gr1ffon/quic-go
1
0
Fork 0
forked from quic-go/quic-go
Code Pull Requests Activity

Merge pull request #321 from lucas-clemente/fix-150

Browse Source 
Fix 150
This commit is contained in:
Lucas Clemente
2016-09-07 18:29:43 +02:00
committed by GitHub
parent aa645301c6 6f4955d2d0
commit 2ca0fb7d21
8 changed files with 85 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
ackhandler/interfaces.go
View File

@@ -10,7 +10,7 @@ import (
// SentPacketHandler handles ACKs received for outgoing packets
type SentPacketHandler interface {
SentPacket(packet *Packet) error
ReceivedAck(ackFrame *frames.AckFrame, withPacketNumber protocol.PacketNumber) error
ReceivedAck(ackFrame *frames.AckFrame, withPacketNumber protocol.PacketNumber, recvTime time.Time) error
GetStopWaitingFrame(force bool) *frames.StopWaitingFrame

13
ackhandler/sent_packet_handler.go
View File

@@ -130,7 +130,7 @@ func (h *sentPacketHandler) SentPacket(packet *Packet) error {
h.packetHistory.PushBack(*packet)
h.congestion.OnPacketSent(
time.Now(),
now,
h.BytesInFlight(),
packet.PacketNumber,
packet.Length,
@@ -140,7 +140,7 @@ func (h *sentPacketHandler) SentPacket(packet *Packet) error {
return nil
}
func (h *sentPacketHandler) ReceivedAck(ackFrame *frames.AckFrame, withPacketNumber protocol.PacketNumber) error {
func (h *sentPacketHandler) ReceivedAck(ackFrame *frames.AckFrame, withPacketNumber protocol.PacketNumber, rcvTime time.Time) error {
if ackFrame.LargestAcked > h.lastSentPacketNumber {
return errAckForUnsentPacket
}
@@ -169,6 +169,7 @@ func (h *sentPacketHandler) ReceivedAck(ackFrame *frames.AckFrame, withPacketNum
var ackedPackets congestion.PacketVector
var lostPackets congestion.PacketVector
ackRangeIndex := 0
rttUpdated := false
var el, elNext *PacketElement
for el = h.packetHistory.Front(); el != nil; el = elNext {
@@ -188,9 +189,9 @@ func (h *sentPacketHandler) ReceivedAck(ackFrame *frames.AckFrame, withPacketNum
// Update the RTT
if packetNumber == h.LargestAcked {
timeDelta := time.Now().Sub(packet.SendTime)
// TODO: Don't always update RTT
h.rttStats.UpdateRTT(timeDelta, ackFrame.DelayTime, time.Now())
rttUpdated = true
timeDelta := rcvTime.Sub(packet.SendTime)
h.rttStats.UpdateRTT(timeDelta, ackFrame.DelayTime, rcvTime)
if utils.Debug() {
utils.Debugf("\tEstimated RTT: %dms", h.rttStats.SmoothedRTT()/time.Millisecond)
}
@@ -231,7 +232,7 @@ func (h *sentPacketHandler) ReceivedAck(ackFrame *frames.AckFrame, withPacketNum
h.stopWaitingManager.ReceivedAck(ackFrame)
h.congestion.OnCongestionEvent(
true, /* TODO: rtt updated */
rttUpdated,
h.BytesInFlight(),
ackedPackets,
lostPackets,

58
ackhandler/sent_packet_handler_test.go
View File

@@ -255,10 +255,10 @@ var _ = Describe("SentPacketHandler", func() {
LargestAcked: protocol.PacketNumber(largestAcked),
LowestAcked: 1,
}
err := handler.ReceivedAck(&ack, 1337)
err := handler.ReceivedAck(&ack, 1337, time.Now())
Expect(err).ToNot(HaveOccurred())
Expect(handler.BytesInFlight()).To(Equal(protocol.ByteCount(len(packets) - 3)))
err = handler.ReceivedAck(&ack, 1337)
err = handler.ReceivedAck(&ack, 1337, time.Now())
Expect(err).To(MatchError(ErrDuplicateOrOutOfOrderAck))
Expect(handler.BytesInFlight()).To(Equal(protocol.ByteCount(len(packets) - 3)))
})
@@ -267,10 +267,10 @@ var _ = Describe("SentPacketHandler", func() {
ack := frames.AckFrame{
LargestAcked: 3,
}
err := handler.ReceivedAck(&ack, 1337)
err := handler.ReceivedAck(&ack, 1337, time.Now())
Expect(err).ToNot(HaveOccurred())
Expect(handler.BytesInFlight()).To(Equal(protocol.ByteCount(len(packets) - 3)))
err = handler.ReceivedAck(&ack, 1337-1)
err = handler.ReceivedAck(&ack, 1337-1, time.Now())
Expect(err).To(MatchError(ErrDuplicateOrOutOfOrderAck))
Expect(handler.LargestAcked).To(Equal(protocol.PacketNumber(3)))
Expect(handler.BytesInFlight()).To(Equal(protocol.ByteCount(len(packets) - 3)))
@@ -280,7 +280,7 @@ var _ = Describe("SentPacketHandler", func() {
ack := frames.AckFrame{
LargestAcked: packets[len(packets)-1].PacketNumber + 1337,
}
err := handler.ReceivedAck(&ack, 1)
err := handler.ReceivedAck(&ack, 1, time.Now())
Expect(err).To(MatchError(errAckForUnsentPacket))
Expect(handler.BytesInFlight()).To(Equal(protocol.ByteCount(len(packets))))
})
@@ -290,10 +290,10 @@ var _ = Describe("SentPacketHandler", func() {
LargestAcked: 3,
LowestAcked: 1,
}
err := handler.ReceivedAck(&ack, 1337)
err := handler.ReceivedAck(&ack, 1337, time.Now())
Expect(err).ToNot(HaveOccurred())
Expect(handler.BytesInFlight()).To(Equal(protocol.ByteCount(len(packets) - 3)))
err = handler.ReceivedAck(&ack, 1337+1)
err = handler.ReceivedAck(&ack, 1337+1, time.Now())
Expect(err).ToNot(HaveOccurred())
Expect(handler.LargestAcked).To(Equal(protocol.PacketNumber(3)))
Expect(handler.BytesInFlight()).To(Equal(protocol.ByteCount(len(packets) - 3)))
@@ -304,7 +304,7 @@ var _ = Describe("SentPacketHandler", func() {
LargestAcked: 12,
LowestAcked: 5,
}
err := handler.ReceivedAck(&ack, 1337)
err := handler.ReceivedAck(&ack, 1337, time.Now())
Expect(err).To(MatchError(ErrAckForSkippedPacket))
Expect(handler.LargestAcked).To(BeZero())
})
@@ -318,7 +318,7 @@ var _ = Describe("SentPacketHandler", func() {
{FirstPacketNumber: 5, LastPacketNumber: 10},
},
}
err := handler.ReceivedAck(&ack, 1337)
err := handler.ReceivedAck(&ack, 1337, time.Now())
Expect(err).ToNot(HaveOccurred())
Expect(handler.LargestAcked).ToNot(BeZero())
})
@@ -330,7 +330,7 @@ var _ = Describe("SentPacketHandler", func() {
LargestAcked: 5,
LowestAcked: 1,
}
err := handler.ReceivedAck(&ack, 1)
err := handler.ReceivedAck(&ack, 1, time.Now())
Expect(err).ToNot(HaveOccurred())
Expect(handler.LargestAcked).To(Equal(protocol.PacketNumber(5)))
el := handler.packetHistory.Front()
@@ -347,7 +347,7 @@ var _ = Describe("SentPacketHandler", func() {
LargestAcked: 8,
LowestAcked: 2,
}
err := handler.ReceivedAck(&ack, 1)
err := handler.ReceivedAck(&ack, 1, time.Now())
Expect(err).ToNot(HaveOccurred())
el := handler.packetHistory.Front()
Expect(el.Value.PacketNumber).To(Equal(protocol.PacketNumber(1)))
@@ -369,7 +369,7 @@ var _ = Describe("SentPacketHandler", func() {
{FirstPacketNumber: 2, LastPacketNumber: 3},
},
}
err := handler.ReceivedAck(&ack, 1)
err := handler.ReceivedAck(&ack, 1, time.Now())
Expect(err).ToNot(HaveOccurred())
el := handler.packetHistory.Front()
Expect(el.Value.PacketNumber).To(Equal(protocol.PacketNumber(1)))
@@ -390,7 +390,7 @@ var _ = Describe("SentPacketHandler", func() {
LargestAcked: 8,
LowestAcked: 3,
}
err := handler.ReceivedAck(&ack, 1)
err := handler.ReceivedAck(&ack, 1, time.Now())
Expect(err).ToNot(HaveOccurred())
el := handler.packetHistory.Front()
Expect(el.Value.PacketNumber).To(Equal(protocol.PacketNumber(1)))
@@ -412,7 +412,7 @@ var _ = Describe("SentPacketHandler", func() {
{FirstPacketNumber: 1, LastPacketNumber: 1},
},
}
err := handler.ReceivedAck(&ack, 1)
err := handler.ReceivedAck(&ack, 1, time.Now())
Expect(err).ToNot(HaveOccurred())
el := handler.packetHistory.Front()
Expect(el.Value.PacketNumber).To(Equal(protocol.PacketNumber(2)))
@@ -441,7 +441,7 @@ var _ = Describe("SentPacketHandler", func() {
{FirstPacketNumber: 1, LastPacketNumber: 2},
},
}
err := handler.ReceivedAck(&ack1, 1)
err := handler.ReceivedAck(&ack1, 1, time.Now())
Expect(err).ToNot(HaveOccurred())
Expect(handler.BytesInFlight()).To(Equal(protocol.ByteCount(len(packets) - 5)))
el := handler.packetHistory.Front()
@@ -450,7 +450,7 @@ var _ = Describe("SentPacketHandler", func() {
LargestAcked: protocol.PacketNumber(largestObserved),
LowestAcked: 1,
}
err = handler.ReceivedAck(&ack2, 2)
err = handler.ReceivedAck(&ack2, 2, time.Now())
Expect(err).ToNot(HaveOccurred())
Expect(handler.BytesInFlight()).To(Equal(protocol.ByteCount(len(packets) - 6)))
Expect(handler.packetHistory.Front().Value.PacketNumber).To(Equal(protocol.PacketNumber(7)))
@@ -465,7 +465,7 @@ var _ = Describe("SentPacketHandler", func() {
{FirstPacketNumber: 1, LastPacketNumber: 2},
},
}
err := handler.ReceivedAck(&ack1, 1)
err := handler.ReceivedAck(&ack1, 1, time.Now())
Expect(err).ToNot(HaveOccurred())
Expect(handler.BytesInFlight()).To(Equal(protocol.ByteCount(len(packets) - 5)))
el := handler.packetHistory.Front()
@@ -474,7 +474,7 @@ var _ = Describe("SentPacketHandler", func() {
LargestAcked: 7,
LowestAcked: 1,
}
err = handler.ReceivedAck(&ack2, 2)
err = handler.ReceivedAck(&ack2, 2, time.Now())
Expect(err).ToNot(HaveOccurred())
Expect(handler.BytesInFlight()).To(Equal(protocol.ByteCount(len(packets) - 7)))
Expect(handler.packetHistory.Front().Value.PacketNumber).To(Equal(protocol.PacketNumber(8)))
@@ -485,7 +485,7 @@ var _ = Describe("SentPacketHandler", func() {
LargestAcked: 6,
LowestAcked: 1,
}
err := handler.ReceivedAck(&ack1, 1)
err := handler.ReceivedAck(&ack1, 1, time.Now())
Expect(err).ToNot(HaveOccurred())
Expect(handler.packetHistory.Front().Value.PacketNumber).To(Equal(protocol.PacketNumber(7)))
Expect(handler.BytesInFlight()).To(Equal(protocol.ByteCount(len(packets) - 6)))
@@ -498,7 +498,7 @@ var _ = Describe("SentPacketHandler", func() {
{FirstPacketNumber: 1, LastPacketNumber: 1},
},
}
err = handler.ReceivedAck(&ack2, 2)
err = handler.ReceivedAck(&ack2, 2, time.Now())
Expect(err).ToNot(HaveOccurred())
Expect(handler.BytesInFlight()).To(Equal(protocol.ByteCount(len(packets) - 6 - 3)))
Expect(handler.packetHistory.Front().Value.PacketNumber).To(Equal(protocol.PacketNumber(7)))
@@ -514,13 +514,13 @@ var _ = Describe("SentPacketHandler", func() {
getPacketElement(2).Value.SendTime = now.Add(-5 * time.Minute)
getPacketElement(6).Value.SendTime = now.Add(-1 * time.Minute)
// Now, check that the proper times are used when calculating the deltas
err := handler.ReceivedAck(&frames.AckFrame{LargestAcked: 1}, 1)
err := handler.ReceivedAck(&frames.AckFrame{LargestAcked: 1}, 1, time.Now())
Expect(err).NotTo(HaveOccurred())
Expect(handler.rttStats.LatestRTT()).To(BeNumerically("~", 10*time.Minute, 1*time.Second))
err = handler.ReceivedAck(&frames.AckFrame{LargestAcked: 2}, 2)
err = handler.ReceivedAck(&frames.AckFrame{LargestAcked: 2}, 2, time.Now())
Expect(err).NotTo(HaveOccurred())
Expect(handler.rttStats.LatestRTT()).To(BeNumerically("~", 5*time.Minute, 1*time.Second))
err = handler.ReceivedAck(&frames.AckFrame{LargestAcked: 6}, 3)
err = handler.ReceivedAck(&frames.AckFrame{LargestAcked: 6}, 3, time.Now())
Expect(err).NotTo(HaveOccurred())
Expect(handler.rttStats.LatestRTT()).To(BeNumerically("~", 1*time.Minute, 1*time.Second))
})
@@ -528,7 +528,7 @@ var _ = Describe("SentPacketHandler", func() {
It("uses the DelayTime in the ack frame", func() {
now := time.Now()
getPacketElement(1).Value.SendTime = now.Add(-10 * time.Minute)
err := handler.ReceivedAck(&frames.AckFrame{LargestAcked: 1, DelayTime: 5 * time.Minute}, 1)
err := handler.ReceivedAck(&frames.AckFrame{LargestAcked: 1, DelayTime: 5 * time.Minute}, 1, time.Now())
Expect(err).NotTo(HaveOccurred())
Expect(handler.rttStats.LatestRTT()).To(BeNumerically("~", 5*time.Minute, 1*time.Second))
})
@@ -611,7 +611,7 @@ var _ = Describe("SentPacketHandler", func() {
Context("StopWaitings", func() {
It("gets a StopWaitingFrame", func() {
ack := frames.AckFrame{LargestAcked: 5, LowestAcked: 5}
err := handler.ReceivedAck(&ack, 1)
err := handler.ReceivedAck(&ack, 1, time.Now())
Expect(err).ToNot(HaveOccurred())
Expect(handler.GetStopWaitingFrame(false)).To(Equal(&frames.StopWaitingFrame{LeastUnacked: 6}))
})
@@ -645,7 +645,7 @@ var _ = Describe("SentPacketHandler", func() {
{FirstPacketNumber: 1, LastPacketNumber: 1},
},
}
err = handler.ReceivedAck(&ack, 1)
err = handler.ReceivedAck(&ack, 1, time.Now())
Expect(err).NotTo(HaveOccurred())
Expect(handler.BytesInFlight()).To(Equal(protocol.ByteCount(2)))
@@ -668,7 +668,7 @@ var _ = Describe("SentPacketHandler", func() {
LargestAcked: 4,
LowestAcked: 1,
}
err = handler.ReceivedAck(&ack, 2)
err = handler.ReceivedAck(&ack, 2, time.Now())
Expect(err).NotTo(HaveOccurred())
Expect(handler.BytesInFlight()).To(Equal(protocol.ByteCount(0)))
})
@@ -711,7 +711,7 @@ var _ = Describe("SentPacketHandler", func() {
{FirstPacketNumber: 1, LastPacketNumber: 1},
},
}
err := handler.ReceivedAck(&ack, 1)
err := handler.ReceivedAck(&ack, 1, time.Now())
Expect(err).NotTo(HaveOccurred())
Expect(cong.nCalls).To(Equal(4)) // 3 * SentPacket + 1 * ReceivedAck
// rttUpdated, bytesInFlight, ackedPackets, lostPackets
@@ -733,7 +733,7 @@ var _ = Describe("SentPacketHandler", func() {
{FirstPacketNumber: 1, LastPacketNumber: 1},
},
}
err = handler.ReceivedAck(&ack, protocol.PacketNumber(2+i))
err = handler.ReceivedAck(&ack, protocol.PacketNumber(2+i), time.Now())
Expect(err).NotTo(HaveOccurred())
}

2
benchmark_test.go
View File

@@ -43,7 +43,7 @@ func newLinkedConnection(other *Session) *linkedConnection {
Expect(err).NotTo(HaveOccurred())
}
hdr.Raw = packet[:len(packet)-r.Len()]
conn.other.handlePacket(nil, hdr, packet[len(packet)-r.Len():])
conn.other.handlePacket(&receivedPacket{publicHeader: hdr, data: packet[len(packet)-r.Len():]})
}
}()
return conn

12
server.go
View File

@@ -6,6 +6,7 @@ import (
"net"
"strings"
"sync"
"time"
"github.com/lucas-clemente/quic-go/crypto"
"github.com/lucas-clemente/quic-go/handshake"
@@ -16,7 +17,7 @@ import (
// packetHandler handles packets
type packetHandler interface {
handlePacket(addr interface{}, hdr *PublicHeader, data []byte)
handlePacket(*receivedPacket)
run()
Close(error) error
}
@@ -130,6 +131,8 @@ func (s *Server) handlePacket(conn *net.UDPConn, remoteAddr *net.UDPAddr, packet
return qerr.PacketTooLarge
}
rcvTime := time.Now()
r := bytes.NewReader(packet)
hdr, err := ParsePublicHeader(r)
@@ -171,7 +174,12 @@ func (s *Server) handlePacket(conn *net.UDPConn, remoteAddr *net.UDPAddr, packet
// Late packet for closed session
return nil
}
session.handlePacket(remoteAddr, hdr, packet[len(packet)-r.Len():])
session.handlePacket(&receivedPacket{
remoteAddr: remoteAddr,
publicHeader: hdr,
data: packet[len(packet)-r.Len():],
rcvTime: rcvTime,
})
return nil
}

2
server_test.go
View File

@@ -20,7 +20,7 @@ type mockSession struct {
closed bool
}
func (s *mockSession) handlePacket(addr interface{}, hdr *PublicHeader, data []byte) {
func (s *mockSession) handlePacket(*receivedPacket) {
s.packetCount++
}

38
session.go
View File

@@ -25,6 +25,7 @@ type receivedPacket struct {
remoteAddr interface{}
publicHeader *PublicHeader
data []byte
rcvTime time.Time
}
var (
@@ -61,14 +62,14 @@ type Session struct {
cryptoSetup *handshake.CryptoSetup
receivedPackets chan receivedPacket
receivedPackets chan *receivedPacket
sendingScheduled chan struct{}
// closeChan is used to notify the run loop that it should terminate.
// If the value is not nil, the error is sent as a CONNECTION_CLOSE.
closeChan chan *qerr.QuicError
closed uint32 // atomic bool
undecryptablePackets []receivedPacket
undecryptablePackets []*receivedPacket
aeadChanged chan struct{}
delayedAckOriginTime time.Time
@@ -107,11 +108,11 @@ func newSession(conn connection, v protocol.VersionNumber, connectionID protocol
sentPacketHandler: sentPacketHandler,
receivedPacketHandler: receivedPacketHandler,
flowControlManager: flowControlManager,
receivedPackets: make(chan receivedPacket, protocol.MaxSessionUnprocessedPackets),
receivedPackets: make(chan *receivedPacket, protocol.MaxSessionUnprocessedPackets),
closeChan: make(chan *qerr.QuicError, 1),
sendingScheduled: make(chan struct{}, 1),
connectionParametersManager: connectionParametersManager,
undecryptablePackets: make([]receivedPacket, 0, protocol.MaxUndecryptablePackets),
undecryptablePackets: make([]*receivedPacket, 0, protocol.MaxUndecryptablePackets),
aeadChanged: make(chan struct{}, 1),
timer: time.NewTimer(0),
lastNetworkActivityTime: time.Now(),
@@ -170,7 +171,7 @@ func (s *Session) run() {
// We do all the interesting stuff after the switch statement, so
// nothing to see here.
case p := <-s.receivedPackets:
err = s.handlePacketImpl(p.remoteAddr, p.publicHeader, p.data)
err = s.handlePacketImpl(p)
if qErr, ok := err.(*qerr.QuicError); ok && qErr.ErrorCode == qerr.DecryptionFailure {
s.tryQueueingUndecryptablePacket(p)
continue
@@ -179,7 +180,7 @@ func (s *Session) run() {
// begins with the public header and we never copy it.
putPacketBuffer(p.publicHeader.Raw)
if s.delayedAckOriginTime.IsZero() {
s.delayedAckOriginTime = time.Now()
s.delayedAckOriginTime = p.rcvTime
}
case <-s.aeadChanged:
s.tryDecryptingQueuedPackets()
@@ -225,8 +226,15 @@ func (s *Session) maybeResetTimer() {
s.currentDeadline = nextDeadline
}
func (s *Session) handlePacketImpl(remoteAddr interface{}, hdr *PublicHeader, data []byte) error {
s.lastNetworkActivityTime = time.Now()
func (s *Session) handlePacketImpl(p *receivedPacket) error {
if p.rcvTime.IsZero() {
// To simplify testing
p.rcvTime = time.Now()
}
s.lastNetworkActivityTime = p.rcvTime
hdr := p.publicHeader
data := p.data
// Calculate packet number
hdr.PacketNumber = protocol.InferPacketNumber(
@@ -239,7 +247,7 @@ func (s *Session) handlePacketImpl(remoteAddr interface{}, hdr *PublicHeader, da
}
// TODO: Only do this after authenticating
s.conn.setCurrentRemoteAddr(remoteAddr)
s.conn.setCurrentRemoteAddr(p.remoteAddr)
packet, err := s.unpacker.Unpack(hdr.Raw, hdr, data)
if err != nil {
@@ -312,12 +320,12 @@ func (s *Session) handleFrames(fs []frames.Frame) error {
return nil
}
// handlePacket handles a packet
func (s *Session) handlePacket(remoteAddr interface{}, hdr *PublicHeader, data []byte) {
// handlePacket is called by the server with a new packet
func (s *Session) handlePacket(p *receivedPacket) {
// Discard packets once the amount of queued packets is larger than
// the channel size, protocol.MaxSessionUnprocessedPackets
select {
case s.receivedPackets <- receivedPacket{remoteAddr: remoteAddr, publicHeader: hdr, data: data}:
case s.receivedPackets <- p:
default:
}
}
@@ -366,7 +374,7 @@ func (s *Session) handleRstStreamFrame(frame *frames.RstStreamFrame) error {
}
func (s *Session) handleAckFrame(frame *frames.AckFrame) error {
if err := s.sentPacketHandler.ReceivedAck(frame, s.lastRcvdPacketNumber); err != nil {
if err := s.sentPacketHandler.ReceivedAck(frame, s.lastRcvdPacketNumber, s.lastNetworkActivityTime); err != nil {
return err
}
return nil
@@ -611,7 +619,7 @@ func (s *Session) scheduleSending() {
}
}
func (s *Session) tryQueueingUndecryptablePacket(p receivedPacket) {
func (s *Session) tryQueueingUndecryptablePacket(p *receivedPacket) {
if s.cryptoSetup.HandshakeComplete() {
return
}
@@ -624,7 +632,7 @@ func (s *Session) tryQueueingUndecryptablePacket(p receivedPacket) {
func (s *Session) tryDecryptingQueuedPackets() {
for _, p := range s.undecryptablePackets {
s.handlePacket(p.remoteAddr, p.publicHeader, p.data)
s.handlePacket(p)
}
s.undecryptablePackets = s.undecryptablePackets[:0]
}

28
session_test.go
View File

@@ -58,7 +58,7 @@ func (h *mockSentPacketHandler) SentPacket(packet *ackhandler.Packet) error {
h.sentPackets = append(h.sentPackets, packet)
return nil
}
func (h *mockSentPacketHandler) ReceivedAck(ackFrame *frames.AckFrame, withPacketNumber protocol.PacketNumber) error {
func (h *mockSentPacketHandler) ReceivedAck(ackFrame *frames.AckFrame, withPacketNumber protocol.PacketNumber, recvTime time.Time) error {
return nil
}
func (h *mockSentPacketHandler) BytesInFlight() protocol.ByteCount { return 0 }
@@ -459,7 +459,7 @@ var _ = Describe("Session", func() {
It("sets the {last,largest}RcvdPacketNumber", func() {
hdr.PacketNumber = 5
err := session.handlePacketImpl(nil, hdr, nil)
err := session.handlePacketImpl(&receivedPacket{publicHeader: hdr})
Expect(err).ToNot(HaveOccurred())
Expect(session.lastRcvdPacketNumber).To(Equal(protocol.PacketNumber(5)))
Expect(session.largestRcvdPacketNumber).To(Equal(protocol.PacketNumber(5)))
@@ -467,12 +467,12 @@ var _ = Describe("Session", func() {
It("sets the {last,largest}RcvdPacketNumber, for an out-of-order packet", func() {
hdr.PacketNumber = 5
err := session.handlePacketImpl(nil, hdr, nil)
err := session.handlePacketImpl(&receivedPacket{publicHeader: hdr})
Expect(err).ToNot(HaveOccurred())
Expect(session.lastRcvdPacketNumber).To(Equal(protocol.PacketNumber(5)))
Expect(session.largestRcvdPacketNumber).To(Equal(protocol.PacketNumber(5)))
hdr.PacketNumber = 3
err = session.handlePacketImpl(nil, hdr, nil)
err = session.handlePacketImpl(&receivedPacket{publicHeader: hdr})
Expect(err).ToNot(HaveOccurred())
Expect(session.lastRcvdPacketNumber).To(Equal(protocol.PacketNumber(3)))
Expect(session.largestRcvdPacketNumber).To(Equal(protocol.PacketNumber(5)))
@@ -480,9 +480,9 @@ var _ = Describe("Session", func() {
It("ignores duplicate packets", func() {
hdr.PacketNumber = 5
err := session.handlePacketImpl(nil, hdr, nil)
err := session.handlePacketImpl(&receivedPacket{publicHeader: hdr})
Expect(err).ToNot(HaveOccurred())
err = session.handlePacketImpl(nil, hdr, nil)
err = session.handlePacketImpl(&receivedPacket{publicHeader: hdr})
Expect(err).ToNot(HaveOccurred())
})
@@ -490,7 +490,7 @@ var _ = Describe("Session", func() {
err := session.receivedPacketHandler.ReceivedStopWaiting(&frames.StopWaitingFrame{LeastUnacked: 10})
Expect(err).ToNot(HaveOccurred())
hdr.PacketNumber = 5
err = session.handlePacketImpl(nil, hdr, nil)
err = session.handlePacketImpl(&receivedPacket{publicHeader: hdr})
Expect(err).ToNot(HaveOccurred())
})
})
@@ -717,7 +717,7 @@ var _ = Describe("Session", func() {
hdr := &PublicHeader{
PacketNumber: protocol.PacketNumber(i + 1),
}
session.handlePacket(nil, hdr, []byte("foobar"))
session.handlePacket(&receivedPacket{publicHeader: hdr, data: []byte("foobar")})
}
session.run()
@@ -731,7 +731,7 @@ var _ = Describe("Session", func() {
hdr := &PublicHeader{
PacketNumber: protocol.PacketNumber(i + 1),
}
session.handlePacket(nil, hdr, []byte("foobar"))
session.handlePacket(&receivedPacket{publicHeader: hdr, data: []byte("foobar")})
}
go session.run()
Consistently(session.undecryptablePackets).Should(HaveLen(0))
@@ -739,10 +739,8 @@ var _ = Describe("Session", func() {
})
It("unqueues undecryptable packets for later decryption", func() {
session.undecryptablePackets = []receivedPacket{{
nil,
&PublicHeader{PacketNumber: protocol.PacketNumber(42)},
nil,
session.undecryptablePackets = []*receivedPacket{{
publicHeader: &PublicHeader{PacketNumber: protocol.PacketNumber(42)},
}}
Expect(session.receivedPackets).NotTo(Receive())
session.tryDecryptingQueuedPackets()
@@ -775,7 +773,7 @@ var _ = Describe("Session", func() {
It("stores up to MaxSessionUnprocessedPackets packets", func(done Done) {
// Nothing here should block
for i := protocol.PacketNumber(0); i < protocol.MaxSessionUnprocessedPackets+10; i++ {
session.handlePacket(nil, nil, nil)
session.handlePacket(&receivedPacket{})
}
close(done)
}, 0.5)
@@ -789,7 +787,7 @@ var _ = Describe("Session", func() {
time.Sleep(time.Microsecond)
ack := &frames.AckFrame{}
ack.LargestAcked = p
err = session.sentPacketHandler.ReceivedAck(ack, p)
err = session.sentPacketHandler.ReceivedAck(ack, p, time.Now())
Expect(err).NotTo(HaveOccurred())
}
session.packer.packetNumberGenerator.next = n + 1