◆ ForceAuthenticationAsync< TIOAdapter >()

async Task System.Net.Security.SslStream.ForceAuthenticationAsync< TIOAdapter >	(	TIOAdapter	adapter,
		bool	receiveFirst,
		byte[]	reAuthenticationData,
		bool	isApm = false )
inlineprivate
Type Constraints
TIOAdapter
:
IReadWriteAdapter
Definition at line 1117 of file SslStream.cs.
                                                                                                                                                                     : IReadWriteAdapter
    {
        bool handshakeCompleted = false;
        if (reAuthenticationData == null && Interlocked.Exchange(ref _nestedAuth, 1) == 1)
        {
            throw new InvalidOperationException(System.SR.Format(System.SR.net_io_invalidnestedcall, isApm ? "BeginAuthenticate" : "Authenticate", "authenticate"));
        }
        try
        {
            if (!receiveFirst)
            {
                ProtocolToken message = _context.NextMessage(reAuthenticationData);
                if (message.Size > 0)
                {
                    await adapter.WriteAsync(message.Payload, 0, message.Size).ConfigureAwait(continueOnCapturedContext: false);
                    await adapter.FlushAsync().ConfigureAwait(continueOnCapturedContext: false);
                    if (System.Net.NetEventSource.Log.IsEnabled())
                    {
                        System.Net.NetEventSource.Log.SentFrame(this, message.Payload);
                    }
                }
                if (message.Failed)
                {
                    throw new AuthenticationException(System.SR.net_auth_SSPI, message.GetException());
                }
                if (message.Status.ErrorCode == SecurityStatusPalErrorCode.OK)
                {
                    handshakeCompleted = true;
                }
            }
            if (!handshakeCompleted)
            {
                _handshakeBuffer = new ArrayBuffer(4160);
            }
            while (!handshakeCompleted)
            {
                ProtocolToken message = await ReceiveBlobAsync(adapter).ConfigureAwait(continueOnCapturedContext: false);
                byte[] payload = null;
                int num = 0;
                if (message.Size > 0)
                {
                    payload = message.Payload;
                    num = message.Size;
                }
                else if (message.Failed && (_lastFrame.Header.Type == TlsContentType.Handshake || _lastFrame.Header.Type == TlsContentType.ChangeCipherSpec))
                {
                    payload = TlsFrameHelper.CreateAlertFrame(_lastFrame.Header.Version, TlsAlertDescription.ProtocolVersion);
                    num = payload.Length;
                }
                if (payload != null && num > 0)
                {
                    await adapter.WriteAsync(payload, 0, num).ConfigureAwait(continueOnCapturedContext: false);
                    await adapter.FlushAsync().ConfigureAwait(continueOnCapturedContext: false);
                    if (System.Net.NetEventSource.Log.IsEnabled())
                    {
                        System.Net.NetEventSource.Log.SentFrame(this, payload);
                    }
                }
                if (message.Failed)
                {
                    if (System.Net.NetEventSource.Log.IsEnabled())
                    {
                        System.Net.NetEventSource.Error(this, message.Status, "ForceAuthenticationAsync");
                    }
                    if (_lastFrame.Header.Type == TlsContentType.Alert && _lastFrame.AlertDescription != 0 && message.Status.ErrorCode == SecurityStatusPalErrorCode.IllegalMessage)
                    {
                        throw new AuthenticationException(System.SR.Format(System.SR.net_auth_tls_alert, _lastFrame.AlertDescription.ToString()), message.GetException());
                    }
                    throw new AuthenticationException(System.SR.net_auth_SSPI, message.GetException());
                }
                if (message.Status.ErrorCode == SecurityStatusPalErrorCode.OK)
                {
                    handshakeCompleted = true;
                }
            }
            if (_handshakeBuffer.ActiveLength > 0)
            {
                ResetReadBuffer();
                _handshakeBuffer.ActiveSpan.CopyTo(_internalBuffer);
                _internalBufferCount = _handshakeBuffer.ActiveLength;
            }
            CompleteHandshake(_sslAuthenticationOptions);
        }
        finally
        {
            _handshakeBuffer.Dispose();
            if (reAuthenticationData == null)
            {
                _nestedAuth = 0;
                _isRenego = false;
            }
        }
        if (System.Net.NetEventSource.Log.IsEnabled())
        {
            System.Net.NetEventSource.Log.SspiSelectedCipherSuite("ForceAuthenticationAsync", SslProtocol, CipherAlgorithm, CipherStrength, HashAlgorithm, HashStrength, KeyExchangeAlgorithm, KeyExchangeStrength);
        }
    }