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