determine the packet type from the QUIC header

qlog/packet_header.go

@@ -7,6 +7,27 @@ import (
 	"github.com/lucas-clemente/quic-go/internal/wire"
 )
 
+func getPacketType(hdr *wire.ExtendedHeader) packetType {
+	if !hdr.IsLongHeader {
+		return packetType1RTT
+	}
+	if hdr.Version == 0 {
+		return packetTypeVersionNegotiation
+	}
+	switch hdr.Type {
+	case protocol.PacketTypeInitial:
+		return packetTypeInitial
+	case protocol.PacketTypeHandshake:
+		return packetTypeHandshake
+	case protocol.PacketType0RTT:
+		return packetType0RTT
+	case protocol.PacketTypeRetry:
+		return packetTypeRetry
+	default:
+		panic("unknown packet type")
+	}
+}
+
 func transformHeader(hdr *wire.ExtendedHeader) *packetHeader {
 	return &packetHeader{
 		PacketNumber:     hdr.PacketNumber,

qlog/packet_header_test.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 
 	"github.com/francoispqt/gojay"
+
 	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/wire"
 
@@ -13,77 +14,133 @@ import (
 )
 
 var _ = Describe("Packet Header", func() {
-	check := func(hdr *wire.ExtendedHeader, expected map[string]interface{}) {
-		buf := &bytes.Buffer{}
-		enc := gojay.NewEncoder(buf)
-		ExpectWithOffset(1, enc.Encode(transformHeader(hdr))).To(Succeed())
-		data := buf.Bytes()
-		ExpectWithOffset(1, json.Valid(data)).To(BeTrue())
-		checkEncoding(data, expected)
-	}
-
-	It("marshals a header", func() {
-		check(
-			&wire.ExtendedHeader{PacketNumber: 42},
-			map[string]interface{}{
-				"packet_number": "42",
-			},
-		)
-	})
-
-	It("marshals a header with a payload length", func() {
-		check(
-			&wire.ExtendedHeader{
-				PacketNumber: 42,
-				Header:       wire.Header{Length: 123},
-			},
-			map[string]interface{}{
-				"packet_number":  "42",
-				"payload_length": 123,
-			},
-		)
-	})
-
-	It("marshals a header with a source connection ID", func() {
-		check(
-			&wire.ExtendedHeader{
-				PacketNumber: 42,
+	Context("determining the packet type", func() {
+		It("recognizes Initial packets", func() {
+			Expect(getPacketType(&wire.ExtendedHeader{
 				Header: wire.Header{
-					SrcConnectionID: protocol.ConnectionID{0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff},
+					IsLongHeader: true,
+					Type:         protocol.PacketTypeInitial,
+					Version:      protocol.VersionTLS,
 				},
-			},
-			map[string]interface{}{
-				"packet_number": "42",
-				"scil":          "16",
-				"scid":          "00112233445566778899aabbccddeeff",
-			},
-		)
+			})).To(Equal(packetTypeInitial))
+		})
+
+		It("recognizes Handshake packets", func() {
+			Expect(getPacketType(&wire.ExtendedHeader{
+				Header: wire.Header{
+					IsLongHeader: true,
+					Type:         protocol.PacketTypeHandshake,
+					Version:      protocol.VersionTLS,
+				},
+			})).To(Equal(packetTypeHandshake))
+		})
+
+		It("recognizes Retry packets", func() {
+			Expect(getPacketType(&wire.ExtendedHeader{
+				Header: wire.Header{
+					IsLongHeader: true,
+					Type:         protocol.PacketTypeRetry,
+					Version:      protocol.VersionTLS,
+				},
+			})).To(Equal(packetTypeRetry))
+		})
+
+		It("recognizes 0-RTT packets", func() {
+			Expect(getPacketType(&wire.ExtendedHeader{
+				Header: wire.Header{
+					IsLongHeader: true,
+					Type:         protocol.PacketType0RTT,
+					Version:      protocol.VersionTLS,
+				},
+			})).To(Equal(packetType0RTT))
+		})
+
+		It("recognizes Version Negotiation packets", func() {
+			Expect(getPacketType(&wire.ExtendedHeader{
+				Header: wire.Header{IsLongHeader: true},
+			})).To(Equal(packetTypeVersionNegotiation))
+		})
+
+		It("recognizes 1-RTT packets", func() {
+			Expect(getPacketType(&wire.ExtendedHeader{
+				Header: wire.Header{},
+			})).To(Equal(packetType1RTT))
+		})
 	})
 
-	It("marshals a header with a destination connection ID", func() {
-		check(
-			&wire.ExtendedHeader{
-				PacketNumber: 42,
-				Header:       wire.Header{DestConnectionID: protocol.ConnectionID{0xde, 0xad, 0xbe, 0xef}},
-			},
-			map[string]interface{}{
-				"packet_number": "42",
-				"dcil":          "4",
-				"dcid":          "deadbeef",
-			},
-		)
-	})
+	Context("marshalling", func() {
+		check := func(hdr *wire.ExtendedHeader, expected map[string]interface{}) {
+			buf := &bytes.Buffer{}
+			enc := gojay.NewEncoder(buf)
+			ExpectWithOffset(1, enc.Encode(transformHeader(hdr))).To(Succeed())
+			data := buf.Bytes()
+			ExpectWithOffset(1, json.Valid(data)).To(BeTrue())
+			checkEncoding(data, expected)
+		}
 
-	It("marshals a header with a version number", func() {
-		check(
-			&wire.ExtendedHeader{
-				PacketNumber: 42,
-				Header:       wire.Header{Version: protocol.VersionNumber(0xdecafbad)},
-			},
-			map[string]interface{}{
-				"packet_number": "42",
-				"version":       "decafbad",
-			},
-		)
+		It("marshals a header", func() {
+			check(
+				&wire.ExtendedHeader{PacketNumber: 42},
+				map[string]interface{}{
+					"packet_number": "42",
+				},
+			)
+		})
+
+		It("marshals a header with a payload length", func() {
+			check(
+				&wire.ExtendedHeader{
+					PacketNumber: 42,
+					Header:       wire.Header{Length: 123},
+				},
+				map[string]interface{}{
+					"packet_number":  "42",
+					"payload_length": 123,
+				},
+			)
+		})
+
+		It("marshals a header with a source connection ID", func() {
+			check(
+				&wire.ExtendedHeader{
+					PacketNumber: 42,
+					Header: wire.Header{
+						SrcConnectionID: protocol.ConnectionID{0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff},
+					},
+				},
+				map[string]interface{}{
+					"packet_number": "42",
+					"scil":          "16",
+					"scid":          "00112233445566778899aabbccddeeff",
+				},
+			)
+		})
+
+		It("marshals a header with a destination connection ID", func() {
+			check(
+				&wire.ExtendedHeader{
+					PacketNumber: 42,
+					Header:       wire.Header{DestConnectionID: protocol.ConnectionID{0xde, 0xad, 0xbe, 0xef}},
+				},
+				map[string]interface{}{
+					"packet_number": "42",
+					"dcil":          "4",
+					"dcid":          "deadbeef",
+				},
+			)
+		})
+
+		It("marshals a header with a version number", func() {
+			check(
+				&wire.ExtendedHeader{
+					PacketNumber: 42,
+					Header:       wire.Header{Version: protocol.VersionNumber(0xdecafbad)},
+				},
+				map[string]interface{}{
+					"packet_number": "42",
+					"version":       "decafbad",
+				},
+			)
+		})
 	})
 })

qlog/types.go

@@ -60,3 +60,33 @@ func (c category) String() string {
 		panic("unknown category")
 	}
 }
+
+type packetType protocol.PacketType
+
+const (
+	packetTypeInitial packetType = iota
+	packetTypeHandshake
+	packetTypeRetry
+	packetType0RTT
+	packetTypeVersionNegotiation
+	packetType1RTT
+)
+
+func (t packetType) String() string {
+	switch t {
+	case packetTypeInitial:
+		return "initial"
+	case packetTypeHandshake:
+		return "handshake"
+	case packetTypeRetry:
+		return "retry"
+	case packetType0RTT:
+		return "0RTT"
+	case packetTypeVersionNegotiation:
+		return "version_negotiation"
+	case packetType1RTT:
+		return "1RTT"
+	default:
+		panic("unknown packet type")
+	}
+}

qlog/types_test.go

@@ -12,4 +12,13 @@ var _ = Describe("Types", func() {
 		Expect(categoryRecovery.String()).To(Equal("recovery"))
 		Expect(categorySecurity.String()).To(Equal("security"))
 	})
+
+	It("has a string representation for the packet type", func() {
+		Expect(packetTypeInitial.String()).To(Equal("initial"))
+		Expect(packetTypeHandshake.String()).To(Equal("handshake"))
+		Expect(packetType0RTT.String()).To(Equal("0RTT"))
+		Expect(packetType1RTT.String()).To(Equal("1RTT"))
+		Expect(packetTypeRetry.String()).To(Equal("retry"))
+		Expect(packetTypeVersionNegotiation.String()).To(Equal("version_negotiation"))
+	})
 })