1package ackhandler 2 3import ( 4 "fmt" 5 "time" 6 7 "github.com/golang/mock/gomock" 8 "github.com/lucas-clemente/quic-go/internal/mocks" 9 "github.com/lucas-clemente/quic-go/internal/protocol" 10 "github.com/lucas-clemente/quic-go/internal/utils" 11 "github.com/lucas-clemente/quic-go/internal/wire" 12 13 . "github.com/onsi/ginkgo" 14 . "github.com/onsi/gomega" 15) 16 17var _ = Describe("SentPacketHandler", func() { 18 var ( 19 handler *sentPacketHandler 20 streamFrame wire.StreamFrame 21 lostPackets []protocol.PacketNumber 22 perspective protocol.Perspective 23 ) 24 25 BeforeEach(func() { perspective = protocol.PerspectiveServer }) 26 27 JustBeforeEach(func() { 28 lostPackets = nil 29 rttStats := utils.NewRTTStats() 30 handler = newSentPacketHandler(42, protocol.InitialPacketSizeIPv4, rttStats, perspective, nil, utils.DefaultLogger) 31 streamFrame = wire.StreamFrame{ 32 StreamID: 5, 33 Data: []byte{0x13, 0x37}, 34 } 35 }) 36 37 getPacket := func(pn protocol.PacketNumber, encLevel protocol.EncryptionLevel) *Packet { 38 if el, ok := handler.getPacketNumberSpace(encLevel).history.packetMap[pn]; ok { 39 return &el.Value 40 } 41 return nil 42 } 43 44 ackElicitingPacket := func(p *Packet) *Packet { 45 if p.EncryptionLevel == 0 { 46 p.EncryptionLevel = protocol.Encryption1RTT 47 } 48 if p.Length == 0 { 49 p.Length = 1 50 } 51 if p.SendTime.IsZero() { 52 p.SendTime = time.Now() 53 } 54 if len(p.Frames) == 0 { 55 p.Frames = []Frame{ 56 {Frame: &wire.PingFrame{}, OnLost: func(wire.Frame) { lostPackets = append(lostPackets, p.PacketNumber) }}, 57 } 58 } 59 return p 60 } 61 62 nonAckElicitingPacket := func(p *Packet) *Packet { 63 p = ackElicitingPacket(p) 64 p.Frames = nil 65 p.LargestAcked = 1 66 return p 67 } 68 69 initialPacket := func(p *Packet) *Packet { 70 p = ackElicitingPacket(p) 71 p.EncryptionLevel = protocol.EncryptionInitial 72 return p 73 } 74 75 handshakePacket := func(p *Packet) *Packet { 76 p = ackElicitingPacket(p) 77 p.EncryptionLevel = protocol.EncryptionHandshake 78 return p 79 } 80 81 handshakePacketNonAckEliciting := func(p *Packet) *Packet { 82 p = nonAckElicitingPacket(p) 83 p.EncryptionLevel = protocol.EncryptionHandshake 84 return p 85 } 86 87 expectInPacketHistory := func(expected []protocol.PacketNumber, encLevel protocol.EncryptionLevel) { 88 pnSpace := handler.getPacketNumberSpace(encLevel) 89 var length int 90 pnSpace.history.Iterate(func(p *Packet) (bool, error) { 91 if !p.declaredLost && !p.skippedPacket { 92 length++ 93 } 94 return true, nil 95 }) 96 ExpectWithOffset(1, length).To(Equal(len(expected))) 97 for _, p := range expected { 98 ExpectWithOffset(2, pnSpace.history.packetMap).To(HaveKey(p)) 99 } 100 } 101 102 updateRTT := func(rtt time.Duration) { 103 handler.rttStats.UpdateRTT(rtt, 0, time.Now()) 104 ExpectWithOffset(1, handler.rttStats.SmoothedRTT()).To(Equal(rtt)) 105 } 106 107 Context("registering sent packets", func() { 108 It("accepts two consecutive packets", func() { 109 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 1, EncryptionLevel: protocol.EncryptionHandshake})) 110 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 2, EncryptionLevel: protocol.EncryptionHandshake})) 111 Expect(handler.handshakePackets.largestSent).To(Equal(protocol.PacketNumber(2))) 112 expectInPacketHistory([]protocol.PacketNumber{1, 2}, protocol.EncryptionHandshake) 113 Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(2))) 114 }) 115 116 It("uses the same packet number space for 0-RTT and 1-RTT packets", func() { 117 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 1, EncryptionLevel: protocol.Encryption0RTT})) 118 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 2, EncryptionLevel: protocol.Encryption1RTT})) 119 Expect(handler.appDataPackets.largestSent).To(Equal(protocol.PacketNumber(2))) 120 Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(2))) 121 }) 122 123 It("accepts packet number 0", func() { 124 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 0, EncryptionLevel: protocol.Encryption1RTT})) 125 Expect(handler.appDataPackets.largestSent).To(BeZero()) 126 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 1, EncryptionLevel: protocol.Encryption1RTT})) 127 Expect(handler.appDataPackets.largestSent).To(Equal(protocol.PacketNumber(1))) 128 expectInPacketHistory([]protocol.PacketNumber{0, 1}, protocol.Encryption1RTT) 129 Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(2))) 130 }) 131 132 It("stores the sent time", func() { 133 sendTime := time.Now().Add(-time.Minute) 134 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 1, SendTime: sendTime})) 135 Expect(handler.appDataPackets.lastAckElicitingPacketTime).To(Equal(sendTime)) 136 }) 137 138 It("stores the sent time of Initial packets", func() { 139 sendTime := time.Now().Add(-time.Minute) 140 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 1, SendTime: sendTime, EncryptionLevel: protocol.EncryptionInitial})) 141 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 2, SendTime: sendTime.Add(time.Hour), EncryptionLevel: protocol.Encryption1RTT})) 142 Expect(handler.initialPackets.lastAckElicitingPacketTime).To(Equal(sendTime)) 143 }) 144 }) 145 146 Context("ACK processing", func() { 147 JustBeforeEach(func() { 148 for i := protocol.PacketNumber(0); i < 10; i++ { 149 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: i})) 150 } 151 // Increase RTT, because the tests would be flaky otherwise 152 updateRTT(time.Hour) 153 Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(10))) 154 }) 155 156 Context("ACK validation", func() { 157 It("accepts ACKs sent in packet 0", func() { 158 ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 0, Largest: 5}}} 159 Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) 160 Expect(handler.appDataPackets.largestAcked).To(Equal(protocol.PacketNumber(5))) 161 }) 162 163 It("accepts multiple ACKs sent in the same packet", func() { 164 ack1 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 0, Largest: 3}}} 165 ack2 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 0, Largest: 4}}} 166 Expect(handler.ReceivedAck(ack1, protocol.Encryption1RTT, time.Now())).To(Succeed()) 167 Expect(handler.appDataPackets.largestAcked).To(Equal(protocol.PacketNumber(3))) 168 // this wouldn't happen in practice 169 // 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 170 Expect(handler.ReceivedAck(ack2, protocol.Encryption1RTT, time.Now())).To(Succeed()) 171 Expect(handler.appDataPackets.largestAcked).To(Equal(protocol.PacketNumber(4))) 172 }) 173 174 It("rejects ACKs that acknowledge a skipped packet number", func() { 175 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 100})) 176 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 102})) 177 ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 100, Largest: 102}}} 178 Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(MatchError("received an ACK for skipped packet number: 101 (1-RTT)")) 179 }) 180 181 It("rejects ACKs with a too high LargestAcked packet number", func() { 182 ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 0, Largest: 9999}}} 183 Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(MatchError("PROTOCOL_VIOLATION: Received ACK for an unsent packet")) 184 Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(10))) 185 }) 186 187 It("ignores repeated ACKs", func() { 188 ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 0, Largest: 3}}} 189 Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) 190 Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(6))) 191 Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) 192 Expect(handler.appDataPackets.largestAcked).To(Equal(protocol.PacketNumber(3))) 193 Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(6))) 194 }) 195 }) 196 197 Context("acks the right packets", func() { 198 expectInPacketHistoryOrLost := func(expected []protocol.PacketNumber, encLevel protocol.EncryptionLevel) { 199 pnSpace := handler.getPacketNumberSpace(encLevel) 200 var length int 201 pnSpace.history.Iterate(func(p *Packet) (bool, error) { 202 if !p.declaredLost { 203 length++ 204 } 205 return true, nil 206 }) 207 ExpectWithOffset(1, length+len(lostPackets)).To(Equal(len(expected))) 208 expectedLoop: 209 for _, p := range expected { 210 if _, ok := pnSpace.history.packetMap[p]; ok { 211 continue 212 } 213 for _, lostP := range lostPackets { 214 if lostP == p { 215 continue expectedLoop 216 } 217 } 218 Fail(fmt.Sprintf("Packet %d not in packet history.", p)) 219 } 220 } 221 222 It("adjusts the LargestAcked, and adjusts the bytes in flight", func() { 223 ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 0, Largest: 5}}} 224 Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) 225 Expect(handler.appDataPackets.largestAcked).To(Equal(protocol.PacketNumber(5))) 226 expectInPacketHistoryOrLost([]protocol.PacketNumber{6, 7, 8, 9}, protocol.Encryption1RTT) 227 Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(4))) 228 }) 229 230 It("acks packet 0", func() { 231 ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 0, Largest: 0}}} 232 Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) 233 Expect(getPacket(0, protocol.Encryption1RTT)).To(BeNil()) 234 expectInPacketHistoryOrLost([]protocol.PacketNumber{1, 2, 3, 4, 5, 6, 7, 8, 9}, protocol.Encryption1RTT) 235 }) 236 237 It("calls the OnAcked callback", func() { 238 var acked bool 239 ping := &wire.PingFrame{} 240 handler.SentPacket(ackElicitingPacket(&Packet{ 241 PacketNumber: 13, 242 Frames: []Frame{{ 243 Frame: ping, OnAcked: func(f wire.Frame) { 244 Expect(f).To(Equal(ping)) 245 acked = true 246 }, 247 }}, 248 })) 249 ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 13, Largest: 13}}} 250 Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) 251 Expect(acked).To(BeTrue()) 252 }) 253 254 It("handles an ACK frame with one missing packet range", func() { 255 ack := &wire.AckFrame{ // lose 4 and 5 256 AckRanges: []wire.AckRange{ 257 {Smallest: 6, Largest: 9}, 258 {Smallest: 1, Largest: 3}, 259 }, 260 } 261 Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) 262 expectInPacketHistoryOrLost([]protocol.PacketNumber{0, 4, 5}, protocol.Encryption1RTT) 263 }) 264 265 It("does not ack packets below the LowestAcked", func() { 266 ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 3, Largest: 8}}} 267 Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) 268 expectInPacketHistoryOrLost([]protocol.PacketNumber{0, 1, 2, 9}, protocol.Encryption1RTT) 269 }) 270 271 It("handles an ACK with multiple missing packet ranges", func() { 272 ack := &wire.AckFrame{ // packets 2, 4 and 5, and 8 were lost 273 AckRanges: []wire.AckRange{ 274 {Smallest: 9, Largest: 9}, 275 {Smallest: 6, Largest: 7}, 276 {Smallest: 3, Largest: 3}, 277 {Smallest: 1, Largest: 1}, 278 }, 279 } 280 Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) 281 expectInPacketHistoryOrLost([]protocol.PacketNumber{0, 2, 4, 5, 8}, protocol.Encryption1RTT) 282 }) 283 284 It("processes an ACK frame that would be sent after a late arrival of a packet", func() { 285 ack1 := &wire.AckFrame{ // 5 lost 286 AckRanges: []wire.AckRange{ 287 {Smallest: 6, Largest: 6}, 288 {Smallest: 1, Largest: 4}, 289 }, 290 } 291 Expect(handler.ReceivedAck(ack1, protocol.Encryption1RTT, time.Now())).To(Succeed()) 292 expectInPacketHistoryOrLost([]protocol.PacketNumber{0, 5, 7, 8, 9}, protocol.Encryption1RTT) 293 ack2 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 6}}} // now ack 5 294 Expect(handler.ReceivedAck(ack2, protocol.Encryption1RTT, time.Now())).To(Succeed()) 295 expectInPacketHistoryOrLost([]protocol.PacketNumber{0, 7, 8, 9}, protocol.Encryption1RTT) 296 }) 297 298 It("processes an ACK that contains old ACK ranges", func() { 299 ack1 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 6}}} 300 Expect(handler.ReceivedAck(ack1, protocol.Encryption1RTT, time.Now())).To(Succeed()) 301 expectInPacketHistoryOrLost([]protocol.PacketNumber{0, 7, 8, 9}, protocol.Encryption1RTT) 302 ack2 := &wire.AckFrame{ 303 AckRanges: []wire.AckRange{ 304 {Smallest: 8, Largest: 8}, 305 {Smallest: 3, Largest: 3}, 306 {Smallest: 1, Largest: 1}, 307 }, 308 } 309 Expect(handler.ReceivedAck(ack2, protocol.Encryption1RTT, time.Now())).To(Succeed()) 310 expectInPacketHistoryOrLost([]protocol.PacketNumber{0, 7, 9}, protocol.Encryption1RTT) 311 }) 312 }) 313 314 Context("calculating RTT", func() { 315 It("computes the RTT", func() { 316 now := time.Now() 317 // First, fake the sent times of the first, second and last packet 318 getPacket(1, protocol.Encryption1RTT).SendTime = now.Add(-10 * time.Minute) 319 getPacket(2, protocol.Encryption1RTT).SendTime = now.Add(-5 * time.Minute) 320 getPacket(6, protocol.Encryption1RTT).SendTime = now.Add(-1 * time.Minute) 321 // Now, check that the proper times are used when calculating the deltas 322 ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}} 323 Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) 324 Expect(handler.rttStats.LatestRTT()).To(BeNumerically("~", 10*time.Minute, 1*time.Second)) 325 ack = &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 2}}} 326 Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) 327 Expect(handler.rttStats.LatestRTT()).To(BeNumerically("~", 5*time.Minute, 1*time.Second)) 328 ack = &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 6}}} 329 Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) 330 Expect(handler.rttStats.LatestRTT()).To(BeNumerically("~", 1*time.Minute, 1*time.Second)) 331 }) 332 333 It("ignores the DelayTime for Initial and Handshake packets", func() { 334 handler.SentPacket(initialPacket(&Packet{PacketNumber: 1})) 335 handler.rttStats.SetMaxAckDelay(time.Hour) 336 // make sure the rttStats have a min RTT, so that the delay is used 337 handler.rttStats.UpdateRTT(5*time.Minute, 0, time.Now()) 338 getPacket(1, protocol.EncryptionInitial).SendTime = time.Now().Add(-10 * time.Minute) 339 ack := &wire.AckFrame{ 340 AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}, 341 DelayTime: 5 * time.Minute, 342 } 343 Expect(handler.ReceivedAck(ack, protocol.EncryptionInitial, time.Now())).To(Succeed()) 344 Expect(handler.rttStats.LatestRTT()).To(BeNumerically("~", 10*time.Minute, 1*time.Second)) 345 }) 346 347 It("uses the DelayTime in the ACK frame", func() { 348 handler.rttStats.SetMaxAckDelay(time.Hour) 349 // make sure the rttStats have a min RTT, so that the delay is used 350 handler.rttStats.UpdateRTT(5*time.Minute, 0, time.Now()) 351 getPacket(1, protocol.Encryption1RTT).SendTime = time.Now().Add(-10 * time.Minute) 352 ack := &wire.AckFrame{ 353 AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}, 354 DelayTime: 5 * time.Minute, 355 } 356 Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) 357 Expect(handler.rttStats.LatestRTT()).To(BeNumerically("~", 5*time.Minute, 1*time.Second)) 358 }) 359 360 It("limits the DelayTime in the ACK frame to max_ack_delay", func() { 361 handler.rttStats.SetMaxAckDelay(time.Minute) 362 // make sure the rttStats have a min RTT, so that the delay is used 363 handler.rttStats.UpdateRTT(5*time.Minute, 0, time.Now()) 364 getPacket(1, protocol.Encryption1RTT).SendTime = time.Now().Add(-10 * time.Minute) 365 ack := &wire.AckFrame{ 366 AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}, 367 DelayTime: 5 * time.Minute, 368 } 369 Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) 370 Expect(handler.rttStats.LatestRTT()).To(BeNumerically("~", 9*time.Minute, 1*time.Second)) 371 }) 372 }) 373 374 Context("determining which ACKs we have received an ACK for", func() { 375 JustBeforeEach(func() { 376 morePackets := []*Packet{ 377 { 378 PacketNumber: 13, 379 LargestAcked: 100, 380 Frames: []Frame{{Frame: &streamFrame, OnLost: func(wire.Frame) {}}}, 381 Length: 1, 382 EncryptionLevel: protocol.Encryption1RTT, 383 }, 384 { 385 PacketNumber: 14, 386 LargestAcked: 200, 387 Frames: []Frame{{Frame: &streamFrame, OnLost: func(wire.Frame) {}}}, 388 Length: 1, 389 EncryptionLevel: protocol.Encryption1RTT, 390 }, 391 { 392 PacketNumber: 15, 393 Frames: []Frame{{Frame: &streamFrame, OnLost: func(wire.Frame) {}}}, 394 Length: 1, 395 EncryptionLevel: protocol.Encryption1RTT, 396 }, 397 } 398 for _, packet := range morePackets { 399 handler.SentPacket(packet) 400 } 401 }) 402 403 It("determines which ACK we have received an ACK for", func() { 404 ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 13, Largest: 15}}} 405 Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) 406 Expect(handler.GetLowestPacketNotConfirmedAcked()).To(Equal(protocol.PacketNumber(201))) 407 }) 408 409 It("doesn't do anything when the acked packet didn't contain an ACK", func() { 410 ack1 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 13, Largest: 13}}} 411 ack2 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 15, Largest: 15}}} 412 Expect(handler.ReceivedAck(ack1, protocol.Encryption1RTT, time.Now())).To(Succeed()) 413 Expect(handler.GetLowestPacketNotConfirmedAcked()).To(Equal(protocol.PacketNumber(101))) 414 Expect(handler.ReceivedAck(ack2, protocol.Encryption1RTT, time.Now())).To(Succeed()) 415 Expect(handler.GetLowestPacketNotConfirmedAcked()).To(Equal(protocol.PacketNumber(101))) 416 }) 417 418 It("doesn't decrease the value", func() { 419 ack1 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 14, Largest: 14}}} 420 ack2 := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 13, Largest: 13}}} 421 Expect(handler.ReceivedAck(ack1, protocol.Encryption1RTT, time.Now())).To(Succeed()) 422 Expect(handler.GetLowestPacketNotConfirmedAcked()).To(Equal(protocol.PacketNumber(201))) 423 Expect(handler.ReceivedAck(ack2, protocol.Encryption1RTT, time.Now())).To(Succeed()) 424 Expect(handler.GetLowestPacketNotConfirmedAcked()).To(Equal(protocol.PacketNumber(201))) 425 }) 426 }) 427 }) 428 429 Context("congestion", func() { 430 var cong *mocks.MockSendAlgorithmWithDebugInfos 431 432 JustBeforeEach(func() { 433 cong = mocks.NewMockSendAlgorithmWithDebugInfos(mockCtrl) 434 handler.congestion = cong 435 }) 436 437 It("should call OnSent", func() { 438 cong.EXPECT().OnPacketSent( 439 gomock.Any(), 440 protocol.ByteCount(42), 441 protocol.PacketNumber(1), 442 protocol.ByteCount(42), 443 true, 444 ) 445 handler.SentPacket(&Packet{ 446 PacketNumber: 1, 447 Length: 42, 448 Frames: []Frame{{Frame: &wire.PingFrame{}, OnLost: func(wire.Frame) {}}}, 449 EncryptionLevel: protocol.Encryption1RTT, 450 }) 451 }) 452 453 It("should call MaybeExitSlowStart and OnPacketAcked", func() { 454 rcvTime := time.Now().Add(-5 * time.Second) 455 cong.EXPECT().OnPacketSent(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(3) 456 gomock.InOrder( 457 cong.EXPECT().MaybeExitSlowStart(), // must be called before packets are acked 458 cong.EXPECT().OnPacketAcked(protocol.PacketNumber(1), protocol.ByteCount(1), protocol.ByteCount(3), rcvTime), 459 cong.EXPECT().OnPacketAcked(protocol.PacketNumber(2), protocol.ByteCount(1), protocol.ByteCount(3), rcvTime), 460 ) 461 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 1})) 462 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 2})) 463 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 3})) 464 ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 2}}} 465 Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, rcvTime)).To(Succeed()) 466 }) 467 468 It("doesn't call OnPacketAcked when a retransmitted packet is acked", func() { 469 cong.EXPECT().OnPacketSent(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(2) 470 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 1, SendTime: time.Now().Add(-time.Hour)})) 471 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 2})) 472 // lose packet 1 473 gomock.InOrder( 474 cong.EXPECT().MaybeExitSlowStart(), 475 cong.EXPECT().OnPacketLost(protocol.PacketNumber(1), protocol.ByteCount(1), protocol.ByteCount(2)), 476 cong.EXPECT().OnPacketAcked(protocol.PacketNumber(2), protocol.ByteCount(1), protocol.ByteCount(2), gomock.Any()), 477 ) 478 ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 2, Largest: 2}}} 479 Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) 480 // don't EXPECT any further calls to the congestion controller 481 ack = &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 2}}} 482 Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) 483 }) 484 485 It("doesn't call OnPacketLost when a Path MTU probe packet is lost", func() { 486 cong.EXPECT().OnPacketSent(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(2) 487 var mtuPacketDeclaredLost bool 488 handler.SentPacket(ackElicitingPacket(&Packet{ 489 PacketNumber: 1, 490 SendTime: time.Now().Add(-time.Hour), 491 IsPathMTUProbePacket: true, 492 Frames: []Frame{{Frame: &wire.PingFrame{}, OnLost: func(wire.Frame) { mtuPacketDeclaredLost = true }}}, 493 })) 494 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 2})) 495 // lose packet 1, but don't EXPECT any calls to OnPacketLost() 496 gomock.InOrder( 497 cong.EXPECT().MaybeExitSlowStart(), 498 cong.EXPECT().OnPacketAcked(protocol.PacketNumber(2), protocol.ByteCount(1), protocol.ByteCount(2), gomock.Any()), 499 ) 500 ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 2, Largest: 2}}} 501 Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) 502 Expect(mtuPacketDeclaredLost).To(BeTrue()) 503 Expect(handler.bytesInFlight).To(BeZero()) 504 }) 505 506 It("calls OnPacketAcked and OnPacketLost with the right bytes_in_flight value", func() { 507 cong.EXPECT().OnPacketSent(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Times(4) 508 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 1, SendTime: time.Now().Add(-time.Hour)})) 509 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 2, SendTime: time.Now().Add(-30 * time.Minute)})) 510 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 3, SendTime: time.Now().Add(-30 * time.Minute)})) 511 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 4, SendTime: time.Now()})) 512 // receive the first ACK 513 gomock.InOrder( 514 cong.EXPECT().MaybeExitSlowStart(), 515 cong.EXPECT().OnPacketLost(protocol.PacketNumber(1), protocol.ByteCount(1), protocol.ByteCount(4)), 516 cong.EXPECT().OnPacketAcked(protocol.PacketNumber(2), protocol.ByteCount(1), protocol.ByteCount(4), gomock.Any()), 517 ) 518 ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 2, Largest: 2}}} 519 Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now().Add(-30*time.Minute))).To(Succeed()) 520 // receive the second ACK 521 gomock.InOrder( 522 cong.EXPECT().MaybeExitSlowStart(), 523 cong.EXPECT().OnPacketLost(protocol.PacketNumber(3), protocol.ByteCount(1), protocol.ByteCount(2)), 524 cong.EXPECT().OnPacketAcked(protocol.PacketNumber(4), protocol.ByteCount(1), protocol.ByteCount(2), gomock.Any()), 525 ) 526 ack = &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 4, Largest: 4}}} 527 Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) 528 }) 529 530 It("passes the bytes in flight to the congestion controller", func() { 531 handler.ReceivedPacket(protocol.EncryptionHandshake) 532 cong.EXPECT().OnPacketSent(gomock.Any(), protocol.ByteCount(42), gomock.Any(), protocol.ByteCount(42), true) 533 handler.SentPacket(&Packet{ 534 Length: 42, 535 EncryptionLevel: protocol.EncryptionInitial, 536 Frames: []Frame{{Frame: &wire.PingFrame{}}}, 537 SendTime: time.Now(), 538 }) 539 cong.EXPECT().CanSend(protocol.ByteCount(42)).Return(true) 540 handler.SendMode() 541 }) 542 543 It("allows sending of ACKs when congestion limited", func() { 544 handler.ReceivedPacket(protocol.EncryptionHandshake) 545 cong.EXPECT().CanSend(gomock.Any()).Return(true) 546 Expect(handler.SendMode()).To(Equal(SendAny)) 547 cong.EXPECT().CanSend(gomock.Any()).Return(false) 548 Expect(handler.SendMode()).To(Equal(SendAck)) 549 }) 550 551 It("allows sending of ACKs when we're keeping track of MaxOutstandingSentPackets packets", func() { 552 handler.ReceivedPacket(protocol.EncryptionHandshake) 553 cong.EXPECT().CanSend(gomock.Any()).Return(true).AnyTimes() 554 cong.EXPECT().OnPacketSent(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() 555 for i := protocol.PacketNumber(0); i < protocol.MaxOutstandingSentPackets; i++ { 556 Expect(handler.SendMode()).To(Equal(SendAny)) 557 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: i})) 558 } 559 Expect(handler.SendMode()).To(Equal(SendAck)) 560 }) 561 562 It("allows PTOs, even when congestion limited", func() { 563 handler.ReceivedPacket(protocol.EncryptionHandshake) 564 // note that we don't EXPECT a call to GetCongestionWindow 565 // that means retransmissions are sent without considering the congestion window 566 handler.numProbesToSend = 1 567 handler.ptoMode = SendPTOHandshake 568 Expect(handler.SendMode()).To(Equal(SendPTOHandshake)) 569 }) 570 571 It("says if it has pacing budget", func() { 572 cong.EXPECT().HasPacingBudget().Return(true) 573 Expect(handler.HasPacingBudget()).To(BeTrue()) 574 cong.EXPECT().HasPacingBudget().Return(false) 575 Expect(handler.HasPacingBudget()).To(BeFalse()) 576 }) 577 578 It("returns the pacing delay", func() { 579 t := time.Now() 580 cong.EXPECT().TimeUntilSend(gomock.Any()).Return(t) 581 Expect(handler.TimeUntilSend()).To(Equal(t)) 582 }) 583 }) 584 585 It("doesn't set an alarm if there are no outstanding packets", func() { 586 handler.ReceivedPacket(protocol.EncryptionHandshake) 587 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 10})) 588 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 11})) 589 ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 10, Largest: 11}}} 590 Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) 591 Expect(handler.GetLossDetectionTimeout()).To(BeZero()) 592 }) 593 594 It("does nothing on OnAlarm if there are no outstanding packets", func() { 595 handler.ReceivedPacket(protocol.EncryptionHandshake) 596 Expect(handler.OnLossDetectionTimeout()).To(Succeed()) 597 Expect(handler.SendMode()).To(Equal(SendAny)) 598 }) 599 600 Context("probe packets", func() { 601 It("queues a probe packet", func() { 602 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 10})) 603 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 11})) 604 queued := handler.QueueProbePacket(protocol.Encryption1RTT) 605 Expect(queued).To(BeTrue()) 606 Expect(lostPackets).To(Equal([]protocol.PacketNumber{10})) 607 }) 608 609 It("says when it can't queue a probe packet", func() { 610 queued := handler.QueueProbePacket(protocol.Encryption1RTT) 611 Expect(queued).To(BeFalse()) 612 }) 613 614 It("implements exponential backoff", func() { 615 handler.peerAddressValidated = true 616 handler.SetHandshakeConfirmed() 617 sendTime := time.Now().Add(-time.Hour) 618 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 1, SendTime: sendTime})) 619 timeout := handler.GetLossDetectionTimeout().Sub(sendTime) 620 Expect(handler.GetLossDetectionTimeout().Sub(sendTime)).To(Equal(timeout)) 621 handler.ptoCount = 1 622 handler.setLossDetectionTimer() 623 Expect(handler.GetLossDetectionTimeout().Sub(sendTime)).To(Equal(2 * timeout)) 624 handler.ptoCount = 2 625 handler.setLossDetectionTimer() 626 Expect(handler.GetLossDetectionTimeout().Sub(sendTime)).To(Equal(4 * timeout)) 627 }) 628 629 It("reset the PTO count when receiving an ACK", func() { 630 handler.ReceivedPacket(protocol.EncryptionHandshake) 631 now := time.Now() 632 handler.SetHandshakeConfirmed() 633 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 1, SendTime: now.Add(-time.Minute)})) 634 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 2, SendTime: now.Add(-time.Minute)})) 635 Expect(handler.GetLossDetectionTimeout()).To(BeTemporally("~", now.Add(-time.Minute), time.Second)) 636 Expect(handler.OnLossDetectionTimeout()).To(Succeed()) 637 Expect(handler.SendMode()).To(Equal(SendPTOAppData)) 638 Expect(handler.ptoCount).To(BeEquivalentTo(1)) 639 Expect(handler.ReceivedAck(&wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}}, protocol.Encryption1RTT, time.Now())).To(Succeed()) 640 Expect(handler.ptoCount).To(BeZero()) 641 }) 642 643 It("resets the PTO mode and PTO count when a packet number space is dropped", func() { 644 handler.ReceivedPacket(protocol.EncryptionHandshake) 645 646 now := time.Now() 647 handler.rttStats.UpdateRTT(time.Second/2, 0, now) 648 Expect(handler.rttStats.SmoothedRTT()).To(Equal(time.Second / 2)) 649 Expect(handler.rttStats.PTO(true)).To(And( 650 BeNumerically(">", time.Second), 651 BeNumerically("<", 2*time.Second), 652 )) 653 sendTimeHandshake := now.Add(-2 * time.Minute) 654 sendTimeAppData := now.Add(-time.Minute) 655 656 handler.SentPacket(ackElicitingPacket(&Packet{ 657 PacketNumber: 1, 658 EncryptionLevel: protocol.EncryptionHandshake, 659 SendTime: sendTimeHandshake, 660 })) 661 handler.SentPacket(ackElicitingPacket(&Packet{ 662 PacketNumber: 2, 663 SendTime: sendTimeAppData, 664 })) 665 666 // PTO timer based on the Handshake packet 667 Expect(handler.OnLossDetectionTimeout()).To(Succeed()) 668 Expect(handler.ptoCount).To(BeEquivalentTo(1)) 669 Expect(handler.SendMode()).To(Equal(SendPTOHandshake)) 670 Expect(handler.GetLossDetectionTimeout()).To(Equal(sendTimeHandshake.Add(handler.rttStats.PTO(false) << 1))) 671 handler.SetHandshakeConfirmed() 672 handler.DropPackets(protocol.EncryptionHandshake) 673 // PTO timer based on the 1-RTT packet 674 Expect(handler.GetLossDetectionTimeout()).To(Equal(sendTimeAppData.Add(handler.rttStats.PTO(true)))) // no backoff. PTO count = 0 675 Expect(handler.SendMode()).ToNot(Equal(SendPTOHandshake)) 676 Expect(handler.ptoCount).To(BeZero()) 677 }) 678 679 It("allows two 1-RTT PTOs", func() { 680 handler.ReceivedPacket(protocol.EncryptionHandshake) 681 handler.SetHandshakeConfirmed() 682 var lostPackets []protocol.PacketNumber 683 handler.SentPacket(ackElicitingPacket(&Packet{ 684 PacketNumber: 1, 685 SendTime: time.Now().Add(-time.Hour), 686 Frames: []Frame{ 687 {Frame: &wire.PingFrame{}, OnLost: func(wire.Frame) { lostPackets = append(lostPackets, 1) }}, 688 }, 689 })) 690 Expect(handler.OnLossDetectionTimeout()).To(Succeed()) 691 Expect(handler.SendMode()).To(Equal(SendPTOAppData)) 692 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 2})) 693 Expect(handler.SendMode()).To(Equal(SendPTOAppData)) 694 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 3})) 695 Expect(handler.SendMode()).ToNot(Equal(SendPTOAppData)) 696 }) 697 698 It("skips a packet number for 1-RTT PTOs", func() { 699 handler.ReceivedPacket(protocol.EncryptionHandshake) 700 handler.SetHandshakeConfirmed() 701 var lostPackets []protocol.PacketNumber 702 pn := handler.PopPacketNumber(protocol.Encryption1RTT) 703 handler.SentPacket(ackElicitingPacket(&Packet{ 704 PacketNumber: pn, 705 SendTime: time.Now().Add(-time.Hour), 706 Frames: []Frame{ 707 {Frame: &wire.PingFrame{}, OnLost: func(wire.Frame) { lostPackets = append(lostPackets, 1) }}, 708 }, 709 })) 710 Expect(handler.OnLossDetectionTimeout()).To(Succeed()) 711 Expect(handler.SendMode()).To(Equal(SendPTOAppData)) 712 // The packet number generator might have introduced another skipped a packet number. 713 Expect(handler.PopPacketNumber(protocol.Encryption1RTT)).To(BeNumerically(">=", pn+2)) 714 }) 715 716 It("only counts ack-eliciting packets as probe packets", func() { 717 handler.ReceivedPacket(protocol.EncryptionHandshake) 718 handler.SetHandshakeConfirmed() 719 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 1, SendTime: time.Now().Add(-time.Hour)})) 720 Expect(handler.OnLossDetectionTimeout()).To(Succeed()) 721 Expect(handler.SendMode()).To(Equal(SendPTOAppData)) 722 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 2})) 723 Expect(handler.SendMode()).To(Equal(SendPTOAppData)) 724 for p := protocol.PacketNumber(3); p < 30; p++ { 725 handler.SentPacket(nonAckElicitingPacket(&Packet{PacketNumber: p})) 726 Expect(handler.SendMode()).To(Equal(SendPTOAppData)) 727 } 728 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 30})) 729 Expect(handler.SendMode()).ToNot(Equal(SendPTOAppData)) 730 }) 731 732 It("gets two probe packets if PTO expires", func() { 733 handler.ReceivedPacket(protocol.EncryptionHandshake) 734 handler.SetHandshakeConfirmed() 735 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 1})) 736 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 2})) 737 738 updateRTT(time.Hour) 739 Expect(handler.appDataPackets.lossTime.IsZero()).To(BeTrue()) 740 741 Expect(handler.OnLossDetectionTimeout()).To(Succeed()) // TLP 742 Expect(handler.ptoCount).To(BeEquivalentTo(1)) 743 Expect(handler.SendMode()).To(Equal(SendPTOAppData)) 744 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 3})) 745 Expect(handler.SendMode()).To(Equal(SendPTOAppData)) 746 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 4})) 747 748 Expect(handler.OnLossDetectionTimeout()).To(Succeed()) // PTO 749 Expect(handler.ptoCount).To(BeEquivalentTo(2)) 750 Expect(handler.SendMode()).To(Equal(SendPTOAppData)) 751 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 5})) 752 Expect(handler.SendMode()).To(Equal(SendPTOAppData)) 753 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 6})) 754 755 Expect(handler.SendMode()).To(Equal(SendAny)) 756 }) 757 758 It("gets two probe packets if PTO expires, for Handshake packets", func() { 759 handler.ReceivedPacket(protocol.EncryptionHandshake) 760 handler.SentPacket(initialPacket(&Packet{PacketNumber: 1})) 761 handler.SentPacket(initialPacket(&Packet{PacketNumber: 2})) 762 763 updateRTT(time.Hour) 764 Expect(handler.initialPackets.lossTime.IsZero()).To(BeTrue()) 765 766 Expect(handler.OnLossDetectionTimeout()).To(Succeed()) 767 Expect(handler.SendMode()).To(Equal(SendPTOInitial)) 768 handler.SentPacket(initialPacket(&Packet{PacketNumber: 3})) 769 Expect(handler.SendMode()).To(Equal(SendPTOInitial)) 770 handler.SentPacket(initialPacket(&Packet{PacketNumber: 4})) 771 772 Expect(handler.SendMode()).To(Equal(SendAny)) 773 }) 774 775 It("doesn't send 1-RTT probe packets before the handshake completes", func() { 776 handler.ReceivedPacket(protocol.EncryptionHandshake) 777 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 1})) 778 updateRTT(time.Hour) 779 Expect(handler.OnLossDetectionTimeout()).To(Succeed()) // TLP 780 Expect(handler.GetLossDetectionTimeout()).To(BeZero()) 781 Expect(handler.SendMode()).To(Equal(SendAny)) 782 handler.SetHandshakeConfirmed() 783 Expect(handler.GetLossDetectionTimeout()).ToNot(BeZero()) 784 Expect(handler.OnLossDetectionTimeout()).To(Succeed()) 785 Expect(handler.SendMode()).To(Equal(SendPTOAppData)) 786 }) 787 788 It("resets the send mode when it receives an acknowledgement after queueing probe packets", func() { 789 handler.ReceivedPacket(protocol.EncryptionHandshake) 790 handler.SetHandshakeConfirmed() 791 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 1, SendTime: time.Now().Add(-time.Hour)})) 792 handler.rttStats.UpdateRTT(time.Second, 0, time.Now()) 793 Expect(handler.OnLossDetectionTimeout()).To(Succeed()) 794 Expect(handler.SendMode()).To(Equal(SendPTOAppData)) 795 ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}} 796 Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, time.Now())).To(Succeed()) 797 Expect(handler.SendMode()).To(Equal(SendAny)) 798 }) 799 800 It("handles ACKs for the original packet", func() { 801 handler.ReceivedPacket(protocol.EncryptionHandshake) 802 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 5, SendTime: time.Now().Add(-time.Hour)})) 803 handler.rttStats.UpdateRTT(time.Second, 0, time.Now()) 804 Expect(handler.OnLossDetectionTimeout()).To(Succeed()) 805 Expect(handler.OnLossDetectionTimeout()).To(Succeed()) 806 }) 807 }) 808 809 Context("amplification limit, for the server", func() { 810 It("limits the window to 3x the bytes received, to avoid amplification attacks", func() { 811 handler.ReceivedPacket(protocol.EncryptionInitial) // receiving an Initial packet doesn't validate the client's address 812 handler.ReceivedBytes(200) 813 handler.SentPacket(&Packet{ 814 PacketNumber: 1, 815 Length: 599, 816 EncryptionLevel: protocol.EncryptionInitial, 817 Frames: []Frame{{Frame: &wire.PingFrame{}}}, 818 SendTime: time.Now(), 819 }) 820 Expect(handler.SendMode()).To(Equal(SendAny)) 821 handler.SentPacket(&Packet{ 822 PacketNumber: 2, 823 Length: 1, 824 EncryptionLevel: protocol.EncryptionInitial, 825 Frames: []Frame{{Frame: &wire.PingFrame{}}}, 826 SendTime: time.Now(), 827 }) 828 Expect(handler.SendMode()).To(Equal(SendNone)) 829 }) 830 831 It("cancels the loss detection timer when it is amplification limited, and resets it when becoming unblocked", func() { 832 handler.ReceivedBytes(300) 833 handler.SentPacket(&Packet{ 834 PacketNumber: 1, 835 Length: 900, 836 EncryptionLevel: protocol.EncryptionInitial, 837 Frames: []Frame{{Frame: &wire.PingFrame{}}}, 838 SendTime: time.Now(), 839 }) 840 // Amplification limited. We don't need to set a timer now. 841 Expect(handler.GetLossDetectionTimeout()).To(BeZero()) 842 // Unblock the server. Now we should fire up the timer. 843 handler.ReceivedBytes(1) 844 Expect(handler.GetLossDetectionTimeout()).ToNot(BeZero()) 845 }) 846 847 It("resets the loss detection timer when the client's address is validated", func() { 848 handler.ReceivedBytes(300) 849 handler.SentPacket(&Packet{ 850 PacketNumber: 1, 851 Length: 900, 852 EncryptionLevel: protocol.EncryptionHandshake, 853 Frames: []Frame{{Frame: &wire.PingFrame{}}}, 854 SendTime: time.Now(), 855 }) 856 // Amplification limited. We don't need to set a timer now. 857 Expect(handler.GetLossDetectionTimeout()).To(BeZero()) 858 handler.ReceivedPacket(protocol.EncryptionHandshake) 859 Expect(handler.GetLossDetectionTimeout()).ToNot(BeZero()) 860 }) 861 }) 862 863 Context("amplification limit, for the client", func() { 864 BeforeEach(func() { 865 perspective = protocol.PerspectiveClient 866 }) 867 868 It("sends an Initial packet to unblock the server", func() { 869 handler.SentPacket(initialPacket(&Packet{PacketNumber: 1})) 870 Expect(handler.ReceivedAck( 871 &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}}, 872 protocol.EncryptionInitial, 873 time.Now(), 874 )).To(Succeed()) 875 // No packets are outstanding at this point. 876 // Make sure that a probe packet is sent. 877 Expect(handler.GetLossDetectionTimeout()).ToNot(BeZero()) 878 Expect(handler.OnLossDetectionTimeout()).To(Succeed()) 879 Expect(handler.SendMode()).To(Equal(SendPTOInitial)) 880 881 // send a single packet to unblock the server 882 handler.SentPacket(initialPacket(&Packet{PacketNumber: 2})) 883 Expect(handler.SendMode()).To(Equal(SendAny)) 884 885 // Now receive an ACK for a Handshake packet. 886 // This tells the client that the server completed address validation. 887 handler.SentPacket(handshakePacket(&Packet{PacketNumber: 1})) 888 Expect(handler.ReceivedAck( 889 &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}}, 890 protocol.EncryptionHandshake, 891 time.Now(), 892 )).To(Succeed()) 893 // Make sure that no timer is set at this point. 894 Expect(handler.GetLossDetectionTimeout()).To(BeZero()) 895 }) 896 897 It("sends a Handshake packet to unblock the server, if Initial keys were already dropped", func() { 898 handler.SentPacket(initialPacket(&Packet{PacketNumber: 1})) 899 Expect(handler.ReceivedAck( 900 &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}}, 901 protocol.EncryptionInitial, 902 time.Now(), 903 )).To(Succeed()) 904 905 handler.SentPacket(handshakePacketNonAckEliciting(&Packet{PacketNumber: 1})) // also drops Initial packets 906 Expect(handler.GetLossDetectionTimeout()).ToNot(BeZero()) 907 Expect(handler.OnLossDetectionTimeout()).To(Succeed()) 908 Expect(handler.SendMode()).To(Equal(SendPTOHandshake)) 909 910 // Now receive an ACK for this packet, and send another one. 911 Expect(handler.ReceivedAck( 912 &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}}, 913 protocol.EncryptionHandshake, 914 time.Now(), 915 )).To(Succeed()) 916 handler.SentPacket(handshakePacketNonAckEliciting(&Packet{PacketNumber: 2})) 917 Expect(handler.GetLossDetectionTimeout()).To(BeZero()) 918 }) 919 920 It("doesn't send a packet to unblock the server after handshake confirmation, even if no Handshake ACK was received", func() { 921 handler.SentPacket(handshakePacket(&Packet{PacketNumber: 1})) 922 Expect(handler.GetLossDetectionTimeout()).ToNot(BeZero()) 923 Expect(handler.OnLossDetectionTimeout()).To(Succeed()) 924 Expect(handler.SendMode()).To(Equal(SendPTOHandshake)) 925 // confirm the handshake 926 handler.DropPackets(protocol.EncryptionHandshake) 927 Expect(handler.GetLossDetectionTimeout()).To(BeZero()) 928 }) 929 930 It("correctly sets the timer after the Initial packet number space has been dropped", func() { 931 handler.SentPacket(initialPacket(&Packet{PacketNumber: 1, SendTime: time.Now().Add(-42 * time.Second)})) 932 Expect(handler.ReceivedAck( 933 &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}}, 934 protocol.EncryptionInitial, 935 time.Now(), 936 )).To(Succeed()) 937 handler.SentPacket(handshakePacketNonAckEliciting(&Packet{PacketNumber: 1, SendTime: time.Now()})) 938 Expect(handler.initialPackets).To(BeNil()) 939 940 pto := handler.rttStats.PTO(false) 941 Expect(pto).ToNot(BeZero()) 942 Expect(handler.GetLossDetectionTimeout()).To(BeTemporally("~", time.Now().Add(pto), 10*time.Millisecond)) 943 }) 944 945 It("doesn't reset the PTO count when receiving an ACK", func() { 946 now := time.Now() 947 handler.SentPacket(initialPacket(&Packet{PacketNumber: 1, SendTime: now.Add(-time.Minute)})) 948 handler.SentPacket(initialPacket(&Packet{PacketNumber: 2, SendTime: now.Add(-time.Minute)})) 949 Expect(handler.GetLossDetectionTimeout()).To(BeTemporally("~", now.Add(-time.Minute), time.Second)) 950 Expect(handler.OnLossDetectionTimeout()).To(Succeed()) 951 Expect(handler.SendMode()).To(Equal(SendPTOInitial)) 952 Expect(handler.ptoCount).To(BeEquivalentTo(1)) 953 Expect(handler.ReceivedAck(&wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}}, protocol.EncryptionInitial, time.Now())).To(Succeed()) 954 Expect(handler.ptoCount).To(BeEquivalentTo(1)) 955 }) 956 }) 957 958 Context("Packet-based loss detection", func() { 959 It("declares packet below the packet loss threshold as lost", func() { 960 now := time.Now() 961 for i := protocol.PacketNumber(1); i <= 6; i++ { 962 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: i})) 963 } 964 ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 6, Largest: 6}}} 965 Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, now)).To(Succeed()) 966 expectInPacketHistory([]protocol.PacketNumber{4, 5}, protocol.Encryption1RTT) 967 Expect(lostPackets).To(Equal([]protocol.PacketNumber{1, 2, 3})) 968 }) 969 }) 970 971 Context("Delay-based loss detection", func() { 972 It("immediately detects old packets as lost when receiving an ACK", func() { 973 now := time.Now() 974 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 1, SendTime: now.Add(-time.Hour)})) 975 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 2, SendTime: now.Add(-time.Second)})) 976 Expect(handler.appDataPackets.lossTime.IsZero()).To(BeTrue()) 977 978 ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 2, Largest: 2}}} 979 Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, now)).To(Succeed()) 980 // no need to set an alarm, since packet 1 was already declared lost 981 Expect(handler.appDataPackets.lossTime.IsZero()).To(BeTrue()) 982 Expect(handler.bytesInFlight).To(BeZero()) 983 }) 984 985 It("sets the early retransmit alarm", func() { 986 handler.ReceivedPacket(protocol.EncryptionHandshake) 987 handler.handshakeConfirmed = true 988 now := time.Now() 989 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 1, SendTime: now.Add(-2 * time.Second)})) 990 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 2, SendTime: now.Add(-2 * time.Second)})) 991 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: 3, SendTime: now})) 992 Expect(handler.appDataPackets.lossTime.IsZero()).To(BeTrue()) 993 994 ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 2, Largest: 2}}} 995 Expect(handler.ReceivedAck(ack, protocol.Encryption1RTT, now.Add(-time.Second))).To(Succeed()) 996 Expect(handler.rttStats.SmoothedRTT()).To(Equal(time.Second)) 997 998 // Packet 1 should be considered lost (1+1/8) RTTs after it was sent. 999 Expect(handler.GetLossDetectionTimeout().Sub(getPacket(1, protocol.Encryption1RTT).SendTime)).To(Equal(time.Second * 9 / 8)) 1000 Expect(handler.SendMode()).To(Equal(SendAny)) 1001 1002 expectInPacketHistory([]protocol.PacketNumber{1, 3}, protocol.Encryption1RTT) 1003 Expect(handler.OnLossDetectionTimeout()).To(Succeed()) 1004 expectInPacketHistory([]protocol.PacketNumber{3}, protocol.Encryption1RTT) 1005 Expect(handler.SendMode()).To(Equal(SendAny)) 1006 }) 1007 1008 It("sets the early retransmit alarm for crypto packets", func() { 1009 handler.ReceivedBytes(1000) 1010 now := time.Now() 1011 handler.SentPacket(initialPacket(&Packet{PacketNumber: 1, SendTime: now.Add(-2 * time.Second)})) 1012 handler.SentPacket(initialPacket(&Packet{PacketNumber: 2, SendTime: now.Add(-2 * time.Second)})) 1013 handler.SentPacket(initialPacket(&Packet{PacketNumber: 3, SendTime: now})) 1014 Expect(handler.initialPackets.lossTime.IsZero()).To(BeTrue()) 1015 1016 ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 2, Largest: 2}}} 1017 Expect(handler.ReceivedAck(ack, protocol.EncryptionInitial, now.Add(-time.Second))).To(Succeed()) 1018 Expect(handler.rttStats.SmoothedRTT()).To(Equal(time.Second)) 1019 1020 // Packet 1 should be considered lost (1+1/8) RTTs after it was sent. 1021 Expect(handler.GetLossDetectionTimeout().Sub(getPacket(1, protocol.EncryptionInitial).SendTime)).To(Equal(time.Second * 9 / 8)) 1022 Expect(handler.SendMode()).To(Equal(SendAny)) 1023 1024 expectInPacketHistory([]protocol.PacketNumber{1, 3}, protocol.EncryptionInitial) 1025 Expect(handler.OnLossDetectionTimeout()).To(Succeed()) 1026 expectInPacketHistory([]protocol.PacketNumber{3}, protocol.EncryptionInitial) 1027 Expect(handler.SendMode()).To(Equal(SendAny)) 1028 }) 1029 }) 1030 1031 Context("crypto packets", func() { 1032 It("rejects an ACK that acks packets with a higher encryption level", func() { 1033 handler.SentPacket(ackElicitingPacket(&Packet{ 1034 PacketNumber: 13, 1035 EncryptionLevel: protocol.Encryption1RTT, 1036 })) 1037 ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 13, Largest: 13}}} 1038 Expect(handler.ReceivedAck(ack, protocol.EncryptionHandshake, time.Now())).To(MatchError("PROTOCOL_VIOLATION: Received ACK for an unsent packet")) 1039 }) 1040 1041 It("deletes Initial packets, as a server", func() { 1042 for i := protocol.PacketNumber(0); i < 6; i++ { 1043 handler.SentPacket(ackElicitingPacket(&Packet{ 1044 PacketNumber: i, 1045 EncryptionLevel: protocol.EncryptionInitial, 1046 })) 1047 } 1048 for i := protocol.PacketNumber(0); i < 10; i++ { 1049 handler.SentPacket(ackElicitingPacket(&Packet{ 1050 PacketNumber: i, 1051 EncryptionLevel: protocol.EncryptionHandshake, 1052 })) 1053 } 1054 Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(16))) 1055 handler.DropPackets(protocol.EncryptionInitial) 1056 Expect(lostPackets).To(BeEmpty()) // frames must not be queued for retransmission 1057 Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(10))) 1058 Expect(handler.initialPackets).To(BeNil()) 1059 Expect(handler.handshakePackets.history.Len()).ToNot(BeZero()) 1060 }) 1061 1062 Context("deleting Initials", func() { 1063 BeforeEach(func() { perspective = protocol.PerspectiveClient }) 1064 1065 It("deletes Initials, as a client", func() { 1066 for i := protocol.PacketNumber(0); i < 6; i++ { 1067 handler.SentPacket(ackElicitingPacket(&Packet{ 1068 PacketNumber: i, 1069 EncryptionLevel: protocol.EncryptionInitial, 1070 })) 1071 } 1072 Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(6))) 1073 handler.DropPackets(protocol.EncryptionInitial) 1074 // DropPackets should be ignored for clients and the Initial packet number space. 1075 // It has to be possible to send another Initial packets after this function was called. 1076 handler.SentPacket(ackElicitingPacket(&Packet{ 1077 PacketNumber: 10, 1078 EncryptionLevel: protocol.EncryptionInitial, 1079 })) 1080 Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(7))) 1081 // Sending a Handshake packet triggers dropping of Initials. 1082 handler.SentPacket(ackElicitingPacket(&Packet{ 1083 PacketNumber: 1, 1084 EncryptionLevel: protocol.EncryptionHandshake, 1085 })) 1086 Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(1))) 1087 Expect(lostPackets).To(BeEmpty()) // frames must not be queued for retransmission 1088 Expect(handler.initialPackets).To(BeNil()) 1089 Expect(handler.handshakePackets.history.Len()).ToNot(BeZero()) 1090 }) 1091 }) 1092 1093 It("deletes Handshake packets", func() { 1094 for i := protocol.PacketNumber(0); i < 6; i++ { 1095 handler.SentPacket(ackElicitingPacket(&Packet{ 1096 PacketNumber: i, 1097 EncryptionLevel: protocol.EncryptionHandshake, 1098 })) 1099 } 1100 for i := protocol.PacketNumber(0); i < 10; i++ { 1101 handler.SentPacket(ackElicitingPacket(&Packet{ 1102 PacketNumber: i, 1103 EncryptionLevel: protocol.Encryption1RTT, 1104 })) 1105 } 1106 Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(16))) 1107 handler.DropPackets(protocol.EncryptionHandshake) 1108 Expect(lostPackets).To(BeEmpty()) // frames must not be queued for retransmission 1109 Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(10))) 1110 Expect(handler.handshakePackets).To(BeNil()) 1111 }) 1112 1113 It("doesn't retransmit 0-RTT packets when 0-RTT keys are dropped", func() { 1114 for i := protocol.PacketNumber(0); i < 6; i++ { 1115 if i == 3 { 1116 continue 1117 } 1118 handler.SentPacket(ackElicitingPacket(&Packet{ 1119 PacketNumber: i, 1120 EncryptionLevel: protocol.Encryption0RTT, 1121 })) 1122 } 1123 for i := protocol.PacketNumber(6); i < 12; i++ { 1124 handler.SentPacket(ackElicitingPacket(&Packet{PacketNumber: i})) 1125 } 1126 Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(11))) 1127 handler.DropPackets(protocol.Encryption0RTT) 1128 Expect(lostPackets).To(BeEmpty()) 1129 Expect(handler.bytesInFlight).To(Equal(protocol.ByteCount(6))) 1130 }) 1131 1132 It("cancels the PTO when dropping a packet number space", func() { 1133 handler.ReceivedPacket(protocol.EncryptionHandshake) 1134 now := time.Now() 1135 handler.SentPacket(handshakePacket(&Packet{PacketNumber: 1, SendTime: now.Add(-time.Minute)})) 1136 handler.SentPacket(handshakePacket(&Packet{PacketNumber: 2, SendTime: now.Add(-time.Minute)})) 1137 Expect(handler.GetLossDetectionTimeout()).To(BeTemporally("~", now.Add(-time.Minute), time.Second)) 1138 Expect(handler.OnLossDetectionTimeout()).To(Succeed()) 1139 Expect(handler.SendMode()).To(Equal(SendPTOHandshake)) 1140 Expect(handler.ptoCount).To(BeEquivalentTo(1)) 1141 handler.DropPackets(protocol.EncryptionHandshake) 1142 Expect(handler.ptoCount).To(BeZero()) 1143 Expect(handler.SendMode()).To(Equal(SendAny)) 1144 }) 1145 }) 1146 1147 Context("peeking and popping packet number", func() { 1148 It("peeks and pops the initial packet number", func() { 1149 pn, _ := handler.PeekPacketNumber(protocol.EncryptionInitial) 1150 Expect(pn).To(Equal(protocol.PacketNumber(42))) 1151 Expect(handler.PopPacketNumber(protocol.EncryptionInitial)).To(Equal(protocol.PacketNumber(42))) 1152 }) 1153 1154 It("peeks and pops beyond the initial packet number", func() { 1155 Expect(handler.PopPacketNumber(protocol.EncryptionInitial)).To(Equal(protocol.PacketNumber(42))) 1156 Expect(handler.PopPacketNumber(protocol.EncryptionInitial)).To(BeNumerically(">", 42)) 1157 }) 1158 1159 It("starts at 0 for handshake and application-data packet number space", func() { 1160 pn, _ := handler.PeekPacketNumber(protocol.EncryptionHandshake) 1161 Expect(pn).To(BeZero()) 1162 Expect(handler.PopPacketNumber(protocol.EncryptionHandshake)).To(BeZero()) 1163 pn, _ = handler.PeekPacketNumber(protocol.Encryption1RTT) 1164 Expect(pn).To(BeZero()) 1165 Expect(handler.PopPacketNumber(protocol.Encryption1RTT)).To(BeZero()) 1166 }) 1167 }) 1168 1169 Context("for the client", func() { 1170 BeforeEach(func() { 1171 perspective = protocol.PerspectiveClient 1172 }) 1173 1174 It("considers the server's address validated right away", func() { 1175 }) 1176 1177 It("queues outstanding packets for retransmission, cancels alarms and resets PTO count when receiving a Retry", func() { 1178 handler.SentPacket(initialPacket(&Packet{PacketNumber: 42})) 1179 Expect(handler.GetLossDetectionTimeout()).ToNot(BeZero()) 1180 Expect(handler.bytesInFlight).ToNot(BeZero()) 1181 Expect(handler.SendMode()).To(Equal(SendAny)) 1182 // now receive a Retry 1183 Expect(handler.ResetForRetry()).To(Succeed()) 1184 Expect(lostPackets).To(Equal([]protocol.PacketNumber{42})) 1185 Expect(handler.bytesInFlight).To(BeZero()) 1186 Expect(handler.GetLossDetectionTimeout()).To(BeZero()) 1187 Expect(handler.SendMode()).To(Equal(SendAny)) 1188 Expect(handler.ptoCount).To(BeZero()) 1189 }) 1190 1191 It("queues outstanding frames for retransmission and cancels alarms when receiving a Retry", func() { 1192 var lostInitial, lost0RTT bool 1193 handler.SentPacket(&Packet{ 1194 PacketNumber: 13, 1195 EncryptionLevel: protocol.EncryptionInitial, 1196 Frames: []Frame{ 1197 {Frame: &wire.CryptoFrame{Data: []byte("foobar")}, OnLost: func(wire.Frame) { lostInitial = true }}, 1198 }, 1199 Length: 100, 1200 }) 1201 pn := handler.PopPacketNumber(protocol.Encryption0RTT) 1202 handler.SentPacket(&Packet{ 1203 PacketNumber: pn, 1204 EncryptionLevel: protocol.Encryption0RTT, 1205 Frames: []Frame{ 1206 {Frame: &wire.StreamFrame{Data: []byte("foobar")}, OnLost: func(wire.Frame) { lost0RTT = true }}, 1207 }, 1208 Length: 999, 1209 }) 1210 Expect(handler.bytesInFlight).ToNot(BeZero()) 1211 // now receive a Retry 1212 Expect(handler.ResetForRetry()).To(Succeed()) 1213 Expect(handler.bytesInFlight).To(BeZero()) 1214 Expect(lostInitial).To(BeTrue()) 1215 Expect(lost0RTT).To(BeTrue()) 1216 1217 // make sure we keep increasing the packet number for 0-RTT packets 1218 Expect(handler.PopPacketNumber(protocol.Encryption0RTT)).To(BeNumerically(">", pn)) 1219 }) 1220 1221 It("uses a Retry for an RTT estimate, if it was not retransmitted", func() { 1222 handler.SentPacket(ackElicitingPacket(&Packet{ 1223 PacketNumber: 42, 1224 EncryptionLevel: protocol.EncryptionInitial, 1225 SendTime: time.Now().Add(-500 * time.Millisecond), 1226 })) 1227 handler.SentPacket(ackElicitingPacket(&Packet{ 1228 PacketNumber: 43, 1229 EncryptionLevel: protocol.EncryptionInitial, 1230 SendTime: time.Now().Add(-10 * time.Millisecond), 1231 })) 1232 Expect(handler.ResetForRetry()).To(Succeed()) 1233 Expect(handler.rttStats.SmoothedRTT()).To(BeNumerically("~", 500*time.Millisecond, 100*time.Millisecond)) 1234 }) 1235 1236 It("uses a Retry for an RTT estimate, but doesn't set the RTT to a value lower than 5ms", func() { 1237 handler.SentPacket(ackElicitingPacket(&Packet{ 1238 PacketNumber: 42, 1239 EncryptionLevel: protocol.EncryptionInitial, 1240 SendTime: time.Now().Add(-500 * time.Microsecond), 1241 })) 1242 handler.SentPacket(ackElicitingPacket(&Packet{ 1243 PacketNumber: 43, 1244 EncryptionLevel: protocol.EncryptionInitial, 1245 SendTime: time.Now().Add(-10 * time.Microsecond), 1246 })) 1247 Expect(handler.ResetForRetry()).To(Succeed()) 1248 Expect(handler.rttStats.SmoothedRTT()).To(Equal(minRTTAfterRetry)) 1249 }) 1250 1251 It("doesn't use a Retry for an RTT estimate, if it was not retransmitted", func() { 1252 handler.SentPacket(ackElicitingPacket(&Packet{ 1253 PacketNumber: 42, 1254 EncryptionLevel: protocol.EncryptionInitial, 1255 SendTime: time.Now().Add(-800 * time.Millisecond), 1256 })) 1257 Expect(handler.OnLossDetectionTimeout()).To(Succeed()) 1258 Expect(handler.SendMode()).To(Equal(SendPTOInitial)) 1259 handler.SentPacket(ackElicitingPacket(&Packet{ 1260 PacketNumber: 43, 1261 EncryptionLevel: protocol.EncryptionInitial, 1262 SendTime: time.Now().Add(-100 * time.Millisecond), 1263 })) 1264 Expect(handler.ResetForRetry()).To(Succeed()) 1265 Expect(handler.rttStats.SmoothedRTT()).To(BeZero()) 1266 }) 1267 }) 1268}) 1269