use go 1.12

Signed-off-by: hongming <talonwan@yunify.com>

vendor/github.com/lucas-clemente/quic-go/internal/utils/atomic_bool.go

@@ -0,0 +1,22 @@
+package utils
+
+import "sync/atomic"
+
+// An AtomicBool is an atomic bool
+type AtomicBool struct {
+	v int32
+}
+
+// Set sets the value
+func (a *AtomicBool) Set(value bool) {
+	var n int32
+	if value {
+		n = 1
+	}
+	atomic.StoreInt32(&a.v, n)
+}
+
+// Get gets the value
+func (a *AtomicBool) Get() bool {
+	return atomic.LoadInt32(&a.v) != 0
+}

vendor/github.com/lucas-clemente/quic-go/internal/utils/byteinterval_linkedlist.go

@@ -0,0 +1,217 @@
+// This file was automatically generated by genny.
+// Any changes will be lost if this file is regenerated.
+// see https://github.com/cheekybits/genny
+
+package utils
+
+// Linked list implementation from the Go standard library.
+
+// ByteIntervalElement is an element of a linked list.
+type ByteIntervalElement struct {
+	// Next and previous pointers in the doubly-linked list of elements.
+	// To simplify the implementation, internally a list l is implemented
+	// as a ring, such that &l.root is both the next element of the last
+	// list element (l.Back()) and the previous element of the first list
+	// element (l.Front()).
+	next, prev *ByteIntervalElement
+
+	// The list to which this element belongs.
+	list *ByteIntervalList
+
+	// The value stored with this element.
+	Value ByteInterval
+}
+
+// Next returns the next list element or nil.
+func (e *ByteIntervalElement) Next() *ByteIntervalElement {
+	if p := e.next; e.list != nil && p != &e.list.root {
+		return p
+	}
+	return nil
+}
+
+// Prev returns the previous list element or nil.
+func (e *ByteIntervalElement) Prev() *ByteIntervalElement {
+	if p := e.prev; e.list != nil && p != &e.list.root {
+		return p
+	}
+	return nil
+}
+
+// ByteIntervalList is a linked list of ByteIntervals.
+type ByteIntervalList struct {
+	root ByteIntervalElement // sentinel list element, only &root, root.prev, and root.next are used
+	len  int                 // current list length excluding (this) sentinel element
+}
+
+// Init initializes or clears list l.
+func (l *ByteIntervalList) Init() *ByteIntervalList {
+	l.root.next = &l.root
+	l.root.prev = &l.root
+	l.len = 0
+	return l
+}
+
+// NewByteIntervalList returns an initialized list.
+func NewByteIntervalList() *ByteIntervalList { return new(ByteIntervalList).Init() }
+
+// Len returns the number of elements of list l.
+// The complexity is O(1).
+func (l *ByteIntervalList) Len() int { return l.len }
+
+// Front returns the first element of list l or nil if the list is empty.
+func (l *ByteIntervalList) Front() *ByteIntervalElement {
+	if l.len == 0 {
+		return nil
+	}
+	return l.root.next
+}
+
+// Back returns the last element of list l or nil if the list is empty.
+func (l *ByteIntervalList) Back() *ByteIntervalElement {
+	if l.len == 0 {
+		return nil
+	}
+	return l.root.prev
+}
+
+// lazyInit lazily initializes a zero List value.
+func (l *ByteIntervalList) lazyInit() {
+	if l.root.next == nil {
+		l.Init()
+	}
+}
+
+// insert inserts e after at, increments l.len, and returns e.
+func (l *ByteIntervalList) insert(e, at *ByteIntervalElement) *ByteIntervalElement {
+	n := at.next
+	at.next = e
+	e.prev = at
+	e.next = n
+	n.prev = e
+	e.list = l
+	l.len++
+	return e
+}
+
+// insertValue is a convenience wrapper for insert(&Element{Value: v}, at).
+func (l *ByteIntervalList) insertValue(v ByteInterval, at *ByteIntervalElement) *ByteIntervalElement {
+	return l.insert(&ByteIntervalElement{Value: v}, at)
+}
+
+// remove removes e from its list, decrements l.len, and returns e.
+func (l *ByteIntervalList) remove(e *ByteIntervalElement) *ByteIntervalElement {
+	e.prev.next = e.next
+	e.next.prev = e.prev
+	e.next = nil // avoid memory leaks
+	e.prev = nil // avoid memory leaks
+	e.list = nil
+	l.len--
+	return e
+}
+
+// Remove removes e from l if e is an element of list l.
+// It returns the element value e.Value.
+// The element must not be nil.
+func (l *ByteIntervalList) Remove(e *ByteIntervalElement) ByteInterval {
+	if e.list == l {
+		// if e.list == l, l must have been initialized when e was inserted
+		// in l or l == nil (e is a zero Element) and l.remove will crash
+		l.remove(e)
+	}
+	return e.Value
+}
+
+// PushFront inserts a new element e with value v at the front of list l and returns e.
+func (l *ByteIntervalList) PushFront(v ByteInterval) *ByteIntervalElement {
+	l.lazyInit()
+	return l.insertValue(v, &l.root)
+}
+
+// PushBack inserts a new element e with value v at the back of list l and returns e.
+func (l *ByteIntervalList) PushBack(v ByteInterval) *ByteIntervalElement {
+	l.lazyInit()
+	return l.insertValue(v, l.root.prev)
+}
+
+// InsertBefore inserts a new element e with value v immediately before mark and returns e.
+// If mark is not an element of l, the list is not modified.
+// The mark must not be nil.
+func (l *ByteIntervalList) InsertBefore(v ByteInterval, mark *ByteIntervalElement) *ByteIntervalElement {
+	if mark.list != l {
+		return nil
+	}
+	// see comment in List.Remove about initialization of l
+	return l.insertValue(v, mark.prev)
+}
+
+// InsertAfter inserts a new element e with value v immediately after mark and returns e.
+// If mark is not an element of l, the list is not modified.
+// The mark must not be nil.
+func (l *ByteIntervalList) InsertAfter(v ByteInterval, mark *ByteIntervalElement) *ByteIntervalElement {
+	if mark.list != l {
+		return nil
+	}
+	// see comment in List.Remove about initialization of l
+	return l.insertValue(v, mark)
+}
+
+// MoveToFront moves element e to the front of list l.
+// If e is not an element of l, the list is not modified.
+// The element must not be nil.
+func (l *ByteIntervalList) MoveToFront(e *ByteIntervalElement) {
+	if e.list != l || l.root.next == e {
+		return
+	}
+	// see comment in List.Remove about initialization of l
+	l.insert(l.remove(e), &l.root)
+}
+
+// MoveToBack moves element e to the back of list l.
+// If e is not an element of l, the list is not modified.
+// The element must not be nil.
+func (l *ByteIntervalList) MoveToBack(e *ByteIntervalElement) {
+	if e.list != l || l.root.prev == e {
+		return
+	}
+	// see comment in List.Remove about initialization of l
+	l.insert(l.remove(e), l.root.prev)
+}
+
+// MoveBefore moves element e to its new position before mark.
+// If e or mark is not an element of l, or e == mark, the list is not modified.
+// The element and mark must not be nil.
+func (l *ByteIntervalList) MoveBefore(e, mark *ByteIntervalElement) {
+	if e.list != l || e == mark || mark.list != l {
+		return
+	}
+	l.insert(l.remove(e), mark.prev)
+}
+
+// MoveAfter moves element e to its new position after mark.
+// If e or mark is not an element of l, or e == mark, the list is not modified.
+// The element and mark must not be nil.
+func (l *ByteIntervalList) MoveAfter(e, mark *ByteIntervalElement) {
+	if e.list != l || e == mark || mark.list != l {
+		return
+	}
+	l.insert(l.remove(e), mark)
+}
+
+// PushBackList inserts a copy of an other list at the back of list l.
+// The lists l and other may be the same. They must not be nil.
+func (l *ByteIntervalList) PushBackList(other *ByteIntervalList) {
+	l.lazyInit()
+	for i, e := other.Len(), other.Front(); i > 0; i, e = i-1, e.Next() {
+		l.insertValue(e.Value, l.root.prev)
+	}
+}
+
+// PushFrontList inserts a copy of an other list at the front of list l.
+// The lists l and other may be the same. They must not be nil.
+func (l *ByteIntervalList) PushFrontList(other *ByteIntervalList) {
+	l.lazyInit()
+	for i, e := other.Len(), other.Back(); i > 0; i, e = i-1, e.Prev() {
+		l.insertValue(e.Value, &l.root)
+	}
+}

