| blob | 4268f2fbd0a668ff3753da4b456e90b64fef1d12 |
1 // Code generated by golang.org/x/tools/cmd/bundle. DO NOT EDIT.
2 //go:generate bundle -o h2_bundle.go -prefix http2 -underscore golang.org/x/net/http2
4 // Package http2 implements the HTTP/2 protocol.
5 //
6 // This package is low-level and intended to be used directly by very
7 // few people. Most users will use it indirectly through the automatic
8 // use by the net/http package (from Go 1.6 and later).
9 // For use in earlier Go versions see ConfigureServer. (Transport support
10 // requires Go 1.6 or later)
11 //
12 // See https://http2.github.io/ for more information on HTTP/2.
13 //
14 // See https://http2.golang.org/ for a test server running this code.
15 //
17 package http
20 "bufio"
21 "bytes"
22 "compress/gzip"
23 "context"
24 "crypto/rand"
25 "crypto/tls"
26 "encoding/binary"
27 "errors"
28 "fmt"
29 "io"
30 "io/ioutil"
31 "log"
32 "math"
33 mathrand "math/rand"
34 "net"
35 "net/http/httptrace"
36 "net/textproto"
37 "net/url"
38 "os"
39 "reflect"
40 "runtime"
41 "sort"
42 "strconv"
43 "strings"
44 "sync"
45 "time"
47 "golang_org/x/net/http/httpguts"
48 "golang_org/x/net/http2/hpack"
49 "golang_org/x/net/idna"
50 )
52 // A list of the possible cipher suite ids. Taken from
53 // https://www.iana.org/assignments/tls-parameters/tls-parameters.txt
84 // Reserved uint16 = 0x001C-1D
126 // Reserved uint16 = 0x0047-4F
127 // Reserved uint16 = 0x0050-58
128 // Reserved uint16 = 0x0059-5C
129 // Unassigned uint16 = 0x005D-5F
130 // Reserved uint16 = 0x0060-66
138 // Unassigned uint16 = 0x006E-83
205 // Unassigned uint16 = 0x00C6-FE
207 // Unassigned uint16 = 0x01-55,*
209 // Unassigned uint16 = 0x5601 - 0xC000
385 // Unassigned uint16 = 0xC0B0-FF
386 // Unassigned uint16 = 0xC1-CB,*
387 // Unassigned uint16 = 0xCC00-A7
395 )
397 // isBadCipher reports whether the cipher is blacklisted by the HTTP/2 spec.
398 // References:
399 // https://tools.ietf.org/html/rfc7540#appendix-A
400 // Reject cipher suites from Appendix A.
401 // "This list includes those cipher suites that do not
402 // offer an ephemeral key exchange and those that are
403 // based on the TLS null, stream or block cipher type"
407 http2cipher_TLS_RSA_WITH_NULL_MD5,
408 http2cipher_TLS_RSA_WITH_NULL_SHA,
409 http2cipher_TLS_RSA_EXPORT_WITH_RC4_40_MD5,
410 http2cipher_TLS_RSA_WITH_RC4_128_MD5,
411 http2cipher_TLS_RSA_WITH_RC4_128_SHA,
412 http2cipher_TLS_RSA_EXPORT_WITH_RC2_CBC_40_MD5,
413 http2cipher_TLS_RSA_WITH_IDEA_CBC_SHA,
414 http2cipher_TLS_RSA_EXPORT_WITH_DES40_CBC_SHA,
415 http2cipher_TLS_RSA_WITH_DES_CBC_SHA,
416 http2cipher_TLS_RSA_WITH_3DES_EDE_CBC_SHA,
417 http2cipher_TLS_DH_DSS_EXPORT_WITH_DES40_CBC_SHA,
418 http2cipher_TLS_DH_DSS_WITH_DES_CBC_SHA,
419 http2cipher_TLS_DH_DSS_WITH_3DES_EDE_CBC_SHA,
420 http2cipher_TLS_DH_RSA_EXPORT_WITH_DES40_CBC_SHA,
421 http2cipher_TLS_DH_RSA_WITH_DES_CBC_SHA,
422 http2cipher_TLS_DH_RSA_WITH_3DES_EDE_CBC_SHA,
423 http2cipher_TLS_DHE_DSS_EXPORT_WITH_DES40_CBC_SHA,
424 http2cipher_TLS_DHE_DSS_WITH_DES_CBC_SHA,
425 http2cipher_TLS_DHE_DSS_WITH_3DES_EDE_CBC_SHA,
426 http2cipher_TLS_DHE_RSA_EXPORT_WITH_DES40_CBC_SHA,
427 http2cipher_TLS_DHE_RSA_WITH_DES_CBC_SHA,
428 http2cipher_TLS_DHE_RSA_WITH_3DES_EDE_CBC_SHA,
429 http2cipher_TLS_DH_anon_EXPORT_WITH_RC4_40_MD5,
430 http2cipher_TLS_DH_anon_WITH_RC4_128_MD5,
431 http2cipher_TLS_DH_anon_EXPORT_WITH_DES40_CBC_SHA,
432 http2cipher_TLS_DH_anon_WITH_DES_CBC_SHA,
433 http2cipher_TLS_DH_anon_WITH_3DES_EDE_CBC_SHA,
434 http2cipher_TLS_KRB5_WITH_DES_CBC_SHA,
435 http2cipher_TLS_KRB5_WITH_3DES_EDE_CBC_SHA,
436 http2cipher_TLS_KRB5_WITH_RC4_128_SHA,
437 http2cipher_TLS_KRB5_WITH_IDEA_CBC_SHA,
438 http2cipher_TLS_KRB5_WITH_DES_CBC_MD5,
439 http2cipher_TLS_KRB5_WITH_3DES_EDE_CBC_MD5,
440 http2cipher_TLS_KRB5_WITH_RC4_128_MD5,
441 http2cipher_TLS_KRB5_WITH_IDEA_CBC_MD5,
442 http2cipher_TLS_KRB5_EXPORT_WITH_DES_CBC_40_SHA,
443 http2cipher_TLS_KRB5_EXPORT_WITH_RC2_CBC_40_SHA,
444 http2cipher_TLS_KRB5_EXPORT_WITH_RC4_40_SHA,
445 http2cipher_TLS_KRB5_EXPORT_WITH_DES_CBC_40_MD5,
446 http2cipher_TLS_KRB5_EXPORT_WITH_RC2_CBC_40_MD5,
447 http2cipher_TLS_KRB5_EXPORT_WITH_RC4_40_MD5,
448 http2cipher_TLS_PSK_WITH_NULL_SHA,
449 http2cipher_TLS_DHE_PSK_WITH_NULL_SHA,
450 http2cipher_TLS_RSA_PSK_WITH_NULL_SHA,
451 http2cipher_TLS_RSA_WITH_AES_128_CBC_SHA,
452 http2cipher_TLS_DH_DSS_WITH_AES_128_CBC_SHA,
453 http2cipher_TLS_DH_RSA_WITH_AES_128_CBC_SHA,
454 http2cipher_TLS_DHE_DSS_WITH_AES_128_CBC_SHA,
455 http2cipher_TLS_DHE_RSA_WITH_AES_128_CBC_SHA,
456 http2cipher_TLS_DH_anon_WITH_AES_128_CBC_SHA,
457 http2cipher_TLS_RSA_WITH_AES_256_CBC_SHA,
458 http2cipher_TLS_DH_DSS_WITH_AES_256_CBC_SHA,
459 http2cipher_TLS_DH_RSA_WITH_AES_256_CBC_SHA,
460 http2cipher_TLS_DHE_DSS_WITH_AES_256_CBC_SHA,
461 http2cipher_TLS_DHE_RSA_WITH_AES_256_CBC_SHA,
462 http2cipher_TLS_DH_anon_WITH_AES_256_CBC_SHA,
463 http2cipher_TLS_RSA_WITH_NULL_SHA256,
464 http2cipher_TLS_RSA_WITH_AES_128_CBC_SHA256,
465 http2cipher_TLS_RSA_WITH_AES_256_CBC_SHA256,
466 http2cipher_TLS_DH_DSS_WITH_AES_128_CBC_SHA256,
467 http2cipher_TLS_DH_RSA_WITH_AES_128_CBC_SHA256,
468 http2cipher_TLS_DHE_DSS_WITH_AES_128_CBC_SHA256,
469 http2cipher_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA,
470 http2cipher_TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA,
471 http2cipher_TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA,
472 http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA,
473 http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA,
474 http2cipher_TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA,
475 http2cipher_TLS_DHE_RSA_WITH_AES_128_CBC_SHA256,
476 http2cipher_TLS_DH_DSS_WITH_AES_256_CBC_SHA256,
477 http2cipher_TLS_DH_RSA_WITH_AES_256_CBC_SHA256,
478 http2cipher_TLS_DHE_DSS_WITH_AES_256_CBC_SHA256,
479 http2cipher_TLS_DHE_RSA_WITH_AES_256_CBC_SHA256,
480 http2cipher_TLS_DH_anon_WITH_AES_128_CBC_SHA256,
481 http2cipher_TLS_DH_anon_WITH_AES_256_CBC_SHA256,
482 http2cipher_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA,
483 http2cipher_TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA,
484 http2cipher_TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA,
485 http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA,
486 http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA,
487 http2cipher_TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA,
488 http2cipher_TLS_PSK_WITH_RC4_128_SHA,
489 http2cipher_TLS_PSK_WITH_3DES_EDE_CBC_SHA,
490 http2cipher_TLS_PSK_WITH_AES_128_CBC_SHA,
491 http2cipher_TLS_PSK_WITH_AES_256_CBC_SHA,
492 http2cipher_TLS_DHE_PSK_WITH_RC4_128_SHA,
493 http2cipher_TLS_DHE_PSK_WITH_3DES_EDE_CBC_SHA,
494 http2cipher_TLS_DHE_PSK_WITH_AES_128_CBC_SHA,
495 http2cipher_TLS_DHE_PSK_WITH_AES_256_CBC_SHA,
496 http2cipher_TLS_RSA_PSK_WITH_RC4_128_SHA,
497 http2cipher_TLS_RSA_PSK_WITH_3DES_EDE_CBC_SHA,
498 http2cipher_TLS_RSA_PSK_WITH_AES_128_CBC_SHA,
499 http2cipher_TLS_RSA_PSK_WITH_AES_256_CBC_SHA,
500 http2cipher_TLS_RSA_WITH_SEED_CBC_SHA,
501 http2cipher_TLS_DH_DSS_WITH_SEED_CBC_SHA,
502 http2cipher_TLS_DH_RSA_WITH_SEED_CBC_SHA,
503 http2cipher_TLS_DHE_DSS_WITH_SEED_CBC_SHA,
504 http2cipher_TLS_DHE_RSA_WITH_SEED_CBC_SHA,
505 http2cipher_TLS_DH_anon_WITH_SEED_CBC_SHA,
506 http2cipher_TLS_RSA_WITH_AES_128_GCM_SHA256,
507 http2cipher_TLS_RSA_WITH_AES_256_GCM_SHA384,
508 http2cipher_TLS_DH_RSA_WITH_AES_128_GCM_SHA256,
509 http2cipher_TLS_DH_RSA_WITH_AES_256_GCM_SHA384,
510 http2cipher_TLS_DH_DSS_WITH_AES_128_GCM_SHA256,
511 http2cipher_TLS_DH_DSS_WITH_AES_256_GCM_SHA384,
512 http2cipher_TLS_DH_anon_WITH_AES_128_GCM_SHA256,
513 http2cipher_TLS_DH_anon_WITH_AES_256_GCM_SHA384,
514 http2cipher_TLS_PSK_WITH_AES_128_GCM_SHA256,
515 http2cipher_TLS_PSK_WITH_AES_256_GCM_SHA384,
516 http2cipher_TLS_RSA_PSK_WITH_AES_128_GCM_SHA256,
517 http2cipher_TLS_RSA_PSK_WITH_AES_256_GCM_SHA384,
518 http2cipher_TLS_PSK_WITH_AES_128_CBC_SHA256,
519 http2cipher_TLS_PSK_WITH_AES_256_CBC_SHA384,
520 http2cipher_TLS_PSK_WITH_NULL_SHA256,
521 http2cipher_TLS_PSK_WITH_NULL_SHA384,
522 http2cipher_TLS_DHE_PSK_WITH_AES_128_CBC_SHA256,
523 http2cipher_TLS_DHE_PSK_WITH_AES_256_CBC_SHA384,
524 http2cipher_TLS_DHE_PSK_WITH_NULL_SHA256,
525 http2cipher_TLS_DHE_PSK_WITH_NULL_SHA384,
526 http2cipher_TLS_RSA_PSK_WITH_AES_128_CBC_SHA256,
527 http2cipher_TLS_RSA_PSK_WITH_AES_256_CBC_SHA384,
528 http2cipher_TLS_RSA_PSK_WITH_NULL_SHA256,
529 http2cipher_TLS_RSA_PSK_WITH_NULL_SHA384,
530 http2cipher_TLS_RSA_WITH_CAMELLIA_128_CBC_SHA256,
531 http2cipher_TLS_DH_DSS_WITH_CAMELLIA_128_CBC_SHA256,
532 http2cipher_TLS_DH_RSA_WITH_CAMELLIA_128_CBC_SHA256,
533 http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_128_CBC_SHA256,
534 http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_128_CBC_SHA256,
535 http2cipher_TLS_DH_anon_WITH_CAMELLIA_128_CBC_SHA256,
536 http2cipher_TLS_RSA_WITH_CAMELLIA_256_CBC_SHA256,
537 http2cipher_TLS_DH_DSS_WITH_CAMELLIA_256_CBC_SHA256,
538 http2cipher_TLS_DH_RSA_WITH_CAMELLIA_256_CBC_SHA256,
539 http2cipher_TLS_DHE_DSS_WITH_CAMELLIA_256_CBC_SHA256,
540 http2cipher_TLS_DHE_RSA_WITH_CAMELLIA_256_CBC_SHA256,
541 http2cipher_TLS_DH_anon_WITH_CAMELLIA_256_CBC_SHA256,
542 http2cipher_TLS_EMPTY_RENEGOTIATION_INFO_SCSV,
543 http2cipher_TLS_ECDH_ECDSA_WITH_NULL_SHA,
544 http2cipher_TLS_ECDH_ECDSA_WITH_RC4_128_SHA,
545 http2cipher_TLS_ECDH_ECDSA_WITH_3DES_EDE_CBC_SHA,
546 http2cipher_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA,
547 http2cipher_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA,
548 http2cipher_TLS_ECDHE_ECDSA_WITH_NULL_SHA,
549 http2cipher_TLS_ECDHE_ECDSA_WITH_RC4_128_SHA,
550 http2cipher_TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA,
551 http2cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
552 http2cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
553 http2cipher_TLS_ECDH_RSA_WITH_NULL_SHA,
554 http2cipher_TLS_ECDH_RSA_WITH_RC4_128_SHA,
555 http2cipher_TLS_ECDH_RSA_WITH_3DES_EDE_CBC_SHA,
556 http2cipher_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA,
557 http2cipher_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA,
558 http2cipher_TLS_ECDHE_RSA_WITH_NULL_SHA,
559 http2cipher_TLS_ECDHE_RSA_WITH_RC4_128_SHA,
560 http2cipher_TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA,
561 http2cipher_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
562 http2cipher_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
563 http2cipher_TLS_ECDH_anon_WITH_NULL_SHA,
564 http2cipher_TLS_ECDH_anon_WITH_RC4_128_SHA,
565 http2cipher_TLS_ECDH_anon_WITH_3DES_EDE_CBC_SHA,
566 http2cipher_TLS_ECDH_anon_WITH_AES_128_CBC_SHA,
567 http2cipher_TLS_ECDH_anon_WITH_AES_256_CBC_SHA,
568 http2cipher_TLS_SRP_SHA_WITH_3DES_EDE_CBC_SHA,
569 http2cipher_TLS_SRP_SHA_RSA_WITH_3DES_EDE_CBC_SHA,
570 http2cipher_TLS_SRP_SHA_DSS_WITH_3DES_EDE_CBC_SHA,
571 http2cipher_TLS_SRP_SHA_WITH_AES_128_CBC_SHA,
572 http2cipher_TLS_SRP_SHA_RSA_WITH_AES_128_CBC_SHA,
573 http2cipher_TLS_SRP_SHA_DSS_WITH_AES_128_CBC_SHA,
574 http2cipher_TLS_SRP_SHA_WITH_AES_256_CBC_SHA,
575 http2cipher_TLS_SRP_SHA_RSA_WITH_AES_256_CBC_SHA,
576 http2cipher_TLS_SRP_SHA_DSS_WITH_AES_256_CBC_SHA,
577 http2cipher_TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256,
578 http2cipher_TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384,
579 http2cipher_TLS_ECDH_ECDSA_WITH_AES_128_CBC_SHA256,
580 http2cipher_TLS_ECDH_ECDSA_WITH_AES_256_CBC_SHA384,
581 http2cipher_TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256,
582 http2cipher_TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384,
583 http2cipher_TLS_ECDH_RSA_WITH_AES_128_CBC_SHA256,
584 http2cipher_TLS_ECDH_RSA_WITH_AES_256_CBC_SHA384,
585 http2cipher_TLS_ECDH_ECDSA_WITH_AES_128_GCM_SHA256,
586 http2cipher_TLS_ECDH_ECDSA_WITH_AES_256_GCM_SHA384,
587 http2cipher_TLS_ECDH_RSA_WITH_AES_128_GCM_SHA256,
588 http2cipher_TLS_ECDH_RSA_WITH_AES_256_GCM_SHA384,
589 http2cipher_TLS_ECDHE_PSK_WITH_RC4_128_SHA,
590 http2cipher_TLS_ECDHE_PSK_WITH_3DES_EDE_CBC_SHA,
591 http2cipher_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA,
592 http2cipher_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA,
593 http2cipher_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256,
594 http2cipher_TLS_ECDHE_PSK_WITH_AES_256_CBC_SHA384,
595 http2cipher_TLS_ECDHE_PSK_WITH_NULL_SHA,
596 http2cipher_TLS_ECDHE_PSK_WITH_NULL_SHA256,
597 http2cipher_TLS_ECDHE_PSK_WITH_NULL_SHA384,
598 http2cipher_TLS_RSA_WITH_ARIA_128_CBC_SHA256,
599 http2cipher_TLS_RSA_WITH_ARIA_256_CBC_SHA384,
600 http2cipher_TLS_DH_DSS_WITH_ARIA_128_CBC_SHA256,
601 http2cipher_TLS_DH_DSS_WITH_ARIA_256_CBC_SHA384,
602 http2cipher_TLS_DH_RSA_WITH_ARIA_128_CBC_SHA256,
603 http2cipher_TLS_DH_RSA_WITH_ARIA_256_CBC_SHA384,
604 http2cipher_TLS_DHE_DSS_WITH_ARIA_128_CBC_SHA256,
605 http2cipher_TLS_DHE_DSS_WITH_ARIA_256_CBC_SHA384,
606 http2cipher_TLS_DHE_RSA_WITH_ARIA_128_CBC_SHA256,
607 http2cipher_TLS_DHE_RSA_WITH_ARIA_256_CBC_SHA384,
608 http2cipher_TLS_DH_anon_WITH_ARIA_128_CBC_SHA256,
609 http2cipher_TLS_DH_anon_WITH_ARIA_256_CBC_SHA384,
610 http2cipher_TLS_ECDHE_ECDSA_WITH_ARIA_128_CBC_SHA256,
611 http2cipher_TLS_ECDHE_ECDSA_WITH_ARIA_256_CBC_SHA384,
612 http2cipher_TLS_ECDH_ECDSA_WITH_ARIA_128_CBC_SHA256,
613 http2cipher_TLS_ECDH_ECDSA_WITH_ARIA_256_CBC_SHA384,
614 http2cipher_TLS_ECDHE_RSA_WITH_ARIA_128_CBC_SHA256,
615 http2cipher_TLS_ECDHE_RSA_WITH_ARIA_256_CBC_SHA384,
616 http2cipher_TLS_ECDH_RSA_WITH_ARIA_128_CBC_SHA256,
617 http2cipher_TLS_ECDH_RSA_WITH_ARIA_256_CBC_SHA384,
618 http2cipher_TLS_RSA_WITH_ARIA_128_GCM_SHA256,
619 http2cipher_TLS_RSA_WITH_ARIA_256_GCM_SHA384,
620 http2cipher_TLS_DH_RSA_WITH_ARIA_128_GCM_SHA256,
621 http2cipher_TLS_DH_RSA_WITH_ARIA_256_GCM_SHA384,
622 http2cipher_TLS_DH_DSS_WITH_ARIA_128_GCM_SHA256,
623 http2cipher_TLS_DH_DSS_WITH_ARIA_256_GCM_SHA384,
624 http2cipher_TLS_DH_anon_WITH_ARIA_128_GCM_SHA256,
625 http2cipher_TLS_DH_anon_WITH_ARIA_256_GCM_SHA384,
626 http2cipher_TLS_ECDH_ECDSA_WITH_ARIA_128_GCM_SHA256,
627 http2cipher_TLS_ECDH_ECDSA_WITH_ARIA_256_GCM_SHA384,
628 http2cipher_TLS_ECDH_RSA_WITH_ARIA_128_GCM_SHA256,
629 http2cipher_TLS_ECDH_RSA_WITH_ARIA_256_GCM_SHA384,
630 http2cipher_TLS_PSK_WITH_ARIA_128_CBC_SHA256,
631 http2cipher_TLS_PSK_WITH_ARIA_256_CBC_SHA384,
632 http2cipher_TLS_DHE_PSK_WITH_ARIA_128_CBC_SHA256,
633 http2cipher_TLS_DHE_PSK_WITH_ARIA_256_CBC_SHA384,
634 http2cipher_TLS_RSA_PSK_WITH_ARIA_128_CBC_SHA256,
635 http2cipher_TLS_RSA_PSK_WITH_ARIA_256_CBC_SHA384,
636 http2cipher_TLS_PSK_WITH_ARIA_128_GCM_SHA256,
637 http2cipher_TLS_PSK_WITH_ARIA_256_GCM_SHA384,
638 http2cipher_TLS_RSA_PSK_WITH_ARIA_128_GCM_SHA256,
639 http2cipher_TLS_RSA_PSK_WITH_ARIA_256_GCM_SHA384,
640 http2cipher_TLS_ECDHE_PSK_WITH_ARIA_128_CBC_SHA256,
641 http2cipher_TLS_ECDHE_PSK_WITH_ARIA_256_CBC_SHA384,
642 http2cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_128_CBC_SHA256,
643 http2cipher_TLS_ECDHE_ECDSA_WITH_CAMELLIA_256_CBC_SHA384,
644 http2cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_CBC_SHA256,
645 http2cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_CBC_SHA384,
646 http2cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_128_CBC_SHA256,
647 http2cipher_TLS_ECDHE_RSA_WITH_CAMELLIA_256_CBC_SHA384,
648 http2cipher_TLS_ECDH_RSA_WITH_CAMELLIA_128_CBC_SHA256,
649 http2cipher_TLS_ECDH_RSA_WITH_CAMELLIA_256_CBC_SHA384,
650 http2cipher_TLS_RSA_WITH_CAMELLIA_128_GCM_SHA256,
651 http2cipher_TLS_RSA_WITH_CAMELLIA_256_GCM_SHA384,
652 http2cipher_TLS_DH_RSA_WITH_CAMELLIA_128_GCM_SHA256,
653 http2cipher_TLS_DH_RSA_WITH_CAMELLIA_256_GCM_SHA384,
654 http2cipher_TLS_DH_DSS_WITH_CAMELLIA_128_GCM_SHA256,
655 http2cipher_TLS_DH_DSS_WITH_CAMELLIA_256_GCM_SHA384,
656 http2cipher_TLS_DH_anon_WITH_CAMELLIA_128_GCM_SHA256,
657 http2cipher_TLS_DH_anon_WITH_CAMELLIA_256_GCM_SHA384,
658 http2cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_128_GCM_SHA256,
659 http2cipher_TLS_ECDH_ECDSA_WITH_CAMELLIA_256_GCM_SHA384,
660 http2cipher_TLS_ECDH_RSA_WITH_CAMELLIA_128_GCM_SHA256,
661 http2cipher_TLS_ECDH_RSA_WITH_CAMELLIA_256_GCM_SHA384,
662 http2cipher_TLS_PSK_WITH_CAMELLIA_128_GCM_SHA256,
663 http2cipher_TLS_PSK_WITH_CAMELLIA_256_GCM_SHA384,
664 http2cipher_TLS_RSA_PSK_WITH_CAMELLIA_128_GCM_SHA256,
665 http2cipher_TLS_RSA_PSK_WITH_CAMELLIA_256_GCM_SHA384,
666 http2cipher_TLS_PSK_WITH_CAMELLIA_128_CBC_SHA256,
667 http2cipher_TLS_PSK_WITH_CAMELLIA_256_CBC_SHA384,
668 http2cipher_TLS_DHE_PSK_WITH_CAMELLIA_128_CBC_SHA256,
669 http2cipher_TLS_DHE_PSK_WITH_CAMELLIA_256_CBC_SHA384,
670 http2cipher_TLS_RSA_PSK_WITH_CAMELLIA_128_CBC_SHA256,
671 http2cipher_TLS_RSA_PSK_WITH_CAMELLIA_256_CBC_SHA384,
672 http2cipher_TLS_ECDHE_PSK_WITH_CAMELLIA_128_CBC_SHA256,
673 http2cipher_TLS_ECDHE_PSK_WITH_CAMELLIA_256_CBC_SHA384,
674 http2cipher_TLS_RSA_WITH_AES_128_CCM,
675 http2cipher_TLS_RSA_WITH_AES_256_CCM,
676 http2cipher_TLS_RSA_WITH_AES_128_CCM_8,
677 http2cipher_TLS_RSA_WITH_AES_256_CCM_8,
678 http2cipher_TLS_PSK_WITH_AES_128_CCM,
679 http2cipher_TLS_PSK_WITH_AES_256_CCM,
680 http2cipher_TLS_PSK_WITH_AES_128_CCM_8,
681 http2cipher_TLS_PSK_WITH_AES_256_CCM_8:
685 }
686 }
688 // ClientConnPool manages a pool of HTTP/2 client connections.
692 }
694 // clientConnPoolIdleCloser is the interface implemented by ClientConnPool
695 // implementations which can close their idle connections.
697 http2ClientConnPool
699 }
704 )
706 // TODO: use singleflight for dialing and addConnCalls?
708 t *http2Transport
711 // TODO: add support for sharing conns based on cert names
712 // (e.g. share conn for googleapis.com and appspot.com)
717 }
719 func (p *http2clientConnPool) GetClientConn(req *Request, addr string) (*http2ClientConn, error) {
721 }
726 )
728 // shouldTraceGetConn reports whether getClientConn should call any
729 // ClientTrace.GetConn hook associated with the http.Request.
730 //
731 // This complexity is needed to avoid double calls of the GetConn hook
732 // during the back-and-forth between net/http and x/net/http2 (when the
733 // net/http.Transport is upgraded to also speak http2), as well as support
734 // the case where x/net/http2 is being used directly.
736 // If our Transport wasn't made via ConfigureTransport, always
737 // trace the GetConn hook if provided, because that means the
738 // http2 package is being used directly and it's the one
739 // dialing, as opposed to net/http.
742 }
743 // Otherwise, only use the GetConn hook if this connection has
744 // been used previously for other requests. For fresh
745 // connections, the net/http package does the dialing.
747 }
749 func (p *http2clientConnPool) getClientConn(req *Request, addr string, dialOnMiss bool) (*http2ClientConn, error) {
751 // It gets its own connection.
757 }
759 }
765 }
768 }
769 }
773 }
779 }
781 // dialCall is an in-flight Transport dial call to a host.
783 p *http2clientConnPool
786 err error // valid after done is closed
787 }
789 // requires p.mu is held.
792 // A dial is already in-flight. Don't start another.
793 return call
794 }
798 }
801 return call
802 }
804 // run in its own goroutine.
814 }
816 }
818 // addConnIfNeeded makes a NewClientConn out of c if a connection for key doesn't
819 // already exist. It coalesces concurrent calls with the same key.
820 // This is used by the http1 Transport code when it creates a new connection. Because
821 // the http1 Transport doesn't de-dup TCP dials to outbound hosts (because it doesn't know
822 // the protocol), it can get into a situation where it has multiple TLS connections.
823 // This code decides which ones live or die.
824 // The return value used is whether c was used.
825 // c is never closed.
826 func (p *http2clientConnPool) addConnIfNeeded(key string, t *http2Transport, c *tls.Conn) (used bool, err error) {
832 }
833 }
838 }
842 }
845 }
851 }
853 }
856 p *http2clientConnPool
858 err error
859 }
870 }
874 }
880 }
882 // p.mu must be held
886 return
887 }
888 }
891 }
894 }
897 }
905 continue
906 }
912 }
913 }
915 }
920 // TODO: don't close a cc if it was just added to the pool
921 // milliseconds ago and has never been used. There's currently
922 // a small race window with the HTTP/1 Transport's integration
923 // where it can add an idle conn just before using it, and
924 // somebody else can concurrently call CloseIdleConns and
925 // break some caller's RoundTrip.
929 }
930 }
931 }
933 func http2filterOutClientConn(in []*http2ClientConn, exclude *http2ClientConn) []*http2ClientConn {
938 }
939 }
940 // If we filtered it out, zero out the last item to prevent
941 // the GC from seeing it.
944 }
945 return out
946 }
948 // noDialClientConnPool is an implementation of http2.ClientConnPool
949 // which never dials. We let the HTTP/1.1 client dial and use its TLS
950 // connection instead.
953 func (p http2noDialClientConnPool) GetClientConn(req *Request, addr string) (*http2ClientConn, error) {
955 }
962 }
966 }
969 }
972 }
975 }
982 // Turns out we don't need this c.
983 // For example, two goroutines made requests to the same host
984 // at the same time, both kicking off TCP dials. (since protocol
985 // was unknown)
987 }
988 return t2
989 }
993 }
996 }
998 }
1000 // registerHTTPSProtocol calls Transport.RegisterProtocol but
1001 // converting panics into errors.
1006 }
1007 }()
1010 }
1012 // noDialH2RoundTripper is a RoundTripper which only tries to complete the request
1013 // if there's already has a cached connection to the host.
1014 // (The field is exported so it can be accessed via reflect from net/http; tested
1015 // by TestNoDialH2RoundTripperType)
1022 }
1024 }
1026 // Buffer chunks are allocated from a pool to reduce pressure on GC.
1027 // The maximum wasted space per dataBuffer is 2x the largest size class,
1028 // which happens when the dataBuffer has multiple chunks and there is
1029 // one unread byte in both the first and last chunks. We use a few size
1030 // classes to minimize overheads for servers that typically receive very
1031 // small request bodies.
1032 //
1033 // TODO: Benchmark to determine if the pools are necessary. The GC may have
1034 // improved enough that we can instead allocate chunks like this:
1035 // make([]byte, max(16<<10, expectedBytesRemaining))
1043 }
1050 }
1051 )
1057 break
1058 }
1059 }
1061 }
1067 return
1068 }
1069 }
1071 }
1073 // dataBuffer is an io.ReadWriter backed by a list of data chunks.
1074 // Each dataBuffer is used to read DATA frames on a single stream.
1075 // The buffer is divided into chunks so the server can limit the
1076 // total memory used by a single connection without limiting the
1077 // request body size on any single stream.
1084 }
1088 // Read copies bytes from the buffer into p.
1089 // It is an error to read when no data is available.
1093 }
1099 ntotal += n
1102 // If the first chunk has been consumed, advance to the next chunk.
1110 }
1111 }
1113 }
1118 }
1120 }
1122 // Len returns the number of bytes of the unread portion of the buffer.
1125 }
1127 // Write appends p to the buffer.
1131 // If the last chunk is empty, allocate a new chunk. Try to allocate
1132 // enough to fully copy p plus any additional bytes we expect to
1133 // receive. However, this may allocate less than len(p).
1137 }
1144 }
1146 }
1152 return last
1153 }
1154 }
1158 return chunk
1159 }
1161 // An ErrCode is an unsigned 32-bit error code as defined in the HTTP/2 spec.
1179 )
1196 }
1200 return s
1201 }
1203 }
1205 // ConnectionError is an error that results in the termination of the
1206 // entire connection.
1207 type http2ConnectionError http2ErrCode
1211 }
1213 // StreamError is an error that only affects one stream within an
1214 // HTTP/2 connection.
1216 StreamID uint32
1217 Code http2ErrCode
1218 Cause error // optional additional detail
1219 }
1223 }
1228 }
1230 }
1232 // 6.9.1 The Flow Control Window
1233 // "If a sender receives a WINDOW_UPDATE that causes a flow control
1234 // window to exceed this maximum it MUST terminate either the stream
1235 // or the connection, as appropriate. For streams, [...]; for the
1236 // connection, a GOAWAY frame with a FLOW_CONTROL_ERROR code."
1239 func (http2goAwayFlowError) Error() string { return "connection exceeded flow control window size" }
1241 // connError represents an HTTP/2 ConnectionError error code, along
1242 // with a string (for debugging) explaining why.
1243 //
1244 // Errors of this type are only returned by the frame parser functions
1245 // and converted into ConnectionError(Code), after stashing away
1246 // the Reason into the Framer's errDetail field, accessible via
1247 // the (*Framer).ErrorDetail method.
1249 Code http2ErrCode // the ConnectionError error code
1251 }
1255 }
1261 }
1267 }
1273 }
1279 }
1284 )
1286 // flow is the flow control window's size.
1288 // n is the number of DATA bytes we're allowed to send.
1289 // A flow is kept both on a conn and a per-stream.
1290 n int32
1292 // conn points to the shared connection-level flow that is
1293 // shared by all streams on that conn. It is nil for the flow
1294 // that's on the conn directly.
1295 conn *http2flow
1296 }
1304 }
1305 return n
1306 }
1311 }
1315 }
1316 }
1318 // add adds n bytes (positive or negative) to the flow control window.
1319 // It returns false if the sum would exceed 2^31-1.
1325 }
1327 }
1333 // A FrameType is a registered frame type as defined in
1334 // http://http2.github.io/http2-spec/#rfc.section.11.2
1348 )
1361 }
1365 return s
1366 }
1368 }
1370 // Flags is a bitmask of HTTP/2 flags.
1371 // The meaning of flags varies depending on the frame type.
1374 // Has reports whether f contains all (0 or more) flags in v.
1377 }
1379 // Frame-specific FrameHeader flag bits.
1381 // Data Frame
1385 // Headers Frame
1391 // Settings Frame
1394 // Ping Frame
1397 // Continuation Frame
1402 )
1405 http2FrameData: {
1408 },
1409 http2FrameHeaders: {
1414 },
1415 http2FrameSettings: {
1417 },
1418 http2FramePing: {
1420 },
1421 http2FrameContinuation: {
1423 },
1424 http2FramePushPromise: {
1427 },
1428 }
1430 // a frameParser parses a frame given its FrameHeader and payload
1431 // bytes. The length of payload will always equal fh.Length (which
1432 // might be 0).
1433 type http2frameParser func(fc *http2frameCache, fh http2FrameHeader, payload []byte) (http2Frame, error)
1446 }
1450 return f
1451 }
1452 return http2parseUnknownFrame
1453 }
1455 // A FrameHeader is the 9 byte header of all HTTP/2 frames.
1456 //
1457 // See http://http2.github.io/http2-spec/#FrameHeader
1461 // Type is the 1 byte frame type. There are ten standard frame
1462 // types, but extension frame types may be written by WriteRawFrame
1463 // and will be returned by ReadFrame (as UnknownFrame).
1464 Type http2FrameType
1466 // Flags are the 1 byte of 8 potential bit flags per frame.
1467 // They are specific to the frame type.
1468 Flags http2Flags
1470 // Length is the length of the frame, not including the 9 byte header.
1471 // The maximum size is one byte less than 16MB (uint24), but only
1472 // frames up to 16KB are allowed without peer agreement.
1473 Length uint32
1475 // StreamID is which stream this frame is for. Certain frames
1476 // are not stream-specific, in which case this field is 0.
1477 StreamID uint32
1478 }
1480 // Header returns h. It exists so FrameHeaders can be embedded in other
1481 // specific frame types and implement the Frame interface.
1490 }
1499 continue
1500 }
1501 set++
1504 }
1510 }
1511 }
1512 }
1515 }
1517 }
1522 }
1523 }
1527 // frame header bytes.
1528 // Used only by ReadFrameHeader.
1533 },
1534 }
1536 // ReadFrameHeader reads 9 bytes from r and returns a FrameHeader.
1537 // Most users should use Framer.ReadFrame instead.
1542 }
1548 }
1556 }
1558 // A Frame is the base interface implemented by all frame types.
1559 // Callers will generally type-assert the specific frame type:
1560 // *HeadersFrame, *SettingsFrame, *WindowUpdateFrame, etc.
1561 //
1562 // Frames are only valid until the next call to Framer.ReadFrame.
1566 // invalidate is called by Framer.ReadFrame to make this
1567 // frame's buffers as being invalid, since the subsequent
1568 // frame will reuse them.
1570 }
1572 // A Framer reads and writes Frames.
1574 r io.Reader
1575 lastFrame http2Frame
1576 errDetail error
1578 // lastHeaderStream is non-zero if the last frame was an
1579 // unfinished HEADERS/CONTINUATION.
1580 lastHeaderStream uint32
1582 maxReadSize uint32
1585 // TODO: let getReadBuf be configurable, and use a less memory-pinning
1586 // allocator in server.go to minimize memory pinned for many idle conns.
1587 // Will probably also need to make frame invalidation have a hook too.
1593 w io.Writer
1596 // AllowIllegalWrites permits the Framer's Write methods to
1597 // write frames that do not conform to the HTTP/2 spec. This
1598 // permits using the Framer to test other HTTP/2
1599 // implementations' conformance to the spec.
1600 // If false, the Write methods will prefer to return an error
1601 // rather than comply.
1602 AllowIllegalWrites bool
1604 // AllowIllegalReads permits the Framer's ReadFrame method
1605 // to return non-compliant frames or frame orders.
1606 // This is for testing and permits using the Framer to test
1607 // other HTTP/2 implementations' conformance to the spec.
1608 // It is not compatible with ReadMetaHeaders.
1609 AllowIllegalReads bool
1611 // ReadMetaHeaders if non-nil causes ReadFrame to merge
1612 // HEADERS and CONTINUATION frames together and return
1613 // MetaHeadersFrame instead.
1616 // MaxHeaderListSize is the http2 MAX_HEADER_LIST_SIZE.
1617 // It's used only if ReadMetaHeaders is set; 0 means a sane default
1618 // (currently 16MB)
1619 // If the limit is hit, MetaHeadersFrame.Truncated is set true.
1620 MaxHeaderListSize uint32
1622 // TODO: track which type of frame & with which flags was sent
1623 // last. Then return an error (unless AllowIllegalWrites) if
1624 // we're in the middle of a header block and a
1625 // non-Continuation or Continuation on a different stream is
1626 // attempted to be written.
1636 }
1641 }
1643 }
1646 // Write the FrameHeader.
1657 }
1660 // Now that we know the final size, fill in the FrameHeader in
1661 // the space previously reserved for it. Abuse append.
1664 return http2ErrFrameTooLarge
1665 }
1672 }
1677 }
1678 return err
1679 }
1686 // Let us read anything, even if we accidentally wrote it
1687 // in the wrong order:
1689 }
1694 return
1695 }
1697 }
1707 }
1712 )
1714 // SetReuseFrames allows the Framer to reuse Frames.
1715 // If called on a Framer, Frames returned by calls to ReadFrame are only
1716 // valid until the next call to ReadFrame.
1719 return
1720 }
1722 }
1725 dataFrame http2DataFrame
1726 }
1731 }
1733 }
1735 // NewFramer returns a Framer that writes frames to w and reads them from r.
1744 }
1748 }
1751 }
1753 return fr
1754 }
1756 // SetMaxReadFrameSize sets the maximum size of a frame
1757 // that will be read by a subsequent call to ReadFrame.
1758 // It is the caller's responsibility to advertise this
1759 // limit with a SETTINGS frame.
1762 v = http2maxFrameSize
1763 }
1765 }
1767 // ErrorDetail returns a more detailed error of the last error
1768 // returned by Framer.ReadFrame. For instance, if ReadFrame
1769 // returns a StreamError with code PROTOCOL_ERROR, ErrorDetail
1770 // will say exactly what was invalid. ErrorDetail is not guaranteed
1771 // to return a non-nil value and like the rest of the http2 package,
1772 // its return value is not protected by an API compatibility promise.
1773 // ErrorDetail is reset after the next call to ReadFrame.
1776 }
1778 // ErrFrameTooLarge is returned from Framer.ReadFrame when the peer
1779 // sends a frame that is larger than declared with SetMaxReadFrameSize.
1782 // terminalReadFrameError reports whether err is an unrecoverable
1783 // error from ReadFrame and no other frames should be read.
1787 }
1789 }
1791 // ReadFrame reads a single frame. The returned Frame is only valid
1792 // until the next call to ReadFrame.
1793 //
1794 // If the frame is larger than previously set with SetMaxReadFrameSize, the
1795 // returned error is ErrFrameTooLarge. Other errors may be of type
1796 // ConnectionError, StreamError, or anything else from the underlying
1797 // reader.
1802 }
1806 }
1809 }
1813 }
1818 }
1820 }
1823 }
1826 }
1829 }
1831 }
1833 // connError returns ConnectionError(code) but first
1834 // stashes away a public reason to the caller can optionally relay it
1835 // to the peer before hanging up on them. This might help others debug
1836 // their implementations.
1840 }
1842 // checkFrameOrder reports an error if f is an invalid frame to return
1843 // next from ReadFrame. Mostly it checks whether HEADERS and
1844 // CONTINUATION frames are contiguous.
1850 }
1859 }
1864 }
1866 return fr.connError(http2ErrCodeProtocol, fmt.Sprintf("unexpected CONTINUATION for stream %d", fh.StreamID))
1867 }
1875 }
1876 }
1879 }
1881 // A DataFrame conveys arbitrary, variable-length sequences of octets
1882 // associated with a stream.
1883 // See http://http2.github.io/http2-spec/#rfc.section.6.1
1885 http2FrameHeader
1887 }
1891 }
1893 // Data returns the frame's data octets, not including any padding
1894 // size byte or padding suffix bytes.
1895 // The caller must not retain the returned memory past the next
1896 // call to ReadFrame.
1900 }
1902 func http2parseDataFrame(fc *http2frameCache, fh http2FrameHeader, payload []byte) (http2Frame, error) {
1904 // DATA frames MUST be associated with a stream. If a
1905 // DATA frame is received whose stream identifier
1906 // field is 0x0, the recipient MUST respond with a
1907 // connection error (Section 5.4.1) of type
1908 // PROTOCOL_ERROR.
1910 }
1916 var err error
1920 }
1921 }
1923 // If the length of the padding is greater than the
1924 // length of the frame payload, the recipient MUST
1925 // treat this as a connection error.
1926 // Filed: https://github.com/http2/http2-spec/issues/610
1928 }
1931 }
1937 http2errPadBytes = errors.New("padding bytes must all be zeros unless AllowIllegalWrites is enabled")
1938 )
1942 }
1946 }
1948 // WriteData writes a DATA frame.
1949 //
1950 // It will perform exactly one Write to the underlying Writer.
1951 // It is the caller's responsibility not to violate the maximum frame size
1952 // and to not call other Write methods concurrently.
1955 }
1957 // WriteData writes a DATA frame with optional padding.
1958 //
1959 // If pad is nil, the padding bit is not sent.
1960 // The length of pad must not exceed 255 bytes.
1961 // The bytes of pad must all be zero, unless f.AllowIllegalWrites is set.
1962 //
1963 // It will perform exactly one Write to the underlying Writer.
1964 // It is the caller's responsibility not to violate the maximum frame size
1965 // and to not call other Write methods concurrently.
1966 func (f *http2Framer) WriteDataPadded(streamID uint32, endStream bool, data, pad []byte) error {
1968 return http2errStreamID
1969 }
1972 return http2errPadLength
1973 }
1977 // "Padding octets MUST be set to zero when sending."
1978 return http2errPadBytes
1979 }
1980 }
1981 }
1982 }
1983 var flags http2Flags
1985 flags |= http2FlagDataEndStream
1986 }
1988 flags |= http2FlagDataPadded
1989 }
1993 }
1997 }
1999 // A SettingsFrame conveys configuration parameters that affect how
2000 // endpoints communicate, such as preferences and constraints on peer
2001 // behavior.
2002 //
2003 // See http://http2.github.io/http2-spec/#SETTINGS
2005 http2FrameHeader
2007 }
2009 func http2parseSettingsFrame(_ *http2frameCache, fh http2FrameHeader, p []byte) (http2Frame, error) {
2011 // When this (ACK 0x1) bit is set, the payload of the
2012 // SETTINGS frame MUST be empty. Receipt of a
2013 // SETTINGS frame with the ACK flag set and a length
2014 // field value other than 0 MUST be treated as a
2015 // connection error (Section 5.4.1) of type
2016 // FRAME_SIZE_ERROR.
2018 }
2020 // SETTINGS frames always apply to a connection,
2021 // never a single stream. The stream identifier for a
2022 // SETTINGS frame MUST be zero (0x0). If an endpoint
2023 // receives a SETTINGS frame whose stream identifier
2024 // field is anything other than 0x0, the endpoint MUST
2025 // respond with a connection error (Section 5.4.1) of
2026 // type PROTOCOL_ERROR.
2028 }
2030 // Expecting even number of 6 byte settings.
2032 }
2035 // Values above the maximum flow control window size of 2^31 - 1 MUST
2036 // be treated as a connection error (Section 5.4.1) of type
2037 // FLOW_CONTROL_ERROR.
2039 }
2041 }
2045 }
2052 }
2053 }
2055 }
2057 // Setting returns the setting from the frame at the given 0-based index.
2058 // The index must be >= 0 and less than f.NumSettings().
2064 }
2065 }
2069 // HasDuplicates reports whether f contains any duplicate setting IDs.
2074 }
2075 // If it's small enough (the common case), just do the n^2
2076 // thing and avoid a map allocation.
2084 }
2085 }
2086 }
2088 }
2094 }
2096 }
2098 }
2100 // ForeachSetting runs fn for each setting.
2101 // It stops and returns the first error.
2106 return err
2107 }
2108 }
2110 }
2112 // WriteSettings writes a SETTINGS frame with zero or more settings
2113 // specified and the ACK bit not set.
2114 //
2115 // It will perform exactly one Write to the underlying Writer.
2116 // It is the caller's responsibility to not call other Write methods concurrently.
2122 }
2124 }
2126 // WriteSettingsAck writes an empty SETTINGS frame with the ACK bit set.
2127 //
2128 // It will perform exactly one Write to the underlying Writer.
2129 // It is the caller's responsibility to not call other Write methods concurrently.
2133 }
2135 // A PingFrame is a mechanism for measuring a minimal round trip time
2136 // from the sender, as well as determining whether an idle connection
2137 // is still functional.
2138 // See http://http2.github.io/http2-spec/#rfc.section.6.7
2140 http2FrameHeader
2142 }
2146 func http2parsePingFrame(_ *http2frameCache, fh http2FrameHeader, payload []byte) (http2Frame, error) {
2149 }
2152 }
2156 }
2159 var flags http2Flags
2161 flags = http2FlagPingAck
2162 }
2166 }
2168 // A GoAwayFrame informs the remote peer to stop creating streams on this connection.
2169 // See http://http2.github.io/http2-spec/#rfc.section.6.8
2171 http2FrameHeader
2172 LastStreamID uint32
2173 ErrCode http2ErrCode
2175 }
2177 // DebugData returns any debug data in the GOAWAY frame. Its contents
2178 // are not defined.
2179 // The caller must not retain the returned memory past the next
2180 // call to ReadFrame.
2184 }
2186 func http2parseGoAwayFrame(_ *http2frameCache, fh http2FrameHeader, p []byte) (http2Frame, error) {
2189 }
2192 }
2199 }
2201 func (f *http2Framer) WriteGoAway(maxStreamID uint32, code http2ErrCode, debugData []byte) error {
2207 }
2209 // An UnknownFrame is the frame type returned when the frame type is unknown
2210 // or no specific frame type parser exists.
2212 http2FrameHeader
2214 }
2216 // Payload returns the frame's payload (after the header). It is not
2217 // valid to call this method after a subsequent call to
2218 // Framer.ReadFrame, nor is it valid to retain the returned slice.
2219 // The memory is owned by the Framer and is invalidated when the next
2220 // frame is read.
2224 }
2226 func http2parseUnknownFrame(_ *http2frameCache, fh http2FrameHeader, p []byte) (http2Frame, error) {
2228 }
2230 // A WindowUpdateFrame is used to implement flow control.
2231 // See http://http2.github.io/http2-spec/#rfc.section.6.9
2233 http2FrameHeader
2235 }
2237 func http2parseWindowUpdateFrame(_ *http2frameCache, fh http2FrameHeader, p []byte) (http2Frame, error) {
2240 }
2243 // A receiver MUST treat the receipt of a
2244 // WINDOW_UPDATE frame with an flow control window
2245 // increment of 0 as a stream error (Section 5.4.2) of
2246 // type PROTOCOL_ERROR; errors on the connection flow
2247 // control window MUST be treated as a connection
2248 // error (Section 5.4.1).
2251 }
2253 }
2258 }
2260 // WriteWindowUpdate writes a WINDOW_UPDATE frame.
2261 // The increment value must be between 1 and 2,147,483,647, inclusive.
2262 // If the Stream ID is zero, the window update applies to the
2263 // connection as a whole.
2265 // "The legal range for the increment to the flow control window is 1 to 2^31-1 (2,147,483,647) octets."
2268 }
2272 }
2274 // A HeadersFrame is used to open a stream and additionally carries a
2275 // header block fragment.
2277 http2FrameHeader
2279 // Priority is set if FlagHeadersPriority is set in the FrameHeader.
2280 Priority http2PriorityParam
2283 }
2288 }
2292 }
2296 }
2300 }
2302 func http2parseHeadersFrame(_ *http2frameCache, fh http2FrameHeader, p []byte) (_ http2Frame, err error) {
2305 }
2307 // HEADERS frames MUST be associated with a stream. If a HEADERS frame
2308 // is received whose stream identifier field is 0x0, the recipient MUST
2309 // respond with a connection error (Section 5.4.1) of type
2310 // PROTOCOL_ERROR.
2312 }
2316 return
2317 }
2318 }
2324 }
2330 }
2331 }
2334 }
2337 }
2339 // HeadersFrameParam are the parameters for writing a HEADERS frame.
2341 // StreamID is the required Stream ID to initiate.
2342 StreamID uint32
2343 // BlockFragment is part (or all) of a Header Block.
2346 // EndStream indicates that the header block is the last that
2347 // the endpoint will send for the identified stream. Setting
2348 // this flag causes the stream to enter one of "half closed"
2349 // states.
2350 EndStream bool
2352 // EndHeaders indicates that this frame contains an entire
2353 // header block and is not followed by any
2354 // CONTINUATION frames.
2355 EndHeaders bool
2357 // PadLength is the optional number of bytes of zeros to add
2358 // to this frame.
2359 PadLength uint8
2361 // Priority, if non-zero, includes stream priority information
2362 // in the HEADER frame.
2363 Priority http2PriorityParam
2364 }
2366 // WriteHeaders writes a single HEADERS frame.
2367 //
2368 // This is a low-level header writing method. Encoding headers and
2369 // splitting them into any necessary CONTINUATION frames is handled
2370 // elsewhere.
2371 //
2372 // It will perform exactly one Write to the underlying Writer.
2373 // It is the caller's responsibility to not call other Write methods concurrently.
2376 return http2errStreamID
2377 }
2378 var flags http2Flags
2380 flags |= http2FlagHeadersPadded
2381 }
2383 flags |= http2FlagHeadersEndStream
2384 }
2386 flags |= http2FlagHeadersEndHeaders
2387 }
2389 flags |= http2FlagHeadersPriority
2390 }
2394 }
2398 return http2errDepStreamID
2399 }
2402 }
2405 }
2409 }
2411 // A PriorityFrame specifies the sender-advised priority of a stream.
2412 // See http://http2.github.io/http2-spec/#rfc.section.6.3
2414 http2FrameHeader
2415 http2PriorityParam
2416 }
2418 // PriorityParam are the stream prioritzation parameters.
2420 // StreamDep is a 31-bit stream identifier for the
2421 // stream that this stream depends on. Zero means no
2422 // dependency.
2423 StreamDep uint32
2425 // Exclusive is whether the dependency is exclusive.
2426 Exclusive bool
2428 // Weight is the stream's zero-indexed weight. It should be
2429 // set together with StreamDep, or neither should be set. Per
2430 // the spec, "Add one to the value to obtain a weight between
2431 // 1 and 256."
2432 Weight uint8
2433 }
2437 }
2439 func http2parsePriorityFrame(_ *http2frameCache, fh http2FrameHeader, payload []byte) (http2Frame, error) {
2442 }
2444 return nil, http2connError{http2ErrCodeFrameSize, fmt.Sprintf("PRIORITY frame payload size was %d; want 5", len(payload))}
2445 }
2454 },
2456 }
2458 // WritePriority writes a PRIORITY frame.
2459 //
2460 // It will perform exactly one Write to the underlying Writer.
2461 // It is the caller's responsibility to not call other Write methods concurrently.
2464 return http2errStreamID
2465 }
2467 return http2errDepStreamID
2468 }
2473 }
2477 }
2479 // A RSTStreamFrame allows for abnormal termination of a stream.
2480 // See http://http2.github.io/http2-spec/#rfc.section.6.4
2482 http2FrameHeader
2483 ErrCode http2ErrCode
2484 }
2486 func http2parseRSTStreamFrame(_ *http2frameCache, fh http2FrameHeader, p []byte) (http2Frame, error) {
2489 }
2492 }
2494 }
2496 // WriteRSTStream writes a RST_STREAM frame.
2497 //
2498 // It will perform exactly one Write to the underlying Writer.
2499 // It is the caller's responsibility to not call other Write methods concurrently.
2502 return http2errStreamID
2503 }
2507 }
2509 // A ContinuationFrame is used to continue a sequence of header block fragments.
2510 // See http://http2.github.io/http2-spec/#rfc.section.6.10
2512 http2FrameHeader
2514 }
2516 func http2parseContinuationFrame(_ *http2frameCache, fh http2FrameHeader, p []byte) (http2Frame, error) {
2519 }
2521 }
2526 }
2530 }
2532 // WriteContinuation writes a CONTINUATION frame.
2533 //
2534 // It will perform exactly one Write to the underlying Writer.
2535 // It is the caller's responsibility to not call other Write methods concurrently.
2536 func (f *http2Framer) WriteContinuation(streamID uint32, endHeaders bool, headerBlockFragment []byte) error {
2538 return http2errStreamID
2539 }
2540 var flags http2Flags
2542 flags |= http2FlagContinuationEndHeaders
2543 }
2547 }
2549 // A PushPromiseFrame is used to initiate a server stream.
2550 // See http://http2.github.io/http2-spec/#rfc.section.6.6
2552 http2FrameHeader
2553 PromiseID uint32
2555 }
2560 }
2564 }
2566 func http2parsePushPromise(_ *http2frameCache, fh http2FrameHeader, p []byte) (_ http2Frame, err error) {
2569 }
2571 // PUSH_PROMISE frames MUST be associated with an existing,
2572 // peer-initiated stream. The stream identifier of a
2573 // PUSH_PROMISE frame indicates the stream it is associated
2574 // with. If the stream identifier field specifies the value
2575 // 0x0, a recipient MUST respond with a connection error
2576 // (Section 5.4.1) of type PROTOCOL_ERROR.
2578 }
2579 // The PUSH_PROMISE frame includes optional padding.
2580 // Padding fields and flags are identical to those defined for DATA frames
2584 return
2585 }
2586 }
2590 return
2591 }
2595 // like the DATA frame, error out if padding is longer than the body.
2597 }
2600 }
2602 // PushPromiseParam are the parameters for writing a PUSH_PROMISE frame.
2604 // StreamID is the required Stream ID to initiate.
2605 StreamID uint32
2607 // PromiseID is the required Stream ID which this
2608 // Push Promises
2609 PromiseID uint32
2611 // BlockFragment is part (or all) of a Header Block.
2614 // EndHeaders indicates that this frame contains an entire
2615 // header block and is not followed by any
2616 // CONTINUATION frames.
2617 EndHeaders bool
2619 // PadLength is the optional number of bytes of zeros to add
2620 // to this frame.
2621 PadLength uint8
2622 }
2624 // WritePushPromise writes a single PushPromise Frame.
2625 //
2626 // As with Header Frames, This is the low level call for writing
2627 // individual frames. Continuation frames are handled elsewhere.
2628 //
2629 // It will perform exactly one Write to the underlying Writer.
2630 // It is the caller's responsibility to not call other Write methods concurrently.
2633 return http2errStreamID
2634 }
2635 var flags http2Flags
2637 flags |= http2FlagPushPromisePadded
2638 }
2640 flags |= http2FlagPushPromiseEndHeaders
2641 }
2645 }
2647 return http2errStreamID
2648 }
2653 }
2655 // WriteRawFrame writes a raw frame. This can be used to write
2656 // extension frames unknown to this package.
2657 func (f *http2Framer) WriteRawFrame(t http2FrameType, flags http2Flags, streamID uint32, payload []byte) error {
2661 }
2666 }
2668 }
2673 }
2675 }
2679 }
2683 }
2686 http2headersEnder
2688 }
2690 // A MetaHeadersFrame is the representation of one HEADERS frame and
2691 // zero or more contiguous CONTINUATION frames and the decoding of
2692 // their HPACK-encoded contents.
2693 //
2694 // This type of frame does not appear on the wire and is only returned
2695 // by the Framer when Framer.ReadMetaHeaders is set.
2697 *http2HeadersFrame
2699 // Fields are the fields contained in the HEADERS and
2700 // CONTINUATION frames. The underlying slice is owned by the
2701 // Framer and must not be retained after the next call to
2702 // ReadFrame.
2703 //
2704 // Fields are guaranteed to be in the correct http2 order and
2705 // not have unknown pseudo header fields or invalid header
2706 // field names or values. Required pseudo header fields may be
2707 // missing, however. Use the MetaHeadersFrame.Pseudo accessor
2708 // method access pseudo headers.
2711 // Truncated is whether the max header list size limit was hit
2712 // and Fields is incomplete. The hpack decoder state is still
2713 // valid, however.
2714 Truncated bool
2715 }
2717 // PseudoValue returns the given pseudo header field's value.
2718 // The provided pseudo field should not contain the leading colon.
2723 }
2726 }
2727 }
2729 }
2731 // RegularFields returns the regular (non-pseudo) header fields of mh.
2732 // The caller does not own the returned slice.
2737 }
2738 }
2740 }
2742 // PseudoFields returns the pseudo header fields of mh.
2743 // The caller does not own the returned slice.
2748 }
2749 }
2751 }
2764 }
2765 // Check for duplicates.
2766 // This would be a bad algorithm, but N is 4.
2767 // And this doesn't allocate.
2771 }
2772 }
2773 }
2775 return http2errMixPseudoHeaderTypes
2776 }
2778 }
2784 }
2785 // They had a crazy big number for MaxHeaderBytes anyway,
2786 // so give them unlimited header lengths:
2788 }
2790 // readMetaFrame returns 0 or more CONTINUATION frames from fr and
2791 // merge them into into the provided hf and returns a MetaHeadersFrame
2792 // with the decoded hpack values.
2796 }
2799 }
2810 }
2813 }
2817 invalid = http2errPseudoAfterRegular
2818 }
2823 }
2824 }
2828 return
2829 }
2835 return
2836 }
2837 remainSize -= size
2840 })
2841 // Lose reference to MetaHeadersFrame:
2849 }
2852 break
2853 }
2858 }
2859 }
2866 }
2871 }
2873 }
2878 }
2880 }
2882 }
2891 n++
2894 }
2897 })
2900 }
2906 }
2910 }
2914 }
2923 }
2925 }
2929 }
2934 }
2935 }
2937 func http2traceGot1xxResponseFunc(trace *http2clientTrace) func(int, textproto.MIMEHeader) error {
2940 }
2942 }
2946 }
2949 context.Context
2950 }
2954 func http2serverConnBaseContext(c net.Conn, opts *http2ServeConnOpts) (ctx http2contextContext, cancel func()) {
2959 }
2960 return
2961 }
2965 }
2969 }
2978 }
2980 }
2987 return
2988 }
2990 }
2995 return
2996 }
3003 }
3007 }
3012 }
3013 }
3018 }
3019 }
3024 }
3025 }
3030 }
3031 }
3036 }
3037 }
3042 }
3044 // Ping sends a PING frame to the server and waits for the ack.
3047 }
3049 // Shutdown gracefully closes the client connection, waiting for running streams to complete.
3052 }
3057 return c2
3058 }
3062 // Push implements http.Pusher.
3068 }
3070 }
3078 }
3079 }
3081 }
3085 }
3089 }
3093 }
3100 }
3109 }
3111 }
3115 return
3116 }
3119 }
3120 }
3124 return
3125 }
3128 }
3129 }
3136 b := *bp
3138 // Parse the 4707 out of "goroutine 4707 ["
3143 }
3148 }
3149 return n
3150 }
3156 },
3157 }
3159 // parseUintBytes is like strconv.ParseUint, but using a []byte.
3165 }
3167 s0 := s
3171 goto Error
3174 // valid base; nothing to do
3177 // Look for octal, hex prefix.
3184 goto Error
3185 }
3190 }
3194 goto Error
3195 }
3214 goto Error
3215 }
3219 goto Error
3220 }
3223 // n*base overflows
3226 goto Error
3227 }
3232 // n+v overflows
3235 goto Error
3236 }
3237 n = n1
3238 }
3242 Error:
3244 }
3246 // Return the first number n such that n*base >= 1<<64.
3250 }
3252 }
3257 )
3308 } {
3312 }
3313 }
3317 return s
3318 }
3320 }
3323 http2VerboseLogs bool
3324 http2logFrameWrites bool
3325 http2logFrameReads bool
3326 http2inTests bool
3327 )
3333 }
3338 }
3339 }
3342 // ClientPreface is the string that must be sent by new
3343 // connections from clients.
3346 // SETTINGS_MAX_FRAME_SIZE default
3347 // http://http2.github.io/http2-spec/#rfc.section.6.5.2
3350 // NextProtoTLS is the NPN/ALPN protocol negotiated during
3351 // HTTP/2's TLS setup.
3354 // http://http2.github.io/http2-spec/#SettingValues
3360 )
3364 )
3368 // HTTP/2 stream states.
3369 //
3370 // See http://tools.ietf.org/html/rfc7540#section-5.1.
3371 //
3372 // For simplicity, the server code merges "reserved (local)" into
3373 // "half-closed (remote)". This is one less state transition to track.
3374 // The only downside is that we send PUSH_PROMISEs slightly less
3375 // liberally than allowable. More discussion here:
3376 // https://lists.w3.org/Archives/Public/ietf-http-wg/2016JulSep/0599.html
3377 //
3378 // "reserved (remote)" is omitted since the client code does not
3379 // support server push.
3382 http2stateOpen
3383 http2stateHalfClosedLocal
3384 http2stateHalfClosedRemote
3385 http2stateClosed
3386 )
3394 }
3398 }
3400 // Setting is a setting parameter: which setting it is, and its value.
3402 // ID is which setting is being set.
3403 // See http://http2.github.io/http2-spec/#SettingValues
3404 ID http2SettingID
3406 // Val is the value.
3407 Val uint32
3408 }
3412 }
3414 // Valid reports whether the setting is valid.
3416 // Limits and error codes from 6.5.2 Defined SETTINGS Parameters
3421 }
3425 }
3429 }
3430 }
3432 }
3434 // A SettingID is an HTTP/2 setting as defined in
3435 // http://http2.github.io/http2-spec/#iana-settings
3445 )
3454 }
3458 return v
3459 }
3461 }
3466 )
3468 // validWireHeaderFieldName reports whether v is a valid header field
3469 // name (key). See httpguts.ValidHeaderName for the base rules.
3470 //
3471 // Further, http2 says:
3472 // "Just as in HTTP/1.x, header field names are strings of ASCII
3473 // characters that are compared in a case-insensitive
3474 // fashion. However, header field names MUST be converted to
3475 // lowercase prior to their encoding in HTTP/2. "
3479 }
3483 }
3486 }
3487 }
3489 }
3497 }
3498 }
3499 }
3503 return s
3504 }
3506 }
3508 // from pkg io
3511 }
3513 // A gate lets two goroutines coordinate their activities.
3520 // A closeWaiter is like a sync.WaitGroup but only goes 1 to 0 (open to closed).
3523 // Init makes a closeWaiter usable.
3524 // It exists because so a closeWaiter value can be placed inside a
3525 // larger struct and have the Mutex and Cond's memory in the same
3526 // allocation.
3529 }
3531 // Close marks the closeWaiter as closed and unblocks any waiters.
3534 }
3536 // Wait waits for the closeWaiter to become closed.
3538 <-cw
3539 }
3541 // bufferedWriter is a buffered writer that writes to w.
3542 // Its buffered writer is lazily allocated as needed, to minimize
3543 // idle memory usage with many connections.
3547 }
3551 }
3553 // bufWriterPoolBufferSize is the size of bufio.Writer's
3554 // buffers created using bufWriterPool.
3555 //
3556 // TODO: pick a less arbitrary value? this is a bit under
3557 // (3 x typical 1500 byte MTU) at least. Other than that,
3558 // not much thought went into it.
3564 },
3565 }
3569 return http2bufWriterPoolBufferSize
3570 }
3572 }
3579 }
3581 }
3587 }
3592 return err
3593 }
3598 }
3600 }
3602 // bodyAllowedForStatus reports whether a given response status code
3603 // permits a body. See RFC 7230, section 3.3.
3612 }
3614 }
3617 msg string
3618 timeout bool
3619 }
3627 var http2errTimeout error = &http2httpError{msg: "http2: timeout awaiting response headers", timeout: true}
3631 }
3637 }
3645 // Keys returns the sorted keys of h.
3646 //
3647 // The returned slice is only valid until s used again or returned to
3648 // its pool.
3653 }
3656 return keys
3657 }
3660 // Our sorter works on s.v, which sorter owns, so
3661 // stash it away while we sort the user's buffer.
3666 }
3668 // validPseudoPath reports whether v is a valid :path pseudo-header
3669 // value. It must be either:
3670 //
3671 // *) a non-empty string starting with '/'
3672 // *) the string '*', for OPTIONS requests.
3673 //
3674 // For now this is only used a quick check for deciding when to clean
3675 // up Opaque URLs before sending requests from the Transport.
3676 // See golang.org/issue/16847
3677 //
3678 // We used to enforce that the path also didn't start with "//", but
3679 // Google's GFE accepts such paths and Chrome sends them, so ignore
3680 // that part of the spec. See golang.org/issue/19103.
3683 }
3685 // pipe is a goroutine-safe io.Reader/io.Writer pair. It's like
3686 // io.Pipe except there are no PipeReader/PipeWriter halves, and the
3687 // underlying buffer is an interface. (io.Pipe is always unbuffered)
3689 mu sync.Mutex
3691 b http2pipeBuffer // nil when done reading
3692 err error // read error once empty. non-nil means closed.
3693 breakErr error // immediate read error (caller doesn't see rest of b)
3696 }
3700 io.Writer
3701 io.Reader
3702 }
3709 }
3711 }
3713 // Read waits until data is available and copies bytes
3714 // from the buffer into p.
3720 }
3724 }
3727 }
3732 }
3735 }
3737 }
3738 }
3742 // Write copies bytes from p into the buffer and wakes a reader.
3743 // It is an error to write more data than the buffer can hold.
3749 }
3753 }
3756 }
3758 }
3760 // CloseWithError causes the next Read (waking up a current blocked
3761 // Read if needed) to return the provided err after all data has been
3762 // read.
3763 //
3764 // The error must be non-nil.
3767 // BreakWithError causes the next Read (waking up a current blocked
3768 // Read if needed) to return the provided err immediately, without
3769 // waiting for unread data.
3772 // closeWithErrorAndCode is like CloseWithError but also sets some code to run
3773 // in the caller's goroutine before returning the error.
3774 func (p *http2pipe) closeWithErrorAndCode(err error, fn func()) { p.closeWithError(&p.err, err, fn) }
3779 }
3784 }
3787 // Already been done.
3788 return
3789 }
3793 }
3796 }
3798 // requires p.mu be held.
3801 return
3802 }
3803 // Close if unclosed. This isn't racy since we always
3804 // hold p.mu while closing.
3809 }
3810 }
3812 // Err returns the error (if any) first set by BreakWithError or CloseWithError.
3818 }
3820 }
3822 // Done returns a channel which is closed if and when this pipe is closed
3823 // with CloseWithError.
3830 // Already hit an error.
3832 }
3833 }
3835 }
3842 )
3849 )
3855 return rws
3856 },
3857 }
3859 // Test hooks.
3865 )
3867 // Server is an HTTP/2 server.
3869 // MaxHandlers limits the number of http.Handler ServeHTTP goroutines
3870 // which may run at a time over all connections.
3871 // Negative or zero no limit.
3872 // TODO: implement
3873 MaxHandlers int
3875 // MaxConcurrentStreams optionally specifies the number of
3876 // concurrent streams that each client may have open at a
3877 // time. This is unrelated to the number of http.Handler goroutines
3878 // which may be active globally, which is MaxHandlers.
3879 // If zero, MaxConcurrentStreams defaults to at least 100, per
3880 // the HTTP/2 spec's recommendations.
3881 MaxConcurrentStreams uint32
3883 // MaxReadFrameSize optionally specifies the largest frame
3884 // this server is willing to read. A valid value is between
3885 // 16k and 16M, inclusive. If zero or otherwise invalid, a
3886 // default value is used.
3887 MaxReadFrameSize uint32
3889 // PermitProhibitedCipherSuites, if true, permits the use of
3890 // cipher suites prohibited by the HTTP/2 spec.
3891 PermitProhibitedCipherSuites bool
3893 // IdleTimeout specifies how long until idle clients should be
3894 // closed with a GOAWAY frame. PING frames are not considered
3895 // activity for the purposes of IdleTimeout.
3896 IdleTimeout time.Duration
3898 // MaxUploadBufferPerConnection is the size of the initial flow
3899 // control window for each connections. The HTTP/2 spec does not
3900 // allow this to be smaller than 65535 or larger than 2^32-1.
3901 // If the value is outside this range, a default value will be
3902 // used instead.
3903 MaxUploadBufferPerConnection int32
3905 // MaxUploadBufferPerStream is the size of the initial flow control
3906 // window for each stream. The HTTP/2 spec does not allow this to
3907 // be larger than 2^32-1. If the value is zero or larger than the
3908 // maximum, a default value will be used instead.
3909 MaxUploadBufferPerStream int32
3911 // NewWriteScheduler constructs a write scheduler for a connection.
3912 // If nil, a default scheduler is chosen.
3915 // Internal state. This is a pointer (rather than embedded directly)
3916 // so that we don't embed a Mutex in this struct, which will make the
3917 // struct non-copyable, which might break some callers.
3918 state *http2serverInternalState
3919 }
3924 }
3926 }
3931 }
3933 }
3937 return v
3938 }
3939 return http2defaultMaxReadFrameSize
3940 }
3944 return v
3945 }
3946 return http2defaultMaxStreams
3947 }
3950 mu sync.Mutex
3952 }
3957 }
3961 }
3966 }
3970 }
3975 }
3979 }
3981 }
3983 // ConfigureServer adds HTTP/2 support to a net/http Server.
3984 //
3985 // The configuration conf may be nil.
3986 //
3987 // ConfigureServer must be called before s begins serving.
3991 }
3994 }
3997 return err
3998 }
4000 return err
4001 }
4006 // If they already provided a CipherSuite list, return
4007 // an error if it has a bad order or is missing
4008 // ECDHE_RSA_WITH_AES_128_GCM_SHA256 or ECDHE_ECDSA_WITH_AES_128_GCM_SHA256.
4014 // Alternative MTI cipher to not discourage ECDSA-only servers.
4015 // See http://golang.org/cl/30721 for further information.
4018 }
4022 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)
4023 }
4024 }
4026 return fmt.Errorf("http2: TLSConfig.CipherSuites is missing an HTTP/2-required AES_128_GCM_SHA256 cipher.")
4027 }
4028 }
4030 // Note: not setting MinVersion to tls.VersionTLS12,
4031 // as we don't want to interfere with HTTP/1.1 traffic
4032 // on the user's server. We enforce TLS 1.2 later once
4033 // we accept a connection. Ideally this should be done
4034 // during next-proto selection, but using TLS <1.2 with
4035 // HTTP/2 is still the client's bug.
4043 break
4044 }
4045 }
4048 }
4052 }
4056 }
4060 })
4061 }
4064 }
4066 // ServeConnOpts are options for the Server.ServeConn method.
4068 // BaseConfig optionally sets the base configuration
4069 // for values. If nil, defaults are used.
4070 BaseConfig *Server
4072 // Handler specifies which handler to use for processing
4073 // requests. If nil, BaseConfig.Handler is used. If BaseConfig
4074 // or BaseConfig.Handler is nil, http.DefaultServeMux is used.
4075 Handler Handler
4076 }
4081 }
4083 }
4089 }
4092 }
4093 }
4094 return DefaultServeMux
4095 }
4097 // ServeConn serves HTTP/2 requests on the provided connection and
4098 // blocks until the connection is no longer readable.
4099 //
4100 // ServeConn starts speaking HTTP/2 assuming that c has not had any
4101 // reads or writes. It writes its initial settings frame and expects
4102 // to be able to read the preface and settings frame from the
4103 // client. If c has a ConnectionState method like a *tls.Conn, the
4104 // ConnectionState is used to verify the TLS ciphersuite and to set
4105 // the Request.TLS field in Handlers.
4106 //
4107 // ServeConn does not support h2c by itself. Any h2c support must be
4108 // implemented in terms of providing a suitably-behaving net.Conn.
4109 //
4110 // The opts parameter is optional. If nil, default values are used.
4130 clientMaxStreams: math.MaxUint32, // Section 6.5.2: "Initially, there is no limit to this value"
4137 }
4142 // The net/http package sets the write deadline from the
4143 // http.Server.WriteTimeout during the TLS handshake, but then
4144 // passes the connection off to us with the deadline already set.
4145 // Write deadlines are set per stream in serverConn.newStream.
4146 // Disarm the net.Conn write deadline here.
4149 }
4155 }
4157 // These start at the RFC-specified defaults. If there is a higher
4158 // configured value for inflow, that will be updated when we send a
4159 // WINDOW_UPDATE shortly after sending SETTINGS.
4173 // 9.2 Use of TLS Features
4174 // An implementation of HTTP/2 over TLS MUST use TLS
4175 // 1.2 or higher with the restrictions on feature set
4176 // and cipher suite described in this section. Due to
4177 // implementation limitations, it might not be
4178 // possible to fail TLS negotiation. An endpoint MUST
4179 // immediately terminate an HTTP/2 connection that
4180 // does not meet the TLS requirements described in
4181 // this section with a connection error (Section
4182 // 5.4.1) of type INADEQUATE_SECURITY.
4185 return
4186 }
4189 // Client must use SNI, but we don't enforce that anymore,
4190 // since it was causing problems when connecting to bare IP
4191 // addresses during development.
4192 //
4193 // TODO: optionally enforce? Or enforce at the time we receive
4194 // a new request, and verify the ServerName matches the :authority?
4195 // But that precludes proxy situations, perhaps.
4196 //
4197 // So for now, do nothing here again.
4198 }
4201 // "Endpoints MAY choose to generate a connection error
4202 // (Section 5.4.1) of type INADEQUATE_SECURITY if one of
4203 // the prohibited cipher suites are negotiated."
4204 //
4205 // We choose that. In my opinion, the spec is weak
4206 // here. It also says both parties must support at least
4207 // TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 so there's no
4208 // excuses here. If we really must, we could allow an
4209 // "AllowInsecureWeakCiphers" option on the server later.
4210 // Let's see how it plays out first.
4211 sc.rejectConn(http2ErrCodeInadequateSecurity, fmt.Sprintf("Prohibited TLS 1.2 Cipher Suite: %x", sc.tlsState.CipherSuite))
4212 return
4213 }
4214 }
4218 }
4220 }
4224 // ignoring errors. hanging up anyway.
4228 }
4231 // Immutable:
4232 srv *http2Server
4233 hs *Server
4234 conn net.Conn
4236 handler Handler
4237 baseCtx http2contextContext
4238 framer *http2Framer
4242 wroteFrameCh chan http2frameWriteResult // from writeFrameAsync -> serve, tickles more frame writes
4245 flow http2flow // conn-wide (not stream-specific) outbound flow control
4246 inflow http2flow // conn-wide inbound flow control
4248 remoteAddrStr string
4249 writeSched http2WriteScheduler
4251 // Everything following is owned by the serve loop; use serveG.check():
4252 serveG http2goroutineLock // used to verify funcs are on serve()
4253 pushEnabled bool
4255 needToSendSettingsAck bool
4257 clientMaxStreams uint32 // SETTINGS_MAX_CONCURRENT_STREAMS from client (our PUSH_PROMISE limit)
4261 maxClientStreamID uint32 // max ever seen from client (odd), or 0 if there have been no client requests
4262 maxPushPromiseID uint32 // ID of the last push promise (even), or 0 if there have been no pushes
4264 initialStreamSendWindowSize int32
4265 maxFrameSize int32
4266 headerTableSize uint32
4270 writingFrameAsync bool // started a frame on its own goroutine but haven't heard back on wroteFrameCh
4275 goAwayCode http2ErrCode
4279 // Owned by the writeFrameAsync goroutine:
4280 headerWriteBuf bytes.Buffer
4283 // Used by startGracefulShutdown.
4284 shutdownOnce sync.Once
4285 }
4290 n = DefaultMaxHeaderBytes
4291 }
4292 // http2's count is in a slightly different unit and includes 32 bytes per pair.
4293 // So, take the net/http.Server value and pad it up a bit, assuming 10 headers.
4297 }
4302 }
4304 // stream represents a stream. This is the minimal metadata needed by
4305 // the serve goroutine. Most of the actual stream state is owned by
4306 // the http.Handler's goroutine in the responseWriter. Because the
4307 // responseWriter's responseWriterState is recycled at the end of a
4308 // handler, this struct intentionally has no pointer to the
4309 // *responseWriter{,State} itself, as the Handler ending nils out the
4310 // responseWriter's state field.
4312 // immutable:
4313 sc *http2serverConn
4314 id uint32
4316 cw http2closeWaiter // closed wait stream transitions to closed state
4317 ctx http2contextContext
4320 // owned by serverConn's serve loop:
4323 flow http2flow // limits writing from Handler to client
4324 inflow http2flow // what the client is allowed to POST/etc to us
4326 numTrailerValues int64
4327 weight uint8
4328 state http2streamState
4334 trailer Header // accumulated trailers
4335 reqTrailer Header // handler's Request.Trailer
4336 }
4346 }
4350 // http://tools.ietf.org/html/rfc7540#section-5.1
4353 }
4354 // "The first use of a new stream identifier implicitly closes all
4355 // streams in the "idle" state that might have been initiated by
4356 // that peer with a lower-valued stream identifier. For example, if
4357 // a client sends a HEADERS frame on stream 7 without ever sending a
4358 // frame on stream 5, then stream 5 transitions to the "closed"
4359 // state when the first frame for stream 7 is sent or received."
4363 }
4367 }
4368 }
4370 }
4372 // setConnState calls the net/http ConnState hook for this connection, if configured.
4373 // Note that the net/http package does StateNew and StateClosed for us.
4374 // There is currently no plan for StateHijacked or hijacking HTTP/2 connections.
4378 }
4379 }
4384 }
4385 }
4392 }
4393 }
4395 // errno returns v's underlying uintptr, else 0.
4396 //
4397 // TODO: remove this helper function once http2 can use build
4398 // tags. See comment in isClosedConnError.
4402 }
4404 }
4406 // isClosedConnError reports whether err is an error from use of a closed
4407 // network connection.
4411 }
4413 // TODO: remove this string search and be more like the Windows
4414 // case below. That might involve modifying the standard library
4415 // to return better error types.
4419 }
4421 // TODO(bradfitz): x/tools/cmd/bundle doesn't really support
4422 // build tags, so I can't make an http2_windows.go file with
4423 // Windows-specific stuff. Fix that and move this, once we
4424 // have a way to bundle this into std's net/http somehow.
4432 }
4433 }
4434 }
4435 }
4437 }
4441 return
4442 }
4443 if err == io.EOF || err == io.ErrUnexpectedEOF || http2isClosedConnError(err) || err == http2errPrefaceTimeout {
4444 // Boring, expected errors.
4448 }
4449 }
4455 return cv
4456 }
4459 return cv
4460 }
4463 }
4466 return cv
4467 }
4470 f http2Frame // valid until readMore is called
4471 err error
4473 // readMore should be called once the consumer no longer needs or
4474 // retains f. After readMore, f is invalid and more frames can be
4475 // read.
4477 }
4479 // readFrames is the loop that reads incoming frames.
4480 // It takes care to only read one frame at a time, blocking until the
4481 // consumer is done with the frame.
4482 // It's run on its own goroutine.
4491 return
4492 }
4496 return
4497 }
4499 return
4500 }
4501 }
4502 }
4504 // frameWriteResult is the message passed from writeFrameAsync to the serve goroutine.
4506 wr http2FrameWriteRequest // what was written (or attempted)
4507 err error // result of the writeFrame call
4508 }
4510 // writeFrameAsync runs in its own goroutine and writes a single frame
4511 // and then reports when it's done.
4512 // At most one goroutine can be running writeFrameAsync at a time per
4513 // serverConn.
4517 }
4523 }
4524 }
4530 }
4531 }
4534 // Note: this is for serverConn.serve panicking, not http.Handler code.
4538 }
4543 }
4544 }
4545 }
4546 }
4558 }
4566 },
4567 })
4570 // Each connection starts with intialWindowSize inflow tokens.
4571 // If a higher value is configured, we add more tokens.
4574 }
4577 sc.condlogf(err, "http2: server: error reading preface from client %v: %v", sc.conn.RemoteAddr(), err)
4578 return
4579 }
4580 // Now that we've got the preface, get us out of the
4581 // "StateNew" state. We can't go directly to idle, though.
4582 // Active means we read some data and anticipate a request. We'll
4583 // do another Active when we get a HEADERS frame.
4590 }
4599 loopNum++
4604 break
4605 }
4611 return
4612 }
4617 }
4628 return
4634 return
4639 }
4644 }
4645 }
4647 // Start the shutdown timer after sending a GOAWAY. When sending GOAWAY
4648 // with no error code (graceful shutdown), don't start the timer until
4649 // all open streams have been completed.
4652 if sentGoAway && sc.shutdownTimer == nil && (sc.goAwayCode != http2ErrCodeNo || gracefulShutdownComplete) {
4654 }
4655 }
4656 }
4658 func (sc *http2serverConn) awaitGracefulShutdown(sharedCh <-chan struct{}, privateCh chan struct{}) {
4663 }
4664 }
4668 // Message values sent to serveMsgCh.
4674 )
4687 }
4688 }
4692 // readPreface reads the ClientPreface greeting from the peer or
4693 // returns errPrefaceTimeout on timeout, or an error if the greeting
4694 // is invalid.
4698 // Read the client preface
4701 errc <- err
4706 }
4707 }()
4712 return http2errPrefaceTimeout
4717 }
4718 }
4719 return err
4720 }
4721 }
4725 }
4729 }
4731 // writeDataFromHandler writes DATA response frames from a handler on
4732 // the given stream.
4733 func (sc *http2serverConn) writeDataFromHandler(stream *http2stream, data []byte, endStream bool) error {
4741 })
4743 return err
4744 }
4750 return http2errClientDisconnected
4752 // If both ch and stream.cw were ready (as might
4753 // happen on the final Write after an http.Handler
4754 // ends), prefer the write result. Otherwise this
4755 // might just be us successfully closing the stream.
4756 // The writeFrameAsync and serve goroutines guarantee
4757 // that the ch send will happen before the stream.cw
4758 // close.
4763 return http2errStreamClosed
4764 }
4765 }
4769 }
4770 return err
4771 }
4773 // writeFrameFromHandler sends wr to sc.wantWriteFrameCh, but aborts
4774 // if the connection has gone away.
4775 //
4776 // This must not be run from the serve goroutine itself, else it might
4777 // deadlock writing to sc.wantWriteFrameCh (which is only mildly
4778 // buffered and is read by serve itself). If you're on the serve
4779 // goroutine, call writeFrame instead.
4786 // Serve loop is gone.
4787 // Client has closed their connection to the server.
4788 return http2errClientDisconnected
4789 }
4790 }
4792 // writeFrame schedules a frame to write and sends it if there's nothing
4793 // already being written.
4794 //
4795 // There is no pushback here (the serve goroutine never blocks). It's
4796 // the http.Handlers that block, waiting for their previous frames to
4797 // make it onto the wire
4798 //
4799 // If you're not on the serve goroutine, use writeFrameFromHandler instead.
4803 // If true, wr will not be written and wr.done will not be signaled.
4806 // We are not allowed to write frames on closed streams. RFC 7540 Section
4807 // 5.1.1 says: "An endpoint MUST NOT send frames other than PRIORITY on
4808 // a closed stream." Our server never sends PRIORITY, so that exception
4809 // does not apply.
4810 //
4811 // The serverConn might close an open stream while the stream's handler
4812 // is still running. For example, the server might close a stream when it
4813 // receives bad data from the client. If this happens, the handler might
4814 // attempt to write a frame after the stream has been closed (since the
4815 // handler hasn't yet been notified of the close). In this case, we simply
4816 // ignore the frame. The handler will notice that the stream is closed when
4817 // it waits for the frame to be written.
4818 //
4819 // As an exception to this rule, we allow sending RST_STREAM after close.
4820 // This allows us to immediately reject new streams without tracking any
4821 // state for those streams (except for the queued RST_STREAM frame). This
4822 // may result in duplicate RST_STREAMs in some cases, but the client should
4823 // ignore those.
4828 }
4829 }
4831 // Don't send a 100-continue response if we've already sent headers.
4832 // See golang.org/issue/14030.
4838 // We do not need to notify wr.done because this frame is
4839 // never written with wr.done != nil.
4842 }
4844 }
4845 }
4849 }
4851 }
4853 // startFrameWrite starts a goroutine to write wr (in a separate
4854 // goroutine since that might block on the network), and updates the
4855 // serve goroutine's state about the world, updated from info in wr.
4860 }
4868 // RFC 7540 Section 5.1 allows sending RST_STREAM, PRIORITY, and WINDOW_UPDATE
4869 // in this state. (We never send PRIORITY from the server, so that is not checked.)
4871 panic(fmt.Sprintf("internal error: attempt to send frame on a half-closed-local stream: %v", wr))
4872 }
4875 }
4876 }
4878 var err error
4883 return
4884 }
4885 }
4896 }
4897 }
4899 // errHandlerPanicked is the error given to any callers blocked in a read from
4900 // Request.Body when the main goroutine panics. Since most handlers read in the
4901 // the main ServeHTTP goroutine, this will show up rarely.
4904 // wroteFrame is called on the serve goroutine with the result of
4905 // whatever happened on writeFrameAsync.
4910 }
4920 }
4923 // Here we would go to stateHalfClosedLocal in
4924 // theory, but since our handler is done and
4925 // the net/http package provides no mechanism
4926 // for closing a ResponseWriter while still
4927 // reading data (see possible TODO at top of
4928 // this file), we go into closed state here
4929 // anyway, after telling the peer we're
4930 // hanging up on them. We'll transition to
4931 // stateClosed after the RST_STREAM frame is
4932 // written.
4934 // Section 8.1: a server MAY request that the client abort
4935 // transmission of a request without error by sending a
4936 // RST_STREAM with an error code of NO_ERROR after sending
4937 // a complete response.
4941 }
4945 // st may be unknown if the RST_STREAM was generated to reject bad input.
4948 }
4951 }
4952 }
4954 // Reply (if requested) to unblock the ServeHTTP goroutine.
4958 }
4960 // scheduleFrameWrite tickles the frame writing scheduler.
4961 //
4962 // If a frame is already being written, nothing happens. This will be called again
4963 // when the frame is done being written.
4964 //
4965 // If a frame isn't being written we need to send one, the best frame
4966 // to send is selected, preferring first things that aren't
4967 // stream-specific (e.g. ACKing settings), and then finding the
4968 // highest priority stream.
4969 //
4970 // If a frame isn't being written and there's nothing else to send, we
4971 // flush the write buffer.
4975 return
4976 }
4985 },
4986 })
4987 continue
4988 }
4992 continue
4993 }
4997 continue
4998 }
4999 }
5003 continue
5004 }
5005 break
5006 }
5008 }
5010 // startGracefulShutdown gracefully shuts down a connection. This
5011 // sends GOAWAY with ErrCodeNo to tell the client we're gracefully
5012 // shutting down. The connection isn't closed until all current
5013 // streams are done.
5014 //
5015 // startGracefulShutdown returns immediately; it does not wait until
5016 // the connection has shut down.
5020 }
5022 // After sending GOAWAY, the connection will close after goAwayTimeout.
5023 // If we close the connection immediately after sending GOAWAY, there may
5024 // be unsent data in our kernel receive buffer, which will cause the kernel
5025 // to send a TCP RST on close() instead of a FIN. This RST will abort the
5026 // connection immediately, whether or not the client had received the GOAWAY.
5027 //
5028 // Ideally we should delay for at least 1 RTT + epsilon so the client has
5029 // a chance to read the GOAWAY and stop sending messages. Measuring RTT
5030 // is hard, so we approximate with 1 second. See golang.org/issue/18701.
5031 //
5032 // This is a var so it can be shorter in tests, where all requests uses the
5033 // loopback interface making the expected RTT very small.
5034 //
5035 // TODO: configurable?
5040 }
5045 return
5046 }
5051 }
5056 }
5063 }
5064 }
5066 // processFrameFromReader processes the serve loop's read from readFrameCh from the
5067 // frame-reading goroutine.
5068 // processFrameFromReader returns whether the connection should be kept open.
5076 }
5079 // TODO: could we also get into this state if
5080 // the peer does a half close
5081 // (e.g. CloseWrite) because they're done
5082 // sending frames but they're still wanting
5083 // our open replies? Investigate.
5084 // TODO: add CloseWrite to crypto/tls.Conn first
5085 // so we have a way to test this? I suppose
5086 // just for testing we could have a non-TLS mode.
5088 }
5093 }
5097 }
5098 }
5113 sc.vlogf("http2: server closing client connection; error reading frame from client %s: %v", sc.conn.RemoteAddr(), err)
5116 }
5118 }
5119 }
5124 // First frame received must be SETTINGS.
5128 }
5130 }
5150 // A client cannot push. Thus, servers MUST treat the receipt of a PUSH_PROMISE
5151 // frame as a connection error (Section 5.4.1) of type PROTOCOL_ERROR.
5156 }
5157 }
5162 // 6.7 PING: " An endpoint MUST NOT respond to PING frames
5163 // containing this flag."
5165 }
5167 // "PING frames are not associated with any individual
5168 // stream. If a PING frame is received with a stream
5169 // identifier field value other than 0x0, the recipient MUST
5170 // respond with a connection error (Section 5.4.1) of type
5171 // PROTOCOL_ERROR."
5173 }
5176 }
5179 }
5187 // Section 5.1: "Receiving any frame other than HEADERS
5188 // or PRIORITY on a stream in this state MUST be
5189 // treated as a connection error (Section 5.4.1) of
5190 // type PROTOCOL_ERROR."
5192 }
5194 // "WINDOW_UPDATE can be sent by a peer that has sent a
5195 // frame bearing the END_STREAM flag. This means that a
5196 // receiver could receive a WINDOW_UPDATE frame on a "half
5197 // closed (remote)" or "closed" stream. A receiver MUST
5198 // NOT treat this as an error, see Section 5.1."
5200 }
5203 }
5207 }
5208 }
5211 }
5218 // 6.4 "RST_STREAM frames MUST NOT be sent for a
5219 // stream in the "idle" state. If a RST_STREAM frame
5220 // identifying an idle stream is received, the
5221 // recipient MUST treat this as a connection error
5222 // (Section 5.4.1) of type PROTOCOL_ERROR.
5224 }
5228 }
5230 }
5236 }
5240 }
5245 }
5251 }
5254 }
5255 }
5257 // Return any buffered unread bytes worth of conn-level flow control.
5258 // See golang.org/issue/16481
5262 }
5265 }
5272 // Why is the peer ACKing settings we never sent?
5273 // The spec doesn't mention this case, but
5274 // hang up on them anyway.
5276 }
5278 }
5280 // This isn't actually in the spec, but hang up on
5281 // suspiciously large settings frames or those with
5282 // duplicate entries.
5284 }
5286 return err
5287 }
5291 }
5296 return err
5297 }
5300 }
5316 // Unknown setting: "An endpoint that receives a SETTINGS
5317 // frame with any unknown or unsupported identifier MUST
5318 // ignore that setting."
5321 }
5322 }
5324 }
5328 // Note: val already validated to be within range by
5329 // processSetting's Valid call.
5331 // "A SETTINGS frame can alter the initial flow control window
5332 // size for all current streams. When the value of
5333 // SETTINGS_INITIAL_WINDOW_SIZE changes, a receiver MUST
5334 // adjust the size of all stream flow control windows that it
5335 // maintains by the difference between the new value and the
5336 // old value."
5342 // 6.9.2 Initial Flow Control Window Size
5343 // "An endpoint MUST treat a change to
5344 // SETTINGS_INITIAL_WINDOW_SIZE that causes any flow
5345 // control window to exceed the maximum size as a
5346 // connection error (Section 5.4.1) of type
5347 // FLOW_CONTROL_ERROR."
5349 }
5350 }
5352 }
5358 }
5361 // "If a DATA frame is received whose stream is not in "open"
5362 // or "half closed (local)" state, the recipient MUST respond
5363 // with a stream error (Section 5.4.2) of type STREAM_CLOSED."
5367 // Section 5.1: "Receiving any frame other than HEADERS
5368 // or PRIORITY on a stream in this state MUST be
5369 // treated as a connection error (Section 5.4.1) of
5370 // type PROTOCOL_ERROR."
5372 }
5373 // RFC 7540, sec 6.1: If a DATA frame is received whose stream is not in
5374 // "open" or "half-closed (local)" state, the recipient MUST respond with a
5375 // stream error (Section 5.4.2) of type STREAM_CLOSED.
5378 }
5380 // This includes sending a RST_STREAM if the stream is
5381 // in stateHalfClosedLocal (which currently means that
5382 // the http.Handler returned, so it's done reading &
5383 // done writing). Try to stop the client from sending
5384 // more DATA.
5386 // But still enforce their connection-level flow control,
5387 // and return any flow control bytes since we're not going
5388 // to consume them.
5391 }
5392 // Deduct the flow control from inflow, since we're
5393 // going to immediately add it back in
5394 // sendWindowUpdate, which also schedules sending the
5395 // frames.
5400 // Already have a stream error in flight. Don't send another.
5402 }
5404 }
5407 }
5409 // Sender sending more than they'd declared?
5411 st.body.CloseWithError(fmt.Errorf("sender tried to send more than declared Content-Length of %d bytes", st.declBodyBytes))
5412 // RFC 7540, sec 8.1.2.6: A request or response is also malformed if the
5413 // value of a content-length header field does not equal the sum of the
5414 // DATA frame payload lengths that form the body.
5416 }
5418 // Check whether the client has flow control quota.
5421 }
5428 }
5431 }
5433 }
5435 // Return any padded flow control now, since we won't
5436 // refund it later on body reads.
5440 }
5441 }
5444 }
5446 }
5454 }
5456 // http://tools.ietf.org/html/rfc7540#section-6.8
5457 // We should not create any new streams, which means we should disable push.
5460 }
5462 // isPushed reports whether the stream is server-initiated.
5465 }
5467 // endStream closes a Request.Body's pipe. It is called when a DATA
5468 // frame says a request body is over (or after trailers).
5474 st.body.CloseWithError(fmt.Errorf("request declared a Content-Length of %d but only wrote %d bytes",
5479 }
5481 }
5483 // copyTrailersToHandlerRequest is run in the Handler's goroutine in
5484 // its Request.Body.Read just before it gets io.EOF.
5488 // Only copy it over it was pre-declared.
5490 }
5491 }
5492 }
5494 // onWriteTimeout is run on its own goroutine (from time.AfterFunc)
5495 // when the stream's WriteTimeout has fired.
5497 st.sc.writeFrameFromHandler(http2FrameWriteRequest{write: http2streamError(st.id, http2ErrCodeInternal)})
5498 }
5504 // Ignore.
5506 }
5507 // http://tools.ietf.org/html/rfc7540#section-5.1.1
5508 // Streams initiated by a client MUST use odd-numbered stream
5509 // identifiers. [...] An endpoint that receives an unexpected
5510 // stream identifier MUST respond with a connection error
5511 // (Section 5.4.1) of type PROTOCOL_ERROR.
5514 }
5515 // A HEADERS frame can be used to create a new stream or
5516 // send a trailer for an open one. If we already have a stream
5517 // open, let it process its own HEADERS frame (trailers at this
5518 // point, if it's valid).
5521 // We're sending RST_STREAM to close the stream, so don't bother
5522 // processing this frame.
5524 }
5525 // RFC 7540, sec 5.1: If an endpoint receives additional frames, other than
5526 // WINDOW_UPDATE, PRIORITY, or RST_STREAM, for a stream that is in
5527 // this state, it MUST respond with a stream error (Section 5.4.2) of
5528 // type STREAM_CLOSED.
5531 }
5533 }
5535 // [...] The identifier of a newly established stream MUST be
5536 // numerically greater than all streams that the initiating
5537 // endpoint has opened or reserved. [...] An endpoint that
5538 // receives an unexpected stream identifier MUST respond with
5539 // a connection error (Section 5.4.1) of type PROTOCOL_ERROR.
5542 }
5547 }
5549 // http://tools.ietf.org/html/rfc7540#section-5.1.2
5550 // [...] Endpoints MUST NOT exceed the limit set by their peer. An
5551 // endpoint that receives a HEADERS frame that causes their
5552 // advertised concurrent stream limit to be exceeded MUST treat
5553 // this as a stream error (Section 5.4.2) of type PROTOCOL_ERROR
5554 // or REFUSED_STREAM.
5557 // They should know better.
5559 }
5560 // Assume it's a network race, where they just haven't
5561 // received our last SETTINGS update. But actually
5562 // this can't happen yet, because we don't yet provide
5563 // a way for users to adjust server parameters at
5564 // runtime.
5566 }
5568 initialState := http2stateOpen
5570 initialState = http2stateHalfClosedRemote
5571 }
5576 return err
5577 }
5579 }
5583 return err
5584 }
5588 }
5594 // Their header list was too long. Send a 431 error.
5595 handler = http2handleHeaderListTooLong
5598 }
5600 // The net/http package sets the read deadline from the
5601 // http.Server.ReadTimeout during the TLS handshake, but then
5602 // passes the connection off to us with the deadline already
5603 // set. Disarm it here after the request headers are read,
5604 // similar to how the http1 server works. Here it's
5605 // technically more like the http1 Server's ReadHeaderTimeout
5606 // (in Go 1.8), though. That's a more sane option anyway.
5609 }
5613 }
5620 }
5624 }
5628 }
5633 // TODO: send more details to the peer somehow. But http2 has
5634 // no way to send debug data at a stream level. Discuss with
5635 // HTTP folk.
5637 }
5639 }
5640 }
5643 }
5647 // Section 5.3.1: "A stream cannot depend on itself. An endpoint MUST treat
5648 // this as a stream error (Section 5.4.2) of type PROTOCOL_ERROR."
5649 // Section 5.3.3 says that a stream can depend on one of its dependencies,
5650 // so it's only self-dependencies that are forbidden.
5652 }
5654 }
5659 }
5661 return err
5662 }
5665 }
5667 func (sc *http2serverConn) newStream(id, pusherID uint32, state http2streamState) *http2stream {
5671 }
5680 }
5688 }
5696 }
5699 }
5701 return st
5702 }
5704 func (sc *http2serverConn) newWriterAndRequest(st *http2stream, f *http2MetaHeadersFrame) (*http2responseWriter, *Request, error) {
5712 }
5718 }
5720 // See 8.1.2.6 Malformed Requests and Responses:
5721 //
5722 // Malformed requests or responses that are detected
5723 // MUST be treated as a stream error (Section 5.4.2)
5724 // of type PROTOCOL_ERROR."
5725 //
5726 // 8.1.2.3 Request Pseudo-Header Fields
5727 // "All HTTP/2 requests MUST include exactly one valid
5728 // value for the :method, :scheme, and :path
5729 // pseudo-header fields"
5731 }
5735 // HEAD requests can't have bodies
5737 }
5742 }
5745 }
5750 }
5756 }
5759 }
5760 }
5762 }
5765 method string
5767 header Header
5768 }
5770 func (sc *http2serverConn) newWriterAndRequestNoBody(st *http2stream, rp http2requestParam) (*http2responseWriter, *Request, error) {
5776 }
5781 }
5782 // Merge Cookie headers into one "; "-delimited value.
5785 }
5787 // Setup Trailers
5788 var trailer Header
5794 // Bogus. (copy of http1 rules)
5795 // Ignore.
5799 }
5801 }
5802 }
5803 }
5812 var err error
5816 }
5818 }
5824 }
5838 }
5853 }
5855 // Run on its own goroutine.
5856 func (sc *http2serverConn) runHandler(rw *http2responseWriter, req *Request, handler func(ResponseWriter, *Request)) {
5865 })
5866 // Same as net/http:
5872 }
5873 return
5874 }
5876 }()
5879 }
5882 // 10.5.1 Limits on Header Block Size:
5883 // .. "A server that receives a larger header block than it is
5884 // willing to handle can send an HTTP 431 (Request Header Fields Too
5885 // Large) status code"
5889 }
5891 // called from handler goroutines.
5892 // h may be nil.
5893 func (sc *http2serverConn) writeHeaders(st *http2stream, headerData *http2writeResHeaders) error {
5897 // If there's a header map (which we don't own), so we have to block on
5898 // waiting for this frame to be written, so an http.Flush mid-handler
5899 // writes out the correct value of keys, before a handler later potentially
5900 // mutates it.
5902 }
5908 return err
5909 }
5914 return err
5916 return http2errClientDisconnected
5918 return http2errStreamClosed
5919 }
5920 }
5922 }
5924 // called from handler goroutines.
5929 })
5930 }
5932 // A bodyReadMsg tells the server loop that the http.Handler read n
5933 // bytes of the DATA from the client on the given stream.
5935 st *http2stream
5936 n int
5937 }
5939 // called from handler goroutines.
5940 // Notes that the handler for the given stream ID read n bytes of its body
5941 // and schedules flow control tokens to be sent.
5948 }
5949 }
5950 }
5956 // Don't send this WINDOW_UPDATE if the stream is closed
5957 // remotely.
5959 }
5960 }
5962 // st may be nil for conn-level
5965 // "The legal range for the increment to the flow control
5966 // window is 1 to 2^31-1 (2,147,483,647) octets."
5967 // A Go Read call on 64-bit machines could in theory read
5968 // a larger Read than this. Very unlikely, but we handle it here
5969 // rather than elsewhere for now.
5973 n -= maxUint31
5974 }
5976 }
5978 // st may be nil for conn-level
5982 return
5983 }
5986 }
5990 }
5994 })
6000 }
6003 }
6004 }
6006 // requestBody is the Handler's Request.Body type.
6007 // Read and Close may be called concurrently.
6009 stream *http2stream
6010 conn *http2serverConn
6015 }
6020 }
6023 }
6029 }
6032 }
6036 }
6038 return
6039 }
6041 return
6042 }
6044 // responseWriter is the http.ResponseWriter implementation. It's
6045 // intentionally small (1 pointer wide) to minimize garbage. The
6046 // responseWriterState pointer inside is zeroed at the end of a
6047 // request (in handlerDone) and calls on the responseWriter thereafter
6048 // simply crash (caller's mistake), but the much larger responseWriterState
6049 // and buffers are reused between multiple requests.
6051 rws *http2responseWriterState
6052 }
6054 // Optional http.ResponseWriter interfaces implemented.
6059 )
6062 // immutable within a request:
6063 stream *http2stream
6064 req *Request
6066 conn *http2serverConn
6068 // TODO: adjust buffer writing sizes based on server config, frame size updates from peer, etc
6071 // mutated by http.Handler goroutine:
6072 handlerHeader Header // nil until called
6073 snapHeader Header // snapshot of handlerHeader at WriteHeader time
6076 wroteHeader bool // WriteHeader called (explicitly or implicitly). Not necessarily sent to user yet.
6082 wroteBytes int64
6086 }
6094 // declareTrailer is called for each Trailer header when the
6095 // response header is written. It notes that a header will need to be
6096 // written in the trailers at the end of the response.
6100 // Forbidden by RFC 7230, section 4.1.2.
6102 return
6103 }
6106 }
6107 }
6109 // writeChunk writes chunks from the bufio.Writer. But because
6110 // bufio.Writer may bypass its chunking, sometimes p may be
6111 // arbitrarily large.
6112 //
6113 // writeChunk is also responsible (on the first chunk) for sending the
6114 // HEADER response.
6118 }
6131 }
6132 }
6133 if clen == "" && rws.handlerDone && http2bodyAllowedForStatus(rws.status) && (len(p) > 0 || !isHeadResp) {
6135 }
6139 }
6142 // TODO(bradfitz): be faster here, like net/http? measure.
6144 }
6148 }
6150 // "Connection" headers aren't allowed in HTTP/2 (RFC 7540, 8.1.2.2),
6151 // but respect "Connection" == "close" to mean sending a GOAWAY and tearing
6152 // down the TCP connection when idle, like we do for HTTP/1.
6153 // TODO: remove more Connection-specific header fields here, in addition
6154 // to "Connection".
6160 }
6161 }
6172 })
6176 }
6179 }
6180 }
6183 }
6186 }
6190 }
6194 // only send a 0 byte DATA frame if we're ending the stream.
6198 }
6199 }
6207 })
6210 }
6212 }
6214 }
6216 // TrailerPrefix is a magic prefix for ResponseWriter.Header map keys
6217 // that, if present, signals that the map entry is actually for
6218 // the response trailers, and not the response headers. The prefix
6219 // is stripped after the ServeHTTP call finishes and the values are
6220 // sent in the trailers.
6221 //
6222 // This mechanism is intended only for trailers that are not known
6223 // prior to the headers being written. If the set of trailers is fixed
6224 // or known before the header is written, the normal Go trailers mechanism
6225 // is preferred:
6226 // https://golang.org/pkg/net/http/#ResponseWriter
6227 // https://golang.org/pkg/net/http/#example_ResponseWriter_trailers
6230 // promoteUndeclaredTrailers permits http.Handlers to set trailers
6231 // after the header has already been flushed. Because the Go
6232 // ResponseWriter interface has no way to set Trailers (only the
6233 // Header), and because we didn't want to expand the ResponseWriter
6234 // interface, and because nobody used trailers, and because RFC 7230
6235 // says you SHOULD (but not must) predeclare any trailers in the
6236 // header, the official ResponseWriter rules said trailers in Go must
6237 // be predeclared, and then we reuse the same ResponseWriter.Header()
6238 // map to mean both Headers and Trailers. When it's time to write the
6239 // Trailers, we pick out the fields of Headers that were declared as
6240 // trailers. That worked for a while, until we found the first major
6241 // user of Trailers in the wild: gRPC (using them only over http2),
6242 // and gRPC libraries permit setting trailers mid-stream without
6243 // predeclarnig them. So: change of plans. We still permit the old
6244 // way, but we also permit this hack: if a Header() key begins with
6245 // "Trailer:", the suffix of that key is a Trailer. Because ':' is an
6246 // invalid token byte anyway, there is no ambiguity. (And it's already
6247 // filtered out) It's mildly hacky, but not terrible.
6248 //
6249 // This method runs after the Handler is done and promotes any Header
6250 // fields to be trailers.
6254 continue
6255 }
6259 }
6265 }
6266 }
6272 }
6275 // Ignore the error. The frame writer already knows.
6276 return
6277 }
6279 // The bufio.Writer won't call chunkWriter.Write
6280 // (writeChunk with zero bytes, so we have to do it
6281 // ourselves to force the HTTP response header and/or
6282 // final DATA frame (with END_STREAM) to be sent.
6284 }
6285 }
6291 }
6301 }()
6302 }
6304 return ch
6305 }
6311 }
6314 }
6316 }
6318 // checkWriteHeaderCode is a copy of net/http's checkWriteHeaderCode.
6320 // Issue 22880: require valid WriteHeader status codes.
6321 // For now we only enforce that it's three digits.
6322 // In the future we might block things over 599 (600 and above aren't defined
6323 // at http://httpwg.org/specs/rfc7231.html#status.codes)
6324 // and we might block under 200 (once we have more mature 1xx support).
6325 // But for now any three digits.
6326 //
6327 // We used to send "HTTP/1.1 000 0" on the wire in responses but there's
6328 // no equivalent bogus thing we can realistically send in HTTP/2,
6329 // so we'll consistently panic instead and help people find their bugs
6330 // early. (We can't return an error from WriteHeader even if we wanted to.)
6333 }
6334 }
6340 }
6342 }
6351 }
6352 }
6353 }
6361 }
6362 return h2
6363 }
6365 // The Life Of A Write is like this:
6366 //
6367 // * Handler calls w.Write or w.WriteString ->
6368 // * -> rws.bw (*bufio.Writer) ->
6369 // * (Handler might call Flush)
6370 // * -> chunkWriter{rws}
6371 // * -> responseWriterState.writeChunk(p []byte)
6372 // * -> responseWriterState.writeChunk (most of the magic; see comment there)
6375 }
6379 }
6381 // either dataB or dataS is non-zero.
6382 func (w *http2responseWriter) write(lenData int, dataB []byte, dataS string) (n int, err error) {
6386 }
6389 }
6392 }
6395 // TODO: send a RST_STREAM
6397 }
6403 }
6404 }
6413 // Only recycle the pool if all prior Write calls to
6414 // the serverConn goroutine completed successfully. If
6415 // they returned earlier due to resets from the peer
6416 // there might still be write goroutines outstanding
6417 // from the serverConn referencing the rws memory. See
6418 // issue 20704.
6420 }
6421 }
6423 // Push errors.
6426 http2ErrPushLimitReached = errors.New("http2: push would exceed peer's SETTINGS_MAX_CONCURRENT_STREAMS")
6427 )
6429 // pushOptions is the internal version of http.PushOptions, which we
6430 // cannot include here because it's only defined in Go 1.8 and later.
6432 Method string
6433 Header Header
6434 }
6441 // No recursive pushes: "PUSH_PROMISE frames MUST only be sent on a peer-initiated stream."
6442 // http://tools.ietf.org/html/rfc7540#section-6.6
6444 return http2ErrRecursivePush
6445 }
6447 // Default options.
6450 }
6453 }
6457 }
6459 // Validate the request.
6462 return err
6463 }
6467 }
6472 return fmt.Errorf("cannot push URL with scheme %q from request with scheme %q", u.Scheme, wantScheme)
6473 }
6476 }
6477 }
6481 }
6482 // These headers are meaningful only if the request has a body,
6483 // but PUSH_PROMISE requests cannot have a body.
6484 // http://tools.ietf.org/html/rfc7540#section-8.2
6485 // Also disallow Host, since the promised URL must be absolute.
6489 }
6490 }
6492 return err
6493 }
6495 // The RFC effectively limits promised requests to GET and HEAD:
6496 // "Promised requests MUST be cacheable [GET, HEAD, or POST], and MUST be safe [GET or HEAD]"
6497 // http://tools.ietf.org/html/rfc7540#section-8.2
6500 }
6508 }
6512 return http2errClientDisconnected
6514 return http2errStreamClosed
6516 }
6520 return http2errClientDisconnected
6522 return http2errStreamClosed
6525 return err
6526 }
6527 }
6530 parent *http2stream
6531 method string
6533 header Header
6534 done chan error
6535 }
6540 // http://tools.ietf.org/html/rfc7540#section-6.6.
6541 // PUSH_PROMISE frames MUST only be sent on a peer-initiated stream that
6542 // is in either the "open" or "half-closed (remote)" state.
6544 // responseWriter.Push checks that the stream is peer-initiaed.
6546 return
6547 }
6549 // http://tools.ietf.org/html/rfc7540#section-6.6.
6552 return
6553 }
6555 // PUSH_PROMISE frames must be sent in increasing order by stream ID, so
6556 // we allocate an ID for the promised stream lazily, when the PUSH_PROMISE
6557 // is written. Once the ID is allocated, we start the request handler.
6561 // Check this again, just in case. Technically, we might have received
6562 // an updated SETTINGS by the time we got around to writing this frame.
6565 }
6566 // http://tools.ietf.org/html/rfc7540#section-6.5.2.
6569 }
6571 // http://tools.ietf.org/html/rfc7540#section-5.1.1.
6572 // Streams initiated by the server MUST use even-numbered identifiers.
6573 // A server that is unable to establish a new stream identifier can send a GOAWAY
6574 // frame so that the client is forced to open a new connection for new streams.
6578 }
6582 // http://tools.ietf.org/html/rfc7540#section-8.2.
6583 // Strictly speaking, the new stream should start in "reserved (local)", then
6584 // transition to "half closed (remote)" after sending the initial HEADERS, but
6585 // we start in "half closed (remote)" for simplicity.
6586 // See further comments at the definition of stateHalfClosedRemote.
6593 header: http2cloneHeader(msg.header), // clone since handler runs concurrently with writing the PUSH_PROMISE
6594 })
6596 // Should not happen, since we've already validated msg.url.
6598 }
6602 }
6611 },
6614 })
6615 }
6617 // foreachHeaderElement splits v according to the "#rule" construction
6618 // in RFC 7230 section 7 and calls fn for each non-empty element.
6622 return
6623 }
6626 return
6627 }
6631 }
6632 }
6633 }
6635 // From http://httpwg.org/specs/rfc7540.html#rfc.section.8.1.2.2
6642 }
6644 // checkValidHTTP2RequestHeaders checks whether h is a valid HTTP/2 request,
6645 // per RFC 7540 Section 8.1.2.2.
6646 // The returned error is reported to users.
6651 }
6652 }
6656 }
6658 }
6663 }
6664 }
6666 // h1ServerKeepAlivesDisabled reports whether hs has its keep-alives
6667 // disabled. See comments on h1ServerShutdownChan above for why
6668 // the code is written this way.
6673 }
6676 }
6678 }
6681 // transportDefaultConnFlow is how many connection-level flow control
6682 // tokens we give the server at start-up, past the default 64k.
6685 // transportDefaultStreamFlow is how many stream-level flow
6686 // control tokens we announce to the peer, and how many bytes
6687 // we buffer per stream.
6690 // transportDefaultStreamMinRefresh is the minimum number of bytes we'll send
6691 // a stream-level WINDOW_UPDATE for at a time.
6695 )
6697 // Transport is an HTTP/2 Transport.
6698 //
6699 // A Transport internally caches connections to servers. It is safe
6700 // for concurrent use by multiple goroutines.
6702 // DialTLS specifies an optional dial function for creating
6703 // TLS connections for requests.
6704 //
6705 // If DialTLS is nil, tls.Dial is used.
6706 //
6707 // If the returned net.Conn has a ConnectionState method like tls.Conn,
6708 // it will be used to set http.Response.TLS.
6711 // TLSClientConfig specifies the TLS configuration to use with
6712 // tls.Client. If nil, the default configuration is used.
6715 // ConnPool optionally specifies an alternate connection pool to use.
6716 // If nil, the default is used.
6717 ConnPool http2ClientConnPool
6719 // DisableCompression, if true, prevents the Transport from
6720 // requesting compression with an "Accept-Encoding: gzip"
6721 // request header when the Request contains no existing
6722 // Accept-Encoding value. If the Transport requests gzip on
6723 // its own and gets a gzipped response, it's transparently
6724 // decoded in the Response.Body. However, if the user
6725 // explicitly requested gzip it is not automatically
6726 // uncompressed.
6727 DisableCompression bool
6729 // AllowHTTP, if true, permits HTTP/2 requests using the insecure,
6730 // plain-text "http" scheme. Note that this does not enable h2c support.
6731 AllowHTTP bool
6733 // MaxHeaderListSize is the http2 SETTINGS_MAX_HEADER_LIST_SIZE to
6734 // send in the initial settings frame. It is how many bytes
6735 // of response headers are allowed. Unlike the http2 spec, zero here
6736 // means to use a default limit (currently 10MB). If you actually
6737 // want to advertise an ulimited value to the peer, Transport
6738 // interprets the highest possible value here (0xffffffff or 1<<32-1)
6739 // to mean no limit.
6740 MaxHeaderListSize uint32
6742 // t1, if non-nil, is the standard library Transport using
6743 // this transport. Its settings are used (but not its
6744 // RoundTrip method, etc).
6745 t1 *Transport
6747 connPoolOnce sync.Once
6748 connPoolOrDef http2ClientConnPool // non-nil version of ConnPool
6749 }
6754 }
6757 }
6759 }
6763 }
6765 var http2errTransportVersion = errors.New("http2: ConfigureTransport is only supported starting at Go 1.6")
6767 // ConfigureTransport configures a net/http HTTP/1 Transport to use HTTP/2.
6768 // It requires Go 1.6 or later and returns an error if the net/http package is too old
6769 // or if t1 has already been HTTP/2-enabled.
6772 return err
6773 }
6778 }
6785 }
6786 }
6788 // ClientConn is the state of a single HTTP/2 client connection to an
6789 // HTTP/2 server.
6791 t *http2Transport
6796 // readLoop goroutine fields:
6798 readerErr error // set before readerDone is closed
6805 flow http2flow // our conn-level flow control quota (cs.flow is per stream)
6806 inflow http2flow // peer's conn-level flow control
6807 closing bool
6808 closed bool
6813 nextStreamID uint32
6814 pendingRequests int // requests blocked and waiting to be sent because len(streams) == maxConcurrentStreams
6818 fr *http2Framer
6819 lastActive time.Time
6820 // Settings from peer: (also guarded by mu)
6821 maxFrameSize uint32
6822 maxConcurrentStreams uint32
6823 peerMaxHeaderListSize uint64
6824 initialWindowSize uint32
6831 werr error // first write error that has occurred
6832 }
6834 // clientStream is the state for a single HTTP/2 stream. One of these
6835 // is created for each Transport.RoundTrip call.
6837 cc *http2ClientConn
6838 req *Request
6840 ID uint32
6841 resc chan http2resAndError
6842 bufPipe http2pipe // buffered pipe with the flow-controlled response payload
6844 requestedGzip bool
6847 flow http2flow // guarded by cc.mu
6848 inflow http2flow // guarded by cc.mu
6850 readErr error // sticky read error; owned by transportResponseBody.Read
6851 stopReqBody error // if non-nil, stop writing req body; guarded by cc.mu
6855 resetErr error // populated before peerReset is closed
6857 done chan struct{} // closed when stream remove from cc.streams map; close calls guarded by cc.mu
6859 // owned by clientConnReadLoop:
6865 trailer Header // accumulated trailers
6867 }
6869 // awaitRequestCancel waits for the user to cancel a request or for the done
6870 // channel to be signaled. A non-nil error is returned only if the request was
6871 // canceled.
6876 }
6879 return http2errRequestCanceled
6884 }
6885 }
6889 // get1xxTraceFunc returns the value of request's httptrace.ClientTrace.Got1xxResponse func,
6890 // if any. It returns nil if not set or if the Go version is too old.
6893 return fn
6894 }
6896 }
6898 // awaitRequestCancel waits for the user to cancel a request, its context to
6899 // expire, or for the request to be done (any way it might be removed from the
6900 // cc.streams map: peer reset, successful completion, TCP connection breakage,
6901 // etc). If the request is canceled, then cs will be canceled and closed.
6906 }
6907 }
6919 }
6920 }
6922 // checkResetOrDone reports any error sent in a RST_STREAM frame by the
6923 // server, or errStreamClosed if the stream is complete.
6929 return http2errStreamClosed
6932 }
6933 }
6940 }
6945 }
6951 }
6954 w io.Writer
6955 err *error
6956 }
6961 }
6964 return
6965 }
6967 // noCachedConnError is the concrete type of ErrNoCachedConn, which
6968 // needs to be detected by net/http regardless of whether it's its
6969 // bundled version (in h2_bundle.go with a rewritten type name) or
6970 // from a user's x/net/http2. As such, as it has a unique method name
6971 // (IsHTTP2NoCachedConnError) that net/http sniffs for via func
6972 // isNoCachedConnError.
6977 func (http2noCachedConnError) Error() string { return "http2: no cached connection was available" }
6979 // isNoCachedConnError reports whether err is of type noCachedConnError
6980 // or its equivalent renamed type in net/http2's h2_bundle.go. Both types
6981 // may coexist in the same running program.
6984 return ok
6985 }
6989 // RoundTripOpt are options for the Transport.RoundTripOpt method.
6991 // OnlyCachedConn controls whether RoundTripOpt may
6992 // create a new TCP connection. If set true and
6993 // no cached connection is available, RoundTripOpt
6994 // will return ErrNoCachedConn.
6995 OnlyCachedConn bool
6996 }
7000 }
7002 // authorityAddr returns a given authority (a host/IP, or host:port / ip:port)
7003 // and returns a host:port. The port 443 is added if needed.
7010 }
7011 host = authority
7012 }
7014 host = a
7015 }
7016 // IPv6 address literal, without a port:
7019 }
7021 }
7023 // RoundTripOpt is like RoundTrip, but takes options.
7024 func (t *http2Transport) RoundTripOpt(req *Request, opt http2RoundTripOpt) (*Response, error) {
7027 }
7035 }
7040 // After the first retry, do exponential backoff with 10% jitter.
7042 continue
7043 }
7048 continue
7051 }
7052 }
7053 }
7057 }
7059 }
7060 }
7062 // CloseIdleConnections closes any connections which were previously
7063 // connected from previous requests but are now sitting idle.
7064 // It does not interrupt any connections currently in use.
7068 }
7069 }
7074 http2errClientConnGotGoAway = errors.New("http2: Transport received Server's graceful shutdown GOAWAY")
7075 )
7077 // shouldRetryRequest is called by RoundTrip when a request fails to get
7078 // response headers. It is always called with a non-nil error.
7079 // It returns either a request to retry (either the same request, or a
7080 // modified clone), or an error if the request can't be replayed.
7084 }
7085 // If the Body is nil (or http.NoBody), it's safe to reuse
7086 // this request and its Body.
7089 }
7091 // If the request body can be reset back to its original
7092 // state via the optional req.GetBody, do that.
7095 // TODO: consider a req.Body.Close here? or audit that all caller paths do?
7099 }
7100 newReq := *req
7103 }
7105 // The Request.Body can't reset back to the beginning, but we
7106 // don't seem to have started to read from it yet, so reuse
7107 // the request directly. The "afterBodyWrite" means the
7108 // bodyWrite process has started, which becomes true before
7109 // the first Read.
7112 }
7114 return nil, fmt.Errorf("http2: Transport: cannot retry err [%v] after Request.Body was written; define Request.GetBody to avoid this error", err)
7115 }
7120 }
7123 }
7125 }
7127 func (t *http2Transport) dialClientConn(addr string, singleUse bool) (*http2ClientConn, error) {
7131 }
7135 }
7137 }
7143 }
7146 }
7149 }
7150 return cfg
7151 }
7156 }
7158 }
7160 func (t *http2Transport) dialTLSDefault(network, addr string, cfg *tls.Config) (net.Conn, error) {
7164 }
7167 }
7171 }
7172 }
7176 }
7179 }
7181 }
7183 // disableKeepAlives reports whether connections should be closed as
7184 // soon as possible after handling the first request.
7187 }
7192 }
7194 }
7198 }
7214 }
7218 }
7221 }
7226 // TODO: adjust this writer size to account for frame size +
7227 // MTU + crypto/tls record padding.
7234 // TODO: SetMaxDynamicTableSize, SetMaxDynamicTableSizeLimit on
7235 // henc in response to SETTINGS frames?
7240 }
7245 }
7250 }
7252 initialSettings = append(initialSettings, http2Setting{ID: http2SettingMaxHeaderListSize, Val: max})
7253 }
7262 }
7266 }
7275 // Merge the previous and current GoAway error frames.
7278 }
7281 }
7288 }
7289 }
7290 }
7291 }
7293 // CanTakeNewRequest reports whether the connection can take a new request,
7294 // meaning it has not been closed or received or sent a GOAWAY.
7299 }
7301 // clientConnIdleState describes the suitability of a client
7302 // connection to initiate a new RoundTrip request.
7304 canTakeNewRequest bool
7306 }
7312 }
7316 return
7317 }
7321 return
7322 }
7327 }
7329 // onIdleTimeout is called from a time.AfterFunc goroutine. It will
7330 // only be called when we're idle, but because we're coming from a new
7331 // goroutine, there could be a new request coming in at the same time,
7332 // so this simply calls the synchronized closeIfIdle to shut down this
7333 // connection. The timer could just call closeIfIdle, but this is more
7334 // clear.
7337 }
7343 return
7344 }
7347 // TODO: do clients send GOAWAY too? maybe? Just Close:
7351 cc.vlogf("http2: Transport closing idle conn %p (forSingleUse=%v, maxStream=%v)", cc, cc.singleUse, nextID-2)
7352 }
7354 }
7358 // Shutdown gracefully close the client connection, waiting for running streams to complete.
7359 // Public implementation is in go17.go and not_go17.go
7362 return err
7363 }
7364 // Wait for all in-flight streams to complete or connection to close
7374 break
7375 }
7377 break
7378 }
7380 }
7381 }()
7385 return err
7388 // Free the goroutine above
7393 }
7394 }
7402 // GOAWAY sent already
7404 }
7405 // Send a graceful shutdown frame to server
7408 return err
7409 }
7411 return err
7412 }
7413 // Prevent new requests
7416 }
7418 // Close closes the client connection immediately.
7419 //
7420 // In-flight requests are interrupted. For a graceful shutdown, use Shutdown instead.
7430 }
7433 }
7436 }
7440 // frameBuffer returns a scratch buffer suitable for writing DATA frames.
7441 // They're capped at the min of the peer's max frame size or 512KB
7442 // (kinda arbitrarily), but definitely capped so we don't allocate 4GB
7443 // bufers.
7448 size = http2maxAllocFrameSize
7449 }
7455 }
7456 }
7459 }
7467 return
7468 }
7472 return
7473 }
7474 }
7475 // forget about it.
7476 }
7478 // errRequestCanceled is a copy of net/http's errRequestCanceled because it's not
7479 // exported. At least they'll be DeepEqual for h1-vs-h2 comparisons tests.
7489 }
7491 }
7495 }
7497 }
7502 }
7503 // No way to do this (yet?) with just an http2.Transport. Probably
7504 // no need. Request.Cancel this is the new way. We only need to support
7505 // this for compatibility with the old http.Transport fields when
7506 // we're doing transparent http2.
7508 }
7510 // checkConnHeaders checks whether req has any invalid connection-level headers.
7511 // per RFC 7540 section 8.1.2.2: Connection-Specific Header Fields.
7512 // Certain headers are special-cased as okay but not transmitted later.
7516 }
7517 if vv := req.Header["Transfer-Encoding"]; len(vv) > 0 && (len(vv) > 1 || vv[0] != "" && vv[0] != "chunked") {
7519 }
7520 if vv := req.Header["Connection"]; len(vv) > 0 && (len(vv) > 1 || vv[0] != "" && !strings.EqualFold(vv[0], "close") && !strings.EqualFold(vv[0], "keep-alive")) {
7522 }
7524 }
7526 // actualContentLength returns a sanitized version of
7527 // req.ContentLength, where 0 actually means zero (not unknown) and -1
7528 // means unknown.
7532 }
7535 }
7537 }
7542 }
7544 func (cc *http2ClientConn) roundTrip(req *Request) (res *Response, gotErrAfterReqBodyWrite bool, err error) {
7547 }
7550 }
7555 }
7562 }
7568 // TODO(bradfitz): this is a copy of the logic in net/http. Unify somewhere?
7574 // Request gzip only, not deflate. Deflate is ambiguous and
7575 // not as universally supported anyway.
7576 // See: http://www.gzip.org/zlib/zlib_faq.html#faq38
7577 //
7578 // Note that we don't request this for HEAD requests,
7579 // due to a bug in nginx:
7580 // http://trac.nginx.org/nginx/ticket/358
7581 // https://golang.org/issue/5522
7582 //
7583 // We don't request gzip if the request is for a range, since
7584 // auto-decoding a portion of a gzipped document will just fail
7585 // anyway. See https://golang.org/issue/8923
7587 }
7589 // we send: HEADERS{1}, CONTINUATION{0,} + DATA{0,} (DATA is
7590 // sent by writeRequestBody below, along with any Trailers,
7591 // again in form HEADERS{1}, CONTINUATION{0,})
7596 }
7616 }
7618 // Don't bother sending a RST_STREAM (our write already failed;
7619 // no need to keep writing)
7622 }
7633 }
7634 }
7643 // On error or status code 3xx, 4xx, 5xx, etc abort any
7644 // ongoing write, assuming that the server doesn't care
7645 // about our request body. If the server replied with 1xx or
7646 // 2xx, however, then assume the server DOES potentially
7647 // want our body (e.g. full-duplex streaming:
7648 // golang.org/issue/13444). If it turns out the server
7649 // doesn't, they'll RST_STREAM us soon enough. This is a
7650 // heuristic to avoid adding knobs to Transport. Hopefully
7651 // we can keep it.
7654 }
7658 }
7662 }
7674 }
7682 }
7688 }
7696 }
7702 }
7710 }
7711 // processResetStream already removed the
7712 // stream from the streams map; no need for
7713 // forgetStreamID.
7716 // Prefer the read loop's response, if available. Issue 16102.
7721 }
7724 }
7730 }
7731 }
7732 }
7733 }
7735 // awaitOpenSlotForRequest waits until len(streams) < maxConcurrentStreams.
7736 // Must hold cc.mu.
7745 }
7746 return http2errClientConnUnusable
7747 }
7751 }
7753 }
7754 // Unfortunately, we cannot wait on a condition variable and channel at
7755 // the same time, so instead, we spin up a goroutine to check if the
7756 // request is canceled while we wait for a slot to open in the connection.
7762 waitingForConnErr = err
7765 }
7766 }()
7767 }
7772 return waitingForConnErr
7773 }
7774 }
7775 }
7777 // requires cc.wmu be held
7778 func (cc *http2ClientConn) writeHeaders(streamID uint32, endStream bool, maxFrameSize int, hdrs []byte) error {
7781 chunk := hdrs
7784 }
7793 })
7797 }
7798 }
7799 // TODO(bradfitz): this Flush could potentially block (as
7800 // could the WriteHeaders call(s) above), which means they
7801 // wouldn't respond to Request.Cancel being readable. That's
7802 // rare, but this should probably be in a goroutine.
7805 }
7807 // internal error values; they don't escape to callers
7809 // abort request body write; don't send cancel
7812 // abort request body write, but send stream reset of cancel.
7814 )
7816 func (cs *http2clientStream) writeRequestBody(body io.Reader, bodyCloser io.Closer) (err error) {
7824 // TODO: write h12Compare test showing whether
7825 // Request.Body is closed by the Transport,
7826 // and in multiple cases: server replies <=299 and >299
7827 // while still writing request body
7830 err = cerr
7831 }
7832 }()
7844 return err
7845 }
7853 return err
7856 return err
7858 return err
7859 }
7866 // TODO(bradfitz): this flush is for latency, not bandwidth.
7867 // Most requests won't need this. Make this opt-in or
7868 // opt-out? Use some heuristic on the body type? Nagel-like
7869 // timers? Based on 'n'? Only last chunk of this for loop,
7870 // unless flow control tokens are low? For now, always.
7871 // If we change this, see comment below.
7873 }
7875 }
7877 return err
7878 }
7879 }
7882 // Already sent END_STREAM (which implies we have no
7883 // trailers) and flushed, because currently all
7884 // WriteData frames above get a flush. So we're done.
7886 }
7896 return err
7897 }
7898 }
7907 // Two ways to send END_STREAM: either with trailers, or
7908 // with an empty DATA frame.
7913 }
7915 err = ferr
7916 }
7917 return err
7918 }
7920 // awaitFlowControl waits for [1, min(maxBytes, cc.cs.maxFrameSize)] flow
7921 // control tokens from the server.
7922 // It returns either the non-zero number of tokens taken or an error
7923 // if the stream is dead.
7931 }
7934 }
7937 }
7939 take := a
7943 }
7946 }
7949 }
7951 }
7952 }
7955 what string
7956 str string
7957 }
7961 // requires cc.mu be held.
7962 func (cc *http2ClientConn) encodeHeaders(req *Request, addGzipHeader bool, trailers string, contentLength int64) ([]byte, error) {
7968 }
7972 }
7978 orig := path
7985 }
7986 }
7987 }
7988 }
7990 // Check for any invalid headers and return an error before we
7991 // potentially pollute our hpack state. (We want to be able to
7992 // continue to reuse the hpack encoder for future requests)
7996 }
8000 }
8001 }
8002 }
8005 // 8.1.2.3 Request Pseudo-Header Fields
8006 // The :path pseudo-header field includes the path and query parts of the
8007 // target URI (the path-absolute production and optionally a '?' character
8008 // followed by the query production (see Sections 3.3 and 3.4 of
8009 // [RFC3986]).
8015 }
8018 }
8023 // Host is :authority, already sent.
8024 // Content-Length is automatic, set below.
8025 continue
8029 // Per 8.1.2.2 Connection-Specific Header
8030 // Fields, don't send connection-specific
8031 // fields. We have already checked if any
8032 // are error-worthy so just ignore the rest.
8033 continue
8035 // Match Go's http1 behavior: at most one
8036 // User-Agent. If set to nil or empty string,
8037 // then omit it. Otherwise if not mentioned,
8038 // include the default (below).
8041 continue
8042 }
8045 continue
8046 }
8048 }
8052 }
8053 }
8056 }
8059 }
8062 }
8063 }
8065 // Do a first pass over the headers counting bytes to ensure
8066 // we don't exceed cc.peerMaxHeaderListSize. This is done as a
8067 // separate pass before encoding the headers to prevent
8068 // modifying the hpack state.
8073 })
8077 }
8082 // Header list size is ok. Write the headers.
8088 }
8089 })
8092 }
8094 // shouldSendReqContentLength reports whether the http2.Transport should send
8095 // a "content-length" request header. This logic is basically a copy of the net/http
8096 // transferWriter.shouldSendContentLength.
8097 // The contentLength is the corrected contentLength (so 0 means actually 0, not unknown).
8098 // -1 means unknown.
8102 }
8105 }
8106 // For zero bodies, whether we send a content-length depends on the method.
8107 // It also kinda doesn't matter for http2 either way, with END_STREAM.
8113 }
8114 }
8116 // requires cc.mu be held.
8125 }
8126 }
8129 }
8132 // Transfer-Encoding, etc.. have already been filtered at the
8133 // start of RoundTrip
8137 }
8138 }
8140 }
8145 }
8147 }
8150 res *Response
8151 err error
8152 }
8154 // requires cc.mu be held.
8162 }
8169 return cs
8170 }
8174 }
8185 }
8187 // Wake up checkResetOrDone via clientStream.awaitFlowControl and
8188 // wake up RoundTrip if there is a pending request.
8190 }
8191 return cs
8192 }
8194 // clientConnReadLoop is the state owned by the clientConn's frame-reading readLoop.
8196 cc *http2ClientConn
8197 closeWhenIdle bool
8198 }
8200 // readLoop runs in its own goroutine and reads and dispatches frames.
8209 }
8210 }
8212 // GoAwayError is returned by the Transport when the server closes the
8213 // TCP connection after sending a GOAWAY frame.
8215 LastStreamID uint32
8216 ErrCode http2ErrCode
8217 DebugData string
8218 }
8221 return fmt.Sprintf("http2: server sent GOAWAY and closed the connection; LastStreamID=%v, ErrCode=%v, debug=%q",
8223 }
8228 }
8231 }
8241 }
8243 // Close any response bodies if the server closes prematurely.
8244 // TODO: also do this if we've written the headers but not
8245 // gotten a response yet.
8253 }
8256 }
8262 }
8264 }
8268 }
8279 }
8286 }
8288 }
8289 continue
8291 return err
8292 }
8295 }
8300 }
8302 }
8329 }
8332 cc.vlogf("http2: Transport conn %p received error from processing frame %v: %v", cc, http2summarizeFrame(f), err)
8333 }
8334 return err
8335 }
8338 }
8339 }
8340 }
8346 // We'd get here if we canceled a request while the
8347 // server had its response still in flight. So if this
8348 // was just something we canceled, ignore it.
8350 }
8352 // Issue 20521: If the stream has ended, streamByID() causes
8353 // clientStream.done to be closed, which causes the request's bodyWriter
8354 // to be closed with an errStreamClosed, which may be received by
8355 // clientConn.RoundTrip before the result of processing these headers.
8356 // Deferring stream closure allows the header processing to occur first.
8357 // clientConn.RoundTrip may still receive the bodyWriter error first, but
8358 // the fix for issue 16102 prioritises any response.
8359 //
8360 // Issue 22413: If there is no request body, we should close the
8361 // stream before writing to cs.resc so that the stream is closed
8362 // immediately once RoundTrip returns.
8367 }
8368 }
8371 // TODO(bradfitz): move first response byte earlier,
8372 // when we first read the 9 byte header, not waiting
8373 // until all the HEADERS+CONTINUATION frames have been
8374 // merged. This works for now.
8376 }
8378 }
8383 }
8388 return err
8389 }
8390 // Any other error type is a stream error.
8395 }
8397 // (nil, nil) special case. See handleResponse docs.
8399 }
8403 }
8405 // may return error types nil, or ConnectionError. Any other error value
8406 // is a StreamError of type ErrCodeProtocol. The returned error in that case
8407 // is the detail.
8408 //
8409 // As a special case, handleResponse may return (nil, nil) to skip the
8410 // frame (currently only used for 1xx responses).
8411 func (rl *http2clientConnReadLoop) handleResponse(cs *http2clientStream, f *http2MetaHeadersFrame) (*Response, error) {
8414 }
8419 }
8422 return nil, errors.New("malformed response from server: malformed non-numeric status pseudo header")
8423 }
8432 }
8440 }
8443 })
8446 }
8447 }
8451 const max1xxResponses = 5 // arbitrary bound on number of informational responses, same as net/http
8454 }
8458 }
8459 }
8464 }
8465 }
8468 }
8478 // TODO: care? unlike http/1, it won't mess up our framing, so it's
8479 // more safe smuggling-wise to ignore.
8480 }
8482 // TODO: care? unlike http/1, it won't mess up our framing, so it's
8483 // more safe smuggling-wise to ignore.
8484 }
8485 }
8490 }
8503 }
8505 }
8507 func (rl *http2clientConnReadLoop) processTrailers(cs *http2clientStream, f *http2MetaHeadersFrame) error {
8509 // Too many HEADERS frames for this stream.
8511 }
8514 // We expect that any headers for trailers also
8515 // has END_STREAM.
8517 }
8519 // No pseudo header fields are defined for trailers.
8520 // TODO: ConnectionError might be overly harsh? Check.
8522 }
8528 }
8533 }
8535 // transportResponseBody is the concrete type of Transport.RoundTrip's
8536 // Response.Body. It is an io.ReadCloser. On Read, it reads from cs.body.
8537 // On Close it sends RST_STREAM if EOF wasn't already seen.
8539 cs *http2clientStream
8540 }
8548 }
8556 }
8559 }
8565 }
8566 }
8568 // No flow control tokens to send back.
8569 return
8570 }
8576 // Check the conn-level first, before the stream-level.
8580 }
8582 // Consider any buffered body data (read from the conn but not
8583 // consumed by the client) when computing flow control for this
8584 // stream.
8589 }
8590 }
8596 }
8599 }
8601 }
8602 return
8603 }
8620 }
8621 // Return connection-level flow control.
8625 }
8629 }
8634 }
8645 // We never asked for this.
8648 }
8649 // We probably did ask for this, but canceled. Just ignore it.
8650 // TODO: be stricter here? only silently ignore things which
8651 // we canceled, but not things which were closed normally
8652 // by the peer? Tough without accumulating too much state.
8654 // But at least return their flow control:
8664 }
8666 }
8672 })
8674 }
8681 })
8683 }
8684 // Check connection-level flow control.
8691 }
8692 // Return any padded flow control now, since we won't
8693 // refund it later on body reads.
8696 refund += pad
8697 }
8698 // Return len(data) now if the stream is already closed,
8699 // since data will never be read.
8703 }
8711 }
8714 }
8720 return err
8721 }
8722 }
8723 }
8727 }
8729 }
8734 // TODO: check that any declared content-length matches, like
8735 // server.go's (*stream).endStream method.
8737 }
8744 }
8747 }
8753 }
8754 }
8761 }
8763 }
8764 }
8770 // TODO: deal with GOAWAY more. particularly the error code
8772 }
8775 }
8786 }
8788 }
8799 // Values above the maximum flow-control
8800 // window size of 2^31-1 MUST be treated as a
8801 // connection error (Section 5.4.1) of type
8802 // FLOW_CONTROL_ERROR.
8805 }
8807 // Adjust flow control of currently-open
8808 // frames by the difference of the old initial
8809 // window size and this one.
8813 }
8818 // TODO(bradfitz): handle more settings? SETTINGS_HEADER_TABLE_SIZE probably.
8820 }
8822 })
8824 return err
8825 }
8833 }
8840 }
8848 }
8851 }
8854 }
8859 // TODO: return error if server tries to RST_STEAM an idle stream
8861 }
8864 // Already reset.
8865 // This is the only goroutine
8866 // which closes this, so there
8867 // isn't a race.
8874 }
8876 }
8878 // Ping sends a PING frame to the server and waits for the ack.
8879 // Public implementation is in go17.go and not_go17.go
8882 // Generate a random payload
8886 return err
8887 }
8889 // check for dup before insert
8893 break
8894 }
8896 }
8900 return err
8901 }
8904 return err
8905 }
8913 // connection closed
8915 }
8916 }
8923 // If ack, notify listener if any
8927 }
8929 }
8934 return err
8935 }
8937 }
8940 // We told the peer we don't want them.
8941 // Spec says:
8942 // "PUSH_PROMISE MUST NOT be sent if the SETTINGS_ENABLE_PUSH
8943 // setting of the peer endpoint is set to 0. An endpoint that
8944 // has set this setting and has received acknowledgement MUST
8945 // treat the receipt of a PUSH_PROMISE frame as a connection
8946 // error (Section 5.4.1) of type PROTOCOL_ERROR."
8948 }
8951 // TODO: map err to more interesting error codes, once the
8952 // HTTP community comes up with some. But currently for
8953 // RST_STREAM there's no equivalent to GOAWAY frame's debug
8954 // data, and the error codes are all pretty vague ("cancel").
8959 }
8962 http2errResponseHeaderListSize = errors.New("http2: response header list larger than advertised limit")
8963 http2errRequestHeaderListSize = errors.New("http2: request header list larger than peer's advertised limit")
8965 )
8969 }
8973 }
8978 }
8979 }
8983 }
8991 }
8992 }
8994 }
8998 func (rt http2erringRoundTripper) RoundTrip(*Request) (*Response, error) { return nil, rt.err }
9000 // gzipReader wraps a response body so it can lazily
9001 // call gzip.NewReader on the first call to Read
9005 zerr error // sticky error
9006 }
9011 }
9017 }
9018 }
9020 }
9024 }
9030 // bodyWriterState encapsulates various state around the Transport's writing
9031 // of the request body, particularly regarding doing delayed writes of the body
9032 // when the request contains "Expect: 100-continue".
9034 cs *http2clientStream
9040 }
9042 func (t *http2Transport) getBodyWriterState(cs *http2clientStream, body io.Reader) (s http2bodyWriterState) {
9045 return
9046 }
9054 }
9060 return
9061 }
9064 // Arm the timer with a very large duration, which we'll
9065 // intentionally lower later. It has to be large now because
9066 // we need a handle to it before writing the headers, but the
9067 // s.delay value is defined to not start until after the
9068 // request headers were written.
9072 })
9073 return
9074 }
9079 }
9080 }
9084 // If we didn't do a delayed write, ignore the server's
9085 // bogus 100 continue response.
9086 return
9087 }
9090 }
9092 // scheduleBodyWrite starts writing the body, either immediately (in
9093 // the common case) or after the delay timeout. It should not be
9094 // called until after the headers have been written.
9097 // We're not doing a delayed write (see
9098 // getBodyWriterState), so just start the writing
9099 // goroutine immediately.
9101 return
9102 }
9106 }
9107 }
9109 // isConnectionCloseRequest reports whether req should use its own
9110 // connection for a single request and then close the connection.
9113 }
9115 // writeFramer is implemented by any type that is used to write frames.
9119 // staysWithinBuffer reports whether this writer promises that
9120 // it will only write less than or equal to size bytes, and it
9121 // won't Flush the write context.
9123 }
9125 // writeContext is the interface needed by the various frame writer
9126 // types below. All the writeFrame methods below are scheduled via the
9127 // frame writing scheduler (see writeScheduler in writesched.go).
9128 //
9129 // This interface is implemented by *serverConn.
9130 //
9131 // TODO: decide whether to a) use this in the client code (which didn't
9132 // end up using this yet, because it has a simpler design, not
9133 // currently implementing priorities), or b) delete this and
9134 // make the server code a bit more concrete.
9139 // HeaderEncoder returns an HPACK encoder that writes to the
9140 // returned buffer.
9142 }
9144 // writeEndsStream reports whether w writes a frame that will transition
9145 // the stream to a half-closed local state. This returns false for RST_STREAM,
9146 // which closes the entire stream (not just the local half).
9154 // This can only happen if the caller reuses w after it's
9155 // been intentionally nil'ed out to prevent use. Keep this
9156 // here to catch future refactoring breaking it.
9158 }
9160 }
9166 }
9176 }
9180 }
9183 maxStreamID uint32
9184 code http2ErrCode
9185 }
9190 return err
9191 }
9196 streamID uint32
9198 endStream bool
9199 }
9202 return fmt.Sprintf("writeData(stream=%d, p=%d, endStream=%v)", w.streamID, len(w.p), w.endStream)
9203 }
9207 }
9211 }
9213 // handlerPanicRST is the message sent from handler goroutines when
9214 // the handler panics.
9216 StreamID uint32
9217 }
9221 }
9223 func (hp http2handlerPanicRST) staysWithinBuffer(max int) bool { return http2frameHeaderLen+4 <= max }
9227 }
9229 func (se http2StreamError) staysWithinBuffer(max int) bool { return http2frameHeaderLen+4 <= max }
9235 }
9239 }
9245 }
9247 func (http2writeSettingsAck) staysWithinBuffer(max int) bool { return http2frameHeaderLen <= max }
9249 // splitHeaderBlock splits headerBlock into fragments so that each fragment fits
9250 // in a single frame, then calls fn for each fragment. firstFrag/lastFrag are true
9251 // for the first/last fragment, respectively.
9252 func http2splitHeaderBlock(ctx http2writeContext, headerBlock []byte, fn func(ctx http2writeContext, frag []byte, firstFrag, lastFrag bool) error) error {
9253 // For now we're lazy and just pick the minimum MAX_FRAME_SIZE
9254 // that all peers must support (16KB). Later we could care
9255 // more and send larger frames if the peer advertised it, but
9256 // there's little point. Most headers are small anyway (so we
9257 // generally won't have CONTINUATION frames), and extra frames
9258 // only waste 9 bytes anyway.
9263 frag := headerBlock
9266 }
9269 return err
9270 }
9272 }
9274 }
9276 // writeResHeaders is a request to write a HEADERS and 0+ CONTINUATION frames
9277 // for HTTP response headers or trailers from a server handler.
9279 streamID uint32
9281 h Header // may be nil
9283 endStream bool
9285 date string
9286 contentType string
9287 contentLength string
9288 }
9293 }
9295 }
9298 // TODO: this is a common one. It'd be nice to return true
9299 // here and get into the fast path if we could be clever and
9300 // calculate the size fast enough, or at least a conservative
9301 // uppper bound that usually fires. (Maybe if w.h and
9302 // w.trailers are nil, so we don't need to enumerate it.)
9303 // Otherwise I'm afraid that just calculating the length to
9304 // answer this question would be slower than the ~2µs benefit.
9306 }
9314 }
9320 }
9323 }
9326 }
9331 }
9334 }
9336 func (w *http2writeResHeaders) writeHeaderBlock(ctx http2writeContext, frag []byte, firstFrag, lastFrag bool) error {
9343 })
9346 }
9347 }
9349 // writePushPromise is a request to write a PUSH_PROMISE and 0+ CONTINUATION frames.
9354 h Header
9356 // Creates an ID for a pushed stream. This runs on serveG just before
9357 // the frame is written. The returned ID is copied to promisedID.
9359 promisedID uint32
9360 }
9363 // TODO: see writeResHeaders.staysWithinBuffer
9365 }
9380 }
9383 }
9385 func (w *http2writePushPromise) writeHeaderBlock(ctx http2writeContext, frag []byte, firstFrag, lastFrag bool) error {
9392 })
9395 }
9396 }
9399 streamID uint32
9400 }
9411 })
9412 }
9415 // Sloppy but conservative:
9417 }
9421 n uint32
9422 }
9424 func (wu http2writeWindowUpdate) staysWithinBuffer(max int) bool { return http2frameHeaderLen+4 <= max }
9428 }
9430 // encodeHeaders encodes an http.Header. If keys is not nil, then (k, h[k])
9431 // is encoded only only if k is in keys.
9435 // Using defer here, since the returned keys from the
9436 // sorter.Keys method is only valid until the sorter
9437 // is returned:
9440 }
9445 // Skip it as backup paranoia. Per
9446 // golang.org/issue/14048, these should
9447 // already be rejected at a higher level.
9448 continue
9449 }
9453 // TODO: return an error? golang.org/issue/14048
9454 // For now just omit it.
9455 continue
9456 }
9457 // TODO: more of "8.1.2.2 Connection-Specific Header Fields"
9459 continue
9460 }
9462 }
9463 }
9464 }
9466 // WriteScheduler is the interface implemented by HTTP/2 write schedulers.
9467 // Methods are never called concurrently.
9469 // OpenStream opens a new stream in the write scheduler.
9470 // It is illegal to call this with streamID=0 or with a streamID that is
9471 // already open -- the call may panic.
9474 // CloseStream closes a stream in the write scheduler. Any frames queued on
9475 // this stream should be discarded. It is illegal to call this on a stream
9476 // that is not open -- the call may panic.
9479 // AdjustStream adjusts the priority of the given stream. This may be called
9480 // on a stream that has not yet been opened or has been closed. Note that
9481 // RFC 7540 allows PRIORITY frames to be sent on streams in any state. See:
9482 // https://tools.ietf.org/html/rfc7540#section-5.1
9485 // Push queues a frame in the scheduler. In most cases, this will not be
9486 // called with wr.StreamID()!=0 unless that stream is currently open. The one
9487 // exception is RST_STREAM frames, which may be sent on idle or closed streams.
9490 // Pop dequeues the next frame to write. Returns false if no frames can
9491 // be written. Frames with a given wr.StreamID() are Pop'd in the same
9492 // order they are Push'd.
9494 }
9496 // OpenStreamOptions specifies extra options for WriteScheduler.OpenStream.
9498 // PusherID is zero if the stream was initiated by the client. Otherwise,
9499 // PusherID names the stream that pushed the newly opened stream.
9500 PusherID uint32
9501 }
9503 // FrameWriteRequest is a request to write a frame.
9505 // write is the interface value that does the writing, once the
9506 // WriteScheduler has selected this frame to write. The write
9507 // functions are all defined in write.go.
9508 write http2writeFramer
9510 // stream is the stream on which this frame will be written.
9511 // nil for non-stream frames like PING and SETTINGS.
9512 stream *http2stream
9514 // done, if non-nil, must be a buffered channel with space for
9515 // 1 message and is sent the return value from write (or an
9516 // earlier error) when the frame has been written.
9517 done chan error
9518 }
9520 // StreamID returns the id of the stream this frame will be written to.
9521 // 0 is used for non-stream frames such as PING and SETTINGS.
9525 // (*serverConn).resetStream doesn't set
9526 // stream because it doesn't necessarily have
9527 // one. So special case this type of write
9528 // message.
9530 }
9532 }
9534 }
9536 // DataSize returns the number of flow control bytes that must be consumed
9537 // to write this entire frame. This is 0 for non-DATA frames.
9541 }
9543 }
9545 // Consume consumes min(n, available) bytes from this frame, where available
9546 // is the number of flow control bytes available on the stream. Consume returns
9547 // 0, 1, or 2 frames, where the integer return value gives the number of frames
9548 // returned.
9549 //
9550 // If flow control prevents consuming any bytes, this returns (_, _, 0). If
9551 // the entire frame was consumed, this returns (wr, _, 1). Otherwise, this
9552 // returns (consumed, rest, 2), where 'consumed' contains the consumed bytes and
9553 // 'rest' contains the remaining bytes. The consumed bytes are deducted from the
9554 // underlying stream's flow control budget.
9555 func (wr http2FrameWriteRequest) Consume(n int32) (http2FrameWriteRequest, http2FrameWriteRequest, int) {
9556 var empty http2FrameWriteRequest
9558 // Non-DATA frames are always consumed whole.
9562 }
9564 // Might need to split after applying limits.
9567 allowed = n
9568 }
9571 }
9574 }
9582 // Even if the original had endStream set, there
9583 // are bytes remaining because len(wd.p) > allowed,
9584 // so we know endStream is false.
9586 },
9587 // Our caller is blocking on the final DATA frame, not
9588 // this intermediate frame, so no need to wait.
9590 }
9597 },
9599 }
9601 }
9603 // The frame is consumed whole.
9604 // NB: This cast cannot overflow because allowed is <= math.MaxInt32.
9607 }
9609 // String is for debugging only.
9616 }
9617 return fmt.Sprintf("[FrameWriteRequest stream=%d, ch=%v, writer=%v]", wr.StreamID(), wr.done != nil, des)
9618 }
9620 // replyToWriter sends err to wr.done and panics if the send must block
9621 // This does nothing if wr.done is nil.
9624 return
9625 }
9630 }
9632 }
9634 // writeQueue is used by implementations of WriteScheduler.
9636 s []http2FrameWriteRequest
9637 }
9643 }
9648 }
9650 // TODO: less copy-happy queue.
9654 return wr
9655 }
9657 // consume consumes up to n bytes from q.s[0]. If the frame is
9658 // entirely consumed, it is removed from the queue. If the frame
9659 // is partially consumed, the frame is kept with the consumed
9660 // bytes removed. Returns true iff any bytes were consumed.
9664 }
9673 }
9675 }
9679 // put inserts an unused writeQueue into the pool.
9681 // put inserts an unused writeQueue into the pool.
9685 }
9688 }
9690 // get returns an empty writeQueue.
9695 }
9700 return q
9701 }
9703 // RFC 7540, Section 5.3.5: the default weight is 16.
9706 // PriorityWriteSchedulerConfig configures a priorityWriteScheduler.
9708 // MaxClosedNodesInTree controls the maximum number of closed streams to
9709 // retain in the priority tree. Setting this to zero saves a small amount
9710 // of memory at the cost of performance.
9711 //
9712 // See RFC 7540, Section 5.3.4:
9713 // "It is possible for a stream to become closed while prioritization
9714 // information ... is in transit. ... This potentially creates suboptimal
9715 // prioritization, since the stream could be given a priority that is
9716 // different from what is intended. To avoid these problems, an endpoint
9717 // SHOULD retain stream prioritization state for a period after streams
9718 // become closed. The longer state is retained, the lower the chance that
9719 // streams are assigned incorrect or default priority values."
9720 MaxClosedNodesInTree int
9722 // MaxIdleNodesInTree controls the maximum number of idle streams to
9723 // retain in the priority tree. Setting this to zero saves a small amount
9724 // of memory at the cost of performance.
9725 //
9726 // See RFC 7540, Section 5.3.4:
9727 // Similarly, streams that are in the "idle" state can be assigned
9728 // priority or become a parent of other streams. This allows for the
9729 // creation of a grouping node in the dependency tree, which enables
9730 // more flexible expressions of priority. Idle streams begin with a
9731 // default priority (Section 5.3.5).
9732 MaxIdleNodesInTree int
9734 // ThrottleOutOfOrderWrites enables write throttling to help ensure that
9735 // data is delivered in priority order. This works around a race where
9736 // stream B depends on stream A and both streams are about to call Write
9737 // to queue DATA frames. If B wins the race, a naive scheduler would eagerly
9738 // write as much data from B as possible, but this is suboptimal because A
9739 // is a higher-priority stream. With throttling enabled, we write a small
9740 // amount of data from B to minimize the amount of bandwidth that B can
9741 // steal from A.
9742 ThrottleOutOfOrderWrites bool
9743 }
9745 // NewPriorityWriteScheduler constructs a WriteScheduler that schedules
9746 // frames by following HTTP/2 priorities as described in RFC 7540 Section 5.3.
9747 // If cfg is nil, default options are used.
9748 func http2NewPriorityWriteScheduler(cfg *http2PriorityWriteSchedulerConfig) http2WriteScheduler {
9750 // For justification of these defaults, see:
9751 // https://docs.google.com/document/d/1oLhNg1skaWD4_DtaoCxdSRN5erEXrH-KnLrMwEpOtFY
9756 }
9757 }
9764 }
9770 }
9771 return ws
9772 }
9778 http2priorityNodeClosed
9779 http2priorityNodeIdle
9780 )
9782 // priorityNode is a node in an HTTP/2 priority tree.
9783 // Each node is associated with a single stream ID.
9784 // See RFC 7540, Section 5.3.
9786 q http2writeQueue // queue of pending frames to write
9789 state http2priorityNodeState // open | closed | idle
9793 // These links form the priority tree.
9794 parent *http2priorityNode
9797 }
9802 }
9804 return
9805 }
9806 // Unlink from current parent.
9812 }
9815 }
9816 }
9817 // Link to new parent.
9818 // If parent=nil, remove n from the tree.
9819 // Always insert at the head of parent.kids (this is assumed by walkReadyInOrder).
9829 }
9831 }
9832 }
9838 }
9839 }
9841 // walkReadyInOrder iterates over the tree in priority order, calling f for each node
9842 // with a non-empty write queue. When f returns true, this funcion returns true and the
9843 // walk halts. tmp is used as scratch space for sorting.
9844 //
9845 // f(n, openParent) takes two arguments: the node to visit, n, and a bool that is true
9846 // if any ancestor p of n is still open (ignoring the root node).
9847 func (n *http2priorityNode) walkReadyInOrder(openParent bool, tmp *[]*http2priorityNode, f func(*http2priorityNode, bool) bool) bool {
9850 }
9853 }
9855 // Don't consider the root "open" when updating openParent since
9856 // we can't send data frames on the root stream (only control frames).
9859 }
9861 // Common case: only one kid or all kids have the same weight.
9862 // Some clients don't use weights; other clients (like web browsers)
9863 // use mostly-linear priority trees.
9869 break
9870 }
9871 }
9876 }
9877 }
9879 }
9881 // Uncommon case: sort the child nodes. We remove the kids from the parent,
9882 // then re-insert after sorting so we can reuse tmp for future sort calls.
9887 }
9891 }
9895 }
9896 }
9898 }
9907 // Prefer the subtree that has sent fewer bytes relative to its weight.
9908 // See sections 5.3.2 and 5.3.4.
9913 }
9916 }
9918 }
9921 // root is the root of the priority tree, where root.id = 0.
9922 // The root queues control frames that are not associated with any stream.
9923 root http2priorityNode
9925 // nodes maps stream ids to priority tree nodes.
9928 // maxID is the maximum stream id in nodes.
9929 maxID uint32
9931 // lists of nodes that have been closed or are idle, but are kept in
9932 // the tree for improved prioritization. When the lengths exceed either
9933 // maxClosedNodesInTree or maxIdleNodesInTree, old nodes are discarded.
9936 // From the config.
9937 maxClosedNodesInTree int
9938 maxIdleNodesInTree int
9939 writeThrottleLimit int32
9940 enableWriteThrottle bool
9942 // tmp is scratch space for priorityNode.walkReadyInOrder to reduce allocations.
9943 tmp []*http2priorityNode
9945 // pool of empty queues for reuse.
9946 queuePool http2writeQueuePool
9947 }
9949 func (ws *http2priorityWriteScheduler) OpenStream(streamID uint32, options http2OpenStreamOptions) {
9950 // The stream may be currently idle but cannot be opened or closed.
9954 }
9956 return
9957 }
9959 // RFC 7540, Section 5.3.5:
9960 // "All streams are initially assigned a non-exclusive dependency on stream 0x0.
9961 // Pushed streams initially depend on their associated stream. In both cases,
9962 // streams are assigned a default weight of 16."
9966 }
9972 }
9977 }
9978 }
9983 }
9986 }
9988 panic(fmt.Sprintf("violation of WriteScheduler interface: stream %d already closed", streamID))
9989 }
10002 }
10003 }
10005 func (ws *http2priorityWriteScheduler) AdjustStream(streamID uint32, priority http2PriorityParam) {
10008 }
10010 // If streamID does not exist, there are two cases:
10011 // - A closed stream that has been removed (this will have ID <= maxID)
10012 // - An idle stream that is being used for "grouping" (this will have ID > maxID)
10016 return
10017 }
10024 }
10028 }
10030 // Section 5.3.1: A dependency on a stream that is not currently in the tree
10031 // results in that stream being given a default priority (Section 5.3.5).
10036 return
10037 }
10039 // Ignore if the client tries to make a node its own parent.
10041 return
10042 }
10044 // Section 5.3.3:
10045 // "If a stream is made dependent on one of its own dependencies, the
10046 // formerly dependent stream is first moved to be dependent on the
10047 // reprioritized stream's previous parent. The moved dependency retains
10048 // its weight."
10049 //
10050 // That is: if parent depends on n, move parent to depend on n.parent.
10054 break
10055 }
10056 }
10058 // Section 5.3.3: The exclusive flag causes the stream to become the sole
10059 // dependency of its parent stream, causing other dependencies to become
10060 // dependent on the exclusive stream.
10067 }
10068 k = next
10069 }
10070 }
10074 }
10083 // id is an idle or closed stream. wr should not be a HEADERS or
10084 // DATA frame. However, wr can be a RST_STREAM. In this case, we
10085 // push wr onto the root, rather than creating a new priorityNode,
10086 // since RST_STREAM is tiny and the stream's priority is unknown
10087 // anyway. See issue #17919.
10090 }
10092 }
10093 }
10095 }
10102 }
10106 }
10108 // If B depends on A and B continuously has data available but A
10109 // does not, gradually increase the throttling limit to allow B to
10110 // steal more and more bandwidth from A.
10115 }
10118 }
10120 })
10122 }
10124 func (ws *http2priorityWriteScheduler) addClosedOrIdleNode(list *[]*http2priorityNode, maxSize int, n *http2priorityNode) {
10126 return
10127 }
10129 // Remove the oldest node, then shift left.
10134 }
10136 }
10141 }
10144 }
10146 // NewRandomWriteScheduler constructs a WriteScheduler that ignores HTTP/2
10147 // priorities. Control frames like SETTINGS and PING are written before DATA
10148 // frames, but if no control frames are queued and multiple streams have queued
10149 // HEADERS or DATA frames, Pop selects a ready stream arbitrarily.
10152 }
10155 // zero are frames not associated with a specific stream.
10156 zero http2writeQueue
10158 // sq contains the stream-specific queues, keyed by stream ID.
10159 // When a stream is idle or closed, it's deleted from the map.
10162 // pool of empty queues for reuse.
10163 queuePool http2writeQueuePool
10164 }
10166 func (ws *http2randomWriteScheduler) OpenStream(streamID uint32, options http2OpenStreamOptions) {
10167 // no-op: idle streams are not tracked
10168 }
10173 return
10174 }
10177 }
10179 func (ws *http2randomWriteScheduler) AdjustStream(streamID uint32, priority http2PriorityParam) {
10180 // no-op: priorities are ignored
10181 }
10187 return
10188 }
10193 }
10195 }
10198 // Control frames first.
10201 }
10202 // Iterate over all non-idle streams until finding one that can be consumed.
10206 }
10207 }
10209 }