Beispiel #1
0
        async Task CopyAsync(
            IReadOnlyStream source,
            IWriteOnlyStream destination,
            CancellationToken cancellationToken = default)
        {
            byte[] buffer = this._bufferPool.Rent(4096);
            try
            {
                int bytesRead;
                while ((bytesRead = await source
                                    .ReadAsync(buffer, 0, buffer.Length, cancellationToken)
                                    .ConfigureAwait(false)) != 0)
                {
                    // Transform

                    await destination
                    .WriteAsync(buffer, 0, bytesRead, cancellationToken)
                    .ConfigureAwait(false);
                }
            }
            finally
            {
                this._bufferPool.Return(buffer);
            }
        }
Beispiel #2
0
        public static async Task CopyTo <TReadOnlyStream>(
            this TReadOnlyStream source,
            IWriteOnlyStream destination,
            byte[] buffer,
            CancellationToken cancellationToken = default) where TReadOnlyStream : IReadOnlyStream
        {
            if (destination == null)
            {
                throw new ArgumentNullException(nameof(destination));
            }
            if (buffer == null)
            {
                throw new ArgumentNullException(nameof(buffer));
            }

            int bytesRead;

            while ((bytesRead = await source
                                .ReadAsync(buffer, 0, buffer.Length, cancellationToken)
                                .ConfigureAwait(false)) != 0)
            {
                await destination
                .WriteAsync(buffer, 0, bytesRead, cancellationToken)
                .ConfigureAwait(false);
            }
        }
Beispiel #3
0
        public async Task WriteToAsync(IWriteOnlyStream stream, ArrayPool <byte> bufferPool)
        {
            if (stream == null)
            {
                throw new ArgumentNullException(nameof(stream));
            }
            if (bufferPool == null)
            {
                throw new ArgumentNullException(nameof(bufferPool));
            }

            // | VER | REP |  RSV  | ATYP | BND.ADDR | BND.PORT |
            // |  1  | 1   | X'00' | 1    | Variable | 2        |
            var buffer = bufferPool.Rent(4 + 1 + byte.MaxValue + sizeof(ushort));

            try
            {
                buffer[0] = 5;
                buffer[1] = (byte)this.ReplyType;
                buffer[2] = 0;

                var bindEndPoint         = this.BindEndPoint ?? new IPEndPoint(new IPAddress(0L), 0);
                int endPointBytesWritten = bindEndPoint.ToBytes(buffer, 3);

                await stream.WriteAsync(buffer, 0, 3 + endPointBytesWritten).ConfigureAwait(false);
            }
            finally
            {
                bufferPool.Return(buffer);
            }
        }
Beispiel #4
0
        public async Task WriteToAsync(IWriteOnlyStream stream, ArrayPool <byte> bufferPool)
        {
            if (stream == null)
            {
                throw new ArgumentNullException(nameof(stream));
            }
            if (bufferPool == null)
            {
                throw new ArgumentNullException(nameof(bufferPool));
            }

            // | VER | METHOD |
            // |  1  |    1   |
            var buffer = bufferPool.Rent(2);

            try
            {
                buffer[0] = 5;
                buffer[1] = (byte)this.SelectedAuthenticationMethod;
                await stream.WriteAsync(buffer, 0, 2).ConfigureAwait(false);
            }
            finally
            {
                bufferPool.Return(buffer);
            }
        }