mirror of
https://github.com/superseriousbusiness/gotosocial.git
synced 2024-12-05 01:52:46 +00:00
a156188b3e
* update dependencies, bump Go version to 1.19 * bump test image Go version * update golangci-lint * update gotosocial-drone-build * sign * linting, go fmt * update swagger docs * update swagger docs * whitespace * update contributing.md * fuckin whoopsie doopsie * linterino, linteroni * fix followrequest test not starting processor * fix other api/client tests not starting processor * fix remaining tests where processor not started * bump go-runners version * don't check last-webfingered-at, processor may have updated this * update swagger command * update bun to latest version * fix embed to work the same as before with new bun Signed-off-by: kim <grufwub@gmail.com> Co-authored-by: tsmethurst <tobi.smethurst@protonmail.com>
227 lines
5.8 KiB
Go
227 lines
5.8 KiB
Go
// Copyright 2014 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package hpack
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"io"
|
|
"sync"
|
|
)
|
|
|
|
var bufPool = sync.Pool{
|
|
New: func() interface{} { return new(bytes.Buffer) },
|
|
}
|
|
|
|
// HuffmanDecode decodes the string in v and writes the expanded
|
|
// result to w, returning the number of bytes written to w and the
|
|
// Write call's return value. At most one Write call is made.
|
|
func HuffmanDecode(w io.Writer, v []byte) (int, error) {
|
|
buf := bufPool.Get().(*bytes.Buffer)
|
|
buf.Reset()
|
|
defer bufPool.Put(buf)
|
|
if err := huffmanDecode(buf, 0, v); err != nil {
|
|
return 0, err
|
|
}
|
|
return w.Write(buf.Bytes())
|
|
}
|
|
|
|
// HuffmanDecodeToString decodes the string in v.
|
|
func HuffmanDecodeToString(v []byte) (string, error) {
|
|
buf := bufPool.Get().(*bytes.Buffer)
|
|
buf.Reset()
|
|
defer bufPool.Put(buf)
|
|
if err := huffmanDecode(buf, 0, v); err != nil {
|
|
return "", err
|
|
}
|
|
return buf.String(), nil
|
|
}
|
|
|
|
// ErrInvalidHuffman is returned for errors found decoding
|
|
// Huffman-encoded strings.
|
|
var ErrInvalidHuffman = errors.New("hpack: invalid Huffman-encoded data")
|
|
|
|
// huffmanDecode decodes v to buf.
|
|
// If maxLen is greater than 0, attempts to write more to buf than
|
|
// maxLen bytes will return ErrStringLength.
|
|
func huffmanDecode(buf *bytes.Buffer, maxLen int, v []byte) error {
|
|
rootHuffmanNode := getRootHuffmanNode()
|
|
n := rootHuffmanNode
|
|
// cur is the bit buffer that has not been fed into n.
|
|
// cbits is the number of low order bits in cur that are valid.
|
|
// sbits is the number of bits of the symbol prefix being decoded.
|
|
cur, cbits, sbits := uint(0), uint8(0), uint8(0)
|
|
for _, b := range v {
|
|
cur = cur<<8 | uint(b)
|
|
cbits += 8
|
|
sbits += 8
|
|
for cbits >= 8 {
|
|
idx := byte(cur >> (cbits - 8))
|
|
n = n.children[idx]
|
|
if n == nil {
|
|
return ErrInvalidHuffman
|
|
}
|
|
if n.children == nil {
|
|
if maxLen != 0 && buf.Len() == maxLen {
|
|
return ErrStringLength
|
|
}
|
|
buf.WriteByte(n.sym)
|
|
cbits -= n.codeLen
|
|
n = rootHuffmanNode
|
|
sbits = cbits
|
|
} else {
|
|
cbits -= 8
|
|
}
|
|
}
|
|
}
|
|
for cbits > 0 {
|
|
n = n.children[byte(cur<<(8-cbits))]
|
|
if n == nil {
|
|
return ErrInvalidHuffman
|
|
}
|
|
if n.children != nil || n.codeLen > cbits {
|
|
break
|
|
}
|
|
if maxLen != 0 && buf.Len() == maxLen {
|
|
return ErrStringLength
|
|
}
|
|
buf.WriteByte(n.sym)
|
|
cbits -= n.codeLen
|
|
n = rootHuffmanNode
|
|
sbits = cbits
|
|
}
|
|
if sbits > 7 {
|
|
// Either there was an incomplete symbol, or overlong padding.
|
|
// Both are decoding errors per RFC 7541 section 5.2.
|
|
return ErrInvalidHuffman
|
|
}
|
|
if mask := uint(1<<cbits - 1); cur&mask != mask {
|
|
// Trailing bits must be a prefix of EOS per RFC 7541 section 5.2.
|
|
return ErrInvalidHuffman
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// incomparable is a zero-width, non-comparable type. Adding it to a struct
|
|
// makes that struct also non-comparable, and generally doesn't add
|
|
// any size (as long as it's first).
|
|
type incomparable [0]func()
|
|
|
|
type node struct {
|
|
_ incomparable
|
|
|
|
// children is non-nil for internal nodes
|
|
children *[256]*node
|
|
|
|
// The following are only valid if children is nil:
|
|
codeLen uint8 // number of bits that led to the output of sym
|
|
sym byte // output symbol
|
|
}
|
|
|
|
func newInternalNode() *node {
|
|
return &node{children: new([256]*node)}
|
|
}
|
|
|
|
var (
|
|
buildRootOnce sync.Once
|
|
lazyRootHuffmanNode *node
|
|
)
|
|
|
|
func getRootHuffmanNode() *node {
|
|
buildRootOnce.Do(buildRootHuffmanNode)
|
|
return lazyRootHuffmanNode
|
|
}
|
|
|
|
func buildRootHuffmanNode() {
|
|
if len(huffmanCodes) != 256 {
|
|
panic("unexpected size")
|
|
}
|
|
lazyRootHuffmanNode = newInternalNode()
|
|
// allocate a leaf node for each of the 256 symbols
|
|
leaves := new([256]node)
|
|
|
|
for sym, code := range huffmanCodes {
|
|
codeLen := huffmanCodeLen[sym]
|
|
|
|
cur := lazyRootHuffmanNode
|
|
for codeLen > 8 {
|
|
codeLen -= 8
|
|
i := uint8(code >> codeLen)
|
|
if cur.children[i] == nil {
|
|
cur.children[i] = newInternalNode()
|
|
}
|
|
cur = cur.children[i]
|
|
}
|
|
shift := 8 - codeLen
|
|
start, end := int(uint8(code<<shift)), int(1<<shift)
|
|
|
|
leaves[sym].sym = byte(sym)
|
|
leaves[sym].codeLen = codeLen
|
|
for i := start; i < start+end; i++ {
|
|
cur.children[i] = &leaves[sym]
|
|
}
|
|
}
|
|
}
|
|
|
|
// AppendHuffmanString appends s, as encoded in Huffman codes, to dst
|
|
// and returns the extended buffer.
|
|
func AppendHuffmanString(dst []byte, s string) []byte {
|
|
// This relies on the maximum huffman code length being 30 (See tables.go huffmanCodeLen array)
|
|
// So if a uint64 buffer has less than 32 valid bits can always accommodate another huffmanCode.
|
|
var (
|
|
x uint64 // buffer
|
|
n uint // number valid of bits present in x
|
|
)
|
|
for i := 0; i < len(s); i++ {
|
|
c := s[i]
|
|
n += uint(huffmanCodeLen[c])
|
|
x <<= huffmanCodeLen[c] % 64
|
|
x |= uint64(huffmanCodes[c])
|
|
if n >= 32 {
|
|
n %= 32 // Normally would be -= 32 but %= 32 informs compiler 0 <= n <= 31 for upcoming shift
|
|
y := uint32(x >> n) // Compiler doesn't combine memory writes if y isn't uint32
|
|
dst = append(dst, byte(y>>24), byte(y>>16), byte(y>>8), byte(y))
|
|
}
|
|
}
|
|
// Add padding bits if necessary
|
|
if over := n % 8; over > 0 {
|
|
const (
|
|
eosCode = 0x3fffffff
|
|
eosNBits = 30
|
|
eosPadByte = eosCode >> (eosNBits - 8)
|
|
)
|
|
pad := 8 - over
|
|
x = (x << pad) | (eosPadByte >> over)
|
|
n += pad // 8 now divides into n exactly
|
|
}
|
|
// n in (0, 8, 16, 24, 32)
|
|
switch n / 8 {
|
|
case 0:
|
|
return dst
|
|
case 1:
|
|
return append(dst, byte(x))
|
|
case 2:
|
|
y := uint16(x)
|
|
return append(dst, byte(y>>8), byte(y))
|
|
case 3:
|
|
y := uint16(x >> 8)
|
|
return append(dst, byte(y>>8), byte(y), byte(x))
|
|
}
|
|
// case 4:
|
|
y := uint32(x)
|
|
return append(dst, byte(y>>24), byte(y>>16), byte(y>>8), byte(y))
|
|
}
|
|
|
|
// HuffmanEncodeLength returns the number of bytes required to encode
|
|
// s in Huffman codes. The result is round up to byte boundary.
|
|
func HuffmanEncodeLength(s string) uint64 {
|
|
n := uint64(0)
|
|
for i := 0; i < len(s); i++ {
|
|
n += uint64(huffmanCodeLen[s[i]])
|
|
}
|
|
return (n + 7) / 8
|
|
}
|