vendor/github.com/lucas-clemente/quic-go/internal/utils/byteorder.go

@@ -0,0 +1,25 @@
+package utils
+
+import (
+	"bytes"
+	"io"
+)
+
+// A ByteOrder specifies how to convert byte sequences into 16-, 32-, or 64-bit unsigned integers.
+type ByteOrder interface {
+	ReadUintN(b io.ByteReader, length uint8) (uint64, error)
+	ReadUint64(io.ByteReader) (uint64, error)
+	ReadUint32(io.ByteReader) (uint32, error)
+	ReadUint16(io.ByteReader) (uint16, error)
+
+	WriteUint64(*bytes.Buffer, uint64)
+	WriteUint56(*bytes.Buffer, uint64)
+	WriteUint48(*bytes.Buffer, uint64)
+	WriteUint40(*bytes.Buffer, uint64)
+	WriteUint32(*bytes.Buffer, uint32)
+	WriteUint24(*bytes.Buffer, uint32)
+	WriteUint16(*bytes.Buffer, uint16)
+
+	ReadUfloat16(io.ByteReader) (uint64, error)
+	WriteUfloat16(*bytes.Buffer, uint64)
+}

vendor/github.com/lucas-clemente/quic-go/internal/utils/byteorder_big_endian.go

@@ -0,0 +1,157 @@
+package utils
+
+import (
+	"bytes"
+	"fmt"
+	"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
+}
+
+// ReadUint64 reads a uint64
+func (bigEndian) ReadUint64(b io.ByteReader) (uint64, error) {
+	var b1, b2, b3, b4, b5, b6, b7, b8 uint8
+	var err error
+	if b8, err = b.ReadByte(); err != nil {
+		return 0, err
+	}
+	if b7, err = b.ReadByte(); err != nil {
+		return 0, err
+	}
+	if b6, err = b.ReadByte(); err != nil {
+		return 0, err
+	}
+	if b5, err = b.ReadByte(); err != nil {
+		return 0, err
+	}
+	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 uint64(b1) + uint64(b2)<<8 + uint64(b3)<<16 + uint64(b4)<<24 + uint64(b5)<<32 + uint64(b6)<<40 + uint64(b7)<<48 + uint64(b8)<<56, 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
+}
+
+// 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
+}
+
+// WriteUint64 writes a uint64
+func (bigEndian) WriteUint64(b *bytes.Buffer, i uint64) {
+	b.Write([]byte{
+		uint8(i >> 56), uint8(i >> 48), uint8(i >> 40), uint8(i >> 32),
+		uint8(i >> 24), uint8(i >> 16), uint8(i >> 8), uint8(i),
+	})
+}
+
+// WriteUint56 writes 56 bit of a uint64
+func (bigEndian) WriteUint56(b *bytes.Buffer, i uint64) {
+	if i >= (1 << 56) {
+		panic(fmt.Sprintf("%#x doesn't fit into 56 bits", i))
+	}
+	b.Write([]byte{
+		uint8(i >> 48), uint8(i >> 40), uint8(i >> 32),
+		uint8(i >> 24), uint8(i >> 16), uint8(i >> 8), uint8(i),
+	})
+}
+
+// WriteUint48 writes 48 bit of a uint64
+func (bigEndian) WriteUint48(b *bytes.Buffer, i uint64) {
+	if i >= (1 << 48) {
+		panic(fmt.Sprintf("%#x doesn't fit into 48 bits", i))
+	}
+	b.Write([]byte{
+		uint8(i >> 40), uint8(i >> 32),
+		uint8(i >> 24), uint8(i >> 16), uint8(i >> 8), uint8(i),
+	})
+}
+
+// WriteUint40 writes 40 bit of a uint64
+func (bigEndian) WriteUint40(b *bytes.Buffer, i uint64) {
+	if i >= (1 << 40) {
+		panic(fmt.Sprintf("%#x doesn't fit into 40 bits", i))
+	}
+	b.Write([]byte{
+		uint8(i >> 32),
+		uint8(i >> 24), uint8(i >> 16), uint8(i >> 8), uint8(i),
+	})
+}
+
+// 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 24 bit of a uint32
+func (bigEndian) WriteUint24(b *bytes.Buffer, i uint32) {
+	if i >= (1 << 24) {
+		panic(fmt.Sprintf("%#x doesn't fit into 24 bits", i))
+	}
+	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)})
+}
+
+func (l bigEndian) ReadUfloat16(b io.ByteReader) (uint64, error) {
+	return readUfloat16(b, l)
+}
+
+func (l bigEndian) WriteUfloat16(b *bytes.Buffer, val uint64) {
+	writeUfloat16(b, l, val)
+}

