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)); }