Mikescher/CarotDav_decompile
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
2d8b6914b8
CarotDav_decompile/Rei.Net.HttpServer/MyHttpServerConnection.cs

1665 lines
52 KiB
C#
Raw Normal View History

Disassembled CarotDav v1.14.7 with dotPeek 2017.2
2017-10-06 17:20:58 +02:00
// Decompiled with JetBrains decompiler
// Type: Rei.Net.HttpServer.MyHttpServerConnection
// Assembly: Rei.Net.HttpServer, Version=1.13.2.9297, Culture=neutral, PublicKeyToken=null
// MVID: 6174F8E9-E7BA-46AD-8F2E-196645884F28
// Assembly location: F:\Eigene Dateien\Dropbox\portable Collection\Progs\CarotDAV\Rei.Net.HttpServer.dll
using Microsoft.VisualBasic.CompilerServices;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading;
namespace Rei.Net.HttpServer
{
[DebuggerDisplay("{toString}")]
public class MyHttpServerConnection : IDisposable
{
private static string[] HeaderOrder = new string[46]
{
"Cache-Control",
"Connection",
"Date",
"Pragma",
"Trailer",
"Transfer-Encoding",
"Upgrade",
"Via",
"Warning",
"Accept-Charset",
"Accept-Encoding",
"Accept-Language",
"Authorization",
"Expect",
"From",
"Host",
"If-Match",
"If-Modified-Since",
"If-None-Match",
"If-Range",
"If-Unmodified-Since",
"Max-Forwards",
"Proxy-Authorization",
"Range",
"Referer",
"TE",
"User-Agent",
"Accept-Ranges",
"Age",
"ETag",
"Location",
"Proxy-Authenticate",
"Retry-After",
"Server",
"Vary",
"WWW-Authenticate",
"Allow",
"Content-Encoding",
"Content-Language",
"Content-Length",
"Content-Location",
"Content-MD5",
"Content-Range",
"Content-Type",
"Expires",
"Last-Modified"
};
private object _Tag;
private object _syncobject;
private LineReadableSocketStream _st;
private bool _needclose;
private bool _isconnected;
private MyEndPoint _remoteep;
private int _requesttimeout;
private int _responsetimeout;
private MyHttpServerConnection.StreamStateType _req_state;
private bool _req_closed;
private string _req_method;
private MyHttpServerConnection.BodyLengthType _req_bodylengthtype;
private long _req_contentlength;
private string _req_currentheader;
private long _req_currentposition;
private int _req_currentchunksize;
private bool _req_expect100continue;
private MyHttpServerConnection.StreamStateType _res_state;
private bool _res_closed;
private MyHttpServerConnection.BodyLengthType _res_bodylengthtype;
private long _res_contentlength;
private bool _res_sentexpect100continue;
private long _res_currentposition;
private string _res_headers;
private bool disposedValue;
public MyHttpServerConnection(Socket basesocket)
{
this.disposedValue = false;
this._syncobject = RuntimeHelpers.GetObjectValue(new object());
this._remoteep = new MyEndPoint((IPEndPoint) basesocket.RemoteEndPoint);
this._st = new LineReadableSocketStream(basesocket);
this._needclose = false;
this._isconnected = true;
this._requesttimeout = 300000;
this._responsetimeout = 300000;
this._req_state = MyHttpServerConnection.StreamStateType.Initial;
this._req_closed = false;
this._res_state = MyHttpServerConnection.StreamStateType.Initial;
this._res_closed = false;
}
public LineReadableSocketStream BaseStream
{
get
{
return this._st;
}
set
{
this._st = value;
}
}
public int ReadTimeout
{
get
{
return this._st.ReadTimeout;
}
set
{
this._st.ReadTimeout = value;
}
}
public int WriteTimeout
{
get
{
return this._st.WriteTimeout;
}
set
{
this._st.WriteTimeout = value;
}
}
public int RequestTimeout
{
get
{
return this._requesttimeout;
}
set
{
this._requesttimeout = value;
}
}
public int ResponseTimeout
{
get
{
return this._responsetimeout;
}
set
{
this._responsetimeout = value;
}
}
public bool IsConnected
{
get
{
return this._isconnected;
}
}
public MyEndPoint RemoteEp
{
get
{
return this._remoteep;
}
}
public object Tag
{
get
{
return this._Tag;
}
set
{
this._Tag = RuntimeHelpers.GetObjectValue(value);
}
}
protected virtual void Dispose(bool disposing)
{
if (!this.disposedValue && disposing && this._st != null)
{
this._st.Close();
this._st = (LineReadableSocketStream) null;
}
this.disposedValue = true;
}
public void Close()
{
this.Dispose(true);
GC.SuppressFinalize((object) this);
}
public MyHttpServerRequest ReceiveRequest()
{
return this.ReceiveRequest(this.RequestTimeout);
}
public MyHttpServerRequest ReceiveRequest(int timeout)
{
IAsyncResult request = this.BeginReceiveRequest((AsyncCallback) null, (object) null);
if (!request.CompletedSynchronously && !request.AsyncWaitHandle.WaitOne(timeout, false))
throw new IOException("Timeout");
return this.EndReceiveRequest(request);
}
public IAsyncResult BeginReceiveRequest(AsyncCallback callback, object asyncstate)
{
object syncobject = this._syncobject;
ObjectFlowControl.CheckForSyncLockOnValueType(syncobject);
Monitor.Enter(syncobject);
try
{
if (this._req_state != MyHttpServerConnection.StreamStateType.Initial)
throw new InvalidOperationException();
this._req_state = MyHttpServerConnection.StreamStateType.Changing;
}
finally
{
Monitor.Exit(syncobject);
}
MyAsyncResult myAsyncResult = new MyAsyncResult(callback, RuntimeHelpers.GetObjectValue(asyncstate));
this._st.BeginReadLine(new AsyncCallback(this.OnRead_RequestLine), (object) myAsyncResult);
return (IAsyncResult) myAsyncResult;
}
private void OnRead_RequestLine(IAsyncResult asyncresult)
{
MyAsyncResult asyncState = (MyAsyncResult) asyncresult.AsyncState;
MyHttpServerRequest req = new MyHttpServerRequest();
asyncState.ReturnValue = (object) req;
if (!asyncresult.CompletedSynchronously)
asyncState.SetAsync();
try
{
req._requestline = this._st.EndReadLine(asyncresult);
if (req._requestline == null)
asyncState.Complete();
else if (Operators.CompareString(req._requestline, "", false) == 0)
{
this._st.BeginReadLine(new AsyncCallback(this.OnRead_RequestLine), (object) asyncState);
}
else
{
string[] strArray = req._requestline.Split(new char[1]
{
' '
}, 3, StringSplitOptions.RemoveEmptyEntries);
if (strArray.Length < 2)
{
this.RequestStreamClose();
throw new MyHttpServerBadRequestException(req);
}
if (strArray[2].Length != 8)
{
this.RequestStreamClose();
throw new MyHttpServerBadRequestException(req);
}
if (string.Compare(strArray[2].Substring(0, 5), "HTTP/", StringComparison.InvariantCultureIgnoreCase) != 0)
{
this.RequestStreamClose();
throw new MyHttpServerBadRequestException(req);
}
float.Parse(strArray[2].Substring(5, 3));
req._method = strArray[0];
req._rawuri = strArray[1];
req._version = strArray[2];
this._req_method = req._method;
this._req_currentheader = (string) null;
this._st.BeginReadLine(new AsyncCallback(this.OnRead_Header), RuntimeHelpers.GetObjectValue(asyncresult.AsyncState));
}
}
catch (Exception ex1)
{
ProjectData.SetProjectError(ex1);
Exception ex2 = ex1;
asyncState.Complete(ex2);
ProjectData.ClearProjectError();
}
}
private void OnRead_Header(IAsyncResult asyncresult)
{
MyAsyncResult asyncState = (MyAsyncResult) asyncresult.AsyncState;
MyHttpServerRequest returnValue = (MyHttpServerRequest) asyncState.ReturnValue;
if (!asyncresult.CompletedSynchronously)
asyncState.SetAsync();
try
{
string Left = this._st.EndReadLine(asyncresult);
if (Left == null)
throw new MyHttpServerConnectionClosedException("Client Closed");
if (this._req_currentheader == null)
{
this._req_currentheader = Left;
this._st.BeginReadLine(new AsyncCallback(this.OnRead_Header), RuntimeHelpers.GetObjectValue(asyncresult.AsyncState));
return;
}
if (Left.Length > 0 && (Operators.CompareString(Conversions.ToString(Left[0]), " ", false) == 0 || Operators.CompareString(Conversions.ToString(Left[0]), "\t", false) == 0))
{
this._req_currentheader = this._req_currentheader + Left;
this._st.BeginReadLine(new AsyncCallback(this.OnRead_Header), RuntimeHelpers.GetObjectValue(asyncresult.AsyncState));
return;
}
int length = this._req_currentheader.IndexOf(":");
if (length < 0)
{
returnValue._requestheaders.Add(this._req_currentheader, "");
}
else
{
string name = this._req_currentheader.Substring(0, length).Trim();
string str = this._req_currentheader.Substring(checked (length + 1)).Trim();
returnValue._requestheaders.Add(name, str);
}
if (Operators.CompareString(Left, "", false) != 0)
{
this._req_currentheader = Left;
this._st.BeginReadLine(new AsyncCallback(this.OnRead_Header), RuntimeHelpers.GetObjectValue(asyncresult.AsyncState));
return;
}
}
catch (Exception ex1)
{
ProjectData.SetProjectError(ex1);
Exception ex2 = ex1;
asyncState.Complete(ex2);
ProjectData.ClearProjectError();
return;
}
asyncState.Complete();
}
public MyHttpServerRequest EndReceiveRequest(IAsyncResult asyncresult)
{
MyAsyncResult myAsyncResult = (MyAsyncResult) asyncresult;
myAsyncResult.AsyncEnd();
MyHttpServerRequest returnValue = (MyHttpServerRequest) myAsyncResult.ReturnValue;
if (returnValue._requestline == null)
return (MyHttpServerRequest) null;
string requestheader1 = returnValue._requestheaders["Content-Length"];
if (requestheader1 != null)
{
if (!long.TryParse(requestheader1, out returnValue._contentlength))
returnValue._contentlength = 0L;
}
else
returnValue._contentlength = 0L;
this._req_contentlength = returnValue._contentlength;
string requestheader2 = returnValue._requestheaders["Transfer-Encoding"];
bool flag;
if (requestheader2 != null)
{
if (string.Compare(requestheader2.Trim(), "chunked", StringComparison.InvariantCultureIgnoreCase) != 0)
{
this.RequestStreamClose();
throw new MyHttpServerBadRequestException(returnValue);
}
flag = true;
}
else
flag = false;
string[] values1 = returnValue._requestheaders.GetValues("Connection");
if (values1 != null)
{
int num1 = 0;
int num2 = checked (values1.Length - 1);
int index = num1;
while (index <= num2)
{
if (string.Compare(values1[index], "Close", StringComparison.InvariantCultureIgnoreCase) == 0)
this._needclose = true;
checked { ++index; }
}
}
string[] values2 = returnValue._requestheaders.GetValues("Expect");
returnValue._expect100continue = false;
if (values2 != null)
{
int num1 = 0;
int num2 = checked (values2.Length - 1);
int index = num1;
while (index <= num2)
{
if (string.Compare(values2[index], "100-continue", StringComparison.InvariantCultureIgnoreCase) == 0)
returnValue._expect100continue = true;
checked { ++index; }
}
}
this._req_expect100continue = returnValue._expect100continue;
this._res_sentexpect100continue = false;
returnValue._host = returnValue._requestheaders["Host"];
if (returnValue._host == null)
{
this.RequestStreamClose();
throw new MyHttpServerBadRequestException(returnValue);
}
if (Operators.CompareString(returnValue._rawuri, "*", false) != 0 && !returnValue._rawuri.StartsWith("http://"))
{
if (returnValue._rawuri.StartsWith("/"))
{
if (!Uri.TryCreate("http://" + returnValue._host + returnValue._rawuri, UriKind.Absolute, out returnValue._requesturi))
throw new MyHttpServerBadRequestException(returnValue);
}
else
{
if (Operators.CompareString(returnValue.Method.ToUpperInvariant(), "CONNECT", false) != 0)
throw new MyHttpServerBadRequestException(returnValue);
if (!Uri.TryCreate("http://" + returnValue._rawuri, UriKind.Absolute, out returnValue._requesturi))
throw new MyHttpServerBadRequestException(returnValue);
if (returnValue._requesturi.Segments.Length != 1)
{
this.RequestStreamClose();
throw new MyHttpServerBadRequestException(returnValue);
}
}
}
if (flag)
this._req_bodylengthtype = MyHttpServerConnection.BodyLengthType.Chunk;
else if (returnValue._contentlength >= 0L)
{
this._req_bodylengthtype = MyHttpServerConnection.BodyLengthType.ContentLength;
}
else
{
this.RequestStreamClose();
throw new MyHttpServerBadRequestException(returnValue);
}
returnValue._reqstream = (Stream) new MyHttpServerConnection.RequestStream(this);
object syncobject = this._syncobject;
ObjectFlowControl.CheckForSyncLockOnValueType(syncobject);
Monitor.Enter(syncobject);
try
{
this._req_state = MyHttpServerConnection.StreamStateType.HeaderFinished;
if (returnValue._contentlength == 0L)
this._req_state = MyHttpServerConnection.StreamStateType.BodyFinished;
}
finally
{
Monitor.Exit(syncobject);
}
return returnValue;
}
private long RequestStreamLength()
{
object syncobject = this._syncobject;
ObjectFlowControl.CheckForSyncLockOnValueType(syncobject);
Monitor.Enter(syncobject);
try
{
if (this._req_state < MyHttpServerConnection.StreamStateType.HeaderFinished)
throw new InvalidOperationException();
}
finally
{
Monitor.Exit(syncobject);
}
return this._req_contentlength;
}
private long RequestStreamPosition()
{
return this._req_currentposition;
}
private IAsyncResult RequestStreamBeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
if (count < 0)
throw new ArgumentOutOfRangeException();
object syncobject = this._syncobject;
ObjectFlowControl.CheckForSyncLockOnValueType(syncobject);
Monitor.Enter(syncobject);
bool flag;
try
{
flag = this._req_state == MyHttpServerConnection.StreamStateType.BodyFinished;
if (!flag)
{
if (this._req_state != MyHttpServerConnection.StreamStateType.HeaderFinished)
throw new InvalidOperationException();
this._req_state = MyHttpServerConnection.StreamStateType.Changing;
}
if (this._req_expect100continue)
{
if (!this._res_sentexpect100continue)
{
if (!flag)
{
if (this._res_state != MyHttpServerConnection.StreamStateType.Initial)
throw new InvalidOperationException();
this._res_state = MyHttpServerConnection.StreamStateType.Changing;
}
}
}
}
finally
{
Monitor.Exit(syncobject);
}
MyAsyncResult mar = new MyAsyncResult(callback, RuntimeHelpers.GetObjectValue(state));
if (flag)
{
mar.ReturnValue = (object) 0;
mar.Complete();
return (IAsyncResult) mar;
}
mar.Tag = (object) new MyHttpServerConnection.StreamReadWriteParameter()
{
buffer = buffer,
offset = offset,
count = count
};
if (this._req_expect100continue && !this._res_sentexpect100continue)
{
byte[] bytes = Encoding.UTF8.GetBytes("HTTP/1.1 100 Continue\r\n\r\n");
this._st.BeginWrite(bytes, 0, bytes.Length, new AsyncCallback(this.OnRead_SendExpect100Continue), (object) mar);
}
else
this.InnerRequestStreamBeginRead2(mar);
return (IAsyncResult) mar;
}
private void OnRead_SendExpect100Continue(IAsyncResult asyncresult)
{
MyAsyncResult asyncState = (MyAsyncResult) asyncresult.AsyncState;
MyHttpServerConnection.StreamReadWriteParameter tag = (MyHttpServerConnection.StreamReadWriteParameter) asyncState.Tag;
if (!asyncresult.CompletedSynchronously)
asyncState.SetAsync();
try
{
this._st.EndWrite(asyncresult);
this._res_sentexpect100continue = true;
object syncobject = this._syncobject;
ObjectFlowControl.CheckForSyncLockOnValueType(syncobject);
Monitor.Enter(syncobject);
try
{
this._res_state = MyHttpServerConnection.StreamStateType.Initial;
}
finally
{
Monitor.Exit(syncobject);
}
this.InnerRequestStreamBeginRead2(asyncState);
}
catch (Exception ex1)
{
ProjectData.SetProjectError(ex1);
Exception ex2 = ex1;
asyncState.Complete(ex2);
ProjectData.ClearProjectError();
}
}
private void InnerRequestStreamBeginRead2(MyAsyncResult mar)
{
MyHttpServerConnection.StreamReadWriteParameter tag = (MyHttpServerConnection.StreamReadWriteParameter) mar.Tag;
switch (this._req_bodylengthtype)
{
case MyHttpServerConnection.BodyLengthType.Chunk:
if (this._req_currentchunksize == 0)
{
this._st.BeginReadLine(new AsyncCallback(this.OnRead_Body_ChunkSize), (object) mar);
break;
}
int count1 = tag.count;
if (count1 > this._req_currentchunksize)
count1 = this._req_currentchunksize;
this._st.BeginRead(tag.buffer, tag.offset, count1, new AsyncCallback(this.OnRead_Body_ChunkData), (object) mar);
break;
case MyHttpServerConnection.BodyLengthType.ContentLength:
int count2 = tag.count;
if (checked (this._req_currentposition + (long) count2) > this._req_contentlength)
count2 = checked ((int) (this._req_contentlength - this._req_currentposition));
this._st.BeginRead(tag.buffer, tag.offset, count2, new AsyncCallback(this.OnRead_Body_ContentLength), (object) mar);
break;
default:
this.RequestStreamClose();
throw new MyHttpServerBadRequestException((MyHttpServerRequest) null);
}
}
private void OnRead_Body_ContentLength(IAsyncResult asyncresult)
{
MyAsyncResult asyncState = (MyAsyncResult) asyncresult.AsyncState;
if (!asyncresult.CompletedSynchronously)
asyncState.SetAsync();
try
{
int num = this._st.EndRead(asyncresult);
if (num == 0)
throw new MyHttpServerConnectionClosedException("Client Closed");
this._req_currentposition = checked (this._req_currentposition + (long) num);
asyncState.ReturnValue = (object) num;
}
catch (Exception ex1)
{
ProjectData.SetProjectError(ex1);
Exception ex2 = ex1;
asyncState.Complete(ex2);
ProjectData.ClearProjectError();
return;
}
asyncState.Complete();
}
private void OnRead_Body_ChunkSize(IAsyncResult asyncresult)
{
MyAsyncResult asyncState = (MyAsyncResult) asyncresult.AsyncState;
MyHttpServerConnection.StreamReadWriteParameter tag = (MyHttpServerConnection.StreamReadWriteParameter) asyncState.Tag;
if (!asyncresult.CompletedSynchronously)
asyncState.SetAsync();
try
{
string str = this._st.EndReadLine(asyncresult);
if (str == null)
throw new MyHttpServerConnectionClosedException("Client Closed");
int length = str.IndexOf(";");
if (length >= 0)
str = str.Substring(0, length);
if (!int.TryParse(str.Trim(), NumberStyles.AllowHexSpecifier, (IFormatProvider) null, out this._req_currentchunksize))
{
this.RequestStreamClose();
throw new MyHttpServerBadRequestException((MyHttpServerRequest) null);
}
if (this._req_currentchunksize == 0)
{
this._st.BeginReadLine(new AsyncCallback(this.OnRead_Body_ChunkTrailer), (object) asyncState);
}
else
{
int count = tag.count;
if (count > this._req_currentchunksize)
count = this._req_currentchunksize;
this._st.BeginRead(tag.buffer, tag.offset, count, new AsyncCallback(this.OnRead_Body_ChunkData), (object) asyncState);
}
}
catch (Exception ex1)
{
ProjectData.SetProjectError(ex1);
Exception ex2 = ex1;
asyncState.Complete(ex2);
ProjectData.ClearProjectError();
}
}
private void OnRead_Body_ChunkData(IAsyncResult asyncresult)
{
MyAsyncResult asyncState = (MyAsyncResult) asyncresult.AsyncState;
if (!asyncresult.CompletedSynchronously)
asyncState.SetAsync();
try
{
int num = this._st.EndRead(asyncresult);
if (num == 0)
{
this.RequestStreamClose();
throw new MyHttpServerBadRequestException((MyHttpServerRequest) null);
}
this._req_currentchunksize = checked (this._req_currentchunksize - num);
this._req_currentposition = checked (this._req_currentposition + (long) num);
asyncState.ReturnValue = (object) num;
this._st.BeginReadLine(new AsyncCallback(this.OnRead_Body_ChunkDataEnd), (object) asyncState);
}
catch (Exception ex1)
{
ProjectData.SetProjectError(ex1);
Exception ex2 = ex1;
asyncState.Complete(ex2);
ProjectData.ClearProjectError();
}
}
private void OnRead_Body_ChunkDataEnd(IAsyncResult asyncresult)
{
MyAsyncResult asyncState = (MyAsyncResult) asyncresult.AsyncState;
if (!asyncresult.CompletedSynchronously)
asyncState.SetAsync();
try
{
this._st.EndReadLine((IAsyncResult) asyncState);
}
catch (Exception ex1)
{
ProjectData.SetProjectError(ex1);
Exception ex2 = ex1;
asyncState.Complete(ex2);
ProjectData.ClearProjectError();
return;
}
asyncState.Complete();
}
private void OnRead_Body_ChunkTrailer(IAsyncResult asyncresult)
{
MyAsyncResult asyncState = (MyAsyncResult) asyncresult.AsyncState;
if (!asyncresult.CompletedSynchronously)
asyncState.SetAsync();
try
{
if (this._st.EndReadLine((IAsyncResult) asyncState).Length == 0)
{
object syncobject = this._syncobject;
ObjectFlowControl.CheckForSyncLockOnValueType(syncobject);
Monitor.Enter(syncobject);
try
{
this._req_state = MyHttpServerConnection.StreamStateType.BodyFinished;
}
finally
{
Monitor.Exit(syncobject);
}
asyncState.ReturnValue = (object) 0;
asyncState.Complete();
}
else
this._st.BeginReadLine(new AsyncCallback(this.OnRead_Body_ChunkTrailer), (object) asyncState);
}
catch (Exception ex1)
{
ProjectData.SetProjectError(ex1);
Exception ex2 = ex1;
asyncState.Complete(ex2);
ProjectData.ClearProjectError();
return;
}
asyncState.Complete();
}
private int RequestStreamEndRead(IAsyncResult asyncResult)
{
MyAsyncResult myAsyncResult = (MyAsyncResult) asyncResult;
myAsyncResult.AsyncEnd();
int returnValue = (int) myAsyncResult.ReturnValue;
if (returnValue == 0 && this._req_state != MyHttpServerConnection.StreamStateType.BodyFinished)
throw new MyHttpServerBadRequestException((MyHttpServerRequest) null);
object syncobject = this._syncobject;
ObjectFlowControl.CheckForSyncLockOnValueType(syncobject);
Monitor.Enter(syncobject);
try
{
this._req_state = MyHttpServerConnection.StreamStateType.HeaderFinished;
if (this._req_currentposition >= this._req_contentlength)
this._req_state = MyHttpServerConnection.StreamStateType.BodyFinished;
}
finally
{
Monitor.Exit(syncobject);
}
return returnValue;
}
public Stream SendResponse(MyHttpServerResponse response)
{
return this.SendResponse(response, this.ResponseTimeout);
}
public Stream SendResponse(MyHttpServerResponse response, int timeout)
{
IAsyncResult asyncresult = this.BeginSendResponse(response, (AsyncCallback) null, (object) null);
if (!asyncresult.CompletedSynchronously && !asyncresult.AsyncWaitHandle.WaitOne(timeout, false))
throw new IOException("Timeout");
return this.EndSendResponse(asyncresult);
}
public IAsyncResult BeginSendResponse(MyHttpServerResponse response, AsyncCallback callback, object asyncstate)
{
object syncobject = this._syncobject;
ObjectFlowControl.CheckForSyncLockOnValueType(syncobject);
Monitor.Enter(syncobject);
try
{
if (this._res_state != MyHttpServerConnection.StreamStateType.Initial)
throw new InvalidOperationException();
this._res_state = MyHttpServerConnection.StreamStateType.Changing;
}
finally
{
Monitor.Exit(syncobject);
}
MyAsyncResult myAsyncResult = new MyAsyncResult(callback, RuntimeHelpers.GetObjectValue(asyncstate));
NameValueCollection nameValueCollection = new NameValueCollection(response._responseheaders);
if (Operators.CompareString(this._req_method, "HEAD", false) == 0)
{
this._res_bodylengthtype = MyHttpServerConnection.BodyLengthType.NoBody;
this._res_contentlength = response._contentlength;
}
else if (response._statuscode == 204 || response._statuscode == 304)
{
this._res_bodylengthtype = MyHttpServerConnection.BodyLengthType.ContentLength;
this._res_contentlength = 0L;
}
else if (response._sendchunked)
{
this._res_bodylengthtype = MyHttpServerConnection.BodyLengthType.Chunk;
this._res_contentlength = -1L;
}
else
{
if (response._contentlength < 0L)
throw new Exception();
this._res_bodylengthtype = MyHttpServerConnection.BodyLengthType.ContentLength;
this._res_contentlength = response._contentlength;
}
if (string.IsNullOrEmpty(response._statusdesc))
{
switch (response.StatusCode)
{
case 200:
response._statusdesc = "OK";
break;
case 201:
response._statusdesc = "Created";
break;
case 202:
response._statusdesc = "Accepted";
break;
case 203:
response._statusdesc = "Non-Authoritative Information";
break;
case 204:
response._statusdesc = "No Content";
break;
case 205:
response._statusdesc = "Reset Content";
break;
case 206:
response._statusdesc = "Partial Content";
break;
case 207:
response._statusdesc = "Multi-Status";
break;
case 300:
response._statusdesc = "Multiple Choices";
break;
case 301:
response._statusdesc = "Moved Permanently";
break;
case 302:
response._statusdesc = "Found";
break;
case 303:
response._statusdesc = "See Other";
break;
case 304:
response._statusdesc = "Not Modified";
break;
case 305:
response._statusdesc = "Use Proxy";
break;
case 306:
response._statusdesc = "(Unused)";
break;
case 307:
response._statusdesc = "Temporary Redirect";
break;
case 400:
response._statusdesc = "Bad Request";
break;
case 401:
response._statusdesc = "Unauthorized";
break;
case 402:
response._statusdesc = "Payment Required";
break;
case 403:
response._statusdesc = "Forbidden";
break;
case 404:
response._statusdesc = "Not Found";
break;
case 405:
response._statusdesc = "Method Not Allowed";
break;
case 406:
response._statusdesc = "Not Acceptable";
break;
case 407:
response._statusdesc = "Proxy Authentication Required";
break;
case 408:
response._statusdesc = "Request Timeout";
break;
case 409:
response._statusdesc = "Conflict";
break;
case 410:
response._statusdesc = "Gone";
break;
case 411:
response._statusdesc = "Length Required";
break;
case 412:
response._statusdesc = "Precondition Failed";
break;
case 413:
response._statusdesc = "Request Entity Too Large";
break;
case 414:
response._statusdesc = "Request-URI Too Long";
break;
case 415:
response._statusdesc = "Unsupported Media Type";
break;
case 416:
response._statusdesc = "Requested Range Not Satisfiable";
break;
case 417:
response._statusdesc = "Expectation Failed";
break;
case 422:
response._statusdesc = "Unprocessable Entity";
break;
case 423:
response._statusdesc = "Locked";
break;
case 424:
response._statusdesc = "Failed Dependency";
break;
case 500:
response._statusdesc = "Internal Server Error";
break;
case 501:
response._statusdesc = "Not Implemented";
break;
case 502:
response._statusdesc = "Bad Gateway";
break;
case 503:
response._statusdesc = "Service Unavailable";
break;
case 504:
response._statusdesc = "Gateway Timeout";
break;
case 505:
response._statusdesc = "HTTP Version Not Supported";
break;
case 506:
response._statusdesc = "Variant Also Negotiates";
break;
case 507:
response._statusdesc = "Insufficient Storage";
break;
default:
response._statusdesc = "";
break;
}
}
string str1 = string.Join(" ", new string[3]
{
"HTTP/1.1",
response._statuscode.ToString(),
response._statusdesc
});
if (this._needclose)
nameValueCollection.Add("Connection", "Close");
string[] values1 = nameValueCollection.GetValues("Connection");
if (values1 != null)
{
int num1 = 0;
int num2 = checked (values1.Length - 1);
int index = num1;
while (index <= num2)
{
if (string.Compare(values1[index], "Close", StringComparison.InvariantCultureIgnoreCase) == 0)
this._needclose = true;
checked { ++index; }
}
}
if (nameValueCollection["Transfer-Encoding"] != null && Operators.CompareString(nameValueCollection["Transfer-Encoding"], "chunked", false) != 0)
throw new NotImplementedException();
if (response._sendchunked)
nameValueCollection["Transfer-Encoding"] = "chunked";
if (nameValueCollection["Date"] == null)
nameValueCollection.Add("Date", DateTime.Now.ToUniversalTime().ToString("r"));
if (this._res_bodylengthtype == MyHttpServerConnection.BodyLengthType.Chunk)
nameValueCollection.Remove("Content-Length");
else
nameValueCollection["Content-Length"] = this._res_contentlength.ToString();
List<string> stringList = new List<string>();
stringList.Add(str1);
string[] headerOrder = MyHttpServerConnection.HeaderOrder;
int index1 = 0;
while (index1 < headerOrder.Length)
{
string name = headerOrder[index1];
string str2 = nameValueCollection.Get(name);
if (str2 != null)
{
stringList.Add(name + ": " + str2.Trim());
nameValueCollection.Remove(name);
}
checked { ++index1; }
}
try
{
foreach (object key in nameValueCollection.Keys)
{
string str2 = Conversions.ToString(key);
string str3 = nameValueCollection.Get(str2);
if (string.Compare(str2, "Set-Cookie", StringComparison.InvariantCultureIgnoreCase) == 0)
{
string[] values2 = nameValueCollection.GetValues(str2);
int index2 = 0;
while (index2 < values2.Length)
{
string str4 = values2[index2];
stringList.Add(str2 + ": " + str4.Trim());
checked { ++index2; }
}
}
else
stringList.Add(str2 + ": " + str3.Trim());
}
}
finally
{
IEnumerator enumerator;
if (enumerator is IDisposable)
(enumerator as IDisposable).Dispose();
}
stringList.Add("");
stringList.Add("");
this._res_headers = string.Join("\r\n", stringList.ToArray());
byte[] bytes = Encoding.UTF8.GetBytes(this._res_headers);
this._st.BeginWrite(bytes, 0, bytes.Length, new AsyncCallback(this.OnSend_Header), (object) myAsyncResult);
return (IAsyncResult) myAsyncResult;
}
private void OnSend_Header(IAsyncResult asyncresult)
{
MyAsyncResult asyncState = (MyAsyncResult) asyncresult.AsyncState;
if (!asyncresult.CompletedSynchronously)
asyncState.SetAsync();
try
{
this._st.EndWrite(asyncresult);
}
catch (Exception ex1)
{
ProjectData.SetProjectError(ex1);
Exception ex2 = ex1;
asyncState.Complete(ex2);
ProjectData.ClearProjectError();
return;
}
asyncState.Complete();
}
public Stream EndSendResponse(IAsyncResult asyncresult)
{
MyAsyncResult myAsyncResult = (MyAsyncResult) asyncresult;
myAsyncResult.AsyncEnd();
myAsyncResult.ReturnValue = (object) new MyHttpServerConnection.ResponseStream(this);
object syncobject = this._syncobject;
ObjectFlowControl.CheckForSyncLockOnValueType(syncobject);
Monitor.Enter(syncobject);
try
{
this._res_state = MyHttpServerConnection.StreamStateType.HeaderFinished;
if (this._res_bodylengthtype != MyHttpServerConnection.BodyLengthType.NoBody)
{
if (this._res_bodylengthtype == MyHttpServerConnection.BodyLengthType.ContentLength)
{
if (this._res_contentlength != 0L)
goto label_6;
}
else
goto label_6;
}
this._res_state = MyHttpServerConnection.StreamStateType.BodyFinished;
}
finally
{
Monitor.Exit(syncobject);
}
label_6:
return (Stream) myAsyncResult.ReturnValue;
}
private long ResponseStreamLength()
{
object syncobject = this._syncobject;
ObjectFlowControl.CheckForSyncLockOnValueType(syncobject);
Monitor.Enter(syncobject);
try
{
if (this._res_state < MyHttpServerConnection.StreamStateType.HeaderFinished)
throw new InvalidOperationException();
}
finally
{
Monitor.Exit(syncobject);
}
return this._res_contentlength;
}
private long ResponseStreamPosition()
{
return this._res_currentposition;
}
private IAsyncResult ResponseStreamBeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
if (count < 0)
throw new ArgumentOutOfRangeException();
object syncobject = this._syncobject;
ObjectFlowControl.CheckForSyncLockOnValueType(syncobject);
Monitor.Enter(syncobject);
try
{
if (this._res_state == MyHttpServerConnection.StreamStateType.BodyFinished)
throw new InvalidOperationException("message body is finished");
if (this._res_state != MyHttpServerConnection.StreamStateType.HeaderFinished)
throw new InvalidOperationException();
this._res_state = MyHttpServerConnection.StreamStateType.Changing;
}
finally
{
Monitor.Exit(syncobject);
}
MyAsyncResult myAsyncResult = new MyAsyncResult(callback, RuntimeHelpers.GetObjectValue(state));
MyHttpServerConnection.StreamReadWriteParameter readWriteParameter = new MyHttpServerConnection.StreamReadWriteParameter();
readWriteParameter.buffer = buffer;
readWriteParameter.offset = offset;
readWriteParameter.count = count;
myAsyncResult.Tag = (object) readWriteParameter;
switch (this._res_bodylengthtype)
{
case MyHttpServerConnection.BodyLengthType.NoBody:
myAsyncResult.Complete();
return (IAsyncResult) myAsyncResult;
case MyHttpServerConnection.BodyLengthType.Chunk:
if (readWriteParameter.count == 0)
{
myAsyncResult.Complete();
return (IAsyncResult) myAsyncResult;
}
byte[] bytes = Encoding.UTF8.GetBytes(readWriteParameter.count.ToString("x") + "\r\n");
this._st.BeginWrite(bytes, 0, bytes.Length, new AsyncCallback(this.OnSend_Body_Chunk_Size), (object) myAsyncResult);
break;
case MyHttpServerConnection.BodyLengthType.ContentLength:
if (checked ((long) readWriteParameter.count + this._res_currentposition) > this._res_contentlength)
throw new IOException("Content length is not match");
this._st.BeginWrite(readWriteParameter.buffer, readWriteParameter.offset, readWriteParameter.count, new AsyncCallback(this.OnSend_Body_ContentLength), (object) myAsyncResult);
break;
default:
throw new Exception();
}
return (IAsyncResult) myAsyncResult;
}
private void OnSend_Body_Chunk_Size(IAsyncResult asyncresult)
{
MyAsyncResult asyncState = (MyAsyncResult) asyncresult.AsyncState;
MyHttpServerConnection.StreamReadWriteParameter tag = (MyHttpServerConnection.StreamReadWriteParameter) asyncState.Tag;
if (!asyncresult.CompletedSynchronously)
asyncState.SetAsync();
try
{
this._st.EndWrite(asyncresult);
this._st.BeginWrite(tag.buffer, tag.offset, tag.count, new AsyncCallback(this.OnSend_Body_Chunk_Data), (object) asyncState);
}
catch (Exception ex1)
{
ProjectData.SetProjectError(ex1);
Exception ex2 = ex1;
asyncState.Complete(ex2);
ProjectData.ClearProjectError();
}
}
private void OnSend_Body_Chunk_Data(IAsyncResult asyncresult)
{
MyAsyncResult asyncState = (MyAsyncResult) asyncresult.AsyncState;
MyHttpServerConnection.StreamReadWriteParameter tag = (MyHttpServerConnection.StreamReadWriteParameter) asyncState.Tag;
if (!asyncresult.CompletedSynchronously)
asyncState.SetAsync();
try
{
this._st.EndWrite(asyncresult);
this._res_currentposition = checked (this._res_currentposition + (long) tag.count);
byte[] buffer = new byte[2]{ (byte) 13, (byte) 10 };
this._st.BeginWrite(buffer, 0, buffer.Length, new AsyncCallback(this.OnSend_Body_Chunk_Data_End), (object) asyncState);
}
catch (Exception ex1)
{
ProjectData.SetProjectError(ex1);
Exception ex2 = ex1;
asyncState.Complete(ex2);
ProjectData.ClearProjectError();
}
}
private void OnSend_Body_Chunk_Data_End(IAsyncResult asyncresult)
{
MyAsyncResult asyncState = (MyAsyncResult) asyncresult.AsyncState;
MyHttpServerConnection.StreamReadWriteParameter tag = (MyHttpServerConnection.StreamReadWriteParameter) asyncState.Tag;
if (!asyncresult.CompletedSynchronously)
asyncState.SetAsync();
try
{
this._st.EndWrite(asyncresult);
object syncobject = this._syncobject;
ObjectFlowControl.CheckForSyncLockOnValueType(syncobject);
Monitor.Enter(syncobject);
try
{
this._res_state = MyHttpServerConnection.StreamStateType.HeaderFinished;
}
finally
{
Monitor.Exit(syncobject);
}
}
catch (Exception ex1)
{
ProjectData.SetProjectError(ex1);
Exception ex2 = ex1;
asyncState.Complete(ex2);
ProjectData.ClearProjectError();
return;
}
asyncState.Complete();
}
private void OnSend_Body_ContentLength(IAsyncResult asyncresult)
{
MyAsyncResult asyncState = (MyAsyncResult) asyncresult.AsyncState;
MyHttpServerConnection.StreamReadWriteParameter tag = (MyHttpServerConnection.StreamReadWriteParameter) asyncState.Tag;
if (!asyncresult.CompletedSynchronously)
asyncState.SetAsync();
try
{
this._st.EndWrite(asyncresult);
this._res_currentposition = checked (this._res_currentposition + (long) tag.count);
object syncobject = this._syncobject;
ObjectFlowControl.CheckForSyncLockOnValueType(syncobject);
Monitor.Enter(syncobject);
try
{
if (this._res_currentposition == this._res_contentlength)
this._res_state = MyHttpServerConnection.StreamStateType.BodyFinished;
else if (this._res_currentposition > this._res_contentlength)
asyncState.Complete(new Exception());
else
this._res_state = MyHttpServerConnection.StreamStateType.HeaderFinished;
}
finally
{
Monitor.Exit(syncobject);
}
}
catch (Exception ex1)
{
ProjectData.SetProjectError(ex1);
Exception ex2 = ex1;
asyncState.Complete(ex2);
ProjectData.ClearProjectError();
return;
}
asyncState.Complete();
}
private void ResponseStreamEndWrite(IAsyncResult asyncResult)
{
((MyAsyncResult) asyncResult).AsyncEnd();
}
internal void RequestStreamClose()
{
this._req_closed = true;
if (!this._res_closed)
return;
this.CloseSeries();
}
private void ResponseStreamClose()
{
object syncobject = this._syncobject;
ObjectFlowControl.CheckForSyncLockOnValueType(syncobject);
Monitor.Enter(syncobject);
try
{
if (this._res_state == MyHttpServerConnection.StreamStateType.HeaderFinished && this._res_bodylengthtype == MyHttpServerConnection.BodyLengthType.Chunk)
{
this._res_state = MyHttpServerConnection.StreamStateType.Changing;
byte[] bytes = Encoding.UTF8.GetBytes("0\r\n\r\n");
this._st.EndWrite(this._st.BeginWrite(bytes, 0, bytes.Length, (AsyncCallback) null, (object) null));
this._res_state = MyHttpServerConnection.StreamStateType.BodyFinished;
}
else if (this._res_bodylengthtype == MyHttpServerConnection.BodyLengthType.ContentLength)
{
if (this._res_state != MyHttpServerConnection.StreamStateType.BodyFinished)
throw new Exception();
}
}
finally
{
Monitor.Exit(syncobject);
}
this._res_closed = true;
if (!this._req_closed)
return;
this.CloseSeries();
}
private void CloseSeries()
{
if (!this._res_closed || !this._req_closed)
return;
this._needclose = this._needclose | this._req_state != MyHttpServerConnection.StreamStateType.BodyFinished;
this._needclose = this._needclose | this._res_state != MyHttpServerConnection.StreamStateType.BodyFinished;
if (this._needclose)
{
this._st.Close();
this._st = (LineReadableSocketStream) null;
this._isconnected = false;
}
else
{
object syncobject = this._syncobject;
ObjectFlowControl.CheckForSyncLockOnValueType(syncobject);
Monitor.Enter(syncobject);
try
{
this._res_currentposition = 0L;
this._req_currentposition = 0L;
this._req_currentchunksize = 0;
this._req_closed = false;
this._res_closed = false;
this._req_state = MyHttpServerConnection.StreamStateType.Initial;
this._res_state = MyHttpServerConnection.StreamStateType.Initial;
}
finally
{
Monitor.Exit(syncobject);
}
}
}
public override string ToString()
{
string str = base.ToString();
if (!this.IsConnected)
return str + "\r\nDicsonnected";
return str + "\r\n" + this._remoteep.ToString() + "\r\n" + this._req_state.ToString();
}
private enum BodyLengthType
{
Unknown,
NoBody,
Chunk,
ContentLength,
Connection,
}
private enum StreamStateType
{
Changing,
Initial,
HeaderFinished,
BodyFinished,
}
private class StreamReadWriteParameter
{
public byte[] buffer;
public int offset;
public int count;
[DebuggerNonUserCode]
public StreamReadWriteParameter()
{
}
}
private class RequestStream : Stream
{
private MyHttpServerConnection _owner;
public RequestStream(MyHttpServerConnection owner)
{
this._owner = owner;
}
public override void Close()
{
if (this._owner != null)
this._owner.RequestStreamClose();
this._owner = (MyHttpServerConnection) null;
base.Close();
}
public override bool CanRead
{
get
{
return true;
}
}
public override bool CanSeek
{
get
{
return false;
}
}
public override bool CanWrite
{
get
{
return false;
}
}
public override void Flush()
{
throw new NotImplementedException();
}
public override long Seek(long offset, SeekOrigin origin)
{
throw new NotImplementedException();
}
public override void SetLength(long value)
{
throw new NotImplementedException();
}
public override void Write(byte[] buffer, int offset, int count)
{
throw new NotImplementedException();
}
public override long Length
{
get
{
if (this._owner == null)
throw new ObjectDisposedException(this.ToString());
return this._owner.RequestStreamLength();
}
}
public override long Position
{
get
{
if (this._owner == null)
throw new ObjectDisposedException(this.ToString());
return this._owner.RequestStreamPosition();
}
set
{
throw new NotImplementedException();
}
}
public override int Read(byte[] buffer, int offset, int count)
{
IAsyncResult asyncResult = this._owner.RequestStreamBeginRead(buffer, offset, count, (AsyncCallback) null, (object) null);
if (!asyncResult.CompletedSynchronously && !asyncResult.AsyncWaitHandle.WaitOne(this._owner.ReadTimeout, false))
throw new IOException("Timeout");
return this._owner.RequestStreamEndRead(asyncResult);
}
public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
return this._owner.RequestStreamBeginRead(buffer, offset, count, callback, RuntimeHelpers.GetObjectValue(state));
}
public override int EndRead(IAsyncResult asyncResult)
{
return this._owner.RequestStreamEndRead(asyncResult);
}
public override int ReadTimeout
{
get
{
return this._owner.ReadTimeout;
}
set
{
this._owner.ReadTimeout = value;
}
}
public override int WriteTimeout
{
get
{
return this._owner.WriteTimeout;
}
set
{
this._owner.WriteTimeout = value;
}
}
}
private class ResponseStream : Stream
{
private MyHttpServerConnection _owner;
public ResponseStream(MyHttpServerConnection owner)
{
this._owner = owner;
}
public override void Close()
{
if (this._owner != null)
this._owner.ResponseStreamClose();
this._owner = (MyHttpServerConnection) null;
base.Close();
}
public override bool CanRead
{
get
{
return false;
}
}
public override bool CanSeek
{
get
{
return false;
}
}
public override bool CanWrite
{
get
{
return true;
}
}
public override void Flush()
{
}
public override long Seek(long offset, SeekOrigin origin)
{
throw new NotImplementedException();
}
public override void SetLength(long value)
{
throw new NotImplementedException();
}
public override long Length
{
get
{
if (this._owner == null)
throw new ObjectDisposedException(this.ToString());
return this._owner.ResponseStreamLength();
}
}
public override long Position
{
get
{
if (this._owner == null)
throw new ObjectDisposedException(this.ToString());
return this._owner.ResponseStreamPosition();
}
set
{
throw new NotImplementedException();
}
}
public override int Read(byte[] buffer, int offset, int count)
{
throw new NotImplementedException();
}
public override void Write(byte[] buffer, int offset, int count)
{
IAsyncResult asyncResult = this._owner.ResponseStreamBeginWrite(buffer, offset, count, (AsyncCallback) null, (object) null);
if (!asyncResult.CompletedSynchronously && !asyncResult.AsyncWaitHandle.WaitOne(this._owner.WriteTimeout, false))
throw new IOException("Timeout");
this._owner.ResponseStreamEndWrite(asyncResult);
}
public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
return this._owner.ResponseStreamBeginWrite(buffer, offset, count, callback, RuntimeHelpers.GetObjectValue(state));
}
public override void EndWrite(IAsyncResult asyncResult)
{
this._owner.ResponseStreamEndWrite(asyncResult);
}
public override int ReadTimeout
{
get
{
return this._owner.ReadTimeout;
}
set
{
this._owner.ReadTimeout = value;
}
}
public override int WriteTimeout
{
get
{
return this._owner.WriteTimeout;
}
set
{
this._owner.WriteTimeout = value;
}
}
}
}
}
Reference in New Issue Copy Permalink