vendor/github.com/lucas-clemente/quic-go/internal/utils/byteorder_little_endian.go

@@ -0,0 +1,157 @@
+package utils
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+)
+
+// LittleEndian is the little-endian implementation of ByteOrder.
+var LittleEndian ByteOrder = littleEndian{}
+
+type littleEndian struct{}
+
+var _ ByteOrder = &littleEndian{}
+
+// ReadUintN reads N bytes
+func (littleEndian) 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) << (i * 8)
+	}
+	return res, nil
+}
+
+// ReadUint64 reads a uint64
+func (littleEndian) ReadUint64(b io.ByteReader) (uint64, error) {
+	var b1, b2, b3, b4, b5, b6, b7, b8 uint8
+	var err error
+	if b1, err = b.ReadByte(); err != nil {
+		return 0, err
+	}
+	if b2, err = b.ReadByte(); err != nil {
+		return 0, err
+	}
+	if b3, err = b.ReadByte(); err != nil {
+		return 0, err
+	}
+	if b4, err = b.ReadByte(); err != nil {
+		return 0, err
+	}
+	if b5, err = b.ReadByte(); err != nil {
+		return 0, err
+	}
+	if b6, err = b.ReadByte(); err != nil {
+		return 0, err
+	}
+	if b7, err = b.ReadByte(); err != nil {
+		return 0, err
+	}
+	if b8, err = b.ReadByte(); err != nil {
+		return 0, err
+	}
+	return uint64(b1) + uint64(b2)<<8 + uint64(b3)<<16 + uint64(b4)<<24 + uint64(b5)<<32 + uint64(b6)<<40 + uint64(b7)<<48 + uint64(b8)<<56, nil
+}
+
+// ReadUint32 reads a uint32
+func (littleEndian) ReadUint32(b io.ByteReader) (uint32, error) {
+	var b1, b2, b3, b4 uint8
+	var err error
+	if b1, err = b.ReadByte(); err != nil {
+		return 0, err
+	}
+	if b2, err = b.ReadByte(); err != nil {
+		return 0, err
+	}
+	if b3, err = b.ReadByte(); err != nil {
+		return 0, err
+	}
+	if b4, err = b.ReadByte(); err != nil {
+		return 0, err
+	}
+	return uint32(b1) + uint32(b2)<<8 + uint32(b3)<<16 + uint32(b4)<<24, nil
+}
+
+// ReadUint16 reads a uint16
+func (littleEndian) ReadUint16(b io.ByteReader) (uint16, error) {
+	var b1, b2 uint8
+	var err error
+	if b1, err = b.ReadByte(); err != nil {
+		return 0, err
+	}
+	if b2, err = b.ReadByte(); err != nil {
+		return 0, err
+	}
+	return uint16(b1) + uint16(b2)<<8, nil
+}
+
+// WriteUint64 writes a uint64
+func (littleEndian) WriteUint64(b *bytes.Buffer, i uint64) {
+	b.Write([]byte{
+		uint8(i), uint8(i >> 8), uint8(i >> 16), uint8(i >> 24),
+		uint8(i >> 32), uint8(i >> 40), uint8(i >> 48), uint8(i >> 56),
+	})
+}
+
+// WriteUint56 writes 56 bit of a uint64
+func (littleEndian) WriteUint56(b *bytes.Buffer, i uint64) {
+	if i >= (1 << 56) {
+		panic(fmt.Sprintf("%#x doesn't fit into 56 bits", i))
+	}
+	b.Write([]byte{
+		uint8(i), uint8(i >> 8), uint8(i >> 16), uint8(i >> 24),
+		uint8(i >> 32), uint8(i >> 40), uint8(i >> 48),
+	})
+}
+
+// WriteUint48 writes 48 bit of a uint64
+func (littleEndian) WriteUint48(b *bytes.Buffer, i uint64) {
+	if i >= (1 << 48) {
+		panic(fmt.Sprintf("%#x doesn't fit into 48 bits", i))
+	}
+	b.Write([]byte{
+		uint8(i), uint8(i >> 8), uint8(i >> 16), uint8(i >> 24),
+		uint8(i >> 32), uint8(i >> 40),
+	})
+}
+
+// WriteUint40 writes 40 bit of a uint64
+func (littleEndian) WriteUint40(b *bytes.Buffer, i uint64) {
+	if i >= (1 << 40) {
+		panic(fmt.Sprintf("%#x doesn't fit into 40 bits", i))
+	}
+	b.Write([]byte{
+		uint8(i), uint8(i >> 8), uint8(i >> 16),
+		uint8(i >> 24), uint8(i >> 32),
+	})
+}
+
+// WriteUint32 writes a uint32
+func (littleEndian) WriteUint32(b *bytes.Buffer, i uint32) {
+	b.Write([]byte{uint8(i), uint8(i >> 8), uint8(i >> 16), uint8(i >> 24)})
+}
+
+// WriteUint24 writes 24 bit of a uint32
+func (littleEndian) WriteUint24(b *bytes.Buffer, i uint32) {
+	if i >= (1 << 24) {
+		panic(fmt.Sprintf("%#x doesn't fit into 24 bits", i))
+	}
+	b.Write([]byte{uint8(i), uint8(i >> 8), uint8(i >> 16)})
+}
+
+// WriteUint16 writes a uint16
+func (littleEndian) WriteUint16(b *bytes.Buffer, i uint16) {
+	b.Write([]byte{uint8(i), uint8(i >> 8)})
+}
+
+func (l littleEndian) ReadUfloat16(b io.ByteReader) (uint64, error) {
+	return readUfloat16(b, l)
+}
+
+func (l littleEndian) WriteUfloat16(b *bytes.Buffer, val uint64) {
+	writeUfloat16(b, l, val)
+}

