// asciiEqualFold is strings.EqualFold, ASCII only. It reports whether s and t // are equal, ASCII-case-insensitively. func http2asciiEqualFold(s, t string) bool { … } // lower returns the ASCII lowercase version of b. func http2lower(b byte) byte { … } // isASCIIPrint returns whether s is ASCII and printable according to // https://tools.ietf.org/html/rfc20#section-4.2. func http2isASCIIPrint(s string) bool { … } // asciiToLower returns the lowercase version of s if s is ASCII and printable, // and whether or not it was. func http2asciiToLower(s string) (lower string, ok bool) { … } const http2cipher_TLS_NULL_WITH_NULL_NULL … const http2cipher_TLS_RSA_WITH_NULL_MD5 … const http2cipher_TLS_RSA_WITH_NULL_SHA … const http2cipher_TLS_RSA_EXPORT_WITH_RC4_40_MD5 … const http2cipher_TLS_RSA_WITH_RC4_128_MD5 … const http2cipher_TLS_RSA_WITH_RC4_128_SHA … const http2cipher_TLS_RSA_EXPORT_WITH_RC2_CBC_40_MD5 … const http2cipher_TLS_RSA_WITH_IDEA_CBC_SHA … const http2cipher_TLS_RSA_EXPORT_WITH_DES40_CBC_SHA … const http2cipher_TLS_RSA_WITH_DES_CBC_SHA … const http2cipher_TLS_RSA_WITH_3DES_EDE_CBC_SHA … const http2cipher_TLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHA … const http2cipher_TLS_DH_DSS_WITH_DES_CBC_SHA … const http2cipher_TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA … const http2cipher_TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA … const http2cipher_TLS_DH_RSA_WITH_DES_CBC_SHA … const http2cipher_TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA … const http2cipher_TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA … const http2cipher_TLS_DHE_DSS_WITH_DES_CBC_SHA … const http2cipher_TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA … const http2cipher_TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA … const http2cipher_TLS_DHE_RSA_WITH_DES_CBC_SHA … const http2cipher_TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA … const http2cipher_TLS_DH_anon_EXPORT_WITH_RC4_40_MD5 … const http2cipher_TLS_DH_anon_WITH_RC4_128_MD5 … const http2cipher_TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHA … const http2cipher_TLS_DH_anon_WITH_DES_CBC_SHA … const http2cipher_TLS_DH_anon_WITH_3DES_EDE_CBC_SHA … const http2cipher_TLS_KRB5_WITH_DES_CBC_SHA … const http2cipher_TLS_KRB5_WITH_3DES_EDE_CBC_SHA … const http2cipher_TLS_KRB5_WITH_RC4_128_SHA … const http2cipher_TLS_KRB5_WITH_IDEA_CBC_SHA … const http2cipher_TLS_KRB5_WITH_DES_CBC_MD5 … const http2cipher_TLS_KRB5_WITH_3DES_EDE_CBC_MD5 … const http2cipher_TLS_KRB5_WITH_RC4_128_MD5 … const http2cipher_TLS_KRB5_WITH_IDEA_CBC_MD5 … const http2cipher_TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA … const http2cipher_TLS_KRB5_EXPORT_WITH_RC2_CBC_40_SHA … const http2cipher_TLS_KRB5_EXPORT_WITH_RC4_40_SHA … const http2cipher_TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5 … const http2cipher_TLS_KRB5_EXPORT_WITH_RC2_CBC_40_MD5 … const http2cipher_TLS_KRB5_EXPORT_WITH_RC4_40_MD5 … const http2cipher_TLS_PSK_WITH_NULL_SHA … const http2cipher_TLS_DHE_PSK_WITH_NULL_SHA … const http2cipher_TLS_RSA_PSK_WITH_NULL_SHA … const http2cipher_TLS_RSA_WITH_AES_128_CBC_SHA … const http2cipher_TLS_DH_DSS_WITH_AES_128_CBC_SHA … const http2cipher_TLS_DH_RSA_WITH_AES_128_CBC_SHA … const http2cipher_TLS_DHE_DSS_WITH_AES_128_CBC_SHA … const http2cipher_TLS_DHE_RSA_WITH_AES_128_CBC_SHA … const http2cipher_TLS_DH_anon_WITH_AES_128_CBC_SHA … const http2cipher_TLS_RSA_WITH_AES_256_CBC_SHA … const http2cipher_TLS_DH_DSS_WITH_AES_256_CBC_SHA … const http2cipher_TLS_DH_RSA_WITH_AES_256_CBC_SHA … const http2cipher_TLS_DHE_DSS_WITH_AES_256_CBC_SHA … const http2cipher_TLS_DHE_RSA_WITH_AES_256_CBC_SHA … const http2cipher_TLS_DH_anon_WITH_AES_256_CBC_SHA … const http2cipher_TLS_RSA_WITH_NULL_SHA256 … const http2cipher_TLS_RSA_WITH_AES_128_CBC_SHA256 … const http2cipher_TLS_RSA_WITH_AES_256_CBC_SHA256 … const http2cipher_TLS_DH_DSS_WITH_AES_128_CBC_SHA256 … const http2cipher_TLS_DH_RSA_WITH_AES_128_CBC_SHA256 … const http2cipher_TLS_DHE_DSS_WITH_AES_128_CBC_SHA256 … const http2cipher_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA … const http2cipher_TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA … const http2cipher_TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA … const http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA … const http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA … const http2cipher_TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA … const http2cipher_TLS_DHE_RSA_WITH_AES_128_CBC_SHA256 … const http2cipher_TLS_DH_DSS_WITH_AES_256_CBC_SHA256 … const http2cipher_TLS_DH_RSA_WITH_AES_256_CBC_SHA256 … const http2cipher_TLS_DHE_DSS_WITH_AES_256_CBC_SHA256 … const http2cipher_TLS_DHE_RSA_WITH_AES_256_CBC_SHA256 … const http2cipher_TLS_DH_anon_WITH_AES_128_CBC_SHA256 … const http2cipher_TLS_DH_anon_WITH_AES_256_CBC_SHA256 … const http2cipher_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA … const http2cipher_TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA … const http2cipher_TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA … const http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA … const http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA … const http2cipher_TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA … const http2cipher_TLS_PSK_WITH_RC4_128_SHA … const http2cipher_TLS_PSK_WITH_3DES_EDE_CBC_SHA … const http2cipher_TLS_PSK_WITH_AES_128_CBC_SHA … const http2cipher_TLS_PSK_WITH_AES_256_CBC_SHA … const http2cipher_TLS_DHE_PSK_WITH_RC4_128_SHA … const http2cipher_TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA … const http2cipher_TLS_DHE_PSK_WITH_AES_128_CBC_SHA … const http2cipher_TLS_DHE_PSK_WITH_AES_256_CBC_SHA … const http2cipher_TLS_RSA_PSK_WITH_RC4_128_SHA … const http2cipher_TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA … const http2cipher_TLS_RSA_PSK_WITH_AES_128_CBC_SHA … const http2cipher_TLS_RSA_PSK_WITH_AES_256_CBC_SHA … const http2cipher_TLS_RSA_WITH_SEED_CBC_SHA … const http2cipher_TLS_DH_DSS_WITH_SEED_CBC_SHA … const http2cipher_TLS_DH_RSA_WITH_SEED_CBC_SHA … const http2cipher_TLS_DHE_DSS_WITH_SEED_CBC_SHA … const http2cipher_TLS_DHE_RSA_WITH_SEED_CBC_SHA … const http2cipher_TLS_DH_anon_WITH_SEED_CBC_SHA … const http2cipher_TLS_RSA_WITH_AES_128_GCM_SHA256 … const http2cipher_TLS_RSA_WITH_AES_256_GCM_SHA384 … const http2cipher_TLS_DHE_RSA_WITH_AES_128_GCM_SHA256 … const http2cipher_TLS_DHE_RSA_WITH_AES_256_GCM_SHA384 … const http2cipher_TLS_DH_RSA_WITH_AES_128_GCM_SHA256 … const http2cipher_TLS_DH_RSA_WITH_AES_256_GCM_SHA384 … const http2cipher_TLS_DHE_DSS_WITH_AES_128_GCM_SHA256 … const http2cipher_TLS_DHE_DSS_WITH_AES_256_GCM_SHA384 … const http2cipher_TLS_DH_DSS_WITH_AES_128_GCM_SHA256 … const http2cipher_TLS_DH_DSS_WITH_AES_256_GCM_SHA384 … const http2cipher_TLS_DH_anon_WITH_AES_128_GCM_SHA256 … const http2cipher_TLS_DH_anon_WITH_AES_256_GCM_SHA384 … const http2cipher_TLS_PSK_WITH_AES_128_GCM_SHA256 … const http2cipher_TLS_PSK_WITH_AES_256_GCM_SHA384 … const http2cipher_TLS_DHE_PSK_WITH_AES_128_GCM_SHA256 … const http2cipher_TLS_DHE_PSK_WITH_AES_256_GCM_SHA384 … const http2cipher_TLS_RSA_PSK_WITH_AES_128_GCM_SHA256 … const http2cipher_TLS_RSA_PSK_WITH_AES_256_GCM_SHA384 … const http2cipher_TLS_PSK_WITH_AES_128_CBC_SHA256 … const http2cipher_TLS_PSK_WITH_AES_256_CBC_SHA384 … const http2cipher_TLS_PSK_WITH_NULL_SHA256 … const http2cipher_TLS_PSK_WITH_NULL_SHA384 … const http2cipher_TLS_DHE_PSK_WITH_AES_128_CBC_SHA256 … const http2cipher_TLS_DHE_PSK_WITH_AES_256_CBC_SHA384 … const http2cipher_TLS_DHE_PSK_WITH_NULL_SHA256 … const http2cipher_TLS_DHE_PSK_WITH_NULL_SHA384 … const http2cipher_TLS_RSA_PSK_WITH_AES_128_CBC_SHA256 … const http2cipher_TLS_RSA_PSK_WITH_AES_256_CBC_SHA384 … const http2cipher_TLS_RSA_PSK_WITH_NULL_SHA256 … const http2cipher_TLS_RSA_PSK_WITH_NULL_SHA384 … const http2cipher_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256 … const http2cipher_TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256 … const http2cipher_TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256 … const http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256 … const http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 … const http2cipher_TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256 … const http2cipher_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256 … const http2cipher_TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256 … const http2cipher_TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256 … const http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256 … const http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256 … const http2cipher_TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256 … const http2cipher_TLS_EMPTY_RENEGOTIATION_INFO_SCSV … const http2cipher_TLS_FALLBACK_SCSV … const http2cipher_TLS_ECDH_ECDSA_WITH_NULL_SHA … const http2cipher_TLS_ECDH_ECDSA_WITH_RC4_128_SHA … const http2cipher_TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA … const http2cipher_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA … const http2cipher_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA … const http2cipher_TLS_ECDHE_ECDSA_WITH_NULL_SHA … const http2cipher_TLS_ECDHE_ECDSA_WITH_RC4_128_SHA … const http2cipher_TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA … const http2cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA … const http2cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA … const http2cipher_TLS_ECDH_RSA_WITH_NULL_SHA … const http2cipher_TLS_ECDH_RSA_WITH_RC4_128_SHA … const http2cipher_TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA … const http2cipher_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA … const http2cipher_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA … const http2cipher_TLS_ECDHE_RSA_WITH_NULL_SHA … const http2cipher_TLS_ECDHE_RSA_WITH_RC4_128_SHA … const http2cipher_TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA … const http2cipher_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA … const http2cipher_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA … const http2cipher_TLS_ECDH_anon_WITH_NULL_SHA … const http2cipher_TLS_ECDH_anon_WITH_RC4_128_SHA … const http2cipher_TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA … const http2cipher_TLS_ECDH_anon_WITH_AES_128_CBC_SHA … const http2cipher_TLS_ECDH_anon_WITH_AES_256_CBC_SHA … const http2cipher_TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA … const http2cipher_TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA … const http2cipher_TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA … const http2cipher_TLS_SRP_SHA_WITH_AES_128_CBC_SHA … const http2cipher_TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA … const http2cipher_TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA … const http2cipher_TLS_SRP_SHA_WITH_AES_256_CBC_SHA … const http2cipher_TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA … const http2cipher_TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA … const http2cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 … const http2cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 … const http2cipher_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256 … const http2cipher_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384 … const http2cipher_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 … const http2cipher_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 … const http2cipher_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256 … const http2cipher_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384 … const http2cipher_TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 … const http2cipher_TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 … const http2cipher_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256 … const http2cipher_TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384 … const http2cipher_TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 … const http2cipher_TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 … const http2cipher_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256 … const http2cipher_TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384 … const http2cipher_TLS_ECDHE_PSK_WITH_RC4_128_SHA … const http2cipher_TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA … const http2cipher_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA … const http2cipher_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA … const http2cipher_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256 … const http2cipher_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384 … const http2cipher_TLS_ECDHE_PSK_WITH_NULL_SHA … const http2cipher_TLS_ECDHE_PSK_WITH_NULL_SHA256 … const http2cipher_TLS_ECDHE_PSK_WITH_NULL_SHA384 … const http2cipher_TLS_RSA_WITH_ARIA_128_CBC_SHA256 … const http2cipher_TLS_RSA_WITH_ARIA_256_CBC_SHA384 … const http2cipher_TLS_DH_DSS_WITH_ARIA_128_CBC_SHA256 … const http2cipher_TLS_DH_DSS_WITH_ARIA_256_CBC_SHA384 … const http2cipher_TLS_DH_RSA_WITH_ARIA_128_CBC_SHA256 … const http2cipher_TLS_DH_RSA_WITH_ARIA_256_CBC_SHA384 … const http2cipher_TLS_DHE_DSS_WITH_ARIA_128_CBC_SHA256 … const http2cipher_TLS_DHE_DSS_WITH_ARIA_256_CBC_SHA384 … const http2cipher_TLS_DHE_RSA_WITH_ARIA_128_CBC_SHA256 … const http2cipher_TLS_DHE_RSA_WITH_ARIA_256_CBC_SHA384 … const http2cipher_TLS_DH_anon_WITH_ARIA_128_CBC_SHA256 … const http2cipher_TLS_DH_anon_WITH_ARIA_256_CBC_SHA384 … const http2cipher_TLS_ECDHE_ECDSA_WITH_ARIA_128_CBC_SHA256 … const http2cipher_TLS_ECDHE_ECDSA_WITH_ARIA_256_CBC_SHA384 … const http2cipher_TLS_ECDH_ECDSA_WITH_ARIA_128_CBC_SHA256 … const http2cipher_TLS_ECDH_ECDSA_WITH_ARIA_256_CBC_SHA384 … const http2cipher_TLS_ECDHE_RSA_WITH_ARIA_128_CBC_SHA256 … const http2cipher_TLS_ECDHE_RSA_WITH_ARIA_256_CBC_SHA384 … const http2cipher_TLS_ECDH_RSA_WITH_ARIA_128_CBC_SHA256 … const http2cipher_TLS_ECDH_RSA_WITH_ARIA_256_CBC_SHA384 … const http2cipher_TLS_RSA_WITH_ARIA_128_GCM_SHA256 … const http2cipher_TLS_RSA_WITH_ARIA_256_GCM_SHA384 … const http2cipher_TLS_DHE_RSA_WITH_ARIA_128_GCM_SHA256 … const http2cipher_TLS_DHE_RSA_WITH_ARIA_256_GCM_SHA384 … const http2cipher_TLS_DH_RSA_WITH_ARIA_128_GCM_SHA256 … const http2cipher_TLS_DH_RSA_WITH_ARIA_256_GCM_SHA384 … const http2cipher_TLS_DHE_DSS_WITH_ARIA_128_GCM_SHA256 … const http2cipher_TLS_DHE_DSS_WITH_ARIA_256_GCM_SHA384 … const http2cipher_TLS_DH_DSS_WITH_ARIA_128_GCM_SHA256 … const http2cipher_TLS_DH_DSS_WITH_ARIA_256_GCM_SHA384 … const http2cipher_TLS_DH_anon_WITH_ARIA_128_GCM_SHA256 … const http2cipher_TLS_DH_anon_WITH_ARIA_256_GCM_SHA384 … const http2cipher_TLS_ECDHE_ECDSA_WITH_ARIA_128_GCM_SHA256 … const http2cipher_TLS_ECDHE_ECDSA_WITH_ARIA_256_GCM_SHA384 … const http2cipher_TLS_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256 … const http2cipher_TLS_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384 … const http2cipher_TLS_ECDHE_RSA_WITH_ARIA_128_GCM_SHA256 … const http2cipher_TLS_ECDHE_RSA_WITH_ARIA_256_GCM_SHA384 … const http2cipher_TLS_ECDH_RSA_WITH_ARIA_128_GCM_SHA256 … const http2cipher_TLS_ECDH_RSA_WITH_ARIA_256_GCM_SHA384 … const http2cipher_TLS_PSK_WITH_ARIA_128_CBC_SHA256 … const http2cipher_TLS_PSK_WITH_ARIA_256_CBC_SHA384 … const http2cipher_TLS_DHE_PSK_WITH_ARIA_128_CBC_SHA256 … const http2cipher_TLS_DHE_PSK_WITH_ARIA_256_CBC_SHA384 … const http2cipher_TLS_RSA_PSK_WITH_ARIA_128_CBC_SHA256 … const http2cipher_TLS_RSA_PSK_WITH_ARIA_256_CBC_SHA384 … const http2cipher_TLS_PSK_WITH_ARIA_128_GCM_SHA256 … const http2cipher_TLS_PSK_WITH_ARIA_256_GCM_SHA384 … const http2cipher_TLS_DHE_PSK_WITH_ARIA_128_GCM_SHA256 … const http2cipher_TLS_DHE_PSK_WITH_ARIA_256_GCM_SHA384 … const http2cipher_TLS_RSA_PSK_WITH_ARIA_128_GCM_SHA256 … const http2cipher_TLS_RSA_PSK_WITH_ARIA_256_GCM_SHA384 … const http2cipher_TLS_ECDHE_PSK_WITH_ARIA_128_CBC_SHA256 … const http2cipher_TLS_ECDHE_PSK_WITH_ARIA_256_CBC_SHA384 … const http2cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 … const http2cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 … const http2cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256 … const http2cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384 … const http2cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256 … const http2cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384 … const http2cipher_TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256 … const http2cipher_TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384 … const http2cipher_TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256 … const http2cipher_TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384 … const http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_128_GCM_SHA256 … const http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_256_GCM_SHA384 … const http2cipher_TLS_DH_RSA_WITH_CAMELLIA_128_GCM_SHA256 … const http2cipher_TLS_DH_RSA_WITH_CAMELLIA_256_GCM_SHA384 … const http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_128_GCM_SHA256 … const http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_256_GCM_SHA384 … const http2cipher_TLS_DH_DSS_WITH_CAMELLIA_128_GCM_SHA256 … const http2cipher_TLS_DH_DSS_WITH_CAMELLIA_256_GCM_SHA384 … const http2cipher_TLS_DH_anon_WITH_CAMELLIA_128_GCM_SHA256 … const http2cipher_TLS_DH_anon_WITH_CAMELLIA_256_GCM_SHA384 … const http2cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_GCM_SHA256 … const http2cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_GCM_SHA384 … const http2cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256 … const http2cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384 … const http2cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_128_GCM_SHA256 … const http2cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_256_GCM_SHA384 … const http2cipher_TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256 … const http2cipher_TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384 … const http2cipher_TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256 … const http2cipher_TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384 … const http2cipher_TLS_DHE_PSK_WITH_CAMELLIA_128_GCM_SHA256 … const http2cipher_TLS_DHE_PSK_WITH_CAMELLIA_256_GCM_SHA384 … const http2cipher_TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256 … const http2cipher_TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384 … const http2cipher_TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256 … const http2cipher_TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384 … const http2cipher_TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 … const http2cipher_TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 … const http2cipher_TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256 … const http2cipher_TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384 … const http2cipher_TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256 … const http2cipher_TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384 … const http2cipher_TLS_RSA_WITH_AES_128_CCM … const http2cipher_TLS_RSA_WITH_AES_256_CCM … const http2cipher_TLS_DHE_RSA_WITH_AES_128_CCM … const http2cipher_TLS_DHE_RSA_WITH_AES_256_CCM … const http2cipher_TLS_RSA_WITH_AES_128_CCM_8 … const http2cipher_TLS_RSA_WITH_AES_256_CCM_8 … const http2cipher_TLS_DHE_RSA_WITH_AES_128_CCM_8 … const http2cipher_TLS_DHE_RSA_WITH_AES_256_CCM_8 … const http2cipher_TLS_PSK_WITH_AES_128_CCM … const http2cipher_TLS_PSK_WITH_AES_256_CCM … const http2cipher_TLS_DHE_PSK_WITH_AES_128_CCM … const http2cipher_TLS_DHE_PSK_WITH_AES_256_CCM … const http2cipher_TLS_PSK_WITH_AES_128_CCM_8 … const http2cipher_TLS_PSK_WITH_AES_256_CCM_8 … const http2cipher_TLS_PSK_DHE_WITH_AES_128_CCM_8 … const http2cipher_TLS_PSK_DHE_WITH_AES_256_CCM_8 … const http2cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CCM … const http2cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CCM … const http2cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CCM_8 … const http2cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CCM_8 … const http2cipher_TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 … const http2cipher_TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 … const http2cipher_TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256 … const http2cipher_TLS_PSK_WITH_CHACHA20_POLY1305_SHA256 … const http2cipher_TLS_ECDHE_PSK_WITH_CHACHA20_POLY1305_SHA256 … const http2cipher_TLS_DHE_PSK_WITH_CHACHA20_POLY1305_SHA256 … const http2cipher_TLS_RSA_PSK_WITH_CHACHA20_POLY1305_SHA256 … // 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 http2isBadCipher(cipher uint16) bool { … } type http2ClientConnPool … type http2clientConnPoolIdleCloser … var _ … var _ … type http2clientConnPool … func (p *http2clientConnPool) GetClientConn(req *Request, addr string) (*http2ClientConn, error) { … } const http2dialOnMiss … const http2noDialOnMiss … func (p *http2clientConnPool) getClientConn(req *Request, addr string, dialOnMiss bool) (*http2ClientConn, error) { … } type http2dialCall … // requires p.mu is held. func (p *http2clientConnPool) getStartDialLocked(ctx context.Context, addr string) *http2dialCall { … } // run in its own goroutine. func (c *http2dialCall) dial(ctx context.Context, addr string) { … } // 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 *http2clientConnPool) addConnIfNeeded(key string, t *http2Transport, c *tls.Conn) (used bool, err error) { … } type http2addConnCall … func (c *http2addConnCall) run(t *http2Transport, key string, tc *tls.Conn) { … } // p.mu must be held func (p *http2clientConnPool) addConnLocked(key string, cc *http2ClientConn) { … } func (p *http2clientConnPool) MarkDead(cc *http2ClientConn) { … } func (p *http2clientConnPool) closeIdleConnections() { … } func http2filterOutClientConn(in []*http2ClientConn, exclude *http2ClientConn) []*http2ClientConn { … } type http2noDialClientConnPool … func (p http2noDialClientConnPool) GetClientConn(req *Request, addr string) (*http2ClientConn, error) { … } // 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 http2shouldRetryDial(call *http2dialCall, req *Request) bool { … } var http2dataChunkPools … func http2getDataBufferChunk(size int64) []byte { … } func http2putDataBufferChunk(p []byte) { … } type http2dataBuffer … var http2errReadEmpty … // Read copies bytes from the buffer into p. // It is an error to read when no data is available. func (b *http2dataBuffer) Read(p []byte) (int, error) { … } func (b *http2dataBuffer) bytesFromFirstChunk() []byte { … } // Len returns the number of bytes of the unread portion of the buffer. func (b *http2dataBuffer) Len() int { … } // Write appends p to the buffer. func (b *http2dataBuffer) Write(p []byte) (int, error) { … } func (b *http2dataBuffer) lastChunkOrAlloc(want int64) []byte { … } type http2ErrCode … const http2ErrCodeNo … const http2ErrCodeProtocol … const http2ErrCodeInternal … const http2ErrCodeFlowControl … const http2ErrCodeSettingsTimeout … const http2ErrCodeStreamClosed … const http2ErrCodeFrameSize … const http2ErrCodeRefusedStream … const http2ErrCodeCancel … const http2ErrCodeCompression … const http2ErrCodeConnect … const http2ErrCodeEnhanceYourCalm … const http2ErrCodeInadequateSecurity … const http2ErrCodeHTTP11Required … var http2errCodeName … func (e http2ErrCode) String() string { … } func (e http2ErrCode) stringToken() string { … } type http2ConnectionError … func (e http2ConnectionError) Error() string { … } type http2StreamError … var http2errFromPeer … func http2streamError(id uint32, code http2ErrCode) http2StreamError { … } func (e http2StreamError) Error() string { … } type http2goAwayFlowError … func (http2goAwayFlowError) Error() string { … } type http2connError … func (e http2connError) Error() string { … } type http2pseudoHeaderError … func (e http2pseudoHeaderError) Error() string { … } type http2duplicatePseudoHeaderError … func (e http2duplicatePseudoHeaderError) Error() string { … } type http2headerFieldNameError … func (e http2headerFieldNameError) Error() string { … } type http2headerFieldValueError … func (e http2headerFieldValueError) Error() string { … } var http2errMixPseudoHeaderTypes … var http2errPseudoAfterRegular … const http2inflowMinRefresh … type http2inflow … // init sets the initial window. func (f *http2inflow) init(n int32) { … } // 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 *http2inflow) add(n int) (connAdd int32) { … } // take attempts to take n bytes from the peer's flow control window. // It reports whether the window has available capacity. func (f *http2inflow) take(n uint32) bool { … } // 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 http2takeInflows(f1, f2 *http2inflow, n uint32) bool { … } type http2outflow … func (f *http2outflow) setConnFlow(cf *http2outflow) { … } func (f *http2outflow) available() int32 { … } func (f *http2outflow) take(n int32) { … } // 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 *http2outflow) add(n int32) bool { … } const http2frameHeaderLen … var http2padZeros … type http2FrameType … const http2FrameData … const http2FrameHeaders … const http2FramePriority … const http2FrameRSTStream … const http2FrameSettings … const http2FramePushPromise … const http2FramePing … const http2FrameGoAway … const http2FrameWindowUpdate … const http2FrameContinuation … var http2frameName … func (t http2FrameType) String() string { … } type http2Flags … // Has reports whether f contains all (0 or more) flags in v. func (f http2Flags) Has(v http2Flags) bool { … } const http2FlagDataEndStream … const http2FlagDataPadded … const http2FlagHeadersEndStream … const http2FlagHeadersEndHeaders … const http2FlagHeadersPadded … const http2FlagHeadersPriority … const http2FlagSettingsAck … const http2FlagPingAck … const http2FlagContinuationEndHeaders … const http2FlagPushPromiseEndHeaders … const http2FlagPushPromisePadded … var http2flagName … type http2frameParser … var http2frameParsers … func http2typeFrameParser(t http2FrameType) http2frameParser { … } type http2FrameHeader … // Header returns h. It exists so FrameHeaders can be embedded in other // specific frame types and implement the Frame interface. func (h http2FrameHeader) Header() http2FrameHeader { … } func (h http2FrameHeader) String() string { … } func (h http2FrameHeader) writeDebug(buf *bytes.Buffer) { … } func (h *http2FrameHeader) checkValid() { … } func (h *http2FrameHeader) invalidate() { … } var http2fhBytes … // ReadFrameHeader reads 9 bytes from r and returns a FrameHeader. // Most users should use Framer.ReadFrame instead. func http2ReadFrameHeader(r io.Reader) (http2FrameHeader, error) { … } func http2readFrameHeader(buf []byte, r io.Reader) (http2FrameHeader, error) { … } type http2Frame … type http2Framer … func (fr *http2Framer) maxHeaderListSize() uint32 { … } func (f *http2Framer) startWrite(ftype http2FrameType, flags http2Flags, streamID uint32) { … } func (f *http2Framer) endWrite() error { … } func (f *http2Framer) logWrite() { … } func (f *http2Framer) writeByte(v byte) { … } func (f *http2Framer) writeBytes(v []byte) { … } func (f *http2Framer) writeUint16(v uint16) { … } func (f *http2Framer) writeUint32(v uint32) { … } const http2minMaxFrameSize … const http2maxFrameSize … // 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 *http2Framer) SetReuseFrames() { … } type http2frameCache … func (fc *http2frameCache) getDataFrame() *http2DataFrame { … } // NewFramer returns a Framer that writes frames to w and reads them from r. func http2NewFramer(w io.Writer, r io.Reader) *http2Framer { … } // 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 *http2Framer) SetMaxReadFrameSize(v uint32) { … } // 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 *http2Framer) ErrorDetail() error { … } var http2ErrFrameTooLarge … // terminalReadFrameError reports whether err is an unrecoverable // error from ReadFrame and no other frames should be read. func http2terminalReadFrameError(err error) bool { … } // 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 *http2Framer) ReadFrame() (http2Frame, error) { … } // 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 *http2Framer) connError(code http2ErrCode, reason string) error { … } // 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 *http2Framer) checkFrameOrder(f http2Frame) error { … } type http2DataFrame … func (f *http2DataFrame) StreamEnded() bool { … } // 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 *http2DataFrame) Data() []byte { … } func http2parseDataFrame(fc *http2frameCache, fh http2FrameHeader, countError func(string), payload []byte) (http2Frame, error) { … } var http2errStreamID … var http2errDepStreamID … var http2errPadLength … var http2errPadBytes … func http2validStreamIDOrZero(streamID uint32) bool { … } func http2validStreamID(streamID uint32) bool { … } // 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 *http2Framer) WriteData(streamID uint32, endStream bool, data []byte) error { … } // 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 *http2Framer) WriteDataPadded(streamID uint32, endStream bool, data, pad []byte) error { … } // 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 *http2Framer) startWriteDataPadded(streamID uint32, endStream bool, data, pad []byte) error { … } type http2SettingsFrame … func http2parseSettingsFrame(_ *http2frameCache, fh http2FrameHeader, countError func(string), p []byte) (http2Frame, error) { … } func (f *http2SettingsFrame) IsAck() bool { … } func (f *http2SettingsFrame) Value(id http2SettingID) (v uint32, ok bool) { … } // 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 *http2SettingsFrame) Setting(i int) http2Setting { … } func (f *http2SettingsFrame) NumSettings() int { … } // HasDuplicates reports whether f contains any duplicate setting IDs. func (f *http2SettingsFrame) HasDuplicates() bool { … } // ForeachSetting runs fn for each setting. // It stops and returns the first error. func (f *http2SettingsFrame) ForeachSetting(fn func(http2Setting) error) error { … } // 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 *http2Framer) WriteSettings(settings ...http2Setting) error { … } // 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 *http2Framer) WriteSettingsAck() error { … } type http2PingFrame … func (f *http2PingFrame) IsAck() bool { … } func http2parsePingFrame(_ *http2frameCache, fh http2FrameHeader, countError func(string), payload []byte) (http2Frame, error) { … } func (f *http2Framer) WritePing(ack bool, data [8]byte) error { … } type http2GoAwayFrame … // 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 *http2GoAwayFrame) DebugData() []byte { … } func http2parseGoAwayFrame(_ *http2frameCache, fh http2FrameHeader, countError func(string), p []byte) (http2Frame, error) { … } func (f *http2Framer) WriteGoAway(maxStreamID uint32, code http2ErrCode, debugData []byte) error { … } type http2UnknownFrame … // 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 *http2UnknownFrame) Payload() []byte { … } func http2parseUnknownFrame(_ *http2frameCache, fh http2FrameHeader, countError func(string), p []byte) (http2Frame, error) { … } type http2WindowUpdateFrame … func http2parseWindowUpdateFrame(_ *http2frameCache, fh http2FrameHeader, countError func(string), p []byte) (http2Frame, error) { … } // 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 *http2Framer) WriteWindowUpdate(streamID, incr uint32) error { … } type http2HeadersFrame … func (f *http2HeadersFrame) HeaderBlockFragment() []byte { … } func (f *http2HeadersFrame) HeadersEnded() bool { … } func (f *http2HeadersFrame) StreamEnded() bool { … } func (f *http2HeadersFrame) HasPriority() bool { … } func http2parseHeadersFrame(_ *http2frameCache, fh http2FrameHeader, countError func(string), p []byte) (_ http2Frame, err error) { … } type http2HeadersFrameParam … // 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 *http2Framer) WriteHeaders(p http2HeadersFrameParam) error { … } type http2PriorityFrame … type http2PriorityParam … func (p http2PriorityParam) IsZero() bool { … } func http2parsePriorityFrame(_ *http2frameCache, fh http2FrameHeader, countError func(string), payload []byte) (http2Frame, error) { … } // 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 *http2Framer) WritePriority(streamID uint32, p http2PriorityParam) error { … } type http2RSTStreamFrame … func http2parseRSTStreamFrame(_ *http2frameCache, fh http2FrameHeader, countError func(string), p []byte) (http2Frame, error) { … } // 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 *http2Framer) WriteRSTStream(streamID uint32, code http2ErrCode) error { … } type http2ContinuationFrame … func http2parseContinuationFrame(_ *http2frameCache, fh http2FrameHeader, countError func(string), p []byte) (http2Frame, error) { … } func (f *http2ContinuationFrame) HeaderBlockFragment() []byte { … } func (f *http2ContinuationFrame) HeadersEnded() bool { … } // 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 *http2Framer) WriteContinuation(streamID uint32, endHeaders bool, headerBlockFragment []byte) error { … } type http2PushPromiseFrame … func (f *http2PushPromiseFrame) HeaderBlockFragment() []byte { … } func (f *http2PushPromiseFrame) HeadersEnded() bool { … } func http2parsePushPromise(_ *http2frameCache, fh http2FrameHeader, countError func(string), p []byte) (_ http2Frame, err error) { … } type http2PushPromiseParam … // 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 *http2Framer) WritePushPromise(p http2PushPromiseParam) error { … } // WriteRawFrame writes a raw frame. This can be used to write // extension frames unknown to this package. func (f *http2Framer) WriteRawFrame(t http2FrameType, flags http2Flags, streamID uint32, payload []byte) error { … } func http2readByte(p []byte) (remain []byte, b byte, err error) { … } func http2readUint32(p []byte) (remain []byte, v uint32, err error) { … } type http2streamEnder … type http2headersEnder … type http2headersOrContinuation … type http2MetaHeadersFrame … // PseudoValue returns the given pseudo header field's value. // The provided pseudo field should not contain the leading colon. func (mh *http2MetaHeadersFrame) PseudoValue(pseudo string) string { … } // RegularFields returns the regular (non-pseudo) header fields of mh. // The caller does not own the returned slice. func (mh *http2MetaHeadersFrame) RegularFields() []hpack.HeaderField { … } // PseudoFields returns the pseudo header fields of mh. // The caller does not own the returned slice. func (mh *http2MetaHeadersFrame) PseudoFields() []hpack.HeaderField { … } func (mh *http2MetaHeadersFrame) checkPseudos() error { … } func (fr *http2Framer) maxHeaderStringLen() int { … } // 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 *http2Framer) readMetaFrame(hf *http2HeadersFrame) (http2Frame, error) { … } func http2summarizeFrame(f http2Frame) string { … } var http2DebugGoroutines … type http2goroutineLock … func http2newGoroutineLock() http2goroutineLock { … } func (g http2goroutineLock) check() { … } func (g http2goroutineLock) checkNotOn() { … } var http2goroutineSpace … func http2curGoroutineID() uint64 { … } var http2littleBuf … // parseUintBytes is like strconv.ParseUint, but using a []byte. func http2parseUintBytes(s []byte, base int, bitSize int) (n uint64, err error) { … } // Return the first number n such that n*base >= 1<<64. func http2cutoff64(base int) uint64 { … } var http2commonBuildOnce … var http2commonLowerHeader … var http2commonCanonHeader … func http2buildCommonHeaderMapsOnce() { … } func http2buildCommonHeaderMaps() { … } func http2lowerHeader(v string) (lower string, ascii bool) { … } func http2canonicalHeader(v string) string { … } var http2VerboseLogs … var http2logFrameWrites … var http2logFrameReads … var http2inTests … func init() { … } const http2ClientPreface … const http2initialMaxFrameSize … const http2NextProtoTLS … const http2initialHeaderTableSize … const http2initialWindowSize … const http2defaultMaxReadFrameSize … var http2clientPreface … type http2streamState … const http2stateIdle … const http2stateOpen … const http2stateHalfClosedLocal … const http2stateHalfClosedRemote … const http2stateClosed … var http2stateName … func (st http2streamState) String() string { … } type http2Setting … func (s http2Setting) String() string { … } // Valid reports whether the setting is valid. func (s http2Setting) Valid() error { … } type http2SettingID … const http2SettingHeaderTableSize … const http2SettingEnablePush … const http2SettingMaxConcurrentStreams … const http2SettingInitialWindowSize … const http2SettingMaxFrameSize … const http2SettingMaxHeaderListSize … var http2settingName … func (s http2SettingID) String() string { … } // 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 http2validWireHeaderFieldName(v string) bool { … } func http2httpCodeString(code int) string { … } type http2stringWriter … type http2closeWaiter … // 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 *http2closeWaiter) Init() { … } // Close marks the closeWaiter as closed and unblocks any waiters. func (cw http2closeWaiter) Close() { … } // Wait waits for the closeWaiter to become closed. func (cw http2closeWaiter) Wait() { … } type http2bufferedWriter … func http2newBufferedWriter(w io.Writer) *http2bufferedWriter { … } const http2bufWriterPoolBufferSize … var http2bufWriterPool … func (w *http2bufferedWriter) Available() int { … } func (w *http2bufferedWriter) Write(p []byte) (n int, err error) { … } func (w *http2bufferedWriter) Flush() error { … } func http2mustUint31(v int32) uint32 { … } // bodyAllowedForStatus reports whether a given response status code // permits a body. See RFC 7230, section 3.3. func http2bodyAllowedForStatus(status int) bool { … } type http2httpError … func (e *http2httpError) Error() string { … } func (e *http2httpError) Timeout() bool { … } func (e *http2httpError) Temporary() bool { … } var http2errTimeout … type http2connectionStater … var http2sorterPool … type http2sorter … func (s *http2sorter) Len() int { … } func (s *http2sorter) Swap(i, j int) { … } func (s *http2sorter) Less(i, j int) bool { … } // Keys returns the sorted keys of h. // // The returned slice is only valid until s used again or returned to // its pool. func (s *http2sorter) Keys(h Header) []string { … } func (s *http2sorter) SortStrings(ss []string) { … } // 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 http2validPseudoPath(v string) bool { … } type http2incomparable … type http2synctestGroupInterface … type http2pipe … type http2pipeBuffer … // setBuffer initializes the pipe buffer. // It has no effect if the pipe is already closed. func (p *http2pipe) setBuffer(b http2pipeBuffer) { … } func (p *http2pipe) Len() int { … } // Read waits until data is available and copies bytes // from the buffer into p. func (p *http2pipe) Read(d []byte) (n int, err error) { … } var http2errClosedPipeWrite … var http2errUninitializedPipeWrite … // 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 *http2pipe) Write(d []byte) (n int, err error) { … } // 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 *http2pipe) CloseWithError(err error) { … } // 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 *http2pipe) BreakWithError(err error) { … } // closeWithErrorAndCode is like CloseWithError but also sets some code to run // in the caller's goroutine before returning the error. func (p *http2pipe) closeWithErrorAndCode(err error, fn func()) { … } func (p *http2pipe) closeWithError(dst *error, err error, fn func()) { … } // requires p.mu be held. func (p *http2pipe) closeDoneLocked() { … } // Err returns the error (if any) first set by BreakWithError or CloseWithError. func (p *http2pipe) Err() error { … } // Done returns a channel which is closed if and when this pipe is closed // with CloseWithError. func (p *http2pipe) Done() <-chan struct{ … } const http2prefaceTimeout … const http2firstSettingsTimeout … const http2handlerChunkWriteSize … const http2defaultMaxStreams … const http2maxQueuedControlFrames … var http2errClientDisconnected … var http2errClosedBody … var http2errHandlerComplete … var http2errStreamClosed … var http2responseWriterStatePool … var http2testHookOnConn … var http2testHookGetServerConn … var http2testHookOnPanicMu … var http2testHookOnPanic … type http2Server … func (s *http2Server) markNewGoroutine() { … } func (s *http2Server) now() time.Time { … } // newTimer creates a new time.Timer, or a synthetic timer in tests. func (s *http2Server) newTimer(d time.Duration) http2timer { … } // afterFunc creates a new time.AfterFunc timer, or a synthetic timer in tests. func (s *http2Server) afterFunc(d time.Duration, f func()) http2timer { … } func (s *http2Server) initialConnRecvWindowSize() int32 { … } func (s *http2Server) initialStreamRecvWindowSize() int32 { … } func (s *http2Server) maxReadFrameSize() uint32 { … } func (s *http2Server) maxConcurrentStreams() uint32 { … } func (s *http2Server) maxDecoderHeaderTableSize() uint32 { … } func (s *http2Server) maxEncoderHeaderTableSize() uint32 { … } // 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. func (s *http2Server) maxQueuedControlFrames() int { … } type http2serverInternalState … func (s *http2serverInternalState) registerConn(sc *http2serverConn) { … } func (s *http2serverInternalState) unregisterConn(sc *http2serverConn) { … } func (s *http2serverInternalState) startGracefulShutdown() { … } // 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 http2ConfigureServer(s *Server, conf *http2Server) error { … } type http2ServeConnOpts … func (o *http2ServeConnOpts) context() context.Context { … } func (o *http2ServeConnOpts) baseConfig() *Server { … } func (o *http2ServeConnOpts) handler() Handler { … } // 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 *http2Server) ServeConn(c net.Conn, opts *http2ServeConnOpts) { … } func (s *http2Server) serveConn(c net.Conn, opts *http2ServeConnOpts, newf func(*http2serverConn)) { … } func http2serverConnBaseContext(c net.Conn, opts *http2ServeConnOpts) (ctx context.Context, cancel func()) { … } func (sc *http2serverConn) rejectConn(err http2ErrCode, debug string) { … } type http2serverConn … func (sc *http2serverConn) maxHeaderListSize() uint32 { … } func (sc *http2serverConn) curOpenStreams() uint32 { … } type http2stream … func (sc *http2serverConn) Framer() *http2Framer { … } func (sc *http2serverConn) CloseConn() error { … } func (sc *http2serverConn) Flush() error { … } func (sc *http2serverConn) HeaderEncoder() (*hpack.Encoder, *bytes.Buffer) { … } func (sc *http2serverConn) state(streamID uint32) (http2streamState, *http2stream) { … } // 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 *http2serverConn) setConnState(state ConnState) { … } func (sc *http2serverConn) vlogf(format string, args ...interface{ … } func (sc *http2serverConn) logf(format string, args ...interface{ … } // errno returns v's underlying uintptr, else 0. // // TODO: remove this helper function once http2 can use build // tags. See comment in isClosedConnError. func http2errno(v error) uintptr { … } // isClosedConnError reports whether err is an error from use of a closed // network connection. func http2isClosedConnError(err error) bool { … } func (sc *http2serverConn) condlogf(err error, format string, args ...interface{ … } const http2maxCachedCanonicalHeadersKeysSize … func (sc *http2serverConn) canonicalHeader(v string) string { … } type http2readFrameResult … // 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 *http2serverConn) readFrames() { … } type http2frameWriteResult … // 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 *http2serverConn) writeFrameAsync(wr http2FrameWriteRequest, wd *http2writeData) { … } func (sc *http2serverConn) closeAllStreamsOnConnClose() { … } func (sc *http2serverConn) stopShutdownTimer() { … } func (sc *http2serverConn) notePanic() { … } func (sc *http2serverConn) serve() { … } type http2serverMessage … var http2settingsTimerMsg … var http2idleTimerMsg … var http2shutdownTimerMsg … var http2gracefulShutdownMsg … var http2handlerDoneMsg … func (sc *http2serverConn) onSettingsTimer() { … } func (sc *http2serverConn) onIdleTimer() { … } func (sc *http2serverConn) onShutdownTimer() { … } func (sc *http2serverConn) sendServeMsg(msg interface{ … } var http2errPrefaceTimeout … // readPreface reads the ClientPreface greeting from the peer or // returns errPrefaceTimeout on timeout, or an error if the greeting // is invalid. func (sc *http2serverConn) readPreface() error { … } var http2errChanPool … var http2writeDataPool … // writeDataFromHandler writes DATA response frames from a handler on // the given stream. func (sc *http2serverConn) writeDataFromHandler(stream *http2stream, data []byte, endStream bool) error { … } // 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 *http2serverConn) writeFrameFromHandler(wr http2FrameWriteRequest) error { … } // 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 *http2serverConn) writeFrame(wr http2FrameWriteRequest) { … } // 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 *http2serverConn) startFrameWrite(wr http2FrameWriteRequest) { … } var http2errHandlerPanicked … // wroteFrame is called on the serve goroutine with the result of // whatever happened on writeFrameAsync. func (sc *http2serverConn) wroteFrame(res http2frameWriteResult) { … } // 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 *http2serverConn) scheduleFrameWrite() { … } // 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 *http2serverConn) startGracefulShutdown() { … } var http2goAwayTimeout … func (sc *http2serverConn) startGracefulShutdownInternal() { … } func (sc *http2serverConn) goAway(code http2ErrCode) { … } func (sc *http2serverConn) shutDownIn(d time.Duration) { … } func (sc *http2serverConn) resetStream(se http2StreamError) { … } // 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 *http2serverConn) processFrameFromReader(res http2readFrameResult) bool { … } func (sc *http2serverConn) processFrame(f http2Frame) error { … } func (sc *http2serverConn) processPing(f *http2PingFrame) error { … } func (sc *http2serverConn) processWindowUpdate(f *http2WindowUpdateFrame) error { … } func (sc *http2serverConn) processResetStream(f *http2RSTStreamFrame) error { … } func (sc *http2serverConn) closeStream(st *http2stream, err error) { … } func (sc *http2serverConn) processSettings(f *http2SettingsFrame) error { … } func (sc *http2serverConn) processSetting(s http2Setting) error { … } func (sc *http2serverConn) processSettingInitialWindowSize(val uint32) error { … } func (sc *http2serverConn) processData(f *http2DataFrame) error { … } func (sc *http2serverConn) processGoAway(f *http2GoAwayFrame) error { … } // isPushed reports whether the stream is server-initiated. func (st *http2stream) isPushed() bool { … } // 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 *http2stream) endStream() { … } // copyTrailersToHandlerRequest is run in the Handler's goroutine in // its Request.Body.Read just before it gets io.EOF. func (st *http2stream) copyTrailersToHandlerRequest() { … } // onReadTimeout is run on its own goroutine (from time.AfterFunc) // when the stream's ReadTimeout has fired. func (st *http2stream) onReadTimeout() { … } // onWriteTimeout is run on its own goroutine (from time.AfterFunc) // when the stream's WriteTimeout has fired. func (st *http2stream) onWriteTimeout() { … } func (sc *http2serverConn) processHeaders(f *http2MetaHeadersFrame) error { … } func (sc *http2serverConn) upgradeRequest(req *Request) { … } func (st *http2stream) processTrailerHeaders(f *http2MetaHeadersFrame) error { … } func (sc *http2serverConn) checkPriority(streamID uint32, p http2PriorityParam) error { … } func (sc *http2serverConn) processPriority(f *http2PriorityFrame) error { … } func (sc *http2serverConn) newStream(id, pusherID uint32, state http2streamState) *http2stream { … } func (sc *http2serverConn) newWriterAndRequest(st *http2stream, f *http2MetaHeadersFrame) (*http2responseWriter, *Request, error) { … } type http2requestParam … func (sc *http2serverConn) newWriterAndRequestNoBody(st *http2stream, rp http2requestParam) (*http2responseWriter, *Request, error) { … } func (sc *http2serverConn) newResponseWriter(st *http2stream, req *Request) *http2responseWriter { … } type http2unstartedHandler … // scheduleHandler starts a handler goroutine, // or schedules one to start as soon as an existing handler finishes. func (sc *http2serverConn) scheduleHandler(streamID uint32, rw *http2responseWriter, req *Request, handler func(ResponseWriter, *Request)) error { … } func (sc *http2serverConn) handlerDone() { … } // Run on its own goroutine. func (sc *http2serverConn) runHandler(rw *http2responseWriter, req *Request, handler func(ResponseWriter, *Request)) { … } func http2handleHeaderListTooLong(w ResponseWriter, r *Request) { … } // called from handler goroutines. // h may be nil. func (sc *http2serverConn) writeHeaders(st *http2stream, headerData *http2writeResHeaders) error { … } // called from handler goroutines. func (sc *http2serverConn) write100ContinueHeaders(st *http2stream) { … } type http2bodyReadMsg … // 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 *http2serverConn) noteBodyReadFromHandler(st *http2stream, n int, err error) { … } func (sc *http2serverConn) noteBodyRead(st *http2stream, n int) { … } // st may be nil for conn-level func (sc *http2serverConn) sendWindowUpdate32(st *http2stream, n int32) { … } // st may be nil for conn-level func (sc *http2serverConn) sendWindowUpdate(st *http2stream, n int) { … } type http2requestBody … func (b *http2requestBody) Close() error { … } func (b *http2requestBody) Read(p []byte) (n int, err error) { … } type http2responseWriter … var _ … var _ … var _ … type http2responseWriterState … type http2chunkWriter … func (cw http2chunkWriter) Write(p []byte) (n int, err error) { … } func (rws *http2responseWriterState) hasTrailers() bool { … } func (rws *http2responseWriterState) hasNonemptyTrailers() bool { … } // 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 *http2responseWriterState) declareTrailer(k string) { … } // 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 *http2responseWriterState) writeChunk(p []byte) (n int, err error) { … } const http2TrailerPrefix … // 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 *http2responseWriterState) promoteUndeclaredTrailers() { … } func (w *http2responseWriter) SetReadDeadline(deadline time.Time) error { … } func (w *http2responseWriter) SetWriteDeadline(deadline time.Time) error { … } func (w *http2responseWriter) Flush() { … } func (w *http2responseWriter) FlushError() error { … } func (w *http2responseWriter) CloseNotify() <-chan bool { … } func (w *http2responseWriter) Header() Header { … } // checkWriteHeaderCode is a copy of net/http's checkWriteHeaderCode. func http2checkWriteHeaderCode(code int) { … } func (w *http2responseWriter) WriteHeader(code int) { … } func (rws *http2responseWriterState) writeHeader(code int) { … } func http2cloneHeader(h Header) Header { … } // 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 *http2responseWriter) Write(p []byte) (n int, err error) { … } func (w *http2responseWriter) WriteString(s string) (n int, err error) { … } // either dataB or dataS is non-zero. func (w *http2responseWriter) write(lenData int, dataB []byte, dataS string) (n int, err error) { … } func (w *http2responseWriter) handlerDone() { … } var http2ErrRecursivePush … var http2ErrPushLimitReached … var _ … func (w *http2responseWriter) Push(target string, opts *PushOptions) error { … } type http2startPushRequest … func (sc *http2serverConn) startPush(msg *http2startPushRequest) { … } // foreachHeaderElement splits v according to the "#rule" construction // in RFC 7230 section 7 and calls fn for each non-empty element. func http2foreachHeaderElement(v string, fn func(string)) { … } var http2connHeaders … // 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 http2checkValidHTTP2RequestHeaders(h Header) error { … } func http2new400Handler(err error) HandlerFunc { … } // h1ServerKeepAlivesDisabled reports whether hs has its keep-alives // disabled. See comments on h1ServerShutdownChan above for why // the code is written this way. func http2h1ServerKeepAlivesDisabled(hs *Server) bool { … } func (sc *http2serverConn) countError(name string, err error) error { … } type http2timer … type http2timeTimer … func (t http2timeTimer) C() <-chan time.Time { … } const http2transportDefaultConnFlow … const http2transportDefaultStreamFlow … const http2defaultUserAgent … const http2initialMaxConcurrentStreams … const http2defaultMaxConcurrentStreams … type http2Transport … type http2transportTestHooks … func (t *http2Transport) markNewGoroutine() { … } // newTimer creates a new time.Timer, or a synthetic timer in tests. func (t *http2Transport) newTimer(d time.Duration) http2timer { … } // afterFunc creates a new time.AfterFunc timer, or a synthetic timer in tests. func (t *http2Transport) afterFunc(d time.Duration, f func()) http2timer { … } func (t *http2Transport) contextWithTimeout(ctx context.Context, d time.Duration) (context.Context, context.CancelFunc) { … } func (t *http2Transport) maxHeaderListSize() uint32 { … } func (t *http2Transport) maxFrameReadSize() uint32 { … } func (t *http2Transport) disableCompression() bool { … } func (t *http2Transport) pingTimeout() time.Duration { … } // 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 http2ConfigureTransport(t1 *Transport) error { … } // 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 http2ConfigureTransports(t1 *Transport) (*http2Transport, error) { … } func http2configureTransports(t1 *Transport) (*http2Transport, error) { … } func (t *http2Transport) connPool() http2ClientConnPool { … } func (t *http2Transport) initConnPool() { … } type http2ClientConn … type http2clientStream … var http2got1xxFuncForTests … // 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 *http2clientStream) get1xxTraceFunc() func(int, textproto.MIMEHeader) error { … } func (cs *http2clientStream) abortStream(err error) { … } func (cs *http2clientStream) abortStreamLocked(err error) { … } func (cs *http2clientStream) abortRequestBodyWrite() { … } func (cs *http2clientStream) closeReqBodyLocked() { … } type http2stickyErrWriter … func (sew http2stickyErrWriter) Write(p []byte) (n int, err error) { … } type http2noCachedConnError … func (http2noCachedConnError) IsHTTP2NoCachedConnError() { … } func (http2noCachedConnError) Error() string { … } // 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 http2isNoCachedConnError(err error) bool { … } var http2ErrNoCachedConn … type http2RoundTripOpt … func (t *http2Transport) RoundTrip(req *Request) (*Response, error) { … } // 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 http2authorityAddr(scheme string, authority string) (addr string) { … } // RoundTripOpt is like RoundTrip, but takes options. func (t *http2Transport) RoundTripOpt(req *Request, opt http2RoundTripOpt) (*Response, error) { … } // 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 *http2Transport) CloseIdleConnections() { … } var http2errClientConnClosed … var http2errClientConnUnusable … var http2errClientConnGotGoAway … // 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 http2shouldRetryRequest(req *Request, err error) (*Request, error) { … } func http2canRetryError(err error) bool { … } func (t *http2Transport) dialClientConn(ctx context.Context, addr string, singleUse bool) (*http2ClientConn, error) { … } func (t *http2Transport) newTLSConfig(host string) *tls.Config { … } func (t *http2Transport) dialTLS(ctx context.Context, network, addr string, tlsCfg *tls.Config) (net.Conn, error) { … } // disableKeepAlives reports whether connections should be closed as // soon as possible after handling the first request. func (t *http2Transport) disableKeepAlives() bool { … } func (t *http2Transport) expectContinueTimeout() time.Duration { … } func (t *http2Transport) maxDecoderHeaderTableSize() uint32 { … } func (t *http2Transport) maxEncoderHeaderTableSize() uint32 { … } func (t *http2Transport) NewClientConn(c net.Conn) (*http2ClientConn, error) { … } func (t *http2Transport) newClientConn(c net.Conn, singleUse bool) (*http2ClientConn, error) { … } func (cc *http2ClientConn) healthCheck() { … } // SetDoNotReuse marks cc as not reusable for future HTTP requests. func (cc *http2ClientConn) SetDoNotReuse() { … } func (cc *http2ClientConn) setGoAway(f *http2GoAwayFrame) { … } // 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 *http2ClientConn) CanTakeNewRequest() bool { … } // ReserveNewRequest is like CanTakeNewRequest but also reserves a // concurrent stream in cc. The reservation is decremented on the // next call to RoundTrip. func (cc *http2ClientConn) ReserveNewRequest() bool { … } type http2ClientConnState … // State returns a snapshot of cc's state. func (cc *http2ClientConn) State() http2ClientConnState { … } type http2clientConnIdleState … func (cc *http2ClientConn) idleState() http2clientConnIdleState { … } func (cc *http2ClientConn) idleStateLocked() (st http2clientConnIdleState) { … } func (cc *http2ClientConn) canTakeNewRequestLocked() bool { … } // tooIdleLocked reports whether this connection has been been sitting idle // for too much wall time. func (cc *http2ClientConn) tooIdleLocked() bool { … } // 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 *http2ClientConn) onIdleTimeout() { … } func (cc *http2ClientConn) closeConn() { … } // A tls.Conn.Close can hang for a long time if the peer is unresponsive. // Try to shut it down more aggressively. func (cc *http2ClientConn) forceCloseConn() { … } func (cc *http2ClientConn) closeIfIdle() { … } func (cc *http2ClientConn) isDoNotReuseAndIdle() bool { … } var http2shutdownEnterWaitStateHook … // Shutdown gracefully closes the client connection, waiting for running streams to complete. func (cc *http2ClientConn) Shutdown(ctx context.Context) error { … } func (cc *http2ClientConn) sendGoAway() error { … } // closes the client connection immediately. In-flight requests are interrupted. // err is sent to streams. func (cc *http2ClientConn) closeForError(err error) { … } // Close closes the client connection immediately. // // In-flight requests are interrupted. For a graceful shutdown, use Shutdown instead. func (cc *http2ClientConn) Close() error { … } // closes the client connection immediately. In-flight requests are interrupted. func (cc *http2ClientConn) closeForLostPing() { … } var http2errRequestCanceled … func http2commaSeparatedTrailers(req *Request) (string, error) { … } func (cc *http2ClientConn) responseHeaderTimeout() time.Duration { … } // 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 http2checkConnHeaders(req *Request) error { … } // actualContentLength returns a sanitized version of // req.ContentLength, where 0 actually means zero (not unknown) and -1 // means unknown. func http2actualContentLength(req *Request) int64 { … } func (cc *http2ClientConn) decrStreamReservations() { … } func (cc *http2ClientConn) decrStreamReservationsLocked() { … } func (cc *http2ClientConn) RoundTrip(req *Request) (*Response, error) { … } func (cc *http2ClientConn) roundTrip(req *Request, streamf func(*http2clientStream)) (*Response, error) { … } // doRequest runs for the duration of the request lifetime. // // It sends the request and performs post-request cleanup (closing Request.Body, etc.). func (cs *http2clientStream) doRequest(req *Request, streamf func(*http2clientStream)) { … } // 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 *http2clientStream) writeRequest(req *Request, streamf func(*http2clientStream)) (err error) { … } func (cs *http2clientStream) encodeAndWriteHeaders(req *Request) error { … } // 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 *http2clientStream) cleanupWriteRequest(err error) { … } // awaitOpenSlotForStreamLocked waits until len(streams) < maxConcurrentStreams. // Must hold cc.mu. func (cc *http2ClientConn) awaitOpenSlotForStreamLocked(cs *http2clientStream) error { … } // requires cc.wmu be held func (cc *http2ClientConn) writeHeaders(streamID uint32, endStream bool, maxFrameSize int, hdrs []byte) error { … } var http2errStopReqBodyWrite … var http2errStopReqBodyWriteAndCancel … var http2errReqBodyTooLong … // 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 *http2clientStream) frameScratchBufferLen(maxFrameSize int) int { … } var http2bufPools … func http2bufPoolIndex(size int) int { … } func (cs *http2clientStream) writeRequestBody(req *Request) (err error) { … } // 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 *http2clientStream) awaitFlowControl(maxBytes int) (taken int32, err error) { … } func http2validateHeaders(hdrs Header) string { … } var http2errNilRequestURL … // requires cc.wmu be held. func (cc *http2ClientConn) encodeHeaders(req *Request, addGzipHeader bool, trailers string, contentLength int64) ([]byte, error) { … } // 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 http2shouldSendReqContentLength(method string, contentLength int64) bool { … } // requires cc.wmu be held. func (cc *http2ClientConn) encodeTrailers(trailer Header) ([]byte, error) { … } func (cc *http2ClientConn) writeHeader(name, value string) { … } type http2resAndError … // requires cc.mu be held. func (cc *http2ClientConn) addStreamLocked(cs *http2clientStream) { … } func (cc *http2ClientConn) forgetStreamID(id uint32) { … } type http2clientConnReadLoop … // readLoop runs in its own goroutine and reads and dispatches frames. func (cc *http2ClientConn) readLoop() { … } type http2GoAwayError … func (e http2GoAwayError) Error() string { … } func http2isEOFOrNetReadError(err error) bool { … } func (rl *http2clientConnReadLoop) cleanup() { … } // countReadFrameError calls Transport.CountError with a string // representing err. func (cc *http2ClientConn) countReadFrameError(err error) { … } func (rl *http2clientConnReadLoop) run() error { … } func (rl *http2clientConnReadLoop) processHeaders(f *http2MetaHeadersFrame) error { … } // 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 *http2clientConnReadLoop) handleResponse(cs *http2clientStream, f *http2MetaHeadersFrame) (*Response, error) { … } func (rl *http2clientConnReadLoop) processTrailers(cs *http2clientStream, f *http2MetaHeadersFrame) error { … } type http2transportResponseBody … func (b http2transportResponseBody) Read(p []byte) (n int, err error) { … } var http2errClosedResponseBody … func (b http2transportResponseBody) Close() error { … } func (rl *http2clientConnReadLoop) processData(f *http2DataFrame) error { … } func (rl *http2clientConnReadLoop) endStream(cs *http2clientStream) { … } func (rl *http2clientConnReadLoop) endStreamError(cs *http2clientStream, err error) { … } func (rl *http2clientConnReadLoop) streamByID(id uint32) *http2clientStream { … } func (cs *http2clientStream) copyTrailers() { … } func (rl *http2clientConnReadLoop) processGoAway(f *http2GoAwayFrame) error { … } func (rl *http2clientConnReadLoop) processSettings(f *http2SettingsFrame) error { … } func (rl *http2clientConnReadLoop) processSettingsNoWrite(f *http2SettingsFrame) error { … } func (rl *http2clientConnReadLoop) processWindowUpdate(f *http2WindowUpdateFrame) error { … } func (rl *http2clientConnReadLoop) processResetStream(f *http2RSTStreamFrame) error { … } // Ping sends a PING frame to the server and waits for the ack. func (cc *http2ClientConn) Ping(ctx context.Context) error { … } func (rl *http2clientConnReadLoop) processPing(f *http2PingFrame) error { … } func (rl *http2clientConnReadLoop) processPushPromise(f *http2PushPromiseFrame) error { … } func (cc *http2ClientConn) writeStreamReset(streamID uint32, code http2ErrCode, err error) { … } var http2errResponseHeaderListSize … var http2errRequestHeaderListSize … func (cc *http2ClientConn) logf(format string, args ...interface{ … } func (cc *http2ClientConn) vlogf(format string, args ...interface{ … } func (t *http2Transport) vlogf(format string, args ...interface{ … } func (t *http2Transport) logf(format string, args ...interface{ … } var http2noBody … type http2noBodyReader … func (http2noBodyReader) Close() error { … } func (http2noBodyReader) Read([]byte) (int, error) { … } type http2missingBody … func (http2missingBody) Close() error { … } func (http2missingBody) Read([]byte) (int, error) { … } func http2strSliceContains(ss []string, s string) bool { … } type http2erringRoundTripper … func (rt http2erringRoundTripper) RoundTripErr() error { … } func (rt http2erringRoundTripper) RoundTrip(*Request) (*Response, error) { … } type http2gzipReader … func (gz *http2gzipReader) Read(p []byte) (n int, err error) { … } func (gz *http2gzipReader) Close() error { … } type http2errorReader … func (r http2errorReader) Read(p []byte) (int, error) { … } // isConnectionCloseRequest reports whether req should use its own // connection for a single request and then close the connection. func http2isConnectionCloseRequest(req *Request) bool { … } // registerHTTPSProtocol calls Transport.RegisterProtocol but // converting panics into errors. func http2registerHTTPSProtocol(t *Transport, rt http2noDialH2RoundTripper) (err error) { … } type http2noDialH2RoundTripper … func (rt http2noDialH2RoundTripper) RoundTrip(req *Request) (*Response, error) { … } func (t *http2Transport) idleConnTimeout() time.Duration { … } func http2traceGetConn(req *Request, hostPort string) { … } func http2traceGotConn(req *Request, cc *http2ClientConn, reused bool) { … } func http2traceWroteHeaders(trace *httptrace.ClientTrace) { … } func http2traceGot100Continue(trace *httptrace.ClientTrace) { … } func http2traceWait100Continue(trace *httptrace.ClientTrace) { … } func http2traceWroteRequest(trace *httptrace.ClientTrace, err error) { … } func http2traceFirstResponseByte(trace *httptrace.ClientTrace) { … } func http2traceHasWroteHeaderField(trace *httptrace.ClientTrace) bool { … } func http2traceWroteHeaderField(trace *httptrace.ClientTrace, k, v string) { … } func http2traceGot1xxResponseFunc(trace *httptrace.ClientTrace) func(int, textproto.MIMEHeader) error { … } // dialTLSWithContext uses tls.Dialer, added in Go 1.15, to open a TLS // connection. func (t *http2Transport) dialTLSWithContext(ctx context.Context, network, addr string, cfg *tls.Config) (*tls.Conn, error) { … } type http2writeFramer … type http2writeContext … // 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 http2writeEndsStream(w http2writeFramer) bool { … } type http2flushFrameWriter … func (http2flushFrameWriter) writeFrame(ctx http2writeContext) error { … } func (http2flushFrameWriter) staysWithinBuffer(max int) bool { … } type http2writeSettings … func (s http2writeSettings) staysWithinBuffer(max int) bool { … } func (s http2writeSettings) writeFrame(ctx http2writeContext) error { … } type http2writeGoAway … func (p *http2writeGoAway) writeFrame(ctx http2writeContext) error { … } func (*http2writeGoAway) staysWithinBuffer(max int) bool { … } type http2writeData … func (w *http2writeData) String() string { … } func (w *http2writeData) writeFrame(ctx http2writeContext) error { … } func (w *http2writeData) staysWithinBuffer(max int) bool { … } type http2handlerPanicRST … func (hp http2handlerPanicRST) writeFrame(ctx http2writeContext) error { … } func (hp http2handlerPanicRST) staysWithinBuffer(max int) bool { … } func (se http2StreamError) writeFrame(ctx http2writeContext) error { … } func (se http2StreamError) staysWithinBuffer(max int) bool { … } type http2writePingAck … func (w http2writePingAck) writeFrame(ctx http2writeContext) error { … } func (w http2writePingAck) staysWithinBuffer(max int) bool { … } type http2writeSettingsAck … func (http2writeSettingsAck) writeFrame(ctx http2writeContext) error { … } func (http2writeSettingsAck) staysWithinBuffer(max int) bool { … } // 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 http2splitHeaderBlock(ctx http2writeContext, headerBlock []byte, fn func(ctx http2writeContext, frag []byte, firstFrag, lastFrag bool) error) error { … } type http2writeResHeaders … func http2encKV(enc *hpack.Encoder, k, v string) { … } func (w *http2writeResHeaders) staysWithinBuffer(max int) bool { … } func (w *http2writeResHeaders) writeFrame(ctx http2writeContext) error { … } func (w *http2writeResHeaders) writeHeaderBlock(ctx http2writeContext, frag []byte, firstFrag, lastFrag bool) error { … } type http2writePushPromise … func (w *http2writePushPromise) staysWithinBuffer(max int) bool { … } func (w *http2writePushPromise) writeFrame(ctx http2writeContext) error { … } func (w *http2writePushPromise) writeHeaderBlock(ctx http2writeContext, frag []byte, firstFrag, lastFrag bool) error { … } type http2write100ContinueHeadersFrame … func (w http2write100ContinueHeadersFrame) writeFrame(ctx http2writeContext) error { … } func (w http2write100ContinueHeadersFrame) staysWithinBuffer(max int) bool { … } type http2writeWindowUpdate … func (wu http2writeWindowUpdate) staysWithinBuffer(max int) bool { … } func (wu http2writeWindowUpdate) writeFrame(ctx http2writeContext) error { … } // encodeHeaders encodes an http.Header. If keys is not nil, then (k, h[k]) // is encoded only if k is in keys. func http2encodeHeaders(enc *hpack.Encoder, h Header, keys []string) { … } type http2WriteScheduler … type http2OpenStreamOptions … type http2FrameWriteRequest … // 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 http2FrameWriteRequest) StreamID() uint32 { … } // isControl reports whether wr is a control frame for MaxQueuedControlFrames // purposes. That includes non-stream frames and RST_STREAM frames. func (wr http2FrameWriteRequest) isControl() bool { … } // 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 http2FrameWriteRequest) DataSize() int { … } // 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 http2FrameWriteRequest) Consume(n int32) (http2FrameWriteRequest, http2FrameWriteRequest, int) { … } // String is for debugging only. func (wr http2FrameWriteRequest) String() string { … } // replyToWriter sends err to wr.done and panics if the send must block // This does nothing if wr.done is nil. func (wr *http2FrameWriteRequest) replyToWriter(err error) { … } type http2writeQueue … func (q *http2writeQueue) empty() bool { … } func (q *http2writeQueue) push(wr http2FrameWriteRequest) { … } func (q *http2writeQueue) shift() http2FrameWriteRequest { … } // 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 *http2writeQueue) consume(n int32) (http2FrameWriteRequest, bool) { … } type http2writeQueuePool … // put inserts an unused writeQueue into the pool. func (p *http2writeQueuePool) put(q *http2writeQueue) { … } // get returns an empty writeQueue. func (p *http2writeQueuePool) get() *http2writeQueue { … } const http2priorityDefaultWeight … type http2PriorityWriteSchedulerConfig … // 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 http2NewPriorityWriteScheduler(cfg *http2PriorityWriteSchedulerConfig) http2WriteScheduler { … } type http2priorityNodeState … const http2priorityNodeOpen … const http2priorityNodeClosed … const http2priorityNodeIdle … type http2priorityNode … func (n *http2priorityNode) setParent(parent *http2priorityNode) { … } func (n *http2priorityNode) addBytes(b int64) { … } // 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 *http2priorityNode) walkReadyInOrder(openParent bool, tmp *[]*http2priorityNode, f func(*http2priorityNode, bool) bool) bool { … } type http2sortPriorityNodeSiblings … func (z http2sortPriorityNodeSiblings) Len() int { … } func (z http2sortPriorityNodeSiblings) Swap(i, k int) { … } func (z http2sortPriorityNodeSiblings) Less(i, k int) bool { … } type http2priorityWriteScheduler … func (ws *http2priorityWriteScheduler) OpenStream(streamID uint32, options http2OpenStreamOptions) { … } func (ws *http2priorityWriteScheduler) CloseStream(streamID uint32) { … } func (ws *http2priorityWriteScheduler) AdjustStream(streamID uint32, priority http2PriorityParam) { … } func (ws *http2priorityWriteScheduler) Push(wr http2FrameWriteRequest) { … } func (ws *http2priorityWriteScheduler) Pop() (wr http2FrameWriteRequest, ok bool) { … } func (ws *http2priorityWriteScheduler) addClosedOrIdleNode(list *[]*http2priorityNode, maxSize int, n *http2priorityNode) { … } func (ws *http2priorityWriteScheduler) removeNode(n *http2priorityNode) { … } // 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 http2NewRandomWriteScheduler() http2WriteScheduler { … } type http2randomWriteScheduler … func (ws *http2randomWriteScheduler) OpenStream(streamID uint32, options http2OpenStreamOptions) { … } func (ws *http2randomWriteScheduler) CloseStream(streamID uint32) { … } func (ws *http2randomWriteScheduler) AdjustStream(streamID uint32, priority http2PriorityParam) { … } func (ws *http2randomWriteScheduler) Push(wr http2FrameWriteRequest) { … } func (ws *http2randomWriteScheduler) Pop() (http2FrameWriteRequest, bool) { … } type http2roundRobinWriteScheduler … // 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 http2newRoundRobinWriteScheduler() http2WriteScheduler { … } func (ws *http2roundRobinWriteScheduler) OpenStream(streamID uint32, options http2OpenStreamOptions) { … } func (ws *http2roundRobinWriteScheduler) CloseStream(streamID uint32) { … } func (ws *http2roundRobinWriteScheduler) AdjustStream(streamID uint32, priority http2PriorityParam) { … } func (ws *http2roundRobinWriteScheduler) Push(wr http2FrameWriteRequest) { … } func (ws *http2roundRobinWriteScheduler) Pop() (http2FrameWriteRequest, bool) { … }
Codebase Browser
go