Arm keepalive timeout timer after response completion.

Async version of parse() - reads data then uses sync parsing.

Read exactly size bytes asynchronously.

Build minimal environ dict for access logging.

Build receive result after waiting for data.

Check whether calling a function raised a ``TypeError`` because the call failed or because something in the function raised the error. :p

Check if fast C parser is available and should be used. Returns False if: - http_parser='python' is explicitly set - gunicorn_h1c is not

Check if H1CProtocol is available (cached at class level).

Clean up resources on exit.

Establish connection to arbiter.

Establish SMTP connection (simulated for demo).

Create a mock HTTP request.

Create a mock HTTP request.

Create an ASGIProtocol instance for testing.

Create an ASGIProtocol instance for testing.

Create an ASGIProtocol instance for testing.

Dispatch command to appropriate handler. Args: message: Request message dict Returns: Response dict

Put body bytes on the wire. The one place body framing happens, so a subclass can frame it differently without reimplementing write()

Execute a parsed command. Args: parts: Command parts (e.g., ["show", "workers"]) Returns: Handler r

Execute while holding the lock.

Called when all headers received. Validates headers for request smuggling vulnerabilities: - Rejects duplicate Content-Length headers

Get ALPN protocol list from configuration. Returns list of ALPN protocol identifiers based on http_protocols setting. Returns empty list if H

Get all buffered data and reset buffer.

Get cached Date header, updating once per second.

Get cached status line bytes.

Get the control socket path, making relative paths absolute.

Generate a unique request ID.

Match prompt to a canned response. Args: prompt: User's input prompt Returns: str: Matched response text

Get SSL context if configured.

Hand the connection over to HTTP/2 once the request is complete. Runs synchronously, inside data_received(), because that is what stops

Accumulate bytes until the connection preface resolves.

Commit to HTTP/2 and replay the bytes read while undecided.

Handle incoming close frame.

Main request handling loop using callback-based parser. Uses synchronous parsing in data_received(), avoiding the async overhead of p

Handle ConnectionTerminated event (GOAWAY frame). Args: event: ConnectionTerminated event

Handle ConnectionTerminated event.

Handle uWSGI protocol connections (legacy path).

Handle continuation frame (already processed in _read_frame).

Handle DataReceived event. Args: event: DataReceived event with body data Returns: None (request completion

Handle DataReceived event.

Handle 'dirty' commands.

Handle a single h2 event. Args: event: h2 event object Returns: HTTP2Request if a request is complete, None

Handle a single h2 event. Args: event: h2 event object Returns: HTTP2Request if a request is complete, None

Handle gunicorn_h1c exceptions with appropriate HTTP status codes. Returns True if the exception was handled, False otherwise.

Serve an Upgrade: h2c request over HTTP/2. The 101 goes out here rather than in _h2c_arm_upgrade so that nothing can write between it

Handle PriorityUpdated event (PRIORITY frame). Args: event: PriorityUpdated event with priority info

Handle PriorityUpdated event (PRIORITY frame). Args: event: PriorityUpdated event with priority info

Handle PROXY protocol detection and parsing. Returns the buffer with proxy protocol data consumed.

Handle RequestReceived event (HEADERS frame). Args: event: RequestReceived event with headers

Handle RequestReceived event (HEADERS frame).

Handle 'show' commands.

Handle StreamEnded event. Args: event: StreamEnded event Returns: HTTP2Request for the completed request

Handle StreamEnded event.

Handle StreamReset event (RST_STREAM frame). Args: event: StreamReset event

Handle StreamReset event.

Handle TrailersReceived event. Args: event: TrailersReceived event with trailer headers Returns: HTTP2Reques

Handle TrailersReceived event.

Handle 'worker' commands.

RFC 9110 section 5.5: only VCHAR, SP, HTAB, and obs-text allowed.

Periodically update heartbeat.

Lazily import h2 library components.

Lazily import h2 library components.

Check if internal buffer is full (HTTP/2 only).

Check if method is valid token with conventional restrictions.

Whether the connection can be reused for another request. A body the application did not read leaves bytes on the socket, which would

Called when keepalive timeout expires.

Create a wsgi.early_hints callback for sending 103 Early Hints. This allows WSGI applications to send 103 Early Hints responses before the fi

Create an error ASGI app for syntax errors during reload.

Callback: request headers are complete.

Pack the message inside ``00`` and ``FF`` As per the dataframing section (5.3) for the websocket spec

Parse all app specifications from config. Populates self.app_specs with parsed information about each app, including the imp

Parse Content-Length delimited body.

Parse chunked transfer encoding.

Parse wrk duration string (e.g., '12.34ms', '1.23s') to ms.

Parse an SSE event.

Parse request using fast C parser (gunicorn_h1c >= 0.4.1).

Parse headers, return True if headers are complete.

Parses for messages in the buffer *buf*. It is assumed that the buffer contains the start character for a message, but that it may c