remove the encryption level from the packed packet struct

This was only needed in gQUIC. In IETF QUIC, We can always derive the
encryption level from the header type when needed.

packet_packer.go

@@ -25,10 +25,23 @@ type packer interface {
 }
 
 type packedPacket struct {
-	header          *wire.ExtendedHeader
-	raw             []byte
-	frames          []wire.Frame
-	encryptionLevel protocol.EncryptionLevel
+	header *wire.ExtendedHeader
+	raw    []byte
+	frames []wire.Frame
+}
+
+func (p *packedPacket) EncryptionLevel() protocol.EncryptionLevel {
+	if !p.header.IsLongHeader {
+		return protocol.Encryption1RTT
+	}
+	switch p.header.Type {
+	case protocol.PacketTypeInitial:
+		return protocol.EncryptionInitial
+	case protocol.PacketTypeHandshake:
+		return protocol.EncryptionHandshake
+	default:
+		return protocol.EncryptionUnspecified
+	}
 }
 
 func (p *packedPacket) ToAckHandlerPacket() *ackhandler.Packet {
@@ -37,7 +50,7 @@ func (p *packedPacket) ToAckHandlerPacket() *ackhandler.Packet {
 		PacketType:      p.header.Type,
 		Frames:          p.frames,
 		Length:          protocol.ByteCount(len(p.raw)),
-		EncryptionLevel: p.encryptionLevel,
+		EncryptionLevel: p.EncryptionLevel(),
 		SendTime:        time.Now(),
 	}
 }
@@ -138,10 +151,9 @@ func (p *packetPacker) PackConnectionClose(ccf *wire.ConnectionCloseFrame) (*pac
 	header := p.getHeader(encLevel)
 	raw, err := p.writeAndSealPacket(header, frames, sealer)
 	return &packedPacket{
-		header:          header,
-		raw:             raw,
-		frames:          frames,
-		encryptionLevel: encLevel,
+		header: header,
+		raw:    raw,
+		frames: frames,
 	}, err
 }
 
@@ -156,10 +168,9 @@ func (p *packetPacker) MaybePackAckPacket() (*packedPacket, error) {
 	frames := []wire.Frame{ack}
 	raw, err := p.writeAndSealPacket(header, frames, sealer)
 	return &packedPacket{
-		header:          header,
-		raw:             raw,
-		frames:          frames,
-		encryptionLevel: encLevel,
+		header: header,
+		raw:    raw,
+		frames: frames,
 	}, err
 }
 
@@ -232,10 +243,9 @@ func (p *packetPacker) PackRetransmission(packet *ackhandler.Packet) ([]*packedP
 			return nil, err
 		}
 		packets = append(packets, &packedPacket{
-			header:          header,
-			raw:             raw,
-			frames:          frames,
-			encryptionLevel: encLevel,
+			header: header,
+			raw:    raw,
+			frames: frames,
 		})
 	}
 	return packets, nil
@@ -286,10 +296,9 @@ func (p *packetPacker) PackPacket() (*packedPacket, error) {
 		return nil, err
 	}
 	return &packedPacket{
-		header:          header,
-		raw:             raw,
-		frames:          frames,
-		encryptionLevel: encLevel,
+		header: header,
+		raw:    raw,
+		frames: frames,
 	}, nil
 }
 
@@ -325,10 +334,9 @@ func (p *packetPacker) maybePackCryptoPacket() (*packedPacket, error) {
 		return nil, err
 	}
 	return &packedPacket{
-		header:          hdr,
-		raw:             raw,
-		frames:          frames,
-		encryptionLevel: encLevel,
+		header: hdr,
+		raw:    raw,
+		frames: frames,
 	}, nil
 }
 

packet_packer_test.go

@@ -253,7 +253,7 @@ var _ = Describe("Packet packer", func() {
 				})
 				p, err := packer.PackPacket()
 				Expect(err).ToNot(HaveOccurred())
-				Expect(p.encryptionLevel).To(Equal(protocol.Encryption1RTT))
+				Expect(p.EncryptionLevel()).To(Equal(protocol.Encryption1RTT))
 			})
 
 			It("packs a single ACK", func() {
@@ -494,7 +494,7 @@ var _ = Describe("Packet packer", func() {
 					Expect(err).ToNot(HaveOccurred())
 					Expect(packets).To(HaveLen(1))
 					p := packets[0]
-					Expect(p.encryptionLevel).To(Equal(protocol.Encryption1RTT))
+					Expect(p.EncryptionLevel()).To(Equal(protocol.Encryption1RTT))
 					Expect(p.frames).To(Equal(frames))
 				})
 
@@ -846,7 +846,7 @@ var _ = Describe("Packet packer", func() {
 					Expect(p).To(HaveLen(1))
 					Expect(p[0].header.Type).To(Equal(protocol.PacketTypeInitial))
 					Expect(p[0].frames).To(Equal([]wire.Frame{f}))
-					Expect(p[0].encryptionLevel).To(Equal(protocol.EncryptionInitial))
+					Expect(p[0].EncryptionLevel()).To(Equal(protocol.EncryptionInitial))
 				})
 
 				It("packs a retransmission for an Initial packet", func() {
@@ -864,7 +864,7 @@ var _ = Describe("Packet packer", func() {
 					Expect(packets).To(HaveLen(1))
 					p := packets[0]
 					Expect(p.frames).To(Equal([]wire.Frame{sf}))
-					Expect(p.encryptionLevel).To(Equal(protocol.EncryptionInitial))
+					Expect(p.EncryptionLevel()).To(Equal(protocol.EncryptionInitial))
 					Expect(p.header.Type).To(Equal(protocol.PacketTypeInitial))
 					Expect(p.header.Token).To(Equal(token))
 					Expect(p.raw).To(HaveLen(protocol.MinInitialPacketSize))

session.go

@@ -976,7 +976,7 @@ func (s *session) logPacket(packet *packedPacket) {
 		// We don't need to allocate the slices for calling the format functions
 		return
 	}
-	s.logger.Debugf("-> Sending packet 0x%x (%d bytes) for connection %s, %s", packet.header.PacketNumber, len(packet.raw), s.srcConnID, packet.encryptionLevel)
+	s.logger.Debugf("-> Sending packet 0x%x (%d bytes) for connection %s, %s", packet.header.PacketNumber, len(packet.raw), s.srcConnID, packet.EncryptionLevel())
 	packet.header.Log(s.logger)
 	for _, frame := range packet.frames {
 		wire.LogFrame(s.logger, frame, true)