send DelayTime in ACK frames

fixes #81

ackhandler/interfaces.go

@@ -23,7 +23,7 @@ type ReceivedPacketHandler interface {
 	ReceivedPacket(packetNumber protocol.PacketNumber, entropyBit bool) error
 	ReceivedStopWaiting(*frames.StopWaitingFrame) error
 
-	DequeueAckFrame() *frames.AckFrame
+	DequeueAckFrame() (*frames.AckFrame, error)
 }
 
 // StopWaitingManager manages StopWaitings for sent packets

ackhandler/received_packet_handler.go

@@ -11,6 +11,8 @@ import (
 // ErrDuplicatePacket occurres when a duplicate packet is received
 var ErrDuplicatePacket = errors.New("ReceivedPacketHandler: Duplicate Packet")
 
+var errInvalidPacketNumber = errors.New("ReceivedPacketHandler: Invalid packet number")
+
 type packetHistoryEntry struct {
 	EntropyBit   bool
 	TimeReceived time.Time
@@ -33,7 +35,7 @@ func NewReceivedPacketHandler() ReceivedPacketHandler {
 
 func (h *receivedPacketHandler) ReceivedPacket(packetNumber protocol.PacketNumber, entropyBit bool) error {
 	if packetNumber == 0 {
-		return errors.New("Invalid packet number")
+		return errInvalidPacketNumber
 	}
 	_, ok := h.packetHistory[packetNumber]
 	if packetNumber <= h.highestInOrderObserved || ok {
@@ -98,17 +100,25 @@ func (h *receivedPacketHandler) getNackRanges() ([]frames.NackRange, EntropyAccu
 	return ranges, entropy
 }
 
-func (h *receivedPacketHandler) DequeueAckFrame() *frames.AckFrame {
+func (h *receivedPacketHandler) DequeueAckFrame() (*frames.AckFrame, error) {
 	if !h.stateChanged {
-		return nil
+		return nil, nil
 	}
 
 	h.stateChanged = false
 
-	nackRanges, entropy := h.getNackRanges()
-	return &frames.AckFrame{
-		LargestObserved: h.largestObserved,
-		Entropy:         byte(entropy),
-		NackRanges:      nackRanges,
+	p, ok := h.packetHistory[h.largestObserved]
+	if !ok {
+		return nil, errors.New("bla")
 	}
+	packetReceivedTime := p.TimeReceived
+
+	nackRanges, entropy := h.getNackRanges()
+	ack := frames.AckFrame{
+		LargestObserved:    h.largestObserved,
+		Entropy:            byte(entropy),
+		NackRanges:         nackRanges,
+		PacketReceivedTime: packetReceivedTime,
+	}
+	return &ack, nil
 }

ackhandler/received_packet_handler_test.go

@@ -34,6 +34,12 @@ var _ = Describe("receivedPacketHandler", func() {
 			Expect(handler.packetHistory).To(HaveKey(protocol.PacketNumber(3)))
 		})
 
+		It("rejects packets with packet number 0", func() {
+			err := handler.ReceivedPacket(protocol.PacketNumber(0), false)
+			Expect(err).To(HaveOccurred())
+			Expect(err).To(Equal(errInvalidPacketNumber))
+		})
+
 		It("rejects a duplicate package with PacketNumber equal to LargestObserved", func() {
 			for i := 1; i < 5; i++ {
 				err := handler.ReceivedPacket(protocol.PacketNumber(i), false)
@@ -243,7 +249,10 @@ var _ = Describe("receivedPacketHandler", func() {
 			Expect(err).ToNot(HaveOccurred())
 			err = handler.ReceivedPacket(protocol.PacketNumber(2), true)
 			Expect(err).ToNot(HaveOccurred())
-			Expect(handler.DequeueAckFrame()).To(Equal(&frames.AckFrame{LargestObserved: 2, Entropy: byte(entropy)}))
+			ack, err := handler.DequeueAckFrame()
+			Expect(err).ToNot(HaveOccurred())
+			Expect(ack.LargestObserved).To(Equal(protocol.PacketNumber(2)))
+			Expect(ack.Entropy).To(Equal(byte(entropy)))
 		})
 
 		It("generates an ACK frame with a NACK range", func() {
@@ -254,12 +263,11 @@ var _ = Describe("receivedPacketHandler", func() {
 			Expect(err).ToNot(HaveOccurred())
 			err = handler.ReceivedPacket(protocol.PacketNumber(4), true)
 			Expect(err).ToNot(HaveOccurred())
-			expectedAck := frames.AckFrame{
-				LargestObserved: 4,
-				Entropy:         byte(entropy),
-				NackRanges:      []frames.NackRange{frames.NackRange{FirstPacketNumber: 2, LastPacketNumber: 3}},
-			}
-			Expect(handler.DequeueAckFrame()).To(Equal(&expectedAck))
+			ack, err := handler.DequeueAckFrame()
+			Expect(err).ToNot(HaveOccurred())
+			Expect(ack.LargestObserved).To(Equal(protocol.PacketNumber(4)))
+			Expect(ack.Entropy).To(Equal(byte(entropy)))
+			Expect(ack.NackRanges).To(Equal([]frames.NackRange{frames.NackRange{FirstPacketNumber: 2, LastPacketNumber: 3}}))
 		})
 
 		It("does not generate an ACK if an ACK has already been sent for the largest Packet", func() {