mirrors/uquic
1
0
Fork 0
mirror of https://github.com/refraction-networking/uquic.git synced 2025-04-04 20:57:36 +03:00
Code Issues Projects Releases Packages Wiki Activity

use separate packet number spaces for sending packets

Browse source 
Packet numbers now start at 0 for every packet number spaces.
Furthermore, an ACK frame now only acknowledges packets in the packet
number space it was sent in.
This commit is contained in:
Marten Seemann 2019-02-11 20:12:46 +08:00
parent b35c161f2e
commit f6642ff948
9 changed files with 369 additions and 378 deletions
Download patch file Download diff file Expand all files Collapse all files

4
internal/ackhandler/interfaces.go
View file

@ -33,8 +33,8 @@ type SentPacketHandler interface {
DequeuePacketForRetransmission() *Packet DequeuePacketForRetransmission() *Packet
DequeueProbePacket() (*Packet, error) DequeueProbePacket() (*Packet, error)
PeekPacketNumber() (protocol.PacketNumber, protocol.PacketNumberLen) PeekPacketNumber(protocol.EncryptionLevel) (protocol.PacketNumber, protocol.PacketNumberLen)
PopPacketNumber() protocol.PacketNumber PopPacketNumber(protocol.EncryptionLevel) protocol.PacketNumber
GetAlarmTimeout() time.Time GetAlarmTimeout() time.Time
OnAlarm() error OnAlarm() error

242
internal/ackhandler/sent_packet_handler.go
View file

@ -21,23 +21,37 @@ const (
granularity = time.Millisecond granularity = time.Millisecond
) )
type sentPacketHandler struct { type packetNumberSpace struct {
largestSent protocol.PacketNumber history *sentPacketHistory
packetNumberGenerator *packetNumberGenerator pns *packetNumberGenerator
lastSentRetransmittablePacketTime time.Time largestAcked protocol.PacketNumber
largestSent protocol.PacketNumber
}
func newPacketNumberSpace(initialPN protocol.PacketNumber) *packetNumberSpace {
return &packetNumberSpace{
history: newSentPacketHistory(),
pns: newPacketNumberGenerator(initialPN, protocol.SkipPacketAveragePeriodLength),
}
}
type sentPacketHandler struct {
lastSentRetransmittablePacketTime time.Time // only applies to the application-data packet number space
lastSentCryptoPacketTime time.Time lastSentCryptoPacketTime time.Time
nextSendTime time.Time nextSendTime time.Time
largestAcked protocol.PacketNumber initialPackets *packetNumberSpace
handshakePackets *packetNumberSpace
oneRTTPackets *packetNumberSpace
// lowestNotConfirmedAcked is the lowest packet number that we sent an ACK for, but haven't received confirmation, that this ACK actually arrived // lowestNotConfirmedAcked is the lowest packet number that we sent an ACK for, but haven't received confirmation, that this ACK actually arrived
// example: we send an ACK for packets 90-100 with packet number 20 // example: we send an ACK for packets 90-100 with packet number 20
// once we receive an ACK from the peer for packet 20, the lowestNotConfirmedAcked is 101 // once we receive an ACK from the peer for packet 20, the lowestNotConfirmedAcked is 101
// Only applies to the application-data packet number space.
lowestNotConfirmedAcked protocol.PacketNumber lowestNotConfirmedAcked protocol.PacketNumber
packetHistory *sentPacketHistory
retransmissionQueue []*Packet retransmissionQueue []*Packet
bytesInFlight protocol.ByteCount bytesInFlight protocol.ByteCount
@ -52,6 +66,7 @@ type sentPacketHandler struct {
// The number of times a PTO has been sent without receiving an ack. // The number of times a PTO has been sent without receiving an ack.
ptoCount uint32 ptoCount uint32
// The number of PTO probe packets that should be sent. // The number of PTO probe packets that should be sent.
// Only applies to the application-data packet number space.
numProbesToSend int numProbesToSend int
// The time at which the next packet will be considered lost based on early transmit or exceeding the reordering window in time. // The time at which the next packet will be considered lost based on early transmit or exceeding the reordering window in time.
@ -78,21 +93,15 @@ func NewSentPacketHandler(
) )
return &sentPacketHandler{ return &sentPacketHandler{
packetNumberGenerator: newPacketNumberGenerator(initialPacketNumber, protocol.SkipPacketAveragePeriodLength), initialPackets: newPacketNumberSpace(initialPacketNumber),
packetHistory: newSentPacketHistory(), handshakePackets: newPacketNumberSpace(0),
rttStats: rttStats, oneRTTPackets: newPacketNumberSpace(0),
congestion: congestion, rttStats: rttStats,
logger: logger, congestion: congestion,
logger: logger,
} }
} }
func (h *sentPacketHandler) lowestUnacked() protocol.PacketNumber {
if p := h.packetHistory.FirstOutstanding(); p != nil {
return p.PacketNumber
}
return h.largestAcked + 1
}
func (h *sentPacketHandler) SetHandshakeComplete() { func (h *sentPacketHandler) SetHandshakeComplete() {
h.logger.Debugf("Handshake complete. Discarding all outstanding crypto packets.") h.logger.Debugf("Handshake complete. Discarding all outstanding crypto packets.")
var queue []*Packet var queue []*Packet
@ -101,15 +110,15 @@ func (h *sentPacketHandler) SetHandshakeComplete() {
queue = append(queue, packet) queue = append(queue, packet)
} }
} }
var cryptoPackets []*Packet for _, pnSpace := range []*packetNumberSpace{h.initialPackets, h.handshakePackets} {
h.packetHistory.Iterate(func(p *Packet) (bool, error) { var cryptoPackets []*Packet
if p.EncryptionLevel != protocol.Encryption1RTT { pnSpace.history.Iterate(func(p *Packet) (bool, error) {
cryptoPackets = append(cryptoPackets, p) cryptoPackets = append(cryptoPackets, p)
return true, nil
})
for _, p := range cryptoPackets {
pnSpace.history.Remove(p.PacketNumber)
} }
return true, nil
})
for _, p := range cryptoPackets {
h.packetHistory.Remove(p.PacketNumber)
} }
h.retransmissionQueue = queue h.retransmissionQueue = queue
h.handshakeComplete = true h.handshakeComplete = true
@ -117,7 +126,7 @@ func (h *sentPacketHandler) SetHandshakeComplete() {
func (h *sentPacketHandler) SentPacket(packet *Packet) { func (h *sentPacketHandler) SentPacket(packet *Packet) {
if isRetransmittable := h.sentPacketImpl(packet); isRetransmittable { if isRetransmittable := h.sentPacketImpl(packet); isRetransmittable {
h.packetHistory.SentPacket(packet) h.getPacketNumberSpace(packet.EncryptionLevel).history.SentPacket(packet)
h.updateLossDetectionAlarm() h.updateLossDetectionAlarm()
} }
} }
@ -129,18 +138,33 @@ func (h *sentPacketHandler) SentPacketsAsRetransmission(packets []*Packet, retra
p = append(p, packet) p = append(p, packet)
} }
} }
h.packetHistory.SentPacketsAsRetransmission(p, retransmissionOf) h.getPacketNumberSpace(p[0].EncryptionLevel).history.SentPacketsAsRetransmission(p, retransmissionOf)
h.updateLossDetectionAlarm() h.updateLossDetectionAlarm()
} }
func (h *sentPacketHandler) getPacketNumberSpace(encLevel protocol.EncryptionLevel) *packetNumberSpace {
switch encLevel {
case protocol.EncryptionInitial:
return h.initialPackets
case protocol.EncryptionHandshake:
return h.handshakePackets
case protocol.Encryption1RTT:
return h.oneRTTPackets
default:
panic("invalid packet number space")
}
}
func (h *sentPacketHandler) sentPacketImpl(packet *Packet) bool /* isRetransmittable */ { func (h *sentPacketHandler) sentPacketImpl(packet *Packet) bool /* isRetransmittable */ {
if h.logger.Debug() && h.largestSent != 0 { pnSpace := h.getPacketNumberSpace(packet.EncryptionLevel)
for p := h.largestSent + 1; p < packet.PacketNumber; p++ {
if h.logger.Debug() && pnSpace.largestSent != 0 {
for p := pnSpace.largestSent + 1; p < packet.PacketNumber; p++ {
h.logger.Debugf("Skipping packet number %#x", p) h.logger.Debugf("Skipping packet number %#x", p)
} }
} }
h.largestSent = packet.PacketNumber pnSpace.largestSent = packet.PacketNumber
if len(packet.Frames) > 0 { if len(packet.Frames) > 0 {
if ackFrame, ok := packet.Frames[0].(*wire.AckFrame); ok { if ackFrame, ok := packet.Frames[0].(*wire.AckFrame); ok {
@ -170,22 +194,29 @@ func (h *sentPacketHandler) sentPacketImpl(packet *Packet) bool /* isRetransmitt
} }
func (h *sentPacketHandler) ReceivedAck(ackFrame *wire.AckFrame, withPacketNumber protocol.PacketNumber, encLevel protocol.EncryptionLevel, rcvTime time.Time) error { func (h *sentPacketHandler) ReceivedAck(ackFrame *wire.AckFrame, withPacketNumber protocol.PacketNumber, encLevel protocol.EncryptionLevel, rcvTime time.Time) error {
pnSpace := h.getPacketNumberSpace(encLevel)
largestAcked := ackFrame.LargestAcked() largestAcked := ackFrame.LargestAcked()
if largestAcked > h.largestSent { if largestAcked > pnSpace.largestSent {
return qerr.Error(qerr.InvalidAckData, "Received ACK for an unsent package") return qerr.Error(qerr.InvalidAckData, "Received ACK for an unsent packet")
} }
h.largestAcked = utils.MaxPacketNumber(h.largestAcked, largestAcked) pnSpace.largestAcked = utils.MaxPacketNumber(pnSpace.largestAcked, largestAcked)
if !h.packetNumberGenerator.Validate(ackFrame) { if !pnSpace.pns.Validate(ackFrame) {
return qerr.Error(qerr.InvalidAckData, "Received an ACK for a skipped packet number") return qerr.Error(qerr.InvalidAckData, "Received an ACK for a skipped packet number")
} }
if rttUpdated := h.maybeUpdateRTT(largestAcked, ackFrame.DelayTime, rcvTime); rttUpdated { // maybe update the RTT
if p := pnSpace.history.GetPacket(ackFrame.LargestAcked()); p != nil {
h.rttStats.UpdateRTT(rcvTime.Sub(p.SendTime), ackFrame.DelayTime, rcvTime)
if h.logger.Debug() {
h.logger.Debugf("\tupdated RTT: %s (σ: %s)", h.rttStats.SmoothedRTT(), h.rttStats.MeanDeviation())
}
h.congestion.MaybeExitSlowStart() h.congestion.MaybeExitSlowStart()
} }
ackedPackets, err := h.determineNewlyAckedPackets(ackFrame) ackedPackets, err := h.determineNewlyAckedPackets(ackFrame, encLevel)
if err != nil { if err != nil {
return err return err
} }
@ -195,15 +226,10 @@ func (h *sentPacketHandler) ReceivedAck(ackFrame *wire.AckFrame, withPacketNumbe
priorInFlight := h.bytesInFlight priorInFlight := h.bytesInFlight
for _, p := range ackedPackets { for _, p := range ackedPackets {
// TODO(#1534): check the encryption level
// if encLevel < p.EncryptionLevel {
// return fmt.Errorf("Received ACK with encryption level %s that acks a packet %d (encryption level %s)", encLevel, p.PacketNumber, p.EncryptionLevel)
// }
// largestAcked == 0 either means that the packet didn't contain an ACK, or it just acked packet 0 // largestAcked == 0 either means that the packet didn't contain an ACK, or it just acked packet 0
// It is safe to ignore the corner case of packets that just acked packet 0, because // It is safe to ignore the corner case of packets that just acked packet 0, because
// the lowestPacketNotConfirmedAcked is only used to limit the number of ACK ranges we will send. // the lowestPacketNotConfirmedAcked is only used to limit the number of ACK ranges we will send.
if p.largestAcked != 0 { if p.largestAcked != 0 && encLevel == protocol.Encryption1RTT {
h.lowestNotConfirmedAcked = utils.MaxPacketNumber(h.lowestNotConfirmedAcked, p.largestAcked+1) h.lowestNotConfirmedAcked = utils.MaxPacketNumber(h.lowestNotConfirmedAcked, p.largestAcked+1)
} }
if err := h.onPacketAcked(p, rcvTime); err != nil { if err := h.onPacketAcked(p, rcvTime); err != nil {
@ -214,7 +240,7 @@ func (h *sentPacketHandler) ReceivedAck(ackFrame *wire.AckFrame, withPacketNumbe
} }
} }
if err := h.detectLostPackets(rcvTime, priorInFlight); err != nil { if err := h.detectLostPackets(rcvTime, encLevel, priorInFlight); err != nil {
return err return err
} }
@ -229,12 +255,16 @@ func (h *sentPacketHandler) GetLowestPacketNotConfirmedAcked() protocol.PacketNu
return h.lowestNotConfirmedAcked return h.lowestNotConfirmedAcked
} }
func (h *sentPacketHandler) determineNewlyAckedPackets(ackFrame *wire.AckFrame) ([]*Packet, error) { func (h *sentPacketHandler) determineNewlyAckedPackets(
ackFrame *wire.AckFrame,
encLevel protocol.EncryptionLevel,
) ([]*Packet, error) {
pnSpace := h.getPacketNumberSpace(encLevel)
var ackedPackets []*Packet var ackedPackets []*Packet
ackRangeIndex := 0 ackRangeIndex := 0
lowestAcked := ackFrame.LowestAcked() lowestAcked := ackFrame.LowestAcked()
largestAcked := ackFrame.LargestAcked() largestAcked := ackFrame.LargestAcked()
err := h.packetHistory.Iterate(func(p *Packet) (bool, error) { err := pnSpace.history.Iterate(func(p *Packet) (bool, error) {
// Ignore packets below the lowest acked // Ignore packets below the lowest acked
if p.PacketNumber < lowestAcked { if p.PacketNumber < lowestAcked {
return true, nil return true, nil
@ -273,25 +303,22 @@ func (h *sentPacketHandler) determineNewlyAckedPackets(ackFrame *wire.AckFrame)
return ackedPackets, err return ackedPackets, err
} }
func (h *sentPacketHandler) maybeUpdateRTT(largestAcked protocol.PacketNumber, ackDelay time.Duration, rcvTime time.Time) bool { func (h *sentPacketHandler) hasOutstandingCryptoPackets() bool {
if p := h.packetHistory.GetPacket(largestAcked); p != nil { return h.initialPackets.history.HasOutstandingPackets() || h.handshakePackets.history.HasOutstandingPackets()
h.rttStats.UpdateRTT(rcvTime.Sub(p.SendTime), ackDelay, rcvTime) }
if h.logger.Debug() {
h.logger.Debugf("\tupdated RTT: %s (σ: %s)", h.rttStats.SmoothedRTT(), h.rttStats.MeanDeviation()) func (h *sentPacketHandler) hasOutstandingPackets() bool {
} return h.oneRTTPackets.history.HasOutstandingPackets() || h.hasOutstandingCryptoPackets()
return true
}
return false
} }
func (h *sentPacketHandler) updateLossDetectionAlarm() { func (h *sentPacketHandler) updateLossDetectionAlarm() {
// Cancel the alarm if no packets are outstanding // Cancel the alarm if no packets are outstanding
if !h.packetHistory.HasOutstandingPackets() { if !h.hasOutstandingPackets() {
h.alarm = time.Time{} h.alarm = time.Time{}
return return
} }
if h.packetHistory.HasOutstandingCryptoPackets() { if h.hasOutstandingCryptoPackets() {
h.alarm = h.lastSentCryptoPacketTime.Add(h.computeCryptoTimeout()) h.alarm = h.lastSentCryptoPacketTime.Add(h.computeCryptoTimeout())
} else if !h.lossTime.IsZero() { } else if !h.lossTime.IsZero() {
// Early retransmit timer or time loss detection. // Early retransmit timer or time loss detection.
@ -301,22 +328,29 @@ func (h *sentPacketHandler) updateLossDetectionAlarm() {
} }
} }
func (h *sentPacketHandler) detectLostPackets(now time.Time, priorInFlight protocol.ByteCount) error { func (h *sentPacketHandler) detectLostPackets(
h.lossTime = time.Time{} now time.Time,
encLevel protocol.EncryptionLevel,
priorInFlight protocol.ByteCount,
) error {
if encLevel == protocol.Encryption1RTT {
h.lossTime = time.Time{}
}
pnSpace := h.getPacketNumberSpace(encLevel)
maxRTT := float64(utils.MaxDuration(h.rttStats.LatestRTT(), h.rttStats.SmoothedRTT())) maxRTT := float64(utils.MaxDuration(h.rttStats.LatestRTT(), h.rttStats.SmoothedRTT()))
delayUntilLost := time.Duration((1.0 + timeReorderingFraction) * maxRTT) delayUntilLost := time.Duration((1.0 + timeReorderingFraction) * maxRTT)
var lostPackets []*Packet var lostPackets []*Packet
h.packetHistory.Iterate(func(packet *Packet) (bool, error) { pnSpace.history.Iterate(func(packet *Packet) (bool, error) {
if packet.PacketNumber > h.largestAcked { if packet.PacketNumber > pnSpace.largestAcked {
return false, nil return false, nil
} }
timeSinceSent := now.Sub(packet.SendTime) timeSinceSent := now.Sub(packet.SendTime)
if timeSinceSent > delayUntilLost { if timeSinceSent > delayUntilLost {
lostPackets = append(lostPackets, packet) lostPackets = append(lostPackets, packet)
} else if h.lossTime.IsZero() { } else if h.lossTime.IsZero() && encLevel == protocol.Encryption1RTT {
if h.logger.Debug() { if h.logger.Debug() {
h.logger.Debugf("\tsetting loss timer for packet %#x to %s (in %s)", packet.PacketNumber, delayUntilLost, delayUntilLost-timeSinceSent) h.logger.Debugf("\tsetting loss timer for packet %#x to %s (in %s)", packet.PacketNumber, delayUntilLost, delayUntilLost-timeSinceSent)
} }
@ -342,11 +376,11 @@ func (h *sentPacketHandler) detectLostPackets(now time.Time, priorInFlight proto
} }
if p.canBeRetransmitted { if p.canBeRetransmitted {
// queue the packet for retransmission, and report the loss to the congestion controller // queue the packet for retransmission, and report the loss to the congestion controller
if err := h.queuePacketForRetransmission(p); err != nil { if err := h.queuePacketForRetransmission(p, pnSpace); err != nil {
return err return err
} }
} }
h.packetHistory.Remove(p.PacketNumber) pnSpace.history.Remove(p.PacketNumber)
} }
return nil return nil
} }
@ -356,7 +390,7 @@ func (h *sentPacketHandler) OnAlarm() error {
// updateLossDetectionAlarm. This doesn't reset the timer in the session though. // updateLossDetectionAlarm. This doesn't reset the timer in the session though.
// When OnAlarm is called, we therefore need to make sure that there are // When OnAlarm is called, we therefore need to make sure that there are
// actually packets outstanding. // actually packets outstanding.
if h.packetHistory.HasOutstandingPackets() { if h.hasOutstandingPackets() {
if err := h.onVerifiedAlarm(); err != nil { if err := h.onVerifiedAlarm(); err != nil {
return err return err
} }
@ -367,7 +401,7 @@ func (h *sentPacketHandler) OnAlarm() error {
func (h *sentPacketHandler) onVerifiedAlarm() error { func (h *sentPacketHandler) onVerifiedAlarm() error {
var err error var err error
if h.packetHistory.HasOutstandingCryptoPackets() { if h.hasOutstandingCryptoPackets() {
if h.logger.Debug() { if h.logger.Debug() {
h.logger.Debugf("Loss detection alarm fired in crypto mode. Crypto count: %d", h.cryptoCount) h.logger.Debugf("Loss detection alarm fired in crypto mode. Crypto count: %d", h.cryptoCount)
} }
@ -378,7 +412,7 @@ func (h *sentPacketHandler) onVerifiedAlarm() error {
h.logger.Debugf("Loss detection alarm fired in loss timer mode. Loss time: %s", h.lossTime) h.logger.Debugf("Loss detection alarm fired in loss timer mode. Loss time: %s", h.lossTime)
} }
// Early retransmit or time loss detection // Early retransmit or time loss detection
err = h.detectLostPackets(time.Now(), h.bytesInFlight) err = h.detectLostPackets(time.Now(), protocol.Encryption1RTT, h.bytesInFlight)
} else { // PTO } else { // PTO
if h.logger.Debug() { if h.logger.Debug() {
h.logger.Debugf("Loss detection alarm fired in PTO mode. PTO count: %d", h.ptoCount) h.logger.Debugf("Loss detection alarm fired in PTO mode. PTO count: %d", h.ptoCount)
@ -394,10 +428,11 @@ func (h *sentPacketHandler) GetAlarmTimeout() time.Time {
} }
func (h *sentPacketHandler) onPacketAcked(p *Packet, rcvTime time.Time) error { func (h *sentPacketHandler) onPacketAcked(p *Packet, rcvTime time.Time) error {
pnSpace := h.getPacketNumberSpace(p.EncryptionLevel)
// This happens if a packet and its retransmissions is acked in the same ACK. // This happens if a packet and its retransmissions is acked in the same ACK.
// As soon as we process the first one, this will remove all the retransmissions, // As soon as we process the first one, this will remove all the retransmissions,
// so we won't find the retransmitted packet number later. // so we won't find the retransmitted packet number later.
if packet := h.packetHistory.GetPacket(p.PacketNumber); packet == nil { if packet := pnSpace.history.GetPacket(p.PacketNumber); packet == nil {
return nil return nil
} }
@ -406,7 +441,7 @@ func (h *sentPacketHandler) onPacketAcked(p *Packet, rcvTime time.Time) error {
// * this packet wasn't retransmitted yet // * this packet wasn't retransmitted yet
if p.isRetransmission { if p.isRetransmission {
// that the parent doesn't exist is expected to happen every time the original packet was already acked // that the parent doesn't exist is expected to happen every time the original packet was already acked
if parent := h.packetHistory.GetPacket(p.retransmissionOf); parent != nil { if parent := pnSpace.history.GetPacket(p.retransmissionOf); parent != nil {
if len(parent.retransmittedAs) == 1 { if len(parent.retransmittedAs) == 1 {
parent.retransmittedAs = nil parent.retransmittedAs = nil
} else { } else {
@ -425,22 +460,22 @@ func (h *sentPacketHandler) onPacketAcked(p *Packet, rcvTime time.Time) error {
if p.includedInBytesInFlight { if p.includedInBytesInFlight {
h.bytesInFlight -= p.Length h.bytesInFlight -= p.Length
} }
if err := h.stopRetransmissionsFor(p); err != nil { if err := h.stopRetransmissionsFor(p, pnSpace); err != nil {
return err return err
} }
return h.packetHistory.Remove(p.PacketNumber) return pnSpace.history.Remove(p.PacketNumber)
} }
func (h *sentPacketHandler) stopRetransmissionsFor(p *Packet) error { func (h *sentPacketHandler) stopRetransmissionsFor(p *Packet, pnSpace *packetNumberSpace) error {
if err := h.packetHistory.MarkCannotBeRetransmitted(p.PacketNumber); err != nil { if err := pnSpace.history.MarkCannotBeRetransmitted(p.PacketNumber); err != nil {
return err return err
} }
for _, r := range p.retransmittedAs { for _, r := range p.retransmittedAs {
packet := h.packetHistory.GetPacket(r) packet := pnSpace.history.GetPacket(r)
if packet == nil { if packet == nil {
return fmt.Errorf("sent packet handler BUG: marking packet as not retransmittable %d (retransmission of %d) not found in history", r, p.PacketNumber) return fmt.Errorf("sent packet handler BUG: marking packet as not retransmittable %d (retransmission of %d) not found in history", r, p.PacketNumber)
} }
h.stopRetransmissionsFor(packet) h.stopRetransmissionsFor(packet, pnSpace)
} }
return nil return nil
} }
@ -458,29 +493,40 @@ func (h *sentPacketHandler) DequeuePacketForRetransmission() *Packet {
} }
func (h *sentPacketHandler) DequeueProbePacket() (*Packet, error) { func (h *sentPacketHandler) DequeueProbePacket() (*Packet, error) {
pnSpace := h.getPacketNumberSpace(protocol.Encryption1RTT)
if len(h.retransmissionQueue) == 0 { if len(h.retransmissionQueue) == 0 {
p := h.packetHistory.FirstOutstanding() p := pnSpace.history.FirstOutstanding()
if p == nil { if p == nil {
return nil, errors.New("cannot dequeue a probe packet. No outstanding packets") return nil, errors.New("cannot dequeue a probe packet. No outstanding packets")
} }
if err := h.queuePacketForRetransmission(p); err != nil { if err := h.queuePacketForRetransmission(p, pnSpace); err != nil {
return nil, err return nil, err
} }
} }
return h.DequeuePacketForRetransmission(), nil return h.DequeuePacketForRetransmission(), nil
} }
func (h *sentPacketHandler) PeekPacketNumber() (protocol.PacketNumber, protocol.PacketNumberLen) { func (h *sentPacketHandler) PeekPacketNumber(encLevel protocol.EncryptionLevel) (protocol.PacketNumber, protocol.PacketNumberLen) {
pn := h.packetNumberGenerator.Peek() pnSpace := h.getPacketNumberSpace(encLevel)
return pn, protocol.GetPacketNumberLengthForHeader(pn, h.lowestUnacked())
var lowestUnacked protocol.PacketNumber
if p := pnSpace.history.FirstOutstanding(); p != nil {
lowestUnacked = p.PacketNumber
} else {
lowestUnacked = pnSpace.largestAcked + 1
}
pn := pnSpace.pns.Peek()
return pn, protocol.GetPacketNumberLengthForHeader(pn, lowestUnacked)
} }
func (h *sentPacketHandler) PopPacketNumber() protocol.PacketNumber { func (h *sentPacketHandler) PopPacketNumber(encLevel protocol.EncryptionLevel) protocol.PacketNumber {
return h.packetNumberGenerator.Pop() return h.getPacketNumberSpace(encLevel).pns.Pop()
} }
func (h *sentPacketHandler) SendMode() SendMode { func (h *sentPacketHandler) SendMode() SendMode {
numTrackedPackets := len(h.retransmissionQueue) + h.packetHistory.Len() numTrackedPackets := len(h.retransmissionQueue) + h.initialPackets.history.Len() +
h.handshakePackets.history.Len() + h.oneRTTPackets.history.Len()
// Don't send any packets if we're keeping track of the maximum number of packets. // Don't send any packets if we're keeping track of the maximum number of packets.
// Note that since MaxOutstandingSentPackets is smaller than MaxTrackedSentPackets, // Note that since MaxOutstandingSentPackets is smaller than MaxTrackedSentPackets,
@ -532,27 +578,35 @@ func (h *sentPacketHandler) ShouldSendNumPackets() int {
} }
func (h *sentPacketHandler) queueCryptoPacketsForRetransmission() error { func (h *sentPacketHandler) queueCryptoPacketsForRetransmission() error {
var cryptoPackets []*Packet if err := h.queueAllPacketsForRetransmission(protocol.EncryptionInitial); err != nil {
h.packetHistory.Iterate(func(p *Packet) (bool, error) { return err
if p.canBeRetransmitted && p.EncryptionLevel != protocol.Encryption1RTT { }
cryptoPackets = append(cryptoPackets, p) return h.queueAllPacketsForRetransmission(protocol.EncryptionHandshake)
}
func (h *sentPacketHandler) queueAllPacketsForRetransmission(encLevel protocol.EncryptionLevel) error {
var packets []*Packet
pnSpace := h.getPacketNumberSpace(encLevel)
pnSpace.history.Iterate(func(p *Packet) (bool, error) {
if p.canBeRetransmitted {
packets = append(packets, p)
} }
return true, nil return true, nil
}) })
for _, p := range cryptoPackets { for _, p := range packets {
h.logger.Debugf("Queueing packet %#x as a crypto retransmission", p.PacketNumber) h.logger.Debugf("Queueing packet %#x (%s) as a crypto retransmission", p.PacketNumber, encLevel)
if err := h.queuePacketForRetransmission(p); err != nil { if err := h.queuePacketForRetransmission(p, pnSpace); err != nil {
return err return err
} }
} }
return nil return nil
} }
func (h *sentPacketHandler) queuePacketForRetransmission(p *Packet) error { func (h *sentPacketHandler) queuePacketForRetransmission(p *Packet, pnSpace *packetNumberSpace) error {
if !p.canBeRetransmitted { if !p.canBeRetransmitted {
return fmt.Errorf("sent packet handler BUG: packet %d already queued for retransmission", p.PacketNumber) return fmt.Errorf("sent packet handler BUG: packet %d already queued for retransmission", p.PacketNumber)
} }
if err := h.packetHistory.MarkCannotBeRetransmitted(p.PacketNumber); err != nil { if err := pnSpace.history.MarkCannotBeRetransmitted(p.PacketNumber); err != nil {
return err return err
} }
h.retransmissionQueue = append(h.retransmissionQueue, p) h.retransmissionQueue = append(h.retransmissionQueue, p)
@ -576,7 +630,7 @@ func (h *sentPacketHandler) ResetForRetry() error {
h.cryptoCount = 0 h.cryptoCount = 0
h.bytesInFlight = 0 h.bytesInFlight = 0
var packets []*Packet var packets []*Packet
h.packetHistory.Iterate(func(p *Packet) (bool, error) { h.initialPackets.history.Iterate(func(p *Packet) (bool, error) {
if p.canBeRetransmitted { if p.canBeRetransmitted {
packets = append(packets, p) packets = append(packets, p)
} }
@ -586,7 +640,7 @@ func (h *sentPacketHandler) ResetForRetry() error {
h.logger.Debugf("Queueing packet %#x for retransmission.", p.PacketNumber) h.logger.Debugf("Queueing packet %#x for retransmission.", p.PacketNumber)
h.retransmissionQueue = append(h.retransmissionQueue, p) h.retransmissionQueue = append(h.retransmissionQueue, p)
} }
h.packetHistory = newSentPacketHistory() h.initialPackets = newPacketNumberSpace(h.initialPackets.pns.Pop())
h.updateLossDetectionAlarm() h.updateLossDetectionAlarm()
return nil return nil
} }

266
internal/ackhandler/sent_packet_handler_test.go
View file

@ -57,17 +57,17 @@ var _ = Describe("SentPacketHandler", func() {
} }
}) })
getPacket := func(pn protocol.PacketNumber) *Packet { getPacket := func(pn protocol.PacketNumber, encLevel protocol.EncryptionLevel) *Packet {
if el, ok := handler.packetHistory.packetMap[pn]; ok { if el, ok := handler.getPacketNumberSpace(encLevel).history.packetMap[pn]; ok {
return &el.Value return &el.Value
} }
return nil return nil
} }
losePacket := func(pn protocol.PacketNumber) { losePacket := func(pn protocol.PacketNumber, encLevel protocol.EncryptionLevel) {
p := getPacket(pn) p := getPacket(pn, encLevel)
ExpectWithOffset(1, p).ToNot(BeNil()) ExpectWithOffset(1, p).ToNot(BeNil())
handler.queuePacketForRetransmission(p) handler.queuePacketForRetransmission(p, handler.getPacketNumberSpace(encLevel))
if p.includedInBytesInFlight { if p.includedInBytesInFlight {
p.includedInBytesInFlight = false p.includedInBytesInFlight = false
handler.bytesInFlight -= p.Length handler.bytesInFlight -= p.Length
@ -77,10 +77,11 @@ var _ = Describe("SentPacketHandler", func() {
ExpectWithOffset(1, r.PacketNumber).To(Equal(pn)) ExpectWithOffset(1, r.PacketNumber).To(Equal(pn))
} }
expectInPacketHistory := func(expected []protocol.PacketNumber) { expectInPacketHistory := func(expected []protocol.PacketNumber, encLevel protocol.EncryptionLevel) {
ExpectWithOffset(1, handler.packetHistory.Len()).To(Equal(len(expected))) pnSpace := handler.getPacketNumberSpace(encLevel)
ExpectWithOffset(1, pnSpace.history.Len()).To(Equal(len(expected)))
for _, p := range expected { for _, p := range expected {
ExpectWithOffset(1, handler.packetHistory.packetMap).To(HaveKey(p)) ExpectWithOffset(1, pnSpace.history.packetMap).To(HaveKey(p))
} }
} }
@ -91,19 +92,19 @@ var _ = Describe("SentPacketHandler", func() {
Context("registering sent packets", func() { Context("registering sent packets", func() {
It("accepts two consecutive packets", func() { It("accepts two consecutive packets", func() {
handler.SentPacket(retransmittablePacket(&Packet{PacketNumber: 1})) handler.SentPacket(retransmittablePacket(&Packet{PacketNumber: 1, EncryptionLevel: protocol.EncryptionHandshake}))
handler.SentPacket(retransmittablePacket(&Packet{PacketNumber: 2})) handler.SentPacket(retransmittablePacket(&Packet{PacketNumber: 2, EncryptionLevel: protocol.EncryptionHandshake}))
Expect(handler.largestSent).To(Equal(protocol.PacketNumber(2))) Expect(handler.handshakePackets.largestSent).To(Equal(protocol.PacketNumber(2)))
expectInPacketHistory([]protocol.PacketNumber{1, 2}) expectInPacketHistory([]protocol.PacketNumber{1, 2}, protocol.EncryptionHandshake)
Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(2))) Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(2)))
}) })
It("accepts packet number 0", func() { It("accepts packet number 0", func() {
handler.SentPacket(retransmittablePacket(&Packet{PacketNumber: 0})) handler.SentPacket(retransmittablePacket(&Packet{PacketNumber: 0, EncryptionLevel: protocol.Encryption1RTT}))
Expect(handler.largestSent).To(BeZero()) Expect(handler.oneRTTPackets.largestSent).To(BeZero())
handler.SentPacket(retransmittablePacket(&Packet{PacketNumber: 1})) handler.SentPacket(retransmittablePacket(&Packet{PacketNumber: 1, EncryptionLevel: protocol.Encryption1RTT}))
Expect(handler.largestSent).To(Equal(protocol.PacketNumber(1))) Expect(handler.oneRTTPackets.largestSent).To(Equal(protocol.PacketNumber(1)))
expectInPacketHistory([]protocol.PacketNumber{0, 1}) expectInPacketHistory([]protocol.PacketNumber{0, 1}, protocol.Encryption1RTT)
Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(2))) Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(2)))
}) })
@ -121,8 +122,8 @@ var _ = Describe("SentPacketHandler", func() {
}) })
It("does not store non-retransmittable packets", func() { It("does not store non-retransmittable packets", func() {
handler.SentPacket(nonRetransmittablePacket(&Packet{PacketNumber: 1})) handler.SentPacket(nonRetransmittablePacket(&Packet{PacketNumber: 1, EncryptionLevel: protocol.Encryption1RTT}))
Expect(handler.packetHistory.Len()).To(BeZero()) Expect(handler.oneRTTPackets.history.Len()).To(BeZero())
Expect(handler.lastSentRetransmittablePacketTime).To(BeZero()) Expect(handler.lastSentRetransmittablePacketTime).To(BeZero())
Expect(handler.bytesInFlight).To(BeZero()) Expect(handler.bytesInFlight).To(BeZero())
}) })
@ -143,37 +144,33 @@ var _ = Describe("SentPacketHandler", func() {
ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 0, Largest: 5}}} ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 0, Largest: 5}}}
err := handler.ReceivedAck(ack, 0, protocol.Encryption1RTT, time.Now()) err := handler.ReceivedAck(ack, 0, protocol.Encryption1RTT, time.Now())
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(handler.largestAcked).To(Equal(protocol.PacketNumber(5))) Expect(handler.oneRTTPackets.largestAcked).To(Equal(protocol.PacketNumber(5)))
}) })
It("accepts multiple ACKs sent in the same packet", func() { It("accepts multiple ACKs sent in the same packet", func() {
ack1 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 0, Largest: 3}}} ack1 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 0, Largest: 3}}}
ack2 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 0, Largest: 4}}} ack2 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 0, Largest: 4}}}
err := handler.ReceivedAck(ack1, 1337, protocol.Encryption1RTT, time.Now()) Expect(handler.ReceivedAck(ack1, 1337, protocol.Encryption1RTT, time.Now())).To(Succeed())
Expect(err).ToNot(HaveOccurred()) Expect(handler.oneRTTPackets.largestAcked).To(Equal(protocol.PacketNumber(3)))
Expect(handler.largestAcked).To(Equal(protocol.PacketNumber(3)))
// this wouldn't happen in practice // this wouldn't happen in practice
// for testing purposes, we pretend send a different ACK frame in a duplicated packet, to be able to verify that it actually doesn't get processed // for testing purposes, we pretend send a different ACK frame in a duplicated packet, to be able to verify that it actually doesn't get processed
err = handler.ReceivedAck(ack2, 1337, protocol.Encryption1RTT, time.Now()) Expect(handler.ReceivedAck(ack2, 1337, protocol.Encryption1RTT, time.Now())).To(Succeed())
Expect(err).ToNot(HaveOccurred()) Expect(handler.oneRTTPackets.largestAcked).To(Equal(protocol.PacketNumber(4)))
Expect(handler.largestAcked).To(Equal(protocol.PacketNumber(4)))
}) })
It("rejects ACKs with a too high LargestAcked packet number", func() { It("rejects ACKs with a too high LargestAcked packet number", func() {
ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 0, Largest: 9999}}} ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 0, Largest: 9999}}}
err := handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now()) err := handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now())
Expect(err).To(MatchError("InvalidAckData: Received ACK for an unsent package")) Expect(err).To(MatchError("InvalidAckData: Received ACK for an unsent packet"))
Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(10))) Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(10)))
}) })
It("ignores repeated ACKs", func() { It("ignores repeated ACKs", func() {
ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 3}}} ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 3}}}
err := handler.ReceivedAck(ack, 1337, protocol.Encryption1RTT, time.Now()) Expect(handler.ReceivedAck(ack, 1337, protocol.Encryption1RTT, time.Now())).To(Succeed())
Expect(err).ToNot(HaveOccurred())
Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(7))) Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(7)))
err = handler.ReceivedAck(ack, 1337+1, protocol.Encryption1RTT, time.Now()) Expect(handler.ReceivedAck(ack, 1337+1, protocol.Encryption1RTT, time.Now())).To(Succeed())
Expect(err).ToNot(HaveOccurred()) Expect(handler.oneRTTPackets.largestAcked).To(Equal(protocol.PacketNumber(3)))
Expect(handler.largestAcked).To(Equal(protocol.PacketNumber(3)))
Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(7))) Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(7)))
}) })
}) })
@ -181,19 +178,17 @@ var _ = Describe("SentPacketHandler", func() {
Context("acks and nacks the right packets", func() { Context("acks and nacks the right packets", func() {
It("adjusts the LargestAcked, and adjusts the bytes in flight", func() { It("adjusts the LargestAcked, and adjusts the bytes in flight", func() {
ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 0, Largest: 5}}} ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 0, Largest: 5}}}
err := handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now()) Expect(handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now())).To(Succeed())
Expect(err).ToNot(HaveOccurred()) Expect(handler.oneRTTPackets.largestAcked).To(Equal(protocol.PacketNumber(5)))
Expect(handler.largestAcked).To(Equal(protocol.PacketNumber(5))) expectInPacketHistory([]protocol.PacketNumber{6, 7, 8, 9}, protocol.Encryption1RTT)
expectInPacketHistory([]protocol.PacketNumber{6, 7, 8, 9})
Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(4))) Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(4)))
}) })
It("acks packet 0", func() { It("acks packet 0", func() {
ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 0, Largest: 0}}} ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 0, Largest: 0}}}
err := handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now()) Expect(handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now())).To(Succeed())
Expect(err).ToNot(HaveOccurred()) Expect(getPacket(0, protocol.Encryption1RTT)).To(BeNil())
Expect(getPacket(0)).To(BeNil()) expectInPacketHistory([]protocol.PacketNumber{1, 2, 3, 4, 5, 6, 7, 8, 9}, protocol.Encryption1RTT)
expectInPacketHistory([]protocol.PacketNumber{1, 2, 3, 4, 5, 6, 7, 8, 9})
}) })
It("handles an ACK frame with one missing packet range", func() { It("handles an ACK frame with one missing packet range", func() {
@ -203,16 +198,14 @@ var _ = Describe("SentPacketHandler", func() {
{Smallest: 1, Largest: 3}, {Smallest: 1, Largest: 3},
}, },
} }
err := handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now()) Expect(handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now())).To(Succeed())
Expect(err).ToNot(HaveOccurred()) expectInPacketHistory([]protocol.PacketNumber{0, 4, 5}, protocol.Encryption1RTT)
expectInPacketHistory([]protocol.PacketNumber{0, 4, 5})
}) })
It("does not ack packets below the LowestAcked", func() { It("does not ack packets below the LowestAcked", func() {
ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 3, Largest: 8}}} ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 3, Largest: 8}}}
err := handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now()) Expect(handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now())).To(Succeed())
Expect(err).ToNot(HaveOccurred()) expectInPacketHistory([]protocol.PacketNumber{0, 1, 2, 9}, protocol.Encryption1RTT)
expectInPacketHistory([]protocol.PacketNumber{0, 1, 2, 9})
}) })
It("handles an ACK with multiple missing packet ranges", func() { It("handles an ACK with multiple missing packet ranges", func() {
@ -224,9 +217,8 @@ var _ = Describe("SentPacketHandler", func() {
{Smallest: 1, Largest: 1}, {Smallest: 1, Largest: 1},
}, },
} }
err := handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now()) Expect(handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now())).To(Succeed())
Expect(err).ToNot(HaveOccurred()) expectInPacketHistory([]protocol.PacketNumber{0, 2, 4, 5, 8}, protocol.Encryption1RTT)
expectInPacketHistory([]protocol.PacketNumber{0, 2, 4, 5, 8})
}) })
It("processes an ACK frame that would be sent after a late arrival of a packet", func() { It("processes an ACK frame that would be sent after a late arrival of a packet", func() {
@ -236,14 +228,12 @@ var _ = Describe("SentPacketHandler", func() {
{Smallest: 1, Largest: 2}, {Smallest: 1, Largest: 2},
}, },
} }
err := handler.ReceivedAck(ack1, 1, protocol.Encryption1RTT, time.Now()) Expect(handler.ReceivedAck(ack1, 1, protocol.Encryption1RTT, time.Now())).To(Succeed())
Expect(err).ToNot(HaveOccurred()) expectInPacketHistory([]protocol.PacketNumber{0, 3, 7, 8, 9}, protocol.Encryption1RTT)
expectInPacketHistory([]protocol.PacketNumber{0, 3, 7, 8, 9})
Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(5))) Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(5)))
ack2 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 6}}} // now ack 3 ack2 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 6}}} // now ack 3
err = handler.ReceivedAck(ack2, 2, protocol.Encryption1RTT, time.Now()) Expect(handler.ReceivedAck(ack2, 2, protocol.Encryption1RTT, time.Now())).To(Succeed())
Expect(err).ToNot(HaveOccurred()) expectInPacketHistory([]protocol.PacketNumber{0, 7, 8, 9}, protocol.Encryption1RTT)
expectInPacketHistory([]protocol.PacketNumber{0, 7, 8, 9})
Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(4))) Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(4)))
}) })
@ -254,22 +244,19 @@ var _ = Describe("SentPacketHandler", func() {
{Smallest: 0, Largest: 2}, {Smallest: 0, Largest: 2},
}, },
} }
err := handler.ReceivedAck(ack1, 1, protocol.Encryption1RTT, time.Now()) Expect(handler.ReceivedAck(ack1, 1, protocol.Encryption1RTT, time.Now())).To(Succeed())
Expect(err).ToNot(HaveOccurred()) expectInPacketHistory([]protocol.PacketNumber{3, 7, 8, 9}, protocol.Encryption1RTT)
expectInPacketHistory([]protocol.PacketNumber{3, 7, 8, 9})
Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(4))) Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(4)))
ack2 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 7}}} ack2 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 7}}}
err = handler.ReceivedAck(ack2, 2, protocol.Encryption1RTT, time.Now()) Expect(handler.ReceivedAck(ack2, 2, protocol.Encryption1RTT, time.Now())).To(Succeed())
Expect(err).ToNot(HaveOccurred())
Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(2))) Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(2)))
expectInPacketHistory([]protocol.PacketNumber{8, 9}) expectInPacketHistory([]protocol.PacketNumber{8, 9}, protocol.Encryption1RTT)
}) })
It("processes an ACK that contains old ACK ranges", func() { It("processes an ACK that contains old ACK ranges", func() {
ack1 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 6}}} ack1 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 6}}}
err := handler.ReceivedAck(ack1, 1, protocol.Encryption1RTT, time.Now()) Expect(handler.ReceivedAck(ack1, 1, protocol.Encryption1RTT, time.Now())).To(Succeed())
Expect(err).ToNot(HaveOccurred()) expectInPacketHistory([]protocol.PacketNumber{0, 7, 8, 9}, protocol.Encryption1RTT)
expectInPacketHistory([]protocol.PacketNumber{0, 7, 8, 9})
Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(4))) Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(4)))
ack2 := &wire.AckFrame{ ack2 := &wire.AckFrame{
AckRanges: []wire.AckRange{ AckRanges: []wire.AckRange{
@ -278,9 +265,8 @@ var _ = Describe("SentPacketHandler", func() {
{Smallest: 1, Largest: 1}, {Smallest: 1, Largest: 1},
}, },
} }
err = handler.ReceivedAck(ack2, 2, protocol.Encryption1RTT, time.Now()) Expect(handler.ReceivedAck(ack2, 2, protocol.Encryption1RTT, time.Now())).To(Succeed())
Expect(err).ToNot(HaveOccurred()) expectInPacketHistory([]protocol.PacketNumber{0, 7, 9}, protocol.Encryption1RTT)
expectInPacketHistory([]protocol.PacketNumber{0, 7, 9})
Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(3))) Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(3)))
}) })
}) })
@ -289,9 +275,9 @@ var _ = Describe("SentPacketHandler", func() {
It("computes the RTT", func() { It("computes the RTT", func() {
now := time.Now() now := time.Now()
// First, fake the sent times of the first, second and last packet // First, fake the sent times of the first, second and last packet
getPacket(1).SendTime = now.Add(-10 * time.Minute) getPacket(1, protocol.Encryption1RTT).SendTime = now.Add(-10 * time.Minute)
getPacket(2).SendTime = now.Add(-5 * time.Minute) getPacket(2, protocol.Encryption1RTT).SendTime = now.Add(-5 * time.Minute)
getPacket(6).SendTime = now.Add(-1 * time.Minute) getPacket(6, protocol.Encryption1RTT).SendTime = now.Add(-1 * time.Minute)
// Now, check that the proper times are used when calculating the deltas // Now, check that the proper times are used when calculating the deltas
ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}} ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}}
err := handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now()) err := handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now())
@ -311,7 +297,7 @@ var _ = Describe("SentPacketHandler", func() {
now := time.Now() now := time.Now()
// make sure the rttStats have a min RTT, so that the delay is used // make sure the rttStats have a min RTT, so that the delay is used
handler.rttStats.UpdateRTT(5*time.Minute, 0, time.Now()) handler.rttStats.UpdateRTT(5*time.Minute, 0, time.Now())
getPacket(1).SendTime = now.Add(-10 * time.Minute) getPacket(1, protocol.Encryption1RTT).SendTime = now.Add(-10 * time.Minute)
ack := &wire.AckFrame{ ack := &wire.AckFrame{
AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}, AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}},
DelayTime: 5 * time.Minute, DelayTime: 5 * time.Minute,
@ -327,9 +313,9 @@ var _ = Describe("SentPacketHandler", func() {
ack1 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 80, Largest: 100}}} ack1 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 80, Largest: 100}}}
ack2 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 50, Largest: 200}}} ack2 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 50, Largest: 200}}}
morePackets := []*Packet{ morePackets := []*Packet{
{PacketNumber: 13, Frames: []wire.Frame{ack1, &streamFrame}, Length: 1}, {PacketNumber: 13, Frames: []wire.Frame{ack1, &streamFrame}, Length: 1, EncryptionLevel: protocol.Encryption1RTT},
{PacketNumber: 14, Frames: []wire.Frame{ack2, &streamFrame}, Length: 1}, {PacketNumber: 14, Frames: []wire.Frame{ack2, &streamFrame}, Length: 1, EncryptionLevel: protocol.Encryption1RTT},
{PacketNumber: 15, Frames: []wire.Frame{&streamFrame}, Length: 1}, {PacketNumber: 15, Frames: []wire.Frame{&streamFrame}, Length: 1, EncryptionLevel: protocol.Encryption1RTT},
} }
for _, packet := range morePackets { for _, packet := range morePackets {
handler.SentPacket(packet) handler.SentPacket(packet)
@ -337,28 +323,26 @@ var _ = Describe("SentPacketHandler", func() {
}) })
It("determines which ACK we have received an ACK for", func() { It("determines which ACK we have received an ACK for", func() {
err := handler.ReceivedAck(&wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 13, Largest: 15}}}, 1, protocol.Encryption1RTT, time.Now()) ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 13, Largest: 15}}}
Expect(err).ToNot(HaveOccurred()) Expect(handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now())).To(Succeed())
Expect(handler.GetLowestPacketNotConfirmedAcked()).To(Equal(protocol.PacketNumber(201))) Expect(handler.GetLowestPacketNotConfirmedAcked()).To(Equal(protocol.PacketNumber(201)))
}) })
It("doesn't do anything when the acked packet didn't contain an ACK", func() { It("doesn't do anything when the acked packet didn't contain an ACK", func() {
ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 13, Largest: 13}}} ack1 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 13, Largest: 13}}}
err := handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now()) ack2 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 15, Largest: 15}}}
Expect(err).ToNot(HaveOccurred()) Expect(handler.ReceivedAck(ack1, 1, protocol.Encryption1RTT, time.Now())).To(Succeed())
Expect(handler.GetLowestPacketNotConfirmedAcked()).To(Equal(protocol.PacketNumber(101))) Expect(handler.GetLowestPacketNotConfirmedAcked()).To(Equal(protocol.PacketNumber(101)))
ack = &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 15, Largest: 15}}} Expect(handler.ReceivedAck(ack2, 2, protocol.Encryption1RTT, time.Now())).To(Succeed())
err = handler.ReceivedAck(ack, 2, protocol.Encryption1RTT, time.Now())
Expect(err).ToNot(HaveOccurred())
Expect(handler.GetLowestPacketNotConfirmedAcked()).To(Equal(protocol.PacketNumber(101))) Expect(handler.GetLowestPacketNotConfirmedAcked()).To(Equal(protocol.PacketNumber(101)))
}) })
It("doesn't decrease the value", func() { It("doesn't decrease the value", func() {
err := handler.ReceivedAck(&wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 14, Largest: 14}}}, 1, protocol.Encryption1RTT, time.Now()) ack1 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 14, Largest: 14}}}
Expect(err).ToNot(HaveOccurred()) ack2 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 13, Largest: 13}}}
Expect(handler.ReceivedAck(ack1, 1, protocol.Encryption1RTT, time.Now())).To(Succeed())
Expect(handler.GetLowestPacketNotConfirmedAcked()).To(Equal(protocol.PacketNumber(201))) Expect(handler.GetLowestPacketNotConfirmedAcked()).To(Equal(protocol.PacketNumber(201)))
err = handler.ReceivedAck(&wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 13, Largest: 13}}}, 2, protocol.Encryption1RTT, time.Now()) Expect(handler.ReceivedAck(ack2, 2, protocol.Encryption1RTT, time.Now())).To(Succeed())
Expect(err).ToNot(HaveOccurred())
Expect(handler.GetLowestPacketNotConfirmedAcked()).To(Equal(protocol.PacketNumber(201))) Expect(handler.GetLowestPacketNotConfirmedAcked()).To(Equal(protocol.PacketNumber(201)))
}) })
}) })
@ -367,9 +351,9 @@ var _ = Describe("SentPacketHandler", func() {
Context("ACK processing, for retransmitted packets", func() { Context("ACK processing, for retransmitted packets", func() {
It("sends a packet as retransmission", func() { It("sends a packet as retransmission", func() {
// packet 5 was retransmitted as packet 6 // packet 5 was retransmitted as packet 6
handler.SentPacket(retransmittablePacket(&Packet{PacketNumber: 5, Length: 10})) handler.SentPacket(retransmittablePacket(&Packet{PacketNumber: 5, Length: 10, EncryptionLevel: protocol.Encryption1RTT}))
Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(10))) Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(10)))
losePacket(5) losePacket(5, protocol.Encryption1RTT)
Expect(handler.bytesInFlight).To(BeZero()) Expect(handler.bytesInFlight).To(BeZero())
handler.SentPacketsAsRetransmission([]*Packet{retransmittablePacket(&Packet{PacketNumber: 6, Length: 11})}, 5) handler.SentPacketsAsRetransmission([]*Packet{retransmittablePacket(&Packet{PacketNumber: 6, Length: 11})}, 5)
Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(11))) Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(11)))
@ -378,21 +362,21 @@ var _ = Describe("SentPacketHandler", func() {
It("removes a packet when it is acked", func() { It("removes a packet when it is acked", func() {
// packet 5 was retransmitted as packet 6 // packet 5 was retransmitted as packet 6
handler.SentPacket(retransmittablePacket(&Packet{PacketNumber: 5, Length: 10})) handler.SentPacket(retransmittablePacket(&Packet{PacketNumber: 5, Length: 10}))
losePacket(5) losePacket(5, protocol.Encryption1RTT)
handler.SentPacketsAsRetransmission([]*Packet{retransmittablePacket(&Packet{PacketNumber: 6, Length: 11})}, 5) handler.SentPacketsAsRetransmission([]*Packet{retransmittablePacket(&Packet{PacketNumber: 6, Length: 11})}, 5)
Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(11))) Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(11)))
// ack 5 // ack 5
ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 5, Largest: 5}}} ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 5, Largest: 5}}}
err := handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now()) err := handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now())
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
expectInPacketHistory([]protocol.PacketNumber{6}) expectInPacketHistory([]protocol.PacketNumber{6}, protocol.Encryption1RTT)
Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(11))) Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(11)))
}) })
It("handles ACKs that ack the original packet as well as the retransmission", func() { It("handles ACKs that ack the original packet as well as the retransmission", func() {
// packet 5 was retransmitted as packet 7 // packet 5 was retransmitted as packet 7
handler.SentPacket(retransmittablePacket(&Packet{PacketNumber: 5, Length: 10})) handler.SentPacket(retransmittablePacket(&Packet{PacketNumber: 5, Length: 10}))
losePacket(5) losePacket(5, protocol.Encryption1RTT)
handler.SentPacketsAsRetransmission([]*Packet{retransmittablePacket(&Packet{PacketNumber: 7, Length: 11})}, 5) handler.SentPacketsAsRetransmission([]*Packet{retransmittablePacket(&Packet{PacketNumber: 7, Length: 11})}, 5)
// ack 5 and 7 // ack 5 and 7
ack := &wire.AckFrame{ ack := &wire.AckFrame{
@ -403,13 +387,13 @@ var _ = Describe("SentPacketHandler", func() {
} }
err := handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now()) err := handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now())
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(handler.packetHistory.Len()).To(BeZero()) Expect(handler.oneRTTPackets.history.Len()).To(BeZero())
Expect(handler.bytesInFlight).To(BeZero()) Expect(handler.bytesInFlight).To(BeZero())
}) })
}) })
It("does not dequeue a packet if no ack has been received", func() { It("does not dequeue a packet if no ACK has been received", func() {
handler.SentPacket(&Packet{PacketNumber: 1}) handler.SentPacket(&Packet{PacketNumber: 1, EncryptionLevel: protocol.Encryption1RTT, SendTime: time.Now().Add(-time.Hour)})
Expect(handler.DequeuePacketForRetransmission()).To(BeNil()) Expect(handler.DequeuePacketForRetransmission()).To(BeNil())
}) })
@ -430,12 +414,12 @@ var _ = Describe("SentPacketHandler", func() {
true, true,
) )
cong.EXPECT().TimeUntilSend(gomock.Any()) cong.EXPECT().TimeUntilSend(gomock.Any())
p := &Packet{ handler.SentPacket(&Packet{
PacketNumber: 1, PacketNumber: 1,
Length: 42, Length: 42,
Frames: []wire.Frame{&wire.PingFrame{}}, Frames: []wire.Frame{&wire.PingFrame{}},
} EncryptionLevel: protocol.Encryption1RTT,
handler.SentPacket(p) })
}) })
It("should call MaybeExitSlowStart and OnPacketAcked", func() { It("should call MaybeExitSlowStart and OnPacketAcked", func() {
@ -557,7 +541,7 @@ var _ = Describe("SentPacketHandler", func() {
handler.bytesInFlight = 100 handler.bytesInFlight = 100
cong.EXPECT().OnPacketSent(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()) cong.EXPECT().OnPacketSent(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any())
cong.EXPECT().TimeUntilSend(protocol.ByteCount(100)).Return(time.Hour) cong.EXPECT().TimeUntilSend(protocol.ByteCount(100)).Return(time.Hour)
handler.SentPacket(&Packet{PacketNumber: 1, SendTime: sendTime}) handler.SentPacket(&Packet{PacketNumber: 1, SendTime: sendTime, EncryptionLevel: protocol.Encryption1RTT})
Expect(handler.TimeUntilSend()).To(Equal(sendTime.Add(time.Hour))) Expect(handler.TimeUntilSend()).To(Equal(sendTime.Add(time.Hour)))
}) })
@ -672,7 +656,7 @@ var _ = Describe("SentPacketHandler", func() {
Expect(handler.ptoCount).To(BeEquivalentTo(3)) Expect(handler.ptoCount).To(BeEquivalentTo(3))
}) })
It("doesn't delete packets transmitted as RTO from the history", func() { It("doesn't delete packets transmitted as PTO from the history", func() {
handler.SentPacket(retransmittablePacket(&Packet{PacketNumber: 1, SendTime: time.Now().Add(-time.Hour)})) handler.SentPacket(retransmittablePacket(&Packet{PacketNumber: 1, SendTime: time.Now().Add(-time.Hour)}))
handler.SentPacket(retransmittablePacket(&Packet{PacketNumber: 2, SendTime: time.Now().Add(-time.Hour)})) handler.SentPacket(retransmittablePacket(&Packet{PacketNumber: 2, SendTime: time.Now().Add(-time.Hour)}))
handler.rttStats.UpdateRTT(time.Second, 0, time.Now()) handler.rttStats.UpdateRTT(time.Second, 0, time.Now())
@ -683,15 +667,15 @@ var _ = Describe("SentPacketHandler", func() {
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
_, err = handler.DequeueProbePacket() _, err = handler.DequeueProbePacket()
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
expectInPacketHistory([]protocol.PacketNumber{1, 2}) expectInPacketHistory([]protocol.PacketNumber{1, 2}, protocol.Encryption1RTT)
Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(2))) Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(2)))
// Send a probe packet and receive an ACK for it. // Send a probe packet and receive an ACK for it.
// This verifies the RTO. // This verifies the RTO.
handler.SentPacket(retransmittablePacket(&Packet{PacketNumber: 3})) handler.SentPacket(retransmittablePacket(&Packet{PacketNumber: 3}))
ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 3, Largest: 3}}} ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 3, Largest: 3}}}
err = handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now()) Expect(handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now())).To(Succeed())
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(handler.packetHistory.Len()).To(BeZero()) Expect(handler.oneRTTPackets.history.Len()).To(BeZero())
Expect(handler.bytesInFlight).To(BeZero()) Expect(handler.bytesInFlight).To(BeZero())
Expect(handler.retransmissionQueue).To(BeEmpty()) // 1 and 2 were already sent as probe packets Expect(handler.retransmissionQueue).To(BeEmpty()) // 1 and 2 were already sent as probe packets
}) })
@ -709,14 +693,14 @@ var _ = Describe("SentPacketHandler", func() {
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
_, err = handler.DequeueProbePacket() _, err = handler.DequeueProbePacket()
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
expectInPacketHistory([]protocol.PacketNumber{1, 2, 3, 4, 5}) expectInPacketHistory([]protocol.PacketNumber{1, 2, 3, 4, 5}, protocol.Encryption1RTT)
// Send a probe packet and receive an ACK for it. // Send a probe packet and receive an ACK for it.
// This verifies the RTO. // This verifies the RTO.
handler.SentPacket(retransmittablePacket(&Packet{PacketNumber: 6})) handler.SentPacket(retransmittablePacket(&Packet{PacketNumber: 6}))
ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 6, Largest: 6}}} ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 6, Largest: 6}}}
err = handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now()) err = handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, time.Now())
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(handler.packetHistory.Len()).To(BeZero()) Expect(handler.oneRTTPackets.history.Len()).To(BeZero())
Expect(handler.bytesInFlight).To(BeZero()) Expect(handler.bytesInFlight).To(BeZero())
Expect(handler.retransmissionQueue).To(HaveLen(3)) // packets 3, 4, 5 Expect(handler.retransmissionQueue).To(HaveLen(3)) // packets 3, 4, 5
}) })
@ -764,22 +748,20 @@ var _ = Describe("SentPacketHandler", func() {
It("sets the early retransmit alarm", func() { It("sets the early retransmit alarm", func() {
now := time.Now() now := time.Now()
handler.SentPacket(retransmittablePacket(&Packet{PacketNumber: 1, SendTime: now.Add(-2 * time.Second)})) handler.SentPacket(retransmittablePacket(&Packet{PacketNumber: 1, SendTime: now.Add(-2 * time.Second), EncryptionLevel: protocol.Encryption1RTT}))
handler.SentPacket(retransmittablePacket(&Packet{PacketNumber: 2, SendTime: now.Add(-2 * time.Second)})) handler.SentPacket(retransmittablePacket(&Packet{PacketNumber: 2, SendTime: now.Add(-2 * time.Second), EncryptionLevel: protocol.Encryption1RTT}))
handler.SentPacket(retransmittablePacket(&Packet{PacketNumber: 3, SendTime: now.Add(-time.Second)})) handler.SentPacket(retransmittablePacket(&Packet{PacketNumber: 3, SendTime: now.Add(-time.Second), EncryptionLevel: protocol.Encryption1RTT}))
Expect(handler.lossTime.IsZero()).To(BeTrue()) Expect(handler.lossTime.IsZero()).To(BeTrue())
ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 2, Largest: 2}}} ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 2, Largest: 2}}}
err := handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, now.Add(-time.Second)) Expect(handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, now.Add(-time.Second))).To(Succeed())
Expect(err).NotTo(HaveOccurred())
Expect(handler.rttStats.SmoothedRTT()).To(Equal(time.Second)) Expect(handler.rttStats.SmoothedRTT()).To(Equal(time.Second))
// Packet 1 should be considered lost (1+1/8) RTTs after it was sent. // Packet 1 should be considered lost (1+1/8) RTTs after it was sent.
Expect(handler.lossTime.IsZero()).To(BeFalse()) Expect(handler.lossTime.IsZero()).To(BeFalse())
Expect(handler.lossTime.Sub(getPacket(1).SendTime)).To(Equal(time.Second * 9 / 8)) Expect(handler.lossTime.Sub(getPacket(1, protocol.Encryption1RTT).SendTime)).To(Equal(time.Second * 9 / 8))
err = handler.OnAlarm() Expect(handler.OnAlarm()).To(Succeed())
Expect(err).ToNot(HaveOccurred())
Expect(handler.DequeuePacketForRetransmission()).NotTo(BeNil()) Expect(handler.DequeuePacketForRetransmission()).NotTo(BeNil())
// make sure this is not an RTO: only packet 1 is retransmissted // make sure this is not an RTO: only packet 1 is retransmissted
Expect(handler.DequeuePacketForRetransmission()).To(BeNil()) Expect(handler.DequeuePacketForRetransmission()).To(BeNil())
@ -795,22 +777,20 @@ var _ = Describe("SentPacketHandler", func() {
now := time.Now() now := time.Now()
sendTime := now.Add(-time.Minute) sendTime := now.Add(-time.Minute)
lastCryptoPacketSendTime := now.Add(-30 * time.Second) lastCryptoPacketSendTime := now.Add(-30 * time.Second)
// send crypto packets: 1, 3 // send Initial packets: 1, 3
// send a forward-secure packet: 2 // send 1-RTT packet: 100
handler.SentPacket(cryptoPacket(&Packet{PacketNumber: 1, SendTime: sendTime})) handler.SentPacket(cryptoPacket(&Packet{PacketNumber: 1, SendTime: sendTime, EncryptionLevel: protocol.EncryptionInitial}))
handler.SentPacket(retransmittablePacket(&Packet{PacketNumber: 2, SendTime: sendTime})) handler.SentPacket(cryptoPacket(&Packet{PacketNumber: 3, SendTime: sendTime, EncryptionLevel: protocol.EncryptionInitial}))
handler.SentPacket(cryptoPacket(&Packet{PacketNumber: 3, SendTime: sendTime})) handler.SentPacket(retransmittablePacket(&Packet{PacketNumber: 100, SendTime: sendTime, EncryptionLevel: protocol.Encryption1RTT}))
ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}} ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}}
err := handler.ReceivedAck(ack, 1, protocol.Encryption1RTT, now) Expect(handler.ReceivedAck(ack, 1, protocol.EncryptionInitial, now)).To(Succeed())
// RTT is now 1 minute // RTT is now 1 minute
Expect(handler.rttStats.SmoothedRTT()).To(Equal(time.Minute)) Expect(handler.rttStats.SmoothedRTT()).To(Equal(time.Minute))
Expect(err).NotTo(HaveOccurred())
Expect(handler.lossTime.IsZero()).To(BeTrue()) Expect(handler.lossTime.IsZero()).To(BeTrue())
Expect(handler.GetAlarmTimeout().Sub(sendTime)).To(Equal(2 * time.Minute)) Expect(handler.GetAlarmTimeout().Sub(sendTime)).To(Equal(2 * time.Minute))
err = handler.OnAlarm() Expect(handler.OnAlarm()).To(Succeed())
Expect(err).ToNot(HaveOccurred())
p := handler.DequeuePacketForRetransmission() p := handler.DequeuePacketForRetransmission()
Expect(p).ToNot(BeNil()) Expect(p).ToNot(BeNil())
Expect(p.PacketNumber).To(Equal(protocol.PacketNumber(3))) Expect(p.PacketNumber).To(Equal(protocol.PacketNumber(3)))
@ -820,8 +800,7 @@ var _ = Describe("SentPacketHandler", func() {
Expect(handler.GetAlarmTimeout().Sub(lastCryptoPacketSendTime)).To(Equal(4 * time.Minute)) Expect(handler.GetAlarmTimeout().Sub(lastCryptoPacketSendTime)).To(Equal(4 * time.Minute))
}) })
// TODO(#1534): also check the encryption level for IETF QUIC It("rejects an ACK that acks packets with a higher encryption level", func() {
PIt("rejects an ACK that acks packets with a higher encryption level", func() {
handler.SentPacket(&Packet{ handler.SentPacket(&Packet{
PacketNumber: 13, PacketNumber: 13,
EncryptionLevel: protocol.Encryption1RTT, EncryptionLevel: protocol.Encryption1RTT,
@ -830,19 +809,23 @@ var _ = Describe("SentPacketHandler", func() {
}) })
ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 13, Largest: 13}}} ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 13, Largest: 13}}}
err := handler.ReceivedAck(ack, 1, protocol.EncryptionHandshake, time.Now()) err := handler.ReceivedAck(ack, 1, protocol.EncryptionHandshake, time.Now())
Expect(err).To(MatchError("Received ACK with encryption level encrypted (not forward-secure) that acks a packet 13 (encryption level forward-secure)")) Expect(err).To(MatchError("InvalidAckData: Received ACK for an unsent packet"))
}) })
It("deletes crypto packets when the handshake completes", func() { It("deletes crypto packets when the handshake completes", func() {
for i := protocol.PacketNumber(1); i <= 6; i++ { for i := protocol.PacketNumber(0); i < 6; i++ {
p := retransmittablePacket(&Packet{PacketNumber: i}) p := retransmittablePacket(&Packet{PacketNumber: i, EncryptionLevel: protocol.EncryptionInitial})
p.EncryptionLevel = protocol.EncryptionHandshake
handler.SentPacket(p) handler.SentPacket(p)
} }
handler.queuePacketForRetransmission(getPacket(1)) for i := protocol.PacketNumber(0); i <= 6; i++ {
handler.queuePacketForRetransmission(getPacket(3)) p := retransmittablePacket(&Packet{PacketNumber: i, EncryptionLevel: protocol.EncryptionHandshake})
handler.SentPacket(p)
}
handler.queuePacketForRetransmission(getPacket(1, protocol.EncryptionInitial), handler.getPacketNumberSpace(protocol.EncryptionInitial))
handler.queuePacketForRetransmission(getPacket(3, protocol.EncryptionHandshake), handler.getPacketNumberSpace(protocol.EncryptionHandshake))
handler.SetHandshakeComplete() handler.SetHandshakeComplete()
Expect(handler.packetHistory.Len()).To(BeZero()) Expect(handler.initialPackets.history.Len()).To(BeZero())
Expect(handler.handshakePackets.history.Len()).To(BeZero())
packet := handler.DequeuePacketForRetransmission() packet := handler.DequeuePacketForRetransmission()
Expect(packet).To(BeNil()) Expect(packet).To(BeNil())
}) })
@ -850,14 +833,23 @@ var _ = Describe("SentPacketHandler", func() {
Context("peeking and popping packet number", func() { Context("peeking and popping packet number", func() {
It("peeks and pops the initial packet number", func() { It("peeks and pops the initial packet number", func() {
pn, _ := handler.PeekPacketNumber() pn, _ := handler.PeekPacketNumber(protocol.EncryptionInitial)
Expect(pn).To(Equal(protocol.PacketNumber(42))) Expect(pn).To(Equal(protocol.PacketNumber(42)))
Expect(handler.PopPacketNumber()).To(Equal(protocol.PacketNumber(42))) Expect(handler.PopPacketNumber(protocol.EncryptionInitial)).To(Equal(protocol.PacketNumber(42)))
}) })
It("peeks and pops beyond the initial packet number", func() { It("peeks and pops beyond the initial packet number", func() {
Expect(handler.PopPacketNumber()).To(Equal(protocol.PacketNumber(42))) Expect(handler.PopPacketNumber(protocol.EncryptionInitial)).To(Equal(protocol.PacketNumber(42)))
Expect(handler.PopPacketNumber()).To(BeNumerically(">", 42)) Expect(handler.PopPacketNumber(protocol.EncryptionInitial)).To(BeNumerically(">", 42))
})
It("starts at 0 for handshake and application-data packet number space", func() {
pn, _ := handler.PeekPacketNumber(protocol.EncryptionHandshake)
Expect(pn).To(BeZero())
Expect(handler.PopPacketNumber(protocol.EncryptionHandshake)).To(BeZero())
pn, _ = handler.PeekPacketNumber(protocol.Encryption1RTT)
Expect(pn).To(BeZero())
Expect(handler.PopPacketNumber(protocol.Encryption1RTT)).To(BeZero())
}) })
}) })

22
internal/ackhandler/sent_packet_history.go
View file

@ -10,8 +10,7 @@ type sentPacketHistory struct {
packetList *PacketList packetList *PacketList
packetMap map[protocol.PacketNumber]*PacketElement packetMap map[protocol.PacketNumber]*PacketElement
numOutstandingPackets int numOutstandingPackets int
numOutstandingCryptoPackets int
firstOutstanding *PacketElement firstOutstanding *PacketElement
} }
@ -35,9 +34,6 @@ func (h *sentPacketHistory) sentPacketImpl(p *Packet) *PacketElement {
} }
if p.canBeRetransmitted { if p.canBeRetransmitted {
h.numOutstandingPackets++ h.numOutstandingPackets++
if p.EncryptionLevel != protocol.Encryption1RTT {
h.numOutstandingCryptoPackets++
}
} }
return el return el
} }
@ -106,12 +102,6 @@ func (h *sentPacketHistory) MarkCannotBeRetransmitted(pn protocol.PacketNumber)
if h.numOutstandingPackets < 0 { if h.numOutstandingPackets < 0 {
panic("numOutstandingHandshakePackets negative") panic("numOutstandingHandshakePackets negative")
} }
if el.Value.EncryptionLevel != protocol.Encryption1RTT {
h.numOutstandingCryptoPackets--
if h.numOutstandingCryptoPackets < 0 {
panic("numOutstandingHandshakePackets negative")
}
}
} }
el.Value.canBeRetransmitted = false el.Value.canBeRetransmitted = false
if el == h.firstOutstanding { if el == h.firstOutstanding {
@ -147,12 +137,6 @@ func (h *sentPacketHistory) Remove(p protocol.PacketNumber) error {
if h.numOutstandingPackets < 0 { if h.numOutstandingPackets < 0 {
panic("numOutstandingHandshakePackets negative") panic("numOutstandingHandshakePackets negative")
} }
if el.Value.EncryptionLevel != protocol.Encryption1RTT {
h.numOutstandingCryptoPackets--
if h.numOutstandingCryptoPackets < 0 {
panic("numOutstandingHandshakePackets negative")
}
}
} }
h.packetList.Remove(el) h.packetList.Remove(el)
delete(h.packetMap, p) delete(h.packetMap, p)
@ -162,7 +146,3 @@ func (h *sentPacketHistory) Remove(p protocol.PacketNumber) error {
func (h *sentPacketHistory) HasOutstandingPackets() bool { func (h *sentPacketHistory) HasOutstandingPackets() bool {
return h.numOutstandingPackets > 0 return h.numOutstandingPackets > 0
} }
func (h *sentPacketHistory) HasOutstandingCryptoPackets() bool {
return h.numOutstandingCryptoPackets > 0
}

36
internal/ackhandler/sent_packet_history_test.go
View file

@ -199,23 +199,12 @@ var _ = Describe("SentPacketHistory", func() {
}) })
Context("outstanding packets", func() { Context("outstanding packets", func() {
It("says if it has outstanding crypto packets", func() {
Expect(hist.HasOutstandingCryptoPackets()).To(BeFalse())
hist.SentPacket(&Packet{
EncryptionLevel: protocol.EncryptionInitial,
canBeRetransmitted: true,
})
Expect(hist.HasOutstandingCryptoPackets()).To(BeTrue())
})
It("says if it has outstanding packets", func() { It("says if it has outstanding packets", func() {
Expect(hist.HasOutstandingCryptoPackets()).To(BeFalse())
Expect(hist.HasOutstandingPackets()).To(BeFalse()) Expect(hist.HasOutstandingPackets()).To(BeFalse())
hist.SentPacket(&Packet{ hist.SentPacket(&Packet{
EncryptionLevel: protocol.Encryption1RTT, EncryptionLevel: protocol.Encryption1RTT,
canBeRetransmitted: true, canBeRetransmitted: true,
}) })
Expect(hist.HasOutstandingCryptoPackets()).To(BeFalse())
Expect(hist.HasOutstandingPackets()).To(BeTrue()) Expect(hist.HasOutstandingPackets()).To(BeTrue())
}) })
@ -223,22 +212,9 @@ var _ = Describe("SentPacketHistory", func() {
hist.SentPacket(&Packet{ hist.SentPacket(&Packet{
EncryptionLevel: protocol.EncryptionInitial, EncryptionLevel: protocol.EncryptionInitial,
}) })
Expect(hist.HasOutstandingCryptoPackets()).To(BeFalse())
Expect(hist.HasOutstandingPackets()).To(BeFalse()) Expect(hist.HasOutstandingPackets()).To(BeFalse())
}) })
It("accounts for deleted crypto packets", func() {
hist.SentPacket(&Packet{
PacketNumber: 5,
EncryptionLevel: protocol.EncryptionHandshake,
canBeRetransmitted: true,
})
Expect(hist.HasOutstandingCryptoPackets()).To(BeTrue())
err := hist.Remove(5)
Expect(err).ToNot(HaveOccurred())
Expect(hist.HasOutstandingCryptoPackets()).To(BeFalse())
})
It("accounts for deleted packets", func() { It("accounts for deleted packets", func() {
hist.SentPacket(&Packet{ hist.SentPacket(&Packet{
PacketNumber: 10, PacketNumber: 10,
@ -251,18 +227,6 @@ var _ = Describe("SentPacketHistory", func() {
Expect(hist.HasOutstandingPackets()).To(BeFalse()) Expect(hist.HasOutstandingPackets()).To(BeFalse())
}) })
It("doesn't count crypto packets marked as non-retransmittable", func() {
hist.SentPacket(&Packet{
PacketNumber: 5,
EncryptionLevel: protocol.EncryptionInitial,
canBeRetransmitted: true,
})
Expect(hist.HasOutstandingCryptoPackets()).To(BeTrue())
err := hist.MarkCannotBeRetransmitted(5)
Expect(err).ToNot(HaveOccurred())
Expect(hist.HasOutstandingCryptoPackets()).To(BeFalse())
})
It("doesn't count packets marked as non-retransmittable", func() { It("doesn't count packets marked as non-retransmittable", func() {
hist.SentPacket(&Packet{ hist.SentPacket(&Packet{
PacketNumber: 10, PacketNumber: 10,

16
internal/mocks/ackhandler/sent_packet_handler.go
View file

@ -99,28 +99,28 @@ func (mr *MockSentPacketHandlerMockRecorder) OnAlarm() *gomock.Call {
} }
// PeekPacketNumber mocks base method // PeekPacketNumber mocks base method
func (m *MockSentPacketHandler) PeekPacketNumber() (protocol.PacketNumber, protocol.PacketNumberLen) { func (m *MockSentPacketHandler) PeekPacketNumber(arg0 protocol.EncryptionLevel) (protocol.PacketNumber, protocol.PacketNumberLen) {
ret := m.ctrl.Call(m, "PeekPacketNumber") ret := m.ctrl.Call(m, "PeekPacketNumber", arg0)
ret0, _ := ret[0].(protocol.PacketNumber) ret0, _ := ret[0].(protocol.PacketNumber)
ret1, _ := ret[1].(protocol.PacketNumberLen) ret1, _ := ret[1].(protocol.PacketNumberLen)
return ret0, ret1 return ret0, ret1
} }
// PeekPacketNumber indicates an expected call of PeekPacketNumber // PeekPacketNumber indicates an expected call of PeekPacketNumber
func (mr *MockSentPacketHandlerMockRecorder) PeekPacketNumber() *gomock.Call { func (mr *MockSentPacketHandlerMockRecorder) PeekPacketNumber(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PeekPacketNumber", reflect.TypeOf((*MockSentPacketHandler)(nil).PeekPacketNumber)) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PeekPacketNumber", reflect.TypeOf((*MockSentPacketHandler)(nil).PeekPacketNumber), arg0)
} }
// PopPacketNumber mocks base method // PopPacketNumber mocks base method
func (m *MockSentPacketHandler) PopPacketNumber() protocol.PacketNumber { func (m *MockSentPacketHandler) PopPacketNumber(arg0 protocol.EncryptionLevel) protocol.PacketNumber {
ret := m.ctrl.Call(m, "PopPacketNumber") ret := m.ctrl.Call(m, "PopPacketNumber", arg0)
ret0, _ := ret[0].(protocol.PacketNumber) ret0, _ := ret[0].(protocol.PacketNumber)
return ret0 return ret0
} }
// PopPacketNumber indicates an expected call of PopPacketNumber // PopPacketNumber indicates an expected call of PopPacketNumber
func (mr *MockSentPacketHandlerMockRecorder) PopPacketNumber() *gomock.Call { func (mr *MockSentPacketHandlerMockRecorder) PopPacketNumber(arg0 interface{}) *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PopPacketNumber", reflect.TypeOf((*MockSentPacketHandler)(nil).PopPacketNumber)) return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PopPacketNumber", reflect.TypeOf((*MockSentPacketHandler)(nil).PopPacketNumber), arg0)
} }
// ReceivedAck mocks base method // ReceivedAck mocks base method

19
packet_packer.go
View file

@ -76,8 +76,8 @@ func getMaxPacketSize(addr net.Addr) protocol.ByteCount {
} }
type packetNumberManager interface { type packetNumberManager interface {
PeekPacketNumber() (protocol.PacketNumber, protocol.PacketNumberLen) PeekPacketNumber(protocol.EncryptionLevel) (protocol.PacketNumber, protocol.PacketNumberLen)
PopPacketNumber() protocol.PacketNumber PopPacketNumber(protocol.EncryptionLevel) protocol.PacketNumber
} }
type sealingManager interface { type sealingManager interface {
@ -150,7 +150,7 @@ func (p *packetPacker) PackConnectionClose(ccf *wire.ConnectionCloseFrame) (*pac
frames := []wire.Frame{ccf} frames := []wire.Frame{ccf}
encLevel, sealer := p.cryptoSetup.GetSealer() encLevel, sealer := p.cryptoSetup.GetSealer()
header := p.getHeader(encLevel) header := p.getHeader(encLevel)
return p.writeAndSealPacket(header, frames, sealer) return p.writeAndSealPacket(header, frames, encLevel, sealer)
} }
func (p *packetPacker) MaybePackAckPacket() (*packedPacket, error) { func (p *packetPacker) MaybePackAckPacket() (*packedPacket, error) {
@ -162,7 +162,7 @@ func (p *packetPacker) MaybePackAckPacket() (*packedPacket, error) {
encLevel, sealer := p.cryptoSetup.GetSealer() encLevel, sealer := p.cryptoSetup.GetSealer()
header := p.getHeader(encLevel) header := p.getHeader(encLevel)
frames := []wire.Frame{ack} frames := []wire.Frame{ack}
return p.writeAndSealPacket(header, frames, sealer) return p.writeAndSealPacket(header, frames, encLevel, sealer)
} }
// PackRetransmission packs a retransmission // PackRetransmission packs a retransmission
@ -229,7 +229,7 @@ func (p *packetPacker) PackRetransmission(packet *ackhandler.Packet) ([]*packedP
if sf, ok := frames[len(frames)-1].(*wire.StreamFrame); ok { if sf, ok := frames[len(frames)-1].(*wire.StreamFrame); ok {
sf.DataLenPresent = false sf.DataLenPresent = false
} }
p, err := p.writeAndSealPacket(header, frames, sealer) p, err := p.writeAndSealPacket(header, frames, encLevel, sealer)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -278,7 +278,7 @@ func (p *packetPacker) PackPacket() (*packedPacket, error) {
p.numNonRetransmittableAcks = 0 p.numNonRetransmittableAcks = 0
} }
return p.writeAndSealPacket(header, frames, sealer) return p.writeAndSealPacket(header, frames, encLevel, sealer)
} }
func (p *packetPacker) maybePackCryptoPacket() (*packedPacket, error) { func (p *packetPacker) maybePackCryptoPacket() (*packedPacket, error) {
@ -319,7 +319,7 @@ func (p *packetPacker) maybePackCryptoPacket() (*packedPacket, error) {
cf := s.PopCryptoFrame(p.maxPacketSize - hdrLen - protocol.ByteCount(sealer.Overhead()) - length) cf := s.PopCryptoFrame(p.maxPacketSize - hdrLen - protocol.ByteCount(sealer.Overhead()) - length)
frames = append(frames, cf) frames = append(frames, cf)
} }
return p.writeAndSealPacket(hdr, frames, sealer) return p.writeAndSealPacket(hdr, frames, encLevel, sealer)
} }
func (p *packetPacker) composeNextPacket(maxFrameSize protocol.ByteCount) ([]wire.Frame, error) { func (p *packetPacker) composeNextPacket(maxFrameSize protocol.ByteCount) ([]wire.Frame, error) {
@ -353,7 +353,7 @@ func (p *packetPacker) composeNextPacket(maxFrameSize protocol.ByteCount) ([]wir
} }
func (p *packetPacker) getHeader(encLevel protocol.EncryptionLevel) *wire.ExtendedHeader { func (p *packetPacker) getHeader(encLevel protocol.EncryptionLevel) *wire.ExtendedHeader {
pn, pnLen := p.pnManager.PeekPacketNumber() pn, pnLen := p.pnManager.PeekPacketNumber(encLevel)
header := &wire.ExtendedHeader{} header := &wire.ExtendedHeader{}
header.PacketNumber = pn header.PacketNumber = pn
header.PacketNumberLen = pnLen header.PacketNumberLen = pnLen
@ -384,6 +384,7 @@ func (p *packetPacker) getHeader(encLevel protocol.EncryptionLevel) *wire.Extend
func (p *packetPacker) writeAndSealPacket( func (p *packetPacker) writeAndSealPacket(
header *wire.ExtendedHeader, header *wire.ExtendedHeader,
frames []wire.Frame, frames []wire.Frame,
encLevel protocol.EncryptionLevel,
sealer handshake.Sealer, sealer handshake.Sealer,
) (*packedPacket, error) { ) (*packedPacket, error) {
packetBuffer := getPacketBuffer() packetBuffer := getPacketBuffer()
@ -459,7 +460,7 @@ func (p *packetPacker) writeAndSealPacket(
raw[pnOffset:payloadOffset], raw[pnOffset:payloadOffset],
) )
num := p.pnManager.PopPacketNumber() num := p.pnManager.PopPacketNumber(encLevel)
if num != header.PacketNumber { if num != header.PacketNumber {
return nil, errors.New("packetPacker BUG: Peeked and Popped packet numbers do not match") return nil, errors.New("packetPacker BUG: Peeked and Popped packet numbers do not match")
} }

138
packet_packer_test.go
View file

@ -101,7 +101,7 @@ var _ = Describe("Packet packer", func() {
Context("generating a packet header", func() { Context("generating a packet header", func() {
It("uses the Long Header format", func() { It("uses the Long Header format", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.EncryptionHandshake).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
h := packer.getHeader(protocol.EncryptionHandshake) h := packer.getHeader(protocol.EncryptionHandshake)
Expect(h.IsLongHeader).To(BeTrue()) Expect(h.IsLongHeader).To(BeTrue())
Expect(h.PacketNumber).To(Equal(protocol.PacketNumber(0x42))) Expect(h.PacketNumber).To(Equal(protocol.PacketNumber(0x42)))
@ -111,7 +111,7 @@ var _ = Describe("Packet packer", func() {
}) })
It("sets source and destination connection ID", func() { It("sets source and destination connection ID", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.EncryptionHandshake).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
srcConnID := protocol.ConnectionID{1, 2, 3, 4, 5, 6, 7, 8} srcConnID := protocol.ConnectionID{1, 2, 3, 4, 5, 6, 7, 8}
destConnID := protocol.ConnectionID{8, 7, 6, 5, 4, 3, 2, 1} destConnID := protocol.ConnectionID{8, 7, 6, 5, 4, 3, 2, 1}
packer.srcConnID = srcConnID packer.srcConnID = srcConnID
@ -122,7 +122,7 @@ var _ = Describe("Packet packer", func() {
}) })
It("changes the destination connection ID", func() { It("changes the destination connection ID", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2).Times(2) pnManager.EXPECT().PeekPacketNumber(protocol.EncryptionInitial).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2).Times(2)
srcConnID := protocol.ConnectionID{1, 1, 1, 1, 1, 1, 1, 1} srcConnID := protocol.ConnectionID{1, 1, 1, 1, 1, 1, 1, 1}
packer.srcConnID = srcConnID packer.srcConnID = srcConnID
dest1 := protocol.ConnectionID{1, 2, 3, 4, 5, 6, 7, 8} dest1 := protocol.ConnectionID{1, 2, 3, 4, 5, 6, 7, 8}
@ -138,7 +138,7 @@ var _ = Describe("Packet packer", func() {
}) })
It("uses the Short Header format for 1-RTT packets", func() { It("uses the Short Header format for 1-RTT packets", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x1337), protocol.PacketNumberLen4) pnManager.EXPECT().PeekPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x1337), protocol.PacketNumberLen4)
h := packer.getHeader(protocol.Encryption1RTT) h := packer.getHeader(protocol.Encryption1RTT)
Expect(h.IsLongHeader).To(BeFalse()) Expect(h.IsLongHeader).To(BeFalse())
Expect(h.PacketNumber).To(Equal(protocol.PacketNumber(0x1337))) Expect(h.PacketNumber).To(Equal(protocol.PacketNumber(0x1337)))
@ -150,8 +150,8 @@ var _ = Describe("Packet packer", func() {
It("encrypts a packet", func() { It("encrypts a packet", func() {
initialStream.EXPECT().HasData() initialStream.EXPECT().HasData()
handshakeStream.EXPECT().HasData() handshakeStream.EXPECT().HasData()
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x1337), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x1337), protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x1337)) pnManager.EXPECT().PopPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x1337))
sealer := mocks.NewMockSealer(mockCtrl) sealer := mocks.NewMockSealer(mockCtrl)
sealer.EXPECT().Overhead().Return(4).AnyTimes() sealer.EXPECT().Overhead().Return(4).AnyTimes()
var hdrRaw []byte var hdrRaw []byte
@ -211,7 +211,7 @@ var _ = Describe("Packet packer", func() {
}) })
It("returns nil when no packet is queued", func() { It("returns nil when no packet is queued", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
// don't expect any calls to PopPacketNumber // don't expect any calls to PopPacketNumber
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer) sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT) ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT)
@ -223,8 +223,8 @@ var _ = Describe("Packet packer", func() {
}) })
It("packs single packets", func() { It("packs single packets", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer) sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT) ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT)
expectAppendControlFrames() expectAppendControlFrames()
@ -243,8 +243,8 @@ var _ = Describe("Packet packer", func() {
}) })
It("stores the encryption level a packet was sealed with", func() { It("stores the encryption level a packet was sealed with", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer) sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT) ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT)
expectAppendControlFrames() expectAppendControlFrames()
@ -258,8 +258,8 @@ var _ = Describe("Packet packer", func() {
}) })
It("packs a single ACK", func() { It("packs a single ACK", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42))
ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Largest: 42, Smallest: 1}}} ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Largest: 42, Smallest: 1}}}
ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT).Return(ack) ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT).Return(ack)
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer) sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
@ -272,8 +272,8 @@ var _ = Describe("Packet packer", func() {
}) })
It("packs a CONNECTION_CLOSE", func() { It("packs a CONNECTION_CLOSE", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42))
// expect no framer.PopStreamFrames // expect no framer.PopStreamFrames
ccf := wire.ConnectionCloseFrame{ ccf := wire.ConnectionCloseFrame{
ErrorCode: 0x1337, ErrorCode: 0x1337,
@ -287,8 +287,8 @@ var _ = Describe("Packet packer", func() {
}) })
It("packs control frames", func() { It("packs control frames", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer) sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT) ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT)
frames := []wire.Frame{&wire.ResetStreamFrame{}, &wire.MaxDataFrame{}} frames := []wire.Frame{&wire.ResetStreamFrame{}, &wire.MaxDataFrame{}}
@ -302,7 +302,7 @@ var _ = Describe("Packet packer", func() {
}) })
It("accounts for the space consumed by control frames", func() { It("accounts for the space consumed by control frames", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer) sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT) ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT)
var maxSize protocol.ByteCount var maxSize protocol.ByteCount
@ -329,8 +329,8 @@ var _ = Describe("Packet packer", func() {
}) })
It("packs ACK packets", func() { It("packs ACK packets", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer) sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 10}}} ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 10}}}
ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT).Return(ack) ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT).Return(ack)
@ -343,8 +343,8 @@ var _ = Describe("Packet packer", func() {
Context("making ACK packets retransmittable", func() { Context("making ACK packets retransmittable", func() {
sendMaxNumNonRetransmittableAcks := func() { sendMaxNumNonRetransmittableAcks := func() {
for i := 0; i < protocol.MaxNonRetransmittableAcks; i++ { for i := 0; i < protocol.MaxNonRetransmittableAcks; i++ {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer) sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT).Return(&wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}}) ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT).Return(&wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}})
expectAppendControlFrames() expectAppendControlFrames()
@ -358,8 +358,8 @@ var _ = Describe("Packet packer", func() {
It("adds a PING frame when it's supposed to send a retransmittable packet", func() { It("adds a PING frame when it's supposed to send a retransmittable packet", func() {
sendMaxNumNonRetransmittableAcks() sendMaxNumNonRetransmittableAcks()
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer) sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT).Return(&wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}}) ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT).Return(&wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}})
expectAppendControlFrames() expectAppendControlFrames()
@ -369,8 +369,8 @@ var _ = Describe("Packet packer", func() {
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.frames).To(ContainElement(&wire.PingFrame{})) Expect(p.frames).To(ContainElement(&wire.PingFrame{}))
// make sure the next packet doesn't contain another PING // make sure the next packet doesn't contain another PING
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer) sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT).Return(&wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}}) ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT).Return(&wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}})
expectAppendControlFrames() expectAppendControlFrames()
@ -384,7 +384,7 @@ var _ = Describe("Packet packer", func() {
It("waits until there's something to send before adding a PING frame", func() { It("waits until there's something to send before adding a PING frame", func() {
sendMaxNumNonRetransmittableAcks() sendMaxNumNonRetransmittableAcks()
// nothing to send // nothing to send
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer) sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
expectAppendControlFrames() expectAppendControlFrames()
expectAppendStreamFrames() expectAppendStreamFrames()
@ -395,8 +395,8 @@ var _ = Describe("Packet packer", func() {
// now add some frame to send // now add some frame to send
expectAppendControlFrames() expectAppendControlFrames()
expectAppendStreamFrames() expectAppendStreamFrames()
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer) sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT).Return(&wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}}) ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT).Return(&wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}})
p, err = packer.PackPacket() p, err = packer.PackPacket()
@ -407,8 +407,8 @@ var _ = Describe("Packet packer", func() {
It("doesn't send a PING if it already sent another retransmittable frame", func() { It("doesn't send a PING if it already sent another retransmittable frame", func() {
sendMaxNumNonRetransmittableAcks() sendMaxNumNonRetransmittableAcks()
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer) sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT) ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT)
expectAppendStreamFrames() expectAppendStreamFrames()
@ -422,8 +422,8 @@ var _ = Describe("Packet packer", func() {
Context("STREAM frame handling", func() { Context("STREAM frame handling", func() {
It("does not split a STREAM frame with maximum size", func() { It("does not split a STREAM frame with maximum size", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42))
ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT) ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT)
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer) sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
expectAppendControlFrames() expectAppendControlFrames()
@ -460,8 +460,8 @@ var _ = Describe("Packet packer", func() {
Data: []byte("frame 3"), Data: []byte("frame 3"),
DataLenPresent: true, DataLenPresent: true,
} }
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer) sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT) ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT)
expectAppendControlFrames() expectAppendControlFrames()
@ -481,8 +481,8 @@ var _ = Describe("Packet packer", func() {
Context("retransmissions", func() { Context("retransmissions", func() {
It("retransmits a small packet", func() { It("retransmits a small packet", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.Encryption1RTT).Return(sealer, nil) sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.Encryption1RTT).Return(sealer, nil)
frames := []wire.Frame{ frames := []wire.Frame{
&wire.MaxDataFrame{ByteOffset: 0x1234}, &wire.MaxDataFrame{ByteOffset: 0x1234},
@ -500,8 +500,8 @@ var _ = Describe("Packet packer", func() {
}) })
It("packs two packets for retransmission if the original packet contained many control frames", func() { It("packs two packets for retransmission if the original packet contained many control frames", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2).Times(2) pnManager.EXPECT().PeekPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2).Times(2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)).Times(2) pnManager.EXPECT().PopPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42)).Times(2)
sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.Encryption1RTT).Return(sealer, nil) sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.Encryption1RTT).Return(sealer, nil)
var frames []wire.Frame var frames []wire.Frame
var totalLen protocol.ByteCount var totalLen protocol.ByteCount
@ -528,8 +528,8 @@ var _ = Describe("Packet packer", func() {
}) })
It("splits a STREAM frame that doesn't fit", func() { It("splits a STREAM frame that doesn't fit", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2).Times(2) pnManager.EXPECT().PeekPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2).Times(2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)).Times(2) pnManager.EXPECT().PopPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42)).Times(2)
sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.Encryption1RTT).Return(sealer, nil) sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.Encryption1RTT).Return(sealer, nil)
packets, err := packer.PackRetransmission(&ackhandler.Packet{ packets, err := packer.PackRetransmission(&ackhandler.Packet{
EncryptionLevel: protocol.Encryption1RTT, EncryptionLevel: protocol.Encryption1RTT,
@ -556,8 +556,8 @@ var _ = Describe("Packet packer", func() {
}) })
It("splits STREAM frames, if necessary", func() { It("splits STREAM frames, if necessary", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2).AnyTimes() pnManager.EXPECT().PeekPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2).AnyTimes()
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)).AnyTimes() pnManager.EXPECT().PopPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42)).AnyTimes()
for i := 0; i < 100; i++ { for i := 0; i < 100; i++ {
sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.Encryption1RTT).Return(sealer, nil).MaxTimes(2) sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.Encryption1RTT).Return(sealer, nil).MaxTimes(2)
sf1 := &wire.StreamFrame{ sf1 := &wire.StreamFrame{
@ -593,8 +593,8 @@ var _ = Describe("Packet packer", func() {
}) })
It("packs two packets for retransmission if the original packet contained many STREAM frames", func() { It("packs two packets for retransmission if the original packet contained many STREAM frames", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2).Times(2) pnManager.EXPECT().PeekPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2).Times(2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)).Times(2) pnManager.EXPECT().PopPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42)).Times(2)
sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.Encryption1RTT).Return(sealer, nil) sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.Encryption1RTT).Return(sealer, nil)
var frames []wire.Frame var frames []wire.Frame
var totalLen protocol.ByteCount var totalLen protocol.ByteCount
@ -622,8 +622,8 @@ var _ = Describe("Packet packer", func() {
}) })
It("correctly sets the DataLenPresent on STREAM frames", func() { It("correctly sets the DataLenPresent on STREAM frames", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.Encryption1RTT).Return(sealer, nil) sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.Encryption1RTT).Return(sealer, nil)
frames := []wire.Frame{ frames := []wire.Frame{
&wire.StreamFrame{StreamID: 4, Data: []byte("foobar"), DataLenPresent: true}, &wire.StreamFrame{StreamID: 4, Data: []byte("foobar"), DataLenPresent: true},
@ -650,7 +650,7 @@ var _ = Describe("Packet packer", func() {
Context("max packet size", func() { Context("max packet size", func() {
It("sets the maximum packet size", func() { It("sets the maximum packet size", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2).Times(2) pnManager.EXPECT().PeekPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2).Times(2)
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer).Times(2) sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer).Times(2)
ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT).Times(2) ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT).Times(2)
var initialMaxPacketSize protocol.ByteCount var initialMaxPacketSize protocol.ByteCount
@ -675,7 +675,7 @@ var _ = Describe("Packet packer", func() {
}) })
It("doesn't increase the max packet size", func() { It("doesn't increase the max packet size", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2).Times(2) pnManager.EXPECT().PeekPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2).Times(2)
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer).Times(2) sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer).Times(2)
ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT).Times(2) ackFramer.EXPECT().GetAckFrame(protocol.Encryption1RTT).Times(2)
var initialMaxPacketSize protocol.ByteCount var initialMaxPacketSize protocol.ByteCount
@ -703,8 +703,8 @@ var _ = Describe("Packet packer", func() {
Context("packing crypto packets", func() { Context("packing crypto packets", func() {
It("sets the length", func() { It("sets the length", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.EncryptionInitial).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.EncryptionInitial).Return(protocol.PacketNumber(0x42))
f := &wire.CryptoFrame{ f := &wire.CryptoFrame{
Offset: 0x1337, Offset: 0x1337,
Data: []byte("foobar"), Data: []byte("foobar"),
@ -720,8 +720,8 @@ var _ = Describe("Packet packer", func() {
It("packs a maximum size crypto packet", func() { It("packs a maximum size crypto packet", func() {
var f *wire.CryptoFrame var f *wire.CryptoFrame
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.EncryptionHandshake).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.EncryptionHandshake).Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.EncryptionHandshake).Return(sealer, nil) sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.EncryptionHandshake).Return(sealer, nil)
ackFramer.EXPECT().GetAckFrame(protocol.EncryptionInitial) ackFramer.EXPECT().GetAckFrame(protocol.EncryptionInitial)
ackFramer.EXPECT().GetAckFrame(protocol.EncryptionHandshake) ackFramer.EXPECT().GetAckFrame(protocol.EncryptionHandshake)
@ -747,8 +747,8 @@ var _ = Describe("Packet packer", func() {
ackFramer.EXPECT().GetAckFrame(protocol.EncryptionInitial).Return(ack) ackFramer.EXPECT().GetAckFrame(protocol.EncryptionInitial).Return(ack)
initialStream.EXPECT().HasData() initialStream.EXPECT().HasData()
sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.EncryptionInitial).Return(sealer, nil) sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.EncryptionInitial).Return(sealer, nil)
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.EncryptionInitial).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.EncryptionInitial).Return(protocol.PacketNumber(0x42))
p, err := packer.PackPacket() p, err := packer.PackPacket()
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.frames).To(Equal([]wire.Frame{ack})) Expect(p.frames).To(Equal([]wire.Frame{ack}))
@ -761,8 +761,8 @@ var _ = Describe("Packet packer", func() {
initialStream.EXPECT().HasData() initialStream.EXPECT().HasData()
handshakeStream.EXPECT().HasData() handshakeStream.EXPECT().HasData()
sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.EncryptionHandshake).Return(sealer, nil) sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.EncryptionHandshake).Return(sealer, nil)
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.EncryptionHandshake).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.EncryptionHandshake).Return(protocol.PacketNumber(0x42))
p, err := packer.PackPacket() p, err := packer.PackPacket()
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(p.frames).To(Equal([]wire.Frame{ack})) Expect(p.frames).To(Equal([]wire.Frame{ack}))
@ -772,8 +772,8 @@ var _ = Describe("Packet packer", func() {
token := []byte("initial token") token := []byte("initial token")
packer.SetToken(token) packer.SetToken(token)
f := &wire.CryptoFrame{Data: []byte("foobar")} f := &wire.CryptoFrame{Data: []byte("foobar")}
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.EncryptionInitial).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.EncryptionInitial).Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.EncryptionInitial).Return(sealer, nil) sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.EncryptionInitial).Return(sealer, nil)
ackFramer.EXPECT().GetAckFrame(protocol.EncryptionInitial) ackFramer.EXPECT().GetAckFrame(protocol.EncryptionInitial)
initialStream.EXPECT().HasData().Return(true) initialStream.EXPECT().HasData().Return(true)
@ -794,8 +794,8 @@ var _ = Describe("Packet packer", func() {
FinBit: true, FinBit: true,
} }
Expect(f.Length(packer.version)).To(BeEquivalentTo(2)) Expect(f.Length(packer.version)).To(BeEquivalentTo(2))
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen1) pnManager.EXPECT().PeekPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen1)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.Encryption1RTT).Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer) sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
ackFramer.EXPECT().GetAckFrame(protocol.EncryptionInitial) ackFramer.EXPECT().GetAckFrame(protocol.EncryptionInitial)
ackFramer.EXPECT().GetAckFrame(protocol.EncryptionHandshake) ackFramer.EXPECT().GetAckFrame(protocol.EncryptionHandshake)
@ -828,8 +828,8 @@ var _ = Describe("Packet packer", func() {
}) })
It("sets the correct length for an Initial packet", func() { It("sets the correct length for an Initial packet", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.EncryptionInitial).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.EncryptionInitial).Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.EncryptionInitial).Return(sealer, nil) sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.EncryptionInitial).Return(sealer, nil)
ackFramer.EXPECT().GetAckFrame(protocol.EncryptionInitial) ackFramer.EXPECT().GetAckFrame(protocol.EncryptionInitial)
initialStream.EXPECT().HasData().Return(true) initialStream.EXPECT().HasData().Return(true)
@ -845,8 +845,8 @@ var _ = Describe("Packet packer", func() {
It("adds an ACK frame", func() { It("adds an ACK frame", func() {
f := &wire.CryptoFrame{Data: []byte("foobar")} f := &wire.CryptoFrame{Data: []byte("foobar")}
ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 42, Largest: 1337}}} ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 42, Largest: 1337}}}
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.EncryptionInitial).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.EncryptionInitial).Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.EncryptionInitial).Return(sealer, nil) sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.EncryptionInitial).Return(sealer, nil)
ackFramer.EXPECT().GetAckFrame(protocol.EncryptionInitial).Return(ack) ackFramer.EXPECT().GetAckFrame(protocol.EncryptionInitial).Return(ack)
initialStream.EXPECT().HasData().Return(true) initialStream.EXPECT().HasData().Return(true)
@ -865,8 +865,8 @@ var _ = Describe("Packet packer", func() {
It("packs a retransmission with the right encryption level", func() { It("packs a retransmission with the right encryption level", func() {
f := &wire.CryptoFrame{Data: []byte("foo")} f := &wire.CryptoFrame{Data: []byte("foo")}
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.EncryptionInitial).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.EncryptionInitial).Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.EncryptionInitial).Return(sealer, nil) sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.EncryptionInitial).Return(sealer, nil)
packet := &ackhandler.Packet{ packet := &ackhandler.Packet{
PacketType: protocol.PacketTypeHandshake, PacketType: protocol.PacketTypeHandshake,
@ -884,8 +884,8 @@ var _ = Describe("Packet packer", func() {
It("packs a retransmission for an Initial packet", func() { It("packs a retransmission for an Initial packet", func() {
token := []byte("initial token") token := []byte("initial token")
packer.SetToken(token) packer.SetToken(token)
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2) pnManager.EXPECT().PeekPacketNumber(protocol.EncryptionInitial).Return(protocol.PacketNumber(0x42), protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)) pnManager.EXPECT().PopPacketNumber(protocol.EncryptionInitial).Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.EncryptionInitial).Return(sealer, nil) sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.EncryptionInitial).Return(sealer, nil)
packer.perspective = protocol.PerspectiveClient packer.perspective = protocol.PerspectiveClient
packet := &ackhandler.Packet{ packet := &ackhandler.Packet{

4
session.go
View file

@ -805,7 +805,7 @@ func (s *session) destroy(e error) {
// It returns the first packet number that should be used in the new session. // It returns the first packet number that should be used in the new session.
func (s *session) closeForRecreating() protocol.PacketNumber { func (s *session) closeForRecreating() protocol.PacketNumber {
s.destroy(errCloseForRecreating) s.destroy(errCloseForRecreating)
nextPN, _ := s.sentPacketHandler.PeekPacketNumber() nextPN, _ := s.sentPacketHandler.PeekPacketNumber(protocol.EncryptionInitial)
return nextPN return nextPN
} }
@ -1028,7 +1028,7 @@ func (s *session) maybeSendRetransmission() (bool, error) {
break break
} }
s.logger.Debugf("Dequeueing retransmission for packet 0x%x", retransmitPacket.PacketNumber) s.logger.Debugf("Dequeueing retransmission for packet 0x%x (%s)", retransmitPacket.PacketNumber, retransmitPacket.EncryptionLevel)
packets, err := s.packer.PackRetransmission(retransmitPacket) packets, err := s.packer.PackRetransmission(retransmitPacket)
if err != nil { if err != nil {
return false, err return false, err