| | | 1 | | // Licensed to the .NET Foundation under one or more agreements. |
| | | 2 | | // The .NET Foundation licenses this file to you under the MIT license. |
| | | 3 | | |
| | | 4 | | using System.Buffers; |
| | | 5 | | using System.Buffers.Text; |
| | | 6 | | using System.Diagnostics; |
| | | 7 | | using System.Globalization; |
| | | 8 | | using System.IO; |
| | | 9 | | using System.Net.Http.Headers; |
| | | 10 | | using System.Net.Sockets; |
| | | 11 | | using System.Runtime.CompilerServices; |
| | | 12 | | using System.Text; |
| | | 13 | | using System.Threading; |
| | | 14 | | using System.Threading.Tasks; |
| | | 15 | | |
| | | 16 | | namespace System.Net.Http |
| | | 17 | | { |
| | | 18 | | internal sealed partial class HttpConnection : HttpConnectionBase |
| | | 19 | | { |
| | | 20 | | /// <summary>Default size of the read buffer used for the connection.</summary> |
| | | 21 | | private const int InitialReadBufferSize = |
| | | 22 | | #if DEBUG |
| | | 23 | | 10; |
| | | 24 | | #else |
| | | 25 | | 4096; |
| | | 26 | | #endif |
| | | 27 | | /// <summary>Default size of the write buffer used for the connection.</summary> |
| | | 28 | | private const int InitialWriteBufferSize = InitialReadBufferSize; |
| | | 29 | | /// <summary> |
| | | 30 | | /// Size after which we'll close the connection rather than send the payload in response |
| | | 31 | | /// to final error status code sent by the server when using Expect: 100-continue. |
| | | 32 | | /// </summary> |
| | | 33 | | private const int Expect100ErrorSendThreshold = 1024; |
| | | 34 | | /// <summary>How long a chunk indicator is allowed to be.</summary> |
| | | 35 | | /// <remarks> |
| | | 36 | | /// While most chunks indicators will contain no more than ulong.MaxValue.ToString("X").Length characters, |
| | | 37 | | /// "chunk extensions" are allowed. We place a limit on how long a line can be to avoid OOM issues if an |
| | | 38 | | /// infinite chunk length is sent. This value is arbitrary and can be changed as needed. |
| | | 39 | | /// </remarks> |
| | | 40 | | private const int MaxChunkBytesAllowed = 16 * 1024; |
| | | 41 | | |
| | 0 | 42 | | private static readonly ulong s_http10Bytes = BitConverter.ToUInt64("HTTP/1.0"u8); |
| | 0 | 43 | | private static readonly ulong s_http11Bytes = BitConverter.ToUInt64("HTTP/1.1"u8); |
| | | 44 | | |
| | | 45 | | internal readonly Stream _stream; |
| | | 46 | | private readonly TransportContext? _transportContext; |
| | | 47 | | |
| | | 48 | | private HttpRequestMessage? _currentRequest; |
| | | 49 | | private ArrayBuffer _writeBuffer; |
| | | 50 | | private int _allowedReadLineBytes; |
| | | 51 | | |
| | | 52 | | /// <summary>Reusable array used to get the values for each header being written to the wire.</summary> |
| | | 53 | | [ThreadStatic] |
| | | 54 | | private static string[]? t_headerValues; |
| | | 55 | | |
| | | 56 | | private const int ReadAheadTask_NotStarted = 0; |
| | | 57 | | private const int ReadAheadTask_Started = 1; |
| | | 58 | | private const int ReadAheadTask_CompletionReserved = 2; |
| | | 59 | | private const int ReadAheadTask_Completed = 3; |
| | | 60 | | private int _readAheadTaskStatus; |
| | | 61 | | private ValueTask<int> _readAheadTask; |
| | | 62 | | private ArrayBuffer _readBuffer; |
| | | 63 | | |
| | | 64 | | private int _keepAliveTimeoutSeconds; // 0 == no timeout |
| | | 65 | | private bool _inUse; |
| | | 66 | | private bool _detachedFromPool; |
| | | 67 | | private bool _canRetry; |
| | | 68 | | private bool _connectionClose; // Connection: close was seen on last response |
| | | 69 | | |
| | | 70 | | private volatile bool _disposed; |
| | | 71 | | |
| | | 72 | | public HttpConnection( |
| | | 73 | | HttpConnectionPool pool, |
| | | 74 | | Stream stream, |
| | | 75 | | TransportContext? transportContext, |
| | | 76 | | Activity? connectionSetupActivity, |
| | | 77 | | IPEndPoint? remoteEndPoint, |
| | | 78 | | long connectionId) |
| | 0 | 79 | | : base(pool, connectionId, connectionSetupActivity, remoteEndPoint) |
| | 0 | 80 | | { |
| | 0 | 81 | | Debug.Assert(stream != null); |
| | | 82 | | |
| | 0 | 83 | | _stream = stream; |
| | | 84 | | |
| | 0 | 85 | | _transportContext = transportContext; |
| | | 86 | | |
| | 0 | 87 | | _writeBuffer = new ArrayBuffer(InitialWriteBufferSize, usePool: false); |
| | 0 | 88 | | _readBuffer = new ArrayBuffer(InitialReadBufferSize, usePool: false); |
| | | 89 | | |
| | 0 | 90 | | if (NetEventSource.Log.IsEnabled()) TraceConnection(_stream); |
| | 0 | 91 | | } |
| | | 92 | | |
| | 0 | 93 | | ~HttpConnection() => Dispose(disposing: false); |
| | | 94 | | |
| | 0 | 95 | | public override void Dispose() => Dispose(disposing: true); |
| | | 96 | | |
| | | 97 | | private void Dispose(bool disposing) |
| | 0 | 98 | | { |
| | | 99 | | // Ensure we're only disposed once. Dispose could be called concurrently, for example, |
| | | 100 | | // if the request and the response were running concurrently and both incurred an exception. |
| | 0 | 101 | | if (!Interlocked.Exchange(ref _disposed, true)) |
| | 0 | 102 | | { |
| | 0 | 103 | | if (NetEventSource.Log.IsEnabled()) Trace("Connection closing."); |
| | | 104 | | |
| | 0 | 105 | | MarkConnectionAsClosed(); |
| | | 106 | | |
| | 0 | 107 | | if (!_detachedFromPool) |
| | 0 | 108 | | { |
| | 0 | 109 | | _pool.InvalidateHttp11Connection(this, disposing); |
| | 0 | 110 | | } |
| | | 111 | | |
| | 0 | 112 | | if (disposing) |
| | 0 | 113 | | { |
| | 0 | 114 | | GC.SuppressFinalize(this); |
| | 0 | 115 | | _stream.Dispose(); |
| | 0 | 116 | | } |
| | 0 | 117 | | } |
| | 0 | 118 | | } |
| | | 119 | | |
| | | 120 | | private bool ReadAheadTaskHasStarted => |
| | 0 | 121 | | _readAheadTaskStatus != ReadAheadTask_NotStarted; |
| | | 122 | | |
| | | 123 | | /// <summary>Prepare an idle connection to be used for a new request. |
| | | 124 | | /// The caller MUST call SendAsync afterwards if this method returns true, or dispose the connection if it retur |
| | | 125 | | /// <param name="async">Indicates whether the coming request will be sync or async.</param> |
| | | 126 | | /// <returns>True if connection can be used, false if it is invalid due to a timeout or receiving EOF or unexpec |
| | | 127 | | public bool PrepareForReuse(bool async) |
| | 0 | 128 | | { |
| | 0 | 129 | | if (CheckKeepAliveTimeoutExceeded()) |
| | 0 | 130 | | { |
| | 0 | 131 | | return false; |
| | | 132 | | } |
| | | 133 | | |
| | | 134 | | // We may already have a read-ahead task if we did a previous scavenge and haven't used the connection since |
| | | 135 | | // If the read-ahead task is completed, then we've received either EOF or erroneous data the connection, so |
| | 0 | 136 | | if (ReadAheadTaskHasStarted) |
| | 0 | 137 | | { |
| | 0 | 138 | | Debug.Assert(_readAheadTaskStatus is ReadAheadTask_Started or ReadAheadTask_Completed); |
| | | 139 | | |
| | 0 | 140 | | return Interlocked.Exchange(ref _readAheadTaskStatus, ReadAheadTask_CompletionReserved) == ReadAheadTask |
| | | 141 | | } |
| | | 142 | | |
| | | 143 | | // Check to see if we've received anything on the connection; if we have, that's |
| | | 144 | | // either erroneous data (we shouldn't have received anything yet) or the connection |
| | | 145 | | // has been closed; either way, we can't use it. |
| | 0 | 146 | | if (!async && _stream is NetworkStream networkStream) |
| | 0 | 147 | | { |
| | | 148 | | // Directly poll the socket rather than doing an async read, so that we can |
| | | 149 | | // issue an appropriate sync read when we actually need it. |
| | | 150 | | try |
| | 0 | 151 | | { |
| | 0 | 152 | | return !networkStream.Socket.Poll(0, SelectMode.SelectRead); |
| | | 153 | | } |
| | 0 | 154 | | catch (Exception e) when (e is SocketException || e is ObjectDisposedException) |
| | 0 | 155 | | { |
| | | 156 | | // Poll can throw when used on a closed socket. |
| | 0 | 157 | | return false; |
| | | 158 | | } |
| | | 159 | | } |
| | | 160 | | else |
| | 0 | 161 | | { |
| | 0 | 162 | | Debug.Assert(_readAheadTaskStatus == ReadAheadTask_NotStarted); |
| | 0 | 163 | | _readAheadTaskStatus = ReadAheadTask_CompletionReserved; |
| | | 164 | | |
| | | 165 | | // Perform an async read on the stream, since we're going to need to read from it |
| | | 166 | | // anyway, and in doing so we can avoid the extra syscall. |
| | | 167 | | try |
| | 0 | 168 | | { |
| | | 169 | | #pragma warning disable CA2012 // we're very careful to ensure the ValueTask is only consumed once, even though it's sto |
| | 0 | 170 | | _readAheadTask = _stream.ReadAsync(_readBuffer.AvailableMemory); |
| | | 171 | | #pragma warning restore CA2012 |
| | | 172 | | |
| | | 173 | | // If the read-ahead task already completed, we can't reuse the connection. |
| | | 174 | | // We're still responsible for observing potential exceptions thrown by the read-ahead task to avoid |
| | 0 | 175 | | if (_readAheadTask.IsCompleted) |
| | 0 | 176 | | { |
| | 0 | 177 | | LogExceptions(_readAheadTask.AsTask()); |
| | 0 | 178 | | return false; |
| | | 179 | | } |
| | | 180 | | |
| | 0 | 181 | | return true; |
| | | 182 | | } |
| | 0 | 183 | | catch (Exception error) |
| | 0 | 184 | | { |
| | | 185 | | // If reading throws, eat the error and don't reuse the connection. |
| | 0 | 186 | | if (NetEventSource.Log.IsEnabled()) Trace($"Error performing read ahead: {error}"); |
| | 0 | 187 | | return false; |
| | | 188 | | } |
| | | 189 | | } |
| | 0 | 190 | | } |
| | | 191 | | |
| | | 192 | | /// <summary>Takes ownership of the scavenging task completion if it was started. |
| | | 193 | | /// The caller MUST call either SendAsync or return the completion ownership afterwards if this method returns t |
| | | 194 | | public bool TryOwnScavengingTaskCompletion() |
| | 0 | 195 | | { |
| | 0 | 196 | | Debug.Assert(_readAheadTaskStatus != ReadAheadTask_CompletionReserved); |
| | | 197 | | |
| | 0 | 198 | | return !ReadAheadTaskHasStarted |
| | 0 | 199 | | || Interlocked.Exchange(ref _readAheadTaskStatus, ReadAheadTask_CompletionReserved) == ReadAheadTask_Sta |
| | 0 | 200 | | } |
| | | 201 | | |
| | | 202 | | /// <summary>Returns ownership of the scavenging task completion if it was started. |
| | | 203 | | /// The caller MUST Dispose the connection afterwards if this method returns false.</summary> |
| | | 204 | | public bool TryReturnScavengingTaskCompletionOwnership() |
| | 0 | 205 | | { |
| | 0 | 206 | | Debug.Assert(_readAheadTaskStatus != ReadAheadTask_Started); |
| | | 207 | | |
| | 0 | 208 | | if (!ReadAheadTaskHasStarted || |
| | 0 | 209 | | Interlocked.Exchange(ref _readAheadTaskStatus, ReadAheadTask_Started) == ReadAheadTask_CompletionReserve |
| | 0 | 210 | | { |
| | 0 | 211 | | return true; |
| | | 212 | | } |
| | | 213 | | |
| | | 214 | | // The read-ahead task has started, and we failed to transition back to Started. |
| | | 215 | | // This means that the read-ahead task has completed, and we can't reuse the connection. The caller must dis |
| | | 216 | | // We're still responsible for observing potential exceptions thrown by the read-ahead task to avoid leaking |
| | 0 | 217 | | LogExceptions(_readAheadTask.AsTask()); |
| | 0 | 218 | | return false; |
| | 0 | 219 | | } |
| | | 220 | | |
| | | 221 | | /// <summary>Check whether a currently idle connection is still usable, or should be scavenged.</summary> |
| | | 222 | | /// <returns>True if connection can be used, false if it is invalid due to a timeout or receiving EOF or unexpec |
| | | 223 | | public override bool CheckUsabilityOnScavenge() |
| | 0 | 224 | | { |
| | 0 | 225 | | if (CheckKeepAliveTimeoutExceeded()) |
| | 0 | 226 | | { |
| | 0 | 227 | | return false; |
| | | 228 | | } |
| | | 229 | | |
| | | 230 | | // We may already have a read-ahead task if we did a previous scavenge and haven't used the connection since |
| | 0 | 231 | | if (!ReadAheadTaskHasStarted) |
| | 0 | 232 | | { |
| | 0 | 233 | | Debug.Assert(_readAheadTask == default); |
| | | 234 | | |
| | 0 | 235 | | _readAheadTaskStatus = ReadAheadTask_Started; |
| | | 236 | | |
| | | 237 | | #pragma warning disable CA2012 // we're very careful to ensure the ValueTask is only consumed once, even though it's sto |
| | 0 | 238 | | _readAheadTask = ReadAheadWithZeroByteReadAsync(); |
| | | 239 | | #pragma warning restore CA2012 |
| | 0 | 240 | | } |
| | | 241 | | |
| | | 242 | | // If the read-ahead task is completed, then we've received either EOF or erroneous data the connection, so |
| | 0 | 243 | | return !_readAheadTask.IsCompleted; |
| | | 244 | | |
| | | 245 | | async ValueTask<int> ReadAheadWithZeroByteReadAsync() |
| | 0 | 246 | | { |
| | 0 | 247 | | Debug.Assert(_readAheadTask == default); |
| | 0 | 248 | | Debug.Assert(_readBuffer.ActiveLength == 0); |
| | | 249 | | |
| | | 250 | | try |
| | 0 | 251 | | { |
| | | 252 | | // Issue a zero-byte read. |
| | | 253 | | // If the underlying stream supports it, this will not complete until the stream has data available, |
| | | 254 | | // which will avoid pinning the connection's read buffer (and possibly allow us to release it to the |
| | | 255 | | // If not, it will complete immediately. |
| | 0 | 256 | | await _stream.ReadAsync(Memory<byte>.Empty).ConfigureAwait(false); |
| | | 257 | | |
| | | 258 | | // We don't know for sure that the stream actually has data available, so we need to issue a real re |
| | 0 | 259 | | int read = await _stream.ReadAsync(_readBuffer.AvailableMemory).ConfigureAwait(false); |
| | | 260 | | |
| | | 261 | | // PrepareForReuse will check TryOwnReadAheadTaskCompletion before calling into SendAsync. |
| | | 262 | | // If we can own the completion from within the read-ahead task, it means that PrepareForReuse hasn' |
| | | 263 | | // In that case we've received EOF/erroneous data before we sent the request headers, and the connec |
| | 0 | 264 | | if (TransitionToCompletedAndTryOwnCompletion()) |
| | 0 | 265 | | { |
| | 0 | 266 | | if (NetEventSource.Log.IsEnabled()) Trace("Read-ahead task observed data before the request was |
| | 0 | 267 | | } |
| | | 268 | | |
| | 0 | 269 | | return read; |
| | | 270 | | } |
| | 0 | 271 | | catch (Exception error) when (TransitionToCompletedAndTryOwnCompletion()) |
| | 0 | 272 | | { |
| | 0 | 273 | | if (NetEventSource.Log.IsEnabled()) Trace($"Error performing read ahead: {error}"); |
| | | 274 | | |
| | 0 | 275 | | return 0; |
| | | 276 | | } |
| | | 277 | | |
| | | 278 | | bool TransitionToCompletedAndTryOwnCompletion() |
| | 0 | 279 | | { |
| | 0 | 280 | | Debug.Assert(_readAheadTaskStatus is ReadAheadTask_Started or ReadAheadTask_CompletionReserved); |
| | | 281 | | |
| | 0 | 282 | | return Interlocked.Exchange(ref _readAheadTaskStatus, ReadAheadTask_Completed) == ReadAheadTask_Star |
| | 0 | 283 | | } |
| | 0 | 284 | | } |
| | 0 | 285 | | } |
| | | 286 | | |
| | | 287 | | private bool CheckKeepAliveTimeoutExceeded() |
| | 0 | 288 | | { |
| | | 289 | | // We intentionally honor the Keep-Alive timeout on all HTTP/1.X versions, not just 1.0. This is to maximize |
| | | 290 | | // servers that use a lower idle timeout than the client, but give us a hint in the form of a Keep-Alive tim |
| | | 291 | | // If _keepAliveTimeoutSeconds is 0, no timeout has been set. |
| | 0 | 292 | | return _keepAliveTimeoutSeconds != 0 && |
| | 0 | 293 | | GetIdleTicks(Environment.TickCount64) >= _keepAliveTimeoutSeconds * 1000; |
| | 0 | 294 | | } |
| | | 295 | | |
| | 0 | 296 | | public TransportContext? TransportContext => _transportContext; |
| | | 297 | | |
| | 0 | 298 | | public HttpConnectionKind Kind => _pool.Kind; |
| | | 299 | | |
| | 0 | 300 | | private int ReadBufferSize => _readBuffer.Capacity; |
| | | 301 | | |
| | 0 | 302 | | private ReadOnlyMemory<byte> RemainingBuffer => _readBuffer.ActiveMemory; |
| | | 303 | | |
| | | 304 | | private void ConsumeFromRemainingBuffer(int bytesToConsume) |
| | 0 | 305 | | { |
| | 0 | 306 | | Debug.Assert(bytesToConsume <= _readBuffer.ActiveLength); |
| | 0 | 307 | | _readBuffer.Discard(bytesToConsume); |
| | 0 | 308 | | } |
| | | 309 | | |
| | | 310 | | private void WriteHeaders(HttpRequestMessage request) |
| | 0 | 311 | | { |
| | 0 | 312 | | Debug.Assert(request.RequestUri is not null); |
| | | 313 | | |
| | | 314 | | // Write the request line |
| | 0 | 315 | | WriteBytes(request.Method.Http1EncodedBytes); |
| | | 316 | | |
| | 0 | 317 | | if (request.Method.IsConnect) |
| | 0 | 318 | | { |
| | | 319 | | // RFC 7231 #section-4.3.6. |
| | | 320 | | // Write only CONNECT foo.com:345 HTTP/1.1 |
| | 0 | 321 | | if (!request.HasHeaders || request.Headers.Host is not string host) |
| | 0 | 322 | | { |
| | 0 | 323 | | throw new HttpRequestException(SR.net_http_request_no_host); |
| | | 324 | | } |
| | | 325 | | |
| | 0 | 326 | | WriteAsciiString(host); |
| | 0 | 327 | | } |
| | | 328 | | else |
| | 0 | 329 | | { |
| | 0 | 330 | | if (Kind == HttpConnectionKind.Proxy) |
| | 0 | 331 | | { |
| | | 332 | | // Proxied requests contain full URL |
| | 0 | 333 | | Debug.Assert(request.RequestUri.Scheme == Uri.UriSchemeHttp); |
| | 0 | 334 | | WriteBytes("http://"u8); |
| | 0 | 335 | | WriteHost(request.RequestUri); |
| | 0 | 336 | | } |
| | | 337 | | |
| | 0 | 338 | | WriteAsciiString(request.RequestUri.PathAndQuery); |
| | 0 | 339 | | } |
| | | 340 | | |
| | | 341 | | // Fall back to 1.1 for all versions other than 1.0 |
| | 0 | 342 | | Debug.Assert(request.Version.Major >= 0 && request.Version.Minor >= 0); // guaranteed by Version class |
| | 0 | 343 | | bool isHttp10 = request.Version.Minor == 0 && request.Version.Major == 1; |
| | 0 | 344 | | WriteBytes(isHttp10 ? " HTTP/1.0\r\n"u8 : " HTTP/1.1\r\n"u8); |
| | | 345 | | |
| | | 346 | | // Write special additional headers. If a host isn't in the headers list, then a Host header |
| | | 347 | | // wasn't set, so as it's required by HTTP 1.1 spec, send one based on the Request Uri. |
| | 0 | 348 | | if (!request.HasHeaders || request.Headers.Host is null) |
| | 0 | 349 | | { |
| | 0 | 350 | | if (_pool.HostHeaderLineBytes is byte[] hostHeaderLineBytes) |
| | 0 | 351 | | { |
| | 0 | 352 | | Debug.Assert(Kind != HttpConnectionKind.Proxy); |
| | 0 | 353 | | WriteBytes(hostHeaderLineBytes); |
| | 0 | 354 | | } |
| | | 355 | | else |
| | 0 | 356 | | { |
| | 0 | 357 | | Debug.Assert(Kind == HttpConnectionKind.Proxy); |
| | 0 | 358 | | WriteBytes(KnownHeaders.Host.AsciiBytesWithColonSpace); |
| | 0 | 359 | | WriteHost(request.RequestUri); |
| | 0 | 360 | | WriteCRLF(); |
| | 0 | 361 | | } |
| | 0 | 362 | | } |
| | | 363 | | |
| | | 364 | | // Determine cookies to send |
| | 0 | 365 | | string? cookiesFromContainer = null; |
| | 0 | 366 | | if (_pool.Settings._useCookies) |
| | 0 | 367 | | { |
| | 0 | 368 | | cookiesFromContainer = _pool.Settings._cookieContainer!.GetCookieHeader(request.RequestUri); |
| | 0 | 369 | | if (cookiesFromContainer == "") |
| | 0 | 370 | | { |
| | 0 | 371 | | cookiesFromContainer = null; |
| | 0 | 372 | | } |
| | 0 | 373 | | } |
| | | 374 | | |
| | | 375 | | // Write request headers |
| | 0 | 376 | | if (request.HasHeaders || cookiesFromContainer is not null) |
| | 0 | 377 | | { |
| | 0 | 378 | | WriteHeaderCollection(request.Headers, cookiesFromContainer); |
| | 0 | 379 | | } |
| | | 380 | | |
| | | 381 | | // Write content headers |
| | 0 | 382 | | if (request.Content is HttpContent content) |
| | 0 | 383 | | { |
| | 0 | 384 | | WriteHeaderCollection(content.Headers); |
| | 0 | 385 | | } |
| | | 386 | | else |
| | 0 | 387 | | { |
| | | 388 | | // Write out Content-Length: 0 header to indicate no body, |
| | | 389 | | // unless this is a method that never has a body. |
| | 0 | 390 | | if (request.Method.MustHaveRequestBody) |
| | 0 | 391 | | { |
| | 0 | 392 | | WriteBytes("Content-Length: 0\r\n"u8); |
| | 0 | 393 | | } |
| | 0 | 394 | | } |
| | | 395 | | |
| | | 396 | | // CRLF for end of headers. |
| | 0 | 397 | | WriteCRLF(); |
| | | 398 | | |
| | | 399 | | void WriteHost(Uri requestUri) |
| | 0 | 400 | | { |
| | | 401 | | // Uri.IdnHost is missing '[', ']' characters around IPv6 address |
| | | 402 | | // and it also contains ScopeID for Link-Local addresses |
| | 0 | 403 | | string host = requestUri.HostNameType == UriHostNameType.IPv6 ? requestUri.Host : requestUri.IdnHost; |
| | 0 | 404 | | WriteAsciiString(host); |
| | | 405 | | |
| | 0 | 406 | | if (!requestUri.IsDefaultPort) |
| | 0 | 407 | | { |
| | 0 | 408 | | _writeBuffer.EnsureAvailableSpace(6); |
| | 0 | 409 | | Span<byte> buffer = _writeBuffer.AvailableSpan; |
| | 0 | 410 | | buffer[0] = (byte)':'; |
| | 0 | 411 | | bool success = ((uint)requestUri.Port).TryFormat(buffer.Slice(1), out int bytesWritten); |
| | 0 | 412 | | Debug.Assert(success); |
| | 0 | 413 | | _writeBuffer.Commit(bytesWritten + 1); |
| | 0 | 414 | | } |
| | 0 | 415 | | } |
| | 0 | 416 | | } |
| | | 417 | | |
| | | 418 | | private void WriteHeaderCollection(HttpHeaders headers, string? cookiesFromContainer = null) |
| | 0 | 419 | | { |
| | 0 | 420 | | Debug.Assert(_currentRequest is not null); |
| | | 421 | | |
| | 0 | 422 | | HeaderEncodingSelector<HttpRequestMessage>? encodingSelector = _pool.Settings._requestHeaderEncodingSelector |
| | 0 | 423 | | ref string[]? headerValues = ref t_headerValues; |
| | | 424 | | |
| | 0 | 425 | | foreach (HeaderEntry header in headers.GetEntries()) |
| | 0 | 426 | | { |
| | 0 | 427 | | if (header.Key.KnownHeader is KnownHeader knownHeader) |
| | 0 | 428 | | { |
| | 0 | 429 | | WriteBytes(knownHeader.AsciiBytesWithColonSpace); |
| | 0 | 430 | | } |
| | | 431 | | else |
| | 0 | 432 | | { |
| | 0 | 433 | | WriteAsciiString(header.Key.Name); |
| | 0 | 434 | | WriteBytes(": "u8); |
| | 0 | 435 | | } |
| | | 436 | | |
| | 0 | 437 | | int headerValuesCount = HttpHeaders.GetStoreValuesIntoStringArray(header.Key, header.Value, ref headerVa |
| | 0 | 438 | | Debug.Assert(headerValuesCount > 0, "No values for header??"); |
| | | 439 | | |
| | 0 | 440 | | Encoding? valueEncoding = encodingSelector?.Invoke(header.Key.Name, _currentRequest); |
| | | 441 | | |
| | 0 | 442 | | WriteString(headerValues[0], valueEncoding); |
| | | 443 | | |
| | 0 | 444 | | if (cookiesFromContainer is not null && header.Key.Equals(KnownHeaders.Cookie)) |
| | 0 | 445 | | { |
| | 0 | 446 | | WriteBytes("; "u8); // Cookies use "; " as the separator |
| | 0 | 447 | | WriteString(cookiesFromContainer, valueEncoding); |
| | 0 | 448 | | cookiesFromContainer = null; |
| | 0 | 449 | | } |
| | | 450 | | |
| | | 451 | | // Some headers such as User-Agent and Server use space as a separator (see: ProductInfoHeaderParser) |
| | 0 | 452 | | if (headerValuesCount > 1) |
| | 0 | 453 | | { |
| | 0 | 454 | | byte[] separator = header.Key.SeparatorBytes; |
| | | 455 | | |
| | 0 | 456 | | for (int i = 1; i < headerValuesCount; i++) |
| | 0 | 457 | | { |
| | 0 | 458 | | WriteBytes(separator); |
| | 0 | 459 | | WriteString(headerValues[i], valueEncoding); |
| | 0 | 460 | | } |
| | 0 | 461 | | } |
| | | 462 | | |
| | 0 | 463 | | WriteCRLF(); |
| | 0 | 464 | | } |
| | | 465 | | |
| | 0 | 466 | | if (cookiesFromContainer is not null) |
| | 0 | 467 | | { |
| | 0 | 468 | | WriteBytes(KnownHeaders.Cookie.AsciiBytesWithColonSpace); |
| | 0 | 469 | | WriteString(cookiesFromContainer, encodingSelector?.Invoke(HttpKnownHeaderNames.Cookie, _currentRequest) |
| | 0 | 470 | | WriteCRLF(); |
| | 0 | 471 | | } |
| | 0 | 472 | | } |
| | | 473 | | |
| | | 474 | | private void WriteCRLF() |
| | 0 | 475 | | { |
| | 0 | 476 | | _writeBuffer.EnsureAvailableSpace(2); |
| | 0 | 477 | | Span<byte> buffer = _writeBuffer.AvailableSpan; |
| | 0 | 478 | | buffer[1] = (byte)'\n'; |
| | 0 | 479 | | buffer[0] = (byte)'\r'; |
| | 0 | 480 | | _writeBuffer.Commit(2); |
| | 0 | 481 | | } |
| | | 482 | | |
| | | 483 | | private void WriteBytes(ReadOnlySpan<byte> bytes) |
| | 0 | 484 | | { |
| | 0 | 485 | | _writeBuffer.EnsureAvailableSpace(bytes.Length); |
| | 0 | 486 | | bytes.CopyTo(_writeBuffer.AvailableSpan); |
| | 0 | 487 | | _writeBuffer.Commit(bytes.Length); |
| | 0 | 488 | | } |
| | | 489 | | |
| | | 490 | | private void WriteAsciiString(string s) |
| | 0 | 491 | | { |
| | 0 | 492 | | Debug.Assert(Ascii.IsValid(s)); |
| | | 493 | | |
| | 0 | 494 | | _writeBuffer.EnsureAvailableSpace(s.Length); |
| | | 495 | | |
| | 0 | 496 | | OperationStatus status = Ascii.FromUtf16(s, _writeBuffer.AvailableSpan, out int bytesWritten); |
| | 0 | 497 | | Debug.Assert(status == OperationStatus.Done); |
| | 0 | 498 | | Debug.Assert(bytesWritten == s.Length); |
| | | 499 | | |
| | 0 | 500 | | _writeBuffer.Commit(bytesWritten); |
| | 0 | 501 | | } |
| | | 502 | | |
| | | 503 | | private void WriteString(string s, Encoding? encoding) |
| | 0 | 504 | | { |
| | 0 | 505 | | if (encoding is null) |
| | 0 | 506 | | { |
| | 0 | 507 | | _writeBuffer.EnsureAvailableSpace(s.Length); |
| | 0 | 508 | | Span<byte> buffer = _writeBuffer.AvailableSpan; |
| | | 509 | | |
| | 0 | 510 | | OperationStatus status = Ascii.FromUtf16(s, buffer, out int bytesWritten); |
| | | 511 | | |
| | 0 | 512 | | if (status == OperationStatus.InvalidData) |
| | 0 | 513 | | { |
| | 0 | 514 | | ThrowForInvalidCharEncoding(); |
| | 0 | 515 | | } |
| | | 516 | | |
| | 0 | 517 | | Debug.Assert(status == OperationStatus.Done); |
| | 0 | 518 | | Debug.Assert(bytesWritten == s.Length); |
| | | 519 | | |
| | 0 | 520 | | _writeBuffer.Commit(s.Length); |
| | 0 | 521 | | } |
| | | 522 | | else |
| | 0 | 523 | | { |
| | 0 | 524 | | _writeBuffer.EnsureAvailableSpace(encoding.GetMaxByteCount(s.Length)); |
| | 0 | 525 | | int length = encoding.GetBytes(s, _writeBuffer.AvailableSpan); |
| | 0 | 526 | | _writeBuffer.Commit(length); |
| | 0 | 527 | | } |
| | | 528 | | |
| | | 529 | | static void ThrowForInvalidCharEncoding() => |
| | 0 | 530 | | throw new HttpRequestException(SR.net_http_request_invalid_char_encoding); |
| | 0 | 531 | | } |
| | | 532 | | |
| | | 533 | | public async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool async, CancellationToken cance |
| | 0 | 534 | | { |
| | 0 | 535 | | request.ConnectionId = Id; |
| | | 536 | | |
| | 0 | 537 | | Debug.Assert(_currentRequest == null, $"Expected null {nameof(_currentRequest)}."); |
| | 0 | 538 | | Debug.Assert(_readBuffer.ActiveLength == 0, "Unexpected data in read buffer"); |
| | 0 | 539 | | Debug.Assert(_readAheadTaskStatus != ReadAheadTask_Started, |
| | 0 | 540 | | "The caller should have called PrepareForReuse or TryOwnScavengingTaskCompletion if the connection was i |
| | | 541 | | |
| | 0 | 542 | | MarkConnectionAsNotIdle(); |
| | | 543 | | |
| | 0 | 544 | | TaskCompletionSource<bool>? allowExpect100ToContinue = null; |
| | 0 | 545 | | Task? sendRequestContentTask = null; |
| | | 546 | | |
| | 0 | 547 | | _currentRequest = request; |
| | | 548 | | |
| | 0 | 549 | | _canRetry = false; |
| | | 550 | | |
| | | 551 | | // Send the request. |
| | 0 | 552 | | if (NetEventSource.Log.IsEnabled()) Trace($"Sending request: {request}"); |
| | 0 | 553 | | if (ConnectionSetupActivity is not null) ConnectionSetupDistributedTracing.AddConnectionLinkToRequestActivit |
| | 0 | 554 | | CancellationTokenRegistration cancellationRegistration = RegisterCancellation(cancellationToken); |
| | | 555 | | try |
| | 0 | 556 | | { |
| | 0 | 557 | | if (HttpTelemetry.Log.IsEnabled()) HttpTelemetry.Log.RequestHeadersStart(Id); |
| | | 558 | | |
| | 0 | 559 | | WriteHeaders(request); |
| | | 560 | | |
| | 0 | 561 | | if (HttpTelemetry.Log.IsEnabled()) HttpTelemetry.Log.RequestHeadersStop(); |
| | | 562 | | |
| | 0 | 563 | | if (request.Content == null) |
| | 0 | 564 | | { |
| | | 565 | | // We have nothing more to send, so flush out any headers we haven't yet sent. |
| | 0 | 566 | | await FlushAsync(async).ConfigureAwait(false); |
| | 0 | 567 | | } |
| | | 568 | | else |
| | 0 | 569 | | { |
| | 0 | 570 | | bool hasExpectContinueHeader = request.HasHeaders && request.Headers.ExpectContinue == true; |
| | 0 | 571 | | if (NetEventSource.Log.IsEnabled()) Trace($"Request content is not null, start processing it. hasExp |
| | | 572 | | |
| | | 573 | | // Send the body if there is one. We prefer to serialize the sending of the content before |
| | | 574 | | // we try to receive any response, but if ExpectContinue has been set, we allow the sending |
| | | 575 | | // to run concurrently until we receive the final status line, at which point we wait for it. |
| | 0 | 576 | | if (!hasExpectContinueHeader) |
| | 0 | 577 | | { |
| | 0 | 578 | | await SendRequestContentAsync(request, CreateRequestContentStream(request), async, cancellationT |
| | 0 | 579 | | } |
| | | 580 | | else |
| | 0 | 581 | | { |
| | | 582 | | // We're sending an Expect: 100-continue header. We need to flush headers so that the server rec |
| | | 583 | | // all of them, and we need to do so before initiating the send, as once we do that, it effectiv |
| | | 584 | | // owns the right to write, and we don't want to concurrently be accessing the write buffer. |
| | 0 | 585 | | await FlushAsync(async).ConfigureAwait(false); |
| | | 586 | | |
| | | 587 | | // Create a TCS we'll use to block the request content from being sent, and create a timer that' |
| | | 588 | | // as a fail-safe to unblock the request content if we don't hear back from the server in a time |
| | | 589 | | // Then kick off the request. The TCS' result indicates whether content should be sent or not. |
| | 0 | 590 | | allowExpect100ToContinue = new TaskCompletionSource<bool>(); |
| | 0 | 591 | | var expect100Timer = new Timer( |
| | 0 | 592 | | static s => ((TaskCompletionSource<bool>)s!).TrySetResult(true), |
| | 0 | 593 | | allowExpect100ToContinue, _pool.Settings._expect100ContinueTimeout, Timeout.InfiniteTimeSpan |
| | | 594 | | #pragma warning disable CA2025 |
| | 0 | 595 | | sendRequestContentTask = SendRequestContentWithExpect100ContinueAsync( |
| | 0 | 596 | | request, allowExpect100ToContinue.Task, CreateRequestContentStream(request), expect100Timer, |
| | | 597 | | #pragma warning restore |
| | 0 | 598 | | } |
| | 0 | 599 | | } |
| | | 600 | | |
| | | 601 | | // Start to read response. |
| | 0 | 602 | | _allowedReadLineBytes = _pool.Settings.MaxResponseHeadersByteLength; |
| | | 603 | | |
| | | 604 | | // We should not have any buffered data here; if there was, it should have been treated as an error |
| | | 605 | | // by the previous request handling. (Note we do not support HTTP pipelining.) |
| | 0 | 606 | | Debug.Assert(_readBuffer.ActiveLength == 0); |
| | | 607 | | |
| | | 608 | | // When the connection was taken out of the pool, a pre-emptive read was performed |
| | | 609 | | // into the read buffer. We need to consume that read prior to issuing another read. |
| | 0 | 610 | | if (ReadAheadTaskHasStarted) |
| | 0 | 611 | | { |
| | | 612 | | // If the read-ahead task completed synchronously, it would have claimed ownership of its completion |
| | | 613 | | // meaning that PrepareForReuse would have failed, and we wouldn't have called SendAsync. |
| | | 614 | | // The task therefore shouldn't be 'default', as it's representing an async operation that had to yi |
| | 0 | 615 | | Debug.Assert(_readAheadTask != default); |
| | 0 | 616 | | Debug.Assert(_readAheadTaskStatus is ReadAheadTask_CompletionReserved or ReadAheadTask_Completed); |
| | | 617 | | |
| | | 618 | | // Handle the pre-emptive read. For the async==false case, hopefully the read has |
| | | 619 | | // already completed and this will be a nop, but if it hasn't, the caller will be forced to block |
| | | 620 | | // waiting for the async operation to complete. We will only hit this case for proxied HTTPS |
| | | 621 | | // requests that use a pooled connection, as in that case we don't have a Socket we |
| | | 622 | | // can poll and are forced to issue an async read. |
| | 0 | 623 | | ValueTask<int> vt = _readAheadTask; |
| | 0 | 624 | | _readAheadTask = default; |
| | | 625 | | |
| | | 626 | | int bytesRead; |
| | 0 | 627 | | if (vt.IsCompleted) |
| | 0 | 628 | | { |
| | 0 | 629 | | bytesRead = vt.Result; |
| | 0 | 630 | | } |
| | | 631 | | else |
| | 0 | 632 | | { |
| | 0 | 633 | | if (NetEventSource.Log.IsEnabled() && !async) |
| | 0 | 634 | | { |
| | 0 | 635 | | Trace($"Pre-emptive read completed asynchronously for a synchronous request."); |
| | 0 | 636 | | } |
| | | 637 | | |
| | 0 | 638 | | bytesRead = await vt.ConfigureAwait(false); |
| | 0 | 639 | | } |
| | | 640 | | |
| | 0 | 641 | | _readBuffer.Commit(bytesRead); |
| | | 642 | | |
| | 0 | 643 | | if (NetEventSource.Log.IsEnabled()) Trace($"Received {bytesRead} bytes."); |
| | | 644 | | |
| | 0 | 645 | | _readAheadTaskStatus = ReadAheadTask_NotStarted; |
| | 0 | 646 | | } |
| | | 647 | | else |
| | 0 | 648 | | { |
| | | 649 | | // No read-ahead, so issue a read ourselves. We will check below for EOF. |
| | 0 | 650 | | await InitialFillAsync(async).ConfigureAwait(false); |
| | 0 | 651 | | } |
| | | 652 | | |
| | 0 | 653 | | if (_readBuffer.ActiveLength == 0) |
| | 0 | 654 | | { |
| | | 655 | | // The server shutdown the connection on their end, likely because of an idle timeout. |
| | | 656 | | // If we haven't started sending the request body yet (or there is no request body), |
| | | 657 | | // then we allow the request to be retried. |
| | 0 | 658 | | if (request.Content is null || allowExpect100ToContinue is not null) |
| | 0 | 659 | | { |
| | 0 | 660 | | _canRetry = true; |
| | 0 | 661 | | } |
| | | 662 | | |
| | 0 | 663 | | throw new HttpIOException(HttpRequestError.ResponseEnded, SR.net_http_invalid_response_premature_eof |
| | | 664 | | } |
| | | 665 | | |
| | | 666 | | |
| | | 667 | | // Parse the response status line. |
| | 0 | 668 | | var response = new HttpResponseMessage() { RequestMessage = request, Content = new HttpConnectionRespons |
| | | 669 | | |
| | 0 | 670 | | while (!ParseStatusLine(response)) |
| | 0 | 671 | | { |
| | 0 | 672 | | await FillForHeadersAsync(async).ConfigureAwait(false); |
| | 0 | 673 | | } |
| | | 674 | | |
| | 0 | 675 | | if (HttpTelemetry.Log.IsEnabled()) HttpTelemetry.Log.ResponseHeadersStart(); |
| | | 676 | | |
| | | 677 | | // Multiple 1xx responses handling. |
| | | 678 | | // RFC 7231: A client MUST be able to parse one or more 1xx responses received prior to a final response |
| | | 679 | | // even if the client does not expect one. A user agent MAY ignore unexpected 1xx responses. |
| | | 680 | | // In .NET Core, apart from 100 Continue, and 101 Switching Protocols, we will treat all other 1xx respo |
| | | 681 | | // as unknown, and will discard them. |
| | 0 | 682 | | while ((uint)(response.StatusCode - 100) <= 199 - 100) |
| | 0 | 683 | | { |
| | | 684 | | // If other 1xx responses come before an expected 100 continue, we will wait for the 100 response be |
| | | 685 | | // sending request body (if any). |
| | 0 | 686 | | if (allowExpect100ToContinue != null && response.StatusCode == HttpStatusCode.Continue) |
| | 0 | 687 | | { |
| | 0 | 688 | | allowExpect100ToContinue.TrySetResult(true); |
| | 0 | 689 | | allowExpect100ToContinue = null; |
| | 0 | 690 | | } |
| | 0 | 691 | | else if (response.StatusCode == HttpStatusCode.SwitchingProtocols) |
| | 0 | 692 | | { |
| | | 693 | | // 101 Upgrade is a final response as it's used to switch protocols with WebSockets handshake. |
| | | 694 | | // Will return a response object with status 101 and a raw connection stream later. |
| | | 695 | | // RFC 7230: If a server receives both an Upgrade and an Expect header field with the "100-conti |
| | | 696 | | // the server MUST send a 100 (Continue) response before sending a 101 (Switching Protocols) res |
| | | 697 | | // If server doesn't follow RFC, we treat 101 as a final response and stop waiting for 100 conti |
| | | 698 | | // never sends a 100-continue. The request body will be sent after expect100Timer expires. |
| | 0 | 699 | | break; |
| | | 700 | | } |
| | | 701 | | |
| | | 702 | | // In case read hangs which eventually leads to connection timeout. |
| | 0 | 703 | | if (NetEventSource.Log.IsEnabled()) Trace($"Current {response.StatusCode} response is an interim res |
| | | 704 | | |
| | | 705 | | // Discard headers that come with the interim 1xx responses. |
| | 0 | 706 | | while (!ParseHeaders(response: null, isFromTrailer: false)) |
| | 0 | 707 | | { |
| | 0 | 708 | | await FillForHeadersAsync(async).ConfigureAwait(false); |
| | 0 | 709 | | } |
| | | 710 | | |
| | | 711 | | // Parse the status line for next response. |
| | 0 | 712 | | while (!ParseStatusLine(response)) |
| | 0 | 713 | | { |
| | 0 | 714 | | await FillForHeadersAsync(async).ConfigureAwait(false); |
| | 0 | 715 | | } |
| | 0 | 716 | | } |
| | | 717 | | |
| | | 718 | | // Parse the response headers. Logic after this point depends on being able to examine headers in the r |
| | 0 | 719 | | while (!ParseHeaders(response, isFromTrailer: false)) |
| | 0 | 720 | | { |
| | 0 | 721 | | await FillForHeadersAsync(async).ConfigureAwait(false); |
| | 0 | 722 | | } |
| | | 723 | | |
| | 0 | 724 | | if (HttpTelemetry.Log.IsEnabled()) HttpTelemetry.Log.ResponseHeadersStop((int)response.StatusCode); |
| | | 725 | | |
| | 0 | 726 | | if (allowExpect100ToContinue != null) |
| | 0 | 727 | | { |
| | | 728 | | // If we sent an Expect: 100-continue header, and didn't receive a 100-continue. Handle the final re |
| | | 729 | | // Note that the developer may have added an Expect: 100-continue header even if there is no Content |
| | 0 | 730 | | if ((int)response.StatusCode >= 300 && |
| | 0 | 731 | | request.Content != null && |
| | 0 | 732 | | (request.Content.Headers.ContentLength == null || request.Content.Headers.ContentLength.GetValue |
| | 0 | 733 | | !AuthenticationHelper.IsSessionAuthenticationChallenge(response)) |
| | 0 | 734 | | { |
| | | 735 | | // For error final status codes, try to avoid sending the payload if its size is unknown or if i |
| | | 736 | | // If we already sent a header detailing the size of the payload, if we then don't send that pay |
| | | 737 | | // for it and assume that the next request on the connection is actually this request's payload. |
| | | 738 | | // to be closed. However, we may have also lost a race condition with the Expect: 100-continue |
| | | 739 | | // we've already started sending the payload (we weren't able to cancel it), then we don't need |
| | | 740 | | // We also must not clone connection if we do NTLM or Negotiate authentication. |
| | 0 | 741 | | allowExpect100ToContinue.TrySetResult(false); |
| | | 742 | | |
| | 0 | 743 | | if (!allowExpect100ToContinue.Task.Result) // if Result is true, the timeout already expired and |
| | 0 | 744 | | { |
| | 0 | 745 | | _connectionClose = true; |
| | 0 | 746 | | } |
| | 0 | 747 | | } |
| | | 748 | | else |
| | 0 | 749 | | { |
| | | 750 | | // For any success status codes, for errors when the request content length is known to be small |
| | | 751 | | // or for session-based authentication challenges, send the payload |
| | | 752 | | // (if there is one... if there isn't, Content is null and thus allowExpect100ToContinue is also |
| | 0 | 753 | | allowExpect100ToContinue.TrySetResult(true); |
| | 0 | 754 | | } |
| | 0 | 755 | | } |
| | | 756 | | |
| | | 757 | | // Determine whether we need to force close the connection when the request/response has completed. |
| | 0 | 758 | | if (response.Headers.ConnectionClose.GetValueOrDefault()) |
| | 0 | 759 | | { |
| | 0 | 760 | | _connectionClose = true; |
| | 0 | 761 | | } |
| | | 762 | | |
| | | 763 | | // Now that we've received our final status line, wait for the request content to fully send. |
| | | 764 | | // In most common scenarios, the server won't send back a response until all of the request |
| | | 765 | | // content has been received, so this task should generally already be complete. |
| | 0 | 766 | | if (sendRequestContentTask != null) |
| | 0 | 767 | | { |
| | 0 | 768 | | Task sendTask = sendRequestContentTask; |
| | 0 | 769 | | sendRequestContentTask = null; |
| | 0 | 770 | | await sendTask.ConfigureAwait(false); |
| | 0 | 771 | | } |
| | | 772 | | |
| | | 773 | | // Now we are sure that the request was fully sent. |
| | 0 | 774 | | if (NetEventSource.Log.IsEnabled()) Trace("Request is fully sent."); |
| | | 775 | | |
| | | 776 | | // We're about to create the response stream, at which point responsibility for canceling |
| | | 777 | | // the remainder of the response lies with the stream. Thus we dispose of our registration |
| | | 778 | | // here (if an exception has occurred or does occur while creating/returning the stream, |
| | | 779 | | // we'll still dispose of it in the catch below as part of Dispose'ing the connection). |
| | 0 | 780 | | cancellationRegistration.Dispose(); |
| | 0 | 781 | | CancellationHelper.ThrowIfCancellationRequested(cancellationToken); // in case cancellation may have dis |
| | | 782 | | |
| | | 783 | | // Create the response stream. |
| | | 784 | | Stream responseStream; |
| | 0 | 785 | | if (request.Method.IsConnect && response.IsSuccessStatusCode) |
| | 0 | 786 | | { |
| | | 787 | | // Successful response to CONNECT does not have body. |
| | | 788 | | // What ever comes next should be opaque. |
| | 0 | 789 | | responseStream = new RawConnectionStream(this); |
| | | 790 | | |
| | | 791 | | // Don't put connection back to the pool if we upgraded to tunnel. |
| | | 792 | | // We cannot use it for normal HTTP requests any more. |
| | 0 | 793 | | _connectionClose = true; |
| | | 794 | | |
| | 0 | 795 | | _pool.InvalidateHttp11Connection(this); |
| | 0 | 796 | | _detachedFromPool = true; |
| | 0 | 797 | | } |
| | 0 | 798 | | else if (request.Method.IsHead || response.StatusCode is HttpStatusCode.NoContent or HttpStatusCode.NotM |
| | 0 | 799 | | { |
| | 0 | 800 | | responseStream = EmptyReadStream.Instance; |
| | 0 | 801 | | CompleteResponse(); |
| | 0 | 802 | | } |
| | 0 | 803 | | else if (response.StatusCode == HttpStatusCode.SwitchingProtocols) |
| | 0 | 804 | | { |
| | 0 | 805 | | responseStream = new RawConnectionStream(this); |
| | | 806 | | |
| | | 807 | | // Don't put connection back to the pool if we switched protocols. |
| | | 808 | | // We cannot use it for normal HTTP requests any more. |
| | 0 | 809 | | _connectionClose = true; |
| | | 810 | | |
| | 0 | 811 | | _pool.InvalidateHttp11Connection(this); |
| | 0 | 812 | | _detachedFromPool = true; |
| | 0 | 813 | | } |
| | 0 | 814 | | else if (response.Headers.TransferEncodingChunked == true) |
| | 0 | 815 | | { |
| | 0 | 816 | | responseStream = new ChunkedEncodingReadStream(this, response); |
| | 0 | 817 | | } |
| | 0 | 818 | | else if (response.Content.Headers.ContentLength != null) |
| | 0 | 819 | | { |
| | 0 | 820 | | long contentLength = response.Content.Headers.ContentLength.GetValueOrDefault(); |
| | 0 | 821 | | if (contentLength <= 0) |
| | 0 | 822 | | { |
| | 0 | 823 | | responseStream = EmptyReadStream.Instance; |
| | 0 | 824 | | CompleteResponse(); |
| | 0 | 825 | | } |
| | | 826 | | else |
| | 0 | 827 | | { |
| | 0 | 828 | | responseStream = new ContentLengthReadStream(this, (ulong)contentLength); |
| | 0 | 829 | | } |
| | 0 | 830 | | } |
| | | 831 | | else |
| | 0 | 832 | | { |
| | 0 | 833 | | responseStream = new ConnectionCloseReadStream(this); |
| | 0 | 834 | | } |
| | 0 | 835 | | ((HttpConnectionResponseContent)response.Content).SetStream(responseStream); |
| | | 836 | | |
| | 0 | 837 | | if (NetEventSource.Log.IsEnabled()) Trace($"Received response: {response}"); |
| | | 838 | | |
| | | 839 | | // Process Set-Cookie headers. |
| | 0 | 840 | | if (_pool.Settings._useCookies) |
| | 0 | 841 | | { |
| | 0 | 842 | | CookieHelper.ProcessReceivedCookies(response, _pool.Settings._cookieContainer!); |
| | 0 | 843 | | } |
| | | 844 | | |
| | 0 | 845 | | return response; |
| | | 846 | | } |
| | 0 | 847 | | catch (Exception error) |
| | 0 | 848 | | { |
| | | 849 | | // Clean up the cancellation registration in case we're still registered. |
| | 0 | 850 | | cancellationRegistration.Dispose(); |
| | | 851 | | |
| | | 852 | | // Make sure to complete the allowExpect100ToContinue task if it exists. |
| | 0 | 853 | | if (allowExpect100ToContinue is not null && !allowExpect100ToContinue.TrySetResult(false)) |
| | 0 | 854 | | { |
| | | 855 | | // allowExpect100ToContinue was already signaled and we may have started sending the request body. |
| | 0 | 856 | | _canRetry = false; |
| | 0 | 857 | | } |
| | | 858 | | |
| | 0 | 859 | | if (_readAheadTask != default) |
| | 0 | 860 | | { |
| | 0 | 861 | | Debug.Assert(_readAheadTaskStatus is ReadAheadTask_CompletionReserved or ReadAheadTask_Completed); |
| | | 862 | | |
| | 0 | 863 | | LogExceptions(_readAheadTask.AsTask()); |
| | 0 | 864 | | } |
| | | 865 | | |
| | 0 | 866 | | if (NetEventSource.Log.IsEnabled()) Trace($"Error sending request: {error}"); |
| | | 867 | | |
| | | 868 | | // In the rare case where Expect: 100-continue was used and then processing |
| | | 869 | | // of the response headers encountered an error such that we weren't able to |
| | | 870 | | // wait for the sending to complete, it's possible the sending also encountered |
| | | 871 | | // an exception or potentially is still going and will encounter an exception |
| | | 872 | | // (we're about to Dispose for the connection). In such cases, we don't want any |
| | | 873 | | // exception in that sending task to become unobserved and raise alarm bells, so we |
| | | 874 | | // hook up a continuation that will log it. |
| | 0 | 875 | | if (sendRequestContentTask != null && !sendRequestContentTask.IsCompletedSuccessfully) |
| | 0 | 876 | | { |
| | | 877 | | // In case the connection is disposed, it's most probable that |
| | | 878 | | // expect100Continue timer expired and request content sending failed. |
| | | 879 | | // We're awaiting the task to propagate the exception in this case. |
| | 0 | 880 | | if (_disposed) |
| | 0 | 881 | | { |
| | | 882 | | try |
| | 0 | 883 | | { |
| | 0 | 884 | | await sendRequestContentTask.ConfigureAwait(false); |
| | 0 | 885 | | } |
| | | 886 | | // Map the exception the same way as we normally do. |
| | 0 | 887 | | catch (Exception ex) when (MapSendException(ex, cancellationToken, out Exception mappedEx)) |
| | 0 | 888 | | { |
| | 0 | 889 | | throw mappedEx; |
| | | 890 | | } |
| | 0 | 891 | | } |
| | 0 | 892 | | LogExceptions(sendRequestContentTask); |
| | 0 | 893 | | } |
| | | 894 | | |
| | | 895 | | // Now clean up the connection. |
| | 0 | 896 | | Dispose(); |
| | | 897 | | |
| | | 898 | | // At this point, we're going to throw an exception; we just need to |
| | | 899 | | // determine which exception to throw. |
| | 0 | 900 | | if (MapSendException(error, cancellationToken, out Exception mappedException)) |
| | 0 | 901 | | { |
| | 0 | 902 | | throw mappedException; |
| | | 903 | | } |
| | | 904 | | // Otherwise, just allow the original exception to propagate. |
| | 0 | 905 | | throw; |
| | | 906 | | } |
| | 0 | 907 | | } |
| | | 908 | | |
| | | 909 | | private bool MapSendException(Exception exception, CancellationToken cancellationToken, out Exception mappedExce |
| | 0 | 910 | | { |
| | 0 | 911 | | if (CancellationHelper.ShouldWrapInOperationCanceledException(exception, cancellationToken)) |
| | 0 | 912 | | { |
| | | 913 | | // Cancellation was requested, so assume that the failure is due to |
| | | 914 | | // the cancellation request. This is a bit unorthodox, as usually we'd |
| | | 915 | | // prioritize a non-OperationCanceledException over a cancellation |
| | | 916 | | // request to avoid losing potentially pertinent information. But given |
| | | 917 | | // the cancellation design where we tear down the underlying connection upon |
| | | 918 | | // a cancellation request, which can then result in a myriad of different |
| | | 919 | | // exceptions (argument exceptions, object disposed exceptions, socket exceptions, |
| | | 920 | | // etc.), as a middle ground we treat it as cancellation, but still propagate the |
| | | 921 | | // original information as the inner exception, for diagnostic purposes. |
| | 0 | 922 | | mappedException = CancellationHelper.CreateOperationCanceledException(exception, cancellationToken); |
| | 0 | 923 | | return true; |
| | | 924 | | } |
| | | 925 | | |
| | 0 | 926 | | if (exception is InvalidOperationException) |
| | 0 | 927 | | { |
| | | 928 | | // For consistency with other handlers we wrap the exception in an HttpRequestException. |
| | 0 | 929 | | mappedException = new HttpRequestException(SR.net_http_client_execution_error, exception); |
| | 0 | 930 | | return true; |
| | | 931 | | } |
| | | 932 | | |
| | 0 | 933 | | if (exception is IOException ioe) |
| | 0 | 934 | | { |
| | | 935 | | // For consistency with other handlers we wrap the exception in an HttpRequestException. |
| | | 936 | | // If the request is retryable, indicate that on the exception. |
| | 0 | 937 | | HttpRequestError error = ioe is HttpIOException httpIoe ? httpIoe.HttpRequestError : HttpRequestError.Un |
| | 0 | 938 | | mappedException = new HttpRequestException(error, SR.net_http_client_execution_error, ioe, _canRetry ? R |
| | 0 | 939 | | return true; |
| | | 940 | | } |
| | | 941 | | |
| | | 942 | | // Otherwise, just allow the original exception to propagate. |
| | 0 | 943 | | mappedException = exception; |
| | 0 | 944 | | return false; |
| | 0 | 945 | | } |
| | | 946 | | |
| | | 947 | | private HttpContentWriteStream CreateRequestContentStream(HttpRequestMessage request) |
| | 0 | 948 | | { |
| | 0 | 949 | | Debug.Assert(request.Content is not null); |
| | 0 | 950 | | bool requestTransferEncodingChunked = request.HasHeaders && request.Headers.TransferEncodingChunked == true; |
| | 0 | 951 | | HttpContentWriteStream requestContentStream = requestTransferEncodingChunked ? (HttpContentWriteStream) |
| | 0 | 952 | | new ChunkedEncodingWriteStream(this) : |
| | 0 | 953 | | new ContentLengthWriteStream(this, request.Content.Headers.ContentLength.GetValueOrDefault()); |
| | 0 | 954 | | return requestContentStream; |
| | 0 | 955 | | } |
| | | 956 | | |
| | | 957 | | private CancellationTokenRegistration RegisterCancellation(CancellationToken cancellationToken) |
| | 0 | 958 | | { |
| | | 959 | | // Cancellation design: |
| | | 960 | | // - We register with the SendAsync CancellationToken for the duration of the SendAsync operation. |
| | | 961 | | // - We register with the Read/Write/CopyToAsync methods on the response stream for each such individual ope |
| | | 962 | | // - The registration disposes of the connection, tearing it down and causing any pending operations to wake |
| | | 963 | | // - Because such a tear down can result in a variety of different exception types, we check for a cancellat |
| | | 964 | | // request and prioritize that over other exceptions, wrapping the actual exception as an inner of an OCE. |
| | 0 | 965 | | return cancellationToken.Register(static s => |
| | 0 | 966 | | { |
| | 0 | 967 | | var connection = (HttpConnection)s!; |
| | 0 | 968 | | if (NetEventSource.Log.IsEnabled()) connection.Trace("Cancellation requested. Disposing of the connectio |
| | 0 | 969 | | connection.Dispose(); |
| | 0 | 970 | | }, this); |
| | 0 | 971 | | } |
| | | 972 | | |
| | | 973 | | private async ValueTask SendRequestContentAsync(HttpRequestMessage request, HttpContentWriteStream stream, bool |
| | 0 | 974 | | { |
| | 0 | 975 | | Debug.Assert(stream.BytesWritten == 0); |
| | 0 | 976 | | if (HttpTelemetry.Log.IsEnabled()) HttpTelemetry.Log.RequestContentStart(); |
| | | 977 | | |
| | | 978 | | // Copy all of the data to the server. |
| | 0 | 979 | | if (async) |
| | 0 | 980 | | { |
| | 0 | 981 | | await request.Content!.CopyToAsync(stream, _transportContext, cancellationToken).ConfigureAwait(false); |
| | 0 | 982 | | } |
| | | 983 | | else |
| | 0 | 984 | | { |
| | 0 | 985 | | request.Content!.CopyTo(stream, _transportContext, cancellationToken); |
| | 0 | 986 | | } |
| | | 987 | | |
| | | 988 | | // Finish the content; with a chunked upload, this includes writing the terminating chunk. |
| | 0 | 989 | | await stream.FinishAsync(async).ConfigureAwait(false); |
| | | 990 | | |
| | | 991 | | // Flush any content that might still be buffered. |
| | 0 | 992 | | await FlushAsync(async).ConfigureAwait(false); |
| | | 993 | | |
| | 0 | 994 | | if (HttpTelemetry.Log.IsEnabled()) HttpTelemetry.Log.RequestContentStop(stream.BytesWritten); |
| | | 995 | | |
| | 0 | 996 | | if (NetEventSource.Log.IsEnabled()) Trace("Finished sending request content."); |
| | 0 | 997 | | } |
| | | 998 | | |
| | | 999 | | private async Task SendRequestContentWithExpect100ContinueAsync( |
| | | 1000 | | HttpRequestMessage request, Task<bool> allowExpect100ToContinueTask, |
| | | 1001 | | HttpContentWriteStream stream, Timer expect100Timer, bool async, CancellationToken cancellationToken) |
| | 0 | 1002 | | { |
| | | 1003 | | // Wait until we receive a trigger notification that it's ok to continue sending content. |
| | | 1004 | | // This will come either when the timer fires or when we receive a response status line from the server. |
| | 0 | 1005 | | bool sendRequestContent = await allowExpect100ToContinueTask.ConfigureAwait(false); |
| | | 1006 | | |
| | | 1007 | | // Clean up the timer; it's no longer needed. |
| | 0 | 1008 | | expect100Timer.Dispose(); |
| | | 1009 | | |
| | | 1010 | | // Send the content if we're supposed to. Otherwise, we're done. |
| | 0 | 1011 | | if (sendRequestContent) |
| | 0 | 1012 | | { |
| | 0 | 1013 | | if (NetEventSource.Log.IsEnabled()) Trace($"Sending request content for Expect: 100-continue."); |
| | | 1014 | | try |
| | 0 | 1015 | | { |
| | 0 | 1016 | | await SendRequestContentAsync(request, stream, async, cancellationToken).ConfigureAwait(false); |
| | 0 | 1017 | | } |
| | 0 | 1018 | | catch |
| | 0 | 1019 | | { |
| | | 1020 | | // Tear down the connection if called from the timer thread because caller's thread will wait for se |
| | | 1021 | | // or till HttpClient.Timeout tear the connection itself. |
| | 0 | 1022 | | Dispose(); |
| | 0 | 1023 | | throw; |
| | | 1024 | | } |
| | 0 | 1025 | | } |
| | | 1026 | | else |
| | 0 | 1027 | | { |
| | 0 | 1028 | | if (NetEventSource.Log.IsEnabled()) Trace($"Canceling request content for Expect: 100-continue."); |
| | 0 | 1029 | | } |
| | 0 | 1030 | | } |
| | | 1031 | | |
| | | 1032 | | private bool ParseStatusLine(HttpResponseMessage response) |
| | 0 | 1033 | | { |
| | 0 | 1034 | | Span<byte> buffer = _readBuffer.ActiveSpan; |
| | | 1035 | | |
| | 0 | 1036 | | int lineFeedIndex = buffer.IndexOf((byte)'\n'); |
| | 0 | 1037 | | if (lineFeedIndex >= 0) |
| | 0 | 1038 | | { |
| | 0 | 1039 | | int bytesConsumed = lineFeedIndex + 1; |
| | 0 | 1040 | | _readBuffer.Discard(bytesConsumed); |
| | 0 | 1041 | | _allowedReadLineBytes -= bytesConsumed; |
| | | 1042 | | |
| | 0 | 1043 | | int carriageReturnIndex = lineFeedIndex - 1; |
| | 0 | 1044 | | int length = (uint)carriageReturnIndex < (uint)buffer.Length && buffer[carriageReturnIndex] == '\r' |
| | 0 | 1045 | | ? carriageReturnIndex |
| | 0 | 1046 | | : lineFeedIndex; |
| | | 1047 | | |
| | 0 | 1048 | | ParseStatusLineCore(buffer.Slice(0, length), response); |
| | 0 | 1049 | | return true; |
| | | 1050 | | } |
| | | 1051 | | else |
| | 0 | 1052 | | { |
| | 0 | 1053 | | if (_allowedReadLineBytes <= buffer.Length) |
| | 0 | 1054 | | { |
| | 0 | 1055 | | ThrowExceededAllowedReadLineBytes(); |
| | 0 | 1056 | | } |
| | 0 | 1057 | | return false; |
| | | 1058 | | } |
| | 0 | 1059 | | } |
| | | 1060 | | |
| | | 1061 | | private static void ParseStatusLineCore(Span<byte> line, HttpResponseMessage response) |
| | 0 | 1062 | | { |
| | | 1063 | | // We sent the request version as either 1.0 or 1.1. |
| | | 1064 | | // We expect a response version of the form 1.X, where X is a single digit as per RFC. |
| | | 1065 | | |
| | | 1066 | | // Validate the beginning of the status line and set the response version. |
| | | 1067 | | const int MinStatusLineLength = 12; // "HTTP/1.x 123" |
| | 0 | 1068 | | if (line.Length < MinStatusLineLength || line[8] != ' ') |
| | 0 | 1069 | | { |
| | 0 | 1070 | | throw new HttpRequestException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_response_ |
| | | 1071 | | } |
| | | 1072 | | |
| | 0 | 1073 | | ulong first8Bytes = BitConverter.ToUInt64(line); |
| | 0 | 1074 | | if (first8Bytes == s_http11Bytes) |
| | 0 | 1075 | | { |
| | 0 | 1076 | | response.SetVersionWithoutValidation(HttpVersion.Version11); |
| | 0 | 1077 | | } |
| | 0 | 1078 | | else if (first8Bytes == s_http10Bytes) |
| | 0 | 1079 | | { |
| | 0 | 1080 | | response.SetVersionWithoutValidation(HttpVersion.Version10); |
| | 0 | 1081 | | } |
| | | 1082 | | else |
| | 0 | 1083 | | { |
| | 0 | 1084 | | byte minorVersion = line[7]; |
| | 0 | 1085 | | if (IsDigit(minorVersion) && line.StartsWith("HTTP/1."u8)) |
| | 0 | 1086 | | { |
| | 0 | 1087 | | response.SetVersionWithoutValidation(new Version(1, minorVersion - '0')); |
| | 0 | 1088 | | } |
| | | 1089 | | else |
| | 0 | 1090 | | { |
| | 0 | 1091 | | throw new HttpRequestException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_respo |
| | | 1092 | | } |
| | 0 | 1093 | | } |
| | | 1094 | | |
| | | 1095 | | // Set the status code |
| | 0 | 1096 | | byte status1 = line[9], status2 = line[10], status3 = line[11]; |
| | 0 | 1097 | | if (!IsDigit(status1) || !IsDigit(status2) || !IsDigit(status3)) |
| | 0 | 1098 | | { |
| | 0 | 1099 | | throw new HttpRequestException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_response_ |
| | | 1100 | | } |
| | 0 | 1101 | | response.SetStatusCodeWithoutValidation((HttpStatusCode)(100 * (status1 - '0') + 10 * (status2 - '0') + (sta |
| | | 1102 | | |
| | | 1103 | | // Parse (optional) reason phrase |
| | 0 | 1104 | | if (line.Length == MinStatusLineLength) |
| | 0 | 1105 | | { |
| | 0 | 1106 | | response.SetReasonPhraseWithoutValidation(string.Empty); |
| | 0 | 1107 | | } |
| | 0 | 1108 | | else if (line[MinStatusLineLength] == ' ') |
| | 0 | 1109 | | { |
| | 0 | 1110 | | ReadOnlySpan<byte> reasonBytes = line.Slice(MinStatusLineLength + 1); |
| | 0 | 1111 | | string? knownReasonPhrase = HttpStatusDescription.Get(response.StatusCode); |
| | 0 | 1112 | | if (knownReasonPhrase != null && Ascii.Equals(reasonBytes, knownReasonPhrase)) |
| | 0 | 1113 | | { |
| | 0 | 1114 | | response.SetReasonPhraseWithoutValidation(knownReasonPhrase); |
| | 0 | 1115 | | } |
| | | 1116 | | else |
| | 0 | 1117 | | { |
| | | 1118 | | try |
| | 0 | 1119 | | { |
| | 0 | 1120 | | response.ReasonPhrase = HttpRuleParser.DefaultHttpEncoding.GetString(reasonBytes); |
| | 0 | 1121 | | } |
| | 0 | 1122 | | catch (FormatException formatEx) |
| | 0 | 1123 | | { |
| | 0 | 1124 | | throw new HttpRequestException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_r |
| | | 1125 | | } |
| | 0 | 1126 | | } |
| | 0 | 1127 | | } |
| | | 1128 | | else |
| | 0 | 1129 | | { |
| | 0 | 1130 | | throw new HttpRequestException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_response_ |
| | | 1131 | | } |
| | 0 | 1132 | | } |
| | | 1133 | | |
| | | 1134 | | private bool ParseHeaders(HttpResponseMessage? response, bool isFromTrailer) |
| | 0 | 1135 | | { |
| | 0 | 1136 | | Span<byte> buffer = _readBuffer.ActiveSpan; |
| | | 1137 | | |
| | 0 | 1138 | | (bool finished, int bytesConsumed) = ParseHeadersCore(buffer, response, isFromTrailer); |
| | | 1139 | | |
| | 0 | 1140 | | int bytesScanned = finished ? bytesConsumed : buffer.Length; |
| | 0 | 1141 | | if (_allowedReadLineBytes < bytesScanned) |
| | 0 | 1142 | | { |
| | 0 | 1143 | | ThrowExceededAllowedReadLineBytes(); |
| | 0 | 1144 | | } |
| | | 1145 | | |
| | 0 | 1146 | | _readBuffer.Discard(bytesConsumed); |
| | 0 | 1147 | | _allowedReadLineBytes -= bytesConsumed; |
| | 0 | 1148 | | Debug.Assert(_allowedReadLineBytes >= 0); |
| | | 1149 | | |
| | 0 | 1150 | | return finished; |
| | 0 | 1151 | | } |
| | | 1152 | | |
| | | 1153 | | private (bool finished, int bytesConsumed) ParseHeadersCore(Span<byte> buffer, HttpResponseMessage? response, bo |
| | 0 | 1154 | | { |
| | 0 | 1155 | | int originalBufferLength = buffer.Length; |
| | | 1156 | | |
| | 0 | 1157 | | while (true) |
| | 0 | 1158 | | { |
| | 0 | 1159 | | int colIdx = buffer.IndexOfAny((byte)':', (byte)'\n'); |
| | 0 | 1160 | | if (colIdx < 0) |
| | 0 | 1161 | | { |
| | 0 | 1162 | | return (finished: false, bytesConsumed: originalBufferLength - buffer.Length); |
| | | 1163 | | } |
| | | 1164 | | |
| | 0 | 1165 | | if (buffer[colIdx] == '\n') |
| | 0 | 1166 | | { |
| | 0 | 1167 | | if ((colIdx == 1 && buffer[0] == '\r') || colIdx == 0) |
| | 0 | 1168 | | { |
| | 0 | 1169 | | return (finished: true, bytesConsumed: originalBufferLength - buffer.Length + colIdx + 1); |
| | | 1170 | | } |
| | | 1171 | | |
| | 0 | 1172 | | ThrowForInvalidHeaderLine(buffer, colIdx); |
| | 0 | 1173 | | } |
| | | 1174 | | |
| | 0 | 1175 | | int valueStartIdx = colIdx + 1; |
| | 0 | 1176 | | if ((uint)valueStartIdx >= (uint)buffer.Length) |
| | 0 | 1177 | | { |
| | 0 | 1178 | | return (finished: false, bytesConsumed: originalBufferLength - buffer.Length); |
| | | 1179 | | } |
| | | 1180 | | |
| | | 1181 | | // Iterate over the value and handle any line folds (new lines followed by SP/HTAB). |
| | | 1182 | | // valueIterator refers to the remainder of the buffer that we can still scan for new lines. |
| | 0 | 1183 | | Span<byte> valueIterator = buffer.Slice(valueStartIdx); |
| | | 1184 | | |
| | 0 | 1185 | | while (true) |
| | 0 | 1186 | | { |
| | 0 | 1187 | | int lfIdx = valueIterator.IndexOf((byte)'\n'); |
| | 0 | 1188 | | if ((uint)lfIdx >= (uint)valueIterator.Length) |
| | 0 | 1189 | | { |
| | 0 | 1190 | | return (finished: false, bytesConsumed: originalBufferLength - buffer.Length); |
| | | 1191 | | } |
| | | 1192 | | |
| | 0 | 1193 | | int crIdx = lfIdx - 1; |
| | 0 | 1194 | | int crOrLfIdx = (uint)crIdx < (uint)valueIterator.Length && valueIterator[crIdx] == '\r' |
| | 0 | 1195 | | ? crIdx |
| | 0 | 1196 | | : lfIdx; |
| | | 1197 | | |
| | 0 | 1198 | | int spIdx = lfIdx + 1; |
| | 0 | 1199 | | if ((uint)spIdx >= (uint)valueIterator.Length) |
| | 0 | 1200 | | { |
| | 0 | 1201 | | return (finished: false, bytesConsumed: originalBufferLength - buffer.Length); |
| | | 1202 | | } |
| | | 1203 | | |
| | 0 | 1204 | | if (valueIterator[spIdx] is not (byte)'\t' and not (byte)' ') |
| | 0 | 1205 | | { |
| | | 1206 | | // Found the end of the header value. |
| | | 1207 | | |
| | 0 | 1208 | | if (response is not null) |
| | 0 | 1209 | | { |
| | 0 | 1210 | | ReadOnlySpan<byte> headerName = buffer.Slice(0, valueStartIdx - 1); |
| | 0 | 1211 | | ReadOnlySpan<byte> headerValue = buffer.Slice(valueStartIdx, buffer.Length - valueIterator.L |
| | 0 | 1212 | | AddResponseHeader(headerName, headerValue, response, isFromTrailer); |
| | 0 | 1213 | | } |
| | | 1214 | | |
| | 0 | 1215 | | buffer = buffer.Slice(buffer.Length - valueIterator.Length + spIdx); |
| | 0 | 1216 | | break; |
| | | 1217 | | } |
| | | 1218 | | |
| | | 1219 | | // Found an obs-fold (CRLFHT/CRLFSP). |
| | | 1220 | | // Replace the CRLF with SPSP and keep looking for the final newline. |
| | 0 | 1221 | | valueIterator[crOrLfIdx] = (byte)' '; |
| | 0 | 1222 | | valueIterator[lfIdx] = (byte)' '; |
| | | 1223 | | |
| | 0 | 1224 | | valueIterator = valueIterator.Slice(spIdx + 1); |
| | 0 | 1225 | | } |
| | 0 | 1226 | | } |
| | | 1227 | | |
| | | 1228 | | static void ThrowForInvalidHeaderLine(ReadOnlySpan<byte> buffer, int newLineIndex) => |
| | 0 | 1229 | | throw new HttpRequestException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_response_ |
| | 0 | 1230 | | } |
| | | 1231 | | |
| | | 1232 | | private void AddResponseHeader(ReadOnlySpan<byte> name, ReadOnlySpan<byte> value, HttpResponseMessage response, |
| | 0 | 1233 | | { |
| | | 1234 | | // Skip trailing whitespace and check for empty length. |
| | 0 | 1235 | | while (true) |
| | 0 | 1236 | | { |
| | 0 | 1237 | | int spIdx = name.Length - 1; |
| | | 1238 | | |
| | 0 | 1239 | | if ((uint)spIdx < (uint)name.Length) |
| | 0 | 1240 | | { |
| | 0 | 1241 | | if (name[spIdx] != ' ') |
| | 0 | 1242 | | { |
| | | 1243 | | // hot path |
| | 0 | 1244 | | break; |
| | | 1245 | | } |
| | | 1246 | | |
| | 0 | 1247 | | name = name.Slice(0, spIdx); |
| | 0 | 1248 | | } |
| | | 1249 | | else |
| | 0 | 1250 | | { |
| | 0 | 1251 | | ThrowForEmptyHeaderName(); |
| | 0 | 1252 | | } |
| | 0 | 1253 | | } |
| | | 1254 | | |
| | | 1255 | | // Skip leading OWS for value. |
| | | 1256 | | // hot path: loop body runs only once. |
| | 0 | 1257 | | while (value.Length != 0 && value[0] is (byte)' ' or (byte)'\t') |
| | 0 | 1258 | | { |
| | 0 | 1259 | | value = value.Slice(1); |
| | 0 | 1260 | | } |
| | | 1261 | | |
| | | 1262 | | // Skip trailing OWS for value. |
| | 0 | 1263 | | while (true) |
| | 0 | 1264 | | { |
| | 0 | 1265 | | int spIdx = value.Length - 1; |
| | | 1266 | | |
| | 0 | 1267 | | if ((uint)spIdx >= (uint)value.Length || !(value[spIdx] is (byte)' ' or (byte)'\t')) |
| | 0 | 1268 | | { |
| | | 1269 | | // hot path |
| | 0 | 1270 | | break; |
| | | 1271 | | } |
| | | 1272 | | |
| | 0 | 1273 | | value = value.Slice(0, spIdx); |
| | 0 | 1274 | | } |
| | | 1275 | | |
| | 0 | 1276 | | if (!HeaderDescriptor.TryGet(name, out HeaderDescriptor descriptor)) |
| | 0 | 1277 | | { |
| | 0 | 1278 | | ThrowForInvalidHeaderName(name); |
| | 0 | 1279 | | } |
| | | 1280 | | |
| | 0 | 1281 | | Encoding? valueEncoding = _pool.Settings._responseHeaderEncodingSelector?.Invoke(descriptor.Name, _currentRe |
| | | 1282 | | |
| | 0 | 1283 | | HttpHeaderType headerType = descriptor.HeaderType; |
| | | 1284 | | |
| | | 1285 | | // Request headers returned on the response must be treated as custom headers. |
| | 0 | 1286 | | if ((headerType & HttpHeaderType.Request) != 0) |
| | 0 | 1287 | | { |
| | 0 | 1288 | | descriptor = descriptor.AsCustomHeader(); |
| | 0 | 1289 | | } |
| | | 1290 | | |
| | | 1291 | | string headerValue; |
| | | 1292 | | HttpHeaders headers; |
| | | 1293 | | |
| | 0 | 1294 | | if (isFromTrailer) |
| | 0 | 1295 | | { |
| | 0 | 1296 | | if ((headerType & HttpHeaderType.NonTrailing) != 0) |
| | 0 | 1297 | | { |
| | | 1298 | | // Disallowed trailer fields. |
| | | 1299 | | // A recipient MUST ignore fields that are forbidden to be sent in a trailer. |
| | 0 | 1300 | | return; |
| | | 1301 | | } |
| | | 1302 | | |
| | 0 | 1303 | | headerValue = descriptor.GetHeaderValue(value, valueEncoding); |
| | 0 | 1304 | | headers = response.TrailingHeaders; |
| | 0 | 1305 | | } |
| | 0 | 1306 | | else if ((headerType & HttpHeaderType.Content) != 0) |
| | 0 | 1307 | | { |
| | 0 | 1308 | | headerValue = descriptor.GetHeaderValue(value, valueEncoding); |
| | 0 | 1309 | | headers = response.Content!.Headers; |
| | 0 | 1310 | | } |
| | | 1311 | | else |
| | 0 | 1312 | | { |
| | 0 | 1313 | | headerValue = GetResponseHeaderValueWithCaching(descriptor, value, valueEncoding); |
| | 0 | 1314 | | headers = response.Headers; |
| | | 1315 | | |
| | 0 | 1316 | | if (descriptor.Equals(KnownHeaders.KeepAlive)) |
| | 0 | 1317 | | { |
| | | 1318 | | // We are intentionally going against RFC to honor the Keep-Alive header even if |
| | | 1319 | | // we haven't received a Keep-Alive connection token to maximize compat with servers. |
| | 0 | 1320 | | ProcessKeepAliveHeader(headerValue); |
| | 0 | 1321 | | } |
| | 0 | 1322 | | } |
| | | 1323 | | |
| | 0 | 1324 | | bool added = headers.TryAddWithoutValidation(descriptor, headerValue); |
| | 0 | 1325 | | Debug.Assert(added); |
| | | 1326 | | |
| | | 1327 | | static void ThrowForEmptyHeaderName() => |
| | 0 | 1328 | | throw new HttpRequestException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_response_ |
| | | 1329 | | |
| | | 1330 | | static void ThrowForInvalidHeaderName(ReadOnlySpan<byte> name) => |
| | 0 | 1331 | | throw new HttpRequestException(HttpRequestError.InvalidResponse, SR.Format(SR.net_http_invalid_response_ |
| | 0 | 1332 | | } |
| | | 1333 | | |
| | | 1334 | | private void ThrowExceededAllowedReadLineBytes() => |
| | 0 | 1335 | | throw new HttpRequestException(HttpRequestError.ConfigurationLimitExceeded, SR.Format(SR.net_http_response_h |
| | | 1336 | | |
| | | 1337 | | private void ProcessKeepAliveHeader(string keepAlive) |
| | 0 | 1338 | | { |
| | 0 | 1339 | | var parsedValues = new UnvalidatedObjectCollection<NameValueHeaderValue>(); |
| | | 1340 | | |
| | 0 | 1341 | | if (NameValueHeaderValue.GetNameValueListLength(keepAlive, 0, ',', parsedValues) == keepAlive.Length) |
| | 0 | 1342 | | { |
| | 0 | 1343 | | foreach (NameValueHeaderValue nameValue in parsedValues) |
| | 0 | 1344 | | { |
| | | 1345 | | // The HTTP/1.1 spec does not define any parameters for the Keep-Alive header, so we are using the d |
| | 0 | 1346 | | if (string.Equals(nameValue.Name, "timeout", StringComparison.OrdinalIgnoreCase)) |
| | 0 | 1347 | | { |
| | 0 | 1348 | | if (!string.IsNullOrEmpty(nameValue.Value) && |
| | 0 | 1349 | | HeaderUtilities.TryParseInt32(nameValue.Value, out int timeout) && |
| | 0 | 1350 | | timeout >= 0) |
| | 0 | 1351 | | { |
| | | 1352 | | // Some servers are very strict with closing the connection exactly at the timeout. |
| | | 1353 | | // Avoid using the connection if it is about to exceed the timeout to avoid resulting reques |
| | | 1354 | | const int OffsetSeconds = 1; |
| | | 1355 | | |
| | 0 | 1356 | | if (timeout <= OffsetSeconds) |
| | 0 | 1357 | | { |
| | 0 | 1358 | | _connectionClose = true; |
| | 0 | 1359 | | } |
| | | 1360 | | else |
| | 0 | 1361 | | { |
| | 0 | 1362 | | _keepAliveTimeoutSeconds = timeout - OffsetSeconds; |
| | 0 | 1363 | | } |
| | 0 | 1364 | | } |
| | 0 | 1365 | | } |
| | 0 | 1366 | | else if (string.Equals(nameValue.Name, "max", StringComparison.OrdinalIgnoreCase)) |
| | 0 | 1367 | | { |
| | 0 | 1368 | | if (nameValue.Value == "0") |
| | 0 | 1369 | | { |
| | 0 | 1370 | | _connectionClose = true; |
| | 0 | 1371 | | } |
| | 0 | 1372 | | } |
| | 0 | 1373 | | } |
| | 0 | 1374 | | } |
| | 0 | 1375 | | } |
| | | 1376 | | |
| | | 1377 | | private void WriteToBuffer(ReadOnlySpan<byte> source) |
| | 0 | 1378 | | { |
| | 0 | 1379 | | Debug.Assert(source.Length <= _writeBuffer.AvailableLength); |
| | 0 | 1380 | | source.CopyTo(_writeBuffer.AvailableSpan); |
| | 0 | 1381 | | _writeBuffer.Commit(source.Length); |
| | 0 | 1382 | | } |
| | | 1383 | | |
| | | 1384 | | private void Write(ReadOnlySpan<byte> source) |
| | 0 | 1385 | | { |
| | 0 | 1386 | | int remaining = _writeBuffer.AvailableLength; |
| | | 1387 | | |
| | 0 | 1388 | | if (source.Length <= remaining) |
| | 0 | 1389 | | { |
| | | 1390 | | // Fits in current write buffer. Just copy and return. |
| | 0 | 1391 | | WriteToBuffer(source); |
| | 0 | 1392 | | return; |
| | | 1393 | | } |
| | | 1394 | | |
| | 0 | 1395 | | if (_writeBuffer.ActiveLength != 0) |
| | 0 | 1396 | | { |
| | | 1397 | | // Fit what we can in the current write buffer and flush it. |
| | 0 | 1398 | | WriteToBuffer(source.Slice(0, remaining)); |
| | 0 | 1399 | | source = source.Slice(remaining); |
| | 0 | 1400 | | Flush(); |
| | 0 | 1401 | | } |
| | | 1402 | | |
| | 0 | 1403 | | if (source.Length >= _writeBuffer.Capacity) |
| | 0 | 1404 | | { |
| | | 1405 | | // Large write. No sense buffering this. Write directly to stream. |
| | 0 | 1406 | | WriteToStream(source); |
| | 0 | 1407 | | } |
| | | 1408 | | else |
| | 0 | 1409 | | { |
| | | 1410 | | // Copy remainder into buffer |
| | 0 | 1411 | | WriteToBuffer(source); |
| | 0 | 1412 | | } |
| | 0 | 1413 | | } |
| | | 1414 | | |
| | | 1415 | | private ValueTask WriteAsync(ReadOnlyMemory<byte> source) |
| | 0 | 1416 | | { |
| | 0 | 1417 | | int remaining = _writeBuffer.AvailableLength; |
| | | 1418 | | |
| | 0 | 1419 | | if (source.Length <= remaining) |
| | 0 | 1420 | | { |
| | | 1421 | | // Fits in current write buffer. Just copy and return. |
| | 0 | 1422 | | WriteToBuffer(source.Span); |
| | 0 | 1423 | | return default; |
| | | 1424 | | } |
| | | 1425 | | |
| | 0 | 1426 | | if (_writeBuffer.ActiveLength != 0) |
| | 0 | 1427 | | { |
| | | 1428 | | // Fit what we can in the current write buffer and flush it. |
| | 0 | 1429 | | WriteToBuffer(source.Span.Slice(0, remaining)); |
| | 0 | 1430 | | source = source.Slice(remaining); |
| | | 1431 | | |
| | 0 | 1432 | | ValueTask flushTask = FlushAsync(async: true); |
| | | 1433 | | |
| | 0 | 1434 | | if (flushTask.IsCompletedSuccessfully) |
| | 0 | 1435 | | { |
| | 0 | 1436 | | flushTask.GetAwaiter().GetResult(); |
| | | 1437 | | |
| | 0 | 1438 | | if (source.Length <= _writeBuffer.Capacity) |
| | 0 | 1439 | | { |
| | 0 | 1440 | | WriteToBuffer(source.Span); |
| | 0 | 1441 | | return default; |
| | | 1442 | | } |
| | | 1443 | | |
| | | 1444 | | // Fall-through to WriteToStreamAsync |
| | 0 | 1445 | | } |
| | | 1446 | | else |
| | 0 | 1447 | | { |
| | 0 | 1448 | | return AwaitFlushAndWriteAsync(flushTask, source); |
| | | 1449 | | } |
| | 0 | 1450 | | } |
| | | 1451 | | |
| | | 1452 | | // Large write. No sense buffering this. Write directly to stream. |
| | 0 | 1453 | | return WriteToStreamAsync(source, async: true); |
| | | 1454 | | |
| | | 1455 | | async ValueTask AwaitFlushAndWriteAsync(ValueTask flushTask, ReadOnlyMemory<byte> source) |
| | 0 | 1456 | | { |
| | 0 | 1457 | | await flushTask.ConfigureAwait(false); |
| | | 1458 | | |
| | 0 | 1459 | | if (source.Length <= _writeBuffer.Capacity) |
| | 0 | 1460 | | { |
| | 0 | 1461 | | WriteToBuffer(source.Span); |
| | 0 | 1462 | | } |
| | | 1463 | | else |
| | 0 | 1464 | | { |
| | 0 | 1465 | | await WriteToStreamAsync(source, async: true).ConfigureAwait(false); |
| | 0 | 1466 | | } |
| | 0 | 1467 | | } |
| | 0 | 1468 | | } |
| | | 1469 | | |
| | | 1470 | | private void WriteWithoutBuffering(ReadOnlySpan<byte> source) |
| | 0 | 1471 | | { |
| | 0 | 1472 | | if (_writeBuffer.ActiveLength != 0) |
| | 0 | 1473 | | { |
| | 0 | 1474 | | if (source.Length <= _writeBuffer.AvailableLength) |
| | 0 | 1475 | | { |
| | | 1476 | | // There's something already in the write buffer, but the content |
| | | 1477 | | // we're writing can also fit after it in the write buffer. Copy |
| | | 1478 | | // the content to the write buffer and then flush it, so that we |
| | | 1479 | | // can do a single send rather than two. |
| | 0 | 1480 | | WriteToBuffer(source); |
| | 0 | 1481 | | Flush(); |
| | 0 | 1482 | | return; |
| | | 1483 | | } |
| | | 1484 | | |
| | | 1485 | | // There's data in the write buffer and the data we're writing doesn't fit after it. |
| | | 1486 | | // Do two writes, one to flush the buffer and then another to write the supplied content. |
| | 0 | 1487 | | Flush(); |
| | 0 | 1488 | | } |
| | | 1489 | | |
| | 0 | 1490 | | WriteToStream(source); |
| | 0 | 1491 | | } |
| | | 1492 | | |
| | | 1493 | | private ValueTask WriteWithoutBufferingAsync(ReadOnlyMemory<byte> source, bool async) |
| | 0 | 1494 | | { |
| | 0 | 1495 | | if (_writeBuffer.ActiveLength == 0) |
| | 0 | 1496 | | { |
| | | 1497 | | // There's nothing in the write buffer we need to flush. |
| | | 1498 | | // Just write the supplied data out to the stream. |
| | 0 | 1499 | | return WriteToStreamAsync(source, async); |
| | | 1500 | | } |
| | | 1501 | | |
| | 0 | 1502 | | if (source.Length <= _writeBuffer.AvailableLength) |
| | 0 | 1503 | | { |
| | | 1504 | | // There's something already in the write buffer, but the content |
| | | 1505 | | // we're writing can also fit after it in the write buffer. Copy |
| | | 1506 | | // the content to the write buffer and then flush it, so that we |
| | | 1507 | | // can do a single send rather than two. |
| | 0 | 1508 | | WriteToBuffer(source.Span); |
| | 0 | 1509 | | return FlushAsync(async); |
| | | 1510 | | } |
| | | 1511 | | |
| | | 1512 | | // There's data in the write buffer and the data we're writing doesn't fit after it. |
| | | 1513 | | // Do two writes, one to flush the buffer and then another to write the supplied content. |
| | 0 | 1514 | | return FlushThenWriteWithoutBufferingAsync(source, async); |
| | 0 | 1515 | | } |
| | | 1516 | | |
| | | 1517 | | private async ValueTask FlushThenWriteWithoutBufferingAsync(ReadOnlyMemory<byte> source, bool async) |
| | 0 | 1518 | | { |
| | 0 | 1519 | | await FlushAsync(async).ConfigureAwait(false); |
| | 0 | 1520 | | await WriteToStreamAsync(source, async).ConfigureAwait(false); |
| | 0 | 1521 | | } |
| | | 1522 | | |
| | | 1523 | | private unsafe ValueTask WriteHexInt32Async(int value, bool async) |
| | 0 | 1524 | | { |
| | | 1525 | | // Try to format into our output buffer directly. |
| | 0 | 1526 | | if (value.TryFormat(_writeBuffer.AvailableSpan, out int bytesWritten, "X")) |
| | 0 | 1527 | | { |
| | 0 | 1528 | | _writeBuffer.Commit(bytesWritten); |
| | 0 | 1529 | | return default; |
| | | 1530 | | } |
| | | 1531 | | |
| | | 1532 | | // If we don't have enough room, do it the slow way. |
| | 0 | 1533 | | if (async) |
| | 0 | 1534 | | { |
| | 0 | 1535 | | Span<byte> temp = stackalloc byte[8]; // max length of Int32 as hex |
| | 0 | 1536 | | bool formatted = value.TryFormat(temp, out bytesWritten, "X"); |
| | 0 | 1537 | | Debug.Assert(formatted); |
| | 0 | 1538 | | return WriteAsync(temp.Slice(0, bytesWritten).ToArray()); |
| | | 1539 | | } |
| | | 1540 | | else |
| | 0 | 1541 | | { |
| | | 1542 | | // We should have enough capacity to write any hex-encoded int after flushing the buffer. |
| | 0 | 1543 | | Debug.Assert(_writeBuffer.Capacity >= 8); |
| | | 1544 | | |
| | 0 | 1545 | | Flush(); |
| | 0 | 1546 | | return WriteHexInt32Async(value, async: false); |
| | | 1547 | | } |
| | 0 | 1548 | | } |
| | | 1549 | | |
| | | 1550 | | private void Flush() |
| | 0 | 1551 | | { |
| | 0 | 1552 | | ReadOnlySpan<byte> bytes = _writeBuffer.ActiveSpan; |
| | 0 | 1553 | | if (bytes.Length > 0) |
| | 0 | 1554 | | { |
| | 0 | 1555 | | _writeBuffer.DiscardAll(); |
| | 0 | 1556 | | WriteToStream(bytes); |
| | 0 | 1557 | | } |
| | 0 | 1558 | | } |
| | | 1559 | | |
| | | 1560 | | private ValueTask FlushAsync(bool async) |
| | 0 | 1561 | | { |
| | 0 | 1562 | | ReadOnlyMemory<byte> bytes = _writeBuffer.ActiveMemory; |
| | 0 | 1563 | | if (bytes.Length > 0) |
| | 0 | 1564 | | { |
| | 0 | 1565 | | _writeBuffer.DiscardAll(); |
| | 0 | 1566 | | return WriteToStreamAsync(bytes, async); |
| | | 1567 | | } |
| | 0 | 1568 | | return default; |
| | 0 | 1569 | | } |
| | | 1570 | | |
| | | 1571 | | private void WriteToStream(ReadOnlySpan<byte> source) |
| | 0 | 1572 | | { |
| | 0 | 1573 | | if (NetEventSource.Log.IsEnabled()) Trace($"Writing {source.Length} bytes."); |
| | 0 | 1574 | | _stream.Write(source); |
| | 0 | 1575 | | } |
| | | 1576 | | |
| | | 1577 | | private ValueTask WriteToStreamAsync(ReadOnlyMemory<byte> source, bool async) |
| | 0 | 1578 | | { |
| | 0 | 1579 | | if (NetEventSource.Log.IsEnabled()) Trace($"Writing {source.Length} bytes."); |
| | | 1580 | | |
| | 0 | 1581 | | if (async) |
| | 0 | 1582 | | { |
| | 0 | 1583 | | return _stream.WriteAsync(source); |
| | | 1584 | | } |
| | | 1585 | | else |
| | 0 | 1586 | | { |
| | 0 | 1587 | | _stream.Write(source.Span); |
| | 0 | 1588 | | return default; |
| | | 1589 | | } |
| | 0 | 1590 | | } |
| | | 1591 | | |
| | | 1592 | | private bool TryReadNextChunkedLine(out ReadOnlySpan<byte> line) |
| | 0 | 1593 | | { |
| | 0 | 1594 | | ReadOnlySpan<byte> buffer = _readBuffer.ActiveReadOnlySpan; |
| | | 1595 | | |
| | | 1596 | | // Unlike the status line and headers, the chunked encoding grammar (RFC 9112 7.1) |
| | | 1597 | | // requires that each line be terminated by a CRLF. Interpreting a lone LF as a line |
| | | 1598 | | // terminator, or allowing a bare CR within the line, is not permitted here. |
| | 0 | 1599 | | int index = buffer.IndexOfAny((byte)'\r', (byte)'\n'); |
| | 0 | 1600 | | if ((uint)index >= (uint)buffer.Length) |
| | 0 | 1601 | | { |
| | | 1602 | | // We haven't found a CR or LF yet, so we don't have a complete line. |
| | 0 | 1603 | | if (buffer.Length < MaxChunkBytesAllowed) |
| | 0 | 1604 | | { |
| | 0 | 1605 | | line = default; |
| | 0 | 1606 | | return false; |
| | | 1607 | | } |
| | 0 | 1608 | | } |
| | 0 | 1609 | | else if (buffer[index] == '\n') |
| | 0 | 1610 | | { |
| | | 1611 | | // We found an LF that is not preceded by a CR. |
| | 0 | 1612 | | throw new HttpIOException(HttpRequestError.InvalidResponse, SR.net_http_invalid_response_chunk_line_endi |
| | | 1613 | | } |
| | | 1614 | | else |
| | 0 | 1615 | | { |
| | | 1616 | | // We found a CR. It must be immediately followed by an LF. |
| | 0 | 1617 | | int lineFeedIndex = index + 1; |
| | 0 | 1618 | | if ((uint)lineFeedIndex < (uint)buffer.Length) |
| | 0 | 1619 | | { |
| | 0 | 1620 | | if (buffer[lineFeedIndex] != '\n') |
| | 0 | 1621 | | { |
| | | 1622 | | // We found a bare CR that is not part of a CRLF sequence. |
| | 0 | 1623 | | throw new HttpIOException(HttpRequestError.InvalidResponse, SR.net_http_invalid_response_chunk_l |
| | | 1624 | | } |
| | | 1625 | | |
| | 0 | 1626 | | int bytesConsumed = lineFeedIndex + 1; |
| | 0 | 1627 | | if (bytesConsumed <= MaxChunkBytesAllowed) |
| | 0 | 1628 | | { |
| | 0 | 1629 | | _readBuffer.Discard(bytesConsumed); |
| | | 1630 | | |
| | 0 | 1631 | | line = buffer.Slice(0, index); |
| | 0 | 1632 | | return true; |
| | | 1633 | | } |
| | 0 | 1634 | | } |
| | 0 | 1635 | | else if (buffer.Length < MaxChunkBytesAllowed) |
| | 0 | 1636 | | { |
| | | 1637 | | // We have the CR but haven't received the following byte yet. |
| | 0 | 1638 | | line = default; |
| | 0 | 1639 | | return false; |
| | | 1640 | | } |
| | 0 | 1641 | | } |
| | | 1642 | | |
| | | 1643 | | // We either didn't find a line terminator within the allowed number of bytes, or the |
| | | 1644 | | // line (including its CRLF) is longer than we're willing to buffer. |
| | 0 | 1645 | | throw new HttpRequestException(SR.net_http_chunk_too_large); |
| | 0 | 1646 | | } |
| | | 1647 | | |
| | | 1648 | | // Does not throw on EOF. Also assumes there is no buffered data. |
| | | 1649 | | private async ValueTask InitialFillAsync(bool async) |
| | 0 | 1650 | | { |
| | 0 | 1651 | | Debug.Assert(!ReadAheadTaskHasStarted); |
| | 0 | 1652 | | Debug.Assert(_readBuffer.AvailableLength == _readBuffer.Capacity); |
| | 0 | 1653 | | Debug.Assert(_readBuffer.AvailableLength >= InitialReadBufferSize); |
| | | 1654 | | |
| | 0 | 1655 | | int bytesRead = async ? |
| | 0 | 1656 | | await _stream.ReadAsync(_readBuffer.AvailableMemory).ConfigureAwait(false) : |
| | 0 | 1657 | | _stream.Read(_readBuffer.AvailableSpan); |
| | | 1658 | | |
| | 0 | 1659 | | _readBuffer.Commit(bytesRead); |
| | | 1660 | | |
| | 0 | 1661 | | if (NetEventSource.Log.IsEnabled()) Trace($"Received {bytesRead} bytes."); |
| | 0 | 1662 | | } |
| | | 1663 | | |
| | | 1664 | | // Throws IOException on EOF. This is only called when we expect more data. |
| | | 1665 | | private async ValueTask FillAsync(bool async) |
| | 0 | 1666 | | { |
| | 0 | 1667 | | Debug.Assert(_readAheadTask == default); |
| | | 1668 | | |
| | 0 | 1669 | | _readBuffer.EnsureAvailableSpace(1); |
| | | 1670 | | |
| | 0 | 1671 | | int bytesRead = async ? |
| | 0 | 1672 | | await _stream.ReadAsync(_readBuffer.AvailableMemory).ConfigureAwait(false) : |
| | 0 | 1673 | | _stream.Read(_readBuffer.AvailableSpan); |
| | | 1674 | | |
| | 0 | 1675 | | _readBuffer.Commit(bytesRead); |
| | | 1676 | | |
| | 0 | 1677 | | if (NetEventSource.Log.IsEnabled()) Trace($"Received {bytesRead} bytes."); |
| | 0 | 1678 | | if (bytesRead == 0) |
| | 0 | 1679 | | { |
| | 0 | 1680 | | throw new HttpIOException(HttpRequestError.ResponseEnded, SR.net_http_invalid_response_premature_eof); |
| | | 1681 | | } |
| | 0 | 1682 | | } |
| | | 1683 | | |
| | | 1684 | | private ValueTask FillForHeadersAsync(bool async) |
| | 0 | 1685 | | { |
| | | 1686 | | // If the start offset is 0, it means we haven't consumed any data since the last FillAsync. |
| | | 1687 | | // If so, read until we either find the next new line or we hit the MaxResponseHeadersLength limit. |
| | 0 | 1688 | | return _readBuffer.ActiveStartOffset == 0 |
| | 0 | 1689 | | ? ReadUntilEndOfHeaderAsync(async) |
| | 0 | 1690 | | : FillAsync(async); |
| | | 1691 | | |
| | | 1692 | | // This method guarantees that the next call to ParseHeaders will consume at least one header. |
| | | 1693 | | // This is the slow path, but guarantees O(n) worst-case parsing complexity. |
| | | 1694 | | async ValueTask ReadUntilEndOfHeaderAsync(bool async) |
| | 0 | 1695 | | { |
| | 0 | 1696 | | int searchOffset = _readBuffer.ActiveLength; |
| | 0 | 1697 | | if (searchOffset > 0) |
| | 0 | 1698 | | { |
| | | 1699 | | // The last character we've buffered could be a new line, |
| | | 1700 | | // we just haven't checked the byte following it to see if it's a space or tab. |
| | 0 | 1701 | | searchOffset--; |
| | 0 | 1702 | | } |
| | | 1703 | | |
| | 0 | 1704 | | while (true) |
| | 0 | 1705 | | { |
| | 0 | 1706 | | await FillAsync(async).ConfigureAwait(false); |
| | 0 | 1707 | | Debug.Assert(_readBuffer.ActiveStartOffset == 0); |
| | 0 | 1708 | | Debug.Assert(_readBuffer.ActiveLength > searchOffset); |
| | | 1709 | | |
| | | 1710 | | // There's no need to search the whole buffer, only look through the new bytes we just read. |
| | 0 | 1711 | | if (TryFindEndOfLine(_readBuffer.ActiveReadOnlySpan.Slice(searchOffset), out int offset)) |
| | 0 | 1712 | | { |
| | 0 | 1713 | | break; |
| | | 1714 | | } |
| | | 1715 | | |
| | 0 | 1716 | | searchOffset += offset; |
| | | 1717 | | |
| | 0 | 1718 | | int readLength = _readBuffer.ActiveLength; |
| | 0 | 1719 | | if (searchOffset != readLength) |
| | 0 | 1720 | | { |
| | 0 | 1721 | | Debug.Assert(searchOffset == readLength - 1 && _readBuffer.ActiveReadOnlySpan[searchOffset] == ' |
| | 0 | 1722 | | if (readLength <= 2) |
| | 0 | 1723 | | { |
| | | 1724 | | // There are no headers - we start off with a new line. |
| | | 1725 | | // This is reachable from ChunkedEncodingReadStream if the buffers allign just right and the |
| | 0 | 1726 | | break; |
| | | 1727 | | } |
| | 0 | 1728 | | } |
| | | 1729 | | |
| | 0 | 1730 | | if (readLength >= _allowedReadLineBytes) |
| | 0 | 1731 | | { |
| | 0 | 1732 | | ThrowExceededAllowedReadLineBytes(); |
| | 0 | 1733 | | } |
| | 0 | 1734 | | } |
| | | 1735 | | |
| | | 1736 | | static bool TryFindEndOfLine(ReadOnlySpan<byte> buffer, out int searchOffset) |
| | 0 | 1737 | | { |
| | 0 | 1738 | | Debug.Assert(buffer.Length > 0); |
| | | 1739 | | |
| | 0 | 1740 | | int originalBufferLength = buffer.Length; |
| | | 1741 | | |
| | 0 | 1742 | | while (true) |
| | 0 | 1743 | | { |
| | 0 | 1744 | | int newLineOffset = buffer.IndexOf((byte)'\n'); |
| | 0 | 1745 | | if (newLineOffset < 0) |
| | 0 | 1746 | | { |
| | 0 | 1747 | | searchOffset = originalBufferLength; |
| | 0 | 1748 | | return false; |
| | | 1749 | | } |
| | | 1750 | | |
| | 0 | 1751 | | int tabOrSpaceIndex = newLineOffset + 1; |
| | 0 | 1752 | | if (tabOrSpaceIndex == buffer.Length) |
| | 0 | 1753 | | { |
| | | 1754 | | // The new line is the last character, read again to make sure it doesn't continue with spac |
| | 0 | 1755 | | searchOffset = originalBufferLength - 1; |
| | 0 | 1756 | | return false; |
| | | 1757 | | } |
| | | 1758 | | |
| | 0 | 1759 | | if (buffer[tabOrSpaceIndex] is not (byte)'\t' and not (byte)' ') |
| | 0 | 1760 | | { |
| | 0 | 1761 | | searchOffset = 0; |
| | 0 | 1762 | | return true; |
| | | 1763 | | } |
| | | 1764 | | |
| | 0 | 1765 | | buffer = buffer.Slice(tabOrSpaceIndex + 1); |
| | 0 | 1766 | | } |
| | 0 | 1767 | | } |
| | 0 | 1768 | | } |
| | 0 | 1769 | | } |
| | | 1770 | | |
| | | 1771 | | private int ReadFromBuffer(Span<byte> buffer) |
| | 0 | 1772 | | { |
| | 0 | 1773 | | ReadOnlySpan<byte> available = _readBuffer.ActiveSpan; |
| | 0 | 1774 | | int toCopy = Math.Min(available.Length, buffer.Length); |
| | | 1775 | | |
| | 0 | 1776 | | available.Slice(0, toCopy).CopyTo(buffer); |
| | 0 | 1777 | | _readBuffer.Discard(toCopy); |
| | | 1778 | | |
| | 0 | 1779 | | return toCopy; |
| | 0 | 1780 | | } |
| | | 1781 | | |
| | | 1782 | | private int Read(Span<byte> destination) |
| | 0 | 1783 | | { |
| | | 1784 | | // This is called when reading the response body. |
| | | 1785 | | |
| | 0 | 1786 | | if (_readBuffer.ActiveLength > 0) |
| | 0 | 1787 | | { |
| | | 1788 | | // We have data in the read buffer. Return it to the caller. |
| | 0 | 1789 | | return ReadFromBuffer(destination); |
| | | 1790 | | } |
| | | 1791 | | |
| | | 1792 | | // No data in read buffer. |
| | | 1793 | | // Do an unbuffered read directly against the underlying stream. |
| | 0 | 1794 | | Debug.Assert(_readAheadTask == default, "Read ahead task should have been consumed as part of the headers.") |
| | 0 | 1795 | | int count = _stream.Read(destination); |
| | 0 | 1796 | | if (NetEventSource.Log.IsEnabled()) Trace($"Received {count} bytes."); |
| | 0 | 1797 | | return count; |
| | 0 | 1798 | | } |
| | | 1799 | | |
| | | 1800 | | private ValueTask<int> ReadAsync(Memory<byte> destination) |
| | 0 | 1801 | | { |
| | | 1802 | | // This is called when reading the response body. |
| | | 1803 | | |
| | 0 | 1804 | | if (_readBuffer.ActiveLength > 0) |
| | 0 | 1805 | | { |
| | | 1806 | | // We have data in the read buffer. Return it to the caller. |
| | 0 | 1807 | | return new ValueTask<int>(ReadFromBuffer(destination.Span)); |
| | | 1808 | | } |
| | | 1809 | | |
| | | 1810 | | // No data in read buffer. |
| | | 1811 | | // Do an unbuffered read directly against the underlying stream. |
| | 0 | 1812 | | Debug.Assert(_readAheadTask == default, "Read ahead task should have been consumed as part of the headers.") |
| | | 1813 | | |
| | 0 | 1814 | | return NetEventSource.Log.IsEnabled() |
| | 0 | 1815 | | ? ReadAndLogBytesReadAsync(destination) |
| | 0 | 1816 | | : _stream.ReadAsync(destination); |
| | | 1817 | | |
| | | 1818 | | async ValueTask<int> ReadAndLogBytesReadAsync(Memory<byte> destination) |
| | 0 | 1819 | | { |
| | 0 | 1820 | | int count = await _stream.ReadAsync(destination).ConfigureAwait(false); |
| | 0 | 1821 | | if (NetEventSource.Log.IsEnabled()) Trace($"Received {count} bytes."); |
| | 0 | 1822 | | return count; |
| | 0 | 1823 | | } |
| | 0 | 1824 | | } |
| | | 1825 | | |
| | | 1826 | | private int ReadBuffered(Span<byte> destination) |
| | 0 | 1827 | | { |
| | | 1828 | | // This is called when reading the response body. |
| | | 1829 | | |
| | 0 | 1830 | | if (_readBuffer.ActiveLength == 0) |
| | 0 | 1831 | | { |
| | | 1832 | | // Do a buffered read directly against the underlying stream. |
| | 0 | 1833 | | Debug.Assert(_readAheadTask == default, "Read ahead task should have been consumed as part of the header |
| | | 1834 | | |
| | 0 | 1835 | | if (destination.Length == 0) |
| | 0 | 1836 | | { |
| | 0 | 1837 | | return _stream.Read(Array.Empty<byte>()); |
| | | 1838 | | } |
| | | 1839 | | |
| | 0 | 1840 | | Debug.Assert(_readBuffer.AvailableLength == _readBuffer.Capacity); |
| | 0 | 1841 | | int bytesRead = _stream.Read(_readBuffer.AvailableSpan); |
| | 0 | 1842 | | _readBuffer.Commit(bytesRead); |
| | | 1843 | | |
| | 0 | 1844 | | if (NetEventSource.Log.IsEnabled()) Trace($"Received {bytesRead} bytes."); |
| | 0 | 1845 | | } |
| | | 1846 | | |
| | | 1847 | | // Hand back as much data as we can fit. |
| | 0 | 1848 | | return ReadFromBuffer(destination); |
| | 0 | 1849 | | } |
| | | 1850 | | |
| | | 1851 | | private ValueTask<int> ReadBufferedAsync(Memory<byte> destination) |
| | 0 | 1852 | | { |
| | | 1853 | | // If the caller provided buffer, and thus the amount of data desired to be read, |
| | | 1854 | | // is larger than the internal buffer, there's no point going through the internal |
| | | 1855 | | // buffer, so just do an unbuffered read. |
| | | 1856 | | // Also avoid avoid using the internal buffer if the user requested a zero-byte read to allow |
| | | 1857 | | // underlying streams to efficiently handle such a read (e.g. SslStream defering buffer allocation). |
| | 0 | 1858 | | return destination.Length >= _readBuffer.Capacity || destination.Length == 0 ? |
| | 0 | 1859 | | ReadAsync(destination) : |
| | 0 | 1860 | | ReadBufferedAsyncCore(destination); |
| | 0 | 1861 | | } |
| | | 1862 | | |
| | | 1863 | | [AsyncMethodBuilder(typeof(PoolingAsyncValueTaskMethodBuilder<>))] |
| | | 1864 | | [RuntimeAsyncMethodGeneration(false)] |
| | | 1865 | | private async ValueTask<int> ReadBufferedAsyncCore(Memory<byte> destination) |
| | 0 | 1866 | | { |
| | | 1867 | | // This is called when reading the response body. |
| | | 1868 | | |
| | 0 | 1869 | | if (_readBuffer.ActiveLength == 0) |
| | 0 | 1870 | | { |
| | | 1871 | | // Do a buffered read directly against the underlying stream. |
| | 0 | 1872 | | Debug.Assert(_readAheadTask == default, "Read ahead task should have been consumed as part of the header |
| | | 1873 | | |
| | 0 | 1874 | | Debug.Assert(_readBuffer.AvailableLength == _readBuffer.Capacity); |
| | 0 | 1875 | | int bytesRead = await _stream.ReadAsync(_readBuffer.AvailableMemory).ConfigureAwait(false); |
| | 0 | 1876 | | _readBuffer.Commit(bytesRead); |
| | | 1877 | | |
| | 0 | 1878 | | if (NetEventSource.Log.IsEnabled()) Trace($"Received {bytesRead} bytes."); |
| | 0 | 1879 | | } |
| | | 1880 | | |
| | | 1881 | | // Hand back as much data as we can fit. |
| | 0 | 1882 | | return ReadFromBuffer(destination.Span); |
| | 0 | 1883 | | } |
| | | 1884 | | |
| | | 1885 | | private ValueTask CopyFromBufferAsync(Stream destination, bool async, int count, CancellationToken cancellationT |
| | 0 | 1886 | | { |
| | 0 | 1887 | | Debug.Assert(count <= _readBuffer.ActiveLength); |
| | | 1888 | | |
| | 0 | 1889 | | if (NetEventSource.Log.IsEnabled()) Trace($"Copying {count} bytes to stream."); |
| | | 1890 | | |
| | 0 | 1891 | | ReadOnlyMemory<byte> source = _readBuffer.ActiveMemory.Slice(0, count); |
| | 0 | 1892 | | _readBuffer.Discard(count); |
| | | 1893 | | |
| | 0 | 1894 | | if (async) |
| | 0 | 1895 | | { |
| | 0 | 1896 | | return destination.WriteAsync(source, cancellationToken); |
| | | 1897 | | } |
| | | 1898 | | else |
| | 0 | 1899 | | { |
| | 0 | 1900 | | destination.Write(source.Span); |
| | 0 | 1901 | | return default; |
| | | 1902 | | } |
| | 0 | 1903 | | } |
| | | 1904 | | |
| | | 1905 | | private Task CopyToUntilEofAsync(Stream destination, bool async, int bufferSize, CancellationToken cancellationT |
| | 0 | 1906 | | { |
| | 0 | 1907 | | Debug.Assert(destination != null); |
| | | 1908 | | |
| | 0 | 1909 | | if (_readBuffer.ActiveLength > 0) |
| | 0 | 1910 | | { |
| | 0 | 1911 | | return CopyToUntilEofWithExistingBufferedDataAsync(destination, async, bufferSize, cancellationToken); |
| | | 1912 | | } |
| | | 1913 | | |
| | 0 | 1914 | | if (async) |
| | 0 | 1915 | | { |
| | 0 | 1916 | | return _stream.CopyToAsync(destination, bufferSize, cancellationToken); |
| | | 1917 | | } |
| | | 1918 | | |
| | 0 | 1919 | | _stream.CopyTo(destination, bufferSize); |
| | 0 | 1920 | | return Task.CompletedTask; |
| | 0 | 1921 | | } |
| | | 1922 | | |
| | | 1923 | | private async Task CopyToUntilEofWithExistingBufferedDataAsync(Stream destination, bool async, int bufferSize, C |
| | 0 | 1924 | | { |
| | 0 | 1925 | | int remaining = _readBuffer.ActiveLength; |
| | 0 | 1926 | | Debug.Assert(remaining > 0); |
| | | 1927 | | |
| | 0 | 1928 | | await CopyFromBufferAsync(destination, async, remaining, cancellationToken).ConfigureAwait(false); |
| | | 1929 | | |
| | 0 | 1930 | | if (async) |
| | 0 | 1931 | | { |
| | 0 | 1932 | | await _stream.CopyToAsync(destination, bufferSize, cancellationToken).ConfigureAwait(false); |
| | 0 | 1933 | | } |
| | | 1934 | | else |
| | 0 | 1935 | | { |
| | 0 | 1936 | | _stream.CopyTo(destination, bufferSize); |
| | 0 | 1937 | | } |
| | 0 | 1938 | | } |
| | | 1939 | | |
| | | 1940 | | // Copy *exactly* [length] bytes into destination; throws on end of stream. |
| | | 1941 | | private async Task CopyToContentLengthAsync(Stream destination, bool async, ulong length, int bufferSize, Cancel |
| | 0 | 1942 | | { |
| | 0 | 1943 | | Debug.Assert(destination != null); |
| | 0 | 1944 | | Debug.Assert(length > 0); |
| | | 1945 | | |
| | | 1946 | | // Copy any data left in the connection's buffer to the destination. |
| | 0 | 1947 | | int remaining = _readBuffer.ActiveLength; |
| | 0 | 1948 | | if (remaining > 0) |
| | 0 | 1949 | | { |
| | 0 | 1950 | | if ((ulong)remaining > length) |
| | 0 | 1951 | | { |
| | 0 | 1952 | | remaining = (int)length; |
| | 0 | 1953 | | } |
| | 0 | 1954 | | await CopyFromBufferAsync(destination, async, remaining, cancellationToken).ConfigureAwait(false); |
| | | 1955 | | |
| | 0 | 1956 | | length -= (ulong)remaining; |
| | 0 | 1957 | | if (length == 0) |
| | 0 | 1958 | | { |
| | 0 | 1959 | | return; |
| | | 1960 | | } |
| | | 1961 | | |
| | 0 | 1962 | | Debug.Assert(_readBuffer.ActiveLength == 0, "HttpConnection's buffer should have been empty."); |
| | 0 | 1963 | | } |
| | | 1964 | | |
| | | 1965 | | // Repeatedly read into HttpConnection's buffer and write that buffer to the destination |
| | | 1966 | | // stream. If after doing so, we find that we filled the whole connection's buffer (which |
| | | 1967 | | // is sized mainly for HTTP headers rather than large payloads), grow the connection's |
| | | 1968 | | // read buffer to the requested buffer size to use for the remainder of the operation. We |
| | | 1969 | | // use a temporary buffer from the ArrayPool so that the connection doesn't hog large |
| | | 1970 | | // buffers from the pool for extended durations, especially if it's going to sit in the |
| | | 1971 | | // connection pool for a prolonged period. |
| | 0 | 1972 | | byte[]? origReadBuffer = null; |
| | | 1973 | | try |
| | 0 | 1974 | | { |
| | 0 | 1975 | | while (true) |
| | 0 | 1976 | | { |
| | 0 | 1977 | | await FillAsync(async).ConfigureAwait(false); |
| | | 1978 | | |
| | 0 | 1979 | | remaining = (int)Math.Min((ulong)_readBuffer.ActiveLength, length); |
| | 0 | 1980 | | await CopyFromBufferAsync(destination, async, remaining, cancellationToken).ConfigureAwait(false); |
| | | 1981 | | |
| | 0 | 1982 | | length -= (ulong)remaining; |
| | 0 | 1983 | | if (length == 0) |
| | 0 | 1984 | | { |
| | 0 | 1985 | | return; |
| | | 1986 | | } |
| | | 1987 | | |
| | | 1988 | | // If we haven't yet grown the buffer (if we previously grew it, then it's sufficiently large), and |
| | | 1989 | | // if we filled the read buffer while doing the last read (which is at least one indication that the |
| | | 1990 | | // data arrival rate is fast enough to warrant a larger buffer), and if the buffer size we'd want is |
| | | 1991 | | // larger than the one we already have, then grow the connection's read buffer to that size. |
| | 0 | 1992 | | if (origReadBuffer is null) |
| | 0 | 1993 | | { |
| | 0 | 1994 | | int currentCapacity = _readBuffer.Capacity; |
| | 0 | 1995 | | if (remaining == currentCapacity) |
| | 0 | 1996 | | { |
| | 0 | 1997 | | int desiredBufferSize = (int)Math.Min((ulong)bufferSize, length); |
| | 0 | 1998 | | if (desiredBufferSize > currentCapacity) |
| | 0 | 1999 | | { |
| | 0 | 2000 | | origReadBuffer = _readBuffer.DangerousGetUnderlyingBuffer(); |
| | 0 | 2001 | | byte[] pooledBuffer = ArrayPool<byte>.Shared.Rent(desiredBufferSize); |
| | 0 | 2002 | | _readBuffer = new ArrayBuffer(pooledBuffer); |
| | 0 | 2003 | | } |
| | 0 | 2004 | | } |
| | 0 | 2005 | | } |
| | 0 | 2006 | | } |
| | | 2007 | | } |
| | | 2008 | | finally |
| | 0 | 2009 | | { |
| | 0 | 2010 | | if (origReadBuffer is not null) |
| | 0 | 2011 | | { |
| | 0 | 2012 | | Debug.Assert(origReadBuffer.Length > 0); |
| | | 2013 | | |
| | | 2014 | | // We don't care how much remaining data there was, just if there was any. |
| | | 2015 | | // Subsequent code is going to check whether the receive buffer is empty |
| | | 2016 | | // and then force the connection closed if it's not. |
| | 0 | 2017 | | bool anyDataAvailable = _readBuffer.ActiveLength > 0; |
| | | 2018 | | |
| | 0 | 2019 | | byte[] pooledBuffer = _readBuffer.DangerousGetUnderlyingBuffer(); |
| | 0 | 2020 | | _readBuffer = new ArrayBuffer(origReadBuffer); |
| | 0 | 2021 | | ArrayPool<byte>.Shared.Return(pooledBuffer); |
| | | 2022 | | |
| | 0 | 2023 | | if (anyDataAvailable) |
| | 0 | 2024 | | { |
| | 0 | 2025 | | _readBuffer.Commit(1); |
| | 0 | 2026 | | } |
| | 0 | 2027 | | } |
| | 0 | 2028 | | } |
| | 0 | 2029 | | } |
| | | 2030 | | |
| | | 2031 | | internal void Acquire() |
| | 0 | 2032 | | { |
| | 0 | 2033 | | Debug.Assert(_currentRequest == null); |
| | 0 | 2034 | | Debug.Assert(!_inUse); |
| | | 2035 | | |
| | 0 | 2036 | | _inUse = true; |
| | 0 | 2037 | | } |
| | | 2038 | | |
| | | 2039 | | internal void Release() |
| | 0 | 2040 | | { |
| | 0 | 2041 | | Debug.Assert(_inUse); |
| | | 2042 | | |
| | 0 | 2043 | | _inUse = false; |
| | | 2044 | | |
| | | 2045 | | // If the last request already completed (because the response had no content), return the connection to the |
| | | 2046 | | // Otherwise, it will be returned when the response has been consumed and CompleteResponse below is called. |
| | 0 | 2047 | | if (_currentRequest == null) |
| | 0 | 2048 | | { |
| | 0 | 2049 | | ReturnConnectionToPool(); |
| | 0 | 2050 | | } |
| | 0 | 2051 | | } |
| | | 2052 | | |
| | | 2053 | | /// <summary> |
| | | 2054 | | /// Detach the connection from the pool, so it is no longer counted against the connection limit. |
| | | 2055 | | /// This is used when we are creating a replacement connection for NT auth challenges. |
| | | 2056 | | /// </summary> |
| | | 2057 | | internal void DetachFromPool() |
| | 0 | 2058 | | { |
| | 0 | 2059 | | Debug.Assert(_inUse); |
| | | 2060 | | |
| | 0 | 2061 | | _detachedFromPool = true; |
| | 0 | 2062 | | } |
| | | 2063 | | |
| | | 2064 | | private void CompleteResponse() |
| | 0 | 2065 | | { |
| | 0 | 2066 | | Debug.Assert(_currentRequest != null, "Expected the connection to be associated with a request."); |
| | 0 | 2067 | | Debug.Assert(_writeBuffer.ActiveLength == 0, "Everything in write buffer should have been flushed."); |
| | | 2068 | | |
| | | 2069 | | // Disassociate the connection from a request. |
| | 0 | 2070 | | _currentRequest = null; |
| | | 2071 | | |
| | | 2072 | | // If we have extraneous data in the read buffer, don't reuse the connection; |
| | | 2073 | | // otherwise we'd interpret this as part of the next response. Plus, we may |
| | | 2074 | | // have been using a temporary buffer to read this erroneous data, and thus |
| | | 2075 | | // may not even have it any more. |
| | 0 | 2076 | | if (_readBuffer.ActiveLength > 0) |
| | 0 | 2077 | | { |
| | 0 | 2078 | | if (NetEventSource.Log.IsEnabled()) |
| | 0 | 2079 | | { |
| | 0 | 2080 | | Trace("Unexpected data on connection after response read."); |
| | 0 | 2081 | | } |
| | | 2082 | | |
| | 0 | 2083 | | _readBuffer.DiscardAll(); |
| | 0 | 2084 | | _connectionClose = true; |
| | 0 | 2085 | | } |
| | | 2086 | | |
| | | 2087 | | // If the connection is no longer in use (i.e. for NT authentication), then we can |
| | | 2088 | | // return it to the pool now; otherwise, it will be returned by the Release method later. |
| | | 2089 | | // The cancellation logic in HTTP/1.1 response stream reading methods is prone to race conditions |
| | | 2090 | | // where CancellationTokenRegistration callbacks may dispose the connection without the disposal |
| | | 2091 | | // leading to an actual cancellation of the response reading methods by an OperationCanceledException. |
| | | 2092 | | // To guard against these cases, it is necessary to check if the connection is disposed before |
| | | 2093 | | // attempting to return it to the pool. |
| | 0 | 2094 | | if (!_inUse && !_disposed) |
| | 0 | 2095 | | { |
| | 0 | 2096 | | ReturnConnectionToPool(); |
| | 0 | 2097 | | } |
| | 0 | 2098 | | } |
| | | 2099 | | |
| | | 2100 | | public async ValueTask DrainResponseAsync(HttpResponseMessage response, CancellationToken cancellationToken) |
| | 0 | 2101 | | { |
| | 0 | 2102 | | Debug.Assert(_inUse); |
| | | 2103 | | |
| | 0 | 2104 | | if (_connectionClose) |
| | 0 | 2105 | | { |
| | 0 | 2106 | | throw new HttpRequestException(HttpRequestError.UserAuthenticationError, SR.net_http_authconnectionfailu |
| | | 2107 | | } |
| | | 2108 | | |
| | 0 | 2109 | | Debug.Assert(response.Content != null); |
| | 0 | 2110 | | Stream stream = response.Content.ReadAsStream(cancellationToken); |
| | 0 | 2111 | | HttpContentReadStream? responseStream = stream as HttpContentReadStream; |
| | | 2112 | | |
| | 0 | 2113 | | Debug.Assert(responseStream != null || stream is EmptyReadStream); |
| | | 2114 | | |
| | 0 | 2115 | | if (responseStream != null && responseStream.NeedsDrain) |
| | 0 | 2116 | | { |
| | 0 | 2117 | | Debug.Assert(response.RequestMessage == _currentRequest); |
| | | 2118 | | |
| | 0 | 2119 | | if (!await responseStream.DrainAsync(_pool.Settings._maxResponseDrainSize).ConfigureAwait(false) || |
| | 0 | 2120 | | _connectionClose) // Draining may have set this |
| | 0 | 2121 | | { |
| | 0 | 2122 | | throw new HttpRequestException(HttpRequestError.UserAuthenticationError, SR.net_http_authconnectionf |
| | | 2123 | | } |
| | 0 | 2124 | | } |
| | | 2125 | | |
| | 0 | 2126 | | Debug.Assert(_currentRequest == null); |
| | | 2127 | | |
| | 0 | 2128 | | response.Dispose(); |
| | 0 | 2129 | | } |
| | | 2130 | | |
| | | 2131 | | private void ReturnConnectionToPool() |
| | 0 | 2132 | | { |
| | 0 | 2133 | | Debug.Assert(!_disposed, "Connection should not be disposed."); |
| | 0 | 2134 | | Debug.Assert(_currentRequest == null, "Connection should no longer be associated with a request."); |
| | 0 | 2135 | | Debug.Assert(_readAheadTask == default, "Expected a previous initial read to already be consumed."); |
| | 0 | 2136 | | Debug.Assert(_readAheadTaskStatus == ReadAheadTask_NotStarted, "Expected SendAsync to reset the read-ahead t |
| | 0 | 2137 | | Debug.Assert(_readBuffer.ActiveLength == 0, "Unexpected data in connection read buffer."); |
| | | 2138 | | |
| | | 2139 | | // If we decided not to reuse the connection (either because the server sent Connection: close, |
| | | 2140 | | // or there was some other problem while processing the request that makes the connection unusable), |
| | | 2141 | | // don't put the connection back in the pool. |
| | 0 | 2142 | | if (_connectionClose) |
| | 0 | 2143 | | { |
| | 0 | 2144 | | if (NetEventSource.Log.IsEnabled()) |
| | 0 | 2145 | | { |
| | 0 | 2146 | | Trace("Connection will not be reused."); |
| | 0 | 2147 | | } |
| | | 2148 | | |
| | | 2149 | | // We're not putting the connection back in the pool. Dispose it. |
| | 0 | 2150 | | Dispose(); |
| | 0 | 2151 | | } |
| | | 2152 | | else |
| | 0 | 2153 | | { |
| | 0 | 2154 | | Debug.Assert(!_detachedFromPool, "Should not be detached from pool unless _connectionClose is true"); |
| | | 2155 | | |
| | | 2156 | | // Put connection back in the pool. |
| | 0 | 2157 | | _pool.RecycleHttp11Connection(this); |
| | 0 | 2158 | | } |
| | 0 | 2159 | | } |
| | | 2160 | | |
| | 0 | 2161 | | public sealed override string ToString() => $"{nameof(HttpConnection)}({_pool})"; // Description for diagnostic |
| | | 2162 | | |
| | | 2163 | | public sealed override void Trace(string message, [CallerMemberName] string? memberName = null) => |
| | 0 | 2164 | | NetEventSource.Log.HandlerMessage( |
| | 0 | 2165 | | _pool?.GetHashCode() ?? 0, // pool ID |
| | 0 | 2166 | | GetHashCode(), // connection ID |
| | 0 | 2167 | | _currentRequest?.GetHashCode() ?? 0, // request ID |
| | 0 | 2168 | | memberName, // method name |
| | 0 | 2169 | | message); // message |
| | | 2170 | | } |
| | | 2171 | | } |
| | | 2172 | | |