hoelee/cloudflared
1
0
Fork 0
mirror of https://github.com/cloudflare/cloudflared.git synced 2025-07-28 21:39:58 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

TUN-4961: Update quic-go to latest

Browse Source 
- Updates fips-go to be the latest on cfsetup.yaml
- Updates sumtype's x/tools to be latest to avoid Internal: nil pkg
  errors with fips.
This commit is contained in:
Sudarsan Reddy
2021-08-27 12:26:00 +01:00
parent d0a1daac3b
commit 414cb12f02
585 changed files with 61873 additions and 6255 deletions
Download Patch File Download Diff File Expand all files Collapse all files

57
vendor/github.com/lucas-clemente/quic-go/quicvarint/varint.go generated vendored
View File

@@ -1,7 +1,6 @@
package quicvarint
import (
"bytes"
"fmt"
"io"
@@ -10,15 +9,21 @@ import (
// taken from the QUIC draft
const (
// Min is the minimum value allowed for a QUIC varint.
Min = 0
// Max is the maximum allowed value for a QUIC varint (2^62-1).
Max = maxVarInt8
maxVarInt1 = 63
maxVarInt2 = 16383
maxVarInt4 = 1073741823
maxVarInt8 = 4611686018427387903
)
// Read reads a number in the QUIC varint format
func Read(b io.ByteReader) (uint64, error) {
firstByte, err := b.ReadByte()
// Read reads a number in the QUIC varint format from r.
func Read(r io.ByteReader) (uint64, error) {
firstByte, err := r.ReadByte()
if err != nil {
return 0, err
}
@@ -28,53 +33,53 @@ func Read(b io.ByteReader) (uint64, error) {
if len == 1 {
return uint64(b1), nil
}
b2, err := b.ReadByte()
b2, err := r.ReadByte()
if err != nil {
return 0, err
}
if len == 2 {
return uint64(b2) + uint64(b1)<<8, nil
}
b3, err := b.ReadByte()
b3, err := r.ReadByte()
if err != nil {
return 0, err
}
b4, err := b.ReadByte()
b4, err := r.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()
b5, err := r.ReadByte()
if err != nil {
return 0, err
}
b6, err := b.ReadByte()
b6, err := r.ReadByte()
if err != nil {
return 0, err
}
b7, err := b.ReadByte()
b7, err := r.ReadByte()
if err != nil {
return 0, err
}
b8, err := b.ReadByte()
b8, err := r.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
}
// Write writes a number in the QUIC varint format
func Write(b *bytes.Buffer, i uint64) {
// Write writes i in the QUIC varint format to w.
func Write(w Writer, i uint64) {
if i <= maxVarInt1 {
b.WriteByte(uint8(i))
w.WriteByte(uint8(i))
} else if i <= maxVarInt2 {
b.Write([]byte{uint8(i>>8) | 0x40, uint8(i)})
w.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)})
w.Write([]byte{uint8(i>>24) | 0x80, uint8(i >> 16), uint8(i >> 8), uint8(i)})
} else if i <= maxVarInt8 {
b.Write([]byte{
w.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),
})
@@ -83,35 +88,35 @@ func Write(b *bytes.Buffer, i uint64) {
}
}
// WriteWithLen writes a number in the QUIC varint format, with the desired length.
func WriteWithLen(b *bytes.Buffer, i uint64, length protocol.ByteCount) {
// WriteWithLen writes i in the QUIC varint format with the desired length to w.
func WriteWithLen(w Writer, i uint64, length protocol.ByteCount) {
if length != 1 && length != 2 && length != 4 && length != 8 {
panic("invalid varint length")
}
l := Len(i)
if l == length {
Write(b, i)
Write(w, i)
return
}
if l > length {
panic(fmt.Sprintf("cannot encode %d in %d bytes", i, length))
}
if length == 2 {
b.WriteByte(0b01000000)
w.WriteByte(0b01000000)
} else if length == 4 {
b.WriteByte(0b10000000)
w.WriteByte(0b10000000)
} else if length == 8 {
b.WriteByte(0b11000000)
w.WriteByte(0b11000000)
}
for j := protocol.ByteCount(1); j < length-l; j++ {
b.WriteByte(0)
w.WriteByte(0)
}
for j := protocol.ByteCount(0); j < l; j++ {
b.WriteByte(uint8(i >> (8 * (l - 1 - j))))
w.WriteByte(uint8(i >> (8 * (l - 1 - j))))
}
}
// Len determines the number of bytes that will be needed to write a number
// Len determines the number of bytes that will be needed to write the number i.
func Len(i uint64) protocol.ByteCount {
if i <= maxVarInt1 {
return 1