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

move the packet number generator to the ackhandler package

Browse source
This commit is contained in:
Marten Seemann 2018-11-01 16:51:12 +07:00
parent 16848038be
commit ebbf839fa4
8 changed files with 184 additions and 83 deletions
Download patch file Download diff file Expand all files Collapse all files

3
internal/ackhandler/interfaces.go
View file

@ -30,6 +30,9 @@ type SentPacketHandler interface {
GetLowestPacketNotConfirmedAcked() protocol.PacketNumber
DequeuePacketForRetransmission() *Packet
DequeueProbePacket() (*Packet, error)
PeekPacketNumber() protocol.PacketNumber
PopPacketNumber() protocol.PacketNumber
GetPacketNumberLen(protocol.PacketNumber) protocol.PacketNumberLen
GetAlarmTimeout() time.Time

2
packet_number_generator.go → internal/ackhandler/packet_number_generator.go
View file

@ -1,4 +1,4 @@
package quic
package ackhandler
import (
"crypto/rand"

2
packet_number_generator_test.go → internal/ackhandler/packet_number_generator_test.go
View file

@ -1,4 +1,4 @@
package quic
package ackhandler
import (
"math"

23
internal/ackhandler/sent_packet_handler.go
View file

@ -30,7 +30,9 @@ const (
)
type sentPacketHandler struct {
lastSentPacketNumber protocol.PacketNumber
lastSentPacketNumber protocol.PacketNumber
packetNumberGenerator *packetNumberGenerator
lastSentRetransmittablePacketTime time.Time
lastSentHandshakePacketTime time.Time
@ -89,11 +91,12 @@ func NewSentPacketHandler(rttStats *congestion.RTTStats, logger utils.Logger, ve
)
return &sentPacketHandler{
packetHistory: newSentPacketHistory(),
rttStats: rttStats,
congestion: congestion,
logger: logger,
version: version,
packetNumberGenerator: newPacketNumberGenerator(1, protocol.SkipPacketAveragePeriodLength),
packetHistory: newSentPacketHistory(),
rttStats: rttStats,
congestion: congestion,
logger: logger,
version: version,
}
}
@ -518,6 +521,14 @@ func (h *sentPacketHandler) DequeueProbePacket() (*Packet, error) {
return h.DequeuePacketForRetransmission(), nil
}
func (h *sentPacketHandler) PeekPacketNumber() protocol.PacketNumber {
return h.packetNumberGenerator.Peek()
}
func (h *sentPacketHandler) PopPacketNumber() protocol.PacketNumber {
return h.packetNumberGenerator.Pop()
}
func (h *sentPacketHandler) GetPacketNumberLen(p protocol.PacketNumber) protocol.PacketNumberLen {
return protocol.GetPacketNumberLengthForHeader(p, h.lowestUnacked(), h.version)
}

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

@ -110,6 +110,30 @@ func (mr *MockSentPacketHandlerMockRecorder) OnAlarm() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnAlarm", reflect.TypeOf((*MockSentPacketHandler)(nil).OnAlarm))
}
// PeekPacketNumber mocks base method
func (m *MockSentPacketHandler) PeekPacketNumber() protocol.PacketNumber {
ret := m.ctrl.Call(m, "PeekPacketNumber")
ret0, _ := ret[0].(protocol.PacketNumber)
return ret0
}
// PeekPacketNumber indicates an expected call of PeekPacketNumber
func (mr *MockSentPacketHandlerMockRecorder) PeekPacketNumber() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PeekPacketNumber", reflect.TypeOf((*MockSentPacketHandler)(nil).PeekPacketNumber))
}
// PopPacketNumber mocks base method
func (m *MockSentPacketHandler) PopPacketNumber() protocol.PacketNumber {
ret := m.ctrl.Call(m, "PopPacketNumber")
ret0, _ := ret[0].(protocol.PacketNumber)
return ret0
}
// PopPacketNumber indicates an expected call of PopPacketNumber
func (mr *MockSentPacketHandlerMockRecorder) PopPacketNumber() *gomock.Call {
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PopPacketNumber", reflect.TypeOf((*MockSentPacketHandler)(nil).PopPacketNumber))
}
// ReceivedAck mocks base method
func (m *MockSentPacketHandler) ReceivedAck(arg0 *wire.AckFrame, arg1 protocol.PacketNumber, arg2 protocol.EncryptionLevel, arg3 time.Time) error {
ret := m.ctrl.Call(m, "ReceivedAck", arg0, arg1, arg2, arg3)

46
packet_packer.go
View file

@ -59,6 +59,12 @@ func getMaxPacketSize(addr net.Addr) protocol.ByteCount {
return maxSize
}
type packetNumberManager interface {
PeekPacketNumber() protocol.PacketNumber
PopPacketNumber() protocol.PacketNumber
GetPacketNumberLen(protocol.PacketNumber) protocol.PacketNumberLen
}
type sealingManager interface {
GetSealer() (protocol.EncryptionLevel, handshake.Sealer)
GetSealerWithEncryptionLevel(protocol.EncryptionLevel) (handshake.Sealer, error)
@ -86,10 +92,9 @@ type packetPacker struct {
token []byte
packetNumberGenerator *packetNumberGenerator
getPacketNumberLen func(protocol.PacketNumber) protocol.PacketNumberLen
framer frameSource
acks ackFrameSource
pnManager packetNumberManager
framer frameSource
acks ackFrameSource
maxPacketSize protocol.ByteCount
hasSentPacket bool // has the packetPacker already sent a packet
@ -103,7 +108,7 @@ func newPacketPacker(
srcConnID protocol.ConnectionID,
initialStream cryptoStream,
handshakeStream cryptoStream,
getPacketNumberLen func(protocol.PacketNumber) protocol.PacketNumberLen,
packetNumberManager packetNumberManager,
remoteAddr net.Addr, // only used for determining the max packet size
token []byte,
cryptoSetup sealingManager,
@ -113,19 +118,18 @@ func newPacketPacker(
version protocol.VersionNumber,
) *packetPacker {
return &packetPacker{
cryptoSetup: cryptoSetup,
token: token,
destConnID: destConnID,
srcConnID: srcConnID,
initialStream: initialStream,
handshakeStream: handshakeStream,
perspective: perspective,
version: version,
framer: framer,
acks: acks,
getPacketNumberLen: getPacketNumberLen,
packetNumberGenerator: newPacketNumberGenerator(1, protocol.SkipPacketAveragePeriodLength),
maxPacketSize: getMaxPacketSize(remoteAddr),
cryptoSetup: cryptoSetup,
token: token,
destConnID: destConnID,
srcConnID: srcConnID,
initialStream: initialStream,
handshakeStream: handshakeStream,
perspective: perspective,
version: version,
framer: framer,
acks: acks,
pnManager: packetNumberManager,
maxPacketSize: getMaxPacketSize(remoteAddr),
}
}
@ -395,8 +399,8 @@ func (p *packetPacker) composeNextPacket(
}
func (p *packetPacker) getHeader(encLevel protocol.EncryptionLevel) *wire.Header {
pnum := p.packetNumberGenerator.Peek()
packetNumberLen := p.getPacketNumberLen(pnum)
pnum := p.pnManager.PeekPacketNumber()
packetNumberLen := p.pnManager.GetPacketNumberLen(pnum)
header := &wire.Header{
PacketNumber: pnum,
@ -481,7 +485,7 @@ func (p *packetPacker) writeAndSealPacket(
_ = sealer.Seal(raw[payloadStartIndex:payloadStartIndex], raw[payloadStartIndex:], header.PacketNumber, raw[:payloadStartIndex])
raw = raw[0 : buffer.Len()+sealer.Overhead()]
num := p.packetNumberGenerator.Pop()
num := p.pnManager.PopPacketNumber()
if num != header.PacketNumber {
return nil, errors.New("packetPacker BUG: Peeked and Popped packet numbers do not match")
}

163
packet_packer_test.go
View file

@ -9,6 +9,7 @@ import (
"github.com/lucas-clemente/quic-go/internal/ackhandler"
"github.com/lucas-clemente/quic-go/internal/handshake"
"github.com/lucas-clemente/quic-go/internal/mocks"
"github.com/lucas-clemente/quic-go/internal/mocks/ackhandler"
"github.com/lucas-clemente/quic-go/internal/protocol"
"github.com/lucas-clemente/quic-go/internal/wire"
. "github.com/onsi/ginkgo"
@ -25,6 +26,7 @@ var _ = Describe("Packet packer", func() {
handshakeStream *MockCryptoStream
sealingManager *MockSealingManager
sealer *mocks.MockSealer
pnManager *mockackhandler.MockSentPacketHandler
token []byte
)
@ -63,6 +65,7 @@ var _ = Describe("Packet packer", func() {
framer = NewMockFrameSource(mockCtrl)
ackFramer = NewMockAckFrameSource(mockCtrl)
sealingManager = NewMockSealingManager(mockCtrl)
pnManager = mockackhandler.NewMockSentPacketHandler(mockCtrl)
sealer = mocks.NewMockSealer(mockCtrl)
sealer.EXPECT().Overhead().Return(7).AnyTimes()
sealer.EXPECT().Seal(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn(func(dst, src []byte, pn protocol.PacketNumber, associatedData []byte) []byte {
@ -76,7 +79,7 @@ var _ = Describe("Packet packer", func() {
protocol.ConnectionID{1, 2, 3, 4, 5, 6, 7, 8},
initialStream,
handshakeStream,
func(protocol.PacketNumber) protocol.PacketNumberLen { return protocol.PacketNumberLen2 },
pnManager,
&net.TCPAddr{},
token, // token
sealingManager,
@ -109,12 +112,18 @@ var _ = Describe("Packet packer", func() {
Context("generating a packet header", func() {
It("uses the Long Header format", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42))
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2)
h := packer.getHeader(protocol.EncryptionHandshake)
Expect(h.IsLongHeader).To(BeTrue())
Expect(h.PacketNumber).To(Equal(protocol.PacketNumber(0x42)))
Expect(h.PacketNumberLen).To(Equal(protocol.PacketNumberLen2))
Expect(h.Version).To(Equal(packer.version))
})
It("sets source and destination connection ID", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42))
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2)
srcConnID := protocol.ConnectionID{1, 2, 3, 4, 5, 6, 7, 8}
destConnID := protocol.ConnectionID{8, 7, 6, 5, 4, 3, 2, 1}
packer.srcConnID = srcConnID
@ -125,6 +134,8 @@ var _ = Describe("Packet packer", func() {
})
It("changes the destination connection ID", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42)).Times(2)
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2).Times(2)
srcConnID := protocol.ConnectionID{1, 1, 1, 1, 1, 1, 1, 1}
packer.srcConnID = srcConnID
dest1 := protocol.ConnectionID{1, 2, 3, 4, 5, 6, 7, 8}
@ -140,9 +151,12 @@ var _ = Describe("Packet packer", func() {
})
It("uses the Short Header format for 1-RTT packets", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x1337))
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen4)
h := packer.getHeader(protocol.Encryption1RTT)
Expect(h.IsLongHeader).To(BeFalse())
Expect(h.PacketNumberLen).To(BeNumerically(">", 0))
Expect(h.PacketNumber).To(Equal(protocol.PacketNumber(0x1337)))
Expect(h.PacketNumberLen).To(Equal(protocol.PacketNumberLen4))
})
})
@ -153,6 +167,9 @@ var _ = Describe("Packet packer", func() {
})
It("returns nil when no packet is queued", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42))
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2)
// don't expect any calls to PopPacketNumber
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
ackFramer.EXPECT().GetAckFrame()
framer.EXPECT().AppendControlFrames(nil, gomock.Any())
@ -163,6 +180,9 @@ var _ = Describe("Packet packer", func() {
})
It("packs single packets", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42))
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
ackFramer.EXPECT().GetAckFrame()
expectAppendControlFrames()
@ -181,6 +201,9 @@ var _ = Describe("Packet packer", func() {
})
It("stores the encryption level a packet was sealed with", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42))
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
ackFramer.EXPECT().GetAckFrame()
expectAppendControlFrames()
@ -194,6 +217,9 @@ var _ = Describe("Packet packer", func() {
})
It("packs a single ACK", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42))
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42))
ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Largest: 42, Smallest: 1}}}
ackFramer.EXPECT().GetAckFrame().Return(ack)
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
@ -206,6 +232,10 @@ var _ = Describe("Packet packer", func() {
})
It("packs a CONNECTION_CLOSE", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42))
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42))
// expect no framer.PopStreamFrames
ccf := wire.ConnectionCloseFrame{
ErrorCode: 0x1337,
ReasonPhrase: "foobar",
@ -217,19 +247,10 @@ var _ = Describe("Packet packer", func() {
Expect(p.frames[0]).To(Equal(&ccf))
})
It("doesn't send any other frames when sending a CONNECTION_CLOSE", func() {
// expect no framer.PopStreamFrames
ccf := &wire.ConnectionCloseFrame{
ErrorCode: 0x1337,
ReasonPhrase: "foobar",
}
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
p, err := packer.PackConnectionClose(ccf)
Expect(err).ToNot(HaveOccurred())
Expect(p.frames).To(Equal([]wire.Frame{ccf}))
})
It("packs control frames", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42))
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
ackFramer.EXPECT().GetAckFrame()
frames := []wire.Frame{&wire.RstStreamFrame{}, &wire.MaxDataFrame{}}
@ -242,23 +263,9 @@ var _ = Describe("Packet packer", func() {
Expect(p.raw).NotTo(BeEmpty())
})
It("increases the packet number", func() {
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer).Times(2)
ackFramer.EXPECT().GetAckFrame().Times(2)
expectAppendControlFrames()
expectAppendStreamFrames(&wire.StreamFrame{Data: []byte("foobar")})
expectAppendControlFrames()
expectAppendStreamFrames(&wire.StreamFrame{Data: []byte("raboof")})
p1, err := packer.PackPacket()
Expect(err).ToNot(HaveOccurred())
Expect(p1).ToNot(BeNil())
p2, err := packer.PackPacket()
Expect(err).ToNot(HaveOccurred())
Expect(p2).ToNot(BeNil())
Expect(p2.header.PacketNumber).To(BeNumerically(">", p1.header.PacketNumber))
})
It("accounts for the space consumed by control frames", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42))
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2)
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
ackFramer.EXPECT().GetAckFrame()
var maxSize protocol.ByteCount
@ -276,25 +283,6 @@ var _ = Describe("Packet packer", func() {
Expect(err).ToNot(HaveOccurred())
})
It("only increases the packet number when there is an actual packet to send", func() {
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer).Times(2)
ackFramer.EXPECT().GetAckFrame().Times(2)
expectAppendStreamFrames()
expectAppendControlFrames()
packer.packetNumberGenerator.nextToSkip = 1000
p, err := packer.PackPacket()
Expect(p).To(BeNil())
Expect(err).ToNot(HaveOccurred())
Expect(packer.packetNumberGenerator.Peek()).To(Equal(protocol.PacketNumber(1)))
expectAppendControlFrames()
expectAppendStreamFrames(&wire.StreamFrame{Data: []byte("foobar")})
p, err = packer.PackPacket()
Expect(err).ToNot(HaveOccurred())
Expect(p).ToNot(BeNil())
Expect(p.header.PacketNumber).To(Equal(protocol.PacketNumber(1)))
Expect(packer.packetNumberGenerator.Peek()).To(Equal(protocol.PacketNumber(2)))
})
Context("packing ACK packets", func() {
It("doesn't pack a packet if there's no ACK to send", func() {
ackFramer.EXPECT().GetAckFrame()
@ -304,6 +292,9 @@ var _ = Describe("Packet packer", func() {
})
It("packs ACK packets", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42))
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 10}}}
ackFramer.EXPECT().GetAckFrame().Return(ack)
@ -316,6 +307,9 @@ var _ = Describe("Packet packer", func() {
Context("making ACK packets retransmittable", func() {
sendMaxNumNonRetransmittableAcks := func() {
for i := 0; i < protocol.MaxNonRetransmittableAcks; i++ {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42))
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
ackFramer.EXPECT().GetAckFrame().Return(&wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}})
expectAppendControlFrames()
@ -329,6 +323,9 @@ var _ = Describe("Packet packer", func() {
It("adds a PING frame when it's supposed to send a retransmittable packet", func() {
sendMaxNumNonRetransmittableAcks()
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42))
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
ackFramer.EXPECT().GetAckFrame().Return(&wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}})
expectAppendControlFrames()
@ -338,6 +335,9 @@ var _ = Describe("Packet packer", func() {
Expect(err).ToNot(HaveOccurred())
Expect(p.frames).To(ContainElement(&wire.PingFrame{}))
// make sure the next packet doesn't contain another PING
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42))
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
ackFramer.EXPECT().GetAckFrame().Return(&wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}})
expectAppendControlFrames()
@ -351,6 +351,8 @@ var _ = Describe("Packet packer", func() {
It("waits until there's something to send before adding a PING frame", func() {
sendMaxNumNonRetransmittableAcks()
// nothing to send
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42))
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2)
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
expectAppendControlFrames()
expectAppendStreamFrames()
@ -361,6 +363,9 @@ var _ = Describe("Packet packer", func() {
// now add some frame to send
expectAppendControlFrames()
expectAppendStreamFrames()
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42))
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
ackFramer.EXPECT().GetAckFrame().Return(&wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 1, Largest: 1}}})
p, err = packer.PackPacket()
@ -371,19 +376,25 @@ var _ = Describe("Packet packer", func() {
It("doesn't send a PING if it already sent another retransmittable frame", func() {
sendMaxNumNonRetransmittableAcks()
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42))
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
ackFramer.EXPECT().GetAckFrame()
expectAppendStreamFrames()
expectAppendControlFrames(&wire.MaxDataFrame{})
p, err := packer.PackPacket()
Expect(p).ToNot(BeNil())
Expect(err).ToNot(HaveOccurred())
Expect(p).ToNot(BeNil())
Expect(p.frames).ToNot(ContainElement(&wire.PingFrame{}))
})
})
Context("STREAM frame handling", func() {
It("does not split a STREAM frame with maximum size", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42))
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42))
ackFramer.EXPECT().GetAckFrame()
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
expectAppendControlFrames()
@ -420,6 +431,9 @@ var _ = Describe("Packet packer", func() {
Data: []byte("frame 3"),
DataLenPresent: true,
}
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42))
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer)
ackFramer.EXPECT().GetAckFrame()
expectAppendControlFrames()
@ -437,6 +451,8 @@ var _ = Describe("Packet packer", func() {
})
It("doesn't send unencrypted stream data on a data stream", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42))
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2)
sealingManager.EXPECT().GetSealer().Return(protocol.EncryptionInitial, sealer)
ackFramer.EXPECT().GetAckFrame()
expectAppendControlFrames()
@ -449,7 +465,9 @@ var _ = Describe("Packet packer", func() {
Context("retransmissions", func() {
It("retransmits a small packet", func() {
packer.packetNumberGenerator.next = 10
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42))
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.Encryption1RTT).Return(sealer, nil)
frames := []wire.Frame{
&wire.MaxDataFrame{ByteOffset: 0x1234},
@ -467,6 +485,9 @@ var _ = Describe("Packet packer", func() {
})
It("packs two packets for retransmission if the original packet contained many control frames", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42)).Times(2)
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2).Times(2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)).Times(2)
sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.Encryption1RTT).Return(sealer, nil)
var frames []wire.Frame
var totalLen protocol.ByteCount
@ -479,7 +500,6 @@ var _ = Describe("Packet packer", func() {
frames = append(frames, f)
totalLen += f.Length(packer.version)
}
packer.packetNumberGenerator.next = 10
packets, err := packer.PackRetransmission(&ackhandler.Packet{
EncryptionLevel: protocol.Encryption1RTT,
Frames: frames,
@ -494,6 +514,9 @@ var _ = Describe("Packet packer", func() {
})
It("splits a STREAM frame that doesn't fit", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42)).Times(2)
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2).Times(2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)).Times(2)
sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.Encryption1RTT).Return(sealer, nil)
packets, err := packer.PackRetransmission(&ackhandler.Packet{
EncryptionLevel: protocol.Encryption1RTT,
@ -520,6 +543,9 @@ var _ = Describe("Packet packer", func() {
})
It("splits STREAM frames, if necessary", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42)).AnyTimes()
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2).AnyTimes()
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)).AnyTimes()
for i := 0; i < 100; i++ {
sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.Encryption1RTT).Return(sealer, nil).MaxTimes(2)
sf1 := &wire.StreamFrame{
@ -555,6 +581,9 @@ var _ = Describe("Packet packer", func() {
})
It("packs two packets for retransmission if the original packet contained many STREAM frames", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42)).Times(2)
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2).Times(2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42)).Times(2)
sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.Encryption1RTT).Return(sealer, nil)
var frames []wire.Frame
var totalLen protocol.ByteCount
@ -582,6 +611,9 @@ var _ = Describe("Packet packer", func() {
})
It("correctly sets the DataLenPresent on STREAM frames", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42))
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.Encryption1RTT).Return(sealer, nil)
frames := []wire.Frame{
&wire.StreamFrame{StreamID: 4, Data: []byte("foobar"), DataLenPresent: true},
@ -608,6 +640,8 @@ var _ = Describe("Packet packer", func() {
Context("max packet size", func() {
It("sets the maximum packet size", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42)).Times(2)
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2).Times(2)
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer).Times(2)
ackFramer.EXPECT().GetAckFrame().Times(2)
var initialMaxPacketSize protocol.ByteCount
@ -632,6 +666,8 @@ var _ = Describe("Packet packer", func() {
})
It("doesn't increase the max packet size", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42)).Times(2)
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2).Times(2)
sealingManager.EXPECT().GetSealer().Return(protocol.Encryption1RTT, sealer).Times(2)
ackFramer.EXPECT().GetAckFrame().Times(2)
var initialMaxPacketSize protocol.ByteCount
@ -659,6 +695,9 @@ var _ = Describe("Packet packer", func() {
Context("packing crypto packets", func() {
It("sets the payload length", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42))
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42))
f := &wire.CryptoFrame{
Offset: 0x1337,
Data: []byte("foobar"),
@ -674,6 +713,9 @@ var _ = Describe("Packet packer", func() {
It("packs a maximum size crypto packet", func() {
var f *wire.CryptoFrame
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42))
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.EncryptionHandshake).Return(sealer, nil)
ackFramer.EXPECT().GetAckFrame()
initialStream.EXPECT().HasData()
@ -695,6 +737,9 @@ var _ = Describe("Packet packer", func() {
It("pads Initial packets to the required minimum packet size", func() {
f := &wire.CryptoFrame{Data: []byte("foobar")}
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42))
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.EncryptionInitial).Return(sealer, nil)
ackFramer.EXPECT().GetAckFrame()
initialStream.EXPECT().HasData().Return(true)
@ -711,6 +756,9 @@ var _ = Describe("Packet packer", func() {
})
It("sets the correct payload length for an Initial packet", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42))
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.EncryptionInitial).Return(sealer, nil)
ackFramer.EXPECT().GetAckFrame()
initialStream.EXPECT().HasData().Return(true)
@ -727,6 +775,9 @@ var _ = Describe("Packet packer", func() {
It("adds an ACK frame", func() {
f := &wire.CryptoFrame{Data: []byte("foobar")}
ack := &wire.AckFrame{AckRanges: []wire.AckRange{{Smallest: 42, Largest: 1337}}}
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42))
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.EncryptionInitial).Return(sealer, nil)
ackFramer.EXPECT().GetAckFrame().Return(ack)
initialStream.EXPECT().HasData().Return(true)
@ -746,6 +797,9 @@ var _ = Describe("Packet packer", func() {
sf := &wire.StreamFrame{Data: []byte("foobar")}
It("packs a retransmission with the right encryption level", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42))
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.EncryptionInitial).Return(sealer, nil)
packet := &ackhandler.Packet{
PacketType: protocol.PacketTypeHandshake,
@ -762,6 +816,8 @@ var _ = Describe("Packet packer", func() {
// this should never happen, since non forward-secure packets are limited to a size smaller than MaxPacketSize, such that it is always possible to retransmit them without splitting the StreamFrame
It("refuses to send a packet larger than MaxPacketSize", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42))
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2)
sealingManager.EXPECT().GetSealerWithEncryptionLevel(gomock.Any()).Return(sealer, nil)
packet := &ackhandler.Packet{
EncryptionLevel: protocol.EncryptionHandshake,
@ -778,6 +834,9 @@ var _ = Describe("Packet packer", func() {
})
It("packs a retransmission for an Initial packet", func() {
pnManager.EXPECT().PeekPacketNumber().Return(protocol.PacketNumber(0x42))
pnManager.EXPECT().GetPacketNumberLen(gomock.Any()).Return(protocol.PacketNumberLen2)
pnManager.EXPECT().PopPacketNumber().Return(protocol.PacketNumber(0x42))
sealingManager.EXPECT().GetSealerWithEncryptionLevel(protocol.EncryptionInitial).Return(sealer, nil)
packer.perspective = protocol.PerspectiveClient
packet := &ackhandler.Packet{

4
session.go
View file

@ -183,7 +183,7 @@ var newSession = func(
s.srcConnID,
initialStream,
handshakeStream,
s.sentPacketHandler.GetPacketNumberLen,
s.sentPacketHandler,
s.RemoteAddr(),
nil, // no token
cs,
@ -256,7 +256,7 @@ var newClientSession = func(
s.srcConnID,
initialStream,
handshakeStream,
s.sentPacketHandler.GetPacketNumberLen,
s.sentPacketHandler,
s.RemoteAddr(),
token,
cs,