ReadAsync< TAdapter >()

async ValueTask< int > System.Net.Security.NegotiateStream.ReadAsync< TAdapter > ( TAdapter adapter, Memory< byte > buffer, [CallerMemberName] string callerName = null )

inlineprivate

Type Constraints

TAdapter

:

IReadWriteAdapter

Definition at line 496 of file NegotiateStream.cs.

                                                                                                                                                        : IReadWriteAdapter
    {
        if (Interlocked.Exchange(ref _readInProgress, 1) == 1)
        {
            throw new NotSupportedException(System.SR.Format(System.SR.net_io_invalidnestedcall, callerName, "read"));
        }
        try
        {
            if (_readBufferCount != 0)
            {
                int num = Math.Min(_readBufferCount, buffer.Length);
                if (num != 0)
                {
                    _readBuffer.AsMemory(_readBufferOffset, num).CopyTo(buffer);
                    _readBufferOffset += num;
                    _readBufferCount -= num;
                }
                return num;
            }
            int num2;
            do
            {
                if (await ReadAllAsync(adapter, _readHeader, allowZeroRead: true).ConfigureAwait(continueOnCapturedContext: false) == 0)
                {
                    return 0;
                }
                num2 = BitConverter.ToInt32(_readHeader, 0);
                if (num2 <= 4 || num2 > 65536)
                {
                    throw new IOException(System.SR.net_frame_read_size);
                }
                _readBufferCount = num2;
                _readBufferOffset = 0;
                if (_readBuffer.Length < num2)
                {
                    _readBuffer = new byte[num2];
                }
                num2 = await ReadAllAsync(adapter, new Memory<byte>(_readBuffer, 0, num2), allowZeroRead: false).ConfigureAwait(continueOnCapturedContext: false);
                num2 = (_readBufferCount = DecryptData(_readBuffer, 0, num2, out _readBufferOffset));
            }
            while (num2 == 0 && buffer.Length != 0);
            if (num2 > buffer.Length)
            {
                num2 = buffer.Length;
            }
            _readBuffer.AsMemory(_readBufferOffset, num2).CopyTo(buffer);
            _readBufferOffset += num2;
            _readBufferCount -= num2;
            return num2;
        }
        catch (Exception ex) when (!(ex is IOException) && !(ex is OperationCanceledException))
        {
            throw new IOException(System.SR.net_io_read, ex);
        }
        finally
        {
            _readInProgress = 0;
        }
        static async ValueTask<int> ReadAllAsync(TAdapter adapter, Memory<byte> buffer, bool allowZeroRead)
        {
            int read = 0;
            do
            {
                int num3 = await adapter.ReadAsync(buffer).ConfigureAwait(continueOnCapturedContext: false);
                if (num3 == 0)
                {
                    if (read == 0 && allowZeroRead)
                    {
                        break;
                    }
                    throw new IOException(System.SR.net_io_eof);
                }
                buffer = buffer.Slice(num3);
                read += num3;
            }
            while (!buffer.IsEmpty);
            return read;
        }
    }

References System.Net.Security.NegotiateStream._readBuffer, System.Net.Security.NegotiateStream._readBufferCount, System.Net.Security.NegotiateStream._readBufferOffset, System.Net.Security.NegotiateStream._readHeader, System.Net.Security.NegotiateStream._readInProgress, System.buffer, System.Threading.Tasks.ValueTask< TResult >.ConfigureAwait(), System.Net.Security.NegotiateStream.DecryptData(), System.Threading.Interlocked.Exchange(), System.SR.Format(), System.Math.Min(), System.SR.net_frame_read_size, System.SR.net_io_eof, System.SR.net_io_invalidnestedcall, System.SR.net_io_read, and System.BitConverter.ToInt32().