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

rename the wire.InvariantHeader to Header

Browse source
This commit is contained in:
Marten Seemann 2018-11-20 17:17:43 +07:00
parent bf96707f48
commit 7b91ba56b6
8 changed files with 178 additions and 178 deletions
Download patch file Download diff file Expand all files Collapse all files

6
internal/wire/extended_header_test.go
View file

@ -326,11 +326,11 @@ var _ = Describe("Header", func() {
srcConnID := protocol.ConnectionID{0xde, 0xca, 0xfb, 0xad, 0x013, 0x37, 0x13, 0x37}
data, err := ComposeVersionNegotiation(destConnID, srcConnID, []protocol.VersionNumber{0x12345678, 0x87654321})
Expect(err).ToNot(HaveOccurred())
iHdr, err := ParseInvariantHeader(bytes.NewReader(data), 4)
hdr, err := ParseHeader(bytes.NewReader(data), 4)
Expect(err).ToNot(HaveOccurred())
hdr, err := iHdr.Parse(bytes.NewReader(data), versionIETFHeader)
extHdr, err := hdr.Parse(bytes.NewReader(data), versionIETFHeader)
Expect(err).ToNot(HaveOccurred())
hdr.Log(logger)
extHdr.Log(logger)
Expect(buf.String()).To(ContainSubstring("VersionNegotiationPacket{DestConnectionID: 0xdeadbeefcafe1337, SrcConnectionID: 0xdecafbad13371337"))
Expect(buf.String()).To(ContainSubstring("0x12345678"))
Expect(buf.String()).To(ContainSubstring("0x87654321"))

96
internal/wire/header_parser.go
View file

@ -10,8 +10,8 @@ import (
"github.com/lucas-clemente/quic-go/internal/utils"
)
// The InvariantHeader is the version independent part of the header
type InvariantHeader struct {
// The Header is the version independent part of the header
type Header struct {
IsLongHeader bool
Version protocol.VersionNumber
SrcConnectionID protocol.ConnectionID
@ -21,10 +21,10 @@ type InvariantHeader struct {
len int // how many bytes were read while parsing this header
}
// ParseInvariantHeader parses the version independent part of the header
func ParseInvariantHeader(b *bytes.Reader, shortHeaderConnIDLen int) (*InvariantHeader, error) {
// ParseHeader parses the version independent part of the header
func ParseHeader(b *bytes.Reader, shortHeaderConnIDLen int) (*Header, error) {
startLen := b.Len()
h, err := parseInvariantHeaderImpl(b, shortHeaderConnIDLen)
h, err := parseHeaderImpl(b, shortHeaderConnIDLen)
if err != nil {
return nil, err
}
@ -32,13 +32,13 @@ func ParseInvariantHeader(b *bytes.Reader, shortHeaderConnIDLen int) (*Invariant
return h, nil
}
func parseInvariantHeaderImpl(b *bytes.Reader, shortHeaderConnIDLen int) (*InvariantHeader, error) {
func parseHeaderImpl(b *bytes.Reader, shortHeaderConnIDLen int) (*Header, error) {
typeByte, err := b.ReadByte()
if err != nil {
return nil, err
}
h := &InvariantHeader{typeByte: typeByte}
h := &Header{typeByte: typeByte}
h.IsLongHeader = typeByte&0x80 > 0
// If this is not a Long Header, it could either be a Public Header or a Short Header.
@ -74,71 +74,71 @@ func parseInvariantHeaderImpl(b *bytes.Reader, shortHeaderConnIDLen int) (*Invar
// Parse parses the version dependent part of the header.
// The Reader has to be set such that it points to the first byte of the header.
func (iv *InvariantHeader) Parse(b *bytes.Reader, ver protocol.VersionNumber) (*ExtendedHeader, error) {
if _, err := b.Seek(int64(iv.len), io.SeekCurrent); err != nil {
func (h *Header) Parse(b *bytes.Reader, ver protocol.VersionNumber) (*ExtendedHeader, error) {
if _, err := b.Seek(int64(h.len), io.SeekCurrent); err != nil {
return nil, err
}
if iv.IsLongHeader {
if iv.Version == 0 { // Version Negotiation Packet
return iv.parseVersionNegotiationPacket(b)
if h.IsLongHeader {
if h.Version == 0 { // Version Negotiation Packet
return h.parseVersionNegotiationPacket(b)
}
return iv.parseLongHeader(b, ver)
return h.parseLongHeader(b, ver)
}
return iv.parseShortHeader(b, ver)
return h.parseShortHeader(b, ver)
}
func (iv *InvariantHeader) toExtendedHeader() *ExtendedHeader {
func (h *Header) toExtendedHeader() *ExtendedHeader {
return &ExtendedHeader{
IsLongHeader: iv.IsLongHeader,
DestConnectionID: iv.DestConnectionID,
SrcConnectionID: iv.SrcConnectionID,
Version: iv.Version,
IsLongHeader: h.IsLongHeader,
DestConnectionID: h.DestConnectionID,
SrcConnectionID: h.SrcConnectionID,
Version: h.Version,
}
}
func (iv *InvariantHeader) parseVersionNegotiationPacket(b *bytes.Reader) (*ExtendedHeader, error) {
h := iv.toExtendedHeader()
func (h *Header) parseVersionNegotiationPacket(b *bytes.Reader) (*ExtendedHeader, error) {
eh := h.toExtendedHeader()
if b.Len() == 0 {
return nil, qerr.Error(qerr.InvalidVersionNegotiationPacket, "empty version list")
}
h.IsVersionNegotiation = true
h.SupportedVersions = make([]protocol.VersionNumber, b.Len()/4)
eh.IsVersionNegotiation = true
eh.SupportedVersions = make([]protocol.VersionNumber, b.Len()/4)
for i := 0; b.Len() > 0; i++ {
v, err := utils.BigEndian.ReadUint32(b)
if err != nil {
return nil, qerr.InvalidVersionNegotiationPacket
}
h.SupportedVersions[i] = protocol.VersionNumber(v)
eh.SupportedVersions[i] = protocol.VersionNumber(v)
}
return h, nil
return eh, nil
}
func (iv *InvariantHeader) parseLongHeader(b *bytes.Reader, v protocol.VersionNumber) (*ExtendedHeader, error) {
h := iv.toExtendedHeader()
h.Type = protocol.PacketType(iv.typeByte & 0x7f)
func (h *Header) parseLongHeader(b *bytes.Reader, v protocol.VersionNumber) (*ExtendedHeader, error) {
eh := h.toExtendedHeader()
eh.Type = protocol.PacketType(h.typeByte & 0x7f)
if h.Type != protocol.PacketTypeInitial && h.Type != protocol.PacketTypeRetry && h.Type != protocol.PacketType0RTT && h.Type != protocol.PacketTypeHandshake {
return nil, qerr.Error(qerr.InvalidPacketHeader, fmt.Sprintf("Received packet with invalid packet type: %d", h.Type))
if eh.Type != protocol.PacketTypeInitial && eh.Type != protocol.PacketTypeRetry && eh.Type != protocol.PacketType0RTT && eh.Type != protocol.PacketTypeHandshake {
return nil, qerr.Error(qerr.InvalidPacketHeader, fmt.Sprintf("Received packet with invalid packet type: %d", eh.Type))
}
if h.Type == protocol.PacketTypeRetry {
if eh.Type == protocol.PacketTypeRetry {
odcilByte, err := b.ReadByte()
if err != nil {
return nil, err
}
odcil := decodeSingleConnIDLen(odcilByte & 0xf)
h.OrigDestConnectionID, err = protocol.ReadConnectionID(b, odcil)
eh.OrigDestConnectionID, err = protocol.ReadConnectionID(b, odcil)
if err != nil {
return nil, err
}
h.Token = make([]byte, b.Len())
if _, err := io.ReadFull(b, h.Token); err != nil {
eh.Token = make([]byte, b.Len())
if _, err := io.ReadFull(b, eh.Token); err != nil {
return nil, err
}
return h, nil
return eh, nil
}
if h.Type == protocol.PacketTypeInitial {
if eh.Type == protocol.PacketTypeInitial {
tokenLen, err := utils.ReadVarInt(b)
if err != nil {
return nil, err
@ -146,8 +146,8 @@ func (iv *InvariantHeader) parseLongHeader(b *bytes.Reader, v protocol.VersionNu
if tokenLen > uint64(b.Len()) {
return nil, io.EOF
}
h.Token = make([]byte, tokenLen)
if _, err := io.ReadFull(b, h.Token); err != nil {
eh.Token = make([]byte, tokenLen)
if _, err := io.ReadFull(b, eh.Token); err != nil {
return nil, err
}
}
@ -156,27 +156,27 @@ func (iv *InvariantHeader) parseLongHeader(b *bytes.Reader, v protocol.VersionNu
if err != nil {
return nil, err
}
h.Length = protocol.ByteCount(pl)
eh.Length = protocol.ByteCount(pl)
pn, pnLen, err := utils.ReadVarIntPacketNumber(b)
if err != nil {
return nil, err
}
h.PacketNumber = pn
h.PacketNumberLen = pnLen
eh.PacketNumber = pn
eh.PacketNumberLen = pnLen
return h, nil
return eh, nil
}
func (iv *InvariantHeader) parseShortHeader(b *bytes.Reader, v protocol.VersionNumber) (*ExtendedHeader, error) {
h := iv.toExtendedHeader()
h.KeyPhase = int(iv.typeByte&0x40) >> 6
func (h *Header) parseShortHeader(b *bytes.Reader, v protocol.VersionNumber) (*ExtendedHeader, error) {
eh := h.toExtendedHeader()
eh.KeyPhase = int(h.typeByte&0x40) >> 6
pn, pnLen, err := utils.ReadVarIntPacketNumber(b)
if err != nil {
return nil, err
}
h.PacketNumber = pn
h.PacketNumberLen = pnLen
eh.PacketNumber = pn
eh.PacketNumberLen = pnLen
return h, nil
return eh, nil
}

190
internal/wire/header_parser_test.go
View file

@ -25,20 +25,20 @@ var _ = Describe("Header Parsing", func() {
versions := []protocol.VersionNumber{0x22334455, 0x33445566}
data, err := ComposeVersionNegotiation(destConnID, srcConnID, versions)
Expect(err).ToNot(HaveOccurred())
iHdr, err := ParseInvariantHeader(bytes.NewReader(data), 0)
hdr, err := ParseHeader(bytes.NewReader(data), 0)
Expect(err).ToNot(HaveOccurred())
Expect(iHdr.DestConnectionID).To(Equal(destConnID))
Expect(iHdr.SrcConnectionID).To(Equal(srcConnID))
Expect(iHdr.IsLongHeader).To(BeTrue())
b := bytes.NewReader(data)
hdr, err := iHdr.Parse(b, versionIETFFrames)
Expect(err).ToNot(HaveOccurred())
Expect(hdr.IsVersionNegotiation).To(BeTrue())
Expect(hdr.Version).To(BeZero())
Expect(hdr.DestConnectionID).To(Equal(destConnID))
Expect(hdr.SrcConnectionID).To(Equal(srcConnID))
Expect(hdr.IsLongHeader).To(BeTrue())
b := bytes.NewReader(data)
extHdr, err := hdr.Parse(b, versionIETFFrames)
Expect(err).ToNot(HaveOccurred())
Expect(extHdr.IsVersionNegotiation).To(BeTrue())
Expect(extHdr.Version).To(BeZero())
Expect(extHdr.DestConnectionID).To(Equal(destConnID))
Expect(extHdr.SrcConnectionID).To(Equal(srcConnID))
for _, v := range versions {
Expect(hdr.SupportedVersions).To(ContainElement(v))
Expect(extHdr.SupportedVersions).To(ContainElement(v))
}
Expect(b.Len()).To(BeZero())
})
@ -49,9 +49,9 @@ var _ = Describe("Header Parsing", func() {
data, err := ComposeVersionNegotiation(connID, connID, versions)
Expect(err).ToNot(HaveOccurred())
data = data[:len(data)-2]
iHdr, err := ParseInvariantHeader(bytes.NewReader(data), 0)
hdr, err := ParseHeader(bytes.NewReader(data), 0)
Expect(err).ToNot(HaveOccurred())
_, err = iHdr.Parse(bytes.NewReader(data), versionIETFFrames)
_, err = hdr.Parse(bytes.NewReader(data), versionIETFFrames)
Expect(err).To(MatchError(qerr.InvalidVersionNegotiationPacket))
})
@ -62,9 +62,9 @@ var _ = Describe("Header Parsing", func() {
Expect(err).ToNot(HaveOccurred())
// remove 8 bytes (two versions), since ComposeVersionNegotiation also added a reserved version number
data = data[:len(data)-8]
iHdr, err := ParseInvariantHeader(bytes.NewReader(data), 0)
hdr, err := ParseHeader(bytes.NewReader(data), 0)
Expect(err).ToNot(HaveOccurred())
_, err = iHdr.Parse(bytes.NewReader(data), versionIETFFrames)
_, err = hdr.Parse(bytes.NewReader(data), versionIETFFrames)
Expect(err).To(MatchError("InvalidVersionNegotiationPacket: empty version list"))
})
})
@ -86,24 +86,24 @@ var _ = Describe("Header Parsing", func() {
// packet number
data = appendPacketNumber(data, 0xbeef, protocol.PacketNumberLen4)
iHdr, err := ParseInvariantHeader(bytes.NewReader(data), 0)
hdr, err := ParseHeader(bytes.NewReader(data), 0)
Expect(err).ToNot(HaveOccurred())
Expect(iHdr.IsLongHeader).To(BeTrue())
Expect(iHdr.DestConnectionID).To(Equal(destConnID))
Expect(iHdr.SrcConnectionID).To(Equal(srcConnID))
b := bytes.NewReader(data)
hdr, err := iHdr.Parse(b, versionIETFFrames)
Expect(err).ToNot(HaveOccurred())
Expect(hdr.Type).To(Equal(protocol.PacketTypeInitial))
Expect(hdr.IsLongHeader).To(BeTrue())
Expect(hdr.DestConnectionID).To(Equal(destConnID))
Expect(hdr.SrcConnectionID).To(Equal(srcConnID))
Expect(hdr.Token).To(Equal([]byte("foobar")))
Expect(hdr.Length).To(Equal(protocol.ByteCount(0x1337)))
Expect(hdr.PacketNumber).To(Equal(protocol.PacketNumber(0xbeef)))
Expect(hdr.PacketNumberLen).To(Equal(protocol.PacketNumberLen4))
Expect(hdr.Version).To(Equal(protocol.VersionNumber(0x1020304)))
Expect(hdr.IsVersionNegotiation).To(BeFalse())
b := bytes.NewReader(data)
extHdr, err := hdr.Parse(b, versionIETFFrames)
Expect(err).ToNot(HaveOccurred())
Expect(extHdr.Type).To(Equal(protocol.PacketTypeInitial))
Expect(extHdr.IsLongHeader).To(BeTrue())
Expect(extHdr.DestConnectionID).To(Equal(destConnID))
Expect(extHdr.SrcConnectionID).To(Equal(srcConnID))
Expect(extHdr.Token).To(Equal([]byte("foobar")))
Expect(extHdr.Length).To(Equal(protocol.ByteCount(0x1337)))
Expect(extHdr.PacketNumber).To(Equal(protocol.PacketNumber(0xbeef)))
Expect(extHdr.PacketNumberLen).To(Equal(protocol.PacketNumberLen4))
Expect(extHdr.Version).To(Equal(protocol.VersionNumber(0x1020304)))
Expect(extHdr.IsVersionNegotiation).To(BeFalse())
Expect(b.Len()).To(BeZero())
})
@ -116,10 +116,10 @@ var _ = Describe("Header Parsing", func() {
}
data = append(data, encodeVarInt(0x42)...) // length
data = append(data, []byte{0xde, 0xca, 0xfb, 0xad}...)
iHdr, err := ParseInvariantHeader(bytes.NewReader(data), 0)
hdr, err := ParseHeader(bytes.NewReader(data), 0)
Expect(err).ToNot(HaveOccurred())
Expect(iHdr.SrcConnectionID).To(Equal(protocol.ConnectionID{0xde, 0xad, 0xbe, 0xef}))
Expect(iHdr.DestConnectionID).To(BeEmpty())
Expect(hdr.SrcConnectionID).To(Equal(protocol.ConnectionID{0xde, 0xad, 0xbe, 0xef}))
Expect(hdr.DestConnectionID).To(BeEmpty())
})
It("parses a Long Header without a source connection ID", func() {
@ -131,10 +131,10 @@ var _ = Describe("Header Parsing", func() {
}
data = append(data, encodeVarInt(0x42)...) // length
data = append(data, []byte{0xde, 0xca, 0xfb, 0xad}...)
iHdr, err := ParseInvariantHeader(bytes.NewReader(data), 0)
hdr, err := ParseHeader(bytes.NewReader(data), 0)
Expect(err).ToNot(HaveOccurred())
Expect(iHdr.SrcConnectionID).To(BeEmpty())
Expect(iHdr.DestConnectionID).To(Equal(protocol.ConnectionID{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}))
Expect(hdr.SrcConnectionID).To(BeEmpty())
Expect(hdr.DestConnectionID).To(Equal(protocol.ConnectionID{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}))
})
It("parses a Long Header with a 2 byte packet number", func() {
@ -147,13 +147,13 @@ var _ = Describe("Header Parsing", func() {
data = append(data, encodeVarInt(0x42)...) // length
data = appendPacketNumber(data, 0x123, protocol.PacketNumberLen2)
iHdr, err := ParseInvariantHeader(bytes.NewReader(data), 0)
hdr, err := ParseHeader(bytes.NewReader(data), 0)
Expect(err).ToNot(HaveOccurred())
b := bytes.NewReader(data)
hdr, err := iHdr.Parse(b, versionIETFFrames)
extHdr, err := hdr.Parse(b, versionIETFFrames)
Expect(err).ToNot(HaveOccurred())
Expect(hdr.PacketNumber).To(Equal(protocol.PacketNumber(0x123)))
Expect(hdr.PacketNumberLen).To(Equal(protocol.PacketNumberLen2))
Expect(extHdr.PacketNumber).To(Equal(protocol.PacketNumber(0x123)))
Expect(extHdr.PacketNumberLen).To(Equal(protocol.PacketNumberLen2))
Expect(b.Len()).To(BeZero())
})
@ -166,14 +166,14 @@ var _ = Describe("Header Parsing", func() {
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, // source connection ID
'f', 'o', 'o', 'b', 'a', 'r', // token
}
iHdr, err := ParseInvariantHeader(bytes.NewReader(data), 0)
hdr, err := ParseHeader(bytes.NewReader(data), 0)
Expect(err).ToNot(HaveOccurred())
b := bytes.NewReader(data)
hdr, err := iHdr.Parse(b, versionIETFFrames)
extHdr, err := hdr.Parse(b, versionIETFFrames)
Expect(err).ToNot(HaveOccurred())
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.Token).To(Equal([]byte("foobar")))
Expect(extHdr.Type).To(Equal(protocol.PacketTypeRetry))
Expect(extHdr.OrigDestConnectionID).To(Equal(protocol.ConnectionID{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}))
Expect(extHdr.Token).To(Equal([]byte("foobar")))
Expect(b.Len()).To(BeZero())
})
@ -189,9 +189,9 @@ var _ = Describe("Header Parsing", func() {
PacketNumberLen: protocol.PacketNumberLen1,
}).Write(buf, protocol.VersionTLS)).To(Succeed())
b := bytes.NewReader(buf.Bytes())
iHdr, err := ParseInvariantHeader(b, 0)
hdr, err := ParseHeader(b, 0)
Expect(err).ToNot(HaveOccurred())
_, err = iHdr.Parse(b, versionIETFFrames)
_, err = hdr.Parse(b, versionIETFFrames)
Expect(err).To(MatchError("InvalidPacketHeader: Received packet with invalid packet type: 42"))
})
@ -206,13 +206,13 @@ var _ = Describe("Header Parsing", func() {
data = appendPacketNumber(data, 0x123, protocol.PacketNumberLen2) // 2 bytes
b := bytes.NewReader(data)
iHdr, err := ParseInvariantHeader(b, 0)
hdr, err := ParseHeader(b, 0)
Expect(err).ToNot(HaveOccurred())
_, err = iHdr.Parse(b, versionIETFFrames)
_, err = hdr.Parse(b, versionIETFFrames)
Expect(err).To(MatchError(io.EOF))
})
It("errors on EOF, when parsing the invariant header", func() {
It("errors on EOF, when parsing the header", func() {
data := []byte{
0x80 ^ uint8(protocol.PacketTypeInitial),
0x1, 0x2, 0x3, 0x4, // version number
@ -221,7 +221,7 @@ var _ = Describe("Header Parsing", func() {
0xde, 0xad, 0xbe, 0xef, 0xca, 0xfe, 0x13, 0x37, // source connection ID
}
for i := 0; i < len(data); i++ {
_, err := ParseInvariantHeader(bytes.NewReader(data[:i]), 0)
_, err := ParseHeader(bytes.NewReader(data[:i]), 0)
Expect(err).To(Equal(io.EOF))
}
})
@ -232,14 +232,14 @@ var _ = Describe("Header Parsing", func() {
0x1, 0x2, 0x3, 0x4, // version number
0x0, // connection ID lengths
}
iHdrLen := len(data)
hdrLen := len(data)
data = append(data, encodeVarInt(0x1337)...)
data = appendPacketNumber(data, 0xdeadbeef, protocol.PacketNumberLen4)
for i := iHdrLen; i < len(data); i++ {
for i := hdrLen; i < len(data); i++ {
b := bytes.NewReader(data[:i])
iHdr, err := ParseInvariantHeader(b, 0)
hdr, err := ParseHeader(b, 0)
Expect(err).ToNot(HaveOccurred())
_, err = iHdr.Parse(b, versionIETFFrames)
_, err = hdr.Parse(b, versionIETFFrames)
Expect(err).To(Equal(io.EOF))
}
})
@ -250,16 +250,16 @@ var _ = Describe("Header Parsing", func() {
0x1, 0x2, 0x3, 0x4, // version number
0x0, // connection ID lengths
}
iHdrLen := len(data)
hdrLen := len(data)
data = append(data, []byte{
0x97, // Orig Destination Connection ID length
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, // source connection ID
}...)
for i := iHdrLen; i < len(data); i++ {
for i := hdrLen; i < len(data); i++ {
b := bytes.NewReader(data[:i])
iHdr, err := ParseInvariantHeader(b, 0)
hdr, err := ParseHeader(b, 0)
Expect(err).ToNot(HaveOccurred())
_, err = iHdr.Parse(b, versionIETFFrames)
_, err = hdr.Parse(b, versionIETFFrames)
Expect(err).To(Equal(io.EOF))
}
})
@ -270,18 +270,18 @@ var _ = Describe("Header Parsing", func() {
connID := protocol.ConnectionID{0xde, 0xad, 0xbe, 0xef, 0xca, 0xfe, 0x13, 0x37}
data := append([]byte{0x30}, connID...)
data = appendPacketNumber(data, 0x42, protocol.PacketNumberLen1)
iHdr, err := ParseInvariantHeader(bytes.NewReader(data), 8)
hdr, err := ParseHeader(bytes.NewReader(data), 8)
Expect(err).ToNot(HaveOccurred())
Expect(iHdr.IsLongHeader).To(BeFalse())
Expect(iHdr.DestConnectionID).To(Equal(connID))
b := bytes.NewReader(data)
hdr, err := iHdr.Parse(b, versionIETFFrames)
Expect(err).ToNot(HaveOccurred())
Expect(hdr.KeyPhase).To(Equal(0))
Expect(hdr.IsLongHeader).To(BeFalse())
Expect(hdr.DestConnectionID).To(Equal(connID))
Expect(hdr.SrcConnectionID).To(BeEmpty())
Expect(hdr.PacketNumber).To(Equal(protocol.PacketNumber(0x42)))
Expect(hdr.IsVersionNegotiation).To(BeFalse())
b := bytes.NewReader(data)
extHdr, err := hdr.Parse(b, versionIETFFrames)
Expect(err).ToNot(HaveOccurred())
Expect(extHdr.KeyPhase).To(Equal(0))
Expect(extHdr.DestConnectionID).To(Equal(connID))
Expect(extHdr.SrcConnectionID).To(BeEmpty())
Expect(extHdr.PacketNumber).To(Equal(protocol.PacketNumber(0x42)))
Expect(extHdr.IsVersionNegotiation).To(BeFalse())
Expect(b.Len()).To(BeZero())
})
@ -289,16 +289,16 @@ var _ = Describe("Header Parsing", func() {
connID := protocol.ConnectionID{1, 2, 3, 4, 5}
data := append([]byte{0x30}, connID...)
data = appendPacketNumber(data, 0x42, protocol.PacketNumberLen1)
iHdr, err := ParseInvariantHeader(bytes.NewReader(data), 5)
hdr, err := ParseHeader(bytes.NewReader(data), 5)
Expect(err).ToNot(HaveOccurred())
Expect(iHdr.IsLongHeader).To(BeFalse())
Expect(iHdr.DestConnectionID).To(Equal(connID))
b := bytes.NewReader(data)
hdr, err := iHdr.Parse(b, versionIETFFrames)
Expect(err).ToNot(HaveOccurred())
Expect(hdr.KeyPhase).To(Equal(0))
Expect(hdr.IsLongHeader).To(BeFalse())
Expect(hdr.DestConnectionID).To(Equal(connID))
Expect(hdr.SrcConnectionID).To(BeEmpty())
b := bytes.NewReader(data)
extHdr, err := hdr.Parse(b, versionIETFFrames)
Expect(err).ToNot(HaveOccurred())
Expect(extHdr.KeyPhase).To(Equal(0))
Expect(extHdr.DestConnectionID).To(Equal(connID))
Expect(extHdr.SrcConnectionID).To(BeEmpty())
Expect(b.Len()).To(BeZero())
})
@ -308,13 +308,13 @@ var _ = Describe("Header Parsing", func() {
0xde, 0xad, 0xbe, 0xef, 0xca, 0xfe, // connection ID
}
data = appendPacketNumber(data, 11, protocol.PacketNumberLen1)
iHdr, err := ParseInvariantHeader(bytes.NewReader(data), 6)
hdr, err := ParseHeader(bytes.NewReader(data), 6)
Expect(err).ToNot(HaveOccurred())
b := bytes.NewReader(data)
hdr, err := iHdr.Parse(b, versionIETFFrames)
extHdr, err := hdr.Parse(b, versionIETFFrames)
Expect(err).ToNot(HaveOccurred())
Expect(hdr.IsLongHeader).To(BeFalse())
Expect(hdr.KeyPhase).To(Equal(1))
Expect(extHdr.IsLongHeader).To(BeFalse())
Expect(extHdr.KeyPhase).To(Equal(1))
Expect(b.Len()).To(BeZero())
})
@ -324,14 +324,14 @@ var _ = Describe("Header Parsing", func() {
0xde, 0xad, 0xbe, 0xef, // connection ID
}
data = appendPacketNumber(data, 0x1337, protocol.PacketNumberLen2)
iHdr, err := ParseInvariantHeader(bytes.NewReader(data), 4)
hdr, err := ParseHeader(bytes.NewReader(data), 4)
Expect(err).ToNot(HaveOccurred())
b := bytes.NewReader(data)
hdr, err := iHdr.Parse(b, versionIETFFrames)
extHdr, err := hdr.Parse(b, versionIETFFrames)
Expect(err).ToNot(HaveOccurred())
Expect(hdr.IsLongHeader).To(BeFalse())
Expect(hdr.PacketNumber).To(Equal(protocol.PacketNumber(0x1337)))
Expect(hdr.PacketNumberLen).To(Equal(protocol.PacketNumberLen2))
Expect(extHdr.IsLongHeader).To(BeFalse())
Expect(extHdr.PacketNumber).To(Equal(protocol.PacketNumber(0x1337)))
Expect(extHdr.PacketNumberLen).To(Equal(protocol.PacketNumberLen2))
Expect(b.Len()).To(BeZero())
})
@ -341,24 +341,24 @@ var _ = Describe("Header Parsing", func() {
0xde, 0xad, 0xbe, 0xef, 0xca, 0xfe, 0x1, 0x2, 0x3, 0x4, // connection ID
}
data = appendPacketNumber(data, 0x99beef, protocol.PacketNumberLen4)
iHdr, err := ParseInvariantHeader(bytes.NewReader(data), 10)
hdr, err := ParseHeader(bytes.NewReader(data), 10)
Expect(err).ToNot(HaveOccurred())
b := bytes.NewReader(data)
hdr, err := iHdr.Parse(b, versionIETFFrames)
extHdr, err := hdr.Parse(b, versionIETFFrames)
Expect(err).ToNot(HaveOccurred())
Expect(hdr.IsLongHeader).To(BeFalse())
Expect(hdr.PacketNumber).To(Equal(protocol.PacketNumber(0x99beef)))
Expect(hdr.PacketNumberLen).To(Equal(protocol.PacketNumberLen4))
Expect(extHdr.IsLongHeader).To(BeFalse())
Expect(extHdr.PacketNumber).To(Equal(protocol.PacketNumber(0x99beef)))
Expect(extHdr.PacketNumberLen).To(Equal(protocol.PacketNumberLen4))
Expect(b.Len()).To(BeZero())
})
It("errors on EOF, when parsing the invariant header", func() {
It("errors on EOF, when parsing the header", func() {
data := []byte{
0x30 ^ 0x2,
0xde, 0xad, 0xbe, 0xef, 0xca, 0xfe, 0x13, 0x37, // connection ID
}
for i := 0; i < len(data); i++ {
_, err := ParseInvariantHeader(bytes.NewReader(data[:i]), 8)
_, err := ParseHeader(bytes.NewReader(data[:i]), 8)
Expect(err).To(Equal(io.EOF))
}
})
@ -368,13 +368,13 @@ var _ = Describe("Header Parsing", func() {
0x30 ^ 0x2,
0xde, 0xad, 0xbe, 0xef, 0xca, 0xfe, // connection ID
}
iHdrLen := len(data)
hdrLen := len(data)
data = appendPacketNumber(data, 0xdeadbeef, protocol.PacketNumberLen4)
for i := iHdrLen; i < len(data); i++ {
for i := hdrLen; i < len(data); i++ {
b := bytes.NewReader(data[:i])
iHdr, err := ParseInvariantHeader(b, 6)
hdr, err := ParseHeader(b, 6)
Expect(err).ToNot(HaveOccurred())
_, err = iHdr.Parse(b, versionIETFFrames)
_, err = hdr.Parse(b, versionIETFFrames)
Expect(err).To(Equal(io.EOF))
}
})

16
internal/wire/version_negotiation_test.go
View file

@ -16,19 +16,19 @@ var _ = Describe("Version Negotiation Packets", func() {
data, err := ComposeVersionNegotiation(destConnID, srcConnID, versions)
Expect(err).ToNot(HaveOccurred())
Expect(data[0] & 0x80).ToNot(BeZero())
iHdr, err := ParseInvariantHeader(bytes.NewReader(data), 4)
hdr, err := ParseHeader(bytes.NewReader(data), 4)
Expect(err).ToNot(HaveOccurred())
b := bytes.NewReader(data)
hdr, err := iHdr.Parse(b, versionIETFFrames)
extHdr, err := hdr.Parse(b, versionIETFFrames)
Expect(err).ToNot(HaveOccurred())
Expect(hdr.IsVersionNegotiation).To(BeTrue())
Expect(hdr.DestConnectionID).To(Equal(destConnID))
Expect(hdr.SrcConnectionID).To(Equal(srcConnID))
Expect(hdr.Version).To(BeZero())
Expect(extHdr.IsVersionNegotiation).To(BeTrue())
Expect(extHdr.DestConnectionID).To(Equal(destConnID))
Expect(extHdr.SrcConnectionID).To(Equal(srcConnID))
Expect(extHdr.Version).To(BeZero())
// the supported versions should include one reserved version number
Expect(hdr.SupportedVersions).To(HaveLen(len(versions) + 1))
Expect(extHdr.SupportedVersions).To(HaveLen(len(versions) + 1))
for _, version := range versions {
Expect(hdr.SupportedVersions).To(ContainElement(version))
Expect(extHdr.SupportedVersions).To(ContainElement(version))
}
Expect(b.Len()).To(BeZero())
})

34
packet_handler_map.go
View file

@ -165,14 +165,14 @@ func (h *packetHandlerMap) handlePacket(addr net.Addr, data []byte) error {
rcvTime := time.Now()
r := bytes.NewReader(data)
iHdr, err := wire.ParseInvariantHeader(r, h.connIDLen)
hdr, err := wire.ParseHeader(r, h.connIDLen)
// drop the packet if we can't parse the header
if err != nil {
return fmt.Errorf("error parsing invariant header: %s", err)
return fmt.Errorf("error parsing header: %s", err)
}
h.mutex.RLock()
handlerEntry, handlerFound := h.handlers[string(iHdr.DestConnectionID)]
handlerEntry, handlerFound := h.handlers[string(hdr.DestConnectionID)]
server := h.server
var version protocol.VersionNumber
@ -183,7 +183,7 @@ func (h *packetHandlerMap) handlePacket(addr net.Addr, data []byte) error {
handlePacket = handler.handlePacket
} else { // no session found
// this might be a stateless reset
if !iHdr.IsLongHeader {
if !hdr.IsLongHeader {
if len(data) >= protocol.MinStatelessResetSize {
var token [16]byte
copy(token[:], data[len(data)-16:])
@ -194,39 +194,39 @@ func (h *packetHandlerMap) handlePacket(addr net.Addr, data []byte) error {
}
}
// TODO(#943): send a stateless reset
return fmt.Errorf("received a short header packet with an unexpected connection ID %s", iHdr.DestConnectionID)
return fmt.Errorf("received a short header packet with an unexpected connection ID %s", hdr.DestConnectionID)
}
if server == nil { // no server set
h.mutex.RUnlock()
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", hdr.DestConnectionID)
}
handlePacket = server.handlePacket
version = iHdr.Version
version = hdr.Version
}
h.mutex.RUnlock()
r = bytes.NewReader(data)
hdr, err := iHdr.Parse(r, version)
extHdr, err := hdr.Parse(r, version)
if err != nil {
return fmt.Errorf("error parsing header: %s", err)
return fmt.Errorf("error parsing extended header: %s", err)
}
hdr.Raw = data[:len(data)-r.Len()]
extHdr.Raw = data[:len(data)-r.Len()]
packetData := data[len(data)-r.Len():]
if hdr.IsLongHeader {
if hdr.Length < protocol.ByteCount(hdr.PacketNumberLen) {
return fmt.Errorf("packet length (%d bytes) shorter than packet number (%d bytes)", hdr.Length, hdr.PacketNumberLen)
if extHdr.IsLongHeader {
if extHdr.Length < protocol.ByteCount(extHdr.PacketNumberLen) {
return fmt.Errorf("packet length (%d bytes) shorter than packet number (%d bytes)", extHdr.Length, extHdr.PacketNumberLen)
}
if protocol.ByteCount(len(packetData))+protocol.ByteCount(hdr.PacketNumberLen) < hdr.Length {
return fmt.Errorf("packet length (%d bytes) is smaller than the expected length (%d bytes)", len(packetData)+int(hdr.PacketNumberLen), hdr.Length)
if protocol.ByteCount(len(packetData))+protocol.ByteCount(extHdr.PacketNumberLen) < extHdr.Length {
return fmt.Errorf("packet length (%d bytes) is smaller than the expected length (%d bytes)", len(packetData)+int(extHdr.PacketNumberLen), extHdr.Length)
}
packetData = packetData[:int(hdr.Length)-int(hdr.PacketNumberLen)]
packetData = packetData[:int(extHdr.Length)-int(extHdr.PacketNumberLen)]
// TODO(#1312): implement parsing of compound packets
}
handlePacket(&receivedPacket{
remoteAddr: addr,
header: hdr,
header: extHdr,
data: packetData,
rcvTime: rcvTime,
})

2
packet_handler_map_test.go
View file

@ -83,7 +83,7 @@ var _ = Describe("Packet Handler Map", func() {
It("drops unparseable packets", func() {
err := handler.handlePacket(nil, []byte{0, 1, 2, 3})
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("error parsing invariant header:"))
Expect(err.Error()).To(ContainSubstring("error parsing header:"))
})
It("deletes removed session immediately", func() {

6
packet_packer_test.go
View file

@ -31,12 +31,12 @@ var _ = Describe("Packet packer", func() {
)
checkLength := func(data []byte) {
iHdr, err := wire.ParseInvariantHeader(bytes.NewReader(data), 0)
hdr, err := wire.ParseHeader(bytes.NewReader(data), 0)
Expect(err).ToNot(HaveOccurred())
r := bytes.NewReader(data)
hdr, err := iHdr.Parse(r, protocol.VersionWhatever)
extHdr, err := hdr.Parse(r, protocol.VersionWhatever)
Expect(err).ToNot(HaveOccurred())
ExpectWithOffset(0, hdr.Length).To(BeEquivalentTo(r.Len() + int(hdr.PacketNumberLen)))
ExpectWithOffset(0, extHdr.Length).To(BeEquivalentTo(r.Len() + int(extHdr.PacketNumberLen)))
}
expectAppendStreamFrames := func(frames ...wire.Frame) {

6
server_test.go
View file

@ -99,11 +99,11 @@ var _ = Describe("Server", func() {
})
parseHeader := func(data []byte) *wire.ExtendedHeader {
iHdr, err := wire.ParseInvariantHeader(bytes.NewReader(data), 0)
hdr, err := wire.ParseHeader(bytes.NewReader(data), 0)
Expect(err).ToNot(HaveOccurred())
hdr, err := iHdr.Parse(bytes.NewReader(data), protocol.VersionTLS)
extHdr, err := hdr.Parse(bytes.NewReader(data), protocol.VersionTLS)
Expect(err).ToNot(HaveOccurred())
return hdr
return extHdr
}
It("drops Initial packets with a too short connection ID", func() {