* drain server queue on transport close
* add integration test for clearing conn queue
* improve documentation and test for Transport.Close
* move to handshake_test.go
---------
Co-authored-by: sukun <sukunrt@gmail.com>
* pass *ClientInfo to ConnContext
This allows users to set some state related to the client's remote
address in `ConnContext`.
This also refuses connection early if the returned context is cancelled.
* review comments
* better error assertion
---------
Co-authored-by: Marten Seemann <martenseemann@gmail.com>
* Update comment styles
1. Use doc links (the square brackets around identifiers) to make
clickable links on pkg.go.dev (https://go.dev/doc/comment#doclinks)
2. Indent lists so that they are rendered properly -- at which point go
fmt updates the bullet character to a dash
(https://go.dev/doc/comment#lists)
3. Add a couple missing punctuation marks
These all will improve the experience of browsing the quic-go docs on
pkg.go.dev.
* ignore SA1019 for the ConnectionTracingID
* ci: exclude ConnectionTracing(ID, Key) from staticlint in http3
---------
Co-authored-by: Marten Seemann <martenseemann@gmail.com>
* pass a context to Transport.ConnContext
This context is cancelled when the QUIC connection is closed, or when
the QUIC handshake fails. This allows the application to easily build
and garbage collect a map of active connections.
* correctly handle fresh contexts returned from ConnContext
* use Transport.VerifySourceAddress to control the Retry Mechanism
This can be used to rate-limit handshakes originating from unverified
source addresses. Rate-limiting for handshakes can be implemented using
the GetConfigForClient callback on the Config.
* pass the remote address to Transport.VerifySourceAddress
* avoid lock contention when accepting new connections
The server used to hold the packet handler map's lock while creating the
connection struct for a newly accepted connection. This was intended to
make sure that no two connections with the same Destination Connection
ID could be created.
This is a corner case: it can only happen if two Initial packets with
the same Destination Connection ID are received at the same time. If
the second one is received after the first one has already been
processed, it would be routed to the first connection. We don't need to
optimized for this corner case. It's ok to create a new connection in
that case, and immediately close it if this collision is detected.
* only pass 0-RTT to the connection if it was actually accepted
* add Transport config options to limit the number of handshakes
* fix accounting for failed handshakes
* increase handshake limits, improve documentation
So far, we used Connection.destroy, which destroys a connection without
sending out a CONNECTION_CLOSE frame. This is useful (for example) when
receiving a stateless reset, but it's not what we want when the server
refuses an incoming connection. In this case, we want to send out a
packet with a CONNECTION_CLOSE frame to inform the client that the
connection attempt is being rejected.
There's no need to have a dedicated shutdown method, as the use case
(shutting down an outgoing connection attempt on context cancellation)
can be achieved by using Connection.destroy.
There is no good reason to manually set the validity period for Retry
tokens. Retry tokens are only valid on a single connection during the
handshake, so it makes sense to limit their validity to the configured
handshake timeout.