vendor/github.com/lucas-clemente/quic-go/internal/utils/float16.go

@@ -0,0 +1,86 @@
+package utils
+
+import (
+	"bytes"
+	"io"
+	"math"
+)
+
+// We define an unsigned 16-bit floating point value, inspired by IEEE floats
+// (http://en.wikipedia.org/wiki/Half_precision_floating-point_format),
+// with 5-bit exponent (bias 1), 11-bit mantissa (effective 12 with hidden
+// bit) and denormals, but without signs, transfinites or fractions. Wire format
+// 16 bits (little-endian byte order) are split into exponent (high 5) and
+// mantissa (low 11) and decoded as:
+//   uint64_t value;
+//   if (exponent == 0) value = mantissa;
+//   else value = (mantissa | 1 << 11) << (exponent - 1)
+const uFloat16ExponentBits = 5
+const uFloat16MaxExponent = (1 << uFloat16ExponentBits) - 2                                        // 30
+const uFloat16MantissaBits = 16 - uFloat16ExponentBits                                             // 11
+const uFloat16MantissaEffectiveBits = uFloat16MantissaBits + 1                                     // 12
+const uFloat16MaxValue = ((uint64(1) << uFloat16MantissaEffectiveBits) - 1) << uFloat16MaxExponent // 0x3FFC0000000
+
+// readUfloat16 reads a float in the QUIC-float16 format and returns its uint64 representation
+func readUfloat16(b io.ByteReader, byteOrder ByteOrder) (uint64, error) {
+	val, err := byteOrder.ReadUint16(b)
+	if err != nil {
+		return 0, err
+	}
+
+	res := uint64(val)
+
+	if res < (1 << uFloat16MantissaEffectiveBits) {
+		// Fast path: either the value is denormalized (no hidden bit), or
+		// normalized (hidden bit set, exponent offset by one) with exponent zero.
+		// Zero exponent offset by one sets the bit exactly where the hidden bit is.
+		// So in both cases the value encodes itself.
+		return res, nil
+	}
+
+	exponent := val >> uFloat16MantissaBits // No sign extend on uint!
+	// After the fast pass, the exponent is at least one (offset by one).
+	// Un-offset the exponent.
+	exponent--
+	// Here we need to clear the exponent and set the hidden bit. We have already
+	// decremented the exponent, so when we subtract it, it leaves behind the
+	// hidden bit.
+	res -= uint64(exponent) << uFloat16MantissaBits
+	res <<= exponent
+	return res, nil
+}
+
+// writeUfloat16 writes a float in the QUIC-float16 format from its uint64 representation
+func writeUfloat16(b *bytes.Buffer, byteOrder ByteOrder, value uint64) {
+	var result uint16
+	if value < (uint64(1) << uFloat16MantissaEffectiveBits) {
+		// Fast path: either the value is denormalized, or has exponent zero.
+		// Both cases are represented by the value itself.
+		result = uint16(value)
+	} else if value >= uFloat16MaxValue {
+		// Value is out of range; clamp it to the maximum representable.
+		result = math.MaxUint16
+	} else {
+		// The highest bit is between position 13 and 42 (zero-based), which
+		// corresponds to exponent 1-30. In the output, mantissa is from 0 to 10,
+		// hidden bit is 11 and exponent is 11 to 15. Shift the highest bit to 11
+		// and count the shifts.
+		exponent := uint16(0)
+		for offset := uint16(16); offset > 0; offset /= 2 {
+			// Right-shift the value until the highest bit is in position 11.
+			// For offset of 16, 8, 4, 2 and 1 (binary search over 1-30),
+			// shift if the bit is at or above 11 + offset.
+			if value >= (uint64(1) << (uFloat16MantissaBits + offset)) {
+				exponent += offset
+				value >>= offset
+			}
+		}
+
+		// Hidden bit (position 11) is set. We should remove it and increment the
+		// exponent. Equivalently, we just add it to the exponent.
+		// This hides the bit.
+		result = (uint16(value) + (exponent << uFloat16MantissaBits))
+	}
+
+	byteOrder.WriteUint16(b, result)
+}

