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

refactor header writing to append to a byte slice (#3646)

Browse source 
This avoids having to allocate a bytes.Buffer.
This commit is contained in:
Marten Seemann 2023-01-17 01:56:06 -08:00 • committed by GitHub
parent 3d4bbc28ba
commit c24fbb094c
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
18 changed files with 282 additions and 279 deletions
Download patch file Download diff file Expand all files Collapse all files

18
quicvarint/varint.go
View file

@ -107,32 +107,32 @@ func Append(b []byte, i uint64) []byte {
panic(fmt.Sprintf("%#x doesn't fit into 62 bits", i))
}
// WriteWithLen writes i in the QUIC varint format with the desired length to w.
func WriteWithLen(w Writer, i uint64, length protocol.ByteCount) {
// AppendWithLen append i in the QUIC varint format with the desired length.
func AppendWithLen(b []byte, i uint64, length protocol.ByteCount) []byte {
if length != 1 && length != 2 && length != 4 && length != 8 {
panic("invalid varint length")
}
l := Len(i)
if l == length {
Write(w, i)
return
return Append(b, i)
}
if l > length {
panic(fmt.Sprintf("cannot encode %d in %d bytes", i, length))
}
if length == 2 {
w.WriteByte(0b01000000)
b = append(b, 0b01000000)
} else if length == 4 {
w.WriteByte(0b10000000)
b = append(b, 0b10000000)
} else if length == 8 {
w.WriteByte(0b11000000)
b = append(b, 0b11000000)
}
for j := protocol.ByteCount(1); j < length-l; j++ {
w.WriteByte(0)
b = append(b, 0)
}
for j := protocol.ByteCount(0); j < l; j++ {
w.WriteByte(uint8(i >> (8 * (l - 1 - j))))
b = append(b, uint8(i>>(8*(l-1-j))))
}
return b
}
// Len determines the number of bytes that will be needed to write the number i.

47
quicvarint/varint_test.go
View file

@ -142,54 +142,47 @@ var _ = Describe("Varint encoding / decoding", func() {
Context("with fixed length", func() {
It("panics when given an invalid length", func() {
Expect(func() { WriteWithLen(&bytes.Buffer{}, 25, 3) }).Should(Panic())
Expect(func() { AppendWithLen(nil, 25, 3) }).Should(Panic())
})
It("panics when given a too short length", func() {
Expect(func() { WriteWithLen(&bytes.Buffer{}, maxVarInt1+1, 1) }).Should(Panic())
Expect(func() { WriteWithLen(&bytes.Buffer{}, maxVarInt2+1, 2) }).Should(Panic())
Expect(func() { WriteWithLen(&bytes.Buffer{}, maxVarInt4+1, 4) }).Should(Panic())
Expect(func() { AppendWithLen(nil, maxVarInt1+1, 1) }).Should(Panic())
Expect(func() { AppendWithLen(nil, maxVarInt2+1, 2) }).Should(Panic())
Expect(func() { AppendWithLen(nil, maxVarInt4+1, 4) }).Should(Panic())
})
It("writes a 1-byte number in minimal encoding", func() {
b := &bytes.Buffer{}
WriteWithLen(b, 37, 1)
Expect(b.Bytes()).To(Equal([]byte{0x25}))
Expect(AppendWithLen(nil, 37, 1)).To(Equal([]byte{0x25}))
})
It("writes a 1-byte number in 2 bytes", func() {
b := &bytes.Buffer{}
WriteWithLen(b, 37, 2)
Expect(b.Bytes()).To(Equal([]byte{0b01000000, 0x25}))
Expect(Read(b)).To(BeEquivalentTo(37))
b := AppendWithLen(nil, 37, 2)
Expect(b).To(Equal([]byte{0b01000000, 0x25}))
Expect(Read(bytes.NewReader(b))).To(BeEquivalentTo(37))
})
It("writes a 1-byte number in 4 bytes", func() {
b := &bytes.Buffer{}
WriteWithLen(b, 37, 4)
Expect(b.Bytes()).To(Equal([]byte{0b10000000, 0, 0, 0x25}))
Expect(Read(b)).To(BeEquivalentTo(37))
b := AppendWithLen(nil, 37, 4)
Expect(b).To(Equal([]byte{0b10000000, 0, 0, 0x25}))
Expect(Read(bytes.NewReader(b))).To(BeEquivalentTo(37))
})
It("writes a 1-byte number in 8 bytes", func() {
b := &bytes.Buffer{}
WriteWithLen(b, 37, 8)
Expect(b.Bytes()).To(Equal([]byte{0b11000000, 0, 0, 0, 0, 0, 0, 0x25}))
Expect(Read(b)).To(BeEquivalentTo(37))
b := AppendWithLen(nil, 37, 8)
Expect(b).To(Equal([]byte{0b11000000, 0, 0, 0, 0, 0, 0, 0x25}))
Expect(Read(bytes.NewReader(b))).To(BeEquivalentTo(37))
})
It("writes a 2-byte number in 4 bytes", func() {
b := &bytes.Buffer{}
WriteWithLen(b, 15293, 4)
Expect(b.Bytes()).To(Equal([]byte{0b10000000, 0, 0x3b, 0xbd}))
Expect(Read(b)).To(BeEquivalentTo(15293))
b := AppendWithLen(nil, 15293, 4)
Expect(b).To(Equal([]byte{0b10000000, 0, 0x3b, 0xbd}))
Expect(Read(bytes.NewReader(b))).To(BeEquivalentTo(15293))
})
It("write a 4-byte number in 8 bytes", func() {
b := &bytes.Buffer{}
WriteWithLen(b, 494878333, 8)
Expect(b.Bytes()).To(Equal([]byte{0b11000000, 0, 0, 0, 0x1d, 0x7f, 0x3e, 0x7d}))
Expect(Read(b)).To(BeEquivalentTo(494878333))
b := AppendWithLen(nil, 494878333, 8)
Expect(b).To(Equal([]byte{0b11000000, 0, 0, 0, 0x1d, 0x7f, 0x3e, 0x7d}))
Expect(Read(bytes.NewReader(b))).To(BeEquivalentTo(494878333))
})
})