Microsoft.AspNetCore.Server.HttpSys

Exposes the Http.Sys authentication configurations.

When attaching to an existing queue this setting must match the one used to create the queue.

Indicates if anonymous requests will be surfaced to the application or challenged by the server. The default value is true.

If true the server should set HttpContext.User. If false the server will only provide an identity when explicitly requested by the AuthenticationScheme. The default is true.

Sets the display name shown to users on login pages. The default is null.

Specifies protocols for authentication.

No authentication is enabled. This should only be used when HttpSysOptions.Authentication.AllowAnonymous is enabled (see ).

Specifies basic authentication.

Specifies NTLM authentication.

Negotiates with the client to determine the authentication scheme. If both client and server support Kerberos, it is used; otherwise, NTLM is used.

Specifies Kerberos authentication.

Describes the client certificate negotiation method for HTTPS connections.

A client certificate will not be populated on the request.

A client certificate will be populated if already present at the start of a request.

The TLS session can be renegotiated to request a client certificate.

Rule that maintains a handle to the Request Queue and UrlPrefix to delegate to.

The name of the Http.Sys request queue

The URL of the Http.Sys Url Prefix

A private utility routine to convert an integer to a chunk header, which is an ASCII hex number followed by a CRLF.The header is returned as a byte array. Generates a right-aligned hex string and returns the start offset.

Chunk size to be encoded A byte array with the header in int.

Enum declaring the allowed values for the verbosity level when http.sys reject requests due to throttling.

A 503 response is not sent; the connection is reset. This is the default HTTP Server API behavior.

The HTTP Server API sends a 503 response with a "Service Unavailable" reason phrase.

The HTTP Server API sends a 503 response with a detailed reason phrase.

Constants for HttpSys.

The name of the authentication scheme used.

Exception thrown by HttpSys when an error occurs

An HTTP server wrapping the Http.Sys APIs that accepts requests.

Start accepting incoming requests.

Stop the server and clean up.

Accept a request from the incoming request queue.

Contains the options used by HttpSys.

Initializes a new .

The name of the Http.Sys request queue The default is `null` (Anonymous queue).

This indicates whether the server is responsible for creating and configuring the request queue, or if it should attach to an existing queue. Most existing configuration options do not apply when attaching to an existing queue. The default is `RequestQueueMode.Create`.

Indicates how client certificates should be populated. The default is to allow a certificate without renegotiation. This does not change the netsh 'clientcertnegotiation' binding option which will need to be enabled for ClientCertificateMethod.AllowCertificate to resolve a certificate.

The maximum number of concurrent accepts. The default is 5 times the number of processors as returned by .

Attempt kernel-mode caching for responses with eligible headers. The response may not include Set-Cookie, Vary, or Pragma headers. It must include a Cache-Control header that's public and either a shared-max-age or max-age value, or an Expires header. The default is `true`.

The url prefixes to register with Http.Sys. These may be modified at any time prior to disposing the listener. When attached to an existing queue the prefixes are only used to compute PathBase for requests.

Http.Sys authentication settings. These may be modified at any time prior to disposing the listener.

Exposes the Http.Sys timeout configurations. These may also be configured in the registry. These may be modified at any time prior to disposing the listener. These settings do not apply when attaching to an existing queue.

Gets or Sets if response body writes that fail due to client disconnects should throw exceptions or complete normally. The default is `false` (complete normally).

Enable buffering of response data in the Kernel. The default value is false. It should be used by an application doing synchronous I/O or by an application doing asynchronous I/O with no more than one outstanding write at a time, and can significantly improve throughput over high-latency connections. Applications that use asynchronous I/O and that may have more than one send outstanding at a time should not use this flag. Enabling this can results in higher CPU and memory usage by Http.Sys.

Gets or sets the maximum number of concurrent connections to accept. Set `-1` for infinite. Set to `null` to use the registry's machine-wide setting. The default value is `null` (machine-wide setting).

Gets or sets the maximum number of requests that will be queued up in Http.Sys. This settings does not apply when attaching to an existing queue. The default is 1000.

Gets or sets the maximum allowed size of any request body in bytes. When set to null, the maximum request body size is unlimited. This limit has no effect on upgraded connections which are always unlimited. This can be overridden per-request via . The default is set to 30,000,000 bytes, which is approximately 28.6MB.

Control whether synchronous input/output is allowed for the HttpContext.Request.Body and HttpContext.Response.Body. The default is `false`.

