public HttpConnection(IMyStream myStream, EPPair epPair, NaiveHttpServer server)
{
this.baseStream = myStream.ToStream();
this.myStream = myStream;
this.server = server;
this.epPair = epPair;
}
public static async Task ReadFullImpl(IMyStream myStream, BytesSegment bs)
{
int pos = 0;
if (myStream is IMyStreamReadR r)
{
while (pos < bs.Len)
{
var read = await r.ReadAsyncR(bs.Sub(pos));
if (read == 0)
{
throw new DisconnectedException($"unexpected EOF while ReadFull() (count={bs.Len}, pos={pos})");
}
pos += read;
}
return;
}
while (pos < bs.Len)
{
var read = await myStream.ReadAsync(bs.Sub(pos)).CAF();
if (read == 0)
{
throw new DisconnectedException($"unexpected EOF while ReadFull() (count={bs.Len}, pos={pos})");
}
pos += read;
}
}
private void ResetState()
{
step = -1;
myStream = null;
bs.ResetSelf();
pos = 0;
}
public WebSocket(IMyStream BaseStream, bool isClient, bool isOpen) : this(BaseStream, isClient)
{
if (isOpen)
{
ConnectionState = States.Open;
}
}
public MultipartFormDataReader(HttpConnection p)
{
bstream = new BackableStream(p.inputDataStream);
myStream = MyStream.FromStream(bstream);
this.p = p;
Boundary = GetBoundary(p);
}
public static AwaitableWrapper <int> ReadAsyncR(this IMyStream myStream, BytesSegment bs)
{
if (myStream is IMyStreamReadR myStreamReuse)
{
return(myStreamReuse.ReadAsyncR(bs));
}
return(new AwaitableWrapper <int>(myStream.ReadAsync(bs)));
}
public TwoWayCopier(IMyStream left, IMyStream right)
{
Left = left;
Right = right;
CopierFromLeft = new Copier(left, right);
CopierFromRight = new Copier(right, left);
Logger = DefaultLogger;
}
public static AwaitableWrapper WriteAsyncR(this IMyStream myStream, BytesSegment bs)
{
if (myStream is IMyStreamWriteR myStreamReuse)
{
return(myStreamReuse.WriteAsyncR(bs));
}
return(new AwaitableWrapper(myStream.WriteAsync(bs)));
}
public static Task Relay(IMyStream left, IMyStream right, Task whenCanReadFromLeft = null)
{
return(new TwoWayCopier(left, right)
{
WhenCanReadFromLeft = whenCanReadFromLeft
}
.SetCounters(globalWriteCouter)
.Run());
}
public static AwaitableWrapper ReadFullAsyncR(this IMyStream myStream, BytesSegment bs)
{
if (myStream is IMyStreamReadFullR fullR)
{
return(fullR.ReadFullAsyncR(bs));
}
else
{
return(new AwaitableWrapper(new ReadFullRStateMachine().Start(myStream, bs)));
}
}
public static int Read(this IMyStream myStream, byte[] buf, int offset, int count)
{
if (myStream is IMyStreamSync sync)
{
return(sync.Read(new BytesSegment(buf, offset, count)));
}
else
{
return(myStream.ReadAsync(buf, offset, count).RunSync());
}
}
public static void Write(this IMyStream myStream, byte[] buf, int offset, int count)
{
if (myStream is IMyStreamSync sync)
{
sync.Write(new BytesSegment(buf, offset, count));
}
else
{
myStream.WriteAsync(buf, offset, count).RunSync();
}
}
public static Stream ToStream(IMyStream myStream)
{
if (myStream is Stream stream)
{
return(stream);
}
if (myStream is IMyStreamGetStream gs)
{
return(gs.GetStream());
}
return(new StreamFromMyStream(myStream));
}
public Task HandleAndPutStream(IAdapter outAdapter, IMyStream stream, Task waitForReadFromStream = null)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
var result = new ConnectResult(outAdapter, ConnectResultEnum.OK, stream)
{
WhenCanRead = waitForReadFromStream
};
return(SetResult(result));
}
public static HttpConnection CreateHttpConnectionFromMyStream(IMyStream myStream, NaiveHttpServer httpSvr)
{
EPPair epPair;
if (myStream is SocketStream ss)
{
epPair = ss.EPPair;
}
else
{
// use fake eppair
epPair = new EPPair(new IPEndPoint(IPAddress.Loopback, 1), new IPEndPoint(IPAddress.Loopback, 2));
}
return(new HttpConnection(myStream.ToStream(), epPair, httpSvr));
}
public MyStream.Copier CreateCopier(Adapter adapter, IMyStream myStream, bool toDest)
{
var dest = Result.Stream;
var ctrFrom = toDest ? adapter.BytesCountersRW : Result.Adapter.GetAdapter().BytesCountersRW;
var ctrTo = !toDest ? adapter.BytesCountersRW : Result.Adapter.GetAdapter().BytesCountersRW;
var c = new MyStream.Copier(toDest ? myStream : dest, !toDest ? myStream : dest)
{
CounterR = ctrFrom.R,
CounterW = ctrTo.W,
Logger = adapter.Logger
};
Request.EnsureSniffer();
Request.Sniffer.ListenToCopier(toDest ? c : null, !toDest ? null : c);
return(c);
}
public ReusableAwaiter <VoidType> Start(IMyStream stream, BytesSegment bytes)
{
if (step != -1)
{
throw new Exception("state machine is already running");
}
if (_moveNext == null)
{
_moveNext = MoveNext;
}
Reset();
step = 0;
myStream = stream;
bs = bytes;
pos = 0;
MoveNext();
return(this);
}
public static AwaitableWrapper WriteMultipleAsyncR(this IMyStream myStream, BytesView bv)
{
if (myStream is IMyStreamMultiBuffer bvs)
{
return(bvs.WriteMultipleAsyncR(bv));
}
else
{
return(new AwaitableWrapper(NaiveUtils.RunAsyncTask(async() => {
foreach (var item in bv)
{
if (item.len > 0)
{
await myStream.WriteAsync(new BytesSegment(item));
}
}
})));
}
}
public SocksInConnection(TcpClient tcp, SocksInAdapter adapter) : base(adapter)
{
_eppair = EPPair.FromSocket(tcp.Client);
_adapter = adapter;
_stream = adapter.GetMyStreamFromSocket(tcp.Client);
socks5svr = new Socks5Server(_stream);
Socks5Server.Methods methods = Socks5Server.Methods.None;
if (adapter._allowNoAuth)
{
methods |= Socks5Server.Methods.NoAuth;
}
if (adapter.users != null)
{
methods |= Socks5Server.Methods.UsernamePassword;
}
socks5svr.AcceptMethods = methods;
outRef = adapter._noAuthOut;
socks5svr.Auth = Auth;
}
public static Task CloseWithTimeout(IMyStream stream, int timeout = -2)
{
if (stream == null)
{
throw new ArgumentNullException(nameof(stream));
}
if (timeout < -2)
{
throw new ArgumentOutOfRangeException(nameof(timeout), "should be -2 (default), -1 (infinity), or >= 0.");
}
if (timeout == -2)
{
timeout = 10 * 1000;
}
if (stream is IMyStreamDispose)
{
if (stream.State.IsDisposed)
{
return(NaiveUtils.CompletedTask);
}
}
else if (stream.State.IsClosed)
{
return(NaiveUtils.CompletedTask);
}
return(Task.Run(async() => {
try {
var closeTask = stream is IMyStreamDispose dis ? dis.Dispose() : stream.Close();
if (await closeTask.WithTimeout(timeout))
{
Logging.warning($"stream closing timed out ({timeout} ms). ({stream})");
}
await closeTask.CAF();
} catch (Exception e) {
Logging.exception(e, Logging.Level.Warning, $"stream closing ({stream.SafeToStr()})");
}
}));
}
public TlsStream(IMyStream baseStream)
{
MyStreamWrapper = new MyStreamWrapper(baseStream);
SslStream = new SslStream(MyStreamWrapper.ToStream(), false);
}
public static Stream ToStream(this IMyStream myStream)
{
return(MyStream.ToStream(myStream));
}
public static Task RelayWith(this IMyStream stream1, IMyStream stream2)
{
return(MyStream.Relay(stream1, stream2));
}
public Task WriteTo(IMyStream stream) => StreamCopy(this, stream);
public StreamFromMyStream(IMyStream baseStream)
{
BaseStream = baseStream;
}
public static Task <int> ReadAsync(this IMyStream myStream, byte[] buf, int offset, int count)
{
return(myStream.ReadAsync(new BytesSegment(buf, offset, count)));
}
public static Task StreamCopy(IMyStream streamfrom, IMyStream streamto) => StreamCopy(streamfrom, streamto, -1);
public Copier(IMyStream from, IMyStream to)
{
From = from;
To = to;
}
public static Task StreamCopy(IMyStream streamfrom, IMyStream streamto, int bs) => StreamCopy(streamfrom, streamto, bs, false);
public static Task StreamCopy(IMyStream streamfrom, IMyStream streamto, int bs, bool dontShutdown)
{
return(new Copier(streamfrom, streamto).Copy(bs, !dontShutdown));
}
