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

remove unused perspective from header parsing

Browse source
This commit is contained in:
Marten Seemann 2018-11-26 11:14:39 +07:00
parent 8a0fa1f8c6
commit 902853784b
8 changed files with 24 additions and 34 deletions
Download patch file Download diff file Expand all files Collapse all files

6
internal/wire/header_parser.go
View file

@ -62,12 +62,12 @@ func ParseInvariantHeader(b *bytes.Reader, shortHeaderConnIDLen int) (*Invariant
} }
// Parse parses the version dependent part of the header // Parse parses the version dependent part of the header
func (iv *InvariantHeader) Parse(b *bytes.Reader, sentBy protocol.Perspective, ver protocol.VersionNumber) (*Header, error) { func (iv *InvariantHeader) Parse(b *bytes.Reader, ver protocol.VersionNumber) (*Header, error) {
if iv.IsLongHeader { if iv.IsLongHeader {
if iv.Version == 0 { // Version Negotiation Packet if iv.Version == 0 { // Version Negotiation Packet
return iv.parseVersionNegotiationPacket(b) return iv.parseVersionNegotiationPacket(b)
} }
return iv.parseLongHeader(b, sentBy, ver) return iv.parseLongHeader(b, ver)
} }
return iv.parseShortHeader(b, ver) return iv.parseShortHeader(b, ver)
} }
@ -98,7 +98,7 @@ func (iv *InvariantHeader) parseVersionNegotiationPacket(b *bytes.Reader) (*Head
return h, nil return h, nil
} }
func (iv *InvariantHeader) parseLongHeader(b *bytes.Reader, sentBy protocol.Perspective, v protocol.VersionNumber) (*Header, error) { func (iv *InvariantHeader) parseLongHeader(b *bytes.Reader, v protocol.VersionNumber) (*Header, error) {
h := iv.toHeader() h := iv.toHeader()
h.Type = protocol.PacketType(iv.typeByte & 0x7f) h.Type = protocol.PacketType(iv.typeByte & 0x7f)

32
internal/wire/header_parser_test.go
View file

@ -31,7 +31,7 @@ var _ = Describe("Header Parsing", func() {
Expect(iHdr.DestConnectionID).To(Equal(destConnID)) Expect(iHdr.DestConnectionID).To(Equal(destConnID))
Expect(iHdr.SrcConnectionID).To(Equal(srcConnID)) Expect(iHdr.SrcConnectionID).To(Equal(srcConnID))
Expect(iHdr.IsLongHeader).To(BeTrue()) Expect(iHdr.IsLongHeader).To(BeTrue())
hdr, err := iHdr.Parse(b, protocol.PerspectiveServer, versionIETFFrames) hdr, err := iHdr.Parse(b, versionIETFFrames)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(hdr.IsVersionNegotiation).To(BeTrue()) Expect(hdr.IsVersionNegotiation).To(BeTrue())
Expect(hdr.Version).To(BeZero()) Expect(hdr.Version).To(BeZero())
@ -50,7 +50,7 @@ var _ = Describe("Header Parsing", func() {
b := bytes.NewReader(data[:len(data)-2]) b := bytes.NewReader(data[:len(data)-2])
iHdr, err := ParseInvariantHeader(b, 0) iHdr, err := ParseInvariantHeader(b, 0)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
_, err = iHdr.Parse(b, protocol.PerspectiveServer, versionIETFFrames) _, err = iHdr.Parse(b, versionIETFFrames)
Expect(err).To(MatchError(qerr.InvalidVersionNegotiationPacket)) Expect(err).To(MatchError(qerr.InvalidVersionNegotiationPacket))
}) })
@ -63,7 +63,7 @@ var _ = Describe("Header Parsing", func() {
b := bytes.NewReader(data[:len(data)-8]) b := bytes.NewReader(data[:len(data)-8])
iHdr, err := ParseInvariantHeader(b, 0) iHdr, err := ParseInvariantHeader(b, 0)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
_, err = iHdr.Parse(b, protocol.PerspectiveServer, versionIETFFrames) _, err = iHdr.Parse(b, versionIETFFrames)
Expect(err).To(MatchError("InvalidVersionNegotiationPacket: empty version list")) Expect(err).To(MatchError("InvalidVersionNegotiationPacket: empty version list"))
}) })
}) })
@ -91,7 +91,7 @@ var _ = Describe("Header Parsing", func() {
Expect(iHdr.IsLongHeader).To(BeTrue()) Expect(iHdr.IsLongHeader).To(BeTrue())
Expect(iHdr.DestConnectionID).To(Equal(destConnID)) Expect(iHdr.DestConnectionID).To(Equal(destConnID))
Expect(iHdr.SrcConnectionID).To(Equal(srcConnID)) Expect(iHdr.SrcConnectionID).To(Equal(srcConnID))
hdr, err := iHdr.Parse(b, protocol.PerspectiveServer, versionIETFFrames) hdr, err := iHdr.Parse(b, versionIETFFrames)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(hdr.Type).To(Equal(protocol.PacketTypeInitial)) Expect(hdr.Type).To(Equal(protocol.PacketTypeInitial))
Expect(hdr.IsLongHeader).To(BeTrue()) Expect(hdr.IsLongHeader).To(BeTrue())
@ -151,7 +151,7 @@ var _ = Describe("Header Parsing", func() {
b := bytes.NewReader(data) b := bytes.NewReader(data)
iHdr, err := ParseInvariantHeader(b, 0) iHdr, err := ParseInvariantHeader(b, 0)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
hdr, err := iHdr.Parse(b, protocol.PerspectiveServer, versionIETFFrames) hdr, err := iHdr.Parse(b, versionIETFFrames)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(hdr.PacketNumber).To(Equal(protocol.PacketNumber(0x123))) Expect(hdr.PacketNumber).To(Equal(protocol.PacketNumber(0x123)))
Expect(hdr.PacketNumberLen).To(Equal(protocol.PacketNumberLen2)) Expect(hdr.PacketNumberLen).To(Equal(protocol.PacketNumberLen2))
@ -169,7 +169,7 @@ var _ = Describe("Header Parsing", func() {
b := bytes.NewReader(data) b := bytes.NewReader(data)
iHdr, err := ParseInvariantHeader(b, 0) iHdr, err := ParseInvariantHeader(b, 0)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
hdr, err := iHdr.Parse(b, protocol.PerspectiveServer, versionIETFFrames) hdr, err := iHdr.Parse(b, versionIETFFrames)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(hdr.Type).To(Equal(protocol.PacketTypeRetry)) Expect(hdr.Type).To(Equal(protocol.PacketTypeRetry))
Expect(hdr.OrigDestConnectionID).To(Equal(protocol.ConnectionID{1, 2, 3, 4, 5, 6, 7, 8, 9, 10})) Expect(hdr.OrigDestConnectionID).To(Equal(protocol.ConnectionID{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}))
@ -191,7 +191,7 @@ var _ = Describe("Header Parsing", func() {
b := bytes.NewReader(buf.Bytes()) b := bytes.NewReader(buf.Bytes())
iHdr, err := ParseInvariantHeader(b, 0) iHdr, err := ParseInvariantHeader(b, 0)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
_, err = iHdr.Parse(b, protocol.PerspectiveClient, versionIETFFrames) _, err = iHdr.Parse(b, versionIETFFrames)
Expect(err).To(MatchError("InvalidPacketHeader: Received packet with invalid packet type: 42")) Expect(err).To(MatchError("InvalidPacketHeader: Received packet with invalid packet type: 42"))
}) })
@ -208,7 +208,7 @@ var _ = Describe("Header Parsing", func() {
b := bytes.NewReader(data) b := bytes.NewReader(data)
iHdr, err := ParseInvariantHeader(b, 0) iHdr, err := ParseInvariantHeader(b, 0)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
_, err = iHdr.Parse(b, protocol.PerspectiveServer, versionIETFFrames) _, err = iHdr.Parse(b, versionIETFFrames)
Expect(err).To(MatchError(io.EOF)) Expect(err).To(MatchError(io.EOF))
}) })
@ -239,7 +239,7 @@ var _ = Describe("Header Parsing", func() {
b := bytes.NewReader(data[:i]) b := bytes.NewReader(data[:i])
iHdr, err := ParseInvariantHeader(b, 0) iHdr, err := ParseInvariantHeader(b, 0)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
_, err = iHdr.Parse(b, protocol.PerspectiveServer, versionIETFFrames) _, err = iHdr.Parse(b, versionIETFFrames)
Expect(err).To(Equal(io.EOF)) Expect(err).To(Equal(io.EOF))
} }
}) })
@ -259,7 +259,7 @@ var _ = Describe("Header Parsing", func() {
b := bytes.NewReader(data[:i]) b := bytes.NewReader(data[:i])
iHdr, err := ParseInvariantHeader(b, 0) iHdr, err := ParseInvariantHeader(b, 0)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
_, err = iHdr.Parse(b, protocol.PerspectiveServer, versionIETFFrames) _, err = iHdr.Parse(b, versionIETFFrames)
Expect(err).To(Equal(io.EOF)) Expect(err).To(Equal(io.EOF))
} }
}) })
@ -275,7 +275,7 @@ var _ = Describe("Header Parsing", func() {
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(iHdr.IsLongHeader).To(BeFalse()) Expect(iHdr.IsLongHeader).To(BeFalse())
Expect(iHdr.DestConnectionID).To(Equal(connID)) Expect(iHdr.DestConnectionID).To(Equal(connID))
hdr, err := iHdr.Parse(b, protocol.PerspectiveClient, versionIETFFrames) hdr, err := iHdr.Parse(b, versionIETFFrames)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(hdr.KeyPhase).To(Equal(0)) Expect(hdr.KeyPhase).To(Equal(0))
Expect(hdr.DestConnectionID).To(Equal(connID)) Expect(hdr.DestConnectionID).To(Equal(connID))
@ -294,7 +294,7 @@ var _ = Describe("Header Parsing", func() {
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(iHdr.IsLongHeader).To(BeFalse()) Expect(iHdr.IsLongHeader).To(BeFalse())
Expect(iHdr.DestConnectionID).To(Equal(connID)) Expect(iHdr.DestConnectionID).To(Equal(connID))
hdr, err := iHdr.Parse(b, protocol.PerspectiveClient, versionIETFFrames) hdr, err := iHdr.Parse(b, versionIETFFrames)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(hdr.KeyPhase).To(Equal(0)) Expect(hdr.KeyPhase).To(Equal(0))
Expect(hdr.DestConnectionID).To(Equal(connID)) Expect(hdr.DestConnectionID).To(Equal(connID))
@ -311,7 +311,7 @@ var _ = Describe("Header Parsing", func() {
b := bytes.NewReader(data) b := bytes.NewReader(data)
iHdr, err := ParseInvariantHeader(b, 6) iHdr, err := ParseInvariantHeader(b, 6)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
hdr, err := iHdr.Parse(b, protocol.PerspectiveServer, versionIETFFrames) hdr, err := iHdr.Parse(b, versionIETFFrames)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(hdr.IsLongHeader).To(BeFalse()) Expect(hdr.IsLongHeader).To(BeFalse())
Expect(hdr.KeyPhase).To(Equal(1)) Expect(hdr.KeyPhase).To(Equal(1))
@ -327,7 +327,7 @@ var _ = Describe("Header Parsing", func() {
b := bytes.NewReader(data) b := bytes.NewReader(data)
iHdr, err := ParseInvariantHeader(b, 4) iHdr, err := ParseInvariantHeader(b, 4)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
hdr, err := iHdr.Parse(b, protocol.PerspectiveClient, versionIETFFrames) hdr, err := iHdr.Parse(b, versionIETFFrames)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(hdr.IsLongHeader).To(BeFalse()) Expect(hdr.IsLongHeader).To(BeFalse())
Expect(hdr.PacketNumber).To(Equal(protocol.PacketNumber(0x1337))) Expect(hdr.PacketNumber).To(Equal(protocol.PacketNumber(0x1337)))
@ -344,7 +344,7 @@ var _ = Describe("Header Parsing", func() {
b := bytes.NewReader(data) b := bytes.NewReader(data)
iHdr, err := ParseInvariantHeader(b, 10) iHdr, err := ParseInvariantHeader(b, 10)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
hdr, err := iHdr.Parse(b, protocol.PerspectiveServer, versionIETFFrames) hdr, err := iHdr.Parse(b, versionIETFFrames)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(hdr.IsLongHeader).To(BeFalse()) Expect(hdr.IsLongHeader).To(BeFalse())
Expect(hdr.PacketNumber).To(Equal(protocol.PacketNumber(0x99beef))) Expect(hdr.PacketNumber).To(Equal(protocol.PacketNumber(0x99beef)))
@ -374,7 +374,7 @@ var _ = Describe("Header Parsing", func() {
b := bytes.NewReader(data[:i]) b := bytes.NewReader(data[:i])
iHdr, err := ParseInvariantHeader(b, 6) iHdr, err := ParseInvariantHeader(b, 6)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
_, err = iHdr.Parse(b, protocol.PerspectiveClient, versionIETFFrames) _, err = iHdr.Parse(b, versionIETFFrames)
Expect(err).To(Equal(io.EOF)) Expect(err).To(Equal(io.EOF))
} }
}) })

2
internal/wire/header_test.go
View file

@ -344,7 +344,7 @@ var _ = Describe("Header", func() {
b := bytes.NewReader(data) b := bytes.NewReader(data)
iHdr, err := ParseInvariantHeader(b, 4) iHdr, err := ParseInvariantHeader(b, 4)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
hdr, err := iHdr.Parse(b, protocol.PerspectiveServer, versionIETFHeader) hdr, err := iHdr.Parse(b, versionIETFHeader)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
hdr.Log(logger) hdr.Log(logger)
Expect(buf.String()).To(ContainSubstring("VersionNegotiationPacket{DestConnectionID: 0xdeadbeefcafe1337, SrcConnectionID: 0xdecafbad13371337")) Expect(buf.String()).To(ContainSubstring("VersionNegotiationPacket{DestConnectionID: 0xdeadbeefcafe1337, SrcConnectionID: 0xdecafbad13371337"))

2
internal/wire/version_negotiation_test.go
View file

@ -19,7 +19,7 @@ var _ = Describe("Version Negotiation Packets", func() {
b := bytes.NewReader(data) b := bytes.NewReader(data)
iHdr, err := ParseInvariantHeader(b, 4) iHdr, err := ParseInvariantHeader(b, 4)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
hdr, err := iHdr.Parse(b, protocol.PerspectiveServer, versionIETFFrames) hdr, err := iHdr.Parse(b, versionIETFFrames)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
Expect(hdr.IsVersionNegotiation).To(BeTrue()) Expect(hdr.IsVersionNegotiation).To(BeTrue())
Expect(hdr.DestConnectionID).To(Equal(destConnID)) Expect(hdr.DestConnectionID).To(Equal(destConnID))

5
packet_handler_map.go
View file

@ -175,12 +175,10 @@ func (h *packetHandlerMap) handlePacket(addr net.Addr, data []byte) error {
handlerEntry, handlerFound := h.handlers[string(iHdr.DestConnectionID)] handlerEntry, handlerFound := h.handlers[string(iHdr.DestConnectionID)]
server := h.server server := h.server
var sentBy protocol.Perspective
var version protocol.VersionNumber var version protocol.VersionNumber
var handlePacket func(*receivedPacket) var handlePacket func(*receivedPacket)
if handlerFound { // existing session if handlerFound { // existing session
handler := handlerEntry.handler handler := handlerEntry.handler
sentBy = handler.GetPerspective().Opposite()
version = handler.GetVersion() version = handler.GetVersion()
handlePacket = handler.handlePacket handlePacket = handler.handlePacket
} else { // no session found } else { // no session found
@ -203,12 +201,11 @@ func (h *packetHandlerMap) handlePacket(addr net.Addr, data []byte) error {
return fmt.Errorf("received a packet with an unexpected connection ID %s", iHdr.DestConnectionID) return fmt.Errorf("received a packet with an unexpected connection ID %s", iHdr.DestConnectionID)
} }
handlePacket = server.handlePacket handlePacket = server.handlePacket
sentBy = protocol.PerspectiveClient
version = iHdr.Version version = iHdr.Version
} }
h.mutex.RUnlock() h.mutex.RUnlock()
hdr, err := iHdr.Parse(r, sentBy, version) hdr, err := iHdr.Parse(r, version)
if err != nil { if err != nil {
return fmt.Errorf("error parsing header: %s", err) return fmt.Errorf("error parsing header: %s", err)
} }

7
packet_handler_map_test.go
View file

@ -62,13 +62,11 @@ var _ = Describe("Packet Handler Map", func() {
close(handledPacket1) close(handledPacket1)
}) })
packetHandler1.EXPECT().GetVersion() packetHandler1.EXPECT().GetVersion()
packetHandler1.EXPECT().GetPerspective().Return(protocol.PerspectiveClient)
packetHandler2.EXPECT().handlePacket(gomock.Any()).Do(func(p *receivedPacket) { packetHandler2.EXPECT().handlePacket(gomock.Any()).Do(func(p *receivedPacket) {
Expect(p.header.DestConnectionID).To(Equal(connID2)) Expect(p.header.DestConnectionID).To(Equal(connID2))
close(handledPacket2) close(handledPacket2)
}) })
packetHandler2.EXPECT().GetVersion() packetHandler2.EXPECT().GetVersion()
packetHandler2.EXPECT().GetPerspective().Return(protocol.PerspectiveClient)
handler.Add(connID1, packetHandler1) handler.Add(connID1, packetHandler1)
handler.Add(connID2, packetHandler2) handler.Add(connID2, packetHandler2)
@ -111,7 +109,6 @@ var _ = Describe("Packet Handler Map", func() {
connID := protocol.ConnectionID{1, 2, 3, 4, 5, 6, 7, 8} connID := protocol.ConnectionID{1, 2, 3, 4, 5, 6, 7, 8}
packetHandler := NewMockPacketHandler(mockCtrl) packetHandler := NewMockPacketHandler(mockCtrl)
packetHandler.EXPECT().GetVersion().Return(protocol.VersionWhatever) packetHandler.EXPECT().GetVersion().Return(protocol.VersionWhatever)
packetHandler.EXPECT().GetPerspective().Return(protocol.PerspectiveClient)
packetHandler.EXPECT().handlePacket(gomock.Any()) packetHandler.EXPECT().handlePacket(gomock.Any())
handler.Add(connID, packetHandler) handler.Add(connID, packetHandler)
handler.Retire(connID) handler.Retire(connID)
@ -129,7 +126,6 @@ var _ = Describe("Packet Handler Map", func() {
connID := protocol.ConnectionID{1, 2, 3, 4, 5, 6, 7, 8} connID := protocol.ConnectionID{1, 2, 3, 4, 5, 6, 7, 8}
packetHandler := NewMockPacketHandler(mockCtrl) packetHandler := NewMockPacketHandler(mockCtrl)
packetHandler.EXPECT().GetVersion().Return(protocol.VersionWhatever) packetHandler.EXPECT().GetVersion().Return(protocol.VersionWhatever)
packetHandler.EXPECT().GetPerspective().Return(protocol.PerspectiveClient)
handler.Add(connID, packetHandler) handler.Add(connID, packetHandler)
hdr := &wire.Header{ hdr := &wire.Header{
IsLongHeader: true, IsLongHeader: true,
@ -151,7 +147,6 @@ var _ = Describe("Packet Handler Map", func() {
connID := protocol.ConnectionID{1, 2, 3, 4, 5, 6, 7, 8} connID := protocol.ConnectionID{1, 2, 3, 4, 5, 6, 7, 8}
packetHandler := NewMockPacketHandler(mockCtrl) packetHandler := NewMockPacketHandler(mockCtrl)
packetHandler.EXPECT().GetVersion().Return(protocol.VersionWhatever) packetHandler.EXPECT().GetVersion().Return(protocol.VersionWhatever)
packetHandler.EXPECT().GetPerspective().Return(protocol.PerspectiveClient)
handler.Add(connID, packetHandler) handler.Add(connID, packetHandler)
hdr := &wire.Header{ hdr := &wire.Header{
IsLongHeader: true, IsLongHeader: true,
@ -170,7 +165,6 @@ var _ = Describe("Packet Handler Map", func() {
connID := protocol.ConnectionID{1, 2, 3, 4, 5, 6, 7, 8} connID := protocol.ConnectionID{1, 2, 3, 4, 5, 6, 7, 8}
packetHandler := NewMockPacketHandler(mockCtrl) packetHandler := NewMockPacketHandler(mockCtrl)
packetHandler.EXPECT().GetVersion().Return(protocol.VersionWhatever) packetHandler.EXPECT().GetVersion().Return(protocol.VersionWhatever)
packetHandler.EXPECT().GetPerspective().Return(protocol.PerspectiveClient)
handler.Add(connID, packetHandler) handler.Add(connID, packetHandler)
packetHandler.EXPECT().handlePacket(gomock.Any()).Do(func(p *receivedPacket) { packetHandler.EXPECT().handlePacket(gomock.Any()).Do(func(p *receivedPacket) {
Expect(p.data).To(HaveLen(456 - int(p.header.PacketNumberLen))) Expect(p.data).To(HaveLen(456 - int(p.header.PacketNumberLen)))
@ -211,7 +205,6 @@ var _ = Describe("Packet Handler Map", func() {
handler.AddWithResetToken(connID, packetHandler, token) handler.AddWithResetToken(connID, packetHandler, token)
// first send a normal packet // first send a normal packet
handledPacket := make(chan struct{}) handledPacket := make(chan struct{})
packetHandler.EXPECT().GetPerspective()
packetHandler.EXPECT().GetVersion() packetHandler.EXPECT().GetVersion()
packetHandler.EXPECT().handlePacket(gomock.Any()).Do(func(p *receivedPacket) { packetHandler.EXPECT().handlePacket(gomock.Any()).Do(func(p *receivedPacket) {
Expect(p.header.DestConnectionID).To(Equal(connID)) Expect(p.header.DestConnectionID).To(Equal(connID))

2
packet_packer_test.go
View file

@ -34,7 +34,7 @@ var _ = Describe("Packet packer", func() {
r := bytes.NewReader(data) r := bytes.NewReader(data)
iHdr, err := wire.ParseInvariantHeader(r, 0) iHdr, err := wire.ParseInvariantHeader(r, 0)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
hdr, err := iHdr.Parse(r, protocol.PerspectiveServer, protocol.VersionWhatever) hdr, err := iHdr.Parse(r, protocol.VersionWhatever)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
ExpectWithOffset(0, hdr.Length).To(BeEquivalentTo(r.Len() + int(hdr.PacketNumberLen))) ExpectWithOffset(0, hdr.Length).To(BeEquivalentTo(r.Len() + int(hdr.PacketNumberLen)))
} }

2
server_test.go
View file

@ -102,7 +102,7 @@ var _ = Describe("Server", func() {
b := bytes.NewReader(data) b := bytes.NewReader(data)
iHdr, err := wire.ParseInvariantHeader(b, 0) iHdr, err := wire.ParseInvariantHeader(b, 0)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
hdr, err := iHdr.Parse(b, protocol.PerspectiveServer, protocol.VersionTLS) hdr, err := iHdr.Parse(b, protocol.VersionTLS)
Expect(err).ToNot(HaveOccurred()) Expect(err).ToNot(HaveOccurred())
return hdr return hdr
} }