| static private BufferCopy ( byte source, int srcOffset, byte dest, int destOffset, int count ) : void | ||
| source | byte | |
| srcOffset | int | |
| dest | byte | |
| destOffset | int | |
| count | int | |
| return | void | |
protected byte[] ReadToByte(byte b, ValidateByteDelegate validator)
{
byte[] dest = null;
if (this._dataCount == 0)
{
this.BufferMoreData();
}
int num = this._dataOffset + this._dataCount;
int srcOffset = this._dataOffset;
int index = srcOffset;
bool flag = false;
while (!flag)
{
bool flag2 = index == num;
flag = !flag2 && (this._dataBuffer[index] == b);
if (((validator != null) && !flag2) && (!flag && !validator(this._dataBuffer[index])))
{
throw new RemotingException(CoreChannel.GetResourceString("Remoting_Http_InvalidDataReceived"));
}
if (flag2 || flag)
{
int count = index - srcOffset;
if (dest == null)
{
dest = new byte[count];
StreamHelper.BufferCopy(this._dataBuffer, srcOffset, dest, 0, count);
}
else
{
int length = dest.Length;
byte[] buffer2 = new byte[length + count];
StreamHelper.BufferCopy(dest, 0, buffer2, 0, length);
StreamHelper.BufferCopy(this._dataBuffer, srcOffset, buffer2, length, count);
dest = buffer2;
}
this._dataOffset += count;
this._dataCount -= count;
if (flag2)
{
this.BufferMoreData();
num = this._dataOffset + this._dataCount;
srcOffset = this._dataOffset;
index = srcOffset;
}
else if (flag)
{
this._dataOffset++;
this._dataCount--;
}
}
else
{
index++;
}
}
return(dest);
}
} // ReadAndMatchFourBytes
public int Read(byte[] buffer, int offset, int count)
{
int totalBytesRead = 0;
byte[] dataBuffer = this.DataBuffer;
// see if we have buffered data
if (_dataCount > 0)
{
// copy minimum of buffered data size and bytes left to read
int readCount = Math.Min(_dataCount, count);
StreamHelper.BufferCopy(dataBuffer, _dataOffset, buffer, offset, readCount);
_dataCount -= readCount;
_dataOffset += readCount;
count -= readCount;
offset += readCount;
totalBytesRead += readCount;
}
// keep reading (whoever is calling this will make sure that they
// don't try to read too much).
while (count > 0)
{
if (count < 256)
{
// if count is less than 256 bytes, I will buffer more data
// because it's not worth making a socket request for less.
BufferMoreData(dataBuffer);
// copy minimum of buffered data size and bytes left to read
int readCount = Math.Min(_dataCount, count);
StreamHelper.BufferCopy(dataBuffer, _dataOffset, buffer, offset, readCount);
_dataCount -= readCount;
_dataOffset += readCount;
count -= readCount;
offset += readCount;
totalBytesRead += readCount;
}
else
{
// just go directly to the socket
// the internal buffer is guaranteed to be empty at this point, so just
// read directly into the array given
int readCount = ReadFromSocket(buffer, offset, count);
count -= readCount;
offset += readCount;
totalBytesRead += readCount;
}
}
return(totalBytesRead);
} // Read
public int Read(byte[] buffer, int offset, int count)
{
int num = 0;
if (this._dataCount > 0)
{
int num2 = Math.Min(this._dataCount, count);
StreamHelper.BufferCopy(this._dataBuffer, this._dataOffset, buffer, offset, num2);
this._dataCount -= num2;
this._dataOffset += num2;
count -= num2;
offset += num2;
num += num2;
}
while (count > 0)
{
if (count < 0x100)
{
this.BufferMoreData();
int num3 = Math.Min(this._dataCount, count);
StreamHelper.BufferCopy(this._dataBuffer, this._dataOffset, buffer, offset, num3);
this._dataCount -= num3;
this._dataOffset += num3;
count -= num3;
offset += num3;
num += num3;
}
else
{
int num4 = this.ReadFromSocket(buffer, offset, count);
count -= num4;
offset += num4;
num += num4;
}
}
return(num);
}
} /// ReadToByte
protected byte[] ReadToByte(byte b, ValidateByteDelegate validator)
{
byte[] readBytes = null;
// start at current position and return byte array consisting of bytes
// up to where we found the byte.
if (_dataCount == 0)
{
BufferMoreData();
}
int dataEnd = _dataOffset + _dataCount; // one byte past last valid byte
int startIndex = _dataOffset; // current position
int endIndex = startIndex; // current index
bool foundByte = false;
bool bufferEnd;
while (!foundByte)
{
InternalRemotingServices.RemotingAssert(endIndex <= dataEnd, "endIndex shouldn't pass dataEnd");
bufferEnd = endIndex == dataEnd;
foundByte = !bufferEnd && (_dataBuffer[endIndex] == b);
// validate character if necessary
if ((validator != null) && !bufferEnd && !foundByte)
{
if (!validator(_dataBuffer[endIndex]))
{
throw new RemotingException(
CoreChannel.GetResourceString(
"Remoting_Http_InvalidDataReceived"));
}
}
// we're at the end of the currently buffered data or we've found our byte
if (bufferEnd || foundByte)
{
// store processed byte in the readBytes array
int count = endIndex - startIndex;
if (readBytes == null)
{
readBytes = new byte[count];
StreamHelper.BufferCopy(_dataBuffer, startIndex, readBytes, 0, count);
}
else
{
int oldSize = readBytes.Length;
byte[] newBytes = new byte[oldSize + count];
StreamHelper.BufferCopy(readBytes, 0, newBytes, 0, oldSize);
StreamHelper.BufferCopy(_dataBuffer, startIndex, newBytes, oldSize, count);
readBytes = newBytes;
}
// update data counters
_dataOffset += count;
_dataCount -= count;
if (bufferEnd)
{
// we still haven't found the byte, so buffer more data
// and keep looking.
BufferMoreData();
// reset indices
dataEnd = _dataOffset + _dataCount; // last valid byte
startIndex = _dataOffset; // current position
endIndex = startIndex; // current index
}
else
if (foundByte)
{
// skip over the byte that we were looking for
_dataOffset += 1;
_dataCount -= 1;
}
}
else
{
// still haven't found character or end of buffer, so advance position
endIndex++;
}
}
return(readBytes);
} // ReadToByte
