wire: simplify packet number parsing, remove utils.ByteOrder interface (#4590)

internal/utils/byteoder_big_endian_test.go

@@ -1,124 +0,0 @@
-package utils
-
-import (
-	"bytes"
-	"io"
-
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-var _ = Describe("Big Endian encoding / decoding", func() {
-	Context("converting", func() {
-		It("Uint16", func() {
-			b := []byte{0x13, 0x37}
-			Expect(BigEndian.Uint16(b)).To(Equal(uint16(0x1337)))
-		})
-
-		It("Uint24", func() {
-			b := []byte{0x13, 0x99, 0x37}
-			Expect(BigEndian.Uint24(b)).To(Equal(uint32(0x139937)))
-		})
-
-		It("Uint32", func() {
-			b := []byte{0xde, 0xad, 0xbe, 0xef}
-			Expect(BigEndian.Uint32(b)).To(Equal(uint32(0xdeadbeef)))
-		})
-	})
-
-	Context("ReadUint16", func() {
-		It("reads a big endian", func() {
-			b := []byte{0x13, 0xEF}
-			val, err := BigEndian.ReadUint16(bytes.NewReader(b))
-			Expect(err).ToNot(HaveOccurred())
-			Expect(val).To(Equal(uint16(0x13EF)))
-		})
-
-		It("throws an error if less than 2 bytes are passed", func() {
-			b := []byte{0x13, 0xEF}
-			for i := 0; i < len(b); i++ {
-				_, err := BigEndian.ReadUint16(bytes.NewReader(b[:i]))
-				Expect(err).To(MatchError(io.EOF))
-			}
-		})
-	})
-
-	Context("ReadUint24", func() {
-		It("reads a big endian", func() {
-			b := []byte{0x13, 0xbe, 0xef}
-			val, err := BigEndian.ReadUint24(bytes.NewReader(b))
-			Expect(err).ToNot(HaveOccurred())
-			Expect(val).To(Equal(uint32(0x13beef)))
-		})
-
-		It("throws an error if less than 3 bytes are passed", func() {
-			b := []byte{0x13, 0xbe, 0xef}
-			for i := 0; i < len(b); i++ {
-				_, err := BigEndian.ReadUint24(bytes.NewReader(b[:i]))
-				Expect(err).To(MatchError(io.EOF))
-			}
-		})
-	})
-
-	Context("ReadUint32", func() {
-		It("reads a big endian", func() {
-			b := []byte{0x12, 0x35, 0xAB, 0xFF}
-			val, err := BigEndian.ReadUint32(bytes.NewReader(b))
-			Expect(err).ToNot(HaveOccurred())
-			Expect(val).To(Equal(uint32(0x1235ABFF)))
-		})
-
-		It("throws an error if less than 4 bytes are passed", func() {
-			b := []byte{0x12, 0x35, 0xAB, 0xFF}
-			for i := 0; i < len(b); i++ {
-				_, err := BigEndian.ReadUint32(bytes.NewReader(b[:i]))
-				Expect(err).To(MatchError(io.EOF))
-			}
-		})
-	})
-
-	Context("WriteUint16", func() {
-		It("outputs 2 bytes", func() {
-			b := &bytes.Buffer{}
-			BigEndian.WriteUint16(b, uint16(1))
-			Expect(b.Len()).To(Equal(2))
-		})
-
-		It("outputs a big endian", func() {
-			num := uint16(0xFF11)
-			b := &bytes.Buffer{}
-			BigEndian.WriteUint16(b, num)
-			Expect(b.Bytes()).To(Equal([]byte{0xFF, 0x11}))
-		})
-	})
-
-	Context("WriteUint24", func() {
-		It("outputs 3 bytes", func() {
-			b := &bytes.Buffer{}
-			BigEndian.WriteUint24(b, uint32(1))
-			Expect(b.Len()).To(Equal(3))
-		})
-
-		It("outputs a big endian", func() {
-			num := uint32(0xff11aa)
-			b := &bytes.Buffer{}
-			BigEndian.WriteUint24(b, num)
-			Expect(b.Bytes()).To(Equal([]byte{0xff, 0x11, 0xaa}))
-		})
-	})
-
-	Context("WriteUint32", func() {
-		It("outputs 4 bytes", func() {
-			b := &bytes.Buffer{}
-			BigEndian.WriteUint32(b, uint32(1))
-			Expect(b.Len()).To(Equal(4))
-		})
-
-		It("outputs a big endian", func() {
-			num := uint32(0xEFAC3512)
-			b := &bytes.Buffer{}
-			BigEndian.WriteUint32(b, num)
-			Expect(b.Bytes()).To(Equal([]byte{0xEF, 0xAC, 0x35, 0x12}))
-		})
-	})
-})

internal/utils/byteorder.go

@@ -1,21 +0,0 @@
-package utils
-
-import (
-	"bytes"
-	"io"
-)
-
-// A ByteOrder specifies how to convert byte sequences into 16-, 32-, or 64-bit unsigned integers.
-type ByteOrder interface {
-	Uint32([]byte) uint32
-	Uint24([]byte) uint32
-	Uint16([]byte) uint16
-
-	ReadUint32(io.ByteReader) (uint32, error)
-	ReadUint24(io.ByteReader) (uint32, error)
-	ReadUint16(io.ByteReader) (uint16, error)
-
-	WriteUint32(*bytes.Buffer, uint32)
-	WriteUint24(*bytes.Buffer, uint32)
-	WriteUint16(*bytes.Buffer, uint16)
-}

internal/utils/byteorder_big_endian.go

@@ -1,103 +0,0 @@
-package utils
-
-import (
-	"bytes"
-	"encoding/binary"
-	"io"
-)
-
-// BigEndian is the big-endian implementation of ByteOrder.
-var BigEndian ByteOrder = bigEndian{}
-
-type bigEndian struct{}
-
-var _ ByteOrder = &bigEndian{}
-
-// ReadUintN reads N bytes
-func (bigEndian) ReadUintN(b io.ByteReader, length uint8) (uint64, error) {
-	var res uint64
-	for i := uint8(0); i < length; i++ {
-		bt, err := b.ReadByte()
-		if err != nil {
-			return 0, err
-		}
-		res ^= uint64(bt) << ((length - 1 - i) * 8)
-	}
-	return res, nil
-}
-
-// ReadUint32 reads a uint32
-func (bigEndian) ReadUint32(b io.ByteReader) (uint32, error) {
-	var b1, b2, b3, b4 uint8
-	var err error
-	if b4, err = b.ReadByte(); err != nil {
-		return 0, err
-	}
-	if b3, err = b.ReadByte(); err != nil {
-		return 0, err
-	}
-	if b2, err = b.ReadByte(); err != nil {
-		return 0, err
-	}
-	if b1, err = b.ReadByte(); err != nil {
-		return 0, err
-	}
-	return uint32(b1) + uint32(b2)<<8 + uint32(b3)<<16 + uint32(b4)<<24, nil
-}
-
-// ReadUint24 reads a uint24
-func (bigEndian) ReadUint24(b io.ByteReader) (uint32, error) {
-	var b1, b2, b3 uint8
-	var err error
-	if b3, err = b.ReadByte(); err != nil {
-		return 0, err
-	}
-	if b2, err = b.ReadByte(); err != nil {
-		return 0, err
-	}
-	if b1, err = b.ReadByte(); err != nil {
-		return 0, err
-	}
-	return uint32(b1) + uint32(b2)<<8 + uint32(b3)<<16, nil
-}
-
-// ReadUint16 reads a uint16
-func (bigEndian) ReadUint16(b io.ByteReader) (uint16, error) {
-	var b1, b2 uint8
-	var err error
-	if b2, err = b.ReadByte(); err != nil {
-		return 0, err
-	}
-	if b1, err = b.ReadByte(); err != nil {
-		return 0, err
-	}
-	return uint16(b1) + uint16(b2)<<8, nil
-}
-
-func (bigEndian) Uint32(b []byte) uint32 {
-	return binary.BigEndian.Uint32(b)
-}
-
-func (bigEndian) Uint24(b []byte) uint32 {
-	_ = b[2] // bounds check hint to compiler; see golang.org/issue/14808
-	return uint32(b[2]) | uint32(b[1])<<8 | uint32(b[0])<<16
-}
-
-func (bigEndian) Uint16(b []byte) uint16 {
-	return binary.BigEndian.Uint16(b)
-}
-
-// WriteUint32 writes a uint32
-func (bigEndian) WriteUint32(b *bytes.Buffer, i uint32) {
-	b.Write([]byte{uint8(i >> 24), uint8(i >> 16), uint8(i >> 8), uint8(i)})
-}
-
-// WriteUint24 writes a uint24
-func (bigEndian) WriteUint24(b *bytes.Buffer, i uint32) {
-	b.Write([]byte{uint8(i >> 16), uint8(i >> 8), uint8(i)})
-}
-
-// WriteUint16 writes a uint16
-func (bigEndian) WriteUint16(b *bytes.Buffer, i uint16) {
-	b.Write([]byte{uint8(i >> 8), uint8(i)})
-}

internal/wire/header.go

@@ -8,7 +8,6 @@ import (
 	"io"
 
 	"github.com/quic-go/quic-go/internal/protocol"
-	"github.com/quic-go/quic-go/internal/utils"
 	"github.com/quic-go/quic-go/quicvarint"
 )
 
@@ -302,11 +301,11 @@ func readPacketNumber(data []byte, pnLen protocol.PacketNumberLen) (protocol.Pac
 	case protocol.PacketNumberLen1:
 		pn = protocol.PacketNumber(data[0])
 	case protocol.PacketNumberLen2:
-		pn = protocol.PacketNumber(utils.BigEndian.Uint16(data[:2]))
+		pn = protocol.PacketNumber(binary.BigEndian.Uint16(data[:2]))
 	case protocol.PacketNumberLen3:
-		pn = protocol.PacketNumber(utils.BigEndian.Uint24(data[:3]))
+		pn = protocol.PacketNumber(uint32(data[2]) + uint32(data[1])<<8 + uint32(data[0])<<16)
 	case protocol.PacketNumberLen4:
-		pn = protocol.PacketNumber(utils.BigEndian.Uint32(data[:4]))
+		pn = protocol.PacketNumber(binary.BigEndian.Uint32(data[:4]))
 	default:
 		return 0, fmt.Errorf("invalid packet number length: %d", pnLen)
 	}