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