don't treat handshake retransmissions separately

packet_packer.go

@@ -167,13 +167,9 @@ func (p *packetPacker) MaybePackAckPacket() (*packedPacket, error) {
 // For packets sent after completion of the handshake, it might happen that 2 packets have to be sent.
 // This can happen e.g. when a longer packet number is used in the header.
 func (p *packetPacker) PackRetransmission(packet *ackhandler.Packet) ([]*packedPacket, error) {
-	if packet.EncryptionLevel != protocol.Encryption1RTT {
-		p, err := p.packHandshakeRetransmission(packet)
-		return []*packedPacket{p}, err
-	}
-
 	var controlFrames []wire.Frame
 	var streamFrames []*wire.StreamFrame
+	// TODO: treat CRYPTO frames separately
 	for _, f := range packet.Frames {
 		if sf, ok := f.(*wire.StreamFrame); ok {
 			sf.DataLenPresent = true
@@ -243,23 +239,6 @@ func (p *packetPacker) PackRetransmission(packet *ackhandler.Packet) ([]*packedP
 	return packets, nil
 }
 
-// packHandshakeRetransmission retransmits a handshake packet
-func (p *packetPacker) packHandshakeRetransmission(packet *ackhandler.Packet) (*packedPacket, error) {
-	sealer, err := p.cryptoSetup.GetSealerWithEncryptionLevel(packet.EncryptionLevel)
-	if err != nil {
-		return nil, err
-	}
-	header := p.getHeader(packet.EncryptionLevel)
-	header.Type = packet.PacketType
-	raw, err := p.writeAndSealPacket(header, packet.Frames, sealer)
-	return &packedPacket{
-		header:          header,
-		raw:             raw,
-		frames:          packet.Frames,
-		encryptionLevel: packet.EncryptionLevel,
-	}, err
-}
-
 // PackPacket packs a new packet
 // the other controlFrames are sent in the next packet, but might be queued and sent in the next packet if the packet would overflow MaxPacketSize otherwise
 func (p *packetPacker) PackPacket() (*packedPacket, error) {

packet_packer_test.go

@@ -748,40 +748,23 @@ var _ = Describe("Packet packer", func() {
 			sf := &wire.StreamFrame{Data: []byte("foobar")}
 
 			It("packs a retransmission with the right encryption level", func() {
+				f := &wire.CryptoFrame{Data: []byte("foo")}
 				pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
 				pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42))
 				sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.EncryptionInitial).Return(sealer, nil)
 				packet := &ackhandler.Packet{
 					PacketType:      protocol.PacketTypeHandshake,
 					EncryptionLevel: protocol.EncryptionInitial,
-					Frames:          []wire.Frame{sf},
+					Frames:          []wire.Frame{f},
 				}
 				p, err := packer.PackRetransmission(packet)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(p).To(HaveLen(1))
-				Expect(p[0].header.Type).To(Equal(protocol.PacketTypeHandshake))
-				Expect(p[0].frames).To(Equal([]wire.Frame{sf}))
+				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))
 			})
 
-			// this should never happen, since non forward-secure packets are limited to a size smaller than MaxPacketSize, such that it is always possible to retransmit them without splitting the StreamFrame
-			It("refuses to send a packet larger than MaxPacketSize", func() {
-				pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
-				sealingManager.EXPECT().GetSealerWithEncryptionLevel(gomock.Any()).Return(sealer, nil)
-				packet := &ackhandler.Packet{
-					EncryptionLevel: protocol.EncryptionHandshake,
-					Frames: []wire.Frame{
-						&wire.StreamFrame{
-							StreamID: 1,
-							Data:     bytes.Repeat([]byte{'f'}, int(maxPacketSize)),
-						},
-					},
-				}
-				_, err := packer.PackRetransmission(packet)
-				Expect(err).To(HaveOccurred())
-				Expect(err.Error()).To(ContainSubstring("PacketPacker BUG: packet too large"))
-			})
-
 			It("packs a retransmission for an Initial packet", func() {
 				pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
 				pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42))

session.go

@@ -903,12 +903,7 @@ func (s *session) maybeSendRetransmission() (bool, error) {
 		break
 	}
 
-	if retransmitPacket.EncryptionLevel != protocol.Encryption1RTT {
-		s.logger.Debugf("Dequeueing handshake retransmission for packet 0x%x", retransmitPacket.PacketNumber)
-	} else {
-		s.logger.Debugf("Dequeueing retransmission for packet 0x%x", retransmitPacket.PacketNumber)
-	}
-
+	s.logger.Debugf("Dequeueing retransmission for packet 0x%x", retransmitPacket.PacketNumber)
 	packets, err := s.packer.PackRetransmission(retransmitPacket)
 	if err != nil {
 		return false, err