gtsocial-umbx

encode.go (7267B)

---

 // 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 (
 	"io"
 )
 
 const (
 	uint32Max              = ^uint32(0)
 	initialHeaderTableSize = 4096
 )
 
 type Encoder struct {
 	dynTab dynamicTable
 	// minSize is the minimum table size set by
 	// SetMaxDynamicTableSize after the previous Header Table Size
 	// Update.
 	minSize uint32
 	// maxSizeLimit is the maximum table size this encoder
 	// supports. This will protect the encoder from too large
 	// size.
 	maxSizeLimit uint32
 	// tableSizeUpdate indicates whether "Header Table Size
 	// Update" is required.
 	tableSizeUpdate bool
 	w               io.Writer
 	buf             []byte
 }
 
 // NewEncoder returns a new Encoder which performs HPACK encoding. An
 // encoded data is written to w.
 func NewEncoder(w io.Writer) *Encoder {
 	e := &Encoder{
 		minSize:         uint32Max,
 		maxSizeLimit:    initialHeaderTableSize,
 		tableSizeUpdate: false,
 		w:               w,
 	}
 	e.dynTab.table.init()
 	e.dynTab.setMaxSize(initialHeaderTableSize)
 	return e
 }
 
 // WriteField encodes f into a single Write to e's underlying Writer.
 // This function may also produce bytes for "Header Table Size Update"
 // if necessary. If produced, it is done before encoding f.
 func (e *Encoder) WriteField(f HeaderField) error {
 	e.buf = e.buf[:0]
 
 	if e.tableSizeUpdate {
 		e.tableSizeUpdate = false
 		if e.minSize < e.dynTab.maxSize {
 			e.buf = appendTableSize(e.buf, e.minSize)
 		}
 		e.minSize = uint32Max
 		e.buf = appendTableSize(e.buf, e.dynTab.maxSize)
 	}
 
 	idx, nameValueMatch := e.searchTable(f)
 	if nameValueMatch {
 		e.buf = appendIndexed(e.buf, idx)
 	} else {
 		indexing := e.shouldIndex(f)
 		if indexing {
 			e.dynTab.add(f)
 		}
 
 		if idx == 0 {
 			e.buf = appendNewName(e.buf, f, indexing)
 		} else {
 			e.buf = appendIndexedName(e.buf, f, idx, indexing)
 		}
 	}
 	n, err := e.w.Write(e.buf)
 	if err == nil && n != len(e.buf) {
 		err = io.ErrShortWrite
 	}
 	return err
 }
 
 // searchTable searches f in both stable and dynamic header tables.
 // The static header table is searched first. Only when there is no
 // exact match for both name and value, the dynamic header table is
 // then searched. If there is no match, i is 0. If both name and value
 // match, i is the matched index and nameValueMatch becomes true. If
 // only name matches, i points to that index and nameValueMatch
 // becomes false.
 func (e *Encoder) searchTable(f HeaderField) (i uint64, nameValueMatch bool) {
 	i, nameValueMatch = staticTable.search(f)
 	if nameValueMatch {
 		return i, true
 	}
 
 	j, nameValueMatch := e.dynTab.table.search(f)
 	if nameValueMatch || (i == 0 && j != 0) {
 		return j + uint64(staticTable.len()), nameValueMatch
 	}
 
 	return i, false
 }
 
 // SetMaxDynamicTableSize changes the dynamic header table size to v.
 // The actual size is bounded by the value passed to
 // SetMaxDynamicTableSizeLimit.
 func (e *Encoder) SetMaxDynamicTableSize(v uint32) {
 	if v > e.maxSizeLimit {
 		v = e.maxSizeLimit
 	}
 	if v < e.minSize {
 		e.minSize = v
 	}
 	e.tableSizeUpdate = true
 	e.dynTab.setMaxSize(v)
 }
 
 // MaxDynamicTableSize returns the current dynamic header table size.
 func (e *Encoder) MaxDynamicTableSize() (v uint32) {
 	return e.dynTab.maxSize
 }
 
 // SetMaxDynamicTableSizeLimit changes the maximum value that can be
 // specified in SetMaxDynamicTableSize to v. By default, it is set to
 // 4096, which is the same size of the default dynamic header table
 // size described in HPACK specification. If the current maximum
 // dynamic header table size is strictly greater than v, "Header Table
 // Size Update" will be done in the next WriteField call and the
 // maximum dynamic header table size is truncated to v.
 func (e *Encoder) SetMaxDynamicTableSizeLimit(v uint32) {
 	e.maxSizeLimit = v
 	if e.dynTab.maxSize > v {
 		e.tableSizeUpdate = true
 		e.dynTab.setMaxSize(v)
 	}
 }
 
 // shouldIndex reports whether f should be indexed.
 func (e *Encoder) shouldIndex(f HeaderField) bool {
 	return !f.Sensitive && f.Size() <= e.dynTab.maxSize
 }
 
 // appendIndexed appends index i, as encoded in "Indexed Header Field"
 // representation, to dst and returns the extended buffer.
 func appendIndexed(dst []byte, i uint64) []byte {
 	first := len(dst)
 	dst = appendVarInt(dst, 7, i)
 	dst[first] |= 0x80
 	return dst
 }
 
 // appendNewName appends f, as encoded in one of "Literal Header field
 // - New Name" representation variants, to dst and returns the
 // extended buffer.
 //
 // If f.Sensitive is true, "Never Indexed" representation is used. If
 // f.Sensitive is false and indexing is true, "Incremental Indexing"
 // representation is used.
 func appendNewName(dst []byte, f HeaderField, indexing bool) []byte {
 	dst = append(dst, encodeTypeByte(indexing, f.Sensitive))
 	dst = appendHpackString(dst, f.Name)
 	return appendHpackString(dst, f.Value)
 }
 
 // appendIndexedName appends f and index i referring indexed name
 // entry, as encoded in one of "Literal Header field - Indexed Name"
 // representation variants, to dst and returns the extended buffer.
 //
 // If f.Sensitive is true, "Never Indexed" representation is used. If
 // f.Sensitive is false and indexing is true, "Incremental Indexing"
 // representation is used.
 func appendIndexedName(dst []byte, f HeaderField, i uint64, indexing bool) []byte {
 	first := len(dst)
 	var n byte
 	if indexing {
 		n = 6
 	} else {
 		n = 4
 	}
 	dst = appendVarInt(dst, n, i)
 	dst[first] |= encodeTypeByte(indexing, f.Sensitive)
 	return appendHpackString(dst, f.Value)
 }
 
 // appendTableSize appends v, as encoded in "Header Table Size Update"
 // representation, to dst and returns the extended buffer.
 func appendTableSize(dst []byte, v uint32) []byte {
 	first := len(dst)
 	dst = appendVarInt(dst, 5, uint64(v))
 	dst[first] |= 0x20
 	return dst
 }
 
 // appendVarInt appends i, as encoded in variable integer form using n
 // bit prefix, to dst and returns the extended buffer.
 //
 // See
 // https://httpwg.org/specs/rfc7541.html#integer.representation
 func appendVarInt(dst []byte, n byte, i uint64) []byte {
 	k := uint64((1 << n) - 1)
 	if i < k {
 		return append(dst, byte(i))
 	}
 	dst = append(dst, byte(k))
 	i -= k
 	for ; i >= 128; i >>= 7 {
 		dst = append(dst, byte(0x80|(i&0x7f)))
 	}
 	return append(dst, byte(i))
 }
 
 // appendHpackString appends s, as encoded in "String Literal"
 // representation, to dst and returns the extended buffer.
 //
 // s will be encoded in Huffman codes only when it produces strictly
 // shorter byte string.
 func appendHpackString(dst []byte, s string) []byte {
 	huffmanLength := HuffmanEncodeLength(s)
 	if huffmanLength < uint64(len(s)) {
 		first := len(dst)
 		dst = appendVarInt(dst, 7, huffmanLength)
 		dst = AppendHuffmanString(dst, s)
 		dst[first] |= 0x80
 	} else {
 		dst = appendVarInt(dst, 7, uint64(len(s)))
 		dst = append(dst, s...)
 	}
 	return dst
 }
 
 // encodeTypeByte returns type byte. If sensitive is true, type byte
 // for "Never Indexed" representation is returned. If sensitive is
 // false and indexing is true, type byte for "Incremental Indexing"
 // representation is returned. Otherwise, type byte for "Without
 // Indexing" is returned.
 func encodeTypeByte(indexing, sensitive bool) byte {
 	if sensitive {
 		return 0x10
 	}
 	if indexing {
 		return 0x40
 	}
 	return 0
 }