425 lines
13 KiB
C#
425 lines
13 KiB
C#
// Decompiled with JetBrains decompiler
|
|
// Type: Rei.Net.HttpServer.LineReadableSocketStream
|
|
// 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.Diagnostics;
|
|
using System.IO;
|
|
using System.Net.Sockets;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Text;
|
|
using System.Threading;
|
|
|
|
namespace Rei.Net.HttpServer
|
|
{
|
|
public class LineReadableSocketStream : Stream
|
|
{
|
|
private Socket _soc;
|
|
private long _readbytes;
|
|
private long _writebytes;
|
|
private bool _shutdownreceive;
|
|
private bool _shutdownsend;
|
|
private int _receive_bufcount;
|
|
private byte[] _receive_buf;
|
|
private int _readtimeout;
|
|
private int _writetimeout;
|
|
private bool disposedValue;
|
|
|
|
public LineReadableSocketStream(Socket basesocket)
|
|
{
|
|
this._shutdownreceive = false;
|
|
this._shutdownsend = false;
|
|
this._readtimeout = 10000;
|
|
this._writetimeout = 10000;
|
|
this.disposedValue = false;
|
|
if (basesocket == null)
|
|
throw new ArgumentNullException();
|
|
this._soc = basesocket;
|
|
this._receive_buf = new byte[65536];
|
|
}
|
|
|
|
public void Shutdown(SocketShutdown how)
|
|
{
|
|
if (this._soc == null)
|
|
throw new ObjectDisposedException(this.ToString());
|
|
this._soc.Shutdown(how);
|
|
if (how == SocketShutdown.Both)
|
|
{
|
|
this._shutdownreceive = true;
|
|
this._shutdownsend = true;
|
|
}
|
|
else if (how == SocketShutdown.Receive)
|
|
{
|
|
this._shutdownreceive = true;
|
|
}
|
|
else
|
|
{
|
|
if (how != SocketShutdown.Send)
|
|
return;
|
|
this._shutdownsend = true;
|
|
}
|
|
}
|
|
|
|
public override bool CanSeek
|
|
{
|
|
get
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
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
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
}
|
|
|
|
public override long Position
|
|
{
|
|
get
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
set
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
}
|
|
|
|
public long ReadBytes
|
|
{
|
|
get
|
|
{
|
|
return this._readbytes;
|
|
}
|
|
}
|
|
|
|
public override bool CanRead
|
|
{
|
|
get
|
|
{
|
|
return !this._shutdownreceive;
|
|
}
|
|
}
|
|
|
|
public override int ReadTimeout
|
|
{
|
|
get
|
|
{
|
|
return this._readtimeout;
|
|
}
|
|
set
|
|
{
|
|
this._readtimeout = value;
|
|
}
|
|
}
|
|
|
|
public override int Read(byte[] buffer, int offset, int count)
|
|
{
|
|
IAsyncResult asyncresult = this.BeginRead(buffer, offset, count, (AsyncCallback) null, (object) null);
|
|
if (!asyncresult.AsyncWaitHandle.WaitOne(this.ReadTimeout, false))
|
|
throw new IOException();
|
|
return this.EndRead(asyncresult);
|
|
}
|
|
|
|
public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object asyncstate)
|
|
{
|
|
if (this._soc == null)
|
|
throw new ObjectDisposedException(this.ToString());
|
|
if (count < 0)
|
|
throw new ArgumentOutOfRangeException();
|
|
int num = this._receive_bufcount;
|
|
if (num > count)
|
|
num = count;
|
|
Array.Copy((Array) this._receive_buf, 0, (Array) buffer, offset, num);
|
|
this._receive_bufcount = checked (this._receive_bufcount - num);
|
|
Array.Copy((Array) this._receive_buf, num, (Array) this._receive_buf, 0, this._receive_bufcount);
|
|
MyAsyncResult myAsyncResult = new MyAsyncResult(callback, RuntimeHelpers.GetObjectValue(asyncstate));
|
|
myAsyncResult.ReturnValue = (object) num;
|
|
if (count == num)
|
|
myAsyncResult.Complete((Exception) null);
|
|
else
|
|
this._soc.BeginReceive(buffer, checked (offset + num), checked (count - num), SocketFlags.None, new AsyncCallback(this.OnReceive), (object) myAsyncResult);
|
|
return (IAsyncResult) myAsyncResult;
|
|
}
|
|
|
|
private void OnReceive(IAsyncResult asyncresult)
|
|
{
|
|
MyAsyncResult asyncState = (MyAsyncResult) asyncresult.AsyncState;
|
|
if (!asyncresult.CompletedSynchronously)
|
|
asyncState.SetAsync();
|
|
int num;
|
|
try
|
|
{
|
|
num = this._soc.EndReceive(asyncresult);
|
|
}
|
|
catch (Exception ex1)
|
|
{
|
|
ProjectData.SetProjectError(ex1);
|
|
Exception ex2 = ex1;
|
|
asyncState.Complete(ex2);
|
|
ProjectData.ClearProjectError();
|
|
return;
|
|
}
|
|
Interlocked.Add(ref this._readbytes, (long) num);
|
|
asyncState.ReturnValue = (object) checked ((int) asyncState.ReturnValue + num);
|
|
asyncState.Complete();
|
|
}
|
|
|
|
public override int EndRead(IAsyncResult asyncresult)
|
|
{
|
|
MyAsyncResult myAsyncResult = asyncresult as MyAsyncResult;
|
|
myAsyncResult.AsyncEnd();
|
|
return (int) myAsyncResult.ReturnValue;
|
|
}
|
|
|
|
public string ReadLine()
|
|
{
|
|
IAsyncResult asyncresult = this.BeginReadLine((AsyncCallback) null, (object) null);
|
|
if (!asyncresult.AsyncWaitHandle.WaitOne(this.ReadTimeout, false))
|
|
throw new IOException();
|
|
return this.EndReadLine(asyncresult);
|
|
}
|
|
|
|
public IAsyncResult BeginReadLine(AsyncCallback callback, object asyncstate)
|
|
{
|
|
if (this._soc == null)
|
|
throw new ObjectDisposedException(this.ToString());
|
|
MyAsyncResult myAsyncResult = new MyAsyncResult(callback, RuntimeHelpers.GetObjectValue(asyncstate));
|
|
int num1 = 0;
|
|
int num2 = checked (this._receive_bufcount - 1);
|
|
int index = num1;
|
|
while (index <= num2)
|
|
{
|
|
if ((int) this._receive_buf[index] == 10)
|
|
{
|
|
byte[] numArray = index <= 0 || (int) this._receive_buf[checked (index - 1)] != 13 ? new byte[checked (index - 1 + 1)] : new byte[checked (index - 2 + 1)];
|
|
Array.Copy((Array) this._receive_buf, 0, (Array) numArray, 0, numArray.Length);
|
|
this._receive_bufcount = checked (this._receive_bufcount - index + 1);
|
|
Array.Copy((Array) this._receive_buf, checked (index + 1), (Array) this._receive_buf, 0, this._receive_bufcount);
|
|
myAsyncResult.ReturnValue = (object) numArray;
|
|
myAsyncResult.Complete();
|
|
return (IAsyncResult) myAsyncResult;
|
|
}
|
|
checked { ++index; }
|
|
}
|
|
if (checked (this._receive_buf.Length - this._receive_bufcount) < 1024)
|
|
this._receive_buf = (byte[]) Utils.CopyArray((Array) this._receive_buf, (Array) new byte[checked (this._receive_buf.Length * 2 - 1 + 1)]);
|
|
this._soc.BeginReceive(this._receive_buf, this._receive_bufcount, checked (this._receive_buf.Length - this._receive_bufcount), SocketFlags.None, new AsyncCallback(this.OnReceiveToBuffer), (object) myAsyncResult);
|
|
return (IAsyncResult) myAsyncResult;
|
|
}
|
|
|
|
private void OnReceiveToBuffer(IAsyncResult asyncresult)
|
|
{
|
|
MyAsyncResult asyncState = (MyAsyncResult) asyncresult.AsyncState;
|
|
if (!asyncresult.CompletedSynchronously)
|
|
asyncState.SetAsync();
|
|
int num1;
|
|
try
|
|
{
|
|
num1 = this._soc.EndReceive(asyncresult);
|
|
}
|
|
catch (Exception ex1)
|
|
{
|
|
ProjectData.SetProjectError(ex1);
|
|
Exception ex2 = ex1;
|
|
asyncState.Complete(ex2);
|
|
ProjectData.ClearProjectError();
|
|
return;
|
|
}
|
|
if (num1 == 0)
|
|
{
|
|
asyncState.ReturnValue = (object) null;
|
|
asyncState.Complete();
|
|
}
|
|
else
|
|
{
|
|
Interlocked.Add(ref this._readbytes, (long) num1);
|
|
this._receive_bufcount = checked (this._receive_bufcount + num1);
|
|
int num2 = 0;
|
|
int num3 = checked (this._receive_bufcount - 1);
|
|
int index = num2;
|
|
while (index <= num3)
|
|
{
|
|
if ((int) this._receive_buf[index] == 10)
|
|
{
|
|
byte[] numArray = index <= 0 || (int) this._receive_buf[checked (index - 1)] != 13 ? new byte[checked (index - 1 + 1)] : new byte[checked (index - 2 + 1)];
|
|
Array.Copy((Array) this._receive_buf, 0, (Array) numArray, 0, numArray.Length);
|
|
this._receive_bufcount = checked (this._receive_bufcount - index + 1);
|
|
Array.Copy((Array) this._receive_buf, checked (index + 1), (Array) this._receive_buf, 0, this._receive_bufcount);
|
|
asyncState.ReturnValue = (object) numArray;
|
|
asyncState.Complete();
|
|
return;
|
|
}
|
|
checked { ++index; }
|
|
}
|
|
if (checked (this._receive_buf.Length - this._receive_bufcount) < 1024)
|
|
this._receive_buf = (byte[]) Utils.CopyArray((Array) this._receive_buf, (Array) new byte[checked (this._receive_buf.Length * 2 - 1 + 1)]);
|
|
this._soc.BeginReceive(this._receive_buf, this._receive_bufcount, checked (this._receive_buf.Length - this._receive_bufcount), SocketFlags.None, new AsyncCallback(this.OnReceiveToBuffer), (object) asyncState);
|
|
}
|
|
}
|
|
|
|
public string EndReadLine(IAsyncResult asyncresult)
|
|
{
|
|
MyAsyncResult myAsyncResult = (MyAsyncResult) asyncresult;
|
|
myAsyncResult.AsyncEnd();
|
|
if (myAsyncResult.ReturnValue == null)
|
|
return (string) null;
|
|
return Encoding.UTF8.GetString((byte[]) myAsyncResult.ReturnValue);
|
|
}
|
|
|
|
public long WriteBytes
|
|
{
|
|
get
|
|
{
|
|
return this._writebytes;
|
|
}
|
|
}
|
|
|
|
public override bool CanWrite
|
|
{
|
|
get
|
|
{
|
|
return !this._shutdownsend;
|
|
}
|
|
}
|
|
|
|
public override int WriteTimeout
|
|
{
|
|
get
|
|
{
|
|
return this._writetimeout;
|
|
}
|
|
set
|
|
{
|
|
this._writetimeout = value;
|
|
}
|
|
}
|
|
|
|
public override void Write(byte[] buffer, int offset, int count)
|
|
{
|
|
IAsyncResult asyncResult = this.BeginWrite(buffer, offset, count, (AsyncCallback) null, (object) null);
|
|
if (!asyncResult.AsyncWaitHandle.WaitOne(this.WriteTimeout, false))
|
|
throw new IOException();
|
|
this.EndWrite(asyncResult);
|
|
}
|
|
|
|
public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
|
|
{
|
|
if (this._soc == null)
|
|
throw new ObjectDisposedException(this.ToString());
|
|
MyAsyncResult myAsyncResult = new MyAsyncResult(callback, RuntimeHelpers.GetObjectValue(state));
|
|
LineReadableSocketStream.StreamReadWriteParameter readWriteParameter = new LineReadableSocketStream.StreamReadWriteParameter();
|
|
if (count < 0)
|
|
throw new ArgumentOutOfRangeException();
|
|
if (count == 0)
|
|
{
|
|
myAsyncResult.ReturnValue = (object) 0;
|
|
myAsyncResult.Complete();
|
|
}
|
|
else
|
|
{
|
|
IAsyncResult asyncResult;
|
|
try
|
|
{
|
|
readWriteParameter.buffer = buffer;
|
|
readWriteParameter.offset = offset;
|
|
readWriteParameter.count = count;
|
|
myAsyncResult.Tag = (object) readWriteParameter;
|
|
this._soc.BeginSend(readWriteParameter.buffer, readWriteParameter.offset, readWriteParameter.count, SocketFlags.None, new AsyncCallback(this.OnSend), (object) myAsyncResult);
|
|
goto label_8;
|
|
}
|
|
catch (Exception ex1)
|
|
{
|
|
ProjectData.SetProjectError(ex1);
|
|
Exception ex2 = ex1;
|
|
myAsyncResult.Complete(ex2);
|
|
asyncResult = (IAsyncResult) myAsyncResult;
|
|
ProjectData.ClearProjectError();
|
|
}
|
|
return asyncResult;
|
|
}
|
|
label_8:
|
|
return (IAsyncResult) myAsyncResult;
|
|
}
|
|
|
|
private void OnSend(IAsyncResult asyncresult)
|
|
{
|
|
MyAsyncResult asyncState = (MyAsyncResult) asyncresult.AsyncState;
|
|
LineReadableSocketStream.StreamReadWriteParameter tag = (LineReadableSocketStream.StreamReadWriteParameter) asyncState.Tag;
|
|
if (!asyncresult.CompletedSynchronously)
|
|
asyncState.SetAsync();
|
|
try
|
|
{
|
|
int num = this._soc.EndSend(asyncresult);
|
|
Interlocked.Add(ref this._writebytes, (long) num);
|
|
LineReadableSocketStream.StreamReadWriteParameter readWriteParameter1 = tag;
|
|
readWriteParameter1.count = checked (readWriteParameter1.count - num);
|
|
LineReadableSocketStream.StreamReadWriteParameter readWriteParameter2 = tag;
|
|
readWriteParameter2.offset = checked (readWriteParameter2.offset + num);
|
|
if (tag.count > 0)
|
|
{
|
|
this._soc.BeginSend(tag.buffer, tag.offset, tag.count, SocketFlags.None, new AsyncCallback(this.OnSend), (object) asyncState);
|
|
return;
|
|
}
|
|
}
|
|
catch (Exception ex1)
|
|
{
|
|
ProjectData.SetProjectError(ex1);
|
|
Exception ex2 = ex1;
|
|
asyncState.Complete(ex2);
|
|
ProjectData.ClearProjectError();
|
|
return;
|
|
}
|
|
asyncState.Complete();
|
|
}
|
|
|
|
public override void EndWrite(IAsyncResult asyncResult)
|
|
{
|
|
((MyAsyncResult) asyncResult).AsyncEnd();
|
|
}
|
|
|
|
protected override void Dispose(bool disposing)
|
|
{
|
|
if (!this.disposedValue && disposing && this._soc != null)
|
|
{
|
|
this._soc.Close();
|
|
this._soc = (Socket) null;
|
|
}
|
|
this.disposedValue = true;
|
|
base.Dispose(disposing);
|
|
}
|
|
|
|
private class StreamReadWriteParameter
|
|
{
|
|
public byte[] buffer;
|
|
public int offset;
|
|
public int count;
|
|
|
|
[DebuggerNonUserCode]
|
|
public StreamReadWriteParameter()
|
|
{
|
|
}
|
|
}
|
|
}
|
|
}
|