vendor/github.com/lucas-clemente/quic-go/internal/utils/gen.go

@@ -0,0 +1,4 @@
+package utils
+
+//go:generate genny -pkg utils -in linkedlist/linkedlist.go -out byteinterval_linkedlist.go gen Item=ByteInterval
+//go:generate genny -pkg utils -in linkedlist/linkedlist.go -out packetinterval_linkedlist.go gen Item=PacketInterval

vendor/github.com/lucas-clemente/quic-go/internal/utils/host.go

@@ -0,0 +1,27 @@
+package utils
+
+import (
+	"net/url"
+	"strings"
+)
+
+// HostnameFromAddr determines the hostname in an address string
+func HostnameFromAddr(addr string) (string, error) {
+	p, err := url.Parse(addr)
+	if err != nil {
+		return "", err
+	}
+	h := p.Host
+
+	// copied from https://golang.org/src/net/http/transport.go
+	if hasPort(h) {
+		h = h[:strings.LastIndex(h, ":")]
+	}
+
+	return h, nil
+}
+
+// copied from https://golang.org/src/net/http/http.go
+func hasPort(s string) bool {
+	return strings.LastIndex(s, ":") > strings.LastIndex(s, "]")
+}

vendor/github.com/lucas-clemente/quic-go/internal/utils/log.go

@@ -0,0 +1,131 @@
+package utils
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"strings"
+	"time"
+)
+
+// LogLevel of quic-go
+type LogLevel uint8
+
+const (
+	// LogLevelNothing disables
+	LogLevelNothing LogLevel = iota
+	// LogLevelError enables err logs
+	LogLevelError
+	// LogLevelInfo enables info logs (e.g. packets)
+	LogLevelInfo
+	// LogLevelDebug enables debug logs (e.g. packet contents)
+	LogLevelDebug
+)
+
+const logEnv = "QUIC_GO_LOG_LEVEL"
+
+// A Logger logs.
+type Logger interface {
+	SetLogLevel(LogLevel)
+	SetLogTimeFormat(format string)
+	WithPrefix(prefix string) Logger
+	Debug() bool
+
+	Errorf(format string, args ...interface{})
+	Infof(format string, args ...interface{})
+	Debugf(format string, args ...interface{})
+}
+
+// DefaultLogger is used by quic-go for logging.
+var DefaultLogger Logger
+
+type defaultLogger struct {
+	prefix string
+
+	logLevel   LogLevel
+	timeFormat string
+}
+
+var _ Logger = &defaultLogger{}
+
+// SetLogLevel sets the log level
+func (l *defaultLogger) SetLogLevel(level LogLevel) {
+	l.logLevel = level
+}
+
+// SetLogTimeFormat sets the format of the timestamp
+// an empty string disables the logging of timestamps
+func (l *defaultLogger) SetLogTimeFormat(format string) {
+	log.SetFlags(0) // disable timestamp logging done by the log package
+	l.timeFormat = format
+}
+
+// Debugf logs something
+func (l *defaultLogger) Debugf(format string, args ...interface{}) {
+	if l.logLevel == LogLevelDebug {
+		l.logMessage(format, args...)
+	}
+}
+
+// Infof logs something
+func (l *defaultLogger) Infof(format string, args ...interface{}) {
+	if l.logLevel >= LogLevelInfo {
+		l.logMessage(format, args...)
+	}
+}
+
+// Errorf logs something
+func (l *defaultLogger) Errorf(format string, args ...interface{}) {
+	if l.logLevel >= LogLevelError {
+		l.logMessage(format, args...)
+	}
+}
+
+func (l *defaultLogger) logMessage(format string, args ...interface{}) {
+	var pre string
+
+	if len(l.timeFormat) > 0 {
+		pre = time.Now().Format(l.timeFormat) + " "
+	}
+	if len(l.prefix) > 0 {
+		pre += l.prefix + " "
+	}
+	log.Printf(pre+format, args...)
+}
+
+func (l *defaultLogger) WithPrefix(prefix string) Logger {
+	if len(l.prefix) > 0 {
+		prefix = l.prefix + " " + prefix
+	}
+	return &defaultLogger{
+		logLevel:   l.logLevel,
+		timeFormat: l.timeFormat,
+		prefix:     prefix,
+	}
+}
+
+// Debug returns true if the log level is LogLevelDebug
+func (l *defaultLogger) Debug() bool {
+	return l.logLevel == LogLevelDebug
+}
+
+func init() {
+	DefaultLogger = &defaultLogger{}
+	DefaultLogger.SetLogLevel(readLoggingEnv())
+}
+
+func readLoggingEnv() LogLevel {
+	switch strings.ToLower(os.Getenv(logEnv)) {
+	case "":
+		return LogLevelNothing
+	case "debug":
+		return LogLevelDebug
+	case "info":
+		return LogLevelInfo
+	case "error":
+		return LogLevelError
+	default:
+		fmt.Fprintln(os.Stderr, "invalid quic-go log level, see https://github.com/lucas-clemente/quic-go/wiki/Logging")
+		return LogLevelNothing
+	}
+}

