don't allocate a wire.Header when parsing short header packets

example/main.go

@@ -10,6 +10,7 @@ import (
 	"io/ioutil"
 	"log"
 	"mime/multipart"
+	"net"
 	"net/http"
 	"os"
 	"strconv"
@@ -163,7 +164,9 @@ func main() {
 	}
 
 	handler := setupHandler(*www)
-	quicConf := &quic.Config{}
+	quicConf := &quic.Config{
+		AcceptToken: func(clientAddr net.Addr, token *quic.Token) bool { return true },
+	}
 	if *enableQlog {
 		quicConf.Tracer = qlog.NewTracer(func(_ logging.Perspective, connID []byte) io.WriteCloser {
 			filename := fmt.Sprintf("server_%x.qlog", connID)

fuzzing/header/fuzz.go

@@ -29,7 +29,10 @@ func Fuzz(data []byte) int {
 	if err != nil {
 		return 0
 	}
-	hdr, _, _, err := wire.ParsePacket(data, connIDLen)
+	if !wire.IsLongHeader(data[0]) {
+		return 0
+	}
+	hdr, _, _, err := wire.ParseLongHeaderPacket(data)
 	if err != nil {
 		return 0
 	}

integrationtests/self/key_update_test.go

@@ -17,29 +17,23 @@ import (
 )
 
 var (
-	sentHeaders     []*logging.ExtendedHeader
-	receivedHeaders []*logging.ExtendedHeader
+	sentKeyPhases     []logging.KeyPhaseBit
+	receivedKeyPhases []logging.KeyPhaseBit
 )
 
 func countKeyPhases() (sent, received int) {
 	lastKeyPhase := protocol.KeyPhaseOne
-	for _, hdr := range sentHeaders {
-		if hdr.IsLongHeader {
-			continue
-		}
-		if hdr.KeyPhase != lastKeyPhase {
+	for _, keyPhase := range sentKeyPhases {
+		if keyPhase != lastKeyPhase {
 			sent++
-			lastKeyPhase = hdr.KeyPhase
+			lastKeyPhase = keyPhase
 		}
 	}
 	lastKeyPhase = protocol.KeyPhaseOne
-	for _, hdr := range receivedHeaders {
-		if hdr.IsLongHeader {
-			continue
-		}
-		if hdr.KeyPhase != lastKeyPhase {
+	for _, keyPhase := range receivedKeyPhases {
+		if keyPhase != lastKeyPhase {
 			received++
-			lastKeyPhase = hdr.KeyPhase
+			lastKeyPhase = keyPhase
 		}
 	}
 	return
@@ -65,13 +59,19 @@ func (t *connTracer) StartedConnection(local, remote net.Addr, version logging.V
 func (t *connTracer) ClosedConnection(logging.CloseReason)                     {}
 func (t *connTracer) SentTransportParameters(*logging.TransportParameters)     {}
 func (t *connTracer) ReceivedTransportParameters(*logging.TransportParameters) {}
-func (t *connTracer) SentPacket(hdr *logging.ExtendedHeader, size logging.ByteCount, ack *logging.AckFrame, frames []logging.Frame) {
-	sentHeaders = append(sentHeaders, hdr)
+func (t *connTracer) SentLongHeaderPacket(*logging.ExtendedHeader, logging.ByteCount, *logging.AckFrame, []logging.Frame) {
+}
+
+func (t *connTracer) SentShortHeaderPacket(_ logging.ConnectionID, _ logging.PacketNumber, kp logging.KeyPhaseBit, _ logging.ByteCount, _ *logging.AckFrame, _ []logging.Frame) {
+	sentKeyPhases = append(sentKeyPhases, kp)
 }
 func (t *connTracer) ReceivedVersionNegotiationPacket(*logging.Header, []logging.VersionNumber) {}
 func (t *connTracer) ReceivedRetry(*logging.Header)                                             {}
-func (t *connTracer) ReceivedPacket(hdr *logging.ExtendedHeader, size logging.ByteCount, frames []logging.Frame) {
-	receivedHeaders = append(receivedHeaders, hdr)
+func (t *connTracer) ReceivedLongHeaderPacket(*logging.ExtendedHeader, logging.ByteCount, []logging.Frame) {
+}
+
+func (t *connTracer) ReceivedShortHeaderPacket(_ logging.ConnectionID, _ logging.PacketNumber, kp logging.KeyPhaseBit, _ logging.ByteCount, _ []logging.Frame) {
+	receivedKeyPhases = append(receivedKeyPhases, kp)
 }
 func (t *connTracer) BufferedPacket(logging.PacketType)                                             {}
 func (t *connTracer) DroppedPacket(logging.PacketType, logging.ByteCount, logging.PacketDropReason) {}

integrationtests/self/mitm_test.go

@@ -88,24 +88,35 @@ var _ = Describe("MITM test", func() {
 
 					sendRandomPacketsOfSameType := func(conn net.PacketConn, remoteAddr net.Addr, raw []byte) {
 						defer GinkgoRecover()
-						hdr, _, _, err := wire.ParsePacket(raw, connIDLen)
-						Expect(err).ToNot(HaveOccurred())
-						replyHdr := &wire.ExtendedHeader{
-							Header: wire.Header{
-								IsLongHeader:     hdr.IsLongHeader,
-								DestConnectionID: hdr.DestConnectionID,
-								SrcConnectionID:  hdr.SrcConnectionID,
-								Type:             hdr.Type,
-								Version:          hdr.Version,
-							},
-							PacketNumber:    protocol.PacketNumber(mrand.Int31n(math.MaxInt32 / 4)),
-							PacketNumberLen: protocol.PacketNumberLen(mrand.Int31n(4) + 1),
+						var replyHdr *wire.ExtendedHeader
+						if wire.IsLongHeader(raw[0]) {
+							hdr, _, _, err := wire.ParseLongHeaderPacket(raw)
+							Expect(err).ToNot(HaveOccurred())
+							replyHdr = &wire.ExtendedHeader{
+								Header: wire.Header{
+									IsLongHeader:     hdr.IsLongHeader,
+									DestConnectionID: hdr.DestConnectionID,
+									SrcConnectionID:  hdr.SrcConnectionID,
+									Type:             hdr.Type,
+									Version:          hdr.Version,
+								},
+								PacketNumber:    protocol.PacketNumber(mrand.Int31n(math.MaxInt32 / 4)),
+								PacketNumberLen: protocol.PacketNumberLen(mrand.Int31n(4) + 1),
+							}
+						} else {
+							destConnID, err := wire.ParseConnectionID(raw, connIDLen)
+							Expect(err).ToNot(HaveOccurred())
+							replyHdr = &wire.ExtendedHeader{
+								Header: wire.Header{DestConnectionID: destConnID},
+							}
 						}
 
 						const numPackets = 10
 						ticker := time.NewTicker(rtt / numPackets)
 						for i := 0; i < numPackets; i++ {
 							payloadLen := mrand.Int31n(100)
+							replyHdr.PacketNumber = protocol.PacketNumber(mrand.Int31())
+							replyHdr.PacketNumberLen = protocol.PacketNumberLen(mrand.Int31n(4) + 1)
 							replyHdr.Length = protocol.ByteCount(mrand.Int31n(payloadLen + 1))
 							buf := &bytes.Buffer{}
 							Expect(replyHdr.Write(buf, version)).To(Succeed())
@@ -350,9 +361,11 @@ var _ = Describe("MITM test", func() {
 						if dir == quicproxy.DirectionIncoming {
 							defer GinkgoRecover()
 
-							hdr, _, _, err := wire.ParsePacket(raw, connIDLen)
+							if !wire.IsLongHeader(raw[0]) {
+								return 0
+							}
+							hdr, _, _, err := wire.ParseLongHeaderPacket(raw)
 							Expect(err).ToNot(HaveOccurred())
-
 							if hdr.Type != protocol.PacketTypeInitial {
 								return 0
 							}
@@ -375,9 +388,11 @@ var _ = Describe("MITM test", func() {
 						if dir == quicproxy.DirectionIncoming && !initialPacketIntercepted {
 							defer GinkgoRecover()
 
-							hdr, _, _, err := wire.ParsePacket(raw, connIDLen)
+							if !wire.IsLongHeader(raw[0]) {
+								return 0
+							}
+							hdr, _, _, err := wire.ParseLongHeaderPacket(raw)
 							Expect(err).ToNot(HaveOccurred())
-
 							if hdr.Type != protocol.PacketTypeInitial {
 								return 0
 							}
@@ -400,9 +415,11 @@ var _ = Describe("MITM test", func() {
 						if dir == quicproxy.DirectionIncoming {
 							defer GinkgoRecover()
 
-							hdr, _, _, err := wire.ParsePacket(raw, connIDLen)
+							if !wire.IsLongHeader(raw[0]) {
+								return 0
+							}
+							hdr, _, _, err := wire.ParseLongHeaderPacket(raw)
 							Expect(err).ToNot(HaveOccurred())
-
 							if hdr.Type != protocol.PacketTypeInitial {
 								return 0
 							}
@@ -421,7 +438,10 @@ var _ = Describe("MITM test", func() {
 					clientAddr := clientConn.LocalAddr()
 					delayCb := func(dir quicproxy.Direction, raw []byte) time.Duration {
 						if dir == quicproxy.DirectionIncoming {
-							hdr, _, _, err := wire.ParsePacket(raw, connIDLen)
+							if !wire.IsLongHeader(raw[0]) {
+								return 0
+							}
+							hdr, _, _, err := wire.ParseLongHeaderPacket(raw)
 							Expect(err).ToNot(HaveOccurred())
 							if hdr.Type != protocol.PacketTypeInitial {
 								return 0

integrationtests/self/zero_rtt_test.go

@@ -31,10 +31,12 @@ var _ = Describe("0-RTT", func() {
 				proxy, err := quicproxy.NewQuicProxy("localhost:0", &quicproxy.Opts{
 					RemoteAddr: fmt.Sprintf("localhost:%d", serverPort),
 					DelayPacket: func(_ quicproxy.Direction, data []byte) time.Duration {
-						hdr, _, _, err := wire.ParsePacket(data, 0)
-						Expect(err).ToNot(HaveOccurred())
-						if hdr.Type == protocol.PacketType0RTT {
-							atomic.AddUint32(&num0RTTPackets, 1)
+						if wire.IsLongHeader(data[0]) {
+							hdr, _, _, err := wire.ParseLongHeaderPacket(data)
+							Expect(err).ToNot(HaveOccurred())
+							if hdr.Type == protocol.PacketType0RTT {
+								atomic.AddUint32(&num0RTTPackets, 1)
+							}
 						}
 						return rtt / 2
 					},
@@ -222,23 +224,27 @@ var _ = Describe("0-RTT", func() {
 				proxy, err := quicproxy.NewQuicProxy("localhost:0", &quicproxy.Opts{
 					RemoteAddr: fmt.Sprintf("localhost:%d", serverPort),
 					DelayPacket: func(_ quicproxy.Direction, data []byte) time.Duration {
-						hdr, _, _, err := wire.ParsePacket(data, 0)
-						Expect(err).ToNot(HaveOccurred())
-						if hdr.Type == protocol.PacketType0RTT {
-							atomic.AddUint32(&num0RTTPackets, 1)
+						if wire.IsLongHeader(data[0]) {
+							hdr, _, _, err := wire.ParseLongHeaderPacket(data)
+							Expect(err).ToNot(HaveOccurred())
+							if hdr.Type == protocol.PacketType0RTT {
+								atomic.AddUint32(&num0RTTPackets, 1)
+							}
 						}
 						return rtt / 2
 					},
 					DropPacket: func(_ quicproxy.Direction, data []byte) bool {
-						hdr, _, _, err := wire.ParsePacket(data, 0)
-						Expect(err).ToNot(HaveOccurred())
-						if hdr.Type == protocol.PacketType0RTT {
-							// drop 25% of the 0-RTT packets
-							drop := mrand.Intn(4) == 0
-							if drop {
-								atomic.AddUint32(&num0RTTDropped, 1)
+						if wire.IsLongHeader(data[0]) {
+							hdr, _, _, err := wire.ParseLongHeaderPacket(data)
+							Expect(err).ToNot(HaveOccurred())
+							if hdr.Type == protocol.PacketType0RTT {
+								// drop 25% of the 0-RTT packets
+								drop := mrand.Intn(4) == 0
+								if drop {
+									atomic.AddUint32(&num0RTTDropped, 1)
+								}
+								return drop
 							}
-							return drop
 						}
 						return false
 					},
@@ -272,7 +278,10 @@ var _ = Describe("0-RTT", func() {
 
 				countZeroRTTBytes := func(data []byte) (n protocol.ByteCount) {
 					for len(data) > 0 {
-						hdr, _, rest, err := wire.ParsePacket(data, 0)
+						if !wire.IsLongHeader(data[0]) {
+							return
+						}
+						hdr, _, rest, err := wire.ParseLongHeaderPacket(data)
 						if err != nil {
 							return
 						}

integrationtests/tools/proxy/proxy_test.go

@@ -48,7 +48,8 @@ var _ = Describe("QUIC Proxy", func() {
 	}
 
 	readPacketNumber := func(b []byte) protocol.PacketNumber {
-		hdr, data, _, err := wire.ParsePacket(b, 0)
+		Expect(wire.IsLongHeader(b[0])).To(BeTrue())
+		hdr, data, _, err := wire.ParseLongHeaderPacket(b)
 		ExpectWithOffset(1, err).ToNot(HaveOccurred())
 		Expect(hdr.Type).To(Equal(protocol.PacketTypeInitial))
 		extHdr, err := hdr.ParseExtended(bytes.NewReader(data), protocol.VersionTLS)