diff options
author | Alex Pilon <apilon@hashicorp.com> | 2019-02-22 18:24:37 -0500 |
---|---|---|
committer | Alex Pilon <apilon@hashicorp.com> | 2019-02-22 18:24:37 -0500 |
commit | 15c0b25d011f37e7c20aeca9eaf461f78285b8d9 (patch) | |
tree | 255c250a5c9d4801c74092d33b7337d8c14438ff /vendor/golang.org/x/net/http2/http2.go | |
parent | 07971ca38143c5faf951d152fba370ddcbe26ad5 (diff) | |
download | terraform-provider-statuscake-15c0b25d011f37e7c20aeca9eaf461f78285b8d9.tar.gz terraform-provider-statuscake-15c0b25d011f37e7c20aeca9eaf461f78285b8d9.tar.zst terraform-provider-statuscake-15c0b25d011f37e7c20aeca9eaf461f78285b8d9.zip |
deps: github.com/hashicorp/terraform@sdk-v0.11-with-go-modules
Updated via: go get github.com/hashicorp/terraform@sdk-v0.11-with-go-modules and go mod tidy
Diffstat (limited to 'vendor/golang.org/x/net/http2/http2.go')
-rw-r--r-- | vendor/golang.org/x/net/http2/http2.go | 391 |
1 files changed, 391 insertions, 0 deletions
diff --git a/vendor/golang.org/x/net/http2/http2.go b/vendor/golang.org/x/net/http2/http2.go new file mode 100644 index 0000000..d565f40 --- /dev/null +++ b/vendor/golang.org/x/net/http2/http2.go | |||
@@ -0,0 +1,391 @@ | |||
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 http2 implements the HTTP/2 protocol. | ||
6 | // | ||
7 | // This package is low-level and intended to be used directly by very | ||
8 | // few people. Most users will use it indirectly through the automatic | ||
9 | // use by the net/http package (from Go 1.6 and later). | ||
10 | // For use in earlier Go versions see ConfigureServer. (Transport support | ||
11 | // requires Go 1.6 or later) | ||
12 | // | ||
13 | // See https://http2.github.io/ for more information on HTTP/2. | ||
14 | // | ||
15 | // See https://http2.golang.org/ for a test server running this code. | ||
16 | // | ||
17 | package http2 // import "golang.org/x/net/http2" | ||
18 | |||
19 | import ( | ||
20 | "bufio" | ||
21 | "crypto/tls" | ||
22 | "errors" | ||
23 | "fmt" | ||
24 | "io" | ||
25 | "net/http" | ||
26 | "os" | ||
27 | "sort" | ||
28 | "strconv" | ||
29 | "strings" | ||
30 | "sync" | ||
31 | |||
32 | "golang.org/x/net/lex/httplex" | ||
33 | ) | ||
34 | |||
35 | var ( | ||
36 | VerboseLogs bool | ||
37 | logFrameWrites bool | ||
38 | logFrameReads bool | ||
39 | inTests bool | ||
40 | ) | ||
41 | |||
42 | func init() { | ||
43 | e := os.Getenv("GODEBUG") | ||
44 | if strings.Contains(e, "http2debug=1") { | ||
45 | VerboseLogs = true | ||
46 | } | ||
47 | if strings.Contains(e, "http2debug=2") { | ||
48 | VerboseLogs = true | ||
49 | logFrameWrites = true | ||
50 | logFrameReads = true | ||
51 | } | ||
52 | } | ||
53 | |||
54 | const ( | ||
55 | // ClientPreface is the string that must be sent by new | ||
56 | // connections from clients. | ||
57 | ClientPreface = "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n" | ||
58 | |||
59 | // SETTINGS_MAX_FRAME_SIZE default | ||
60 | // http://http2.github.io/http2-spec/#rfc.section.6.5.2 | ||
61 | initialMaxFrameSize = 16384 | ||
62 | |||
63 | // NextProtoTLS is the NPN/ALPN protocol negotiated during | ||
64 | // HTTP/2's TLS setup. | ||
65 | NextProtoTLS = "h2" | ||
66 | |||
67 | // http://http2.github.io/http2-spec/#SettingValues | ||
68 | initialHeaderTableSize = 4096 | ||
69 | |||
70 | initialWindowSize = 65535 // 6.9.2 Initial Flow Control Window Size | ||
71 | |||
72 | defaultMaxReadFrameSize = 1 << 20 | ||
73 | ) | ||
74 | |||
75 | var ( | ||
76 | clientPreface = []byte(ClientPreface) | ||
77 | ) | ||
78 | |||
79 | type streamState int | ||
80 | |||
81 | // HTTP/2 stream states. | ||
82 | // | ||
83 | // See http://tools.ietf.org/html/rfc7540#section-5.1. | ||
84 | // | ||
85 | // For simplicity, the server code merges "reserved (local)" into | ||
86 | // "half-closed (remote)". This is one less state transition to track. | ||
87 | // The only downside is that we send PUSH_PROMISEs slightly less | ||
88 | // liberally than allowable. More discussion here: | ||
89 | // https://lists.w3.org/Archives/Public/ietf-http-wg/2016JulSep/0599.html | ||
90 | // | ||
91 | // "reserved (remote)" is omitted since the client code does not | ||
92 | // support server push. | ||
93 | const ( | ||
94 | stateIdle streamState = iota | ||
95 | stateOpen | ||
96 | stateHalfClosedLocal | ||
97 | stateHalfClosedRemote | ||
98 | stateClosed | ||
99 | ) | ||
100 | |||
101 | var stateName = [...]string{ | ||
102 | stateIdle: "Idle", | ||
103 | stateOpen: "Open", | ||
104 | stateHalfClosedLocal: "HalfClosedLocal", | ||
105 | stateHalfClosedRemote: "HalfClosedRemote", | ||
106 | stateClosed: "Closed", | ||
107 | } | ||
108 | |||
109 | func (st streamState) String() string { | ||
110 | return stateName[st] | ||
111 | } | ||
112 | |||
113 | // Setting is a setting parameter: which setting it is, and its value. | ||
114 | type Setting struct { | ||
115 | // ID is which setting is being set. | ||
116 | // See http://http2.github.io/http2-spec/#SettingValues | ||
117 | ID SettingID | ||
118 | |||
119 | // Val is the value. | ||
120 | Val uint32 | ||
121 | } | ||
122 | |||
123 | func (s Setting) String() string { | ||
124 | return fmt.Sprintf("[%v = %d]", s.ID, s.Val) | ||
125 | } | ||
126 | |||
127 | // Valid reports whether the setting is valid. | ||
128 | func (s Setting) Valid() error { | ||
129 | // Limits and error codes from 6.5.2 Defined SETTINGS Parameters | ||
130 | switch s.ID { | ||
131 | case SettingEnablePush: | ||
132 | if s.Val != 1 && s.Val != 0 { | ||
133 | return ConnectionError(ErrCodeProtocol) | ||
134 | } | ||
135 | case SettingInitialWindowSize: | ||
136 | if s.Val > 1<<31-1 { | ||
137 | return ConnectionError(ErrCodeFlowControl) | ||
138 | } | ||
139 | case SettingMaxFrameSize: | ||
140 | if s.Val < 16384 || s.Val > 1<<24-1 { | ||
141 | return ConnectionError(ErrCodeProtocol) | ||
142 | } | ||
143 | } | ||
144 | return nil | ||
145 | } | ||
146 | |||
147 | // A SettingID is an HTTP/2 setting as defined in | ||
148 | // http://http2.github.io/http2-spec/#iana-settings | ||
149 | type SettingID uint16 | ||
150 | |||
151 | const ( | ||
152 | SettingHeaderTableSize SettingID = 0x1 | ||
153 | SettingEnablePush SettingID = 0x2 | ||
154 | SettingMaxConcurrentStreams SettingID = 0x3 | ||
155 | SettingInitialWindowSize SettingID = 0x4 | ||
156 | SettingMaxFrameSize SettingID = 0x5 | ||
157 | SettingMaxHeaderListSize SettingID = 0x6 | ||
158 | ) | ||
159 | |||
160 | var settingName = map[SettingID]string{ | ||
161 | SettingHeaderTableSize: "HEADER_TABLE_SIZE", | ||
162 | SettingEnablePush: "ENABLE_PUSH", | ||
163 | SettingMaxConcurrentStreams: "MAX_CONCURRENT_STREAMS", | ||
164 | SettingInitialWindowSize: "INITIAL_WINDOW_SIZE", | ||
165 | SettingMaxFrameSize: "MAX_FRAME_SIZE", | ||
166 | SettingMaxHeaderListSize: "MAX_HEADER_LIST_SIZE", | ||
167 | } | ||
168 | |||
169 | func (s SettingID) String() string { | ||
170 | if v, ok := settingName[s]; ok { | ||
171 | return v | ||
172 | } | ||
173 | return fmt.Sprintf("UNKNOWN_SETTING_%d", uint16(s)) | ||
174 | } | ||
175 | |||
176 | var ( | ||
177 | errInvalidHeaderFieldName = errors.New("http2: invalid header field name") | ||
178 | errInvalidHeaderFieldValue = errors.New("http2: invalid header field value") | ||
179 | ) | ||
180 | |||
181 | // validWireHeaderFieldName reports whether v is a valid header field | ||
182 | // name (key). See httplex.ValidHeaderName for the base rules. | ||
183 | // | ||
184 | // Further, http2 says: | ||
185 | // "Just as in HTTP/1.x, header field names are strings of ASCII | ||
186 | // characters that are compared in a case-insensitive | ||
187 | // fashion. However, header field names MUST be converted to | ||
188 | // lowercase prior to their encoding in HTTP/2. " | ||
189 | func validWireHeaderFieldName(v string) bool { | ||
190 | if len(v) == 0 { | ||
191 | return false | ||
192 | } | ||
193 | for _, r := range v { | ||
194 | if !httplex.IsTokenRune(r) { | ||
195 | return false | ||
196 | } | ||
197 | if 'A' <= r && r <= 'Z' { | ||
198 | return false | ||
199 | } | ||
200 | } | ||
201 | return true | ||
202 | } | ||
203 | |||
204 | var httpCodeStringCommon = map[int]string{} // n -> strconv.Itoa(n) | ||
205 | |||
206 | func init() { | ||
207 | for i := 100; i <= 999; i++ { | ||
208 | if v := http.StatusText(i); v != "" { | ||
209 | httpCodeStringCommon[i] = strconv.Itoa(i) | ||
210 | } | ||
211 | } | ||
212 | } | ||
213 | |||
214 | func httpCodeString(code int) string { | ||
215 | if s, ok := httpCodeStringCommon[code]; ok { | ||
216 | return s | ||
217 | } | ||
218 | return strconv.Itoa(code) | ||
219 | } | ||
220 | |||
221 | // from pkg io | ||
222 | type stringWriter interface { | ||
223 | WriteString(s string) (n int, err error) | ||
224 | } | ||
225 | |||
226 | // A gate lets two goroutines coordinate their activities. | ||
227 | type gate chan struct{} | ||
228 | |||
229 | func (g gate) Done() { g <- struct{}{} } | ||
230 | func (g gate) Wait() { <-g } | ||
231 | |||
232 | // A closeWaiter is like a sync.WaitGroup but only goes 1 to 0 (open to closed). | ||
233 | type closeWaiter chan struct{} | ||
234 | |||
235 | // Init makes a closeWaiter usable. | ||
236 | // It exists because so a closeWaiter value can be placed inside a | ||
237 | // larger struct and have the Mutex and Cond's memory in the same | ||
238 | // allocation. | ||
239 | func (cw *closeWaiter) Init() { | ||
240 | *cw = make(chan struct{}) | ||
241 | } | ||
242 | |||
243 | // Close marks the closeWaiter as closed and unblocks any waiters. | ||
244 | func (cw closeWaiter) Close() { | ||
245 | close(cw) | ||
246 | } | ||
247 | |||
248 | // Wait waits for the closeWaiter to become closed. | ||
249 | func (cw closeWaiter) Wait() { | ||
250 | <-cw | ||
251 | } | ||
252 | |||
253 | // bufferedWriter is a buffered writer that writes to w. | ||
254 | // Its buffered writer is lazily allocated as needed, to minimize | ||
255 | // idle memory usage with many connections. | ||
256 | type bufferedWriter struct { | ||
257 | w io.Writer // immutable | ||
258 | bw *bufio.Writer // non-nil when data is buffered | ||
259 | } | ||
260 | |||
261 | func newBufferedWriter(w io.Writer) *bufferedWriter { | ||
262 | return &bufferedWriter{w: w} | ||
263 | } | ||
264 | |||
265 | // bufWriterPoolBufferSize is the size of bufio.Writer's | ||
266 | // buffers created using bufWriterPool. | ||
267 | // | ||
268 | // TODO: pick a less arbitrary value? this is a bit under | ||
269 | // (3 x typical 1500 byte MTU) at least. Other than that, | ||
270 | // not much thought went into it. | ||
271 | const bufWriterPoolBufferSize = 4 << 10 | ||
272 | |||
273 | var bufWriterPool = sync.Pool{ | ||
274 | New: func() interface{} { | ||
275 | return bufio.NewWriterSize(nil, bufWriterPoolBufferSize) | ||
276 | }, | ||
277 | } | ||
278 | |||
279 | func (w *bufferedWriter) Available() int { | ||
280 | if w.bw == nil { | ||
281 | return bufWriterPoolBufferSize | ||
282 | } | ||
283 | return w.bw.Available() | ||
284 | } | ||
285 | |||
286 | func (w *bufferedWriter) Write(p []byte) (n int, err error) { | ||
287 | if w.bw == nil { | ||
288 | bw := bufWriterPool.Get().(*bufio.Writer) | ||
289 | bw.Reset(w.w) | ||
290 | w.bw = bw | ||
291 | } | ||
292 | return w.bw.Write(p) | ||
293 | } | ||
294 | |||
295 | func (w *bufferedWriter) Flush() error { | ||
296 | bw := w.bw | ||
297 | if bw == nil { | ||
298 | return nil | ||
299 | } | ||
300 | err := bw.Flush() | ||
301 | bw.Reset(nil) | ||
302 | bufWriterPool.Put(bw) | ||
303 | w.bw = nil | ||
304 | return err | ||
305 | } | ||
306 | |||
307 | func mustUint31(v int32) uint32 { | ||
308 | if v < 0 || v > 2147483647 { | ||
309 | panic("out of range") | ||
310 | } | ||
311 | return uint32(v) | ||
312 | } | ||
313 | |||
314 | // bodyAllowedForStatus reports whether a given response status code | ||
315 | // permits a body. See RFC 2616, section 4.4. | ||
316 | func bodyAllowedForStatus(status int) bool { | ||
317 | switch { | ||
318 | case status >= 100 && status <= 199: | ||
319 | return false | ||
320 | case status == 204: | ||
321 | return false | ||
322 | case status == 304: | ||
323 | return false | ||
324 | } | ||
325 | return true | ||
326 | } | ||
327 | |||
328 | type httpError struct { | ||
329 | msg string | ||
330 | timeout bool | ||
331 | } | ||
332 | |||
333 | func (e *httpError) Error() string { return e.msg } | ||
334 | func (e *httpError) Timeout() bool { return e.timeout } | ||
335 | func (e *httpError) Temporary() bool { return true } | ||
336 | |||
337 | var errTimeout error = &httpError{msg: "http2: timeout awaiting response headers", timeout: true} | ||
338 | |||
339 | type connectionStater interface { | ||
340 | ConnectionState() tls.ConnectionState | ||
341 | } | ||
342 | |||
343 | var sorterPool = sync.Pool{New: func() interface{} { return new(sorter) }} | ||
344 | |||
345 | type sorter struct { | ||
346 | v []string // owned by sorter | ||
347 | } | ||
348 | |||
349 | func (s *sorter) Len() int { return len(s.v) } | ||
350 | func (s *sorter) Swap(i, j int) { s.v[i], s.v[j] = s.v[j], s.v[i] } | ||
351 | func (s *sorter) Less(i, j int) bool { return s.v[i] < s.v[j] } | ||
352 | |||
353 | // Keys returns the sorted keys of h. | ||
354 | // | ||
355 | // The returned slice is only valid until s used again or returned to | ||
356 | // its pool. | ||
357 | func (s *sorter) Keys(h http.Header) []string { | ||
358 | keys := s.v[:0] | ||
359 | for k := range h { | ||
360 | keys = append(keys, k) | ||
361 | } | ||
362 | s.v = keys | ||
363 | sort.Sort(s) | ||
364 | return keys | ||
365 | } | ||
366 | |||
367 | func (s *sorter) SortStrings(ss []string) { | ||
368 | // Our sorter works on s.v, which sorter owns, so | ||
369 | // stash it away while we sort the user's buffer. | ||
370 | save := s.v | ||
371 | s.v = ss | ||
372 | sort.Sort(s) | ||
373 | s.v = save | ||
374 | } | ||
375 | |||
376 | // validPseudoPath reports whether v is a valid :path pseudo-header | ||
377 | // value. It must be either: | ||
378 | // | ||
379 | // *) a non-empty string starting with '/' | ||
380 | // *) the string '*', for OPTIONS requests. | ||
381 | // | ||
382 | // For now this is only used a quick check for deciding when to clean | ||
383 | // up Opaque URLs before sending requests from the Transport. | ||
384 | // See golang.org/issue/16847 | ||
385 | // | ||
386 | // We used to enforce that the path also didn't start with "//", but | ||
387 | // Google's GFE accepts such paths and Chrome sends them, so ignore | ||
388 | // that part of the spec. See golang.org/issue/19103. | ||
389 | func validPseudoPath(v string) bool { | ||
390 | return (len(v) > 0 && v[0] == '/') || v == "*" | ||
391 | } | ||