podman

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
// MaxDynamicTableSize returns the current dynamic header table size.
120
func (e *Encoder) MaxDynamicTableSize() (v uint32) {
121
	return e.dynTab.maxSize
122
}
123

124
// SetMaxDynamicTableSizeLimit changes the maximum value that can be
125
// specified in SetMaxDynamicTableSize to v. By default, it is set to
126
// 4096, which is the same size of the default dynamic header table
127
// size described in HPACK specification. If the current maximum
128
// dynamic header table size is strictly greater than v, "Header Table
129
// Size Update" will be done in the next WriteField call and the
130
// maximum dynamic header table size is truncated to v.
131
func (e *Encoder) SetMaxDynamicTableSizeLimit(v uint32) {
132
	e.maxSizeLimit = v
133
	if e.dynTab.maxSize > v {
134
		e.tableSizeUpdate = true
135
		e.dynTab.setMaxSize(v)
136
	}
137
}
138

139
// shouldIndex reports whether f should be indexed.
140
func (e *Encoder) shouldIndex(f HeaderField) bool {
141
	return !f.Sensitive && f.Size() <= e.dynTab.maxSize
142
}
143

144
// appendIndexed appends index i, as encoded in "Indexed Header Field"
145
// representation, to dst and returns the extended buffer.
146
func appendIndexed(dst []byte, i uint64) []byte {
147
	first := len(dst)
148
	dst = appendVarInt(dst, 7, i)
149
	dst[first] |= 0x80
150
	return dst
151
}
152

153
// appendNewName appends f, as encoded in one of "Literal Header field
154
// - New Name" representation variants, to dst and returns the
155
// extended buffer.
156
//
157
// If f.Sensitive is true, "Never Indexed" representation is used. If
158
// f.Sensitive is false and indexing is true, "Incremental Indexing"
159
// representation is used.
160
func appendNewName(dst []byte, f HeaderField, indexing bool) []byte {
161
	dst = append(dst, encodeTypeByte(indexing, f.Sensitive))
162
	dst = appendHpackString(dst, f.Name)
163
	return appendHpackString(dst, f.Value)
164
}
165

166
// appendIndexedName appends f and index i referring indexed name
167
// entry, as encoded in one of "Literal Header field - Indexed Name"
168
// representation variants, to dst and returns the extended buffer.
169
//
170
// If f.Sensitive is true, "Never Indexed" representation is used. If
171
// f.Sensitive is false and indexing is true, "Incremental Indexing"
172
// representation is used.
173
func appendIndexedName(dst []byte, f HeaderField, i uint64, indexing bool) []byte {
174
	first := len(dst)
175
	var n byte
176
	if indexing {
177
		n = 6
178
	} else {
179
		n = 4
180
	}
181
	dst = appendVarInt(dst, n, i)
182
	dst[first] |= encodeTypeByte(indexing, f.Sensitive)
183
	return appendHpackString(dst, f.Value)
184
}
185

186
// appendTableSize appends v, as encoded in "Header Table Size Update"
187
// representation, to dst and returns the extended buffer.
188
func appendTableSize(dst []byte, v uint32) []byte {
189
	first := len(dst)
190
	dst = appendVarInt(dst, 5, uint64(v))
191
	dst[first] |= 0x20
192
	return dst
193
}
194

195
// appendVarInt appends i, as encoded in variable integer form using n
196
// bit prefix, to dst and returns the extended buffer.
197
//
198
// See
199
// https://httpwg.org/specs/rfc7541.html#integer.representation
200
func appendVarInt(dst []byte, n byte, i uint64) []byte {
201
	k := uint64((1 << n) - 1)
202
	if i < k {
203
		return append(dst, byte(i))
204
	}
205
	dst = append(dst, byte(k))
206
	i -= k
207
	for ; i >= 128; i >>= 7 {
208
		dst = append(dst, byte(0x80|(i&0x7f)))
209
	}
210
	return append(dst, byte(i))
211
}
212

213
// appendHpackString appends s, as encoded in "String Literal"
214
// representation, to dst and returns the extended buffer.
215
//
216
// s will be encoded in Huffman codes only when it produces strictly
217
// shorter byte string.
218
func appendHpackString(dst []byte, s string) []byte {
219
	huffmanLength := HuffmanEncodeLength(s)
220
	if huffmanLength < uint64(len(s)) {
221
		first := len(dst)
222
		dst = appendVarInt(dst, 7, huffmanLength)
223
		dst = AppendHuffmanString(dst, s)
224
		dst[first] |= 0x80
225
	} else {
226
		dst = appendVarInt(dst, 7, uint64(len(s)))
227
		dst = append(dst, s...)
228
	}
229
	return dst
230
}
231

232
// encodeTypeByte returns type byte. If sensitive is true, type byte
233
// for "Never Indexed" representation is returned. If sensitive is
234
// false and indexing is true, type byte for "Incremental Indexing"
235
// representation is returned. Otherwise, type byte for "Without
236
// Indexing" is returned.
237
func encodeTypeByte(indexing, sensitive bool) byte {
238
	if sensitive {
239
		return 0x10
240
	}
241
	if indexing {
242
		return 0x40
243
	}
244
	return 0
245
}
246