Gets or sets a value that controls how http.sys reacts when rejecting requests due to throttling conditions - like when the request queue limit is reached. The default in http.sys is "Basic" which means http.sys is just resetting the TCP connection. IIS uses Limited as its default behavior which will result in sending back a 503 - Service Unavailable back to the client. This settings does not apply when attaching to an existing queue.

Inline request processing instead of dispatching to the threadpool.

Enabling this setting will run application code on the IO thread to reduce request processing latency. However, this will limit parallel request processing to . This setting can make overall throughput worse if requests take long to process.

Configures request headers to use encoding.

Defaults to `false`, in which case will be used. />.

Defines the types of request processing timestamps exposed via the Http.Sys HTTP_REQUEST_TIMING_INFO extensibility point.

Use to access these timestamps.

Time the connection started.

Time the first HTTP byte is received.

Time TLS certificate loading starts.

Time TLS certificate loading ends.

Time TLS leg one handshake starts.

Time TLS leg one handshake ends.

Time TLS leg two handshake starts.

Time TLS leg two handshake ends.

Time TLS attribute query starts.

Time TLS attribute query ends.

Time TLS client cert query starts.

Time TLS client cert query ends.

Time HTTP2 streaming starts.

Time HTTP2 header decoding starts.

Time HTTP2 header decoding ends.

Time HTTP header parsing starts.

For most requests, this is a good timestamp to use as a per request starting timestamp.

Time HTTP header parsing ends.

Time Http.Sys starts to determine which request queue to route the request to.

Time Http.Sys has determined which request queue to route the request to.

Time the request is queued for inspection.

Time the request is delivered for inspection.

Time the request has finished being inspected.

Time the request is queued for delegation.

Time the request is delivered for delegation.

Time the request was delegated.

Time the request was queued to the final request queue for processing.

Time the request was delivered to the final request queue for processing.

Time HTTP3 streaming starts.

Time HTTP3 header decoding starts.

Time HTTP3 header decoding ends.

Interface for delegating requests to other Http.Sys request queues.

Indicates if the server can delegate this request to another HttpSys request queue.

Attempt to delegate the request to another Http.Sys request queue. The request body must not be read nor the response started before this is invoked. Check before invoking.

The rule maintaining the handle to the destination queue.

This exposes the Http.Sys HTTP_REQUEST_INFO extensibility point as opaque data for the caller to interperate. ,

A collection of the HTTP_REQUEST_INFO for the current request. The integer represents the identifying HTTP_REQUEST_INFO_TYPE enum value. The Memory is opaque bytes that need to be interperted in the format specified by the enum value.

This exposes the Http.Sys HTTP_REQUEST_TIMING_INFO extensibility point which contains request processing timestamp data from Http.Sys.

Gets all Http.Sys timing timestamps

These timestamps were obtained using QueryPerformanceCounter and the timestamp frequency can be obtained via QueryPerformanceFrequency . The index of the timing can be cast to to know what the timing represents. The value may be 0 if the timing is not available for the current request.

Gets the timestamp for the given timing.

These timestamps were obtained using QueryPerformanceCounter and the timestamp frequency can be obtained via QueryPerformanceFrequency . The timestamp type to get. The value of the timestamp if set. True if the given timing was set (i.e., non-zero).

Gets the elapsed time between the two given timings.

The timestamp type marking the beginning of the time period. The timestamp type marking the end of the time period. A for the elapsed time between the starting and ending timestamps. True if both given timings were set (i.e., non-zero).

This exposes the creation of delegation rules on request queues owned by the server.

Create a delegation rule on request queue owned by the server.

The name of the Http.Sys request queue. The URL of the Http.Sys Url Prefix. Creates a that can used to delegate individual requests.

True if this instace created the queue instead of attaching to an existing one.

Represents a handle to a Windows module (DLL).

Returns a value stating whether the library exports a given proc.

Gets a delegate pointing to a given export from this library.

Opens a library. If 'filename' is not a fully-qualified path, the default search path is used.

Contains helpers for dealing with TLS token binding.

Returns the 'provided' token binding identifier, optionally also returning the 'referred' token binding identifier. Returns null on failure.

Flushes and completes the response.

Forcibly terminate and dispose the request, closing the connection if necessary.

The authentication challenges that will be added to the response if the status code is 401. This must be a subset of the AuthenticationSchemes enabled on the server.

Enable kernel caching for the response with the given timeout. Http.Sys determines if the response can be cached.

Indicates if the response status, reason, and headers are prepared to send and can no longer be modified. This is caused by the first write or flush to the response body.

Used to indicate if this server instance should create a new Http.Sys request queue or attach to an existing one.

