diff --git a/ackhandlernew/packet_test.go b/ackhandlernew/packet_test.go index 7b59cc9d..9b08f87d 100644 --- a/ackhandlernew/packet_test.go +++ b/ackhandlernew/packet_test.go @@ -25,12 +25,12 @@ var _ = Describe("Packet", func() { Data: []byte{0xDE, 0xCA, 0xFB, 0xAD}, } ackFrame1 = &frames.AckFrameNew{ - LargestObserved: 13, - LowestAcked: 1, + LargestAcked: 13, + LowestAcked: 1, } ackFrame2 = &frames.AckFrameNew{ - LargestObserved: 333, - LowestAcked: 100, + LargestAcked: 333, + LowestAcked: 100, } rstStreamFrame = &frames.RstStreamFrame{ StreamID: 555, diff --git a/ackhandlernew/received_packet_handler.go b/ackhandlernew/received_packet_handler.go index 6f6ac4b7..9385f4b7 100644 --- a/ackhandlernew/received_packet_handler.go +++ b/ackhandlernew/received_packet_handler.go @@ -133,7 +133,7 @@ func (h *receivedPacketHandler) GetAckFrame(dequeue bool) (*frames.AckFrameNew, ackRanges := h.getAckRanges() h.currentAckFrame = &frames.AckFrameNew{ - LargestObserved: h.largestObserved, + LargestAcked: h.largestObserved, LowestAcked: ackRanges[len(ackRanges)-1].FirstPacketNumber, PacketReceivedTime: packetReceivedTime, } diff --git a/ackhandlernew/received_packet_handler_test.go b/ackhandlernew/received_packet_handler_test.go index 7c524397..3c80be7d 100644 --- a/ackhandlernew/received_packet_handler_test.go +++ b/ackhandlernew/received_packet_handler_test.go @@ -188,7 +188,7 @@ var _ = Describe("receivedPacketHandler", func() { Expect(err).ToNot(HaveOccurred()) ack, err := handler.GetAckFrame(true) Expect(err).ToNot(HaveOccurred()) - Expect(ack.LargestObserved).To(Equal(protocol.PacketNumber(2))) + Expect(ack.LargestAcked).To(Equal(protocol.PacketNumber(2))) Expect(ack.LowestAcked).To(Equal(protocol.PacketNumber(1))) Expect(ack.AckRanges).To(BeEmpty()) }) @@ -200,7 +200,7 @@ var _ = Describe("receivedPacketHandler", func() { Expect(err).ToNot(HaveOccurred()) ack, err := handler.GetAckFrame(true) Expect(err).ToNot(HaveOccurred()) - Expect(ack.LargestObserved).To(Equal(protocol.PacketNumber(4))) + Expect(ack.LargestAcked).To(Equal(protocol.PacketNumber(4))) Expect(ack.LowestAcked).To(Equal(protocol.PacketNumber(1))) Expect(ack.AckRanges).To(HaveLen(2)) Expect(ack.AckRanges[0]).To(Equal(frames.AckRange{FirstPacketNumber: 4, LastPacketNumber: 4})) @@ -251,12 +251,12 @@ var _ = Describe("receivedPacketHandler", func() { Expect(err).ToNot(HaveOccurred()) ack, _ := handler.GetAckFrame(true) Expect(ack).ToNot(BeNil()) - Expect(ack.LargestObserved).To(Equal(protocol.PacketNumber(1))) + Expect(ack.LargestAcked).To(Equal(protocol.PacketNumber(1))) err = handler.ReceivedPacket(protocol.PacketNumber(3)) Expect(err).ToNot(HaveOccurred()) ack, _ = handler.GetAckFrame(true) Expect(ack).ToNot(BeNil()) - Expect(ack.LargestObserved).To(Equal(protocol.PacketNumber(3))) + Expect(ack.LargestAcked).To(Equal(protocol.PacketNumber(3))) }) It("generates a new ACK when an out-of-order packet arrives", func() { diff --git a/ackhandlernew/sent_packet_handler.go b/ackhandlernew/sent_packet_handler.go index 537ac5b6..35b5405c 100644 --- a/ackhandlernew/sent_packet_handler.go +++ b/ackhandlernew/sent_packet_handler.go @@ -148,15 +148,15 @@ func (h *sentPacketHandler) SentPacket(packet *Packet) error { // TODO: Simplify return types func (h *sentPacketHandler) ReceivedAck(ackFrame *frames.AckFrameNew) error { - if ackFrame.LargestObserved > h.lastSentPacketNumber { + if ackFrame.LargestAcked > h.lastSentPacketNumber { return errAckForUnsentPacket } - if ackFrame.LargestObserved <= h.LargestObserved { // duplicate or out-of-order AckFrame + if ackFrame.LargestAcked <= h.LargestObserved { // duplicate or out-of-order AckFrame return ErrDuplicateOrOutOfOrderAck } - h.LargestObserved = ackFrame.LargestObserved + h.LargestObserved = ackFrame.LargestAcked // Update the RTT timeDelta := time.Now().Sub(h.packetHistory[h.LargestObserved].sendTime) @@ -170,7 +170,7 @@ func (h *sentPacketHandler) ReceivedAck(ackFrame *frames.AckFrameNew) error { var lostPackets congestion.PacketVector ackRangeIndex := 0 - for i := ackFrame.LowestAcked; i <= ackFrame.LargestObserved; i++ { + for i := ackFrame.LowestAcked; i <= ackFrame.LargestAcked; i++ { if ackFrame.HasMissingRanges() { ackRange := ackFrame.AckRanges[len(ackFrame.AckRanges)-1-ackRangeIndex] diff --git a/ackhandlernew/sent_packet_handler_test.go b/ackhandlernew/sent_packet_handler_test.go index 5f193bef..38eec437 100644 --- a/ackhandlernew/sent_packet_handler_test.go +++ b/ackhandlernew/sent_packet_handler_test.go @@ -178,9 +178,9 @@ var _ = Describe("SentPacketHandler", func() { Context("ACK validation", func() { It("rejects duplicate ACKs", func() { - largestObserved := 3 + largestAcked := 3 ack := frames.AckFrameNew{ - LargestObserved: protocol.PacketNumber(largestObserved), + LargestAcked: protocol.PacketNumber(largestAcked), } err := handler.ReceivedAck(&ack) Expect(err).ToNot(HaveOccurred()) @@ -191,23 +191,23 @@ var _ = Describe("SentPacketHandler", func() { }) It("rejects out of order ACKs", func() { - largestObserved := 3 + largestAcked := 3 ack := frames.AckFrameNew{ - LargestObserved: protocol.PacketNumber(largestObserved), + LargestAcked: protocol.PacketNumber(largestAcked), } err := handler.ReceivedAck(&ack) Expect(err).ToNot(HaveOccurred()) Expect(handler.BytesInFlight()).To(Equal(protocol.ByteCount(len(packets) - 3))) - ack.LargestObserved-- + ack.LargestAcked-- err = handler.ReceivedAck(&ack) Expect(err).To(MatchError(ErrDuplicateOrOutOfOrderAck)) - Expect(handler.LargestObserved).To(Equal(protocol.PacketNumber(largestObserved))) + Expect(handler.LargestObserved).To(Equal(protocol.PacketNumber(largestAcked))) Expect(handler.BytesInFlight()).To(Equal(protocol.ByteCount(len(packets) - 3))) }) - It("rejects ACKs with a too high LargestObserved packet number", func() { + It("rejects ACKs with a too high LargestAcked packet number", func() { ack := frames.AckFrameNew{ - LargestObserved: packets[len(packets)-1].PacketNumber + 1337, + LargestAcked: packets[len(packets)-1].PacketNumber + 1337, } err := handler.ReceivedAck(&ack) Expect(err).To(MatchError(errAckForUnsentPacket)) @@ -220,8 +220,8 @@ var _ = Describe("SentPacketHandler", func() { It("adjusts the highestInOrderAckedPacketNumber", func() { ack := frames.AckFrameNew{ - LargestObserved: 5, - LowestAcked: 1, + LargestAcked: 5, + LowestAcked: 1, } err := handler.ReceivedAck(&ack) Expect(err).ToNot(HaveOccurred()) @@ -237,8 +237,8 @@ var _ = Describe("SentPacketHandler", func() { It("ACKs all packets for an ACK frame with no missing packets", func() { ack := frames.AckFrameNew{ - LargestObserved: 8, - LowestAcked: 2, + LargestAcked: 8, + LowestAcked: 2, } err := handler.ReceivedAck(&ack) Expect(err).ToNot(HaveOccurred()) @@ -256,8 +256,8 @@ var _ = Describe("SentPacketHandler", func() { It("handles an ACK frame with one missing packet range", func() { ack := frames.AckFrameNew{ - LargestObserved: 9, - LowestAcked: 2, + LargestAcked: 9, + LowestAcked: 2, AckRanges: []frames.AckRange{ // packets 4 and 5 were lost {FirstPacketNumber: 6, LastPacketNumber: 9}, {FirstPacketNumber: 2, LastPacketNumber: 3}, @@ -284,8 +284,8 @@ var _ = Describe("SentPacketHandler", func() { It("handles an ACK with multiple missing packet ranges", func() { ack := frames.AckFrameNew{ - LargestObserved: 9, - LowestAcked: 1, + LargestAcked: 9, + LowestAcked: 1, AckRanges: []frames.AckRange{ // packets 2, 4 and 5, and 8 were lost {FirstPacketNumber: 9, LastPacketNumber: 9}, {FirstPacketNumber: 6, LastPacketNumber: 7}, @@ -321,13 +321,13 @@ var _ = Describe("SentPacketHandler", func() { handler.packetHistory[2].sendTime = now.Add(-5 * time.Minute) handler.packetHistory[6].sendTime = now.Add(-1 * time.Minute) // Now, check that the proper times are used when calculating the deltas - err := handler.ReceivedAck(&frames.AckFrameNew{LargestObserved: 1}) + err := handler.ReceivedAck(&frames.AckFrameNew{LargestAcked: 1}) Expect(err).NotTo(HaveOccurred()) Expect(handler.rttStats.LatestRTT()).To(BeNumerically("~", 10*time.Minute, 1*time.Second)) - err = handler.ReceivedAck(&frames.AckFrameNew{LargestObserved: 2}) + err = handler.ReceivedAck(&frames.AckFrameNew{LargestAcked: 2}) Expect(err).NotTo(HaveOccurred()) Expect(handler.rttStats.LatestRTT()).To(BeNumerically("~", 5*time.Minute, 1*time.Second)) - err = handler.ReceivedAck(&frames.AckFrameNew{LargestObserved: 6}) + err = handler.ReceivedAck(&frames.AckFrameNew{LargestAcked: 6}) Expect(err).NotTo(HaveOccurred()) Expect(handler.rttStats.LatestRTT()).To(BeNumerically("~", 1*time.Minute, 1*time.Second)) }) @@ -335,7 +335,7 @@ var _ = Describe("SentPacketHandler", func() { It("uses the DelayTime in the ack frame", func() { now := time.Now() handler.packetHistory[1].sendTime = now.Add(-10 * time.Minute) - err := handler.ReceivedAck(&frames.AckFrameNew{LargestObserved: 1, DelayTime: 5 * time.Minute}) + err := handler.ReceivedAck(&frames.AckFrameNew{LargestAcked: 1, DelayTime: 5 * time.Minute}) Expect(err).NotTo(HaveOccurred()) Expect(handler.rttStats.LatestRTT()).To(BeNumerically("~", 5*time.Minute, 1*time.Second)) }) @@ -424,8 +424,8 @@ var _ = Describe("SentPacketHandler", func() { It("does not change the highestInOrderAckedPacketNumber after queueing a retransmission", func() { ack := frames.AckFrameNew{ - LargestObserved: 4, - LowestAcked: 1, + LargestAcked: 4, + LowestAcked: 1, AckRanges: []frames.AckRange{ {FirstPacketNumber: 4, LastPacketNumber: 4}, {FirstPacketNumber: 1, LastPacketNumber: 2}, @@ -467,8 +467,8 @@ var _ = Describe("SentPacketHandler", func() { // ACK 1 and 3, NACK 2 ack := frames.AckFrameNew{ - LargestObserved: 3, - LowestAcked: 1, + LargestAcked: 3, + LowestAcked: 1, AckRanges: []frames.AckRange{ {FirstPacketNumber: 3, LastPacketNumber: 3}, {FirstPacketNumber: 1, LastPacketNumber: 1}, @@ -493,8 +493,8 @@ var _ = Describe("SentPacketHandler", func() { // ACK ack = frames.AckFrameNew{ - LargestObserved: 4, - LowestAcked: 1, + LargestAcked: 4, + LowestAcked: 1, } err = handler.ReceivedAck(&ack) Expect(err).NotTo(HaveOccurred()) @@ -532,8 +532,8 @@ var _ = Describe("SentPacketHandler", func() { handler.SentPacket(&Packet{PacketNumber: 2, Frames: []frames.Frame{}, Length: 2}) handler.SentPacket(&Packet{PacketNumber: 3, Frames: []frames.Frame{}, Length: 3}) err := handler.ReceivedAck(&frames.AckFrameNew{ - LargestObserved: 3, - LowestAcked: 1, + LargestAcked: 3, + LowestAcked: 1, AckRanges: []frames.AckRange{ {FirstPacketNumber: 3, LastPacketNumber: 3}, {FirstPacketNumber: 1, LastPacketNumber: 1}, @@ -553,8 +553,8 @@ var _ = Describe("SentPacketHandler", func() { packetNumber = protocol.PacketNumber(4 + i) handler.SentPacket(&Packet{PacketNumber: packetNumber, Frames: []frames.Frame{}, Length: protocol.ByteCount(packetNumber)}) err = handler.ReceivedAck(&frames.AckFrameNew{ - LargestObserved: packetNumber, - LowestAcked: 1, + LargestAcked: packetNumber, + LowestAcked: 1, AckRanges: []frames.AckRange{ {FirstPacketNumber: 3, LastPacketNumber: packetNumber}, {FirstPacketNumber: 1, LastPacketNumber: 1}, diff --git a/frames/ack_frame_new.go b/frames/ack_frame_new.go index 1ce4e0fd..fdf6ae02 100644 --- a/frames/ack_frame_new.go +++ b/frames/ack_frame_new.go @@ -13,17 +13,16 @@ import ( var ErrInvalidAckRanges = errors.New("AckFrame: ACK frame contains invalid ACK ranges") var ( - errInconsistentAckLargestObserved = errors.New("internal inconsistency: LargestObserved does not match ACK ranges") - errInconsistentAckLowestAcked = errors.New("internal inconsistency: LowestAcked does not match ACK ranges") + errInconsistentAckLargestAcked = errors.New("internal inconsistency: LargestAcked does not match ACK ranges") + errInconsistentAckLowestAcked = errors.New("internal inconsistency: LowestAcked does not match ACK ranges") ) // An AckFrameNew is a ACK frame in QUIC c34 type AckFrameNew struct { - // TODO: rename to LargestAcked - LargestObserved protocol.PacketNumber - NackRanges []NackRange // has to be ordered. The NACK range with the highest FirstPacketNumber goes first, the NACK range with the lowest FirstPacketNumber goes last - LowestAcked protocol.PacketNumber - AckRanges []AckRange + LargestAcked protocol.PacketNumber + NackRanges []NackRange // has to be ordered. The NACK range with the highest FirstPacketNumber goes first, the NACK range with the lowest FirstPacketNumber goes last + LowestAcked protocol.PacketNumber + AckRanges []AckRange DelayTime time.Duration PacketReceivedTime time.Time // only for received packets. Will not be modified for received ACKs frames @@ -43,9 +42,9 @@ func ParseAckFrameNew(r *bytes.Reader, version protocol.VersionNumber) (*AckFram hasMissingRanges = true } - largestObservedLen := 2 * ((typeByte & 0x0C) >> 2) - if largestObservedLen == 0 { - largestObservedLen = 1 + largestAckedLen := 2 * ((typeByte & 0x0C) >> 2) + if largestAckedLen == 0 { + largestAckedLen = 1 } missingSequenceNumberDeltaLen := 2 * (typeByte & 0x03) @@ -53,11 +52,11 @@ func ParseAckFrameNew(r *bytes.Reader, version protocol.VersionNumber) (*AckFram missingSequenceNumberDeltaLen = 1 } - largestObserved, err := utils.ReadUintN(r, largestObservedLen) + largestAcked, err := utils.ReadUintN(r, largestAckedLen) if err != nil { return nil, err } - frame.LargestObserved = protocol.PacketNumber(largestObserved) + frame.LargestAcked = protocol.PacketNumber(largestAcked) delay, err := utils.ReadUfloat16(r) if err != nil { @@ -78,14 +77,14 @@ func ParseAckFrameNew(r *bytes.Reader, version protocol.VersionNumber) (*AckFram return nil, err } - if ackBlockLength > largestObserved { + if ackBlockLength > largestAcked { return nil, ErrInvalidAckRanges } if hasMissingRanges { ackRange := AckRange{ - FirstPacketNumber: protocol.PacketNumber(largestObserved-ackBlockLength) + 1, - LastPacketNumber: frame.LargestObserved, + FirstPacketNumber: protocol.PacketNumber(largestAcked-ackBlockLength) + 1, + LastPacketNumber: frame.LargestAcked, } frame.AckRanges = append(frame.AckRanges, ackRange) @@ -119,7 +118,7 @@ func ParseAckFrameNew(r *bytes.Reader, version protocol.VersionNumber) (*AckFram } frame.LowestAcked = frame.AckRanges[len(frame.AckRanges)-1].FirstPacketNumber } else { - frame.LowestAcked = protocol.PacketNumber(largestObserved + 1 - ackBlockLength) + frame.LowestAcked = protocol.PacketNumber(largestAcked + 1 - ackBlockLength) } if !frame.validateAckRanges() { @@ -134,7 +133,7 @@ func ParseAckFrameNew(r *bytes.Reader, version protocol.VersionNumber) (*AckFram numTimestamp := uint8(numTimestampByte) if numTimestamp > 0 { - // Delta Largest observed + // Delta Largest acked _, err = r.ReadByte() if err != nil { return nil, err @@ -146,7 +145,7 @@ func ParseAckFrameNew(r *bytes.Reader, version protocol.VersionNumber) (*AckFram } for i := 0; i < int(numTimestamp)-1; i++ { - // Delta Largest observed + // Delta Largest acked _, err = r.ReadByte() if err != nil { return nil, err @@ -165,12 +164,12 @@ func ParseAckFrameNew(r *bytes.Reader, version protocol.VersionNumber) (*AckFram // Write writes an ACK frame. func (f *AckFrameNew) Write(b *bytes.Buffer, version protocol.VersionNumber) error { - largestObservedLen := protocol.GetPacketNumberLength(f.LargestObserved) + largestAckedLen := protocol.GetPacketNumberLength(f.LargestAcked) typeByte := uint8(0x40) - if largestObservedLen != protocol.PacketNumberLen1 { - typeByte ^= (uint8(largestObservedLen / 2)) << 2 + if largestAckedLen != protocol.PacketNumberLen1 { + typeByte ^= (uint8(largestAckedLen / 2)) << 2 } // TODO: send shorter values, if possible @@ -185,15 +184,15 @@ func (f *AckFrameNew) Write(b *bytes.Buffer, version protocol.VersionNumber) err b.WriteByte(typeByte) - switch largestObservedLen { + switch largestAckedLen { case protocol.PacketNumberLen1: - b.WriteByte(uint8(f.LargestObserved)) + b.WriteByte(uint8(f.LargestAcked)) case protocol.PacketNumberLen2: - utils.WriteUint16(b, uint16(f.LargestObserved)) + utils.WriteUint16(b, uint16(f.LargestAcked)) case protocol.PacketNumberLen4: - utils.WriteUint32(b, uint32(f.LargestObserved)) + utils.WriteUint32(b, uint32(f.LargestAcked)) case protocol.PacketNumberLen6: - utils.WriteUint48(b, uint64(f.LargestObserved)) + utils.WriteUint48(b, uint64(f.LargestAcked)) } f.DelayTime = time.Now().Sub(f.PacketReceivedTime) @@ -210,15 +209,15 @@ func (f *AckFrameNew) Write(b *bytes.Buffer, version protocol.VersionNumber) err } if !f.HasMissingRanges() { - utils.WriteUint48(b, uint64(f.LargestObserved-f.LowestAcked+1)) + utils.WriteUint48(b, uint64(f.LargestAcked-f.LowestAcked+1)) } else { - if f.LargestObserved != f.AckRanges[0].LastPacketNumber { - return errInconsistentAckLargestObserved + if f.LargestAcked != f.AckRanges[0].LastPacketNumber { + return errInconsistentAckLargestAcked } if f.LowestAcked != f.AckRanges[len(f.AckRanges)-1].FirstPacketNumber { return errInconsistentAckLowestAcked } - length := f.LargestObserved - f.AckRanges[0].FirstPacketNumber + 1 + length := f.LargestAcked - f.AckRanges[0].FirstPacketNumber + 1 utils.WriteUint48(b, uint64(length)) numRangesWritten++ } @@ -273,7 +272,7 @@ func (f *AckFrameNew) Write(b *bytes.Buffer, version protocol.VersionNumber) err func (f *AckFrameNew) MinLength(version protocol.VersionNumber) (protocol.ByteCount, error) { var length protocol.ByteCount length = 1 + 2 + 1 // 1 TypeByte, 2 ACK delay time, 1 Num Timestamp - length += protocol.ByteCount(protocol.GetPacketNumberLength(f.LargestObserved)) + length += protocol.ByteCount(protocol.GetPacketNumberLength(f.LargestAcked)) missingSequenceNumberDeltaLen := protocol.ByteCount(protocol.PacketNumberLen6) @@ -306,7 +305,7 @@ func (f *AckFrameNew) validateAckRanges() bool { return false } - if f.AckRanges[0].LastPacketNumber != f.LargestObserved { + if f.AckRanges[0].LastPacketNumber != f.LargestAcked { return false } diff --git a/frames/ack_frame_new_test.go b/frames/ack_frame_new_test.go index ef008699..b4dbfa61 100644 --- a/frames/ack_frame_new_test.go +++ b/frames/ack_frame_new_test.go @@ -15,7 +15,7 @@ var _ = Describe("AckFrame", func() { b := bytes.NewReader([]byte{0x40, 0x1c, 0x8e, 0x0, 0x1c, 0x1, 0x1, 0x6b, 0x26, 0x3, 0x0}) frame, err := ParseAckFrameNew(b, 0) Expect(err).ToNot(HaveOccurred()) - Expect(frame.LargestObserved).To(Equal(protocol.PacketNumber(0x1c))) + Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(0x1c))) Expect(frame.LowestAcked).To(Equal(protocol.PacketNumber(1))) Expect(frame.DelayTime).To(Equal(142 * time.Microsecond)) Expect(frame.HasMissingRanges()).To(BeFalse()) @@ -26,14 +26,14 @@ var _ = Describe("AckFrame", func() { b := bytes.NewReader([]byte{0x40, 0x3, 0x50, 0x15, 0x3, 0x0}) frame, err := ParseAckFrameNew(b, 0) Expect(err).ToNot(HaveOccurred()) - Expect(frame.LargestObserved).To(Equal(protocol.PacketNumber(3))) + Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(3))) }) It("parses a frame with a 48 bit packet number", func() { b := bytes.NewReader([]byte{0x4c, 0x37, 0x13, 0xad, 0xfb, 0xca, 0xde, 0x0, 0x0, 0x0, 0x1, 0, 0, 0, 0, 0}) frame, err := ParseAckFrameNew(b, protocol.Version34) Expect(err).ToNot(HaveOccurred()) - Expect(frame.LargestObserved).To(Equal(protocol.PacketNumber(0xdecafbad1337))) + Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(0xdecafbad1337))) Expect(frame.HasMissingRanges()).To(BeFalse()) Expect(b.Len()).To(BeZero()) }) @@ -42,7 +42,7 @@ var _ = Describe("AckFrame", func() { b := bytes.NewReader([]byte{0x40, 0x9, 0x92, 0x7, 0x8, 0x3, 0x2, 0x69, 0xa3, 0x0, 0x0, 0x1, 0xc9, 0x2, 0x0, 0x46, 0x10}) frame, err := ParseAckFrameNew(b, 0) Expect(err).ToNot(HaveOccurred()) - Expect(frame.LargestObserved).To(Equal(protocol.PacketNumber(9))) + Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(9))) Expect(frame.LowestAcked).To(Equal(protocol.PacketNumber(2))) Expect(b.Len()).To(BeZero()) }) @@ -55,7 +55,7 @@ var _ = Describe("AckFrame", func() { }) It("errors when the ACK range is too large", func() { - // LargestObserved: 0x1c + // LargestAcked: 0x1c // Length: 0x1d => LowestAcked would be -1 b := bytes.NewReader([]byte{0x40, 0x1c, 0x8e, 0x0, 0x1d, 0x1, 0x1, 0x6b, 0x26, 0x3, 0x0}) _, err := ParseAckFrameNew(b, 0) @@ -67,7 +67,7 @@ var _ = Describe("AckFrame", func() { b := bytes.NewReader([]byte{0x60, 0x18, 0x94, 0x1, 0x1, 0x3, 0x2, 0x10, 0x2, 0x1, 0x5c, 0xd5, 0x0, 0x0, 0x0, 0x95, 0x0}) frame, err := ParseAckFrameNew(b, 0) Expect(err).ToNot(HaveOccurred()) - Expect(frame.LargestObserved).To(Equal(protocol.PacketNumber(24))) + Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(24))) Expect(frame.HasMissingRanges()).To(BeTrue()) Expect(frame.AckRanges).To(HaveLen(2)) Expect(frame.AckRanges[0]).To(Equal(AckRange{FirstPacketNumber: 22, LastPacketNumber: 24})) @@ -87,7 +87,7 @@ var _ = Describe("AckFrame", func() { b := bytes.NewReader([]byte{0x60, 0x27, 0xda, 0x0, 0x6, 0x9, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x1, 0x13, 0x2, 0x1, 0x71, 0x12, 0x3, 0x0, 0x0, 0x47, 0x2}) frame, err := ParseAckFrameNew(b, 0) Expect(err).ToNot(HaveOccurred()) - Expect(frame.LargestObserved).To(Equal(protocol.PacketNumber(0x27))) + Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(0x27))) Expect(frame.HasMissingRanges()).To(BeTrue()) Expect(frame.AckRanges).To(HaveLen(7)) Expect(frame.AckRanges[0]).To(Equal(AckRange{FirstPacketNumber: 31, LastPacketNumber: 0x27})) @@ -105,7 +105,7 @@ var _ = Describe("AckFrame", func() { b := bytes.NewReader([]byte{0x60, 0xc, 0x92, 0x0, 0x1, 0x1, 0x1, 0x9, 0x2, 0x2, 0x53, 0x43, 0x1, 0x0, 0x0, 0xa7, 0x0}) frame, err := ParseAckFrameNew(b, 0) Expect(err).ToNot(HaveOccurred()) - Expect(frame.LargestObserved).To(Equal(protocol.PacketNumber(12))) + Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(12))) Expect(frame.LowestAcked).To(Equal(protocol.PacketNumber(2))) Expect(frame.AckRanges).To(HaveLen(2)) Expect(frame.AckRanges[0]).To(Equal(AckRange{FirstPacketNumber: 12, LastPacketNumber: 12})) @@ -117,7 +117,7 @@ var _ = Describe("AckFrame", func() { b := bytes.NewReader([]byte{0x60, 0x52, 0xd1, 0x0, 0x3, 0x17, 0xa, 0x10, 0x4, 0x8, 0x2, 0x12, 0x2, 0x1, 0x6c, 0xc8, 0x2, 0x0, 0x0, 0x7e, 0x1}) frame, err := ParseAckFrameNew(b, 0) Expect(err).ToNot(HaveOccurred()) - Expect(frame.LargestObserved).To(Equal(protocol.PacketNumber(0x52))) + Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(0x52))) Expect(frame.HasMissingRanges()).To(BeTrue()) Expect(frame.AckRanges).To(HaveLen(4)) Expect(frame.AckRanges[0]).To(Equal(AckRange{FirstPacketNumber: 60, LastPacketNumber: 0x52})) @@ -133,7 +133,7 @@ var _ = Describe("AckFrame", func() { b := bytes.NewReader([]byte{0x64, 0x44, 0x1, 0xa7, 0x0, 0x2, 0x19, 0xff, 0x0, 0x19, 0x13, 0x2, 0x1, 0xb, 0x59, 0x2, 0x0, 0x0, 0xb6, 0x0}) frame, err := ParseAckFrameNew(b, 0) Expect(err).ToNot(HaveOccurred()) - Expect(frame.LargestObserved).To(Equal(protocol.PacketNumber(0x144))) + Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(0x144))) Expect(frame.HasMissingRanges()).To(BeTrue()) Expect(frame.AckRanges).To(HaveLen(2)) Expect(frame.AckRanges[0]).To(Equal(AckRange{FirstPacketNumber: 300, LastPacketNumber: 0x144})) @@ -146,7 +146,7 @@ var _ = Describe("AckFrame", func() { b := bytes.NewReader([]byte{0x64, 0x5b, 0x9, 0x66, 0x1, 0xa, 0x1f, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0xff, 0x0, 0x32, 0x13, 0x4, 0x3, 0xb4, 0xda, 0x1, 0x0, 0x2, 0xe0, 0x0, 0x1, 0x9a, 0x0, 0x0, 0x81, 0x0}) frame, err := ParseAckFrameNew(b, 0) Expect(err).ToNot(HaveOccurred()) - Expect(frame.LargestObserved).To(Equal(protocol.PacketNumber(0x95b))) + Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(0x95b))) Expect(frame.HasMissingRanges()).To(BeTrue()) Expect(frame.AckRanges).To(HaveLen(2)) Expect(frame.AckRanges[0]).To(Equal(AckRange{FirstPacketNumber: 2365, LastPacketNumber: 0x95b})) @@ -159,7 +159,7 @@ var _ = Describe("AckFrame", func() { b := bytes.NewReader([]byte{0x65, 0x66, 0x9, 0x23, 0x1, 0x7, 0x7, 0x0, 0xff, 0x0, 0x0, 0xf5, 0x8a, 0x2, 0xc8, 0xe6, 0x0, 0xff, 0x0, 0x0, 0xff, 0x0, 0x0, 0xff, 0x0, 0x0, 0x23, 0x13, 0x0, 0x2, 0x1, 0x13, 0xae, 0xb, 0x0, 0x0, 0x80, 0x5}) frame, err := ParseAckFrameNew(b, 0) Expect(err).ToNot(HaveOccurred()) - Expect(frame.LargestObserved).To(Equal(protocol.PacketNumber(0x966))) + Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(0x966))) Expect(frame.HasMissingRanges()).To(BeTrue()) Expect(frame.AckRanges).To(HaveLen(4)) Expect(frame.AckRanges[0]).To(Equal(AckRange{FirstPacketNumber: 2400, LastPacketNumber: 0x966})) @@ -174,7 +174,7 @@ var _ = Describe("AckFrame", func() { b := bytes.NewReader([]byte{0x64, 0x8f, 0x3, 0x65, 0x1, 0x5, 0x3d, 0x1, 0x32, 0xff, 0x0, 0xff, 0x0, 0xf0, 0x1c, 0x2, 0x13, 0x3, 0x2, 0x23, 0xaf, 0x2, 0x0, 0x1, 0x3, 0x1, 0x0, 0x8e, 0x0}) frame, err := ParseAckFrameNew(b, 0) Expect(err).ToNot(HaveOccurred()) - Expect(frame.LargestObserved).To(Equal(protocol.PacketNumber(0x38f))) + Expect(frame.LargestAcked).To(Equal(protocol.PacketNumber(0x38f))) Expect(frame.HasMissingRanges()).To(BeTrue()) Expect(frame.AckRanges).To(HaveLen(4)) Expect(frame.AckRanges[0]).To(Equal(AckRange{FirstPacketNumber: 851, LastPacketNumber: 0x38f})) @@ -198,30 +198,30 @@ var _ = Describe("AckFrame", func() { Context("self-consistency", func() { It("writes a simple ACK frame", func() { frameOrig := &AckFrameNew{ - LargestObserved: 1, - LowestAcked: 1, + LargestAcked: 1, + LowestAcked: 1, } err := frameOrig.Write(b, 0) Expect(err).ToNot(HaveOccurred()) r := bytes.NewReader(b.Bytes()) frame, err := ParseAckFrameNew(r, 0) Expect(err).ToNot(HaveOccurred()) - Expect(frame.LargestObserved).To(Equal(frameOrig.LargestObserved)) + Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.HasMissingRanges()).To(BeFalse()) Expect(r.Len()).To(BeZero()) }) It("writes the correct block length in a simple ACK frame", func() { frameOrig := &AckFrameNew{ - LargestObserved: 20, - LowestAcked: 10, + LargestAcked: 20, + LowestAcked: 10, } err := frameOrig.Write(b, 0) Expect(err).ToNot(HaveOccurred()) r := bytes.NewReader(b.Bytes()) frame, err := ParseAckFrameNew(r, 0) Expect(err).ToNot(HaveOccurred()) - Expect(frame.LargestObserved).To(Equal(frameOrig.LargestObserved)) + Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.LowestAcked).To(Equal(frameOrig.LowestAcked)) Expect(frame.HasMissingRanges()).To(BeFalse()) Expect(r.Len()).To(BeZero()) @@ -229,23 +229,23 @@ var _ = Describe("AckFrame", func() { It("writes a simple ACK frame with a high packet number", func() { frameOrig := &AckFrameNew{ - LargestObserved: 0xDEADBEEFCAFE, - LowestAcked: 0xDEADBEEFCAFE, + LargestAcked: 0xDEADBEEFCAFE, + LowestAcked: 0xDEADBEEFCAFE, } err := frameOrig.Write(b, 0) Expect(err).ToNot(HaveOccurred()) r := bytes.NewReader(b.Bytes()) frame, err := ParseAckFrameNew(r, 0) Expect(err).ToNot(HaveOccurred()) - Expect(frame.LargestObserved).To(Equal(frameOrig.LargestObserved)) + Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.HasMissingRanges()).To(BeFalse()) Expect(r.Len()).To(BeZero()) }) It("writes an ACK frame with one packet missing", func() { frameOrig := &AckFrameNew{ - LargestObserved: 40, - LowestAcked: 1, + LargestAcked: 40, + LowestAcked: 1, AckRanges: []AckRange{ AckRange{FirstPacketNumber: 25, LastPacketNumber: 40}, AckRange{FirstPacketNumber: 1, LastPacketNumber: 23}, @@ -256,7 +256,7 @@ var _ = Describe("AckFrame", func() { r := bytes.NewReader(b.Bytes()) frame, err := ParseAckFrameNew(r, 0) Expect(err).ToNot(HaveOccurred()) - Expect(frame.LargestObserved).To(Equal(frameOrig.LargestObserved)) + Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.LowestAcked).To(Equal(frameOrig.LowestAcked)) Expect(frame.AckRanges).To(Equal(frameOrig.AckRanges)) Expect(r.Len()).To(BeZero()) @@ -264,8 +264,8 @@ var _ = Describe("AckFrame", func() { It("writes an ACK frame with multiple missing packets", func() { frameOrig := &AckFrameNew{ - LargestObserved: 25, - LowestAcked: 1, + LargestAcked: 25, + LowestAcked: 1, AckRanges: []AckRange{ AckRange{FirstPacketNumber: 22, LastPacketNumber: 25}, AckRange{FirstPacketNumber: 15, LastPacketNumber: 18}, @@ -278,7 +278,7 @@ var _ = Describe("AckFrame", func() { r := bytes.NewReader(b.Bytes()) frame, err := ParseAckFrameNew(r, 0) Expect(err).ToNot(HaveOccurred()) - Expect(frame.LargestObserved).To(Equal(frameOrig.LargestObserved)) + Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.LowestAcked).To(Equal(frameOrig.LowestAcked)) Expect(frame.AckRanges).To(Equal(frameOrig.AckRanges)) Expect(r.Len()).To(BeZero()) @@ -286,21 +286,21 @@ var _ = Describe("AckFrame", func() { It("rejects a frame with incorrect LargestObserved value", func() { frame := &AckFrameNew{ - LargestObserved: 26, - LowestAcked: 1, + LargestAcked: 26, + LowestAcked: 1, AckRanges: []AckRange{ AckRange{FirstPacketNumber: 12, LastPacketNumber: 25}, AckRange{FirstPacketNumber: 1, LastPacketNumber: 10}, }, } err := frame.Write(b, 0) - Expect(err).To(MatchError(errInconsistentAckLargestObserved)) + Expect(err).To(MatchError(errInconsistentAckLargestAcked)) }) It("rejects a frame with incorrect LargestObserved value", func() { frame := &AckFrameNew{ - LargestObserved: 25, - LowestAcked: 2, + LargestAcked: 25, + LowestAcked: 2, AckRanges: []AckRange{ AckRange{FirstPacketNumber: 12, LastPacketNumber: 25}, AckRange{FirstPacketNumber: 1, LastPacketNumber: 10}, @@ -313,8 +313,8 @@ var _ = Describe("AckFrame", func() { Context("longer ACK blocks", func() { It("only writes one block for 254 lost packets", func() { frameOrig := &AckFrameNew{ - LargestObserved: 300, - LowestAcked: 1, + LargestAcked: 300, + LowestAcked: 1, AckRanges: []AckRange{ AckRange{FirstPacketNumber: 20 + 254, LastPacketNumber: 300}, AckRange{FirstPacketNumber: 1, LastPacketNumber: 19}, @@ -326,14 +326,14 @@ var _ = Describe("AckFrame", func() { r := bytes.NewReader(b.Bytes()) frame, err := ParseAckFrameNew(r, 0) Expect(err).ToNot(HaveOccurred()) - Expect(frame.LargestObserved).To(Equal(frameOrig.LargestObserved)) + Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.AckRanges).To(Equal(frameOrig.AckRanges)) }) It("only writes one block for 255 lost packets", func() { frameOrig := &AckFrameNew{ - LargestObserved: 300, - LowestAcked: 1, + LargestAcked: 300, + LowestAcked: 1, AckRanges: []AckRange{ AckRange{FirstPacketNumber: 20 + 255, LastPacketNumber: 300}, AckRange{FirstPacketNumber: 1, LastPacketNumber: 19}, @@ -345,14 +345,14 @@ var _ = Describe("AckFrame", func() { r := bytes.NewReader(b.Bytes()) frame, err := ParseAckFrameNew(r, 0) Expect(err).ToNot(HaveOccurred()) - Expect(frame.LargestObserved).To(Equal(frameOrig.LargestObserved)) + Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.AckRanges).To(Equal(frameOrig.AckRanges)) }) It("writes two blocks for 256 lost packets", func() { frameOrig := &AckFrameNew{ - LargestObserved: 300, - LowestAcked: 1, + LargestAcked: 300, + LowestAcked: 1, AckRanges: []AckRange{ AckRange{FirstPacketNumber: 20 + 256, LastPacketNumber: 300}, AckRange{FirstPacketNumber: 1, LastPacketNumber: 19}, @@ -366,14 +366,14 @@ var _ = Describe("AckFrame", func() { r := bytes.NewReader(b.Bytes()) frame, err := ParseAckFrameNew(r, 0) Expect(err).ToNot(HaveOccurred()) - Expect(frame.LargestObserved).To(Equal(frameOrig.LargestObserved)) + Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.AckRanges).To(Equal(frameOrig.AckRanges)) }) It("writes multiple blocks for a lot of lost packets", func() { frameOrig := &AckFrameNew{ - LargestObserved: 3000, - LowestAcked: 1, + LargestAcked: 3000, + LowestAcked: 1, AckRanges: []AckRange{ AckRange{FirstPacketNumber: 2900, LastPacketNumber: 3000}, AckRange{FirstPacketNumber: 1, LastPacketNumber: 19}, @@ -384,14 +384,14 @@ var _ = Describe("AckFrame", func() { r := bytes.NewReader(b.Bytes()) frame, err := ParseAckFrameNew(r, 0) Expect(err).ToNot(HaveOccurred()) - Expect(frame.LargestObserved).To(Equal(frameOrig.LargestObserved)) + Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.AckRanges).To(Equal(frameOrig.AckRanges)) }) It("writes multiple longer blocks for 256 lost packets", func() { frameOrig := &AckFrameNew{ - LargestObserved: 3600, - LowestAcked: 1, + LargestAcked: 3600, + LowestAcked: 1, AckRanges: []AckRange{ AckRange{FirstPacketNumber: 2900, LastPacketNumber: 3600}, AckRange{FirstPacketNumber: 1000, LastPacketNumber: 2500}, @@ -403,7 +403,7 @@ var _ = Describe("AckFrame", func() { r := bytes.NewReader(b.Bytes()) frame, err := ParseAckFrameNew(r, 0) Expect(err).ToNot(HaveOccurred()) - Expect(frame.LargestObserved).To(Equal(frameOrig.LargestObserved)) + Expect(frame.LargestAcked).To(Equal(frameOrig.LargestAcked)) Expect(frame.AckRanges).To(Equal(frameOrig.AckRanges)) }) }) @@ -412,7 +412,7 @@ var _ = Describe("AckFrame", func() { Context("min length", func() { It("has proper min length", func() { f := &AckFrameNew{ - LargestObserved: 1, + LargestAcked: 1, } err := f.Write(b, 0) Expect(err).ToNot(HaveOccurred()) @@ -421,7 +421,7 @@ var _ = Describe("AckFrame", func() { It("has proper min length with a large LargestObserved", func() { f := &AckFrameNew{ - LargestObserved: 0xDEADBEEFCAFE, + LargestAcked: 0xDEADBEEFCAFE, } err := f.Write(b, 0) Expect(err).ToNot(HaveOccurred()) @@ -430,8 +430,8 @@ var _ = Describe("AckFrame", func() { It("has the proper min length for an ACK with missing packets", func() { f := &AckFrameNew{ - LargestObserved: 2000, - LowestAcked: 10, + LargestAcked: 2000, + LowestAcked: 10, AckRanges: []AckRange{ AckRange{FirstPacketNumber: 1000, LastPacketNumber: 2000}, AckRange{FirstPacketNumber: 50, LastPacketNumber: 900}, @@ -445,8 +445,8 @@ var _ = Describe("AckFrame", func() { It("has the proper min length for an ACK with long gaps of missing packets", func() { f := &AckFrameNew{ - LargestObserved: 2000, - LowestAcked: 1, + LargestAcked: 2000, + LowestAcked: 1, AckRanges: []AckRange{ AckRange{FirstPacketNumber: 1500, LastPacketNumber: 2000}, AckRange{FirstPacketNumber: 290, LastPacketNumber: 295}, @@ -462,21 +462,21 @@ var _ = Describe("AckFrame", func() { Context("ACK range validator", func() { It("accepts an ACK without NACK Ranges", func() { - ack := AckFrameNew{LargestObserved: 7} + ack := AckFrameNew{LargestAcked: 7} Expect(ack.validateAckRanges()).To(BeTrue()) }) It("rejects ACK ranges with a single range", func() { ack := AckFrameNew{ - LargestObserved: 10, - AckRanges: []AckRange{AckRange{FirstPacketNumber: 1, LastPacketNumber: 10}}, + LargestAcked: 10, + AckRanges: []AckRange{AckRange{FirstPacketNumber: 1, LastPacketNumber: 10}}, } Expect(ack.validateAckRanges()).To(BeFalse()) }) It("rejects ACK ranges with LastPacketNumber of the first range unequal to LargestObserved", func() { ack := AckFrameNew{ - LargestObserved: 10, + LargestAcked: 10, AckRanges: []AckRange{ AckRange{FirstPacketNumber: 8, LastPacketNumber: 9}, AckRange{FirstPacketNumber: 2, LastPacketNumber: 3}, @@ -487,7 +487,7 @@ var _ = Describe("AckFrame", func() { It("rejects ACK ranges with FirstPacketNumber greater than LastPacketNumber", func() { ack := AckFrameNew{ - LargestObserved: 10, + LargestAcked: 10, AckRanges: []AckRange{ AckRange{FirstPacketNumber: 8, LastPacketNumber: 10}, AckRange{FirstPacketNumber: 4, LastPacketNumber: 3}, @@ -498,7 +498,7 @@ var _ = Describe("AckFrame", func() { It("rejects ACK ranges with FirstPacketNumber greater than LargestObserved", func() { ack := AckFrameNew{ - LargestObserved: 5, + LargestAcked: 5, AckRanges: []AckRange{ AckRange{FirstPacketNumber: 4, LastPacketNumber: 10}, AckRange{FirstPacketNumber: 1, LastPacketNumber: 2}, @@ -509,7 +509,7 @@ var _ = Describe("AckFrame", func() { It("rejects ACK ranges in the wrong order", func() { ack := AckFrameNew{ - LargestObserved: 7, + LargestAcked: 7, AckRanges: []AckRange{ {FirstPacketNumber: 2, LastPacketNumber: 2}, {FirstPacketNumber: 6, LastPacketNumber: 7}, @@ -520,7 +520,7 @@ var _ = Describe("AckFrame", func() { It("rejects with overlapping ACK ranges", func() { ack := AckFrameNew{ - LargestObserved: 7, + LargestAcked: 7, AckRanges: []AckRange{ {FirstPacketNumber: 5, LastPacketNumber: 7}, {FirstPacketNumber: 2, LastPacketNumber: 5}, @@ -531,7 +531,7 @@ var _ = Describe("AckFrame", func() { It("rejects ACK ranges that are part of a larger ACK range", func() { ack := AckFrameNew{ - LargestObserved: 7, + LargestAcked: 7, AckRanges: []AckRange{ {FirstPacketNumber: 4, LastPacketNumber: 7}, {FirstPacketNumber: 5, LastPacketNumber: 6}, @@ -542,7 +542,7 @@ var _ = Describe("AckFrame", func() { It("rejects with directly adjacent ACK ranges", func() { ack := AckFrameNew{ - LargestObserved: 7, + LargestAcked: 7, AckRanges: []AckRange{ {FirstPacketNumber: 5, LastPacketNumber: 7}, {FirstPacketNumber: 2, LastPacketNumber: 4}, @@ -553,7 +553,7 @@ var _ = Describe("AckFrame", func() { It("accepts an ACK with one lost packet", func() { ack := AckFrameNew{ - LargestObserved: 10, + LargestAcked: 10, AckRanges: []AckRange{ {FirstPacketNumber: 5, LastPacketNumber: 10}, {FirstPacketNumber: 1, LastPacketNumber: 3}, @@ -564,7 +564,7 @@ var _ = Describe("AckFrame", func() { It("accepts an ACK with multiple lost packets", func() { ack := AckFrameNew{ - LargestObserved: 20, + LargestAcked: 20, AckRanges: []AckRange{ {FirstPacketNumber: 15, LastPacketNumber: 20}, {FirstPacketNumber: 10, LastPacketNumber: 12},