| // 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" |
| "io" |
| "math" |
| "net" |
| "net/netip" |
| "reflect" |
| "strings" |
| "testing" |
| "time" |
| ) |
| |
| var testVV = flag.Bool("vv", false, "even more verbose test output") |
| |
| func TestConnTestConn(t *testing.T) { |
| tc := newTestConn(t, serverSide) |
| if got, want := tc.timeUntilEvent(), defaultMaxIdleTimeout; got != want { |
| t.Errorf("new conn timeout=%v, want %v (max_idle_timeout)", got, want) |
| } |
| |
| var ranAt time.Time |
| tc.conn.runOnLoop(func(now time.Time, c *Conn) { |
| ranAt = now |
| }) |
| if !ranAt.Equal(tc.now) { |
| t.Errorf("func ran on loop at %v, want %v", ranAt, tc.now) |
| } |
| tc.wait() |
| |
| nextTime := tc.now.Add(defaultMaxIdleTimeout / 2) |
| tc.advanceTo(nextTime) |
| tc.conn.runOnLoop(func(now time.Time, c *Conn) { |
| ranAt = now |
| }) |
| if !ranAt.Equal(nextTime) { |
| t.Errorf("func ran on loop at %v, want %v", ranAt, nextTime) |
| } |
| tc.wait() |
| |
| tc.advanceToTimer() |
| if !tc.conn.exited { |
| t.Errorf("after advancing to idle timeout, exited = false, want true") |
| } |
| } |
| |
| type testDatagram struct { |
| packets []*testPacket |
| paddedSize int |
| } |
| |
| 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 |
| version uint32 |
| num packetNumber |
| dstConnID []byte |
| srcConnID []byte |
| 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) |
| } |
| for _, f := range p.frames { |
| fmt.Fprintf(&b, "\n %v", f) |
| } |
| return b.String() |
| } |
| |
| // 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 |
| listener *Listener |
| now time.Time |
| timer time.Time |
| timerLastFired time.Time |
| idlec chan struct{} // only accessed on the conn's loop |
| |
| // Read and write 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. |
| rkeys [numberSpaceCount]keyData // for packets sent to the conn |
| wkeys [numberSpaceCount]keyData // for packets sent by the conn |
| |
| // 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 |
| lastPacket *testPacket |
| |
| recvDatagram chan *datagram |
| |
| // Transport parameters sent by the conn. |
| sentTransportParameters *transportParameters |
| |
| // Frame types to ignore in tests. |
| ignoreFrames map[byte]bool |
| |
| asyncTestState |
| } |
| |
| type keyData struct { |
| suite uint16 |
| secret []byte |
| k keys |
| } |
| |
| // 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() |
| tc := &testConn{ |
| t: t, |
| now: time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC), |
| 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) |
| |
| config := &Config{ |
| TLSConfig: newTestTLSConfig(side), |
| } |
| peerProvidedParams := defaultTransportParameters() |
| for _, o := range opts { |
| switch o := o.(type) { |
| case func(*Config): |
| o(config) |
| case func(*tls.Config): |
| o(config.TLSConfig) |
| case func(p *transportParameters): |
| o(&peerProvidedParams) |
| default: |
| t.Fatalf("unknown newTestConn option %T", o) |
| } |
| } |
| |
| var initialConnID []byte |
| if side == serverSide { |
| // The initial connection ID for the server is chosen by the client. |
| initialConnID = testPeerConnID(-1) |
| } |
| |
| peerQUICConfig := &tls.QUICConfig{TLSConfig: newTestTLSConfig(side.peer())} |
| if side == clientSide { |
| tc.peerTLSConn = tls.QUICServer(peerQUICConfig) |
| } else { |
| tc.peerTLSConn = tls.QUICClient(peerQUICConfig) |
| } |
| tc.peerTLSConn.SetTransportParameters(marshalTransportParameters(peerProvidedParams)) |
| tc.peerTLSConn.Start(context.Background()) |
| |
| tc.listener = newListener((*testConnUDPConn)(tc), config, (*testConnHooks)(tc)) |
| conn, err := tc.listener.newConn( |
| tc.now, |
| side, |
| initialConnID, |
| netip.MustParseAddrPort("127.0.0.1:443")) |
| if err != nil { |
| tc.t.Fatal(err) |
| } |
| tc.conn = conn |
| |
| tc.wkeys[initialSpace].k = conn.wkeys[initialSpace] |
| tc.rkeys[initialSpace].k = conn.rkeys[initialSpace] |
| |
| tc.wait() |
| return tc |
| } |
| |
| // advance causes time to pass. |
| func (tc *testConn) advance(d time.Duration) { |
| tc.t.Helper() |
| tc.advanceTo(tc.now.Add(d)) |
| } |
| |
| // advanceTo sets the current time. |
| func (tc *testConn) advanceTo(now time.Time) { |
| tc.t.Helper() |
| if tc.now.After(now) { |
| tc.t.Fatalf("time moved backwards: %v -> %v", tc.now, now) |
| } |
| tc.now = now |
| if tc.timer.After(tc.now) { |
| return |
| } |
| tc.conn.sendMsg(timerEvent{}) |
| tc.wait() |
| } |
| |
| // 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.now) { |
| return 0 |
| } |
| return tc.timer.Sub(tc.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.now) { |
| return 0 |
| } |
| return tc.timer.Sub(tc.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: |
| } |
| if fail { |
| panic(fail) |
| } |
| } |
| |
| func (tc *testConn) cleanup() { |
| if tc.conn == nil { |
| return |
| } |
| tc.conn.exit() |
| tc.listener.Close(context.Background()) |
| } |
| |
| func (tc *testConn) logDatagram(text string, d *testDatagram) { |
| tc.t.Helper() |
| if !*testVV { |
| return |
| } |
| pad := "" |
| if d.paddedSize > 0 { |
| pad = fmt.Sprintf(" (padded to %v)", d.paddedSize) |
| } |
| tc.t.Logf("%v datagram%v", text, pad) |
| for _, p := range d.packets { |
| switch p.ptype { |
| case packetType1RTT: |
| tc.t.Logf(" %v pnum=%v", p.ptype, p.num) |
| default: |
| tc.t.Logf(" %v pnum=%v ver=%v dst={%x} src={%x}", p.ptype, p.num, p.version, p.dstConnID, p.srcConnID) |
| } |
| for _, f := range p.frames { |
| tc.t.Logf(" %v", f) |
| } |
| } |
| } |
| |
| // write sends the Conn a datagram. |
| func (tc *testConn) write(d *testDatagram) { |
| tc.t.Helper() |
| var buf []byte |
| tc.logDatagram("<- conn under test receives", d) |
| for _, p := range d.packets { |
| space := spaceForPacketType(p.ptype) |
| if p.num >= tc.peerNextPacketNum[space] { |
| tc.peerNextPacketNum[space] = p.num + 1 |
| } |
| pad := 0 |
| if p.ptype == packetType1RTT { |
| pad = d.paddedSize |
| } |
| buf = append(buf, tc.encodeTestPacket(p, pad)...) |
| } |
| for len(buf) < d.paddedSize { |
| buf = append(buf, 0) |
| } |
| tc.conn.sendMsg(&datagram{ |
| b: buf, |
| }) |
| tc.wait() |
| } |
| |
| // 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], |
| frames: frames, |
| version: 1, |
| dstConnID: dstConnID, |
| srcConnID: tc.peerConnID, |
| }}, |
| } |
| 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 |
| if len(tc.sentDatagrams) == 0 { |
| return nil |
| } |
| buf := tc.sentDatagrams[0] |
| tc.sentDatagrams = tc.sentDatagrams[1:] |
| d := tc.parseTestDatagram(buf) |
| // Log the datagram before removing ignored frames. |
| // When things go wrong, it's useful to see all the frames. |
| tc.logDatagram("-> 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 |
| } |
| 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 |
| } |
| tc.sentPackets = d.packets |
| } |
| 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 !reflect.DeepEqual(got, want) { |
| tc.t.Fatalf("%v:\ngot datagram: %v\nwant datagram: %v", expectation, got, want) |
| } |
| } |
| |
| // 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 !reflect.DeepEqual(got, want) { |
| tc.t.Fatalf("%v:\ngot packet: %v\nwant packet: %v", expectation, got, want) |
| } |
| } |
| |
| // 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 !reflect.DeepEqual(got, want) { |
| tc.t.Fatalf("%v:\ngot frame: %v\nwant frame: %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 (tc *testConn) encodeTestPacket(p *testPacket, pad int) []byte { |
| tc.t.Helper() |
| var w packetWriter |
| w.reset(1200) |
| var pnumMaxAcked packetNumber |
| if p.ptype != packetType1RTT { |
| w.startProtectedLongHeaderPacket(pnumMaxAcked, longPacket{ |
| ptype: p.ptype, |
| version: p.version, |
| num: p.num, |
| dstConnID: p.dstConnID, |
| srcConnID: p.srcConnID, |
| }) |
| } else { |
| w.start1RTTPacket(p.num, pnumMaxAcked, p.dstConnID) |
| } |
| for _, f := range p.frames { |
| f.write(&w) |
| } |
| space := spaceForPacketType(p.ptype) |
| if !tc.rkeys[space].k.isSet() { |
| tc.t.Fatalf("sending packet with no %v keys available", space) |
| return nil |
| } |
| w.appendPaddingTo(pad) |
| if p.ptype != packetType1RTT { |
| w.finishProtectedLongHeaderPacket(pnumMaxAcked, tc.rkeys[space].k, longPacket{ |
| ptype: p.ptype, |
| version: p.version, |
| num: p.num, |
| dstConnID: p.dstConnID, |
| srcConnID: p.srcConnID, |
| }) |
| } else { |
| w.finish1RTTPacket(p.num, pnumMaxAcked, p.dstConnID, tc.rkeys[space].k) |
| } |
| return w.datagram() |
| } |
| |
| func (tc *testConn) parseTestDatagram(buf []byte) *testDatagram { |
| tc.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) |
| space := spaceForPacketType(ptype) |
| if !tc.wkeys[space].k.isSet() { |
| tc.t.Fatalf("no keys for space %v, packet type %v", space, ptype) |
| } |
| if isLongHeader(buf[0]) { |
| var pnumMax packetNumber // TODO: Track packet numbers. |
| p, n := parseLongHeaderPacket(buf, tc.wkeys[space].k, pnumMax) |
| if n < 0 { |
| tc.t.Fatalf("packet parse error") |
| } |
| frames, err := tc.parseTestFrames(p.payload) |
| if err != nil { |
| tc.t.Fatal(err) |
| } |
| d.packets = append(d.packets, &testPacket{ |
| ptype: p.ptype, |
| version: p.version, |
| num: p.num, |
| dstConnID: p.dstConnID, |
| srcConnID: p.srcConnID, |
| frames: frames, |
| }) |
| buf = buf[n:] |
| } else { |
| var pnumMax packetNumber // TODO: Track packet numbers. |
| p, n := parse1RTTPacket(buf, tc.wkeys[space].k, len(tc.peerConnID), pnumMax) |
| if n < 0 { |
| tc.t.Fatalf("packet parse error") |
| } |
| frames, err := tc.parseTestFrames(p.payload) |
| if err != nil { |
| tc.t.Fatal(err) |
| } |
| d.packets = append(d.packets, &testPacket{ |
| ptype: packetType1RTT, |
| num: p.num, |
| dstConnID: buf[1:][:len(tc.peerConnID)], |
| frames: frames, |
| }) |
| buf = buf[n:] |
| } |
| } |
| // 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 (tc *testConn) parseTestFrames(payload []byte) ([]debugFrame, error) { |
| tc.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("TODO: packetTypeRetry") |
| case packetType1RTT: |
| return appDataSpace |
| } |
| panic("unknown packet type") |
| } |
| |
| // testConnHooks implements connTestHooks. |
| type testConnHooks testConn |
| |
| // 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) { |
| setKey := func(keys *[numberSpaceCount]keyData, e tls.QUICEvent) { |
| k, err := newKeys(e.Suite, e.Data) |
| if err != nil { |
| tc.t.Errorf("newKeys: %v", err) |
| return |
| } |
| 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 |
| } |
| s := "read" |
| if keys == &tc.wkeys { |
| s = "write" |
| } |
| if keys[space].k.isSet() { |
| if keys[space].suite != e.Suite || !bytes.Equal(keys[space].secret, e.Data) { |
| tc.t.Errorf("%v key mismatch for level for level %v", s, e.Level) |
| } |
| return |
| } |
| keys[space].suite = e.Suite |
| keys[space].secret = append([]byte{}, e.Data...) |
| keys[space].k = k |
| } |
| switch e.Kind { |
| case tls.QUICSetReadSecret: |
| setKey(&tc.rkeys, e) |
| case tls.QUICSetWriteSecret: |
| setKey(&tc.wkeys, e) |
| 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: |
| setKey(&tc.wkeys, e) |
| case tls.QUICSetWriteSecret: |
| setKey(&tc.rkeys, e) |
| 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.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.now, timer) |
| } else { |
| tc.timerLastFired = timer |
| return tc.now, timerEvent{} |
| } |
| } |
| select { |
| case m := <-msgc: |
| return tc.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.now, m |
| } |
| |
| func (tc *testConnHooks) newConnID(seq int64) ([]byte, error) { |
| return testLocalConnID(seq), nil |
| } |
| |
| func (tc *testConnHooks) timeNow() time.Time { |
| return tc.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)} |
| } |
| |
| // testConnUDPConn implements UDPConn. |
| type testConnUDPConn testConn |
| |
| func (tc *testConnUDPConn) Close() error { |
| close(tc.recvDatagram) |
| return nil |
| } |
| |
| func (tc *testConnUDPConn) LocalAddr() net.Addr { |
| return net.UDPAddrFromAddrPort(netip.MustParseAddrPort("127.0.0.1:443")) |
| } |
| |
| func (tc *testConnUDPConn) ReadMsgUDPAddrPort(b, control []byte) (n, controln, flags int, _ netip.AddrPort, _ error) { |
| for d := range tc.recvDatagram { |
| n = copy(b, d.b) |
| return n, 0, 0, d.addr, nil |
| } |
| return 0, 0, 0, netip.AddrPort{}, io.EOF |
| } |
| |
| func (tc *testConnUDPConn) WriteToUDPAddrPort(b []byte, addr netip.AddrPort) (int, error) { |
| tc.sentDatagrams = append(tc.sentDatagrams, append([]byte(nil), b...)) |
| return len(b), nil |
| } |
| |
| // 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 |
| } |