Create a new queue. This will fail if there's an existing queue with the same name.

Attach to an existing queue with the name given. This will fail if the queue does not already exist. Most configuration options do not apply when attaching to an existing queue.

Create a queue with the given name if it does not already exist, otherwise attach to the existing queue. Most configuration options do not apply when attaching to an existing queue.

Exposes the Http.Sys timeout configurations. These may also be configured in the registry. These settings do not apply when attaching to an existing queue.

The time, in seconds, allowed for the request entity body to arrive. The default timer is 2 minutes. The HTTP Server API turns on this timer when the request has an entity body. The timer expiration is initially set to the configured value. When the HTTP Server API receives additional data indications on the request, it resets the timer to give the connection another interval. Use TimeSpan.Zero to indicate that system defaults should be used.

The time, in seconds, allowed for the HTTP Server API to drain the entity body on a Keep-Alive connection. The default timer is 2 minutes. On a Keep-Alive connection, after the application has sent a response for a request and before the request entity body has completely arrived, the HTTP Server API starts draining the remainder of the entity body to reach another potentially pipelined request from the client. If the time to drain the remaining entity body exceeds the allowed period the connection is timed out. Use TimeSpan.Zero to indicate that system defaults should be used.

The time, in seconds, allowed for the request to remain in the request queue before the application picks it up. The default timer is 2 minutes. Use TimeSpan.Zero to indicate that system defaults should be used.

The time, in seconds, allowed for an idle connection. The default timer is 2 minutes. This timeout is only enforced after the first request on the connection is routed to the application. Use TimeSpan.Zero to indicate that system defaults should be used.

The time, in seconds, allowed for the HTTP Server API to parse the request header. The default timer is 2 minutes. This timeout is only enforced after the first request on the connection is routed to the application. Use TimeSpan.Zero to indicate that system defaults should be used.

The minimum send rate, in bytes-per-second, for the response. The default response send rate is 150 bytes-per-second. Use 0 to indicate that system defaults should be used. To disable this timer set it to UInt32.MaxValue

A set of URL parameters used to listen for incoming requests.

http://msdn.microsoft.com/en-us/library/windows/desktop/aa364698(v=vs.85).aspx

http or https. Will be normalized to lower case. +, *, IPv4, [IPv6], or a dns name. Http.Sys does not permit punycode (xn--), use Unicode instead. If empty, the default port for the given scheme will be used (80 or 443). Should start and end with a '/', though a missing trailing slash will be added. This value must be un-escaped.

http://msdn.microsoft.com/en-us/library/windows/desktop/aa364698(v=vs.85).aspx

The string that the will be created from.

Gets a value that determines if the prefix's scheme is HTTPS.

Gets the scheme used by the prefix.

Gets the host domain name used by the prefix.

Gets a string representation of the port used by the prefix.

Gets an integer representation of the port used by the prefix.

Gets the path component of the prefix.

Gets a string representation of the prefix

A collection or URL prefixes

Gets a value that determines if this collection is readOnly.

Creates a from the given string, and adds it to this collection.

The string representing the to add to this collection.

Adds a to this collection.

The prefix to add to this collection.

Returns an enumerator that iterates through this collection.

The prefix '{0}' is not registered. Please run the following command as Administrator to register this prefix: netsh http add urlacl url={0} user={1} See "Preregister URL prefixes on the server" on https://go.microsoft.com/fwlink/?linkid=2127065 for more i ...

The destination array is too small.

End has already been called.

The status code '{0}' is not supported.

The stream is not seekable.

The prefix '{0}' is already registered.

This stream only supports read operations.

More data written than specified in the Content-Length header.

Only the http and https schemes are supported.

This stream only supports write operations.

The given IAsyncResult does not match this opperation.

An exception occurred while running an action registered with {0}.

A faster version of String.Concat(, , .ToString("X8"))

Provides extensions method to use Http.sys as the server for the web host.

Specify Http.sys as the server to be used by the web host.

The Microsoft.AspNetCore.Hosting.IWebHostBuilder to configure. A reference to the parameter object.

Specify Http.sys as the server to be used by the web host.

The Microsoft.AspNetCore.Hosting.IWebHostBuilder to configure. A callback to configure Http.sys options. A reference to the parameter object. This class is used when subclassing EndPoint, and provides indication on how to format the memory buffers that winsock uses for network addresses. [To be supplied.] [To be supplied.]

Find the segment of the URI byte array which represents the path.

Compare the beginning portion of the raw URL byte array to https:// and http://

