Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2025-05-25 12:27
📄 ack_delay.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "math" "time" ) // An unscaledAckDelay is an ACK Delay field value from an ACK packet, // without the ack_delay_exponent scaling applied. type unscaledAckDelay int64 func unscaledAckDelayFromDuration(d time.Duration, ackDelayExponent uint8) unscaledAckDelay { return unscaledAckDelay(d.Microseconds() >> ackDelayExponent) } func (d unscaledAckDelay) Duration(ackDelayExponent uint8) time.Duration { if int64(d) > (math.MaxInt64>>ackDelayExponent)/int64(time.Microsecond) { // If scaling the delay would overflow, ignore the delay. return 0 } return time.Duration(d<<ackDelayExponent) * time.Microsecond }	820 B	2025-05-25 12:27
📄 ack_delay_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "math" "testing" "time" ) func TestAckDelayFromDuration(t testing.T) { for _, test := range []struct { d time.Duration ackDelayExponent uint8 want unscaledAckDelay }{{ d: 8 time.Microsecond, ackDelayExponent: 3, want: 1, }, { d: 1 * time.Nanosecond, ackDelayExponent: 3, want: 0, // rounds to zero }, { d: 3 * (1 << 20) * time.Microsecond, ackDelayExponent: 20, want: 3, }} { got := unscaledAckDelayFromDuration(test.d, test.ackDelayExponent) if got != test.want { t.Errorf("unscaledAckDelayFromDuration(%v, %v) = %v, want %v", test.d, test.ackDelayExponent, got, test.want) } } } func TestAckDelayToDuration(t testing.T) { for _, test := range []struct { d unscaledAckDelay ackDelayExponent uint8 want time.Duration }{{ d: 1, ackDelayExponent: 3, want: 8 time.Microsecond, }, { d: 0, ackDelayExponent: 3, want: 0, }, { d: 3, ackDelayExponent: 20, want: 3 * (1 << 20) * time.Microsecond, }, { d: math.MaxInt64 / 1000, ackDelayExponent: 0, want: (math.MaxInt64 / 1000) * time.Microsecond, }, { d: (math.MaxInt64 / 1000) + 1, ackDelayExponent: 0, want: 0, // return 0 on overflow }, { d: math.MaxInt64 / 1000 / 8, ackDelayExponent: 3, want: (math.MaxInt64 / 1000 / 8) * 8 * time.Microsecond, }, { d: (math.MaxInt64 / 1000 / 8) + 1, ackDelayExponent: 3, want: 0, // return 0 on overflow }} { got := test.d.Duration(test.ackDelayExponent) if got != test.want { t.Errorf("unscaledAckDelay(%v).Duration(%v) = %v, want %v", test.d, test.ackDelayExponent, int64(got), int64(test.want)) } } }	2.08 KB	2025-05-25 12:27
📄 acks.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "time" ) // ackState tracks packets received from a peer within a number space. // It handles packet deduplication (don't process the same packet twice) and // determines the timing and content of ACK frames. type ackState struct { seen rangeset[packetNumber] // The time at which we must send an ACK frame, even if we have no other data to send. nextAck time.Time // The time we received the largest-numbered packet in seen. maxRecvTime time.Time // The largest-numbered ack-eliciting packet in seen. maxAckEliciting packetNumber // The number of ack-eliciting packets in seen that we have not yet acknowledged. unackedAckEliciting int } // shouldProcess reports whether a packet should be handled or discarded. func (acks ackState) shouldProcess(num packetNumber) bool { if packetNumber(acks.seen.min()) > num { // We've discarded the state for this range of packet numbers. // Discard the packet rather than potentially processing a duplicate. // https://www.rfc-editor.org/rfc/rfc9000.html#section-13.2.3-5 return false } if acks.seen.contains(num) { // Discard duplicate packets. return false } return true } // receive records receipt of a packet. func (acks ackState) receive(now time.Time, space numberSpace, num packetNumber, ackEliciting bool) { if ackEliciting { acks.unackedAckEliciting++ if acks.mustAckImmediately(space, num) { acks.nextAck = now } else if acks.nextAck.IsZero() { // This packet does not need to be acknowledged immediately, // but the ack must not be intentionally delayed by more than // the max_ack_delay transport parameter we sent to the peer. // // We always delay acks by the maximum allowed, less the timer // granularity. ("[max_ack_delay] SHOULD include the receiver's // expected delays in alarms firing.") // // https://www.rfc-editor.org/rfc/rfc9000#section-18.2-4.28.1 acks.nextAck = now.Add(maxAckDelay - timerGranularity) } if num > acks.maxAckEliciting { acks.maxAckEliciting = num } } acks.seen.add(num, num+1) if num == acks.seen.max() { acks.maxRecvTime = now } // Limit the total number of ACK ranges by dropping older ranges. // // Remembering more ranges results in larger ACK frames. // // Remembering a large number of ranges could result in ACK frames becoming // too large to fit in a packet, in which case we will silently drop older // ranges during packet construction. // // Remembering fewer ranges can result in unnecessary retransmissions, // since we cannot accept packets older than the oldest remembered range. // // The limit here is completely arbitrary. If it seems wrong, it probably is. // // https://www.rfc-editor.org/rfc/rfc9000#section-13.2.3 const maxAckRanges = 8 if overflow := acks.seen.numRanges() - maxAckRanges; overflow > 0 { acks.seen.removeranges(0, overflow) } } // mustAckImmediately reports whether an ack-eliciting packet must be acknowledged immediately, // or whether the ack may be deferred. func (acks ackState) mustAckImmediately(space numberSpace, num packetNumber) bool { // https://www.rfc-editor.org/rfc/rfc9000.html#section-13.2.1 if space != appDataSpace { // "[...] all ack-eliciting Initial and Handshake packets [...]" // https://www.rfc-editor.org/rfc/rfc9000.html#section-13.2.1-2 return true } if num < acks.maxAckEliciting { // "[...] when the received packet has a packet number less than another // ack-eliciting packet that has been received [...]" // https://www.rfc-editor.org/rfc/rfc9000.html#section-13.2.1-8.1 return true } if acks.seen.rangeContaining(acks.maxAckEliciting).end != num { // "[...] when the packet has a packet number larger than the highest-numbered // ack-eliciting packet that has been received and there are missing packets // between that packet and this packet." // https://www.rfc-editor.org/rfc/rfc9000.html#section-13.2.1-8.2 // // This case is a bit tricky. Let's say we've received: // 0, ack-eliciting // 1, ack-eliciting // 3, NOT ack eliciting // // We have sent ACKs for 0 and 1. If we receive ack-eliciting packet 2, // we do not need to send an immediate ACK, because there are no missing // packets between it and the highest-numbered ack-eliciting packet (1). // If we receive ack-eliciting packet 4, we do need to send an immediate ACK, // because there's a gap (the missing packet 2). // // We check for this by looking up the ACK range which contains the // highest-numbered ack-eliciting packet: [0, 1) in the above example. // If the range ends just before the packet we are now processing, // there are no gaps. If it does not, there must be a gap. return true } // "[...] SHOULD send an ACK frame after receiving at least two ack-eliciting packets." // https://www.rfc-editor.org/rfc/rfc9000.html#section-13.2.2 // // This ack frequency takes a substantial toll on performance, however. // Follow the behavior of Google QUICHE: // Ack every other packet for the first 100 packets, and then ack every 10th packet. // This keeps ack frequency high during the beginning of slow start when CWND is // increasing rapidly. packetsBeforeAck := 2 if acks.seen.max() > 100 { packetsBeforeAck = 10 } return acks.unackedAckEliciting >= packetsBeforeAck } // shouldSendAck reports whether the connection should send an ACK frame at this time, // in an ACK-only packet if necessary. func (acks ackState) shouldSendAck(now time.Time) bool { return !acks.nextAck.IsZero() && !acks.nextAck.After(now) } // acksToSend returns the set of packet numbers to ACK at this time, and the current ack delay. // It may return acks even if shouldSendAck returns false, when there are unacked // ack-eliciting packets whose ack is being delayed. func (acks ackState) acksToSend(now time.Time) (nums rangeset[packetNumber], ackDelay time.Duration) { if acks.nextAck.IsZero() && acks.unackedAckEliciting == 0 { return nil, 0 } // "[...] the delays intentionally introduced between the time the packet with the // largest packet number is received and the time an acknowledgement is sent." // https://www.rfc-editor.org/rfc/rfc9000#section-13.2.5-1 delay := now.Sub(acks.maxRecvTime) if delay < 0 { delay = 0 } return acks.seen, delay } // sentAck records that an ACK frame has been sent. func (acks ackState) sentAck() { acks.nextAck = time.Time{} acks.unackedAckEliciting = 0 } // handleAck records that an ack has been received for a ACK frame we sent // containing the given Largest Acknowledged field. func (acks ackState) handleAck(largestAcked packetNumber) { // We can stop acking packets less or equal to largestAcked. // https://www.rfc-editor.org/rfc/rfc9000.html#section-13.2.4-1 // // We rely on acks.seen containing the largest packet number that has been successfully // processed, so we retain the range containing largestAcked and discard previous ones. acks.seen.sub(0, acks.seen.rangeContaining(largestAcked).start) } // largestSeen reports the largest seen packet. func (acks ackState) largestSeen() packetNumber { return acks.seen.max() }	7.15 KB	2025-05-25 12:27
📄 acks_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "slices" "testing" "time" ) func TestAcksDisallowDuplicate(t testing.T) { // Don't process a packet that we've seen before. acks := ackState{} now := time.Now() receive := []packetNumber{0, 1, 2, 4, 7, 6, 9} seen := map[packetNumber]bool{} for i, pnum := range receive { acks.receive(now, appDataSpace, pnum, true) seen[pnum] = true for ppnum := packetNumber(0); ppnum < 11; ppnum++ { if got, want := acks.shouldProcess(ppnum), !seen[ppnum]; got != want { t.Fatalf("after receiving %v: acks.shouldProcess(%v) = %v, want %v", receive[:i+1], ppnum, got, want) } } } } func TestAcksDisallowDiscardedAckRanges(t testing.T) { // Don't process a packet with a number in a discarded range. acks := ackState{} now := time.Now() for pnum := packetNumber(0); ; pnum += 2 { acks.receive(now, appDataSpace, pnum, true) send, _ := acks.acksToSend(now) for ppnum := packetNumber(0); ppnum < packetNumber(send.min()); ppnum++ { if acks.shouldProcess(ppnum) { t.Fatalf("after limiting ack ranges to %v: acks.shouldProcess(%v) (in discarded range) = true, want false", send, ppnum) } } if send.min() > 10 { break } } } func TestAcksSent(t testing.T) { type packet struct { pnum packetNumber ackEliciting bool } for _, test := range []struct { name string space numberSpace // ackedPackets and packets are packets that we receive. // After receiving all packets in ackedPackets, we send an ack. // Then we receive the subsequent packets in packets. ackedPackets []packet packets []packet wantDelay time.Duration wantAcks rangeset[packetNumber] }{{ name: "no packets to ack", space: initialSpace, }, { name: "non-ack-eliciting packets are not acked", space: initialSpace, packets: []packet{{ pnum: 0, ackEliciting: false, }}, }, { name: "ack-eliciting Initial packets are acked immediately", space: initialSpace, packets: []packet{{ pnum: 0, ackEliciting: true, }}, wantAcks: rangeset[packetNumber]{{0, 1}}, wantDelay: 0, }, { name: "ack-eliciting Handshake packets are acked immediately", space: handshakeSpace, packets: []packet{{ pnum: 0, ackEliciting: true, }}, wantAcks: rangeset[packetNumber]{{0, 1}}, wantDelay: 0, }, { name: "ack-eliciting AppData packets are acked after max_ack_delay", space: appDataSpace, packets: []packet{{ pnum: 0, ackEliciting: true, }}, wantAcks: rangeset[packetNumber]{{0, 1}}, wantDelay: maxAckDelay - timerGranularity, }, { name: "reordered ack-eliciting packets are acked immediately", space: appDataSpace, ackedPackets: []packet{{ pnum: 1, ackEliciting: true, }}, packets: []packet{{ pnum: 0, ackEliciting: true, }}, wantAcks: rangeset[packetNumber]{{0, 2}}, wantDelay: 0, }, { name: "gaps in ack-eliciting packets are acked immediately", space: appDataSpace, packets: []packet{{ pnum: 1, ackEliciting: true, }}, wantAcks: rangeset[packetNumber]{{1, 2}}, wantDelay: 0, }, { name: "reordered non-ack-eliciting packets are not acked immediately", space: appDataSpace, ackedPackets: []packet{{ pnum: 1, ackEliciting: true, }}, packets: []packet{{ pnum: 2, ackEliciting: true, }, { pnum: 0, ackEliciting: false, }, { pnum: 4, ackEliciting: false, }}, wantAcks: rangeset[packetNumber]{{0, 3}, {4, 5}}, wantDelay: maxAckDelay - timerGranularity, }, { name: "immediate ack after two ack-eliciting packets are received", space: appDataSpace, packets: []packet{{ pnum: 0, ackEliciting: true, }, { pnum: 1, ackEliciting: true, }}, wantAcks: rangeset[packetNumber]{{0, 2}}, wantDelay: 0, }} { t.Run(test.name, func(t testing.T) { acks := ackState{} start := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC) for _, p := range test.ackedPackets { t.Logf("receive %v.%v, ack-eliciting=%v", test.space, p.pnum, p.ackEliciting) acks.receive(start, test.space, p.pnum, p.ackEliciting) } t.Logf("send an ACK frame") acks.sentAck() for _, p := range test.packets { t.Logf("receive %v.%v, ack-eliciting=%v", test.space, p.pnum, p.ackEliciting) acks.receive(start, test.space, p.pnum, p.ackEliciting) } switch { case len(test.wantAcks) == 0: // No ACK should be sent, even well after max_ack_delay. if acks.shouldSendAck(start.Add(10 * maxAckDelay)) { t.Errorf("acks.shouldSendAck(T+10max_ack_delay) = true, want false") } case test.wantDelay > 0: // No ACK should be sent before a delay. if acks.shouldSendAck(start.Add(test.wantDelay - 1)) { t.Errorf("acks.shouldSendAck(T+%v-1ns) = true, want false", test.wantDelay) } fallthrough default: // ACK should be sent after a delay. if !acks.shouldSendAck(start.Add(test.wantDelay)) { t.Errorf("acks.shouldSendAck(T+%v) = false, want true", test.wantDelay) } } // acksToSend always reports the available packets that can be acked, // and the amount of time that has passed since the most recent acked // packet was received. for _, delay := range []time.Duration{ 0, test.wantDelay, test.wantDelay + 1, } { gotNums, gotDelay := acks.acksToSend(start.Add(delay)) wantDelay := delay if len(gotNums) == 0 { wantDelay = 0 } if !slices.Equal(gotNums, test.wantAcks) \|\| gotDelay != wantDelay { t.Errorf("acks.acksToSend(T+%v) = %v, %v; want %v, %v", delay, gotNums, gotDelay, test.wantAcks, wantDelay) } } }) } } func TestAcksDiscardAfterAck(t testing.T) { acks := ackState{} now := time.Now() acks.receive(now, appDataSpace, 0, true) acks.receive(now, appDataSpace, 2, true) acks.receive(now, appDataSpace, 4, true) acks.receive(now, appDataSpace, 5, true) acks.receive(now, appDataSpace, 6, true) acks.handleAck(6) // discards all ranges prior to the one containing packet 6 acks.receive(now, appDataSpace, 7, true) got, _ := acks.acksToSend(now) if len(got) != 1 { t.Errorf("acks.acksToSend contains ranges prior to last acknowledged ack; got %v, want 1 range", got) } } func TestAcksLargestSeen(t *testing.T) { acks := ackState{} now := time.Now() acks.receive(now, appDataSpace, 0, true) acks.receive(now, appDataSpace, 4, true) acks.receive(now, appDataSpace, 1, true) if got, want := acks.largestSeen(), packetNumber(4); got != want { t.Errorf("acks.largestSeen() = %v, want %v", got, want) } }	6.61 KB	2025-05-25 12:27
📄 atomic_bits.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import "sync/atomic" // atomicBits is an atomic uint32 that supports setting individual bits. type atomicBits[T ~uint32] struct { bits atomic.Uint32 } // set sets the bits in mask to the corresponding bits in v. // It returns the new value. func (a atomicBits[T]) set(v, mask T) T { if v&^mask != 0 { panic("BUG: bits in v are not in mask") } for { o := a.bits.Load() n := (o &^ uint32(mask)) \| uint32(v) if a.bits.CompareAndSwap(o, n) { return T(n) } } } func (a atomicBits[T]) load() T { return T(a.bits.Load()) }	733 B	2025-05-25 12:27
📄 bench_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "context" "fmt" "io" "math" "sync" "testing" ) // BenchmarkThroughput is based on the crypto/tls benchmark of the same name. func BenchmarkThroughput(b testing.B) { for size := 1; size <= 64; size <<= 1 { name := fmt.Sprintf("%dMiB", size) b.Run(name, func(b testing.B) { throughput(b, int64(size<<20)) }) } } func throughput(b testing.B, totalBytes int64) { // Same buffer size as crypto/tls's BenchmarkThroughput, for consistency. const bufsize = 32 << 10 cli, srv := newLocalConnPair(b, &Config{}, &Config{}) go func() { buf := make([]byte, bufsize) for i := 0; i < b.N; i++ { sconn, err := srv.AcceptStream(context.Background()) if err != nil { panic(fmt.Errorf("AcceptStream: %v", err)) } if _, err := io.CopyBuffer(sconn, sconn, buf); err != nil { panic(fmt.Errorf("CopyBuffer: %v", err)) } sconn.Close() } }() b.SetBytes(totalBytes) buf := make([]byte, bufsize) chunks := int(math.Ceil(float64(totalBytes) / float64(len(buf)))) for i := 0; i < b.N; i++ { cconn, err := cli.NewStream(context.Background()) if err != nil { b.Fatalf("NewStream: %v", err) } closec := make(chan struct{}) go func() { defer close(closec) buf := make([]byte, bufsize) if _, err := io.CopyBuffer(io.Discard, cconn, buf); err != nil { panic(fmt.Errorf("Discard: %v", err)) } }() for j := 0; j < chunks; j++ { _, err := cconn.Write(buf) if err != nil { b.Fatalf("Write: %v", err) } } cconn.CloseWrite() <-closec cconn.Close() } } func BenchmarkReadByte(b testing.B) { cli, srv := newLocalConnPair(b, &Config{}, &Config{}) var wg sync.WaitGroup defer wg.Wait() wg.Add(1) go func() { defer wg.Done() buf := make([]byte, 1<<20) sconn, err := srv.AcceptStream(context.Background()) if err != nil { panic(fmt.Errorf("AcceptStream: %v", err)) } for { if _, err := sconn.Write(buf); err != nil { break } sconn.Flush() } }() b.SetBytes(1) cconn, err := cli.NewStream(context.Background()) if err != nil { b.Fatalf("NewStream: %v", err) } cconn.Flush() for i := 0; i < b.N; i++ { _, err := cconn.ReadByte() if err != nil { b.Fatalf("ReadByte: %v", err) } } cconn.Close() } func BenchmarkWriteByte(b testing.B) { cli, srv := newLocalConnPair(b, &Config{}, &Config{}) var wg sync.WaitGroup defer wg.Wait() wg.Add(1) go func() { defer wg.Done() sconn, err := srv.AcceptStream(context.Background()) if err != nil { panic(fmt.Errorf("AcceptStream: %v", err)) } n, err := io.Copy(io.Discard, sconn) if n != int64(b.N) \|\| err != nil { b.Errorf("server io.Copy() = %v, %v; want %v, nil", n, err, b.N) } }() b.SetBytes(1) cconn, err := cli.NewStream(context.Background()) if err != nil { b.Fatalf("NewStream: %v", err) } cconn.Flush() for i := 0; i < b.N; i++ { if err := cconn.WriteByte(0); err != nil { b.Fatalf("WriteByte: %v", err) } } cconn.Close() } func BenchmarkStreamCreation(b testing.B) { cli, srv := newLocalConnPair(b, &Config{}, &Config{}) go func() { for i := 0; i < b.N; i++ { sconn, err := srv.AcceptStream(context.Background()) if err != nil { panic(fmt.Errorf("AcceptStream: %v", err)) } sconn.Close() } }() buf := make([]byte, 1) for i := 0; i < b.N; i++ { cconn, err := cli.NewStream(context.Background()) if err != nil { b.Fatalf("NewStream: %v", err) } cconn.Write(buf) cconn.Flush() cconn.Read(buf) cconn.Close() } }	3.6 KB	2025-05-25 12:27
📄 config.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "crypto/tls" "log/slog" "math" "time" ) // A Config structure configures a QUIC endpoint. // A Config must not be modified after it has been passed to a QUIC function. // A Config may be reused; the quic package will also not modify it. type Config struct { // TLSConfig is the endpoint's TLS configuration. // It must be non-nil and include at least one certificate or else set GetCertificate. TLSConfig tls.Config // MaxBidiRemoteStreams limits the number of simultaneous bidirectional streams // a peer may open. // If zero, the default value of 100 is used. // If negative, the limit is zero. MaxBidiRemoteStreams int64 // MaxUniRemoteStreams limits the number of simultaneous unidirectional streams // a peer may open. // If zero, the default value of 100 is used. // If negative, the limit is zero. MaxUniRemoteStreams int64 // MaxStreamReadBufferSize is the maximum amount of data sent by the peer that a // stream will buffer for reading. // If zero, the default value of 1MiB is used. // If negative, the limit is zero. MaxStreamReadBufferSize int64 // MaxStreamWriteBufferSize is the maximum amount of data a stream will buffer for // sending to the peer. // If zero, the default value of 1MiB is used. // If negative, the limit is zero. MaxStreamWriteBufferSize int64 // MaxConnReadBufferSize is the maximum amount of data sent by the peer that a // connection will buffer for reading, across all streams. // If zero, the default value of 1MiB is used. // If negative, the limit is zero. MaxConnReadBufferSize int64 // RequireAddressValidation may be set to true to enable address validation // of client connections prior to starting the handshake. // // Enabling this setting reduces the amount of work packets with spoofed // source address information can cause a server to perform, // at the cost of increased handshake latency. RequireAddressValidation bool // StatelessResetKey is used to provide stateless reset of connections. // A restart may leave an endpoint without access to the state of // existing connections. Stateless reset permits an endpoint to respond // to a packet for a connection it does not recognize. // // This field should be filled with random bytes. // The contents should remain stable across restarts, // to permit an endpoint to send a reset for // connections created before a restart. // // The contents of the StatelessResetKey should not be exposed. // An attacker can use knowledge of this field's value to // reset existing connections. // // If this field is left as zero, stateless reset is disabled. StatelessResetKey [32]byte // HandshakeTimeout is the maximum time in which a connection handshake must complete. // If zero, the default of 10 seconds is used. // If negative, there is no handshake timeout. HandshakeTimeout time.Duration // MaxIdleTimeout is the maximum time after which an idle connection will be closed. // If zero, the default of 30 seconds is used. // If negative, idle connections are never closed. // // The idle timeout for a connection is the minimum of the maximum idle timeouts // of the endpoints. MaxIdleTimeout time.Duration // KeepAlivePeriod is the time after which a packet will be sent to keep // an idle connection alive. // If zero, keep alive packets are not sent. // If greater than zero, the keep alive period is the smaller of KeepAlivePeriod and // half the connection idle timeout. KeepAlivePeriod time.Duration // QLogLogger receives qlog events. // // Events currently correspond to the definitions in draft-ietf-qlog-quic-events-03. // This is not the latest version of the draft, but is the latest version supported // by common event log viewers as of the time this paragraph was written. // // The qlog package contains a slog.Handler which serializes qlog events // to a standard JSON representation. QLogLogger slog.Logger } // Clone returns a shallow clone of c, or nil if c is nil. // It is safe to clone a [Config] that is being used concurrently by a QUIC endpoint. func (c Config) Clone() Config { n := c return &n } func configDefault[T ~int64](v, def, limit T) T { switch { case v == 0: return def case v < 0: return 0 default: return min(v, limit) } } func (c Config) maxBidiRemoteStreams() int64 { return configDefault(c.MaxBidiRemoteStreams, 100, maxStreamsLimit) } func (c Config) maxUniRemoteStreams() int64 { return configDefault(c.MaxUniRemoteStreams, 100, maxStreamsLimit) } func (c Config) maxStreamReadBufferSize() int64 { return configDefault(c.MaxStreamReadBufferSize, 1<<20, maxVarint) } func (c Config) maxStreamWriteBufferSize() int64 { return configDefault(c.MaxStreamWriteBufferSize, 1<<20, maxVarint) } func (c Config) maxConnReadBufferSize() int64 { return configDefault(c.MaxConnReadBufferSize, 1<<20, maxVarint) } func (c Config) handshakeTimeout() time.Duration { return configDefault(c.HandshakeTimeout, defaultHandshakeTimeout, math.MaxInt64) } func (c Config) maxIdleTimeout() time.Duration { return configDefault(c.MaxIdleTimeout, defaultMaxIdleTimeout, math.MaxInt64) } func (c *Config) keepAlivePeriod() time.Duration { return configDefault(c.KeepAlivePeriod, defaultKeepAlivePeriod, math.MaxInt64) }	5.35 KB	2025-05-25 12:27
📄 config_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import "testing" func TestConfigTransportParameters(t testing.T) { const ( wantInitialMaxData = int64(1) wantInitialMaxStreamData = int64(2) wantInitialMaxStreamsBidi = int64(3) wantInitialMaxStreamsUni = int64(4) ) tc := newTestConn(t, clientSide, func(c Config) { c.MaxBidiRemoteStreams = wantInitialMaxStreamsBidi c.MaxUniRemoteStreams = wantInitialMaxStreamsUni c.MaxStreamReadBufferSize = wantInitialMaxStreamData c.MaxConnReadBufferSize = wantInitialMaxData }) tc.handshake() if tc.sentTransportParameters == nil { t.Fatalf("conn didn't send transport parameters during handshake") } p := tc.sentTransportParameters if got, want := p.initialMaxData, wantInitialMaxData; got != want { t.Errorf("initial_max_data = %v, want %v", got, want) } if got, want := p.initialMaxStreamDataBidiLocal, wantInitialMaxStreamData; got != want { t.Errorf("initial_max_stream_data_bidi_local = %v, want %v", got, want) } if got, want := p.initialMaxStreamDataBidiRemote, wantInitialMaxStreamData; got != want { t.Errorf("initial_max_stream_data_bidi_remote = %v, want %v", got, want) } if got, want := p.initialMaxStreamDataUni, wantInitialMaxStreamData; got != want { t.Errorf("initial_max_stream_data_uni = %v, want %v", got, want) } if got, want := p.initialMaxStreamsBidi, wantInitialMaxStreamsBidi; got != want { t.Errorf("initial_max_stream_data_uni = %v, want %v", got, want) } if got, want := p.initialMaxStreamsUni, wantInitialMaxStreamsUni; got != want { t.Errorf("initial_max_stream_data_uni = %v, want %v", got, want) } }	1.74 KB	2025-05-25 12:27
📄 congestion_reno.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "context" "log/slog" "math" "time" ) // ccReno is the NewReno-based congestion controller defined in RFC 9002. // https://www.rfc-editor.org/rfc/rfc9002.html#section-7 type ccReno struct { maxDatagramSize int // Maximum number of bytes allowed to be in flight. congestionWindow int // Sum of size of all packets that contain at least one ack-eliciting // or PADDING frame (i.e., any non-ACK frame), and have neither been // acknowledged nor declared lost. bytesInFlight int // When the congestion window is below the slow start threshold, // the controller is in slow start. slowStartThreshold int // The time the current recovery period started, or zero when not // in a recovery period. recoveryStartTime time.Time // Accumulated count of bytes acknowledged in congestion avoidance. congestionPendingAcks int // When entering a recovery period, we are allowed to send one packet // before reducing the congestion window. sendOnePacketInRecovery is // true if we haven't sent that packet yet. sendOnePacketInRecovery bool // inRecovery is set when we are in the recovery state. inRecovery bool // underutilized is set if the congestion window is underutilized // due to insufficient application data, flow control limits, or // anti-amplification limits. underutilized bool // ackLastLoss is the sent time of the newest lost packet processed // in the current batch. ackLastLoss time.Time // Data tracking the duration of the most recently handled sequence of // contiguous lost packets. If this exceeds the persistent congestion duration, // persistent congestion is declared. // // https://www.rfc-editor.org/rfc/rfc9002#section-7.6 persistentCongestion [numberSpaceCount]struct { start time.Time // send time of first lost packet end time.Time // send time of last lost packet next packetNumber // one plus the number of the last lost packet } } func newReno(maxDatagramSize int) ccReno { c := &ccReno{ maxDatagramSize: maxDatagramSize, } // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.2-1 c.congestionWindow = min(10maxDatagramSize, max(14720, c.minimumCongestionWindow())) // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.3.1-1 c.slowStartThreshold = math.MaxInt for space := range c.persistentCongestion { c.persistentCongestion[space].next = -1 } return c } // canSend reports whether the congestion controller permits sending // a maximum-size datagram at this time. // // "An endpoint MUST NOT send a packet if it would cause bytes_in_flight [...] // to be larger than the congestion window [...]" // https://www.rfc-editor.org/rfc/rfc9002#section-7-7 // // For simplicity and efficiency, we don't permit sending undersized datagrams. func (c ccReno) canSend() bool { if c.sendOnePacketInRecovery { return true } return c.bytesInFlight+c.maxDatagramSize <= c.congestionWindow } // setUnderutilized indicates that the congestion window is underutilized. // // The congestion window is underutilized if bytes in flight is smaller than // the congestion window and sending is not pacing limited; that is, the // congestion controller permits sending data, but no data is sent. // // https://www.rfc-editor.org/rfc/rfc9002#section-7.8 func (c ccReno) setUnderutilized(log slog.Logger, v bool) { if c.underutilized == v { return } oldState := c.state() c.underutilized = v if logEnabled(log, QLogLevelPacket) { logCongestionStateUpdated(log, oldState, c.state()) } } // packetSent indicates that a packet has been sent. func (c ccReno) packetSent(now time.Time, log slog.Logger, space numberSpace, sent sentPacket) { if !sent.inFlight { return } c.bytesInFlight += sent.size if c.sendOnePacketInRecovery { c.sendOnePacketInRecovery = false } } // Acked and lost packets are processed in batches // resulting from either a received ACK frame or // the loss detection timer expiring. // // A batch consists of zero or more calls to packetAcked and packetLost, // followed by a single call to packetBatchEnd. // // Acks may be reported in any order, but lost packets must // be reported in strictly increasing order. // packetAcked indicates that a packet has been newly acknowledged. func (c ccReno) packetAcked(now time.Time, sent sentPacket) { if !sent.inFlight { return } c.bytesInFlight -= sent.size if c.underutilized { // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.8 return } if sent.time.Before(c.recoveryStartTime) { // In recovery, and this packet was sent before we entered recovery. // (If this packet was sent after we entered recovery, receiving an ack // for it moves us out of recovery into congestion avoidance.) // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.3.2 return } c.congestionPendingAcks += sent.size } // packetLost indicates that a packet has been newly marked as lost. // Lost packets must be reported in increasing order. func (c ccReno) packetLost(now time.Time, space numberSpace, sent sentPacket, rtt rttState) { // Record state to check for persistent congestion. // https://www.rfc-editor.org/rfc/rfc9002#section-7.6 // // Note that this relies on always receiving loss events in increasing order: // All packets prior to the one we're examining now have either been // acknowledged or declared lost. isValidPersistentCongestionSample := (sent.ackEliciting && !rtt.firstSampleTime.IsZero() && !sent.time.Before(rtt.firstSampleTime)) if isValidPersistentCongestionSample { // This packet either extends an existing range of lost packets, // or starts a new one. if sent.num != c.persistentCongestion[space].next { c.persistentCongestion[space].start = sent.time } c.persistentCongestion[space].end = sent.time c.persistentCongestion[space].next = sent.num + 1 } else { // This packet cannot establish persistent congestion on its own. // However, if we have an existing range of lost packets, // this does not break it. if sent.num == c.persistentCongestion[space].next { c.persistentCongestion[space].next = sent.num + 1 } } if !sent.inFlight { return } c.bytesInFlight -= sent.size if sent.time.After(c.ackLastLoss) { c.ackLastLoss = sent.time } } // packetBatchEnd is called at the end of processing a batch of acked or lost packets. func (c ccReno) packetBatchEnd(now time.Time, log slog.Logger, space numberSpace, rtt rttState, maxAckDelay time.Duration) { if logEnabled(log, QLogLevelPacket) { oldState := c.state() defer func() { logCongestionStateUpdated(log, oldState, c.state()) }() } if !c.ackLastLoss.IsZero() && !c.ackLastLoss.Before(c.recoveryStartTime) { // Enter the recovery state. // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.3.2 c.recoveryStartTime = now c.slowStartThreshold = c.congestionWindow / 2 c.congestionWindow = max(c.slowStartThreshold, c.minimumCongestionWindow()) c.sendOnePacketInRecovery = true // Clear congestionPendingAcks to avoid increasing the congestion // window based on acks in a frame that sends us into recovery. c.congestionPendingAcks = 0 c.inRecovery = true } else if c.congestionPendingAcks > 0 { // We are in slow start or congestion avoidance. c.inRecovery = false if c.congestionWindow < c.slowStartThreshold { // When the congestion window is less than the slow start threshold, // we are in slow start and increase the window by the number of // bytes acknowledged. d := min(c.slowStartThreshold-c.congestionWindow, c.congestionPendingAcks) c.congestionWindow += d c.congestionPendingAcks -= d } // When the congestion window is at or above the slow start threshold, // we are in congestion avoidance. // // RFC 9002 does not specify an algorithm here. The following is // the recommended algorithm from RFC 5681, in which we increment // the window by the maximum datagram size every time the number // of bytes acknowledged reaches cwnd. for c.congestionPendingAcks > c.congestionWindow { c.congestionPendingAcks -= c.congestionWindow c.congestionWindow += c.maxDatagramSize } } if !c.ackLastLoss.IsZero() { // Check for persistent congestion. // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.6 // // "A sender [...] MAY use state for just the packet number space that // was acknowledged." // https://www.rfc-editor.org/rfc/rfc9002#section-7.6.2-5 // // For simplicity, we consider each number space independently. const persistentCongestionThreshold = 3 d := (rtt.smoothedRTT + max(4rtt.rttvar, timerGranularity) + maxAckDelay) persistentCongestionThreshold start := c.persistentCongestion[space].start end := c.persistentCongestion[space].end if end.Sub(start) >= d { c.congestionWindow = c.minimumCongestionWindow() c.recoveryStartTime = time.Time{} rtt.establishPersistentCongestion() } } c.ackLastLoss = time.Time{} } // packetDiscarded indicates that the keys for a packet's space have been discarded. func (c ccReno) packetDiscarded(sent sentPacket) { // https://www.rfc-editor.org/rfc/rfc9002#section-6.2.2-3 if sent.inFlight { c.bytesInFlight -= sent.size } } func (c ccReno) minimumCongestionWindow() int { // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.2-4 return 2 c.maxDatagramSize } func logCongestionStateUpdated(log slog.Logger, oldState, newState congestionState) { if oldState == newState { return } log.LogAttrs(context.Background(), QLogLevelPacket, "recovery:congestion_state_updated", slog.String("old", oldState.String()), slog.String("new", newState.String()), ) } type congestionState string func (s congestionState) String() string { return string(s) } const ( congestionSlowStart = congestionState("slow_start") congestionCongestionAvoidance = congestionState("congestion_avoidance") congestionApplicationLimited = congestionState("application_limited") congestionRecovery = congestionState("recovery") ) func (c ccReno) state() congestionState { switch { case c.inRecovery: return congestionRecovery case c.underutilized: return congestionApplicationLimited case c.congestionWindow < c.slowStartThreshold: return congestionSlowStart default: return congestionCongestionAvoidance } }	10.23 KB	2025-05-25 12:27
📄 congestion_reno_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "testing" "time" ) func TestRenoInitialCongestionWindow(t testing.T) { // https://www.rfc-editor.org/rfc/rfc9002#section-7.2-1 for _, test := range []struct { maxDatagramSize int wantWindow int }{{ // "[...] ten times the maximum datagram size [...]" maxDatagramSize: 1200, wantWindow: 12000, }, { // [...] limiting the window to the larger of 14,720 bytes [...]" maxDatagramSize: 1500, wantWindow: 14720, }, { // [...] or twice the maximum datagram size." maxDatagramSize: 15000, wantWindow: 30000, }} { c := newReno(test.maxDatagramSize) if got, want := c.congestionWindow, test.wantWindow; got != want { t.Errorf("newReno(max_datagram_size=%v): congestion_window = %v, want %v", test.maxDatagramSize, got, want) } } } func TestRenoSlowStartWindowIncreases(t testing.T) { // "[...] the congestion window increases by the number of bytes acknowledged [...]" // https://www.rfc-editor.org/rfc/rfc9002#section-7.3.1-2 test := newRenoTest(t, 1200) p0 := test.packetSent(initialSpace, 1200) test.wantVar("congestion_window", 12000) test.packetAcked(initialSpace, p0) test.packetBatchEnd(initialSpace) test.wantVar("congestion_window", 12000+1200) p1 := test.packetSent(handshakeSpace, 600) p2 := test.packetSent(handshakeSpace, 300) test.packetAcked(handshakeSpace, p1) test.packetAcked(handshakeSpace, p2) test.packetBatchEnd(handshakeSpace) test.wantVar("congestion_window", 12000+1200+600+300) } func TestRenoSlowStartToRecovery(t testing.T) { // "The sender MUST exit slow start and enter a recovery period // when a packet is lost [...]" // https://www.rfc-editor.org/rfc/rfc9002#section-7.3.1-3 test := newRenoTest(t, 1200) p0 := test.packetSent(initialSpace, 1200) p1 := test.packetSent(initialSpace, 1200) p2 := test.packetSent(initialSpace, 1200) p3 := test.packetSent(initialSpace, 1200) test.wantVar("congestion_window", 12000) t.Logf("# ACK triggers packet loss, sender enters recovery") test.advance(1 time.Millisecond) test.packetAcked(initialSpace, p3) test.packetLost(initialSpace, p0) test.packetBatchEnd(initialSpace) // "[...] set the slow start threshold to half the value of // the congestion window when loss is detected." // https://www.rfc-editor.org/rfc/rfc9002#section-7.3.2-2 test.wantVar("slow_start_threshold", 6000) t.Logf("# packet loss in recovery does not change congestion window") test.packetLost(initialSpace, p1) test.packetBatchEnd(initialSpace) t.Logf("# ack of packet from before recovery does not change congestion window") test.packetAcked(initialSpace, p2) test.packetBatchEnd(initialSpace) p4 := test.packetSent(initialSpace, 1200) test.packetAcked(initialSpace, p4) test.packetBatchEnd(initialSpace) // "The congestion window MUST be set to the reduced value of // the slow start threshold before exiting the recovery period." // https://www.rfc-editor.org/rfc/rfc9002#section-7.3.2-2 test.wantVar("congestion_window", 6000) } func TestRenoRecoveryToCongestionAvoidance(t testing.T) { // "A sender in congestion avoidance [limits] the increase // to the congestion window to at most one maximum datagram size // for each congestion window that is acknowledged." // https://www.rfc-editor.org/rfc/rfc9002#section-7.3.3-2 test := newRenoTest(t, 1200) p0 := test.packetSent(initialSpace, 1200) p1 := test.packetSent(initialSpace, 1200) p2 := test.packetSent(initialSpace, 1200) test.advance(1 time.Millisecond) test.packetAcked(initialSpace, p1) test.packetLost(initialSpace, p0) test.packetBatchEnd(initialSpace) p3 := test.packetSent(initialSpace, 1000) test.advance(1 * time.Millisecond) test.packetAcked(initialSpace, p3) test.packetBatchEnd(initialSpace) test.wantVar("congestion_window", 6000) test.wantVar("slow_start_threshold", 6000) test.wantVar("congestion_pending_acks", 1000) t.Logf("# ack of packet from before recovery does not change congestion window") test.packetAcked(initialSpace, p2) test.packetBatchEnd(initialSpace) test.wantVar("congestion_pending_acks", 1000) for i := 0; i < 6; i++ { p := test.packetSent(initialSpace, 1000) test.packetAcked(initialSpace, p) } test.packetBatchEnd(initialSpace) t.Logf("# congestion window increased by max_datagram_size") test.wantVar("congestion_window", 6000+1200) test.wantVar("congestion_pending_acks", 1000) } func TestRenoMinimumCongestionWindow(t testing.T) { // "The RECOMMENDED [minimum congestion window] is 2 max_datagram_size." // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.2-4 test := newRenoTest(t, 1200) p0 := test.packetSent(handshakeSpace, 1200) p1 := test.packetSent(handshakeSpace, 1200) test.advance(1 * time.Millisecond) test.packetAcked(handshakeSpace, p1) test.packetLost(handshakeSpace, p0) test.packetBatchEnd(handshakeSpace) test.wantVar("slow_start_threshold", 6000) test.wantVar("congestion_window", 6000) test.advance(1 * time.Millisecond) p2 := test.packetSent(handshakeSpace, 1200) p3 := test.packetSent(handshakeSpace, 1200) test.advance(1 * time.Millisecond) test.packetAcked(handshakeSpace, p3) test.packetLost(handshakeSpace, p2) test.packetBatchEnd(handshakeSpace) test.wantVar("slow_start_threshold", 3000) test.wantVar("congestion_window", 3000) p4 := test.packetSent(handshakeSpace, 1200) p5 := test.packetSent(handshakeSpace, 1200) test.advance(1 * time.Millisecond) test.packetAcked(handshakeSpace, p4) test.packetLost(handshakeSpace, p5) test.packetBatchEnd(handshakeSpace) test.wantVar("slow_start_threshold", 1500) test.wantVar("congestion_window", 2400) // minimum p6 := test.packetSent(handshakeSpace, 1200) p7 := test.packetSent(handshakeSpace, 1200) test.advance(1 * time.Millisecond) test.packetAcked(handshakeSpace, p7) test.packetLost(handshakeSpace, p6) test.packetBatchEnd(handshakeSpace) test.wantVar("slow_start_threshold", 1200) // half congestion window test.wantVar("congestion_window", 2400) // minimum } func TestRenoSlowStartToCongestionAvoidance(t testing.T) { test := newRenoTest(t, 1200) test.setRTT(1time.Millisecond, 0) t.Logf("# enter recovery with persistent congestion") p0 := test.packetSent(handshakeSpace, 1200) test.advance(1 * time.Second) // larger than persistent congestion duration p1 := test.packetSent(handshakeSpace, 1200) p2 := test.packetSent(handshakeSpace, 1200) test.advance(1 * time.Millisecond) test.packetAcked(handshakeSpace, p2) test.packetLost(handshakeSpace, p0) test.packetLost(handshakeSpace, p1) test.packetBatchEnd(handshakeSpace) test.wantVar("slow_start_threshold", 6000) test.wantVar("congestion_window", 2400) // minimum in persistent congestion test.wantVar("congestion_pending_acks", 0) t.Logf("# enter slow start on new ack") p3 := test.packetSent(handshakeSpace, 1200) test.packetAcked(handshakeSpace, p3) test.packetBatchEnd(handshakeSpace) test.wantVar("congestion_window", 3600) test.wantVar("congestion_pending_acks", 0) t.Logf("# enter congestion avoidance after reaching slow_start_threshold") p4 := test.packetSent(handshakeSpace, 1200) p5 := test.packetSent(handshakeSpace, 1200) p6 := test.packetSent(handshakeSpace, 1200) test.packetAcked(handshakeSpace, p4) test.packetAcked(handshakeSpace, p5) test.packetAcked(handshakeSpace, p6) test.packetBatchEnd(handshakeSpace) test.wantVar("congestion_window", 6000) test.wantVar("congestion_pending_acks", 1200) } func TestRenoPersistentCongestionDurationExceeded(t testing.T) { // "When persistent congestion is declared, the sender's congestion // window MUST be reduced to the minimum congestion window [...]" // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.6.2-6 test := newRenoTest(t, 1200) test.setRTT(10time.Millisecond, 3time.Millisecond) test.maxAckDelay = 25 time.Millisecond t.Logf("persistent congesion duration is 3 * (10ms + 43ms + 25ms) = 141ms") p0 := test.packetSent(handshakeSpace, 1200) test.advance(142 time.Millisecond) // larger than persistent congestion duration p1 := test.packetSent(handshakeSpace, 1200) p2 := test.packetSent(handshakeSpace, 1200) test.packetAcked(handshakeSpace, p2) test.packetLost(handshakeSpace, p0) test.packetLost(handshakeSpace, p1) test.packetBatchEnd(handshakeSpace) test.wantVar("slow_start_threshold", 6000) test.wantVar("congestion_window", 2400) // minimum in persistent congestion } func TestRenoPersistentCongestionDurationNotExceeded(t testing.T) { test := newRenoTest(t, 1200) test.setRTT(10time.Millisecond, 3time.Millisecond) test.maxAckDelay = 25 time.Millisecond t.Logf("persistent congesion duration is 3 * (10ms + 43ms + 25ms) = 141ms") p0 := test.packetSent(handshakeSpace, 1200) test.advance(140 time.Millisecond) // smaller than persistent congestion duration p1 := test.packetSent(handshakeSpace, 1200) p2 := test.packetSent(handshakeSpace, 1200) test.packetAcked(handshakeSpace, p2) test.packetLost(handshakeSpace, p0) test.packetLost(handshakeSpace, p1) test.packetBatchEnd(handshakeSpace) test.wantVar("slow_start_threshold", 6000) test.wantVar("congestion_window", 6000) // no persistent congestion } func TestRenoPersistentCongestionInterveningAck(t testing.T) { // "[...] none of the packets sent between the send times // of these two packets are acknowledged [...]" // https://www.rfc-editor.org/rfc/rfc9002#section-7.6.2-2.1 test := newRenoTest(t, 1200) test.setRTT(10time.Millisecond, 3time.Millisecond) test.maxAckDelay = 25 time.Millisecond t.Logf("persistent congesion duration is 3 * (10ms + 43ms + 25ms) = 141ms") p0 := test.packetSent(handshakeSpace, 1200) test.advance(100 time.Millisecond) p1 := test.packetSent(handshakeSpace, 1200) test.advance(42 * time.Millisecond) p2 := test.packetSent(handshakeSpace, 1200) p3 := test.packetSent(handshakeSpace, 1200) test.packetAcked(handshakeSpace, p1) test.packetAcked(handshakeSpace, p3) test.packetLost(handshakeSpace, p0) test.packetLost(handshakeSpace, p2) test.packetBatchEnd(handshakeSpace) test.wantVar("slow_start_threshold", 6000) test.wantVar("congestion_window", 6000) // no persistent congestion } func TestRenoPersistentCongestionInterveningLosses(t testing.T) { test := newRenoTest(t, 1200) test.setRTT(10time.Millisecond, 3time.Millisecond) test.maxAckDelay = 25 time.Millisecond t.Logf("persistent congesion duration is 3 * (10ms + 43ms + 25ms) = 141ms") p0 := test.packetSent(handshakeSpace, 1200) test.advance(50 time.Millisecond) p1 := test.packetSent(handshakeSpace, 1200, func(p sentPacket) { p.inFlight = false p.ackEliciting = false }) test.advance(50 time.Millisecond) p2 := test.packetSent(handshakeSpace, 1200, func(p sentPacket) { p.ackEliciting = false }) test.advance(42 time.Millisecond) p3 := test.packetSent(handshakeSpace, 1200) p4 := test.packetSent(handshakeSpace, 1200) test.packetAcked(handshakeSpace, p4) test.packetLost(handshakeSpace, p0) test.packetLost(handshakeSpace, p1) test.packetLost(handshakeSpace, p2) test.packetBatchEnd(handshakeSpace) test.wantVar("congestion_window", 6000) // no persistent congestion yet test.packetLost(handshakeSpace, p3) test.packetBatchEnd(handshakeSpace) test.wantVar("congestion_window", 2400) // persistent congestion } func TestRenoPersistentCongestionNoRTTSample(t testing.T) { // "[...] a prior RTT sample existed when these two packets were sent." // https://www.rfc-editor.org/rfc/rfc9002#section-7.6.2-2.3 test := newRenoTest(t, 1200) t.Logf("first packet sent prior to first RTT sample") p0 := test.packetSent(handshakeSpace, 1200) test.advance(1 time.Millisecond) test.setRTT(10time.Millisecond, 3time.Millisecond) test.maxAckDelay = 25 * time.Millisecond t.Logf("persistent congesion duration is 3 * (10ms + 43ms + 25ms) = 141ms") test.advance(142 time.Millisecond) // larger than persistent congestion duration p1 := test.packetSent(handshakeSpace, 1200) p2 := test.packetSent(handshakeSpace, 1200) test.packetAcked(handshakeSpace, p2) test.packetLost(handshakeSpace, p0) test.packetLost(handshakeSpace, p1) test.packetBatchEnd(handshakeSpace) test.wantVar("slow_start_threshold", 6000) test.wantVar("congestion_window", 6000) // no persistent congestion } func TestRenoPersistentCongestionPacketNotAckEliciting(t testing.T) { // "These two packets MUST be ack-eliciting [...]" // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.6.2-3 test := newRenoTest(t, 1200) t.Logf("first packet set prior to first RTT sample") p0 := test.packetSent(handshakeSpace, 1200) test.advance(1 time.Millisecond) test.setRTT(10time.Millisecond, 3time.Millisecond) test.maxAckDelay = 25 * time.Millisecond t.Logf("persistent congesion duration is 3 * (10ms + 43ms + 25ms) = 141ms") test.advance(142 time.Millisecond) // larger than persistent congestion duration p1 := test.packetSent(handshakeSpace, 1200) p2 := test.packetSent(handshakeSpace, 1200) test.packetAcked(handshakeSpace, p2) test.packetLost(handshakeSpace, p0) test.packetLost(handshakeSpace, p1) test.packetBatchEnd(handshakeSpace) test.wantVar("slow_start_threshold", 6000) test.wantVar("congestion_window", 6000) // no persistent congestion } func TestRenoCanSend(t testing.T) { test := newRenoTest(t, 1200) test.wantVar("congestion_window", 12000) t.Logf("controller permits sending until congestion window is full") var packets []sentPacket for i := 0; i < 10; i++ { test.wantVar("bytes_in_flight", i1200) test.wantCanSend(true) p := test.packetSent(initialSpace, 1200) packets = append(packets, p) } test.wantVar("bytes_in_flight", 12000) t.Logf("controller blocks sending when congestion window is consumed") test.wantCanSend(false) t.Logf("loss of packet moves to recovery, reduces window") test.packetLost(initialSpace, packets[0]) test.packetAcked(initialSpace, packets[1]) test.packetBatchEnd(initialSpace) test.wantVar("bytes_in_flight", 9600) // 12000 - 21200 test.wantVar("congestion_window", 6000) // 12000 / 2 t.Logf("one packet permitted on entry to recovery") test.wantCanSend(true) test.packetSent(initialSpace, 1200) test.wantVar("bytes_in_flight", 10800) test.wantCanSend(false) } func TestRenoNonAckEliciting(t testing.T) { test := newRenoTest(t, 1200) test.wantVar("congestion_window", 12000) t.Logf("in-flight packet") p0 := test.packetSent(initialSpace, 1200) test.wantVar("bytes_in_flight", 1200) test.packetAcked(initialSpace, p0) test.packetBatchEnd(initialSpace) test.wantVar("bytes_in_flight", 0) test.wantVar("congestion_window", 12000+1200) t.Logf("non-in-flight packet") p1 := test.packetSent(initialSpace, 1200, func(p sentPacket) { p.inFlight = false p.ackEliciting = false }) test.wantVar("bytes_in_flight", 0) test.packetAcked(initialSpace, p1) test.packetBatchEnd(initialSpace) test.wantVar("bytes_in_flight", 0) test.wantVar("congestion_window", 12000+1200) } func TestRenoUnderutilizedCongestionWindow(t testing.T) { test := newRenoTest(t, 1200) test.setUnderutilized(true) test.wantVar("congestion_window", 12000) t.Logf("congestion window does not increase when application limited") p0 := test.packetSent(initialSpace, 1200) test.packetAcked(initialSpace, p0) test.wantVar("congestion_window", 12000) } func TestRenoDiscardKeys(t testing.T) { test := newRenoTest(t, 1200) p0 := test.packetSent(initialSpace, 1200) p1 := test.packetSent(handshakeSpace, 1200) test.wantVar("bytes_in_flight", 2400) test.packetDiscarded(initialSpace, p0) test.wantVar("bytes_in_flight", 1200) test.packetDiscarded(handshakeSpace, p1) test.wantVar("bytes_in_flight", 0) } type ccTest struct { t testing.T cc ccReno rtt rttState maxAckDelay time.Duration now time.Time nextNum [numberSpaceCount]packetNumber } func newRenoTest(t testing.T, maxDatagramSize int) ccTest { test := &ccTest{ t: t, now: time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC), } test.cc = newReno(maxDatagramSize) return test } func (c ccTest) setRTT(smoothedRTT, rttvar time.Duration) { c.t.Helper() c.t.Logf("set smoothed_rtt=%v rttvar=%v", smoothedRTT, rttvar) c.rtt.smoothedRTT = smoothedRTT c.rtt.rttvar = rttvar if c.rtt.firstSampleTime.IsZero() { c.rtt.firstSampleTime = c.now } } func (c ccTest) setUnderutilized(v bool) { c.t.Helper() c.t.Logf("set underutilized = %v", v) c.cc.setUnderutilized(nil, v) } func (c ccTest) packetSent(space numberSpace, size int, fns ...func(sentPacket)) sentPacket { c.t.Helper() num := c.nextNum[space] c.nextNum[space]++ sent := &sentPacket{ inFlight: true, ackEliciting: true, num: num, size: size, time: c.now, } for _, f := range fns { f(sent) } c.t.Logf("packet sent: num=%v.%v, size=%v", space, sent.num, sent.size) c.cc.packetSent(c.now, nil, space, sent) return sent } func (c ccTest) advance(d time.Duration) { c.t.Helper() c.t.Logf("advance time %v", d) c.now = c.now.Add(d) } func (c ccTest) packetAcked(space numberSpace, sent sentPacket) { c.t.Helper() c.t.Logf("packet acked: num=%v.%v, size=%v", space, sent.num, sent.size) c.cc.packetAcked(c.now, sent) } func (c ccTest) packetLost(space numberSpace, sent sentPacket) { c.t.Helper() c.t.Logf("packet lost: num=%v.%v, size=%v", space, sent.num, sent.size) c.cc.packetLost(c.now, space, sent, &c.rtt) } func (c ccTest) packetDiscarded(space numberSpace, sent sentPacket) { c.t.Helper() c.t.Logf("packet number space discarded: num=%v.%v, size=%v", space, sent.num, sent.size) c.cc.packetDiscarded(sent) } func (c ccTest) packetBatchEnd(space numberSpace) { c.t.Helper() c.t.Logf("(end of batch)") c.cc.packetBatchEnd(c.now, nil, space, &c.rtt, c.maxAckDelay) } func (c ccTest) wantCanSend(want bool) { if got := c.cc.canSend(); got != want { c.t.Fatalf("canSend() = %v, want %v", got, want) } } func (c *ccTest) wantVar(name string, want int) { c.t.Helper() var got int switch name { case "bytes_in_flight": got = c.cc.bytesInFlight case "congestion_pending_acks": got = c.cc.congestionPendingAcks case "congestion_window": got = c.cc.congestionWindow case "slow_start_threshold": got = c.cc.slowStartThreshold default: c.t.Fatalf("unknown var %q", name) } if got != want { c.t.Fatalf("ERROR: %v = %v, want %v", name, got, want) } c.t.Logf("# %v = %v", name, got) }	18.19 KB	2025-05-25 12:27
📄 conn.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "context" "crypto/tls" "errors" "fmt" "log/slog" "net/netip" "time" ) // A Conn is a QUIC connection. // // Multiple goroutines may invoke methods on a Conn simultaneously. type Conn struct { side connSide endpoint Endpoint config Config testHooks connTestHooks peerAddr netip.AddrPort localAddr netip.AddrPort msgc chan any donec chan struct{} // closed when conn loop exits w packetWriter acks [numberSpaceCount]ackState // indexed by number space lifetime lifetimeState idle idleState connIDState connIDState loss lossState streams streamsState path pathState // Packet protection keys, CRYPTO streams, and TLS state. keysInitial fixedKeyPair keysHandshake fixedKeyPair keysAppData updatingKeyPair crypto [numberSpaceCount]cryptoStream tls tls.QUICConn // retryToken is the token provided by the peer in a Retry packet. retryToken []byte // handshakeConfirmed is set when the handshake is confirmed. // For server connections, it tracks sending HANDSHAKE_DONE. handshakeConfirmed sentVal peerAckDelayExponent int8 // -1 when unknown // Tests only: Send a PING in a specific number space. testSendPingSpace numberSpace testSendPing sentVal log slog.Logger } // connTestHooks override conn behavior in tests. type connTestHooks interface { // init is called after a conn is created. init() // nextMessage is called to request the next event from msgc. // Used to give tests control of the connection event loop. nextMessage(msgc chan any, nextTimeout time.Time) (now time.Time, message any) // handleTLSEvent is called with each TLS event. handleTLSEvent(tls.QUICEvent) // newConnID is called to generate a new connection ID. // Permits tests to generate consistent connection IDs rather than random ones. newConnID(seq int64) ([]byte, error) // waitUntil blocks until the until func returns true or the context is done. // Used to synchronize asynchronous blocking operations in tests. waitUntil(ctx context.Context, until func() bool) error // timeNow returns the current time. timeNow() time.Time } // newServerConnIDs is connection IDs associated with a new server connection. type newServerConnIDs struct { srcConnID []byte // source from client's current Initial dstConnID []byte // destination from client's current Initial originalDstConnID []byte // destination from client's first Initial retrySrcConnID []byte // source from server's Retry } func newConn(now time.Time, side connSide, cids newServerConnIDs, peerHostname string, peerAddr netip.AddrPort, config Config, e Endpoint) (conn Conn, _ error) { c := &Conn{ side: side, endpoint: e, config: config, peerAddr: unmapAddrPort(peerAddr), msgc: make(chan any, 1), donec: make(chan struct{}), peerAckDelayExponent: -1, } defer func() { // If we hit an error in newConn, close donec so tests don't get stuck waiting for it. // This is only relevant if we've got a bug, but it makes tracking that bug down // much easier. if conn == nil { close(c.donec) } }() // A one-element buffer allows us to wake a Conn's event loop as a // non-blocking operation. c.msgc = make(chan any, 1) if e.testHooks != nil { e.testHooks.newConn(c) } // initialConnID is the connection ID used to generate Initial packet protection keys. var initialConnID []byte if c.side == clientSide { if err := c.connIDState.initClient(c); err != nil { return nil, err } initialConnID, _ = c.connIDState.dstConnID() } else { initialConnID = cids.originalDstConnID if cids.retrySrcConnID != nil { initialConnID = cids.retrySrcConnID } if err := c.connIDState.initServer(c, cids); err != nil { return nil, err } } // TODO: PMTU discovery. c.logConnectionStarted(cids.originalDstConnID, peerAddr) c.keysAppData.init() c.loss.init(c.side, smallestMaxDatagramSize, now) c.streamsInit() c.lifetimeInit() c.restartIdleTimer(now) if err := c.startTLS(now, initialConnID, peerHostname, transportParameters{ initialSrcConnID: c.connIDState.srcConnID(), originalDstConnID: cids.originalDstConnID, retrySrcConnID: cids.retrySrcConnID, ackDelayExponent: ackDelayExponent, maxUDPPayloadSize: maxUDPPayloadSize, maxAckDelay: maxAckDelay, disableActiveMigration: true, initialMaxData: config.maxConnReadBufferSize(), initialMaxStreamDataBidiLocal: config.maxStreamReadBufferSize(), initialMaxStreamDataBidiRemote: config.maxStreamReadBufferSize(), initialMaxStreamDataUni: config.maxStreamReadBufferSize(), initialMaxStreamsBidi: c.streams.remoteLimit[bidiStream].max, initialMaxStreamsUni: c.streams.remoteLimit[uniStream].max, activeConnIDLimit: activeConnIDLimit, }); err != nil { return nil, err } if c.testHooks != nil { c.testHooks.init() } go c.loop(now) return c, nil } func (c Conn) String() string { return fmt.Sprintf("quic.Conn(%v,->%v)", c.side, c.peerAddr) } // LocalAddr returns the local network address, if known. func (c Conn) LocalAddr() netip.AddrPort { return c.localAddr } // RemoteAddr returns the remote network address, if known. func (c Conn) RemoteAddr() netip.AddrPort { return c.peerAddr } // confirmHandshake is called when the handshake is confirmed. // https://www.rfc-editor.org/rfc/rfc9001#section-4.1.2 func (c Conn) confirmHandshake(now time.Time) { // If handshakeConfirmed is unset, the handshake is not confirmed. // If it is unsent, the handshake is confirmed and we need to send a HANDSHAKE_DONE. // If it is sent, we have sent a HANDSHAKE_DONE. // If it is received, the handshake is confirmed and we do not need to send anything. if c.handshakeConfirmed.isSet() { return // already confirmed } if c.side == serverSide { // When the server confirms the handshake, it sends a HANDSHAKE_DONE. c.handshakeConfirmed.setUnsent() c.endpoint.serverConnEstablished(c) } else { // The client never sends a HANDSHAKE_DONE, so we set handshakeConfirmed // to the received state, indicating that the handshake is confirmed and we // don't need to send anything. c.handshakeConfirmed.setReceived() } c.restartIdleTimer(now) c.loss.confirmHandshake() // "An endpoint MUST discard its Handshake keys when the TLS handshake is confirmed" // https://www.rfc-editor.org/rfc/rfc9001#section-4.9.2-1 c.discardKeys(now, handshakeSpace) } // discardKeys discards unused packet protection keys. // https://www.rfc-editor.org/rfc/rfc9001#section-4.9 func (c Conn) discardKeys(now time.Time, space numberSpace) { if err := c.crypto[space].discardKeys(); err != nil { c.abort(now, err) } switch space { case initialSpace: c.keysInitial.discard() case handshakeSpace: c.keysHandshake.discard() } c.loss.discardKeys(now, c.log, space) } // receiveTransportParameters applies transport parameters sent by the peer. func (c Conn) receiveTransportParameters(p transportParameters) error { isRetry := c.retryToken != nil if err := c.connIDState.validateTransportParameters(c, isRetry, p); err != nil { return err } c.streams.outflow.setMaxData(p.initialMaxData) c.streams.localLimit[bidiStream].setMax(p.initialMaxStreamsBidi) c.streams.localLimit[uniStream].setMax(p.initialMaxStreamsUni) c.streams.peerInitialMaxStreamDataBidiLocal = p.initialMaxStreamDataBidiLocal c.streams.peerInitialMaxStreamDataRemote[bidiStream] = p.initialMaxStreamDataBidiRemote c.streams.peerInitialMaxStreamDataRemote[uniStream] = p.initialMaxStreamDataUni c.receivePeerMaxIdleTimeout(p.maxIdleTimeout) c.peerAckDelayExponent = p.ackDelayExponent c.loss.setMaxAckDelay(p.maxAckDelay) if err := c.connIDState.setPeerActiveConnIDLimit(c, p.activeConnIDLimit); err != nil { return err } if p.preferredAddrConnID != nil { var ( seq int64 = 1 // sequence number of this conn id is 1 retirePriorTo int64 = 0 // retire nothing resetToken [16]byte ) copy(resetToken[:], p.preferredAddrResetToken) if err := c.connIDState.handleNewConnID(c, seq, retirePriorTo, p.preferredAddrConnID, resetToken); err != nil { return err } } // TODO: stateless_reset_token // TODO: max_udp_payload_size // TODO: disable_active_migration // TODO: preferred_address return nil } type ( timerEvent struct{} wakeEvent struct{} ) var errIdleTimeout = errors.New("idle timeout") // loop is the connection main loop. // // Except where otherwise noted, all connection state is owned by the loop goroutine. // // The loop processes messages from c.msgc and timer events. // Other goroutines may examine or modify conn state by sending the loop funcs to execute. func (c Conn) loop(now time.Time) { defer c.cleanup() // The connection timer sends a message to the connection loop on expiry. // We need to give it an expiry when creating it, so set the initial timeout to // an arbitrary large value. The timer will be reset before this expires (and it // isn't a problem if it does anyway). Skip creating the timer in tests which // take control of the connection message loop. var timer time.Timer var lastTimeout time.Time hooks := c.testHooks if hooks == nil { timer = time.AfterFunc(1time.Hour, func() { c.sendMsg(timerEvent{}) }) defer timer.Stop() } for c.lifetime.state != connStateDone { sendTimeout := c.maybeSend(now) // try sending // Note that we only need to consider the ack timer for the App Data space, // since the Initial and Handshake spaces always ack immediately. nextTimeout := sendTimeout nextTimeout = firstTime(nextTimeout, c.idle.nextTimeout) if c.isAlive() { nextTimeout = firstTime(nextTimeout, c.loss.timer) nextTimeout = firstTime(nextTimeout, c.acks[appDataSpace].nextAck) } else { nextTimeout = firstTime(nextTimeout, c.lifetime.drainEndTime) } var m any if hooks != nil { // Tests only: Wait for the test to tell us to continue. now, m = hooks.nextMessage(c.msgc, nextTimeout) } else if !nextTimeout.IsZero() && nextTimeout.Before(now) { // A connection timer has expired. now = time.Now() m = timerEvent{} } else { // Reschedule the connection timer if necessary // and wait for the next event. if !nextTimeout.Equal(lastTimeout) && !nextTimeout.IsZero() { // Resetting a timer created with time.AfterFunc guarantees // that the timer will run again. We might generate a spurious // timer event under some circumstances, but that's okay. timer.Reset(nextTimeout.Sub(now)) lastTimeout = nextTimeout } m = <-c.msgc now = time.Now() } switch m := m.(type) { case datagram: if !c.handleDatagram(now, m) { if c.logEnabled(QLogLevelPacket) { c.logPacketDropped(m) } } m.recycle() case timerEvent: // A connection timer has expired. if c.idleAdvance(now) { // The connection idle timer has expired. c.abortImmediately(now, errIdleTimeout) return } c.loss.advance(now, c.handleAckOrLoss) if c.lifetimeAdvance(now) { // The connection has completed the draining period, // and may be shut down. return } case wakeEvent: // We're being woken up to try sending some frames. case func(time.Time, Conn): // Send a func to msgc to run it on the main Conn goroutine m(now, c) default: panic(fmt.Sprintf("quic: unrecognized conn message %T", m)) } } } func (c Conn) cleanup() { c.logConnectionClosed() c.endpoint.connDrained(c) c.tls.Close() close(c.donec) } // sendMsg sends a message to the conn's loop. // It does not wait for the message to be processed. // The conn may close before processing the message, in which case it is lost. func (c Conn) sendMsg(m any) { select { case c.msgc <- m: case <-c.donec: } } // wake wakes up the conn's loop. func (c Conn) wake() { select { case c.msgc <- wakeEvent{}: default: } } // runOnLoop executes a function within the conn's loop goroutine. func (c Conn) runOnLoop(ctx context.Context, f func(now time.Time, c Conn)) error { donec := make(chan struct{}) msg := func(now time.Time, c Conn) { defer close(donec) f(now, c) } if c.testHooks != nil { // In tests, we can't rely on being able to send a message immediately: // c.msgc might be full, and testConnHooks.nextMessage might be waiting // for us to block before it processes the next message. // To avoid a deadlock, we send the message in waitUntil. // If msgc is empty, the message is buffered. // If msgc is full, we block and let nextMessage process the queue. msgc := c.msgc c.testHooks.waitUntil(ctx, func() bool { for { select { case msgc <- msg: msgc = nil // send msg only once case <-donec: return true case <-c.donec: return true default: return false } } }) } else { c.sendMsg(msg) } select { case <-donec: case <-c.donec: return errors.New("quic: connection closed") } return nil } func (c *Conn) waitOnDone(ctx context.Context, ch <-chan struct{}) error { if c.testHooks != nil { return c.testHooks.waitUntil(ctx, func() bool { select { case <-ch: return true default: } return false }) } // Check the channel before the context. // We always prefer to return results when available, // even when provided with an already-canceled context. select { case <-ch: return nil default: } select { case <-ch: case <-ctx.Done(): return ctx.Err() } return nil } // firstTime returns the earliest non-zero time, or zero if both times are zero. func firstTime(a, b time.Time) time.Time { switch { case a.IsZero(): return b case b.IsZero(): return a case a.Before(b): return a default: return b } }	13.8 KB	2025-05-25 12:27
📄 conn_async_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "context" "errors" "fmt" "path/filepath" "runtime" "sync" ) // asyncTestState permits handling asynchronous operations in a synchronous test. // // For example, a test may want to write to a stream and observe that // STREAM frames are sent with the contents of the write in response // to MAX_STREAM_DATA frames received from the peer. // The Stream.Write is an asynchronous operation, but the test is simpler // if we can start the write, observe the first STREAM frame sent, // send a MAX_STREAM_DATA frame, observe the next STREAM frame sent, etc. // // We do this by instrumenting points where operations can block. // We start async operations like Write in a goroutine, // and wait for the operation to either finish or hit a blocking point. // When the connection event loop is idle, we check a list of // blocked operations to see if any can be woken. type asyncTestState struct { mu sync.Mutex notify chan struct{} blocked map[blockedAsync]struct{} } // An asyncOp is an asynchronous operation that results in (T, error). type asyncOp[T any] struct { v T err error caller string tc testConn donec chan struct{} cancelFunc context.CancelFunc } // cancel cancels the async operation's context, and waits for // the operation to complete. func (a asyncOp[T]) cancel() { select { case <-a.donec: return // already done default: } a.cancelFunc() <-a.tc.asyncTestState.notify select { case <-a.donec: default: panic(fmt.Errorf("%v: async op failed to finish after being canceled", a.caller)) } } var errNotDone = errors.New("async op is not done") // result returns the result of the async operation. // It returns errNotDone if the operation is still in progress. // // Note that unlike a traditional async/await, this doesn't block // waiting for the operation to complete. Since tests have full // control over the progress of operations, an asyncOp can only // become done in reaction to the test taking some action. func (a asyncOp[T]) result() (v T, err error) { a.tc.wait() select { case <-a.donec: return a.v, a.err default: return v, errNotDone } } // A blockedAsync is a blocked async operation. type blockedAsync struct { until func() bool // when this returns true, the operation is unblocked donec chan struct{} // closed when the operation is unblocked } type asyncContextKey struct{} // runAsync starts an asynchronous operation. // // The function f should call a blocking function such as // Stream.Write or Conn.AcceptStream and return its result. // It must use the provided context. func runAsync[T any](tc testConn, f func(context.Context) (T, error)) asyncOp[T] { as := &tc.asyncTestState if as.notify == nil { as.notify = make(chan struct{}) as.mu.Lock() as.blocked = make(map[blockedAsync]struct{}) as.mu.Unlock() } _, file, line, _ := runtime.Caller(1) ctx := context.WithValue(context.Background(), asyncContextKey{}, true) ctx, cancel := context.WithCancel(ctx) a := &asyncOp[T]{ tc: tc, caller: fmt.Sprintf("%v:%v", filepath.Base(file), line), donec: make(chan struct{}), cancelFunc: cancel, } go func() { a.v, a.err = f(ctx) close(a.donec) as.notify <- struct{}{} }() tc.t.Cleanup(func() { if _, err := a.result(); err == errNotDone { tc.t.Errorf("%v: async operation is still executing at end of test", a.caller) a.cancel() } }) // Wait for the operation to either finish or block. <-as.notify tc.wait() return a } // waitUntil waits for a blocked async operation to complete. // The operation is complete when the until func returns true. func (as asyncTestState) waitUntil(ctx context.Context, until func() bool) error { if until() { return nil } if err := ctx.Err(); err != nil { // Context has already expired. return err } if ctx.Value(asyncContextKey{}) == nil { // Context is not one that we've created, and hasn't expired. // This probably indicates that we've tried to perform a // blocking operation without using the async test harness here, // which may have unpredictable results. panic("blocking async point with unexpected Context") } b := &blockedAsync{ until: until, donec: make(chan struct{}), } // Record this as a pending blocking operation. as.mu.Lock() as.blocked[b] = struct{}{} as.mu.Unlock() // Notify the creator of the operation that we're blocked, // and wait to be woken up. as.notify <- struct{}{} select { case <-b.donec: case <-ctx.Done(): return ctx.Err() } return nil } // wakeAsync tries to wake up a blocked async operation. // It returns true if one was woken, false otherwise. func (as asyncTestState) wakeAsync() bool { as.mu.Lock() var woken blockedAsync for w := range as.blocked { if w.until() { woken = w delete(as.blocked, w) break } } as.mu.Unlock() if woken == nil { return false } close(woken.donec) <-as.notify // must not hold as.mu while blocked here return true }	5.05 KB	2025-05-25 12:27
📄 conn_close.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "context" "errors" "time" ) // connState is the state of a connection. type connState int const ( // A connection is alive when it is first created. connStateAlive = connState(iota) // The connection has received a CONNECTION_CLOSE frame from the peer, // and has not yet sent a CONNECTION_CLOSE in response. // // We will send a CONNECTION_CLOSE, and then enter the draining state. connStatePeerClosed // The connection is in the closing state. // // We will send CONNECTION_CLOSE frames to the peer // (once upon entering the closing state, and possibly again in response to peer packets). // // If we receive a CONNECTION_CLOSE from the peer, we will enter the draining state. // Otherwise, we will eventually time out and move to the done state. // // https://www.rfc-editor.org/rfc/rfc9000#section-10.2.1 connStateClosing // The connection is in the draining state. // // We will neither send packets nor process received packets. // When the drain timer expires, we move to the done state. // // https://www.rfc-editor.org/rfc/rfc9000#section-10.2.2 connStateDraining // The connection is done, and the conn loop will exit. connStateDone ) // lifetimeState tracks the state of a connection. // // This is fairly coupled to the rest of a Conn, but putting it in a struct of its own helps // reason about operations that cause state transitions. type lifetimeState struct { state connState readyc chan struct{} // closed when TLS handshake completes donec chan struct{} // closed when finalErr is set localErr error // error sent to the peer finalErr error // error sent by the peer, or transport error; set before closing donec connCloseSentTime time.Time // send time of last CONNECTION_CLOSE frame connCloseDelay time.Duration // delay until next CONNECTION_CLOSE frame sent drainEndTime time.Time // time the connection exits the draining state } func (c Conn) lifetimeInit() { c.lifetime.readyc = make(chan struct{}) c.lifetime.donec = make(chan struct{}) } var ( errNoPeerResponse = errors.New("peer did not respond to CONNECTION_CLOSE") errConnClosed = errors.New("connection closed") ) // advance is called when time passes. func (c Conn) lifetimeAdvance(now time.Time) (done bool) { if c.lifetime.drainEndTime.IsZero() \|\| c.lifetime.drainEndTime.After(now) { return false } // The connection drain period has ended, and we can shut down. // https://www.rfc-editor.org/rfc/rfc9000.html#section-10.2-7 c.lifetime.drainEndTime = time.Time{} if c.lifetime.state != connStateDraining { // We were in the closing state, waiting for a CONNECTION_CLOSE from the peer. c.setFinalError(errNoPeerResponse) } c.setState(now, connStateDone) return true } // setState sets the conn state. func (c Conn) setState(now time.Time, state connState) { if c.lifetime.state == state { return } c.lifetime.state = state switch state { case connStateClosing, connStateDraining: if c.lifetime.drainEndTime.IsZero() { c.lifetime.drainEndTime = now.Add(3 c.loss.ptoBasePeriod()) } case connStateDone: c.setFinalError(nil) } if state != connStateAlive { c.streamsCleanup() } } // confirmHandshake is called when the TLS handshake completes. func (c Conn) handshakeDone() { close(c.lifetime.readyc) } // isDraining reports whether the conn is in the draining state. // // The draining state is entered once an endpoint receives a CONNECTION_CLOSE frame. // The endpoint will no longer send any packets, but we retain knowledge of the connection // until the end of the drain period to ensure we discard packets for the connection // rather than treating them as starting a new connection. // // https://www.rfc-editor.org/rfc/rfc9000.html#section-10.2.2 func (c Conn) isDraining() bool { switch c.lifetime.state { case connStateDraining, connStateDone: return true } return false } // isAlive reports whether the conn is handling packets. func (c Conn) isAlive() bool { return c.lifetime.state == connStateAlive } // sendOK reports whether the conn can send frames at this time. func (c Conn) sendOK(now time.Time) bool { switch c.lifetime.state { case connStateAlive: return true case connStatePeerClosed: if c.lifetime.localErr == nil { // We're waiting for the user to close the connection, providing us with // a final status to send to the peer. return false } // We should send a CONNECTION_CLOSE. return true case connStateClosing: if c.lifetime.connCloseSentTime.IsZero() { return true } maxRecvTime := c.acks[initialSpace].maxRecvTime if t := c.acks[handshakeSpace].maxRecvTime; t.After(maxRecvTime) { maxRecvTime = t } if t := c.acks[appDataSpace].maxRecvTime; t.After(maxRecvTime) { maxRecvTime = t } if maxRecvTime.Before(c.lifetime.connCloseSentTime.Add(c.lifetime.connCloseDelay)) { // After sending CONNECTION_CLOSE, ignore packets from the peer for // a delay. On the next packet received after the delay, send another // CONNECTION_CLOSE. return false } return true case connStateDraining: // We are in the draining state, and will send no more packets. return false case connStateDone: return false default: panic("BUG: unhandled connection state") } } // sendConnectionClose reports that the conn has sent a CONNECTION_CLOSE to the peer. func (c Conn) sentConnectionClose(now time.Time) { switch c.lifetime.state { case connStatePeerClosed: c.enterDraining(now) } if c.lifetime.connCloseSentTime.IsZero() { // Set the initial delay before we will send another CONNECTION_CLOSE. // // RFC 9000 states that we should rate limit CONNECTION_CLOSE frames, // but leaves the implementation of the limit up to us. Here, we start // with the same delay as the PTO timer (RFC 9002, Section 6.2.1), // not including max_ack_delay, and double it on every CONNECTION_CLOSE sent. c.lifetime.connCloseDelay = c.loss.rtt.smoothedRTT + max(4c.loss.rtt.rttvar, timerGranularity) } else if !c.lifetime.connCloseSentTime.Equal(now) { // If connCloseSentTime == now, we're sending two CONNECTION_CLOSE frames // coalesced into the same datagram. We only want to increase the delay once. c.lifetime.connCloseDelay = 2 } c.lifetime.connCloseSentTime = now } // handlePeerConnectionClose handles a CONNECTION_CLOSE from the peer. func (c Conn) handlePeerConnectionClose(now time.Time, err error) { c.setFinalError(err) switch c.lifetime.state { case connStateAlive: c.setState(now, connStatePeerClosed) case connStatePeerClosed: // Duplicate CONNECTION_CLOSE, ignore. case connStateClosing: if c.lifetime.connCloseSentTime.IsZero() { c.setState(now, connStatePeerClosed) } else { c.setState(now, connStateDraining) } case connStateDraining: case connStateDone: } } // setFinalError records the final connection status we report to the user. func (c Conn) setFinalError(err error) { select { case <-c.lifetime.donec: return // already set default: } c.lifetime.finalErr = err close(c.lifetime.donec) } func (c Conn) waitReady(ctx context.Context) error { select { case <-c.lifetime.readyc: return nil case <-c.lifetime.donec: return c.lifetime.finalErr default: } select { case <-c.lifetime.readyc: return nil case <-c.lifetime.donec: return c.lifetime.finalErr case <-ctx.Done(): return ctx.Err() } } // Close closes the connection. // // Close is equivalent to: // // conn.Abort(nil) // err := conn.Wait(context.Background()) func (c Conn) Close() error { c.Abort(nil) <-c.lifetime.donec return c.lifetime.finalErr } // Wait waits for the peer to close the connection. // // If the connection is closed locally and the peer does not close its end of the connection, // Wait will return with a non-nil error after the drain period expires. // // If the peer closes the connection with a NO_ERROR transport error, Wait returns nil. // If the peer closes the connection with an application error, Wait returns an ApplicationError // containing the peer's error code and reason. // If the peer closes the connection with any other status, Wait returns a non-nil error. func (c Conn) Wait(ctx context.Context) error { if err := c.waitOnDone(ctx, c.lifetime.donec); err != nil { return err } return c.lifetime.finalErr } // Abort closes the connection and returns immediately. // // If err is nil, Abort sends a transport error of NO_ERROR to the peer. // If err is an ApplicationError, Abort sends its error code and text. // Otherwise, Abort sends a transport error of APPLICATION_ERROR with the error's text. func (c Conn) Abort(err error) { if err == nil { err = localTransportError{code: errNo} } c.sendMsg(func(now time.Time, c Conn) { c.enterClosing(now, err) }) } // abort terminates a connection with an error. func (c Conn) abort(now time.Time, err error) { c.setFinalError(err) // this error takes precedence over the peer's CONNECTION_CLOSE c.enterClosing(now, err) } // abortImmediately terminates a connection. // The connection does not send a CONNECTION_CLOSE, and skips the draining period. func (c Conn) abortImmediately(now time.Time, err error) { c.setFinalError(err) c.setState(now, connStateDone) } // enterClosing starts an immediate close. // We will send a CONNECTION_CLOSE to the peer and wait for their response. func (c Conn) enterClosing(now time.Time, err error) { switch c.lifetime.state { case connStateAlive: c.lifetime.localErr = err c.setState(now, connStateClosing) case connStatePeerClosed: c.lifetime.localErr = err } } // enterDraining moves directly to the draining state, without sending a CONNECTION_CLOSE. func (c Conn) enterDraining(now time.Time) { switch c.lifetime.state { case connStateAlive, connStatePeerClosed, connStateClosing: c.setState(now, connStateDraining) } } // exit fully terminates a connection immediately. func (c Conn) exit() { c.sendMsg(func(now time.Time, c Conn) { c.abortImmediately(now, errors.New("connection closed")) }) }	9.99 KB	2025-05-25 12:27
📄 conn_close_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "context" "crypto/tls" "errors" "testing" "time" ) func TestConnCloseResponseBackoff(t testing.T) { tc := newTestConn(t, clientSide, func(c Config) { clear(c.StatelessResetKey[:]) }) tc.handshake() tc.conn.Abort(nil) tc.wantFrame("aborting connection generates CONN_CLOSE", packetType1RTT, debugFrameConnectionCloseTransport{ code: errNo, }) waiting := runAsync(tc, func(ctx context.Context) (struct{}, error) { return struct{}{}, tc.conn.Wait(ctx) }) if _, err := waiting.result(); err != errNotDone { t.Errorf("conn.Wait() = %v, want still waiting", err) } tc.writeFrames(packetType1RTT, debugFramePing{}) tc.wantIdle("packets received immediately after CONN_CLOSE receive no response") tc.advance(1100 * time.Microsecond) tc.writeFrames(packetType1RTT, debugFramePing{}) tc.wantFrame("receiving packet 1.1ms after CONN_CLOSE generates another CONN_CLOSE", packetType1RTT, debugFrameConnectionCloseTransport{ code: errNo, }) tc.advance(1100 * time.Microsecond) tc.writeFrames(packetType1RTT, debugFramePing{}) tc.wantIdle("no response to packet, because CONN_CLOSE backoff is now 2ms") tc.advance(1000 * time.Microsecond) tc.writeFrames(packetType1RTT, debugFramePing{}) tc.wantFrame("2ms since last CONN_CLOSE, receiving a packet generates another CONN_CLOSE", packetType1RTT, debugFrameConnectionCloseTransport{ code: errNo, }) if _, err := waiting.result(); err != errNotDone { t.Errorf("conn.Wait() = %v, want still waiting", err) } tc.advance(100000 * time.Microsecond) tc.writeFrames(packetType1RTT, debugFramePing{}) tc.wantIdle("drain timer expired, no more responses") if _, err := waiting.result(); !errors.Is(err, errNoPeerResponse) { t.Errorf("blocked conn.Wait() = %v, want errNoPeerResponse", err) } if err := tc.conn.Wait(canceledContext()); !errors.Is(err, errNoPeerResponse) { t.Errorf("non-blocking conn.Wait() = %v, want errNoPeerResponse", err) } } func TestConnCloseWithPeerResponse(t testing.T) { qr := &qlogRecord{} tc := newTestConn(t, clientSide, qr.config) tc.handshake() tc.conn.Abort(nil) tc.wantFrame("aborting connection generates CONN_CLOSE", packetType1RTT, debugFrameConnectionCloseTransport{ code: errNo, }) waiting := runAsync(tc, func(ctx context.Context) (struct{}, error) { return struct{}{}, tc.conn.Wait(ctx) }) if _, err := waiting.result(); err != errNotDone { t.Errorf("conn.Wait() = %v, want still waiting", err) } tc.writeFrames(packetType1RTT, debugFrameConnectionCloseApplication{ code: 20, }) wantErr := &ApplicationError{ Code: 20, } if _, err := waiting.result(); !errors.Is(err, wantErr) { t.Errorf("blocked conn.Wait() = %v, want %v", err, wantErr) } if err := tc.conn.Wait(canceledContext()); !errors.Is(err, wantErr) { t.Errorf("non-blocking conn.Wait() = %v, want %v", err, wantErr) } tc.advance(1 time.Second) // long enough to exit the draining state qr.wantEvents(t, jsonEvent{ "name": "connectivity:connection_closed", "data": map[string]any{ "trigger": "application", }, }) } func TestConnClosePeerCloses(t testing.T) { qr := &qlogRecord{} tc := newTestConn(t, clientSide, qr.config) tc.handshake() wantErr := &ApplicationError{ Code: 42, Reason: "why?", } tc.writeFrames(packetType1RTT, debugFrameConnectionCloseApplication{ code: wantErr.Code, reason: wantErr.Reason, }) tc.wantIdle("CONN_CLOSE response not sent until user closes this side") if err := tc.conn.Wait(canceledContext()); !errors.Is(err, wantErr) { t.Errorf("conn.Wait() = %v, want %v", err, wantErr) } tc.conn.Abort(&ApplicationError{ Code: 9, Reason: "because", }) tc.wantFrame("CONN_CLOSE sent after user closes connection", packetType1RTT, debugFrameConnectionCloseApplication{ code: 9, reason: "because", }) tc.advance(1 time.Second) // long enough to exit the draining state qr.wantEvents(t, jsonEvent{ "name": "connectivity:connection_closed", "data": map[string]any{ "trigger": "application", }, }) } func TestConnCloseReceiveInInitial(t testing.T) { tc := newTestConn(t, clientSide) tc.wantFrame("client sends Initial CRYPTO frame", packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataOut[tls.QUICEncryptionLevelInitial], }) tc.writeFrames(packetTypeInitial, debugFrameConnectionCloseTransport{ code: errConnectionRefused, }) tc.wantIdle("CONN_CLOSE response not sent until user closes this side") wantErr := peerTransportError{code: errConnectionRefused} if err := tc.conn.Wait(canceledContext()); !errors.Is(err, wantErr) { t.Errorf("conn.Wait() = %v, want %v", err, wantErr) } tc.conn.Abort(&ApplicationError{Code: 1}) tc.wantFrame("CONN_CLOSE in Initial frame is APPLICATION_ERROR", packetTypeInitial, debugFrameConnectionCloseTransport{ code: errApplicationError, }) tc.wantIdle("no more frames to send") } func TestConnCloseReceiveInHandshake(t testing.T) { tc := newTestConn(t, clientSide) tc.ignoreFrame(frameTypeAck) tc.wantFrame("client sends Initial CRYPTO frame", packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataOut[tls.QUICEncryptionLevelInitial], }) tc.writeFrames(packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelInitial], }) tc.writeFrames(packetTypeHandshake, debugFrameConnectionCloseTransport{ code: errConnectionRefused, }) tc.wantIdle("CONN_CLOSE response not sent until user closes this side") wantErr := peerTransportError{code: errConnectionRefused} if err := tc.conn.Wait(canceledContext()); !errors.Is(err, wantErr) { t.Errorf("conn.Wait() = %v, want %v", err, wantErr) } // The conn has Initial and Handshake keys, so it will send CONN_CLOSE in both spaces. tc.conn.Abort(&ApplicationError{Code: 1}) tc.wantFrame("CONN_CLOSE in Initial frame is APPLICATION_ERROR", packetTypeInitial, debugFrameConnectionCloseTransport{ code: errApplicationError, }) tc.wantFrame("CONN_CLOSE in Handshake frame is APPLICATION_ERROR", packetTypeHandshake, debugFrameConnectionCloseTransport{ code: errApplicationError, }) tc.wantIdle("no more frames to send") } func TestConnCloseClosedByEndpoint(t testing.T) { ctx := canceledContext() tc := newTestConn(t, clientSide) tc.handshake() tc.endpoint.e.Close(ctx) tc.wantFrame("endpoint closes connection before exiting", packetType1RTT, debugFrameConnectionCloseTransport{ code: errNo, }) } func testConnCloseUnblocks(t testing.T, f func(context.Context, testConn) error, opts ...any) { tc := newTestConn(t, clientSide, opts...) tc.handshake() op := runAsync(tc, func(ctx context.Context) (struct{}, error) { return struct{}{}, f(ctx, tc) }) if _, err := op.result(); err != errNotDone { t.Fatalf("before abort, op = %v, want errNotDone", err) } tc.conn.Abort(nil) if _, err := op.result(); err == nil \|\| err == errNotDone { t.Fatalf("after abort, op = %v, want error", err) } } func TestConnCloseUnblocksAcceptStream(t testing.T) { testConnCloseUnblocks(t, func(ctx context.Context, tc testConn) error { _, err := tc.conn.AcceptStream(ctx) return err }, permissiveTransportParameters) } func TestConnCloseUnblocksNewStream(t testing.T) { testConnCloseUnblocks(t, func(ctx context.Context, tc testConn) error { _, err := tc.conn.NewStream(ctx) return err }) } func TestConnCloseUnblocksStreamRead(t testing.T) { testConnCloseUnblocks(t, func(ctx context.Context, tc testConn) error { s := newLocalStream(t, tc, bidiStream) s.SetReadContext(ctx) buf := make([]byte, 16) _, err := s.Read(buf) return err }, permissiveTransportParameters) } func TestConnCloseUnblocksStreamWrite(t testing.T) { testConnCloseUnblocks(t, func(ctx context.Context, tc testConn) error { s := newLocalStream(t, tc, bidiStream) s.SetWriteContext(ctx) buf := make([]byte, 32) _, err := s.Write(buf) return err }, permissiveTransportParameters, func(c Config) { c.MaxStreamWriteBufferSize = 16 }) } func TestConnCloseUnblocksStreamClose(t testing.T) { testConnCloseUnblocks(t, func(ctx context.Context, tc testConn) error { s := newLocalStream(t, tc, bidiStream) s.SetWriteContext(ctx) buf := make([]byte, 16) _, err := s.Write(buf) if err != nil { return err } return s.Close() }, permissiveTransportParameters) }	8.31 KB	2025-05-25 12:27
📄 conn_flow.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "sync/atomic" "time" ) // connInflow tracks connection-level flow control for data sent by the peer to us. // // There are four byte offsets of significance in the stream of data received from the peer, // each >= to the previous: // // - bytes read by the user // - bytes received from the peer // - limit sent to the peer in a MAX_DATA frame // - potential new limit to sent to the peer // // We maintain a flow control window, so as bytes are read by the user // the potential limit is extended correspondingly. // // We keep an atomic counter of bytes read by the user and not yet applied to the // potential limit (credit). When this count grows large enough, we update the // new limit to send and mark that we need to send a new MAX_DATA frame. type connInflow struct { sent sentVal // set when we need to send a MAX_DATA update to the peer usedLimit int64 // total bytes sent by the peer, must be less than sentLimit sentLimit int64 // last MAX_DATA sent to the peer newLimit int64 // new MAX_DATA to send credit atomic.Int64 // bytes read but not yet applied to extending the flow-control window } func (c Conn) inflowInit() { // The initial MAX_DATA limit is sent as a transport parameter. c.streams.inflow.sentLimit = c.config.maxConnReadBufferSize() c.streams.inflow.newLimit = c.streams.inflow.sentLimit } // handleStreamBytesReadOffLoop records that the user has consumed bytes from a stream. // We may extend the peer's flow control window. // // This is called indirectly by the user, via Read or CloseRead. func (c Conn) handleStreamBytesReadOffLoop(n int64) { if n == 0 { return } if c.shouldUpdateFlowControl(c.streams.inflow.credit.Add(n)) { // We should send a MAX_DATA update to the peer. // Record this on the Conn's main loop. c.sendMsg(func(now time.Time, c Conn) { // A MAX_DATA update may have already happened, so check again. if c.shouldUpdateFlowControl(c.streams.inflow.credit.Load()) { c.sendMaxDataUpdate() } }) } } // handleStreamBytesReadOnLoop extends the peer's flow control window after // data has been discarded due to a RESET_STREAM frame. // // This is called on the conn's loop. func (c Conn) handleStreamBytesReadOnLoop(n int64) { if c.shouldUpdateFlowControl(c.streams.inflow.credit.Add(n)) { c.sendMaxDataUpdate() } } func (c Conn) sendMaxDataUpdate() { c.streams.inflow.sent.setUnsent() // Apply current credit to the limit. // We don't strictly need to do this here // since appendMaxDataFrame will do so as well, // but this avoids redundant trips down this path // if the MAX_DATA frame doesn't go out right away. c.streams.inflow.newLimit += c.streams.inflow.credit.Swap(0) } func (c Conn) shouldUpdateFlowControl(credit int64) bool { return shouldUpdateFlowControl(c.config.maxConnReadBufferSize(), credit) } // handleStreamBytesReceived records that the peer has sent us stream data. func (c Conn) handleStreamBytesReceived(n int64) error { c.streams.inflow.usedLimit += n if c.streams.inflow.usedLimit > c.streams.inflow.sentLimit { return localTransportError{ code: errFlowControl, reason: "stream exceeded flow control limit", } } return nil } // appendMaxDataFrame appends a MAX_DATA frame to the current packet. // // It returns true if no more frames need appending, // false if it could not fit a frame in the current packet. func (c Conn) appendMaxDataFrame(w packetWriter, pnum packetNumber, pto bool) bool { if c.streams.inflow.sent.shouldSendPTO(pto) { // Add any unapplied credit to the new limit now. c.streams.inflow.newLimit += c.streams.inflow.credit.Swap(0) if !w.appendMaxDataFrame(c.streams.inflow.newLimit) { return false } c.streams.inflow.sentLimit += c.streams.inflow.newLimit c.streams.inflow.sent.setSent(pnum) } return true } // ackOrLossMaxData records the fate of a MAX_DATA frame. func (c Conn) ackOrLossMaxData(pnum packetNumber, fate packetFate) { c.streams.inflow.sent.ackLatestOrLoss(pnum, fate) } // connOutflow tracks connection-level flow control for data sent by us to the peer. type connOutflow struct { max int64 // largest MAX_DATA received from peer used int64 // total bytes of STREAM data sent to peer } // setMaxData updates the connection-level flow control limit // with the initial limit conveyed in transport parameters // or an update from a MAX_DATA frame. func (f connOutflow) setMaxData(maxData int64) { f.max = max(f.max, maxData) } // avail returns the number of connection-level flow control bytes available. func (f connOutflow) avail() int64 { return f.max - f.used } // consume records consumption of n bytes of flow. func (f *connOutflow) consume(n int64) { f.used += n }	4.81 KB	2025-05-25 12:27
📄 conn_flow_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "context" "testing" ) func TestConnInflowReturnOnRead(t testing.T) { tc, s := newTestConnAndRemoteStream(t, serverSide, uniStream, func(c Config) { c.MaxConnReadBufferSize = 64 }) tc.writeFrames(packetType1RTT, debugFrameStream{ id: s.id, data: make([]byte, 8), }) if n, err := s.Read(make([]byte, 8)); n != 8 \|\| err != nil { t.Fatalf("s.Read() = %v, %v; want %v, nil", n, err, 8) } tc.wantFrame("available window increases, send a MAX_DATA", packetType1RTT, debugFrameMaxData{ max: 64 + 8, }) // Peer can write up to the new limit. tc.writeFrames(packetType1RTT, debugFrameStream{ id: s.id, off: 8, data: make([]byte, 64), }) if n, err := s.Read(make([]byte, 64+1)); n != 64 { t.Fatalf("s.Read() = %v, %v; want %v, anything", n, err, 64) } tc.wantFrame("available window increases, send a MAX_DATA", packetType1RTT, debugFrameMaxData{ max: 64 + 8 + 64, }) tc.wantIdle("connection is idle") } func TestConnInflowReturnOnRacingReads(t testing.T) { // Perform two reads at the same time, // one for half of MaxConnReadBufferSize // and one for one byte. // // We should observe a single MAX_DATA update. // Depending on the ordering of events, // this may include the credit from just the larger read // or the credit from both. ctx := canceledContext() tc := newTestConn(t, serverSide, func(c Config) { c.MaxConnReadBufferSize = 64 }) tc.handshake() tc.ignoreFrame(frameTypeAck) tc.writeFrames(packetType1RTT, debugFrameStream{ id: newStreamID(clientSide, uniStream, 0), data: make([]byte, 16), }) tc.writeFrames(packetType1RTT, debugFrameStream{ id: newStreamID(clientSide, uniStream, 1), data: make([]byte, 1), }) s1, err := tc.conn.AcceptStream(ctx) if err != nil { t.Fatalf("conn.AcceptStream() = %v", err) } s2, err := tc.conn.AcceptStream(ctx) if err != nil { t.Fatalf("conn.AcceptStream() = %v", err) } read1 := runAsync(tc, func(ctx context.Context) (int, error) { return s1.Read(make([]byte, 16)) }) read2 := runAsync(tc, func(ctx context.Context) (int, error) { return s2.Read(make([]byte, 1)) }) // This MAX_DATA might extend the window by 16 or 17, depending on // whether the second write occurs before the update happens. tc.wantFrameType("MAX_DATA update is sent", packetType1RTT, debugFrameMaxData{}) tc.wantIdle("redundant MAX_DATA is not sent") if _, err := read1.result(); err != nil { t.Errorf("Read #1 = %v", err) } if _, err := read2.result(); err != nil { t.Errorf("Read #2 = %v", err) } } func TestConnInflowReturnOnClose(t testing.T) { tc, s := newTestConnAndRemoteStream(t, serverSide, uniStream, func(c Config) { c.MaxConnReadBufferSize = 64 }) tc.ignoreFrame(frameTypeStopSending) tc.writeFrames(packetType1RTT, debugFrameStream{ id: s.id, data: make([]byte, 64), }) s.CloseRead() tc.wantFrame("closing stream updates connection-level flow control", packetType1RTT, debugFrameMaxData{ max: 128, }) } func TestConnInflowReturnOnReset(t testing.T) { tc, s := newTestConnAndRemoteStream(t, serverSide, uniStream, func(c Config) { c.MaxConnReadBufferSize = 64 }) tc.ignoreFrame(frameTypeStopSending) tc.writeFrames(packetType1RTT, debugFrameStream{ id: s.id, data: make([]byte, 32), }) tc.writeFrames(packetType1RTT, debugFrameResetStream{ id: s.id, finalSize: 64, }) s.CloseRead() tc.wantFrame("receiving stream reseet updates connection-level flow control", packetType1RTT, debugFrameMaxData{ max: 128, }) } func TestConnInflowStreamViolation(t testing.T) { tc := newTestConn(t, serverSide, func(c Config) { c.MaxConnReadBufferSize = 100 }) tc.handshake() tc.ignoreFrame(frameTypeAck) // Total MAX_DATA consumed: 50 tc.writeFrames(packetType1RTT, debugFrameStream{ id: newStreamID(clientSide, bidiStream, 0), data: make([]byte, 50), }) // Total MAX_DATA consumed: 80 tc.writeFrames(packetType1RTT, debugFrameStream{ id: newStreamID(clientSide, uniStream, 0), off: 20, data: make([]byte, 10), }) // Total MAX_DATA consumed: 100 tc.writeFrames(packetType1RTT, debugFrameStream{ id: newStreamID(clientSide, bidiStream, 0), off: 70, fin: true, }) // This stream has already consumed quota for these bytes. // Total MAX_DATA consumed: 100 tc.writeFrames(packetType1RTT, debugFrameStream{ id: newStreamID(clientSide, uniStream, 0), data: make([]byte, 20), }) tc.wantIdle("peer has consumed all MAX_DATA quota") // Total MAX_DATA consumed: 101 tc.writeFrames(packetType1RTT, debugFrameStream{ id: newStreamID(clientSide, bidiStream, 2), data: make([]byte, 1), }) tc.wantFrame("peer violates MAX_DATA limit", packetType1RTT, debugFrameConnectionCloseTransport{ code: errFlowControl, }) } func TestConnInflowResetViolation(t testing.T) { tc := newTestConn(t, serverSide, func(c Config) { c.MaxConnReadBufferSize = 100 }) tc.handshake() tc.ignoreFrame(frameTypeAck) tc.writeFrames(packetType1RTT, debugFrameStream{ id: newStreamID(clientSide, bidiStream, 0), data: make([]byte, 100), }) tc.wantIdle("peer has consumed all MAX_DATA quota") tc.writeFrames(packetType1RTT, debugFrameResetStream{ id: newStreamID(clientSide, uniStream, 0), finalSize: 0, }) tc.wantIdle("stream reset does not consume MAX_DATA quota, no error") tc.writeFrames(packetType1RTT, debugFrameResetStream{ id: newStreamID(clientSide, uniStream, 1), finalSize: 1, }) tc.wantFrame("RESET_STREAM final size violates MAX_DATA limit", packetType1RTT, debugFrameConnectionCloseTransport{ code: errFlowControl, }) } func TestConnInflowMultipleStreams(t testing.T) { tc := newTestConn(t, serverSide, func(c Config) { c.MaxConnReadBufferSize = 128 }) tc.handshake() tc.ignoreFrame(frameTypeAck) var streams []Stream for _, id := range []streamID{ newStreamID(clientSide, uniStream, 0), newStreamID(clientSide, uniStream, 1), newStreamID(clientSide, bidiStream, 0), newStreamID(clientSide, bidiStream, 1), } { tc.writeFrames(packetType1RTT, debugFrameStream{ id: id, data: make([]byte, 1), }) s := tc.acceptStream() streams = append(streams, s) if n, err := s.Read(make([]byte, 1)); err != nil \|\| n != 1 { t.Fatalf("s.Read() = %v, %v; want 1, nil", n, err) } } tc.wantIdle("streams have read data, but not enough to update MAX_DATA") for _, s := range streams { tc.writeFrames(packetType1RTT, debugFrameStream{ id: s.id, off: 1, data: make([]byte, 31), }) } if n, err := streams[0].Read(make([]byte, 32)); n != 31 { t.Fatalf("s.Read() = %v, %v; want 31, anything", n, err) } tc.wantFrame("read enough data to trigger a MAX_DATA update", packetType1RTT, debugFrameMaxData{ max: 128 + 32 + 1 + 1 + 1, }) tc.ignoreFrame(frameTypeStopSending) streams[2].CloseRead() tc.wantFrame("closed stream triggers another MAX_DATA update", packetType1RTT, debugFrameMaxData{ max: 128 + 32 + 1 + 32 + 1, }) } func TestConnOutflowBlocked(t testing.T) { tc, s := newTestConnAndLocalStream(t, clientSide, uniStream, permissiveTransportParameters, func(p transportParameters) { p.initialMaxData = 10 }) tc.ignoreFrame(frameTypeAck) data := makeTestData(32) n, err := s.Write(data) if n != len(data) \|\| err != nil { t.Fatalf("s.Write() = %v, %v; want %v, nil", n, err, len(data)) } s.Flush() tc.wantFrame("stream writes data up to MAX_DATA limit", packetType1RTT, debugFrameStream{ id: s.id, data: data[:10], }) tc.wantIdle("stream is blocked by MAX_DATA limit") tc.writeFrames(packetType1RTT, debugFrameMaxData{ max: 20, }) tc.wantFrame("stream writes data up to new MAX_DATA limit", packetType1RTT, debugFrameStream{ id: s.id, off: 10, data: data[10:20], }) tc.wantIdle("stream is blocked by new MAX_DATA limit") tc.writeFrames(packetType1RTT, debugFrameMaxData{ max: 100, }) tc.wantFrame("stream writes remaining data", packetType1RTT, debugFrameStream{ id: s.id, off: 20, data: data[20:], }) } func TestConnOutflowMaxDataDecreases(t testing.T) { tc, s := newTestConnAndLocalStream(t, clientSide, uniStream, permissiveTransportParameters, func(p transportParameters) { p.initialMaxData = 10 }) tc.ignoreFrame(frameTypeAck) // Decrease in MAX_DATA is ignored. tc.writeFrames(packetType1RTT, debugFrameMaxData{ max: 5, }) data := makeTestData(32) n, err := s.Write(data) if n != len(data) \|\| err != nil { t.Fatalf("s.Write() = %v, %v; want %v, nil", n, err, len(data)) } s.Flush() tc.wantFrame("stream writes data up to MAX_DATA limit", packetType1RTT, debugFrameStream{ id: s.id, data: data[:10], }) } func TestConnOutflowMaxDataRoundRobin(t testing.T) { ctx := canceledContext() tc := newTestConn(t, clientSide, permissiveTransportParameters, func(p transportParameters) { p.initialMaxData = 0 }) tc.handshake() tc.ignoreFrame(frameTypeAck) s1, err := tc.conn.newLocalStream(ctx, uniStream) if err != nil { t.Fatalf("conn.newLocalStream(%v) = %v", uniStream, err) } s2, err := tc.conn.newLocalStream(ctx, uniStream) if err != nil { t.Fatalf("conn.newLocalStream(%v) = %v", uniStream, err) } s1.Write(make([]byte, 10)) s1.Flush() s2.Write(make([]byte, 10)) s2.Flush() tc.writeFrames(packetType1RTT, debugFrameMaxData{ max: 1, }) tc.wantFrame("stream 1 writes data up to MAX_DATA limit", packetType1RTT, debugFrameStream{ id: s1.id, data: []byte{0}, }) tc.writeFrames(packetType1RTT, debugFrameMaxData{ max: 2, }) tc.wantFrame("stream 2 writes data up to MAX_DATA limit", packetType1RTT, debugFrameStream{ id: s2.id, data: []byte{0}, }) tc.writeFrames(packetType1RTT, debugFrameMaxData{ max: 3, }) tc.wantFrame("stream 1 writes data up to MAX_DATA limit", packetType1RTT, debugFrameStream{ id: s1.id, off: 1, data: []byte{0}, }) } func TestConnOutflowMetaAndData(t testing.T) { tc, s := newTestConnAndLocalStream(t, clientSide, bidiStream, permissiveTransportParameters, func(p transportParameters) { p.initialMaxData = 0 }) tc.ignoreFrame(frameTypeAck) data := makeTestData(32) s.Write(data) s.Flush() s.CloseRead() tc.wantFrame("CloseRead sends a STOP_SENDING, not flow controlled", packetType1RTT, debugFrameStopSending{ id: s.id, }) tc.writeFrames(packetType1RTT, debugFrameMaxData{ max: 100, }) tc.wantFrame("unblocked MAX_DATA", packetType1RTT, debugFrameStream{ id: s.id, data: data, }) } func TestConnOutflowResentData(t testing.T) { tc, s := newTestConnAndLocalStream(t, clientSide, bidiStream, permissiveTransportParameters, func(p *transportParameters) { p.initialMaxData = 10 }) tc.ignoreFrame(frameTypeAck) data := makeTestData(15) s.Write(data[:8]) s.Flush() tc.wantFrame("data is under MAX_DATA limit, all sent", packetType1RTT, debugFrameStream{ id: s.id, data: data[:8], }) // Lose the last STREAM packet. const pto = false tc.triggerLossOrPTO(packetType1RTT, false) tc.wantFrame("lost STREAM data is retransmitted", packetType1RTT, debugFrameStream{ id: s.id, data: data[:8], }) s.Write(data[8:]) s.Flush() tc.wantFrame("new data is sent up to the MAX_DATA limit", packetType1RTT, debugFrameStream{ id: s.id, off: 8, data: data[8:10], }) }	11.27 KB	2025-05-25 12:27
📄 conn_id.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "bytes" "crypto/rand" ) // connIDState is a conn's connection IDs. type connIDState struct { // The destination connection IDs of packets we receive are local. // The destination connection IDs of packets we send are remote. // // Local IDs are usually issued by us, and remote IDs by the peer. // The exception is the transient destination connection ID sent in // a client's Initial packets, which is chosen by the client. // // These are []connID rather than []connID to minimize allocations. local []connID remote []remoteConnID nextLocalSeq int64 retireRemotePriorTo int64 // largest Retire Prior To value sent by the peer peerActiveConnIDLimit int64 // peer's active_connection_id_limit transport parameter originalDstConnID []byte // expected original_destination_connection_id param retrySrcConnID []byte // expected retry_source_connection_id param needSend bool } // A connID is a connection ID and associated metadata. type connID struct { // cid is the connection ID itself. cid []byte // seq is the connection ID's sequence number: // https://www.rfc-editor.org/rfc/rfc9000.html#section-5.1.1-1 // // For the transient destination ID in a client's Initial packet, this is -1. seq int64 // retired is set when the connection ID is retired. retired bool // send is set when the connection ID's state needs to be sent to the peer. // // For local IDs, this indicates a new ID that should be sent // in a NEW_CONNECTION_ID frame. // // For remote IDs, this indicates a retired ID that should be sent // in a RETIRE_CONNECTION_ID frame. send sentVal } // A remoteConnID is a connection ID and stateless reset token. type remoteConnID struct { connID resetToken statelessResetToken } func (s connIDState) initClient(c Conn) error { // Client chooses its initial connection ID, and sends it // in the Source Connection ID field of the first Initial packet. locid, err := c.newConnID(0) if err != nil { return err } s.local = append(s.local, connID{ seq: 0, cid: locid, }) s.nextLocalSeq = 1 c.endpoint.connsMap.updateConnIDs(func(conns connsMap) { conns.addConnID(c, locid) }) // Client chooses an initial, transient connection ID for the server, // and sends it in the Destination Connection ID field of the first Initial packet. remid, err := c.newConnID(-1) if err != nil { return err } s.remote = append(s.remote, remoteConnID{ connID: connID{ seq: -1, cid: remid, }, }) s.originalDstConnID = remid return nil } func (s connIDState) initServer(c Conn, cids newServerConnIDs) error { dstConnID := cloneBytes(cids.dstConnID) // Client-chosen, transient connection ID received in the first Initial packet. // The server will not use this as the Source Connection ID of packets it sends, // but remembers it because it may receive packets sent to this destination. s.local = append(s.local, connID{ seq: -1, cid: dstConnID, }) // Server chooses a connection ID, and sends it in the Source Connection ID of // the response to the clent. locid, err := c.newConnID(0) if err != nil { return err } s.local = append(s.local, connID{ seq: 0, cid: locid, }) s.nextLocalSeq = 1 c.endpoint.connsMap.updateConnIDs(func(conns connsMap) { conns.addConnID(c, dstConnID) conns.addConnID(c, locid) }) // Client chose its own connection ID. s.remote = append(s.remote, remoteConnID{ connID: connID{ seq: 0, cid: cloneBytes(cids.srcConnID), }, }) return nil } // srcConnID is the Source Connection ID to use in a sent packet. func (s connIDState) srcConnID() []byte { if s.local[0].seq == -1 && len(s.local) > 1 { // Don't use the transient connection ID if another is available. return s.local[1].cid } return s.local[0].cid } // dstConnID is the Destination Connection ID to use in a sent packet. func (s connIDState) dstConnID() (cid []byte, ok bool) { for i := range s.remote { if !s.remote[i].retired { return s.remote[i].cid, true } } return nil, false } // isValidStatelessResetToken reports whether the given reset token is // associated with a non-retired connection ID which we have used. func (s connIDState) isValidStatelessResetToken(resetToken statelessResetToken) bool { for i := range s.remote { // We currently only use the first available remote connection ID, // so any other reset token is not valid. if !s.remote[i].retired { return s.remote[i].resetToken == resetToken } } return false } // setPeerActiveConnIDLimit sets the active_connection_id_limit // transport parameter received from the peer. func (s connIDState) setPeerActiveConnIDLimit(c Conn, lim int64) error { s.peerActiveConnIDLimit = lim return s.issueLocalIDs(c) } func (s connIDState) issueLocalIDs(c Conn) error { toIssue := min(int(s.peerActiveConnIDLimit), maxPeerActiveConnIDLimit) for i := range s.local { if s.local[i].seq != -1 && !s.local[i].retired { toIssue-- } } var newIDs [][]byte for toIssue > 0 { cid, err := c.newConnID(s.nextLocalSeq) if err != nil { return err } newIDs = append(newIDs, cid) s.local = append(s.local, connID{ seq: s.nextLocalSeq, cid: cid, }) s.local[len(s.local)-1].send.setUnsent() s.nextLocalSeq++ s.needSend = true toIssue-- } c.endpoint.connsMap.updateConnIDs(func(conns connsMap) { for _, cid := range newIDs { conns.addConnID(c, cid) } }) return nil } // validateTransportParameters verifies the original_destination_connection_id and // initial_source_connection_id transport parameters match the expected values. func (s connIDState) validateTransportParameters(c Conn, isRetry bool, p transportParameters) error { // TODO: Consider returning more detailed errors, for debugging. // Verify original_destination_connection_id matches // the transient remote connection ID we chose (client) // or is empty (server). if !bytes.Equal(s.originalDstConnID, p.originalDstConnID) { return localTransportError{ code: errTransportParameter, reason: "original_destination_connection_id mismatch", } } s.originalDstConnID = nil // we have no further need for this // Verify retry_source_connection_id matches the value from // the server's Retry packet (when one was sent), or is empty. if !bytes.Equal(p.retrySrcConnID, s.retrySrcConnID) { return localTransportError{ code: errTransportParameter, reason: "retry_source_connection_id mismatch", } } s.retrySrcConnID = nil // we have no further need for this // Verify initial_source_connection_id matches the first remote connection ID. if len(s.remote) == 0 \|\| s.remote[0].seq != 0 { return localTransportError{ code: errInternal, reason: "remote connection id missing", } } if !bytes.Equal(p.initialSrcConnID, s.remote[0].cid) { return localTransportError{ code: errTransportParameter, reason: "initial_source_connection_id mismatch", } } if len(p.statelessResetToken) > 0 { if c.side == serverSide { return localTransportError{ code: errTransportParameter, reason: "client sent stateless_reset_token", } } token := statelessResetToken(p.statelessResetToken) s.remote[0].resetToken = token c.endpoint.connsMap.updateConnIDs(func(conns connsMap) { conns.addResetToken(c, token) }) } return nil } // handlePacket updates the connection ID state during the handshake // (Initial and Handshake packets). func (s connIDState) handlePacket(c Conn, ptype packetType, srcConnID []byte) { switch { case ptype == packetTypeInitial && c.side == clientSide: if len(s.remote) == 1 && s.remote[0].seq == -1 { // We're a client connection processing the first Initial packet // from the server. Replace the transient remote connection ID // with the Source Connection ID from the packet. s.remote[0] = remoteConnID{ connID: connID{ seq: 0, cid: cloneBytes(srcConnID), }, } } case ptype == packetTypeHandshake && c.side == serverSide: if len(s.local) > 0 && s.local[0].seq == -1 && !s.local[0].retired { // We're a server connection processing the first Handshake packet from // the client. Discard the transient, client-chosen connection ID used // for Initial packets; the client will never send it again. cid := s.local[0].cid c.endpoint.connsMap.updateConnIDs(func(conns connsMap) { conns.retireConnID(c, cid) }) s.local = append(s.local[:0], s.local[1:]...) } } } func (s connIDState) handleRetryPacket(srcConnID []byte) { if len(s.remote) != 1 \|\| s.remote[0].seq != -1 { panic("BUG: handling retry with non-transient remote conn id") } s.retrySrcConnID = cloneBytes(srcConnID) s.remote[0].cid = s.retrySrcConnID } func (s connIDState) handleNewConnID(c Conn, seq, retire int64, cid []byte, resetToken statelessResetToken) error { if len(s.remote[0].cid) == 0 { // "An endpoint that is sending packets with a zero-length // Destination Connection ID MUST treat receipt of a NEW_CONNECTION_ID // frame as a connection error of type PROTOCOL_VIOLATION." // https://www.rfc-editor.org/rfc/rfc9000.html#section-19.15-6 return localTransportError{ code: errProtocolViolation, reason: "NEW_CONNECTION_ID from peer with zero-length DCID", } } if retire > s.retireRemotePriorTo { s.retireRemotePriorTo = retire } have := false // do we already have this connection ID? active := 0 for i := range s.remote { rcid := &s.remote[i] if !rcid.retired && rcid.seq >= 0 && rcid.seq < s.retireRemotePriorTo { s.retireRemote(rcid) c.endpoint.connsMap.updateConnIDs(func(conns connsMap) { conns.retireResetToken(c, rcid.resetToken) }) } if !rcid.retired { active++ } if rcid.seq == seq { if !bytes.Equal(rcid.cid, cid) { return localTransportError{ code: errProtocolViolation, reason: "NEW_CONNECTION_ID does not match prior id", } } have = true // yes, we've seen this sequence number } } if !have { // This is a new connection ID that we have not seen before. // // We could take steps to keep the list of remote connection IDs // sorted by sequence number, but there's no particular need // so we don't bother. s.remote = append(s.remote, remoteConnID{ connID: connID{ seq: seq, cid: cloneBytes(cid), }, resetToken: resetToken, }) if seq < s.retireRemotePriorTo { // This ID was already retired by a previous NEW_CONNECTION_ID frame. s.retireRemote(&s.remote[len(s.remote)-1]) } else { active++ c.endpoint.connsMap.updateConnIDs(func(conns connsMap) { conns.addResetToken(c, resetToken) }) } } if active > activeConnIDLimit { // Retired connection IDs (including newly-retired ones) do not count // against the limit. // https://www.rfc-editor.org/rfc/rfc9000.html#section-5.1.1-5 return localTransportError{ code: errConnectionIDLimit, reason: "active_connection_id_limit exceeded", } } // "An endpoint SHOULD limit the number of connection IDs it has retired locally // for which RETIRE_CONNECTION_ID frames have not yet been acknowledged." // https://www.rfc-editor.org/rfc/rfc9000#section-5.1.2-6 // // Set a limit of four times the active_connection_id_limit for // the total number of remote connection IDs we keep state for locally. if len(s.remote) > 4activeConnIDLimit { return localTransportError{ code: errConnectionIDLimit, reason: "too many unacknowledged RETIRE_CONNECTION_ID frames", } } return nil } // retireRemote marks a remote connection ID as retired. func (s connIDState) retireRemote(rcid remoteConnID) { rcid.retired = true rcid.send.setUnsent() s.needSend = true } func (s connIDState) handleRetireConnID(c Conn, seq int64) error { if seq >= s.nextLocalSeq { return localTransportError{ code: errProtocolViolation, reason: "RETIRE_CONNECTION_ID for unissued sequence number", } } for i := range s.local { if s.local[i].seq == seq { cid := s.local[i].cid c.endpoint.connsMap.updateConnIDs(func(conns connsMap) { conns.retireConnID(c, cid) }) s.local = append(s.local[:i], s.local[i+1:]...) break } } s.issueLocalIDs(c) return nil } func (s connIDState) ackOrLossNewConnectionID(pnum packetNumber, seq int64, fate packetFate) { for i := range s.local { if s.local[i].seq != seq { continue } s.local[i].send.ackOrLoss(pnum, fate) if fate != packetAcked { s.needSend = true } return } } func (s connIDState) ackOrLossRetireConnectionID(pnum packetNumber, seq int64, fate packetFate) { for i := 0; i < len(s.remote); i++ { if s.remote[i].seq != seq { continue } if fate == packetAcked { // We have retired this connection ID, and the peer has acked. // Discard its state completely. s.remote = append(s.remote[:i], s.remote[i+1:]...) } else { // RETIRE_CONNECTION_ID frame was lost, mark for retransmission. s.needSend = true s.remote[i].send.ackOrLoss(pnum, fate) } return } } // appendFrames appends NEW_CONNECTION_ID and RETIRE_CONNECTION_ID frames // to the current packet. // // It returns true if no more frames need appending, // false if not everything fit in the current packet. func (s connIDState) appendFrames(c Conn, pnum packetNumber, pto bool) bool { if !s.needSend && !pto { // Fast path: We don't need to send anything. return true } retireBefore := int64(0) if s.local[0].seq != -1 { retireBefore = s.local[0].seq } for i := range s.local { if !s.local[i].send.shouldSendPTO(pto) { continue } if !c.w.appendNewConnectionIDFrame( s.local[i].seq, retireBefore, s.local[i].cid, c.endpoint.resetGen.tokenForConnID(s.local[i].cid), ) { return false } s.local[i].send.setSent(pnum) } for i := range s.remote { if !s.remote[i].send.shouldSendPTO(pto) { continue } if !c.w.appendRetireConnectionIDFrame(s.remote[i].seq) { return false } s.remote[i].send.setSent(pnum) } s.needSend = false return true } func cloneBytes(b []byte) []byte { n := make([]byte, len(b)) copy(n, b) return n } func (c *Conn) newConnID(seq int64) ([]byte, error) { if c.testHooks != nil { return c.testHooks.newConnID(seq) } return newRandomConnID(seq) } func newRandomConnID(_ int64) ([]byte, error) { // It is not necessary for connection IDs to be cryptographically secure, // but it doesn't hurt. id := make([]byte, connIDLen) if _, err := rand.Read(id); err != nil { // TODO: Surface this error as a metric or log event or something. // rand.Read really shouldn't ever fail, but if it does, we should // have a way to inform the user. return nil, err } return id, nil }	14.51 KB	2025-05-25 12:27
📄 conn_id_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "bytes" "crypto/tls" "fmt" "net/netip" "strings" "testing" ) func TestConnIDClientHandshake(t testing.T) { tc := newTestConn(t, clientSide) // On initialization, the client chooses local and remote IDs. // // The order in which we allocate the two isn't actually important, // but test is a lot simpler if we assume. if got, want := tc.conn.connIDState.srcConnID(), testLocalConnID(0); !bytes.Equal(got, want) { t.Errorf("after initialization: srcConnID = %x, want %x", got, want) } dstConnID, _ := tc.conn.connIDState.dstConnID() if got, want := dstConnID, testLocalConnID(-1); !bytes.Equal(got, want) { t.Errorf("after initialization: dstConnID = %x, want %x", got, want) } // The server's first Initial packet provides the client with a // non-transient remote connection ID. tc.writeFrames(packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelInitial], }) dstConnID, _ = tc.conn.connIDState.dstConnID() if got, want := dstConnID, testPeerConnID(0); !bytes.Equal(got, want) { t.Errorf("after receiving Initial: dstConnID = %x, want %x", got, want) } wantLocal := []connID{{ cid: testLocalConnID(0), seq: 0, }} if got := tc.conn.connIDState.local; !connIDListEqual(got, wantLocal) { t.Errorf("local ids: %v, want %v", fmtConnIDList(got), fmtConnIDList(wantLocal)) } wantRemote := []remoteConnID{{ connID: connID{ cid: testPeerConnID(0), seq: 0, }, }} if got := tc.conn.connIDState.remote; !remoteConnIDListEqual(got, wantRemote) { t.Errorf("remote ids: %v, want %v", fmtRemoteConnIDList(got), fmtRemoteConnIDList(wantRemote)) } } func TestConnIDServerHandshake(t testing.T) { tc := newTestConn(t, serverSide) // On initialization, the server is provided with the client-chosen // transient connection ID, and allocates an ID of its own. // The Initial packet sets the remote connection ID. tc.writeFrames(packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelInitial][:1], }) if got, want := tc.conn.connIDState.srcConnID(), testLocalConnID(0); !bytes.Equal(got, want) { t.Errorf("after initClient: srcConnID = %q, want %q", got, want) } dstConnID, _ := tc.conn.connIDState.dstConnID() if got, want := dstConnID, testPeerConnID(0); !bytes.Equal(got, want) { t.Errorf("after initClient: dstConnID = %q, want %q", got, want) } // The Initial flight of CRYPTO data includes transport parameters, // which cause us to allocate another local connection ID. tc.writeFrames(packetTypeInitial, debugFrameCrypto{ off: 1, data: tc.cryptoDataIn[tls.QUICEncryptionLevelInitial][1:], }) wantLocal := []connID{{ cid: testPeerConnID(-1), seq: -1, }, { cid: testLocalConnID(0), seq: 0, }, { cid: testLocalConnID(1), seq: 1, }} if got := tc.conn.connIDState.local; !connIDListEqual(got, wantLocal) { t.Errorf("local ids: %v, want %v", fmtConnIDList(got), fmtConnIDList(wantLocal)) } wantRemote := []remoteConnID{{ connID: connID{ cid: testPeerConnID(0), seq: 0, }, }} if got := tc.conn.connIDState.remote; !remoteConnIDListEqual(got, wantRemote) { t.Errorf("remote ids: %v, want %v", fmtRemoteConnIDList(got), fmtRemoteConnIDList(wantRemote)) } // The client's first Handshake packet permits the server to discard the // transient connection ID. tc.writeFrames(packetTypeHandshake, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelHandshake], }) wantLocal = []connID{{ cid: testLocalConnID(0), seq: 0, }, { cid: testLocalConnID(1), seq: 1, }} if got := tc.conn.connIDState.local; !connIDListEqual(got, wantLocal) { t.Errorf("local ids: %v, want %v", fmtConnIDList(got), fmtConnIDList(wantLocal)) } } func connIDListEqual(a, b []connID) bool { if len(a) != len(b) { return false } for i := range a { if a[i].seq != b[i].seq { return false } if !bytes.Equal(a[i].cid, b[i].cid) { return false } } return true } func remoteConnIDListEqual(a, b []remoteConnID) bool { if len(a) != len(b) { return false } for i := range a { if a[i].seq != b[i].seq { return false } if !bytes.Equal(a[i].cid, b[i].cid) { return false } if a[i].resetToken != b[i].resetToken { return false } } return true } func fmtConnIDList(s []connID) string { var strs []string for _, cid := range s { strs = append(strs, fmt.Sprintf("[seq:%v cid:{%x}]", cid.seq, cid.cid)) } return "{" + strings.Join(strs, " ") + "}" } func fmtRemoteConnIDList(s []remoteConnID) string { var strs []string for _, cid := range s { strs = append(strs, fmt.Sprintf("[seq:%v cid:{%x} token:{%x}]", cid.seq, cid.cid, cid.resetToken)) } return "{" + strings.Join(strs, " ") + "}" } func TestNewRandomConnID(t testing.T) { cid, err := newRandomConnID(0) if len(cid) != connIDLen \|\| err != nil { t.Fatalf("newConnID() = %x, %v; want %v bytes", cid, connIDLen, err) } } func TestConnIDPeerRequestsManyIDs(t testing.T) { // "An endpoint SHOULD ensure that its peer has a sufficient number // of available and unused connection IDs." // https://www.rfc-editor.org/rfc/rfc9000#section-5.1.1-4 // // "An endpoint MAY limit the total number of connection IDs // issued for each connection [...]" // https://www.rfc-editor.org/rfc/rfc9000#section-5.1.1-6 // // Peer requests 100 connection IDs. // We give them 4 in total. tc := newTestConn(t, serverSide, func(p transportParameters) { p.activeConnIDLimit = 100 }) tc.ignoreFrame(frameTypeAck) tc.ignoreFrame(frameTypeCrypto) tc.writeFrames(packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelInitial], }) tc.wantFrame("provide additional connection ID 1", packetType1RTT, debugFrameNewConnectionID{ seq: 1, connID: testLocalConnID(1), token: testLocalStatelessResetToken(1), }) tc.wantFrame("provide additional connection ID 2", packetType1RTT, debugFrameNewConnectionID{ seq: 2, connID: testLocalConnID(2), token: testLocalStatelessResetToken(2), }) tc.wantFrame("provide additional connection ID 3", packetType1RTT, debugFrameNewConnectionID{ seq: 3, connID: testLocalConnID(3), token: testLocalStatelessResetToken(3), }) tc.wantIdle("connection ID limit reached, no more to provide") } func TestConnIDPeerProvidesTooManyIDs(t testing.T) { // "An endpoint MUST NOT provide more connection IDs than the peer's limit." // https://www.rfc-editor.org/rfc/rfc9000#section-5.1.1-4 tc := newTestConn(t, serverSide) tc.handshake() tc.ignoreFrame(frameTypeAck) tc.writeFrames(packetType1RTT, debugFrameNewConnectionID{ seq: 2, connID: testLocalConnID(2), }) tc.wantFrame("peer provided 3 connection IDs, our limit is 2", packetType1RTT, debugFrameConnectionCloseTransport{ code: errConnectionIDLimit, }) } func TestConnIDPeerTemporarilyExceedsActiveConnIDLimit(t testing.T) { // "An endpoint MAY send connection IDs that temporarily exceed a peer's limit // if the NEW_CONNECTION_ID frame also requires the retirement of any excess [...]" // https://www.rfc-editor.org/rfc/rfc9000#section-5.1.1-4 tc := newTestConn(t, serverSide) tc.handshake() tc.ignoreFrame(frameTypeAck) tc.writeFrames(packetType1RTT, debugFrameNewConnectionID{ retirePriorTo: 2, seq: 2, connID: testPeerConnID(2), }, debugFrameNewConnectionID{ retirePriorTo: 2, seq: 3, connID: testPeerConnID(3), }) tc.wantFrame("peer requested we retire conn id 0", packetType1RTT, debugFrameRetireConnectionID{ seq: 0, }) tc.wantFrame("peer requested we retire conn id 1", packetType1RTT, debugFrameRetireConnectionID{ seq: 1, }) } func TestConnIDPeerRetiresConnID(t testing.T) { // "An endpoint SHOULD supply a new connection ID when the peer retires a connection ID." // https://www.rfc-editor.org/rfc/rfc9000#section-5.1.1-6 for _, side := range []connSide{ clientSide, serverSide, } { t.Run(side.String(), func(t testing.T) { tc := newTestConn(t, side) tc.handshake() tc.ignoreFrame(frameTypeAck) tc.writeFrames(packetType1RTT, debugFrameRetireConnectionID{ seq: 0, }) tc.wantFrame("provide replacement connection ID", packetType1RTT, debugFrameNewConnectionID{ seq: 2, retirePriorTo: 1, connID: testLocalConnID(2), token: testLocalStatelessResetToken(2), }) }) } } func TestConnIDPeerWithZeroLengthConnIDSendsNewConnectionID(t testing.T) { // "An endpoint that selects a zero-length connection ID during the handshake // cannot issue a new connection ID." // https://www.rfc-editor.org/rfc/rfc9000#section-5.1.1-8 tc := newTestConn(t, clientSide, func(p transportParameters) { p.initialSrcConnID = []byte{} }) tc.peerConnID = []byte{} tc.ignoreFrame(frameTypeAck) tc.uncheckedHandshake() tc.writeFrames(packetType1RTT, debugFrameNewConnectionID{ seq: 1, connID: testPeerConnID(1), }) tc.wantFrame("invalid NEW_CONNECTION_ID: previous conn id is zero-length", packetType1RTT, debugFrameConnectionCloseTransport{ code: errProtocolViolation, }) } func TestConnIDPeerRequestsRetirement(t testing.T) { // "Upon receipt of an increased Retire Prior To field, the peer MUST // stop using the corresponding connection IDs and retire them with // RETIRE_CONNECTION_ID frames [...]" // https://www.rfc-editor.org/rfc/rfc9000#section-5.1.2-5 tc := newTestConn(t, clientSide) tc.handshake() tc.ignoreFrame(frameTypeAck) tc.writeFrames(packetType1RTT, debugFrameNewConnectionID{ seq: 2, retirePriorTo: 1, connID: testPeerConnID(2), }) tc.wantFrame("peer asked for conn id 0 to be retired", packetType1RTT, debugFrameRetireConnectionID{ seq: 0, }) if got, want := tc.lastPacket.dstConnID, testPeerConnID(1); !bytes.Equal(got, want) { t.Fatalf("used destination conn id {%x}, want {%x}", got, want) } } func TestConnIDPeerDoesNotAcknowledgeRetirement(t testing.T) { // "An endpoint SHOULD limit the number of connection IDs it has retired locally // for which RETIRE_CONNECTION_ID frames have not yet been acknowledged." // https://www.rfc-editor.org/rfc/rfc9000#section-5.1.2-6 tc := newTestConn(t, clientSide) tc.handshake() tc.ignoreFrame(frameTypeAck) tc.ignoreFrame(frameTypeRetireConnectionID) // Send a number of NEW_CONNECTION_ID frames, each retiring an old one. for seq := int64(0); seq < 7; seq++ { tc.writeFrames(packetType1RTT, debugFrameNewConnectionID{ seq: seq + 2, retirePriorTo: seq + 1, connID: testPeerConnID(seq + 2), }) // We're ignoring the RETIRE_CONNECTION_ID frames. } tc.wantFrame("number of retired, unacked conn ids is too large", packetType1RTT, debugFrameConnectionCloseTransport{ code: errConnectionIDLimit, }) } func TestConnIDRepeatedNewConnectionIDFrame(t testing.T) { // "Receipt of the same [NEW_CONNECTION_ID] frame multiple times // MUST NOT be treated as a connection error. // https://www.rfc-editor.org/rfc/rfc9000#section-19.15-7 tc := newTestConn(t, clientSide) tc.handshake() tc.ignoreFrame(frameTypeAck) for i := 0; i < 4; i++ { tc.writeFrames(packetType1RTT, debugFrameNewConnectionID{ seq: 2, retirePriorTo: 1, connID: testPeerConnID(2), }) } tc.wantFrame("peer asked for conn id to be retired", packetType1RTT, debugFrameRetireConnectionID{ seq: 0, }) tc.wantIdle("repeated NEW_CONNECTION_ID frames are not an error") } func TestConnIDForSequenceNumberChanges(t testing.T) { // "[...] if a sequence number is used for different connection IDs, // the endpoint MAY treat that receipt as a connection error // of type PROTOCOL_VIOLATION." // https://www.rfc-editor.org/rfc/rfc9000#section-19.15-8 tc := newTestConn(t, clientSide) tc.handshake() tc.ignoreFrame(frameTypeAck) tc.ignoreFrame(frameTypeRetireConnectionID) tc.writeFrames(packetType1RTT, debugFrameNewConnectionID{ seq: 2, retirePriorTo: 1, connID: testPeerConnID(2), }) tc.writeFrames(packetType1RTT, debugFrameNewConnectionID{ seq: 2, retirePriorTo: 1, connID: testPeerConnID(3), }) tc.wantFrame("connection ID for sequence 0 has changed", packetType1RTT, debugFrameConnectionCloseTransport{ code: errProtocolViolation, }) } func TestConnIDRetirePriorToAfterNewConnID(t testing.T) { // "Receiving a value in the Retire Prior To field that is greater than // that in the Sequence Number field MUST be treated as a connection error // of type FRAME_ENCODING_ERROR. // https://www.rfc-editor.org/rfc/rfc9000#section-19.15-9 tc := newTestConn(t, serverSide) tc.handshake() tc.ignoreFrame(frameTypeAck) tc.writeFrames(packetType1RTT, debugFrameNewConnectionID{ retirePriorTo: 3, seq: 2, connID: testPeerConnID(2), }) tc.wantFrame("invalid NEW_CONNECTION_ID: retired the new conn id", packetType1RTT, debugFrameConnectionCloseTransport{ code: errFrameEncoding, }) } func TestConnIDAlreadyRetired(t testing.T) { // "An endpoint that receives a NEW_CONNECTION_ID frame with a // sequence number smaller than the Retire Prior To field of a // previously received NEW_CONNECTION_ID frame MUST send a // corresponding RETIRE_CONNECTION_ID frame [...]" // https://www.rfc-editor.org/rfc/rfc9000#section-19.15-11 tc := newTestConn(t, clientSide) tc.handshake() tc.ignoreFrame(frameTypeAck) tc.writeFrames(packetType1RTT, debugFrameNewConnectionID{ seq: 4, retirePriorTo: 3, connID: testPeerConnID(4), }) tc.wantFrame("peer asked for conn id to be retired", packetType1RTT, debugFrameRetireConnectionID{ seq: 0, }) tc.wantFrame("peer asked for conn id to be retired", packetType1RTT, debugFrameRetireConnectionID{ seq: 1, }) tc.writeFrames(packetType1RTT, debugFrameNewConnectionID{ seq: 2, retirePriorTo: 0, connID: testPeerConnID(2), }) tc.wantFrame("NEW_CONNECTION_ID was for an already-retired ID", packetType1RTT, debugFrameRetireConnectionID{ seq: 2, }) } func TestConnIDRepeatedRetireConnectionIDFrame(t testing.T) { tc := newTestConn(t, clientSide) tc.handshake() tc.ignoreFrame(frameTypeAck) for i := 0; i < 4; i++ { tc.writeFrames(packetType1RTT, debugFrameRetireConnectionID{ seq: 0, }) } tc.wantFrame("issue new conn id after peer retires one", packetType1RTT, debugFrameNewConnectionID{ retirePriorTo: 1, seq: 2, connID: testLocalConnID(2), token: testLocalStatelessResetToken(2), }) tc.wantIdle("repeated RETIRE_CONNECTION_ID frames are not an error") } func TestConnIDRetiredUnsent(t testing.T) { // "Receipt of a RETIRE_CONNECTION_ID frame containing a sequence number // greater than any previously sent to the peer MUST be treated as a // connection error of type PROTOCOL_VIOLATION." // https://www.rfc-editor.org/rfc/rfc9000#section-19.16-7 tc := newTestConn(t, clientSide) tc.handshake() tc.ignoreFrame(frameTypeAck) tc.writeFrames(packetType1RTT, debugFrameRetireConnectionID{ seq: 2, }) tc.wantFrame("invalid NEW_CONNECTION_ID: previous conn id is zero-length", packetType1RTT, debugFrameConnectionCloseTransport{ code: errProtocolViolation, }) } func TestConnIDUsePreferredAddressConnID(t testing.T) { // Peer gives us a connection ID in the preferred address transport parameter. // We don't use the preferred address at this time, but we should use the // connection ID. (It isn't tied to any specific address.) // // This test will probably need updating if/when we start using the preferred address. cid := testPeerConnID(10) tc := newTestConn(t, serverSide, func(p transportParameters) { p.preferredAddrV4 = netip.MustParseAddrPort("0.0.0.0:0") p.preferredAddrV6 = netip.MustParseAddrPort("[::0]:0") p.preferredAddrConnID = cid p.preferredAddrResetToken = make([]byte, 16) }) tc.uncheckedHandshake() tc.ignoreFrame(frameTypeAck) tc.writeFrames(packetType1RTT, debugFrameNewConnectionID{ seq: 2, retirePriorTo: 1, connID: []byte{0xff}, }) tc.wantFrame("peer asked for conn id 0 to be retired", packetType1RTT, debugFrameRetireConnectionID{ seq: 0, }) if got, want := tc.lastPacket.dstConnID, cid; !bytes.Equal(got, want) { t.Fatalf("used destination conn id {%x}, want {%x} from preferred address transport parameter", got, want) } } func TestConnIDPeerProvidesPreferredAddrAndTooManyConnIDs(t testing.T) { // Peer gives us more conn ids than our advertised limit, // including a conn id in the preferred address transport parameter. cid := testPeerConnID(10) tc := newTestConn(t, serverSide, func(p transportParameters) { p.preferredAddrV4 = netip.MustParseAddrPort("0.0.0.0:0") p.preferredAddrV6 = netip.MustParseAddrPort("[::0]:0") p.preferredAddrConnID = cid p.preferredAddrResetToken = make([]byte, 16) }) tc.uncheckedHandshake() tc.ignoreFrame(frameTypeAck) tc.writeFrames(packetType1RTT, debugFrameNewConnectionID{ seq: 2, retirePriorTo: 0, connID: testPeerConnID(2), }) tc.wantFrame("peer provided 3 connection IDs, our limit is 2", packetType1RTT, debugFrameConnectionCloseTransport{ code: errConnectionIDLimit, }) } func TestConnIDPeerWithZeroLengthIDProvidesPreferredAddr(t testing.T) { // Peer gives us more conn ids than our advertised limit, // including a conn id in the preferred address transport parameter. tc := newTestConn(t, serverSide, func(p transportParameters) { p.initialSrcConnID = []byte{} p.preferredAddrV4 = netip.MustParseAddrPort("0.0.0.0:0") p.preferredAddrV6 = netip.MustParseAddrPort("[::0]:0") p.preferredAddrConnID = testPeerConnID(1) p.preferredAddrResetToken = make([]byte, 16) }, func(cids newServerConnIDs) { cids.srcConnID = []byte{} }, func(tc testConn) { tc.peerConnID = []byte{} }) tc.writeFrames(packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelInitial], }) tc.wantFrame("peer with zero-length connection ID tried to provide another in transport parameters", packetTypeInitial, debugFrameConnectionCloseTransport{ code: errProtocolViolation, }) } func TestConnIDInitialSrcConnIDMismatch(t testing.T) { // "Endpoints MUST validate that received [initial_source_connection_id] // parameters match received connection ID values." // https://www.rfc-editor.org/rfc/rfc9000#section-7.3-3 testSides(t, "", func(t testing.T, side connSide) { tc := newTestConn(t, side, func(p transportParameters) { p.initialSrcConnID = []byte("invalid") }) tc.ignoreFrame(frameTypeAck) tc.ignoreFrame(frameTypeCrypto) tc.writeFrames(packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelInitial], }) if side == clientSide { // Server transport parameters are carried in the Handshake packet. tc.writeFrames(packetTypeHandshake, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelHandshake], }) } tc.wantFrame("initial_source_connection_id transport parameter mismatch", packetTypeInitial, debugFrameConnectionCloseTransport{ code: errTransportParameter, }) }) } func TestConnIDsCleanedUpAfterClose(t testing.T) { testSides(t, "", func(t testing.T, side connSide) { tc := newTestConn(t, side, func(p *transportParameters) { if side == clientSide { token := testPeerStatelessResetToken(0) p.statelessResetToken = token[:] } }) tc.handshake() tc.ignoreFrame(frameTypeAck) tc.writeFrames(packetType1RTT, debugFrameNewConnectionID{ seq: 2, retirePriorTo: 1, connID: testPeerConnID(2), token: testPeerStatelessResetToken(0), }) tc.wantFrame("peer asked for conn id 0 to be retired", packetType1RTT, debugFrameRetireConnectionID{ seq: 0, }) tc.writeFrames(packetType1RTT, debugFrameConnectionCloseTransport{}) tc.conn.Abort(nil) tc.wantFrame("CONN_CLOSE sent after user closes connection", packetType1RTT, debugFrameConnectionCloseTransport{}) // Wait for the conn to drain. // Then wait for the conn loop to exit, // and force an immediate sync of the connsMap updates // (normally only done by the endpoint read loop). tc.advanceToTimer() <-tc.conn.donec tc.endpoint.e.connsMap.applyUpdates() if got := len(tc.endpoint.e.connsMap.byConnID); got != 0 { t.Errorf("%v conn ids in endpoint map after closing, want 0", got) } if got := len(tc.endpoint.e.connsMap.byResetToken); got != 0 { t.Errorf("%v reset tokens in endpoint map after closing, want 0", got) } }) }	20.41 KB	2025-05-25 12:27
📄 conn_loss.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import "fmt" // handleAckOrLoss deals with the final fate of a packet we sent: // Either the peer acknowledges it, or we declare it lost. // // In order to handle packet loss, we must retain any information sent to the peer // until the peer has acknowledged it. // // When information is acknowledged, we can discard it. // // When information is lost, we mark it for retransmission. // See RFC 9000, Section 13.3 for a complete list of information which is retransmitted on loss. // https://www.rfc-editor.org/rfc/rfc9000#section-13.3 func (c Conn) handleAckOrLoss(space numberSpace, sent sentPacket, fate packetFate) { if fate == packetLost && c.logEnabled(QLogLevelPacket) { c.logPacketLost(space, sent) } // The list of frames in a sent packet is marshaled into a buffer in the sentPacket // by the packetWriter. Unmarshal that buffer here. This code must be kept in sync with // packetWriter.append*. // // A sent packet meets its fate (acked or lost) only once, so it's okay to consume // the sentPacket's buffer here. for !sent.done() { switch f := sent.next(); f { default: panic(fmt.Sprintf("BUG: unhandled acked/lost frame type %x", f)) case frameTypeAck: // Unlike most information, loss of an ACK frame does not trigger // retransmission. ACKs are sent in response to ack-eliciting packets, // and always contain the latest information available. // // Acknowledgement of an ACK frame may allow us to discard information // about older packets. largest := packetNumber(sent.nextInt()) if fate == packetAcked { c.acks[space].handleAck(largest) } case frameTypeCrypto: start, end := sent.nextRange() c.crypto[space].ackOrLoss(start, end, fate) case frameTypeMaxData: c.ackOrLossMaxData(sent.num, fate) case frameTypeResetStream, frameTypeStopSending, frameTypeMaxStreamData, frameTypeStreamDataBlocked: id := streamID(sent.nextInt()) s := c.streamForID(id) if s == nil { continue } s.ackOrLoss(sent.num, f, fate) case frameTypeStreamBase, frameTypeStreamBase \| streamFinBit: id := streamID(sent.nextInt()) start, end := sent.nextRange() s := c.streamForID(id) if s == nil { continue } fin := f&streamFinBit != 0 s.ackOrLossData(sent.num, start, end, fin, fate) case frameTypeMaxStreamsBidi: c.streams.remoteLimit[bidiStream].sendMax.ackLatestOrLoss(sent.num, fate) case frameTypeMaxStreamsUni: c.streams.remoteLimit[uniStream].sendMax.ackLatestOrLoss(sent.num, fate) case frameTypeNewConnectionID: seq := int64(sent.nextInt()) c.connIDState.ackOrLossNewConnectionID(sent.num, seq, fate) case frameTypeRetireConnectionID: seq := int64(sent.nextInt()) c.connIDState.ackOrLossRetireConnectionID(sent.num, seq, fate) case frameTypeHandshakeDone: c.handshakeConfirmed.ackOrLoss(sent.num, fate) } } }	2.99 KB	2025-05-25 12:27
📄 conn_loss_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "context" "crypto/tls" "fmt" "testing" ) // Frames may be retransmitted either when the packet containing the frame is lost, or on PTO. // lostFrameTest runs a test in both configurations. func lostFrameTest(t testing.T, f func(t testing.T, pto bool)) { t.Run("lost", func(t testing.T) { f(t, false) }) t.Run("pto", func(t testing.T) { f(t, true) }) } // triggerLossOrPTO causes the conn to declare the last sent packet lost, // or advances to the PTO timer. func (tc testConn) triggerLossOrPTO(ptype packetType, pto bool) { tc.t.Helper() if pto { if !tc.conn.loss.ptoTimerArmed { tc.t.Fatalf("PTO timer not armed, expected it to be") } if testVV { tc.t.Logf("advancing to PTO timer") } tc.advanceTo(tc.conn.loss.timer) return } if testVV { testVV = false defer func() { tc.t.Logf("cause conn to declare last packet lost") testVV = true }() } defer func(ignoreFrames map[byte]bool) { tc.ignoreFrames = ignoreFrames }(tc.ignoreFrames) tc.ignoreFrames = map[byte]bool{ frameTypeAck: true, frameTypePadding: true, } // Send three packets containing PINGs, and then respond with an ACK for the // last one. This puts the last packet before the PINGs outside the packet // reordering threshold, and it will be declared lost. const lossThreshold = 3 var num packetNumber for i := 0; i < lossThreshold; i++ { tc.conn.ping(spaceForPacketType(ptype)) d := tc.readDatagram() if d == nil { tc.t.Fatalf("conn is idle; want PING frame") } if d.packets[0].ptype != ptype { tc.t.Fatalf("conn sent %v packet; want %v", d.packets[0].ptype, ptype) } num = d.packets[0].num } tc.writeFrames(ptype, debugFrameAck{ ranges: []i64range[packetNumber]{ {num, num + 1}, }, }) } func TestLostResetStreamFrame(t testing.T) { // "Cancellation of stream transmission, as carried in a RESET_STREAM frame, // is sent until acknowledged or until all stream data is acknowledged by the peer [...]" // https://www.rfc-editor.org/rfc/rfc9000.html#section-13.3-3.4 lostFrameTest(t, func(t testing.T, pto bool) { tc, s := newTestConnAndLocalStream(t, serverSide, uniStream, permissiveTransportParameters) tc.ignoreFrame(frameTypeAck) s.Reset(1) tc.wantFrame("reset stream", packetType1RTT, debugFrameResetStream{ id: s.id, code: 1, }) tc.triggerLossOrPTO(packetType1RTT, pto) tc.wantFrame("resent RESET_STREAM frame", packetType1RTT, debugFrameResetStream{ id: s.id, code: 1, }) }) } func TestLostStopSendingFrame(t testing.T) { // "[...] a request to cancel stream transmission, as encoded in a STOP_SENDING frame, // is sent until the receiving part of the stream enters either a "Data Recvd" or // "Reset Recvd" state [...]" // https://www.rfc-editor.org/rfc/rfc9000.html#section-13.3-3.5 // // Technically, we can stop sending a STOP_SENDING frame if the peer sends // us all the data for the stream or resets it. We don't bother tracking this, // however, so we'll keep sending the frame until it is acked. This is harmless. lostFrameTest(t, func(t testing.T, pto bool) { tc, s := newTestConnAndRemoteStream(t, serverSide, uniStream, permissiveTransportParameters) tc.ignoreFrame(frameTypeAck) s.CloseRead() tc.wantFrame("stream is read-closed", packetType1RTT, debugFrameStopSending{ id: s.id, }) tc.triggerLossOrPTO(packetType1RTT, pto) tc.wantFrame("resent STOP_SENDING frame", packetType1RTT, debugFrameStopSending{ id: s.id, }) }) } func TestLostCryptoFrame(t testing.T) { // "Data sent in CRYPTO frames is retransmitted [...] until all data has been acknowledged." // https://www.rfc-editor.org/rfc/rfc9000.html#section-13.3-3.1 lostFrameTest(t, func(t testing.T, pto bool) { tc := newTestConn(t, clientSide) tc.ignoreFrame(frameTypeAck) tc.wantFrame("client sends Initial CRYPTO frame", packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataOut[tls.QUICEncryptionLevelInitial], }) tc.triggerLossOrPTO(packetTypeInitial, pto) tc.wantFrame("client resends Initial CRYPTO frame", packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataOut[tls.QUICEncryptionLevelInitial], }) tc.writeFrames(packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelInitial], }) tc.writeFrames(packetTypeHandshake, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelHandshake], }) tc.wantFrame("client sends Handshake CRYPTO frame", packetTypeHandshake, debugFrameCrypto{ data: tc.cryptoDataOut[tls.QUICEncryptionLevelHandshake], }) tc.wantFrame("client provides server with an additional connection ID", packetType1RTT, debugFrameNewConnectionID{ seq: 1, connID: testLocalConnID(1), token: testLocalStatelessResetToken(1), }) tc.triggerLossOrPTO(packetTypeHandshake, pto) tc.wantFrame("client resends Handshake CRYPTO frame", packetTypeHandshake, debugFrameCrypto{ data: tc.cryptoDataOut[tls.QUICEncryptionLevelHandshake], }) }) } func TestLostStreamFrameEmpty(t testing.T) { // A STREAM frame opening a stream, but containing no stream data, should // be retransmitted if lost. lostFrameTest(t, func(t testing.T, pto bool) { ctx := canceledContext() tc := newTestConn(t, clientSide, permissiveTransportParameters) tc.handshake() tc.ignoreFrame(frameTypeAck) c, err := tc.conn.NewStream(ctx) if err != nil { t.Fatalf("NewStream: %v", err) } c.Flush() // open the stream tc.wantFrame("created bidirectional stream 0", packetType1RTT, debugFrameStream{ id: newStreamID(clientSide, bidiStream, 0), data: []byte{}, }) tc.triggerLossOrPTO(packetType1RTT, pto) tc.wantFrame("resent stream frame", packetType1RTT, debugFrameStream{ id: newStreamID(clientSide, bidiStream, 0), data: []byte{}, }) }) } func TestLostStreamWithData(t testing.T) { // "Application data sent in STREAM frames is retransmitted in new STREAM // frames unless the endpoint has sent a RESET_STREAM for that stream." // https://www.rfc-editor.org/rfc/rfc9000#section-13.3-3.2 // // TODO: Lost stream frame after RESET_STREAM lostFrameTest(t, func(t testing.T, pto bool) { data := []byte{0, 1, 2, 3, 4, 5, 6, 7} tc, s := newTestConnAndLocalStream(t, serverSide, uniStream, func(p transportParameters) { p.initialMaxStreamsUni = 1 p.initialMaxData = 1 << 20 p.initialMaxStreamDataUni = 1 << 20 }) s.Write(data[:4]) s.Flush() tc.wantFrame("send [0,4)", packetType1RTT, debugFrameStream{ id: s.id, off: 0, data: data[:4], }) s.Write(data[4:8]) s.Flush() tc.wantFrame("send [4,8)", packetType1RTT, debugFrameStream{ id: s.id, off: 4, data: data[4:8], }) s.CloseWrite() tc.wantFrame("send FIN", packetType1RTT, debugFrameStream{ id: s.id, off: 8, fin: true, data: []byte{}, }) tc.triggerLossOrPTO(packetType1RTT, pto) tc.wantFrame("resend data", packetType1RTT, debugFrameStream{ id: s.id, off: 0, fin: true, data: data[:8], }) }) } func TestLostStreamPartialLoss(t testing.T) { // Conn sends four STREAM packets. // ACKs are received for the packets containing bytes 0 and 2. // The remaining packets are declared lost. // The Conn resends only the lost data. // // This test doesn't have a PTO mode, because the ACK for the packet containing byte 2 // starts the loss timer for the packet containing byte 1, and the PTO timer is not // armed when the loss timer is. data := []byte{0, 1, 2, 3} tc, s := newTestConnAndLocalStream(t, serverSide, uniStream, func(p transportParameters) { p.initialMaxStreamsUni = 1 p.initialMaxData = 1 << 20 p.initialMaxStreamDataUni = 1 << 20 }) for i := range data { s.Write(data[i : i+1]) s.Flush() tc.wantFrame(fmt.Sprintf("send STREAM frame with byte %v", i), packetType1RTT, debugFrameStream{ id: s.id, off: int64(i), data: data[i : i+1], }) if i%2 == 0 { tc.writeAckForLatest() } } const pto = false tc.triggerLossOrPTO(packetType1RTT, pto) tc.wantFrame("resend byte 1", packetType1RTT, debugFrameStream{ id: s.id, off: 1, data: data[1:2], }) tc.wantFrame("resend byte 3", packetType1RTT, debugFrameStream{ id: s.id, off: 3, data: data[3:4], }) tc.wantIdle("no more frames sent after packet loss") } func TestLostMaxDataFrame(t testing.T) { // "An updated value is sent in a MAX_DATA frame if the packet // containing the most recently sent MAX_DATA frame is declared lost [...]" // https://www.rfc-editor.org/rfc/rfc9000#section-13.3-3.7 lostFrameTest(t, func(t testing.T, pto bool) { const maxWindowSize = 32 buf := make([]byte, maxWindowSize) tc, s := newTestConnAndRemoteStream(t, serverSide, uniStream, func(c Config) { c.MaxConnReadBufferSize = 32 }) // We send MAX_DATA = 63. tc.writeFrames(packetType1RTT, debugFrameStream{ id: s.id, off: 0, data: make([]byte, maxWindowSize-1), }) if n, err := s.Read(buf[:maxWindowSize]); err != nil \|\| n != maxWindowSize-1 { t.Fatalf("Read() = %v, %v; want %v, nil", n, err, maxWindowSize-1) } tc.wantFrame("conn window is extended after reading data", packetType1RTT, debugFrameMaxData{ max: (maxWindowSize 2) - 1, }) // MAX_DATA = 64, which is only one more byte, so we don't send the frame. tc.writeFrames(packetType1RTT, debugFrameStream{ id: s.id, off: maxWindowSize - 1, data: make([]byte, 1), }) if n, err := s.Read(buf[:1]); err != nil \|\| n != 1 { t.Fatalf("Read() = %v, %v; want %v, nil", n, err, 1) } tc.wantIdle("read doesn't extend window enough to send another MAX_DATA") // The MAX_DATA = 63 packet was lost, so we send 64. tc.triggerLossOrPTO(packetType1RTT, pto) tc.wantFrame("resent MAX_DATA includes most current value", packetType1RTT, debugFrameMaxData{ max: maxWindowSize * 2, }) }) } func TestLostMaxStreamDataFrame(t testing.T) { // "[...] an updated value is sent when the packet containing // the most recent MAX_STREAM_DATA frame for a stream is lost" // https://www.rfc-editor.org/rfc/rfc9000#section-13.3-3.8 lostFrameTest(t, func(t testing.T, pto bool) { const maxWindowSize = 32 buf := make([]byte, maxWindowSize) tc, s := newTestConnAndRemoteStream(t, serverSide, uniStream, func(c Config) { c.MaxStreamReadBufferSize = maxWindowSize }) // We send MAX_STREAM_DATA = 63. tc.writeFrames(packetType1RTT, debugFrameStream{ id: s.id, off: 0, data: make([]byte, maxWindowSize-1), }) if n, err := s.Read(buf[:maxWindowSize]); err != nil \|\| n != maxWindowSize-1 { t.Fatalf("Read() = %v, %v; want %v, nil", n, err, maxWindowSize-1) } tc.wantFrame("stream window is extended after reading data", packetType1RTT, debugFrameMaxStreamData{ id: s.id, max: (maxWindowSize 2) - 1, }) // MAX_STREAM_DATA = 64, which is only one more byte, so we don't send the frame. tc.writeFrames(packetType1RTT, debugFrameStream{ id: s.id, off: maxWindowSize - 1, data: make([]byte, 1), }) if n, err := s.Read(buf); err != nil \|\| n != 1 { t.Fatalf("Read() = %v, %v; want %v, nil", n, err, 1) } tc.wantIdle("read doesn't extend window enough to send another MAX_STREAM_DATA") // The MAX_STREAM_DATA = 63 packet was lost, so we send 64. tc.triggerLossOrPTO(packetType1RTT, pto) tc.wantFrame("resent MAX_STREAM_DATA includes most current value", packetType1RTT, debugFrameMaxStreamData{ id: s.id, max: maxWindowSize * 2, }) }) } func TestLostMaxStreamDataFrameAfterStreamFinReceived(t testing.T) { // "An endpoint SHOULD stop sending MAX_STREAM_DATA frames when // the receiving part of the stream enters a "Size Known" or "Reset Recvd" state." // https://www.rfc-editor.org/rfc/rfc9000#section-13.3-3.8 lostFrameTest(t, func(t testing.T, pto bool) { const maxWindowSize = 10 buf := make([]byte, maxWindowSize) tc, s := newTestConnAndRemoteStream(t, serverSide, uniStream, func(c Config) { c.MaxStreamReadBufferSize = maxWindowSize }) tc.writeFrames(packetType1RTT, debugFrameStream{ id: s.id, off: 0, data: make([]byte, maxWindowSize), }) if n, err := s.Read(buf); err != nil \|\| n != maxWindowSize { t.Fatalf("Read() = %v, %v; want %v, nil", n, err, maxWindowSize) } tc.wantFrame("stream window is extended after reading data", packetType1RTT, debugFrameMaxStreamData{ id: s.id, max: 2 maxWindowSize, }) tc.writeFrames(packetType1RTT, debugFrameStream{ id: s.id, off: maxWindowSize, fin: true, }) tc.ignoreFrame(frameTypePing) tc.triggerLossOrPTO(packetType1RTT, pto) tc.wantIdle("lost MAX_STREAM_DATA not resent for stream in 'size known'") }) } func TestLostMaxStreamsFrameMostRecent(t testing.T) { // "[...] an updated value is sent when a packet containing the // most recent MAX_STREAMS for a stream type frame is declared lost [...]" // https://www.rfc-editor.org/rfc/rfc9000#section-13.3-3.9 testStreamTypes(t, "", func(t testing.T, styp streamType) { lostFrameTest(t, func(t testing.T, pto bool) { ctx := canceledContext() tc := newTestConn(t, serverSide, func(c Config) { c.MaxUniRemoteStreams = 1 c.MaxBidiRemoteStreams = 1 }) tc.handshake() tc.ignoreFrame(frameTypeAck) tc.writeFrames(packetType1RTT, debugFrameStream{ id: newStreamID(clientSide, styp, 0), fin: true, }) s, err := tc.conn.AcceptStream(ctx) if err != nil { t.Fatalf("AcceptStream() = %v", err) } s.SetWriteContext(ctx) s.Close() if styp == bidiStream { tc.wantFrame("stream is closed", packetType1RTT, debugFrameStream{ id: s.id, data: []byte{}, fin: true, }) tc.writeAckForAll() } tc.wantFrame("closing stream updates peer's MAX_STREAMS", packetType1RTT, debugFrameMaxStreams{ streamType: styp, max: 2, }) tc.triggerLossOrPTO(packetType1RTT, pto) tc.wantFrame("lost MAX_STREAMS is resent", packetType1RTT, debugFrameMaxStreams{ streamType: styp, max: 2, }) }) }) } func TestLostMaxStreamsFrameNotMostRecent(t testing.T) { // Send two MAX_STREAMS frames, lose the first one. // // No PTO mode for this test: The ack that causes the first frame // to be lost arms the loss timer for the second, so the PTO timer is not armed. const pto = false ctx := canceledContext() tc := newTestConn(t, serverSide, func(c Config) { c.MaxUniRemoteStreams = 2 }) tc.handshake() tc.ignoreFrame(frameTypeAck) for i := int64(0); i < 2; i++ { tc.writeFrames(packetType1RTT, debugFrameStream{ id: newStreamID(clientSide, uniStream, i), fin: true, }) s, err := tc.conn.AcceptStream(ctx) if err != nil { t.Fatalf("AcceptStream() = %v", err) } if err := s.Close(); err != nil { t.Fatalf("stream.Close() = %v", err) } tc.wantFrame("closing stream updates peer's MAX_STREAMS", packetType1RTT, debugFrameMaxStreams{ streamType: uniStream, max: 3 + i, }) } // The second MAX_STREAMS frame is acked. tc.writeAckForLatest() // The first MAX_STREAMS frame is lost. tc.conn.ping(appDataSpace) tc.wantFrame("connection should send a PING frame", packetType1RTT, debugFramePing{}) tc.triggerLossOrPTO(packetType1RTT, pto) tc.wantIdle("superseded MAX_DATA is not resent on loss") } func TestLostStreamDataBlockedFrame(t testing.T) { // "A new [STREAM_DATA_BLOCKED] frame is sent if a packet containing // the most recent frame for a scope is lost [...]" // https://www.rfc-editor.org/rfc/rfc9000#section-13.3-3.10 lostFrameTest(t, func(t testing.T, pto bool) { tc, s := newTestConnAndLocalStream(t, serverSide, uniStream, func(p transportParameters) { p.initialMaxStreamsUni = 1 p.initialMaxData = 1 << 20 }) w := runAsync(tc, func(ctx context.Context) (int, error) { return s.Write([]byte{0, 1, 2, 3}) }) defer w.cancel() tc.wantFrame("write is blocked by flow control", packetType1RTT, debugFrameStreamDataBlocked{ id: s.id, max: 0, }) tc.writeFrames(packetType1RTT, debugFrameMaxStreamData{ id: s.id, max: 1, }) tc.wantFrame("write makes some progress, but is still blocked by flow control", packetType1RTT, debugFrameStreamDataBlocked{ id: s.id, max: 1, }) tc.wantFrame("write consuming available window", packetType1RTT, debugFrameStream{ id: s.id, off: 0, data: []byte{0}, }) tc.triggerLossOrPTO(packetType1RTT, pto) tc.wantFrame("STREAM_DATA_BLOCKED is resent", packetType1RTT, debugFrameStreamDataBlocked{ id: s.id, max: 1, }) tc.wantFrame("STREAM is resent as well", packetType1RTT, debugFrameStream{ id: s.id, off: 0, data: []byte{0}, }) }) } func TestLostStreamDataBlockedFrameAfterStreamUnblocked(t testing.T) { // "A new [STREAM_DATA_BLOCKED] frame is sent [...] only while // the endpoint is blocked on the corresponding limit." // https://www.rfc-editor.org/rfc/rfc9000#section-13.3-3.10 lostFrameTest(t, func(t testing.T, pto bool) { tc, s := newTestConnAndLocalStream(t, serverSide, uniStream, func(p transportParameters) { p.initialMaxStreamsUni = 1 p.initialMaxData = 1 << 20 }) data := []byte{0, 1, 2, 3} w := runAsync(tc, func(ctx context.Context) (int, error) { return s.Write(data) }) defer w.cancel() tc.wantFrame("write is blocked by flow control", packetType1RTT, debugFrameStreamDataBlocked{ id: s.id, max: 0, }) tc.writeFrames(packetType1RTT, debugFrameMaxStreamData{ id: s.id, max: 10, }) tc.wantFrame("write completes after flow control available", packetType1RTT, debugFrameStream{ id: s.id, off: 0, data: data, }) tc.triggerLossOrPTO(packetType1RTT, pto) tc.wantFrame("STREAM data is resent", packetType1RTT, debugFrameStream{ id: s.id, off: 0, data: data, }) tc.wantIdle("STREAM_DATA_BLOCKED is not resent, since the stream is not blocked") }) } func TestLostNewConnectionIDFrame(t testing.T) { // "New connection IDs are [...] retransmitted if the packet containing them is lost." // https://www.rfc-editor.org/rfc/rfc9000#section-13.3-3.13 lostFrameTest(t, func(t testing.T, pto bool) { tc := newTestConn(t, serverSide) tc.handshake() tc.ignoreFrame(frameTypeAck) tc.writeFrames(packetType1RTT, debugFrameRetireConnectionID{ seq: 1, }) tc.wantFrame("provide a new connection ID after peer retires old one", packetType1RTT, debugFrameNewConnectionID{ seq: 2, connID: testLocalConnID(2), token: testLocalStatelessResetToken(2), }) tc.triggerLossOrPTO(packetType1RTT, pto) tc.wantFrame("resend new connection ID", packetType1RTT, debugFrameNewConnectionID{ seq: 2, connID: testLocalConnID(2), token: testLocalStatelessResetToken(2), }) }) } func TestLostRetireConnectionIDFrame(t testing.T) { // "[...] retired connection IDs are [...] retransmitted // if the packet containing them is lost." // https://www.rfc-editor.org/rfc/rfc9000#section-13.3-3.13 lostFrameTest(t, func(t testing.T, pto bool) { tc := newTestConn(t, clientSide) tc.handshake() tc.ignoreFrame(frameTypeAck) tc.writeFrames(packetType1RTT, debugFrameNewConnectionID{ seq: 2, retirePriorTo: 1, connID: testPeerConnID(2), }) tc.wantFrame("peer requested connection id be retired", packetType1RTT, debugFrameRetireConnectionID{ seq: 0, }) tc.triggerLossOrPTO(packetType1RTT, pto) tc.wantFrame("resend RETIRE_CONNECTION_ID", packetType1RTT, debugFrameRetireConnectionID{ seq: 0, }) }) } func TestLostPathResponseFrame(t testing.T) { // "Responses to path validation using PATH_RESPONSE frames are sent just once." // https://www.rfc-editor.org/rfc/rfc9000.html#section-13.3-3.12 lostFrameTest(t, func(t testing.T, pto bool) { tc := newTestConn(t, clientSide) tc.handshake() tc.ignoreFrame(frameTypeAck) tc.ignoreFrame(frameTypePing) data := pathChallengeData{0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef} tc.writeFrames(packetType1RTT, debugFramePathChallenge{ data: data, }) tc.wantFrame("response to PATH_CHALLENGE", packetType1RTT, debugFramePathResponse{ data: data, }) tc.triggerLossOrPTO(packetType1RTT, pto) tc.wantIdle("lost PATH_RESPONSE frame is not retransmitted") }) } func TestLostHandshakeDoneFrame(t testing.T) { // "The HANDSHAKE_DONE frame MUST be retransmitted until it is acknowledged." // https://www.rfc-editor.org/rfc/rfc9000.html#section-13.3-3.16 lostFrameTest(t, func(t testing.T, pto bool) { tc := newTestConn(t, serverSide) tc.ignoreFrame(frameTypeAck) tc.writeFrames(packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelInitial], }) tc.wantFrame("server sends Initial CRYPTO frame", packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataOut[tls.QUICEncryptionLevelInitial], }) tc.wantFrame("server sends Handshake CRYPTO frame", packetTypeHandshake, debugFrameCrypto{ data: tc.cryptoDataOut[tls.QUICEncryptionLevelHandshake], }) tc.wantFrame("server provides an additional connection ID", packetType1RTT, debugFrameNewConnectionID{ seq: 1, connID: testLocalConnID(1), token: testLocalStatelessResetToken(1), }) tc.writeFrames(packetTypeHandshake, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelHandshake], }) tc.wantFrame("server sends HANDSHAKE_DONE after handshake completes", packetType1RTT, debugFrameHandshakeDone{}) tc.triggerLossOrPTO(packetType1RTT, pto) tc.wantFrame("server resends HANDSHAKE_DONE", packetType1RTT, debugFrameHandshakeDone{}) }) }	21.52 KB	2025-05-25 12:27
📄 conn_recv.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "bytes" "encoding/binary" "errors" "time" ) func (c Conn) handleDatagram(now time.Time, dgram datagram) (handled bool) { if !c.localAddr.IsValid() { // We don't have any way to tell in the general case what address we're // sending packets from. Set our address from the destination address of // the first packet received from the peer. c.localAddr = dgram.localAddr } if dgram.peerAddr.IsValid() && dgram.peerAddr != c.peerAddr { if c.side == clientSide { // "If a client receives packets from an unknown server address, // the client MUST discard these packets." // https://www.rfc-editor.org/rfc/rfc9000#section-9-6 return false } // We currently don't support connection migration, // so for now the server also drops packets from an unknown address. return false } buf := dgram.b c.loss.datagramReceived(now, len(buf)) if c.isDraining() { return false } for len(buf) > 0 { var n int ptype := getPacketType(buf) switch ptype { case packetTypeInitial: if c.side == serverSide && len(dgram.b) < paddedInitialDatagramSize { // Discard client-sent Initial packets in too-short datagrams. // https://www.rfc-editor.org/rfc/rfc9000#section-14.1-4 return false } n = c.handleLongHeader(now, dgram, ptype, initialSpace, c.keysInitial.r, buf) case packetTypeHandshake: n = c.handleLongHeader(now, dgram, ptype, handshakeSpace, c.keysHandshake.r, buf) case packetType1RTT: n = c.handle1RTT(now, dgram, buf) case packetTypeRetry: c.handleRetry(now, buf) return true case packetTypeVersionNegotiation: c.handleVersionNegotiation(now, buf) return true default: n = -1 } if n <= 0 { // We don't expect to get a stateless reset with a valid // destination connection ID, since the sender of a stateless // reset doesn't know what the connection ID is. // // We're required to perform this check anyway. // // "[...] the comparison MUST be performed when the first packet // in an incoming datagram [...] cannot be decrypted." // https://www.rfc-editor.org/rfc/rfc9000#section-10.3.1-2 if len(buf) == len(dgram.b) && len(buf) > statelessResetTokenLen { var token statelessResetToken copy(token[:], buf[len(buf)-len(token):]) if c.handleStatelessReset(now, token) { return true } } // Invalid data at the end of a datagram is ignored. return false } c.idleHandlePacketReceived(now) buf = buf[n:] } return true } func (c Conn) handleLongHeader(now time.Time, dgram datagram, ptype packetType, space numberSpace, k fixedKeys, buf []byte) int { if !k.isSet() { return skipLongHeaderPacket(buf) } pnumMax := c.acks[space].largestSeen() p, n := parseLongHeaderPacket(buf, k, pnumMax) if n < 0 { return -1 } if buf[0]&reservedLongBits != 0 { // Reserved header bits must be 0. // https://www.rfc-editor.org/rfc/rfc9000#section-17.2-8.2.1 c.abort(now, localTransportError{ code: errProtocolViolation, reason: "reserved header bits are not zero", }) return -1 } if p.version != quicVersion1 { // The peer has changed versions on us mid-handshake? c.abort(now, localTransportError{ code: errProtocolViolation, reason: "protocol version changed during handshake", }) return -1 } if !c.acks[space].shouldProcess(p.num) { return n } if logPackets { logInboundLongPacket(c, p) } if c.logEnabled(QLogLevelPacket) { c.logLongPacketReceived(p, buf[:n]) } c.connIDState.handlePacket(c, p.ptype, p.srcConnID) ackEliciting := c.handleFrames(now, dgram, ptype, space, p.payload) c.acks[space].receive(now, space, p.num, ackEliciting) if p.ptype == packetTypeHandshake && c.side == serverSide { c.loss.validateClientAddress() // "[...] a server MUST discard Initial keys when it first successfully // processes a Handshake packet [...]" // https://www.rfc-editor.org/rfc/rfc9001#section-4.9.1-2 c.discardKeys(now, initialSpace) } return n } func (c Conn) handle1RTT(now time.Time, dgram datagram, buf []byte) int { if !c.keysAppData.canRead() { // 1-RTT packets extend to the end of the datagram, // so skip the remainder of the datagram if we can't parse this. return len(buf) } pnumMax := c.acks[appDataSpace].largestSeen() p, err := parse1RTTPacket(buf, &c.keysAppData, connIDLen, pnumMax) if err != nil { // A localTransportError terminates the connection. // Other errors indicate an unparseable packet, but otherwise may be ignored. if _, ok := err.(localTransportError); ok { c.abort(now, err) } return -1 } if buf[0]&reserved1RTTBits != 0 { // Reserved header bits must be 0. // https://www.rfc-editor.org/rfc/rfc9000#section-17.3.1-4.8.1 c.abort(now, localTransportError{ code: errProtocolViolation, reason: "reserved header bits are not zero", }) return -1 } if !c.acks[appDataSpace].shouldProcess(p.num) { return len(buf) } if logPackets { logInboundShortPacket(c, p) } if c.logEnabled(QLogLevelPacket) { c.log1RTTPacketReceived(p, buf) } ackEliciting := c.handleFrames(now, dgram, packetType1RTT, appDataSpace, p.payload) c.acks[appDataSpace].receive(now, appDataSpace, p.num, ackEliciting) return len(buf) } func (c Conn) handleRetry(now time.Time, pkt []byte) { if c.side != clientSide { return // clients don't send Retry packets } // "After the client has received and processed an Initial or Retry packet // from the server, it MUST discard any subsequent Retry packets that it receives." // https://www.rfc-editor.org/rfc/rfc9000#section-17.2.5.2-1 if !c.keysInitial.canRead() { return // discarded Initial keys, connection is already established } if c.acks[initialSpace].seen.numRanges() != 0 { return // processed at least one packet } if c.retryToken != nil { return // received a Retry already } // "Clients MUST discard Retry packets that have a Retry Integrity Tag // that cannot be validated." // https://www.rfc-editor.org/rfc/rfc9000#section-17.2.5.2-2 p, ok := parseRetryPacket(pkt, c.connIDState.originalDstConnID) if !ok { return } // "A client MUST discard a Retry packet with a zero-length Retry Token field." // https://www.rfc-editor.org/rfc/rfc9000#section-17.2.5.2-2 if len(p.token) == 0 { return } c.retryToken = cloneBytes(p.token) c.connIDState.handleRetryPacket(p.srcConnID) // We need to resend any data we've already sent in Initial packets. // We must not reuse already sent packet numbers. c.loss.discardPackets(initialSpace, c.log, c.handleAckOrLoss) // TODO: Discard 0-RTT packets as well, once we support 0-RTT. } var errVersionNegotiation = errors.New("server does not support QUIC version 1") func (c Conn) handleVersionNegotiation(now time.Time, pkt []byte) { if c.side != clientSide { return // servers don't handle Version Negotiation packets } // "A client MUST discard any Version Negotiation packet if it has // received and successfully processed any other packet [...]" // https://www.rfc-editor.org/rfc/rfc9000#section-6.2-2 if !c.keysInitial.canRead() { return // discarded Initial keys, connection is already established } if c.acks[initialSpace].seen.numRanges() != 0 { return // processed at least one packet } _, srcConnID, versions := parseVersionNegotiation(pkt) if len(c.connIDState.remote) < 1 \|\| !bytes.Equal(c.connIDState.remote[0].cid, srcConnID) { return // Source Connection ID doesn't match what we sent } for len(versions) >= 4 { ver := binary.BigEndian.Uint32(versions) if ver == 1 { // "A client MUST discard a Version Negotiation packet that lists // the QUIC version selected by the client." // https://www.rfc-editor.org/rfc/rfc9000#section-6.2-2 return } versions = versions[4:] } // "A client that supports only this version of QUIC MUST // abandon the current connection attempt if it receives // a Version Negotiation packet, [with the two exceptions handled above]." // https://www.rfc-editor.org/rfc/rfc9000#section-6.2-2 c.abortImmediately(now, errVersionNegotiation) } func (c Conn) handleFrames(now time.Time, dgram datagram, ptype packetType, space numberSpace, payload []byte) (ackEliciting bool) { if len(payload) == 0 { // "An endpoint MUST treat receipt of a packet containing no frames // as a connection error of type PROTOCOL_VIOLATION." // https://www.rfc-editor.org/rfc/rfc9000#section-12.4-3 c.abort(now, localTransportError{ code: errProtocolViolation, reason: "packet contains no frames", }) return false } // frameOK verifies that ptype is one of the packets in mask. frameOK := func(c Conn, ptype, mask packetType) (ok bool) { if ptype&mask == 0 { // "An endpoint MUST treat receipt of a frame in a packet type // that is not permitted as a connection error of type // PROTOCOL_VIOLATION." // https://www.rfc-editor.org/rfc/rfc9000#section-12.4-3 c.abort(now, localTransportError{ code: errProtocolViolation, reason: "frame not allowed in packet", }) return false } return true } // Packet masks from RFC 9000 Table 3. // https://www.rfc-editor.org/rfc/rfc9000#table-3 const ( IH_1 = packetTypeInitial \| packetTypeHandshake \| packetType1RTT __01 = packetType0RTT \| packetType1RTT ___1 = packetType1RTT ) hasCrypto := false for len(payload) > 0 { switch payload[0] { case frameTypePadding, frameTypeAck, frameTypeAckECN, frameTypeConnectionCloseTransport, frameTypeConnectionCloseApplication: default: ackEliciting = true } n := -1 switch payload[0] { case frameTypePadding: // PADDING is OK in all spaces. n = 1 case frameTypePing: // PING is OK in all spaces. // // A PING frame causes us to respond with an ACK by virtue of being // an ack-eliciting frame, but requires no other action. n = 1 case frameTypeAck, frameTypeAckECN: if !frameOK(c, ptype, IH_1) { return } n = c.handleAckFrame(now, space, payload) case frameTypeResetStream: if !frameOK(c, ptype, __01) { return } n = c.handleResetStreamFrame(now, space, payload) case frameTypeStopSending: if !frameOK(c, ptype, __01) { return } n = c.handleStopSendingFrame(now, space, payload) case frameTypeCrypto: if !frameOK(c, ptype, IH_1) { return } hasCrypto = true n = c.handleCryptoFrame(now, space, payload) case frameTypeNewToken: if !frameOK(c, ptype, ___1) { return } _, n = consumeNewTokenFrame(payload) case 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f: // STREAM if !frameOK(c, ptype, __01) { return } n = c.handleStreamFrame(now, space, payload) case frameTypeMaxData: if !frameOK(c, ptype, __01) { return } n = c.handleMaxDataFrame(now, payload) case frameTypeMaxStreamData: if !frameOK(c, ptype, __01) { return } n = c.handleMaxStreamDataFrame(now, payload) case frameTypeMaxStreamsBidi, frameTypeMaxStreamsUni: if !frameOK(c, ptype, __01) { return } n = c.handleMaxStreamsFrame(now, payload) case frameTypeDataBlocked: if !frameOK(c, ptype, __01) { return } _, n = consumeDataBlockedFrame(payload) case frameTypeStreamsBlockedBidi, frameTypeStreamsBlockedUni: if !frameOK(c, ptype, __01) { return } _, _, n = consumeStreamsBlockedFrame(payload) case frameTypeStreamDataBlocked: if !frameOK(c, ptype, __01) { return } _, _, n = consumeStreamDataBlockedFrame(payload) case frameTypeNewConnectionID: if !frameOK(c, ptype, __01) { return } n = c.handleNewConnectionIDFrame(now, space, payload) case frameTypeRetireConnectionID: if !frameOK(c, ptype, __01) { return } n = c.handleRetireConnectionIDFrame(now, space, payload) case frameTypePathChallenge: if !frameOK(c, ptype, __01) { return } n = c.handlePathChallengeFrame(now, dgram, space, payload) case frameTypePathResponse: if !frameOK(c, ptype, ___1) { return } n = c.handlePathResponseFrame(now, space, payload) case frameTypeConnectionCloseTransport: // Transport CONNECTION_CLOSE is OK in all spaces. n = c.handleConnectionCloseTransportFrame(now, payload) case frameTypeConnectionCloseApplication: if !frameOK(c, ptype, __01) { return } n = c.handleConnectionCloseApplicationFrame(now, payload) case frameTypeHandshakeDone: if !frameOK(c, ptype, ___1) { return } n = c.handleHandshakeDoneFrame(now, space, payload) } if n < 0 { c.abort(now, localTransportError{ code: errFrameEncoding, reason: "frame encoding error", }) return false } payload = payload[n:] } if hasCrypto { // Process TLS events after handling all frames in a packet. // TLS events can cause us to drop state for a number space, // so do that last, to avoid handling frames differently // depending on whether they come before or after a CRYPTO frame. if err := c.handleTLSEvents(now); err != nil { c.abort(now, err) } } return ackEliciting } func (c Conn) handleAckFrame(now time.Time, space numberSpace, payload []byte) int { c.loss.receiveAckStart() largest, ackDelay, n := consumeAckFrame(payload, func(rangeIndex int, start, end packetNumber) { if end > c.loss.nextNumber(space) { // Acknowledgement of a packet we never sent. c.abort(now, localTransportError{ code: errProtocolViolation, reason: "acknowledgement for unsent packet", }) return } c.loss.receiveAckRange(now, space, rangeIndex, start, end, c.handleAckOrLoss) }) // Prior to receiving the peer's transport parameters, we cannot // interpret the ACK Delay field because we don't know the ack_delay_exponent // to apply. // // For servers, we should always know the ack_delay_exponent because the // client's transport parameters are carried in its Initial packets and we // won't send an ack-eliciting Initial packet until after receiving the last // client Initial packet. // // For clients, we won't receive the server's transport parameters until handling // its Handshake flight, which will probably happen after reading its ACK for our // Initial packet(s). However, the peer's acknowledgement delay cannot reduce our // adjusted RTT sample below min_rtt, and min_rtt is generally going to be set // by the packet containing the ACK for our Initial flight. Therefore, the // ACK Delay for an ACK in the Initial space is likely to be ignored anyway. // // Long story short, setting the delay to 0 prior to reading transport parameters // is usually going to have no effect, will have only a minor effect in the rare // cases when it happens, and there aren't any good alternatives anyway since we // can't interpret the ACK Delay field without knowing the exponent. var delay time.Duration if c.peerAckDelayExponent >= 0 { delay = ackDelay.Duration(uint8(c.peerAckDelayExponent)) } c.loss.receiveAckEnd(now, c.log, space, delay, c.handleAckOrLoss) if space == appDataSpace { c.keysAppData.handleAckFor(largest) } return n } func (c Conn) handleMaxDataFrame(now time.Time, payload []byte) int { maxData, n := consumeMaxDataFrame(payload) if n < 0 { return -1 } c.streams.outflow.setMaxData(maxData) return n } func (c Conn) handleMaxStreamDataFrame(now time.Time, payload []byte) int { id, maxStreamData, n := consumeMaxStreamDataFrame(payload) if n < 0 { return -1 } if s := c.streamForFrame(now, id, sendStream); s != nil { if err := s.handleMaxStreamData(maxStreamData); err != nil { c.abort(now, err) return -1 } } return n } func (c Conn) handleMaxStreamsFrame(now time.Time, payload []byte) int { styp, max, n := consumeMaxStreamsFrame(payload) if n < 0 { return -1 } c.streams.localLimit[styp].setMax(max) return n } func (c Conn) handleResetStreamFrame(now time.Time, space numberSpace, payload []byte) int { id, code, finalSize, n := consumeResetStreamFrame(payload) if n < 0 { return -1 } if s := c.streamForFrame(now, id, recvStream); s != nil { if err := s.handleReset(code, finalSize); err != nil { c.abort(now, err) } } return n } func (c Conn) handleStopSendingFrame(now time.Time, space numberSpace, payload []byte) int { id, code, n := consumeStopSendingFrame(payload) if n < 0 { return -1 } if s := c.streamForFrame(now, id, sendStream); s != nil { if err := s.handleStopSending(code); err != nil { c.abort(now, err) } } return n } func (c Conn) handleCryptoFrame(now time.Time, space numberSpace, payload []byte) int { off, data, n := consumeCryptoFrame(payload) err := c.handleCrypto(now, space, off, data) if err != nil { c.abort(now, err) return -1 } return n } func (c Conn) handleStreamFrame(now time.Time, space numberSpace, payload []byte) int { id, off, fin, b, n := consumeStreamFrame(payload) if n < 0 { return -1 } if s := c.streamForFrame(now, id, recvStream); s != nil { if err := s.handleData(off, b, fin); err != nil { c.abort(now, err) } } return n } func (c Conn) handleNewConnectionIDFrame(now time.Time, space numberSpace, payload []byte) int { seq, retire, connID, resetToken, n := consumeNewConnectionIDFrame(payload) if n < 0 { return -1 } if err := c.connIDState.handleNewConnID(c, seq, retire, connID, resetToken); err != nil { c.abort(now, err) } return n } func (c Conn) handleRetireConnectionIDFrame(now time.Time, space numberSpace, payload []byte) int { seq, n := consumeRetireConnectionIDFrame(payload) if n < 0 { return -1 } if err := c.connIDState.handleRetireConnID(c, seq); err != nil { c.abort(now, err) } return n } func (c Conn) handlePathChallengeFrame(now time.Time, dgram datagram, space numberSpace, payload []byte) int { data, n := consumePathChallengeFrame(payload) if n < 0 { return -1 } c.handlePathChallenge(now, dgram, data) return n } func (c Conn) handlePathResponseFrame(now time.Time, space numberSpace, payload []byte) int { data, n := consumePathResponseFrame(payload) if n < 0 { return -1 } c.handlePathResponse(now, data) return n } func (c Conn) handleConnectionCloseTransportFrame(now time.Time, payload []byte) int { code, _, reason, n := consumeConnectionCloseTransportFrame(payload) if n < 0 { return -1 } c.handlePeerConnectionClose(now, peerTransportError{code: code, reason: reason}) return n } func (c Conn) handleConnectionCloseApplicationFrame(now time.Time, payload []byte) int { code, reason, n := consumeConnectionCloseApplicationFrame(payload) if n < 0 { return -1 } c.handlePeerConnectionClose(now, &ApplicationError{Code: code, Reason: reason}) return n } func (c Conn) handleHandshakeDoneFrame(now time.Time, space numberSpace, payload []byte) int { if c.side == serverSide { // Clients should never send HANDSHAKE_DONE. // https://www.rfc-editor.org/rfc/rfc9000#section-19.20-4 c.abort(now, localTransportError{ code: errProtocolViolation, reason: "client sent HANDSHAKE_DONE", }) return -1 } if c.isAlive() { c.confirmHandshake(now) } return 1 } var errStatelessReset = errors.New("received stateless reset") func (c Conn) handleStatelessReset(now time.Time, resetToken statelessResetToken) (valid bool) { if !c.connIDState.isValidStatelessResetToken(resetToken) { return false } c.setFinalError(errStatelessReset) c.enterDraining(now) return true }	19.06 KB	2025-05-25 12:27
📄 conn_recv_test.go // Copyright 2024 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "crypto/tls" "testing" ) func TestConnReceiveAckForUnsentPacket(t testing.T) { tc := newTestConn(t, serverSide, permissiveTransportParameters) tc.handshake() tc.writeFrames(packetType1RTT, debugFrameAck{ ackDelay: 0, ranges: []i64range[packetNumber]{{0, 10}}, }) tc.wantFrame("ACK for unsent packet causes CONNECTION_CLOSE", packetType1RTT, debugFrameConnectionCloseTransport{ code: errProtocolViolation, }) } // Issue #70703: If a packet contains both a CRYPTO frame which causes us to // drop state for a number space, and also contains a valid ACK frame for that space, // we shouldn't complain about the ACK. func TestConnReceiveAckForDroppedSpace(t testing.T) { tc := newTestConn(t, serverSide, permissiveTransportParameters) tc.ignoreFrame(frameTypeAck) tc.ignoreFrame(frameTypeNewConnectionID) tc.writeFrames(packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelInitial], }) tc.wantFrame("send Initial crypto", packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataOut[tls.QUICEncryptionLevelInitial], }) tc.wantFrame("send Handshake crypto", packetTypeHandshake, debugFrameCrypto{ data: tc.cryptoDataOut[tls.QUICEncryptionLevelHandshake], }) tc.writeFrames(packetTypeHandshake, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelHandshake], }, debugFrameAck{ ackDelay: 0, ranges: []i64range[packetNumber]{{0, tc.lastPacket.num + 1}}, }) tc.wantFrame("handshake finishes", packetType1RTT, debugFrameHandshakeDone{}) tc.wantIdle("connection is idle") }	1.74 KB	2025-05-25 12:27
📄 conn_send.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "crypto/tls" "errors" "time" ) // maybeSend sends datagrams, if possible. // // If sending is blocked by pacing, it returns the next time // a datagram may be sent. // // If sending is blocked indefinitely, it returns the zero Time. func (c Conn) maybeSend(now time.Time) (next time.Time) { // Assumption: The congestion window is not underutilized. // If congestion control, pacing, and anti-amplification all permit sending, // but we have no packet to send, then we will declare the window underutilized. underutilized := false defer func() { c.loss.cc.setUnderutilized(c.log, underutilized) }() // Send one datagram on each iteration of this loop, // until we hit a limit or run out of data to send. // // For each number space where we have write keys, // attempt to construct a packet in that space. // If the packet contains no frames (we have no data in need of sending), // abandon the packet. // // Speculatively constructing packets means we don't need // separate code paths for "do we have data to send?" and // "send the data" that need to be kept in sync. for { limit, next := c.loss.sendLimit(now) if limit == ccBlocked { // If anti-amplification blocks sending, then no packet can be sent. return next } if !c.sendOK(now) { return time.Time{} } // We may still send ACKs, even if congestion control or pacing limit sending. // Prepare to write a datagram of at most maxSendSize bytes. c.w.reset(c.loss.maxSendSize()) dstConnID, ok := c.connIDState.dstConnID() if !ok { // It is currently not possible for us to end up without a connection ID, // but handle the case anyway. return time.Time{} } // Initial packet. pad := false var sentInitial sentPacket if c.keysInitial.canWrite() { pnumMaxAcked := c.loss.spaces[initialSpace].maxAcked pnum := c.loss.nextNumber(initialSpace) p := longPacket{ ptype: packetTypeInitial, version: quicVersion1, num: pnum, dstConnID: dstConnID, srcConnID: c.connIDState.srcConnID(), extra: c.retryToken, } c.w.startProtectedLongHeaderPacket(pnumMaxAcked, p) c.appendFrames(now, initialSpace, pnum, limit) if logPackets { logSentPacket(c, packetTypeInitial, pnum, p.srcConnID, p.dstConnID, c.w.payload()) } if c.logEnabled(QLogLevelPacket) && len(c.w.payload()) > 0 { c.logPacketSent(packetTypeInitial, pnum, p.srcConnID, p.dstConnID, c.w.packetLen(), c.w.payload()) } sentInitial = c.w.finishProtectedLongHeaderPacket(pnumMaxAcked, c.keysInitial.w, p) if sentInitial != nil { // Client initial packets and ack-eliciting server initial packaets // need to be sent in a datagram padded to at least 1200 bytes. // We can't add the padding yet, however, since we may want to // coalesce additional packets with this one. if c.side == clientSide \|\| sentInitial.ackEliciting { pad = true } } } // Handshake packet. if c.keysHandshake.canWrite() { pnumMaxAcked := c.loss.spaces[handshakeSpace].maxAcked pnum := c.loss.nextNumber(handshakeSpace) p := longPacket{ ptype: packetTypeHandshake, version: quicVersion1, num: pnum, dstConnID: dstConnID, srcConnID: c.connIDState.srcConnID(), } c.w.startProtectedLongHeaderPacket(pnumMaxAcked, p) c.appendFrames(now, handshakeSpace, pnum, limit) if logPackets { logSentPacket(c, packetTypeHandshake, pnum, p.srcConnID, p.dstConnID, c.w.payload()) } if c.logEnabled(QLogLevelPacket) && len(c.w.payload()) > 0 { c.logPacketSent(packetTypeHandshake, pnum, p.srcConnID, p.dstConnID, c.w.packetLen(), c.w.payload()) } if sent := c.w.finishProtectedLongHeaderPacket(pnumMaxAcked, c.keysHandshake.w, p); sent != nil { c.packetSent(now, handshakeSpace, sent) if c.side == clientSide { // "[...] a client MUST discard Initial keys when it first // sends a Handshake packet [...]" // https://www.rfc-editor.org/rfc/rfc9001.html#section-4.9.1-2 c.discardKeys(now, initialSpace) } } } // 1-RTT packet. if c.keysAppData.canWrite() { pnumMaxAcked := c.loss.spaces[appDataSpace].maxAcked pnum := c.loss.nextNumber(appDataSpace) c.w.start1RTTPacket(pnum, pnumMaxAcked, dstConnID) c.appendFrames(now, appDataSpace, pnum, limit) if pad && len(c.w.payload()) > 0 { // 1-RTT packets have no length field and extend to the end // of the datagram, so if we're sending a datagram that needs // padding we need to add it inside the 1-RTT packet. c.w.appendPaddingTo(paddedInitialDatagramSize) pad = false } if logPackets { logSentPacket(c, packetType1RTT, pnum, nil, dstConnID, c.w.payload()) } if c.logEnabled(QLogLevelPacket) && len(c.w.payload()) > 0 { c.logPacketSent(packetType1RTT, pnum, nil, dstConnID, c.w.packetLen(), c.w.payload()) } if sent := c.w.finish1RTTPacket(pnum, pnumMaxAcked, dstConnID, &c.keysAppData); sent != nil { c.packetSent(now, appDataSpace, sent) } } buf := c.w.datagram() if len(buf) == 0 { if limit == ccOK { // We have nothing to send, and congestion control does not // block sending. The congestion window is underutilized. underutilized = true } return next } if sentInitial != nil { if pad { // Pad out the datagram with zeros, coalescing the Initial // packet with invalid packets that will be ignored by the peer. // https://www.rfc-editor.org/rfc/rfc9000.html#section-14.1-1 for len(buf) < paddedInitialDatagramSize { buf = append(buf, 0) // Technically this padding isn't in any packet, but // account it to the Initial packet in this datagram // for purposes of flow control and loss recovery. sentInitial.size++ sentInitial.inFlight = true } } // If we're a client and this Initial packet is coalesced // with a Handshake packet, then we've discarded Initial keys // since constructing the packet and shouldn't record it as in-flight. if c.keysInitial.canWrite() { c.packetSent(now, initialSpace, sentInitial) } } c.endpoint.sendDatagram(datagram{ b: buf, peerAddr: c.peerAddr, }) } } func (c Conn) packetSent(now time.Time, space numberSpace, sent sentPacket) { c.idleHandlePacketSent(now, sent) c.loss.packetSent(now, c.log, space, sent) } func (c Conn) appendFrames(now time.Time, space numberSpace, pnum packetNumber, limit ccLimit) { if c.lifetime.localErr != nil { c.appendConnectionCloseFrame(now, space, c.lifetime.localErr) return } shouldSendAck := c.acks[space].shouldSendAck(now) if limit != ccOK { // ACKs are not limited by congestion control. if shouldSendAck && c.appendAckFrame(now, space) { c.acks[space].sentAck() } return } // We want to send an ACK frame if the ack controller wants to send a frame now, // OR if we are sending a packet anyway and have ack-eliciting packets which we // have not yet acked. // // We speculatively add ACK frames here, to put them at the front of the packet // to avoid truncation. // // After adding all frames, if we don't need to send an ACK frame and have not // added any other frames, we abandon the packet. if c.appendAckFrame(now, space) { defer func() { // All frames other than ACK and PADDING are ack-eliciting, // so if the packet is ack-eliciting we've added additional // frames to it. if !shouldSendAck && !c.w.sent.ackEliciting { // There's nothing in this packet but ACK frames, and // we don't want to send an ACK-only packet at this time. // Abandoning the packet means we wrote an ACK frame for // nothing, but constructing the frame is cheap. c.w.abandonPacket() return } // Either we are willing to send an ACK-only packet, // or we've added additional frames. c.acks[space].sentAck() if !c.w.sent.ackEliciting && c.shouldMakePacketAckEliciting() { c.w.appendPingFrame() } }() } if limit != ccOK { return } pto := c.loss.ptoExpired // TODO: Add all the other frames we can send. // CRYPTO c.crypto[space].dataToSend(pto, func(off, size int64) int64 { b, _ := c.w.appendCryptoFrame(off, int(size)) c.crypto[space].sendData(off, b) return int64(len(b)) }) // Test-only PING frames. if space == c.testSendPingSpace && c.testSendPing.shouldSendPTO(pto) { if !c.w.appendPingFrame() { return } c.testSendPing.setSent(pnum) } if space == appDataSpace { // HANDSHAKE_DONE if c.handshakeConfirmed.shouldSendPTO(pto) { if !c.w.appendHandshakeDoneFrame() { return } c.handshakeConfirmed.setSent(pnum) } // NEW_CONNECTION_ID, RETIRE_CONNECTION_ID if !c.connIDState.appendFrames(c, pnum, pto) { return } // PATH_RESPONSE if pad, ok := c.appendPathFrames(); !ok { return } else if pad { defer c.w.appendPaddingTo(smallestMaxDatagramSize) } // All stream-related frames. This should come last in the packet, // so large amounts of STREAM data don't crowd out other frames // we may need to send. if !c.appendStreamFrames(&c.w, pnum, pto) { return } if !c.appendKeepAlive(now) { return } } // If this is a PTO probe and we haven't added an ack-eliciting frame yet, // add a PING to make this an ack-eliciting probe. // // Technically, there are separate PTO timers for each number space. // When a PTO timer expires, we MUST send an ack-eliciting packet in the // timer's space. We SHOULD send ack-eliciting packets in every other space // with in-flight data. (RFC 9002, section 6.2.4) // // What we actually do is send a single datagram containing an ack-eliciting packet // for every space for which we have keys. // // We fill the PTO probe packets with new or unacknowledged data. For example, // a PTO probe sent for the Initial space will generally retransmit previously // sent but unacknowledged CRYPTO data. // // When sending a PTO probe datagram containing multiple packets, it is // possible that an earlier packet will fill up the datagram, leaving no // space for the remaining probe packet(s). This is not a problem in practice. // // A client discards Initial keys when it first sends a Handshake packet // (RFC 9001 Section 4.9.1). Handshake keys are discarded when the handshake // is confirmed (RFC 9001 Section 4.9.2). The PTO timer is not set for the // Application Data packet number space until the handshake is confirmed // (RFC 9002 Section 6.2.1). Therefore, the only times a PTO probe can fire // while data for multiple spaces is in flight are: // // - a server's Initial or Handshake timers can fire while Initial and Handshake // data is in flight; and // // - a client's Handshake timer can fire while Handshake and Application Data // data is in flight. // // It is theoretically possible for a server's Initial CRYPTO data to overflow // the maximum datagram size, but unlikely in practice; this space contains // only the ServerHello TLS message, which is small. It's also unlikely that // the Handshake PTO probe will fire while Initial data is in flight (this // requires not just that the Initial CRYPTO data completely fill a datagram, // but a quite specific arrangement of lost and retransmitted packets.) // We don't bother worrying about this case here, since the worst case is // that we send a PTO probe for the in-flight Initial data and drop the // Handshake probe. // // If a client's Handshake PTO timer fires while Application Data data is in // flight, it is possible that the resent Handshake CRYPTO data will crowd // out the probe for the Application Data space. However, since this probe is // optional (recall that the Application Data PTO timer is never set until // after Handshake keys have been discarded), dropping it is acceptable. if pto && !c.w.sent.ackEliciting { c.w.appendPingFrame() } } // shouldMakePacketAckEliciting is called when sending a packet containing nothing but an ACK frame. // It reports whether we should add a PING frame to the packet to make it ack-eliciting. func (c Conn) shouldMakePacketAckEliciting() bool { if c.keysAppData.needAckEliciting() { // The peer has initiated a key update. // We haven't sent them any packets yet in the new phase. // Make this an ack-eliciting packet. // Their ack of this packet will complete the key update. return true } if c.loss.consecutiveNonAckElicitingPackets >= 19 { // We've sent a run of non-ack-eliciting packets. // Add in an ack-eliciting one every once in a while so the peer // lets us know which ones have arrived. // // Google QUICHE injects a PING after sending 19 packets. We do the same. // // https://www.rfc-editor.org/rfc/rfc9000#section-13.2.4-2 return true } // TODO: Consider making every packet sent when in PTO ack-eliciting to speed up recovery. return false } func (c Conn) appendAckFrame(now time.Time, space numberSpace) bool { seen, delay := c.acks[space].acksToSend(now) if len(seen) == 0 { return false } d := unscaledAckDelayFromDuration(delay, ackDelayExponent) return c.w.appendAckFrame(seen, d) } func (c Conn) appendConnectionCloseFrame(now time.Time, space numberSpace, err error) { c.sentConnectionClose(now) switch e := err.(type) { case localTransportError: c.w.appendConnectionCloseTransportFrame(e.code, 0, e.reason) case *ApplicationError: if space != appDataSpace { // "CONNECTION_CLOSE frames signaling application errors (type 0x1d) // MUST only appear in the application data packet number space." // https://www.rfc-editor.org/rfc/rfc9000#section-12.5-2.2 c.w.appendConnectionCloseTransportFrame(errApplicationError, 0, "") } else { c.w.appendConnectionCloseApplicationFrame(e.Code, e.Reason) } default: // TLS alerts are sent using error codes [0x0100,0x01ff). // https://www.rfc-editor.org/rfc/rfc9000#section-20.1-2.36.1 var alert tls.AlertError switch { case errors.As(err, &alert): // tls.AlertError is a uint8, so this can't exceed 0x01ff. code := errTLSBase + transportError(alert) c.w.appendConnectionCloseTransportFrame(code, 0, "") default: c.w.appendConnectionCloseTransportFrame(errInternal, 0, "") } } }	14.08 KB	2025-05-25 12:27
📄 conn_send_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "testing" "time" ) func TestAckElicitingAck(t testing.T) { // "A receiver that sends only non-ack-eliciting packets [...] might not receive // an acknowledgment for a long period of time. // [...] a receiver could send a [...] ack-eliciting frame occasionally [...] // to elicit an ACK from the peer." // https://www.rfc-editor.org/rfc/rfc9000#section-13.2.4-2 // // Send a bunch of ack-eliciting packets, verify that the conn doesn't just // send ACKs in response. tc := newTestConn(t, clientSide, permissiveTransportParameters) tc.handshake() const count = 100 for i := 0; i < count; i++ { tc.advance(1 time.Millisecond) tc.writeFrames(packetType1RTT, debugFramePing{}, ) got, _ := tc.readFrame() switch got.(type) { case debugFrameAck: continue case debugFramePing: return } } t.Errorf("after sending %v PINGs, got no ack-eliciting response", count) } func TestSendPacketNumberSize(t testing.T) { tc := newTestConn(t, clientSide, permissiveTransportParameters) tc.handshake() recvPing := func() testPacket { t.Helper() tc.conn.ping(appDataSpace) p := tc.readPacket() if p == nil { t.Fatalf("want packet containing PING, got none") } return p } // Desynchronize the packet numbers the conn is sending and the ones it is receiving, // by having the conn send a number of unacked packets. for i := 0; i < 16; i++ { recvPing() } // Establish the maximum packet number the conn has received an ACK for. maxAcked := recvPing().num tc.writeAckForAll() // Make the conn send a sequence of packets. // Check that the packet number is encoded with two bytes once the difference between the // current packet and the max acked one is sufficiently large. for want := maxAcked + 1; want < maxAcked+0x100; want++ { p := recvPing() if p.num != want { t.Fatalf("received packet number %v, want %v", p.num, want) } gotPnumLen := int(p.header&0x03) + 1 wantPnumLen := 1 if p.num-maxAcked >= 0x80 { wantPnumLen = 2 } if gotPnumLen != wantPnumLen { t.Fatalf("packet number 0x%x encoded with %v bytes, want %v (max acked = %v)", p.num, gotPnumLen, wantPnumLen, maxAcked) } } }	2.32 KB	2025-05-25 12:27
📄 conn_streams.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "context" "sync" "sync/atomic" "time" ) type streamsState struct { queue queue[Stream] // new, peer-created streams // All peer-created streams. // // Implicitly created streams are included as an empty entry in the map. // (For example, if we receive a frame for stream 4, we implicitly create stream 0 and // insert an empty entry for it to the map.) // // The map value is maybeStream rather than Stream as a reminder that values can be nil. streams map[streamID]maybeStream // Limits on the number of streams, indexed by streamType. localLimit [streamTypeCount]localStreamLimits remoteLimit [streamTypeCount]remoteStreamLimits // Peer configuration provided in transport parameters. peerInitialMaxStreamDataRemote [streamTypeCount]int64 // streams opened by us peerInitialMaxStreamDataBidiLocal int64 // streams opened by them // Connection-level flow control. inflow connInflow outflow connOutflow // Streams with frames to send are stored in one of two circular linked lists, // depending on whether they require connection-level flow control. needSend atomic.Bool sendMu sync.Mutex queueMeta streamRing // streams with any non-flow-controlled frames queueData streamRing // streams with only flow-controlled frames } // maybeStream is a possibly nil Stream. See streamsState.streams. type maybeStream struct { s Stream } func (c Conn) streamsInit() { c.streams.streams = make(map[streamID]maybeStream) c.streams.queue = newQueue[Stream]() c.streams.localLimit[bidiStream].init() c.streams.localLimit[uniStream].init() c.streams.remoteLimit[bidiStream].init(c.config.maxBidiRemoteStreams()) c.streams.remoteLimit[uniStream].init(c.config.maxUniRemoteStreams()) c.inflowInit() } func (c Conn) streamsCleanup() { c.streams.queue.close(errConnClosed) c.streams.localLimit[bidiStream].connHasClosed() c.streams.localLimit[uniStream].connHasClosed() for _, s := range c.streams.streams { if s.s != nil { s.s.connHasClosed() } } } // AcceptStream waits for and returns the next stream created by the peer. func (c Conn) AcceptStream(ctx context.Context) (Stream, error) { return c.streams.queue.get(ctx, c.testHooks) } // NewStream creates a stream. // // If the peer's maximum stream limit for the connection has been reached, // NewStream blocks until the limit is increased or the context expires. func (c Conn) NewStream(ctx context.Context) (Stream, error) { return c.newLocalStream(ctx, bidiStream) } // NewSendOnlyStream creates a unidirectional, send-only stream. // // If the peer's maximum stream limit for the connection has been reached, // NewSendOnlyStream blocks until the limit is increased or the context expires. func (c Conn) NewSendOnlyStream(ctx context.Context) (Stream, error) { return c.newLocalStream(ctx, uniStream) } func (c Conn) newLocalStream(ctx context.Context, styp streamType) (Stream, error) { num, err := c.streams.localLimit[styp].open(ctx, c) if err != nil { return nil, err } s := newStream(c, newStreamID(c.side, styp, num)) s.outmaxbuf = c.config.maxStreamWriteBufferSize() s.outwin = c.streams.peerInitialMaxStreamDataRemote[styp] if styp == bidiStream { s.inmaxbuf = c.config.maxStreamReadBufferSize() s.inwin = c.config.maxStreamReadBufferSize() } s.inUnlock() s.outUnlock() // Modify c.streams on the conn's loop. if err := c.runOnLoop(ctx, func(now time.Time, c Conn) { c.streams.streams[s.id] = maybeStream{s} }); err != nil { return nil, err } return s, nil } // streamFrameType identifies which direction of a stream, // from the local perspective, a frame is associated with. // // For example, STREAM is a recvStream frame, // because it carries data from the peer to us. type streamFrameType uint8 const ( sendStream = streamFrameType(iota) // for example, MAX_DATA recvStream // for example, STREAM_DATA_BLOCKED ) // streamForID returns the stream with the given id. // If the stream does not exist, it returns nil. func (c Conn) streamForID(id streamID) Stream { return c.streams.streams[id].s } // streamForFrame returns the stream with the given id. // If the stream does not exist, it may be created. // // streamForFrame aborts the connection if the stream id, state, and frame type don't align. // For example, it aborts the connection with a STREAM_STATE error if a MAX_DATA frame // is received for a receive-only stream, or if the peer attempts to create a stream that // should be originated locally. // // streamForFrame returns nil if the stream no longer exists or if an error occurred. func (c Conn) streamForFrame(now time.Time, id streamID, ftype streamFrameType) Stream { if id.streamType() == uniStream { if (id.initiator() == c.side) != (ftype == sendStream) { // Received an invalid frame for unidirectional stream. // For example, a RESET_STREAM frame for a send-only stream. c.abort(now, localTransportError{ code: errStreamState, reason: "invalid frame for unidirectional stream", }) return nil } } ms, isOpen := c.streams.streams[id] if ms.s != nil { return ms.s } num := id.num() styp := id.streamType() if id.initiator() == c.side { if num < c.streams.localLimit[styp].opened { // This stream was created by us, and has been closed. return nil } // Received a frame for a stream that should be originated by us, // but which we never created. c.abort(now, localTransportError{ code: errStreamState, reason: "received frame for unknown stream", }) return nil } else { // if isOpen, this is a stream that was implicitly opened by a // previous frame for a larger-numbered stream, but we haven't // actually created it yet. if !isOpen && num < c.streams.remoteLimit[styp].opened { // This stream was created by the peer, and has been closed. return nil } } prevOpened := c.streams.remoteLimit[styp].opened if err := c.streams.remoteLimit[styp].open(id); err != nil { c.abort(now, err) return nil } // Receiving a frame for a stream implicitly creates all streams // with the same initiator and type and a lower number. // Add a nil entry to the streams map for each implicitly created stream. for n := newStreamID(id.initiator(), id.streamType(), prevOpened); n < id; n += 4 { c.streams.streams[n] = maybeStream{} } s := newStream(c, id) s.inmaxbuf = c.config.maxStreamReadBufferSize() s.inwin = c.config.maxStreamReadBufferSize() if id.streamType() == bidiStream { s.outmaxbuf = c.config.maxStreamWriteBufferSize() s.outwin = c.streams.peerInitialMaxStreamDataBidiLocal } s.inUnlock() s.outUnlock() c.streams.streams[id] = maybeStream{s} c.streams.queue.put(s) return s } // maybeQueueStreamForSend marks a stream as containing frames that need sending. func (c Conn) maybeQueueStreamForSend(s Stream, state streamState) { if state.wantQueue() == state.inQueue() { return // already on the right queue } c.streams.sendMu.Lock() defer c.streams.sendMu.Unlock() state = s.state.load() // may have changed while waiting c.queueStreamForSendLocked(s, state) c.streams.needSend.Store(true) c.wake() } // queueStreamForSendLocked moves a stream to the correct send queue, // or removes it from all queues. // // state is the last known stream state. func (c Conn) queueStreamForSendLocked(s Stream, state streamState) { for { wantQueue := state.wantQueue() inQueue := state.inQueue() if inQueue == wantQueue { return // already on the right queue } switch inQueue { case metaQueue: c.streams.queueMeta.remove(s) case dataQueue: c.streams.queueData.remove(s) } switch wantQueue { case metaQueue: c.streams.queueMeta.append(s) state = s.state.set(streamQueueMeta, streamQueueMeta\|streamQueueData) case dataQueue: c.streams.queueData.append(s) state = s.state.set(streamQueueData, streamQueueMeta\|streamQueueData) case noQueue: state = s.state.set(0, streamQueueMeta\|streamQueueData) } // If the stream state changed while we were moving the stream, // we might now be on the wrong queue. // // For example: // - stream has data to send: streamOutSendData\|streamQueueData // - appendStreamFrames sends all the data: streamQueueData // - concurrently, more data is written: streamOutSendData\|streamQueueData // - appendStreamFrames calls us with the last state it observed // (streamQueueData). // - We remove the stream from the queue and observe the updated state: // streamOutSendData // - We realize that the stream needs to go back on the data queue. // // Go back around the loop to confirm we're on the correct queue. } } // appendStreamFrames writes stream-related frames to the current packet. // // It returns true if no more frames need appending, // false if not everything fit in the current packet. func (c Conn) appendStreamFrames(w packetWriter, pnum packetNumber, pto bool) bool { // MAX_DATA if !c.appendMaxDataFrame(w, pnum, pto) { return false } // MAX_STREAM_DATA if !c.streams.remoteLimit[uniStream].appendFrame(w, uniStream, pnum, pto) { return false } if !c.streams.remoteLimit[bidiStream].appendFrame(w, bidiStream, pnum, pto) { return false } if pto { return c.appendStreamFramesPTO(w, pnum) } if !c.streams.needSend.Load() { return true } c.streams.sendMu.Lock() defer c.streams.sendMu.Unlock() // queueMeta contains streams with non-flow-controlled frames to send. for c.streams.queueMeta.head != nil { s := c.streams.queueMeta.head state := s.state.load() if state&(streamQueueMeta\|streamConnRemoved) != streamQueueMeta { panic("BUG: queueMeta stream is not streamQueueMeta") } if state&streamInSendMeta != 0 { s.ingate.lock() ok := s.appendInFramesLocked(w, pnum, pto) state = s.inUnlockNoQueue() if !ok { return false } if state&streamInSendMeta != 0 { panic("BUG: streamInSendMeta set after successfully appending frames") } } if state&streamOutSendMeta != 0 { s.outgate.lock() // This might also append flow-controlled frames if we have any // and available conn-level quota. That's fine. ok := s.appendOutFramesLocked(w, pnum, pto) state = s.outUnlockNoQueue() // We're checking both ok and state, because appendOutFramesLocked // might have filled up the packet with flow-controlled data. // If so, we want to move the stream to queueData for any remaining frames. if !ok && state&streamOutSendMeta != 0 { return false } if state&streamOutSendMeta != 0 { panic("BUG: streamOutSendMeta set after successfully appending frames") } } // We've sent all frames for this stream, so remove it from the send queue. c.streams.queueMeta.remove(s) if state&(streamInDone\|streamOutDone) == streamInDone\|streamOutDone { // Stream is finished, remove it from the conn. state = s.state.set(streamConnRemoved, streamQueueMeta\|streamConnRemoved) delete(c.streams.streams, s.id) // Record finalization of remote streams, to know when // to extend the peer's stream limit. if s.id.initiator() != c.side { c.streams.remoteLimit[s.id.streamType()].close() } } else { state = s.state.set(0, streamQueueMeta\|streamConnRemoved) } // The stream may have flow-controlled data to send, // or something might have added non-flow-controlled frames after we // unlocked the stream. // If so, put the stream back on a queue. c.queueStreamForSendLocked(s, state) } // queueData contains streams with flow-controlled frames. for c.streams.queueData.head != nil { avail := c.streams.outflow.avail() if avail == 0 { break // no flow control quota available } s := c.streams.queueData.head s.outgate.lock() ok := s.appendOutFramesLocked(w, pnum, pto) state := s.outUnlockNoQueue() if !ok { // We've sent some data for this stream, but it still has more to send. // If the stream got a reasonable chance to put data in a packet, // advance sendHead to the next stream in line, to avoid starvation. // We'll come back to this stream after going through the others. // // If the packet was already mostly out of space, leave sendHead alone // and come back to this stream again on the next packet. if avail > 512 { c.streams.queueData.head = s.next } return false } if state&streamQueueData == 0 { panic("BUG: queueData stream is not streamQueueData") } if state&streamOutSendData != 0 { // We must have run out of connection-level flow control: // appendOutFramesLocked says it wrote all it can, but there's // still data to send. // // Advance sendHead to the next stream in line to avoid starvation. if c.streams.outflow.avail() != 0 { panic("BUG: streamOutSendData set and flow control available after send") } c.streams.queueData.head = s.next return true } c.streams.queueData.remove(s) state = s.state.set(0, streamQueueData) c.queueStreamForSendLocked(s, state) } if c.streams.queueMeta.head == nil && c.streams.queueData.head == nil { c.streams.needSend.Store(false) } return true } // appendStreamFramesPTO writes stream-related frames to the current packet // for a PTO probe. // // It returns true if no more frames need appending, // false if not everything fit in the current packet. func (c Conn) appendStreamFramesPTO(w packetWriter, pnum packetNumber) bool { c.streams.sendMu.Lock() defer c.streams.sendMu.Unlock() const pto = true for _, ms := range c.streams.streams { s := ms.s if s == nil { continue } const pto = true s.ingate.lock() inOK := s.appendInFramesLocked(w, pnum, pto) s.inUnlockNoQueue() if !inOK { return false } s.outgate.lock() outOK := s.appendOutFramesLocked(w, pnum, pto) s.outUnlockNoQueue() if !outOK { return false } } return true } // A streamRing is a circular linked list of streams. type streamRing struct { head Stream } // remove removes s from the ring. // s must be on the ring. func (r streamRing) remove(s Stream) { if s.next == s { r.head = nil // s was the last stream in the ring } else { s.prev.next = s.next s.next.prev = s.prev if r.head == s { r.head = s.next } } } // append places s at the last position in the ring. // s must not be attached to any ring. func (r streamRing) append(s *Stream) { if r.head == nil { r.head = s s.next = s s.prev = s } else { s.prev = r.head.prev s.next = r.head s.prev.next = s s.next.prev = s } }	14.39 KB	2025-05-25 12:27
📄 conn_streams_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "context" "fmt" "io" "math" "sync" "testing" ) func TestStreamsCreate(t testing.T) { ctx := canceledContext() tc := newTestConn(t, clientSide, permissiveTransportParameters) tc.handshake() s, err := tc.conn.NewStream(ctx) if err != nil { t.Fatalf("NewStream: %v", err) } s.Flush() // open the stream tc.wantFrame("created bidirectional stream 0", packetType1RTT, debugFrameStream{ id: 0, // client-initiated, bidi, number 0 data: []byte{}, }) s, err = tc.conn.NewSendOnlyStream(ctx) if err != nil { t.Fatalf("NewStream: %v", err) } s.Flush() // open the stream tc.wantFrame("created unidirectional stream 0", packetType1RTT, debugFrameStream{ id: 2, // client-initiated, uni, number 0 data: []byte{}, }) s, err = tc.conn.NewStream(ctx) if err != nil { t.Fatalf("NewStream: %v", err) } s.Flush() // open the stream tc.wantFrame("created bidirectional stream 1", packetType1RTT, debugFrameStream{ id: 4, // client-initiated, uni, number 4 data: []byte{}, }) } func TestStreamsAccept(t testing.T) { ctx := canceledContext() tc := newTestConn(t, serverSide) tc.handshake() tc.writeFrames(packetType1RTT, debugFrameStream{ id: 0, // client-initiated, bidi, number 0 }, debugFrameStream{ id: 2, // client-initiated, uni, number 0 }, debugFrameStream{ id: 4, // client-initiated, bidi, number 1 }) for _, accept := range []struct { id streamID readOnly bool }{ {0, false}, {2, true}, {4, false}, } { s, err := tc.conn.AcceptStream(ctx) if err != nil { t.Fatalf("conn.AcceptStream() = %v, want stream %v", err, accept.id) } if got, want := s.id, accept.id; got != want { t.Fatalf("conn.AcceptStream() = stream %v, want %v", got, want) } if got, want := s.IsReadOnly(), accept.readOnly; got != want { t.Fatalf("stream %v: s.IsReadOnly() = %v, want %v", accept.id, got, want) } } _, err := tc.conn.AcceptStream(ctx) if err != context.Canceled { t.Fatalf("conn.AcceptStream() = %v, want context.Canceled", err) } } func TestStreamsBlockingAccept(t testing.T) { tc := newTestConn(t, serverSide) tc.handshake() a := runAsync(tc, func(ctx context.Context) (Stream, error) { return tc.conn.AcceptStream(ctx) }) if _, err := a.result(); err != errNotDone { tc.t.Fatalf("AcceptStream() = _, %v; want errNotDone", err) } sid := newStreamID(clientSide, bidiStream, 0) tc.writeFrames(packetType1RTT, debugFrameStream{ id: sid, }) s, err := a.result() if err != nil { t.Fatalf("conn.AcceptStream() = _, %v, want stream", err) } if got, want := s.id, sid; got != want { t.Fatalf("conn.AcceptStream() = stream %v, want %v", got, want) } if got, want := s.IsReadOnly(), false; got != want { t.Fatalf("s.IsReadOnly() = %v, want %v", got, want) } } func TestStreamsLocalStreamNotCreated(t testing.T) { // "An endpoint MUST terminate the connection with error STREAM_STATE_ERROR // if it receives a STREAM frame for a locally initiated stream that has // not yet been created [...]" // https://www.rfc-editor.org/rfc/rfc9000.html#section-19.8-3 tc := newTestConn(t, serverSide) tc.handshake() tc.writeFrames(packetType1RTT, debugFrameStream{ id: 1, // server-initiated, bidi, number 0 }) tc.wantFrame("peer sent STREAM frame for an uncreated local stream", packetType1RTT, debugFrameConnectionCloseTransport{ code: errStreamState, }) } func TestStreamsLocalStreamClosed(t testing.T) { tc, s := newTestConnAndLocalStream(t, clientSide, uniStream, permissiveTransportParameters) s.CloseWrite() tc.wantFrame("FIN for closed stream", packetType1RTT, debugFrameStream{ id: newStreamID(clientSide, uniStream, 0), fin: true, data: []byte{}, }) tc.writeAckForAll() tc.writeFrames(packetType1RTT, debugFrameStopSending{ id: newStreamID(clientSide, uniStream, 0), }) tc.wantIdle("frame for finalized stream is ignored") // ACKing the last stream packet should have cleaned up the stream. // Check that we don't have any state left. if got := len(tc.conn.streams.streams); got != 0 { t.Fatalf("after close, len(tc.conn.streams.streams) = %v, want 0", got) } if tc.conn.streams.queueMeta.head != nil { t.Fatalf("after close, stream send queue is not empty; should be") } } func TestStreamsStreamSendOnly(t testing.T) { // "An endpoint MUST terminate the connection with error STREAM_STATE_ERROR // if it receives a STREAM frame for a locally initiated stream that has // not yet been created [...]" // https://www.rfc-editor.org/rfc/rfc9000.html#section-19.8-3 ctx := canceledContext() tc := newTestConn(t, serverSide, permissiveTransportParameters) tc.handshake() s, err := tc.conn.NewSendOnlyStream(ctx) if err != nil { t.Fatalf("NewStream: %v", err) } s.Flush() // open the stream tc.wantFrame("created unidirectional stream 0", packetType1RTT, debugFrameStream{ id: 3, // server-initiated, uni, number 0 data: []byte{}, }) tc.writeFrames(packetType1RTT, debugFrameStream{ id: 3, // server-initiated, bidi, number 0 }) tc.wantFrame("peer sent STREAM frame for a send-only stream", packetType1RTT, debugFrameConnectionCloseTransport{ code: errStreamState, }) } func TestStreamsWriteQueueFairness(t testing.T) { ctx := canceledContext() const dataLen = 1 << 20 const numStreams = 3 tc := newTestConn(t, clientSide, func(p transportParameters) { p.initialMaxStreamsBidi = numStreams p.initialMaxData = 1<<62 - 1 p.initialMaxStreamDataBidiRemote = dataLen }, func(c Config) { c.MaxStreamWriteBufferSize = dataLen }) tc.handshake() tc.ignoreFrame(frameTypeAck) // Create a number of streams, and write a bunch of data to them. // The streams are not limited by flow control. // // The first stream we create is going to immediately consume all // available congestion window. // // Once we've created all the remaining streams, // we start sending acks back to open up the congestion window. // We verify that all streams can make progress. data := make([]byte, dataLen) var streams []Stream for i := 0; i < numStreams; i++ { s, err := tc.conn.NewStream(ctx) if err != nil { t.Fatal(err) } streams = append(streams, s) if n, err := s.Write(data); n != len(data) \|\| err != nil { t.Fatalf("s.Write() = %v, %v; want %v, nil", n, err, len(data)) } // Wait for the stream to finish writing whatever frames it can before // congestion control blocks it. tc.wait() } sent := make([]int64, len(streams)) for { p := tc.readPacket() if p == nil { break } tc.writeFrames(packetType1RTT, debugFrameAck{ ranges: []i64range[packetNumber]{{0, p.num}}, }) for _, f := range p.frames { sf, ok := f.(debugFrameStream) if !ok { t.Fatalf("got unexpected frame (want STREAM): %v", sf) } if got, want := sf.off, sent[sf.id.num()]; got != want { t.Fatalf("got frame: %v\nwant offset: %v", sf, want) } sent[sf.id.num()] = sf.off + int64(len(sf.data)) // Look at the amount of data sent by all streams, excluding the first one. // (The first stream got a head start when it consumed the initial window.) // // We expect that difference between the streams making the most and least progress // so far will be less than the maximum datagram size. minSent := sent[1] maxSent := sent[1] for _, s := range sent[2:] { minSent = min(minSent, s) maxSent = max(maxSent, s) } const maxDelta = maxUDPPayloadSize if d := maxSent - minSent; d > maxDelta { t.Fatalf("stream data sent: %v; delta=%v, want delta <= %v", sent, d, maxDelta) } } } // Final check that every stream sent the full amount of data expected. for num, s := range sent { if s != dataLen { t.Errorf("stream %v sent %v bytes, want %v", num, s, dataLen) } } } func TestStreamsShutdown(t testing.T) { // These tests verify that a stream is removed from the Conn's map of live streams // after it is fully shut down. // // Each case consists of a setup step, after which one stream should exist, // and a shutdown step, after which no streams should remain in the Conn. for _, test := range []struct { name string side streamSide styp streamType setup func(testing.T, testConn, Stream) shutdown func(testing.T, testConn, Stream) }{{ name: "closed", side: localStream, styp: uniStream, setup: func(t testing.T, tc testConn, s Stream) { s.Close() }, shutdown: func(t testing.T, tc testConn, s Stream) { tc.writeAckForAll() }, }, { name: "local close", side: localStream, styp: bidiStream, setup: func(t testing.T, tc testConn, s Stream) { tc.writeFrames(packetType1RTT, debugFrameResetStream{ id: s.id, }) s.Close() }, shutdown: func(t testing.T, tc testConn, s Stream) { tc.writeAckForAll() }, }, { name: "remote reset", side: localStream, styp: bidiStream, setup: func(t testing.T, tc testConn, s Stream) { s.Close() tc.wantIdle("all frames after Close are ignored") tc.writeAckForAll() }, shutdown: func(t testing.T, tc testConn, s Stream) { tc.writeFrames(packetType1RTT, debugFrameResetStream{ id: s.id, }) }, }, { name: "local close", side: remoteStream, styp: uniStream, setup: func(t testing.T, tc testConn, s Stream) { tc.writeFrames(packetType1RTT, debugFrameStream{ id: s.id, fin: true, }) if n, err := s.Read(make([]byte, 16)); n != 0 \|\| err != io.EOF { t.Errorf("Read() = %v, %v; want 0, io.EOF", n, err) } }, shutdown: func(t testing.T, tc testConn, s Stream) { s.CloseRead() }, }} { name := fmt.Sprintf("%v/%v/%v", test.side, test.styp, test.name) t.Run(name, func(t testing.T) { tc, s := newTestConnAndStream(t, serverSide, test.side, test.styp, permissiveTransportParameters) tc.ignoreFrame(frameTypeStreamBase) tc.ignoreFrame(frameTypeStopSending) test.setup(t, tc, s) tc.wantIdle("conn should be idle after setup") if got, want := len(tc.conn.streams.streams), 1; got != want { t.Fatalf("after setup: %v streams in Conn's map; want %v", got, want) } test.shutdown(t, tc, s) tc.wantIdle("conn should be idle after shutdown") if got, want := len(tc.conn.streams.streams), 0; got != want { t.Fatalf("after shutdown: %v streams in Conn's map; want %v", got, want) } }) } } func TestStreamsCreateAndCloseRemote(t testing.T) { // This test exercises creating new streams in response to frames // from the peer, and cleaning up after streams are fully closed. // // It's overfitted to the current implementation, but works through // a number of corner cases in that implementation. // // Disable verbose logging in this test: It sends a lot of packets, // and they're not especially interesting on their own. defer func(vv bool) { testVV = vv }(testVV) testVV = false ctx := canceledContext() tc := newTestConn(t, serverSide, permissiveTransportParameters) tc.handshake() tc.ignoreFrame(frameTypeAck) type op struct { id streamID } type streamOp op type resetOp op type acceptOp op const noStream = math.MaxInt64 stringID := func(id streamID) string { return fmt.Sprintf("%v/%v", id.streamType(), id.num()) } for _, op := range []any{ "opening bidi/5 implicitly opens bidi/0-4", streamOp{newStreamID(clientSide, bidiStream, 5)}, acceptOp{newStreamID(clientSide, bidiStream, 5)}, "bidi/3 was implicitly opened", streamOp{newStreamID(clientSide, bidiStream, 3)}, acceptOp{newStreamID(clientSide, bidiStream, 3)}, resetOp{newStreamID(clientSide, bidiStream, 3)}, "bidi/3 is done, frames for it are discarded", streamOp{newStreamID(clientSide, bidiStream, 3)}, "open and close some uni streams as well", streamOp{newStreamID(clientSide, uniStream, 0)}, acceptOp{newStreamID(clientSide, uniStream, 0)}, streamOp{newStreamID(clientSide, uniStream, 1)}, acceptOp{newStreamID(clientSide, uniStream, 1)}, streamOp{newStreamID(clientSide, uniStream, 2)}, acceptOp{newStreamID(clientSide, uniStream, 2)}, resetOp{newStreamID(clientSide, uniStream, 1)}, resetOp{newStreamID(clientSide, uniStream, 0)}, resetOp{newStreamID(clientSide, uniStream, 2)}, "closing an implicitly opened stream causes us to accept it", resetOp{newStreamID(clientSide, bidiStream, 0)}, acceptOp{newStreamID(clientSide, bidiStream, 0)}, resetOp{newStreamID(clientSide, bidiStream, 1)}, acceptOp{newStreamID(clientSide, bidiStream, 1)}, resetOp{newStreamID(clientSide, bidiStream, 2)}, acceptOp{newStreamID(clientSide, bidiStream, 2)}, "stream bidi/3 was reset previously", resetOp{newStreamID(clientSide, bidiStream, 3)}, resetOp{newStreamID(clientSide, bidiStream, 4)}, acceptOp{newStreamID(clientSide, bidiStream, 4)}, "stream bidi/5 was reset previously", resetOp{newStreamID(clientSide, bidiStream, 5)}, "stream bidi/6 was not implicitly opened", resetOp{newStreamID(clientSide, bidiStream, 6)}, acceptOp{newStreamID(clientSide, bidiStream, 6)}, } { if _, ok := op.(acceptOp); !ok { if s, err := tc.conn.AcceptStream(ctx); err == nil { t.Fatalf("accepted stream %v, want none", stringID(s.id)) } } switch op := op.(type) { case string: t.Log("# " + op) case streamOp: t.Logf("open stream %v", stringID(op.id)) tc.writeFrames(packetType1RTT, debugFrameStream{ id: streamID(op.id), }) case resetOp: t.Logf("reset stream %v", stringID(op.id)) tc.writeFrames(packetType1RTT, debugFrameResetStream{ id: op.id, }) case acceptOp: s := tc.acceptStream() if s.id != op.id { t.Fatalf("accepted stream %v; want stream %v", stringID(s.id), stringID(op.id)) } t.Logf("accepted stream %v", stringID(op.id)) // Immediately close the stream, so the stream becomes done when the // peer closes its end. s.Close() } p := tc.readPacket() if p != nil { tc.writeFrames(p.ptype, debugFrameAck{ ranges: []i64range[packetNumber]{{0, p.num + 1}}, }) } } // Every stream should be fully closed now. // Check that we don't have any state left. if got := len(tc.conn.streams.streams); got != 0 { t.Fatalf("after test, len(tc.conn.streams.streams) = %v, want 0", got) } if tc.conn.streams.queueMeta.head != nil { t.Fatalf("after test, stream send queue is not empty; should be") } } func TestStreamsCreateConcurrency(t testing.T) { cli, srv := newLocalConnPair(t, &Config{}, &Config{}) srvdone := make(chan int) go func() { defer close(srvdone) for streams := 0; ; streams++ { s, err := srv.AcceptStream(context.Background()) if err != nil { srvdone <- streams return } s.Close() } }() var wg sync.WaitGroup const concurrency = 10 const streams = 10 for i := 0; i < concurrency; i++ { wg.Add(1) go func() { defer wg.Done() for j := 0; j < streams; j++ { s, err := cli.NewStream(context.Background()) if err != nil { t.Errorf("NewStream: %v", err) return } s.Flush() _, err = io.ReadAll(s) if err != nil { t.Errorf("ReadFull: %v", err) } s.Close() } }() } wg.Wait() cli.Abort(nil) srv.Abort(nil) if got, want := <-srvdone, concurrencystreams; got != want { t.Errorf("accepted %v streams, want %v", got, want) } } func TestStreamsPTOWithImplicitStream(t testing.T) { ctx := canceledContext() tc := newTestConn(t, serverSide, permissiveTransportParameters) tc.handshake() tc.ignoreFrame(frameTypeAck) // Peer creates stream 1, and implicitly creates stream 0. tc.writeFrames(packetType1RTT, debugFrameStream{ id: newStreamID(clientSide, bidiStream, 1), }) // We accept stream 1 and write data to it. data := []byte("data") s, err := tc.conn.AcceptStream(ctx) if err != nil { t.Fatalf("conn.AcceptStream() = %v, want stream", err) } s.Write(data) s.Flush() tc.wantFrame("data written to stream", packetType1RTT, debugFrameStream{ id: newStreamID(clientSide, bidiStream, 1), data: data, }) // PTO expires, and the data is resent. const pto = true tc.triggerLossOrPTO(packetType1RTT, true) tc.wantFrame("data resent after PTO expires", packetType1RTT, debugFrameStream{ id: newStreamID(clientSide, bidiStream, 1), data: data, }) }	16.06 KB	2025-05-25 12:27
📄 conn_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "bytes" "context" "crypto/tls" "errors" "flag" "fmt" "log/slog" "math" "net/netip" "reflect" "strings" "testing" "time" "golang.org/x/net/quic/qlog" ) var ( testVV = flag.Bool("vv", false, "even more verbose test output") qlogdir = flag.String("qlog", "", "write qlog logs to directory") ) func TestConnTestConn(t testing.T) { tc := newTestConn(t, serverSide) tc.handshake() if got, want := tc.timeUntilEvent(), defaultMaxIdleTimeout; got != want { t.Errorf("new conn timeout=%v, want %v (max_idle_timeout)", got, want) } ranAt, _ := runAsync(tc, func(ctx context.Context) (when time.Time, _ error) { tc.conn.runOnLoop(ctx, func(now time.Time, c Conn) { when = now }) return }).result() if !ranAt.Equal(tc.endpoint.now) { t.Errorf("func ran on loop at %v, want %v", ranAt, tc.endpoint.now) } tc.wait() nextTime := tc.endpoint.now.Add(defaultMaxIdleTimeout / 2) tc.advanceTo(nextTime) ranAt, _ = runAsync(tc, func(ctx context.Context) (when time.Time, _ error) { tc.conn.runOnLoop(ctx, func(now time.Time, c Conn) { when = now }) return }).result() if !ranAt.Equal(nextTime) { t.Errorf("func ran on loop at %v, want %v", ranAt, nextTime) } tc.wait() tc.advanceToTimer() if got := tc.conn.lifetime.state; got != connStateDone { t.Errorf("after advancing to idle timeout, conn state = %v, want done", got) } } type testDatagram struct { packets []testPacket paddedSize int addr netip.AddrPort } func (d testDatagram) String() string { var b strings.Builder fmt.Fprintf(&b, "datagram with %v packets", len(d.packets)) if d.paddedSize > 0 { fmt.Fprintf(&b, " (padded to %v bytes)", d.paddedSize) } b.WriteString(":") for _, p := range d.packets { b.WriteString("\n") b.WriteString(p.String()) } return b.String() } type testPacket struct { ptype packetType header byte version uint32 num packetNumber keyPhaseBit bool keyNumber int dstConnID []byte srcConnID []byte token []byte originalDstConnID []byte // used for encoding Retry packets frames []debugFrame } func (p testPacket) String() string { var b strings.Builder fmt.Fprintf(&b, " %v %v", p.ptype, p.num) if p.version != 0 { fmt.Fprintf(&b, " version=%v", p.version) } if p.srcConnID != nil { fmt.Fprintf(&b, " src={%x}", p.srcConnID) } if p.dstConnID != nil { fmt.Fprintf(&b, " dst={%x}", p.dstConnID) } if p.token != nil { fmt.Fprintf(&b, " token={%x}", p.token) } for _, f := range p.frames { fmt.Fprintf(&b, "\n %v", f) } return b.String() } // maxTestKeyPhases is the maximum number of 1-RTT keys we'll generate in a test. const maxTestKeyPhases = 3 // A testConn is a Conn whose external interactions (sending and receiving packets, // setting timers) can be manipulated in tests. type testConn struct { t testing.T conn Conn endpoint testEndpoint timer time.Time timerLastFired time.Time idlec chan struct{} // only accessed on the conn's loop // Keys are distinct from the conn's keys, // because the test may know about keys before the conn does. // For example, when sending a datagram with coalesced // Initial and Handshake packets to a client conn, // we use Handshake keys to encrypt the packet. // The client only acquires those keys when it processes // the Initial packet. keysInitial fixedKeyPair keysHandshake fixedKeyPair rkeyAppData test1RTTKeys wkeyAppData test1RTTKeys rsecrets [numberSpaceCount]keySecret wsecrets [numberSpaceCount]keySecret // testConn uses a test hook to snoop on the conn's TLS events. // CRYPTO data produced by the conn's QUICConn is placed in // cryptoDataOut. // // The peerTLSConn is is a QUICConn representing the peer. // CRYPTO data produced by the conn is written to peerTLSConn, // and data produced by peerTLSConn is placed in cryptoDataIn. cryptoDataOut map[tls.QUICEncryptionLevel][]byte cryptoDataIn map[tls.QUICEncryptionLevel][]byte peerTLSConn tls.QUICConn // Information about the conn's (fake) peer. peerConnID []byte // source conn id of peer's packets peerNextPacketNum [numberSpaceCount]packetNumber // next packet number to use // Datagrams, packets, and frames sent by the conn, // but not yet processed by the test. sentDatagrams [][]byte sentPackets []testPacket sentFrames []debugFrame lastDatagram testDatagram lastPacket testPacket recvDatagram chan datagram // Transport parameters sent by the conn. sentTransportParameters transportParameters // Frame types to ignore in tests. ignoreFrames map[byte]bool // Values to set in packets sent to the conn. sendKeyNumber int sendKeyPhaseBit bool asyncTestState } type test1RTTKeys struct { hdr headerKey pkt [maxTestKeyPhases]packetKey } type keySecret struct { suite uint16 secret []byte } // newTestConn creates a Conn for testing. // // The Conn's event loop is controlled by the test, // allowing test code to access Conn state directly // by first ensuring the loop goroutine is idle. func newTestConn(t testing.T, side connSide, opts ...any) testConn { t.Helper() config := &Config{ TLSConfig: newTestTLSConfig(side), StatelessResetKey: testStatelessResetKey, QLogLogger: slog.New(qlog.NewJSONHandler(qlog.HandlerOptions{ Level: QLogLevelFrame, Dir: qlogdir, })), } var cids newServerConnIDs if side == serverSide { // The initial connection ID for the server is chosen by the client. cids.srcConnID = testPeerConnID(0) cids.dstConnID = testPeerConnID(-1) cids.originalDstConnID = cids.dstConnID } var configTransportParams []func(transportParameters) var configTestConn []func(testConn) for _, o := range opts { switch o := o.(type) { case func(Config): o(config) case func(tls.Config): o(config.TLSConfig) case func(cids newServerConnIDs): o(&cids) case func(p transportParameters): configTransportParams = append(configTransportParams, o) case func(p testConn): configTestConn = append(configTestConn, o) default: t.Fatalf("unknown newTestConn option %T", o) } } endpoint := newTestEndpoint(t, config) endpoint.configTransportParams = configTransportParams endpoint.configTestConn = configTestConn conn, err := endpoint.e.newConn( endpoint.now, config, side, cids, "", netip.MustParseAddrPort("127.0.0.1:443")) if err != nil { t.Fatal(err) } tc := endpoint.conns[conn] tc.wait() return tc } func newTestConnForConn(t testing.T, endpoint testEndpoint, conn Conn) testConn { t.Helper() tc := &testConn{ t: t, endpoint: endpoint, conn: conn, peerConnID: testPeerConnID(0), ignoreFrames: map[byte]bool{ frameTypePadding: true, // ignore PADDING by default }, cryptoDataOut: make(map[tls.QUICEncryptionLevel][]byte), cryptoDataIn: make(map[tls.QUICEncryptionLevel][]byte), recvDatagram: make(chan datagram), } t.Cleanup(tc.cleanup) for _, f := range endpoint.configTestConn { f(tc) } conn.testHooks = (testConnHooks)(tc) if endpoint.peerTLSConn != nil { tc.peerTLSConn = endpoint.peerTLSConn endpoint.peerTLSConn = nil return tc } peerProvidedParams := defaultTransportParameters() peerProvidedParams.initialSrcConnID = testPeerConnID(0) if conn.side == clientSide { peerProvidedParams.originalDstConnID = testLocalConnID(-1) } for _, f := range endpoint.configTransportParams { f(&peerProvidedParams) } peerQUICConfig := &tls.QUICConfig{TLSConfig: newTestTLSConfig(conn.side.peer())} if conn.side == clientSide { tc.peerTLSConn = tls.QUICServer(peerQUICConfig) } else { tc.peerTLSConn = tls.QUICClient(peerQUICConfig) } tc.peerTLSConn.SetTransportParameters(marshalTransportParameters(peerProvidedParams)) tc.peerTLSConn.Start(context.Background()) t.Cleanup(func() { tc.peerTLSConn.Close() }) return tc } // advance causes time to pass. func (tc testConn) advance(d time.Duration) { tc.t.Helper() tc.endpoint.advance(d) } // advanceTo sets the current time. func (tc testConn) advanceTo(now time.Time) { tc.t.Helper() tc.endpoint.advanceTo(now) } // advanceToTimer sets the current time to the time of the Conn's next timer event. func (tc testConn) advanceToTimer() { if tc.timer.IsZero() { tc.t.Fatalf("advancing to timer, but timer is not set") } tc.advanceTo(tc.timer) } func (tc testConn) timerDelay() time.Duration { if tc.timer.IsZero() { return math.MaxInt64 // infinite } if tc.timer.Before(tc.endpoint.now) { return 0 } return tc.timer.Sub(tc.endpoint.now) } const infiniteDuration = time.Duration(math.MaxInt64) // timeUntilEvent returns the amount of time until the next connection event. func (tc testConn) timeUntilEvent() time.Duration { if tc.timer.IsZero() { return infiniteDuration } if tc.timer.Before(tc.endpoint.now) { return 0 } return tc.timer.Sub(tc.endpoint.now) } // wait blocks until the conn becomes idle. // The conn is idle when it is blocked waiting for a packet to arrive or a timer to expire. // Tests shouldn't need to call wait directly. // testConn methods that wake the Conn event loop will call wait for them. func (tc testConn) wait() { tc.t.Helper() idlec := make(chan struct{}) fail := false tc.conn.sendMsg(func(now time.Time, c Conn) { if tc.idlec != nil { tc.t.Errorf("testConn.wait called concurrently") fail = true close(idlec) } else { // nextMessage will close idlec. tc.idlec = idlec } }) select { case <-idlec: case <-tc.conn.donec: // We may have async ops that can proceed now that the conn is done. tc.wakeAsync() } if fail { panic(fail) } } func (tc testConn) cleanup() { if tc.conn == nil { return } tc.conn.exit() <-tc.conn.donec } func (tc testConn) acceptStream() Stream { tc.t.Helper() s, err := tc.conn.AcceptStream(canceledContext()) if err != nil { tc.t.Fatalf("conn.AcceptStream() = %v, want stream", err) } s.SetReadContext(canceledContext()) s.SetWriteContext(canceledContext()) return s } func logDatagram(t testing.T, text string, d testDatagram) { t.Helper() if !testVV { return } pad := "" if d.paddedSize > 0 { pad = fmt.Sprintf(" (padded to %v)", d.paddedSize) } t.Logf("%v datagram%v", text, pad) for _, p := range d.packets { var s string switch p.ptype { case packetType1RTT: s = fmt.Sprintf(" %v pnum=%v", p.ptype, p.num) default: s = fmt.Sprintf(" %v pnum=%v ver=%v dst={%x} src={%x}", p.ptype, p.num, p.version, p.dstConnID, p.srcConnID) } if p.token != nil { s += fmt.Sprintf(" token={%x}", p.token) } if p.keyPhaseBit { s += fmt.Sprintf(" KeyPhase") } if p.keyNumber != 0 { s += fmt.Sprintf(" keynum=%v", p.keyNumber) } t.Log(s) for _, f := range p.frames { t.Logf(" %v", f) } } } // write sends the Conn a datagram. func (tc testConn) write(d testDatagram) { tc.t.Helper() tc.endpoint.writeDatagram(d) } // writeFrame sends the Conn a datagram containing the given frames. func (tc testConn) writeFrames(ptype packetType, frames ...debugFrame) { tc.t.Helper() space := spaceForPacketType(ptype) dstConnID := tc.conn.connIDState.local[0].cid if tc.conn.connIDState.local[0].seq == -1 && ptype != packetTypeInitial { // Only use the transient connection ID in Initial packets. dstConnID = tc.conn.connIDState.local[1].cid } d := &testDatagram{ packets: []testPacket{{ ptype: ptype, num: tc.peerNextPacketNum[space], keyNumber: tc.sendKeyNumber, keyPhaseBit: tc.sendKeyPhaseBit, frames: frames, version: quicVersion1, dstConnID: dstConnID, srcConnID: tc.peerConnID, }}, addr: tc.conn.peerAddr, } if ptype == packetTypeInitial && tc.conn.side == serverSide { d.paddedSize = 1200 } tc.write(d) } // writeAckForAll sends the Conn a datagram containing an ack for all packets up to the // last one received. func (tc testConn) writeAckForAll() { tc.t.Helper() if tc.lastPacket == nil { return } tc.writeFrames(tc.lastPacket.ptype, debugFrameAck{ ranges: []i64range[packetNumber]{{0, tc.lastPacket.num + 1}}, }) } // writeAckForLatest sends the Conn a datagram containing an ack for the // most recent packet received. func (tc testConn) writeAckForLatest() { tc.t.Helper() if tc.lastPacket == nil { return } tc.writeFrames(tc.lastPacket.ptype, debugFrameAck{ ranges: []i64range[packetNumber]{{tc.lastPacket.num, tc.lastPacket.num + 1}}, }) } // ignoreFrame hides frames of the given type sent by the Conn. func (tc testConn) ignoreFrame(frameType byte) { tc.ignoreFrames[frameType] = true } // readDatagram reads the next datagram sent by the Conn. // It returns nil if the Conn has no more datagrams to send at this time. func (tc testConn) readDatagram() testDatagram { tc.t.Helper() tc.wait() tc.sentPackets = nil tc.sentFrames = nil buf := tc.endpoint.read() if buf == nil { return nil } d := parseTestDatagram(tc.t, tc.endpoint, tc, buf) // Log the datagram before removing ignored frames. // When things go wrong, it's useful to see all the frames. logDatagram(tc.t, "-> conn under test sends", d) typeForFrame := func(f debugFrame) byte { // This is very clunky, and points at a problem // in how we specify what frames to ignore in tests. // // We mark frames to ignore using the frame type, // but we've got a debugFrame data structure here. // Perhaps we should be ignoring frames by debugFrame // type instead: tc.ignoreFrame[debugFrameAck](). switch f := f.(type) { case debugFramePadding: return frameTypePadding case debugFramePing: return frameTypePing case debugFrameAck: return frameTypeAck case debugFrameResetStream: return frameTypeResetStream case debugFrameStopSending: return frameTypeStopSending case debugFrameCrypto: return frameTypeCrypto case debugFrameNewToken: return frameTypeNewToken case debugFrameStream: return frameTypeStreamBase case debugFrameMaxData: return frameTypeMaxData case debugFrameMaxStreamData: return frameTypeMaxStreamData case debugFrameMaxStreams: if f.streamType == bidiStream { return frameTypeMaxStreamsBidi } else { return frameTypeMaxStreamsUni } case debugFrameDataBlocked: return frameTypeDataBlocked case debugFrameStreamDataBlocked: return frameTypeStreamDataBlocked case debugFrameStreamsBlocked: if f.streamType == bidiStream { return frameTypeStreamsBlockedBidi } else { return frameTypeStreamsBlockedUni } case debugFrameNewConnectionID: return frameTypeNewConnectionID case debugFrameRetireConnectionID: return frameTypeRetireConnectionID case debugFramePathChallenge: return frameTypePathChallenge case debugFramePathResponse: return frameTypePathResponse case debugFrameConnectionCloseTransport: return frameTypeConnectionCloseTransport case debugFrameConnectionCloseApplication: return frameTypeConnectionCloseApplication case debugFrameHandshakeDone: return frameTypeHandshakeDone } panic(fmt.Errorf("unhandled frame type %T", f)) } for _, p := range d.packets { var frames []debugFrame for _, f := range p.frames { if !tc.ignoreFrames[typeForFrame(f)] { frames = append(frames, f) } } p.frames = frames } tc.lastDatagram = d return d } // readPacket reads the next packet sent by the Conn. // It returns nil if the Conn has no more packets to send at this time. func (tc testConn) readPacket() testPacket { tc.t.Helper() for len(tc.sentPackets) == 0 { d := tc.readDatagram() if d == nil { return nil } for _, p := range d.packets { if len(p.frames) == 0 { tc.lastPacket = p continue } tc.sentPackets = append(tc.sentPackets, p) } } p := tc.sentPackets[0] tc.sentPackets = tc.sentPackets[1:] tc.lastPacket = p return p } // readFrame reads the next frame sent by the Conn. // It returns nil if the Conn has no more frames to send at this time. func (tc testConn) readFrame() (debugFrame, packetType) { tc.t.Helper() for len(tc.sentFrames) == 0 { p := tc.readPacket() if p == nil { return nil, packetTypeInvalid } tc.sentFrames = p.frames } f := tc.sentFrames[0] tc.sentFrames = tc.sentFrames[1:] return f, tc.lastPacket.ptype } // wantDatagram indicates that we expect the Conn to send a datagram. func (tc testConn) wantDatagram(expectation string, want testDatagram) { tc.t.Helper() got := tc.readDatagram() if !datagramEqual(got, want) { tc.t.Fatalf("%v:\ngot datagram: %v\nwant datagram: %v", expectation, got, want) } } func datagramEqual(a, b testDatagram) bool { if a == nil && b == nil { return true } if a == nil \|\| b == nil { return false } if a.paddedSize != b.paddedSize \|\| a.addr != b.addr \|\| len(a.packets) != len(b.packets) { return false } for i := range a.packets { if !packetEqual(a.packets[i], b.packets[i]) { return false } } return true } // wantPacket indicates that we expect the Conn to send a packet. func (tc testConn) wantPacket(expectation string, want testPacket) { tc.t.Helper() got := tc.readPacket() if !packetEqual(got, want) { tc.t.Fatalf("%v:\ngot packet: %v\nwant packet: %v", expectation, got, want) } } func packetEqual(a, b testPacket) bool { if a == nil && b == nil { return true } if a == nil \|\| b == nil { return false } ac := a ac.frames = nil ac.header = 0 bc := b bc.frames = nil bc.header = 0 if !reflect.DeepEqual(ac, bc) { return false } if len(a.frames) != len(b.frames) { return false } for i := range a.frames { if !frameEqual(a.frames[i], b.frames[i]) { return false } } return true } // wantFrame indicates that we expect the Conn to send a frame. func (tc testConn) wantFrame(expectation string, wantType packetType, want debugFrame) { tc.t.Helper() got, gotType := tc.readFrame() if got == nil { tc.t.Fatalf("%v:\nconnection is idle\nwant %v frame: %v", expectation, wantType, want) } if gotType != wantType { tc.t.Fatalf("%v:\ngot %v packet, want %v\ngot frame: %v", expectation, gotType, wantType, got) } if !frameEqual(got, want) { tc.t.Fatalf("%v:\ngot frame: %v\nwant frame: %v", expectation, got, want) } } func frameEqual(a, b debugFrame) bool { switch af := a.(type) { case debugFrameConnectionCloseTransport: bf, ok := b.(debugFrameConnectionCloseTransport) return ok && af.code == bf.code } return reflect.DeepEqual(a, b) } // wantFrameType indicates that we expect the Conn to send a frame, // although we don't care about the contents. func (tc testConn) wantFrameType(expectation string, wantType packetType, want debugFrame) { tc.t.Helper() got, gotType := tc.readFrame() if got == nil { tc.t.Fatalf("%v:\nconnection is idle\nwant %v frame: %v", expectation, wantType, want) } if gotType != wantType { tc.t.Fatalf("%v:\ngot %v packet, want %v\ngot frame: %v", expectation, gotType, wantType, got) } if reflect.TypeOf(got) != reflect.TypeOf(want) { tc.t.Fatalf("%v:\ngot frame: %v\nwant frame of type: %v", expectation, got, want) } } // wantIdle indicates that we expect the Conn to not send any more frames. func (tc testConn) wantIdle(expectation string) { tc.t.Helper() switch { case len(tc.sentFrames) > 0: tc.t.Fatalf("expect: %v\nunexpectedly got: %v", expectation, tc.sentFrames[0]) case len(tc.sentPackets) > 0: tc.t.Fatalf("expect: %v\nunexpectedly got: %v", expectation, tc.sentPackets[0]) } if f, _ := tc.readFrame(); f != nil { tc.t.Fatalf("expect: %v\nunexpectedly got: %v", expectation, f) } } func encodeTestPacket(t testing.T, tc testConn, p testPacket, pad int) []byte { t.Helper() var w packetWriter w.reset(1200) var pnumMaxAcked packetNumber switch p.ptype { case packetTypeRetry: return encodeRetryPacket(p.originalDstConnID, retryPacket{ srcConnID: p.srcConnID, dstConnID: p.dstConnID, token: p.token, }) case packetType1RTT: w.start1RTTPacket(p.num, pnumMaxAcked, p.dstConnID) default: w.startProtectedLongHeaderPacket(pnumMaxAcked, longPacket{ ptype: p.ptype, version: p.version, num: p.num, dstConnID: p.dstConnID, srcConnID: p.srcConnID, extra: p.token, }) } for _, f := range p.frames { f.write(&w) } w.appendPaddingTo(pad) if p.ptype != packetType1RTT { var k fixedKeys if tc == nil { if p.ptype == packetTypeInitial { k = initialKeys(p.dstConnID, serverSide).r } else { t.Fatalf("sending %v packet with no conn", p.ptype) } } else { switch p.ptype { case packetTypeInitial: k = tc.keysInitial.w case packetTypeHandshake: k = tc.keysHandshake.w } } if !k.isSet() { t.Fatalf("sending %v packet with no write key", p.ptype) } w.finishProtectedLongHeaderPacket(pnumMaxAcked, k, longPacket{ ptype: p.ptype, version: p.version, num: p.num, dstConnID: p.dstConnID, srcConnID: p.srcConnID, extra: p.token, }) } else { if tc == nil \|\| !tc.wkeyAppData.hdr.isSet() { t.Fatalf("sending 1-RTT packet with no write key") } // Somewhat hackish: Generate a temporary updatingKeyPair that will // always use our desired key phase. k := &updatingKeyPair{ w: updatingKeys{ hdr: tc.wkeyAppData.hdr, pkt: [2]packetKey{ tc.wkeyAppData.pkt[p.keyNumber], tc.wkeyAppData.pkt[p.keyNumber], }, }, updateAfter: maxPacketNumber, } if p.keyPhaseBit { k.phase \|= keyPhaseBit } w.finish1RTTPacket(p.num, pnumMaxAcked, p.dstConnID, k) } return w.datagram() } func parseTestDatagram(t testing.T, te testEndpoint, tc testConn, buf []byte) testDatagram { t.Helper() bufSize := len(buf) d := &testDatagram{} size := len(buf) for len(buf) > 0 { if buf[0] == 0 { d.paddedSize = bufSize break } ptype := getPacketType(buf) switch ptype { case packetTypeRetry: retry, ok := parseRetryPacket(buf, te.lastInitialDstConnID) if !ok { t.Fatalf("could not parse %v packet", ptype) } return &testDatagram{ packets: []testPacket{{ ptype: packetTypeRetry, dstConnID: retry.dstConnID, srcConnID: retry.srcConnID, token: retry.token, }}, } case packetTypeInitial, packetTypeHandshake: var k fixedKeys if tc == nil { if ptype == packetTypeInitial { p, _ := parseGenericLongHeaderPacket(buf) k = initialKeys(p.srcConnID, serverSide).w } else { t.Fatalf("reading %v packet with no conn", ptype) } } else { switch ptype { case packetTypeInitial: k = tc.keysInitial.r case packetTypeHandshake: k = tc.keysHandshake.r } } if !k.isSet() { t.Fatalf("reading %v packet with no read key", ptype) } var pnumMax packetNumber // TODO: Track packet numbers. p, n := parseLongHeaderPacket(buf, k, pnumMax) if n < 0 { t.Fatalf("packet parse error") } frames, err := parseTestFrames(t, p.payload) if err != nil { t.Fatal(err) } var token []byte if ptype == packetTypeInitial && len(p.extra) > 0 { token = p.extra } d.packets = append(d.packets, &testPacket{ ptype: p.ptype, header: buf[0], version: p.version, num: p.num, dstConnID: p.dstConnID, srcConnID: p.srcConnID, token: token, frames: frames, }) buf = buf[n:] case packetType1RTT: if tc == nil \|\| !tc.rkeyAppData.hdr.isSet() { t.Fatalf("reading 1-RTT packet with no read key") } var pnumMax packetNumber // TODO: Track packet numbers. pnumOff := 1 + len(tc.peerConnID) // Try unprotecting the packet with the first maxTestKeyPhases keys. var phase int var pnum packetNumber var hdr []byte var pay []byte var err error for phase = 0; phase < maxTestKeyPhases; phase++ { b := append([]byte{}, buf...) hdr, pay, pnum, err = tc.rkeyAppData.hdr.unprotect(b, pnumOff, pnumMax) if err != nil { t.Fatalf("1-RTT packet header parse error") } k := tc.rkeyAppData.pkt[phase] pay, err = k.unprotect(hdr, pay, pnum) if err == nil { break } } if err != nil { t.Fatalf("1-RTT packet payload parse error") } frames, err := parseTestFrames(t, pay) if err != nil { t.Fatal(err) } d.packets = append(d.packets, &testPacket{ ptype: packetType1RTT, header: hdr[0], num: pnum, dstConnID: hdr[1:][:len(tc.peerConnID)], keyPhaseBit: hdr[0]&keyPhaseBit != 0, keyNumber: phase, frames: frames, }) buf = buf[len(buf):] default: t.Fatalf("unhandled packet type %v", ptype) } } // This is rather hackish: If the last frame in the last packet // in the datagram is PADDING, then remove it and record // the padded size in the testDatagram.paddedSize. // // This makes it easier to write a test that expects a datagram // padded to 1200 bytes. if len(d.packets) > 0 && len(d.packets[len(d.packets)-1].frames) > 0 { p := d.packets[len(d.packets)-1] f := p.frames[len(p.frames)-1] if _, ok := f.(debugFramePadding); ok { p.frames = p.frames[:len(p.frames)-1] d.paddedSize = size } } return d } func parseTestFrames(t testing.T, payload []byte) ([]debugFrame, error) { t.Helper() var frames []debugFrame for len(payload) > 0 { f, n := parseDebugFrame(payload) if n < 0 { return nil, errors.New("error parsing frames") } frames = append(frames, f) payload = payload[n:] } return frames, nil } func spaceForPacketType(ptype packetType) numberSpace { switch ptype { case packetTypeInitial: return initialSpace case packetType0RTT: panic("TODO: packetType0RTT") case packetTypeHandshake: return handshakeSpace case packetTypeRetry: panic("retry packets have no number space") case packetType1RTT: return appDataSpace } panic("unknown packet type") } // testConnHooks implements connTestHooks. type testConnHooks testConn func (tc testConnHooks) init() { tc.conn.keysAppData.updateAfter = maxPacketNumber // disable key updates tc.keysInitial.r = tc.conn.keysInitial.w tc.keysInitial.w = tc.conn.keysInitial.r if tc.conn.side == serverSide { tc.endpoint.acceptQueue = append(tc.endpoint.acceptQueue, (testConn)(tc)) } } // handleTLSEvent processes TLS events generated by // the connection under test's tls.QUICConn. // // We maintain a second tls.QUICConn representing the peer, // and feed the TLS handshake data into it. // // We stash TLS handshake data from both sides in the testConn, // where it can be used by tests. // // We snoop packet protection keys out of the tls.QUICConns, // and verify that both sides of the connection are getting // matching keys. func (tc testConnHooks) handleTLSEvent(e tls.QUICEvent) { checkKey := func(typ string, secrets [numberSpaceCount]keySecret, e tls.QUICEvent) { var space numberSpace switch { case e.Level == tls.QUICEncryptionLevelHandshake: space = handshakeSpace case e.Level == tls.QUICEncryptionLevelApplication: space = appDataSpace default: tc.t.Errorf("unexpected encryption level %v", e.Level) return } if secrets[space].secret == nil { secrets[space].suite = e.Suite secrets[space].secret = append([]byte{}, e.Data...) } else if secrets[space].suite != e.Suite \|\| !bytes.Equal(secrets[space].secret, e.Data) { tc.t.Errorf("%v key mismatch for level for level %v", typ, e.Level) } } setAppDataKey := func(suite uint16, secret []byte, k test1RTTKeys) { k.hdr.init(suite, secret) for i := 0; i < len(k.pkt); i++ { k.pkt[i].init(suite, secret) secret = updateSecret(suite, secret) } } switch e.Kind { case tls.QUICSetReadSecret: checkKey("write", &tc.wsecrets, e) switch e.Level { case tls.QUICEncryptionLevelHandshake: tc.keysHandshake.w.init(e.Suite, e.Data) case tls.QUICEncryptionLevelApplication: setAppDataKey(e.Suite, e.Data, &tc.wkeyAppData) } case tls.QUICSetWriteSecret: checkKey("read", &tc.rsecrets, e) switch e.Level { case tls.QUICEncryptionLevelHandshake: tc.keysHandshake.r.init(e.Suite, e.Data) case tls.QUICEncryptionLevelApplication: setAppDataKey(e.Suite, e.Data, &tc.rkeyAppData) } case tls.QUICWriteData: tc.cryptoDataOut[e.Level] = append(tc.cryptoDataOut[e.Level], e.Data...) tc.peerTLSConn.HandleData(e.Level, e.Data) } for { e := tc.peerTLSConn.NextEvent() switch e.Kind { case tls.QUICNoEvent: return case tls.QUICSetReadSecret: checkKey("write", &tc.rsecrets, e) switch e.Level { case tls.QUICEncryptionLevelHandshake: tc.keysHandshake.r.init(e.Suite, e.Data) case tls.QUICEncryptionLevelApplication: setAppDataKey(e.Suite, e.Data, &tc.rkeyAppData) } case tls.QUICSetWriteSecret: checkKey("read", &tc.wsecrets, e) switch e.Level { case tls.QUICEncryptionLevelHandshake: tc.keysHandshake.w.init(e.Suite, e.Data) case tls.QUICEncryptionLevelApplication: setAppDataKey(e.Suite, e.Data, &tc.wkeyAppData) } case tls.QUICWriteData: tc.cryptoDataIn[e.Level] = append(tc.cryptoDataIn[e.Level], e.Data...) case tls.QUICTransportParameters: p, err := unmarshalTransportParams(e.Data) if err != nil { tc.t.Logf("sent unparseable transport parameters %x %v", e.Data, err) } else { tc.sentTransportParameters = &p } } } } // nextMessage is called by the Conn's event loop to request its next event. func (tc testConnHooks) nextMessage(msgc chan any, timer time.Time) (now time.Time, m any) { tc.timer = timer for { if !timer.IsZero() && !timer.After(tc.endpoint.now) { if timer.Equal(tc.timerLastFired) { // If the connection timer fires at time T, the Conn should take some // action to advance the timer into the future. If the Conn reschedules // the timer for the same time, it isn't making progress and we have a bug. tc.t.Errorf("connection timer spinning; now=%v timer=%v", tc.endpoint.now, timer) } else { tc.timerLastFired = timer return tc.endpoint.now, timerEvent{} } } select { case m := <-msgc: return tc.endpoint.now, m default: } if !tc.wakeAsync() { break } } // If the message queue is empty, then the conn is idle. if tc.idlec != nil { idlec := tc.idlec tc.idlec = nil close(idlec) } m = <-msgc return tc.endpoint.now, m } func (tc testConnHooks) newConnID(seq int64) ([]byte, error) { return testLocalConnID(seq), nil } func (tc testConnHooks) timeNow() time.Time { return tc.endpoint.now } // testLocalConnID returns the connection ID with a given sequence number // used by a Conn under test. func testLocalConnID(seq int64) []byte { cid := make([]byte, connIDLen) copy(cid, []byte{0xc0, 0xff, 0xee}) cid[len(cid)-1] = byte(seq) return cid } // testPeerConnID returns the connection ID with a given sequence number // used by the fake peer of a Conn under test. func testPeerConnID(seq int64) []byte { // Use a different length than we choose for our own conn ids, // to help catch any bad assumptions. return []byte{0xbe, 0xee, 0xff, byte(seq)} } func testPeerStatelessResetToken(seq int64) statelessResetToken { return statelessResetToken{ 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, 0xee, byte(seq), } } // canceledContext returns a canceled Context. // // Functions which take a context preference progress over cancelation. // For example, a read with a canceled context will return data if any is available. // Tests use canceled contexts to perform non-blocking operations. func canceledContext() context.Context { ctx, cancel := context.WithCancel(context.Background()) cancel() return ctx }	31.18 KB	2025-05-25 12:27
📄 crypto_stream.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic // "Implementations MUST support buffering at least 4096 bytes of data // received in out-of-order CRYPTO frames." // https://www.rfc-editor.org/rfc/rfc9000.html#section-7.5-2 // // 4096 is too small for real-world cases, however, so we allow more. const cryptoBufferSize = 1 << 20 // A cryptoStream is the stream of data passed in CRYPTO frames. // There is one cryptoStream per packet number space. type cryptoStream struct { // CRYPTO data received from the peer. in pipe inset rangeset[int64] // bytes received // CRYPTO data queued for transmission to the peer. out pipe outunsent rangeset[int64] // bytes in need of sending outacked rangeset[int64] // bytes acked by peer } // handleCrypto processes data received in a CRYPTO frame. func (s cryptoStream) handleCrypto(off int64, b []byte, f func([]byte) error) error { end := off + int64(len(b)) if end-s.inset.min() > cryptoBufferSize { return localTransportError{ code: errCryptoBufferExceeded, reason: "crypto buffer exceeded", } } s.inset.add(off, end) if off == s.in.start { // Fast path: This is the next chunk of data in the stream, // so just handle it immediately. if err := f(b); err != nil { return err } s.in.discardBefore(end) } else { // This is either data we've already processed, // data we can't process yet, or a mix of both. s.in.writeAt(b, off) } // s.in.start is the next byte in sequence. // If it's in s.inset, we have bytes to provide. // If it isn't, we don't--we're either out of data, // or only have data that comes after the next byte. if !s.inset.contains(s.in.start) { return nil } // size is the size of the first contiguous chunk of bytes // that have not been processed yet. size := int(s.inset[0].end - s.in.start) if size <= 0 { return nil } err := s.in.read(s.in.start, size, f) s.in.discardBefore(s.inset[0].end) return err } // write queues data for sending to the peer. // It does not block or limit the amount of buffered data. // QUIC connections don't communicate the amount of CRYPTO data they are willing to buffer, // so we send what we have and the peer can close the connection if it is too much. func (s cryptoStream) write(b []byte) { start := s.out.end s.out.writeAt(b, start) s.outunsent.add(start, s.out.end) } // ackOrLoss reports that an CRYPTO frame sent by us has been acknowledged by the peer, or lost. func (s cryptoStream) ackOrLoss(start, end int64, fate packetFate) { switch fate { case packetAcked: s.outacked.add(start, end) s.outunsent.sub(start, end) // If this ack is for data at the start of the send buffer, we can now discard it. if s.outacked.contains(s.out.start) { s.out.discardBefore(s.outacked[0].end) } case packetLost: // Mark everything lost, but not previously acked, as needing retransmission. // We do this by adding all the lost bytes to outunsent, and then // removing everything already acked. s.outunsent.add(start, end) for _, a := range s.outacked { s.outunsent.sub(a.start, a.end) } } } // dataToSend reports what data should be sent in CRYPTO frames to the peer. // It calls f with each range of data to send. // f uses sendData to get the bytes to send, and returns the number of bytes sent. // dataToSend calls f until no data is left, or f returns 0. // // This function is unusually indirect (why not just return a []byte, // or implement io.Reader?). // // Returning a []byte to the caller either requires that we store the // data to send contiguously (which we don't), allocate a temporary buffer // and copy into it (inefficient), or return less data than we have available // (requires complexity to avoid unnecessarily breaking data across frames). // // Accepting a []byte from the caller (io.Reader) makes packet construction // difficult. Since CRYPTO data is encoded with a varint length prefix, the // location of the data depends on the length of the data. (We could hardcode // a 2-byte length, of course.) // // Instead, we tell the caller how much data is, the caller figures out where // to put it (and possibly decides that it doesn't have space for this data // in the packet after all), and the caller then makes a separate call to // copy the data it wants into position. func (s cryptoStream) dataToSend(pto bool, f func(off, size int64) (sent int64)) { for { off, size := dataToSend(s.out.start, s.out.end, s.outunsent, s.outacked, pto) if size == 0 { return } n := f(off, size) if n == 0 \|\| pto { return } } } // sendData fills b with data to send to the peer, starting at off, // and marks the data as sent. The caller must have already ascertained // that there is data to send in this region using dataToSend. func (s cryptoStream) sendData(off int64, b []byte) { s.out.copy(off, b) s.outunsent.sub(off, off+int64(len(b))) } // discardKeys is called when the packet protection keys for the stream are dropped. func (s cryptoStream) discardKeys() error { if s.in.end-s.in.start != 0 { // The peer sent some unprocessed CRYPTO data that we're about to discard. // Close the connetion with a TLS unexpected_message alert. // https://www.rfc-editor.org/rfc/rfc5246#section-7.2.2 const unexpectedMessage = 10 return localTransportError{ code: errTLSBase + unexpectedMessage, reason: "excess crypto data", } } // Discard any unacked (but presumably received) data in our output buffer. s.out.discardBefore(s.out.end) *s = cryptoStream{} return nil }	5.55 KB	2025-05-25 12:27
📄 crypto_stream_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "crypto/rand" "reflect" "testing" ) func TestCryptoStreamReceive(t testing.T) { data := make([]byte, 1<<20) rand.Read(data) // doesn't need to be crypto/rand, but non-deprecated and harmless type frame struct { start int64 end int64 want int } for _, test := range []struct { name string frames []frame }{{ name: "linear", frames: []frame{{ start: 0, end: 1000, want: 1000, }, { start: 1000, end: 2000, want: 2000, }, { // larger than any realistic packet can hold start: 2000, end: 1 << 20, want: 1 << 20, }}, }, { name: "out of order", frames: []frame{{ start: 1000, end: 2000, }, { start: 2000, end: 3000, }, { start: 0, end: 1000, want: 3000, }}, }, { name: "resent", frames: []frame{{ start: 0, end: 1000, want: 1000, }, { start: 0, end: 1000, want: 1000, }, { start: 1000, end: 2000, want: 2000, }, { start: 0, end: 1000, want: 2000, }, { start: 1000, end: 2000, want: 2000, }}, }, { name: "overlapping", frames: []frame{{ start: 0, end: 1000, want: 1000, }, { start: 3000, end: 4000, want: 1000, }, { start: 2000, end: 3000, want: 1000, }, { start: 1000, end: 3000, want: 4000, }}, }, { name: "resent consumed data", frames: []frame{{ start: 0, end: 1000, want: 1000, }, { start: 1000, end: 2000, want: 2000, }, { start: 0, end: 1000, want: 2000, }}, }} { t.Run(test.name, func(t testing.T) { var s cryptoStream var got []byte for _, f := range test.frames { t.Logf("receive [%v,%v)", f.start, f.end) s.handleCrypto( f.start, data[f.start:f.end], func(b []byte) error { t.Logf("got new bytes [%v,%v)", len(got), len(got)+len(b)) got = append(got, b...) return nil }, ) if len(got) != f.want { t.Fatalf("have bytes [0,%v), want [0,%v)", len(got), f.want) } for i := range got { if got[i] != data[i] { t.Fatalf("byte %v of received data = %v, want %v", i, got[i], data[i]) } } } }) } } func TestCryptoStreamSends(t testing.T) { data := make([]byte, 1<<20) rand.Read(data) // doesn't need to be crypto/rand, but non-deprecated and harmless type ( sendOp i64range[int64] ackOp i64range[int64] lossOp i64range[int64] ) for _, test := range []struct { name string size int64 ops []any wantSend []i64range[int64] wantPTOSend []i64range[int64] }{{ name: "writes with data remaining", size: 4000, ops: []any{ sendOp{0, 1000}, sendOp{1000, 2000}, sendOp{2000, 3000}, }, wantSend: []i64range[int64]{ {3000, 4000}, }, wantPTOSend: []i64range[int64]{ {0, 4000}, }, }, { name: "lost data is resent", size: 4000, ops: []any{ sendOp{0, 1000}, sendOp{1000, 2000}, sendOp{2000, 3000}, sendOp{3000, 4000}, lossOp{1000, 2000}, lossOp{3000, 4000}, }, wantSend: []i64range[int64]{ {1000, 2000}, {3000, 4000}, }, wantPTOSend: []i64range[int64]{ {0, 4000}, }, }, { name: "acked data at start of range", size: 4000, ops: []any{ sendOp{0, 4000}, ackOp{0, 1000}, ackOp{1000, 2000}, ackOp{2000, 3000}, }, wantSend: nil, wantPTOSend: []i64range[int64]{ {3000, 4000}, }, }, { name: "acked data is not resent on pto", size: 4000, ops: []any{ sendOp{0, 4000}, ackOp{1000, 2000}, }, wantSend: nil, wantPTOSend: []i64range[int64]{ {0, 1000}, }, }, { // This is an unusual, but possible scenario: // Data is sent, resent, one of the two sends is acked, and the other is lost. name: "acked and then lost data is not resent", size: 4000, ops: []any{ sendOp{0, 4000}, sendOp{1000, 2000}, // resent, no-op ackOp{1000, 2000}, lossOp{1000, 2000}, }, wantSend: nil, wantPTOSend: []i64range[int64]{ {0, 1000}, }, }, { // The opposite of the above scenario: data is marked lost, and then acked // before being resent. name: "lost and then acked data is not resent", size: 4000, ops: []any{ sendOp{0, 4000}, sendOp{1000, 2000}, // resent, no-op lossOp{1000, 2000}, ackOp{1000, 2000}, }, wantSend: nil, wantPTOSend: []i64range[int64]{ {0, 1000}, }, }} { t.Run(test.name, func(t testing.T) { var s cryptoStream s.write(data[:test.size]) for _, op := range test.ops { switch op := op.(type) { case sendOp: t.Logf("send [%v,%v)", op.start, op.end) b := make([]byte, op.end-op.start) s.sendData(op.start, b) case ackOp: t.Logf("ack [%v,%v)", op.start, op.end) s.ackOrLoss(op.start, op.end, packetAcked) case lossOp: t.Logf("loss [%v,%v)", op.start, op.end) s.ackOrLoss(op.start, op.end, packetLost) default: t.Fatalf("unhandled type %T", op) } } var gotSend []i64range[int64] s.dataToSend(true, func(off, size int64) (wrote int64) { gotSend = append(gotSend, i64range[int64]{off, off + size}) return 0 }) if !reflect.DeepEqual(gotSend, test.wantPTOSend) { t.Fatalf("got data to send on PTO: %v, want %v", gotSend, test.wantPTOSend) } gotSend = nil s.dataToSend(false, func(off, size int64) (wrote int64) { gotSend = append(gotSend, i64range[int64]{off, off + size}) b := make([]byte, size) s.sendData(off, b) return int64(len(b)) }) if !reflect.DeepEqual(gotSend, test.wantSend) { t.Fatalf("got data to send: %v, want %v", gotSend, test.wantSend) } }) } }	5.67 KB	2025-05-25 12:27
📄 dgram.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "net/netip" "sync" ) type datagram struct { b []byte localAddr netip.AddrPort peerAddr netip.AddrPort ecn ecnBits } // Explicit Congestion Notification bits. // // https://www.rfc-editor.org/rfc/rfc3168.html#section-5 type ecnBits byte const ( ecnMask = 0b000000_11 ecnNotECT = 0b000000_00 ecnECT1 = 0b000000_01 ecnECT0 = 0b000000_10 ecnCE = 0b000000_11 ) var datagramPool = sync.Pool{ New: func() any { return &datagram{ b: make([]byte, maxUDPPayloadSize), } }, } func newDatagram() datagram { m := datagramPool.Get().(datagram) m = datagram{ b: m.b[:cap(m.b)], } return m } func (m datagram) recycle() { if cap(m.b) != maxUDPPayloadSize { return } datagramPool.Put(m) }	940 B	2025-05-25 12:27
📄 doc.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Package quic implements the QUIC protocol. // // This package is a work in progress. // It is not ready for production usage. // Its API is subject to change without notice. // // This package is low-level. // Most users will use it indirectly through an HTTP/3 implementation. // // # Usage // // An [Endpoint] sends and receives traffic on a network address. // Create an Endpoint to either accept inbound QUIC connections // or create outbound ones. // // A [Conn] is a QUIC connection. // // A [Stream] is a QUIC stream, an ordered, reliable byte stream. // // # Cancelation // // All blocking operations may be canceled using a context.Context. // When performing an operation with a canceled context, the operation // will succeed if doing so does not require blocking. For example, // reading from a stream will return data when buffered data is available, // even if the stream context is canceled. // // # Limitations // // This package is a work in progress. // Known limitations include: // // - Performance is untuned. // - 0-RTT is not supported. // - Address migration is not supported. // - Server preferred addresses are not supported. // - The latency spin bit is not supported. // - Stream send/receive windows are configurable, // but are fixed and do not adapt to available throughput. // - Path MTU discovery is not implemented. package quic	1.51 KB	2025-05-25 12:27
📄 endpoint.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "context" "crypto/rand" "errors" "net" "net/netip" "sync" "sync/atomic" "time" ) // An Endpoint handles QUIC traffic on a network address. // It can accept inbound connections or create outbound ones. // // Multiple goroutines may invoke methods on an Endpoint simultaneously. type Endpoint struct { listenConfig Config packetConn packetConn testHooks endpointTestHooks resetGen statelessResetTokenGenerator retry retryState acceptQueue queue[Conn] // new inbound connections connsMap connsMap // only accessed by the listen loop connsMu sync.Mutex conns map[Conn]struct{} closing bool // set when Close is called closec chan struct{} // closed when the listen loop exits } type endpointTestHooks interface { timeNow() time.Time newConn(c Conn) } // A packetConn is the interface to sending and receiving UDP packets. type packetConn interface { Close() error LocalAddr() netip.AddrPort Read(f func(datagram)) Write(datagram) error } // Listen listens on a local network address. // // The config is used to for connections accepted by the endpoint. // If the config is nil, the endpoint will not accept connections. func Listen(network, address string, listenConfig Config) (Endpoint, error) { if listenConfig != nil && listenConfig.TLSConfig == nil { return nil, errors.New("TLSConfig is not set") } a, err := net.ResolveUDPAddr(network, address) if err != nil { return nil, err } udpConn, err := net.ListenUDP(network, a) if err != nil { return nil, err } pc, err := newNetUDPConn(udpConn) if err != nil { return nil, err } return newEndpoint(pc, listenConfig, nil) } func newEndpoint(pc packetConn, config Config, hooks endpointTestHooks) (Endpoint, error) { e := &Endpoint{ listenConfig: config, packetConn: pc, testHooks: hooks, conns: make(map[Conn]struct{}), acceptQueue: newQueue[Conn](), closec: make(chan struct{}), } var statelessResetKey [32]byte if config != nil { statelessResetKey = config.StatelessResetKey } e.resetGen.init(statelessResetKey) e.connsMap.init() if config != nil && config.RequireAddressValidation { if err := e.retry.init(); err != nil { return nil, err } } go e.listen() return e, nil } // LocalAddr returns the local network address. func (e Endpoint) LocalAddr() netip.AddrPort { return e.packetConn.LocalAddr() } // Close closes the Endpoint. // Any blocked operations on the Endpoint or associated Conns and Stream will be unblocked // and return errors. // // Close aborts every open connection. // Data in stream read and write buffers is discarded. // It waits for the peers of any open connection to acknowledge the connection has been closed. func (e Endpoint) Close(ctx context.Context) error { e.acceptQueue.close(errors.New("endpoint closed")) // It isn't safe to call Conn.Abort or conn.exit with connsMu held, // so copy the list of conns. var conns []Conn e.connsMu.Lock() if !e.closing { e.closing = true // setting e.closing prevents new conns from being created for c := range e.conns { conns = append(conns, c) } if len(e.conns) == 0 { e.packetConn.Close() } } e.connsMu.Unlock() for _, c := range conns { c.Abort(localTransportError{code: errNo}) } select { case <-e.closec: case <-ctx.Done(): for _, c := range conns { c.exit() } return ctx.Err() } return nil } // Accept waits for and returns the next connection. func (e Endpoint) Accept(ctx context.Context) (Conn, error) { return e.acceptQueue.get(ctx, nil) } // Dial creates and returns a connection to a network address. // The config cannot be nil. func (e Endpoint) Dial(ctx context.Context, network, address string, config Config) (Conn, error) { u, err := net.ResolveUDPAddr(network, address) if err != nil { return nil, err } addr := u.AddrPort() addr = netip.AddrPortFrom(addr.Addr().Unmap(), addr.Port()) c, err := e.newConn(time.Now(), config, clientSide, newServerConnIDs{}, address, addr) if err != nil { return nil, err } if err := c.waitReady(ctx); err != nil { c.Abort(nil) return nil, err } return c, nil } func (e Endpoint) newConn(now time.Time, config Config, side connSide, cids newServerConnIDs, peerHostname string, peerAddr netip.AddrPort) (Conn, error) { e.connsMu.Lock() defer e.connsMu.Unlock() if e.closing { return nil, errors.New("endpoint closed") } c, err := newConn(now, side, cids, peerHostname, peerAddr, config, e) if err != nil { return nil, err } e.conns[c] = struct{}{} return c, nil } // serverConnEstablished is called by a conn when the handshake completes // for an inbound (serverSide) connection. func (e Endpoint) serverConnEstablished(c Conn) { e.acceptQueue.put(c) } // connDrained is called by a conn when it leaves the draining state, // either when the peer acknowledges connection closure or the drain timeout expires. func (e Endpoint) connDrained(c Conn) { var cids [][]byte for i := range c.connIDState.local { cids = append(cids, c.connIDState.local[i].cid) } var tokens []statelessResetToken for i := range c.connIDState.remote { tokens = append(tokens, c.connIDState.remote[i].resetToken) } e.connsMap.updateConnIDs(func(conns connsMap) { for _, cid := range cids { conns.retireConnID(c, cid) } for _, token := range tokens { conns.retireResetToken(c, token) } }) e.connsMu.Lock() defer e.connsMu.Unlock() delete(e.conns, c) if e.closing && len(e.conns) == 0 { e.packetConn.Close() } } func (e Endpoint) listen() { defer close(e.closec) e.packetConn.Read(func(m datagram) { if e.connsMap.updateNeeded.Load() { e.connsMap.applyUpdates() } e.handleDatagram(m) }) } func (e Endpoint) handleDatagram(m datagram) { dstConnID, ok := dstConnIDForDatagram(m.b) if !ok { m.recycle() return } c := e.connsMap.byConnID[string(dstConnID)] if c == nil { // TODO: Move this branch into a separate goroutine to avoid blocking // the endpoint while processing packets. e.handleUnknownDestinationDatagram(m) return } // TODO: This can block the endpoint while waiting for the conn to accept the dgram. // Think about buffering between the receive loop and the conn. c.sendMsg(m) } func (e Endpoint) handleUnknownDestinationDatagram(m datagram) { defer func() { if m != nil { m.recycle() } }() const minimumValidPacketSize = 21 if len(m.b) < minimumValidPacketSize { return } var now time.Time if e.testHooks != nil { now = e.testHooks.timeNow() } else { now = time.Now() } // Check to see if this is a stateless reset. var token statelessResetToken copy(token[:], m.b[len(m.b)-len(token):]) if c := e.connsMap.byResetToken[token]; c != nil { c.sendMsg(func(now time.Time, c Conn) { c.handleStatelessReset(now, token) }) return } // If this is a 1-RTT packet, there's nothing productive we can do with it. // Send a stateless reset if possible. if !isLongHeader(m.b[0]) { e.maybeSendStatelessReset(m.b, m.peerAddr) return } p, ok := parseGenericLongHeaderPacket(m.b) if !ok \|\| len(m.b) < paddedInitialDatagramSize { return } switch p.version { case quicVersion1: case 0: // Version Negotiation for an unknown connection. return default: // Unknown version. e.sendVersionNegotiation(p, m.peerAddr) return } if getPacketType(m.b) != packetTypeInitial { // This packet isn't trying to create a new connection. // It might be associated with some connection we've lost state for. // We are technically permitted to send a stateless reset for // a long-header packet, but this isn't generally useful. See: // https://www.rfc-editor.org/rfc/rfc9000#section-10.3-16 return } if e.listenConfig == nil { // We are not configured to accept connections. return } cids := newServerConnIDs{ srcConnID: p.srcConnID, dstConnID: p.dstConnID, } if e.listenConfig.RequireAddressValidation { var ok bool cids.retrySrcConnID = p.dstConnID cids.originalDstConnID, ok = e.validateInitialAddress(now, p, m.peerAddr) if !ok { return } } else { cids.originalDstConnID = p.dstConnID } var err error c, err := e.newConn(now, e.listenConfig, serverSide, cids, "", m.peerAddr) if err != nil { // The accept queue is probably full. // We could send a CONNECTION_CLOSE to the peer to reject the connection. // Currently, we just drop the datagram. // https://www.rfc-editor.org/rfc/rfc9000.html#section-5.2.2-5 return } c.sendMsg(m) m = nil // don't recycle, sendMsg takes ownership } func (e Endpoint) maybeSendStatelessReset(b []byte, peerAddr netip.AddrPort) { if !e.resetGen.canReset { // Config.StatelessResetKey isn't set, so we don't send stateless resets. return } // The smallest possible valid packet a peer can send us is: // 1 byte of header // connIDLen bytes of destination connection ID // 1 byte of packet number // 1 byte of payload // 16 bytes AEAD expansion if len(b) < 1+connIDLen+1+1+16 { return } // TODO: Rate limit stateless resets. cid := b[1:][:connIDLen] token := e.resetGen.tokenForConnID(cid) // We want to generate a stateless reset that is as short as possible, // but long enough to be difficult to distinguish from a 1-RTT packet. // // The minimal 1-RTT packet is: // 1 byte of header // 0-20 bytes of destination connection ID // 1-4 bytes of packet number // 1 byte of payload // 16 bytes AEAD expansion // // Assuming the maximum possible connection ID and packet number size, // this gives 1 + 20 + 4 + 1 + 16 = 42 bytes. // // We also must generate a stateless reset that is shorter than the datagram // we are responding to, in order to ensure that reset loops terminate. // // See: https://www.rfc-editor.org/rfc/rfc9000#section-10.3 size := min(len(b)-1, 42) // Reuse the input buffer for generating the stateless reset. b = b[:size] rand.Read(b[:len(b)-statelessResetTokenLen]) b[0] &^= headerFormLong // clear long header bit b[0] \|= fixedBit // set fixed bit copy(b[len(b)-statelessResetTokenLen:], token[:]) e.sendDatagram(datagram{ b: b, peerAddr: peerAddr, }) } func (e Endpoint) sendVersionNegotiation(p genericLongPacket, peerAddr netip.AddrPort) { m := newDatagram() m.b = appendVersionNegotiation(m.b[:0], p.srcConnID, p.dstConnID, quicVersion1) m.peerAddr = peerAddr e.sendDatagram(m) m.recycle() } func (e Endpoint) sendConnectionClose(in genericLongPacket, peerAddr netip.AddrPort, code transportError) { keys := initialKeys(in.dstConnID, serverSide) var w packetWriter p := longPacket{ ptype: packetTypeInitial, version: quicVersion1, num: 0, dstConnID: in.srcConnID, srcConnID: in.dstConnID, } const pnumMaxAcked = 0 w.reset(paddedInitialDatagramSize) w.startProtectedLongHeaderPacket(pnumMaxAcked, p) w.appendConnectionCloseTransportFrame(code, 0, "") w.finishProtectedLongHeaderPacket(pnumMaxAcked, keys.w, p) buf := w.datagram() if len(buf) == 0 { return } e.sendDatagram(datagram{ b: buf, peerAddr: peerAddr, }) } func (e Endpoint) sendDatagram(dgram datagram) error { return e.packetConn.Write(dgram) } // A connsMap is an endpoint's mapping of conn ids and reset tokens to conns. type connsMap struct { byConnID map[string]Conn byResetToken map[statelessResetToken]Conn updateMu sync.Mutex updateNeeded atomic.Bool updates []func(connsMap) } func (m connsMap) init() { m.byConnID = map[string]Conn{} m.byResetToken = map[statelessResetToken]Conn{} } func (m connsMap) addConnID(c Conn, cid []byte) { m.byConnID[string(cid)] = c } func (m connsMap) retireConnID(c Conn, cid []byte) { delete(m.byConnID, string(cid)) } func (m connsMap) addResetToken(c Conn, token statelessResetToken) { m.byResetToken[token] = c } func (m connsMap) retireResetToken(c Conn, token statelessResetToken) { delete(m.byResetToken, token) } func (m connsMap) updateConnIDs(f func(connsMap)) { m.updateMu.Lock() defer m.updateMu.Unlock() m.updates = append(m.updates, f) m.updateNeeded.Store(true) } // applyConnIDUpdates is called by the datagram receive loop to update its connection ID map. func (m connsMap) applyUpdates() { m.updateMu.Lock() defer m.updateMu.Unlock() for _, f := range m.updates { f(m) } clear(m.updates) m.updates = m.updates[:0] m.updateNeeded.Store(false) }	12.31 KB	2025-05-25 12:27
📄 endpoint_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "bytes" "context" "crypto/tls" "io" "log/slog" "net/netip" "runtime" "testing" "time" "golang.org/x/net/quic/qlog" ) func TestConnect(t testing.T) { newLocalConnPair(t, &Config{}, &Config{}) } func TestConnectDefaultTLSConfig(t testing.T) { serverConfig := newTestTLSConfigWithMoreDefaults(serverSide) clientConfig := newTestTLSConfigWithMoreDefaults(clientSide) newLocalConnPair(t, &Config{TLSConfig: serverConfig}, &Config{TLSConfig: clientConfig}) } func TestStreamTransfer(t testing.T) { ctx := context.Background() cli, srv := newLocalConnPair(t, &Config{}, &Config{}) data := makeTestData(1 << 20) srvdone := make(chan struct{}) go func() { defer close(srvdone) s, err := srv.AcceptStream(ctx) if err != nil { t.Errorf("AcceptStream: %v", err) return } b, err := io.ReadAll(s) if err != nil { t.Errorf("io.ReadAll(s): %v", err) return } if !bytes.Equal(b, data) { t.Errorf("read data mismatch (got %v bytes, want %v", len(b), len(data)) } if err := s.Close(); err != nil { t.Errorf("s.Close() = %v", err) } }() s, err := cli.NewSendOnlyStream(ctx) if err != nil { t.Fatalf("NewStream: %v", err) } n, err := io.Copy(s, bytes.NewBuffer(data)) if n != int64(len(data)) \|\| err != nil { t.Fatalf("io.Copy(s, data) = %v, %v; want %v, nil", n, err, len(data)) } if err := s.Close(); err != nil { t.Fatalf("s.Close() = %v", err) } } func newLocalConnPair(t testing.TB, conf1, conf2 Config) (clientConn, serverConn Conn) { switch runtime.GOOS { case "plan9": t.Skipf("ReadMsgUDP not supported on %s", runtime.GOOS) } t.Helper() ctx := context.Background() e1 := newLocalEndpoint(t, serverSide, conf1) e2 := newLocalEndpoint(t, clientSide, conf2) conf2 = makeTestConfig(conf2, clientSide) c2, err := e2.Dial(ctx, "udp", e1.LocalAddr().String(), conf2) if err != nil { t.Fatal(err) } c1, err := e1.Accept(ctx) if err != nil { t.Fatal(err) } return c2, c1 } func newLocalEndpoint(t testing.TB, side connSide, conf Config) Endpoint { t.Helper() conf = makeTestConfig(conf, side) e, err := Listen("udp", "127.0.0.1:0", conf) if err != nil { t.Fatal(err) } t.Cleanup(func() { e.Close(canceledContext()) }) return e } func makeTestConfig(conf Config, side connSide) Config { if conf == nil { return nil } newConf := conf conf = &newConf if conf.TLSConfig == nil { conf.TLSConfig = newTestTLSConfig(side) } if conf.QLogLogger == nil { conf.QLogLogger = slog.New(qlog.NewJSONHandler(qlog.HandlerOptions{ Level: QLogLevelFrame, Dir: qlogdir, })) } return conf } type testEndpoint struct { t testing.T e Endpoint now time.Time recvc chan datagram idlec chan struct{} conns map[Conn]testConn acceptQueue []testConn configTransportParams []func(transportParameters) configTestConn []func(testConn) sentDatagrams [][]byte peerTLSConn tls.QUICConn lastInitialDstConnID []byte // for parsing Retry packets } func newTestEndpoint(t testing.T, config Config) testEndpoint { te := &testEndpoint{ t: t, now: time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC), recvc: make(chan datagram), idlec: make(chan struct{}), conns: make(map[Conn]testConn), } var err error te.e, err = newEndpoint((testEndpointUDPConn)(te), config, (testEndpointHooks)(te)) if err != nil { t.Fatal(err) } t.Cleanup(te.cleanup) return te } func (te testEndpoint) cleanup() { te.e.Close(canceledContext()) } func (te testEndpoint) wait() { select { case te.idlec <- struct{}{}: case <-te.e.closec: } for _, tc := range te.conns { tc.wait() } } // accept returns a server connection from the endpoint. // Unlike Endpoint.Accept, connections are available as soon as they are created. func (te testEndpoint) accept() testConn { if len(te.acceptQueue) == 0 { te.t.Fatalf("accept: expected available conn, but found none") } tc := te.acceptQueue[0] te.acceptQueue = te.acceptQueue[1:] return tc } func (te testEndpoint) write(d datagram) { te.recvc <- d te.wait() } var testClientAddr = netip.MustParseAddrPort("10.0.0.1:8000") func (te testEndpoint) writeDatagram(d testDatagram) { te.t.Helper() logDatagram(te.t, "<- endpoint under test receives", d) var buf []byte for _, p := range d.packets { tc := te.connForDestination(p.dstConnID) if p.ptype != packetTypeRetry && tc != nil { space := spaceForPacketType(p.ptype) if p.num >= tc.peerNextPacketNum[space] { tc.peerNextPacketNum[space] = p.num + 1 } } if p.ptype == packetTypeInitial { te.lastInitialDstConnID = p.dstConnID } pad := 0 if p.ptype == packetType1RTT { pad = d.paddedSize - len(buf) } buf = append(buf, encodeTestPacket(te.t, tc, p, pad)...) } for len(buf) < d.paddedSize { buf = append(buf, 0) } te.write(&datagram{ b: buf, peerAddr: d.addr, }) } func (te testEndpoint) connForDestination(dstConnID []byte) testConn { for _, tc := range te.conns { for _, loc := range tc.conn.connIDState.local { if bytes.Equal(loc.cid, dstConnID) { return tc } } } return nil } func (te testEndpoint) connForSource(srcConnID []byte) testConn { for _, tc := range te.conns { for _, loc := range tc.conn.connIDState.remote { if bytes.Equal(loc.cid, srcConnID) { return tc } } } return nil } func (te testEndpoint) read() []byte { te.t.Helper() te.wait() if len(te.sentDatagrams) == 0 { return nil } d := te.sentDatagrams[0] te.sentDatagrams = te.sentDatagrams[1:] return d } func (te testEndpoint) readDatagram() testDatagram { te.t.Helper() buf := te.read() if buf == nil { return nil } p, _ := parseGenericLongHeaderPacket(buf) tc := te.connForSource(p.dstConnID) d := parseTestDatagram(te.t, te, tc, buf) logDatagram(te.t, "-> endpoint under test sends", d) return d } // wantDatagram indicates that we expect the Endpoint to send a datagram. func (te testEndpoint) wantDatagram(expectation string, want testDatagram) { te.t.Helper() got := te.readDatagram() if !datagramEqual(got, want) { te.t.Fatalf("%v:\ngot datagram: %v\nwant datagram: %v", expectation, got, want) } } // wantIdle indicates that we expect the Endpoint to not send any more datagrams. func (te testEndpoint) wantIdle(expectation string) { if got := te.readDatagram(); got != nil { te.t.Fatalf("expect: %v\nunexpectedly got: %v", expectation, got) } } // advance causes time to pass. func (te testEndpoint) advance(d time.Duration) { te.t.Helper() te.advanceTo(te.now.Add(d)) } // advanceTo sets the current time. func (te testEndpoint) advanceTo(now time.Time) { te.t.Helper() if te.now.After(now) { te.t.Fatalf("time moved backwards: %v -> %v", te.now, now) } te.now = now for _, tc := range te.conns { if !tc.timer.After(te.now) { tc.conn.sendMsg(timerEvent{}) tc.wait() } } } // testEndpointHooks implements endpointTestHooks. type testEndpointHooks testEndpoint func (te testEndpointHooks) timeNow() time.Time { return te.now } func (te testEndpointHooks) newConn(c Conn) { tc := newTestConnForConn(te.t, (testEndpoint)(te), c) te.conns[c] = tc } // testEndpointUDPConn implements UDPConn. type testEndpointUDPConn testEndpoint func (te testEndpointUDPConn) Close() error { close(te.recvc) return nil } func (te testEndpointUDPConn) LocalAddr() netip.AddrPort { return netip.MustParseAddrPort("127.0.0.1:443") } func (te testEndpointUDPConn) Read(f func(datagram)) { for { select { case d, ok := <-te.recvc: if !ok { return } f(d) case <-te.idlec: } } } func (te *testEndpointUDPConn) Write(dgram datagram) error { te.sentDatagrams = append(te.sentDatagrams, append([]byte(nil), dgram.b...)) return nil }	7.88 KB	2025-05-25 12:27
📄 errors.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "fmt" ) // A transportError is a transport error code from RFC 9000 Section 20.1. // // The transportError type doesn't implement the error interface to ensure we always // distinguish between errors sent to and received from the peer. // See the localTransportError and peerTransportError types below. type transportError uint64 // https://www.rfc-editor.org/rfc/rfc9000.html#section-20.1 const ( errNo = transportError(0x00) errInternal = transportError(0x01) errConnectionRefused = transportError(0x02) errFlowControl = transportError(0x03) errStreamLimit = transportError(0x04) errStreamState = transportError(0x05) errFinalSize = transportError(0x06) errFrameEncoding = transportError(0x07) errTransportParameter = transportError(0x08) errConnectionIDLimit = transportError(0x09) errProtocolViolation = transportError(0x0a) errInvalidToken = transportError(0x0b) errApplicationError = transportError(0x0c) errCryptoBufferExceeded = transportError(0x0d) errKeyUpdateError = transportError(0x0e) errAEADLimitReached = transportError(0x0f) errNoViablePath = transportError(0x10) errTLSBase = transportError(0x0100) // 0x0100-0x01ff; base + TLS code ) func (e transportError) String() string { switch e { case errNo: return "NO_ERROR" case errInternal: return "INTERNAL_ERROR" case errConnectionRefused: return "CONNECTION_REFUSED" case errFlowControl: return "FLOW_CONTROL_ERROR" case errStreamLimit: return "STREAM_LIMIT_ERROR" case errStreamState: return "STREAM_STATE_ERROR" case errFinalSize: return "FINAL_SIZE_ERROR" case errFrameEncoding: return "FRAME_ENCODING_ERROR" case errTransportParameter: return "TRANSPORT_PARAMETER_ERROR" case errConnectionIDLimit: return "CONNECTION_ID_LIMIT_ERROR" case errProtocolViolation: return "PROTOCOL_VIOLATION" case errInvalidToken: return "INVALID_TOKEN" case errApplicationError: return "APPLICATION_ERROR" case errCryptoBufferExceeded: return "CRYPTO_BUFFER_EXCEEDED" case errKeyUpdateError: return "KEY_UPDATE_ERROR" case errAEADLimitReached: return "AEAD_LIMIT_REACHED" case errNoViablePath: return "NO_VIABLE_PATH" } if e >= 0x0100 && e <= 0x01ff { return fmt.Sprintf("CRYPTO_ERROR(%v)", uint64(e)&0xff) } return fmt.Sprintf("ERROR %d", uint64(e)) } // A localTransportError is an error sent to the peer. type localTransportError struct { code transportError reason string } func (e localTransportError) Error() string { if e.reason == "" { return fmt.Sprintf("closed connection: %v", e.code) } return fmt.Sprintf("closed connection: %v: %q", e.code, e.reason) } // A peerTransportError is an error received from the peer. type peerTransportError struct { code transportError reason string } func (e peerTransportError) Error() string { return fmt.Sprintf("peer closed connection: %v: %q", e.code, e.reason) } // A StreamErrorCode is an application protocol error code (RFC 9000, Section 20.2) // indicating whay a stream is being closed. type StreamErrorCode uint64 func (e StreamErrorCode) Error() string { return fmt.Sprintf("stream error code %v", uint64(e)) } // An ApplicationError is an application protocol error code (RFC 9000, Section 20.2). // Application protocol errors may be sent when terminating a stream or connection. type ApplicationError struct { Code uint64 Reason string } func (e ApplicationError) Error() string { // TODO: Include the Reason string here, but sanitize it first. return fmt.Sprintf("AppError %v", e.Code) } // Is reports a match if err is an ApplicationError with a matching Code. func (e ApplicationError) Is(err error) bool { e2, ok := err.(ApplicationError) return ok && e2.Code == e.Code }	3.94 KB	2025-05-25 12:27
📄 files_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "bytes" "os" "strings" "testing" ) // TestFiles checks that every file in this package has a build constraint on Go 1.21. // // The QUIC implementation depends on crypto/tls features added in Go 1.21, // so there's no point in trying to build on anything older. // // Drop this test when the x/net go.mod depends on 1.21 or newer. func TestFiles(t *testing.T) { f, err := os.Open(".") if err != nil { t.Fatal(err) } names, err := f.Readdirnames(-1) if err != nil { t.Fatal(err) } for _, name := range names { if !strings.HasSuffix(name, ".go") { continue } b, err := os.ReadFile(name) if err != nil { t.Fatal(err) } // Check for copyright header while we're in here. if !bytes.Contains(b, []byte("The Go Authors.")) { t.Errorf("%v: missing copyright", name) } // doc.go doesn't need a build constraint. if name == "doc.go" { continue } if !bytes.Contains(b, []byte("//go:build go1.21")) { t.Errorf("%v: missing constraint on go1.21", name) } } }	1.18 KB	2025-05-25 12:27
📄 frame_debug.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "fmt" "log/slog" "strconv" "time" ) // A debugFrame is a representation of the contents of a QUIC frame, // used for debug logs and testing but not the primary serving path. type debugFrame interface { String() string write(w packetWriter) bool LogValue() slog.Value } func parseDebugFrame(b []byte) (f debugFrame, n int) { if len(b) == 0 { return nil, -1 } switch b[0] { case frameTypePadding: f, n = parseDebugFramePadding(b) case frameTypePing: f, n = parseDebugFramePing(b) case frameTypeAck, frameTypeAckECN: f, n = parseDebugFrameAck(b) case frameTypeResetStream: f, n = parseDebugFrameResetStream(b) case frameTypeStopSending: f, n = parseDebugFrameStopSending(b) case frameTypeCrypto: f, n = parseDebugFrameCrypto(b) case frameTypeNewToken: f, n = parseDebugFrameNewToken(b) case frameTypeStreamBase, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f: f, n = parseDebugFrameStream(b) case frameTypeMaxData: f, n = parseDebugFrameMaxData(b) case frameTypeMaxStreamData: f, n = parseDebugFrameMaxStreamData(b) case frameTypeMaxStreamsBidi, frameTypeMaxStreamsUni: f, n = parseDebugFrameMaxStreams(b) case frameTypeDataBlocked: f, n = parseDebugFrameDataBlocked(b) case frameTypeStreamDataBlocked: f, n = parseDebugFrameStreamDataBlocked(b) case frameTypeStreamsBlockedBidi, frameTypeStreamsBlockedUni: f, n = parseDebugFrameStreamsBlocked(b) case frameTypeNewConnectionID: f, n = parseDebugFrameNewConnectionID(b) case frameTypeRetireConnectionID: f, n = parseDebugFrameRetireConnectionID(b) case frameTypePathChallenge: f, n = parseDebugFramePathChallenge(b) case frameTypePathResponse: f, n = parseDebugFramePathResponse(b) case frameTypeConnectionCloseTransport: f, n = parseDebugFrameConnectionCloseTransport(b) case frameTypeConnectionCloseApplication: f, n = parseDebugFrameConnectionCloseApplication(b) case frameTypeHandshakeDone: f, n = parseDebugFrameHandshakeDone(b) default: return nil, -1 } return f, n } // debugFramePadding is a sequence of PADDING frames. type debugFramePadding struct { size int to int // alternate for writing packets: pad to } func parseDebugFramePadding(b []byte) (f debugFramePadding, n int) { for n < len(b) && b[n] == frameTypePadding { n++ } f.size = n return f, n } func (f debugFramePadding) String() string { return fmt.Sprintf("PADDING%v", f.size) } func (f debugFramePadding) write(w packetWriter) bool { if w.avail() == 0 { return false } if f.to > 0 { w.appendPaddingTo(f.to) return true } for i := 0; i < f.size && w.avail() > 0; i++ { w.b = append(w.b, frameTypePadding) } return true } func (f debugFramePadding) LogValue() slog.Value { return slog.GroupValue( slog.String("frame_type", "padding"), slog.Int("length", f.size), ) } // debugFramePing is a PING frame. type debugFramePing struct{} func parseDebugFramePing(b []byte) (f debugFramePing, n int) { return f, 1 } func (f debugFramePing) String() string { return "PING" } func (f debugFramePing) write(w packetWriter) bool { return w.appendPingFrame() } func (f debugFramePing) LogValue() slog.Value { return slog.GroupValue( slog.String("frame_type", "ping"), ) } // debugFrameAck is an ACK frame. type debugFrameAck struct { ackDelay unscaledAckDelay ranges []i64range[packetNumber] } func parseDebugFrameAck(b []byte) (f debugFrameAck, n int) { f.ranges = nil _, f.ackDelay, n = consumeAckFrame(b, func(_ int, start, end packetNumber) { f.ranges = append(f.ranges, i64range[packetNumber]{ start: start, end: end, }) }) // Ranges are parsed high to low; reverse ranges slice to order them low to high. for i := 0; i < len(f.ranges)/2; i++ { j := len(f.ranges) - 1 f.ranges[i], f.ranges[j] = f.ranges[j], f.ranges[i] } return f, n } func (f debugFrameAck) String() string { s := fmt.Sprintf("ACK Delay=%v", f.ackDelay) for _, r := range f.ranges { s += fmt.Sprintf(" [%v,%v)", r.start, r.end) } return s } func (f debugFrameAck) write(w packetWriter) bool { return w.appendAckFrame(rangeset[packetNumber](f.ranges), f.ackDelay) } func (f debugFrameAck) LogValue() slog.Value { return slog.StringValue("error: debugFrameAck should not appear as a slog Value") } // debugFrameScaledAck is an ACK frame with scaled ACK Delay. // // This type is used in qlog events, which need access to the delay as a duration. type debugFrameScaledAck struct { ackDelay time.Duration ranges []i64range[packetNumber] } func (f debugFrameScaledAck) LogValue() slog.Value { var ackDelay slog.Attr if f.ackDelay >= 0 { ackDelay = slog.Duration("ack_delay", f.ackDelay) } return slog.GroupValue( slog.String("frame_type", "ack"), // Rather than trying to convert the ack ranges into the slog data model, // pass a value that can JSON-encode itself. slog.Any("acked_ranges", debugAckRanges(f.ranges)), ackDelay, ) } type debugAckRanges []i64range[packetNumber] // AppendJSON appends a JSON encoding of the ack ranges to b, and returns it. // This is different than the standard json.Marshaler, but more efficient. // Since we only use this in cooperation with the qlog package, // encoding/json compatibility is irrelevant. func (r debugAckRanges) AppendJSON(b []byte) []byte { b = append(b, '[') for i, ar := range r { start, end := ar.start, ar.end-1 // qlog ranges are closed-closed if i != 0 { b = append(b, ',') } b = append(b, '[') b = strconv.AppendInt(b, int64(start), 10) if start != end { b = append(b, ',') b = strconv.AppendInt(b, int64(end), 10) } b = append(b, ']') } b = append(b, ']') return b } func (r debugAckRanges) String() string { return string(r.AppendJSON(nil)) } // debugFrameResetStream is a RESET_STREAM frame. type debugFrameResetStream struct { id streamID code uint64 finalSize int64 } func parseDebugFrameResetStream(b []byte) (f debugFrameResetStream, n int) { f.id, f.code, f.finalSize, n = consumeResetStreamFrame(b) return f, n } func (f debugFrameResetStream) String() string { return fmt.Sprintf("RESET_STREAM ID=%v Code=%v FinalSize=%v", f.id, f.code, f.finalSize) } func (f debugFrameResetStream) write(w packetWriter) bool { return w.appendResetStreamFrame(f.id, f.code, f.finalSize) } func (f debugFrameResetStream) LogValue() slog.Value { return slog.GroupValue( slog.String("frame_type", "reset_stream"), slog.Uint64("stream_id", uint64(f.id)), slog.Uint64("final_size", uint64(f.finalSize)), ) } // debugFrameStopSending is a STOP_SENDING frame. type debugFrameStopSending struct { id streamID code uint64 } func parseDebugFrameStopSending(b []byte) (f debugFrameStopSending, n int) { f.id, f.code, n = consumeStopSendingFrame(b) return f, n } func (f debugFrameStopSending) String() string { return fmt.Sprintf("STOP_SENDING ID=%v Code=%v", f.id, f.code) } func (f debugFrameStopSending) write(w packetWriter) bool { return w.appendStopSendingFrame(f.id, f.code) } func (f debugFrameStopSending) LogValue() slog.Value { return slog.GroupValue( slog.String("frame_type", "stop_sending"), slog.Uint64("stream_id", uint64(f.id)), slog.Uint64("error_code", uint64(f.code)), ) } // debugFrameCrypto is a CRYPTO frame. type debugFrameCrypto struct { off int64 data []byte } func parseDebugFrameCrypto(b []byte) (f debugFrameCrypto, n int) { f.off, f.data, n = consumeCryptoFrame(b) return f, n } func (f debugFrameCrypto) String() string { return fmt.Sprintf("CRYPTO Offset=%v Length=%v", f.off, len(f.data)) } func (f debugFrameCrypto) write(w packetWriter) bool { b, added := w.appendCryptoFrame(f.off, len(f.data)) copy(b, f.data) return added } func (f debugFrameCrypto) LogValue() slog.Value { return slog.GroupValue( slog.String("frame_type", "crypto"), slog.Int64("offset", f.off), slog.Int("length", len(f.data)), ) } // debugFrameNewToken is a NEW_TOKEN frame. type debugFrameNewToken struct { token []byte } func parseDebugFrameNewToken(b []byte) (f debugFrameNewToken, n int) { f.token, n = consumeNewTokenFrame(b) return f, n } func (f debugFrameNewToken) String() string { return fmt.Sprintf("NEW_TOKEN Token=%x", f.token) } func (f debugFrameNewToken) write(w packetWriter) bool { return w.appendNewTokenFrame(f.token) } func (f debugFrameNewToken) LogValue() slog.Value { return slog.GroupValue( slog.String("frame_type", "new_token"), slogHexstring("token", f.token), ) } // debugFrameStream is a STREAM frame. type debugFrameStream struct { id streamID fin bool off int64 data []byte } func parseDebugFrameStream(b []byte) (f debugFrameStream, n int) { f.id, f.off, f.fin, f.data, n = consumeStreamFrame(b) return f, n } func (f debugFrameStream) String() string { fin := "" if f.fin { fin = " FIN" } return fmt.Sprintf("STREAM ID=%v%v Offset=%v Length=%v", f.id, fin, f.off, len(f.data)) } func (f debugFrameStream) write(w packetWriter) bool { b, added := w.appendStreamFrame(f.id, f.off, len(f.data), f.fin) copy(b, f.data) return added } func (f debugFrameStream) LogValue() slog.Value { var fin slog.Attr if f.fin { fin = slog.Bool("fin", true) } return slog.GroupValue( slog.String("frame_type", "stream"), slog.Uint64("stream_id", uint64(f.id)), slog.Int64("offset", f.off), slog.Int("length", len(f.data)), fin, ) } // debugFrameMaxData is a MAX_DATA frame. type debugFrameMaxData struct { max int64 } func parseDebugFrameMaxData(b []byte) (f debugFrameMaxData, n int) { f.max, n = consumeMaxDataFrame(b) return f, n } func (f debugFrameMaxData) String() string { return fmt.Sprintf("MAX_DATA Max=%v", f.max) } func (f debugFrameMaxData) write(w packetWriter) bool { return w.appendMaxDataFrame(f.max) } func (f debugFrameMaxData) LogValue() slog.Value { return slog.GroupValue( slog.String("frame_type", "max_data"), slog.Int64("maximum", f.max), ) } // debugFrameMaxStreamData is a MAX_STREAM_DATA frame. type debugFrameMaxStreamData struct { id streamID max int64 } func parseDebugFrameMaxStreamData(b []byte) (f debugFrameMaxStreamData, n int) { f.id, f.max, n = consumeMaxStreamDataFrame(b) return f, n } func (f debugFrameMaxStreamData) String() string { return fmt.Sprintf("MAX_STREAM_DATA ID=%v Max=%v", f.id, f.max) } func (f debugFrameMaxStreamData) write(w packetWriter) bool { return w.appendMaxStreamDataFrame(f.id, f.max) } func (f debugFrameMaxStreamData) LogValue() slog.Value { return slog.GroupValue( slog.String("frame_type", "max_stream_data"), slog.Uint64("stream_id", uint64(f.id)), slog.Int64("maximum", f.max), ) } // debugFrameMaxStreams is a MAX_STREAMS frame. type debugFrameMaxStreams struct { streamType streamType max int64 } func parseDebugFrameMaxStreams(b []byte) (f debugFrameMaxStreams, n int) { f.streamType, f.max, n = consumeMaxStreamsFrame(b) return f, n } func (f debugFrameMaxStreams) String() string { return fmt.Sprintf("MAX_STREAMS Type=%v Max=%v", f.streamType, f.max) } func (f debugFrameMaxStreams) write(w packetWriter) bool { return w.appendMaxStreamsFrame(f.streamType, f.max) } func (f debugFrameMaxStreams) LogValue() slog.Value { return slog.GroupValue( slog.String("frame_type", "max_streams"), slog.String("stream_type", f.streamType.qlogString()), slog.Int64("maximum", f.max), ) } // debugFrameDataBlocked is a DATA_BLOCKED frame. type debugFrameDataBlocked struct { max int64 } func parseDebugFrameDataBlocked(b []byte) (f debugFrameDataBlocked, n int) { f.max, n = consumeDataBlockedFrame(b) return f, n } func (f debugFrameDataBlocked) String() string { return fmt.Sprintf("DATA_BLOCKED Max=%v", f.max) } func (f debugFrameDataBlocked) write(w packetWriter) bool { return w.appendDataBlockedFrame(f.max) } func (f debugFrameDataBlocked) LogValue() slog.Value { return slog.GroupValue( slog.String("frame_type", "data_blocked"), slog.Int64("limit", f.max), ) } // debugFrameStreamDataBlocked is a STREAM_DATA_BLOCKED frame. type debugFrameStreamDataBlocked struct { id streamID max int64 } func parseDebugFrameStreamDataBlocked(b []byte) (f debugFrameStreamDataBlocked, n int) { f.id, f.max, n = consumeStreamDataBlockedFrame(b) return f, n } func (f debugFrameStreamDataBlocked) String() string { return fmt.Sprintf("STREAM_DATA_BLOCKED ID=%v Max=%v", f.id, f.max) } func (f debugFrameStreamDataBlocked) write(w packetWriter) bool { return w.appendStreamDataBlockedFrame(f.id, f.max) } func (f debugFrameStreamDataBlocked) LogValue() slog.Value { return slog.GroupValue( slog.String("frame_type", "stream_data_blocked"), slog.Uint64("stream_id", uint64(f.id)), slog.Int64("limit", f.max), ) } // debugFrameStreamsBlocked is a STREAMS_BLOCKED frame. type debugFrameStreamsBlocked struct { streamType streamType max int64 } func parseDebugFrameStreamsBlocked(b []byte) (f debugFrameStreamsBlocked, n int) { f.streamType, f.max, n = consumeStreamsBlockedFrame(b) return f, n } func (f debugFrameStreamsBlocked) String() string { return fmt.Sprintf("STREAMS_BLOCKED Type=%v Max=%v", f.streamType, f.max) } func (f debugFrameStreamsBlocked) write(w packetWriter) bool { return w.appendStreamsBlockedFrame(f.streamType, f.max) } func (f debugFrameStreamsBlocked) LogValue() slog.Value { return slog.GroupValue( slog.String("frame_type", "streams_blocked"), slog.String("stream_type", f.streamType.qlogString()), slog.Int64("limit", f.max), ) } // debugFrameNewConnectionID is a NEW_CONNECTION_ID frame. type debugFrameNewConnectionID struct { seq int64 retirePriorTo int64 connID []byte token statelessResetToken } func parseDebugFrameNewConnectionID(b []byte) (f debugFrameNewConnectionID, n int) { f.seq, f.retirePriorTo, f.connID, f.token, n = consumeNewConnectionIDFrame(b) return f, n } func (f debugFrameNewConnectionID) String() string { return fmt.Sprintf("NEW_CONNECTION_ID Seq=%v Retire=%v ID=%x Token=%x", f.seq, f.retirePriorTo, f.connID, f.token[:]) } func (f debugFrameNewConnectionID) write(w packetWriter) bool { return w.appendNewConnectionIDFrame(f.seq, f.retirePriorTo, f.connID, f.token) } func (f debugFrameNewConnectionID) LogValue() slog.Value { return slog.GroupValue( slog.String("frame_type", "new_connection_id"), slog.Int64("sequence_number", f.seq), slog.Int64("retire_prior_to", f.retirePriorTo), slogHexstring("connection_id", f.connID), slogHexstring("stateless_reset_token", f.token[:]), ) } // debugFrameRetireConnectionID is a NEW_CONNECTION_ID frame. type debugFrameRetireConnectionID struct { seq int64 } func parseDebugFrameRetireConnectionID(b []byte) (f debugFrameRetireConnectionID, n int) { f.seq, n = consumeRetireConnectionIDFrame(b) return f, n } func (f debugFrameRetireConnectionID) String() string { return fmt.Sprintf("RETIRE_CONNECTION_ID Seq=%v", f.seq) } func (f debugFrameRetireConnectionID) write(w packetWriter) bool { return w.appendRetireConnectionIDFrame(f.seq) } func (f debugFrameRetireConnectionID) LogValue() slog.Value { return slog.GroupValue( slog.String("frame_type", "retire_connection_id"), slog.Int64("sequence_number", f.seq), ) } // debugFramePathChallenge is a PATH_CHALLENGE frame. type debugFramePathChallenge struct { data pathChallengeData } func parseDebugFramePathChallenge(b []byte) (f debugFramePathChallenge, n int) { f.data, n = consumePathChallengeFrame(b) return f, n } func (f debugFramePathChallenge) String() string { return fmt.Sprintf("PATH_CHALLENGE Data=%x", f.data) } func (f debugFramePathChallenge) write(w packetWriter) bool { return w.appendPathChallengeFrame(f.data) } func (f debugFramePathChallenge) LogValue() slog.Value { return slog.GroupValue( slog.String("frame_type", "path_challenge"), slog.String("data", fmt.Sprintf("%x", f.data)), ) } // debugFramePathResponse is a PATH_RESPONSE frame. type debugFramePathResponse struct { data pathChallengeData } func parseDebugFramePathResponse(b []byte) (f debugFramePathResponse, n int) { f.data, n = consumePathResponseFrame(b) return f, n } func (f debugFramePathResponse) String() string { return fmt.Sprintf("PATH_RESPONSE Data=%x", f.data) } func (f debugFramePathResponse) write(w packetWriter) bool { return w.appendPathResponseFrame(f.data) } func (f debugFramePathResponse) LogValue() slog.Value { return slog.GroupValue( slog.String("frame_type", "path_response"), slog.String("data", fmt.Sprintf("%x", f.data)), ) } // debugFrameConnectionCloseTransport is a CONNECTION_CLOSE frame carrying a transport error. type debugFrameConnectionCloseTransport struct { code transportError frameType uint64 reason string } func parseDebugFrameConnectionCloseTransport(b []byte) (f debugFrameConnectionCloseTransport, n int) { f.code, f.frameType, f.reason, n = consumeConnectionCloseTransportFrame(b) return f, n } func (f debugFrameConnectionCloseTransport) String() string { s := fmt.Sprintf("CONNECTION_CLOSE Code=%v", f.code) if f.frameType != 0 { s += fmt.Sprintf(" FrameType=%v", f.frameType) } if f.reason != "" { s += fmt.Sprintf(" Reason=%q", f.reason) } return s } func (f debugFrameConnectionCloseTransport) write(w packetWriter) bool { return w.appendConnectionCloseTransportFrame(f.code, f.frameType, f.reason) } func (f debugFrameConnectionCloseTransport) LogValue() slog.Value { return slog.GroupValue( slog.String("frame_type", "connection_close"), slog.String("error_space", "transport"), slog.Uint64("error_code_value", uint64(f.code)), slog.String("reason", f.reason), ) } // debugFrameConnectionCloseApplication is a CONNECTION_CLOSE frame carrying an application error. type debugFrameConnectionCloseApplication struct { code uint64 reason string } func parseDebugFrameConnectionCloseApplication(b []byte) (f debugFrameConnectionCloseApplication, n int) { f.code, f.reason, n = consumeConnectionCloseApplicationFrame(b) return f, n } func (f debugFrameConnectionCloseApplication) String() string { s := fmt.Sprintf("CONNECTION_CLOSE AppCode=%v", f.code) if f.reason != "" { s += fmt.Sprintf(" Reason=%q", f.reason) } return s } func (f debugFrameConnectionCloseApplication) write(w packetWriter) bool { return w.appendConnectionCloseApplicationFrame(f.code, f.reason) } func (f debugFrameConnectionCloseApplication) LogValue() slog.Value { return slog.GroupValue( slog.String("frame_type", "connection_close"), slog.String("error_space", "application"), slog.Uint64("error_code_value", uint64(f.code)), slog.String("reason", f.reason), ) } // debugFrameHandshakeDone is a HANDSHAKE_DONE frame. type debugFrameHandshakeDone struct{} func parseDebugFrameHandshakeDone(b []byte) (f debugFrameHandshakeDone, n int) { return f, 1 } func (f debugFrameHandshakeDone) String() string { return "HANDSHAKE_DONE" } func (f debugFrameHandshakeDone) write(w *packetWriter) bool { return w.appendHandshakeDoneFrame() } func (f debugFrameHandshakeDone) LogValue() slog.Value { return slog.GroupValue( slog.String("frame_type", "handshake_done"), ) }	18.84 KB	2025-05-25 12:27
📄 gate.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import "context" // An gate is a monitor (mutex + condition variable) with one bit of state. // // The condition may be either set or unset. // Lock operations may be unconditional, or wait for the condition to be set. // Unlock operations record the new state of the condition. type gate struct { // When unlocked, exactly one of set or unset contains a value. // When locked, neither chan contains a value. set chan struct{} unset chan struct{} } // newGate returns a new, unlocked gate with the condition unset. func newGate() gate { g := newLockedGate() g.unlock(false) return g } // newLocked gate returns a new, locked gate. func newLockedGate() gate { return gate{ set: make(chan struct{}, 1), unset: make(chan struct{}, 1), } } // lock acquires the gate unconditionally. // It reports whether the condition is set. func (g gate) lock() (set bool) { select { case <-g.set: return true case <-g.unset: return false } } // waitAndLock waits until the condition is set before acquiring the gate. // If the context expires, waitAndLock returns an error and does not acquire the gate. func (g gate) waitAndLock(ctx context.Context, testHooks connTestHooks) error { if testHooks != nil { return testHooks.waitUntil(ctx, g.lockIfSet) } select { case <-g.set: return nil default: } select { case <-g.set: return nil case <-ctx.Done(): return ctx.Err() } } // lockIfSet acquires the gate if and only if the condition is set. func (g gate) lockIfSet() (acquired bool) { select { case <-g.set: return true default: return false } } // unlock sets the condition and releases the gate. func (g gate) unlock(set bool) { if set { g.set <- struct{}{} } else { g.unset <- struct{}{} } } // unlock sets the condition to the result of f and releases the gate. // Useful in defers. func (g *gate) unlockFunc(f func() bool) { g.unlock(f()) }	2.04 KB	2025-05-25 12:27
📄 gate_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "context" "testing" "time" ) func TestGateLockAndUnlock(t testing.T) { g := newGate() if set := g.lock(); set { t.Errorf("g.lock() of never-locked gate: true, want false") } unlockedc := make(chan struct{}) donec := make(chan struct{}) go func() { defer close(donec) set := g.lock() select { case <-unlockedc: default: t.Errorf("g.lock() succeeded while gate was held") } if !set { t.Errorf("g.lock() of set gate: false, want true") } g.unlock(false) }() time.Sleep(1 time.Millisecond) close(unlockedc) g.unlock(true) <-donec if set := g.lock(); set { t.Errorf("g.lock() of unset gate: true, want false") } } func TestGateWaitAndLockContext(t testing.T) { g := newGate() // waitAndLock is canceled ctx, cancel := context.WithCancel(context.Background()) go func() { time.Sleep(1 time.Millisecond) cancel() }() if err := g.waitAndLock(ctx, nil); err != context.Canceled { t.Errorf("g.waitAndLock() = %v, want context.Canceled", err) } // waitAndLock succeeds set := false go func() { time.Sleep(1 * time.Millisecond) g.lock() set = true g.unlock(true) }() if err := g.waitAndLock(context.Background(), nil); err != nil { t.Errorf("g.waitAndLock() = %v, want nil", err) } if !set { t.Errorf("g.waitAndLock() returned before gate was set") } g.unlock(true) // waitAndLock succeeds when the gate is set and the context is canceled if err := g.waitAndLock(ctx, nil); err != nil { t.Errorf("g.waitAndLock() = %v, want nil", err) } } func TestGateLockIfSet(t testing.T) { g := newGate() if locked := g.lockIfSet(); locked { t.Errorf("g.lockIfSet() of unset gate = %v, want false", locked) } g.lock() g.unlock(true) if locked := g.lockIfSet(); !locked { t.Errorf("g.lockIfSet() of set gate = %v, want true", locked) } } func TestGateUnlockFunc(t testing.T) { g := newGate() go func() { g.lock() defer g.unlockFunc(func() bool { return true }) }() g.waitAndLock(context.Background(), nil) }	2.15 KB	2025-05-25 12:27
📄 gotraceback_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 && unix package quic import ( "os" "os/signal" "runtime/debug" "syscall" ) // When killed with SIGQUIT (C-\), print stacks with GOTRACEBACK=all rather than system, // to reduce irrelevant noise when debugging hung tests. func init() { ch := make(chan os.Signal, 1) signal.Notify(ch, syscall.SIGQUIT) go func() { <-ch debug.SetTraceback("all") panic("SIGQUIT") }() }	561 B	2025-05-25 12:27
📄 idle.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "time" ) // idleState tracks connection idle events. // // Before the handshake is confirmed, the idle timeout is Config.HandshakeTimeout. // // After the handshake is confirmed, the idle timeout is // the minimum of Config.MaxIdleTimeout and the peer's max_idle_timeout transport parameter. // // If KeepAlivePeriod is set, keep-alive pings are sent. // Keep-alives are only sent after the handshake is confirmed. // // https://www.rfc-editor.org/rfc/rfc9000#section-10.1 type idleState struct { // idleDuration is the negotiated idle timeout for the connection. idleDuration time.Duration // idleTimeout is the time at which the connection will be closed due to inactivity. idleTimeout time.Time // nextTimeout is the time of the next idle event. // If nextTimeout == idleTimeout, this is the idle timeout. // Otherwise, this is the keep-alive timeout. nextTimeout time.Time // sentSinceLastReceive is set if we have sent an ack-eliciting packet // since the last time we received and processed a packet from the peer. sentSinceLastReceive bool } // receivePeerMaxIdleTimeout handles the peer's max_idle_timeout transport parameter. func (c Conn) receivePeerMaxIdleTimeout(peerMaxIdleTimeout time.Duration) { localMaxIdleTimeout := c.config.maxIdleTimeout() switch { case localMaxIdleTimeout == 0: c.idle.idleDuration = peerMaxIdleTimeout case peerMaxIdleTimeout == 0: c.idle.idleDuration = localMaxIdleTimeout default: c.idle.idleDuration = min(localMaxIdleTimeout, peerMaxIdleTimeout) } } func (c Conn) idleHandlePacketReceived(now time.Time) { if !c.handshakeConfirmed.isSet() { return } // "An endpoint restarts its idle timer when a packet from its peer is // received and processed successfully." // https://www.rfc-editor.org/rfc/rfc9000#section-10.1-3 c.idle.sentSinceLastReceive = false c.restartIdleTimer(now) } func (c Conn) idleHandlePacketSent(now time.Time, sent sentPacket) { // "An endpoint also restarts its idle timer when sending an ack-eliciting packet // if no other ack-eliciting packets have been sent since // last receiving and processing a packet." // https://www.rfc-editor.org/rfc/rfc9000#section-10.1-3 if c.idle.sentSinceLastReceive \|\| !sent.ackEliciting \|\| !c.handshakeConfirmed.isSet() { return } c.idle.sentSinceLastReceive = true c.restartIdleTimer(now) } func (c Conn) restartIdleTimer(now time.Time) { if !c.isAlive() { // Connection is closing, disable timeouts. c.idle.idleTimeout = time.Time{} c.idle.nextTimeout = time.Time{} return } var idleDuration time.Duration if c.handshakeConfirmed.isSet() { idleDuration = c.idle.idleDuration } else { idleDuration = c.config.handshakeTimeout() } if idleDuration == 0 { c.idle.idleTimeout = time.Time{} } else { // "[...] endpoints MUST increase the idle timeout period to be // at least three times the current Probe Timeout (PTO)." // https://www.rfc-editor.org/rfc/rfc9000#section-10.1-4 idleDuration = max(idleDuration, 3c.loss.ptoPeriod()) c.idle.idleTimeout = now.Add(idleDuration) } // Set the time of our next event: // The idle timer if no keep-alive is set, or the keep-alive timer if one is. c.idle.nextTimeout = c.idle.idleTimeout keepAlive := c.config.keepAlivePeriod() switch { case !c.handshakeConfirmed.isSet(): // We do not send keep-alives before the handshake is complete. case keepAlive <= 0: // Keep-alives are not enabled. case c.idle.sentSinceLastReceive: // We have sent an ack-eliciting packet to the peer. // If they don't acknowledge it, loss detection will follow up with PTO probes, // which will function as keep-alives. // We don't need to send further pings. case idleDuration == 0: // The connection does not have a negotiated idle timeout. // Send keep-alives anyway, since they may be required to keep middleboxes // from losing state. c.idle.nextTimeout = now.Add(keepAlive) default: // Schedule our next keep-alive. // If our configured keep-alive period is greater than half the negotiated // connection idle timeout, we reduce the keep-alive period to half // the idle timeout to ensure we have time for the ping to arrive. c.idle.nextTimeout = now.Add(min(keepAlive, idleDuration/2)) } } func (c Conn) appendKeepAlive(now time.Time) bool { if c.idle.nextTimeout.IsZero() \|\| c.idle.nextTimeout.After(now) { return true // timer has not expired } if c.idle.nextTimeout.Equal(c.idle.idleTimeout) { return true // no keepalive timer set, only idle } if c.idle.sentSinceLastReceive { return true // already sent an ack-eliciting packet } if c.w.sent.ackEliciting { return true // this packet is already ack-eliciting } // Send an ack-eliciting PING frame to the peer to keep the connection alive. return c.w.appendPingFrame() } var errHandshakeTimeout error = localTransportError{ code: errConnectionRefused, reason: "handshake timeout", } func (c Conn) idleAdvance(now time.Time) (shouldExit bool) { if c.idle.idleTimeout.IsZero() \|\| now.Before(c.idle.idleTimeout) { return false } c.idle.idleTimeout = time.Time{} c.idle.nextTimeout = time.Time{} if !c.handshakeConfirmed.isSet() { // Handshake timeout has expired. // If we're a server, we're refusing the too-slow client. // If we're a client, we're giving up. // In either case, we're going to send a CONNECTION_CLOSE frame and // enter the closing state rather than unceremoniously dropping the connection, // since the peer might still be trying to complete the handshake. c.abort(now, errHandshakeTimeout) return false } // Idle timeout has expired. // // "[...] the connection is silently closed and its state is discarded [...]" // https://www.rfc-editor.org/rfc/rfc9000#section-10.1-1 return true }	5.83 KB	2025-05-25 12:27
📄 idle_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "context" "crypto/tls" "fmt" "testing" "time" ) func TestHandshakeTimeoutExpiresServer(t testing.T) { const timeout = 5 time.Second tc := newTestConn(t, serverSide, func(c Config) { c.HandshakeTimeout = timeout }) tc.ignoreFrame(frameTypeAck) tc.ignoreFrame(frameTypeNewConnectionID) tc.writeFrames(packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelInitial], }) // Server starts its end of the handshake. // Client acks these packets to avoid starting the PTO timer. tc.wantFrameType("server sends Initial CRYPTO flight", packetTypeInitial, debugFrameCrypto{}) tc.writeAckForAll() tc.wantFrameType("server sends Handshake CRYPTO flight", packetTypeHandshake, debugFrameCrypto{}) tc.writeAckForAll() if got, want := tc.timerDelay(), timeout; got != want { t.Errorf("connection timer = %v, want %v (handshake timeout)", got, want) } // Client sends a packet, but this does not extend the handshake timer. tc.advance(1 time.Second) tc.writeFrames(packetTypeHandshake, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelHandshake][:1], // partial data }) tc.wantIdle("handshake is not complete") tc.advance(timeout - 1time.Second) tc.wantFrame("server closes connection after handshake timeout", packetTypeHandshake, debugFrameConnectionCloseTransport{ code: errConnectionRefused, }) } func TestHandshakeTimeoutExpiresClient(t testing.T) { const timeout = 5 * time.Second tc := newTestConn(t, clientSide, func(c Config) { c.HandshakeTimeout = timeout }) tc.ignoreFrame(frameTypeAck) tc.ignoreFrame(frameTypeNewConnectionID) // Start the handshake. // The client always sets a PTO timer until it gets an ack for a handshake packet // or confirms the handshake, so proceed far enough through the handshake to // let us not worry about PTO. tc.wantFrameType("client sends Initial CRYPTO flight", packetTypeInitial, debugFrameCrypto{}) tc.writeAckForAll() tc.writeFrames(packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelInitial], }) tc.writeFrames(packetTypeHandshake, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelHandshake], }) tc.wantFrameType("client sends Handshake CRYPTO flight", packetTypeHandshake, debugFrameCrypto{}) tc.writeAckForAll() tc.wantIdle("client is waiting for end of handshake") if got, want := tc.timerDelay(), timeout; got != want { t.Errorf("connection timer = %v, want %v (handshake timeout)", got, want) } tc.advance(timeout) tc.wantFrame("client closes connection after handshake timeout", packetTypeHandshake, debugFrameConnectionCloseTransport{ code: errConnectionRefused, }) } func TestIdleTimeoutExpires(t testing.T) { for _, test := range []struct { localMaxIdleTimeout time.Duration peerMaxIdleTimeout time.Duration wantTimeout time.Duration }{{ localMaxIdleTimeout: 10 * time.Second, peerMaxIdleTimeout: 20 * time.Second, wantTimeout: 10 * time.Second, }, { localMaxIdleTimeout: 20 * time.Second, peerMaxIdleTimeout: 10 * time.Second, wantTimeout: 10 * time.Second, }, { localMaxIdleTimeout: 0, peerMaxIdleTimeout: 10 * time.Second, wantTimeout: 10 * time.Second, }, { localMaxIdleTimeout: 10 * time.Second, peerMaxIdleTimeout: 0, wantTimeout: 10 * time.Second, }} { name := fmt.Sprintf("local=%v/peer=%v", test.localMaxIdleTimeout, test.peerMaxIdleTimeout) t.Run(name, func(t testing.T) { tc := newTestConn(t, serverSide, func(p transportParameters) { p.maxIdleTimeout = test.peerMaxIdleTimeout }, func(c Config) { c.MaxIdleTimeout = test.localMaxIdleTimeout }) tc.handshake() if got, want := tc.timeUntilEvent(), test.wantTimeout; got != want { t.Errorf("new conn timeout=%v, want %v (idle timeout)", got, want) } tc.advance(test.wantTimeout - 1) tc.wantIdle("connection is idle and alive prior to timeout") ctx := canceledContext() if err := tc.conn.Wait(ctx); err != context.Canceled { t.Fatalf("conn.Wait() = %v, want Canceled", err) } tc.advance(1) tc.wantIdle("connection exits after timeout") if err := tc.conn.Wait(ctx); err != errIdleTimeout { t.Fatalf("conn.Wait() = %v, want errIdleTimeout", err) } }) } } func TestIdleTimeoutKeepAlive(t testing.T) { for _, test := range []struct { idleTimeout time.Duration keepAlive time.Duration wantTimeout time.Duration }{{ idleTimeout: 30 * time.Second, keepAlive: 10 * time.Second, wantTimeout: 10 * time.Second, }, { idleTimeout: 10 * time.Second, keepAlive: 30 * time.Second, wantTimeout: 5 * time.Second, }, { idleTimeout: -1, // disabled keepAlive: 30 * time.Second, wantTimeout: 30 * time.Second, }} { name := fmt.Sprintf("idle_timeout=%v/keepalive=%v", test.idleTimeout, test.keepAlive) t.Run(name, func(t testing.T) { tc := newTestConn(t, serverSide, func(c Config) { c.MaxIdleTimeout = test.idleTimeout c.KeepAlivePeriod = test.keepAlive }) tc.handshake() if got, want := tc.timeUntilEvent(), test.wantTimeout; got != want { t.Errorf("new conn timeout=%v, want %v (keepalive timeout)", got, want) } tc.advance(test.wantTimeout - 1) tc.wantIdle("connection is idle prior to timeout") tc.advance(1) tc.wantFrameType("keep-alive ping is sent", packetType1RTT, debugFramePing{}) }) } } func TestIdleLongTermKeepAliveSent(t testing.T) { // This test examines a connection sitting idle and sending periodic keep-alive pings. const keepAlivePeriod = 30 time.Second tc := newTestConn(t, clientSide, func(c Config) { c.KeepAlivePeriod = keepAlivePeriod c.MaxIdleTimeout = -1 }) tc.handshake() // The handshake will have completed a little bit after the point at which the // keepalive timer was set. Send two PING frames to the conn, triggering an immediate ack // and resetting the timer. tc.writeFrames(packetType1RTT, debugFramePing{}) tc.writeFrames(packetType1RTT, debugFramePing{}) tc.wantFrameType("conn acks received pings", packetType1RTT, debugFrameAck{}) for i := 0; i < 10; i++ { tc.wantIdle("conn has nothing more to send") if got, want := tc.timeUntilEvent(), keepAlivePeriod; got != want { t.Errorf("i=%v conn timeout=%v, want %v (keepalive timeout)", i, got, want) } tc.advance(keepAlivePeriod) tc.wantFrameType("keep-alive ping is sent", packetType1RTT, debugFramePing{}) tc.writeAckForAll() } } func TestIdleLongTermKeepAliveReceived(t testing.T) { // This test examines a connection sitting idle, but receiving periodic peer // traffic to keep the connection alive. const idleTimeout = 30 * time.Second tc := newTestConn(t, serverSide, func(c Config) { c.MaxIdleTimeout = idleTimeout }) tc.handshake() for i := 0; i < 10; i++ { tc.advance(idleTimeout - 1time.Second) tc.writeFrames(packetType1RTT, debugFramePing{}) if got, want := tc.timeUntilEvent(), maxAckDelay-timerGranularity; got != want { t.Errorf("i=%v conn timeout=%v, want %v (max_ack_delay)", i, got, want) } tc.advanceToTimer() tc.wantFrameType("conn acks received ping", packetType1RTT, debugFrameAck{}) } // Connection is still alive. ctx := canceledContext() if err := tc.conn.Wait(ctx); err != context.Canceled { t.Fatalf("conn.Wait() = %v, want Canceled", err) } }	7.39 KB	2025-05-25 12:27
📄 key_update_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "testing" ) func TestKeyUpdatePeerUpdates(t testing.T) { tc := newTestConn(t, serverSide) tc.handshake() tc.ignoreFrames = nil // ignore nothing // Peer initiates a key update. tc.sendKeyNumber = 1 tc.sendKeyPhaseBit = true tc.writeFrames(packetType1RTT, debugFramePing{}) // We update to the new key. tc.advanceToTimer() tc.wantFrameType("conn ACKs last packet", packetType1RTT, debugFrameAck{}) tc.wantFrame("first packet after a key update is always ack-eliciting", packetType1RTT, debugFramePing{}) if got, want := tc.lastPacket.keyNumber, 1; got != want { t.Errorf("after key rotation, conn sent packet with key %v, want %v", got, want) } if !tc.lastPacket.keyPhaseBit { t.Errorf("after key rotation, conn failed to change Key Phase bit") } tc.wantIdle("conn has nothing to send") // Peer's ACK of a packet we sent in the new phase completes the update. tc.writeAckForAll() // Peer initiates a second key update. tc.sendKeyNumber = 2 tc.sendKeyPhaseBit = false tc.writeFrames(packetType1RTT, debugFramePing{}) // We update to the new key. tc.advanceToTimer() tc.wantFrameType("conn ACKs last packet", packetType1RTT, debugFrameAck{}) tc.wantFrame("first packet after a key update is always ack-eliciting", packetType1RTT, debugFramePing{}) if got, want := tc.lastPacket.keyNumber, 2; got != want { t.Errorf("after key rotation, conn sent packet with key %v, want %v", got, want) } if tc.lastPacket.keyPhaseBit { t.Errorf("after second key rotation, conn failed to change Key Phase bit") } tc.wantIdle("conn has nothing to send") } func TestKeyUpdateAcceptPreviousPhaseKeys(t testing.T) { // "An endpoint SHOULD retain old keys for some time after // unprotecting a packet sent using the new keys." // https://www.rfc-editor.org/rfc/rfc9001#section-6.1-8 tc := newTestConn(t, serverSide) tc.handshake() tc.ignoreFrames = nil // ignore nothing // Peer initiates a key update, skipping one packet number. pnum0 := tc.peerNextPacketNum[appDataSpace] tc.peerNextPacketNum[appDataSpace]++ tc.sendKeyNumber = 1 tc.sendKeyPhaseBit = true tc.writeFrames(packetType1RTT, debugFramePing{}) // We update to the new key. // This ACK is not delayed, because we've skipped a packet number. tc.wantFrame("conn ACKs last packet", packetType1RTT, debugFrameAck{ ranges: []i64range[packetNumber]{ {0, pnum0}, {pnum0 + 1, pnum0 + 2}, }, }) tc.wantFrame("first packet after a key update is always ack-eliciting", packetType1RTT, debugFramePing{}) if got, want := tc.lastPacket.keyNumber, 1; got != want { t.Errorf("after key rotation, conn sent packet with key %v, want %v", got, want) } if !tc.lastPacket.keyPhaseBit { t.Errorf("after key rotation, conn failed to change Key Phase bit") } tc.wantIdle("conn has nothing to send") // We receive the previously-skipped packet in the earlier key phase. tc.peerNextPacketNum[appDataSpace] = pnum0 tc.sendKeyNumber = 0 tc.sendKeyPhaseBit = false tc.writeFrames(packetType1RTT, debugFramePing{}) // We ack the reordered packet immediately, still in the new key phase. tc.wantFrame("conn ACKs reordered packet", packetType1RTT, debugFrameAck{ ranges: []i64range[packetNumber]{ {0, pnum0 + 2}, }, }) tc.wantIdle("packet is not ack-eliciting") if got, want := tc.lastPacket.keyNumber, 1; got != want { t.Errorf("after key rotation, conn sent packet with key %v, want %v", got, want) } if !tc.lastPacket.keyPhaseBit { t.Errorf("after key rotation, conn failed to change Key Phase bit") } } func TestKeyUpdateRejectPacketFromPriorPhase(t testing.T) { // "Packets with higher packet numbers MUST be protected with either // the same or newer packet protection keys than packets with lower packet numbers." // https://www.rfc-editor.org/rfc/rfc9001#section-6.4-2 tc := newTestConn(t, serverSide) tc.handshake() tc.ignoreFrames = nil // ignore nothing // Peer initiates a key update. tc.sendKeyNumber = 1 tc.sendKeyPhaseBit = true tc.writeFrames(packetType1RTT, debugFramePing{}) // We update to the new key. tc.advanceToTimer() tc.wantFrameType("conn ACKs last packet", packetType1RTT, debugFrameAck{}) tc.wantFrame("first packet after a key update is always ack-eliciting", packetType1RTT, debugFramePing{}) if got, want := tc.lastPacket.keyNumber, 1; got != want { t.Errorf("after key rotation, conn sent packet with key %v, want %v", got, want) } if !tc.lastPacket.keyPhaseBit { t.Errorf("after key rotation, conn failed to change Key Phase bit") } tc.wantIdle("conn has nothing to send") // Peer sends an ack-eliciting packet using the prior phase keys. // We fail to unprotect the packet and ignore it. skipped := tc.peerNextPacketNum[appDataSpace] tc.sendKeyNumber = 0 tc.sendKeyPhaseBit = false tc.writeFrames(packetType1RTT, debugFramePing{}) // Peer sends an ack-eliciting packet using the current phase keys. tc.sendKeyNumber = 1 tc.sendKeyPhaseBit = true tc.writeFrames(packetType1RTT, debugFramePing{}) // We ack the peer's packets, not including the one sent with the wrong keys. tc.wantFrame("conn ACKs packets, not including packet sent with wrong keys", packetType1RTT, debugFrameAck{ ranges: []i64range[packetNumber]{ {0, skipped}, {skipped + 1, skipped + 2}, }, }) } func TestKeyUpdateLocallyInitiated(t testing.T) { const updateAfter = 4 // initiate key update after 1-RTT packet 4 tc := newTestConn(t, serverSide) tc.conn.keysAppData.updateAfter = updateAfter tc.handshake() for { tc.writeFrames(packetType1RTT, debugFramePing{}) tc.advanceToTimer() tc.wantFrameType("conn ACKs last packet", packetType1RTT, debugFrameAck{}) if tc.lastPacket.num > updateAfter { break } if got, want := tc.lastPacket.keyNumber, 0; got != want { t.Errorf("before key update, conn sent packet with key %v, want %v", got, want) } if tc.lastPacket.keyPhaseBit { t.Errorf("before key update, keyPhaseBit is set, want unset") } } if got, want := tc.lastPacket.keyNumber, 1; got != want { t.Errorf("after key update, conn sent packet with key %v, want %v", got, want) } if !tc.lastPacket.keyPhaseBit { t.Errorf("after key update, keyPhaseBit is unset, want set") } tc.wantFrame("first packet after a key update is always ack-eliciting", packetType1RTT, debugFramePing{}) tc.wantIdle("no more frames") // Peer sends another packet using the prior phase keys. tc.writeFrames(packetType1RTT, debugFramePing{}) tc.advanceToTimer() tc.wantFrameType("conn ACKs packet in prior phase", packetType1RTT, debugFrameAck{}) tc.wantIdle("packet is not ack-eliciting") if got, want := tc.lastPacket.keyNumber, 1; got != want { t.Errorf("after key update, conn sent packet with key %v, want %v", got, want) } // Peer updates to the next phase. tc.sendKeyNumber = 1 tc.sendKeyPhaseBit = true tc.writeAckForAll() tc.writeFrames(packetType1RTT, debugFramePing{}) tc.advanceToTimer() tc.wantFrameType("conn ACKs packet in current phase", packetType1RTT, debugFrameAck{}) tc.wantIdle("packet is not ack-eliciting") if got, want := tc.lastPacket.keyNumber, 1; got != want { t.Errorf("after key update, conn sent packet with key %v, want %v", got, want) } // Peer initiates its own update. tc.sendKeyNumber = 2 tc.sendKeyPhaseBit = false tc.writeFrames(packetType1RTT, debugFramePing{}) tc.advanceToTimer() tc.wantFrameType("conn ACKs packet in current phase", packetType1RTT, debugFrameAck{}) tc.wantFrame("first packet after a key update is always ack-eliciting", packetType1RTT, debugFramePing{}) if got, want := tc.lastPacket.keyNumber, 2; got != want { t.Errorf("after peer key update, conn sent packet with key %v, want %v", got, want) } if tc.lastPacket.keyPhaseBit { t.Errorf("after peer key update, keyPhaseBit is unset, want set") } }	7.85 KB	2025-05-25 12:27
📄 log.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "fmt" "os" "strings" ) var logPackets bool // Parse GODEBUG settings. // // GODEBUG=quiclogpackets=1 -- log every packet sent and received. func init() { s := os.Getenv("GODEBUG") for len(s) > 0 { var opt string opt, s, _ = strings.Cut(s, ",") switch opt { case "quiclogpackets=1": logPackets = true } } } func logInboundLongPacket(c Conn, p longPacket) { if !logPackets { return } prefix := c.String() fmt.Printf("%v recv %v %v\n", prefix, p.ptype, p.num) logFrames(prefix+" <- ", p.payload) } func logInboundShortPacket(c Conn, p shortPacket) { if !logPackets { return } prefix := c.String() fmt.Printf("%v recv 1-RTT %v\n", prefix, p.num) logFrames(prefix+" <- ", p.payload) } func logSentPacket(c *Conn, ptype packetType, pnum packetNumber, src, dst, payload []byte) { if !logPackets \|\| len(payload) == 0 { return } prefix := c.String() fmt.Printf("%v send %v %v\n", prefix, ptype, pnum) logFrames(prefix+" -> ", payload) } func logFrames(prefix string, payload []byte) { for len(payload) > 0 { f, n := parseDebugFrame(payload) if n < 0 { fmt.Printf("%vBAD DATA\n", prefix) break } payload = payload[n:] fmt.Printf("%v%v\n", prefix, f) } }	1.38 KB	2025-05-25 12:27
📄 loss.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "context" "log/slog" "math" "time" ) type lossState struct { side connSide // True when the handshake is confirmed. // https://www.rfc-editor.org/rfc/rfc9001#section-4.1.2 handshakeConfirmed bool // Peer's max_ack_delay transport parameter. // https://www.rfc-editor.org/rfc/rfc9000.html#section-18.2-4.28.1 maxAckDelay time.Duration // Time of the next event: PTO expiration (if ptoTimerArmed is true), // or loss detection. // The connection must call lossState.advance when the timer expires. timer time.Time // True when the PTO timer is set. ptoTimerArmed bool // True when the PTO timer has expired and a probe packet has not yet been sent. ptoExpired bool // Count of PTO expirations since the lack received acknowledgement. // https://www.rfc-editor.org/rfc/rfc9002#section-6.2.1-9 ptoBackoffCount int // Anti-amplification limit: Three times the amount of data received from // the peer, less the amount of data sent. // // Set to antiAmplificationUnlimited (MaxInt) to disable the limit. // The limit is always disabled for clients, and for servers after the // peer's address is validated. // // Anti-amplification is per-address; this will need to change if/when we // support address migration. // // https://www.rfc-editor.org/rfc/rfc9000#section-8-2 antiAmplificationLimit int // Count of non-ack-eliciting packets (ACKs) sent since the last ack-eliciting one. consecutiveNonAckElicitingPackets int rtt rttState pacer pacerState cc ccReno // Per-space loss detection state. spaces [numberSpaceCount]struct { sentPacketList maxAcked packetNumber lastAckEliciting packetNumber } // Temporary state used when processing an ACK frame. ackFrameRTT time.Duration // RTT from latest packet in frame ackFrameContainsAckEliciting bool // newly acks an ack-eliciting packet? } const antiAmplificationUnlimited = math.MaxInt func (c lossState) init(side connSide, maxDatagramSize int, now time.Time) { c.side = side if side == clientSide { // Clients don't have an anti-amplification limit. c.antiAmplificationLimit = antiAmplificationUnlimited } c.rtt.init() c.cc = newReno(maxDatagramSize) c.pacer.init(now, c.cc.congestionWindow, timerGranularity) // Peer's assumed max_ack_delay, prior to receiving transport parameters. // https://www.rfc-editor.org/rfc/rfc9000#section-18.2 c.maxAckDelay = 25 * time.Millisecond for space := range c.spaces { c.spaces[space].maxAcked = -1 c.spaces[space].lastAckEliciting = -1 } } // setMaxAckDelay sets the max_ack_delay transport parameter received from the peer. func (c lossState) setMaxAckDelay(d time.Duration) { if d >= (1<<14)time.Millisecond { // Values of 2^14 or greater are invalid. // https://www.rfc-editor.org/rfc/rfc9000.html#section-18.2-4.28.1 return } c.maxAckDelay = d } // confirmHandshake indicates the handshake has been confirmed. func (c lossState) confirmHandshake() { c.handshakeConfirmed = true } // validateClientAddress disables the anti-amplification limit after // a server validates a client's address. func (c lossState) validateClientAddress() { c.antiAmplificationLimit = antiAmplificationUnlimited } // minDatagramSize is the minimum datagram size permitted by // anti-amplification protection. // // Defining a minimum size avoids the case where, say, anti-amplification // technically allows us to send a 1-byte datagram, but no such datagram // can be constructed. const minPacketSize = 128 type ccLimit int const ( ccOK = ccLimit(iota) // OK to send ccBlocked // sending blocked by anti-amplification ccLimited // sending blocked by congestion control ccPaced // sending allowed by congestion, but delayed by pacer ) // sendLimit reports whether sending is possible at this time. // When sending is pacing limited, it returns the next time a packet may be sent. func (c lossState) sendLimit(now time.Time) (limit ccLimit, next time.Time) { if c.antiAmplificationLimit < minPacketSize { // When at the anti-amplification limit, we may not send anything. return ccBlocked, time.Time{} } if c.ptoExpired { // On PTO expiry, send a probe. return ccOK, time.Time{} } if !c.cc.canSend() { // Congestion control blocks sending. return ccLimited, time.Time{} } if c.cc.bytesInFlight == 0 { // If no bytes are in flight, send packet unpaced. return ccOK, time.Time{} } canSend, next := c.pacer.canSend(now) if !canSend { // Pacer blocks sending. return ccPaced, next } return ccOK, time.Time{} } // maxSendSize reports the maximum datagram size that may be sent. func (c lossState) maxSendSize() int { return min(c.antiAmplificationLimit, c.cc.maxDatagramSize) } // advance is called when time passes. // The lossf function is called for each packet newly detected as lost. func (c lossState) advance(now time.Time, lossf func(numberSpace, sentPacket, packetFate)) { c.pacer.advance(now, c.cc.congestionWindow, c.rtt.smoothedRTT) if c.ptoTimerArmed && !c.timer.IsZero() && !c.timer.After(now) { c.ptoExpired = true c.timer = time.Time{} c.ptoBackoffCount++ } c.detectLoss(now, lossf) } // nextNumber returns the next packet number to use in a space. func (c lossState) nextNumber(space numberSpace) packetNumber { return c.spaces[space].nextNum } // packetSent records a sent packet. func (c lossState) packetSent(now time.Time, log slog.Logger, space numberSpace, sent sentPacket) { sent.time = now c.spaces[space].add(sent) size := sent.size if c.antiAmplificationLimit != antiAmplificationUnlimited { c.antiAmplificationLimit = max(0, c.antiAmplificationLimit-size) } if sent.inFlight { c.cc.packetSent(now, log, space, sent) c.pacer.packetSent(now, size, c.cc.congestionWindow, c.rtt.smoothedRTT) if sent.ackEliciting { c.spaces[space].lastAckEliciting = sent.num c.ptoExpired = false // reset expired PTO timer after sending probe } c.scheduleTimer(now) if logEnabled(log, QLogLevelPacket) { logBytesInFlight(log, c.cc.bytesInFlight) } } if sent.ackEliciting { c.consecutiveNonAckElicitingPackets = 0 } else { c.consecutiveNonAckElicitingPackets++ } } // datagramReceived records a datagram (not packet!) received from the peer. func (c lossState) datagramReceived(now time.Time, size int) { if c.antiAmplificationLimit != antiAmplificationUnlimited { c.antiAmplificationLimit += 3 size // Reset the PTO timer, possibly to a point in the past, in which // case the caller should execute it immediately. // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.2.1-2 c.scheduleTimer(now) if c.ptoTimerArmed && !c.timer.IsZero() && !c.timer.After(now) { c.ptoExpired = true c.timer = time.Time{} } } } // receiveAckStart starts processing an ACK frame. // Call receiveAckRange for each range in the frame. // Call receiveAckFrameEnd after all ranges are processed. func (c lossState) receiveAckStart() { c.ackFrameContainsAckEliciting = false c.ackFrameRTT = -1 } // receiveAckRange processes a range within an ACK frame. // The ackf function is called for each newly-acknowledged packet. func (c lossState) receiveAckRange(now time.Time, space numberSpace, rangeIndex int, start, end packetNumber, ackf func(numberSpace, sentPacket, packetFate)) { // Limit our range to the intersection of the ACK range and // the in-flight packets we have state for. if s := c.spaces[space].start(); start < s { start = s } if e := c.spaces[space].end(); end > e { end = e } if start >= end { return } if rangeIndex == 0 { // If the latest packet in the ACK frame is newly-acked, // record the RTT in c.ackFrameRTT. sent := c.spaces[space].num(end - 1) if !sent.acked { c.ackFrameRTT = max(0, now.Sub(sent.time)) } } for pnum := start; pnum < end; pnum++ { sent := c.spaces[space].num(pnum) if sent.acked \|\| sent.lost { continue } // This is a newly-acknowledged packet. if pnum > c.spaces[space].maxAcked { c.spaces[space].maxAcked = pnum } sent.acked = true c.cc.packetAcked(now, sent) ackf(space, sent, packetAcked) if sent.ackEliciting { c.ackFrameContainsAckEliciting = true } } } // receiveAckEnd finishes processing an ack frame. // The lossf function is called for each packet newly detected as lost. func (c lossState) receiveAckEnd(now time.Time, log slog.Logger, space numberSpace, ackDelay time.Duration, lossf func(numberSpace, sentPacket, packetFate)) { c.spaces[space].sentPacketList.clean() // Update the RTT sample when the largest acknowledged packet in the ACK frame // is newly acknowledged, and at least one newly acknowledged packet is ack-eliciting. // https://www.rfc-editor.org/rfc/rfc9002.html#section-5.1-2.2 if c.ackFrameRTT >= 0 && c.ackFrameContainsAckEliciting { c.rtt.updateSample(now, c.handshakeConfirmed, space, c.ackFrameRTT, ackDelay, c.maxAckDelay) } // Reset the PTO backoff. // Exception: A client does not reset the backoff on acks for Initial packets. // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.1-9 if !(c.side == clientSide && space == initialSpace) { c.ptoBackoffCount = 0 } // If the client has set a PTO timer with no packets in flight // we want to restart that timer now. Clearing c.timer does this. // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.2.1-3 c.timer = time.Time{} c.detectLoss(now, lossf) c.cc.packetBatchEnd(now, log, space, &c.rtt, c.maxAckDelay) if logEnabled(log, QLogLevelPacket) { var ssthresh slog.Attr if c.cc.slowStartThreshold != math.MaxInt { ssthresh = slog.Int("ssthresh", c.cc.slowStartThreshold) } log.LogAttrs(context.Background(), QLogLevelPacket, "recovery:metrics_updated", slog.Duration("min_rtt", c.rtt.minRTT), slog.Duration("smoothed_rtt", c.rtt.smoothedRTT), slog.Duration("latest_rtt", c.rtt.latestRTT), slog.Duration("rtt_variance", c.rtt.rttvar), slog.Int("congestion_window", c.cc.congestionWindow), slog.Int("bytes_in_flight", c.cc.bytesInFlight), ssthresh, ) } } // discardPackets declares that packets within a number space will not be delivered // and that data contained in them should be resent. // For example, after receiving a Retry packet we discard already-sent Initial packets. func (c lossState) discardPackets(space numberSpace, log slog.Logger, lossf func(numberSpace, sentPacket, packetFate)) { for i := 0; i < c.spaces[space].size; i++ { sent := c.spaces[space].nth(i) sent.lost = true c.cc.packetDiscarded(sent) lossf(numberSpace(space), sent, packetLost) } c.spaces[space].clean() if logEnabled(log, QLogLevelPacket) { logBytesInFlight(log, c.cc.bytesInFlight) } } // discardKeys is called when dropping packet protection keys for a number space. func (c lossState) discardKeys(now time.Time, log slog.Logger, space numberSpace) { // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.4 for i := 0; i < c.spaces[space].size; i++ { sent := c.spaces[space].nth(i) c.cc.packetDiscarded(sent) } c.spaces[space].discard() c.spaces[space].maxAcked = -1 c.spaces[space].lastAckEliciting = -1 c.scheduleTimer(now) if logEnabled(log, QLogLevelPacket) { logBytesInFlight(log, c.cc.bytesInFlight) } } func (c lossState) lossDuration() time.Duration { // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.1.2 return max((9max(c.rtt.smoothedRTT, c.rtt.latestRTT))/8, timerGranularity) } func (c lossState) detectLoss(now time.Time, lossf func(numberSpace, sentPacket, packetFate)) { // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.1.1-1 const lossThreshold = 3 lossTime := now.Add(-c.lossDuration()) for space := numberSpace(0); space < numberSpaceCount; space++ { for i := 0; i < c.spaces[space].size; i++ { sent := c.spaces[space].nth(i) if sent.lost \|\| sent.acked { continue } // RFC 9002 Section 6.1 states that a packet is only declared lost if it // is "in flight", which excludes packets that contain only ACK frames. // However, we need some way to determine when to drop state for ACK-only // packets, and the loss algorithm in Appendix A handles loss detection of // not-in-flight packets identically to all others, so we do the same here. switch { case c.spaces[space].maxAcked-sent.num >= lossThreshold: // Packet threshold // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.1.1 fallthrough case sent.num <= c.spaces[space].maxAcked && !sent.time.After(lossTime): // Time threshold // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.1.2 sent.lost = true lossf(space, sent, packetLost) if sent.inFlight { c.cc.packetLost(now, space, sent, &c.rtt) } } if !sent.lost { break } } c.spaces[space].clean() } c.scheduleTimer(now) } // scheduleTimer sets the loss or PTO timer. // // The connection is responsible for arranging for advance to be called after // the timer expires. // // The timer may be set to a point in the past, in which advance should be called // immediately. We don't do this here, because executing the timer can cause // packet loss events, and it's simpler for the connection if loss events only // occur when advancing time. func (c lossState) scheduleTimer(now time.Time) { c.ptoTimerArmed = false // Loss timer for sent packets. // The loss timer is only started once a later packet has been acknowledged, // and takes precedence over the PTO timer. // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.1.2 var oldestPotentiallyLost time.Time for space := numberSpace(0); space < numberSpaceCount; space++ { if c.spaces[space].size > 0 && c.spaces[space].start() <= c.spaces[space].maxAcked { firstTime := c.spaces[space].nth(0).time if oldestPotentiallyLost.IsZero() \|\| firstTime.Before(oldestPotentiallyLost) { oldestPotentiallyLost = firstTime } } } if !oldestPotentiallyLost.IsZero() { c.timer = oldestPotentiallyLost.Add(c.lossDuration()) return } // PTO timer. if c.ptoExpired { // PTO timer has expired, don't restart it until we send a probe. c.timer = time.Time{} return } if c.antiAmplificationLimit >= 0 && c.antiAmplificationLimit < minPacketSize { // Server is at its anti-amplification limit and can't send any more data. // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.2.1-1 c.timer = time.Time{} return } // Timer starts at the most recently sent ack-eliciting packet. // Prior to confirming the handshake, we consider the Initial and Handshake // number spaces; after, we consider only Application Data. var last time.Time if !c.handshakeConfirmed { for space := initialSpace; space <= handshakeSpace; space++ { sent := c.spaces[space].num(c.spaces[space].lastAckEliciting) if sent == nil { continue } if last.IsZero() \|\| last.After(sent.time) { last = sent.time } } } else { sent := c.spaces[appDataSpace].num(c.spaces[appDataSpace].lastAckEliciting) if sent != nil { last = sent.time } } if last.IsZero() && c.side == clientSide && c.spaces[handshakeSpace].maxAcked < 0 && !c.handshakeConfirmed { // The client must always set a PTO timer prior to receiving an ack for a // handshake packet or the handshake being confirmed. // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.2.1 if !c.timer.IsZero() { // If c.timer is non-zero here, we've already set the PTO timer and // should leave it as-is rather than moving it forward. c.ptoTimerArmed = true return } last = now } else if last.IsZero() { c.timer = time.Time{} return } c.timer = last.Add(c.ptoPeriod()) c.ptoTimerArmed = true } func (c lossState) ptoPeriod() time.Duration { // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.1 return c.ptoBasePeriod() << c.ptoBackoffCount } func (c lossState) ptoBasePeriod() time.Duration { // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.1 pto := c.rtt.smoothedRTT + max(4c.rtt.rttvar, timerGranularity) if c.handshakeConfirmed { // The max_ack_delay is the maximum amount of time the peer might delay sending // an ack to us. We only take it into account for the Application Data space. // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.1-4 pto += c.maxAckDelay } return pto } func logBytesInFlight(log slog.Logger, bytesInFlight int) { log.LogAttrs(context.Background(), QLogLevelPacket, "recovery:metrics_updated", slog.Int("bytes_in_flight", bytesInFlight), ) }	16.36 KB	2025-05-25 12:27
📄 loss_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "fmt" "testing" "time" ) func TestLossAntiAmplificationLimit(t testing.T) { test := newLossTest(t, serverSide, lossTestOpts{}) test.datagramReceived(1200) t.Logf("# consume anti-amplification capacity in a mix of packets") test.send(initialSpace, 0, sentPacket{ size: 1200, ackEliciting: true, inFlight: true, }) test.send(initialSpace, 1, sentPacket{ size: 1200, ackEliciting: false, inFlight: false, }) test.send(initialSpace, 2, sentPacket{ size: 1200, ackEliciting: false, inFlight: true, }) t.Logf("# send blocked by anti-amplification limit") test.wantSendLimit(ccBlocked) t.Logf("# receiving a datagram unblocks server") test.datagramReceived(100) test.wantSendLimit(ccOK) t.Logf("# validating client address removes anti-amplification limit") test.validateClientAddress() test.wantSendLimit(ccOK) } func TestLossRTTSampleNotGenerated(t testing.T) { test := newLossTest(t, clientSide, lossTestOpts{}) test.send(initialSpace, 0, 1) test.send(initialSpace, 2, sentPacket{ ackEliciting: false, inFlight: false, }) test.advance(10 * time.Millisecond) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{1, 2}) test.wantAck(initialSpace, 1) test.wantVar("latest_rtt", 10time.Millisecond) t.Logf("# smoothed_rtt = latest_rtt") test.wantVar("smoothed_rtt", 10time.Millisecond) t.Logf("# rttvar = latest_rtt / 2") test.wantVar("rttvar", 5time.Millisecond) // "...an ACK frame SHOULD NOT be used to update RTT estimates if // it does not newly acknowledge the largest acknowledged packet." // https://www.rfc-editor.org/rfc/rfc9002.html#section-5.1-6 t.Logf("# acks for older packets do not generate an RTT sample") test.advance(1 * time.Millisecond) test.ack(initialSpace, 1time.Millisecond, i64range[packetNumber]{0, 2}) test.wantAck(initialSpace, 0) test.wantVar("smoothed_rtt", 10time.Millisecond) // "An RTT sample MUST NOT be generated on receiving an ACK frame // that does not newly acknowledge at least one ack-eliciting packet." // https://www.rfc-editor.org/rfc/rfc9002.html#section-5.1-7 t.Logf("# acks for non-ack-eliciting packets do not generate an RTT sample") test.advance(1 * time.Millisecond) test.ack(initialSpace, 1time.Millisecond, i64range[packetNumber]{0, 3}) test.wantAck(initialSpace, 2) test.wantVar("smoothed_rtt", 10time.Millisecond) } func TestLossMinRTT(t testing.T) { test := newLossTest(t, clientSide, lossTestOpts{}) // "min_rtt MUST be set to the latest_rtt on the first RTT sample." // https://www.rfc-editor.org/rfc/rfc9002.html#section-5.2-2 t.Logf("# min_rtt set on first sample") test.send(initialSpace, 0) test.advance(10 time.Millisecond) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{0, 1}) test.wantAck(initialSpace, 0) test.wantVar("min_rtt", 10time.Millisecond) // "min_rtt MUST be set to the lesser of min_rtt and latest_rtt [...] // on all other samples." t.Logf("# min_rtt does not increase") test.send(initialSpace, 1) test.advance(20 * time.Millisecond) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{0, 2}) test.wantAck(initialSpace, 1) test.wantVar("min_rtt", 10time.Millisecond) t.Logf("# min_rtt decreases") test.send(initialSpace, 2) test.advance(5 * time.Millisecond) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{0, 3}) test.wantAck(initialSpace, 2) test.wantVar("min_rtt", 5time.Millisecond) } func TestLossMinRTTAfterCongestion(t testing.T) { // "Endpoints SHOULD set the min_rtt to the newest RTT sample // after persistent congestion is established." // https://www.rfc-editor.org/rfc/rfc9002.html#section-5.2-5 test := newLossTest(t, clientSide, lossTestOpts{ maxDatagramSize: 1200, }) t.Logf("# establish initial RTT sample") test.send(initialSpace, 0, testSentPacketSize(1200)) test.advance(10 time.Millisecond) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{0, 1}) test.wantAck(initialSpace, 0) test.wantVar("min_rtt", 10time.Millisecond) t.Logf("# send two packets spanning persistent congestion duration") test.send(initialSpace, 1, testSentPacketSize(1200)) t.Logf("# 2000ms >> persistent congestion duration") test.advance(2000 * time.Millisecond) test.wantPTOExpired() test.send(initialSpace, 2, testSentPacketSize(1200)) t.Logf("# trigger loss of previous packets") test.advance(10 * time.Millisecond) test.send(initialSpace, 3, testSentPacketSize(1200)) test.advance(20 * time.Millisecond) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{3, 4}) test.wantAck(initialSpace, 3) test.wantLoss(initialSpace, 1, 2) t.Logf("# persistent congestion detected") test.send(initialSpace, 4, testSentPacketSize(1200)) test.advance(20 time.Millisecond) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{4, 5}) test.wantAck(initialSpace, 4) t.Logf("# min_rtt set from first sample after persistent congestion") test.wantVar("min_rtt", 20time.Millisecond) } func TestLossInitialRTTSample(t testing.T) { test := newLossTest(t, clientSide, lossTestOpts{}) test.setMaxAckDelay(2 time.Millisecond) t.Logf("# initial smoothed_rtt and rtt values") test.wantVar("smoothed_rtt", 333time.Millisecond) test.wantVar("rttvar", 333time.Millisecond/2) // https://www.rfc-editor.org/rfc/rfc9002.html#section-5.3-11 t.Logf("# first RTT sample") test.send(initialSpace, 0) test.advance(10 * time.Millisecond) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{0, 1}) test.wantAck(initialSpace, 0) test.wantVar("latest_rtt", 10time.Millisecond) t.Logf("# smoothed_rtt = latest_rtt") test.wantVar("smoothed_rtt", 10time.Millisecond) t.Logf("# rttvar = latest_rtt / 2") test.wantVar("rttvar", 5time.Millisecond) } func TestLossSmoothedRTTIgnoresMaxAckDelayBeforeHandshakeConfirmed(t testing.T) { test := newLossTest(t, clientSide, lossTestOpts{}) test.setMaxAckDelay(1 time.Millisecond) test.send(initialSpace, 0) test.advance(10 * time.Millisecond) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{0, 1}) test.wantAck(initialSpace, 0) smoothedRTT := 10 time.Millisecond rttvar := 5 * time.Millisecond // "[...] an endpoint [...] SHOULD ignore the peer's max_ack_delay // until the handshake is confirmed [...]" // https://www.rfc-editor.org/rfc/rfc9002.html#section-5.3-7.2 t.Logf("# subsequent RTT sample") test.send(handshakeSpace, 0) test.advance(20 * time.Millisecond) test.ack(handshakeSpace, 10time.Millisecond, i64range[packetNumber]{0, 1}) test.wantAck(handshakeSpace, 0) test.wantVar("latest_rtt", 20time.Millisecond) t.Logf("# ack_delay > max_ack_delay") t.Logf("# handshake not confirmed, so ignore max_ack_delay") t.Logf("# adjusted_rtt = latest_rtt - ackDelay") adjustedRTT := 10 * time.Millisecond t.Logf("# smoothed_rtt = 7/8 * smoothed_rtt + 1/8 * adjusted_rtt") smoothedRTT = (7smoothedRTT + adjustedRTT) / 8 test.wantVar("smoothed_rtt", smoothedRTT) rttvarSample := abs(smoothedRTT - adjustedRTT) t.Logf("# rttvar_sample = abs(smoothed_rtt - adjusted_rtt) = %v", rttvarSample) t.Logf("# rttvar = 3/4 rttvar + 1/4 * rttvar_sample") rttvar = (3rttvar + rttvarSample) / 4 test.wantVar("rttvar", rttvar) } func TestLossSmoothedRTTUsesMaxAckDelayAfterHandshakeConfirmed(t testing.T) { test := newLossTest(t, clientSide, lossTestOpts{}) test.setMaxAckDelay(25 * time.Millisecond) test.send(initialSpace, 0) test.advance(10 * time.Millisecond) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{0, 1}) test.wantAck(initialSpace, 0) smoothedRTT := 10 time.Millisecond rttvar := 5 * time.Millisecond test.confirmHandshake() // "[...] an endpoint [...] MUST use the lesser of the acknowledgment // delay and the peer's max_ack_delay after the handshake is confirmed [...]" // https://www.rfc-editor.org/rfc/rfc9002.html#section-5.3-7.3 t.Logf("# subsequent RTT sample") test.send(handshakeSpace, 0) test.advance(50 * time.Millisecond) test.ack(handshakeSpace, 40time.Millisecond, i64range[packetNumber]{0, 1}) test.wantAck(handshakeSpace, 0) test.wantVar("latest_rtt", 50time.Millisecond) t.Logf("# ack_delay > max_ack_delay") t.Logf("# handshake confirmed, so adjusted_rtt clamps to max_ack_delay") t.Logf("# adjusted_rtt = max_ack_delay") adjustedRTT := 25 * time.Millisecond rttvarSample := abs(smoothedRTT - adjustedRTT) t.Logf("# rttvar_sample = abs(smoothed_rtt - adjusted_rtt) = %v", rttvarSample) t.Logf("# rttvar = 3/4 * rttvar + 1/4 * rttvar_sample") rttvar = (3rttvar + rttvarSample) / 4 test.wantVar("rttvar", rttvar) t.Logf("# smoothed_rtt = 7/8 smoothed_rtt + 1/8 * adjusted_rtt") smoothedRTT = (7smoothedRTT + adjustedRTT) / 8 test.wantVar("smoothed_rtt", smoothedRTT) } func TestLossAckDelayReducesRTTBelowMinRTT(t testing.T) { test := newLossTest(t, clientSide, lossTestOpts{}) test.send(initialSpace, 0) test.advance(10 * time.Millisecond) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{0, 1}) test.wantAck(initialSpace, 0) smoothedRTT := 10 time.Millisecond rttvar := 5 * time.Millisecond // "[...] an endpoint [...] MUST NOT subtract the acknowledgment delay // from the RTT sample if the resulting value is smaller than the min_rtt." // https://www.rfc-editor.org/rfc/rfc9002.html#section-5.3-7.4 t.Logf("# subsequent RTT sample") test.send(handshakeSpace, 0) test.advance(12 * time.Millisecond) test.ack(handshakeSpace, 4time.Millisecond, i64range[packetNumber]{0, 1}) test.wantAck(handshakeSpace, 0) test.wantVar("latest_rtt", 12time.Millisecond) t.Logf("# latest_rtt - ack_delay < min_rtt, so adjusted_rtt = latest_rtt") adjustedRTT := 12 * time.Millisecond rttvarSample := abs(smoothedRTT - adjustedRTT) t.Logf("# rttvar_sample = abs(smoothed_rtt - adjusted_rtt) = %v", rttvarSample) t.Logf("# rttvar = 3/4 * rttvar + 1/4 * rttvar_sample") rttvar = (3rttvar + rttvarSample) / 4 test.wantVar("rttvar", rttvar) t.Logf("# smoothed_rtt = 7/8 smoothed_rtt + 1/8 * adjusted_rtt") smoothedRTT = (7smoothedRTT + adjustedRTT) / 8 test.wantVar("smoothed_rtt", smoothedRTT) } func TestLossPacketThreshold(t testing.T) { // "[...] the packet was sent kPacketThreshold packets before an // acknowledged packet [...]" // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.1.1 test := newLossTest(t, clientSide, lossTestOpts{}) t.Logf("# acking a packet triggers loss of packets sent kPacketThreshold earlier") test.send(appDataSpace, 0, 1, 2, 3, 4, 5, 6) test.ack(appDataSpace, 0time.Millisecond, i64range[packetNumber]{4, 5}) test.wantAck(appDataSpace, 4) test.wantLoss(appDataSpace, 0, 1) } func TestLossOutOfOrderAcks(t testing.T) { test := newLossTest(t, clientSide, lossTestOpts{}) t.Logf("# out of order acks, no loss") test.send(appDataSpace, 0, 1, 2) test.ack(appDataSpace, 0time.Millisecond, i64range[packetNumber]{2, 3}) test.wantAck(appDataSpace, 2) test.ack(appDataSpace, 0time.Millisecond, i64range[packetNumber]{1, 2}) test.wantAck(appDataSpace, 1) test.ack(appDataSpace, 0time.Millisecond, i64range[packetNumber]{0, 1}) test.wantAck(appDataSpace, 0) } func TestLossSendAndAck(t testing.T) { test := newLossTest(t, clientSide, lossTestOpts{}) test.send(appDataSpace, 0, 1, 2) test.ack(appDataSpace, 0time.Millisecond, i64range[packetNumber]{0, 3}) test.wantAck(appDataSpace, 0, 1, 2) // Redundant ACK doesn't trigger more ACK events. // (If we did get an extra ACK, the test cleanup would notice and complain.) test.ack(appDataSpace, 0time.Millisecond, i64range[packetNumber]{0, 3}) } func TestLossAckEveryOtherPacket(t testing.T) { test := newLossTest(t, clientSide, lossTestOpts{}) test.send(appDataSpace, 0, 1, 2, 3, 4, 5, 6) test.ack(appDataSpace, 0time.Millisecond, i64range[packetNumber]{0, 1}) test.wantAck(appDataSpace, 0) test.ack(appDataSpace, 0time.Millisecond, i64range[packetNumber]{2, 3}) test.wantAck(appDataSpace, 2) test.ack(appDataSpace, 0time.Millisecond, i64range[packetNumber]{4, 5}) test.wantAck(appDataSpace, 4) test.wantLoss(appDataSpace, 1) test.ack(appDataSpace, 0time.Millisecond, i64range[packetNumber]{6, 7}) test.wantAck(appDataSpace, 6) test.wantLoss(appDataSpace, 3) } func TestLossMultipleSpaces(t testing.T) { // "Loss detection is separate per packet number space [...]" // https://www.rfc-editor.org/rfc/rfc9002.html#section-6-3 test := newLossTest(t, clientSide, lossTestOpts{}) t.Logf("# send packets in different spaces") test.send(initialSpace, 0, 1, 2) test.send(handshakeSpace, 0, 1, 2) test.send(appDataSpace, 0, 1, 2) t.Logf("# ack one packet in each space") test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{1, 2}) test.wantAck(initialSpace, 1) test.ack(handshakeSpace, 0time.Millisecond, i64range[packetNumber]{1, 2}) test.wantAck(handshakeSpace, 1) test.ack(appDataSpace, 0time.Millisecond, i64range[packetNumber]{1, 2}) test.wantAck(appDataSpace, 1) t.Logf("# send more packets") test.send(initialSpace, 3, 4, 5) test.send(handshakeSpace, 3, 4, 5) test.send(appDataSpace, 3, 4, 5) t.Logf("# ack the last packet, triggering loss") test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{5, 6}) test.wantAck(initialSpace, 5) test.wantLoss(initialSpace, 0, 2) test.ack(handshakeSpace, 0time.Millisecond, i64range[packetNumber]{5, 6}) test.wantAck(handshakeSpace, 5) test.wantLoss(handshakeSpace, 0, 2) test.ack(appDataSpace, 0time.Millisecond, i64range[packetNumber]{5, 6}) test.wantAck(appDataSpace, 5) test.wantLoss(appDataSpace, 0, 2) } func TestLossTimeThresholdFirstPacketLost(t testing.T) { // "[...] the packet [...] was sent long enough in the past." // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.1-3.2 test := newLossTest(t, clientSide, lossTestOpts{}) t.Logf("# packet 0 lost after time threshold passes") test.send(initialSpace, 0, 1) test.advance(10 time.Millisecond) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{1, 2}) test.wantAck(initialSpace, 1) t.Logf("# latest_rtt == smoothed_rtt") test.wantVar("smoothed_rtt", 10time.Millisecond) test.wantVar("latest_rtt", 10time.Millisecond) t.Logf("# timeout = 9/8 max(smoothed_rtt, latest_rtt) - time_since_packet_sent") test.wantTimeout(((10 * time.Millisecond * 9) / 8) - 10time.Millisecond) test.advanceToLossTimer() test.wantLoss(initialSpace, 0) } func TestLossTimeThreshold(t testing.T) { // "The time threshold is: // max(kTimeThreshold * max(smoothed_rtt, latest_rtt), kGranularity)" // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.1.2-2 for _, tc := range []struct { name string initialRTT time.Duration latestRTT time.Duration wantTimeout time.Duration }{{ name: "rtt increasing", initialRTT: 10 * time.Millisecond, latestRTT: 20 * time.Millisecond, wantTimeout: 20 * time.Millisecond * 9 / 8, }, { name: "rtt decreasing", initialRTT: 10 * time.Millisecond, latestRTT: 5 * time.Millisecond, wantTimeout: ((710time.Millisecond + 5time.Millisecond) / 8) 9 / 8, }, { name: "rtt less than timer granularity", initialRTT: 500 * time.Microsecond, latestRTT: 500 * time.Microsecond, wantTimeout: 1 * time.Millisecond, }} { t.Run(tc.name, func(t testing.T) { test := newLossTest(t, clientSide, lossTestOpts{}) t.Logf("# first ack establishes smoothed_rtt") test.send(initialSpace, 0) test.advance(tc.initialRTT) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{0, 1}) test.wantAck(initialSpace, 0) t.Logf("# ack of packet 2 starts loss timer for packet 1") test.send(initialSpace, 1, 2) test.advance(tc.latestRTT) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{2, 3}) test.wantAck(initialSpace, 2) t.Logf("# smoothed_rtt = %v", test.c.rtt.smoothedRTT) t.Logf("# latest_rtt = %v", test.c.rtt.latestRTT) t.Logf("# timeout = max(9/8 max(smoothed_rtt, latest_rtt), 1ms)") t.Logf("# (measured since packet 1 sent)") test.wantTimeout(tc.wantTimeout - tc.latestRTT) t.Logf("# advancing to the loss time causes loss of packet 1") test.advanceToLossTimer() test.wantLoss(initialSpace, 1) }) } } func TestLossPTONotAckEliciting(t testing.T) { // "When an ack-eliciting packet is transmitted, // the sender schedules a timer for the PTO period [...]" // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.1-1 test := newLossTest(t, clientSide, lossTestOpts{}) t.Logf("# PTO timer for first packet") test.send(initialSpace, 0) test.wantVar("smoothed_rtt", 333time.Millisecond) // initial value test.wantVar("rttvar", 333time.Millisecond/2) // initial value t.Logf("# PTO = smoothed_rtt + max(4rttvar, 1ms)") test.wantTimeout(999 * time.Millisecond) t.Logf("# sending a non-ack-eliciting packet doesn't adjust PTO") test.advance(333 * time.Millisecond) test.send(initialSpace, 1, sentPacket{ ackEliciting: false, }) test.wantVar("smoothed_rtt", 333time.Millisecond) // unchanged test.wantVar("rttvar", 333time.Millisecond/2) // unchanged test.wantTimeout(666 * time.Millisecond) } func TestLossPTOMaxAckDelay(t testing.T) { // "When the PTO is armed for Initial or Handshake packet number spaces, // the max_ack_delay in the PTO period computation is set to 0 [...]" // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.1-4 test := newLossTest(t, clientSide, lossTestOpts{}) t.Logf("# PTO timer for first packet") test.send(initialSpace, 0) test.wantVar("smoothed_rtt", 333time.Millisecond) // initial value test.wantVar("rttvar", 333time.Millisecond/2) // initial value t.Logf("# PTO = smoothed_rtt + max(4rttvar, 1ms)") test.wantTimeout(999 * time.Millisecond) test.advance(10 * time.Millisecond) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{0, 1}) test.wantAck(initialSpace, 0) t.Logf("# PTO timer for handshake packet") test.send(handshakeSpace, 0) test.wantVar("smoothed_rtt", 10time.Millisecond) test.wantVar("rttvar", 5time.Millisecond) t.Logf("# PTO = smoothed_rtt + max(4rttvar, 1ms)") test.wantTimeout(30 * time.Millisecond) test.advance(10 * time.Millisecond) test.ack(handshakeSpace, 0time.Millisecond, i64range[packetNumber]{0, 1}) test.wantAck(handshakeSpace, 0) test.confirmHandshake() t.Logf("# PTO timer for appdata packet") test.send(appDataSpace, 0) test.wantVar("smoothed_rtt", 10time.Millisecond) test.wantVar("rttvar", 3750time.Microsecond) t.Logf("# PTO = smoothed_rtt + max(4rttvar, 1ms) + max_ack_delay (25ms)") test.wantTimeout(50 * time.Millisecond) } func TestLossPTOUnderTimerGranularity(t testing.T) { // "The PTO period MUST be at least kGranularity [...]" // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.1-5 test := newLossTest(t, clientSide, lossTestOpts{}) test.send(initialSpace, 0) test.advance(10 time.Microsecond) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{0, 1}) test.wantAck(initialSpace, 0) test.send(initialSpace, 1) test.wantVar("smoothed_rtt", 10time.Microsecond) test.wantVar("rttvar", 5time.Microsecond) t.Logf("# PTO = smoothed_rtt + max(4rttvar, 1ms)") test.wantTimeout(10time.Microsecond + 1time.Millisecond) } func TestLossPTOMultipleSpaces(t testing.T) { // "[...] the timer MUST be set to the earlier value of the Initial and Handshake // packet number spaces." // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.1-6 test := newLossTest(t, clientSide, lossTestOpts{}) t.Logf("# PTO timer for first packet") test.send(initialSpace, 0) test.wantVar("smoothed_rtt", 333time.Millisecond) // initial value test.wantVar("rttvar", 333time.Millisecond/2) // initial value t.Logf("# PTO = smoothed_rtt + max(4rttvar, 1ms)") test.wantTimeout(999 * time.Millisecond) t.Logf("# Initial and Handshake packets in flight, first takes precedence") test.advance(333 * time.Millisecond) test.send(handshakeSpace, 0) test.wantTimeout(666 * time.Millisecond) t.Logf("# Initial packet acked, Handshake PTO timer armed") test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{0, 1}) test.wantAck(initialSpace, 0) test.wantTimeout(999 time.Millisecond) t.Logf("# send Initial, earlier Handshake PTO takes precedence") test.advance(333 * time.Millisecond) test.send(initialSpace, 1) test.wantTimeout(666 * time.Millisecond) } func TestLossPTOHandshakeConfirmation(t testing.T) { // "An endpoint MUST NOT set its PTO timer for the Application Data // packet number space until the handshake is confirmed." // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.1-7 test := newLossTest(t, clientSide, lossTestOpts{}) test.send(initialSpace, 0) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{0, 1}) test.wantAck(initialSpace, 0) test.send(handshakeSpace, 0) test.ack(handshakeSpace, 0time.Millisecond, i64range[packetNumber]{0, 1}) test.wantAck(handshakeSpace, 0) test.send(appDataSpace, 0) test.wantNoTimeout() } func TestLossPTOBackoffDoubles(t testing.T) { // "When a PTO timer expires, the PTO backoff MUST be increased, // resulting in the PTO period being set to twice its current value." // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.1-9 test := newLossTest(t, serverSide, lossTestOpts{}) test.datagramReceived(1200) test.send(initialSpace, 0) test.wantVar("smoothed_rtt", 333time.Millisecond) // initial value test.wantVar("rttvar", 333time.Millisecond/2) // initial value t.Logf("# PTO = smoothed_rtt + max(4rttvar, 1ms)") test.wantTimeout(999 time.Millisecond) t.Logf("# wait for PTO timer expiration") test.advanceToLossTimer() test.wantPTOExpired() test.wantNoTimeout() t.Logf("# PTO timer doubles") test.send(initialSpace, 1) test.wantTimeout(2 * 999 * time.Millisecond) test.advanceToLossTimer() test.wantPTOExpired() test.wantNoTimeout() t.Logf("# PTO timer doubles again") test.send(initialSpace, 2) test.wantTimeout(4 * 999 * time.Millisecond) test.advanceToLossTimer() test.wantPTOExpired() test.wantNoTimeout() } func TestLossPTOBackoffResetOnAck(t testing.T) { // "The PTO backoff factor is reset when an acknowledgment is received [...]" // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.1-9 test := newLossTest(t, serverSide, lossTestOpts{}) test.datagramReceived(1200) t.Logf("# first ack establishes smoothed_rtt = 10ms") test.send(initialSpace, 0) test.advance(10 time.Millisecond) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{0, 1}) test.wantAck(initialSpace, 0) t.Logf("# set rttvar for simplicity") test.setRTTVar(0) t.Logf("# send packet 1 and wait for PTO") test.send(initialSpace, 1) test.wantTimeout(11 time.Millisecond) test.advanceToLossTimer() test.wantPTOExpired() test.wantNoTimeout() t.Logf("# send packet 2 & 3, PTO doubles") test.send(initialSpace, 2, 3) test.wantTimeout(22 * time.Millisecond) test.advance(10 * time.Millisecond) t.Logf("# check remaining PTO (22ms - 10ms elapsed)") test.wantTimeout(12 * time.Millisecond) t.Logf("# ACK to packet 2 resets PTO") test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{0, 3}) test.wantAck(initialSpace, 1) test.wantAck(initialSpace, 2) t.Logf("# check remaining PTO (11ms - 10ms elapsed)") test.wantTimeout(1 time.Millisecond) } func TestLossPTOBackoffNotResetOnClientInitialAck(t testing.T) { // "[...] a client does not reset the PTO backoff factor on // receiving acknowledgments in Initial packets." // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.1-9 test := newLossTest(t, clientSide, lossTestOpts{}) t.Logf("# first ack establishes smoothed_rtt = 10ms") test.send(initialSpace, 0) test.advance(10 time.Millisecond) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{0, 1}) test.wantAck(initialSpace, 0) t.Logf("# set rttvar for simplicity") test.setRTTVar(0) t.Logf("# send packet 1 and wait for PTO") test.send(initialSpace, 1) test.wantTimeout(11 time.Millisecond) test.advanceToLossTimer() test.wantPTOExpired() test.wantNoTimeout() t.Logf("# send more packets, PTO doubles") test.send(initialSpace, 2, 3) test.send(handshakeSpace, 0) test.wantTimeout(22 * time.Millisecond) test.advance(10 * time.Millisecond) t.Logf("# check remaining PTO (22ms - 10ms elapsed)") test.wantTimeout(12 * time.Millisecond) // TODO: Is this right? 6.2.1-9 says we don't reset the PTO backoff, not the PTO. // 6.2.1-8 says we reset the PTO timer when an ack-eliciting packet is sent or // acknowledged, but the pseudocode in appendix A doesn't appear to do the latter. t.Logf("# ACK to Initial packet does not reset PTO for client") test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{0, 3}) test.wantAck(initialSpace, 1) test.wantAck(initialSpace, 2) t.Logf("# check remaining PTO (22ms - 10ms elapsed)") test.wantTimeout(12 time.Millisecond) t.Logf("# ACK to handshake packet does reset PTO") test.ack(handshakeSpace, 0time.Millisecond, i64range[packetNumber]{0, 1}) test.wantAck(handshakeSpace, 0) t.Logf("# check remaining PTO (12ms - 10ms elapsed)") test.wantTimeout(1 time.Millisecond) } func TestLossPTONotSetWhenLossTimerSet(t testing.T) { // "The PTO timer MUST NOT be set if a timer is set // for time threshold loss detection [...]" // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.1-12 test := newLossTest(t, serverSide, lossTestOpts{}) test.datagramReceived(1200) t.Logf("# PTO timer set for first packets sent") test.send(initialSpace, 0, 1) test.wantVar("smoothed_rtt", 333time.Millisecond) // initial value test.wantVar("rttvar", 333time.Millisecond/2) // initial value t.Logf("# PTO = smoothed_rtt + max(4rttvar, 1ms)") test.wantTimeout(999 * time.Millisecond) t.Logf("# ack of packet 1 starts loss timer for 0, PTO overidden") test.advance(333 * time.Millisecond) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{1, 2}) test.wantAck(initialSpace, 1) t.Logf("# latest_rtt == smoothed_rtt") test.wantVar("smoothed_rtt", 333time.Millisecond) test.wantVar("latest_rtt", 333time.Millisecond) t.Logf("# timeout = 9/8 max(smoothed_rtt, latest_rtt) - time_since_packet_sent") test.wantTimeout(((333 * time.Millisecond * 9) / 8) - 333time.Millisecond) } func TestLossDiscardingKeysResetsTimers(t testing.T) { // "When Initial or Handshake keys are discarded, // the PTO and loss detection timers MUST be reset" // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.2-3 test := newLossTest(t, clientSide, lossTestOpts{}) t.Logf("# handshake packet sent 1ms after initial") test.send(initialSpace, 0, 1) test.advance(1 * time.Millisecond) test.send(handshakeSpace, 0, 1) test.advance(9 * time.Millisecond) t.Logf("# ack of Initial packet 2 starts loss timer for packet 1") test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{1, 2}) test.wantAck(initialSpace, 1) test.advance(1 time.Millisecond) t.Logf("# smoothed_rtt = %v", 10time.Millisecond) t.Logf("# latest_rtt = %v", 10time.Millisecond) t.Logf("# timeout = max(9/8 * max(smoothed_rtt, latest_rtt), 1ms)") t.Logf("# (measured since Initial packet 1 sent)") test.wantTimeout((10 * time.Millisecond * 9 / 8) - 11time.Millisecond) t.Logf("# ack of Handshake packet 2 starts loss timer for packet 1") test.ack(handshakeSpace, 0time.Millisecond, i64range[packetNumber]{1, 2}) test.wantAck(handshakeSpace, 1) t.Logf("# dropping Initial keys sets timer to Handshake timeout") test.discardKeys(initialSpace) test.wantTimeout((10 * time.Millisecond * 9 / 8) - 10time.Millisecond) } func TestLossNoPTOAtAntiAmplificationLimit(t testing.T) { // "If no additional data can be sent [because the server is at the // anti-amplification limit], the server's PTO timer MUST NOT be armed [...]" // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.2.1-1 test := newLossTest(t, serverSide, lossTestOpts{ maxDatagramSize: 1 << 20, // large initial congestion window }) test.datagramReceived(1200) test.send(initialSpace, 0, sentPacket{ ackEliciting: true, inFlight: true, size: 1200, }) test.wantTimeout(999 * time.Millisecond) t.Logf("PTO timer should be disabled when at the anti-amplification limit") test.send(initialSpace, 1, sentPacket{ ackEliciting: false, inFlight: true, size: 2 * 1200, }) test.wantNoTimeout() // "When the server receives a datagram from the client, the amplification // limit is increased and the server resets the PTO timer." // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.2.1-2 t.Logf("PTO timer should be reset when datagrams are received") test.datagramReceived(1200) test.wantTimeout(999 * time.Millisecond) // "If the PTO timer is then set to a time in the past, it is executed immediately." // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.2.1-2 test.send(initialSpace, 2, sentPacket{ ackEliciting: true, inFlight: true, size: 3 * 1200, }) test.wantNoTimeout() t.Logf("resetting expired PTO timer should exeute immediately") test.advance(1000 * time.Millisecond) test.datagramReceived(1200) test.wantPTOExpired() test.wantNoTimeout() } func TestLossClientSetsPTOWhenHandshakeUnacked(t testing.T) { // "[...] the client MUST set the PTO timer if the client has not // received an acknowledgment for any of its Handshake packets and // the handshake is not confirmed [...]" // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.2.1-3 test := newLossTest(t, clientSide, lossTestOpts{}) test.send(initialSpace, 0) test.wantVar("smoothed_rtt", 333time.Millisecond) // initial value test.wantVar("rttvar", 333time.Millisecond/2) // initial value t.Logf("# PTO = smoothed_rtt + max(4rttvar, 1ms)") test.wantTimeout(999 * time.Millisecond) test.advance(333 * time.Millisecond) test.wantTimeout(666 * time.Millisecond) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{0, 1}) test.wantAck(initialSpace, 0) t.Logf("# PTO timer set for a client before handshake ack even if no packets in flight") test.wantTimeout(999 time.Millisecond) test.advance(333 * time.Millisecond) test.wantTimeout(666 * time.Millisecond) } func TestLossKeysDiscarded(t testing.T) { // "The sender MUST discard all recovery state associated with // [packets in number spaces with discarded keys] and MUST remove // them from the count of bytes in flight." // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.4-1 test := newLossTest(t, clientSide, lossTestOpts{}) test.send(initialSpace, 0, testSentPacketSize(1200)) test.send(handshakeSpace, 0, testSentPacketSize(600)) test.wantVar("bytes_in_flight", 1800) test.discardKeys(initialSpace) test.wantVar("bytes_in_flight", 600) test.discardKeys(handshakeSpace) test.wantVar("bytes_in_flight", 0) } func TestLossInitialCongestionWindow(t testing.T) { // "Endpoints SHOULD use an initial congestion window of [...]" // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.2-1 // "[...] 10 times the maximum datagram size [...]" test := newLossTest(t, clientSide, lossTestOpts{ maxDatagramSize: 1200, }) t.Logf("# congestion_window = 10max_datagram_size (1200)") test.wantVar("congestion_window", 12000) // "[...] while limiting the window to the larger of 14720 bytes [...]" test = newLossTest(t, clientSide, lossTestOpts{ maxDatagramSize: 1500, }) t.Logf("# congestion_window limited to 14720 bytes") test.wantVar("congestion_window", 14720) // "[...] or twice the maximum datagram size." test = newLossTest(t, clientSide, lossTestOpts{ maxDatagramSize: 10000, }) t.Logf("# congestion_window limited to 2max_datagram_size (10000)") test.wantVar("congestion_window", 20000) for _, tc := range []struct { maxDatagramSize int wantInitialBurst int }{{ // "[...] 10 times the maximum datagram size [...]" maxDatagramSize: 1200, wantInitialBurst: 12000, }, { // "[...] while limiting the window to the larger of 14720 bytes [...]" maxDatagramSize: 1500, wantInitialBurst: 14720, }, { // "[...] or twice the maximum datagram size." maxDatagramSize: 10000, wantInitialBurst: 20000, }} { t.Run(fmt.Sprintf("max_datagram_size=%v", tc.maxDatagramSize), func(t testing.T) { test := newLossTest(t, clientSide, lossTestOpts{ maxDatagramSize: tc.maxDatagramSize, }) var num packetNumber window := tc.wantInitialBurst for window >= tc.maxDatagramSize { t.Logf("# %v bytes of initial congestion window remain", window) test.send(initialSpace, num, sentPacket{ ackEliciting: true, inFlight: true, size: tc.maxDatagramSize, }) window -= tc.maxDatagramSize num++ } t.Logf("# congestion window (%v) < max_datagram_size, congestion control blocks send", window) test.wantSendLimit(ccLimited) }) } } func TestLossBytesInFlight(t testing.T) { test := newLossTest(t, clientSide, lossTestOpts{ maxDatagramSize: 1200, }) t.Logf("# sent packets are added to bytes_in_flight") test.wantVar("bytes_in_flight", 0) test.send(initialSpace, 0, testSentPacketSize(1200)) test.wantVar("bytes_in_flight", 1200) test.send(initialSpace, 1, testSentPacketSize(800)) test.wantVar("bytes_in_flight", 2000) t.Logf("# acked packets are removed from bytes_in_flight") test.advance(10 * time.Millisecond) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{1, 2}) test.wantAck(initialSpace, 1) test.wantVar("bytes_in_flight", 1200) t.Logf("# lost packets are removed from bytes_in_flight") test.advanceToLossTimer() test.wantLoss(initialSpace, 0) test.wantVar("bytes_in_flight", 0) } func TestLossCongestionWindowLimit(t testing.T) { // "An endpoint MUST NOT send a packet if it would cause bytes_in_flight // [...] to be larger than the congestion window [...]" // https://www.rfc-editor.org/rfc/rfc9002.html#section-7-7 test := newLossTest(t, clientSide, lossTestOpts{ maxDatagramSize: 1200, }) t.Logf("# consume the initial congestion window") test.send(initialSpace, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, testSentPacketSize(1200)) test.wantSendLimit(ccLimited) t.Logf("# give the pacer bucket time to refill") test.advance(333 * time.Millisecond) // initial RTT t.Logf("# sending limited by congestion window, not the pacer") test.wantVar("congestion_window", 12000) test.wantVar("bytes_in_flight", 12000) test.wantVar("pacer_bucket", 12000) test.wantSendLimit(ccLimited) t.Logf("# receiving an ack opens up the congestion window") test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{0, 1}) test.wantAck(initialSpace, 0) test.wantSendLimit(ccOK) } func TestLossCongestionStates(t testing.T) { test := newLossTest(t, clientSide, lossTestOpts{ maxDatagramSize: 1200, }) t.Logf("# consume the initial congestion window") test.send(initialSpace, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, testSentPacketSize(1200)) test.wantSendLimit(ccLimited) test.wantVar("congestion_window", 12000) // "While a sender is in slow start, the congestion window // increases by the number of bytes acknowledged [...]" // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.3.1-2 test.advance(333 * time.Millisecond) t.Logf("# congestion window increases by number of bytes acked (1200)") test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{0, 1}) test.wantAck(initialSpace, 0) test.wantVar("congestion_window", 13200) // 12000 + 1200 t.Logf("# congestion window increases by number of bytes acked (2400)") test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{0, 3}) test.wantAck(initialSpace, 1, 2) test.wantVar("congestion_window", 15600) // 12000 + 31200 // TODO: ECN-CE count // "The sender MUST exit slow start and enter a recovery period // when a packet is lost [...]" // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.3.1-3 t.Logf("# loss of a packet triggers entry to a recovery period") test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{6, 7}) test.wantAck(initialSpace, 6) test.wantLoss(initialSpace, 3) // "On entering a recovery period, a sender MUST set the slow start // threshold to half the value of the congestion window when loss is detected." // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.3.2-2 t.Logf("# slow_start_threshold = congestion_window / 2") test.wantVar("slow_start_threshold", 7800) // 15600/2 // "[...] a single packet can be sent prior to reduction [of the congestion window]." // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.3.2-3 test.send(initialSpace, 10, testSentPacketSize(1200)) // "The congestion window MUST be set to the reduced value of the slow start // threshold before exiting the recovery period." // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.3.2-2 t.Logf("# congestion window reduced to slow start threshold") test.wantVar("congestion_window", 7800) t.Logf("# acks for packets sent before recovery started do not affect congestion") test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{0, 10}) test.wantAck(initialSpace, 4, 5, 7, 8, 9) test.wantVar("slow_start_threshold", 7800) test.wantVar("congestion_window", 7800) // "A recovery period ends and the sender enters congestion avoidance when // a packet sent during the recovery period is acknowledged." // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.3.2-5 t.Logf("# recovery ends and congestion avoidance begins when packet 10 is acked") test.advance(333 time.Millisecond) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{0, 11}) test.wantAck(initialSpace, 10) // "[...] limit the increase to the congestion window to at most one // maximum datagram size for each congestion window that is acknowledged." // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.3.3-2 t.Logf("# after processing acks for one congestion window's worth of data...") test.send(initialSpace, 11, 12, 13, 14, 15, 16, testSentPacketSize(1200)) test.advance(333 time.Millisecond) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{0, 17}) test.wantAck(initialSpace, 11, 12, 13, 14, 15, 16) t.Logf("# ...congestion window increases by max_datagram_size") test.wantVar("congestion_window", 9000) // 7800 + 1200 // "The sender exits congestion avoidance and enters a recovery period // when a packet is lost [...]" // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.3.3-3 test.send(initialSpace, 17, 18, 19, 20, 21, testSentPacketSize(1200)) test.advance(333 time.Millisecond) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{18, 21}) test.wantAck(initialSpace, 18, 19, 20) test.wantLoss(initialSpace, 17) t.Logf("# slow_start_threshold = congestion_window / 2") test.wantVar("slow_start_threshold", 4500) } func TestLossMinimumCongestionWindow(t testing.T) { // "The RECOMMENDED [minimum congestion window] is 2 * max_datagram_size." // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.2-4 test := newLossTest(t, clientSide, lossTestOpts{ maxDatagramSize: 1200, }) test.send(initialSpace, 0, 1, 2, 3, testSentPacketSize(1200)) test.wantVar("congestion_window", 12000) t.Logf("# enter recovery") test.advance(333 * time.Millisecond) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{3, 4}) test.wantAck(initialSpace, 3) test.wantLoss(initialSpace, 0) test.wantVar("congestion_window", 6000) t.Logf("# enter congestion avoidance and return to recovery") test.send(initialSpace, 4, 5, 6, 7) test.advance(333 time.Millisecond) test.wantLoss(initialSpace, 1, 2) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{7, 8}) test.wantAck(initialSpace, 7) test.wantLoss(initialSpace, 4) test.wantVar("congestion_window", 3000) t.Logf("# enter congestion avoidance and return to recovery") test.send(initialSpace, 8, 9, 10, 11) test.advance(333 time.Millisecond) test.wantLoss(initialSpace, 5, 6) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{11, 12}) test.wantAck(initialSpace, 11) test.wantLoss(initialSpace, 8) t.Logf("# congestion window does not fall below 2max_datagram_size") test.wantVar("congestion_window", 2400) t.Logf("# enter congestion avoidance and return to recovery") test.send(initialSpace, 12, 13, 14, 15) test.advance(333 * time.Millisecond) test.wantLoss(initialSpace, 9, 10) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{15, 16}) test.wantAck(initialSpace, 15) test.wantLoss(initialSpace, 12) t.Logf("# congestion window does not fall below 2max_datagram_size") test.wantVar("congestion_window", 2400) } func TestLossPersistentCongestion(t testing.T) { // "When persistent congestion is declared, the sender's congestion // window MUST be reduced to the minimum congestion window [...]" // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.6.2-6 test := newLossTest(t, clientSide, lossTestOpts{ maxDatagramSize: 1200, }) test.send(initialSpace, 0, testSentPacketSize(1200)) test.c.cc.setUnderutilized(nil, true) test.advance(10 time.Millisecond) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{0, 1}) test.wantAck(initialSpace, 0) t.Logf("# set rttvar for simplicity") test.setRTTVar(0) test.wantVar("smoothed_rtt", 10time.Millisecond) t.Logf("# persistent congestion duration = 3(smoothed_rtt + timerGranularity + max_ack_delay)") t.Logf("# persistent congestion duration = 108ms") t.Logf("# sending packets 1-5 over 108ms") test.send(initialSpace, 1, testSentPacketSize(1200)) test.advance(11 time.Millisecond) // total 11ms test.wantPTOExpired() test.send(initialSpace, 2, testSentPacketSize(1200)) test.advance(22 * time.Millisecond) // total 33ms test.wantPTOExpired() test.send(initialSpace, 3, testSentPacketSize(1200)) test.advance(44 * time.Millisecond) // total 77ms test.wantPTOExpired() test.send(initialSpace, 4, testSentPacketSize(1200)) test.advance(31 * time.Millisecond) // total 108ms test.send(initialSpace, 5, testSentPacketSize(1200)) t.Logf("# 108ms between packets 1-5") test.wantVar("congestion_window", 12000) t.Logf("# triggering loss of packets 1-5") test.send(initialSpace, 6, 7, 8, testSentPacketSize(1200)) test.advance(10 * time.Millisecond) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{8, 9}) test.wantAck(initialSpace, 8) test.wantLoss(initialSpace, 1, 2, 3, 4, 5) t.Logf("# lost packets spanning persistent congestion duration") t.Logf("# congestion_window = 2 max_datagram_size (minimum)") test.wantVar("congestion_window", 2400) } func TestLossSimplePersistentCongestion(t testing.T) { // Simpler version of TestLossPersistentCongestion which acts as a // base for subsequent tests. test := newLossTest(t, clientSide, lossTestOpts{ maxDatagramSize: 1200, }) t.Logf("# establish initial RTT sample") test.send(initialSpace, 0, testSentPacketSize(1200)) test.advance(10 time.Millisecond) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{0, 1}) test.wantAck(initialSpace, 0) t.Logf("# send two packets spanning persistent congestion duration") test.send(initialSpace, 1, testSentPacketSize(1200)) t.Logf("# 2000ms >> persistent congestion duration") test.advance(2000 time.Millisecond) test.wantPTOExpired() test.send(initialSpace, 2, testSentPacketSize(1200)) t.Logf("# trigger loss of previous packets") test.advance(10 * time.Millisecond) test.send(initialSpace, 3, testSentPacketSize(1200)) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{3, 4}) test.wantAck(initialSpace, 3) test.wantLoss(initialSpace, 1, 2) t.Logf("# persistent congestion detected") test.wantVar("congestion_window", 2400) } func TestLossPersistentCongestionAckElicitingPackets(t testing.T) { // "These two packets MUST be ack-eliciting [...]" // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.6.2-3 test := newLossTest(t, clientSide, lossTestOpts{ maxDatagramSize: 1200, }) t.Logf("# establish initial RTT sample") test.send(initialSpace, 0, testSentPacketSize(1200)) test.advance(10 * time.Millisecond) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{0, 1}) test.wantAck(initialSpace, 0) t.Logf("# send two packets spanning persistent congestion duration") test.send(initialSpace, 1, testSentPacketSize(1200)) t.Logf("# 2000ms >> persistent congestion duration") test.advance(2000 time.Millisecond) test.wantPTOExpired() test.send(initialSpace, 2, sentPacket{ inFlight: true, ackEliciting: false, size: 1200, }) test.send(initialSpace, 3, testSentPacketSize(1200)) // PTO probe t.Logf("# trigger loss of previous packets") test.advance(10 * time.Millisecond) test.send(initialSpace, 4, testSentPacketSize(1200)) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{3, 5}) test.wantAck(initialSpace, 3) test.wantAck(initialSpace, 4) test.wantLoss(initialSpace, 1, 2) t.Logf("# persistent congestion not detected: packet 2 is not ack-eliciting") test.wantVar("congestion_window", (12000+1200+1200-1200)/2) } func TestLossNoPersistentCongestionWithoutRTTSample(t testing.T) { // "The persistent congestion period SHOULD NOT start until there // is at least one RTT sample." // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.6.2-4 test := newLossTest(t, clientSide, lossTestOpts{ maxDatagramSize: 1200, }) t.Logf("# packets sent before initial RTT sample") test.send(initialSpace, 0, testSentPacketSize(1200)) test.advance(2000 * time.Millisecond) test.wantPTOExpired() test.send(initialSpace, 1, testSentPacketSize(1200)) test.advance(10 * time.Millisecond) test.send(initialSpace, 2, testSentPacketSize(1200)) t.Logf("# first ack establishes RTT sample") test.advance(10 * time.Millisecond) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{2, 3}) test.wantAck(initialSpace, 2) test.wantLoss(initialSpace, 0, 1) t.Logf("# loss of packets before initial RTT sample does not cause persistent congestion") test.wantVar("congestion_window", 12000/2) } func TestLossPacerRefillRate(t testing.T) { // "A sender SHOULD pace sending of all in-flight packets based on // input from the congestion controller." // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.7-1 test := newLossTest(t, clientSide, lossTestOpts{ maxDatagramSize: 1200, }) t.Logf("# consume the initial congestion window") test.send(initialSpace, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, testSentPacketSize(1200)) test.wantSendLimit(ccLimited) test.wantVar("pacer_bucket", 0) test.wantVar("congestion_window", 12000) t.Logf("# first RTT sample establishes smoothed_rtt") rtt := 100 * time.Millisecond test.advance(rtt) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{0, 10}) test.wantAck(initialSpace, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9) test.wantVar("congestion_window", 24000) // 12000 + 101200 test.wantVar("smoothed_rtt", rtt) t.Logf("# advance 1 RTT to let the pacer bucket refill completely") test.advance(100 * time.Millisecond) t.Logf("# pacer_bucket = initial_congestion_window") test.wantVar("pacer_bucket", 12000) t.Logf("# consume capacity from the pacer bucket") test.send(initialSpace, 10, testSentPacketSize(1200)) test.wantVar("pacer_bucket", 10800) // 12000 - 1200 test.send(initialSpace, 11, testSentPacketSize(600)) test.wantVar("pacer_bucket", 10200) // 10800 - 600 test.send(initialSpace, 12, testSentPacketSize(600)) test.wantVar("pacer_bucket", 9600) // 10200 - 600 test.send(initialSpace, 13, 14, 15, 16, testSentPacketSize(1200)) test.wantVar("pacer_bucket", 4800) // 9600 - 41200 t.Logf("# advance 1/10 of an RTT, bucket refills") test.advance(rtt / 10) t.Logf("# pacer_bucket += 1.25 (1/10) * congestion_window") t.Logf("# += 3000") test.wantVar("pacer_bucket", 7800) } func TestLossPacerNextSendTime(t testing.T) { test := newLossTest(t, clientSide, lossTestOpts{ maxDatagramSize: 1200, }) t.Logf("# consume the initial congestion window") test.send(initialSpace, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, testSentPacketSize(1200)) test.wantSendLimit(ccLimited) test.wantVar("pacer_bucket", 0) test.wantVar("congestion_window", 12000) t.Logf("# first RTT sample establishes smoothed_rtt") rtt := 100 time.Millisecond test.advance(rtt) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{0, 10}) test.wantAck(initialSpace, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9) test.wantVar("congestion_window", 24000) // 12000 + 101200 test.wantVar("smoothed_rtt", rtt) t.Logf("# advance 1 RTT to let the pacer bucket refill completely") test.advance(100 * time.Millisecond) t.Logf("# pacer_bucket = initial_congestion_window") test.wantVar("pacer_bucket", 12000) t.Logf("# consume the refilled pacer bucket") test.send(initialSpace, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, testSentPacketSize(1200)) test.wantSendLimit(ccPaced) t.Logf("# refill rate = 1.25 * congestion_window / rtt") test.wantSendDelay(rtt / 25) // rtt / (1.25 * 24000 / 1200) t.Logf("# no capacity available yet") test.advance(rtt / 50) test.wantVar("pacer_bucket", -600) test.wantSendLimit(ccPaced) t.Logf("# capacity available") test.advance(rtt / 50) test.wantVar("pacer_bucket", 0) test.wantSendLimit(ccOK) } func TestLossCongestionWindowUnderutilized(t testing.T) { // "When bytes in flight is smaller than the congestion window // and sending is not pacing limited [...] the congestion window // SHOULD NOT be increased in either slow start or congestion avoidance." // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.8-1 test := newLossTest(t, clientSide, lossTestOpts{ maxDatagramSize: 1200, }) test.send(initialSpace, 0, testSentPacketSize(1200)) test.setUnderutilized(true) t.Logf("# underutilized: %v", test.c.cc.underutilized) test.wantVar("congestion_window", 12000) test.advance(10 time.Millisecond) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{0, 1}) test.wantAck(initialSpace, 0) t.Logf("# congestion window does not increase, because window is underutilized") test.wantVar("congestion_window", 12000) t.Logf("# refill pacer bucket") test.advance(10 time.Millisecond) test.wantVar("pacer_bucket", 12000) test.send(initialSpace, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, testSentPacketSize(1200)) test.setUnderutilized(false) test.advance(10 * time.Millisecond) test.ack(initialSpace, 0time.Millisecond, i64range[packetNumber]{0, 11}) test.wantAck(initialSpace, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10) t.Logf("# congestion window increases") test.wantVar("congestion_window", 24000) } type lossTest struct { t testing.T c lossState now time.Time fates map[spaceNum]packetFate failed bool } type lossTestOpts struct { maxDatagramSize int } func newLossTest(t testing.T, side connSide, opts lossTestOpts) lossTest { c := &lossTest{ t: t, now: time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC), fates: make(map[spaceNum]packetFate), } maxDatagramSize := 1200 if opts.maxDatagramSize != 0 { maxDatagramSize = opts.maxDatagramSize } c.c.init(side, maxDatagramSize, c.now) t.Cleanup(func() { if !c.failed { c.checkUnexpectedEvents() } }) return c } type spaceNum struct { space numberSpace num packetNumber } func (c lossTest) checkUnexpectedEvents() { c.t.Helper() for sn, fate := range c.fates { c.t.Errorf("ERROR: unexpected %v: %v %v", fate, sn.space, sn.num) } if c.c.ptoExpired { c.t.Errorf("ERROR: PTO timer unexpectedly expired") } } func (c lossTest) setSmoothedRTT(d time.Duration) { c.t.Helper() c.checkUnexpectedEvents() c.t.Logf("set smoothed_rtt to %v", d) c.c.rtt.smoothedRTT = d } func (c lossTest) setRTTVar(d time.Duration) { c.t.Helper() c.checkUnexpectedEvents() c.t.Logf("set rttvar to %v", d) c.c.rtt.rttvar = d } func (c lossTest) setUnderutilized(v bool) { c.t.Logf("set congestion window underutilized: %v", v) c.c.cc.setUnderutilized(nil, v) } func (c lossTest) advance(d time.Duration) { c.t.Helper() c.checkUnexpectedEvents() c.t.Logf("advance time %v", d) c.now = c.now.Add(d) c.c.advance(c.now, c.onAckOrLoss) } func (c lossTest) advanceToLossTimer() { c.t.Helper() c.checkUnexpectedEvents() d := c.c.timer.Sub(c.now) c.t.Logf("advance time %v (up to loss timer)", d) if d < 0 { c.t.Fatalf("loss timer is in the past") } c.now = c.c.timer c.c.advance(c.now, c.onAckOrLoss) } type testSentPacketSize int func (c lossTest) send(spaceID numberSpace, opts ...any) { c.t.Helper() c.checkUnexpectedEvents() var nums []packetNumber prototype := sentPacket{ ackEliciting: true, inFlight: true, } for _, o := range opts { switch o := o.(type) { case sentPacket: prototype = o case testSentPacketSize: prototype.size = int(o) case int: nums = append(nums, packetNumber(o)) case packetNumber: nums = append(nums, o) case i64range[packetNumber]: for num := o.start; num < o.end; num++ { nums = append(nums, num) } } } c.t.Logf("send %v %v", spaceID, nums) limit, _ := c.c.sendLimit(c.now) if prototype.inFlight && limit != ccOK { c.t.Fatalf("congestion control blocks sending packet") } if !prototype.inFlight && limit == ccBlocked { c.t.Fatalf("congestion control blocks sending packet") } for _, num := range nums { sent := &sentPacket{} sent = prototype sent.num = num c.c.packetSent(c.now, nil, spaceID, sent) } } func (c lossTest) datagramReceived(size int) { c.t.Helper() c.checkUnexpectedEvents() c.t.Logf("receive %v-byte datagram", size) c.c.datagramReceived(c.now, size) } func (c lossTest) ack(spaceID numberSpace, ackDelay time.Duration, rs ...i64range[packetNumber]) { c.t.Helper() c.checkUnexpectedEvents() c.c.receiveAckStart() var acked rangeset[packetNumber] for _, r := range rs { c.t.Logf("ack %v delay=%v [%v,%v)", spaceID, ackDelay, r.start, r.end) acked.add(r.start, r.end) } for i, r := range rs { c.t.Logf("ack %v delay=%v [%v,%v)", spaceID, ackDelay, r.start, r.end) c.c.receiveAckRange(c.now, spaceID, i, r.start, r.end, c.onAckOrLoss) } c.c.receiveAckEnd(c.now, nil, spaceID, ackDelay, c.onAckOrLoss) } func (c lossTest) onAckOrLoss(space numberSpace, sent sentPacket, fate packetFate) { c.t.Logf("%v %v %v", fate, space, sent.num) if _, ok := c.fates[spaceNum{space, sent.num}]; ok { c.t.Errorf("ERROR: duplicate %v for %v %v", fate, space, sent.num) } c.fates[spaceNum{space, sent.num}] = fate } func (c lossTest) confirmHandshake() { c.t.Helper() c.checkUnexpectedEvents() c.t.Logf("confirm handshake") c.c.confirmHandshake() } func (c lossTest) validateClientAddress() { c.t.Helper() c.checkUnexpectedEvents() c.t.Logf("validate client address") c.c.validateClientAddress() } func (c lossTest) discardKeys(spaceID numberSpace) { c.t.Helper() c.checkUnexpectedEvents() c.t.Logf("discard %s keys", spaceID) c.c.discardKeys(c.now, nil, spaceID) } func (c lossTest) setMaxAckDelay(d time.Duration) { c.t.Helper() c.checkUnexpectedEvents() c.t.Logf("set max_ack_delay = %v", d) c.c.setMaxAckDelay(d) } func (c lossTest) wantAck(spaceID numberSpace, nums ...packetNumber) { c.t.Helper() for _, num := range nums { if c.fates[spaceNum{spaceID, num}] != packetAcked { c.t.Fatalf("expected ack for %v %v\n", spaceID, num) } delete(c.fates, spaceNum{spaceID, num}) } } func (c lossTest) wantLoss(spaceID numberSpace, nums ...packetNumber) { c.t.Helper() for _, num := range nums { if c.fates[spaceNum{spaceID, num}] != packetLost { c.t.Fatalf("expected loss of %v %v\n", spaceID, num) } delete(c.fates, spaceNum{spaceID, num}) } } func (c lossTest) wantPTOExpired() { c.t.Helper() if !c.c.ptoExpired { c.t.Fatalf("expected PTO timer to expire") } else { c.t.Logf("PTO TIMER EXPIRED") } c.c.ptoExpired = false } func (l ccLimit) String() string { switch l { case ccOK: return "ccOK" case ccBlocked: return "ccBlocked" case ccLimited: return "ccLimited" case ccPaced: return "ccPaced" } return "BUG" } func (c lossTest) wantSendLimit(want ccLimit) { c.t.Helper() if got, _ := c.c.sendLimit(c.now); got != want { c.t.Fatalf("congestion control send limit is %v, want %v", got, want) } } func (c lossTest) wantSendDelay(want time.Duration) { c.t.Helper() limit, next := c.c.sendLimit(c.now) if limit != ccPaced { c.t.Fatalf("congestion control limit is %v, want %v", limit, ccPaced) } got := next.Sub(c.now) if got != want { c.t.Fatalf("delay until next send is %v, want %v", got, want) } } func (c lossTest) wantVar(name string, want any) { c.t.Helper() var got any switch name { case "latest_rtt": got = c.c.rtt.latestRTT case "min_rtt": got = c.c.rtt.minRTT case "smoothed_rtt": got = c.c.rtt.smoothedRTT case "rttvar": got = c.c.rtt.rttvar case "congestion_window": got = c.c.cc.congestionWindow case "slow_start_threshold": got = c.c.cc.slowStartThreshold case "bytes_in_flight": got = c.c.cc.bytesInFlight case "pacer_bucket": got = c.c.pacer.bucket default: c.t.Fatalf("unknown var %q", name) } if got != want { c.t.Fatalf("%v = %v, want %v\n", name, got, want) } else { c.t.Logf("%v = %v", name, got) } } func (c lossTest) wantTimeout(want time.Duration) { c.t.Helper() if c.c.timer.IsZero() { c.t.Fatalf("loss detection timer is not set, want %v", want) } got := c.c.timer.Sub(c.now) if got != want { c.t.Fatalf("loss detection timer expires in %v, want %v", got, want) } c.t.Logf("loss detection timer expires in %v", got) } func (c lossTest) wantNoTimeout() { c.t.Helper() if !c.c.timer.IsZero() { d := c.c.timer.Sub(c.now) c.t.Fatalf("loss detection timer expires in %v, want not set", d) } c.t.Logf("loss detection timer is not set") } func (f packetFate) String() string { switch f { case packetAcked: return "ACK" case packetLost: return "LOSS" default: panic("unknown packetFate") } }	57 KB	2025-05-25 12:27
📄 main_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "bytes" "fmt" "os" "runtime" "testing" "time" ) func TestMain(m testing.M) { // Add all goroutines running at the start of the test to the set // of not-leaked goroutines. This includes TestMain, and anything else // that might have been started by test infrastructure. skip := [][]byte{ []byte("created by os/signal.Notify"), []byte("gotraceback_test.go"), } buf := make([]byte, 2<<20) buf = buf[:runtime.Stack(buf, true)] for _, g := range bytes.Split(buf, []byte("\n\n")) { id, _, _ := bytes.Cut(g, []byte("[")) skip = append(skip, id) } defer os.Exit(m.Run()) // Look for leaked goroutines. // // Checking after every test makes it easier to tell which test is the culprit, // but checking once at the end is faster and less likely to miss something. if runtime.GOOS == "js" { // The js-wasm runtime creates an additional background goroutine. // Just skip the leak check there. return } start := time.Now() warned := false for { buf := make([]byte, 2<<20) buf = buf[:runtime.Stack(buf, true)] leaked := false for _, g := range bytes.Split(buf, []byte("\n\n")) { leaked = true for _, s := range skip { if bytes.Contains(g, s) { leaked = false break } } } if !leaked { break } if !warned && time.Since(start) > 1time.Second { // Print a warning quickly, in case this is an interactive session. // Keep waiting until the test times out, in case this is a slow trybot. fmt.Printf("Tests seem to have leaked some goroutines, still waiting.\n\n") fmt.Print(string(buf)) warned = true } // Goroutines might still be shutting down. time.Sleep(1 * time.Millisecond) } }	1.84 KB	2025-05-25 12:27
📄 math.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic func abs[T ~int \| ~int64](a T) T { if a < 0 { return -a } return a }	267 B	2025-05-25 12:27
📄 pacer.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "time" ) // A pacerState controls the rate at which packets are sent using a leaky-bucket rate limiter. // // The pacer limits the maximum size of a burst of packets. // When a burst exceeds this limit, it spreads subsequent packets // over time. // // The bucket is initialized to the maximum burst size (ten packets by default), // and fills at the rate: // // 1.25 * congestion_window / smoothed_rtt // // A sender can send one congestion window of packets per RTT, // since the congestion window consumed by each packet is returned // one round-trip later by the responding ack. // The pacer permits sending at slightly faster than this rate to // avoid underutilizing the congestion window. // // The pacer permits the bucket to become negative, and permits // sending when non-negative. This biases slightly in favor of // sending packets over limiting them, and permits bursts one // packet greater than the configured maximum, but permits the pacer // to be ignorant of the maximum packet size. // // https://www.rfc-editor.org/rfc/rfc9002.html#section-7.7 type pacerState struct { bucket int // measured in bytes maxBucket int timerGranularity time.Duration lastUpdate time.Time nextSend time.Time } func (p pacerState) init(now time.Time, maxBurst int, timerGranularity time.Duration) { // Bucket is limited to maximum burst size, which is the initial congestion window. // https://www.rfc-editor.org/rfc/rfc9002#section-7.7-2 p.maxBucket = maxBurst p.bucket = p.maxBucket p.timerGranularity = timerGranularity p.lastUpdate = now p.nextSend = now } // pacerBytesForInterval returns the number of bytes permitted over an interval. // // rate = 1.25 congestion_window / smoothed_rtt // bytes = interval * rate // // https://www.rfc-editor.org/rfc/rfc9002#section-7.7-6 func pacerBytesForInterval(interval time.Duration, congestionWindow int, rtt time.Duration) int { bytes := (int64(interval) * int64(congestionWindow)) / int64(rtt) bytes = (bytes * 5) / 4 // bytes = 1.25 return int(bytes) } // pacerIntervalForBytes returns the amount of time required for a number of bytes. // // time_per_byte = (smoothed_rtt / congestion_window) / 1.25 // interval = time_per_byte bytes // // https://www.rfc-editor.org/rfc/rfc9002#section-7.7-8 func pacerIntervalForBytes(bytes int, congestionWindow int, rtt time.Duration) time.Duration { interval := (int64(rtt) * int64(bytes)) / int64(congestionWindow) interval = (interval * 4) / 5 // interval /= 1.25 return time.Duration(interval) } // advance is called when time passes. func (p pacerState) advance(now time.Time, congestionWindow int, rtt time.Duration) { elapsed := now.Sub(p.lastUpdate) if elapsed < 0 { // Time has gone backward? elapsed = 0 p.nextSend = now // allow a packet through to get back on track if p.bucket < 0 { p.bucket = 0 } } p.lastUpdate = now if rtt == 0 { // Avoid divide by zero in the implausible case that we measure no RTT. p.bucket = p.maxBucket return } // Refill the bucket. delta := pacerBytesForInterval(elapsed, congestionWindow, rtt) p.bucket = min(p.bucket+delta, p.maxBucket) } // packetSent is called to record transmission of a packet. func (p pacerState) packetSent(now time.Time, size, congestionWindow int, rtt time.Duration) { p.bucket -= size if p.bucket < -congestionWindow { // Never allow the bucket to fall more than one congestion window in arrears. // We can only fall this far behind if the sender is sending unpaced packets, // the congestion window has been exceeded, or the RTT is less than the // timer granularity. // // Limiting the minimum bucket size limits the maximum pacer delay // to RTT/1.25. p.bucket = -congestionWindow } if p.bucket >= 0 { p.nextSend = now return } // Next send occurs when the bucket has refilled to 0. delay := pacerIntervalForBytes(-p.bucket, congestionWindow, rtt) p.nextSend = now.Add(delay) } // canSend reports whether a packet can be sent now. // If it returns false, next is the time when the next packet can be sent. func (p *pacerState) canSend(now time.Time) (canSend bool, next time.Time) { // If the next send time is within the timer granularity, send immediately. if p.nextSend.After(now.Add(p.timerGranularity)) { return false, p.nextSend } return true, time.Time{} }	4.45 KB	2025-05-25 12:27
📄 pacer_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "testing" "time" ) func TestPacerStartup(t testing.T) { p := &pacerTest{ cwnd: 10000, rtt: 100 time.Millisecond, timerGranularity: 1 * time.Millisecond, } p.init(t) t.Logf("# initial burst permits sending ten packets") for i := 0; i < 10; i++ { p.sendPacket(1000) } t.Logf("# empty bucket allows for one more packet") p.sendPacket(1000) t.Logf("# sending 1000 byte packets with 8ms interval:") t.Logf("# (smoothed_rtt * packet_size / congestion_window) / 1.25") t.Logf("# (100ms * 1000 / 10000) / 1.25 = 8ms") p.wantSendDelay(8 * time.Millisecond) p.advance(8 * time.Millisecond) p.sendPacket(1000) p.wantSendDelay(8 * time.Millisecond) t.Logf("# accumulate enough window for two packets") p.advance(16 * time.Millisecond) p.sendPacket(1000) p.sendPacket(1000) p.wantSendDelay(8 * time.Millisecond) t.Logf("# window does not grow to more than burst limit") p.advance(1 * time.Second) for i := 0; i < 11; i++ { p.sendPacket(1000) } p.wantSendDelay(8 * time.Millisecond) } func TestPacerTimerGranularity(t testing.T) { p := &pacerTest{ cwnd: 10000, rtt: 100 time.Millisecond, timerGranularity: 1 * time.Millisecond, } p.init(t) t.Logf("# consume initial burst") for i := 0; i < 11; i++ { p.sendPacket(1000) } p.wantSendDelay(8 * time.Millisecond) t.Logf("# small advance in time does not permit sending") p.advance(4 * time.Millisecond) p.wantSendDelay(4 * time.Millisecond) t.Logf("# advancing to within timerGranularity of next send permits send") p.advance(3 * time.Millisecond) p.wantSendDelay(0) t.Logf("# early send adds skipped delay (1ms) to next send (8ms)") p.sendPacket(1000) p.wantSendDelay(9 * time.Millisecond) } func TestPacerChangingRate(t testing.T) { p := &pacerTest{ cwnd: 10000, rtt: 100 time.Millisecond, timerGranularity: 0, } p.init(t) t.Logf("# consume initial burst") for i := 0; i < 11; i++ { p.sendPacket(1000) } p.wantSendDelay(8 * time.Millisecond) p.advance(8 * time.Millisecond) t.Logf("# set congestion window to 20000, 1000 byte interval is 4ms") p.cwnd = 20000 p.sendPacket(1000) p.wantSendDelay(4 * time.Millisecond) p.advance(4 * time.Millisecond) t.Logf("# set rtt to 200ms, 1000 byte interval is 8ms") p.rtt = 200 * time.Millisecond p.sendPacket(1000) p.wantSendDelay(8 * time.Millisecond) p.advance(8 * time.Millisecond) t.Logf("# set congestion window to 40000, 1000 byte interval is 4ms") p.cwnd = 40000 p.advance(8 * time.Millisecond) p.sendPacket(1000) p.sendPacket(1000) p.sendPacket(1000) p.wantSendDelay(4 * time.Millisecond) } func TestPacerTimeReverses(t testing.T) { p := &pacerTest{ cwnd: 10000, rtt: 100 time.Millisecond, timerGranularity: 0, } p.init(t) t.Logf("# consume initial burst") for i := 0; i < 11; i++ { p.sendPacket(1000) } p.wantSendDelay(8 * time.Millisecond) t.Logf("# reverse time") p.advance(-4 * time.Millisecond) p.sendPacket(1000) p.wantSendDelay(8 * time.Millisecond) p.advance(8 * time.Millisecond) p.sendPacket(1000) p.wantSendDelay(8 * time.Millisecond) } func TestPacerZeroRTT(t testing.T) { p := &pacerTest{ cwnd: 10000, rtt: 0, timerGranularity: 0, } p.init(t) t.Logf("# with rtt 0, the pacer does not limit sending") for i := 0; i < 20; i++ { p.sendPacket(1000) } p.advance(1 time.Second) for i := 0; i < 20; i++ { p.sendPacket(1000) } } func TestPacerZeroCongestionWindow(t testing.T) { p := &pacerTest{ cwnd: 10000, rtt: 100 time.Millisecond, timerGranularity: 0, } p.init(t) p.cwnd = 0 t.Logf("# with cwnd 0, the pacer does not limit sending") for i := 0; i < 20; i++ { p.sendPacket(1000) } } type pacerTest struct { t testing.T p pacerState timerGranularity time.Duration cwnd int rtt time.Duration now time.Time } func newPacerTest(t testing.T, congestionWindow int, rtt time.Duration) pacerTest { p := &pacerTest{ now: time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC), cwnd: congestionWindow, rtt: rtt, } p.p.init(p.now, congestionWindow, p.timerGranularity) return p } func (p pacerTest) init(t testing.T) { p.t = t p.now = time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC) p.p.init(p.now, p.cwnd, p.timerGranularity) t.Logf("# initial congestion window: %v", p.cwnd) t.Logf("# timer granularity: %v", p.timerGranularity) } func (p pacerTest) advance(d time.Duration) { p.t.Logf("advance time %v", d) p.now = p.now.Add(d) p.p.advance(p.now, p.cwnd, p.rtt) } func (p pacerTest) sendPacket(size int) { if canSend, next := p.p.canSend(p.now); !canSend { p.t.Fatalf("ERROR: pacer unexpectedly blocked send, delay=%v", next.Sub(p.now)) } p.t.Logf("send packet of size %v", size) p.p.packetSent(p.now, size, p.cwnd, p.rtt) } func (p pacerTest) wantSendDelay(want time.Duration) { wantCanSend := want == 0 gotCanSend, next := p.p.canSend(p.now) var got time.Duration if !gotCanSend { got = next.Sub(p.now) } p.t.Logf("# pacer send delay: %v", got) if got != want \|\| gotCanSend != wantCanSend { p.t.Fatalf("ERROR: pacer send delay = %v (can send: %v); want %v, %v", got, gotCanSend, want, wantCanSend) } } func (p *pacerTest) sendDelay() time.Duration { canSend, next := p.p.canSend(p.now) if canSend { return 0 } return next.Sub(p.now) }	5.54 KB	2025-05-25 12:27
📄 packet.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "encoding/binary" "fmt" ) // packetType is a QUIC packet type. // https://www.rfc-editor.org/rfc/rfc9000.html#section-17 type packetType byte const ( packetTypeInvalid = packetType(iota) packetTypeInitial packetType0RTT packetTypeHandshake packetTypeRetry packetType1RTT packetTypeVersionNegotiation ) func (p packetType) String() string { switch p { case packetTypeInitial: return "Initial" case packetType0RTT: return "0-RTT" case packetTypeHandshake: return "Handshake" case packetTypeRetry: return "Retry" case packetType1RTT: return "1-RTT" } return fmt.Sprintf("unknown packet type %v", byte(p)) } func (p packetType) qlogString() string { switch p { case packetTypeInitial: return "initial" case packetType0RTT: return "0RTT" case packetTypeHandshake: return "handshake" case packetTypeRetry: return "retry" case packetType1RTT: return "1RTT" } return "unknown" } // Bits set in the first byte of a packet. const ( headerFormLong = 0x80 // https://www.rfc-editor.org/rfc/rfc9000.html#section-17.2-3.2.1 headerFormShort = 0x00 // https://www.rfc-editor.org/rfc/rfc9000.html#section-17.3.1-4.2.1 fixedBit = 0x40 // https://www.rfc-editor.org/rfc/rfc9000.html#section-17.2-3.4.1 reservedLongBits = 0x0c // https://www.rfc-editor.org/rfc/rfc9000#section-17.2-8.2.1 reserved1RTTBits = 0x18 // https://www.rfc-editor.org/rfc/rfc9000#section-17.3.1-4.8.1 keyPhaseBit = 0x04 // https://www.rfc-editor.org/rfc/rfc9000#section-17.3.1-4.10.1 ) // Long Packet Type bits. // https://www.rfc-editor.org/rfc/rfc9000.html#section-17.2-3.6.1 const ( longPacketTypeInitial = 0 << 4 longPacketType0RTT = 1 << 4 longPacketTypeHandshake = 2 << 4 longPacketTypeRetry = 3 << 4 ) // Frame types. // https://www.rfc-editor.org/rfc/rfc9000.html#section-19 const ( frameTypePadding = 0x00 frameTypePing = 0x01 frameTypeAck = 0x02 frameTypeAckECN = 0x03 frameTypeResetStream = 0x04 frameTypeStopSending = 0x05 frameTypeCrypto = 0x06 frameTypeNewToken = 0x07 frameTypeStreamBase = 0x08 // low three bits carry stream flags frameTypeMaxData = 0x10 frameTypeMaxStreamData = 0x11 frameTypeMaxStreamsBidi = 0x12 frameTypeMaxStreamsUni = 0x13 frameTypeDataBlocked = 0x14 frameTypeStreamDataBlocked = 0x15 frameTypeStreamsBlockedBidi = 0x16 frameTypeStreamsBlockedUni = 0x17 frameTypeNewConnectionID = 0x18 frameTypeRetireConnectionID = 0x19 frameTypePathChallenge = 0x1a frameTypePathResponse = 0x1b frameTypeConnectionCloseTransport = 0x1c frameTypeConnectionCloseApplication = 0x1d frameTypeHandshakeDone = 0x1e ) // The low three bits of STREAM frames. // https://www.rfc-editor.org/rfc/rfc9000.html#section-19.8 const ( streamOffBit = 0x04 streamLenBit = 0x02 streamFinBit = 0x01 ) // Maximum length of a connection ID. const maxConnIDLen = 20 // isLongHeader returns true if b is the first byte of a long header. func isLongHeader(b byte) bool { return b&headerFormLong == headerFormLong } // getPacketType returns the type of a packet. func getPacketType(b []byte) packetType { if len(b) == 0 { return packetTypeInvalid } if !isLongHeader(b[0]) { if b[0]&fixedBit != fixedBit { return packetTypeInvalid } return packetType1RTT } if len(b) < 5 { return packetTypeInvalid } if b[1] == 0 && b[2] == 0 && b[3] == 0 && b[4] == 0 { // Version Negotiation packets don't necessarily set the fixed bit. return packetTypeVersionNegotiation } if b[0]&fixedBit != fixedBit { return packetTypeInvalid } switch b[0] & 0x30 { case longPacketTypeInitial: return packetTypeInitial case longPacketType0RTT: return packetType0RTT case longPacketTypeHandshake: return packetTypeHandshake case longPacketTypeRetry: return packetTypeRetry } return packetTypeInvalid } // dstConnIDForDatagram returns the destination connection ID field of the // first QUIC packet in a datagram. func dstConnIDForDatagram(pkt []byte) (id []byte, ok bool) { if len(pkt) < 1 { return nil, false } var n int var b []byte if isLongHeader(pkt[0]) { if len(pkt) < 6 { return nil, false } n = int(pkt[5]) b = pkt[6:] } else { n = connIDLen b = pkt[1:] } if len(b) < n { return nil, false } return b[:n], true } // parseVersionNegotiation parses a Version Negotiation packet. // The returned versions is a slice of big-endian uint32s. // It returns (nil, nil, nil) for an invalid packet. func parseVersionNegotiation(pkt []byte) (dstConnID, srcConnID, versions []byte) { p, ok := parseGenericLongHeaderPacket(pkt) if !ok { return nil, nil, nil } if len(p.data)%4 != 0 { return nil, nil, nil } return p.dstConnID, p.srcConnID, p.data } // appendVersionNegotiation appends a Version Negotiation packet to pkt, // returning the result. func appendVersionNegotiation(pkt, dstConnID, srcConnID []byte, versions ...uint32) []byte { pkt = append(pkt, headerFormLong\|fixedBit) // header byte pkt = append(pkt, 0, 0, 0, 0) // Version (0 for Version Negotiation) pkt = appendUint8Bytes(pkt, dstConnID) // Destination Connection ID pkt = appendUint8Bytes(pkt, srcConnID) // Source Connection ID for _, v := range versions { pkt = binary.BigEndian.AppendUint32(pkt, v) // Supported Version } return pkt } // A longPacket is a long header packet. type longPacket struct { ptype packetType version uint32 num packetNumber dstConnID []byte srcConnID []byte payload []byte // The extra data depends on the packet type: // Initial: Token. // Retry: Retry token and integrity tag. extra []byte } // A shortPacket is a short header (1-RTT) packet. type shortPacket struct { num packetNumber payload []byte } // A genericLongPacket is a long header packet of an arbitrary QUIC version. // https://www.rfc-editor.org/rfc/rfc8999#section-5.1 type genericLongPacket struct { version uint32 dstConnID []byte srcConnID []byte data []byte } func parseGenericLongHeaderPacket(b []byte) (p genericLongPacket, ok bool) { if len(b) < 5 \|\| !isLongHeader(b[0]) { return genericLongPacket{}, false } b = b[1:] // Version (32), var n int p.version, n = consumeUint32(b) if n < 0 { return genericLongPacket{}, false } b = b[n:] // Destination Connection ID Length (8), // Destination Connection ID (0..2048), p.dstConnID, n = consumeUint8Bytes(b) if n < 0 \|\| len(p.dstConnID) > 2048/8 { return genericLongPacket{}, false } b = b[n:] // Source Connection ID Length (8), // Source Connection ID (0..2048), p.srcConnID, n = consumeUint8Bytes(b) if n < 0 \|\| len(p.dstConnID) > 2048/8 { return genericLongPacket{}, false } b = b[n:] p.data = b return p, true }	7.03 KB	2025-05-25 12:27
📄 packet_codec_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "bytes" "crypto/tls" "io" "log/slog" "reflect" "testing" "time" "golang.org/x/net/quic/qlog" ) func TestParseLongHeaderPacket(t testing.T) { // Example Initial packet from: // https://www.rfc-editor.org/rfc/rfc9001.html#section-a.3 cid := unhex(`8394c8f03e515708`) initialServerKeys := initialKeys(cid, clientSide).r pkt := unhex(` cf000000010008f067a5502a4262b500 4075c0d95a482cd0991cd25b0aac406a 5816b6394100f37a1c69797554780bb3 8cc5a99f5ede4cf73c3ec2493a1839b3 dbcba3f6ea46c5b7684df3548e7ddeb9 c3bf9c73cc3f3bded74b562bfb19fb84 022f8ef4cdd93795d77d06edbb7aaf2f 58891850abbdca3d20398c276456cbc4 2158407dd074ee `) want := longPacket{ ptype: packetTypeInitial, version: 1, num: 1, dstConnID: []byte{}, srcConnID: unhex(`f067a5502a4262b5`), payload: unhex(` 02000000000600405a020000560303ee fce7f7b37ba1d1632e96677825ddf739 88cfc79825df566dc5430b9a045a1200 130100002e00330024001d00209d3c94 0d89690b84d08a60993c144eca684d10 81287c834d5311bcf32bb9da1a002b00 020304 `), extra: []byte{}, } // Parse the packet. got, n := parseLongHeaderPacket(pkt, initialServerKeys, 0) if n != len(pkt) { t.Errorf("parseLongHeaderPacket: n=%v, want %v", n, len(pkt)) } if !reflect.DeepEqual(got, want) { t.Errorf("parseLongHeaderPacket:\n got: %+v\nwant: %+v", got, want) } // Skip the packet. if got, want := skipLongHeaderPacket(pkt), len(pkt); got != want { t.Errorf("skipLongHeaderPacket: n=%v, want %v", got, want) } // Parse truncated versions of the packet; every attempt should fail. for i := 0; i < len(pkt); i++ { if _, n := parseLongHeaderPacket(pkt[:i], initialServerKeys, 0); n != -1 { t.Fatalf("parse truncated long header packet: n=%v, want -1\ninput: %x", n, pkt[:i]) } if n := skipLongHeaderPacket(pkt[:i]); n != -1 { t.Errorf("skip truncated long header packet: n=%v, want -1", n) } } // Parse with the wrong keys. invalidKeys := initialKeys([]byte{}, clientSide).w if _, n := parseLongHeaderPacket(pkt, invalidKeys, 0); n != -1 { t.Fatalf("parse long header packet with wrong keys: n=%v, want -1", n) } } func TestRoundtripEncodeLongPacket(t testing.T) { var aes128Keys, aes256Keys, chachaKeys fixedKeys aes128Keys.init(tls.TLS_AES_128_GCM_SHA256, []byte("secret")) aes256Keys.init(tls.TLS_AES_256_GCM_SHA384, []byte("secret")) chachaKeys.init(tls.TLS_CHACHA20_POLY1305_SHA256, []byte("secret")) for _, test := range []struct { desc string p longPacket k fixedKeys }{{ desc: "Initial, 1-byte number, AES128", p: longPacket{ ptype: packetTypeInitial, version: 0x11223344, num: 0, // 1-byte encodeing dstConnID: []byte{1, 2, 3, 4}, srcConnID: []byte{5, 6, 7, 8}, payload: []byte("payload"), extra: []byte("token"), }, k: aes128Keys, }, { desc: "0-RTT, 2-byte number, AES256", p: longPacket{ ptype: packetType0RTT, version: 0x11223344, num: 0x100, // 2-byte encoding dstConnID: []byte{1, 2, 3, 4}, srcConnID: []byte{5, 6, 7, 8}, payload: []byte("payload"), }, k: aes256Keys, }, { desc: "0-RTT, 3-byte number, AES256", p: longPacket{ ptype: packetType0RTT, version: 0x11223344, num: 0x10000, // 2-byte encoding dstConnID: []byte{1, 2, 3, 4}, srcConnID: []byte{5, 6, 7, 8}, payload: []byte{0}, }, k: aes256Keys, }, { desc: "Handshake, 4-byte number, ChaCha20Poly1305", p: longPacket{ ptype: packetTypeHandshake, version: 0x11223344, num: 0x1000000, // 4-byte encoding dstConnID: []byte{1, 2, 3, 4}, srcConnID: []byte{5, 6, 7, 8}, payload: []byte("payload"), }, k: chachaKeys, }} { t.Run(test.desc, func(t testing.T) { var w packetWriter w.reset(1200) w.startProtectedLongHeaderPacket(0, test.p) w.b = append(w.b, test.p.payload...) w.finishProtectedLongHeaderPacket(0, test.k, test.p) pkt := w.datagram() got, n := parseLongHeaderPacket(pkt, test.k, 0) if n != len(pkt) { t.Errorf("parseLongHeaderPacket: n=%v, want %v", n, len(pkt)) } if !reflect.DeepEqual(got, test.p) { t.Errorf("Round-trip encode/decode did not preserve packet.\nsent: %+v\n got: %+v\nwire: %x", test.p, got, pkt) } }) } } func TestRoundtripEncodeShortPacket(t testing.T) { var aes128Keys, aes256Keys, chachaKeys updatingKeyPair aes128Keys.r.init(tls.TLS_AES_128_GCM_SHA256, []byte("secret")) aes256Keys.r.init(tls.TLS_AES_256_GCM_SHA384, []byte("secret")) chachaKeys.r.init(tls.TLS_CHACHA20_POLY1305_SHA256, []byte("secret")) aes128Keys.w = aes128Keys.r aes256Keys.w = aes256Keys.r chachaKeys.w = chachaKeys.r aes128Keys.updateAfter = maxPacketNumber aes256Keys.updateAfter = maxPacketNumber chachaKeys.updateAfter = maxPacketNumber connID := make([]byte, connIDLen) for i := range connID { connID[i] = byte(i) } for _, test := range []struct { desc string num packetNumber payload []byte k updatingKeyPair }{{ desc: "1-byte number, AES128", num: 0, // 1-byte encoding, payload: []byte("payload"), k: aes128Keys, }, { desc: "2-byte number, AES256", num: 0x100, // 2-byte encoding payload: []byte("payload"), k: aes256Keys, }, { desc: "3-byte number, ChaCha20Poly1305", num: 0x10000, // 3-byte encoding payload: []byte("payload"), k: chachaKeys, }, { desc: "4-byte number, ChaCha20Poly1305", num: 0x1000000, // 4-byte encoding payload: []byte{0}, k: chachaKeys, }} { t.Run(test.desc, func(t testing.T) { var w packetWriter w.reset(1200) w.start1RTTPacket(test.num, 0, connID) w.b = append(w.b, test.payload...) w.finish1RTTPacket(test.num, 0, connID, &test.k) pkt := w.datagram() p, err := parse1RTTPacket(pkt, &test.k, connIDLen, 0) if err != nil { t.Errorf("parse1RTTPacket: err=%v, want nil", err) } if p.num != test.num \|\| !bytes.Equal(p.payload, test.payload) { t.Errorf("Round-trip encode/decode did not preserve packet.\nsent: num=%v, payload={%x}\ngot: num=%v, payload={%x}", test.num, test.payload, p.num, p.payload) } }) } } func TestFrameEncodeDecode(t testing.T) { for _, test := range []struct { s string j string f debugFrame b []byte truncated []byte }{{ s: "PADDING1", j: `{"frame_type":"padding","length":1}`, f: debugFramePadding{ size: 1, }, b: []byte{ 0x00, // Type (i) = 0x00, }, }, { s: "PING", j: `{"frame_type":"ping"}`, f: debugFramePing{}, b: []byte{ 0x01, // TYPE(i) = 0x01 }, }, { s: "ACK Delay=10 [0,16) [17,32) [48,64)", j: `"error: debugFrameAck should not appear as a slog Value"`, f: debugFrameAck{ ackDelay: 10, ranges: []i64range[packetNumber]{ {0x00, 0x10}, {0x11, 0x20}, {0x30, 0x40}, }, }, b: []byte{ 0x02, // TYPE (i) = 0x02 0x3f, // Largest Acknowledged (i) 10, // ACK Delay (i) 0x02, // ACK Range Count (i) 0x0f, // First ACK Range (i) 0x0f, // Gap (i) 0x0e, // ACK Range Length (i) 0x00, // Gap (i) 0x0f, // ACK Range Length (i) }, truncated: []byte{ 0x02, // TYPE (i) = 0x02 0x3f, // Largest Acknowledged (i) 10, // ACK Delay (i) 0x01, // ACK Range Count (i) 0x0f, // First ACK Range (i) 0x0f, // Gap (i) 0x0e, // ACK Range Length (i) }, }, { s: "RESET_STREAM ID=1 Code=2 FinalSize=3", j: `{"frame_type":"reset_stream","stream_id":1,"final_size":3}`, f: debugFrameResetStream{ id: 1, code: 2, finalSize: 3, }, b: []byte{ 0x04, // TYPE(i) = 0x04 0x01, // Stream ID (i), 0x02, // Application Protocol Error Code (i), 0x03, // Final Size (i), }, }, { s: "STOP_SENDING ID=1 Code=2", j: `{"frame_type":"stop_sending","stream_id":1,"error_code":2}`, f: debugFrameStopSending{ id: 1, code: 2, }, b: []byte{ 0x05, // TYPE(i) = 0x05 0x01, // Stream ID (i), 0x02, // Application Protocol Error Code (i), }, }, { s: "CRYPTO Offset=1 Length=2", j: `{"frame_type":"crypto","offset":1,"length":2}`, f: debugFrameCrypto{ off: 1, data: []byte{3, 4}, }, b: []byte{ 0x06, // Type (i) = 0x06, 0x01, // Offset (i), 0x02, // Length (i), 0x03, 0x04, // Crypto Data (..), }, truncated: []byte{ 0x06, // Type (i) = 0x06, 0x01, // Offset (i), 0x01, // Length (i), 0x03, }, }, { s: "NEW_TOKEN Token=0304", j: `{"frame_type":"new_token","token":"0304"}`, f: debugFrameNewToken{ token: []byte{3, 4}, }, b: []byte{ 0x07, // Type (i) = 0x07, 0x02, // Token Length (i), 0x03, 0x04, // Token (..), }, }, { s: "STREAM ID=1 Offset=0 Length=0", j: `{"frame_type":"stream","stream_id":1,"offset":0,"length":0}`, f: debugFrameStream{ id: 1, fin: false, off: 0, data: []byte{}, }, b: []byte{ 0x0a, // Type (i) = 0x08..0x0f, 0x01, // Stream ID (i), // [Offset (i)], 0x00, // [Length (i)], // Stream Data (..), }, }, { s: "STREAM ID=100 Offset=4 Length=3", j: `{"frame_type":"stream","stream_id":100,"offset":4,"length":3}`, f: debugFrameStream{ id: 100, fin: false, off: 4, data: []byte{0xa0, 0xa1, 0xa2}, }, b: []byte{ 0x0e, // Type (i) = 0x08..0x0f, 0x40, 0x64, // Stream ID (i), 0x04, // [Offset (i)], 0x03, // [Length (i)], 0xa0, 0xa1, 0xa2, // Stream Data (..), }, truncated: []byte{ 0x0e, // Type (i) = 0x08..0x0f, 0x40, 0x64, // Stream ID (i), 0x04, // [Offset (i)], 0x02, // [Length (i)], 0xa0, 0xa1, // Stream Data (..), }, }, { s: "STREAM ID=100 FIN Offset=4 Length=3", j: `{"frame_type":"stream","stream_id":100,"offset":4,"length":3,"fin":true}`, f: debugFrameStream{ id: 100, fin: true, off: 4, data: []byte{0xa0, 0xa1, 0xa2}, }, b: []byte{ 0x0f, // Type (i) = 0x08..0x0f, 0x40, 0x64, // Stream ID (i), 0x04, // [Offset (i)], 0x03, // [Length (i)], 0xa0, 0xa1, 0xa2, // Stream Data (..), }, truncated: []byte{ 0x0e, // Type (i) = 0x08..0x0f, 0x40, 0x64, // Stream ID (i), 0x04, // [Offset (i)], 0x02, // [Length (i)], 0xa0, 0xa1, // Stream Data (..), }, }, { s: "STREAM ID=1 FIN Offset=100 Length=0", j: `{"frame_type":"stream","stream_id":1,"offset":100,"length":0,"fin":true}`, f: debugFrameStream{ id: 1, fin: true, off: 100, data: []byte{}, }, b: []byte{ 0x0f, // Type (i) = 0x08..0x0f, 0x01, // Stream ID (i), 0x40, 0x64, // [Offset (i)], 0x00, // [Length (i)], // Stream Data (..), }, }, { s: "MAX_DATA Max=10", j: `{"frame_type":"max_data","maximum":10}`, f: debugFrameMaxData{ max: 10, }, b: []byte{ 0x10, // Type (i) = 0x10, 0x0a, // Maximum Data (i), }, }, { s: "MAX_STREAM_DATA ID=1 Max=10", j: `{"frame_type":"max_stream_data","stream_id":1,"maximum":10}`, f: debugFrameMaxStreamData{ id: 1, max: 10, }, b: []byte{ 0x11, // Type (i) = 0x11, 0x01, // Stream ID (i), 0x0a, // Maximum Stream Data (i), }, }, { s: "MAX_STREAMS Type=bidi Max=1", j: `{"frame_type":"max_streams","stream_type":"bidirectional","maximum":1}`, f: debugFrameMaxStreams{ streamType: bidiStream, max: 1, }, b: []byte{ 0x12, // Type (i) = 0x12..0x13, 0x01, // Maximum Streams (i), }, }, { s: "MAX_STREAMS Type=uni Max=1", j: `{"frame_type":"max_streams","stream_type":"unidirectional","maximum":1}`, f: debugFrameMaxStreams{ streamType: uniStream, max: 1, }, b: []byte{ 0x13, // Type (i) = 0x12..0x13, 0x01, // Maximum Streams (i), }, }, { s: "DATA_BLOCKED Max=1", j: `{"frame_type":"data_blocked","limit":1}`, f: debugFrameDataBlocked{ max: 1, }, b: []byte{ 0x14, // Type (i) = 0x14, 0x01, // Maximum Data (i), }, }, { s: "STREAM_DATA_BLOCKED ID=1 Max=2", j: `{"frame_type":"stream_data_blocked","stream_id":1,"limit":2}`, f: debugFrameStreamDataBlocked{ id: 1, max: 2, }, b: []byte{ 0x15, // Type (i) = 0x15, 0x01, // Stream ID (i), 0x02, // Maximum Stream Data (i), }, }, { s: "STREAMS_BLOCKED Type=bidi Max=1", j: `{"frame_type":"streams_blocked","stream_type":"bidirectional","limit":1}`, f: debugFrameStreamsBlocked{ streamType: bidiStream, max: 1, }, b: []byte{ 0x16, // Type (i) = 0x16..0x17, 0x01, // Maximum Streams (i), }, }, { s: "STREAMS_BLOCKED Type=uni Max=1", j: `{"frame_type":"streams_blocked","stream_type":"unidirectional","limit":1}`, f: debugFrameStreamsBlocked{ streamType: uniStream, max: 1, }, b: []byte{ 0x17, // Type (i) = 0x16..0x17, 0x01, // Maximum Streams (i), }, }, { s: "NEW_CONNECTION_ID Seq=3 Retire=2 ID=a0a1a2a3 Token=0102030405060708090a0b0c0d0e0f10", j: `{"frame_type":"new_connection_id","sequence_number":3,"retire_prior_to":2,"connection_id":"a0a1a2a3","stateless_reset_token":"0102030405060708090a0b0c0d0e0f10"}`, f: debugFrameNewConnectionID{ seq: 3, retirePriorTo: 2, connID: []byte{0xa0, 0xa1, 0xa2, 0xa3}, token: [16]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}, }, b: []byte{ 0x18, // Type (i) = 0x18, 0x03, // Sequence Number (i), 0x02, // Retire Prior To (i), 0x04, // Length (8), 0xa0, 0xa1, 0xa2, 0xa3, // Connection ID (8..160), 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, // Stateless Reset Token (128), }, }, { s: "RETIRE_CONNECTION_ID Seq=1", j: `{"frame_type":"retire_connection_id","sequence_number":1}`, f: debugFrameRetireConnectionID{ seq: 1, }, b: []byte{ 0x19, // Type (i) = 0x19, 0x01, // Sequence Number (i), }, }, { s: "PATH_CHALLENGE Data=0123456789abcdef", j: `{"frame_type":"path_challenge","data":"0123456789abcdef"}`, f: debugFramePathChallenge{ data: pathChallengeData{0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef}, }, b: []byte{ 0x1a, // Type (i) = 0x1a, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, // Data (64), }, }, { s: "PATH_RESPONSE Data=0123456789abcdef", j: `{"frame_type":"path_response","data":"0123456789abcdef"}`, f: debugFramePathResponse{ data: pathChallengeData{0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef}, }, b: []byte{ 0x1b, // Type (i) = 0x1b, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, // Data (64), }, }, { s: `CONNECTION_CLOSE Code=INTERNAL_ERROR FrameType=2 Reason="oops"`, j: `{"frame_type":"connection_close","error_space":"transport","error_code_value":1,"reason":"oops"}`, f: debugFrameConnectionCloseTransport{ code: 1, frameType: 2, reason: "oops", }, b: []byte{ 0x1c, // Type (i) = 0x1c..0x1d, 0x01, // Error Code (i), 0x02, // [Frame Type (i)], 0x04, // Reason Phrase Length (i), 'o', 'o', 'p', 's', // Reason Phrase (..), }, }, { s: `CONNECTION_CLOSE AppCode=1 Reason="oops"`, j: `{"frame_type":"connection_close","error_space":"application","error_code_value":1,"reason":"oops"}`, f: debugFrameConnectionCloseApplication{ code: 1, reason: "oops", }, b: []byte{ 0x1d, // Type (i) = 0x1c..0x1d, 0x01, // Error Code (i), 0x04, // Reason Phrase Length (i), 'o', 'o', 'p', 's', // Reason Phrase (..), }, }, { s: "HANDSHAKE_DONE", j: `{"frame_type":"handshake_done"}`, f: debugFrameHandshakeDone{}, b: []byte{ 0x1e, // Type (i) = 0x1e, }, }} { var w packetWriter w.reset(1200) w.start1RTTPacket(0, 0, nil) w.pktLim = w.payOff + len(test.b) if added := test.f.write(&w); !added { t.Errorf("encoding %v with %v bytes available: write unexpectedly failed", test.f, len(test.b)) } if got, want := w.payload(), test.b; !bytes.Equal(got, want) { t.Errorf("encoding %v:\ngot {%x}\nwant {%x}", test.f, got, want) } gotf, n := parseDebugFrame(test.b) if n != len(test.b) \|\| !reflect.DeepEqual(gotf, test.f) { t.Errorf("decoding {%x}:\ndecoded %v bytes, want %v\ngot: %v\nwant: %v", test.b, n, len(test.b), gotf, test.f) } if got, want := test.f.String(), test.s; got != want { t.Errorf("frame.String():\ngot %q\nwant %q", got, want) } if got, want := frameJSON(test.f), test.j; got != want { t.Errorf("frame.LogValue():\ngot %q\nwant %q", got, want) } // Try encoding the frame into too little space. // Most frames will result in an error; some (like STREAM frames) will truncate // the data written. w.reset(1200) w.start1RTTPacket(0, 0, nil) w.pktLim = w.payOff + len(test.b) - 1 if added := test.f.write(&w); added { if test.truncated == nil { t.Errorf("encoding %v with %v-1 bytes available: write unexpectedly succeeded", test.f, len(test.b)) } else if got, want := w.payload(), test.truncated; !bytes.Equal(got, want) { t.Errorf("encoding %v with %v-1 bytes available:\ngot {%x}\nwant {%x}", test.f, len(test.b), got, want) } } // Try parsing truncated data. for i := 0; i < len(test.b); i++ { f, n := parseDebugFrame(test.b[:i]) if n >= 0 { t.Errorf("decoding truncated frame {%x}:\ngot: %v\nwant error", test.b[:i], f) } } } } func TestFrameScaledAck(t testing.T) { for _, test := range []struct { j string f debugFrameScaledAck }{{ j: `{"frame_type":"ack","acked_ranges":[[0,15],[17],[48,63]],"ack_delay":10.000000}`, f: debugFrameScaledAck{ ackDelay: 10 * time.Millisecond, ranges: []i64range[packetNumber]{ {0x00, 0x10}, {0x11, 0x12}, {0x30, 0x40}, }, }, }} { if got, want := frameJSON(test.f), test.j; got != want { t.Errorf("frame.LogValue():\ngot %q\nwant %q", got, want) } } } func frameJSON(f slog.LogValuer) string { var buf bytes.Buffer h := qlog.NewJSONHandler(qlog.HandlerOptions{ Level: QLogLevelFrame, NewTrace: func(info qlog.TraceInfo) (io.WriteCloser, error) { return nopCloseWriter{&buf}, nil }, }) // Log the frame, and then trim out everything but the frame from the log. slog.New(h).Info("message", slog.Any("frame", f)) _, b, _ := bytes.Cut(buf.Bytes(), []byte(`"frame":`)) b = bytes.TrimSuffix(b, []byte("}}\n")) return string(b) } func TestFrameDecode(t testing.T) { for _, test := range []struct { desc string want debugFrame b []byte }{{ desc: "STREAM frame with LEN bit unset", want: debugFrameStream{ id: 1, fin: false, data: []byte{0x01, 0x02, 0x03}, }, b: []byte{ 0x08, // Type (i) = 0x08..0x0f, 0x01, // Stream ID (i), // [Offset (i)], // [Length (i)], 0x01, 0x02, 0x03, // Stream Data (..), }, }, { desc: "ACK frame with ECN counts", want: debugFrameAck{ ackDelay: 10, ranges: []i64range[packetNumber]{ {0, 1}, }, }, b: []byte{ 0x03, // TYPE (i) = 0x02..0x03 0x00, // Largest Acknowledged (i) 10, // ACK Delay (i) 0x00, // ACK Range Count (i) 0x00, // First ACK Range (i) 0x01, 0x02, 0x03, // [ECN Counts (..)], }, }} { got, n := parseDebugFrame(test.b) if n != len(test.b) \|\| !reflect.DeepEqual(got, test.want) { t.Errorf("decoding {%x}:\ndecoded %v bytes, want %v\ngot: %v\nwant: %v", test.b, n, len(test.b), got, test.want) } } } func TestFrameDecodeErrors(t testing.T) { for _, test := range []struct { name string b []byte }{{ name: "ACK [-1,0]", b: []byte{ 0x02, // TYPE (i) = 0x02 0x00, // Largest Acknowledged (i) 0x00, // ACK Delay (i) 0x00, // ACK Range Count (i) 0x01, // First ACK Range (i) }, }, { name: "ACK [-1,16]", b: []byte{ 0x02, // TYPE (i) = 0x02 0x10, // Largest Acknowledged (i) 0x00, // ACK Delay (i) 0x00, // ACK Range Count (i) 0x11, // First ACK Range (i) }, }, { name: "ACK [-1,0],[1,2]", b: []byte{ 0x02, // TYPE (i) = 0x02 0x02, // Largest Acknowledged (i) 0x00, // ACK Delay (i) 0x01, // ACK Range Count (i) 0x00, // First ACK Range (i) 0x01, // Gap (i) 0x01, // ACK Range Length (i) }, }, { name: "NEW_TOKEN with zero-length token", b: []byte{ 0x07, // Type (i) = 0x07, 0x00, // Token Length (i), }, }, { name: "MAX_STREAMS with too many streams", b: func() []byte { // https://www.rfc-editor.org/rfc/rfc9000.html#section-19.11-5.2.1 return appendVarint([]byte{frameTypeMaxStreamsBidi}, (1<<60)+1) }(), }, { name: "NEW_CONNECTION_ID too small", b: []byte{ 0x18, // Type (i) = 0x18, 0x03, // Sequence Number (i), 0x02, // Retire Prior To (i), 0x00, // Length (8), // Connection ID (8..160), 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, // Stateless Reset Token (128), }, }, { name: "NEW_CONNECTION_ID too large", b: []byte{ 0x18, // Type (i) = 0x18, 0x03, // Sequence Number (i), 0x02, // Retire Prior To (i), 21, // Length (8), 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, // Connection ID (8..160), 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, // Stateless Reset Token (128), }, }, { name: "NEW_CONNECTION_ID sequence smaller than retire", b: []byte{ 0x18, // Type (i) = 0x18, 0x02, // Sequence Number (i), 0x03, // Retire Prior To (i), 0x02, // Length (8), 0xff, 0xff, // Connection ID (8..160), 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, // Stateless Reset Token (128), }, }} { f, n := parseDebugFrame(test.b) if n >= 0 { t.Errorf("%v: no error when parsing invalid frame {%x}\ngot: %v", test.name, test.b, f) } } } func FuzzParseLongHeaderPacket(f testing.F) { cid := unhex(`0000000000000000`) initialServerKeys := initialKeys(cid, clientSide).r f.Fuzz(func(t testing.T, in []byte) { parseLongHeaderPacket(in, initialServerKeys, 0) }) } func FuzzFrameDecode(f testing.F) { f.Fuzz(func(t testing.T, in []byte) { parseDebugFrame(in) }) }	21.83 KB	2025-05-25 12:27
📄 packet_number.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic // A packetNumber is a QUIC packet number. // Packet numbers are integers in the range [0, 2^62-1]. // // https://www.rfc-editor.org/rfc/rfc9000.html#section-12.3 type packetNumber int64 const maxPacketNumber = 1<<62 - 1 // https://www.rfc-editor.org/rfc/rfc9000.html#section-17.1-1 // decodePacketNumber decodes a truncated packet number, given // the largest acknowledged packet number in this number space, // the truncated number received in a packet, and the size of the // number received in bytes. // // https://www.rfc-editor.org/rfc/rfc9000.html#section-17.1 // https://www.rfc-editor.org/rfc/rfc9000.html#section-a.3 func decodePacketNumber(largest, truncated packetNumber, numLenInBytes int) packetNumber { expected := largest + 1 win := packetNumber(1) << (uint(numLenInBytes) * 8) hwin := win / 2 mask := win - 1 candidate := (expected &^ mask) \| truncated if candidate <= expected-hwin && candidate < (1<<62)-win { return candidate + win } if candidate > expected+hwin && candidate >= win { return candidate - win } return candidate } // appendPacketNumber appends an encoded packet number to b. // The packet number must be larger than the largest acknowledged packet number. // When no packets have been acknowledged yet, largestAck is -1. // // https://www.rfc-editor.org/rfc/rfc9000.html#section-17.1-5 func appendPacketNumber(b []byte, pnum, largestAck packetNumber) []byte { switch packetNumberLength(pnum, largestAck) { case 1: return append(b, byte(pnum)) case 2: return append(b, byte(pnum>>8), byte(pnum)) case 3: return append(b, byte(pnum>>16), byte(pnum>>8), byte(pnum)) default: return append(b, byte(pnum>>24), byte(pnum>>16), byte(pnum>>8), byte(pnum)) } } // packetNumberLength returns the minimum length, in bytes, needed to encode // a packet number given the largest acknowledged packet number. // The packet number must be larger than the largest acknowledged packet number. // // https://www.rfc-editor.org/rfc/rfc9000.html#section-17.1-5 func packetNumberLength(pnum, largestAck packetNumber) int { d := pnum - largestAck switch { case d < 0x80: return 1 case d < 0x8000: return 2 case d < 0x800000: return 3 default: return 4 } }	2.35 KB	2025-05-25 12:27
📄 packet_number_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "bytes" "encoding/binary" "testing" ) func TestDecodePacketNumber(t testing.T) { for _, test := range []struct { largest packetNumber truncated packetNumber want packetNumber size int }{{ largest: 0, truncated: 1, size: 4, want: 1, }, { largest: 0, truncated: 0, size: 1, want: 0, }, { largest: 0x00, truncated: 0x01, size: 1, want: 0x01, }, { largest: 0x00, truncated: 0xff, size: 1, want: 0xff, }, { largest: 0xff, truncated: 0x01, size: 1, want: 0x101, }, { largest: 0x1000, truncated: 0xff, size: 1, want: 0xfff, }, { largest: 0xa82f30ea, truncated: 0x9b32, size: 2, want: 0xa82f9b32, }} { got := decodePacketNumber(test.largest, test.truncated, test.size) if got != test.want { t.Errorf("decodePacketNumber(largest=0x%x, truncated=0x%x, size=%v) = 0x%x, want 0x%x", test.largest, test.truncated, test.size, got, test.want) } } } func TestEncodePacketNumber(t testing.T) { for _, test := range []struct { largestAcked packetNumber pnum packetNumber wantSize int }{{ largestAcked: -1, pnum: 0, wantSize: 1, }, { largestAcked: 1000, pnum: 1000 + 0x7f, wantSize: 1, }, { largestAcked: 1000, pnum: 1000 + 0x80, // 0x468 wantSize: 2, }, { largestAcked: 0x12345678, pnum: 0x12345678 + 0x7fff, // 0x305452663 wantSize: 2, }, { largestAcked: 0x12345678, pnum: 0x12345678 + 0x8000, wantSize: 3, }, { largestAcked: 0, pnum: 0x7fffff, wantSize: 3, }, { largestAcked: 0, pnum: 0x800000, wantSize: 4, }, { largestAcked: 0xabe8bc, pnum: 0xac5c02, wantSize: 2, }, { largestAcked: 0xabe8bc, pnum: 0xace8fe, wantSize: 3, }} { size := packetNumberLength(test.pnum, test.largestAcked) if got, want := size, test.wantSize; got != want { t.Errorf("packetNumberLength(num=%x, maxAck=%x) = %v, want %v", test.pnum, test.largestAcked, got, want) } var enc packetNumber switch size { case 1: enc = test.pnum & 0xff case 2: enc = test.pnum & 0xffff case 3: enc = test.pnum & 0xffffff case 4: enc = test.pnum & 0xffffffff } wantBytes := binary.BigEndian.AppendUint32(nil, uint32(enc))[4-size:] gotBytes := appendPacketNumber(nil, test.pnum, test.largestAcked) if !bytes.Equal(gotBytes, wantBytes) { t.Errorf("appendPacketNumber(num=%v, maxAck=%x) = {%x}, want {%x}", test.pnum, test.largestAcked, gotBytes, wantBytes) } gotNum := decodePacketNumber(test.largestAcked, enc, size) if got, want := gotNum, test.pnum; got != want { t.Errorf("packetNumberLength(num=%x, maxAck=%x) = %v, but decoded number=%x", test.pnum, test.largestAcked, size, got) } } } func FuzzPacketNumber(f testing.F) { truncatedNumber := func(in []byte) packetNumber { var truncated packetNumber for _, b := range in { truncated = (truncated << 8) \| packetNumber(b) } return truncated } f.Fuzz(func(t testing.T, in []byte, largestAckedInt64 int64) { largestAcked := packetNumber(largestAckedInt64) if len(in) < 1 \|\| len(in) > 4 \|\| largestAcked < 0 \|\| largestAcked > maxPacketNumber { return } truncatedIn := truncatedNumber(in) decoded := decodePacketNumber(largestAcked, truncatedIn, len(in)) // Check that the decoded packet number's least significant bits match the input. var mask packetNumber for i := 0; i < len(in); i++ { mask = (mask << 8) \| 0xff } if truncatedIn != decoded&mask { t.Fatalf("decoding mismatch: input=%x largestAcked=%v decoded=0x%x", in, largestAcked, decoded) } // We don't support encoding packet numbers less than largestAcked (since packet numbers // never decrease), so skip the encoder tests if this would make us go backwards. if decoded < largestAcked { return } // We might encode this number using a different length than we received, // but the common portions should match. encoded := appendPacketNumber(nil, decoded, largestAcked) a, b := in, encoded if len(b) < len(a) { a, b = b, a } for len(a) < len(b) { b = b[1:] } if len(a) == 0 \|\| !bytes.Equal(a, b) { t.Fatalf("encoding mismatch: input=%x largestAcked=%v decoded=%v reencoded=%x", in, largestAcked, decoded, encoded) } if g := decodePacketNumber(largestAcked, truncatedNumber(encoded), len(encoded)); g != decoded { t.Fatalf("packet encode/decode mismatch: pnum=%v largestAcked=%v encoded=%x got=%v", decoded, largestAcked, encoded, g) } if l := packetNumberLength(decoded, largestAcked); l != len(encoded) { t.Fatalf("packet number length mismatch: pnum=%v largestAcked=%v encoded=%x len=%v", decoded, largestAcked, encoded, l) } }) }	4.9 KB	2025-05-25 12:27
📄 packet_parser.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic // parseLongHeaderPacket parses a QUIC long header packet. // // It does not parse Version Negotiation packets. // // On input, pkt contains a long header packet (possibly followed by more packets), // k the decryption keys for the packet, and pnumMax the largest packet number seen // in the number space of this packet. // // parseLongHeaderPacket returns the parsed packet with protection removed // and its length in bytes. // // It returns an empty packet and -1 if the packet could not be parsed. func parseLongHeaderPacket(pkt []byte, k fixedKeys, pnumMax packetNumber) (p longPacket, n int) { if len(pkt) < 5 \|\| !isLongHeader(pkt[0]) { return longPacket{}, -1 } // Header Form (1) = 1, // Fixed Bit (1) = 1, // Long Packet Type (2), // Type-Specific Bits (4), b := pkt p.ptype = getPacketType(b) if p.ptype == packetTypeInvalid { return longPacket{}, -1 } b = b[1:] // Version (32), p.version, n = consumeUint32(b) if n < 0 { return longPacket{}, -1 } b = b[n:] if p.version == 0 { // Version Negotiation packet; not handled here. return longPacket{}, -1 } // Destination Connection ID Length (8), // Destination Connection ID (0..160), p.dstConnID, n = consumeUint8Bytes(b) if n < 0 \|\| len(p.dstConnID) > maxConnIDLen { return longPacket{}, -1 } b = b[n:] // Source Connection ID Length (8), // Source Connection ID (0..160), p.srcConnID, n = consumeUint8Bytes(b) if n < 0 \|\| len(p.dstConnID) > maxConnIDLen { return longPacket{}, -1 } b = b[n:] switch p.ptype { case packetTypeInitial: // Token Length (i), // Token (..), p.extra, n = consumeVarintBytes(b) if n < 0 { return longPacket{}, -1 } b = b[n:] case packetTypeRetry: // Retry Token (..), // Retry Integrity Tag (128), p.extra = b return p, len(pkt) } // Length (i), payLen, n := consumeVarint(b) if n < 0 { return longPacket{}, -1 } b = b[n:] if uint64(len(b)) < payLen { return longPacket{}, -1 } // Packet Number (8..32), // Packet Payload (..), pnumOff := len(pkt) - len(b) pkt = pkt[:pnumOff+int(payLen)] if k.isSet() { var err error p.payload, p.num, err = k.unprotect(pkt, pnumOff, pnumMax) if err != nil { return longPacket{}, -1 } } return p, len(pkt) } // skipLongHeaderPacket returns the length of the long header packet at the start of pkt, // or -1 if the buffer does not contain a valid packet. func skipLongHeaderPacket(pkt []byte) int { // Header byte, 4 bytes of version. n := 5 if len(pkt) <= n { return -1 } // Destination connection ID length, destination connection ID. n += 1 + int(pkt[n]) if len(pkt) <= n { return -1 } // Source connection ID length, source connection ID. n += 1 + int(pkt[n]) if len(pkt) <= n { return -1 } if getPacketType(pkt) == packetTypeInitial { // Token length, token. _, nn := consumeVarintBytes(pkt[n:]) if nn < 0 { return -1 } n += nn } // Length, packet number, payload. _, nn := consumeVarintBytes(pkt[n:]) if nn < 0 { return -1 } n += nn if len(pkt) < n { return -1 } return n } // parse1RTTPacket parses a QUIC 1-RTT (short header) packet. // // On input, pkt contains a short header packet, k the decryption keys for the packet, // and pnumMax the largest packet number seen in the number space of this packet. func parse1RTTPacket(pkt []byte, k *updatingKeyPair, dstConnIDLen int, pnumMax packetNumber) (p shortPacket, err error) { pay, pnum, err := k.unprotect(pkt, 1+dstConnIDLen, pnumMax) if err != nil { return shortPacket{}, err } p.num = pnum p.payload = pay return p, nil } // Consume functions return n=-1 on conditions which result in FRAME_ENCODING_ERROR, // which includes both general parse failures and specific violations of frame // constraints. func consumeAckFrame(frame []byte, f func(rangeIndex int, start, end packetNumber)) (largest packetNumber, ackDelay unscaledAckDelay, n int) { b := frame[1:] // type largestAck, n := consumeVarint(b) if n < 0 { return 0, 0, -1 } b = b[n:] v, n := consumeVarintInt64(b) if n < 0 { return 0, 0, -1 } b = b[n:] ackDelay = unscaledAckDelay(v) ackRangeCount, n := consumeVarint(b) if n < 0 { return 0, 0, -1 } b = b[n:] rangeMax := packetNumber(largestAck) for i := uint64(0); ; i++ { rangeLen, n := consumeVarint(b) if n < 0 { return 0, 0, -1 } b = b[n:] rangeMin := rangeMax - packetNumber(rangeLen) if rangeMin < 0 \|\| rangeMin > rangeMax { return 0, 0, -1 } f(int(i), rangeMin, rangeMax+1) if i == ackRangeCount { break } gap, n := consumeVarint(b) if n < 0 { return 0, 0, -1 } b = b[n:] rangeMax = rangeMin - packetNumber(gap) - 2 } if frame[0] != frameTypeAckECN { return packetNumber(largestAck), ackDelay, len(frame) - len(b) } ect0Count, n := consumeVarint(b) if n < 0 { return 0, 0, -1 } b = b[n:] ect1Count, n := consumeVarint(b) if n < 0 { return 0, 0, -1 } b = b[n:] ecnCECount, n := consumeVarint(b) if n < 0 { return 0, 0, -1 } b = b[n:] // TODO: Make use of ECN feedback. // https://www.rfc-editor.org/rfc/rfc9000.html#section-19.3.2 _ = ect0Count _ = ect1Count _ = ecnCECount return packetNumber(largestAck), ackDelay, len(frame) - len(b) } func consumeResetStreamFrame(b []byte) (id streamID, code uint64, finalSize int64, n int) { n = 1 idInt, nn := consumeVarint(b[n:]) if nn < 0 { return 0, 0, 0, -1 } n += nn code, nn = consumeVarint(b[n:]) if nn < 0 { return 0, 0, 0, -1 } n += nn v, nn := consumeVarint(b[n:]) if nn < 0 { return 0, 0, 0, -1 } n += nn finalSize = int64(v) return streamID(idInt), code, finalSize, n } func consumeStopSendingFrame(b []byte) (id streamID, code uint64, n int) { n = 1 idInt, nn := consumeVarint(b[n:]) if nn < 0 { return 0, 0, -1 } n += nn code, nn = consumeVarint(b[n:]) if nn < 0 { return 0, 0, -1 } n += nn return streamID(idInt), code, n } func consumeCryptoFrame(b []byte) (off int64, data []byte, n int) { n = 1 v, nn := consumeVarint(b[n:]) if nn < 0 { return 0, nil, -1 } off = int64(v) n += nn data, nn = consumeVarintBytes(b[n:]) if nn < 0 { return 0, nil, -1 } n += nn return off, data, n } func consumeNewTokenFrame(b []byte) (token []byte, n int) { n = 1 data, nn := consumeVarintBytes(b[n:]) if nn < 0 { return nil, -1 } if len(data) == 0 { return nil, -1 } n += nn return data, n } func consumeStreamFrame(b []byte) (id streamID, off int64, fin bool, data []byte, n int) { fin = (b[0] & 0x01) != 0 n = 1 idInt, nn := consumeVarint(b[n:]) if nn < 0 { return 0, 0, false, nil, -1 } n += nn if b[0]&0x04 != 0 { v, nn := consumeVarint(b[n:]) if nn < 0 { return 0, 0, false, nil, -1 } n += nn off = int64(v) } if b[0]&0x02 != 0 { data, nn = consumeVarintBytes(b[n:]) if nn < 0 { return 0, 0, false, nil, -1 } n += nn } else { data = b[n:] n += len(data) } if off+int64(len(data)) >= 1<<62 { return 0, 0, false, nil, -1 } return streamID(idInt), off, fin, data, n } func consumeMaxDataFrame(b []byte) (max int64, n int) { n = 1 v, nn := consumeVarint(b[n:]) if nn < 0 { return 0, -1 } n += nn return int64(v), n } func consumeMaxStreamDataFrame(b []byte) (id streamID, max int64, n int) { n = 1 v, nn := consumeVarint(b[n:]) if nn < 0 { return 0, 0, -1 } n += nn id = streamID(v) v, nn = consumeVarint(b[n:]) if nn < 0 { return 0, 0, -1 } n += nn max = int64(v) return id, max, n } func consumeMaxStreamsFrame(b []byte) (typ streamType, max int64, n int) { switch b[0] { case frameTypeMaxStreamsBidi: typ = bidiStream case frameTypeMaxStreamsUni: typ = uniStream default: return 0, 0, -1 } n = 1 v, nn := consumeVarint(b[n:]) if nn < 0 { return 0, 0, -1 } n += nn if v > maxStreamsLimit { return 0, 0, -1 } return typ, int64(v), n } func consumeStreamDataBlockedFrame(b []byte) (id streamID, max int64, n int) { n = 1 v, nn := consumeVarint(b[n:]) if nn < 0 { return 0, 0, -1 } n += nn id = streamID(v) max, nn = consumeVarintInt64(b[n:]) if nn < 0 { return 0, 0, -1 } n += nn return id, max, n } func consumeDataBlockedFrame(b []byte) (max int64, n int) { n = 1 max, nn := consumeVarintInt64(b[n:]) if nn < 0 { return 0, -1 } n += nn return max, n } func consumeStreamsBlockedFrame(b []byte) (typ streamType, max int64, n int) { if b[0] == frameTypeStreamsBlockedBidi { typ = bidiStream } else { typ = uniStream } n = 1 max, nn := consumeVarintInt64(b[n:]) if nn < 0 { return 0, 0, -1 } n += nn return typ, max, n } func consumeNewConnectionIDFrame(b []byte) (seq, retire int64, connID []byte, resetToken statelessResetToken, n int) { n = 1 var nn int seq, nn = consumeVarintInt64(b[n:]) if nn < 0 { return 0, 0, nil, statelessResetToken{}, -1 } n += nn retire, nn = consumeVarintInt64(b[n:]) if nn < 0 { return 0, 0, nil, statelessResetToken{}, -1 } n += nn if seq < retire { return 0, 0, nil, statelessResetToken{}, -1 } connID, nn = consumeVarintBytes(b[n:]) if nn < 0 { return 0, 0, nil, statelessResetToken{}, -1 } if len(connID) < 1 \|\| len(connID) > 20 { return 0, 0, nil, statelessResetToken{}, -1 } n += nn if len(b[n:]) < len(resetToken) { return 0, 0, nil, statelessResetToken{}, -1 } copy(resetToken[:], b[n:]) n += len(resetToken) return seq, retire, connID, resetToken, n } func consumeRetireConnectionIDFrame(b []byte) (seq int64, n int) { n = 1 var nn int seq, nn = consumeVarintInt64(b[n:]) if nn < 0 { return 0, -1 } n += nn return seq, n } func consumePathChallengeFrame(b []byte) (data pathChallengeData, n int) { n = 1 nn := copy(data[:], b[n:]) if nn != len(data) { return data, -1 } n += nn return data, n } func consumePathResponseFrame(b []byte) (data pathChallengeData, n int) { return consumePathChallengeFrame(b) // identical frame format } func consumeConnectionCloseTransportFrame(b []byte) (code transportError, frameType uint64, reason string, n int) { n = 1 var nn int var codeInt uint64 codeInt, nn = consumeVarint(b[n:]) if nn < 0 { return 0, 0, "", -1 } code = transportError(codeInt) n += nn frameType, nn = consumeVarint(b[n:]) if nn < 0 { return 0, 0, "", -1 } n += nn reasonb, nn := consumeVarintBytes(b[n:]) if nn < 0 { return 0, 0, "", -1 } n += nn reason = string(reasonb) return code, frameType, reason, n } func consumeConnectionCloseApplicationFrame(b []byte) (code uint64, reason string, n int) { n = 1 var nn int code, nn = consumeVarint(b[n:]) if nn < 0 { return 0, "", -1 } n += nn reasonb, nn := consumeVarintBytes(b[n:]) if nn < 0 { return 0, "", -1 } n += nn reason = string(reasonb) return code, reason, n }	10.62 KB	2025-05-25 12:27
📄 packet_protection.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "crypto" "crypto/aes" "crypto/cipher" "crypto/sha256" "crypto/tls" "errors" "hash" "golang.org/x/crypto/chacha20" "golang.org/x/crypto/chacha20poly1305" "golang.org/x/crypto/cryptobyte" "golang.org/x/crypto/hkdf" ) var errInvalidPacket = errors.New("quic: invalid packet") // headerProtectionSampleSize is the size of the ciphertext sample used for header protection. // https://www.rfc-editor.org/rfc/rfc9001#section-5.4.2 const headerProtectionSampleSize = 16 // aeadOverhead is the difference in size between the AEAD output and input. // All cipher suites defined for use with QUIC have 16 bytes of overhead. const aeadOverhead = 16 // A headerKey applies or removes header protection. // https://www.rfc-editor.org/rfc/rfc9001#section-5.4 type headerKey struct { hp headerProtection } func (k headerKey) isSet() bool { return k.hp != nil } func (k headerKey) init(suite uint16, secret []byte) { h, keySize := hashForSuite(suite) hpKey := hkdfExpandLabel(h.New, secret, "quic hp", nil, keySize) switch suite { case tls.TLS_AES_128_GCM_SHA256, tls.TLS_AES_256_GCM_SHA384: c, err := aes.NewCipher(hpKey) if err != nil { panic(err) } k.hp = &aesHeaderProtection{cipher: c} case tls.TLS_CHACHA20_POLY1305_SHA256: k.hp = chaCha20HeaderProtection{hpKey} default: panic("BUG: unknown cipher suite") } } // protect applies header protection. // pnumOff is the offset of the packet number in the packet. func (k headerKey) protect(hdr []byte, pnumOff int) { // Apply header protection. pnumSize := int(hdr[0]&0x03) + 1 sample := hdr[pnumOff+4:][:headerProtectionSampleSize] mask := k.hp.headerProtection(sample) if isLongHeader(hdr[0]) { hdr[0] ^= mask[0] & 0x0f } else { hdr[0] ^= mask[0] & 0x1f } for i := 0; i < pnumSize; i++ { hdr[pnumOff+i] ^= mask[1+i] } } // unprotect removes header protection. // pnumOff is the offset of the packet number in the packet. // pnumMax is the largest packet number seen in the number space of this packet. func (k headerKey) unprotect(pkt []byte, pnumOff int, pnumMax packetNumber) (hdr, pay []byte, pnum packetNumber, _ error) { if len(pkt) < pnumOff+4+headerProtectionSampleSize { return nil, nil, 0, errInvalidPacket } numpay := pkt[pnumOff:] sample := numpay[4:][:headerProtectionSampleSize] mask := k.hp.headerProtection(sample) if isLongHeader(pkt[0]) { pkt[0] ^= mask[0] & 0x0f } else { pkt[0] ^= mask[0] & 0x1f } pnumLen := int(pkt[0]&0x03) + 1 pnum = packetNumber(0) for i := 0; i < pnumLen; i++ { numpay[i] ^= mask[1+i] pnum = (pnum << 8) \| packetNumber(numpay[i]) } pnum = decodePacketNumber(pnumMax, pnum, pnumLen) hdr = pkt[:pnumOff+pnumLen] pay = numpay[pnumLen:] return hdr, pay, pnum, nil } // headerProtection is the header_protection function as defined in: // https://www.rfc-editor.org/rfc/rfc9001#section-5.4.1 // // This function takes a sample of the packet ciphertext // and returns a 5-byte mask which will be applied to the // protected portions of the packet header. type headerProtection interface { headerProtection(sample []byte) (mask [5]byte) } // AES-based header protection. // https://www.rfc-editor.org/rfc/rfc9001#section-5.4.3 type aesHeaderProtection struct { cipher cipher.Block scratch [aes.BlockSize]byte } func (hp aesHeaderProtection) headerProtection(sample []byte) (mask [5]byte) { hp.cipher.Encrypt(hp.scratch[:], sample) copy(mask[:], hp.scratch[:]) return mask } // ChaCha20-based header protection. // https://www.rfc-editor.org/rfc/rfc9001#section-5.4.4 type chaCha20HeaderProtection struct { key []byte } func (hp chaCha20HeaderProtection) headerProtection(sample []byte) (mask [5]byte) { counter := uint32(sample[3])<<24 \| uint32(sample[2])<<16 \| uint32(sample[1])<<8 \| uint32(sample[0]) nonce := sample[4:16] c, err := chacha20.NewUnauthenticatedCipher(hp.key, nonce) if err != nil { panic(err) } c.SetCounter(counter) c.XORKeyStream(mask[:], mask[:]) return mask } // A packetKey applies or removes packet protection. // https://www.rfc-editor.org/rfc/rfc9001#section-5.1 type packetKey struct { aead cipher.AEAD // AEAD function used for packet protection. iv []byte // IV used to construct the AEAD nonce. } func (k packetKey) init(suite uint16, secret []byte) { // https://www.rfc-editor.org/rfc/rfc9001#section-5.1 h, keySize := hashForSuite(suite) key := hkdfExpandLabel(h.New, secret, "quic key", nil, keySize) switch suite { case tls.TLS_AES_128_GCM_SHA256, tls.TLS_AES_256_GCM_SHA384: k.aead = newAESAEAD(key) case tls.TLS_CHACHA20_POLY1305_SHA256: k.aead = newChaCha20AEAD(key) default: panic("BUG: unknown cipher suite") } k.iv = hkdfExpandLabel(h.New, secret, "quic iv", nil, k.aead.NonceSize()) } func newAESAEAD(key []byte) cipher.AEAD { c, err := aes.NewCipher(key) if err != nil { panic(err) } aead, err := cipher.NewGCM(c) if err != nil { panic(err) } return aead } func newChaCha20AEAD(key []byte) cipher.AEAD { var err error aead, err := chacha20poly1305.New(key) if err != nil { panic(err) } return aead } func (k packetKey) protect(hdr, pay []byte, pnum packetNumber) []byte { k.xorIV(pnum) defer k.xorIV(pnum) return k.aead.Seal(hdr, k.iv, pay, hdr) } func (k packetKey) unprotect(hdr, pay []byte, pnum packetNumber) (dec []byte, err error) { k.xorIV(pnum) defer k.xorIV(pnum) return k.aead.Open(pay[:0], k.iv, pay, hdr) } // xorIV xors the packet protection IV with the packet number. func (k packetKey) xorIV(pnum packetNumber) { k.iv[len(k.iv)-8] ^= uint8(pnum >> 56) k.iv[len(k.iv)-7] ^= uint8(pnum >> 48) k.iv[len(k.iv)-6] ^= uint8(pnum >> 40) k.iv[len(k.iv)-5] ^= uint8(pnum >> 32) k.iv[len(k.iv)-4] ^= uint8(pnum >> 24) k.iv[len(k.iv)-3] ^= uint8(pnum >> 16) k.iv[len(k.iv)-2] ^= uint8(pnum >> 8) k.iv[len(k.iv)-1] ^= uint8(pnum) } // A fixedKeys is a header protection key and fixed packet protection key. // The packet protection key is fixed (it does not update). // // Fixed keys are used for Initial and Handshake keys, which do not update. type fixedKeys struct { hdr headerKey pkt packetKey } func (k fixedKeys) init(suite uint16, secret []byte) { k.hdr.init(suite, secret) k.pkt.init(suite, secret) } func (k fixedKeys) isSet() bool { return k.hdr.hp != nil } // protect applies packet protection to a packet. // // On input, hdr contains the packet header, pay the unencrypted payload, // pnumOff the offset of the packet number in the header, and pnum the untruncated // packet number. // // protect returns the result of appending the encrypted payload to hdr and // applying header protection. func (k fixedKeys) protect(hdr, pay []byte, pnumOff int, pnum packetNumber) []byte { pkt := k.pkt.protect(hdr, pay, pnum) k.hdr.protect(pkt, pnumOff) return pkt } // unprotect removes packet protection from a packet. // // On input, pkt contains the full protected packet, pnumOff the offset of // the packet number in the header, and pnumMax the largest packet number // seen in the number space of this packet. // // unprotect removes header protection from the header in pkt, and returns // the unprotected payload and packet number. func (k fixedKeys) unprotect(pkt []byte, pnumOff int, pnumMax packetNumber) (pay []byte, num packetNumber, err error) { hdr, pay, pnum, err := k.hdr.unprotect(pkt, pnumOff, pnumMax) if err != nil { return nil, 0, err } pay, err = k.pkt.unprotect(hdr, pay, pnum) if err != nil { return nil, 0, err } return pay, pnum, nil } // A fixedKeyPair is a read/write pair of fixed keys. type fixedKeyPair struct { r, w fixedKeys } func (k fixedKeyPair) discard() { k = fixedKeyPair{} } func (k fixedKeyPair) canRead() bool { return k.r.isSet() } func (k fixedKeyPair) canWrite() bool { return k.w.isSet() } // An updatingKeys is a header protection key and updatable packet protection key. // updatingKeys are used for 1-RTT keys, where the packet protection key changes // over the lifetime of a connection. // https://www.rfc-editor.org/rfc/rfc9001#section-6 type updatingKeys struct { suite uint16 hdr headerKey pkt [2]packetKey // current, next nextSecret []byte // secret used to generate pkt[1] } func (k updatingKeys) init(suite uint16, secret []byte) { k.suite = suite k.hdr.init(suite, secret) // Initialize pkt[1] with secret_0, and then call update to generate secret_1. k.pkt[1].init(suite, secret) k.nextSecret = secret k.update() } // update performs a key update. // The current key in pkt[0] is discarded. // The next key in pkt[1] becomes the current key. // A new next key is generated in pkt[1]. func (k updatingKeys) update() { k.nextSecret = updateSecret(k.suite, k.nextSecret) k.pkt[0] = k.pkt[1] k.pkt[1].init(k.suite, k.nextSecret) } func updateSecret(suite uint16, secret []byte) (nextSecret []byte) { h, _ := hashForSuite(suite) return hkdfExpandLabel(h.New, secret, "quic ku", nil, len(secret)) } // An updatingKeyPair is a read/write pair of updating keys. // // We keep two keys (current and next) in both read and write directions. // When an incoming packet's phase matches the current phase bit, // we unprotect it using the current keys; otherwise we use the next keys. // // When updating=false, outgoing packets are protected using the current phase. // // An update is initiated and updating is set to true when: // - we decide to initiate a key update; or // - we successfully unprotect a packet using the next keys, // indicating the peer has initiated a key update. // // When updating=true, outgoing packets are protected using the next phase. // We do not change the current phase bit or generate new keys yet. // // The update concludes when we receive an ACK frame for a packet sent // with the next keys. At this time, we set updating to false, flip the // phase bit, and update the keys. This permits us to handle up to 1-RTT // of reordered packets before discarding the previous phase's keys after // an update. type updatingKeyPair struct { phase uint8 // current key phase (r.pkt[0], w.pkt[0]) updating bool authFailures int64 // total packet unprotect failures minSent packetNumber // min packet number sent since entering the updating state minReceived packetNumber // min packet number received in the next phase updateAfter packetNumber // packet number after which to initiate key update r, w updatingKeys } func (k updatingKeyPair) init() { // 1-RTT packets until the first key update. // // We perform the first key update early in the connection so a peer // which does not support key updates will fail rapidly, // rather than after the connection has been long established. // // The QUIC interop runner "keyupdate" test requires that the client // initiate a key rotation early in the connection. Increasing this // value may cause interop test failures; if we do want to increase it, // we should either skip the keyupdate test or provide a way to override // the setting in interop tests. k.updateAfter = 100 } func (k updatingKeyPair) canRead() bool { return k.r.hdr.hp != nil } func (k updatingKeyPair) canWrite() bool { return k.w.hdr.hp != nil } // handleAckFor finishes a key update after receiving an ACK for a packet in the next phase. func (k updatingKeyPair) handleAckFor(pnum packetNumber) { if k.updating && pnum >= k.minSent { k.updating = false k.phase ^= keyPhaseBit k.r.update() k.w.update() } } // needAckEliciting reports whether we should send an ack-eliciting packet in the next phase. // The first packet sent in a phase is ack-eliciting, since the peer must acknowledge a // packet in the new phase for us to finish the update. func (k updatingKeyPair) needAckEliciting() bool { return k.updating && k.minSent == maxPacketNumber } // protect applies packet protection to a packet. // Parameters and returns are as for fixedKeyPair.protect. func (k updatingKeyPair) protect(hdr, pay []byte, pnumOff int, pnum packetNumber) []byte { var pkt []byte if k.updating { hdr[0] \|= k.phase ^ keyPhaseBit pkt = k.w.pkt[1].protect(hdr, pay, pnum) k.minSent = min(pnum, k.minSent) } else { hdr[0] \|= k.phase pkt = k.w.pkt[0].protect(hdr, pay, pnum) if pnum >= k.updateAfter { // Initiate a key update, starting with the next packet we send. // // We do this after protecting the current packet // to allow Conn.appendFrames to ensure that the first packet sent // in the new phase is ack-eliciting. k.updating = true k.minSent = maxPacketNumber k.minReceived = maxPacketNumber // The lowest confidentiality limit for a supported AEAD is 2^23 packets. // https://www.rfc-editor.org/rfc/rfc9001#section-6.6-5 // // Schedule our next update for half that. k.updateAfter += (1 << 22) } } k.w.hdr.protect(pkt, pnumOff) return pkt } // unprotect removes packet protection from a packet. // Parameters and returns are as for fixedKeyPair.unprotect. func (k updatingKeyPair) unprotect(pkt []byte, pnumOff int, pnumMax packetNumber) (pay []byte, pnum packetNumber, err error) { hdr, pay, pnum, err := k.r.hdr.unprotect(pkt, pnumOff, pnumMax) if err != nil { return nil, 0, err } // To avoid timing signals that might indicate the key phase bit is invalid, // we always attempt to unprotect the packet with one key. // // If the key phase bit matches and the packet number doesn't come after // the start of an in-progress update, use the current phase. // Otherwise, use the next phase. if hdr[0]&keyPhaseBit == k.phase && (!k.updating \|\| pnum < k.minReceived) { pay, err = k.r.pkt[0].unprotect(hdr, pay, pnum) } else { pay, err = k.r.pkt[1].unprotect(hdr, pay, pnum) if err == nil { if !k.updating { // The peer has initiated a key update. k.updating = true k.minSent = maxPacketNumber k.minReceived = pnum } else { k.minReceived = min(pnum, k.minReceived) } } } if err != nil { k.authFailures++ if k.authFailures >= aeadIntegrityLimit(k.r.suite) { return nil, 0, localTransportError{code: errAEADLimitReached} } return nil, 0, err } return pay, pnum, nil } // aeadIntegrityLimit returns the integrity limit for an AEAD: // The maximum number of received packets that may fail authentication // before closing the connection. // // https://www.rfc-editor.org/rfc/rfc9001#section-6.6-4 func aeadIntegrityLimit(suite uint16) int64 { switch suite { case tls.TLS_AES_128_GCM_SHA256, tls.TLS_AES_256_GCM_SHA384: return 1 << 52 case tls.TLS_CHACHA20_POLY1305_SHA256: return 1 << 36 default: panic("BUG: unknown cipher suite") } } // https://www.rfc-editor.org/rfc/rfc9001#section-5.2-2 var initialSalt = []byte{0x38, 0x76, 0x2c, 0xf7, 0xf5, 0x59, 0x34, 0xb3, 0x4d, 0x17, 0x9a, 0xe6, 0xa4, 0xc8, 0x0c, 0xad, 0xcc, 0xbb, 0x7f, 0x0a} // initialKeys returns the keys used to protect Initial packets. // // The Initial packet keys are derived from the Destination Connection ID // field in the client's first Initial packet. // // https://www.rfc-editor.org/rfc/rfc9001#section-5.2 func initialKeys(cid []byte, side connSide) fixedKeyPair { initialSecret := hkdf.Extract(sha256.New, cid, initialSalt) var clientKeys fixedKeys clientSecret := hkdfExpandLabel(sha256.New, initialSecret, "client in", nil, sha256.Size) clientKeys.init(tls.TLS_AES_128_GCM_SHA256, clientSecret) var serverKeys fixedKeys serverSecret := hkdfExpandLabel(sha256.New, initialSecret, "server in", nil, sha256.Size) serverKeys.init(tls.TLS_AES_128_GCM_SHA256, serverSecret) if side == clientSide { return fixedKeyPair{r: serverKeys, w: clientKeys} } else { return fixedKeyPair{w: serverKeys, r: clientKeys} } } // checkCipherSuite returns an error if suite is not a supported cipher suite. func checkCipherSuite(suite uint16) error { switch suite { case tls.TLS_AES_128_GCM_SHA256: case tls.TLS_AES_256_GCM_SHA384: case tls.TLS_CHACHA20_POLY1305_SHA256: default: return errors.New("invalid cipher suite") } return nil } func hashForSuite(suite uint16) (h crypto.Hash, keySize int) { switch suite { case tls.TLS_AES_128_GCM_SHA256: return crypto.SHA256, 128 / 8 case tls.TLS_AES_256_GCM_SHA384: return crypto.SHA384, 256 / 8 case tls.TLS_CHACHA20_POLY1305_SHA256: return crypto.SHA256, chacha20.KeySize default: panic("BUG: unknown cipher suite") } } // hdkfExpandLabel implements HKDF-Expand-Label from RFC 8446, Section 7.1. // // Copied from crypto/tls/key_schedule.go. func hkdfExpandLabel(hash func() hash.Hash, secret []byte, label string, context []byte, length int) []byte { var hkdfLabel cryptobyte.Builder hkdfLabel.AddUint16(uint16(length)) hkdfLabel.AddUint8LengthPrefixed(func(b cryptobyte.Builder) { b.AddBytes([]byte("tls13 ")) b.AddBytes([]byte(label)) }) hkdfLabel.AddUint8LengthPrefixed(func(b *cryptobyte.Builder) { b.AddBytes(context) }) out := make([]byte, length) n, err := hkdf.Expand(hash, secret, hkdfLabel.BytesOrPanic()).Read(out) if err != nil \|\| n != length { panic("quic: HKDF-Expand-Label invocation failed unexpectedly") } return out }	16.88 KB	2025-05-25 12:27
📄 packet_protection_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "bytes" "crypto/tls" "testing" ) func TestPacketProtection(t testing.T) { // Test cases from: // https://www.rfc-editor.org/rfc/rfc9001#section-appendix.a cid := unhex(`8394c8f03e515708`) k := initialKeys(cid, clientSide) initialClientKeys, initialServerKeys := k.w, k.r for _, test := range []struct { name string k fixedKeys pnum packetNumber hdr []byte pay []byte prot []byte }{{ name: "Client Initial", k: initialClientKeys, pnum: 2, hdr: unhex(` c300000001088394c8f03e5157080000 449e00000002 `), pay: pad(1162, unhex(` 060040f1010000ed0303ebf8fa56f129 39b9584a3896472ec40bb863cfd3e868 04fe3a47f06a2b69484c000004130113 02010000c000000010000e00000b6578 616d706c652e636f6dff01000100000a 00080006001d00170018001000070005 04616c706e0005000501000000000033 00260024001d00209370b2c9caa47fba baf4559fedba753de171fa71f50f1ce1 5d43e994ec74d748002b000302030400 0d0010000e0403050306030203080408 050806002d00020101001c0002400100 3900320408ffffffffffffffff050480 00ffff07048000ffff08011001048000 75300901100f088394c8f03e51570806 048000ffff `)), prot: unhex(` c000000001088394c8f03e5157080000 449e7b9aec34d1b1c98dd7689fb8ec11 d242b123dc9bd8bab936b47d92ec356c 0bab7df5976d27cd449f63300099f399 1c260ec4c60d17b31f8429157bb35a12 82a643a8d2262cad67500cadb8e7378c 8eb7539ec4d4905fed1bee1fc8aafba1 7c750e2c7ace01e6005f80fcb7df6212 30c83711b39343fa028cea7f7fb5ff89 eac2308249a02252155e2347b63d58c5 457afd84d05dfffdb20392844ae81215 4682e9cf012f9021a6f0be17ddd0c208 4dce25ff9b06cde535d0f920a2db1bf3 62c23e596d11a4f5a6cf3948838a3aec 4e15daf8500a6ef69ec4e3feb6b1d98e 610ac8b7ec3faf6ad760b7bad1db4ba3 485e8a94dc250ae3fdb41ed15fb6a8e5 eba0fc3dd60bc8e30c5c4287e53805db 059ae0648db2f64264ed5e39be2e20d8 2df566da8dd5998ccabdae053060ae6c 7b4378e846d29f37ed7b4ea9ec5d82e7 961b7f25a9323851f681d582363aa5f8 9937f5a67258bf63ad6f1a0b1d96dbd4 faddfcefc5266ba6611722395c906556 be52afe3f565636ad1b17d508b73d874 3eeb524be22b3dcbc2c7468d54119c74 68449a13d8e3b95811a198f3491de3e7 fe942b330407abf82a4ed7c1b311663a c69890f4157015853d91e923037c227a 33cdd5ec281ca3f79c44546b9d90ca00 f064c99e3dd97911d39fe9c5d0b23a22 9a234cb36186c4819e8b9c5927726632 291d6a418211cc2962e20fe47feb3edf 330f2c603a9d48c0fcb5699dbfe58964 25c5bac4aee82e57a85aaf4e2513e4f0 5796b07ba2ee47d80506f8d2c25e50fd 14de71e6c418559302f939b0e1abd576 f279c4b2e0feb85c1f28ff18f58891ff ef132eef2fa09346aee33c28eb130ff2 8f5b766953334113211996d20011a198 e3fc433f9f2541010ae17c1bf202580f 6047472fb36857fe843b19f5984009dd c324044e847a4f4a0ab34f719595de37 252d6235365e9b84392b061085349d73 203a4a13e96f5432ec0fd4a1ee65accd d5e3904df54c1da510b0ff20dcc0c77f cb2c0e0eb605cb0504db87632cf3d8b4 dae6e705769d1de354270123cb11450e fc60ac47683d7b8d0f811365565fd98c 4c8eb936bcab8d069fc33bd801b03ade a2e1fbc5aa463d08ca19896d2bf59a07 1b851e6c239052172f296bfb5e724047 90a2181014f3b94a4e97d117b4381303 68cc39dbb2d198065ae3986547926cd2 162f40a29f0c3c8745c0f50fba3852e5 66d44575c29d39a03f0cda721984b6f4 40591f355e12d439ff150aab7613499d bd49adabc8676eef023b15b65bfc5ca0 6948109f23f350db82123535eb8a7433 bdabcb909271a6ecbcb58b936a88cd4e 8f2e6ff5800175f113253d8fa9ca8885 c2f552e657dc603f252e1a8e308f76f0 be79e2fb8f5d5fbbe2e30ecadd220723 c8c0aea8078cdfcb3868263ff8f09400 54da48781893a7e49ad5aff4af300cd8 04a6b6279ab3ff3afb64491c85194aab 760d58a606654f9f4400e8b38591356f bf6425aca26dc85244259ff2b19c41b9 f96f3ca9ec1dde434da7d2d392b905dd f3d1f9af93d1af5950bd493f5aa731b4 056df31bd267b6b90a079831aaf579be 0a39013137aac6d404f518cfd4684064 7e78bfe706ca4cf5e9c5453e9f7cfd2b 8b4c8d169a44e55c88d4a9a7f9474241 e221af44860018ab0856972e194cd934 `), }, { name: "Server Initial", k: initialServerKeys, pnum: 1, hdr: unhex(` c1000000010008f067a5502a4262b500 40750001 `), pay: unhex(` 02000000000600405a020000560303ee fce7f7b37ba1d1632e96677825ddf739 88cfc79825df566dc5430b9a045a1200 130100002e00330024001d00209d3c94 0d89690b84d08a60993c144eca684d10 81287c834d5311bcf32bb9da1a002b00 020304 `), prot: unhex(` cf000000010008f067a5502a4262b500 4075c0d95a482cd0991cd25b0aac406a 5816b6394100f37a1c69797554780bb3 8cc5a99f5ede4cf73c3ec2493a1839b3 dbcba3f6ea46c5b7684df3548e7ddeb9 c3bf9c73cc3f3bded74b562bfb19fb84 022f8ef4cdd93795d77d06edbb7aaf2f 58891850abbdca3d20398c276456cbc4 2158407dd074ee `), }, { name: "ChaCha20_Poly1305 Short Header", k: func() fixedKeys { secret := unhex(` 9ac312a7f877468ebe69422748ad00a1 5443f18203a07d6060f688f30f21632b `) var k fixedKeys k.init(tls.TLS_CHACHA20_POLY1305_SHA256, secret) return k }(), pnum: 654360564, hdr: unhex(`4200bff4`), pay: unhex(`01`), prot: unhex(` 4cfe4189655e5cd55c41f69080575d79 99c25a5bfb `), }} { test := test t.Run(test.name, func(t testing.T) { pnumLen := int(test.hdr[0]&0x03) + 1 pnumOff := len(test.hdr) - pnumLen b := append([]byte{}, test.hdr...) gotProt := test.k.protect(b, test.pay, pnumOff, test.pnum) if got, want := gotProt, test.prot; !bytes.Equal(got, want) { t.Errorf("Protected payload does not match:") t.Errorf("got: %x", got) t.Errorf("want: %x", want) } pkt := append([]byte{}, test.prot...) gotPay, gotNum, err := test.k.unprotect(pkt, pnumOff, test.pnum-1) if err != nil { t.Fatalf("Unexpected error unprotecting packet: %v", err) } if got, want := pkt[:len(test.hdr)], test.hdr; !bytes.Equal(got, want) { t.Errorf("Unprotected header does not match:") t.Errorf("got: %x", got) t.Errorf("want: %x", want) } if got, want := gotPay, test.pay; !bytes.Equal(got, want) { t.Errorf("Unprotected payload does not match:") t.Errorf("got: %x", got) t.Errorf("want: %x", want) } if got, want := gotNum, test.pnum; got != want { t.Errorf("Unprotected packet number does not match: got %v, want %v", got, want) } }) } } func pad(n int, b []byte) []byte { for len(b) < n { b = append(b, 0) } return b }	6.1 KB	2025-05-25 12:27
📄 packet_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "bytes" "encoding/binary" "encoding/hex" "reflect" "strings" "testing" ) func TestPacketHeader(t testing.T) { for _, test := range []struct { name string packet []byte isLongHeader bool packetType packetType dstConnID []byte }{{ // Initial packet from https://www.rfc-editor.org/rfc/rfc9001#section-a.1 // (truncated) name: "rfc9001_a1", packet: unhex(` c000000001088394c8f03e5157080000 449e7b9aec34d1b1c98dd7689fb8ec11 `), isLongHeader: true, packetType: packetTypeInitial, dstConnID: unhex(`8394c8f03e515708`), }, { // Initial packet from https://www.rfc-editor.org/rfc/rfc9001#section-a.3 // (truncated) name: "rfc9001_a3", packet: unhex(` cf000000010008f067a5502a4262b500 4075c0d95a482cd0991cd25b0aac406a `), isLongHeader: true, packetType: packetTypeInitial, dstConnID: []byte{}, }, { // Retry packet from https://www.rfc-editor.org/rfc/rfc9001#section-a.4 name: "rfc9001_a4", packet: unhex(` ff000000010008f067a5502a4262b574 6f6b656e04a265ba2eff4d829058fb3f 0f2496ba `), isLongHeader: true, packetType: packetTypeRetry, dstConnID: []byte{}, }, { // Short header packet from https://www.rfc-editor.org/rfc/rfc9001#section-a.5 name: "rfc9001_a5", packet: unhex(` 4cfe4189655e5cd55c41f69080575d7999c25a5bfb `), isLongHeader: false, packetType: packetType1RTT, dstConnID: unhex(`fe4189655e5cd55c`), }, { // Version Negotiation packet. name: "version_negotiation", packet: unhex(` 80 00000000 01ff0001020304 `), isLongHeader: true, packetType: packetTypeVersionNegotiation, dstConnID: []byte{0xff}, }, { // Too-short packet. name: "truncated_after_connid_length", packet: unhex(` cf0000000105 `), isLongHeader: true, packetType: packetTypeInitial, dstConnID: nil, }, { // Too-short packet. name: "truncated_after_version", packet: unhex(` cf00000001 `), isLongHeader: true, packetType: packetTypeInitial, dstConnID: nil, }, { // Much too short packet. name: "truncated_in_version", packet: unhex(` cf000000 `), isLongHeader: true, packetType: packetTypeInvalid, dstConnID: nil, }} { t.Run(test.name, func(t testing.T) { if got, want := isLongHeader(test.packet[0]), test.isLongHeader; got != want { t.Errorf("packet %x:\nisLongHeader(packet) = %v, want %v", test.packet, got, want) } if got, want := getPacketType(test.packet), test.packetType; got != want { t.Errorf("packet %x:\ngetPacketType(packet) = %v, want %v", test.packet, got, want) } gotConnID, gotOK := dstConnIDForDatagram(test.packet) wantConnID, wantOK := test.dstConnID, test.dstConnID != nil if !bytes.Equal(gotConnID, wantConnID) \|\| gotOK != wantOK { t.Errorf("packet %x:\ndstConnIDForDatagram(packet) = {%x}, %v; want {%x}, %v", test.packet, gotConnID, gotOK, wantConnID, wantOK) } }) } } func TestEncodeDecodeVersionNegotiation(t testing.T) { dstConnID := []byte("this is a very long destination connection id") srcConnID := []byte("this is a very long source connection id") versions := []uint32{1, 0xffffffff} got := appendVersionNegotiation([]byte{}, dstConnID, srcConnID, versions...) want := bytes.Join([][]byte{{ 0b1100_0000, // header byte 0, 0, 0, 0, // Version byte(len(dstConnID)), }, dstConnID, { byte(len(srcConnID)), }, srcConnID, { 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xff, 0xff, }}, nil) if !bytes.Equal(got, want) { t.Fatalf("appendVersionNegotiation(nil, %x, %x, %v):\ngot %x\nwant %x", dstConnID, srcConnID, versions, got, want) } gotDst, gotSrc, gotVersionBytes := parseVersionNegotiation(got) if got, want := gotDst, dstConnID; !bytes.Equal(got, want) { t.Errorf("parseVersionNegotiation: got dstConnID = %x, want %x", got, want) } if got, want := gotSrc, srcConnID; !bytes.Equal(got, want) { t.Errorf("parseVersionNegotiation: got srcConnID = %x, want %x", got, want) } var gotVersions []uint32 for len(gotVersionBytes) >= 4 { gotVersions = append(gotVersions, binary.BigEndian.Uint32(gotVersionBytes)) gotVersionBytes = gotVersionBytes[4:] } if got, want := gotVersions, versions; !reflect.DeepEqual(got, want) { t.Errorf("parseVersionNegotiation: got versions = %v, want %v", got, want) } } func TestParseGenericLongHeaderPacket(t testing.T) { for _, test := range []struct { name string packet []byte version uint32 dstConnID []byte srcConnID []byte data []byte }{{ name: "long header packet", packet: unhex(` 80 01020304 04a1a2a3a4 05b1b2b3b4b5 c1 `), version: 0x01020304, dstConnID: unhex(`a1a2a3a4`), srcConnID: unhex(`b1b2b3b4b5`), data: unhex(`c1`), }, { name: "zero everything", packet: unhex(` 80 00000000 00 00 `), version: 0, dstConnID: []byte{}, srcConnID: []byte{}, data: []byte{}, }} { t.Run(test.name, func(t testing.T) { p, ok := parseGenericLongHeaderPacket(test.packet) if !ok { t.Fatalf("parseGenericLongHeaderPacket() = _, false; want true") } if got, want := p.version, test.version; got != want { t.Errorf("version = %v, want %v", got, want) } if got, want := p.dstConnID, test.dstConnID; !bytes.Equal(got, want) { t.Errorf("Destination Connection ID = {%x}, want {%x}", got, want) } if got, want := p.srcConnID, test.srcConnID; !bytes.Equal(got, want) { t.Errorf("Source Connection ID = {%x}, want {%x}", got, want) } if got, want := p.data, test.data; !bytes.Equal(got, want) { t.Errorf("Data = {%x}, want {%x}", got, want) } }) } } func TestParseGenericLongHeaderPacketErrors(t testing.T) { for _, test := range []struct { name string packet []byte }{{ name: "short header packet", packet: unhex(` 00 01020304 04a1a2a3a4 05b1b2b3b4b5 c1 `), }, { name: "packet too short", packet: unhex(` 80 000000 `), }, { name: "destination id too long", packet: unhex(` 80 00000000 02 00 `), }, { name: "source id too long", packet: unhex(` 80 00000000 00 01 `), }} { t.Run(test.name, func(t *testing.T) { _, ok := parseGenericLongHeaderPacket(test.packet) if ok { t.Fatalf("parseGenericLongHeaderPacket() = _, true; want false") } }) } } func unhex(s string) []byte { b, err := hex.DecodeString(strings.Map(func(c rune) rune { switch c { case ' ', '\t', '\n': return -1 } return c }, s)) if err != nil { panic(err) } return b }	6.53 KB	2025-05-25 12:27
📄 packet_writer.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "encoding/binary" ) // A packetWriter constructs QUIC datagrams. // // A datagram consists of one or more packets. // A packet consists of a header followed by one or more frames. // // Packets are written in three steps: // - startProtectedLongHeaderPacket or start1RTT packet prepare the packet; // - appendFrame appends frames to the payload; and // - finishProtectedLongHeaderPacket or finish1RTT finalize the packet. // // The start functions are efficient, so we can start speculatively // writing a packet before we know whether we have any frames to // put in it. The finish functions will abandon the packet if the // payload contains no data. type packetWriter struct { dgramLim int // max datagram size pktLim int // max packet size pktOff int // offset of the start of the current packet payOff int // offset of the payload of the current packet b []byte sent sentPacket } // reset prepares to write a datagram of at most lim bytes. func (w packetWriter) reset(lim int) { if cap(w.b) < lim { w.b = make([]byte, 0, lim) } w.dgramLim = lim w.b = w.b[:0] } // datagram returns the current datagram. func (w packetWriter) datagram() []byte { return w.b } // packet returns the size of the current packet. func (w packetWriter) packetLen() int { return len(w.b[w.pktOff:]) + aeadOverhead } // payload returns the payload of the current packet. func (w packetWriter) payload() []byte { return w.b[w.payOff:] } func (w packetWriter) abandonPacket() { w.b = w.b[:w.payOff] w.sent.reset() } // startProtectedLongHeaderPacket starts writing an Initial, 0-RTT, or Handshake packet. func (w packetWriter) startProtectedLongHeaderPacket(pnumMaxAcked packetNumber, p longPacket) { if w.sent == nil { w.sent = newSentPacket() } w.pktOff = len(w.b) hdrSize := 1 // packet type hdrSize += 4 // version hdrSize += 1 + len(p.dstConnID) hdrSize += 1 + len(p.srcConnID) switch p.ptype { case packetTypeInitial: hdrSize += sizeVarint(uint64(len(p.extra))) + len(p.extra) } hdrSize += 2 // length, hardcoded to a 2-byte varint pnumOff := len(w.b) + hdrSize hdrSize += packetNumberLength(p.num, pnumMaxAcked) payOff := len(w.b) + hdrSize // Check if we have enough space to hold the packet, including the header, // header protection sample (RFC 9001, section 5.4.2), and encryption overhead. if pnumOff+4+headerProtectionSampleSize+aeadOverhead >= w.dgramLim { // Set the limit on the packet size to be the current write buffer length, // ensuring that any writes to the payload fail. w.payOff = len(w.b) w.pktLim = len(w.b) return } w.payOff = payOff w.pktLim = w.dgramLim - aeadOverhead // We hardcode the payload length field to be 2 bytes, which limits the payload // (including the packet number) to 16383 bytes (the largest 2-byte QUIC varint). // // Most networks don't support datagrams over 1472 bytes, and even Ethernet // jumbo frames are generally only about 9000 bytes. if lim := pnumOff + 16383 - aeadOverhead; lim < w.pktLim { w.pktLim = lim } w.b = w.b[:payOff] } // finishProtectedLongHeaderPacket finishes writing an Initial, 0-RTT, or Handshake packet, // canceling the packet if it contains no payload. // It returns a sentPacket describing the packet, or nil if no packet was written. func (w packetWriter) finishProtectedLongHeaderPacket(pnumMaxAcked packetNumber, k fixedKeys, p longPacket) sentPacket { if len(w.b) == w.payOff { // The payload is empty, so just abandon the packet. w.b = w.b[:w.pktOff] return nil } pnumLen := packetNumberLength(p.num, pnumMaxAcked) plen := w.padPacketLength(pnumLen) hdr := w.b[:w.pktOff] var typeBits byte switch p.ptype { case packetTypeInitial: typeBits = longPacketTypeInitial case packetType0RTT: typeBits = longPacketType0RTT case packetTypeHandshake: typeBits = longPacketTypeHandshake case packetTypeRetry: typeBits = longPacketTypeRetry } hdr = append(hdr, headerFormLong\|fixedBit\|typeBits\|byte(pnumLen-1)) hdr = binary.BigEndian.AppendUint32(hdr, p.version) hdr = appendUint8Bytes(hdr, p.dstConnID) hdr = appendUint8Bytes(hdr, p.srcConnID) switch p.ptype { case packetTypeInitial: hdr = appendVarintBytes(hdr, p.extra) // token } // Packet length, always encoded as a 2-byte varint. hdr = append(hdr, 0x40\|byte(plen>>8), byte(plen)) pnumOff := len(hdr) hdr = appendPacketNumber(hdr, p.num, pnumMaxAcked) k.protect(hdr[w.pktOff:], w.b[len(hdr):], pnumOff-w.pktOff, p.num) return w.finish(p.ptype, p.num) } // start1RTTPacket starts writing a 1-RTT (short header) packet. func (w packetWriter) start1RTTPacket(pnum, pnumMaxAcked packetNumber, dstConnID []byte) { if w.sent == nil { w.sent = newSentPacket() } w.pktOff = len(w.b) hdrSize := 1 // packet type hdrSize += len(dstConnID) // Ensure we have enough space to hold the packet, including the header, // header protection sample (RFC 9001, section 5.4.2), and encryption overhead. if len(w.b)+hdrSize+4+headerProtectionSampleSize+aeadOverhead >= w.dgramLim { w.payOff = len(w.b) w.pktLim = len(w.b) return } hdrSize += packetNumberLength(pnum, pnumMaxAcked) w.payOff = len(w.b) + hdrSize w.pktLim = w.dgramLim - aeadOverhead w.b = w.b[:w.payOff] } // finish1RTTPacket finishes writing a 1-RTT packet, // canceling the packet if it contains no payload. // It returns a sentPacket describing the packet, or nil if no packet was written. func (w packetWriter) finish1RTTPacket(pnum, pnumMaxAcked packetNumber, dstConnID []byte, k updatingKeyPair) sentPacket { if len(w.b) == w.payOff { // The payload is empty, so just abandon the packet. w.b = w.b[:w.pktOff] return nil } // TODO: Spin pnumLen := packetNumberLength(pnum, pnumMaxAcked) hdr := w.b[:w.pktOff] hdr = append(hdr, 0x40\|byte(pnumLen-1)) hdr = append(hdr, dstConnID...) pnumOff := len(hdr) hdr = appendPacketNumber(hdr, pnum, pnumMaxAcked) w.padPacketLength(pnumLen) k.protect(hdr[w.pktOff:], w.b[len(hdr):], pnumOff-w.pktOff, pnum) return w.finish(packetType1RTT, pnum) } // padPacketLength pads out the payload of the current packet to the minimum size, // and returns the combined length of the packet number and payload (used for the Length // field of long header packets). func (w packetWriter) padPacketLength(pnumLen int) int { plen := len(w.b) - w.payOff + pnumLen + aeadOverhead // "To ensure that sufficient data is available for sampling, packets are // padded so that the combined lengths of the encoded packet number and // protected payload is at least 4 bytes longer than the sample required // for header protection." // https://www.rfc-editor.org/rfc/rfc9001.html#section-5.4.2 for plen < 4+headerProtectionSampleSize { w.b = append(w.b, 0) plen++ } return plen } // finish finishes the current packet after protection is applied. func (w packetWriter) finish(ptype packetType, pnum packetNumber) sentPacket { w.b = w.b[:len(w.b)+aeadOverhead] w.sent.size = len(w.b) - w.pktOff w.sent.ptype = ptype w.sent.num = pnum sent := w.sent w.sent = nil return sent } // avail reports how many more bytes may be written to the current packet. func (w packetWriter) avail() int { return w.pktLim - len(w.b) } // appendPaddingTo appends PADDING frames until the total datagram size // (including AEAD overhead of the current packet) is n. func (w packetWriter) appendPaddingTo(n int) { n -= aeadOverhead lim := w.pktLim if n < lim { lim = n } if len(w.b) >= lim { return } for len(w.b) < lim { w.b = append(w.b, frameTypePadding) } // Packets are considered in flight when they contain a PADDING frame. // https://www.rfc-editor.org/rfc/rfc9002.html#section-2-3.6.1 w.sent.inFlight = true } func (w packetWriter) appendPingFrame() (added bool) { if len(w.b) >= w.pktLim { return false } w.b = append(w.b, frameTypePing) w.sent.markAckEliciting() // no need to record the frame itself return true } // appendAckFrame appends an ACK frame to the payload. // It includes at least the most recent range in the rangeset // (the range with the largest packet numbers), // followed by as many additional ranges as fit within the packet. // // We always place ACK frames at the start of packets, // we limit the number of ack ranges retained, and // we set a minimum packet payload size. // As a result, appendAckFrame will rarely if ever drop ranges // in practice. // // In the event that ranges are dropped, the impact is limited // to the peer potentially failing to receive an acknowledgement // for an older packet during a period of high packet loss or // reordering. This may result in unnecessary retransmissions. func (w packetWriter) appendAckFrame(seen rangeset[packetNumber], delay unscaledAckDelay) (added bool) { if len(seen) == 0 { return false } var ( largest = uint64(seen.max()) firstRange = uint64(seen[len(seen)-1].size() - 1) ) if w.avail() < 1+sizeVarint(largest)+sizeVarint(uint64(delay))+1+sizeVarint(firstRange) { return false } w.b = append(w.b, frameTypeAck) w.b = appendVarint(w.b, largest) w.b = appendVarint(w.b, uint64(delay)) // The range count is technically a varint, but we'll reserve a single byte for it // and never add more than 62 ranges (the maximum varint that fits in a byte). rangeCountOff := len(w.b) w.b = append(w.b, 0) w.b = appendVarint(w.b, firstRange) rangeCount := byte(0) for i := len(seen) - 2; i >= 0; i-- { gap := uint64(seen[i+1].start - seen[i].end - 1) size := uint64(seen[i].size() - 1) if w.avail() < sizeVarint(gap)+sizeVarint(size) \|\| rangeCount > 62 { break } w.b = appendVarint(w.b, gap) w.b = appendVarint(w.b, size) rangeCount++ } w.b[rangeCountOff] = rangeCount w.sent.appendNonAckElicitingFrame(frameTypeAck) w.sent.appendInt(uint64(seen.max())) return true } func (w packetWriter) appendNewTokenFrame(token []byte) (added bool) { if w.avail() < 1+sizeVarint(uint64(len(token)))+len(token) { return false } w.b = append(w.b, frameTypeNewToken) w.b = appendVarintBytes(w.b, token) return true } func (w packetWriter) appendResetStreamFrame(id streamID, code uint64, finalSize int64) (added bool) { if w.avail() < 1+sizeVarint(uint64(id))+sizeVarint(code)+sizeVarint(uint64(finalSize)) { return false } w.b = append(w.b, frameTypeResetStream) w.b = appendVarint(w.b, uint64(id)) w.b = appendVarint(w.b, code) w.b = appendVarint(w.b, uint64(finalSize)) w.sent.appendAckElicitingFrame(frameTypeResetStream) w.sent.appendInt(uint64(id)) return true } func (w packetWriter) appendStopSendingFrame(id streamID, code uint64) (added bool) { if w.avail() < 1+sizeVarint(uint64(id))+sizeVarint(code) { return false } w.b = append(w.b, frameTypeStopSending) w.b = appendVarint(w.b, uint64(id)) w.b = appendVarint(w.b, code) w.sent.appendAckElicitingFrame(frameTypeStopSending) w.sent.appendInt(uint64(id)) return true } // appendCryptoFrame appends a CRYPTO frame. // It returns a []byte into which the data should be written and whether a frame was added. // The returned []byte may be smaller than size if the packet cannot hold all the data. func (w packetWriter) appendCryptoFrame(off int64, size int) (_ []byte, added bool) { max := w.avail() max -= 1 // frame type max -= sizeVarint(uint64(off)) // offset max -= sizeVarint(uint64(size)) // maximum length if max <= 0 { return nil, false } if max < size { size = max } w.b = append(w.b, frameTypeCrypto) w.b = appendVarint(w.b, uint64(off)) w.b = appendVarint(w.b, uint64(size)) start := len(w.b) w.b = w.b[:start+size] w.sent.appendAckElicitingFrame(frameTypeCrypto) w.sent.appendOffAndSize(off, size) return w.b[start:][:size], true } // appendStreamFrame appends a STREAM frame. // It returns a []byte into which the data should be written and whether a frame was added. // The returned []byte may be smaller than size if the packet cannot hold all the data. func (w packetWriter) appendStreamFrame(id streamID, off int64, size int, fin bool) (_ []byte, added bool) { typ := uint8(frameTypeStreamBase \| streamLenBit) max := w.avail() max -= 1 // frame type max -= sizeVarint(uint64(id)) if off != 0 { max -= sizeVarint(uint64(off)) typ \|= streamOffBit } max -= sizeVarint(uint64(size)) // maximum length if max < 0 \|\| (max == 0 && size > 0) { return nil, false } if max < size { size = max } else if fin { typ \|= streamFinBit } w.b = append(w.b, typ) w.b = appendVarint(w.b, uint64(id)) if off != 0 { w.b = appendVarint(w.b, uint64(off)) } w.b = appendVarint(w.b, uint64(size)) start := len(w.b) w.b = w.b[:start+size] w.sent.appendAckElicitingFrame(typ & (frameTypeStreamBase \| streamFinBit)) w.sent.appendInt(uint64(id)) w.sent.appendOffAndSize(off, size) return w.b[start:][:size], true } func (w packetWriter) appendMaxDataFrame(max int64) (added bool) { if w.avail() < 1+sizeVarint(uint64(max)) { return false } w.b = append(w.b, frameTypeMaxData) w.b = appendVarint(w.b, uint64(max)) w.sent.appendAckElicitingFrame(frameTypeMaxData) return true } func (w packetWriter) appendMaxStreamDataFrame(id streamID, max int64) (added bool) { if w.avail() < 1+sizeVarint(uint64(id))+sizeVarint(uint64(max)) { return false } w.b = append(w.b, frameTypeMaxStreamData) w.b = appendVarint(w.b, uint64(id)) w.b = appendVarint(w.b, uint64(max)) w.sent.appendAckElicitingFrame(frameTypeMaxStreamData) w.sent.appendInt(uint64(id)) return true } func (w packetWriter) appendMaxStreamsFrame(streamType streamType, max int64) (added bool) { if w.avail() < 1+sizeVarint(uint64(max)) { return false } var typ byte if streamType == bidiStream { typ = frameTypeMaxStreamsBidi } else { typ = frameTypeMaxStreamsUni } w.b = append(w.b, typ) w.b = appendVarint(w.b, uint64(max)) w.sent.appendAckElicitingFrame(typ) return true } func (w packetWriter) appendDataBlockedFrame(max int64) (added bool) { if w.avail() < 1+sizeVarint(uint64(max)) { return false } w.b = append(w.b, frameTypeDataBlocked) w.b = appendVarint(w.b, uint64(max)) w.sent.appendAckElicitingFrame(frameTypeDataBlocked) return true } func (w packetWriter) appendStreamDataBlockedFrame(id streamID, max int64) (added bool) { if w.avail() < 1+sizeVarint(uint64(id))+sizeVarint(uint64(max)) { return false } w.b = append(w.b, frameTypeStreamDataBlocked) w.b = appendVarint(w.b, uint64(id)) w.b = appendVarint(w.b, uint64(max)) w.sent.appendAckElicitingFrame(frameTypeStreamDataBlocked) w.sent.appendInt(uint64(id)) return true } func (w packetWriter) appendStreamsBlockedFrame(typ streamType, max int64) (added bool) { if w.avail() < 1+sizeVarint(uint64(max)) { return false } var ftype byte if typ == bidiStream { ftype = frameTypeStreamsBlockedBidi } else { ftype = frameTypeStreamsBlockedUni } w.b = append(w.b, ftype) w.b = appendVarint(w.b, uint64(max)) w.sent.appendAckElicitingFrame(ftype) return true } func (w packetWriter) appendNewConnectionIDFrame(seq, retirePriorTo int64, connID []byte, token [16]byte) (added bool) { if w.avail() < 1+sizeVarint(uint64(seq))+sizeVarint(uint64(retirePriorTo))+1+len(connID)+len(token) { return false } w.b = append(w.b, frameTypeNewConnectionID) w.b = appendVarint(w.b, uint64(seq)) w.b = appendVarint(w.b, uint64(retirePriorTo)) w.b = appendUint8Bytes(w.b, connID) w.b = append(w.b, token[:]...) w.sent.appendAckElicitingFrame(frameTypeNewConnectionID) w.sent.appendInt(uint64(seq)) return true } func (w packetWriter) appendRetireConnectionIDFrame(seq int64) (added bool) { if w.avail() < 1+sizeVarint(uint64(seq)) { return false } w.b = append(w.b, frameTypeRetireConnectionID) w.b = appendVarint(w.b, uint64(seq)) w.sent.appendAckElicitingFrame(frameTypeRetireConnectionID) w.sent.appendInt(uint64(seq)) return true } func (w packetWriter) appendPathChallengeFrame(data pathChallengeData) (added bool) { if w.avail() < 1+8 { return false } w.b = append(w.b, frameTypePathChallenge) w.b = append(w.b, data[:]...) w.sent.markAckEliciting() // no need to record the frame itself return true } func (w packetWriter) appendPathResponseFrame(data pathChallengeData) (added bool) { if w.avail() < 1+8 { return false } w.b = append(w.b, frameTypePathResponse) w.b = append(w.b, data[:]...) w.sent.markAckEliciting() // no need to record the frame itself return true } // appendConnectionCloseTransportFrame appends a CONNECTION_CLOSE frame // carrying a transport error code. func (w packetWriter) appendConnectionCloseTransportFrame(code transportError, frameType uint64, reason string) (added bool) { if w.avail() < 1+sizeVarint(uint64(code))+sizeVarint(frameType)+sizeVarint(uint64(len(reason)))+len(reason) { return false } w.b = append(w.b, frameTypeConnectionCloseTransport) w.b = appendVarint(w.b, uint64(code)) w.b = appendVarint(w.b, frameType) w.b = appendVarintBytes(w.b, []byte(reason)) // We don't record CONNECTION_CLOSE frames in w.sent, since they are never acked or // detected as lost. return true } // appendConnectionCloseTransportFrame appends a CONNECTION_CLOSE frame // carrying an application protocol error code. func (w packetWriter) appendConnectionCloseApplicationFrame(code uint64, reason string) (added bool) { if w.avail() < 1+sizeVarint(code)+sizeVarint(uint64(len(reason)))+len(reason) { return false } w.b = append(w.b, frameTypeConnectionCloseApplication) w.b = appendVarint(w.b, code) w.b = appendVarintBytes(w.b, []byte(reason)) // We don't record CONNECTION_CLOSE frames in w.sent, since they are never acked or // detected as lost. return true } func (w *packetWriter) appendHandshakeDoneFrame() (added bool) { if w.avail() < 1 { return false } w.b = append(w.b, frameTypeHandshakeDone) w.sent.appendAckElicitingFrame(frameTypeHandshakeDone) return true }	17.61 KB	2025-05-25 12:27
📄 path.go // Copyright 2024 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import "time" type pathState struct { // Response to a peer's PATH_CHALLENGE. // This is not a sentVal, because we don't resend lost PATH_RESPONSE frames. // We only track the most recent PATH_CHALLENGE. // If the peer sends a second PATH_CHALLENGE before we respond to the first, // we'll drop the first response. sendPathResponse pathResponseType data pathChallengeData } // pathChallengeData is data carried in a PATH_CHALLENGE or PATH_RESPONSE frame. type pathChallengeData [64 / 8]byte type pathResponseType uint8 const ( pathResponseNotNeeded = pathResponseType(iota) pathResponseSmall // send PATH_RESPONSE, do not expand datagram pathResponseExpanded // send PATH_RESPONSE, expand datagram to 1200 bytes ) func (c Conn) handlePathChallenge(_ time.Time, dgram datagram, data pathChallengeData) { // A PATH_RESPONSE is sent in a datagram expanded to 1200 bytes, // except when this would exceed the anti-amplification limit. // // Rather than maintaining anti-amplification state for each path // we may be sending a PATH_RESPONSE on, follow the following heuristic: // // If we receive a PATH_CHALLENGE in an expanded datagram, // respond with an expanded datagram. // // If we receive a PATH_CHALLENGE in a non-expanded datagram, // then the peer is presumably blocked by its own anti-amplification limit. // Respond with a non-expanded datagram. Receiving this PATH_RESPONSE // will validate the path to the peer, remove its anti-amplification limit, // and permit it to send a followup PATH_CHALLENGE in an expanded datagram. // https://www.rfc-editor.org/rfc/rfc9000.html#section-8.2.1 if len(dgram.b) >= smallestMaxDatagramSize { c.path.sendPathResponse = pathResponseExpanded } else { c.path.sendPathResponse = pathResponseSmall } c.path.data = data } func (c Conn) handlePathResponse(now time.Time, _ pathChallengeData) { // "If the content of a PATH_RESPONSE frame does not match the content of // a PATH_CHALLENGE frame previously sent by the endpoint, // the endpoint MAY generate a connection error of type PROTOCOL_VIOLATION." // https://www.rfc-editor.org/rfc/rfc9000.html#section-19.18-4 // // We never send PATH_CHALLENGE frames. c.abort(now, localTransportError{ code: errProtocolViolation, reason: "PATH_RESPONSE received when no PATH_CHALLENGE sent", }) } // appendPathFrames appends path validation related frames to the current packet. // If the return value pad is true, then the packet should be padded to 1200 bytes. func (c Conn) appendPathFrames() (pad, ok bool) { if c.path.sendPathResponse == pathResponseNotNeeded { return pad, true } // We're required to send the PATH_RESPONSE on the path where the // PATH_CHALLENGE was received (RFC 9000, Section 8.2.2). // // At the moment, we don't support path migration and reject packets if // the peer changes its source address, so just sending the PATH_RESPONSE // in a regular datagram is fine. if !c.w.appendPathResponseFrame(c.path.data) { return pad, false } if c.path.sendPathResponse == pathResponseExpanded { pad = true } c.path.sendPathResponse = pathResponseNotNeeded return pad, true }	3.29 KB	2025-05-25 12:27
📄 path_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "testing" ) func TestPathChallengeReceived(t testing.T) { for _, test := range []struct { name string padTo int wantPadding int }{{ name: "unexpanded", padTo: 0, wantPadding: 0, }, { name: "expanded", padTo: 1200, wantPadding: 1200, }} { // "The recipient of [a PATH_CHALLENGE] frame MUST generate // a PATH_RESPONSE frame [...] containing the same Data value." // https://www.rfc-editor.org/rfc/rfc9000.html#section-19.17-7 tc := newTestConn(t, clientSide) tc.handshake() tc.ignoreFrame(frameTypeAck) data := pathChallengeData{0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef} tc.writeFrames(packetType1RTT, debugFramePathChallenge{ data: data, }, debugFramePadding{ to: test.padTo, }) tc.wantFrame("response to PATH_CHALLENGE", packetType1RTT, debugFramePathResponse{ data: data, }) if got, want := tc.lastDatagram.paddedSize, test.wantPadding; got != want { t.Errorf("PATH_RESPONSE expanded to %v bytes, want %v", got, want) } tc.wantIdle("connection is idle") } } func TestPathResponseMismatchReceived(t testing.T) { // "If the content of a PATH_RESPONSE frame does not match the content of // a PATH_CHALLENGE frame previously sent by the endpoint, // the endpoint MAY generate a connection error of type PROTOCOL_VIOLATION." // https://www.rfc-editor.org/rfc/rfc9000.html#section-19.18-4 tc := newTestConn(t, clientSide) tc.handshake() tc.ignoreFrame(frameTypeAck) tc.writeFrames(packetType1RTT, debugFramePathResponse{ data: pathChallengeData{}, }) tc.wantFrame("invalid PATH_RESPONSE causes the connection to close", packetType1RTT, debugFrameConnectionCloseTransport{ code: errProtocolViolation, }, ) }	1.9 KB	2025-05-25 12:27
📄 ping.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import "time" func (c Conn) ping(space numberSpace) { c.sendMsg(func(now time.Time, c Conn) { c.testSendPing.setUnsent() c.testSendPingSpace = space }) }	356 B	2025-05-25 12:27
📄 ping_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import "testing" func TestPing(t testing.T) { tc := newTestConn(t, clientSide) tc.handshake() tc.conn.ping(appDataSpace) tc.wantFrame("connection should send a PING frame", packetType1RTT, debugFramePing{}) tc.advanceToTimer() tc.wantFrame("on PTO, connection should send another PING frame", packetType1RTT, debugFramePing{}) tc.wantIdle("after sending PTO probe, no additional frames to send") } func TestAck(t testing.T) { tc := newTestConn(t, serverSide) tc.handshake() // Send two packets, to trigger an immediate ACK. tc.writeFrames(packetType1RTT, debugFramePing{}, ) tc.writeFrames(packetType1RTT, debugFramePing{}, ) tc.wantFrame("connection should respond to ack-eliciting packet with an ACK frame", packetType1RTT, debugFrameAck{ ranges: []i64range[packetNumber]{{0, 4}}, }, ) }	1 KB	2025-05-25 12:27
📄 pipe.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "sync" ) // A pipe is a byte buffer used in implementing streams. // // A pipe contains a window of stream data. // Random access reads and writes are supported within the window. // Writing past the end of the window extends it. // Data may be discarded from the start of the pipe, advancing the window. type pipe struct { start int64 // stream position of first stored byte end int64 // stream position just past the last stored byte head pipebuf // if non-nil, then head.off + len(head.b) > start tail pipebuf // if non-nil, then tail.off + len(tail.b) == end } type pipebuf struct { off int64 // stream position of b[0] b []byte next pipebuf } func (pb pipebuf) end() int64 { return pb.off + int64(len(pb.b)) } var pipebufPool = sync.Pool{ New: func() any { return &pipebuf{ b: make([]byte, 4096), } }, } func newPipebuf() pipebuf { return pipebufPool.Get().(pipebuf) } func (b pipebuf) recycle() { b.off = 0 b.next = nil pipebufPool.Put(b) } // writeAt writes len(b) bytes to the pipe at offset off. // // Writes to offsets before p.start are discarded. // Writes to offsets after p.end extend the pipe window. func (p pipe) writeAt(b []byte, off int64) { end := off + int64(len(b)) if end > p.end { p.end = end } else if end <= p.start { return } if off < p.start { // Discard the portion of b which falls before p.start. trim := p.start - off b = b[trim:] off = p.start } if p.head == nil { p.head = newPipebuf() p.head.off = p.start p.tail = p.head } pb := p.head if off >= p.tail.off { // Common case: Writing past the end of the pipe. pb = p.tail } for { pboff := off - pb.off if pboff < int64(len(pb.b)) { n := copy(pb.b[pboff:], b) if n == len(b) { return } off += int64(n) b = b[n:] } if pb.next == nil { pb.next = newPipebuf() pb.next.off = pb.off + int64(len(pb.b)) p.tail = pb.next } pb = pb.next } } // copy copies len(b) bytes into b starting from off. // The pipe must contain [off, off+len(b)). func (p pipe) copy(off int64, b []byte) { dst := b[:0] p.read(off, len(b), func(c []byte) error { dst = append(dst, c...) return nil }) } // read calls f with the data in [off, off+n) // The data may be provided sequentially across multiple calls to f. // Note that read (unlike an io.Reader) does not consume the read data. func (p pipe) read(off int64, n int, f func([]byte) error) error { if off < p.start { panic("invalid read range") } for pb := p.head; pb != nil && n > 0; pb = pb.next { if off >= pb.end() { continue } b := pb.b[off-pb.off:] if len(b) > n { b = b[:n] } off += int64(len(b)) n -= len(b) if err := f(b); err != nil { return err } } if n > 0 { panic("invalid read range") } return nil } // peek returns a reference to up to n bytes of internal data buffer, starting at p.start. // The returned slice is valid until the next call to discardBefore. // The length of the returned slice will be in the range [0,n]. func (p pipe) peek(n int64) []byte { pb := p.head if pb == nil { return nil } b := pb.b[p.start-pb.off:] return b[:min(int64(len(b)), n)] } // availableBuffer returns the available contiguous, allocated buffer space // following the pipe window. // // This is used by the stream write fast path, which makes multiple writes into the pipe buffer // without a lock, and then adjusts p.end at a later time with a lock held. func (p pipe) availableBuffer() []byte { if p.tail == nil { return nil } return p.tail.b[p.end-p.tail.off:] } // discardBefore discards all data prior to off. func (p *pipe) discardBefore(off int64) { for p.head != nil && p.head.end() < off { head := p.head p.head = p.head.next head.recycle() } if p.head == nil { p.tail = nil } p.start = off p.end = max(p.end, off) }	3.95 KB	2025-05-25 12:27
📄 pipe_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "bytes" "math/rand" "testing" ) func TestPipeWrites(t *testing.T) { type writeOp struct { start, end int64 } type discardBeforeOp struct { off int64 } type op any src := make([]byte, 65536) rand.New(rand.NewSource(0)).Read(src) for _, test := range []struct { desc string ops []op }{{ desc: "sequential writes", ops: []op{ writeOp{0, 1024}, writeOp{1024, 4096}, writeOp{4096, 65536}, }, }, { desc: "disordered overlapping writes", ops: []op{ writeOp{2000, 8000}, writeOp{0, 3000}, writeOp{7000, 12000}, }, }, { desc: "write to discarded region", ops: []op{ writeOp{0, 65536}, discardBeforeOp{32768}, writeOp{0, 1000}, writeOp{3000, 5000}, writeOp{0, 32768}, }, }, { desc: "write overlaps discarded region", ops: []op{ discardBeforeOp{10000}, writeOp{0, 20000}, }, }, { desc: "discard everything", ops: []op{ writeOp{0, 10000}, discardBeforeOp{10000}, writeOp{10000, 20000}, }, }, { desc: "discard before writing", ops: []op{ discardBeforeOp{1000}, writeOp{0, 1}, }, }} { var p pipe var wantset rangeset[int64] var wantStart, wantEnd int64 for i, o := range test.ops { switch o := o.(type) { case writeOp: p.writeAt(src[o.start:o.end], o.start) wantset.add(o.start, o.end) wantset.sub(0, wantStart) if o.end > wantEnd { wantEnd = o.end } case discardBeforeOp: p.discardBefore(o.off) wantset.sub(0, o.off) wantStart = o.off if o.off > wantEnd { wantEnd = o.off } } if p.start != wantStart \|\| p.end != wantEnd { t.Errorf("%v: after %#v p contains [%v,%v), want [%v,%v)", test.desc, test.ops[:i+1], p.start, p.end, wantStart, wantEnd) } for _, r := range wantset { want := src[r.start:][:r.size()] got := make([]byte, r.size()) p.copy(r.start, got) if !bytes.Equal(got, want) { t.Errorf("%v after %#v, mismatch in data in %v", test.desc, test.ops[:i+1], r) } } } } }	2.15 KB	2025-05-25 12:27
📁 qlog	-	2025-05-25 12:27
📄 qlog.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "context" "encoding/hex" "log/slog" "net/netip" "time" ) // Log levels for qlog events. const ( // QLogLevelFrame includes per-frame information. // When this level is enabled, packet_sent and packet_received events will // contain information on individual frames sent/received. QLogLevelFrame = slog.Level(-6) // QLogLevelPacket events occur at most once per packet sent or received. // // For example: packet_sent, packet_received. QLogLevelPacket = slog.Level(-4) // QLogLevelConn events occur multiple times over a connection's lifetime, // but less often than the frequency of individual packets. // // For example: connection_state_updated. QLogLevelConn = slog.Level(-2) // QLogLevelEndpoint events occur at most once per connection. // // For example: connection_started, connection_closed. QLogLevelEndpoint = slog.Level(0) ) func (c Conn) logEnabled(level slog.Level) bool { return logEnabled(c.log, level) } func logEnabled(log slog.Logger, level slog.Level) bool { return log != nil && log.Enabled(context.Background(), level) } // slogHexstring returns a slog.Attr for a value of the hexstring type. // // https://www.ietf.org/archive/id/draft-ietf-quic-qlog-main-schema-04.html#section-1.1.1 func slogHexstring(key string, value []byte) slog.Attr { return slog.String(key, hex.EncodeToString(value)) } func slogAddr(key string, value netip.Addr) slog.Attr { return slog.String(key, value.String()) } func (c Conn) logConnectionStarted(originalDstConnID []byte, peerAddr netip.AddrPort) { if c.config.QLogLogger == nil \|\| !c.config.QLogLogger.Enabled(context.Background(), QLogLevelEndpoint) { return } var vantage string if c.side == clientSide { vantage = "client" originalDstConnID = c.connIDState.originalDstConnID } else { vantage = "server" } // A qlog Trace container includes some metadata (title, description, vantage_point) // and a list of Events. The Trace also includes a common_fields field setting field // values common to all events in the trace. // // Trace = { // ? title: text // ? description: text // ? configuration: Configuration // ? common_fields: CommonFields // ? vantage_point: VantagePoint // events: [ Event] // } // // To map this into slog's data model, we start each per-connection trace with a With // call that includes both the trace metadata and the common fields. // // This means that in slog's model, each trace event will also include // the Trace metadata fields (vantage_point), which is a divergence from the qlog model. c.log = c.config.QLogLogger.With( // The group_id permits associating traces taken from different vantage points // for the same connection. // // We use the original destination connection ID as the group ID. // // https://www.ietf.org/archive/id/draft-ietf-quic-qlog-main-schema-04.html#section-3.4.6 slogHexstring("group_id", originalDstConnID), slog.Group("vantage_point", slog.String("name", "go quic"), slog.String("type", vantage), ), ) localAddr := c.endpoint.LocalAddr() // https://www.ietf.org/archive/id/draft-ietf-quic-qlog-quic-events-03.html#section-4.2 c.log.LogAttrs(context.Background(), QLogLevelEndpoint, "connectivity:connection_started", slogAddr("src_ip", localAddr.Addr()), slog.Int("src_port", int(localAddr.Port())), slogHexstring("src_cid", c.connIDState.local[0].cid), slogAddr("dst_ip", peerAddr.Addr()), slog.Int("dst_port", int(peerAddr.Port())), slogHexstring("dst_cid", c.connIDState.remote[0].cid), ) } func (c Conn) logConnectionClosed() { if !c.logEnabled(QLogLevelEndpoint) { return } err := c.lifetime.finalErr trigger := "error" switch e := err.(type) { case ApplicationError: // TODO: Distinguish between peer and locally-initiated close. trigger = "application" case localTransportError: switch err { case errHandshakeTimeout: trigger = "handshake_timeout" default: if e.code == errNo { trigger = "clean" } } case peerTransportError: if e.code == errNo { trigger = "clean" } default: switch err { case errIdleTimeout: trigger = "idle_timeout" case errStatelessReset: trigger = "stateless_reset" } } // https://www.ietf.org/archive/id/draft-ietf-quic-qlog-quic-events-03.html#section-4.3 c.log.LogAttrs(context.Background(), QLogLevelEndpoint, "connectivity:connection_closed", slog.String("trigger", trigger), ) } func (c Conn) logPacketDropped(dgram datagram) { c.log.LogAttrs(context.Background(), QLogLevelPacket, "connectivity:packet_dropped", ) } func (c Conn) logLongPacketReceived(p longPacket, pkt []byte) { var frames slog.Attr if c.logEnabled(QLogLevelFrame) { frames = c.packetFramesAttr(p.payload) } c.log.LogAttrs(context.Background(), QLogLevelPacket, "transport:packet_received", slog.Group("header", slog.String("packet_type", p.ptype.qlogString()), slog.Uint64("packet_number", uint64(p.num)), slog.Uint64("flags", uint64(pkt[0])), slogHexstring("scid", p.srcConnID), slogHexstring("dcid", p.dstConnID), ), slog.Group("raw", slog.Int("length", len(pkt)), ), frames, ) } func (c Conn) log1RTTPacketReceived(p shortPacket, pkt []byte) { var frames slog.Attr if c.logEnabled(QLogLevelFrame) { frames = c.packetFramesAttr(p.payload) } dstConnID, _ := dstConnIDForDatagram(pkt) c.log.LogAttrs(context.Background(), QLogLevelPacket, "transport:packet_received", slog.Group("header", slog.String("packet_type", packetType1RTT.qlogString()), slog.Uint64("packet_number", uint64(p.num)), slog.Uint64("flags", uint64(pkt[0])), slogHexstring("dcid", dstConnID), ), slog.Group("raw", slog.Int("length", len(pkt)), ), frames, ) } func (c Conn) logPacketSent(ptype packetType, pnum packetNumber, src, dst []byte, pktLen int, payload []byte) { var frames slog.Attr if c.logEnabled(QLogLevelFrame) { frames = c.packetFramesAttr(payload) } var scid slog.Attr if len(src) > 0 { scid = slogHexstring("scid", src) } c.log.LogAttrs(context.Background(), QLogLevelPacket, "transport:packet_sent", slog.Group("header", slog.String("packet_type", ptype.qlogString()), slog.Uint64("packet_number", uint64(pnum)), scid, slogHexstring("dcid", dst), ), slog.Group("raw", slog.Int("length", pktLen), ), frames, ) } // packetFramesAttr returns the "frames" attribute containing the frames in a packet. // We currently pass this as a slog Any containing a []slog.Value, // where each Value is a debugFrame that implements slog.LogValuer. // // This isn't tremendously efficient, but avoids the need to put a JSON encoder // in the quic package or a frame parser in the qlog package. func (c Conn) packetFramesAttr(payload []byte) slog.Attr { var frames []slog.Value for len(payload) > 0 { f, n := parseDebugFrame(payload) if n < 0 { break } payload = payload[n:] switch f := f.(type) { case debugFrameAck: // The qlog ACK frame contains the ACK Delay field as a duration. // Interpreting the contents of this field as a duration requires // knowing the peer's ack_delay_exponent transport parameter, // and it's possible for us to parse an ACK frame before we've // received that parameter. // // We could plumb connection state down into the frame parser, // but for now let's minimize the amount of code that needs to // deal with this and convert the unscaled value into a scaled one here. ackDelay := time.Duration(-1) if c.peerAckDelayExponent >= 0 { ackDelay = f.ackDelay.Duration(uint8(c.peerAckDelayExponent)) } frames = append(frames, slog.AnyValue(debugFrameScaledAck{ ranges: f.ranges, ackDelay: ackDelay, })) default: frames = append(frames, slog.AnyValue(f)) } } return slog.Any("frames", frames) } func (c Conn) logPacketLost(space numberSpace, sent sentPacket) { c.log.LogAttrs(context.Background(), QLogLevelPacket, "recovery:packet_lost", slog.Group("header", slog.String("packet_type", sent.ptype.qlogString()), slog.Uint64("packet_number", uint64(sent.num)), ), ) }	8.13 KB	2025-05-25 12:27
📄 qlog_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "bytes" "encoding/hex" "encoding/json" "fmt" "io" "log/slog" "reflect" "testing" "time" "golang.org/x/net/quic/qlog" ) func TestQLogHandshake(t testing.T) { testSides(t, "", func(t testing.T, side connSide) { qr := &qlogRecord{} tc := newTestConn(t, side, qr.config) tc.handshake() tc.conn.Abort(nil) tc.wantFrame("aborting connection generates CONN_CLOSE", packetType1RTT, debugFrameConnectionCloseTransport{ code: errNo, }) tc.writeFrames(packetType1RTT, debugFrameConnectionCloseTransport{}) tc.advanceToTimer() // let the conn finish draining var src, dst []byte if side == clientSide { src = testLocalConnID(0) dst = testLocalConnID(-1) } else { src = testPeerConnID(-1) dst = testPeerConnID(0) } qr.wantEvents(t, jsonEvent{ "name": "connectivity:connection_started", "data": map[string]any{ "src_cid": hex.EncodeToString(src), "dst_cid": hex.EncodeToString(dst), }, }, jsonEvent{ "name": "connectivity:connection_closed", "data": map[string]any{ "trigger": "clean", }, }) }) } func TestQLogPacketFrames(t testing.T) { qr := &qlogRecord{} tc := newTestConn(t, clientSide, qr.config) tc.handshake() tc.conn.Abort(nil) tc.writeFrames(packetType1RTT, debugFrameConnectionCloseTransport{}) tc.advanceToTimer() // let the conn finish draining qr.wantEvents(t, jsonEvent{ "name": "transport:packet_sent", "data": map[string]any{ "header": map[string]any{ "packet_type": "initial", "packet_number": 0, "dcid": hex.EncodeToString(testLocalConnID(-1)), "scid": hex.EncodeToString(testLocalConnID(0)), }, "frames": []any{ map[string]any{"frame_type": "crypto"}, }, }, }, jsonEvent{ "name": "transport:packet_received", "data": map[string]any{ "header": map[string]any{ "packet_type": "initial", "packet_number": 0, "dcid": hex.EncodeToString(testLocalConnID(0)), "scid": hex.EncodeToString(testPeerConnID(0)), }, "frames": []any{map[string]any{"frame_type": "crypto"}}, }, }) } func TestQLogConnectionClosedTrigger(t testing.T) { for _, test := range []struct { trigger string connOpts []any f func(testConn) }{{ trigger: "clean", f: func(tc testConn) { tc.handshake() tc.conn.Abort(nil) }, }, { trigger: "handshake_timeout", connOpts: []any{ func(c Config) { c.HandshakeTimeout = 5 time.Second }, }, f: func(tc testConn) { tc.ignoreFrame(frameTypeCrypto) tc.ignoreFrame(frameTypeAck) tc.ignoreFrame(frameTypePing) tc.advance(5 time.Second) }, }, { trigger: "idle_timeout", connOpts: []any{ func(c Config) { c.MaxIdleTimeout = 5 time.Second }, }, f: func(tc testConn) { tc.handshake() tc.advance(5 time.Second) }, }, { trigger: "error", f: func(tc testConn) { tc.handshake() tc.writeFrames(packetType1RTT, debugFrameConnectionCloseTransport{ code: errProtocolViolation, }) tc.conn.Abort(nil) }, }} { t.Run(test.trigger, func(t testing.T) { qr := &qlogRecord{} tc := newTestConn(t, clientSide, append(test.connOpts, qr.config)...) test.f(tc) fr, ptype := tc.readFrame() switch fr := fr.(type) { case debugFrameConnectionCloseTransport: tc.writeFrames(ptype, fr) case nil: default: t.Fatalf("unexpected frame: %v", fr) } tc.wantIdle("connection should be idle while closing") tc.advance(5 * time.Second) // long enough for the drain timer to expire qr.wantEvents(t, jsonEvent{ "name": "connectivity:connection_closed", "data": map[string]any{ "trigger": test.trigger, }, }) }) } } func TestQLogRecovery(t testing.T) { qr := &qlogRecord{} tc, s := newTestConnAndLocalStream(t, clientSide, uniStream, permissiveTransportParameters, qr.config) // Ignore events from the handshake. qr.ev = nil data := make([]byte, 16) s.Write(data) s.CloseWrite() tc.wantFrame("created stream 0", packetType1RTT, debugFrameStream{ id: newStreamID(clientSide, uniStream, 0), fin: true, data: data, }) tc.writeAckForAll() tc.wantIdle("connection should be idle now") // Don't check the contents of fields, but verify that recovery metrics are logged. qr.wantEvents(t, jsonEvent{ "name": "recovery:metrics_updated", "data": map[string]any{ "bytes_in_flight": nil, }, }, jsonEvent{ "name": "recovery:metrics_updated", "data": map[string]any{ "bytes_in_flight": 0, "congestion_window": nil, "latest_rtt": nil, "min_rtt": nil, "rtt_variance": nil, "smoothed_rtt": nil, }, }) } func TestQLogLoss(t testing.T) { qr := &qlogRecord{} tc, s := newTestConnAndLocalStream(t, clientSide, uniStream, permissiveTransportParameters, qr.config) // Ignore events from the handshake. qr.ev = nil data := make([]byte, 16) s.Write(data) s.CloseWrite() tc.wantFrame("created stream 0", packetType1RTT, debugFrameStream{ id: newStreamID(clientSide, uniStream, 0), fin: true, data: data, }) const pto = false tc.triggerLossOrPTO(packetType1RTT, pto) qr.wantEvents(t, jsonEvent{ "name": "recovery:packet_lost", "data": map[string]any{ "header": map[string]any{ "packet_number": nil, "packet_type": "1RTT", }, }, }) } func TestQLogPacketDropped(t testing.T) { qr := &qlogRecord{} tc := newTestConn(t, clientSide, permissiveTransportParameters, qr.config) tc.handshake() // A garbage-filled datagram with a DCID matching this connection. dgram := bytes.Join([][]byte{ {headerFormShort \| fixedBit}, testLocalConnID(0), make([]byte, 100), []byte{1, 2, 3, 4}, // random data, to avoid this looking like a stateless reset }, nil) tc.endpoint.write(&datagram{ b: dgram, }) qr.wantEvents(t, jsonEvent{ "name": "connectivity:packet_dropped", }) } type nopCloseWriter struct { io.Writer } func (nopCloseWriter) Close() error { return nil } type jsonEvent map[string]any func (j jsonEvent) String() string { b, _ := json.MarshalIndent(j, "", " ") return string(b) } // jsonPartialEqual compares two JSON structures. // It ignores fields not set in want (see below for specifics). func jsonPartialEqual(got, want any) (equal bool) { cmpval := func(v any) any { // Map certain types to a common representation. switch v := v.(type) { case int: // JSON uses float64s rather than ints for numbers. // Map int->float64 so we can use integers in expectations. return float64(v) case jsonEvent: return (map[string]any)(v) case []jsonEvent: s := []any{} for _, e := range v { s = append(s, e) } return s } return v } if want == nil { return true // match anything } got = cmpval(got) want = cmpval(want) if reflect.TypeOf(got) != reflect.TypeOf(want) { return false } switch w := want.(type) { case map[string]any: // JSON object: Every field in want must match a field in got. g := got.(map[string]any) for k := range w { if !jsonPartialEqual(g[k], w[k]) { return false } } case []any: // JSON slice: Every field in want must match a field in got, in order. // So want=[2,4] matches got=[1,2,3,4] but not [4,2]. g := got.([]any) for _, ge := range g { if jsonPartialEqual(ge, w[0]) { w = w[1:] if len(w) == 0 { return true } } } return false default: if !reflect.DeepEqual(got, want) { return false } } return true } // A qlogRecord records events. type qlogRecord struct { ev []jsonEvent } func (q qlogRecord) Write(b []byte) (int, error) { // This relies on the property that the Handler always makes one Write call per event. if len(b) < 1 \|\| b[0] != 0x1e { panic(fmt.Errorf("trace Write should start with record separator, got %q", string(b))) } var val map[string]any if err := json.Unmarshal(b[1:], &val); err != nil { panic(fmt.Errorf("log unmarshal failure: %v\n%v", err, string(b))) } q.ev = append(q.ev, val) return len(b), nil } func (q qlogRecord) Close() error { return nil } // config may be passed to newTestConn to configure the conn to use this logger. func (q qlogRecord) config(c Config) { c.QLogLogger = slog.New(qlog.NewJSONHandler(qlog.HandlerOptions{ Level: QLogLevelFrame, NewTrace: func(info qlog.TraceInfo) (io.WriteCloser, error) { return q, nil }, })) } // wantEvents checks that every event in want occurs in the order specified. func (q qlogRecord) wantEvents(t *testing.T, want ...jsonEvent) { t.Helper() got := q.ev if !jsonPartialEqual(got, want) { t.Fatalf("got events:\n%v\n\nwant events:\n%v", got, want) } }	8.64 KB	2025-05-25 12:27
📄 queue.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import "context" // A queue is an unbounded queue of some item (new connections and streams). type queue[T any] struct { // The gate condition is set if the queue is non-empty or closed. gate gate err error q []T } func newQueue[T any]() queue[T] { return queue[T]{gate: newGate()} } // close closes the queue, causing pending and future pop operations // to return immediately with err. func (q queue[T]) close(err error) { q.gate.lock() defer q.unlock() if q.err == nil { q.err = err } } // put appends an item to the queue. // It returns true if the item was added, false if the queue is closed. func (q queue[T]) put(v T) bool { q.gate.lock() defer q.unlock() if q.err != nil { return false } q.q = append(q.q, v) return true } // get removes the first item from the queue, blocking until ctx is done, an item is available, // or the queue is closed. func (q queue[T]) get(ctx context.Context, testHooks connTestHooks) (T, error) { var zero T if err := q.gate.waitAndLock(ctx, testHooks); err != nil { return zero, err } defer q.unlock() if q.err != nil { return zero, q.err } v := q.q[0] copy(q.q[:], q.q[1:]) q.q[len(q.q)-1] = zero q.q = q.q[:len(q.q)-1] return v, nil } func (q queue[T]) unlock() { q.gate.unlock(q.err != nil \|\| len(q.q) > 0) }	1.46 KB	2025-05-25 12:27
📄 queue_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "context" "io" "testing" "time" ) func TestQueue(t testing.T) { nonblocking, cancel := context.WithCancel(context.Background()) cancel() q := newQueue[int]() if got, err := q.get(nonblocking, nil); err != context.Canceled { t.Fatalf("q.get() = %v, %v, want nil, contex.Canceled", got, err) } if !q.put(1) { t.Fatalf("q.put(1) = false, want true") } if !q.put(2) { t.Fatalf("q.put(2) = false, want true") } if got, err := q.get(nonblocking, nil); got != 1 \|\| err != nil { t.Fatalf("q.get() = %v, %v, want 1, nil", got, err) } if got, err := q.get(nonblocking, nil); got != 2 \|\| err != nil { t.Fatalf("q.get() = %v, %v, want 2, nil", got, err) } if got, err := q.get(nonblocking, nil); err != context.Canceled { t.Fatalf("q.get() = %v, %v, want nil, contex.Canceled", got, err) } go func() { time.Sleep(1 time.Millisecond) q.put(3) }() if got, err := q.get(context.Background(), nil); got != 3 \|\| err != nil { t.Fatalf("q.get() = %v, %v, want 3, nil", got, err) } if !q.put(4) { t.Fatalf("q.put(2) = false, want true") } q.close(io.EOF) if got, err := q.get(context.Background(), nil); got != 0 \|\| err != io.EOF { t.Fatalf("q.get() = %v, %v, want 0, io.EOF", got, err) } if q.put(5) { t.Fatalf("q.put(5) = true, want false") } }	1.46 KB	2025-05-25 12:27
📄 quic.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "time" ) // QUIC versions. // We only support v1 at this time. const ( quicVersion1 = 1 quicVersion2 = 0x6b3343cf // https://www.rfc-editor.org/rfc/rfc9369 ) // connIDLen is the length in bytes of connection IDs chosen by this package. // Since 1-RTT packets don't include a connection ID length field, // we use a consistent length for all our IDs. // https://www.rfc-editor.org/rfc/rfc9000.html#section-5.1-6 const connIDLen = 8 // Local values of various transport parameters. // https://www.rfc-editor.org/rfc/rfc9000.html#section-18.2 const ( defaultMaxIdleTimeout = 30 * time.Second // max_idle_timeout // The max_udp_payload_size transport parameter is the size of our // network receive buffer. // // Set this to the largest UDP packet that can be sent over // Ethernet without using jumbo frames: 1500 byte Ethernet frame, // minus 20 byte IPv4 header and 8 byte UDP header. // // The maximum possible UDP payload is 65527 bytes. Supporting this // without wasting memory in unused receive buffers will require some // care. For now, just limit ourselves to the most common case. maxUDPPayloadSize = 1472 ackDelayExponent = 3 // ack_delay_exponent maxAckDelay = 25 * time.Millisecond // max_ack_delay // The active_conn_id_limit transport parameter is the maximum // number of connection IDs from the peer we're willing to store. // // maxPeerActiveConnIDLimit is the maximum number of connection IDs // we're willing to send to the peer. // // https://www.rfc-editor.org/rfc/rfc9000.html#section-18.2-6.2.1 activeConnIDLimit = 2 maxPeerActiveConnIDLimit = 4 ) // Time limit for completing the handshake. const defaultHandshakeTimeout = 10 * time.Second // Keep-alive ping frequency. const defaultKeepAlivePeriod = 0 // Local timer granularity. // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.1.2-6 const timerGranularity = 1 * time.Millisecond // The smallest allowed maximum datagram size. // https://www.rfc-editor.org/rfc/rfc9000#section-14 const smallestMaxDatagramSize = 1200 // Minimum size of a UDP datagram sent by a client carrying an Initial packet, // or a server containing an ack-eliciting Initial packet. // https://www.rfc-editor.org/rfc/rfc9000#section-14.1 const paddedInitialDatagramSize = smallestMaxDatagramSize // Maximum number of streams of a given type which may be created. // https://www.rfc-editor.org/rfc/rfc9000.html#section-4.6-2 const maxStreamsLimit = 1 << 60 // Maximum number of streams we will allow the peer to create implicitly. // A stream ID that is used out of order results in all streams of that type // with lower-numbered IDs also being opened. To limit the amount of work we // will do in response to a single frame, we cap the peer's stream limit to // this value. const implicitStreamLimit = 100 // A connSide distinguishes between the client and server sides of a connection. type connSide int8 const ( clientSide = connSide(iota) serverSide ) func (s connSide) String() string { switch s { case clientSide: return "client" case serverSide: return "server" default: return "BUG" } } func (s connSide) peer() connSide { if s == clientSide { return serverSide } else { return clientSide } } // A numberSpace is the context in which a packet number applies. // https://www.rfc-editor.org/rfc/rfc9000.html#section-12.3-7 type numberSpace byte const ( initialSpace = numberSpace(iota) handshakeSpace appDataSpace numberSpaceCount ) func (n numberSpace) String() string { switch n { case initialSpace: return "Initial" case handshakeSpace: return "Handshake" case appDataSpace: return "AppData" default: return "BUG" } } // A streamType is the type of a stream: bidirectional or unidirectional. type streamType uint8 const ( bidiStream = streamType(iota) uniStream streamTypeCount ) func (s streamType) qlogString() string { switch s { case bidiStream: return "bidirectional" case uniStream: return "unidirectional" default: return "BUG" } } func (s streamType) String() string { switch s { case bidiStream: return "bidi" case uniStream: return "uni" default: return "BUG" } } // A streamID is a QUIC stream ID. // https://www.rfc-editor.org/rfc/rfc9000.html#section-2.1 type streamID uint64 // The two least significant bits of a stream ID indicate the initiator // and directionality of the stream. The upper bits are the stream number. // Each of the four possible combinations of initiator and direction // each has a distinct number space. const ( clientInitiatedStreamBit = 0x0 serverInitiatedStreamBit = 0x1 initiatorStreamBitMask = 0x1 bidiStreamBit = 0x0 uniStreamBit = 0x2 dirStreamBitMask = 0x2 ) func newStreamID(initiator connSide, typ streamType, num int64) streamID { id := streamID(num << 2) if typ == uniStream { id \|= uniStreamBit } if initiator == serverSide { id \|= serverInitiatedStreamBit } return id } func (s streamID) initiator() connSide { if s&initiatorStreamBitMask == serverInitiatedStreamBit { return serverSide } return clientSide } func (s streamID) num() int64 { return int64(s) >> 2 } func (s streamID) streamType() streamType { if s&dirStreamBitMask == uniStreamBit { return uniStream } return bidiStream } // packetFate is the fate of a sent packet: Either acknowledged by the peer, // or declared lost. type packetFate byte const ( packetLost = packetFate(iota) packetAcked )	5.54 KB	2025-05-25 12:27
📄 quic_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "testing" ) func testSides(t testing.T, name string, f func(testing.T, connSide)) { if name != "" { name += "/" } t.Run(name+"server", func(t testing.T) { f(t, serverSide) }) t.Run(name+"client", func(t testing.T) { f(t, clientSide) }) } func testStreamTypes(t testing.T, name string, f func(testing.T, streamType)) { if name != "" { name += "/" } t.Run(name+"bidi", func(t testing.T) { f(t, bidiStream) }) t.Run(name+"uni", func(t testing.T) { f(t, uniStream) }) } func testSidesAndStreamTypes(t testing.T, name string, f func(testing.T, connSide, streamType)) { if name != "" { name += "/" } t.Run(name+"server/bidi", func(t testing.T) { f(t, serverSide, bidiStream) }) t.Run(name+"client/bidi", func(t testing.T) { f(t, clientSide, bidiStream) }) t.Run(name+"server/uni", func(t testing.T) { f(t, serverSide, uniStream) }) t.Run(name+"client/uni", func(t testing.T) { f(t, clientSide, uniStream) }) }	1.12 KB	2025-05-25 12:27
📄 rangeset.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic // A rangeset is a set of int64s, stored as an ordered list of non-overlapping, // non-empty ranges. // // Rangesets are efficient for small numbers of ranges, // which is expected to be the common case. type rangeset[T ~int64] []i64range[T] type i64range[T ~int64] struct { start, end T // [start, end) } // size returns the size of the range. func (r i64range[T]) size() T { return r.end - r.start } // contains reports whether v is in the range. func (r i64range[T]) contains(v T) bool { return r.start <= v && v < r.end } // add adds [start, end) to the set, combining it with existing ranges if necessary. func (s rangeset[T]) add(start, end T) { if start == end { return } for i := range s { r := &(s)[i] if r.start > end { // The new range comes before range i. s.insertrange(i, start, end) return } if start > r.end { // The new range comes after range i. continue } // The new range is adjacent to or overlapping range i. if start < r.start { r.start = start } if end <= r.end { return } // Possibly coalesce subsequent ranges into range i. r.end = end j := i + 1 for ; j < len(s) && r.end >= (s)[j].start; j++ { if e := (s)[j].end; e > r.end { // Range j ends after the new range. r.end = e } } s.removeranges(i+1, j) return } s = append(s, i64range[T]{start, end}) } // sub removes [start, end) from the set. func (s rangeset[T]) sub(start, end T) { removefrom, removeto := -1, -1 for i := range s { r := &(s)[i] if end < r.start { break } if r.end < start { continue } switch { case start <= r.start && end >= r.end: // Remove the entire range. if removefrom == -1 { removefrom = i } removeto = i + 1 case start <= r.start: // Remove a prefix. r.start = end case end >= r.end: // Remove a suffix. r.end = start default: // Remove the middle, leaving two new ranges. rend := r.end r.end = start s.insertrange(i+1, end, rend) return } } if removefrom != -1 { s.removeranges(removefrom, removeto) } } // contains reports whether s contains v. func (s rangeset[T]) contains(v T) bool { for _, r := range s { if v >= r.end { continue } if r.start <= v { return true } return false } return false } // rangeContaining returns the range containing v, or the range [0,0) if v is not in s. func (s rangeset[T]) rangeContaining(v T) i64range[T] { for _, r := range s { if v >= r.end { continue } if r.start <= v { return r } break } return i64range[T]{0, 0} } // min returns the minimum value in the set, or 0 if empty. func (s rangeset[T]) min() T { if len(s) == 0 { return 0 } return s[0].start } // max returns the maximum value in the set, or 0 if empty. func (s rangeset[T]) max() T { if len(s) == 0 { return 0 } return s[len(s)-1].end - 1 } // end returns the end of the last range in the set, or 0 if empty. func (s rangeset[T]) end() T { if len(s) == 0 { return 0 } return s[len(s)-1].end } // numRanges returns the number of ranges in the rangeset. func (s rangeset[T]) numRanges() int { return len(s) } // isrange reports if the rangeset covers exactly the range [start, end). func (s rangeset[T]) isrange(start, end T) bool { switch len(s) { case 0: return start == 0 && end == 0 case 1: return s[0].start == start && s[0].end == end } return false } // removeranges removes ranges [i,j). func (s rangeset[T]) removeranges(i, j int) { if i == j { return } copy((s)[i:], (s)[j:]) s = (s)[:len(s)-(j-i)] } // insert adds a new range at index i. func (s rangeset[T]) insertrange(i int, start, end T) { s = append(s, i64range[T]{}) copy((s)[i+1:], (s)[i:]) (*s)[i] = i64range[T]{start, end} }	3.87 KB	2025-05-25 12:27
📄 rangeset_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "reflect" "testing" ) func TestRangeSize(t testing.T) { for _, test := range []struct { r i64range[int64] want int64 }{{ r: i64range[int64]{0, 100}, want: 100, }, { r: i64range[int64]{10, 20}, want: 10, }} { if got := test.r.size(); got != test.want { t.Errorf("%+v.size = %v, want %v", test.r, got, test.want) } } } func TestRangeContains(t testing.T) { r := i64range[int64]{5, 10} for _, i := range []int64{0, 4, 10, 15} { if r.contains(i) { t.Errorf("%v.contains(%v) = true, want false", r, i) } } for _, i := range []int64{5, 6, 7, 8, 9} { if !r.contains(i) { t.Errorf("%v.contains(%v) = false, want true", r, i) } } } func TestRangesetAdd(t testing.T) { for _, test := range []struct { desc string set rangeset[int64] add i64range[int64] want rangeset[int64] }{{ desc: "add to empty set", set: rangeset[int64]{}, add: i64range[int64]{0, 100}, want: rangeset[int64]{{0, 100}}, }, { desc: "add empty range", set: rangeset[int64]{}, add: i64range[int64]{100, 100}, want: rangeset[int64]{}, }, { desc: "append nonadjacent range", set: rangeset[int64]{{100, 200}}, add: i64range[int64]{300, 400}, want: rangeset[int64]{{100, 200}, {300, 400}}, }, { desc: "prepend nonadjacent range", set: rangeset[int64]{{100, 200}}, add: i64range[int64]{0, 50}, want: rangeset[int64]{{0, 50}, {100, 200}}, }, { desc: "insert nonadjacent range", set: rangeset[int64]{{100, 200}, {500, 600}}, add: i64range[int64]{300, 400}, want: rangeset[int64]{{100, 200}, {300, 400}, {500, 600}}, }, { desc: "prepend adjacent range", set: rangeset[int64]{{100, 200}}, add: i64range[int64]{50, 100}, want: rangeset[int64]{{50, 200}}, }, { desc: "append adjacent range", set: rangeset[int64]{{100, 200}}, add: i64range[int64]{200, 250}, want: rangeset[int64]{{100, 250}}, }, { desc: "prepend overlapping range", set: rangeset[int64]{{100, 200}}, add: i64range[int64]{50, 150}, want: rangeset[int64]{{50, 200}}, }, { desc: "append overlapping range", set: rangeset[int64]{{100, 200}}, add: i64range[int64]{150, 250}, want: rangeset[int64]{{100, 250}}, }, { desc: "replace range", set: rangeset[int64]{{100, 200}}, add: i64range[int64]{50, 250}, want: rangeset[int64]{{50, 250}}, }, { desc: "prepend and combine", set: rangeset[int64]{{100, 200}, {300, 400}, {500, 600}}, add: i64range[int64]{50, 300}, want: rangeset[int64]{{50, 400}, {500, 600}}, }, { desc: "combine several ranges", set: rangeset[int64]{{100, 200}, {300, 400}, {500, 600}, {700, 800}, {900, 1000}}, add: i64range[int64]{300, 850}, want: rangeset[int64]{{100, 200}, {300, 850}, {900, 1000}}, }} { test := test t.Run(test.desc, func(t testing.T) { got := test.set got.add(test.add.start, test.add.end) if !reflect.DeepEqual(got, test.want) { t.Errorf("add [%v,%v) to %v", test.add.start, test.add.end, test.set) t.Errorf(" got: %v", got) t.Errorf(" want: %v", test.want) } }) } } func TestRangesetSub(t testing.T) { for _, test := range []struct { desc string set rangeset[int64] sub i64range[int64] want rangeset[int64] }{{ desc: "subtract from empty set", set: rangeset[int64]{}, sub: i64range[int64]{0, 100}, want: rangeset[int64]{}, }, { desc: "subtract empty range", set: rangeset[int64]{{0, 100}}, sub: i64range[int64]{0, 0}, want: rangeset[int64]{{0, 100}}, }, { desc: "subtract not present in set", set: rangeset[int64]{{0, 100}, {200, 300}}, sub: i64range[int64]{100, 200}, want: rangeset[int64]{{0, 100}, {200, 300}}, }, { desc: "subtract prefix", set: rangeset[int64]{{100, 200}}, sub: i64range[int64]{0, 150}, want: rangeset[int64]{{150, 200}}, }, { desc: "subtract suffix", set: rangeset[int64]{{100, 200}}, sub: i64range[int64]{150, 300}, want: rangeset[int64]{{100, 150}}, }, { desc: "subtract middle", set: rangeset[int64]{{0, 100}}, sub: i64range[int64]{40, 60}, want: rangeset[int64]{{0, 40}, {60, 100}}, }, { desc: "subtract from two ranges", set: rangeset[int64]{{0, 100}, {200, 300}}, sub: i64range[int64]{50, 250}, want: rangeset[int64]{{0, 50}, {250, 300}}, }, { desc: "subtract removes range", set: rangeset[int64]{{0, 100}, {200, 300}, {400, 500}}, sub: i64range[int64]{200, 300}, want: rangeset[int64]{{0, 100}, {400, 500}}, }, { desc: "subtract removes multiple ranges", set: rangeset[int64]{{0, 100}, {200, 300}, {400, 500}, {600, 700}}, sub: i64range[int64]{50, 650}, want: rangeset[int64]{{0, 50}, {650, 700}}, }, { desc: "subtract only range", set: rangeset[int64]{{0, 100}}, sub: i64range[int64]{0, 100}, want: rangeset[int64]{}, }} { test := test t.Run(test.desc, func(t testing.T) { got := test.set got.sub(test.sub.start, test.sub.end) if !reflect.DeepEqual(got, test.want) { t.Errorf("sub [%v,%v) from %v", test.sub.start, test.sub.end, test.set) t.Errorf(" got: %v", got) t.Errorf(" want: %v", test.want) } }) } } func TestRangesetContains(t testing.T) { var s rangeset[int64] s.add(10, 20) s.add(30, 40) for i := int64(0); i < 50; i++ { want := (i >= 10 && i < 20) \|\| (i >= 30 && i < 40) if got := s.contains(i); got != want { t.Errorf("%v.contains(%v) = %v, want %v", s, i, got, want) } } } func TestRangesetRangeContaining(t testing.T) { var s rangeset[int64] s.add(10, 20) s.add(30, 40) for _, test := range []struct { v int64 want i64range[int64] }{ {0, i64range[int64]{0, 0}}, {9, i64range[int64]{0, 0}}, {10, i64range[int64]{10, 20}}, {15, i64range[int64]{10, 20}}, {19, i64range[int64]{10, 20}}, {20, i64range[int64]{0, 0}}, {29, i64range[int64]{0, 0}}, {30, i64range[int64]{30, 40}}, {39, i64range[int64]{30, 40}}, {40, i64range[int64]{0, 0}}, } { got := s.rangeContaining(test.v) if got != test.want { t.Errorf("%v.rangeContaining(%v) = %v, want %v", s, test.v, got, test.want) } } } func TestRangesetLimits(t testing.T) { for _, test := range []struct { s rangeset[int64] wantMin int64 wantMax int64 wantEnd int64 }{{ s: rangeset[int64]{}, wantMin: 0, wantMax: 0, wantEnd: 0, }, { s: rangeset[int64]{{10, 20}}, wantMin: 10, wantMax: 19, wantEnd: 20, }, { s: rangeset[int64]{{10, 20}, {30, 40}, {50, 60}}, wantMin: 10, wantMax: 59, wantEnd: 60, }} { if got, want := test.s.min(), test.wantMin; got != want { t.Errorf("%+v.min() = %v, want %v", test.s, got, want) } if got, want := test.s.max(), test.wantMax; got != want { t.Errorf("%+v.max() = %v, want %v", test.s, got, want) } if got, want := test.s.end(), test.wantEnd; got != want { t.Errorf("%+v.end() = %v, want %v", test.s, got, want) } } } func TestRangesetIsRange(t testing.T) { for _, test := range []struct { s rangeset[int64] r i64range[int64] want bool }{{ s: rangeset[int64]{{0, 100}}, r: i64range[int64]{0, 100}, want: true, }, { s: rangeset[int64]{{0, 100}}, r: i64range[int64]{0, 101}, want: false, }, { s: rangeset[int64]{{0, 10}, {11, 100}}, r: i64range[int64]{0, 100}, want: false, }, { s: rangeset[int64]{}, r: i64range[int64]{0, 0}, want: true, }, { s: rangeset[int64]{}, r: i64range[int64]{0, 1}, want: false, }} { if got := test.s.isrange(test.r.start, test.r.end); got != test.want { t.Errorf("%+v.isrange(%v, %v) = %v, want %v", test.s, test.r.start, test.r.end, got, test.want) } } } func TestRangesetNumRanges(t *testing.T) { for _, test := range []struct { s rangeset[int64] want int }{{ s: rangeset[int64]{}, want: 0, }, { s: rangeset[int64]{{0, 100}}, want: 1, }, { s: rangeset[int64]{{0, 100}, {200, 300}}, want: 2, }} { if got, want := test.s.numRanges(), test.want; got != want { t.Errorf("%+v.numRanges() = %v, want %v", test.s, got, want) } } }	7.99 KB	2025-05-25 12:27
📄 retry.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "bytes" "crypto/aes" "crypto/cipher" "crypto/rand" "encoding/binary" "net/netip" "time" "golang.org/x/crypto/chacha20poly1305" ) // AEAD and nonce used to compute the Retry Integrity Tag. // https://www.rfc-editor.org/rfc/rfc9001#section-5.8 var ( retrySecret = []byte{0xbe, 0x0c, 0x69, 0x0b, 0x9f, 0x66, 0x57, 0x5a, 0x1d, 0x76, 0x6b, 0x54, 0xe3, 0x68, 0xc8, 0x4e} retryNonce = []byte{0x46, 0x15, 0x99, 0xd3, 0x5d, 0x63, 0x2b, 0xf2, 0x23, 0x98, 0x25, 0xbb} retryAEAD = func() cipher.AEAD { c, err := aes.NewCipher(retrySecret) if err != nil { panic(err) } aead, err := cipher.NewGCM(c) if err != nil { panic(err) } return aead }() ) // retryTokenValidityPeriod is how long we accept a Retry packet token after sending it. const retryTokenValidityPeriod = 5 * time.Second // retryState generates and validates an endpoint's retry tokens. type retryState struct { aead cipher.AEAD } func (rs retryState) init() error { // Retry tokens are authenticated using a per-server key chosen at start time. // TODO: Provide a way for the user to set this key. secret := make([]byte, chacha20poly1305.KeySize) if _, err := rand.Read(secret); err != nil { return err } aead, err := chacha20poly1305.NewX(secret) if err != nil { panic(err) } rs.aead = aead return nil } // Retry tokens are encrypted with an AEAD. // The plaintext contains the time the token was created and // the original destination connection ID. // The additional data contains the sender's source address and original source connection ID. // The token nonce is randomly generated. // We use the nonce as the Source Connection ID of the Retry packet. // Since the 24-byte XChaCha20-Poly1305 nonce is too large to fit in a 20-byte connection ID, // we include the remaining 4 bytes of nonce in the token. // // Token { // Last 4 Bytes of Nonce (32), // Ciphertext (..), // } // // Plaintext { // Timestamp (64), // Original Destination Connection ID, // } // // // Additional Data { // Original Source Connection ID Length (8), // Original Source Connection ID (..), // IP Address (32..128), // Port (16), // } // // TODO: Consider using AES-256-GCM-SIV once crypto/tls supports it. func (rs retryState) makeToken(now time.Time, srcConnID, origDstConnID []byte, addr netip.AddrPort) (token, newDstConnID []byte, err error) { nonce := make([]byte, rs.aead.NonceSize()) if _, err := rand.Read(nonce); err != nil { return nil, nil, err } var plaintext []byte plaintext = binary.BigEndian.AppendUint64(plaintext, uint64(now.Unix())) plaintext = append(plaintext, origDstConnID...) token = append(token, nonce[maxConnIDLen:]...) token = rs.aead.Seal(token, nonce, plaintext, rs.additionalData(srcConnID, addr)) return token, nonce[:maxConnIDLen], nil } func (rs retryState) validateToken(now time.Time, token, srcConnID, dstConnID []byte, addr netip.AddrPort) (origDstConnID []byte, ok bool) { tokenNonceLen := rs.aead.NonceSize() - maxConnIDLen if len(token) < tokenNonceLen { return nil, false } nonce := append([]byte{}, dstConnID...) nonce = append(nonce, token[:tokenNonceLen]...) ciphertext := token[tokenNonceLen:] plaintext, err := rs.aead.Open(nil, nonce, ciphertext, rs.additionalData(srcConnID, addr)) if err != nil { return nil, false } if len(plaintext) < 8 { return nil, false } when := time.Unix(int64(binary.BigEndian.Uint64(plaintext)), 0) origDstConnID = plaintext[8:] // We allow for tokens created in the future (up to the validity period), // which likely indicates that the system clock was adjusted backwards. if d := abs(now.Sub(when)); d > retryTokenValidityPeriod { return nil, false } return origDstConnID, true } func (rs retryState) additionalData(srcConnID []byte, addr netip.AddrPort) []byte { var additional []byte additional = appendUint8Bytes(additional, srcConnID) additional = append(additional, addr.Addr().AsSlice()...) additional = binary.BigEndian.AppendUint16(additional, addr.Port()) return additional } func (e Endpoint) validateInitialAddress(now time.Time, p genericLongPacket, peerAddr netip.AddrPort) (origDstConnID []byte, ok bool) { // The retry token is at the start of an Initial packet's data. token, n := consumeUint8Bytes(p.data) if n < 0 { // We've already validated that the packet is at least 1200 bytes long, // so there's no way for even a maximum size token to not fit. // Check anyway. return nil, false } if len(token) == 0 { // The sender has not provided a token. // Send a Retry packet to them with one. e.sendRetry(now, p, peerAddr) return nil, false } origDstConnID, ok = e.retry.validateToken(now, token, p.srcConnID, p.dstConnID, peerAddr) if !ok { // This does not seem to be a valid token. // Close the connection with an INVALID_TOKEN error. // https://www.rfc-editor.org/rfc/rfc9000#section-8.1.2-5 e.sendConnectionClose(p, peerAddr, errInvalidToken) return nil, false } return origDstConnID, true } func (e Endpoint) sendRetry(now time.Time, p genericLongPacket, peerAddr netip.AddrPort) { token, srcConnID, err := e.retry.makeToken(now, p.srcConnID, p.dstConnID, peerAddr) if err != nil { return } b := encodeRetryPacket(p.dstConnID, retryPacket{ dstConnID: p.srcConnID, srcConnID: srcConnID, token: token, }) e.sendDatagram(datagram{ b: b, peerAddr: peerAddr, }) } type retryPacket struct { dstConnID []byte srcConnID []byte token []byte } func encodeRetryPacket(originalDstConnID []byte, p retryPacket) []byte { // Retry packets include an integrity tag, computed by AEAD_AES_128_GCM over // the original destination connection ID followed by the Retry packet // (less the integrity tag itself). // https://www.rfc-editor.org/rfc/rfc9001#section-5.8 // // Create the pseudo-packet (including the original DCID), append the tag, // and return the Retry packet. var b []byte b = appendUint8Bytes(b, originalDstConnID) // Original Destination Connection ID start := len(b) // start of the Retry packet b = append(b, headerFormLong\|fixedBit\|longPacketTypeRetry) b = binary.BigEndian.AppendUint32(b, quicVersion1) // Version b = appendUint8Bytes(b, p.dstConnID) // Destination Connection ID b = appendUint8Bytes(b, p.srcConnID) // Source Connection ID b = append(b, p.token...) // Token b = retryAEAD.Seal(b, retryNonce, nil, b) // Retry Integrity Tag return b[start:] } func parseRetryPacket(b, origDstConnID []byte) (p retryPacket, ok bool) { const retryIntegrityTagLength = 128 / 8 lp, ok := parseGenericLongHeaderPacket(b) if !ok { return retryPacket{}, false } if len(lp.data) < retryIntegrityTagLength { return retryPacket{}, false } gotTag := lp.data[len(lp.data)-retryIntegrityTagLength:] // Create the pseudo-packet consisting of the original destination connection ID // followed by the Retry packet (less the integrity tag). // Use this to validate the packet integrity tag. pseudo := appendUint8Bytes(nil, origDstConnID) pseudo = append(pseudo, b[:len(b)-retryIntegrityTagLength]...) wantTag := retryAEAD.Seal(nil, retryNonce, nil, pseudo) if !bytes.Equal(gotTag, wantTag) { return retryPacket{}, false } token := lp.data[:len(lp.data)-retryIntegrityTagLength] return retryPacket{ dstConnID: lp.dstConnID, srcConnID: lp.srcConnID, token: token, }, true }	7.46 KB	2025-05-25 12:27
📄 retry_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "bytes" "context" "crypto/tls" "net/netip" "testing" "time" ) type retryServerTest struct { te testEndpoint originalSrcConnID []byte originalDstConnID []byte retry retryPacket initialCrypto []byte } // newRetryServerTest creates a test server connection, // sends the connection an Initial packet, // and expects a Retry in response. func newRetryServerTest(t testing.T) retryServerTest { t.Helper() config := &Config{ TLSConfig: newTestTLSConfig(serverSide), RequireAddressValidation: true, } te := newTestEndpoint(t, config) srcID := testPeerConnID(0) dstID := testLocalConnID(-1) params := defaultTransportParameters() params.initialSrcConnID = srcID initialCrypto := initialClientCrypto(t, te, params) // Initial packet with no Token. // Server responds with a Retry containing a token. te.writeDatagram(&testDatagram{ packets: []testPacket{{ ptype: packetTypeInitial, num: 0, version: quicVersion1, srcConnID: srcID, dstConnID: dstID, frames: []debugFrame{ debugFrameCrypto{ data: initialCrypto, }, }, }}, paddedSize: 1200, }) got := te.readDatagram() if len(got.packets) != 1 \|\| got.packets[0].ptype != packetTypeRetry { t.Fatalf("got datagram: %v\nwant Retry", got) } p := got.packets[0] if got, want := p.dstConnID, srcID; !bytes.Equal(got, want) { t.Fatalf("Retry destination = {%x}, want {%x}", got, want) } return &retryServerTest{ te: te, originalSrcConnID: srcID, originalDstConnID: dstID, retry: retryPacket{ dstConnID: p.dstConnID, srcConnID: p.srcConnID, token: p.token, }, initialCrypto: initialCrypto, } } func TestRetryServerSucceeds(t testing.T) { rt := newRetryServerTest(t) te := rt.te te.advance(retryTokenValidityPeriod) te.writeDatagram(&testDatagram{ packets: []testPacket{{ ptype: packetTypeInitial, num: 1, version: quicVersion1, srcConnID: rt.originalSrcConnID, dstConnID: rt.retry.srcConnID, token: rt.retry.token, frames: []debugFrame{ debugFrameCrypto{ data: rt.initialCrypto, }, }, }}, paddedSize: 1200, }) tc := te.accept() initial := tc.readPacket() if initial == nil \|\| initial.ptype != packetTypeInitial { t.Fatalf("got packet:\n%v\nwant: Initial", initial) } handshake := tc.readPacket() if handshake == nil \|\| handshake.ptype != packetTypeHandshake { t.Fatalf("got packet:\n%v\nwant: Handshake", initial) } if got, want := tc.sentTransportParameters.retrySrcConnID, rt.retry.srcConnID; !bytes.Equal(got, want) { t.Errorf("retry_source_connection_id = {%x}, want {%x}", got, want) } if got, want := tc.sentTransportParameters.initialSrcConnID, initial.srcConnID; !bytes.Equal(got, want) { t.Errorf("initial_source_connection_id = {%x}, want {%x}", got, want) } if got, want := tc.sentTransportParameters.originalDstConnID, rt.originalDstConnID; !bytes.Equal(got, want) { t.Errorf("original_destination_connection_id = {%x}, want {%x}", got, want) } } func TestRetryServerTokenInvalid(t testing.T) { // "If a server receives a client Initial that contains an invalid Retry token [...] // the server SHOULD immediately close [...] the connection with an // INVALID_TOKEN error." // https://www.rfc-editor.org/rfc/rfc9000#section-8.1.2-5 rt := newRetryServerTest(t) te := rt.te te.writeDatagram(&testDatagram{ packets: []testPacket{{ ptype: packetTypeInitial, num: 1, version: quicVersion1, srcConnID: rt.originalSrcConnID, dstConnID: rt.retry.srcConnID, token: append(rt.retry.token, 0), frames: []debugFrame{ debugFrameCrypto{ data: rt.initialCrypto, }, }, }}, paddedSize: 1200, }) te.wantDatagram("server closes connection after Initial with invalid Retry token", initialConnectionCloseDatagram( rt.retry.srcConnID, rt.originalSrcConnID, errInvalidToken)) } func TestRetryServerTokenTooOld(t testing.T) { // "[...] a token SHOULD have an expiration time [...]" // https://www.rfc-editor.org/rfc/rfc9000#section-8.1.3-3 rt := newRetryServerTest(t) te := rt.te te.advance(retryTokenValidityPeriod + time.Second) te.writeDatagram(&testDatagram{ packets: []testPacket{{ ptype: packetTypeInitial, num: 1, version: quicVersion1, srcConnID: rt.originalSrcConnID, dstConnID: rt.retry.srcConnID, token: rt.retry.token, frames: []debugFrame{ debugFrameCrypto{ data: rt.initialCrypto, }, }, }}, paddedSize: 1200, }) te.wantDatagram("server closes connection after Initial with expired token", initialConnectionCloseDatagram( rt.retry.srcConnID, rt.originalSrcConnID, errInvalidToken)) } func TestRetryServerTokenWrongIP(t testing.T) { // "Tokens sent in Retry packets SHOULD include information that allows the server // to verify that the source IP address and port in client packets remain constant." // https://www.rfc-editor.org/rfc/rfc9000#section-8.1.4-3 rt := newRetryServerTest(t) te := rt.te te.writeDatagram(&testDatagram{ packets: []testPacket{{ ptype: packetTypeInitial, num: 1, version: quicVersion1, srcConnID: rt.originalSrcConnID, dstConnID: rt.retry.srcConnID, token: rt.retry.token, frames: []debugFrame{ debugFrameCrypto{ data: rt.initialCrypto, }, }, }}, paddedSize: 1200, addr: netip.MustParseAddrPort("10.0.0.2:8000"), }) te.wantDatagram("server closes connection after Initial from wrong address", initialConnectionCloseDatagram( rt.retry.srcConnID, rt.originalSrcConnID, errInvalidToken)) } func TestRetryServerIgnoresRetry(t testing.T) { tc := newTestConn(t, serverSide) tc.handshake() tc.write(&testDatagram{ packets: []testPacket{{ ptype: packetTypeRetry, originalDstConnID: testLocalConnID(-1), srcConnID: testPeerConnID(0), dstConnID: testLocalConnID(0), token: []byte{1, 2, 3, 4}, }}, }) // Send two packets, to trigger an immediate ACK. tc.writeFrames(packetType1RTT, debugFramePing{}) tc.writeFrames(packetType1RTT, debugFramePing{}) tc.wantFrameType("server connection ignores spurious Retry packet", packetType1RTT, debugFrameAck{}) } func TestRetryClientSuccess(t testing.T) { // "This token MUST be repeated by the client in all Initial packets it sends // for that connection after it receives the Retry packet." // https://www.rfc-editor.org/rfc/rfc9000#section-8.1.2-1 tc := newTestConn(t, clientSide) tc.wantFrame("client Initial CRYPTO data", packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataOut[tls.QUICEncryptionLevelInitial], }) newServerConnID := []byte("new_conn_id") token := []byte("token") tc.write(&testDatagram{ packets: []testPacket{{ ptype: packetTypeRetry, originalDstConnID: testLocalConnID(-1), srcConnID: newServerConnID, dstConnID: testLocalConnID(0), token: token, }}, }) tc.wantPacket("client sends a new Initial packet with a token", &testPacket{ ptype: packetTypeInitial, num: 1, version: quicVersion1, srcConnID: testLocalConnID(0), dstConnID: newServerConnID, token: token, frames: []debugFrame{ debugFrameCrypto{ data: tc.cryptoDataOut[tls.QUICEncryptionLevelInitial], }, }, }, ) tc.advanceToTimer() tc.wantPacket("after PTO client sends another Initial packet with a token", &testPacket{ ptype: packetTypeInitial, num: 2, version: quicVersion1, srcConnID: testLocalConnID(0), dstConnID: newServerConnID, token: token, frames: []debugFrame{ debugFrameCrypto{ data: tc.cryptoDataOut[tls.QUICEncryptionLevelInitial], }, }, }, ) } func TestRetryClientInvalidServerTransportParameters(t testing.T) { // Various permutations of missing or invalid values for transport parameters // after a Retry. // https://www.rfc-editor.org/rfc/rfc9000#section-7.3 initialSrcConnID := testPeerConnID(0) originalDstConnID := testLocalConnID(-1) retrySrcConnID := testPeerConnID(100) for _, test := range []struct { name string f func(transportParameters) ok bool }{{ name: "valid", f: func(p transportParameters) {}, ok: true, }, { name: "missing initial_source_connection_id", f: func(p transportParameters) { p.initialSrcConnID = nil }, }, { name: "invalid initial_source_connection_id", f: func(p transportParameters) { p.initialSrcConnID = []byte("invalid") }, }, { name: "missing original_destination_connection_id", f: func(p transportParameters) { p.originalDstConnID = nil }, }, { name: "invalid original_destination_connection_id", f: func(p transportParameters) { p.originalDstConnID = []byte("invalid") }, }, { name: "missing retry_source_connection_id", f: func(p transportParameters) { p.retrySrcConnID = nil }, }, { name: "invalid retry_source_connection_id", f: func(p transportParameters) { p.retrySrcConnID = []byte("invalid") }, }} { t.Run(test.name, func(t testing.T) { tc := newTestConn(t, clientSide, func(p transportParameters) { p.initialSrcConnID = initialSrcConnID p.originalDstConnID = originalDstConnID p.retrySrcConnID = retrySrcConnID }, test.f) tc.ignoreFrame(frameTypeAck) tc.wantFrameType("client Initial CRYPTO data", packetTypeInitial, debugFrameCrypto{}) tc.write(&testDatagram{ packets: []testPacket{{ ptype: packetTypeRetry, originalDstConnID: originalDstConnID, srcConnID: retrySrcConnID, dstConnID: testLocalConnID(0), token: []byte{1, 2, 3, 4}, }}, }) tc.wantFrameType("client resends Initial CRYPTO data", packetTypeInitial, debugFrameCrypto{}) tc.writeFrames(packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelInitial], }) tc.writeFrames(packetTypeHandshake, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelHandshake], }) if test.ok { tc.wantFrameType("valid params, client sends Handshake", packetTypeHandshake, debugFrameCrypto{}) } else { tc.wantFrame("invalid transport parameters", packetTypeInitial, debugFrameConnectionCloseTransport{ code: errTransportParameter, }) } }) } } func TestRetryClientIgnoresRetryAfterReceivingPacket(t testing.T) { // "After the client has received and processed an Initial or Retry packet // from the server, it MUST discard any subsequent Retry packets that it receives." // https://www.rfc-editor.org/rfc/rfc9000#section-17.2.5.2-1 tc := newTestConn(t, clientSide) tc.ignoreFrame(frameTypeAck) tc.ignoreFrame(frameTypeNewConnectionID) tc.wantFrameType("client Initial CRYPTO data", packetTypeInitial, debugFrameCrypto{}) tc.writeFrames(packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelInitial], }) retry := &testDatagram{ packets: []testPacket{{ ptype: packetTypeRetry, originalDstConnID: testLocalConnID(-1), srcConnID: testPeerConnID(100), dstConnID: testLocalConnID(0), token: []byte{1, 2, 3, 4}, }}, } tc.write(retry) tc.wantIdle("client ignores Retry after receiving Initial packet") tc.writeFrames(packetTypeHandshake, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelHandshake], }) tc.wantFrameType("client Handshake CRYPTO data", packetTypeHandshake, debugFrameCrypto{}) tc.write(retry) tc.wantIdle("client ignores Retry after discarding Initial keys") } func TestRetryClientIgnoresRetryAfterReceivingRetry(t testing.T) { // "After the client has received and processed an Initial or Retry packet // from the server, it MUST discard any subsequent Retry packets that it receives." // https://www.rfc-editor.org/rfc/rfc9000#section-17.2.5.2-1 tc := newTestConn(t, clientSide) tc.wantFrameType("client Initial CRYPTO data", packetTypeInitial, debugFrameCrypto{}) retry := &testDatagram{ packets: []testPacket{{ ptype: packetTypeRetry, originalDstConnID: testLocalConnID(-1), srcConnID: testPeerConnID(100), dstConnID: testLocalConnID(0), token: []byte{1, 2, 3, 4}, }}, } tc.write(retry) tc.wantFrameType("client resends Initial CRYPTO data", packetTypeInitial, debugFrameCrypto{}) tc.write(retry) tc.wantIdle("client ignores second Retry") } func TestRetryClientIgnoresRetryWithInvalidIntegrityTag(t testing.T) { tc := newTestConn(t, clientSide) tc.wantFrameType("client Initial CRYPTO data", packetTypeInitial, debugFrameCrypto{}) pkt := encodeRetryPacket(testLocalConnID(-1), retryPacket{ srcConnID: testPeerConnID(100), dstConnID: testLocalConnID(0), token: []byte{1, 2, 3, 4}, }) pkt[len(pkt)-1] ^= 1 // invalidate the integrity tag tc.endpoint.write(&datagram{ b: pkt, peerAddr: testClientAddr, }) tc.wantIdle("client ignores Retry with invalid integrity tag") } func TestRetryClientIgnoresRetryWithZeroLengthToken(t testing.T) { // "A client MUST discard a Retry packet with a zero-length Retry Token field." // https://www.rfc-editor.org/rfc/rfc9000#section-17.2.5.2-2 tc := newTestConn(t, clientSide) tc.wantFrameType("client Initial CRYPTO data", packetTypeInitial, debugFrameCrypto{}) tc.write(&testDatagram{ packets: []testPacket{{ ptype: packetTypeRetry, originalDstConnID: testLocalConnID(-1), srcConnID: testPeerConnID(100), dstConnID: testLocalConnID(0), token: []byte{}, }}, }) tc.wantIdle("client ignores Retry with zero-length token") } func TestRetryStateValidateInvalidToken(t testing.T) { // Test handling of tokens that may have a valid signature, // but unexpected contents. var rs retryState if err := rs.init(); err != nil { t.Fatal(err) } nonce := make([]byte, rs.aead.NonceSize()) now := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC) srcConnID := []byte{1, 2, 3, 4} dstConnID := nonce[:20] addr := testClientAddr for _, test := range []struct { name string token []byte }{{ name: "token too short", token: []byte{1, 2, 3}, }, { name: "token plaintext too short", token: func() []byte { plaintext := make([]byte, 7) // not enough bytes of content token := append([]byte{}, nonce[20:]...) return rs.aead.Seal(token, nonce, plaintext, rs.additionalData(srcConnID, addr)) }(), }} { t.Run(test.name, func(t testing.T) { if _, ok := rs.validateToken(now, test.token, srcConnID, dstConnID, addr); ok { t.Errorf("validateToken succeeded, want failure") } }) } } func TestParseInvalidRetryPackets(t testing.T) { originalDstConnID := []byte{1, 2, 3, 4} goodPkt := encodeRetryPacket(originalDstConnID, retryPacket{ dstConnID: []byte{1}, srcConnID: []byte{2}, token: []byte{3}, }) for _, test := range []struct { name string pkt []byte }{{ name: "packet too short", pkt: goodPkt[:len(goodPkt)-4], }, { name: "packet header invalid", pkt: goodPkt[:5], }, { name: "integrity tag invalid", pkt: func() []byte { pkt := cloneBytes(goodPkt) pkt[len(pkt)-1] ^= 1 return pkt }(), }} { t.Run(test.name, func(t testing.T) { if _, ok := parseRetryPacket(test.pkt, originalDstConnID); ok { t.Errorf("parseRetryPacket succeeded, want failure") } }) } } func initialClientCrypto(t testing.T, e testEndpoint, p transportParameters) []byte { t.Helper() config := &tls.QUICConfig{TLSConfig: newTestTLSConfig(clientSide)} tlsClient := tls.QUICClient(config) tlsClient.SetTransportParameters(marshalTransportParameters(p)) tlsClient.Start(context.Background()) t.Cleanup(func() { tlsClient.Close() }) e.peerTLSConn = tlsClient var data []byte for { e := tlsClient.NextEvent() switch e.Kind { case tls.QUICNoEvent: return data case tls.QUICWriteData: if e.Level != tls.QUICEncryptionLevelInitial { t.Fatal("initial data at unexpected level") } data = append(data, e.Data...) } } } func initialConnectionCloseDatagram(srcConnID, dstConnID []byte, code transportError) testDatagram { return &testDatagram{ packets: []*testPacket{{ ptype: packetTypeInitial, num: 0, version: quicVersion1, srcConnID: srcConnID, dstConnID: dstConnID, frames: []debugFrame{ debugFrameConnectionCloseTransport{ code: code, }, }, }}, } }	16.38 KB	2025-05-25 12:27
📄 rtt.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "time" ) type rttState struct { minRTT time.Duration latestRTT time.Duration smoothedRTT time.Duration rttvar time.Duration // RTT variation firstSampleTime time.Time // time of first RTT sample } func (r rttState) init() { r.minRTT = -1 // -1 indicates the first sample has not been taken yet // "[...] the initial RTT SHOULD be set to 333 milliseconds." // https://www.rfc-editor.org/rfc/rfc9002.html#section-6.2.2-1 const initialRTT = 333 time.Millisecond // https://www.rfc-editor.org/rfc/rfc9002.html#section-5.3-12 r.smoothedRTT = initialRTT r.rttvar = initialRTT / 2 } func (r rttState) establishPersistentCongestion() { // "Endpoints SHOULD set the min_rtt to the newest RTT sample // after persistent congestion is established." // https://www.rfc-editor.org/rfc/rfc9002#section-5.2-5 r.minRTT = r.latestRTT } // updateRTTSample is called when we generate a new RTT sample. // https://www.rfc-editor.org/rfc/rfc9002.html#section-5 func (r rttState) updateSample(now time.Time, handshakeConfirmed bool, spaceID numberSpace, latestRTT, ackDelay, maxAckDelay time.Duration) { r.latestRTT = latestRTT if r.minRTT < 0 { // First RTT sample. // "min_rtt MUST be set to the latest_rtt on the first RTT sample." // https://www.rfc-editor.org/rfc/rfc9002.html#section-5.2-2 r.minRTT = latestRTT // https://www.rfc-editor.org/rfc/rfc9002.html#section-5.3-14 r.smoothedRTT = latestRTT r.rttvar = latestRTT / 2 r.firstSampleTime = now return } // "min_rtt MUST be set to the lesser of min_rtt and latest_rtt [...] // on all other samples." // https://www.rfc-editor.org/rfc/rfc9002.html#section-5.2-2 r.minRTT = min(r.minRTT, latestRTT) // https://www.rfc-editor.org/rfc/rfc9002.html#section-5.3-16 if handshakeConfirmed { ackDelay = min(ackDelay, maxAckDelay) } adjustedRTT := latestRTT - ackDelay if adjustedRTT < r.minRTT { adjustedRTT = latestRTT } rttvarSample := abs(r.smoothedRTT - adjustedRTT) r.rttvar = (3r.rttvar + rttvarSample) / 4 r.smoothedRTT = ((7 r.smoothedRTT) + adjustedRTT) / 8 }	2.25 KB	2025-05-25 12:27
📄 rtt_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "testing" "time" ) func TestRTTMinRTT(t testing.T) { var ( handshakeConfirmed = false ackDelay = 0 time.Millisecond maxAckDelay = 25 * time.Millisecond now = time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC) ) rtt := &rttState{} rtt.init() // "min_rtt MUST be set to the latest_rtt on the first RTT sample." // https://www.rfc-editor.org/rfc/rfc9002.html#section-5.2-2 rtt.updateSample(now, handshakeConfirmed, initialSpace, 10time.Millisecond, ackDelay, maxAckDelay) if got, want := rtt.latestRTT, 10time.Millisecond; got != want { t.Errorf("on first sample: latest_rtt = %v, want %v", got, want) } if got, want := rtt.minRTT, 10time.Millisecond; got != want { t.Errorf("on first sample: min_rtt = %v, want %v", got, want) } // "min_rtt MUST be set to the lesser of min_rtt and latest_rtt [...] // on all other samples." rtt.updateSample(now, handshakeConfirmed, initialSpace, 20time.Millisecond, ackDelay, maxAckDelay) if got, want := rtt.latestRTT, 20time.Millisecond; got != want { t.Errorf("on increasing sample: latest_rtt = %v, want %v", got, want) } if got, want := rtt.minRTT, 10time.Millisecond; got != want { t.Errorf("on increasing sample: min_rtt = %v, want %v (no change)", got, want) } rtt.updateSample(now, handshakeConfirmed, initialSpace, 5time.Millisecond, ackDelay, maxAckDelay) if got, want := rtt.latestRTT, 5time.Millisecond; got != want { t.Errorf("on new minimum: latest_rtt = %v, want %v", got, want) } if got, want := rtt.minRTT, 5time.Millisecond; got != want { t.Errorf("on new minimum: min_rtt = %v, want %v", got, want) } // "Endpoints SHOULD set the min_rtt to the newest RTT sample // after persistent congestion is established." // https://www.rfc-editor.org/rfc/rfc9002.html#section-5.2-5 rtt.updateSample(now, handshakeConfirmed, initialSpace, 15time.Millisecond, ackDelay, maxAckDelay) if got, want := rtt.latestRTT, 15time.Millisecond; got != want { t.Errorf("on increasing sample: latest_rtt = %v, want %v", got, want) } if got, want := rtt.minRTT, 5time.Millisecond; got != want { t.Errorf("on increasing sample: min_rtt = %v, want %v (no change)", got, want) } rtt.establishPersistentCongestion() if got, want := rtt.minRTT, 15time.Millisecond; got != want { t.Errorf("after persistent congestion: min_rtt = %v, want %v", got, want) } } func TestRTTInitialRTT(t testing.T) { var ( handshakeConfirmed = false ackDelay = 0 * time.Millisecond maxAckDelay = 25 * time.Millisecond now = time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC) ) rtt := &rttState{} rtt.init() // "When no previous RTT is available, // the initial RTT SHOULD be set to 333 milliseconds." // https://www.rfc-editor.org/rfc/rfc9002#section-6.2.2-1 if got, want := rtt.smoothedRTT, 333time.Millisecond; got != want { t.Errorf("initial smoothed_rtt = %v, want %v", got, want) } if got, want := rtt.rttvar, 333time.Millisecond/2; got != want { t.Errorf("initial rttvar = %v, want %v", got, want) } rtt.updateSample(now, handshakeConfirmed, initialSpace, 10time.Millisecond, ackDelay, maxAckDelay) smoothedRTT := 10 time.Millisecond if got, want := rtt.smoothedRTT, smoothedRTT; got != want { t.Errorf("after first rtt sample of 10ms, smoothed_rtt = %v, want %v", got, want) } rttvar := 5 * time.Millisecond if got, want := rtt.rttvar, rttvar; got != want { t.Errorf("after first rtt sample of 10ms, rttvar = %v, want %v", got, want) } // "[...] MAY ignore the acknowledgment delay for Initial packets [...]" // https://www.rfc-editor.org/rfc/rfc9002#section-5.3-7.1 ackDelay = 1 * time.Millisecond rtt.updateSample(now, handshakeConfirmed, initialSpace, 10time.Millisecond, ackDelay, maxAckDelay) adjustedRTT := 10 time.Millisecond smoothedRTT = (7smoothedRTT + adjustedRTT) / 8 if got, want := rtt.smoothedRTT, smoothedRTT; got != want { t.Errorf("smoothed_rtt = %v, want %v", got, want) } rttvarSample := abs(smoothedRTT - adjustedRTT) rttvar = (3rttvar + rttvarSample) / 4 if got, want := rtt.rttvar, rttvar; got != want { t.Errorf("rttvar = %v, want %v", got, want) } // "[...] SHOULD ignore the peer's max_ack_delay until the handshake is confirmed [...]" // https://www.rfc-editor.org/rfc/rfc9002#section-5.3-7.2 ackDelay = 30 * time.Millisecond maxAckDelay = 25 * time.Millisecond rtt.updateSample(now, handshakeConfirmed, handshakeSpace, 40time.Millisecond, ackDelay, maxAckDelay) adjustedRTT = 10 time.Millisecond // latest_rtt (40ms) - ack_delay (30ms) smoothedRTT = (7smoothedRTT + adjustedRTT) / 8 if got, want := rtt.smoothedRTT, smoothedRTT; got != want { t.Errorf("smoothed_rtt = %v, want %v", got, want) } rttvarSample = abs(smoothedRTT - adjustedRTT) rttvar = (3rttvar + rttvarSample) / 4 if got, want := rtt.rttvar, rttvar; got != want { t.Errorf("rttvar = %v, want %v", got, want) } // "[...] MUST use the lesser of the acknowledgment delay and // the peer's max_ack_delay after the handshake is confirmed [...]" // https://www.rfc-editor.org/rfc/rfc9002#section-5.3-7.3 ackDelay = 30 * time.Millisecond maxAckDelay = 25 * time.Millisecond handshakeConfirmed = true rtt.updateSample(now, handshakeConfirmed, handshakeSpace, 40time.Millisecond, ackDelay, maxAckDelay) adjustedRTT = 15 time.Millisecond // latest_rtt (40ms) - max_ack_delay (25ms) rttvarSample = abs(smoothedRTT - adjustedRTT) rttvar = (3rttvar + rttvarSample) / 4 if got, want := rtt.rttvar, rttvar; got != want { t.Errorf("rttvar = %v, want %v", got, want) } smoothedRTT = (7smoothedRTT + adjustedRTT) / 8 if got, want := rtt.smoothedRTT, smoothedRTT; got != want { t.Errorf("smoothed_rtt = %v, want %v", got, want) } // "[...] MUST NOT subtract the acknowledgment delay from // the RTT sample if the resulting value is smaller than the min_rtt." // https://www.rfc-editor.org/rfc/rfc9002#section-5.3-7.4 ackDelay = 25 * time.Millisecond maxAckDelay = 25 * time.Millisecond handshakeConfirmed = true rtt.updateSample(now, handshakeConfirmed, handshakeSpace, 30time.Millisecond, ackDelay, maxAckDelay) if got, want := rtt.minRTT, 10time.Millisecond; got != want { t.Errorf("min_rtt = %v, want %v", got, want) } // latest_rtt (30ms) - ack_delay (25ms) = 5ms, which is less than min_rtt (10ms) adjustedRTT = 30 * time.Millisecond // latest_rtt rttvarSample = abs(smoothedRTT - adjustedRTT) rttvar = (3rttvar + rttvarSample) / 4 if got, want := rtt.rttvar, rttvar; got != want { t.Errorf("rttvar = %v, want %v", got, want) } smoothedRTT = (7smoothedRTT + adjustedRTT) / 8 if got, want := rtt.smoothedRTT, smoothedRTT; got != want { t.Errorf("smoothed_rtt = %v, want %v", got, want) } }	6.79 KB	2025-05-25 12:27
📄 sent_packet.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "sync" "time" ) // A sentPacket tracks state related to an in-flight packet we sent, // to be committed when the peer acks it or resent if the packet is lost. type sentPacket struct { num packetNumber size int // size in bytes time time.Time // time sent ptype packetType ackEliciting bool // https://www.rfc-editor.org/rfc/rfc9002.html#section-2-3.4.1 inFlight bool // https://www.rfc-editor.org/rfc/rfc9002.html#section-2-3.6.1 acked bool // ack has been received lost bool // packet is presumed lost // Frames sent in the packet. // // This is an abbreviated version of the packet payload, containing only the information // we need to process an ack for or loss of this packet. // For example, a CRYPTO frame is recorded as the frame type (0x06), offset, and length, // but does not include the sent data. // // This buffer is written by packetWriter.append* and read by Conn.handleAckOrLoss. b []byte n int // read offset into b } var sentPool = sync.Pool{ New: func() any { return &sentPacket{} }, } func newSentPacket() sentPacket { sent := sentPool.Get().(sentPacket) sent.reset() return sent } // recycle returns a sentPacket to the pool. func (sent sentPacket) recycle() { sentPool.Put(sent) } func (sent sentPacket) reset() { sent = sentPacket{ b: sent.b[:0], } } // markAckEliciting marks the packet as containing an ack-eliciting frame. func (sent sentPacket) markAckEliciting() { sent.ackEliciting = true sent.inFlight = true } // The append* methods record information about frames in the packet. func (sent sentPacket) appendNonAckElicitingFrame(frameType byte) { sent.b = append(sent.b, frameType) } func (sent sentPacket) appendAckElicitingFrame(frameType byte) { sent.ackEliciting = true sent.inFlight = true sent.b = append(sent.b, frameType) } func (sent sentPacket) appendInt(v uint64) { sent.b = appendVarint(sent.b, v) } func (sent sentPacket) appendOffAndSize(start int64, size int) { sent.b = appendVarint(sent.b, uint64(start)) sent.b = appendVarint(sent.b, uint64(size)) } // The next* methods read back information about frames in the packet. func (sent sentPacket) next() (frameType byte) { f := sent.b[sent.n] sent.n++ return f } func (sent sentPacket) nextInt() uint64 { v, n := consumeVarint(sent.b[sent.n:]) sent.n += n return v } func (sent sentPacket) nextRange() (start, end int64) { start = int64(sent.nextInt()) end = start + int64(sent.nextInt()) return start, end } func (sent sentPacket) done() bool { return sent.n == len(sent.b) }	2.72 KB	2025-05-25 12:27
📄 sent_packet_list.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic // A sentPacketList is a ring buffer of sentPackets. // // Processing an ack for a packet causes all older packets past a small threshold // to be discarded (RFC 9002, Section 6.1.1), so the list of in-flight packets is // not sparse and will contain at most a few acked/lost packets we no longer // care about. type sentPacketList struct { nextNum packetNumber // next packet number to add to the buffer off int // offset of first packet in the buffer size int // number of packets p []sentPacket } // start is the first packet in the list. func (s sentPacketList) start() packetNumber { return s.nextNum - packetNumber(s.size) } // end is one after the last packet in the list. // If the list is empty, start == end. func (s sentPacketList) end() packetNumber { return s.nextNum } // discard clears the list. func (s sentPacketList) discard() { s = sentPacketList{} } // add appends a packet to the list. func (s sentPacketList) add(sent sentPacket) { if s.nextNum != sent.num { panic("inserting out-of-order packet") } s.nextNum++ if s.size >= len(s.p) { s.grow() } i := (s.off + s.size) % len(s.p) s.size++ s.p[i] = sent } // nth returns a packet by index. func (s sentPacketList) nth(n int) sentPacket { index := (s.off + n) % len(s.p) return s.p[index] } // num returns a packet by number. // It returns nil if the packet is not in the list. func (s sentPacketList) num(num packetNumber) sentPacket { i := int(num - s.start()) if i < 0 \|\| i >= s.size { return nil } return s.nth(i) } // clean removes all acked or lost packets from the head of the list. func (s sentPacketList) clean() { for s.size > 0 { sent := s.p[s.off] if !sent.acked && !sent.lost { return } sent.recycle() s.p[s.off] = nil s.off = (s.off + 1) % len(s.p) s.size-- } s.off = 0 } // grow increases the buffer to hold more packaets. func (s sentPacketList) grow() { newSize := len(s.p) 2 if newSize == 0 { newSize = 64 } p := make([]*sentPacket, newSize) for i := 0; i < s.size; i++ { p[i] = s.nth(i) } s.p = p s.off = 0 }	2.25 KB	2025-05-25 12:27
📄 sent_packet_list_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import "testing" func TestSentPacketListSlidingWindow(t testing.T) { // Record 1000 sent packets, acking everything outside the most recent 10. list := &sentPacketList{} const window = 10 for i := packetNumber(0); i < 1000; i++ { list.add(&sentPacket{num: i}) if i < window { continue } prev := i - window sent := list.num(prev) if sent == nil { t.Fatalf("packet %v not in list", prev) } if sent.num != prev { t.Fatalf("list.num(%v) = packet %v", prev, sent.num) } if got := list.nth(0); got != sent { t.Fatalf("list.nth(0) != list.num(%v)", prev) } sent.acked = true list.clean() if got := list.num(prev); got != nil { t.Fatalf("list.num(%v) = packet %v, expected it to be discarded", prev, got.num) } if got, want := list.start(), prev+1; got != want { t.Fatalf("list.start() = %v, want %v", got, want) } if got, want := list.end(), i+1; got != want { t.Fatalf("list.end() = %v, want %v", got, want) } if got, want := list.size, window; got != want { t.Fatalf("list.size = %v, want %v", got, want) } } } func TestSentPacketListGrows(t testing.T) { // Record 1000 sent packets. list := &sentPacketList{} const count = 1000 for i := packetNumber(0); i < count; i++ { list.add(&sentPacket{num: i}) } if got, want := list.start(), packetNumber(0); got != want { t.Fatalf("list.start() = %v, want %v", got, want) } if got, want := list.end(), packetNumber(count); got != want { t.Fatalf("list.end() = %v, want %v", got, want) } if got, want := list.size, count; got != want { t.Fatalf("list.size = %v, want %v", got, want) } for i := packetNumber(0); i < count; i++ { sent := list.num(i) if sent == nil { t.Fatalf("packet %v not in list", i) } if sent.num != i { t.Fatalf("list.num(%v) = packet %v", i, sent.num) } if got := list.nth(int(i)); got != sent { t.Fatalf("list.nth(%v) != list.num(%v)", int(i), i) } } } func TestSentPacketListCleanAll(t *testing.T) { list := &sentPacketList{} // Record 10 sent packets. const count = 10 for i := packetNumber(0); i < count; i++ { list.add(&sentPacket{num: i}) } // Mark all the packets as acked. for i := packetNumber(0); i < count; i++ { list.num(i).acked = true } list.clean() if got, want := list.size, 0; got != want { t.Fatalf("list.size = %v, want %v", got, want) } list.add(&sentPacket{num: 10}) if got, want := list.size, 1; got != want { t.Fatalf("list.size = %v, want %v", got, want) } sent := list.num(10) if sent == nil { t.Fatalf("packet %v not in list", 10) } if sent.num != 10 { t.Fatalf("list.num(10) = %v", sent.num) } if got := list.nth(0); got != sent { t.Fatalf("list.nth(0) != list.num(10)") } }	2.84 KB	2025-05-25 12:27
📄 sent_packet_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import "testing" func TestSentPacket(t *testing.T) { frames := []any{ byte(frameTypePing), byte(frameTypeStreamBase), uint64(1), i64range[int64]{1 << 20, 1<<20 + 1024}, } // Record sent frames. sent := newSentPacket() for _, f := range frames { switch f := f.(type) { case byte: sent.appendAckElicitingFrame(f) case uint64: sent.appendInt(f) case i64range[int64]: sent.appendOffAndSize(f.start, int(f.size())) } } // Read the record. for i, want := range frames { if done := sent.done(); done { t.Fatalf("before consuming contents, sent.done() = true, want false") } switch want := want.(type) { case byte: if got := sent.next(); got != want { t.Fatalf("%v: sent.next() = %v, want %v", i, got, want) } case uint64: if got := sent.nextInt(); got != want { t.Fatalf("%v: sent.nextInt() = %v, want %v", i, got, want) } case i64range[int64]: if start, end := sent.nextRange(); start != want.start \|\| end != want.end { t.Fatalf("%v: sent.nextRange() = [%v,%v), want %v", i, start, end, want) } } } if done := sent.done(); !done { t.Fatalf("after consuming contents, sent.done() = false, want true") } }	1.35 KB	2025-05-25 12:27
📄 sent_val.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic // A sentVal tracks sending some piece of information to the peer. // It tracks whether the information has been sent, acked, and // (when in-flight) the most recent packet to carry it. // // For example, a sentVal can track sending of a RESET_STREAM frame. // // - unset: stream is active, no need to send RESET_STREAM // - unsent: we should send a RESET_STREAM, but have not yet // - sent: we have sent a RESET_STREAM, but have not received an ack // - received: we have sent a RESET_STREAM, and the peer has acked the packet that contained it // // In the "sent" state, a sentVal also tracks the latest packet number to carry // the information. (QUIC packet numbers are always at most 62 bits in size, // so the sentVal keeps the number in the low 62 bits and the state in the high 2 bits.) type sentVal uint64 const ( sentValUnset = 0 // unset sentValUnsent = 1 << 62 // set, not sent to the peer sentValSent = 2 << 62 // set, sent to the peer but not yet acked; pnum is set sentValReceived = 3 << 62 // set, peer acked receipt sentValStateMask = 3 << 62 ) // isSet reports whether the value is set. func (s sentVal) isSet() bool { return s != 0 } // shouldSend reports whether the value is set and has not been sent to the peer. func (s sentVal) shouldSend() bool { return s.state() == sentValUnsent } // shouldSend reports whether the value needs to be sent to the peer. // The value needs to be sent if it is set and has not been sent. // If pto is true, indicating that we are sending a PTO probe, the value // should also be sent if it is set and has not been acknowledged. func (s sentVal) shouldSendPTO(pto bool) bool { st := s.state() return st == sentValUnsent \|\| (pto && st == sentValSent) } // isReceived reports whether the value has been received by the peer. func (s sentVal) isReceived() bool { return s == sentValReceived } // set sets the value and records that it should be sent to the peer. // If the value has already been sent, it is not resent. func (s sentVal) set() { if s == 0 { s = sentValUnsent } } // reset sets the value to the unsent state. func (s sentVal) setUnsent() { s = sentValUnsent } // clear sets the value to the unset state. func (s sentVal) clear() { s = sentValUnset } // setSent sets the value to the send state and records the number of the most recent // packet containing the value. func (s sentVal) setSent(pnum packetNumber) { s = sentValSent \| sentVal(pnum) } // setReceived sets the value to the received state. func (s sentVal) setReceived() { s = sentValReceived } // ackOrLoss reports that an acknowledgement has been received for the value, // or that the packet carrying the value has been lost. func (s sentVal) ackOrLoss(pnum packetNumber, fate packetFate) { if fate == packetAcked { s = sentValReceived } else if s == sentVal(pnum)\|sentValSent { s = sentValUnsent } } // ackLatestOrLoss reports that an acknowledgement has been received for the value, // or that the packet carrying the value has been lost. // The value is set to the acked state only if pnum is the latest packet containing it. // // We use this to handle acks for data that varies every time it is sent. // For example, if we send a MAX_DATA frame followed by an updated MAX_DATA value in a // second packet, we consider the data sent only upon receiving an ack for the most // recent value. func (s sentVal) ackLatestOrLoss(pnum packetNumber, fate packetFate) { if fate == packetAcked { if s == sentVal(pnum)\|sentValSent { s = sentValReceived } } else { if s == sentVal(pnum)\|sentValSent { s = sentValUnsent } } } func (s sentVal) state() uint64 { return uint64(s) & sentValStateMask }	3.81 KB	2025-05-25 12:27
📄 sent_val_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import "testing" func TestSentVal(t testing.T) { for _, test := range []struct { name string f func(sentVal) wantIsSet bool wantShouldSend bool wantIsReceived bool wantShouldSendPTO bool }{{ name: "zero value", f: func(sentVal) {}, wantIsSet: false, wantShouldSend: false, wantShouldSendPTO: false, wantIsReceived: false, }, { name: "v.set()", f: (sentVal).set, wantIsSet: true, wantShouldSend: true, wantShouldSendPTO: true, wantIsReceived: false, }, { name: "v.setSent(0)", f: func(v sentVal) { v.setSent(0) }, wantIsSet: true, wantShouldSend: false, wantShouldSendPTO: true, wantIsReceived: false, }, { name: "sent.set()", f: func(v sentVal) { v.setSent(0) v.set() }, wantIsSet: true, wantShouldSend: false, wantShouldSendPTO: true, wantIsReceived: false, }, { name: "sent.setUnsent()", f: func(v sentVal) { v.setSent(0) v.setUnsent() }, wantIsSet: true, wantShouldSend: true, wantShouldSendPTO: true, wantIsReceived: false, }, { name: "set.clear()", f: func(v sentVal) { v.set() v.clear() }, wantIsSet: false, wantShouldSend: false, wantShouldSendPTO: false, wantIsReceived: false, }, { name: "v.setReceived()", f: (sentVal).setReceived, wantIsSet: true, wantShouldSend: false, wantShouldSendPTO: false, wantIsReceived: true, }, { name: "v.ackOrLoss(!pnum, true)", f: func(v sentVal) { v.setSent(1) v.ackOrLoss(0, packetAcked) // ack different packet containing the val }, wantIsSet: true, wantShouldSend: false, wantShouldSendPTO: false, wantIsReceived: true, }, { name: "v.ackOrLoss(!pnum, packetLost)", f: func(v sentVal) { v.setSent(1) v.ackOrLoss(0, packetLost) // lose different packet containing the val }, wantIsSet: true, wantShouldSend: false, wantShouldSendPTO: true, wantIsReceived: false, }, { name: "v.ackOrLoss(pnum, packetLost)", f: func(v sentVal) { v.setSent(1) v.ackOrLoss(1, packetLost) // lose same packet containing the val }, wantIsSet: true, wantShouldSend: true, wantShouldSendPTO: true, wantIsReceived: false, }, { name: "v.ackLatestOrLoss(!pnum, packetAcked)", f: func(v sentVal) { v.setSent(1) v.ackLatestOrLoss(0, packetAcked) // ack different packet containing the val }, wantIsSet: true, wantShouldSend: false, wantShouldSendPTO: true, wantIsReceived: false, }, { name: "v.ackLatestOrLoss(pnum, packetAcked)", f: func(v sentVal) { v.setSent(1) v.ackLatestOrLoss(1, packetAcked) // ack same packet containing the val }, wantIsSet: true, wantShouldSend: false, wantShouldSendPTO: false, wantIsReceived: true, }, { name: "v.ackLatestOrLoss(!pnum, packetLost)", f: func(v sentVal) { v.setSent(1) v.ackLatestOrLoss(0, packetLost) // lose different packet containing the val }, wantIsSet: true, wantShouldSend: false, wantShouldSendPTO: true, wantIsReceived: false, }, { name: "v.ackLatestOrLoss(pnum, packetLost)", f: func(v sentVal) { v.setSent(1) v.ackLatestOrLoss(1, packetLost) // lose same packet containing the val }, wantIsSet: true, wantShouldSend: true, wantShouldSendPTO: true, wantIsReceived: false, }} { var v sentVal test.f(&v) if got, want := v.isSet(), test.wantIsSet; got != want { t.Errorf("%v: v.isSet() = %v, want %v", test.name, got, want) } if got, want := v.shouldSend(), test.wantShouldSend; got != want { t.Errorf("%v: v.shouldSend() = %v, want %v", test.name, got, want) } if got, want := v.shouldSendPTO(false), test.wantShouldSend; got != want { t.Errorf("%v: v.shouldSendPTO(false) = %v, want %v", test.name, got, want) } if got, want := v.shouldSendPTO(true), test.wantShouldSendPTO; got != want { t.Errorf("%v: v.shouldSendPTO(true) = %v, want %v", test.name, got, want) } if got, want := v.isReceived(), test.wantIsReceived; got != want { t.Errorf("%v: v.isReceived() = %v, want %v", test.name, got, want) } } }	4.42 KB	2025-05-25 12:27
📄 stateless_reset.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "crypto/hmac" "crypto/rand" "crypto/sha256" "hash" "sync" ) const statelessResetTokenLen = 128 / 8 // A statelessResetToken is a stateless reset token. // https://www.rfc-editor.org/rfc/rfc9000#section-10.3 type statelessResetToken [statelessResetTokenLen]byte type statelessResetTokenGenerator struct { canReset bool // The hash.Hash interface is not concurrency safe, // so we need a mutex here. // // There shouldn't be much contention on stateless reset token generation. // If this proves to be a problem, we could avoid the mutex by using a separate // generator per Conn, or by using a concurrency-safe generator. mu sync.Mutex mac hash.Hash } func (g statelessResetTokenGenerator) init(secret [32]byte) { zero := true for _, b := range secret { if b != 0 { zero = false break } } if zero { // Generate tokens using a random secret, but don't send stateless resets. rand.Read(secret[:]) g.canReset = false } else { g.canReset = true } g.mac = hmac.New(sha256.New, secret[:]) } func (g statelessResetTokenGenerator) tokenForConnID(cid []byte) (token statelessResetToken) { g.mu.Lock() defer g.mu.Unlock() defer g.mac.Reset() g.mac.Write(cid) copy(token[:], g.mac.Sum(nil)) return token }	1.42 KB	2025-05-25 12:27
📄 stateless_reset_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "bytes" "context" "crypto/rand" "crypto/tls" "errors" "net/netip" "testing" "time" ) func TestStatelessResetClientSendsStatelessResetTokenTransportParameter(t testing.T) { // "[The stateless_reset_token] transport parameter MUST NOT be sent by a client [...]" // https://www.rfc-editor.org/rfc/rfc9000#section-18.2-4.6.1 resetToken := testPeerStatelessResetToken(0) tc := newTestConn(t, serverSide, func(p transportParameters) { p.statelessResetToken = resetToken[:] }) tc.writeFrames(packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelInitial], }) tc.wantFrame("client provided stateless_reset_token transport parameter", packetTypeInitial, debugFrameConnectionCloseTransport{ code: errTransportParameter, }) } var testStatelessResetKey = func() (key [32]byte) { if _, err := rand.Read(key[:]); err != nil { panic(err) } return key }() func testStatelessResetToken(cid []byte) statelessResetToken { var gen statelessResetTokenGenerator gen.init(testStatelessResetKey) return gen.tokenForConnID(cid) } func testLocalStatelessResetToken(seq int64) statelessResetToken { return testStatelessResetToken(testLocalConnID(seq)) } func newDatagramForReset(cid []byte, size int, addr netip.AddrPort) datagram { dgram := append([]byte{headerFormShort \| fixedBit}, cid...) for len(dgram) < size { dgram = append(dgram, byte(len(dgram))) // semi-random junk } return &datagram{ b: dgram, peerAddr: addr, } } func TestStatelessResetSentSizes(t testing.T) { config := &Config{ TLSConfig: newTestTLSConfig(serverSide), StatelessResetKey: testStatelessResetKey, } addr := netip.MustParseAddr("127.0.0.1") te := newTestEndpoint(t, config) for i, test := range []struct { reqSize int wantSize int }{{ // Datagrams larger than 42 bytes result in a 42-byte stateless reset. // This isn't specifically mandated by RFC 9000, but is implied. // https://www.rfc-editor.org/rfc/rfc9000#section-10.3-11 reqSize: 1200, wantSize: 42, }, { // "An endpoint that sends a Stateless Reset in response to a packet // that is 43 bytes or shorter SHOULD send a Stateless Reset that is // one byte shorter than the packet it responds to." // https://www.rfc-editor.org/rfc/rfc9000#section-10.3-11 reqSize: 43, wantSize: 42, }, { reqSize: 42, wantSize: 41, }, { // We should send a stateless reset in response to the smallest possible // valid datagram the peer can send us. // The smallest packet is 1-RTT: // header byte, conn id, packet num, payload, AEAD. reqSize: 1 + connIDLen + 1 + 1 + 16, wantSize: 1 + connIDLen + 1 + 1 + 16 - 1, }, { // The smallest possible stateless reset datagram is 21 bytes. // Since our response must be smaller than the incoming datagram, // we must not respond to a 21 byte or smaller packet. reqSize: 21, wantSize: 0, }} { cid := testLocalConnID(int64(i)) token := testStatelessResetToken(cid) addrport := netip.AddrPortFrom(addr, uint16(8000+i)) te.write(newDatagramForReset(cid, test.reqSize, addrport)) got := te.read() if len(got) != test.wantSize { t.Errorf("got %v-byte response to %v-byte req, want %v", len(got), test.reqSize, test.wantSize) } if len(got) == 0 { continue } // "Endpoints MUST send Stateless Resets formatted as // a packet with a short header." // https://www.rfc-editor.org/rfc/rfc9000#section-10.3-15 if isLongHeader(got[0]) { t.Errorf("response to %v-byte request is not a short-header packet\ngot: %x", test.reqSize, got) } if !bytes.HasSuffix(got, token[:]) { t.Errorf("response to %v-byte request does not end in stateless reset token\ngot: %x\nwant suffix: %x", test.reqSize, got, token) } } } func TestStatelessResetSuccessfulNewConnectionID(t testing.T) { // "[...] Stateless Reset Token field values from [...] NEW_CONNECTION_ID frames [...]" // https://www.rfc-editor.org/rfc/rfc9000#section-10.3.1-1 qr := &qlogRecord{} tc := newTestConn(t, clientSide, qr.config) tc.handshake() tc.ignoreFrame(frameTypeAck) // Retire connection ID 0. tc.writeFrames(packetType1RTT, debugFrameNewConnectionID{ retirePriorTo: 1, seq: 2, connID: testPeerConnID(2), }) tc.wantFrame("peer requested we retire conn id 0", packetType1RTT, debugFrameRetireConnectionID{ seq: 0, }) resetToken := testPeerStatelessResetToken(1) // provided during handshake dgram := append(make([]byte, 100), resetToken[:]...) tc.endpoint.write(&datagram{ b: dgram, }) if err := tc.conn.Wait(canceledContext()); !errors.Is(err, errStatelessReset) { t.Errorf("conn.Wait() = %v, want errStatelessReset", err) } tc.wantIdle("closed connection is idle in draining") tc.advance(1 time.Second) // long enough to exit the draining state tc.wantIdle("closed connection is idle after draining") qr.wantEvents(t, jsonEvent{ "name": "connectivity:connection_closed", "data": map[string]any{ "trigger": "stateless_reset", }, }) } func TestStatelessResetSuccessfulTransportParameter(t testing.T) { // "[...] Stateless Reset Token field values from [...] // the server's transport parameters [...]" // https://www.rfc-editor.org/rfc/rfc9000#section-10.3.1-1 resetToken := testPeerStatelessResetToken(0) tc := newTestConn(t, clientSide, func(p transportParameters) { p.statelessResetToken = resetToken[:] }) tc.handshake() dgram := append(make([]byte, 100), resetToken[:]...) tc.endpoint.write(&datagram{ b: dgram, }) if err := tc.conn.Wait(canceledContext()); !errors.Is(err, errStatelessReset) { t.Errorf("conn.Wait() = %v, want errStatelessReset", err) } tc.wantIdle("closed connection is idle") } func TestStatelessResetSuccessfulPrefix(t testing.T) { for _, test := range []struct { name string prefix []byte size int }{{ name: "short header and fixed bit", prefix: []byte{ headerFormShort \| fixedBit, }, size: 100, }, { // "[...] endpoints MUST treat [long header packets] ending in a // valid stateless reset token as a Stateless Reset [...]" // https://www.rfc-editor.org/rfc/rfc9000#section-10.3-15 name: "long header no fixed bit", prefix: []byte{ headerFormLong, }, size: 100, }, { // "[...] the comparison MUST be performed when the first packet // in an incoming datagram [...] cannot be decrypted." // https://www.rfc-editor.org/rfc/rfc9000#section-10.3.1-2 name: "short header valid DCID", prefix: append([]byte{ headerFormShort \| fixedBit, }, testLocalConnID(0)...), size: 100, }, { name: "handshake valid DCID", prefix: append([]byte{ headerFormLong \| fixedBit \| longPacketTypeHandshake, }, testLocalConnID(0)...), size: 100, }, { name: "no fixed bit valid DCID", prefix: append([]byte{ 0, }, testLocalConnID(0)...), size: 100, }} { t.Run(test.name, func(t testing.T) { resetToken := testPeerStatelessResetToken(0) tc := newTestConn(t, clientSide, func(p transportParameters) { p.statelessResetToken = resetToken[:] }) tc.handshake() dgram := test.prefix for len(dgram) < test.size-len(resetToken) { dgram = append(dgram, byte(len(dgram))) // semi-random junk } dgram = append(dgram, resetToken[:]...) tc.endpoint.write(&datagram{ b: dgram, }) if err := tc.conn.Wait(canceledContext()); !errors.Is(err, errStatelessReset) { t.Errorf("conn.Wait() = %v, want errStatelessReset", err) } }) } } func TestStatelessResetRetiredConnID(t testing.T) { // "An endpoint MUST NOT check for any stateless reset tokens [...] // for connection IDs that have been retired." // https://www.rfc-editor.org/rfc/rfc9000#section-10.3.1-3 resetToken := testPeerStatelessResetToken(0) tc := newTestConn(t, clientSide, func(p *transportParameters) { p.statelessResetToken = resetToken[:] }) tc.handshake() tc.ignoreFrame(frameTypeAck) // We retire connection ID 0. tc.writeFrames(packetType1RTT, debugFrameNewConnectionID{ seq: 2, retirePriorTo: 1, connID: testPeerConnID(2), }) tc.wantFrame("peer asked for conn id 0 to be retired", packetType1RTT, debugFrameRetireConnectionID{ seq: 0, }) // Receive a stateless reset for connection ID 0. dgram := append(make([]byte, 100), resetToken[:]...) tc.endpoint.write(&datagram{ b: dgram, }) if err := tc.conn.Wait(canceledContext()); !errors.Is(err, context.Canceled) { t.Errorf("conn.Wait() = %v, want connection to be alive", err) } }	8.49 KB	2025-05-25 12:27
📄 stream.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "context" "errors" "fmt" "io" "math" ) // A Stream is an ordered byte stream. // // Streams may be bidirectional, read-only, or write-only. // Methods inappropriate for a stream's direction // (for example, [Write] to a read-only stream) // return errors. // // It is not safe to perform concurrent reads from or writes to a stream. // It is safe, however, to read and write at the same time. // // Reads and writes are buffered. // It is generally not necessary to wrap a stream in a [bufio.ReadWriter] // or otherwise apply additional buffering. // // To cancel reads or writes, use the [SetReadContext] and [SetWriteContext] methods. type Stream struct { id streamID conn Conn // Contexts used for read/write operations. // Intentionally not mutex-guarded, to allow the race detector to catch concurrent access. inctx context.Context outctx context.Context // ingate's lock guards receive-related state. // // The gate condition is set if a read from the stream will not block, // either because the stream has available data or because the read will fail. ingate gate in pipe // received data inwin int64 // last MAX_STREAM_DATA sent to the peer insendmax sentVal // set when we should send MAX_STREAM_DATA to the peer inmaxbuf int64 // maximum amount of data we will buffer insize int64 // stream final size; -1 before this is known inset rangeset[int64] // received ranges inclosed sentVal // set by CloseRead inresetcode int64 // RESET_STREAM code received from the peer; -1 if not reset // outgate's lock guards send-related state. // // The gate condition is set if a write to the stream will not block, // either because the stream has available flow control or because // the write will fail. outgate gate out pipe // buffered data to send outflushed int64 // offset of last flush call outwin int64 // maximum MAX_STREAM_DATA received from the peer outmaxsent int64 // maximum data offset we've sent to the peer outmaxbuf int64 // maximum amount of data we will buffer outunsent rangeset[int64] // ranges buffered but not yet sent (only flushed data) outacked rangeset[int64] // ranges sent and acknowledged outopened sentVal // set if we should open the stream outclosed sentVal // set by CloseWrite outblocked sentVal // set when a write to the stream is blocked by flow control outreset sentVal // set by Reset outresetcode uint64 // reset code to send in RESET_STREAM outdone chan struct{} // closed when all data sent // Unsynchronized buffers, used for lock-free fast path. inbuf []byte // received data inbufoff int // bytes of inbuf which have been consumed outbuf []byte // written data outbufoff int // bytes of outbuf which contain data to write // Atomic stream state bits. // // These bits provide a fast way to coordinate between the // send and receive sides of the stream, and the conn's loop. // // streamIn bits must be set with ingate held. // streamOut* bits must be set with outgate held. // streamConn* bits are set by the conn's loop. // streamQueue* bits must be set with streamsState.sendMu held. state atomicBits[streamState] prev, next Stream // guarded by streamsState.sendMu } type streamState uint32 const ( // streamInSendMeta is set when there are frames to send for the // inbound side of the stream. For example, MAX_STREAM_DATA. // Inbound frames are never flow-controlled. streamInSendMeta = streamState(1 << iota) // streamOutSendMeta is set when there are non-flow-controlled frames // to send for the outbound side of the stream. For example, STREAM_DATA_BLOCKED. // streamOutSendData is set when there are no non-flow-controlled outbound frames // and the stream has data to send. // // At most one of streamOutSendMeta and streamOutSendData is set at any time. streamOutSendMeta streamOutSendData // streamInDone and streamOutDone are set when the inbound or outbound // sides of the stream are finished. When both are set, the stream // can be removed from the Conn and forgotten. streamInDone streamOutDone // streamConnRemoved is set when the stream has been removed from the conn. streamConnRemoved // streamQueueMeta and streamQueueData indicate which of the streamsState // send queues the conn is currently on. streamQueueMeta streamQueueData ) type streamQueue int const ( noQueue = streamQueue(iota) metaQueue // streamsState.queueMeta dataQueue // streamsState.queueData ) // streamResetByConnClose is assigned to Stream.inresetcode to indicate that a stream // was implicitly reset when the connection closed. It's out of the range of // possible reset codes the peer can send. const streamResetByConnClose = math.MaxInt64 // wantQueue returns the send queue the stream should be on. func (s streamState) wantQueue() streamQueue { switch { case s&(streamInSendMeta\|streamOutSendMeta) != 0: return metaQueue case s&(streamInDone\|streamOutDone\|streamConnRemoved) == streamInDone\|streamOutDone: return metaQueue case s&streamOutSendData != 0: // The stream has no non-flow-controlled frames to send, // but does have data. Put it on the data queue, which is only // processed when flow control is available. return dataQueue } return noQueue } // inQueue returns the send queue the stream is currently on. func (s streamState) inQueue() streamQueue { switch { case s&streamQueueMeta != 0: return metaQueue case s&streamQueueData != 0: return dataQueue } return noQueue } // newStream returns a new stream. // // The stream's ingate and outgate are locked. // (We create the stream with locked gates so after the caller // initializes the flow control window, // unlocking outgate will set the stream writability state.) func newStream(c Conn, id streamID) Stream { s := &Stream{ conn: c, id: id, insize: -1, // -1 indicates the stream size is unknown inresetcode: -1, // -1 indicates no RESET_STREAM received ingate: newLockedGate(), outgate: newLockedGate(), inctx: context.Background(), outctx: context.Background(), } if !s.IsReadOnly() { s.outdone = make(chan struct{}) } return s } // SetReadContext sets the context used for reads from the stream. // // It is not safe to call SetReadContext concurrently. func (s Stream) SetReadContext(ctx context.Context) { s.inctx = ctx } // SetWriteContext sets the context used for writes to the stream. // The write context is also used by Close when waiting for writes to be // received by the peer. // // It is not safe to call SetWriteContext concurrently. func (s Stream) SetWriteContext(ctx context.Context) { s.outctx = ctx } // IsReadOnly reports whether the stream is read-only // (a unidirectional stream created by the peer). func (s Stream) IsReadOnly() bool { return s.id.streamType() == uniStream && s.id.initiator() != s.conn.side } // IsWriteOnly reports whether the stream is write-only // (a unidirectional stream created locally). func (s Stream) IsWriteOnly() bool { return s.id.streamType() == uniStream && s.id.initiator() == s.conn.side } // Read reads data from the stream. // // Read returns as soon as at least one byte of data is available. // // If the peer closes the stream cleanly, Read returns io.EOF after // returning all data sent by the peer. // If the peer aborts reads on the stream, Read returns // an error wrapping StreamResetCode. // // It is not safe to call Read concurrently. func (s Stream) Read(b []byte) (n int, err error) { if s.IsWriteOnly() { return 0, errors.New("read from write-only stream") } if len(s.inbuf) > s.inbufoff { // Fast path: If s.inbuf contains unread bytes, return them immediately // without taking a lock. n = copy(b, s.inbuf[s.inbufoff:]) s.inbufoff += n return n, nil } if err := s.ingate.waitAndLock(s.inctx, s.conn.testHooks); err != nil { return 0, err } if s.inbufoff > 0 { // Discard bytes consumed by the fast path above. s.in.discardBefore(s.in.start + int64(s.inbufoff)) s.inbufoff = 0 s.inbuf = nil } // bytesRead contains the number of bytes of connection-level flow control to return. // We return flow control for bytes read by this Read call, as well as bytes moved // to the fast-path read buffer (s.inbuf). var bytesRead int64 defer func() { s.inUnlock() s.conn.handleStreamBytesReadOffLoop(bytesRead) // must be done with ingate unlocked }() if s.inresetcode != -1 { return 0, fmt.Errorf("stream reset by peer: %w", StreamErrorCode(s.inresetcode)) } if s.inclosed.isSet() { return 0, errors.New("read from closed stream") } if s.insize == s.in.start { return 0, io.EOF } // Getting here indicates the stream contains data to be read. if len(s.inset) < 1 \|\| s.inset[0].start != 0 \|\| s.inset[0].end <= s.in.start { panic("BUG: inconsistent input stream state") } if size := int(s.inset[0].end - s.in.start); size < len(b) { b = b[:size] } bytesRead = int64(len(b)) start := s.in.start end := start + int64(len(b)) s.in.copy(start, b) s.in.discardBefore(end) if end == s.insize { // We have read up to the end of the stream. // No need to update stream flow control. return len(b), io.EOF } if len(s.inset) > 0 && s.inset[0].start <= s.in.start && s.inset[0].end > s.in.start { // If we have more readable bytes available, put the next chunk of data // in s.inbuf for lock-free reads. s.inbuf = s.in.peek(s.inset[0].end - s.in.start) bytesRead += int64(len(s.inbuf)) } if s.insize == -1 \|\| s.insize > s.inwin { newWindow := s.in.start + int64(len(s.inbuf)) + s.inmaxbuf addedWindow := newWindow - s.inwin if shouldUpdateFlowControl(s.inmaxbuf, addedWindow) { // Update stream flow control with a STREAM_MAX_DATA frame. s.insendmax.setUnsent() } } return len(b), nil } // ReadByte reads and returns a single byte from the stream. // // It is not safe to call ReadByte concurrently. func (s Stream) ReadByte() (byte, error) { if len(s.inbuf) > s.inbufoff { b := s.inbuf[s.inbufoff] s.inbufoff++ return b, nil } var b [1]byte n, err := s.Read(b[:]) if n > 0 { return b[0], err } return 0, err } // shouldUpdateFlowControl determines whether to send a flow control window update. // // We want to balance keeping the peer well-supplied with flow control with not sending // many small updates. func shouldUpdateFlowControl(maxWindow, addedWindow int64) bool { return addedWindow >= maxWindow/8 } // Write writes data to the stream. // // Write writes data to the stream write buffer. // Buffered data is only sent when the buffer is sufficiently full. // Call the Flush method to ensure buffered data is sent. func (s Stream) Write(b []byte) (n int, err error) { if s.IsReadOnly() { return 0, errors.New("write to read-only stream") } if len(b) > 0 && len(s.outbuf)-s.outbufoff >= len(b) { // Fast path: The data to write fits in s.outbuf. copy(s.outbuf[s.outbufoff:], b) s.outbufoff += len(b) return len(b), nil } canWrite := s.outgate.lock() s.flushFastOutputBuffer() for { // The first time through this loop, we may or may not be write blocked. // We exit the loop after writing all data, so on subsequent passes through // the loop we are always write blocked. if len(b) > 0 && !canWrite { // Our send buffer is full. Wait for the peer to ack some data. s.outUnlock() if err := s.outgate.waitAndLock(s.outctx, s.conn.testHooks); err != nil { return n, err } // Successfully returning from waitAndLockGate means we are no longer // write blocked. (Unlike traditional condition variables, gates do not // have spurious wakeups.) } if s.outreset.isSet() { s.outUnlock() return n, errors.New("write to reset stream") } if s.outclosed.isSet() { s.outUnlock() return n, errors.New("write to closed stream") } if len(b) == 0 { break } // Write limit is our send buffer limit. // This is a stream offset. lim := s.out.start + s.outmaxbuf // Amount to write is min(the full buffer, data up to the write limit). // This is a number of bytes. nn := min(int64(len(b)), lim-s.out.end) // Copy the data into the output buffer. s.out.writeAt(b[:nn], s.out.end) b = b[nn:] n += int(nn) // Possibly flush the output buffer. // We automatically flush if: // - We have enough data to consume the send window. // Sending this data may cause the peer to extend the window. // - We have buffered as much data as we're willing do. // We need to send data to clear out buffer space. // - We have enough data to fill a 1-RTT packet using the smallest // possible maximum datagram size (1200 bytes, less header byte, // connection ID, packet number, and AEAD overhead). const autoFlushSize = smallestMaxDatagramSize - 1 - connIDLen - 1 - aeadOverhead shouldFlush := s.out.end >= s.outwin \|\| // peer send window is full s.out.end >= lim \|\| // local send buffer is full (s.out.end-s.outflushed) >= autoFlushSize // enough data buffered if shouldFlush { s.flushLocked() } if s.out.end > s.outwin { // We're blocked by flow control. // Send a STREAM_DATA_BLOCKED frame to let the peer know. s.outblocked.set() } // If we have bytes left to send, we're blocked. canWrite = false } if lim := s.out.start + s.outmaxbuf - s.out.end - 1; lim > 0 { // If s.out has space allocated and available to be written into, // then reference it in s.outbuf for fast-path writes. // // It's perhaps a bit pointless to limit s.outbuf to the send buffer limit. // We've already allocated this buffer so we aren't saving any memory // by not using it. // For now, we limit it anyway to make it easier to reason about limits. // // We set the limit to one less than the send buffer limit (the -1 above) // so that a write which completely fills the buffer will overflow // s.outbuf and trigger a flush. s.outbuf = s.out.availableBuffer() if int64(len(s.outbuf)) > lim { s.outbuf = s.outbuf[:lim] } } s.outUnlock() return n, nil } // WriteBytes writes a single byte to the stream. func (s Stream) WriteByte(c byte) error { if s.outbufoff < len(s.outbuf) { s.outbuf[s.outbufoff] = c s.outbufoff++ return nil } b := [1]byte{c} _, err := s.Write(b[:]) return err } func (s Stream) flushFastOutputBuffer() { if s.outbuf == nil { return } // Commit data previously written to s.outbuf. // s.outbuf is a reference to a buffer in s.out, so we just need to record // that the output buffer has been extended. s.out.end += int64(s.outbufoff) s.outbuf = nil s.outbufoff = 0 } // Flush flushes data written to the stream. // It does not wait for the peer to acknowledge receipt of the data. // Use Close to wait for the peer's acknowledgement. func (s Stream) Flush() { s.outgate.lock() defer s.outUnlock() s.flushLocked() } func (s Stream) flushLocked() { s.flushFastOutputBuffer() s.outopened.set() if s.outflushed < s.outwin { s.outunsent.add(s.outflushed, min(s.outwin, s.out.end)) } s.outflushed = s.out.end } // Close closes the stream. // Any blocked stream operations will be unblocked and return errors. // // Close flushes any data in the stream write buffer and waits for the peer to // acknowledge receipt of the data. // If the stream has been reset, it waits for the peer to acknowledge the reset. // If the context expires before the peer receives the stream's data, // Close discards the buffer and returns the context error. func (s Stream) Close() error { s.CloseRead() if s.IsReadOnly() { return nil } s.CloseWrite() // TODO: Return code from peer's RESET_STREAM frame? if err := s.conn.waitOnDone(s.outctx, s.outdone); err != nil { return err } s.outgate.lock() defer s.outUnlock() if s.outclosed.isReceived() && s.outacked.isrange(0, s.out.end) { return nil } return errors.New("stream reset") } // CloseRead aborts reads on the stream. // Any blocked reads will be unblocked and return errors. // // CloseRead notifies the peer that the stream has been closed for reading. // It does not wait for the peer to acknowledge the closure. // Use Close to wait for the peer's acknowledgement. func (s Stream) CloseRead() { if s.IsWriteOnly() { return } s.ingate.lock() if s.inset.isrange(0, s.insize) \|\| s.inresetcode != -1 { // We've already received all data from the peer, // so there's no need to send STOP_SENDING. // This is the same as saying we sent one and they got it. s.inclosed.setReceived() } else { s.inclosed.set() } discarded := s.in.end - s.in.start s.in.discardBefore(s.in.end) s.inUnlock() s.conn.handleStreamBytesReadOffLoop(discarded) // must be done with ingate unlocked } // CloseWrite aborts writes on the stream. // Any blocked writes will be unblocked and return errors. // // CloseWrite sends any data in the stream write buffer to the peer. // It does not wait for the peer to acknowledge receipt of the data. // Use Close to wait for the peer's acknowledgement. func (s Stream) CloseWrite() { if s.IsReadOnly() { return } s.outgate.lock() defer s.outUnlock() s.outclosed.set() s.flushLocked() } // Reset aborts writes on the stream and notifies the peer // that the stream was terminated abruptly. // Any blocked writes will be unblocked and return errors. // // Reset sends the application protocol error code, which must be // less than 2^62, to the peer. // It does not wait for the peer to acknowledge receipt of the error. // Use Close to wait for the peer's acknowledgement. // // Reset does not affect reads. // Use CloseRead to abort reads on the stream. func (s Stream) Reset(code uint64) { const userClosed = true s.resetInternal(code, userClosed) } // resetInternal resets the send side of the stream. // // If userClosed is true, this is s.Reset. // If userClosed is false, this is a reaction to a STOP_SENDING frame. func (s Stream) resetInternal(code uint64, userClosed bool) { s.outgate.lock() defer s.outUnlock() if s.IsReadOnly() { return } if userClosed { // Mark that the user closed the stream. s.outclosed.set() } if s.outreset.isSet() { return } if code > maxVarint { code = maxVarint } // We could check here to see if the stream is closed and the // peer has acked all the data and the FIN, but sending an // extra RESET_STREAM in this case is harmless. s.outreset.set() s.outresetcode = code s.outbuf = nil s.outbufoff = 0 s.out.discardBefore(s.out.end) s.outunsent = rangeset[int64]{} s.outblocked.clear() } // connHasClosed indicates the stream's conn has closed. func (s Stream) connHasClosed() { // If we're in the closing state, the user closed the conn. // Otherwise, we the peer initiated the close. // This only matters for the error we're going to return from stream operations. localClose := s.conn.lifetime.state == connStateClosing s.ingate.lock() if !s.inset.isrange(0, s.insize) && s.inresetcode == -1 { if localClose { s.inclosed.set() } else { s.inresetcode = streamResetByConnClose } } s.inUnlock() s.outgate.lock() if localClose { s.outclosed.set() } s.outreset.set() s.outUnlock() } // inUnlock unlocks s.ingate. // It sets the gate condition if reads from s will not block. // If s has receive-related frames to write or if both directions // are done and the stream should be removed, it notifies the Conn. func (s Stream) inUnlock() { state := s.inUnlockNoQueue() s.conn.maybeQueueStreamForSend(s, state) } // inUnlockNoQueue is inUnlock, // but reports whether s has frames to write rather than notifying the Conn. func (s Stream) inUnlockNoQueue() streamState { nextByte := s.in.start + int64(len(s.inbuf)) canRead := s.inset.contains(nextByte) \|\| // data available to read s.insize == s.in.start+int64(len(s.inbuf)) \|\| // at EOF s.inresetcode != -1 \|\| // reset by peer s.inclosed.isSet() // closed locally defer s.ingate.unlock(canRead) var state streamState switch { case s.IsWriteOnly(): state = streamInDone case s.inresetcode != -1: // reset by peer fallthrough case s.in.start == s.insize: // all data received and read // We don't increase MAX_STREAMS until the user calls ReadClose or Close, // so the receive side is not finished until inclosed is set. if s.inclosed.isSet() { state = streamInDone } case s.insendmax.shouldSend(): // STREAM_MAX_DATA state = streamInSendMeta case s.inclosed.shouldSend(): // STOP_SENDING state = streamInSendMeta } const mask = streamInDone \| streamInSendMeta return s.state.set(state, mask) } // outUnlock unlocks s.outgate. // It sets the gate condition if writes to s will not block. // If s has send-related frames to write or if both directions // are done and the stream should be removed, it notifies the Conn. func (s Stream) outUnlock() { state := s.outUnlockNoQueue() s.conn.maybeQueueStreamForSend(s, state) } // outUnlockNoQueue is outUnlock, // but reports whether s has frames to write rather than notifying the Conn. func (s Stream) outUnlockNoQueue() streamState { isDone := s.outclosed.isReceived() && s.outacked.isrange(0, s.out.end) \|\| // all data acked s.outreset.isSet() // reset locally if isDone { select { case <-s.outdone: default: if !s.IsReadOnly() { close(s.outdone) } } } lim := s.out.start + s.outmaxbuf canWrite := lim > s.out.end \|\| // available send buffer s.outclosed.isSet() \|\| // closed locally s.outreset.isSet() // reset locally defer s.outgate.unlock(canWrite) var state streamState switch { case s.IsReadOnly(): state = streamOutDone case s.outclosed.isReceived() && s.outacked.isrange(0, s.out.end): // all data sent and acked fallthrough case s.outreset.isReceived(): // RESET_STREAM sent and acked // We don't increase MAX_STREAMS until the user calls WriteClose or Close, // so the send side is not finished until outclosed is set. if s.outclosed.isSet() { state = streamOutDone } case s.outreset.shouldSend(): // RESET_STREAM state = streamOutSendMeta case s.outreset.isSet(): // RESET_STREAM sent but not acknowledged case s.outblocked.shouldSend(): // STREAM_DATA_BLOCKED state = streamOutSendMeta case len(s.outunsent) > 0: // STREAM frame with data if s.outunsent.min() < s.outmaxsent { state = streamOutSendMeta // resent data, will not consume flow control } else { state = streamOutSendData // new data, requires flow control } case s.outclosed.shouldSend() && s.out.end == s.outmaxsent: // empty STREAM frame with FIN bit state = streamOutSendMeta case s.outopened.shouldSend(): // STREAM frame with no data state = streamOutSendMeta } const mask = streamOutDone \| streamOutSendMeta \| streamOutSendData return s.state.set(state, mask) } // handleData handles data received in a STREAM frame. func (s Stream) handleData(off int64, b []byte, fin bool) error { s.ingate.lock() defer s.inUnlock() end := off + int64(len(b)) if err := s.checkStreamBounds(end, fin); err != nil { return err } if s.inclosed.isSet() \|\| s.inresetcode != -1 { // The user read-closed the stream, or the peer reset it. // Either way, we can discard this frame. return nil } if s.insize == -1 && end > s.in.end { added := end - s.in.end if err := s.conn.handleStreamBytesReceived(added); err != nil { return err } } s.in.writeAt(b, off) s.inset.add(off, end) if fin { s.insize = end // The peer has enough flow control window to send the entire stream. s.insendmax.clear() } return nil } // handleReset handles a RESET_STREAM frame. func (s Stream) handleReset(code uint64, finalSize int64) error { s.ingate.lock() defer s.inUnlock() const fin = true if err := s.checkStreamBounds(finalSize, fin); err != nil { return err } if s.inresetcode != -1 { // The stream was already reset. return nil } if s.insize == -1 { added := finalSize - s.in.end if err := s.conn.handleStreamBytesReceived(added); err != nil { return err } } s.conn.handleStreamBytesReadOnLoop(finalSize - s.in.start) s.in.discardBefore(s.in.end) s.inresetcode = int64(code) s.insize = finalSize return nil } // checkStreamBounds validates the stream offset in a STREAM or RESET_STREAM frame. func (s Stream) checkStreamBounds(end int64, fin bool) error { if end > s.inwin { // The peer sent us data past the maximum flow control window we gave them. return localTransportError{ code: errFlowControl, reason: "stream flow control window exceeded", } } if s.insize != -1 && end > s.insize { // The peer sent us data past the final size of the stream they previously gave us. return localTransportError{ code: errFinalSize, reason: "data received past end of stream", } } if fin && s.insize != -1 && end != s.insize { // The peer changed the final size of the stream. return localTransportError{ code: errFinalSize, reason: "final size of stream changed", } } if fin && end < s.in.end { // The peer has previously sent us data past the final size. return localTransportError{ code: errFinalSize, reason: "end of stream occurs before prior data", } } return nil } // handleStopSending handles a STOP_SENDING frame. func (s Stream) handleStopSending(code uint64) error { // Peer requests that we reset this stream. // https://www.rfc-editor.org/rfc/rfc9000#section-3.5-4 const userReset = false s.resetInternal(code, userReset) return nil } // handleMaxStreamData handles an update received in a MAX_STREAM_DATA frame. func (s Stream) handleMaxStreamData(maxStreamData int64) error { s.outgate.lock() defer s.outUnlock() if maxStreamData <= s.outwin { return nil } if s.outflushed > s.outwin { s.outunsent.add(s.outwin, min(maxStreamData, s.outflushed)) } s.outwin = maxStreamData if s.out.end > s.outwin { // We've still got more data than flow control window. s.outblocked.setUnsent() } else { s.outblocked.clear() } return nil } // ackOrLoss handles the fate of stream frames other than STREAM. func (s Stream) ackOrLoss(pnum packetNumber, ftype byte, fate packetFate) { // Frames which carry new information each time they are sent // (MAX_STREAM_DATA, STREAM_DATA_BLOCKED) must only be marked // as received if the most recent packet carrying this frame is acked. // // Frames which are always the same (STOP_SENDING, RESET_STREAM) // can be marked as received if any packet carrying this frame is acked. switch ftype { case frameTypeResetStream: s.outgate.lock() s.outreset.ackOrLoss(pnum, fate) s.outUnlock() case frameTypeStopSending: s.ingate.lock() s.inclosed.ackOrLoss(pnum, fate) s.inUnlock() case frameTypeMaxStreamData: s.ingate.lock() s.insendmax.ackLatestOrLoss(pnum, fate) s.inUnlock() case frameTypeStreamDataBlocked: s.outgate.lock() s.outblocked.ackLatestOrLoss(pnum, fate) s.outUnlock() default: panic("unhandled frame type") } } // ackOrLossData handles the fate of a STREAM frame. func (s Stream) ackOrLossData(pnum packetNumber, start, end int64, fin bool, fate packetFate) { s.outgate.lock() defer s.outUnlock() s.outopened.ackOrLoss(pnum, fate) if fin { s.outclosed.ackOrLoss(pnum, fate) } if s.outreset.isSet() { // If the stream has been reset, we don't care any more. return } switch fate { case packetAcked: s.outacked.add(start, end) s.outunsent.sub(start, end) // If this ack is for data at the start of the send buffer, we can now discard it. if s.outacked.contains(s.out.start) { s.out.discardBefore(s.outacked[0].end) } case packetLost: // Mark everything lost, but not previously acked, as needing retransmission. // We do this by adding all the lost bytes to outunsent, and then // removing everything already acked. s.outunsent.add(start, end) for _, a := range s.outacked { s.outunsent.sub(a.start, a.end) } } } // appendInFramesLocked appends STOP_SENDING and MAX_STREAM_DATA frames // to the current packet. // // It returns true if no more frames need appending, // false if not everything fit in the current packet. func (s Stream) appendInFramesLocked(w packetWriter, pnum packetNumber, pto bool) bool { if s.inclosed.shouldSendPTO(pto) { // We don't currently have an API for setting the error code. // Just send zero. code := uint64(0) if !w.appendStopSendingFrame(s.id, code) { return false } s.inclosed.setSent(pnum) } // TODO: STOP_SENDING if s.insendmax.shouldSendPTO(pto) { // MAX_STREAM_DATA maxStreamData := s.in.start + s.inmaxbuf if !w.appendMaxStreamDataFrame(s.id, maxStreamData) { return false } s.inwin = maxStreamData s.insendmax.setSent(pnum) } return true } // appendOutFramesLocked appends RESET_STREAM, STREAM_DATA_BLOCKED, and STREAM frames // to the current packet. // // It returns true if no more frames need appending, // false if not everything fit in the current packet. func (s Stream) appendOutFramesLocked(w packetWriter, pnum packetNumber, pto bool) bool { if s.outreset.isSet() { // RESET_STREAM if s.outreset.shouldSendPTO(pto) { if !w.appendResetStreamFrame(s.id, s.outresetcode, min(s.outwin, s.out.end)) { return false } s.outreset.setSent(pnum) s.frameOpensStream(pnum) } return true } if s.outblocked.shouldSendPTO(pto) { // STREAM_DATA_BLOCKED if !w.appendStreamDataBlockedFrame(s.id, s.outwin) { return false } s.outblocked.setSent(pnum) s.frameOpensStream(pnum) } for { // STREAM off, size := dataToSend(min(s.out.start, s.outwin), min(s.outflushed, s.outwin), s.outunsent, s.outacked, pto) if end := off + size; end > s.outmaxsent { // This will require connection-level flow control to send. end = min(end, s.outmaxsent+s.conn.streams.outflow.avail()) end = max(end, off) size = end - off } fin := s.outclosed.isSet() && off+size == s.out.end shouldSend := size > 0 \|\| // have data to send s.outopened.shouldSendPTO(pto) \|\| // should open the stream (fin && s.outclosed.shouldSendPTO(pto)) // should close the stream if !shouldSend { return true } b, added := w.appendStreamFrame(s.id, off, int(size), fin) if !added { return false } s.out.copy(off, b) end := off + int64(len(b)) if end > s.outmaxsent { s.conn.streams.outflow.consume(end - s.outmaxsent) s.outmaxsent = end } s.outunsent.sub(off, end) s.frameOpensStream(pnum) if fin { s.outclosed.setSent(pnum) } if pto { return true } if int64(len(b)) < size { return false } } } // frameOpensStream records that we're sending a frame that will open the stream. // // If we don't have an acknowledgement from the peer for a previous frame opening the stream, // record this packet as being the latest one to open it. func (s Stream) frameOpensStream(pnum packetNumber) { if !s.outopened.isReceived() { s.outopened.setSent(pnum) } } // dataToSend returns the next range of data to send in a STREAM or CRYPTO_STREAM. func dataToSend(start, end int64, outunsent, outacked rangeset[int64], pto bool) (sendStart, size int64) { switch { case pto: // On PTO, resend unacked data that fits in the probe packet. // For simplicity, we send the range starting at s.out.start // (which is definitely unacked, or else we would have discarded it) // up to the next acked byte (if any). // // This may miss unacked data starting after that acked byte, // but avoids resending data the peer has acked. for _, r := range outacked { if r.start > start { return start, r.start - start } } return start, end - start case outunsent.numRanges() > 0: return outunsent.min(), outunsent[0].size() default: return end, 0 } }	31.32 KB	2025-05-25 12:27
📄 stream_limits.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "context" ) // Limits on the number of open streams. // Every connection has separate limits for bidirectional and unidirectional streams. // // Note that the MAX_STREAMS limit includes closed as well as open streams. // Closing a stream doesn't enable an endpoint to open a new one; // only an increase in the MAX_STREAMS limit does. // localStreamLimits are limits on the number of open streams created by us. type localStreamLimits struct { gate gate max int64 // peer-provided MAX_STREAMS opened int64 // number of streams opened by us, -1 when conn is closed } func (lim localStreamLimits) init() { lim.gate = newGate() } // open creates a new local stream, blocking until MAX_STREAMS quota is available. func (lim localStreamLimits) open(ctx context.Context, c Conn) (num int64, err error) { // TODO: Send a STREAMS_BLOCKED when blocked. if err := lim.gate.waitAndLock(ctx, c.testHooks); err != nil { return 0, err } if lim.opened < 0 { lim.gate.unlock(true) return 0, errConnClosed } num = lim.opened lim.opened++ lim.gate.unlock(lim.opened < lim.max) return num, nil } // connHasClosed indicates the connection has been closed, locally or by the peer. func (lim localStreamLimits) connHasClosed() { lim.gate.lock() lim.opened = -1 lim.gate.unlock(true) } // setMax sets the MAX_STREAMS provided by the peer. func (lim localStreamLimits) setMax(maxStreams int64) { lim.gate.lock() lim.max = max(lim.max, maxStreams) lim.gate.unlock(lim.opened < lim.max) } // remoteStreamLimits are limits on the number of open streams created by the peer. type remoteStreamLimits struct { max int64 // last MAX_STREAMS sent to the peer opened int64 // number of streams opened by the peer (including subsequently closed ones) closed int64 // number of peer streams in the "closed" state maxOpen int64 // how many streams we want to let the peer simultaneously open sendMax sentVal // set when we should send MAX_STREAMS } func (lim remoteStreamLimits) init(maxOpen int64) { lim.maxOpen = maxOpen lim.max = min(maxOpen, implicitStreamLimit) // initial limit sent in transport parameters lim.opened = 0 } // open handles the peer opening a new stream. func (lim remoteStreamLimits) open(id streamID) error { num := id.num() if num >= lim.max { return localTransportError{ code: errStreamLimit, reason: "stream limit exceeded", } } if num >= lim.opened { lim.opened = num + 1 lim.maybeUpdateMax() } return nil } // close handles the peer closing an open stream. func (lim remoteStreamLimits) close() { lim.closed++ lim.maybeUpdateMax() } // maybeUpdateMax updates the MAX_STREAMS value we will send to the peer. func (lim remoteStreamLimits) maybeUpdateMax() { newMax := min( // Max streams the peer can have open at once. lim.closed+lim.maxOpen, // Max streams the peer can open with a single frame. lim.opened+implicitStreamLimit, ) avail := lim.max - lim.opened if newMax > lim.max && (avail < 8 \|\| newMax-lim.max >= 2avail) { // If the peer has less than 8 streams, or if increasing the peer's // stream limit would double it, then send a MAX_STREAMS. lim.max = newMax lim.sendMax.setUnsent() } } // appendFrame appends a MAX_STREAMS frame to the current packet, if necessary. // // It returns true if no more frames need appending, // false if not everything fit in the current packet. func (lim remoteStreamLimits) appendFrame(w packetWriter, typ streamType, pnum packetNumber, pto bool) bool { if lim.sendMax.shouldSendPTO(pto) { if !w.appendMaxStreamsFrame(typ, lim.max) { return false } lim.sendMax.setSent(pnum) } return true }	3.77 KB	2025-05-25 12:27
📄 stream_limits_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "context" "crypto/tls" "testing" ) func TestStreamLimitNewStreamBlocked(t testing.T) { // "An endpoint that receives a frame with a stream ID exceeding the limit // it has sent MUST treat this as a connection error of type STREAM_LIMIT_ERROR [...]" // https://www.rfc-editor.org/rfc/rfc9000#section-4.6-3 testStreamTypes(t, "", func(t testing.T, styp streamType) { ctx := canceledContext() tc := newTestConn(t, clientSide, permissiveTransportParameters, func(p transportParameters) { p.initialMaxStreamsBidi = 0 p.initialMaxStreamsUni = 0 }) tc.handshake() tc.ignoreFrame(frameTypeAck) opening := runAsync(tc, func(ctx context.Context) (Stream, error) { return tc.conn.newLocalStream(ctx, styp) }) if _, err := opening.result(); err != errNotDone { t.Fatalf("new stream blocked by limit: %v, want errNotDone", err) } tc.writeFrames(packetType1RTT, debugFrameMaxStreams{ streamType: styp, max: 1, }) if _, err := opening.result(); err != nil { t.Fatalf("new stream not created after limit raised: %v", err) } if _, err := tc.conn.newLocalStream(ctx, styp); err == nil { t.Fatalf("new stream blocked by raised limit: %v, want error", err) } }) } func TestStreamLimitMaxStreamsDecreases(t testing.T) { // "MAX_STREAMS frames that do not increase the stream limit MUST be ignored." // https://www.rfc-editor.org/rfc/rfc9000#section-4.6-4 testStreamTypes(t, "", func(t testing.T, styp streamType) { ctx := canceledContext() tc := newTestConn(t, clientSide, permissiveTransportParameters, func(p transportParameters) { p.initialMaxStreamsBidi = 0 p.initialMaxStreamsUni = 0 }) tc.handshake() tc.ignoreFrame(frameTypeAck) tc.writeFrames(packetType1RTT, debugFrameMaxStreams{ streamType: styp, max: 2, }) tc.writeFrames(packetType1RTT, debugFrameMaxStreams{ streamType: styp, max: 1, }) if _, err := tc.conn.newLocalStream(ctx, styp); err != nil { t.Fatalf("open stream 1, limit 2, got error: %v", err) } if _, err := tc.conn.newLocalStream(ctx, styp); err != nil { t.Fatalf("open stream 2, limit 2, got error: %v", err) } if _, err := tc.conn.newLocalStream(ctx, styp); err == nil { t.Fatalf("open stream 3, limit 2, got error: %v", err) } }) } func TestStreamLimitViolated(t testing.T) { testStreamTypes(t, "", func(t testing.T, styp streamType) { tc := newTestConn(t, serverSide, func(c Config) { if styp == bidiStream { c.MaxBidiRemoteStreams = 10 } else { c.MaxUniRemoteStreams = 10 } }) tc.handshake() tc.ignoreFrame(frameTypeAck) tc.writeFrames(packetType1RTT, debugFrameStream{ id: newStreamID(clientSide, styp, 9), }) tc.wantIdle("stream number 9 is within the limit") tc.writeFrames(packetType1RTT, debugFrameStream{ id: newStreamID(clientSide, styp, 10), }) tc.wantFrame("stream number 10 is beyond the limit", packetType1RTT, debugFrameConnectionCloseTransport{ code: errStreamLimit, }, ) }) } func TestStreamLimitImplicitStreams(t testing.T) { testStreamTypes(t, "", func(t testing.T, styp streamType) { tc := newTestConn(t, serverSide, func(c Config) { c.MaxBidiRemoteStreams = 1 << 60 c.MaxUniRemoteStreams = 1 << 60 }) tc.handshake() tc.ignoreFrame(frameTypeAck) if got, want := tc.sentTransportParameters.initialMaxStreamsBidi, int64(implicitStreamLimit); got != want { t.Errorf("sent initial_max_streams_bidi = %v, want %v", got, want) } if got, want := tc.sentTransportParameters.initialMaxStreamsUni, int64(implicitStreamLimit); got != want { t.Errorf("sent initial_max_streams_uni = %v, want %v", got, want) } // Create stream 0. tc.writeFrames(packetType1RTT, debugFrameStream{ id: newStreamID(clientSide, styp, 0), }) tc.wantIdle("max streams not increased enough to send a new frame") // Create streams [0, implicitStreamLimit). tc.writeFrames(packetType1RTT, debugFrameStream{ id: newStreamID(clientSide, styp, implicitStreamLimit-1), }) tc.wantFrame("max streams increases to implicit stream limit", packetType1RTT, debugFrameMaxStreams{ streamType: styp, max: 2 implicitStreamLimit, }) // Create a stream past the limit. tc.writeFrames(packetType1RTT, debugFrameStream{ id: newStreamID(clientSide, styp, 2implicitStreamLimit), }) tc.wantFrame("stream is past the limit", packetType1RTT, debugFrameConnectionCloseTransport{ code: errStreamLimit, }, ) }) } func TestStreamLimitMaxStreamsTransportParameterTooLarge(t testing.T) { // "If a max_streams transport parameter [...] is received with // a value greater than 2^60 [...] the connection MUST be closed // immediately with a connection error of type TRANSPORT_PARAMETER_ERROR [...]" // https://www.rfc-editor.org/rfc/rfc9000#section-4.6-2 testStreamTypes(t, "", func(t testing.T, styp streamType) { tc := newTestConn(t, serverSide, func(p transportParameters) { if styp == bidiStream { p.initialMaxStreamsBidi = 1<<60 + 1 } else { p.initialMaxStreamsUni = 1<<60 + 1 } }) tc.writeFrames(packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelInitial], }) tc.wantFrame("max streams transport parameter is too large", packetTypeInitial, debugFrameConnectionCloseTransport{ code: errTransportParameter, }, ) }) } func TestStreamLimitMaxStreamsFrameTooLarge(t testing.T) { // "If [...] a MAX_STREAMS frame is received with a value // greater than 2^60 [...] the connection MUST be closed immediately // with a connection error [...] of type FRAME_ENCODING_ERROR [...]" // https://www.rfc-editor.org/rfc/rfc9000#section-4.6-2 testStreamTypes(t, "", func(t testing.T, styp streamType) { tc := newTestConn(t, serverSide) tc.handshake() tc.writeFrames(packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelInitial], }) tc.writeFrames(packetType1RTT, debugFrameMaxStreams{ streamType: styp, max: 1<<60 + 1, }) tc.wantFrame("MAX_STREAMS value is too large", packetType1RTT, debugFrameConnectionCloseTransport{ code: errFrameEncoding, }, ) }) } func TestStreamLimitSendUpdatesMaxStreams(t testing.T) { testStreamTypes(t, "", func(t testing.T, styp streamType) { tc := newTestConn(t, serverSide, func(c Config) { if styp == uniStream { c.MaxUniRemoteStreams = 4 c.MaxBidiRemoteStreams = 0 } else { c.MaxUniRemoteStreams = 0 c.MaxBidiRemoteStreams = 4 } }) tc.handshake() tc.ignoreFrame(frameTypeAck) var streams []Stream for i := 0; i < 4; i++ { tc.writeFrames(packetType1RTT, debugFrameStream{ id: newStreamID(clientSide, styp, int64(i)), fin: true, }) streams = append(streams, tc.acceptStream()) } streams[3].Close() if styp == bidiStream { tc.wantFrame("stream is closed", packetType1RTT, debugFrameStream{ id: streams[3].id, fin: true, data: []byte{}, }) tc.writeAckForAll() } tc.wantFrame("closing a stream when peer is at limit immediately extends the limit", packetType1RTT, debugFrameMaxStreams{ streamType: styp, max: 5, }) }) } func TestStreamLimitStopSendingDoesNotUpdateMaxStreams(t testing.T) { tc, s := newTestConnAndRemoteStream(t, serverSide, bidiStream, func(c Config) { c.MaxBidiRemoteStreams = 1 }) tc.writeFrames(packetType1RTT, debugFrameStream{ id: s.id, fin: true, }) s.CloseRead() tc.writeFrames(packetType1RTT, debugFrameStopSending{ id: s.id, }) tc.wantFrame("received STOP_SENDING, send RESET_STREAM", packetType1RTT, debugFrameResetStream{ id: s.id, }) tc.writeAckForAll() tc.wantIdle("MAX_STREAMS is not extended until the user fully closes the stream") s.CloseWrite() tc.wantFrame("user closing the stream triggers MAX_STREAMS update", packetType1RTT, debugFrameMaxStreams{ streamType: bidiStream, max: 2, }) }	8.01 KB	2025-05-25 12:27
📄 stream_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "bytes" "context" "crypto/rand" "errors" "fmt" "io" "strings" "testing" ) func TestStreamWriteBlockedByOutputBuffer(t testing.T) { testStreamTypes(t, "", func(t testing.T, styp streamType) { want := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} const writeBufferSize = 4 tc := newTestConn(t, clientSide, permissiveTransportParameters, func(c Config) { c.MaxStreamWriteBufferSize = writeBufferSize }) tc.handshake() tc.ignoreFrame(frameTypeAck) s := newLocalStream(t, tc, styp) // Non-blocking write. n, err := s.Write(want) if n != writeBufferSize \|\| err != context.Canceled { t.Fatalf("s.Write() = %v, %v; want %v, context.Canceled", n, err, writeBufferSize) } s.Flush() tc.wantFrame("first write buffer of data sent", packetType1RTT, debugFrameStream{ id: s.id, data: want[:writeBufferSize], }) off := int64(writeBufferSize) // Blocking write, which must wait for buffer space. w := runAsync(tc, func(ctx context.Context) (int, error) { s.SetWriteContext(ctx) n, err := s.Write(want[writeBufferSize:]) s.Flush() return n, err }) tc.wantIdle("write buffer is full, no more data can be sent") // The peer's ack of the STREAM frame allows progress. tc.writeAckForAll() tc.wantFrame("second write buffer of data sent", packetType1RTT, debugFrameStream{ id: s.id, off: off, data: want[off:][:writeBufferSize], }) off += writeBufferSize tc.wantIdle("write buffer is full, no more data can be sent") // The peer's ack of the second STREAM frame allows sending the remaining data. tc.writeAckForAll() tc.wantFrame("remaining data sent", packetType1RTT, debugFrameStream{ id: s.id, off: off, data: want[off:], }) if n, err := w.result(); n != len(want)-writeBufferSize \|\| err != nil { t.Fatalf("s.Write() = %v, %v; want %v, nil", len(want)-writeBufferSize, err, writeBufferSize) } }) } func TestStreamWriteBlockedByStreamFlowControl(t testing.T) { testStreamTypes(t, "", func(t testing.T, styp streamType) { ctx := canceledContext() want := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} tc := newTestConn(t, clientSide, func(p transportParameters) { p.initialMaxStreamsBidi = 100 p.initialMaxStreamsUni = 100 p.initialMaxData = 1 << 20 }) tc.handshake() tc.ignoreFrame(frameTypeAck) s, err := tc.conn.newLocalStream(ctx, styp) if err != nil { t.Fatal(err) } // Data is written to the stream output buffer, but we have no flow control. _, err = s.Write(want[:1]) if err != nil { t.Fatalf("write with available output buffer: unexpected error: %v", err) } s.Flush() tc.wantFrame("write blocked by flow control triggers a STREAM_DATA_BLOCKED frame", packetType1RTT, debugFrameStreamDataBlocked{ id: s.id, max: 0, }) // Write more data. _, err = s.Write(want[1:]) if err != nil { t.Fatalf("write with available output buffer: unexpected error: %v", err) } s.Flush() tc.wantIdle("adding more blocked data does not trigger another STREAM_DATA_BLOCKED") // Provide some flow control window. tc.writeFrames(packetType1RTT, debugFrameMaxStreamData{ id: s.id, max: 4, }) tc.wantFrame("stream window extended, but still more data to write", packetType1RTT, debugFrameStreamDataBlocked{ id: s.id, max: 4, }) tc.wantFrame("stream window extended to 4, expect blocked write to progress", packetType1RTT, debugFrameStream{ id: s.id, data: want[:4], }) // Provide more flow control window. tc.writeFrames(packetType1RTT, debugFrameMaxStreamData{ id: s.id, max: int64(len(want)), }) tc.wantFrame("stream window extended further, expect blocked write to finish", packetType1RTT, debugFrameStream{ id: s.id, off: 4, data: want[4:], }) }) } func TestStreamIgnoresMaxStreamDataReduction(t testing.T) { // "A sender MUST ignore any MAX_STREAM_DATA [...] frames that // do not increase flow control limits." // https://www.rfc-editor.org/rfc/rfc9000#section-4.1-9 testStreamTypes(t, "", func(t testing.T, styp streamType) { ctx := canceledContext() want := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} tc := newTestConn(t, clientSide, func(p transportParameters) { if styp == uniStream { p.initialMaxStreamsUni = 1 p.initialMaxStreamDataUni = 4 } else { p.initialMaxStreamsBidi = 1 p.initialMaxStreamDataBidiRemote = 4 } p.initialMaxData = 1 << 20 }) tc.handshake() tc.ignoreFrame(frameTypeAck) tc.ignoreFrame(frameTypeStreamDataBlocked) // Write [0,1). s, err := tc.conn.newLocalStream(ctx, styp) if err != nil { t.Fatal(err) } s.Write(want[:1]) s.Flush() tc.wantFrame("sent data (1 byte) fits within flow control limit", packetType1RTT, debugFrameStream{ id: s.id, off: 0, data: want[:1], }) // MAX_STREAM_DATA tries to decrease limit, and is ignored. tc.writeFrames(packetType1RTT, debugFrameMaxStreamData{ id: s.id, max: 2, }) // Write [1,4). s.Write(want[1:]) tc.wantFrame("stream limit is 4 bytes, ignoring decrease in MAX_STREAM_DATA", packetType1RTT, debugFrameStream{ id: s.id, off: 1, data: want[1:4], }) // MAX_STREAM_DATA increases limit. // Second MAX_STREAM_DATA decreases it, and is ignored. tc.writeFrames(packetType1RTT, debugFrameMaxStreamData{ id: s.id, max: 8, }) tc.writeFrames(packetType1RTT, debugFrameMaxStreamData{ id: s.id, max: 6, }) // Write [1,4). s.Write(want[4:]) tc.wantFrame("stream limit is 8 bytes, ignoring decrease in MAX_STREAM_DATA", packetType1RTT, debugFrameStream{ id: s.id, off: 4, data: want[4:8], }) }) } func TestStreamWriteBlockedByWriteBufferLimit(t testing.T) { testStreamTypes(t, "", func(t testing.T, styp streamType) { want := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} const maxWriteBuffer = 4 tc := newTestConn(t, clientSide, func(p transportParameters) { p.initialMaxStreamsBidi = 100 p.initialMaxStreamsUni = 100 p.initialMaxData = 1 << 20 p.initialMaxStreamDataBidiRemote = 1 << 20 p.initialMaxStreamDataUni = 1 << 20 }, func(c Config) { c.MaxStreamWriteBufferSize = maxWriteBuffer }) tc.handshake() tc.ignoreFrame(frameTypeAck) // Write more data than StreamWriteBufferSize. // The peer has given us plenty of flow control, // so we're just blocked by our local limit. s := newLocalStream(t, tc, styp) w := runAsync(tc, func(ctx context.Context) (int, error) { s.SetWriteContext(ctx) return s.Write(want) }) tc.wantFrame("stream write should send as much data as write buffer allows", packetType1RTT, debugFrameStream{ id: s.id, off: 0, data: want[:maxWriteBuffer], }) tc.wantIdle("no STREAM_DATA_BLOCKED, we're blocked locally not by flow control") // ACK for previously-sent data allows making more progress. tc.writeAckForAll() tc.wantFrame("ACK for previous data allows making progress", packetType1RTT, debugFrameStream{ id: s.id, off: maxWriteBuffer, data: want[maxWriteBuffer:][:maxWriteBuffer], }) // Cancel the write with data left to send. w.cancel() n, err := w.result() if n != 2maxWriteBuffer \|\| err == nil { t.Fatalf("Write() = %v, %v; want %v bytes, error", n, err, 2maxWriteBuffer) } }) } func TestStreamReceive(t testing.T) { // "Endpoints MUST be able to deliver stream data to an application as // an ordered byte stream." // https://www.rfc-editor.org/rfc/rfc9000#section-2.2-2 want := make([]byte, 5000) for i := range want { want[i] = byte(i) } type frame struct { start int64 end int64 fin bool want int wantEOF bool } for _, test := range []struct { name string frames []frame }{{ name: "linear", frames: []frame{{ start: 0, end: 1000, want: 1000, }, { start: 1000, end: 2000, want: 2000, }, { start: 2000, end: 3000, want: 3000, fin: true, wantEOF: true, }}, }, { name: "out of order", frames: []frame{{ start: 1000, end: 2000, }, { start: 2000, end: 3000, }, { start: 0, end: 1000, want: 3000, }}, }, { name: "resent", frames: []frame{{ start: 0, end: 1000, want: 1000, }, { start: 0, end: 1000, want: 1000, }, { start: 1000, end: 2000, want: 2000, }, { start: 0, end: 1000, want: 2000, }, { start: 1000, end: 2000, want: 2000, }}, }, { name: "overlapping", frames: []frame{{ start: 0, end: 1000, want: 1000, }, { start: 3000, end: 4000, want: 1000, }, { start: 2000, end: 3000, want: 1000, }, { start: 1000, end: 3000, want: 4000, }}, }, { name: "early eof", frames: []frame{{ start: 3000, end: 3000, fin: true, want: 0, }, { start: 1000, end: 2000, want: 0, }, { start: 0, end: 1000, want: 2000, }, { start: 2000, end: 3000, want: 3000, wantEOF: true, }}, }, { name: "empty eof", frames: []frame{{ start: 0, end: 1000, want: 1000, }, { start: 1000, end: 1000, fin: true, want: 1000, wantEOF: true, }}, }} { testStreamTypes(t, test.name, func(t testing.T, styp streamType) { tc := newTestConn(t, serverSide) tc.handshake() sid := newStreamID(clientSide, styp, 0) var s Stream got := make([]byte, len(want)) var total int for _, f := range test.frames { t.Logf("receive [%v,%v)", f.start, f.end) tc.writeFrames(packetType1RTT, debugFrameStream{ id: sid, off: f.start, data: want[f.start:f.end], fin: f.fin, }) if s == nil { s = tc.acceptStream() } for { n, err := s.Read(got[total:]) t.Logf("s.Read() = %v, %v", n, err) total += n if f.wantEOF && err != io.EOF { t.Fatalf("Read() error = %v; want io.EOF", err) } if !f.wantEOF && err == io.EOF { t.Fatalf("Read() error = io.EOF, want something else") } if err != nil { break } } if total != f.want { t.Fatalf("total bytes read = %v, want %v", total, f.want) } for i := 0; i < total; i++ { if got[i] != want[i] { t.Fatalf("byte %v differs: got %v, want %v", i, got[i], want[i]) } } } }) } } func TestStreamReceiveExtendsStreamWindow(t testing.T) { testStreamTypes(t, "", func(t testing.T, styp streamType) { const maxWindowSize = 20 ctx := canceledContext() tc := newTestConn(t, serverSide, func(c Config) { c.MaxStreamReadBufferSize = maxWindowSize }) tc.handshake() tc.ignoreFrame(frameTypeAck) sid := newStreamID(clientSide, styp, 0) tc.writeFrames(packetType1RTT, debugFrameStream{ id: sid, off: 0, data: make([]byte, maxWindowSize), }) s, err := tc.conn.AcceptStream(ctx) if err != nil { t.Fatalf("AcceptStream: %v", err) } tc.wantIdle("stream window is not extended before data is read") buf := make([]byte, maxWindowSize+1) if n, err := s.Read(buf); n != maxWindowSize \|\| err != nil { t.Fatalf("s.Read() = %v, %v; want %v, nil", n, err, maxWindowSize) } tc.wantFrame("stream window is extended after reading data", packetType1RTT, debugFrameMaxStreamData{ id: sid, max: maxWindowSize 2, }) tc.writeFrames(packetType1RTT, debugFrameStream{ id: sid, off: maxWindowSize, data: make([]byte, maxWindowSize), fin: true, }) if n, err := s.Read(buf); n != maxWindowSize \|\| err != io.EOF { t.Fatalf("s.Read() = %v, %v; want %v, io.EOF", n, err, maxWindowSize) } tc.wantIdle("stream window is not extended after FIN") }) } func TestStreamReceiveViolatesStreamDataLimit(t testing.T) { // "A receiver MUST close the connection with an error of type FLOW_CONTROL_ERROR if // the sender violates the advertised [...] stream data limits [...]" // https://www.rfc-editor.org/rfc/rfc9000#section-4.1-8 testStreamTypes(t, "", func(t testing.T, styp streamType) { const maxStreamData = 10 for _, test := range []struct { off int64 size int64 }{{ off: maxStreamData, size: 1, }, { off: 0, size: maxStreamData + 1, }, { off: maxStreamData - 1, size: 2, }} { tc := newTestConn(t, serverSide, func(c Config) { c.MaxStreamReadBufferSize = maxStreamData }) tc.handshake() tc.ignoreFrame(frameTypeAck) tc.writeFrames(packetType1RTT, debugFrameStream{ id: newStreamID(clientSide, styp, 0), off: test.off, data: make([]byte, test.size), }) tc.wantFrame( fmt.Sprintf("data [%v,%v) violates stream data limit and closes connection", test.off, test.off+test.size), packetType1RTT, debugFrameConnectionCloseTransport{ code: errFlowControl, }, ) } }) } func TestStreamReceiveDuplicateDataDoesNotViolateLimits(t testing.T) { testStreamTypes(t, "", func(t testing.T, styp streamType) { const maxData = 10 tc := newTestConn(t, serverSide, func(c Config) { // TODO: Add connection-level maximum data here as well. c.MaxStreamReadBufferSize = maxData }) tc.handshake() tc.ignoreFrame(frameTypeAck) for i := 0; i < 3; i++ { tc.writeFrames(packetType1RTT, debugFrameStream{ id: newStreamID(clientSide, styp, 0), off: 0, data: make([]byte, maxData), }) tc.wantIdle(fmt.Sprintf("conn sends no frames after receiving data frame %v", i)) } }) } func TestStreamReceiveEmptyEOF(t testing.T) { // A stream receives some data, we read a byte of that data // (causing the rest to be pulled into the s.inbuf buffer), // and then we receive a FIN with no additional data. testStreamTypes(t, "", func(t testing.T, styp streamType) { tc, s := newTestConnAndRemoteStream(t, serverSide, styp, permissiveTransportParameters) want := []byte{1, 2, 3} tc.writeFrames(packetType1RTT, debugFrameStream{ id: s.id, data: want, }) if got, err := s.ReadByte(); got != want[0] \|\| err != nil { t.Fatalf("s.ReadByte() = %v, %v; want %v, nil", got, err, want[0]) } tc.writeFrames(packetType1RTT, debugFrameStream{ id: s.id, off: 3, fin: true, }) if got, err := io.ReadAll(s); !bytes.Equal(got, want[1:]) \|\| err != nil { t.Fatalf("io.ReadAll(s) = {%x}, %v; want {%x}, nil", got, err, want[1:]) } }) } func finalSizeTest(t testing.T, wantErr transportError, f func(tc testConn, sid streamID) (finalSize int64), opts ...any) { testStreamTypes(t, "", func(t testing.T, styp streamType) { for _, test := range []struct { name string finalFrame func(tc testConn, sid streamID, finalSize int64) }{{ name: "FIN", finalFrame: func(tc testConn, sid streamID, finalSize int64) { tc.writeFrames(packetType1RTT, debugFrameStream{ id: sid, off: finalSize, fin: true, }) }, }, { name: "RESET_STREAM", finalFrame: func(tc testConn, sid streamID, finalSize int64) { tc.writeFrames(packetType1RTT, debugFrameResetStream{ id: sid, finalSize: finalSize, }) }, }} { t.Run(test.name, func(t testing.T) { tc := newTestConn(t, serverSide, opts...) tc.handshake() sid := newStreamID(clientSide, styp, 0) finalSize := f(tc, sid) test.finalFrame(tc, sid, finalSize) tc.wantFrame("change in final size of stream is an error", packetType1RTT, debugFrameConnectionCloseTransport{ code: wantErr, }, ) }) } }) } func TestStreamFinalSizeChangedAfterFin(t testing.T) { // "If a RESET_STREAM or STREAM frame is received indicating a change // in the final size for the stream, an endpoint SHOULD respond with // an error of type FINAL_SIZE_ERROR [...]" // https://www.rfc-editor.org/rfc/rfc9000#section-4.5-5 finalSizeTest(t, errFinalSize, func(tc testConn, sid streamID) (finalSize int64) { tc.writeFrames(packetType1RTT, debugFrameStream{ id: sid, off: 10, fin: true, }) return 9 }) } func TestStreamFinalSizeBeforePreviousData(t testing.T) { finalSizeTest(t, errFinalSize, func(tc testConn, sid streamID) (finalSize int64) { tc.writeFrames(packetType1RTT, debugFrameStream{ id: sid, off: 10, data: []byte{0}, }) return 9 }) } func TestStreamFinalSizePastMaxStreamData(t testing.T) { finalSizeTest(t, errFlowControl, func(tc testConn, sid streamID) (finalSize int64) { return 11 }, func(c Config) { c.MaxStreamReadBufferSize = 10 }) } func TestStreamDataBeyondFinalSize(t testing.T) { // "A receiver SHOULD treat receipt of data at or beyond // the final size as an error of type FINAL_SIZE_ERROR [...]" // https://www.rfc-editor.org/rfc/rfc9000#section-4.5-5 testStreamTypes(t, "", func(t testing.T, styp streamType) { tc := newTestConn(t, serverSide) tc.handshake() sid := newStreamID(clientSide, styp, 0) const write1size = 4 tc.writeFrames(packetType1RTT, debugFrameStream{ id: sid, off: 0, data: make([]byte, 16), fin: true, }) tc.writeFrames(packetType1RTT, debugFrameStream{ id: sid, off: 16, data: []byte{0}, }) tc.wantFrame("received data past final size of stream", packetType1RTT, debugFrameConnectionCloseTransport{ code: errFinalSize, }, ) }) } func TestStreamReceiveUnblocksReader(t testing.T) { testStreamTypes(t, "", func(t testing.T, styp streamType) { tc := newTestConn(t, serverSide) tc.handshake() want := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} sid := newStreamID(clientSide, styp, 0) // AcceptStream blocks until a STREAM frame is received. accept := runAsync(tc, func(ctx context.Context) (Stream, error) { return tc.conn.AcceptStream(ctx) }) const write1size = 4 tc.writeFrames(packetType1RTT, debugFrameStream{ id: sid, off: 0, data: want[:write1size], }) s, err := accept.result() if err != nil { t.Fatalf("AcceptStream() = %v", err) } // Read succeeds immediately, since we already have data. got := make([]byte, len(want)) read := runAsync(tc, func(ctx context.Context) (int, error) { return s.Read(got) }) if n, err := read.result(); n != write1size \|\| err != nil { t.Fatalf("Read = %v, %v; want %v, nil", n, err, write1size) } // Read blocks waiting for more data. read = runAsync(tc, func(ctx context.Context) (int, error) { s.SetReadContext(ctx) return s.Read(got[write1size:]) }) tc.writeFrames(packetType1RTT, debugFrameStream{ id: sid, off: write1size, data: want[write1size:], fin: true, }) if n, err := read.result(); n != len(want)-write1size \|\| err != io.EOF { t.Fatalf("Read = %v, %v; want %v, io.EOF", n, err, len(want)-write1size) } if !bytes.Equal(got, want) { t.Fatalf("read bytes %x, want %x", got, want) } }) } // testStreamSendFrameInvalidState calls the test func with a stream ID for: // // - a remote bidirectional stream that the peer has not created // - a remote unidirectional stream // // It then sends the returned frame (STREAM, STREAM_DATA_BLOCKED, etc.) // to the conn and expects a STREAM_STATE_ERROR. func testStreamSendFrameInvalidState(t testing.T, f func(sid streamID) debugFrame) { testSides(t, "stream_not_created", func(t testing.T, side connSide) { tc := newTestConn(t, side, permissiveTransportParameters) tc.handshake() tc.writeFrames(packetType1RTT, f(newStreamID(side, bidiStream, 0))) tc.wantFrame("frame for local stream which has not been created", packetType1RTT, debugFrameConnectionCloseTransport{ code: errStreamState, }) }) testSides(t, "uni_stream", func(t testing.T, side connSide) { ctx := canceledContext() tc := newTestConn(t, side, permissiveTransportParameters) tc.handshake() sid := newStreamID(side, uniStream, 0) s, err := tc.conn.NewSendOnlyStream(ctx) if err != nil { t.Fatal(err) } s.Flush() // open the stream tc.wantFrame("new stream is opened", packetType1RTT, debugFrameStream{ id: sid, data: []byte{}, }) tc.writeFrames(packetType1RTT, f(sid)) tc.wantFrame("send-oriented frame for send-only stream", packetType1RTT, debugFrameConnectionCloseTransport{ code: errStreamState, }) }) } func TestStreamResetStreamInvalidState(t testing.T) { // "An endpoint that receives a RESET_STREAM frame for a send-only // stream MUST terminate the connection with error STREAM_STATE_ERROR." // https://www.rfc-editor.org/rfc/rfc9000#section-19.4-3 testStreamSendFrameInvalidState(t, func(sid streamID) debugFrame { return debugFrameResetStream{ id: sid, code: 0, finalSize: 0, } }) } func TestStreamStreamFrameInvalidState(t testing.T) { // "An endpoint MUST terminate the connection with error STREAM_STATE_ERROR // if it receives a STREAM frame for a locally initiated stream // that has not yet been created, or for a send-only stream." // https://www.rfc-editor.org/rfc/rfc9000.html#section-19.8-3 testStreamSendFrameInvalidState(t, func(sid streamID) debugFrame { return debugFrameStream{ id: sid, } }) } func TestStreamDataBlockedInvalidState(t testing.T) { // "An endpoint MUST terminate the connection with error STREAM_STATE_ERROR // if it receives a STREAM frame for a locally initiated stream // that has not yet been created, or for a send-only stream." // https://www.rfc-editor.org/rfc/rfc9000.html#section-19.8-3 testStreamSendFrameInvalidState(t, func(sid streamID) debugFrame { return debugFrameStream{ id: sid, } }) } // testStreamReceiveFrameInvalidState calls the test func with a stream ID for: // // - a remote bidirectional stream that the peer has not created // - a local unidirectional stream // // It then sends the returned frame (MAX_STREAM_DATA, STOP_SENDING, etc.) // to the conn and expects a STREAM_STATE_ERROR. func testStreamReceiveFrameInvalidState(t testing.T, f func(sid streamID) debugFrame) { testSides(t, "stream_not_created", func(t testing.T, side connSide) { tc := newTestConn(t, side) tc.handshake() tc.writeFrames(packetType1RTT, f(newStreamID(side, bidiStream, 0))) tc.wantFrame("frame for local stream which has not been created", packetType1RTT, debugFrameConnectionCloseTransport{ code: errStreamState, }) }) testSides(t, "uni_stream", func(t testing.T, side connSide) { tc := newTestConn(t, side) tc.handshake() tc.writeFrames(packetType1RTT, f(newStreamID(side.peer(), uniStream, 0))) tc.wantFrame("receive-oriented frame for receive-only stream", packetType1RTT, debugFrameConnectionCloseTransport{ code: errStreamState, }) }) } func TestStreamStopSendingInvalidState(t testing.T) { // "Receiving a STOP_SENDING frame for a locally initiated stream // that has not yet been created MUST be treated as a connection error // of type STREAM_STATE_ERROR. An endpoint that receives a STOP_SENDING // frame for a receive-only stream MUST terminate the connection with // error STREAM_STATE_ERROR." // https://www.rfc-editor.org/rfc/rfc9000#section-19.5-2 testStreamReceiveFrameInvalidState(t, func(sid streamID) debugFrame { return debugFrameStopSending{ id: sid, } }) } func TestStreamMaxStreamDataInvalidState(t testing.T) { // "Receiving a MAX_STREAM_DATA frame for a locally initiated stream // that has not yet been created MUST be treated as a connection error // of type STREAM_STATE_ERROR. An endpoint that receives a MAX_STREAM_DATA // frame for a receive-only stream MUST terminate the connection // with error STREAM_STATE_ERROR." // https://www.rfc-editor.org/rfc/rfc9000#section-19.10-2 testStreamReceiveFrameInvalidState(t, func(sid streamID) debugFrame { return debugFrameMaxStreamData{ id: sid, max: 1000, } }) } func TestStreamOffsetTooLarge(t testing.T) { // "Receipt of a frame that exceeds [2^62-1] MUST be treated as a // connection error of type FRAME_ENCODING_ERROR or FLOW_CONTROL_ERROR." // https://www.rfc-editor.org/rfc/rfc9000.html#section-19.8-9 tc := newTestConn(t, serverSide) tc.handshake() tc.writeFrames(packetType1RTT, debugFrameStream{ id: newStreamID(clientSide, bidiStream, 0), off: 1<<62 - 1, data: []byte{0}, }) got, _ := tc.readFrame() want1 := debugFrameConnectionCloseTransport{code: errFrameEncoding} want2 := debugFrameConnectionCloseTransport{code: errFlowControl} if !frameEqual(got, want1) && !frameEqual(got, want2) { t.Fatalf("STREAM offset exceeds 2^62-1\ngot: %v\nwant: %v\n or: %v", got, want1, want2) } } func TestStreamReadFromWriteOnlyStream(t testing.T) { _, s := newTestConnAndLocalStream(t, serverSide, uniStream, permissiveTransportParameters) buf := make([]byte, 10) wantErr := "read from write-only stream" if n, err := s.Read(buf); err == nil \|\| !strings.Contains(err.Error(), wantErr) { t.Errorf("s.Read() = %v, %v; want error %q", n, err, wantErr) } } func TestStreamWriteToReadOnlyStream(t testing.T) { _, s := newTestConnAndRemoteStream(t, serverSide, uniStream) buf := make([]byte, 10) wantErr := "write to read-only stream" if n, err := s.Write(buf); err == nil \|\| !strings.Contains(err.Error(), wantErr) { t.Errorf("s.Write() = %v, %v; want error %q", n, err, wantErr) } } func TestStreamReadFromClosedStream(t testing.T) { tc, s := newTestConnAndRemoteStream(t, serverSide, bidiStream, permissiveTransportParameters) s.CloseRead() tc.wantFrame("CloseRead sends a STOP_SENDING frame", packetType1RTT, debugFrameStopSending{ id: s.id, }) wantErr := "read from closed stream" if n, err := s.Read(make([]byte, 16)); err == nil \|\| !strings.Contains(err.Error(), wantErr) { t.Errorf("s.Read() = %v, %v; want error %q", n, err, wantErr) } // Data which shows up after STOP_SENDING is discarded. tc.writeFrames(packetType1RTT, debugFrameStream{ id: s.id, data: []byte{1, 2, 3}, fin: true, }) if n, err := s.Read(make([]byte, 16)); err == nil \|\| !strings.Contains(err.Error(), wantErr) { t.Errorf("s.Read() = %v, %v; want error %q", n, err, wantErr) } } func TestStreamCloseReadWithAllDataReceived(t testing.T) { tc, s := newTestConnAndRemoteStream(t, serverSide, bidiStream, permissiveTransportParameters) tc.writeFrames(packetType1RTT, debugFrameStream{ id: s.id, data: []byte{1, 2, 3}, fin: true, }) s.CloseRead() tc.wantIdle("CloseRead in Data Recvd state doesn't need to send STOP_SENDING") // We had all the data for the stream, but CloseRead discarded it. wantErr := "read from closed stream" if n, err := s.Read(make([]byte, 16)); err == nil \|\| !strings.Contains(err.Error(), wantErr) { t.Errorf("s.Read() = %v, %v; want error %q", n, err, wantErr) } } func TestStreamWriteToClosedStream(t testing.T) { tc, s := newTestConnAndLocalStream(t, serverSide, bidiStream, permissiveTransportParameters) s.CloseWrite() tc.wantFrame("stream is opened after being closed", packetType1RTT, debugFrameStream{ id: s.id, off: 0, fin: true, data: []byte{}, }) wantErr := "write to closed stream" if n, err := s.Write([]byte{}); err == nil \|\| !strings.Contains(err.Error(), wantErr) { t.Errorf("s.Write() = %v, %v; want error %q", n, err, wantErr) } } func TestStreamResetBlockedStream(t testing.T) { tc, s := newTestConnAndLocalStream(t, serverSide, bidiStream, permissiveTransportParameters, func(c Config) { c.MaxStreamWriteBufferSize = 4 }) tc.ignoreFrame(frameTypeStreamDataBlocked) writing := runAsync(tc, func(ctx context.Context) (int, error) { s.SetWriteContext(ctx) return s.Write([]byte{0, 1, 2, 3, 4, 5, 6, 7}) }) tc.wantFrame("stream writes data until write buffer fills", packetType1RTT, debugFrameStream{ id: s.id, off: 0, data: []byte{0, 1, 2, 3}, }) s.Reset(42) tc.wantFrame("stream is reset", packetType1RTT, debugFrameResetStream{ id: s.id, code: 42, finalSize: 4, }) wantErr := "write to reset stream" if n, err := writing.result(); n != 4 \|\| !strings.Contains(err.Error(), wantErr) { t.Errorf("s.Write() interrupted by Reset: %v, %q; want 4, %q", n, err, wantErr) } tc.writeAckForAll() tc.wantIdle("buffer space is available, but stream has been reset") s.Reset(100) tc.wantIdle("resetting stream a second time has no effect") if n, err := s.Write([]byte{}); err == nil \|\| !strings.Contains(err.Error(), wantErr) { t.Errorf("s.Write() = %v, %v; want error %q", n, err, wantErr) } } func TestStreamWriteMoreThanOnePacketOfData(t testing.T) { tc, s := newTestConnAndLocalStream(t, serverSide, uniStream, func(p transportParameters) { p.initialMaxStreamsUni = 1 p.initialMaxData = 1 << 20 p.initialMaxStreamDataUni = 1 << 20 }) want := make([]byte, 4096) rand.Read(want) // doesn't need to be crypto/rand, but non-deprecated and harmless w := runAsync(tc, func(ctx context.Context) (int, error) { n, err := s.Write(want) s.Flush() return n, err }) got := make([]byte, 0, len(want)) for { f, _ := tc.readFrame() if f == nil { break } sf, ok := f.(debugFrameStream) if !ok { t.Fatalf("unexpected frame: %v", sf) } if len(got) != int(sf.off) { t.Fatalf("got frame: %v\nwant offset %v", sf, len(got)) } got = append(got, sf.data...) } if n, err := w.result(); n != len(want) \|\| err != nil { t.Fatalf("s.Write() = %v, %v; want %v, nil", n, err, len(want)) } if !bytes.Equal(got, want) { t.Fatalf("mismatch in received stream data") } } func TestStreamCloseWaitsForAcks(t testing.T) { tc, s := newTestConnAndLocalStream(t, serverSide, uniStream, permissiveTransportParameters) data := make([]byte, 100) s.Write(data) s.Flush() tc.wantFrame("conn sends data for the stream", packetType1RTT, debugFrameStream{ id: s.id, data: data, }) if err := s.Close(); err != context.Canceled { t.Fatalf("s.Close() = %v, want context.Canceled (data not acked yet)", err) } tc.wantFrame("conn sends FIN for closed stream", packetType1RTT, debugFrameStream{ id: s.id, off: int64(len(data)), fin: true, data: []byte{}, }) closing := runAsync(tc, func(ctx context.Context) (struct{}, error) { s.SetWriteContext(ctx) return struct{}{}, s.Close() }) if _, err := closing.result(); err != errNotDone { t.Fatalf("s.Close() = %v, want it to block waiting for acks", err) } tc.writeAckForAll() if _, err := closing.result(); err != nil { t.Fatalf("s.Close() = %v, want nil (all data acked)", err) } } func TestStreamCloseReadOnly(t testing.T) { tc, s := newTestConnAndRemoteStream(t, serverSide, uniStream, permissiveTransportParameters) if err := s.Close(); err != nil { t.Errorf("s.Close() = %v, want nil", err) } tc.wantFrame("closed stream sends STOP_SENDING", packetType1RTT, debugFrameStopSending{ id: s.id, }) } func TestStreamCloseUnblocked(t testing.T) { for _, test := range []struct { name string unblock func(tc testConn, s Stream) success bool }{{ name: "data received", unblock: func(tc testConn, s Stream) { tc.writeAckForAll() }, success: true, }, { name: "stop sending received", unblock: func(tc testConn, s Stream) { tc.writeFrames(packetType1RTT, debugFrameStopSending{ id: s.id, }) }, }, { name: "stream reset", unblock: func(tc testConn, s Stream) { s.Reset(0) tc.wait() // wait for test conn to process the Reset }, }} { t.Run(test.name, func(t testing.T) { tc, s := newTestConnAndLocalStream(t, serverSide, uniStream, permissiveTransportParameters) data := make([]byte, 100) s.Write(data) s.Flush() tc.wantFrame("conn sends data for the stream", packetType1RTT, debugFrameStream{ id: s.id, data: data, }) if err := s.Close(); err != context.Canceled { t.Fatalf("s.Close() = %v, want context.Canceled (data not acked yet)", err) } tc.wantFrame("conn sends FIN for closed stream", packetType1RTT, debugFrameStream{ id: s.id, off: int64(len(data)), fin: true, data: []byte{}, }) closing := runAsync(tc, func(ctx context.Context) (struct{}, error) { s.SetWriteContext(ctx) return struct{}{}, s.Close() }) if _, err := closing.result(); err != errNotDone { t.Fatalf("s.Close() = %v, want it to block waiting for acks", err) } test.unblock(tc, s) _, err := closing.result() switch { case err == errNotDone: t.Fatalf("s.Close() still blocking; want it to have returned") case err == nil && !test.success: t.Fatalf("s.Close() = nil, want error") case err != nil && test.success: t.Fatalf("s.Close() = %v, want nil (all data acked)", err) } }) } } func TestStreamCloseWriteWhenBlockedByStreamFlowControl(t testing.T) { tc, s := newTestConnAndLocalStream(t, serverSide, uniStream, permissiveTransportParameters, func(p transportParameters) { //p.initialMaxData = 0 p.initialMaxStreamDataUni = 0 }) tc.ignoreFrame(frameTypeStreamDataBlocked) if _, err := s.Write([]byte{0, 1}); err != nil { t.Fatalf("s.Write = %v", err) } s.CloseWrite() tc.wantIdle("stream write is blocked by flow control") tc.writeFrames(packetType1RTT, debugFrameMaxStreamData{ id: s.id, max: 1, }) tc.wantFrame("send data up to flow control limit", packetType1RTT, debugFrameStream{ id: s.id, data: []byte{0}, }) tc.wantIdle("stream write is again blocked by flow control") tc.writeFrames(packetType1RTT, debugFrameMaxStreamData{ id: s.id, max: 2, }) tc.wantFrame("send remaining data and FIN", packetType1RTT, debugFrameStream{ id: s.id, off: 1, data: []byte{1}, fin: true, }) } func TestStreamPeerResetsWithUnreadAndUnsentData(t testing.T) { testStreamTypes(t, "", func(t testing.T, styp streamType) { tc, s := newTestConnAndRemoteStream(t, serverSide, styp) data := []byte{0, 1, 2, 3, 4, 5, 6, 7} tc.writeFrames(packetType1RTT, debugFrameStream{ id: s.id, data: data, }) got := make([]byte, 4) if n, err := s.Read(got); n != len(got) \|\| err != nil { t.Fatalf("Read start of stream: got %v, %v; want %v, nil", n, err, len(got)) } const sentCode = 42 tc.writeFrames(packetType1RTT, debugFrameResetStream{ id: s.id, finalSize: 20, code: sentCode, }) wantErr := StreamErrorCode(sentCode) if _, err := io.ReadAll(s); !errors.Is(err, wantErr) { t.Fatalf("Read reset stream: ReadAll got error %v; want %v", err, wantErr) } }) } func TestStreamPeerResetWakesBlockedRead(t testing.T) { testStreamTypes(t, "", func(t testing.T, styp streamType) { tc, s := newTestConnAndRemoteStream(t, serverSide, styp) reader := runAsync(tc, func(ctx context.Context) (int, error) { s.SetReadContext(ctx) got := make([]byte, 4) return s.Read(got) }) const sentCode = 42 tc.writeFrames(packetType1RTT, debugFrameResetStream{ id: s.id, finalSize: 20, code: sentCode, }) wantErr := StreamErrorCode(sentCode) if n, err := reader.result(); n != 0 \|\| !errors.Is(err, wantErr) { t.Fatalf("Read reset stream: got %v, %v; want 0, %v", n, err, wantErr) } }) } func TestStreamPeerResetFollowedByData(t testing.T) { testStreamTypes(t, "", func(t testing.T, styp streamType) { tc, s := newTestConnAndRemoteStream(t, serverSide, styp) tc.writeFrames(packetType1RTT, debugFrameResetStream{ id: s.id, finalSize: 4, code: 1, }) tc.writeFrames(packetType1RTT, debugFrameStream{ id: s.id, data: []byte{0, 1, 2, 3}, }) // Another reset with a different code, for good measure. tc.writeFrames(packetType1RTT, debugFrameResetStream{ id: s.id, finalSize: 4, code: 2, }) wantErr := StreamErrorCode(1) if n, err := s.Read(make([]byte, 16)); n != 0 \|\| !errors.Is(err, wantErr) { t.Fatalf("Read from reset stream: got %v, %v; want 0, %v", n, err, wantErr) } }) } func TestStreamResetInvalidCode(t testing.T) { tc, s := newTestConnAndLocalStream(t, serverSide, uniStream, permissiveTransportParameters) s.Reset(1 << 62) tc.wantFrame("reset with invalid code sends a RESET_STREAM anyway", packetType1RTT, debugFrameResetStream{ id: s.id, // The code we send here isn't specified, // so this could really be any value. code: (1 << 62) - 1, }) } func TestStreamResetReceiveOnly(t testing.T) { tc, s := newTestConnAndRemoteStream(t, serverSide, uniStream) s.Reset(0) tc.wantIdle("resetting a receive-only stream has no effect") } func TestStreamPeerStopSendingForActiveStream(t testing.T) { // "An endpoint that receives a STOP_SENDING frame MUST send a RESET_STREAM frame if // the stream is in the "Ready" or "Send" state." // https://www.rfc-editor.org/rfc/rfc9000#section-3.5-4 testStreamTypes(t, "", func(t testing.T, styp streamType) { tc, s := newTestConnAndLocalStream(t, serverSide, styp, permissiveTransportParameters) for i := 0; i < 4; i++ { s.Write([]byte{byte(i)}) s.Flush() tc.wantFrame("write sends a STREAM frame to peer", packetType1RTT, debugFrameStream{ id: s.id, off: int64(i), data: []byte{byte(i)}, }) } tc.writeFrames(packetType1RTT, debugFrameStopSending{ id: s.id, code: 42, }) tc.wantFrame("receiving STOP_SENDING causes stream reset", packetType1RTT, debugFrameResetStream{ id: s.id, code: 42, finalSize: 4, }) if n, err := s.Write([]byte{0}); err == nil { t.Errorf("s.Write() after STOP_SENDING = %v, %v; want error", n, err) } // This ack will result in some of the previous frames being marked as lost. tc.writeAckForLatest() tc.wantIdle("lost STREAM frames for reset stream are not resent") }) } func TestStreamReceiveDataBlocked(t testing.T) { tc := newTestConn(t, serverSide, permissiveTransportParameters) tc.handshake() tc.ignoreFrame(frameTypeAck) // We don't do anything with these frames, // but should accept them if the peer sends one. tc.writeFrames(packetType1RTT, debugFrameStreamDataBlocked{ id: newStreamID(clientSide, bidiStream, 0), max: 100, }) tc.writeFrames(packetType1RTT, debugFrameDataBlocked{ max: 100, }) tc.wantIdle("no response to STREAM_DATA_BLOCKED and DATA_BLOCKED") } func TestStreamFlushExplicit(t testing.T) { testStreamTypes(t, "", func(t testing.T, styp streamType) { tc, s := newTestConnAndLocalStream(t, clientSide, styp, permissiveTransportParameters) want := []byte{0, 1, 2, 3} n, err := s.Write(want) if n != len(want) \|\| err != nil { t.Fatalf("s.Write() = %v, %v; want %v, nil", n, err, len(want)) } tc.wantIdle("unflushed data is not sent") s.Flush() tc.wantFrame("data is sent after flush", packetType1RTT, debugFrameStream{ id: s.id, data: want, }) }) } func TestStreamFlushImplicitExact(t testing.T) { testStreamTypes(t, "", func(t testing.T, styp streamType) { const writeBufferSize = 4 tc, s := newTestConnAndLocalStream(t, clientSide, styp, permissiveTransportParameters, func(c Config) { c.MaxStreamWriteBufferSize = writeBufferSize }) want := []byte{0, 1, 2, 3, 4, 5, 6} // This write doesn't quite fill the output buffer. n, err := s.Write(want[:3]) if n != 3 \|\| err != nil { t.Fatalf("s.Write() = %v, %v; want %v, nil", n, err, len(want)) } tc.wantIdle("unflushed data is not sent") // This write fills the output buffer exactly. n, err = s.Write(want[3:4]) if n != 1 \|\| err != nil { t.Fatalf("s.Write() = %v, %v; want %v, nil", n, err, len(want)) } tc.wantFrame("data is sent after write buffer fills", packetType1RTT, debugFrameStream{ id: s.id, data: want[0:4], }) }) } func TestStreamFlushImplicitLargerThanBuffer(t testing.T) { testStreamTypes(t, "", func(t testing.T, styp streamType) { const writeBufferSize = 4 tc, s := newTestConnAndLocalStream(t, clientSide, styp, permissiveTransportParameters, func(c Config) { c.MaxStreamWriteBufferSize = writeBufferSize }) want := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} w := runAsync(tc, func(ctx context.Context) (int, error) { s.SetWriteContext(ctx) n, err := s.Write(want) return n, err }) tc.wantFrame("data is sent after write buffer fills", packetType1RTT, debugFrameStream{ id: s.id, data: want[0:4], }) tc.writeAckForAll() tc.wantFrame("ack permits sending more data", packetType1RTT, debugFrameStream{ id: s.id, off: 4, data: want[4:8], }) tc.writeAckForAll() tc.wantIdle("write buffer is not full") if n, err := w.result(); n != len(want) \|\| err != nil { t.Fatalf("Write() = %v, %v; want %v, nil", n, err, len(want)) } s.Flush() tc.wantFrame("flush sends last buffer of data", packetType1RTT, debugFrameStream{ id: s.id, off: 8, data: want[8:], }) }) } type streamSide string const ( localStream = streamSide("local") remoteStream = streamSide("remote") ) func newTestConnAndStream(t testing.T, side connSide, sside streamSide, styp streamType, opts ...any) (testConn, Stream) { if sside == localStream { return newTestConnAndLocalStream(t, side, styp, opts...) } else { return newTestConnAndRemoteStream(t, side, styp, opts...) } } func newTestConnAndLocalStream(t testing.T, side connSide, styp streamType, opts ...any) (testConn, Stream) { t.Helper() tc := newTestConn(t, side, opts...) tc.handshake() tc.ignoreFrame(frameTypeAck) s := newLocalStream(t, tc, styp) s.SetReadContext(canceledContext()) s.SetWriteContext(canceledContext()) return tc, s } func newLocalStream(t testing.T, tc testConn, styp streamType) Stream { t.Helper() ctx := canceledContext() s, err := tc.conn.newLocalStream(ctx, styp) if err != nil { t.Fatalf("conn.newLocalStream(%v) = %v", styp, err) } s.SetReadContext(canceledContext()) s.SetWriteContext(canceledContext()) return s } func newTestConnAndRemoteStream(t testing.T, side connSide, styp streamType, opts ...any) (testConn, Stream) { t.Helper() tc := newTestConn(t, side, opts...) tc.handshake() tc.ignoreFrame(frameTypeAck) s := newRemoteStream(t, tc, styp) s.SetReadContext(canceledContext()) s.SetWriteContext(canceledContext()) return tc, s } func newRemoteStream(t testing.T, tc testConn, styp streamType) Stream { t.Helper() ctx := canceledContext() tc.writeFrames(packetType1RTT, debugFrameStream{ id: newStreamID(tc.conn.side.peer(), styp, 0), }) s, err := tc.conn.AcceptStream(ctx) if err != nil { t.Fatalf("conn.AcceptStream() = %v", err) } s.SetReadContext(canceledContext()) s.SetWriteContext(canceledContext()) return s } // permissiveTransportParameters may be passed as an option to newTestConn. func permissiveTransportParameters(p *transportParameters) { p.initialMaxStreamsBidi = maxStreamsLimit p.initialMaxStreamsUni = maxStreamsLimit p.initialMaxData = maxVarint p.initialMaxStreamDataBidiRemote = maxVarint p.initialMaxStreamDataBidiLocal = maxVarint p.initialMaxStreamDataUni = maxVarint } func makeTestData(n int) []byte { b := make([]byte, n) for i := 0; i < n; i++ { b[i] = byte(i) } return b }	42.14 KB	2025-05-25 12:27
📄 tls.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "context" "crypto/tls" "errors" "fmt" "net" "time" ) // startTLS starts the TLS handshake. func (c Conn) startTLS(now time.Time, initialConnID []byte, peerHostname string, params transportParameters) error { tlsConfig := c.config.TLSConfig if a, _, err := net.SplitHostPort(peerHostname); err == nil { peerHostname = a } if tlsConfig.ServerName == "" && peerHostname != "" { tlsConfig = tlsConfig.Clone() tlsConfig.ServerName = peerHostname } c.keysInitial = initialKeys(initialConnID, c.side) qconfig := &tls.QUICConfig{TLSConfig: tlsConfig} if c.side == clientSide { c.tls = tls.QUICClient(qconfig) } else { c.tls = tls.QUICServer(qconfig) } c.tls.SetTransportParameters(marshalTransportParameters(params)) // TODO: We don't need or want a context for cancelation here, // but users can use a context to plumb values through to hooks defined // in the tls.Config. Pass through a context. if err := c.tls.Start(context.TODO()); err != nil { return err } return c.handleTLSEvents(now) } func (c Conn) handleTLSEvents(now time.Time) error { for { e := c.tls.NextEvent() if c.testHooks != nil { c.testHooks.handleTLSEvent(e) } switch e.Kind { case tls.QUICNoEvent: return nil case tls.QUICSetReadSecret: if err := checkCipherSuite(e.Suite); err != nil { return err } switch e.Level { case tls.QUICEncryptionLevelHandshake: c.keysHandshake.r.init(e.Suite, e.Data) case tls.QUICEncryptionLevelApplication: c.keysAppData.r.init(e.Suite, e.Data) } case tls.QUICSetWriteSecret: if err := checkCipherSuite(e.Suite); err != nil { return err } switch e.Level { case tls.QUICEncryptionLevelHandshake: c.keysHandshake.w.init(e.Suite, e.Data) case tls.QUICEncryptionLevelApplication: c.keysAppData.w.init(e.Suite, e.Data) } case tls.QUICWriteData: var space numberSpace switch e.Level { case tls.QUICEncryptionLevelInitial: space = initialSpace case tls.QUICEncryptionLevelHandshake: space = handshakeSpace case tls.QUICEncryptionLevelApplication: space = appDataSpace default: return fmt.Errorf("quic: internal error: write handshake data at level %v", e.Level) } c.crypto[space].write(e.Data) case tls.QUICHandshakeDone: if c.side == serverSide { // "[...] the TLS handshake is considered confirmed // at the server when the handshake completes." // https://www.rfc-editor.org/rfc/rfc9001#section-4.1.2-1 c.confirmHandshake(now) } c.handshakeDone() case tls.QUICTransportParameters: params, err := unmarshalTransportParams(e.Data) if err != nil { return err } if err := c.receiveTransportParameters(params); err != nil { return err } } } } // handleCrypto processes data received in a CRYPTO frame. func (c *Conn) handleCrypto(now time.Time, space numberSpace, off int64, data []byte) error { var level tls.QUICEncryptionLevel switch space { case initialSpace: level = tls.QUICEncryptionLevelInitial case handshakeSpace: level = tls.QUICEncryptionLevelHandshake case appDataSpace: level = tls.QUICEncryptionLevelApplication default: return errors.New("quic: internal error: received CRYPTO frame in unexpected number space") } return c.crypto[space].handleCrypto(off, data, func(b []byte) error { return c.tls.HandleData(level, b) }) }	3.48 KB	2025-05-25 12:27
📄 tls_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "crypto/tls" "crypto/x509" "errors" "testing" "time" ) // handshake executes the handshake. func (tc testConn) handshake() { tc.t.Helper() if testVV { testVV = false defer func() { tc.t.Helper() testVV = true tc.t.Logf("performed connection handshake") }() } defer func(saved map[byte]bool) { tc.ignoreFrames = saved }(tc.ignoreFrames) tc.ignoreFrames = nil t := tc.t dgrams := handshakeDatagrams(tc) i := 0 for { if i == len(dgrams)-1 { if tc.conn.side == clientSide { want := tc.endpoint.now.Add(maxAckDelay - timerGranularity) if !tc.timer.Equal(want) { t.Fatalf("want timer = %v (max_ack_delay), got %v", want, tc.timer) } if got := tc.readDatagram(); got != nil { t.Fatalf("client unexpectedly sent: %v", got) } } tc.advance(maxAckDelay) } // Check that we're sending exactly the data we expect. // Any variation from the norm here should be intentional. got := tc.readDatagram() var want testDatagram if !(tc.conn.side == serverSide && i == 0) && i < len(dgrams) { want = dgrams[i] fillCryptoFrames(want, tc.cryptoDataOut) i++ } if !datagramEqual(got, want) { t.Fatalf("dgram %v:\ngot %v\n\nwant %v", i, got, want) } if i >= len(dgrams) { break } fillCryptoFrames(dgrams[i], tc.cryptoDataIn) tc.write(dgrams[i]) i++ } } func handshakeDatagrams(tc testConn) (dgrams []testDatagram) { var ( clientConnIDs [][]byte serverConnIDs [][]byte clientResetToken statelessResetToken serverResetToken statelessResetToken transientConnID []byte ) localConnIDs := [][]byte{ testLocalConnID(0), testLocalConnID(1), } peerConnIDs := [][]byte{ testPeerConnID(0), testPeerConnID(1), } localResetToken := tc.endpoint.e.resetGen.tokenForConnID(localConnIDs[1]) peerResetToken := testPeerStatelessResetToken(1) if tc.conn.side == clientSide { clientConnIDs = localConnIDs serverConnIDs = peerConnIDs clientResetToken = localResetToken serverResetToken = peerResetToken transientConnID = testLocalConnID(-1) } else { clientConnIDs = peerConnIDs serverConnIDs = localConnIDs clientResetToken = peerResetToken serverResetToken = localResetToken transientConnID = testPeerConnID(-1) } return []testDatagram{{ // Client Initial packets: []testPacket{{ ptype: packetTypeInitial, num: 0, version: quicVersion1, srcConnID: clientConnIDs[0], dstConnID: transientConnID, frames: []debugFrame{ debugFrameCrypto{}, }, }}, paddedSize: 1200, }, { // Server Initial + Handshake + 1-RTT packets: []testPacket{{ ptype: packetTypeInitial, num: 0, version: quicVersion1, srcConnID: serverConnIDs[0], dstConnID: clientConnIDs[0], frames: []debugFrame{ debugFrameAck{ ranges: []i64range[packetNumber]{{0, 1}}, }, debugFrameCrypto{}, }, }, { ptype: packetTypeHandshake, num: 0, version: quicVersion1, srcConnID: serverConnIDs[0], dstConnID: clientConnIDs[0], frames: []debugFrame{ debugFrameCrypto{}, }, }, { ptype: packetType1RTT, num: 0, dstConnID: clientConnIDs[0], frames: []debugFrame{ debugFrameNewConnectionID{ seq: 1, connID: serverConnIDs[1], token: serverResetToken, }, }, }}, paddedSize: 1200, }, { // Client Initial + Handshake + 1-RTT packets: []testPacket{{ ptype: packetTypeInitial, num: 1, version: quicVersion1, srcConnID: clientConnIDs[0], dstConnID: serverConnIDs[0], frames: []debugFrame{ debugFrameAck{ ranges: []i64range[packetNumber]{{0, 1}}, }, }, }, { ptype: packetTypeHandshake, num: 0, version: quicVersion1, srcConnID: clientConnIDs[0], dstConnID: serverConnIDs[0], frames: []debugFrame{ debugFrameAck{ ranges: []i64range[packetNumber]{{0, 1}}, }, debugFrameCrypto{}, }, }, { ptype: packetType1RTT, num: 0, dstConnID: serverConnIDs[0], frames: []debugFrame{ debugFrameAck{ ranges: []i64range[packetNumber]{{0, 1}}, }, debugFrameNewConnectionID{ seq: 1, connID: clientConnIDs[1], token: clientResetToken, }, }, }}, paddedSize: 1200, }, { // Server HANDSHAKE_DONE packets: []testPacket{{ ptype: packetType1RTT, num: 1, dstConnID: clientConnIDs[0], frames: []debugFrame{ debugFrameAck{ ranges: []i64range[packetNumber]{{0, 1}}, }, debugFrameHandshakeDone{}, }, }}, }, { // Client ack (after max_ack_delay) packets: []testPacket{{ ptype: packetType1RTT, num: 1, dstConnID: serverConnIDs[0], frames: []debugFrame{ debugFrameAck{ ackDelay: unscaledAckDelayFromDuration( maxAckDelay, ackDelayExponent), ranges: []i64range[packetNumber]{{0, 2}}, }, }, }}, }} } func fillCryptoFrames(d testDatagram, data map[tls.QUICEncryptionLevel][]byte) { for _, p := range d.packets { var level tls.QUICEncryptionLevel switch p.ptype { case packetTypeInitial: level = tls.QUICEncryptionLevelInitial case packetTypeHandshake: level = tls.QUICEncryptionLevelHandshake case packetType1RTT: level = tls.QUICEncryptionLevelApplication default: continue } for i := range p.frames { c, ok := p.frames[i].(debugFrameCrypto) if !ok { continue } c.data = data[level] data[level] = nil p.frames[i] = c } } } // uncheckedHandshake executes the handshake. // // Unlike testConn.handshake, it sends nothing unnecessary // (in particular, no NEW_CONNECTION_ID frames), // and does not validate the conn's responses. // // Useful for testing scenarios where configuration has // changed the handshake responses in some way. func (tc testConn) uncheckedHandshake() { tc.t.Helper() defer func(saved map[byte]bool) { tc.ignoreFrames = saved }(tc.ignoreFrames) tc.ignoreFrames = map[byte]bool{ frameTypeAck: true, frameTypeCrypto: true, frameTypeNewConnectionID: true, } if tc.conn.side == serverSide { tc.writeFrames(packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelInitial], }) tc.writeFrames(packetTypeHandshake, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelHandshake], }) tc.wantFrame("send HANDSHAKE_DONE after handshake completes", packetType1RTT, debugFrameHandshakeDone{}) tc.writeFrames(packetType1RTT, debugFrameAck{ ackDelay: unscaledAckDelayFromDuration( maxAckDelay, ackDelayExponent), ranges: []i64range[packetNumber]{{0, tc.lastPacket.num + 1}}, }) } else { tc.wantIdle("initial frames are ignored") tc.writeFrames(packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelInitial], }) tc.writeFrames(packetTypeHandshake, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelHandshake], }) tc.wantIdle("don't expect any frames we aren't ignoring") // Send the next two frames in separate packets, so the client sends an // ack immediately without delay. We want to consume that ack here, rather // than returning with a delayed ack waiting to be sent. tc.ignoreFrames = nil tc.writeFrames(packetType1RTT, debugFrameHandshakeDone{}) tc.writeFrames(packetType1RTT, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelApplication], }) tc.wantFrame("client ACKs server's first 1-RTT packet", packetType1RTT, debugFrameAck{ ranges: []i64range[packetNumber]{{0, 2}}, }) } tc.wantIdle("handshake is done") } func TestConnClientHandshake(t testing.T) { tc := newTestConn(t, clientSide) tc.handshake() tc.advance(1 * time.Second) tc.wantIdle("no packets should be sent by an idle conn after the handshake") } func TestConnServerHandshake(t testing.T) { tc := newTestConn(t, serverSide) tc.handshake() tc.advance(1 time.Second) tc.wantIdle("no packets should be sent by an idle conn after the handshake") } func TestConnKeysDiscardedClient(t testing.T) { tc := newTestConn(t, clientSide) tc.ignoreFrame(frameTypeAck) tc.wantFrame("client sends Initial CRYPTO frame", packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataOut[tls.QUICEncryptionLevelInitial], }) tc.writeFrames(packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelInitial], }) tc.writeFrames(packetTypeHandshake, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelHandshake], }) tc.wantFrame("client sends Handshake CRYPTO frame", packetTypeHandshake, debugFrameCrypto{ data: tc.cryptoDataOut[tls.QUICEncryptionLevelHandshake], }) tc.wantFrame("client provides an additional connection ID", packetType1RTT, debugFrameNewConnectionID{ seq: 1, connID: testLocalConnID(1), token: testLocalStatelessResetToken(1), }) // The client discards Initial keys after sending a Handshake packet. tc.writeFrames(packetTypeInitial, debugFrameConnectionCloseTransport{code: errInternal}) tc.wantIdle("client has discarded Initial keys, cannot read CONNECTION_CLOSE") // The client discards Handshake keys after receiving a HANDSHAKE_DONE frame. tc.writeFrames(packetType1RTT, debugFrameHandshakeDone{}) tc.writeFrames(packetTypeHandshake, debugFrameConnectionCloseTransport{code: errInternal}) tc.wantIdle("client has discarded Handshake keys, cannot read CONNECTION_CLOSE") tc.writeFrames(packetType1RTT, debugFrameConnectionCloseTransport{code: errInternal}) tc.conn.Abort(nil) tc.wantFrame("client closes connection after 1-RTT CONNECTION_CLOSE", packetType1RTT, debugFrameConnectionCloseTransport{ code: errNo, }) } func TestConnKeysDiscardedServer(t testing.T) { tc := newTestConn(t, serverSide) tc.ignoreFrame(frameTypeAck) tc.writeFrames(packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelInitial], }) tc.wantFrame("server sends Initial CRYPTO frame", packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataOut[tls.QUICEncryptionLevelInitial], }) tc.wantFrame("server sends Handshake CRYPTO frame", packetTypeHandshake, debugFrameCrypto{ data: tc.cryptoDataOut[tls.QUICEncryptionLevelHandshake], }) // The server discards Initial keys after receiving a Handshake packet. // The Handshake packet contains only the start of the client's CRYPTO flight here, // to avoids completing the handshake yet. tc.writeFrames(packetTypeHandshake, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelHandshake][:1], }) tc.writeFrames(packetTypeInitial, debugFrameConnectionCloseTransport{code: errInternal}) tc.wantFrame("server provides an additional connection ID", packetType1RTT, debugFrameNewConnectionID{ seq: 1, connID: testLocalConnID(1), token: testLocalStatelessResetToken(1), }) tc.wantIdle("server has discarded Initial keys, cannot read CONNECTION_CLOSE") // The server discards Handshake keys after sending a HANDSHAKE_DONE frame. tc.writeFrames(packetTypeHandshake, debugFrameCrypto{ off: 1, data: tc.cryptoDataIn[tls.QUICEncryptionLevelHandshake][1:], }) tc.wantFrame("server sends HANDSHAKE_DONE after handshake completes", packetType1RTT, debugFrameHandshakeDone{}) tc.writeFrames(packetTypeHandshake, debugFrameConnectionCloseTransport{code: errInternal}) tc.wantIdle("server has discarded Handshake keys, cannot read CONNECTION_CLOSE") tc.writeFrames(packetType1RTT, debugFrameConnectionCloseTransport{code: errInternal}) tc.conn.Abort(nil) tc.wantFrame("server closes connection after 1-RTT CONNECTION_CLOSE", packetType1RTT, debugFrameConnectionCloseTransport{ code: errNo, }) } func TestConnInvalidCryptoData(t testing.T) { tc := newTestConn(t, clientSide) tc.ignoreFrame(frameTypeAck) tc.wantFrame("client sends Initial CRYPTO frame", packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataOut[tls.QUICEncryptionLevelInitial], }) tc.writeFrames(packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelInitial], }) // Render the server's response invalid. // // The client closes the connection with CRYPTO_ERROR. // // Changing the first byte will change the TLS message type, // so we can reasonably assume that this is an unexpected_message alert (10). tc.cryptoDataIn[tls.QUICEncryptionLevelHandshake][0] ^= 0x1 tc.writeFrames(packetTypeHandshake, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelHandshake], }) tc.wantFrame("client closes connection due to TLS handshake error", packetTypeInitial, debugFrameConnectionCloseTransport{ code: errTLSBase + 10, }) } func TestConnInvalidPeerCertificate(t testing.T) { tc := newTestConn(t, clientSide, func(c tls.Config) { c.VerifyPeerCertificate = func([][]byte, [][]x509.Certificate) error { return errors.New("I will not buy this certificate. It is scratched.") } }) tc.ignoreFrame(frameTypeAck) tc.wantFrame("client sends Initial CRYPTO frame", packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataOut[tls.QUICEncryptionLevelInitial], }) tc.writeFrames(packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelInitial], }) tc.writeFrames(packetTypeHandshake, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelHandshake], }) tc.wantFrame("client closes connection due to rejecting server certificate", packetTypeInitial, debugFrameConnectionCloseTransport{ code: errTLSBase + 42, // 42: bad_certificate }) } func TestConnHandshakeDoneSentToServer(t testing.T) { tc := newTestConn(t, serverSide) tc.handshake() tc.writeFrames(packetType1RTT, debugFrameHandshakeDone{}) tc.wantFrame("server closes connection when client sends a HANDSHAKE_DONE frame", packetType1RTT, debugFrameConnectionCloseTransport{ code: errProtocolViolation, }) } func TestConnCryptoDataOutOfOrder(t testing.T) { tc := newTestConn(t, clientSide) tc.ignoreFrame(frameTypeAck) tc.wantFrame("client sends Initial CRYPTO frame", packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataOut[tls.QUICEncryptionLevelInitial], }) tc.writeFrames(packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelInitial], }) tc.wantIdle("client is idle, server Handshake flight has not arrived") tc.writeFrames(packetTypeHandshake, debugFrameCrypto{ off: 15, data: tc.cryptoDataIn[tls.QUICEncryptionLevelHandshake][15:], }) tc.wantIdle("client is idle, server Handshake flight is not complete") tc.writeFrames(packetTypeHandshake, debugFrameCrypto{ off: 1, data: tc.cryptoDataIn[tls.QUICEncryptionLevelHandshake][1:20], }) tc.wantIdle("client is idle, server Handshake flight is still not complete") tc.writeFrames(packetTypeHandshake, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelHandshake][0:1], }) tc.wantFrame("client sends Handshake CRYPTO frame", packetTypeHandshake, debugFrameCrypto{ data: tc.cryptoDataOut[tls.QUICEncryptionLevelHandshake], }) } func TestConnCryptoBufferSizeExceeded(t testing.T) { tc := newTestConn(t, clientSide) tc.ignoreFrame(frameTypeAck) tc.wantFrame("client sends Initial CRYPTO frame", packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataOut[tls.QUICEncryptionLevelInitial], }) tc.writeFrames(packetTypeInitial, debugFrameCrypto{ off: cryptoBufferSize, data: []byte{0}, }) tc.wantFrame("client closes connection after server exceeds CRYPTO buffer", packetTypeInitial, debugFrameConnectionCloseTransport{ code: errCryptoBufferExceeded, }) } func TestConnAEADLimitReached(t testing.T) { // "[...] endpoints MUST count the number of received packets that // fail authentication during the lifetime of a connection. // If the total number of received packets that fail authentication [...] // exceeds the integrity limit for the selected AEAD, // the endpoint MUST immediately close the connection [...]" // https://www.rfc-editor.org/rfc/rfc9001#section-6.6-6 tc := newTestConn(t, clientSide, func(c Config) { clear(c.StatelessResetKey[:]) }) tc.handshake() var limit int64 switch suite := tc.conn.keysAppData.r.suite; suite { case tls.TLS_AES_128_GCM_SHA256, tls.TLS_AES_256_GCM_SHA384: limit = 1 << 52 case tls.TLS_CHACHA20_POLY1305_SHA256: limit = 1 << 36 default: t.Fatalf("conn.keysAppData.r.suite = %v, unknown suite", suite) } dstConnID := tc.conn.connIDState.local[0].cid if tc.conn.connIDState.local[0].seq == -1 { // Only use the transient connection ID in Initial packets. dstConnID = tc.conn.connIDState.local[1].cid } invalid := encodeTestPacket(t, tc, &testPacket{ ptype: packetType1RTT, num: 1000, frames: []debugFrame{debugFramePing{}}, version: quicVersion1, dstConnID: dstConnID, srcConnID: tc.peerConnID, }, 0) invalid[len(invalid)-1] ^= 1 sendInvalid := func() { t.Logf("<- conn under test receives invalid datagram") tc.conn.sendMsg(&datagram{ b: invalid, }) tc.wait() } // Set the conn's auth failure count to just before the AEAD integrity limit. tc.conn.keysAppData.authFailures = limit - 1 tc.writeFrames(packetType1RTT, debugFramePing{}) tc.advanceToTimer() tc.wantFrameType("auth failures less than limit: conn ACKs packet", packetType1RTT, debugFrameAck{}) sendInvalid() tc.writeFrames(packetType1RTT, debugFramePing{}) tc.advanceToTimer() tc.wantFrameType("auth failures at limit: conn closes", packetType1RTT, debugFrameConnectionCloseTransport{ code: errAEADLimitReached, }) tc.writeFrames(packetType1RTT, debugFramePing{}) tc.advance(1 time.Second) tc.wantIdle("auth failures at limit: conn does not process additional packets") } func TestConnKeysDiscardedWithExcessCryptoData(t *testing.T) { tc := newTestConn(t, serverSide, permissiveTransportParameters) tc.ignoreFrame(frameTypeAck) tc.ignoreFrame(frameTypeNewConnectionID) tc.ignoreFrame(frameTypeCrypto) // One byte of excess CRYPTO data, separated from the valid data by a one-byte gap. tc.writeFrames(packetTypeInitial, debugFrameCrypto{ off: int64(len(tc.cryptoDataIn[tls.QUICEncryptionLevelInitial]) + 1), data: []byte{0}, }) tc.writeFrames(packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelInitial], }) // We don't drop the Initial keys and discover the excess data until the client // sends a Handshake packet. tc.writeFrames(packetTypeHandshake, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelHandshake], }) tc.wantFrame("connection closed due to excess Initial CRYPTO data", packetType1RTT, debugFrameConnectionCloseTransport{ code: errTLSBase + 10, }) }	18.55 KB	2025-05-25 12:27
📄 tlsconfig_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "crypto/tls" "strings" ) func newTestTLSConfig(side connSide) tls.Config { config := &tls.Config{ InsecureSkipVerify: true, CipherSuites: []uint16{ tls.TLS_AES_128_GCM_SHA256, tls.TLS_AES_256_GCM_SHA384, tls.TLS_CHACHA20_POLY1305_SHA256, }, MinVersion: tls.VersionTLS13, // Default key exchange mechanisms as of Go 1.23 minus X25519Kyber768Draft00, // which bloats the client hello enough to spill into a second datagram. // Tests were written with the assuption each flight in the handshake // fits in one datagram, and it's simpler to keep that property. CurvePreferences: []tls.CurveID{ tls.X25519, tls.CurveP256, tls.CurveP384, tls.CurveP521, }, } if side == serverSide { config.Certificates = []tls.Certificate{testCert} } return config } // newTestTLSConfigWithMoreDefaults returns a tls.Config for testing // which behaves more like a default, empty config. // // In particular, it uses the default curve preferences, which can increase // the size of the handshake. func newTestTLSConfigWithMoreDefaults(side connSide) *tls.Config { config := newTestTLSConfig(side) config.CipherSuites = nil config.CurvePreferences = nil return config } var testCert = func() tls.Certificate { cert, err := tls.X509KeyPair(localhostCert, localhostKey) if err != nil { panic(err) } return cert }() // localhostCert is a PEM-encoded TLS cert with SAN IPs // "127.0.0.1" and "[::1]", expiring at Jan 29 16:00:00 2084 GMT. // generated from src/crypto/tls: // go run generate_cert.go --ecdsa-curve P256 --host 127.0.0.1,::1,example.com --ca --start-date "Jan 1 00:00:00 1970" --duration=1000000h var localhostCert = []byte(`-----BEGIN CERTIFICATE----- MIIBrDCCAVKgAwIBAgIPCvPhO+Hfv+NW76kWxULUMAoGCCqGSM49BAMCMBIxEDAO BgNVBAoTB0FjbWUgQ28wIBcNNzAwMTAxMDAwMDAwWhgPMjA4NDAxMjkxNjAwMDBa MBIxEDAOBgNVBAoTB0FjbWUgQ28wWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAARh WRF8p8X9scgW7JjqAwI9nYV8jtkdhqAXG9gyEgnaFNN5Ze9l3Tp1R9yCDBMNsGms PyfMPe5Jrha/LmjgR1G9o4GIMIGFMA4GA1UdDwEB/wQEAwIChDATBgNVHSUEDDAK BggrBgEFBQcDATAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBSOJri/wLQxq6oC Y6ZImms/STbTljAuBgNVHREEJzAlggtleGFtcGxlLmNvbYcEfwAAAYcQAAAAAAAA AAAAAAAAAAAAATAKBggqhkjOPQQDAgNIADBFAiBUguxsW6TGhixBAdORmVNnkx40 HjkKwncMSDbUaeL9jQIhAJwQ8zV9JpQvYpsiDuMmqCuW35XXil3cQ6Drz82c+fvE -----END CERTIFICATE-----`) // localhostKey is the private key for localhostCert. var localhostKey = []byte(testingKey(`-----BEGIN TESTING KEY----- MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgY1B1eL/Bbwf/MDcs rnvvWhFNr1aGmJJR59PdCN9lVVqhRANCAARhWRF8p8X9scgW7JjqAwI9nYV8jtkd hqAXG9gyEgnaFNN5Ze9l3Tp1R9yCDBMNsGmsPyfMPe5Jrha/LmjgR1G9 -----END TESTING KEY-----`)) // testingKey helps keep security scanners from getting excited about a private key in this file. func testingKey(s string) string { return strings.ReplaceAll(s, "TESTING KEY", "PRIVATE KEY") }	2.97 KB	2025-05-25 12:27
📄 transport_params.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "encoding/binary" "net/netip" "time" ) // transportParameters transferred in the quic_transport_parameters TLS extension. // https://www.rfc-editor.org/rfc/rfc9000.html#section-18.2 type transportParameters struct { originalDstConnID []byte maxIdleTimeout time.Duration statelessResetToken []byte maxUDPPayloadSize int64 initialMaxData int64 initialMaxStreamDataBidiLocal int64 initialMaxStreamDataBidiRemote int64 initialMaxStreamDataUni int64 initialMaxStreamsBidi int64 initialMaxStreamsUni int64 ackDelayExponent int8 maxAckDelay time.Duration disableActiveMigration bool preferredAddrV4 netip.AddrPort preferredAddrV6 netip.AddrPort preferredAddrConnID []byte preferredAddrResetToken []byte activeConnIDLimit int64 initialSrcConnID []byte retrySrcConnID []byte } const ( defaultParamMaxUDPPayloadSize = 65527 defaultParamAckDelayExponent = 3 defaultParamMaxAckDelayMilliseconds = 25 defaultParamActiveConnIDLimit = 2 ) // defaultTransportParameters is initialized to the RFC 9000 default values. func defaultTransportParameters() transportParameters { return transportParameters{ maxUDPPayloadSize: defaultParamMaxUDPPayloadSize, ackDelayExponent: defaultParamAckDelayExponent, maxAckDelay: defaultParamMaxAckDelayMilliseconds * time.Millisecond, activeConnIDLimit: defaultParamActiveConnIDLimit, } } const ( paramOriginalDestinationConnectionID = 0x00 paramMaxIdleTimeout = 0x01 paramStatelessResetToken = 0x02 paramMaxUDPPayloadSize = 0x03 paramInitialMaxData = 0x04 paramInitialMaxStreamDataBidiLocal = 0x05 paramInitialMaxStreamDataBidiRemote = 0x06 paramInitialMaxStreamDataUni = 0x07 paramInitialMaxStreamsBidi = 0x08 paramInitialMaxStreamsUni = 0x09 paramAckDelayExponent = 0x0a paramMaxAckDelay = 0x0b paramDisableActiveMigration = 0x0c paramPreferredAddress = 0x0d paramActiveConnectionIDLimit = 0x0e paramInitialSourceConnectionID = 0x0f paramRetrySourceConnectionID = 0x10 ) func marshalTransportParameters(p transportParameters) []byte { var b []byte if v := p.originalDstConnID; v != nil { b = appendVarint(b, paramOriginalDestinationConnectionID) b = appendVarintBytes(b, v) } if v := uint64(p.maxIdleTimeout / time.Millisecond); v != 0 { b = appendVarint(b, paramMaxIdleTimeout) b = appendVarint(b, uint64(sizeVarint(v))) b = appendVarint(b, uint64(v)) } if v := p.statelessResetToken; v != nil { b = appendVarint(b, paramStatelessResetToken) b = appendVarintBytes(b, v) } if v := p.maxUDPPayloadSize; v != defaultParamMaxUDPPayloadSize { b = appendVarint(b, paramMaxUDPPayloadSize) b = appendVarint(b, uint64(sizeVarint(uint64(v)))) b = appendVarint(b, uint64(v)) } if v := p.initialMaxData; v != 0 { b = appendVarint(b, paramInitialMaxData) b = appendVarint(b, uint64(sizeVarint(uint64(v)))) b = appendVarint(b, uint64(v)) } if v := p.initialMaxStreamDataBidiLocal; v != 0 { b = appendVarint(b, paramInitialMaxStreamDataBidiLocal) b = appendVarint(b, uint64(sizeVarint(uint64(v)))) b = appendVarint(b, uint64(v)) } if v := p.initialMaxStreamDataBidiRemote; v != 0 { b = appendVarint(b, paramInitialMaxStreamDataBidiRemote) b = appendVarint(b, uint64(sizeVarint(uint64(v)))) b = appendVarint(b, uint64(v)) } if v := p.initialMaxStreamDataUni; v != 0 { b = appendVarint(b, paramInitialMaxStreamDataUni) b = appendVarint(b, uint64(sizeVarint(uint64(v)))) b = appendVarint(b, uint64(v)) } if v := p.initialMaxStreamsBidi; v != 0 { b = appendVarint(b, paramInitialMaxStreamsBidi) b = appendVarint(b, uint64(sizeVarint(uint64(v)))) b = appendVarint(b, uint64(v)) } if v := p.initialMaxStreamsUni; v != 0 { b = appendVarint(b, paramInitialMaxStreamsUni) b = appendVarint(b, uint64(sizeVarint(uint64(v)))) b = appendVarint(b, uint64(v)) } if v := p.ackDelayExponent; v != defaultParamAckDelayExponent { b = appendVarint(b, paramAckDelayExponent) b = appendVarint(b, uint64(sizeVarint(uint64(v)))) b = appendVarint(b, uint64(v)) } if v := uint64(p.maxAckDelay / time.Millisecond); v != defaultParamMaxAckDelayMilliseconds { b = appendVarint(b, paramMaxAckDelay) b = appendVarint(b, uint64(sizeVarint(v))) b = appendVarint(b, v) } if p.disableActiveMigration { b = appendVarint(b, paramDisableActiveMigration) b = append(b, 0) // 0-length value } if p.preferredAddrConnID != nil { b = append(b, paramPreferredAddress) b = appendVarint(b, uint64(4+2+16+2+1+len(p.preferredAddrConnID)+16)) b = append(b, p.preferredAddrV4.Addr().AsSlice()...) // 4 bytes b = binary.BigEndian.AppendUint16(b, p.preferredAddrV4.Port()) // 2 bytes b = append(b, p.preferredAddrV6.Addr().AsSlice()...) // 16 bytes b = binary.BigEndian.AppendUint16(b, p.preferredAddrV6.Port()) // 2 bytes b = appendUint8Bytes(b, p.preferredAddrConnID) // 1 byte + len(conn_id) b = append(b, p.preferredAddrResetToken...) // 16 bytes } if v := p.activeConnIDLimit; v != defaultParamActiveConnIDLimit { b = appendVarint(b, paramActiveConnectionIDLimit) b = appendVarint(b, uint64(sizeVarint(uint64(v)))) b = appendVarint(b, uint64(v)) } if v := p.initialSrcConnID; v != nil { b = appendVarint(b, paramInitialSourceConnectionID) b = appendVarintBytes(b, v) } if v := p.retrySrcConnID; v != nil { b = appendVarint(b, paramRetrySourceConnectionID) b = appendVarintBytes(b, v) } return b } func unmarshalTransportParams(params []byte) (transportParameters, error) { p := defaultTransportParameters() for len(params) > 0 { id, n := consumeVarint(params) if n < 0 { return p, localTransportError{code: errTransportParameter} } params = params[n:] val, n := consumeVarintBytes(params) if n < 0 { return p, localTransportError{code: errTransportParameter} } params = params[n:] n = 0 switch id { case paramOriginalDestinationConnectionID: p.originalDstConnID = val n = len(val) case paramMaxIdleTimeout: var v uint64 v, n = consumeVarint(val) // If this is unreasonably large, consider it as no timeout to avoid // time.Duration overflows. if v > 1<<32 { v = 0 } p.maxIdleTimeout = time.Duration(v) * time.Millisecond case paramStatelessResetToken: if len(val) != 16 { return p, localTransportError{code: errTransportParameter} } p.statelessResetToken = val n = 16 case paramMaxUDPPayloadSize: p.maxUDPPayloadSize, n = consumeVarintInt64(val) if p.maxUDPPayloadSize < 1200 { return p, localTransportError{code: errTransportParameter} } case paramInitialMaxData: p.initialMaxData, n = consumeVarintInt64(val) case paramInitialMaxStreamDataBidiLocal: p.initialMaxStreamDataBidiLocal, n = consumeVarintInt64(val) case paramInitialMaxStreamDataBidiRemote: p.initialMaxStreamDataBidiRemote, n = consumeVarintInt64(val) case paramInitialMaxStreamDataUni: p.initialMaxStreamDataUni, n = consumeVarintInt64(val) case paramInitialMaxStreamsBidi: p.initialMaxStreamsBidi, n = consumeVarintInt64(val) if p.initialMaxStreamsBidi > maxStreamsLimit { return p, localTransportError{code: errTransportParameter} } case paramInitialMaxStreamsUni: p.initialMaxStreamsUni, n = consumeVarintInt64(val) if p.initialMaxStreamsUni > maxStreamsLimit { return p, localTransportError{code: errTransportParameter} } case paramAckDelayExponent: var v uint64 v, n = consumeVarint(val) if v > 20 { return p, localTransportError{code: errTransportParameter} } p.ackDelayExponent = int8(v) case paramMaxAckDelay: var v uint64 v, n = consumeVarint(val) if v >= 1<<14 { return p, localTransportError{code: errTransportParameter} } p.maxAckDelay = time.Duration(v) * time.Millisecond case paramDisableActiveMigration: p.disableActiveMigration = true case paramPreferredAddress: if len(val) < 4+2+16+2+1 { return p, localTransportError{code: errTransportParameter} } p.preferredAddrV4 = netip.AddrPortFrom( netip.AddrFrom4(([4]byte)(val[:4])), binary.BigEndian.Uint16(val[4:][:2]), ) val = val[4+2:] p.preferredAddrV6 = netip.AddrPortFrom( netip.AddrFrom16(([16]byte)(val[:16])), binary.BigEndian.Uint16(val[16:][:2]), ) val = val[16+2:] var nn int p.preferredAddrConnID, nn = consumeUint8Bytes(val) if nn < 0 { return p, localTransportError{code: errTransportParameter} } val = val[nn:] if len(val) != 16 { return p, localTransportError{code: errTransportParameter} } p.preferredAddrResetToken = val val = nil case paramActiveConnectionIDLimit: p.activeConnIDLimit, n = consumeVarintInt64(val) if p.activeConnIDLimit < 2 { return p, localTransportError{code: errTransportParameter} } case paramInitialSourceConnectionID: p.initialSrcConnID = val n = len(val) case paramRetrySourceConnectionID: p.retrySrcConnID = val n = len(val) default: n = len(val) } if n != len(val) { return p, localTransportError{code: errTransportParameter} } } return p, nil }	9.46 KB	2025-05-25 12:27
📄 transport_params_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "bytes" "math" "net/netip" "reflect" "testing" "time" ) func TestTransportParametersMarshalUnmarshal(t testing.T) { for _, test := range []struct { params func(p transportParameters) enc []byte }{{ params: func(p transportParameters) { p.originalDstConnID = []byte("connid") }, enc: []byte{ 0x00, // original_destination_connection_id byte(len("connid")), 'c', 'o', 'n', 'n', 'i', 'd', }, }, { params: func(p transportParameters) { p.maxIdleTimeout = 10 * time.Millisecond }, enc: []byte{ 0x01, // max_idle_timeout 1, // length 10, // varint msecs }, }, { params: func(p transportParameters) { p.statelessResetToken = []byte("0123456789abcdef") }, enc: []byte{ 0x02, // stateless_reset_token 16, // length '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', // reset token }, }, { params: func(p transportParameters) { p.maxUDPPayloadSize = 1200 }, enc: []byte{ 0x03, // max_udp_payload_size 2, // length 0x44, 0xb0, // varint value }, }, { params: func(p transportParameters) { p.initialMaxData = 10 }, enc: []byte{ 0x04, // initial_max_data 1, // length 10, // varint value }, }, { params: func(p transportParameters) { p.initialMaxStreamDataBidiLocal = 10 }, enc: []byte{ 0x05, // initial_max_stream_data_bidi_local 1, // length 10, // varint value }, }, { params: func(p transportParameters) { p.initialMaxStreamDataBidiRemote = 10 }, enc: []byte{ 0x06, // initial_max_stream_data_bidi_remote 1, // length 10, // varint value }, }, { params: func(p transportParameters) { p.initialMaxStreamDataUni = 10 }, enc: []byte{ 0x07, // initial_max_stream_data_uni 1, // length 10, // varint value }, }, { params: func(p transportParameters) { p.initialMaxStreamsBidi = 10 }, enc: []byte{ 0x08, // initial_max_streams_bidi 1, // length 10, // varint value }, }, { params: func(p transportParameters) { p.initialMaxStreamsUni = 10 }, enc: []byte{ 0x09, // initial_max_streams_uni 1, // length 10, // varint value }, }, { params: func(p transportParameters) { p.ackDelayExponent = 4 }, enc: []byte{ 0x0a, // ack_delay_exponent 1, // length 4, // varint value }, }, { params: func(p transportParameters) { p.maxAckDelay = 10 * time.Millisecond }, enc: []byte{ 0x0b, // max_ack_delay 1, // length 10, // varint value }, }, { params: func(p transportParameters) { p.disableActiveMigration = true }, enc: []byte{ 0x0c, // disable_active_migration 0, // length }, }, { params: func(p transportParameters) { p.preferredAddrV4 = netip.MustParseAddrPort("127.0.0.1:80") p.preferredAddrV6 = netip.MustParseAddrPort("[fe80::1]:1024") p.preferredAddrConnID = []byte("connid") p.preferredAddrResetToken = []byte("0123456789abcdef") }, enc: []byte{ 0x0d, // preferred_address byte(4 + 2 + 16 + 2 + 1 + len("connid") + 16), // length 127, 0, 0, 1, // v4 address 0, 80, // v4 port 0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, // v6 address 0x04, 0x00, // v6 port, 6, // connection id length 'c', 'o', 'n', 'n', 'i', 'd', // connection id '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', // reset token }, }, { params: func(p transportParameters) { p.activeConnIDLimit = 10 }, enc: []byte{ 0x0e, // active_connection_id_limit 1, // length 10, // varint value }, }, { params: func(p transportParameters) { p.initialSrcConnID = []byte("connid") }, enc: []byte{ 0x0f, // initial_source_connection_id byte(len("connid")), 'c', 'o', 'n', 'n', 'i', 'd', }, }, { params: func(p transportParameters) { p.retrySrcConnID = []byte("connid") }, enc: []byte{ 0x10, // retry_source_connection_id byte(len("connid")), 'c', 'o', 'n', 'n', 'i', 'd', }, }} { wantParams := defaultTransportParameters() test.params(&wantParams) gotBytes := marshalTransportParameters(wantParams) if !bytes.Equal(gotBytes, test.enc) { t.Errorf("marshalTransportParameters(%#v):\n got: %x\nwant: %x", wantParams, gotBytes, test.enc) } gotParams, err := unmarshalTransportParams(test.enc) if err != nil { t.Errorf("unmarshalTransportParams(%x): unexpected error: %v", test.enc, err) } else if !reflect.DeepEqual(gotParams, wantParams) { t.Errorf("unmarshalTransportParams(%x):\n got: %#v\nwant: %#v", test.enc, gotParams, wantParams) } } } func TestTransportParametersErrors(t testing.T) { for _, test := range []struct { desc string enc []byte }{{ desc: "invalid id", enc: []byte{ 0x40, // too short }, }, { desc: "parameter too short", enc: []byte{ 0x00, // original_destination_connection_id 0x04, // length 1, 2, 3, // not enough data }, }, { desc: "extra data in parameter", enc: []byte{ 0x01, // max_idle_timeout 2, // length 10, // varint msecs 0, // extra junk }, }, { desc: "invalid varint in parameter", enc: []byte{ 0x01, // max_idle_timeout 1, // length 0x40, // incomplete varint }, }, { desc: "stateless_reset_token not 16 bytes", enc: []byte{ 0x02, // stateless_reset_token, 15, // length 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, }, }, { desc: "initial_max_streams_bidi is too large", enc: []byte{ 0x08, // initial_max_streams_bidi, 8, // length, 0xd0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, }, }, { desc: "initial_max_streams_uni is too large", enc: []byte{ 0x08, // initial_max_streams_uni, 9, // length, 0xd0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, }, }, { desc: "preferred_address is too short", enc: []byte{ 0x0d, // preferred_address byte(3), 127, 0, 0, }, }, { desc: "preferred_address reset token too short", enc: []byte{ 0x0d, // preferred_address byte(4 + 2 + 16 + 2 + 1 + len("connid") + 15), // length 127, 0, 0, 1, // v4 address 0, 80, // v4 port 0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, // v6 address 0x04, 0x00, // v6 port, 6, // connection id length 'c', 'o', 'n', 'n', 'i', 'd', // connection id '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', // reset token, one byte too short }, }, { desc: "preferred_address conn id too long", enc: []byte{ 0x0d, // preferred_address byte(4 + 2 + 16 + 2 + 1 + len("connid") + 16), // length 127, 0, 0, 1, // v4 address 0, 80, // v4 port 0xfe, 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, // v6 address 0x04, 0x00, // v6 port, byte(len("connid")) + 16 + 1, // connection id length, too long 'c', 'o', 'n', 'n', 'i', 'd', // connection id '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', // reset token }, }} { _, err := unmarshalTransportParams(test.enc) if err == nil { t.Errorf("%v:\nunmarshalTransportParams(%x): unexpectedly succeeded", test.desc, test.enc) } } } func TestTransportParametersRangeErrors(t testing.T) { for _, test := range []struct { desc string params func(p transportParameters) }{{ desc: "max_udp_payload_size < 1200", params: func(p transportParameters) { p.maxUDPPayloadSize = 1199 }, }, { desc: "ack_delay_exponent > 20", params: func(p transportParameters) { p.ackDelayExponent = 21 }, }, { desc: "max_ack_delay > 1^14 ms", params: func(p transportParameters) { p.maxAckDelay = (1 << 14) time.Millisecond }, }, { desc: "active_connection_id_limit < 2", params: func(p transportParameters) { p.activeConnIDLimit = 1 }, }} { p := defaultTransportParameters() test.params(&p) enc := marshalTransportParameters(p) _, err := unmarshalTransportParams(enc) if err == nil { t.Errorf("%v: unmarshalTransportParams unexpectedly succeeded", test.desc) } } } func TestTransportParameterMaxIdleTimeoutOverflowsDuration(t testing.T) { tooManyMS := 1 + (math.MaxInt64 / uint64(time.Millisecond)) var enc []byte enc = appendVarint(enc, paramMaxIdleTimeout) enc = appendVarint(enc, uint64(sizeVarint(tooManyMS))) enc = appendVarint(enc, uint64(tooManyMS)) dec, err := unmarshalTransportParams(enc) if err != nil { t.Fatalf("unmarshalTransportParameters(enc) = %v", err) } if got, want := dec.maxIdleTimeout, time.Duration(0); got != want { t.Errorf("max_idle_timeout=%v, got maxIdleTimeout=%v; want %v", tooManyMS, got, want) } } func TestTransportParametersSkipUnknownParameters(t testing.T) { enc := []byte{ 0x20, // unknown transport parameter 1, // length 0, // varint value 0x04, // initial_max_data 1, // length 10, // varint value 0x21, // unknown transport parameter 1, // length 0, // varint value } dec, err := unmarshalTransportParams(enc) if err != nil { t.Fatalf("unmarshalTransportParameters(enc) = %v", err) } if got, want := dec.initialMaxData, int64(10); got != want { t.Errorf("got initial_max_data=%v; want %v", got, want) } } func FuzzTransportParametersMarshalUnmarshal(f testing.F) { f.Fuzz(func(t *testing.T, in []byte) { p1, err := unmarshalTransportParams(in) if err != nil { return } out := marshalTransportParameters(p1) p2, err := unmarshalTransportParams(out) if err != nil { t.Fatalf("round trip unmarshal/remarshal: unmarshal error: %v\n%x", err, in) } if !reflect.DeepEqual(p1, p2) { t.Fatalf("round trip unmarshal/remarshal: parameters differ:\n%x\n%#v\n%#v", in, p1, p2) } }) }	9.75 KB	2025-05-25 12:27
📄 udp.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import "net/netip" // Per-plaform consts describing support for various features. // // const udpECNSupport indicates whether the platform supports setting // the ECN (Explicit Congestion Notification) IP header bits. // // const udpInvalidLocalAddrIsError indicates whether sending a packet // from an local address not associated with the system is an error. // For example, assuming 127.0.0.2 is not a local address, does sending // from it (using IP_PKTINFO or some other such feature) result in an error? // unmapAddrPort returns a with any IPv4-mapped IPv6 address prefix removed. func unmapAddrPort(a netip.AddrPort) netip.AddrPort { if a.Addr().Is4In6() { return netip.AddrPortFrom( a.Addr().Unmap(), a.Port(), ) } return a }	942 B	2025-05-25 12:27
📄 udp_darwin.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 && darwin package quic import ( "encoding/binary" "golang.org/x/sys/unix" ) // See udp.go. const ( udpECNSupport = true udpInvalidLocalAddrIsError = true ) // Confusingly, on Darwin the contents of the IP_TOS option differ depending on whether // it is used as an inbound or outbound cmsg. func parseIPTOS(b []byte) (ecnBits, bool) { // Single byte. The low two bits are the ECN field. if len(b) != 1 { return 0, false } return ecnBits(b[0] & ecnMask), true } func appendCmsgECNv4(b []byte, ecn ecnBits) []byte { // 32-bit integer. // https://github.com/apple/darwin-xnu/blob/2ff845c2e033bd0ff64b5b6aa6063a1f8f65aa32/bsd/netinet/in_tclass.c#L1062-L1073 b, data := appendCmsg(b, unix.IPPROTO_IP, unix.IP_TOS, 4) binary.NativeEndian.PutUint32(data, uint32(ecn)) return b }	984 B	2025-05-25 12:27
📄 udp_linux.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 && linux package quic import ( "golang.org/x/sys/unix" ) // See udp.go. const ( udpECNSupport = true udpInvalidLocalAddrIsError = false ) // The IP_TOS socket option is a single byte containing the IP TOS field. // The low two bits are the ECN field. func parseIPTOS(b []byte) (ecnBits, bool) { if len(b) != 1 { return 0, false } return ecnBits(b[0] & ecnMask), true } func appendCmsgECNv4(b []byte, ecn ecnBits) []byte { b, data := appendCmsg(b, unix.IPPROTO_IP, unix.IP_TOS, 1) data[0] = byte(ecn) return b }	719 B	2025-05-25 12:27
📄 udp_msg.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 && !quicbasicnet && (darwin \|\| linux) package quic import ( "encoding/binary" "net" "net/netip" "sync" "unsafe" "golang.org/x/sys/unix" ) // Network interface for platforms using sendmsg/recvmsg with cmsgs. type netUDPConn struct { c net.UDPConn localAddr netip.AddrPort } func newNetUDPConn(uc net.UDPConn) (netUDPConn, error) { a, _ := uc.LocalAddr().(net.UDPAddr) localAddr := a.AddrPort() if localAddr.Addr().IsUnspecified() { // If the conn is not bound to a specified (non-wildcard) address, // then set localAddr.Addr to an invalid netip.Addr. // This better conveys that this is not an address we should be using, // and is a bit more efficient to test against. localAddr = netip.AddrPortFrom(netip.Addr{}, localAddr.Port()) } sc, err := uc.SyscallConn() if err != nil { return nil, err } sc.Control(func(fd uintptr) { // Ask for ECN info and (when we aren't bound to a fixed local address) // destination info. // // If any of these calls fail, we won't get the requested information. // That's fine, we'll gracefully handle the lack. unix.SetsockoptInt(int(fd), unix.IPPROTO_IP, unix.IP_RECVTOS, 1) unix.SetsockoptInt(int(fd), unix.IPPROTO_IPV6, unix.IPV6_RECVTCLASS, 1) if !localAddr.IsValid() { unix.SetsockoptInt(int(fd), unix.IPPROTO_IP, unix.IP_PKTINFO, 1) unix.SetsockoptInt(int(fd), unix.IPPROTO_IPV6, unix.IPV6_RECVPKTINFO, 1) } }) return &netUDPConn{ c: uc, localAddr: localAddr, }, nil } func (c netUDPConn) Close() error { return c.c.Close() } func (c netUDPConn) LocalAddr() netip.AddrPort { a, _ := c.c.LocalAddr().(net.UDPAddr) return a.AddrPort() } func (c netUDPConn) Read(f func(datagram)) { // We shouldn't ever see all of these messages at the same time, // but the total is small so just allocate enough space for everything we use. const ( inPktinfoSize = 12 // int + in_addr + in_addr in6PktinfoSize = 20 // in6_addr + int ipTOSSize = 4 ipv6TclassSize = 4 ) control := make([]byte, 0+ unix.CmsgSpace(inPktinfoSize)+ unix.CmsgSpace(in6PktinfoSize)+ unix.CmsgSpace(ipTOSSize)+ unix.CmsgSpace(ipv6TclassSize)) for { d := newDatagram() n, controlLen, _, peerAddr, err := c.c.ReadMsgUDPAddrPort(d.b, control) if err != nil { return } if n == 0 { continue } d.localAddr = c.localAddr d.peerAddr = unmapAddrPort(peerAddr) d.b = d.b[:n] parseControl(d, control[:controlLen]) f(d) } } var cmsgPool = sync.Pool{ New: func() any { return new([]byte) }, } func (c netUDPConn) Write(dgram datagram) error { controlp := cmsgPool.Get().([]byte) control := controlp defer func() { controlp = control[:0] cmsgPool.Put(controlp) }() localIP := dgram.localAddr.Addr() if localIP.IsValid() { if localIP.Is4() { control = appendCmsgIPSourceAddrV4(control, localIP) } else { control = appendCmsgIPSourceAddrV6(control, localIP) } } if dgram.ecn != ecnNotECT { if dgram.peerAddr.Addr().Is4() { control = appendCmsgECNv4(control, dgram.ecn) } else { control = appendCmsgECNv6(control, dgram.ecn) } } _, _, err := c.c.WriteMsgUDPAddrPort(dgram.b, control, dgram.peerAddr) return err } func parseControl(d datagram, control []byte) { for len(control) > 0 { hdr, data, remainder, err := unix.ParseOneSocketControlMessage(control) if err != nil { return } control = remainder switch hdr.Level { case unix.IPPROTO_IP: switch hdr.Type { case unix.IP_TOS, unix.IP_RECVTOS: // (Linux sets the type to IP_TOS, Darwin to IP_RECVTOS, // just check for both.) if ecn, ok := parseIPTOS(data); ok { d.ecn = ecn } case unix.IP_PKTINFO: if a, ok := parseInPktinfo(data); ok { d.localAddr = netip.AddrPortFrom(a, d.localAddr.Port()) } } case unix.IPPROTO_IPV6: switch hdr.Type { case unix.IPV6_TCLASS: // 32-bit integer containing the traffic class field. // The low two bits are the ECN field. if ecn, ok := parseIPv6TCLASS(data); ok { d.ecn = ecn } case unix.IPV6_PKTINFO: if a, ok := parseIn6Pktinfo(data); ok { d.localAddr = netip.AddrPortFrom(a, d.localAddr.Port()) } } } } } // IPV6_TCLASS is specified by RFC 3542 as an int. func parseIPv6TCLASS(b []byte) (ecnBits, bool) { if len(b) != 4 { return 0, false } return ecnBits(binary.NativeEndian.Uint32(b) & ecnMask), true } func appendCmsgECNv6(b []byte, ecn ecnBits) []byte { b, data := appendCmsg(b, unix.IPPROTO_IPV6, unix.IPV6_TCLASS, 4) binary.NativeEndian.PutUint32(data, uint32(ecn)) return b } // struct in_pktinfo { // unsigned int ipi_ifindex; /* send/recv interface index / // struct in_addr ipi_spec_dst; / Local address / // struct in_addr ipi_addr; / IP Header dst address / // }; // parseInPktinfo returns the destination address from an IP_PKTINFO. func parseInPktinfo(b []byte) (dst netip.Addr, ok bool) { if len(b) != 12 { return netip.Addr{}, false } return netip.AddrFrom4([4]byte(b[8:][:4])), true } // appendCmsgIPSourceAddrV4 appends an IP_PKTINFO setting the source address // for an outbound datagram. func appendCmsgIPSourceAddrV4(b []byte, src netip.Addr) []byte { // struct in_pktinfo { // unsigned int ipi_ifindex; / send/recv interface index / // struct in_addr ipi_spec_dst; / Local address / // struct in_addr ipi_addr; / IP Header dst address / // }; b, data := appendCmsg(b, unix.IPPROTO_IP, unix.IP_PKTINFO, 12) ip := src.As4() copy(data[4:], ip[:]) return b } // struct in6_pktinfo { // struct in6_addr ipi6_addr; / src/dst IPv6 address / // unsigned int ipi6_ifindex; / send/recv interface index / // }; // parseIn6Pktinfo returns the destination address from an IPV6_PKTINFO. func parseIn6Pktinfo(b []byte) (netip.Addr, bool) { if len(b) != 20 { return netip.Addr{}, false } return netip.AddrFrom16([16]byte(b[:16])).Unmap(), true } // appendCmsgIPSourceAddrV6 appends an IPV6_PKTINFO setting the source address // for an outbound datagram. func appendCmsgIPSourceAddrV6(b []byte, src netip.Addr) []byte { b, data := appendCmsg(b, unix.IPPROTO_IPV6, unix.IPV6_PKTINFO, 20) ip := src.As16() copy(data[0:], ip[:]) return b } // appendCmsg appends a cmsg with the given level, type, and size to b. // It returns the new buffer, and the data section of the cmsg. func appendCmsg(b []byte, level, typ int32, size int) (_, data []byte) { off := len(b) b = append(b, make([]byte, unix.CmsgSpace(size))...) h := (unix.Cmsghdr)(unsafe.Pointer(&b[off])) h.Level = level h.Type = typ h.SetLen(unix.CmsgLen(size)) return b, b[off+unix.CmsgSpace(0):][:size] }	6.67 KB	2025-05-25 12:27
📄 udp_other.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 && (quicbasicnet \|\| !(darwin \|\| linux)) package quic import ( "net" "net/netip" ) // Lowest common denominator network interface: Basic net.UDPConn, no cmsgs. // We will not be able to send or receive ECN bits, // and we will not know what our local address is. // // The quicbasicnet build tag allows selecting this interface on any platform. // See udp.go. const ( udpECNSupport = false udpInvalidLocalAddrIsError = false ) type netUDPConn struct { c net.UDPConn } func newNetUDPConn(uc net.UDPConn) (netUDPConn, error) { return &netUDPConn{ c: uc, }, nil } func (c netUDPConn) Close() error { return c.c.Close() } func (c netUDPConn) LocalAddr() netip.AddrPort { a, _ := c.c.LocalAddr().(net.UDPAddr) return a.AddrPort() } func (c netUDPConn) Read(f func(datagram)) { for { dgram := newDatagram() n, _, _, peerAddr, err := c.c.ReadMsgUDPAddrPort(dgram.b, nil) if err != nil { return } if n == 0 { continue } dgram.peerAddr = unmapAddrPort(peerAddr) dgram.b = dgram.b[:n] f(dgram) } } func (c *netUDPConn) Write(dgram datagram) error { _, err := c.c.WriteToUDPAddrPort(dgram.b, dgram.peerAddr) return err }	1.33 KB	2025-05-25 12:27
📄 udp_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "bytes" "fmt" "net" "net/netip" "runtime" "testing" ) func TestUDPSourceUnspecified(t testing.T) { // Send datagram with no source address set. runUDPTest(t, func(t testing.T, test udpTest) { t.Logf("%v", test.dstAddr) data := []byte("source unspecified") if err := test.src.Write(datagram{ b: data, peerAddr: test.dstAddr, }); err != nil { t.Fatalf("Write: %v", err) } got := <-test.dgramc if !bytes.Equal(got.b, data) { t.Errorf("got datagram {%x}, want {%x}", got.b, data) } }) } func TestUDPSourceSpecified(t testing.T) { // Send datagram with source address set. runUDPTest(t, func(t testing.T, test udpTest) { data := []byte("source specified") if err := test.src.Write(datagram{ b: data, peerAddr: test.dstAddr, localAddr: test.src.LocalAddr(), }); err != nil { t.Fatalf("Write: %v", err) } got := <-test.dgramc if !bytes.Equal(got.b, data) { t.Errorf("got datagram {%x}, want {%x}", got.b, data) } }) } func TestUDPSourceInvalid(t testing.T) { // Send datagram with source address set to an address not associated with the connection. if !udpInvalidLocalAddrIsError { t.Skipf("%v: sending from invalid source succeeds", runtime.GOOS) } runUDPTest(t, func(t testing.T, test udpTest) { var localAddr netip.AddrPort if test.src.LocalAddr().Addr().Is4() { localAddr = netip.MustParseAddrPort("127.0.0.2:1234") } else { localAddr = netip.MustParseAddrPort("[::2]:1234") } data := []byte("source invalid") if err := test.src.Write(datagram{ b: data, peerAddr: test.dstAddr, localAddr: localAddr, }); err == nil { t.Errorf("Write with invalid localAddr succeeded; want error") } }) } func TestUDPECN(t testing.T) { if !udpECNSupport { t.Skipf("%v: no ECN support", runtime.GOOS) } // Send datagrams with ECN bits set, verify the ECN bits are received. runUDPTest(t, func(t testing.T, test udpTest) { for _, ecn := range []ecnBits{ecnNotECT, ecnECT1, ecnECT0, ecnCE} { if err := test.src.Write(datagram{ b: []byte{1, 2, 3, 4}, peerAddr: test.dstAddr, ecn: ecn, }); err != nil { t.Fatalf("Write: %v", err) } got := <-test.dgramc if got.ecn != ecn { t.Errorf("sending ECN bits %x, got %x", ecn, got.ecn) } } }) } type udpTest struct { src netUDPConn dst netUDPConn dstAddr netip.AddrPort dgramc chan datagram } // runUDPTest calls f with a pair of UDPConns in a matrix of network variations: // udp, udp4, and udp6, and variations on binding to an unspecified address (0.0.0.0) // or a specified one. func runUDPTest(t testing.T, f func(t testing.T, u udpTest)) { for _, test := range []struct { srcNet, srcAddr, dstNet, dstAddr string }{ {"udp4", "127.0.0.1", "udp", ""}, {"udp4", "127.0.0.1", "udp4", ""}, {"udp4", "127.0.0.1", "udp4", "127.0.0.1"}, {"udp6", "::1", "udp", ""}, {"udp6", "::1", "udp6", ""}, {"udp6", "::1", "udp6", "::1"}, } { spec := "spec" if test.dstAddr == "" { spec = "unspec" } t.Run(fmt.Sprintf("%v/%v/%v", test.srcNet, test.dstNet, spec), func(t testing.T) { // See: https://go.googlesource.com/go/+/refs/tags/go1.22.0/src/net/ipsock.go#47 // On these platforms, conns with network="udp" cannot accept IPv6. switch runtime.GOOS { case "dragonfly", "openbsd": if test.srcNet == "udp6" && test.dstNet == "udp" { t.Skipf("%v: no support for mapping IPv4 address to IPv6", runtime.GOOS) } case "plan9": t.Skipf("ReadMsgUDP not supported on %s", runtime.GOOS) } if runtime.GOARCH == "wasm" && test.srcNet == "udp6" { t.Skipf("%v: IPv6 tests fail when using wasm fake net", runtime.GOARCH) } srcAddr := netip.AddrPortFrom(netip.MustParseAddr(test.srcAddr), 0) srcConn, err := net.ListenUDP(test.srcNet, net.UDPAddrFromAddrPort(srcAddr)) if err != nil { // If ListenUDP fails here, we presumably don't have // IPv4/IPv6 configured. t.Skipf("ListenUDP(%q, %v) = %v", test.srcNet, srcAddr, err) } t.Cleanup(func() { srcConn.Close() }) src, err := newNetUDPConn(srcConn) if err != nil { t.Fatalf("newNetUDPConn: %v", err) } var dstAddr netip.AddrPort if test.dstAddr != "" { dstAddr = netip.AddrPortFrom(netip.MustParseAddr(test.dstAddr), 0) } dstConn, err := net.ListenUDP(test.dstNet, net.UDPAddrFromAddrPort(dstAddr)) if err != nil { t.Skipf("ListenUDP(%q, nil) = %v", test.dstNet, err) } dst, err := newNetUDPConn(dstConn) if err != nil { dstConn.Close() t.Fatalf("newNetUDPConn: %v", err) } dgramc := make(chan datagram) go func() { defer close(dgramc) dst.Read(func(dgram datagram) { dgramc <- dgram }) }() t.Cleanup(func() { dstConn.Close() for range dgramc { t.Errorf("test read unexpected datagram") } }) f(t, udpTest{ src: src, dst: dst, dstAddr: netip.AddrPortFrom( srcAddr.Addr(), dst.LocalAddr().Port(), ), dgramc: dgramc, }) }) } }	5.12 KB	2025-05-25 12:27
📄 version_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "bytes" "context" "crypto/tls" "testing" ) func TestVersionNegotiationServerReceivesUnknownVersion(t testing.T) { config := &Config{ TLSConfig: newTestTLSConfig(serverSide), } te := newTestEndpoint(t, config) // Packet of unknown contents for some unrecognized QUIC version. dstConnID := []byte{1, 2, 3, 4} srcConnID := []byte{5, 6, 7, 8} pkt := []byte{ 0b1000_0000, 0x00, 0x00, 0x00, 0x0f, } pkt = append(pkt, byte(len(dstConnID))) pkt = append(pkt, dstConnID...) pkt = append(pkt, byte(len(srcConnID))) pkt = append(pkt, srcConnID...) for len(pkt) < paddedInitialDatagramSize { pkt = append(pkt, 0) } te.write(&datagram{ b: pkt, }) gotPkt := te.read() if gotPkt == nil { t.Fatalf("got no response; want Version Negotiation") } if got := getPacketType(gotPkt); got != packetTypeVersionNegotiation { t.Fatalf("got packet type %v; want Version Negotiation", got) } gotDst, gotSrc, versions := parseVersionNegotiation(gotPkt) if got, want := gotDst, srcConnID; !bytes.Equal(got, want) { t.Errorf("got Destination Connection ID %x, want %x", got, want) } if got, want := gotSrc, dstConnID; !bytes.Equal(got, want) { t.Errorf("got Source Connection ID %x, want %x", got, want) } if got, want := versions, []byte{0, 0, 0, 1}; !bytes.Equal(got, want) { t.Errorf("got Supported Version %x, want %x", got, want) } } func TestVersionNegotiationClientAborts(t testing.T) { tc := newTestConn(t, clientSide) p := tc.readPacket() // client Initial packet tc.endpoint.write(&datagram{ b: appendVersionNegotiation(nil, p.srcConnID, p.dstConnID, 10), }) tc.wantIdle("connection does not send a CONNECTION_CLOSE") if err := tc.conn.waitReady(canceledContext()); err != errVersionNegotiation { t.Errorf("conn.waitReady() = %v, want errVersionNegotiation", err) } } func TestVersionNegotiationClientIgnoresAfterProcessingPacket(t testing.T) { tc := newTestConn(t, clientSide) tc.ignoreFrame(frameTypeAck) p := tc.readPacket() // client Initial packet tc.writeFrames(packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelInitial], }) tc.endpoint.write(&datagram{ b: appendVersionNegotiation(nil, p.srcConnID, p.dstConnID, 10), }) if err := tc.conn.waitReady(canceledContext()); err != context.Canceled { t.Errorf("conn.waitReady() = %v, want context.Canceled", err) } tc.writeFrames(packetTypeHandshake, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelHandshake], }) tc.wantFrameType("conn ignores Version Negotiation and continues with handshake", packetTypeHandshake, debugFrameCrypto{}) } func TestVersionNegotiationClientIgnoresMismatchingSourceConnID(t testing.T) { tc := newTestConn(t, clientSide) tc.ignoreFrame(frameTypeAck) p := tc.readPacket() // client Initial packet tc.endpoint.write(&datagram{ b: appendVersionNegotiation(nil, p.srcConnID, []byte("mismatch"), 10), }) tc.writeFrames(packetTypeInitial, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelInitial], }) tc.writeFrames(packetTypeHandshake, debugFrameCrypto{ data: tc.cryptoDataIn[tls.QUICEncryptionLevelHandshake], }) tc.wantFrameType("conn ignores Version Negotiation and continues with handshake", packetTypeHandshake, debugFrameCrypto{}) }	3.4 KB	2025-05-25 12:27
📄 wire.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import "encoding/binary" const ( maxVarintSize = 8 // encoded size in bytes maxVarint = (1 << 62) - 1 ) // consumeVarint parses a variable-length integer, reporting its length. // It returns a negative length upon an error. // // https://www.rfc-editor.org/rfc/rfc9000.html#section-16 func consumeVarint(b []byte) (v uint64, n int) { if len(b) < 1 { return 0, -1 } b0 := b[0] & 0x3f switch b[0] >> 6 { case 0: return uint64(b0), 1 case 1: if len(b) < 2 { return 0, -1 } return uint64(b0)<<8 \| uint64(b[1]), 2 case 2: if len(b) < 4 { return 0, -1 } return uint64(b0)<<24 \| uint64(b[1])<<16 \| uint64(b[2])<<8 \| uint64(b[3]), 4 case 3: if len(b) < 8 { return 0, -1 } return uint64(b0)<<56 \| uint64(b[1])<<48 \| uint64(b[2])<<40 \| uint64(b[3])<<32 \| uint64(b[4])<<24 \| uint64(b[5])<<16 \| uint64(b[6])<<8 \| uint64(b[7]), 8 } return 0, -1 } // consumeVarint64 parses a variable-length integer as an int64. func consumeVarintInt64(b []byte) (v int64, n int) { u, n := consumeVarint(b) // QUIC varints are 62-bits large, so this conversion can never overflow. return int64(u), n } // appendVarint appends a variable-length integer to b. // // https://www.rfc-editor.org/rfc/rfc9000.html#section-16 func appendVarint(b []byte, v uint64) []byte { switch { case v <= 63: return append(b, byte(v)) case v <= 16383: return append(b, (1<<6)\|byte(v>>8), byte(v)) case v <= 1073741823: return append(b, (2<<6)\|byte(v>>24), byte(v>>16), byte(v>>8), byte(v)) case v <= 4611686018427387903: return append(b, (3<<6)\|byte(v>>56), byte(v>>48), byte(v>>40), byte(v>>32), byte(v>>24), byte(v>>16), byte(v>>8), byte(v)) default: panic("varint too large") } } // sizeVarint returns the size of the variable-length integer encoding of f. func sizeVarint(v uint64) int { switch { case v <= 63: return 1 case v <= 16383: return 2 case v <= 1073741823: return 4 case v <= 4611686018427387903: return 8 default: panic("varint too large") } } // consumeUint32 parses a 32-bit fixed-length, big-endian integer, reporting its length. // It returns a negative length upon an error. func consumeUint32(b []byte) (uint32, int) { if len(b) < 4 { return 0, -1 } return binary.BigEndian.Uint32(b), 4 } // consumeUint64 parses a 64-bit fixed-length, big-endian integer, reporting its length. // It returns a negative length upon an error. func consumeUint64(b []byte) (uint64, int) { if len(b) < 8 { return 0, -1 } return binary.BigEndian.Uint64(b), 8 } // consumeUint8Bytes parses a sequence of bytes prefixed with an 8-bit length, // reporting the total number of bytes consumed. // It returns a negative length upon an error. func consumeUint8Bytes(b []byte) ([]byte, int) { if len(b) < 1 { return nil, -1 } size := int(b[0]) const n = 1 if size > len(b[n:]) { return nil, -1 } return b[n:][:size], size + n } // appendUint8Bytes appends a sequence of bytes prefixed by an 8-bit length. func appendUint8Bytes(b, v []byte) []byte { if len(v) > 0xff { panic("uint8-prefixed bytes too large") } b = append(b, uint8(len(v))) b = append(b, v...) return b } // consumeVarintBytes parses a sequence of bytes preceded by a variable-length integer length, // reporting the total number of bytes consumed. // It returns a negative length upon an error. func consumeVarintBytes(b []byte) ([]byte, int) { size, n := consumeVarint(b) if n < 0 { return nil, -1 } if size > uint64(len(b[n:])) { return nil, -1 } return b[n:][:size], int(size) + n } // appendVarintBytes appends a sequence of bytes prefixed by a variable-length integer length. func appendVarintBytes(b, v []byte) []byte { b = appendVarint(b, uint64(len(v))) b = append(b, v...) return b }	3.84 KB	2025-05-25 12:27
📄 wire_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.21 package quic import ( "bytes" "testing" ) func TestConsumeVarint(t testing.T) { for _, test := range []struct { b []byte want uint64 wantLen int }{ {[]byte{0x00}, 0, 1}, {[]byte{0x3f}, 63, 1}, {[]byte{0x40, 0x00}, 0, 2}, {[]byte{0x7f, 0xff}, 16383, 2}, {[]byte{0x80, 0x00, 0x00, 0x00}, 0, 4}, {[]byte{0xbf, 0xff, 0xff, 0xff}, 1073741823, 4}, {[]byte{0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 0, 8}, {[]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, 4611686018427387903, 8}, // Example cases from https://www.rfc-editor.org/rfc/rfc9000.html#section-a.1 {[]byte{0xc2, 0x19, 0x7c, 0x5e, 0xff, 0x14, 0xe8, 0x8c}, 151288809941952652, 8}, {[]byte{0x9d, 0x7f, 0x3e, 0x7d}, 494878333, 4}, {[]byte{0x7b, 0xbd}, 15293, 2}, {[]byte{0x25}, 37, 1}, {[]byte{0x40, 0x25}, 37, 2}, } { got, gotLen := consumeVarint(test.b) if got != test.want \|\| gotLen != test.wantLen { t.Errorf("consumeVarint(%x) = %v, %v; want %v, %v", test.b, got, gotLen, test.want, test.wantLen) } // Extra data in the buffer is ignored. b := append(test.b, 0) got, gotLen = consumeVarint(b) if got != test.want \|\| gotLen != test.wantLen { t.Errorf("consumeVarint(%x) = %v, %v; want %v, %v", b, got, gotLen, test.want, test.wantLen) } // Short buffer results in an error. for i := 1; i <= len(test.b); i++ { b = test.b[:len(test.b)-i] got, gotLen = consumeVarint(b) if got != 0 \|\| gotLen >= 0 { t.Errorf("consumeVarint(%x) = %v, %v; want 0, -1", b, got, gotLen) } } } } func TestAppendVarint(t testing.T) { for _, test := range []struct { v uint64 want []byte }{ {0, []byte{0x00}}, {63, []byte{0x3f}}, {16383, []byte{0x7f, 0xff}}, {1073741823, []byte{0xbf, 0xff, 0xff, 0xff}}, {4611686018427387903, []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}}, // Example cases from https://www.rfc-editor.org/rfc/rfc9000.html#section-a.1 {151288809941952652, []byte{0xc2, 0x19, 0x7c, 0x5e, 0xff, 0x14, 0xe8, 0x8c}}, {494878333, []byte{0x9d, 0x7f, 0x3e, 0x7d}}, {15293, []byte{0x7b, 0xbd}}, {37, []byte{0x25}}, } { got := appendVarint([]byte{}, test.v) if !bytes.Equal(got, test.want) { t.Errorf("AppendVarint(nil, %v) = %x, want %x", test.v, got, test.want) } if gotLen, wantLen := sizeVarint(test.v), len(got); gotLen != wantLen { t.Errorf("SizeVarint(%v) = %v, want %v", test.v, gotLen, wantLen) } } } func TestConsumeUint32(t testing.T) { for _, test := range []struct { b []byte want uint32 wantLen int }{ {[]byte{0x01, 0x02, 0x03, 0x04}, 0x01020304, 4}, {[]byte{0x01, 0x02, 0x03}, 0, -1}, } { if got, n := consumeUint32(test.b); got != test.want \|\| n != test.wantLen { t.Errorf("consumeUint32(%x) = %v, %v; want %v, %v", test.b, got, n, test.want, test.wantLen) } } } func TestConsumeUint64(t testing.T) { for _, test := range []struct { b []byte want uint64 wantLen int }{ {[]byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08}, 0x0102030405060708, 8}, {[]byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07}, 0, -1}, } { if got, n := consumeUint64(test.b); got != test.want \|\| n != test.wantLen { t.Errorf("consumeUint32(%x) = %v, %v; want %v, %v", test.b, got, n, test.want, test.wantLen) } } } func TestConsumeVarintBytes(t testing.T) { for _, test := range []struct { b []byte want []byte wantLen int }{ {[]byte{0x00}, []byte{}, 1}, {[]byte{0x40, 0x00}, []byte{}, 2}, {[]byte{0x04, 0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, 5}, {[]byte{0x40, 0x04, 0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, 6}, } { got, gotLen := consumeVarintBytes(test.b) if !bytes.Equal(got, test.want) \|\| gotLen != test.wantLen { t.Errorf("consumeVarintBytes(%x) = {%x}, %v; want {%x}, %v", test.b, got, gotLen, test.want, test.wantLen) } // Extra data in the buffer is ignored. b := append(test.b, 0) got, gotLen = consumeVarintBytes(b) if !bytes.Equal(got, test.want) \|\| gotLen != test.wantLen { t.Errorf("consumeVarintBytes(%x) = {%x}, %v; want {%x}, %v", b, got, gotLen, test.want, test.wantLen) } // Short buffer results in an error. for i := 1; i <= len(test.b); i++ { b = test.b[:len(test.b)-i] got, gotLen := consumeVarintBytes(b) if len(got) > 0 \|\| gotLen > 0 { t.Errorf("consumeVarintBytes(%x) = {%x}, %v; want {}, -1", b, got, gotLen) } } } } func TestConsumeVarintBytesErrors(t testing.T) { for _, b := range [][]byte{ {0x01}, {0x40, 0x01}, } { got, gotLen := consumeVarintBytes(b) if len(got) > 0 \|\| gotLen > 0 { t.Errorf("consumeVarintBytes(%x) = {%x}, %v; want {}, -1", b, got, gotLen) } } } func TestConsumeUint8Bytes(t testing.T) { for _, test := range []struct { b []byte want []byte wantLen int }{ {[]byte{0x00}, []byte{}, 1}, {[]byte{0x01, 0x00}, []byte{0x00}, 2}, {[]byte{0x04, 0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, 5}, } { got, gotLen := consumeUint8Bytes(test.b) if !bytes.Equal(got, test.want) \|\| gotLen != test.wantLen { t.Errorf("consumeUint8Bytes(%x) = {%x}, %v; want {%x}, %v", test.b, got, gotLen, test.want, test.wantLen) } // Extra data in the buffer is ignored. b := append(test.b, 0) got, gotLen = consumeUint8Bytes(b) if !bytes.Equal(got, test.want) \|\| gotLen != test.wantLen { t.Errorf("consumeUint8Bytes(%x) = {%x}, %v; want {%x}, %v", b, got, gotLen, test.want, test.wantLen) } // Short buffer results in an error. for i := 1; i <= len(test.b); i++ { b = test.b[:len(test.b)-i] got, gotLen := consumeUint8Bytes(b) if len(got) > 0 \|\| gotLen > 0 { t.Errorf("consumeUint8Bytes(%x) = {%x}, %v; want {}, -1", b, got, gotLen) } } } } func TestConsumeUint8BytesErrors(t testing.T) { for _, b := range [][]byte{ {0x01}, {0x04, 0x01, 0x02, 0x03}, } { got, gotLen := consumeUint8Bytes(b) if len(got) > 0 \|\| gotLen > 0 { t.Errorf("consumeUint8Bytes(%x) = {%x}, %v; want {}, -1", b, got, gotLen) } } } func TestAppendUint8Bytes(t testing.T) { var got []byte got = appendUint8Bytes(got, []byte{}) got = appendUint8Bytes(got, []byte{0xaa, 0xbb}) want := []byte{ 0x00, 0x02, 0xaa, 0xbb, } if !bytes.Equal(got, want) { t.Errorf("appendUint8Bytes {}, {aabb} = {%x}; want {%x}", got, want) } } func TestAppendVarintBytes(t testing.T) { var got []byte got = appendVarintBytes(got, []byte{}) got = appendVarintBytes(got, []byte{0xaa, 0xbb}) want := []byte{ 0x00, 0x02, 0xaa, 0xbb, } if !bytes.Equal(got, want) { t.Errorf("appendVarintBytes {}, {aabb} = {%x}; want {%x}", got, want) } }	6.63 KB	2025-05-25 12:27

Edit File:

Terminal