vendor/github.com/lucas-clemente/quic-go/internal/utils/minmax.go

@@ -0,0 +1,147 @@
+package utils
+
+import (
+	"math"
+	"time"
+
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+)
+
+// InfDuration is a duration of infinite length
+const InfDuration = time.Duration(math.MaxInt64)
+
+// Max returns the maximum of two Ints
+func Max(a, b int) int {
+	if a < b {
+		return b
+	}
+	return a
+}
+
+// MaxUint32 returns the maximum of two uint32
+func MaxUint32(a, b uint32) uint32 {
+	if a < b {
+		return b
+	}
+	return a
+}
+
+// MaxUint64 returns the maximum of two uint64
+func MaxUint64(a, b uint64) uint64 {
+	if a < b {
+		return b
+	}
+	return a
+}
+
+// MinUint64 returns the maximum of two uint64
+func MinUint64(a, b uint64) uint64 {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+// Min returns the minimum of two Ints
+func Min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+// MinUint32 returns the maximum of two uint32
+func MinUint32(a, b uint32) uint32 {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+// MinInt64 returns the minimum of two int64
+func MinInt64(a, b int64) int64 {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+// MaxInt64 returns the minimum of two int64
+func MaxInt64(a, b int64) int64 {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+// MinByteCount returns the minimum of two ByteCounts
+func MinByteCount(a, b protocol.ByteCount) protocol.ByteCount {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+// MaxByteCount returns the maximum of two ByteCounts
+func MaxByteCount(a, b protocol.ByteCount) protocol.ByteCount {
+	if a < b {
+		return b
+	}
+	return a
+}
+
+// MaxDuration returns the max duration
+func MaxDuration(a, b time.Duration) time.Duration {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+// MinDuration returns the minimum duration
+func MinDuration(a, b time.Duration) time.Duration {
+	if a > b {
+		return b
+	}
+	return a
+}
+
+// AbsDuration returns the absolute value of a time duration
+func AbsDuration(d time.Duration) time.Duration {
+	if d >= 0 {
+		return d
+	}
+	return -d
+}
+
+// MinTime returns the earlier time
+func MinTime(a, b time.Time) time.Time {
+	if a.After(b) {
+		return b
+	}
+	return a
+}
+
+// MaxTime returns the later time
+func MaxTime(a, b time.Time) time.Time {
+	if a.After(b) {
+		return a
+	}
+	return b
+}
+
+// MaxPacketNumber returns the max packet number
+func MaxPacketNumber(a, b protocol.PacketNumber) protocol.PacketNumber {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+// MinPacketNumber returns the min packet number
+func MinPacketNumber(a, b protocol.PacketNumber) protocol.PacketNumber {
+	if a < b {
+		return a
+	}
+	return b
+}

vendor/github.com/lucas-clemente/quic-go/internal/utils/packet_interval.go

@@ -0,0 +1,9 @@
+package utils
+
+import "github.com/lucas-clemente/quic-go/internal/protocol"
+
+// PacketInterval is an interval from one PacketNumber to the other
+type PacketInterval struct {
+	Start protocol.PacketNumber
+	End   protocol.PacketNumber
+}

vendor/github.com/lucas-clemente/quic-go/internal/utils/packetinterval_linkedlist.go

@@ -0,0 +1,217 @@
+// This file was automatically generated by genny.
+// Any changes will be lost if this file is regenerated.
+// see https://github.com/cheekybits/genny
+
+package utils
+
+// Linked list implementation from the Go standard library.
+
+// PacketIntervalElement is an element of a linked list.
+type PacketIntervalElement struct {
+	// Next and previous pointers in the doubly-linked list of elements.
+	// To simplify the implementation, internally a list l is implemented
+	// as a ring, such that &l.root is both the next element of the last
+	// list element (l.Back()) and the previous element of the first list
+	// element (l.Front()).
+	next, prev *PacketIntervalElement
+
+	// The list to which this element belongs.
+	list *PacketIntervalList
+
+	// The value stored with this element.
+	Value PacketInterval
+}
+
+// Next returns the next list element or nil.
+func (e *PacketIntervalElement) Next() *PacketIntervalElement {
+	if p := e.next; e.list != nil && p != &e.list.root {
+		return p
+	}
+	return nil
+}
+
+// Prev returns the previous list element or nil.
+func (e *PacketIntervalElement) Prev() *PacketIntervalElement {
+	if p := e.prev; e.list != nil && p != &e.list.root {
+		return p
+	}
+	return nil
+}
+
+// PacketIntervalList is a linked list of PacketIntervals.
+type PacketIntervalList struct {
+	root PacketIntervalElement // sentinel list element, only &root, root.prev, and root.next are used
+	len  int                   // current list length excluding (this) sentinel element
+}
+
+// Init initializes or clears list l.
+func (l *PacketIntervalList) Init() *PacketIntervalList {
+	l.root.next = &l.root
+	l.root.prev = &l.root
+	l.len = 0
+	return l
+}
+
+// NewPacketIntervalList returns an initialized list.
+func NewPacketIntervalList() *PacketIntervalList { return new(PacketIntervalList).Init() }
+
+// Len returns the number of elements of list l.
+// The complexity is O(1).
+func (l *PacketIntervalList) Len() int { return l.len }
+
+// Front returns the first element of list l or nil if the list is empty.
+func (l *PacketIntervalList) Front() *PacketIntervalElement {
+	if l.len == 0 {
+		return nil
+	}
+	return l.root.next
+}
+
+// Back returns the last element of list l or nil if the list is empty.
+func (l *PacketIntervalList) Back() *PacketIntervalElement {
+	if l.len == 0 {
+		return nil
+	}
+	return l.root.prev
+}
+
+// lazyInit lazily initializes a zero List value.
+func (l *PacketIntervalList) lazyInit() {
+	if l.root.next == nil {
+		l.Init()
+	}
+}
+
+// insert inserts e after at, increments l.len, and returns e.
+func (l *PacketIntervalList) insert(e, at *PacketIntervalElement) *PacketIntervalElement {
+	n := at.next
+	at.next = e
+	e.prev = at
+	e.next = n
+	n.prev = e
+	e.list = l
+	l.len++
+	return e
+}
+
+// insertValue is a convenience wrapper for insert(&Element{Value: v}, at).
+func (l *PacketIntervalList) insertValue(v PacketInterval, at *PacketIntervalElement) *PacketIntervalElement {
+	return l.insert(&PacketIntervalElement{Value: v}, at)
+}
+
+// remove removes e from its list, decrements l.len, and returns e.
+func (l *PacketIntervalList) remove(e *PacketIntervalElement) *PacketIntervalElement {
+	e.prev.next = e.next
+	e.next.prev = e.prev
+	e.next = nil // avoid memory leaks
+	e.prev = nil // avoid memory leaks
+	e.list = nil
+	l.len--
+	return e
+}
+
+// Remove removes e from l if e is an element of list l.
+// It returns the element value e.Value.
+// The element must not be nil.
+func (l *PacketIntervalList) Remove(e *PacketIntervalElement) PacketInterval {
+	if e.list == l {
+		// if e.list == l, l must have been initialized when e was inserted
+		// in l or l == nil (e is a zero Element) and l.remove will crash
+		l.remove(e)
+	}
+	return e.Value
+}
+
+// PushFront inserts a new element e with value v at the front of list l and returns e.
+func (l *PacketIntervalList) PushFront(v PacketInterval) *PacketIntervalElement {
+	l.lazyInit()
+	return l.insertValue(v, &l.root)
+}
+
+// PushBack inserts a new element e with value v at the back of list l and returns e.
+func (l *PacketIntervalList) PushBack(v PacketInterval) *PacketIntervalElement {
+	l.lazyInit()
+	return l.insertValue(v, l.root.prev)
+}
+
+// InsertBefore inserts a new element e with value v immediately before mark and returns e.
+// If mark is not an element of l, the list is not modified.
+// The mark must not be nil.
+func (l *PacketIntervalList) InsertBefore(v PacketInterval, mark *PacketIntervalElement) *PacketIntervalElement {
+	if mark.list != l {
+		return nil
+	}
+	// see comment in List.Remove about initialization of l
+	return l.insertValue(v, mark.prev)
+}
+
+// InsertAfter inserts a new element e with value v immediately after mark and returns e.
+// If mark is not an element of l, the list is not modified.
+// The mark must not be nil.
+func (l *PacketIntervalList) InsertAfter(v PacketInterval, mark *PacketIntervalElement) *PacketIntervalElement {
+	if mark.list != l {
+		return nil
+	}
+	// see comment in List.Remove about initialization of l
+	return l.insertValue(v, mark)
+}
+
+// MoveToFront moves element e to the front of list l.
+// If e is not an element of l, the list is not modified.
+// The element must not be nil.
+func (l *PacketIntervalList) MoveToFront(e *PacketIntervalElement) {
+	if e.list != l || l.root.next == e {
+		return
+	}
+	// see comment in List.Remove about initialization of l
+	l.insert(l.remove(e), &l.root)
+}
+
+// MoveToBack moves element e to the back of list l.
+// If e is not an element of l, the list is not modified.
+// The element must not be nil.
+func (l *PacketIntervalList) MoveToBack(e *PacketIntervalElement) {
+	if e.list != l || l.root.prev == e {
+		return
+	}
+	// see comment in List.Remove about initialization of l
+	l.insert(l.remove(e), l.root.prev)
+}
+
+// MoveBefore moves element e to its new position before mark.
+// If e or mark is not an element of l, or e == mark, the list is not modified.
+// The element and mark must not be nil.
+func (l *PacketIntervalList) MoveBefore(e, mark *PacketIntervalElement) {
+	if e.list != l || e == mark || mark.list != l {
+		return
+	}
+	l.insert(l.remove(e), mark.prev)
+}
+
+// MoveAfter moves element e to its new position after mark.
+// If e or mark is not an element of l, or e == mark, the list is not modified.
+// The element and mark must not be nil.
+func (l *PacketIntervalList) MoveAfter(e, mark *PacketIntervalElement) {
+	if e.list != l || e == mark || mark.list != l {
+		return
+	}
+	l.insert(l.remove(e), mark)
+}
+
+// PushBackList inserts a copy of an other list at the back of list l.
+// The lists l and other may be the same. They must not be nil.
+func (l *PacketIntervalList) PushBackList(other *PacketIntervalList) {
+	l.lazyInit()
+	for i, e := other.Len(), other.Front(); i > 0; i, e = i-1, e.Next() {
+		l.insertValue(e.Value, l.root.prev)
+	}
+}
+
+// PushFrontList inserts a copy of an other list at the front of list l.
+// The lists l and other may be the same. They must not be nil.
+func (l *PacketIntervalList) PushFrontList(other *PacketIntervalList) {
+	l.lazyInit()
+	for i, e := other.Len(), other.Back(); i > 0; i, e = i-1, e.Prev() {
+		l.insertValue(e.Value, &l.root)
+	}
+}

vendor/github.com/lucas-clemente/quic-go/internal/utils/streamframe_interval.go

@@ -0,0 +1,9 @@
+package utils
+
+import "github.com/lucas-clemente/quic-go/internal/protocol"
+
+// ByteInterval is an interval from one ByteCount to the other
+type ByteInterval struct {
+	Start protocol.ByteCount
+	End   protocol.ByteCount
+}

vendor/github.com/lucas-clemente/quic-go/internal/utils/timer.go

@@ -0,0 +1,48 @@
+package utils
+
+import (
+	"math"
+	"time"
+)
+
+// A Timer wrapper that behaves correctly when resetting
+type Timer struct {
+	t        *time.Timer
+	read     bool
+	deadline time.Time
+}
+
+// NewTimer creates a new timer that is not set
+func NewTimer() *Timer {
+	return &Timer{t: time.NewTimer(time.Duration(math.MaxInt64))}
+}
+
+// Chan returns the channel of the wrapped timer
+func (t *Timer) Chan() <-chan time.Time {
+	return t.t.C
+}
+
+// Reset the timer, no matter whether the value was read or not
+func (t *Timer) Reset(deadline time.Time) {
+	if deadline.Equal(t.deadline) && !t.read {
+		// No need to reset the timer
+		return
+	}
+
+	// We need to drain the timer if the value from its channel was not read yet.
+	// See https://groups.google.com/forum/#!topic/golang-dev/c9UUfASVPoU
+	if !t.t.Stop() && !t.read {
+		<-t.t.C
+	}
+	if !deadline.IsZero() {
+		t.t.Reset(time.Until(deadline))
+	}
+
+	t.read = false
+	t.deadline = deadline
+}
+
+// SetRead should be called after the value from the chan was read
+func (t *Timer) SetRead() {
+	t.read = true
+}

vendor/github.com/lucas-clemente/quic-go/internal/utils/varint.go

@@ -0,0 +1,101 @@
+package utils
+
+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))
+	}
+}
+
+// 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
+	}
+	panic(fmt.Sprintf("%#x doesn't fit into 62 bits", i))
+}

vendor/github.com/lucas-clemente/quic-go/internal/utils/varint_packetnumber.go

@@ -0,0 +1,50 @@
+package utils
+
+import (
+	"bytes"
+	"fmt"
+
+	"github.com/lucas-clemente/quic-go/internal/protocol"
+)
+
+// ReadVarIntPacketNumber reads a number in the QUIC varint packet number format
+func ReadVarIntPacketNumber(b *bytes.Reader) (protocol.PacketNumber, protocol.PacketNumberLen, error) {
+	b1, err := b.ReadByte()
+	if err != nil {
+		return 0, 0, err
+	}
+	if b1&0x80 == 0 {
+		return protocol.PacketNumber(b1), protocol.PacketNumberLen1, nil
+	}
+	b2, err := b.ReadByte()
+	if err != nil {
+		return 0, 0, err
+	}
+	if b1&0x40 == 0 {
+		return protocol.PacketNumber(uint64(b1&0x3f)<<8 + uint64(b2)), protocol.PacketNumberLen2, nil
+	}
+	b3, err := b.ReadByte()
+	if err != nil {
+		return 0, 0, err
+	}
+	b4, err := b.ReadByte()
+	if err != nil {
+		return 0, 0, err
+	}
+	return protocol.PacketNumber(uint64(b1&0x3f)<<24 + uint64(b2)<<16 + uint64(b3)<<8 + uint64(b4)), protocol.PacketNumberLen4, nil
+}
+
+// WriteVarIntPacketNumber writes a packet number in the QUIC varint packet number format
+func WriteVarIntPacketNumber(b *bytes.Buffer, i protocol.PacketNumber, len protocol.PacketNumberLen) error {
+	switch len {
+	case protocol.PacketNumberLen1:
+		b.WriteByte(uint8(i & 0x7f))
+	case protocol.PacketNumberLen2:
+		b.Write([]byte{(uint8(i>>8) & 0x3f) | 0x80, uint8(i)})
+	case protocol.PacketNumberLen4:
+		b.Write([]byte{(uint8(i>>24) & 0x3f) | 0xc0, uint8(i >> 16), uint8(i >> 8), uint8(i)})
+	default:
+		return fmt.Errorf("invalid packet number length: %d", len)
+	}
+	return nil
+}