SendAsyncCore()

async Task< HttpResponseMessage > System.Net.Http.HttpConnection.SendAsyncCore ( HttpRequestMessage request, bool async, CancellationToken cancellationToken )

inline

Definition at line 1359 of file HttpConnection.cs.

    {
        TaskCompletionSource<bool> allowExpect100ToContinue = null;
        Task sendRequestContentTask = null;
        _currentRequest = request;
        HttpMethod normalizedMethod = HttpMethod.Normalize(request.Method);
        _canRetry = false;
        _startedSendingRequestBody = false;
        if (System.Net.NetEventSource.Log.IsEnabled())
        {
            Trace($"Sending request: {request}", "SendAsyncCore");
        }
        CancellationTokenRegistration cancellationRegistration = RegisterCancellation(cancellationToken);
        Unsafe.SkipInit(out HttpResponseMessage result);
        try
        {
            if (HttpTelemetry.Log.IsEnabled())
            {
                HttpTelemetry.Log.RequestHeadersStart();
            }
            await WriteStringAsync(normalizedMethod.Method, async).ConfigureAwait(continueOnCapturedContext: false);
            await WriteByteAsync(32, async).ConfigureAwait(continueOnCapturedContext: false);
            if ((object)normalizedMethod == HttpMethod.Connect)
            {
                if (!request.HasHeaders || request.Headers.Host == null)
                {
                    throw new HttpRequestException(System.SR.net_http_request_no_host);
                }
                await WriteAsciiStringAsync(request.Headers.Host, async).ConfigureAwait(continueOnCapturedContext: false);
            }
            else
            {
                if (Kind == HttpConnectionKind.Proxy)
                {
                    await WriteBytesAsync(s_httpSchemeAndDelimiter, async).ConfigureAwait(continueOnCapturedContext: false);
                    if (request.RequestUri.HostNameType != UriHostNameType.IPv6)
                    {
                        await WriteAsciiStringAsync(request.RequestUri.IdnHost, async).ConfigureAwait(continueOnCapturedContext: false);
                    }
                    else
                    {
                        await WriteByteAsync(91, async).ConfigureAwait(continueOnCapturedContext: false);
                        await WriteAsciiStringAsync(request.RequestUri.IdnHost, async).ConfigureAwait(continueOnCapturedContext: false);
                        await WriteByteAsync(93, async).ConfigureAwait(continueOnCapturedContext: false);
                    }
                    if (!request.RequestUri.IsDefaultPort)
                    {
                        await WriteByteAsync(58, async).ConfigureAwait(continueOnCapturedContext: false);
                        await WriteDecimalInt32Async(request.RequestUri.Port, async).ConfigureAwait(continueOnCapturedContext: false);
                    }
                }
                await WriteStringAsync(request.RequestUri.PathAndQuery, async).ConfigureAwait(continueOnCapturedContext: false);
            }
            bool flag = request.Version.Minor == 0 && request.Version.Major == 1;
            await WriteBytesAsync(flag ? s_spaceHttp10NewlineAsciiBytes : s_spaceHttp11NewlineAsciiBytes, async).ConfigureAwait(continueOnCapturedContext: false);
            string cookiesFromContainer = null;
            if (_pool.Settings._useCookies)
            {
                cookiesFromContainer = _pool.Settings._cookieContainer.GetCookieHeader(request.RequestUri);
                if (cookiesFromContainer == "")
                {
                    cookiesFromContainer = null;
                }
            }
            if (!request.HasHeaders || request.Headers.Host == null)
            {
                await WriteHostHeaderAsync(request.RequestUri, async).ConfigureAwait(continueOnCapturedContext: false);
            }
            if (request.HasHeaders || cookiesFromContainer != null)
            {
                await WriteHeadersAsync(request.Headers, cookiesFromContainer, async).ConfigureAwait(continueOnCapturedContext: false);
            }
            if (request.Content != null)
            {
                await WriteHeadersAsync(request.Content.Headers, null, async).ConfigureAwait(continueOnCapturedContext: false);
            }
            else if (normalizedMethod.MustHaveRequestBody)
            {
                await WriteBytesAsync(s_contentLength0NewlineAsciiBytes, async).ConfigureAwait(continueOnCapturedContext: false);
            }
            await WriteTwoBytesAsync(13, 10, async).ConfigureAwait(continueOnCapturedContext: false);
            if (HttpTelemetry.Log.IsEnabled())
            {
                HttpTelemetry.Log.RequestHeadersStop();
            }
            if (request.Content == null)
            {
                await FlushAsync(async).ConfigureAwait(continueOnCapturedContext: false);
            }
            else
            {
                bool flag2 = request.HasHeaders && request.Headers.ExpectContinue == true;
                if (System.Net.NetEventSource.Log.IsEnabled())
                {
                    Trace($"Request content is not null, start processing it. hasExpectContinueHeader = {flag2}", "SendAsyncCore");
                }
                if (!flag2)
                {
                    await SendRequestContentAsync(request, CreateRequestContentStream(request), async, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
                }
                else
                {
                    await FlushAsync(async).ConfigureAwait(continueOnCapturedContext: false);
                    allowExpect100ToContinue = new TaskCompletionSource<bool>();
                    Timer expect100Timer = new Timer(delegate(object s)
                    {
                        ((TaskCompletionSource<bool>)s).TrySetResult(result: true);
                    }, allowExpect100ToContinue, _pool.Settings._expect100ContinueTimeout, Timeout.InfiniteTimeSpan);
                    sendRequestContentTask = SendRequestContentWithExpect100ContinueAsync(request, allowExpect100ToContinue.Task, CreateRequestContentStream(request), expect100Timer, async, cancellationToken);
                }
            }
            _allowedReadLineBytes = (int)Math.Min(2147483647L, (long)_pool.Settings._maxResponseHeadersLength * 1024L);
            ValueTask<int>? valueTask = ConsumeReadAheadTask();
            if (!valueTask.HasValue)
            {
                await InitialFillAsync(async).ConfigureAwait(continueOnCapturedContext: false);
            }
            else
            {
                ValueTask<int> valueOrDefault = valueTask.GetValueOrDefault();
                int num;
                if (valueOrDefault.IsCompleted)
                {
                    num = valueOrDefault.Result;
                }
                else
                {
                    if (!async)
                    {
                        Trace("Pre-emptive read completed asynchronously for a synchronous request.", "SendAsyncCore");
                    }
                    num = await valueOrDefault.ConfigureAwait(continueOnCapturedContext: false);
                }
                if (System.Net.NetEventSource.Log.IsEnabled())
                {
                    Trace($"Received {num} bytes.", "SendAsyncCore");
                }
                _readOffset = 0;
                _readLength = num;
            }
            if (_readLength == 0)
            {
                if (!_startedSendingRequestBody)
                {
                    _canRetry = true;
                }
                throw new IOException(System.SR.net_http_invalid_response_premature_eof);
            }
            HttpResponseMessage response = new HttpResponseMessage
            {
                RequestMessage = request,
                Content = new HttpConnectionResponseContent()
            };
            ParseStatusLine((await ReadNextResponseHeaderLineAsync(async).ConfigureAwait(continueOnCapturedContext: false)).Span, response);
            if (HttpTelemetry.Log.IsEnabled())
            {
                HttpTelemetry.Log.ResponseHeadersStart();
            }
            while ((uint)(response.StatusCode - 100) <= 99u)
            {
                if (allowExpect100ToContinue != null && response.StatusCode == HttpStatusCode.Continue)
                {
                    allowExpect100ToContinue.TrySetResult(result: true);
                    allowExpect100ToContinue = null;
                }
                else if (response.StatusCode == HttpStatusCode.SwitchingProtocols)
                {
                    break;
                }
                if (System.Net.NetEventSource.Log.IsEnabled())
                {
                    Trace($"Current {response.StatusCode} response is an interim response or not expected, need to read for a final response.", "SendAsyncCore");
                }
                while (!IsLineEmpty(await ReadNextResponseHeaderLineAsync(async).ConfigureAwait(continueOnCapturedContext: false)))
                {
                }
                ParseStatusLine((await ReadNextResponseHeaderLineAsync(async).ConfigureAwait(continueOnCapturedContext: false)).Span, response);
            }
            while (true)
            {
                ReadOnlyMemory<byte> line = await ReadNextResponseHeaderLineAsync(async, foldedHeadersAllowed: true).ConfigureAwait(continueOnCapturedContext: false);
                if (IsLineEmpty(line))
                {
                    break;
                }
                ParseHeaderNameValue(this, line.Span, response, isFromTrailer: false);
            }
            if (HttpTelemetry.Log.IsEnabled())
            {
                HttpTelemetry.Log.ResponseHeadersStop();
            }
            if (allowExpect100ToContinue != null)
            {
                if (response.StatusCode >= HttpStatusCode.MultipleChoices && request.Content != null && (!request.Content.Headers.ContentLength.HasValue || request.Content.Headers.ContentLength.GetValueOrDefault() > 1024) && !AuthenticationHelper.IsSessionAuthenticationChallenge(response))
                {
                    allowExpect100ToContinue.TrySetResult(result: false);
                    if (!allowExpect100ToContinue.Task.Result)
                    {
                        _connectionClose = true;
                    }
                }
                else
                {
                    allowExpect100ToContinue.TrySetResult(result: true);
                }
            }
            if (response.Headers.ConnectionClose.GetValueOrDefault())
            {
                _connectionClose = true;
            }
            if (sendRequestContentTask != null)
            {
                Task task = sendRequestContentTask;
                sendRequestContentTask = null;
                await task.ConfigureAwait(continueOnCapturedContext: false);
            }
            if (System.Net.NetEventSource.Log.IsEnabled())
            {
                Trace("Request is fully sent.", "SendAsyncCore");
            }
            cancellationRegistration.Dispose();
            CancellationHelper.ThrowIfCancellationRequested(cancellationToken);
            Stream stream;
            if ((object)normalizedMethod == HttpMethod.Head || response.StatusCode == HttpStatusCode.NoContent || response.StatusCode == HttpStatusCode.NotModified)
            {
                stream = EmptyReadStream.Instance;
                CompleteResponse();
            }
            else if ((object)normalizedMethod == HttpMethod.Connect && response.StatusCode == HttpStatusCode.OK)
            {
                stream = new RawConnectionStream(this);
                _connectionClose = true;
                _pool.InvalidateHttp11Connection(this);
                _detachedFromPool = true;
            }
            else if (response.StatusCode == HttpStatusCode.SwitchingProtocols)
            {
                stream = new RawConnectionStream(this);
                _connectionClose = true;
                _pool.InvalidateHttp11Connection(this);
                _detachedFromPool = true;
            }
            else if (!response.Content.Headers.ContentLength.HasValue)
            {
                stream = ((response.Headers.TransferEncodingChunked != true) ? ((HttpContentReadStream)new ConnectionCloseReadStream(this)) : ((HttpContentReadStream)new ChunkedEncodingReadStream(this, response)));
            }
            else
            {
                long valueOrDefault2 = response.Content.Headers.ContentLength.GetValueOrDefault();
                if (valueOrDefault2 <= 0)
                {
                    stream = EmptyReadStream.Instance;
                    CompleteResponse();
                }
                else
                {
                    stream = new ContentLengthReadStream(this, (ulong)valueOrDefault2);
                }
            }
            ((HttpConnectionResponseContent)response.Content).SetStream(stream);
            if (System.Net.NetEventSource.Log.IsEnabled())
            {
                Trace($"Received response: {response}", "SendAsyncCore");
            }
            if (_pool.Settings._useCookies)
            {
                CookieHelper.ProcessReceivedCookies(response, _pool.Settings._cookieContainer);
            }
            result = response;
            return result;
        }
        catch (Exception ex)
        {
            Exception error = ex;
            cancellationRegistration.Dispose();
            allowExpect100ToContinue?.TrySetResult(result: false);
            if (System.Net.NetEventSource.Log.IsEnabled())
            {
                Trace($"Error sending request: {error}", "SendAsyncCore");
            }
            if (sendRequestContentTask != null && !sendRequestContentTask.IsCompletedSuccessfully)
            {
                if (Volatile.Read(ref _disposed) == 1)
                {
                    Exception mappedException;
                    try
                    {
                        await sendRequestContentTask.ConfigureAwait(continueOnCapturedContext: false);
                    }
                    catch (Exception exception) when (MapSendException(exception, cancellationToken, out mappedException))
                    {
                        throw mappedException;
                    }
                }
                LogExceptions(sendRequestContentTask);
            }
            Dispose();
            if (MapSendException(error, cancellationToken, out var mappedException2))
            {
                throw mappedException2;
            }
            if (!(ex is Exception source))
            {
                throw ex;
            }
            ExceptionDispatchInfo.Capture(source).Throw();
        }
        return result;
    }

References System.Net.Http.HttpConnection._allowedReadLineBytes, System.Net.Http.HttpConnection._canRetry, System.Net.Http.HttpConnection._connectionClose, System.Net.Http.HttpConnectionSettings._cookieContainer, System.Net.Http.HttpConnection._currentRequest, System.Net.Http.HttpConnection._detachedFromPool, System.Net.Http.HttpConnection._disposed, System.Net.Http.HttpConnectionSettings._expect100ContinueTimeout, System.Net.Http.HttpConnection._pool, System.Net.Http.HttpConnection._readLength, System.Net.Http.HttpConnection._readOffset, System.Net.Http.HttpConnection._startedSendingRequestBody, System.Net.Http.HttpConnectionSettings._useCookies, System.cancellationToken, System.Runtime.ExceptionServices.ExceptionDispatchInfo.Capture(), System.Net.Http.HttpConnection.CompleteResponse(), System.Threading.Tasks.Task< TResult >.ConfigureAwait(), System.Threading.Tasks.ValueTask< TResult >.ConfigureAwait(), System.Net.Http.HttpMethod.Connect, System.Net.Http.HttpConnection.ConsumeReadAheadTask(), System.Net.Http.HttpConnection.CreateRequestContentStream(), System.Net.Http.HttpConnection.Dispose(), System.exception, System.Net.Http.HttpConnection.FlushAsync(), System.Net.CookieContainer.GetCookieHeader(), System.Net.Http.HttpMethod.Head, System.Threading.Timeout.InfiniteTimeSpan, System.Net.Http.HttpConnection.InitialFillAsync(), System.Net.Http.EmptyReadStream.Instance, System.Net.Http.HttpConnectionPool.InvalidateHttp11Connection(), System.Net.Http.HttpConnection.IsLineEmpty(), System.Net.Http.AuthenticationHelper.IsSessionAuthenticationChallenge(), System.Net.Http.HttpConnection.Kind, System.L, System.Net.Http.HttpTelemetry.Log, System.Net.NetEventSource.Log, System.Net.Http.HttpConnectionBase.LogExceptions(), System.Net.Http.HttpConnection.MapSendException(), System.Math.Min(), System.SR.net_http_invalid_response_premature_eof, System.SR.net_http_request_no_host, System.Net.Http.HttpMethod.Normalize(), System.Net.Http.HttpConnection.ParseHeaderNameValue(), System.Net.Http.HttpConnection.ParseStatusLine(), System.Net.Http.CookieHelper.ProcessReceivedCookies(), System.Threading.Volatile.Read(), System.Net.Http.HttpConnection.ReadNextResponseHeaderLineAsync(), System.Net.Http.HttpConnection.RegisterCancellation(), System.s, System.Net.Http.HttpConnection.s_contentLength0NewlineAsciiBytes, System.Net.Http.HttpConnection.s_httpSchemeAndDelimiter, System.Net.Http.HttpConnection.s_spaceHttp10NewlineAsciiBytes, System.Net.Http.HttpConnection.s_spaceHttp11NewlineAsciiBytes, System.Net.Http.HttpConnection.SendRequestContentAsync(), System.Net.Http.HttpConnection.SendRequestContentWithExpect100ContinueAsync(), System.Net.Http.HttpConnectionPool.Settings, System.source, System.stream, System.task, System.Net.Http.CancellationHelper.ThrowIfCancellationRequested(), System.Net.Http.HttpConnection.Trace(), System.Net.Http.HttpConnection.WriteAsciiStringAsync(), System.Net.Http.HttpConnection.WriteByteAsync(), System.Net.Http.HttpConnection.WriteBytesAsync(), System.Net.Http.HttpConnection.WriteDecimalInt32Async(), System.Net.Http.HttpConnection.WriteHeadersAsync(), System.Net.Http.HttpConnection.WriteHostHeaderAsync(), System.Net.Http.HttpConnection.WriteStringAsync(), and System.Net.Http.HttpConnection.WriteTwoBytesAsync().

Referenced by System.Net.Http.AuthenticationHelper.InnerSendAsync(), and System.Net.Http.HttpConnection.SendAsync().