Black Lives Matter. Support the Equal Justice Initiative.

Source file src/net/http/h2_bundle.go

Documentation: net/http

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

View as plain text