325 Commits
Author SHA1 Message Date
Aryan Shah bf446775a1 Wait for writes to drain before closing in NIOHTTP2ServerConnectionManagementHandler (#582)
### Motivation

`NIOHTTP2ServerConnectionManagementHandler` was derived from the
implementation in
[`gRPC-swift-nio-transport`](https://github.com/grpc/grpc-swift-nio-transport/blob/main/Sources/GRPCNIOTransportCore/Server/Connection/ServerConnectionManagementHandler.swift).

In that implementation, PR
https://github.com/grpc/grpc-swift-nio-transport/pull/183 updated the
way how the channel is closed. The channel is now first half-closed and
then fully-closed in order to allow all pending writes to drain.

This is also applicable in this implementation, so we should apply the
same change here.

### Modifications

Applied the changes verbatim from PR
https://github.com/grpc/grpc-swift-nio-transport/pull/183.

### Result

Pending writes are drained when gracefully shutting down.
2026-11-17 10:10:41 +00:00
DmitryandDmitry Rantovov 0f3e54e29c Match the documented parameter names to the signatures in NIOHPACK (#562)
The base64 helper looks like it came over from Foundation with
`Data(base64Encoded:options:)` still in the doc comment, and the
parameter is a Bool now. The other two seem to be plain leftovers. All
three are internal, so DocC never builds them and nothing flags the
mismatch. Nothing else touched.

Co-authored-by: Dmitry Rantovov <rantovov5@gmail.com>
2026-09-01 05:57:10 +00:00
Eirik Botten Nicolaysen bea911a3de Reject the empty HTTP/2 field name (#563)
`isValidFieldName` validates a field name with `allSatisfy` over the
tchar set. `allSatisfy` returns `true` for an empty collection, so the
empty field name passes.

The file already states the rule it is implementing. The doc comment at
line 312 quotes:

```
token          = 1*tchar
```

The derivation that follows is correct — I expanded `0x21, 0x23...0x27,
0x2a, 0x2b, 0x2d, 0x2e, 0x30...0x39, 0x5e...0x7a, 0x7c, 0x7e` byte by
byte against tchar minus `A-Z` and every one of the four rewriting steps
in lines 315-341 holds, including the `%x5E-60 / %x61-7A` → `%x5E-7A`
collapse. It is the `1*` quantifier that is missing: the code implements
`*tchar`.

### Scope

All three block types accept an empty name today, since they share
`HeaderFieldName.init`:

```
request:  empty name -> accepted
response: empty name -> accepted
trailers: empty name -> accepted
```

An empty name serialises as `: value`, and RFC 9113 § 8.2.1 lists field
names as something a recipient is required to validate and treat as
malformed when the generic syntax is violated. This is a conformance gap
in a validator that already does the rest of that section — the
uppercase check, the CR/LF/NUL value check and the connection-specific
header check are all there.

(`":"` alone is already rejected, though as `unknownPseudoHeader` rather
than a name error, since `dropFirst()` leaves an empty base name that
matches no known pseudo-header. That path is unchanged here.)

### The change

An explicit early return, mirroring the shape swift-http-types uses for
the same production in `tokenValidity`:

```swift
if buffer.isEmpty {
    return .invalid
}
```

### Tests

Added to `HTTP2FramePayloadToHTTP1CodecCRLFTests.swift`, which already
exercises `validateRequestBlock`, `validateResponseBlock` and
`validateTrailersBlock` directly for the § 8.2.1 value rules. Five
cases: the empty name in each of the three block types, plus `"a b"` and
an ordinary `x-custom-header` to keep the surrounding behaviour pinned.

### Verification

**I could not run `swift test` here**: this machine has Command Line
Tools without XCTest, so the test targets fail at `import XCTest` with
`no such module`. Pre-existing and unrelated — it reproduces on an
unmodified checkout (18 occurrences). **CI should be the authority;
treat my local run as unverified.**

`swift build` succeeds. I linked a throwaway executable against
`NIOHTTP2` to exercise the change directly:

```
PASS request:  empty name       -> rejected
PASS response: empty name       -> rejected
PASS trailers: empty name       -> rejected
PASS request:  "a b"            -> rejected
PASS request:  "Host" (uppercase) -> rejected
PASS request:  valid name       -> accepted
PASS request:  pseudo-headers only -> accepted
```

Before the change the first three were accepted.

### Conflicts

No open PR touches `HPACKHeaders+Validation.swift`. #531 and #562 touch
NIOHPACK, and #531 (`+ Fix a bug`) is about `isASCII` in
`HPACKHeader.swift` — no overlap with `isValidFieldName`.
2026-09-01 05:16:30 +00:00
Aryan Shah d6f5f25943 Rate-limit PING, SETTINGS, PRIORITY, ALTSVC, and ORIGIN frames (#561)
### Motivation

We currently mitigate against receiving an excessive numbers of
RST_STREAM frames, empty DATA frames, or encountering stream errors in a
given time window.

Receiving excessive numbers of PING, SETTINGS, PRIORITY, ALTSVC, or
ORIGIN frames also results in the endpoint performing unnecessary work.
As such, this PR adds these five frames to the current rate-limiting
mechanism.

### Modifications

- Updated `DOSHeuristics` to also rate-limit PING, SETTINGS, PRIORITY,
ALTSVC, and ORIGIN frames.
- Added a new `controlFrameRateLimit` property to
`NIOHTTP2Handler.ConnectionConfiguration`.
- Plumbed the configuration argument to `NIOHTTP2Handler` initializers.

### Result

Mechanism in place to avoid endpoints from being overwhelmed by
excessive PING, SETTINGS, PRIORITY, ALTSVC, or ORIGIN frames.
2026-08-18 17:43:05 +01:00
nishaddeokar 281170341a Fix outbound stream starvation (#559)
Motivation:

`nextStreamToSend()` returned `self.flushableStreams.first`, and since `Set.first` always yields the same stable element, under load the buffer kept handing the whole connection window to one stream while the rest starved to near-zero.

Modifiations:

Rotate through the flushable streams instead of always picking the same one. `flushableStreams` stays the source of truth for membership, and alongside it we keep a queue of those streams (`sendQueue`) in the order to serve them. We pop the front to pick the next stream, and append it to the back once it's been served, so every flushable stream gets a turn per sweep and none can be starved. Both the pop and the append are O(1). Removing a stream from the middle of the queue would be O(n), so we avoid this. A stream that stops being flushable is left as a stale entry and simply skipped when it reaches the front (lazy deletion), with a `queuedStreams` set to stop us ever enqueuing a duplicate.
2026-08-07 08:36:41 +01:00
abhinav9-coderandGeorge Barnett 45bdf67024 NIOHTTP2: reject SP and control characters in pseudo-header values (#555)
Stacks on #554 — the diff will show that commit too until it merges.

## Motivation

`isValidPseudoHeaderValue` rejects CR, LF and NUL, which is narrower
than the HTTP/1.1 request line actually needs.

`:path` ends up as the request-target in:

```
METHOD SP request-target SP HTTP-version CRLF
```

so `:path = "/a HTTP/1.1"` serializes to `GET /a HTTP/1.1 HTTP/1.1`.
Whether a recipient reads the first or the last SP-delimited token as
the version decides what the request-target actually is, which is the
usual parser-differential setup. RFC 9112 § 3.2 wants SP in a
request-target percent-encoded, and bare HTAB and the other CTLs aren't
valid there either.

None of the HTTP/2 pseudo-headers have a grammar that allows SP or a
CTL: `:method` and `:protocol` are tokens, `:scheme` is a URI scheme,
`:authority` is host[:port], `:path` is a request-target, `:status` is
3DIGIT. So rejecting them doesn't reject anything well-formed.

Same severity caveat as #554: NIOHTTP1's
`uriOnlyContainsAllowedCharacters` already rejects SP in a
request-target by default, so this is hardening rather than something
exploitable on a stock pipeline.

## Modifications

`isValidPseudoHeaderValue` goes from `{0x00, 0x0A, 0x0D}` to `<= 0x20 ||
== 0x7F`, so the whole CTL range plus SP and DEL.

Bytes >= 0x80 stay allowed on purpose. They aren't delimiters in a
request line or header block, and rejecting them would break anyone
sending unencoded UTF-8 in `:path`.

### One behaviour change worth flagging

`validateRequestBlock` runs on send as well as receive, so a client
passing a URI with a raw space in it will now throw where it didn't
before. I'd argue that's the right outcome, since NIOHTTP1's validator
already rejects that URI by default and this makes the two layers agree,
but it is a behaviour change and it's the bit most likely to need
discussion. That's why I split it out of #554 instead of bundling them.

## Result

Pseudo-header values containing SP or any control character are
rejected.

## Testing

Added to `HTTP2FramePayloadToHTTP1CodecCRLFTests.swift`:

- `:path` with SP (`/a HTTP/1.1`), HTAB, VT, FF, DEL, SOH
- SP in `:authority`, `:method`, `:scheme`
- covered at the predicate, request-validation and server-codec levels

The existing positive cases in that file still pass untouched — `/`,
`/foo/bar`, `/foo?q=1&r=2`, `/foo#fragment`, `*`, `/foo%20bar`, `200` —
which is the check that this doesn't reject anything legitimate.

Built and ran on Linux, Swift 6.1 aarch64. `swift test -Xswiftc
-warnings-as-errors` is clean with no new warnings, the new tests pass,
and `swift format lint --strict Sources/ Tests/` is clean.

---------

Co-authored-by: George Barnett <gbarnett@apple.com>
2026-07-22 11:34:07 +00:00
abhinav9-coder 48bfd9067d Treat CR, LF and NUL in regular header field values as malformed (#554)
## Motivation

RFC 9113 § 8.2.1 requires that a field value must not contain NUL, LF or
CR at any position, and that a message carrying one is treated as
malformed. That applies to every field value, not just pseudo-headers.

`legalHeaderField(value:)` only enforces it for pseudo-headers. The
regular-header branch checks the forbidden-name list and then returns
without looking at the value:

```swift
switch self.baseName {
case "connection", "transfer-encoding", "proxy-connection", "keep-alive", "upgrade":
    throw NIOHTTP2Errors.forbiddenHeaderField(name: String(self.baseName), value: value)
default:
    return
}
```

Nothing else on the inbound path picks it up either. HPACK values are
length-prefixed octet strings, and I couldn't find any charset
validation of values anywhere in NIOHPACK.

Where it bites is `HTTP2ToHTTP1Codec`. Serializing `name: value CRLF`
with an embedded CR or LF terminates the field early and injects header
lines into the HTTP/1.1 message downstream. Same sink as the `:path`
validation added for GHSA-4px2-pw77-vc85, just reached through a regular
field instead.

To be clear about severity: I don't think this is exploitable on a
default pipeline and I don't have a PoC. NIOHTTP1's
`NIOHTTPRequestHeadersValidator` rejects 0x00...0x1F and 0x7F on write,
and the pipeline helpers insert it by default
(`enableOutboundHeaderValidation` defaults to true). So this is
hardening.

I still think it's worth doing here. It's a MUST that NIOHTTP2 is in the
right place to enforce; `HTTPEncoder` itself doesn't validate, so a
hand-built pipeline has no check at all; and anyone reading
`HTTPRequestHead.headers` and passing values on elsewhere is inheriting
a check they'd probably assume the HTTP/2 layer had already done.

## Modifications

`isValidFieldValue(_:)` rejects 0x00, 0x0A and 0x0D, and
`legalHeaderField(value:)` now calls it for regular headers, throwing a
new `NIOHTTP2Errors.invalidHTTP2HeaderFieldValue`. The state machine
already turns a throw here into the right stream/connection error, so
nothing else needed changing.

SP, HTAB and obs-text stay legal (RFC 9110 § 5.5). It sits behind the
existing `headerBlockValidation` flag. The new error type mirrors
`ForbiddenHeaderField`'s storage pattern and is additive public API.

Two things I left out on purpose, both easy to add if you'd rather have
them:

- § 8.2.1 also forbids a value starting or ending with SP/HTAB. Not
smuggling-relevant, and rejecting it seemed likely to break peers
sending harmless padding.
- No check in the codec itself.
`HTTPRequestHead(http2HeaderBlock:isEndStream:)` validates
pseudo-headers inline via `peekPseudoHeader`, but
`appendRegularHeaders(from:)` just copies. I didn't add one there
because it's per-request and you have allocation thresholds. It does
leave the two asymmetric if `headerBlockValidation` is `.disabled`.

## Result

Regular field values containing NUL, CR or LF are treated as malformed.
Well-formed values are unaffected.

## Testing

Added to `HTTP2FramePayloadToHTTP1CodecCRLFTests.swift`, the regression
file from GHSA-4px2-pw77-vc85, which currently has no coverage for
regular field values.

- `isValidFieldValue` against CRLF, lone CR, lone LF, NUL, a full
smuggling payload, a TE desync payload
- values that must still pass: `with spaces inside`, `with\ttab`,
`text/html; charset=utf-8`, bearer tokens, non-ASCII
- request, response and trailers validation

Built and ran on Linux, Swift 6.1 aarch64. `swift test -Xswiftc
-warnings-as-errors` is clean with no new warnings, the new tests pass,
and `swift format lint --strict Sources/ Tests/` is clean.
2026-07-22 10:58:49 +01:00
AkshayandGeorge Barnett 41a8b95a98 NIOHTTP2: forbid keep-alive and upgrade connection-specific headers (#552)
RFC 9113 § 8.2.2 enumerates five connection-specific header fields that
a conformant HTTP/2 endpoint must treat as malformed: Connection,
Proxy-Connection, Keep-Alive, Transfer-Encoding, and Upgrade.
HeaderFieldName .legalHeaderField(value:) only rejected three of them,
so keep-alive and upgrade passed validation and were translated verbatim
into HTTP/1.1 messages by the H2->H1 codecs. This is a conformance gap
and a defence-in-depth issue, since downstream HTTP/1.1 parsers may act
on those fields independently.

Modifications:

- Add keep-alive and upgrade to the forbidden connection-specific header
switch in legalHeaderField(value:).
- Update the surrounding comment to cite RFC 9113 § 8.2.2 and its
explicit enumeration in place of the obsoleted RFC 7540 § 8.1.2.2
reference.
- Add request- and response-block validation tests covering all five
connection-specific fields.

Result:

All five connection-specific header fields named by RFC 9113 § 8.2.2 are
rejected during header-block validation.

Resolves #549

Co-authored-by: George Barnett <gbarnett@apple.com>
2026-07-02 10:58:11 +00:00
AkshayandGeorge Barnett 2a044b90f4 HPACKDecoder: reject more than two table size updates per header block (#551)
RFC 7541 § 4.2 specifies that an encoder emits at most two dynamic table
size updates between two header blocks (the smallest size reached, then
the final size). The decoder enforced placement - updates must precede
the first header - but put no upper bound on their count, so a block of
arbitrarily many 0x20 bytes followed by a header was accepted. This is a
conformance gap. It is not a DoS: setting an already-empty table to 0 is
O(1).

Modifications:

- Count consecutive table size updates in decodeHeaders(from:) and throw
IllegalDynamicTableSizeChange once a third is seen.
- Extend the existing § 4.2 comment to cite the at-most-two rule.
- Add tests covering the two-accepted and three-rejected cases.

Result:

Header blocks with more than two dynamic table size updates are rejected
as malformed, matching RFC 7541 § 4.2.

Co-authored-by: George Barnett <gbarnett@apple.com>
2026-07-01 11:47:56 +00:00
Fabian Fett 61d1b44f6e Merge commit from fork 2026-05-20 10:08:41 +01:00
Mads Odgaard 81cc18264f Update clampedToValidWindowSize to use Int32.max (#546)
Fixes a runtime crash on 32-bit devices because of an overflow.

This occurred immediately when trying to make a HTTP2 request on our
Android 32-bit devices.
2026-04-14 13:30:42 +00:00
George Barnett 6d8d596f0a Allow connection and stream window target sizes to be configured separately (#543)
Motivation:

At the moment users can only set a target window size which applies to
both the connection and to streams. It should be possible to set these
separately so that one stream can't stall other streams by consuming the
whole flow control window.

Modifications:

- Add target window size to the connection config
- Plumb through the values

Result:

Users can set target flow control window sizes separately
2026-03-18 10:05:08 +00:00
Fabian Fett 9019b76fa8 Improve HPACKEncoding performance by ~1.5x (#542)
As it turns out our `isEqualCaseInsensitiveASCIIBytes` implementation
isn't super fast. So instead of hitting this 60 times for each header
(once for every entry in the static list), we may just want to compute
the hash of our new header candidate once and do a dict lookup.
2026-03-11 16:21:22 +01:00
Fabian Fett 0b600fc4ff Improve HPACKEncoding performance by ~2x (#541) 2026-03-10 17:06:04 +00:00
aryan-25 b6571f3db4 Add a server connection manager (#532)
Motivation:

`NIOHTTP2Handler` currently does not support graceful shutdown because
it does not action upon a `ChannelShouldQuiesceEvent` event. See issue
https://github.com/apple/swift-nio-http2/issues/336.

Per the
[comment](https://github.com/apple/swift-nio-http2/issues/336#issuecomment-2252862397)
on that issue,
[`gRPC-swift-nio-transport`](https://github.com/grpc/grpc-swift-nio-transport)
implements this functionality in a separate channel handler, named
[`ServerConnectionManagementHandler`](https://github.com/grpc/grpc-swift-nio-transport/blob/main/Sources/GRPCNIOTransportCore/Server/Connection/ServerConnectionManagementHandler.swift).
We should introduce this to this repo too.

Modifications:

- Added `ServerConnectionManagementHandler` from
`gRPC-swift-nio-transport` with some slight modifications such as
removing gRPC-specific functionality like policing client pings.
- Added a new `configureAsyncHTTP2Pipeline` helper, which takes a
connection manager configuration as an argument and sets the
connection manager up alongside `NIOHTTP2Handler`.

Result:

Addresses issue https://github.com/apple/swift-nio-http2/issues/336.
2026-02-18 08:08:55 +00:00
Fabian Fett 979f431f1f Optimize HTTP2ToHTTP1 client codec to reduce empty data frames (#535)
The codec now caches the most recent outbound frame and only writes it
on flush or when receiving `.end`. This lets us set `endStream=true` on
the final data or headers frame instead of sending a separate empty data
frame.

Changes:
- Introduced `PendingFrameWrite` to cache frame payload and promise
- Modified `processOutboundData` to return optional frames instead of
writing immediately
- Added `flush()` method to both client codecs to handle cached writes
- Promise merging ensures correct completion notification when combining
frames
2026-02-10 10:16:27 +00:00
George Barnett 5e9e99ec96 Add a frame delegate (#522)
Motivation:

Frames written from a child channel may not be written immediately by
the connection channel. For example, a DATA frame written on a stream
may be larger than the max frame size imposed on the connection and so
the connection channel will have to slice it into multiple frames. Or
the connection may not be writable and may delay the transmission of the
frame. This behaviour isn't currently observable but is useful to know
about.

Modifications:

- Add a frame delegate which is notified when certain frames are written
by the connection channel.

Result:

Users can observer when headers and data frames are written into the
connection channel.
2025-07-18 15:30:36 +01:00
Gus Cairo f0e94525a7 Add GlitchesMonitor (#518)
Add a `GlitchesMonitor` that will terminate a connection if too many glitches are triggered.
See https://github.com/HTTPWorkshop/workshop2024/blob/main/talks/1.%20Security/glitches.pdf for details.
2025-07-16 16:19:40 +01:00
Gus Cairo 623755c0cd Enable warnings as errors (#517) 2025-05-14 14:17:48 +01:00
George Barnett 4281466512 Remove temporary shims (#514)
Motivation:

We added a couple of shims which were upstreamed to swift-nio and were
released in 2.82.0.

Modifications:

- Bump minimum verison of swift-nio
- Remove shims

Result:

Less code
2025-04-23 07:29:33 +01:00
George Barnett 9a582726cf Strict concurrency for perf tests and the h2 server (#509) 2025-03-31 11:31:38 +01:00
George Barnett 276b9cb73d Provide a senable view over the stream multiplexer (#506)
Motivation:

The HTTP2StreamMultiplexer isn't `Sendable`, but it has public API for
creating streams which must operate from off of the `EventLoop`.

Modifications:

- Add a `SendableView` over the multiplexer which only provides the
methods for creating streams. These are safe to call from any isolation
domain.

Result:

Can create streams from off of the EL.
2025-03-27 14:10:38 +00:00
George Barnett 61f6aa4142 Add explicit Sendable annotations (#505) 2025-03-27 14:01:05 +00:00
George BarnettandRick Newton-Rogers 0c020df343 Strict concurrency for pipeline helpers (#503)
Motivation:

To increase concurrency safety the NIOHTTP2 module should compile
without warning under strict concurrency checking.

Modifications:

- Add a few temporary internal helpers
- Annotate the pipeline helpers

Result:

Fewer concurrency warnings

Co-authored-by: Rick Newton-Rogers <rnro@apple.com>
2025-03-27 11:33:37 +00:00
George Barnett a7a0a9a118 Strict concurrency for NIOHPACK (#502)
Motivation:

To increase concurrency safety the NIOPHACK module should compile
without warning under strict concurrency checking.

Modifications:

- Add explicit Sendable annotations

Result:

No concurrency warnings.
2025-03-21 17:15:54 +00:00
George Barnett 1251530b26 Allow max reset stream frames to be configured (#494)
Motivation:

The maximum number of recently reset stream frames to track is limited
to a fixed value of 32. This should be configurable.

Modifications:

- Add it to the connection config and propagate it through

Result:

- Resolves #493
2025-02-28 13:54:05 +00:00
George Barnett 124e859117 Better handle new streams when server is quiescing (#481)
Motivation:

When the server is in the locally quiescing state and a client attempts
to open a new stream, the connection state machine treats receiving the
headers as a connection error. This results in the connection being
closed and in-flight requests being failed.

This can happen because of the inherent race between the server sending
a GOAWAY frame and the client receiving it, during which time the client
can open a stream not knowing it's doomed to failure.

Rather than the server treating this as a connection error, it should
reject the stream with a RST_STREAM frame and emit a stream error.

Modifications:

- Emit a stream error when receiving HEADERS in the locally quiesced
state

Result:

Better handling of new streams when the server is quiescing
2025-01-20 18:01:49 +00:00
Gus Cairo 170f4ca06b Don't fail closeFuture when an error occurs on closing (#487)
Strictly speaking, a `close` operation can't really fail (except when
the closing mode isn't supported or the channel is already closed). Even
if an error is encountered while closing a channel, or if an error
caused the channel to be closed, the end result is the same: the channel
will be closed.

In this case in particular, when streams are closed from the client
(i.e. by sending a RST_STREAM frame) the `HTTP2StreamChannel` would fail
the channel's `closeFuture`. This isn't appropriate however, as the
channel is successfully closed.

This change stops failing the stream channel's `closeFuture`. Instead,
if the close happens uncleanly, the error will be fired down the
pipeline and the `close` method's promise will be failed.
2024-12-16 15:38:34 +00:00
Rick Newton-Rogers 2083f5d7e8 Enable MemberImportVisibility check on all targets (#486)
Enable MemberImportVisibility check on all targets. Use a standard
string header and footer to bracket the new block for ease of updating
in the future with scripts.
2024-12-11 15:38:17 +00:00
Gus Cairo 1879e72392 Finish multiplexer's inbound streams in more cases (#483)
## Motivation
Currently, the multiplexer's inbound streams stream is finished only
when the channel becomes inactive.
There are some scenarios in which the channel may be closed before it
has a chance to become active, and the stream will never be finished.
This can cause any users iterating over the stream to hang.

## Modifications
This PR finishes the inbound streams stream when a connection error is
fired, and when the handler is removed.

## Result
Fewer bugs.
2024-11-15 10:45:47 +00:00
Adam FowlerandGeorge Barnett 91136a6604 Make configureHTTP2AsyncSecureUpgrade public (#480)
Minor PR to make `configureHTTP2AsyncSecureUpgrade ` helper function
public

Co-authored-by: George Barnett <gbarnett@apple.com>
2024-11-14 10:57:17 +00:00
Adam Fowler 04a093d050 Add a variant of configureAsyncHTTPServerPipeline which takes a stream delegate (#471)
In the async HTTP2 pipeline there is no way to account for the opening
and closing of streams. This PR adds a variant of
`configureAsyncHTTPServerPipeline` (HTTP2 upgrade channel) that allows
the user to pass in a `NIOHTTP2StreamDelegate` to be applied to the
HTTP2 channel if the upgrade occurs.

This is similar to #439 which did the same HTTP2 only channels.
2024-11-14 10:27:14 +00:00
Peter Adams 1118370ec4 Apply swift-format changes and CI (#472)
Motivation:

Standardised formatting makes the project cleaner to look at and work
on.

Modifications:

Setup swift-format with the same settings as Swift-NIO

Result:

Common formatting throughout
2024-10-29 13:09:54 +00:00
Peter Adams 31c8609808 Drop support for Swift 5.8 (#470)
Motivation:

Only the last 3 versions of Swift are supported.

Modifications:

Update the Swift tools version in Package.swift.
Remove code which can now never be compiled.
Remove legacy docker configuration.

Result:

Only Swift 5.9+ supported.
2024-10-23 15:06:45 +01:00
Peter Adams bc93af21b0 GitHub Actions to parity with existing CI (#469)
Motivation:

Want to move away from legacy CI.

Modifications:

Add configuration and update code to use GitHub actions.

Result:

GitHub Actions can be used for basic CI.
2024-10-23 14:02:30 +00:00
George BarnettandCory Benfield eaa71bb6ae Add an article about multiplexing (#465)
Motivation:

It's hard to keep track of all the pieces that do multiplexing. When
making some changes I found myself writing down what each piece did and
how they fit together. I think this is generally useful information for
anyone maintaining the library.

Modifications:

- Add a DocC article about the different multiplexing approaches that's
aimed at _maintainers_ of NIOHTTP2.

Result:

Easier to learn about how multiplexing is done

---------

Co-authored-by: Cory Benfield <lukasa@apple.com>
2024-09-18 10:30:35 -07:00
George Barnett 6693a60432 Propagate ChannelShouldQuiesceEvent to child channels (#464)
Motivation:

NIO has a 'ChannelShouldQuiesceEvent' which channels can listen for in
order to know when they should quiesce. This is typically used to
initiate a graceful shutdown of an HTTP/2 server. However, child
channels aren't notified of this event so HTTP/2 servers must keep track
of streams separately in order to notify them when the server is
quiescing.

Modifications:

- Propagate the `ChannelShouldQuiesceEvent` to child channels

Result:

Child channels can watch for `ChannelShouldQuiesceEvent`s
2024-09-18 07:02:53 +01:00
Clinton Nkwocha 376312d334 Handle race condition between sending GOAWAY and HEADERS (#457)
Motivation:

A potential race exists between a server sending a GOAWAY frame and a
client opening a new stream (i.e., sending a HEADERS frame before
receiving an already sent GOAWAY frame). If there are no open streams
when the server sends the GOAWAY frame, the connection state on the
server transitions to being fully quiesced, which throws a connection
error on receipt of a HEADERS frame.

Modifications:

- Adjust the connection state machine on the server to throw a stream
error (instead of a connection error), and consequently, send a
RST_STREAM frame to the client.

Result:

This condition will be treated as a stream-level error instead.
2024-09-06 11:59:15 +01:00
Clinton Nkwocha 9f6d865c81 Accept PING frames even when fully quiesced (#455)
Motivation:

When the connection is fully quiesced, an endpoint responds with a
connection error when it receives or tries to respond to a PING frame.
This behaviour is unnecessary.

Modifications:

- Adjust `HTTP2ConnectionStateMachine` to successfully receive and send
PING frames even when the connection is fully quiesced.

Result:

When the connection is fully quiesced, an endpoint will treat receipt
and sending of a PING frame as it would when the connection is active.
2024-08-30 03:50:01 -07:00
aryan-25 35b0b8f7e5 Fix bug where client ignores HEADERS frames on open stream when locally quiescing (#445)
Motivation:

Currently, HEADERS frames are ignored by the client on a client-initiated stream after the client sends a GOAWAY.

As per [Section 6.8 (GOAWAY) in RFC 9113](https://httpwg.org/specs/rfc9113#GOAWAY):
_"Once the GOAWAY is sent, the sender will ignore frames sent on streams **initiated by the receiver** if the stream has an identifier higher than the included last stream identifier."_

In this case, the client (sender) should **not** ignore the HEADERS frame as the stream is initiated by the _client_, not the receiver.

Modifications:

Fixed the condition in the `receiveHeaders` function (given `LocallyQuiescingState`) in `ReceivingHeadersState.swift` to work for _both_ the client and server roles -- before this change, the condition is only correct when `self.role == ConnectionRole.server`

Result:

HEADERS frames are not ignored by the client on a client-initiated stream when locally quiescing.
2024-07-18 06:55:30 -07:00
George Barnett ab04d05c6f Reduce allocs in HTTP2StreamChannel (#449)
Motivation:

The HTTP2StreamChannel stores two atomic booleans for whether the
channel is active and writable. These are only accessed externally and
access is relatively infrequent. Each atomic requires an allocation,
instead we can just protect each with a single lock.

Modifications:

- Combine the two atomics into a single 'flags' struct protected by a
  locked value box

Result:

Fewer allocations
2024-07-18 01:13:16 -07:00
a2b4d284f4 Make HEADERS frame payload non-indirect (#428)
* Make HEADERS frame payload non-indirect

Motivation:

In previous patches we shrank the size of HTTP2Frame by
making various data types indirect in the frame payload.
This included HEADERS, which is unfortunte as HEADERS frames
are quite common.

This patch changes the layout of the HEADERS frame to remove the
indirect case.

Modifications:

- Move END_STREAM into an OptionSet.
- Turn the two optional bits into flags in the aforementioned
    OptionSet
- Replace the properties with computed properties.
- Remove the indirect case

Result:

HEADERS frames are cheaper.

* Update alloc limits

---------

Co-authored-by: George Barnett <gbarnett@apple.com>
Co-authored-by: Gustavo Cairo <gus.cairo@apple.com>
2024-07-17 09:00:49 -07:00
Gustavo Cairo 79802e0b69 Reduce allocations on InlineStreamMultiplexer/createStreamChannel (#450)
## Motivation
When creating stream channels on the `InlineStreamMultiplexer`, we are currently performing a `flatSubmit` on two different codepaths. This allocates two ELFs: one on `submit`, and one on `flatMap`. This is unnecessary, as we could do with just one allocation.

## Modifications
Create a single ELP and call `execute` on the EL instead of using `flatSubmit`.

## Result
Fewer allocations
2024-07-16 07:29:04 -07:00
Gustavo Cairo aab0f121e5 Add alloc tests for alternative stream creation API (#451)
Allocation tests currently use a func that takes a promise to create the stream multiplexer.
However, we also provide a different API that doesn't require a promise and instead returns an `EventLoopFuture<Channel>`.
We don't currently have allocation tests for the latter, so this PR duplicates the current H2 tests but uses the non-promise API to create the multiplexer.
I also had to add a new method on the old H2 multiplexer to conform to a test protocol.
2024-07-16 14:36:38 +01:00
George Barnett ac2a15cc88 Keep capacity when dropping pending reads in the stream channel (#447)
Motivation:

When the stream channel has closed it drops all of its pending reads. It
does this by calling 'removeAll()' on its CircularBuffer. The buffers
underlying storage is emptied and then a `nil` is appended (internally
CircularBuffer is never empty) which triggers an allocation.

Modifications:

- Remove all but keep capacity

Result:

Fewer allocations
2024-07-08 09:26:51 +01:00
George Barnett ed8a315489 Reduce error allocations (#446)
Motivation:

Existential errors are unconditionally boxed. We typically create and
use errors to fail promises when performing cleanup work. One example
of this is failing pending writes when a stream channel is closed,
however this is done unconditionally which means every stream channel
incurs an allocation when it closes.

Modifications:

- Statically create some existential errors ahead of time

Result:

Fewer allocations
2024-07-05 08:35:46 -04:00
Clinton NkwochaandGeorge Barnett d629013a6e Reject long sequences of CONTINUATION frames (#443)
* Reject long sequences of CONTINUATION frames

Motivation:

Long sequences of CONTINUATION frames can be used to mount attacks by attempting to get a remote peer to consume large amounts of memory.

Modifications:

- Add a limit to the number of sequential CONTINUATION frames that can be received. This limit is configurable by users at the NIOHTTP2Handler level and has a default value of 5. When this limit is exceeded, the recipient responds with a GOAWAY frame and an "Enhance Your Calm" error of a newly created type `ExcessiveContinuationFrames`.

Result:

Long sequences of CONTINUATION frames are now rejected by the recipient.

* Refactor implementation

* Minor adjustments

* Implement adjustments

- Refactor implementation
- Revert unnecessary diffs

* Implement adjustments

- Change `public let maximumSequentialContinuationFrames` to `public var`.
- Refactor implementation.

* Implement minor adjustments

* Store the default `maximumSequentialContinuationFrames` in a `private static let`

---------

Co-authored-by: George Barnett <gbarnett@apple.com>
2024-07-04 14:13:49 +01:00
George Barnett a0224f3d20 Discard read bytes when accumulating continuation frames (#444)
Motivation:

When accumulating sequences of CONTINUATION frames, each frame is parsed
from a buffer. These bytes are read when the CONTINUATION frame is
parsed, but if more CONTINUATION frames follow then the buffer isn't
reset. This means that long sequences of CONTINUATION frames can result
in a larger than necessary buffer where most of the contents have
already been read.

Modifications:

- Discard the bytes of the accumulation buffer when transitioning back
  to AccumulatingHeaderBlockFragmentsParserState if more than half of
  the buffer has been read.

Result:

Lower memory footprint when parsing sequences of CONTINUATION frames.
2024-06-29 08:20:48 -04:00
Eric Rosenberg 6af2cf64cb Implement RFC8441 Extended CONNECT (#441)
Implement RFC8441 Extended CONNECT
2024-06-24 08:33:39 +01:00
George Barnett 8d8eb60992 Add a variant of configureAsyncHTTP2Pipeline which takes a stream delegate (#439)
Motivation:

`configureAsyncHTTP2Pipeline` doesn't allow a stream delegate to be
specified. As the async pipeline uses the "inline" stream multiplexer
there's no way to account for streams within the connection channel.

Modifications:

- Add a sync and async variants of `configureAsyncHTTP2Pipeline` which
  accepts an optional stream delegate
- Rewrite the existing helpers in terms of the new one

Result:

Users can configure an async http pipeline with a stream delegate.
2024-05-16 14:12:57 +01:00