SendWithNtAuthAsync()

static async Task< HttpResponseMessage > System.Net.Http.AuthenticationHelper.SendWithNtAuthAsync ( HttpRequestMessage request, Uri authUri, bool async, ICredentials credentials, bool isProxyAuth, HttpConnection connection, HttpConnectionPool connectionPool, CancellationToken cancellationToken )

inlinestaticprivate

Definition at line 633 of file AuthenticationHelper.cs.

    {
        HttpResponseMessage response = await InnerSendAsync(request, async, isProxyAuth, connectionPool, connection, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
        if (!isProxyAuth && connection.Kind == HttpConnectionKind.Proxy && !ProxySupportsConnectionAuth(response))
        {
            if (System.Net.NetEventSource.Log.IsEnabled())
            {
                System.Net.NetEventSource.Error(connection, $"Proxy doesn't support connection-based auth, uri={authUri}", "SendWithNtAuthAsync");
            }
            return response;
        }
        if (TryGetAuthenticationChallenge(response, isProxyAuth, authUri, credentials, out var challenge) && (challenge.AuthenticationType == AuthenticationType.Negotiate || challenge.AuthenticationType == AuthenticationType.Ntlm))
        {
            bool isNewConnection = false;
            bool needDrain = true;
            try
            {
                if (response.Headers.ConnectionClose.GetValueOrDefault())
                {
                    connection.DetachFromPool();
                    connection = await connectionPool.CreateHttp11ConnectionAsync(request, async, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
                    connection.Acquire();
                    isNewConnection = true;
                    needDrain = false;
                }
                if (System.Net.NetEventSource.Log.IsEnabled())
                {
                    System.Net.NetEventSource.Info(connection, $"Authentication: {challenge.AuthenticationType}, Uri: {authUri.AbsoluteUri}", "SendWithNtAuthAsync");
                }
                string text;
                if (!isProxyAuth && request.HasHeaders && request.Headers.Host != null)
                {
                    text = request.Headers.Host;
                    if (System.Net.NetEventSource.Log.IsEnabled())
                    {
                        System.Net.NetEventSource.Info(connection, $"Authentication: {challenge.AuthenticationType}, Host: {text}", "SendWithNtAuthAsync");
                    }
                }
                else
                {
                    UriHostNameType hostNameType = authUri.HostNameType;
                    text = ((hostNameType != UriHostNameType.IPv6 && hostNameType != UriHostNameType.IPv4) ? (await Dns.GetHostEntryAsync(authUri.IdnHost, cancellationToken).ConfigureAwait(continueOnCapturedContext: false)).HostName : authUri.IdnHost);
                    if (!isProxyAuth && !authUri.IsDefaultPort && UsePortInSpn)
                    {
                        IFormatProvider formatProvider = null;
                        IFormatProvider provider = formatProvider;
                        Span<char> initialBuffer = stackalloc char[128];
                        DefaultInterpolatedStringHandler handler = new DefaultInterpolatedStringHandler(1, 2, formatProvider, initialBuffer);
                        handler.AppendFormatted(text);
                        handler.AppendLiteral(":");
                        handler.AppendFormatted(authUri.Port);
                        text = string.Create(provider, initialBuffer, ref handler);
                    }
                }
                string text2 = "HTTP/" + text;
                if (System.Net.NetEventSource.Log.IsEnabled())
                {
                    System.Net.NetEventSource.Info(connection, $"Authentication: {challenge.AuthenticationType}, SPN: {text2}", "SendWithNtAuthAsync");
                }
                ChannelBinding channelBinding = connection.TransportContext?.GetChannelBinding(ChannelBindingKind.Endpoint);
                System.Net.NTAuthentication authContext = new System.Net.NTAuthentication(isServer: false, challenge.SchemeName, challenge.Credential, text2, System.Net.ContextFlagsPal.Connection | System.Net.ContextFlagsPal.AcceptStream, channelBinding);
                string challengeData = challenge.ChallengeData;
                try
                {
                    while (true)
                    {
                        string challengeResponse = authContext.GetOutgoingBlob(challengeData);
                        if (challengeResponse != null)
                        {
                            if (needDrain)
                            {
                                await connection.DrainResponseAsync(response, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
                            }
                            SetRequestAuthenticationHeaderValue(request, new AuthenticationHeaderValue(challenge.SchemeName, challengeResponse), isProxyAuth);
                            response = await InnerSendAsync(request, async, isProxyAuth, connectionPool, connection, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
                            if (!authContext.IsCompleted && TryGetRepeatedChallenge(response, challenge.SchemeName, isProxyAuth, out challengeData))
                            {
                                needDrain = true;
                                continue;
                            }
                            break;
                        }
                        break;
                    }
                }
                finally
                {
                    authContext.CloseContext();
                }
            }
            finally
            {
                if (isNewConnection)
                {
                    connection.Release();
                }
            }
        }
        return response;
    }

References System.Net.Http.HttpConnection.Acquire(), System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendFormatted(), System.Runtime.CompilerServices.DefaultInterpolatedStringHandler.AppendLiteral(), System.cancellationToken, System.Net.Http.HttpConnection.DetachFromPool(), System.Net.Http.HttpConnection.DrainResponseAsync(), System.Net.NetEventSource.Error(), System.Net.TransportContext.GetChannelBinding(), System.Net.Dns.GetHostEntryAsync(), System.Net.NetEventSource.Info(), System.Net.Http.AuthenticationHelper.InnerSendAsync(), System.Net.Http.HttpConnection.Kind, System.Net.NetEventSource.Log, System.Net.Http.AuthenticationHelper.ProxySupportsConnectionAuth(), System.Net.Http.HttpConnection.Release(), System.Net.Http.AuthenticationHelper.SetRequestAuthenticationHeaderValue(), System.text, System.Net.Http.HttpConnection.TransportContext, System.Net.Http.AuthenticationHelper.TryGetAuthenticationChallenge(), System.Net.Http.AuthenticationHelper.TryGetRepeatedChallenge(), and System.Net.Http.AuthenticationHelper.UsePortInSpn.

Referenced by System.Net.Http.AuthenticationHelper.SendWithNtConnectionAuthAsync(), and System.Net.Http.AuthenticationHelper.SendWithNtProxyAuthAsync().