Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2025-05-25 12:27
📄 .gitignore *~ h2i/h2i	11 B	2025-05-25 12:27
📄 ascii.go // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import "strings" // The HTTP protocols are defined in terms of ASCII, not Unicode. This file // contains helper functions which may use Unicode-aware functions which would // otherwise be unsafe and could introduce vulnerabilities if used improperly. // asciiEqualFold is strings.EqualFold, ASCII only. It reports whether s and t // are equal, ASCII-case-insensitively. func asciiEqualFold(s, t string) bool { if len(s) != len(t) { return false } for i := 0; i < len(s); i++ { if lower(s[i]) != lower(t[i]) { return false } } return true } // lower returns the ASCII lowercase version of b. func lower(b byte) byte { if 'A' <= b && b <= 'Z' { return b + ('a' - 'A') } return b } // isASCIIPrint returns whether s is ASCII and printable according to // https://tools.ietf.org/html/rfc20#section-4.2. func isASCIIPrint(s string) bool { for i := 0; i < len(s); i++ { if s[i] < ' ' \|\| s[i] > '~' { return false } } return true } // asciiToLower returns the lowercase version of s if s is ASCII and printable, // and whether or not it was. func asciiToLower(s string) (lower string, ok bool) { if !isASCIIPrint(s) { return "", false } return strings.ToLower(s), true }	1.35 KB	2025-05-25 12:27
📄 ascii_test.go // Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import "testing" func TestASCIIEqualFold(t testing.T) { var tests = []struct { name string a, b string want bool }{ { name: "empty", want: true, }, { name: "simple match", a: "CHUNKED", b: "chunked", want: true, }, { name: "same string", a: "chunked", b: "chunked", want: true, }, { name: "Unicode Kelvin symbol", a: "chunKed", // This "K" is 'KELVIN SIGN' (\u212A) b: "chunked", want: false, }, } for _, tt := range tests { t.Run(tt.name, func(t testing.T) { if got := asciiEqualFold(tt.a, tt.b); got != tt.want { t.Errorf("AsciiEqualFold(%q,%q): got %v want %v", tt.a, tt.b, got, tt.want) } }) } } func TestIsASCIIPrint(t testing.T) { var tests = []struct { name string in string want bool }{ { name: "empty", want: true, }, { name: "ASCII low", in: "This is a space: ' '", want: true, }, { name: "ASCII high", in: "This is a tilde: '~'", want: true, }, { name: "ASCII low non-print", in: "This is a unit separator: \x1F", want: false, }, { name: "Ascii high non-print", in: "This is a Delete: \x7F", want: false, }, { name: "Unicode letter", in: "Today it's 280K outside: it's freezing!", // This "K" is 'KELVIN SIGN' (\u212A) want: false, }, { name: "Unicode emoji", in: "Gophers like 🧀", want: false, }, } for _, tt := range tests { t.Run(tt.name, func(t testing.T) { if got := isASCIIPrint(tt.in); got != tt.want { t.Errorf("IsASCIIPrint(%q): got %v want %v", tt.in, got, tt.want) } }) } }	1.77 KB	2025-05-25 12:27
📄 ciphers.go // Copyright 2017 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 // A list of the possible cipher suite ids. Taken from // https://www.iana.org/assignments/tls-parameters/tls-parameters.txt const ( cipher_TLS_NULL_WITH_NULL_NULL uint16 = 0x0000 cipher_TLS_RSA_WITH_NULL_MD5 uint16 = 0x0001 cipher_TLS_RSA_WITH_NULL_SHA uint16 = 0x0002 cipher_TLS_RSA_EXPORT_WITH_RC4_40_MD5 uint16 = 0x0003 cipher_TLS_RSA_WITH_RC4_128_MD5 uint16 = 0x0004 cipher_TLS_RSA_WITH_RC4_128_SHA uint16 = 0x0005 cipher_TLS_RSA_EXPORT_WITH_RC2_CBC_40_MD5 uint16 = 0x0006 cipher_TLS_RSA_WITH_IDEA_CBC_SHA uint16 = 0x0007 cipher_TLS_RSA_EXPORT_WITH_DES40_CBC_SHA uint16 = 0x0008 cipher_TLS_RSA_WITH_DES_CBC_SHA uint16 = 0x0009 cipher_TLS_RSA_WITH_3DES_EDE_CBC_SHA uint16 = 0x000A cipher_TLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHA uint16 = 0x000B cipher_TLS_DH_DSS_WITH_DES_CBC_SHA uint16 = 0x000C cipher_TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA uint16 = 0x000D cipher_TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA uint16 = 0x000E cipher_TLS_DH_RSA_WITH_DES_CBC_SHA uint16 = 0x000F cipher_TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA uint16 = 0x0010 cipher_TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA uint16 = 0x0011 cipher_TLS_DHE_DSS_WITH_DES_CBC_SHA uint16 = 0x0012 cipher_TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA uint16 = 0x0013 cipher_TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA uint16 = 0x0014 cipher_TLS_DHE_RSA_WITH_DES_CBC_SHA uint16 = 0x0015 cipher_TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA uint16 = 0x0016 cipher_TLS_DH_anon_EXPORT_WITH_RC4_40_MD5 uint16 = 0x0017 cipher_TLS_DH_anon_WITH_RC4_128_MD5 uint16 = 0x0018 cipher_TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHA uint16 = 0x0019 cipher_TLS_DH_anon_WITH_DES_CBC_SHA uint16 = 0x001A cipher_TLS_DH_anon_WITH_3DES_EDE_CBC_SHA uint16 = 0x001B // Reserved uint16 = 0x001C-1D cipher_TLS_KRB5_WITH_DES_CBC_SHA uint16 = 0x001E cipher_TLS_KRB5_WITH_3DES_EDE_CBC_SHA uint16 = 0x001F cipher_TLS_KRB5_WITH_RC4_128_SHA uint16 = 0x0020 cipher_TLS_KRB5_WITH_IDEA_CBC_SHA uint16 = 0x0021 cipher_TLS_KRB5_WITH_DES_CBC_MD5 uint16 = 0x0022 cipher_TLS_KRB5_WITH_3DES_EDE_CBC_MD5 uint16 = 0x0023 cipher_TLS_KRB5_WITH_RC4_128_MD5 uint16 = 0x0024 cipher_TLS_KRB5_WITH_IDEA_CBC_MD5 uint16 = 0x0025 cipher_TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA uint16 = 0x0026 cipher_TLS_KRB5_EXPORT_WITH_RC2_CBC_40_SHA uint16 = 0x0027 cipher_TLS_KRB5_EXPORT_WITH_RC4_40_SHA uint16 = 0x0028 cipher_TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5 uint16 = 0x0029 cipher_TLS_KRB5_EXPORT_WITH_RC2_CBC_40_MD5 uint16 = 0x002A cipher_TLS_KRB5_EXPORT_WITH_RC4_40_MD5 uint16 = 0x002B cipher_TLS_PSK_WITH_NULL_SHA uint16 = 0x002C cipher_TLS_DHE_PSK_WITH_NULL_SHA uint16 = 0x002D cipher_TLS_RSA_PSK_WITH_NULL_SHA uint16 = 0x002E cipher_TLS_RSA_WITH_AES_128_CBC_SHA uint16 = 0x002F cipher_TLS_DH_DSS_WITH_AES_128_CBC_SHA uint16 = 0x0030 cipher_TLS_DH_RSA_WITH_AES_128_CBC_SHA uint16 = 0x0031 cipher_TLS_DHE_DSS_WITH_AES_128_CBC_SHA uint16 = 0x0032 cipher_TLS_DHE_RSA_WITH_AES_128_CBC_SHA uint16 = 0x0033 cipher_TLS_DH_anon_WITH_AES_128_CBC_SHA uint16 = 0x0034 cipher_TLS_RSA_WITH_AES_256_CBC_SHA uint16 = 0x0035 cipher_TLS_DH_DSS_WITH_AES_256_CBC_SHA uint16 = 0x0036 cipher_TLS_DH_RSA_WITH_AES_256_CBC_SHA uint16 = 0x0037 cipher_TLS_DHE_DSS_WITH_AES_256_CBC_SHA uint16 = 0x0038 cipher_TLS_DHE_RSA_WITH_AES_256_CBC_SHA uint16 = 0x0039 cipher_TLS_DH_anon_WITH_AES_256_CBC_SHA uint16 = 0x003A cipher_TLS_RSA_WITH_NULL_SHA256 uint16 = 0x003B cipher_TLS_RSA_WITH_AES_128_CBC_SHA256 uint16 = 0x003C cipher_TLS_RSA_WITH_AES_256_CBC_SHA256 uint16 = 0x003D cipher_TLS_DH_DSS_WITH_AES_128_CBC_SHA256 uint16 = 0x003E cipher_TLS_DH_RSA_WITH_AES_128_CBC_SHA256 uint16 = 0x003F cipher_TLS_DHE_DSS_WITH_AES_128_CBC_SHA256 uint16 = 0x0040 cipher_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA uint16 = 0x0041 cipher_TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA uint16 = 0x0042 cipher_TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA uint16 = 0x0043 cipher_TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA uint16 = 0x0044 cipher_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA uint16 = 0x0045 cipher_TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA uint16 = 0x0046 // Reserved uint16 = 0x0047-4F // Reserved uint16 = 0x0050-58 // Reserved uint16 = 0x0059-5C // Unassigned uint16 = 0x005D-5F // Reserved uint16 = 0x0060-66 cipher_TLS_DHE_RSA_WITH_AES_128_CBC_SHA256 uint16 = 0x0067 cipher_TLS_DH_DSS_WITH_AES_256_CBC_SHA256 uint16 = 0x0068 cipher_TLS_DH_RSA_WITH_AES_256_CBC_SHA256 uint16 = 0x0069 cipher_TLS_DHE_DSS_WITH_AES_256_CBC_SHA256 uint16 = 0x006A cipher_TLS_DHE_RSA_WITH_AES_256_CBC_SHA256 uint16 = 0x006B cipher_TLS_DH_anon_WITH_AES_128_CBC_SHA256 uint16 = 0x006C cipher_TLS_DH_anon_WITH_AES_256_CBC_SHA256 uint16 = 0x006D // Unassigned uint16 = 0x006E-83 cipher_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA uint16 = 0x0084 cipher_TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA uint16 = 0x0085 cipher_TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA uint16 = 0x0086 cipher_TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA uint16 = 0x0087 cipher_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA uint16 = 0x0088 cipher_TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA uint16 = 0x0089 cipher_TLS_PSK_WITH_RC4_128_SHA uint16 = 0x008A cipher_TLS_PSK_WITH_3DES_EDE_CBC_SHA uint16 = 0x008B cipher_TLS_PSK_WITH_AES_128_CBC_SHA uint16 = 0x008C cipher_TLS_PSK_WITH_AES_256_CBC_SHA uint16 = 0x008D cipher_TLS_DHE_PSK_WITH_RC4_128_SHA uint16 = 0x008E cipher_TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA uint16 = 0x008F cipher_TLS_DHE_PSK_WITH_AES_128_CBC_SHA uint16 = 0x0090 cipher_TLS_DHE_PSK_WITH_AES_256_CBC_SHA uint16 = 0x0091 cipher_TLS_RSA_PSK_WITH_RC4_128_SHA uint16 = 0x0092 cipher_TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA uint16 = 0x0093 cipher_TLS_RSA_PSK_WITH_AES_128_CBC_SHA uint16 = 0x0094 cipher_TLS_RSA_PSK_WITH_AES_256_CBC_SHA uint16 = 0x0095 cipher_TLS_RSA_WITH_SEED_CBC_SHA uint16 = 0x0096 cipher_TLS_DH_DSS_WITH_SEED_CBC_SHA uint16 = 0x0097 cipher_TLS_DH_RSA_WITH_SEED_CBC_SHA uint16 = 0x0098 cipher_TLS_DHE_DSS_WITH_SEED_CBC_SHA uint16 = 0x0099 cipher_TLS_DHE_RSA_WITH_SEED_CBC_SHA uint16 = 0x009A cipher_TLS_DH_anon_WITH_SEED_CBC_SHA uint16 = 0x009B cipher_TLS_RSA_WITH_AES_128_GCM_SHA256 uint16 = 0x009C cipher_TLS_RSA_WITH_AES_256_GCM_SHA384 uint16 = 0x009D cipher_TLS_DHE_RSA_WITH_AES_128_GCM_SHA256 uint16 = 0x009E cipher_TLS_DHE_RSA_WITH_AES_256_GCM_SHA384 uint16 = 0x009F cipher_TLS_DH_RSA_WITH_AES_128_GCM_SHA256 uint16 = 0x00A0 cipher_TLS_DH_RSA_WITH_AES_256_GCM_SHA384 uint16 = 0x00A1 cipher_TLS_DHE_DSS_WITH_AES_128_GCM_SHA256 uint16 = 0x00A2 cipher_TLS_DHE_DSS_WITH_AES_256_GCM_SHA384 uint16 = 0x00A3 cipher_TLS_DH_DSS_WITH_AES_128_GCM_SHA256 uint16 = 0x00A4 cipher_TLS_DH_DSS_WITH_AES_256_GCM_SHA384 uint16 = 0x00A5 cipher_TLS_DH_anon_WITH_AES_128_GCM_SHA256 uint16 = 0x00A6 cipher_TLS_DH_anon_WITH_AES_256_GCM_SHA384 uint16 = 0x00A7 cipher_TLS_PSK_WITH_AES_128_GCM_SHA256 uint16 = 0x00A8 cipher_TLS_PSK_WITH_AES_256_GCM_SHA384 uint16 = 0x00A9 cipher_TLS_DHE_PSK_WITH_AES_128_GCM_SHA256 uint16 = 0x00AA cipher_TLS_DHE_PSK_WITH_AES_256_GCM_SHA384 uint16 = 0x00AB cipher_TLS_RSA_PSK_WITH_AES_128_GCM_SHA256 uint16 = 0x00AC cipher_TLS_RSA_PSK_WITH_AES_256_GCM_SHA384 uint16 = 0x00AD cipher_TLS_PSK_WITH_AES_128_CBC_SHA256 uint16 = 0x00AE cipher_TLS_PSK_WITH_AES_256_CBC_SHA384 uint16 = 0x00AF cipher_TLS_PSK_WITH_NULL_SHA256 uint16 = 0x00B0 cipher_TLS_PSK_WITH_NULL_SHA384 uint16 = 0x00B1 cipher_TLS_DHE_PSK_WITH_AES_128_CBC_SHA256 uint16 = 0x00B2 cipher_TLS_DHE_PSK_WITH_AES_256_CBC_SHA384 uint16 = 0x00B3 cipher_TLS_DHE_PSK_WITH_NULL_SHA256 uint16 = 0x00B4 cipher_TLS_DHE_PSK_WITH_NULL_SHA384 uint16 = 0x00B5 cipher_TLS_RSA_PSK_WITH_AES_128_CBC_SHA256 uint16 = 0x00B6 cipher_TLS_RSA_PSK_WITH_AES_256_CBC_SHA384 uint16 = 0x00B7 cipher_TLS_RSA_PSK_WITH_NULL_SHA256 uint16 = 0x00B8 cipher_TLS_RSA_PSK_WITH_NULL_SHA384 uint16 = 0x00B9 cipher_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0x00BA cipher_TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0x00BB cipher_TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0x00BC cipher_TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0x00BD cipher_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0x00BE cipher_TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0x00BF cipher_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256 uint16 = 0x00C0 cipher_TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256 uint16 = 0x00C1 cipher_TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256 uint16 = 0x00C2 cipher_TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256 uint16 = 0x00C3 cipher_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256 uint16 = 0x00C4 cipher_TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256 uint16 = 0x00C5 // Unassigned uint16 = 0x00C6-FE cipher_TLS_EMPTY_RENEGOTIATION_INFO_SCSV uint16 = 0x00FF // Unassigned uint16 = 0x01-55,* cipher_TLS_FALLBACK_SCSV uint16 = 0x5600 // Unassigned uint16 = 0x5601 - 0xC000 cipher_TLS_ECDH_ECDSA_WITH_NULL_SHA uint16 = 0xC001 cipher_TLS_ECDH_ECDSA_WITH_RC4_128_SHA uint16 = 0xC002 cipher_TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA uint16 = 0xC003 cipher_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA uint16 = 0xC004 cipher_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA uint16 = 0xC005 cipher_TLS_ECDHE_ECDSA_WITH_NULL_SHA uint16 = 0xC006 cipher_TLS_ECDHE_ECDSA_WITH_RC4_128_SHA uint16 = 0xC007 cipher_TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA uint16 = 0xC008 cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA uint16 = 0xC009 cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA uint16 = 0xC00A cipher_TLS_ECDH_RSA_WITH_NULL_SHA uint16 = 0xC00B cipher_TLS_ECDH_RSA_WITH_RC4_128_SHA uint16 = 0xC00C cipher_TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA uint16 = 0xC00D cipher_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA uint16 = 0xC00E cipher_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA uint16 = 0xC00F cipher_TLS_ECDHE_RSA_WITH_NULL_SHA uint16 = 0xC010 cipher_TLS_ECDHE_RSA_WITH_RC4_128_SHA uint16 = 0xC011 cipher_TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA uint16 = 0xC012 cipher_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA uint16 = 0xC013 cipher_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA uint16 = 0xC014 cipher_TLS_ECDH_anon_WITH_NULL_SHA uint16 = 0xC015 cipher_TLS_ECDH_anon_WITH_RC4_128_SHA uint16 = 0xC016 cipher_TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA uint16 = 0xC017 cipher_TLS_ECDH_anon_WITH_AES_128_CBC_SHA uint16 = 0xC018 cipher_TLS_ECDH_anon_WITH_AES_256_CBC_SHA uint16 = 0xC019 cipher_TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA uint16 = 0xC01A cipher_TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA uint16 = 0xC01B cipher_TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA uint16 = 0xC01C cipher_TLS_SRP_SHA_WITH_AES_128_CBC_SHA uint16 = 0xC01D cipher_TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA uint16 = 0xC01E cipher_TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA uint16 = 0xC01F cipher_TLS_SRP_SHA_WITH_AES_256_CBC_SHA uint16 = 0xC020 cipher_TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA uint16 = 0xC021 cipher_TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA uint16 = 0xC022 cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 uint16 = 0xC023 cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 uint16 = 0xC024 cipher_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256 uint16 = 0xC025 cipher_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384 uint16 = 0xC026 cipher_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 uint16 = 0xC027 cipher_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 uint16 = 0xC028 cipher_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256 uint16 = 0xC029 cipher_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384 uint16 = 0xC02A cipher_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 uint16 = 0xC02B cipher_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 uint16 = 0xC02C cipher_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256 uint16 = 0xC02D cipher_TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384 uint16 = 0xC02E cipher_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 uint16 = 0xC02F cipher_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 uint16 = 0xC030 cipher_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256 uint16 = 0xC031 cipher_TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384 uint16 = 0xC032 cipher_TLS_ECDHE_PSK_WITH_RC4_128_SHA uint16 = 0xC033 cipher_TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA uint16 = 0xC034 cipher_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA uint16 = 0xC035 cipher_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA uint16 = 0xC036 cipher_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256 uint16 = 0xC037 cipher_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384 uint16 = 0xC038 cipher_TLS_ECDHE_PSK_WITH_NULL_SHA uint16 = 0xC039 cipher_TLS_ECDHE_PSK_WITH_NULL_SHA256 uint16 = 0xC03A cipher_TLS_ECDHE_PSK_WITH_NULL_SHA384 uint16 = 0xC03B cipher_TLS_RSA_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC03C cipher_TLS_RSA_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC03D cipher_TLS_DH_DSS_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC03E cipher_TLS_DH_DSS_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC03F cipher_TLS_DH_RSA_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC040 cipher_TLS_DH_RSA_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC041 cipher_TLS_DHE_DSS_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC042 cipher_TLS_DHE_DSS_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC043 cipher_TLS_DHE_RSA_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC044 cipher_TLS_DHE_RSA_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC045 cipher_TLS_DH_anon_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC046 cipher_TLS_DH_anon_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC047 cipher_TLS_ECDHE_ECDSA_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC048 cipher_TLS_ECDHE_ECDSA_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC049 cipher_TLS_ECDH_ECDSA_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC04A cipher_TLS_ECDH_ECDSA_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC04B cipher_TLS_ECDHE_RSA_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC04C cipher_TLS_ECDHE_RSA_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC04D cipher_TLS_ECDH_RSA_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC04E cipher_TLS_ECDH_RSA_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC04F cipher_TLS_RSA_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC050 cipher_TLS_RSA_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC051 cipher_TLS_DHE_RSA_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC052 cipher_TLS_DHE_RSA_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC053 cipher_TLS_DH_RSA_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC054 cipher_TLS_DH_RSA_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC055 cipher_TLS_DHE_DSS_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC056 cipher_TLS_DHE_DSS_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC057 cipher_TLS_DH_DSS_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC058 cipher_TLS_DH_DSS_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC059 cipher_TLS_DH_anon_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC05A cipher_TLS_DH_anon_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC05B cipher_TLS_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC05C cipher_TLS_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC05D cipher_TLS_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC05E cipher_TLS_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC05F cipher_TLS_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC060 cipher_TLS_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC061 cipher_TLS_ECDH_RSA_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC062 cipher_TLS_ECDH_RSA_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC063 cipher_TLS_PSK_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC064 cipher_TLS_PSK_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC065 cipher_TLS_DHE_PSK_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC066 cipher_TLS_DHE_PSK_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC067 cipher_TLS_RSA_PSK_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC068 cipher_TLS_RSA_PSK_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC069 cipher_TLS_PSK_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC06A cipher_TLS_PSK_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC06B cipher_TLS_DHE_PSK_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC06C cipher_TLS_DHE_PSK_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC06D cipher_TLS_RSA_PSK_WITH_ARIA_128_GCM_SHA256 uint16 = 0xC06E cipher_TLS_RSA_PSK_WITH_ARIA_256_GCM_SHA384 uint16 = 0xC06F cipher_TLS_ECDHE_PSK_WITH_ARIA_128_CBC_SHA256 uint16 = 0xC070 cipher_TLS_ECDHE_PSK_WITH_ARIA_256_CBC_SHA384 uint16 = 0xC071 cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0xC072 cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 uint16 = 0xC073 cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0xC074 cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 uint16 = 0xC075 cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0xC076 cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384 uint16 = 0xC077 cipher_TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0xC078 cipher_TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384 uint16 = 0xC079 cipher_TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC07A cipher_TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC07B cipher_TLS_DHE_RSA_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC07C cipher_TLS_DHE_RSA_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC07D cipher_TLS_DH_RSA_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC07E cipher_TLS_DH_RSA_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC07F cipher_TLS_DHE_DSS_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC080 cipher_TLS_DHE_DSS_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC081 cipher_TLS_DH_DSS_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC082 cipher_TLS_DH_DSS_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC083 cipher_TLS_DH_anon_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC084 cipher_TLS_DH_anon_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC085 cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC086 cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC087 cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC088 cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC089 cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC08A cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC08B cipher_TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC08C cipher_TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC08D cipher_TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC08E cipher_TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC08F cipher_TLS_DHE_PSK_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC090 cipher_TLS_DHE_PSK_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC091 cipher_TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256 uint16 = 0xC092 cipher_TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384 uint16 = 0xC093 cipher_TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0xC094 cipher_TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384 uint16 = 0xC095 cipher_TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0xC096 cipher_TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 uint16 = 0xC097 cipher_TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0xC098 cipher_TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384 uint16 = 0xC099 cipher_TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 uint16 = 0xC09A cipher_TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 uint16 = 0xC09B cipher_TLS_RSA_WITH_AES_128_CCM uint16 = 0xC09C cipher_TLS_RSA_WITH_AES_256_CCM uint16 = 0xC09D cipher_TLS_DHE_RSA_WITH_AES_128_CCM uint16 = 0xC09E cipher_TLS_DHE_RSA_WITH_AES_256_CCM uint16 = 0xC09F cipher_TLS_RSA_WITH_AES_128_CCM_8 uint16 = 0xC0A0 cipher_TLS_RSA_WITH_AES_256_CCM_8 uint16 = 0xC0A1 cipher_TLS_DHE_RSA_WITH_AES_128_CCM_8 uint16 = 0xC0A2 cipher_TLS_DHE_RSA_WITH_AES_256_CCM_8 uint16 = 0xC0A3 cipher_TLS_PSK_WITH_AES_128_CCM uint16 = 0xC0A4 cipher_TLS_PSK_WITH_AES_256_CCM uint16 = 0xC0A5 cipher_TLS_DHE_PSK_WITH_AES_128_CCM uint16 = 0xC0A6 cipher_TLS_DHE_PSK_WITH_AES_256_CCM uint16 = 0xC0A7 cipher_TLS_PSK_WITH_AES_128_CCM_8 uint16 = 0xC0A8 cipher_TLS_PSK_WITH_AES_256_CCM_8 uint16 = 0xC0A9 cipher_TLS_PSK_DHE_WITH_AES_128_CCM_8 uint16 = 0xC0AA cipher_TLS_PSK_DHE_WITH_AES_256_CCM_8 uint16 = 0xC0AB cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CCM uint16 = 0xC0AC cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CCM uint16 = 0xC0AD cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8 uint16 = 0xC0AE cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8 uint16 = 0xC0AF // Unassigned uint16 = 0xC0B0-FF // Unassigned uint16 = 0xC1-CB,* // Unassigned uint16 = 0xCC00-A7 cipher_TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 uint16 = 0xCCA8 cipher_TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 uint16 = 0xCCA9 cipher_TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256 uint16 = 0xCCAA cipher_TLS_PSK_WITH_CHACHA20_POLY1305_SHA256 uint16 = 0xCCAB cipher_TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256 uint16 = 0xCCAC cipher_TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256 uint16 = 0xCCAD cipher_TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256 uint16 = 0xCCAE ) // isBadCipher reports whether the cipher is blacklisted by the HTTP/2 spec. // References: // https://tools.ietf.org/html/rfc7540#appendix-A // Reject cipher suites from Appendix A. // "This list includes those cipher suites that do not // offer an ephemeral key exchange and those that are // based on the TLS null, stream or block cipher type" func isBadCipher(cipher uint16) bool { switch cipher { case cipher_TLS_NULL_WITH_NULL_NULL, cipher_TLS_RSA_WITH_NULL_MD5, cipher_TLS_RSA_WITH_NULL_SHA, cipher_TLS_RSA_EXPORT_WITH_RC4_40_MD5, cipher_TLS_RSA_WITH_RC4_128_MD5, cipher_TLS_RSA_WITH_RC4_128_SHA, cipher_TLS_RSA_EXPORT_WITH_RC2_CBC_40_MD5, cipher_TLS_RSA_WITH_IDEA_CBC_SHA, cipher_TLS_RSA_EXPORT_WITH_DES40_CBC_SHA, cipher_TLS_RSA_WITH_DES_CBC_SHA, cipher_TLS_RSA_WITH_3DES_EDE_CBC_SHA, cipher_TLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHA, cipher_TLS_DH_DSS_WITH_DES_CBC_SHA, cipher_TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA, cipher_TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA, cipher_TLS_DH_RSA_WITH_DES_CBC_SHA, cipher_TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA, cipher_TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA, cipher_TLS_DHE_DSS_WITH_DES_CBC_SHA, cipher_TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA, cipher_TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA, cipher_TLS_DHE_RSA_WITH_DES_CBC_SHA, cipher_TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA, cipher_TLS_DH_anon_EXPORT_WITH_RC4_40_MD5, cipher_TLS_DH_anon_WITH_RC4_128_MD5, cipher_TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHA, cipher_TLS_DH_anon_WITH_DES_CBC_SHA, cipher_TLS_DH_anon_WITH_3DES_EDE_CBC_SHA, cipher_TLS_KRB5_WITH_DES_CBC_SHA, cipher_TLS_KRB5_WITH_3DES_EDE_CBC_SHA, cipher_TLS_KRB5_WITH_RC4_128_SHA, cipher_TLS_KRB5_WITH_IDEA_CBC_SHA, cipher_TLS_KRB5_WITH_DES_CBC_MD5, cipher_TLS_KRB5_WITH_3DES_EDE_CBC_MD5, cipher_TLS_KRB5_WITH_RC4_128_MD5, cipher_TLS_KRB5_WITH_IDEA_CBC_MD5, cipher_TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA, cipher_TLS_KRB5_EXPORT_WITH_RC2_CBC_40_SHA, cipher_TLS_KRB5_EXPORT_WITH_RC4_40_SHA, cipher_TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5, cipher_TLS_KRB5_EXPORT_WITH_RC2_CBC_40_MD5, cipher_TLS_KRB5_EXPORT_WITH_RC4_40_MD5, cipher_TLS_PSK_WITH_NULL_SHA, cipher_TLS_DHE_PSK_WITH_NULL_SHA, cipher_TLS_RSA_PSK_WITH_NULL_SHA, cipher_TLS_RSA_WITH_AES_128_CBC_SHA, cipher_TLS_DH_DSS_WITH_AES_128_CBC_SHA, cipher_TLS_DH_RSA_WITH_AES_128_CBC_SHA, cipher_TLS_DHE_DSS_WITH_AES_128_CBC_SHA, cipher_TLS_DHE_RSA_WITH_AES_128_CBC_SHA, cipher_TLS_DH_anon_WITH_AES_128_CBC_SHA, cipher_TLS_RSA_WITH_AES_256_CBC_SHA, cipher_TLS_DH_DSS_WITH_AES_256_CBC_SHA, cipher_TLS_DH_RSA_WITH_AES_256_CBC_SHA, cipher_TLS_DHE_DSS_WITH_AES_256_CBC_SHA, cipher_TLS_DHE_RSA_WITH_AES_256_CBC_SHA, cipher_TLS_DH_anon_WITH_AES_256_CBC_SHA, cipher_TLS_RSA_WITH_NULL_SHA256, cipher_TLS_RSA_WITH_AES_128_CBC_SHA256, cipher_TLS_RSA_WITH_AES_256_CBC_SHA256, cipher_TLS_DH_DSS_WITH_AES_128_CBC_SHA256, cipher_TLS_DH_RSA_WITH_AES_128_CBC_SHA256, cipher_TLS_DHE_DSS_WITH_AES_128_CBC_SHA256, cipher_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA, cipher_TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA, cipher_TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA, cipher_TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA, cipher_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA, cipher_TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA, cipher_TLS_DHE_RSA_WITH_AES_128_CBC_SHA256, cipher_TLS_DH_DSS_WITH_AES_256_CBC_SHA256, cipher_TLS_DH_RSA_WITH_AES_256_CBC_SHA256, cipher_TLS_DHE_DSS_WITH_AES_256_CBC_SHA256, cipher_TLS_DHE_RSA_WITH_AES_256_CBC_SHA256, cipher_TLS_DH_anon_WITH_AES_128_CBC_SHA256, cipher_TLS_DH_anon_WITH_AES_256_CBC_SHA256, cipher_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA, cipher_TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA, cipher_TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA, cipher_TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA, cipher_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA, cipher_TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA, cipher_TLS_PSK_WITH_RC4_128_SHA, cipher_TLS_PSK_WITH_3DES_EDE_CBC_SHA, cipher_TLS_PSK_WITH_AES_128_CBC_SHA, cipher_TLS_PSK_WITH_AES_256_CBC_SHA, cipher_TLS_DHE_PSK_WITH_RC4_128_SHA, cipher_TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA, cipher_TLS_DHE_PSK_WITH_AES_128_CBC_SHA, cipher_TLS_DHE_PSK_WITH_AES_256_CBC_SHA, cipher_TLS_RSA_PSK_WITH_RC4_128_SHA, cipher_TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA, cipher_TLS_RSA_PSK_WITH_AES_128_CBC_SHA, cipher_TLS_RSA_PSK_WITH_AES_256_CBC_SHA, cipher_TLS_RSA_WITH_SEED_CBC_SHA, cipher_TLS_DH_DSS_WITH_SEED_CBC_SHA, cipher_TLS_DH_RSA_WITH_SEED_CBC_SHA, cipher_TLS_DHE_DSS_WITH_SEED_CBC_SHA, cipher_TLS_DHE_RSA_WITH_SEED_CBC_SHA, cipher_TLS_DH_anon_WITH_SEED_CBC_SHA, cipher_TLS_RSA_WITH_AES_128_GCM_SHA256, cipher_TLS_RSA_WITH_AES_256_GCM_SHA384, cipher_TLS_DH_RSA_WITH_AES_128_GCM_SHA256, cipher_TLS_DH_RSA_WITH_AES_256_GCM_SHA384, cipher_TLS_DH_DSS_WITH_AES_128_GCM_SHA256, cipher_TLS_DH_DSS_WITH_AES_256_GCM_SHA384, cipher_TLS_DH_anon_WITH_AES_128_GCM_SHA256, cipher_TLS_DH_anon_WITH_AES_256_GCM_SHA384, cipher_TLS_PSK_WITH_AES_128_GCM_SHA256, cipher_TLS_PSK_WITH_AES_256_GCM_SHA384, cipher_TLS_RSA_PSK_WITH_AES_128_GCM_SHA256, cipher_TLS_RSA_PSK_WITH_AES_256_GCM_SHA384, cipher_TLS_PSK_WITH_AES_128_CBC_SHA256, cipher_TLS_PSK_WITH_AES_256_CBC_SHA384, cipher_TLS_PSK_WITH_NULL_SHA256, cipher_TLS_PSK_WITH_NULL_SHA384, cipher_TLS_DHE_PSK_WITH_AES_128_CBC_SHA256, cipher_TLS_DHE_PSK_WITH_AES_256_CBC_SHA384, cipher_TLS_DHE_PSK_WITH_NULL_SHA256, cipher_TLS_DHE_PSK_WITH_NULL_SHA384, cipher_TLS_RSA_PSK_WITH_AES_128_CBC_SHA256, cipher_TLS_RSA_PSK_WITH_AES_256_CBC_SHA384, cipher_TLS_RSA_PSK_WITH_NULL_SHA256, cipher_TLS_RSA_PSK_WITH_NULL_SHA384, cipher_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256, cipher_TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256, cipher_TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256, cipher_TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256, cipher_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256, cipher_TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256, cipher_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256, cipher_TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256, cipher_TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256, cipher_TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256, cipher_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256, cipher_TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256, cipher_TLS_EMPTY_RENEGOTIATION_INFO_SCSV, cipher_TLS_ECDH_ECDSA_WITH_NULL_SHA, cipher_TLS_ECDH_ECDSA_WITH_RC4_128_SHA, cipher_TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA, cipher_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA, cipher_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA, cipher_TLS_ECDHE_ECDSA_WITH_NULL_SHA, cipher_TLS_ECDHE_ECDSA_WITH_RC4_128_SHA, cipher_TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA, cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, cipher_TLS_ECDH_RSA_WITH_NULL_SHA, cipher_TLS_ECDH_RSA_WITH_RC4_128_SHA, cipher_TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA, cipher_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA, cipher_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA, cipher_TLS_ECDHE_RSA_WITH_NULL_SHA, cipher_TLS_ECDHE_RSA_WITH_RC4_128_SHA, cipher_TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA, cipher_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA, cipher_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA, cipher_TLS_ECDH_anon_WITH_NULL_SHA, cipher_TLS_ECDH_anon_WITH_RC4_128_SHA, cipher_TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA, cipher_TLS_ECDH_anon_WITH_AES_128_CBC_SHA, cipher_TLS_ECDH_anon_WITH_AES_256_CBC_SHA, cipher_TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA, cipher_TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA, cipher_TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA, cipher_TLS_SRP_SHA_WITH_AES_128_CBC_SHA, cipher_TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA, cipher_TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA, cipher_TLS_SRP_SHA_WITH_AES_256_CBC_SHA, cipher_TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA, cipher_TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA, cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256, cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384, cipher_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256, cipher_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384, cipher_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256, cipher_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384, cipher_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256, cipher_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384, cipher_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256, cipher_TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384, cipher_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256, cipher_TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384, cipher_TLS_ECDHE_PSK_WITH_RC4_128_SHA, cipher_TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA, cipher_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA, cipher_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA, cipher_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256, cipher_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384, cipher_TLS_ECDHE_PSK_WITH_NULL_SHA, cipher_TLS_ECDHE_PSK_WITH_NULL_SHA256, cipher_TLS_ECDHE_PSK_WITH_NULL_SHA384, cipher_TLS_RSA_WITH_ARIA_128_CBC_SHA256, cipher_TLS_RSA_WITH_ARIA_256_CBC_SHA384, cipher_TLS_DH_DSS_WITH_ARIA_128_CBC_SHA256, cipher_TLS_DH_DSS_WITH_ARIA_256_CBC_SHA384, cipher_TLS_DH_RSA_WITH_ARIA_128_CBC_SHA256, cipher_TLS_DH_RSA_WITH_ARIA_256_CBC_SHA384, cipher_TLS_DHE_DSS_WITH_ARIA_128_CBC_SHA256, cipher_TLS_DHE_DSS_WITH_ARIA_256_CBC_SHA384, cipher_TLS_DHE_RSA_WITH_ARIA_128_CBC_SHA256, cipher_TLS_DHE_RSA_WITH_ARIA_256_CBC_SHA384, cipher_TLS_DH_anon_WITH_ARIA_128_CBC_SHA256, cipher_TLS_DH_anon_WITH_ARIA_256_CBC_SHA384, cipher_TLS_ECDHE_ECDSA_WITH_ARIA_128_CBC_SHA256, cipher_TLS_ECDHE_ECDSA_WITH_ARIA_256_CBC_SHA384, cipher_TLS_ECDH_ECDSA_WITH_ARIA_128_CBC_SHA256, cipher_TLS_ECDH_ECDSA_WITH_ARIA_256_CBC_SHA384, cipher_TLS_ECDHE_RSA_WITH_ARIA_128_CBC_SHA256, cipher_TLS_ECDHE_RSA_WITH_ARIA_256_CBC_SHA384, cipher_TLS_ECDH_RSA_WITH_ARIA_128_CBC_SHA256, cipher_TLS_ECDH_RSA_WITH_ARIA_256_CBC_SHA384, cipher_TLS_RSA_WITH_ARIA_128_GCM_SHA256, cipher_TLS_RSA_WITH_ARIA_256_GCM_SHA384, cipher_TLS_DH_RSA_WITH_ARIA_128_GCM_SHA256, cipher_TLS_DH_RSA_WITH_ARIA_256_GCM_SHA384, cipher_TLS_DH_DSS_WITH_ARIA_128_GCM_SHA256, cipher_TLS_DH_DSS_WITH_ARIA_256_GCM_SHA384, cipher_TLS_DH_anon_WITH_ARIA_128_GCM_SHA256, cipher_TLS_DH_anon_WITH_ARIA_256_GCM_SHA384, cipher_TLS_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256, cipher_TLS_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384, cipher_TLS_ECDH_RSA_WITH_ARIA_128_GCM_SHA256, cipher_TLS_ECDH_RSA_WITH_ARIA_256_GCM_SHA384, cipher_TLS_PSK_WITH_ARIA_128_CBC_SHA256, cipher_TLS_PSK_WITH_ARIA_256_CBC_SHA384, cipher_TLS_DHE_PSK_WITH_ARIA_128_CBC_SHA256, cipher_TLS_DHE_PSK_WITH_ARIA_256_CBC_SHA384, cipher_TLS_RSA_PSK_WITH_ARIA_128_CBC_SHA256, cipher_TLS_RSA_PSK_WITH_ARIA_256_CBC_SHA384, cipher_TLS_PSK_WITH_ARIA_128_GCM_SHA256, cipher_TLS_PSK_WITH_ARIA_256_GCM_SHA384, cipher_TLS_RSA_PSK_WITH_ARIA_128_GCM_SHA256, cipher_TLS_RSA_PSK_WITH_ARIA_256_GCM_SHA384, cipher_TLS_ECDHE_PSK_WITH_ARIA_128_CBC_SHA256, cipher_TLS_ECDHE_PSK_WITH_ARIA_256_CBC_SHA384, cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256, cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384, cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256, cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384, cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256, cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384, cipher_TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256, cipher_TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384, cipher_TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256, cipher_TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384, cipher_TLS_DH_RSA_WITH_CAMELLIA_128_GCM_SHA256, cipher_TLS_DH_RSA_WITH_CAMELLIA_256_GCM_SHA384, cipher_TLS_DH_DSS_WITH_CAMELLIA_128_GCM_SHA256, cipher_TLS_DH_DSS_WITH_CAMELLIA_256_GCM_SHA384, cipher_TLS_DH_anon_WITH_CAMELLIA_128_GCM_SHA256, cipher_TLS_DH_anon_WITH_CAMELLIA_256_GCM_SHA384, cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256, cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384, cipher_TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256, cipher_TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384, cipher_TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256, cipher_TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384, cipher_TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256, cipher_TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384, cipher_TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256, cipher_TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384, cipher_TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256, cipher_TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384, cipher_TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256, cipher_TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384, cipher_TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256, cipher_TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384, cipher_TLS_RSA_WITH_AES_128_CCM, cipher_TLS_RSA_WITH_AES_256_CCM, cipher_TLS_RSA_WITH_AES_128_CCM_8, cipher_TLS_RSA_WITH_AES_256_CCM_8, cipher_TLS_PSK_WITH_AES_128_CCM, cipher_TLS_PSK_WITH_AES_256_CCM, cipher_TLS_PSK_WITH_AES_128_CCM_8, cipher_TLS_PSK_WITH_AES_256_CCM_8: return true default: return false } }	34.38 KB	2025-05-25 12:27
📄 ciphers_test.go // Copyright 2017 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import "testing" func TestIsBadCipherBad(t testing.T) { for _, c := range badCiphers { if !isBadCipher(c) { t.Errorf("Wrong result for isBadCipher(%d), want true", c) } } } // verify we don't give false positives on ciphers not on blacklist func TestIsBadCipherGood(t testing.T) { goodCiphers := map[uint16]string{ cipher_TLS_DHE_RSA_WITH_AES_256_CCM: "cipher_TLS_DHE_RSA_WITH_AES_256_CCM", cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CCM: "cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CCM", cipher_TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256: "cipher_TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256", } for c, name := range goodCiphers { if isBadCipher(c) { t.Errorf("Wrong result for isBadCipher(%d) %s, want false", c, name) } } } // copied from https://httpwg.org/specs/rfc7540.html#BadCipherSuites, var badCiphers = []uint16{ cipher_TLS_NULL_WITH_NULL_NULL, cipher_TLS_RSA_WITH_NULL_MD5, cipher_TLS_RSA_WITH_NULL_SHA, cipher_TLS_RSA_EXPORT_WITH_RC4_40_MD5, cipher_TLS_RSA_WITH_RC4_128_MD5, cipher_TLS_RSA_WITH_RC4_128_SHA, cipher_TLS_RSA_EXPORT_WITH_RC2_CBC_40_MD5, cipher_TLS_RSA_WITH_IDEA_CBC_SHA, cipher_TLS_RSA_EXPORT_WITH_DES40_CBC_SHA, cipher_TLS_RSA_WITH_DES_CBC_SHA, cipher_TLS_RSA_WITH_3DES_EDE_CBC_SHA, cipher_TLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHA, cipher_TLS_DH_DSS_WITH_DES_CBC_SHA, cipher_TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA, cipher_TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA, cipher_TLS_DH_RSA_WITH_DES_CBC_SHA, cipher_TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA, cipher_TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA, cipher_TLS_DHE_DSS_WITH_DES_CBC_SHA, cipher_TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA, cipher_TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA, cipher_TLS_DHE_RSA_WITH_DES_CBC_SHA, cipher_TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA, cipher_TLS_DH_anon_EXPORT_WITH_RC4_40_MD5, cipher_TLS_DH_anon_WITH_RC4_128_MD5, cipher_TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHA, cipher_TLS_DH_anon_WITH_DES_CBC_SHA, cipher_TLS_DH_anon_WITH_3DES_EDE_CBC_SHA, cipher_TLS_KRB5_WITH_DES_CBC_SHA, cipher_TLS_KRB5_WITH_3DES_EDE_CBC_SHA, cipher_TLS_KRB5_WITH_RC4_128_SHA, cipher_TLS_KRB5_WITH_IDEA_CBC_SHA, cipher_TLS_KRB5_WITH_DES_CBC_MD5, cipher_TLS_KRB5_WITH_3DES_EDE_CBC_MD5, cipher_TLS_KRB5_WITH_RC4_128_MD5, cipher_TLS_KRB5_WITH_IDEA_CBC_MD5, cipher_TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA, cipher_TLS_KRB5_EXPORT_WITH_RC2_CBC_40_SHA, cipher_TLS_KRB5_EXPORT_WITH_RC4_40_SHA, cipher_TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5, cipher_TLS_KRB5_EXPORT_WITH_RC2_CBC_40_MD5, cipher_TLS_KRB5_EXPORT_WITH_RC4_40_MD5, cipher_TLS_PSK_WITH_NULL_SHA, cipher_TLS_DHE_PSK_WITH_NULL_SHA, cipher_TLS_RSA_PSK_WITH_NULL_SHA, cipher_TLS_RSA_WITH_AES_128_CBC_SHA, cipher_TLS_DH_DSS_WITH_AES_128_CBC_SHA, cipher_TLS_DH_RSA_WITH_AES_128_CBC_SHA, cipher_TLS_DHE_DSS_WITH_AES_128_CBC_SHA, cipher_TLS_DHE_RSA_WITH_AES_128_CBC_SHA, cipher_TLS_DH_anon_WITH_AES_128_CBC_SHA, cipher_TLS_RSA_WITH_AES_256_CBC_SHA, cipher_TLS_DH_DSS_WITH_AES_256_CBC_SHA, cipher_TLS_DH_RSA_WITH_AES_256_CBC_SHA, cipher_TLS_DHE_DSS_WITH_AES_256_CBC_SHA, cipher_TLS_DHE_RSA_WITH_AES_256_CBC_SHA, cipher_TLS_DH_anon_WITH_AES_256_CBC_SHA, cipher_TLS_RSA_WITH_NULL_SHA256, cipher_TLS_RSA_WITH_AES_128_CBC_SHA256, cipher_TLS_RSA_WITH_AES_256_CBC_SHA256, cipher_TLS_DH_DSS_WITH_AES_128_CBC_SHA256, cipher_TLS_DH_RSA_WITH_AES_128_CBC_SHA256, cipher_TLS_DHE_DSS_WITH_AES_128_CBC_SHA256, cipher_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA, cipher_TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA, cipher_TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA, cipher_TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA, cipher_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA, cipher_TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA, cipher_TLS_DHE_RSA_WITH_AES_128_CBC_SHA256, cipher_TLS_DH_DSS_WITH_AES_256_CBC_SHA256, cipher_TLS_DH_RSA_WITH_AES_256_CBC_SHA256, cipher_TLS_DHE_DSS_WITH_AES_256_CBC_SHA256, cipher_TLS_DHE_RSA_WITH_AES_256_CBC_SHA256, cipher_TLS_DH_anon_WITH_AES_128_CBC_SHA256, cipher_TLS_DH_anon_WITH_AES_256_CBC_SHA256, cipher_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA, cipher_TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA, cipher_TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA, cipher_TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA, cipher_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA, cipher_TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA, cipher_TLS_PSK_WITH_RC4_128_SHA, cipher_TLS_PSK_WITH_3DES_EDE_CBC_SHA, cipher_TLS_PSK_WITH_AES_128_CBC_SHA, cipher_TLS_PSK_WITH_AES_256_CBC_SHA, cipher_TLS_DHE_PSK_WITH_RC4_128_SHA, cipher_TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA, cipher_TLS_DHE_PSK_WITH_AES_128_CBC_SHA, cipher_TLS_DHE_PSK_WITH_AES_256_CBC_SHA, cipher_TLS_RSA_PSK_WITH_RC4_128_SHA, cipher_TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA, cipher_TLS_RSA_PSK_WITH_AES_128_CBC_SHA, cipher_TLS_RSA_PSK_WITH_AES_256_CBC_SHA, cipher_TLS_RSA_WITH_SEED_CBC_SHA, cipher_TLS_DH_DSS_WITH_SEED_CBC_SHA, cipher_TLS_DH_RSA_WITH_SEED_CBC_SHA, cipher_TLS_DHE_DSS_WITH_SEED_CBC_SHA, cipher_TLS_DHE_RSA_WITH_SEED_CBC_SHA, cipher_TLS_DH_anon_WITH_SEED_CBC_SHA, cipher_TLS_RSA_WITH_AES_128_GCM_SHA256, cipher_TLS_RSA_WITH_AES_256_GCM_SHA384, cipher_TLS_DH_RSA_WITH_AES_128_GCM_SHA256, cipher_TLS_DH_RSA_WITH_AES_256_GCM_SHA384, cipher_TLS_DH_DSS_WITH_AES_128_GCM_SHA256, cipher_TLS_DH_DSS_WITH_AES_256_GCM_SHA384, cipher_TLS_DH_anon_WITH_AES_128_GCM_SHA256, cipher_TLS_DH_anon_WITH_AES_256_GCM_SHA384, cipher_TLS_PSK_WITH_AES_128_GCM_SHA256, cipher_TLS_PSK_WITH_AES_256_GCM_SHA384, cipher_TLS_RSA_PSK_WITH_AES_128_GCM_SHA256, cipher_TLS_RSA_PSK_WITH_AES_256_GCM_SHA384, cipher_TLS_PSK_WITH_AES_128_CBC_SHA256, cipher_TLS_PSK_WITH_AES_256_CBC_SHA384, cipher_TLS_PSK_WITH_NULL_SHA256, cipher_TLS_PSK_WITH_NULL_SHA384, cipher_TLS_DHE_PSK_WITH_AES_128_CBC_SHA256, cipher_TLS_DHE_PSK_WITH_AES_256_CBC_SHA384, cipher_TLS_DHE_PSK_WITH_NULL_SHA256, cipher_TLS_DHE_PSK_WITH_NULL_SHA384, cipher_TLS_RSA_PSK_WITH_AES_128_CBC_SHA256, cipher_TLS_RSA_PSK_WITH_AES_256_CBC_SHA384, cipher_TLS_RSA_PSK_WITH_NULL_SHA256, cipher_TLS_RSA_PSK_WITH_NULL_SHA384, cipher_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256, cipher_TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256, cipher_TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256, cipher_TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256, cipher_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256, cipher_TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256, cipher_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256, cipher_TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256, cipher_TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256, cipher_TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256, cipher_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256, cipher_TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256, cipher_TLS_EMPTY_RENEGOTIATION_INFO_SCSV, cipher_TLS_ECDH_ECDSA_WITH_NULL_SHA, cipher_TLS_ECDH_ECDSA_WITH_RC4_128_SHA, cipher_TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA, cipher_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA, cipher_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA, cipher_TLS_ECDHE_ECDSA_WITH_NULL_SHA, cipher_TLS_ECDHE_ECDSA_WITH_RC4_128_SHA, cipher_TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA, cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, cipher_TLS_ECDH_RSA_WITH_NULL_SHA, cipher_TLS_ECDH_RSA_WITH_RC4_128_SHA, cipher_TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA, cipher_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA, cipher_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA, cipher_TLS_ECDHE_RSA_WITH_NULL_SHA, cipher_TLS_ECDHE_RSA_WITH_RC4_128_SHA, cipher_TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA, cipher_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA, cipher_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA, cipher_TLS_ECDH_anon_WITH_NULL_SHA, cipher_TLS_ECDH_anon_WITH_RC4_128_SHA, cipher_TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA, cipher_TLS_ECDH_anon_WITH_AES_128_CBC_SHA, cipher_TLS_ECDH_anon_WITH_AES_256_CBC_SHA, cipher_TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA, cipher_TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA, cipher_TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA, cipher_TLS_SRP_SHA_WITH_AES_128_CBC_SHA, cipher_TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA, cipher_TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA, cipher_TLS_SRP_SHA_WITH_AES_256_CBC_SHA, cipher_TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA, cipher_TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA, cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256, cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384, cipher_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256, cipher_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384, cipher_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256, cipher_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384, cipher_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256, cipher_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384, cipher_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256, cipher_TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384, cipher_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256, cipher_TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384, cipher_TLS_ECDHE_PSK_WITH_RC4_128_SHA, cipher_TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA, cipher_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA, cipher_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA, cipher_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256, cipher_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384, cipher_TLS_ECDHE_PSK_WITH_NULL_SHA, cipher_TLS_ECDHE_PSK_WITH_NULL_SHA256, cipher_TLS_ECDHE_PSK_WITH_NULL_SHA384, cipher_TLS_RSA_WITH_ARIA_128_CBC_SHA256, cipher_TLS_RSA_WITH_ARIA_256_CBC_SHA384, cipher_TLS_DH_DSS_WITH_ARIA_128_CBC_SHA256, cipher_TLS_DH_DSS_WITH_ARIA_256_CBC_SHA384, cipher_TLS_DH_RSA_WITH_ARIA_128_CBC_SHA256, cipher_TLS_DH_RSA_WITH_ARIA_256_CBC_SHA384, cipher_TLS_DHE_DSS_WITH_ARIA_128_CBC_SHA256, cipher_TLS_DHE_DSS_WITH_ARIA_256_CBC_SHA384, cipher_TLS_DHE_RSA_WITH_ARIA_128_CBC_SHA256, cipher_TLS_DHE_RSA_WITH_ARIA_256_CBC_SHA384, cipher_TLS_DH_anon_WITH_ARIA_128_CBC_SHA256, cipher_TLS_DH_anon_WITH_ARIA_256_CBC_SHA384, cipher_TLS_ECDHE_ECDSA_WITH_ARIA_128_CBC_SHA256, cipher_TLS_ECDHE_ECDSA_WITH_ARIA_256_CBC_SHA384, cipher_TLS_ECDH_ECDSA_WITH_ARIA_128_CBC_SHA256, cipher_TLS_ECDH_ECDSA_WITH_ARIA_256_CBC_SHA384, cipher_TLS_ECDHE_RSA_WITH_ARIA_128_CBC_SHA256, cipher_TLS_ECDHE_RSA_WITH_ARIA_256_CBC_SHA384, cipher_TLS_ECDH_RSA_WITH_ARIA_128_CBC_SHA256, cipher_TLS_ECDH_RSA_WITH_ARIA_256_CBC_SHA384, cipher_TLS_RSA_WITH_ARIA_128_GCM_SHA256, cipher_TLS_RSA_WITH_ARIA_256_GCM_SHA384, cipher_TLS_DH_RSA_WITH_ARIA_128_GCM_SHA256, cipher_TLS_DH_RSA_WITH_ARIA_256_GCM_SHA384, cipher_TLS_DH_DSS_WITH_ARIA_128_GCM_SHA256, cipher_TLS_DH_DSS_WITH_ARIA_256_GCM_SHA384, cipher_TLS_DH_anon_WITH_ARIA_128_GCM_SHA256, cipher_TLS_DH_anon_WITH_ARIA_256_GCM_SHA384, cipher_TLS_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256, cipher_TLS_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384, cipher_TLS_ECDH_RSA_WITH_ARIA_128_GCM_SHA256, cipher_TLS_ECDH_RSA_WITH_ARIA_256_GCM_SHA384, cipher_TLS_PSK_WITH_ARIA_128_CBC_SHA256, cipher_TLS_PSK_WITH_ARIA_256_CBC_SHA384, cipher_TLS_DHE_PSK_WITH_ARIA_128_CBC_SHA256, cipher_TLS_DHE_PSK_WITH_ARIA_256_CBC_SHA384, cipher_TLS_RSA_PSK_WITH_ARIA_128_CBC_SHA256, cipher_TLS_RSA_PSK_WITH_ARIA_256_CBC_SHA384, cipher_TLS_PSK_WITH_ARIA_128_GCM_SHA256, cipher_TLS_PSK_WITH_ARIA_256_GCM_SHA384, cipher_TLS_RSA_PSK_WITH_ARIA_128_GCM_SHA256, cipher_TLS_RSA_PSK_WITH_ARIA_256_GCM_SHA384, cipher_TLS_ECDHE_PSK_WITH_ARIA_128_CBC_SHA256, cipher_TLS_ECDHE_PSK_WITH_ARIA_256_CBC_SHA384, cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256, cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384, cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256, cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384, cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256, cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384, cipher_TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256, cipher_TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384, cipher_TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256, cipher_TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384, cipher_TLS_DH_RSA_WITH_CAMELLIA_128_GCM_SHA256, cipher_TLS_DH_RSA_WITH_CAMELLIA_256_GCM_SHA384, cipher_TLS_DH_DSS_WITH_CAMELLIA_128_GCM_SHA256, cipher_TLS_DH_DSS_WITH_CAMELLIA_256_GCM_SHA384, cipher_TLS_DH_anon_WITH_CAMELLIA_128_GCM_SHA256, cipher_TLS_DH_anon_WITH_CAMELLIA_256_GCM_SHA384, cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256, cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384, cipher_TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256, cipher_TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384, cipher_TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256, cipher_TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384, cipher_TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256, cipher_TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384, cipher_TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256, cipher_TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384, cipher_TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256, cipher_TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384, cipher_TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256, cipher_TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384, cipher_TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256, cipher_TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384, cipher_TLS_RSA_WITH_AES_128_CCM, cipher_TLS_RSA_WITH_AES_256_CCM, cipher_TLS_RSA_WITH_AES_128_CCM_8, cipher_TLS_RSA_WITH_AES_256_CCM_8, cipher_TLS_PSK_WITH_AES_128_CCM, cipher_TLS_PSK_WITH_AES_256_CCM, cipher_TLS_PSK_WITH_AES_128_CCM_8, cipher_TLS_PSK_WITH_AES_256_CCM_8, }	12.77 KB	2025-05-25 12:27
📄 client_conn_pool.go // Copyright 2015 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Transport code's client connection pooling. package http2 import ( "context" "errors" "net" "net/http" "sync" ) // ClientConnPool manages a pool of HTTP/2 client connections. type ClientConnPool interface { // GetClientConn returns a specific HTTP/2 connection (usually // a TLS-TCP connection) to an HTTP/2 server. On success, the // returned ClientConn accounts for the upcoming RoundTrip // call, so the caller should not omit it. If the caller needs // to, ClientConn.RoundTrip can be called with a bogus // new(http.Request) to release the stream reservation. GetClientConn(req http.Request, addr string) (ClientConn, error) MarkDead(ClientConn) } // clientConnPoolIdleCloser is the interface implemented by ClientConnPool // implementations which can close their idle connections. type clientConnPoolIdleCloser interface { ClientConnPool closeIdleConnections() } var ( _ clientConnPoolIdleCloser = (clientConnPool)(nil) _ clientConnPoolIdleCloser = noDialClientConnPool{} ) // TODO: use singleflight for dialing and addConnCalls? type clientConnPool struct { t Transport mu sync.Mutex // TODO: maybe switch to RWMutex // TODO: add support for sharing conns based on cert names // (e.g. share conn for googleapis.com and appspot.com) conns map[string][]ClientConn // key is host:port dialing map[string]dialCall // currently in-flight dials keys map[ClientConn][]string addConnCalls map[string]addConnCall // in-flight addConnIfNeeded calls } func (p clientConnPool) GetClientConn(req http.Request, addr string) (ClientConn, error) { return p.getClientConn(req, addr, dialOnMiss) } const ( dialOnMiss = true noDialOnMiss = false ) func (p clientConnPool) getClientConn(req http.Request, addr string, dialOnMiss bool) (ClientConn, error) { // TODO(dneil): Dial a new connection when t.DisableKeepAlives is set? if isConnectionCloseRequest(req) && dialOnMiss { // It gets its own connection. traceGetConn(req, addr) const singleUse = true cc, err := p.t.dialClientConn(req.Context(), addr, singleUse) if err != nil { return nil, err } return cc, nil } for { p.mu.Lock() for _, cc := range p.conns[addr] { if cc.ReserveNewRequest() { // When a connection is presented to us by the net/http package, // the GetConn hook has already been called. // Don't call it a second time here. if !cc.getConnCalled { traceGetConn(req, addr) } cc.getConnCalled = false p.mu.Unlock() return cc, nil } } if !dialOnMiss { p.mu.Unlock() return nil, ErrNoCachedConn } traceGetConn(req, addr) call := p.getStartDialLocked(req.Context(), addr) p.mu.Unlock() <-call.done if shouldRetryDial(call, req) { continue } cc, err := call.res, call.err if err != nil { return nil, err } if cc.ReserveNewRequest() { return cc, nil } } } // dialCall is an in-flight Transport dial call to a host. type dialCall struct { _ incomparable p clientConnPool // the context associated with the request // that created this dialCall ctx context.Context done chan struct{} // closed when done res ClientConn // valid after done is closed err error // valid after done is closed } // requires p.mu is held. func (p clientConnPool) getStartDialLocked(ctx context.Context, addr string) dialCall { if call, ok := p.dialing[addr]; ok { // A dial is already in-flight. Don't start another. return call } call := &dialCall{p: p, done: make(chan struct{}), ctx: ctx} if p.dialing == nil { p.dialing = make(map[string]dialCall) } p.dialing[addr] = call go call.dial(call.ctx, addr) return call } // run in its own goroutine. func (c dialCall) dial(ctx context.Context, addr string) { const singleUse = false // shared conn c.res, c.err = c.p.t.dialClientConn(ctx, addr, singleUse) c.p.mu.Lock() delete(c.p.dialing, addr) if c.err == nil { c.p.addConnLocked(addr, c.res) } c.p.mu.Unlock() close(c.done) } // addConnIfNeeded makes a NewClientConn out of c if a connection for key doesn't // already exist. It coalesces concurrent calls with the same key. // This is used by the http1 Transport code when it creates a new connection. Because // the http1 Transport doesn't de-dup TCP dials to outbound hosts (because it doesn't know // the protocol), it can get into a situation where it has multiple TLS connections. // This code decides which ones live or die. // The return value used is whether c was used. // c is never closed. func (p clientConnPool) addConnIfNeeded(key string, t Transport, c net.Conn) (used bool, err error) { p.mu.Lock() for _, cc := range p.conns[key] { if cc.CanTakeNewRequest() { p.mu.Unlock() return false, nil } } call, dup := p.addConnCalls[key] if !dup { if p.addConnCalls == nil { p.addConnCalls = make(map[string]addConnCall) } call = &addConnCall{ p: p, done: make(chan struct{}), } p.addConnCalls[key] = call go call.run(t, key, c) } p.mu.Unlock() <-call.done if call.err != nil { return false, call.err } return !dup, nil } type addConnCall struct { _ incomparable p clientConnPool done chan struct{} // closed when done err error } func (c addConnCall) run(t Transport, key string, nc net.Conn) { cc, err := t.NewClientConn(nc) p := c.p p.mu.Lock() if err != nil { c.err = err } else { cc.getConnCalled = true // already called by the net/http package p.addConnLocked(key, cc) } delete(p.addConnCalls, key) p.mu.Unlock() close(c.done) } // p.mu must be held func (p clientConnPool) addConnLocked(key string, cc ClientConn) { for _, v := range p.conns[key] { if v == cc { return } } if p.conns == nil { p.conns = make(map[string][]ClientConn) } if p.keys == nil { p.keys = make(map[ClientConn][]string) } p.conns[key] = append(p.conns[key], cc) p.keys[cc] = append(p.keys[cc], key) } func (p clientConnPool) MarkDead(cc ClientConn) { p.mu.Lock() defer p.mu.Unlock() for _, key := range p.keys[cc] { vv, ok := p.conns[key] if !ok { continue } newList := filterOutClientConn(vv, cc) if len(newList) > 0 { p.conns[key] = newList } else { delete(p.conns, key) } } delete(p.keys, cc) } func (p clientConnPool) closeIdleConnections() { p.mu.Lock() defer p.mu.Unlock() // TODO: don't close a cc if it was just added to the pool // milliseconds ago and has never been used. There's currently // a small race window with the HTTP/1 Transport's integration // where it can add an idle conn just before using it, and // somebody else can concurrently call CloseIdleConns and // break some caller's RoundTrip. for _, vv := range p.conns { for _, cc := range vv { cc.closeIfIdle() } } } func filterOutClientConn(in []ClientConn, exclude ClientConn) []ClientConn { out := in[:0] for _, v := range in { if v != exclude { out = append(out, v) } } // If we filtered it out, zero out the last item to prevent // the GC from seeing it. if len(in) != len(out) { in[len(in)-1] = nil } return out } // noDialClientConnPool is an implementation of http2.ClientConnPool // which never dials. We let the HTTP/1.1 client dial and use its TLS // connection instead. type noDialClientConnPool struct{ clientConnPool } func (p noDialClientConnPool) GetClientConn(req http.Request, addr string) (ClientConn, error) { return p.getClientConn(req, addr, noDialOnMiss) } // shouldRetryDial reports whether the current request should // retry dialing after the call finished unsuccessfully, for example // if the dial was canceled because of a context cancellation or // deadline expiry. func shouldRetryDial(call dialCall, req http.Request) bool { if call.err == nil { // No error, no need to retry return false } if call.ctx == req.Context() { // If the call has the same context as the request, the dial // should not be retried, since any cancellation will have come // from this request. return false } if !errors.Is(call.err, context.Canceled) && !errors.Is(call.err, context.DeadlineExceeded) { // If the call error is not because of a context cancellation or a deadline expiry, // the dial should not be retried. return false } // Only retry if the error is a context cancellation error or deadline expiry // and the context associated with the call was canceled or expired. return call.ctx.Err() != nil }	8.39 KB	2025-05-25 12:27
📄 clientconn_test.go // Copyright 2024 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Infrastructure for testing ClientConn.RoundTrip. // Put actual tests in transport_test.go. package http2 import ( "bytes" "context" "crypto/tls" "fmt" "io" "net/http" "reflect" "sync/atomic" "testing" "time" "golang.org/x/net/http2/hpack" ) // TestTestClientConn demonstrates usage of testClientConn. func TestTestClientConn(t testing.T) { // newTestClientConn creates a ClientConn and surrounding test infrastructure. tc := newTestClientConn(t) // tc.greet reads the client's initial SETTINGS and WINDOW_UPDATE frames, // and sends a SETTINGS frame to the client. // // Additional settings may be provided as optional parameters to greet. tc.greet() // Request bodies must either be constant (bytes.Buffer, strings.Reader) // or created with newRequestBody. body := tc.newRequestBody() body.writeBytes(10) // 10 arbitrary bytes... body.closeWithError(io.EOF) // ...followed by EOF. // tc.roundTrip calls RoundTrip, but does not wait for it to return. // It returns a testRoundTrip. req, _ := http.NewRequest("PUT", "https://dummy.tld/", body) rt := tc.roundTrip(req) // tc has a number of methods to check for expected frames sent. // Here, we look for headers and the request body. tc.wantHeaders(wantHeader{ streamID: rt.streamID(), endStream: false, header: http.Header{ ":authority": []string{"dummy.tld"}, ":method": []string{"PUT"}, ":path": []string{"/"}, }, }) // Expect 10 bytes of request body in DATA frames. tc.wantData(wantData{ streamID: rt.streamID(), endStream: true, size: 10, multiple: true, }) // tc.writeHeaders sends a HEADERS frame back to the client. tc.writeHeaders(HeadersFrameParam{ StreamID: rt.streamID(), EndHeaders: true, EndStream: true, BlockFragment: tc.makeHeaderBlockFragment( ":status", "200", ), }) // Now that we've received headers, RoundTrip has finished. // testRoundTrip has various methods to examine the response, // or to fetch the response and/or error returned by RoundTrip rt.wantStatus(200) rt.wantBody(nil) } // A testClientConn allows testing ClientConn.RoundTrip against a fake server. // // A test using testClientConn consists of: // - actions on the client (calling RoundTrip, making data available to Request.Body); // - validation of frames sent by the client to the server; and // - providing frames from the server to the client. // // testClientConn manages synchronization, so tests can generally be written as // a linear sequence of actions and validations without additional synchronization. type testClientConn struct { t testing.T tr Transport fr Framer cc ClientConn group synctestGroup testConnFramer encbuf bytes.Buffer enc hpack.Encoder roundtrips []testRoundTrip netconn synctestNetConn } func newTestClientConnFromClientConn(t testing.T, cc ClientConn) testClientConn { tc := &testClientConn{ t: t, tr: cc.t, cc: cc, group: cc.t.transportTestHooks.group.(synctestGroup), } // srv is the side controlled by the test. var srv synctestNetConn if cc.tconn == nil { // If cc.tconn is nil, we're being called with a new conn created by the // Transport's client pool. This path skips dialing the server, and we // create a test connection pair here. cc.tconn, srv = synctestNetPipe(tc.group) } else { // If cc.tconn is non-nil, we're in a test which provides a conn to the // Transport via a TLSNextProto hook. Extract the test connection pair. if tc, ok := cc.tconn.(tls.Conn); ok { // Unwrap any tls.Conn to the underlying net.Conn, // to avoid dealing with encryption in tests. cc.tconn = tc.NetConn() } srv = cc.tconn.(synctestNetConn).peer } srv.SetReadDeadline(tc.group.Now()) srv.autoWait = true tc.netconn = srv tc.enc = hpack.NewEncoder(&tc.encbuf) tc.fr = NewFramer(srv, srv) tc.testConnFramer = testConnFramer{ t: t, fr: tc.fr, dec: hpack.NewDecoder(initialHeaderTableSize, nil), } tc.fr.SetMaxReadFrameSize(10 << 20) t.Cleanup(func() { tc.closeWrite() }) return tc } func (tc testClientConn) readClientPreface() { tc.t.Helper() // Read the client's HTTP/2 preface, sent prior to any HTTP/2 frames. buf := make([]byte, len(clientPreface)) if _, err := io.ReadFull(tc.netconn, buf); err != nil { tc.t.Fatalf("reading preface: %v", err) } if !bytes.Equal(buf, clientPreface) { tc.t.Fatalf("client preface: %q, want %q", buf, clientPreface) } } func newTestClientConn(t testing.T, opts ...any) testClientConn { t.Helper() tt := newTestTransport(t, opts...) const singleUse = false _, err := tt.tr.newClientConn(nil, singleUse) if err != nil { t.Fatalf("newClientConn: %v", err) } return tt.getConn() } // sync waits for the ClientConn under test to reach a stable state, // with all goroutines blocked on some input. func (tc testClientConn) sync() { tc.group.Wait() } // advance advances synthetic time by a duration. func (tc testClientConn) advance(d time.Duration) { tc.group.AdvanceTime(d) tc.sync() } // hasFrame reports whether a frame is available to be read. func (tc testClientConn) hasFrame() bool { return len(tc.netconn.Peek()) > 0 } // isClosed reports whether the peer has closed the connection. func (tc testClientConn) isClosed() bool { return tc.netconn.IsClosedByPeer() } // closeWrite causes the net.Conn used by the ClientConn to return a error // from Read calls. func (tc testClientConn) closeWrite() { tc.netconn.Close() } // testRequestBody is a Request.Body for use in tests. type testRequestBody struct { tc testClientConn gate gate // At most one of buf or bytes can be set at any given time: buf bytes.Buffer // specific bytes to read from the body bytes int // body contains this many arbitrary bytes err error // read error (comes after any available bytes) } func (tc testClientConn) newRequestBody() testRequestBody { b := &testRequestBody{ tc: tc, gate: newGate(), } return b } func (b testRequestBody) unlock() { b.gate.unlock(b.buf.Len() > 0 \|\| b.bytes > 0 \|\| b.err != nil) } // Read is called by the ClientConn to read from a request body. func (b testRequestBody) Read(p []byte) (n int, _ error) { if err := b.gate.waitAndLock(context.Background()); err != nil { return 0, err } defer b.unlock() switch { case b.buf.Len() > 0: return b.buf.Read(p) case b.bytes > 0: if len(p) > b.bytes { p = p[:b.bytes] } b.bytes -= len(p) for i := range p { p[i] = 'A' } return len(p), nil default: return 0, b.err } } // Close is called by the ClientConn when it is done reading from a request body. func (b testRequestBody) Close() error { return nil } // writeBytes adds n arbitrary bytes to the body. func (b testRequestBody) writeBytes(n int) { defer b.tc.sync() b.gate.lock() defer b.unlock() b.bytes += n b.checkWrite() b.tc.sync() } // Write adds bytes to the body. func (b testRequestBody) Write(p []byte) (int, error) { defer b.tc.sync() b.gate.lock() defer b.unlock() n, err := b.buf.Write(p) b.checkWrite() return n, err } func (b testRequestBody) checkWrite() { if b.bytes > 0 && b.buf.Len() > 0 { b.tc.t.Fatalf("can't interleave Write and writeBytes on request body") } if b.err != nil { b.tc.t.Fatalf("can't write to request body after closeWithError") } } // closeWithError sets an error which will be returned by Read. func (b testRequestBody) closeWithError(err error) { defer b.tc.sync() b.gate.lock() defer b.unlock() b.err = err } // roundTrip starts a RoundTrip call. // // (Note that the RoundTrip won't complete until response headers are received, // the request times out, or some other terminal condition is reached.) func (tc testClientConn) roundTrip(req http.Request) testRoundTrip { rt := &testRoundTrip{ t: tc.t, donec: make(chan struct{}), } tc.roundtrips = append(tc.roundtrips, rt) go func() { tc.group.Join() defer close(rt.donec) rt.resp, rt.respErr = tc.cc.roundTrip(req, func(cs clientStream) { rt.id.Store(cs.ID) }) }() tc.sync() tc.t.Cleanup(func() { if !rt.done() { return } res, _ := rt.result() if res != nil { res.Body.Close() } }) return rt } func (tc testClientConn) greet(settings ...Setting) { tc.wantFrameType(FrameSettings) tc.wantFrameType(FrameWindowUpdate) tc.writeSettings(settings...) tc.writeSettingsAck() tc.wantFrameType(FrameSettings) // acknowledgement } // makeHeaderBlockFragment encodes headers in a form suitable for inclusion // in a HEADERS or CONTINUATION frame. // // It takes a list of alernating names and values. func (tc testClientConn) makeHeaderBlockFragment(s ...string) []byte { if len(s)%2 != 0 { tc.t.Fatalf("uneven list of header name/value pairs") } tc.encbuf.Reset() for i := 0; i < len(s); i += 2 { tc.enc.WriteField(hpack.HeaderField{Name: s[i], Value: s[i+1]}) } return tc.encbuf.Bytes() } // inflowWindow returns the amount of inbound flow control available for a stream, // or for the connection if streamID is 0. func (tc testClientConn) inflowWindow(streamID uint32) int32 { tc.cc.mu.Lock() defer tc.cc.mu.Unlock() if streamID == 0 { return tc.cc.inflow.avail + tc.cc.inflow.unsent } cs := tc.cc.streams[streamID] if cs == nil { tc.t.Errorf("no stream with id %v", streamID) return -1 } return cs.inflow.avail + cs.inflow.unsent } // testRoundTrip manages a RoundTrip in progress. type testRoundTrip struct { t testing.T resp http.Response respErr error donec chan struct{} id atomic.Uint32 } // streamID returns the HTTP/2 stream ID of the request. func (rt testRoundTrip) streamID() uint32 { id := rt.id.Load() if id == 0 { panic("stream ID unknown") } return id } // done reports whether RoundTrip has returned. func (rt testRoundTrip) done() bool { select { case <-rt.donec: return true default: return false } } // result returns the result of the RoundTrip. func (rt testRoundTrip) result() (http.Response, error) { t := rt.t t.Helper() select { case <-rt.donec: default: t.Fatalf("RoundTrip is not done; want it to be") } return rt.resp, rt.respErr } // response returns the response of a successful RoundTrip. // If the RoundTrip unexpectedly failed, it calls t.Fatal. func (rt testRoundTrip) response() http.Response { t := rt.t t.Helper() resp, err := rt.result() if err != nil { t.Fatalf("RoundTrip returned unexpected error: %v", rt.respErr) } if resp == nil { t.Fatalf("RoundTrip returned nil Response and nil error") } return resp } // err returns the (possibly nil) error result of RoundTrip. func (rt testRoundTrip) err() error { t := rt.t t.Helper() _, err := rt.result() return err } // wantStatus indicates the expected response StatusCode. func (rt testRoundTrip) wantStatus(want int) { t := rt.t t.Helper() if got := rt.response().StatusCode; got != want { t.Fatalf("got response status %v, want %v", got, want) } } // body reads the contents of the response body. func (rt testRoundTrip) readBody() ([]byte, error) { t := rt.t t.Helper() return io.ReadAll(rt.response().Body) } // wantBody indicates the expected response body. // (Note that this consumes the body.) func (rt testRoundTrip) wantBody(want []byte) { t := rt.t t.Helper() got, err := rt.readBody() if err != nil { t.Fatalf("unexpected error reading response body: %v", err) } if !bytes.Equal(got, want) { t.Fatalf("unexpected response body:\ngot: %q\nwant: %q", got, want) } } // wantHeaders indicates the expected response headers. func (rt testRoundTrip) wantHeaders(want http.Header) { t := rt.t t.Helper() res := rt.response() if diff := diffHeaders(res.Header, want); diff != "" { t.Fatalf("unexpected response headers:\n%v", diff) } } // wantTrailers indicates the expected response trailers. func (rt testRoundTrip) wantTrailers(want http.Header) { t := rt.t t.Helper() res := rt.response() if diff := diffHeaders(res.Trailer, want); diff != "" { t.Fatalf("unexpected response trailers:\n%v", diff) } } func diffHeaders(got, want http.Header) string { // nil and 0-length non-nil are equal. if len(got) == 0 && len(want) == 0 { return "" } // We could do a more sophisticated diff here. // DeepEqual is good enough for now. if reflect.DeepEqual(got, want) { return "" } return fmt.Sprintf("got: %v\nwant: %v", got, want) } // A testTransport allows testing Transport.RoundTrip against fake servers. // Tests that aren't specifically exercising RoundTrip's retry loop or connection pooling // should use testClientConn instead. type testTransport struct { t testing.T tr Transport group synctestGroup ccs []testClientConn } func newTestTransport(t testing.T, opts ...any) testTransport { tt := &testTransport{ t: t, group: newSynctest(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)), } tt.group.Join() tr := &Transport{} for _, o := range opts { switch o := o.(type) { case func(http.Transport): if tr.t1 == nil { tr.t1 = &http.Transport{} } o(tr.t1) case func(Transport): o(tr) case Transport: tr = o } } tt.tr = tr tr.transportTestHooks = &transportTestHooks{ group: tt.group, newclientconn: func(cc ClientConn) { tc := newTestClientConnFromClientConn(t, cc) tt.ccs = append(tt.ccs, tc) }, } t.Cleanup(func() { tt.sync() if len(tt.ccs) > 0 { t.Fatalf("%v test ClientConns created, but not examined by test", len(tt.ccs)) } tt.group.Close(t) }) return tt } func (tt testTransport) sync() { tt.group.Wait() } func (tt testTransport) advance(d time.Duration) { tt.group.AdvanceTime(d) tt.sync() } func (tt testTransport) hasConn() bool { return len(tt.ccs) > 0 } func (tt testTransport) getConn() testClientConn { tt.t.Helper() if len(tt.ccs) == 0 { tt.t.Fatalf("no new ClientConns created; wanted one") } tc := tt.ccs[0] tt.ccs = tt.ccs[1:] tc.sync() tc.readClientPreface() tc.sync() return tc } func (tt testTransport) roundTrip(req http.Request) testRoundTrip { rt := &testRoundTrip{ t: tt.t, donec: make(chan struct{}), } go func() { tt.group.Join() defer close(rt.donec) rt.resp, rt.respErr = tt.tr.RoundTrip(req) }() tt.sync() tt.t.Cleanup(func() { if !rt.done() { return } res, _ := rt.result() if res != nil { res.Body.Close() } }) return rt }	14.23 KB	2025-05-25 12:27
📄 config.go // Copyright 2024 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import ( "math" "net/http" "time" ) // http2Config is a package-internal version of net/http.HTTP2Config. // // http.HTTP2Config was added in Go 1.24. // When running with a version of net/http that includes HTTP2Config, // we merge the configuration with the fields in Transport or Server // to produce an http2Config. // // Zero valued fields in http2Config are interpreted as in the // net/http.HTTPConfig documentation. // // Precedence order for reconciling configurations is: // // - Use the net/http.{Server,Transport}.HTTP2Config value, when non-zero. // - Otherwise use the http2.{Server.Transport} value. // - If the resulting value is zero or out of range, use a default. type http2Config struct { MaxConcurrentStreams uint32 MaxDecoderHeaderTableSize uint32 MaxEncoderHeaderTableSize uint32 MaxReadFrameSize uint32 MaxUploadBufferPerConnection int32 MaxUploadBufferPerStream int32 SendPingTimeout time.Duration PingTimeout time.Duration WriteByteTimeout time.Duration PermitProhibitedCipherSuites bool CountError func(errType string) } // configFromServer merges configuration settings from // net/http.Server.HTTP2Config and http2.Server. func configFromServer(h1 http.Server, h2 Server) http2Config { conf := http2Config{ MaxConcurrentStreams: h2.MaxConcurrentStreams, MaxEncoderHeaderTableSize: h2.MaxEncoderHeaderTableSize, MaxDecoderHeaderTableSize: h2.MaxDecoderHeaderTableSize, MaxReadFrameSize: h2.MaxReadFrameSize, MaxUploadBufferPerConnection: h2.MaxUploadBufferPerConnection, MaxUploadBufferPerStream: h2.MaxUploadBufferPerStream, SendPingTimeout: h2.ReadIdleTimeout, PingTimeout: h2.PingTimeout, WriteByteTimeout: h2.WriteByteTimeout, PermitProhibitedCipherSuites: h2.PermitProhibitedCipherSuites, CountError: h2.CountError, } fillNetHTTPServerConfig(&conf, h1) setConfigDefaults(&conf, true) return conf } // configFromServer merges configuration settings from h2 and h2.t1.HTTP2 // (the net/http Transport). func configFromTransport(h2 Transport) http2Config { conf := http2Config{ MaxEncoderHeaderTableSize: h2.MaxEncoderHeaderTableSize, MaxDecoderHeaderTableSize: h2.MaxDecoderHeaderTableSize, MaxReadFrameSize: h2.MaxReadFrameSize, SendPingTimeout: h2.ReadIdleTimeout, PingTimeout: h2.PingTimeout, WriteByteTimeout: h2.WriteByteTimeout, } // Unlike most config fields, where out-of-range values revert to the default, // Transport.MaxReadFrameSize clips. if conf.MaxReadFrameSize < minMaxFrameSize { conf.MaxReadFrameSize = minMaxFrameSize } else if conf.MaxReadFrameSize > maxFrameSize { conf.MaxReadFrameSize = maxFrameSize } if h2.t1 != nil { fillNetHTTPTransportConfig(&conf, h2.t1) } setConfigDefaults(&conf, false) return conf } func setDefault[T ~int \| ~int32 \| ~uint32 \| ~int64](v T, minval, maxval, defval T) { if v < minval \|\| v > maxval { v = defval } } func setConfigDefaults(conf http2Config, server bool) { setDefault(&conf.MaxConcurrentStreams, 1, math.MaxUint32, defaultMaxStreams) setDefault(&conf.MaxEncoderHeaderTableSize, 1, math.MaxUint32, initialHeaderTableSize) setDefault(&conf.MaxDecoderHeaderTableSize, 1, math.MaxUint32, initialHeaderTableSize) if server { setDefault(&conf.MaxUploadBufferPerConnection, initialWindowSize, math.MaxInt32, 1<<20) } else { setDefault(&conf.MaxUploadBufferPerConnection, initialWindowSize, math.MaxInt32, transportDefaultConnFlow) } if server { setDefault(&conf.MaxUploadBufferPerStream, 1, math.MaxInt32, 1<<20) } else { setDefault(&conf.MaxUploadBufferPerStream, 1, math.MaxInt32, transportDefaultStreamFlow) } setDefault(&conf.MaxReadFrameSize, minMaxFrameSize, maxFrameSize, defaultMaxReadFrameSize) setDefault(&conf.PingTimeout, 1, math.MaxInt64, 15time.Second) } // adjustHTTP1MaxHeaderSize converts a limit in bytes on the size of an HTTP/1 header // to an HTTP/2 MAX_HEADER_LIST_SIZE value. func adjustHTTP1MaxHeaderSize(n int64) int64 { // http2's count is in a slightly different unit and includes 32 bytes per pair. // So, take the net/http.Server value and pad it up a bit, assuming 10 headers. const perFieldOverhead = 32 // per http2 spec const typicalHeaders = 10 // conservative return n + typicalHeadersperFieldOverhead }	4.54 KB	2025-05-25 12:27
📄 config_go124.go // Copyright 2024 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.24 package http2 import "net/http" // fillNetHTTPServerConfig sets fields in conf from srv.HTTP2. func fillNetHTTPServerConfig(conf http2Config, srv http.Server) { fillNetHTTPConfig(conf, srv.HTTP2) } // fillNetHTTPServerConfig sets fields in conf from tr.HTTP2. func fillNetHTTPTransportConfig(conf http2Config, tr http.Transport) { fillNetHTTPConfig(conf, tr.HTTP2) } func fillNetHTTPConfig(conf http2Config, h2 http.HTTP2Config) { if h2 == nil { return } if h2.MaxConcurrentStreams != 0 { conf.MaxConcurrentStreams = uint32(h2.MaxConcurrentStreams) } if h2.MaxEncoderHeaderTableSize != 0 { conf.MaxEncoderHeaderTableSize = uint32(h2.MaxEncoderHeaderTableSize) } if h2.MaxDecoderHeaderTableSize != 0 { conf.MaxDecoderHeaderTableSize = uint32(h2.MaxDecoderHeaderTableSize) } if h2.MaxConcurrentStreams != 0 { conf.MaxConcurrentStreams = uint32(h2.MaxConcurrentStreams) } if h2.MaxReadFrameSize != 0 { conf.MaxReadFrameSize = uint32(h2.MaxReadFrameSize) } if h2.MaxReceiveBufferPerConnection != 0 { conf.MaxUploadBufferPerConnection = int32(h2.MaxReceiveBufferPerConnection) } if h2.MaxReceiveBufferPerStream != 0 { conf.MaxUploadBufferPerStream = int32(h2.MaxReceiveBufferPerStream) } if h2.SendPingTimeout != 0 { conf.SendPingTimeout = h2.SendPingTimeout } if h2.PingTimeout != 0 { conf.PingTimeout = h2.PingTimeout } if h2.WriteByteTimeout != 0 { conf.WriteByteTimeout = h2.WriteByteTimeout } if h2.PermitProhibitedCipherSuites { conf.PermitProhibitedCipherSuites = true } if h2.CountError != nil { conf.CountError = h2.CountError } }	1.74 KB	2025-05-25 12:27
📄 config_pre_go124.go // Copyright 2024 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build !go1.24 package http2 import "net/http" // Pre-Go 1.24 fallback. // The Server.HTTP2 and Transport.HTTP2 config fields were added in Go 1.24. func fillNetHTTPServerConfig(conf http2Config, srv http.Server) {} func fillNetHTTPTransportConfig(conf http2Config, tr http.Transport) {}	461 B	2025-05-25 12:27
📄 config_test.go // Copyright 2024 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build go1.24 package http2 import ( "net/http" "testing" "time" ) func TestConfigServerSettings(t testing.T) { config := &http.HTTP2Config{ MaxConcurrentStreams: 1, MaxDecoderHeaderTableSize: 1<<20 + 2, MaxEncoderHeaderTableSize: 1<<20 + 3, MaxReadFrameSize: 1<<20 + 4, MaxReceiveBufferPerConnection: 64<<10 + 5, MaxReceiveBufferPerStream: 64<<10 + 6, } const maxHeaderBytes = 4096 + 7 st := newServerTester(t, nil, func(s http.Server) { s.MaxHeaderBytes = maxHeaderBytes s.HTTP2 = config }) st.writePreface() st.writeSettings() st.wantSettings(map[SettingID]uint32{ SettingMaxConcurrentStreams: uint32(config.MaxConcurrentStreams), SettingHeaderTableSize: uint32(config.MaxDecoderHeaderTableSize), SettingInitialWindowSize: uint32(config.MaxReceiveBufferPerStream), SettingMaxFrameSize: uint32(config.MaxReadFrameSize), SettingMaxHeaderListSize: maxHeaderBytes + (32 * 10), }) } func TestConfigTransportSettings(t testing.T) { config := &http.HTTP2Config{ MaxConcurrentStreams: 1, // ignored by Transport MaxDecoderHeaderTableSize: 1<<20 + 2, MaxEncoderHeaderTableSize: 1<<20 + 3, MaxReadFrameSize: 1<<20 + 4, MaxReceiveBufferPerConnection: 64<<10 + 5, MaxReceiveBufferPerStream: 64<<10 + 6, } const maxHeaderBytes = 4096 + 7 tc := newTestClientConn(t, func(tr http.Transport) { tr.HTTP2 = config tr.MaxResponseHeaderBytes = maxHeaderBytes }) tc.wantSettings(map[SettingID]uint32{ SettingHeaderTableSize: uint32(config.MaxDecoderHeaderTableSize), SettingInitialWindowSize: uint32(config.MaxReceiveBufferPerStream), SettingMaxFrameSize: uint32(config.MaxReadFrameSize), SettingMaxHeaderListSize: maxHeaderBytes + (32 * 10), }) tc.wantWindowUpdate(0, uint32(config.MaxReceiveBufferPerConnection)) } func TestConfigPingTimeoutServer(t testing.T) { st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { }, func(s Server) { s.ReadIdleTimeout = 2 time.Second s.PingTimeout = 3 * time.Second }) st.greet() st.advance(2 * time.Second) _ = readFrame[PingFrame](t, st) st.advance(3 time.Second) st.wantClosed() } func TestConfigPingTimeoutTransport(t testing.T) { tc := newTestClientConn(t, func(tr Transport) { tr.ReadIdleTimeout = 2 * time.Second tr.PingTimeout = 3 * time.Second }) tc.greet() req, _ := http.NewRequest("GET", "https://dummy.tld/", nil) rt := tc.roundTrip(req) tc.wantFrameType(FrameHeaders) tc.advance(2 * time.Second) tc.wantFrameType(FramePing) tc.advance(3 * time.Second) err := rt.err() if err == nil { t.Fatalf("expected connection to close") } }	2.79 KB	2025-05-25 12:27
📄 connframes_test.go // Copyright 2024 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import ( "bytes" "io" "net/http" "os" "reflect" "slices" "testing" "golang.org/x/net/http2/hpack" ) type testConnFramer struct { t testing.TB fr Framer dec hpack.Decoder } // readFrame reads the next frame. // It returns nil if the conn is closed or no frames are available. func (tf testConnFramer) readFrame() Frame { tf.t.Helper() fr, err := tf.fr.ReadFrame() if err == io.EOF \|\| err == os.ErrDeadlineExceeded { return nil } if err != nil { tf.t.Fatalf("ReadFrame: %v", err) } return fr } type readFramer interface { readFrame() Frame } // readFrame reads a frame of a specific type. func readFrame[T any](t testing.TB, framer readFramer) T { t.Helper() var v T fr := framer.readFrame() if fr == nil { t.Fatalf("got no frame, want frame %T", v) } v, ok := fr.(T) if !ok { t.Fatalf("got frame %T, want %T", fr, v) } return v } // wantFrameType reads the next frame. // It produces an error if the frame type is not the expected value. func (tf testConnFramer) wantFrameType(want FrameType) { tf.t.Helper() fr := tf.readFrame() if fr == nil { tf.t.Fatalf("got no frame, want frame %v", want) } if got := fr.Header().Type; got != want { tf.t.Fatalf("got frame %v, want %v", got, want) } } // wantUnorderedFrames reads frames until every condition in want has been satisfied. // // want is a list of func(SomeFrame) bool. // wantUnorderedFrames will call each func with frames of the appropriate type // until the func returns true. // It calls t.Fatal if an unexpected frame is received (no func has that frame type, // or all funcs with that type have returned true), or if the framer runs out of frames // with unsatisfied funcs. // // Example: // // // Read a SETTINGS frame, and any number of DATA frames for a stream. // // The SETTINGS frame may appear anywhere in the sequence. // // The last DATA frame must indicate the end of the stream. // tf.wantUnorderedFrames( // func(f SettingsFrame) bool { // return true // }, // func(f DataFrame) bool { // return f.StreamEnded() // }, // ) func (tf testConnFramer) wantUnorderedFrames(want ...any) { tf.t.Helper() want = slices.Clone(want) seen := 0 frame: for seen < len(want) && !tf.t.Failed() { fr := tf.readFrame() if fr == nil { break } for i, f := range want { if f == nil { continue } typ := reflect.TypeOf(f) if typ.Kind() != reflect.Func \|\| typ.NumIn() != 1 \|\| typ.NumOut() != 1 \|\| typ.Out(0) != reflect.TypeOf(true) { tf.t.Fatalf("expected func(SomeFrame) bool, got %T", f) } if typ.In(0) == reflect.TypeOf(fr) { out := reflect.ValueOf(f).Call([]reflect.Value{reflect.ValueOf(fr)}) if out[0].Bool() { want[i] = nil seen++ } continue frame } } tf.t.Errorf("got unexpected frame type %T", fr) } if seen < len(want) { for _, f := range want { if f == nil { continue } tf.t.Errorf("did not see expected frame: %v", reflect.TypeOf(f).In(0)) } tf.t.Fatalf("did not see %v expected frame types", len(want)-seen) } } type wantHeader struct { streamID uint32 endStream bool header http.Header } // wantHeaders reads a HEADERS frame and potential CONTINUATION frames, // and asserts that they contain the expected headers. func (tf testConnFramer) wantHeaders(want wantHeader) { tf.t.Helper() hf := readFrame[HeadersFrame](tf.t, tf) if got, want := hf.StreamID, want.streamID; got != want { tf.t.Fatalf("got stream ID %v, want %v", got, want) } if got, want := hf.StreamEnded(), want.endStream; got != want { tf.t.Fatalf("got stream ended %v, want %v", got, want) } gotHeader := make(http.Header) tf.dec.SetEmitFunc(func(hf hpack.HeaderField) { gotHeader[hf.Name] = append(gotHeader[hf.Name], hf.Value) }) defer tf.dec.SetEmitFunc(nil) if _, err := tf.dec.Write(hf.HeaderBlockFragment()); err != nil { tf.t.Fatalf("decoding HEADERS frame: %v", err) } headersEnded := hf.HeadersEnded() for !headersEnded { cf := readFrame[ContinuationFrame](tf.t, tf) if cf == nil { tf.t.Fatalf("got end of frames, want CONTINUATION") } if _, err := tf.dec.Write(cf.HeaderBlockFragment()); err != nil { tf.t.Fatalf("decoding CONTINUATION frame: %v", err) } headersEnded = cf.HeadersEnded() } if err := tf.dec.Close(); err != nil { tf.t.Fatalf("hpack decoding error: %v", err) } for k, v := range want.header { if !reflect.DeepEqual(v, gotHeader[k]) { tf.t.Fatalf("got header %q = %q; want %q", k, v, gotHeader[k]) } } } // decodeHeader supports some older server tests. // TODO: rewrite those tests to use newer, more convenient test APIs. func (tf testConnFramer) decodeHeader(headerBlock []byte) (pairs [][2]string) { tf.dec.SetEmitFunc(func(hf hpack.HeaderField) { if hf.Name == "date" { return } pairs = append(pairs, [2]string{hf.Name, hf.Value}) }) defer tf.dec.SetEmitFunc(nil) if _, err := tf.dec.Write(headerBlock); err != nil { tf.t.Fatalf("hpack decoding error: %v", err) } if err := tf.dec.Close(); err != nil { tf.t.Fatalf("hpack decoding error: %v", err) } return pairs } type wantData struct { streamID uint32 endStream bool size int data []byte multiple bool // data may be spread across multiple DATA frames } // wantData reads zero or more DATA frames, and asserts that they match the expectation. func (tf testConnFramer) wantData(want wantData) { tf.t.Helper() gotSize := 0 gotEndStream := false if want.data != nil { want.size = len(want.data) } var gotData []byte for { fr := tf.readFrame() if fr == nil { break } data, ok := fr.(DataFrame) if !ok { tf.t.Fatalf("got frame %T, want DataFrame", fr) } if want.data != nil { gotData = append(gotData, data.Data()...) } gotSize += len(data.Data()) if data.StreamEnded() { gotEndStream = true break } if !want.endStream && gotSize >= want.size { break } if !want.multiple { break } } if gotSize != want.size { tf.t.Fatalf("got %v bytes of DATA frames, want %v", gotSize, want.size) } if gotEndStream != want.endStream { tf.t.Fatalf("after %v bytes of DATA frames, got END_STREAM=%v; want %v", gotSize, gotEndStream, want.endStream) } if want.data != nil && !bytes.Equal(gotData, want.data) { tf.t.Fatalf("got data %q, want %q", gotData, want.data) } } func (tf testConnFramer) wantRSTStream(streamID uint32, code ErrCode) { tf.t.Helper() fr := readFrame[RSTStreamFrame](tf.t, tf) if fr.StreamID != streamID \|\| fr.ErrCode != code { tf.t.Fatalf("got %v, want RST_STREAM StreamID=%v, code=%v", summarizeFrame(fr), streamID, code) } } func (tf testConnFramer) wantSettings(want map[SettingID]uint32) { fr := readFrame[SettingsFrame](tf.t, tf) if fr.Header().Flags.Has(FlagSettingsAck) { tf.t.Errorf("got SETTINGS frame with ACK set, want no ACK") } for wantID, wantVal := range want { gotVal, ok := fr.Value(wantID) if !ok { tf.t.Errorf("SETTINGS: %v is not set, want %v", wantID, wantVal) } else if gotVal != wantVal { tf.t.Errorf("SETTINGS: %v is %v, want %v", wantID, gotVal, wantVal) } } if tf.t.Failed() { tf.t.Fatalf("%v", fr) } } func (tf testConnFramer) wantSettingsAck() { tf.t.Helper() fr := readFrame[SettingsFrame](tf.t, tf) if !fr.Header().Flags.Has(FlagSettingsAck) { tf.t.Fatal("Settings Frame didn't have ACK set") } } func (tf testConnFramer) wantGoAway(maxStreamID uint32, code ErrCode) { tf.t.Helper() fr := readFrame[GoAwayFrame](tf.t, tf) if fr.LastStreamID != maxStreamID \|\| fr.ErrCode != code { tf.t.Fatalf("got %v, want GOAWAY LastStreamID=%v, code=%v", summarizeFrame(fr), maxStreamID, code) } } func (tf testConnFramer) wantWindowUpdate(streamID, incr uint32) { tf.t.Helper() wu := readFrame[WindowUpdateFrame](tf.t, tf) if wu.FrameHeader.StreamID != streamID { tf.t.Fatalf("WindowUpdate StreamID = %d; want %d", wu.FrameHeader.StreamID, streamID) } if wu.Increment != incr { tf.t.Fatalf("WindowUpdate increment = %d; want %d", wu.Increment, incr) } } func (tf testConnFramer) wantClosed() { tf.t.Helper() fr, err := tf.fr.ReadFrame() if err == nil { tf.t.Fatalf("got unexpected frame (want closed connection): %v", fr) } if err == os.ErrDeadlineExceeded { tf.t.Fatalf("connection is not closed; want it to be") } } func (tf testConnFramer) wantIdle() { tf.t.Helper() fr, err := tf.fr.ReadFrame() if err == nil { tf.t.Fatalf("got unexpected frame (want idle connection): %v", fr) } if err != os.ErrDeadlineExceeded { tf.t.Fatalf("got unexpected frame error (want idle connection): %v", err) } } func (tf testConnFramer) writeSettings(settings ...Setting) { tf.t.Helper() if err := tf.fr.WriteSettings(settings...); err != nil { tf.t.Fatal(err) } } func (tf testConnFramer) writeSettingsAck() { tf.t.Helper() if err := tf.fr.WriteSettingsAck(); err != nil { tf.t.Fatal(err) } } func (tf testConnFramer) writeData(streamID uint32, endStream bool, data []byte) { tf.t.Helper() if err := tf.fr.WriteData(streamID, endStream, data); err != nil { tf.t.Fatal(err) } } func (tf testConnFramer) writeDataPadded(streamID uint32, endStream bool, data, pad []byte) { tf.t.Helper() if err := tf.fr.WriteDataPadded(streamID, endStream, data, pad); err != nil { tf.t.Fatal(err) } } func (tf testConnFramer) writeHeaders(p HeadersFrameParam) { tf.t.Helper() if err := tf.fr.WriteHeaders(p); err != nil { tf.t.Fatal(err) } } // writeHeadersMode writes header frames, as modified by mode: // // - noHeader: Don't write the header. // - oneHeader: Write a single HEADERS frame. // - splitHeader: Write a HEADERS frame and CONTINUATION frame. func (tf testConnFramer) writeHeadersMode(mode headerType, p HeadersFrameParam) { tf.t.Helper() switch mode { case noHeader: case oneHeader: tf.writeHeaders(p) case splitHeader: if len(p.BlockFragment) < 2 { panic("too small") } contData := p.BlockFragment[1:] contEnd := p.EndHeaders p.BlockFragment = p.BlockFragment[:1] p.EndHeaders = false tf.writeHeaders(p) tf.writeContinuation(p.StreamID, contEnd, contData) default: panic("bogus mode") } } func (tf testConnFramer) writeContinuation(streamID uint32, endHeaders bool, headerBlockFragment []byte) { tf.t.Helper() if err := tf.fr.WriteContinuation(streamID, endHeaders, headerBlockFragment); err != nil { tf.t.Fatal(err) } } func (tf testConnFramer) writePriority(id uint32, p PriorityParam) { if err := tf.fr.WritePriority(id, p); err != nil { tf.t.Fatal(err) } } func (tf testConnFramer) writeRSTStream(streamID uint32, code ErrCode) { tf.t.Helper() if err := tf.fr.WriteRSTStream(streamID, code); err != nil { tf.t.Fatal(err) } } func (tf testConnFramer) writePing(ack bool, data [8]byte) { tf.t.Helper() if err := tf.fr.WritePing(ack, data); err != nil { tf.t.Fatal(err) } } func (tf testConnFramer) writeGoAway(maxStreamID uint32, code ErrCode, debugData []byte) { tf.t.Helper() if err := tf.fr.WriteGoAway(maxStreamID, code, debugData); err != nil { tf.t.Fatal(err) } } func (tf *testConnFramer) writeWindowUpdate(streamID, incr uint32) { tf.t.Helper() if err := tf.fr.WriteWindowUpdate(streamID, incr); err != nil { tf.t.Fatal(err) } }	11.13 KB	2025-05-25 12:27
📄 databuffer.go // Copyright 2014 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import ( "errors" "fmt" "sync" ) // Buffer chunks are allocated from a pool to reduce pressure on GC. // The maximum wasted space per dataBuffer is 2x the largest size class, // which happens when the dataBuffer has multiple chunks and there is // one unread byte in both the first and last chunks. We use a few size // classes to minimize overheads for servers that typically receive very // small request bodies. // // TODO: Benchmark to determine if the pools are necessary. The GC may have // improved enough that we can instead allocate chunks like this: // make([]byte, max(16<<10, expectedBytesRemaining)) var dataChunkPools = [...]sync.Pool{ {New: func() interface{} { return new([1 << 10]byte) }}, {New: func() interface{} { return new([2 << 10]byte) }}, {New: func() interface{} { return new([4 << 10]byte) }}, {New: func() interface{} { return new([8 << 10]byte) }}, {New: func() interface{} { return new([16 << 10]byte) }}, } func getDataBufferChunk(size int64) []byte { switch { case size <= 1<<10: return dataChunkPools[0].Get().([1 << 10]byte)[:] case size <= 2<<10: return dataChunkPools[1].Get().([2 << 10]byte)[:] case size <= 4<<10: return dataChunkPools[2].Get().([4 << 10]byte)[:] case size <= 8<<10: return dataChunkPools[3].Get().([8 << 10]byte)[:] default: return dataChunkPools[4].Get().([16 << 10]byte)[:] } } func putDataBufferChunk(p []byte) { switch len(p) { case 1 << 10: dataChunkPools[0].Put(([1 << 10]byte)(p)) case 2 << 10: dataChunkPools[1].Put(([2 << 10]byte)(p)) case 4 << 10: dataChunkPools[2].Put(([4 << 10]byte)(p)) case 8 << 10: dataChunkPools[3].Put(([8 << 10]byte)(p)) case 16 << 10: dataChunkPools[4].Put(([16 << 10]byte)(p)) default: panic(fmt.Sprintf("unexpected buffer len=%v", len(p))) } } // dataBuffer is an io.ReadWriter backed by a list of data chunks. // Each dataBuffer is used to read DATA frames on a single stream. // The buffer is divided into chunks so the server can limit the // total memory used by a single connection without limiting the // request body size on any single stream. type dataBuffer struct { chunks [][]byte r int // next byte to read is chunks[0][r] w int // next byte to write is chunks[len(chunks)-1][w] size int // total buffered bytes expected int64 // we expect at least this many bytes in future Write calls (ignored if <= 0) } var errReadEmpty = errors.New("read from empty dataBuffer") // Read copies bytes from the buffer into p. // It is an error to read when no data is available. func (b dataBuffer) Read(p []byte) (int, error) { if b.size == 0 { return 0, errReadEmpty } var ntotal int for len(p) > 0 && b.size > 0 { readFrom := b.bytesFromFirstChunk() n := copy(p, readFrom) p = p[n:] ntotal += n b.r += n b.size -= n // If the first chunk has been consumed, advance to the next chunk. if b.r == len(b.chunks[0]) { putDataBufferChunk(b.chunks[0]) end := len(b.chunks) - 1 copy(b.chunks[:end], b.chunks[1:]) b.chunks[end] = nil b.chunks = b.chunks[:end] b.r = 0 } } return ntotal, nil } func (b dataBuffer) bytesFromFirstChunk() []byte { if len(b.chunks) == 1 { return b.chunks[0][b.r:b.w] } return b.chunks[0][b.r:] } // Len returns the number of bytes of the unread portion of the buffer. func (b dataBuffer) Len() int { return b.size } // Write appends p to the buffer. func (b dataBuffer) Write(p []byte) (int, error) { ntotal := len(p) for len(p) > 0 { // If the last chunk is empty, allocate a new chunk. Try to allocate // enough to fully copy p plus any additional bytes we expect to // receive. However, this may allocate less than len(p). want := int64(len(p)) if b.expected > want { want = b.expected } chunk := b.lastChunkOrAlloc(want) n := copy(chunk[b.w:], p) p = p[n:] b.w += n b.size += n b.expected -= int64(n) } return ntotal, nil } func (b *dataBuffer) lastChunkOrAlloc(want int64) []byte { if len(b.chunks) != 0 { last := b.chunks[len(b.chunks)-1] if b.w < len(last) { return last } } chunk := getDataBufferChunk(want) b.chunks = append(b.chunks, chunk) b.w = 0 return chunk }	4.26 KB	2025-05-25 12:27
📄 databuffer_test.go // Copyright 2017 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import ( "bytes" "fmt" "reflect" "testing" ) func fmtDataChunk(chunk []byte) string { out := "" var last byte var count int for _, c := range chunk { if c != last { if count > 0 { out += fmt.Sprintf(" x %d ", count) count = 0 } out += string([]byte{c}) last = c } count++ } if count > 0 { out += fmt.Sprintf(" x %d", count) } return out } func fmtDataChunks(chunks [][]byte) string { var out string for _, chunk := range chunks { out += fmt.Sprintf("{%q}", fmtDataChunk(chunk)) } return out } func testDataBuffer(t testing.T, wantBytes []byte, setup func(t testing.T) dataBuffer) { // Run setup, then read the remaining bytes from the dataBuffer and check // that they match wantBytes. We use different read sizes to check corner // cases in Read. for _, readSize := range []int{1, 2, 1 1024, 32 * 1024} { t.Run(fmt.Sprintf("ReadSize=%d", readSize), func(t testing.T) { b := setup(t) buf := make([]byte, readSize) var gotRead bytes.Buffer for { n, err := b.Read(buf) gotRead.Write(buf[:n]) if err == errReadEmpty { break } if err != nil { t.Fatalf("error after %v bytes: %v", gotRead.Len(), err) } } if got, want := gotRead.Bytes(), wantBytes; !bytes.Equal(got, want) { t.Errorf("FinalRead=%q, want %q", fmtDataChunk(got), fmtDataChunk(want)) } }) } } func TestDataBufferAllocation(t testing.T) { writes := [][]byte{ bytes.Repeat([]byte("a"), 11024-1), []byte("a"), bytes.Repeat([]byte("b"), 41024-1), []byte("b"), bytes.Repeat([]byte("c"), 81024-1), []byte("c"), bytes.Repeat([]byte("d"), 161024-1), []byte("d"), bytes.Repeat([]byte("e"), 321024), } var wantRead bytes.Buffer for _, p := range writes { wantRead.Write(p) } testDataBuffer(t, wantRead.Bytes(), func(t testing.T) dataBuffer { b := &dataBuffer{} for _, p := range writes { if n, err := b.Write(p); n != len(p) \|\| err != nil { t.Fatalf("Write(%q x %d)=%v,%v want %v,nil", p[:1], len(p), n, err, len(p)) } } want := [][]byte{ bytes.Repeat([]byte("a"), 11024), bytes.Repeat([]byte("b"), 41024), bytes.Repeat([]byte("c"), 81024), bytes.Repeat([]byte("d"), 161024), bytes.Repeat([]byte("e"), 161024), bytes.Repeat([]byte("e"), 161024), } if !reflect.DeepEqual(b.chunks, want) { t.Errorf("dataBuffer.chunks\ngot: %s\nwant: %s", fmtDataChunks(b.chunks), fmtDataChunks(want)) } return b }) } func TestDataBufferAllocationWithExpected(t testing.T) { writes := [][]byte{ bytes.Repeat([]byte("a"), 11024), // allocates 16KB bytes.Repeat([]byte("b"), 141024), bytes.Repeat([]byte("c"), 151024), // allocates 16KB more bytes.Repeat([]byte("d"), 21024), bytes.Repeat([]byte("e"), 11024), // overflows 32KB expectation, allocates just 1KB } var wantRead bytes.Buffer for _, p := range writes { wantRead.Write(p) } testDataBuffer(t, wantRead.Bytes(), func(t testing.T) dataBuffer { b := &dataBuffer{expected: 32 1024} for _, p := range writes { if n, err := b.Write(p); n != len(p) \|\| err != nil { t.Fatalf("Write(%q x %d)=%v,%v want %v,nil", p[:1], len(p), n, err, len(p)) } } want := [][]byte{ append(bytes.Repeat([]byte("a"), 11024), append(bytes.Repeat([]byte("b"), 141024), bytes.Repeat([]byte("c"), 11024)...)...), append(bytes.Repeat([]byte("c"), 141024), bytes.Repeat([]byte("d"), 21024)...), bytes.Repeat([]byte("e"), 11024), } if !reflect.DeepEqual(b.chunks, want) { t.Errorf("dataBuffer.chunks\ngot: %s\nwant: %s", fmtDataChunks(b.chunks), fmtDataChunks(want)) } return b }) } func TestDataBufferWriteAfterPartialRead(t testing.T) { testDataBuffer(t, []byte("cdxyz"), func(t testing.T) *dataBuffer { b := &dataBuffer{} if n, err := b.Write([]byte("abcd")); n != 4 \|\| err != nil { t.Fatalf("Write(\"abcd\")=%v,%v want 4,nil", n, err) } p := make([]byte, 2) if n, err := b.Read(p); n != 2 \|\| err != nil \|\| !bytes.Equal(p, []byte("ab")) { t.Fatalf("Read()=%q,%v,%v want \"ab\",2,nil", p, n, err) } if n, err := b.Write([]byte("xyz")); n != 3 \|\| err != nil { t.Fatalf("Write(\"xyz\")=%v,%v want 3,nil", n, err) } return b }) }	4.28 KB	2025-05-25 12:27
📄 errors.go // Copyright 2014 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import ( "errors" "fmt" ) // An ErrCode is an unsigned 32-bit error code as defined in the HTTP/2 spec. type ErrCode uint32 const ( ErrCodeNo ErrCode = 0x0 ErrCodeProtocol ErrCode = 0x1 ErrCodeInternal ErrCode = 0x2 ErrCodeFlowControl ErrCode = 0x3 ErrCodeSettingsTimeout ErrCode = 0x4 ErrCodeStreamClosed ErrCode = 0x5 ErrCodeFrameSize ErrCode = 0x6 ErrCodeRefusedStream ErrCode = 0x7 ErrCodeCancel ErrCode = 0x8 ErrCodeCompression ErrCode = 0x9 ErrCodeConnect ErrCode = 0xa ErrCodeEnhanceYourCalm ErrCode = 0xb ErrCodeInadequateSecurity ErrCode = 0xc ErrCodeHTTP11Required ErrCode = 0xd ) var errCodeName = map[ErrCode]string{ ErrCodeNo: "NO_ERROR", ErrCodeProtocol: "PROTOCOL_ERROR", ErrCodeInternal: "INTERNAL_ERROR", ErrCodeFlowControl: "FLOW_CONTROL_ERROR", ErrCodeSettingsTimeout: "SETTINGS_TIMEOUT", ErrCodeStreamClosed: "STREAM_CLOSED", ErrCodeFrameSize: "FRAME_SIZE_ERROR", ErrCodeRefusedStream: "REFUSED_STREAM", ErrCodeCancel: "CANCEL", ErrCodeCompression: "COMPRESSION_ERROR", ErrCodeConnect: "CONNECT_ERROR", ErrCodeEnhanceYourCalm: "ENHANCE_YOUR_CALM", ErrCodeInadequateSecurity: "INADEQUATE_SECURITY", ErrCodeHTTP11Required: "HTTP_1_1_REQUIRED", } func (e ErrCode) String() string { if s, ok := errCodeName[e]; ok { return s } return fmt.Sprintf("unknown error code 0x%x", uint32(e)) } func (e ErrCode) stringToken() string { if s, ok := errCodeName[e]; ok { return s } return fmt.Sprintf("ERR_UNKNOWN_%d", uint32(e)) } // ConnectionError is an error that results in the termination of the // entire connection. type ConnectionError ErrCode func (e ConnectionError) Error() string { return fmt.Sprintf("connection error: %s", ErrCode(e)) } // StreamError is an error that only affects one stream within an // HTTP/2 connection. type StreamError struct { StreamID uint32 Code ErrCode Cause error // optional additional detail } // errFromPeer is a sentinel error value for StreamError.Cause to // indicate that the StreamError was sent from the peer over the wire // and wasn't locally generated in the Transport. var errFromPeer = errors.New("received from peer") func streamError(id uint32, code ErrCode) StreamError { return StreamError{StreamID: id, Code: code} } func (e StreamError) Error() string { if e.Cause != nil { return fmt.Sprintf("stream error: stream ID %d; %v; %v", e.StreamID, e.Code, e.Cause) } return fmt.Sprintf("stream error: stream ID %d; %v", e.StreamID, e.Code) } // 6.9.1 The Flow Control Window // "If a sender receives a WINDOW_UPDATE that causes a flow control // window to exceed this maximum it MUST terminate either the stream // or the connection, as appropriate. For streams, [...]; for the // connection, a GOAWAY frame with a FLOW_CONTROL_ERROR code." type goAwayFlowError struct{} func (goAwayFlowError) Error() string { return "connection exceeded flow control window size" } // connError represents an HTTP/2 ConnectionError error code, along // with a string (for debugging) explaining why. // // Errors of this type are only returned by the frame parser functions // and converted into ConnectionError(Code), after stashing away // the Reason into the Framer's errDetail field, accessible via // the (*Framer).ErrorDetail method. type connError struct { Code ErrCode // the ConnectionError error code Reason string // additional reason } func (e connError) Error() string { return fmt.Sprintf("http2: connection error: %v: %v", e.Code, e.Reason) } type pseudoHeaderError string func (e pseudoHeaderError) Error() string { return fmt.Sprintf("invalid pseudo-header %q", string(e)) } type duplicatePseudoHeaderError string func (e duplicatePseudoHeaderError) Error() string { return fmt.Sprintf("duplicate pseudo-header %q", string(e)) } type headerFieldNameError string func (e headerFieldNameError) Error() string { return fmt.Sprintf("invalid header field name %q", string(e)) } type headerFieldValueError string func (e headerFieldValueError) Error() string { return fmt.Sprintf("invalid header field value for %q", string(e)) } var ( errMixPseudoHeaderTypes = errors.New("mix of request and response pseudo headers") errPseudoAfterRegular = errors.New("pseudo header field after regular") )	4.52 KB	2025-05-25 12:27
📄 errors_test.go // Copyright 2014 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import "testing" func TestErrCodeString(t *testing.T) { tests := []struct { err ErrCode want string }{ {ErrCodeProtocol, "PROTOCOL_ERROR"}, {0xd, "HTTP_1_1_REQUIRED"}, {0xf, "unknown error code 0xf"}, } for i, tt := range tests { got := tt.err.String() if got != tt.want { t.Errorf("%d. Error = %q; want %q", i, got, tt.want) } } }	533 B	2025-05-25 12:27
📄 flow.go // Copyright 2014 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Flow control package http2 // inflowMinRefresh is the minimum number of bytes we'll send for a // flow control window update. const inflowMinRefresh = 4 << 10 // inflow accounts for an inbound flow control window. // It tracks both the latest window sent to the peer (used for enforcement) // and the accumulated unsent window. type inflow struct { avail int32 unsent int32 } // init sets the initial window. func (f inflow) init(n int32) { f.avail = n } // add adds n bytes to the window, with a maximum window size of max, // indicating that the peer can now send us more data. // For example, the user read from a {Request,Response} body and consumed // some of the buffered data, so the peer can now send more. // It returns the number of bytes to send in a WINDOW_UPDATE frame to the peer. // Window updates are accumulated and sent when the unsent capacity // is at least inflowMinRefresh or will at least double the peer's available window. func (f inflow) add(n int) (connAdd int32) { if n < 0 { panic("negative update") } unsent := int64(f.unsent) + int64(n) // "A sender MUST NOT allow a flow-control window to exceed 2^31-1 octets." // RFC 7540 Section 6.9.1. const maxWindow = 1<<31 - 1 if unsent+int64(f.avail) > maxWindow { panic("flow control update exceeds maximum window size") } f.unsent = int32(unsent) if f.unsent < inflowMinRefresh && f.unsent < f.avail { // If there aren't at least inflowMinRefresh bytes of window to send, // and this update won't at least double the window, buffer the update for later. return 0 } f.avail += f.unsent f.unsent = 0 return int32(unsent) } // take attempts to take n bytes from the peer's flow control window. // It reports whether the window has available capacity. func (f inflow) take(n uint32) bool { if n > uint32(f.avail) { return false } f.avail -= int32(n) return true } // takeInflows attempts to take n bytes from two inflows, // typically connection-level and stream-level flows. // It reports whether both windows have available capacity. func takeInflows(f1, f2 inflow, n uint32) bool { if n > uint32(f1.avail) \|\| n > uint32(f2.avail) { return false } f1.avail -= int32(n) f2.avail -= int32(n) return true } // outflow is the outbound flow control window's size. type outflow struct { _ incomparable // n is the number of DATA bytes we're allowed to send. // An outflow is kept both on a conn and a per-stream. n int32 // conn points to the shared connection-level outflow that is // shared by all streams on that conn. It is nil for the outflow // that's on the conn directly. conn outflow } func (f outflow) setConnFlow(cf outflow) { f.conn = cf } func (f outflow) available() int32 { n := f.n if f.conn != nil && f.conn.n < n { n = f.conn.n } return n } func (f outflow) take(n int32) { if n > f.available() { panic("internal error: took too much") } f.n -= n if f.conn != nil { f.conn.n -= n } } // add adds n bytes (positive or negative) to the flow control window. // It returns false if the sum would exceed 2^31-1. func (f outflow) add(n int32) bool { sum := f.n + n if (sum > n) == (f.n > 0) { f.n = sum return true } return false }	3.29 KB	2025-05-25 12:27
📄 flow_test.go // Copyright 2014 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import "testing" func TestInFlowTake(t testing.T) { var f inflow f.init(100) if !f.take(40) { t.Fatalf("f.take(40) from 100: got false, want true") } if !f.take(40) { t.Fatalf("f.take(40) from 60: got false, want true") } if f.take(40) { t.Fatalf("f.take(40) from 20: got true, want false") } if !f.take(20) { t.Fatalf("f.take(20) from 20: got false, want true") } } func TestInflowAddSmall(t testing.T) { var f inflow f.init(0) // Adding even a small amount when there is no flow causes an immediate send. if got, want := f.add(1), int32(1); got != want { t.Fatalf("f.add(1) to 1 = %v, want %v", got, want) } } func TestInflowAdd(t testing.T) { var f inflow f.init(10 inflowMinRefresh) if got, want := f.add(inflowMinRefresh-1), int32(0); got != want { t.Fatalf("f.add(minRefresh - 1) = %v, want %v", got, want) } if got, want := f.add(1), int32(inflowMinRefresh); got != want { t.Fatalf("f.add(minRefresh) = %v, want %v", got, want) } } func TestTakeInflows(t testing.T) { var a, b inflow a.init(10) b.init(20) if !takeInflows(&a, &b, 5) { t.Fatalf("takeInflows(a, b, 5) from 10, 20: got false, want true") } if takeInflows(&a, &b, 6) { t.Fatalf("takeInflows(a, b, 6) from 5, 15: got true, want false") } if !takeInflows(&a, &b, 5) { t.Fatalf("takeInflows(a, b, 5) from 5, 15: got false, want true") } } func TestOutFlow(t testing.T) { var st outflow var conn outflow st.add(3) conn.add(2) if got, want := st.available(), int32(3); got != want { t.Errorf("available = %d; want %d", got, want) } st.setConnFlow(&conn) if got, want := st.available(), int32(2); got != want { t.Errorf("after parent setup, available = %d; want %d", got, want) } st.take(2) if got, want := conn.available(), int32(0); got != want { t.Errorf("after taking 2, conn = %d; want %d", got, want) } if got, want := st.available(), int32(0); got != want { t.Errorf("after taking 2, stream = %d; want %d", got, want) } } func TestOutFlowAdd(t testing.T) { var f outflow if !f.add(1) { t.Fatal("failed to add 1") } if !f.add(-1) { t.Fatal("failed to add -1") } if got, want := f.available(), int32(0); got != want { t.Fatalf("size = %d; want %d", got, want) } if !f.add(1<<31 - 1) { t.Fatal("failed to add 2^31-1") } if got, want := f.available(), int32(1<<31-1); got != want { t.Fatalf("size = %d; want %d", got, want) } if f.add(1) { t.Fatal("adding 1 to max shouldn't be allowed") } } func TestOutFlowAddOverflow(t testing.T) { var f outflow if !f.add(0) { t.Fatal("failed to add 0") } if !f.add(-1) { t.Fatal("failed to add -1") } if !f.add(0) { t.Fatal("failed to add 0") } if !f.add(1) { t.Fatal("failed to add 1") } if !f.add(1) { t.Fatal("failed to add 1") } if !f.add(0) { t.Fatal("failed to add 0") } if !f.add(-3) { t.Fatal("failed to add -3") } if got, want := f.available(), int32(-2); got != want { t.Fatalf("size = %d; want %d", got, want) } if !f.add(1<<31 - 1) { t.Fatal("failed to add 2^31-1") } if got, want := f.available(), int32(1+-3+(1<<31-1)); got != want { t.Fatalf("size = %d; want %d", got, want) } }	3.25 KB	2025-05-25 12:27
📄 frame.go // Copyright 2014 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import ( "bytes" "encoding/binary" "errors" "fmt" "io" "log" "strings" "sync" "golang.org/x/net/http/httpguts" "golang.org/x/net/http2/hpack" ) const frameHeaderLen = 9 var padZeros = make([]byte, 255) // zeros for padding // A FrameType is a registered frame type as defined in // https://httpwg.org/specs/rfc7540.html#rfc.section.11.2 type FrameType uint8 const ( FrameData FrameType = 0x0 FrameHeaders FrameType = 0x1 FramePriority FrameType = 0x2 FrameRSTStream FrameType = 0x3 FrameSettings FrameType = 0x4 FramePushPromise FrameType = 0x5 FramePing FrameType = 0x6 FrameGoAway FrameType = 0x7 FrameWindowUpdate FrameType = 0x8 FrameContinuation FrameType = 0x9 ) var frameName = map[FrameType]string{ FrameData: "DATA", FrameHeaders: "HEADERS", FramePriority: "PRIORITY", FrameRSTStream: "RST_STREAM", FrameSettings: "SETTINGS", FramePushPromise: "PUSH_PROMISE", FramePing: "PING", FrameGoAway: "GOAWAY", FrameWindowUpdate: "WINDOW_UPDATE", FrameContinuation: "CONTINUATION", } func (t FrameType) String() string { if s, ok := frameName[t]; ok { return s } return fmt.Sprintf("UNKNOWN_FRAME_TYPE_%d", uint8(t)) } // Flags is a bitmask of HTTP/2 flags. // The meaning of flags varies depending on the frame type. type Flags uint8 // Has reports whether f contains all (0 or more) flags in v. func (f Flags) Has(v Flags) bool { return (f & v) == v } // Frame-specific FrameHeader flag bits. const ( // Data Frame FlagDataEndStream Flags = 0x1 FlagDataPadded Flags = 0x8 // Headers Frame FlagHeadersEndStream Flags = 0x1 FlagHeadersEndHeaders Flags = 0x4 FlagHeadersPadded Flags = 0x8 FlagHeadersPriority Flags = 0x20 // Settings Frame FlagSettingsAck Flags = 0x1 // Ping Frame FlagPingAck Flags = 0x1 // Continuation Frame FlagContinuationEndHeaders Flags = 0x4 FlagPushPromiseEndHeaders Flags = 0x4 FlagPushPromisePadded Flags = 0x8 ) var flagName = map[FrameType]map[Flags]string{ FrameData: { FlagDataEndStream: "END_STREAM", FlagDataPadded: "PADDED", }, FrameHeaders: { FlagHeadersEndStream: "END_STREAM", FlagHeadersEndHeaders: "END_HEADERS", FlagHeadersPadded: "PADDED", FlagHeadersPriority: "PRIORITY", }, FrameSettings: { FlagSettingsAck: "ACK", }, FramePing: { FlagPingAck: "ACK", }, FrameContinuation: { FlagContinuationEndHeaders: "END_HEADERS", }, FramePushPromise: { FlagPushPromiseEndHeaders: "END_HEADERS", FlagPushPromisePadded: "PADDED", }, } // a frameParser parses a frame given its FrameHeader and payload // bytes. The length of payload will always equal fh.Length (which // might be 0). type frameParser func(fc frameCache, fh FrameHeader, countError func(string), payload []byte) (Frame, error) var frameParsers = map[FrameType]frameParser{ FrameData: parseDataFrame, FrameHeaders: parseHeadersFrame, FramePriority: parsePriorityFrame, FrameRSTStream: parseRSTStreamFrame, FrameSettings: parseSettingsFrame, FramePushPromise: parsePushPromise, FramePing: parsePingFrame, FrameGoAway: parseGoAwayFrame, FrameWindowUpdate: parseWindowUpdateFrame, FrameContinuation: parseContinuationFrame, } func typeFrameParser(t FrameType) frameParser { if f := frameParsers[t]; f != nil { return f } return parseUnknownFrame } // A FrameHeader is the 9 byte header of all HTTP/2 frames. // // See https://httpwg.org/specs/rfc7540.html#FrameHeader type FrameHeader struct { valid bool // caller can access []byte fields in the Frame // Type is the 1 byte frame type. There are ten standard frame // types, but extension frame types may be written by WriteRawFrame // and will be returned by ReadFrame (as UnknownFrame). Type FrameType // Flags are the 1 byte of 8 potential bit flags per frame. // They are specific to the frame type. Flags Flags // Length is the length of the frame, not including the 9 byte header. // The maximum size is one byte less than 16MB (uint24), but only // frames up to 16KB are allowed without peer agreement. Length uint32 // StreamID is which stream this frame is for. Certain frames // are not stream-specific, in which case this field is 0. StreamID uint32 } // Header returns h. It exists so FrameHeaders can be embedded in other // specific frame types and implement the Frame interface. func (h FrameHeader) Header() FrameHeader { return h } func (h FrameHeader) String() string { var buf bytes.Buffer buf.WriteString("[FrameHeader ") h.writeDebug(&buf) buf.WriteByte(']') return buf.String() } func (h FrameHeader) writeDebug(buf bytes.Buffer) { buf.WriteString(h.Type.String()) if h.Flags != 0 { buf.WriteString(" flags=") set := 0 for i := uint8(0); i < 8; i++ { if h.Flags&(1<<i) == 0 { continue } set++ if set > 1 { buf.WriteByte('\|') } name := flagName[h.Type][Flags(1<<i)] if name != "" { buf.WriteString(name) } else { fmt.Fprintf(buf, "0x%x", 1<<i) } } } if h.StreamID != 0 { fmt.Fprintf(buf, " stream=%d", h.StreamID) } fmt.Fprintf(buf, " len=%d", h.Length) } func (h FrameHeader) checkValid() { if !h.valid { panic("Frame accessor called on non-owned Frame") } } func (h FrameHeader) invalidate() { h.valid = false } // frame header bytes. // Used only by ReadFrameHeader. var fhBytes = sync.Pool{ New: func() interface{} { buf := make([]byte, frameHeaderLen) return &buf }, } // ReadFrameHeader reads 9 bytes from r and returns a FrameHeader. // Most users should use Framer.ReadFrame instead. func ReadFrameHeader(r io.Reader) (FrameHeader, error) { bufp := fhBytes.Get().([]byte) defer fhBytes.Put(bufp) return readFrameHeader(bufp, r) } func readFrameHeader(buf []byte, r io.Reader) (FrameHeader, error) { _, err := io.ReadFull(r, buf[:frameHeaderLen]) if err != nil { return FrameHeader{}, err } return FrameHeader{ Length: (uint32(buf[0])<<16 \| uint32(buf[1])<<8 \| uint32(buf[2])), Type: FrameType(buf[3]), Flags: Flags(buf[4]), StreamID: binary.BigEndian.Uint32(buf[5:]) & (1<<31 - 1), valid: true, }, nil } // A Frame is the base interface implemented by all frame types. // Callers will generally type-assert the specific frame type: // HeadersFrame, SettingsFrame, WindowUpdateFrame, etc. // // Frames are only valid until the next call to Framer.ReadFrame. type Frame interface { Header() FrameHeader // invalidate is called by Framer.ReadFrame to make this // frame's buffers as being invalid, since the subsequent // frame will reuse them. invalidate() } // A Framer reads and writes Frames. type Framer struct { r io.Reader lastFrame Frame errDetail error // countError is a non-nil func that's called on a frame parse // error with some unique error path token. It's initialized // from Transport.CountError or Server.CountError. countError func(errToken string) // lastHeaderStream is non-zero if the last frame was an // unfinished HEADERS/CONTINUATION. lastHeaderStream uint32 maxReadSize uint32 headerBuf [frameHeaderLen]byte // TODO: let getReadBuf be configurable, and use a less memory-pinning // allocator in server.go to minimize memory pinned for many idle conns. // Will probably also need to make frame invalidation have a hook too. getReadBuf func(size uint32) []byte readBuf []byte // cache for default getReadBuf maxWriteSize uint32 // zero means unlimited; TODO: implement w io.Writer wbuf []byte // AllowIllegalWrites permits the Framer's Write methods to // write frames that do not conform to the HTTP/2 spec. This // permits using the Framer to test other HTTP/2 // implementations' conformance to the spec. // If false, the Write methods will prefer to return an error // rather than comply. AllowIllegalWrites bool // AllowIllegalReads permits the Framer's ReadFrame method // to return non-compliant frames or frame orders. // This is for testing and permits using the Framer to test // other HTTP/2 implementations' conformance to the spec. // It is not compatible with ReadMetaHeaders. AllowIllegalReads bool // ReadMetaHeaders if non-nil causes ReadFrame to merge // HEADERS and CONTINUATION frames together and return // MetaHeadersFrame instead. ReadMetaHeaders hpack.Decoder // MaxHeaderListSize is the http2 MAX_HEADER_LIST_SIZE. // It's used only if ReadMetaHeaders is set; 0 means a sane default // (currently 16MB) // If the limit is hit, MetaHeadersFrame.Truncated is set true. MaxHeaderListSize uint32 // TODO: track which type of frame & with which flags was sent // last. Then return an error (unless AllowIllegalWrites) if // we're in the middle of a header block and a // non-Continuation or Continuation on a different stream is // attempted to be written. logReads, logWrites bool debugFramer Framer // only use for logging written writes debugFramerBuf bytes.Buffer debugReadLoggerf func(string, ...interface{}) debugWriteLoggerf func(string, ...interface{}) frameCache frameCache // nil if frames aren't reused (default) } func (fr Framer) maxHeaderListSize() uint32 { if fr.MaxHeaderListSize == 0 { return 16 << 20 // sane default, per docs } return fr.MaxHeaderListSize } func (f Framer) startWrite(ftype FrameType, flags Flags, streamID uint32) { // Write the FrameHeader. f.wbuf = append(f.wbuf[:0], 0, // 3 bytes of length, filled in in endWrite 0, 0, byte(ftype), byte(flags), byte(streamID>>24), byte(streamID>>16), byte(streamID>>8), byte(streamID)) } func (f Framer) endWrite() error { // Now that we know the final size, fill in the FrameHeader in // the space previously reserved for it. Abuse append. length := len(f.wbuf) - frameHeaderLen if length >= (1 << 24) { return ErrFrameTooLarge } _ = append(f.wbuf[:0], byte(length>>16), byte(length>>8), byte(length)) if f.logWrites { f.logWrite() } n, err := f.w.Write(f.wbuf) if err == nil && n != len(f.wbuf) { err = io.ErrShortWrite } return err } func (f Framer) logWrite() { if f.debugFramer == nil { f.debugFramerBuf = new(bytes.Buffer) f.debugFramer = NewFramer(nil, f.debugFramerBuf) f.debugFramer.logReads = false // we log it ourselves, saying "wrote" below // Let us read anything, even if we accidentally wrote it // in the wrong order: f.debugFramer.AllowIllegalReads = true } f.debugFramerBuf.Write(f.wbuf) fr, err := f.debugFramer.ReadFrame() if err != nil { f.debugWriteLoggerf("http2: Framer %p: failed to decode just-written frame", f) return } f.debugWriteLoggerf("http2: Framer %p: wrote %v", f, summarizeFrame(fr)) } func (f Framer) writeByte(v byte) { f.wbuf = append(f.wbuf, v) } func (f Framer) writeBytes(v []byte) { f.wbuf = append(f.wbuf, v...) } func (f Framer) writeUint16(v uint16) { f.wbuf = append(f.wbuf, byte(v>>8), byte(v)) } func (f Framer) writeUint32(v uint32) { f.wbuf = append(f.wbuf, byte(v>>24), byte(v>>16), byte(v>>8), byte(v)) } const ( minMaxFrameSize = 1 << 14 maxFrameSize = 1<<24 - 1 ) // SetReuseFrames allows the Framer to reuse Frames. // If called on a Framer, Frames returned by calls to ReadFrame are only // valid until the next call to ReadFrame. func (fr Framer) SetReuseFrames() { if fr.frameCache != nil { return } fr.frameCache = &frameCache{} } type frameCache struct { dataFrame DataFrame } func (fc frameCache) getDataFrame() DataFrame { if fc == nil { return &DataFrame{} } return &fc.dataFrame } // NewFramer returns a Framer that writes frames to w and reads them from r. func NewFramer(w io.Writer, r io.Reader) Framer { fr := &Framer{ w: w, r: r, countError: func(string) {}, logReads: logFrameReads, logWrites: logFrameWrites, debugReadLoggerf: log.Printf, debugWriteLoggerf: log.Printf, } fr.getReadBuf = func(size uint32) []byte { if cap(fr.readBuf) >= int(size) { return fr.readBuf[:size] } fr.readBuf = make([]byte, size) return fr.readBuf } fr.SetMaxReadFrameSize(maxFrameSize) return fr } // SetMaxReadFrameSize sets the maximum size of a frame // that will be read by a subsequent call to ReadFrame. // It is the caller's responsibility to advertise this // limit with a SETTINGS frame. func (fr Framer) SetMaxReadFrameSize(v uint32) { if v > maxFrameSize { v = maxFrameSize } fr.maxReadSize = v } // ErrorDetail returns a more detailed error of the last error // returned by Framer.ReadFrame. For instance, if ReadFrame // returns a StreamError with code PROTOCOL_ERROR, ErrorDetail // will say exactly what was invalid. ErrorDetail is not guaranteed // to return a non-nil value and like the rest of the http2 package, // its return value is not protected by an API compatibility promise. // ErrorDetail is reset after the next call to ReadFrame. func (fr Framer) ErrorDetail() error { return fr.errDetail } // ErrFrameTooLarge is returned from Framer.ReadFrame when the peer // sends a frame that is larger than declared with SetMaxReadFrameSize. var ErrFrameTooLarge = errors.New("http2: frame too large") // terminalReadFrameError reports whether err is an unrecoverable // error from ReadFrame and no other frames should be read. func terminalReadFrameError(err error) bool { if _, ok := err.(StreamError); ok { return false } return err != nil } // ReadFrame reads a single frame. The returned Frame is only valid // until the next call to ReadFrame. // // If the frame is larger than previously set with SetMaxReadFrameSize, the // returned error is ErrFrameTooLarge. Other errors may be of type // ConnectionError, StreamError, or anything else from the underlying // reader. // // If ReadFrame returns an error and a non-nil Frame, the Frame's StreamID // indicates the stream responsible for the error. func (fr Framer) ReadFrame() (Frame, error) { fr.errDetail = nil if fr.lastFrame != nil { fr.lastFrame.invalidate() } fh, err := readFrameHeader(fr.headerBuf[:], fr.r) if err != nil { return nil, err } if fh.Length > fr.maxReadSize { return nil, ErrFrameTooLarge } payload := fr.getReadBuf(fh.Length) if _, err := io.ReadFull(fr.r, payload); err != nil { return nil, err } f, err := typeFrameParser(fh.Type)(fr.frameCache, fh, fr.countError, payload) if err != nil { if ce, ok := err.(connError); ok { return nil, fr.connError(ce.Code, ce.Reason) } return nil, err } if err := fr.checkFrameOrder(f); err != nil { return nil, err } if fr.logReads { fr.debugReadLoggerf("http2: Framer %p: read %v", fr, summarizeFrame(f)) } if fh.Type == FrameHeaders && fr.ReadMetaHeaders != nil { return fr.readMetaFrame(f.(HeadersFrame)) } return f, nil } // connError returns ConnectionError(code) but first // stashes away a public reason to the caller can optionally relay it // to the peer before hanging up on them. This might help others debug // their implementations. func (fr Framer) connError(code ErrCode, reason string) error { fr.errDetail = errors.New(reason) return ConnectionError(code) } // checkFrameOrder reports an error if f is an invalid frame to return // next from ReadFrame. Mostly it checks whether HEADERS and // CONTINUATION frames are contiguous. func (fr Framer) checkFrameOrder(f Frame) error { last := fr.lastFrame fr.lastFrame = f if fr.AllowIllegalReads { return nil } fh := f.Header() if fr.lastHeaderStream != 0 { if fh.Type != FrameContinuation { return fr.connError(ErrCodeProtocol, fmt.Sprintf("got %s for stream %d; expected CONTINUATION following %s for stream %d", fh.Type, fh.StreamID, last.Header().Type, fr.lastHeaderStream)) } if fh.StreamID != fr.lastHeaderStream { return fr.connError(ErrCodeProtocol, fmt.Sprintf("got CONTINUATION for stream %d; expected stream %d", fh.StreamID, fr.lastHeaderStream)) } } else if fh.Type == FrameContinuation { return fr.connError(ErrCodeProtocol, fmt.Sprintf("unexpected CONTINUATION for stream %d", fh.StreamID)) } switch fh.Type { case FrameHeaders, FrameContinuation: if fh.Flags.Has(FlagHeadersEndHeaders) { fr.lastHeaderStream = 0 } else { fr.lastHeaderStream = fh.StreamID } } return nil } // A DataFrame conveys arbitrary, variable-length sequences of octets // associated with a stream. // See https://httpwg.org/specs/rfc7540.html#rfc.section.6.1 type DataFrame struct { FrameHeader data []byte } func (f DataFrame) StreamEnded() bool { return f.FrameHeader.Flags.Has(FlagDataEndStream) } // Data returns the frame's data octets, not including any padding // size byte or padding suffix bytes. // The caller must not retain the returned memory past the next // call to ReadFrame. func (f DataFrame) Data() []byte { f.checkValid() return f.data } func parseDataFrame(fc frameCache, fh FrameHeader, countError func(string), payload []byte) (Frame, error) { if fh.StreamID == 0 { // DATA frames MUST be associated with a stream. If a // DATA frame is received whose stream identifier // field is 0x0, the recipient MUST respond with a // connection error (Section 5.4.1) of type // PROTOCOL_ERROR. countError("frame_data_stream_0") return nil, connError{ErrCodeProtocol, "DATA frame with stream ID 0"} } f := fc.getDataFrame() f.FrameHeader = fh var padSize byte if fh.Flags.Has(FlagDataPadded) { var err error payload, padSize, err = readByte(payload) if err != nil { countError("frame_data_pad_byte_short") return nil, err } } if int(padSize) > len(payload) { // If the length of the padding is greater than the // length of the frame payload, the recipient MUST // treat this as a connection error. // Filed: https://github.com/http2/http2-spec/issues/610 countError("frame_data_pad_too_big") return nil, connError{ErrCodeProtocol, "pad size larger than data payload"} } f.data = payload[:len(payload)-int(padSize)] return f, nil } var ( errStreamID = errors.New("invalid stream ID") errDepStreamID = errors.New("invalid dependent stream ID") errPadLength = errors.New("pad length too large") errPadBytes = errors.New("padding bytes must all be zeros unless AllowIllegalWrites is enabled") ) func validStreamIDOrZero(streamID uint32) bool { return streamID&(1<<31) == 0 } func validStreamID(streamID uint32) bool { return streamID != 0 && streamID&(1<<31) == 0 } // WriteData writes a DATA frame. // // It will perform exactly one Write to the underlying Writer. // It is the caller's responsibility not to violate the maximum frame size // and to not call other Write methods concurrently. func (f Framer) WriteData(streamID uint32, endStream bool, data []byte) error { return f.WriteDataPadded(streamID, endStream, data, nil) } // WriteDataPadded writes a DATA frame with optional padding. // // If pad is nil, the padding bit is not sent. // The length of pad must not exceed 255 bytes. // The bytes of pad must all be zero, unless f.AllowIllegalWrites is set. // // It will perform exactly one Write to the underlying Writer. // It is the caller's responsibility not to violate the maximum frame size // and to not call other Write methods concurrently. func (f Framer) WriteDataPadded(streamID uint32, endStream bool, data, pad []byte) error { if err := f.startWriteDataPadded(streamID, endStream, data, pad); err != nil { return err } return f.endWrite() } // startWriteDataPadded is WriteDataPadded, but only writes the frame to the Framer's internal buffer. // The caller should call endWrite to flush the frame to the underlying writer. func (f Framer) startWriteDataPadded(streamID uint32, endStream bool, data, pad []byte) error { if !validStreamID(streamID) && !f.AllowIllegalWrites { return errStreamID } if len(pad) > 0 { if len(pad) > 255 { return errPadLength } if !f.AllowIllegalWrites { for _, b := range pad { if b != 0 { // "Padding octets MUST be set to zero when sending." return errPadBytes } } } } var flags Flags if endStream { flags \|= FlagDataEndStream } if pad != nil { flags \|= FlagDataPadded } f.startWrite(FrameData, flags, streamID) if pad != nil { f.wbuf = append(f.wbuf, byte(len(pad))) } f.wbuf = append(f.wbuf, data...) f.wbuf = append(f.wbuf, pad...) return nil } // A SettingsFrame conveys configuration parameters that affect how // endpoints communicate, such as preferences and constraints on peer // behavior. // // See https://httpwg.org/specs/rfc7540.html#SETTINGS type SettingsFrame struct { FrameHeader p []byte } func parseSettingsFrame(_ frameCache, fh FrameHeader, countError func(string), p []byte) (Frame, error) { if fh.Flags.Has(FlagSettingsAck) && fh.Length > 0 { // When this (ACK 0x1) bit is set, the payload of the // SETTINGS frame MUST be empty. Receipt of a // SETTINGS frame with the ACK flag set and a length // field value other than 0 MUST be treated as a // connection error (Section 5.4.1) of type // FRAME_SIZE_ERROR. countError("frame_settings_ack_with_length") return nil, ConnectionError(ErrCodeFrameSize) } if fh.StreamID != 0 { // SETTINGS frames always apply to a connection, // never a single stream. The stream identifier for a // SETTINGS frame MUST be zero (0x0). If an endpoint // receives a SETTINGS frame whose stream identifier // field is anything other than 0x0, the endpoint MUST // respond with a connection error (Section 5.4.1) of // type PROTOCOL_ERROR. countError("frame_settings_has_stream") return nil, ConnectionError(ErrCodeProtocol) } if len(p)%6 != 0 { countError("frame_settings_mod_6") // Expecting even number of 6 byte settings. return nil, ConnectionError(ErrCodeFrameSize) } f := &SettingsFrame{FrameHeader: fh, p: p} if v, ok := f.Value(SettingInitialWindowSize); ok && v > (1<<31)-1 { countError("frame_settings_window_size_too_big") // Values above the maximum flow control window size of 2^31 - 1 MUST // be treated as a connection error (Section 5.4.1) of type // FLOW_CONTROL_ERROR. return nil, ConnectionError(ErrCodeFlowControl) } return f, nil } func (f SettingsFrame) IsAck() bool { return f.FrameHeader.Flags.Has(FlagSettingsAck) } func (f SettingsFrame) Value(id SettingID) (v uint32, ok bool) { f.checkValid() for i := 0; i < f.NumSettings(); i++ { if s := f.Setting(i); s.ID == id { return s.Val, true } } return 0, false } // Setting returns the setting from the frame at the given 0-based index. // The index must be >= 0 and less than f.NumSettings(). func (f SettingsFrame) Setting(i int) Setting { buf := f.p return Setting{ ID: SettingID(binary.BigEndian.Uint16(buf[i6 : i6+2])), Val: binary.BigEndian.Uint32(buf[i6+2 : i6+6]), } } func (f SettingsFrame) NumSettings() int { return len(f.p) / 6 } // HasDuplicates reports whether f contains any duplicate setting IDs. func (f SettingsFrame) HasDuplicates() bool { num := f.NumSettings() if num == 0 { return false } // If it's small enough (the common case), just do the n^2 // thing and avoid a map allocation. if num < 10 { for i := 0; i < num; i++ { idi := f.Setting(i).ID for j := i + 1; j < num; j++ { idj := f.Setting(j).ID if idi == idj { return true } } } return false } seen := map[SettingID]bool{} for i := 0; i < num; i++ { id := f.Setting(i).ID if seen[id] { return true } seen[id] = true } return false } // ForeachSetting runs fn for each setting. // It stops and returns the first error. func (f SettingsFrame) ForeachSetting(fn func(Setting) error) error { f.checkValid() for i := 0; i < f.NumSettings(); i++ { if err := fn(f.Setting(i)); err != nil { return err } } return nil } // WriteSettings writes a SETTINGS frame with zero or more settings // specified and the ACK bit not set. // // It will perform exactly one Write to the underlying Writer. // It is the caller's responsibility to not call other Write methods concurrently. func (f Framer) WriteSettings(settings ...Setting) error { f.startWrite(FrameSettings, 0, 0) for _, s := range settings { f.writeUint16(uint16(s.ID)) f.writeUint32(s.Val) } return f.endWrite() } // WriteSettingsAck writes an empty SETTINGS frame with the ACK bit set. // // It will perform exactly one Write to the underlying Writer. // It is the caller's responsibility to not call other Write methods concurrently. func (f Framer) WriteSettingsAck() error { f.startWrite(FrameSettings, FlagSettingsAck, 0) return f.endWrite() } // A PingFrame is a mechanism for measuring a minimal round trip time // from the sender, as well as determining whether an idle connection // is still functional. // See https://httpwg.org/specs/rfc7540.html#rfc.section.6.7 type PingFrame struct { FrameHeader Data [8]byte } func (f PingFrame) IsAck() bool { return f.Flags.Has(FlagPingAck) } func parsePingFrame(_ frameCache, fh FrameHeader, countError func(string), payload []byte) (Frame, error) { if len(payload) != 8 { countError("frame_ping_length") return nil, ConnectionError(ErrCodeFrameSize) } if fh.StreamID != 0 { countError("frame_ping_has_stream") return nil, ConnectionError(ErrCodeProtocol) } f := &PingFrame{FrameHeader: fh} copy(f.Data[:], payload) return f, nil } func (f Framer) WritePing(ack bool, data [8]byte) error { var flags Flags if ack { flags = FlagPingAck } f.startWrite(FramePing, flags, 0) f.writeBytes(data[:]) return f.endWrite() } // A GoAwayFrame informs the remote peer to stop creating streams on this connection. // See https://httpwg.org/specs/rfc7540.html#rfc.section.6.8 type GoAwayFrame struct { FrameHeader LastStreamID uint32 ErrCode ErrCode debugData []byte } // DebugData returns any debug data in the GOAWAY frame. Its contents // are not defined. // The caller must not retain the returned memory past the next // call to ReadFrame. func (f GoAwayFrame) DebugData() []byte { f.checkValid() return f.debugData } func parseGoAwayFrame(_ frameCache, fh FrameHeader, countError func(string), p []byte) (Frame, error) { if fh.StreamID != 0 { countError("frame_goaway_has_stream") return nil, ConnectionError(ErrCodeProtocol) } if len(p) < 8 { countError("frame_goaway_short") return nil, ConnectionError(ErrCodeFrameSize) } return &GoAwayFrame{ FrameHeader: fh, LastStreamID: binary.BigEndian.Uint32(p[:4]) & (1<<31 - 1), ErrCode: ErrCode(binary.BigEndian.Uint32(p[4:8])), debugData: p[8:], }, nil } func (f Framer) WriteGoAway(maxStreamID uint32, code ErrCode, debugData []byte) error { f.startWrite(FrameGoAway, 0, 0) f.writeUint32(maxStreamID & (1<<31 - 1)) f.writeUint32(uint32(code)) f.writeBytes(debugData) return f.endWrite() } // An UnknownFrame is the frame type returned when the frame type is unknown // or no specific frame type parser exists. type UnknownFrame struct { FrameHeader p []byte } // Payload returns the frame's payload (after the header). It is not // valid to call this method after a subsequent call to // Framer.ReadFrame, nor is it valid to retain the returned slice. // The memory is owned by the Framer and is invalidated when the next // frame is read. func (f UnknownFrame) Payload() []byte { f.checkValid() return f.p } func parseUnknownFrame(_ frameCache, fh FrameHeader, countError func(string), p []byte) (Frame, error) { return &UnknownFrame{fh, p}, nil } // A WindowUpdateFrame is used to implement flow control. // See https://httpwg.org/specs/rfc7540.html#rfc.section.6.9 type WindowUpdateFrame struct { FrameHeader Increment uint32 // never read with high bit set } func parseWindowUpdateFrame(_ frameCache, fh FrameHeader, countError func(string), p []byte) (Frame, error) { if len(p) != 4 { countError("frame_windowupdate_bad_len") return nil, ConnectionError(ErrCodeFrameSize) } inc := binary.BigEndian.Uint32(p[:4]) & 0x7fffffff // mask off high reserved bit if inc == 0 { // A receiver MUST treat the receipt of a // WINDOW_UPDATE frame with an flow control window // increment of 0 as a stream error (Section 5.4.2) of // type PROTOCOL_ERROR; errors on the connection flow // control window MUST be treated as a connection // error (Section 5.4.1). if fh.StreamID == 0 { countError("frame_windowupdate_zero_inc_conn") return nil, ConnectionError(ErrCodeProtocol) } countError("frame_windowupdate_zero_inc_stream") return nil, streamError(fh.StreamID, ErrCodeProtocol) } return &WindowUpdateFrame{ FrameHeader: fh, Increment: inc, }, nil } // WriteWindowUpdate writes a WINDOW_UPDATE frame. // The increment value must be between 1 and 2,147,483,647, inclusive. // If the Stream ID is zero, the window update applies to the // connection as a whole. func (f Framer) WriteWindowUpdate(streamID, incr uint32) error { // "The legal range for the increment to the flow control window is 1 to 2^31-1 (2,147,483,647) octets." if (incr < 1 \|\| incr > 2147483647) && !f.AllowIllegalWrites { return errors.New("illegal window increment value") } f.startWrite(FrameWindowUpdate, 0, streamID) f.writeUint32(incr) return f.endWrite() } // A HeadersFrame is used to open a stream and additionally carries a // header block fragment. type HeadersFrame struct { FrameHeader // Priority is set if FlagHeadersPriority is set in the FrameHeader. Priority PriorityParam headerFragBuf []byte // not owned } func (f HeadersFrame) HeaderBlockFragment() []byte { f.checkValid() return f.headerFragBuf } func (f HeadersFrame) HeadersEnded() bool { return f.FrameHeader.Flags.Has(FlagHeadersEndHeaders) } func (f HeadersFrame) StreamEnded() bool { return f.FrameHeader.Flags.Has(FlagHeadersEndStream) } func (f HeadersFrame) HasPriority() bool { return f.FrameHeader.Flags.Has(FlagHeadersPriority) } func parseHeadersFrame(_ frameCache, fh FrameHeader, countError func(string), p []byte) (_ Frame, err error) { hf := &HeadersFrame{ FrameHeader: fh, } if fh.StreamID == 0 { // HEADERS frames MUST be associated with a stream. If a HEADERS frame // is received whose stream identifier field is 0x0, the recipient MUST // respond with a connection error (Section 5.4.1) of type // PROTOCOL_ERROR. countError("frame_headers_zero_stream") return nil, connError{ErrCodeProtocol, "HEADERS frame with stream ID 0"} } var padLength uint8 if fh.Flags.Has(FlagHeadersPadded) { if p, padLength, err = readByte(p); err != nil { countError("frame_headers_pad_short") return } } if fh.Flags.Has(FlagHeadersPriority) { var v uint32 p, v, err = readUint32(p) if err != nil { countError("frame_headers_prio_short") return nil, err } hf.Priority.StreamDep = v & 0x7fffffff hf.Priority.Exclusive = (v != hf.Priority.StreamDep) // high bit was set p, hf.Priority.Weight, err = readByte(p) if err != nil { countError("frame_headers_prio_weight_short") return nil, err } } if len(p)-int(padLength) < 0 { countError("frame_headers_pad_too_big") return nil, streamError(fh.StreamID, ErrCodeProtocol) } hf.headerFragBuf = p[:len(p)-int(padLength)] return hf, nil } // HeadersFrameParam are the parameters for writing a HEADERS frame. type HeadersFrameParam struct { // StreamID is the required Stream ID to initiate. StreamID uint32 // BlockFragment is part (or all) of a Header Block. BlockFragment []byte // EndStream indicates that the header block is the last that // the endpoint will send for the identified stream. Setting // this flag causes the stream to enter one of "half closed" // states. EndStream bool // EndHeaders indicates that this frame contains an entire // header block and is not followed by any // CONTINUATION frames. EndHeaders bool // PadLength is the optional number of bytes of zeros to add // to this frame. PadLength uint8 // Priority, if non-zero, includes stream priority information // in the HEADER frame. Priority PriorityParam } // WriteHeaders writes a single HEADERS frame. // // This is a low-level header writing method. Encoding headers and // splitting them into any necessary CONTINUATION frames is handled // elsewhere. // // It will perform exactly one Write to the underlying Writer. // It is the caller's responsibility to not call other Write methods concurrently. func (f Framer) WriteHeaders(p HeadersFrameParam) error { if !validStreamID(p.StreamID) && !f.AllowIllegalWrites { return errStreamID } var flags Flags if p.PadLength != 0 { flags \|= FlagHeadersPadded } if p.EndStream { flags \|= FlagHeadersEndStream } if p.EndHeaders { flags \|= FlagHeadersEndHeaders } if !p.Priority.IsZero() { flags \|= FlagHeadersPriority } f.startWrite(FrameHeaders, flags, p.StreamID) if p.PadLength != 0 { f.writeByte(p.PadLength) } if !p.Priority.IsZero() { v := p.Priority.StreamDep if !validStreamIDOrZero(v) && !f.AllowIllegalWrites { return errDepStreamID } if p.Priority.Exclusive { v \|= 1 << 31 } f.writeUint32(v) f.writeByte(p.Priority.Weight) } f.wbuf = append(f.wbuf, p.BlockFragment...) f.wbuf = append(f.wbuf, padZeros[:p.PadLength]...) return f.endWrite() } // A PriorityFrame specifies the sender-advised priority of a stream. // See https://httpwg.org/specs/rfc7540.html#rfc.section.6.3 type PriorityFrame struct { FrameHeader PriorityParam } // PriorityParam are the stream prioritzation parameters. type PriorityParam struct { // StreamDep is a 31-bit stream identifier for the // stream that this stream depends on. Zero means no // dependency. StreamDep uint32 // Exclusive is whether the dependency is exclusive. Exclusive bool // Weight is the stream's zero-indexed weight. It should be // set together with StreamDep, or neither should be set. Per // the spec, "Add one to the value to obtain a weight between // 1 and 256." Weight uint8 } func (p PriorityParam) IsZero() bool { return p == PriorityParam{} } func parsePriorityFrame(_ frameCache, fh FrameHeader, countError func(string), payload []byte) (Frame, error) { if fh.StreamID == 0 { countError("frame_priority_zero_stream") return nil, connError{ErrCodeProtocol, "PRIORITY frame with stream ID 0"} } if len(payload) != 5 { countError("frame_priority_bad_length") return nil, connError{ErrCodeFrameSize, fmt.Sprintf("PRIORITY frame payload size was %d; want 5", len(payload))} } v := binary.BigEndian.Uint32(payload[:4]) streamID := v & 0x7fffffff // mask off high bit return &PriorityFrame{ FrameHeader: fh, PriorityParam: PriorityParam{ Weight: payload[4], StreamDep: streamID, Exclusive: streamID != v, // was high bit set? }, }, nil } // WritePriority writes a PRIORITY frame. // // It will perform exactly one Write to the underlying Writer. // It is the caller's responsibility to not call other Write methods concurrently. func (f Framer) WritePriority(streamID uint32, p PriorityParam) error { if !validStreamID(streamID) && !f.AllowIllegalWrites { return errStreamID } if !validStreamIDOrZero(p.StreamDep) { return errDepStreamID } f.startWrite(FramePriority, 0, streamID) v := p.StreamDep if p.Exclusive { v \|= 1 << 31 } f.writeUint32(v) f.writeByte(p.Weight) return f.endWrite() } // A RSTStreamFrame allows for abnormal termination of a stream. // See https://httpwg.org/specs/rfc7540.html#rfc.section.6.4 type RSTStreamFrame struct { FrameHeader ErrCode ErrCode } func parseRSTStreamFrame(_ frameCache, fh FrameHeader, countError func(string), p []byte) (Frame, error) { if len(p) != 4 { countError("frame_rststream_bad_len") return nil, ConnectionError(ErrCodeFrameSize) } if fh.StreamID == 0 { countError("frame_rststream_zero_stream") return nil, ConnectionError(ErrCodeProtocol) } return &RSTStreamFrame{fh, ErrCode(binary.BigEndian.Uint32(p[:4]))}, nil } // WriteRSTStream writes a RST_STREAM frame. // // It will perform exactly one Write to the underlying Writer. // It is the caller's responsibility to not call other Write methods concurrently. func (f Framer) WriteRSTStream(streamID uint32, code ErrCode) error { if !validStreamID(streamID) && !f.AllowIllegalWrites { return errStreamID } f.startWrite(FrameRSTStream, 0, streamID) f.writeUint32(uint32(code)) return f.endWrite() } // A ContinuationFrame is used to continue a sequence of header block fragments. // See https://httpwg.org/specs/rfc7540.html#rfc.section.6.10 type ContinuationFrame struct { FrameHeader headerFragBuf []byte } func parseContinuationFrame(_ frameCache, fh FrameHeader, countError func(string), p []byte) (Frame, error) { if fh.StreamID == 0 { countError("frame_continuation_zero_stream") return nil, connError{ErrCodeProtocol, "CONTINUATION frame with stream ID 0"} } return &ContinuationFrame{fh, p}, nil } func (f ContinuationFrame) HeaderBlockFragment() []byte { f.checkValid() return f.headerFragBuf } func (f ContinuationFrame) HeadersEnded() bool { return f.FrameHeader.Flags.Has(FlagContinuationEndHeaders) } // WriteContinuation writes a CONTINUATION frame. // // It will perform exactly one Write to the underlying Writer. // It is the caller's responsibility to not call other Write methods concurrently. func (f Framer) WriteContinuation(streamID uint32, endHeaders bool, headerBlockFragment []byte) error { if !validStreamID(streamID) && !f.AllowIllegalWrites { return errStreamID } var flags Flags if endHeaders { flags \|= FlagContinuationEndHeaders } f.startWrite(FrameContinuation, flags, streamID) f.wbuf = append(f.wbuf, headerBlockFragment...) return f.endWrite() } // A PushPromiseFrame is used to initiate a server stream. // See https://httpwg.org/specs/rfc7540.html#rfc.section.6.6 type PushPromiseFrame struct { FrameHeader PromiseID uint32 headerFragBuf []byte // not owned } func (f PushPromiseFrame) HeaderBlockFragment() []byte { f.checkValid() return f.headerFragBuf } func (f PushPromiseFrame) HeadersEnded() bool { return f.FrameHeader.Flags.Has(FlagPushPromiseEndHeaders) } func parsePushPromise(_ frameCache, fh FrameHeader, countError func(string), p []byte) (_ Frame, err error) { pp := &PushPromiseFrame{ FrameHeader: fh, } if pp.StreamID == 0 { // PUSH_PROMISE frames MUST be associated with an existing, // peer-initiated stream. The stream identifier of a // PUSH_PROMISE frame indicates the stream it is associated // with. If the stream identifier field specifies the value // 0x0, a recipient MUST respond with a connection error // (Section 5.4.1) of type PROTOCOL_ERROR. countError("frame_pushpromise_zero_stream") return nil, ConnectionError(ErrCodeProtocol) } // The PUSH_PROMISE frame includes optional padding. // Padding fields and flags are identical to those defined for DATA frames var padLength uint8 if fh.Flags.Has(FlagPushPromisePadded) { if p, padLength, err = readByte(p); err != nil { countError("frame_pushpromise_pad_short") return } } p, pp.PromiseID, err = readUint32(p) if err != nil { countError("frame_pushpromise_promiseid_short") return } pp.PromiseID = pp.PromiseID & (1<<31 - 1) if int(padLength) > len(p) { // like the DATA frame, error out if padding is longer than the body. countError("frame_pushpromise_pad_too_big") return nil, ConnectionError(ErrCodeProtocol) } pp.headerFragBuf = p[:len(p)-int(padLength)] return pp, nil } // PushPromiseParam are the parameters for writing a PUSH_PROMISE frame. type PushPromiseParam struct { // StreamID is the required Stream ID to initiate. StreamID uint32 // PromiseID is the required Stream ID which this // Push Promises PromiseID uint32 // BlockFragment is part (or all) of a Header Block. BlockFragment []byte // EndHeaders indicates that this frame contains an entire // header block and is not followed by any // CONTINUATION frames. EndHeaders bool // PadLength is the optional number of bytes of zeros to add // to this frame. PadLength uint8 } // WritePushPromise writes a single PushPromise Frame. // // As with Header Frames, This is the low level call for writing // individual frames. Continuation frames are handled elsewhere. // // It will perform exactly one Write to the underlying Writer. // It is the caller's responsibility to not call other Write methods concurrently. func (f Framer) WritePushPromise(p PushPromiseParam) error { if !validStreamID(p.StreamID) && !f.AllowIllegalWrites { return errStreamID } var flags Flags if p.PadLength != 0 { flags \|= FlagPushPromisePadded } if p.EndHeaders { flags \|= FlagPushPromiseEndHeaders } f.startWrite(FramePushPromise, flags, p.StreamID) if p.PadLength != 0 { f.writeByte(p.PadLength) } if !validStreamID(p.PromiseID) && !f.AllowIllegalWrites { return errStreamID } f.writeUint32(p.PromiseID) f.wbuf = append(f.wbuf, p.BlockFragment...) f.wbuf = append(f.wbuf, padZeros[:p.PadLength]...) return f.endWrite() } // WriteRawFrame writes a raw frame. This can be used to write // extension frames unknown to this package. func (f Framer) WriteRawFrame(t FrameType, flags Flags, streamID uint32, payload []byte) error { f.startWrite(t, flags, streamID) f.writeBytes(payload) return f.endWrite() } func readByte(p []byte) (remain []byte, b byte, err error) { if len(p) == 0 { return nil, 0, io.ErrUnexpectedEOF } return p[1:], p[0], nil } func readUint32(p []byte) (remain []byte, v uint32, err error) { if len(p) < 4 { return nil, 0, io.ErrUnexpectedEOF } return p[4:], binary.BigEndian.Uint32(p[:4]), nil } type streamEnder interface { StreamEnded() bool } type headersEnder interface { HeadersEnded() bool } type headersOrContinuation interface { headersEnder HeaderBlockFragment() []byte } // A MetaHeadersFrame is the representation of one HEADERS frame and // zero or more contiguous CONTINUATION frames and the decoding of // their HPACK-encoded contents. // // This type of frame does not appear on the wire and is only returned // by the Framer when Framer.ReadMetaHeaders is set. type MetaHeadersFrame struct { HeadersFrame // Fields are the fields contained in the HEADERS and // CONTINUATION frames. The underlying slice is owned by the // Framer and must not be retained after the next call to // ReadFrame. // // Fields are guaranteed to be in the correct http2 order and // not have unknown pseudo header fields or invalid header // field names or values. Required pseudo header fields may be // missing, however. Use the MetaHeadersFrame.Pseudo accessor // method access pseudo headers. Fields []hpack.HeaderField // Truncated is whether the max header list size limit was hit // and Fields is incomplete. The hpack decoder state is still // valid, however. Truncated bool } // PseudoValue returns the given pseudo header field's value. // The provided pseudo field should not contain the leading colon. func (mh MetaHeadersFrame) PseudoValue(pseudo string) string { for _, hf := range mh.Fields { if !hf.IsPseudo() { return "" } if hf.Name[1:] == pseudo { return hf.Value } } return "" } // RegularFields returns the regular (non-pseudo) header fields of mh. // The caller does not own the returned slice. func (mh MetaHeadersFrame) RegularFields() []hpack.HeaderField { for i, hf := range mh.Fields { if !hf.IsPseudo() { return mh.Fields[i:] } } return nil } // PseudoFields returns the pseudo header fields of mh. // The caller does not own the returned slice. func (mh MetaHeadersFrame) PseudoFields() []hpack.HeaderField { for i, hf := range mh.Fields { if !hf.IsPseudo() { return mh.Fields[:i] } } return mh.Fields } func (mh MetaHeadersFrame) checkPseudos() error { var isRequest, isResponse bool pf := mh.PseudoFields() for i, hf := range pf { switch hf.Name { case ":method", ":path", ":scheme", ":authority", ":protocol": isRequest = true case ":status": isResponse = true default: return pseudoHeaderError(hf.Name) } // Check for duplicates. // This would be a bad algorithm, but N is 5. // And this doesn't allocate. for _, hf2 := range pf[:i] { if hf.Name == hf2.Name { return duplicatePseudoHeaderError(hf.Name) } } } if isRequest && isResponse { return errMixPseudoHeaderTypes } return nil } func (fr Framer) maxHeaderStringLen() int { v := int(fr.maxHeaderListSize()) if v < 0 { // If maxHeaderListSize overflows an int, use no limit (0). return 0 } return v } // readMetaFrame returns 0 or more CONTINUATION frames from fr and // merge them into the provided hf and returns a MetaHeadersFrame // with the decoded hpack values. func (fr Framer) readMetaFrame(hf HeadersFrame) (Frame, error) { if fr.AllowIllegalReads { return nil, errors.New("illegal use of AllowIllegalReads with ReadMetaHeaders") } mh := &MetaHeadersFrame{ HeadersFrame: hf, } var remainSize = fr.maxHeaderListSize() var sawRegular bool var invalid error // pseudo header field errors hdec := fr.ReadMetaHeaders hdec.SetEmitEnabled(true) hdec.SetMaxStringLength(fr.maxHeaderStringLen()) hdec.SetEmitFunc(func(hf hpack.HeaderField) { if VerboseLogs && fr.logReads { fr.debugReadLoggerf("http2: decoded hpack field %+v", hf) } if !httpguts.ValidHeaderFieldValue(hf.Value) { // Don't include the value in the error, because it may be sensitive. invalid = headerFieldValueError(hf.Name) } isPseudo := strings.HasPrefix(hf.Name, ":") if isPseudo { if sawRegular { invalid = errPseudoAfterRegular } } else { sawRegular = true if !validWireHeaderFieldName(hf.Name) { invalid = headerFieldNameError(hf.Name) } } if invalid != nil { hdec.SetEmitEnabled(false) return } size := hf.Size() if size > remainSize { hdec.SetEmitEnabled(false) mh.Truncated = true remainSize = 0 return } remainSize -= size mh.Fields = append(mh.Fields, hf) }) // Lose reference to MetaHeadersFrame: defer hdec.SetEmitFunc(func(hf hpack.HeaderField) {}) var hc headersOrContinuation = hf for { frag := hc.HeaderBlockFragment() // Avoid parsing large amounts of headers that we will then discard. // If the sender exceeds the max header list size by too much, // skip parsing the fragment and close the connection. // // "Too much" is either any CONTINUATION frame after we've already // exceeded the max header list size (in which case remainSize is 0), // or a frame whose encoded size is more than twice the remaining // header list bytes we're willing to accept. if int64(len(frag)) > int64(2remainSize) { if VerboseLogs { log.Printf("http2: header list too large") } // It would be nice to send a RST_STREAM before sending the GOAWAY, // but the structure of the server's frame writer makes this difficult. return mh, ConnectionError(ErrCodeProtocol) } // Also close the connection after any CONTINUATION frame following an // invalid header, since we stop tracking the size of the headers after // an invalid one. if invalid != nil { if VerboseLogs { log.Printf("http2: invalid header: %v", invalid) } // It would be nice to send a RST_STREAM before sending the GOAWAY, // but the structure of the server's frame writer makes this difficult. return mh, ConnectionError(ErrCodeProtocol) } if _, err := hdec.Write(frag); err != nil { return mh, ConnectionError(ErrCodeCompression) } if hc.HeadersEnded() { break } if f, err := fr.ReadFrame(); err != nil { return nil, err } else { hc = f.(ContinuationFrame) // guaranteed by checkFrameOrder } } mh.HeadersFrame.headerFragBuf = nil mh.HeadersFrame.invalidate() if err := hdec.Close(); err != nil { return mh, ConnectionError(ErrCodeCompression) } if invalid != nil { fr.errDetail = invalid if VerboseLogs { log.Printf("http2: invalid header: %v", invalid) } return nil, StreamError{mh.StreamID, ErrCodeProtocol, invalid} } if err := mh.checkPseudos(); err != nil { fr.errDetail = err if VerboseLogs { log.Printf("http2: invalid pseudo headers: %v", err) } return nil, StreamError{mh.StreamID, ErrCodeProtocol, err} } return mh, nil } func summarizeFrame(f Frame) string { var buf bytes.Buffer f.Header().writeDebug(&buf) switch f := f.(type) { case SettingsFrame: n := 0 f.ForeachSetting(func(s Setting) error { n++ if n == 1 { buf.WriteString(", settings:") } fmt.Fprintf(&buf, " %v=%v,", s.ID, s.Val) return nil }) if n > 0 { buf.Truncate(buf.Len() - 1) // remove trailing comma } case DataFrame: data := f.Data() const max = 256 if len(data) > max { data = data[:max] } fmt.Fprintf(&buf, " data=%q", data) if len(f.Data()) > max { fmt.Fprintf(&buf, " (%d bytes omitted)", len(f.Data())-max) } case WindowUpdateFrame: if f.StreamID == 0 { buf.WriteString(" (conn)") } fmt.Fprintf(&buf, " incr=%v", f.Increment) case PingFrame: fmt.Fprintf(&buf, " ping=%q", f.Data[:]) case GoAwayFrame: fmt.Fprintf(&buf, " LastStreamID=%v ErrCode=%v Debug=%q", f.LastStreamID, f.ErrCode, f.debugData) case *RSTStreamFrame: fmt.Fprintf(&buf, " ErrCode=%v", f.ErrCode) } return buf.String() }	48.25 KB	2025-05-25 12:27
📄 frame_test.go // Copyright 2014 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import ( "bytes" "fmt" "io" "reflect" "strings" "testing" "unsafe" "golang.org/x/net/http2/hpack" ) func testFramer() (Framer, bytes.Buffer) { buf := new(bytes.Buffer) return NewFramer(buf, buf), buf } func TestFrameSizes(t testing.T) { // Catch people rearranging the FrameHeader fields. if got, want := int(unsafe.Sizeof(FrameHeader{})), 12; got != want { t.Errorf("FrameHeader size = %d; want %d", got, want) } } func TestFrameTypeString(t testing.T) { tests := []struct { ft FrameType want string }{ {FrameData, "DATA"}, {FramePing, "PING"}, {FrameGoAway, "GOAWAY"}, {0xf, "UNKNOWN_FRAME_TYPE_15"}, } for i, tt := range tests { got := tt.ft.String() if got != tt.want { t.Errorf("%d. String(FrameType %d) = %q; want %q", i, int(tt.ft), got, tt.want) } } } func TestWriteRST(t testing.T) { fr, buf := testFramer() var streamID uint32 = 1<<24 + 2<<16 + 3<<8 + 4 var errCode uint32 = 7<<24 + 6<<16 + 5<<8 + 4 fr.WriteRSTStream(streamID, ErrCode(errCode)) const wantEnc = "\x00\x00\x04\x03\x00\x01\x02\x03\x04\x07\x06\x05\x04" if buf.String() != wantEnc { t.Errorf("encoded as %q; want %q", buf.Bytes(), wantEnc) } f, err := fr.ReadFrame() if err != nil { t.Fatal(err) } want := &RSTStreamFrame{ FrameHeader: FrameHeader{ valid: true, Type: 0x3, Flags: 0x0, Length: 0x4, StreamID: 0x1020304, }, ErrCode: 0x7060504, } if !reflect.DeepEqual(f, want) { t.Errorf("parsed back %#v; want %#v", f, want) } } func TestWriteData(t testing.T) { fr, buf := testFramer() var streamID uint32 = 1<<24 + 2<<16 + 3<<8 + 4 data := []byte("ABC") fr.WriteData(streamID, true, data) const wantEnc = "\x00\x00\x03\x00\x01\x01\x02\x03\x04ABC" if buf.String() != wantEnc { t.Errorf("encoded as %q; want %q", buf.Bytes(), wantEnc) } f, err := fr.ReadFrame() if err != nil { t.Fatal(err) } df, ok := f.(DataFrame) if !ok { t.Fatalf("got %T; want DataFrame", f) } if !bytes.Equal(df.Data(), data) { t.Errorf("got %q; want %q", df.Data(), data) } if f.Header().Flags&1 == 0 { t.Errorf("didn't see END_STREAM flag") } } func TestWriteDataPadded(t testing.T) { tests := [...]struct { streamID uint32 endStream bool data []byte pad []byte wantHeader FrameHeader }{ // Unpadded: 0: { streamID: 1, endStream: true, data: []byte("foo"), pad: nil, wantHeader: FrameHeader{ Type: FrameData, Flags: FlagDataEndStream, Length: 3, StreamID: 1, }, }, // Padded bit set, but no padding: 1: { streamID: 1, endStream: true, data: []byte("foo"), pad: []byte{}, wantHeader: FrameHeader{ Type: FrameData, Flags: FlagDataEndStream \| FlagDataPadded, Length: 4, StreamID: 1, }, }, // Padded bit set, with padding: 2: { streamID: 1, endStream: false, data: []byte("foo"), pad: []byte{0, 0, 0}, wantHeader: FrameHeader{ Type: FrameData, Flags: FlagDataPadded, Length: 7, StreamID: 1, }, }, } for i, tt := range tests { fr, _ := testFramer() fr.WriteDataPadded(tt.streamID, tt.endStream, tt.data, tt.pad) f, err := fr.ReadFrame() if err != nil { t.Errorf("%d. ReadFrame: %v", i, err) continue } got := f.Header() tt.wantHeader.valid = true if !got.Equal(tt.wantHeader) { t.Errorf("%d. read %+v; want %+v", i, got, tt.wantHeader) continue } df := f.(DataFrame) if !bytes.Equal(df.Data(), tt.data) { t.Errorf("%d. got %q; want %q", i, df.Data(), tt.data) } } } func (fh FrameHeader) Equal(b FrameHeader) bool { return fh.valid == b.valid && fh.Type == b.Type && fh.Flags == b.Flags && fh.Length == b.Length && fh.StreamID == b.StreamID } func TestWriteHeaders(t testing.T) { tests := []struct { name string p HeadersFrameParam wantEnc string wantFrame HeadersFrame }{ { "basic", HeadersFrameParam{ StreamID: 42, BlockFragment: []byte("abc"), Priority: PriorityParam{}, }, "\x00\x00\x03\x01\x00\x00\x00\x00abc", &HeadersFrame{ FrameHeader: FrameHeader{ valid: true, StreamID: 42, Type: FrameHeaders, Length: uint32(len("abc")), }, Priority: PriorityParam{}, headerFragBuf: []byte("abc"), }, }, { "basic + end flags", HeadersFrameParam{ StreamID: 42, BlockFragment: []byte("abc"), EndStream: true, EndHeaders: true, Priority: PriorityParam{}, }, "\x00\x00\x03\x01\x05\x00\x00\x00abc", &HeadersFrame{ FrameHeader: FrameHeader{ valid: true, StreamID: 42, Type: FrameHeaders, Flags: FlagHeadersEndStream \| FlagHeadersEndHeaders, Length: uint32(len("abc")), }, Priority: PriorityParam{}, headerFragBuf: []byte("abc"), }, }, { "with padding", HeadersFrameParam{ StreamID: 42, BlockFragment: []byte("abc"), EndStream: true, EndHeaders: true, PadLength: 5, Priority: PriorityParam{}, }, "\x00\x00\t\x01\r\x00\x00\x00\x05abc\x00\x00\x00\x00\x00", &HeadersFrame{ FrameHeader: FrameHeader{ valid: true, StreamID: 42, Type: FrameHeaders, Flags: FlagHeadersEndStream \| FlagHeadersEndHeaders \| FlagHeadersPadded, Length: uint32(1 + len("abc") + 5), // pad length + contents + padding }, Priority: PriorityParam{}, headerFragBuf: []byte("abc"), }, }, { "with priority", HeadersFrameParam{ StreamID: 42, BlockFragment: []byte("abc"), EndStream: true, EndHeaders: true, PadLength: 2, Priority: PriorityParam{ StreamDep: 15, Exclusive: true, Weight: 127, }, }, "\x00\x00\v\x01-\x00\x00\x00\x02\x80\x00\x00\x0f\u007fabc\x00\x00", &HeadersFrame{ FrameHeader: FrameHeader{ valid: true, StreamID: 42, Type: FrameHeaders, Flags: FlagHeadersEndStream \| FlagHeadersEndHeaders \| FlagHeadersPadded \| FlagHeadersPriority, Length: uint32(1 + 5 + len("abc") + 2), // pad length + priority + contents + padding }, Priority: PriorityParam{ StreamDep: 15, Exclusive: true, Weight: 127, }, headerFragBuf: []byte("abc"), }, }, { "with priority stream dep zero", // golang.org/issue/15444 HeadersFrameParam{ StreamID: 42, BlockFragment: []byte("abc"), EndStream: true, EndHeaders: true, PadLength: 2, Priority: PriorityParam{ StreamDep: 0, Exclusive: true, Weight: 127, }, }, "\x00\x00\v\x01-\x00\x00\x00\x02\x80\x00\x00\x00\u007fabc\x00\x00", &HeadersFrame{ FrameHeader: FrameHeader{ valid: true, StreamID: 42, Type: FrameHeaders, Flags: FlagHeadersEndStream \| FlagHeadersEndHeaders \| FlagHeadersPadded \| FlagHeadersPriority, Length: uint32(1 + 5 + len("abc") + 2), // pad length + priority + contents + padding }, Priority: PriorityParam{ StreamDep: 0, Exclusive: true, Weight: 127, }, headerFragBuf: []byte("abc"), }, }, { "zero length", HeadersFrameParam{ StreamID: 42, Priority: PriorityParam{}, }, "\x00\x00\x00\x01\x00\x00\x00\x00", &HeadersFrame{ FrameHeader: FrameHeader{ valid: true, StreamID: 42, Type: FrameHeaders, Length: 0, }, Priority: PriorityParam{}, }, }, } for _, tt := range tests { fr, buf := testFramer() if err := fr.WriteHeaders(tt.p); err != nil { t.Errorf("test %q: %v", tt.name, err) continue } if buf.String() != tt.wantEnc { t.Errorf("test %q: encoded %q; want %q", tt.name, buf.Bytes(), tt.wantEnc) } f, err := fr.ReadFrame() if err != nil { t.Errorf("test %q: failed to read the frame back: %v", tt.name, err) continue } if !reflect.DeepEqual(f, tt.wantFrame) { t.Errorf("test %q: mismatch.\n got: %#v\nwant: %#v\n", tt.name, f, tt.wantFrame) } } } func TestWriteInvalidStreamDep(t testing.T) { fr, _ := testFramer() err := fr.WriteHeaders(HeadersFrameParam{ StreamID: 42, Priority: PriorityParam{ StreamDep: 1 << 31, }, }) if err != errDepStreamID { t.Errorf("header error = %v; want %q", err, errDepStreamID) } err = fr.WritePriority(2, PriorityParam{StreamDep: 1 << 31}) if err != errDepStreamID { t.Errorf("priority error = %v; want %q", err, errDepStreamID) } } func TestWriteContinuation(t testing.T) { const streamID = 42 tests := []struct { name string end bool frag []byte wantFrame ContinuationFrame }{ { "not end", false, []byte("abc"), &ContinuationFrame{ FrameHeader: FrameHeader{ valid: true, StreamID: streamID, Type: FrameContinuation, Length: uint32(len("abc")), }, headerFragBuf: []byte("abc"), }, }, { "end", true, []byte("def"), &ContinuationFrame{ FrameHeader: FrameHeader{ valid: true, StreamID: streamID, Type: FrameContinuation, Flags: FlagContinuationEndHeaders, Length: uint32(len("def")), }, headerFragBuf: []byte("def"), }, }, } for _, tt := range tests { fr, _ := testFramer() if err := fr.WriteContinuation(streamID, tt.end, tt.frag); err != nil { t.Errorf("test %q: %v", tt.name, err) continue } fr.AllowIllegalReads = true f, err := fr.ReadFrame() if err != nil { t.Errorf("test %q: failed to read the frame back: %v", tt.name, err) continue } if !reflect.DeepEqual(f, tt.wantFrame) { t.Errorf("test %q: mismatch.\n got: %#v\nwant: %#v\n", tt.name, f, tt.wantFrame) } } } func TestWritePriority(t testing.T) { const streamID = 42 tests := []struct { name string priority PriorityParam wantFrame PriorityFrame }{ { "not exclusive", PriorityParam{ StreamDep: 2, Exclusive: false, Weight: 127, }, &PriorityFrame{ FrameHeader{ valid: true, StreamID: streamID, Type: FramePriority, Length: 5, }, PriorityParam{ StreamDep: 2, Exclusive: false, Weight: 127, }, }, }, { "exclusive", PriorityParam{ StreamDep: 3, Exclusive: true, Weight: 77, }, &PriorityFrame{ FrameHeader{ valid: true, StreamID: streamID, Type: FramePriority, Length: 5, }, PriorityParam{ StreamDep: 3, Exclusive: true, Weight: 77, }, }, }, } for _, tt := range tests { fr, _ := testFramer() if err := fr.WritePriority(streamID, tt.priority); err != nil { t.Errorf("test %q: %v", tt.name, err) continue } f, err := fr.ReadFrame() if err != nil { t.Errorf("test %q: failed to read the frame back: %v", tt.name, err) continue } if !reflect.DeepEqual(f, tt.wantFrame) { t.Errorf("test %q: mismatch.\n got: %#v\nwant: %#v\n", tt.name, f, tt.wantFrame) } } } func TestWriteSettings(t testing.T) { fr, buf := testFramer() settings := []Setting{{1, 2}, {3, 4}} fr.WriteSettings(settings...) const wantEnc = "\x00\x00\f\x04\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x03\x00\x00\x00\x04" if buf.String() != wantEnc { t.Errorf("encoded as %q; want %q", buf.Bytes(), wantEnc) } f, err := fr.ReadFrame() if err != nil { t.Fatal(err) } sf, ok := f.(SettingsFrame) if !ok { t.Fatalf("Got a %T; want a SettingsFrame", f) } var got []Setting sf.ForeachSetting(func(s Setting) error { got = append(got, s) valBack, ok := sf.Value(s.ID) if !ok \|\| valBack != s.Val { t.Errorf("Value(%d) = %v, %v; want %v, true", s.ID, valBack, ok, s.Val) } return nil }) if !reflect.DeepEqual(settings, got) { t.Errorf("Read settings %+v != written settings %+v", got, settings) } } func TestWriteSettingsAck(t testing.T) { fr, buf := testFramer() fr.WriteSettingsAck() const wantEnc = "\x00\x00\x00\x04\x01\x00\x00\x00\x00" if buf.String() != wantEnc { t.Errorf("encoded as %q; want %q", buf.Bytes(), wantEnc) } } func TestWriteWindowUpdate(t testing.T) { fr, buf := testFramer() const streamID = 1<<24 + 2<<16 + 3<<8 + 4 const incr = 7<<24 + 6<<16 + 5<<8 + 4 if err := fr.WriteWindowUpdate(streamID, incr); err != nil { t.Fatal(err) } const wantEnc = "\x00\x00\x04\x08\x00\x01\x02\x03\x04\x07\x06\x05\x04" if buf.String() != wantEnc { t.Errorf("encoded as %q; want %q", buf.Bytes(), wantEnc) } f, err := fr.ReadFrame() if err != nil { t.Fatal(err) } want := &WindowUpdateFrame{ FrameHeader: FrameHeader{ valid: true, Type: 0x8, Flags: 0x0, Length: 0x4, StreamID: 0x1020304, }, Increment: 0x7060504, } if !reflect.DeepEqual(f, want) { t.Errorf("parsed back %#v; want %#v", f, want) } } func TestWritePing(t testing.T) { testWritePing(t, false) } func TestWritePingAck(t testing.T) { testWritePing(t, true) } func testWritePing(t testing.T, ack bool) { fr, buf := testFramer() if err := fr.WritePing(ack, [8]byte{1, 2, 3, 4, 5, 6, 7, 8}); err != nil { t.Fatal(err) } var wantFlags Flags if ack { wantFlags = FlagPingAck } var wantEnc = "\x00\x00\x08\x06" + string(wantFlags) + "\x00\x00\x00\x00" + "\x01\x02\x03\x04\x05\x06\x07\x08" if buf.String() != wantEnc { t.Errorf("encoded as %q; want %q", buf.Bytes(), wantEnc) } f, err := fr.ReadFrame() if err != nil { t.Fatal(err) } want := &PingFrame{ FrameHeader: FrameHeader{ valid: true, Type: 0x6, Flags: wantFlags, Length: 0x8, StreamID: 0, }, Data: [8]byte{1, 2, 3, 4, 5, 6, 7, 8}, } if !reflect.DeepEqual(f, want) { t.Errorf("parsed back %#v; want %#v", f, want) } } func TestReadFrameHeader(t testing.T) { tests := []struct { in string want FrameHeader }{ {in: "\x00\x00\x00" + "\x00" + "\x00" + "\x00\x00\x00\x00", want: FrameHeader{}}, {in: "\x01\x02\x03" + "\x04" + "\x05" + "\x06\x07\x08\x09", want: FrameHeader{ Length: 66051, Type: 4, Flags: 5, StreamID: 101124105, }}, // Ignore high bit: {in: "\xff\xff\xff" + "\xff" + "\xff" + "\xff\xff\xff\xff", want: FrameHeader{ Length: 16777215, Type: 255, Flags: 255, StreamID: 2147483647}}, {in: "\xff\xff\xff" + "\xff" + "\xff" + "\x7f\xff\xff\xff", want: FrameHeader{ Length: 16777215, Type: 255, Flags: 255, StreamID: 2147483647}}, } for i, tt := range tests { got, err := readFrameHeader(make([]byte, 9), strings.NewReader(tt.in)) if err != nil { t.Errorf("%d. readFrameHeader(%q) = %v", i, tt.in, err) continue } tt.want.valid = true if !got.Equal(tt.want) { t.Errorf("%d. readFrameHeader(%q) = %+v; want %+v", i, tt.in, got, tt.want) } } } func TestReadWriteFrameHeader(t testing.T) { tests := []struct { len uint32 typ FrameType flags Flags streamID uint32 }{ {len: 0, typ: 255, flags: 1, streamID: 0}, {len: 0, typ: 255, flags: 1, streamID: 1}, {len: 0, typ: 255, flags: 1, streamID: 255}, {len: 0, typ: 255, flags: 1, streamID: 256}, {len: 0, typ: 255, flags: 1, streamID: 65535}, {len: 0, typ: 255, flags: 1, streamID: 65536}, {len: 0, typ: 1, flags: 255, streamID: 1}, {len: 255, typ: 1, flags: 255, streamID: 1}, {len: 256, typ: 1, flags: 255, streamID: 1}, {len: 65535, typ: 1, flags: 255, streamID: 1}, {len: 65536, typ: 1, flags: 255, streamID: 1}, {len: 16777215, typ: 1, flags: 255, streamID: 1}, } for _, tt := range tests { fr, buf := testFramer() fr.startWrite(tt.typ, tt.flags, tt.streamID) fr.writeBytes(make([]byte, tt.len)) fr.endWrite() fh, err := ReadFrameHeader(buf) if err != nil { t.Errorf("ReadFrameHeader(%+v) = %v", tt, err) continue } if fh.Type != tt.typ \|\| fh.Flags != tt.flags \|\| fh.Length != tt.len \|\| fh.StreamID != tt.streamID { t.Errorf("ReadFrameHeader(%+v) = %+v; mismatch", tt, fh) } } } func TestWriteTooLargeFrame(t testing.T) { fr, _ := testFramer() fr.startWrite(0, 1, 1) fr.writeBytes(make([]byte, 1<<24)) err := fr.endWrite() if err != ErrFrameTooLarge { t.Errorf("endWrite = %v; want errFrameTooLarge", err) } } func TestWriteGoAway(t testing.T) { const debug = "foo" fr, buf := testFramer() if err := fr.WriteGoAway(0x01020304, 0x05060708, []byte(debug)); err != nil { t.Fatal(err) } const wantEnc = "\x00\x00\v\a\x00\x00\x00\x00\x00\x01\x02\x03\x04\x05\x06\x07\x08" + debug if buf.String() != wantEnc { t.Errorf("encoded as %q; want %q", buf.Bytes(), wantEnc) } f, err := fr.ReadFrame() if err != nil { t.Fatal(err) } want := &GoAwayFrame{ FrameHeader: FrameHeader{ valid: true, Type: 0x7, Flags: 0, Length: uint32(4 + 4 + len(debug)), StreamID: 0, }, LastStreamID: 0x01020304, ErrCode: 0x05060708, debugData: []byte(debug), } if !reflect.DeepEqual(f, want) { t.Fatalf("parsed back:\n%#v\nwant:\n%#v", f, want) } if got := string(f.(GoAwayFrame).DebugData()); got != debug { t.Errorf("debug data = %q; want %q", got, debug) } } func TestWritePushPromise(t testing.T) { pp := PushPromiseParam{ StreamID: 42, PromiseID: 42, BlockFragment: []byte("abc"), } fr, buf := testFramer() if err := fr.WritePushPromise(pp); err != nil { t.Fatal(err) } const wantEnc = "\x00\x00\x07\x05\x00\x00\x00\x00\x00\x00\x00abc" if buf.String() != wantEnc { t.Errorf("encoded as %q; want %q", buf.Bytes(), wantEnc) } f, err := fr.ReadFrame() if err != nil { t.Fatal(err) } _, ok := f.(PushPromiseFrame) if !ok { t.Fatalf("got %T; want PushPromiseFrame", f) } want := &PushPromiseFrame{ FrameHeader: FrameHeader{ valid: true, Type: 0x5, Flags: 0x0, Length: 0x7, StreamID: 42, }, PromiseID: 42, headerFragBuf: []byte("abc"), } if !reflect.DeepEqual(f, want) { t.Fatalf("parsed back:\n%#v\nwant:\n%#v", f, want) } } // test checkFrameOrder and that HEADERS and CONTINUATION frames can't be intermingled. func TestReadFrameOrder(t testing.T) { head := func(f Framer, id uint32, end bool) { f.WriteHeaders(HeadersFrameParam{ StreamID: id, BlockFragment: []byte("foo"), // unused, but non-empty EndHeaders: end, }) } cont := func(f Framer, id uint32, end bool) { f.WriteContinuation(id, end, []byte("foo")) } tests := [...]struct { name string w func(Framer) atLeast int wantErr string }{ 0: { w: func(f Framer) { head(f, 1, true) }, }, 1: { w: func(f Framer) { head(f, 1, true) head(f, 2, true) }, }, 2: { wantErr: "got HEADERS for stream 2; expected CONTINUATION following HEADERS for stream 1", w: func(f Framer) { head(f, 1, false) head(f, 2, true) }, }, 3: { wantErr: "got DATA for stream 1; expected CONTINUATION following HEADERS for stream 1", w: func(f Framer) { head(f, 1, false) }, }, 4: { w: func(f Framer) { head(f, 1, false) cont(f, 1, true) head(f, 2, true) }, }, 5: { wantErr: "got CONTINUATION for stream 2; expected stream 1", w: func(f Framer) { head(f, 1, false) cont(f, 2, true) head(f, 2, true) }, }, 6: { wantErr: "unexpected CONTINUATION for stream 1", w: func(f Framer) { cont(f, 1, true) }, }, 7: { wantErr: "unexpected CONTINUATION for stream 1", w: func(f Framer) { cont(f, 1, false) }, }, 8: { wantErr: "HEADERS frame with stream ID 0", w: func(f Framer) { head(f, 0, true) }, }, 9: { wantErr: "CONTINUATION frame with stream ID 0", w: func(f Framer) { cont(f, 0, true) }, }, 10: { wantErr: "unexpected CONTINUATION for stream 1", atLeast: 5, w: func(f Framer) { head(f, 1, false) cont(f, 1, false) cont(f, 1, false) cont(f, 1, false) cont(f, 1, true) cont(f, 1, false) }, }, } for i, tt := range tests { buf := new(bytes.Buffer) f := NewFramer(buf, buf) f.AllowIllegalWrites = true tt.w(f) f.WriteData(1, true, nil) // to test transition away from last step var err error n := 0 var log bytes.Buffer for { var got Frame got, err = f.ReadFrame() fmt.Fprintf(&log, " read %v, %v\n", got, err) if err != nil { break } n++ } if err == io.EOF { err = nil } ok := tt.wantErr == "" if ok && err != nil { t.Errorf("%d. after %d good frames, ReadFrame = %v; want success\n%s", i, n, err, log.Bytes()) continue } if !ok && err != ConnectionError(ErrCodeProtocol) { t.Errorf("%d. after %d good frames, ReadFrame = %v; want ConnectionError(ErrCodeProtocol)\n%s", i, n, err, log.Bytes()) continue } if !((f.errDetail == nil && tt.wantErr == "") \|\| (fmt.Sprint(f.errDetail) == tt.wantErr)) { t.Errorf("%d. framer eror = %q; want %q\n%s", i, f.errDetail, tt.wantErr, log.Bytes()) } if n < tt.atLeast { t.Errorf("%d. framer only read %d frames; want at least %d\n%s", i, n, tt.atLeast, log.Bytes()) } } } func TestMetaFrameHeader(t testing.T) { write := func(f Framer, frags ...[]byte) { for i, frag := range frags { end := (i == len(frags)-1) if i == 0 { f.WriteHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: frag, EndHeaders: end, }) } else { f.WriteContinuation(1, end, frag) } } } want := func(flags Flags, length uint32, pairs ...string) MetaHeadersFrame { mh := &MetaHeadersFrame{ HeadersFrame: &HeadersFrame{ FrameHeader: FrameHeader{ Type: FrameHeaders, Flags: flags, Length: length, StreamID: 1, }, }, Fields: []hpack.HeaderField(nil), } for len(pairs) > 0 { mh.Fields = append(mh.Fields, hpack.HeaderField{ Name: pairs[0], Value: pairs[1], }) pairs = pairs[2:] } return mh } truncated := func(mh MetaHeadersFrame) MetaHeadersFrame { mh.Truncated = true return mh } const noFlags Flags = 0 oneKBString := strings.Repeat("a", 1<<10) tests := [...]struct { name string w func(Framer) want interface{} // MetaHeaderFrame or error wantErrReason string maxHeaderListSize uint32 }{ 0: { name: "single_headers", w: func(f Framer) { var he hpackEncoder all := he.encodeHeaderRaw(t, ":method", "GET", ":path", "/") write(f, all) }, want: want(FlagHeadersEndHeaders, 2, ":method", "GET", ":path", "/"), }, 1: { name: "with_continuation", w: func(f Framer) { var he hpackEncoder all := he.encodeHeaderRaw(t, ":method", "GET", ":path", "/", "foo", "bar") write(f, all[:1], all[1:]) }, want: want(noFlags, 1, ":method", "GET", ":path", "/", "foo", "bar"), }, 2: { name: "with_two_continuation", w: func(f Framer) { var he hpackEncoder all := he.encodeHeaderRaw(t, ":method", "GET", ":path", "/", "foo", "bar") write(f, all[:2], all[2:4], all[4:]) }, want: want(noFlags, 2, ":method", "GET", ":path", "/", "foo", "bar"), }, 3: { name: "big_string_okay", w: func(f Framer) { var he hpackEncoder all := he.encodeHeaderRaw(t, ":method", "GET", ":path", "/", "foo", oneKBString) write(f, all[:2], all[2:]) }, want: want(noFlags, 2, ":method", "GET", ":path", "/", "foo", oneKBString), }, 4: { name: "big_string_error", w: func(f Framer) { var he hpackEncoder all := he.encodeHeaderRaw(t, ":method", "GET", ":path", "/", "foo", oneKBString) write(f, all[:2], all[2:]) }, maxHeaderListSize: (1 << 10) / 2, want: ConnectionError(ErrCodeCompression), }, 5: { name: "max_header_list_truncated", w: func(f Framer) { var he hpackEncoder var pairs = []string{":method", "GET", ":path", "/"} for i := 0; i < 100; i++ { pairs = append(pairs, "foo", "bar") } all := he.encodeHeaderRaw(t, pairs...) write(f, all[:2], all[2:]) }, maxHeaderListSize: (1 << 10) / 2, want: truncated(want(noFlags, 2, ":method", "GET", ":path", "/", "foo", "bar", "foo", "bar", "foo", "bar", "foo", "bar", "foo", "bar", "foo", "bar", "foo", "bar", "foo", "bar", "foo", "bar", "foo", "bar", "foo", "bar", // 11 )), }, 6: { name: "pseudo_order", w: func(f Framer) { write(f, encodeHeaderRaw(t, ":method", "GET", "foo", "bar", ":path", "/", // bogus )) }, want: streamError(1, ErrCodeProtocol), wantErrReason: "pseudo header field after regular", }, 7: { name: "pseudo_unknown", w: func(f Framer) { write(f, encodeHeaderRaw(t, ":unknown", "foo", // bogus "foo", "bar", )) }, want: streamError(1, ErrCodeProtocol), wantErrReason: "invalid pseudo-header \":unknown\"", }, 8: { name: "pseudo_mix_request_response", w: func(f Framer) { write(f, encodeHeaderRaw(t, ":method", "GET", ":status", "100", )) }, want: streamError(1, ErrCodeProtocol), wantErrReason: "mix of request and response pseudo headers", }, 9: { name: "pseudo_dup", w: func(f Framer) { write(f, encodeHeaderRaw(t, ":method", "GET", ":method", "POST", )) }, want: streamError(1, ErrCodeProtocol), wantErrReason: "duplicate pseudo-header \":method\"", }, 10: { name: "trailer_okay_no_pseudo", w: func(f Framer) { write(f, encodeHeaderRaw(t, "foo", "bar")) }, want: want(FlagHeadersEndHeaders, 8, "foo", "bar"), }, 11: { name: "invalid_field_name", w: func(f Framer) { write(f, encodeHeaderRaw(t, "CapitalBad", "x")) }, want: streamError(1, ErrCodeProtocol), wantErrReason: "invalid header field name \"CapitalBad\"", }, 12: { name: "invalid_field_value", w: func(f Framer) { write(f, encodeHeaderRaw(t, "key", "bad_null\x00")) }, want: streamError(1, ErrCodeProtocol), wantErrReason: `invalid header field value for "key"`, }, } for i, tt := range tests { buf := new(bytes.Buffer) f := NewFramer(buf, buf) f.ReadMetaHeaders = hpack.NewDecoder(initialHeaderTableSize, nil) f.MaxHeaderListSize = tt.maxHeaderListSize tt.w(f) name := tt.name if name == "" { name = fmt.Sprintf("test index %d", i) } var got interface{} var err error got, err = f.ReadFrame() if err != nil { got = err // Ignore the StreamError.Cause field, if it matches the wantErrReason. // The test table above predates the Cause field. if se, ok := err.(StreamError); ok && se.Cause != nil && se.Cause.Error() == tt.wantErrReason { se.Cause = nil got = se } } if !reflect.DeepEqual(got, tt.want) { if mhg, ok := got.(MetaHeadersFrame); ok { if mhw, ok := tt.want.(MetaHeadersFrame); ok { hg := mhg.HeadersFrame hw := mhw.HeadersFrame if hg != nil && hw != nil && !reflect.DeepEqual(hg, hw) { t.Errorf("%s: headers differ:\n got: %+v\nwant: %+v\n", name, hg, hw) } } } str := func(v interface{}) string { if _, ok := v.(error); ok { return fmt.Sprintf("error %v", v) } else { return fmt.Sprintf("value %#v", v) } } t.Errorf("%s:\n got: %v\nwant: %s", name, str(got), str(tt.want)) } if tt.wantErrReason != "" && tt.wantErrReason != fmt.Sprint(f.errDetail) { t.Errorf("%s: got error reason %q; want %q", name, f.errDetail, tt.wantErrReason) } } } func TestSetReuseFrames(t testing.T) { fr, buf := testFramer() fr.SetReuseFrames() // Check that DataFrames are reused. Note that // SetReuseFrames only currently implements reuse of DataFrames. firstDf := readAndVerifyDataFrame("ABC", 3, fr, buf, t) for i := 0; i < 10; i++ { df := readAndVerifyDataFrame("XYZ", 3, fr, buf, t) if df != firstDf { t.Errorf("Expected Framer to return references to the same DataFrame. Have %v and %v", &df, &firstDf) } } for i := 0; i < 10; i++ { df := readAndVerifyDataFrame("", 0, fr, buf, t) if df != firstDf { t.Errorf("Expected Framer to return references to the same DataFrame. Have %v and %v", &df, &firstDf) } } for i := 0; i < 10; i++ { df := readAndVerifyDataFrame("HHH", 3, fr, buf, t) if df != firstDf { t.Errorf("Expected Framer to return references to the same DataFrame. Have %v and %v", &df, &firstDf) } } } func TestSetReuseFramesMoreThanOnce(t testing.T) { fr, buf := testFramer() fr.SetReuseFrames() firstDf := readAndVerifyDataFrame("ABC", 3, fr, buf, t) fr.SetReuseFrames() for i := 0; i < 10; i++ { df := readAndVerifyDataFrame("XYZ", 3, fr, buf, t) // SetReuseFrames should be idempotent fr.SetReuseFrames() if df != firstDf { t.Errorf("Expected Framer to return references to the same DataFrame. Have %v and %v", &df, &firstDf) } } } func TestNoSetReuseFrames(t testing.T) { fr, buf := testFramer() const numNewDataFrames = 10 dfSoFar := make([]interface{}, numNewDataFrames) // Check that DataFrames are not reused if SetReuseFrames wasn't called. // SetReuseFrames only currently implements reuse of DataFrames. for i := 0; i < numNewDataFrames; i++ { df := readAndVerifyDataFrame("XYZ", 3, fr, buf, t) for _, item := range dfSoFar { if df == item { t.Errorf("Expected Framer to return new DataFrames since SetNoReuseFrames not set.") } } dfSoFar[i] = df } } func readAndVerifyDataFrame(data string, length byte, fr Framer, buf bytes.Buffer, t testing.T) DataFrame { var streamID uint32 = 1<<24 + 2<<16 + 3<<8 + 4 fr.WriteData(streamID, true, []byte(data)) wantEnc := "\x00\x00" + string(length) + "\x00\x01\x01\x02\x03\x04" + data if buf.String() != wantEnc { t.Errorf("encoded as %q; want %q", buf.Bytes(), wantEnc) } f, err := fr.ReadFrame() if err != nil { t.Fatal(err) } df, ok := f.(DataFrame) if !ok { t.Fatalf("got %T; want DataFrame", f) } if !bytes.Equal(df.Data(), []byte(data)) { t.Errorf("got %q; want %q", df.Data(), []byte(data)) } if f.Header().Flags&1 == 0 { t.Errorf("didn't see END_STREAM flag") } return df } func encodeHeaderRaw(t testing.T, pairs ...string) []byte { var he hpackEncoder return he.encodeHeaderRaw(t, pairs...) } func TestSettingsDuplicates(t testing.T) { tests := []struct { settings []Setting want bool }{ {nil, false}, {[]Setting{{ID: 1}}, false}, {[]Setting{{ID: 1}, {ID: 2}}, false}, {[]Setting{{ID: 1}, {ID: 2}}, false}, {[]Setting{{ID: 1}, {ID: 2}, {ID: 3}}, false}, {[]Setting{{ID: 1}, {ID: 2}, {ID: 3}}, false}, {[]Setting{{ID: 1}, {ID: 2}, {ID: 3}, {ID: 4}}, false}, {[]Setting{{ID: 1}, {ID: 2}, {ID: 3}, {ID: 2}}, true}, {[]Setting{{ID: 4}, {ID: 2}, {ID: 3}, {ID: 4}}, true}, {[]Setting{ {ID: 1}, {ID: 2}, {ID: 3}, {ID: 4}, {ID: 5}, {ID: 6}, {ID: 7}, {ID: 8}, {ID: 9}, {ID: 10}, {ID: 11}, {ID: 12}, }, false}, {[]Setting{ {ID: 1}, {ID: 2}, {ID: 3}, {ID: 4}, {ID: 5}, {ID: 6}, {ID: 7}, {ID: 8}, {ID: 9}, {ID: 10}, {ID: 11}, {ID: 11}, }, true}, } for i, tt := range tests { fr, _ := testFramer() fr.WriteSettings(tt.settings...) f, err := fr.ReadFrame() if err != nil { t.Fatalf("%d. ReadFrame: %v", i, err) } sf := f.(*SettingsFrame) got := sf.HasDuplicates() if got != tt.want { t.Errorf("%d. HasDuplicates = %v; want %v", i, got, tt.want) } } }	30.73 KB	2025-05-25 12:27
📄 gate_test.go // Copyright 2024 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import "context" // An gate is a monitor (mutex + condition variable) with one bit of state. // // The condition may be either set or unset. // Lock operations may be unconditional, or wait for the condition to be set. // Unlock operations record the new state of the condition. type gate struct { // When unlocked, exactly one of set or unset contains a value. // When locked, neither chan contains a value. set chan struct{} unset chan struct{} } // newGate returns a new, unlocked gate with the condition unset. func newGate() gate { g := newLockedGate() g.unlock(false) return g } // newLocked gate returns a new, locked gate. func newLockedGate() gate { return gate{ set: make(chan struct{}, 1), unset: make(chan struct{}, 1), } } // lock acquires the gate unconditionally. // It reports whether the condition is set. func (g gate) lock() (set bool) { select { case <-g.set: return true case <-g.unset: return false } } // waitAndLock waits until the condition is set before acquiring the gate. // If the context expires, waitAndLock returns an error and does not acquire the gate. func (g gate) waitAndLock(ctx context.Context) error { select { case <-g.set: return nil default: } select { case <-g.set: return nil case <-ctx.Done(): return ctx.Err() } } // lockIfSet acquires the gate if and only if the condition is set. func (g gate) lockIfSet() (acquired bool) { select { case <-g.set: return true default: return false } } // unlock sets the condition and releases the gate. func (g gate) unlock(set bool) { if set { g.set <- struct{}{} } else { g.unset <- struct{}{} } } // unlock sets the condition to the result of f and releases the gate. // Useful in defers. func (g *gate) unlockFunc(f func() bool) { g.unlock(f()) }	1.93 KB	2025-05-25 12:27
📄 gotrack.go // Copyright 2014 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Defensive debug-only utility to track that functions run on the // goroutine that they're supposed to. package http2 import ( "bytes" "errors" "fmt" "os" "runtime" "strconv" "sync" ) var DebugGoroutines = os.Getenv("DEBUG_HTTP2_GOROUTINES") == "1" type goroutineLock uint64 func newGoroutineLock() goroutineLock { if !DebugGoroutines { return 0 } return goroutineLock(curGoroutineID()) } func (g goroutineLock) check() { if !DebugGoroutines { return } if curGoroutineID() != uint64(g) { panic("running on the wrong goroutine") } } func (g goroutineLock) checkNotOn() { if !DebugGoroutines { return } if curGoroutineID() == uint64(g) { panic("running on the wrong goroutine") } } var goroutineSpace = []byte("goroutine ") func curGoroutineID() uint64 { bp := littleBuf.Get().([]byte) defer littleBuf.Put(bp) b := bp b = b[:runtime.Stack(b, false)] // Parse the 4707 out of "goroutine 4707 [" b = bytes.TrimPrefix(b, goroutineSpace) i := bytes.IndexByte(b, ' ') if i < 0 { panic(fmt.Sprintf("No space found in %q", b)) } b = b[:i] n, err := parseUintBytes(b, 10, 64) if err != nil { panic(fmt.Sprintf("Failed to parse goroutine ID out of %q: %v", b, err)) } return n } var littleBuf = sync.Pool{ New: func() interface{} { buf := make([]byte, 64) return &buf }, } // parseUintBytes is like strconv.ParseUint, but using a []byte. func parseUintBytes(s []byte, base int, bitSize int) (n uint64, err error) { var cutoff, maxVal uint64 if bitSize == 0 { bitSize = int(strconv.IntSize) } s0 := s switch { case len(s) < 1: err = strconv.ErrSyntax goto Error case 2 <= base && base <= 36: // valid base; nothing to do case base == 0: // Look for octal, hex prefix. switch { case s[0] == '0' && len(s) > 1 && (s[1] == 'x' \|\| s[1] == 'X'): base = 16 s = s[2:] if len(s) < 1 { err = strconv.ErrSyntax goto Error } case s[0] == '0': base = 8 default: base = 10 } default: err = errors.New("invalid base " + strconv.Itoa(base)) goto Error } n = 0 cutoff = cutoff64(base) maxVal = 1<<uint(bitSize) - 1 for i := 0; i < len(s); i++ { var v byte d := s[i] switch { case '0' <= d && d <= '9': v = d - '0' case 'a' <= d && d <= 'z': v = d - 'a' + 10 case 'A' <= d && d <= 'Z': v = d - 'A' + 10 default: n = 0 err = strconv.ErrSyntax goto Error } if int(v) >= base { n = 0 err = strconv.ErrSyntax goto Error } if n >= cutoff { // nbase overflows n = 1<<64 - 1 err = strconv.ErrRange goto Error } n = uint64(base) n1 := n + uint64(v) if n1 < n \|\| n1 > maxVal { // n+v overflows n = 1<<64 - 1 err = strconv.ErrRange goto Error } n = n1 } return n, nil Error: return n, &strconv.NumError{Func: "ParseUint", Num: string(s0), Err: err} } // Return the first number n such that n*base >= 1<<64. func cutoff64(base int) uint64 { if base < 2 { return 0 } return (1<<64-1)/uint64(base) + 1 }	3.09 KB	2025-05-25 12:27
📄 gotrack_test.go // Copyright 2014 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import ( "fmt" "strings" "testing" ) func TestGoroutineLock(t *testing.T) { oldDebug := DebugGoroutines DebugGoroutines = true defer func() { DebugGoroutines = oldDebug }() g := newGoroutineLock() g.check() sawPanic := make(chan interface{}) go func() { defer func() { sawPanic <- recover() }() g.check() // should panic }() e := <-sawPanic if e == nil { t.Fatal("did not see panic from check in other goroutine") } if !strings.Contains(fmt.Sprint(e), "wrong goroutine") { t.Errorf("expected on see panic about running on the wrong goroutine; got %v", e) } }	761 B	2025-05-25 12:27
📁 h2c	-	2025-05-25 12:27
📁 h2i	-	2025-05-25 12:27
📄 headermap.go // Copyright 2014 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import ( "net/http" "sync" ) var ( commonBuildOnce sync.Once commonLowerHeader map[string]string // Go-Canonical-Case -> lower-case commonCanonHeader map[string]string // lower-case -> Go-Canonical-Case ) func buildCommonHeaderMapsOnce() { commonBuildOnce.Do(buildCommonHeaderMaps) } func buildCommonHeaderMaps() { common := []string{ "accept", "accept-charset", "accept-encoding", "accept-language", "accept-ranges", "age", "access-control-allow-credentials", "access-control-allow-headers", "access-control-allow-methods", "access-control-allow-origin", "access-control-expose-headers", "access-control-max-age", "access-control-request-headers", "access-control-request-method", "allow", "authorization", "cache-control", "content-disposition", "content-encoding", "content-language", "content-length", "content-location", "content-range", "content-type", "cookie", "date", "etag", "expect", "expires", "from", "host", "if-match", "if-modified-since", "if-none-match", "if-unmodified-since", "last-modified", "link", "location", "max-forwards", "origin", "proxy-authenticate", "proxy-authorization", "range", "referer", "refresh", "retry-after", "server", "set-cookie", "strict-transport-security", "trailer", "transfer-encoding", "user-agent", "vary", "via", "www-authenticate", "x-forwarded-for", "x-forwarded-proto", } commonLowerHeader = make(map[string]string, len(common)) commonCanonHeader = make(map[string]string, len(common)) for _, v := range common { chk := http.CanonicalHeaderKey(v) commonLowerHeader[chk] = v commonCanonHeader[v] = chk } } func lowerHeader(v string) (lower string, ascii bool) { buildCommonHeaderMapsOnce() if s, ok := commonLowerHeader[v]; ok { return s, true } return asciiToLower(v) } func canonicalHeader(v string) string { buildCommonHeaderMapsOnce() if s, ok := commonCanonHeader[v]; ok { return s } return http.CanonicalHeaderKey(v) }	2.15 KB	2025-05-25 12:27
📁 hpack	-	2025-05-25 12:27
📄 http2.go // Copyright 2014 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Package http2 implements the HTTP/2 protocol. // // This package is low-level and intended to be used directly by very // few people. Most users will use it indirectly through the automatic // use by the net/http package (from Go 1.6 and later). // For use in earlier Go versions see ConfigureServer. (Transport support // requires Go 1.6 or later) // // See https://http2.github.io/ for more information on HTTP/2. // // See https://http2.golang.org/ for a test server running this code. package http2 // import "golang.org/x/net/http2" import ( "bufio" "context" "crypto/tls" "errors" "fmt" "net" "net/http" "os" "sort" "strconv" "strings" "sync" "time" "golang.org/x/net/http/httpguts" ) var ( VerboseLogs bool logFrameWrites bool logFrameReads bool inTests bool disableExtendedConnectProtocol bool ) func init() { e := os.Getenv("GODEBUG") if strings.Contains(e, "http2debug=1") { VerboseLogs = true } if strings.Contains(e, "http2debug=2") { VerboseLogs = true logFrameWrites = true logFrameReads = true } if strings.Contains(e, "http2xconnect=0") { disableExtendedConnectProtocol = true } } const ( // ClientPreface is the string that must be sent by new // connections from clients. ClientPreface = "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n" // SETTINGS_MAX_FRAME_SIZE default // https://httpwg.org/specs/rfc7540.html#rfc.section.6.5.2 initialMaxFrameSize = 16384 // NextProtoTLS is the NPN/ALPN protocol negotiated during // HTTP/2's TLS setup. NextProtoTLS = "h2" // https://httpwg.org/specs/rfc7540.html#SettingValues initialHeaderTableSize = 4096 initialWindowSize = 65535 // 6.9.2 Initial Flow Control Window Size defaultMaxReadFrameSize = 1 << 20 ) var ( clientPreface = []byte(ClientPreface) ) type streamState int // HTTP/2 stream states. // // See http://tools.ietf.org/html/rfc7540#section-5.1. // // For simplicity, the server code merges "reserved (local)" into // "half-closed (remote)". This is one less state transition to track. // The only downside is that we send PUSH_PROMISEs slightly less // liberally than allowable. More discussion here: // https://lists.w3.org/Archives/Public/ietf-http-wg/2016JulSep/0599.html // // "reserved (remote)" is omitted since the client code does not // support server push. const ( stateIdle streamState = iota stateOpen stateHalfClosedLocal stateHalfClosedRemote stateClosed ) var stateName = [...]string{ stateIdle: "Idle", stateOpen: "Open", stateHalfClosedLocal: "HalfClosedLocal", stateHalfClosedRemote: "HalfClosedRemote", stateClosed: "Closed", } func (st streamState) String() string { return stateName[st] } // Setting is a setting parameter: which setting it is, and its value. type Setting struct { // ID is which setting is being set. // See https://httpwg.org/specs/rfc7540.html#SettingFormat ID SettingID // Val is the value. Val uint32 } func (s Setting) String() string { return fmt.Sprintf("[%v = %d]", s.ID, s.Val) } // Valid reports whether the setting is valid. func (s Setting) Valid() error { // Limits and error codes from 6.5.2 Defined SETTINGS Parameters switch s.ID { case SettingEnablePush: if s.Val != 1 && s.Val != 0 { return ConnectionError(ErrCodeProtocol) } case SettingInitialWindowSize: if s.Val > 1<<31-1 { return ConnectionError(ErrCodeFlowControl) } case SettingMaxFrameSize: if s.Val < 16384 \|\| s.Val > 1<<24-1 { return ConnectionError(ErrCodeProtocol) } case SettingEnableConnectProtocol: if s.Val != 1 && s.Val != 0 { return ConnectionError(ErrCodeProtocol) } } return nil } // A SettingID is an HTTP/2 setting as defined in // https://httpwg.org/specs/rfc7540.html#iana-settings type SettingID uint16 const ( SettingHeaderTableSize SettingID = 0x1 SettingEnablePush SettingID = 0x2 SettingMaxConcurrentStreams SettingID = 0x3 SettingInitialWindowSize SettingID = 0x4 SettingMaxFrameSize SettingID = 0x5 SettingMaxHeaderListSize SettingID = 0x6 SettingEnableConnectProtocol SettingID = 0x8 ) var settingName = map[SettingID]string{ SettingHeaderTableSize: "HEADER_TABLE_SIZE", SettingEnablePush: "ENABLE_PUSH", SettingMaxConcurrentStreams: "MAX_CONCURRENT_STREAMS", SettingInitialWindowSize: "INITIAL_WINDOW_SIZE", SettingMaxFrameSize: "MAX_FRAME_SIZE", SettingMaxHeaderListSize: "MAX_HEADER_LIST_SIZE", SettingEnableConnectProtocol: "ENABLE_CONNECT_PROTOCOL", } func (s SettingID) String() string { if v, ok := settingName[s]; ok { return v } return fmt.Sprintf("UNKNOWN_SETTING_%d", uint16(s)) } // validWireHeaderFieldName reports whether v is a valid header field // name (key). See httpguts.ValidHeaderName for the base rules. // // Further, http2 says: // // "Just as in HTTP/1.x, header field names are strings of ASCII // characters that are compared in a case-insensitive // fashion. However, header field names MUST be converted to // lowercase prior to their encoding in HTTP/2. " func validWireHeaderFieldName(v string) bool { if len(v) == 0 { return false } for _, r := range v { if !httpguts.IsTokenRune(r) { return false } if 'A' <= r && r <= 'Z' { return false } } return true } func httpCodeString(code int) string { switch code { case 200: return "200" case 404: return "404" } return strconv.Itoa(code) } // from pkg io type stringWriter interface { WriteString(s string) (n int, err error) } // A closeWaiter is like a sync.WaitGroup but only goes 1 to 0 (open to closed). type closeWaiter chan struct{} // Init makes a closeWaiter usable. // It exists because so a closeWaiter value can be placed inside a // larger struct and have the Mutex and Cond's memory in the same // allocation. func (cw closeWaiter) Init() { cw = make(chan struct{}) } // Close marks the closeWaiter as closed and unblocks any waiters. func (cw closeWaiter) Close() { close(cw) } // Wait waits for the closeWaiter to become closed. func (cw closeWaiter) Wait() { <-cw } // bufferedWriter is a buffered writer that writes to w. // Its buffered writer is lazily allocated as needed, to minimize // idle memory usage with many connections. type bufferedWriter struct { _ incomparable group synctestGroupInterface // immutable conn net.Conn // immutable bw bufio.Writer // non-nil when data is buffered byteTimeout time.Duration // immutable, WriteByteTimeout } func newBufferedWriter(group synctestGroupInterface, conn net.Conn, timeout time.Duration) bufferedWriter { return &bufferedWriter{ group: group, conn: conn, byteTimeout: timeout, } } // bufWriterPoolBufferSize is the size of bufio.Writer's // buffers created using bufWriterPool. // // TODO: pick a less arbitrary value? this is a bit under // (3 x typical 1500 byte MTU) at least. Other than that, // not much thought went into it. const bufWriterPoolBufferSize = 4 << 10 var bufWriterPool = sync.Pool{ New: func() interface{} { return bufio.NewWriterSize(nil, bufWriterPoolBufferSize) }, } func (w bufferedWriter) Available() int { if w.bw == nil { return bufWriterPoolBufferSize } return w.bw.Available() } func (w bufferedWriter) Write(p []byte) (n int, err error) { if w.bw == nil { bw := bufWriterPool.Get().(bufio.Writer) bw.Reset((bufferedWriterTimeoutWriter)(w)) w.bw = bw } return w.bw.Write(p) } func (w bufferedWriter) Flush() error { bw := w.bw if bw == nil { return nil } err := bw.Flush() bw.Reset(nil) bufWriterPool.Put(bw) w.bw = nil return err } type bufferedWriterTimeoutWriter bufferedWriter func (w bufferedWriterTimeoutWriter) Write(p []byte) (n int, err error) { return writeWithByteTimeout(w.group, w.conn, w.byteTimeout, p) } // writeWithByteTimeout writes to conn. // If more than timeout passes without any bytes being written to the connection, // the write fails. func writeWithByteTimeout(group synctestGroupInterface, conn net.Conn, timeout time.Duration, p []byte) (n int, err error) { if timeout <= 0 { return conn.Write(p) } for { var now time.Time if group == nil { now = time.Now() } else { now = group.Now() } conn.SetWriteDeadline(now.Add(timeout)) nn, err := conn.Write(p[n:]) n += nn if n == len(p) \|\| nn == 0 \|\| !errors.Is(err, os.ErrDeadlineExceeded) { // Either we finished the write, made no progress, or hit the deadline. // Whichever it is, we're done now. conn.SetWriteDeadline(time.Time{}) return n, err } } } func mustUint31(v int32) uint32 { if v < 0 \|\| v > 2147483647 { panic("out of range") } return uint32(v) } // bodyAllowedForStatus reports whether a given response status code // permits a body. See RFC 7230, section 3.3. func bodyAllowedForStatus(status int) bool { switch { case status >= 100 && status <= 199: return false case status == 204: return false case status == 304: return false } return true } type httpError struct { _ incomparable msg string timeout bool } func (e httpError) Error() string { return e.msg } func (e httpError) Timeout() bool { return e.timeout } func (e httpError) Temporary() bool { return true } var errTimeout error = &httpError{msg: "http2: timeout awaiting response headers", timeout: true} type connectionStater interface { ConnectionState() tls.ConnectionState } var sorterPool = sync.Pool{New: func() interface{} { return new(sorter) }} type sorter struct { v []string // owned by sorter } func (s sorter) Len() int { return len(s.v) } func (s sorter) Swap(i, j int) { s.v[i], s.v[j] = s.v[j], s.v[i] } func (s sorter) Less(i, j int) bool { return s.v[i] < s.v[j] } // Keys returns the sorted keys of h. // // The returned slice is only valid until s used again or returned to // its pool. func (s sorter) Keys(h http.Header) []string { keys := s.v[:0] for k := range h { keys = append(keys, k) } s.v = keys sort.Sort(s) return keys } func (s sorter) SortStrings(ss []string) { // Our sorter works on s.v, which sorter owns, so // stash it away while we sort the user's buffer. save := s.v s.v = ss sort.Sort(s) s.v = save } // validPseudoPath reports whether v is a valid :path pseudo-header // value. It must be either: // // - a non-empty string starting with '/' // - the string '', for OPTIONS requests. // // For now this is only used a quick check for deciding when to clean // up Opaque URLs before sending requests from the Transport. // See golang.org/issue/16847 // // We used to enforce that the path also didn't start with "//", but // Google's GFE accepts such paths and Chrome sends them, so ignore // that part of the spec. See golang.org/issue/19103. func validPseudoPath(v string) bool { return (len(v) > 0 && v[0] == '/') \|\| v == "" } // incomparable is a zero-width, non-comparable type. Adding it to a struct // makes that struct also non-comparable, and generally doesn't add // any size (as long as it's first). type incomparable [0]func() // synctestGroupInterface is the methods of synctestGroup used by Server and Transport. // It's defined as an interface here to let us keep synctestGroup entirely test-only // and not a part of non-test builds. type synctestGroupInterface interface { Join() Now() time.Time NewTimer(d time.Duration) timer AfterFunc(d time.Duration, f func()) timer ContextWithTimeout(ctx context.Context, d time.Duration) (context.Context, context.CancelFunc) }	11.49 KB	2025-05-25 12:27
📄 http2_test.go // Copyright 2014 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import ( "bytes" "flag" "fmt" "net/http" "os" "path/filepath" "regexp" "strings" "testing" "time" "golang.org/x/net/http2/hpack" ) var knownFailing = flag.Bool("known_failing", false, "Run known-failing tests.") func condSkipFailingTest(t testing.T) { if !knownFailing { t.Skip("Skipping known-failing test without --known_failing") } } func init() { inTests = true DebugGoroutines = true flag.BoolVar(&VerboseLogs, "verboseh2", VerboseLogs, "Verbose HTTP/2 debug logging") } func TestSettingString(t testing.T) { tests := []struct { s Setting want string }{ {Setting{SettingMaxFrameSize, 123}, "[MAX_FRAME_SIZE = 123]"}, {Setting{1<<16 - 1, 123}, "[UNKNOWN_SETTING_65535 = 123]"}, } for i, tt := range tests { got := fmt.Sprint(tt.s) if got != tt.want { t.Errorf("%d. for %#v, string = %q; want %q", i, tt.s, got, tt.want) } } } type twriter struct { t testing.TB st serverTester // optional } func (w twriter) Write(p []byte) (n int, err error) { if w.st != nil { ps := string(p) for _, phrase := range w.st.logFilter { if strings.Contains(ps, phrase) { return len(p), nil // no logging } } } w.t.Logf("%s", p) return len(p), nil } // like encodeHeader, but don't add implicit pseudo headers. func encodeHeaderNoImplicit(t testing.T, headers ...string) []byte { var buf bytes.Buffer enc := hpack.NewEncoder(&buf) for len(headers) > 0 { k, v := headers[0], headers[1] headers = headers[2:] if err := enc.WriteField(hpack.HeaderField{Name: k, Value: v}); err != nil { t.Fatalf("HPACK encoding error for %q/%q: %v", k, v, err) } } return buf.Bytes() } type puppetCommand struct { fn func(w http.ResponseWriter, r http.Request) done chan<- bool } type handlerPuppet struct { ch chan puppetCommand } func newHandlerPuppet() handlerPuppet { return &handlerPuppet{ ch: make(chan puppetCommand), } } func (p handlerPuppet) act(w http.ResponseWriter, r http.Request) { for cmd := range p.ch { cmd.fn(w, r) cmd.done <- true } } func (p handlerPuppet) done() { close(p.ch) } func (p handlerPuppet) do(fn func(http.ResponseWriter, http.Request)) { done := make(chan bool) p.ch <- puppetCommand{fn, done} <-done } func cleanDate(res http.Response) { if d := res.Header["Date"]; len(d) == 1 { d[0] = "XXX" } } func TestSorterPoolAllocs(t testing.T) { ss := []string{"a", "b", "c"} h := http.Header{ "a": nil, "b": nil, "c": nil, } sorter := new(sorter) if allocs := testing.AllocsPerRun(100, func() { sorter.SortStrings(ss) }); allocs >= 1 { t.Logf("SortStrings allocs = %v; want <1", allocs) } if allocs := testing.AllocsPerRun(5, func() { if len(sorter.Keys(h)) != 3 { t.Fatal("wrong result") } }); allocs > 0 { t.Logf("Keys allocs = %v; want <1", allocs) } } // waitCondition reports whether fn eventually returned true, // checking immediately and then every checkEvery amount, // until waitFor has elapsed, at which point it returns false. func waitCondition(waitFor, checkEvery time.Duration, fn func() bool) bool { deadline := time.Now().Add(waitFor) for time.Now().Before(deadline) { if fn() { return true } time.Sleep(checkEvery) } return false } // waitErrCondition is like waitCondition but with errors instead of bools. func waitErrCondition(waitFor, checkEvery time.Duration, fn func() error) error { deadline := time.Now().Add(waitFor) var err error for time.Now().Before(deadline) { if err = fn(); err == nil { return nil } time.Sleep(checkEvery) } return err } func equalError(a, b error) bool { if a == nil { return b == nil } if b == nil { return a == nil } return a.Error() == b.Error() } // Tests that http2.Server.IdleTimeout is initialized from // http.Server.{Idle,Read}Timeout. http.Server.IdleTimeout was // added in Go 1.8. func TestConfigureServerIdleTimeout_Go18(t testing.T) { const timeout = 5 time.Second const notThisOne = 1 * time.Second // With a zero http2.Server, verify that it copies IdleTimeout: { s1 := &http.Server{ IdleTimeout: timeout, ReadTimeout: notThisOne, } s2 := &Server{} if err := ConfigureServer(s1, s2); err != nil { t.Fatal(err) } if s2.IdleTimeout != timeout { t.Errorf("s2.IdleTimeout = %v; want %v", s2.IdleTimeout, timeout) } } // And that it falls back to ReadTimeout: { s1 := &http.Server{ ReadTimeout: timeout, } s2 := &Server{} if err := ConfigureServer(s1, s2); err != nil { t.Fatal(err) } if s2.IdleTimeout != timeout { t.Errorf("s2.IdleTimeout = %v; want %v", s2.IdleTimeout, timeout) } } // Verify that s1's IdleTimeout doesn't overwrite an existing setting: { s1 := &http.Server{ IdleTimeout: notThisOne, } s2 := &Server{ IdleTimeout: timeout, } if err := ConfigureServer(s1, s2); err != nil { t.Fatal(err) } if s2.IdleTimeout != timeout { t.Errorf("s2.IdleTimeout = %v; want %v", s2.IdleTimeout, timeout) } } } var forbiddenStringsFunctions = map[string]bool{ // Functions that use Unicode-aware case folding. "EqualFold": true, "Title": true, "ToLower": true, "ToLowerSpecial": true, "ToTitle": true, "ToTitleSpecial": true, "ToUpper": true, "ToUpperSpecial": true, // Functions that use Unicode-aware spaces. "Fields": true, "TrimSpace": true, } // TestNoUnicodeStrings checks that nothing in net/http uses the Unicode-aware // strings and bytes package functions. HTTP is mostly ASCII based, and doing // Unicode-aware case folding or space stripping can introduce vulnerabilities. func TestNoUnicodeStrings(t *testing.T) { re := regexp.MustCompile(`(strings\|bytes).([A-Za-z]+)`) if err := filepath.Walk(".", func(path string, info os.FileInfo, err error) error { if err != nil { t.Fatal(err) } if path == "h2i" \|\| path == "h2c" { return filepath.SkipDir } if !strings.HasSuffix(path, ".go") \|\| strings.HasSuffix(path, "_test.go") \|\| path == "ascii.go" \|\| info.IsDir() { return nil } contents, err := os.ReadFile(path) if err != nil { t.Fatal(err) } for lineNum, line := range strings.Split(string(contents), "\n") { for _, match := range re.FindAllStringSubmatch(line, -1) { if !forbiddenStringsFunctions[match[2]] { continue } t.Errorf("disallowed call to %s at %s:%d", match[0], path, lineNum+1) } } return nil }); err != nil { t.Fatal(err) } } // must returns v if err is nil, or panics otherwise. func must[T any](v T, err error) T { if err != nil { panic(err) } return v }	6.59 KB	2025-05-25 12:27
📄 netconn_test.go // Copyright 2024 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import ( "bytes" "context" "errors" "io" "math" "net" "net/netip" "os" "sync" "time" ) // synctestNetPipe creates an in-memory, full duplex network connection. // Read and write timeouts are managed by the synctest group. // // Unlike net.Pipe, the connection is not synchronous. // Writes are made to a buffer, and return immediately. // By default, the buffer size is unlimited. func synctestNetPipe(group synctestGroup) (r, w synctestNetConn) { s1addr := net.TCPAddrFromAddrPort(netip.MustParseAddrPort("127.0.0.1:8000")) s2addr := net.TCPAddrFromAddrPort(netip.MustParseAddrPort("127.0.0.1:8001")) s1 := newSynctestNetConnHalf(s1addr) s2 := newSynctestNetConnHalf(s2addr) r = &synctestNetConn{group: group, loc: s1, rem: s2} w = &synctestNetConn{group: group, loc: s2, rem: s1} r.peer = w w.peer = r return r, w } // A synctestNetConn is one endpoint of the connection created by synctestNetPipe. type synctestNetConn struct { group synctestGroup // local and remote connection halves. // Each half contains a buffer. // Reads pull from the local buffer, and writes push to the remote buffer. loc, rem synctestNetConnHalf // When set, group.Wait is automatically called before reads and after writes. autoWait bool // peer is the other endpoint. peer synctestNetConn } // Read reads data from the connection. func (c synctestNetConn) Read(b []byte) (n int, err error) { if c.autoWait { c.group.Wait() } return c.loc.read(b) } // Peek returns the available unread read buffer, // without consuming its contents. func (c synctestNetConn) Peek() []byte { if c.autoWait { c.group.Wait() } return c.loc.peek() } // Write writes data to the connection. func (c synctestNetConn) Write(b []byte) (n int, err error) { if c.autoWait { defer c.group.Wait() } return c.rem.write(b) } // IsClosed reports whether the peer has closed its end of the connection. func (c synctestNetConn) IsClosedByPeer() bool { if c.autoWait { c.group.Wait() } return c.loc.isClosedByPeer() } // Close closes the connection. func (c synctestNetConn) Close() error { c.loc.setWriteError(errors.New("connection closed by peer")) c.rem.setReadError(io.EOF) if c.autoWait { c.group.Wait() } return nil } // LocalAddr returns the (fake) local network address. func (c synctestNetConn) LocalAddr() net.Addr { return c.loc.addr } // LocalAddr returns the (fake) remote network address. func (c synctestNetConn) RemoteAddr() net.Addr { return c.rem.addr } // SetDeadline sets the read and write deadlines for the connection. func (c synctestNetConn) SetDeadline(t time.Time) error { c.SetReadDeadline(t) c.SetWriteDeadline(t) return nil } // SetReadDeadline sets the read deadline for the connection. func (c synctestNetConn) SetReadDeadline(t time.Time) error { c.loc.rctx.setDeadline(c.group, t) return nil } // SetWriteDeadline sets the write deadline for the connection. func (c synctestNetConn) SetWriteDeadline(t time.Time) error { c.rem.wctx.setDeadline(c.group, t) return nil } // SetReadBufferSize sets the read buffer limit for the connection. // Writes by the peer will block so long as the buffer is full. func (c synctestNetConn) SetReadBufferSize(size int) { c.loc.setReadBufferSize(size) } // synctestNetConnHalf is one data flow in the connection created by synctestNetPipe. // Each half contains a buffer. Writes to the half push to the buffer, and reads pull from it. type synctestNetConnHalf struct { addr net.Addr // Read and write timeouts. rctx, wctx deadlineContext // A half can be readable and/or writable. // // These four channels act as a lock, // and allow waiting for readability/writability. // When the half is unlocked, exactly one channel contains a value. // When the half is locked, all channels are empty. lockr chan struct{} // readable lockw chan struct{} // writable lockrw chan struct{} // readable and writable lockc chan struct{} // neither readable nor writable bufMax int // maximum buffer size buf bytes.Buffer readErr error // error returned by reads writeErr error // error returned by writes } func newSynctestNetConnHalf(addr net.Addr) synctestNetConnHalf { h := &synctestNetConnHalf{ addr: addr, lockw: make(chan struct{}, 1), lockr: make(chan struct{}, 1), lockrw: make(chan struct{}, 1), lockc: make(chan struct{}, 1), bufMax: math.MaxInt, // unlimited } h.unlock() return h } func (h synctestNetConnHalf) lock() { select { case <-h.lockw: case <-h.lockr: case <-h.lockrw: case <-h.lockc: } } func (h synctestNetConnHalf) unlock() { canRead := h.readErr != nil \|\| h.buf.Len() > 0 canWrite := h.writeErr != nil \|\| h.bufMax > h.buf.Len() switch { case canRead && canWrite: h.lockrw <- struct{}{} case canRead: h.lockr <- struct{}{} case canWrite: h.lockw <- struct{}{} default: h.lockc <- struct{}{} } } func (h synctestNetConnHalf) readWaitAndLock() error { select { case <-h.lockr: return nil case <-h.lockrw: return nil default: } ctx := h.rctx.context() select { case <-h.lockr: return nil case <-h.lockrw: return nil case <-ctx.Done(): return context.Cause(ctx) } } func (h synctestNetConnHalf) writeWaitAndLock() error { select { case <-h.lockw: return nil case <-h.lockrw: return nil default: } ctx := h.wctx.context() select { case <-h.lockw: return nil case <-h.lockrw: return nil case <-ctx.Done(): return context.Cause(ctx) } } func (h synctestNetConnHalf) peek() []byte { h.lock() defer h.unlock() return h.buf.Bytes() } func (h synctestNetConnHalf) isClosedByPeer() bool { h.lock() defer h.unlock() return h.readErr != nil } func (h synctestNetConnHalf) read(b []byte) (n int, err error) { if err := h.readWaitAndLock(); err != nil { return 0, err } defer h.unlock() if h.buf.Len() == 0 && h.readErr != nil { return 0, h.readErr } return h.buf.Read(b) } func (h synctestNetConnHalf) setReadBufferSize(size int) { h.lock() defer h.unlock() h.bufMax = size } func (h synctestNetConnHalf) write(b []byte) (n int, err error) { for n < len(b) { nn, err := h.writePartial(b[n:]) n += nn if err != nil { return n, err } } return n, nil } func (h synctestNetConnHalf) writePartial(b []byte) (n int, err error) { if err := h.writeWaitAndLock(); err != nil { return 0, err } defer h.unlock() if h.writeErr != nil { return 0, h.writeErr } writeMax := h.bufMax - h.buf.Len() if writeMax < len(b) { b = b[:writeMax] } return h.buf.Write(b) } func (h synctestNetConnHalf) setReadError(err error) { h.lock() defer h.unlock() if h.readErr == nil { h.readErr = err } } func (h synctestNetConnHalf) setWriteError(err error) { h.lock() defer h.unlock() if h.writeErr == nil { h.writeErr = err } } // deadlineContext converts a changable deadline (as in net.Conn.SetDeadline) into a Context. type deadlineContext struct { mu sync.Mutex ctx context.Context cancel context.CancelCauseFunc timer timer } // context returns a Context which expires when the deadline does. func (t deadlineContext) context() context.Context { t.mu.Lock() defer t.mu.Unlock() if t.ctx == nil { t.ctx, t.cancel = context.WithCancelCause(context.Background()) } return t.ctx } // setDeadline sets the current deadline. func (t deadlineContext) setDeadline(group synctestGroup, deadline time.Time) { t.mu.Lock() defer t.mu.Unlock() // If t.ctx is non-nil and t.cancel is nil, then t.ctx was canceled // and we should create a new one. if t.ctx == nil \|\| t.cancel == nil { t.ctx, t.cancel = context.WithCancelCause(context.Background()) } // Stop any existing deadline from expiring. if t.timer != nil { t.timer.Stop() } if deadline.IsZero() { // No deadline. return } if !deadline.After(group.Now()) { // Deadline has already expired. t.cancel(os.ErrDeadlineExceeded) t.cancel = nil return } if t.timer != nil { // Reuse existing deadline timer. t.timer.Reset(deadline.Sub(group.Now())) return } // Create a new timer to cancel the context at the deadline. t.timer = group.AfterFunc(deadline.Sub(group.Now()), func() { t.mu.Lock() defer t.mu.Unlock() t.cancel(os.ErrDeadlineExceeded) t.cancel = nil }) }	8.24 KB	2025-05-25 12:27
📄 pipe.go // Copyright 2014 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import ( "errors" "io" "sync" ) // pipe is a goroutine-safe io.Reader/io.Writer pair. It's like // io.Pipe except there are no PipeReader/PipeWriter halves, and the // underlying buffer is an interface. (io.Pipe is always unbuffered) type pipe struct { mu sync.Mutex c sync.Cond // c.L lazily initialized to &p.mu b pipeBuffer // nil when done reading unread int // bytes unread when done err error // read error once empty. non-nil means closed. breakErr error // immediate read error (caller doesn't see rest of b) donec chan struct{} // closed on error readFn func() // optional code to run in Read before error } type pipeBuffer interface { Len() int io.Writer io.Reader } // setBuffer initializes the pipe buffer. // It has no effect if the pipe is already closed. func (p pipe) setBuffer(b pipeBuffer) { p.mu.Lock() defer p.mu.Unlock() if p.err != nil \|\| p.breakErr != nil { return } p.b = b } func (p pipe) Len() int { p.mu.Lock() defer p.mu.Unlock() if p.b == nil { return p.unread } return p.b.Len() } // Read waits until data is available and copies bytes // from the buffer into p. func (p pipe) Read(d []byte) (n int, err error) { p.mu.Lock() defer p.mu.Unlock() if p.c.L == nil { p.c.L = &p.mu } for { if p.breakErr != nil { return 0, p.breakErr } if p.b != nil && p.b.Len() > 0 { return p.b.Read(d) } if p.err != nil { if p.readFn != nil { p.readFn() // e.g. copy trailers p.readFn = nil // not sticky like p.err } p.b = nil return 0, p.err } p.c.Wait() } } var ( errClosedPipeWrite = errors.New("write on closed buffer") errUninitializedPipeWrite = errors.New("write on uninitialized buffer") ) // Write copies bytes from p into the buffer and wakes a reader. // It is an error to write more data than the buffer can hold. func (p pipe) Write(d []byte) (n int, err error) { p.mu.Lock() defer p.mu.Unlock() if p.c.L == nil { p.c.L = &p.mu } defer p.c.Signal() if p.err != nil \|\| p.breakErr != nil { return 0, errClosedPipeWrite } // pipe.setBuffer is never invoked, leaving the buffer uninitialized. // We shouldn't try to write to an uninitialized pipe, // but returning an error is better than panicking. if p.b == nil { return 0, errUninitializedPipeWrite } return p.b.Write(d) } // CloseWithError causes the next Read (waking up a current blocked // Read if needed) to return the provided err after all data has been // read. // // The error must be non-nil. func (p pipe) CloseWithError(err error) { p.closeWithError(&p.err, err, nil) } // BreakWithError causes the next Read (waking up a current blocked // Read if needed) to return the provided err immediately, without // waiting for unread data. func (p pipe) BreakWithError(err error) { p.closeWithError(&p.breakErr, err, nil) } // closeWithErrorAndCode is like CloseWithError but also sets some code to run // in the caller's goroutine before returning the error. func (p pipe) closeWithErrorAndCode(err error, fn func()) { p.closeWithError(&p.err, err, fn) } func (p pipe) closeWithError(dst error, err error, fn func()) { if err == nil { panic("err must be non-nil") } p.mu.Lock() defer p.mu.Unlock() if p.c.L == nil { p.c.L = &p.mu } defer p.c.Signal() if dst != nil { // Already been done. return } p.readFn = fn if dst == &p.breakErr { if p.b != nil { p.unread += p.b.Len() } p.b = nil } dst = err p.closeDoneLocked() } // requires p.mu be held. func (p pipe) closeDoneLocked() { if p.donec == nil { return } // Close if unclosed. This isn't racy since we always // hold p.mu while closing. select { case <-p.donec: default: close(p.donec) } } // Err returns the error (if any) first set by BreakWithError or CloseWithError. func (p pipe) Err() error { p.mu.Lock() defer p.mu.Unlock() if p.breakErr != nil { return p.breakErr } return p.err } // Done returns a channel which is closed if and when this pipe is closed // with CloseWithError. func (p pipe) Done() <-chan struct{} { p.mu.Lock() defer p.mu.Unlock() if p.donec == nil { p.donec = make(chan struct{}) if p.err != nil \|\| p.breakErr != nil { // Already hit an error. p.closeDoneLocked() } } return p.donec }	4.39 KB	2025-05-25 12:27
📄 pipe_test.go // Copyright 2014 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import ( "bytes" "errors" "io" "testing" ) func TestPipeClose(t testing.T) { var p pipe p.b = new(bytes.Buffer) a := errors.New("a") b := errors.New("b") p.CloseWithError(a) p.CloseWithError(b) _, err := p.Read(make([]byte, 1)) if err != a { t.Errorf("err = %v want %v", err, a) } } func TestPipeDoneChan(t testing.T) { var p pipe done := p.Done() select { case <-done: t.Fatal("done too soon") default: } p.CloseWithError(io.EOF) select { case <-done: default: t.Fatal("should be done") } } func TestPipeDoneChan_ErrFirst(t testing.T) { var p pipe p.CloseWithError(io.EOF) done := p.Done() select { case <-done: default: t.Fatal("should be done") } } func TestPipeDoneChan_Break(t testing.T) { var p pipe done := p.Done() select { case <-done: t.Fatal("done too soon") default: } p.BreakWithError(io.EOF) select { case <-done: default: t.Fatal("should be done") } } func TestPipeDoneChan_Break_ErrFirst(t testing.T) { var p pipe p.BreakWithError(io.EOF) done := p.Done() select { case <-done: default: t.Fatal("should be done") } } func TestPipeCloseWithError(t testing.T) { p := &pipe{b: new(bytes.Buffer)} const body = "foo" io.WriteString(p, body) a := errors.New("test error") p.CloseWithError(a) all, err := io.ReadAll(p) if string(all) != body { t.Errorf("read bytes = %q; want %q", all, body) } if err != a { t.Logf("read error = %v, %v", err, a) } if p.Len() != 0 { t.Errorf("pipe should have 0 unread bytes") } // Read and Write should fail. if n, err := p.Write([]byte("abc")); err != errClosedPipeWrite \|\| n != 0 { t.Errorf("Write(abc) after close\ngot %v, %v\nwant 0, %v", n, err, errClosedPipeWrite) } if n, err := p.Read(make([]byte, 1)); err == nil \|\| n != 0 { t.Errorf("Read() after close\ngot %v, nil\nwant 0, %v", n, errClosedPipeWrite) } if p.Len() != 0 { t.Errorf("pipe should have 0 unread bytes") } } func TestPipeBreakWithError(t *testing.T) { p := &pipe{b: new(bytes.Buffer)} io.WriteString(p, "foo") a := errors.New("test err") p.BreakWithError(a) all, err := io.ReadAll(p) if string(all) != "" { t.Errorf("read bytes = %q; want empty string", all) } if err != a { t.Logf("read error = %v, %v", err, a) } if p.b != nil { t.Errorf("buffer should be nil after BreakWithError") } if p.Len() != 3 { t.Errorf("pipe should have 3 unread bytes") } // Write should fail. if n, err := p.Write([]byte("abc")); err != errClosedPipeWrite \|\| n != 0 { t.Errorf("Write(abc) after break\ngot %v, %v\nwant 0, errClosedPipeWrite", n, err) } if p.b != nil { t.Errorf("buffer should be nil after Write") } if p.Len() != 3 { t.Errorf("pipe should have 6 unread bytes") } // Read should fail. if n, err := p.Read(make([]byte, 1)); err == nil \|\| n != 0 { t.Errorf("Read() after close\ngot %v, nil\nwant 0, not nil", n) } }	2.98 KB	2025-05-25 12:27
📄 server.go // Copyright 2014 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // TODO: turn off the serve goroutine when idle, so // an idle conn only has the readFrames goroutine active. (which could // also be optimized probably to pin less memory in crypto/tls). This // would involve tracking when the serve goroutine is active (atomic // int32 read/CAS probably?) and starting it up when frames arrive, // and shutting it down when all handlers exit. the occasional PING // packets could use time.AfterFunc to call sc.wakeStartServeLoop() // (which is a no-op if already running) and then queue the PING write // as normal. The serve loop would then exit in most cases (if no // Handlers running) and not be woken up again until the PING packet // returns. // TODO (maybe): add a mechanism for Handlers to going into // half-closed-local mode (rw.(io.Closer) test?) but not exit their // handler, and continue to be able to read from the // Request.Body. This would be a somewhat semantic change from HTTP/1 // (or at least what we expose in net/http), so I'd probably want to // add it there too. For now, this package says that returning from // the Handler ServeHTTP function means you're both done reading and // done writing, without a way to stop just one or the other. package http2 import ( "bufio" "bytes" "context" "crypto/rand" "crypto/tls" "errors" "fmt" "io" "log" "math" "net" "net/http" "net/textproto" "net/url" "os" "reflect" "runtime" "strconv" "strings" "sync" "time" "golang.org/x/net/http/httpguts" "golang.org/x/net/http2/hpack" ) const ( prefaceTimeout = 10 * time.Second firstSettingsTimeout = 2 * time.Second // should be in-flight with preface anyway handlerChunkWriteSize = 4 << 10 defaultMaxStreams = 250 // TODO: make this 100 as the GFE seems to? // maxQueuedControlFrames is the maximum number of control frames like // SETTINGS, PING and RST_STREAM that will be queued for writing before // the connection is closed to prevent memory exhaustion attacks. maxQueuedControlFrames = 10000 ) var ( errClientDisconnected = errors.New("client disconnected") errClosedBody = errors.New("body closed by handler") errHandlerComplete = errors.New("http2: request body closed due to handler exiting") errStreamClosed = errors.New("http2: stream closed") ) var responseWriterStatePool = sync.Pool{ New: func() interface{} { rws := &responseWriterState{} rws.bw = bufio.NewWriterSize(chunkWriter{rws}, handlerChunkWriteSize) return rws }, } // Test hooks. var ( testHookOnConn func() testHookGetServerConn func(serverConn) testHookOnPanicMu sync.Mutex // nil except in tests testHookOnPanic func(sc serverConn, panicVal interface{}) (rePanic bool) ) // Server is an HTTP/2 server. type Server struct { // MaxHandlers limits the number of http.Handler ServeHTTP goroutines // which may run at a time over all connections. // Negative or zero no limit. // TODO: implement MaxHandlers int // MaxConcurrentStreams optionally specifies the number of // concurrent streams that each client may have open at a // time. This is unrelated to the number of http.Handler goroutines // which may be active globally, which is MaxHandlers. // If zero, MaxConcurrentStreams defaults to at least 100, per // the HTTP/2 spec's recommendations. MaxConcurrentStreams uint32 // MaxDecoderHeaderTableSize optionally specifies the http2 // SETTINGS_HEADER_TABLE_SIZE to send in the initial settings frame. It // informs the remote endpoint of the maximum size of the header compression // table used to decode header blocks, in octets. If zero, the default value // of 4096 is used. MaxDecoderHeaderTableSize uint32 // MaxEncoderHeaderTableSize optionally specifies an upper limit for the // header compression table used for encoding request headers. Received // SETTINGS_HEADER_TABLE_SIZE settings are capped at this limit. If zero, // the default value of 4096 is used. MaxEncoderHeaderTableSize uint32 // MaxReadFrameSize optionally specifies the largest frame // this server is willing to read. A valid value is between // 16k and 16M, inclusive. If zero or otherwise invalid, a // default value is used. MaxReadFrameSize uint32 // PermitProhibitedCipherSuites, if true, permits the use of // cipher suites prohibited by the HTTP/2 spec. PermitProhibitedCipherSuites bool // IdleTimeout specifies how long until idle clients should be // closed with a GOAWAY frame. PING frames are not considered // activity for the purposes of IdleTimeout. // If zero or negative, there is no timeout. IdleTimeout time.Duration // ReadIdleTimeout is the timeout after which a health check using a ping // frame will be carried out if no frame is received on the connection. // If zero, no health check is performed. ReadIdleTimeout time.Duration // PingTimeout is the timeout after which the connection will be closed // if a response to a ping is not received. // If zero, a default of 15 seconds is used. PingTimeout time.Duration // WriteByteTimeout is the timeout after which a connection will be // closed if no data can be written to it. The timeout begins when data is // available to write, and is extended whenever any bytes are written. // If zero or negative, there is no timeout. WriteByteTimeout time.Duration // MaxUploadBufferPerConnection is the size of the initial flow // control window for each connections. The HTTP/2 spec does not // allow this to be smaller than 65535 or larger than 2^32-1. // If the value is outside this range, a default value will be // used instead. MaxUploadBufferPerConnection int32 // MaxUploadBufferPerStream is the size of the initial flow control // window for each stream. The HTTP/2 spec does not allow this to // be larger than 2^32-1. If the value is zero or larger than the // maximum, a default value will be used instead. MaxUploadBufferPerStream int32 // NewWriteScheduler constructs a write scheduler for a connection. // If nil, a default scheduler is chosen. NewWriteScheduler func() WriteScheduler // CountError, if non-nil, is called on HTTP/2 server errors. // It's intended to increment a metric for monitoring, such // as an expvar or Prometheus metric. // The errType consists of only ASCII word characters. CountError func(errType string) // Internal state. This is a pointer (rather than embedded directly) // so that we don't embed a Mutex in this struct, which will make the // struct non-copyable, which might break some callers. state serverInternalState // Synchronization group used for testing. // Outside of tests, this is nil. group synctestGroupInterface } func (s Server) markNewGoroutine() { if s.group != nil { s.group.Join() } } func (s Server) now() time.Time { if s.group != nil { return s.group.Now() } return time.Now() } // newTimer creates a new time.Timer, or a synthetic timer in tests. func (s Server) newTimer(d time.Duration) timer { if s.group != nil { return s.group.NewTimer(d) } return timeTimer{time.NewTimer(d)} } // afterFunc creates a new time.AfterFunc timer, or a synthetic timer in tests. func (s Server) afterFunc(d time.Duration, f func()) timer { if s.group != nil { return s.group.AfterFunc(d, f) } return timeTimer{time.AfterFunc(d, f)} } type serverInternalState struct { mu sync.Mutex activeConns map[serverConn]struct{} } func (s serverInternalState) registerConn(sc serverConn) { if s == nil { return // if the Server was used without calling ConfigureServer } s.mu.Lock() s.activeConns[sc] = struct{}{} s.mu.Unlock() } func (s serverInternalState) unregisterConn(sc serverConn) { if s == nil { return // if the Server was used without calling ConfigureServer } s.mu.Lock() delete(s.activeConns, sc) s.mu.Unlock() } func (s serverInternalState) startGracefulShutdown() { if s == nil { return // if the Server was used without calling ConfigureServer } s.mu.Lock() for sc := range s.activeConns { sc.startGracefulShutdown() } s.mu.Unlock() } // ConfigureServer adds HTTP/2 support to a net/http Server. // // The configuration conf may be nil. // // ConfigureServer must be called before s begins serving. func ConfigureServer(s http.Server, conf Server) error { if s == nil { panic("nil http.Server") } if conf == nil { conf = new(Server) } conf.state = &serverInternalState{activeConns: make(map[serverConn]struct{})} if h1, h2 := s, conf; h2.IdleTimeout == 0 { if h1.IdleTimeout != 0 { h2.IdleTimeout = h1.IdleTimeout } else { h2.IdleTimeout = h1.ReadTimeout } } s.RegisterOnShutdown(conf.state.startGracefulShutdown) if s.TLSConfig == nil { s.TLSConfig = new(tls.Config) } else if s.TLSConfig.CipherSuites != nil && s.TLSConfig.MinVersion < tls.VersionTLS13 { // If they already provided a TLS 1.0–1.2 CipherSuite list, return an // error if it is missing ECDHE_RSA_WITH_AES_128_GCM_SHA256 or // ECDHE_ECDSA_WITH_AES_128_GCM_SHA256. haveRequired := false for _, cs := range s.TLSConfig.CipherSuites { switch cs { case tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, // Alternative MTI cipher to not discourage ECDSA-only servers. // See http://golang.org/cl/30721 for further information. tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256: haveRequired = true } } if !haveRequired { return fmt.Errorf("http2: TLSConfig.CipherSuites is missing an HTTP/2-required AES_128_GCM_SHA256 cipher (need at least one of TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 or TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256)") } } // Note: not setting MinVersion to tls.VersionTLS12, // as we don't want to interfere with HTTP/1.1 traffic // on the user's server. We enforce TLS 1.2 later once // we accept a connection. Ideally this should be done // during next-proto selection, but using TLS <1.2 with // HTTP/2 is still the client's bug. s.TLSConfig.PreferServerCipherSuites = true if !strSliceContains(s.TLSConfig.NextProtos, NextProtoTLS) { s.TLSConfig.NextProtos = append(s.TLSConfig.NextProtos, NextProtoTLS) } if !strSliceContains(s.TLSConfig.NextProtos, "http/1.1") { s.TLSConfig.NextProtos = append(s.TLSConfig.NextProtos, "http/1.1") } if s.TLSNextProto == nil { s.TLSNextProto = map[string]func(http.Server, tls.Conn, http.Handler){} } protoHandler := func(hs http.Server, c net.Conn, h http.Handler, sawClientPreface bool) { if testHookOnConn != nil { testHookOnConn() } // The TLSNextProto interface predates contexts, so // the net/http package passes down its per-connection // base context via an exported but unadvertised // method on the Handler. This is for internal // net/http<=>http2 use only. var ctx context.Context type baseContexter interface { BaseContext() context.Context } if bc, ok := h.(baseContexter); ok { ctx = bc.BaseContext() } conf.ServeConn(c, &ServeConnOpts{ Context: ctx, Handler: h, BaseConfig: hs, SawClientPreface: sawClientPreface, }) } s.TLSNextProto[NextProtoTLS] = func(hs http.Server, c tls.Conn, h http.Handler) { protoHandler(hs, c, h, false) } // The "unencrypted_http2" TLSNextProto key is used to pass off non-TLS HTTP/2 conns. // // A connection passed in this method has already had the HTTP/2 preface read from it. s.TLSNextProto[nextProtoUnencryptedHTTP2] = func(hs http.Server, c tls.Conn, h http.Handler) { nc, err := unencryptedNetConnFromTLSConn(c) if err != nil { if lg := hs.ErrorLog; lg != nil { lg.Print(err) } else { log.Print(err) } go c.Close() return } protoHandler(hs, nc, h, true) } return nil } // ServeConnOpts are options for the Server.ServeConn method. type ServeConnOpts struct { // Context is the base context to use. // If nil, context.Background is used. Context context.Context // BaseConfig optionally sets the base configuration // for values. If nil, defaults are used. BaseConfig http.Server // Handler specifies which handler to use for processing // requests. If nil, BaseConfig.Handler is used. If BaseConfig // or BaseConfig.Handler is nil, http.DefaultServeMux is used. Handler http.Handler // UpgradeRequest is an initial request received on a connection // undergoing an h2c upgrade. The request body must have been // completely read from the connection before calling ServeConn, // and the 101 Switching Protocols response written. UpgradeRequest http.Request // Settings is the decoded contents of the HTTP2-Settings header // in an h2c upgrade request. Settings []byte // SawClientPreface is set if the HTTP/2 connection preface // has already been read from the connection. SawClientPreface bool } func (o ServeConnOpts) context() context.Context { if o != nil && o.Context != nil { return o.Context } return context.Background() } func (o ServeConnOpts) baseConfig() http.Server { if o != nil && o.BaseConfig != nil { return o.BaseConfig } return new(http.Server) } func (o ServeConnOpts) handler() http.Handler { if o != nil { if o.Handler != nil { return o.Handler } if o.BaseConfig != nil && o.BaseConfig.Handler != nil { return o.BaseConfig.Handler } } return http.DefaultServeMux } // ServeConn serves HTTP/2 requests on the provided connection and // blocks until the connection is no longer readable. // // ServeConn starts speaking HTTP/2 assuming that c has not had any // reads or writes. It writes its initial settings frame and expects // to be able to read the preface and settings frame from the // client. If c has a ConnectionState method like a tls.Conn, the // ConnectionState is used to verify the TLS ciphersuite and to set // the Request.TLS field in Handlers. // // ServeConn does not support h2c by itself. Any h2c support must be // implemented in terms of providing a suitably-behaving net.Conn. // // The opts parameter is optional. If nil, default values are used. func (s Server) ServeConn(c net.Conn, opts ServeConnOpts) { s.serveConn(c, opts, nil) } func (s Server) serveConn(c net.Conn, opts ServeConnOpts, newf func(serverConn)) { baseCtx, cancel := serverConnBaseContext(c, opts) defer cancel() http1srv := opts.baseConfig() conf := configFromServer(http1srv, s) sc := &serverConn{ srv: s, hs: http1srv, conn: c, baseCtx: baseCtx, remoteAddrStr: c.RemoteAddr().String(), bw: newBufferedWriter(s.group, c, conf.WriteByteTimeout), handler: opts.handler(), streams: make(map[uint32]stream), readFrameCh: make(chan readFrameResult), wantWriteFrameCh: make(chan FrameWriteRequest, 8), serveMsgCh: make(chan interface{}, 8), wroteFrameCh: make(chan frameWriteResult, 1), // buffered; one send in writeFrameAsync bodyReadCh: make(chan bodyReadMsg), // buffering doesn't matter either way doneServing: make(chan struct{}), clientMaxStreams: math.MaxUint32, // Section 6.5.2: "Initially, there is no limit to this value" advMaxStreams: conf.MaxConcurrentStreams, initialStreamSendWindowSize: initialWindowSize, initialStreamRecvWindowSize: conf.MaxUploadBufferPerStream, maxFrameSize: initialMaxFrameSize, pingTimeout: conf.PingTimeout, countErrorFunc: conf.CountError, serveG: newGoroutineLock(), pushEnabled: true, sawClientPreface: opts.SawClientPreface, } if newf != nil { newf(sc) } s.state.registerConn(sc) defer s.state.unregisterConn(sc) // The net/http package sets the write deadline from the // http.Server.WriteTimeout during the TLS handshake, but then // passes the connection off to us with the deadline already set. // Write deadlines are set per stream in serverConn.newStream. // Disarm the net.Conn write deadline here. if sc.hs.WriteTimeout > 0 { sc.conn.SetWriteDeadline(time.Time{}) } if s.NewWriteScheduler != nil { sc.writeSched = s.NewWriteScheduler() } else { sc.writeSched = newRoundRobinWriteScheduler() } // These start at the RFC-specified defaults. If there is a higher // configured value for inflow, that will be updated when we send a // WINDOW_UPDATE shortly after sending SETTINGS. sc.flow.add(initialWindowSize) sc.inflow.init(initialWindowSize) sc.hpackEncoder = hpack.NewEncoder(&sc.headerWriteBuf) sc.hpackEncoder.SetMaxDynamicTableSizeLimit(conf.MaxEncoderHeaderTableSize) fr := NewFramer(sc.bw, c) if conf.CountError != nil { fr.countError = conf.CountError } fr.ReadMetaHeaders = hpack.NewDecoder(conf.MaxDecoderHeaderTableSize, nil) fr.MaxHeaderListSize = sc.maxHeaderListSize() fr.SetMaxReadFrameSize(conf.MaxReadFrameSize) sc.framer = fr if tc, ok := c.(connectionStater); ok { sc.tlsState = new(tls.ConnectionState) sc.tlsState = tc.ConnectionState() // 9.2 Use of TLS Features // An implementation of HTTP/2 over TLS MUST use TLS // 1.2 or higher with the restrictions on feature set // and cipher suite described in this section. Due to // implementation limitations, it might not be // possible to fail TLS negotiation. An endpoint MUST // immediately terminate an HTTP/2 connection that // does not meet the TLS requirements described in // this section with a connection error (Section // 5.4.1) of type INADEQUATE_SECURITY. if sc.tlsState.Version < tls.VersionTLS12 { sc.rejectConn(ErrCodeInadequateSecurity, "TLS version too low") return } if sc.tlsState.ServerName == "" { // Client must use SNI, but we don't enforce that anymore, // since it was causing problems when connecting to bare IP // addresses during development. // // TODO: optionally enforce? Or enforce at the time we receive // a new request, and verify the ServerName matches the :authority? // But that precludes proxy situations, perhaps. // // So for now, do nothing here again. } if !conf.PermitProhibitedCipherSuites && isBadCipher(sc.tlsState.CipherSuite) { // "Endpoints MAY choose to generate a connection error // (Section 5.4.1) of type INADEQUATE_SECURITY if one of // the prohibited cipher suites are negotiated." // // We choose that. In my opinion, the spec is weak // here. It also says both parties must support at least // TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 so there's no // excuses here. If we really must, we could allow an // "AllowInsecureWeakCiphers" option on the server later. // Let's see how it plays out first. sc.rejectConn(ErrCodeInadequateSecurity, fmt.Sprintf("Prohibited TLS 1.2 Cipher Suite: %x", sc.tlsState.CipherSuite)) return } } if opts.Settings != nil { fr := &SettingsFrame{ FrameHeader: FrameHeader{valid: true}, p: opts.Settings, } if err := fr.ForeachSetting(sc.processSetting); err != nil { sc.rejectConn(ErrCodeProtocol, "invalid settings") return } opts.Settings = nil } if hook := testHookGetServerConn; hook != nil { hook(sc) } if opts.UpgradeRequest != nil { sc.upgradeRequest(opts.UpgradeRequest) opts.UpgradeRequest = nil } sc.serve(conf) } func serverConnBaseContext(c net.Conn, opts ServeConnOpts) (ctx context.Context, cancel func()) { ctx, cancel = context.WithCancel(opts.context()) ctx = context.WithValue(ctx, http.LocalAddrContextKey, c.LocalAddr()) if hs := opts.baseConfig(); hs != nil { ctx = context.WithValue(ctx, http.ServerContextKey, hs) } return } func (sc serverConn) rejectConn(err ErrCode, debug string) { sc.vlogf("http2: server rejecting conn: %v, %s", err, debug) // ignoring errors. hanging up anyway. sc.framer.WriteGoAway(0, err, []byte(debug)) sc.bw.Flush() sc.conn.Close() } type serverConn struct { // Immutable: srv Server hs http.Server conn net.Conn bw bufferedWriter // writing to conn handler http.Handler baseCtx context.Context framer Framer doneServing chan struct{} // closed when serverConn.serve ends readFrameCh chan readFrameResult // written by serverConn.readFrames wantWriteFrameCh chan FrameWriteRequest // from handlers -> serve wroteFrameCh chan frameWriteResult // from writeFrameAsync -> serve, tickles more frame writes bodyReadCh chan bodyReadMsg // from handlers -> serve serveMsgCh chan interface{} // misc messages & code to send to / run on the serve loop flow outflow // conn-wide (not stream-specific) outbound flow control inflow inflow // conn-wide inbound flow control tlsState tls.ConnectionState // shared by all handlers, like net/http remoteAddrStr string writeSched WriteScheduler countErrorFunc func(errType string) // Everything following is owned by the serve loop; use serveG.check(): serveG goroutineLock // used to verify funcs are on serve() pushEnabled bool sawClientPreface bool // preface has already been read, used in h2c upgrade sawFirstSettings bool // got the initial SETTINGS frame after the preface needToSendSettingsAck bool unackedSettings int // how many SETTINGS have we sent without ACKs? queuedControlFrames int // control frames in the writeSched queue clientMaxStreams uint32 // SETTINGS_MAX_CONCURRENT_STREAMS from client (our PUSH_PROMISE limit) advMaxStreams uint32 // our SETTINGS_MAX_CONCURRENT_STREAMS advertised the client curClientStreams uint32 // number of open streams initiated by the client curPushedStreams uint32 // number of open streams initiated by server push curHandlers uint32 // number of running handler goroutines maxClientStreamID uint32 // max ever seen from client (odd), or 0 if there have been no client requests maxPushPromiseID uint32 // ID of the last push promise (even), or 0 if there have been no pushes streams map[uint32]stream unstartedHandlers []unstartedHandler initialStreamSendWindowSize int32 initialStreamRecvWindowSize int32 maxFrameSize int32 peerMaxHeaderListSize uint32 // zero means unknown (default) canonHeader map[string]string // http2-lower-case -> Go-Canonical-Case canonHeaderKeysSize int // canonHeader keys size in bytes writingFrame bool // started writing a frame (on serve goroutine or separate) writingFrameAsync bool // started a frame on its own goroutine but haven't heard back on wroteFrameCh needsFrameFlush bool // last frame write wasn't a flush inGoAway bool // we've started to or sent GOAWAY inFrameScheduleLoop bool // whether we're in the scheduleFrameWrite loop needToSendGoAway bool // we need to schedule a GOAWAY frame write pingSent bool sentPingData [8]byte goAwayCode ErrCode shutdownTimer timer // nil until used idleTimer timer // nil if unused readIdleTimeout time.Duration pingTimeout time.Duration readIdleTimer timer // nil if unused // Owned by the writeFrameAsync goroutine: headerWriteBuf bytes.Buffer hpackEncoder hpack.Encoder // Used by startGracefulShutdown. shutdownOnce sync.Once } func (sc serverConn) maxHeaderListSize() uint32 { n := sc.hs.MaxHeaderBytes if n <= 0 { n = http.DefaultMaxHeaderBytes } return uint32(adjustHTTP1MaxHeaderSize(int64(n))) } func (sc serverConn) curOpenStreams() uint32 { sc.serveG.check() return sc.curClientStreams + sc.curPushedStreams } // stream represents a stream. This is the minimal metadata needed by // the serve goroutine. Most of the actual stream state is owned by // the http.Handler's goroutine in the responseWriter. Because the // responseWriter's responseWriterState is recycled at the end of a // handler, this struct intentionally has no pointer to the // responseWriter{,State} itself, as the Handler ending nils out the // responseWriter's state field. type stream struct { // immutable: sc serverConn id uint32 body pipe // non-nil if expecting DATA frames cw closeWaiter // closed wait stream transitions to closed state ctx context.Context cancelCtx func() // owned by serverConn's serve loop: bodyBytes int64 // body bytes seen so far declBodyBytes int64 // or -1 if undeclared flow outflow // limits writing from Handler to client inflow inflow // what the client is allowed to POST/etc to us state streamState resetQueued bool // RST_STREAM queued for write; set by sc.resetStream gotTrailerHeader bool // HEADER frame for trailers was seen wroteHeaders bool // whether we wrote headers (not status 100) readDeadline timer // nil if unused writeDeadline timer // nil if unused closeErr error // set before cw is closed trailer http.Header // accumulated trailers reqTrailer http.Header // handler's Request.Trailer } func (sc serverConn) Framer() Framer { return sc.framer } func (sc serverConn) CloseConn() error { return sc.conn.Close() } func (sc serverConn) Flush() error { return sc.bw.Flush() } func (sc serverConn) HeaderEncoder() (hpack.Encoder, bytes.Buffer) { return sc.hpackEncoder, &sc.headerWriteBuf } func (sc serverConn) state(streamID uint32) (streamState, stream) { sc.serveG.check() // http://tools.ietf.org/html/rfc7540#section-5.1 if st, ok := sc.streams[streamID]; ok { return st.state, st } // "The first use of a new stream identifier implicitly closes all // streams in the "idle" state that might have been initiated by // that peer with a lower-valued stream identifier. For example, if // a client sends a HEADERS frame on stream 7 without ever sending a // frame on stream 5, then stream 5 transitions to the "closed" // state when the first frame for stream 7 is sent or received." if streamID%2 == 1 { if streamID <= sc.maxClientStreamID { return stateClosed, nil } } else { if streamID <= sc.maxPushPromiseID { return stateClosed, nil } } return stateIdle, nil } // setConnState calls the net/http ConnState hook for this connection, if configured. // Note that the net/http package does StateNew and StateClosed for us. // There is currently no plan for StateHijacked or hijacking HTTP/2 connections. func (sc serverConn) setConnState(state http.ConnState) { if sc.hs.ConnState != nil { sc.hs.ConnState(sc.conn, state) } } func (sc serverConn) vlogf(format string, args ...interface{}) { if VerboseLogs { sc.logf(format, args...) } } func (sc serverConn) logf(format string, args ...interface{}) { if lg := sc.hs.ErrorLog; lg != nil { lg.Printf(format, args...) } else { log.Printf(format, args...) } } // errno returns v's underlying uintptr, else 0. // // TODO: remove this helper function once http2 can use build // tags. See comment in isClosedConnError. func errno(v error) uintptr { if rv := reflect.ValueOf(v); rv.Kind() == reflect.Uintptr { return uintptr(rv.Uint()) } return 0 } // isClosedConnError reports whether err is an error from use of a closed // network connection. func isClosedConnError(err error) bool { if err == nil { return false } if errors.Is(err, net.ErrClosed) { return true } // TODO(bradfitz): x/tools/cmd/bundle doesn't really support // build tags, so I can't make an http2_windows.go file with // Windows-specific stuff. Fix that and move this, once we // have a way to bundle this into std's net/http somehow. if runtime.GOOS == "windows" { if oe, ok := err.(net.OpError); ok && oe.Op == "read" { if se, ok := oe.Err.(os.SyscallError); ok && se.Syscall == "wsarecv" { const WSAECONNABORTED = 10053 const WSAECONNRESET = 10054 if n := errno(se.Err); n == WSAECONNRESET \|\| n == WSAECONNABORTED { return true } } } } return false } func (sc serverConn) condlogf(err error, format string, args ...interface{}) { if err == nil { return } if err == io.EOF \|\| err == io.ErrUnexpectedEOF \|\| isClosedConnError(err) \|\| err == errPrefaceTimeout { // Boring, expected errors. sc.vlogf(format, args...) } else { sc.logf(format, args...) } } // maxCachedCanonicalHeadersKeysSize is an arbitrarily-chosen limit on the size // of the entries in the canonHeader cache. // This should be larger than the size of unique, uncommon header keys likely to // be sent by the peer, while not so high as to permit unreasonable memory usage // if the peer sends an unbounded number of unique header keys. const maxCachedCanonicalHeadersKeysSize = 2048 func (sc serverConn) canonicalHeader(v string) string { sc.serveG.check() buildCommonHeaderMapsOnce() cv, ok := commonCanonHeader[v] if ok { return cv } cv, ok = sc.canonHeader[v] if ok { return cv } if sc.canonHeader == nil { sc.canonHeader = make(map[string]string) } cv = http.CanonicalHeaderKey(v) size := 100 + len(v)2 // 100 bytes of map overhead + key + value if sc.canonHeaderKeysSize+size <= maxCachedCanonicalHeadersKeysSize { sc.canonHeader[v] = cv sc.canonHeaderKeysSize += size } return cv } type readFrameResult struct { f Frame // valid until readMore is called err error // readMore should be called once the consumer no longer needs or // retains f. After readMore, f is invalid and more frames can be // read. readMore func() } // readFrames is the loop that reads incoming frames. // It takes care to only read one frame at a time, blocking until the // consumer is done with the frame. // It's run on its own goroutine. func (sc serverConn) readFrames() { sc.srv.markNewGoroutine() gate := make(chan struct{}) gateDone := func() { gate <- struct{}{} } for { f, err := sc.framer.ReadFrame() select { case sc.readFrameCh <- readFrameResult{f, err, gateDone}: case <-sc.doneServing: return } select { case <-gate: case <-sc.doneServing: return } if terminalReadFrameError(err) { return } } } // frameWriteResult is the message passed from writeFrameAsync to the serve goroutine. type frameWriteResult struct { _ incomparable wr FrameWriteRequest // what was written (or attempted) err error // result of the writeFrame call } // writeFrameAsync runs in its own goroutine and writes a single frame // and then reports when it's done. // At most one goroutine can be running writeFrameAsync at a time per // serverConn. func (sc serverConn) writeFrameAsync(wr FrameWriteRequest, wd writeData) { sc.srv.markNewGoroutine() var err error if wd == nil { err = wr.write.writeFrame(sc) } else { err = sc.framer.endWrite() } sc.wroteFrameCh <- frameWriteResult{wr: wr, err: err} } func (sc serverConn) closeAllStreamsOnConnClose() { sc.serveG.check() for _, st := range sc.streams { sc.closeStream(st, errClientDisconnected) } } func (sc serverConn) stopShutdownTimer() { sc.serveG.check() if t := sc.shutdownTimer; t != nil { t.Stop() } } func (sc serverConn) notePanic() { // Note: this is for serverConn.serve panicking, not http.Handler code. if testHookOnPanicMu != nil { testHookOnPanicMu.Lock() defer testHookOnPanicMu.Unlock() } if testHookOnPanic != nil { if e := recover(); e != nil { if testHookOnPanic(sc, e) { panic(e) } } } } func (sc serverConn) serve(conf http2Config) { sc.serveG.check() defer sc.notePanic() defer sc.conn.Close() defer sc.closeAllStreamsOnConnClose() defer sc.stopShutdownTimer() defer close(sc.doneServing) // unblocks handlers trying to send if VerboseLogs { sc.vlogf("http2: server connection from %v on %p", sc.conn.RemoteAddr(), sc.hs) } settings := writeSettings{ {SettingMaxFrameSize, conf.MaxReadFrameSize}, {SettingMaxConcurrentStreams, sc.advMaxStreams}, {SettingMaxHeaderListSize, sc.maxHeaderListSize()}, {SettingHeaderTableSize, conf.MaxDecoderHeaderTableSize}, {SettingInitialWindowSize, uint32(sc.initialStreamRecvWindowSize)}, } if !disableExtendedConnectProtocol { settings = append(settings, Setting{SettingEnableConnectProtocol, 1}) } sc.writeFrame(FrameWriteRequest{ write: settings, }) sc.unackedSettings++ // Each connection starts with initialWindowSize inflow tokens. // If a higher value is configured, we add more tokens. if diff := conf.MaxUploadBufferPerConnection - initialWindowSize; diff > 0 { sc.sendWindowUpdate(nil, int(diff)) } if err := sc.readPreface(); err != nil { sc.condlogf(err, "http2: server: error reading preface from client %v: %v", sc.conn.RemoteAddr(), err) return } // Now that we've got the preface, get us out of the // "StateNew" state. We can't go directly to idle, though. // Active means we read some data and anticipate a request. We'll // do another Active when we get a HEADERS frame. sc.setConnState(http.StateActive) sc.setConnState(http.StateIdle) if sc.srv.IdleTimeout > 0 { sc.idleTimer = sc.srv.afterFunc(sc.srv.IdleTimeout, sc.onIdleTimer) defer sc.idleTimer.Stop() } if conf.SendPingTimeout > 0 { sc.readIdleTimeout = conf.SendPingTimeout sc.readIdleTimer = sc.srv.afterFunc(conf.SendPingTimeout, sc.onReadIdleTimer) defer sc.readIdleTimer.Stop() } go sc.readFrames() // closed by defer sc.conn.Close above settingsTimer := sc.srv.afterFunc(firstSettingsTimeout, sc.onSettingsTimer) defer settingsTimer.Stop() lastFrameTime := sc.srv.now() loopNum := 0 for { loopNum++ select { case wr := <-sc.wantWriteFrameCh: if se, ok := wr.write.(StreamError); ok { sc.resetStream(se) break } sc.writeFrame(wr) case res := <-sc.wroteFrameCh: sc.wroteFrame(res) case res := <-sc.readFrameCh: lastFrameTime = sc.srv.now() // Process any written frames before reading new frames from the client since a // written frame could have triggered a new stream to be started. if sc.writingFrameAsync { select { case wroteRes := <-sc.wroteFrameCh: sc.wroteFrame(wroteRes) default: } } if !sc.processFrameFromReader(res) { return } res.readMore() if settingsTimer != nil { settingsTimer.Stop() settingsTimer = nil } case m := <-sc.bodyReadCh: sc.noteBodyRead(m.st, m.n) case msg := <-sc.serveMsgCh: switch v := msg.(type) { case func(int): v(loopNum) // for testing case serverMessage: switch v { case settingsTimerMsg: sc.logf("timeout waiting for SETTINGS frames from %v", sc.conn.RemoteAddr()) return case idleTimerMsg: sc.vlogf("connection is idle") sc.goAway(ErrCodeNo) case readIdleTimerMsg: sc.handlePingTimer(lastFrameTime) case shutdownTimerMsg: sc.vlogf("GOAWAY close timer fired; closing conn from %v", sc.conn.RemoteAddr()) return case gracefulShutdownMsg: sc.startGracefulShutdownInternal() case handlerDoneMsg: sc.handlerDone() default: panic("unknown timer") } case startPushRequest: sc.startPush(v) case func(serverConn): v(sc) default: panic(fmt.Sprintf("unexpected type %T", v)) } } // If the peer is causing us to generate a lot of control frames, // but not reading them from us, assume they are trying to make us // run out of memory. if sc.queuedControlFrames > maxQueuedControlFrames { sc.vlogf("http2: too many control frames in send queue, closing connection") return } // Start the shutdown timer after sending a GOAWAY. When sending GOAWAY // with no error code (graceful shutdown), don't start the timer until // all open streams have been completed. sentGoAway := sc.inGoAway && !sc.needToSendGoAway && !sc.writingFrame gracefulShutdownComplete := sc.goAwayCode == ErrCodeNo && sc.curOpenStreams() == 0 if sentGoAway && sc.shutdownTimer == nil && (sc.goAwayCode != ErrCodeNo \|\| gracefulShutdownComplete) { sc.shutDownIn(goAwayTimeout) } } } func (sc serverConn) handlePingTimer(lastFrameReadTime time.Time) { if sc.pingSent { sc.vlogf("timeout waiting for PING response") sc.conn.Close() return } pingAt := lastFrameReadTime.Add(sc.readIdleTimeout) now := sc.srv.now() if pingAt.After(now) { // We received frames since arming the ping timer. // Reset it for the next possible timeout. sc.readIdleTimer.Reset(pingAt.Sub(now)) return } sc.pingSent = true // Ignore crypto/rand.Read errors: It generally can't fail, and worse case if it does // is we send a PING frame containing 0s. _, _ = rand.Read(sc.sentPingData[:]) sc.writeFrame(FrameWriteRequest{ write: &writePing{data: sc.sentPingData}, }) sc.readIdleTimer.Reset(sc.pingTimeout) } type serverMessage int // Message values sent to serveMsgCh. var ( settingsTimerMsg = new(serverMessage) idleTimerMsg = new(serverMessage) readIdleTimerMsg = new(serverMessage) shutdownTimerMsg = new(serverMessage) gracefulShutdownMsg = new(serverMessage) handlerDoneMsg = new(serverMessage) ) func (sc serverConn) onSettingsTimer() { sc.sendServeMsg(settingsTimerMsg) } func (sc serverConn) onIdleTimer() { sc.sendServeMsg(idleTimerMsg) } func (sc serverConn) onReadIdleTimer() { sc.sendServeMsg(readIdleTimerMsg) } func (sc serverConn) onShutdownTimer() { sc.sendServeMsg(shutdownTimerMsg) } func (sc serverConn) sendServeMsg(msg interface{}) { sc.serveG.checkNotOn() // NOT select { case sc.serveMsgCh <- msg: case <-sc.doneServing: } } var errPrefaceTimeout = errors.New("timeout waiting for client preface") // readPreface reads the ClientPreface greeting from the peer or // returns errPrefaceTimeout on timeout, or an error if the greeting // is invalid. func (sc serverConn) readPreface() error { if sc.sawClientPreface { return nil } errc := make(chan error, 1) go func() { // Read the client preface buf := make([]byte, len(ClientPreface)) if _, err := io.ReadFull(sc.conn, buf); err != nil { errc <- err } else if !bytes.Equal(buf, clientPreface) { errc <- fmt.Errorf("bogus greeting %q", buf) } else { errc <- nil } }() timer := sc.srv.newTimer(prefaceTimeout) // TODO: configurable on Server? defer timer.Stop() select { case <-timer.C(): return errPrefaceTimeout case err := <-errc: if err == nil { if VerboseLogs { sc.vlogf("http2: server: client %v said hello", sc.conn.RemoteAddr()) } } return err } } var errChanPool = sync.Pool{ New: func() interface{} { return make(chan error, 1) }, } var writeDataPool = sync.Pool{ New: func() interface{} { return new(writeData) }, } // writeDataFromHandler writes DATA response frames from a handler on // the given stream. func (sc serverConn) writeDataFromHandler(stream stream, data []byte, endStream bool) error { ch := errChanPool.Get().(chan error) writeArg := writeDataPool.Get().(writeData) writeArg = writeData{stream.id, data, endStream} err := sc.writeFrameFromHandler(FrameWriteRequest{ write: writeArg, stream: stream, done: ch, }) if err != nil { return err } var frameWriteDone bool // the frame write is done (successfully or not) select { case err = <-ch: frameWriteDone = true case <-sc.doneServing: return errClientDisconnected case <-stream.cw: // If both ch and stream.cw were ready (as might // happen on the final Write after an http.Handler // ends), prefer the write result. Otherwise this // might just be us successfully closing the stream. // The writeFrameAsync and serve goroutines guarantee // that the ch send will happen before the stream.cw // close. select { case err = <-ch: frameWriteDone = true default: return errStreamClosed } } errChanPool.Put(ch) if frameWriteDone { writeDataPool.Put(writeArg) } return err } // writeFrameFromHandler sends wr to sc.wantWriteFrameCh, but aborts // if the connection has gone away. // // This must not be run from the serve goroutine itself, else it might // deadlock writing to sc.wantWriteFrameCh (which is only mildly // buffered and is read by serve itself). If you're on the serve // goroutine, call writeFrame instead. func (sc serverConn) writeFrameFromHandler(wr FrameWriteRequest) error { sc.serveG.checkNotOn() // NOT select { case sc.wantWriteFrameCh <- wr: return nil case <-sc.doneServing: // Serve loop is gone. // Client has closed their connection to the server. return errClientDisconnected } } // writeFrame schedules a frame to write and sends it if there's nothing // already being written. // // There is no pushback here (the serve goroutine never blocks). It's // the http.Handlers that block, waiting for their previous frames to // make it onto the wire // // If you're not on the serve goroutine, use writeFrameFromHandler instead. func (sc serverConn) writeFrame(wr FrameWriteRequest) { sc.serveG.check() // If true, wr will not be written and wr.done will not be signaled. var ignoreWrite bool // We are not allowed to write frames on closed streams. RFC 7540 Section // 5.1.1 says: "An endpoint MUST NOT send frames other than PRIORITY on // a closed stream." Our server never sends PRIORITY, so that exception // does not apply. // // The serverConn might close an open stream while the stream's handler // is still running. For example, the server might close a stream when it // receives bad data from the client. If this happens, the handler might // attempt to write a frame after the stream has been closed (since the // handler hasn't yet been notified of the close). In this case, we simply // ignore the frame. The handler will notice that the stream is closed when // it waits for the frame to be written. // // As an exception to this rule, we allow sending RST_STREAM after close. // This allows us to immediately reject new streams without tracking any // state for those streams (except for the queued RST_STREAM frame). This // may result in duplicate RST_STREAMs in some cases, but the client should // ignore those. if wr.StreamID() != 0 { _, isReset := wr.write.(StreamError) if state, _ := sc.state(wr.StreamID()); state == stateClosed && !isReset { ignoreWrite = true } } // Don't send a 100-continue response if we've already sent headers. // See golang.org/issue/14030. switch wr.write.(type) { case writeResHeaders: wr.stream.wroteHeaders = true case write100ContinueHeadersFrame: if wr.stream.wroteHeaders { // We do not need to notify wr.done because this frame is // never written with wr.done != nil. if wr.done != nil { panic("wr.done != nil for write100ContinueHeadersFrame") } ignoreWrite = true } } if !ignoreWrite { if wr.isControl() { sc.queuedControlFrames++ // For extra safety, detect wraparounds, which should not happen, // and pull the plug. if sc.queuedControlFrames < 0 { sc.conn.Close() } } sc.writeSched.Push(wr) } sc.scheduleFrameWrite() } // startFrameWrite starts a goroutine to write wr (in a separate // goroutine since that might block on the network), and updates the // serve goroutine's state about the world, updated from info in wr. func (sc serverConn) startFrameWrite(wr FrameWriteRequest) { sc.serveG.check() if sc.writingFrame { panic("internal error: can only be writing one frame at a time") } st := wr.stream if st != nil { switch st.state { case stateHalfClosedLocal: switch wr.write.(type) { case StreamError, handlerPanicRST, writeWindowUpdate: // RFC 7540 Section 5.1 allows sending RST_STREAM, PRIORITY, and WINDOW_UPDATE // in this state. (We never send PRIORITY from the server, so that is not checked.) default: panic(fmt.Sprintf("internal error: attempt to send frame on a half-closed-local stream: %v", wr)) } case stateClosed: panic(fmt.Sprintf("internal error: attempt to send frame on a closed stream: %v", wr)) } } if wpp, ok := wr.write.(writePushPromise); ok { var err error wpp.promisedID, err = wpp.allocatePromisedID() if err != nil { sc.writingFrameAsync = false wr.replyToWriter(err) return } } sc.writingFrame = true sc.needsFrameFlush = true if wr.write.staysWithinBuffer(sc.bw.Available()) { sc.writingFrameAsync = false err := wr.write.writeFrame(sc) sc.wroteFrame(frameWriteResult{wr: wr, err: err}) } else if wd, ok := wr.write.(writeData); ok { // Encode the frame in the serve goroutine, to ensure we don't have // any lingering asynchronous references to data passed to Write. // See https://go.dev/issue/58446. sc.framer.startWriteDataPadded(wd.streamID, wd.endStream, wd.p, nil) sc.writingFrameAsync = true go sc.writeFrameAsync(wr, wd) } else { sc.writingFrameAsync = true go sc.writeFrameAsync(wr, nil) } } // errHandlerPanicked is the error given to any callers blocked in a read from // Request.Body when the main goroutine panics. Since most handlers read in the // main ServeHTTP goroutine, this will show up rarely. var errHandlerPanicked = errors.New("http2: handler panicked") // wroteFrame is called on the serve goroutine with the result of // whatever happened on writeFrameAsync. func (sc serverConn) wroteFrame(res frameWriteResult) { sc.serveG.check() if !sc.writingFrame { panic("internal error: expected to be already writing a frame") } sc.writingFrame = false sc.writingFrameAsync = false if res.err != nil { sc.conn.Close() } wr := res.wr if writeEndsStream(wr.write) { st := wr.stream if st == nil { panic("internal error: expecting non-nil stream") } switch st.state { case stateOpen: // Here we would go to stateHalfClosedLocal in // theory, but since our handler is done and // the net/http package provides no mechanism // for closing a ResponseWriter while still // reading data (see possible TODO at top of // this file), we go into closed state here // anyway, after telling the peer we're // hanging up on them. We'll transition to // stateClosed after the RST_STREAM frame is // written. st.state = stateHalfClosedLocal // Section 8.1: a server MAY request that the client abort // transmission of a request without error by sending a // RST_STREAM with an error code of NO_ERROR after sending // a complete response. sc.resetStream(streamError(st.id, ErrCodeNo)) case stateHalfClosedRemote: sc.closeStream(st, errHandlerComplete) } } else { switch v := wr.write.(type) { case StreamError: // st may be unknown if the RST_STREAM was generated to reject bad input. if st, ok := sc.streams[v.StreamID]; ok { sc.closeStream(st, v) } case handlerPanicRST: sc.closeStream(wr.stream, errHandlerPanicked) } } // Reply (if requested) to unblock the ServeHTTP goroutine. wr.replyToWriter(res.err) sc.scheduleFrameWrite() } // scheduleFrameWrite tickles the frame writing scheduler. // // If a frame is already being written, nothing happens. This will be called again // when the frame is done being written. // // If a frame isn't being written and we need to send one, the best frame // to send is selected by writeSched. // // If a frame isn't being written and there's nothing else to send, we // flush the write buffer. func (sc serverConn) scheduleFrameWrite() { sc.serveG.check() if sc.writingFrame \|\| sc.inFrameScheduleLoop { return } sc.inFrameScheduleLoop = true for !sc.writingFrameAsync { if sc.needToSendGoAway { sc.needToSendGoAway = false sc.startFrameWrite(FrameWriteRequest{ write: &writeGoAway{ maxStreamID: sc.maxClientStreamID, code: sc.goAwayCode, }, }) continue } if sc.needToSendSettingsAck { sc.needToSendSettingsAck = false sc.startFrameWrite(FrameWriteRequest{write: writeSettingsAck{}}) continue } if !sc.inGoAway \|\| sc.goAwayCode == ErrCodeNo { if wr, ok := sc.writeSched.Pop(); ok { if wr.isControl() { sc.queuedControlFrames-- } sc.startFrameWrite(wr) continue } } if sc.needsFrameFlush { sc.startFrameWrite(FrameWriteRequest{write: flushFrameWriter{}}) sc.needsFrameFlush = false // after startFrameWrite, since it sets this true continue } break } sc.inFrameScheduleLoop = false } // startGracefulShutdown gracefully shuts down a connection. This // sends GOAWAY with ErrCodeNo to tell the client we're gracefully // shutting down. The connection isn't closed until all current // streams are done. // // startGracefulShutdown returns immediately; it does not wait until // the connection has shut down. func (sc serverConn) startGracefulShutdown() { sc.serveG.checkNotOn() // NOT sc.shutdownOnce.Do(func() { sc.sendServeMsg(gracefulShutdownMsg) }) } // After sending GOAWAY with an error code (non-graceful shutdown), the // connection will close after goAwayTimeout. // // If we close the connection immediately after sending GOAWAY, there may // be unsent data in our kernel receive buffer, which will cause the kernel // to send a TCP RST on close() instead of a FIN. This RST will abort the // connection immediately, whether or not the client had received the GOAWAY. // // Ideally we should delay for at least 1 RTT + epsilon so the client has // a chance to read the GOAWAY and stop sending messages. Measuring RTT // is hard, so we approximate with 1 second. See golang.org/issue/18701. // // This is a var so it can be shorter in tests, where all requests uses the // loopback interface making the expected RTT very small. // // TODO: configurable? var goAwayTimeout = 1 time.Second func (sc serverConn) startGracefulShutdownInternal() { sc.goAway(ErrCodeNo) } func (sc serverConn) goAway(code ErrCode) { sc.serveG.check() if sc.inGoAway { if sc.goAwayCode == ErrCodeNo { sc.goAwayCode = code } return } sc.inGoAway = true sc.needToSendGoAway = true sc.goAwayCode = code sc.scheduleFrameWrite() } func (sc serverConn) shutDownIn(d time.Duration) { sc.serveG.check() sc.shutdownTimer = sc.srv.afterFunc(d, sc.onShutdownTimer) } func (sc serverConn) resetStream(se StreamError) { sc.serveG.check() sc.writeFrame(FrameWriteRequest{write: se}) if st, ok := sc.streams[se.StreamID]; ok { st.resetQueued = true } } // processFrameFromReader processes the serve loop's read from readFrameCh from the // frame-reading goroutine. // processFrameFromReader returns whether the connection should be kept open. func (sc serverConn) processFrameFromReader(res readFrameResult) bool { sc.serveG.check() err := res.err if err != nil { if err == ErrFrameTooLarge { sc.goAway(ErrCodeFrameSize) return true // goAway will close the loop } clientGone := err == io.EOF \|\| err == io.ErrUnexpectedEOF \|\| isClosedConnError(err) if clientGone { // TODO: could we also get into this state if // the peer does a half close // (e.g. CloseWrite) because they're done // sending frames but they're still wanting // our open replies? Investigate. // TODO: add CloseWrite to crypto/tls.Conn first // so we have a way to test this? I suppose // just for testing we could have a non-TLS mode. return false } } else { f := res.f if VerboseLogs { sc.vlogf("http2: server read frame %v", summarizeFrame(f)) } err = sc.processFrame(f) if err == nil { return true } } switch ev := err.(type) { case StreamError: sc.resetStream(ev) return true case goAwayFlowError: sc.goAway(ErrCodeFlowControl) return true case ConnectionError: if res.f != nil { if id := res.f.Header().StreamID; id > sc.maxClientStreamID { sc.maxClientStreamID = id } } sc.logf("http2: server connection error from %v: %v", sc.conn.RemoteAddr(), ev) sc.goAway(ErrCode(ev)) return true // goAway will handle shutdown default: if res.err != nil { sc.vlogf("http2: server closing client connection; error reading frame from client %s: %v", sc.conn.RemoteAddr(), err) } else { sc.logf("http2: server closing client connection: %v", err) } return false } } func (sc serverConn) processFrame(f Frame) error { sc.serveG.check() // First frame received must be SETTINGS. if !sc.sawFirstSettings { if _, ok := f.(SettingsFrame); !ok { return sc.countError("first_settings", ConnectionError(ErrCodeProtocol)) } sc.sawFirstSettings = true } // Discard frames for streams initiated after the identified last // stream sent in a GOAWAY, or all frames after sending an error. // We still need to return connection-level flow control for DATA frames. // RFC 9113 Section 6.8. if sc.inGoAway && (sc.goAwayCode != ErrCodeNo \|\| f.Header().StreamID > sc.maxClientStreamID) { if f, ok := f.(DataFrame); ok { if !sc.inflow.take(f.Length) { return sc.countError("data_flow", streamError(f.Header().StreamID, ErrCodeFlowControl)) } sc.sendWindowUpdate(nil, int(f.Length)) // conn-level } return nil } switch f := f.(type) { case SettingsFrame: return sc.processSettings(f) case MetaHeadersFrame: return sc.processHeaders(f) case WindowUpdateFrame: return sc.processWindowUpdate(f) case PingFrame: return sc.processPing(f) case DataFrame: return sc.processData(f) case RSTStreamFrame: return sc.processResetStream(f) case PriorityFrame: return sc.processPriority(f) case GoAwayFrame: return sc.processGoAway(f) case PushPromiseFrame: // A client cannot push. Thus, servers MUST treat the receipt of a PUSH_PROMISE // frame as a connection error (Section 5.4.1) of type PROTOCOL_ERROR. return sc.countError("push_promise", ConnectionError(ErrCodeProtocol)) default: sc.vlogf("http2: server ignoring frame: %v", f.Header()) return nil } } func (sc serverConn) processPing(f PingFrame) error { sc.serveG.check() if f.IsAck() { if sc.pingSent && sc.sentPingData == f.Data { // This is a response to a PING we sent. sc.pingSent = false sc.readIdleTimer.Reset(sc.readIdleTimeout) } // 6.7 PING: " An endpoint MUST NOT respond to PING frames // containing this flag." return nil } if f.StreamID != 0 { // "PING frames are not associated with any individual // stream. If a PING frame is received with a stream // identifier field value other than 0x0, the recipient MUST // respond with a connection error (Section 5.4.1) of type // PROTOCOL_ERROR." return sc.countError("ping_on_stream", ConnectionError(ErrCodeProtocol)) } sc.writeFrame(FrameWriteRequest{write: writePingAck{f}}) return nil } func (sc serverConn) processWindowUpdate(f WindowUpdateFrame) error { sc.serveG.check() switch { case f.StreamID != 0: // stream-level flow control state, st := sc.state(f.StreamID) if state == stateIdle { // Section 5.1: "Receiving any frame other than HEADERS // or PRIORITY on a stream in this state MUST be // treated as a connection error (Section 5.4.1) of // type PROTOCOL_ERROR." return sc.countError("stream_idle", ConnectionError(ErrCodeProtocol)) } if st == nil { // "WINDOW_UPDATE can be sent by a peer that has sent a // frame bearing the END_STREAM flag. This means that a // receiver could receive a WINDOW_UPDATE frame on a "half // closed (remote)" or "closed" stream. A receiver MUST // NOT treat this as an error, see Section 5.1." return nil } if !st.flow.add(int32(f.Increment)) { return sc.countError("bad_flow", streamError(f.StreamID, ErrCodeFlowControl)) } default: // connection-level flow control if !sc.flow.add(int32(f.Increment)) { return goAwayFlowError{} } } sc.scheduleFrameWrite() return nil } func (sc serverConn) processResetStream(f RSTStreamFrame) error { sc.serveG.check() state, st := sc.state(f.StreamID) if state == stateIdle { // 6.4 "RST_STREAM frames MUST NOT be sent for a // stream in the "idle" state. If a RST_STREAM frame // identifying an idle stream is received, the // recipient MUST treat this as a connection error // (Section 5.4.1) of type PROTOCOL_ERROR. return sc.countError("reset_idle_stream", ConnectionError(ErrCodeProtocol)) } if st != nil { st.cancelCtx() sc.closeStream(st, streamError(f.StreamID, f.ErrCode)) } return nil } func (sc serverConn) closeStream(st stream, err error) { sc.serveG.check() if st.state == stateIdle \|\| st.state == stateClosed { panic(fmt.Sprintf("invariant; can't close stream in state %v", st.state)) } st.state = stateClosed if st.readDeadline != nil { st.readDeadline.Stop() } if st.writeDeadline != nil { st.writeDeadline.Stop() } if st.isPushed() { sc.curPushedStreams-- } else { sc.curClientStreams-- } delete(sc.streams, st.id) if len(sc.streams) == 0 { sc.setConnState(http.StateIdle) if sc.srv.IdleTimeout > 0 && sc.idleTimer != nil { sc.idleTimer.Reset(sc.srv.IdleTimeout) } if h1ServerKeepAlivesDisabled(sc.hs) { sc.startGracefulShutdownInternal() } } if p := st.body; p != nil { // Return any buffered unread bytes worth of conn-level flow control. // See golang.org/issue/16481 sc.sendWindowUpdate(nil, p.Len()) p.CloseWithError(err) } if e, ok := err.(StreamError); ok { if e.Cause != nil { err = e.Cause } else { err = errStreamClosed } } st.closeErr = err st.cancelCtx() st.cw.Close() // signals Handler's CloseNotifier, unblocks writes, etc sc.writeSched.CloseStream(st.id) } func (sc serverConn) processSettings(f SettingsFrame) error { sc.serveG.check() if f.IsAck() { sc.unackedSettings-- if sc.unackedSettings < 0 { // Why is the peer ACKing settings we never sent? // The spec doesn't mention this case, but // hang up on them anyway. return sc.countError("ack_mystery", ConnectionError(ErrCodeProtocol)) } return nil } if f.NumSettings() > 100 \|\| f.HasDuplicates() { // This isn't actually in the spec, but hang up on // suspiciously large settings frames or those with // duplicate entries. return sc.countError("settings_big_or_dups", ConnectionError(ErrCodeProtocol)) } if err := f.ForeachSetting(sc.processSetting); err != nil { return err } // TODO: judging by RFC 7540, Section 6.5.3 each SETTINGS frame should be // acknowledged individually, even if multiple are received before the ACK. sc.needToSendSettingsAck = true sc.scheduleFrameWrite() return nil } func (sc serverConn) processSetting(s Setting) error { sc.serveG.check() if err := s.Valid(); err != nil { return err } if VerboseLogs { sc.vlogf("http2: server processing setting %v", s) } switch s.ID { case SettingHeaderTableSize: sc.hpackEncoder.SetMaxDynamicTableSize(s.Val) case SettingEnablePush: sc.pushEnabled = s.Val != 0 case SettingMaxConcurrentStreams: sc.clientMaxStreams = s.Val case SettingInitialWindowSize: return sc.processSettingInitialWindowSize(s.Val) case SettingMaxFrameSize: sc.maxFrameSize = int32(s.Val) // the maximum valid s.Val is < 2^31 case SettingMaxHeaderListSize: sc.peerMaxHeaderListSize = s.Val case SettingEnableConnectProtocol: // Receipt of this parameter by a server does not // have any impact default: // Unknown setting: "An endpoint that receives a SETTINGS // frame with any unknown or unsupported identifier MUST // ignore that setting." if VerboseLogs { sc.vlogf("http2: server ignoring unknown setting %v", s) } } return nil } func (sc serverConn) processSettingInitialWindowSize(val uint32) error { sc.serveG.check() // Note: val already validated to be within range by // processSetting's Valid call. // "A SETTINGS frame can alter the initial flow control window // size for all current streams. When the value of // SETTINGS_INITIAL_WINDOW_SIZE changes, a receiver MUST // adjust the size of all stream flow control windows that it // maintains by the difference between the new value and the // old value." old := sc.initialStreamSendWindowSize sc.initialStreamSendWindowSize = int32(val) growth := int32(val) - old // may be negative for _, st := range sc.streams { if !st.flow.add(growth) { // 6.9.2 Initial Flow Control Window Size // "An endpoint MUST treat a change to // SETTINGS_INITIAL_WINDOW_SIZE that causes any flow // control window to exceed the maximum size as a // connection error (Section 5.4.1) of type // FLOW_CONTROL_ERROR." return sc.countError("setting_win_size", ConnectionError(ErrCodeFlowControl)) } } return nil } func (sc serverConn) processData(f DataFrame) error { sc.serveG.check() id := f.Header().StreamID data := f.Data() state, st := sc.state(id) if id == 0 \|\| state == stateIdle { // Section 6.1: "DATA frames MUST be associated with a // stream. If a DATA frame is received whose stream // identifier field is 0x0, the recipient MUST respond // with a connection error (Section 5.4.1) of type // PROTOCOL_ERROR." // // Section 5.1: "Receiving any frame other than HEADERS // or PRIORITY on a stream in this state MUST be // treated as a connection error (Section 5.4.1) of // type PROTOCOL_ERROR." return sc.countError("data_on_idle", ConnectionError(ErrCodeProtocol)) } // "If a DATA frame is received whose stream is not in "open" // or "half closed (local)" state, the recipient MUST respond // with a stream error (Section 5.4.2) of type STREAM_CLOSED." if st == nil \|\| state != stateOpen \|\| st.gotTrailerHeader \|\| st.resetQueued { // This includes sending a RST_STREAM if the stream is // in stateHalfClosedLocal (which currently means that // the http.Handler returned, so it's done reading & // done writing). Try to stop the client from sending // more DATA. // But still enforce their connection-level flow control, // and return any flow control bytes since we're not going // to consume them. if !sc.inflow.take(f.Length) { return sc.countError("data_flow", streamError(id, ErrCodeFlowControl)) } sc.sendWindowUpdate(nil, int(f.Length)) // conn-level if st != nil && st.resetQueued { // Already have a stream error in flight. Don't send another. return nil } return sc.countError("closed", streamError(id, ErrCodeStreamClosed)) } if st.body == nil { panic("internal error: should have a body in this state") } // Sender sending more than they'd declared? if st.declBodyBytes != -1 && st.bodyBytes+int64(len(data)) > st.declBodyBytes { if !sc.inflow.take(f.Length) { return sc.countError("data_flow", streamError(id, ErrCodeFlowControl)) } sc.sendWindowUpdate(nil, int(f.Length)) // conn-level st.body.CloseWithError(fmt.Errorf("sender tried to send more than declared Content-Length of %d bytes", st.declBodyBytes)) // RFC 7540, sec 8.1.2.6: A request or response is also malformed if the // value of a content-length header field does not equal the sum of the // DATA frame payload lengths that form the body. return sc.countError("send_too_much", streamError(id, ErrCodeProtocol)) } if f.Length > 0 { // Check whether the client has flow control quota. if !takeInflows(&sc.inflow, &st.inflow, f.Length) { return sc.countError("flow_on_data_length", streamError(id, ErrCodeFlowControl)) } if len(data) > 0 { st.bodyBytes += int64(len(data)) wrote, err := st.body.Write(data) if err != nil { // The handler has closed the request body. // Return the connection-level flow control for the discarded data, // but not the stream-level flow control. sc.sendWindowUpdate(nil, int(f.Length)-wrote) return nil } if wrote != len(data) { panic("internal error: bad Writer") } } // Return any padded flow control now, since we won't // refund it later on body reads. // Call sendWindowUpdate even if there is no padding, // to return buffered flow control credit if the sent // window has shrunk. pad := int32(f.Length) - int32(len(data)) sc.sendWindowUpdate32(nil, pad) sc.sendWindowUpdate32(st, pad) } if f.StreamEnded() { st.endStream() } return nil } func (sc serverConn) processGoAway(f GoAwayFrame) error { sc.serveG.check() if f.ErrCode != ErrCodeNo { sc.logf("http2: received GOAWAY %+v, starting graceful shutdown", f) } else { sc.vlogf("http2: received GOAWAY %+v, starting graceful shutdown", f) } sc.startGracefulShutdownInternal() // http://tools.ietf.org/html/rfc7540#section-6.8 // We should not create any new streams, which means we should disable push. sc.pushEnabled = false return nil } // isPushed reports whether the stream is server-initiated. func (st stream) isPushed() bool { return st.id%2 == 0 } // endStream closes a Request.Body's pipe. It is called when a DATA // frame says a request body is over (or after trailers). func (st stream) endStream() { sc := st.sc sc.serveG.check() if st.declBodyBytes != -1 && st.declBodyBytes != st.bodyBytes { st.body.CloseWithError(fmt.Errorf("request declared a Content-Length of %d but only wrote %d bytes", st.declBodyBytes, st.bodyBytes)) } else { st.body.closeWithErrorAndCode(io.EOF, st.copyTrailersToHandlerRequest) st.body.CloseWithError(io.EOF) } st.state = stateHalfClosedRemote } // copyTrailersToHandlerRequest is run in the Handler's goroutine in // its Request.Body.Read just before it gets io.EOF. func (st stream) copyTrailersToHandlerRequest() { for k, vv := range st.trailer { if _, ok := st.reqTrailer[k]; ok { // Only copy it over it was pre-declared. st.reqTrailer[k] = vv } } } // onReadTimeout is run on its own goroutine (from time.AfterFunc) // when the stream's ReadTimeout has fired. func (st stream) onReadTimeout() { if st.body != nil { // Wrap the ErrDeadlineExceeded to avoid callers depending on us // returning the bare error. st.body.CloseWithError(fmt.Errorf("%w", os.ErrDeadlineExceeded)) } } // onWriteTimeout is run on its own goroutine (from time.AfterFunc) // when the stream's WriteTimeout has fired. func (st stream) onWriteTimeout() { st.sc.writeFrameFromHandler(FrameWriteRequest{write: StreamError{ StreamID: st.id, Code: ErrCodeInternal, Cause: os.ErrDeadlineExceeded, }}) } func (sc serverConn) processHeaders(f MetaHeadersFrame) error { sc.serveG.check() id := f.StreamID // http://tools.ietf.org/html/rfc7540#section-5.1.1 // Streams initiated by a client MUST use odd-numbered stream // identifiers. [...] An endpoint that receives an unexpected // stream identifier MUST respond with a connection error // (Section 5.4.1) of type PROTOCOL_ERROR. if id%2 != 1 { return sc.countError("headers_even", ConnectionError(ErrCodeProtocol)) } // A HEADERS frame can be used to create a new stream or // send a trailer for an open one. If we already have a stream // open, let it process its own HEADERS frame (trailers at this // point, if it's valid). if st := sc.streams[f.StreamID]; st != nil { if st.resetQueued { // We're sending RST_STREAM to close the stream, so don't bother // processing this frame. return nil } // RFC 7540, sec 5.1: If an endpoint receives additional frames, other than // WINDOW_UPDATE, PRIORITY, or RST_STREAM, for a stream that is in // this state, it MUST respond with a stream error (Section 5.4.2) of // type STREAM_CLOSED. if st.state == stateHalfClosedRemote { return sc.countError("headers_half_closed", streamError(id, ErrCodeStreamClosed)) } return st.processTrailerHeaders(f) } // [...] The identifier of a newly established stream MUST be // numerically greater than all streams that the initiating // endpoint has opened or reserved. [...] An endpoint that // receives an unexpected stream identifier MUST respond with // a connection error (Section 5.4.1) of type PROTOCOL_ERROR. if id <= sc.maxClientStreamID { return sc.countError("stream_went_down", ConnectionError(ErrCodeProtocol)) } sc.maxClientStreamID = id if sc.idleTimer != nil { sc.idleTimer.Stop() } // http://tools.ietf.org/html/rfc7540#section-5.1.2 // [...] Endpoints MUST NOT exceed the limit set by their peer. An // endpoint that receives a HEADERS frame that causes their // advertised concurrent stream limit to be exceeded MUST treat // this as a stream error (Section 5.4.2) of type PROTOCOL_ERROR // or REFUSED_STREAM. if sc.curClientStreams+1 > sc.advMaxStreams { if sc.unackedSettings == 0 { // They should know better. return sc.countError("over_max_streams", streamError(id, ErrCodeProtocol)) } // Assume it's a network race, where they just haven't // received our last SETTINGS update. But actually // this can't happen yet, because we don't yet provide // a way for users to adjust server parameters at // runtime. return sc.countError("over_max_streams_race", streamError(id, ErrCodeRefusedStream)) } initialState := stateOpen if f.StreamEnded() { initialState = stateHalfClosedRemote } st := sc.newStream(id, 0, initialState) if f.HasPriority() { if err := sc.checkPriority(f.StreamID, f.Priority); err != nil { return err } sc.writeSched.AdjustStream(st.id, f.Priority) } rw, req, err := sc.newWriterAndRequest(st, f) if err != nil { return err } st.reqTrailer = req.Trailer if st.reqTrailer != nil { st.trailer = make(http.Header) } st.body = req.Body.(requestBody).pipe // may be nil st.declBodyBytes = req.ContentLength handler := sc.handler.ServeHTTP if f.Truncated { // Their header list was too long. Send a 431 error. handler = handleHeaderListTooLong } else if err := checkValidHTTP2RequestHeaders(req.Header); err != nil { handler = new400Handler(err) } // The net/http package sets the read deadline from the // http.Server.ReadTimeout during the TLS handshake, but then // passes the connection off to us with the deadline already // set. Disarm it here after the request headers are read, // similar to how the http1 server works. Here it's // technically more like the http1 Server's ReadHeaderTimeout // (in Go 1.8), though. That's a more sane option anyway. if sc.hs.ReadTimeout > 0 { sc.conn.SetReadDeadline(time.Time{}) st.readDeadline = sc.srv.afterFunc(sc.hs.ReadTimeout, st.onReadTimeout) } return sc.scheduleHandler(id, rw, req, handler) } func (sc serverConn) upgradeRequest(req http.Request) { sc.serveG.check() id := uint32(1) sc.maxClientStreamID = id st := sc.newStream(id, 0, stateHalfClosedRemote) st.reqTrailer = req.Trailer if st.reqTrailer != nil { st.trailer = make(http.Header) } rw := sc.newResponseWriter(st, req) // Disable any read deadline set by the net/http package // prior to the upgrade. if sc.hs.ReadTimeout > 0 { sc.conn.SetReadDeadline(time.Time{}) } // This is the first request on the connection, // so start the handler directly rather than going // through scheduleHandler. sc.curHandlers++ go sc.runHandler(rw, req, sc.handler.ServeHTTP) } func (st stream) processTrailerHeaders(f MetaHeadersFrame) error { sc := st.sc sc.serveG.check() if st.gotTrailerHeader { return sc.countError("dup_trailers", ConnectionError(ErrCodeProtocol)) } st.gotTrailerHeader = true if !f.StreamEnded() { return sc.countError("trailers_not_ended", streamError(st.id, ErrCodeProtocol)) } if len(f.PseudoFields()) > 0 { return sc.countError("trailers_pseudo", streamError(st.id, ErrCodeProtocol)) } if st.trailer != nil { for _, hf := range f.RegularFields() { key := sc.canonicalHeader(hf.Name) if !httpguts.ValidTrailerHeader(key) { // TODO: send more details to the peer somehow. But http2 has // no way to send debug data at a stream level. Discuss with // HTTP folk. return sc.countError("trailers_bogus", streamError(st.id, ErrCodeProtocol)) } st.trailer[key] = append(st.trailer[key], hf.Value) } } st.endStream() return nil } func (sc serverConn) checkPriority(streamID uint32, p PriorityParam) error { if streamID == p.StreamDep { // Section 5.3.1: "A stream cannot depend on itself. An endpoint MUST treat // this as a stream error (Section 5.4.2) of type PROTOCOL_ERROR." // Section 5.3.3 says that a stream can depend on one of its dependencies, // so it's only self-dependencies that are forbidden. return sc.countError("priority", streamError(streamID, ErrCodeProtocol)) } return nil } func (sc serverConn) processPriority(f PriorityFrame) error { if err := sc.checkPriority(f.StreamID, f.PriorityParam); err != nil { return err } sc.writeSched.AdjustStream(f.StreamID, f.PriorityParam) return nil } func (sc serverConn) newStream(id, pusherID uint32, state streamState) stream { sc.serveG.check() if id == 0 { panic("internal error: cannot create stream with id 0") } ctx, cancelCtx := context.WithCancel(sc.baseCtx) st := &stream{ sc: sc, id: id, state: state, ctx: ctx, cancelCtx: cancelCtx, } st.cw.Init() st.flow.conn = &sc.flow // link to conn-level counter st.flow.add(sc.initialStreamSendWindowSize) st.inflow.init(sc.initialStreamRecvWindowSize) if sc.hs.WriteTimeout > 0 { st.writeDeadline = sc.srv.afterFunc(sc.hs.WriteTimeout, st.onWriteTimeout) } sc.streams[id] = st sc.writeSched.OpenStream(st.id, OpenStreamOptions{PusherID: pusherID}) if st.isPushed() { sc.curPushedStreams++ } else { sc.curClientStreams++ } if sc.curOpenStreams() == 1 { sc.setConnState(http.StateActive) } return st } func (sc serverConn) newWriterAndRequest(st stream, f MetaHeadersFrame) (responseWriter, http.Request, error) { sc.serveG.check() rp := requestParam{ method: f.PseudoValue("method"), scheme: f.PseudoValue("scheme"), authority: f.PseudoValue("authority"), path: f.PseudoValue("path"), protocol: f.PseudoValue("protocol"), } // extended connect is disabled, so we should not see :protocol if disableExtendedConnectProtocol && rp.protocol != "" { return nil, nil, sc.countError("bad_connect", streamError(f.StreamID, ErrCodeProtocol)) } isConnect := rp.method == "CONNECT" if isConnect { if rp.protocol == "" && (rp.path != "" \|\| rp.scheme != "" \|\| rp.authority == "") { return nil, nil, sc.countError("bad_connect", streamError(f.StreamID, ErrCodeProtocol)) } } else if rp.method == "" \|\| rp.path == "" \|\| (rp.scheme != "https" && rp.scheme != "http") { // See 8.1.2.6 Malformed Requests and Responses: // // Malformed requests or responses that are detected // MUST be treated as a stream error (Section 5.4.2) // of type PROTOCOL_ERROR." // // 8.1.2.3 Request Pseudo-Header Fields // "All HTTP/2 requests MUST include exactly one valid // value for the :method, :scheme, and :path // pseudo-header fields" return nil, nil, sc.countError("bad_path_method", streamError(f.StreamID, ErrCodeProtocol)) } rp.header = make(http.Header) for _, hf := range f.RegularFields() { rp.header.Add(sc.canonicalHeader(hf.Name), hf.Value) } if rp.authority == "" { rp.authority = rp.header.Get("Host") } if rp.protocol != "" { rp.header.Set(":protocol", rp.protocol) } rw, req, err := sc.newWriterAndRequestNoBody(st, rp) if err != nil { return nil, nil, err } bodyOpen := !f.StreamEnded() if bodyOpen { if vv, ok := rp.header["Content-Length"]; ok { if cl, err := strconv.ParseUint(vv[0], 10, 63); err == nil { req.ContentLength = int64(cl) } else { req.ContentLength = 0 } } else { req.ContentLength = -1 } req.Body.(requestBody).pipe = &pipe{ b: &dataBuffer{expected: req.ContentLength}, } } return rw, req, nil } type requestParam struct { method string scheme, authority, path string protocol string header http.Header } func (sc serverConn) newWriterAndRequestNoBody(st stream, rp requestParam) (responseWriter, http.Request, error) { sc.serveG.check() var tlsState tls.ConnectionState // nil if not scheme https if rp.scheme == "https" { tlsState = sc.tlsState } needsContinue := httpguts.HeaderValuesContainsToken(rp.header["Expect"], "100-continue") if needsContinue { rp.header.Del("Expect") } // Merge Cookie headers into one "; "-delimited value. if cookies := rp.header["Cookie"]; len(cookies) > 1 { rp.header.Set("Cookie", strings.Join(cookies, "; ")) } // Setup Trailers var trailer http.Header for _, v := range rp.header["Trailer"] { for _, key := range strings.Split(v, ",") { key = http.CanonicalHeaderKey(textproto.TrimString(key)) switch key { case "Transfer-Encoding", "Trailer", "Content-Length": // Bogus. (copy of http1 rules) // Ignore. default: if trailer == nil { trailer = make(http.Header) } trailer[key] = nil } } } delete(rp.header, "Trailer") var url_ url.URL var requestURI string if rp.method == "CONNECT" && rp.protocol == "" { url_ = &url.URL{Host: rp.authority} requestURI = rp.authority // mimic HTTP/1 server behavior } else { var err error url_, err = url.ParseRequestURI(rp.path) if err != nil { return nil, nil, sc.countError("bad_path", streamError(st.id, ErrCodeProtocol)) } requestURI = rp.path } body := &requestBody{ conn: sc, stream: st, needsContinue: needsContinue, } req := &http.Request{ Method: rp.method, URL: url_, RemoteAddr: sc.remoteAddrStr, Header: rp.header, RequestURI: requestURI, Proto: "HTTP/2.0", ProtoMajor: 2, ProtoMinor: 0, TLS: tlsState, Host: rp.authority, Body: body, Trailer: trailer, } req = req.WithContext(st.ctx) rw := sc.newResponseWriter(st, req) return rw, req, nil } func (sc serverConn) newResponseWriter(st stream, req http.Request) responseWriter { rws := responseWriterStatePool.Get().(responseWriterState) bwSave := rws.bw rws = responseWriterState{} // zero all the fields rws.conn = sc rws.bw = bwSave rws.bw.Reset(chunkWriter{rws}) rws.stream = st rws.req = req return &responseWriter{rws: rws} } type unstartedHandler struct { streamID uint32 rw responseWriter req http.Request handler func(http.ResponseWriter, http.Request) } // scheduleHandler starts a handler goroutine, // or schedules one to start as soon as an existing handler finishes. func (sc serverConn) scheduleHandler(streamID uint32, rw responseWriter, req http.Request, handler func(http.ResponseWriter, http.Request)) error { sc.serveG.check() maxHandlers := sc.advMaxStreams if sc.curHandlers < maxHandlers { sc.curHandlers++ go sc.runHandler(rw, req, handler) return nil } if len(sc.unstartedHandlers) > int(4sc.advMaxStreams) { return sc.countError("too_many_early_resets", ConnectionError(ErrCodeEnhanceYourCalm)) } sc.unstartedHandlers = append(sc.unstartedHandlers, unstartedHandler{ streamID: streamID, rw: rw, req: req, handler: handler, }) return nil } func (sc serverConn) handlerDone() { sc.serveG.check() sc.curHandlers-- i := 0 maxHandlers := sc.advMaxStreams for ; i < len(sc.unstartedHandlers); i++ { u := sc.unstartedHandlers[i] if sc.streams[u.streamID] == nil { // This stream was reset before its goroutine had a chance to start. continue } if sc.curHandlers >= maxHandlers { break } sc.curHandlers++ go sc.runHandler(u.rw, u.req, u.handler) sc.unstartedHandlers[i] = unstartedHandler{} // don't retain references } sc.unstartedHandlers = sc.unstartedHandlers[i:] if len(sc.unstartedHandlers) == 0 { sc.unstartedHandlers = nil } } // Run on its own goroutine. func (sc serverConn) runHandler(rw responseWriter, req http.Request, handler func(http.ResponseWriter, http.Request)) { sc.srv.markNewGoroutine() defer sc.sendServeMsg(handlerDoneMsg) didPanic := true defer func() { rw.rws.stream.cancelCtx() if req.MultipartForm != nil { req.MultipartForm.RemoveAll() } if didPanic { e := recover() sc.writeFrameFromHandler(FrameWriteRequest{ write: handlerPanicRST{rw.rws.stream.id}, stream: rw.rws.stream, }) // Same as net/http: if e != nil && e != http.ErrAbortHandler { const size = 64 << 10 buf := make([]byte, size) buf = buf[:runtime.Stack(buf, false)] sc.logf("http2: panic serving %v: %v\n%s", sc.conn.RemoteAddr(), e, buf) } return } rw.handlerDone() }() handler(rw, req) didPanic = false } func handleHeaderListTooLong(w http.ResponseWriter, r http.Request) { // 10.5.1 Limits on Header Block Size: // .. "A server that receives a larger header block than it is // willing to handle can send an HTTP 431 (Request Header Fields Too // Large) status code" const statusRequestHeaderFieldsTooLarge = 431 // only in Go 1.6+ w.WriteHeader(statusRequestHeaderFieldsTooLarge) io.WriteString(w, "<h1>HTTP Error 431</h1><p>Request Header Field(s) Too Large</p>") } // called from handler goroutines. // h may be nil. func (sc serverConn) writeHeaders(st stream, headerData writeResHeaders) error { sc.serveG.checkNotOn() // NOT on var errc chan error if headerData.h != nil { // If there's a header map (which we don't own), so we have to block on // waiting for this frame to be written, so an http.Flush mid-handler // writes out the correct value of keys, before a handler later potentially // mutates it. errc = errChanPool.Get().(chan error) } if err := sc.writeFrameFromHandler(FrameWriteRequest{ write: headerData, stream: st, done: errc, }); err != nil { return err } if errc != nil { select { case err := <-errc: errChanPool.Put(errc) return err case <-sc.doneServing: return errClientDisconnected case <-st.cw: return errStreamClosed } } return nil } // called from handler goroutines. func (sc serverConn) write100ContinueHeaders(st stream) { sc.writeFrameFromHandler(FrameWriteRequest{ write: write100ContinueHeadersFrame{st.id}, stream: st, }) } // A bodyReadMsg tells the server loop that the http.Handler read n // bytes of the DATA from the client on the given stream. type bodyReadMsg struct { st stream n int } // called from handler goroutines. // Notes that the handler for the given stream ID read n bytes of its body // and schedules flow control tokens to be sent. func (sc serverConn) noteBodyReadFromHandler(st stream, n int, err error) { sc.serveG.checkNotOn() // NOT on if n > 0 { select { case sc.bodyReadCh <- bodyReadMsg{st, n}: case <-sc.doneServing: } } } func (sc serverConn) noteBodyRead(st stream, n int) { sc.serveG.check() sc.sendWindowUpdate(nil, n) // conn-level if st.state != stateHalfClosedRemote && st.state != stateClosed { // Don't send this WINDOW_UPDATE if the stream is closed // remotely. sc.sendWindowUpdate(st, n) } } // st may be nil for conn-level func (sc serverConn) sendWindowUpdate32(st stream, n int32) { sc.sendWindowUpdate(st, int(n)) } // st may be nil for conn-level func (sc serverConn) sendWindowUpdate(st stream, n int) { sc.serveG.check() var streamID uint32 var send int32 if st == nil { send = sc.inflow.add(n) } else { streamID = st.id send = st.inflow.add(n) } if send == 0 { return } sc.writeFrame(FrameWriteRequest{ write: writeWindowUpdate{streamID: streamID, n: uint32(send)}, stream: st, }) } // requestBody is the Handler's Request.Body type. // Read and Close may be called concurrently. type requestBody struct { _ incomparable stream stream conn serverConn closeOnce sync.Once // for use by Close only sawEOF bool // for use by Read only pipe pipe // non-nil if we have an HTTP entity message body needsContinue bool // need to send a 100-continue } func (b requestBody) Close() error { b.closeOnce.Do(func() { if b.pipe != nil { b.pipe.BreakWithError(errClosedBody) } }) return nil } func (b requestBody) Read(p []byte) (n int, err error) { if b.needsContinue { b.needsContinue = false b.conn.write100ContinueHeaders(b.stream) } if b.pipe == nil \|\| b.sawEOF { return 0, io.EOF } n, err = b.pipe.Read(p) if err == io.EOF { b.sawEOF = true } if b.conn == nil && inTests { return } b.conn.noteBodyReadFromHandler(b.stream, n, err) return } // responseWriter is the http.ResponseWriter implementation. It's // intentionally small (1 pointer wide) to minimize garbage. The // responseWriterState pointer inside is zeroed at the end of a // request (in handlerDone) and calls on the responseWriter thereafter // simply crash (caller's mistake), but the much larger responseWriterState // and buffers are reused between multiple requests. type responseWriter struct { rws responseWriterState } // Optional http.ResponseWriter interfaces implemented. var ( _ http.CloseNotifier = (responseWriter)(nil) _ http.Flusher = (responseWriter)(nil) _ stringWriter = (responseWriter)(nil) ) type responseWriterState struct { // immutable within a request: stream stream req http.Request conn serverConn // TODO: adjust buffer writing sizes based on server config, frame size updates from peer, etc bw bufio.Writer // writing to a chunkWriter{this responseWriterState} // mutated by http.Handler goroutine: handlerHeader http.Header // nil until called snapHeader http.Header // snapshot of handlerHeader at WriteHeader time trailers []string // set in writeChunk status int // status code passed to WriteHeader wroteHeader bool // WriteHeader called (explicitly or implicitly). Not necessarily sent to user yet. sentHeader bool // have we sent the header frame? handlerDone bool // handler has finished sentContentLen int64 // non-zero if handler set a Content-Length header wroteBytes int64 closeNotifierMu sync.Mutex // guards closeNotifierCh closeNotifierCh chan bool // nil until first used } type chunkWriter struct{ rws responseWriterState } func (cw chunkWriter) Write(p []byte) (n int, err error) { n, err = cw.rws.writeChunk(p) if err == errStreamClosed { // If writing failed because the stream has been closed, // return the reason it was closed. err = cw.rws.stream.closeErr } return n, err } func (rws responseWriterState) hasTrailers() bool { return len(rws.trailers) > 0 } func (rws responseWriterState) hasNonemptyTrailers() bool { for _, trailer := range rws.trailers { if _, ok := rws.handlerHeader[trailer]; ok { return true } } return false } // declareTrailer is called for each Trailer header when the // response header is written. It notes that a header will need to be // written in the trailers at the end of the response. func (rws responseWriterState) declareTrailer(k string) { k = http.CanonicalHeaderKey(k) if !httpguts.ValidTrailerHeader(k) { // Forbidden by RFC 7230, section 4.1.2. rws.conn.logf("ignoring invalid trailer %q", k) return } if !strSliceContains(rws.trailers, k) { rws.trailers = append(rws.trailers, k) } } // writeChunk writes chunks from the bufio.Writer. But because // bufio.Writer may bypass its chunking, sometimes p may be // arbitrarily large. // // writeChunk is also responsible (on the first chunk) for sending the // HEADER response. func (rws responseWriterState) writeChunk(p []byte) (n int, err error) { if !rws.wroteHeader { rws.writeHeader(200) } if rws.handlerDone { rws.promoteUndeclaredTrailers() } isHeadResp := rws.req.Method == "HEAD" if !rws.sentHeader { rws.sentHeader = true var ctype, clen string if clen = rws.snapHeader.Get("Content-Length"); clen != "" { rws.snapHeader.Del("Content-Length") if cl, err := strconv.ParseUint(clen, 10, 63); err == nil { rws.sentContentLen = int64(cl) } else { clen = "" } } _, hasContentLength := rws.snapHeader["Content-Length"] if !hasContentLength && clen == "" && rws.handlerDone && bodyAllowedForStatus(rws.status) && (len(p) > 0 \|\| !isHeadResp) { clen = strconv.Itoa(len(p)) } _, hasContentType := rws.snapHeader["Content-Type"] // If the Content-Encoding is non-blank, we shouldn't // sniff the body. See Issue golang.org/issue/31753. ce := rws.snapHeader.Get("Content-Encoding") hasCE := len(ce) > 0 if !hasCE && !hasContentType && bodyAllowedForStatus(rws.status) && len(p) > 0 { ctype = http.DetectContentType(p) } var date string if _, ok := rws.snapHeader["Date"]; !ok { // TODO(bradfitz): be faster here, like net/http? measure. date = rws.conn.srv.now().UTC().Format(http.TimeFormat) } for _, v := range rws.snapHeader["Trailer"] { foreachHeaderElement(v, rws.declareTrailer) } // "Connection" headers aren't allowed in HTTP/2 (RFC 7540, 8.1.2.2), // but respect "Connection" == "close" to mean sending a GOAWAY and tearing // down the TCP connection when idle, like we do for HTTP/1. // TODO: remove more Connection-specific header fields here, in addition // to "Connection". if _, ok := rws.snapHeader["Connection"]; ok { v := rws.snapHeader.Get("Connection") delete(rws.snapHeader, "Connection") if v == "close" { rws.conn.startGracefulShutdown() } } endStream := (rws.handlerDone && !rws.hasTrailers() && len(p) == 0) \|\| isHeadResp err = rws.conn.writeHeaders(rws.stream, &writeResHeaders{ streamID: rws.stream.id, httpResCode: rws.status, h: rws.snapHeader, endStream: endStream, contentType: ctype, contentLength: clen, date: date, }) if err != nil { return 0, err } if endStream { return 0, nil } } if isHeadResp { return len(p), nil } if len(p) == 0 && !rws.handlerDone { return 0, nil } // only send trailers if they have actually been defined by the // server handler. hasNonemptyTrailers := rws.hasNonemptyTrailers() endStream := rws.handlerDone && !hasNonemptyTrailers if len(p) > 0 \|\| endStream { // only send a 0 byte DATA frame if we're ending the stream. if err := rws.conn.writeDataFromHandler(rws.stream, p, endStream); err != nil { return 0, err } } if rws.handlerDone && hasNonemptyTrailers { err = rws.conn.writeHeaders(rws.stream, &writeResHeaders{ streamID: rws.stream.id, h: rws.handlerHeader, trailers: rws.trailers, endStream: true, }) return len(p), err } return len(p), nil } // TrailerPrefix is a magic prefix for ResponseWriter.Header map keys // that, if present, signals that the map entry is actually for // the response trailers, and not the response headers. The prefix // is stripped after the ServeHTTP call finishes and the values are // sent in the trailers. // // This mechanism is intended only for trailers that are not known // prior to the headers being written. If the set of trailers is fixed // or known before the header is written, the normal Go trailers mechanism // is preferred: // // https://golang.org/pkg/net/http/#ResponseWriter // https://golang.org/pkg/net/http/#example_ResponseWriter_trailers const TrailerPrefix = "Trailer:" // promoteUndeclaredTrailers permits http.Handlers to set trailers // after the header has already been flushed. Because the Go // ResponseWriter interface has no way to set Trailers (only the // Header), and because we didn't want to expand the ResponseWriter // interface, and because nobody used trailers, and because RFC 7230 // says you SHOULD (but not must) predeclare any trailers in the // header, the official ResponseWriter rules said trailers in Go must // be predeclared, and then we reuse the same ResponseWriter.Header() // map to mean both Headers and Trailers. When it's time to write the // Trailers, we pick out the fields of Headers that were declared as // trailers. That worked for a while, until we found the first major // user of Trailers in the wild: gRPC (using them only over http2), // and gRPC libraries permit setting trailers mid-stream without // predeclaring them. So: change of plans. We still permit the old // way, but we also permit this hack: if a Header() key begins with // "Trailer:", the suffix of that key is a Trailer. Because ':' is an // invalid token byte anyway, there is no ambiguity. (And it's already // filtered out) It's mildly hacky, but not terrible. // // This method runs after the Handler is done and promotes any Header // fields to be trailers. func (rws responseWriterState) promoteUndeclaredTrailers() { for k, vv := range rws.handlerHeader { if !strings.HasPrefix(k, TrailerPrefix) { continue } trailerKey := strings.TrimPrefix(k, TrailerPrefix) rws.declareTrailer(trailerKey) rws.handlerHeader[http.CanonicalHeaderKey(trailerKey)] = vv } if len(rws.trailers) > 1 { sorter := sorterPool.Get().(sorter) sorter.SortStrings(rws.trailers) sorterPool.Put(sorter) } } func (w responseWriter) SetReadDeadline(deadline time.Time) error { st := w.rws.stream if !deadline.IsZero() && deadline.Before(w.rws.conn.srv.now()) { // If we're setting a deadline in the past, reset the stream immediately // so writes after SetWriteDeadline returns will fail. st.onReadTimeout() return nil } w.rws.conn.sendServeMsg(func(sc serverConn) { if st.readDeadline != nil { if !st.readDeadline.Stop() { // Deadline already exceeded, or stream has been closed. return } } if deadline.IsZero() { st.readDeadline = nil } else if st.readDeadline == nil { st.readDeadline = sc.srv.afterFunc(deadline.Sub(sc.srv.now()), st.onReadTimeout) } else { st.readDeadline.Reset(deadline.Sub(sc.srv.now())) } }) return nil } func (w responseWriter) SetWriteDeadline(deadline time.Time) error { st := w.rws.stream if !deadline.IsZero() && deadline.Before(w.rws.conn.srv.now()) { // If we're setting a deadline in the past, reset the stream immediately // so writes after SetWriteDeadline returns will fail. st.onWriteTimeout() return nil } w.rws.conn.sendServeMsg(func(sc serverConn) { if st.writeDeadline != nil { if !st.writeDeadline.Stop() { // Deadline already exceeded, or stream has been closed. return } } if deadline.IsZero() { st.writeDeadline = nil } else if st.writeDeadline == nil { st.writeDeadline = sc.srv.afterFunc(deadline.Sub(sc.srv.now()), st.onWriteTimeout) } else { st.writeDeadline.Reset(deadline.Sub(sc.srv.now())) } }) return nil } func (w responseWriter) EnableFullDuplex() error { // We always support full duplex responses, so this is a no-op. return nil } func (w responseWriter) Flush() { w.FlushError() } func (w responseWriter) FlushError() error { rws := w.rws if rws == nil { panic("Header called after Handler finished") } var err error if rws.bw.Buffered() > 0 { err = rws.bw.Flush() } else { // The bufio.Writer won't call chunkWriter.Write // (writeChunk with zero bytes), so we have to do it // ourselves to force the HTTP response header and/or // final DATA frame (with END_STREAM) to be sent. _, err = chunkWriter{rws}.Write(nil) if err == nil { select { case <-rws.stream.cw: err = rws.stream.closeErr default: } } } return err } func (w responseWriter) CloseNotify() <-chan bool { rws := w.rws if rws == nil { panic("CloseNotify called after Handler finished") } rws.closeNotifierMu.Lock() ch := rws.closeNotifierCh if ch == nil { ch = make(chan bool, 1) rws.closeNotifierCh = ch cw := rws.stream.cw go func() { cw.Wait() // wait for close ch <- true }() } rws.closeNotifierMu.Unlock() return ch } func (w responseWriter) Header() http.Header { rws := w.rws if rws == nil { panic("Header called after Handler finished") } if rws.handlerHeader == nil { rws.handlerHeader = make(http.Header) } return rws.handlerHeader } // checkWriteHeaderCode is a copy of net/http's checkWriteHeaderCode. func checkWriteHeaderCode(code int) { // Issue 22880: require valid WriteHeader status codes. // For now we only enforce that it's three digits. // In the future we might block things over 599 (600 and above aren't defined // at http://httpwg.org/specs/rfc7231.html#status.codes). // But for now any three digits. // // We used to send "HTTP/1.1 000 0" on the wire in responses but there's // no equivalent bogus thing we can realistically send in HTTP/2, // so we'll consistently panic instead and help people find their bugs // early. (We can't return an error from WriteHeader even if we wanted to.) if code < 100 \|\| code > 999 { panic(fmt.Sprintf("invalid WriteHeader code %v", code)) } } func (w responseWriter) WriteHeader(code int) { rws := w.rws if rws == nil { panic("WriteHeader called after Handler finished") } rws.writeHeader(code) } func (rws responseWriterState) writeHeader(code int) { if rws.wroteHeader { return } checkWriteHeaderCode(code) // Handle informational headers if code >= 100 && code <= 199 { // Per RFC 8297 we must not clear the current header map h := rws.handlerHeader _, cl := h["Content-Length"] _, te := h["Transfer-Encoding"] if cl \|\| te { h = h.Clone() h.Del("Content-Length") h.Del("Transfer-Encoding") } rws.conn.writeHeaders(rws.stream, &writeResHeaders{ streamID: rws.stream.id, httpResCode: code, h: h, endStream: rws.handlerDone && !rws.hasTrailers(), }) return } rws.wroteHeader = true rws.status = code if len(rws.handlerHeader) > 0 { rws.snapHeader = cloneHeader(rws.handlerHeader) } } func cloneHeader(h http.Header) http.Header { h2 := make(http.Header, len(h)) for k, vv := range h { vv2 := make([]string, len(vv)) copy(vv2, vv) h2[k] = vv2 } return h2 } // The Life Of A Write is like this: // // * Handler calls w.Write or w.WriteString -> // * -> rws.bw (bufio.Writer) -> // (Handler might call Flush) // * -> chunkWriter{rws} // * -> responseWriterState.writeChunk(p []byte) // * -> responseWriterState.writeChunk (most of the magic; see comment there) func (w responseWriter) Write(p []byte) (n int, err error) { return w.write(len(p), p, "") } func (w responseWriter) WriteString(s string) (n int, err error) { return w.write(len(s), nil, s) } // either dataB or dataS is non-zero. func (w responseWriter) write(lenData int, dataB []byte, dataS string) (n int, err error) { rws := w.rws if rws == nil { panic("Write called after Handler finished") } if !rws.wroteHeader { w.WriteHeader(200) } if !bodyAllowedForStatus(rws.status) { return 0, http.ErrBodyNotAllowed } rws.wroteBytes += int64(len(dataB)) + int64(len(dataS)) // only one can be set if rws.sentContentLen != 0 && rws.wroteBytes > rws.sentContentLen { // TODO: send a RST_STREAM return 0, errors.New("http2: handler wrote more than declared Content-Length") } if dataB != nil { return rws.bw.Write(dataB) } else { return rws.bw.WriteString(dataS) } } func (w responseWriter) handlerDone() { rws := w.rws rws.handlerDone = true w.Flush() w.rws = nil responseWriterStatePool.Put(rws) } // Push errors. var ( ErrRecursivePush = errors.New("http2: recursive push not allowed") ErrPushLimitReached = errors.New("http2: push would exceed peer's SETTINGS_MAX_CONCURRENT_STREAMS") ) var _ http.Pusher = (responseWriter)(nil) func (w responseWriter) Push(target string, opts http.PushOptions) error { st := w.rws.stream sc := st.sc sc.serveG.checkNotOn() // No recursive pushes: "PUSH_PROMISE frames MUST only be sent on a peer-initiated stream." // http://tools.ietf.org/html/rfc7540#section-6.6 if st.isPushed() { return ErrRecursivePush } if opts == nil { opts = new(http.PushOptions) } // Default options. if opts.Method == "" { opts.Method = "GET" } if opts.Header == nil { opts.Header = http.Header{} } wantScheme := "http" if w.rws.req.TLS != nil { wantScheme = "https" } // Validate the request. u, err := url.Parse(target) if err != nil { return err } if u.Scheme == "" { if !strings.HasPrefix(target, "/") { return fmt.Errorf("target must be an absolute URL or an absolute path: %q", target) } u.Scheme = wantScheme u.Host = w.rws.req.Host } else { if u.Scheme != wantScheme { return fmt.Errorf("cannot push URL with scheme %q from request with scheme %q", u.Scheme, wantScheme) } if u.Host == "" { return errors.New("URL must have a host") } } for k := range opts.Header { if strings.HasPrefix(k, ":") { return fmt.Errorf("promised request headers cannot include pseudo header %q", k) } // These headers are meaningful only if the request has a body, // but PUSH_PROMISE requests cannot have a body. // http://tools.ietf.org/html/rfc7540#section-8.2 // Also disallow Host, since the promised URL must be absolute. if asciiEqualFold(k, "content-length") \|\| asciiEqualFold(k, "content-encoding") \|\| asciiEqualFold(k, "trailer") \|\| asciiEqualFold(k, "te") \|\| asciiEqualFold(k, "expect") \|\| asciiEqualFold(k, "host") { return fmt.Errorf("promised request headers cannot include %q", k) } } if err := checkValidHTTP2RequestHeaders(opts.Header); err != nil { return err } // The RFC effectively limits promised requests to GET and HEAD: // "Promised requests MUST be cacheable [GET, HEAD, or POST], and MUST be safe [GET or HEAD]" // http://tools.ietf.org/html/rfc7540#section-8.2 if opts.Method != "GET" && opts.Method != "HEAD" { return fmt.Errorf("method %q must be GET or HEAD", opts.Method) } msg := &startPushRequest{ parent: st, method: opts.Method, url: u, header: cloneHeader(opts.Header), done: errChanPool.Get().(chan error), } select { case <-sc.doneServing: return errClientDisconnected case <-st.cw: return errStreamClosed case sc.serveMsgCh <- msg: } select { case <-sc.doneServing: return errClientDisconnected case <-st.cw: return errStreamClosed case err := <-msg.done: errChanPool.Put(msg.done) return err } } type startPushRequest struct { parent stream method string url url.URL header http.Header done chan error } func (sc serverConn) startPush(msg startPushRequest) { sc.serveG.check() // http://tools.ietf.org/html/rfc7540#section-6.6. // PUSH_PROMISE frames MUST only be sent on a peer-initiated stream that // is in either the "open" or "half-closed (remote)" state. if msg.parent.state != stateOpen && msg.parent.state != stateHalfClosedRemote { // responseWriter.Push checks that the stream is peer-initiated. msg.done <- errStreamClosed return } // http://tools.ietf.org/html/rfc7540#section-6.6. if !sc.pushEnabled { msg.done <- http.ErrNotSupported return } // PUSH_PROMISE frames must be sent in increasing order by stream ID, so // we allocate an ID for the promised stream lazily, when the PUSH_PROMISE // is written. Once the ID is allocated, we start the request handler. allocatePromisedID := func() (uint32, error) { sc.serveG.check() // Check this again, just in case. Technically, we might have received // an updated SETTINGS by the time we got around to writing this frame. if !sc.pushEnabled { return 0, http.ErrNotSupported } // http://tools.ietf.org/html/rfc7540#section-6.5.2. if sc.curPushedStreams+1 > sc.clientMaxStreams { return 0, ErrPushLimitReached } // http://tools.ietf.org/html/rfc7540#section-5.1.1. // Streams initiated by the server MUST use even-numbered identifiers. // A server that is unable to establish a new stream identifier can send a GOAWAY // frame so that the client is forced to open a new connection for new streams. if sc.maxPushPromiseID+2 >= 1<<31 { sc.startGracefulShutdownInternal() return 0, ErrPushLimitReached } sc.maxPushPromiseID += 2 promisedID := sc.maxPushPromiseID // http://tools.ietf.org/html/rfc7540#section-8.2. // Strictly speaking, the new stream should start in "reserved (local)", then // transition to "half closed (remote)" after sending the initial HEADERS, but // we start in "half closed (remote)" for simplicity. // See further comments at the definition of stateHalfClosedRemote. promised := sc.newStream(promisedID, msg.parent.id, stateHalfClosedRemote) rw, req, err := sc.newWriterAndRequestNoBody(promised, requestParam{ method: msg.method, scheme: msg.url.Scheme, authority: msg.url.Host, path: msg.url.RequestURI(), header: cloneHeader(msg.header), // clone since handler runs concurrently with writing the PUSH_PROMISE }) if err != nil { // Should not happen, since we've already validated msg.url. panic(fmt.Sprintf("newWriterAndRequestNoBody(%+v): %v", msg.url, err)) } sc.curHandlers++ go sc.runHandler(rw, req, sc.handler.ServeHTTP) return promisedID, nil } sc.writeFrame(FrameWriteRequest{ write: &writePushPromise{ streamID: msg.parent.id, method: msg.method, url: msg.url, h: msg.header, allocatePromisedID: allocatePromisedID, }, stream: msg.parent, done: msg.done, }) } // foreachHeaderElement splits v according to the "#rule" construction // in RFC 7230 section 7 and calls fn for each non-empty element. func foreachHeaderElement(v string, fn func(string)) { v = textproto.TrimString(v) if v == "" { return } if !strings.Contains(v, ",") { fn(v) return } for _, f := range strings.Split(v, ",") { if f = textproto.TrimString(f); f != "" { fn(f) } } } // From http://httpwg.org/specs/rfc7540.html#rfc.section.8.1.2.2 var connHeaders = []string{ "Connection", "Keep-Alive", "Proxy-Connection", "Transfer-Encoding", "Upgrade", } // checkValidHTTP2RequestHeaders checks whether h is a valid HTTP/2 request, // per RFC 7540 Section 8.1.2.2. // The returned error is reported to users. func checkValidHTTP2RequestHeaders(h http.Header) error { for _, k := range connHeaders { if _, ok := h[k]; ok { return fmt.Errorf("request header %q is not valid in HTTP/2", k) } } te := h["Te"] if len(te) > 0 && (len(te) > 1 \|\| (te[0] != "trailers" && te[0] != "")) { return errors.New(`request header "TE" may only be "trailers" in HTTP/2`) } return nil } func new400Handler(err error) http.HandlerFunc { return func(w http.ResponseWriter, r http.Request) { http.Error(w, err.Error(), http.StatusBadRequest) } } // h1ServerKeepAlivesDisabled reports whether hs has its keep-alives // disabled. See comments on h1ServerShutdownChan above for why // the code is written this way. func h1ServerKeepAlivesDisabled(hs http.Server) bool { var x interface{} = hs type I interface { doKeepAlives() bool } if hs, ok := x.(I); ok { return !hs.doKeepAlives() } return false } func (sc serverConn) countError(name string, err error) error { if sc == nil \|\| sc.srv == nil { return err } f := sc.countErrorFunc if f == nil { return err } var typ string var code ErrCode switch e := err.(type) { case ConnectionError: typ = "conn" code = ErrCode(e) case StreamError: typ = "stream" code = ErrCode(e.Code) default: return err } codeStr := errCodeName[code] if codeStr == "" { codeStr = strconv.Itoa(int(code)) } f(fmt.Sprintf("%s_%s_%s", typ, codeStr, name)) return err }	104.93 KB	2025-05-25 12:27
📄 server_push_test.go // Copyright 2016 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import ( "errors" "fmt" "io" "net/http" "reflect" "runtime" "strconv" "sync" "testing" "time" ) func TestServer_Push_Success(t testing.T) { const ( mainBody = "<html>index page</html>" pushedBody = "<html>pushed page</html>" userAgent = "testagent" cookie = "testcookie" ) var stURL string checkPromisedReq := func(r http.Request, wantMethod string, wantH http.Header) error { if got, want := r.Method, wantMethod; got != want { return fmt.Errorf("promised Req.Method=%q, want %q", got, want) } if got, want := r.Header, wantH; !reflect.DeepEqual(got, want) { return fmt.Errorf("promised Req.Header=%q, want %q", got, want) } if got, want := "https://"+r.Host, stURL; got != want { return fmt.Errorf("promised Req.Host=%q, want %q", got, want) } if r.Body == nil { return fmt.Errorf("nil Body") } if buf, err := io.ReadAll(r.Body); err != nil \|\| len(buf) != 0 { return fmt.Errorf("ReadAll(Body)=%q,%v, want '',nil", buf, err) } return nil } errc := make(chan error, 3) st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { switch r.URL.RequestURI() { case "/": // Push "/pushed?get" as a GET request, using an absolute URL. opt := &http.PushOptions{ Header: http.Header{ "User-Agent": {userAgent}, }, } if err := w.(http.Pusher).Push(stURL+"/pushed?get", opt); err != nil { errc <- fmt.Errorf("error pushing /pushed?get: %v", err) return } // Push "/pushed?head" as a HEAD request, using a path. opt = &http.PushOptions{ Method: "HEAD", Header: http.Header{ "User-Agent": {userAgent}, "Cookie": {cookie}, }, } if err := w.(http.Pusher).Push("/pushed?head", opt); err != nil { errc <- fmt.Errorf("error pushing /pushed?head: %v", err) return } w.Header().Set("Content-Type", "text/html") w.Header().Set("Content-Length", strconv.Itoa(len(mainBody))) w.WriteHeader(200) io.WriteString(w, mainBody) errc <- nil case "/pushed?get": wantH := http.Header{} wantH.Set("User-Agent", userAgent) if err := checkPromisedReq(r, "GET", wantH); err != nil { errc <- fmt.Errorf("/pushed?get: %v", err) return } w.Header().Set("Content-Type", "text/html") w.Header().Set("Content-Length", strconv.Itoa(len(pushedBody))) w.WriteHeader(200) io.WriteString(w, pushedBody) errc <- nil case "/pushed?head": wantH := http.Header{} wantH.Set("User-Agent", userAgent) wantH.Set("Cookie", cookie) if err := checkPromisedReq(r, "HEAD", wantH); err != nil { errc <- fmt.Errorf("/pushed?head: %v", err) return } w.WriteHeader(204) errc <- nil default: errc <- fmt.Errorf("unknown RequestURL %q", r.URL.RequestURI()) } }) stURL = "https://" + st.authority() // Send one request, which should push two responses. st.greet() getSlash(st) for k := 0; k < 3; k++ { select { case <-time.After(2 time.Second): t.Errorf("timeout waiting for handler %d to finish", k) case err := <-errc: if err != nil { t.Fatal(err) } } } checkPushPromise := func(f Frame, promiseID uint32, wantH [][2]string) error { pp, ok := f.(PushPromiseFrame) if !ok { return fmt.Errorf("got a %T; want PushPromiseFrame", f) } if !pp.HeadersEnded() { return fmt.Errorf("want END_HEADERS flag in PushPromiseFrame") } if got, want := pp.PromiseID, promiseID; got != want { return fmt.Errorf("got PromiseID %v; want %v", got, want) } gotH := st.decodeHeader(pp.HeaderBlockFragment()) if !reflect.DeepEqual(gotH, wantH) { return fmt.Errorf("got promised headers %v; want %v", gotH, wantH) } return nil } checkHeaders := func(f Frame, wantH [][2]string) error { hf, ok := f.(HeadersFrame) if !ok { return fmt.Errorf("got a %T; want HeadersFrame", f) } gotH := st.decodeHeader(hf.HeaderBlockFragment()) if !reflect.DeepEqual(gotH, wantH) { return fmt.Errorf("got response headers %v; want %v", gotH, wantH) } return nil } checkData := func(f Frame, wantData string) error { df, ok := f.(DataFrame) if !ok { return fmt.Errorf("got a %T; want DataFrame", f) } if gotData := string(df.Data()); gotData != wantData { return fmt.Errorf("got response data %q; want %q", gotData, wantData) } return nil } // Stream 1 has 2 PUSH_PROMISE + HEADERS + DATA // Stream 2 has HEADERS + DATA // Stream 4 has HEADERS expected := map[uint32][]func(Frame) error{ 1: { func(f Frame) error { return checkPushPromise(f, 2, [][2]string{ {":method", "GET"}, {":scheme", "https"}, {":authority", st.authority()}, {":path", "/pushed?get"}, {"user-agent", userAgent}, }) }, func(f Frame) error { return checkPushPromise(f, 4, [][2]string{ {":method", "HEAD"}, {":scheme", "https"}, {":authority", st.authority()}, {":path", "/pushed?head"}, {"cookie", cookie}, {"user-agent", userAgent}, }) }, func(f Frame) error { return checkHeaders(f, [][2]string{ {":status", "200"}, {"content-type", "text/html"}, {"content-length", strconv.Itoa(len(mainBody))}, }) }, func(f Frame) error { return checkData(f, mainBody) }, }, 2: { func(f Frame) error { return checkHeaders(f, [][2]string{ {":status", "200"}, {"content-type", "text/html"}, {"content-length", strconv.Itoa(len(pushedBody))}, }) }, func(f Frame) error { return checkData(f, pushedBody) }, }, 4: { func(f Frame) error { return checkHeaders(f, [][2]string{ {":status", "204"}, }) }, }, } consumed := map[uint32]int{} for k := 0; len(expected) > 0; k++ { f := st.readFrame() if f == nil { for id, left := range expected { t.Errorf("stream %d: missing %d frames", id, len(left)) } break } id := f.Header().StreamID label := fmt.Sprintf("stream %d, frame %d", id, consumed[id]) if len(expected[id]) == 0 { t.Fatalf("%s: unexpected frame %#+v", label, f) } check := expected[id][0] expected[id] = expected[id][1:] if len(expected[id]) == 0 { delete(expected, id) } if err := check(f); err != nil { t.Fatalf("%s: %v", label, err) } consumed[id]++ } } func TestServer_Push_SuccessNoRace(t testing.T) { // Regression test for issue #18326. Ensure the request handler can mutate // pushed request headers without racing with the PUSH_PROMISE write. errc := make(chan error, 2) st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { switch r.URL.RequestURI() { case "/": opt := &http.PushOptions{ Header: http.Header{"User-Agent": {"testagent"}}, } if err := w.(http.Pusher).Push("/pushed", opt); err != nil { errc <- fmt.Errorf("error pushing: %v", err) return } w.WriteHeader(200) errc <- nil case "/pushed": // Update request header, ensure there is no race. r.Header.Set("User-Agent", "newagent") r.Header.Set("Cookie", "cookie") w.WriteHeader(200) errc <- nil default: errc <- fmt.Errorf("unknown RequestURL %q", r.URL.RequestURI()) } }) // Send one request, which should push one response. st.greet() getSlash(st) for k := 0; k < 2; k++ { select { case <-time.After(2 * time.Second): t.Errorf("timeout waiting for handler %d to finish", k) case err := <-errc: if err != nil { t.Fatal(err) } } } } func TestServer_Push_RejectRecursivePush(t testing.T) { // Expect two requests, but might get three if there's a bug and the second push succeeds. errc := make(chan error, 3) handler := func(w http.ResponseWriter, r http.Request) error { baseURL := "https://" + r.Host switch r.URL.Path { case "/": if err := w.(http.Pusher).Push(baseURL+"/push1", nil); err != nil { return fmt.Errorf("first Push()=%v, want nil", err) } return nil case "/push1": if got, want := w.(http.Pusher).Push(baseURL+"/push2", nil), ErrRecursivePush; got != want { return fmt.Errorf("Push()=%v, want %v", got, want) } return nil default: return fmt.Errorf("unexpected path: %q", r.URL.Path) } } st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { errc <- handler(w, r) }) defer st.Close() st.greet() getSlash(st) if err := <-errc; err != nil { t.Errorf("First request failed: %v", err) } if err := <-errc; err != nil { t.Errorf("Second request failed: %v", err) } } func testServer_Push_RejectSingleRequest(t testing.T, doPush func(http.Pusher, http.Request) error, settings ...Setting) { // Expect one request, but might get two if there's a bug and the push succeeds. errc := make(chan error, 2) st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { errc <- doPush(w.(http.Pusher), r) }) defer st.Close() st.greet() if err := st.fr.WriteSettings(settings...); err != nil { st.t.Fatalf("WriteSettings: %v", err) } st.wantSettingsAck() getSlash(st) if err := <-errc; err != nil { t.Error(err) } // Should not get a PUSH_PROMISE frame. st.wantHeaders(wantHeader{ streamID: 1, endStream: true, }) } func TestServer_Push_RejectIfDisabled(t testing.T) { testServer_Push_RejectSingleRequest(t, func(p http.Pusher, r http.Request) error { if got, want := p.Push("https://"+r.Host+"/pushed", nil), http.ErrNotSupported; got != want { return fmt.Errorf("Push()=%v, want %v", got, want) } return nil }, Setting{SettingEnablePush, 0}) } func TestServer_Push_RejectWhenNoConcurrentStreams(t testing.T) { testServer_Push_RejectSingleRequest(t, func(p http.Pusher, r http.Request) error { if got, want := p.Push("https://"+r.Host+"/pushed", nil), ErrPushLimitReached; got != want { return fmt.Errorf("Push()=%v, want %v", got, want) } return nil }, Setting{SettingMaxConcurrentStreams, 0}) } func TestServer_Push_RejectWrongScheme(t testing.T) { testServer_Push_RejectSingleRequest(t, func(p http.Pusher, r http.Request) error { if err := p.Push("http://"+r.Host+"/pushed", nil); err == nil { return errors.New("Push() should have failed (push target URL is http)") } return nil }) } func TestServer_Push_RejectMissingHost(t testing.T) { testServer_Push_RejectSingleRequest(t, func(p http.Pusher, r http.Request) error { if err := p.Push("https:pushed", nil); err == nil { return errors.New("Push() should have failed (push target URL missing host)") } return nil }) } func TestServer_Push_RejectRelativePath(t testing.T) { testServer_Push_RejectSingleRequest(t, func(p http.Pusher, r http.Request) error { if err := p.Push("../test", nil); err == nil { return errors.New("Push() should have failed (push target is a relative path)") } return nil }) } func TestServer_Push_RejectForbiddenMethod(t testing.T) { testServer_Push_RejectSingleRequest(t, func(p http.Pusher, r http.Request) error { if err := p.Push("https://"+r.Host+"/pushed", &http.PushOptions{Method: "POST"}); err == nil { return errors.New("Push() should have failed (cannot promise a POST)") } return nil }) } func TestServer_Push_RejectForbiddenHeader(t testing.T) { testServer_Push_RejectSingleRequest(t, func(p http.Pusher, r http.Request) error { header := http.Header{ "Content-Length": {"10"}, "Content-Encoding": {"gzip"}, "Trailer": {"Foo"}, "Te": {"trailers"}, "Host": {"test.com"}, ":authority": {"test.com"}, } if err := p.Push("https://"+r.Host+"/pushed", &http.PushOptions{Header: header}); err == nil { return errors.New("Push() should have failed (forbidden headers)") } return nil }) } func TestServer_Push_StateTransitions(t testing.T) { const body = "foo" gotPromise := make(chan bool) finishedPush := make(chan bool) st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { switch r.URL.RequestURI() { case "/": if err := w.(http.Pusher).Push("/pushed", nil); err != nil { t.Errorf("Push error: %v", err) } // Don't finish this request until the push finishes so we don't // nondeterministically interleave output frames with the push. <-finishedPush case "/pushed": <-gotPromise } w.Header().Set("Content-Type", "text/html") w.Header().Set("Content-Length", strconv.Itoa(len(body))) w.WriteHeader(200) io.WriteString(w, body) }) defer st.Close() st.greet() if st.stream(2) != nil { t.Fatal("stream 2 should be empty") } if got, want := st.streamState(2), stateIdle; got != want { t.Fatalf("streamState(2)=%v, want %v", got, want) } getSlash(st) // After the PUSH_PROMISE is sent, the stream should be stateHalfClosedRemote. _ = readFrame[PushPromiseFrame](t, st) if got, want := st.streamState(2), stateHalfClosedRemote; got != want { t.Fatalf("streamState(2)=%v, want %v", got, want) } // We stall the HTTP handler for "/pushed" until the above check. If we don't // stall the handler, then the handler might write HEADERS and DATA and finish // the stream before we check st.streamState(2) -- should that happen, we'll // see stateClosed and fail the above check. close(gotPromise) st.wantHeaders(wantHeader{ streamID: 2, endStream: false, }) if got, want := st.streamState(2), stateClosed; got != want { t.Fatalf("streamState(2)=%v, want %v", got, want) } close(finishedPush) } func TestServer_Push_RejectAfterGoAway(t testing.T) { var readyOnce sync.Once ready := make(chan struct{}) errc := make(chan error, 2) st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { <-ready if got, want := w.(http.Pusher).Push("https://"+r.Host+"/pushed", nil), http.ErrNotSupported; got != want { errc <- fmt.Errorf("Push()=%v, want %v", got, want) } errc <- nil }) defer st.Close() st.greet() getSlash(st) // Send GOAWAY and wait for it to be processed. st.fr.WriteGoAway(1, ErrCodeNo, nil) go func() { for { select { case <-ready: return default: if runtime.GOARCH == "wasm" { // Work around https://go.dev/issue/65178 to avoid goroutine starvation. runtime.Gosched() } } st.sc.serveMsgCh <- func(loopNum int) { if !st.sc.pushEnabled { readyOnce.Do(func() { close(ready) }) } } } }() if err := <-errc; err != nil { t.Error(err) } } func TestServer_Push_Underflow(t testing.T) { // Test for #63511: Send several requests which generate PUSH_PROMISE responses, // verify they all complete successfully. st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { switch r.URL.RequestURI() { case "/": opt := &http.PushOptions{ Header: http.Header{"User-Agent": {"testagent"}}, } if err := w.(http.Pusher).Push("/pushed", opt); err != nil { t.Errorf("error pushing: %v", err) } w.WriteHeader(200) case "/pushed": r.Header.Set("User-Agent", "newagent") r.Header.Set("Cookie", "cookie") w.WriteHeader(200) default: t.Errorf("unknown RequestURL %q", r.URL.RequestURI()) } }) // Send several requests. st.greet() const numRequests = 4 for i := 0; i < numRequests; i++ { st.writeHeaders(HeadersFrameParam{ StreamID: uint32(1 + i2), // clients send odd numbers BlockFragment: st.encodeHeader(), EndStream: true, EndHeaders: true, }) } // Each request should result in one PUSH_PROMISE and two responses. numPushPromises := 0 numHeaders := 0 for numHeaders < numRequests2 \|\| numPushPromises < numRequests { f := st.readFrame() if f == nil { st.t.Fatal("conn is idle, want frame") } switch f := f.(type) { case HeadersFrame: if !f.Flags.Has(FlagHeadersEndStream) { t.Fatalf("got HEADERS frame with no END_STREAM, expected END_STREAM: %v", f) } numHeaders++ case *PushPromiseFrame: numPushPromises++ } } }	15.63 KB	2025-05-25 12:27
📄 server_test.go // Copyright 2014 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import ( "bytes" "compress/gzip" "compress/zlib" "context" "crypto/tls" "errors" "flag" "fmt" "io" "log" "math" "net" "net/http" "net/http/httptest" "os" "reflect" "runtime" "strconv" "strings" "sync" "testing" "time" "golang.org/x/net/http2/hpack" ) var stderrVerbose = flag.Bool("stderr_verbose", false, "Mirror verbosity to stderr, unbuffered") func stderrv() io.Writer { if stderrVerbose { return os.Stderr } return io.Discard } type safeBuffer struct { b bytes.Buffer m sync.Mutex } func (sb safeBuffer) Write(d []byte) (int, error) { sb.m.Lock() defer sb.m.Unlock() return sb.b.Write(d) } func (sb safeBuffer) Bytes() []byte { sb.m.Lock() defer sb.m.Unlock() return sb.b.Bytes() } func (sb safeBuffer) Len() int { sb.m.Lock() defer sb.m.Unlock() return sb.b.Len() } type serverTester struct { cc net.Conn // client conn t testing.TB group synctestGroup h1server http.Server h2server Server serverLogBuf safeBuffer // logger for httptest.Server logFilter []string // substrings to filter out scMu sync.Mutex // guards sc sc serverConn testConnFramer // If http2debug!=2, then we capture Frame debug logs that will be written // to t.Log after a test fails. The read and write logs use separate locks // and buffers so we don't accidentally introduce synchronization between // the read and write goroutines, which may hide data races. frameReadLogMu sync.Mutex frameReadLogBuf bytes.Buffer frameWriteLogMu sync.Mutex frameWriteLogBuf bytes.Buffer // writing headers: headerBuf bytes.Buffer hpackEnc hpack.Encoder } func init() { testHookOnPanicMu = new(sync.Mutex) goAwayTimeout = 25 time.Millisecond } func resetHooks() { testHookOnPanicMu.Lock() testHookOnPanic = nil testHookOnPanicMu.Unlock() } func newTestServer(t testing.TB, handler http.HandlerFunc, opts ...interface{}) httptest.Server { ts := httptest.NewUnstartedServer(handler) ts.EnableHTTP2 = true ts.Config.ErrorLog = log.New(twriter{t: t}, "", log.LstdFlags) h2server := new(Server) for _, opt := range opts { switch v := opt.(type) { case func(httptest.Server): v(ts) case func(http.Server): v(ts.Config) case func(Server): v(h2server) default: t.Fatalf("unknown newTestServer option type %T", v) } } ConfigureServer(ts.Config, h2server) // ConfigureServer populates ts.Config.TLSConfig. // Copy it to ts.TLS as well. ts.TLS = ts.Config.TLSConfig // Go 1.22 changes the default minimum TLS version to TLS 1.2, // in order to properly test cases where we want to reject low // TLS versions, we need to explicitly configure the minimum // version here. ts.Config.TLSConfig.MinVersion = tls.VersionTLS10 ts.StartTLS() t.Cleanup(func() { ts.CloseClientConnections() ts.Close() }) return ts } type serverTesterOpt string var optFramerReuseFrames = serverTesterOpt("frame_reuse_frames") var optQuiet = func(server http.Server) { server.ErrorLog = log.New(io.Discard, "", 0) } func newServerTester(t testing.TB, handler http.HandlerFunc, opts ...interface{}) serverTester { t.Helper() g := newSynctest(time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)) t.Cleanup(func() { g.Close(t) }) h1server := &http.Server{} h2server := &Server{ group: g, } tlsState := tls.ConnectionState{ Version: tls.VersionTLS13, ServerName: "go.dev", CipherSuite: tls.TLS_AES_128_GCM_SHA256, } for _, opt := range opts { switch v := opt.(type) { case func(Server): v(h2server) case func(http.Server): v(h1server) case func(tls.ConnectionState): v(&tlsState) default: t.Fatalf("unknown newServerTester option type %T", v) } } ConfigureServer(h1server, h2server) cli, srv := synctestNetPipe(g) cli.SetReadDeadline(g.Now()) cli.autoWait = true st := &serverTester{ t: t, cc: cli, group: g, h1server: h1server, h2server: h2server, } st.hpackEnc = hpack.NewEncoder(&st.headerBuf) if h1server.ErrorLog == nil { h1server.ErrorLog = log.New(io.MultiWriter(stderrv(), twriter{t: t, st: st}, &st.serverLogBuf), "", log.LstdFlags) } t.Cleanup(func() { st.Close() g.AdvanceTime(goAwayTimeout) // give server time to shut down }) connc := make(chan serverConn) go func() { g.Join() h2server.serveConn(&netConnWithConnectionState{ Conn: srv, state: tlsState, }, &ServeConnOpts{ Handler: handler, BaseConfig: h1server, }, func(sc serverConn) { connc <- sc }) }() st.sc = <-connc st.fr = NewFramer(st.cc, st.cc) st.testConnFramer = testConnFramer{ t: t, fr: NewFramer(st.cc, st.cc), dec: hpack.NewDecoder(initialHeaderTableSize, nil), } g.Wait() return st } type netConnWithConnectionState struct { net.Conn state tls.ConnectionState } func (c netConnWithConnectionState) ConnectionState() tls.ConnectionState { return c.state } // newServerTesterWithRealConn creates a test server listening on a localhost port. // Mostly superseded by newServerTester, which creates a test server using a fake // net.Conn and synthetic time. This function is still around because some benchmarks // rely on it; new tests should use newServerTester. func newServerTesterWithRealConn(t testing.TB, handler http.HandlerFunc, opts ...interface{}) serverTester { resetHooks() ts := httptest.NewUnstartedServer(handler) t.Cleanup(ts.Close) tlsConfig := &tls.Config{ InsecureSkipVerify: true, NextProtos: []string{NextProtoTLS}, } var framerReuseFrames bool h2server := new(Server) for _, opt := range opts { switch v := opt.(type) { case func(tls.Config): v(tlsConfig) case func(httptest.Server): v(ts) case func(http.Server): v(ts.Config) case func(Server): v(h2server) case serverTesterOpt: switch v { case optFramerReuseFrames: framerReuseFrames = true } case func(net.Conn, http.ConnState): ts.Config.ConnState = v default: t.Fatalf("unknown newServerTester option type %T", v) } } ConfigureServer(ts.Config, h2server) // Go 1.22 changes the default minimum TLS version to TLS 1.2, // in order to properly test cases where we want to reject low // TLS versions, we need to explicitly configure the minimum // version here. ts.Config.TLSConfig.MinVersion = tls.VersionTLS10 st := &serverTester{ t: t, } st.hpackEnc = hpack.NewEncoder(&st.headerBuf) ts.TLS = ts.Config.TLSConfig // the httptest.Server has its own copy of this TLS config if ts.Config.ErrorLog == nil { ts.Config.ErrorLog = log.New(io.MultiWriter(stderrv(), twriter{t: t, st: st}, &st.serverLogBuf), "", log.LstdFlags) } ts.StartTLS() if VerboseLogs { t.Logf("Running test server at: %s", ts.URL) } testHookGetServerConn = func(v serverConn) { st.scMu.Lock() defer st.scMu.Unlock() st.sc = v } log.SetOutput(io.MultiWriter(stderrv(), twriter{t: t, st: st})) cc, err := tls.Dial("tcp", ts.Listener.Addr().String(), tlsConfig) if err != nil { t.Fatal(err) } st.cc = cc st.testConnFramer = testConnFramer{ t: t, fr: NewFramer(st.cc, st.cc), dec: hpack.NewDecoder(initialHeaderTableSize, nil), } if framerReuseFrames { st.fr.SetReuseFrames() } if !logFrameReads && !logFrameWrites { st.fr.debugReadLoggerf = func(m string, v ...interface{}) { m = time.Now().Format("2006-01-02 15:04:05.999999999 ") + strings.TrimPrefix(m, "http2: ") + "\n" st.frameReadLogMu.Lock() fmt.Fprintf(&st.frameReadLogBuf, m, v...) st.frameReadLogMu.Unlock() } st.fr.debugWriteLoggerf = func(m string, v ...interface{}) { m = time.Now().Format("2006-01-02 15:04:05.999999999 ") + strings.TrimPrefix(m, "http2: ") + "\n" st.frameWriteLogMu.Lock() fmt.Fprintf(&st.frameWriteLogBuf, m, v...) st.frameWriteLogMu.Unlock() } st.fr.logReads = true st.fr.logWrites = true } return st } // sync waits for all goroutines to idle. func (st serverTester) sync() { if st.group != nil { st.group.Wait() } } // advance advances synthetic time by a duration. func (st serverTester) advance(d time.Duration) { st.group.AdvanceTime(d) } func (st serverTester) authority() string { return "dummy.tld" } func (st serverTester) closeConn() { st.scMu.Lock() defer st.scMu.Unlock() st.sc.conn.Close() } func (st serverTester) addLogFilter(phrase string) { st.logFilter = append(st.logFilter, phrase) } func (st serverTester) stream(id uint32) stream { ch := make(chan stream, 1) st.sc.serveMsgCh <- func(int) { ch <- st.sc.streams[id] } return <-ch } func (st serverTester) streamState(id uint32) streamState { ch := make(chan streamState, 1) st.sc.serveMsgCh <- func(int) { state, _ := st.sc.state(id) ch <- state } return <-ch } // loopNum reports how many times this conn's select loop has gone around. func (st serverTester) loopNum() int { lastc := make(chan int, 1) st.sc.serveMsgCh <- func(loopNum int) { lastc <- loopNum } return <-lastc } // awaitIdle heuristically awaits for the server conn's select loop to be idle. // The heuristic is that the server connection's serve loop must schedule // 50 times in a row without any channel sends or receives occurring. func (st serverTester) awaitIdle() { remain := 50 last := st.loopNum() for remain > 0 { n := st.loopNum() if n == last+1 { remain-- } else { remain = 50 } last = n } } func (st serverTester) Close() { if st.t.Failed() { st.frameReadLogMu.Lock() if st.frameReadLogBuf.Len() > 0 { st.t.Logf("Framer read log:\n%s", st.frameReadLogBuf.String()) } st.frameReadLogMu.Unlock() st.frameWriteLogMu.Lock() if st.frameWriteLogBuf.Len() > 0 { st.t.Logf("Framer write log:\n%s", st.frameWriteLogBuf.String()) } st.frameWriteLogMu.Unlock() // If we failed already (and are likely in a Fatal, // unwindowing), force close the connection, so the // httptest.Server doesn't wait forever for the conn // to close. if st.cc != nil { st.cc.Close() } } if st.cc != nil { st.cc.Close() } log.SetOutput(os.Stderr) } // greet initiates the client's HTTP/2 connection into a state where // frames may be sent. func (st serverTester) greet() { st.t.Helper() st.greetAndCheckSettings(func(Setting) error { return nil }) } func (st serverTester) greetAndCheckSettings(checkSetting func(s Setting) error) { st.t.Helper() st.writePreface() st.writeSettings() st.sync() readFrame[SettingsFrame](st.t, st).ForeachSetting(checkSetting) st.writeSettingsAck() // The initial WINDOW_UPDATE and SETTINGS ACK can come in any order. var gotSettingsAck bool var gotWindowUpdate bool for i := 0; i < 2; i++ { f := st.readFrame() if f == nil { st.t.Fatal("wanted a settings ACK and window update, got none") } switch f := f.(type) { case SettingsFrame: if !f.Header().Flags.Has(FlagSettingsAck) { st.t.Fatal("Settings Frame didn't have ACK set") } gotSettingsAck = true case WindowUpdateFrame: if f.FrameHeader.StreamID != 0 { st.t.Fatalf("WindowUpdate StreamID = %d; want 0", f.FrameHeader.StreamID) } conf := configFromServer(st.sc.hs, st.sc.srv) incr := uint32(conf.MaxUploadBufferPerConnection - initialWindowSize) if f.Increment != incr { st.t.Fatalf("WindowUpdate increment = %d; want %d", f.Increment, incr) } gotWindowUpdate = true default: st.t.Fatalf("Wanting a settings ACK or window update, received a %T", f) } } if !gotSettingsAck { st.t.Fatalf("Didn't get a settings ACK") } if !gotWindowUpdate { st.t.Fatalf("Didn't get a window update") } } func (st serverTester) writePreface() { n, err := st.cc.Write(clientPreface) if err != nil { st.t.Fatalf("Error writing client preface: %v", err) } if n != len(clientPreface) { st.t.Fatalf("Writing client preface, wrote %d bytes; want %d", n, len(clientPreface)) } } func (st serverTester) encodeHeaderField(k, v string) { err := st.hpackEnc.WriteField(hpack.HeaderField{Name: k, Value: v}) if err != nil { st.t.Fatalf("HPACK encoding error for %q/%q: %v", k, v, err) } } // encodeHeaderRaw is the magic-free version of encodeHeader. // It takes 0 or more (k, v) pairs and encodes them. func (st serverTester) encodeHeaderRaw(headers ...string) []byte { if len(headers)%2 == 1 { panic("odd number of kv args") } st.headerBuf.Reset() for len(headers) > 0 { k, v := headers[0], headers[1] st.encodeHeaderField(k, v) headers = headers[2:] } return st.headerBuf.Bytes() } // encodeHeader encodes headers and returns their HPACK bytes. headers // must contain an even number of key/value pairs. There may be // multiple pairs for keys (e.g. "cookie"). The :method, :path, and // :scheme headers default to GET, / and https. The :authority header // defaults to st.ts.Listener.Addr(). func (st serverTester) encodeHeader(headers ...string) []byte { if len(headers)%2 == 1 { panic("odd number of kv args") } st.headerBuf.Reset() defaultAuthority := st.authority() if len(headers) == 0 { // Fast path, mostly for benchmarks, so test code doesn't pollute // profiles when we're looking to improve server allocations. st.encodeHeaderField(":method", "GET") st.encodeHeaderField(":scheme", "https") st.encodeHeaderField(":authority", defaultAuthority) st.encodeHeaderField(":path", "/") return st.headerBuf.Bytes() } if len(headers) == 2 && headers[0] == ":method" { // Another fast path for benchmarks. st.encodeHeaderField(":method", headers[1]) st.encodeHeaderField(":scheme", "https") st.encodeHeaderField(":authority", defaultAuthority) st.encodeHeaderField(":path", "/") return st.headerBuf.Bytes() } pseudoCount := map[string]int{} keys := []string{":method", ":scheme", ":authority", ":path"} vals := map[string][]string{ ":method": {"GET"}, ":scheme": {"https"}, ":authority": {defaultAuthority}, ":path": {"/"}, } for len(headers) > 0 { k, v := headers[0], headers[1] headers = headers[2:] if _, ok := vals[k]; !ok { keys = append(keys, k) } if strings.HasPrefix(k, ":") { pseudoCount[k]++ if pseudoCount[k] == 1 { vals[k] = []string{v} } else { // Allows testing of invalid headers w/ dup pseudo fields. vals[k] = append(vals[k], v) } } else { vals[k] = append(vals[k], v) } } for _, k := range keys { for _, v := range vals[k] { st.encodeHeaderField(k, v) } } return st.headerBuf.Bytes() } // bodylessReq1 writes a HEADERS frames with StreamID 1 and EndStream and EndHeaders set. func (st serverTester) bodylessReq1(headers ...string) { st.writeHeaders(HeadersFrameParam{ StreamID: 1, // clients send odd numbers BlockFragment: st.encodeHeader(headers...), EndStream: true, EndHeaders: true, }) } func (st serverTester) wantFlowControlConsumed(streamID, consumed int32) { conf := configFromServer(st.sc.hs, st.sc.srv) var initial int32 if streamID == 0 { initial = conf.MaxUploadBufferPerConnection } else { initial = conf.MaxUploadBufferPerStream } donec := make(chan struct{}) st.sc.sendServeMsg(func(sc serverConn) { defer close(donec) var avail int32 if streamID == 0 { avail = sc.inflow.avail + sc.inflow.unsent } else { } if got, want := initial-avail, consumed; got != want { st.t.Errorf("stream %v flow control consumed: %v, want %v", streamID, got, want) } }) <-donec } func TestServer(t testing.T) { gotReq := make(chan bool, 1) st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { w.Header().Set("Foo", "Bar") gotReq <- true }) defer st.Close() st.greet() st.writeHeaders(HeadersFrameParam{ StreamID: 1, // clients send odd numbers BlockFragment: st.encodeHeader(), EndStream: true, // no DATA frames EndHeaders: true, }) <-gotReq } func TestServer_Request_Get(t testing.T) { testServerRequest(t, func(st serverTester) { st.writeHeaders(HeadersFrameParam{ StreamID: 1, // clients send odd numbers BlockFragment: st.encodeHeader("foo-bar", "some-value"), EndStream: true, // no DATA frames EndHeaders: true, }) }, func(r http.Request) { if r.Method != "GET" { t.Errorf("Method = %q; want GET", r.Method) } if r.URL.Path != "/" { t.Errorf("URL.Path = %q; want /", r.URL.Path) } if r.ContentLength != 0 { t.Errorf("ContentLength = %v; want 0", r.ContentLength) } if r.Close { t.Error("Close = true; want false") } if !strings.Contains(r.RemoteAddr, ":") { t.Errorf("RemoteAddr = %q; want something with a colon", r.RemoteAddr) } if r.Proto != "HTTP/2.0" \|\| r.ProtoMajor != 2 \|\| r.ProtoMinor != 0 { t.Errorf("Proto = %q Major=%v,Minor=%v; want HTTP/2.0", r.Proto, r.ProtoMajor, r.ProtoMinor) } wantHeader := http.Header{ "Foo-Bar": []string{"some-value"}, } if !reflect.DeepEqual(r.Header, wantHeader) { t.Errorf("Header = %#v; want %#v", r.Header, wantHeader) } if n, err := r.Body.Read([]byte(" ")); err != io.EOF \|\| n != 0 { t.Errorf("Read = %d, %v; want 0, EOF", n, err) } }) } func TestServer_Request_Get_PathSlashes(t testing.T) { testServerRequest(t, func(st serverTester) { st.writeHeaders(HeadersFrameParam{ StreamID: 1, // clients send odd numbers BlockFragment: st.encodeHeader(":path", "/%2f/"), EndStream: true, // no DATA frames EndHeaders: true, }) }, func(r http.Request) { if r.RequestURI != "/%2f/" { t.Errorf("RequestURI = %q; want /%%2f/", r.RequestURI) } if r.URL.Path != "///" { t.Errorf("URL.Path = %q; want ///", r.URL.Path) } }) } // TODO: add a test with EndStream=true on the HEADERS but setting a // Content-Length anyway. Should we just omit it and force it to // zero? func TestServer_Request_Post_NoContentLength_EndStream(t testing.T) { testServerRequest(t, func(st serverTester) { st.writeHeaders(HeadersFrameParam{ StreamID: 1, // clients send odd numbers BlockFragment: st.encodeHeader(":method", "POST"), EndStream: true, EndHeaders: true, }) }, func(r http.Request) { if r.Method != "POST" { t.Errorf("Method = %q; want POST", r.Method) } if r.ContentLength != 0 { t.Errorf("ContentLength = %v; want 0", r.ContentLength) } if n, err := r.Body.Read([]byte(" ")); err != io.EOF \|\| n != 0 { t.Errorf("Read = %d, %v; want 0, EOF", n, err) } }) } func TestServer_Request_Post_Body_ImmediateEOF(t testing.T) { testBodyContents(t, -1, "", func(st serverTester) { st.writeHeaders(HeadersFrameParam{ StreamID: 1, // clients send odd numbers BlockFragment: st.encodeHeader(":method", "POST"), EndStream: false, // to say DATA frames are coming EndHeaders: true, }) st.writeData(1, true, nil) // just kidding. empty body. }) } func TestServer_Request_Post_Body_OneData(t testing.T) { const content = "Some content" testBodyContents(t, -1, content, func(st serverTester) { st.writeHeaders(HeadersFrameParam{ StreamID: 1, // clients send odd numbers BlockFragment: st.encodeHeader(":method", "POST"), EndStream: false, // to say DATA frames are coming EndHeaders: true, }) st.writeData(1, true, []byte(content)) }) } func TestServer_Request_Post_Body_TwoData(t testing.T) { const content = "Some content" testBodyContents(t, -1, content, func(st serverTester) { st.writeHeaders(HeadersFrameParam{ StreamID: 1, // clients send odd numbers BlockFragment: st.encodeHeader(":method", "POST"), EndStream: false, // to say DATA frames are coming EndHeaders: true, }) st.writeData(1, false, []byte(content[:5])) st.writeData(1, true, []byte(content[5:])) }) } func TestServer_Request_Post_Body_ContentLength_Correct(t testing.T) { const content = "Some content" testBodyContents(t, int64(len(content)), content, func(st serverTester) { st.writeHeaders(HeadersFrameParam{ StreamID: 1, // clients send odd numbers BlockFragment: st.encodeHeader( ":method", "POST", "content-length", strconv.Itoa(len(content)), ), EndStream: false, // to say DATA frames are coming EndHeaders: true, }) st.writeData(1, true, []byte(content)) }) } func TestServer_Request_Post_Body_ContentLength_TooLarge(t testing.T) { testBodyContentsFail(t, 3, "request declared a Content-Length of 3 but only wrote 2 bytes", func(st serverTester) { st.writeHeaders(HeadersFrameParam{ StreamID: 1, // clients send odd numbers BlockFragment: st.encodeHeader( ":method", "POST", "content-length", "3", ), EndStream: false, // to say DATA frames are coming EndHeaders: true, }) st.writeData(1, true, []byte("12")) }) } func TestServer_Request_Post_Body_ContentLength_TooSmall(t testing.T) { testBodyContentsFail(t, 4, "sender tried to send more than declared Content-Length of 4 bytes", func(st serverTester) { st.writeHeaders(HeadersFrameParam{ StreamID: 1, // clients send odd numbers BlockFragment: st.encodeHeader( ":method", "POST", "content-length", "4", ), EndStream: false, // to say DATA frames are coming EndHeaders: true, }) st.writeData(1, true, []byte("12345")) // Return flow control bytes back, since the data handler closed // the stream. st.wantRSTStream(1, ErrCodeProtocol) st.wantFlowControlConsumed(0, 0) }) } func testBodyContents(t testing.T, wantContentLength int64, wantBody string, write func(st serverTester)) { testServerRequest(t, write, func(r http.Request) { if r.Method != "POST" { t.Errorf("Method = %q; want POST", r.Method) } if r.ContentLength != wantContentLength { t.Errorf("ContentLength = %v; want %d", r.ContentLength, wantContentLength) } all, err := io.ReadAll(r.Body) if err != nil { t.Fatal(err) } if string(all) != wantBody { t.Errorf("Read = %q; want %q", all, wantBody) } if err := r.Body.Close(); err != nil { t.Fatalf("Close: %v", err) } }) } func testBodyContentsFail(t testing.T, wantContentLength int64, wantReadError string, write func(st serverTester)) { testServerRequest(t, write, func(r http.Request) { if r.Method != "POST" { t.Errorf("Method = %q; want POST", r.Method) } if r.ContentLength != wantContentLength { t.Errorf("ContentLength = %v; want %d", r.ContentLength, wantContentLength) } all, err := io.ReadAll(r.Body) if err == nil { t.Fatalf("expected an error (%q) reading from the body. Successfully read %q instead.", wantReadError, all) } if !strings.Contains(err.Error(), wantReadError) { t.Fatalf("Body.Read = %v; want substring %q", err, wantReadError) } if err := r.Body.Close(); err != nil { t.Fatalf("Close: %v", err) } }) } // Using a Host header, instead of :authority func TestServer_Request_Get_Host(t testing.T) { const host = "example.com" testServerRequest(t, func(st serverTester) { st.writeHeaders(HeadersFrameParam{ StreamID: 1, // clients send odd numbers BlockFragment: st.encodeHeader(":authority", "", "host", host), EndStream: true, EndHeaders: true, }) }, func(r http.Request) { if r.Host != host { t.Errorf("Host = %q; want %q", r.Host, host) } }) } // Using an :authority pseudo-header, instead of Host func TestServer_Request_Get_Authority(t testing.T) { const host = "example.com" testServerRequest(t, func(st serverTester) { st.writeHeaders(HeadersFrameParam{ StreamID: 1, // clients send odd numbers BlockFragment: st.encodeHeader(":authority", host), EndStream: true, EndHeaders: true, }) }, func(r http.Request) { if r.Host != host { t.Errorf("Host = %q; want %q", r.Host, host) } }) } func TestServer_Request_WithContinuation(t testing.T) { wantHeader := http.Header{ "Foo-One": []string{"value-one"}, "Foo-Two": []string{"value-two"}, "Foo-Three": []string{"value-three"}, } testServerRequest(t, func(st serverTester) { fullHeaders := st.encodeHeader( "foo-one", "value-one", "foo-two", "value-two", "foo-three", "value-three", ) remain := fullHeaders chunks := 0 for len(remain) > 0 { const maxChunkSize = 5 chunk := remain if len(chunk) > maxChunkSize { chunk = chunk[:maxChunkSize] } remain = remain[len(chunk):] if chunks == 0 { st.writeHeaders(HeadersFrameParam{ StreamID: 1, // clients send odd numbers BlockFragment: chunk, EndStream: true, // no DATA frames EndHeaders: false, // we'll have continuation frames }) } else { err := st.fr.WriteContinuation(1, len(remain) == 0, chunk) if err != nil { t.Fatal(err) } } chunks++ } if chunks < 2 { t.Fatal("too few chunks") } }, func(r http.Request) { if !reflect.DeepEqual(r.Header, wantHeader) { t.Errorf("Header = %#v; want %#v", r.Header, wantHeader) } }) } // Concatenated cookie headers. ("8.1.2.5 Compressing the Cookie Header Field") func TestServer_Request_CookieConcat(t testing.T) { const host = "example.com" testServerRequest(t, func(st serverTester) { st.bodylessReq1( ":authority", host, "cookie", "a=b", "cookie", "c=d", "cookie", "e=f", ) }, func(r http.Request) { const want = "a=b; c=d; e=f" if got := r.Header.Get("Cookie"); got != want { t.Errorf("Cookie = %q; want %q", got, want) } }) } func TestServer_Request_Reject_CapitalHeader(t testing.T) { testRejectRequest(t, func(st serverTester) { st.bodylessReq1("UPPER", "v") }) } func TestServer_Request_Reject_HeaderFieldNameColon(t testing.T) { testRejectRequest(t, func(st serverTester) { st.bodylessReq1("has:colon", "v") }) } func TestServer_Request_Reject_HeaderFieldNameNULL(t testing.T) { testRejectRequest(t, func(st serverTester) { st.bodylessReq1("has\x00null", "v") }) } func TestServer_Request_Reject_HeaderFieldNameEmpty(t testing.T) { testRejectRequest(t, func(st serverTester) { st.bodylessReq1("", "v") }) } func TestServer_Request_Reject_HeaderFieldValueNewline(t testing.T) { testRejectRequest(t, func(st serverTester) { st.bodylessReq1("foo", "has\nnewline") }) } func TestServer_Request_Reject_HeaderFieldValueCR(t testing.T) { testRejectRequest(t, func(st serverTester) { st.bodylessReq1("foo", "has\rcarriage") }) } func TestServer_Request_Reject_HeaderFieldValueDEL(t testing.T) { testRejectRequest(t, func(st serverTester) { st.bodylessReq1("foo", "has\x7fdel") }) } func TestServer_Request_Reject_Pseudo_Missing_method(t testing.T) { testRejectRequest(t, func(st serverTester) { st.bodylessReq1(":method", "") }) } func TestServer_Request_Reject_Pseudo_ExactlyOne(t testing.T) { // 8.1.2.3 Request Pseudo-Header Fields // "All HTTP/2 requests MUST include exactly one valid value" ... testRejectRequest(t, func(st serverTester) { st.addLogFilter("duplicate pseudo-header") st.bodylessReq1(":method", "GET", ":method", "POST") }) } func TestServer_Request_Reject_Pseudo_AfterRegular(t testing.T) { // 8.1.2.3 Request Pseudo-Header Fields // "All pseudo-header fields MUST appear in the header block // before regular header fields. Any request or response that // contains a pseudo-header field that appears in a header // block after a regular header field MUST be treated as // malformed (Section 8.1.2.6)." testRejectRequest(t, func(st serverTester) { st.addLogFilter("pseudo-header after regular header") var buf bytes.Buffer enc := hpack.NewEncoder(&buf) enc.WriteField(hpack.HeaderField{Name: ":method", Value: "GET"}) enc.WriteField(hpack.HeaderField{Name: "regular", Value: "foobar"}) enc.WriteField(hpack.HeaderField{Name: ":path", Value: "/"}) enc.WriteField(hpack.HeaderField{Name: ":scheme", Value: "https"}) st.writeHeaders(HeadersFrameParam{ StreamID: 1, // clients send odd numbers BlockFragment: buf.Bytes(), EndStream: true, EndHeaders: true, }) }) } func TestServer_Request_Reject_Pseudo_Missing_path(t testing.T) { testRejectRequest(t, func(st serverTester) { st.bodylessReq1(":path", "") }) } func TestServer_Request_Reject_Pseudo_Missing_scheme(t testing.T) { testRejectRequest(t, func(st serverTester) { st.bodylessReq1(":scheme", "") }) } func TestServer_Request_Reject_Pseudo_scheme_invalid(t testing.T) { testRejectRequest(t, func(st serverTester) { st.bodylessReq1(":scheme", "bogus") }) } func TestServer_Request_Reject_Pseudo_Unknown(t testing.T) { testRejectRequest(t, func(st serverTester) { st.addLogFilter(`invalid pseudo-header ":unknown_thing"`) st.bodylessReq1(":unknown_thing", "") }) } func testRejectRequest(t testing.T, send func(serverTester)) { st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { t.Error("server request made it to handler; should've been rejected") }) defer st.Close() st.greet() send(st) st.wantRSTStream(1, ErrCodeProtocol) } func newServerTesterForError(t testing.T) serverTester { t.Helper() st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { t.Error("server request made it to handler; should've been rejected") }, optQuiet) st.greet() return st } // Section 5.1, on idle connections: "Receiving any frame other than // HEADERS or PRIORITY on a stream in this state MUST be treated as a // connection error (Section 5.4.1) of type PROTOCOL_ERROR." func TestRejectFrameOnIdle_WindowUpdate(t testing.T) { st := newServerTesterForError(t) st.fr.WriteWindowUpdate(123, 456) st.wantGoAway(123, ErrCodeProtocol) } func TestRejectFrameOnIdle_Data(t testing.T) { st := newServerTesterForError(t) st.fr.WriteData(123, true, nil) st.wantGoAway(123, ErrCodeProtocol) } func TestRejectFrameOnIdle_RSTStream(t testing.T) { st := newServerTesterForError(t) st.fr.WriteRSTStream(123, ErrCodeCancel) st.wantGoAway(123, ErrCodeProtocol) } func TestServer_Request_Connect(t testing.T) { testServerRequest(t, func(st serverTester) { st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: st.encodeHeaderRaw( ":method", "CONNECT", ":authority", "example.com:123", ), EndStream: true, EndHeaders: true, }) }, func(r http.Request) { if g, w := r.Method, "CONNECT"; g != w { t.Errorf("Method = %q; want %q", g, w) } if g, w := r.RequestURI, "example.com:123"; g != w { t.Errorf("RequestURI = %q; want %q", g, w) } if g, w := r.URL.Host, "example.com:123"; g != w { t.Errorf("URL.Host = %q; want %q", g, w) } }) } func TestServer_Request_Connect_InvalidPath(t testing.T) { testServerRejectsStream(t, ErrCodeProtocol, func(st serverTester) { st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: st.encodeHeaderRaw( ":method", "CONNECT", ":authority", "example.com:123", ":path", "/bogus", ), EndStream: true, EndHeaders: true, }) }) } func TestServer_Request_Connect_InvalidScheme(t testing.T) { testServerRejectsStream(t, ErrCodeProtocol, func(st serverTester) { st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: st.encodeHeaderRaw( ":method", "CONNECT", ":authority", "example.com:123", ":scheme", "https", ), EndStream: true, EndHeaders: true, }) }) } func TestServer_Ping(t testing.T) { st := newServerTester(t, nil) defer st.Close() st.greet() // Server should ignore this one, since it has ACK set. ackPingData := [8]byte{1, 2, 4, 8, 16, 32, 64, 128} if err := st.fr.WritePing(true, ackPingData); err != nil { t.Fatal(err) } // But the server should reply to this one, since ACK is false. pingData := [8]byte{1, 2, 3, 4, 5, 6, 7, 8} if err := st.fr.WritePing(false, pingData); err != nil { t.Fatal(err) } pf := readFrame[PingFrame](t, st) if !pf.Flags.Has(FlagPingAck) { t.Error("response ping doesn't have ACK set") } if pf.Data != pingData { t.Errorf("response ping has data %q; want %q", pf.Data, pingData) } } type filterListener struct { net.Listener accept func(conn net.Conn) (net.Conn, error) } func (l filterListener) Accept() (net.Conn, error) { c, err := l.Listener.Accept() if err != nil { return nil, err } return l.accept(c) } func TestServer_MaxQueuedControlFrames(t testing.T) { // Goroutine debugging makes this test very slow. disableGoroutineTracking(t) st := newServerTester(t, nil) st.greet() st.cc.(synctestNetConn).SetReadBufferSize(0) // all writes block st.cc.(synctestNetConn).autoWait = false // don't sync after every write // Send maxQueuedControlFrames pings, plus a few extra // to account for ones that enter the server's write buffer. const extraPings = 2 for i := 0; i < maxQueuedControlFrames+extraPings; i++ { pingData := [8]byte{1, 2, 3, 4, 5, 6, 7, 8} st.fr.WritePing(false, pingData) } st.group.Wait() // Unblock the server. // It should have closed the connection after exceeding the control frame limit. st.cc.(synctestNetConn).SetReadBufferSize(math.MaxInt) st.advance(goAwayTimeout) // Some frames may have persisted in the server's buffers. for i := 0; i < 10; i++ { if st.readFrame() == nil { break } } st.wantClosed() } func TestServer_RejectsLargeFrames(t testing.T) { if runtime.GOOS == "windows" \|\| runtime.GOOS == "plan9" \|\| runtime.GOOS == "zos" { t.Skip("see golang.org/issue/13434, golang.org/issue/37321") } st := newServerTester(t, nil) defer st.Close() st.greet() // Write too large of a frame (too large by one byte) // We ignore the return value because it's expected that the server // will only read the first 9 bytes (the headre) and then disconnect. st.fr.WriteRawFrame(0xff, 0, 0, make([]byte, defaultMaxReadFrameSize+1)) st.wantGoAway(0, ErrCodeFrameSize) st.advance(goAwayTimeout) st.wantClosed() } func TestServer_Handler_Sends_WindowUpdate(t testing.T) { // Need to set this to at least twice the initial window size, // or st.greet gets stuck waiting for a WINDOW_UPDATE. // // This also needs to be less than MAX_FRAME_SIZE. const windowSize = 65535 * 2 puppet := newHandlerPuppet() st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { puppet.act(w, r) }, func(s Server) { s.MaxUploadBufferPerConnection = windowSize s.MaxUploadBufferPerStream = windowSize }) defer st.Close() defer puppet.done() st.greet() st.writeHeaders(HeadersFrameParam{ StreamID: 1, // clients send odd numbers BlockFragment: st.encodeHeader(":method", "POST"), EndStream: false, // data coming EndHeaders: true, }) // Write less than half the max window of data and consume it. // The server doesn't return flow control yet, buffering the 1024 bytes to // combine with a future update. data := make([]byte, windowSize) st.writeData(1, false, data[:1024]) puppet.do(readBodyHandler(t, string(data[:1024]))) // Write up to the window limit. // The server returns the buffered credit. st.writeData(1, false, data[1024:]) st.wantWindowUpdate(0, 1024) st.wantWindowUpdate(1, 1024) // The handler consumes the data and the server returns credit. puppet.do(readBodyHandler(t, string(data[1024:]))) st.wantWindowUpdate(0, windowSize-1024) st.wantWindowUpdate(1, windowSize-1024) } // the version of the TestServer_Handler_Sends_WindowUpdate with padding. // See golang.org/issue/16556 func TestServer_Handler_Sends_WindowUpdate_Padding(t testing.T) { const windowSize = 65535 2 puppet := newHandlerPuppet() st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { puppet.act(w, r) }, func(s Server) { s.MaxUploadBufferPerConnection = windowSize s.MaxUploadBufferPerStream = windowSize }) defer st.Close() defer puppet.done() st.greet() st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: st.encodeHeader(":method", "POST"), EndStream: false, EndHeaders: true, }) // Write half a window of data, with some padding. // The server doesn't return the padding yet, buffering the 5 bytes to combine // with a future update. data := make([]byte, windowSize/2) pad := make([]byte, 4) st.writeDataPadded(1, false, data, pad) // The handler consumes the body. // The server returns flow control for the body and padding // (4 bytes of padding + 1 byte of length). puppet.do(readBodyHandler(t, string(data))) st.wantWindowUpdate(0, uint32(len(data)+1+len(pad))) st.wantWindowUpdate(1, uint32(len(data)+1+len(pad))) } func TestServer_Send_GoAway_After_Bogus_WindowUpdate(t testing.T) { st := newServerTester(t, nil) defer st.Close() st.greet() if err := st.fr.WriteWindowUpdate(0, 1<<31-1); err != nil { t.Fatal(err) } st.wantGoAway(0, ErrCodeFlowControl) } func TestServer_Send_RstStream_After_Bogus_WindowUpdate(t testing.T) { inHandler := make(chan bool) blockHandler := make(chan bool) st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { inHandler <- true <-blockHandler }) defer st.Close() defer close(blockHandler) st.greet() st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: st.encodeHeader(":method", "POST"), EndStream: false, // keep it open EndHeaders: true, }) <-inHandler // Send a bogus window update: if err := st.fr.WriteWindowUpdate(1, 1<<31-1); err != nil { t.Fatal(err) } st.wantRSTStream(1, ErrCodeFlowControl) } // testServerPostUnblock sends a hanging POST with unsent data to handler, // then runs fn once in the handler, and verifies that the error returned from // handler is acceptable. It fails if takes over 5 seconds for handler to exit. func testServerPostUnblock(t testing.T, handler func(http.ResponseWriter, http.Request) error, fn func(serverTester), checkErr func(error), otherHeaders ...string) { inHandler := make(chan bool) errc := make(chan error, 1) st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { inHandler <- true errc <- handler(w, r) }) defer st.Close() st.greet() st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: st.encodeHeader(append([]string{":method", "POST"}, otherHeaders...)...), EndStream: false, // keep it open EndHeaders: true, }) <-inHandler fn(st) err := <-errc if checkErr != nil { checkErr(err) } } func TestServer_RSTStream_Unblocks_Read(t testing.T) { testServerPostUnblock(t, func(w http.ResponseWriter, r http.Request) (err error) { _, err = r.Body.Read(make([]byte, 1)) return }, func(st serverTester) { if err := st.fr.WriteRSTStream(1, ErrCodeCancel); err != nil { t.Fatal(err) } }, func(err error) { want := StreamError{StreamID: 0x1, Code: 0x8} if !reflect.DeepEqual(err, want) { t.Errorf("Read error = %v; want %v", err, want) } }, ) } func TestServer_RSTStream_Unblocks_Header_Write(t testing.T) { // Run this test a bunch, because it doesn't always // deadlock. But with a bunch, it did. n := 50 if testing.Short() { n = 5 } for i := 0; i < n; i++ { testServer_RSTStream_Unblocks_Header_Write(t) } } func testServer_RSTStream_Unblocks_Header_Write(t testing.T) { inHandler := make(chan bool, 1) unblockHandler := make(chan bool, 1) headerWritten := make(chan bool, 1) wroteRST := make(chan bool, 1) st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { inHandler <- true <-wroteRST w.Header().Set("foo", "bar") w.WriteHeader(200) w.(http.Flusher).Flush() headerWritten <- true <-unblockHandler }) defer st.Close() st.greet() st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: st.encodeHeader(":method", "POST"), EndStream: false, // keep it open EndHeaders: true, }) <-inHandler if err := st.fr.WriteRSTStream(1, ErrCodeCancel); err != nil { t.Fatal(err) } wroteRST <- true st.awaitIdle() <-headerWritten unblockHandler <- true } func TestServer_DeadConn_Unblocks_Read(t testing.T) { testServerPostUnblock(t, func(w http.ResponseWriter, r http.Request) (err error) { _, err = r.Body.Read(make([]byte, 1)) return }, func(st serverTester) { st.cc.Close() }, func(err error) { if err == nil { t.Error("unexpected nil error from Request.Body.Read") } }, ) } var blockUntilClosed = func(w http.ResponseWriter, r http.Request) error { <-w.(http.CloseNotifier).CloseNotify() return nil } func TestServer_CloseNotify_After_RSTStream(t testing.T) { testServerPostUnblock(t, blockUntilClosed, func(st serverTester) { if err := st.fr.WriteRSTStream(1, ErrCodeCancel); err != nil { t.Fatal(err) } }, nil) } func TestServer_CloseNotify_After_ConnClose(t testing.T) { testServerPostUnblock(t, blockUntilClosed, func(st serverTester) { st.cc.Close() }, nil) } // that CloseNotify unblocks after a stream error due to the client's // problem that's unrelated to them explicitly canceling it (which is // TestServer_CloseNotify_After_RSTStream above) func TestServer_CloseNotify_After_StreamError(t testing.T) { testServerPostUnblock(t, blockUntilClosed, func(st serverTester) { // data longer than declared Content-Length => stream error st.writeData(1, true, []byte("1234")) }, nil, "content-length", "3") } func TestServer_StateTransitions(t testing.T) { var st serverTester inHandler := make(chan bool) writeData := make(chan bool) leaveHandler := make(chan bool) st = newServerTester(t, func(w http.ResponseWriter, r http.Request) { inHandler <- true if st.stream(1) == nil { t.Errorf("nil stream 1 in handler") } if got, want := st.streamState(1), stateOpen; got != want { t.Errorf("in handler, state is %v; want %v", got, want) } writeData <- true if n, err := r.Body.Read(make([]byte, 1)); n != 0 \|\| err != io.EOF { t.Errorf("body read = %d, %v; want 0, EOF", n, err) } if got, want := st.streamState(1), stateHalfClosedRemote; got != want { t.Errorf("in handler, state is %v; want %v", got, want) } <-leaveHandler }) st.greet() if st.stream(1) != nil { t.Fatal("stream 1 should be empty") } if got := st.streamState(1); got != stateIdle { t.Fatalf("stream 1 should be idle; got %v", got) } st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: st.encodeHeader(":method", "POST"), EndStream: false, // keep it open EndHeaders: true, }) <-inHandler <-writeData st.writeData(1, true, nil) leaveHandler <- true st.wantHeaders(wantHeader{ streamID: 1, endStream: true, }) if got, want := st.streamState(1), stateClosed; got != want { t.Errorf("at end, state is %v; want %v", got, want) } if st.stream(1) != nil { t.Fatal("at end, stream 1 should be gone") } } // test HEADERS w/o EndHeaders + another HEADERS (should get rejected) func TestServer_Rejects_HeadersNoEnd_Then_Headers(t testing.T) { st := newServerTesterForError(t) st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: st.encodeHeader(), EndStream: true, EndHeaders: false, }) st.writeHeaders(HeadersFrameParam{ // Not a continuation. StreamID: 3, // different stream. BlockFragment: st.encodeHeader(), EndStream: true, EndHeaders: true, }) st.wantGoAway(0, ErrCodeProtocol) } // test HEADERS w/o EndHeaders + PING (should get rejected) func TestServer_Rejects_HeadersNoEnd_Then_Ping(t testing.T) { st := newServerTesterForError(t) st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: st.encodeHeader(), EndStream: true, EndHeaders: false, }) if err := st.fr.WritePing(false, [8]byte{}); err != nil { t.Fatal(err) } st.wantGoAway(0, ErrCodeProtocol) } // test HEADERS w/ EndHeaders + a continuation HEADERS (should get rejected) func TestServer_Rejects_HeadersEnd_Then_Continuation(t testing.T) { st := newServerTester(t, func(w http.ResponseWriter, r http.Request) {}, optQuiet) st.greet() st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: st.encodeHeader(), EndStream: true, EndHeaders: true, }) st.wantHeaders(wantHeader{ streamID: 1, endStream: true, }) if err := st.fr.WriteContinuation(1, true, encodeHeaderNoImplicit(t, "foo", "bar")); err != nil { t.Fatal(err) } st.wantGoAway(1, ErrCodeProtocol) } // test HEADERS w/o EndHeaders + a continuation HEADERS on wrong stream ID func TestServer_Rejects_HeadersNoEnd_Then_ContinuationWrongStream(t testing.T) { st := newServerTesterForError(t) st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: st.encodeHeader(), EndStream: true, EndHeaders: false, }) if err := st.fr.WriteContinuation(3, true, encodeHeaderNoImplicit(t, "foo", "bar")); err != nil { t.Fatal(err) } st.wantGoAway(0, ErrCodeProtocol) } // No HEADERS on stream 0. func TestServer_Rejects_Headers0(t testing.T) { st := newServerTesterForError(t) st.fr.AllowIllegalWrites = true st.writeHeaders(HeadersFrameParam{ StreamID: 0, BlockFragment: st.encodeHeader(), EndStream: true, EndHeaders: true, }) st.wantGoAway(0, ErrCodeProtocol) } // No CONTINUATION on stream 0. func TestServer_Rejects_Continuation0(t testing.T) { st := newServerTesterForError(t) st.fr.AllowIllegalWrites = true if err := st.fr.WriteContinuation(0, true, st.encodeHeader()); err != nil { t.Fatal(err) } st.wantGoAway(0, ErrCodeProtocol) } // No PRIORITY on stream 0. func TestServer_Rejects_Priority0(t testing.T) { st := newServerTesterForError(t) st.fr.AllowIllegalWrites = true st.writePriority(0, PriorityParam{StreamDep: 1}) st.wantGoAway(0, ErrCodeProtocol) } // No HEADERS frame with a self-dependence. func TestServer_Rejects_HeadersSelfDependence(t testing.T) { testServerRejectsStream(t, ErrCodeProtocol, func(st serverTester) { st.fr.AllowIllegalWrites = true st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: st.encodeHeader(), EndStream: true, EndHeaders: true, Priority: PriorityParam{StreamDep: 1}, }) }) } // No PRIORITY frame with a self-dependence. func TestServer_Rejects_PrioritySelfDependence(t testing.T) { testServerRejectsStream(t, ErrCodeProtocol, func(st serverTester) { st.fr.AllowIllegalWrites = true st.writePriority(1, PriorityParam{StreamDep: 1}) }) } func TestServer_Rejects_PushPromise(t testing.T) { st := newServerTesterForError(t) pp := PushPromiseParam{ StreamID: 1, PromiseID: 3, } if err := st.fr.WritePushPromise(pp); err != nil { t.Fatal(err) } st.wantGoAway(1, ErrCodeProtocol) } // testServerRejectsStream tests that the server sends a RST_STREAM with the provided // error code after a client sends a bogus request. func testServerRejectsStream(t testing.T, code ErrCode, writeReq func(serverTester)) { st := newServerTester(t, func(w http.ResponseWriter, r http.Request) {}) defer st.Close() st.greet() writeReq(st) st.wantRSTStream(1, code) } // testServerRequest sets up an idle HTTP/2 connection and lets you // write a single request with writeReq, and then verify that the // http.Request is built correctly in checkReq. func testServerRequest(t testing.T, writeReq func(serverTester), checkReq func(http.Request)) { gotReq := make(chan bool, 1) st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { if r.Body == nil { t.Fatal("nil Body") } checkReq(r) gotReq <- true }) defer st.Close() st.greet() writeReq(st) <-gotReq } func getSlash(st serverTester) { st.bodylessReq1() } func TestServer_Response_NoData(t testing.T) { testServerResponse(t, func(w http.ResponseWriter, r http.Request) error { // Nothing. return nil }, func(st serverTester) { getSlash(st) st.wantHeaders(wantHeader{ streamID: 1, endStream: true, }) }) } func TestServer_Response_NoData_Header_FooBar(t testing.T) { testServerResponse(t, func(w http.ResponseWriter, r http.Request) error { w.Header().Set("Foo-Bar", "some-value") return nil }, func(st serverTester) { getSlash(st) st.wantHeaders(wantHeader{ streamID: 1, endStream: true, header: http.Header{ ":status": []string{"200"}, "foo-bar": []string{"some-value"}, "content-length": []string{"0"}, }, }) }) } // Reject content-length headers containing a sign. // See https://golang.org/issue/39017 func TestServerIgnoresContentLengthSignWhenWritingChunks(t testing.T) { tests := []struct { name string cl string wantCL string }{ { name: "proper content-length", cl: "3", wantCL: "3", }, { name: "ignore cl with plus sign", cl: "+3", wantCL: "0", }, { name: "ignore cl with minus sign", cl: "-3", wantCL: "0", }, { name: "max int64, for safe uint64->int64 conversion", cl: "9223372036854775807", wantCL: "9223372036854775807", }, { name: "overflows int64, so ignored", cl: "9223372036854775808", wantCL: "0", }, } for _, tt := range tests { testServerResponse(t, func(w http.ResponseWriter, r http.Request) error { w.Header().Set("content-length", tt.cl) return nil }, func(st serverTester) { getSlash(st) st.wantHeaders(wantHeader{ streamID: 1, endStream: true, header: http.Header{ ":status": []string{"200"}, "content-length": []string{tt.wantCL}, }, }) }) } } // Reject content-length headers containing a sign. // See https://golang.org/issue/39017 func TestServerRejectsContentLengthWithSignNewRequests(t testing.T) { tests := []struct { name string cl string wantCL int64 }{ { name: "proper content-length", cl: "3", wantCL: 3, }, { name: "ignore cl with plus sign", cl: "+3", wantCL: 0, }, { name: "ignore cl with minus sign", cl: "-3", wantCL: 0, }, { name: "max int64, for safe uint64->int64 conversion", cl: "9223372036854775807", wantCL: 9223372036854775807, }, { name: "overflows int64, so ignored", cl: "9223372036854775808", wantCL: 0, }, } for _, tt := range tests { tt := tt t.Run(tt.name, func(t testing.T) { writeReq := func(st serverTester) { st.writeHeaders(HeadersFrameParam{ StreamID: 1, // clients send odd numbers BlockFragment: st.encodeHeader("content-length", tt.cl), EndStream: false, EndHeaders: true, }) st.writeData(1, false, []byte("")) } checkReq := func(r http.Request) { if r.ContentLength != tt.wantCL { t.Fatalf("Got: %q\nWant: %q", r.ContentLength, tt.wantCL) } } testServerRequest(t, writeReq, checkReq) }) } } func TestServer_Response_Data_Sniff_DoesntOverride(t testing.T) { const msg = "<html>this is HTML." testServerResponse(t, func(w http.ResponseWriter, r http.Request) error { w.Header().Set("Content-Type", "foo/bar") io.WriteString(w, msg) return nil }, func(st serverTester) { getSlash(st) st.wantHeaders(wantHeader{ streamID: 1, endStream: false, header: http.Header{ ":status": []string{"200"}, "content-type": []string{"foo/bar"}, "content-length": []string{strconv.Itoa(len(msg))}, }, }) st.wantData(wantData{ streamID: 1, endStream: true, data: []byte(msg), }) }) } func TestServer_Response_TransferEncoding_chunked(t testing.T) { const msg = "hi" testServerResponse(t, func(w http.ResponseWriter, r http.Request) error { w.Header().Set("Transfer-Encoding", "chunked") // should be stripped io.WriteString(w, msg) return nil }, func(st serverTester) { getSlash(st) st.wantHeaders(wantHeader{ streamID: 1, endStream: false, header: http.Header{ ":status": []string{"200"}, "content-type": []string{"text/plain; charset=utf-8"}, "content-length": []string{strconv.Itoa(len(msg))}, }, }) }) } // Header accessed only after the initial write. func TestServer_Response_Data_IgnoreHeaderAfterWrite_After(t testing.T) { const msg = "<html>this is HTML." testServerResponse(t, func(w http.ResponseWriter, r http.Request) error { io.WriteString(w, msg) w.Header().Set("foo", "should be ignored") return nil }, func(st serverTester) { getSlash(st) st.wantHeaders(wantHeader{ streamID: 1, endStream: false, header: http.Header{ ":status": []string{"200"}, "content-type": []string{"text/html; charset=utf-8"}, "content-length": []string{strconv.Itoa(len(msg))}, }, }) }) } // Header accessed before the initial write and later mutated. func TestServer_Response_Data_IgnoreHeaderAfterWrite_Overwrite(t testing.T) { const msg = "<html>this is HTML." testServerResponse(t, func(w http.ResponseWriter, r http.Request) error { w.Header().Set("foo", "proper value") io.WriteString(w, msg) w.Header().Set("foo", "should be ignored") return nil }, func(st serverTester) { getSlash(st) st.wantHeaders(wantHeader{ streamID: 1, endStream: false, header: http.Header{ ":status": []string{"200"}, "foo": []string{"proper value"}, "content-type": []string{"text/html; charset=utf-8"}, "content-length": []string{strconv.Itoa(len(msg))}, }, }) }) } func TestServer_Response_Data_SniffLenType(t testing.T) { const msg = "<html>this is HTML." testServerResponse(t, func(w http.ResponseWriter, r http.Request) error { io.WriteString(w, msg) return nil }, func(st serverTester) { getSlash(st) st.wantHeaders(wantHeader{ streamID: 1, endStream: false, header: http.Header{ ":status": []string{"200"}, "content-type": []string{"text/html; charset=utf-8"}, "content-length": []string{strconv.Itoa(len(msg))}, }, }) st.wantData(wantData{ streamID: 1, endStream: true, data: []byte(msg), }) }) } func TestServer_Response_Header_Flush_MidWrite(t testing.T) { const msg = "<html>this is HTML" const msg2 = ", and this is the next chunk" testServerResponse(t, func(w http.ResponseWriter, r http.Request) error { io.WriteString(w, msg) w.(http.Flusher).Flush() io.WriteString(w, msg2) return nil }, func(st serverTester) { getSlash(st) st.wantHeaders(wantHeader{ streamID: 1, endStream: false, header: http.Header{ ":status": []string{"200"}, "content-type": []string{"text/html; charset=utf-8"}, // sniffed // and no content-length }, }) st.wantData(wantData{ streamID: 1, endStream: false, data: []byte(msg), }) st.wantData(wantData{ streamID: 1, endStream: true, data: []byte(msg2), }) }) } func TestServer_Response_LargeWrite(t testing.T) { const size = 1 << 20 const maxFrameSize = 16 << 10 testServerResponse(t, func(w http.ResponseWriter, r http.Request) error { n, err := w.Write(bytes.Repeat([]byte("a"), size)) if err != nil { return fmt.Errorf("Write error: %v", err) } if n != size { return fmt.Errorf("wrong size %d from Write", n) } return nil }, func(st serverTester) { if err := st.fr.WriteSettings( Setting{SettingInitialWindowSize, 0}, Setting{SettingMaxFrameSize, maxFrameSize}, ); err != nil { t.Fatal(err) } st.wantSettingsAck() getSlash(st) // make the single request // Give the handler quota to write: if err := st.fr.WriteWindowUpdate(1, size); err != nil { t.Fatal(err) } // Give the handler quota to write to connection-level // window as well if err := st.fr.WriteWindowUpdate(0, size); err != nil { t.Fatal(err) } st.wantHeaders(wantHeader{ streamID: 1, endStream: false, header: http.Header{ ":status": []string{"200"}, "content-type": []string{"text/plain; charset=utf-8"}, // sniffed // and no content-length }, }) var bytes, frames int for { df := readFrame[DataFrame](t, st) bytes += len(df.Data()) frames++ for _, b := range df.Data() { if b != 'a' { t.Fatal("non-'a' byte seen in DATA") } } if df.StreamEnded() { break } } if bytes != size { t.Errorf("Got %d bytes; want %d", bytes, size) } if want := int(size / maxFrameSize); frames < want \|\| frames > want2 { t.Errorf("Got %d frames; want %d", frames, size) } }) } // Test that the handler can't write more than the client allows func TestServer_Response_LargeWrite_FlowControlled(t testing.T) { // Make these reads. Before each read, the client adds exactly enough // flow-control to satisfy the read. Numbers chosen arbitrarily. reads := []int{123, 1, 13, 127} size := 0 for _, n := range reads { size += n } testServerResponse(t, func(w http.ResponseWriter, r http.Request) error { w.(http.Flusher).Flush() n, err := w.Write(bytes.Repeat([]byte("a"), size)) if err != nil { return fmt.Errorf("Write error: %v", err) } if n != size { return fmt.Errorf("wrong size %d from Write", n) } return nil }, func(st serverTester) { // Set the window size to something explicit for this test. // It's also how much initial data we expect. if err := st.fr.WriteSettings(Setting{SettingInitialWindowSize, uint32(reads[0])}); err != nil { t.Fatal(err) } st.wantSettingsAck() getSlash(st) // make the single request st.wantHeaders(wantHeader{ streamID: 1, endStream: false, }) st.wantData(wantData{ streamID: 1, endStream: false, size: reads[0], }) for i, quota := range reads[1:] { if err := st.fr.WriteWindowUpdate(1, uint32(quota)); err != nil { t.Fatal(err) } st.wantData(wantData{ streamID: 1, endStream: i == len(reads[1:])-1, size: quota, }) } }) } // Test that the handler blocked in a Write is unblocked if the server sends a RST_STREAM. func TestServer_Response_RST_Unblocks_LargeWrite(t testing.T) { const size = 1 << 20 const maxFrameSize = 16 << 10 testServerResponse(t, func(w http.ResponseWriter, r http.Request) error { w.(http.Flusher).Flush() _, err := w.Write(bytes.Repeat([]byte("a"), size)) if err == nil { return errors.New("unexpected nil error from Write in handler") } return nil }, func(st serverTester) { if err := st.fr.WriteSettings( Setting{SettingInitialWindowSize, 0}, Setting{SettingMaxFrameSize, maxFrameSize}, ); err != nil { t.Fatal(err) } st.wantSettingsAck() getSlash(st) // make the single request st.wantHeaders(wantHeader{ streamID: 1, endStream: false, }) if err := st.fr.WriteRSTStream(1, ErrCodeCancel); err != nil { t.Fatal(err) } }) } func TestServer_Response_Empty_Data_Not_FlowControlled(t testing.T) { testServerResponse(t, func(w http.ResponseWriter, r http.Request) error { w.(http.Flusher).Flush() // Nothing; send empty DATA return nil }, func(st serverTester) { // Handler gets no data quota: if err := st.fr.WriteSettings(Setting{SettingInitialWindowSize, 0}); err != nil { t.Fatal(err) } st.wantSettingsAck() getSlash(st) // make the single request st.wantHeaders(wantHeader{ streamID: 1, endStream: false, }) st.wantData(wantData{ streamID: 1, endStream: true, size: 0, }) }) } func TestServer_Response_Automatic100Continue(t testing.T) { const msg = "foo" const reply = "bar" testServerResponse(t, func(w http.ResponseWriter, r http.Request) error { if v := r.Header.Get("Expect"); v != "" { t.Errorf("Expect header = %q; want empty", v) } buf := make([]byte, len(msg)) // This read should trigger the 100-continue being sent. if n, err := io.ReadFull(r.Body, buf); err != nil \|\| n != len(msg) \|\| string(buf) != msg { return fmt.Errorf("ReadFull = %q, %v; want %q, nil", buf[:n], err, msg) } _, err := io.WriteString(w, reply) return err }, func(st serverTester) { st.writeHeaders(HeadersFrameParam{ StreamID: 1, // clients send odd numbers BlockFragment: st.encodeHeader(":method", "POST", "expect", "100-Continue"), EndStream: false, EndHeaders: true, }) st.wantHeaders(wantHeader{ streamID: 1, endStream: false, header: http.Header{ ":status": []string{"100"}, }, }) // Okay, they sent status 100, so we can send our // gigantic and/or sensitive "foo" payload now. st.writeData(1, true, []byte(msg)) st.wantHeaders(wantHeader{ streamID: 1, endStream: false, header: http.Header{ ":status": []string{"200"}, "content-type": []string{"text/plain; charset=utf-8"}, "content-length": []string{strconv.Itoa(len(reply))}, }, }) st.wantData(wantData{ streamID: 1, endStream: true, data: []byte(reply), }) }) } func TestServer_HandlerWriteErrorOnDisconnect(t testing.T) { errc := make(chan error, 1) testServerResponse(t, func(w http.ResponseWriter, r http.Request) error { p := []byte("some data.\n") for { _, err := w.Write(p) if err != nil { errc <- err return nil } } }, func(st serverTester) { st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: st.encodeHeader(), EndStream: false, EndHeaders: true, }) st.wantHeaders(wantHeader{ streamID: 1, endStream: false, }) // Close the connection and wait for the handler to (hopefully) notice. st.cc.Close() _ = <-errc }) } func TestServer_Rejects_Too_Many_Streams(t testing.T) { const testPath = "/some/path" inHandler := make(chan uint32) leaveHandler := make(chan bool) st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { id := w.(responseWriter).rws.stream.id inHandler <- id if id == 1+(defaultMaxStreams+1)2 && r.URL.Path != testPath { t.Errorf("decoded final path as %q; want %q", r.URL.Path, testPath) } <-leaveHandler }) defer st.Close() // Automatically syncing after every write / before every read // slows this test down substantially. st.cc.(synctestNetConn).autoWait = false st.greet() nextStreamID := uint32(1) streamID := func() uint32 { defer func() { nextStreamID += 2 }() return nextStreamID } sendReq := func(id uint32, headers ...string) { st.writeHeaders(HeadersFrameParam{ StreamID: id, BlockFragment: st.encodeHeader(headers...), EndStream: true, EndHeaders: true, }) } for i := 0; i < defaultMaxStreams; i++ { sendReq(streamID()) <-inHandler } defer func() { for i := 0; i < defaultMaxStreams; i++ { leaveHandler <- true } }() // And this one should cross the limit: // (It's also sent as a CONTINUATION, to verify we still track the decoder context, // even if we're rejecting it) rejectID := streamID() headerBlock := st.encodeHeader(":path", testPath) frag1, frag2 := headerBlock[:3], headerBlock[3:] st.writeHeaders(HeadersFrameParam{ StreamID: rejectID, BlockFragment: frag1, EndStream: true, EndHeaders: false, // CONTINUATION coming }) if err := st.fr.WriteContinuation(rejectID, true, frag2); err != nil { t.Fatal(err) } st.sync() st.wantRSTStream(rejectID, ErrCodeProtocol) // But let a handler finish: leaveHandler <- true st.sync() st.wantHeaders(wantHeader{ streamID: 1, endStream: true, }) // And now another stream should be able to start: goodID := streamID() sendReq(goodID, ":path", testPath) if got := <-inHandler; got != goodID { t.Errorf("Got stream %d; want %d", got, goodID) } } // So many response headers that the server needs to use CONTINUATION frames: func TestServer_Response_ManyHeaders_With_Continuation(t testing.T) { testServerResponse(t, func(w http.ResponseWriter, r http.Request) error { h := w.Header() for i := 0; i < 5000; i++ { h.Set(fmt.Sprintf("x-header-%d", i), fmt.Sprintf("x-value-%d", i)) } return nil }, func(st serverTester) { getSlash(st) hf := readFrame[HeadersFrame](t, st) if hf.HeadersEnded() { t.Fatal("got unwanted END_HEADERS flag") } n := 0 for { n++ cf := readFrame[ContinuationFrame](t, st) if cf.HeadersEnded() { break } } if n < 5 { t.Errorf("Only got %d CONTINUATION frames; expected 5+ (currently 6)", n) } }) } // This previously crashed (reported by Mathieu Lonjaret as observed // while using Camlistore) because we got a DATA frame from the client // after the handler exited and our logic at the time was wrong, // keeping a stream in the map in stateClosed, which tickled an // invariant check later when we tried to remove that stream (via // defer sc.closeAllStreamsOnConnClose) when the serverConn serve loop // ended. func TestServer_NoCrash_HandlerClose_Then_ClientClose(t testing.T) { testServerResponse(t, func(w http.ResponseWriter, r http.Request) error { // nothing return nil }, func(st serverTester) { st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: st.encodeHeader(), EndStream: false, // DATA is coming EndHeaders: true, }) st.wantHeaders(wantHeader{ streamID: 1, endStream: true, }) // Sent when the a Handler closes while a client has // indicated it's still sending DATA: st.wantRSTStream(1, ErrCodeNo) // Now the handler has ended, so it's ended its // stream, but the client hasn't closed its side // (stateClosedLocal). So send more data and verify // it doesn't crash with an internal invariant panic, like // it did before. st.writeData(1, true, []byte("foo")) // Sent after a peer sends data anyway (admittedly the // previous RST_STREAM might've still been in-flight), // but they'll get the more friendly 'cancel' code // first. st.wantRSTStream(1, ErrCodeStreamClosed) // We should have our flow control bytes back, // since the handler didn't get them. st.wantFlowControlConsumed(0, 0) // Set up a bunch of machinery to record the panic we saw // previously. var ( panMu sync.Mutex panicVal interface{} ) testHookOnPanicMu.Lock() testHookOnPanic = func(sc serverConn, pv interface{}) bool { panMu.Lock() panicVal = pv panMu.Unlock() return true } testHookOnPanicMu.Unlock() // Now force the serve loop to end, via closing the connection. st.cc.Close() <-st.sc.doneServing panMu.Lock() got := panicVal panMu.Unlock() if got != nil { t.Errorf("Got panic: %v", got) } }) } func TestServer_Rejects_TLS10(t testing.T) { testRejectTLS(t, tls.VersionTLS10) } func TestServer_Rejects_TLS11(t testing.T) { testRejectTLS(t, tls.VersionTLS11) } func testRejectTLS(t testing.T, version uint16) { st := newServerTester(t, nil, func(state tls.ConnectionState) { // As of 1.18 the default minimum Go TLS version is // 1.2. In order to test rejection of lower versions, // manually set the version to 1.0 state.Version = version }) defer st.Close() st.wantGoAway(0, ErrCodeInadequateSecurity) } func TestServer_Rejects_TLSBadCipher(t testing.T) { st := newServerTester(t, nil, func(state tls.ConnectionState) { state.Version = tls.VersionTLS12 state.CipherSuite = tls.TLS_RSA_WITH_RC4_128_SHA }) defer st.Close() st.wantGoAway(0, ErrCodeInadequateSecurity) } func TestServer_Advertises_Common_Cipher(t testing.T) { ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { }, func(srv http.Server) { // Have the server configured with no specific cipher suites. // This tests that Go's defaults include the required one. srv.TLSConfig = nil }) // Have the client only support the one required by the spec. const requiredSuite = tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 tlsConfig := tlsConfigInsecure.Clone() tlsConfig.MaxVersion = tls.VersionTLS12 tlsConfig.CipherSuites = []uint16{requiredSuite} tr := &Transport{TLSClientConfig: tlsConfig} defer tr.CloseIdleConnections() req, err := http.NewRequest("GET", ts.URL, nil) if err != nil { t.Fatal(err) } res, err := tr.RoundTrip(req) if err != nil { t.Fatal(err) } res.Body.Close() } // testServerResponse sets up an idle HTTP/2 connection. The client function should // write a single request that must be handled by the handler. func testServerResponse(t testing.TB, handler func(http.ResponseWriter, http.Request) error, client func(serverTester), ) { errc := make(chan error, 1) st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { if r.Body == nil { t.Fatal("nil Body") } err := handler(w, r) select { case errc <- err: default: t.Errorf("unexpected duplicate request") } }) defer st.Close() st.greet() client(st) if err := <-errc; err != nil { t.Fatalf("Error in handler: %v", err) } } // readBodyHandler returns an http Handler func that reads len(want) // bytes from r.Body and fails t if the contents read were not // the value of want. func readBodyHandler(t testing.T, want string) func(w http.ResponseWriter, r http.Request) { return func(w http.ResponseWriter, r http.Request) { buf := make([]byte, len(want)) _, err := io.ReadFull(r.Body, buf) if err != nil { t.Error(err) return } if string(buf) != want { t.Errorf("read %q; want %q", buf, want) } } } func TestServer_MaxDecoderHeaderTableSize(t testing.T) { wantHeaderTableSize := uint32(initialHeaderTableSize 2) st := newServerTester(t, func(w http.ResponseWriter, r http.Request) {}, func(s Server) { s.MaxDecoderHeaderTableSize = wantHeaderTableSize }) defer st.Close() var advHeaderTableSize uint32 st.greetAndCheckSettings(func(s Setting) error { switch s.ID { case SettingHeaderTableSize: advHeaderTableSize = &s.Val } return nil }) if advHeaderTableSize == nil { t.Errorf("server didn't advertise a header table size") } else if got, want := advHeaderTableSize, wantHeaderTableSize; got != want { t.Errorf("server advertised a header table size of %d, want %d", got, want) } } func TestServer_MaxEncoderHeaderTableSize(t testing.T) { wantHeaderTableSize := uint32(initialHeaderTableSize / 2) st := newServerTester(t, func(w http.ResponseWriter, r http.Request) {}, func(s Server) { s.MaxEncoderHeaderTableSize = wantHeaderTableSize }) defer st.Close() st.greet() if got, want := st.sc.hpackEncoder.MaxDynamicTableSize(), wantHeaderTableSize; got != want { t.Errorf("server encoder is using a header table size of %d, want %d", got, want) } } // Issue 12843 func TestServerDoS_MaxHeaderListSize(t testing.T) { st := newServerTester(t, func(w http.ResponseWriter, r http.Request) {}) defer st.Close() // shake hands frameSize := defaultMaxReadFrameSize var advHeaderListSize uint32 st.greetAndCheckSettings(func(s Setting) error { switch s.ID { case SettingMaxFrameSize: if s.Val < minMaxFrameSize { frameSize = minMaxFrameSize } else if s.Val > maxFrameSize { frameSize = maxFrameSize } else { frameSize = int(s.Val) } case SettingMaxHeaderListSize: advHeaderListSize = &s.Val } return nil }) if advHeaderListSize == nil { t.Errorf("server didn't advertise a max header list size") } else if advHeaderListSize == 0 { t.Errorf("server advertised a max header list size of 0") } st.encodeHeaderField(":method", "GET") st.encodeHeaderField(":path", "/") st.encodeHeaderField(":scheme", "https") cookie := strings.Repeat("", 4058) st.encodeHeaderField("cookie", cookie) st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: st.headerBuf.Bytes(), EndStream: true, EndHeaders: false, }) // Capture the short encoding of a duplicate ~4K cookie, now // that we've already sent it once. st.headerBuf.Reset() st.encodeHeaderField("cookie", cookie) // Now send 1MB of it. const size = 1 << 20 b := bytes.Repeat(st.headerBuf.Bytes(), size/st.headerBuf.Len()) for len(b) > 0 { chunk := b if len(chunk) > frameSize { chunk = chunk[:frameSize] } b = b[len(chunk):] st.fr.WriteContinuation(1, len(b) == 0, chunk) } st.wantHeaders(wantHeader{ streamID: 1, endStream: false, header: http.Header{ ":status": []string{"431"}, "content-type": []string{"text/html; charset=utf-8"}, "content-length": []string{"63"}, }, }) } func TestServer_Response_Stream_With_Missing_Trailer(t testing.T) { testServerResponse(t, func(w http.ResponseWriter, r http.Request) error { w.Header().Set("Trailer", "test-trailer") return nil }, func(st serverTester) { getSlash(st) st.wantHeaders(wantHeader{ streamID: 1, endStream: false, }) st.wantData(wantData{ streamID: 1, endStream: true, size: 0, }) }) } func TestCompressionErrorOnWrite(t testing.T) { const maxStrLen = 8 << 10 var serverConfig http.Server st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { // No response body. }, func(s http.Server) { serverConfig = s serverConfig.MaxHeaderBytes = maxStrLen }) st.addLogFilter("connection error: COMPRESSION_ERROR") defer st.Close() st.greet() maxAllowed := st.sc.framer.maxHeaderStringLen() // Crank this up, now that we have a conn connected with the // hpack.Decoder's max string length set has been initialized // from the earlier low ~8K value. We want this higher so don't // hit the max header list size. We only want to test hitting // the max string size. serverConfig.MaxHeaderBytes = 1 << 20 // First a request with a header that's exactly the max allowed size // for the hpack compression. It's still too long for the header list // size, so we'll get the 431 error, but that keeps the compression // context still valid. hbf := st.encodeHeader("foo", strings.Repeat("a", maxAllowed)) st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: hbf, EndStream: true, EndHeaders: true, }) st.wantHeaders(wantHeader{ streamID: 1, endStream: false, header: http.Header{ ":status": []string{"431"}, "content-type": []string{"text/html; charset=utf-8"}, "content-length": []string{"63"}, }, }) df := readFrame[DataFrame](t, st) if !strings.Contains(string(df.Data()), "HTTP Error 431") { t.Errorf("Unexpected data body: %q", df.Data()) } if !df.StreamEnded() { t.Fatalf("expect data stream end") } // And now send one that's just one byte too big. hbf = st.encodeHeader("bar", strings.Repeat("b", maxAllowed+1)) st.writeHeaders(HeadersFrameParam{ StreamID: 3, BlockFragment: hbf, EndStream: true, EndHeaders: true, }) st.wantGoAway(3, ErrCodeCompression) } func TestCompressionErrorOnClose(t testing.T) { st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { // No response body. }) st.addLogFilter("connection error: COMPRESSION_ERROR") defer st.Close() st.greet() hbf := st.encodeHeader("foo", "bar") hbf = hbf[:len(hbf)-1] // truncate one byte from the end, so hpack.Decoder.Close fails. st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: hbf, EndStream: true, EndHeaders: true, }) st.wantGoAway(1, ErrCodeCompression) } // test that a server handler can read trailers from a client func TestServerReadsTrailers(t testing.T) { const testBody = "some test body" writeReq := func(st serverTester) { st.writeHeaders(HeadersFrameParam{ StreamID: 1, // clients send odd numbers BlockFragment: st.encodeHeader("trailer", "Foo, Bar", "trailer", "Baz"), EndStream: false, EndHeaders: true, }) st.writeData(1, false, []byte(testBody)) st.writeHeaders(HeadersFrameParam{ StreamID: 1, // clients send odd numbers BlockFragment: st.encodeHeaderRaw( "foo", "foov", "bar", "barv", "baz", "bazv", "surprise", "wasn't declared; shouldn't show up", ), EndStream: true, EndHeaders: true, }) } checkReq := func(r http.Request) { wantTrailer := http.Header{ "Foo": nil, "Bar": nil, "Baz": nil, } if !reflect.DeepEqual(r.Trailer, wantTrailer) { t.Errorf("initial Trailer = %v; want %v", r.Trailer, wantTrailer) } slurp, err := io.ReadAll(r.Body) if string(slurp) != testBody { t.Errorf("read body %q; want %q", slurp, testBody) } if err != nil { t.Fatalf("Body slurp: %v", err) } wantTrailerAfter := http.Header{ "Foo": {"foov"}, "Bar": {"barv"}, "Baz": {"bazv"}, } if !reflect.DeepEqual(r.Trailer, wantTrailerAfter) { t.Errorf("final Trailer = %v; want %v", r.Trailer, wantTrailerAfter) } } testServerRequest(t, writeReq, checkReq) } // test that a server handler can send trailers func TestServerWritesTrailers_WithFlush(t testing.T) { testServerWritesTrailers(t, true) } func TestServerWritesTrailers_WithoutFlush(t testing.T) { testServerWritesTrailers(t, false) } func testServerWritesTrailers(t testing.T, withFlush bool) { // See https://httpwg.github.io/specs/rfc7540.html#rfc.section.8.1.3 testServerResponse(t, func(w http.ResponseWriter, r http.Request) error { w.Header().Set("Trailer", "Server-Trailer-A, Server-Trailer-B") w.Header().Add("Trailer", "Server-Trailer-C") w.Header().Add("Trailer", "Transfer-Encoding, Content-Length, Trailer") // filtered // Regular headers: w.Header().Set("Foo", "Bar") w.Header().Set("Content-Length", "5") // len("Hello") io.WriteString(w, "Hello") if withFlush { w.(http.Flusher).Flush() } w.Header().Set("Server-Trailer-A", "valuea") w.Header().Set("Server-Trailer-C", "valuec") // skipping B // After a flush, random keys like Server-Surprise shouldn't show up: w.Header().Set("Server-Surpise", "surprise! this isn't predeclared!") // But we do permit promoting keys to trailers after a // flush if they start with the magic // otherwise-invalid "Trailer:" prefix: w.Header().Set("Trailer:Post-Header-Trailer", "hi1") w.Header().Set("Trailer:post-header-trailer2", "hi2") w.Header().Set("Trailer:Range", "invalid") w.Header().Set("Trailer:Foo\x01Bogus", "invalid") w.Header().Set("Transfer-Encoding", "should not be included; Forbidden by RFC 7230 4.1.2") w.Header().Set("Content-Length", "should not be included; Forbidden by RFC 7230 4.1.2") w.Header().Set("Trailer", "should not be included; Forbidden by RFC 7230 4.1.2") return nil }, func(st serverTester) { getSlash(st) st.wantHeaders(wantHeader{ streamID: 1, endStream: false, header: http.Header{ ":status": []string{"200"}, "foo": []string{"Bar"}, "trailer": []string{ "Server-Trailer-A, Server-Trailer-B", "Server-Trailer-C", "Transfer-Encoding, Content-Length, Trailer", }, "content-type": []string{"text/plain; charset=utf-8"}, "content-length": []string{"5"}, }, }) st.wantData(wantData{ streamID: 1, endStream: false, data: []byte("Hello"), }) st.wantHeaders(wantHeader{ streamID: 1, endStream: true, header: http.Header{ "post-header-trailer": []string{"hi1"}, "post-header-trailer2": []string{"hi2"}, "server-trailer-a": []string{"valuea"}, "server-trailer-c": []string{"valuec"}, }, }) }) } func TestServerWritesUndeclaredTrailers(t testing.T) { const trailer = "Trailer-Header" const value = "hi1" ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { w.Header().Set(http.TrailerPrefix+trailer, value) }) tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() cl := &http.Client{Transport: tr} resp, err := cl.Get(ts.URL) if err != nil { t.Fatal(err) } io.Copy(io.Discard, resp.Body) resp.Body.Close() if got, want := resp.Trailer.Get(trailer), value; got != want { t.Errorf("trailer %v = %q, want %q", trailer, got, want) } } // validate transmitted header field names & values // golang.org/issue/14048 func TestServerDoesntWriteInvalidHeaders(t testing.T) { testServerResponse(t, func(w http.ResponseWriter, r http.Request) error { w.Header().Add("OK1", "x") w.Header().Add("Bad:Colon", "x") // colon (non-token byte) in key w.Header().Add("Bad1\x00", "x") // null in key w.Header().Add("Bad2", "x\x00y") // null in value return nil }, func(st serverTester) { getSlash(st) st.wantHeaders(wantHeader{ streamID: 1, endStream: true, header: http.Header{ ":status": []string{"200"}, "ok1": []string{"x"}, "content-length": []string{"0"}, }, }) }) } func BenchmarkServerGets(b testing.B) { disableGoroutineTracking(b) b.ReportAllocs() const msg = "Hello, world" st := newServerTesterWithRealConn(b, func(w http.ResponseWriter, r http.Request) { io.WriteString(w, msg) }) defer st.Close() st.greet() // Give the server quota to reply. (plus it has the 64KB) if err := st.fr.WriteWindowUpdate(0, uint32(b.Nlen(msg))); err != nil { b.Fatal(err) } for i := 0; i < b.N; i++ { id := 1 + uint32(i)2 st.writeHeaders(HeadersFrameParam{ StreamID: id, BlockFragment: st.encodeHeader(), EndStream: true, EndHeaders: true, }) st.wantFrameType(FrameHeaders) if df := readFrame[DataFrame](b, st); !df.StreamEnded() { b.Fatalf("DATA didn't have END_STREAM; got %v", df) } } } func BenchmarkServerPosts(b testing.B) { disableGoroutineTracking(b) b.ReportAllocs() const msg = "Hello, world" st := newServerTesterWithRealConn(b, func(w http.ResponseWriter, r http.Request) { // Consume the (empty) body from th peer before replying, otherwise // the server will sometimes (depending on scheduling) send the peer a // a RST_STREAM with the CANCEL error code. if n, err := io.Copy(io.Discard, r.Body); n != 0 \|\| err != nil { b.Errorf("Copy error; got %v, %v; want 0, nil", n, err) } io.WriteString(w, msg) }) defer st.Close() st.greet() // Give the server quota to reply. (plus it has the 64KB) if err := st.fr.WriteWindowUpdate(0, uint32(b.Nlen(msg))); err != nil { b.Fatal(err) } for i := 0; i < b.N; i++ { id := 1 + uint32(i)2 st.writeHeaders(HeadersFrameParam{ StreamID: id, BlockFragment: st.encodeHeader(":method", "POST"), EndStream: false, EndHeaders: true, }) st.writeData(id, true, nil) st.wantFrameType(FrameHeaders) if df := readFrame[DataFrame](b, st); !df.StreamEnded() { b.Fatalf("DATA didn't have END_STREAM; got %v", df) } } } // Send a stream of messages from server to client in separate data frames. // Brings up performance issues seen in long streams. // Created to show problem in go issue #18502 func BenchmarkServerToClientStreamDefaultOptions(b testing.B) { benchmarkServerToClientStream(b) } // Justification for Change-Id: Iad93420ef6c3918f54249d867098f1dadfa324d8 // Expect to see memory/alloc reduction by opting in to Frame reuse with the Framer. func BenchmarkServerToClientStreamReuseFrames(b testing.B) { benchmarkServerToClientStream(b, optFramerReuseFrames) } func benchmarkServerToClientStream(b testing.B, newServerOpts ...interface{}) { disableGoroutineTracking(b) b.ReportAllocs() const msgLen = 1 // default window size const windowSize = 1<<16 - 1 // next message to send from the server and for the client to expect nextMsg := func(i int) []byte { msg := make([]byte, msgLen) msg[0] = byte(i) if len(msg) != msgLen { panic("invalid test setup msg length") } return msg } st := newServerTesterWithRealConn(b, func(w http.ResponseWriter, r http.Request) { // Consume the (empty) body from th peer before replying, otherwise // the server will sometimes (depending on scheduling) send the peer a // a RST_STREAM with the CANCEL error code. if n, err := io.Copy(io.Discard, r.Body); n != 0 \|\| err != nil { b.Errorf("Copy error; got %v, %v; want 0, nil", n, err) } for i := 0; i < b.N; i += 1 { w.Write(nextMsg(i)) w.(http.Flusher).Flush() } }, newServerOpts...) defer st.Close() st.greet() const id = uint32(1) st.writeHeaders(HeadersFrameParam{ StreamID: id, BlockFragment: st.encodeHeader(":method", "POST"), EndStream: false, EndHeaders: true, }) st.writeData(id, true, nil) st.wantHeaders(wantHeader{ streamID: 1, endStream: false, }) var pendingWindowUpdate = uint32(0) for i := 0; i < b.N; i += 1 { expected := nextMsg(i) st.wantData(wantData{ streamID: 1, endStream: false, data: expected, }) // try to send infrequent but large window updates so they don't overwhelm the test pendingWindowUpdate += uint32(len(expected)) if pendingWindowUpdate >= windowSize/2 { if err := st.fr.WriteWindowUpdate(0, pendingWindowUpdate); err != nil { b.Fatal(err) } if err := st.fr.WriteWindowUpdate(id, pendingWindowUpdate); err != nil { b.Fatal(err) } pendingWindowUpdate = 0 } } st.wantData(wantData{ streamID: 1, endStream: true, }) } // go-fuzz bug, originally reported at https://github.com/bradfitz/http2/issues/53 // Verify we don't hang. func TestIssue53(t testing.T) { const data = "PRI * HTTP/2.0\r\n\r\nSM" + "\r\n\r\n\x00\x00\x00\x01\ainfinfin\ad" s := &http.Server{ ErrorLog: log.New(io.MultiWriter(stderrv(), twriter{t: t}), "", log.LstdFlags), Handler: http.HandlerFunc(func(w http.ResponseWriter, req http.Request) { w.Write([]byte("hello")) }), } s2 := &Server{ MaxReadFrameSize: 1 << 16, PermitProhibitedCipherSuites: true, } c := &issue53Conn{[]byte(data), false, false} s2.ServeConn(c, &ServeConnOpts{BaseConfig: s}) if !c.closed { t.Fatal("connection is not closed") } } type issue53Conn struct { data []byte closed bool written bool } func (c issue53Conn) Read(b []byte) (n int, err error) { if len(c.data) == 0 { return 0, io.EOF } n = copy(b, c.data) c.data = c.data[n:] return } func (c issue53Conn) Write(b []byte) (n int, err error) { c.written = true return len(b), nil } func (c issue53Conn) Close() error { c.closed = true return nil } func (c issue53Conn) LocalAddr() net.Addr { return &net.TCPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 49706} } func (c issue53Conn) RemoteAddr() net.Addr { return &net.TCPAddr{IP: net.IPv4(127, 0, 0, 1), Port: 49706} } func (c issue53Conn) SetDeadline(t time.Time) error { return nil } func (c issue53Conn) SetReadDeadline(t time.Time) error { return nil } func (c issue53Conn) SetWriteDeadline(t time.Time) error { return nil } // golang.org/issue/33839 func TestServeConnOptsNilReceiverBehavior(t testing.T) { defer func() { if r := recover(); r != nil { t.Errorf("got a panic that should not happen: %v", r) } }() var o ServeConnOpts if o.context() == nil { t.Error("o.context should not return nil") } if o.baseConfig() == nil { t.Error("o.baseConfig should not return nil") } if o.handler() == nil { t.Error("o.handler should not return nil") } } // golang.org/issue/12895 func TestConfigureServer(t testing.T) { tests := []struct { name string tlsConfig tls.Config wantErr string }{ { name: "empty server", }, { name: "empty CipherSuites", tlsConfig: &tls.Config{}, }, { name: "bad CipherSuites but MinVersion TLS 1.3", tlsConfig: &tls.Config{ MinVersion: tls.VersionTLS13, CipherSuites: []uint16{tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384}, }, }, { name: "just the required cipher suite", tlsConfig: &tls.Config{ CipherSuites: []uint16{tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256}, }, }, { name: "just the alternative required cipher suite", tlsConfig: &tls.Config{ CipherSuites: []uint16{tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256}, }, }, { name: "missing required cipher suite", tlsConfig: &tls.Config{ CipherSuites: []uint16{tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384}, }, wantErr: "is missing an HTTP/2-required", }, { name: "required after bad", tlsConfig: &tls.Config{ CipherSuites: []uint16{tls.TLS_RSA_WITH_RC4_128_SHA, tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256}, }, }, { name: "bad after required", tlsConfig: &tls.Config{ CipherSuites: []uint16{tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, tls.TLS_RSA_WITH_RC4_128_SHA}, }, }, } for _, tt := range tests { srv := &http.Server{TLSConfig: tt.tlsConfig} err := ConfigureServer(srv, nil) if (err != nil) != (tt.wantErr != "") { if tt.wantErr != "" { t.Errorf("%s: success, but want error", tt.name) } else { t.Errorf("%s: unexpected error: %v", tt.name, err) } } if err != nil && tt.wantErr != "" && !strings.Contains(err.Error(), tt.wantErr) { t.Errorf("%s: err = %v; want substring %q", tt.name, err, tt.wantErr) } if err == nil && !srv.TLSConfig.PreferServerCipherSuites { t.Errorf("%s: PreferServerCipherSuite is false; want true", tt.name) } } } func TestServerNoAutoContentLengthOnHead(t testing.T) { st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { // No response body. (or smaller than one frame) }) defer st.Close() st.greet() st.writeHeaders(HeadersFrameParam{ StreamID: 1, // clients send odd numbers BlockFragment: st.encodeHeader(":method", "HEAD"), EndStream: true, EndHeaders: true, }) st.wantHeaders(wantHeader{ streamID: 1, endStream: true, header: http.Header{ ":status": []string{"200"}, }, }) } // golang.org/issue/13495 func TestServerNoDuplicateContentType(t testing.T) { st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { w.Header()["Content-Type"] = []string{""} fmt.Fprintf(w, "<html><head></head><body>hi</body></html>") }) defer st.Close() st.greet() st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: st.encodeHeader(), EndStream: true, EndHeaders: true, }) st.wantHeaders(wantHeader{ streamID: 1, endStream: false, header: http.Header{ ":status": []string{"200"}, "content-type": []string{""}, "content-length": []string{"41"}, }, }) } func TestServerContentLengthCanBeDisabled(t testing.T) { st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { w.Header()["Content-Length"] = nil fmt.Fprintf(w, "OK") }) defer st.Close() st.greet() st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: st.encodeHeader(), EndStream: true, EndHeaders: true, }) st.wantHeaders(wantHeader{ streamID: 1, endStream: false, header: http.Header{ ":status": []string{"200"}, "content-type": []string{"text/plain; charset=utf-8"}, }, }) } func disableGoroutineTracking(t testing.TB) { old := DebugGoroutines DebugGoroutines = false t.Cleanup(func() { DebugGoroutines = old }) } func BenchmarkServer_GetRequest(b testing.B) { disableGoroutineTracking(b) b.ReportAllocs() const msg = "Hello, world." st := newServerTesterWithRealConn(b, func(w http.ResponseWriter, r http.Request) { n, err := io.Copy(io.Discard, r.Body) if err != nil \|\| n > 0 { b.Errorf("Read %d bytes, error %v; want 0 bytes.", n, err) } io.WriteString(w, msg) }) defer st.Close() st.greet() // Give the server quota to reply. (plus it has the 64KB) if err := st.fr.WriteWindowUpdate(0, uint32(b.Nlen(msg))); err != nil { b.Fatal(err) } hbf := st.encodeHeader(":method", "GET") for i := 0; i < b.N; i++ { streamID := uint32(1 + 2i) st.writeHeaders(HeadersFrameParam{ StreamID: streamID, BlockFragment: hbf, EndStream: true, EndHeaders: true, }) st.wantFrameType(FrameHeaders) st.wantFrameType(FrameData) } } func BenchmarkServer_PostRequest(b testing.B) { disableGoroutineTracking(b) b.ReportAllocs() const msg = "Hello, world." st := newServerTesterWithRealConn(b, func(w http.ResponseWriter, r http.Request) { n, err := io.Copy(io.Discard, r.Body) if err != nil \|\| n > 0 { b.Errorf("Read %d bytes, error %v; want 0 bytes.", n, err) } io.WriteString(w, msg) }) defer st.Close() st.greet() // Give the server quota to reply. (plus it has the 64KB) if err := st.fr.WriteWindowUpdate(0, uint32(b.Nlen(msg))); err != nil { b.Fatal(err) } hbf := st.encodeHeader(":method", "POST") for i := 0; i < b.N; i++ { streamID := uint32(1 + 2i) st.writeHeaders(HeadersFrameParam{ StreamID: streamID, BlockFragment: hbf, EndStream: false, EndHeaders: true, }) st.writeData(streamID, true, nil) st.wantFrameType(FrameHeaders) st.wantFrameType(FrameData) } } type connStateConn struct { net.Conn cs tls.ConnectionState } func (c connStateConn) ConnectionState() tls.ConnectionState { return c.cs } // golang.org/issue/12737 -- handle any net.Conn, not just // tls.Conn. func TestServerHandleCustomConn(t testing.T) { var s Server c1, c2 := net.Pipe() clientDone := make(chan struct{}) handlerDone := make(chan struct{}) var req http.Request go func() { defer close(clientDone) defer c2.Close() fr := NewFramer(c2, c2) io.WriteString(c2, ClientPreface) fr.WriteSettings() fr.WriteSettingsAck() f, err := fr.ReadFrame() if err != nil { t.Error(err) return } if sf, ok := f.(SettingsFrame); !ok \|\| sf.IsAck() { t.Errorf("Got %v; want non-ACK SettingsFrame", summarizeFrame(f)) return } f, err = fr.ReadFrame() if err != nil { t.Error(err) return } if sf, ok := f.(SettingsFrame); !ok \|\| !sf.IsAck() { t.Errorf("Got %v; want ACK SettingsFrame", summarizeFrame(f)) return } var henc hpackEncoder fr.WriteHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: henc.encodeHeaderRaw(t, ":method", "GET", ":path", "/", ":scheme", "https", ":authority", "foo.com"), EndStream: true, EndHeaders: true, }) go io.Copy(io.Discard, c2) <-handlerDone }() const testString = "my custom ConnectionState" fakeConnState := tls.ConnectionState{ ServerName: testString, Version: tls.VersionTLS12, CipherSuite: cipher_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, } go s.ServeConn(connStateConn{c1, fakeConnState}, &ServeConnOpts{ BaseConfig: &http.Server{ Handler: http.HandlerFunc(func(w http.ResponseWriter, r http.Request) { defer close(handlerDone) req = r }), }}) <-clientDone if req.TLS == nil { t.Fatalf("Request.TLS is nil. Got: %#v", req) } if req.TLS.ServerName != testString { t.Fatalf("Request.TLS = %+v; want ServerName of %q", req.TLS, testString) } } // golang.org/issue/14214 func TestServer_Rejects_ConnHeaders(t testing.T) { st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { t.Error("should not get to Handler") }) defer st.Close() st.greet() st.bodylessReq1("connection", "foo") st.wantHeaders(wantHeader{ streamID: 1, endStream: false, header: http.Header{ ":status": []string{"400"}, "content-type": []string{"text/plain; charset=utf-8"}, "x-content-type-options": []string{"nosniff"}, "content-length": []string{"51"}, }, }) } type hpackEncoder struct { enc hpack.Encoder buf bytes.Buffer } func (he hpackEncoder) encodeHeaderRaw(t testing.T, headers ...string) []byte { if len(headers)%2 == 1 { panic("odd number of kv args") } he.buf.Reset() if he.enc == nil { he.enc = hpack.NewEncoder(&he.buf) } for len(headers) > 0 { k, v := headers[0], headers[1] err := he.enc.WriteField(hpack.HeaderField{Name: k, Value: v}) if err != nil { t.Fatalf("HPACK encoding error for %q/%q: %v", k, v, err) } headers = headers[2:] } return he.buf.Bytes() } func TestCheckValidHTTP2Request(t testing.T) { tests := []struct { h http.Header want error }{ { h: http.Header{"Te": {"trailers"}}, want: nil, }, { h: http.Header{"Te": {"trailers", "bogus"}}, want: errors.New(`request header "TE" may only be "trailers" in HTTP/2`), }, { h: http.Header{"Foo": {""}}, want: nil, }, { h: http.Header{"Connection": {""}}, want: errors.New(`request header "Connection" is not valid in HTTP/2`), }, { h: http.Header{"Proxy-Connection": {""}}, want: errors.New(`request header "Proxy-Connection" is not valid in HTTP/2`), }, { h: http.Header{"Keep-Alive": {""}}, want: errors.New(`request header "Keep-Alive" is not valid in HTTP/2`), }, { h: http.Header{"Upgrade": {""}}, want: errors.New(`request header "Upgrade" is not valid in HTTP/2`), }, } for i, tt := range tests { got := checkValidHTTP2RequestHeaders(tt.h) if !equalError(got, tt.want) { t.Errorf("%d. checkValidHTTP2Request = %v; want %v", i, got, tt.want) } } } // golang.org/issue/14030 func TestExpect100ContinueAfterHandlerWrites(t testing.T) { const msg = "Hello" const msg2 = "World" doRead := make(chan bool, 1) defer close(doRead) // fallback cleanup ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { io.WriteString(w, msg) w.(http.Flusher).Flush() // Do a read, which might force a 100-continue status to be sent. <-doRead r.Body.Read(make([]byte, 10)) io.WriteString(w, msg2) }) tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() req, _ := http.NewRequest("POST", ts.URL, io.LimitReader(neverEnding('A'), 2<<20)) req.Header.Set("Expect", "100-continue") res, err := tr.RoundTrip(req) if err != nil { t.Fatal(err) } defer res.Body.Close() buf := make([]byte, len(msg)) if _, err := io.ReadFull(res.Body, buf); err != nil { t.Fatal(err) } if string(buf) != msg { t.Fatalf("msg = %q; want %q", buf, msg) } doRead <- true if _, err := io.ReadFull(res.Body, buf); err != nil { t.Fatal(err) } if string(buf) != msg2 { t.Fatalf("second msg = %q; want %q", buf, msg2) } } type funcReader func([]byte) (n int, err error) func (f funcReader) Read(p []byte) (n int, err error) { return f(p) } // golang.org/issue/16481 -- return flow control when streams close with unread data. // (The Server version of the bug. See also TestUnreadFlowControlReturned_Transport) func TestUnreadFlowControlReturned_Server(t testing.T) { for _, tt := range []struct { name string reqFn func(r http.Request) }{ { "body-open", func(r http.Request) {}, }, { "body-closed", func(r http.Request) { r.Body.Close() }, }, { "read-1-byte-and-close", func(r http.Request) { b := make([]byte, 1) r.Body.Read(b) r.Body.Close() }, }, } { t.Run(tt.name, func(t testing.T) { unblock := make(chan bool, 1) defer close(unblock) ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { // Don't read the 16KB request body. Wait until the client's // done sending it and then return. This should cause the Server // to then return those 16KB of flow control to the client. tt.reqFn(r) <-unblock }) tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() // This previously hung on the 4th iteration. iters := 100 if testing.Short() { iters = 20 } for i := 0; i < iters; i++ { body := io.MultiReader( io.LimitReader(neverEnding('A'), 16<<10), funcReader(func([]byte) (n int, err error) { unblock <- true return 0, io.EOF }), ) req, _ := http.NewRequest("POST", ts.URL, body) res, err := tr.RoundTrip(req) if err != nil { t.Fatal(tt.name, err) } res.Body.Close() } }) } } func TestServerReturnsStreamAndConnFlowControlOnBodyClose(t testing.T) { unblockHandler := make(chan struct{}) defer close(unblockHandler) st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { r.Body.Close() w.WriteHeader(200) w.(http.Flusher).Flush() <-unblockHandler }) defer st.Close() st.greet() st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: st.encodeHeader(), EndHeaders: true, }) st.wantHeaders(wantHeader{ streamID: 1, endStream: false, }) const size = inflowMinRefresh // enough to trigger flow control return st.writeData(1, false, make([]byte, size)) st.wantWindowUpdate(0, size) // conn-level flow control is returned unblockHandler <- struct{}{} st.wantData(wantData{ streamID: 1, endStream: true, }) } func TestServerIdleTimeout(t testing.T) { if testing.Short() { t.Skip("skipping in short mode") } st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { }, func(h2s Server) { h2s.IdleTimeout = 500 time.Millisecond }) defer st.Close() st.greet() st.advance(500 * time.Millisecond) st.wantGoAway(0, ErrCodeNo) } func TestServerIdleTimeout_AfterRequest(t testing.T) { if testing.Short() { t.Skip("skipping in short mode") } const ( requestTimeout = 2 time.Second idleTimeout = 1 * time.Second ) var st serverTester st = newServerTester(t, func(w http.ResponseWriter, r http.Request) { st.group.Sleep(requestTimeout) }, func(h2s Server) { h2s.IdleTimeout = idleTimeout }) defer st.Close() st.greet() // Send a request which takes twice the timeout. Verifies the // idle timeout doesn't fire while we're in a request: st.bodylessReq1() st.advance(requestTimeout) st.wantHeaders(wantHeader{ streamID: 1, endStream: true, }) // But the idle timeout should be rearmed after the request // is done: st.advance(idleTimeout) st.wantGoAway(1, ErrCodeNo) } // grpc-go closes the Request.Body currently with a Read. // Verify that it doesn't race. // See https://github.com/grpc/grpc-go/pull/938 func TestRequestBodyReadCloseRace(t testing.T) { for i := 0; i < 100; i++ { body := &requestBody{ pipe: &pipe{ b: new(bytes.Buffer), }, } body.pipe.CloseWithError(io.EOF) done := make(chan bool, 1) buf := make([]byte, 10) go func() { time.Sleep(1 * time.Millisecond) body.Close() done <- true }() body.Read(buf) <-done } } func TestIssue20704Race(t testing.T) { if testing.Short() && os.Getenv("GO_BUILDER_NAME") == "" { t.Skip("skipping in short mode") } const ( itemSize = 1 << 10 itemCount = 100 ) ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { for i := 0; i < itemCount; i++ { _, err := w.Write(make([]byte, itemSize)) if err != nil { return } } }) tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() cl := &http.Client{Transport: tr} for i := 0; i < 1000; i++ { resp, err := cl.Get(ts.URL) if err != nil { t.Fatal(err) } // Force a RST stream to the server by closing without // reading the body: resp.Body.Close() } } func TestServer_Rejects_TooSmall(t testing.T) { testServerResponse(t, func(w http.ResponseWriter, r http.Request) error { io.ReadAll(r.Body) return nil }, func(st serverTester) { st.writeHeaders(HeadersFrameParam{ StreamID: 1, // clients send odd numbers BlockFragment: st.encodeHeader( ":method", "POST", "content-length", "4", ), EndStream: false, // to say DATA frames are coming EndHeaders: true, }) st.writeData(1, true, []byte("12345")) st.wantRSTStream(1, ErrCodeProtocol) st.wantFlowControlConsumed(0, 0) }) } // Tests that a handler setting "Connection: close" results in a GOAWAY being sent, // and the connection still completing. func TestServerHandlerConnectionClose(t testing.T) { unblockHandler := make(chan bool, 1) testServerResponse(t, func(w http.ResponseWriter, r http.Request) error { w.Header().Set("Connection", "close") w.Header().Set("Foo", "bar") w.(http.Flusher).Flush() <-unblockHandler return nil }, func(st serverTester) { defer close(unblockHandler) // backup; in case of errors st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: st.encodeHeader(), EndStream: true, EndHeaders: true, }) var sawGoAway bool var sawRes bool var sawWindowUpdate bool for { f := st.readFrame() if f == nil { break } switch f := f.(type) { case GoAwayFrame: sawGoAway = true if f.LastStreamID != 1 \|\| f.ErrCode != ErrCodeNo { t.Errorf("unexpected GOAWAY frame: %v", summarizeFrame(f)) } // Create a stream and reset it. // The server should ignore the stream. st.writeHeaders(HeadersFrameParam{ StreamID: 3, BlockFragment: st.encodeHeader(), EndStream: false, EndHeaders: true, }) st.fr.WriteRSTStream(3, ErrCodeCancel) // Create a stream and send data to it. // The server should return flow control, even though it // does not process the stream. st.writeHeaders(HeadersFrameParam{ StreamID: 5, BlockFragment: st.encodeHeader(), EndStream: false, EndHeaders: true, }) // Write enough data to trigger a window update. st.writeData(5, true, make([]byte, 1<<19)) case HeadersFrame: goth := st.decodeHeader(f.HeaderBlockFragment()) wanth := [][2]string{ {":status", "200"}, {"foo", "bar"}, } if !reflect.DeepEqual(goth, wanth) { t.Errorf("got headers %v; want %v", goth, wanth) } sawRes = true case DataFrame: if f.StreamID != 1 \|\| !f.StreamEnded() \|\| len(f.Data()) != 0 { t.Errorf("unexpected DATA frame: %v", summarizeFrame(f)) } case WindowUpdateFrame: if !sawGoAway { t.Errorf("unexpected WINDOW_UPDATE frame: %v", summarizeFrame(f)) return } if f.StreamID != 0 { st.t.Fatalf("WindowUpdate StreamID = %d; want 5", f.FrameHeader.StreamID) return } sawWindowUpdate = true unblockHandler <- true st.sync() st.advance(goAwayTimeout) default: t.Logf("unexpected frame: %v", summarizeFrame(f)) } } if !sawGoAway { t.Errorf("didn't see GOAWAY") } if !sawRes { t.Errorf("didn't see response") } if !sawWindowUpdate { t.Errorf("didn't see WINDOW_UPDATE") } }) } func TestServer_Headers_HalfCloseRemote(t testing.T) { var st serverTester writeData := make(chan bool) writeHeaders := make(chan bool) leaveHandler := make(chan bool) st = newServerTester(t, func(w http.ResponseWriter, r http.Request) { if st.stream(1) == nil { t.Errorf("nil stream 1 in handler") } if got, want := st.streamState(1), stateOpen; got != want { t.Errorf("in handler, state is %v; want %v", got, want) } writeData <- true if n, err := r.Body.Read(make([]byte, 1)); n != 0 \|\| err != io.EOF { t.Errorf("body read = %d, %v; want 0, EOF", n, err) } if got, want := st.streamState(1), stateHalfClosedRemote; got != want { t.Errorf("in handler, state is %v; want %v", got, want) } writeHeaders <- true <-leaveHandler }) st.greet() st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: st.encodeHeader(), EndStream: false, // keep it open EndHeaders: true, }) <-writeData st.writeData(1, true, nil) <-writeHeaders st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: st.encodeHeader(), EndStream: false, // keep it open EndHeaders: true, }) defer close(leaveHandler) st.wantRSTStream(1, ErrCodeStreamClosed) } func TestServerGracefulShutdown(t testing.T) { handlerDone := make(chan struct{}) st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { <-handlerDone w.Header().Set("x-foo", "bar") }) defer st.Close() st.greet() st.bodylessReq1() st.sync() st.h1server.Shutdown(context.Background()) st.wantGoAway(1, ErrCodeNo) close(handlerDone) st.sync() st.wantHeaders(wantHeader{ streamID: 1, endStream: true, header: http.Header{ ":status": []string{"200"}, "x-foo": []string{"bar"}, "content-length": []string{"0"}, }, }) n, err := st.cc.Read([]byte{0}) if n != 0 \|\| err == nil { t.Errorf("Read = %v, %v; want 0, non-nil", n, err) } } // Issue 31753: don't sniff when Content-Encoding is set func TestContentEncodingNoSniffing(t testing.T) { type resp struct { name string body []byte // setting Content-Encoding as an interface instead of a string // directly, so as to differentiate between 3 states: // unset, empty string "" and set string "foo/bar". contentEncoding interface{} wantContentType string } resps := []resp{ { name: "gzip content-encoding, gzipped", // don't sniff. contentEncoding: "application/gzip", wantContentType: "", body: func() []byte { buf := new(bytes.Buffer) gzw := gzip.NewWriter(buf) gzw.Write([]byte("doctype html><p>Hello</p>")) gzw.Close() return buf.Bytes() }(), }, { name: "zlib content-encoding, zlibbed", // don't sniff. contentEncoding: "application/zlib", wantContentType: "", body: func() []byte { buf := new(bytes.Buffer) zw := zlib.NewWriter(buf) zw.Write([]byte("doctype html><p>Hello</p>")) zw.Close() return buf.Bytes() }(), }, { name: "no content-encoding", // must sniff. wantContentType: "application/x-gzip", body: func() []byte { buf := new(bytes.Buffer) gzw := gzip.NewWriter(buf) gzw.Write([]byte("doctype html><p>Hello</p>")) gzw.Close() return buf.Bytes() }(), }, { name: "phony content-encoding", // don't sniff. contentEncoding: "foo/bar", body: []byte("doctype html><p>Hello</p>"), }, { name: "empty but set content-encoding", contentEncoding: "", wantContentType: "audio/mpeg", body: []byte("ID3"), }, } for _, tt := range resps { t.Run(tt.name, func(t testing.T) { ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { if tt.contentEncoding != nil { w.Header().Set("Content-Encoding", tt.contentEncoding.(string)) } w.Write(tt.body) }) tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() req, _ := http.NewRequest("GET", ts.URL, nil) res, err := tr.RoundTrip(req) if err != nil { t.Fatalf("GET %s: %v", ts.URL, err) } defer res.Body.Close() g := res.Header.Get("Content-Encoding") t.Logf("%s: Content-Encoding: %s", ts.URL, g) if w := tt.contentEncoding; g != w { if w != nil { // The case where contentEncoding was set explicitly. t.Errorf("Content-Encoding mismatch\n\tgot: %q\n\twant: %q", g, w) } else if g != "" { // "" should be the equivalent when the contentEncoding is unset. t.Errorf("Unexpected Content-Encoding %q", g) } } g = res.Header.Get("Content-Type") if w := tt.wantContentType; g != w { t.Errorf("Content-Type mismatch\n\tgot: %q\n\twant: %q", g, w) } t.Logf("%s: Content-Type: %s", ts.URL, g) }) } } func TestServerWindowUpdateOnBodyClose(t testing.T) { const windowSize = 65535 * 2 content := make([]byte, windowSize) blockCh := make(chan bool) errc := make(chan error, 1) st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { buf := make([]byte, 4) n, err := io.ReadFull(r.Body, buf) if err != nil { errc <- err return } if n != len(buf) { errc <- fmt.Errorf("too few bytes read: %d", n) return } blockCh <- true <-blockCh errc <- nil }, func(s Server) { s.MaxUploadBufferPerConnection = windowSize s.MaxUploadBufferPerStream = windowSize }) defer st.Close() st.greet() st.writeHeaders(HeadersFrameParam{ StreamID: 1, // clients send odd numbers BlockFragment: st.encodeHeader( ":method", "POST", "content-length", strconv.Itoa(len(content)), ), EndStream: false, // to say DATA frames are coming EndHeaders: true, }) st.writeData(1, false, content[:windowSize/2]) <-blockCh st.stream(1).body.CloseWithError(io.EOF) blockCh <- true // Wait for flow control credit for the portion of the request written so far. increments := windowSize / 2 for { f := st.readFrame() if f == nil { break } if wu, ok := f.(WindowUpdateFrame); ok && wu.StreamID == 0 { increments -= int(wu.Increment) if increments == 0 { break } } } // Writing data after the stream is reset immediately returns flow control credit. st.writeData(1, false, content[windowSize/2:]) st.wantWindowUpdate(0, windowSize/2) if err := <-errc; err != nil { t.Error(err) } } func TestNoErrorLoggedOnPostAfterGOAWAY(t testing.T) { st := newServerTester(t, func(w http.ResponseWriter, r http.Request) {}) defer st.Close() st.greet() content := "some content" st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: st.encodeHeader( ":method", "POST", "content-length", strconv.Itoa(len(content)), ), EndStream: false, EndHeaders: true, }) st.wantHeaders(wantHeader{ streamID: 1, endStream: true, }) st.sc.startGracefulShutdown() st.wantRSTStream(1, ErrCodeNo) st.wantGoAway(1, ErrCodeNo) st.writeData(1, true, []byte(content)) st.Close() if bytes.Contains(st.serverLogBuf.Bytes(), []byte("PROTOCOL_ERROR")) { t.Error("got protocol error") } } func TestServerSendsProcessing(t testing.T) { testServerResponse(t, func(w http.ResponseWriter, r http.Request) error { w.WriteHeader(http.StatusProcessing) w.Write([]byte("stuff")) return nil }, func(st serverTester) { getSlash(st) st.wantHeaders(wantHeader{ streamID: 1, endStream: false, header: http.Header{ ":status": []string{"102"}, }, }) st.wantHeaders(wantHeader{ streamID: 1, endStream: false, header: http.Header{ ":status": []string{"200"}, "content-type": []string{"text/plain; charset=utf-8"}, "content-length": []string{"5"}, }, }) }) } func TestServerSendsEarlyHints(t testing.T) { testServerResponse(t, func(w http.ResponseWriter, r http.Request) error { h := w.Header() h.Add("Content-Length", "123") h.Add("Link", "</style.css>; rel=preload; as=style") h.Add("Link", "</script.js>; rel=preload; as=script") w.WriteHeader(http.StatusEarlyHints) h.Add("Link", "</foo.js>; rel=preload; as=script") w.WriteHeader(http.StatusEarlyHints) w.Write([]byte("stuff")) return nil }, func(st serverTester) { getSlash(st) st.wantHeaders(wantHeader{ streamID: 1, endStream: false, header: http.Header{ ":status": []string{"103"}, "link": []string{ "</style.css>; rel=preload; as=style", "</script.js>; rel=preload; as=script", }, }, }) st.wantHeaders(wantHeader{ streamID: 1, endStream: false, header: http.Header{ ":status": []string{"103"}, "link": []string{ "</style.css>; rel=preload; as=style", "</script.js>; rel=preload; as=script", "</foo.js>; rel=preload; as=script", }, }, }) st.wantHeaders(wantHeader{ streamID: 1, endStream: false, header: http.Header{ ":status": []string{"200"}, "link": []string{ "</style.css>; rel=preload; as=style", "</script.js>; rel=preload; as=script", "</foo.js>; rel=preload; as=script", }, "content-type": []string{"text/plain; charset=utf-8"}, "content-length": []string{"123"}, }, }) }) } func TestProtocolErrorAfterGoAway(t testing.T) { st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { io.Copy(io.Discard, r.Body) }) defer st.Close() st.greet() content := "some content" st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: st.encodeHeader( ":method", "POST", "content-length", strconv.Itoa(len(content)), ), EndStream: false, EndHeaders: true, }) st.writeData(1, false, []byte(content[:5])) // Send a GOAWAY with ErrCodeNo, followed by a bogus window update. // The server should close the connection. if err := st.fr.WriteGoAway(1, ErrCodeNo, nil); err != nil { t.Fatal(err) } if err := st.fr.WriteWindowUpdate(0, 1<<31-1); err != nil { t.Fatal(err) } st.advance(goAwayTimeout) st.wantGoAway(1, ErrCodeNo) st.wantClosed() } func TestServerInitialFlowControlWindow(t testing.T) { for _, want := range []int32{ 65535, 1 << 19, 1 << 21, // For MaxUploadBufferPerConnection values in the range // (65535, 655352), we don't send an initial WINDOW_UPDATE // because we only send flow control when the window drops // below half of the maximum. Perhaps it would be nice to // test this case, but we currently do not. 65535 2, } { t.Run(fmt.Sprint(want), func(t testing.T) { st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { }, func(s Server) { s.MaxUploadBufferPerConnection = want }) st.writePreface() st.writeSettings() _ = readFrame[SettingsFrame](t, st) st.writeSettingsAck() st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: st.encodeHeader(), EndStream: true, EndHeaders: true, }) window := 65535 Frames: for { f := st.readFrame() switch f := f.(type) { case WindowUpdateFrame: if f.FrameHeader.StreamID != 0 { t.Errorf("WindowUpdate StreamID = %d; want 0", f.FrameHeader.StreamID) return } window += int(f.Increment) case HeadersFrame: break Frames case nil: break Frames default: } } if window != int(want) { t.Errorf("got initial flow control window = %v, want %v", window, want) } }) } } // TestCanonicalHeaderCacheGrowth verifies that the canonical header cache // size is capped to a reasonable level. func TestCanonicalHeaderCacheGrowth(t testing.T) { for _, size := range []int{1, (1 << 20) - 10} { base := strings.Repeat("X", size) sc := &serverConn{ serveG: newGoroutineLock(), } count := 0 added := 0 for added < 10maxCachedCanonicalHeadersKeysSize { h := fmt.Sprintf("%v-%v", base, count) c := sc.canonicalHeader(h) if len(h) != len(c) { t.Errorf("sc.canonicalHeader(%q) = %q, want same length", h, c) } count++ added += len(h) } total := 0 for k, v := range sc.canonHeader { total += len(k) + len(v) + 100 } if total > maxCachedCanonicalHeadersKeysSize { t.Errorf("after adding %v ~%v-byte headers, canonHeader cache is ~%v bytes, want <%v", count, size, total, maxCachedCanonicalHeadersKeysSize) } } } // TestServerWriteDoesNotRetainBufferAfterStreamClose checks for access to // the slice passed to ResponseWriter.Write after Write returns. // // Terminating the request stream on the client causes Write to return. // We should not access the slice after this point. func TestServerWriteDoesNotRetainBufferAfterReturn(t testing.T) { donec := make(chan struct{}) ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { defer close(donec) buf := make([]byte, 1<<20) var i byte for { i++ _, err := w.Write(buf) for j := range buf { buf[j] = byte(i) // trigger race detector } if err != nil { return } } }) tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() req, _ := http.NewRequest("GET", ts.URL, nil) res, err := tr.RoundTrip(req) if err != nil { t.Fatal(err) } res.Body.Close() <-donec } // TestServerWriteDoesNotRetainBufferAfterServerClose checks for access to // the slice passed to ResponseWriter.Write after Write returns. // // Shutting down the Server causes Write to return. // We should not access the slice after this point. func TestServerWriteDoesNotRetainBufferAfterServerClose(t testing.T) { donec := make(chan struct{}, 1) ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { donec <- struct{}{} defer close(donec) buf := make([]byte, 1<<20) var i byte for { i++ _, err := w.Write(buf) for j := range buf { buf[j] = byte(i) } if err != nil { return } } }) tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() req, _ := http.NewRequest("GET", ts.URL, nil) res, err := tr.RoundTrip(req) if err != nil { t.Fatal(err) } defer res.Body.Close() <-donec ts.Config.Close() <-donec } func TestServerMaxHandlerGoroutines(t testing.T) { const maxHandlers = 10 handlerc := make(chan chan bool) donec := make(chan struct{}) defer close(donec) st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { stopc := make(chan bool, 1) select { case handlerc <- stopc: case <-donec: } select { case shouldPanic := <-stopc: if shouldPanic { panic(http.ErrAbortHandler) } case <-donec: } }, func(s Server) { s.MaxConcurrentStreams = maxHandlers }) defer st.Close() st.greet() // Make maxHandlers concurrent requests. // Reset them all, but only after the handler goroutines have started. var stops []chan bool streamID := uint32(1) for i := 0; i < maxHandlers; i++ { st.writeHeaders(HeadersFrameParam{ StreamID: streamID, BlockFragment: st.encodeHeader(), EndStream: true, EndHeaders: true, }) stops = append(stops, <-handlerc) st.fr.WriteRSTStream(streamID, ErrCodeCancel) streamID += 2 } // Start another request, and immediately reset it. st.writeHeaders(HeadersFrameParam{ StreamID: streamID, BlockFragment: st.encodeHeader(), EndStream: true, EndHeaders: true, }) st.fr.WriteRSTStream(streamID, ErrCodeCancel) streamID += 2 // Start another two requests. Don't reset these. for i := 0; i < 2; i++ { st.writeHeaders(HeadersFrameParam{ StreamID: streamID, BlockFragment: st.encodeHeader(), EndStream: true, EndHeaders: true, }) streamID += 2 } // The initial maxHandlers handlers are still executing, // so the last two requests don't start any new handlers. select { case <-handlerc: t.Errorf("handler unexpectedly started while maxHandlers are already running") case <-time.After(1 time.Millisecond): } // Tell two handlers to exit. // The pending requests which weren't reset start handlers. stops[0] <- false // normal exit stops[1] <- true // panic stops = stops[2:] stops = append(stops, <-handlerc) stops = append(stops, <-handlerc) // Make a bunch more requests. // Eventually, the server tells us to go away. for i := 0; i < 5maxHandlers; i++ { st.writeHeaders(HeadersFrameParam{ StreamID: streamID, BlockFragment: st.encodeHeader(), EndStream: true, EndHeaders: true, }) st.fr.WriteRSTStream(streamID, ErrCodeCancel) streamID += 2 } fr := readFrame[GoAwayFrame](t, st) if fr.ErrCode != ErrCodeEnhanceYourCalm { t.Errorf("err code = %v; want %v", fr.ErrCode, ErrCodeEnhanceYourCalm) } for _, s := range stops { close(s) } } func TestServerContinuationFlood(t testing.T) { st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { fmt.Println(r.Header) }, func(s http.Server) { s.MaxHeaderBytes = 4096 }) defer st.Close() st.greet() st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: st.encodeHeader(), EndStream: true, }) for i := 0; i < 1000; i++ { st.fr.WriteContinuation(1, false, st.encodeHeaderRaw( fmt.Sprintf("x-%v", i), "1234567890", )) } st.fr.WriteContinuation(1, true, st.encodeHeaderRaw( "x-last-header", "1", )) for { f := st.readFrame() if f == nil { break } switch f := f.(type) { case HeadersFrame: t.Fatalf("received HEADERS frame; want GOAWAY and a closed connection") case GoAwayFrame: // We might not see the GOAWAY (see below), but if we do it should // indicate that the server processed this request so the client doesn't // attempt to retry it. if got, want := f.LastStreamID, uint32(1); got != want { t.Errorf("received GOAWAY with LastStreamId %v, want %v", got, want) } } } // We expect to have seen a GOAWAY before the connection closes, // but the server will close the connection after one second // whether or not it has finished sending the GOAWAY. On windows-amd64-race // builders, this fairly consistently results in the connection closing without // the GOAWAY being sent. // // Since the server's behavior is inherently racy here and the important thing // is that the connection is closed, don't check for the GOAWAY having been sent. } func TestServerContinuationAfterInvalidHeader(t testing.T) { st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { fmt.Println(r.Header) }) defer st.Close() st.greet() st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: st.encodeHeader(), EndStream: true, }) st.fr.WriteContinuation(1, false, st.encodeHeaderRaw( "x-invalid-header", "\x00", )) st.fr.WriteContinuation(1, true, st.encodeHeaderRaw( "x-valid-header", "1", )) var sawGoAway bool for { f := st.readFrame() if f == nil { break } switch f.(type) { case GoAwayFrame: sawGoAway = true case HeadersFrame: t.Fatalf("received HEADERS frame; want GOAWAY") } } if !sawGoAway { t.Errorf("connection closed with no GOAWAY frame; want one") } } func TestServerUpgradeRequestPrefaceFailure(t testing.T) { // An h2c upgrade request fails when the client preface is not as expected. s2 := &Server{ // Setting IdleTimeout triggers #67168. IdleTimeout: 60 * time.Minute, } c1, c2 := net.Pipe() donec := make(chan struct{}) go func() { defer close(donec) s2.ServeConn(c1, &ServeConnOpts{ UpgradeRequest: httptest.NewRequest("GET", "/", nil), }) }() // The server expects to see the HTTP/2 preface, // but we close the connection instead. c2.Close() <-donec } // Issue 67036: A stream error should result in the handler's request context being canceled. func TestServerRequestCancelOnError(t testing.T) { recvc := make(chan struct{}) // handler has started donec := make(chan struct{}) // handler has finished st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { close(recvc) <-r.Context().Done() close(donec) }) defer st.Close() st.greet() // Client sends request headers, handler starts. st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: st.encodeHeader(), EndStream: true, EndHeaders: true, }) <-recvc // Client sends an invalid second set of request headers. // The stream is reset. // The handler's context is canceled, and the handler exits. st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: st.encodeHeader(), EndStream: true, EndHeaders: true, }) <-donec } func TestServerSetReadWriteDeadlineRace(t testing.T) { ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { ctl := http.NewResponseController(w) ctl.SetReadDeadline(time.Now().Add(3600 * time.Second)) ctl.SetWriteDeadline(time.Now().Add(3600 * time.Second)) }) resp, err := ts.Client().Get(ts.URL) if err != nil { t.Fatal(err) } resp.Body.Close() } func TestServerWriteByteTimeout(t testing.T) { const timeout = 1 time.Second st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { w.Write(make([]byte, 100)) }, func(s Server) { s.WriteByteTimeout = timeout }) st.greet() st.cc.(synctestNetConn).SetReadBufferSize(1) // write one byte at a time st.writeHeaders(HeadersFrameParam{ StreamID: 1, BlockFragment: st.encodeHeader(), EndStream: true, EndHeaders: true, }) // Read a few bytes, staying just under WriteByteTimeout. for i := 0; i < 10; i++ { st.advance(timeout - 1) if n, err := st.cc.Read(make([]byte, 1)); n != 1 \|\| err != nil { t.Fatalf("read %v: %v, %v; want 1, nil", i, n, err) } } // Wait for WriteByteTimeout. // The connection should close. st.advance(1 time.Second) // timeout after writing one byte st.advance(1 * time.Second) // timeout after failing to write any more bytes st.wantClosed() } func TestServerPingSent(t testing.T) { const readIdleTimeout = 15 time.Second st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { }, func(s Server) { s.ReadIdleTimeout = readIdleTimeout }) st.greet() st.wantIdle() st.advance(readIdleTimeout) _ = readFrame[PingFrame](t, st) st.wantIdle() st.advance(14 time.Second) st.wantIdle() st.advance(1 * time.Second) st.wantClosed() } func TestServerPingResponded(t testing.T) { const readIdleTimeout = 15 time.Second st := newServerTester(t, func(w http.ResponseWriter, r http.Request) { }, func(s Server) { s.ReadIdleTimeout = readIdleTimeout }) st.greet() st.wantIdle() st.advance(readIdleTimeout) pf := readFrame[PingFrame](t, st) st.wantIdle() st.advance(14 time.Second) st.wantIdle() st.writePing(true, pf.Data) st.advance(2 * time.Second) st.wantIdle() }	125.03 KB	2025-05-25 12:27
📄 sync_test.go // Copyright 2024 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import ( "context" "fmt" "runtime" "strconv" "strings" "sync" "testing" "time" ) // A synctestGroup synchronizes between a set of cooperating goroutines. type synctestGroup struct { mu sync.Mutex gids map[int]bool now time.Time timers map[fakeTimer]struct{} } type goroutine struct { id int parent int state string } // newSynctest creates a new group with the synthetic clock set the provided time. func newSynctest(now time.Time) synctestGroup { return &synctestGroup{ gids: map[int]bool{ currentGoroutine(): true, }, now: now, } } // Join adds the current goroutine to the group. func (g synctestGroup) Join() { g.mu.Lock() defer g.mu.Unlock() g.gids[currentGoroutine()] = true } // Count returns the number of goroutines in the group. func (g synctestGroup) Count() int { gs := stacks(true) count := 0 for _, gr := range gs { if !g.gids[gr.id] && !g.gids[gr.parent] { continue } count++ } return count } // Close calls t.Fatal if the group contains any running goroutines. func (g synctestGroup) Close(t testing.TB) { if count := g.Count(); count != 1 { buf := make([]byte, 161024) n := runtime.Stack(buf, true) t.Logf("stacks:\n%s", buf[:n]) t.Fatalf("%v goroutines still running after test completed, expect 1", count) } } // Wait blocks until every goroutine in the group and their direct children are idle. func (g synctestGroup) Wait() { for i := 0; ; i++ { if g.idle() { return } runtime.Gosched() } } func (g synctestGroup) idle() bool { gs := stacks(true) g.mu.Lock() defer g.mu.Unlock() for _, gr := range gs[1:] { if !g.gids[gr.id] && !g.gids[gr.parent] { continue } // From runtime/runtime2.go. switch gr.state { case "IO wait": case "chan receive (nil chan)": case "chan send (nil chan)": case "select": case "select (no cases)": case "chan receive": case "chan send": case "sync.Cond.Wait": case "sync.Mutex.Lock": case "sync.RWMutex.RLock": case "sync.RWMutex.Lock": default: return false } } return true } func currentGoroutine() int { s := stacks(false) return s[0].id } func stacks(all bool) []goroutine { buf := make([]byte, 161024) for { n := runtime.Stack(buf, all) if n < len(buf) { buf = buf[:n] break } buf = make([]byte, len(buf)2) } var goroutines []goroutine for _, gs := range strings.Split(string(buf), "\n\n") { skip, rest, ok := strings.Cut(gs, "goroutine ") if skip != "" \|\| !ok { panic(fmt.Errorf("1 unparsable goroutine stack:\n%s", gs)) } ids, rest, ok := strings.Cut(rest, " [") if !ok { panic(fmt.Errorf("2 unparsable goroutine stack:\n%s", gs)) } id, err := strconv.Atoi(ids) if err != nil { panic(fmt.Errorf("3 unparsable goroutine stack:\n%s", gs)) } state, rest, ok := strings.Cut(rest, "]") var parent int _, rest, ok = strings.Cut(rest, "\ncreated by ") if ok && strings.Contains(rest, " in goroutine ") { _, rest, ok := strings.Cut(rest, " in goroutine ") if !ok { panic(fmt.Errorf("4 unparsable goroutine stack:\n%s", gs)) } parents, rest, ok := strings.Cut(rest, "\n") if !ok { panic(fmt.Errorf("5 unparsable goroutine stack:\n%s", gs)) } parent, err = strconv.Atoi(parents) if err != nil { panic(fmt.Errorf("6 unparsable goroutine stack:\n%s", gs)) } } goroutines = append(goroutines, goroutine{ id: id, parent: parent, state: state, }) } return goroutines } // AdvanceTime advances the synthetic clock by d. func (g synctestGroup) AdvanceTime(d time.Duration) { defer g.Wait() g.mu.Lock() defer g.mu.Unlock() g.now = g.now.Add(d) for tm := range g.timers { if tm.when.After(g.now) { continue } tm.run() delete(g.timers, tm) } } // Now returns the current synthetic time. func (g synctestGroup) Now() time.Time { g.mu.Lock() defer g.mu.Unlock() return g.now } // TimeUntilEvent returns the amount of time until the next scheduled timer. func (g synctestGroup) TimeUntilEvent() (d time.Duration, scheduled bool) { g.mu.Lock() defer g.mu.Unlock() for tm := range g.timers { if dd := tm.when.Sub(g.now); !scheduled \|\| dd < d { d = dd scheduled = true } } return d, scheduled } // Sleep is time.Sleep, but using synthetic time. func (g synctestGroup) Sleep(d time.Duration) { tm := g.NewTimer(d) <-tm.C() } // NewTimer is time.NewTimer, but using synthetic time. func (g synctestGroup) NewTimer(d time.Duration) Timer { return g.addTimer(d, &fakeTimer{ ch: make(chan time.Time), }) } // AfterFunc is time.AfterFunc, but using synthetic time. func (g synctestGroup) AfterFunc(d time.Duration, f func()) Timer { return g.addTimer(d, &fakeTimer{ f: f, }) } // ContextWithTimeout is context.WithTimeout, but using synthetic time. func (g synctestGroup) ContextWithTimeout(ctx context.Context, d time.Duration) (context.Context, context.CancelFunc) { ctx, cancel := context.WithCancel(ctx) tm := g.AfterFunc(d, cancel) return ctx, func() { tm.Stop() cancel() } } func (g synctestGroup) addTimer(d time.Duration, tm fakeTimer) fakeTimer { g.mu.Lock() defer g.mu.Unlock() tm.g = g tm.when = g.now.Add(d) if g.timers == nil { g.timers = make(map[fakeTimer]struct{}) } if tm.when.After(g.now) { g.timers[tm] = struct{}{} } else { tm.run() } return tm } type Timer = interface { C() <-chan time.Time Reset(d time.Duration) bool Stop() bool } type fakeTimer struct { g synctestGroup when time.Time ch chan time.Time f func() } func (tm fakeTimer) run() { if tm.ch != nil { tm.ch <- tm.g.now } else { go func() { tm.g.Join() tm.f() }() } } func (tm fakeTimer) C() <-chan time.Time { return tm.ch } func (tm fakeTimer) Reset(d time.Duration) bool { tm.g.mu.Lock() defer tm.g.mu.Unlock() _, stopped := tm.g.timers[tm] if d <= 0 { delete(tm.g.timers, tm) tm.run() } else { tm.when = tm.g.now.Add(d) tm.g.timers[tm] = struct{}{} } return stopped } func (tm fakeTimer) Stop() bool { tm.g.mu.Lock() defer tm.g.mu.Unlock() _, stopped := tm.g.timers[tm] delete(tm.g.timers, tm) return stopped }	6.16 KB	2025-05-25 12:27
📄 timer.go // Copyright 2024 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import "time" // A timer is a time.Timer, as an interface which can be replaced in tests. type timer = interface { C() <-chan time.Time Reset(d time.Duration) bool Stop() bool } // timeTimer adapts a time.Timer to the timer interface. type timeTimer struct { *time.Timer } func (t timeTimer) C() <-chan time.Time { return t.Timer.C }	515 B	2025-05-25 12:27
📄 transport.go // Copyright 2015 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Transport code. package http2 import ( "bufio" "bytes" "compress/gzip" "context" "crypto/rand" "crypto/tls" "errors" "fmt" "io" "io/fs" "log" "math" "math/bits" mathrand "math/rand" "net" "net/http" "net/http/httptrace" "net/textproto" "sort" "strconv" "strings" "sync" "sync/atomic" "time" "golang.org/x/net/http/httpguts" "golang.org/x/net/http2/hpack" "golang.org/x/net/idna" ) const ( // transportDefaultConnFlow is how many connection-level flow control // tokens we give the server at start-up, past the default 64k. transportDefaultConnFlow = 1 << 30 // transportDefaultStreamFlow is how many stream-level flow // control tokens we announce to the peer, and how many bytes // we buffer per stream. transportDefaultStreamFlow = 4 << 20 defaultUserAgent = "Go-http-client/2.0" // initialMaxConcurrentStreams is a connections maxConcurrentStreams until // it's received servers initial SETTINGS frame, which corresponds with the // spec's minimum recommended value. initialMaxConcurrentStreams = 100 // defaultMaxConcurrentStreams is a connections default maxConcurrentStreams // if the server doesn't include one in its initial SETTINGS frame. defaultMaxConcurrentStreams = 1000 ) // Transport is an HTTP/2 Transport. // // A Transport internally caches connections to servers. It is safe // for concurrent use by multiple goroutines. type Transport struct { // DialTLSContext specifies an optional dial function with context for // creating TLS connections for requests. // // If DialTLSContext and DialTLS is nil, tls.Dial is used. // // If the returned net.Conn has a ConnectionState method like tls.Conn, // it will be used to set http.Response.TLS. DialTLSContext func(ctx context.Context, network, addr string, cfg tls.Config) (net.Conn, error) // DialTLS specifies an optional dial function for creating // TLS connections for requests. // // If DialTLSContext and DialTLS is nil, tls.Dial is used. // // Deprecated: Use DialTLSContext instead, which allows the transport // to cancel dials as soon as they are no longer needed. // If both are set, DialTLSContext takes priority. DialTLS func(network, addr string, cfg tls.Config) (net.Conn, error) // TLSClientConfig specifies the TLS configuration to use with // tls.Client. If nil, the default configuration is used. TLSClientConfig tls.Config // ConnPool optionally specifies an alternate connection pool to use. // If nil, the default is used. ConnPool ClientConnPool // DisableCompression, if true, prevents the Transport from // requesting compression with an "Accept-Encoding: gzip" // request header when the Request contains no existing // Accept-Encoding value. If the Transport requests gzip on // its own and gets a gzipped response, it's transparently // decoded in the Response.Body. However, if the user // explicitly requested gzip it is not automatically // uncompressed. DisableCompression bool // AllowHTTP, if true, permits HTTP/2 requests using the insecure, // plain-text "http" scheme. Note that this does not enable h2c support. AllowHTTP bool // MaxHeaderListSize is the http2 SETTINGS_MAX_HEADER_LIST_SIZE to // send in the initial settings frame. It is how many bytes // of response headers are allowed. Unlike the http2 spec, zero here // means to use a default limit (currently 10MB). If you actually // want to advertise an unlimited value to the peer, Transport // interprets the highest possible value here (0xffffffff or 1<<32-1) // to mean no limit. MaxHeaderListSize uint32 // MaxReadFrameSize is the http2 SETTINGS_MAX_FRAME_SIZE to send in the // initial settings frame. It is the size in bytes of the largest frame // payload that the sender is willing to receive. If 0, no setting is // sent, and the value is provided by the peer, which should be 16384 // according to the spec: // https://datatracker.ietf.org/doc/html/rfc7540#section-6.5.2. // Values are bounded in the range 16k to 16M. MaxReadFrameSize uint32 // MaxDecoderHeaderTableSize optionally specifies the http2 // SETTINGS_HEADER_TABLE_SIZE to send in the initial settings frame. It // informs the remote endpoint of the maximum size of the header compression // table used to decode header blocks, in octets. If zero, the default value // of 4096 is used. MaxDecoderHeaderTableSize uint32 // MaxEncoderHeaderTableSize optionally specifies an upper limit for the // header compression table used for encoding request headers. Received // SETTINGS_HEADER_TABLE_SIZE settings are capped at this limit. If zero, // the default value of 4096 is used. MaxEncoderHeaderTableSize uint32 // StrictMaxConcurrentStreams controls whether the server's // SETTINGS_MAX_CONCURRENT_STREAMS should be respected // globally. If false, new TCP connections are created to the // server as needed to keep each under the per-connection // SETTINGS_MAX_CONCURRENT_STREAMS limit. If true, the // server's SETTINGS_MAX_CONCURRENT_STREAMS is interpreted as // a global limit and callers of RoundTrip block when needed, // waiting for their turn. StrictMaxConcurrentStreams bool // IdleConnTimeout is the maximum amount of time an idle // (keep-alive) connection will remain idle before closing // itself. // Zero means no limit. IdleConnTimeout time.Duration // ReadIdleTimeout is the timeout after which a health check using ping // frame will be carried out if no frame is received on the connection. // Note that a ping response will is considered a received frame, so if // there is no other traffic on the connection, the health check will // be performed every ReadIdleTimeout interval. // If zero, no health check is performed. ReadIdleTimeout time.Duration // PingTimeout is the timeout after which the connection will be closed // if a response to Ping is not received. // Defaults to 15s. PingTimeout time.Duration // WriteByteTimeout is the timeout after which the connection will be // closed no data can be written to it. The timeout begins when data is // available to write, and is extended whenever any bytes are written. WriteByteTimeout time.Duration // CountError, if non-nil, is called on HTTP/2 transport errors. // It's intended to increment a metric for monitoring, such // as an expvar or Prometheus metric. // The errType consists of only ASCII word characters. CountError func(errType string) // t1, if non-nil, is the standard library Transport using // this transport. Its settings are used (but not its // RoundTrip method, etc). t1 http.Transport connPoolOnce sync.Once connPoolOrDef ClientConnPool // non-nil version of ConnPool transportTestHooks } // Hook points used for testing. // Outside of tests, t.transportTestHooks is nil and these all have minimal implementations. // Inside tests, see the testSyncHooks function docs. type transportTestHooks struct { newclientconn func(ClientConn) group synctestGroupInterface } func (t Transport) markNewGoroutine() { if t != nil && t.transportTestHooks != nil { t.transportTestHooks.group.Join() } } func (t Transport) now() time.Time { if t != nil && t.transportTestHooks != nil { return t.transportTestHooks.group.Now() } return time.Now() } func (t Transport) timeSince(when time.Time) time.Duration { if t != nil && t.transportTestHooks != nil { return t.now().Sub(when) } return time.Since(when) } // newTimer creates a new time.Timer, or a synthetic timer in tests. func (t Transport) newTimer(d time.Duration) timer { if t.transportTestHooks != nil { return t.transportTestHooks.group.NewTimer(d) } return timeTimer{time.NewTimer(d)} } // afterFunc creates a new time.AfterFunc timer, or a synthetic timer in tests. func (t Transport) afterFunc(d time.Duration, f func()) timer { if t.transportTestHooks != nil { return t.transportTestHooks.group.AfterFunc(d, f) } return timeTimer{time.AfterFunc(d, f)} } func (t Transport) contextWithTimeout(ctx context.Context, d time.Duration) (context.Context, context.CancelFunc) { if t.transportTestHooks != nil { return t.transportTestHooks.group.ContextWithTimeout(ctx, d) } return context.WithTimeout(ctx, d) } func (t Transport) maxHeaderListSize() uint32 { n := int64(t.MaxHeaderListSize) if t.t1 != nil && t.t1.MaxResponseHeaderBytes != 0 { n = t.t1.MaxResponseHeaderBytes if n > 0 { n = adjustHTTP1MaxHeaderSize(n) } } if n <= 0 { return 10 << 20 } if n >= 0xffffffff { return 0 } return uint32(n) } func (t Transport) disableCompression() bool { return t.DisableCompression \|\| (t.t1 != nil && t.t1.DisableCompression) } // ConfigureTransport configures a net/http HTTP/1 Transport to use HTTP/2. // It returns an error if t1 has already been HTTP/2-enabled. // // Use ConfigureTransports instead to configure the HTTP/2 Transport. func ConfigureTransport(t1 http.Transport) error { _, err := ConfigureTransports(t1) return err } // ConfigureTransports configures a net/http HTTP/1 Transport to use HTTP/2. // It returns a new HTTP/2 Transport for further configuration. // It returns an error if t1 has already been HTTP/2-enabled. func ConfigureTransports(t1 http.Transport) (Transport, error) { return configureTransports(t1) } func configureTransports(t1 http.Transport) (Transport, error) { connPool := new(clientConnPool) t2 := &Transport{ ConnPool: noDialClientConnPool{connPool}, t1: t1, } connPool.t = t2 if err := registerHTTPSProtocol(t1, noDialH2RoundTripper{t2}); err != nil { return nil, err } if t1.TLSClientConfig == nil { t1.TLSClientConfig = new(tls.Config) } if !strSliceContains(t1.TLSClientConfig.NextProtos, "h2") { t1.TLSClientConfig.NextProtos = append([]string{"h2"}, t1.TLSClientConfig.NextProtos...) } if !strSliceContains(t1.TLSClientConfig.NextProtos, "http/1.1") { t1.TLSClientConfig.NextProtos = append(t1.TLSClientConfig.NextProtos, "http/1.1") } upgradeFn := func(scheme, authority string, c net.Conn) http.RoundTripper { addr := authorityAddr(scheme, authority) if used, err := connPool.addConnIfNeeded(addr, t2, c); err != nil { go c.Close() return erringRoundTripper{err} } else if !used { // Turns out we don't need this c. // For example, two goroutines made requests to the same host // at the same time, both kicking off TCP dials. (since protocol // was unknown) go c.Close() } if scheme == "http" { return (unencryptedTransport)(t2) } return t2 } if t1.TLSNextProto == nil { t1.TLSNextProto = make(map[string]func(string, tls.Conn) http.RoundTripper) } t1.TLSNextProto[NextProtoTLS] = func(authority string, c tls.Conn) http.RoundTripper { return upgradeFn("https", authority, c) } // The "unencrypted_http2" TLSNextProto key is used to pass off non-TLS HTTP/2 conns. t1.TLSNextProto[nextProtoUnencryptedHTTP2] = func(authority string, c tls.Conn) http.RoundTripper { nc, err := unencryptedNetConnFromTLSConn(c) if err != nil { go c.Close() return erringRoundTripper{err} } return upgradeFn("http", authority, nc) } return t2, nil } // unencryptedTransport is a Transport with a RoundTrip method that // always permits http:// URLs. type unencryptedTransport Transport func (t unencryptedTransport) RoundTrip(req http.Request) (http.Response, error) { return (Transport)(t).RoundTripOpt(req, RoundTripOpt{allowHTTP: true}) } func (t Transport) connPool() ClientConnPool { t.connPoolOnce.Do(t.initConnPool) return t.connPoolOrDef } func (t Transport) initConnPool() { if t.ConnPool != nil { t.connPoolOrDef = t.ConnPool } else { t.connPoolOrDef = &clientConnPool{t: t} } } // ClientConn is the state of a single HTTP/2 client connection to an // HTTP/2 server. type ClientConn struct { t Transport tconn net.Conn // usually tls.Conn, except specialized impls tlsState tls.ConnectionState // nil only for specialized impls atomicReused uint32 // whether conn is being reused; atomic singleUse bool // whether being used for a single http.Request getConnCalled bool // used by clientConnPool // readLoop goroutine fields: readerDone chan struct{} // closed on error readerErr error // set before readerDone is closed idleTimeout time.Duration // or 0 for never idleTimer timer mu sync.Mutex // guards following cond sync.Cond // hold mu; broadcast on flow/closed changes flow outflow // our conn-level flow control quota (cs.outflow is per stream) inflow inflow // peer's conn-level flow control doNotReuse bool // whether conn is marked to not be reused for any future requests closing bool closed bool seenSettings bool // true if we've seen a settings frame, false otherwise seenSettingsChan chan struct{} // closed when seenSettings is true or frame reading fails wantSettingsAck bool // we sent a SETTINGS frame and haven't heard back goAway GoAwayFrame // if non-nil, the GoAwayFrame we received goAwayDebug string // goAway frame's debug data, retained as a string streams map[uint32]clientStream // client-initiated streamsReserved int // incr by ReserveNewRequest; decr on RoundTrip nextStreamID uint32 pendingRequests int // requests blocked and waiting to be sent because len(streams) == maxConcurrentStreams pings map[[8]byte]chan struct{} // in flight ping data to notification channel br bufio.Reader lastActive time.Time lastIdle time.Time // time last idle // Settings from peer: (also guarded by wmu) maxFrameSize uint32 maxConcurrentStreams uint32 peerMaxHeaderListSize uint64 peerMaxHeaderTableSize uint32 initialWindowSize uint32 initialStreamRecvWindowSize int32 readIdleTimeout time.Duration pingTimeout time.Duration extendedConnectAllowed bool // rstStreamPingsBlocked works around an unfortunate gRPC behavior. // gRPC strictly limits the number of PING frames that it will receive. // The default is two pings per two hours, but the limit resets every time // the gRPC endpoint sends a HEADERS or DATA frame. See golang/go#70575. // // rstStreamPingsBlocked is set after receiving a response to a PING frame // bundled with an RST_STREAM (see pendingResets below), and cleared after // receiving a HEADERS or DATA frame. rstStreamPingsBlocked bool // pendingResets is the number of RST_STREAM frames we have sent to the peer, // without confirming that the peer has received them. When we send a RST_STREAM, // we bundle it with a PING frame, unless a PING is already in flight. We count // the reset stream against the connection's concurrency limit until we get // a PING response. This limits the number of requests we'll try to send to a // completely unresponsive connection. pendingResets int // reqHeaderMu is a 1-element semaphore channel controlling access to sending new requests. // Write to reqHeaderMu to lock it, read from it to unlock. // Lock reqmu BEFORE mu or wmu. reqHeaderMu chan struct{} // wmu is held while writing. // Acquire BEFORE mu when holding both, to avoid blocking mu on network writes. // Only acquire both at the same time when changing peer settings. wmu sync.Mutex bw bufio.Writer fr Framer werr error // first write error that has occurred hbuf bytes.Buffer // HPACK encoder writes into this henc hpack.Encoder } // clientStream is the state for a single HTTP/2 stream. One of these // is created for each Transport.RoundTrip call. type clientStream struct { cc ClientConn // Fields of Request that we may access even after the response body is closed. ctx context.Context reqCancel <-chan struct{} trace httptrace.ClientTrace // or nil ID uint32 bufPipe pipe // buffered pipe with the flow-controlled response payload requestedGzip bool isHead bool abortOnce sync.Once abort chan struct{} // closed to signal stream should end immediately abortErr error // set if abort is closed peerClosed chan struct{} // closed when the peer sends an END_STREAM flag donec chan struct{} // closed after the stream is in the closed state on100 chan struct{} // buffered; written to if a 100 is received respHeaderRecv chan struct{} // closed when headers are received res http.Response // set if respHeaderRecv is closed flow outflow // guarded by cc.mu inflow inflow // guarded by cc.mu bytesRemain int64 // -1 means unknown; owned by transportResponseBody.Read readErr error // sticky read error; owned by transportResponseBody.Read reqBody io.ReadCloser reqBodyContentLength int64 // -1 means unknown reqBodyClosed chan struct{} // guarded by cc.mu; non-nil on Close, closed when done // owned by writeRequest: sentEndStream bool // sent an END_STREAM flag to the peer sentHeaders bool // owned by clientConnReadLoop: firstByte bool // got the first response byte pastHeaders bool // got first MetaHeadersFrame (actual headers) pastTrailers bool // got optional second MetaHeadersFrame (trailers) readClosed bool // peer sent an END_STREAM flag readAborted bool // read loop reset the stream totalHeaderSize int64 // total size of 1xx headers seen trailer http.Header // accumulated trailers resTrailer http.Header // client's Response.Trailer } var got1xxFuncForTests func(int, textproto.MIMEHeader) error // get1xxTraceFunc returns the value of request's httptrace.ClientTrace.Got1xxResponse func, // if any. It returns nil if not set or if the Go version is too old. func (cs clientStream) get1xxTraceFunc() func(int, textproto.MIMEHeader) error { if fn := got1xxFuncForTests; fn != nil { return fn } return traceGot1xxResponseFunc(cs.trace) } func (cs clientStream) abortStream(err error) { cs.cc.mu.Lock() defer cs.cc.mu.Unlock() cs.abortStreamLocked(err) } func (cs clientStream) abortStreamLocked(err error) { cs.abortOnce.Do(func() { cs.abortErr = err close(cs.abort) }) if cs.reqBody != nil { cs.closeReqBodyLocked() } // TODO(dneil): Clean up tests where cs.cc.cond is nil. if cs.cc.cond != nil { // Wake up writeRequestBody if it is waiting on flow control. cs.cc.cond.Broadcast() } } func (cs clientStream) abortRequestBodyWrite() { cc := cs.cc cc.mu.Lock() defer cc.mu.Unlock() if cs.reqBody != nil && cs.reqBodyClosed == nil { cs.closeReqBodyLocked() cc.cond.Broadcast() } } func (cs clientStream) closeReqBodyLocked() { if cs.reqBodyClosed != nil { return } cs.reqBodyClosed = make(chan struct{}) reqBodyClosed := cs.reqBodyClosed go func() { cs.cc.t.markNewGoroutine() cs.reqBody.Close() close(reqBodyClosed) }() } type stickyErrWriter struct { group synctestGroupInterface conn net.Conn timeout time.Duration err error } func (sew stickyErrWriter) Write(p []byte) (n int, err error) { if sew.err != nil { return 0, sew.err } n, err = writeWithByteTimeout(sew.group, sew.conn, sew.timeout, p) sew.err = err return n, err } // noCachedConnError is the concrete type of ErrNoCachedConn, which // needs to be detected by net/http regardless of whether it's its // bundled version (in h2_bundle.go with a rewritten type name) or // from a user's x/net/http2. As such, as it has a unique method name // (IsHTTP2NoCachedConnError) that net/http sniffs for via func // isNoCachedConnError. type noCachedConnError struct{} func (noCachedConnError) IsHTTP2NoCachedConnError() {} func (noCachedConnError) Error() string { return "http2: no cached connection was available" } // isNoCachedConnError reports whether err is of type noCachedConnError // or its equivalent renamed type in net/http2's h2_bundle.go. Both types // may coexist in the same running program. func isNoCachedConnError(err error) bool { _, ok := err.(interface{ IsHTTP2NoCachedConnError() }) return ok } var ErrNoCachedConn error = noCachedConnError{} // RoundTripOpt are options for the Transport.RoundTripOpt method. type RoundTripOpt struct { // OnlyCachedConn controls whether RoundTripOpt may // create a new TCP connection. If set true and // no cached connection is available, RoundTripOpt // will return ErrNoCachedConn. OnlyCachedConn bool allowHTTP bool // allow http:// URLs } func (t Transport) RoundTrip(req http.Request) (http.Response, error) { return t.RoundTripOpt(req, RoundTripOpt{}) } // authorityAddr returns a given authority (a host/IP, or host:port / ip:port) // and returns a host:port. The port 443 is added if needed. func authorityAddr(scheme string, authority string) (addr string) { host, port, err := net.SplitHostPort(authority) if err != nil { // authority didn't have a port host = authority port = "" } if port == "" { // authority's port was empty port = "443" if scheme == "http" { port = "80" } } if a, err := idna.ToASCII(host); err == nil { host = a } // IPv6 address literal, without a port: if strings.HasPrefix(host, "[") && strings.HasSuffix(host, "]") { return host + ":" + port } return net.JoinHostPort(host, port) } // RoundTripOpt is like RoundTrip, but takes options. func (t Transport) RoundTripOpt(req http.Request, opt RoundTripOpt) (http.Response, error) { switch req.URL.Scheme { case "https": // Always okay. case "http": if !t.AllowHTTP && !opt.allowHTTP { return nil, errors.New("http2: unencrypted HTTP/2 not enabled") } default: return nil, errors.New("http2: unsupported scheme") } addr := authorityAddr(req.URL.Scheme, req.URL.Host) for retry := 0; ; retry++ { cc, err := t.connPool().GetClientConn(req, addr) if err != nil { t.vlogf("http2: Transport failed to get client conn for %s: %v", addr, err) return nil, err } reused := !atomic.CompareAndSwapUint32(&cc.atomicReused, 0, 1) traceGotConn(req, cc, reused) res, err := cc.RoundTrip(req) if err != nil && retry <= 6 { roundTripErr := err if req, err = shouldRetryRequest(req, err); err == nil { // After the first retry, do exponential backoff with 10% jitter. if retry == 0 { t.vlogf("RoundTrip retrying after failure: %v", roundTripErr) continue } backoff := float64(uint(1) << (uint(retry) - 1)) backoff += backoff * (0.1 * mathrand.Float64()) d := time.Second * time.Duration(backoff) tm := t.newTimer(d) select { case <-tm.C(): t.vlogf("RoundTrip retrying after failure: %v", roundTripErr) continue case <-req.Context().Done(): tm.Stop() err = req.Context().Err() } } } if err == errClientConnNotEstablished { // This ClientConn was created recently, // this is the first request to use it, // and the connection is closed and not usable. // // In this state, cc.idleTimer will remove the conn from the pool // when it fires. Stop the timer and remove it here so future requests // won't try to use this connection. // // If the timer has already fired and we're racing it, the redundant // call to MarkDead is harmless. if cc.idleTimer != nil { cc.idleTimer.Stop() } t.connPool().MarkDead(cc) } if err != nil { t.vlogf("RoundTrip failure: %v", err) return nil, err } return res, nil } } // CloseIdleConnections closes any connections which were previously // connected from previous requests but are now sitting idle. // It does not interrupt any connections currently in use. func (t Transport) CloseIdleConnections() { if cp, ok := t.connPool().(clientConnPoolIdleCloser); ok { cp.closeIdleConnections() } } var ( errClientConnClosed = errors.New("http2: client conn is closed") errClientConnUnusable = errors.New("http2: client conn not usable") errClientConnNotEstablished = errors.New("http2: client conn could not be established") errClientConnGotGoAway = errors.New("http2: Transport received Server's graceful shutdown GOAWAY") ) // shouldRetryRequest is called by RoundTrip when a request fails to get // response headers. It is always called with a non-nil error. // It returns either a request to retry (either the same request, or a // modified clone), or an error if the request can't be replayed. func shouldRetryRequest(req http.Request, err error) (http.Request, error) { if !canRetryError(err) { return nil, err } // If the Body is nil (or http.NoBody), it's safe to reuse // this request and its Body. if req.Body == nil \|\| req.Body == http.NoBody { return req, nil } // If the request body can be reset back to its original // state via the optional req.GetBody, do that. if req.GetBody != nil { body, err := req.GetBody() if err != nil { return nil, err } newReq := req newReq.Body = body return &newReq, nil } // The Request.Body can't reset back to the beginning, but we // don't seem to have started to read from it yet, so reuse // the request directly. if err == errClientConnUnusable { return req, nil } return nil, fmt.Errorf("http2: Transport: cannot retry err [%v] after Request.Body was written; define Request.GetBody to avoid this error", err) } func canRetryError(err error) bool { if err == errClientConnUnusable \|\| err == errClientConnGotGoAway { return true } if se, ok := err.(StreamError); ok { if se.Code == ErrCodeProtocol && se.Cause == errFromPeer { // See golang/go#47635, golang/go#42777 return true } return se.Code == ErrCodeRefusedStream } return false } func (t Transport) dialClientConn(ctx context.Context, addr string, singleUse bool) (ClientConn, error) { if t.transportTestHooks != nil { return t.newClientConn(nil, singleUse) } host, _, err := net.SplitHostPort(addr) if err != nil { return nil, err } tconn, err := t.dialTLS(ctx, "tcp", addr, t.newTLSConfig(host)) if err != nil { return nil, err } return t.newClientConn(tconn, singleUse) } func (t Transport) newTLSConfig(host string) tls.Config { cfg := new(tls.Config) if t.TLSClientConfig != nil { cfg = t.TLSClientConfig.Clone() } if !strSliceContains(cfg.NextProtos, NextProtoTLS) { cfg.NextProtos = append([]string{NextProtoTLS}, cfg.NextProtos...) } if cfg.ServerName == "" { cfg.ServerName = host } return cfg } func (t Transport) dialTLS(ctx context.Context, network, addr string, tlsCfg tls.Config) (net.Conn, error) { if t.DialTLSContext != nil { return t.DialTLSContext(ctx, network, addr, tlsCfg) } else if t.DialTLS != nil { return t.DialTLS(network, addr, tlsCfg) } tlsCn, err := t.dialTLSWithContext(ctx, network, addr, tlsCfg) if err != nil { return nil, err } state := tlsCn.ConnectionState() if p := state.NegotiatedProtocol; p != NextProtoTLS { return nil, fmt.Errorf("http2: unexpected ALPN protocol %q; want %q", p, NextProtoTLS) } if !state.NegotiatedProtocolIsMutual { return nil, errors.New("http2: could not negotiate protocol mutually") } return tlsCn, nil } // disableKeepAlives reports whether connections should be closed as // soon as possible after handling the first request. func (t Transport) disableKeepAlives() bool { return t.t1 != nil && t.t1.DisableKeepAlives } func (t Transport) expectContinueTimeout() time.Duration { if t.t1 == nil { return 0 } return t.t1.ExpectContinueTimeout } func (t Transport) NewClientConn(c net.Conn) (ClientConn, error) { return t.newClientConn(c, t.disableKeepAlives()) } func (t Transport) newClientConn(c net.Conn, singleUse bool) (ClientConn, error) { conf := configFromTransport(t) cc := &ClientConn{ t: t, tconn: c, readerDone: make(chan struct{}), nextStreamID: 1, maxFrameSize: 16 << 10, // spec default initialWindowSize: 65535, // spec default initialStreamRecvWindowSize: conf.MaxUploadBufferPerStream, maxConcurrentStreams: initialMaxConcurrentStreams, // "infinite", per spec. Use a smaller value until we have received server settings. peerMaxHeaderListSize: 0xffffffffffffffff, // "infinite", per spec. Use 2^64-1 instead. streams: make(map[uint32]clientStream), singleUse: singleUse, seenSettingsChan: make(chan struct{}), wantSettingsAck: true, readIdleTimeout: conf.SendPingTimeout, pingTimeout: conf.PingTimeout, pings: make(map[[8]byte]chan struct{}), reqHeaderMu: make(chan struct{}, 1), lastActive: t.now(), } var group synctestGroupInterface if t.transportTestHooks != nil { t.markNewGoroutine() t.transportTestHooks.newclientconn(cc) c = cc.tconn group = t.group } if VerboseLogs { t.vlogf("http2: Transport creating client conn %p to %v", cc, c.RemoteAddr()) } cc.cond = sync.NewCond(&cc.mu) cc.flow.add(int32(initialWindowSize)) // TODO: adjust this writer size to account for frame size + // MTU + crypto/tls record padding. cc.bw = bufio.NewWriter(stickyErrWriter{ group: group, conn: c, timeout: conf.WriteByteTimeout, err: &cc.werr, }) cc.br = bufio.NewReader(c) cc.fr = NewFramer(cc.bw, cc.br) cc.fr.SetMaxReadFrameSize(conf.MaxReadFrameSize) if t.CountError != nil { cc.fr.countError = t.CountError } maxHeaderTableSize := conf.MaxDecoderHeaderTableSize cc.fr.ReadMetaHeaders = hpack.NewDecoder(maxHeaderTableSize, nil) cc.fr.MaxHeaderListSize = t.maxHeaderListSize() cc.henc = hpack.NewEncoder(&cc.hbuf) cc.henc.SetMaxDynamicTableSizeLimit(conf.MaxEncoderHeaderTableSize) cc.peerMaxHeaderTableSize = initialHeaderTableSize if cs, ok := c.(connectionStater); ok { state := cs.ConnectionState() cc.tlsState = &state } initialSettings := []Setting{ {ID: SettingEnablePush, Val: 0}, {ID: SettingInitialWindowSize, Val: uint32(cc.initialStreamRecvWindowSize)}, } initialSettings = append(initialSettings, Setting{ID: SettingMaxFrameSize, Val: conf.MaxReadFrameSize}) if max := t.maxHeaderListSize(); max != 0 { initialSettings = append(initialSettings, Setting{ID: SettingMaxHeaderListSize, Val: max}) } if maxHeaderTableSize != initialHeaderTableSize { initialSettings = append(initialSettings, Setting{ID: SettingHeaderTableSize, Val: maxHeaderTableSize}) } cc.bw.Write(clientPreface) cc.fr.WriteSettings(initialSettings...) cc.fr.WriteWindowUpdate(0, uint32(conf.MaxUploadBufferPerConnection)) cc.inflow.init(conf.MaxUploadBufferPerConnection + initialWindowSize) cc.bw.Flush() if cc.werr != nil { cc.Close() return nil, cc.werr } // Start the idle timer after the connection is fully initialized. if d := t.idleConnTimeout(); d != 0 { cc.idleTimeout = d cc.idleTimer = t.afterFunc(d, cc.onIdleTimeout) } go cc.readLoop() return cc, nil } func (cc ClientConn) healthCheck() { pingTimeout := cc.pingTimeout // We don't need to periodically ping in the health check, because the readLoop of ClientConn will // trigger the healthCheck again if there is no frame received. ctx, cancel := cc.t.contextWithTimeout(context.Background(), pingTimeout) defer cancel() cc.vlogf("http2: Transport sending health check") err := cc.Ping(ctx) if err != nil { cc.vlogf("http2: Transport health check failure: %v", err) cc.closeForLostPing() } else { cc.vlogf("http2: Transport health check success") } } // SetDoNotReuse marks cc as not reusable for future HTTP requests. func (cc ClientConn) SetDoNotReuse() { cc.mu.Lock() defer cc.mu.Unlock() cc.doNotReuse = true } func (cc ClientConn) setGoAway(f GoAwayFrame) { cc.mu.Lock() defer cc.mu.Unlock() old := cc.goAway cc.goAway = f // Merge the previous and current GoAway error frames. if cc.goAwayDebug == "" { cc.goAwayDebug = string(f.DebugData()) } if old != nil && old.ErrCode != ErrCodeNo { cc.goAway.ErrCode = old.ErrCode } last := f.LastStreamID for streamID, cs := range cc.streams { if streamID <= last { // The server's GOAWAY indicates that it received this stream. // It will either finish processing it, or close the connection // without doing so. Either way, leave the stream alone for now. continue } if streamID == 1 && cc.goAway.ErrCode != ErrCodeNo { // Don't retry the first stream on a connection if we get a non-NO error. // If the server is sending an error on a new connection, // retrying the request on a new one probably isn't going to work. cs.abortStreamLocked(fmt.Errorf("http2: Transport received GOAWAY from server ErrCode:%v", cc.goAway.ErrCode)) } else { // Aborting the stream with errClentConnGotGoAway indicates that // the request should be retried on a new connection. cs.abortStreamLocked(errClientConnGotGoAway) } } } // CanTakeNewRequest reports whether the connection can take a new request, // meaning it has not been closed or received or sent a GOAWAY. // // If the caller is going to immediately make a new request on this // connection, use ReserveNewRequest instead. func (cc ClientConn) CanTakeNewRequest() bool { cc.mu.Lock() defer cc.mu.Unlock() return cc.canTakeNewRequestLocked() } // ReserveNewRequest is like CanTakeNewRequest but also reserves a // concurrent stream in cc. The reservation is decremented on the // next call to RoundTrip. func (cc ClientConn) ReserveNewRequest() bool { cc.mu.Lock() defer cc.mu.Unlock() if st := cc.idleStateLocked(); !st.canTakeNewRequest { return false } cc.streamsReserved++ return true } // ClientConnState describes the state of a ClientConn. type ClientConnState struct { // Closed is whether the connection is closed. Closed bool // Closing is whether the connection is in the process of // closing. It may be closing due to shutdown, being a // single-use connection, being marked as DoNotReuse, or // having received a GOAWAY frame. Closing bool // StreamsActive is how many streams are active. StreamsActive int // StreamsReserved is how many streams have been reserved via // ClientConn.ReserveNewRequest. StreamsReserved int // StreamsPending is how many requests have been sent in excess // of the peer's advertised MaxConcurrentStreams setting and // are waiting for other streams to complete. StreamsPending int // MaxConcurrentStreams is how many concurrent streams the // peer advertised as acceptable. Zero means no SETTINGS // frame has been received yet. MaxConcurrentStreams uint32 // LastIdle, if non-zero, is when the connection last // transitioned to idle state. LastIdle time.Time } // State returns a snapshot of cc's state. func (cc ClientConn) State() ClientConnState { cc.wmu.Lock() maxConcurrent := cc.maxConcurrentStreams if !cc.seenSettings { maxConcurrent = 0 } cc.wmu.Unlock() cc.mu.Lock() defer cc.mu.Unlock() return ClientConnState{ Closed: cc.closed, Closing: cc.closing \|\| cc.singleUse \|\| cc.doNotReuse \|\| cc.goAway != nil, StreamsActive: len(cc.streams) + cc.pendingResets, StreamsReserved: cc.streamsReserved, StreamsPending: cc.pendingRequests, LastIdle: cc.lastIdle, MaxConcurrentStreams: maxConcurrent, } } // clientConnIdleState describes the suitability of a client // connection to initiate a new RoundTrip request. type clientConnIdleState struct { canTakeNewRequest bool } func (cc ClientConn) idleState() clientConnIdleState { cc.mu.Lock() defer cc.mu.Unlock() return cc.idleStateLocked() } func (cc ClientConn) idleStateLocked() (st clientConnIdleState) { if cc.singleUse && cc.nextStreamID > 1 { return } var maxConcurrentOkay bool if cc.t.StrictMaxConcurrentStreams { // We'll tell the caller we can take a new request to // prevent the caller from dialing a new TCP // connection, but then we'll block later before // writing it. maxConcurrentOkay = true } else { // We can take a new request if the total of // - active streams; // - reservation slots for new streams; and // - streams for which we have sent a RST_STREAM and a PING, // but received no subsequent frame // is less than the concurrency limit. maxConcurrentOkay = cc.currentRequestCountLocked() < int(cc.maxConcurrentStreams) } st.canTakeNewRequest = cc.goAway == nil && !cc.closed && !cc.closing && maxConcurrentOkay && !cc.doNotReuse && int64(cc.nextStreamID)+2int64(cc.pendingRequests) < math.MaxInt32 && !cc.tooIdleLocked() // If this connection has never been used for a request and is closed, // then let it take a request (which will fail). // // This avoids a situation where an error early in a connection's lifetime // goes unreported. if cc.nextStreamID == 1 && cc.streamsReserved == 0 && cc.closed { st.canTakeNewRequest = true } return } // currentRequestCountLocked reports the number of concurrency slots currently in use, // including active streams, reserved slots, and reset streams waiting for acknowledgement. func (cc ClientConn) currentRequestCountLocked() int { return len(cc.streams) + cc.streamsReserved + cc.pendingResets } func (cc ClientConn) canTakeNewRequestLocked() bool { st := cc.idleStateLocked() return st.canTakeNewRequest } // tooIdleLocked reports whether this connection has been been sitting idle // for too much wall time. func (cc ClientConn) tooIdleLocked() bool { // The Round(0) strips the monontonic clock reading so the // times are compared based on their wall time. We don't want // to reuse a connection that's been sitting idle during // VM/laptop suspend if monotonic time was also frozen. return cc.idleTimeout != 0 && !cc.lastIdle.IsZero() && cc.t.timeSince(cc.lastIdle.Round(0)) > cc.idleTimeout } // onIdleTimeout is called from a time.AfterFunc goroutine. It will // only be called when we're idle, but because we're coming from a new // goroutine, there could be a new request coming in at the same time, // so this simply calls the synchronized closeIfIdle to shut down this // connection. The timer could just call closeIfIdle, but this is more // clear. func (cc ClientConn) onIdleTimeout() { cc.closeIfIdle() } func (cc ClientConn) closeConn() { t := time.AfterFunc(250time.Millisecond, cc.forceCloseConn) defer t.Stop() cc.tconn.Close() } // A tls.Conn.Close can hang for a long time if the peer is unresponsive. // Try to shut it down more aggressively. func (cc ClientConn) forceCloseConn() { tc, ok := cc.tconn.(tls.Conn) if !ok { return } if nc := tc.NetConn(); nc != nil { nc.Close() } } func (cc ClientConn) closeIfIdle() { cc.mu.Lock() if len(cc.streams) > 0 \|\| cc.streamsReserved > 0 { cc.mu.Unlock() return } cc.closed = true nextID := cc.nextStreamID // TODO: do clients send GOAWAY too? maybe? Just Close: cc.mu.Unlock() if VerboseLogs { cc.vlogf("http2: Transport closing idle conn %p (forSingleUse=%v, maxStream=%v)", cc, cc.singleUse, nextID-2) } cc.closeConn() } func (cc ClientConn) isDoNotReuseAndIdle() bool { cc.mu.Lock() defer cc.mu.Unlock() return cc.doNotReuse && len(cc.streams) == 0 } var shutdownEnterWaitStateHook = func() {} // Shutdown gracefully closes the client connection, waiting for running streams to complete. func (cc ClientConn) Shutdown(ctx context.Context) error { if err := cc.sendGoAway(); err != nil { return err } // Wait for all in-flight streams to complete or connection to close done := make(chan struct{}) cancelled := false // guarded by cc.mu go func() { cc.t.markNewGoroutine() cc.mu.Lock() defer cc.mu.Unlock() for { if len(cc.streams) == 0 \|\| cc.closed { cc.closed = true close(done) break } if cancelled { break } cc.cond.Wait() } }() shutdownEnterWaitStateHook() select { case <-done: cc.closeConn() return nil case <-ctx.Done(): cc.mu.Lock() // Free the goroutine above cancelled = true cc.cond.Broadcast() cc.mu.Unlock() return ctx.Err() } } func (cc ClientConn) sendGoAway() error { cc.mu.Lock() closing := cc.closing cc.closing = true maxStreamID := cc.nextStreamID cc.mu.Unlock() if closing { // GOAWAY sent already return nil } cc.wmu.Lock() defer cc.wmu.Unlock() // Send a graceful shutdown frame to server if err := cc.fr.WriteGoAway(maxStreamID, ErrCodeNo, nil); err != nil { return err } if err := cc.bw.Flush(); err != nil { return err } // Prevent new requests return nil } // closes the client connection immediately. In-flight requests are interrupted. // err is sent to streams. func (cc ClientConn) closeForError(err error) { cc.mu.Lock() cc.closed = true for _, cs := range cc.streams { cs.abortStreamLocked(err) } cc.cond.Broadcast() cc.mu.Unlock() cc.closeConn() } // Close closes the client connection immediately. // // In-flight requests are interrupted. For a graceful shutdown, use Shutdown instead. func (cc ClientConn) Close() error { err := errors.New("http2: client connection force closed via ClientConn.Close") cc.closeForError(err) return nil } // closes the client connection immediately. In-flight requests are interrupted. func (cc ClientConn) closeForLostPing() { err := errors.New("http2: client connection lost") if f := cc.t.CountError; f != nil { f("conn_close_lost_ping") } cc.closeForError(err) } // errRequestCanceled is a copy of net/http's errRequestCanceled because it's not // exported. At least they'll be DeepEqual for h1-vs-h2 comparisons tests. var errRequestCanceled = errors.New("net/http: request canceled") func commaSeparatedTrailers(req http.Request) (string, error) { keys := make([]string, 0, len(req.Trailer)) for k := range req.Trailer { k = canonicalHeader(k) switch k { case "Transfer-Encoding", "Trailer", "Content-Length": return "", fmt.Errorf("invalid Trailer key %q", k) } keys = append(keys, k) } if len(keys) > 0 { sort.Strings(keys) return strings.Join(keys, ","), nil } return "", nil } func (cc ClientConn) responseHeaderTimeout() time.Duration { if cc.t.t1 != nil { return cc.t.t1.ResponseHeaderTimeout } // No way to do this (yet?) with just an http2.Transport. Probably // no need. Request.Cancel this is the new way. We only need to support // this for compatibility with the old http.Transport fields when // we're doing transparent http2. return 0 } // checkConnHeaders checks whether req has any invalid connection-level headers. // per RFC 7540 section 8.1.2.2: Connection-Specific Header Fields. // Certain headers are special-cased as okay but not transmitted later. func checkConnHeaders(req http.Request) error { if v := req.Header.Get("Upgrade"); v != "" { return fmt.Errorf("http2: invalid Upgrade request header: %q", req.Header["Upgrade"]) } if vv := req.Header["Transfer-Encoding"]; len(vv) > 0 && (len(vv) > 1 \|\| vv[0] != "" && vv[0] != "chunked") { return fmt.Errorf("http2: invalid Transfer-Encoding request header: %q", vv) } if vv := req.Header["Connection"]; len(vv) > 0 && (len(vv) > 1 \|\| vv[0] != "" && !asciiEqualFold(vv[0], "close") && !asciiEqualFold(vv[0], "keep-alive")) { return fmt.Errorf("http2: invalid Connection request header: %q", vv) } return nil } // actualContentLength returns a sanitized version of // req.ContentLength, where 0 actually means zero (not unknown) and -1 // means unknown. func actualContentLength(req http.Request) int64 { if req.Body == nil \|\| req.Body == http.NoBody { return 0 } if req.ContentLength != 0 { return req.ContentLength } return -1 } func (cc ClientConn) decrStreamReservations() { cc.mu.Lock() defer cc.mu.Unlock() cc.decrStreamReservationsLocked() } func (cc ClientConn) decrStreamReservationsLocked() { if cc.streamsReserved > 0 { cc.streamsReserved-- } } func (cc ClientConn) RoundTrip(req http.Request) (http.Response, error) { return cc.roundTrip(req, nil) } func (cc ClientConn) roundTrip(req http.Request, streamf func(clientStream)) (http.Response, error) { ctx := req.Context() cs := &clientStream{ cc: cc, ctx: ctx, reqCancel: req.Cancel, isHead: req.Method == "HEAD", reqBody: req.Body, reqBodyContentLength: actualContentLength(req), trace: httptrace.ContextClientTrace(ctx), peerClosed: make(chan struct{}), abort: make(chan struct{}), respHeaderRecv: make(chan struct{}), donec: make(chan struct{}), } // TODO(bradfitz): this is a copy of the logic in net/http. Unify somewhere? if !cc.t.disableCompression() && req.Header.Get("Accept-Encoding") == "" && req.Header.Get("Range") == "" && !cs.isHead { // Request gzip only, not deflate. Deflate is ambiguous and // not as universally supported anyway. // See: https://zlib.net/zlib_faq.html#faq39 // // Note that we don't request this for HEAD requests, // due to a bug in nginx: // http://trac.nginx.org/nginx/ticket/358 // https://golang.org/issue/5522 // // We don't request gzip if the request is for a range, since // auto-decoding a portion of a gzipped document will just fail // anyway. See https://golang.org/issue/8923 cs.requestedGzip = true } go cs.doRequest(req, streamf) waitDone := func() error { select { case <-cs.donec: return nil case <-ctx.Done(): return ctx.Err() case <-cs.reqCancel: return errRequestCanceled } } handleResponseHeaders := func() (http.Response, error) { res := cs.res if res.StatusCode > 299 { // On error or status code 3xx, 4xx, 5xx, etc abort any // ongoing write, assuming that the server doesn't care // about our request body. If the server replied with 1xx or // 2xx, however, then assume the server DOES potentially // want our body (e.g. full-duplex streaming: // golang.org/issue/13444). If it turns out the server // doesn't, they'll RST_STREAM us soon enough. This is a // heuristic to avoid adding knobs to Transport. Hopefully // we can keep it. cs.abortRequestBodyWrite() } res.Request = req res.TLS = cc.tlsState if res.Body == noBody && actualContentLength(req) == 0 { // If there isn't a request or response body still being // written, then wait for the stream to be closed before // RoundTrip returns. if err := waitDone(); err != nil { return nil, err } } return res, nil } cancelRequest := func(cs clientStream, err error) error { cs.cc.mu.Lock() bodyClosed := cs.reqBodyClosed cs.cc.mu.Unlock() // Wait for the request body to be closed. // // If nothing closed the body before now, abortStreamLocked // will have started a goroutine to close it. // // Closing the body before returning avoids a race condition // with net/http checking its readTrackingBody to see if the // body was read from or closed. See golang/go#60041. // // The body is closed in a separate goroutine without the // connection mutex held, but dropping the mutex before waiting // will keep us from holding it indefinitely if the body // close is slow for some reason. if bodyClosed != nil { <-bodyClosed } return err } for { select { case <-cs.respHeaderRecv: return handleResponseHeaders() case <-cs.abort: select { case <-cs.respHeaderRecv: // If both cs.respHeaderRecv and cs.abort are signaling, // pick respHeaderRecv. The server probably wrote the // response and immediately reset the stream. // golang.org/issue/49645 return handleResponseHeaders() default: waitDone() return nil, cs.abortErr } case <-ctx.Done(): err := ctx.Err() cs.abortStream(err) return nil, cancelRequest(cs, err) case <-cs.reqCancel: cs.abortStream(errRequestCanceled) return nil, cancelRequest(cs, errRequestCanceled) } } } // doRequest runs for the duration of the request lifetime. // // It sends the request and performs post-request cleanup (closing Request.Body, etc.). func (cs clientStream) doRequest(req http.Request, streamf func(clientStream)) { cs.cc.t.markNewGoroutine() err := cs.writeRequest(req, streamf) cs.cleanupWriteRequest(err) } var errExtendedConnectNotSupported = errors.New("net/http: extended connect not supported by peer") // writeRequest sends a request. // // It returns nil after the request is written, the response read, // and the request stream is half-closed by the peer. // // It returns non-nil if the request ends otherwise. // If the returned error is StreamError, the error Code may be used in resetting the stream. func (cs clientStream) writeRequest(req http.Request, streamf func(clientStream)) (err error) { cc := cs.cc ctx := cs.ctx if err := checkConnHeaders(req); err != nil { return err } // wait for setting frames to be received, a server can change this value later, // but we just wait for the first settings frame var isExtendedConnect bool if req.Method == "CONNECT" && req.Header.Get(":protocol") != "" { isExtendedConnect = true } // Acquire the new-request lock by writing to reqHeaderMu. // This lock guards the critical section covering allocating a new stream ID // (requires mu) and creating the stream (requires wmu). if cc.reqHeaderMu == nil { panic("RoundTrip on uninitialized ClientConn") // for tests } if isExtendedConnect { select { case <-cs.reqCancel: return errRequestCanceled case <-ctx.Done(): return ctx.Err() case <-cc.seenSettingsChan: if !cc.extendedConnectAllowed { return errExtendedConnectNotSupported } } } select { case cc.reqHeaderMu <- struct{}{}: case <-cs.reqCancel: return errRequestCanceled case <-ctx.Done(): return ctx.Err() } cc.mu.Lock() if cc.idleTimer != nil { cc.idleTimer.Stop() } cc.decrStreamReservationsLocked() if err := cc.awaitOpenSlotForStreamLocked(cs); err != nil { cc.mu.Unlock() <-cc.reqHeaderMu return err } cc.addStreamLocked(cs) // assigns stream ID if isConnectionCloseRequest(req) { cc.doNotReuse = true } cc.mu.Unlock() if streamf != nil { streamf(cs) } continueTimeout := cc.t.expectContinueTimeout() if continueTimeout != 0 { if !httpguts.HeaderValuesContainsToken(req.Header["Expect"], "100-continue") { continueTimeout = 0 } else { cs.on100 = make(chan struct{}, 1) } } // Past this point (where we send request headers), it is possible for // RoundTrip to return successfully. Since the RoundTrip contract permits // the caller to "mutate or reuse" the Request after closing the Response's Body, // we must take care when referencing the Request from here on. err = cs.encodeAndWriteHeaders(req) <-cc.reqHeaderMu if err != nil { return err } hasBody := cs.reqBodyContentLength != 0 if !hasBody { cs.sentEndStream = true } else { if continueTimeout != 0 { traceWait100Continue(cs.trace) timer := time.NewTimer(continueTimeout) select { case <-timer.C: err = nil case <-cs.on100: err = nil case <-cs.abort: err = cs.abortErr case <-ctx.Done(): err = ctx.Err() case <-cs.reqCancel: err = errRequestCanceled } timer.Stop() if err != nil { traceWroteRequest(cs.trace, err) return err } } if err = cs.writeRequestBody(req); err != nil { if err != errStopReqBodyWrite { traceWroteRequest(cs.trace, err) return err } } else { cs.sentEndStream = true } } traceWroteRequest(cs.trace, err) var respHeaderTimer <-chan time.Time var respHeaderRecv chan struct{} if d := cc.responseHeaderTimeout(); d != 0 { timer := cc.t.newTimer(d) defer timer.Stop() respHeaderTimer = timer.C() respHeaderRecv = cs.respHeaderRecv } // Wait until the peer half-closes its end of the stream, // or until the request is aborted (via context, error, or otherwise), // whichever comes first. for { select { case <-cs.peerClosed: return nil case <-respHeaderTimer: return errTimeout case <-respHeaderRecv: respHeaderRecv = nil respHeaderTimer = nil // keep waiting for END_STREAM case <-cs.abort: return cs.abortErr case <-ctx.Done(): return ctx.Err() case <-cs.reqCancel: return errRequestCanceled } } } func (cs clientStream) encodeAndWriteHeaders(req http.Request) error { cc := cs.cc ctx := cs.ctx cc.wmu.Lock() defer cc.wmu.Unlock() // If the request was canceled while waiting for cc.mu, just quit. select { case <-cs.abort: return cs.abortErr case <-ctx.Done(): return ctx.Err() case <-cs.reqCancel: return errRequestCanceled default: } // Encode headers. // // we send: HEADERS{1}, CONTINUATION{0,} + DATA{0,} (DATA is // sent by writeRequestBody below, along with any Trailers, // again in form HEADERS{1}, CONTINUATION{0,}) trailers, err := commaSeparatedTrailers(req) if err != nil { return err } hasTrailers := trailers != "" contentLen := actualContentLength(req) hasBody := contentLen != 0 hdrs, err := cc.encodeHeaders(req, cs.requestedGzip, trailers, contentLen) if err != nil { return err } // Write the request. endStream := !hasBody && !hasTrailers cs.sentHeaders = true err = cc.writeHeaders(cs.ID, endStream, int(cc.maxFrameSize), hdrs) traceWroteHeaders(cs.trace) return err } // cleanupWriteRequest performs post-request tasks. // // If err (the result of writeRequest) is non-nil and the stream is not closed, // cleanupWriteRequest will send a reset to the peer. func (cs clientStream) cleanupWriteRequest(err error) { cc := cs.cc if cs.ID == 0 { // We were canceled before creating the stream, so return our reservation. cc.decrStreamReservations() } // TODO: write h12Compare test showing whether // Request.Body is closed by the Transport, // and in multiple cases: server replies <=299 and >299 // while still writing request body cc.mu.Lock() mustCloseBody := false if cs.reqBody != nil && cs.reqBodyClosed == nil { mustCloseBody = true cs.reqBodyClosed = make(chan struct{}) } bodyClosed := cs.reqBodyClosed closeOnIdle := cc.singleUse \|\| cc.doNotReuse \|\| cc.t.disableKeepAlives() \|\| cc.goAway != nil cc.mu.Unlock() if mustCloseBody { cs.reqBody.Close() close(bodyClosed) } if bodyClosed != nil { <-bodyClosed } if err != nil && cs.sentEndStream { // If the connection is closed immediately after the response is read, // we may be aborted before finishing up here. If the stream was closed // cleanly on both sides, there is no error. select { case <-cs.peerClosed: err = nil default: } } if err != nil { cs.abortStream(err) // possibly redundant, but harmless if cs.sentHeaders { if se, ok := err.(StreamError); ok { if se.Cause != errFromPeer { cc.writeStreamReset(cs.ID, se.Code, false, err) } } else { // We're cancelling an in-flight request. // // This could be due to the server becoming unresponsive. // To avoid sending too many requests on a dead connection, // we let the request continue to consume a concurrency slot // until we can confirm the server is still responding. // We do this by sending a PING frame along with the RST_STREAM // (unless a ping is already in flight). // // For simplicity, we don't bother tracking the PING payload: // We reset cc.pendingResets any time we receive a PING ACK. // // We skip this if the conn is going to be closed on idle, // because it's short lived and will probably be closed before // we get the ping response. ping := false if !closeOnIdle { cc.mu.Lock() // rstStreamPingsBlocked works around a gRPC behavior: // see comment on the field for details. if !cc.rstStreamPingsBlocked { if cc.pendingResets == 0 { ping = true } cc.pendingResets++ } cc.mu.Unlock() } cc.writeStreamReset(cs.ID, ErrCodeCancel, ping, err) } } cs.bufPipe.CloseWithError(err) // no-op if already closed } else { if cs.sentHeaders && !cs.sentEndStream { cc.writeStreamReset(cs.ID, ErrCodeNo, false, nil) } cs.bufPipe.CloseWithError(errRequestCanceled) } if cs.ID != 0 { cc.forgetStreamID(cs.ID) } cc.wmu.Lock() werr := cc.werr cc.wmu.Unlock() if werr != nil { cc.Close() } close(cs.donec) } // awaitOpenSlotForStreamLocked waits until len(streams) < maxConcurrentStreams. // Must hold cc.mu. func (cc ClientConn) awaitOpenSlotForStreamLocked(cs clientStream) error { for { if cc.closed && cc.nextStreamID == 1 && cc.streamsReserved == 0 { // This is the very first request sent to this connection. // Return a fatal error which aborts the retry loop. return errClientConnNotEstablished } cc.lastActive = cc.t.now() if cc.closed \|\| !cc.canTakeNewRequestLocked() { return errClientConnUnusable } cc.lastIdle = time.Time{} if cc.currentRequestCountLocked() < int(cc.maxConcurrentStreams) { return nil } cc.pendingRequests++ cc.cond.Wait() cc.pendingRequests-- select { case <-cs.abort: return cs.abortErr default: } } } // requires cc.wmu be held func (cc ClientConn) writeHeaders(streamID uint32, endStream bool, maxFrameSize int, hdrs []byte) error { first := true // first frame written (HEADERS is first, then CONTINUATION) for len(hdrs) > 0 && cc.werr == nil { chunk := hdrs if len(chunk) > maxFrameSize { chunk = chunk[:maxFrameSize] } hdrs = hdrs[len(chunk):] endHeaders := len(hdrs) == 0 if first { cc.fr.WriteHeaders(HeadersFrameParam{ StreamID: streamID, BlockFragment: chunk, EndStream: endStream, EndHeaders: endHeaders, }) first = false } else { cc.fr.WriteContinuation(streamID, endHeaders, chunk) } } cc.bw.Flush() return cc.werr } // internal error values; they don't escape to callers var ( // abort request body write; don't send cancel errStopReqBodyWrite = errors.New("http2: aborting request body write") // abort request body write, but send stream reset of cancel. errStopReqBodyWriteAndCancel = errors.New("http2: canceling request") errReqBodyTooLong = errors.New("http2: request body larger than specified content length") ) // frameScratchBufferLen returns the length of a buffer to use for // outgoing request bodies to read/write to/from. // // It returns max(1, min(peer's advertised max frame size, // Request.ContentLength+1, 512KB)). func (cs clientStream) frameScratchBufferLen(maxFrameSize int) int { const max = 512 << 10 n := int64(maxFrameSize) if n > max { n = max } if cl := cs.reqBodyContentLength; cl != -1 && cl+1 < n { // Add an extra byte past the declared content-length to // give the caller's Request.Body io.Reader a chance to // give us more bytes than they declared, so we can catch it // early. n = cl + 1 } if n < 1 { return 1 } return int(n) // doesn't truncate; max is 512K } // Seven bufPools manage different frame sizes. This helps to avoid scenarios where long-running // streaming requests using small frame sizes occupy large buffers initially allocated for prior // requests needing big buffers. The size ranges are as follows: // {0 KB, 16 KB], {16 KB, 32 KB], {32 KB, 64 KB], {64 KB, 128 KB], {128 KB, 256 KB], // {256 KB, 512 KB], {512 KB, infinity} // In practice, the maximum scratch buffer size should not exceed 512 KB due to // frameScratchBufferLen(maxFrameSize), thus the "infinity pool" should never be used. // It exists mainly as a safety measure, for potential future increases in max buffer size. var bufPools [7]sync.Pool // of []byte func bufPoolIndex(size int) int { if size <= 16384 { return 0 } size -= 1 bits := bits.Len(uint(size)) index := bits - 14 if index >= len(bufPools) { return len(bufPools) - 1 } return index } func (cs clientStream) writeRequestBody(req http.Request) (err error) { cc := cs.cc body := cs.reqBody sentEnd := false // whether we sent the final DATA frame w/ END_STREAM hasTrailers := req.Trailer != nil remainLen := cs.reqBodyContentLength hasContentLen := remainLen != -1 cc.mu.Lock() maxFrameSize := int(cc.maxFrameSize) cc.mu.Unlock() // Scratch buffer for reading into & writing from. scratchLen := cs.frameScratchBufferLen(maxFrameSize) var buf []byte index := bufPoolIndex(scratchLen) if bp, ok := bufPools[index].Get().([]byte); ok && len(bp) >= scratchLen { defer bufPools[index].Put(bp) buf = bp } else { buf = make([]byte, scratchLen) defer bufPools[index].Put(&buf) } var sawEOF bool for !sawEOF { n, err := body.Read(buf) if hasContentLen { remainLen -= int64(n) if remainLen == 0 && err == nil { // The request body's Content-Length was predeclared and // we just finished reading it all, but the underlying io.Reader // returned the final chunk with a nil error (which is one of // the two valid things a Reader can do at EOF). Because we'd prefer // to send the END_STREAM bit early, double-check that we're actually // at EOF. Subsequent reads should return (0, EOF) at this point. // If either value is different, we return an error in one of two ways below. var scratch [1]byte var n1 int n1, err = body.Read(scratch[:]) remainLen -= int64(n1) } if remainLen < 0 { err = errReqBodyTooLong return err } } if err != nil { cc.mu.Lock() bodyClosed := cs.reqBodyClosed != nil cc.mu.Unlock() switch { case bodyClosed: return errStopReqBodyWrite case err == io.EOF: sawEOF = true err = nil default: return err } } remain := buf[:n] for len(remain) > 0 && err == nil { var allowed int32 allowed, err = cs.awaitFlowControl(len(remain)) if err != nil { return err } cc.wmu.Lock() data := remain[:allowed] remain = remain[allowed:] sentEnd = sawEOF && len(remain) == 0 && !hasTrailers err = cc.fr.WriteData(cs.ID, sentEnd, data) if err == nil { // TODO(bradfitz): this flush is for latency, not bandwidth. // Most requests won't need this. Make this opt-in or // opt-out? Use some heuristic on the body type? Nagel-like // timers? Based on 'n'? Only last chunk of this for loop, // unless flow control tokens are low? For now, always. // If we change this, see comment below. err = cc.bw.Flush() } cc.wmu.Unlock() } if err != nil { return err } } if sentEnd { // Already sent END_STREAM (which implies we have no // trailers) and flushed, because currently all // WriteData frames above get a flush. So we're done. return nil } // Since the RoundTrip contract permits the caller to "mutate or reuse" // a request after the Response's Body is closed, verify that this hasn't // happened before accessing the trailers. cc.mu.Lock() trailer := req.Trailer err = cs.abortErr cc.mu.Unlock() if err != nil { return err } cc.wmu.Lock() defer cc.wmu.Unlock() var trls []byte if len(trailer) > 0 { trls, err = cc.encodeTrailers(trailer) if err != nil { return err } } // Two ways to send END_STREAM: either with trailers, or // with an empty DATA frame. if len(trls) > 0 { err = cc.writeHeaders(cs.ID, true, maxFrameSize, trls) } else { err = cc.fr.WriteData(cs.ID, true, nil) } if ferr := cc.bw.Flush(); ferr != nil && err == nil { err = ferr } return err } // awaitFlowControl waits for [1, min(maxBytes, cc.cs.maxFrameSize)] flow // control tokens from the server. // It returns either the non-zero number of tokens taken or an error // if the stream is dead. func (cs clientStream) awaitFlowControl(maxBytes int) (taken int32, err error) { cc := cs.cc ctx := cs.ctx cc.mu.Lock() defer cc.mu.Unlock() for { if cc.closed { return 0, errClientConnClosed } if cs.reqBodyClosed != nil { return 0, errStopReqBodyWrite } select { case <-cs.abort: return 0, cs.abortErr case <-ctx.Done(): return 0, ctx.Err() case <-cs.reqCancel: return 0, errRequestCanceled default: } if a := cs.flow.available(); a > 0 { take := a if int(take) > maxBytes { take = int32(maxBytes) // can't truncate int; take is int32 } if take > int32(cc.maxFrameSize) { take = int32(cc.maxFrameSize) } cs.flow.take(take) return take, nil } cc.cond.Wait() } } func validateHeaders(hdrs http.Header) string { for k, vv := range hdrs { if !httpguts.ValidHeaderFieldName(k) && k != ":protocol" { return fmt.Sprintf("name %q", k) } for _, v := range vv { if !httpguts.ValidHeaderFieldValue(v) { // Don't include the value in the error, // because it may be sensitive. return fmt.Sprintf("value for header %q", k) } } } return "" } var errNilRequestURL = errors.New("http2: Request.URI is nil") func isNormalConnect(req http.Request) bool { return req.Method == "CONNECT" && req.Header.Get(":protocol") == "" } // requires cc.wmu be held. func (cc ClientConn) encodeHeaders(req http.Request, addGzipHeader bool, trailers string, contentLength int64) ([]byte, error) { cc.hbuf.Reset() if req.URL == nil { return nil, errNilRequestURL } host := req.Host if host == "" { host = req.URL.Host } host, err := httpguts.PunycodeHostPort(host) if err != nil { return nil, err } if !httpguts.ValidHostHeader(host) { return nil, errors.New("http2: invalid Host header") } var path string if !isNormalConnect(req) { path = req.URL.RequestURI() if !validPseudoPath(path) { orig := path path = strings.TrimPrefix(path, req.URL.Scheme+"://"+host) if !validPseudoPath(path) { if req.URL.Opaque != "" { return nil, fmt.Errorf("invalid request :path %q from URL.Opaque = %q", orig, req.URL.Opaque) } else { return nil, fmt.Errorf("invalid request :path %q", orig) } } } } // Check for any invalid headers+trailers and return an error before we // potentially pollute our hpack state. (We want to be able to // continue to reuse the hpack encoder for future requests) if err := validateHeaders(req.Header); err != "" { return nil, fmt.Errorf("invalid HTTP header %s", err) } if err := validateHeaders(req.Trailer); err != "" { return nil, fmt.Errorf("invalid HTTP trailer %s", err) } enumerateHeaders := func(f func(name, value string)) { // 8.1.2.3 Request Pseudo-Header Fields // The :path pseudo-header field includes the path and query parts of the // target URI (the path-absolute production and optionally a '?' character // followed by the query production, see Sections 3.3 and 3.4 of // [RFC3986]). f(":authority", host) m := req.Method if m == "" { m = http.MethodGet } f(":method", m) if !isNormalConnect(req) { f(":path", path) f(":scheme", req.URL.Scheme) } if trailers != "" { f("trailer", trailers) } var didUA bool for k, vv := range req.Header { if asciiEqualFold(k, "host") \|\| asciiEqualFold(k, "content-length") { // Host is :authority, already sent. // Content-Length is automatic, set below. continue } else if asciiEqualFold(k, "connection") \|\| asciiEqualFold(k, "proxy-connection") \|\| asciiEqualFold(k, "transfer-encoding") \|\| asciiEqualFold(k, "upgrade") \|\| asciiEqualFold(k, "keep-alive") { // Per 8.1.2.2 Connection-Specific Header // Fields, don't send connection-specific // fields. We have already checked if any // are error-worthy so just ignore the rest. continue } else if asciiEqualFold(k, "user-agent") { // Match Go's http1 behavior: at most one // User-Agent. If set to nil or empty string, // then omit it. Otherwise if not mentioned, // include the default (below). didUA = true if len(vv) < 1 { continue } vv = vv[:1] if vv[0] == "" { continue } } else if asciiEqualFold(k, "cookie") { // Per 8.1.2.5 To allow for better compression efficiency, the // Cookie header field MAY be split into separate header fields, // each with one or more cookie-pairs. for _, v := range vv { for { p := strings.IndexByte(v, ';') if p < 0 { break } f("cookie", v[:p]) p++ // strip space after semicolon if any. for p+1 <= len(v) && v[p] == ' ' { p++ } v = v[p:] } if len(v) > 0 { f("cookie", v) } } continue } for _, v := range vv { f(k, v) } } if shouldSendReqContentLength(req.Method, contentLength) { f("content-length", strconv.FormatInt(contentLength, 10)) } if addGzipHeader { f("accept-encoding", "gzip") } if !didUA { f("user-agent", defaultUserAgent) } } // Do a first pass over the headers counting bytes to ensure // we don't exceed cc.peerMaxHeaderListSize. This is done as a // separate pass before encoding the headers to prevent // modifying the hpack state. hlSize := uint64(0) enumerateHeaders(func(name, value string) { hf := hpack.HeaderField{Name: name, Value: value} hlSize += uint64(hf.Size()) }) if hlSize > cc.peerMaxHeaderListSize { return nil, errRequestHeaderListSize } trace := httptrace.ContextClientTrace(req.Context()) traceHeaders := traceHasWroteHeaderField(trace) // Header list size is ok. Write the headers. enumerateHeaders(func(name, value string) { name, ascii := lowerHeader(name) if !ascii { // Skip writing invalid headers. Per RFC 7540, Section 8.1.2, header // field names have to be ASCII characters (just as in HTTP/1.x). return } cc.writeHeader(name, value) if traceHeaders { traceWroteHeaderField(trace, name, value) } }) return cc.hbuf.Bytes(), nil } // shouldSendReqContentLength reports whether the http2.Transport should send // a "content-length" request header. This logic is basically a copy of the net/http // transferWriter.shouldSendContentLength. // The contentLength is the corrected contentLength (so 0 means actually 0, not unknown). // -1 means unknown. func shouldSendReqContentLength(method string, contentLength int64) bool { if contentLength > 0 { return true } if contentLength < 0 { return false } // For zero bodies, whether we send a content-length depends on the method. // It also kinda doesn't matter for http2 either way, with END_STREAM. switch method { case "POST", "PUT", "PATCH": return true default: return false } } // requires cc.wmu be held. func (cc ClientConn) encodeTrailers(trailer http.Header) ([]byte, error) { cc.hbuf.Reset() hlSize := uint64(0) for k, vv := range trailer { for _, v := range vv { hf := hpack.HeaderField{Name: k, Value: v} hlSize += uint64(hf.Size()) } } if hlSize > cc.peerMaxHeaderListSize { return nil, errRequestHeaderListSize } for k, vv := range trailer { lowKey, ascii := lowerHeader(k) if !ascii { // Skip writing invalid headers. Per RFC 7540, Section 8.1.2, header // field names have to be ASCII characters (just as in HTTP/1.x). continue } // Transfer-Encoding, etc.. have already been filtered at the // start of RoundTrip for _, v := range vv { cc.writeHeader(lowKey, v) } } return cc.hbuf.Bytes(), nil } func (cc ClientConn) writeHeader(name, value string) { if VerboseLogs { log.Printf("http2: Transport encoding header %q = %q", name, value) } cc.henc.WriteField(hpack.HeaderField{Name: name, Value: value}) } type resAndError struct { _ incomparable res http.Response err error } // requires cc.mu be held. func (cc ClientConn) addStreamLocked(cs clientStream) { cs.flow.add(int32(cc.initialWindowSize)) cs.flow.setConnFlow(&cc.flow) cs.inflow.init(cc.initialStreamRecvWindowSize) cs.ID = cc.nextStreamID cc.nextStreamID += 2 cc.streams[cs.ID] = cs if cs.ID == 0 { panic("assigned stream ID 0") } } func (cc ClientConn) forgetStreamID(id uint32) { cc.mu.Lock() slen := len(cc.streams) delete(cc.streams, id) if len(cc.streams) != slen-1 { panic("forgetting unknown stream id") } cc.lastActive = cc.t.now() if len(cc.streams) == 0 && cc.idleTimer != nil { cc.idleTimer.Reset(cc.idleTimeout) cc.lastIdle = cc.t.now() } // Wake up writeRequestBody via clientStream.awaitFlowControl and // wake up RoundTrip if there is a pending request. cc.cond.Broadcast() closeOnIdle := cc.singleUse \|\| cc.doNotReuse \|\| cc.t.disableKeepAlives() \|\| cc.goAway != nil if closeOnIdle && cc.streamsReserved == 0 && len(cc.streams) == 0 { if VerboseLogs { cc.vlogf("http2: Transport closing idle conn %p (forSingleUse=%v, maxStream=%v)", cc, cc.singleUse, cc.nextStreamID-2) } cc.closed = true defer cc.closeConn() } cc.mu.Unlock() } // clientConnReadLoop is the state owned by the clientConn's frame-reading readLoop. type clientConnReadLoop struct { _ incomparable cc ClientConn } // readLoop runs in its own goroutine and reads and dispatches frames. func (cc ClientConn) readLoop() { cc.t.markNewGoroutine() rl := &clientConnReadLoop{cc: cc} defer rl.cleanup() cc.readerErr = rl.run() if ce, ok := cc.readerErr.(ConnectionError); ok { cc.wmu.Lock() cc.fr.WriteGoAway(0, ErrCode(ce), nil) cc.wmu.Unlock() } } // GoAwayError is returned by the Transport when the server closes the // TCP connection after sending a GOAWAY frame. type GoAwayError struct { LastStreamID uint32 ErrCode ErrCode DebugData string } func (e GoAwayError) Error() string { return fmt.Sprintf("http2: server sent GOAWAY and closed the connection; LastStreamID=%v, ErrCode=%v, debug=%q", e.LastStreamID, e.ErrCode, e.DebugData) } func isEOFOrNetReadError(err error) bool { if err == io.EOF { return true } ne, ok := err.(net.OpError) return ok && ne.Op == "read" } func (rl clientConnReadLoop) cleanup() { cc := rl.cc defer cc.closeConn() defer close(cc.readerDone) if cc.idleTimer != nil { cc.idleTimer.Stop() } // Close any response bodies if the server closes prematurely. // TODO: also do this if we've written the headers but not // gotten a response yet. err := cc.readerErr cc.mu.Lock() if cc.goAway != nil && isEOFOrNetReadError(err) { err = GoAwayError{ LastStreamID: cc.goAway.LastStreamID, ErrCode: cc.goAway.ErrCode, DebugData: cc.goAwayDebug, } } else if err == io.EOF { err = io.ErrUnexpectedEOF } cc.closed = true // If the connection has never been used, and has been open for only a short time, // leave it in the connection pool for a little while. // // This avoids a situation where new connections are constantly created, // added to the pool, fail, and are removed from the pool, without any error // being surfaced to the user. const unusedWaitTime = 5 * time.Second idleTime := cc.t.now().Sub(cc.lastActive) if atomic.LoadUint32(&cc.atomicReused) == 0 && idleTime < unusedWaitTime { cc.idleTimer = cc.t.afterFunc(unusedWaitTime-idleTime, func() { cc.t.connPool().MarkDead(cc) }) } else { cc.mu.Unlock() // avoid any deadlocks in MarkDead cc.t.connPool().MarkDead(cc) cc.mu.Lock() } for _, cs := range cc.streams { select { case <-cs.peerClosed: // The server closed the stream before closing the conn, // so no need to interrupt it. default: cs.abortStreamLocked(err) } } cc.cond.Broadcast() cc.mu.Unlock() } // countReadFrameError calls Transport.CountError with a string // representing err. func (cc ClientConn) countReadFrameError(err error) { f := cc.t.CountError if f == nil \|\| err == nil { return } if ce, ok := err.(ConnectionError); ok { errCode := ErrCode(ce) f(fmt.Sprintf("read_frame_conn_error_%s", errCode.stringToken())) return } if errors.Is(err, io.EOF) { f("read_frame_eof") return } if errors.Is(err, io.ErrUnexpectedEOF) { f("read_frame_unexpected_eof") return } if errors.Is(err, ErrFrameTooLarge) { f("read_frame_too_large") return } f("read_frame_other") } func (rl clientConnReadLoop) run() error { cc := rl.cc gotSettings := false readIdleTimeout := cc.readIdleTimeout var t timer if readIdleTimeout != 0 { t = cc.t.afterFunc(readIdleTimeout, cc.healthCheck) } for { f, err := cc.fr.ReadFrame() if t != nil { t.Reset(readIdleTimeout) } if err != nil { cc.vlogf("http2: Transport readFrame error on conn %p: (%T) %v", cc, err, err) } if se, ok := err.(StreamError); ok { if cs := rl.streamByID(se.StreamID, notHeaderOrDataFrame); cs != nil { if se.Cause == nil { se.Cause = cc.fr.errDetail } rl.endStreamError(cs, se) } continue } else if err != nil { cc.countReadFrameError(err) return err } if VerboseLogs { cc.vlogf("http2: Transport received %s", summarizeFrame(f)) } if !gotSettings { if _, ok := f.(SettingsFrame); !ok { cc.logf("protocol error: received %T before a SETTINGS frame", f) return ConnectionError(ErrCodeProtocol) } gotSettings = true } switch f := f.(type) { case MetaHeadersFrame: err = rl.processHeaders(f) case DataFrame: err = rl.processData(f) case GoAwayFrame: err = rl.processGoAway(f) case RSTStreamFrame: err = rl.processResetStream(f) case SettingsFrame: err = rl.processSettings(f) case PushPromiseFrame: err = rl.processPushPromise(f) case WindowUpdateFrame: err = rl.processWindowUpdate(f) case PingFrame: err = rl.processPing(f) default: cc.logf("Transport: unhandled response frame type %T", f) } if err != nil { if VerboseLogs { cc.vlogf("http2: Transport conn %p received error from processing frame %v: %v", cc, summarizeFrame(f), err) } if !cc.seenSettings { close(cc.seenSettingsChan) } return err } } } func (rl clientConnReadLoop) processHeaders(f MetaHeadersFrame) error { cs := rl.streamByID(f.StreamID, headerOrDataFrame) if cs == nil { // We'd get here if we canceled a request while the // server had its response still in flight. So if this // was just something we canceled, ignore it. return nil } if cs.readClosed { rl.endStreamError(cs, StreamError{ StreamID: f.StreamID, Code: ErrCodeProtocol, Cause: errors.New("protocol error: headers after END_STREAM"), }) return nil } if !cs.firstByte { if cs.trace != nil { // TODO(bradfitz): move first response byte earlier, // when we first read the 9 byte header, not waiting // until all the HEADERS+CONTINUATION frames have been // merged. This works for now. traceFirstResponseByte(cs.trace) } cs.firstByte = true } if !cs.pastHeaders { cs.pastHeaders = true } else { return rl.processTrailers(cs, f) } res, err := rl.handleResponse(cs, f) if err != nil { if _, ok := err.(ConnectionError); ok { return err } // Any other error type is a stream error. rl.endStreamError(cs, StreamError{ StreamID: f.StreamID, Code: ErrCodeProtocol, Cause: err, }) return nil // return nil from process funcs to keep conn alive } if res == nil { // (nil, nil) special case. See handleResponse docs. return nil } cs.resTrailer = &res.Trailer cs.res = res close(cs.respHeaderRecv) if f.StreamEnded() { rl.endStream(cs) } return nil } // may return error types nil, or ConnectionError. Any other error value // is a StreamError of type ErrCodeProtocol. The returned error in that case // is the detail. // // As a special case, handleResponse may return (nil, nil) to skip the // frame (currently only used for 1xx responses). func (rl clientConnReadLoop) handleResponse(cs clientStream, f MetaHeadersFrame) (http.Response, error) { if f.Truncated { return nil, errResponseHeaderListSize } status := f.PseudoValue("status") if status == "" { return nil, errors.New("malformed response from server: missing status pseudo header") } statusCode, err := strconv.Atoi(status) if err != nil { return nil, errors.New("malformed response from server: malformed non-numeric status pseudo header") } regularFields := f.RegularFields() strs := make([]string, len(regularFields)) header := make(http.Header, len(regularFields)) res := &http.Response{ Proto: "HTTP/2.0", ProtoMajor: 2, Header: header, StatusCode: statusCode, Status: status + " " + http.StatusText(statusCode), } for _, hf := range regularFields { key := canonicalHeader(hf.Name) if key == "Trailer" { t := res.Trailer if t == nil { t = make(http.Header) res.Trailer = t } foreachHeaderElement(hf.Value, func(v string) { t[canonicalHeader(v)] = nil }) } else { vv := header[key] if vv == nil && len(strs) > 0 { // More than likely this will be a single-element key. // Most headers aren't multi-valued. // Set the capacity on strs[0] to 1, so any future append // won't extend the slice into the other strings. vv, strs = strs[:1:1], strs[1:] vv[0] = hf.Value header[key] = vv } else { header[key] = append(vv, hf.Value) } } } if statusCode >= 100 && statusCode <= 199 { if f.StreamEnded() { return nil, errors.New("1xx informational response with END_STREAM flag") } if fn := cs.get1xxTraceFunc(); fn != nil { // If the 1xx response is being delivered to the user, // then they're responsible for limiting the number // of responses. if err := fn(statusCode, textproto.MIMEHeader(header)); err != nil { return nil, err } } else { // If the user didn't examine the 1xx response, then we // limit the size of all 1xx headers. // // This differs a bit from the HTTP/1 implementation, which // limits the size of all 1xx headers plus the final response. // Use the larger limit of MaxHeaderListSize and // net/http.Transport.MaxResponseHeaderBytes. limit := int64(cs.cc.t.maxHeaderListSize()) if t1 := cs.cc.t.t1; t1 != nil && t1.MaxResponseHeaderBytes > limit { limit = t1.MaxResponseHeaderBytes } for _, h := range f.Fields { cs.totalHeaderSize += int64(h.Size()) } if cs.totalHeaderSize > limit { if VerboseLogs { log.Printf("http2: 1xx informational responses too large") } return nil, errors.New("header list too large") } } if statusCode == 100 { traceGot100Continue(cs.trace) select { case cs.on100 <- struct{}{}: default: } } cs.pastHeaders = false // do it all again return nil, nil } res.ContentLength = -1 if clens := res.Header["Content-Length"]; len(clens) == 1 { if cl, err := strconv.ParseUint(clens[0], 10, 63); err == nil { res.ContentLength = int64(cl) } else { // TODO: care? unlike http/1, it won't mess up our framing, so it's // more safe smuggling-wise to ignore. } } else if len(clens) > 1 { // TODO: care? unlike http/1, it won't mess up our framing, so it's // more safe smuggling-wise to ignore. } else if f.StreamEnded() && !cs.isHead { res.ContentLength = 0 } if cs.isHead { res.Body = noBody return res, nil } if f.StreamEnded() { if res.ContentLength > 0 { res.Body = missingBody{} } else { res.Body = noBody } return res, nil } cs.bufPipe.setBuffer(&dataBuffer{expected: res.ContentLength}) cs.bytesRemain = res.ContentLength res.Body = transportResponseBody{cs} if cs.requestedGzip && asciiEqualFold(res.Header.Get("Content-Encoding"), "gzip") { res.Header.Del("Content-Encoding") res.Header.Del("Content-Length") res.ContentLength = -1 res.Body = &gzipReader{body: res.Body} res.Uncompressed = true } return res, nil } func (rl clientConnReadLoop) processTrailers(cs clientStream, f MetaHeadersFrame) error { if cs.pastTrailers { // Too many HEADERS frames for this stream. return ConnectionError(ErrCodeProtocol) } cs.pastTrailers = true if !f.StreamEnded() { // We expect that any headers for trailers also // has END_STREAM. return ConnectionError(ErrCodeProtocol) } if len(f.PseudoFields()) > 0 { // No pseudo header fields are defined for trailers. // TODO: ConnectionError might be overly harsh? Check. return ConnectionError(ErrCodeProtocol) } trailer := make(http.Header) for _, hf := range f.RegularFields() { key := canonicalHeader(hf.Name) trailer[key] = append(trailer[key], hf.Value) } cs.trailer = trailer rl.endStream(cs) return nil } // transportResponseBody is the concrete type of Transport.RoundTrip's // Response.Body. It is an io.ReadCloser. type transportResponseBody struct { cs clientStream } func (b transportResponseBody) Read(p []byte) (n int, err error) { cs := b.cs cc := cs.cc if cs.readErr != nil { return 0, cs.readErr } n, err = b.cs.bufPipe.Read(p) if cs.bytesRemain != -1 { if int64(n) > cs.bytesRemain { n = int(cs.bytesRemain) if err == nil { err = errors.New("net/http: server replied with more than declared Content-Length; truncated") cs.abortStream(err) } cs.readErr = err return int(cs.bytesRemain), err } cs.bytesRemain -= int64(n) if err == io.EOF && cs.bytesRemain > 0 { err = io.ErrUnexpectedEOF cs.readErr = err return n, err } } if n == 0 { // No flow control tokens to send back. return } cc.mu.Lock() connAdd := cc.inflow.add(n) var streamAdd int32 if err == nil { // No need to refresh if the stream is over or failed. streamAdd = cs.inflow.add(n) } cc.mu.Unlock() if connAdd != 0 \|\| streamAdd != 0 { cc.wmu.Lock() defer cc.wmu.Unlock() if connAdd != 0 { cc.fr.WriteWindowUpdate(0, mustUint31(connAdd)) } if streamAdd != 0 { cc.fr.WriteWindowUpdate(cs.ID, mustUint31(streamAdd)) } cc.bw.Flush() } return } var errClosedResponseBody = errors.New("http2: response body closed") func (b transportResponseBody) Close() error { cs := b.cs cc := cs.cc cs.bufPipe.BreakWithError(errClosedResponseBody) cs.abortStream(errClosedResponseBody) unread := cs.bufPipe.Len() if unread > 0 { cc.mu.Lock() // Return connection-level flow control. connAdd := cc.inflow.add(unread) cc.mu.Unlock() // TODO(dneil): Acquiring this mutex can block indefinitely. // Move flow control return to a goroutine? cc.wmu.Lock() // Return connection-level flow control. if connAdd > 0 { cc.fr.WriteWindowUpdate(0, uint32(connAdd)) } cc.bw.Flush() cc.wmu.Unlock() } select { case <-cs.donec: case <-cs.ctx.Done(): // See golang/go#49366: The net/http package can cancel the // request context after the response body is fully read. // Don't treat this as an error. return nil case <-cs.reqCancel: return errRequestCanceled } return nil } func (rl clientConnReadLoop) processData(f DataFrame) error { cc := rl.cc cs := rl.streamByID(f.StreamID, headerOrDataFrame) data := f.Data() if cs == nil { cc.mu.Lock() neverSent := cc.nextStreamID cc.mu.Unlock() if f.StreamID >= neverSent { // We never asked for this. cc.logf("http2: Transport received unsolicited DATA frame; closing connection") return ConnectionError(ErrCodeProtocol) } // We probably did ask for this, but canceled. Just ignore it. // TODO: be stricter here? only silently ignore things which // we canceled, but not things which were closed normally // by the peer? Tough without accumulating too much state. // But at least return their flow control: if f.Length > 0 { cc.mu.Lock() ok := cc.inflow.take(f.Length) connAdd := cc.inflow.add(int(f.Length)) cc.mu.Unlock() if !ok { return ConnectionError(ErrCodeFlowControl) } if connAdd > 0 { cc.wmu.Lock() cc.fr.WriteWindowUpdate(0, uint32(connAdd)) cc.bw.Flush() cc.wmu.Unlock() } } return nil } if cs.readClosed { cc.logf("protocol error: received DATA after END_STREAM") rl.endStreamError(cs, StreamError{ StreamID: f.StreamID, Code: ErrCodeProtocol, }) return nil } if !cs.pastHeaders { cc.logf("protocol error: received DATA before a HEADERS frame") rl.endStreamError(cs, StreamError{ StreamID: f.StreamID, Code: ErrCodeProtocol, }) return nil } if f.Length > 0 { if cs.isHead && len(data) > 0 { cc.logf("protocol error: received DATA on a HEAD request") rl.endStreamError(cs, StreamError{ StreamID: f.StreamID, Code: ErrCodeProtocol, }) return nil } // Check connection-level flow control. cc.mu.Lock() if !takeInflows(&cc.inflow, &cs.inflow, f.Length) { cc.mu.Unlock() return ConnectionError(ErrCodeFlowControl) } // Return any padded flow control now, since we won't // refund it later on body reads. var refund int if pad := int(f.Length) - len(data); pad > 0 { refund += pad } didReset := false var err error if len(data) > 0 { if _, err = cs.bufPipe.Write(data); err != nil { // Return len(data) now if the stream is already closed, // since data will never be read. didReset = true refund += len(data) } } sendConn := cc.inflow.add(refund) var sendStream int32 if !didReset { sendStream = cs.inflow.add(refund) } cc.mu.Unlock() if sendConn > 0 \|\| sendStream > 0 { cc.wmu.Lock() if sendConn > 0 { cc.fr.WriteWindowUpdate(0, uint32(sendConn)) } if sendStream > 0 { cc.fr.WriteWindowUpdate(cs.ID, uint32(sendStream)) } cc.bw.Flush() cc.wmu.Unlock() } if err != nil { rl.endStreamError(cs, err) return nil } } if f.StreamEnded() { rl.endStream(cs) } return nil } func (rl clientConnReadLoop) endStream(cs clientStream) { // TODO: check that any declared content-length matches, like // server.go's (stream).endStream method. if !cs.readClosed { cs.readClosed = true // Close cs.bufPipe and cs.peerClosed with cc.mu held to avoid a // race condition: The caller can read io.EOF from Response.Body // and close the body before we close cs.peerClosed, causing // cleanupWriteRequest to send a RST_STREAM. rl.cc.mu.Lock() defer rl.cc.mu.Unlock() cs.bufPipe.closeWithErrorAndCode(io.EOF, cs.copyTrailers) close(cs.peerClosed) } } func (rl clientConnReadLoop) endStreamError(cs clientStream, err error) { cs.readAborted = true cs.abortStream(err) } // Constants passed to streamByID for documentation purposes. const ( headerOrDataFrame = true notHeaderOrDataFrame = false ) // streamByID returns the stream with the given id, or nil if no stream has that id. // If headerOrData is true, it clears rst.StreamPingsBlocked. func (rl clientConnReadLoop) streamByID(id uint32, headerOrData bool) clientStream { rl.cc.mu.Lock() defer rl.cc.mu.Unlock() if headerOrData { // Work around an unfortunate gRPC behavior. // See comment on ClientConn.rstStreamPingsBlocked for details. rl.cc.rstStreamPingsBlocked = false } cs := rl.cc.streams[id] if cs != nil && !cs.readAborted { return cs } return nil } func (cs clientStream) copyTrailers() { for k, vv := range cs.trailer { t := cs.resTrailer if t == nil { t = make(http.Header) } (t)[k] = vv } } func (rl clientConnReadLoop) processGoAway(f GoAwayFrame) error { cc := rl.cc cc.t.connPool().MarkDead(cc) if f.ErrCode != 0 { // TODO: deal with GOAWAY more. particularly the error code cc.vlogf("transport got GOAWAY with error code = %v", f.ErrCode) if fn := cc.t.CountError; fn != nil { fn("recv_goaway_" + f.ErrCode.stringToken()) } } cc.setGoAway(f) return nil } func (rl clientConnReadLoop) processSettings(f SettingsFrame) error { cc := rl.cc // Locking both mu and wmu here allows frame encoding to read settings with only wmu held. // Acquiring wmu when f.IsAck() is unnecessary, but convenient and mostly harmless. cc.wmu.Lock() defer cc.wmu.Unlock() if err := rl.processSettingsNoWrite(f); err != nil { return err } if !f.IsAck() { cc.fr.WriteSettingsAck() cc.bw.Flush() } return nil } func (rl clientConnReadLoop) processSettingsNoWrite(f SettingsFrame) error { cc := rl.cc cc.mu.Lock() defer cc.mu.Unlock() if f.IsAck() { if cc.wantSettingsAck { cc.wantSettingsAck = false return nil } return ConnectionError(ErrCodeProtocol) } var seenMaxConcurrentStreams bool err := f.ForeachSetting(func(s Setting) error { switch s.ID { case SettingMaxFrameSize: cc.maxFrameSize = s.Val case SettingMaxConcurrentStreams: cc.maxConcurrentStreams = s.Val seenMaxConcurrentStreams = true case SettingMaxHeaderListSize: cc.peerMaxHeaderListSize = uint64(s.Val) case SettingInitialWindowSize: // Values above the maximum flow-control // window size of 2^31-1 MUST be treated as a // connection error (Section 5.4.1) of type // FLOW_CONTROL_ERROR. if s.Val > math.MaxInt32 { return ConnectionError(ErrCodeFlowControl) } // Adjust flow control of currently-open // frames by the difference of the old initial // window size and this one. delta := int32(s.Val) - int32(cc.initialWindowSize) for _, cs := range cc.streams { cs.flow.add(delta) } cc.cond.Broadcast() cc.initialWindowSize = s.Val case SettingHeaderTableSize: cc.henc.SetMaxDynamicTableSize(s.Val) cc.peerMaxHeaderTableSize = s.Val case SettingEnableConnectProtocol: if err := s.Valid(); err != nil { return err } // If the peer wants to send us SETTINGS_ENABLE_CONNECT_PROTOCOL, // we require that it do so in the first SETTINGS frame. // // When we attempt to use extended CONNECT, we wait for the first // SETTINGS frame to see if the server supports it. If we let the // server enable the feature with a later SETTINGS frame, then // users will see inconsistent results depending on whether we've // seen that frame or not. if !cc.seenSettings { cc.extendedConnectAllowed = s.Val == 1 } default: cc.vlogf("Unhandled Setting: %v", s) } return nil }) if err != nil { return err } if !cc.seenSettings { if !seenMaxConcurrentStreams { // This was the servers initial SETTINGS frame and it // didn't contain a MAX_CONCURRENT_STREAMS field so // increase the number of concurrent streams this // connection can establish to our default. cc.maxConcurrentStreams = defaultMaxConcurrentStreams } close(cc.seenSettingsChan) cc.seenSettings = true } return nil } func (rl clientConnReadLoop) processWindowUpdate(f WindowUpdateFrame) error { cc := rl.cc cs := rl.streamByID(f.StreamID, notHeaderOrDataFrame) if f.StreamID != 0 && cs == nil { return nil } cc.mu.Lock() defer cc.mu.Unlock() fl := &cc.flow if cs != nil { fl = &cs.flow } if !fl.add(int32(f.Increment)) { // For stream, the sender sends RST_STREAM with an error code of FLOW_CONTROL_ERROR if cs != nil { rl.endStreamError(cs, StreamError{ StreamID: f.StreamID, Code: ErrCodeFlowControl, }) return nil } return ConnectionError(ErrCodeFlowControl) } cc.cond.Broadcast() return nil } func (rl clientConnReadLoop) processResetStream(f RSTStreamFrame) error { cs := rl.streamByID(f.StreamID, notHeaderOrDataFrame) if cs == nil { // TODO: return error if server tries to RST_STREAM an idle stream return nil } serr := streamError(cs.ID, f.ErrCode) serr.Cause = errFromPeer if f.ErrCode == ErrCodeProtocol { rl.cc.SetDoNotReuse() } if fn := cs.cc.t.CountError; fn != nil { fn("recv_rststream_" + f.ErrCode.stringToken()) } cs.abortStream(serr) cs.bufPipe.CloseWithError(serr) return nil } // Ping sends a PING frame to the server and waits for the ack. func (cc ClientConn) Ping(ctx context.Context) error { c := make(chan struct{}) // Generate a random payload var p [8]byte for { if _, err := rand.Read(p[:]); err != nil { return err } cc.mu.Lock() // check for dup before insert if _, found := cc.pings[p]; !found { cc.pings[p] = c cc.mu.Unlock() break } cc.mu.Unlock() } var pingError error errc := make(chan struct{}) go func() { cc.t.markNewGoroutine() cc.wmu.Lock() defer cc.wmu.Unlock() if pingError = cc.fr.WritePing(false, p); pingError != nil { close(errc) return } if pingError = cc.bw.Flush(); pingError != nil { close(errc) return } }() select { case <-c: return nil case <-errc: return pingError case <-ctx.Done(): return ctx.Err() case <-cc.readerDone: // connection closed return cc.readerErr } } func (rl clientConnReadLoop) processPing(f PingFrame) error { if f.IsAck() { cc := rl.cc cc.mu.Lock() defer cc.mu.Unlock() // If ack, notify listener if any if c, ok := cc.pings[f.Data]; ok { close(c) delete(cc.pings, f.Data) } if cc.pendingResets > 0 { // See clientStream.cleanupWriteRequest. cc.pendingResets = 0 cc.rstStreamPingsBlocked = true cc.cond.Broadcast() } return nil } cc := rl.cc cc.wmu.Lock() defer cc.wmu.Unlock() if err := cc.fr.WritePing(true, f.Data); err != nil { return err } return cc.bw.Flush() } func (rl clientConnReadLoop) processPushPromise(f PushPromiseFrame) error { // We told the peer we don't want them. // Spec says: // "PUSH_PROMISE MUST NOT be sent if the SETTINGS_ENABLE_PUSH // setting of the peer endpoint is set to 0. An endpoint that // has set this setting and has received acknowledgement MUST // treat the receipt of a PUSH_PROMISE frame as a connection // error (Section 5.4.1) of type PROTOCOL_ERROR." return ConnectionError(ErrCodeProtocol) } // writeStreamReset sends a RST_STREAM frame. // When ping is true, it also sends a PING frame with a random payload. func (cc ClientConn) writeStreamReset(streamID uint32, code ErrCode, ping bool, err error) { // TODO: map err to more interesting error codes, once the // HTTP community comes up with some. But currently for // RST_STREAM there's no equivalent to GOAWAY frame's debug // data, and the error codes are all pretty vague ("cancel"). cc.wmu.Lock() cc.fr.WriteRSTStream(streamID, code) if ping { var payload [8]byte rand.Read(payload[:]) cc.fr.WritePing(false, payload) } cc.bw.Flush() cc.wmu.Unlock() } var ( errResponseHeaderListSize = errors.New("http2: response header list larger than advertised limit") errRequestHeaderListSize = errors.New("http2: request header list larger than peer's advertised limit") ) func (cc ClientConn) logf(format string, args ...interface{}) { cc.t.logf(format, args...) } func (cc ClientConn) vlogf(format string, args ...interface{}) { cc.t.vlogf(format, args...) } func (t Transport) vlogf(format string, args ...interface{}) { if VerboseLogs { t.logf(format, args...) } } func (t Transport) logf(format string, args ...interface{}) { log.Printf(format, args...) } var noBody io.ReadCloser = noBodyReader{} type noBodyReader struct{} func (noBodyReader) Close() error { return nil } func (noBodyReader) Read([]byte) (int, error) { return 0, io.EOF } type missingBody struct{} func (missingBody) Close() error { return nil } func (missingBody) Read([]byte) (int, error) { return 0, io.ErrUnexpectedEOF } func strSliceContains(ss []string, s string) bool { for _, v := range ss { if v == s { return true } } return false } type erringRoundTripper struct{ err error } func (rt erringRoundTripper) RoundTripErr() error { return rt.err } func (rt erringRoundTripper) RoundTrip(http.Request) (http.Response, error) { return nil, rt.err } // gzipReader wraps a response body so it can lazily // call gzip.NewReader on the first call to Read type gzipReader struct { _ incomparable body io.ReadCloser // underlying Response.Body zr gzip.Reader // lazily-initialized gzip reader zerr error // sticky error } func (gz gzipReader) Read(p []byte) (n int, err error) { if gz.zerr != nil { return 0, gz.zerr } if gz.zr == nil { gz.zr, err = gzip.NewReader(gz.body) if err != nil { gz.zerr = err return 0, err } } return gz.zr.Read(p) } func (gz gzipReader) Close() error { if err := gz.body.Close(); err != nil { return err } gz.zerr = fs.ErrClosed return nil } type errorReader struct{ err error } func (r errorReader) Read(p []byte) (int, error) { return 0, r.err } // isConnectionCloseRequest reports whether req should use its own // connection for a single request and then close the connection. func isConnectionCloseRequest(req http.Request) bool { return req.Close \|\| httpguts.HeaderValuesContainsToken(req.Header["Connection"], "close") } // registerHTTPSProtocol calls Transport.RegisterProtocol but // converting panics into errors. func registerHTTPSProtocol(t http.Transport, rt noDialH2RoundTripper) (err error) { defer func() { if e := recover(); e != nil { err = fmt.Errorf("%v", e) } }() t.RegisterProtocol("https", rt) return nil } // noDialH2RoundTripper is a RoundTripper which only tries to complete the request // if there's already has a cached connection to the host. // (The field is exported so it can be accessed via reflect from net/http; tested // by TestNoDialH2RoundTripperType) type noDialH2RoundTripper struct{ Transport } func (rt noDialH2RoundTripper) RoundTrip(req http.Request) (http.Response, error) { res, err := rt.Transport.RoundTrip(req) if isNoCachedConnError(err) { return nil, http.ErrSkipAltProtocol } return res, err } func (t Transport) idleConnTimeout() time.Duration { // to keep things backwards compatible, we use non-zero values of // IdleConnTimeout, followed by using the IdleConnTimeout on the underlying // http1 transport, followed by 0 if t.IdleConnTimeout != 0 { return t.IdleConnTimeout } if t.t1 != nil { return t.t1.IdleConnTimeout } return 0 } func traceGetConn(req http.Request, hostPort string) { trace := httptrace.ContextClientTrace(req.Context()) if trace == nil \|\| trace.GetConn == nil { return } trace.GetConn(hostPort) } func traceGotConn(req http.Request, cc ClientConn, reused bool) { trace := httptrace.ContextClientTrace(req.Context()) if trace == nil \|\| trace.GotConn == nil { return } ci := httptrace.GotConnInfo{Conn: cc.tconn} ci.Reused = reused cc.mu.Lock() ci.WasIdle = len(cc.streams) == 0 && reused if ci.WasIdle && !cc.lastActive.IsZero() { ci.IdleTime = cc.t.timeSince(cc.lastActive) } cc.mu.Unlock() trace.GotConn(ci) } func traceWroteHeaders(trace httptrace.ClientTrace) { if trace != nil && trace.WroteHeaders != nil { trace.WroteHeaders() } } func traceGot100Continue(trace httptrace.ClientTrace) { if trace != nil && trace.Got100Continue != nil { trace.Got100Continue() } } func traceWait100Continue(trace httptrace.ClientTrace) { if trace != nil && trace.Wait100Continue != nil { trace.Wait100Continue() } } func traceWroteRequest(trace httptrace.ClientTrace, err error) { if trace != nil && trace.WroteRequest != nil { trace.WroteRequest(httptrace.WroteRequestInfo{Err: err}) } } func traceFirstResponseByte(trace httptrace.ClientTrace) { if trace != nil && trace.GotFirstResponseByte != nil { trace.GotFirstResponseByte() } } func traceHasWroteHeaderField(trace httptrace.ClientTrace) bool { return trace != nil && trace.WroteHeaderField != nil } func traceWroteHeaderField(trace httptrace.ClientTrace, k, v string) { if trace != nil && trace.WroteHeaderField != nil { trace.WroteHeaderField(k, []string{v}) } } func traceGot1xxResponseFunc(trace httptrace.ClientTrace) func(int, textproto.MIMEHeader) error { if trace != nil { return trace.Got1xxResponse } return nil } // dialTLSWithContext uses tls.Dialer, added in Go 1.15, to open a TLS // connection. func (t Transport) dialTLSWithContext(ctx context.Context, network, addr string, cfg tls.Config) (tls.Conn, error) { dialer := &tls.Dialer{ Config: cfg, } cn, err := dialer.DialContext(ctx, network, addr) if err != nil { return nil, err } tlsCn := cn.(*tls.Conn) // DialContext comment promises this will always succeed return tlsCn, nil }	101.54 KB	2025-05-25 12:27
📄 transport_test.go // Copyright 2015 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import ( "bufio" "bytes" "compress/gzip" "context" "crypto/tls" "encoding/hex" "errors" "flag" "fmt" "io" "io/fs" "log" "math/rand" "net" "net/http" "net/http/httptest" "net/http/httptrace" "net/textproto" "net/url" "os" "reflect" "runtime" "sort" "strconv" "strings" "sync" "sync/atomic" "testing" "time" "golang.org/x/net/http2/hpack" ) var ( extNet = flag.Bool("extnet", false, "do external network tests") transportHost = flag.String("transporthost", "http2.golang.org", "hostname to use for TestTransport") insecure = flag.Bool("insecure", false, "insecure TLS dials") // TODO: dead code. remove? ) var tlsConfigInsecure = &tls.Config{InsecureSkipVerify: true} var canceledCtx context.Context func init() { ctx, cancel := context.WithCancel(context.Background()) cancel() canceledCtx = ctx } func TestTransportExternal(t testing.T) { if !extNet { t.Skip("skipping external network test") } req, _ := http.NewRequest("GET", "https://"+transportHost+"/", nil) rt := &Transport{TLSClientConfig: tlsConfigInsecure} res, err := rt.RoundTrip(req) if err != nil { t.Fatalf("%v", err) } res.Write(os.Stdout) } type fakeTLSConn struct { net.Conn } func (c fakeTLSConn) ConnectionState() tls.ConnectionState { return tls.ConnectionState{ Version: tls.VersionTLS12, CipherSuite: cipher_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, } } func startH2cServer(t testing.T) net.Listener { h2Server := &Server{} l := newLocalListener(t) go func() { conn, err := l.Accept() if err != nil { t.Error(err) return } h2Server.ServeConn(&fakeTLSConn{conn}, &ServeConnOpts{Handler: http.HandlerFunc(func(w http.ResponseWriter, r http.Request) { fmt.Fprintf(w, "Hello, %v, http: %v", r.URL.Path, r.TLS == nil) })}) }() return l } func TestIdleConnTimeout(t testing.T) { for _, test := range []struct { name string idleConnTimeout time.Duration wait time.Duration baseTransport http.Transport wantNewConn bool }{{ name: "NoExpiry", idleConnTimeout: 2 * time.Second, wait: 1 * time.Second, baseTransport: nil, wantNewConn: false, }, { name: "H2TransportTimeoutExpires", idleConnTimeout: 1 * time.Second, wait: 2 * time.Second, baseTransport: nil, wantNewConn: true, }, { name: "H1TransportTimeoutExpires", idleConnTimeout: 0 * time.Second, wait: 1 * time.Second, baseTransport: &http.Transport{ IdleConnTimeout: 2 * time.Second, }, wantNewConn: false, }} { t.Run(test.name, func(t testing.T) { tt := newTestTransport(t, func(tr Transport) { tr.IdleConnTimeout = test.idleConnTimeout }) var tc testClientConn for i := 0; i < 3; i++ { req, _ := http.NewRequest("GET", "https://dummy.tld/", nil) rt := tt.roundTrip(req) // This request happens on a new conn if it's the first request // (and there is no cached conn), or if the test timeout is long // enough that old conns are being closed. wantConn := i == 0 \|\| test.wantNewConn if has := tt.hasConn(); has != wantConn { t.Fatalf("request %v: hasConn=%v, want %v", i, has, wantConn) } if wantConn { tc = tt.getConn() // Read client's SETTINGS and first WINDOW_UPDATE, // send our SETTINGS. tc.wantFrameType(FrameSettings) tc.wantFrameType(FrameWindowUpdate) tc.writeSettings() } if tt.hasConn() { t.Fatalf("request %v: Transport has more than one conn", i) } // Respond to the client's request. hf := readFrame[HeadersFrame](t, tc) tc.writeHeaders(HeadersFrameParam{ StreamID: hf.StreamID, EndHeaders: true, EndStream: true, BlockFragment: tc.makeHeaderBlockFragment( ":status", "200", ), }) rt.wantStatus(200) // If this was a newly-accepted conn, read the SETTINGS ACK. if wantConn { tc.wantFrameType(FrameSettings) // ACK to our settings } tt.advance(test.wait) if got, want := tc.isClosed(), test.wantNewConn; got != want { t.Fatalf("after waiting %v, conn closed=%v; want %v", test.wait, got, want) } } }) } } func TestTransportH2c(t testing.T) { l := startH2cServer(t) defer l.Close() req, err := http.NewRequest("GET", "http://"+l.Addr().String()+"/foobar", nil) if err != nil { t.Fatal(err) } var gotConnCnt int32 trace := &httptrace.ClientTrace{ GotConn: func(connInfo httptrace.GotConnInfo) { if !connInfo.Reused { atomic.AddInt32(&gotConnCnt, 1) } }, } req = req.WithContext(httptrace.WithClientTrace(req.Context(), trace)) tr := &Transport{ AllowHTTP: true, DialTLS: func(network, addr string, cfg tls.Config) (net.Conn, error) { return net.Dial(network, addr) }, } res, err := tr.RoundTrip(req) if err != nil { t.Fatal(err) } if res.ProtoMajor != 2 { t.Fatal("proto not h2c") } body, err := io.ReadAll(res.Body) if err != nil { t.Fatal(err) } if got, want := string(body), "Hello, /foobar, http: true"; got != want { t.Fatalf("response got %v, want %v", got, want) } if got, want := gotConnCnt, int32(1); got != want { t.Errorf("Too many got connections: %d", gotConnCnt) } } func TestTransport(t testing.T) { const body = "sup" ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { io.WriteString(w, body) }) tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() u, err := url.Parse(ts.URL) if err != nil { t.Fatal(err) } for i, m := range []string{"GET", ""} { req := &http.Request{ Method: m, URL: u, } res, err := tr.RoundTrip(req) if err != nil { t.Fatalf("%d: %s", i, err) } t.Logf("%d: Got res: %+v", i, res) if g, w := res.StatusCode, 200; g != w { t.Errorf("%d: StatusCode = %v; want %v", i, g, w) } if g, w := res.Status, "200 OK"; g != w { t.Errorf("%d: Status = %q; want %q", i, g, w) } wantHeader := http.Header{ "Content-Length": []string{"3"}, "Content-Type": []string{"text/plain; charset=utf-8"}, "Date": []string{"XXX"}, // see cleanDate } cleanDate(res) if !reflect.DeepEqual(res.Header, wantHeader) { t.Errorf("%d: res Header = %v; want %v", i, res.Header, wantHeader) } if res.Request != req { t.Errorf("%d: Response.Request = %p; want %p", i, res.Request, req) } if res.TLS == nil { t.Errorf("%d: Response.TLS = nil; want non-nil", i) } slurp, err := io.ReadAll(res.Body) if err != nil { t.Errorf("%d: Body read: %v", i, err) } else if string(slurp) != body { t.Errorf("%d: Body = %q; want %q", i, slurp, body) } res.Body.Close() } } func testTransportReusesConns(t testing.T, useClient, wantSame bool, modReq func(http.Request)) { ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { io.WriteString(w, r.RemoteAddr) }, func(ts httptest.Server) { ts.Config.ConnState = func(c net.Conn, st http.ConnState) { t.Logf("conn %v is now state %v", c.RemoteAddr(), st) } }) tr := &Transport{TLSClientConfig: tlsConfigInsecure} if useClient { tr.ConnPool = noDialClientConnPool{new(clientConnPool)} } defer tr.CloseIdleConnections() get := func() string { req, err := http.NewRequest("GET", ts.URL, nil) if err != nil { t.Fatal(err) } modReq(req) var res http.Response if useClient { c := ts.Client() ConfigureTransports(c.Transport.(http.Transport)) res, err = c.Do(req) } else { res, err = tr.RoundTrip(req) } if err != nil { t.Fatal(err) } defer res.Body.Close() slurp, err := io.ReadAll(res.Body) if err != nil { t.Fatalf("Body read: %v", err) } addr := strings.TrimSpace(string(slurp)) if addr == "" { t.Fatalf("didn't get an addr in response") } return addr } first := get() second := get() if got := first == second; got != wantSame { t.Errorf("first and second responses on same connection: %v; want %v", got, wantSame) } } func TestTransportReusesConns(t testing.T) { for _, test := range []struct { name string modReq func(http.Request) wantSame bool }{{ name: "ReuseConn", modReq: func(http.Request) {}, wantSame: true, }, { name: "RequestClose", modReq: func(r http.Request) { r.Close = true }, wantSame: false, }, { name: "ConnClose", modReq: func(r http.Request) { r.Header.Set("Connection", "close") }, wantSame: false, }} { t.Run(test.name, func(t testing.T) { t.Run("Transport", func(t testing.T) { const useClient = false testTransportReusesConns(t, useClient, test.wantSame, test.modReq) }) t.Run("Client", func(t testing.T) { const useClient = true testTransportReusesConns(t, useClient, test.wantSame, test.modReq) }) }) } } func TestTransportGetGotConnHooks_HTTP2Transport(t testing.T) { testTransportGetGotConnHooks(t, false) } func TestTransportGetGotConnHooks_Client(t testing.T) { testTransportGetGotConnHooks(t, true) } func testTransportGetGotConnHooks(t testing.T, useClient bool) { ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { io.WriteString(w, r.RemoteAddr) }) tr := &Transport{TLSClientConfig: tlsConfigInsecure} client := ts.Client() ConfigureTransports(client.Transport.(http.Transport)) var ( getConns int32 gotConns int32 ) for i := 0; i < 2; i++ { trace := &httptrace.ClientTrace{ GetConn: func(hostport string) { atomic.AddInt32(&getConns, 1) }, GotConn: func(connInfo httptrace.GotConnInfo) { got := atomic.AddInt32(&gotConns, 1) wantReused, wantWasIdle := false, false if got > 1 { wantReused, wantWasIdle = true, true } if connInfo.Reused != wantReused \|\| connInfo.WasIdle != wantWasIdle { t.Errorf("GotConn %v: Reused=%v (want %v), WasIdle=%v (want %v)", i, connInfo.Reused, wantReused, connInfo.WasIdle, wantWasIdle) } }, } req, err := http.NewRequest("GET", ts.URL, nil) if err != nil { t.Fatal(err) } req = req.WithContext(httptrace.WithClientTrace(req.Context(), trace)) var res http.Response if useClient { res, err = client.Do(req) } else { res, err = tr.RoundTrip(req) } if err != nil { t.Fatal(err) } res.Body.Close() if get := atomic.LoadInt32(&getConns); get != int32(i+1) { t.Errorf("after request %v, %v calls to GetConns: want %v", i, get, i+1) } if got := atomic.LoadInt32(&gotConns); got != int32(i+1) { t.Errorf("after request %v, %v calls to GotConns: want %v", i, got, i+1) } } } type testNetConn struct { net.Conn closed bool onClose func() } func (c testNetConn) Close() error { if !c.closed { // We can call Close multiple times on the same net.Conn. c.onClose() } c.closed = true return c.Conn.Close() } // Tests that the Transport only keeps one pending dial open per destination address. // https://golang.org/issue/13397 func TestTransportGroupsPendingDials(t testing.T) { ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { }) var ( mu sync.Mutex dialCount int closeCount int ) tr := &Transport{ TLSClientConfig: tlsConfigInsecure, DialTLS: func(network, addr string, cfg tls.Config) (net.Conn, error) { mu.Lock() dialCount++ mu.Unlock() c, err := tls.Dial(network, addr, cfg) return &testNetConn{ Conn: c, onClose: func() { mu.Lock() closeCount++ mu.Unlock() }, }, err }, } defer tr.CloseIdleConnections() var wg sync.WaitGroup for i := 0; i < 10; i++ { wg.Add(1) go func() { defer wg.Done() req, err := http.NewRequest("GET", ts.URL, nil) if err != nil { t.Error(err) return } res, err := tr.RoundTrip(req) if err != nil { t.Error(err) return } res.Body.Close() }() } wg.Wait() tr.CloseIdleConnections() if dialCount != 1 { t.Errorf("saw %d dials; want 1", dialCount) } if closeCount != 1 { t.Errorf("saw %d closes; want 1", closeCount) } } func TestTransportAbortClosesPipes(t testing.T) { shutdown := make(chan struct{}) ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { w.(http.Flusher).Flush() <-shutdown }, ) defer close(shutdown) // we must shutdown before st.Close() to avoid hanging errCh := make(chan error) go func() { defer close(errCh) tr := &Transport{TLSClientConfig: tlsConfigInsecure} req, err := http.NewRequest("GET", ts.URL, nil) if err != nil { errCh <- err return } res, err := tr.RoundTrip(req) if err != nil { errCh <- err return } defer res.Body.Close() ts.CloseClientConnections() _, err = io.ReadAll(res.Body) if err == nil { errCh <- errors.New("expected error from res.Body.Read") return } }() select { case err := <-errCh: if err != nil { t.Fatal(err) } // deadlock? that's a bug. case <-time.After(3 * time.Second): t.Fatal("timeout") } } // TODO: merge this with TestTransportBody to make TestTransportRequest? This // could be a table-driven test with extra goodies. func TestTransportPath(t testing.T) { gotc := make(chan url.URL, 1) ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { gotc <- r.URL }, ) tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() const ( path = "/testpath" query = "q=1" ) surl := ts.URL + path + "?" + query req, err := http.NewRequest("POST", surl, nil) if err != nil { t.Fatal(err) } c := &http.Client{Transport: tr} res, err := c.Do(req) if err != nil { t.Fatal(err) } defer res.Body.Close() got := <-gotc if got.Path != path { t.Errorf("Read Path = %q; want %q", got.Path, path) } if got.RawQuery != query { t.Errorf("Read RawQuery = %q; want %q", got.RawQuery, query) } } func randString(n int) string { rnd := rand.New(rand.NewSource(int64(n))) b := make([]byte, n) for i := range b { b[i] = byte(rnd.Intn(256)) } return string(b) } type panicReader struct{} func (panicReader) Read([]byte) (int, error) { panic("unexpected Read") } func (panicReader) Close() error { panic("unexpected Close") } func TestActualContentLength(t testing.T) { tests := []struct { req http.Request want int64 }{ // Verify we don't read from Body: 0: { req: &http.Request{Body: panicReader{}}, want: -1, }, // nil Body means 0, regardless of ContentLength: 1: { req: &http.Request{Body: nil, ContentLength: 5}, want: 0, }, // ContentLength is used if set. 2: { req: &http.Request{Body: panicReader{}, ContentLength: 5}, want: 5, }, // http.NoBody means 0, not -1. 3: { req: &http.Request{Body: http.NoBody}, want: 0, }, } for i, tt := range tests { got := actualContentLength(tt.req) if got != tt.want { t.Errorf("test[%d]: got %d; want %d", i, got, tt.want) } } } func TestTransportBody(t testing.T) { bodyTests := []struct { body string noContentLen bool }{ {body: "some message"}, {body: "some message", noContentLen: true}, {body: strings.Repeat("a", 1<<20), noContentLen: true}, {body: strings.Repeat("a", 1<<20)}, {body: randString(16<<10 - 1)}, {body: randString(16 << 10)}, {body: randString(16<<10 + 1)}, {body: randString(512<<10 - 1)}, {body: randString(512 << 10)}, {body: randString(512<<10 + 1)}, {body: randString(1<<20 - 1)}, {body: randString(1 << 20)}, {body: randString(1<<20 + 2)}, } type reqInfo struct { req http.Request slurp []byte err error } gotc := make(chan reqInfo, 1) ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { slurp, err := io.ReadAll(r.Body) if err != nil { gotc <- reqInfo{err: err} } else { gotc <- reqInfo{req: r, slurp: slurp} } }, ) for i, tt := range bodyTests { tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() var body io.Reader = strings.NewReader(tt.body) if tt.noContentLen { body = struct{ io.Reader }{body} // just a Reader, hiding concrete type and other methods } req, err := http.NewRequest("POST", ts.URL, body) if err != nil { t.Fatalf("#%d: %v", i, err) } c := &http.Client{Transport: tr} res, err := c.Do(req) if err != nil { t.Fatalf("#%d: %v", i, err) } defer res.Body.Close() ri := <-gotc if ri.err != nil { t.Errorf("#%d: read error: %v", i, ri.err) continue } if got := string(ri.slurp); got != tt.body { t.Errorf("#%d: Read body mismatch.\n got: %q (len %d)\nwant: %q (len %d)", i, shortString(got), len(got), shortString(tt.body), len(tt.body)) } wantLen := int64(len(tt.body)) if tt.noContentLen && tt.body != "" { wantLen = -1 } if ri.req.ContentLength != wantLen { t.Errorf("#%d. handler got ContentLength = %v; want %v", i, ri.req.ContentLength, wantLen) } } } func shortString(v string) string { const maxLen = 100 if len(v) <= maxLen { return v } return fmt.Sprintf("%v[...%d bytes omitted...]%v", v[:maxLen/2], len(v)-maxLen, v[len(v)-maxLen/2:]) } func TestTransportDialTLS(t testing.T) { var mu sync.Mutex // guards following var gotReq, didDial bool ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { mu.Lock() gotReq = true mu.Unlock() }, ) tr := &Transport{ DialTLS: func(netw, addr string, cfg tls.Config) (net.Conn, error) { mu.Lock() didDial = true mu.Unlock() cfg.InsecureSkipVerify = true c, err := tls.Dial(netw, addr, cfg) if err != nil { return nil, err } return c, c.Handshake() }, } defer tr.CloseIdleConnections() client := &http.Client{Transport: tr} res, err := client.Get(ts.URL) if err != nil { t.Fatal(err) } res.Body.Close() mu.Lock() if !gotReq { t.Error("didn't get request") } if !didDial { t.Error("didn't use dial hook") } } func TestConfigureTransport(t testing.T) { t1 := &http.Transport{} err := ConfigureTransport(t1) if err != nil { t.Fatal(err) } if got := fmt.Sprintf("%#v", t1); !strings.Contains(got, `"h2"`) { // Laziness, to avoid buildtags. t.Errorf("stringification of HTTP/1 transport didn't contain \"h2\": %v", got) } wantNextProtos := []string{"h2", "http/1.1"} if t1.TLSClientConfig == nil { t.Errorf("nil t1.TLSClientConfig") } else if !reflect.DeepEqual(t1.TLSClientConfig.NextProtos, wantNextProtos) { t.Errorf("TLSClientConfig.NextProtos = %q; want %q", t1.TLSClientConfig.NextProtos, wantNextProtos) } if err := ConfigureTransport(t1); err == nil { t.Error("unexpected success on second call to ConfigureTransport") } // And does it work? ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { io.WriteString(w, r.Proto) }) t1.TLSClientConfig.InsecureSkipVerify = true c := &http.Client{Transport: t1} res, err := c.Get(ts.URL) if err != nil { t.Fatal(err) } slurp, err := io.ReadAll(res.Body) if err != nil { t.Fatal(err) } if got, want := string(slurp), "HTTP/2.0"; got != want { t.Errorf("body = %q; want %q", got, want) } } type capitalizeReader struct { r io.Reader } func (cr capitalizeReader) Read(p []byte) (n int, err error) { n, err = cr.r.Read(p) for i, b := range p[:n] { if b >= 'a' && b <= 'z' { p[i] = b - ('a' - 'A') } } return } type flushWriter struct { w io.Writer } func (fw flushWriter) Write(p []byte) (n int, err error) { n, err = fw.w.Write(p) if f, ok := fw.w.(http.Flusher); ok { f.Flush() } return } func newLocalListener(t testing.T) net.Listener { ln, err := net.Listen("tcp4", "127.0.0.1:0") if err == nil { return ln } ln, err = net.Listen("tcp6", "[::1]:0") if err != nil { t.Fatal(err) } return ln } func TestTransportReqBodyAfterResponse_200(t testing.T) { testTransportReqBodyAfterResponse(t, 200) } func TestTransportReqBodyAfterResponse_403(t testing.T) { testTransportReqBodyAfterResponse(t, 403) } func testTransportReqBodyAfterResponse(t testing.T, status int) { const bodySize = 1 << 10 tc := newTestClientConn(t) tc.greet() body := tc.newRequestBody() body.writeBytes(bodySize / 2) req, _ := http.NewRequest("PUT", "https://dummy.tld/", body) rt := tc.roundTrip(req) tc.wantHeaders(wantHeader{ streamID: rt.streamID(), endStream: false, header: http.Header{ ":authority": []string{"dummy.tld"}, ":method": []string{"PUT"}, ":path": []string{"/"}, }, }) // Provide enough congestion window for the full request body. tc.writeWindowUpdate(0, bodySize) tc.writeWindowUpdate(rt.streamID(), bodySize) tc.wantData(wantData{ streamID: rt.streamID(), endStream: false, size: bodySize / 2, }) tc.writeHeaders(HeadersFrameParam{ StreamID: rt.streamID(), EndHeaders: true, EndStream: true, BlockFragment: tc.makeHeaderBlockFragment( ":status", strconv.Itoa(status), ), }) res := rt.response() if res.StatusCode != status { t.Fatalf("status code = %v; want %v", res.StatusCode, status) } body.writeBytes(bodySize / 2) body.closeWithError(io.EOF) if status == 200 { // After a 200 response, client sends the remaining request body. tc.wantData(wantData{ streamID: rt.streamID(), endStream: true, size: bodySize / 2, multiple: true, }) } else { // After a 403 response, client gives up and resets the stream. tc.wantFrameType(FrameRSTStream) } rt.wantBody(nil) } // See golang.org/issue/13444 func TestTransportFullDuplex(t testing.T) { ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { w.WriteHeader(200) // redundant but for clarity w.(http.Flusher).Flush() io.Copy(flushWriter{w}, capitalizeReader{r.Body}) fmt.Fprintf(w, "bye.\n") }) tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() c := &http.Client{Transport: tr} pr, pw := io.Pipe() req, err := http.NewRequest("PUT", ts.URL, io.NopCloser(pr)) if err != nil { t.Fatal(err) } req.ContentLength = -1 res, err := c.Do(req) if err != nil { t.Fatal(err) } defer res.Body.Close() if res.StatusCode != 200 { t.Fatalf("StatusCode = %v; want %v", res.StatusCode, 200) } bs := bufio.NewScanner(res.Body) want := func(v string) { if !bs.Scan() { t.Fatalf("wanted to read %q but Scan() = false, err = %v", v, bs.Err()) } } write := func(v string) { _, err := io.WriteString(pw, v) if err != nil { t.Fatalf("pipe write: %v", err) } } write("foo\n") want("FOO") write("bar\n") want("BAR") pw.Close() want("bye.") if err := bs.Err(); err != nil { t.Fatal(err) } } func TestTransportConnectRequest(t testing.T) { gotc := make(chan http.Request, 1) ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { gotc <- r }) u, err := url.Parse(ts.URL) if err != nil { t.Fatal(err) } tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() c := &http.Client{Transport: tr} tests := []struct { req http.Request want string }{ { req: &http.Request{ Method: "CONNECT", Header: http.Header{}, URL: u, }, want: u.Host, }, { req: &http.Request{ Method: "CONNECT", Header: http.Header{}, URL: u, Host: "example.com:123", }, want: "example.com:123", }, } for i, tt := range tests { res, err := c.Do(tt.req) if err != nil { t.Errorf("%d. RoundTrip = %v", i, err) continue } res.Body.Close() req := <-gotc if req.Method != "CONNECT" { t.Errorf("method = %q; want CONNECT", req.Method) } if req.Host != tt.want { t.Errorf("Host = %q; want %q", req.Host, tt.want) } if req.URL.Host != tt.want { t.Errorf("URL.Host = %q; want %q", req.URL.Host, tt.want) } } } type headerType int const ( noHeader headerType = iota // omitted oneHeader splitHeader // broken into continuation on purpose ) const ( f0 = noHeader f1 = oneHeader f2 = splitHeader d0 = false d1 = true ) // Test all 36 combinations of response frame orders: // // (3 ways of 100-continue) (2 ways of headers) * (2 ways of data) * (3 ways of trailers):func TestTransportResponsePattern_00f0(t testing.T) { testTransportResponsePattern(h0, h1, false, h0) } // // Generated by http://play.golang.org/p/SScqYKJYXd func TestTransportResPattern_c0h1d0t0(t testing.T) { testTransportResPattern(t, f0, f1, d0, f0) } func TestTransportResPattern_c0h1d0t1(t testing.T) { testTransportResPattern(t, f0, f1, d0, f1) } func TestTransportResPattern_c0h1d0t2(t testing.T) { testTransportResPattern(t, f0, f1, d0, f2) } func TestTransportResPattern_c0h1d1t0(t testing.T) { testTransportResPattern(t, f0, f1, d1, f0) } func TestTransportResPattern_c0h1d1t1(t testing.T) { testTransportResPattern(t, f0, f1, d1, f1) } func TestTransportResPattern_c0h1d1t2(t testing.T) { testTransportResPattern(t, f0, f1, d1, f2) } func TestTransportResPattern_c0h2d0t0(t testing.T) { testTransportResPattern(t, f0, f2, d0, f0) } func TestTransportResPattern_c0h2d0t1(t testing.T) { testTransportResPattern(t, f0, f2, d0, f1) } func TestTransportResPattern_c0h2d0t2(t testing.T) { testTransportResPattern(t, f0, f2, d0, f2) } func TestTransportResPattern_c0h2d1t0(t testing.T) { testTransportResPattern(t, f0, f2, d1, f0) } func TestTransportResPattern_c0h2d1t1(t testing.T) { testTransportResPattern(t, f0, f2, d1, f1) } func TestTransportResPattern_c0h2d1t2(t testing.T) { testTransportResPattern(t, f0, f2, d1, f2) } func TestTransportResPattern_c1h1d0t0(t testing.T) { testTransportResPattern(t, f1, f1, d0, f0) } func TestTransportResPattern_c1h1d0t1(t testing.T) { testTransportResPattern(t, f1, f1, d0, f1) } func TestTransportResPattern_c1h1d0t2(t testing.T) { testTransportResPattern(t, f1, f1, d0, f2) } func TestTransportResPattern_c1h1d1t0(t testing.T) { testTransportResPattern(t, f1, f1, d1, f0) } func TestTransportResPattern_c1h1d1t1(t testing.T) { testTransportResPattern(t, f1, f1, d1, f1) } func TestTransportResPattern_c1h1d1t2(t testing.T) { testTransportResPattern(t, f1, f1, d1, f2) } func TestTransportResPattern_c1h2d0t0(t testing.T) { testTransportResPattern(t, f1, f2, d0, f0) } func TestTransportResPattern_c1h2d0t1(t testing.T) { testTransportResPattern(t, f1, f2, d0, f1) } func TestTransportResPattern_c1h2d0t2(t testing.T) { testTransportResPattern(t, f1, f2, d0, f2) } func TestTransportResPattern_c1h2d1t0(t testing.T) { testTransportResPattern(t, f1, f2, d1, f0) } func TestTransportResPattern_c1h2d1t1(t testing.T) { testTransportResPattern(t, f1, f2, d1, f1) } func TestTransportResPattern_c1h2d1t2(t testing.T) { testTransportResPattern(t, f1, f2, d1, f2) } func TestTransportResPattern_c2h1d0t0(t testing.T) { testTransportResPattern(t, f2, f1, d0, f0) } func TestTransportResPattern_c2h1d0t1(t testing.T) { testTransportResPattern(t, f2, f1, d0, f1) } func TestTransportResPattern_c2h1d0t2(t testing.T) { testTransportResPattern(t, f2, f1, d0, f2) } func TestTransportResPattern_c2h1d1t0(t testing.T) { testTransportResPattern(t, f2, f1, d1, f0) } func TestTransportResPattern_c2h1d1t1(t testing.T) { testTransportResPattern(t, f2, f1, d1, f1) } func TestTransportResPattern_c2h1d1t2(t testing.T) { testTransportResPattern(t, f2, f1, d1, f2) } func TestTransportResPattern_c2h2d0t0(t testing.T) { testTransportResPattern(t, f2, f2, d0, f0) } func TestTransportResPattern_c2h2d0t1(t testing.T) { testTransportResPattern(t, f2, f2, d0, f1) } func TestTransportResPattern_c2h2d0t2(t testing.T) { testTransportResPattern(t, f2, f2, d0, f2) } func TestTransportResPattern_c2h2d1t0(t testing.T) { testTransportResPattern(t, f2, f2, d1, f0) } func TestTransportResPattern_c2h2d1t1(t testing.T) { testTransportResPattern(t, f2, f2, d1, f1) } func TestTransportResPattern_c2h2d1t2(t testing.T) { testTransportResPattern(t, f2, f2, d1, f2) } func testTransportResPattern(t testing.T, expect100Continue, resHeader headerType, withData bool, trailers headerType) { const reqBody = "some request body" const resBody = "some response body" if resHeader == noHeader { // TODO: test 100-continue followed by immediate // server stream reset, without headers in the middle? panic("invalid combination") } tc := newTestClientConn(t) tc.greet() req, _ := http.NewRequest("POST", "https://dummy.tld/", strings.NewReader(reqBody)) if expect100Continue != noHeader { req.Header.Set("Expect", "100-continue") } rt := tc.roundTrip(req) tc.wantFrameType(FrameHeaders) // Possibly 100-continue, or skip when noHeader. tc.writeHeadersMode(expect100Continue, HeadersFrameParam{ StreamID: rt.streamID(), EndHeaders: true, EndStream: false, BlockFragment: tc.makeHeaderBlockFragment( ":status", "100", ), }) // Client sends request body. tc.wantData(wantData{ streamID: rt.streamID(), endStream: true, size: len(reqBody), }) hdr := []string{ ":status", "200", "x-foo", "blah", "x-bar", "more", } if trailers != noHeader { hdr = append(hdr, "trailer", "some-trailer") } tc.writeHeadersMode(resHeader, HeadersFrameParam{ StreamID: rt.streamID(), EndHeaders: true, EndStream: withData == false && trailers == noHeader, BlockFragment: tc.makeHeaderBlockFragment(hdr...), }) if withData { endStream := trailers == noHeader tc.writeData(rt.streamID(), endStream, []byte(resBody)) } tc.writeHeadersMode(trailers, HeadersFrameParam{ StreamID: rt.streamID(), EndHeaders: true, EndStream: true, BlockFragment: tc.makeHeaderBlockFragment( "some-trailer", "some-value", ), }) rt.wantStatus(200) if !withData { rt.wantBody(nil) } else { rt.wantBody([]byte(resBody)) } if trailers == noHeader { rt.wantTrailers(nil) } else { rt.wantTrailers(http.Header{ "Some-Trailer": {"some-value"}, }) } } // Issue 26189, Issue 17739: ignore unknown 1xx responses func TestTransportUnknown1xx(t testing.T) { var buf bytes.Buffer defer func() { got1xxFuncForTests = nil }() got1xxFuncForTests = func(code int, header textproto.MIMEHeader) error { fmt.Fprintf(&buf, "code=%d header=%v\n", code, header) return nil } tc := newTestClientConn(t) tc.greet() req, _ := http.NewRequest("GET", "https://dummy.tld/", nil) rt := tc.roundTrip(req) for i := 110; i <= 114; i++ { tc.writeHeaders(HeadersFrameParam{ StreamID: rt.streamID(), EndHeaders: true, EndStream: false, BlockFragment: tc.makeHeaderBlockFragment( ":status", fmt.Sprint(i), "foo-bar", fmt.Sprint(i), ), }) } tc.writeHeaders(HeadersFrameParam{ StreamID: rt.streamID(), EndHeaders: true, EndStream: true, BlockFragment: tc.makeHeaderBlockFragment( ":status", "204", ), }) res := rt.response() if res.StatusCode != 204 { t.Fatalf("status code = %v; want 204", res.StatusCode) } want := `code=110 header=map[Foo-Bar:[110]] code=111 header=map[Foo-Bar:[111]] code=112 header=map[Foo-Bar:[112]] code=113 header=map[Foo-Bar:[113]] code=114 header=map[Foo-Bar:[114]] ` if got := buf.String(); got != want { t.Errorf("Got trace:\n%s\nWant:\n%s", got, want) } } func TestTransportReceiveUndeclaredTrailer(t testing.T) { tc := newTestClientConn(t) tc.greet() req, _ := http.NewRequest("GET", "https://dummy.tld/", nil) rt := tc.roundTrip(req) tc.writeHeaders(HeadersFrameParam{ StreamID: rt.streamID(), EndHeaders: true, EndStream: false, BlockFragment: tc.makeHeaderBlockFragment( ":status", "200", ), }) tc.writeHeaders(HeadersFrameParam{ StreamID: rt.streamID(), EndHeaders: true, EndStream: true, BlockFragment: tc.makeHeaderBlockFragment( "some-trailer", "I'm an undeclared Trailer!", ), }) rt.wantStatus(200) rt.wantBody(nil) rt.wantTrailers(http.Header{ "Some-Trailer": []string{"I'm an undeclared Trailer!"}, }) } func TestTransportInvalidTrailer_Pseudo1(t testing.T) { testTransportInvalidTrailer_Pseudo(t, oneHeader) } func TestTransportInvalidTrailer_Pseudo2(t testing.T) { testTransportInvalidTrailer_Pseudo(t, splitHeader) } func testTransportInvalidTrailer_Pseudo(t testing.T, trailers headerType) { testInvalidTrailer(t, trailers, pseudoHeaderError(":colon"), ":colon", "foo", "foo", "bar", ) } func TestTransportInvalidTrailer_Capital1(t testing.T) { testTransportInvalidTrailer_Capital(t, oneHeader) } func TestTransportInvalidTrailer_Capital2(t testing.T) { testTransportInvalidTrailer_Capital(t, splitHeader) } func testTransportInvalidTrailer_Capital(t testing.T, trailers headerType) { testInvalidTrailer(t, trailers, headerFieldNameError("Capital"), "foo", "bar", "Capital", "bad", ) } func TestTransportInvalidTrailer_EmptyFieldName(t testing.T) { testInvalidTrailer(t, oneHeader, headerFieldNameError(""), "", "bad", ) } func TestTransportInvalidTrailer_BinaryFieldValue(t testing.T) { testInvalidTrailer(t, oneHeader, headerFieldValueError("x"), "x", "has\nnewline", ) } func testInvalidTrailer(t testing.T, mode headerType, wantErr error, trailers ...string) { tc := newTestClientConn(t) tc.greet() req, _ := http.NewRequest("GET", "https://dummy.tld/", nil) rt := tc.roundTrip(req) tc.writeHeaders(HeadersFrameParam{ StreamID: rt.streamID(), EndHeaders: true, EndStream: false, BlockFragment: tc.makeHeaderBlockFragment( ":status", "200", "trailer", "declared", ), }) tc.writeHeadersMode(mode, HeadersFrameParam{ StreamID: rt.streamID(), EndHeaders: true, EndStream: true, BlockFragment: tc.makeHeaderBlockFragment(trailers...), }) rt.wantStatus(200) body, err := rt.readBody() se, ok := err.(StreamError) if !ok \|\| se.Cause != wantErr { t.Fatalf("res.Body ReadAll error = %q, %#v; want StreamError with cause %T, %#v", body, err, wantErr, wantErr) } if len(body) > 0 { t.Fatalf("body = %q; want nothing", body) } } // headerListSize returns the HTTP2 header list size of h. // // http://httpwg.org/specs/rfc7540.html#SETTINGS_MAX_HEADER_LIST_SIZE // http://httpwg.org/specs/rfc7540.html#MaxHeaderBlock func headerListSize(h http.Header) (size uint32) { for k, vv := range h { for _, v := range vv { hf := hpack.HeaderField{Name: k, Value: v} size += hf.Size() } } return size } // padHeaders adds data to an http.Header until headerListSize(h) == // limit. Due to the way header list sizes are calculated, padHeaders // cannot add fewer than len("Pad-Headers") + 32 bytes to h, and will // call t.Fatal if asked to do so. PadHeaders first reserves enough // space for an empty "Pad-Headers" key, then adds as many copies of // filler as possible. Any remaining bytes necessary to push the // header list size up to limit are added to h["Pad-Headers"]. func padHeaders(t testing.T, h http.Header, limit uint64, filler string) { if limit > 0xffffffff { t.Fatalf("padHeaders: refusing to pad to more than 2^32-1 bytes. limit = %v", limit) } hf := hpack.HeaderField{Name: "Pad-Headers", Value: ""} minPadding := uint64(hf.Size()) size := uint64(headerListSize(h)) minlimit := size + minPadding if limit < minlimit { t.Fatalf("padHeaders: limit %v < %v", limit, minlimit) } // Use a fixed-width format for name so that fieldSize // remains constant. nameFmt := "Pad-Headers-%06d" hf = hpack.HeaderField{Name: fmt.Sprintf(nameFmt, 1), Value: filler} fieldSize := uint64(hf.Size()) // Add as many complete filler values as possible, leaving // room for at least one empty "Pad-Headers" key. limit = limit - minPadding for i := 0; size+fieldSize < limit; i++ { name := fmt.Sprintf(nameFmt, i) h.Add(name, filler) size += fieldSize } // Add enough bytes to reach limit. remain := limit - size lastValue := strings.Repeat("", int(remain)) h.Add("Pad-Headers", lastValue) } func TestPadHeaders(t testing.T) { check := func(h http.Header, limit uint32, fillerLen int) { if h == nil { h = make(http.Header) } filler := strings.Repeat("f", fillerLen) padHeaders(t, h, uint64(limit), filler) gotSize := headerListSize(h) if gotSize != limit { t.Errorf("Got size = %v; want %v", gotSize, limit) } } // Try all possible combinations for small fillerLen and limit. hf := hpack.HeaderField{Name: "Pad-Headers", Value: ""} minLimit := hf.Size() for limit := minLimit; limit <= 128; limit++ { for fillerLen := 0; uint32(fillerLen) <= limit; fillerLen++ { check(nil, limit, fillerLen) } } // Try a few tests with larger limits, plus cumulative // tests. Since these tests are cumulative, tests[i+1].limit // must be >= tests[i].limit + minLimit. See the comment on // padHeaders for more info on why the limit arg has this // restriction. tests := []struct { fillerLen int limit uint32 }{ { fillerLen: 64, limit: 1024, }, { fillerLen: 1024, limit: 1286, }, { fillerLen: 256, limit: 2048, }, { fillerLen: 1024, limit: 10 * 1024, }, { fillerLen: 1023, limit: 11 * 1024, }, } h := make(http.Header) for _, tc := range tests { check(nil, tc.limit, tc.fillerLen) check(h, tc.limit, tc.fillerLen) } } func TestTransportChecksRequestHeaderListSize(t testing.T) { ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { // Consume body & force client to send // trailers before writing response. // io.ReadAll returns non-nil err for // requests that attempt to send greater than // maxHeaderListSize bytes of trailers, since // those requests generate a stream reset. io.ReadAll(r.Body) r.Body.Close() }, func(ts httptest.Server) { ts.Config.MaxHeaderBytes = 16 << 10 }, optQuiet, ) tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() checkRoundTrip := func(req http.Request, wantErr error, desc string) { // Make an arbitrary request to ensure we get the server's // settings frame and initialize peerMaxHeaderListSize. req0, err := http.NewRequest("GET", ts.URL, nil) if err != nil { t.Fatalf("newRequest: NewRequest: %v", err) } res0, err := tr.RoundTrip(req0) if err != nil { t.Errorf("%v: Initial RoundTrip err = %v", desc, err) } res0.Body.Close() res, err := tr.RoundTrip(req) if err != wantErr { if res != nil { res.Body.Close() } t.Errorf("%v: RoundTrip err = %v; want %v", desc, err, wantErr) return } if err == nil { if res == nil { t.Errorf("%v: response nil; want non-nil.", desc) return } defer res.Body.Close() if res.StatusCode != http.StatusOK { t.Errorf("%v: response status = %v; want %v", desc, res.StatusCode, http.StatusOK) } return } if res != nil { t.Errorf("%v: RoundTrip err = %v but response non-nil", desc, err) } } headerListSizeForRequest := func(req http.Request) (size uint64) { contentLen := actualContentLength(req) trailers, err := commaSeparatedTrailers(req) if err != nil { t.Fatalf("headerListSizeForRequest: %v", err) } cc := &ClientConn{peerMaxHeaderListSize: 0xffffffffffffffff} cc.henc = hpack.NewEncoder(&cc.hbuf) cc.mu.Lock() hdrs, err := cc.encodeHeaders(req, true, trailers, contentLen) cc.mu.Unlock() if err != nil { t.Fatalf("headerListSizeForRequest: %v", err) } hpackDec := hpack.NewDecoder(initialHeaderTableSize, func(hf hpack.HeaderField) { size += uint64(hf.Size()) }) if len(hdrs) > 0 { if _, err := hpackDec.Write(hdrs); err != nil { t.Fatalf("headerListSizeForRequest: %v", err) } } return size } // Create a new Request for each test, rather than reusing the // same Request, to avoid a race when modifying req.Headers. // See https://github.com/golang/go/issues/21316 newRequest := func() http.Request { // Body must be non-nil to enable writing trailers. body := strings.NewReader("hello") req, err := http.NewRequest("POST", ts.URL, body) if err != nil { t.Fatalf("newRequest: NewRequest: %v", err) } return req } var ( scMu sync.Mutex sc serverConn ) testHookGetServerConn = func(v serverConn) { scMu.Lock() defer scMu.Unlock() if sc != nil { panic("testHookGetServerConn called multiple times") } sc = v } defer func() { testHookGetServerConn = nil }() // Validate peerMaxHeaderListSize. req := newRequest() checkRoundTrip(req, nil, "Initial request") addr := authorityAddr(req.URL.Scheme, req.URL.Host) cc, err := tr.connPool().GetClientConn(req, addr) if err != nil { t.Fatalf("GetClientConn: %v", err) } cc.mu.Lock() peerSize := cc.peerMaxHeaderListSize cc.mu.Unlock() scMu.Lock() wantSize := uint64(sc.maxHeaderListSize()) scMu.Unlock() if peerSize != wantSize { t.Errorf("peerMaxHeaderListSize = %v; want %v", peerSize, wantSize) } // Sanity check peerSize. (serverConn) maxHeaderListSize adds // 320 bytes of padding. wantHeaderBytes := uint64(ts.Config.MaxHeaderBytes) + 320 if peerSize != wantHeaderBytes { t.Errorf("peerMaxHeaderListSize = %v; want %v.", peerSize, wantHeaderBytes) } // Pad headers & trailers, but stay under peerSize. req = newRequest() req.Header = make(http.Header) req.Trailer = make(http.Header) filler := strings.Repeat("", 1024) padHeaders(t, req.Trailer, peerSize, filler) // cc.encodeHeaders adds some default headers to the request, // so we need to leave room for those. defaultBytes := headerListSizeForRequest(req) padHeaders(t, req.Header, peerSize-defaultBytes, filler) checkRoundTrip(req, nil, "Headers & Trailers under limit") // Add enough header bytes to push us over peerSize. req = newRequest() req.Header = make(http.Header) padHeaders(t, req.Header, peerSize, filler) checkRoundTrip(req, errRequestHeaderListSize, "Headers over limit") // Push trailers over the limit. req = newRequest() req.Trailer = make(http.Header) padHeaders(t, req.Trailer, peerSize+1, filler) checkRoundTrip(req, errRequestHeaderListSize, "Trailers over limit") // Send headers with a single large value. req = newRequest() filler = strings.Repeat("", int(peerSize)) req.Header = make(http.Header) req.Header.Set("Big", filler) checkRoundTrip(req, errRequestHeaderListSize, "Single large header") // Send trailers with a single large value. req = newRequest() req.Trailer = make(http.Header) req.Trailer.Set("Big", filler) checkRoundTrip(req, errRequestHeaderListSize, "Single large trailer") } func TestTransportChecksResponseHeaderListSize(t testing.T) { tc := newTestClientConn(t) tc.greet() req, _ := http.NewRequest("GET", "https://dummy.tld/", nil) rt := tc.roundTrip(req) tc.wantFrameType(FrameHeaders) hdr := []string{":status", "200"} large := strings.Repeat("a", 1<<10) for i := 0; i < 5042; i++ { hdr = append(hdr, large, large) } hbf := tc.makeHeaderBlockFragment(hdr...) // Note: this number might change if our hpack implementation changes. // That's fine. This is just a sanity check that our response can fit in a single // header block fragment frame. if size, want := len(hbf), 6329; size != want { t.Fatalf("encoding over 10MB of duplicate keypairs took %d bytes; expected %d", size, want) } tc.writeHeaders(HeadersFrameParam{ StreamID: rt.streamID(), EndHeaders: true, EndStream: true, BlockFragment: hbf, }) res, err := rt.result() if e, ok := err.(StreamError); ok { err = e.Cause } if err != errResponseHeaderListSize { size := int64(0) if res != nil { res.Body.Close() for k, vv := range res.Header { for _, v := range vv { size += int64(len(k)) + int64(len(v)) + 32 } } } t.Fatalf("RoundTrip Error = %v (and %d bytes of response headers); want errResponseHeaderListSize", err, size) } } func TestTransportCookieHeaderSplit(t testing.T) { tc := newTestClientConn(t) tc.greet() req, _ := http.NewRequest("GET", "https://dummy.tld/", nil) req.Header.Add("Cookie", "a=b;c=d; e=f;") req.Header.Add("Cookie", "e=f;g=h; ") req.Header.Add("Cookie", "i=j") rt := tc.roundTrip(req) tc.wantHeaders(wantHeader{ streamID: rt.streamID(), endStream: true, header: http.Header{ "cookie": []string{"a=b", "c=d", "e=f", "e=f", "g=h", "i=j"}, }, }) tc.writeHeaders(HeadersFrameParam{ StreamID: rt.streamID(), EndHeaders: true, EndStream: true, BlockFragment: tc.makeHeaderBlockFragment( ":status", "204", ), }) if err := rt.err(); err != nil { t.Fatalf("RoundTrip = %v, want success", err) } } // Test that the Transport returns a typed error from Response.Body.Read calls // when the server sends an error. (here we use a panic, since that should generate // a stream error, but others like cancel should be similar) func TestTransportBodyReadErrorType(t testing.T) { doPanic := make(chan bool, 1) ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { w.(http.Flusher).Flush() // force headers out <-doPanic panic("boom") }, optQuiet, ) tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() c := &http.Client{Transport: tr} res, err := c.Get(ts.URL) if err != nil { t.Fatal(err) } defer res.Body.Close() doPanic <- true buf := make([]byte, 100) n, err := res.Body.Read(buf) got, ok := err.(StreamError) want := StreamError{StreamID: 0x1, Code: 0x2} if !ok \|\| got.StreamID != want.StreamID \|\| got.Code != want.Code { t.Errorf("Read = %v, %#v; want error %#v", n, err, want) } } // golang.org/issue/13924 // This used to fail after many iterations, especially with -race: // go test -v -run=TestTransportDoubleCloseOnWriteError -count=500 -race func TestTransportDoubleCloseOnWriteError(t testing.T) { var ( mu sync.Mutex conn net.Conn // to close if set ) ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { mu.Lock() defer mu.Unlock() if conn != nil { conn.Close() } }, ) tr := &Transport{ TLSClientConfig: tlsConfigInsecure, DialTLS: func(network, addr string, cfg tls.Config) (net.Conn, error) { tc, err := tls.Dial(network, addr, cfg) if err != nil { return nil, err } mu.Lock() defer mu.Unlock() conn = tc return tc, nil }, } defer tr.CloseIdleConnections() c := &http.Client{Transport: tr} c.Get(ts.URL) } // Test that the http1 Transport.DisableKeepAlives option is respected // and connections are closed as soon as idle. // See golang.org/issue/14008 func TestTransportDisableKeepAlives(t testing.T) { ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { io.WriteString(w, "hi") }, ) connClosed := make(chan struct{}) // closed on tls.Conn.Close tr := &Transport{ t1: &http.Transport{ DisableKeepAlives: true, }, TLSClientConfig: tlsConfigInsecure, DialTLS: func(network, addr string, cfg tls.Config) (net.Conn, error) { tc, err := tls.Dial(network, addr, cfg) if err != nil { return nil, err } return &noteCloseConn{Conn: tc, closefn: func() { close(connClosed) }}, nil }, } c := &http.Client{Transport: tr} res, err := c.Get(ts.URL) if err != nil { t.Fatal(err) } if _, err := io.ReadAll(res.Body); err != nil { t.Fatal(err) } defer res.Body.Close() select { case <-connClosed: case <-time.After(1 time.Second): t.Errorf("timeout") } } // Test concurrent requests with Transport.DisableKeepAlives. We can share connections, // but when things are totally idle, it still needs to close. func TestTransportDisableKeepAlives_Concurrency(t testing.T) { const D = 25 time.Millisecond ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { time.Sleep(D) io.WriteString(w, "hi") }, ) var dials int32 var conns sync.WaitGroup tr := &Transport{ t1: &http.Transport{ DisableKeepAlives: true, }, TLSClientConfig: tlsConfigInsecure, DialTLS: func(network, addr string, cfg tls.Config) (net.Conn, error) { tc, err := tls.Dial(network, addr, cfg) if err != nil { return nil, err } atomic.AddInt32(&dials, 1) conns.Add(1) return &noteCloseConn{Conn: tc, closefn: func() { conns.Done() }}, nil }, } c := &http.Client{Transport: tr} var reqs sync.WaitGroup const N = 20 for i := 0; i < N; i++ { reqs.Add(1) if i == N-1 { // For the final request, try to make all the // others close. This isn't verified in the // count, other than the Log statement, since // it's so timing dependent. This test is // really to make sure we don't interrupt a // valid request. time.Sleep(D * 2) } go func() { defer reqs.Done() res, err := c.Get(ts.URL) if err != nil { t.Error(err) return } if _, err := io.ReadAll(res.Body); err != nil { t.Error(err) return } res.Body.Close() }() } reqs.Wait() conns.Wait() t.Logf("did %d dials, %d requests", atomic.LoadInt32(&dials), N) } type noteCloseConn struct { net.Conn onceClose sync.Once closefn func() } func (c noteCloseConn) Close() error { c.onceClose.Do(c.closefn) return c.Conn.Close() } func isTimeout(err error) bool { switch err := err.(type) { case nil: return false case url.Error: return isTimeout(err.Err) case net.Error: return err.Timeout() } return false } // Test that the http1 Transport.ResponseHeaderTimeout option and cancel is sent. func TestTransportResponseHeaderTimeout_NoBody(t testing.T) { testTransportResponseHeaderTimeout(t, false) } func TestTransportResponseHeaderTimeout_Body(t testing.T) { testTransportResponseHeaderTimeout(t, true) } func testTransportResponseHeaderTimeout(t testing.T, body bool) { const bodySize = 4 << 20 tc := newTestClientConn(t, func(tr Transport) { tr.t1 = &http.Transport{ ResponseHeaderTimeout: 5 * time.Millisecond, } }) tc.greet() var req http.Request var reqBody testRequestBody if body { reqBody = tc.newRequestBody() reqBody.writeBytes(bodySize) reqBody.closeWithError(io.EOF) req, _ = http.NewRequest("POST", "https://dummy.tld/", reqBody) req.Header.Set("Content-Type", "text/foo") } else { req, _ = http.NewRequest("GET", "https://dummy.tld/", nil) } rt := tc.roundTrip(req) tc.wantFrameType(FrameHeaders) tc.writeWindowUpdate(0, bodySize) tc.writeWindowUpdate(rt.streamID(), bodySize) if body { tc.wantData(wantData{ endStream: true, size: bodySize, multiple: true, }) } tc.advance(4 * time.Millisecond) if rt.done() { t.Fatalf("RoundTrip is done after 4ms; want still waiting") } tc.advance(1 * time.Millisecond) if err := rt.err(); !isTimeout(err) { t.Fatalf("RoundTrip error: %v; want timeout error", err) } } func TestTransportDisableCompression(t testing.T) { const body = "sup" ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { want := http.Header{ "User-Agent": []string{"Go-http-client/2.0"}, } if !reflect.DeepEqual(r.Header, want) { t.Errorf("request headers = %v; want %v", r.Header, want) } }) tr := &Transport{ TLSClientConfig: tlsConfigInsecure, t1: &http.Transport{ DisableCompression: true, }, } defer tr.CloseIdleConnections() req, err := http.NewRequest("GET", ts.URL, nil) if err != nil { t.Fatal(err) } res, err := tr.RoundTrip(req) if err != nil { t.Fatal(err) } defer res.Body.Close() } // RFC 7540 section 8.1.2.2 func TestTransportRejectsConnHeaders(t testing.T) { ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { var got []string for k := range r.Header { got = append(got, k) } sort.Strings(got) w.Header().Set("Got-Header", strings.Join(got, ",")) }) tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() tests := []struct { key string value []string want string }{ { key: "Upgrade", value: []string{"anything"}, want: "ERROR: http2: invalid Upgrade request header: [\"anything\"]", }, { key: "Connection", value: []string{"foo"}, want: "ERROR: http2: invalid Connection request header: [\"foo\"]", }, { key: "Connection", value: []string{"close"}, want: "Accept-Encoding,User-Agent", }, { key: "Connection", value: []string{"CLoSe"}, want: "Accept-Encoding,User-Agent", }, { key: "Connection", value: []string{"close", "something-else"}, want: "ERROR: http2: invalid Connection request header: [\"close\" \"something-else\"]", }, { key: "Connection", value: []string{"keep-alive"}, want: "Accept-Encoding,User-Agent", }, { key: "Connection", value: []string{"Keep-ALIVE"}, want: "Accept-Encoding,User-Agent", }, { key: "Proxy-Connection", // just deleted and ignored value: []string{"keep-alive"}, want: "Accept-Encoding,User-Agent", }, { key: "Transfer-Encoding", value: []string{""}, want: "Accept-Encoding,User-Agent", }, { key: "Transfer-Encoding", value: []string{"foo"}, want: "ERROR: http2: invalid Transfer-Encoding request header: [\"foo\"]", }, { key: "Transfer-Encoding", value: []string{"chunked"}, want: "Accept-Encoding,User-Agent", }, { key: "Transfer-Encoding", value: []string{"chunKed"}, // Kelvin sign want: "ERROR: http2: invalid Transfer-Encoding request header: [\"chunKed\"]", }, { key: "Transfer-Encoding", value: []string{"chunked", "other"}, want: "ERROR: http2: invalid Transfer-Encoding request header: [\"chunked\" \"other\"]", }, { key: "Content-Length", value: []string{"123"}, want: "Accept-Encoding,User-Agent", }, { key: "Keep-Alive", value: []string{"doop"}, want: "Accept-Encoding,User-Agent", }, } for _, tt := range tests { req, _ := http.NewRequest("GET", ts.URL, nil) req.Header[tt.key] = tt.value res, err := tr.RoundTrip(req) var got string if err != nil { got = fmt.Sprintf("ERROR: %v", err) } else { got = res.Header.Get("Got-Header") res.Body.Close() } if got != tt.want { t.Errorf("For key %q, value %q, got = %q; want %q", tt.key, tt.value, got, tt.want) } } } // Reject content-length headers containing a sign. // See https://golang.org/issue/39017 func TestTransportRejectsContentLengthWithSign(t testing.T) { tests := []struct { name string cl []string wantCL string }{ { name: "proper content-length", cl: []string{"3"}, wantCL: "3", }, { name: "ignore cl with plus sign", cl: []string{"+3"}, wantCL: "", }, { name: "ignore cl with minus sign", cl: []string{"-3"}, wantCL: "", }, { name: "max int64, for safe uint64->int64 conversion", cl: []string{"9223372036854775807"}, wantCL: "9223372036854775807", }, { name: "overflows int64, so ignored", cl: []string{"9223372036854775808"}, wantCL: "", }, } for _, tt := range tests { tt := tt t.Run(tt.name, func(t testing.T) { ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { w.Header().Set("Content-Length", tt.cl[0]) }) tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() req, _ := http.NewRequest("HEAD", ts.URL, nil) res, err := tr.RoundTrip(req) var got string if err != nil { got = fmt.Sprintf("ERROR: %v", err) } else { got = res.Header.Get("Content-Length") res.Body.Close() } if got != tt.wantCL { t.Fatalf("Got: %q\nWant: %q", got, tt.wantCL) } }) } } // golang.org/issue/14048 // golang.org/issue/64766 func TestTransportFailsOnInvalidHeadersAndTrailers(t testing.T) { ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { var got []string for k := range r.Header { got = append(got, k) } sort.Strings(got) w.Header().Set("Got-Header", strings.Join(got, ",")) }) tests := [...]struct { h http.Header t http.Header wantErr string }{ 0: { h: http.Header{"with space": {"foo"}}, wantErr: `invalid HTTP header name "with space"`, }, 1: { h: http.Header{"name": {"Брэд"}}, wantErr: "", // okay }, 2: { h: http.Header{"имя": {"Brad"}}, wantErr: `invalid HTTP header name "имя"`, }, 3: { h: http.Header{"foo": {"foo\x01bar"}}, wantErr: `invalid HTTP header value for header "foo"`, }, 4: { t: http.Header{"foo": {"foo\x01bar"}}, wantErr: `invalid HTTP trailer value for header "foo"`, }, 5: { t: http.Header{"x-\r\nda": {"foo\x01bar"}}, wantErr: `invalid HTTP trailer name "x-\r\nda"`, }, } tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() for i, tt := range tests { req, _ := http.NewRequest("GET", ts.URL, nil) req.Header = tt.h req.Trailer = tt.t res, err := tr.RoundTrip(req) var bad bool if tt.wantErr == "" { if err != nil { bad = true t.Errorf("case %d: error = %v; want no error", i, err) } } else { if !strings.Contains(fmt.Sprint(err), tt.wantErr) { bad = true t.Errorf("case %d: error = %v; want error %q", i, err, tt.wantErr) } } if err == nil { if bad { t.Logf("case %d: server got headers %q", i, res.Header.Get("Got-Header")) } res.Body.Close() } } } // Tests that gzipReader doesn't crash on a second Read call following // the first Read call's gzip.NewReader returning an error. func TestGzipReader_DoubleReadCrash(t testing.T) { gz := &gzipReader{ body: io.NopCloser(strings.NewReader("0123456789")), } var buf [1]byte n, err1 := gz.Read(buf[:]) if n != 0 \|\| !strings.Contains(fmt.Sprint(err1), "invalid header") { t.Fatalf("Read = %v, %v; want 0, invalid header", n, err1) } n, err2 := gz.Read(buf[:]) if n != 0 \|\| err2 != err1 { t.Fatalf("second Read = %v, %v; want 0, %v", n, err2, err1) } } func TestGzipReader_ReadAfterClose(t testing.T) { body := bytes.Buffer{} w := gzip.NewWriter(&body) w.Write([]byte("012345679")) w.Close() gz := &gzipReader{ body: io.NopCloser(&body), } var buf [1]byte n, err := gz.Read(buf[:]) if n != 1 \|\| err != nil { t.Fatalf("first Read = %v, %v; want 1, nil", n, err) } if err := gz.Close(); err != nil { t.Fatalf("gz Close error: %v", err) } n, err = gz.Read(buf[:]) if n != 0 \|\| err != fs.ErrClosed { t.Fatalf("Read after close = %v, %v; want 0, fs.ErrClosed", n, err) } } func TestTransportNewTLSConfig(t testing.T) { tests := [...]struct { conf tls.Config host string want tls.Config }{ // Normal case. 0: { conf: nil, host: "foo.com", want: &tls.Config{ ServerName: "foo.com", NextProtos: []string{NextProtoTLS}, }, }, // User-provided name (bar.com) takes precedence: 1: { conf: &tls.Config{ ServerName: "bar.com", }, host: "foo.com", want: &tls.Config{ ServerName: "bar.com", NextProtos: []string{NextProtoTLS}, }, }, // NextProto is prepended: 2: { conf: &tls.Config{ NextProtos: []string{"foo", "bar"}, }, host: "example.com", want: &tls.Config{ ServerName: "example.com", NextProtos: []string{NextProtoTLS, "foo", "bar"}, }, }, // NextProto is not duplicated: 3: { conf: &tls.Config{ NextProtos: []string{"foo", "bar", NextProtoTLS}, }, host: "example.com", want: &tls.Config{ ServerName: "example.com", NextProtos: []string{"foo", "bar", NextProtoTLS}, }, }, } for i, tt := range tests { // Ignore the session ticket keys part, which ends up populating // unexported fields in the Config: if tt.conf != nil { tt.conf.SessionTicketsDisabled = true } tr := &Transport{TLSClientConfig: tt.conf} got := tr.newTLSConfig(tt.host) got.SessionTicketsDisabled = false if !reflect.DeepEqual(got, tt.want) { t.Errorf("%d. got %#v; want %#v", i, got, tt.want) } } } // The Google GFE responds to HEAD requests with a HEADERS frame // without END_STREAM, followed by a 0-length DATA frame with // END_STREAM. Make sure we don't get confused by that. (We did.) func TestTransportReadHeadResponse(t testing.T) { tc := newTestClientConn(t) tc.greet() req, _ := http.NewRequest("HEAD", "https://dummy.tld/", nil) rt := tc.roundTrip(req) tc.wantFrameType(FrameHeaders) tc.writeHeaders(HeadersFrameParam{ StreamID: rt.streamID(), EndHeaders: true, EndStream: false, // as the GFE does BlockFragment: tc.makeHeaderBlockFragment( ":status", "200", "content-length", "123", ), }) tc.writeData(rt.streamID(), true, nil) res := rt.response() if res.ContentLength != 123 { t.Fatalf("Content-Length = %d; want 123", res.ContentLength) } rt.wantBody(nil) } func TestTransportReadHeadResponseWithBody(t testing.T) { // This test uses an invalid response format. // Discard logger output to not spam tests output. log.SetOutput(io.Discard) defer log.SetOutput(os.Stderr) response := "redirecting to /elsewhere" tc := newTestClientConn(t) tc.greet() req, _ := http.NewRequest("HEAD", "https://dummy.tld/", nil) rt := tc.roundTrip(req) tc.wantFrameType(FrameHeaders) tc.writeHeaders(HeadersFrameParam{ StreamID: rt.streamID(), EndHeaders: true, EndStream: false, BlockFragment: tc.makeHeaderBlockFragment( ":status", "200", "content-length", strconv.Itoa(len(response)), ), }) tc.writeData(rt.streamID(), true, []byte(response)) res := rt.response() if res.ContentLength != int64(len(response)) { t.Fatalf("Content-Length = %d; want %d", res.ContentLength, len(response)) } rt.wantBody(nil) } type neverEnding byte func (b neverEnding) Read(p []byte) (int, error) { for i := range p { p[i] = byte(b) } return len(p), nil } // golang.org/issue/15425: test that a handler closing the request // body doesn't terminate the stream to the peer. (It just stops // readability from the handler's side, and eventually the client // runs out of flow control tokens) func TestTransportHandlerBodyClose(t testing.T) { const bodySize = 10 << 20 ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { r.Body.Close() io.Copy(w, io.LimitReader(neverEnding('A'), bodySize)) }) tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() g0 := runtime.NumGoroutine() const numReq = 10 for i := 0; i < numReq; i++ { req, err := http.NewRequest("POST", ts.URL, struct{ io.Reader }{io.LimitReader(neverEnding('A'), bodySize)}) if err != nil { t.Fatal(err) } res, err := tr.RoundTrip(req) if err != nil { t.Fatal(err) } n, err := io.Copy(io.Discard, res.Body) res.Body.Close() if n != bodySize \|\| err != nil { t.Fatalf("req#%d: Copy = %d, %v; want %d, nil", i, n, err, bodySize) } } tr.CloseIdleConnections() if !waitCondition(5time.Second, 100time.Millisecond, func() bool { gd := runtime.NumGoroutine() - g0 return gd < numReq/2 }) { t.Errorf("appeared to leak goroutines") } } // https://golang.org/issue/15930 func TestTransportFlowControl(t testing.T) { const bufLen = 64 << 10 var total int64 = 100 << 20 // 100MB if testing.Short() { total = 10 << 20 } var wrote int64 // updated atomically ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { b := make([]byte, bufLen) for wrote < total { n, err := w.Write(b) atomic.AddInt64(&wrote, int64(n)) if err != nil { t.Errorf("ResponseWriter.Write error: %v", err) break } w.(http.Flusher).Flush() } }) tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() req, err := http.NewRequest("GET", ts.URL, nil) if err != nil { t.Fatal("NewRequest error:", err) } resp, err := tr.RoundTrip(req) if err != nil { t.Fatal("RoundTrip error:", err) } defer resp.Body.Close() var read int64 b := make([]byte, bufLen) for { n, err := resp.Body.Read(b) if err == io.EOF { break } if err != nil { t.Fatal("Read error:", err) } read += int64(n) const max = transportDefaultStreamFlow if w := atomic.LoadInt64(&wrote); -max > read-w \|\| read-w > max { t.Fatalf("Too much data inflight: server wrote %v bytes but client only received %v", w, read) } // Let the server get ahead of the client. time.Sleep(1 * time.Millisecond) } } // golang.org/issue/14627 -- if the server sends a GOAWAY frame, make // the Transport remember it and return it back to users (via // RoundTrip or request body reads) if needed (e.g. if the server // proceeds to close the TCP connection before the client gets its // response) func TestTransportUsesGoAwayDebugError_RoundTrip(t testing.T) { testTransportUsesGoAwayDebugError(t, false) } func TestTransportUsesGoAwayDebugError_Body(t testing.T) { testTransportUsesGoAwayDebugError(t, true) } func testTransportUsesGoAwayDebugError(t testing.T, failMidBody bool) { tc := newTestClientConn(t) tc.greet() const goAwayErrCode = ErrCodeHTTP11Required // arbitrary const goAwayDebugData = "some debug data" req, _ := http.NewRequest("GET", "https://dummy.tld/", nil) rt := tc.roundTrip(req) tc.wantFrameType(FrameHeaders) if failMidBody { tc.writeHeaders(HeadersFrameParam{ StreamID: rt.streamID(), EndHeaders: true, EndStream: false, BlockFragment: tc.makeHeaderBlockFragment( ":status", "200", "content-length", "123", ), }) } // Write two GOAWAY frames, to test that the Transport takes // the interesting parts of both. tc.writeGoAway(5, ErrCodeNo, []byte(goAwayDebugData)) tc.writeGoAway(5, goAwayErrCode, nil) tc.closeWrite() res, err := rt.result() whence := "RoundTrip" if failMidBody { whence = "Body.Read" if err != nil { t.Fatalf("RoundTrip error = %v, want success", err) } _, err = res.Body.Read(make([]byte, 1)) } want := GoAwayError{ LastStreamID: 5, ErrCode: goAwayErrCode, DebugData: goAwayDebugData, } if !reflect.DeepEqual(err, want) { t.Errorf("%v error = %T: %#v, want %T (%#v)", whence, err, err, want, want) } } func testTransportReturnsUnusedFlowControl(t testing.T, oneDataFrame bool) { tc := newTestClientConn(t) tc.greet() req, _ := http.NewRequest("GET", "https://dummy.tld/", nil) rt := tc.roundTrip(req) tc.wantFrameType(FrameHeaders) tc.writeHeaders(HeadersFrameParam{ StreamID: rt.streamID(), EndHeaders: true, EndStream: false, BlockFragment: tc.makeHeaderBlockFragment( ":status", "200", "content-length", "5000", ), }) initialInflow := tc.inflowWindow(0) // Two cases: // - Send one DATA frame with 5000 bytes. // - Send two DATA frames with 1 and 4999 bytes each. // // In both cases, the client should consume one byte of data, // refund that byte, then refund the following 4999 bytes. // // In the second case, the server waits for the client to reset the // stream before sending the second DATA frame. This tests the case // where the client receives a DATA frame after it has reset the stream. const streamNotEnded = false if oneDataFrame { tc.writeData(rt.streamID(), streamNotEnded, make([]byte, 5000)) } else { tc.writeData(rt.streamID(), streamNotEnded, make([]byte, 1)) } res := rt.response() if n, err := res.Body.Read(make([]byte, 1)); err != nil \|\| n != 1 { t.Fatalf("body read = %v, %v; want 1, nil", n, err) } res.Body.Close() // leaving 4999 bytes unread tc.sync() sentAdditionalData := false tc.wantUnorderedFrames( func(f RSTStreamFrame) bool { if f.ErrCode != ErrCodeCancel { t.Fatalf("Expected a RSTStreamFrame with code cancel; got %v", summarizeFrame(f)) } if !oneDataFrame { // Send the remaining data now. tc.writeData(rt.streamID(), streamNotEnded, make([]byte, 4999)) sentAdditionalData = true } return true }, func(f PingFrame) bool { return true }, func(f WindowUpdateFrame) bool { if !oneDataFrame && !sentAdditionalData { t.Fatalf("Got WindowUpdateFrame, don't expect one yet") } if f.Increment != 5000 { t.Fatalf("Expected WindowUpdateFrames for 5000 bytes; got %v", summarizeFrame(f)) } return true }, ) if got, want := tc.inflowWindow(0), initialInflow; got != want { t.Fatalf("connection flow tokens = %v, want %v", got, want) } } // See golang.org/issue/16481 func TestTransportReturnsUnusedFlowControlSingleWrite(t testing.T) { testTransportReturnsUnusedFlowControl(t, true) } // See golang.org/issue/20469 func TestTransportReturnsUnusedFlowControlMultipleWrites(t testing.T) { testTransportReturnsUnusedFlowControl(t, false) } // Issue 16612: adjust flow control on open streams when transport // receives SETTINGS with INITIAL_WINDOW_SIZE from server. func TestTransportAdjustsFlowControl(t testing.T) { const bodySize = 1 << 20 tc := newTestClientConn(t) tc.wantFrameType(FrameSettings) tc.wantFrameType(FrameWindowUpdate) // Don't write our SETTINGS yet. body := tc.newRequestBody() body.writeBytes(bodySize) body.closeWithError(io.EOF) req, _ := http.NewRequest("POST", "https://dummy.tld/", body) rt := tc.roundTrip(req) tc.wantFrameType(FrameHeaders) gotBytes := int64(0) for { f := readFrame[DataFrame](t, tc) gotBytes += int64(len(f.Data())) // After we've got half the client's initial flow control window's worth // of request body data, give it just enough flow control to finish. if gotBytes >= initialWindowSize/2 { break } } tc.writeSettings(Setting{ID: SettingInitialWindowSize, Val: bodySize}) tc.writeWindowUpdate(0, bodySize) tc.writeSettingsAck() tc.wantUnorderedFrames( func(f SettingsFrame) bool { return true }, func(f DataFrame) bool { gotBytes += int64(len(f.Data())) return f.StreamEnded() }, ) if gotBytes != bodySize { t.Fatalf("server received %v bytes of body, want %v", gotBytes, bodySize) } tc.writeHeaders(HeadersFrameParam{ StreamID: rt.streamID(), EndHeaders: true, EndStream: true, BlockFragment: tc.makeHeaderBlockFragment( ":status", "200", ), }) rt.wantStatus(200) } // See golang.org/issue/16556 func TestTransportReturnsDataPaddingFlowControl(t testing.T) { tc := newTestClientConn(t) tc.greet() req, _ := http.NewRequest("GET", "https://dummy.tld/", nil) rt := tc.roundTrip(req) tc.wantFrameType(FrameHeaders) tc.writeHeaders(HeadersFrameParam{ StreamID: rt.streamID(), EndHeaders: true, EndStream: false, BlockFragment: tc.makeHeaderBlockFragment( ":status", "200", "content-length", "5000", ), }) initialConnWindow := tc.inflowWindow(0) initialStreamWindow := tc.inflowWindow(rt.streamID()) pad := make([]byte, 5) tc.writeDataPadded(rt.streamID(), false, make([]byte, 5000), pad) // Padding flow control should have been returned. if got, want := tc.inflowWindow(0), initialConnWindow-5000; got != want { t.Errorf("conn inflow window = %v, want %v", got, want) } if got, want := tc.inflowWindow(rt.streamID()), initialStreamWindow-5000; got != want { t.Errorf("stream inflow window = %v, want %v", got, want) } } // golang.org/issue/16572 -- RoundTrip shouldn't hang when it gets a // StreamError as a result of the response HEADERS func TestTransportReturnsErrorOnBadResponseHeaders(t testing.T) { tc := newTestClientConn(t) tc.greet() req, _ := http.NewRequest("GET", "https://dummy.tld/", nil) rt := tc.roundTrip(req) tc.wantFrameType(FrameHeaders) tc.writeHeaders(HeadersFrameParam{ StreamID: rt.streamID(), EndHeaders: true, EndStream: false, BlockFragment: tc.makeHeaderBlockFragment( ":status", "200", " content-type", "bogus", ), }) err := rt.err() want := StreamError{1, ErrCodeProtocol, headerFieldNameError(" content-type")} if !reflect.DeepEqual(err, want) { t.Fatalf("RoundTrip error = %#v; want %#v", err, want) } fr := readFrame[RSTStreamFrame](t, tc) if fr.StreamID != 1 \|\| fr.ErrCode != ErrCodeProtocol { t.Errorf("Frame = %v; want RST_STREAM for stream 1 with ErrCodeProtocol", summarizeFrame(fr)) } } // byteAndEOFReader returns is in an io.Reader which reads one byte // (the underlying byte) and io.EOF at once in its Read call. type byteAndEOFReader byte func (b byteAndEOFReader) Read(p []byte) (n int, err error) { if len(p) == 0 { panic("unexpected useless call") } p[0] = byte(b) return 1, io.EOF } // Issue 16788: the Transport had a regression where it started // sending a spurious DATA frame with a duplicate END_STREAM bit after // the request body writer goroutine had already read an EOF from the // Request.Body and included the END_STREAM on a data-carrying DATA // frame. // // Notably, to trigger this, the requests need to use a Request.Body // which returns (non-0, io.EOF) and also needs to set the ContentLength // explicitly. func TestTransportBodyDoubleEndStream(t testing.T) { ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { // Nothing. }) tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() for i := 0; i < 2; i++ { req, _ := http.NewRequest("POST", ts.URL, byteAndEOFReader('a')) req.ContentLength = 1 res, err := tr.RoundTrip(req) if err != nil { t.Fatalf("failure on req %d: %v", i+1, err) } defer res.Body.Close() } } // golang.org/issue/16847, golang.org/issue/19103 func TestTransportRequestPathPseudo(t testing.T) { type result struct { path string err string } tests := []struct { req http.Request want result }{ 0: { req: &http.Request{ Method: "GET", URL: &url.URL{ Host: "foo.com", Path: "/foo", }, }, want: result{path: "/foo"}, }, // In Go 1.7, we accepted paths of "//foo". // In Go 1.8, we rejected it (issue 16847). // In Go 1.9, we accepted it again (issue 19103). 1: { req: &http.Request{ Method: "GET", URL: &url.URL{ Host: "foo.com", Path: "//foo", }, }, want: result{path: "//foo"}, }, // Opaque with //$Matching_Hostname/path 2: { req: &http.Request{ Method: "GET", URL: &url.URL{ Scheme: "https", Opaque: "//foo.com/path", Host: "foo.com", Path: "/ignored", }, }, want: result{path: "/path"}, }, // Opaque with some other Request.Host instead: 3: { req: &http.Request{ Method: "GET", Host: "bar.com", URL: &url.URL{ Scheme: "https", Opaque: "//bar.com/path", Host: "foo.com", Path: "/ignored", }, }, want: result{path: "/path"}, }, // Opaque without the leading "//": 4: { req: &http.Request{ Method: "GET", URL: &url.URL{ Opaque: "/path", Host: "foo.com", Path: "/ignored", }, }, want: result{path: "/path"}, }, // Opaque we can't handle: 5: { req: &http.Request{ Method: "GET", URL: &url.URL{ Scheme: "https", Opaque: "//unknown_host/path", Host: "foo.com", Path: "/ignored", }, }, want: result{err: `invalid request :path "https://unknown_host/path" from URL.Opaque = "//unknown_host/path"`}, }, // A CONNECT request: 6: { req: &http.Request{ Method: "CONNECT", URL: &url.URL{ Host: "foo.com", }, }, want: result{}, }, } for i, tt := range tests { cc := &ClientConn{peerMaxHeaderListSize: 0xffffffffffffffff} cc.henc = hpack.NewEncoder(&cc.hbuf) cc.mu.Lock() hdrs, err := cc.encodeHeaders(tt.req, false, "", -1) cc.mu.Unlock() var got result hpackDec := hpack.NewDecoder(initialHeaderTableSize, func(f hpack.HeaderField) { if f.Name == ":path" { got.path = f.Value } }) if err != nil { got.err = err.Error() } else if len(hdrs) > 0 { if _, err := hpackDec.Write(hdrs); err != nil { t.Errorf("%d. bogus hpack: %v", i, err) continue } } if got != tt.want { t.Errorf("%d. got %+v; want %+v", i, got, tt.want) } } } // golang.org/issue/17071 -- don't sniff the first byte of the request body // before we've determined that the ClientConn is usable. func TestRoundTripDoesntConsumeRequestBodyEarly(t testing.T) { const body = "foo" req, _ := http.NewRequest("POST", "http://foo.com/", io.NopCloser(strings.NewReader(body))) cc := &ClientConn{ closed: true, reqHeaderMu: make(chan struct{}, 1), t: &Transport{}, } _, err := cc.RoundTrip(req) if err != errClientConnUnusable { t.Fatalf("RoundTrip = %v; want errClientConnUnusable", err) } slurp, err := io.ReadAll(req.Body) if err != nil { t.Errorf("ReadAll = %v", err) } if string(slurp) != body { t.Errorf("Body = %q; want %q", slurp, body) } } func TestClientConnPing(t testing.T) { ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) {}) tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() ctx := context.Background() cc, err := tr.dialClientConn(ctx, ts.Listener.Addr().String(), false) if err != nil { t.Fatal(err) } if err = cc.Ping(context.Background()); err != nil { t.Fatal(err) } } // Issue 16974: if the server sent a DATA frame after the user // canceled the Transport's Request, the Transport previously wrote to a // closed pipe, got an error, and ended up closing the whole TCP // connection. func TestTransportCancelDataResponseRace(t testing.T) { cancel := make(chan struct{}) clientGotResponse := make(chan bool, 1) const msg = "Hello." ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { if strings.Contains(r.URL.Path, "/hello") { time.Sleep(50 time.Millisecond) io.WriteString(w, msg) return } for i := 0; i < 50; i++ { io.WriteString(w, "Some data.") w.(http.Flusher).Flush() if i == 2 { <-clientGotResponse close(cancel) } time.Sleep(10 * time.Millisecond) } }) tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() c := &http.Client{Transport: tr} req, _ := http.NewRequest("GET", ts.URL, nil) req.Cancel = cancel res, err := c.Do(req) clientGotResponse <- true if err != nil { t.Fatal(err) } if _, err = io.Copy(io.Discard, res.Body); err == nil { t.Fatal("unexpected success") } res, err = c.Get(ts.URL + "/hello") if err != nil { t.Fatal(err) } slurp, err := io.ReadAll(res.Body) if err != nil { t.Fatal(err) } if string(slurp) != msg { t.Errorf("Got = %q; want %q", slurp, msg) } } // Issue 21316: It should be safe to reuse an http.Request after the // request has completed. func TestTransportNoRaceOnRequestObjectAfterRequestComplete(t testing.T) { ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { w.WriteHeader(200) io.WriteString(w, "body") }) tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() req, _ := http.NewRequest("GET", ts.URL, nil) resp, err := tr.RoundTrip(req) if err != nil { t.Fatal(err) } if _, err = io.Copy(io.Discard, resp.Body); err != nil { t.Fatalf("error reading response body: %v", err) } if err := resp.Body.Close(); err != nil { t.Fatalf("error closing response body: %v", err) } // This access of req.Header should not race with code in the transport. req.Header = http.Header{} } func TestTransportCloseAfterLostPing(t testing.T) { tc := newTestClientConn(t, func(tr Transport) { tr.PingTimeout = 1 * time.Second tr.ReadIdleTimeout = 1 * time.Second }) tc.greet() req, _ := http.NewRequest("GET", "https://dummy.tld/", nil) rt := tc.roundTrip(req) tc.wantFrameType(FrameHeaders) tc.advance(1 * time.Second) tc.wantFrameType(FramePing) tc.advance(1 * time.Second) err := rt.err() if err == nil \|\| !strings.Contains(err.Error(), "client connection lost") { t.Fatalf("expected to get error about \"connection lost\", got %v", err) } } func TestTransportPingWriteBlocks(t testing.T) { ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) {}, ) tr := &Transport{ TLSClientConfig: tlsConfigInsecure, DialTLS: func(network, addr string, cfg tls.Config) (net.Conn, error) { s, c := net.Pipe() // unbuffered, unlike a TCP conn go func() { // Read initial handshake frames. // Without this, we block indefinitely in newClientConn, // and never get to the point of sending a PING. var buf [1024]byte s.Read(buf[:]) }() return c, nil }, PingTimeout: 1 time.Millisecond, ReadIdleTimeout: 1 * time.Millisecond, } defer tr.CloseIdleConnections() c := &http.Client{Transport: tr} _, err := c.Get(ts.URL) if err == nil { t.Fatalf("Get = nil, want error") } } func TestTransportPingWhenReadingMultiplePings(t testing.T) { tc := newTestClientConn(t, func(tr Transport) { tr.ReadIdleTimeout = 1000 * time.Millisecond }) tc.greet() ctx, cancel := context.WithCancel(context.Background()) req, _ := http.NewRequestWithContext(ctx, "GET", "https://dummy.tld/", nil) rt := tc.roundTrip(req) tc.wantFrameType(FrameHeaders) tc.writeHeaders(HeadersFrameParam{ StreamID: rt.streamID(), EndHeaders: true, EndStream: false, BlockFragment: tc.makeHeaderBlockFragment( ":status", "200", ), }) for i := 0; i < 5; i++ { // No ping yet... tc.advance(999 * time.Millisecond) if f := tc.readFrame(); f != nil { t.Fatalf("unexpected frame: %v", f) } // ...ping now. tc.advance(1 * time.Millisecond) f := readFrame[PingFrame](t, tc) tc.writePing(true, f.Data) } // Cancel the request, Transport resets it and returns an error from body reads. cancel() tc.sync() tc.wantFrameType(FrameRSTStream) _, err := rt.readBody() if err == nil { t.Fatalf("Response.Body.Read() = %v, want error", err) } } func TestTransportPingWhenReadingPingDisabled(t testing.T) { tc := newTestClientConn(t, func(tr Transport) { tr.ReadIdleTimeout = 0 // PINGs disabled }) tc.greet() req, _ := http.NewRequest("GET", "https://dummy.tld/", nil) rt := tc.roundTrip(req) tc.wantFrameType(FrameHeaders) tc.writeHeaders(HeadersFrameParam{ StreamID: rt.streamID(), EndHeaders: true, EndStream: false, BlockFragment: tc.makeHeaderBlockFragment( ":status", "200", ), }) // No PING is sent, even after a long delay. tc.advance(1 time.Minute) if f := tc.readFrame(); f != nil { t.Fatalf("unexpected frame: %v", f) } } func TestTransportRetryAfterGOAWAYNoRetry(t testing.T) { tt := newTestTransport(t) req, _ := http.NewRequest("GET", "https://dummy.tld/", nil) rt := tt.roundTrip(req) // First attempt: Server sends a GOAWAY with an error and // a MaxStreamID less than the request ID. // This probably indicates that there was something wrong with our request, // so we don't retry it. tc := tt.getConn() tc.wantFrameType(FrameSettings) tc.wantFrameType(FrameWindowUpdate) tc.wantHeaders(wantHeader{ streamID: 1, endStream: true, }) tc.writeSettings() tc.writeGoAway(0 /max id/, ErrCodeInternal, nil) if rt.err() == nil { t.Fatalf("after GOAWAY, RoundTrip is not done, want error") } } func TestTransportRetryAfterGOAWAYRetry(t testing.T) { tt := newTestTransport(t) req, _ := http.NewRequest("GET", "https://dummy.tld/", nil) rt := tt.roundTrip(req) // First attempt: Server sends a GOAWAY with ErrCodeNo and // a MaxStreamID less than the request ID. // We take the server at its word that nothing has really gone wrong, // and retry the request. tc := tt.getConn() tc.wantFrameType(FrameSettings) tc.wantFrameType(FrameWindowUpdate) tc.wantHeaders(wantHeader{ streamID: 1, endStream: true, }) tc.writeSettings() tc.writeGoAway(0 /max id/, ErrCodeNo, nil) if rt.done() { t.Fatalf("after GOAWAY, RoundTrip is done; want it to be retrying") } // Second attempt succeeds on a new connection. tc = tt.getConn() tc.wantFrameType(FrameSettings) tc.wantFrameType(FrameWindowUpdate) tc.wantHeaders(wantHeader{ streamID: 1, endStream: true, }) tc.writeSettings() tc.writeHeaders(HeadersFrameParam{ StreamID: 1, EndHeaders: true, EndStream: true, BlockFragment: tc.makeHeaderBlockFragment( ":status", "200", ), }) rt.wantStatus(200) } func TestTransportRetryAfterGOAWAYSecondRequest(t testing.T) { tt := newTestTransport(t) // First request succeeds. req, _ := http.NewRequest("GET", "https://dummy.tld/", nil) rt1 := tt.roundTrip(req) tc := tt.getConn() tc.wantFrameType(FrameSettings) tc.wantFrameType(FrameWindowUpdate) tc.wantHeaders(wantHeader{ streamID: 1, endStream: true, }) tc.writeSettings() tc.wantFrameType(FrameSettings) // Settings ACK tc.writeHeaders(HeadersFrameParam{ StreamID: 1, EndHeaders: true, EndStream: true, BlockFragment: tc.makeHeaderBlockFragment( ":status", "200", ), }) rt1.wantStatus(200) // Second request: Server sends a GOAWAY with // a MaxStreamID less than the request ID. // The server says it didn't see this request, // so we retry it on a new connection. req, _ = http.NewRequest("GET", "https://dummy.tld/", nil) rt2 := tt.roundTrip(req) // Second request, first attempt. tc.wantHeaders(wantHeader{ streamID: 3, endStream: true, }) tc.writeSettings() tc.writeGoAway(1 /max id/, ErrCodeProtocol, nil) if rt2.done() { t.Fatalf("after GOAWAY, RoundTrip is done; want it to be retrying") } // Second request, second attempt. tc = tt.getConn() tc.wantFrameType(FrameSettings) tc.wantFrameType(FrameWindowUpdate) tc.wantHeaders(wantHeader{ streamID: 1, endStream: true, }) tc.writeSettings() tc.writeHeaders(HeadersFrameParam{ StreamID: 1, EndHeaders: true, EndStream: true, BlockFragment: tc.makeHeaderBlockFragment( ":status", "200", ), }) rt2.wantStatus(200) } func TestTransportRetryAfterRefusedStream(t testing.T) { tt := newTestTransport(t) req, _ := http.NewRequest("GET", "https://dummy.tld/", nil) rt := tt.roundTrip(req) // First attempt: Server sends a RST_STREAM. tc := tt.getConn() tc.wantFrameType(FrameSettings) tc.wantFrameType(FrameWindowUpdate) tc.wantHeaders(wantHeader{ streamID: 1, endStream: true, }) tc.writeSettings() tc.wantFrameType(FrameSettings) // settings ACK tc.writeRSTStream(1, ErrCodeRefusedStream) if rt.done() { t.Fatalf("after RST_STREAM, RoundTrip is done; want it to be retrying") } // Second attempt succeeds on the same connection. tc.wantHeaders(wantHeader{ streamID: 3, endStream: true, }) tc.writeSettings() tc.writeHeaders(HeadersFrameParam{ StreamID: 3, EndHeaders: true, EndStream: true, BlockFragment: tc.makeHeaderBlockFragment( ":status", "204", ), }) rt.wantStatus(204) } func TestTransportRetryHasLimit(t testing.T) { tt := newTestTransport(t) req, _ := http.NewRequest("GET", "https://dummy.tld/", nil) rt := tt.roundTrip(req) // First attempt: Server sends a GOAWAY. tc := tt.getConn() tc.wantFrameType(FrameSettings) tc.wantFrameType(FrameWindowUpdate) var totalDelay time.Duration count := 0 for streamID := uint32(1); ; streamID += 2 { count++ tc.wantHeaders(wantHeader{ streamID: streamID, endStream: true, }) if streamID == 1 { tc.writeSettings() tc.wantFrameType(FrameSettings) // settings ACK } tc.writeRSTStream(streamID, ErrCodeRefusedStream) d, scheduled := tt.group.TimeUntilEvent() if !scheduled { if streamID == 1 { continue } break } totalDelay += d if totalDelay > 5time.Minute { t.Fatalf("RoundTrip still retrying after %v, should have given up", totalDelay) } tt.advance(d) } if got, want := count, 5; got < count { t.Errorf("RoundTrip made %v attempts, want at least %v", got, want) } if rt.err() == nil { t.Errorf("RoundTrip succeeded, want error") } } func TestTransportResponseDataBeforeHeaders(t testing.T) { // Discard log output complaining about protocol error. log.SetOutput(io.Discard) t.Cleanup(func() { log.SetOutput(os.Stderr) }) // after other cleanup is done tc := newTestClientConn(t) tc.greet() // First request is normal to ensure the check is per stream and not per connection. req, _ := http.NewRequest("GET", "https://dummy.tld/", nil) rt1 := tc.roundTrip(req) tc.wantFrameType(FrameHeaders) tc.writeHeaders(HeadersFrameParam{ StreamID: rt1.streamID(), EndHeaders: true, EndStream: true, BlockFragment: tc.makeHeaderBlockFragment( ":status", "200", ), }) rt1.wantStatus(200) // Second request returns a DATA frame with no HEADERS. rt2 := tc.roundTrip(req) tc.wantFrameType(FrameHeaders) tc.writeData(rt2.streamID(), true, []byte("payload")) if err, ok := rt2.err().(StreamError); !ok \|\| err.Code != ErrCodeProtocol { t.Fatalf("expected stream PROTOCOL_ERROR, got: %v", err) } } func TestTransportMaxFrameReadSize(t testing.T) { for _, test := range []struct { maxReadFrameSize uint32 want uint32 }{{ maxReadFrameSize: 64000, want: 64000, }, { maxReadFrameSize: 1024, want: minMaxFrameSize, }} { t.Run(fmt.Sprint(test.maxReadFrameSize), func(t testing.T) { tc := newTestClientConn(t, func(tr Transport) { tr.MaxReadFrameSize = test.maxReadFrameSize }) fr := readFrame[SettingsFrame](t, tc) got, ok := fr.Value(SettingMaxFrameSize) if !ok { t.Errorf("Transport.MaxReadFrameSize = %v; server got no setting, want %v", test.maxReadFrameSize, test.want) } else if got != test.want { t.Errorf("Transport.MaxReadFrameSize = %v; server got %v, want %v", test.maxReadFrameSize, got, test.want) } }) } } func TestTransportRequestsLowServerLimit(t testing.T) { ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { }, func(s Server) { s.MaxConcurrentStreams = 1 }) var ( connCountMu sync.Mutex connCount int ) tr := &Transport{ TLSClientConfig: tlsConfigInsecure, DialTLS: func(network, addr string, cfg tls.Config) (net.Conn, error) { connCountMu.Lock() defer connCountMu.Unlock() connCount++ return tls.Dial(network, addr, cfg) }, } defer tr.CloseIdleConnections() const reqCount = 3 for i := 0; i < reqCount; i++ { req, err := http.NewRequest("GET", ts.URL, nil) if err != nil { t.Fatal(err) } res, err := tr.RoundTrip(req) if err != nil { t.Fatal(err) } if got, want := res.StatusCode, 200; got != want { t.Errorf("StatusCode = %v; want %v", got, want) } if res != nil && res.Body != nil { res.Body.Close() } } if connCount != 1 { t.Errorf("created %v connections for %v requests, want 1", connCount, reqCount) } } // tests Transport.StrictMaxConcurrentStreams func TestTransportRequestsStallAtServerLimit(t testing.T) { const maxConcurrent = 2 tc := newTestClientConn(t, func(tr Transport) { tr.StrictMaxConcurrentStreams = true }) tc.greet(Setting{SettingMaxConcurrentStreams, maxConcurrent}) cancelClientRequest := make(chan struct{}) // Start maxConcurrent+2 requests. // The server does not respond to any of them yet. var rts []testRoundTrip for k := 0; k < maxConcurrent+2; k++ { req, _ := http.NewRequest("GET", fmt.Sprintf("https://dummy.tld/%d", k), nil) if k == maxConcurrent { req.Cancel = cancelClientRequest } rt := tc.roundTrip(req) rts = append(rts, rt) if k < maxConcurrent { // We are under the stream limit, so the client sends the request. tc.wantHeaders(wantHeader{ streamID: rt.streamID(), endStream: true, header: http.Header{ ":authority": []string{"dummy.tld"}, ":method": []string{"GET"}, ":path": []string{fmt.Sprintf("/%d", k)}, }, }) } else { // We have reached the stream limit, // so the client cannot send the request. if fr := tc.readFrame(); fr != nil { t.Fatalf("after making new request while at stream limit, got unexpected frame: %v", fr) } } if rt.done() { t.Fatalf("rt %v done", k) } } // Cancel the maxConcurrent'th request. // The request should fail. close(cancelClientRequest) tc.sync() if err := rts[maxConcurrent].err(); err == nil { t.Fatalf("RoundTrip(%d) should have failed due to cancel, did not", maxConcurrent) } // No requests should be complete, except for the canceled one. for i, rt := range rts { if i != maxConcurrent && rt.done() { t.Fatalf("RoundTrip(%d) is done, but should not be", i) } } // Server responds to a request, unblocking the last one. tc.writeHeaders(HeadersFrameParam{ StreamID: rts[0].streamID(), EndHeaders: true, EndStream: true, BlockFragment: tc.makeHeaderBlockFragment( ":status", "200", ), }) tc.wantHeaders(wantHeader{ streamID: rts[maxConcurrent+1].streamID(), endStream: true, header: http.Header{ ":authority": []string{"dummy.tld"}, ":method": []string{"GET"}, ":path": []string{fmt.Sprintf("/%d", maxConcurrent+1)}, }, }) rts[0].wantStatus(200) } func TestTransportMaxDecoderHeaderTableSize(t testing.T) { var reqSize, resSize uint32 = 8192, 16384 tc := newTestClientConn(t, func(tr Transport) { tr.MaxDecoderHeaderTableSize = reqSize }) fr := readFrame[SettingsFrame](t, tc) if v, ok := fr.Value(SettingHeaderTableSize); !ok { t.Fatalf("missing SETTINGS_HEADER_TABLE_SIZE setting") } else if v != reqSize { t.Fatalf("received SETTINGS_HEADER_TABLE_SIZE = %d, want %d", v, reqSize) } tc.writeSettings(Setting{SettingHeaderTableSize, resSize}) tc.cc.mu.Lock() defer tc.cc.mu.Unlock() if got, want := tc.cc.peerMaxHeaderTableSize, resSize; got != want { t.Fatalf("peerHeaderTableSize = %d, want %d", got, want) } } func TestTransportMaxEncoderHeaderTableSize(t testing.T) { var peerAdvertisedMaxHeaderTableSize uint32 = 16384 tc := newTestClientConn(t, func(tr Transport) { tr.MaxEncoderHeaderTableSize = 8192 }) tc.greet(Setting{SettingHeaderTableSize, peerAdvertisedMaxHeaderTableSize}) if got, want := tc.cc.henc.MaxDynamicTableSize(), tc.tr.MaxEncoderHeaderTableSize; got != want { t.Fatalf("henc.MaxDynamicTableSize() = %d, want %d", got, want) } } func TestAuthorityAddr(t testing.T) { tests := []struct { scheme, authority string want string }{ {"http", "foo.com", "foo.com:80"}, {"https", "foo.com", "foo.com:443"}, {"https", "foo.com:", "foo.com:443"}, {"https", "foo.com:1234", "foo.com:1234"}, {"https", "1.2.3.4:1234", "1.2.3.4:1234"}, {"https", "1.2.3.4", "1.2.3.4:443"}, {"https", "1.2.3.4:", "1.2.3.4:443"}, {"https", "[::1]:1234", "[::1]:1234"}, {"https", "[::1]", "[::1]:443"}, {"https", "[::1]:", "[::1]:443"}, } for _, tt := range tests { got := authorityAddr(tt.scheme, tt.authority) if got != tt.want { t.Errorf("authorityAddr(%q, %q) = %q; want %q", tt.scheme, tt.authority, got, tt.want) } } } // Issue 20448: stop allocating for DATA frames' payload after // Response.Body.Close is called. func TestTransportAllocationsAfterResponseBodyClose(t testing.T) { megabyteZero := make([]byte, 1<<20) writeErr := make(chan error, 1) ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { w.(http.Flusher).Flush() var sum int64 for i := 0; i < 100; i++ { n, err := w.Write(megabyteZero) sum += int64(n) if err != nil { writeErr <- err return } } t.Logf("wrote all %d bytes", sum) writeErr <- nil }) tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() c := &http.Client{Transport: tr} res, err := c.Get(ts.URL) if err != nil { t.Fatal(err) } var buf [1]byte if _, err := res.Body.Read(buf[:]); err != nil { t.Error(err) } if err := res.Body.Close(); err != nil { t.Error(err) } trb, ok := res.Body.(transportResponseBody) if !ok { t.Fatalf("res.Body = %T; want transportResponseBody", res.Body) } if trb.cs.bufPipe.b != nil { t.Errorf("response body pipe is still open") } gotErr := <-writeErr if gotErr == nil { t.Errorf("Handler unexpectedly managed to write its entire response without getting an error") } else if gotErr != errStreamClosed { t.Errorf("Handler Write err = %v; want errStreamClosed", gotErr) } } // Issue 18891: make sure Request.Body == NoBody means no DATA frame // is ever sent, even if empty. func TestTransportNoBodyMeansNoDATA(t testing.T) { tc := newTestClientConn(t) tc.greet() req, _ := http.NewRequest("GET", "https://dummy.tld/", http.NoBody) rt := tc.roundTrip(req) tc.wantHeaders(wantHeader{ streamID: rt.streamID(), endStream: true, // END_STREAM should be set when body is http.NoBody header: http.Header{ ":authority": []string{"dummy.tld"}, ":method": []string{"GET"}, ":path": []string{"/"}, }, }) if fr := tc.readFrame(); fr != nil { t.Fatalf("unexpected frame after headers: %v", fr) } } func benchSimpleRoundTrip(b testing.B, nReqHeaders, nResHeader int) { disableGoroutineTracking(b) b.ReportAllocs() ts := newTestServer(b, func(w http.ResponseWriter, r http.Request) { for i := 0; i < nResHeader; i++ { name := fmt.Sprint("A-", i) w.Header().Set(name, "") } }, optQuiet, ) tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() req, err := http.NewRequest("GET", ts.URL, nil) if err != nil { b.Fatal(err) } for i := 0; i < nReqHeaders; i++ { name := fmt.Sprint("A-", i) req.Header.Set(name, "") } b.ResetTimer() for i := 0; i < b.N; i++ { res, err := tr.RoundTrip(req) if err != nil { if res != nil { res.Body.Close() } b.Fatalf("RoundTrip err = %v; want nil", err) } res.Body.Close() if res.StatusCode != http.StatusOK { b.Fatalf("Response code = %v; want %v", res.StatusCode, http.StatusOK) } } } type infiniteReader struct{} func (r infiniteReader) Read(b []byte) (int, error) { return len(b), nil } // Issue 20521: it is not an error to receive a response and end stream // from the server without the body being consumed. func TestTransportResponseAndResetWithoutConsumingBodyRace(t testing.T) { ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { w.WriteHeader(http.StatusOK) }) tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() // The request body needs to be big enough to trigger flow control. req, _ := http.NewRequest("PUT", ts.URL, infiniteReader{}) res, err := tr.RoundTrip(req) if err != nil { t.Fatal(err) } if res.StatusCode != http.StatusOK { t.Fatalf("Response code = %v; want %v", res.StatusCode, http.StatusOK) } } // Verify transport doesn't crash when receiving bogus response lacking a :status header. // Issue 22880. func TestTransportHandlesInvalidStatuslessResponse(t testing.T) { tc := newTestClientConn(t) tc.greet() req, _ := http.NewRequest("GET", "https://dummy.tld/", nil) rt := tc.roundTrip(req) tc.wantFrameType(FrameHeaders) tc.writeHeaders(HeadersFrameParam{ StreamID: rt.streamID(), EndHeaders: true, EndStream: false, // we'll send some DATA to try to crash the transport BlockFragment: tc.makeHeaderBlockFragment( "content-type", "text/html", // no :status header ), }) tc.writeData(rt.streamID(), true, []byte("payload")) } func BenchmarkClientRequestHeaders(b testing.B) { b.Run(" 0 Headers", func(b testing.B) { benchSimpleRoundTrip(b, 0, 0) }) b.Run(" 10 Headers", func(b testing.B) { benchSimpleRoundTrip(b, 10, 0) }) b.Run(" 100 Headers", func(b testing.B) { benchSimpleRoundTrip(b, 100, 0) }) b.Run("1000 Headers", func(b testing.B) { benchSimpleRoundTrip(b, 1000, 0) }) } func BenchmarkClientResponseHeaders(b testing.B) { b.Run(" 0 Headers", func(b testing.B) { benchSimpleRoundTrip(b, 0, 0) }) b.Run(" 10 Headers", func(b testing.B) { benchSimpleRoundTrip(b, 0, 10) }) b.Run(" 100 Headers", func(b testing.B) { benchSimpleRoundTrip(b, 0, 100) }) b.Run("1000 Headers", func(b testing.B) { benchSimpleRoundTrip(b, 0, 1000) }) } func BenchmarkDownloadFrameSize(b testing.B) { b.Run(" 16k Frame", func(b testing.B) { benchLargeDownloadRoundTrip(b, 161024) }) b.Run(" 64k Frame", func(b testing.B) { benchLargeDownloadRoundTrip(b, 641024) }) b.Run("128k Frame", func(b testing.B) { benchLargeDownloadRoundTrip(b, 1281024) }) b.Run("256k Frame", func(b testing.B) { benchLargeDownloadRoundTrip(b, 2561024) }) b.Run("512k Frame", func(b testing.B) { benchLargeDownloadRoundTrip(b, 5121024) }) } func benchLargeDownloadRoundTrip(b testing.B, frameSize uint32) { disableGoroutineTracking(b) const transferSize = 1024 * 1024 * 1024 // must be multiple of 1M b.ReportAllocs() ts := newTestServer(b, func(w http.ResponseWriter, r http.Request) { // test 1GB transfer w.Header().Set("Content-Length", strconv.Itoa(transferSize)) w.Header().Set("Content-Transfer-Encoding", "binary") var data [1024 1024]byte for i := 0; i < transferSize/(10241024); i++ { w.Write(data[:]) } }, optQuiet, ) tr := &Transport{TLSClientConfig: tlsConfigInsecure, MaxReadFrameSize: frameSize} defer tr.CloseIdleConnections() req, err := http.NewRequest("GET", ts.URL, nil) if err != nil { b.Fatal(err) } b.N = 3 b.SetBytes(transferSize) b.ResetTimer() for i := 0; i < b.N; i++ { res, err := tr.RoundTrip(req) if err != nil { if res != nil { res.Body.Close() } b.Fatalf("RoundTrip err = %v; want nil", err) } data, _ := io.ReadAll(res.Body) if len(data) != transferSize { b.Fatalf("Response length invalid") } res.Body.Close() if res.StatusCode != http.StatusOK { b.Fatalf("Response code = %v; want %v", res.StatusCode, http.StatusOK) } } } func activeStreams(cc ClientConn) int { count := 0 cc.mu.Lock() defer cc.mu.Unlock() for _, cs := range cc.streams { select { case <-cs.abort: default: count++ } } return count } type closeMode int const ( closeAtHeaders closeMode = iota closeAtBody shutdown shutdownCancel ) // See golang.org/issue/17292 func testClientConnClose(t testing.T, closeMode closeMode) { clientDone := make(chan struct{}) defer close(clientDone) handlerDone := make(chan struct{}) closeDone := make(chan struct{}) beforeHeader := func() {} bodyWrite := func(w http.ResponseWriter) {} ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { defer close(handlerDone) beforeHeader() w.WriteHeader(http.StatusOK) w.(http.Flusher).Flush() bodyWrite(w) select { case <-w.(http.CloseNotifier).CloseNotify(): // client closed connection before completion if closeMode == shutdown \|\| closeMode == shutdownCancel { t.Error("expected request to complete") } case <-clientDone: if closeMode == closeAtHeaders \|\| closeMode == closeAtBody { t.Error("expected connection closed by client") } } }) tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() ctx := context.Background() cc, err := tr.dialClientConn(ctx, ts.Listener.Addr().String(), false) req, err := http.NewRequest("GET", ts.URL, nil) if err != nil { t.Fatal(err) } if closeMode == closeAtHeaders { beforeHeader = func() { if err := cc.Close(); err != nil { t.Error(err) } close(closeDone) } } var sendBody chan struct{} if closeMode == closeAtBody { sendBody = make(chan struct{}) bodyWrite = func(w http.ResponseWriter) { <-sendBody b := make([]byte, 32) w.Write(b) w.(http.Flusher).Flush() if err := cc.Close(); err != nil { t.Errorf("unexpected ClientConn close error: %v", err) } close(closeDone) w.Write(b) w.(http.Flusher).Flush() } } res, err := cc.RoundTrip(req) if res != nil { defer res.Body.Close() } if closeMode == closeAtHeaders { got := fmt.Sprint(err) want := "http2: client connection force closed via ClientConn.Close" if got != want { t.Fatalf("RoundTrip error = %v, want %v", got, want) } } else { if err != nil { t.Fatalf("RoundTrip: %v", err) } if got, want := activeStreams(cc), 1; got != want { t.Errorf("got %d active streams, want %d", got, want) } } switch closeMode { case shutdownCancel: if err = cc.Shutdown(canceledCtx); err != context.Canceled { t.Errorf("got %v, want %v", err, context.Canceled) } if cc.closing == false { t.Error("expected closing to be true") } if cc.CanTakeNewRequest() == true { t.Error("CanTakeNewRequest to return false") } if v, want := len(cc.streams), 1; v != want { t.Errorf("expected %d active streams, got %d", want, v) } clientDone <- struct{}{} <-handlerDone case shutdown: wait := make(chan struct{}) shutdownEnterWaitStateHook = func() { close(wait) shutdownEnterWaitStateHook = func() {} } defer func() { shutdownEnterWaitStateHook = func() {} }() shutdown := make(chan struct{}, 1) go func() { if err = cc.Shutdown(context.Background()); err != nil { t.Error(err) } close(shutdown) }() // Let the shutdown to enter wait state <-wait cc.mu.Lock() if cc.closing == false { t.Error("expected closing to be true") } cc.mu.Unlock() if cc.CanTakeNewRequest() == true { t.Error("CanTakeNewRequest to return false") } if got, want := activeStreams(cc), 1; got != want { t.Errorf("got %d active streams, want %d", got, want) } // Let the active request finish clientDone <- struct{}{} // Wait for the shutdown to end select { case <-shutdown: case <-time.After(2 * time.Second): t.Fatal("expected server connection to close") } case closeAtHeaders, closeAtBody: if closeMode == closeAtBody { go close(sendBody) if _, err := io.Copy(io.Discard, res.Body); err == nil { t.Error("expected a Copy error, got nil") } } <-closeDone if got, want := activeStreams(cc), 0; got != want { t.Errorf("got %d active streams, want %d", got, want) } // wait for server to get the connection close notice select { case <-handlerDone: case <-time.After(2 * time.Second): t.Fatal("expected server connection to close") } } } // The client closes the connection just after the server got the client's HEADERS // frame, but before the server sends its HEADERS response back. The expected // result is an error on RoundTrip explaining the client closed the connection. func TestClientConnCloseAtHeaders(t testing.T) { testClientConnClose(t, closeAtHeaders) } // The client closes the connection between two server's response DATA frames. // The expected behavior is a response body io read error on the client. func TestClientConnCloseAtBody(t testing.T) { testClientConnClose(t, closeAtBody) } // The client sends a GOAWAY frame before the server finished processing a request. // We expect the connection not to close until the request is completed. func TestClientConnShutdown(t testing.T) { testClientConnClose(t, shutdown) } // The client sends a GOAWAY frame before the server finishes processing a request, // but cancels the passed context before the request is completed. The expected // behavior is the client closing the connection after the context is canceled. func TestClientConnShutdownCancel(t testing.T) { testClientConnClose(t, shutdownCancel) } // Issue 25009: use Request.GetBody if present, even if it seems like // we might not need it. Apparently something else can still read from // the original request body. Data race? In any case, rewinding // unconditionally on retry is a nicer model anyway and should // simplify code in the future (after the Go 1.11 freeze) func TestTransportUsesGetBodyWhenPresent(t testing.T) { calls := 0 someBody := func() io.ReadCloser { return struct{ io.ReadCloser }{io.NopCloser(bytes.NewReader(nil))} } req := &http.Request{ Body: someBody(), GetBody: func() (io.ReadCloser, error) { calls++ return someBody(), nil }, } req2, err := shouldRetryRequest(req, errClientConnUnusable) if err != nil { t.Fatal(err) } if calls != 1 { t.Errorf("Calls = %d; want 1", calls) } if req2 == req { t.Error("req2 changed") } if req2 == nil { t.Fatal("req2 is nil") } if req2.Body == nil { t.Fatal("req2.Body is nil") } if req2.GetBody == nil { t.Fatal("req2.GetBody is nil") } if req2.Body == req.Body { t.Error("req2.Body unchanged") } } // Issue 22891: verify that the "https" altproto we register with net/http // is a certain type: a struct with one field with our http2.Transport in it. func TestNoDialH2RoundTripperType(t testing.T) { t1 := new(http.Transport) t2 := new(Transport) rt := noDialH2RoundTripper{t2} if err := registerHTTPSProtocol(t1, rt); err != nil { t.Fatal(err) } rv := reflect.ValueOf(rt) if rv.Type().Kind() != reflect.Struct { t.Fatalf("kind = %v; net/http expects struct", rv.Type().Kind()) } if n := rv.Type().NumField(); n != 1 { t.Fatalf("fields = %d; net/http expects 1", n) } v := rv.Field(0) if _, ok := v.Interface().(Transport); !ok { t.Fatalf("wrong kind %T; want Transport", v.Interface()) } } type errReader struct { body []byte err error } func (r errReader) Read(p []byte) (int, error) { if len(r.body) > 0 { n := copy(p, r.body) r.body = r.body[n:] return n, nil } return 0, r.err } func testTransportBodyReadError(t testing.T, body []byte) { tc := newTestClientConn(t) tc.greet() bodyReadError := errors.New("body read error") b := tc.newRequestBody() b.Write(body) b.closeWithError(bodyReadError) req, _ := http.NewRequest("PUT", "https://dummy.tld/", b) rt := tc.roundTrip(req) tc.wantFrameType(FrameHeaders) var receivedBody []byte readFrames: for { switch f := tc.readFrame().(type) { case DataFrame: receivedBody = append(receivedBody, f.Data()...) case RSTStreamFrame: break readFrames default: t.Fatalf("unexpected frame: %v", f) case nil: t.Fatalf("transport is idle, want RST_STREAM") } } if !bytes.Equal(receivedBody, body) { t.Fatalf("body: %q; expected %q", receivedBody, body) } if err := rt.err(); err != bodyReadError { t.Fatalf("err = %v; want %v", err, bodyReadError) } if got := activeStreams(tc.cc); got != 0 { t.Fatalf("active streams count: %v; want 0", got) } } func TestTransportBodyReadError_Immediately(t testing.T) { testTransportBodyReadError(t, nil) } func TestTransportBodyReadError_Some(t testing.T) { testTransportBodyReadError(t, []byte("123")) } // Issue 32254: verify that the client sends END_STREAM flag eagerly with the last // (or in this test-case the only one) request body data frame, and does not send // extra zero-len data frames. func TestTransportBodyEagerEndStream(t testing.T) { const reqBody = "some request body" const resBody = "some response body" tc := newTestClientConn(t) tc.greet() body := strings.NewReader(reqBody) req, _ := http.NewRequest("PUT", "https://dummy.tld/", body) tc.roundTrip(req) tc.wantFrameType(FrameHeaders) f := readFrame[DataFrame](t, tc) if !f.StreamEnded() { t.Fatalf("data frame without END_STREAM %v", f) } } type chunkReader struct { chunks [][]byte } func (r chunkReader) Read(p []byte) (int, error) { if len(r.chunks) > 0 { n := copy(p, r.chunks[0]) r.chunks = r.chunks[1:] return n, nil } panic("shouldn't read this many times") } // Issue 32254: if the request body is larger than the specified // content length, the client should refuse to send the extra part // and abort the stream. // // In _len3 case, the first Read() matches the expected content length // but the second read returns more data. // // In _len2 case, the first Read() exceeds the expected content length. func TestTransportBodyLargerThanSpecifiedContentLength_len3(t testing.T) { body := &chunkReader{[][]byte{ []byte("123"), []byte("456"), }} testTransportBodyLargerThanSpecifiedContentLength(t, body, 3) } func TestTransportBodyLargerThanSpecifiedContentLength_len2(t testing.T) { body := &chunkReader{[][]byte{ []byte("123"), }} testTransportBodyLargerThanSpecifiedContentLength(t, body, 2) } func testTransportBodyLargerThanSpecifiedContentLength(t testing.T, body chunkReader, contentLen int64) { ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { r.Body.Read(make([]byte, 6)) }) tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() req, _ := http.NewRequest("POST", ts.URL, body) req.ContentLength = contentLen _, err := tr.RoundTrip(req) if err != errReqBodyTooLong { t.Fatalf("expected %v, got %v", errReqBodyTooLong, err) } } func TestClientConnTooIdle(t testing.T) { tests := []struct { cc func() ClientConn want bool }{ { func() ClientConn { return &ClientConn{idleTimeout: 5 * time.Second, lastIdle: time.Now().Add(-10 * time.Second)} }, true, }, { func() ClientConn { return &ClientConn{idleTimeout: 5 time.Second, lastIdle: time.Time{}} }, false, }, { func() ClientConn { return &ClientConn{idleTimeout: 60 time.Second, lastIdle: time.Now().Add(-10 * time.Second)} }, false, }, { func() ClientConn { return &ClientConn{idleTimeout: 0, lastIdle: time.Now().Add(-10 time.Second)} }, false, }, } for i, tt := range tests { got := tt.cc().tooIdleLocked() if got != tt.want { t.Errorf("%d. got %v; want %v", i, got, tt.want) } } } type fakeConnErr struct { net.Conn writeErr error closed bool } func (fce fakeConnErr) Write(b []byte) (n int, err error) { return 0, fce.writeErr } func (fce fakeConnErr) Close() error { fce.closed = true return nil } // issue 39337: close the connection on a failed write func TestTransportNewClientConnCloseOnWriteError(t testing.T) { tr := &Transport{} writeErr := errors.New("write error") fakeConn := &fakeConnErr{writeErr: writeErr} _, err := tr.NewClientConn(fakeConn) if err != writeErr { t.Fatalf("expected %v, got %v", writeErr, err) } if !fakeConn.closed { t.Error("expected closed conn") } } func TestTransportRoundtripCloseOnWriteError(t testing.T) { req, err := http.NewRequest("GET", "https://dummy.tld/", nil) if err != nil { t.Fatal(err) } ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) {}) tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() ctx := context.Background() cc, err := tr.dialClientConn(ctx, ts.Listener.Addr().String(), false) if err != nil { t.Fatal(err) } writeErr := errors.New("write error") cc.wmu.Lock() cc.werr = writeErr cc.wmu.Unlock() _, err = cc.RoundTrip(req) if err != writeErr { t.Fatalf("expected %v, got %v", writeErr, err) } cc.mu.Lock() closed := cc.closed cc.mu.Unlock() if !closed { t.Fatal("expected closed") } } // Issue 31192: A failed request may be retried if the body has not been read // already. If the request body has started to be sent, one must wait until it // is completed. func TestTransportBodyRewindRace(t testing.T) { ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { w.Header().Set("Connection", "close") w.WriteHeader(http.StatusOK) return }) tr := &http.Transport{ TLSClientConfig: tlsConfigInsecure, MaxConnsPerHost: 1, } err := ConfigureTransport(tr) if err != nil { t.Fatal(err) } client := &http.Client{ Transport: tr, } const clients = 50 var wg sync.WaitGroup wg.Add(clients) for i := 0; i < clients; i++ { req, err := http.NewRequest("POST", ts.URL, bytes.NewBufferString("abcdef")) if err != nil { t.Fatalf("unexpect new request error: %v", err) } go func() { defer wg.Done() res, err := client.Do(req) if err == nil { res.Body.Close() } }() } wg.Wait() } // Issue 42498: A request with a body will never be sent if the stream is // reset prior to sending any data. func TestTransportServerResetStreamAtHeaders(t testing.T) { ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { w.WriteHeader(http.StatusUnauthorized) return }) tr := &http.Transport{ TLSClientConfig: tlsConfigInsecure, MaxConnsPerHost: 1, ExpectContinueTimeout: 10 time.Second, } err := ConfigureTransport(tr) if err != nil { t.Fatal(err) } client := &http.Client{ Transport: tr, } req, err := http.NewRequest("POST", ts.URL, errorReader{io.EOF}) if err != nil { t.Fatalf("unexpect new request error: %v", err) } req.ContentLength = 0 // so transport is tempted to sniff it req.Header.Set("Expect", "100-continue") res, err := client.Do(req) if err != nil { t.Fatal(err) } res.Body.Close() } type trackingReader struct { rdr io.Reader wasRead uint32 } func (tr trackingReader) Read(p []byte) (int, error) { atomic.StoreUint32(&tr.wasRead, 1) return tr.rdr.Read(p) } func (tr trackingReader) WasRead() bool { return atomic.LoadUint32(&tr.wasRead) != 0 } func TestTransportExpectContinue(t testing.T) { ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { switch r.URL.Path { case "/reject": w.WriteHeader(403) default: io.Copy(io.Discard, r.Body) } }) tr := &http.Transport{ TLSClientConfig: tlsConfigInsecure, MaxConnsPerHost: 1, ExpectContinueTimeout: 10 * time.Second, } err := ConfigureTransport(tr) if err != nil { t.Fatal(err) } client := &http.Client{ Transport: tr, } testCases := []struct { Name string Path string Body trackingReader ExpectedCode int ShouldRead bool }{ { Name: "read-all", Path: "/", Body: &trackingReader{rdr: strings.NewReader("hello")}, ExpectedCode: 200, ShouldRead: true, }, { Name: "reject", Path: "/reject", Body: &trackingReader{rdr: strings.NewReader("hello")}, ExpectedCode: 403, ShouldRead: false, }, } for _, tc := range testCases { t.Run(tc.Name, func(t testing.T) { startTime := time.Now() req, err := http.NewRequest("POST", ts.URL+tc.Path, tc.Body) if err != nil { t.Fatal(err) } req.Header.Set("Expect", "100-continue") res, err := client.Do(req) if err != nil { t.Fatal(err) } res.Body.Close() if delta := time.Since(startTime); delta >= tr.ExpectContinueTimeout { t.Error("Request didn't finish before expect continue timeout") } if res.StatusCode != tc.ExpectedCode { t.Errorf("Unexpected status code, got %d, expected %d", res.StatusCode, tc.ExpectedCode) } if tc.Body.WasRead() != tc.ShouldRead { t.Errorf("Unexpected read status, got %v, expected %v", tc.Body.WasRead(), tc.ShouldRead) } }) } } type closeChecker struct { io.ReadCloser closed chan struct{} } func newCloseChecker(r io.ReadCloser) closeChecker { return &closeChecker{r, make(chan struct{})} } func newStaticCloseChecker(body string) closeChecker { return newCloseChecker(io.NopCloser(strings.NewReader("body"))) } func (rc closeChecker) Read(b []byte) (n int, err error) { select { default: case <-rc.closed: // TODO(dneil): Consider restructuring the request write to avoid reading // from the request body after closing it, and check for read-after-close here. // Currently, abortRequestBodyWrite races with writeRequestBody. return 0, errors.New("read after Body.Close") } return rc.ReadCloser.Read(b) } func (rc closeChecker) Close() error { close(rc.closed) return rc.ReadCloser.Close() } func (rc closeChecker) isClosed() error { // The RoundTrip contract says that it will close the request body, // but that it may do so in a separate goroutine. Wait a reasonable // amount of time before concluding that the body isn't being closed. timeout := time.Duration(10 time.Second) select { case <-rc.closed: case <-time.After(timeout): return fmt.Errorf("body not closed after %v", timeout) } return nil } // A blockingWriteConn is a net.Conn that blocks in Write after some number of bytes are written. type blockingWriteConn struct { net.Conn writeOnce sync.Once writec chan struct{} // closed after the write limit is reached unblockc chan struct{} // closed to unblock writes count, limit int } func newBlockingWriteConn(conn net.Conn, limit int) blockingWriteConn { return &blockingWriteConn{ Conn: conn, limit: limit, writec: make(chan struct{}), unblockc: make(chan struct{}), } } // wait waits until the conn blocks writing the limit+1st byte. func (c blockingWriteConn) wait() { <-c.writec } // unblock unblocks writes to the conn. func (c blockingWriteConn) unblock() { close(c.unblockc) } func (c blockingWriteConn) Write(b []byte) (n int, err error) { if c.count+len(b) > c.limit { c.writeOnce.Do(func() { close(c.writec) }) <-c.unblockc } n, err = c.Conn.Write(b) c.count += n return n, err } // Write several requests to a ClientConn at the same time, looking for race conditions. // See golang.org/issue/48340 func TestTransportFrameBufferReuse(t testing.T) { filler := hex.EncodeToString([]byte(randString(2048))) ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { if got, want := r.Header.Get("Big"), filler; got != want { t.Errorf(`r.Header.Get("Big") = %q, want %q`, got, want) } b, err := io.ReadAll(r.Body) if err != nil { t.Errorf("error reading request body: %v", err) } if got, want := string(b), filler; got != want { t.Errorf("request body = %q, want %q", got, want) } if got, want := r.Trailer.Get("Big"), filler; got != want { t.Errorf(`r.Trailer.Get("Big") = %q, want %q`, got, want) } }) tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() var wg sync.WaitGroup defer wg.Wait() for i := 0; i < 10; i++ { wg.Add(1) go func() { defer wg.Done() req, err := http.NewRequest("POST", ts.URL, strings.NewReader(filler)) if err != nil { t.Error(err) return } req.Header.Set("Big", filler) req.Trailer = make(http.Header) req.Trailer.Set("Big", filler) res, err := tr.RoundTrip(req) if err != nil { t.Error(err) return } if got, want := res.StatusCode, 200; got != want { t.Errorf("StatusCode = %v; want %v", got, want) } if res != nil && res.Body != nil { res.Body.Close() } }() } } // Ensure that a request blocking while being written to the underlying net.Conn doesn't // block access to the ClientConn pool. Test requests blocking while writing headers, the body, // and trailers. // See golang.org/issue/32388 func TestTransportBlockingRequestWrite(t testing.T) { filler := hex.EncodeToString([]byte(randString(2048))) for _, test := range []struct { name string req func(url string) (http.Request, error) }{{ name: "headers", req: func(url string) (http.Request, error) { req, err := http.NewRequest("POST", url, nil) if err != nil { return nil, err } req.Header.Set("Big", filler) return req, err }, }, { name: "body", req: func(url string) (http.Request, error) { req, err := http.NewRequest("POST", url, strings.NewReader(filler)) if err != nil { return nil, err } return req, err }, }, { name: "trailer", req: func(url string) (http.Request, error) { req, err := http.NewRequest("POST", url, strings.NewReader("body")) if err != nil { return nil, err } req.Trailer = make(http.Header) req.Trailer.Set("Big", filler) return req, err }, }} { test := test t.Run(test.name, func(t testing.T) { ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { if v := r.Header.Get("Big"); v != "" && v != filler { t.Errorf("request header mismatch") } if v, _ := io.ReadAll(r.Body); len(v) != 0 && string(v) != "body" && string(v) != filler { t.Errorf("request body mismatch\ngot: %q\nwant: %q", string(v), filler) } if v := r.Trailer.Get("Big"); v != "" && v != filler { t.Errorf("request trailer mismatch\ngot: %q\nwant: %q", string(v), filler) } }, func(s Server) { s.MaxConcurrentStreams = 1 }) // This Transport creates connections that block on writes after 1024 bytes. connc := make(chan blockingWriteConn, 1) connCount := 0 tr := &Transport{ TLSClientConfig: tlsConfigInsecure, DialTLS: func(network, addr string, cfg tls.Config) (net.Conn, error) { connCount++ c, err := tls.Dial(network, addr, cfg) wc := newBlockingWriteConn(c, 1024) select { case connc <- wc: default: } return wc, err }, } defer tr.CloseIdleConnections() // Request 1: A small request to ensure we read the server MaxConcurrentStreams. { req, err := http.NewRequest("POST", ts.URL, nil) if err != nil { t.Fatal(err) } res, err := tr.RoundTrip(req) if err != nil { t.Fatal(err) } if got, want := res.StatusCode, 200; got != want { t.Errorf("StatusCode = %v; want %v", got, want) } if res != nil && res.Body != nil { res.Body.Close() } } // Request 2: A large request that blocks while being written. reqc := make(chan struct{}) go func() { defer close(reqc) req, err := test.req(ts.URL) if err != nil { t.Error(err) return } res, _ := tr.RoundTrip(req) if res != nil && res.Body != nil { res.Body.Close() } }() conn := <-connc conn.wait() // wait for the request to block // Request 3: A small request that is sent on a new connection, since request 2 // is hogging the only available stream on the previous connection. { req, err := http.NewRequest("POST", ts.URL, nil) if err != nil { t.Fatal(err) } res, err := tr.RoundTrip(req) if err != nil { t.Fatal(err) } if got, want := res.StatusCode, 200; got != want { t.Errorf("StatusCode = %v; want %v", got, want) } if res != nil && res.Body != nil { res.Body.Close() } } // Request 2 should still be blocking at this point. select { case <-reqc: t.Errorf("request 2 unexpectedly completed") default: } conn.unblock() <-reqc if connCount != 2 { t.Errorf("created %v connections, want 1", connCount) } }) } } func TestTransportCloseRequestBody(t testing.T) { var statusCode int ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { w.WriteHeader(statusCode) }) tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() ctx := context.Background() cc, err := tr.dialClientConn(ctx, ts.Listener.Addr().String(), false) if err != nil { t.Fatal(err) } for _, status := range []int{200, 401} { t.Run(fmt.Sprintf("status=%d", status), func(t testing.T) { statusCode = status pr, pw := io.Pipe() body := newCloseChecker(pr) req, err := http.NewRequest("PUT", "https://dummy.tld/", body) if err != nil { t.Fatal(err) } res, err := cc.RoundTrip(req) if err != nil { t.Fatal(err) } res.Body.Close() pw.Close() if err := body.isClosed(); err != nil { t.Fatal(err) } }) } } func TestTransportRetriesOnStreamProtocolError(t testing.T) { // This test verifies that // - receiving a protocol error on a connection does not interfere with // other requests in flight on that connection; // - the connection is not reused for further requests; and // - the failed request is retried on a new connecection. tt := newTestTransport(t) // Start two requests. The first is a long request // that will finish after the second. The second one // will result in the protocol error. // Request #1: The long request. req1, _ := http.NewRequest("GET", "https://dummy.tld/", nil) rt1 := tt.roundTrip(req1) tc1 := tt.getConn() tc1.wantFrameType(FrameSettings) tc1.wantFrameType(FrameWindowUpdate) tc1.wantHeaders(wantHeader{ streamID: 1, endStream: true, }) tc1.writeSettings() tc1.wantFrameType(FrameSettings) // settings ACK // Request #2(a): The short request. req2, _ := http.NewRequest("GET", "https://dummy.tld/", nil) rt2 := tt.roundTrip(req2) tc1.wantHeaders(wantHeader{ streamID: 3, endStream: true, }) // Request #2(a) fails with ErrCodeProtocol. tc1.writeRSTStream(3, ErrCodeProtocol) if rt1.done() { t.Fatalf("After protocol error on RoundTrip #2, RoundTrip #1 is done; want still in progress") } if rt2.done() { t.Fatalf("After protocol error on RoundTrip #2, RoundTrip #2 is done; want still in progress") } // Request #2(b): The short request is retried on a new connection. tc2 := tt.getConn() tc2.wantFrameType(FrameSettings) tc2.wantFrameType(FrameWindowUpdate) tc2.wantHeaders(wantHeader{ streamID: 1, endStream: true, }) tc2.writeSettings() tc2.wantFrameType(FrameSettings) // settings ACK // Request #2(b) succeeds. tc2.writeHeaders(HeadersFrameParam{ StreamID: 1, EndHeaders: true, EndStream: true, BlockFragment: tc1.makeHeaderBlockFragment( ":status", "201", ), }) rt2.wantStatus(201) // Request #1 succeeds. tc1.writeHeaders(HeadersFrameParam{ StreamID: 1, EndHeaders: true, EndStream: true, BlockFragment: tc1.makeHeaderBlockFragment( ":status", "200", ), }) rt1.wantStatus(200) } func TestClientConnReservations(t testing.T) { tc := newTestClientConn(t) tc.greet( Setting{ID: SettingMaxConcurrentStreams, Val: initialMaxConcurrentStreams}, ) doRoundTrip := func() { req, _ := http.NewRequest("GET", "https://dummy.tld/", nil) rt := tc.roundTrip(req) tc.wantFrameType(FrameHeaders) tc.writeHeaders(HeadersFrameParam{ StreamID: rt.streamID(), EndHeaders: true, EndStream: true, BlockFragment: tc.makeHeaderBlockFragment( ":status", "200", ), }) rt.wantStatus(200) } n := 0 for n <= initialMaxConcurrentStreams && tc.cc.ReserveNewRequest() { n++ } if n != initialMaxConcurrentStreams { t.Errorf("did %v reservations; want %v", n, initialMaxConcurrentStreams) } doRoundTrip() n2 := 0 for n2 <= 5 && tc.cc.ReserveNewRequest() { n2++ } if n2 != 1 { t.Fatalf("after one RoundTrip, did %v reservations; want 1", n2) } // Use up all the reservations for i := 0; i < n; i++ { doRoundTrip() } n2 = 0 for n2 <= initialMaxConcurrentStreams && tc.cc.ReserveNewRequest() { n2++ } if n2 != n { t.Errorf("after reset, reservations = %v; want %v", n2, n) } } func TestTransportTimeoutServerHangs(t testing.T) { tc := newTestClientConn(t) tc.greet() ctx, cancel := context.WithCancel(context.Background()) req, _ := http.NewRequestWithContext(ctx, "PUT", "https://dummy.tld/", nil) rt := tc.roundTrip(req) tc.wantFrameType(FrameHeaders) tc.advance(5 * time.Second) if f := tc.readFrame(); f != nil { t.Fatalf("unexpected frame: %v", f) } if rt.done() { t.Fatalf("after 5 seconds with no response, RoundTrip unexpectedly returned") } cancel() tc.sync() if rt.err() != context.Canceled { t.Fatalf("RoundTrip error: %v; want context.Canceled", rt.err()) } } func TestTransportContentLengthWithoutBody(t testing.T) { contentLength := "" ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { w.Header().Set("Content-Length", contentLength) }) tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() for _, test := range []struct { name string contentLength string wantBody string wantErr error wantContentLength int64 }{ { name: "non-zero content length", contentLength: "42", wantErr: io.ErrUnexpectedEOF, wantContentLength: 42, }, { name: "zero content length", contentLength: "0", wantErr: nil, wantContentLength: 0, }, } { t.Run(test.name, func(t testing.T) { contentLength = test.contentLength req, _ := http.NewRequest("GET", ts.URL, nil) res, err := tr.RoundTrip(req) if err != nil { t.Fatal(err) } defer res.Body.Close() body, err := io.ReadAll(res.Body) if err != test.wantErr { t.Errorf("Expected error %v, got: %v", test.wantErr, err) } if len(body) > 0 { t.Errorf("Expected empty body, got: %v", body) } if res.ContentLength != test.wantContentLength { t.Errorf("Expected content length %d, got: %d", test.wantContentLength, res.ContentLength) } }) } } func TestTransportCloseResponseBodyWhileRequestBodyHangs(t testing.T) { ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { w.WriteHeader(200) w.(http.Flusher).Flush() io.Copy(io.Discard, r.Body) }) tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() pr, pw := net.Pipe() req, err := http.NewRequest("GET", ts.URL, pr) if err != nil { t.Fatal(err) } res, err := tr.RoundTrip(req) if err != nil { t.Fatal(err) } // Closing the Response's Body interrupts the blocked body read. res.Body.Close() pw.Close() } func TestTransport300ResponseBody(t testing.T) { reqc := make(chan struct{}) body := []byte("response body") ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { w.WriteHeader(300) w.(http.Flusher).Flush() <-reqc w.Write(body) }) tr := &Transport{TLSClientConfig: tlsConfigInsecure} defer tr.CloseIdleConnections() pr, pw := net.Pipe() req, err := http.NewRequest("GET", ts.URL, pr) if err != nil { t.Fatal(err) } res, err := tr.RoundTrip(req) if err != nil { t.Fatal(err) } close(reqc) got, err := io.ReadAll(res.Body) if err != nil { t.Fatalf("error reading response body: %v", err) } if !bytes.Equal(got, body) { t.Errorf("got response body %q, want %q", string(got), string(body)) } res.Body.Close() pw.Close() } func TestTransportWriteByteTimeout(t testing.T) { ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) {}, ) tr := &Transport{ TLSClientConfig: tlsConfigInsecure, DialTLS: func(network, addr string, cfg tls.Config) (net.Conn, error) { _, c := net.Pipe() return c, nil }, WriteByteTimeout: 1 * time.Millisecond, } defer tr.CloseIdleConnections() c := &http.Client{Transport: tr} _, err := c.Get(ts.URL) if !errors.Is(err, os.ErrDeadlineExceeded) { t.Fatalf("Get on unresponsive connection: got %q; want ErrDeadlineExceeded", err) } } type slowWriteConn struct { net.Conn hasWriteDeadline bool } func (c slowWriteConn) SetWriteDeadline(t time.Time) error { c.hasWriteDeadline = !t.IsZero() return nil } func (c slowWriteConn) Write(b []byte) (n int, err error) { if c.hasWriteDeadline && len(b) > 1 { n, err = c.Conn.Write(b[:1]) if err != nil { return n, err } return n, fmt.Errorf("slow write: %w", os.ErrDeadlineExceeded) } return c.Conn.Write(b) } func TestTransportSlowWrites(t testing.T) { ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) {}, ) tr := &Transport{ TLSClientConfig: tlsConfigInsecure, DialTLS: func(network, addr string, cfg tls.Config) (net.Conn, error) { cfg.InsecureSkipVerify = true c, err := tls.Dial(network, addr, cfg) return &slowWriteConn{Conn: c}, err }, WriteByteTimeout: 1 time.Millisecond, } defer tr.CloseIdleConnections() c := &http.Client{Transport: tr} const bodySize = 1 << 20 resp, err := c.Post(ts.URL, "text/foo", io.LimitReader(neverEnding('A'), bodySize)) if err != nil { t.Fatal(err) } resp.Body.Close() } func TestTransportClosesConnAfterGoAwayNoStreams(t testing.T) { testTransportClosesConnAfterGoAway(t, 0) } func TestTransportClosesConnAfterGoAwayLastStream(t testing.T) { testTransportClosesConnAfterGoAway(t, 1) } // testTransportClosesConnAfterGoAway verifies that the transport // closes a connection after reading a GOAWAY from it. // // lastStream is the last stream ID in the GOAWAY frame. // When 0, the transport (unsuccessfully) retries the request (stream 1); // when 1, the transport reads the response after receiving the GOAWAY. func testTransportClosesConnAfterGoAway(t testing.T, lastStream uint32) { tc := newTestClientConn(t) tc.greet() req, _ := http.NewRequest("GET", "https://dummy.tld/", nil) rt := tc.roundTrip(req) tc.wantFrameType(FrameHeaders) tc.writeGoAway(lastStream, ErrCodeNo, nil) if lastStream > 0 { // Send a valid response to first request. tc.writeHeaders(HeadersFrameParam{ StreamID: rt.streamID(), EndHeaders: true, EndStream: true, BlockFragment: tc.makeHeaderBlockFragment( ":status", "200", ), }) } tc.closeWrite() err := rt.err() if gotErr, wantErr := err != nil, lastStream == 0; gotErr != wantErr { t.Errorf("RoundTrip got error %v (want error: %v)", err, wantErr) } if !tc.isClosed() { t.Errorf("ClientConn did not close its net.Conn, expected it to") } } type slowCloser struct { closing chan struct{} closed chan struct{} } func (r slowCloser) Read([]byte) (int, error) { return 0, io.EOF } func (r slowCloser) Close() error { close(r.closing) <-r.closed return nil } func TestTransportSlowClose(t testing.T) { ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { }) client := ts.Client() body := &slowCloser{ closing: make(chan struct{}), closed: make(chan struct{}), } reqc := make(chan struct{}) go func() { defer close(reqc) res, err := client.Post(ts.URL, "text/plain", body) if err != nil { t.Error(err) } res.Body.Close() }() defer func() { close(body.closed) <-reqc // wait for POST request to finish }() <-body.closing // wait for POST request to call body.Close // This GET request should not be blocked by the in-progress POST. res, err := client.Get(ts.URL) if err != nil { t.Fatal(err) } res.Body.Close() } func TestTransportDialTLSContext(t testing.T) { blockCh := make(chan struct{}) serverTLSConfigFunc := func(ts httptest.Server) { ts.Config.TLSConfig = &tls.Config{ // Triggers the server to request the clients certificate // during TLS handshake. ClientAuth: tls.RequestClientCert, } } ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) {}, serverTLSConfigFunc, ) tr := &Transport{ TLSClientConfig: &tls.Config{ GetClientCertificate: func(cri tls.CertificateRequestInfo) (tls.Certificate, error) { // Tests that the context provided to `req` is // passed into this function. close(blockCh) <-cri.Context().Done() return nil, cri.Context().Err() }, InsecureSkipVerify: true, }, } defer tr.CloseIdleConnections() req, err := http.NewRequest(http.MethodGet, ts.URL, nil) if err != nil { t.Fatal(err) } ctx, cancel := context.WithCancel(context.Background()) defer cancel() req = req.WithContext(ctx) errCh := make(chan error) go func() { defer close(errCh) res, err := tr.RoundTrip(req) if err != nil { errCh <- err return } res.Body.Close() }() // Wait for GetClientCertificate handler to be called <-blockCh // Cancel the context cancel() // Expect the cancellation error here err = <-errCh if err == nil { t.Fatal("cancelling context during client certificate fetch did not error as expected") return } if !errors.Is(err, context.Canceled) { t.Fatalf("unexpected error returned after cancellation: %v", err) } } // TestDialRaceResumesDial tests that, given two concurrent requests // to the same address, when the first Dial is interrupted because // the first request's context is cancelled, the second request // resumes the dial automatically. func TestDialRaceResumesDial(t testing.T) { blockCh := make(chan struct{}) serverTLSConfigFunc := func(ts httptest.Server) { ts.Config.TLSConfig = &tls.Config{ // Triggers the server to request the clients certificate // during TLS handshake. ClientAuth: tls.RequestClientCert, } } ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) {}, serverTLSConfigFunc, ) tr := &Transport{ TLSClientConfig: &tls.Config{ GetClientCertificate: func(cri tls.CertificateRequestInfo) (tls.Certificate, error) { select { case <-blockCh: // If we already errored, return without error. return &tls.Certificate{}, nil default: } close(blockCh) <-cri.Context().Done() return nil, cri.Context().Err() }, InsecureSkipVerify: true, }, } defer tr.CloseIdleConnections() req, err := http.NewRequest(http.MethodGet, ts.URL, nil) if err != nil { t.Fatal(err) } // Create two requests with independent cancellation. ctx1, cancel1 := context.WithCancel(context.Background()) defer cancel1() req1 := req.WithContext(ctx1) ctx2, cancel2 := context.WithCancel(context.Background()) defer cancel2() req2 := req.WithContext(ctx2) errCh := make(chan error) go func() { res, err := tr.RoundTrip(req1) if err != nil { errCh <- err return } res.Body.Close() }() successCh := make(chan struct{}) go func() { // Don't start request until first request // has initiated the handshake. <-blockCh res, err := tr.RoundTrip(req2) if err != nil { errCh <- err return } res.Body.Close() // Close successCh to indicate that the second request // made it to the server successfully. close(successCh) }() // Wait for GetClientCertificate handler to be called <-blockCh // Cancel the context first cancel1() // Expect the cancellation error here err = <-errCh if err == nil { t.Fatal("cancelling context during client certificate fetch did not error as expected") return } if !errors.Is(err, context.Canceled) { t.Fatalf("unexpected error returned after cancellation: %v", err) } select { case err := <-errCh: t.Fatalf("unexpected second error: %v", err) case <-successCh: } } func TestTransportDataAfter1xxHeader(t testing.T) { // Discard logger output to avoid spamming stderr. log.SetOutput(io.Discard) defer log.SetOutput(os.Stderr) // https://go.dev/issue/65927 - server sends a 1xx response, followed by a DATA frame. tc := newTestClientConn(t) tc.greet() req, _ := http.NewRequest("GET", "https://dummy.tld/", nil) rt := tc.roundTrip(req) tc.wantFrameType(FrameHeaders) tc.writeHeaders(HeadersFrameParam{ StreamID: rt.streamID(), EndHeaders: true, EndStream: false, BlockFragment: tc.makeHeaderBlockFragment( ":status", "100", ), }) tc.writeData(rt.streamID(), true, []byte{0}) err := rt.err() if err, ok := err.(StreamError); !ok \|\| err.Code != ErrCodeProtocol { t.Errorf("RoundTrip error: %v; want ErrCodeProtocol", err) } tc.wantFrameType(FrameRSTStream) } func TestIssue66763Race(t testing.T) { tr := &Transport{ IdleConnTimeout: 1 time.Nanosecond, AllowHTTP: true, // issue 66763 only occurs when AllowHTTP is true } defer tr.CloseIdleConnections() cli, srv := net.Pipe() donec := make(chan struct{}) go func() { // Creating the client conn may succeed or fail, // depending on when the idle timeout happens. // Either way, the idle timeout will close the net.Conn. tr.NewClientConn(cli) close(donec) }() // The client sends its preface and SETTINGS frame, // and then closes its conn after the idle timeout. io.ReadAll(srv) srv.Close() <-donec } // Issue 67671: Sending a Connection: close request on a Transport with AllowHTTP // set caused a the transport to wedge. func TestIssue67671(t testing.T) { ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) {}) tr := &Transport{ TLSClientConfig: tlsConfigInsecure, AllowHTTP: true, } defer tr.CloseIdleConnections() req, _ := http.NewRequest("GET", ts.URL, nil) req.Close = true for i := 0; i < 2; i++ { res, err := tr.RoundTrip(req) if err != nil { t.Fatal(err) } res.Body.Close() } } func TestTransport1xxLimits(t testing.T) { for _, test := range []struct { name string opt any ctxfn func(context.Context) context.Context hcount int limited bool }{{ name: "default", hcount: 10, limited: false, }, { name: "MaxHeaderListSize", opt: func(tr Transport) { tr.MaxHeaderListSize = 10000 }, hcount: 10, limited: true, }, { name: "MaxResponseHeaderBytes", opt: func(tr http.Transport) { tr.MaxResponseHeaderBytes = 10000 }, hcount: 10, limited: true, }, { name: "limit by client trace", ctxfn: func(ctx context.Context) context.Context { count := 0 return httptrace.WithClientTrace(ctx, &httptrace.ClientTrace{ Got1xxResponse: func(code int, header textproto.MIMEHeader) error { count++ if count >= 10 { return errors.New("too many 1xx") } return nil }, }) }, hcount: 10, limited: true, }, { name: "limit disabled by client trace", opt: func(tr Transport) { tr.MaxHeaderListSize = 10000 }, ctxfn: func(ctx context.Context) context.Context { return httptrace.WithClientTrace(ctx, &httptrace.ClientTrace{ Got1xxResponse: func(code int, header textproto.MIMEHeader) error { return nil }, }) }, hcount: 20, limited: false, }} { t.Run(test.name, func(t testing.T) { tc := newTestClientConn(t, test.opt) tc.greet() ctx := context.Background() if test.ctxfn != nil { ctx = test.ctxfn(ctx) } req, _ := http.NewRequestWithContext(ctx, "GET", "https://dummy.tld/", nil) rt := tc.roundTrip(req) tc.wantFrameType(FrameHeaders) for i := 0; i < test.hcount; i++ { if fr, err := tc.fr.ReadFrame(); err != os.ErrDeadlineExceeded { t.Fatalf("after writing %v 1xx headers: read %v, %v; want idle", i, fr, err) } tc.writeHeaders(HeadersFrameParam{ StreamID: rt.streamID(), EndHeaders: true, EndStream: false, BlockFragment: tc.makeHeaderBlockFragment( ":status", "103", "x-field", strings.Repeat("a", 1000), ), }) } if test.limited { tc.wantFrameType(FrameRSTStream) } else { tc.wantIdle() } }) } } func TestTransportSendPingWithReset(t testing.T) { tc := newTestClientConn(t, func(tr Transport) { tr.StrictMaxConcurrentStreams = true }) const maxConcurrent = 3 tc.greet(Setting{SettingMaxConcurrentStreams, maxConcurrent}) // Start several requests. var rts []testRoundTrip for i := 0; i < maxConcurrent+1; i++ { req := must(http.NewRequest("GET", "https://dummy.tld/", nil)) rt := tc.roundTrip(req) if i >= maxConcurrent { tc.wantIdle() continue } tc.wantFrameType(FrameHeaders) tc.writeHeaders(HeadersFrameParam{ StreamID: rt.streamID(), EndHeaders: true, BlockFragment: tc.makeHeaderBlockFragment( ":status", "200", ), }) rt.wantStatus(200) rts = append(rts, rt) } // Cancel one request. We send a PING frame along with the RST_STREAM. rts[0].response().Body.Close() tc.wantRSTStream(rts[0].streamID(), ErrCodeCancel) pf := readFrame[PingFrame](t, tc) tc.wantIdle() // Cancel another request. No PING frame, since one is in flight. rts[1].response().Body.Close() tc.wantRSTStream(rts[1].streamID(), ErrCodeCancel) tc.wantIdle() // Respond to the PING. // This finalizes the previous resets, and allows the pending request to be sent. tc.writePing(true, pf.Data) tc.wantFrameType(FrameHeaders) tc.wantIdle() // Receive a byte of data for the remaining stream, which resets our ability // to send pings (see comment on ClientConn.rstStreamPingsBlocked). tc.writeData(rts[2].streamID(), false, []byte{0}) // Cancel the last request. We send another PING, since none are in flight. rts[2].response().Body.Close() tc.wantRSTStream(rts[2].streamID(), ErrCodeCancel) tc.wantFrameType(FramePing) tc.wantIdle() } // Issue #70505: gRPC gets upset if we send more than 2 pings per HEADERS/DATA frame // sent by the server. func TestTransportSendNoMoreThanOnePingWithReset(t testing.T) { tc := newTestClientConn(t) tc.greet() makeAndResetRequest := func() { t.Helper() ctx, cancel := context.WithCancel(context.Background()) req := must(http.NewRequestWithContext(ctx, "GET", "https://dummy.tld/", nil)) rt := tc.roundTrip(req) tc.wantFrameType(FrameHeaders) cancel() tc.wantRSTStream(rt.streamID(), ErrCodeCancel) // client sends RST_STREAM } // Create a request and cancel it. // The client sends a PING frame along with the reset. makeAndResetRequest() pf1 := readFrame[PingFrame](t, tc) // client sends PING // Create another request and cancel it. // We do not send a PING frame along with the reset, // because we haven't received a HEADERS or DATA frame from the server // since the last PING we sent. makeAndResetRequest() // Server belatedly responds to request 1. // The server has not responded to our first PING yet. tc.writeHeaders(HeadersFrameParam{ StreamID: 1, EndHeaders: true, EndStream: true, BlockFragment: tc.makeHeaderBlockFragment( ":status", "200", ), }) // Create yet another request and cancel it. // We still do not send a PING frame along with the reset. // We've received a HEADERS frame, but it came before the response to the PING. makeAndResetRequest() // The server responds to our PING. tc.writePing(true, pf1.Data) // Create yet another request and cancel it. // Still no PING frame; we got a response to the previous one, // but no HEADERS or DATA. makeAndResetRequest() // Server belatedly responds to the second request. tc.writeHeaders(HeadersFrameParam{ StreamID: 3, EndHeaders: true, EndStream: true, BlockFragment: tc.makeHeaderBlockFragment( ":status", "200", ), }) // One more request. // This time we send a PING frame. makeAndResetRequest() tc.wantFrameType(FramePing) } func TestTransportConnBecomesUnresponsive(t testing.T) { // We send a number of requests in series to an unresponsive connection. // Each request is canceled or times out without a response. // Eventually, we open a new connection rather than trying to use the old one. tt := newTestTransport(t) const maxConcurrent = 3 t.Logf("first request opens a new connection and succeeds") req1 := must(http.NewRequest("GET", "https://dummy.tld/", nil)) rt1 := tt.roundTrip(req1) tc1 := tt.getConn() tc1.wantFrameType(FrameSettings) tc1.wantFrameType(FrameWindowUpdate) hf1 := readFrame[HeadersFrame](t, tc1) tc1.writeSettings(Setting{SettingMaxConcurrentStreams, maxConcurrent}) tc1.wantFrameType(FrameSettings) // ack tc1.writeHeaders(HeadersFrameParam{ StreamID: hf1.StreamID, EndHeaders: true, EndStream: true, BlockFragment: tc1.makeHeaderBlockFragment( ":status", "200", ), }) rt1.wantStatus(200) rt1.response().Body.Close() // Send more requests. // None receive a response. // Each is canceled. for i := 0; i < maxConcurrent; i++ { t.Logf("request %v receives no response and is canceled", i) ctx, cancel := context.WithCancel(context.Background()) req := must(http.NewRequestWithContext(ctx, "GET", "https://dummy.tld/", nil)) tt.roundTrip(req) if tt.hasConn() { t.Fatalf("new connection created; expect existing conn to be reused") } tc1.wantFrameType(FrameHeaders) cancel() tc1.wantFrameType(FrameRSTStream) if i == 0 { tc1.wantFrameType(FramePing) } tc1.wantIdle() } // The conn has hit its concurrency limit. // The next request is sent on a new conn. req2 := must(http.NewRequest("GET", "https://dummy.tld/", nil)) rt2 := tt.roundTrip(req2) tc2 := tt.getConn() tc2.wantFrameType(FrameSettings) tc2.wantFrameType(FrameWindowUpdate) hf := readFrame[HeadersFrame](t, tc2) tc2.writeSettings(Setting{SettingMaxConcurrentStreams, maxConcurrent}) tc2.wantFrameType(FrameSettings) // ack tc2.writeHeaders(HeadersFrameParam{ StreamID: hf.StreamID, EndHeaders: true, EndStream: true, BlockFragment: tc2.makeHeaderBlockFragment( ":status", "200", ), }) rt2.wantStatus(200) rt2.response().Body.Close() } // Test that the Transport can use a conn provided to it by a TLSNextProto hook. func TestTransportTLSNextProtoConnOK(t testing.T) { t1 := &http.Transport{} t2, _ := ConfigureTransports(t1) tt := newTestTransport(t, t2) // Create a new, fake connection and pass it to the Transport via the TLSNextProto hook. cli, _ := synctestNetPipe(tt.group) cliTLS := tls.Client(cli, tlsConfigInsecure) go func() { tt.group.Join() t1.TLSNextProto["h2"]("dummy.tld", cliTLS) }() tt.sync() tc := tt.getConn() tc.greet() // Send a request on the Transport. // It uses the conn we provided. req := must(http.NewRequest("GET", "https://dummy.tld/", nil)) rt := tt.roundTrip(req) tc.wantHeaders(wantHeader{ streamID: 1, endStream: true, header: http.Header{ ":authority": []string{"dummy.tld"}, ":method": []string{"GET"}, ":path": []string{"/"}, }, }) tc.writeHeaders(HeadersFrameParam{ StreamID: 1, EndHeaders: true, EndStream: true, BlockFragment: tc.makeHeaderBlockFragment( ":status", "200", ), }) rt.wantStatus(200) rt.wantBody(nil) } // Test the case where a conn provided via a TLSNextProto hook immediately encounters an error. func TestTransportTLSNextProtoConnImmediateFailureUsed(t testing.T) { t1 := &http.Transport{} t2, _ := ConfigureTransports(t1) tt := newTestTransport(t, t2) // Create a new, fake connection and pass it to the Transport via the TLSNextProto hook. cli, _ := synctestNetPipe(tt.group) cliTLS := tls.Client(cli, tlsConfigInsecure) go func() { tt.group.Join() t1.TLSNextProto["h2"]("dummy.tld", cliTLS) }() tt.sync() tc := tt.getConn() // The connection encounters an error before we send a request that uses it. tc.closeWrite() // Send a request on the Transport. // // It should fail, because we have no usable connections, but not with ErrNoCachedConn. req := must(http.NewRequest("GET", "https://dummy.tld/", nil)) rt := tt.roundTrip(req) if err := rt.err(); err == nil \|\| errors.Is(err, ErrNoCachedConn) { t.Fatalf("RoundTrip with broken conn: got %v, want an error other than ErrNoCachedConn", err) } // Send the request again. // This time it should fail with ErrNoCachedConn, // because the dead conn has been removed from the pool. rt = tt.roundTrip(req) if err := rt.err(); !errors.Is(err, ErrNoCachedConn) { t.Fatalf("RoundTrip after broken conn is used: got %v, want ErrNoCachedConn", err) } } // Test the case where a conn provided via a TLSNextProto hook immediately encounters an error, // but no requests are sent which would use the bad connection. func TestTransportTLSNextProtoConnImmediateFailureUnused(t testing.T) { t1 := &http.Transport{} t2, _ := ConfigureTransports(t1) tt := newTestTransport(t, t2) // Create a new, fake connection and pass it to the Transport via the TLSNextProto hook. cli, _ := synctestNetPipe(tt.group) cliTLS := tls.Client(cli, tlsConfigInsecure) go func() { tt.group.Join() t1.TLSNextProto["h2"]("dummy.tld", cliTLS) }() tt.sync() tc := tt.getConn() // The connection encounters an error before we send a request that uses it. tc.closeWrite() // Some time passes. // The dead connection is removed from the pool. tc.advance(10 time.Second) // Send a request on the Transport. // // It should fail with ErrNoCachedConn, because the pool contains no conns. req := must(http.NewRequest("GET", "https://dummy.tld/", nil)) rt := tt.roundTrip(req) if err := rt.err(); !errors.Is(err, ErrNoCachedConn) { t.Fatalf("RoundTrip after broken conn expires: got %v, want ErrNoCachedConn", err) } } func TestExtendedConnectClientWithServerSupport(t testing.T) { disableExtendedConnectProtocol = false ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { if r.Header.Get(":protocol") != "extended-connect" { t.Fatalf("unexpected :protocol header received") } t.Log(io.Copy(w, r.Body)) }) tr := &Transport{ TLSClientConfig: tlsConfigInsecure, AllowHTTP: true, } defer tr.CloseIdleConnections() pr, pw := io.Pipe() pwDone := make(chan struct{}) req, _ := http.NewRequest("CONNECT", ts.URL, pr) req.Header.Set(":protocol", "extended-connect") go func() { pw.Write([]byte("hello, extended connect")) pw.Close() close(pwDone) }() res, err := tr.RoundTrip(req) if err != nil { t.Fatal(err) } body, err := io.ReadAll(res.Body) if err != nil { t.Fatal(err) } if !bytes.Equal(body, []byte("hello, extended connect")) { t.Fatal("unexpected body received") } } func TestExtendedConnectClientWithoutServerSupport(t testing.T) { disableExtendedConnectProtocol = true ts := newTestServer(t, func(w http.ResponseWriter, r http.Request) { io.Copy(w, r.Body) }) tr := &Transport{ TLSClientConfig: tlsConfigInsecure, AllowHTTP: true, } defer tr.CloseIdleConnections() pr, pw := io.Pipe() pwDone := make(chan struct{}) req, _ := http.NewRequest("CONNECT", ts.URL, pr) req.Header.Set(":protocol", "extended-connect") go func() { pw.Write([]byte("hello, extended connect")) pw.Close() close(pwDone) }() _, err := tr.RoundTrip(req) if !errors.Is(err, errExtendedConnectNotSupported) { t.Fatalf("expected error errExtendedConnectNotSupported, got: %v", err) } }	152.57 KB	2025-05-25 12:27
📄 unencrypted.go // Copyright 2024 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import ( "crypto/tls" "errors" "net" ) const nextProtoUnencryptedHTTP2 = "unencrypted_http2" // unencryptedNetConnFromTLSConn retrieves a net.Conn wrapped in a tls.Conn. // // TLSNextProto functions accept a tls.Conn. // // When passing an unencrypted HTTP/2 connection to a TLSNextProto function, // we pass a tls.Conn with an underlying net.Conn containing the unencrypted connection. // To be extra careful about mistakes (accidentally dropping TLS encryption in a place // where we want it), the tls.Conn contains a net.Conn with an UnencryptedNetConn method // that returns the actual connection we want to use. func unencryptedNetConnFromTLSConn(tc tls.Conn) (net.Conn, error) { conner, ok := tc.NetConn().(interface { UnencryptedNetConn() net.Conn }) if !ok { return nil, errors.New("http2: TLS conn unexpectedly found in unencrypted handoff") } return conner.UnencryptedNetConn(), nil }	1.06 KB	2025-05-25 12:27
📄 write.go // Copyright 2014 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import ( "bytes" "fmt" "log" "net/http" "net/url" "golang.org/x/net/http/httpguts" "golang.org/x/net/http2/hpack" ) // writeFramer is implemented by any type that is used to write frames. type writeFramer interface { writeFrame(writeContext) error // staysWithinBuffer reports whether this writer promises that // it will only write less than or equal to size bytes, and it // won't Flush the write context. staysWithinBuffer(size int) bool } // writeContext is the interface needed by the various frame writer // types below. All the writeFrame methods below are scheduled via the // frame writing scheduler (see writeScheduler in writesched.go). // // This interface is implemented by serverConn. // // TODO: decide whether to a) use this in the client code (which didn't // end up using this yet, because it has a simpler design, not // currently implementing priorities), or b) delete this and // make the server code a bit more concrete. type writeContext interface { Framer() Framer Flush() error CloseConn() error // HeaderEncoder returns an HPACK encoder that writes to the // returned buffer. HeaderEncoder() (hpack.Encoder, bytes.Buffer) } // writeEndsStream reports whether w writes a frame that will transition // the stream to a half-closed local state. This returns false for RST_STREAM, // which closes the entire stream (not just the local half). func writeEndsStream(w writeFramer) bool { switch v := w.(type) { case writeData: return v.endStream case writeResHeaders: return v.endStream case nil: // This can only happen if the caller reuses w after it's // been intentionally nil'ed out to prevent use. Keep this // here to catch future refactoring breaking it. panic("writeEndsStream called on nil writeFramer") } return false } type flushFrameWriter struct{} func (flushFrameWriter) writeFrame(ctx writeContext) error { return ctx.Flush() } func (flushFrameWriter) staysWithinBuffer(max int) bool { return false } type writeSettings []Setting func (s writeSettings) staysWithinBuffer(max int) bool { const settingSize = 6 // uint16 + uint32 return frameHeaderLen+settingSizelen(s) <= max } func (s writeSettings) writeFrame(ctx writeContext) error { return ctx.Framer().WriteSettings([]Setting(s)...) } type writeGoAway struct { maxStreamID uint32 code ErrCode } func (p writeGoAway) writeFrame(ctx writeContext) error { err := ctx.Framer().WriteGoAway(p.maxStreamID, p.code, nil) ctx.Flush() // ignore error: we're hanging up on them anyway return err } func (writeGoAway) staysWithinBuffer(max int) bool { return false } // flushes type writeData struct { streamID uint32 p []byte endStream bool } func (w writeData) String() string { return fmt.Sprintf("writeData(stream=%d, p=%d, endStream=%v)", w.streamID, len(w.p), w.endStream) } func (w writeData) writeFrame(ctx writeContext) error { return ctx.Framer().WriteData(w.streamID, w.endStream, w.p) } func (w writeData) staysWithinBuffer(max int) bool { return frameHeaderLen+len(w.p) <= max } // handlerPanicRST is the message sent from handler goroutines when // the handler panics. type handlerPanicRST struct { StreamID uint32 } func (hp handlerPanicRST) writeFrame(ctx writeContext) error { return ctx.Framer().WriteRSTStream(hp.StreamID, ErrCodeInternal) } func (hp handlerPanicRST) staysWithinBuffer(max int) bool { return frameHeaderLen+4 <= max } func (se StreamError) writeFrame(ctx writeContext) error { return ctx.Framer().WriteRSTStream(se.StreamID, se.Code) } func (se StreamError) staysWithinBuffer(max int) bool { return frameHeaderLen+4 <= max } type writePing struct { data [8]byte } func (w writePing) writeFrame(ctx writeContext) error { return ctx.Framer().WritePing(false, w.data) } func (w writePing) staysWithinBuffer(max int) bool { return frameHeaderLen+len(w.data) <= max } type writePingAck struct{ pf PingFrame } func (w writePingAck) writeFrame(ctx writeContext) error { return ctx.Framer().WritePing(true, w.pf.Data) } func (w writePingAck) staysWithinBuffer(max int) bool { return frameHeaderLen+len(w.pf.Data) <= max } type writeSettingsAck struct{} func (writeSettingsAck) writeFrame(ctx writeContext) error { return ctx.Framer().WriteSettingsAck() } func (writeSettingsAck) staysWithinBuffer(max int) bool { return frameHeaderLen <= max } // splitHeaderBlock splits headerBlock into fragments so that each fragment fits // in a single frame, then calls fn for each fragment. firstFrag/lastFrag are true // for the first/last fragment, respectively. func splitHeaderBlock(ctx writeContext, headerBlock []byte, fn func(ctx writeContext, frag []byte, firstFrag, lastFrag bool) error) error { // For now we're lazy and just pick the minimum MAX_FRAME_SIZE // that all peers must support (16KB). Later we could care // more and send larger frames if the peer advertised it, but // there's little point. Most headers are small anyway (so we // generally won't have CONTINUATION frames), and extra frames // only waste 9 bytes anyway. const maxFrameSize = 16384 first := true for len(headerBlock) > 0 { frag := headerBlock if len(frag) > maxFrameSize { frag = frag[:maxFrameSize] } headerBlock = headerBlock[len(frag):] if err := fn(ctx, frag, first, len(headerBlock) == 0); err != nil { return err } first = false } return nil } // writeResHeaders is a request to write a HEADERS and 0+ CONTINUATION frames // for HTTP response headers or trailers from a server handler. type writeResHeaders struct { streamID uint32 httpResCode int // 0 means no ":status" line h http.Header // may be nil trailers []string // if non-nil, which keys of h to write. nil means all. endStream bool date string contentType string contentLength string } func encKV(enc hpack.Encoder, k, v string) { if VerboseLogs { log.Printf("http2: server encoding header %q = %q", k, v) } enc.WriteField(hpack.HeaderField{Name: k, Value: v}) } func (w writeResHeaders) staysWithinBuffer(max int) bool { // TODO: this is a common one. It'd be nice to return true // here and get into the fast path if we could be clever and // calculate the size fast enough, or at least a conservative // upper bound that usually fires. (Maybe if w.h and // w.trailers are nil, so we don't need to enumerate it.) // Otherwise I'm afraid that just calculating the length to // answer this question would be slower than the ~2µs benefit. return false } func (w writeResHeaders) writeFrame(ctx writeContext) error { enc, buf := ctx.HeaderEncoder() buf.Reset() if w.httpResCode != 0 { encKV(enc, ":status", httpCodeString(w.httpResCode)) } encodeHeaders(enc, w.h, w.trailers) if w.contentType != "" { encKV(enc, "content-type", w.contentType) } if w.contentLength != "" { encKV(enc, "content-length", w.contentLength) } if w.date != "" { encKV(enc, "date", w.date) } headerBlock := buf.Bytes() if len(headerBlock) == 0 && w.trailers == nil { panic("unexpected empty hpack") } return splitHeaderBlock(ctx, headerBlock, w.writeHeaderBlock) } func (w writeResHeaders) writeHeaderBlock(ctx writeContext, frag []byte, firstFrag, lastFrag bool) error { if firstFrag { return ctx.Framer().WriteHeaders(HeadersFrameParam{ StreamID: w.streamID, BlockFragment: frag, EndStream: w.endStream, EndHeaders: lastFrag, }) } else { return ctx.Framer().WriteContinuation(w.streamID, lastFrag, frag) } } // writePushPromise is a request to write a PUSH_PROMISE and 0+ CONTINUATION frames. type writePushPromise struct { streamID uint32 // pusher stream method string // for :method url url.URL // for :scheme, :authority, :path h http.Header // Creates an ID for a pushed stream. This runs on serveG just before // the frame is written. The returned ID is copied to promisedID. allocatePromisedID func() (uint32, error) promisedID uint32 } func (w writePushPromise) staysWithinBuffer(max int) bool { // TODO: see writeResHeaders.staysWithinBuffer return false } func (w writePushPromise) writeFrame(ctx writeContext) error { enc, buf := ctx.HeaderEncoder() buf.Reset() encKV(enc, ":method", w.method) encKV(enc, ":scheme", w.url.Scheme) encKV(enc, ":authority", w.url.Host) encKV(enc, ":path", w.url.RequestURI()) encodeHeaders(enc, w.h, nil) headerBlock := buf.Bytes() if len(headerBlock) == 0 { panic("unexpected empty hpack") } return splitHeaderBlock(ctx, headerBlock, w.writeHeaderBlock) } func (w writePushPromise) writeHeaderBlock(ctx writeContext, frag []byte, firstFrag, lastFrag bool) error { if firstFrag { return ctx.Framer().WritePushPromise(PushPromiseParam{ StreamID: w.streamID, PromiseID: w.promisedID, BlockFragment: frag, EndHeaders: lastFrag, }) } else { return ctx.Framer().WriteContinuation(w.streamID, lastFrag, frag) } } type write100ContinueHeadersFrame struct { streamID uint32 } func (w write100ContinueHeadersFrame) writeFrame(ctx writeContext) error { enc, buf := ctx.HeaderEncoder() buf.Reset() encKV(enc, ":status", "100") return ctx.Framer().WriteHeaders(HeadersFrameParam{ StreamID: w.streamID, BlockFragment: buf.Bytes(), EndStream: false, EndHeaders: true, }) } func (w write100ContinueHeadersFrame) staysWithinBuffer(max int) bool { // Sloppy but conservative: return 9+2(len(":status")+len("100")) <= max } type writeWindowUpdate struct { streamID uint32 // or 0 for conn-level n uint32 } func (wu writeWindowUpdate) staysWithinBuffer(max int) bool { return frameHeaderLen+4 <= max } func (wu writeWindowUpdate) writeFrame(ctx writeContext) error { return ctx.Framer().WriteWindowUpdate(wu.streamID, wu.n) } // encodeHeaders encodes an http.Header. If keys is not nil, then (k, h[k]) // is encoded only if k is in keys. func encodeHeaders(enc hpack.Encoder, h http.Header, keys []string) { if keys == nil { sorter := sorterPool.Get().(sorter) // Using defer here, since the returned keys from the // sorter.Keys method is only valid until the sorter // is returned: defer sorterPool.Put(sorter) keys = sorter.Keys(h) } for _, k := range keys { vv := h[k] k, ascii := lowerHeader(k) if !ascii { // Skip writing invalid headers. Per RFC 7540, Section 8.1.2, header // field names have to be ASCII characters (just as in HTTP/1.x). continue } if !validWireHeaderFieldName(k) { // Skip it as backup paranoia. Per // golang.org/issue/14048, these should // already be rejected at a higher level. continue } isTE := k == "transfer-encoding" for _, v := range vv { if !httpguts.ValidHeaderFieldValue(v) { // TODO: return an error? golang.org/issue/14048 // For now just omit it. continue } // TODO: more of "8.1.2.2 Connection-Specific Header Fields" if isTE && v != "trailers" { continue } encKV(enc, k, v) } } }	10.91 KB	2025-05-25 12:27
📄 writesched.go // Copyright 2014 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import "fmt" // WriteScheduler is the interface implemented by HTTP/2 write schedulers. // Methods are never called concurrently. type WriteScheduler interface { // OpenStream opens a new stream in the write scheduler. // It is illegal to call this with streamID=0 or with a streamID that is // already open -- the call may panic. OpenStream(streamID uint32, options OpenStreamOptions) // CloseStream closes a stream in the write scheduler. Any frames queued on // this stream should be discarded. It is illegal to call this on a stream // that is not open -- the call may panic. CloseStream(streamID uint32) // AdjustStream adjusts the priority of the given stream. This may be called // on a stream that has not yet been opened or has been closed. Note that // RFC 7540 allows PRIORITY frames to be sent on streams in any state. See: // https://tools.ietf.org/html/rfc7540#section-5.1 AdjustStream(streamID uint32, priority PriorityParam) // Push queues a frame in the scheduler. In most cases, this will not be // called with wr.StreamID()!=0 unless that stream is currently open. The one // exception is RST_STREAM frames, which may be sent on idle or closed streams. Push(wr FrameWriteRequest) // Pop dequeues the next frame to write. Returns false if no frames can // be written. Frames with a given wr.StreamID() are Pop'd in the same // order they are Push'd, except RST_STREAM frames. No frames should be // discarded except by CloseStream. Pop() (wr FrameWriteRequest, ok bool) } // OpenStreamOptions specifies extra options for WriteScheduler.OpenStream. type OpenStreamOptions struct { // PusherID is zero if the stream was initiated by the client. Otherwise, // PusherID names the stream that pushed the newly opened stream. PusherID uint32 } // FrameWriteRequest is a request to write a frame. type FrameWriteRequest struct { // write is the interface value that does the writing, once the // WriteScheduler has selected this frame to write. The write // functions are all defined in write.go. write writeFramer // stream is the stream on which this frame will be written. // nil for non-stream frames like PING and SETTINGS. // nil for RST_STREAM streams, which use the StreamError.StreamID field instead. stream stream // done, if non-nil, must be a buffered channel with space for // 1 message and is sent the return value from write (or an // earlier error) when the frame has been written. done chan error } // StreamID returns the id of the stream this frame will be written to. // 0 is used for non-stream frames such as PING and SETTINGS. func (wr FrameWriteRequest) StreamID() uint32 { if wr.stream == nil { if se, ok := wr.write.(StreamError); ok { // (serverConn).resetStream doesn't set // stream because it doesn't necessarily have // one. So special case this type of write // message. return se.StreamID } return 0 } return wr.stream.id } // isControl reports whether wr is a control frame for MaxQueuedControlFrames // purposes. That includes non-stream frames and RST_STREAM frames. func (wr FrameWriteRequest) isControl() bool { return wr.stream == nil } // DataSize returns the number of flow control bytes that must be consumed // to write this entire frame. This is 0 for non-DATA frames. func (wr FrameWriteRequest) DataSize() int { if wd, ok := wr.write.(writeData); ok { return len(wd.p) } return 0 } // Consume consumes min(n, available) bytes from this frame, where available // is the number of flow control bytes available on the stream. Consume returns // 0, 1, or 2 frames, where the integer return value gives the number of frames // returned. // // If flow control prevents consuming any bytes, this returns (_, _, 0). If // the entire frame was consumed, this returns (wr, _, 1). Otherwise, this // returns (consumed, rest, 2), where 'consumed' contains the consumed bytes and // 'rest' contains the remaining bytes. The consumed bytes are deducted from the // underlying stream's flow control budget. func (wr FrameWriteRequest) Consume(n int32) (FrameWriteRequest, FrameWriteRequest, int) { var empty FrameWriteRequest // Non-DATA frames are always consumed whole. wd, ok := wr.write.(writeData) if !ok \|\| len(wd.p) == 0 { return wr, empty, 1 } // Might need to split after applying limits. allowed := wr.stream.flow.available() if n < allowed { allowed = n } if wr.stream.sc.maxFrameSize < allowed { allowed = wr.stream.sc.maxFrameSize } if allowed <= 0 { return empty, empty, 0 } if len(wd.p) > int(allowed) { wr.stream.flow.take(allowed) consumed := FrameWriteRequest{ stream: wr.stream, write: &writeData{ streamID: wd.streamID, p: wd.p[:allowed], // Even if the original had endStream set, there // are bytes remaining because len(wd.p) > allowed, // so we know endStream is false. endStream: false, }, // Our caller is blocking on the final DATA frame, not // this intermediate frame, so no need to wait. done: nil, } rest := FrameWriteRequest{ stream: wr.stream, write: &writeData{ streamID: wd.streamID, p: wd.p[allowed:], endStream: wd.endStream, }, done: wr.done, } return consumed, rest, 2 } // The frame is consumed whole. // NB: This cast cannot overflow because allowed is <= math.MaxInt32. wr.stream.flow.take(int32(len(wd.p))) return wr, empty, 1 } // String is for debugging only. func (wr FrameWriteRequest) String() string { var des string if s, ok := wr.write.(fmt.Stringer); ok { des = s.String() } else { des = fmt.Sprintf("%T", wr.write) } return fmt.Sprintf("[FrameWriteRequest stream=%d, ch=%v, writer=%v]", wr.StreamID(), wr.done != nil, des) } // replyToWriter sends err to wr.done and panics if the send must block // This does nothing if wr.done is nil. func (wr FrameWriteRequest) replyToWriter(err error) { if wr.done == nil { return } select { case wr.done <- err: default: panic(fmt.Sprintf("unbuffered done channel passed in for type %T", wr.write)) } wr.write = nil // prevent use (assume it's tainted after wr.done send) } // writeQueue is used by implementations of WriteScheduler. type writeQueue struct { s []FrameWriteRequest prev, next writeQueue } func (q writeQueue) empty() bool { return len(q.s) == 0 } func (q writeQueue) push(wr FrameWriteRequest) { q.s = append(q.s, wr) } func (q writeQueue) shift() FrameWriteRequest { if len(q.s) == 0 { panic("invalid use of queue") } wr := q.s[0] // TODO: less copy-happy queue. copy(q.s, q.s[1:]) q.s[len(q.s)-1] = FrameWriteRequest{} q.s = q.s[:len(q.s)-1] return wr } // consume consumes up to n bytes from q.s[0]. If the frame is // entirely consumed, it is removed from the queue. If the frame // is partially consumed, the frame is kept with the consumed // bytes removed. Returns true iff any bytes were consumed. func (q writeQueue) consume(n int32) (FrameWriteRequest, bool) { if len(q.s) == 0 { return FrameWriteRequest{}, false } consumed, rest, numresult := q.s[0].Consume(n) switch numresult { case 0: return FrameWriteRequest{}, false case 1: q.shift() case 2: q.s[0] = rest } return consumed, true } type writeQueuePool []writeQueue // put inserts an unused writeQueue into the pool. func (p writeQueuePool) put(q writeQueue) { for i := range q.s { q.s[i] = FrameWriteRequest{} } q.s = q.s[:0] p = append(p, q) } // get returns an empty writeQueue. func (p writeQueuePool) get() writeQueue { ln := len(p) if ln == 0 { return new(writeQueue) } x := ln - 1 q := (p)[x] (p)[x] = nil p = (p)[:x] return q }	7.66 KB	2025-05-25 12:27
📄 writesched_priority.go // Copyright 2016 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import ( "fmt" "math" "sort" ) // RFC 7540, Section 5.3.5: the default weight is 16. const priorityDefaultWeight = 15 // 16 = 15 + 1 // PriorityWriteSchedulerConfig configures a priorityWriteScheduler. type PriorityWriteSchedulerConfig struct { // MaxClosedNodesInTree controls the maximum number of closed streams to // retain in the priority tree. Setting this to zero saves a small amount // of memory at the cost of performance. // // See RFC 7540, Section 5.3.4: // "It is possible for a stream to become closed while prioritization // information ... is in transit. ... This potentially creates suboptimal // prioritization, since the stream could be given a priority that is // different from what is intended. To avoid these problems, an endpoint // SHOULD retain stream prioritization state for a period after streams // become closed. The longer state is retained, the lower the chance that // streams are assigned incorrect or default priority values." MaxClosedNodesInTree int // MaxIdleNodesInTree controls the maximum number of idle streams to // retain in the priority tree. Setting this to zero saves a small amount // of memory at the cost of performance. // // See RFC 7540, Section 5.3.4: // Similarly, streams that are in the "idle" state can be assigned // priority or become a parent of other streams. This allows for the // creation of a grouping node in the dependency tree, which enables // more flexible expressions of priority. Idle streams begin with a // default priority (Section 5.3.5). MaxIdleNodesInTree int // ThrottleOutOfOrderWrites enables write throttling to help ensure that // data is delivered in priority order. This works around a race where // stream B depends on stream A and both streams are about to call Write // to queue DATA frames. If B wins the race, a naive scheduler would eagerly // write as much data from B as possible, but this is suboptimal because A // is a higher-priority stream. With throttling enabled, we write a small // amount of data from B to minimize the amount of bandwidth that B can // steal from A. ThrottleOutOfOrderWrites bool } // NewPriorityWriteScheduler constructs a WriteScheduler that schedules // frames by following HTTP/2 priorities as described in RFC 7540 Section 5.3. // If cfg is nil, default options are used. func NewPriorityWriteScheduler(cfg PriorityWriteSchedulerConfig) WriteScheduler { if cfg == nil { // For justification of these defaults, see: // https://docs.google.com/document/d/1oLhNg1skaWD4_DtaoCxdSRN5erEXrH-KnLrMwEpOtFY cfg = &PriorityWriteSchedulerConfig{ MaxClosedNodesInTree: 10, MaxIdleNodesInTree: 10, ThrottleOutOfOrderWrites: false, } } ws := &priorityWriteScheduler{ nodes: make(map[uint32]priorityNode), maxClosedNodesInTree: cfg.MaxClosedNodesInTree, maxIdleNodesInTree: cfg.MaxIdleNodesInTree, enableWriteThrottle: cfg.ThrottleOutOfOrderWrites, } ws.nodes[0] = &ws.root if cfg.ThrottleOutOfOrderWrites { ws.writeThrottleLimit = 1024 } else { ws.writeThrottleLimit = math.MaxInt32 } return ws } type priorityNodeState int const ( priorityNodeOpen priorityNodeState = iota priorityNodeClosed priorityNodeIdle ) // priorityNode is a node in an HTTP/2 priority tree. // Each node is associated with a single stream ID. // See RFC 7540, Section 5.3. type priorityNode struct { q writeQueue // queue of pending frames to write id uint32 // id of the stream, or 0 for the root of the tree weight uint8 // the actual weight is weight+1, so the value is in [1,256] state priorityNodeState // open \| closed \| idle bytes int64 // number of bytes written by this node, or 0 if closed subtreeBytes int64 // sum(node.bytes) of all nodes in this subtree // These links form the priority tree. parent priorityNode kids priorityNode // start of the kids list prev, next priorityNode // doubly-linked list of siblings } func (n priorityNode) setParent(parent priorityNode) { if n == parent { panic("setParent to self") } if n.parent == parent { return } // Unlink from current parent. if parent := n.parent; parent != nil { if n.prev == nil { parent.kids = n.next } else { n.prev.next = n.next } if n.next != nil { n.next.prev = n.prev } } // Link to new parent. // If parent=nil, remove n from the tree. // Always insert at the head of parent.kids (this is assumed by walkReadyInOrder). n.parent = parent if parent == nil { n.next = nil n.prev = nil } else { n.next = parent.kids n.prev = nil if n.next != nil { n.next.prev = n } parent.kids = n } } func (n priorityNode) addBytes(b int64) { n.bytes += b for ; n != nil; n = n.parent { n.subtreeBytes += b } } // walkReadyInOrder iterates over the tree in priority order, calling f for each node // with a non-empty write queue. When f returns true, this function returns true and the // walk halts. tmp is used as scratch space for sorting. // // f(n, openParent) takes two arguments: the node to visit, n, and a bool that is true // if any ancestor p of n is still open (ignoring the root node). func (n priorityNode) walkReadyInOrder(openParent bool, tmp []priorityNode, f func(priorityNode, bool) bool) bool { if !n.q.empty() && f(n, openParent) { return true } if n.kids == nil { return false } // Don't consider the root "open" when updating openParent since // we can't send data frames on the root stream (only control frames). if n.id != 0 { openParent = openParent \|\| (n.state == priorityNodeOpen) } // Common case: only one kid or all kids have the same weight. // Some clients don't use weights; other clients (like web browsers) // use mostly-linear priority trees. w := n.kids.weight needSort := false for k := n.kids.next; k != nil; k = k.next { if k.weight != w { needSort = true break } } if !needSort { for k := n.kids; k != nil; k = k.next { if k.walkReadyInOrder(openParent, tmp, f) { return true } } return false } // Uncommon case: sort the child nodes. We remove the kids from the parent, // then re-insert after sorting so we can reuse tmp for future sort calls. tmp = (tmp)[:0] for n.kids != nil { tmp = append(tmp, n.kids) n.kids.setParent(nil) } sort.Sort(sortPriorityNodeSiblings(tmp)) for i := len(tmp) - 1; i >= 0; i-- { (tmp)[i].setParent(n) // setParent inserts at the head of n.kids } for k := n.kids; k != nil; k = k.next { if k.walkReadyInOrder(openParent, tmp, f) { return true } } return false } type sortPriorityNodeSiblings []priorityNode func (z sortPriorityNodeSiblings) Len() int { return len(z) } func (z sortPriorityNodeSiblings) Swap(i, k int) { z[i], z[k] = z[k], z[i] } func (z sortPriorityNodeSiblings) Less(i, k int) bool { // Prefer the subtree that has sent fewer bytes relative to its weight. // See sections 5.3.2 and 5.3.4. wi, bi := float64(z[i].weight+1), float64(z[i].subtreeBytes) wk, bk := float64(z[k].weight+1), float64(z[k].subtreeBytes) if bi == 0 && bk == 0 { return wi >= wk } if bk == 0 { return false } return bi/bk <= wi/wk } type priorityWriteScheduler struct { // root is the root of the priority tree, where root.id = 0. // The root queues control frames that are not associated with any stream. root priorityNode // nodes maps stream ids to priority tree nodes. nodes map[uint32]priorityNode // maxID is the maximum stream id in nodes. maxID uint32 // lists of nodes that have been closed or are idle, but are kept in // the tree for improved prioritization. When the lengths exceed either // maxClosedNodesInTree or maxIdleNodesInTree, old nodes are discarded. closedNodes, idleNodes []priorityNode // From the config. maxClosedNodesInTree int maxIdleNodesInTree int writeThrottleLimit int32 enableWriteThrottle bool // tmp is scratch space for priorityNode.walkReadyInOrder to reduce allocations. tmp []priorityNode // pool of empty queues for reuse. queuePool writeQueuePool } func (ws priorityWriteScheduler) OpenStream(streamID uint32, options OpenStreamOptions) { // The stream may be currently idle but cannot be opened or closed. if curr := ws.nodes[streamID]; curr != nil { if curr.state != priorityNodeIdle { panic(fmt.Sprintf("stream %d already opened", streamID)) } curr.state = priorityNodeOpen return } // RFC 7540, Section 5.3.5: // "All streams are initially assigned a non-exclusive dependency on stream 0x0. // Pushed streams initially depend on their associated stream. In both cases, // streams are assigned a default weight of 16." parent := ws.nodes[options.PusherID] if parent == nil { parent = &ws.root } n := &priorityNode{ q: ws.queuePool.get(), id: streamID, weight: priorityDefaultWeight, state: priorityNodeOpen, } n.setParent(parent) ws.nodes[streamID] = n if streamID > ws.maxID { ws.maxID = streamID } } func (ws priorityWriteScheduler) CloseStream(streamID uint32) { if streamID == 0 { panic("violation of WriteScheduler interface: cannot close stream 0") } if ws.nodes[streamID] == nil { panic(fmt.Sprintf("violation of WriteScheduler interface: unknown stream %d", streamID)) } if ws.nodes[streamID].state != priorityNodeOpen { panic(fmt.Sprintf("violation of WriteScheduler interface: stream %d already closed", streamID)) } n := ws.nodes[streamID] n.state = priorityNodeClosed n.addBytes(-n.bytes) q := n.q ws.queuePool.put(&q) n.q.s = nil if ws.maxClosedNodesInTree > 0 { ws.addClosedOrIdleNode(&ws.closedNodes, ws.maxClosedNodesInTree, n) } else { ws.removeNode(n) } } func (ws priorityWriteScheduler) AdjustStream(streamID uint32, priority PriorityParam) { if streamID == 0 { panic("adjustPriority on root") } // If streamID does not exist, there are two cases: // - A closed stream that has been removed (this will have ID <= maxID) // - An idle stream that is being used for "grouping" (this will have ID > maxID) n := ws.nodes[streamID] if n == nil { if streamID <= ws.maxID \|\| ws.maxIdleNodesInTree == 0 { return } ws.maxID = streamID n = &priorityNode{ q: ws.queuePool.get(), id: streamID, weight: priorityDefaultWeight, state: priorityNodeIdle, } n.setParent(&ws.root) ws.nodes[streamID] = n ws.addClosedOrIdleNode(&ws.idleNodes, ws.maxIdleNodesInTree, n) } // Section 5.3.1: A dependency on a stream that is not currently in the tree // results in that stream being given a default priority (Section 5.3.5). parent := ws.nodes[priority.StreamDep] if parent == nil { n.setParent(&ws.root) n.weight = priorityDefaultWeight return } // Ignore if the client tries to make a node its own parent. if n == parent { return } // Section 5.3.3: // "If a stream is made dependent on one of its own dependencies, the // formerly dependent stream is first moved to be dependent on the // reprioritized stream's previous parent. The moved dependency retains // its weight." // // That is: if parent depends on n, move parent to depend on n.parent. for x := parent.parent; x != nil; x = x.parent { if x == n { parent.setParent(n.parent) break } } // Section 5.3.3: The exclusive flag causes the stream to become the sole // dependency of its parent stream, causing other dependencies to become // dependent on the exclusive stream. if priority.Exclusive { k := parent.kids for k != nil { next := k.next if k != n { k.setParent(n) } k = next } } n.setParent(parent) n.weight = priority.Weight } func (ws priorityWriteScheduler) Push(wr FrameWriteRequest) { var n priorityNode if wr.isControl() { n = &ws.root } else { id := wr.StreamID() n = ws.nodes[id] if n == nil { // id is an idle or closed stream. wr should not be a HEADERS or // DATA frame. In other case, we push wr onto the root, rather // than creating a new priorityNode. if wr.DataSize() > 0 { panic("add DATA on non-open stream") } n = &ws.root } } n.q.push(wr) } func (ws priorityWriteScheduler) Pop() (wr FrameWriteRequest, ok bool) { ws.root.walkReadyInOrder(false, &ws.tmp, func(n priorityNode, openParent bool) bool { limit := int32(math.MaxInt32) if openParent { limit = ws.writeThrottleLimit } wr, ok = n.q.consume(limit) if !ok { return false } n.addBytes(int64(wr.DataSize())) // If B depends on A and B continuously has data available but A // does not, gradually increase the throttling limit to allow B to // steal more and more bandwidth from A. if openParent { ws.writeThrottleLimit += 1024 if ws.writeThrottleLimit < 0 { ws.writeThrottleLimit = math.MaxInt32 } } else if ws.enableWriteThrottle { ws.writeThrottleLimit = 1024 } return true }) return wr, ok } func (ws priorityWriteScheduler) addClosedOrIdleNode(list []priorityNode, maxSize int, n priorityNode) { if maxSize == 0 { return } if len(list) == maxSize { // Remove the oldest node, then shift left. ws.removeNode((list)[0]) x := (list)[1:] copy(list, x) list = (list)[:len(x)] } list = append(list, n) } func (ws priorityWriteScheduler) removeNode(n priorityNode) { for n.kids != nil { n.kids.setParent(n.parent) } n.setParent(nil) delete(ws.nodes, n.id) }	13.32 KB	2025-05-25 12:27
📄 writesched_priority_test.go // Copyright 2016 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import ( "bytes" "fmt" "sort" "testing" ) func defaultPriorityWriteScheduler() priorityWriteScheduler { return NewPriorityWriteScheduler(nil).(priorityWriteScheduler) } func checkPriorityWellFormed(ws priorityWriteScheduler) error { for id, n := range ws.nodes { if id != n.id { return fmt.Errorf("bad ws.nodes: ws.nodes[%d] = %d", id, n.id) } if n.parent == nil { if n.next != nil \|\| n.prev != nil { return fmt.Errorf("bad node %d: nil parent but prev/next not nil", id) } continue } found := false for k := n.parent.kids; k != nil; k = k.next { if k.id == id { found = true break } } if !found { return fmt.Errorf("bad node %d: not found in parent %d kids list", id, n.parent.id) } } return nil } func fmtTree(ws priorityWriteScheduler, fmtNode func(priorityNode) string) string { var ids []int for _, n := range ws.nodes { ids = append(ids, int(n.id)) } sort.Ints(ids) var buf bytes.Buffer for _, id := range ids { if buf.Len() != 0 { buf.WriteString(" ") } if id == 0 { buf.WriteString(fmtNode(&ws.root)) } else { buf.WriteString(fmtNode(ws.nodes[uint32(id)])) } } return buf.String() } func fmtNodeParentSkipRoot(n priorityNode) string { switch { case n.id == 0: return "" case n.parent == nil: return fmt.Sprintf("%d{parent:nil}", n.id) default: return fmt.Sprintf("%d{parent:%d}", n.id, n.parent.id) } } func fmtNodeWeightParentSkipRoot(n priorityNode) string { switch { case n.id == 0: return "" case n.parent == nil: return fmt.Sprintf("%d{weight:%d,parent:nil}", n.id, n.weight) default: return fmt.Sprintf("%d{weight:%d,parent:%d}", n.id, n.weight, n.parent.id) } } func TestPriorityTwoStreams(t testing.T) { ws := defaultPriorityWriteScheduler() ws.OpenStream(1, OpenStreamOptions{}) ws.OpenStream(2, OpenStreamOptions{}) want := "1{weight:15,parent:0} 2{weight:15,parent:0}" if got := fmtTree(ws, fmtNodeWeightParentSkipRoot); got != want { t.Errorf("After open\ngot %q\nwant %q", got, want) } // Move 1's parent to 2. ws.AdjustStream(1, PriorityParam{ StreamDep: 2, Weight: 32, Exclusive: false, }) want = "1{weight:32,parent:2} 2{weight:15,parent:0}" if got := fmtTree(ws, fmtNodeWeightParentSkipRoot); got != want { t.Errorf("After adjust\ngot %q\nwant %q", got, want) } if err := checkPriorityWellFormed(ws); err != nil { t.Error(err) } } func TestPriorityAdjustExclusiveZero(t testing.T) { // 1, 2, and 3 are all children of the 0 stream. // Exclusive reprioritization to any of the streams should bring // the rest of the streams under the reprioritized stream. ws := defaultPriorityWriteScheduler() ws.OpenStream(1, OpenStreamOptions{}) ws.OpenStream(2, OpenStreamOptions{}) ws.OpenStream(3, OpenStreamOptions{}) want := "1{weight:15,parent:0} 2{weight:15,parent:0} 3{weight:15,parent:0}" if got := fmtTree(ws, fmtNodeWeightParentSkipRoot); got != want { t.Errorf("After open\ngot %q\nwant %q", got, want) } ws.AdjustStream(2, PriorityParam{ StreamDep: 0, Weight: 20, Exclusive: true, }) want = "1{weight:15,parent:2} 2{weight:20,parent:0} 3{weight:15,parent:2}" if got := fmtTree(ws, fmtNodeWeightParentSkipRoot); got != want { t.Errorf("After adjust\ngot %q\nwant %q", got, want) } if err := checkPriorityWellFormed(ws); err != nil { t.Error(err) } } func TestPriorityAdjustOwnParent(t testing.T) { // Assigning a node as its own parent should have no effect. ws := defaultPriorityWriteScheduler() ws.OpenStream(1, OpenStreamOptions{}) ws.OpenStream(2, OpenStreamOptions{}) ws.AdjustStream(2, PriorityParam{ StreamDep: 2, Weight: 20, Exclusive: true, }) want := "1{weight:15,parent:0} 2{weight:15,parent:0}" if got := fmtTree(ws, fmtNodeWeightParentSkipRoot); got != want { t.Errorf("After adjust\ngot %q\nwant %q", got, want) } if err := checkPriorityWellFormed(ws); err != nil { t.Error(err) } } func TestPriorityClosedStreams(t testing.T) { ws := NewPriorityWriteScheduler(&PriorityWriteSchedulerConfig{MaxClosedNodesInTree: 2}).(priorityWriteScheduler) ws.OpenStream(1, OpenStreamOptions{}) ws.OpenStream(2, OpenStreamOptions{PusherID: 1}) ws.OpenStream(3, OpenStreamOptions{PusherID: 2}) ws.OpenStream(4, OpenStreamOptions{PusherID: 3}) // Close the first three streams. We lose 1, but keep 2 and 3. ws.CloseStream(1) ws.CloseStream(2) ws.CloseStream(3) want := "2{weight:15,parent:0} 3{weight:15,parent:2} 4{weight:15,parent:3}" if got := fmtTree(ws, fmtNodeWeightParentSkipRoot); got != want { t.Errorf("After close\ngot %q\nwant %q", got, want) } if err := checkPriorityWellFormed(ws); err != nil { t.Error(err) } // Adding a stream as an exclusive child of 1 gives it default // priorities, since 1 is gone. ws.OpenStream(5, OpenStreamOptions{}) ws.AdjustStream(5, PriorityParam{StreamDep: 1, Weight: 15, Exclusive: true}) // Adding a stream as an exclusive child of 2 should work, since 2 is not gone. ws.OpenStream(6, OpenStreamOptions{}) ws.AdjustStream(6, PriorityParam{StreamDep: 2, Weight: 15, Exclusive: true}) want = "2{weight:15,parent:0} 3{weight:15,parent:6} 4{weight:15,parent:3} 5{weight:15,parent:0} 6{weight:15,parent:2}" if got := fmtTree(ws, fmtNodeWeightParentSkipRoot); got != want { t.Errorf("After add streams\ngot %q\nwant %q", got, want) } if err := checkPriorityWellFormed(ws); err != nil { t.Error(err) } } func TestPriorityClosedStreamsDisabled(t testing.T) { ws := NewPriorityWriteScheduler(&PriorityWriteSchedulerConfig{}).(priorityWriteScheduler) ws.OpenStream(1, OpenStreamOptions{}) ws.OpenStream(2, OpenStreamOptions{PusherID: 1}) ws.OpenStream(3, OpenStreamOptions{PusherID: 2}) // Close the first two streams. We keep only 3. ws.CloseStream(1) ws.CloseStream(2) want := "3{weight:15,parent:0}" if got := fmtTree(ws, fmtNodeWeightParentSkipRoot); got != want { t.Errorf("After close\ngot %q\nwant %q", got, want) } if err := checkPriorityWellFormed(ws); err != nil { t.Error(err) } } func TestPriorityIdleStreams(t testing.T) { ws := NewPriorityWriteScheduler(&PriorityWriteSchedulerConfig{MaxIdleNodesInTree: 2}).(priorityWriteScheduler) ws.AdjustStream(1, PriorityParam{StreamDep: 0, Weight: 15}) // idle ws.AdjustStream(2, PriorityParam{StreamDep: 0, Weight: 15}) // idle ws.AdjustStream(3, PriorityParam{StreamDep: 2, Weight: 20}) // idle ws.OpenStream(4, OpenStreamOptions{}) ws.OpenStream(5, OpenStreamOptions{}) ws.OpenStream(6, OpenStreamOptions{}) ws.AdjustStream(4, PriorityParam{StreamDep: 1, Weight: 15}) ws.AdjustStream(5, PriorityParam{StreamDep: 2, Weight: 15}) ws.AdjustStream(6, PriorityParam{StreamDep: 3, Weight: 15}) want := "2{weight:15,parent:0} 3{weight:20,parent:2} 4{weight:15,parent:0} 5{weight:15,parent:2} 6{weight:15,parent:3}" if got := fmtTree(ws, fmtNodeWeightParentSkipRoot); got != want { t.Errorf("After open\ngot %q\nwant %q", got, want) } if err := checkPriorityWellFormed(ws); err != nil { t.Error(err) } } func TestPriorityIdleStreamsDisabled(t testing.T) { ws := NewPriorityWriteScheduler(&PriorityWriteSchedulerConfig{}).(priorityWriteScheduler) ws.AdjustStream(1, PriorityParam{StreamDep: 0, Weight: 15}) // idle ws.AdjustStream(2, PriorityParam{StreamDep: 0, Weight: 15}) // idle ws.AdjustStream(3, PriorityParam{StreamDep: 2, Weight: 20}) // idle ws.OpenStream(4, OpenStreamOptions{}) want := "4{weight:15,parent:0}" if got := fmtTree(ws, fmtNodeWeightParentSkipRoot); got != want { t.Errorf("After open\ngot %q\nwant %q", got, want) } if err := checkPriorityWellFormed(ws); err != nil { t.Error(err) } } func TestPrioritySection531NonExclusive(t testing.T) { // Example from RFC 7540 Section 5.3.1. // A,B,C,D = 1,2,3,4 ws := defaultPriorityWriteScheduler() ws.OpenStream(1, OpenStreamOptions{}) ws.OpenStream(2, OpenStreamOptions{PusherID: 1}) ws.OpenStream(3, OpenStreamOptions{PusherID: 1}) ws.OpenStream(4, OpenStreamOptions{}) ws.AdjustStream(4, PriorityParam{ StreamDep: 1, Weight: 15, Exclusive: false, }) want := "1{parent:0} 2{parent:1} 3{parent:1} 4{parent:1}" if got := fmtTree(ws, fmtNodeParentSkipRoot); got != want { t.Errorf("After adjust\ngot %q\nwant %q", got, want) } if err := checkPriorityWellFormed(ws); err != nil { t.Error(err) } } func TestPrioritySection531Exclusive(t testing.T) { // Example from RFC 7540 Section 5.3.1. // A,B,C,D = 1,2,3,4 ws := defaultPriorityWriteScheduler() ws.OpenStream(1, OpenStreamOptions{}) ws.OpenStream(2, OpenStreamOptions{PusherID: 1}) ws.OpenStream(3, OpenStreamOptions{PusherID: 1}) ws.OpenStream(4, OpenStreamOptions{}) ws.AdjustStream(4, PriorityParam{ StreamDep: 1, Weight: 15, Exclusive: true, }) want := "1{parent:0} 2{parent:4} 3{parent:4} 4{parent:1}" if got := fmtTree(ws, fmtNodeParentSkipRoot); got != want { t.Errorf("After adjust\ngot %q\nwant %q", got, want) } if err := checkPriorityWellFormed(ws); err != nil { t.Error(err) } } func makeSection533Tree() priorityWriteScheduler { // Initial tree from RFC 7540 Section 5.3.3. // A,B,C,D,E,F = 1,2,3,4,5,6 ws := defaultPriorityWriteScheduler() ws.OpenStream(1, OpenStreamOptions{}) ws.OpenStream(2, OpenStreamOptions{PusherID: 1}) ws.OpenStream(3, OpenStreamOptions{PusherID: 1}) ws.OpenStream(4, OpenStreamOptions{PusherID: 3}) ws.OpenStream(5, OpenStreamOptions{PusherID: 3}) ws.OpenStream(6, OpenStreamOptions{PusherID: 4}) return ws } func TestPrioritySection533NonExclusive(t testing.T) { // Example from RFC 7540 Section 5.3.3. // A,B,C,D,E,F = 1,2,3,4,5,6 ws := defaultPriorityWriteScheduler() ws.OpenStream(1, OpenStreamOptions{}) ws.OpenStream(2, OpenStreamOptions{PusherID: 1}) ws.OpenStream(3, OpenStreamOptions{PusherID: 1}) ws.OpenStream(4, OpenStreamOptions{PusherID: 3}) ws.OpenStream(5, OpenStreamOptions{PusherID: 3}) ws.OpenStream(6, OpenStreamOptions{PusherID: 4}) ws.AdjustStream(1, PriorityParam{ StreamDep: 4, Weight: 15, Exclusive: false, }) want := "1{parent:4} 2{parent:1} 3{parent:1} 4{parent:0} 5{parent:3} 6{parent:4}" if got := fmtTree(ws, fmtNodeParentSkipRoot); got != want { t.Errorf("After adjust\ngot %q\nwant %q", got, want) } if err := checkPriorityWellFormed(ws); err != nil { t.Error(err) } } func TestPrioritySection533Exclusive(t testing.T) { // Example from RFC 7540 Section 5.3.3. // A,B,C,D,E,F = 1,2,3,4,5,6 ws := defaultPriorityWriteScheduler() ws.OpenStream(1, OpenStreamOptions{}) ws.OpenStream(2, OpenStreamOptions{PusherID: 1}) ws.OpenStream(3, OpenStreamOptions{PusherID: 1}) ws.OpenStream(4, OpenStreamOptions{PusherID: 3}) ws.OpenStream(5, OpenStreamOptions{PusherID: 3}) ws.OpenStream(6, OpenStreamOptions{PusherID: 4}) ws.AdjustStream(1, PriorityParam{ StreamDep: 4, Weight: 15, Exclusive: true, }) want := "1{parent:4} 2{parent:1} 3{parent:1} 4{parent:0} 5{parent:3} 6{parent:1}" if got := fmtTree(ws, fmtNodeParentSkipRoot); got != want { t.Errorf("After adjust\ngot %q\nwant %q", got, want) } if err := checkPriorityWellFormed(ws); err != nil { t.Error(err) } } func checkPopAll(ws WriteScheduler, order []uint32) error { for k, id := range order { wr, ok := ws.Pop() if !ok { return fmt.Errorf("Pop[%d]: got ok=false, want %d (order=%v)", k, id, order) } if got := wr.StreamID(); got != id { return fmt.Errorf("Pop[%d]: got %v, want %d (order=%v)", k, got, id, order) } } wr, ok := ws.Pop() if ok { return fmt.Errorf("Pop[%d]: got %v, want ok=false (order=%v)", len(order), wr.StreamID(), order) } return nil } func TestPriorityPopFrom533Tree(t testing.T) { ws := makeSection533Tree() ws.Push(makeWriteHeadersRequest(3 /C/)) ws.Push(makeWriteNonStreamRequest()) ws.Push(makeWriteHeadersRequest(5 /E/)) ws.Push(makeWriteHeadersRequest(1 /A/)) t.Log("tree:", fmtTree(ws, fmtNodeParentSkipRoot)) if err := checkPopAll(ws, []uint32{0 /NonStream/, 1, 3, 5}); err != nil { t.Error(err) } } // #49741 RST_STREAM and Control frames should have more priority than data // frames to avoid blocking streams caused by clients not able to drain the // queue. func TestPriorityRSTFrames(t testing.T) { ws := defaultPriorityWriteScheduler() ws.OpenStream(1, OpenStreamOptions{}) sc := &serverConn{maxFrameSize: 16} st1 := &stream{id: 1, sc: sc} ws.Push(FrameWriteRequest{&writeData{1, make([]byte, 16), false}, st1, nil}) ws.Push(FrameWriteRequest{&writeData{1, make([]byte, 16), false}, st1, nil}) ws.Push(makeWriteRSTStream(1)) // No flow-control bytes available. wr, ok := ws.Pop() if !ok { t.Fatalf("Pop should work for control frames and not be limited by flow control") } if _, ok := wr.write.(StreamError); !ok { t.Fatal("expected RST stream frames first", wr) } } func TestPriorityPopFromLinearTree(t testing.T) { ws := defaultPriorityWriteScheduler() ws.OpenStream(1, OpenStreamOptions{}) ws.OpenStream(2, OpenStreamOptions{PusherID: 1}) ws.OpenStream(3, OpenStreamOptions{PusherID: 2}) ws.OpenStream(4, OpenStreamOptions{PusherID: 3}) ws.Push(makeWriteHeadersRequest(3)) ws.Push(makeWriteHeadersRequest(4)) ws.Push(makeWriteHeadersRequest(1)) ws.Push(makeWriteHeadersRequest(2)) ws.Push(makeWriteNonStreamRequest()) ws.Push(makeWriteNonStreamRequest()) t.Log("tree:", fmtTree(ws, fmtNodeParentSkipRoot)) if err := checkPopAll(ws, []uint32{0, 0 /NonStreams/, 1, 2, 3, 4}); err != nil { t.Error(err) } } func TestPriorityFlowControl(t testing.T) { ws := NewPriorityWriteScheduler(&PriorityWriteSchedulerConfig{ThrottleOutOfOrderWrites: false}) ws.OpenStream(1, OpenStreamOptions{}) ws.OpenStream(2, OpenStreamOptions{PusherID: 1}) sc := &serverConn{maxFrameSize: 16} st1 := &stream{id: 1, sc: sc} st2 := &stream{id: 2, sc: sc} ws.Push(FrameWriteRequest{&writeData{1, make([]byte, 16), false}, st1, nil}) ws.Push(FrameWriteRequest{&writeData{2, make([]byte, 16), false}, st2, nil}) ws.AdjustStream(2, PriorityParam{StreamDep: 1}) // No flow-control bytes available. if wr, ok := ws.Pop(); ok { t.Fatalf("Pop(limited by flow control)=%v,true, want false", wr) } // Add enough flow-control bytes to write st2 in two Pop calls. // Should write data from st2 even though it's lower priority than st1. for i := 1; i <= 2; i++ { st2.flow.add(8) wr, ok := ws.Pop() if !ok { t.Fatalf("Pop(%d)=false, want true", i) } if got, want := wr.DataSize(), 8; got != want { t.Fatalf("Pop(%d)=%d bytes, want %d bytes", i, got, want) } } } func TestPriorityThrottleOutOfOrderWrites(t testing.T) { ws := NewPriorityWriteScheduler(&PriorityWriteSchedulerConfig{ThrottleOutOfOrderWrites: true}) ws.OpenStream(1, OpenStreamOptions{}) ws.OpenStream(2, OpenStreamOptions{PusherID: 1}) sc := &serverConn{maxFrameSize: 4096} st1 := &stream{id: 1, sc: sc} st2 := &stream{id: 2, sc: sc} st1.flow.add(4096) st2.flow.add(4096) ws.Push(FrameWriteRequest{&writeData{2, make([]byte, 4096), false}, st2, nil}) ws.AdjustStream(2, PriorityParam{StreamDep: 1}) // We have enough flow-control bytes to write st2 in a single Pop call. // However, due to out-of-order write throttling, the first call should // only write 1KB. wr, ok := ws.Pop() if !ok { t.Fatalf("Pop(st2.first)=false, want true") } if got, want := wr.StreamID(), uint32(2); got != want { t.Fatalf("Pop(st2.first)=stream %d, want stream %d", got, want) } if got, want := wr.DataSize(), 1024; got != want { t.Fatalf("Pop(st2.first)=%d bytes, want %d bytes", got, want) } // Now add data on st1. This should take precedence. ws.Push(FrameWriteRequest{&writeData{1, make([]byte, 4096), false}, st1, nil}) wr, ok = ws.Pop() if !ok { t.Fatalf("Pop(st1)=false, want true") } if got, want := wr.StreamID(), uint32(1); got != want { t.Fatalf("Pop(st1)=stream %d, want stream %d", got, want) } if got, want := wr.DataSize(), 4096; got != want { t.Fatalf("Pop(st1)=%d bytes, want %d bytes", got, want) } // Should go back to writing 1KB from st2. wr, ok = ws.Pop() if !ok { t.Fatalf("Pop(st2.last)=false, want true") } if got, want := wr.StreamID(), uint32(2); got != want { t.Fatalf("Pop(st2.last)=stream %d, want stream %d", got, want) } if got, want := wr.DataSize(), 1024; got != want { t.Fatalf("Pop(st2.last)=%d bytes, want %d bytes", got, want) } } func TestPriorityWeights(t testing.T) { ws := defaultPriorityWriteScheduler() ws.OpenStream(1, OpenStreamOptions{}) ws.OpenStream(2, OpenStreamOptions{}) sc := &serverConn{maxFrameSize: 8} st1 := &stream{id: 1, sc: sc} st2 := &stream{id: 2, sc: sc} st1.flow.add(40) st2.flow.add(40) ws.Push(FrameWriteRequest{&writeData{1, make([]byte, 40), false}, st1, nil}) ws.Push(FrameWriteRequest{&writeData{2, make([]byte, 40), false}, st2, nil}) ws.AdjustStream(1, PriorityParam{StreamDep: 0, Weight: 34}) ws.AdjustStream(2, PriorityParam{StreamDep: 0, Weight: 9}) // st1 gets 3.5x the bandwidth of st2 (3.5 = (34+1)/(9+1)). // The maximum frame size is 8 bytes. The write sequence should be: // st1, total bytes so far is (st1=8, st=0) // st2, total bytes so far is (st1=8, st=8) // st1, total bytes so far is (st1=16, st=8) // st1, total bytes so far is (st1=24, st=8) // 3x bandwidth // st1, total bytes so far is (st1=32, st=8) // 4x bandwidth // st2, total bytes so far is (st1=32, st=16) // 2x bandwidth // st1, total bytes so far is (st1=40, st=16) // st2, total bytes so far is (st1=40, st=24) // st2, total bytes so far is (st1=40, st=32) // st2, total bytes so far is (st1=40, st=40) if err := checkPopAll(ws, []uint32{1, 2, 1, 1, 1, 2, 1, 2, 2, 2}); err != nil { t.Error(err) } } func TestPriorityRstStreamOnNonOpenStreams(t testing.T) { ws := NewPriorityWriteScheduler(&PriorityWriteSchedulerConfig{ MaxClosedNodesInTree: 0, MaxIdleNodesInTree: 0, }) ws.OpenStream(1, OpenStreamOptions{}) ws.CloseStream(1) ws.Push(FrameWriteRequest{write: streamError(1, ErrCodeProtocol)}) ws.Push(FrameWriteRequest{write: streamError(2, ErrCodeProtocol)}) if err := checkPopAll(ws, []uint32{1, 2}); err != nil { t.Error(err) } } // https://go.dev/issue/66514 func TestPriorityIssue66514(t testing.T) { addDep := func(ws priorityWriteScheduler, child uint32, parent uint32) { ws.AdjustStream(child, PriorityParam{ StreamDep: parent, Exclusive: false, Weight: 16, }) } validateDepTree := func(ws priorityWriteScheduler, id uint32, t testing.T) { for n := ws.nodes[id]; n != nil; n = n.parent { if n.parent == nil { if n.id != uint32(0) { t.Errorf("detected nodes not parented to 0") } } } } ws := NewPriorityWriteScheduler(nil).(*priorityWriteScheduler) // Root entry addDep(ws, uint32(1), uint32(0)) addDep(ws, uint32(3), uint32(1)) addDep(ws, uint32(5), uint32(1)) for id := uint32(7); id < uint32(100); id += uint32(4) { addDep(ws, id, id-uint32(4)) addDep(ws, id+uint32(2), id-uint32(4)) validateDepTree(ws, id, t) } }	18.7 KB	2025-05-25 12:27
📄 writesched_random.go // Copyright 2014 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import "math" // NewRandomWriteScheduler constructs a WriteScheduler that ignores HTTP/2 // priorities. Control frames like SETTINGS and PING are written before DATA // frames, but if no control frames are queued and multiple streams have queued // HEADERS or DATA frames, Pop selects a ready stream arbitrarily. func NewRandomWriteScheduler() WriteScheduler { return &randomWriteScheduler{sq: make(map[uint32]writeQueue)} } type randomWriteScheduler struct { // zero are frames not associated with a specific stream. zero writeQueue // sq contains the stream-specific queues, keyed by stream ID. // When a stream is idle, closed, or emptied, it's deleted // from the map. sq map[uint32]writeQueue // pool of empty queues for reuse. queuePool writeQueuePool } func (ws randomWriteScheduler) OpenStream(streamID uint32, options OpenStreamOptions) { // no-op: idle streams are not tracked } func (ws randomWriteScheduler) CloseStream(streamID uint32) { q, ok := ws.sq[streamID] if !ok { return } delete(ws.sq, streamID) ws.queuePool.put(q) } func (ws randomWriteScheduler) AdjustStream(streamID uint32, priority PriorityParam) { // no-op: priorities are ignored } func (ws randomWriteScheduler) Push(wr FrameWriteRequest) { if wr.isControl() { ws.zero.push(wr) return } id := wr.StreamID() q, ok := ws.sq[id] if !ok { q = ws.queuePool.get() ws.sq[id] = q } q.push(wr) } func (ws *randomWriteScheduler) Pop() (FrameWriteRequest, bool) { // Control and RST_STREAM frames first. if !ws.zero.empty() { return ws.zero.shift(), true } // Iterate over all non-idle streams until finding one that can be consumed. for streamID, q := range ws.sq { if wr, ok := q.consume(math.MaxInt32); ok { if q.empty() { delete(ws.sq, streamID) ws.queuePool.put(q) } return wr, true } } return FrameWriteRequest{}, false }	2 KB	2025-05-25 12:27
📄 writesched_random_test.go // Copyright 2016 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import "testing" func TestRandomScheduler(t testing.T) { ws := NewRandomWriteScheduler() ws.Push(makeWriteHeadersRequest(3)) ws.Push(makeWriteHeadersRequest(4)) ws.Push(makeWriteHeadersRequest(1)) ws.Push(makeWriteHeadersRequest(2)) ws.Push(makeWriteNonStreamRequest()) ws.Push(makeWriteNonStreamRequest()) ws.Push(makeWriteRSTStream(1)) // Pop all frames. Should get the non-stream and RST stream requests first, // followed by the stream requests in any order. var order []FrameWriteRequest for { wr, ok := ws.Pop() if !ok { break } order = append(order, wr) } t.Logf("got frames: %v", order) if len(order) != 7 { t.Fatalf("got %d frames, expected 6", len(order)) } if order[0].StreamID() != 0 \|\| order[1].StreamID() != 0 { t.Fatal("expected non-stream frames first", order[0], order[1]) } if _, ok := order[2].write.(StreamError); !ok { t.Fatal("expected RST stream frames first", order[2]) } got := make(map[uint32]bool) for _, wr := range order[2:] { got[wr.StreamID()] = true } for id := uint32(1); id <= 4; id++ { if !got[id] { t.Errorf("frame not found for stream %d", id) } } // Verify that we clean up maps for empty queues in all cases (golang.org/issue/33812) const arbitraryStreamID = 123 ws.Push(makeHandlerPanicRST(arbitraryStreamID)) rws := ws.(randomWriteScheduler) if got, want := len(rws.sq), 1; got != want { t.Fatalf("len of 123 stream = %v; want %v", got, want) } _, ok := ws.Pop() if !ok { t.Fatal("expected to be able to Pop") } if got, want := len(rws.sq), 0; got != want { t.Fatalf("len of 123 stream = %v; want %v", got, want) } }	1.76 KB	2025-05-25 12:27
📄 writesched_roundrobin.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import ( "fmt" "math" ) type roundRobinWriteScheduler struct { // control contains control frames (SETTINGS, PING, etc.). control writeQueue // streams maps stream ID to a queue. streams map[uint32]writeQueue // stream queues are stored in a circular linked list. // head is the next stream to write, or nil if there are no streams open. head writeQueue // pool of empty queues for reuse. queuePool writeQueuePool } // newRoundRobinWriteScheduler constructs a new write scheduler. // The round robin scheduler priorizes control frames // like SETTINGS and PING over DATA frames. // When there are no control frames to send, it performs a round-robin // selection from the ready streams. func newRoundRobinWriteScheduler() WriteScheduler { ws := &roundRobinWriteScheduler{ streams: make(map[uint32]writeQueue), } return ws } func (ws roundRobinWriteScheduler) OpenStream(streamID uint32, options OpenStreamOptions) { if ws.streams[streamID] != nil { panic(fmt.Errorf("stream %d already opened", streamID)) } q := ws.queuePool.get() ws.streams[streamID] = q if ws.head == nil { ws.head = q q.next = q q.prev = q } else { // Queues are stored in a ring. // Insert the new stream before ws.head, putting it at the end of the list. q.prev = ws.head.prev q.next = ws.head q.prev.next = q q.next.prev = q } } func (ws roundRobinWriteScheduler) CloseStream(streamID uint32) { q := ws.streams[streamID] if q == nil { return } if q.next == q { // This was the only open stream. ws.head = nil } else { q.prev.next = q.next q.next.prev = q.prev if ws.head == q { ws.head = q.next } } delete(ws.streams, streamID) ws.queuePool.put(q) } func (ws roundRobinWriteScheduler) AdjustStream(streamID uint32, priority PriorityParam) {} func (ws roundRobinWriteScheduler) Push(wr FrameWriteRequest) { if wr.isControl() { ws.control.push(wr) return } q := ws.streams[wr.StreamID()] if q == nil { // This is a closed stream. // wr should not be a HEADERS or DATA frame. // We push the request onto the control queue. if wr.DataSize() > 0 { panic("add DATA on non-open stream") } ws.control.push(wr) return } q.push(wr) } func (ws roundRobinWriteScheduler) Pop() (FrameWriteRequest, bool) { // Control and RST_STREAM frames first. if !ws.control.empty() { return ws.control.shift(), true } if ws.head == nil { return FrameWriteRequest{}, false } q := ws.head for { if wr, ok := q.consume(math.MaxInt32); ok { ws.head = q.next return wr, true } q = q.next if q == ws.head { break } } return FrameWriteRequest{}, false }	2.75 KB	2025-05-25 12:27
📄 writesched_roundrobin_test.go // Copyright 2023 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import ( "reflect" "testing" ) func TestRoundRobinScheduler(t testing.T) { const maxFrameSize = 16 sc := &serverConn{maxFrameSize: maxFrameSize} ws := newRoundRobinWriteScheduler() streams := make([]stream, 4) for i := range streams { streamID := uint32(i) + 1 streams[i] = &stream{ id: streamID, sc: sc, } streams[i].flow.add(1 << 20) // arbitrary large value ws.OpenStream(streamID, OpenStreamOptions{}) wr := FrameWriteRequest{ write: &writeData{ streamID: streamID, p: make([]byte, maxFrameSize*(i+1)), endStream: false, }, stream: streams[i], } ws.Push(wr) } const controlFrames = 2 for i := 0; i < controlFrames; i++ { ws.Push(makeWriteNonStreamRequest()) } // We should get the control frames first. for i := 0; i < controlFrames; i++ { wr, ok := ws.Pop() if !ok \|\| wr.StreamID() != 0 { t.Fatalf("wr.Pop() = stream %v, %v; want 0, true", wr.StreamID(), ok) } } // Each stream should write maxFrameSize bytes until it runs out of data. // Stream 1 has one frame of data, 2 has two frames, etc. want := []uint32{1, 2, 3, 4, 2, 3, 4, 3, 4, 4} var got []uint32 for { wr, ok := ws.Pop() if !ok { break } if wr.DataSize() != maxFrameSize { t.Fatalf("wr.Pop() = %v data bytes, want %v", wr.DataSize(), maxFrameSize) } got = append(got, wr.StreamID()) } if !reflect.DeepEqual(got, want) { t.Fatalf("popped streams %v, want %v", got, want) } }	1.59 KB	2025-05-25 12:27
📄 writesched_test.go // Copyright 2016 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package http2 import ( "fmt" "math" "reflect" "testing" ) func makeWriteNonStreamRequest() FrameWriteRequest { return FrameWriteRequest{writeSettingsAck{}, nil, nil} } func makeWriteHeadersRequest(streamID uint32) FrameWriteRequest { st := &stream{id: streamID} return FrameWriteRequest{&writeResHeaders{streamID: streamID, httpResCode: 200}, st, nil} } func makeHandlerPanicRST(streamID uint32) FrameWriteRequest { st := &stream{id: streamID} return FrameWriteRequest{&handlerPanicRST{StreamID: streamID}, st, nil} } func makeWriteRSTStream(streamID uint32) FrameWriteRequest { return FrameWriteRequest{write: streamError(streamID, ErrCodeInternal)} } func checkConsume(wr FrameWriteRequest, nbytes int32, want []FrameWriteRequest) error { consumed, rest, n := wr.Consume(nbytes) var wantConsumed, wantRest FrameWriteRequest switch len(want) { case 0: case 1: wantConsumed = want[0] case 2: wantConsumed = want[0] wantRest = want[1] } if !reflect.DeepEqual(consumed, wantConsumed) \|\| !reflect.DeepEqual(rest, wantRest) \|\| n != len(want) { return fmt.Errorf("got %v, %v, %v\nwant %v, %v, %v", consumed, rest, n, wantConsumed, wantRest, len(want)) } return nil } func TestFrameWriteRequestNonData(t testing.T) { wr := makeWriteNonStreamRequest() if got, want := wr.DataSize(), 0; got != want { t.Errorf("DataSize: got %v, want %v", got, want) } // Non-DATA frames are always consumed whole. if err := checkConsume(wr, 0, []FrameWriteRequest{wr}); err != nil { t.Errorf("Consume:\n%v", err) } wr = makeWriteRSTStream(123) if got, want := wr.DataSize(), 0; got != want { t.Errorf("DataSize: got %v, want %v", got, want) } // RST_STREAM frames are always consumed whole. if err := checkConsume(wr, 0, []FrameWriteRequest{wr}); err != nil { t.Errorf("Consume:\n%v", err) } } // #49741 RST_STREAM and Control frames should have more priority than data // frames to avoid blocking streams caused by clients not able to drain the // queue. func TestFrameWriteRequestWithData(t testing.T) { st := &stream{ id: 1, sc: &serverConn{maxFrameSize: 16}, } const size = 32 wr := FrameWriteRequest{&writeData{st.id, make([]byte, size), true}, st, make(chan error)} if got, want := wr.DataSize(), size; got != want { t.Errorf("DataSize: got %v, want %v", got, want) } // No flow-control bytes available: cannot consume anything. if err := checkConsume(wr, math.MaxInt32, []FrameWriteRequest{}); err != nil { t.Errorf("Consume(limited by flow control):\n%v", err) } wr = makeWriteNonStreamRequest() if got, want := wr.DataSize(), 0; got != want { t.Errorf("DataSize: got %v, want %v", got, want) } // Non-DATA frames are always consumed whole. if err := checkConsume(wr, 0, []FrameWriteRequest{wr}); err != nil { t.Errorf("Consume:\n%v", err) } wr = makeWriteRSTStream(1) if got, want := wr.DataSize(), 0; got != want { t.Errorf("DataSize: got %v, want %v", got, want) } // RST_STREAM frames are always consumed whole. if err := checkConsume(wr, 0, []FrameWriteRequest{wr}); err != nil { t.Errorf("Consume:\n%v", err) } } func TestFrameWriteRequestData(t testing.T) { st := &stream{ id: 1, sc: &serverConn{maxFrameSize: 16}, } const size = 32 wr := FrameWriteRequest{&writeData{st.id, make([]byte, size), true}, st, make(chan error)} if got, want := wr.DataSize(), size; got != want { t.Errorf("DataSize: got %v, want %v", got, want) } // No flow-control bytes available: cannot consume anything. if err := checkConsume(wr, math.MaxInt32, []FrameWriteRequest{}); err != nil { t.Errorf("Consume(limited by flow control):\n%v", err) } // Add enough flow-control bytes to consume the entire frame, // but we're now restricted by st.sc.maxFrameSize. st.flow.add(size) want := []FrameWriteRequest{ { write: &writeData{st.id, make([]byte, st.sc.maxFrameSize), false}, stream: st, done: nil, }, { write: &writeData{st.id, make([]byte, size-st.sc.maxFrameSize), true}, stream: st, done: wr.done, }, } if err := checkConsume(wr, math.MaxInt32, want); err != nil { t.Errorf("Consume(limited by maxFrameSize):\n%v", err) } rest := want[1] // Consume 8 bytes from the remaining frame. want = []FrameWriteRequest{ { write: &writeData{st.id, make([]byte, 8), false}, stream: st, done: nil, }, { write: &writeData{st.id, make([]byte, size-st.sc.maxFrameSize-8), true}, stream: st, done: wr.done, }, } if err := checkConsume(rest, 8, want); err != nil { t.Errorf("Consume(8):\n%v", err) } rest = want[1] // Consume all remaining bytes. want = []FrameWriteRequest{ { write: &writeData{st.id, make([]byte, size-st.sc.maxFrameSize-8), true}, stream: st, done: wr.done, }, } if err := checkConsume(rest, math.MaxInt32, want); err != nil { t.Errorf("Consume(remainder):\n%v", err) } } func TestFrameWriteRequest_StreamID(t testing.T) { const streamID = 123 wr := FrameWriteRequest{write: streamError(streamID, ErrCodeNo)} if got := wr.StreamID(); got != streamID { t.Errorf("FrameWriteRequest(StreamError) = %v; want %v", got, streamID) } }	5.18 KB	2025-05-25 12:27

Edit File:

Terminal