Source file src/pkg/vendor/golang.org/x/net/http2/hpack/encode.go

     1	// Copyright 2014 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	package hpack
     6	
     7	import (
     8		"io"
     9	)
    10	
    11	const (
    12		uint32Max              = ^uint32(0)
    13		initialHeaderTableSize = 4096
    14	)
    15	
    16	type Encoder struct {
    17		dynTab dynamicTable
    18		// minSize is the minimum table size set by
    19		// SetMaxDynamicTableSize after the previous Header Table Size
    20		// Update.
    21		minSize uint32
    22		// maxSizeLimit is the maximum table size this encoder
    23		// supports. This will protect the encoder from too large
    24		// size.
    25		maxSizeLimit uint32
    26		// tableSizeUpdate indicates whether "Header Table Size
    27		// Update" is required.
    28		tableSizeUpdate bool
    29		w               io.Writer
    30		buf             []byte
    31	}
    32	
    33	// NewEncoder returns a new Encoder which performs HPACK encoding. An
    34	// encoded data is written to w.
    35	func NewEncoder(w io.Writer) *Encoder {
    36		e := &Encoder{
    37			minSize:         uint32Max,
    38			maxSizeLimit:    initialHeaderTableSize,
    39			tableSizeUpdate: false,
    40			w:               w,
    41		}
    42		e.dynTab.table.init()
    43		e.dynTab.setMaxSize(initialHeaderTableSize)
    44		return e
    45	}
    46	
    47	// WriteField encodes f into a single Write to e's underlying Writer.
    48	// This function may also produce bytes for "Header Table Size Update"
    49	// if necessary. If produced, it is done before encoding f.
    50	func (e *Encoder) WriteField(f HeaderField) error {
    51		e.buf = e.buf[:0]
    52	
    53		if e.tableSizeUpdate {
    54			e.tableSizeUpdate = false
    55			if e.minSize < e.dynTab.maxSize {
    56				e.buf = appendTableSize(e.buf, e.minSize)
    57			}
    58			e.minSize = uint32Max
    59			e.buf = appendTableSize(e.buf, e.dynTab.maxSize)
    60		}
    61	
    62		idx, nameValueMatch := e.searchTable(f)
    63		if nameValueMatch {
    64			e.buf = appendIndexed(e.buf, idx)
    65		} else {
    66			indexing := e.shouldIndex(f)
    67			if indexing {
    68				e.dynTab.add(f)
    69			}
    70	
    71			if idx == 0 {
    72				e.buf = appendNewName(e.buf, f, indexing)
    73			} else {
    74				e.buf = appendIndexedName(e.buf, f, idx, indexing)
    75			}
    76		}
    77		n, err := e.w.Write(e.buf)
    78		if err == nil && n != len(e.buf) {
    79			err = io.ErrShortWrite
    80		}
    81		return err
    82	}
    83	
    84	// searchTable searches f in both stable and dynamic header tables.
    85	// The static header table is searched first. Only when there is no
    86	// exact match for both name and value, the dynamic header table is
    87	// then searched. If there is no match, i is 0. If both name and value
    88	// match, i is the matched index and nameValueMatch becomes true. If
    89	// only name matches, i points to that index and nameValueMatch
    90	// becomes false.
    91	func (e *Encoder) searchTable(f HeaderField) (i uint64, nameValueMatch bool) {
    92		i, nameValueMatch = staticTable.search(f)
    93		if nameValueMatch {
    94			return i, true
    95		}
    96	
    97		j, nameValueMatch := e.dynTab.table.search(f)
    98		if nameValueMatch || (i == 0 && j != 0) {
    99			return j + uint64(staticTable.len()), nameValueMatch
   100		}
   101	
   102		return i, false
   103	}
   104	
   105	// SetMaxDynamicTableSize changes the dynamic header table size to v.
   106	// The actual size is bounded by the value passed to
   107	// SetMaxDynamicTableSizeLimit.
   108	func (e *Encoder) SetMaxDynamicTableSize(v uint32) {
   109		if v > e.maxSizeLimit {
   110			v = e.maxSizeLimit
   111		}
   112		if v < e.minSize {
   113			e.minSize = v
   114		}
   115		e.tableSizeUpdate = true
   116		e.dynTab.setMaxSize(v)
   117	}
   118	
   119	// SetMaxDynamicTableSizeLimit changes the maximum value that can be
   120	// specified in SetMaxDynamicTableSize to v. By default, it is set to
   121	// 4096, which is the same size of the default dynamic header table
   122	// size described in HPACK specification. If the current maximum
   123	// dynamic header table size is strictly greater than v, "Header Table
   124	// Size Update" will be done in the next WriteField call and the
   125	// maximum dynamic header table size is truncated to v.
   126	func (e *Encoder) SetMaxDynamicTableSizeLimit(v uint32) {
   127		e.maxSizeLimit = v
   128		if e.dynTab.maxSize > v {
   129			e.tableSizeUpdate = true
   130			e.dynTab.setMaxSize(v)
   131		}
   132	}
   133	
   134	// shouldIndex reports whether f should be indexed.
   135	func (e *Encoder) shouldIndex(f HeaderField) bool {
   136		return !f.Sensitive && f.Size() <= e.dynTab.maxSize
   137	}
   138	
   139	// appendIndexed appends index i, as encoded in "Indexed Header Field"
   140	// representation, to dst and returns the extended buffer.
   141	func appendIndexed(dst []byte, i uint64) []byte {
   142		first := len(dst)
   143		dst = appendVarInt(dst, 7, i)
   144		dst[first] |= 0x80
   145		return dst
   146	}
   147	
   148	// appendNewName appends f, as encoded in one of "Literal Header field
   149	// - New Name" representation variants, to dst and returns the
   150	// extended buffer.
   151	//
   152	// If f.Sensitive is true, "Never Indexed" representation is used. If
   153	// f.Sensitive is false and indexing is true, "Inremental Indexing"
   154	// representation is used.
   155	func appendNewName(dst []byte, f HeaderField, indexing bool) []byte {
   156		dst = append(dst, encodeTypeByte(indexing, f.Sensitive))
   157		dst = appendHpackString(dst, f.Name)
   158		return appendHpackString(dst, f.Value)
   159	}
   160	
   161	// appendIndexedName appends f and index i referring indexed name
   162	// entry, as encoded in one of "Literal Header field - Indexed Name"
   163	// representation variants, to dst and returns the extended buffer.
   164	//
   165	// If f.Sensitive is true, "Never Indexed" representation is used. If
   166	// f.Sensitive is false and indexing is true, "Incremental Indexing"
   167	// representation is used.
   168	func appendIndexedName(dst []byte, f HeaderField, i uint64, indexing bool) []byte {
   169		first := len(dst)
   170		var n byte
   171		if indexing {
   172			n = 6
   173		} else {
   174			n = 4
   175		}
   176		dst = appendVarInt(dst, n, i)
   177		dst[first] |= encodeTypeByte(indexing, f.Sensitive)
   178		return appendHpackString(dst, f.Value)
   179	}
   180	
   181	// appendTableSize appends v, as encoded in "Header Table Size Update"
   182	// representation, to dst and returns the extended buffer.
   183	func appendTableSize(dst []byte, v uint32) []byte {
   184		first := len(dst)
   185		dst = appendVarInt(dst, 5, uint64(v))
   186		dst[first] |= 0x20
   187		return dst
   188	}
   189	
   190	// appendVarInt appends i, as encoded in variable integer form using n
   191	// bit prefix, to dst and returns the extended buffer.
   192	//
   193	// See
   194	// http://http2.github.io/http2-spec/compression.html#integer.representation
   195	func appendVarInt(dst []byte, n byte, i uint64) []byte {
   196		k := uint64((1 << n) - 1)
   197		if i < k {
   198			return append(dst, byte(i))
   199		}
   200		dst = append(dst, byte(k))
   201		i -= k
   202		for ; i >= 128; i >>= 7 {
   203			dst = append(dst, byte(0x80|(i&0x7f)))
   204		}
   205		return append(dst, byte(i))
   206	}
   207	
   208	// appendHpackString appends s, as encoded in "String Literal"
   209	// representation, to dst and returns the extended buffer.
   210	//
   211	// s will be encoded in Huffman codes only when it produces strictly
   212	// shorter byte string.
   213	func appendHpackString(dst []byte, s string) []byte {
   214		huffmanLength := HuffmanEncodeLength(s)
   215		if huffmanLength < uint64(len(s)) {
   216			first := len(dst)
   217			dst = appendVarInt(dst, 7, huffmanLength)
   218			dst = AppendHuffmanString(dst, s)
   219			dst[first] |= 0x80
   220		} else {
   221			dst = appendVarInt(dst, 7, uint64(len(s)))
   222			dst = append(dst, s...)
   223		}
   224		return dst
   225	}
   226	
   227	// encodeTypeByte returns type byte. If sensitive is true, type byte
   228	// for "Never Indexed" representation is returned. If sensitive is
   229	// false and indexing is true, type byte for "Incremental Indexing"
   230	// representation is returned. Otherwise, type byte for "Without
   231	// Indexing" is returned.
   232	func encodeTypeByte(indexing, sensitive bool) byte {
   233		if sensitive {
   234			return 0x10
   235		}
   236		if indexing {
   237			return 0x40
   238		}
   239		return 0
   240	}
   241	

View as plain text