Source file
src/net/http/h2_bundle.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package http
20
21 import (
22 "bufio"
23 "bytes"
24 "compress/gzip"
25 "context"
26 "crypto/rand"
27 "crypto/tls"
28 "encoding/binary"
29 "errors"
30 "fmt"
31 "io"
32 "io/ioutil"
33 "log"
34 "math"
35 mathrand "math/rand"
36 "net"
37 "net/http/httptrace"
38 "net/textproto"
39 "net/url"
40 "os"
41 "reflect"
42 "runtime"
43 "sort"
44 "strconv"
45 "strings"
46 "sync"
47 "sync/atomic"
48 "time"
49
50 "golang.org/x/net/http/httpguts"
51 "golang.org/x/net/http2/hpack"
52 "golang.org/x/net/idna"
53 )
54
55
56
57
58 const (
59 http2cipher_TLS_NULL_WITH_NULL_NULL uint16 = 0x0000
60 http2cipher_TLS_RSA_WITH_NULL_MD5 uint16 = 0x0001
61 http2cipher_TLS_RSA_WITH_NULL_SHA uint16 = 0x0002
62 http2cipher_TLS_RSA_EXPORT_WITH_RC4_40_MD5 uint16 = 0x0003
63 http2cipher_TLS_RSA_WITH_RC4_128_MD5 uint16 = 0x0004
64 http2cipher_TLS_RSA_WITH_RC4_128_SHA uint16 = 0x0005
65 http2cipher_TLS_RSA_EXPORT_WITH_RC2_CBC_40_MD5 uint16 = 0x0006
66 http2cipher_TLS_RSA_WITH_IDEA_CBC_SHA uint16 = 0x0007
67 http2cipher_TLS_RSA_EXPORT_WITH_DES40_CBC_SHA uint16 = 0x0008
68 http2cipher_TLS_RSA_WITH_DES_CBC_SHA uint16 = 0x0009
69 http2cipher_TLS_RSA_WITH_3DES_EDE_CBC_SHA uint16 = 0x000A
70 http2cipher_TLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHA uint16 = 0x000B
71 http2cipher_TLS_DH_DSS_WITH_DES_CBC_SHA uint16 = 0x000C
72 http2cipher_TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA uint16 = 0x000D
73 http2cipher_TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA uint16 = 0x000E
74 http2cipher_TLS_DH_RSA_WITH_DES_CBC_SHA uint16 = 0x000F
75 http2cipher_TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA uint16 = 0x0010
76 http2cipher_TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA uint16 = 0x0011
77 http2cipher_TLS_DHE_DSS_WITH_DES_CBC_SHA uint16 = 0x0012
78 http2cipher_TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA uint16 = 0x0013
79 http2cipher_TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA uint16 = 0x0014
80 http2cipher_TLS_DHE_RSA_WITH_DES_CBC_SHA uint16 = 0x0015
81 http2cipher_TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA uint16 = 0x0016
82 http2cipher_TLS_DH_anon_EXPORT_WITH_RC4_40_MD5 uint16 = 0x0017
83 http2cipher_TLS_DH_anon_WITH_RC4_128_MD5 uint16 = 0x0018
84 http2cipher_TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHA uint16 = 0x0019
85 http2cipher_TLS_DH_anon_WITH_DES_CBC_SHA uint16 = 0x001A
86 http2cipher_TLS_DH_anon_WITH_3DES_EDE_CBC_SHA uint16 = 0x001B
87
88 http2cipher_TLS_KRB5_WITH_DES_CBC_SHA uint16 = 0x001E
89 http2cipher_TLS_KRB5_WITH_3DES_EDE_CBC_SHA uint16 = 0x001F
90 http2cipher_TLS_KRB5_WITH_RC4_128_SHA uint16 = 0x0020
91 http2cipher_TLS_KRB5_WITH_IDEA_CBC_SHA uint16 = 0x0021
92 http2cipher_TLS_KRB5_WITH_DES_CBC_MD5 uint16 = 0x0022
93 http2cipher_TLS_KRB5_WITH_3DES_EDE_CBC_MD5 uint16 = 0x0023
94 http2cipher_TLS_KRB5_WITH_RC4_128_MD5 uint16 = 0x0024
95 http2cipher_TLS_KRB5_WITH_IDEA_CBC_MD5 uint16 = 0x0025
96 http2cipher_TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA uint16 = 0x0026
97 http2cipher_TLS_KRB5_EXPORT_WITH_RC2_CBC_40_SHA uint16 = 0x0027
98 http2cipher_TLS_KRB5_EXPORT_WITH_RC4_40_SHA uint16 = 0x0028
99 http2cipher_TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5 uint16 = 0x0029
100 http2cipher_TLS_KRB5_EXPORT_WITH_RC2_CBC_40_MD5 uint16 = 0x002A
101 http2cipher_TLS_KRB5_EXPORT_WITH_RC4_40_MD5 uint16 = 0x002B
102 http2cipher_TLS_PSK_WITH_NULL_SHA uint16 = 0x002C
103 http2cipher_TLS_DHE_PSK_WITH_NULL_SHA uint16 = 0x002D
104 http2cipher_TLS_RSA_PSK_WITH_NULL_SHA uint16 = 0x002E
105 http2cipher_TLS_RSA_WITH_AES_128_CBC_SHA uint16 = 0x002F
106 http2cipher_TLS_DH_DSS_WITH_AES_128_CBC_SHA uint16 = 0x0030
107 http2cipher_TLS_DH_RSA_WITH_AES_128_CBC_SHA uint16 = 0x0031
108 http2cipher_TLS_DHE_DSS_WITH_AES_128_CBC_SHA uint16 = 0x0032
109 http2cipher_TLS_DHE_RSA_WITH_AES_128_CBC_SHA uint16 = 0x0033
110 http2cipher_TLS_DH_anon_WITH_AES_128_CBC_SHA uint16 = 0x0034
111 http2cipher_TLS_RSA_WITH_AES_256_CBC_SHA uint16 = 0x0035
112 http2cipher_TLS_DH_DSS_WITH_AES_256_CBC_SHA uint16 = 0x0036
113 http2cipher_TLS_DH_RSA_WITH_AES_256_CBC_SHA uint16 = 0x0037
114 http2cipher_TLS_DHE_DSS_WITH_AES_256_CBC_SHA uint16 = 0x0038
115 http2cipher_TLS_DHE_RSA_WITH_AES_256_CBC_SHA uint16 = 0x0039
116 http2cipher_TLS_DH_anon_WITH_AES_256_CBC_SHA uint16 = 0x003A
117 http2cipher_TLS_RSA_WITH_NULL_SHA256 uint16 = 0x003B
118 http2cipher_TLS_RSA_WITH_AES_128_CBC_SHA256 uint16 = 0x003C
119 http2cipher_TLS_RSA_WITH_AES_256_CBC_SHA256 uint16 = 0x003D
120 http2cipher_TLS_DH_DSS_WITH_AES_128_CBC_SHA256 uint16 = 0x003E
121 http2cipher_TLS_DH_RSA_WITH_AES_128_CBC_SHA256 uint16 = 0x003F
122 http2cipher_TLS_DHE_DSS_WITH_AES_128_CBC_SHA256 uint16 = 0x0040
123 http2cipher_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA uint16 = 0x0041
124 http2cipher_TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA uint16 = 0x0042
125 http2cipher_TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA uint16 = 0x0043
126 http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA uint16 = 0x0044
127 http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA uint16 = 0x0045
128 http2cipher_TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA uint16 = 0x0046
129
130
131
132
133
134 http2cipher_TLS_DHE_RSA_WITH_AES_128_CBC_SHA256 uint16 = 0x0067
135 http2cipher_TLS_DH_DSS_WITH_AES_256_CBC_SHA256 uint16 = 0x0068
136 http2cipher_TLS_DH_RSA_WITH_AES_256_CBC_SHA256 uint16 = 0x0069
137 http2cipher_TLS_DHE_DSS_WITH_AES_256_CBC_SHA256 uint16 = 0x006A
138 http2cipher_TLS_DHE_RSA_WITH_AES_256_CBC_SHA256 uint16 = 0x006B
139 http2cipher_TLS_DH_anon_WITH_AES_128_CBC_SHA256 uint16 = 0x006C
140 http2cipher_TLS_DH_anon_WITH_AES_256_CBC_SHA256 uint16 = 0x006D
141
142 http2cipher_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA uint16 = 0x0084
143 http2cipher_TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA uint16 = 0x0085
144 http2cipher_TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA uint16 = 0x0086
145 http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA uint16 = 0x0087
146 http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA uint16 = 0x0088
147 http2cipher_TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA uint16 = 0x0089
148 http2cipher_TLS_PSK_WITH_RC4_128_SHA uint16 = 0x008A
149 http2cipher_TLS_PSK_WITH_3DES_EDE_CBC_SHA uint16 = 0x008B
150 http2cipher_TLS_PSK_WITH_AES_128_CBC_SHA uint16 = 0x008C
151 http2cipher_TLS_PSK_WITH_AES_256_CBC_SHA uint16 = 0x008D
152 http2cipher_TLS_DHE_PSK_WITH_RC4_128_SHA uint16 = 0x008E
153 http2cipher_TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA uint16 = 0x008F
154 http2cipher_TLS_DHE_PSK_WITH_AES_128_CBC_SHA uint16 = 0x0090
155 http2cipher_TLS_DHE_PSK_WITH_AES_256_CBC_SHA uint16 = 0x0091
156 http2cipher_TLS_RSA_PSK_WITH_RC4_128_SHA uint16 = 0x0092
157 http2cipher_TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA uint16 = 0x0093
158 http2cipher_TLS_RSA_PSK_WITH_AES_128_CBC_SHA uint16 = 0x0094
159 http2cipher_TLS_RSA_PSK_WITH_AES_256_CBC_SHA uint16 = 0x0095
160 http2cipher_TLS_RSA_WITH_SEED_CBC_SHA uint16 = 0x0096
161 http2cipher_TLS_DH_DSS_WITH_SEED_CBC_SHA uint16 = 0x0097
162 http2cipher_TLS_DH_RSA_WITH_SEED_CBC_SHA uint16 = 0x0098
163 http2cipher_TLS_DHE_DSS_WITH_SEED_CBC_SHA uint16 = 0x0099
164 http2cipher_TLS_DHE_RSA_WITH_SEED_CBC_SHA uint16 = 0x009A
165 http2cipher_TLS_DH_anon_WITH_SEED_CBC_SHA uint16 = 0x009B
166 http2cipher_TLS_RSA_WITH_AES_128_GCM_SHA256 uint16 = 0x009C
167 http2cipher_TLS_RSA_WITH_AES_256_GCM_SHA384 uint16 = 0x009D
168 http2cipher_TLS_DHE_RSA_WITH_AES_128_GCM_SHA256 uint16 = 0x009E
169 http2cipher_TLS_DHE_RSA_WITH_AES_256_GCM_SHA384 uint16 = 0x009F
170 http2cipher_TLS_DH_RSA_WITH_AES_128_GCM_SHA256 uint16 = 0x00A0
171 http2cipher_TLS_DH_RSA_WITH_AES_256_GCM_SHA384 uint16 = 0x00A1
172 http2cipher_TLS_DHE_DSS_WITH_AES_128_GCM_SHA256 uint16 = 0x00A2
173 http2cipher_TLS_DHE_DSS_WITH_AES_256_GCM_SHA384 uint16 = 0x00A3
174 http2cipher_TLS_DH_DSS_WITH_AES_128_GCM_SHA256 uint16 = 0x00A4
175 http2cipher_TLS_DH_DSS_WITH_AES_256_GCM_SHA384 uint16 = 0x00A5
176 http2cipher_TLS_DH_anon_WITH_AES_128_GCM_SHA256 uint16 = 0x00A6
177 http2cipher_TLS_DH_anon_WITH_AES_256_GCM_SHA384 uint16 = 0x00A7
178 http2cipher_TLS_PSK_WITH_AES_128_GCM_SHA256 uint16 = 0x00A8
179 http2cipher_TLS_PSK_WITH_AES_256_GCM_SHA384 uint16 = 0x00A9
180 http2cipher_TLS_DHE_PSK_WITH_AES_128_GCM_SHA256 uint16 = 0x00AA
181 http2cipher_TLS_DHE_PSK_WITH_AES_256_GCM_SHA384 uint16 = 0x00AB
182 http2cipher_TLS_RSA_PSK_WITH_AES_128_GCM_SHA256 uint16 = 0x00AC
183 http2cipher_TLS_RSA_PSK_WITH_AES_256_GCM_SHA384 uint16 = 0x00AD
184 http2cipher_TLS_PSK_WITH_AES_128_CBC_SHA256 uint16 = 0x00AE
185 http2cipher_TLS_PSK_WITH_AES_256_CBC_SHA384 uint16 = 0x00AF
186 http2cipher_TLS_PSK_WITH_NULL_SHA256 uint16 = 0x00B0
187 http2cipher_TLS_PSK_WITH_NULL_SHA384 uint16 = 0x00B1
188 http2cipher_TLS_DHE_PSK_WITH_AES_128_CBC_SHA256 uint16 = 0x00B2
189 http2cipher_TLS_DHE_PSK_WITH_AES_256_CBC_SHA384 uint16 = 0x00B3
190 http2cipher_TLS_DHE_PSK_WITH_NULL_SHA256 uint16 = 0x00B4
191 http2cipher_TLS_DHE_PSK_WITH_NULL_SHA384 uint16 = 0x00B5
192 http2cipher_TLS_RSA_PSK_WITH_AES_128_CBC_SHA256 uint16 = 0x00B6
193 http2cipher_TLS_RSA_PSK_WITH_AES_256_CBC_SHA384 uint16 = 0x00B7
194 http2cipher_TLS_RSA_PSK_WITH_NULL_SHA256 uint16 = 0x00B8
195 http2cipher_TLS_RSA_PSK_WITH_NULL_SHA384 uint16 = 0x00B9
196 http2cipher_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0x00BA
197 http2cipher_TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0x00BB
198 http2cipher_TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0x00BC
199 http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0x00BD
200 http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0x00BE
201 http2cipher_TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0x00BF
202 http2cipher_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256 uint16 = 0x00C0
203 http2cipher_TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256 uint16 = 0x00C1
204 http2cipher_TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256 uint16 = 0x00C2
205 http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256 uint16 = 0x00C3
206 http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256 uint16 = 0x00C4
207 http2cipher_TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256 uint16 = 0x00C5
208
209 http2cipher_TLS_EMPTY_RENEGOTIATION_INFO_SCSV uint16 = 0x00FF
210
211 http2cipher_TLS_FALLBACK_SCSV uint16 = 0x5600
212
213 http2cipher_TLS_ECDH_ECDSA_WITH_NULL_SHA uint16 = 0xC001
214 http2cipher_TLS_ECDH_ECDSA_WITH_RC4_128_SHA uint16 = 0xC002
215 http2cipher_TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA uint16 = 0xC003
216 http2cipher_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA uint16 = 0xC004
217 http2cipher_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA uint16 = 0xC005
218 http2cipher_TLS_ECDHE_ECDSA_WITH_NULL_SHA uint16 = 0xC006
219 http2cipher_TLS_ECDHE_ECDSA_WITH_RC4_128_SHA uint16 = 0xC007
220 http2cipher_TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA uint16 = 0xC008
221 http2cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA uint16 = 0xC009
222 http2cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA uint16 = 0xC00A
223 http2cipher_TLS_ECDH_RSA_WITH_NULL_SHA uint16 = 0xC00B
224 http2cipher_TLS_ECDH_RSA_WITH_RC4_128_SHA uint16 = 0xC00C
225 http2cipher_TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA uint16 = 0xC00D
226 http2cipher_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA uint16 = 0xC00E
227 http2cipher_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA uint16 = 0xC00F
228 http2cipher_TLS_ECDHE_RSA_WITH_NULL_SHA uint16 = 0xC010
229 http2cipher_TLS_ECDHE_RSA_WITH_RC4_128_SHA uint16 = 0xC011
230 http2cipher_TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA uint16 = 0xC012
231 http2cipher_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA uint16 = 0xC013
232 http2cipher_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA uint16 = 0xC014
233 http2cipher_TLS_ECDH_anon_WITH_NULL_SHA uint16 = 0xC015
234 http2cipher_TLS_ECDH_anon_WITH_RC4_128_SHA uint16 = 0xC016
235 http2cipher_TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA uint16 = 0xC017
236 http2cipher_TLS_ECDH_anon_WITH_AES_128_CBC_SHA uint16 = 0xC018
237 http2cipher_TLS_ECDH_anon_WITH_AES_256_CBC_SHA uint16 = 0xC019
238 http2cipher_TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA uint16 = 0xC01A
239 http2cipher_TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA uint16 = 0xC01B
240 http2cipher_TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA uint16 = 0xC01C
241 http2cipher_TLS_SRP_SHA_WITH_AES_128_CBC_SHA uint16 = 0xC01D
242 http2cipher_TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA uint16 = 0xC01E
243 http2cipher_TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA uint16 = 0xC01F
244 http2cipher_TLS_SRP_SHA_WITH_AES_256_CBC_SHA uint16 = 0xC020
245 http2cipher_TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA uint16 = 0xC021
246 http2cipher_TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA uint16 = 0xC022
247 http2cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 uint16 = 0xC023
248 http2cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 uint16 = 0xC024
249 http2cipher_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256 uint16 = 0xC025
250 http2cipher_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384 uint16 = 0xC026
251 http2cipher_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 uint16 = 0xC027
252 http2cipher_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 uint16 = 0xC028
253 http2cipher_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256 uint16 = 0xC029
254 http2cipher_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384 uint16 = 0xC02A
255 http2cipher_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 uint16 = 0xC02B
256 http2cipher_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 uint16 = 0xC02C
257 http2cipher_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256 uint16 = 0xC02D
258 http2cipher_TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384 uint16 = 0xC02E
259 http2cipher_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 uint16 = 0xC02F
260 http2cipher_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 uint16 = 0xC030
261 http2cipher_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256 uint16 = 0xC031
262 http2cipher_TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384 uint16 = 0xC032
263 http2cipher_TLS_ECDHE_PSK_WITH_RC4_128_SHA uint16 = 0xC033
264 http2cipher_TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA uint16 = 0xC034
265 http2cipher_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA uint16 = 0xC035
266 http2cipher_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA uint16 = 0xC036
267 http2cipher_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256 uint16 = 0xC037
268 http2cipher_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384 uint16 = 0xC038
269 http2cipher_TLS_ECDHE_PSK_WITH_NULL_SHA uint16 = 0xC039
270 http2cipher_TLS_ECDHE_PSK_WITH_NULL_SHA256 uint16 = 0xC03A
271 http2cipher_TLS_ECDHE_PSK_WITH_NULL_SHA384 uint16 = 0xC03B
272 http2cipher_TLS_RSA_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC03C
273 http2cipher_TLS_RSA_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC03D
274 http2cipher_TLS_DH_DSS_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC03E
275 http2cipher_TLS_DH_DSS_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC03F
276 http2cipher_TLS_DH_RSA_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC040
277 http2cipher_TLS_DH_RSA_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC041
278 http2cipher_TLS_DHE_DSS_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC042
279 http2cipher_TLS_DHE_DSS_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC043
280 http2cipher_TLS_DHE_RSA_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC044
281 http2cipher_TLS_DHE_RSA_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC045
282 http2cipher_TLS_DH_anon_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC046
283 http2cipher_TLS_DH_anon_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC047
284 http2cipher_TLS_ECDHE_ECDSA_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC048
285 http2cipher_TLS_ECDHE_ECDSA_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC049
286 http2cipher_TLS_ECDH_ECDSA_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC04A
287 http2cipher_TLS_ECDH_ECDSA_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC04B
288 http2cipher_TLS_ECDHE_RSA_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC04C
289 http2cipher_TLS_ECDHE_RSA_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC04D
290 http2cipher_TLS_ECDH_RSA_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC04E
291 http2cipher_TLS_ECDH_RSA_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC04F
292 http2cipher_TLS_RSA_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC050
293 http2cipher_TLS_RSA_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC051
294 http2cipher_TLS_DHE_RSA_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC052
295 http2cipher_TLS_DHE_RSA_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC053
296 http2cipher_TLS_DH_RSA_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC054
297 http2cipher_TLS_DH_RSA_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC055
298 http2cipher_TLS_DHE_DSS_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC056
299 http2cipher_TLS_DHE_DSS_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC057
300 http2cipher_TLS_DH_DSS_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC058
301 http2cipher_TLS_DH_DSS_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC059
302 http2cipher_TLS_DH_anon_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC05A
303 http2cipher_TLS_DH_anon_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC05B
304 http2cipher_TLS_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC05C
305 http2cipher_TLS_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC05D
306 http2cipher_TLS_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC05E
307 http2cipher_TLS_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC05F
308 http2cipher_TLS_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC060
309 http2cipher_TLS_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC061
310 http2cipher_TLS_ECDH_RSA_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC062
311 http2cipher_TLS_ECDH_RSA_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC063
312 http2cipher_TLS_PSK_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC064
313 http2cipher_TLS_PSK_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC065
314 http2cipher_TLS_DHE_PSK_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC066
315 http2cipher_TLS_DHE_PSK_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC067
316 http2cipher_TLS_RSA_PSK_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC068
317 http2cipher_TLS_RSA_PSK_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC069
318 http2cipher_TLS_PSK_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC06A
319 http2cipher_TLS_PSK_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC06B
320 http2cipher_TLS_DHE_PSK_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC06C
321 http2cipher_TLS_DHE_PSK_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC06D
322 http2cipher_TLS_RSA_PSK_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC06E
323 http2cipher_TLS_RSA_PSK_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC06F
324 http2cipher_TLS_ECDHE_PSK_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC070
325 http2cipher_TLS_ECDHE_PSK_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC071
326 http2cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0xC072
327 http2cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 uint16 = 0xC073
328 http2cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0xC074
329 http2cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 uint16 = 0xC075
330 http2cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0xC076
331 http2cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384 uint16 = 0xC077
332 http2cipher_TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0xC078
333 http2cipher_TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384 uint16 = 0xC079
334 http2cipher_TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC07A
335 http2cipher_TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC07B
336 http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC07C
337 http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC07D
338 http2cipher_TLS_DH_RSA_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC07E
339 http2cipher_TLS_DH_RSA_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC07F
340 http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC080
341 http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC081
342 http2cipher_TLS_DH_DSS_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC082
343 http2cipher_TLS_DH_DSS_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC083
344 http2cipher_TLS_DH_anon_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC084
345 http2cipher_TLS_DH_anon_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC085
346 http2cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC086
347 http2cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC087
348 http2cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC088
349 http2cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC089
350 http2cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC08A
351 http2cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC08B
352 http2cipher_TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC08C
353 http2cipher_TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC08D
354 http2cipher_TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC08E
355 http2cipher_TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC08F
356 http2cipher_TLS_DHE_PSK_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC090
357 http2cipher_TLS_DHE_PSK_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC091
358 http2cipher_TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC092
359 http2cipher_TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC093
360 http2cipher_TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0xC094
361 http2cipher_TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384 uint16 = 0xC095
362 http2cipher_TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0xC096
363 http2cipher_TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 uint16 = 0xC097
364 http2cipher_TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0xC098
365 http2cipher_TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384 uint16 = 0xC099
366 http2cipher_TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0xC09A
367 http2cipher_TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 uint16 = 0xC09B
368 http2cipher_TLS_RSA_WITH_AES_128_CCM uint16 = 0xC09C
369 http2cipher_TLS_RSA_WITH_AES_256_CCM uint16 = 0xC09D
370 http2cipher_TLS_DHE_RSA_WITH_AES_128_CCM uint16 = 0xC09E
371 http2cipher_TLS_DHE_RSA_WITH_AES_256_CCM uint16 = 0xC09F
372 http2cipher_TLS_RSA_WITH_AES_128_CCM_8 uint16 = 0xC0A0
373 http2cipher_TLS_RSA_WITH_AES_256_CCM_8 uint16 = 0xC0A1
374 http2cipher_TLS_DHE_RSA_WITH_AES_128_CCM_8 uint16 = 0xC0A2
375 http2cipher_TLS_DHE_RSA_WITH_AES_256_CCM_8 uint16 = 0xC0A3
376 http2cipher_TLS_PSK_WITH_AES_128_CCM uint16 = 0xC0A4
377 http2cipher_TLS_PSK_WITH_AES_256_CCM uint16 = 0xC0A5
378 http2cipher_TLS_DHE_PSK_WITH_AES_128_CCM uint16 = 0xC0A6
379 http2cipher_TLS_DHE_PSK_WITH_AES_256_CCM uint16 = 0xC0A7
380 http2cipher_TLS_PSK_WITH_AES_128_CCM_8 uint16 = 0xC0A8
381 http2cipher_TLS_PSK_WITH_AES_256_CCM_8 uint16 = 0xC0A9
382 http2cipher_TLS_PSK_DHE_WITH_AES_128_CCM_8 uint16 = 0xC0AA
383 http2cipher_TLS_PSK_DHE_WITH_AES_256_CCM_8 uint16 = 0xC0AB
384 http2cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CCM uint16 = 0xC0AC
385 http2cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CCM uint16 = 0xC0AD
386 http2cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8 uint16 = 0xC0AE
387 http2cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8 uint16 = 0xC0AF
388
389
390
391 http2cipher_TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 uint16 = 0xCCA8
392 http2cipher_TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 uint16 = 0xCCA9
393 http2cipher_TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256 uint16 = 0xCCAA
394 http2cipher_TLS_PSK_WITH_CHACHA20_POLY1305_SHA256 uint16 = 0xCCAB
395 http2cipher_TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256 uint16 = 0xCCAC
396 http2cipher_TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256 uint16 = 0xCCAD
397 http2cipher_TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256 uint16 = 0xCCAE
398 )
399
400
401
402
403
404
405
406
407 func http2isBadCipher(cipher uint16) bool {
408 switch cipher {
409 case http2cipher_TLS_NULL_WITH_NULL_NULL,
410 http2cipher_TLS_RSA_WITH_NULL_MD5,
411 http2cipher_TLS_RSA_WITH_NULL_SHA,
412 http2cipher_TLS_RSA_EXPORT_WITH_RC4_40_MD5,
413 http2cipher_TLS_RSA_WITH_RC4_128_MD5,
414 http2cipher_TLS_RSA_WITH_RC4_128_SHA,
415 http2cipher_TLS_RSA_EXPORT_WITH_RC2_CBC_40_MD5,
416 http2cipher_TLS_RSA_WITH_IDEA_CBC_SHA,
417 http2cipher_TLS_RSA_EXPORT_WITH_DES40_CBC_SHA,
418 http2cipher_TLS_RSA_WITH_DES_CBC_SHA,
419 http2cipher_TLS_RSA_WITH_3DES_EDE_CBC_SHA,
420 http2cipher_TLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHA,
421 http2cipher_TLS_DH_DSS_WITH_DES_CBC_SHA,
422 http2cipher_TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA,
423 http2cipher_TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA,
424 http2cipher_TLS_DH_RSA_WITH_DES_CBC_SHA,
425 http2cipher_TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA,
426 http2cipher_TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA,
427 http2cipher_TLS_DHE_DSS_WITH_DES_CBC_SHA,
428 http2cipher_TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA,
429 http2cipher_TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA,
430 http2cipher_TLS_DHE_RSA_WITH_DES_CBC_SHA,
431 http2cipher_TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA,
432 http2cipher_TLS_DH_anon_EXPORT_WITH_RC4_40_MD5,
433 http2cipher_TLS_DH_anon_WITH_RC4_128_MD5,
434 http2cipher_TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHA,
435 http2cipher_TLS_DH_anon_WITH_DES_CBC_SHA,
436 http2cipher_TLS_DH_anon_WITH_3DES_EDE_CBC_SHA,
437 http2cipher_TLS_KRB5_WITH_DES_CBC_SHA,
438 http2cipher_TLS_KRB5_WITH_3DES_EDE_CBC_SHA,
439 http2cipher_TLS_KRB5_WITH_RC4_128_SHA,
440 http2cipher_TLS_KRB5_WITH_IDEA_CBC_SHA,
441 http2cipher_TLS_KRB5_WITH_DES_CBC_MD5,
442 http2cipher_TLS_KRB5_WITH_3DES_EDE_CBC_MD5,
443 http2cipher_TLS_KRB5_WITH_RC4_128_MD5,
444 http2cipher_TLS_KRB5_WITH_IDEA_CBC_MD5,
445 http2cipher_TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA,
446 http2cipher_TLS_KRB5_EXPORT_WITH_RC2_CBC_40_SHA,
447 http2cipher_TLS_KRB5_EXPORT_WITH_RC4_40_SHA,
448 http2cipher_TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5,
449 http2cipher_TLS_KRB5_EXPORT_WITH_RC2_CBC_40_MD5,
450 http2cipher_TLS_KRB5_EXPORT_WITH_RC4_40_MD5,
451 http2cipher_TLS_PSK_WITH_NULL_SHA,
452 http2cipher_TLS_DHE_PSK_WITH_NULL_SHA,
453 http2cipher_TLS_RSA_PSK_WITH_NULL_SHA,
454 http2cipher_TLS_RSA_WITH_AES_128_CBC_SHA,
455 http2cipher_TLS_DH_DSS_WITH_AES_128_CBC_SHA,
456 http2cipher_TLS_DH_RSA_WITH_AES_128_CBC_SHA,
457 http2cipher_TLS_DHE_DSS_WITH_AES_128_CBC_SHA,
458 http2cipher_TLS_DHE_RSA_WITH_AES_128_CBC_SHA,
459 http2cipher_TLS_DH_anon_WITH_AES_128_CBC_SHA,
460 http2cipher_TLS_RSA_WITH_AES_256_CBC_SHA,
461 http2cipher_TLS_DH_DSS_WITH_AES_256_CBC_SHA,
462 http2cipher_TLS_DH_RSA_WITH_AES_256_CBC_SHA,
463 http2cipher_TLS_DHE_DSS_WITH_AES_256_CBC_SHA,
464 http2cipher_TLS_DHE_RSA_WITH_AES_256_CBC_SHA,
465 http2cipher_TLS_DH_anon_WITH_AES_256_CBC_SHA,
466 http2cipher_TLS_RSA_WITH_NULL_SHA256,
467 http2cipher_TLS_RSA_WITH_AES_128_CBC_SHA256,
468 http2cipher_TLS_RSA_WITH_AES_256_CBC_SHA256,
469 http2cipher_TLS_DH_DSS_WITH_AES_128_CBC_SHA256,
470 http2cipher_TLS_DH_RSA_WITH_AES_128_CBC_SHA256,
471 http2cipher_TLS_DHE_DSS_WITH_AES_128_CBC_SHA256,
472 http2cipher_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA,
473 http2cipher_TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA,
474 http2cipher_TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA,
475 http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA,
476 http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA,
477 http2cipher_TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA,
478 http2cipher_TLS_DHE_RSA_WITH_AES_128_CBC_SHA256,
479 http2cipher_TLS_DH_DSS_WITH_AES_256_CBC_SHA256,
480 http2cipher_TLS_DH_RSA_WITH_AES_256_CBC_SHA256,
481 http2cipher_TLS_DHE_DSS_WITH_AES_256_CBC_SHA256,
482 http2cipher_TLS_DHE_RSA_WITH_AES_256_CBC_SHA256,
483 http2cipher_TLS_DH_anon_WITH_AES_128_CBC_SHA256,
484 http2cipher_TLS_DH_anon_WITH_AES_256_CBC_SHA256,
485 http2cipher_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA,
486 http2cipher_TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA,
487 http2cipher_TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA,
488 http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA,
489 http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA,
490 http2cipher_TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA,
491 http2cipher_TLS_PSK_WITH_RC4_128_SHA,
492 http2cipher_TLS_PSK_WITH_3DES_EDE_CBC_SHA,
493 http2cipher_TLS_PSK_WITH_AES_128_CBC_SHA,
494 http2cipher_TLS_PSK_WITH_AES_256_CBC_SHA,
495 http2cipher_TLS_DHE_PSK_WITH_RC4_128_SHA,
496 http2cipher_TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA,
497 http2cipher_TLS_DHE_PSK_WITH_AES_128_CBC_SHA,
498 http2cipher_TLS_DHE_PSK_WITH_AES_256_CBC_SHA,
499 http2cipher_TLS_RSA_PSK_WITH_RC4_128_SHA,
500 http2cipher_TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA,
501 http2cipher_TLS_RSA_PSK_WITH_AES_128_CBC_SHA,
502 http2cipher_TLS_RSA_PSK_WITH_AES_256_CBC_SHA,
503 http2cipher_TLS_RSA_WITH_SEED_CBC_SHA,
504 http2cipher_TLS_DH_DSS_WITH_SEED_CBC_SHA,
505 http2cipher_TLS_DH_RSA_WITH_SEED_CBC_SHA,
506 http2cipher_TLS_DHE_DSS_WITH_SEED_CBC_SHA,
507 http2cipher_TLS_DHE_RSA_WITH_SEED_CBC_SHA,
508 http2cipher_TLS_DH_anon_WITH_SEED_CBC_SHA,
509 http2cipher_TLS_RSA_WITH_AES_128_GCM_SHA256,
510 http2cipher_TLS_RSA_WITH_AES_256_GCM_SHA384,
511 http2cipher_TLS_DH_RSA_WITH_AES_128_GCM_SHA256,
512 http2cipher_TLS_DH_RSA_WITH_AES_256_GCM_SHA384,
513 http2cipher_TLS_DH_DSS_WITH_AES_128_GCM_SHA256,
514 http2cipher_TLS_DH_DSS_WITH_AES_256_GCM_SHA384,
515 http2cipher_TLS_DH_anon_WITH_AES_128_GCM_SHA256,
516 http2cipher_TLS_DH_anon_WITH_AES_256_GCM_SHA384,
517 http2cipher_TLS_PSK_WITH_AES_128_GCM_SHA256,
518 http2cipher_TLS_PSK_WITH_AES_256_GCM_SHA384,
519 http2cipher_TLS_RSA_PSK_WITH_AES_128_GCM_SHA256,
520 http2cipher_TLS_RSA_PSK_WITH_AES_256_GCM_SHA384,
521 http2cipher_TLS_PSK_WITH_AES_128_CBC_SHA256,
522 http2cipher_TLS_PSK_WITH_AES_256_CBC_SHA384,
523 http2cipher_TLS_PSK_WITH_NULL_SHA256,
524 http2cipher_TLS_PSK_WITH_NULL_SHA384,
525 http2cipher_TLS_DHE_PSK_WITH_AES_128_CBC_SHA256,
526 http2cipher_TLS_DHE_PSK_WITH_AES_256_CBC_SHA384,
527 http2cipher_TLS_DHE_PSK_WITH_NULL_SHA256,
528 http2cipher_TLS_DHE_PSK_WITH_NULL_SHA384,
529 http2cipher_TLS_RSA_PSK_WITH_AES_128_CBC_SHA256,
530 http2cipher_TLS_RSA_PSK_WITH_AES_256_CBC_SHA384,
531 http2cipher_TLS_RSA_PSK_WITH_NULL_SHA256,
532 http2cipher_TLS_RSA_PSK_WITH_NULL_SHA384,
533 http2cipher_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256,
534 http2cipher_TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256,
535 http2cipher_TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256,
536 http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256,
537 http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256,
538 http2cipher_TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256,
539 http2cipher_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256,
540 http2cipher_TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256,
541 http2cipher_TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256,
542 http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256,
543 http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256,
544 http2cipher_TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256,
545 http2cipher_TLS_EMPTY_RENEGOTIATION_INFO_SCSV,
546 http2cipher_TLS_ECDH_ECDSA_WITH_NULL_SHA,
547 http2cipher_TLS_ECDH_ECDSA_WITH_RC4_128_SHA,
548 http2cipher_TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA,
549 http2cipher_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA,
550 http2cipher_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA,
551 http2cipher_TLS_ECDHE_ECDSA_WITH_NULL_SHA,
552 http2cipher_TLS_ECDHE_ECDSA_WITH_RC4_128_SHA,
553 http2cipher_TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA,
554 http2cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
555 http2cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
556 http2cipher_TLS_ECDH_RSA_WITH_NULL_SHA,
557 http2cipher_TLS_ECDH_RSA_WITH_RC4_128_SHA,
558 http2cipher_TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA,
559 http2cipher_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA,
560 http2cipher_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA,
561 http2cipher_TLS_ECDHE_RSA_WITH_NULL_SHA,
562 http2cipher_TLS_ECDHE_RSA_WITH_RC4_128_SHA,
563 http2cipher_TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA,
564 http2cipher_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
565 http2cipher_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
566 http2cipher_TLS_ECDH_anon_WITH_NULL_SHA,
567 http2cipher_TLS_ECDH_anon_WITH_RC4_128_SHA,
568 http2cipher_TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA,
569 http2cipher_TLS_ECDH_anon_WITH_AES_128_CBC_SHA,
570 http2cipher_TLS_ECDH_anon_WITH_AES_256_CBC_SHA,
571 http2cipher_TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA,
572 http2cipher_TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA,
573 http2cipher_TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA,
574 http2cipher_TLS_SRP_SHA_WITH_AES_128_CBC_SHA,
575 http2cipher_TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA,
576 http2cipher_TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA,
577 http2cipher_TLS_SRP_SHA_WITH_AES_256_CBC_SHA,
578 http2cipher_TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA,
579 http2cipher_TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA,
580 http2cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256,
581 http2cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384,
582 http2cipher_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256,
583 http2cipher_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384,
584 http2cipher_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256,
585 http2cipher_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384,
586 http2cipher_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256,
587 http2cipher_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384,
588 http2cipher_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256,
589 http2cipher_TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384,
590 http2cipher_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256,
591 http2cipher_TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384,
592 http2cipher_TLS_ECDHE_PSK_WITH_RC4_128_SHA,
593 http2cipher_TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA,
594 http2cipher_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA,
595 http2cipher_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA,
596 http2cipher_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256,
597 http2cipher_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384,
598 http2cipher_TLS_ECDHE_PSK_WITH_NULL_SHA,
599 http2cipher_TLS_ECDHE_PSK_WITH_NULL_SHA256,
600 http2cipher_TLS_ECDHE_PSK_WITH_NULL_SHA384,
601 http2cipher_TLS_RSA_WITH_ARIA_128_CBC_SHA256,
602 http2cipher_TLS_RSA_WITH_ARIA_256_CBC_SHA384,
603 http2cipher_TLS_DH_DSS_WITH_ARIA_128_CBC_SHA256,
604 http2cipher_TLS_DH_DSS_WITH_ARIA_256_CBC_SHA384,
605 http2cipher_TLS_DH_RSA_WITH_ARIA_128_CBC_SHA256,
606 http2cipher_TLS_DH_RSA_WITH_ARIA_256_CBC_SHA384,
607 http2cipher_TLS_DHE_DSS_WITH_ARIA_128_CBC_SHA256,
608 http2cipher_TLS_DHE_DSS_WITH_ARIA_256_CBC_SHA384,
609 http2cipher_TLS_DHE_RSA_WITH_ARIA_128_CBC_SHA256,
610 http2cipher_TLS_DHE_RSA_WITH_ARIA_256_CBC_SHA384,
611 http2cipher_TLS_DH_anon_WITH_ARIA_128_CBC_SHA256,
612 http2cipher_TLS_DH_anon_WITH_ARIA_256_CBC_SHA384,
613 http2cipher_TLS_ECDHE_ECDSA_WITH_ARIA_128_CBC_SHA256,
614 http2cipher_TLS_ECDHE_ECDSA_WITH_ARIA_256_CBC_SHA384,
615 http2cipher_TLS_ECDH_ECDSA_WITH_ARIA_128_CBC_SHA256,
616 http2cipher_TLS_ECDH_ECDSA_WITH_ARIA_256_CBC_SHA384,
617 http2cipher_TLS_ECDHE_RSA_WITH_ARIA_128_CBC_SHA256,
618 http2cipher_TLS_ECDHE_RSA_WITH_ARIA_256_CBC_SHA384,
619 http2cipher_TLS_ECDH_RSA_WITH_ARIA_128_CBC_SHA256,
620 http2cipher_TLS_ECDH_RSA_WITH_ARIA_256_CBC_SHA384,
621 http2cipher_TLS_RSA_WITH_ARIA_128_GCM_SHA256,
622 http2cipher_TLS_RSA_WITH_ARIA_256_GCM_SHA384,
623 http2cipher_TLS_DH_RSA_WITH_ARIA_128_GCM_SHA256,
624 http2cipher_TLS_DH_RSA_WITH_ARIA_256_GCM_SHA384,
625 http2cipher_TLS_DH_DSS_WITH_ARIA_128_GCM_SHA256,
626 http2cipher_TLS_DH_DSS_WITH_ARIA_256_GCM_SHA384,
627 http2cipher_TLS_DH_anon_WITH_ARIA_128_GCM_SHA256,
628 http2cipher_TLS_DH_anon_WITH_ARIA_256_GCM_SHA384,
629 http2cipher_TLS_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256,
630 http2cipher_TLS_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384,
631 http2cipher_TLS_ECDH_RSA_WITH_ARIA_128_GCM_SHA256,
632 http2cipher_TLS_ECDH_RSA_WITH_ARIA_256_GCM_SHA384,
633 http2cipher_TLS_PSK_WITH_ARIA_128_CBC_SHA256,
634 http2cipher_TLS_PSK_WITH_ARIA_256_CBC_SHA384,
635 http2cipher_TLS_DHE_PSK_WITH_ARIA_128_CBC_SHA256,
636 http2cipher_TLS_DHE_PSK_WITH_ARIA_256_CBC_SHA384,
637 http2cipher_TLS_RSA_PSK_WITH_ARIA_128_CBC_SHA256,
638 http2cipher_TLS_RSA_PSK_WITH_ARIA_256_CBC_SHA384,
639 http2cipher_TLS_PSK_WITH_ARIA_128_GCM_SHA256,
640 http2cipher_TLS_PSK_WITH_ARIA_256_GCM_SHA384,
641 http2cipher_TLS_RSA_PSK_WITH_ARIA_128_GCM_SHA256,
642 http2cipher_TLS_RSA_PSK_WITH_ARIA_256_GCM_SHA384,
643 http2cipher_TLS_ECDHE_PSK_WITH_ARIA_128_CBC_SHA256,
644 http2cipher_TLS_ECDHE_PSK_WITH_ARIA_256_CBC_SHA384,
645 http2cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256,
646 http2cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384,
647 http2cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256,
648 http2cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384,
649 http2cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256,
650 http2cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384,
651 http2cipher_TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256,
652 http2cipher_TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384,
653 http2cipher_TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256,
654 http2cipher_TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384,
655 http2cipher_TLS_DH_RSA_WITH_CAMELLIA_128_GCM_SHA256,
656 http2cipher_TLS_DH_RSA_WITH_CAMELLIA_256_GCM_SHA384,
657 http2cipher_TLS_DH_DSS_WITH_CAMELLIA_128_GCM_SHA256,
658 http2cipher_TLS_DH_DSS_WITH_CAMELLIA_256_GCM_SHA384,
659 http2cipher_TLS_DH_anon_WITH_CAMELLIA_128_GCM_SHA256,
660 http2cipher_TLS_DH_anon_WITH_CAMELLIA_256_GCM_SHA384,
661 http2cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256,
662 http2cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384,
663 http2cipher_TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256,
664 http2cipher_TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384,
665 http2cipher_TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256,
666 http2cipher_TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384,
667 http2cipher_TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256,
668 http2cipher_TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384,
669 http2cipher_TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256,
670 http2cipher_TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384,
671 http2cipher_TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256,
672 http2cipher_TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384,
673 http2cipher_TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256,
674 http2cipher_TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384,
675 http2cipher_TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256,
676 http2cipher_TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384,
677 http2cipher_TLS_RSA_WITH_AES_128_CCM,
678 http2cipher_TLS_RSA_WITH_AES_256_CCM,
679 http2cipher_TLS_RSA_WITH_AES_128_CCM_8,
680 http2cipher_TLS_RSA_WITH_AES_256_CCM_8,
681 http2cipher_TLS_PSK_WITH_AES_128_CCM,
682 http2cipher_TLS_PSK_WITH_AES_256_CCM,
683 http2cipher_TLS_PSK_WITH_AES_128_CCM_8,
684 http2cipher_TLS_PSK_WITH_AES_256_CCM_8:
685 return true
686 default:
687 return false
688 }
689 }
690
691
692 type http2ClientConnPool interface {
693 GetClientConn(req *Request, addr string) (*http2ClientConn, error)
694 MarkDead(*http2ClientConn)
695 }
696
697
698
699 type http2clientConnPoolIdleCloser interface {
700 http2ClientConnPool
701 closeIdleConnections()
702 }
703
704 var (
705 _ http2clientConnPoolIdleCloser = (*http2clientConnPool)(nil)
706 _ http2clientConnPoolIdleCloser = http2noDialClientConnPool{}
707 )
708
709
710 type http2clientConnPool struct {
711 t *http2Transport
712
713 mu sync.Mutex
714
715
716 conns map[string][]*http2ClientConn
717 dialing map[string]*http2dialCall
718 keys map[*http2ClientConn][]string
719 addConnCalls map[string]*http2addConnCall
720 }
721
722 func (p *http2clientConnPool) GetClientConn(req *Request, addr string) (*http2ClientConn, error) {
723 return p.getClientConn(req, addr, http2dialOnMiss)
724 }
725
726 const (
727 http2dialOnMiss = true
728 http2noDialOnMiss = false
729 )
730
731
732
733
734
735
736
737
738 func (p *http2clientConnPool) shouldTraceGetConn(st http2clientConnIdleState) bool {
739
740
741
742
743 if _, ok := p.t.ConnPool.(http2noDialClientConnPool); !ok {
744 return true
745 }
746
747
748
749 return !st.freshConn
750 }
751
752 func (p *http2clientConnPool) getClientConn(req *Request, addr string, dialOnMiss bool) (*http2ClientConn, error) {
753 if http2isConnectionCloseRequest(req) && dialOnMiss {
754
755 http2traceGetConn(req, addr)
756 const singleUse = true
757 cc, err := p.t.dialClientConn(addr, singleUse)
758 if err != nil {
759 return nil, err
760 }
761 return cc, nil
762 }
763 p.mu.Lock()
764 for _, cc := range p.conns[addr] {
765 if st := cc.idleState(); st.canTakeNewRequest {
766 if p.shouldTraceGetConn(st) {
767 http2traceGetConn(req, addr)
768 }
769 p.mu.Unlock()
770 return cc, nil
771 }
772 }
773 if !dialOnMiss {
774 p.mu.Unlock()
775 return nil, http2ErrNoCachedConn
776 }
777 http2traceGetConn(req, addr)
778 call := p.getStartDialLocked(addr)
779 p.mu.Unlock()
780 <-call.done
781 return call.res, call.err
782 }
783
784
785 type http2dialCall struct {
786 _ http2incomparable
787 p *http2clientConnPool
788 done chan struct{}
789 res *http2ClientConn
790 err error
791 }
792
793
794 func (p *http2clientConnPool) getStartDialLocked(addr string) *http2dialCall {
795 if call, ok := p.dialing[addr]; ok {
796
797 return call
798 }
799 call := &http2dialCall{p: p, done: make(chan struct{})}
800 if p.dialing == nil {
801 p.dialing = make(map[string]*http2dialCall)
802 }
803 p.dialing[addr] = call
804 go call.dial(addr)
805 return call
806 }
807
808
809 func (c *http2dialCall) dial(addr string) {
810 const singleUse = false
811 c.res, c.err = c.p.t.dialClientConn(addr, singleUse)
812 close(c.done)
813
814 c.p.mu.Lock()
815 delete(c.p.dialing, addr)
816 if c.err == nil {
817 c.p.addConnLocked(addr, c.res)
818 }
819 c.p.mu.Unlock()
820 }
821
822
823
824
825
826
827
828
829
830 func (p *http2clientConnPool) addConnIfNeeded(key string, t *http2Transport, c *tls.Conn) (used bool, err error) {
831 p.mu.Lock()
832 for _, cc := range p.conns[key] {
833 if cc.CanTakeNewRequest() {
834 p.mu.Unlock()
835 return false, nil
836 }
837 }
838 call, dup := p.addConnCalls[key]
839 if !dup {
840 if p.addConnCalls == nil {
841 p.addConnCalls = make(map[string]*http2addConnCall)
842 }
843 call = &http2addConnCall{
844 p: p,
845 done: make(chan struct{}),
846 }
847 p.addConnCalls[key] = call
848 go call.run(t, key, c)
849 }
850 p.mu.Unlock()
851
852 <-call.done
853 if call.err != nil {
854 return false, call.err
855 }
856 return !dup, nil
857 }
858
859 type http2addConnCall struct {
860 _ http2incomparable
861 p *http2clientConnPool
862 done chan struct{}
863 err error
864 }
865
866 func (c *http2addConnCall) run(t *http2Transport, key string, tc *tls.Conn) {
867 cc, err := t.NewClientConn(tc)
868
869 p := c.p
870 p.mu.Lock()
871 if err != nil {
872 c.err = err
873 } else {
874 p.addConnLocked(key, cc)
875 }
876 delete(p.addConnCalls, key)
877 p.mu.Unlock()
878 close(c.done)
879 }
880
881
882 func (p *http2clientConnPool) addConnLocked(key string, cc *http2ClientConn) {
883 for _, v := range p.conns[key] {
884 if v == cc {
885 return
886 }
887 }
888 if p.conns == nil {
889 p.conns = make(map[string][]*http2ClientConn)
890 }
891 if p.keys == nil {
892 p.keys = make(map[*http2ClientConn][]string)
893 }
894 p.conns[key] = append(p.conns[key], cc)
895 p.keys[cc] = append(p.keys[cc], key)
896 }
897
898 func (p *http2clientConnPool) MarkDead(cc *http2ClientConn) {
899 p.mu.Lock()
900 defer p.mu.Unlock()
901 for _, key := range p.keys[cc] {
902 vv, ok := p.conns[key]
903 if !ok {
904 continue
905 }
906 newList := http2filterOutClientConn(vv, cc)
907 if len(newList) > 0 {
908 p.conns[key] = newList
909 } else {
910 delete(p.conns, key)
911 }
912 }
913 delete(p.keys, cc)
914 }
915
916 func (p *http2clientConnPool) closeIdleConnections() {
917 p.mu.Lock()
918 defer p.mu.Unlock()
919
920
921
922
923
924
925 for _, vv := range p.conns {
926 for _, cc := range vv {
927 cc.closeIfIdle()
928 }
929 }
930 }
931
932 func http2filterOutClientConn(in []*http2ClientConn, exclude *http2ClientConn) []*http2ClientConn {
933 out := in[:0]
934 for _, v := range in {
935 if v != exclude {
936 out = append(out, v)
937 }
938 }
939
940
941 if len(in) != len(out) {
942 in[len(in)-1] = nil
943 }
944 return out
945 }
946
947
948
949
950 type http2noDialClientConnPool struct{ *http2clientConnPool }
951
952 func (p http2noDialClientConnPool) GetClientConn(req *Request, addr string) (*http2ClientConn, error) {
953 return p.getClientConn(req, addr, http2noDialOnMiss)
954 }
955
956
957
958
959
960
961
962
963
964
965
966 var (
967 http2dataChunkSizeClasses = []int{
968 1 << 10,
969 2 << 10,
970 4 << 10,
971 8 << 10,
972 16 << 10,
973 }
974 http2dataChunkPools = [...]sync.Pool{
975 {New: func() interface{} { return make([]byte, 1<<10) }},
976 {New: func() interface{} { return make([]byte, 2<<10) }},
977 {New: func() interface{} { return make([]byte, 4<<10) }},
978 {New: func() interface{} { return make([]byte, 8<<10) }},
979 {New: func() interface{} { return make([]byte, 16<<10) }},
980 }
981 )
982
983 func http2getDataBufferChunk(size int64) []byte {
984 i := 0
985 for ; i < len(http2dataChunkSizeClasses)-1; i++ {
986 if size <= int64(http2dataChunkSizeClasses[i]) {
987 break
988 }
989 }
990 return http2dataChunkPools[i].Get().([]byte)
991 }
992
993 func http2putDataBufferChunk(p []byte) {
994 for i, n := range http2dataChunkSizeClasses {
995 if len(p) == n {
996 http2dataChunkPools[i].Put(p)
997 return
998 }
999 }
1000 panic(fmt.Sprintf("unexpected buffer len=%v", len(p)))
1001 }
1002
1003
1004
1005
1006
1007
1008 type http2dataBuffer struct {
1009 chunks [][]byte
1010 r int
1011 w int
1012 size int
1013 expected int64
1014 }
1015
1016 var http2errReadEmpty = errors.New("read from empty dataBuffer")
1017
1018
1019
1020 func (b *http2dataBuffer) Read(p []byte) (int, error) {
1021 if b.size == 0 {
1022 return 0, http2errReadEmpty
1023 }
1024 var ntotal int
1025 for len(p) > 0 && b.size > 0 {
1026 readFrom := b.bytesFromFirstChunk()
1027 n := copy(p, readFrom)
1028 p = p[n:]
1029 ntotal += n
1030 b.r += n
1031 b.size -= n
1032
1033 if b.r == len(b.chunks[0]) {
1034 http2putDataBufferChunk(b.chunks[0])
1035 end := len(b.chunks) - 1
1036 copy(b.chunks[:end], b.chunks[1:])
1037 b.chunks[end] = nil
1038 b.chunks = b.chunks[:end]
1039 b.r = 0
1040 }
1041 }
1042 return ntotal, nil
1043 }
1044
1045 func (b *http2dataBuffer) bytesFromFirstChunk() []byte {
1046 if len(b.chunks) == 1 {
1047 return b.chunks[0][b.r:b.w]
1048 }
1049 return b.chunks[0][b.r:]
1050 }
1051
1052
1053 func (b *http2dataBuffer) Len() int {
1054 return b.size
1055 }
1056
1057
1058 func (b *http2dataBuffer) Write(p []byte) (int, error) {
1059 ntotal := len(p)
1060 for len(p) > 0 {
1061
1062
1063
1064 want := int64(len(p))
1065 if b.expected > want {
1066 want = b.expected
1067 }
1068 chunk := b.lastChunkOrAlloc(want)
1069 n := copy(chunk[b.w:], p)
1070 p = p[n:]
1071 b.w += n
1072 b.size += n
1073 b.expected -= int64(n)
1074 }
1075 return ntotal, nil
1076 }
1077
1078 func (b *http2dataBuffer) lastChunkOrAlloc(want int64) []byte {
1079 if len(b.chunks) != 0 {
1080 last := b.chunks[len(b.chunks)-1]
1081 if b.w < len(last) {
1082 return last
1083 }
1084 }
1085 chunk := http2getDataBufferChunk(want)
1086 b.chunks = append(b.chunks, chunk)
1087 b.w = 0
1088 return chunk
1089 }
1090
1091
1092 type http2ErrCode uint32
1093
1094 const (
1095 http2ErrCodeNo http2ErrCode = 0x0
1096 http2ErrCodeProtocol http2ErrCode = 0x1
1097 http2ErrCodeInternal http2ErrCode = 0x2
1098 http2ErrCodeFlowControl http2ErrCode = 0x3
1099 http2ErrCodeSettingsTimeout http2ErrCode = 0x4
1100 http2ErrCodeStreamClosed http2ErrCode = 0x5
1101 http2ErrCodeFrameSize http2ErrCode = 0x6
1102 http2ErrCodeRefusedStream http2ErrCode = 0x7
1103 http2ErrCodeCancel http2ErrCode = 0x8
1104 http2ErrCodeCompression http2ErrCode = 0x9
1105 http2ErrCodeConnect http2ErrCode = 0xa
1106 http2ErrCodeEnhanceYourCalm http2ErrCode = 0xb
1107 http2ErrCodeInadequateSecurity http2ErrCode = 0xc
1108 http2ErrCodeHTTP11Required http2ErrCode = 0xd
1109 )
1110
1111 var http2errCodeName = map[http2ErrCode]string{
1112 http2ErrCodeNo: "NO_ERROR",
1113 http2ErrCodeProtocol: "PROTOCOL_ERROR",
1114 http2ErrCodeInternal: "INTERNAL_ERROR",
1115 http2ErrCodeFlowControl: "FLOW_CONTROL_ERROR",
1116 http2ErrCodeSettingsTimeout: "SETTINGS_TIMEOUT",
1117 http2ErrCodeStreamClosed: "STREAM_CLOSED",
1118 http2ErrCodeFrameSize: "FRAME_SIZE_ERROR",
1119 http2ErrCodeRefusedStream: "REFUSED_STREAM",
1120 http2ErrCodeCancel: "CANCEL",
1121 http2ErrCodeCompression: "COMPRESSION_ERROR",
1122 http2ErrCodeConnect: "CONNECT_ERROR",
1123 http2ErrCodeEnhanceYourCalm: "ENHANCE_YOUR_CALM",
1124 http2ErrCodeInadequateSecurity: "INADEQUATE_SECURITY",
1125 http2ErrCodeHTTP11Required: "HTTP_1_1_REQUIRED",
1126 }
1127
1128 func (e http2ErrCode) String() string {
1129 if s, ok := http2errCodeName[e]; ok {
1130 return s
1131 }
1132 return fmt.Sprintf("unknown error code 0x%x", uint32(e))
1133 }
1134
1135
1136
1137 type http2ConnectionError http2ErrCode
1138
1139 func (e http2ConnectionError) Error() string {
1140 return fmt.Sprintf("connection error: %s", http2ErrCode(e))
1141 }
1142
1143
1144
1145 type http2StreamError struct {
1146 StreamID uint32
1147 Code http2ErrCode
1148 Cause error
1149 }
1150
1151 func http2streamError(id uint32, code http2ErrCode) http2StreamError {
1152 return http2StreamError{StreamID: id, Code: code}
1153 }
1154
1155 func (e http2StreamError) Error() string {
1156 if e.Cause != nil {
1157 return fmt.Sprintf("stream error: stream ID %d; %v; %v", e.StreamID, e.Code, e.Cause)
1158 }
1159 return fmt.Sprintf("stream error: stream ID %d; %v", e.StreamID, e.Code)
1160 }
1161
1162
1163
1164
1165
1166
1167 type http2goAwayFlowError struct{}
1168
1169 func (http2goAwayFlowError) Error() string { return "connection exceeded flow control window size" }
1170
1171
1172
1173
1174
1175
1176
1177
1178 type http2connError struct {
1179 Code http2ErrCode
1180 Reason string
1181 }
1182
1183 func (e http2connError) Error() string {
1184 return fmt.Sprintf("http2: connection error: %v: %v", e.Code, e.Reason)
1185 }
1186
1187 type http2pseudoHeaderError string
1188
1189 func (e http2pseudoHeaderError) Error() string {
1190 return fmt.Sprintf("invalid pseudo-header %q", string(e))
1191 }
1192
1193 type http2duplicatePseudoHeaderError string
1194
1195 func (e http2duplicatePseudoHeaderError) Error() string {
1196 return fmt.Sprintf("duplicate pseudo-header %q", string(e))
1197 }
1198
1199 type http2headerFieldNameError string
1200
1201 func (e http2headerFieldNameError) Error() string {
1202 return fmt.Sprintf("invalid header field name %q", string(e))
1203 }
1204
1205 type http2headerFieldValueError string
1206
1207 func (e http2headerFieldValueError) Error() string {
1208 return fmt.Sprintf("invalid header field value %q", string(e))
1209 }
1210
1211 var (
1212 http2errMixPseudoHeaderTypes = errors.New("mix of request and response pseudo headers")
1213 http2errPseudoAfterRegular = errors.New("pseudo header field after regular")
1214 )
1215
1216
1217 type http2flow struct {
1218 _ http2incomparable
1219
1220
1221
1222 n int32
1223
1224
1225
1226
1227 conn *http2flow
1228 }
1229
1230 func (f *http2flow) setConnFlow(cf *http2flow) { f.conn = cf }
1231
1232 func (f *http2flow) available() int32 {
1233 n := f.n
1234 if f.conn != nil && f.conn.n < n {
1235 n = f.conn.n
1236 }
1237 return n
1238 }
1239
1240 func (f *http2flow) take(n int32) {
1241 if n > f.available() {
1242 panic("internal error: took too much")
1243 }
1244 f.n -= n
1245 if f.conn != nil {
1246 f.conn.n -= n
1247 }
1248 }
1249
1250
1251
1252 func (f *http2flow) add(n int32) bool {
1253 sum := f.n + n
1254 if (sum > n) == (f.n > 0) {
1255 f.n = sum
1256 return true
1257 }
1258 return false
1259 }
1260
1261 const http2frameHeaderLen = 9
1262
1263 var http2padZeros = make([]byte, 255)
1264
1265
1266
1267 type http2FrameType uint8
1268
1269 const (
1270 http2FrameData http2FrameType = 0x0
1271 http2FrameHeaders http2FrameType = 0x1
1272 http2FramePriority http2FrameType = 0x2
1273 http2FrameRSTStream http2FrameType = 0x3
1274 http2FrameSettings http2FrameType = 0x4
1275 http2FramePushPromise http2FrameType = 0x5
1276 http2FramePing http2FrameType = 0x6
1277 http2FrameGoAway http2FrameType = 0x7
1278 http2FrameWindowUpdate http2FrameType = 0x8
1279 http2FrameContinuation http2FrameType = 0x9
1280 )
1281
1282 var http2frameName = map[http2FrameType]string{
1283 http2FrameData: "DATA",
1284 http2FrameHeaders: "HEADERS",
1285 http2FramePriority: "PRIORITY",
1286 http2FrameRSTStream: "RST_STREAM",
1287 http2FrameSettings: "SETTINGS",
1288 http2FramePushPromise: "PUSH_PROMISE",
1289 http2FramePing: "PING",
1290 http2FrameGoAway: "GOAWAY",
1291 http2FrameWindowUpdate: "WINDOW_UPDATE",
1292 http2FrameContinuation: "CONTINUATION",
1293 }
1294
1295 func (t http2FrameType) String() string {
1296 if s, ok := http2frameName[t]; ok {
1297 return s
1298 }
1299 return fmt.Sprintf("UNKNOWN_FRAME_TYPE_%d", uint8(t))
1300 }
1301
1302
1303
1304 type http2Flags uint8
1305
1306
1307 func (f http2Flags) Has(v http2Flags) bool {
1308 return (f & v) == v
1309 }
1310
1311
1312 const (
1313
1314 http2FlagDataEndStream http2Flags = 0x1
1315 http2FlagDataPadded http2Flags = 0x8
1316
1317
1318 http2FlagHeadersEndStream http2Flags = 0x1
1319 http2FlagHeadersEndHeaders http2Flags = 0x4
1320 http2FlagHeadersPadded http2Flags = 0x8
1321 http2FlagHeadersPriority http2Flags = 0x20
1322
1323
1324 http2FlagSettingsAck http2Flags = 0x1
1325
1326
1327 http2FlagPingAck http2Flags = 0x1
1328
1329
1330 http2FlagContinuationEndHeaders http2Flags = 0x4
1331
1332 http2FlagPushPromiseEndHeaders http2Flags = 0x4
1333 http2FlagPushPromisePadded http2Flags = 0x8
1334 )
1335
1336 var http2flagName = map[http2FrameType]map[http2Flags]string{
1337 http2FrameData: {
1338 http2FlagDataEndStream: "END_STREAM",
1339 http2FlagDataPadded: "PADDED",
1340 },
1341 http2FrameHeaders: {
1342 http2FlagHeadersEndStream: "END_STREAM",
1343 http2FlagHeadersEndHeaders: "END_HEADERS",
1344 http2FlagHeadersPadded: "PADDED",
1345 http2FlagHeadersPriority: "PRIORITY",
1346 },
1347 http2FrameSettings: {
1348 http2FlagSettingsAck: "ACK",
1349 },
1350 http2FramePing: {
1351 http2FlagPingAck: "ACK",
1352 },
1353 http2FrameContinuation: {
1354 http2FlagContinuationEndHeaders: "END_HEADERS",
1355 },
1356 http2FramePushPromise: {
1357 http2FlagPushPromiseEndHeaders: "END_HEADERS",
1358 http2FlagPushPromisePadded: "PADDED",
1359 },
1360 }
1361
1362
1363
1364
1365 type http2frameParser func(fc *http2frameCache, fh http2FrameHeader, payload []byte) (http2Frame, error)
1366
1367 var http2frameParsers = map[http2FrameType]http2frameParser{
1368 http2FrameData: http2parseDataFrame,
1369 http2FrameHeaders: http2parseHeadersFrame,
1370 http2FramePriority: http2parsePriorityFrame,
1371 http2FrameRSTStream: http2parseRSTStreamFrame,
1372 http2FrameSettings: http2parseSettingsFrame,
1373 http2FramePushPromise: http2parsePushPromise,
1374 http2FramePing: http2parsePingFrame,
1375 http2FrameGoAway: http2parseGoAwayFrame,
1376 http2FrameWindowUpdate: http2parseWindowUpdateFrame,
1377 http2FrameContinuation: http2parseContinuationFrame,
1378 }
1379
1380 func http2typeFrameParser(t http2FrameType) http2frameParser {
1381 if f := http2frameParsers[t]; f != nil {
1382 return f
1383 }
1384 return http2parseUnknownFrame
1385 }
1386
1387
1388
1389
1390 type http2FrameHeader struct {
1391 valid bool
1392
1393
1394
1395
1396 Type http2FrameType
1397
1398
1399
1400 Flags http2Flags
1401
1402
1403
1404
1405 Length uint32
1406
1407
1408
1409 StreamID uint32
1410 }
1411
1412
1413
1414 func (h http2FrameHeader) Header() http2FrameHeader { return h }
1415
1416 func (h http2FrameHeader) String() string {
1417 var buf bytes.Buffer
1418 buf.WriteString("[FrameHeader ")
1419 h.writeDebug(&buf)
1420 buf.WriteByte(']')
1421 return buf.String()
1422 }
1423
1424 func (h http2FrameHeader) writeDebug(buf *bytes.Buffer) {
1425 buf.WriteString(h.Type.String())
1426 if h.Flags != 0 {
1427 buf.WriteString(" flags=")
1428 set := 0
1429 for i := uint8(0); i < 8; i++ {
1430 if h.Flags&(1<<i) == 0 {
1431 continue
1432 }
1433 set++
1434 if set > 1 {
1435 buf.WriteByte('|')
1436 }
1437 name := http2flagName[h.Type][http2Flags(1<<i)]
1438 if name != "" {
1439 buf.WriteString(name)
1440 } else {
1441 fmt.Fprintf(buf, "0x%x", 1<<i)
1442 }
1443 }
1444 }
1445 if h.StreamID != 0 {
1446 fmt.Fprintf(buf, " stream=%d", h.StreamID)
1447 }
1448 fmt.Fprintf(buf, " len=%d", h.Length)
1449 }
1450
1451 func (h *http2FrameHeader) checkValid() {
1452 if !h.valid {
1453 panic("Frame accessor called on non-owned Frame")
1454 }
1455 }
1456
1457 func (h *http2FrameHeader) invalidate() { h.valid = false }
1458
1459
1460
1461 var http2fhBytes = sync.Pool{
1462 New: func() interface{} {
1463 buf := make([]byte, http2frameHeaderLen)
1464 return &buf
1465 },
1466 }
1467
1468
1469
1470 func http2ReadFrameHeader(r io.Reader) (http2FrameHeader, error) {
1471 bufp := http2fhBytes.Get().(*[]byte)
1472 defer http2fhBytes.Put(bufp)
1473 return http2readFrameHeader(*bufp, r)
1474 }
1475
1476 func http2readFrameHeader(buf []byte, r io.Reader) (http2FrameHeader, error) {
1477 _, err := io.ReadFull(r, buf[:http2frameHeaderLen])
1478 if err != nil {
1479 return http2FrameHeader{}, err
1480 }
1481 return http2FrameHeader{
1482 Length: (uint32(buf[0])<<16 | uint32(buf[1])<<8 | uint32(buf[2])),
1483 Type: http2FrameType(buf[3]),
1484 Flags: http2Flags(buf[4]),
1485 StreamID: binary.BigEndian.Uint32(buf[5:]) & (1<<31 - 1),
1486 valid: true,
1487 }, nil
1488 }
1489
1490
1491
1492
1493
1494
1495 type http2Frame interface {
1496 Header() http2FrameHeader
1497
1498
1499
1500
1501 invalidate()
1502 }
1503
1504
1505 type http2Framer struct {
1506 r io.Reader
1507 lastFrame http2Frame
1508 errDetail error
1509
1510
1511
1512 lastHeaderStream uint32
1513
1514 maxReadSize uint32
1515 headerBuf [http2frameHeaderLen]byte
1516
1517
1518
1519
1520 getReadBuf func(size uint32) []byte
1521 readBuf []byte
1522
1523 maxWriteSize uint32
1524
1525 w io.Writer
1526 wbuf []byte
1527
1528
1529
1530
1531
1532
1533
1534 AllowIllegalWrites bool
1535
1536
1537
1538
1539
1540
1541 AllowIllegalReads bool
1542
1543
1544
1545
1546 ReadMetaHeaders *hpack.Decoder
1547
1548
1549
1550
1551
1552 MaxHeaderListSize uint32
1553
1554
1555
1556
1557
1558
1559
1560 logReads, logWrites bool
1561
1562 debugFramer *http2Framer
1563 debugFramerBuf *bytes.Buffer
1564 debugReadLoggerf func(string, ...interface{})
1565 debugWriteLoggerf func(string, ...interface{})
1566
1567 frameCache *http2frameCache
1568 }
1569
1570 func (fr *http2Framer) maxHeaderListSize() uint32 {
1571 if fr.MaxHeaderListSize == 0 {
1572 return 16 << 20
1573 }
1574 return fr.MaxHeaderListSize
1575 }
1576
1577 func (f *http2Framer) startWrite(ftype http2FrameType, flags http2Flags, streamID uint32) {
1578
1579 f.wbuf = append(f.wbuf[:0],
1580 0,
1581 0,
1582 0,
1583 byte(ftype),
1584 byte(flags),
1585 byte(streamID>>24),
1586 byte(streamID>>16),
1587 byte(streamID>>8),
1588 byte(streamID))
1589 }
1590
1591 func (f *http2Framer) endWrite() error {
1592
1593
1594 length := len(f.wbuf) - http2frameHeaderLen
1595 if length >= (1 << 24) {
1596 return http2ErrFrameTooLarge
1597 }
1598 _ = append(f.wbuf[:0],
1599 byte(length>>16),
1600 byte(length>>8),
1601 byte(length))
1602 if f.logWrites {
1603 f.logWrite()
1604 }
1605
1606 n, err := f.w.Write(f.wbuf)
1607 if err == nil && n != len(f.wbuf) {
1608 err = io.ErrShortWrite
1609 }
1610 return err
1611 }
1612
1613 func (f *http2Framer) logWrite() {
1614 if f.debugFramer == nil {
1615 f.debugFramerBuf = new(bytes.Buffer)
1616 f.debugFramer = http2NewFramer(nil, f.debugFramerBuf)
1617 f.debugFramer.logReads = false
1618
1619
1620 f.debugFramer.AllowIllegalReads = true
1621 }
1622 f.debugFramerBuf.Write(f.wbuf)
1623 fr, err := f.debugFramer.ReadFrame()
1624 if err != nil {
1625 f.debugWriteLoggerf("http2: Framer %p: failed to decode just-written frame", f)
1626 return
1627 }
1628 f.debugWriteLoggerf("http2: Framer %p: wrote %v", f, http2summarizeFrame(fr))
1629 }
1630
1631 func (f *http2Framer) writeByte(v byte) { f.wbuf = append(f.wbuf, v) }
1632
1633 func (f *http2Framer) writeBytes(v []byte) { f.wbuf = append(f.wbuf, v...) }
1634
1635 func (f *http2Framer) writeUint16(v uint16) { f.wbuf = append(f.wbuf, byte(v>>8), byte(v)) }
1636
1637 func (f *http2Framer) writeUint32(v uint32) {
1638 f.wbuf = append(f.wbuf, byte(v>>24), byte(v>>16), byte(v>>8), byte(v))
1639 }
1640
1641 const (
1642 http2minMaxFrameSize = 1 << 14
1643 http2maxFrameSize = 1<<24 - 1
1644 )
1645
1646
1647
1648
1649 func (fr *http2Framer) SetReuseFrames() {
1650 if fr.frameCache != nil {
1651 return
1652 }
1653 fr.frameCache = &http2frameCache{}
1654 }
1655
1656 type http2frameCache struct {
1657 dataFrame http2DataFrame
1658 }
1659
1660 func (fc *http2frameCache) getDataFrame() *http2DataFrame {
1661 if fc == nil {
1662 return &http2DataFrame{}
1663 }
1664 return &fc.dataFrame
1665 }
1666
1667
1668 func http2NewFramer(w io.Writer, r io.Reader) *http2Framer {
1669 fr := &http2Framer{
1670 w: w,
1671 r: r,
1672 logReads: http2logFrameReads,
1673 logWrites: http2logFrameWrites,
1674 debugReadLoggerf: log.Printf,
1675 debugWriteLoggerf: log.Printf,
1676 }
1677 fr.getReadBuf = func(size uint32) []byte {
1678 if cap(fr.readBuf) >= int(size) {
1679 return fr.readBuf[:size]
1680 }
1681 fr.readBuf = make([]byte, size)
1682 return fr.readBuf
1683 }
1684 fr.SetMaxReadFrameSize(http2maxFrameSize)
1685 return fr
1686 }
1687
1688
1689
1690
1691
1692 func (fr *http2Framer) SetMaxReadFrameSize(v uint32) {
1693 if v > http2maxFrameSize {
1694 v = http2maxFrameSize
1695 }
1696 fr.maxReadSize = v
1697 }
1698
1699
1700
1701
1702
1703
1704
1705
1706 func (fr *http2Framer) ErrorDetail() error {
1707 return fr.errDetail
1708 }
1709
1710
1711
1712 var http2ErrFrameTooLarge = errors.New("http2: frame too large")
1713
1714
1715
1716 func http2terminalReadFrameError(err error) bool {
1717 if _, ok := err.(http2StreamError); ok {
1718 return false
1719 }
1720 return err != nil
1721 }
1722
1723
1724
1725
1726
1727
1728
1729
1730 func (fr *http2Framer) ReadFrame() (http2Frame, error) {
1731 fr.errDetail = nil
1732 if fr.lastFrame != nil {
1733 fr.lastFrame.invalidate()
1734 }
1735 fh, err := http2readFrameHeader(fr.headerBuf[:], fr.r)
1736 if err != nil {
1737 return nil, err
1738 }
1739 if fh.Length > fr.maxReadSize {
1740 return nil, http2ErrFrameTooLarge
1741 }
1742 payload := fr.getReadBuf(fh.Length)
1743 if _, err := io.ReadFull(fr.r, payload); err != nil {
1744 return nil, err
1745 }
1746 f, err := http2typeFrameParser(fh.Type)(fr.frameCache, fh, payload)
1747 if err != nil {
1748 if ce, ok := err.(http2connError); ok {
1749 return nil, fr.connError(ce.Code, ce.Reason)
1750 }
1751 return nil, err
1752 }
1753 if err := fr.checkFrameOrder(f); err != nil {
1754 return nil, err
1755 }
1756 if fr.logReads {
1757 fr.debugReadLoggerf("http2: Framer %p: read %v", fr, http2summarizeFrame(f))
1758 }
1759 if fh.Type == http2FrameHeaders && fr.ReadMetaHeaders != nil {
1760 return fr.readMetaFrame(f.(*http2HeadersFrame))
1761 }
1762 return f, nil
1763 }
1764
1765
1766
1767
1768
1769 func (fr *http2Framer) connError(code http2ErrCode, reason string) error {
1770 fr.errDetail = errors.New(reason)
1771 return http2ConnectionError(code)
1772 }
1773
1774
1775
1776
1777 func (fr *http2Framer) checkFrameOrder(f http2Frame) error {
1778 last := fr.lastFrame
1779 fr.lastFrame = f
1780 if fr.AllowIllegalReads {
1781 return nil
1782 }
1783
1784 fh := f.Header()
1785 if fr.lastHeaderStream != 0 {
1786 if fh.Type != http2FrameContinuation {
1787 return fr.connError(http2ErrCodeProtocol,
1788 fmt.Sprintf("got %s for stream %d; expected CONTINUATION following %s for stream %d",
1789 fh.Type, fh.StreamID,
1790 last.Header().Type, fr.lastHeaderStream))
1791 }
1792 if fh.StreamID != fr.lastHeaderStream {
1793 return fr.connError(http2ErrCodeProtocol,
1794 fmt.Sprintf("got CONTINUATION for stream %d; expected stream %d",
1795 fh.StreamID, fr.lastHeaderStream))
1796 }
1797 } else if fh.Type == http2FrameContinuation {
1798 return fr.connError(http2ErrCodeProtocol, fmt.Sprintf("unexpected CONTINUATION for stream %d", fh.StreamID))
1799 }
1800
1801 switch fh.Type {
1802 case http2FrameHeaders, http2FrameContinuation:
1803 if fh.Flags.Has(http2FlagHeadersEndHeaders) {
1804 fr.lastHeaderStream = 0
1805 } else {
1806 fr.lastHeaderStream = fh.StreamID
1807 }
1808 }
1809
1810 return nil
1811 }
1812
1813
1814
1815
1816 type http2DataFrame struct {
1817 http2FrameHeader
1818 data []byte
1819 }
1820
1821 func (f *http2DataFrame) StreamEnded() bool {
1822 return f.http2FrameHeader.Flags.Has(http2FlagDataEndStream)
1823 }
1824
1825
1826
1827
1828
1829 func (f *http2DataFrame) Data() []byte {
1830 f.checkValid()
1831 return f.data
1832 }
1833
1834 func http2parseDataFrame(fc *http2frameCache, fh http2FrameHeader, payload []byte) (http2Frame, error) {
1835 if fh.StreamID == 0 {
1836
1837
1838
1839
1840
1841 return nil, http2connError{http2ErrCodeProtocol, "DATA frame with stream ID 0"}
1842 }
1843 f := fc.getDataFrame()
1844 f.http2FrameHeader = fh
1845
1846 var padSize byte
1847 if fh.Flags.Has(http2FlagDataPadded) {
1848 var err error
1849 payload, padSize, err = http2readByte(payload)
1850 if err != nil {
1851 return nil, err
1852 }
1853 }
1854 if int(padSize) > len(payload) {
1855
1856
1857
1858
1859 return nil, http2connError{http2ErrCodeProtocol, "pad size larger than data payload"}
1860 }
1861 f.data = payload[:len(payload)-int(padSize)]
1862 return f, nil
1863 }
1864
1865 var (
1866 http2errStreamID = errors.New("invalid stream ID")
1867 http2errDepStreamID = errors.New("invalid dependent stream ID")
1868 http2errPadLength = errors.New("pad length too large")
1869 http2errPadBytes = errors.New("padding bytes must all be zeros unless AllowIllegalWrites is enabled")
1870 )
1871
1872 func http2validStreamIDOrZero(streamID uint32) bool {
1873 return streamID&(1<<31) == 0
1874 }
1875
1876 func http2validStreamID(streamID uint32) bool {
1877 return streamID != 0 && streamID&(1<<31) == 0
1878 }
1879
1880
1881
1882
1883
1884
1885 func (f *http2Framer) WriteData(streamID uint32, endStream bool, data []byte) error {
1886 return f.WriteDataPadded(streamID, endStream, data, nil)
1887 }
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898 func (f *http2Framer) WriteDataPadded(streamID uint32, endStream bool, data, pad []byte) error {
1899 if !http2validStreamID(streamID) && !f.AllowIllegalWrites {
1900 return http2errStreamID
1901 }
1902 if len(pad) > 0 {
1903 if len(pad) > 255 {
1904 return http2errPadLength
1905 }
1906 if !f.AllowIllegalWrites {
1907 for _, b := range pad {
1908 if b != 0 {
1909
1910 return http2errPadBytes
1911 }
1912 }
1913 }
1914 }
1915 var flags http2Flags
1916 if endStream {
1917 flags |= http2FlagDataEndStream
1918 }
1919 if pad != nil {
1920 flags |= http2FlagDataPadded
1921 }
1922 f.startWrite(http2FrameData, flags, streamID)
1923 if pad != nil {
1924 f.wbuf = append(f.wbuf, byte(len(pad)))
1925 }
1926 f.wbuf = append(f.wbuf, data...)
1927 f.wbuf = append(f.wbuf, pad...)
1928 return f.endWrite()
1929 }
1930
1931
1932
1933
1934
1935
1936 type http2SettingsFrame struct {
1937 http2FrameHeader
1938 p []byte
1939 }
1940
1941 func http2parseSettingsFrame(_ *http2frameCache, fh http2FrameHeader, p []byte) (http2Frame, error) {
1942 if fh.Flags.Has(http2FlagSettingsAck) && fh.Length > 0 {
1943
1944
1945
1946
1947
1948
1949 return nil, http2ConnectionError(http2ErrCodeFrameSize)
1950 }
1951 if fh.StreamID != 0 {
1952
1953
1954
1955
1956
1957
1958
1959 return nil, http2ConnectionError(http2ErrCodeProtocol)
1960 }
1961 if len(p)%6 != 0 {
1962
1963 return nil, http2ConnectionError(http2ErrCodeFrameSize)
1964 }
1965 f := &http2SettingsFrame{http2FrameHeader: fh, p: p}
1966 if v, ok := f.Value(http2SettingInitialWindowSize); ok && v > (1<<31)-1 {
1967
1968
1969
1970 return nil, http2ConnectionError(http2ErrCodeFlowControl)
1971 }
1972 return f, nil
1973 }
1974
1975 func (f *http2SettingsFrame) IsAck() bool {
1976 return f.http2FrameHeader.Flags.Has(http2FlagSettingsAck)
1977 }
1978
1979 func (f *http2SettingsFrame) Value(id http2SettingID) (v uint32, ok bool) {
1980 f.checkValid()
1981 for i := 0; i < f.NumSettings(); i++ {
1982 if s := f.Setting(i); s.ID == id {
1983 return s.Val, true
1984 }
1985 }
1986 return 0, false
1987 }
1988
1989
1990
1991 func (f *http2SettingsFrame) Setting(i int) http2Setting {
1992 buf := f.p
1993 return http2Setting{
1994 ID: http2SettingID(binary.BigEndian.Uint16(buf[i*6 : i*6+2])),
1995 Val: binary.BigEndian.Uint32(buf[i*6+2 : i*6+6]),
1996 }
1997 }
1998
1999 func (f *http2SettingsFrame) NumSettings() int { return len(f.p) / 6 }
2000
2001
2002 func (f *http2SettingsFrame) HasDuplicates() bool {
2003 num := f.NumSettings()
2004 if num == 0 {
2005 return false
2006 }
2007
2008
2009 if num < 10 {
2010 for i := 0; i < num; i++ {
2011 idi := f.Setting(i).ID
2012 for j := i + 1; j < num; j++ {
2013 idj := f.Setting(j).ID
2014 if idi == idj {
2015 return true
2016 }
2017 }
2018 }
2019 return false
2020 }
2021 seen := map[http2SettingID]bool{}
2022 for i := 0; i < num; i++ {
2023 id := f.Setting(i).ID
2024 if seen[id] {
2025 return true
2026 }
2027 seen[id] = true
2028 }
2029 return false
2030 }
2031
2032
2033
2034 func (f *http2SettingsFrame) ForeachSetting(fn func(http2Setting) error) error {
2035 f.checkValid()
2036 for i := 0; i < f.NumSettings(); i++ {
2037 if err := fn(f.Setting(i)); err != nil {
2038 return err
2039 }
2040 }
2041 return nil
2042 }
2043
2044
2045
2046
2047
2048
2049 func (f *http2Framer) WriteSettings(settings ...http2Setting) error {
2050 f.startWrite(http2FrameSettings, 0, 0)
2051 for _, s := range settings {
2052 f.writeUint16(uint16(s.ID))
2053 f.writeUint32(s.Val)
2054 }
2055 return f.endWrite()
2056 }
2057
2058
2059
2060
2061
2062 func (f *http2Framer) WriteSettingsAck() error {
2063 f.startWrite(http2FrameSettings, http2FlagSettingsAck, 0)
2064 return f.endWrite()
2065 }
2066
2067
2068
2069
2070
2071 type http2PingFrame struct {
2072 http2FrameHeader
2073 Data [8]byte
2074 }
2075
2076 func (f *http2PingFrame) IsAck() bool { return f.Flags.Has(http2FlagPingAck) }
2077
2078 func http2parsePingFrame(_ *http2frameCache, fh http2FrameHeader, payload []byte) (http2Frame, error) {
2079 if len(payload) != 8 {
2080 return nil, http2ConnectionError(http2ErrCodeFrameSize)
2081 }
2082 if fh.StreamID != 0 {
2083 return nil, http2ConnectionError(http2ErrCodeProtocol)
2084 }
2085 f := &http2PingFrame{http2FrameHeader: fh}
2086 copy(f.Data[:], payload)
2087 return f, nil
2088 }
2089
2090 func (f *http2Framer) WritePing(ack bool, data [8]byte) error {
2091 var flags http2Flags
2092 if ack {
2093 flags = http2FlagPingAck
2094 }
2095 f.startWrite(http2FramePing, flags, 0)
2096 f.writeBytes(data[:])
2097 return f.endWrite()
2098 }
2099
2100
2101
2102 type http2GoAwayFrame struct {
2103 http2FrameHeader
2104 LastStreamID uint32
2105 ErrCode http2ErrCode
2106 debugData []byte
2107 }
2108
2109
2110
2111
2112
2113 func (f *http2GoAwayFrame) DebugData() []byte {
2114 f.checkValid()
2115 return f.debugData
2116 }
2117
2118 func http2parseGoAwayFrame(_ *http2frameCache, fh http2FrameHeader, p []byte) (http2Frame, error) {
2119 if fh.StreamID != 0 {
2120 return nil, http2ConnectionError(http2ErrCodeProtocol)
2121 }
2122 if len(p) < 8 {
2123 return nil, http2ConnectionError(http2ErrCodeFrameSize)
2124 }
2125 return &http2GoAwayFrame{
2126 http2FrameHeader: fh,
2127 LastStreamID: binary.BigEndian.Uint32(p[:4]) & (1<<31 - 1),
2128 ErrCode: http2ErrCode(binary.BigEndian.Uint32(p[4:8])),
2129 debugData: p[8:],
2130 }, nil
2131 }
2132
2133 func (f *http2Framer) WriteGoAway(maxStreamID uint32, code http2ErrCode, debugData []byte) error {
2134 f.startWrite(http2FrameGoAway, 0, 0)
2135 f.writeUint32(maxStreamID & (1<<31 - 1))
2136 f.writeUint32(uint32(code))
2137 f.writeBytes(debugData)
2138 return f.endWrite()
2139 }
2140
2141
2142
2143 type http2UnknownFrame struct {
2144 http2FrameHeader
2145 p []byte
2146 }
2147
2148
2149
2150
2151
2152
2153 func (f *http2UnknownFrame) Payload() []byte {
2154 f.checkValid()
2155 return f.p
2156 }
2157
2158 func http2parseUnknownFrame(_ *http2frameCache, fh http2FrameHeader, p []byte) (http2Frame, error) {
2159 return &http2UnknownFrame{fh, p}, nil
2160 }
2161
2162
2163
2164 type http2WindowUpdateFrame struct {
2165 http2FrameHeader
2166 Increment uint32
2167 }
2168
2169 func http2parseWindowUpdateFrame(_ *http2frameCache, fh http2FrameHeader, p []byte) (http2Frame, error) {
2170 if len(p) != 4 {
2171 return nil, http2ConnectionError(http2ErrCodeFrameSize)
2172 }
2173 inc := binary.BigEndian.Uint32(p[:4]) & 0x7fffffff
2174 if inc == 0 {
2175
2176
2177
2178
2179
2180
2181 if fh.StreamID == 0 {
2182 return nil, http2ConnectionError(http2ErrCodeProtocol)
2183 }
2184 return nil, http2streamError(fh.StreamID, http2ErrCodeProtocol)
2185 }
2186 return &http2WindowUpdateFrame{
2187 http2FrameHeader: fh,
2188 Increment: inc,
2189 }, nil
2190 }
2191
2192
2193
2194
2195
2196 func (f *http2Framer) WriteWindowUpdate(streamID, incr uint32) error {
2197
2198 if (incr < 1 || incr > 2147483647) && !f.AllowIllegalWrites {
2199 return errors.New("illegal window increment value")
2200 }
2201 f.startWrite(http2FrameWindowUpdate, 0, streamID)
2202 f.writeUint32(incr)
2203 return f.endWrite()
2204 }
2205
2206
2207
2208 type http2HeadersFrame struct {
2209 http2FrameHeader
2210
2211
2212 Priority http2PriorityParam
2213
2214 headerFragBuf []byte
2215 }
2216
2217 func (f *http2HeadersFrame) HeaderBlockFragment() []byte {
2218 f.checkValid()
2219 return f.headerFragBuf
2220 }
2221
2222 func (f *http2HeadersFrame) HeadersEnded() bool {
2223 return f.http2FrameHeader.Flags.Has(http2FlagHeadersEndHeaders)
2224 }
2225
2226 func (f *http2HeadersFrame) StreamEnded() bool {
2227 return f.http2FrameHeader.Flags.Has(http2FlagHeadersEndStream)
2228 }
2229
2230 func (f *http2HeadersFrame) HasPriority() bool {
2231 return f.http2FrameHeader.Flags.Has(http2FlagHeadersPriority)
2232 }
2233
2234 func http2parseHeadersFrame(_ *http2frameCache, fh http2FrameHeader, p []byte) (_ http2Frame, err error) {
2235 hf := &http2HeadersFrame{
2236 http2FrameHeader: fh,
2237 }
2238 if fh.StreamID == 0 {
2239
2240
2241
2242
2243 return nil, http2connError{http2ErrCodeProtocol, "HEADERS frame with stream ID 0"}
2244 }
2245 var padLength uint8
2246 if fh.Flags.Has(http2FlagHeadersPadded) {
2247 if p, padLength, err = http2readByte(p); err != nil {
2248 return
2249 }
2250 }
2251 if fh.Flags.Has(http2FlagHeadersPriority) {
2252 var v uint32
2253 p, v, err = http2readUint32(p)
2254 if err != nil {
2255 return nil, err
2256 }
2257 hf.Priority.StreamDep = v & 0x7fffffff
2258 hf.Priority.Exclusive = (v != hf.Priority.StreamDep)
2259 p, hf.Priority.Weight, err = http2readByte(p)
2260 if err != nil {
2261 return nil, err
2262 }
2263 }
2264 if len(p)-int(padLength) <= 0 {
2265 return nil, http2streamError(fh.StreamID, http2ErrCodeProtocol)
2266 }
2267 hf.headerFragBuf = p[:len(p)-int(padLength)]
2268 return hf, nil
2269 }
2270
2271
2272 type http2HeadersFrameParam struct {
2273
2274 StreamID uint32
2275
2276 BlockFragment []byte
2277
2278
2279
2280
2281
2282 EndStream bool
2283
2284
2285
2286
2287 EndHeaders bool
2288
2289
2290
2291 PadLength uint8
2292
2293
2294
2295 Priority http2PriorityParam
2296 }
2297
2298
2299
2300
2301
2302
2303
2304
2305
2306 func (f *http2Framer) WriteHeaders(p http2HeadersFrameParam) error {
2307 if !http2validStreamID(p.StreamID) && !f.AllowIllegalWrites {
2308 return http2errStreamID
2309 }
2310 var flags http2Flags
2311 if p.PadLength != 0 {
2312 flags |= http2FlagHeadersPadded
2313 }
2314 if p.EndStream {
2315 flags |= http2FlagHeadersEndStream
2316 }
2317 if p.EndHeaders {
2318 flags |= http2FlagHeadersEndHeaders
2319 }
2320 if !p.Priority.IsZero() {
2321 flags |= http2FlagHeadersPriority
2322 }
2323 f.startWrite(http2FrameHeaders, flags, p.StreamID)
2324 if p.PadLength != 0 {
2325 f.writeByte(p.PadLength)
2326 }
2327 if !p.Priority.IsZero() {
2328 v := p.Priority.StreamDep
2329 if !http2validStreamIDOrZero(v) && !f.AllowIllegalWrites {
2330 return http2errDepStreamID
2331 }
2332 if p.Priority.Exclusive {
2333 v |= 1 << 31
2334 }
2335 f.writeUint32(v)
2336 f.writeByte(p.Priority.Weight)
2337 }
2338 f.wbuf = append(f.wbuf, p.BlockFragment...)
2339 f.wbuf = append(f.wbuf, http2padZeros[:p.PadLength]...)
2340 return f.endWrite()
2341 }
2342
2343
2344
2345 type http2PriorityFrame struct {
2346 http2FrameHeader
2347 http2PriorityParam
2348 }
2349
2350
2351 type http2PriorityParam struct {
2352
2353
2354
2355 StreamDep uint32
2356
2357
2358 Exclusive bool
2359
2360
2361
2362
2363
2364 Weight uint8
2365 }
2366
2367 func (p http2PriorityParam) IsZero() bool {
2368 return p == http2PriorityParam{}
2369 }
2370
2371 func http2parsePriorityFrame(_ *http2frameCache, fh http2FrameHeader, payload []byte) (http2Frame, error) {
2372 if fh.StreamID == 0 {
2373 return nil, http2connError{http2ErrCodeProtocol, "PRIORITY frame with stream ID 0"}
2374 }
2375 if len(payload) != 5 {
2376 return nil, http2connError{http2ErrCodeFrameSize, fmt.Sprintf("PRIORITY frame payload size was %d; want 5", len(payload))}
2377 }
2378 v := binary.BigEndian.Uint32(payload[:4])
2379 streamID := v & 0x7fffffff
2380 return &http2PriorityFrame{
2381 http2FrameHeader: fh,
2382 http2PriorityParam: http2PriorityParam{
2383 Weight: payload[4],
2384 StreamDep: streamID,
2385 Exclusive: streamID != v,
2386 },
2387 }, nil
2388 }
2389
2390
2391
2392
2393
2394 func (f *http2Framer) WritePriority(streamID uint32, p http2PriorityParam) error {
2395 if !http2validStreamID(streamID) && !f.AllowIllegalWrites {
2396 return http2errStreamID
2397 }
2398 if !http2validStreamIDOrZero(p.StreamDep) {
2399 return http2errDepStreamID
2400 }
2401 f.startWrite(http2FramePriority, 0, streamID)
2402 v := p.StreamDep
2403 if p.Exclusive {
2404 v |= 1 << 31
2405 }
2406 f.writeUint32(v)
2407 f.writeByte(p.Weight)
2408 return f.endWrite()
2409 }
2410
2411
2412
2413 type http2RSTStreamFrame struct {
2414 http2FrameHeader
2415 ErrCode http2ErrCode
2416 }
2417
2418 func http2parseRSTStreamFrame(_ *http2frameCache, fh http2FrameHeader, p []byte) (http2Frame, error) {
2419 if len(p) != 4 {
2420 return nil, http2ConnectionError(http2ErrCodeFrameSize)
2421 }
2422 if fh.StreamID == 0 {
2423 return nil, http2ConnectionError(http2ErrCodeProtocol)
2424 }
2425 return &http2RSTStreamFrame{fh, http2ErrCode(binary.BigEndian.Uint32(p[:4]))}, nil
2426 }
2427
2428
2429
2430
2431
2432 func (f *http2Framer) WriteRSTStream(streamID uint32, code http2ErrCode) error {
2433 if !http2validStreamID(streamID) && !f.AllowIllegalWrites {
2434 return http2errStreamID
2435 }
2436 f.startWrite(http2FrameRSTStream, 0, streamID)
2437 f.writeUint32(uint32(code))
2438 return f.endWrite()
2439 }
2440
2441
2442
2443 type http2ContinuationFrame struct {
2444 http2FrameHeader
2445 headerFragBuf []byte
2446 }
2447
2448 func http2parseContinuationFrame(_ *http2frameCache, fh http2FrameHeader, p []byte) (http2Frame, error) {
2449 if fh.StreamID == 0 {
2450 return nil, http2connError{http2ErrCodeProtocol, "CONTINUATION frame with stream ID 0"}
2451 }
2452 return &http2ContinuationFrame{fh, p}, nil
2453 }
2454
2455 func (f *http2ContinuationFrame) HeaderBlockFragment() []byte {
2456 f.checkValid()
2457 return f.headerFragBuf
2458 }
2459
2460 func (f *http2ContinuationFrame) HeadersEnded() bool {
2461 return f.http2FrameHeader.Flags.Has(http2FlagContinuationEndHeaders)
2462 }
2463
2464
2465
2466
2467
2468 func (f *http2Framer) WriteContinuation(streamID uint32, endHeaders bool, headerBlockFragment []byte) error {
2469 if !http2validStreamID(streamID) && !f.AllowIllegalWrites {
2470 return http2errStreamID
2471 }
2472 var flags http2Flags
2473 if endHeaders {
2474 flags |= http2FlagContinuationEndHeaders
2475 }
2476 f.startWrite(http2FrameContinuation, flags, streamID)
2477 f.wbuf = append(f.wbuf, headerBlockFragment...)
2478 return f.endWrite()
2479 }
2480
2481
2482
2483 type http2PushPromiseFrame struct {
2484 http2FrameHeader
2485 PromiseID uint32
2486 headerFragBuf []byte
2487 }
2488
2489 func (f *http2PushPromiseFrame) HeaderBlockFragment() []byte {
2490 f.checkValid()
2491 return f.headerFragBuf
2492 }
2493
2494 func (f *http2PushPromiseFrame) HeadersEnded() bool {
2495 return f.http2FrameHeader.Flags.Has(http2FlagPushPromiseEndHeaders)
2496 }
2497
2498 func http2parsePushPromise(_ *http2frameCache, fh http2FrameHeader, p []byte) (_ http2Frame, err error) {
2499 pp := &http2PushPromiseFrame{
2500 http2FrameHeader: fh,
2501 }
2502 if pp.StreamID == 0 {
2503
2504
2505
2506
2507
2508
2509 return nil, http2ConnectionError(http2ErrCodeProtocol)
2510 }
2511
2512
2513 var padLength uint8
2514 if fh.Flags.Has(http2FlagPushPromisePadded) {
2515 if p, padLength, err = http2readByte(p); err != nil {
2516 return
2517 }
2518 }
2519
2520 p, pp.PromiseID, err = http2readUint32(p)
2521 if err != nil {
2522 return
2523 }
2524 pp.PromiseID = pp.PromiseID & (1<<31 - 1)
2525
2526 if int(padLength) > len(p) {
2527
2528 return nil, http2ConnectionError(http2ErrCodeProtocol)
2529 }
2530 pp.headerFragBuf = p[:len(p)-int(padLength)]
2531 return pp, nil
2532 }
2533
2534
2535 type http2PushPromiseParam struct {
2536
2537 StreamID uint32
2538
2539
2540
2541 PromiseID uint32
2542
2543
2544 BlockFragment []byte
2545
2546
2547
2548
2549 EndHeaders bool
2550
2551
2552
2553 PadLength uint8
2554 }
2555
2556
2557
2558
2559
2560
2561
2562
2563 func (f *http2Framer) WritePushPromise(p http2PushPromiseParam) error {
2564 if !http2validStreamID(p.StreamID) && !f.AllowIllegalWrites {
2565 return http2errStreamID
2566 }
2567 var flags http2Flags
2568 if p.PadLength != 0 {
2569 flags |= http2FlagPushPromisePadded
2570 }
2571 if p.EndHeaders {
2572 flags |= http2FlagPushPromiseEndHeaders
2573 }
2574 f.startWrite(http2FramePushPromise, flags, p.StreamID)
2575 if p.PadLength != 0 {
2576 f.writeByte(p.PadLength)
2577 }
2578 if !http2validStreamID(p.PromiseID) && !f.AllowIllegalWrites {
2579 return http2errStreamID
2580 }
2581 f.writeUint32(p.PromiseID)
2582 f.wbuf = append(f.wbuf, p.BlockFragment...)
2583 f.wbuf = append(f.wbuf, http2padZeros[:p.PadLength]...)
2584 return f.endWrite()
2585 }
2586
2587
2588
2589 func (f *http2Framer) WriteRawFrame(t http2FrameType, flags http2Flags, streamID uint32, payload []byte) error {
2590 f.startWrite(t, flags, streamID)
2591 f.writeBytes(payload)
2592 return f.endWrite()
2593 }
2594
2595 func http2readByte(p []byte) (remain []byte, b byte, err error) {
2596 if len(p) == 0 {
2597 return nil, 0, io.ErrUnexpectedEOF
2598 }
2599 return p[1:], p[0], nil
2600 }
2601
2602 func http2readUint32(p []byte) (remain []byte, v uint32, err error) {
2603 if len(p) < 4 {
2604 return nil, 0, io.ErrUnexpectedEOF
2605 }
2606 return p[4:], binary.BigEndian.Uint32(p[:4]), nil
2607 }
2608
2609 type http2streamEnder interface {
2610 StreamEnded() bool
2611 }
2612
2613 type http2headersEnder interface {
2614 HeadersEnded() bool
2615 }
2616
2617 type http2headersOrContinuation interface {
2618 http2headersEnder
2619 HeaderBlockFragment() []byte
2620 }
2621
2622
2623
2624
2625
2626
2627
2628 type http2MetaHeadersFrame struct {
2629 *http2HeadersFrame
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
2641 Fields []hpack.HeaderField
2642
2643
2644
2645
2646 Truncated bool
2647 }
2648
2649
2650
2651 func (mh *http2MetaHeadersFrame) PseudoValue(pseudo string) string {
2652 for _, hf := range mh.Fields {
2653 if !hf.IsPseudo() {
2654 return ""
2655 }
2656 if hf.Name[1:] == pseudo {
2657 return hf.Value
2658 }
2659 }
2660 return ""
2661 }
2662
2663
2664
2665 func (mh *http2MetaHeadersFrame) RegularFields() []hpack.HeaderField {
2666 for i, hf := range mh.Fields {
2667 if !hf.IsPseudo() {
2668 return mh.Fields[i:]
2669 }
2670 }
2671 return nil
2672 }
2673
2674
2675
2676 func (mh *http2MetaHeadersFrame) PseudoFields() []hpack.HeaderField {
2677 for i, hf := range mh.Fields {
2678 if !hf.IsPseudo() {
2679 return mh.Fields[:i]
2680 }
2681 }
2682 return mh.Fields
2683 }
2684
2685 func (mh *http2MetaHeadersFrame) checkPseudos() error {
2686 var isRequest, isResponse bool
2687 pf := mh.PseudoFields()
2688 for i, hf := range pf {
2689 switch hf.Name {
2690 case ":method", ":path", ":scheme", ":authority":
2691 isRequest = true
2692 case ":status":
2693 isResponse = true
2694 default:
2695 return http2pseudoHeaderError(hf.Name)
2696 }
2697
2698
2699
2700 for _, hf2 := range pf[:i] {
2701 if hf.Name == hf2.Name {
2702 return http2duplicatePseudoHeaderError(hf.Name)
2703 }
2704 }
2705 }
2706 if isRequest && isResponse {
2707 return http2errMixPseudoHeaderTypes
2708 }
2709 return nil
2710 }
2711
2712 func (fr *http2Framer) maxHeaderStringLen() int {
2713 v := fr.maxHeaderListSize()
2714 if uint32(int(v)) == v {
2715 return int(v)
2716 }
2717
2718
2719 return 0
2720 }
2721
2722
2723
2724
2725 func (fr *http2Framer) readMetaFrame(hf *http2HeadersFrame) (*http2MetaHeadersFrame, error) {
2726 if fr.AllowIllegalReads {
2727 return nil, errors.New("illegal use of AllowIllegalReads with ReadMetaHeaders")
2728 }
2729 mh := &http2MetaHeadersFrame{
2730 http2HeadersFrame: hf,
2731 }
2732 var remainSize = fr.maxHeaderListSize()
2733 var sawRegular bool
2734
2735 var invalid error
2736 hdec := fr.ReadMetaHeaders
2737 hdec.SetEmitEnabled(true)
2738 hdec.SetMaxStringLength(fr.maxHeaderStringLen())
2739 hdec.SetEmitFunc(func(hf hpack.HeaderField) {
2740 if http2VerboseLogs && fr.logReads {
2741 fr.debugReadLoggerf("http2: decoded hpack field %+v", hf)
2742 }
2743 if !httpguts.ValidHeaderFieldValue(hf.Value) {
2744 invalid = http2headerFieldValueError(hf.Value)
2745 }
2746 isPseudo := strings.HasPrefix(hf.Name, ":")
2747 if isPseudo {
2748 if sawRegular {
2749 invalid = http2errPseudoAfterRegular
2750 }
2751 } else {
2752 sawRegular = true
2753 if !http2validWireHeaderFieldName(hf.Name) {
2754 invalid = http2headerFieldNameError(hf.Name)
2755 }
2756 }
2757
2758 if invalid != nil {
2759 hdec.SetEmitEnabled(false)
2760 return
2761 }
2762
2763 size := hf.Size()
2764 if size > remainSize {
2765 hdec.SetEmitEnabled(false)
2766 mh.Truncated = true
2767 return
2768 }
2769 remainSize -= size
2770
2771 mh.Fields = append(mh.Fields, hf)
2772 })
2773
2774 defer hdec.SetEmitFunc(func(hf hpack.HeaderField) {})
2775
2776 var hc http2headersOrContinuation = hf
2777 for {
2778 frag := hc.HeaderBlockFragment()
2779 if _, err := hdec.Write(frag); err != nil {
2780 return nil, http2ConnectionError(http2ErrCodeCompression)
2781 }
2782
2783 if hc.HeadersEnded() {
2784 break
2785 }
2786 if f, err := fr.ReadFrame(); err != nil {
2787 return nil, err
2788 } else {
2789 hc = f.(*http2ContinuationFrame)
2790 }
2791 }
2792
2793 mh.http2HeadersFrame.headerFragBuf = nil
2794 mh.http2HeadersFrame.invalidate()
2795
2796 if err := hdec.Close(); err != nil {
2797 return nil, http2ConnectionError(http2ErrCodeCompression)
2798 }
2799 if invalid != nil {
2800 fr.errDetail = invalid
2801 if http2VerboseLogs {
2802 log.Printf("http2: invalid header: %v", invalid)
2803 }
2804 return nil, http2StreamError{mh.StreamID, http2ErrCodeProtocol, invalid}
2805 }
2806 if err := mh.checkPseudos(); err != nil {
2807 fr.errDetail = err
2808 if http2VerboseLogs {
2809 log.Printf("http2: invalid pseudo headers: %v", err)
2810 }
2811 return nil, http2StreamError{mh.StreamID, http2ErrCodeProtocol, err}
2812 }
2813 return mh, nil
2814 }
2815
2816 func http2summarizeFrame(f http2Frame) string {
2817 var buf bytes.Buffer
2818 f.Header().writeDebug(&buf)
2819 switch f := f.(type) {
2820 case *http2SettingsFrame:
2821 n := 0
2822 f.ForeachSetting(func(s http2Setting) error {
2823 n++
2824 if n == 1 {
2825 buf.WriteString(", settings:")
2826 }
2827 fmt.Fprintf(&buf, " %v=%v,", s.ID, s.Val)
2828 return nil
2829 })
2830 if n > 0 {
2831 buf.Truncate(buf.Len() - 1)
2832 }
2833 case *http2DataFrame:
2834 data := f.Data()
2835 const max = 256
2836 if len(data) > max {
2837 data = data[:max]
2838 }
2839 fmt.Fprintf(&buf, " data=%q", data)
2840 if len(f.Data()) > max {
2841 fmt.Fprintf(&buf, " (%d bytes omitted)", len(f.Data())-max)
2842 }
2843 case *http2WindowUpdateFrame:
2844 if f.StreamID == 0 {
2845 buf.WriteString(" (conn)")
2846 }
2847 fmt.Fprintf(&buf, " incr=%v", f.Increment)
2848 case *http2PingFrame:
2849 fmt.Fprintf(&buf, " ping=%q", f.Data[:])
2850 case *http2GoAwayFrame:
2851 fmt.Fprintf(&buf, " LastStreamID=%v ErrCode=%v Debug=%q",
2852 f.LastStreamID, f.ErrCode, f.debugData)
2853 case *http2RSTStreamFrame:
2854 fmt.Fprintf(&buf, " ErrCode=%v", f.ErrCode)
2855 }
2856 return buf.String()
2857 }
2858
2859 func http2traceHasWroteHeaderField(trace *httptrace.ClientTrace) bool {
2860 return trace != nil && trace.WroteHeaderField != nil
2861 }
2862
2863 func http2traceWroteHeaderField(trace *httptrace.ClientTrace, k, v string) {
2864 if trace != nil && trace.WroteHeaderField != nil {
2865 trace.WroteHeaderField(k, []string{v})
2866 }
2867 }
2868
2869 func http2traceGot1xxResponseFunc(trace *httptrace.ClientTrace) func(int, textproto.MIMEHeader) error {
2870 if trace != nil {
2871 return trace.Got1xxResponse
2872 }
2873 return nil
2874 }
2875
2876 var http2DebugGoroutines = os.Getenv("DEBUG_HTTP2_GOROUTINES") == "1"
2877
2878 type http2goroutineLock uint64
2879
2880 func http2newGoroutineLock() http2goroutineLock {
2881 if !http2DebugGoroutines {
2882 return 0
2883 }
2884 return http2goroutineLock(http2curGoroutineID())
2885 }
2886
2887 func (g http2goroutineLock) check() {
2888 if !http2DebugGoroutines {
2889 return
2890 }
2891 if http2curGoroutineID() != uint64(g) {
2892 panic("running on the wrong goroutine")
2893 }
2894 }
2895
2896 func (g http2goroutineLock) checkNotOn() {
2897 if !http2DebugGoroutines {
2898 return
2899 }
2900 if http2curGoroutineID() == uint64(g) {
2901 panic("running on the wrong goroutine")
2902 }
2903 }
2904
2905 var http2goroutineSpace = []byte("goroutine ")
2906
2907 func http2curGoroutineID() uint64 {
2908 bp := http2littleBuf.Get().(*[]byte)
2909 defer http2littleBuf.Put(bp)
2910 b := *bp
2911 b = b[:runtime.Stack(b, false)]
2912
2913 b = bytes.TrimPrefix(b, http2goroutineSpace)
2914 i := bytes.IndexByte(b, ' ')
2915 if i < 0 {
2916 panic(fmt.Sprintf("No space found in %q", b))
2917 }
2918 b = b[:i]
2919 n, err := http2parseUintBytes(b, 10, 64)
2920 if err != nil {
2921 panic(fmt.Sprintf("Failed to parse goroutine ID out of %q: %v", b, err))
2922 }
2923 return n
2924 }
2925
2926 var http2littleBuf = sync.Pool{
2927 New: func() interface{} {
2928 buf := make([]byte, 64)
2929 return &buf
2930 },
2931 }
2932
2933
2934 func http2parseUintBytes(s []byte, base int, bitSize int) (n uint64, err error) {
2935 var cutoff, maxVal uint64
2936
2937 if bitSize == 0 {
2938 bitSize = int(strconv.IntSize)
2939 }
2940
2941 s0 := s
2942 switch {
2943 case len(s) < 1:
2944 err = strconv.ErrSyntax
2945 goto Error
2946
2947 case 2 <= base && base <= 36:
2948
2949
2950 case base == 0:
2951
2952 switch {
2953 case s[0] == '0' && len(s) > 1 && (s[1] == 'x' || s[1] == 'X'):
2954 base = 16
2955 s = s[2:]
2956 if len(s) < 1 {
2957 err = strconv.ErrSyntax
2958 goto Error
2959 }
2960 case s[0] == '0':
2961 base = 8
2962 default:
2963 base = 10
2964 }
2965
2966 default:
2967 err = errors.New("invalid base " + strconv.Itoa(base))
2968 goto Error
2969 }
2970
2971 n = 0
2972 cutoff = http2cutoff64(base)
2973 maxVal = 1<<uint(bitSize) - 1
2974
2975 for i := 0; i < len(s); i++ {
2976 var v byte
2977 d := s[i]
2978 switch {
2979 case '0' <= d && d <= '9':
2980 v = d - '0'
2981 case 'a' <= d && d <= 'z':
2982 v = d - 'a' + 10
2983 case 'A' <= d && d <= 'Z':
2984 v = d - 'A' + 10
2985 default:
2986 n = 0
2987 err = strconv.ErrSyntax
2988 goto Error
2989 }
2990 if int(v) >= base {
2991 n = 0
2992 err = strconv.ErrSyntax
2993 goto Error
2994 }
2995
2996 if n >= cutoff {
2997
2998 n = 1<<64 - 1
2999 err = strconv.ErrRange
3000 goto Error
3001 }
3002 n *= uint64(base)
3003
3004 n1 := n + uint64(v)
3005 if n1 < n || n1 > maxVal {
3006
3007 n = 1<<64 - 1
3008 err = strconv.ErrRange
3009 goto Error
3010 }
3011 n = n1
3012 }
3013
3014 return n, nil
3015
3016 Error:
3017 return n, &strconv.NumError{Func: "ParseUint", Num: string(s0), Err: err}
3018 }
3019
3020
3021 func http2cutoff64(base int) uint64 {
3022 if base < 2 {
3023 return 0
3024 }
3025 return (1<<64-1)/uint64(base) + 1
3026 }
3027
3028 var (
3029 http2commonBuildOnce sync.Once
3030 http2commonLowerHeader map[string]string
3031 http2commonCanonHeader map[string]string
3032 )
3033
3034 func http2buildCommonHeaderMapsOnce() {
3035 http2commonBuildOnce.Do(http2buildCommonHeaderMaps)
3036 }
3037
3038 func http2buildCommonHeaderMaps() {
3039 common := []string{
3040 "accept",
3041 "accept-charset",
3042 "accept-encoding",
3043 "accept-language",
3044 "accept-ranges",
3045 "age",
3046 "access-control-allow-origin",
3047 "allow",
3048 "authorization",
3049 "cache-control",
3050 "content-disposition",
3051 "content-encoding",
3052 "content-language",
3053 "content-length",
3054 "content-location",
3055 "content-range",
3056 "content-type",
3057 "cookie",
3058 "date",
3059 "etag",
3060 "expect",
3061 "expires",
3062 "from",
3063 "host",
3064 "if-match",
3065 "if-modified-since",
3066 "if-none-match",
3067 "if-unmodified-since",
3068 "last-modified",
3069 "link",
3070 "location",
3071 "max-forwards",
3072 "proxy-authenticate",
3073 "proxy-authorization",
3074 "range",
3075 "referer",
3076 "refresh",
3077 "retry-after",
3078 "server",
3079 "set-cookie",
3080 "strict-transport-security",
3081 "trailer",
3082 "transfer-encoding",
3083 "user-agent",
3084 "vary",
3085 "via",
3086 "www-authenticate",
3087 }
3088 http2commonLowerHeader = make(map[string]string, len(common))
3089 http2commonCanonHeader = make(map[string]string, len(common))
3090 for _, v := range common {
3091 chk := CanonicalHeaderKey(v)
3092 http2commonLowerHeader[chk] = v
3093 http2commonCanonHeader[v] = chk
3094 }
3095 }
3096
3097 func http2lowerHeader(v string) string {
3098 http2buildCommonHeaderMapsOnce()
3099 if s, ok := http2commonLowerHeader[v]; ok {
3100 return s
3101 }
3102 return strings.ToLower(v)
3103 }
3104
3105 var (
3106 http2VerboseLogs bool
3107 http2logFrameWrites bool
3108 http2logFrameReads bool
3109 http2inTests bool
3110 )
3111
3112 func init() {
3113 e := os.Getenv("GODEBUG")
3114 if strings.Contains(e, "http2debug=1") {
3115 http2VerboseLogs = true
3116 }
3117 if strings.Contains(e, "http2debug=2") {
3118 http2VerboseLogs = true
3119 http2logFrameWrites = true
3120 http2logFrameReads = true
3121 }
3122 }
3123
3124 const (
3125
3126
3127 http2ClientPreface = "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"
3128
3129
3130
3131 http2initialMaxFrameSize = 16384
3132
3133
3134
3135 http2NextProtoTLS = "h2"
3136
3137
3138 http2initialHeaderTableSize = 4096
3139
3140 http2initialWindowSize = 65535
3141
3142 http2defaultMaxReadFrameSize = 1 << 20
3143 )
3144
3145 var (
3146 http2clientPreface = []byte(http2ClientPreface)
3147 )
3148
3149 type http2streamState int
3150
3151
3152
3153
3154
3155
3156
3157
3158
3159
3160
3161
3162
3163 const (
3164 http2stateIdle http2streamState = iota
3165 http2stateOpen
3166 http2stateHalfClosedLocal
3167 http2stateHalfClosedRemote
3168 http2stateClosed
3169 )
3170
3171 var http2stateName = [...]string{
3172 http2stateIdle: "Idle",
3173 http2stateOpen: "Open",
3174 http2stateHalfClosedLocal: "HalfClosedLocal",
3175 http2stateHalfClosedRemote: "HalfClosedRemote",
3176 http2stateClosed: "Closed",
3177 }
3178
3179 func (st http2streamState) String() string {
3180 return http2stateName[st]
3181 }
3182
3183
3184 type http2Setting struct {
3185
3186
3187 ID http2SettingID
3188
3189
3190 Val uint32
3191 }
3192
3193 func (s http2Setting) String() string {
3194 return fmt.Sprintf("[%v = %d]", s.ID, s.Val)
3195 }
3196
3197
3198 func (s http2Setting) Valid() error {
3199
3200 switch s.ID {
3201 case http2SettingEnablePush:
3202 if s.Val != 1 && s.Val != 0 {
3203 return http2ConnectionError(http2ErrCodeProtocol)
3204 }
3205 case http2SettingInitialWindowSize:
3206 if s.Val > 1<<31-1 {
3207 return http2ConnectionError(http2ErrCodeFlowControl)
3208 }
3209 case http2SettingMaxFrameSize:
3210 if s.Val < 16384 || s.Val > 1<<24-1 {
3211 return http2ConnectionError(http2ErrCodeProtocol)
3212 }
3213 }
3214 return nil
3215 }
3216
3217
3218
3219 type http2SettingID uint16
3220
3221 const (
3222 http2SettingHeaderTableSize http2SettingID = 0x1
3223 http2SettingEnablePush http2SettingID = 0x2
3224 http2SettingMaxConcurrentStreams http2SettingID = 0x3
3225 http2SettingInitialWindowSize http2SettingID = 0x4
3226 http2SettingMaxFrameSize http2SettingID = 0x5
3227 http2SettingMaxHeaderListSize http2SettingID = 0x6
3228 )
3229
3230 var http2settingName = map[http2SettingID]string{
3231 http2SettingHeaderTableSize: "HEADER_TABLE_SIZE",
3232 http2SettingEnablePush: "ENABLE_PUSH",
3233 http2SettingMaxConcurrentStreams: "MAX_CONCURRENT_STREAMS",
3234 http2SettingInitialWindowSize: "INITIAL_WINDOW_SIZE",
3235 http2SettingMaxFrameSize: "MAX_FRAME_SIZE",
3236 http2SettingMaxHeaderListSize: "MAX_HEADER_LIST_SIZE",
3237 }
3238
3239 func (s http2SettingID) String() string {
3240 if v, ok := http2settingName[s]; ok {
3241 return v
3242 }
3243 return fmt.Sprintf("UNKNOWN_SETTING_%d", uint16(s))
3244 }
3245
3246
3247
3248
3249
3250
3251
3252
3253
3254 func http2validWireHeaderFieldName(v string) bool {
3255 if len(v) == 0 {
3256 return false
3257 }
3258 for _, r := range v {
3259 if !httpguts.IsTokenRune(r) {
3260 return false
3261 }
3262 if 'A' <= r && r <= 'Z' {
3263 return false
3264 }
3265 }
3266 return true
3267 }
3268
3269 func http2httpCodeString(code int) string {
3270 switch code {
3271 case 200:
3272 return "200"
3273 case 404:
3274 return "404"
3275 }
3276 return strconv.Itoa(code)
3277 }
3278
3279
3280 type http2stringWriter interface {
3281 WriteString(s string) (n int, err error)
3282 }
3283
3284
3285 type http2gate chan struct{}
3286
3287 func (g http2gate) Done() { g <- struct{}{} }
3288
3289 func (g http2gate) Wait() { <-g }
3290
3291
3292 type http2closeWaiter chan struct{}
3293
3294
3295
3296
3297
3298 func (cw *http2closeWaiter) Init() {
3299 *cw = make(chan struct{})
3300 }
3301
3302
3303 func (cw http2closeWaiter) Close() {
3304 close(cw)
3305 }
3306
3307
3308 func (cw http2closeWaiter) Wait() {
3309 <-cw
3310 }
3311
3312
3313
3314
3315 type http2bufferedWriter struct {
3316 _ http2incomparable
3317 w io.Writer
3318 bw *bufio.Writer
3319 }
3320
3321 func http2newBufferedWriter(w io.Writer) *http2bufferedWriter {
3322 return &http2bufferedWriter{w: w}
3323 }
3324
3325
3326
3327
3328
3329
3330
3331 const http2bufWriterPoolBufferSize = 4 << 10
3332
3333 var http2bufWriterPool = sync.Pool{
3334 New: func() interface{} {
3335 return bufio.NewWriterSize(nil, http2bufWriterPoolBufferSize)
3336 },
3337 }
3338
3339 func (w *http2bufferedWriter) Available() int {
3340 if w.bw == nil {
3341 return http2bufWriterPoolBufferSize
3342 }
3343 return w.bw.Available()
3344 }
3345
3346 func (w *http2bufferedWriter) Write(p []byte) (n int, err error) {
3347 if w.bw == nil {
3348 bw := http2bufWriterPool.Get().(*bufio.Writer)
3349 bw.Reset(w.w)
3350 w.bw = bw
3351 }
3352 return w.bw.Write(p)
3353 }
3354
3355 func (w *http2bufferedWriter) Flush() error {
3356 bw := w.bw
3357 if bw == nil {
3358 return nil
3359 }
3360 err := bw.Flush()
3361 bw.Reset(nil)
3362 http2bufWriterPool.Put(bw)
3363 w.bw = nil
3364 return err
3365 }
3366
3367 func http2mustUint31(v int32) uint32 {
3368 if v < 0 || v > 2147483647 {
3369 panic("out of range")
3370 }
3371 return uint32(v)
3372 }
3373
3374
3375
3376 func http2bodyAllowedForStatus(status int) bool {
3377 switch {
3378 case status >= 100 && status <= 199:
3379 return false
3380 case status == 204:
3381 return false
3382 case status == 304:
3383 return false
3384 }
3385 return true
3386 }
3387
3388 type http2httpError struct {
3389 _ http2incomparable
3390 msg string
3391 timeout bool
3392 }
3393
3394 func (e *http2httpError) Error() string { return e.msg }
3395
3396 func (e *http2httpError) Timeout() bool { return e.timeout }
3397
3398 func (e *http2httpError) Temporary() bool { return true }
3399
3400 var http2errTimeout error = &http2httpError{msg: "http2: timeout awaiting response headers", timeout: true}
3401
3402 type http2connectionStater interface {
3403 ConnectionState() tls.ConnectionState
3404 }
3405
3406 var http2sorterPool = sync.Pool{New: func() interface{} { return new(http2sorter) }}
3407
3408 type http2sorter struct {
3409 v []string
3410 }
3411
3412 func (s *http2sorter) Len() int { return len(s.v) }
3413
3414 func (s *http2sorter) Swap(i, j int) { s.v[i], s.v[j] = s.v[j], s.v[i] }
3415
3416 func (s *http2sorter) Less(i, j int) bool { return s.v[i] < s.v[j] }
3417
3418
3419
3420
3421
3422 func (s *http2sorter) Keys(h Header) []string {
3423 keys := s.v[:0]
3424 for k := range h {
3425 keys = append(keys, k)
3426 }
3427 s.v = keys
3428 sort.Sort(s)
3429 return keys
3430 }
3431
3432 func (s *http2sorter) SortStrings(ss []string) {
3433
3434
3435 save := s.v
3436 s.v = ss
3437 sort.Sort(s)
3438 s.v = save
3439 }
3440
3441
3442
3443
3444
3445
3446
3447
3448
3449
3450
3451
3452
3453
3454 func http2validPseudoPath(v string) bool {
3455 return (len(v) > 0 && v[0] == '/') || v == "*"
3456 }
3457
3458
3459
3460
3461 type http2incomparable [0]func()
3462
3463
3464
3465
3466 type http2pipe struct {
3467 mu sync.Mutex
3468 c sync.Cond
3469 b http2pipeBuffer
3470 unread int
3471 err error
3472 breakErr error
3473 donec chan struct{}
3474 readFn func()
3475 }
3476
3477 type http2pipeBuffer interface {
3478 Len() int
3479 io.Writer
3480 io.Reader
3481 }
3482
3483 func (p *http2pipe) Len() int {
3484 p.mu.Lock()
3485 defer p.mu.Unlock()
3486 if p.b == nil {
3487 return p.unread
3488 }
3489 return p.b.Len()
3490 }
3491
3492
3493
3494 func (p *http2pipe) Read(d []byte) (n int, err error) {
3495 p.mu.Lock()
3496 defer p.mu.Unlock()
3497 if p.c.L == nil {
3498 p.c.L = &p.mu
3499 }
3500 for {
3501 if p.breakErr != nil {
3502 return 0, p.breakErr
3503 }
3504 if p.b != nil && p.b.Len() > 0 {
3505 return p.b.Read(d)
3506 }
3507 if p.err != nil {
3508 if p.readFn != nil {
3509 p.readFn()
3510 p.readFn = nil
3511 }
3512 p.b = nil
3513 return 0, p.err
3514 }
3515 p.c.Wait()
3516 }
3517 }
3518
3519 var http2errClosedPipeWrite = errors.New("write on closed buffer")
3520
3521
3522
3523 func (p *http2pipe) Write(d []byte) (n int, err error) {
3524 p.mu.Lock()
3525 defer p.mu.Unlock()
3526 if p.c.L == nil {
3527 p.c.L = &p.mu
3528 }
3529 defer p.c.Signal()
3530 if p.err != nil {
3531 return 0, http2errClosedPipeWrite
3532 }
3533 if p.breakErr != nil {
3534 p.unread += len(d)
3535 return len(d), nil
3536 }
3537 return p.b.Write(d)
3538 }
3539
3540
3541
3542
3543
3544
3545 func (p *http2pipe) CloseWithError(err error) { p.closeWithError(&p.err, err, nil) }
3546
3547
3548
3549
3550 func (p *http2pipe) BreakWithError(err error) { p.closeWithError(&p.breakErr, err, nil) }
3551
3552
3553
3554 func (p *http2pipe) closeWithErrorAndCode(err error, fn func()) { p.closeWithError(&p.err, err, fn) }
3555
3556 func (p *http2pipe) closeWithError(dst *error, err error, fn func()) {
3557 if err == nil {
3558 panic("err must be non-nil")
3559 }
3560 p.mu.Lock()
3561 defer p.mu.Unlock()
3562 if p.c.L == nil {
3563 p.c.L = &p.mu
3564 }
3565 defer p.c.Signal()
3566 if *dst != nil {
3567
3568 return
3569 }
3570 p.readFn = fn
3571 if dst == &p.breakErr {
3572 if p.b != nil {
3573 p.unread += p.b.Len()
3574 }
3575 p.b = nil
3576 }
3577 *dst = err
3578 p.closeDoneLocked()
3579 }
3580
3581
3582 func (p *http2pipe) closeDoneLocked() {
3583 if p.donec == nil {
3584 return
3585 }
3586
3587
3588 select {
3589 case <-p.donec:
3590 default:
3591 close(p.donec)
3592 }
3593 }
3594
3595
3596 func (p *http2pipe) Err() error {
3597 p.mu.Lock()
3598 defer p.mu.Unlock()
3599 if p.breakErr != nil {
3600 return p.breakErr
3601 }
3602 return p.err
3603 }
3604
3605
3606
3607 func (p *http2pipe) Done() <-chan struct{} {
3608 p.mu.Lock()
3609 defer p.mu.Unlock()
3610 if p.donec == nil {
3611 p.donec = make(chan struct{})
3612 if p.err != nil || p.breakErr != nil {
3613
3614 p.closeDoneLocked()
3615 }
3616 }
3617 return p.donec
3618 }
3619
3620 const (
3621 http2prefaceTimeout = 10 * time.Second
3622 http2firstSettingsTimeout = 2 * time.Second
3623 http2handlerChunkWriteSize = 4 << 10
3624 http2defaultMaxStreams = 250
3625 http2maxQueuedControlFrames = 10000
3626 )
3627
3628 var (
3629 http2errClientDisconnected = errors.New("client disconnected")
3630 http2errClosedBody = errors.New("body closed by handler")
3631 http2errHandlerComplete = errors.New("http2: request body closed due to handler exiting")
3632 http2errStreamClosed = errors.New("http2: stream closed")
3633 )
3634
3635 var http2responseWriterStatePool = sync.Pool{
3636 New: func() interface{} {
3637 rws := &http2responseWriterState{}
3638 rws.bw = bufio.NewWriterSize(http2chunkWriter{rws}, http2handlerChunkWriteSize)
3639 return rws
3640 },
3641 }
3642
3643
3644 var (
3645 http2testHookOnConn func()
3646 http2testHookGetServerConn func(*http2serverConn)
3647 http2testHookOnPanicMu *sync.Mutex
3648 http2testHookOnPanic func(sc *http2serverConn, panicVal interface{}) (rePanic bool)
3649 )
3650
3651
3652 type http2Server struct {
3653
3654
3655
3656
3657 MaxHandlers int
3658
3659
3660
3661
3662
3663
3664
3665 MaxConcurrentStreams uint32
3666
3667
3668
3669
3670
3671 MaxReadFrameSize uint32
3672
3673
3674
3675 PermitProhibitedCipherSuites bool
3676
3677
3678
3679
3680 IdleTimeout time.Duration
3681
3682
3683
3684
3685
3686
3687 MaxUploadBufferPerConnection int32
3688
3689
3690
3691
3692
3693 MaxUploadBufferPerStream int32
3694
3695
3696
3697 NewWriteScheduler func() http2WriteScheduler
3698
3699
3700
3701
3702 state *http2serverInternalState
3703 }
3704
3705 func (s *http2Server) initialConnRecvWindowSize() int32 {
3706 if s.MaxUploadBufferPerConnection > http2initialWindowSize {
3707 return s.MaxUploadBufferPerConnection
3708 }
3709 return 1 << 20
3710 }
3711
3712 func (s *http2Server) initialStreamRecvWindowSize() int32 {
3713 if s.MaxUploadBufferPerStream > 0 {
3714 return s.MaxUploadBufferPerStream
3715 }
3716 return 1 << 20
3717 }
3718
3719 func (s *http2Server) maxReadFrameSize() uint32 {
3720 if v := s.MaxReadFrameSize; v >= http2minMaxFrameSize && v <= http2maxFrameSize {
3721 return v
3722 }
3723 return http2defaultMaxReadFrameSize
3724 }
3725
3726 func (s *http2Server) maxConcurrentStreams() uint32 {
3727 if v := s.MaxConcurrentStreams; v > 0 {
3728 return v
3729 }
3730 return http2defaultMaxStreams
3731 }
3732
3733
3734
3735
3736 func (s *http2Server) maxQueuedControlFrames() int {
3737
3738
3739 return http2maxQueuedControlFrames
3740 }
3741
3742 type http2serverInternalState struct {
3743 mu sync.Mutex
3744 activeConns map[*http2serverConn]struct{}
3745 }
3746
3747 func (s *http2serverInternalState) registerConn(sc *http2serverConn) {
3748 if s == nil {
3749 return
3750 }
3751 s.mu.Lock()
3752 s.activeConns[sc] = struct{}{}
3753 s.mu.Unlock()
3754 }
3755
3756 func (s *http2serverInternalState) unregisterConn(sc *http2serverConn) {
3757 if s == nil {
3758 return
3759 }
3760 s.mu.Lock()
3761 delete(s.activeConns, sc)
3762 s.mu.Unlock()
3763 }
3764
3765 func (s *http2serverInternalState) startGracefulShutdown() {
3766 if s == nil {
3767 return
3768 }
3769 s.mu.Lock()
3770 for sc := range s.activeConns {
3771 sc.startGracefulShutdown()
3772 }
3773 s.mu.Unlock()
3774 }
3775
3776
3777
3778
3779
3780
3781 func http2ConfigureServer(s *Server, conf *http2Server) error {
3782 if s == nil {
3783 panic("nil *http.Server")
3784 }
3785 if conf == nil {
3786 conf = new(http2Server)
3787 }
3788 conf.state = &http2serverInternalState{activeConns: make(map[*http2serverConn]struct{})}
3789 if h1, h2 := s, conf; h2.IdleTimeout == 0 {
3790 if h1.IdleTimeout != 0 {
3791 h2.IdleTimeout = h1.IdleTimeout
3792 } else {
3793 h2.IdleTimeout = h1.ReadTimeout
3794 }
3795 }
3796 s.RegisterOnShutdown(conf.state.startGracefulShutdown)
3797
3798 if s.TLSConfig == nil {
3799 s.TLSConfig = new(tls.Config)
3800 } else if s.TLSConfig.CipherSuites != nil {
3801
3802
3803
3804 haveRequired := false
3805 sawBad := false
3806 for i, cs := range s.TLSConfig.CipherSuites {
3807 switch cs {
3808 case tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
3809
3810
3811 tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256:
3812 haveRequired = true
3813 }
3814 if http2isBadCipher(cs) {
3815 sawBad = true
3816 } else if sawBad {
3817 return fmt.Errorf("http2: TLSConfig.CipherSuites index %d contains an HTTP/2-approved cipher suite (%#04x), but it comes after unapproved cipher suites. With this configuration, clients that don't support previous, approved cipher suites may be given an unapproved one and reject the connection.", i, cs)
3818 }
3819 }
3820 if !haveRequired {
3821 return fmt.Errorf("http2: TLSConfig.CipherSuites is missing an HTTP/2-required AES_128_GCM_SHA256 cipher (need at least one of TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 or TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256).")
3822 }
3823 }
3824
3825
3826
3827
3828
3829
3830
3831
3832 s.TLSConfig.PreferServerCipherSuites = true
3833
3834 haveNPN := false
3835 for _, p := range s.TLSConfig.NextProtos {
3836 if p == http2NextProtoTLS {
3837 haveNPN = true
3838 break
3839 }
3840 }
3841 if !haveNPN {
3842 s.TLSConfig.NextProtos = append(s.TLSConfig.NextProtos, http2NextProtoTLS)
3843 }
3844
3845 if s.TLSNextProto == nil {
3846 s.TLSNextProto = map[string]func(*Server, *tls.Conn, Handler){}
3847 }
3848 protoHandler := func(hs *Server, c *tls.Conn, h Handler) {
3849 if http2testHookOnConn != nil {
3850 http2testHookOnConn()
3851 }
3852
3853
3854
3855
3856
3857 var ctx context.Context
3858 type baseContexter interface {
3859 BaseContext() context.Context
3860 }
3861 if bc, ok := h.(baseContexter); ok {
3862 ctx = bc.BaseContext()
3863 }
3864 conf.ServeConn(c, &http2ServeConnOpts{
3865 Context: ctx,
3866 Handler: h,
3867 BaseConfig: hs,
3868 })
3869 }
3870 s.TLSNextProto[http2NextProtoTLS] = protoHandler
3871 return nil
3872 }
3873
3874
3875 type http2ServeConnOpts struct {
3876
3877
3878 Context context.Context
3879
3880
3881
3882 BaseConfig *Server
3883
3884
3885
3886
3887 Handler Handler
3888 }
3889
3890 func (o *http2ServeConnOpts) context() context.Context {
3891 if o != nil && o.Context != nil {
3892 return o.Context
3893 }
3894 return context.Background()
3895 }
3896
3897 func (o *http2ServeConnOpts) baseConfig() *Server {
3898 if o != nil && o.BaseConfig != nil {
3899 return o.BaseConfig
3900 }
3901 return new(Server)
3902 }
3903
3904 func (o *http2ServeConnOpts) handler() Handler {
3905 if o != nil {
3906 if o.Handler != nil {
3907 return o.Handler
3908 }
3909 if o.BaseConfig != nil && o.BaseConfig.Handler != nil {
3910 return o.BaseConfig.Handler
3911 }
3912 }
3913 return DefaultServeMux
3914 }
3915
3916
3917
3918
3919
3920
3921
3922
3923
3924
3925
3926
3927
3928
3929
3930 func (s *http2Server) ServeConn(c net.Conn, opts *http2ServeConnOpts) {
3931 baseCtx, cancel := http2serverConnBaseContext(c, opts)
3932 defer cancel()
3933
3934 sc := &http2serverConn{
3935 srv: s,
3936 hs: opts.baseConfig(),
3937 conn: c,
3938 baseCtx: baseCtx,
3939 remoteAddrStr: c.RemoteAddr().String(),
3940 bw: http2newBufferedWriter(c),
3941 handler: opts.handler(),
3942 streams: make(map[uint32]*http2stream),
3943 readFrameCh: make(chan http2readFrameResult),
3944 wantWriteFrameCh: make(chan http2FrameWriteRequest, 8),
3945 serveMsgCh: make(chan interface{}, 8),
3946 wroteFrameCh: make(chan http2frameWriteResult, 1),
3947 bodyReadCh: make(chan http2bodyReadMsg),
3948 doneServing: make(chan struct{}),
3949 clientMaxStreams: math.MaxUint32,
3950 advMaxStreams: s.maxConcurrentStreams(),
3951 initialStreamSendWindowSize: http2initialWindowSize,
3952 maxFrameSize: http2initialMaxFrameSize,
3953 headerTableSize: http2initialHeaderTableSize,
3954 serveG: http2newGoroutineLock(),
3955 pushEnabled: true,
3956 }
3957
3958 s.state.registerConn(sc)
3959 defer s.state.unregisterConn(sc)
3960
3961
3962
3963
3964
3965
3966 if sc.hs.WriteTimeout != 0 {
3967 sc.conn.SetWriteDeadline(time.Time{})
3968 }
3969
3970 if s.NewWriteScheduler != nil {
3971 sc.writeSched = s.NewWriteScheduler()
3972 } else {
3973 sc.writeSched = http2NewRandomWriteScheduler()
3974 }
3975
3976
3977
3978
3979 sc.flow.add(http2initialWindowSize)
3980 sc.inflow.add(http2initialWindowSize)
3981 sc.hpackEncoder = hpack.NewEncoder(&sc.headerWriteBuf)
3982
3983 fr := http2NewFramer(sc.bw, c)
3984 fr.ReadMetaHeaders = hpack.NewDecoder(http2initialHeaderTableSize, nil)
3985 fr.MaxHeaderListSize = sc.maxHeaderListSize()
3986 fr.SetMaxReadFrameSize(s.maxReadFrameSize())
3987 sc.framer = fr
3988
3989 if tc, ok := c.(http2connectionStater); ok {
3990 sc.tlsState = new(tls.ConnectionState)
3991 *sc.tlsState = tc.ConnectionState()
3992
3993
3994
3995
3996
3997
3998
3999
4000
4001
4002 if sc.tlsState.Version < tls.VersionTLS12 {
4003 sc.rejectConn(http2ErrCodeInadequateSecurity, "TLS version too low")
4004 return
4005 }
4006
4007 if sc.tlsState.ServerName == "" {
4008
4009
4010
4011
4012
4013
4014
4015
4016
4017 }
4018
4019 if !s.PermitProhibitedCipherSuites && http2isBadCipher(sc.tlsState.CipherSuite) {
4020
4021
4022
4023
4024
4025
4026
4027
4028
4029
4030 sc.rejectConn(http2ErrCodeInadequateSecurity, fmt.Sprintf("Prohibited TLS 1.2 Cipher Suite: %x", sc.tlsState.CipherSuite))
4031 return
4032 }
4033 }
4034
4035 if hook := http2testHookGetServerConn; hook != nil {
4036 hook(sc)
4037 }
4038 sc.serve()
4039 }
4040
4041 func http2serverConnBaseContext(c net.Conn, opts *http2ServeConnOpts) (ctx context.Context, cancel func()) {
4042 ctx, cancel = context.WithCancel(opts.context())
4043 ctx = context.WithValue(ctx, LocalAddrContextKey, c.LocalAddr())
4044 if hs := opts.baseConfig(); hs != nil {
4045 ctx = context.WithValue(ctx, ServerContextKey, hs)
4046 }
4047 return
4048 }
4049
4050 func (sc *http2serverConn) rejectConn(err http2ErrCode, debug string) {
4051 sc.vlogf("http2: server rejecting conn: %v, %s", err, debug)
4052
4053 sc.framer.WriteGoAway(0, err, []byte(debug))
4054 sc.bw.Flush()
4055 sc.conn.Close()
4056 }
4057
4058 type http2serverConn struct {
4059
4060 srv *http2Server
4061 hs *Server
4062 conn net.Conn
4063 bw *http2bufferedWriter
4064 handler Handler
4065 baseCtx context.Context
4066 framer *http2Framer
4067 doneServing chan struct{}
4068 readFrameCh chan http2readFrameResult
4069 wantWriteFrameCh chan http2FrameWriteRequest
4070 wroteFrameCh chan http2frameWriteResult
4071 bodyReadCh chan http2bodyReadMsg
4072 serveMsgCh chan interface{}
4073 flow http2flow
4074 inflow http2flow
4075 tlsState *tls.ConnectionState
4076 remoteAddrStr string
4077 writeSched http2WriteScheduler
4078
4079
4080 serveG http2goroutineLock
4081 pushEnabled bool
4082 sawFirstSettings bool
4083 needToSendSettingsAck bool
4084 unackedSettings int
4085 queuedControlFrames int
4086 clientMaxStreams uint32
4087 advMaxStreams uint32
4088 curClientStreams uint32
4089 curPushedStreams uint32
4090 maxClientStreamID uint32
4091 maxPushPromiseID uint32
4092 streams map[uint32]*http2stream
4093 initialStreamSendWindowSize int32
4094 maxFrameSize int32
4095 headerTableSize uint32
4096 peerMaxHeaderListSize uint32
4097 canonHeader map[string]string
4098 writingFrame bool
4099 writingFrameAsync bool
4100 needsFrameFlush bool
4101 inGoAway bool
4102 inFrameScheduleLoop bool
4103 needToSendGoAway bool
4104 goAwayCode http2ErrCode
4105 shutdownTimer *time.Timer
4106 idleTimer *time.Timer
4107
4108
4109 headerWriteBuf bytes.Buffer
4110 hpackEncoder *hpack.Encoder
4111
4112
4113 shutdownOnce sync.Once
4114 }
4115
4116 func (sc *http2serverConn) maxHeaderListSize() uint32 {
4117 n := sc.hs.MaxHeaderBytes
4118 if n <= 0 {
4119 n = DefaultMaxHeaderBytes
4120 }
4121
4122
4123 const perFieldOverhead = 32
4124 const typicalHeaders = 10
4125 return uint32(n + typicalHeaders*perFieldOverhead)
4126 }
4127
4128 func (sc *http2serverConn) curOpenStreams() uint32 {
4129 sc.serveG.check()
4130 return sc.curClientStreams + sc.curPushedStreams
4131 }
4132
4133
4134
4135
4136
4137
4138
4139
4140 type http2stream struct {
4141
4142 sc *http2serverConn
4143 id uint32
4144 body *http2pipe
4145 cw http2closeWaiter
4146 ctx context.Context
4147 cancelCtx func()
4148
4149
4150 bodyBytes int64
4151 declBodyBytes int64
4152 flow http2flow
4153 inflow http2flow
4154 state http2streamState
4155 resetQueued bool
4156 gotTrailerHeader bool
4157 wroteHeaders bool
4158 writeDeadline *time.Timer
4159
4160 trailer Header
4161 reqTrailer Header
4162 }
4163
4164 func (sc *http2serverConn) Framer() *http2Framer { return sc.framer }
4165
4166 func (sc *http2serverConn) CloseConn() error { return sc.conn.Close() }
4167
4168 func (sc *http2serverConn) Flush() error { return sc.bw.Flush() }
4169
4170 func (sc *http2serverConn) HeaderEncoder() (*hpack.Encoder, *bytes.Buffer) {
4171 return sc.hpackEncoder, &sc.headerWriteBuf
4172 }
4173
4174 func (sc *http2serverConn) state(streamID uint32) (http2streamState, *http2stream) {
4175 sc.serveG.check()
4176
4177 if st, ok := sc.streams[streamID]; ok {
4178 return st.state, st
4179 }
4180
4181
4182
4183
4184
4185
4186 if streamID%2 == 1 {
4187 if streamID <= sc.maxClientStreamID {
4188 return http2stateClosed, nil
4189 }
4190 } else {
4191 if streamID <= sc.maxPushPromiseID {
4192 return http2stateClosed, nil
4193 }
4194 }
4195 return http2stateIdle, nil
4196 }
4197
4198
4199
4200
4201 func (sc *http2serverConn) setConnState(state ConnState) {
4202 if sc.hs.ConnState != nil {
4203 sc.hs.ConnState(sc.conn, state)
4204 }
4205 }
4206
4207 func (sc *http2serverConn) vlogf(format string, args ...interface{}) {
4208 if http2VerboseLogs {
4209 sc.logf(format, args...)
4210 }
4211 }
4212
4213 func (sc *http2serverConn) logf(format string, args ...interface{}) {
4214 if lg := sc.hs.ErrorLog; lg != nil {
4215 lg.Printf(format, args...)
4216 } else {
4217 log.Printf(format, args...)
4218 }
4219 }
4220
4221
4222
4223
4224
4225 func http2errno(v error) uintptr {
4226 if rv := reflect.ValueOf(v); rv.Kind() == reflect.Uintptr {
4227 return uintptr(rv.Uint())
4228 }
4229 return 0
4230 }
4231
4232
4233
4234 func http2isClosedConnError(err error) bool {
4235 if err == nil {
4236 return false
4237 }
4238
4239
4240
4241
4242 str := err.Error()
4243 if strings.Contains(str, "use of closed network connection") {
4244 return true
4245 }
4246
4247
4248
4249
4250
4251 if runtime.GOOS == "windows" {
4252 if oe, ok := err.(*net.OpError); ok && oe.Op == "read" {
4253 if se, ok := oe.Err.(*os.SyscallError); ok && se.Syscall == "wsarecv" {
4254 const WSAECONNABORTED = 10053
4255 const WSAECONNRESET = 10054
4256 if n := http2errno(se.Err); n == WSAECONNRESET || n == WSAECONNABORTED {
4257 return true
4258 }
4259 }
4260 }
4261 }
4262 return false
4263 }
4264
4265 func (sc *http2serverConn) condlogf(err error, format string, args ...interface{}) {
4266 if err == nil {
4267 return
4268 }
4269 if err == io.EOF || err == io.ErrUnexpectedEOF || http2isClosedConnError(err) || err == http2errPrefaceTimeout {
4270
4271 sc.vlogf(format, args...)
4272 } else {
4273 sc.logf(format, args...)
4274 }
4275 }
4276
4277 func (sc *http2serverConn) canonicalHeader(v string) string {
4278 sc.serveG.check()
4279 http2buildCommonHeaderMapsOnce()
4280 cv, ok := http2commonCanonHeader[v]
4281 if ok {
4282 return cv
4283 }
4284 cv, ok = sc.canonHeader[v]
4285 if ok {
4286 return cv
4287 }
4288 if sc.canonHeader == nil {
4289 sc.canonHeader = make(map[string]string)
4290 }
4291 cv = CanonicalHeaderKey(v)
4292 sc.canonHeader[v] = cv
4293 return cv
4294 }
4295
4296 type http2readFrameResult struct {
4297 f http2Frame
4298 err error
4299
4300
4301
4302
4303 readMore func()
4304 }
4305
4306
4307
4308
4309
4310 func (sc *http2serverConn) readFrames() {
4311 gate := make(http2gate)
4312 gateDone := gate.Done
4313 for {
4314 f, err := sc.framer.ReadFrame()
4315 select {
4316 case sc.readFrameCh <- http2readFrameResult{f, err, gateDone}:
4317 case <-sc.doneServing:
4318 return
4319 }
4320 select {
4321 case <-gate:
4322 case <-sc.doneServing:
4323 return
4324 }
4325 if http2terminalReadFrameError(err) {
4326 return
4327 }
4328 }
4329 }
4330
4331
4332 type http2frameWriteResult struct {
4333 _ http2incomparable
4334 wr http2FrameWriteRequest
4335 err error
4336 }
4337
4338
4339
4340
4341
4342 func (sc *http2serverConn) writeFrameAsync(wr http2FrameWriteRequest) {
4343 err := wr.write.writeFrame(sc)
4344 sc.wroteFrameCh <- http2frameWriteResult{wr: wr, err: err}
4345 }
4346
4347 func (sc *http2serverConn) closeAllStreamsOnConnClose() {
4348 sc.serveG.check()
4349 for _, st := range sc.streams {
4350 sc.closeStream(st, http2errClientDisconnected)
4351 }
4352 }
4353
4354 func (sc *http2serverConn) stopShutdownTimer() {
4355 sc.serveG.check()
4356 if t := sc.shutdownTimer; t != nil {
4357 t.Stop()
4358 }
4359 }
4360
4361 func (sc *http2serverConn) notePanic() {
4362
4363 if http2testHookOnPanicMu != nil {
4364 http2testHookOnPanicMu.Lock()
4365 defer http2testHookOnPanicMu.Unlock()
4366 }
4367 if http2testHookOnPanic != nil {
4368 if e := recover(); e != nil {
4369 if http2testHookOnPanic(sc, e) {
4370 panic(e)
4371 }
4372 }
4373 }
4374 }
4375
4376 func (sc *http2serverConn) serve() {
4377 sc.serveG.check()
4378 defer sc.notePanic()
4379 defer sc.conn.Close()
4380 defer sc.closeAllStreamsOnConnClose()
4381 defer sc.stopShutdownTimer()
4382 defer close(sc.doneServing)
4383
4384 if http2VerboseLogs {
4385 sc.vlogf("http2: server connection from %v on %p", sc.conn.RemoteAddr(), sc.hs)
4386 }
4387
4388 sc.writeFrame(http2FrameWriteRequest{
4389 write: http2writeSettings{
4390 {http2SettingMaxFrameSize, sc.srv.maxReadFrameSize()},
4391 {http2SettingMaxConcurrentStreams, sc.advMaxStreams},
4392 {http2SettingMaxHeaderListSize, sc.maxHeaderListSize()},
4393 {http2SettingInitialWindowSize, uint32(sc.srv.initialStreamRecvWindowSize())},
4394 },
4395 })
4396 sc.unackedSettings++
4397
4398
4399
4400 if diff := sc.srv.initialConnRecvWindowSize() - http2initialWindowSize; diff > 0 {
4401 sc.sendWindowUpdate(nil, int(diff))
4402 }
4403
4404 if err := sc.readPreface(); err != nil {
4405 sc.condlogf(err, "http2: server: error reading preface from client %v: %v", sc.conn.RemoteAddr(), err)
4406 return
4407 }
4408
4409
4410
4411
4412 sc.setConnState(StateActive)
4413 sc.setConnState(StateIdle)
4414
4415 if sc.srv.IdleTimeout != 0 {
4416 sc.idleTimer = time.AfterFunc(sc.srv.IdleTimeout, sc.onIdleTimer)
4417 defer sc.idleTimer.Stop()
4418 }
4419
4420 go sc.readFrames()
4421
4422 settingsTimer := time.AfterFunc(http2firstSettingsTimeout, sc.onSettingsTimer)
4423 defer settingsTimer.Stop()
4424
4425 loopNum := 0
4426 for {
4427 loopNum++
4428 select {
4429 case wr := <-sc.wantWriteFrameCh:
4430 if se, ok := wr.write.(http2StreamError); ok {
4431 sc.resetStream(se)
4432 break
4433 }
4434 sc.writeFrame(wr)
4435 case res := <-sc.wroteFrameCh:
4436 sc.wroteFrame(res)
4437 case res := <-sc.readFrameCh:
4438 if !sc.processFrameFromReader(res) {
4439 return
4440 }
4441 res.readMore()
4442 if settingsTimer != nil {
4443 settingsTimer.Stop()
4444 settingsTimer = nil
4445 }
4446 case m := <-sc.bodyReadCh:
4447 sc.noteBodyRead(m.st, m.n)
4448 case msg := <-sc.serveMsgCh:
4449 switch v := msg.(type) {
4450 case func(int):
4451 v(loopNum)
4452 case *http2serverMessage:
4453 switch v {
4454 case http2settingsTimerMsg:
4455 sc.logf("timeout waiting for SETTINGS frames from %v", sc.conn.RemoteAddr())
4456 return
4457 case http2idleTimerMsg:
4458 sc.vlogf("connection is idle")
4459 sc.goAway(http2ErrCodeNo)
4460 case http2shutdownTimerMsg:
4461 sc.vlogf("GOAWAY close timer fired; closing conn from %v", sc.conn.RemoteAddr())
4462 return
4463 case http2gracefulShutdownMsg:
4464 sc.startGracefulShutdownInternal()
4465 default:
4466 panic("unknown timer")
4467 }
4468 case *http2startPushRequest:
4469 sc.startPush(v)
4470 default:
4471 panic(fmt.Sprintf("unexpected type %T", v))
4472 }
4473 }
4474
4475
4476
4477
4478 if sc.queuedControlFrames > sc.srv.maxQueuedControlFrames() {
4479 sc.vlogf("http2: too many control frames in send queue, closing connection")
4480 return
4481 }
4482
4483
4484
4485
4486 sentGoAway := sc.inGoAway && !sc.needToSendGoAway && !sc.writingFrame
4487 gracefulShutdownComplete := sc.goAwayCode == http2ErrCodeNo && sc.curOpenStreams() == 0
4488 if sentGoAway && sc.shutdownTimer == nil && (sc.goAwayCode != http2ErrCodeNo || gracefulShutdownComplete) {
4489 sc.shutDownIn(http2goAwayTimeout)
4490 }
4491 }
4492 }
4493
4494 func (sc *http2serverConn) awaitGracefulShutdown(sharedCh <-chan struct{}, privateCh chan struct{}) {
4495 select {
4496 case <-sc.doneServing:
4497 case <-sharedCh:
4498 close(privateCh)
4499 }
4500 }
4501
4502 type http2serverMessage int
4503
4504
4505 var (
4506 http2settingsTimerMsg = new(http2serverMessage)
4507 http2idleTimerMsg = new(http2serverMessage)
4508 http2shutdownTimerMsg = new(http2serverMessage)
4509 http2gracefulShutdownMsg = new(http2serverMessage)
4510 )
4511
4512 func (sc *http2serverConn) onSettingsTimer() { sc.sendServeMsg(http2settingsTimerMsg) }
4513
4514 func (sc *http2serverConn) onIdleTimer() { sc.sendServeMsg(http2idleTimerMsg) }
4515
4516 func (sc *http2serverConn) onShutdownTimer() { sc.sendServeMsg(http2shutdownTimerMsg) }
4517
4518 func (sc *http2serverConn) sendServeMsg(msg interface{}) {
4519 sc.serveG.checkNotOn()
4520 select {
4521 case sc.serveMsgCh <- msg:
4522 case <-sc.doneServing:
4523 }
4524 }
4525
4526 var http2errPrefaceTimeout = errors.New("timeout waiting for client preface")
4527
4528
4529
4530
4531 func (sc *http2serverConn) readPreface() error {
4532 errc := make(chan error, 1)
4533 go func() {
4534
4535 buf := make([]byte, len(http2ClientPreface))
4536 if _, err := io.ReadFull(sc.conn, buf); err != nil {
4537 errc <- err
4538 } else if !bytes.Equal(buf, http2clientPreface) {
4539 errc <- fmt.Errorf("bogus greeting %q", buf)
4540 } else {
4541 errc <- nil
4542 }
4543 }()
4544 timer := time.NewTimer(http2prefaceTimeout)
4545 defer timer.Stop()
4546 select {
4547 case <-timer.C:
4548 return http2errPrefaceTimeout
4549 case err := <-errc:
4550 if err == nil {
4551 if http2VerboseLogs {
4552 sc.vlogf("http2: server: client %v said hello", sc.conn.RemoteAddr())
4553 }
4554 }
4555 return err
4556 }
4557 }
4558
4559 var http2errChanPool = sync.Pool{
4560 New: func() interface{} { return make(chan error, 1) },
4561 }
4562
4563 var http2writeDataPool = sync.Pool{
4564 New: func() interface{} { return new(http2writeData) },
4565 }
4566
4567
4568
4569 func (sc *http2serverConn) writeDataFromHandler(stream *http2stream, data []byte, endStream bool) error {
4570 ch := http2errChanPool.Get().(chan error)
4571 writeArg := http2writeDataPool.Get().(*http2writeData)
4572 *writeArg = http2writeData{stream.id, data, endStream}
4573 err := sc.writeFrameFromHandler(http2FrameWriteRequest{
4574 write: writeArg,
4575 stream: stream,
4576 done: ch,
4577 })
4578 if err != nil {
4579 return err
4580 }
4581 var frameWriteDone bool
4582 select {
4583 case err = <-ch:
4584 frameWriteDone = true
4585 case <-sc.doneServing:
4586 return http2errClientDisconnected
4587 case <-stream.cw:
4588
4589
4590
4591
4592
4593
4594
4595 select {
4596 case err = <-ch:
4597 frameWriteDone = true
4598 default:
4599 return http2errStreamClosed
4600 }
4601 }
4602 http2errChanPool.Put(ch)
4603 if frameWriteDone {
4604 http2writeDataPool.Put(writeArg)
4605 }
4606 return err
4607 }
4608
4609
4610
4611
4612
4613
4614
4615
4616 func (sc *http2serverConn) writeFrameFromHandler(wr http2FrameWriteRequest) error {
4617 sc.serveG.checkNotOn()
4618 select {
4619 case sc.wantWriteFrameCh <- wr:
4620 return nil
4621 case <-sc.doneServing:
4622
4623
4624 return http2errClientDisconnected
4625 }
4626 }
4627
4628
4629
4630
4631
4632
4633
4634
4635
4636 func (sc *http2serverConn) writeFrame(wr http2FrameWriteRequest) {
4637 sc.serveG.check()
4638
4639
4640 var ignoreWrite bool
4641
4642
4643
4644
4645
4646
4647
4648
4649
4650
4651
4652
4653
4654
4655
4656
4657
4658
4659
4660 if wr.StreamID() != 0 {
4661 _, isReset := wr.write.(http2StreamError)
4662 if state, _ := sc.state(wr.StreamID()); state == http2stateClosed && !isReset {
4663 ignoreWrite = true
4664 }
4665 }
4666
4667
4668
4669 switch wr.write.(type) {
4670 case *http2writeResHeaders:
4671 wr.stream.wroteHeaders = true
4672 case http2write100ContinueHeadersFrame:
4673 if wr.stream.wroteHeaders {
4674
4675
4676 if wr.done != nil {
4677 panic("wr.done != nil for write100ContinueHeadersFrame")
4678 }
4679 ignoreWrite = true
4680 }
4681 }
4682
4683 if !ignoreWrite {
4684 if wr.isControl() {
4685 sc.queuedControlFrames++
4686
4687
4688 if sc.queuedControlFrames < 0 {
4689 sc.conn.Close()
4690 }
4691 }
4692 sc.writeSched.Push(wr)
4693 }
4694 sc.scheduleFrameWrite()
4695 }
4696
4697
4698
4699
4700 func (sc *http2serverConn) startFrameWrite(wr http2FrameWriteRequest) {
4701 sc.serveG.check()
4702 if sc.writingFrame {
4703 panic("internal error: can only be writing one frame at a time")
4704 }
4705
4706 st := wr.stream
4707 if st != nil {
4708 switch st.state {
4709 case http2stateHalfClosedLocal:
4710 switch wr.write.(type) {
4711 case http2StreamError, http2handlerPanicRST, http2writeWindowUpdate:
4712
4713
4714 default:
4715 panic(fmt.Sprintf("internal error: attempt to send frame on a half-closed-local stream: %v", wr))
4716 }
4717 case http2stateClosed:
4718 panic(fmt.Sprintf("internal error: attempt to send frame on a closed stream: %v", wr))
4719 }
4720 }
4721 if wpp, ok := wr.write.(*http2writePushPromise); ok {
4722 var err error
4723 wpp.promisedID, err = wpp.allocatePromisedID()
4724 if err != nil {
4725 sc.writingFrameAsync = false
4726 wr.replyToWriter(err)
4727 return
4728 }
4729 }
4730
4731 sc.writingFrame = true
4732 sc.needsFrameFlush = true
4733 if wr.write.staysWithinBuffer(sc.bw.Available()) {
4734 sc.writingFrameAsync = false
4735 err := wr.write.writeFrame(sc)
4736 sc.wroteFrame(http2frameWriteResult{wr: wr, err: err})
4737 } else {
4738 sc.writingFrameAsync = true
4739 go sc.writeFrameAsync(wr)
4740 }
4741 }
4742
4743
4744
4745
4746 var http2errHandlerPanicked = errors.New("http2: handler panicked")
4747
4748
4749
4750 func (sc *http2serverConn) wroteFrame(res http2frameWriteResult) {
4751 sc.serveG.check()
4752 if !sc.writingFrame {
4753 panic("internal error: expected to be already writing a frame")
4754 }
4755 sc.writingFrame = false
4756 sc.writingFrameAsync = false
4757
4758 wr := res.wr
4759
4760 if http2writeEndsStream(wr.write) {
4761 st := wr.stream
4762 if st == nil {
4763 panic("internal error: expecting non-nil stream")
4764 }
4765 switch st.state {
4766 case http2stateOpen:
4767
4768
4769
4770
4771
4772
4773
4774
4775
4776
4777 st.state = http2stateHalfClosedLocal
4778
4779
4780
4781
4782 sc.resetStream(http2streamError(st.id, http2ErrCodeNo))
4783 case http2stateHalfClosedRemote:
4784 sc.closeStream(st, http2errHandlerComplete)
4785 }
4786 } else {
4787 switch v := wr.write.(type) {
4788 case http2StreamError:
4789
4790 if st, ok := sc.streams[v.StreamID]; ok {
4791 sc.closeStream(st, v)
4792 }
4793 case http2handlerPanicRST:
4794 sc.closeStream(wr.stream, http2errHandlerPanicked)
4795 }
4796 }
4797
4798
4799 wr.replyToWriter(res.err)
4800
4801 sc.scheduleFrameWrite()
4802 }
4803
4804
4805
4806
4807
4808
4809
4810
4811
4812
4813
4814 func (sc *http2serverConn) scheduleFrameWrite() {
4815 sc.serveG.check()
4816 if sc.writingFrame || sc.inFrameScheduleLoop {
4817 return
4818 }
4819 sc.inFrameScheduleLoop = true
4820 for !sc.writingFrameAsync {
4821 if sc.needToSendGoAway {
4822 sc.needToSendGoAway = false
4823 sc.startFrameWrite(http2FrameWriteRequest{
4824 write: &http2writeGoAway{
4825 maxStreamID: sc.maxClientStreamID,
4826 code: sc.goAwayCode,
4827 },
4828 })
4829 continue
4830 }
4831 if sc.needToSendSettingsAck {
4832 sc.needToSendSettingsAck = false
4833 sc.startFrameWrite(http2FrameWriteRequest{write: http2writeSettingsAck{}})
4834 continue
4835 }
4836 if !sc.inGoAway || sc.goAwayCode == http2ErrCodeNo {
4837 if wr, ok := sc.writeSched.Pop(); ok {
4838 if wr.isControl() {
4839 sc.queuedControlFrames--
4840 }
4841 sc.startFrameWrite(wr)
4842 continue
4843 }
4844 }
4845 if sc.needsFrameFlush {
4846 sc.startFrameWrite(http2FrameWriteRequest{write: http2flushFrameWriter{}})
4847 sc.needsFrameFlush = false
4848 continue
4849 }
4850 break
4851 }
4852 sc.inFrameScheduleLoop = false
4853 }
4854
4855
4856
4857
4858
4859
4860
4861
4862 func (sc *http2serverConn) startGracefulShutdown() {
4863 sc.serveG.checkNotOn()
4864 sc.shutdownOnce.Do(func() { sc.sendServeMsg(http2gracefulShutdownMsg) })
4865 }
4866
4867
4868
4869
4870
4871
4872
4873
4874
4875
4876
4877
4878
4879
4880
4881 var http2goAwayTimeout = 1 * time.Second
4882
4883 func (sc *http2serverConn) startGracefulShutdownInternal() {
4884 sc.goAway(http2ErrCodeNo)
4885 }
4886
4887 func (sc *http2serverConn) goAway(code http2ErrCode) {
4888 sc.serveG.check()
4889 if sc.inGoAway {
4890 return
4891 }
4892 sc.inGoAway = true
4893 sc.needToSendGoAway = true
4894 sc.goAwayCode = code
4895 sc.scheduleFrameWrite()
4896 }
4897
4898 func (sc *http2serverConn) shutDownIn(d time.Duration) {
4899 sc.serveG.check()
4900 sc.shutdownTimer = time.AfterFunc(d, sc.onShutdownTimer)
4901 }
4902
4903 func (sc *http2serverConn) resetStream(se http2StreamError) {
4904 sc.serveG.check()
4905 sc.writeFrame(http2FrameWriteRequest{write: se})
4906 if st, ok := sc.streams[se.StreamID]; ok {
4907 st.resetQueued = true
4908 }
4909 }
4910
4911
4912
4913
4914 func (sc *http2serverConn) processFrameFromReader(res http2readFrameResult) bool {
4915 sc.serveG.check()
4916 err := res.err
4917 if err != nil {
4918 if err == http2ErrFrameTooLarge {
4919 sc.goAway(http2ErrCodeFrameSize)
4920 return true
4921 }
4922 clientGone := err == io.EOF || err == io.ErrUnexpectedEOF || http2isClosedConnError(err)
4923 if clientGone {
4924
4925
4926
4927
4928
4929
4930
4931
4932 return false
4933 }
4934 } else {
4935 f := res.f
4936 if http2VerboseLogs {
4937 sc.vlogf("http2: server read frame %v", http2summarizeFrame(f))
4938 }
4939 err = sc.processFrame(f)
4940 if err == nil {
4941 return true
4942 }
4943 }
4944
4945 switch ev := err.(type) {
4946 case http2StreamError:
4947 sc.resetStream(ev)
4948 return true
4949 case http2goAwayFlowError:
4950 sc.goAway(http2ErrCodeFlowControl)
4951 return true
4952 case http2ConnectionError:
4953 sc.logf("http2: server connection error from %v: %v", sc.conn.RemoteAddr(), ev)
4954 sc.goAway(http2ErrCode(ev))
4955 return true
4956 default:
4957 if res.err != nil {
4958 sc.vlogf("http2: server closing client connection; error reading frame from client %s: %v", sc.conn.RemoteAddr(), err)
4959 } else {
4960 sc.logf("http2: server closing client connection: %v", err)
4961 }
4962 return false
4963 }
4964 }
4965
4966 func (sc *http2serverConn) processFrame(f http2Frame) error {
4967 sc.serveG.check()
4968
4969
4970 if !sc.sawFirstSettings {
4971 if _, ok := f.(*http2SettingsFrame); !ok {
4972 return http2ConnectionError(http2ErrCodeProtocol)
4973 }
4974 sc.sawFirstSettings = true
4975 }
4976
4977 switch f := f.(type) {
4978 case *http2SettingsFrame:
4979 return sc.processSettings(f)
4980 case *http2MetaHeadersFrame:
4981 return sc.processHeaders(f)
4982 case *http2WindowUpdateFrame:
4983 return sc.processWindowUpdate(f)
4984 case *http2PingFrame:
4985 return sc.processPing(f)
4986 case *http2DataFrame:
4987 return sc.processData(f)
4988 case *http2RSTStreamFrame:
4989 return sc.processResetStream(f)
4990 case *http2PriorityFrame:
4991 return sc.processPriority(f)
4992 case *http2GoAwayFrame:
4993 return sc.processGoAway(f)
4994 case *http2PushPromiseFrame:
4995
4996
4997 return http2ConnectionError(http2ErrCodeProtocol)
4998 default:
4999 sc.vlogf("http2: server ignoring frame: %v", f.Header())
5000 return nil
5001 }
5002 }
5003
5004 func (sc *http2serverConn) processPing(f *http2PingFrame) error {
5005 sc.serveG.check()
5006 if f.IsAck() {
5007
5008
5009 return nil
5010 }
5011 if f.StreamID != 0 {
5012
5013
5014
5015
5016
5017 return http2ConnectionError(http2ErrCodeProtocol)
5018 }
5019 if sc.inGoAway && sc.goAwayCode != http2ErrCodeNo {
5020 return nil
5021 }
5022 sc.writeFrame(http2FrameWriteRequest{write: http2writePingAck{f}})
5023 return nil
5024 }
5025
5026 func (sc *http2serverConn) processWindowUpdate(f *http2WindowUpdateFrame) error {
5027 sc.serveG.check()
5028 switch {
5029 case f.StreamID != 0:
5030 state, st := sc.state(f.StreamID)
5031 if state == http2stateIdle {
5032
5033
5034
5035
5036 return http2ConnectionError(http2ErrCodeProtocol)
5037 }
5038 if st == nil {
5039
5040
5041
5042
5043
5044 return nil
5045 }
5046 if !st.flow.add(int32(f.Increment)) {
5047 return http2streamError(f.StreamID, http2ErrCodeFlowControl)
5048 }
5049 default:
5050 if !sc.flow.add(int32(f.Increment)) {
5051 return http2goAwayFlowError{}
5052 }
5053 }
5054 sc.scheduleFrameWrite()
5055 return nil
5056 }
5057
5058 func (sc *http2serverConn) processResetStream(f *http2RSTStreamFrame) error {
5059 sc.serveG.check()
5060
5061 state, st := sc.state(f.StreamID)
5062 if state == http2stateIdle {
5063
5064
5065
5066
5067
5068 return http2ConnectionError(http2ErrCodeProtocol)
5069 }
5070 if st != nil {
5071 st.cancelCtx()
5072 sc.closeStream(st, http2streamError(f.StreamID, f.ErrCode))
5073 }
5074 return nil
5075 }
5076
5077 func (sc *http2serverConn) closeStream(st *http2stream, err error) {
5078 sc.serveG.check()
5079 if st.state == http2stateIdle || st.state == http2stateClosed {
5080 panic(fmt.Sprintf("invariant; can't close stream in state %v", st.state))
5081 }
5082 st.state = http2stateClosed
5083 if st.writeDeadline != nil {
5084 st.writeDeadline.Stop()
5085 }
5086 if st.isPushed() {
5087 sc.curPushedStreams--
5088 } else {
5089 sc.curClientStreams--
5090 }
5091 delete(sc.streams, st.id)
5092 if len(sc.streams) == 0 {
5093 sc.setConnState(StateIdle)
5094 if sc.srv.IdleTimeout != 0 {
5095 sc.idleTimer.Reset(sc.srv.IdleTimeout)
5096 }
5097 if http2h1ServerKeepAlivesDisabled(sc.hs) {
5098 sc.startGracefulShutdownInternal()
5099 }
5100 }
5101 if p := st.body; p != nil {
5102
5103
5104 sc.sendWindowUpdate(nil, p.Len())
5105
5106 p.CloseWithError(err)
5107 }
5108 st.cw.Close()
5109 sc.writeSched.CloseStream(st.id)
5110 }
5111
5112 func (sc *http2serverConn) processSettings(f *http2SettingsFrame) error {
5113 sc.serveG.check()
5114 if f.IsAck() {
5115 sc.unackedSettings--
5116 if sc.unackedSettings < 0 {
5117
5118
5119
5120 return http2ConnectionError(http2ErrCodeProtocol)
5121 }
5122 return nil
5123 }
5124 if f.NumSettings() > 100 || f.HasDuplicates() {
5125
5126
5127
5128 return http2ConnectionError(http2ErrCodeProtocol)
5129 }
5130 if err := f.ForeachSetting(sc.processSetting); err != nil {
5131 return err
5132 }
5133
5134
5135 sc.needToSendSettingsAck = true
5136 sc.scheduleFrameWrite()
5137 return nil
5138 }
5139
5140 func (sc *http2serverConn) processSetting(s http2Setting) error {
5141 sc.serveG.check()
5142 if err := s.Valid(); err != nil {
5143 return err
5144 }
5145 if http2VerboseLogs {
5146 sc.vlogf("http2: server processing setting %v", s)
5147 }
5148 switch s.ID {
5149 case http2SettingHeaderTableSize:
5150 sc.headerTableSize = s.Val
5151 sc.hpackEncoder.SetMaxDynamicTableSize(s.Val)
5152 case http2SettingEnablePush:
5153 sc.pushEnabled = s.Val != 0
5154 case http2SettingMaxConcurrentStreams:
5155 sc.clientMaxStreams = s.Val
5156 case http2SettingInitialWindowSize:
5157 return sc.processSettingInitialWindowSize(s.Val)
5158 case http2SettingMaxFrameSize:
5159 sc.maxFrameSize = int32(s.Val)
5160 case http2SettingMaxHeaderListSize:
5161 sc.peerMaxHeaderListSize = s.Val
5162 default:
5163
5164
5165
5166 if http2VerboseLogs {
5167 sc.vlogf("http2: server ignoring unknown setting %v", s)
5168 }
5169 }
5170 return nil
5171 }
5172
5173 func (sc *http2serverConn) processSettingInitialWindowSize(val uint32) error {
5174 sc.serveG.check()
5175
5176
5177
5178
5179
5180
5181
5182
5183
5184 old := sc.initialStreamSendWindowSize
5185 sc.initialStreamSendWindowSize = int32(val)
5186 growth := int32(val) - old
5187 for _, st := range sc.streams {
5188 if !st.flow.add(growth) {
5189
5190
5191
5192
5193
5194
5195 return http2ConnectionError(http2ErrCodeFlowControl)
5196 }
5197 }
5198 return nil
5199 }
5200
5201 func (sc *http2serverConn) processData(f *http2DataFrame) error {
5202 sc.serveG.check()
5203 if sc.inGoAway && sc.goAwayCode != http2ErrCodeNo {
5204 return nil
5205 }
5206 data := f.Data()
5207
5208
5209
5210
5211 id := f.Header().StreamID
5212 state, st := sc.state(id)
5213 if id == 0 || state == http2stateIdle {
5214
5215
5216
5217
5218 return http2ConnectionError(http2ErrCodeProtocol)
5219 }
5220 if st == nil || state != http2stateOpen || st.gotTrailerHeader || st.resetQueued {
5221
5222
5223
5224
5225
5226
5227
5228
5229
5230 if sc.inflow.available() < int32(f.Length) {
5231 return http2streamError(id, http2ErrCodeFlowControl)
5232 }
5233
5234
5235
5236
5237 sc.inflow.take(int32(f.Length))
5238 sc.sendWindowUpdate(nil, int(f.Length))
5239
5240 if st != nil && st.resetQueued {
5241
5242 return nil
5243 }
5244 return http2streamError(id, http2ErrCodeStreamClosed)
5245 }
5246 if st.body == nil {
5247 panic("internal error: should have a body in this state")
5248 }
5249
5250
5251 if st.declBodyBytes != -1 && st.bodyBytes+int64(len(data)) > st.declBodyBytes {
5252 st.body.CloseWithError(fmt.Errorf("sender tried to send more than declared Content-Length of %d bytes", st.declBodyBytes))
5253
5254
5255
5256 return http2streamError(id, http2ErrCodeProtocol)
5257 }
5258 if f.Length > 0 {
5259
5260 if st.inflow.available() < int32(f.Length) {
5261 return http2streamError(id, http2ErrCodeFlowControl)
5262 }
5263 st.inflow.take(int32(f.Length))
5264
5265 if len(data) > 0 {
5266 wrote, err := st.body.Write(data)
5267 if err != nil {
5268 return http2streamError(id, http2ErrCodeStreamClosed)
5269 }
5270 if wrote != len(data) {
5271 panic("internal error: bad Writer")
5272 }
5273 st.bodyBytes += int64(len(data))
5274 }
5275
5276
5277
5278 if pad := int32(f.Length) - int32(len(data)); pad > 0 {
5279 sc.sendWindowUpdate32(nil, pad)
5280 sc.sendWindowUpdate32(st, pad)
5281 }
5282 }
5283 if f.StreamEnded() {
5284 st.endStream()
5285 }
5286 return nil
5287 }
5288
5289 func (sc *http2serverConn) processGoAway(f *http2GoAwayFrame) error {
5290 sc.serveG.check()
5291 if f.ErrCode != http2ErrCodeNo {
5292 sc.logf("http2: received GOAWAY %+v, starting graceful shutdown", f)
5293 } else {
5294 sc.vlogf("http2: received GOAWAY %+v, starting graceful shutdown", f)
5295 }
5296 sc.startGracefulShutdownInternal()
5297
5298
5299 sc.pushEnabled = false
5300 return nil
5301 }
5302
5303
5304 func (st *http2stream) isPushed() bool {
5305 return st.id%2 == 0
5306 }
5307
5308
5309
5310 func (st *http2stream) endStream() {
5311 sc := st.sc
5312 sc.serveG.check()
5313
5314 if st.declBodyBytes != -1 && st.declBodyBytes != st.bodyBytes {
5315 st.body.CloseWithError(fmt.Errorf("request declared a Content-Length of %d but only wrote %d bytes",
5316 st.declBodyBytes, st.bodyBytes))
5317 } else {
5318 st.body.closeWithErrorAndCode(io.EOF, st.copyTrailersToHandlerRequest)
5319 st.body.CloseWithError(io.EOF)
5320 }
5321 st.state = http2stateHalfClosedRemote
5322 }
5323
5324
5325
5326 func (st *http2stream) copyTrailersToHandlerRequest() {
5327 for k, vv := range st.trailer {
5328 if _, ok := st.reqTrailer[k]; ok {
5329
5330 st.reqTrailer[k] = vv
5331 }
5332 }
5333 }
5334
5335
5336
5337 func (st *http2stream) onWriteTimeout() {
5338 st.sc.writeFrameFromHandler(http2FrameWriteRequest{write: http2streamError(st.id, http2ErrCodeInternal)})
5339 }
5340
5341 func (sc *http2serverConn) processHeaders(f *http2MetaHeadersFrame) error {
5342 sc.serveG.check()
5343 id := f.StreamID
5344 if sc.inGoAway {
5345
5346 return nil
5347 }
5348
5349
5350
5351
5352
5353 if id%2 != 1 {
5354 return http2ConnectionError(http2ErrCodeProtocol)
5355 }
5356
5357
5358
5359
5360 if st := sc.streams[f.StreamID]; st != nil {
5361 if st.resetQueued {
5362
5363
5364 return nil
5365 }
5366
5367
5368
5369
5370 if st.state == http2stateHalfClosedRemote {
5371 return http2streamError(id, http2ErrCodeStreamClosed)
5372 }
5373 return st.processTrailerHeaders(f)
5374 }
5375
5376
5377
5378
5379
5380
5381 if id <= sc.maxClientStreamID {
5382 return http2ConnectionError(http2ErrCodeProtocol)
5383 }
5384 sc.maxClientStreamID = id
5385
5386 if sc.idleTimer != nil {
5387 sc.idleTimer.Stop()
5388 }
5389
5390
5391
5392
5393
5394
5395
5396 if sc.curClientStreams+1 > sc.advMaxStreams {
5397 if sc.unackedSettings == 0 {
5398
5399 return http2streamError(id, http2ErrCodeProtocol)
5400 }
5401
5402
5403
5404
5405
5406 return http2streamError(id, http2ErrCodeRefusedStream)
5407 }
5408
5409 initialState := http2stateOpen
5410 if f.StreamEnded() {
5411 initialState = http2stateHalfClosedRemote
5412 }
5413 st := sc.newStream(id, 0, initialState)
5414
5415 if f.HasPriority() {
5416 if err := http2checkPriority(f.StreamID, f.Priority); err != nil {
5417 return err
5418 }
5419 sc.writeSched.AdjustStream(st.id, f.Priority)
5420 }
5421
5422 rw, req, err := sc.newWriterAndRequest(st, f)
5423 if err != nil {
5424 return err
5425 }
5426 st.reqTrailer = req.Trailer
5427 if st.reqTrailer != nil {
5428 st.trailer = make(Header)
5429 }
5430 st.body = req.Body.(*http2requestBody).pipe
5431 st.declBodyBytes = req.ContentLength
5432
5433 handler := sc.handler.ServeHTTP
5434 if f.Truncated {
5435
5436 handler = http2handleHeaderListTooLong
5437 } else if err := http2checkValidHTTP2RequestHeaders(req.Header); err != nil {
5438 handler = http2new400Handler(err)
5439 }
5440
5441
5442
5443
5444
5445
5446
5447
5448 if sc.hs.ReadTimeout != 0 {
5449 sc.conn.SetReadDeadline(time.Time{})
5450 }
5451
5452 go sc.runHandler(rw, req, handler)
5453 return nil
5454 }
5455
5456 func (st *http2stream) processTrailerHeaders(f *http2MetaHeadersFrame) error {
5457 sc := st.sc
5458 sc.serveG.check()
5459 if st.gotTrailerHeader {
5460 return http2ConnectionError(http2ErrCodeProtocol)
5461 }
5462 st.gotTrailerHeader = true
5463 if !f.StreamEnded() {
5464 return http2streamError(st.id, http2ErrCodeProtocol)
5465 }
5466
5467 if len(f.PseudoFields()) > 0 {
5468 return http2streamError(st.id, http2ErrCodeProtocol)
5469 }
5470 if st.trailer != nil {
5471 for _, hf := range f.RegularFields() {
5472 key := sc.canonicalHeader(hf.Name)
5473 if !httpguts.ValidTrailerHeader(key) {
5474
5475
5476
5477 return http2streamError(st.id, http2ErrCodeProtocol)
5478 }
5479 st.trailer[key] = append(st.trailer[key], hf.Value)
5480 }
5481 }
5482 st.endStream()
5483 return nil
5484 }
5485
5486 func http2checkPriority(streamID uint32, p http2PriorityParam) error {
5487 if streamID == p.StreamDep {
5488
5489
5490
5491
5492 return http2streamError(streamID, http2ErrCodeProtocol)
5493 }
5494 return nil
5495 }
5496
5497 func (sc *http2serverConn) processPriority(f *http2PriorityFrame) error {
5498 if sc.inGoAway {
5499 return nil
5500 }
5501 if err := http2checkPriority(f.StreamID, f.http2PriorityParam); err != nil {
5502 return err
5503 }
5504 sc.writeSched.AdjustStream(f.StreamID, f.http2PriorityParam)
5505 return nil
5506 }
5507
5508 func (sc *http2serverConn) newStream(id, pusherID uint32, state http2streamState) *http2stream {
5509 sc.serveG.check()
5510 if id == 0 {
5511 panic("internal error: cannot create stream with id 0")
5512 }
5513
5514 ctx, cancelCtx := context.WithCancel(sc.baseCtx)
5515 st := &http2stream{
5516 sc: sc,
5517 id: id,
5518 state: state,
5519 ctx: ctx,
5520 cancelCtx: cancelCtx,
5521 }
5522 st.cw.Init()
5523 st.flow.conn = &sc.flow
5524 st.flow.add(sc.initialStreamSendWindowSize)
5525 st.inflow.conn = &sc.inflow
5526 st.inflow.add(sc.srv.initialStreamRecvWindowSize())
5527 if sc.hs.WriteTimeout != 0 {
5528 st.writeDeadline = time.AfterFunc(sc.hs.WriteTimeout, st.onWriteTimeout)
5529 }
5530
5531 sc.streams[id] = st
5532 sc.writeSched.OpenStream(st.id, http2OpenStreamOptions{PusherID: pusherID})
5533 if st.isPushed() {
5534 sc.curPushedStreams++
5535 } else {
5536 sc.curClientStreams++
5537 }
5538 if sc.curOpenStreams() == 1 {
5539 sc.setConnState(StateActive)
5540 }
5541
5542 return st
5543 }
5544
5545 func (sc *http2serverConn) newWriterAndRequest(st *http2stream, f *http2MetaHeadersFrame) (*http2responseWriter, *Request, error) {
5546 sc.serveG.check()
5547
5548 rp := http2requestParam{
5549 method: f.PseudoValue("method"),
5550 scheme: f.PseudoValue("scheme"),
5551 authority: f.PseudoValue("authority"),
5552 path: f.PseudoValue("path"),
5553 }
5554
5555 isConnect := rp.method == "CONNECT"
5556 if isConnect {
5557 if rp.path != "" || rp.scheme != "" || rp.authority == "" {
5558 return nil, nil, http2streamError(f.StreamID, http2ErrCodeProtocol)
5559 }
5560 } else if rp.method == "" || rp.path == "" || (rp.scheme != "https" && rp.scheme != "http") {
5561
5562
5563
5564
5565
5566
5567
5568
5569
5570
5571 return nil, nil, http2streamError(f.StreamID, http2ErrCodeProtocol)
5572 }
5573
5574 bodyOpen := !f.StreamEnded()
5575 if rp.method == "HEAD" && bodyOpen {
5576
5577 return nil, nil, http2streamError(f.StreamID, http2ErrCodeProtocol)
5578 }
5579
5580 rp.header = make(Header)
5581 for _, hf := range f.RegularFields() {
5582 rp.header.Add(sc.canonicalHeader(hf.Name), hf.Value)
5583 }
5584 if rp.authority == "" {
5585 rp.authority = rp.header.Get("Host")
5586 }
5587
5588 rw, req, err := sc.newWriterAndRequestNoBody(st, rp)
5589 if err != nil {
5590 return nil, nil, err
5591 }
5592 if bodyOpen {
5593 if vv, ok := rp.header["Content-Length"]; ok {
5594 req.ContentLength, _ = strconv.ParseInt(vv[0], 10, 64)
5595 } else {
5596 req.ContentLength = -1
5597 }
5598 req.Body.(*http2requestBody).pipe = &http2pipe{
5599 b: &http2dataBuffer{expected: req.ContentLength},
5600 }
5601 }
5602 return rw, req, nil
5603 }
5604
5605 type http2requestParam struct {
5606 method string
5607 scheme, authority, path string
5608 header Header
5609 }
5610
5611 func (sc *http2serverConn) newWriterAndRequestNoBody(st *http2stream, rp http2requestParam) (*http2responseWriter, *Request, error) {
5612 sc.serveG.check()
5613
5614 var tlsState *tls.ConnectionState
5615 if rp.scheme == "https" {
5616 tlsState = sc.tlsState
5617 }
5618
5619 needsContinue := rp.header.Get("Expect") == "100-continue"
5620 if needsContinue {
5621 rp.header.Del("Expect")
5622 }
5623
5624 if cookies := rp.header["Cookie"]; len(cookies) > 1 {
5625 rp.header.Set("Cookie", strings.Join(cookies, "; "))
5626 }
5627
5628
5629 var trailer Header
5630 for _, v := range rp.header["Trailer"] {
5631 for _, key := range strings.Split(v, ",") {
5632 key = CanonicalHeaderKey(strings.TrimSpace(key))
5633 switch key {
5634 case "Transfer-Encoding", "Trailer", "Content-Length":
5635
5636
5637 default:
5638 if trailer == nil {
5639 trailer = make(Header)
5640 }
5641 trailer[key] = nil
5642 }
5643 }
5644 }
5645 delete(rp.header, "Trailer")
5646
5647 var url_ *url.URL
5648 var requestURI string
5649 if rp.method == "CONNECT" {
5650 url_ = &url.URL{Host: rp.authority}
5651 requestURI = rp.authority
5652 } else {
5653 var err error
5654 url_, err = url.ParseRequestURI(rp.path)
5655 if err != nil {
5656 return nil, nil, http2streamError(st.id, http2ErrCodeProtocol)
5657 }
5658 requestURI = rp.path
5659 }
5660
5661 body := &http2requestBody{
5662 conn: sc,
5663 stream: st,
5664 needsContinue: needsContinue,
5665 }
5666 req := &Request{
5667 Method: rp.method,
5668 URL: url_,
5669 RemoteAddr: sc.remoteAddrStr,
5670 Header: rp.header,
5671 RequestURI: requestURI,
5672 Proto: "HTTP/2.0",
5673 ProtoMajor: 2,
5674 ProtoMinor: 0,
5675 TLS: tlsState,
5676 Host: rp.authority,
5677 Body: body,
5678 Trailer: trailer,
5679 }
5680 req = req.WithContext(st.ctx)
5681
5682 rws := http2responseWriterStatePool.Get().(*http2responseWriterState)
5683 bwSave := rws.bw
5684 *rws = http2responseWriterState{}
5685 rws.conn = sc
5686 rws.bw = bwSave
5687 rws.bw.Reset(http2chunkWriter{rws})
5688 rws.stream = st
5689 rws.req = req
5690 rws.body = body
5691
5692 rw := &http2responseWriter{rws: rws}
5693 return rw, req, nil
5694 }
5695
5696
5697 func (sc *http2serverConn) runHandler(rw *http2responseWriter, req *Request, handler func(ResponseWriter, *Request)) {
5698 didPanic := true
5699 defer func() {
5700 rw.rws.stream.cancelCtx()
5701 if didPanic {
5702 e := recover()
5703 sc.writeFrameFromHandler(http2FrameWriteRequest{
5704 write: http2handlerPanicRST{rw.rws.stream.id},
5705 stream: rw.rws.stream,
5706 })
5707
5708 if e != nil && e != ErrAbortHandler {
5709 const size = 64 << 10
5710 buf := make([]byte, size)
5711 buf = buf[:runtime.Stack(buf, false)]
5712 sc.logf("http2: panic serving %v: %v\n%s", sc.conn.RemoteAddr(), e, buf)
5713 }
5714 return
5715 }
5716 rw.handlerDone()
5717 }()
5718 handler(rw, req)
5719 didPanic = false
5720 }
5721
5722 func http2handleHeaderListTooLong(w ResponseWriter, r *Request) {
5723
5724
5725
5726
5727 const statusRequestHeaderFieldsTooLarge = 431
5728 w.WriteHeader(statusRequestHeaderFieldsTooLarge)
5729 io.WriteString(w, "<h1>HTTP Error 431</h1><p>Request Header Field(s) Too Large</p>")
5730 }
5731
5732
5733
5734 func (sc *http2serverConn) writeHeaders(st *http2stream, headerData *http2writeResHeaders) error {
5735 sc.serveG.checkNotOn()
5736 var errc chan error
5737 if headerData.h != nil {
5738
5739
5740
5741
5742 errc = http2errChanPool.Get().(chan error)
5743 }
5744 if err := sc.writeFrameFromHandler(http2FrameWriteRequest{
5745 write: headerData,
5746 stream: st,
5747 done: errc,
5748 }); err != nil {
5749 return err
5750 }
5751 if errc != nil {
5752 select {
5753 case err := <-errc:
5754 http2errChanPool.Put(errc)
5755 return err
5756 case <-sc.doneServing:
5757 return http2errClientDisconnected
5758 case <-st.cw:
5759 return http2errStreamClosed
5760 }
5761 }
5762 return nil
5763 }
5764
5765
5766 func (sc *http2serverConn) write100ContinueHeaders(st *http2stream) {
5767 sc.writeFrameFromHandler(http2FrameWriteRequest{
5768 write: http2write100ContinueHeadersFrame{st.id},
5769 stream: st,
5770 })
5771 }
5772
5773
5774
5775 type http2bodyReadMsg struct {
5776 st *http2stream
5777 n int
5778 }
5779
5780
5781
5782
5783 func (sc *http2serverConn) noteBodyReadFromHandler(st *http2stream, n int, err error) {
5784 sc.serveG.checkNotOn()
5785 if n > 0 {
5786 select {
5787 case sc.bodyReadCh <- http2bodyReadMsg{st, n}:
5788 case <-sc.doneServing:
5789 }
5790 }
5791 }
5792
5793 func (sc *http2serverConn) noteBodyRead(st *http2stream, n int) {
5794 sc.serveG.check()
5795 sc.sendWindowUpdate(nil, n)
5796 if st.state != http2stateHalfClosedRemote && st.state != http2stateClosed {
5797
5798
5799 sc.sendWindowUpdate(st, n)
5800 }
5801 }
5802
5803
5804 func (sc *http2serverConn) sendWindowUpdate(st *http2stream, n int) {
5805 sc.serveG.check()
5806
5807
5808
5809
5810
5811 const maxUint31 = 1<<31 - 1
5812 for n >= maxUint31 {
5813 sc.sendWindowUpdate32(st, maxUint31)
5814 n -= maxUint31
5815 }
5816 sc.sendWindowUpdate32(st, int32(n))
5817 }
5818
5819
5820 func (sc *http2serverConn) sendWindowUpdate32(st *http2stream, n int32) {
5821 sc.serveG.check()
5822 if n == 0 {
5823 return
5824 }
5825 if n < 0 {
5826 panic("negative update")
5827 }
5828 var streamID uint32
5829 if st != nil {
5830 streamID = st.id
5831 }
5832 sc.writeFrame(http2FrameWriteRequest{
5833 write: http2writeWindowUpdate{streamID: streamID, n: uint32(n)},
5834 stream: st,
5835 })
5836 var ok bool
5837 if st == nil {
5838 ok = sc.inflow.add(n)
5839 } else {
5840 ok = st.inflow.add(n)
5841 }
5842 if !ok {
5843 panic("internal error; sent too many window updates without decrements?")
5844 }
5845 }
5846
5847
5848
5849 type http2requestBody struct {
5850 _ http2incomparable
5851 stream *http2stream
5852 conn *http2serverConn
5853 closed bool
5854 sawEOF bool
5855 pipe *http2pipe
5856 needsContinue bool
5857 }
5858
5859 func (b *http2requestBody) Close() error {
5860 if b.pipe != nil && !b.closed {
5861 b.pipe.BreakWithError(http2errClosedBody)
5862 }
5863 b.closed = true
5864 return nil
5865 }
5866
5867 func (b *http2requestBody) Read(p []byte) (n int, err error) {
5868 if b.needsContinue {
5869 b.needsContinue = false
5870 b.conn.write100ContinueHeaders(b.stream)
5871 }
5872 if b.pipe == nil || b.sawEOF {
5873 return 0, io.EOF
5874 }
5875 n, err = b.pipe.Read(p)
5876 if err == io.EOF {
5877 b.sawEOF = true
5878 }
5879 if b.conn == nil && http2inTests {
5880 return
5881 }
5882 b.conn.noteBodyReadFromHandler(b.stream, n, err)
5883 return
5884 }
5885
5886
5887
5888
5889
5890
5891
5892 type http2responseWriter struct {
5893 rws *http2responseWriterState
5894 }
5895
5896
5897 var (
5898 _ CloseNotifier = (*http2responseWriter)(nil)
5899 _ Flusher = (*http2responseWriter)(nil)
5900 _ http2stringWriter = (*http2responseWriter)(nil)
5901 )
5902
5903 type http2responseWriterState struct {
5904
5905 stream *http2stream
5906 req *Request
5907 body *http2requestBody
5908 conn *http2serverConn
5909
5910
5911 bw *bufio.Writer
5912
5913
5914 handlerHeader Header
5915 snapHeader Header
5916 trailers []string
5917 status int
5918 wroteHeader bool
5919 sentHeader bool
5920 handlerDone bool
5921 dirty bool
5922
5923 sentContentLen int64
5924 wroteBytes int64
5925
5926 closeNotifierMu sync.Mutex
5927 closeNotifierCh chan bool
5928 }
5929
5930 type http2chunkWriter struct{ rws *http2responseWriterState }
5931
5932 func (cw http2chunkWriter) Write(p []byte) (n int, err error) { return cw.rws.writeChunk(p) }
5933
5934 func (rws *http2responseWriterState) hasTrailers() bool { return len(rws.trailers) > 0 }
5935
5936 func (rws *http2responseWriterState) hasNonemptyTrailers() bool {
5937 for _, trailer := range rws.trailers {
5938 if _, ok := rws.handlerHeader[trailer]; ok {
5939 return true
5940 }
5941 }
5942 return false
5943 }
5944
5945
5946
5947
5948 func (rws *http2responseWriterState) declareTrailer(k string) {
5949 k = CanonicalHeaderKey(k)
5950 if !httpguts.ValidTrailerHeader(k) {
5951
5952 rws.conn.logf("ignoring invalid trailer %q", k)
5953 return
5954 }
5955 if !http2strSliceContains(rws.trailers, k) {
5956 rws.trailers = append(rws.trailers, k)
5957 }
5958 }
5959
5960
5961
5962
5963
5964
5965
5966 func (rws *http2responseWriterState) writeChunk(p []byte) (n int, err error) {
5967 if !rws.wroteHeader {
5968 rws.writeHeader(200)
5969 }
5970
5971 isHeadResp := rws.req.Method == "HEAD"
5972 if !rws.sentHeader {
5973 rws.sentHeader = true
5974 var ctype, clen string
5975 if clen = rws.snapHeader.Get("Content-Length"); clen != "" {
5976 rws.snapHeader.Del("Content-Length")
5977 clen64, err := strconv.ParseInt(clen, 10, 64)
5978 if err == nil && clen64 >= 0 {
5979 rws.sentContentLen = clen64
5980 } else {
5981 clen = ""
5982 }
5983 }
5984 if clen == "" && rws.handlerDone && http2bodyAllowedForStatus(rws.status) && (len(p) > 0 || !isHeadResp) {
5985 clen = strconv.Itoa(len(p))
5986 }
5987 _, hasContentType := rws.snapHeader["Content-Type"]
5988
5989
5990 ce := rws.snapHeader.Get("Content-Encoding")
5991 hasCE := len(ce) > 0
5992 if !hasCE && !hasContentType && http2bodyAllowedForStatus(rws.status) && len(p) > 0 {
5993 ctype = DetectContentType(p)
5994 }
5995 var date string
5996 if _, ok := rws.snapHeader["Date"]; !ok {
5997
5998 date = time.Now().UTC().Format(TimeFormat)
5999 }
6000
6001 for _, v := range rws.snapHeader["Trailer"] {
6002 http2foreachHeaderElement(v, rws.declareTrailer)
6003 }
6004
6005
6006
6007
6008
6009
6010 if _, ok := rws.snapHeader["Connection"]; ok {
6011 v := rws.snapHeader.Get("Connection")
6012 delete(rws.snapHeader, "Connection")
6013 if v == "close" {
6014 rws.conn.startGracefulShutdown()
6015 }
6016 }
6017
6018 endStream := (rws.handlerDone && !rws.hasTrailers() && len(p) == 0) || isHeadResp
6019 err = rws.conn.writeHeaders(rws.stream, &http2writeResHeaders{
6020 streamID: rws.stream.id,
6021 httpResCode: rws.status,
6022 h: rws.snapHeader,
6023 endStream: endStream,
6024 contentType: ctype,
6025 contentLength: clen,
6026 date: date,
6027 })
6028 if err != nil {
6029 rws.dirty = true
6030 return 0, err
6031 }
6032 if endStream {
6033 return 0, nil
6034 }
6035 }
6036 if isHeadResp {
6037 return len(p), nil
6038 }
6039 if len(p) == 0 && !rws.handlerDone {
6040 return 0, nil
6041 }
6042
6043 if rws.handlerDone {
6044 rws.promoteUndeclaredTrailers()
6045 }
6046
6047
6048
6049 hasNonemptyTrailers := rws.hasNonemptyTrailers()
6050 endStream := rws.handlerDone && !hasNonemptyTrailers
6051 if len(p) > 0 || endStream {
6052
6053 if err := rws.conn.writeDataFromHandler(rws.stream, p, endStream); err != nil {
6054 rws.dirty = true
6055 return 0, err
6056 }
6057 }
6058
6059 if rws.handlerDone && hasNonemptyTrailers {
6060 err = rws.conn.writeHeaders(rws.stream, &http2writeResHeaders{
6061 streamID: rws.stream.id,
6062 h: rws.handlerHeader,
6063 trailers: rws.trailers,
6064 endStream: true,
6065 })
6066 if err != nil {
6067 rws.dirty = true
6068 }
6069 return len(p), err
6070 }
6071 return len(p), nil
6072 }
6073
6074
6075
6076
6077
6078
6079
6080
6081
6082
6083
6084
6085
6086 const http2TrailerPrefix = "Trailer:"
6087
6088
6089
6090
6091
6092
6093
6094
6095
6096
6097
6098
6099
6100
6101
6102
6103
6104
6105
6106
6107
6108
6109 func (rws *http2responseWriterState) promoteUndeclaredTrailers() {
6110 for k, vv := range rws.handlerHeader {
6111 if !strings.HasPrefix(k, http2TrailerPrefix) {
6112 continue
6113 }
6114 trailerKey := strings.TrimPrefix(k, http2TrailerPrefix)
6115 rws.declareTrailer(trailerKey)
6116 rws.handlerHeader[CanonicalHeaderKey(trailerKey)] = vv
6117 }
6118
6119 if len(rws.trailers) > 1 {
6120 sorter := http2sorterPool.Get().(*http2sorter)
6121 sorter.SortStrings(rws.trailers)
6122 http2sorterPool.Put(sorter)
6123 }
6124 }
6125
6126 func (w *http2responseWriter) Flush() {
6127 rws := w.rws
6128 if rws == nil {
6129 panic("Header called after Handler finished")
6130 }
6131 if rws.bw.Buffered() > 0 {
6132 if err := rws.bw.Flush(); err != nil {
6133
6134 return
6135 }
6136 } else {
6137
6138
6139
6140
6141 rws.writeChunk(nil)
6142 }
6143 }
6144
6145 func (w *http2responseWriter) CloseNotify() <-chan bool {
6146 rws := w.rws
6147 if rws == nil {
6148 panic("CloseNotify called after Handler finished")
6149 }
6150 rws.closeNotifierMu.Lock()
6151 ch := rws.closeNotifierCh
6152 if ch == nil {
6153 ch = make(chan bool, 1)
6154 rws.closeNotifierCh = ch
6155 cw := rws.stream.cw
6156 go func() {
6157 cw.Wait()
6158 ch <- true
6159 }()
6160 }
6161 rws.closeNotifierMu.Unlock()
6162 return ch
6163 }
6164
6165 func (w *http2responseWriter) Header() Header {
6166 rws := w.rws
6167 if rws == nil {
6168 panic("Header called after Handler finished")
6169 }
6170 if rws.handlerHeader == nil {
6171 rws.handlerHeader = make(Header)
6172 }
6173 return rws.handlerHeader
6174 }
6175
6176
6177 func http2checkWriteHeaderCode(code int) {
6178
6179
6180
6181
6182
6183
6184
6185
6186
6187
6188
6189 if code < 100 || code > 999 {
6190 panic(fmt.Sprintf("invalid WriteHeader code %v", code))
6191 }
6192 }
6193
6194 func (w *http2responseWriter) WriteHeader(code int) {
6195 rws := w.rws
6196 if rws == nil {
6197 panic("WriteHeader called after Handler finished")
6198 }
6199 rws.writeHeader(code)
6200 }
6201
6202 func (rws *http2responseWriterState) writeHeader(code int) {
6203 if !rws.wroteHeader {
6204 http2checkWriteHeaderCode(code)
6205 rws.wroteHeader = true
6206 rws.status = code
6207 if len(rws.handlerHeader) > 0 {
6208 rws.snapHeader = http2cloneHeader(rws.handlerHeader)
6209 }
6210 }
6211 }
6212
6213 func http2cloneHeader(h Header) Header {
6214 h2 := make(Header, len(h))
6215 for k, vv := range h {
6216 vv2 := make([]string, len(vv))
6217 copy(vv2, vv)
6218 h2[k] = vv2
6219 }
6220 return h2
6221 }
6222
6223
6224
6225
6226
6227
6228
6229
6230
6231 func (w *http2responseWriter) Write(p []byte) (n int, err error) {
6232 return w.write(len(p), p, "")
6233 }
6234
6235 func (w *http2responseWriter) WriteString(s string) (n int, err error) {
6236 return w.write(len(s), nil, s)
6237 }
6238
6239
6240 func (w *http2responseWriter) write(lenData int, dataB []byte, dataS string) (n int, err error) {
6241 rws := w.rws
6242 if rws == nil {
6243 panic("Write called after Handler finished")
6244 }
6245 if !rws.wroteHeader {
6246 w.WriteHeader(200)
6247 }
6248 if !http2bodyAllowedForStatus(rws.status) {
6249 return 0, ErrBodyNotAllowed
6250 }
6251 rws.wroteBytes += int64(len(dataB)) + int64(len(dataS))
6252 if rws.sentContentLen != 0 && rws.wroteBytes > rws.sentContentLen {
6253
6254 return 0, errors.New("http2: handler wrote more than declared Content-Length")
6255 }
6256
6257 if dataB != nil {
6258 return rws.bw.Write(dataB)
6259 } else {
6260 return rws.bw.WriteString(dataS)
6261 }
6262 }
6263
6264 func (w *http2responseWriter) handlerDone() {
6265 rws := w.rws
6266 dirty := rws.dirty
6267 rws.handlerDone = true
6268 w.Flush()
6269 w.rws = nil
6270 if !dirty {
6271
6272
6273
6274
6275
6276
6277 http2responseWriterStatePool.Put(rws)
6278 }
6279 }
6280
6281
6282 var (
6283 http2ErrRecursivePush = errors.New("http2: recursive push not allowed")
6284 http2ErrPushLimitReached = errors.New("http2: push would exceed peer's SETTINGS_MAX_CONCURRENT_STREAMS")
6285 )
6286
6287 var _ Pusher = (*http2responseWriter)(nil)
6288
6289 func (w *http2responseWriter) Push(target string, opts *PushOptions) error {
6290 st := w.rws.stream
6291 sc := st.sc
6292 sc.serveG.checkNotOn()
6293
6294
6295
6296 if st.isPushed() {
6297 return http2ErrRecursivePush
6298 }
6299
6300 if opts == nil {
6301 opts = new(PushOptions)
6302 }
6303
6304
6305 if opts.Method == "" {
6306 opts.Method = "GET"
6307 }
6308 if opts.Header == nil {
6309 opts.Header = Header{}
6310 }
6311 wantScheme := "http"
6312 if w.rws.req.TLS != nil {
6313 wantScheme = "https"
6314 }
6315
6316
6317 u, err := url.Parse(target)
6318 if err != nil {
6319 return err
6320 }
6321 if u.Scheme == "" {
6322 if !strings.HasPrefix(target, "/") {
6323 return fmt.Errorf("target must be an absolute URL or an absolute path: %q", target)
6324 }
6325 u.Scheme = wantScheme
6326 u.Host = w.rws.req.Host
6327 } else {
6328 if u.Scheme != wantScheme {
6329 return fmt.Errorf("cannot push URL with scheme %q from request with scheme %q", u.Scheme, wantScheme)
6330 }
6331 if u.Host == "" {
6332 return errors.New("URL must have a host")
6333 }
6334 }
6335 for k := range opts.Header {
6336 if strings.HasPrefix(k, ":") {
6337 return fmt.Errorf("promised request headers cannot include pseudo header %q", k)
6338 }
6339
6340
6341
6342
6343 switch strings.ToLower(k) {
6344 case "content-length", "content-encoding", "trailer", "te", "expect", "host":
6345 return fmt.Errorf("promised request headers cannot include %q", k)
6346 }
6347 }
6348 if err := http2checkValidHTTP2RequestHeaders(opts.Header); err != nil {
6349 return err
6350 }
6351
6352
6353
6354
6355 if opts.Method != "GET" && opts.Method != "HEAD" {
6356 return fmt.Errorf("method %q must be GET or HEAD", opts.Method)
6357 }
6358
6359 msg := &http2startPushRequest{
6360 parent: st,
6361 method: opts.Method,
6362 url: u,
6363 header: http2cloneHeader(opts.Header),
6364 done: http2errChanPool.Get().(chan error),
6365 }
6366
6367 select {
6368 case <-sc.doneServing:
6369 return http2errClientDisconnected
6370 case <-st.cw:
6371 return http2errStreamClosed
6372 case sc.serveMsgCh <- msg:
6373 }
6374
6375 select {
6376 case <-sc.doneServing:
6377 return http2errClientDisconnected
6378 case <-st.cw:
6379 return http2errStreamClosed
6380 case err := <-msg.done:
6381 http2errChanPool.Put(msg.done)
6382 return err
6383 }
6384 }
6385
6386 type http2startPushRequest struct {
6387 parent *http2stream
6388 method string
6389 url *url.URL
6390 header Header
6391 done chan error
6392 }
6393
6394 func (sc *http2serverConn) startPush(msg *http2startPushRequest) {
6395 sc.serveG.check()
6396
6397
6398
6399
6400 if msg.parent.state != http2stateOpen && msg.parent.state != http2stateHalfClosedRemote {
6401
6402 msg.done <- http2errStreamClosed
6403 return
6404 }
6405
6406
6407 if !sc.pushEnabled {
6408 msg.done <- ErrNotSupported
6409 return
6410 }
6411
6412
6413
6414
6415 allocatePromisedID := func() (uint32, error) {
6416 sc.serveG.check()
6417
6418
6419
6420 if !sc.pushEnabled {
6421 return 0, ErrNotSupported
6422 }
6423
6424 if sc.curPushedStreams+1 > sc.clientMaxStreams {
6425 return 0, http2ErrPushLimitReached
6426 }
6427
6428
6429
6430
6431
6432 if sc.maxPushPromiseID+2 >= 1<<31 {
6433 sc.startGracefulShutdownInternal()
6434 return 0, http2ErrPushLimitReached
6435 }
6436 sc.maxPushPromiseID += 2
6437 promisedID := sc.maxPushPromiseID
6438
6439
6440
6441
6442
6443
6444 promised := sc.newStream(promisedID, msg.parent.id, http2stateHalfClosedRemote)
6445 rw, req, err := sc.newWriterAndRequestNoBody(promised, http2requestParam{
6446 method: msg.method,
6447 scheme: msg.url.Scheme,
6448 authority: msg.url.Host,
6449 path: msg.url.RequestURI(),
6450 header: http2cloneHeader(msg.header),
6451 })
6452 if err != nil {
6453
6454 panic(fmt.Sprintf("newWriterAndRequestNoBody(%+v): %v", msg.url, err))
6455 }
6456
6457 go sc.runHandler(rw, req, sc.handler.ServeHTTP)
6458 return promisedID, nil
6459 }
6460
6461 sc.writeFrame(http2FrameWriteRequest{
6462 write: &http2writePushPromise{
6463 streamID: msg.parent.id,
6464 method: msg.method,
6465 url: msg.url,
6466 h: msg.header,
6467 allocatePromisedID: allocatePromisedID,
6468 },
6469 stream: msg.parent,
6470 done: msg.done,
6471 })
6472 }
6473
6474
6475
6476 func http2foreachHeaderElement(v string, fn func(string)) {
6477 v = textproto.TrimString(v)
6478 if v == "" {
6479 return
6480 }
6481 if !strings.Contains(v, ",") {
6482 fn(v)
6483 return
6484 }
6485 for _, f := range strings.Split(v, ",") {
6486 if f = textproto.TrimString(f); f != "" {
6487 fn(f)
6488 }
6489 }
6490 }
6491
6492
6493 var http2connHeaders = []string{
6494 "Connection",
6495 "Keep-Alive",
6496 "Proxy-Connection",
6497 "Transfer-Encoding",
6498 "Upgrade",
6499 }
6500
6501
6502
6503
6504 func http2checkValidHTTP2RequestHeaders(h Header) error {
6505 for _, k := range http2connHeaders {
6506 if _, ok := h[k]; ok {
6507 return fmt.Errorf("request header %q is not valid in HTTP/2", k)
6508 }
6509 }
6510 te := h["Te"]
6511 if len(te) > 0 && (len(te) > 1 || (te[0] != "trailers" && te[0] != "")) {
6512 return errors.New(`request header "TE" may only be "trailers" in HTTP/2`)
6513 }
6514 return nil
6515 }
6516
6517 func http2new400Handler(err error) HandlerFunc {
6518 return func(w ResponseWriter, r *Request) {
6519 Error(w, err.Error(), StatusBadRequest)
6520 }
6521 }
6522
6523
6524
6525
6526 func http2h1ServerKeepAlivesDisabled(hs *Server) bool {
6527 var x interface{} = hs
6528 type I interface {
6529 doKeepAlives() bool
6530 }
6531 if hs, ok := x.(I); ok {
6532 return !hs.doKeepAlives()
6533 }
6534 return false
6535 }
6536
6537 const (
6538
6539
6540 http2transportDefaultConnFlow = 1 << 30
6541
6542
6543
6544
6545 http2transportDefaultStreamFlow = 4 << 20
6546
6547
6548
6549 http2transportDefaultStreamMinRefresh = 4 << 10
6550
6551 http2defaultUserAgent = "Go-http-client/2.0"
6552 )
6553
6554
6555
6556
6557
6558 type http2Transport struct {
6559
6560
6561
6562
6563
6564
6565
6566 DialTLS func(network, addr string, cfg *tls.Config) (net.Conn, error)
6567
6568
6569
6570 TLSClientConfig *tls.Config
6571
6572
6573
6574 ConnPool http2ClientConnPool
6575
6576
6577
6578
6579
6580
6581
6582
6583
6584 DisableCompression bool
6585
6586
6587
6588 AllowHTTP bool
6589
6590
6591
6592
6593
6594
6595
6596
6597 MaxHeaderListSize uint32
6598
6599
6600
6601
6602
6603
6604
6605
6606
6607 StrictMaxConcurrentStreams bool
6608
6609
6610
6611
6612 t1 *Transport
6613
6614 connPoolOnce sync.Once
6615 connPoolOrDef http2ClientConnPool
6616 }
6617
6618 func (t *http2Transport) maxHeaderListSize() uint32 {
6619 if t.MaxHeaderListSize == 0 {
6620 return 10 << 20
6621 }
6622 if t.MaxHeaderListSize == 0xffffffff {
6623 return 0
6624 }
6625 return t.MaxHeaderListSize
6626 }
6627
6628 func (t *http2Transport) disableCompression() bool {
6629 return t.DisableCompression || (t.t1 != nil && t.t1.DisableCompression)
6630 }
6631
6632
6633
6634 func http2ConfigureTransport(t1 *Transport) error {
6635 _, err := http2configureTransport(t1)
6636 return err
6637 }
6638
6639 func http2configureTransport(t1 *Transport) (*http2Transport, error) {
6640 connPool := new(http2clientConnPool)
6641 t2 := &http2Transport{
6642 ConnPool: http2noDialClientConnPool{connPool},
6643 t1: t1,
6644 }
6645 connPool.t = t2
6646 if err := http2registerHTTPSProtocol(t1, http2noDialH2RoundTripper{t2}); err != nil {
6647 return nil, err
6648 }
6649 if t1.TLSClientConfig == nil {
6650 t1.TLSClientConfig = new(tls.Config)
6651 }
6652 if !http2strSliceContains(t1.TLSClientConfig.NextProtos, "h2") {
6653 t1.TLSClientConfig.NextProtos = append([]string{"h2"}, t1.TLSClientConfig.NextProtos...)
6654 }
6655 if !http2strSliceContains(t1.TLSClientConfig.NextProtos, "http/1.1") {
6656 t1.TLSClientConfig.NextProtos = append(t1.TLSClientConfig.NextProtos, "http/1.1")
6657 }
6658 upgradeFn := func(authority string, c *tls.Conn) RoundTripper {
6659 addr := http2authorityAddr("https", authority)
6660 if used, err := connPool.addConnIfNeeded(addr, t2, c); err != nil {
6661 go c.Close()
6662 return http2erringRoundTripper{err}
6663 } else if !used {
6664
6665
6666
6667
6668 go c.Close()
6669 }
6670 return t2
6671 }
6672 if m := t1.TLSNextProto; len(m) == 0 {
6673 t1.TLSNextProto = map[string]func(string, *tls.Conn) RoundTripper{
6674 "h2": upgradeFn,
6675 }
6676 } else {
6677 m["h2"] = upgradeFn
6678 }
6679 return t2, nil
6680 }
6681
6682 func (t *http2Transport) connPool() http2ClientConnPool {
6683 t.connPoolOnce.Do(t.initConnPool)
6684 return t.connPoolOrDef
6685 }
6686
6687 func (t *http2Transport) initConnPool() {
6688 if t.ConnPool != nil {
6689 t.connPoolOrDef = t.ConnPool
6690 } else {
6691 t.connPoolOrDef = &http2clientConnPool{t: t}
6692 }
6693 }
6694
6695
6696
6697 type http2ClientConn struct {
6698 t *http2Transport
6699 tconn net.Conn
6700 tlsState *tls.ConnectionState
6701 reused uint32
6702 singleUse bool
6703
6704
6705 readerDone chan struct{}
6706 readerErr error
6707
6708 idleTimeout time.Duration
6709 idleTimer *time.Timer
6710
6711 mu sync.Mutex
6712 cond *sync.Cond
6713 flow http2flow
6714 inflow http2flow
6715 closing bool
6716 closed bool
6717 wantSettingsAck bool
6718 goAway *http2GoAwayFrame
6719 goAwayDebug string
6720 streams map[uint32]*http2clientStream
6721 nextStreamID uint32
6722 pendingRequests int
6723 pings map[[8]byte]chan struct{}
6724 bw *bufio.Writer
6725 br *bufio.Reader
6726 fr *http2Framer
6727 lastActive time.Time
6728 lastIdle time.Time
6729
6730 maxFrameSize uint32
6731 maxConcurrentStreams uint32
6732 peerMaxHeaderListSize uint64
6733 initialWindowSize uint32
6734
6735 hbuf bytes.Buffer
6736 henc *hpack.Encoder
6737 freeBuf [][]byte
6738
6739 wmu sync.Mutex
6740 werr error
6741 }
6742
6743
6744
6745 type http2clientStream struct {
6746 cc *http2ClientConn
6747 req *Request
6748 trace *httptrace.ClientTrace
6749 ID uint32
6750 resc chan http2resAndError
6751 bufPipe http2pipe
6752 startedWrite bool
6753 requestedGzip bool
6754 on100 func()
6755
6756 flow http2flow
6757 inflow http2flow
6758 bytesRemain int64
6759 readErr error
6760 stopReqBody error
6761 didReset bool
6762
6763 peerReset chan struct{}
6764 resetErr error
6765
6766 done chan struct{}
6767
6768
6769 firstByte bool
6770 pastHeaders bool
6771 pastTrailers bool
6772 num1xx uint8
6773
6774 trailer Header
6775 resTrailer *Header
6776 }
6777
6778
6779
6780
6781 func http2awaitRequestCancel(req *Request, done <-chan struct{}) error {
6782 ctx := req.Context()
6783 if req.Cancel == nil && ctx.Done() == nil {
6784 return nil
6785 }
6786 select {
6787 case <-req.Cancel:
6788 return http2errRequestCanceled
6789 case <-ctx.Done():
6790 return ctx.Err()
6791 case <-done:
6792 return nil
6793 }
6794 }
6795
6796 var http2got1xxFuncForTests func(int, textproto.MIMEHeader) error
6797
6798
6799
6800 func (cs *http2clientStream) get1xxTraceFunc() func(int, textproto.MIMEHeader) error {
6801 if fn := http2got1xxFuncForTests; fn != nil {
6802 return fn
6803 }
6804 return http2traceGot1xxResponseFunc(cs.trace)
6805 }
6806
6807
6808
6809
6810
6811 func (cs *http2clientStream) awaitRequestCancel(req *Request) {
6812 if err := http2awaitRequestCancel(req, cs.done); err != nil {
6813 cs.cancelStream()
6814 cs.bufPipe.CloseWithError(err)
6815 }
6816 }
6817
6818 func (cs *http2clientStream) cancelStream() {
6819 cc := cs.cc
6820 cc.mu.Lock()
6821 didReset := cs.didReset
6822 cs.didReset = true
6823 cc.mu.Unlock()
6824
6825 if !didReset {
6826 cc.writeStreamReset(cs.ID, http2ErrCodeCancel, nil)
6827 cc.forgetStreamID(cs.ID)
6828 }
6829 }
6830
6831
6832
6833 func (cs *http2clientStream) checkResetOrDone() error {
6834 select {
6835 case <-cs.peerReset:
6836 return cs.resetErr
6837 case <-cs.done:
6838 return http2errStreamClosed
6839 default:
6840 return nil
6841 }
6842 }
6843
6844 func (cs *http2clientStream) getStartedWrite() bool {
6845 cc := cs.cc
6846 cc.mu.Lock()
6847 defer cc.mu.Unlock()
6848 return cs.startedWrite
6849 }
6850
6851 func (cs *http2clientStream) abortRequestBodyWrite(err error) {
6852 if err == nil {
6853 panic("nil error")
6854 }
6855 cc := cs.cc
6856 cc.mu.Lock()
6857 cs.stopReqBody = err
6858 cc.cond.Broadcast()
6859 cc.mu.Unlock()
6860 }
6861
6862 type http2stickyErrWriter struct {
6863 w io.Writer
6864 err *error
6865 }
6866
6867 func (sew http2stickyErrWriter) Write(p []byte) (n int, err error) {
6868 if *sew.err != nil {
6869 return 0, *sew.err
6870 }
6871 n, err = sew.w.Write(p)
6872 *sew.err = err
6873 return
6874 }
6875
6876
6877
6878
6879
6880
6881
6882 type http2noCachedConnError struct{}
6883
6884 func (http2noCachedConnError) IsHTTP2NoCachedConnError() {}
6885
6886 func (http2noCachedConnError) Error() string { return "http2: no cached connection was available" }
6887
6888
6889
6890
6891 func http2isNoCachedConnError(err error) bool {
6892 _, ok := err.(interface{ IsHTTP2NoCachedConnError() })
6893 return ok
6894 }
6895
6896 var http2ErrNoCachedConn error = http2noCachedConnError{}
6897
6898
6899 type http2RoundTripOpt struct {
6900
6901
6902
6903
6904 OnlyCachedConn bool
6905 }
6906
6907 func (t *http2Transport) RoundTrip(req *Request) (*Response, error) {
6908 return t.RoundTripOpt(req, http2RoundTripOpt{})
6909 }
6910
6911
6912
6913 func http2authorityAddr(scheme string, authority string) (addr string) {
6914 host, port, err := net.SplitHostPort(authority)
6915 if err != nil {
6916 port = "443"
6917 if scheme == "http" {
6918 port = "80"
6919 }
6920 host = authority
6921 }
6922 if a, err := idna.ToASCII(host); err == nil {
6923 host = a
6924 }
6925
6926 if strings.HasPrefix(host, "[") && strings.HasSuffix(host, "]") {
6927 return host + ":" + port
6928 }
6929 return net.JoinHostPort(host, port)
6930 }
6931
6932
6933 func (t *http2Transport) RoundTripOpt(req *Request, opt http2RoundTripOpt) (*Response, error) {
6934 if !(req.URL.Scheme == "https" || (req.URL.Scheme == "http" && t.AllowHTTP)) {
6935 return nil, errors.New("http2: unsupported scheme")
6936 }
6937
6938 addr := http2authorityAddr(req.URL.Scheme, req.URL.Host)
6939 for retry := 0; ; retry++ {
6940 cc, err := t.connPool().GetClientConn(req, addr)
6941 if err != nil {
6942 t.vlogf("http2: Transport failed to get client conn for %s: %v", addr, err)
6943 return nil, err
6944 }
6945 reused := !atomic.CompareAndSwapUint32(&cc.reused, 0, 1)
6946 http2traceGotConn(req, cc, reused)
6947 res, gotErrAfterReqBodyWrite, err := cc.roundTrip(req)
6948 if err != nil && retry <= 6 {
6949 if req, err = http2shouldRetryRequest(req, err, gotErrAfterReqBodyWrite); err == nil {
6950
6951 if retry == 0 {
6952 continue
6953 }
6954 backoff := float64(uint(1) << (uint(retry) - 1))
6955 backoff += backoff * (0.1 * mathrand.Float64())
6956 select {
6957 case <-time.After(time.Second * time.Duration(backoff)):
6958 continue
6959 case <-req.Context().Done():
6960 return nil, req.Context().Err()
6961 }
6962 }
6963 }
6964 if err != nil {
6965 t.vlogf("RoundTrip failure: %v", err)
6966 return nil, err
6967 }
6968 return res, nil
6969 }
6970 }
6971
6972
6973
6974
6975 func (t *http2Transport) CloseIdleConnections() {
6976 if cp, ok := t.connPool().(http2clientConnPoolIdleCloser); ok {
6977 cp.closeIdleConnections()
6978 }
6979 }
6980
6981 var (
6982 http2errClientConnClosed = errors.New("http2: client conn is closed")
6983 http2errClientConnUnusable = errors.New("http2: client conn not usable")
6984 http2errClientConnGotGoAway = errors.New("http2: Transport received Server's graceful shutdown GOAWAY")
6985 )
6986
6987
6988
6989
6990
6991 func http2shouldRetryRequest(req *Request, err error, afterBodyWrite bool) (*Request, error) {
6992 if !http2canRetryError(err) {
6993 return nil, err
6994 }
6995
6996
6997 if req.Body == nil || req.Body == NoBody {
6998 return req, nil
6999 }
7000
7001
7002
7003 if req.GetBody != nil {
7004
7005 body, err := req.GetBody()
7006 if err != nil {
7007 return nil, err
7008 }
7009 newReq := *req
7010 newReq.Body = body
7011 return &newReq, nil
7012 }
7013
7014
7015
7016
7017
7018
7019 if !afterBodyWrite {
7020 return req, nil
7021 }
7022
7023 return nil, fmt.Errorf("http2: Transport: cannot retry err [%v] after Request.Body was written; define Request.GetBody to avoid this error", err)
7024 }
7025
7026 func http2canRetryError(err error) bool {
7027 if err == http2errClientConnUnusable || err == http2errClientConnGotGoAway {
7028 return true
7029 }
7030 if se, ok := err.(http2StreamError); ok {
7031 return se.Code == http2ErrCodeRefusedStream
7032 }
7033 return false
7034 }
7035
7036 func (t *http2Transport) dialClientConn(addr string, singleUse bool) (*http2ClientConn, error) {
7037 host, _, err := net.SplitHostPort(addr)
7038 if err != nil {
7039 return nil, err
7040 }
7041 tconn, err := t.dialTLS()("tcp", addr, t.newTLSConfig(host))
7042 if err != nil {
7043 return nil, err
7044 }
7045 return t.newClientConn(tconn, singleUse)
7046 }
7047
7048 func (t *http2Transport) newTLSConfig(host string) *tls.Config {
7049 cfg := new(tls.Config)
7050 if t.TLSClientConfig != nil {
7051 *cfg = *t.TLSClientConfig.Clone()
7052 }
7053 if !http2strSliceContains(cfg.NextProtos, http2NextProtoTLS) {
7054 cfg.NextProtos = append([]string{http2NextProtoTLS}, cfg.NextProtos...)
7055 }
7056 if cfg.ServerName == "" {
7057 cfg.ServerName = host
7058 }
7059 return cfg
7060 }
7061
7062 func (t *http2Transport) dialTLS() func(string, string, *tls.Config) (net.Conn, error) {
7063 if t.DialTLS != nil {
7064 return t.DialTLS
7065 }
7066 return t.dialTLSDefault
7067 }
7068
7069 func (t *http2Transport) dialTLSDefault(network, addr string, cfg *tls.Config) (net.Conn, error) {
7070 cn, err := tls.Dial(network, addr, cfg)
7071 if err != nil {
7072 return nil, err
7073 }
7074 if err := cn.Handshake(); err != nil {
7075 return nil, err
7076 }
7077 if !cfg.InsecureSkipVerify {
7078 if err := cn.VerifyHostname(cfg.ServerName); err != nil {
7079 return nil, err
7080 }
7081 }
7082 state := cn.ConnectionState()
7083 if p := state.NegotiatedProtocol; p != http2NextProtoTLS {
7084 return nil, fmt.Errorf("http2: unexpected ALPN protocol %q; want %q", p, http2NextProtoTLS)
7085 }
7086 if !state.NegotiatedProtocolIsMutual {
7087 return nil, errors.New("http2: could not negotiate protocol mutually")
7088 }
7089 return cn, nil
7090 }
7091
7092
7093
7094 func (t *http2Transport) disableKeepAlives() bool {
7095 return t.t1 != nil && t.t1.DisableKeepAlives
7096 }
7097
7098 func (t *http2Transport) expectContinueTimeout() time.Duration {
7099 if t.t1 == nil {
7100 return 0
7101 }
7102 return t.t1.ExpectContinueTimeout
7103 }
7104
7105 func (t *http2Transport) NewClientConn(c net.Conn) (*http2ClientConn, error) {
7106 return t.newClientConn(c, t.disableKeepAlives())
7107 }
7108
7109 func (t *http2Transport) newClientConn(c net.Conn, singleUse bool) (*http2ClientConn, error) {
7110 cc := &http2ClientConn{
7111 t: t,
7112 tconn: c,
7113 readerDone: make(chan struct{}),
7114 nextStreamID: 1,
7115 maxFrameSize: 16 << 10,
7116 initialWindowSize: 65535,
7117 maxConcurrentStreams: 1000,
7118 peerMaxHeaderListSize: 0xffffffffffffffff,
7119 streams: make(map[uint32]*http2clientStream),
7120 singleUse: singleUse,
7121 wantSettingsAck: true,
7122 pings: make(map[[8]byte]chan struct{}),
7123 }
7124 if d := t.idleConnTimeout(); d != 0 {
7125 cc.idleTimeout = d
7126 cc.idleTimer = time.AfterFunc(d, cc.onIdleTimeout)
7127 }
7128 if http2VerboseLogs {
7129 t.vlogf("http2: Transport creating client conn %p to %v", cc, c.RemoteAddr())
7130 }
7131
7132 cc.cond = sync.NewCond(&cc.mu)
7133 cc.flow.add(int32(http2initialWindowSize))
7134
7135
7136
7137 cc.bw = bufio.NewWriter(http2stickyErrWriter{c, &cc.werr})
7138 cc.br = bufio.NewReader(c)
7139 cc.fr = http2NewFramer(cc.bw, cc.br)
7140 cc.fr.ReadMetaHeaders = hpack.NewDecoder(http2initialHeaderTableSize, nil)
7141 cc.fr.MaxHeaderListSize = t.maxHeaderListSize()
7142
7143
7144
7145 cc.henc = hpack.NewEncoder(&cc.hbuf)
7146
7147 if t.AllowHTTP {
7148 cc.nextStreamID = 3
7149 }
7150
7151 if cs, ok := c.(http2connectionStater); ok {
7152 state := cs.ConnectionState()
7153 cc.tlsState = &state
7154 }
7155
7156 initialSettings := []http2Setting{
7157 {ID: http2SettingEnablePush, Val: 0},
7158 {ID: http2SettingInitialWindowSize, Val: http2transportDefaultStreamFlow},
7159 }
7160 if max := t.maxHeaderListSize(); max != 0 {
7161 initialSettings = append(initialSettings, http2Setting{ID: http2SettingMaxHeaderListSize, Val: max})
7162 }
7163
7164 cc.bw.Write(http2clientPreface)
7165 cc.fr.WriteSettings(initialSettings...)
7166 cc.fr.WriteWindowUpdate(0, http2transportDefaultConnFlow)
7167 cc.inflow.add(http2transportDefaultConnFlow + http2initialWindowSize)
7168 cc.bw.Flush()
7169 if cc.werr != nil {
7170 return nil, cc.werr
7171 }
7172
7173 go cc.readLoop()
7174 return cc, nil
7175 }
7176
7177 func (cc *http2ClientConn) setGoAway(f *http2GoAwayFrame) {
7178 cc.mu.Lock()
7179 defer cc.mu.Unlock()
7180
7181 old := cc.goAway
7182 cc.goAway = f
7183
7184
7185 if cc.goAwayDebug == "" {
7186 cc.goAwayDebug = string(f.DebugData())
7187 }
7188 if old != nil && old.ErrCode != http2ErrCodeNo {
7189 cc.goAway.ErrCode = old.ErrCode
7190 }
7191 last := f.LastStreamID
7192 for streamID, cs := range cc.streams {
7193 if streamID > last {
7194 select {
7195 case cs.resc <- http2resAndError{err: http2errClientConnGotGoAway}:
7196 default:
7197 }
7198 }
7199 }
7200 }
7201
7202
7203
7204 func (cc *http2ClientConn) CanTakeNewRequest() bool {
7205 cc.mu.Lock()
7206 defer cc.mu.Unlock()
7207 return cc.canTakeNewRequestLocked()
7208 }
7209
7210
7211
7212 type http2clientConnIdleState struct {
7213 canTakeNewRequest bool
7214 freshConn bool
7215 }
7216
7217 func (cc *http2ClientConn) idleState() http2clientConnIdleState {
7218 cc.mu.Lock()
7219 defer cc.mu.Unlock()
7220 return cc.idleStateLocked()
7221 }
7222
7223 func (cc *http2ClientConn) idleStateLocked() (st http2clientConnIdleState) {
7224 if cc.singleUse && cc.nextStreamID > 1 {
7225 return
7226 }
7227 var maxConcurrentOkay bool
7228 if cc.t.StrictMaxConcurrentStreams {
7229
7230
7231
7232
7233 maxConcurrentOkay = true
7234 } else {
7235 maxConcurrentOkay = int64(len(cc.streams)+1) < int64(cc.maxConcurrentStreams)
7236 }
7237
7238 st.canTakeNewRequest = cc.goAway == nil && !cc.closed && !cc.closing && maxConcurrentOkay &&
7239 int64(cc.nextStreamID)+2*int64(cc.pendingRequests) < math.MaxInt32 &&
7240 !cc.tooIdleLocked()
7241 st.freshConn = cc.nextStreamID == 1 && st.canTakeNewRequest
7242 return
7243 }
7244
7245 func (cc *http2ClientConn) canTakeNewRequestLocked() bool {
7246 st := cc.idleStateLocked()
7247 return st.canTakeNewRequest
7248 }
7249
7250
7251
7252 func (cc *http2ClientConn) tooIdleLocked() bool {
7253
7254
7255
7256
7257 return cc.idleTimeout != 0 && !cc.lastIdle.IsZero() && time.Since(cc.lastIdle.Round(0)) > cc.idleTimeout
7258 }
7259
7260
7261
7262
7263
7264
7265
7266 func (cc *http2ClientConn) onIdleTimeout() {
7267 cc.closeIfIdle()
7268 }
7269
7270 func (cc *http2ClientConn) closeIfIdle() {
7271 cc.mu.Lock()
7272 if len(cc.streams) > 0 {
7273 cc.mu.Unlock()
7274 return
7275 }
7276 cc.closed = true
7277 nextID := cc.nextStreamID
7278
7279 cc.mu.Unlock()
7280
7281 if http2VerboseLogs {
7282 cc.vlogf("http2: Transport closing idle conn %p (forSingleUse=%v, maxStream=%v)", cc, cc.singleUse, nextID-2)
7283 }
7284 cc.tconn.Close()
7285 }
7286
7287 var http2shutdownEnterWaitStateHook = func() {}
7288
7289
7290 func (cc *http2ClientConn) Shutdown(ctx context.Context) error {
7291 if err := cc.sendGoAway(); err != nil {
7292 return err
7293 }
7294
7295 done := make(chan error, 1)
7296 cancelled := false
7297 go func() {
7298 cc.mu.Lock()
7299 defer cc.mu.Unlock()
7300 for {
7301 if len(cc.streams) == 0 || cc.closed {
7302 cc.closed = true
7303 done <- cc.tconn.Close()
7304 break
7305 }
7306 if cancelled {
7307 break
7308 }
7309 cc.cond.Wait()
7310 }
7311 }()
7312 http2shutdownEnterWaitStateHook()
7313 select {
7314 case err := <-done:
7315 return err
7316 case <-ctx.Done():
7317 cc.mu.Lock()
7318
7319 cancelled = true
7320 cc.cond.Broadcast()
7321 cc.mu.Unlock()
7322 return ctx.Err()
7323 }
7324 }
7325
7326 func (cc *http2ClientConn) sendGoAway() error {
7327 cc.mu.Lock()
7328 defer cc.mu.Unlock()
7329 cc.wmu.Lock()
7330 defer cc.wmu.Unlock()
7331 if cc.closing {
7332
7333 return nil
7334 }
7335
7336 maxStreamID := cc.nextStreamID
7337 if err := cc.fr.WriteGoAway(maxStreamID, http2ErrCodeNo, nil); err != nil {
7338 return err
7339 }
7340 if err := cc.bw.Flush(); err != nil {
7341 return err
7342 }
7343
7344 cc.closing = true
7345 return nil
7346 }
7347
7348
7349
7350
7351 func (cc *http2ClientConn) Close() error {
7352 cc.mu.Lock()
7353 defer cc.cond.Broadcast()
7354 defer cc.mu.Unlock()
7355 err := errors.New("http2: client connection force closed via ClientConn.Close")
7356 for id, cs := range cc.streams {
7357 select {
7358 case cs.resc <- http2resAndError{err: err}:
7359 default:
7360 }
7361 cs.bufPipe.CloseWithError(err)
7362 delete(cc.streams, id)
7363 }
7364 cc.closed = true
7365 return cc.tconn.Close()
7366 }
7367
7368 const http2maxAllocFrameSize = 512 << 10
7369
7370
7371
7372
7373
7374 func (cc *http2ClientConn) frameScratchBuffer() []byte {
7375 cc.mu.Lock()
7376 size := cc.maxFrameSize
7377 if size > http2maxAllocFrameSize {
7378 size = http2maxAllocFrameSize
7379 }
7380 for i, buf := range cc.freeBuf {
7381 if len(buf) >= int(size) {
7382 cc.freeBuf[i] = nil
7383 cc.mu.Unlock()
7384 return buf[:size]
7385 }
7386 }
7387 cc.mu.Unlock()
7388 return make([]byte, size)
7389 }
7390
7391 func (cc *http2ClientConn) putFrameScratchBuffer(buf []byte) {
7392 cc.mu.Lock()
7393 defer cc.mu.Unlock()
7394 const maxBufs = 4
7395 if len(cc.freeBuf) < maxBufs {
7396 cc.freeBuf = append(cc.freeBuf, buf)
7397 return
7398 }
7399 for i, old := range cc.freeBuf {
7400 if old == nil {
7401 cc.freeBuf[i] = buf
7402 return
7403 }
7404 }
7405
7406 }
7407
7408
7409
7410 var http2errRequestCanceled = errors.New("net/http: request canceled")
7411
7412 func http2commaSeparatedTrailers(req *Request) (string, error) {
7413 keys := make([]string, 0, len(req.Trailer))
7414 for k := range req.Trailer {
7415 k = CanonicalHeaderKey(k)
7416 switch k {
7417 case "Transfer-Encoding", "Trailer", "Content-Length":
7418 return "", fmt.Errorf("invalid Trailer key %q", k)
7419 }
7420 keys = append(keys, k)
7421 }
7422 if len(keys) > 0 {
7423 sort.Strings(keys)
7424 return strings.Join(keys, ","), nil
7425 }
7426 return "", nil
7427 }
7428
7429 func (cc *http2ClientConn) responseHeaderTimeout() time.Duration {
7430 if cc.t.t1 != nil {
7431 return cc.t.t1.ResponseHeaderTimeout
7432 }
7433
7434
7435
7436
7437 return 0
7438 }
7439
7440
7441
7442
7443 func http2checkConnHeaders(req *Request) error {
7444 if v := req.Header.Get("Upgrade"); v != "" {
7445 return fmt.Errorf("http2: invalid Upgrade request header: %q", req.Header["Upgrade"])
7446 }
7447 if vv := req.Header["Transfer-Encoding"]; len(vv) > 0 && (len(vv) > 1 || vv[0] != "" && vv[0] != "chunked") {
7448 return fmt.Errorf("http2: invalid Transfer-Encoding request header: %q", vv)
7449 }
7450 if vv := req.Header["Connection"]; len(vv) > 0 && (len(vv) > 1 || vv[0] != "" && !strings.EqualFold(vv[0], "close") && !strings.EqualFold(vv[0], "keep-alive")) {
7451 return fmt.Errorf("http2: invalid Connection request header: %q", vv)
7452 }
7453 return nil
7454 }
7455
7456
7457
7458
7459 func http2actualContentLength(req *Request) int64 {
7460 if req.Body == nil || req.Body == NoBody {
7461 return 0
7462 }
7463 if req.ContentLength != 0 {
7464 return req.ContentLength
7465 }
7466 return -1
7467 }
7468
7469 func (cc *http2ClientConn) RoundTrip(req *Request) (*Response, error) {
7470 resp, _, err := cc.roundTrip(req)
7471 return resp, err
7472 }
7473
7474 func (cc *http2ClientConn) roundTrip(req *Request) (res *Response, gotErrAfterReqBodyWrite bool, err error) {
7475 if err := http2checkConnHeaders(req); err != nil {
7476 return nil, false, err
7477 }
7478 if cc.idleTimer != nil {
7479 cc.idleTimer.Stop()
7480 }
7481
7482 trailers, err := http2commaSeparatedTrailers(req)
7483 if err != nil {
7484 return nil, false, err
7485 }
7486 hasTrailers := trailers != ""
7487
7488 cc.mu.Lock()
7489 if err := cc.awaitOpenSlotForRequest(req); err != nil {
7490 cc.mu.Unlock()
7491 return nil, false, err
7492 }
7493
7494 body := req.Body
7495 contentLen := http2actualContentLength(req)
7496 hasBody := contentLen != 0
7497
7498
7499 var requestedGzip bool
7500 if !cc.t.disableCompression() &&
7501 req.Header.Get("Accept-Encoding") == "" &&
7502 req.Header.Get("Range") == "" &&
7503 req.Method != "HEAD" {
7504
7505
7506
7507
7508
7509
7510
7511
7512
7513
7514
7515
7516 requestedGzip = true
7517 }
7518
7519
7520
7521
7522 hdrs, err := cc.encodeHeaders(req, requestedGzip, trailers, contentLen)
7523 if err != nil {
7524 cc.mu.Unlock()
7525 return nil, false, err
7526 }
7527
7528 cs := cc.newStream()
7529 cs.req = req
7530 cs.trace = httptrace.ContextClientTrace(req.Context())
7531 cs.requestedGzip = requestedGzip
7532 bodyWriter := cc.t.getBodyWriterState(cs, body)
7533 cs.on100 = bodyWriter.on100
7534
7535 cc.wmu.Lock()
7536 endStream := !hasBody && !hasTrailers
7537 werr := cc.writeHeaders(cs.ID, endStream, int(cc.maxFrameSize), hdrs)
7538 cc.wmu.Unlock()
7539 http2traceWroteHeaders(cs.trace)
7540 cc.mu.Unlock()
7541
7542 if werr != nil {
7543 if hasBody {
7544 req.Body.Close()
7545 bodyWriter.cancel()
7546 }
7547 cc.forgetStreamID(cs.ID)
7548
7549
7550 http2traceWroteRequest(cs.trace, werr)
7551 return nil, false, werr
7552 }
7553
7554 var respHeaderTimer <-chan time.Time
7555 if hasBody {
7556 bodyWriter.scheduleBodyWrite()
7557 } else {
7558 http2traceWroteRequest(cs.trace, nil)
7559 if d := cc.responseHeaderTimeout(); d != 0 {
7560 timer := time.NewTimer(d)
7561 defer timer.Stop()
7562 respHeaderTimer = timer.C
7563 }
7564 }
7565
7566 readLoopResCh := cs.resc
7567 bodyWritten := false
7568 ctx := req.Context()
7569
7570 handleReadLoopResponse := func(re http2resAndError) (*Response, bool, error) {
7571 res := re.res
7572 if re.err != nil || res.StatusCode > 299 {
7573
7574
7575
7576
7577
7578
7579
7580
7581
7582 bodyWriter.cancel()
7583 cs.abortRequestBodyWrite(http2errStopReqBodyWrite)
7584 }
7585 if re.err != nil {
7586 cc.forgetStreamID(cs.ID)
7587 return nil, cs.getStartedWrite(), re.err
7588 }
7589 res.Request = req
7590 res.TLS = cc.tlsState
7591 return res, false, nil
7592 }
7593
7594 for {
7595 select {
7596 case re := <-readLoopResCh:
7597 return handleReadLoopResponse(re)
7598 case <-respHeaderTimer:
7599 if !hasBody || bodyWritten {
7600 cc.writeStreamReset(cs.ID, http2ErrCodeCancel, nil)
7601 } else {
7602 bodyWriter.cancel()
7603 cs.abortRequestBodyWrite(http2errStopReqBodyWriteAndCancel)
7604 }
7605 cc.forgetStreamID(cs.ID)
7606 return nil, cs.getStartedWrite(), http2errTimeout
7607 case <-ctx.Done():
7608 if !hasBody || bodyWritten {
7609 cc.writeStreamReset(cs.ID, http2ErrCodeCancel, nil)
7610 } else {
7611 bodyWriter.cancel()
7612 cs.abortRequestBodyWrite(http2errStopReqBodyWriteAndCancel)
7613 }
7614 cc.forgetStreamID(cs.ID)
7615 return nil, cs.getStartedWrite(), ctx.Err()
7616 case <-req.Cancel:
7617 if !hasBody || bodyWritten {
7618 cc.writeStreamReset(cs.ID, http2ErrCodeCancel, nil)
7619 } else {
7620 bodyWriter.cancel()
7621 cs.abortRequestBodyWrite(http2errStopReqBodyWriteAndCancel)
7622 }
7623 cc.forgetStreamID(cs.ID)
7624 return nil, cs.getStartedWrite(), http2errRequestCanceled
7625 case <-cs.peerReset:
7626
7627
7628
7629 return nil, cs.getStartedWrite(), cs.resetErr
7630 case err := <-bodyWriter.resc:
7631
7632 select {
7633 case re := <-readLoopResCh:
7634 return handleReadLoopResponse(re)
7635 default:
7636 }
7637 if err != nil {
7638 cc.forgetStreamID(cs.ID)
7639 return nil, cs.getStartedWrite(), err
7640 }
7641 bodyWritten = true
7642 if d := cc.responseHeaderTimeout(); d != 0 {
7643 timer := time.NewTimer(d)
7644 defer timer.Stop()
7645 respHeaderTimer = timer.C
7646 }
7647 }
7648 }
7649 }
7650
7651
7652
7653 func (cc *http2ClientConn) awaitOpenSlotForRequest(req *Request) error {
7654 var waitingForConn chan struct{}
7655 var waitingForConnErr error
7656 for {
7657 cc.lastActive = time.Now()
7658 if cc.closed || !cc.canTakeNewRequestLocked() {
7659 if waitingForConn != nil {
7660 close(waitingForConn)
7661 }
7662 return http2errClientConnUnusable
7663 }
7664 cc.lastIdle = time.Time{}
7665 if int64(len(cc.streams))+1 <= int64(cc.maxConcurrentStreams) {
7666 if waitingForConn != nil {
7667 close(waitingForConn)
7668 }
7669 return nil
7670 }
7671
7672
7673
7674 if waitingForConn == nil {
7675 waitingForConn = make(chan struct{})
7676 go func() {
7677 if err := http2awaitRequestCancel(req, waitingForConn); err != nil {
7678 cc.mu.Lock()
7679 waitingForConnErr = err
7680 cc.cond.Broadcast()
7681 cc.mu.Unlock()
7682 }
7683 }()
7684 }
7685 cc.pendingRequests++
7686 cc.cond.Wait()
7687 cc.pendingRequests--
7688 if waitingForConnErr != nil {
7689 return waitingForConnErr
7690 }
7691 }
7692 }
7693
7694
7695 func (cc *http2ClientConn) writeHeaders(streamID uint32, endStream bool, maxFrameSize int, hdrs []byte) error {
7696 first := true
7697 for len(hdrs) > 0 && cc.werr == nil {
7698 chunk := hdrs
7699 if len(chunk) > maxFrameSize {
7700 chunk = chunk[:maxFrameSize]
7701 }
7702 hdrs = hdrs[len(chunk):]
7703 endHeaders := len(hdrs) == 0
7704 if first {
7705 cc.fr.WriteHeaders(http2HeadersFrameParam{
7706 StreamID: streamID,
7707 BlockFragment: chunk,
7708 EndStream: endStream,
7709 EndHeaders: endHeaders,
7710 })
7711 first = false
7712 } else {
7713 cc.fr.WriteContinuation(streamID, endHeaders, chunk)
7714 }
7715 }
7716
7717
7718
7719
7720 cc.bw.Flush()
7721 return cc.werr
7722 }
7723
7724
7725 var (
7726
7727 http2errStopReqBodyWrite = errors.New("http2: aborting request body write")
7728
7729
7730 http2errStopReqBodyWriteAndCancel = errors.New("http2: canceling request")
7731
7732 http2errReqBodyTooLong = errors.New("http2: request body larger than specified content length")
7733 )
7734
7735 func (cs *http2clientStream) writeRequestBody(body io.Reader, bodyCloser io.Closer) (err error) {
7736 cc := cs.cc
7737 sentEnd := false
7738 buf := cc.frameScratchBuffer()
7739 defer cc.putFrameScratchBuffer(buf)
7740
7741 defer func() {
7742 http2traceWroteRequest(cs.trace, err)
7743
7744
7745
7746
7747 cerr := bodyCloser.Close()
7748 if err == nil {
7749 err = cerr
7750 }
7751 }()
7752
7753 req := cs.req
7754 hasTrailers := req.Trailer != nil
7755 remainLen := http2actualContentLength(req)
7756 hasContentLen := remainLen != -1
7757
7758 var sawEOF bool
7759 for !sawEOF {
7760 n, err := body.Read(buf[:len(buf)-1])
7761 if hasContentLen {
7762 remainLen -= int64(n)
7763 if remainLen == 0 && err == nil {
7764
7765
7766
7767
7768
7769
7770
7771 var n1 int
7772 n1, err = body.Read(buf[n:])
7773 remainLen -= int64(n1)
7774 }
7775 if remainLen < 0 {
7776 err = http2errReqBodyTooLong
7777 cc.writeStreamReset(cs.ID, http2ErrCodeCancel, err)
7778 return err
7779 }
7780 }
7781 if err == io.EOF {
7782 sawEOF = true
7783 err = nil
7784 } else if err != nil {
7785 cc.writeStreamReset(cs.ID, http2ErrCodeCancel, err)
7786 return err
7787 }
7788
7789 remain := buf[:n]
7790 for len(remain) > 0 && err == nil {
7791 var allowed int32
7792 allowed, err = cs.awaitFlowControl(len(remain))
7793 switch {
7794 case err == http2errStopReqBodyWrite:
7795 return err
7796 case err == http2errStopReqBodyWriteAndCancel:
7797 cc.writeStreamReset(cs.ID, http2ErrCodeCancel, nil)
7798 return err
7799 case err != nil:
7800 return err
7801 }
7802 cc.wmu.Lock()
7803 data := remain[:allowed]
7804 remain = remain[allowed:]
7805 sentEnd = sawEOF && len(remain) == 0 && !hasTrailers
7806 err = cc.fr.WriteData(cs.ID, sentEnd, data)
7807 if err == nil {
7808
7809
7810
7811
7812
7813
7814 err = cc.bw.Flush()
7815 }
7816 cc.wmu.Unlock()
7817 }
7818 if err != nil {
7819 return err
7820 }
7821 }
7822
7823 if sentEnd {
7824
7825
7826
7827 return nil
7828 }
7829
7830 var trls []byte
7831 if hasTrailers {
7832 cc.mu.Lock()
7833 trls, err = cc.encodeTrailers(req)
7834 cc.mu.Unlock()
7835 if err != nil {
7836 cc.writeStreamReset(cs.ID, http2ErrCodeInternal, err)
7837 cc.forgetStreamID(cs.ID)
7838 return err
7839 }
7840 }
7841
7842 cc.mu.Lock()
7843 maxFrameSize := int(cc.maxFrameSize)
7844 cc.mu.Unlock()
7845
7846 cc.wmu.Lock()
7847 defer cc.wmu.Unlock()
7848
7849
7850
7851 if len(trls) > 0 {
7852 err = cc.writeHeaders(cs.ID, true, maxFrameSize, trls)
7853 } else {
7854 err = cc.fr.WriteData(cs.ID, true, nil)
7855 }
7856 if ferr := cc.bw.Flush(); ferr != nil && err == nil {
7857 err = ferr
7858 }
7859 return err
7860 }
7861
7862
7863
7864
7865
7866 func (cs *http2clientStream) awaitFlowControl(maxBytes int) (taken int32, err error) {
7867 cc := cs.cc
7868 cc.mu.Lock()
7869 defer cc.mu.Unlock()
7870 for {
7871 if cc.closed {
7872 return 0, http2errClientConnClosed
7873 }
7874 if cs.stopReqBody != nil {
7875 return 0, cs.stopReqBody
7876 }
7877 if err := cs.checkResetOrDone(); err != nil {
7878 return 0, err
7879 }
7880 if a := cs.flow.available(); a > 0 {
7881 take := a
7882 if int(take) > maxBytes {
7883
7884 take = int32(maxBytes)
7885 }
7886 if take > int32(cc.maxFrameSize) {
7887 take = int32(cc.maxFrameSize)
7888 }
7889 cs.flow.take(take)
7890 return take, nil
7891 }
7892 cc.cond.Wait()
7893 }
7894 }
7895
7896
7897 func (cc *http2ClientConn) encodeHeaders(req *Request, addGzipHeader bool, trailers string, contentLength int64) ([]byte, error) {
7898 cc.hbuf.Reset()
7899
7900 host := req.Host
7901 if host == "" {
7902 host = req.URL.Host
7903 }
7904 host, err := httpguts.PunycodeHostPort(host)
7905 if err != nil {
7906 return nil, err
7907 }
7908
7909 var path string
7910 if req.Method != "CONNECT" {
7911 path = req.URL.RequestURI()
7912 if !http2validPseudoPath(path) {
7913 orig := path
7914 path = strings.TrimPrefix(path, req.URL.Scheme+"://"+host)
7915 if !http2validPseudoPath(path) {
7916 if req.URL.Opaque != "" {
7917 return nil, fmt.Errorf("invalid request :path %q from URL.Opaque = %q", orig, req.URL.Opaque)
7918 } else {
7919 return nil, fmt.Errorf("invalid request :path %q", orig)
7920 }
7921 }
7922 }
7923 }
7924
7925
7926
7927
7928 for k, vv := range req.Header {
7929 if !httpguts.ValidHeaderFieldName(k) {
7930 return nil, fmt.Errorf("invalid HTTP header name %q", k)
7931 }
7932 for _, v := range vv {
7933 if !httpguts.ValidHeaderFieldValue(v) {
7934 return nil, fmt.Errorf("invalid HTTP header value %q for header %q", v, k)
7935 }
7936 }
7937 }
7938
7939 enumerateHeaders := func(f func(name, value string)) {
7940
7941
7942
7943
7944
7945 f(":authority", host)
7946 m := req.Method
7947 if m == "" {
7948 m = MethodGet
7949 }
7950 f(":method", m)
7951 if req.Method != "CONNECT" {
7952 f(":path", path)
7953 f(":scheme", req.URL.Scheme)
7954 }
7955 if trailers != "" {
7956 f("trailer", trailers)
7957 }
7958
7959 var didUA bool
7960 for k, vv := range req.Header {
7961 if strings.EqualFold(k, "host") || strings.EqualFold(k, "content-length") {
7962
7963
7964 continue
7965 } else if strings.EqualFold(k, "connection") || strings.EqualFold(k, "proxy-connection") ||
7966 strings.EqualFold(k, "transfer-encoding") || strings.EqualFold(k, "upgrade") ||
7967 strings.EqualFold(k, "keep-alive") {
7968
7969
7970
7971
7972 continue
7973 } else if strings.EqualFold(k, "user-agent") {
7974
7975
7976
7977
7978 didUA = true
7979 if len(vv) < 1 {
7980 continue
7981 }
7982 vv = vv[:1]
7983 if vv[0] == "" {
7984 continue
7985 }
7986 } else if strings.EqualFold(k, "cookie") {
7987
7988
7989
7990 for _, v := range vv {
7991 for {
7992 p := strings.IndexByte(v, ';')
7993 if p < 0 {
7994 break
7995 }
7996 f("cookie", v[:p])
7997 p++
7998
7999 for p+1 <= len(v) && v[p] == ' ' {
8000 p++
8001 }
8002 v = v[p:]
8003 }
8004 if len(v) > 0 {
8005 f("cookie", v)
8006 }
8007 }
8008 continue
8009 }
8010
8011 for _, v := range vv {
8012 f(k, v)
8013 }
8014 }
8015 if http2shouldSendReqContentLength(req.Method, contentLength) {
8016 f("content-length", strconv.FormatInt(contentLength, 10))
8017 }
8018 if addGzipHeader {
8019 f("accept-encoding", "gzip")
8020 }
8021 if !didUA {
8022 f("user-agent", http2defaultUserAgent)
8023 }
8024 }
8025
8026
8027
8028
8029
8030 hlSize := uint64(0)
8031 enumerateHeaders(func(name, value string) {
8032 hf := hpack.HeaderField{Name: name, Value: value}
8033 hlSize += uint64(hf.Size())
8034 })
8035
8036 if hlSize > cc.peerMaxHeaderListSize {
8037 return nil, http2errRequestHeaderListSize
8038 }
8039
8040 trace := httptrace.ContextClientTrace(req.Context())
8041 traceHeaders := http2traceHasWroteHeaderField(trace)
8042
8043
8044 enumerateHeaders(func(name, value string) {
8045 name = strings.ToLower(name)
8046 cc.writeHeader(name, value)
8047 if traceHeaders {
8048 http2traceWroteHeaderField(trace, name, value)
8049 }
8050 })
8051
8052 return cc.hbuf.Bytes(), nil
8053 }
8054
8055
8056
8057
8058
8059
8060 func http2shouldSendReqContentLength(method string, contentLength int64) bool {
8061 if contentLength > 0 {
8062 return true
8063 }
8064 if contentLength < 0 {
8065 return false
8066 }
8067
8068
8069 switch method {
8070 case "POST", "PUT", "PATCH":
8071 return true
8072 default:
8073 return false
8074 }
8075 }
8076
8077
8078 func (cc *http2ClientConn) encodeTrailers(req *Request) ([]byte, error) {
8079 cc.hbuf.Reset()
8080
8081 hlSize := uint64(0)
8082 for k, vv := range req.Trailer {
8083 for _, v := range vv {
8084 hf := hpack.HeaderField{Name: k, Value: v}
8085 hlSize += uint64(hf.Size())
8086 }
8087 }
8088 if hlSize > cc.peerMaxHeaderListSize {
8089 return nil, http2errRequestHeaderListSize
8090 }
8091
8092 for k, vv := range req.Trailer {
8093
8094
8095 lowKey := strings.ToLower(k)
8096 for _, v := range vv {
8097 cc.writeHeader(lowKey, v)
8098 }
8099 }
8100 return cc.hbuf.Bytes(), nil
8101 }
8102
8103 func (cc *http2ClientConn) writeHeader(name, value string) {
8104 if http2VerboseLogs {
8105 log.Printf("http2: Transport encoding header %q = %q", name, value)
8106 }
8107 cc.henc.WriteField(hpack.HeaderField{Name: name, Value: value})
8108 }
8109
8110 type http2resAndError struct {
8111 _ http2incomparable
8112 res *Response
8113 err error
8114 }
8115
8116
8117 func (cc *http2ClientConn) newStream() *http2clientStream {
8118 cs := &http2clientStream{
8119 cc: cc,
8120 ID: cc.nextStreamID,
8121 resc: make(chan http2resAndError, 1),
8122 peerReset: make(chan struct{}),
8123 done: make(chan struct{}),
8124 }
8125 cs.flow.add(int32(cc.initialWindowSize))
8126 cs.flow.setConnFlow(&cc.flow)
8127 cs.inflow.add(http2transportDefaultStreamFlow)
8128 cs.inflow.setConnFlow(&cc.inflow)
8129 cc.nextStreamID += 2
8130 cc.streams[cs.ID] = cs
8131 return cs
8132 }
8133
8134 func (cc *http2ClientConn) forgetStreamID(id uint32) {
8135 cc.streamByID(id, true)
8136 }
8137
8138 func (cc *http2ClientConn) streamByID(id uint32, andRemove bool) *http2clientStream {
8139 cc.mu.Lock()
8140 defer cc.mu.Unlock()
8141 cs := cc.streams[id]
8142 if andRemove && cs != nil && !cc.closed {
8143 cc.lastActive = time.Now()
8144 delete(cc.streams, id)
8145 if len(cc.streams) == 0 && cc.idleTimer != nil {
8146 cc.idleTimer.Reset(cc.idleTimeout)
8147 cc.lastIdle = time.Now()
8148 }
8149 close(cs.done)
8150
8151
8152 cc.cond.Broadcast()
8153 }
8154 return cs
8155 }
8156
8157
8158 type http2clientConnReadLoop struct {
8159 _ http2incomparable
8160 cc *http2ClientConn
8161 closeWhenIdle bool
8162 }
8163
8164
8165 func (cc *http2ClientConn) readLoop() {
8166 rl := &http2clientConnReadLoop{cc: cc}
8167 defer rl.cleanup()
8168 cc.readerErr = rl.run()
8169 if ce, ok := cc.readerErr.(http2ConnectionError); ok {
8170 cc.wmu.Lock()
8171 cc.fr.WriteGoAway(0, http2ErrCode(ce), nil)
8172 cc.wmu.Unlock()
8173 }
8174 }
8175
8176
8177
8178 type http2GoAwayError struct {
8179 LastStreamID uint32
8180 ErrCode http2ErrCode
8181 DebugData string
8182 }
8183
8184 func (e http2GoAwayError) Error() string {
8185 return fmt.Sprintf("http2: server sent GOAWAY and closed the connection; LastStreamID=%v, ErrCode=%v, debug=%q",
8186 e.LastStreamID, e.ErrCode, e.DebugData)
8187 }
8188
8189 func http2isEOFOrNetReadError(err error) bool {
8190 if err == io.EOF {
8191 return true
8192 }
8193 ne, ok := err.(*net.OpError)
8194 return ok && ne.Op == "read"
8195 }
8196
8197 func (rl *http2clientConnReadLoop) cleanup() {
8198 cc := rl.cc
8199 defer cc.tconn.Close()
8200 defer cc.t.connPool().MarkDead(cc)
8201 defer close(cc.readerDone)
8202
8203 if cc.idleTimer != nil {
8204 cc.idleTimer.Stop()
8205 }
8206
8207
8208
8209
8210 err := cc.readerErr
8211 cc.mu.Lock()
8212 if cc.goAway != nil && http2isEOFOrNetReadError(err) {
8213 err = http2GoAwayError{
8214 LastStreamID: cc.goAway.LastStreamID,
8215 ErrCode: cc.goAway.ErrCode,
8216 DebugData: cc.goAwayDebug,
8217 }
8218 } else if err == io.EOF {
8219 err = io.ErrUnexpectedEOF
8220 }
8221 for _, cs := range cc.streams {
8222 cs.bufPipe.CloseWithError(err)
8223 select {
8224 case cs.resc <- http2resAndError{err: err}:
8225 default:
8226 }
8227 close(cs.done)
8228 }
8229 cc.closed = true
8230 cc.cond.Broadcast()
8231 cc.mu.Unlock()
8232 }
8233
8234 func (rl *http2clientConnReadLoop) run() error {
8235 cc := rl.cc
8236 rl.closeWhenIdle = cc.t.disableKeepAlives() || cc.singleUse
8237 gotReply := false
8238 gotSettings := false
8239 for {
8240 f, err := cc.fr.ReadFrame()
8241 if err != nil {
8242 cc.vlogf("http2: Transport readFrame error on conn %p: (%T) %v", cc, err, err)
8243 }
8244 if se, ok := err.(http2StreamError); ok {
8245 if cs := cc.streamByID(se.StreamID, false); cs != nil {
8246 cs.cc.writeStreamReset(cs.ID, se.Code, err)
8247 cs.cc.forgetStreamID(cs.ID)
8248 if se.Cause == nil {
8249 se.Cause = cc.fr.errDetail
8250 }
8251 rl.endStreamError(cs, se)
8252 }
8253 continue
8254 } else if err != nil {
8255 return err
8256 }
8257 if http2VerboseLogs {
8258 cc.vlogf("http2: Transport received %s", http2summarizeFrame(f))
8259 }
8260 if !gotSettings {
8261 if _, ok := f.(*http2SettingsFrame); !ok {
8262 cc.logf("protocol error: received %T before a SETTINGS frame", f)
8263 return http2ConnectionError(http2ErrCodeProtocol)
8264 }
8265 gotSettings = true
8266 }
8267 maybeIdle := false
8268
8269 switch f := f.(type) {
8270 case *http2MetaHeadersFrame:
8271 err = rl.processHeaders(f)
8272 maybeIdle = true
8273 gotReply = true
8274 case *http2DataFrame:
8275 err = rl.processData(f)
8276 maybeIdle = true
8277 case *http2GoAwayFrame:
8278 err = rl.processGoAway(f)
8279 maybeIdle = true
8280 case *http2RSTStreamFrame:
8281 err = rl.processResetStream(f)
8282 maybeIdle = true
8283 case *http2SettingsFrame:
8284 err = rl.processSettings(f)
8285 case *http2PushPromiseFrame:
8286 err = rl.processPushPromise(f)
8287 case *http2WindowUpdateFrame:
8288 err = rl.processWindowUpdate(f)
8289 case *http2PingFrame:
8290 err = rl.processPing(f)
8291 default:
8292 cc.logf("Transport: unhandled response frame type %T", f)
8293 }
8294 if err != nil {
8295 if http2VerboseLogs {
8296 cc.vlogf("http2: Transport conn %p received error from processing frame %v: %v", cc, http2summarizeFrame(f), err)
8297 }
8298 return err
8299 }
8300 if rl.closeWhenIdle && gotReply && maybeIdle {
8301 cc.closeIfIdle()
8302 }
8303 }
8304 }
8305
8306 func (rl *http2clientConnReadLoop) processHeaders(f *http2MetaHeadersFrame) error {
8307 cc := rl.cc
8308 cs := cc.streamByID(f.StreamID, false)
8309 if cs == nil {
8310
8311
8312
8313 return nil
8314 }
8315 if f.StreamEnded() {
8316
8317
8318
8319
8320
8321
8322
8323
8324
8325
8326
8327 if cs.req.Body != nil {
8328 defer cc.forgetStreamID(f.StreamID)
8329 } else {
8330 cc.forgetStreamID(f.StreamID)
8331 }
8332 }
8333 if !cs.firstByte {
8334 if cs.trace != nil {
8335
8336
8337
8338
8339 http2traceFirstResponseByte(cs.trace)
8340 }
8341 cs.firstByte = true
8342 }
8343 if !cs.pastHeaders {
8344 cs.pastHeaders = true
8345 } else {
8346 return rl.processTrailers(cs, f)
8347 }
8348
8349 res, err := rl.handleResponse(cs, f)
8350 if err != nil {
8351 if _, ok := err.(http2ConnectionError); ok {
8352 return err
8353 }
8354
8355 cs.cc.writeStreamReset(f.StreamID, http2ErrCodeProtocol, err)
8356 cc.forgetStreamID(cs.ID)
8357 cs.resc <- http2resAndError{err: err}
8358 return nil
8359 }
8360 if res == nil {
8361
8362 return nil
8363 }
8364 cs.resTrailer = &res.Trailer
8365 cs.resc <- http2resAndError{res: res}
8366 return nil
8367 }
8368
8369
8370
8371
8372
8373
8374
8375 func (rl *http2clientConnReadLoop) handleResponse(cs *http2clientStream, f *http2MetaHeadersFrame) (*Response, error) {
8376 if f.Truncated {
8377 return nil, http2errResponseHeaderListSize
8378 }
8379
8380 status := f.PseudoValue("status")
8381 if status == "" {
8382 return nil, errors.New("malformed response from server: missing status pseudo header")
8383 }
8384 statusCode, err := strconv.Atoi(status)
8385 if err != nil {
8386 return nil, errors.New("malformed response from server: malformed non-numeric status pseudo header")
8387 }
8388
8389 regularFields := f.RegularFields()
8390 strs := make([]string, len(regularFields))
8391 header := make(Header, len(regularFields))
8392 res := &Response{
8393 Proto: "HTTP/2.0",
8394 ProtoMajor: 2,
8395 Header: header,
8396 StatusCode: statusCode,
8397 Status: status + " " + StatusText(statusCode),
8398 }
8399 for _, hf := range regularFields {
8400 key := CanonicalHeaderKey(hf.Name)
8401 if key == "Trailer" {
8402 t := res.Trailer
8403 if t == nil {
8404 t = make(Header)
8405 res.Trailer = t
8406 }
8407 http2foreachHeaderElement(hf.Value, func(v string) {
8408 t[CanonicalHeaderKey(v)] = nil
8409 })
8410 } else {
8411 vv := header[key]
8412 if vv == nil && len(strs) > 0 {
8413
8414
8415
8416
8417 vv, strs = strs[:1:1], strs[1:]
8418 vv[0] = hf.Value
8419 header[key] = vv
8420 } else {
8421 header[key] = append(vv, hf.Value)
8422 }
8423 }
8424 }
8425
8426 if statusCode >= 100 && statusCode <= 199 {
8427 cs.num1xx++
8428 const max1xxResponses = 5
8429 if cs.num1xx > max1xxResponses {
8430 return nil, errors.New("http2: too many 1xx informational responses")
8431 }
8432 if fn := cs.get1xxTraceFunc(); fn != nil {
8433 if err := fn(statusCode, textproto.MIMEHeader(header)); err != nil {
8434 return nil, err
8435 }
8436 }
8437 if statusCode == 100 {
8438 http2traceGot100Continue(cs.trace)
8439 if cs.on100 != nil {
8440 cs.on100()
8441 }
8442 }
8443 cs.pastHeaders = false
8444 return nil, nil
8445 }
8446
8447 streamEnded := f.StreamEnded()
8448 isHead := cs.req.Method == "HEAD"
8449 if !streamEnded || isHead {
8450 res.ContentLength = -1
8451 if clens := res.Header["Content-Length"]; len(clens) == 1 {
8452 if clen64, err := strconv.ParseInt(clens[0], 10, 64); err == nil {
8453 res.ContentLength = clen64
8454 } else {
8455
8456
8457 }
8458 } else if len(clens) > 1 {
8459
8460
8461 }
8462 }
8463
8464 if streamEnded || isHead {
8465 res.Body = http2noBody
8466 return res, nil
8467 }
8468
8469 cs.bufPipe = http2pipe{b: &http2dataBuffer{expected: res.ContentLength}}
8470 cs.bytesRemain = res.ContentLength
8471 res.Body = http2transportResponseBody{cs}
8472 go cs.awaitRequestCancel(cs.req)
8473
8474 if cs.requestedGzip && res.Header.Get("Content-Encoding") == "gzip" {
8475 res.Header.Del("Content-Encoding")
8476 res.Header.Del("Content-Length")
8477 res.ContentLength = -1
8478 res.Body = &http2gzipReader{body: res.Body}
8479 res.Uncompressed = true
8480 }
8481 return res, nil
8482 }
8483
8484 func (rl *http2clientConnReadLoop) processTrailers(cs *http2clientStream, f *http2MetaHeadersFrame) error {
8485 if cs.pastTrailers {
8486
8487 return http2ConnectionError(http2ErrCodeProtocol)
8488 }
8489 cs.pastTrailers = true
8490 if !f.StreamEnded() {
8491
8492
8493 return http2ConnectionError(http2ErrCodeProtocol)
8494 }
8495 if len(f.PseudoFields()) > 0 {
8496
8497
8498 return http2ConnectionError(http2ErrCodeProtocol)
8499 }
8500
8501 trailer := make(Header)
8502 for _, hf := range f.RegularFields() {
8503 key := CanonicalHeaderKey(hf.Name)
8504 trailer[key] = append(trailer[key], hf.Value)
8505 }
8506 cs.trailer = trailer
8507
8508 rl.endStream(cs)
8509 return nil
8510 }
8511
8512
8513
8514
8515 type http2transportResponseBody struct {
8516 cs *http2clientStream
8517 }
8518
8519 func (b http2transportResponseBody) Read(p []byte) (n int, err error) {
8520 cs := b.cs
8521 cc := cs.cc
8522
8523 if cs.readErr != nil {
8524 return 0, cs.readErr
8525 }
8526 n, err = b.cs.bufPipe.Read(p)
8527 if cs.bytesRemain != -1 {
8528 if int64(n) > cs.bytesRemain {
8529 n = int(cs.bytesRemain)
8530 if err == nil {
8531 err = errors.New("net/http: server replied with more than declared Content-Length; truncated")
8532 cc.writeStreamReset(cs.ID, http2ErrCodeProtocol, err)
8533 }
8534 cs.readErr = err
8535 return int(cs.bytesRemain), err
8536 }
8537 cs.bytesRemain -= int64(n)
8538 if err == io.EOF && cs.bytesRemain > 0 {
8539 err = io.ErrUnexpectedEOF
8540 cs.readErr = err
8541 return n, err
8542 }
8543 }
8544 if n == 0 {
8545
8546 return
8547 }
8548
8549 cc.mu.Lock()
8550 defer cc.mu.Unlock()
8551
8552 var connAdd, streamAdd int32
8553
8554 if v := cc.inflow.available(); v < http2transportDefaultConnFlow/2 {
8555 connAdd = http2transportDefaultConnFlow - v
8556 cc.inflow.add(connAdd)
8557 }
8558 if err == nil {
8559
8560
8561
8562 v := int(cs.inflow.available()) + cs.bufPipe.Len()
8563 if v < http2transportDefaultStreamFlow-http2transportDefaultStreamMinRefresh {
8564 streamAdd = int32(http2transportDefaultStreamFlow - v)
8565 cs.inflow.add(streamAdd)
8566 }
8567 }
8568 if connAdd != 0 || streamAdd != 0 {
8569 cc.wmu.Lock()
8570 defer cc.wmu.Unlock()
8571 if connAdd != 0 {
8572 cc.fr.WriteWindowUpdate(0, http2mustUint31(connAdd))
8573 }
8574 if streamAdd != 0 {
8575 cc.fr.WriteWindowUpdate(cs.ID, http2mustUint31(streamAdd))
8576 }
8577 cc.bw.Flush()
8578 }
8579 return
8580 }
8581
8582 var http2errClosedResponseBody = errors.New("http2: response body closed")
8583
8584 func (b http2transportResponseBody) Close() error {
8585 cs := b.cs
8586 cc := cs.cc
8587
8588 serverSentStreamEnd := cs.bufPipe.Err() == io.EOF
8589 unread := cs.bufPipe.Len()
8590
8591 if unread > 0 || !serverSentStreamEnd {
8592 cc.mu.Lock()
8593 cc.wmu.Lock()
8594 if !serverSentStreamEnd {
8595 cc.fr.WriteRSTStream(cs.ID, http2ErrCodeCancel)
8596 cs.didReset = true
8597 }
8598
8599 if unread > 0 {
8600 cc.inflow.add(int32(unread))
8601 cc.fr.WriteWindowUpdate(0, uint32(unread))
8602 }
8603 cc.bw.Flush()
8604 cc.wmu.Unlock()
8605 cc.mu.Unlock()
8606 }
8607
8608 cs.bufPipe.BreakWithError(http2errClosedResponseBody)
8609 cc.forgetStreamID(cs.ID)
8610 return nil
8611 }
8612
8613 func (rl *http2clientConnReadLoop) processData(f *http2DataFrame) error {
8614 cc := rl.cc
8615 cs := cc.streamByID(f.StreamID, f.StreamEnded())
8616 data := f.Data()
8617 if cs == nil {
8618 cc.mu.Lock()
8619 neverSent := cc.nextStreamID
8620 cc.mu.Unlock()
8621 if f.StreamID >= neverSent {
8622
8623 cc.logf("http2: Transport received unsolicited DATA frame; closing connection")
8624 return http2ConnectionError(http2ErrCodeProtocol)
8625 }
8626
8627
8628
8629
8630
8631
8632 if f.Length > 0 {
8633 cc.mu.Lock()
8634 cc.inflow.add(int32(f.Length))
8635 cc.mu.Unlock()
8636
8637 cc.wmu.Lock()
8638 cc.fr.WriteWindowUpdate(0, uint32(f.Length))
8639 cc.bw.Flush()
8640 cc.wmu.Unlock()
8641 }
8642 return nil
8643 }
8644 if !cs.firstByte {
8645 cc.logf("protocol error: received DATA before a HEADERS frame")
8646 rl.endStreamError(cs, http2StreamError{
8647 StreamID: f.StreamID,
8648 Code: http2ErrCodeProtocol,
8649 })
8650 return nil
8651 }
8652 if f.Length > 0 {
8653 if cs.req.Method == "HEAD" && len(data) > 0 {
8654 cc.logf("protocol error: received DATA on a HEAD request")
8655 rl.endStreamError(cs, http2StreamError{
8656 StreamID: f.StreamID,
8657 Code: http2ErrCodeProtocol,
8658 })
8659 return nil
8660 }
8661
8662 cc.mu.Lock()
8663 if cs.inflow.available() >= int32(f.Length) {
8664 cs.inflow.take(int32(f.Length))
8665 } else {
8666 cc.mu.Unlock()
8667 return http2ConnectionError(http2ErrCodeFlowControl)
8668 }
8669
8670
8671 var refund int
8672 if pad := int(f.Length) - len(data); pad > 0 {
8673 refund += pad
8674 }
8675
8676
8677 didReset := cs.didReset
8678 if didReset {
8679 refund += len(data)
8680 }
8681 if refund > 0 {
8682 cc.inflow.add(int32(refund))
8683 cc.wmu.Lock()
8684 cc.fr.WriteWindowUpdate(0, uint32(refund))
8685 if !didReset {
8686 cs.inflow.add(int32(refund))
8687 cc.fr.WriteWindowUpdate(cs.ID, uint32(refund))
8688 }
8689 cc.bw.Flush()
8690 cc.wmu.Unlock()
8691 }
8692 cc.mu.Unlock()
8693
8694 if len(data) > 0 && !didReset {
8695 if _, err := cs.bufPipe.Write(data); err != nil {
8696 rl.endStreamError(cs, err)
8697 return err
8698 }
8699 }
8700 }
8701
8702 if f.StreamEnded() {
8703 rl.endStream(cs)
8704 }
8705 return nil
8706 }
8707
8708 func (rl *http2clientConnReadLoop) endStream(cs *http2clientStream) {
8709
8710
8711 rl.endStreamError(cs, nil)
8712 }
8713
8714 func (rl *http2clientConnReadLoop) endStreamError(cs *http2clientStream, err error) {
8715 var code func()
8716 if err == nil {
8717 err = io.EOF
8718 code = cs.copyTrailers
8719 }
8720 if http2isConnectionCloseRequest(cs.req) {
8721 rl.closeWhenIdle = true
8722 }
8723 cs.bufPipe.closeWithErrorAndCode(err, code)
8724
8725 select {
8726 case cs.resc <- http2resAndError{err: err}:
8727 default:
8728 }
8729 }
8730
8731 func (cs *http2clientStream) copyTrailers() {
8732 for k, vv := range cs.trailer {
8733 t := cs.resTrailer
8734 if *t == nil {
8735 *t = make(Header)
8736 }
8737 (*t)[k] = vv
8738 }
8739 }
8740
8741 func (rl *http2clientConnReadLoop) processGoAway(f *http2GoAwayFrame) error {
8742 cc := rl.cc
8743 cc.t.connPool().MarkDead(cc)
8744 if f.ErrCode != 0 {
8745
8746 cc.vlogf("transport got GOAWAY with error code = %v", f.ErrCode)
8747 }
8748 cc.setGoAway(f)
8749 return nil
8750 }
8751
8752 func (rl *http2clientConnReadLoop) processSettings(f *http2SettingsFrame) error {
8753 cc := rl.cc
8754 cc.mu.Lock()
8755 defer cc.mu.Unlock()
8756
8757 if f.IsAck() {
8758 if cc.wantSettingsAck {
8759 cc.wantSettingsAck = false
8760 return nil
8761 }
8762 return http2ConnectionError(http2ErrCodeProtocol)
8763 }
8764
8765 err := f.ForeachSetting(func(s http2Setting) error {
8766 switch s.ID {
8767 case http2SettingMaxFrameSize:
8768 cc.maxFrameSize = s.Val
8769 case http2SettingMaxConcurrentStreams:
8770 cc.maxConcurrentStreams = s.Val
8771 case http2SettingMaxHeaderListSize:
8772 cc.peerMaxHeaderListSize = uint64(s.Val)
8773 case http2SettingInitialWindowSize:
8774
8775
8776
8777
8778 if s.Val > math.MaxInt32 {
8779 return http2ConnectionError(http2ErrCodeFlowControl)
8780 }
8781
8782
8783
8784
8785 delta := int32(s.Val) - int32(cc.initialWindowSize)
8786 for _, cs := range cc.streams {
8787 cs.flow.add(delta)
8788 }
8789 cc.cond.Broadcast()
8790
8791 cc.initialWindowSize = s.Val
8792 default:
8793
8794 cc.vlogf("Unhandled Setting: %v", s)
8795 }
8796 return nil
8797 })
8798 if err != nil {
8799 return err
8800 }
8801
8802 cc.wmu.Lock()
8803 defer cc.wmu.Unlock()
8804
8805 cc.fr.WriteSettingsAck()
8806 cc.bw.Flush()
8807 return cc.werr
8808 }
8809
8810 func (rl *http2clientConnReadLoop) processWindowUpdate(f *http2WindowUpdateFrame) error {
8811 cc := rl.cc
8812 cs := cc.streamByID(f.StreamID, false)
8813 if f.StreamID != 0 && cs == nil {
8814 return nil
8815 }
8816
8817 cc.mu.Lock()
8818 defer cc.mu.Unlock()
8819
8820 fl := &cc.flow
8821 if cs != nil {
8822 fl = &cs.flow
8823 }
8824 if !fl.add(int32(f.Increment)) {
8825 return http2ConnectionError(http2ErrCodeFlowControl)
8826 }
8827 cc.cond.Broadcast()
8828 return nil
8829 }
8830
8831 func (rl *http2clientConnReadLoop) processResetStream(f *http2RSTStreamFrame) error {
8832 cs := rl.cc.streamByID(f.StreamID, true)
8833 if cs == nil {
8834
8835 return nil
8836 }
8837 select {
8838 case <-cs.peerReset:
8839
8840
8841
8842
8843 default:
8844 err := http2streamError(cs.ID, f.ErrCode)
8845 cs.resetErr = err
8846 close(cs.peerReset)
8847 cs.bufPipe.CloseWithError(err)
8848 cs.cc.cond.Broadcast()
8849 }
8850 return nil
8851 }
8852
8853
8854 func (cc *http2ClientConn) Ping(ctx context.Context) error {
8855 c := make(chan struct{})
8856
8857 var p [8]byte
8858 for {
8859 if _, err := rand.Read(p[:]); err != nil {
8860 return err
8861 }
8862 cc.mu.Lock()
8863
8864 if _, found := cc.pings[p]; !found {
8865 cc.pings[p] = c
8866 cc.mu.Unlock()
8867 break
8868 }
8869 cc.mu.Unlock()
8870 }
8871 cc.wmu.Lock()
8872 if err := cc.fr.WritePing(false, p); err != nil {
8873 cc.wmu.Unlock()
8874 return err
8875 }
8876 if err := cc.bw.Flush(); err != nil {
8877 cc.wmu.Unlock()
8878 return err
8879 }
8880 cc.wmu.Unlock()
8881 select {
8882 case <-c:
8883 return nil
8884 case <-ctx.Done():
8885 return ctx.Err()
8886 case <-cc.readerDone:
8887
8888 return cc.readerErr
8889 }
8890 }
8891
8892 func (rl *http2clientConnReadLoop) processPing(f *http2PingFrame) error {
8893 if f.IsAck() {
8894 cc := rl.cc
8895 cc.mu.Lock()
8896 defer cc.mu.Unlock()
8897
8898 if c, ok := cc.pings[f.Data]; ok {
8899 close(c)
8900 delete(cc.pings, f.Data)
8901 }
8902 return nil
8903 }
8904 cc := rl.cc
8905 cc.wmu.Lock()
8906 defer cc.wmu.Unlock()
8907 if err := cc.fr.WritePing(true, f.Data); err != nil {
8908 return err
8909 }
8910 return cc.bw.Flush()
8911 }
8912
8913 func (rl *http2clientConnReadLoop) processPushPromise(f *http2PushPromiseFrame) error {
8914
8915
8916
8917
8918
8919
8920
8921 return http2ConnectionError(http2ErrCodeProtocol)
8922 }
8923
8924 func (cc *http2ClientConn) writeStreamReset(streamID uint32, code http2ErrCode, err error) {
8925
8926
8927
8928
8929 cc.wmu.Lock()
8930 cc.fr.WriteRSTStream(streamID, code)
8931 cc.bw.Flush()
8932 cc.wmu.Unlock()
8933 }
8934
8935 var (
8936 http2errResponseHeaderListSize = errors.New("http2: response header list larger than advertised limit")
8937 http2errRequestHeaderListSize = errors.New("http2: request header list larger than peer's advertised limit")
8938 )
8939
8940 func (cc *http2ClientConn) logf(format string, args ...interface{}) {
8941 cc.t.logf(format, args...)
8942 }
8943
8944 func (cc *http2ClientConn) vlogf(format string, args ...interface{}) {
8945 cc.t.vlogf(format, args...)
8946 }
8947
8948 func (t *http2Transport) vlogf(format string, args ...interface{}) {
8949 if http2VerboseLogs {
8950 t.logf(format, args...)
8951 }
8952 }
8953
8954 func (t *http2Transport) logf(format string, args ...interface{}) {
8955 log.Printf(format, args...)
8956 }
8957
8958 var http2noBody io.ReadCloser = ioutil.NopCloser(bytes.NewReader(nil))
8959
8960 func http2strSliceContains(ss []string, s string) bool {
8961 for _, v := range ss {
8962 if v == s {
8963 return true
8964 }
8965 }
8966 return false
8967 }
8968
8969 type http2erringRoundTripper struct{ err error }
8970
8971 func (rt http2erringRoundTripper) RoundTrip(*Request) (*Response, error) { return nil, rt.err }
8972
8973
8974
8975 type http2gzipReader struct {
8976 _ http2incomparable
8977 body io.ReadCloser
8978 zr *gzip.Reader
8979 zerr error
8980 }
8981
8982 func (gz *http2gzipReader) Read(p []byte) (n int, err error) {
8983 if gz.zerr != nil {
8984 return 0, gz.zerr
8985 }
8986 if gz.zr == nil {
8987 gz.zr, err = gzip.NewReader(gz.body)
8988 if err != nil {
8989 gz.zerr = err
8990 return 0, err
8991 }
8992 }
8993 return gz.zr.Read(p)
8994 }
8995
8996 func (gz *http2gzipReader) Close() error {
8997 return gz.body.Close()
8998 }
8999
9000 type http2errorReader struct{ err error }
9001
9002 func (r http2errorReader) Read(p []byte) (int, error) { return 0, r.err }
9003
9004
9005
9006
9007 type http2bodyWriterState struct {
9008 cs *http2clientStream
9009 timer *time.Timer
9010 fnonce *sync.Once
9011 fn func()
9012 resc chan error
9013 delay time.Duration
9014 }
9015
9016 func (t *http2Transport) getBodyWriterState(cs *http2clientStream, body io.Reader) (s http2bodyWriterState) {
9017 s.cs = cs
9018 if body == nil {
9019 return
9020 }
9021 resc := make(chan error, 1)
9022 s.resc = resc
9023 s.fn = func() {
9024 cs.cc.mu.Lock()
9025 cs.startedWrite = true
9026 cs.cc.mu.Unlock()
9027 resc <- cs.writeRequestBody(body, cs.req.Body)
9028 }
9029 s.delay = t.expectContinueTimeout()
9030 if s.delay == 0 ||
9031 !httpguts.HeaderValuesContainsToken(
9032 cs.req.Header["Expect"],
9033 "100-continue") {
9034 return
9035 }
9036 s.fnonce = new(sync.Once)
9037
9038
9039
9040
9041
9042
9043 const hugeDuration = 365 * 24 * time.Hour
9044 s.timer = time.AfterFunc(hugeDuration, func() {
9045 s.fnonce.Do(s.fn)
9046 })
9047 return
9048 }
9049
9050 func (s http2bodyWriterState) cancel() {
9051 if s.timer != nil {
9052 s.timer.Stop()
9053 }
9054 }
9055
9056 func (s http2bodyWriterState) on100() {
9057 if s.timer == nil {
9058
9059
9060 return
9061 }
9062 s.timer.Stop()
9063 go func() { s.fnonce.Do(s.fn) }()
9064 }
9065
9066
9067
9068
9069 func (s http2bodyWriterState) scheduleBodyWrite() {
9070 if s.timer == nil {
9071
9072
9073
9074 go s.fn()
9075 return
9076 }
9077 http2traceWait100Continue(s.cs.trace)
9078 if s.timer.Stop() {
9079 s.timer.Reset(s.delay)
9080 }
9081 }
9082
9083
9084
9085 func http2isConnectionCloseRequest(req *Request) bool {
9086 return req.Close || httpguts.HeaderValuesContainsToken(req.Header["Connection"], "close")
9087 }
9088
9089
9090
9091 func http2registerHTTPSProtocol(t *Transport, rt http2noDialH2RoundTripper) (err error) {
9092 defer func() {
9093 if e := recover(); e != nil {
9094 err = fmt.Errorf("%v", e)
9095 }
9096 }()
9097 t.RegisterProtocol("https", rt)
9098 return nil
9099 }
9100
9101
9102
9103
9104
9105 type http2noDialH2RoundTripper struct{ *http2Transport }
9106
9107 func (rt http2noDialH2RoundTripper) RoundTrip(req *Request) (*Response, error) {
9108 res, err := rt.http2Transport.RoundTrip(req)
9109 if http2isNoCachedConnError(err) {
9110 return nil, ErrSkipAltProtocol
9111 }
9112 return res, err
9113 }
9114
9115 func (t *http2Transport) idleConnTimeout() time.Duration {
9116 if t.t1 != nil {
9117 return t.t1.IdleConnTimeout
9118 }
9119 return 0
9120 }
9121
9122 func http2traceGetConn(req *Request, hostPort string) {
9123 trace := httptrace.ContextClientTrace(req.Context())
9124 if trace == nil || trace.GetConn == nil {
9125 return
9126 }
9127 trace.GetConn(hostPort)
9128 }
9129
9130 func http2traceGotConn(req *Request, cc *http2ClientConn, reused bool) {
9131 trace := httptrace.ContextClientTrace(req.Context())
9132 if trace == nil || trace.GotConn == nil {
9133 return
9134 }
9135 ci := httptrace.GotConnInfo{Conn: cc.tconn}
9136 ci.Reused = reused
9137 cc.mu.Lock()
9138 ci.WasIdle = len(cc.streams) == 0 && reused
9139 if ci.WasIdle && !cc.lastActive.IsZero() {
9140 ci.IdleTime = time.Now().Sub(cc.lastActive)
9141 }
9142 cc.mu.Unlock()
9143
9144 trace.GotConn(ci)
9145 }
9146
9147 func http2traceWroteHeaders(trace *httptrace.ClientTrace) {
9148 if trace != nil && trace.WroteHeaders != nil {
9149 trace.WroteHeaders()
9150 }
9151 }
9152
9153 func http2traceGot100Continue(trace *httptrace.ClientTrace) {
9154 if trace != nil && trace.Got100Continue != nil {
9155 trace.Got100Continue()
9156 }
9157 }
9158
9159 func http2traceWait100Continue(trace *httptrace.ClientTrace) {
9160 if trace != nil && trace.Wait100Continue != nil {
9161 trace.Wait100Continue()
9162 }
9163 }
9164
9165 func http2traceWroteRequest(trace *httptrace.ClientTrace, err error) {
9166 if trace != nil && trace.WroteRequest != nil {
9167 trace.WroteRequest(httptrace.WroteRequestInfo{Err: err})
9168 }
9169 }
9170
9171 func http2traceFirstResponseByte(trace *httptrace.ClientTrace) {
9172 if trace != nil && trace.GotFirstResponseByte != nil {
9173 trace.GotFirstResponseByte()
9174 }
9175 }
9176
9177
9178 type http2writeFramer interface {
9179 writeFrame(http2writeContext) error
9180
9181
9182
9183
9184 staysWithinBuffer(size int) bool
9185 }
9186
9187
9188
9189
9190
9191
9192
9193
9194
9195
9196
9197 type http2writeContext interface {
9198 Framer() *http2Framer
9199 Flush() error
9200 CloseConn() error
9201
9202
9203 HeaderEncoder() (*hpack.Encoder, *bytes.Buffer)
9204 }
9205
9206
9207
9208
9209 func http2writeEndsStream(w http2writeFramer) bool {
9210 switch v := w.(type) {
9211 case *http2writeData:
9212 return v.endStream
9213 case *http2writeResHeaders:
9214 return v.endStream
9215 case nil:
9216
9217
9218
9219 panic("writeEndsStream called on nil writeFramer")
9220 }
9221 return false
9222 }
9223
9224 type http2flushFrameWriter struct{}
9225
9226 func (http2flushFrameWriter) writeFrame(ctx http2writeContext) error {
9227 return ctx.Flush()
9228 }
9229
9230 func (http2flushFrameWriter) staysWithinBuffer(max int) bool { return false }
9231
9232 type http2writeSettings []http2Setting
9233
9234 func (s http2writeSettings) staysWithinBuffer(max int) bool {
9235 const settingSize = 6
9236 return http2frameHeaderLen+settingSize*len(s) <= max
9237
9238 }
9239
9240 func (s http2writeSettings) writeFrame(ctx http2writeContext) error {
9241 return ctx.Framer().WriteSettings([]http2Setting(s)...)
9242 }
9243
9244 type http2writeGoAway struct {
9245 maxStreamID uint32
9246 code http2ErrCode
9247 }
9248
9249 func (p *http2writeGoAway) writeFrame(ctx http2writeContext) error {
9250 err := ctx.Framer().WriteGoAway(p.maxStreamID, p.code, nil)
9251 ctx.Flush()
9252 return err
9253 }
9254
9255 func (*http2writeGoAway) staysWithinBuffer(max int) bool { return false }
9256
9257 type http2writeData struct {
9258 streamID uint32
9259 p []byte
9260 endStream bool
9261 }
9262
9263 func (w *http2writeData) String() string {
9264 return fmt.Sprintf("writeData(stream=%d, p=%d, endStream=%v)", w.streamID, len(w.p), w.endStream)
9265 }
9266
9267 func (w *http2writeData) writeFrame(ctx http2writeContext) error {
9268 return ctx.Framer().WriteData(w.streamID, w.endStream, w.p)
9269 }
9270
9271 func (w *http2writeData) staysWithinBuffer(max int) bool {
9272 return http2frameHeaderLen+len(w.p) <= max
9273 }
9274
9275
9276
9277 type http2handlerPanicRST struct {
9278 StreamID uint32
9279 }
9280
9281 func (hp http2handlerPanicRST) writeFrame(ctx http2writeContext) error {
9282 return ctx.Framer().WriteRSTStream(hp.StreamID, http2ErrCodeInternal)
9283 }
9284
9285 func (hp http2handlerPanicRST) staysWithinBuffer(max int) bool { return http2frameHeaderLen+4 <= max }
9286
9287 func (se http2StreamError) writeFrame(ctx http2writeContext) error {
9288 return ctx.Framer().WriteRSTStream(se.StreamID, se.Code)
9289 }
9290
9291 func (se http2StreamError) staysWithinBuffer(max int) bool { return http2frameHeaderLen+4 <= max }
9292
9293 type http2writePingAck struct{ pf *http2PingFrame }
9294
9295 func (w http2writePingAck) writeFrame(ctx http2writeContext) error {
9296 return ctx.Framer().WritePing(true, w.pf.Data)
9297 }
9298
9299 func (w http2writePingAck) staysWithinBuffer(max int) bool {
9300 return http2frameHeaderLen+len(w.pf.Data) <= max
9301 }
9302
9303 type http2writeSettingsAck struct{}
9304
9305 func (http2writeSettingsAck) writeFrame(ctx http2writeContext) error {
9306 return ctx.Framer().WriteSettingsAck()
9307 }
9308
9309 func (http2writeSettingsAck) staysWithinBuffer(max int) bool { return http2frameHeaderLen <= max }
9310
9311
9312
9313
9314 func http2splitHeaderBlock(ctx http2writeContext, headerBlock []byte, fn func(ctx http2writeContext, frag []byte, firstFrag, lastFrag bool) error) error {
9315
9316
9317
9318
9319
9320
9321 const maxFrameSize = 16384
9322
9323 first := true
9324 for len(headerBlock) > 0 {
9325 frag := headerBlock
9326 if len(frag) > maxFrameSize {
9327 frag = frag[:maxFrameSize]
9328 }
9329 headerBlock = headerBlock[len(frag):]
9330 if err := fn(ctx, frag, first, len(headerBlock) == 0); err != nil {
9331 return err
9332 }
9333 first = false
9334 }
9335 return nil
9336 }
9337
9338
9339
9340 type http2writeResHeaders struct {
9341 streamID uint32
9342 httpResCode int
9343 h Header
9344 trailers []string
9345 endStream bool
9346
9347 date string
9348 contentType string
9349 contentLength string
9350 }
9351
9352 func http2encKV(enc *hpack.Encoder, k, v string) {
9353 if http2VerboseLogs {
9354 log.Printf("http2: server encoding header %q = %q", k, v)
9355 }
9356 enc.WriteField(hpack.HeaderField{Name: k, Value: v})
9357 }
9358
9359 func (w *http2writeResHeaders) staysWithinBuffer(max int) bool {
9360
9361
9362
9363
9364
9365
9366
9367 return false
9368 }
9369
9370 func (w *http2writeResHeaders) writeFrame(ctx http2writeContext) error {
9371 enc, buf := ctx.HeaderEncoder()
9372 buf.Reset()
9373
9374 if w.httpResCode != 0 {
9375 http2encKV(enc, ":status", http2httpCodeString(w.httpResCode))
9376 }
9377
9378 http2encodeHeaders(enc, w.h, w.trailers)
9379
9380 if w.contentType != "" {
9381 http2encKV(enc, "content-type", w.contentType)
9382 }
9383 if w.contentLength != "" {
9384 http2encKV(enc, "content-length", w.contentLength)
9385 }
9386 if w.date != "" {
9387 http2encKV(enc, "date", w.date)
9388 }
9389
9390 headerBlock := buf.Bytes()
9391 if len(headerBlock) == 0 && w.trailers == nil {
9392 panic("unexpected empty hpack")
9393 }
9394
9395 return http2splitHeaderBlock(ctx, headerBlock, w.writeHeaderBlock)
9396 }
9397
9398 func (w *http2writeResHeaders) writeHeaderBlock(ctx http2writeContext, frag []byte, firstFrag, lastFrag bool) error {
9399 if firstFrag {
9400 return ctx.Framer().WriteHeaders(http2HeadersFrameParam{
9401 StreamID: w.streamID,
9402 BlockFragment: frag,
9403 EndStream: w.endStream,
9404 EndHeaders: lastFrag,
9405 })
9406 } else {
9407 return ctx.Framer().WriteContinuation(w.streamID, lastFrag, frag)
9408 }
9409 }
9410
9411
9412 type http2writePushPromise struct {
9413 streamID uint32
9414 method string
9415 url *url.URL
9416 h Header
9417
9418
9419
9420 allocatePromisedID func() (uint32, error)
9421 promisedID uint32
9422 }
9423
9424 func (w *http2writePushPromise) staysWithinBuffer(max int) bool {
9425
9426 return false
9427 }
9428
9429 func (w *http2writePushPromise) writeFrame(ctx http2writeContext) error {
9430 enc, buf := ctx.HeaderEncoder()
9431 buf.Reset()
9432
9433 http2encKV(enc, ":method", w.method)
9434 http2encKV(enc, ":scheme", w.url.Scheme)
9435 http2encKV(enc, ":authority", w.url.Host)
9436 http2encKV(enc, ":path", w.url.RequestURI())
9437 http2encodeHeaders(enc, w.h, nil)
9438
9439 headerBlock := buf.Bytes()
9440 if len(headerBlock) == 0 {
9441 panic("unexpected empty hpack")
9442 }
9443
9444 return http2splitHeaderBlock(ctx, headerBlock, w.writeHeaderBlock)
9445 }
9446
9447 func (w *http2writePushPromise) writeHeaderBlock(ctx http2writeContext, frag []byte, firstFrag, lastFrag bool) error {
9448 if firstFrag {
9449 return ctx.Framer().WritePushPromise(http2PushPromiseParam{
9450 StreamID: w.streamID,
9451 PromiseID: w.promisedID,
9452 BlockFragment: frag,
9453 EndHeaders: lastFrag,
9454 })
9455 } else {
9456 return ctx.Framer().WriteContinuation(w.streamID, lastFrag, frag)
9457 }
9458 }
9459
9460 type http2write100ContinueHeadersFrame struct {
9461 streamID uint32
9462 }
9463
9464 func (w http2write100ContinueHeadersFrame) writeFrame(ctx http2writeContext) error {
9465 enc, buf := ctx.HeaderEncoder()
9466 buf.Reset()
9467 http2encKV(enc, ":status", "100")
9468 return ctx.Framer().WriteHeaders(http2HeadersFrameParam{
9469 StreamID: w.streamID,
9470 BlockFragment: buf.Bytes(),
9471 EndStream: false,
9472 EndHeaders: true,
9473 })
9474 }
9475
9476 func (w http2write100ContinueHeadersFrame) staysWithinBuffer(max int) bool {
9477
9478 return 9+2*(len(":status")+len("100")) <= max
9479 }
9480
9481 type http2writeWindowUpdate struct {
9482 streamID uint32
9483 n uint32
9484 }
9485
9486 func (wu http2writeWindowUpdate) staysWithinBuffer(max int) bool { return http2frameHeaderLen+4 <= max }
9487
9488 func (wu http2writeWindowUpdate) writeFrame(ctx http2writeContext) error {
9489 return ctx.Framer().WriteWindowUpdate(wu.streamID, wu.n)
9490 }
9491
9492
9493
9494 func http2encodeHeaders(enc *hpack.Encoder, h Header, keys []string) {
9495 if keys == nil {
9496 sorter := http2sorterPool.Get().(*http2sorter)
9497
9498
9499
9500 defer http2sorterPool.Put(sorter)
9501 keys = sorter.Keys(h)
9502 }
9503 for _, k := range keys {
9504 vv := h[k]
9505 k = http2lowerHeader(k)
9506 if !http2validWireHeaderFieldName(k) {
9507
9508
9509
9510 continue
9511 }
9512 isTE := k == "transfer-encoding"
9513 for _, v := range vv {
9514 if !httpguts.ValidHeaderFieldValue(v) {
9515
9516
9517 continue
9518 }
9519
9520 if isTE && v != "trailers" {
9521 continue
9522 }
9523 http2encKV(enc, k, v)
9524 }
9525 }
9526 }
9527
9528
9529
9530 type http2WriteScheduler interface {
9531
9532
9533
9534 OpenStream(streamID uint32, options http2OpenStreamOptions)
9535
9536
9537
9538
9539 CloseStream(streamID uint32)
9540
9541
9542
9543
9544
9545 AdjustStream(streamID uint32, priority http2PriorityParam)
9546
9547
9548
9549
9550 Push(wr http2FrameWriteRequest)
9551
9552
9553
9554
9555 Pop() (wr http2FrameWriteRequest, ok bool)
9556 }
9557
9558
9559 type http2OpenStreamOptions struct {
9560
9561
9562 PusherID uint32
9563 }
9564
9565
9566 type http2FrameWriteRequest struct {
9567
9568
9569
9570 write http2writeFramer
9571
9572
9573
9574 stream *http2stream
9575
9576
9577
9578
9579 done chan error
9580 }
9581
9582
9583
9584 func (wr http2FrameWriteRequest) StreamID() uint32 {
9585 if wr.stream == nil {
9586 if se, ok := wr.write.(http2StreamError); ok {
9587
9588
9589
9590
9591 return se.StreamID
9592 }
9593 return 0
9594 }
9595 return wr.stream.id
9596 }
9597
9598
9599
9600 func (wr http2FrameWriteRequest) isControl() bool {
9601 return wr.stream == nil
9602 }
9603
9604
9605
9606 func (wr http2FrameWriteRequest) DataSize() int {
9607 if wd, ok := wr.write.(*http2writeData); ok {
9608 return len(wd.p)
9609 }
9610 return 0
9611 }
9612
9613
9614
9615
9616
9617
9618
9619
9620
9621
9622
9623 func (wr http2FrameWriteRequest) Consume(n int32) (http2FrameWriteRequest, http2FrameWriteRequest, int) {
9624 var empty http2FrameWriteRequest
9625
9626
9627 wd, ok := wr.write.(*http2writeData)
9628 if !ok || len(wd.p) == 0 {
9629 return wr, empty, 1
9630 }
9631
9632
9633 allowed := wr.stream.flow.available()
9634 if n < allowed {
9635 allowed = n
9636 }
9637 if wr.stream.sc.maxFrameSize < allowed {
9638 allowed = wr.stream.sc.maxFrameSize
9639 }
9640 if allowed <= 0 {
9641 return empty, empty, 0
9642 }
9643 if len(wd.p) > int(allowed) {
9644 wr.stream.flow.take(allowed)
9645 consumed := http2FrameWriteRequest{
9646 stream: wr.stream,
9647 write: &http2writeData{
9648 streamID: wd.streamID,
9649 p: wd.p[:allowed],
9650
9651
9652
9653 endStream: false,
9654 },
9655
9656
9657 done: nil,
9658 }
9659 rest := http2FrameWriteRequest{
9660 stream: wr.stream,
9661 write: &http2writeData{
9662 streamID: wd.streamID,
9663 p: wd.p[allowed:],
9664 endStream: wd.endStream,
9665 },
9666 done: wr.done,
9667 }
9668 return consumed, rest, 2
9669 }
9670
9671
9672
9673 wr.stream.flow.take(int32(len(wd.p)))
9674 return wr, empty, 1
9675 }
9676
9677
9678 func (wr http2FrameWriteRequest) String() string {
9679 var des string
9680 if s, ok := wr.write.(fmt.Stringer); ok {
9681 des = s.String()
9682 } else {
9683 des = fmt.Sprintf("%T", wr.write)
9684 }
9685 return fmt.Sprintf("[FrameWriteRequest stream=%d, ch=%v, writer=%v]", wr.StreamID(), wr.done != nil, des)
9686 }
9687
9688
9689
9690 func (wr *http2FrameWriteRequest) replyToWriter(err error) {
9691 if wr.done == nil {
9692 return
9693 }
9694 select {
9695 case wr.done <- err:
9696 default:
9697 panic(fmt.Sprintf("unbuffered done channel passed in for type %T", wr.write))
9698 }
9699 wr.write = nil
9700 }
9701
9702
9703 type http2writeQueue struct {
9704 s []http2FrameWriteRequest
9705 }
9706
9707 func (q *http2writeQueue) empty() bool { return len(q.s) == 0 }
9708
9709 func (q *http2writeQueue) push(wr http2FrameWriteRequest) {
9710 q.s = append(q.s, wr)
9711 }
9712
9713 func (q *http2writeQueue) shift() http2FrameWriteRequest {
9714 if len(q.s) == 0 {
9715 panic("invalid use of queue")
9716 }
9717 wr := q.s[0]
9718
9719 copy(q.s, q.s[1:])
9720 q.s[len(q.s)-1] = http2FrameWriteRequest{}
9721 q.s = q.s[:len(q.s)-1]
9722 return wr
9723 }
9724
9725
9726
9727
9728
9729 func (q *http2writeQueue) consume(n int32) (http2FrameWriteRequest, bool) {
9730 if len(q.s) == 0 {
9731 return http2FrameWriteRequest{}, false
9732 }
9733 consumed, rest, numresult := q.s[0].Consume(n)
9734 switch numresult {
9735 case 0:
9736 return http2FrameWriteRequest{}, false
9737 case 1:
9738 q.shift()
9739 case 2:
9740 q.s[0] = rest
9741 }
9742 return consumed, true
9743 }
9744
9745 type http2writeQueuePool []*http2writeQueue
9746
9747
9748
9749
9750 func (p *http2writeQueuePool) put(q *http2writeQueue) {
9751 for i := range q.s {
9752 q.s[i] = http2FrameWriteRequest{}
9753 }
9754 q.s = q.s[:0]
9755 *p = append(*p, q)
9756 }
9757
9758
9759 func (p *http2writeQueuePool) get() *http2writeQueue {
9760 ln := len(*p)
9761 if ln == 0 {
9762 return new(http2writeQueue)
9763 }
9764 x := ln - 1
9765 q := (*p)[x]
9766 (*p)[x] = nil
9767 *p = (*p)[:x]
9768 return q
9769 }
9770
9771
9772 const http2priorityDefaultWeight = 15
9773
9774
9775 type http2PriorityWriteSchedulerConfig struct {
9776
9777
9778
9779
9780
9781
9782
9783
9784
9785
9786
9787
9788 MaxClosedNodesInTree int
9789
9790
9791
9792
9793
9794
9795
9796
9797
9798
9799
9800 MaxIdleNodesInTree int
9801
9802
9803
9804
9805
9806
9807
9808
9809
9810 ThrottleOutOfOrderWrites bool
9811 }
9812
9813
9814
9815
9816 func http2NewPriorityWriteScheduler(cfg *http2PriorityWriteSchedulerConfig) http2WriteScheduler {
9817 if cfg == nil {
9818
9819
9820 cfg = &http2PriorityWriteSchedulerConfig{
9821 MaxClosedNodesInTree: 10,
9822 MaxIdleNodesInTree: 10,
9823 ThrottleOutOfOrderWrites: false,
9824 }
9825 }
9826
9827 ws := &http2priorityWriteScheduler{
9828 nodes: make(map[uint32]*http2priorityNode),
9829 maxClosedNodesInTree: cfg.MaxClosedNodesInTree,
9830 maxIdleNodesInTree: cfg.MaxIdleNodesInTree,
9831 enableWriteThrottle: cfg.ThrottleOutOfOrderWrites,
9832 }
9833 ws.nodes[0] = &ws.root
9834 if cfg.ThrottleOutOfOrderWrites {
9835 ws.writeThrottleLimit = 1024
9836 } else {
9837 ws.writeThrottleLimit = math.MaxInt32
9838 }
9839 return ws
9840 }
9841
9842 type http2priorityNodeState int
9843
9844 const (
9845 http2priorityNodeOpen http2priorityNodeState = iota
9846 http2priorityNodeClosed
9847 http2priorityNodeIdle
9848 )
9849
9850
9851
9852
9853 type http2priorityNode struct {
9854 q http2writeQueue
9855 id uint32
9856 weight uint8
9857 state http2priorityNodeState
9858 bytes int64
9859 subtreeBytes int64
9860
9861
9862 parent *http2priorityNode
9863 kids *http2priorityNode
9864 prev, next *http2priorityNode
9865 }
9866
9867 func (n *http2priorityNode) setParent(parent *http2priorityNode) {
9868 if n == parent {
9869 panic("setParent to self")
9870 }
9871 if n.parent == parent {
9872 return
9873 }
9874
9875 if parent := n.parent; parent != nil {
9876 if n.prev == nil {
9877 parent.kids = n.next
9878 } else {
9879 n.prev.next = n.next
9880 }
9881 if n.next != nil {
9882 n.next.prev = n.prev
9883 }
9884 }
9885
9886
9887
9888 n.parent = parent
9889 if parent == nil {
9890 n.next = nil
9891 n.prev = nil
9892 } else {
9893 n.next = parent.kids
9894 n.prev = nil
9895 if n.next != nil {
9896 n.next.prev = n
9897 }
9898 parent.kids = n
9899 }
9900 }
9901
9902 func (n *http2priorityNode) addBytes(b int64) {
9903 n.bytes += b
9904 for ; n != nil; n = n.parent {
9905 n.subtreeBytes += b
9906 }
9907 }
9908
9909
9910
9911
9912
9913
9914
9915 func (n *http2priorityNode) walkReadyInOrder(openParent bool, tmp *[]*http2priorityNode, f func(*http2priorityNode, bool) bool) bool {
9916 if !n.q.empty() && f(n, openParent) {
9917 return true
9918 }
9919 if n.kids == nil {
9920 return false
9921 }
9922
9923
9924
9925 if n.id != 0 {
9926 openParent = openParent || (n.state == http2priorityNodeOpen)
9927 }
9928
9929
9930
9931
9932 w := n.kids.weight
9933 needSort := false
9934 for k := n.kids.next; k != nil; k = k.next {
9935 if k.weight != w {
9936 needSort = true
9937 break
9938 }
9939 }
9940 if !needSort {
9941 for k := n.kids; k != nil; k = k.next {
9942 if k.walkReadyInOrder(openParent, tmp, f) {
9943 return true
9944 }
9945 }
9946 return false
9947 }
9948
9949
9950
9951 *tmp = (*tmp)[:0]
9952 for n.kids != nil {
9953 *tmp = append(*tmp, n.kids)
9954 n.kids.setParent(nil)
9955 }
9956 sort.Sort(http2sortPriorityNodeSiblings(*tmp))
9957 for i := len(*tmp) - 1; i >= 0; i-- {
9958 (*tmp)[i].setParent(n)
9959 }
9960 for k := n.kids; k != nil; k = k.next {
9961 if k.walkReadyInOrder(openParent, tmp, f) {
9962 return true
9963 }
9964 }
9965 return false
9966 }
9967
9968 type http2sortPriorityNodeSiblings []*http2priorityNode
9969
9970 func (z http2sortPriorityNodeSiblings) Len() int { return len(z) }
9971
9972 func (z http2sortPriorityNodeSiblings) Swap(i, k int) { z[i], z[k] = z[k], z[i] }
9973
9974 func (z http2sortPriorityNodeSiblings) Less(i, k int) bool {
9975
9976
9977 wi, bi := float64(z[i].weight+1), float64(z[i].subtreeBytes)
9978 wk, bk := float64(z[k].weight+1), float64(z[k].subtreeBytes)
9979 if bi == 0 && bk == 0 {
9980 return wi >= wk
9981 }
9982 if bk == 0 {
9983 return false
9984 }
9985 return bi/bk <= wi/wk
9986 }
9987
9988 type http2priorityWriteScheduler struct {
9989
9990
9991 root http2priorityNode
9992
9993
9994 nodes map[uint32]*http2priorityNode
9995
9996
9997 maxID uint32
9998
9999
10000
10001
10002 closedNodes, idleNodes []*http2priorityNode
10003
10004
10005 maxClosedNodesInTree int
10006 maxIdleNodesInTree int
10007 writeThrottleLimit int32
10008 enableWriteThrottle bool
10009
10010
10011 tmp []*http2priorityNode
10012
10013
10014 queuePool http2writeQueuePool
10015 }
10016
10017 func (ws *http2priorityWriteScheduler) OpenStream(streamID uint32, options http2OpenStreamOptions) {
10018
10019 if curr := ws.nodes[streamID]; curr != nil {
10020 if curr.state != http2priorityNodeIdle {
10021 panic(fmt.Sprintf("stream %d already opened", streamID))
10022 }
10023 curr.state = http2priorityNodeOpen
10024 return
10025 }
10026
10027
10028
10029
10030
10031 parent := ws.nodes[options.PusherID]
10032 if parent == nil {
10033 parent = &ws.root
10034 }
10035 n := &http2priorityNode{
10036 q: *ws.queuePool.get(),
10037 id: streamID,
10038 weight: http2priorityDefaultWeight,
10039 state: http2priorityNodeOpen,
10040 }
10041 n.setParent(parent)
10042 ws.nodes[streamID] = n
10043 if streamID > ws.maxID {
10044 ws.maxID = streamID
10045 }
10046 }
10047
10048 func (ws *http2priorityWriteScheduler) CloseStream(streamID uint32) {
10049 if streamID == 0 {
10050 panic("violation of WriteScheduler interface: cannot close stream 0")
10051 }
10052 if ws.nodes[streamID] == nil {
10053 panic(fmt.Sprintf("violation of WriteScheduler interface: unknown stream %d", streamID))
10054 }
10055 if ws.nodes[streamID].state != http2priorityNodeOpen {
10056 panic(fmt.Sprintf("violation of WriteScheduler interface: stream %d already closed", streamID))
10057 }
10058
10059 n := ws.nodes[streamID]
10060 n.state = http2priorityNodeClosed
10061 n.addBytes(-n.bytes)
10062
10063 q := n.q
10064 ws.queuePool.put(&q)
10065 n.q.s = nil
10066 if ws.maxClosedNodesInTree > 0 {
10067 ws.addClosedOrIdleNode(&ws.closedNodes, ws.maxClosedNodesInTree, n)
10068 } else {
10069 ws.removeNode(n)
10070 }
10071 }
10072
10073 func (ws *http2priorityWriteScheduler) AdjustStream(streamID uint32, priority http2PriorityParam) {
10074 if streamID == 0 {
10075 panic("adjustPriority on root")
10076 }
10077
10078
10079
10080
10081 n := ws.nodes[streamID]
10082 if n == nil {
10083 if streamID <= ws.maxID || ws.maxIdleNodesInTree == 0 {
10084 return
10085 }
10086 ws.maxID = streamID
10087 n = &http2priorityNode{
10088 q: *ws.queuePool.get(),
10089 id: streamID,
10090 weight: http2priorityDefaultWeight,
10091 state: http2priorityNodeIdle,
10092 }
10093 n.setParent(&ws.root)
10094 ws.nodes[streamID] = n
10095 ws.addClosedOrIdleNode(&ws.idleNodes, ws.maxIdleNodesInTree, n)
10096 }
10097
10098
10099
10100 parent := ws.nodes[priority.StreamDep]
10101 if parent == nil {
10102 n.setParent(&ws.root)
10103 n.weight = http2priorityDefaultWeight
10104 return
10105 }
10106
10107
10108 if n == parent {
10109 return
10110 }
10111
10112
10113
10114
10115
10116
10117
10118
10119 for x := parent.parent; x != nil; x = x.parent {
10120 if x == n {
10121 parent.setParent(n.parent)
10122 break
10123 }
10124 }
10125
10126
10127
10128
10129 if priority.Exclusive {
10130 k := parent.kids
10131 for k != nil {
10132 next := k.next
10133 if k != n {
10134 k.setParent(n)
10135 }
10136 k = next
10137 }
10138 }
10139
10140 n.setParent(parent)
10141 n.weight = priority.Weight
10142 }
10143
10144 func (ws *http2priorityWriteScheduler) Push(wr http2FrameWriteRequest) {
10145 var n *http2priorityNode
10146 if id := wr.StreamID(); id == 0 {
10147 n = &ws.root
10148 } else {
10149 n = ws.nodes[id]
10150 if n == nil {
10151
10152
10153
10154
10155
10156 if wr.DataSize() > 0 {
10157 panic("add DATA on non-open stream")
10158 }
10159 n = &ws.root
10160 }
10161 }
10162 n.q.push(wr)
10163 }
10164
10165 func (ws *http2priorityWriteScheduler) Pop() (wr http2FrameWriteRequest, ok bool) {
10166 ws.root.walkReadyInOrder(false, &ws.tmp, func(n *http2priorityNode, openParent bool) bool {
10167 limit := int32(math.MaxInt32)
10168 if openParent {
10169 limit = ws.writeThrottleLimit
10170 }
10171 wr, ok = n.q.consume(limit)
10172 if !ok {
10173 return false
10174 }
10175 n.addBytes(int64(wr.DataSize()))
10176
10177
10178
10179 if openParent {
10180 ws.writeThrottleLimit += 1024
10181 if ws.writeThrottleLimit < 0 {
10182 ws.writeThrottleLimit = math.MaxInt32
10183 }
10184 } else if ws.enableWriteThrottle {
10185 ws.writeThrottleLimit = 1024
10186 }
10187 return true
10188 })
10189 return wr, ok
10190 }
10191
10192 func (ws *http2priorityWriteScheduler) addClosedOrIdleNode(list *[]*http2priorityNode, maxSize int, n *http2priorityNode) {
10193 if maxSize == 0 {
10194 return
10195 }
10196 if len(*list) == maxSize {
10197
10198 ws.removeNode((*list)[0])
10199 x := (*list)[1:]
10200 copy(*list, x)
10201 *list = (*list)[:len(x)]
10202 }
10203 *list = append(*list, n)
10204 }
10205
10206 func (ws *http2priorityWriteScheduler) removeNode(n *http2priorityNode) {
10207 for k := n.kids; k != nil; k = k.next {
10208 k.setParent(n.parent)
10209 }
10210 n.setParent(nil)
10211 delete(ws.nodes, n.id)
10212 }
10213
10214
10215
10216
10217
10218 func http2NewRandomWriteScheduler() http2WriteScheduler {
10219 return &http2randomWriteScheduler{sq: make(map[uint32]*http2writeQueue)}
10220 }
10221
10222 type http2randomWriteScheduler struct {
10223
10224 zero http2writeQueue
10225
10226
10227
10228
10229 sq map[uint32]*http2writeQueue
10230
10231
10232 queuePool http2writeQueuePool
10233 }
10234
10235 func (ws *http2randomWriteScheduler) OpenStream(streamID uint32, options http2OpenStreamOptions) {
10236
10237 }
10238
10239 func (ws *http2randomWriteScheduler) CloseStream(streamID uint32) {
10240 q, ok := ws.sq[streamID]
10241 if !ok {
10242 return
10243 }
10244 delete(ws.sq, streamID)
10245 ws.queuePool.put(q)
10246 }
10247
10248 func (ws *http2randomWriteScheduler) AdjustStream(streamID uint32, priority http2PriorityParam) {
10249
10250 }
10251
10252 func (ws *http2randomWriteScheduler) Push(wr http2FrameWriteRequest) {
10253 id := wr.StreamID()
10254 if id == 0 {
10255 ws.zero.push(wr)
10256 return
10257 }
10258 q, ok := ws.sq[id]
10259 if !ok {
10260 q = ws.queuePool.get()
10261 ws.sq[id] = q
10262 }
10263 q.push(wr)
10264 }
10265
10266 func (ws *http2randomWriteScheduler) Pop() (http2FrameWriteRequest, bool) {
10267
10268 if !ws.zero.empty() {
10269 return ws.zero.shift(), true
10270 }
10271
10272 for streamID, q := range ws.sq {
10273 if wr, ok := q.consume(math.MaxInt32); ok {
10274 if q.empty() {
10275 delete(ws.sq, streamID)
10276 ws.queuePool.put(q)
10277 }
10278 return wr, true
10279 }
10280 }
10281 return http2FrameWriteRequest{}, false
10282 }
10283
View as plain text