static void Main(string[] args)
{
ChunkedMemoryStream cms = new ChunkedMemoryStream();
Debug.Assert(cms.Length == 0);
Debug.Assert(cms.Position == 0);
cms.Position = 0;
byte[] helloworld = Encoding.UTF8.GetBytes("hello world");
cms.Write(helloworld, 0, 3);
cms.Write(helloworld, 3, 3);
cms.Write(helloworld, 6, 5);
Debug.Assert(cms.Length == 11);
Debug.Assert(cms.Position == 11);
cms.Position = 0;
byte[] b = new byte[20];
cms.Read(b, 3, (int)cms.Length);
Debug.Assert(b.Skip(3).Take(11).SequenceEqual(helloworld));
cms.Position = 0;
cms.Write(Encoding.UTF8.GetBytes("seeya"), 0, 5);
Debug.Assert(cms.Length == 11);
Debug.Assert(cms.Position == 5);
cms.Position = 0;
cms.Read(b, 0, (byte)cms.Length);
Debug.Assert(b.Take(11).SequenceEqual(Encoding.UTF8.GetBytes("seeya world")));
Debug.Assert(cms.Length == 11);
Debug.Assert(cms.Position == 11);
cms.Write(Encoding.UTF8.GetBytes(" again"), 0, 6);
Debug.Assert(cms.Length == 17);
Debug.Assert(cms.Position == 17);
cms.Position = 0;
cms.Read(b, 0, (byte)cms.Length);
Debug.Assert(b.Take(17).SequenceEqual(Encoding.UTF8.GetBytes("seeya world again")));
}
public void ChunkedMemoryStream_Write_CanWriteDataToFullInMultipleTimes()
{
var buffers = new[]
{
new byte[10],
new byte[20]
};
var chunkedMemoryStream = new ChunkedMemoryStream(buffers, 0, 30);
// Write the data partially in 2 times
var inBuffer = new byte[10];
for (int i = 0; i < 10; i++)
{
inBuffer[i] = (byte)i;
}
chunkedMemoryStream.Write(inBuffer, 0, 10);
var inBuffer2 = new byte[10];
for (int i = 0; i < 10; i++)
{
inBuffer2[i] = (byte)(i + 10);
}
chunkedMemoryStream.Write(inBuffer2, 0, 10);
var inBuffer3 = new byte[10];
for (int i = 0; i < 10; i++)
{
inBuffer3[i] = (byte)(i + 20);
}
chunkedMemoryStream.Write(inBuffer3, 0, 10);
Assert.AreEqual(30, chunkedMemoryStream.Position);
Assert.AreEqual(30, chunkedMemoryStream.Length);
for (int i = 0; i < 10; i++)
{
Assert.AreEqual(inBuffer[i], buffers[0][i]);
}
for (int i = 0; i < 10; i++)
{
Assert.AreEqual(inBuffer2[i], buffers[1][i]);
}
for (int i = 0; i < 10; i++)
{
Assert.AreEqual(inBuffer3[i], buffers[1][i + 10]);
}
}
static RestService()
{
var hwText = Encoding.UTF8.GetBytes("Hello, World!");
HelloWorld.Write(hwText, 0, hwText.Length);
HelloWorld.Position = 0;
}
public void TestCreateTextDataFromStream()
{
var stream = new ChunkedMemoryStream();
var str = Encoding.ASCII.GetBytes("string");
stream.Write(str, 0, str.Length);
stream.Position = 0L;
var text = ImapData.CreateTextData(stream);
Assert.AreEqual(ImapDataFormat.Text, text.Format);
Assert.AreEqual(6, text.GetTextLength());
Assert.AreEqual(Encoding.ASCII.GetBytes("string"), text.GetTextAsByteArray());
Assert.AreEqual(new ByteString(str), text.GetTextAsByteString());
Assert.AreEqual("string", text.GetTextAsString());
Assert.AreSame(stream, text.GetTextAsStream());
FileAssert.AreEqual(new MemoryStream(str, false), text.GetTextAsStream());
var buffer = new byte[3];
text.CopyText(buffer, 0, buffer.Length);
Assert.AreEqual(str.Slice(0, 3), buffer);
}
public void ChunkedMemoryStream_Write_CanWriteDataPartiallyInOneTime()
{
var buffers = new[]
{
new byte[10],
new byte[20]
};
var chunkedMemoryStream = new ChunkedMemoryStream(buffers, 0, 30);
// Write the data partially in 1 time
var inBuffer = new byte[20];
for (int i = 0; i < 20; i++)
{
inBuffer[i] = (byte)i;
}
chunkedMemoryStream.Write(inBuffer, 0, 20);
Assert.AreEqual(20, chunkedMemoryStream.Position);
Assert.AreEqual(30, chunkedMemoryStream.Length);
for (int i = 0; i < 10; i++)
{
Assert.AreEqual(inBuffer[i], buffers[0][i]);
}
for (int i = 0; i < 10; i++)
{
Assert.AreEqual(inBuffer[10 + i], buffers[1][i]);
}
}
public void Write_100_bytes()
{
byte[] bytes = GetBytes(100);
var stream = new ChunkedMemoryStream();
stream.Write(bytes, 0, bytes.Length);
Assert.AreEqual(100, stream.Length);
}
public void Write_199k_bytes()
{
byte[] bytes = GetBytes(199 * 1024);
var stream = new ChunkedMemoryStream();
stream.Write(bytes, 0, bytes.Length);
}
public void Write_100_bytes()
{
byte[] bytes = GetBytes(100);
var stream = new ChunkedMemoryStream();
stream.Write(bytes, 0, bytes.Length);
Assert.AreEqual(100, stream.Length);
}
public void Write_fixed_buffer_with_offset_and_overflow()
{
var bytes = GetBytes(100);
var stream = new ChunkedMemoryStream(bytes, 10, 9);
var writtenBytes = GetBytes(10).Reverse().ToArray();
stream.Write(writtenBytes, 0, writtenBytes.Length);
}
public void Write_100_bytes_100_times()
{
byte[] bytes = GetBytes(100);
var stream = new ChunkedMemoryStream();
for(int i = 0; i < 100; ++i) {
stream.Write(bytes, 0, bytes.Length);
}
}
public void Write_100_bytes_100_times()
{
byte[] bytes = GetBytes(100);
var stream = new ChunkedMemoryStream();
for (int i = 0; i < 100; ++i)
{
stream.Write(bytes, 0, bytes.Length);
}
}
static RestService()
{
var hwText = Encoding.UTF8.GetBytes("Hello, World!");
HelloWorld.Write(hwText, 0, hwText.Length);
HelloWorld.Position = 0;
for (int i = 0; i < IDs.Length; i++)
{
IDs[i] = i.ToString();
}
}
public static Stream DeserializeStream(BufferedTextReader sr, int nextToken)
{
if (nextToken != '"')
{
throw new SerializationException("Expecting '\"' at position " + JsonSerialization.PositionInStream(sr) + ". Found " + (char)nextToken);
}
nextToken = sr.Read();
if (nextToken == '"')
{
return(new MemoryStream());
}
//TODO: lazy init stream (more lightweight!?)
var res = new ChunkedMemoryStream();
var base64 = sr.LargeTempBuffer;
int i = 1;
base64[0] = (char)nextToken;
int len;
while ((len = sr.ReadUntil(base64, i, '"')) > 0)
{
i += len;
if (i == base64.Length)
{
var bytes = Convert.FromBase64CharArray(base64, 0, base64.Length);
res.Write(bytes, 0, bytes.Length);
i = 0;
}
}
nextToken = sr.Read();
if (i > 0)
{
var bytes = Convert.FromBase64CharArray(base64, 0, i);
res.Write(bytes, 0, bytes.Length);
}
if (nextToken != '"')
{
throw new SerializationException("Expecting '\"' at position " + JsonSerialization.PositionInStream(sr) + ". Found end of stream.");
}
return(res);
}
public ResourceContentBE(string value, MimeType mimeType)
: this(true) {
if(value == null) {
throw new ArgumentNullException("value");
}
if(mimeType == null) {
throw new ArgumentNullException("mimeType");
}
_mimeType = mimeType;
_stream = new ChunkedMemoryStream();
_stream.Write(mimeType.CharSet, value);
_size = (uint)_stream.Length;
}
public void Write_fixed_buffer_with_offset()
{
var bytes = GetBytes(100);
var stream = new ChunkedMemoryStream(bytes, 10, 10);
var writtenBytes = GetBytes(10).Reverse().ToArray();
stream.Write(writtenBytes, 0, writtenBytes.Length);
stream.Position = 0;
var readBytes = new byte[10];
stream.Read(readBytes, 0, readBytes.Length);
Assert.AreEqual(writtenBytes, readBytes);
}
public ResourceContentBE(string value, MimeType mimeType)
: this(true) {
if (value == null)
{
throw new ArgumentNullException("value");
}
if (mimeType == null)
{
throw new ArgumentNullException("mimeType");
}
_mimeType = mimeType;
_stream = new ChunkedMemoryStream();
_stream.Write(mimeType.CharSet, value);
_size = (uint)_stream.Length;
}
public void Write_100_bytes_Read_100_bytes()
{
byte[] bytes = GetBytes(100);
var stream = new ChunkedMemoryStream();
stream.Write(bytes, 0, bytes.Length);
stream.Position = 0;
byte[] buffer = new byte[bytes.Length];
int read = stream.Read(buffer, 0, buffer.Length);
Assert.AreEqual(buffer.Length, read);
Assert.AreEqual(bytes, buffer);
Assert.AreEqual(0, stream.Read(buffer, 0, buffer.Length));
}
public void MemoryStream_WriteToTests_Negative()
{
using var ms2 = new ChunkedMemoryStream(this.allocator);
Assert.Throws <ArgumentNullException>(() => ms2.WriteTo(null));
ms2.Write(new byte[] { 1 }, 0, 1);
var readonlyStream = new MemoryStream(new byte[1028], false);
Assert.Throws <NotSupportedException>(() => ms2.WriteTo(readonlyStream));
readonlyStream.Dispose();
// [] Pass in a closed stream
Assert.Throws <ObjectDisposedException>(() => ms2.WriteTo(readonlyStream));
}
public void Write_64k_bytes_Truncate_17k_Read_64k()
{
byte[] bytes = GetBytes(64 * 1024);
var stream = new ChunkedMemoryStream();
stream.Write(bytes, 0, bytes.Length);
stream.SetLength(17 * 1024);
stream.Position = 0;
byte[] buffer = new byte[bytes.Length];
int read = stream.Read(buffer, 0, buffer.Length);
Assert.AreEqual(17 * 1024, read);
Assert.AreEqual(bytes.Take(17 * 1024).ToArray(), buffer.Take(17 * 1024).ToArray());
Assert.AreEqual(0, stream.Read(buffer, 0, buffer.Length));
}
public void Write_100_bytes_100_times_Read_10000_bytes()
{
byte[] bytes = GetBytes(100);
byte[][] arrays = new byte[100][];
var stream = new ChunkedMemoryStream();
for(int i = 0; i < 100; ++i) {
stream.Write(bytes, 0, bytes.Length);
arrays[i] = bytes;
}
stream.Position = 0;
byte[] buffer = new byte[100 * bytes.Length];
int read = stream.Read(buffer, 0, buffer.Length);
Assert.AreEqual(buffer.Length, read);
Assert.AreEqual(ArrayUtil.Concat(arrays), buffer);
Assert.AreEqual(0, stream.Read(buffer, 0, buffer.Length));
}
public static void MemoryStream_WriteToTests()
{
using (var ms2 = new ChunkedMemoryStream())
{
byte[] bytArrRet;
byte[] bytArr = new byte[] { byte.MinValue, byte.MaxValue, 1, 2, 3, 4, 5, 6, 128, 250 };
// [] Write to FileStream, check the filestream
ms2.Write(bytArr, 0, bytArr.Length);
using (var readonlyStream = new ChunkedMemoryStream())
{
ms2.WriteTo(readonlyStream);
readonlyStream.Flush();
readonlyStream.Position = 0;
bytArrRet = new byte[(int)readonlyStream.Length];
readonlyStream.Read(bytArrRet, 0, (int)readonlyStream.Length);
for (int i = 0; i < bytArr.Length; i++)
{
Assert.Equal(bytArr[i], bytArrRet[i]);
}
}
}
// [] Write to memoryStream, check the memoryStream
using (var ms2 = new ChunkedMemoryStream())
using (var ms3 = new ChunkedMemoryStream())
{
byte[] bytArrRet;
byte[] bytArr = new byte[] { byte.MinValue, byte.MaxValue, 1, 2, 3, 4, 5, 6, 128, 250 };
ms2.Write(bytArr, 0, bytArr.Length);
ms2.WriteTo(ms3);
ms3.Position = 0;
bytArrRet = new byte[(int)ms3.Length];
ms3.Read(bytArrRet, 0, (int)ms3.Length);
for (int i = 0; i < bytArr.Length; i++)
{
Assert.Equal(bytArr[i], bytArrRet[i]);
}
}
}
public void Write_100_bytes_100_times_Read_10000_bytes()
{
byte[] bytes = GetBytes(100);
byte[][] arrays = new byte[100][];
var stream = new ChunkedMemoryStream();
for (int i = 0; i < 100; ++i)
{
stream.Write(bytes, 0, bytes.Length);
arrays[i] = bytes;
}
stream.Position = 0;
byte[] buffer = new byte[100 * bytes.Length];
int read = stream.Read(buffer, 0, buffer.Length);
Assert.AreEqual(buffer.Length, read);
Assert.AreEqual(ArrayUtil.Concat(arrays), buffer);
Assert.AreEqual(0, stream.Read(buffer, 0, buffer.Length));
}
private static bool ReCalculateFileMD5(string path)
{
if (!XLPack.IsFileExist(path))
{
return(false);
}
var position = XLPack.FOpen(path, "r");
long fileSize = XLPack.FSize(position);
const int bufSize = 0x4000;
byte[] buffer = new byte[bufSize];
IntPtr bufPtr = Marshal.UnsafeAddrOfPinnedArrayElement(buffer, 0);
// TODO: Do this without reading the entire file into memory to calculate the MD5
// Maybe try to use the XLPack.DLL's MD5Init, MD5Update and MD5 Finalize functions ?
// Using ChunkedMemoryStream instead of MemoryStream to hopefully avoid outofmemory errors on large files
ChunkedMemoryStream ms = new ChunkedMemoryStream();
long readTotalSize = 0;
while (readTotalSize < fileSize)
{
long readSize = fileSize - readTotalSize;
if (readSize > bufSize)
{
readSize = bufSize;
}
XLPack.FRead(position, bufPtr, readSize);
ms.Write(buffer, 0, (int)readSize); // readSize should never be out of int range, so it's safe to cast it
readTotalSize += readSize;
}
XLPack.FClose(ref position);
ms.Position = 0;
MD5 md5Hash = MD5.Create();
string md5String = GetMd5Hash(md5Hash, ms).Replace("-", "").ToLower();
ms.Dispose();
var res = SetFileMD5(path, md5String);
return(res);
}
public bool Parse(Socket socket, out RouteMatch?match, out RouteHandler route)
{
positionInTmp = 0;
Pipeline = false;
var methodEnd = ReadUntil(socket, Space, 0);
if (methodEnd == -1)
{
match = null;
route = null;
if (!socket.Connected)
{
offsetInOutput = 0;
return(false);
}
else if (positionInTmp == 0)
{
if (offsetInOutput != 0)
{
socket.Send(OutputTemp, offsetInOutput, SocketFlags.None);
offsetInOutput = 0;
socket.Close();
return(false);
}
else
{
return(ReturnError(socket, 408));
}
}
else
{
return(ReturnError(socket, 505));
}
}
HttpMethod = ReadMethod(methodEnd, InputTemp);
var rowEnd = ReadUntil(socket, LF, methodEnd + 1);
if (rowEnd == -1 || rowEnd < 12)
{
match = null;
route = null;
return(ReturnError(socket, 505));
}
RequestHeadersLength = 0;
ResponseHeadersLength = 0;
HttpProtocolVersion = ReadProtocol(rowEnd - 2);
if (HttpProtocolVersion == null)
{
match = null;
route = null;
ReturnError(socket, 505, "Only HTTP/1.1 and HTTP/1.0 supported (partially)", false);
return(false);
}
match = ReadUrl(rowEnd, out route);
if (route == null)
{
var unknownRoute = "Unknown route " + RawUrl + " on method " + HttpMethod;
ReturnError(socket, 404, unknownRoute, false);
return(false);
}
ResponseStatus = HttpStatusCode.OK;
ResponseLength = null;
ResponseContentType = null;
TemplateMatch = null;
ResponseIsJson = false;
ContentTypeResponseIndex = -1;
do
{
var start = rowEnd + 1;
rowEnd = ReadUntil(socket, CR, start);
if (rowEnd == start)
{
break;
}
else if (rowEnd == -1)
{
return(ReturnError(socket, 414));
}
else
{
int i = start;
for (; i < rowEnd; i++)
{
if (InputTemp[i] == ':')
{
break;
}
}
if (i == rowEnd)
{
return(ReturnError(socket, 414));
}
var nameBuf = TmpCharBuf;
for (int x = start; x < i; x++)
{
nameBuf[x - start] = Lower[InputTemp[x]];
}
var name = KeyCache.Get(nameBuf, i - start);
if (InputTemp[i + 1] == 32)
{
i++;
}
for (int x = i + 1; x < rowEnd; x++)
{
nameBuf[x - i - 1] = (char)InputTemp[x];
}
var value = ValueCache.Get(nameBuf, rowEnd - i - 1);
if (RequestHeadersLength == RequestHeaders.Length)
{
var newHeaders = new HeaderPair[RequestHeaders.Length * 2];
Array.Copy(RequestHeaders, newHeaders, RequestHeaders.Length);
RequestHeaders = newHeaders;
}
RequestHeaders[RequestHeadersLength++] = new HeaderPair(name, value);
}
rowEnd++;
} while (positionInTmp <= InputTemp.Length);
rowEnd += 2;
if (HttpMethod == "POST" || HttpMethod == "PUT")
{
int len = 0;
var ct = GetRequestHeader("content-length");
if (ct != null)
{
if (!int.TryParse(ct, out len))
{
return(ReturnError(socket, 411));
}
if (len > Limit)
{
return(ReturnError(socket, 413));
}
}
else
{
return(ReturnError(socket, 411));
}
InputStream.Reset();
var size = totalBytes - rowEnd;
InputStream.Write(InputTemp, rowEnd, size);
len -= size;
var oldTimeout = socket.ReceiveTimeout;
socket.ReceiveTimeout = 10000;
while (len > 0)
{
size = socket.Receive(InputTemp, Math.Min(len, InputTemp.Length), SocketFlags.None);
if (size < 1)
{
return(ReturnError(socket, 408));
}
InputStream.Write(InputTemp, 0, size);
len -= size;
}
socket.ReceiveTimeout = oldTimeout;
InputStream.Position = 0;
rowEnd = totalBytes;
totalBytes = 0;
}
else
{
Pipeline = rowEnd < totalBytes;
if (Pipeline)
{
Buffer.BlockCopy(InputTemp, rowEnd, InputTemp, 0, totalBytes - rowEnd);
totalBytes -= rowEnd;
}
else
{
totalBytes = 0;
}
}
return(true);
}
public static Stream DeserializeStream(BufferedTextReader sr, int nextToken)
{
if (nextToken != '"') throw new SerializationException("Expecting '\"' at position " + JsonSerialization.PositionInStream(sr) + ". Found " + (char)nextToken);
nextToken = sr.Read();
if (nextToken == '"') return new MemoryStream();
//TODO: lazy init stream (more lightweight!?)
var res = new ChunkedMemoryStream();
var base64 = sr.LargeTempBuffer;
int i = 1;
base64[0] = (char)nextToken;
int len;
while ((len = sr.ReadUntil(base64, i, '"')) > 0)
{
i += len;
if (i == base64.Length)
{
var bytes = Convert.FromBase64CharArray(base64, 0, base64.Length);
res.Write(bytes, 0, bytes.Length);
i = 0;
}
}
nextToken = sr.Read();
if (i > 0)
{
var bytes = Convert.FromBase64CharArray(base64, 0, i);
res.Write(bytes, 0, bytes.Length);
}
if (nextToken != '"') throw new SerializationException("Expecting '\"' at position " + JsonSerialization.PositionInStream(sr) + ". Found end of stream.");
return res;
}
public void Write_fixed_buffer_with_offset_and_overflow()
{
var bytes = GetBytes(100);
var stream = new ChunkedMemoryStream(bytes, 10, 9);
var writtenBytes = GetBytes(10).Reverse().ToArray();
stream.Write(writtenBytes, 0, writtenBytes.Length);
}
public void Write_fixed_buffer_with_offset()
{
var bytes = GetBytes(100);
var stream = new ChunkedMemoryStream(bytes, 10, 10);
var writtenBytes = GetBytes(10).Reverse().ToArray();
stream.Write(writtenBytes, 0, writtenBytes.Length);
stream.Position = 0;
var readBytes = new byte[10];
stream.Read(readBytes, 0, readBytes.Length);
Assert.AreEqual(writtenBytes, readBytes);
}
public void Write_64k_bytes_Truncate_17k_Read_64k()
{
byte[] bytes = GetBytes(64 * 1024);
var stream = new ChunkedMemoryStream();
stream.Write(bytes, 0, bytes.Length);
stream.SetLength(17 * 1024);
stream.Position = 0;
byte[] buffer = new byte[bytes.Length];
int read = stream.Read(buffer, 0, buffer.Length);
Assert.AreEqual(17 * 1024, read);
Assert.AreEqual(bytes.Take(17 * 1024).ToArray(), buffer.Take(17 * 1024).ToArray());
Assert.AreEqual(0, stream.Read(buffer, 0, buffer.Length));
}
public void Write_64k_bytes_Read_64k_bytes()
{
byte[] bytes = GetBytes(64 * 1024);
var stream = new ChunkedMemoryStream();
stream.Write(bytes, 0, bytes.Length);
stream.Position = 0;
byte[] buffer = new byte[bytes.Length];
int read = stream.Read(buffer, 0, buffer.Length);
Assert.AreEqual(buffer.Length, read);
Assert.AreEqual(bytes, buffer);
Assert.AreEqual(0, stream.Read(buffer, 0, buffer.Length));
}
public void Write_64k_bytes()
{
byte[] bytes = GetBytes(64 * 1024);
var stream = new ChunkedMemoryStream();
stream.Write(bytes, 0, bytes.Length);
}
public void TestSeekInternalStateNotChanged2()
{
using (var stream = new ChunkedMemoryStream()) {
Assert.AreEqual(0L, stream.Position);
Assert.AreEqual(0L, stream.Length);
stream.Position = 0L;
Assert.AreEqual(0L, stream.Position);
Assert.AreEqual(0L, stream.Length);
stream.Write(new byte[] {0x00, 0x01, 0x02, 0x03}, 0, 4);
Assert.AreEqual(4L, stream.Position);
Assert.AreEqual(4L, stream.Length);
}
}
public void TestWrite()
{
using (var stream = new ChunkedMemoryStream(8)) {
Assert.AreEqual(0L, stream.Position);
Assert.AreEqual(0L, stream.Length);
stream.Write(new byte[] {0x00}, 0, 1);
Assert.AreEqual(1L, stream.Position);
Assert.AreEqual(1L, stream.Length);
stream.Write(new byte[] {0x01, 0x02, 0x03}, 0, 3);
Assert.AreEqual(4L, stream.Position);
Assert.AreEqual(4L, stream.Length);
stream.Write(new byte[] {0x04, 0x05, 0x06, 0x07}, 0, 4);
Assert.AreEqual(8L, stream.Position);
Assert.AreEqual(8L, stream.Length);
stream.Write(new byte[] {0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e}, 0, 7);
Assert.AreEqual(15L, stream.Position);
Assert.AreEqual(15L, stream.Length);
stream.Write(new byte[] {0x0f, 0x10}, 0, 2);
Assert.AreEqual(17L, stream.Position);
Assert.AreEqual(17L, stream.Length);
stream.Write(new byte[] {0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f}, 0, 15);
Assert.AreEqual(32L, stream.Position);
Assert.AreEqual(32L, stream.Length);
Assert.AreEqual(new byte[] {
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
}, stream.ToArray());
}
}
public void Write_100_bytes_100_times_Read_100_bytes_100_times()
{
byte[] bytes = GetBytes(100);
var stream = new ChunkedMemoryStream();
for(int i = 0; i < 100; ++i) {
stream.Write(bytes, 0, bytes.Length);
}
stream.Position = 0;
byte[] buffer = new byte[bytes.Length];
for(int i = 0; i < 100; ++i) {
int read = stream.Read(buffer, 0, buffer.Length);
Assert.AreEqual(buffer.Length, read);
Assert.AreEqual(bytes, buffer);
}
Assert.AreEqual(0, stream.Read(buffer, 0, buffer.Length));
}
public bool Parse(Socket socket)
{
positionInTmp = 0;
Pipeline = false;
var methodEnd = ReadUntil(socket, Space, 0);
if (methodEnd == -1)
{
return(ReturnError(socket, 505));
}
HttpMethod = ReadMethod(methodEnd, InputTemp);
var rowEnd = ReadUntil(socket, LF, methodEnd + 1);
if (rowEnd == -1 || rowEnd < 12)
{
return(ReturnError(socket, 505));
}
RequestHeadersLength = 0;
ResponseHeadersLength = 0;
HttpProtocolVersion = ReadProtocol(rowEnd - 2);
if (HttpProtocolVersion == null)
{
ReturnError(socket, 505, "Only HTTP/1.1 and HTTP/1.0 supported (partially)", false);
return(false);
}
ReadUrl(rowEnd);
int askSign = RawUrl.IndexOf('?');
AbsolutePath = askSign == -1 ? RawUrl : RawUrl.Substring(0, askSign);
ResponseStatus = HttpStatusCode.OK;
ResponseLength = null;
ResponseContentType = null;
TemplateMatch = null;
ResponseIsJson = false;
ContentTypeResponseIndex = -1;
do
{
var start = rowEnd + 1;
rowEnd = ReadUntil(socket, CR, start);
if (rowEnd == start)
{
break;
}
else if (rowEnd == -1)
{
return(ReturnError(socket, 414));
}
else
{
int i = start;
for (; i < rowEnd; i++)
{
if (InputTemp[i] == ':')
{
break;
}
}
if (i == rowEnd)
{
return(ReturnError(socket, 414));
}
var nameBuf = TmpCharBuf;
for (int x = start; x < i; x++)
{
nameBuf[x - start] = Lower[InputTemp[x]];
}
string name = new string(nameBuf, 0, i - start);
if (InputTemp[i + 1] == 32)
{
i++;
}
for (int x = i + 1; x < rowEnd; x++)
{
nameBuf[x - i - 1] = (char)InputTemp[x];
}
string value = new string(nameBuf, 0, rowEnd - i - 1);
if (RequestHeadersLength == RequestHeaders.Length)
{
var newHeaders = new HeaderPair[RequestHeaders.Length * 2];
Array.Copy(RequestHeaders, newHeaders, RequestHeaders.Length);
RequestHeaders = newHeaders;
}
RequestHeaders[RequestHeadersLength++] = new HeaderPair(name, value);
}
rowEnd++;
} while (positionInTmp <= InputTemp.Length);
rowEnd += 2;
if (HttpMethod == "POST" || HttpMethod == "PUT")
{
int len = 0;
var ct = GetRequestHeader("content-length");
if (ct != null)
{
if (!int.TryParse(ct, out len))
{
return(ReturnError(socket, 411));
}
if (len > Limit)
{
return(ReturnError(socket, 413));
}
}
else
{
return(ReturnError(socket, 411));
}
InputStream.Reset();
var size = totalBytes - rowEnd;
InputStream.Write(InputTemp, rowEnd, size);
len -= size;
while (len > 0)
{
size = socket.Receive(InputTemp, Math.Min(len, InputTemp.Length), SocketFlags.None);
if (size < 1)
{
return(ReturnError(socket, 408));
}
InputStream.Write(InputTemp, 0, size);
len -= size;
}
InputStream.Position = 0;
rowEnd = totalBytes;
totalBytes = 0;
}
else
{
Pipeline = rowEnd < totalBytes;
if (Pipeline)
{
Buffer.BlockCopy(InputTemp, rowEnd, InputTemp, 0, totalBytes - rowEnd);
totalBytes -= rowEnd;
}
else
{
totalBytes = 0;
}
}
return(true);
}