mirror of
https://github.com/refraction-networking/uquic.git
synced 2025-04-03 20:27:35 +03:00
move varint encoding / decoding to a separate package
... which is not internal.
This commit is contained in:
Marten Seemann
parent
602212e983
commit
11c5045065
47 changed files with 319 additions and 286 deletions
13
quicvarint/quicvarint_suite_test.go
Normal file
13
quicvarint/quicvarint_suite_test.go
Normal file
|
|
@ -0,0 +1,13 @@
|
|||
package quicvarint_test
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
. "github.com/onsi/ginkgo"
|
||||
. "github.com/onsi/gomega"
|
||||
)
|
||||
|
||||
func TestQuicVarint(t *testing.T) {
|
||||
RegisterFailHandler(Fail)
|
||||
RunSpecs(t, "QUIC Varint Suite")
|
||||
}
|
||||
134
quicvarint/varint.go
Normal file
134
quicvarint/varint.go
Normal file
|
|
@ -0,0 +1,134 @@
|
|||
package quicvarint
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"io"
|
||||
|
||||
"github.com/lucas-clemente/quic-go/internal/protocol"
|
||||
)
|
||||
|
||||
// taken from the QUIC draft
|
||||
const (
|
||||
maxVarInt1 = 63
|
||||
maxVarInt2 = 16383
|
||||
maxVarInt4 = 1073741823
|
||||
maxVarInt8 = 4611686018427387903
|
||||
)
|
||||
|
||||
// ReadVarInt reads a number in the QUIC varint format
|
||||
func ReadVarInt(b io.ByteReader) (uint64, error) {
|
||||
firstByte, err := b.ReadByte()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
// the first two bits of the first byte encode the length
|
||||
len := 1 << ((firstByte & 0xc0) >> 6)
|
||||
b1 := firstByte & (0xff - 0xc0)
|
||||
if len == 1 {
|
||||
return uint64(b1), nil
|
||||
}
|
||||
b2, err := b.ReadByte()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
if len == 2 {
|
||||
return uint64(b2) + uint64(b1)<<8, nil
|
||||
}
|
||||
b3, err := b.ReadByte()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
b4, err := b.ReadByte()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
if len == 4 {
|
||||
return uint64(b4) + uint64(b3)<<8 + uint64(b2)<<16 + uint64(b1)<<24, nil
|
||||
}
|
||||
b5, err := b.ReadByte()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
b6, err := b.ReadByte()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
b7, err := b.ReadByte()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
b8, err := b.ReadByte()
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
return uint64(b8) + uint64(b7)<<8 + uint64(b6)<<16 + uint64(b5)<<24 + uint64(b4)<<32 + uint64(b3)<<40 + uint64(b2)<<48 + uint64(b1)<<56, nil
|
||||
}
|
||||
|
||||
// WriteVarInt writes a number in the QUIC varint format
|
||||
func WriteVarInt(b *bytes.Buffer, i uint64) {
|
||||
if i <= maxVarInt1 {
|
||||
b.WriteByte(uint8(i))
|
||||
} else if i <= maxVarInt2 {
|
||||
b.Write([]byte{uint8(i>>8) | 0x40, uint8(i)})
|
||||
} else if i <= maxVarInt4 {
|
||||
b.Write([]byte{uint8(i>>24) | 0x80, uint8(i >> 16), uint8(i >> 8), uint8(i)})
|
||||
} else if i <= maxVarInt8 {
|
||||
b.Write([]byte{
|
||||
uint8(i>>56) | 0xc0, uint8(i >> 48), uint8(i >> 40), uint8(i >> 32),
|
||||
uint8(i >> 24), uint8(i >> 16), uint8(i >> 8), uint8(i),
|
||||
})
|
||||
} else {
|
||||
panic(fmt.Sprintf("%#x doesn't fit into 62 bits", i))
|
||||
}
|
||||
}
|
||||
|
||||
// WriteVarIntWithLen writes a number in the QUIC varint format, with the desired length.
|
||||
func WriteVarIntWithLen(b *bytes.Buffer, i uint64, length protocol.ByteCount) {
|
||||
if length != 1 && length != 2 && length != 4 && length != 8 {
|
||||
panic("invalid varint length")
|
||||
}
|
||||
l := VarIntLen(i)
|
||||
if l == length {
|
||||
WriteVarInt(b, i)
|
||||
return
|
||||
}
|
||||
if l > length {
|
||||
panic(fmt.Sprintf("cannot encode %d in %d bytes", i, length))
|
||||
}
|
||||
if length == 2 {
|
||||
b.WriteByte(0b01000000)
|
||||
} else if length == 4 {
|
||||
b.WriteByte(0b10000000)
|
||||
} else if length == 8 {
|
||||
b.WriteByte(0b11000000)
|
||||
}
|
||||
for j := protocol.ByteCount(1); j < length-l; j++ {
|
||||
b.WriteByte(0)
|
||||
}
|
||||
for j := protocol.ByteCount(0); j < l; j++ {
|
||||
b.WriteByte(uint8(i >> (8 * (l - 1 - j))))
|
||||
}
|
||||
}
|
||||
|
||||
// VarIntLen determines the number of bytes that will be needed to write a number
|
||||
func VarIntLen(i uint64) protocol.ByteCount {
|
||||
if i <= maxVarInt1 {
|
||||
return 1
|
||||
}
|
||||
if i <= maxVarInt2 {
|
||||
return 2
|
||||
}
|
||||
if i <= maxVarInt4 {
|
||||
return 4
|
||||
}
|
||||
if i <= maxVarInt8 {
|
||||
return 8
|
||||
}
|
||||
// Don't use a fmt.Sprintf here to format the error message.
|
||||
// The function would then exceed the inlining budget.
|
||||
panic(struct {
|
||||
message string
|
||||
num uint64
|
||||
}{"value doesn't fit into 62 bits: ", i})
|
||||
}
|
||||
211
quicvarint/varint_test.go
Normal file
211
quicvarint/varint_test.go
Normal file
|
|
@ -0,0 +1,211 @@
|
|||
package quicvarint
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
|
||||
. "github.com/onsi/ginkgo"
|
||||
. "github.com/onsi/gomega"
|
||||
)
|
||||
|
||||
var _ = Describe("Varint encoding / decoding", func() {
|
||||
Context("decoding", func() {
|
||||
It("reads a 1 byte number", func() {
|
||||
b := bytes.NewReader([]byte{0b00011001})
|
||||
val, err := ReadVarInt(b)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(val).To(Equal(uint64(25)))
|
||||
Expect(b.Len()).To(BeZero())
|
||||
})
|
||||
|
||||
It("reads a number that is encoded too long", func() {
|
||||
b := bytes.NewReader([]byte{0b01000000, 0x25})
|
||||
val, err := ReadVarInt(b)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(val).To(Equal(uint64(37)))
|
||||
Expect(b.Len()).To(BeZero())
|
||||
})
|
||||
|
||||
It("reads a 2 byte number", func() {
|
||||
b := bytes.NewReader([]byte{0b01111011, 0xbd})
|
||||
val, err := ReadVarInt(b)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(val).To(Equal(uint64(15293)))
|
||||
Expect(b.Len()).To(BeZero())
|
||||
})
|
||||
|
||||
It("reads a 4 byte number", func() {
|
||||
b := bytes.NewReader([]byte{0b10011101, 0x7f, 0x3e, 0x7d})
|
||||
val, err := ReadVarInt(b)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(val).To(Equal(uint64(494878333)))
|
||||
Expect(b.Len()).To(BeZero())
|
||||
})
|
||||
|
||||
It("reads an 8 byte number", func() {
|
||||
b := bytes.NewReader([]byte{0b11000010, 0x19, 0x7c, 0x5e, 0xff, 0x14, 0xe8, 0x8c})
|
||||
val, err := ReadVarInt(b)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(val).To(Equal(uint64(151288809941952652)))
|
||||
Expect(b.Len()).To(BeZero())
|
||||
})
|
||||
})
|
||||
|
||||
Context("encoding", func() {
|
||||
Context("with minimal length", func() {
|
||||
It("writes a 1 byte number", func() {
|
||||
b := &bytes.Buffer{}
|
||||
WriteVarInt(b, 37)
|
||||
Expect(b.Bytes()).To(Equal([]byte{0x25}))
|
||||
})
|
||||
|
||||
It("writes the maximum 1 byte number in 1 byte", func() {
|
||||
b := &bytes.Buffer{}
|
||||
WriteVarInt(b, maxVarInt1)
|
||||
Expect(b.Bytes()).To(Equal([]byte{0b00111111}))
|
||||
})
|
||||
|
||||
It("writes the minimum 2 byte number in 2 bytes", func() {
|
||||
b := &bytes.Buffer{}
|
||||
WriteVarInt(b, maxVarInt1+1)
|
||||
Expect(b.Bytes()).To(Equal([]byte{0x40, maxVarInt1 + 1}))
|
||||
})
|
||||
|
||||
It("writes a 2 byte number", func() {
|
||||
b := &bytes.Buffer{}
|
||||
WriteVarInt(b, 15293)
|
||||
Expect(b.Bytes()).To(Equal([]byte{0b01000000 ^ 0x3b, 0xbd}))
|
||||
})
|
||||
|
||||
It("writes the maximum 2 byte number in 2 bytes", func() {
|
||||
b := &bytes.Buffer{}
|
||||
WriteVarInt(b, maxVarInt2)
|
||||
Expect(b.Bytes()).To(Equal([]byte{0b01111111, 0xff}))
|
||||
})
|
||||
|
||||
It("writes the minimum 4 byte number in 4 bytes", func() {
|
||||
b := &bytes.Buffer{}
|
||||
WriteVarInt(b, maxVarInt2+1)
|
||||
Expect(b.Len()).To(Equal(4))
|
||||
num, err := ReadVarInt(b)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(num).To(Equal(uint64(maxVarInt2 + 1)))
|
||||
})
|
||||
|
||||
It("writes a 4 byte number", func() {
|
||||
b := &bytes.Buffer{}
|
||||
WriteVarInt(b, 494878333)
|
||||
Expect(b.Bytes()).To(Equal([]byte{0b10000000 ^ 0x1d, 0x7f, 0x3e, 0x7d}))
|
||||
})
|
||||
|
||||
It("writes the maximum 4 byte number in 4 bytes", func() {
|
||||
b := &bytes.Buffer{}
|
||||
WriteVarInt(b, maxVarInt4)
|
||||
Expect(b.Bytes()).To(Equal([]byte{0b10111111, 0xff, 0xff, 0xff}))
|
||||
})
|
||||
|
||||
It("writes the minimum 8 byte number in 8 bytes", func() {
|
||||
b := &bytes.Buffer{}
|
||||
WriteVarInt(b, maxVarInt4+1)
|
||||
Expect(b.Len()).To(Equal(8))
|
||||
num, err := ReadVarInt(b)
|
||||
Expect(err).ToNot(HaveOccurred())
|
||||
Expect(num).To(Equal(uint64(maxVarInt4 + 1)))
|
||||
})
|
||||
|
||||
It("writes an 8 byte number", func() {
|
||||
b := &bytes.Buffer{}
|
||||
WriteVarInt(b, 151288809941952652)
|
||||
Expect(b.Bytes()).To(Equal([]byte{0xc2, 0x19, 0x7c, 0x5e, 0xff, 0x14, 0xe8, 0x8c}))
|
||||
})
|
||||
|
||||
It("writes the maximum 8 byte number in 8 bytes", func() {
|
||||
b := &bytes.Buffer{}
|
||||
WriteVarInt(b, maxVarInt8)
|
||||
Expect(b.Bytes()).To(Equal([]byte{0xff /* 11111111 */, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}))
|
||||
})
|
||||
|
||||
It("panics when given a too large number (> 62 bit)", func() {
|
||||
Expect(func() { WriteVarInt(&bytes.Buffer{}, maxVarInt8+1) }).Should(Panic())
|
||||
})
|
||||
})
|
||||
|
||||
Context("with fixed length", func() {
|
||||
It("panics when given an invalid length", func() {
|
||||
Expect(func() { WriteVarIntWithLen(&bytes.Buffer{}, 25, 3) }).Should(Panic())
|
||||
})
|
||||
|
||||
It("panics when given a too short length", func() {
|
||||
Expect(func() { WriteVarIntWithLen(&bytes.Buffer{}, maxVarInt1+1, 1) }).Should(Panic())
|
||||
Expect(func() { WriteVarIntWithLen(&bytes.Buffer{}, maxVarInt2+1, 2) }).Should(Panic())
|
||||
Expect(func() { WriteVarIntWithLen(&bytes.Buffer{}, maxVarInt4+1, 4) }).Should(Panic())
|
||||
})
|
||||
|
||||
It("writes a 1-byte number in minimal encoding", func() {
|
||||
b := &bytes.Buffer{}
|
||||
WriteVarIntWithLen(b, 37, 1)
|
||||
Expect(b.Bytes()).To(Equal([]byte{0x25}))
|
||||
})
|
||||
|
||||
It("writes a 1-byte number in 2 bytes", func() {
|
||||
b := &bytes.Buffer{}
|
||||
WriteVarIntWithLen(b, 37, 2)
|
||||
Expect(b.Bytes()).To(Equal([]byte{0b01000000, 0x25}))
|
||||
Expect(ReadVarInt(b)).To(BeEquivalentTo(37))
|
||||
})
|
||||
|
||||
It("writes a 1-byte number in 4 bytes", func() {
|
||||
b := &bytes.Buffer{}
|
||||
WriteVarIntWithLen(b, 37, 4)
|
||||
Expect(b.Bytes()).To(Equal([]byte{0b10000000, 0, 0, 0x25}))
|
||||
Expect(ReadVarInt(b)).To(BeEquivalentTo(37))
|
||||
})
|
||||
|
||||
It("writes a 1-byte number in 8 bytes", func() {
|
||||
b := &bytes.Buffer{}
|
||||
WriteVarIntWithLen(b, 37, 8)
|
||||
Expect(b.Bytes()).To(Equal([]byte{0b11000000, 0, 0, 0, 0, 0, 0, 0x25}))
|
||||
Expect(ReadVarInt(b)).To(BeEquivalentTo(37))
|
||||
})
|
||||
|
||||
It("writes a 2-byte number in 4 bytes", func() {
|
||||
b := &bytes.Buffer{}
|
||||
WriteVarIntWithLen(b, 15293, 4)
|
||||
Expect(b.Bytes()).To(Equal([]byte{0b10000000, 0, 0x3b, 0xbd}))
|
||||
Expect(ReadVarInt(b)).To(BeEquivalentTo(15293))
|
||||
})
|
||||
|
||||
It("write a 4-byte number in 8 bytes", func() {
|
||||
b := &bytes.Buffer{}
|
||||
WriteVarIntWithLen(b, 494878333, 8)
|
||||
Expect(b.Bytes()).To(Equal([]byte{0b11000000, 0, 0, 0, 0x1d, 0x7f, 0x3e, 0x7d}))
|
||||
Expect(ReadVarInt(b)).To(BeEquivalentTo(494878333))
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
Context("determining the length needed for encoding", func() {
|
||||
It("for numbers that need 1 byte", func() {
|
||||
Expect(VarIntLen(0)).To(BeEquivalentTo(1))
|
||||
Expect(VarIntLen(maxVarInt1)).To(BeEquivalentTo(1))
|
||||
})
|
||||
|
||||
It("for numbers that need 2 bytes", func() {
|
||||
Expect(VarIntLen(maxVarInt1 + 1)).To(BeEquivalentTo(2))
|
||||
Expect(VarIntLen(maxVarInt2)).To(BeEquivalentTo(2))
|
||||
})
|
||||
|
||||
It("for numbers that need 4 bytes", func() {
|
||||
Expect(VarIntLen(maxVarInt2 + 1)).To(BeEquivalentTo(4))
|
||||
Expect(VarIntLen(maxVarInt4)).To(BeEquivalentTo(4))
|
||||
})
|
||||
|
||||
It("for numbers that need 8 bytes", func() {
|
||||
Expect(VarIntLen(maxVarInt4 + 1)).To(BeEquivalentTo(8))
|
||||
Expect(VarIntLen(maxVarInt8)).To(BeEquivalentTo(8))
|
||||
})
|
||||
|
||||
It("panics when given a too large number (> 62 bit)", func() {
|
||||
Expect(func() { VarIntLen(maxVarInt8 + 1) }).Should(Panic())
|
||||
})
|
||||
})
|
||||
})
|
||||
Loading…
Add table
Add a link
Reference in a new issue