The byte array represents the raw URI Length of the matched bytes, 0 if it is not matched.

Unescape a given path string in place. The given path string may contain escaped char.

The raw path string to be unescaped The unescaped path string

Unescape the percent-encodings

The iterator point to the first % char The place to write to The end of the buffer The byte array

Read the percent-encoding and try unescape it. The operation first peek at the character the iterator points at. If it is % the is then moved on to scan the following to characters. If the two following characters are hexadecimal literals they will be unescaped and the value will be returned. If the first character is not % the iterator will be removed beyond the location of % and -1 will be returned. If the following two characters can't be successfully unescaped the iterator will be move behind the % and -1 will be returned.

The value to read The end of the buffer The byte array The unescaped byte if success. Otherwise return -1.

Read the next char and convert it into hexadecimal value. The iterator will be moved to the next byte no matter no matter whether the operation successes.

The value to read The end of the buffer The byte array The hexadecimal value if successes, otherwise -1.

Used to allocate and distribute re-usable blocks of memory.

This default value passed in to Rent to use the default value for the pool.

Block tracking object used by the byte buffer memory pool. A slab is a large allocation which is divided into smaller blocks. The individual blocks are then treated as independent array segments.

Back-reference to the memory pool which this block was allocated from. It may only be returned to this pool.

This object cannot be instantiated outside of the static Create method

Wraps an array allocated in the pinned object heap in a reusable block of managed memory

Back-reference to the memory pool which this block was allocated from. It may only be returned to this pool.

Used to allocate and distribute re-usable blocks of memory.

The size of a block. 4096 is chosen because most operating systems use 4k pages.

Max allocation block size for pooled blocks, larger values can be leased but they will be disposed after use rather than returned to the pool.

The size of a block. 4096 is chosen because most operating systems use 4k pages.

Thread-safe collection of blocks which are currently in the pool. A slab will pre-allocate all of the block tracking objects and add them to this collection. When memory is requested it is taken from here first, and when it is returned it is re-added.

This is part of implementing the IDisposable pattern.

This default value passed in to Rent to use the default value for the pool.

Called to return a block to the pool. Once Return has been called the memory no longer belongs to the caller, and Very Bad Things will happen if the memory is read of modified subsequently. If a caller fails to call Return and the block tracking object is garbage collected, the block tracking object's finalizer will automatically re-create and return a new tracking object into the pool. This will only happen if there is a bug in the server, however it is necessary to avoid leaving "dead zones" in the slab due to lost block tracking objects.

The block to return. It must have been acquired by calling Lease on the same memory pool instance.

Provides support for efficiently using Tasks to implement the APM (Begin/End) pattern.

Marshals the Task as an IAsyncResult, using the supplied callback and state to implement the APM pattern.

The Task to be marshaled. The callback to be invoked upon completion. The state to be stored in the IAsyncResult. An IAsyncResult to represent the task's asynchronous operation.

Processes an IAsyncResult returned by Begin.

The IAsyncResult to unwrap.

Processes an IAsyncResult returned by Begin.

The IAsyncResult to unwrap.

Provides a simple IAsyncResult that wraps a Task.

We could use the Task as the IAsyncResult if the Task's AsyncState is the same as the object state, but that's very rare, in particular in a situation where someone cares about allocation, and always using TaskAsyncResult simplifies things and enables additional optimizations.

The wrapped Task.

Callback to invoke when the wrapped task completes.

Initializes the IAsyncResult with the Task to wrap and the associated object state.

The Task to wrap. The new AsyncState value. Callback to invoke when the wrapped task completes.

Invokes the callback.

Gets a user-defined object that qualifies or contains information about an asynchronous operation.

Gets a value that indicates whether the asynchronous operation completed synchronously.

This is set lazily based on whether the has completed by the time this object is created.

Gets a value that indicates whether the asynchronous operation has completed.

Gets a that is used to wait for an asynchronous operation to complete.

Allocator that manages blocks of unmanaged memory.

The default block size for the allocator.

This size assumes a common page size and provides an accommodation for the pointer chain used to track allocated blocks.

Instantiate an instance.

The unmanaged memory block size in bytes.

Allocate the requested amount of space from the allocator.

The type requested The count in units A pointer to the reserved memory. The allocated memory is uninitialized.

Allocate the requested amount of space from the allocator.

The type requested The count in units A Span to the reserved memory. The allocated memory is uninitialized.

Get pointer to bytes for the supplied string in UTF-8.

The string The length of the returned byte buffer. A pointer to the buffer of bytes