| public ReceiveRecord ( Stream record ) : byte[] | ||
| record | Stream | |
| return | byte[] | |
// read encrypted data until we have enough to decrypt (at least) one
// record and return are the records (may be more than one) we have
private void InternalReadCallback_inner(InternalAsyncResult internalResult, byte[] recbuf, object[] state,
bool didRead, int n)
{
if (disposed)
{
return;
}
try
{
var dataToReturn = false;
var pos = recordStream.Position;
recordStream.Position = 0;
byte[] record = null;
// don't try to decode record unless we have at least 5 bytes
// i.e. type (1), protocol (2) and length (2)
if (recordStream.Length >= 5)
{
record = protocol.ReceiveRecord(recordStream);
}
// a record of 0 length is valid (and there may be more record after it)
while (record != null)
{
// we probably received more stuff after the record, and we must keep it!
var remainder = recordStream.Length - recordStream.Position;
byte[] outofrecord = null;
if (remainder > 0)
{
outofrecord = new byte[remainder];
recordStream.Read(outofrecord, 0, outofrecord.Length);
}
lock (read)
{
var position = inputBuffer.Position;
if (record.Length > 0)
{
// Write new data to the inputBuffer
inputBuffer.Seek(0, SeekOrigin.End);
inputBuffer.Write(record, 0, record.Length);
// Restore buffer position
inputBuffer.Seek(position, SeekOrigin.Begin);
dataToReturn = true;
}
}
recordStream.SetLength(0);
record = null;
if (remainder > 0)
{
recordStream.Write(outofrecord, 0, outofrecord.Length);
// type (1), protocol (2) and length (2)
if (recordStream.Length >= 5)
{
// try to see if another record is available
recordStream.Position = 0;
record = protocol.ReceiveRecord(recordStream);
if (record == null)
{
pos = recordStream.Length;
}
}
else
{
pos = remainder;
}
}
else
{
pos = 0;
}
}
if (!dataToReturn && (!didRead || n > 0))
{
if (context.ReceivedConnectionEnd)
{
internalResult.SetComplete(0);
}
else
{
// there is no record to return to caller and (possibly) more data waiting
// so continue reading from network (and appending to stream)
recordStream.Position = recordStream.Length;
innerStream.BeginRead(recbuf, 0, recbuf.Length,
InternalReadCallback, state);
}
}
else
{
// we have record(s) to return -or- no more available to read from network
// reset position for further reading
recordStream.Position = pos;
var bytesRead = 0;
lock (read)
{
bytesRead = inputBuffer.Read(internalResult.Buffer, internalResult.Offset,
internalResult.Count);
}
internalResult.SetComplete(bytesRead);
}
}
catch (Exception ex)
{
internalResult.SetComplete(ex);
}
}
private void InternalReadCallback(IAsyncResult result)
{
if (!disposed)
{
object[] array = (object[])result.AsyncState;
byte[] array2 = (byte[])array[0];
InternalAsyncResult internalAsyncResult = (InternalAsyncResult)array[1];
try
{
int num = innerStream.EndRead(result);
if (num > 0)
{
recordStream.Write(array2, 0, num);
bool flag = false;
long position = recordStream.Position;
recordStream.Position = 0L;
byte[] array3 = null;
if (recordStream.Length >= 5)
{
array3 = protocol.ReceiveRecord(recordStream);
}
while (array3 != null)
{
long num2 = recordStream.Length - recordStream.Position;
byte[] array4 = null;
if (num2 > 0)
{
array4 = new byte[num2];
recordStream.Read(array4, 0, array4.Length);
}
lock (read)
{
long position2 = inputBuffer.Position;
if (array3.Length > 0)
{
inputBuffer.Seek(0L, SeekOrigin.End);
inputBuffer.Write(array3, 0, array3.Length);
inputBuffer.Seek(position2, SeekOrigin.Begin);
flag = true;
}
}
recordStream.SetLength(0L);
array3 = null;
if (num2 > 0)
{
recordStream.Write(array4, 0, array4.Length);
if (recordStream.Length >= 5)
{
recordStream.Position = 0L;
array3 = protocol.ReceiveRecord(recordStream);
if (array3 == null)
{
position = recordStream.Length;
}
}
else
{
position = num2;
}
}
else
{
position = 0L;
}
}
if (!flag && num > 0)
{
if (context.ReceivedConnectionEnd)
{
internalAsyncResult.SetComplete(0);
}
else
{
recordStream.Position = recordStream.Length;
innerStream.BeginRead(array2, 0, array2.Length, InternalReadCallback, array);
}
}
else
{
recordStream.Position = position;
int complete = 0;
lock (read)
{
complete = inputBuffer.Read(internalAsyncResult.Buffer, internalAsyncResult.Offset, internalAsyncResult.Count);
}
internalAsyncResult.SetComplete(complete);
}
}
else
{
internalAsyncResult.SetComplete(0);
}
}
catch (Exception complete2)
{
internalAsyncResult.SetComplete(complete2);
}
}
}
