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