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