Add packer.SetLeastUnacked and remove the parameter from the Pack* functions

2017-06-20 14:11:19 +02:00
parent 4064c75d97
commit efc9ec5051
3 changed files with 66 additions and 56 deletions
--- a/packet_packer.go
+++ b/packet_packer.go
@@ -30,6 +30,7 @@ type packetPacker struct {

 	controlFrames []frames.Frame
 	stopWaiting   *frames.StopWaitingFrame
+	leastUnacked  protocol.PacketNumber
 }

 func newPacketPacker(connectionID protocol.ConnectionID,
@@ -51,10 +52,10 @@ func newPacketPacker(connectionID protocol.ConnectionID,
 }

 // PackConnectionClose packs a packet that ONLY contains a ConnectionCloseFrame
-func (p *packetPacker) PackConnectionClose(ccf *frames.ConnectionCloseFrame, leastUnacked protocol.PacketNumber) (*packedPacket, error) {
+func (p *packetPacker) PackConnectionClose(ccf *frames.ConnectionCloseFrame) (*packedPacket, error) {
 	frames := []frames.Frame{ccf}
 	encLevel, sealer := p.cryptoSetup.GetSealer()
-	ph := p.getPublicHeader(leastUnacked, encLevel)
+	ph := p.getPublicHeader(encLevel)
 	raw, err := p.writeAndSealPacket(ph, frames, sealer)
 	return &packedPacket{
 		number:          ph.PacketNumber,
@@ -64,9 +65,9 @@ func (p *packetPacker) PackConnectionClose(ccf *frames.ConnectionCloseFrame, lea
 	}, err
 }

-func (p *packetPacker) PackAckPacket(leastUnacked protocol.PacketNumber, ackframe *frames.AckFrame) (*packedPacket, error) {
+func (p *packetPacker) PackAckPacket(ackframe *frames.AckFrame) (*packedPacket, error) {
 	encLevel, sealer := p.cryptoSetup.GetSealer()
-	ph := p.getPublicHeader(leastUnacked, encLevel)
+	ph := p.getPublicHeader(encLevel)
 	frames := []frames.Frame{ackframe}
 	if p.stopWaiting != nil {
 		p.stopWaiting.PacketNumber = ph.PacketNumber
@@ -95,7 +96,7 @@ func (p *packetPacker) RetransmitNonForwardSecurePacket(packet *ackhandler.Packe
 	if p.stopWaiting == nil {
 		return nil, errors.New("PacketPacker BUG: Handshake retransmissions must contain a StopWaitingFrame")
 	}
-	ph := p.getPublicHeader(0, packet.EncryptionLevel)
+	ph := p.getPublicHeader(packet.EncryptionLevel)
 	p.stopWaiting.PacketNumber = ph.PacketNumber
 	p.stopWaiting.PacketNumberLen = ph.PacketNumberLen
 	frames := append([]frames.Frame{p.stopWaiting}, packet.Frames...)
@@ -111,14 +112,14 @@ func (p *packetPacker) RetransmitNonForwardSecurePacket(packet *ackhandler.Packe

 // 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(leastUnacked protocol.PacketNumber) (*packedPacket, error) {
+func (p *packetPacker) PackPacket() (*packedPacket, error) {
 	if p.streamFramer.HasCryptoStreamFrame() {
-		return p.packCryptoPacket(leastUnacked)
+		return p.packCryptoPacket()
 	}

 	encLevel, sealer := p.cryptoSetup.GetSealer()

-	publicHeader := p.getPublicHeader(leastUnacked, encLevel)
+	publicHeader := p.getPublicHeader(encLevel)
 	publicHeaderLength, err := publicHeader.GetLength(p.perspective)
 	if err != nil {
 		return nil, err
@@ -156,9 +157,9 @@ func (p *packetPacker) PackPacket(leastUnacked protocol.PacketNumber) (*packedPa
 	}, nil
 }

-func (p *packetPacker) packCryptoPacket(leastUnacked protocol.PacketNumber) (*packedPacket, error) {
+func (p *packetPacker) packCryptoPacket() (*packedPacket, error) {
 	encLevel, sealer := p.cryptoSetup.GetSealerForCryptoStream()
-	publicHeader := p.getPublicHeader(leastUnacked, encLevel)
+	publicHeader := p.getPublicHeader(encLevel)
 	publicHeaderLength, err := publicHeader.GetLength(p.perspective)
 	if err != nil {
 		return nil, err
@@ -239,9 +240,9 @@ func (p *packetPacker) QueueControlFrameForNextPacket(f frames.Frame) {
 	}
 }

-func (p *packetPacker) getPublicHeader(leastUnacked protocol.PacketNumber, encLevel protocol.EncryptionLevel) *PublicHeader {
+func (p *packetPacker) getPublicHeader(encLevel protocol.EncryptionLevel) *PublicHeader {
 	pnum := p.packetNumberGenerator.Peek()
-	packetNumberLen := protocol.GetPacketNumberLengthForPublicHeader(pnum, leastUnacked)
+	packetNumberLen := protocol.GetPacketNumberLengthForPublicHeader(pnum, p.leastUnacked)
 	publicHeader := &PublicHeader{
 		ConnectionID:         p.connectionID,
 		PacketNumber:         pnum,
@@ -300,3 +301,7 @@ func (p *packetPacker) canSendData(encLevel protocol.EncryptionLevel) bool {
 	}
 	return encLevel == protocol.EncryptionForwardSecure
 }
+
+func (p *packetPacker) SetLeastUnacked(leastUnacked protocol.PacketNumber) {
+	p.leastUnacked = leastUnacked
+}
--- a/packet_packer_test.go
+++ b/packet_packer_test.go
@@ -80,7 +80,7 @@ var _ = Describe("Packet packer", func() {
 	})

 	It("returns nil when no packet is queued", func() {
-		p, err := packer.PackPacket(0)
+		p, err := packer.PackPacket()
 		Expect(p).To(BeNil())
 		Expect(err).ToNot(HaveOccurred())
 	})
@@ -91,7 +91,7 @@ var _ = Describe("Packet packer", func() {
 			Data:     []byte{0xDE, 0xCA, 0xFB, 0xAD},
 		}
 		streamFramer.AddFrameForRetransmission(f)
-		p, err := packer.PackPacket(0)
+		p, err := packer.PackPacket()
 		Expect(err).ToNot(HaveOccurred())
 		Expect(p).ToNot(BeNil())
 		b := &bytes.Buffer{}
@@ -107,7 +107,7 @@ var _ = Describe("Packet packer", func() {
 			Data:     []byte("foobar"),
 		}
 		streamFramer.AddFrameForRetransmission(f)
-		p, err := packer.PackPacket(0)
+		p, err := packer.PackPacket()
 		Expect(err).ToNot(HaveOccurred())
 		Expect(p.encryptionLevel).To(Equal(protocol.EncryptionForwardSecure))
 	})
@@ -121,23 +121,23 @@ var _ = Describe("Packet packer", func() {
 		})

 		It("doesn't include a div nonce, when sending a packet with initial encryption", func() {
-			ph := packer.getPublicHeader(1, protocol.EncryptionUnencrypted)
+			ph := packer.getPublicHeader(protocol.EncryptionUnencrypted)
 			Expect(ph.DiversificationNonce).To(BeEmpty())
 		})

 		It("includes a div nonce, when sending a packet with secure encryption", func() {
-			ph := packer.getPublicHeader(1, protocol.EncryptionSecure)
+			ph := packer.getPublicHeader(protocol.EncryptionSecure)
 			Expect(ph.DiversificationNonce).To(Equal(nonce))
 		})

 		It("doesn't include a div nonce, when sending a packet with forward-secure encryption", func() {
-			ph := packer.getPublicHeader(1, protocol.EncryptionForwardSecure)
+			ph := packer.getPublicHeader(protocol.EncryptionForwardSecure)
 			Expect(ph.DiversificationNonce).To(BeEmpty())
 		})

 		It("doesn't send a div nonce as a client", func() {
 			packer.perspective = protocol.PerspectiveClient
-			ph := packer.getPublicHeader(1, protocol.EncryptionSecure)
+			ph := packer.getPublicHeader(protocol.EncryptionSecure)
 			Expect(ph.DiversificationNonce).To(BeEmpty())
 		})
 	})
@@ -147,7 +147,7 @@ var _ = Describe("Packet packer", func() {
 			ErrorCode:    0x1337,
 			ReasonPhrase: "foobar",
 		}
-		p, err := packer.PackConnectionClose(&ccf, 0)
+		p, err := packer.PackConnectionClose(&ccf)
 		Expect(err).ToNot(HaveOccurred())
 		Expect(p.frames).To(HaveLen(1))
 		Expect(p.frames[0]).To(Equal(&ccf))
@@ -163,7 +163,7 @@ var _ = Describe("Packet packer", func() {
 			StreamID: 5,
 			Data:     []byte("foobar"),
 		})
-		p, err := packer.PackConnectionClose(&ccf, 0)
+		p, err := packer.PackConnectionClose(&ccf)
 		Expect(err).ToNot(HaveOccurred())
 		Expect(p.frames).To(HaveLen(1))
 		Expect(p.frames[0]).To(Equal(&ccf))
@@ -172,7 +172,7 @@ var _ = Describe("Packet packer", func() {
 	It("packs only control frames", func() {
 		packer.QueueControlFrameForNextPacket(&frames.RstStreamFrame{})
 		packer.QueueControlFrameForNextPacket(&frames.WindowUpdateFrame{})
-		p, err := packer.PackPacket(0)
+		p, err := packer.PackPacket()
 		Expect(p).ToNot(BeNil())
 		Expect(err).ToNot(HaveOccurred())
 		Expect(p.frames).To(HaveLen(2))
@@ -181,11 +181,11 @@ var _ = Describe("Packet packer", func() {

 	It("increases the packet number", func() {
 		packer.QueueControlFrameForNextPacket(&frames.RstStreamFrame{})
-		p1, err := packer.PackPacket(0)
+		p1, err := packer.PackPacket()
 		Expect(err).ToNot(HaveOccurred())
 		Expect(p1).ToNot(BeNil())
 		packer.QueueControlFrameForNextPacket(&frames.RstStreamFrame{})
-		p2, err := packer.PackPacket(0)
+		p2, err := packer.PackPacket()
 		Expect(err).ToNot(HaveOccurred())
 		Expect(p2).ToNot(BeNil())
 		Expect(p2.number).To(BeNumerically(">", p1.number))
@@ -196,7 +196,7 @@ var _ = Describe("Packet packer", func() {
 		swf := &frames.StopWaitingFrame{LeastUnacked: 10}
 		packer.QueueControlFrameForNextPacket(&frames.RstStreamFrame{})
 		packer.QueueControlFrameForNextPacket(swf)
-		p, err := packer.PackPacket(0)
+		p, err := packer.PackPacket()
 		Expect(err).ToNot(HaveOccurred())
 		Expect(p).ToNot(BeNil())
 		Expect(p.frames).To(HaveLen(2))
@@ -209,7 +209,7 @@ var _ = Describe("Packet packer", func() {
 		swf := &frames.StopWaitingFrame{LeastUnacked: packetNumber - 0x100}
 		packer.QueueControlFrameForNextPacket(&frames.RstStreamFrame{})
 		packer.QueueControlFrameForNextPacket(swf)
-		p, err := packer.PackPacket(0)
+		p, err := packer.PackPacket()
 		Expect(err).ToNot(HaveOccurred())
 		Expect(p.frames[0].(*frames.StopWaitingFrame).PacketNumberLen).To(Equal(protocol.PacketNumberLen4))
 	})
@@ -217,14 +217,14 @@ var _ = Describe("Packet packer", func() {
 	It("does not pack a packet containing only a StopWaitingFrame", func() {
 		swf := &frames.StopWaitingFrame{LeastUnacked: 10}
 		packer.QueueControlFrameForNextPacket(swf)
-		p, err := packer.PackPacket(0)
+		p, err := packer.PackPacket()
 		Expect(p).To(BeNil())
 		Expect(err).ToNot(HaveOccurred())
 	})

 	It("packs a packet if it has queued control frames, but no new control frames", func() {
 		packer.controlFrames = []frames.Frame{&frames.BlockedFrame{StreamID: 0}}
-		p, err := packer.PackPacket(0)
+		p, err := packer.PackPacket()
 		Expect(err).ToNot(HaveOccurred())
 		Expect(p).ToNot(BeNil())
 	})
@@ -235,7 +235,7 @@ var _ = Describe("Packet packer", func() {
 		packer.controlFrames = []frames.Frame{&frames.BlockedFrame{StreamID: 0}}
 		packer.connectionID = 0x1337
 		packer.version = 123
-		p, err := packer.PackPacket(0)
+		p, err := packer.PackPacket()
 		Expect(err).ToNot(HaveOccurred())
 		Expect(p).ToNot(BeNil())
 		hdr, err := ParsePublicHeader(bytes.NewReader(p.raw), protocol.PerspectiveClient)
@@ -249,7 +249,7 @@ var _ = Describe("Packet packer", func() {
 		packer.cryptoSetup.(*mockCryptoSetup).encLevelSeal = protocol.EncryptionForwardSecure
 		packer.controlFrames = []frames.Frame{&frames.BlockedFrame{StreamID: 0}}
 		packer.connectionID = 0x1337
-		p, err := packer.PackPacket(0)
+		p, err := packer.PackPacket()
 		Expect(err).ToNot(HaveOccurred())
 		Expect(p).ToNot(BeNil())
 		hdr, err := ParsePublicHeader(bytes.NewReader(p.raw), protocol.PerspectiveClient)
@@ -296,7 +296,7 @@ var _ = Describe("Packet packer", func() {

 	It("only increases the packet number when there is an actual packet to send", func() {
 		packer.packetNumberGenerator.nextToSkip = 1000
-		p, err := packer.PackPacket(0)
+		p, err := packer.PackPacket()
 		Expect(p).To(BeNil())
 		Expect(err).ToNot(HaveOccurred())
 		Expect(packer.packetNumberGenerator.Peek()).To(Equal(protocol.PacketNumber(1)))
@@ -305,7 +305,7 @@ var _ = Describe("Packet packer", func() {
 			Data:     []byte{0xDE, 0xCA, 0xFB, 0xAD},
 		}
 		streamFramer.AddFrameForRetransmission(f)
-		p, err = packer.PackPacket(0)
+		p, err = packer.PackPacket()
 		Expect(err).ToNot(HaveOccurred())
 		Expect(p).ToNot(BeNil())
 		Expect(p.number).To(Equal(protocol.PacketNumber(1)))
@@ -346,12 +346,12 @@ var _ = Describe("Packet packer", func() {
 			}
 			streamFramer.AddFrameForRetransmission(f1)
 			streamFramer.AddFrameForRetransmission(f2)
-			p, err := packer.PackPacket(0)
+			p, err := packer.PackPacket()
 			Expect(err).ToNot(HaveOccurred())
 			Expect(p.raw).To(HaveLen(int(protocol.MaxPacketSize - 1)))
 			Expect(p.frames).To(HaveLen(1))
 			Expect(p.frames[0].(*frames.StreamFrame).DataLenPresent).To(BeFalse())
-			p, err = packer.PackPacket(0)
+			p, err = packer.PackPacket()
 			Expect(err).ToNot(HaveOccurred())
 			Expect(p.frames).To(HaveLen(1))
 			Expect(p.frames[0].(*frames.StreamFrame).DataLenPresent).To(BeFalse())
@@ -373,7 +373,7 @@ var _ = Describe("Packet packer", func() {
 			streamFramer.AddFrameForRetransmission(f1)
 			streamFramer.AddFrameForRetransmission(f2)
 			streamFramer.AddFrameForRetransmission(f3)
-			p, err := packer.PackPacket(0)
+			p, err := packer.PackPacket()
 			Expect(p).ToNot(BeNil())
 			Expect(err).ToNot(HaveOccurred())
 			b := &bytes.Buffer{}
@@ -427,23 +427,23 @@ var _ = Describe("Packet packer", func() {
 			}
 			streamFramer.AddFrameForRetransmission(f1)
 			streamFramer.AddFrameForRetransmission(f2)
-			p, err := packer.PackPacket(0)
+			p, err := packer.PackPacket()
 			Expect(err).ToNot(HaveOccurred())
 			Expect(p.frames).To(HaveLen(1))
 			Expect(p.frames[0].(*frames.StreamFrame).DataLenPresent).To(BeFalse())
 			Expect(p.raw).To(HaveLen(int(protocol.MaxPacketSize)))
-			p, err = packer.PackPacket(0)
+			p, err = packer.PackPacket()
 			Expect(p.frames).To(HaveLen(2))
 			Expect(p.frames[0].(*frames.StreamFrame).DataLenPresent).To(BeTrue())
 			Expect(p.frames[1].(*frames.StreamFrame).DataLenPresent).To(BeFalse())
 			Expect(err).ToNot(HaveOccurred())
 			Expect(p.raw).To(HaveLen(int(protocol.MaxPacketSize)))
-			p, err = packer.PackPacket(0)
+			p, err = packer.PackPacket()
 			Expect(p.frames).To(HaveLen(1))
 			Expect(p.frames[0].(*frames.StreamFrame).DataLenPresent).To(BeFalse())
 			Expect(err).ToNot(HaveOccurred())
 			Expect(p).ToNot(BeNil())
-			p, err = packer.PackPacket(0)
+			p, err = packer.PackPacket()
 			Expect(err).ToNot(HaveOccurred())
 			Expect(p).To(BeNil())
 		})
@@ -456,7 +456,7 @@ var _ = Describe("Packet packer", func() {
 			minLength, _ := f.MinLength(0)
 			f.Data = bytes.Repeat([]byte{'f'}, int(protocol.MaxFrameAndPublicHeaderSize-publicHeaderLen-minLength+1)) // + 1 since MinceLength is 1 bigger than the actual StreamFrame header
 			streamFramer.AddFrameForRetransmission(f)
-			p, err := packer.PackPacket(0)
+			p, err := packer.PackPacket()
 			Expect(err).ToNot(HaveOccurred())
 			Expect(p).ToNot(BeNil())
 			Expect(p.raw).To(HaveLen(int(protocol.MaxPacketSize)))
@@ -486,7 +486,7 @@ var _ = Describe("Packet packer", func() {
 				Data:     []byte("foobar"),
 			}
 			streamFramer.AddFrameForRetransmission(f)
-			p, err := packer.PackPacket(0)
+			p, err := packer.PackPacket()
 			Expect(err).NotTo(HaveOccurred())
 			Expect(p).To(BeNil())
 		})
@@ -499,7 +499,7 @@ var _ = Describe("Packet packer", func() {
 				Data:     []byte("foobar"),
 			}
 			streamFramer.AddFrameForRetransmission(f)
-			p, err := packer.PackPacket(0)
+			p, err := packer.PackPacket()
 			Expect(err).ToNot(HaveOccurred())
 			Expect(p.encryptionLevel).To(Equal(protocol.EncryptionSecure))
 			Expect(p.frames[0]).To(Equal(f))
@@ -512,7 +512,7 @@ var _ = Describe("Packet packer", func() {
 				Data:     []byte("foobar"),
 			}
 			streamFramer.AddFrameForRetransmission(f)
-			p, err := packer.PackPacket(0)
+			p, err := packer.PackPacket()
 			Expect(err).ToNot(HaveOccurred())
 			Expect(p).To(BeNil())
 		})
@@ -520,7 +520,7 @@ var _ = Describe("Packet packer", func() {
 		It("sends unencrypted stream data on the crypto stream", func() {
 			packer.cryptoSetup.(*mockCryptoSetup).encLevelSealCrypto = protocol.EncryptionUnencrypted
 			cryptoStream.dataForWriting = []byte("foobar")
-			p, err := packer.PackPacket(0)
+			p, err := packer.PackPacket()
 			Expect(err).ToNot(HaveOccurred())
 			Expect(p.encryptionLevel).To(Equal(protocol.EncryptionUnencrypted))
 			Expect(p.frames).To(HaveLen(1))
@@ -530,7 +530,7 @@ var _ = Describe("Packet packer", func() {
 		It("sends encrypted stream data on the crypto stream", func() {
 			packer.cryptoSetup.(*mockCryptoSetup).encLevelSealCrypto = protocol.EncryptionSecure
 			cryptoStream.dataForWriting = []byte("foobar")
-			p, err := packer.PackPacket(0)
+			p, err := packer.PackPacket()
 			Expect(err).ToNot(HaveOccurred())
 			Expect(p.encryptionLevel).To(Equal(protocol.EncryptionSecure))
 			Expect(p.frames).To(HaveLen(1))
@@ -541,7 +541,7 @@ var _ = Describe("Packet packer", func() {
 			packer.cryptoSetup.(*mockCryptoSetup).encLevelSeal = protocol.EncryptionUnencrypted
 			packer.QueueControlFrameForNextPacket(&frames.AckFrame{})
 			streamFramer.AddFrameForRetransmission(&frames.StreamFrame{StreamID: 3, Data: []byte("foobar")})
-			p, err := packer.PackPacket(0)
+			p, err := packer.PackPacket()
 			Expect(err).ToNot(HaveOccurred())
 			Expect(p.frames).To(HaveLen(1))
 			Expect(func() { _ = p.frames[0].(*frames.AckFrame) }).NotTo(Panic())
@@ -591,7 +591,7 @@ var _ = Describe("Packet packer", func() {

 	It("returns nil if we only have a single STOP_WAITING", func() {
 		packer.QueueControlFrameForNextPacket(&frames.StopWaitingFrame{})
-		p, err := packer.PackPacket(0)
+		p, err := packer.PackPacket()
 		Expect(err).NotTo(HaveOccurred())
 		Expect(p).To(BeNil())
 	})
@@ -599,7 +599,7 @@ var _ = Describe("Packet packer", func() {
 	It("packs a single ACK", func() {
 		ack := &frames.AckFrame{LargestAcked: 42}
 		packer.QueueControlFrameForNextPacket(ack)
-		p, err := packer.PackPacket(0)
+		p, err := packer.PackPacket()
 		Expect(err).NotTo(HaveOccurred())
 		Expect(p).ToNot(BeNil())
 		Expect(p.frames[0]).To(Equal(ack))
@@ -608,7 +608,7 @@ var _ = Describe("Packet packer", func() {
 	It("does not return nil if we only have a single ACK but request it to be sent", func() {
 		ack := &frames.AckFrame{}
 		packer.QueueControlFrameForNextPacket(ack)
-		p, err := packer.PackPacket(0)
+		p, err := packer.PackPacket()
 		Expect(err).NotTo(HaveOccurred())
 		Expect(p).ToNot(BeNil())
 	})
@@ -616,7 +616,7 @@ var _ = Describe("Packet packer", func() {
 	It("queues a control frame to be sent in the next packet", func() {
 		wuf := &frames.WindowUpdateFrame{StreamID: 5}
 		packer.QueueControlFrameForNextPacket(wuf)
-		p, err := packer.PackPacket(0)
+		p, err := packer.PackPacket()
 		Expect(err).NotTo(HaveOccurred())
 		Expect(p.frames).To(HaveLen(1))
 		Expect(p.frames[0]).To(Equal(wuf))
@@ -707,14 +707,14 @@ var _ = Describe("Packet packer", func() {

 	Context("packing ACK packets", func() {
 		It("packs ACK packets", func() {
-			p, err := packer.PackAckPacket(0, &frames.AckFrame{})
+			p, err := packer.PackAckPacket(&frames.AckFrame{})
 			Expect(err).NotTo(HaveOccurred())
 			Expect(p.frames).To(Equal([]frames.Frame{&frames.AckFrame{DelayTime: math.MaxInt64}}))
 		})

 		It("packs ACK packets with SWFs", func() {
 			packer.QueueControlFrameForNextPacket(&frames.StopWaitingFrame{})
-			p, err := packer.PackAckPacket(0, &frames.AckFrame{})
+			p, err := packer.PackAckPacket(&frames.AckFrame{})
 			Expect(err).NotTo(HaveOccurred())
 			Expect(p.frames).To(Equal([]frames.Frame{
 				&frames.AckFrame{DelayTime: math.MaxInt64},
--- a/session.go
+++ b/session.go
@@ -562,13 +562,14 @@ func (s *session) handleCloseError(closeErr closeError) error {
 }

 func (s *session) sendPacket() error {
+	s.packer.SetLeastUnacked(s.sentPacketHandler.GetLeastUnacked())
+
 	// Get WindowUpdate frames
 	// this call triggers the flow controller to increase the flow control windows, if necessary
 	windowUpdateFrames := s.getWindowUpdateFrames()
 	for _, wuf := range windowUpdateFrames {
 		s.packer.QueueControlFrameForNextPacket(wuf)
 	}
-
 	// Repeatedly try sending until we don't have any more data, or run out of the congestion window
 	for {
 		if !s.sentPacketHandler.SendingAllowed() {
@@ -581,7 +582,7 @@ func (s *session) sendPacket() error {
 			if swf != nil {
 				s.packer.QueueControlFrameForNextPacket(swf)
 			}
-			packet, err := s.packer.PackAckPacket(s.sentPacketHandler.GetLeastUnacked(), ack)
+			packet, err := s.packer.PackAckPacket(ack)
 			if err != nil {
 				return err
 			}
@@ -640,7 +641,7 @@ func (s *session) sendPacket() error {
 				s.packer.QueueControlFrameForNextPacket(swf)
 			}
 		}
-		packet, err := s.packer.PackPacket(s.sentPacketHandler.GetLeastUnacked())
+		packet, err := s.packer.PackPacket()
 		if err != nil || packet == nil {
 			return err
 		}
@@ -676,7 +677,11 @@ func (s *session) sendPackedPacket(packet *packedPacket) error {
 }

 func (s *session) sendConnectionClose(quicErr *qerr.QuicError) error {
-	packet, err := s.packer.PackConnectionClose(&frames.ConnectionCloseFrame{ErrorCode: quicErr.ErrorCode, ReasonPhrase: quicErr.ErrorMessage}, s.sentPacketHandler.GetLeastUnacked())
+	s.packer.SetLeastUnacked(s.sentPacketHandler.GetLeastUnacked())
+	packet, err := s.packer.PackConnectionClose(&frames.ConnectionCloseFrame{
+		ErrorCode:    quicErr.ErrorCode,
+		ReasonPhrase: quicErr.ErrorMessage,
+	})
 	if err != nil {
 		return err
 	}