Source file src/net/http/internal/http2/frame.go

     1  // Copyright 2014 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package http2
     6  
     7  import (
     8  	"bytes"
     9  	"encoding/binary"
    10  	"errors"
    11  	"fmt"
    12  	"io"
    13  	"log"
    14  	"slices"
    15  	"strings"
    16  	"sync"
    17  
    18  	"net/http/internal/httpsfv"
    19  
    20  	"golang.org/x/net/http2/hpack"
    21  
    22  	"golang.org/x/net/http/httpguts"
    23  )
    24  
    25  const frameHeaderLen = 9
    26  
    27  var padZeros = make([]byte, 255) // zeros for padding
    28  
    29  // A FrameType is a registered frame type as defined in
    30  // https://httpwg.org/specs/rfc7540.html#rfc.section.11.2 and other future
    31  // RFCs.
    32  type FrameType uint8
    33  
    34  const (
    35  	FrameData           FrameType = 0x0
    36  	FrameHeaders        FrameType = 0x1
    37  	FramePriority       FrameType = 0x2
    38  	FrameRSTStream      FrameType = 0x3
    39  	FrameSettings       FrameType = 0x4
    40  	FramePushPromise    FrameType = 0x5
    41  	FramePing           FrameType = 0x6
    42  	FrameGoAway         FrameType = 0x7
    43  	FrameWindowUpdate   FrameType = 0x8
    44  	FrameContinuation   FrameType = 0x9
    45  	FramePriorityUpdate FrameType = 0x10
    46  )
    47  
    48  var frameNames = [...]string{
    49  	FrameData:           "DATA",
    50  	FrameHeaders:        "HEADERS",
    51  	FramePriority:       "PRIORITY",
    52  	FrameRSTStream:      "RST_STREAM",
    53  	FrameSettings:       "SETTINGS",
    54  	FramePushPromise:    "PUSH_PROMISE",
    55  	FramePing:           "PING",
    56  	FrameGoAway:         "GOAWAY",
    57  	FrameWindowUpdate:   "WINDOW_UPDATE",
    58  	FrameContinuation:   "CONTINUATION",
    59  	FramePriorityUpdate: "PRIORITY_UPDATE",
    60  }
    61  
    62  func (t FrameType) String() string {
    63  	if int(t) < len(frameNames) {
    64  		return frameNames[t]
    65  	}
    66  	return fmt.Sprintf("UNKNOWN_FRAME_TYPE_%d", t)
    67  }
    68  
    69  // Flags is a bitmask of HTTP/2 flags.
    70  // The meaning of flags varies depending on the frame type.
    71  type Flags uint8
    72  
    73  // Has reports whether f contains all (0 or more) flags in v.
    74  func (f Flags) Has(v Flags) bool {
    75  	return (f & v) == v
    76  }
    77  
    78  // Frame-specific FrameHeader flag bits.
    79  const (
    80  	// Data Frame
    81  	FlagDataEndStream Flags = 0x1
    82  	FlagDataPadded    Flags = 0x8
    83  
    84  	// Headers Frame
    85  	FlagHeadersEndStream  Flags = 0x1
    86  	FlagHeadersEndHeaders Flags = 0x4
    87  	FlagHeadersPadded     Flags = 0x8
    88  	FlagHeadersPriority   Flags = 0x20
    89  
    90  	// Settings Frame
    91  	FlagSettingsAck Flags = 0x1
    92  
    93  	// Ping Frame
    94  	FlagPingAck Flags = 0x1
    95  
    96  	// Continuation Frame
    97  	FlagContinuationEndHeaders Flags = 0x4
    98  
    99  	FlagPushPromiseEndHeaders Flags = 0x4
   100  	FlagPushPromisePadded     Flags = 0x8
   101  )
   102  
   103  var flagName = map[FrameType]map[Flags]string{
   104  	FrameData: {
   105  		FlagDataEndStream: "END_STREAM",
   106  		FlagDataPadded:    "PADDED",
   107  	},
   108  	FrameHeaders: {
   109  		FlagHeadersEndStream:  "END_STREAM",
   110  		FlagHeadersEndHeaders: "END_HEADERS",
   111  		FlagHeadersPadded:     "PADDED",
   112  		FlagHeadersPriority:   "PRIORITY",
   113  	},
   114  	FrameSettings: {
   115  		FlagSettingsAck: "ACK",
   116  	},
   117  	FramePing: {
   118  		FlagPingAck: "ACK",
   119  	},
   120  	FrameContinuation: {
   121  		FlagContinuationEndHeaders: "END_HEADERS",
   122  	},
   123  	FramePushPromise: {
   124  		FlagPushPromiseEndHeaders: "END_HEADERS",
   125  		FlagPushPromisePadded:     "PADDED",
   126  	},
   127  }
   128  
   129  // a frameParser parses a frame given its FrameHeader and payload
   130  // bytes. The length of payload will always equal fh.Length (which
   131  // might be 0).
   132  type frameParser func(fc *frameCache, fh FrameHeader, countError func(string), payload []byte) (Frame, error)
   133  
   134  var frameParsers = [...]frameParser{
   135  	FrameData:           parseDataFrame,
   136  	FrameHeaders:        parseHeadersFrame,
   137  	FramePriority:       parsePriorityFrame,
   138  	FrameRSTStream:      parseRSTStreamFrame,
   139  	FrameSettings:       parseSettingsFrame,
   140  	FramePushPromise:    parsePushPromise,
   141  	FramePing:           parsePingFrame,
   142  	FrameGoAway:         parseGoAwayFrame,
   143  	FrameWindowUpdate:   parseWindowUpdateFrame,
   144  	FrameContinuation:   parseContinuationFrame,
   145  	FramePriorityUpdate: parsePriorityUpdateFrame,
   146  }
   147  
   148  func typeFrameParser(t FrameType) frameParser {
   149  	if int(t) < len(frameParsers) {
   150  		if f := frameParsers[t]; f != nil {
   151  			return f
   152  		}
   153  	}
   154  	return parseUnknownFrame
   155  }
   156  
   157  // A FrameHeader is the 9 byte header of all HTTP/2 frames.
   158  //
   159  // See https://httpwg.org/specs/rfc7540.html#FrameHeader
   160  type FrameHeader struct {
   161  	valid bool // caller can access []byte fields in the Frame
   162  
   163  	// Type is the 1 byte frame type. There are ten standard frame
   164  	// types, but extension frame types may be written by WriteRawFrame
   165  	// and will be returned by ReadFrame (as UnknownFrame).
   166  	Type FrameType
   167  
   168  	// Flags are the 1 byte of 8 potential bit flags per frame.
   169  	// They are specific to the frame type.
   170  	Flags Flags
   171  
   172  	// Length is the length of the frame, not including the 9 byte header.
   173  	// The maximum size is one byte less than 16MB (uint24), but only
   174  	// frames up to 16KB are allowed without peer agreement.
   175  	Length uint32
   176  
   177  	// StreamID is which stream this frame is for. Certain frames
   178  	// are not stream-specific, in which case this field is 0.
   179  	StreamID uint32
   180  }
   181  
   182  // Header returns h. It exists so FrameHeaders can be embedded in other
   183  // specific frame types and implement the Frame interface.
   184  func (h FrameHeader) Header() FrameHeader { return h }
   185  
   186  func (h FrameHeader) String() string {
   187  	var buf bytes.Buffer
   188  	buf.WriteString("[FrameHeader ")
   189  	h.writeDebug(&buf)
   190  	buf.WriteByte(']')
   191  	return buf.String()
   192  }
   193  
   194  func (h FrameHeader) writeDebug(buf *bytes.Buffer) {
   195  	buf.WriteString(h.Type.String())
   196  	if h.Flags != 0 {
   197  		buf.WriteString(" flags=")
   198  		set := 0
   199  		for i := range uint8(8) {
   200  			if h.Flags&(1<<i) == 0 {
   201  				continue
   202  			}
   203  			set++
   204  			if set > 1 {
   205  				buf.WriteByte('|')
   206  			}
   207  			name := flagName[h.Type][Flags(1<<i)]
   208  			if name != "" {
   209  				buf.WriteString(name)
   210  			} else {
   211  				fmt.Fprintf(buf, "0x%x", 1<<i)
   212  			}
   213  		}
   214  	}
   215  	if h.StreamID != 0 {
   216  		fmt.Fprintf(buf, " stream=%d", h.StreamID)
   217  	}
   218  	fmt.Fprintf(buf, " len=%d", h.Length)
   219  }
   220  
   221  func (h *FrameHeader) checkValid() {
   222  	if !h.valid {
   223  		panic("Frame accessor called on non-owned Frame")
   224  	}
   225  }
   226  
   227  func (h *FrameHeader) invalidate() { h.valid = false }
   228  
   229  // frame header bytes.
   230  // Used only by ReadFrameHeader.
   231  var fhBytes = sync.Pool{
   232  	New: func() any {
   233  		buf := make([]byte, frameHeaderLen)
   234  		return &buf
   235  	},
   236  }
   237  
   238  func invalidHTTP1LookingFrameHeader() FrameHeader {
   239  	fh, _ := readFrameHeader(make([]byte, frameHeaderLen), strings.NewReader("HTTP/1.1 "))
   240  	return fh
   241  }
   242  
   243  // ReadFrameHeader reads 9 bytes from r and returns a FrameHeader.
   244  // Most users should use Framer.ReadFrame instead.
   245  func ReadFrameHeader(r io.Reader) (FrameHeader, error) {
   246  	bufp := fhBytes.Get().(*[]byte)
   247  	defer fhBytes.Put(bufp)
   248  	return readFrameHeader(*bufp, r)
   249  }
   250  
   251  func readFrameHeader(buf []byte, r io.Reader) (FrameHeader, error) {
   252  	_, err := io.ReadFull(r, buf[:frameHeaderLen])
   253  	if err != nil {
   254  		return FrameHeader{}, err
   255  	}
   256  	return FrameHeader{
   257  		Length:   (uint32(buf[0])<<16 | uint32(buf[1])<<8 | uint32(buf[2])),
   258  		Type:     FrameType(buf[3]),
   259  		Flags:    Flags(buf[4]),
   260  		StreamID: binary.BigEndian.Uint32(buf[5:]) & (1<<31 - 1),
   261  		valid:    true,
   262  	}, nil
   263  }
   264  
   265  // A Frame is the base interface implemented by all frame types.
   266  // Callers will generally type-assert the specific frame type:
   267  // *HeadersFrame, *SettingsFrame, *WindowUpdateFrame, etc.
   268  //
   269  // Frames are only valid until the next call to Framer.ReadFrame.
   270  type Frame interface {
   271  	Header() FrameHeader
   272  
   273  	// invalidate is called by Framer.ReadFrame to make this
   274  	// frame's buffers as being invalid, since the subsequent
   275  	// frame will reuse them.
   276  	invalidate()
   277  }
   278  
   279  // A Framer reads and writes Frames.
   280  type Framer struct {
   281  	r         io.Reader
   282  	lastFrame Frame
   283  	errDetail error
   284  
   285  	// countError is a non-nil func that's called on a frame parse
   286  	// error with some unique error path token. It's initialized
   287  	// from Transport.CountError or Server.CountError.
   288  	countError func(errToken string)
   289  
   290  	// lastHeaderStream is non-zero if the last frame was an
   291  	// unfinished HEADERS/CONTINUATION.
   292  	lastHeaderStream uint32
   293  	// lastFrameType holds the type of the last frame for verifying frame order.
   294  	lastFrameType FrameType
   295  
   296  	maxReadSize uint32
   297  	headerBuf   [frameHeaderLen]byte
   298  
   299  	// TODO: let getReadBuf be configurable, and use a less memory-pinning
   300  	// allocator in server.go to minimize memory pinned for many idle conns.
   301  	// Will probably also need to make frame invalidation have a hook too.
   302  	getReadBuf func(size uint32) []byte
   303  	readBuf    []byte // cache for default getReadBuf
   304  
   305  	maxWriteSize uint32 // zero means unlimited; TODO: implement
   306  
   307  	w    io.Writer
   308  	wbuf []byte
   309  
   310  	// AllowIllegalWrites permits the Framer's Write methods to
   311  	// write frames that do not conform to the HTTP/2 spec. This
   312  	// permits using the Framer to test other HTTP/2
   313  	// implementations' conformance to the spec.
   314  	// If false, the Write methods will prefer to return an error
   315  	// rather than comply.
   316  	AllowIllegalWrites bool
   317  
   318  	// AllowIllegalReads permits the Framer's ReadFrame method
   319  	// to return non-compliant frames or frame orders.
   320  	// This is for testing and permits using the Framer to test
   321  	// other HTTP/2 implementations' conformance to the spec.
   322  	// It is not compatible with ReadMetaHeaders.
   323  	AllowIllegalReads bool
   324  
   325  	// ReadMetaHeaders if non-nil causes ReadFrame to merge
   326  	// HEADERS and CONTINUATION frames together and return
   327  	// MetaHeadersFrame instead.
   328  	ReadMetaHeaders *hpack.Decoder
   329  
   330  	// MaxHeaderListSize is the http2 MAX_HEADER_LIST_SIZE.
   331  	// It's used only if ReadMetaHeaders is set; 0 means a sane default
   332  	// (currently 16MB)
   333  	// If the limit is hit, MetaHeadersFrame.Truncated is set true.
   334  	MaxHeaderListSize uint32
   335  
   336  	// MaxHeaderValueCount is the maximum permitted number of
   337  	// header values.
   338  	// It's used only if ReadMetaHeaders is set; 0 means no limit.
   339  	// If the limit is hit, MetaHeadersFrame.Truncated is set true.
   340  	MaxHeaderValueCount int
   341  
   342  	// TODO: track which type of frame & with which flags was sent
   343  	// last. Then return an error (unless AllowIllegalWrites) if
   344  	// we're in the middle of a header block and a
   345  	// non-Continuation or Continuation on a different stream is
   346  	// attempted to be written.
   347  
   348  	logReads, logWrites bool
   349  
   350  	debugFramer       *Framer // only use for logging written writes
   351  	debugFramerBuf    *bytes.Buffer
   352  	debugReadLoggerf  func(string, ...any)
   353  	debugWriteLoggerf func(string, ...any)
   354  
   355  	frameCache *frameCache // nil if frames aren't reused (default)
   356  }
   357  
   358  func (fr *Framer) maxHeaderListSize() uint32 {
   359  	if fr.MaxHeaderListSize == 0 {
   360  		return 16 << 20 // sane default, per docs
   361  	}
   362  	return fr.MaxHeaderListSize
   363  }
   364  
   365  func (fr *Framer) maxHeaderValueCount() int {
   366  	return fr.MaxHeaderValueCount
   367  }
   368  
   369  func (f *Framer) startWrite(ftype FrameType, flags Flags, streamID uint32) {
   370  	// Write the FrameHeader.
   371  	f.wbuf = append(f.wbuf[:0],
   372  		0, // 3 bytes of length, filled in endWrite
   373  		0,
   374  		0,
   375  		byte(ftype),
   376  		byte(flags),
   377  		byte(streamID>>24),
   378  		byte(streamID>>16),
   379  		byte(streamID>>8),
   380  		byte(streamID))
   381  }
   382  
   383  func (f *Framer) endWrite() error {
   384  	// Now that we know the final size, fill in the FrameHeader in
   385  	// the space previously reserved for it. Abuse append.
   386  	length := len(f.wbuf) - frameHeaderLen
   387  	if length >= (1 << 24) {
   388  		return ErrFrameTooLarge
   389  	}
   390  	_ = append(f.wbuf[:0],
   391  		byte(length>>16),
   392  		byte(length>>8),
   393  		byte(length))
   394  	if f.logWrites {
   395  		f.logWrite()
   396  	}
   397  
   398  	n, err := f.w.Write(f.wbuf)
   399  	if err == nil && n != len(f.wbuf) {
   400  		err = io.ErrShortWrite
   401  	}
   402  	return err
   403  }
   404  
   405  func (f *Framer) logWrite() {
   406  	if f.debugFramer == nil {
   407  		f.debugFramerBuf = new(bytes.Buffer)
   408  		f.debugFramer = NewFramer(nil, f.debugFramerBuf)
   409  		f.debugFramer.logReads = false // we log it ourselves, saying "wrote" below
   410  		// Let us read anything, even if we accidentally wrote it
   411  		// in the wrong order:
   412  		f.debugFramer.AllowIllegalReads = true
   413  	}
   414  	f.debugFramerBuf.Write(f.wbuf)
   415  	fr, err := f.debugFramer.ReadFrame()
   416  	if err != nil {
   417  		f.debugWriteLoggerf("http2: Framer %p: failed to decode just-written frame", f)
   418  		return
   419  	}
   420  	f.debugWriteLoggerf("http2: Framer %p: wrote %v", f, summarizeFrame(fr))
   421  }
   422  
   423  func (f *Framer) writeByte(v byte)     { f.wbuf = append(f.wbuf, v) }
   424  func (f *Framer) writeBytes(v []byte)  { f.wbuf = append(f.wbuf, v...) }
   425  func (f *Framer) writeUint16(v uint16) { f.wbuf = append(f.wbuf, byte(v>>8), byte(v)) }
   426  func (f *Framer) writeUint32(v uint32) {
   427  	f.wbuf = append(f.wbuf, byte(v>>24), byte(v>>16), byte(v>>8), byte(v))
   428  }
   429  
   430  const (
   431  	minMaxFrameSize = 1 << 14
   432  	maxFrameSize    = 1<<24 - 1
   433  )
   434  
   435  // SetReuseFrames allows the Framer to reuse Frames.
   436  // If called on a Framer, Frames returned by calls to ReadFrame are only
   437  // valid until the next call to ReadFrame.
   438  func (fr *Framer) SetReuseFrames() {
   439  	if fr.frameCache != nil {
   440  		return
   441  	}
   442  	fr.frameCache = &frameCache{}
   443  }
   444  
   445  type frameCache struct {
   446  	dataFrame DataFrame
   447  }
   448  
   449  func (fc *frameCache) getDataFrame() *DataFrame {
   450  	if fc == nil {
   451  		return &DataFrame{}
   452  	}
   453  	return &fc.dataFrame
   454  }
   455  
   456  // NewFramer returns a Framer that writes frames to w and reads them from r.
   457  func NewFramer(w io.Writer, r io.Reader) *Framer {
   458  	fr := &Framer{
   459  		w:                 w,
   460  		r:                 r,
   461  		countError:        func(string) {},
   462  		logReads:          logFrameReads,
   463  		logWrites:         logFrameWrites,
   464  		debugReadLoggerf:  log.Printf,
   465  		debugWriteLoggerf: log.Printf,
   466  	}
   467  	fr.getReadBuf = func(size uint32) []byte {
   468  		if cap(fr.readBuf) >= int(size) {
   469  			return fr.readBuf[:size]
   470  		}
   471  		fr.readBuf = make([]byte, size)
   472  		return fr.readBuf
   473  	}
   474  	fr.SetMaxReadFrameSize(maxFrameSize)
   475  	return fr
   476  }
   477  
   478  // SetMaxReadFrameSize sets the maximum size of a frame
   479  // that will be read by a subsequent call to ReadFrame.
   480  // It is the caller's responsibility to advertise this
   481  // limit with a SETTINGS frame.
   482  func (fr *Framer) SetMaxReadFrameSize(v uint32) {
   483  	if v > maxFrameSize {
   484  		v = maxFrameSize
   485  	}
   486  	fr.maxReadSize = v
   487  }
   488  
   489  // ErrorDetail returns a more detailed error of the last error
   490  // returned by Framer.ReadFrame. For instance, if ReadFrame
   491  // returns a StreamError with code PROTOCOL_ERROR, ErrorDetail
   492  // will say exactly what was invalid. ErrorDetail is not guaranteed
   493  // to return a non-nil value and like the rest of the http2 package,
   494  // its return value is not protected by an API compatibility promise.
   495  // ErrorDetail is reset after the next call to ReadFrame.
   496  func (fr *Framer) ErrorDetail() error {
   497  	return fr.errDetail
   498  }
   499  
   500  // ErrFrameTooLarge is returned from Framer.ReadFrame when the peer
   501  // sends a frame that is larger than declared with SetMaxReadFrameSize.
   502  var ErrFrameTooLarge = errors.New("http2: frame too large")
   503  
   504  // terminalReadFrameError reports whether err is an unrecoverable
   505  // error from ReadFrame and no other frames should be read.
   506  func terminalReadFrameError(err error) bool {
   507  	if _, ok := err.(StreamError); ok {
   508  		return false
   509  	}
   510  	return err != nil
   511  }
   512  
   513  // ReadFrameHeader reads the header of the next frame.
   514  // It reads the 9-byte fixed frame header, and does not read any portion of the
   515  // frame payload. The caller is responsible for consuming the payload, either
   516  // with ReadFrameForHeader or directly from the Framer's io.Reader.
   517  //
   518  // If the frame is larger than previously set with SetMaxReadFrameSize, it
   519  // returns the frame header and ErrFrameTooLarge.
   520  //
   521  // If the returned FrameHeader.StreamID is non-zero, it indicates the stream
   522  // responsible for the error.
   523  func (fr *Framer) ReadFrameHeader() (FrameHeader, error) {
   524  	fr.errDetail = nil
   525  	fh, err := readFrameHeader(fr.headerBuf[:], fr.r)
   526  	if err != nil {
   527  		return fh, err
   528  	}
   529  	if fh.Length > fr.maxReadSize {
   530  		if fh == invalidHTTP1LookingFrameHeader() {
   531  			return fh, fmt.Errorf("http2: failed reading the frame payload: %w, note that the frame header looked like an HTTP/1.1 header", ErrFrameTooLarge)
   532  		}
   533  		return fh, ErrFrameTooLarge
   534  	}
   535  	if err := fr.checkFrameOrder(fh); err != nil {
   536  		return fh, err
   537  	}
   538  	return fh, nil
   539  }
   540  
   541  // ReadFrameForHeader reads the payload for the frame with the given FrameHeader.
   542  //
   543  // It behaves identically to ReadFrame, other than not checking the maximum
   544  // frame size.
   545  func (fr *Framer) ReadFrameForHeader(fh FrameHeader) (Frame, error) {
   546  	if fr.lastFrame != nil {
   547  		fr.lastFrame.invalidate()
   548  	}
   549  	payload := fr.getReadBuf(fh.Length)
   550  	if _, err := io.ReadFull(fr.r, payload); err != nil {
   551  		if fh == invalidHTTP1LookingFrameHeader() {
   552  			return nil, fmt.Errorf("http2: failed reading the frame payload: %w, note that the frame header looked like an HTTP/1.1 header", err)
   553  		}
   554  		return nil, err
   555  	}
   556  	f, err := typeFrameParser(fh.Type)(fr.frameCache, fh, fr.countError, payload)
   557  	if err != nil {
   558  		if ce, ok := err.(connError); ok {
   559  			return nil, fr.connError(ce.Code, ce.Reason)
   560  		}
   561  		return nil, err
   562  	}
   563  	fr.lastFrame = f
   564  	if fr.logReads {
   565  		fr.debugReadLoggerf("http2: Framer %p: read %v", fr, summarizeFrame(f))
   566  	}
   567  	if fh.Type == FrameHeaders && fr.ReadMetaHeaders != nil {
   568  		return fr.readMetaFrame(f.(*HeadersFrame))
   569  	}
   570  	return f, nil
   571  }
   572  
   573  // ReadFrame reads a single frame. The returned Frame is only valid
   574  // until the next call to ReadFrame or ReadFrameBodyForHeader.
   575  //
   576  // If the frame is larger than previously set with SetMaxReadFrameSize, the
   577  // returned error is ErrFrameTooLarge. Other errors may be of type
   578  // ConnectionError, StreamError, or anything else from the underlying
   579  // reader.
   580  //
   581  // If ReadFrame returns an error and a non-nil Frame, the Frame's StreamID
   582  // indicates the stream responsible for the error.
   583  func (fr *Framer) ReadFrame() (Frame, error) {
   584  	fh, err := fr.ReadFrameHeader()
   585  	if err != nil {
   586  		return nil, err
   587  	}
   588  	return fr.ReadFrameForHeader(fh)
   589  }
   590  
   591  // connError returns ConnectionError(code) but first
   592  // stashes away a public reason to the caller can optionally relay it
   593  // to the peer before hanging up on them. This might help others debug
   594  // their implementations.
   595  func (fr *Framer) connError(code ErrCode, reason string) error {
   596  	fr.errDetail = errors.New(reason)
   597  	return ConnectionError(code)
   598  }
   599  
   600  // checkFrameOrder reports an error if f is an invalid frame to return
   601  // next from ReadFrame. Mostly it checks whether HEADERS and
   602  // CONTINUATION frames are contiguous.
   603  func (fr *Framer) checkFrameOrder(fh FrameHeader) error {
   604  	lastType := fr.lastFrameType
   605  	fr.lastFrameType = fh.Type
   606  	if fr.AllowIllegalReads {
   607  		return nil
   608  	}
   609  
   610  	if fr.lastHeaderStream != 0 {
   611  		if fh.Type != FrameContinuation {
   612  			return fr.connError(ErrCodeProtocol,
   613  				fmt.Sprintf("got %s for stream %d; expected CONTINUATION following %s for stream %d",
   614  					fh.Type, fh.StreamID,
   615  					lastType, fr.lastHeaderStream))
   616  		}
   617  		if fh.StreamID != fr.lastHeaderStream {
   618  			return fr.connError(ErrCodeProtocol,
   619  				fmt.Sprintf("got CONTINUATION for stream %d; expected stream %d",
   620  					fh.StreamID, fr.lastHeaderStream))
   621  		}
   622  	} else if fh.Type == FrameContinuation {
   623  		return fr.connError(ErrCodeProtocol, fmt.Sprintf("unexpected CONTINUATION for stream %d", fh.StreamID))
   624  	}
   625  
   626  	switch fh.Type {
   627  	case FrameHeaders, FrameContinuation:
   628  		if fh.Flags.Has(FlagHeadersEndHeaders) {
   629  			fr.lastHeaderStream = 0
   630  		} else {
   631  			fr.lastHeaderStream = fh.StreamID
   632  		}
   633  	}
   634  
   635  	return nil
   636  }
   637  
   638  // A DataFrame conveys arbitrary, variable-length sequences of octets
   639  // associated with a stream.
   640  // See https://httpwg.org/specs/rfc7540.html#rfc.section.6.1
   641  type DataFrame struct {
   642  	FrameHeader
   643  	data []byte
   644  }
   645  
   646  func (f *DataFrame) StreamEnded() bool {
   647  	return f.FrameHeader.Flags.Has(FlagDataEndStream)
   648  }
   649  
   650  // Data returns the frame's data octets, not including any padding
   651  // size byte or padding suffix bytes.
   652  // The caller must not retain the returned memory past the next
   653  // call to ReadFrame.
   654  func (f *DataFrame) Data() []byte {
   655  	f.checkValid()
   656  	return f.data
   657  }
   658  
   659  func parseDataFrame(fc *frameCache, fh FrameHeader, countError func(string), payload []byte) (Frame, error) {
   660  	if fh.StreamID == 0 {
   661  		// DATA frames MUST be associated with a stream. If a
   662  		// DATA frame is received whose stream identifier
   663  		// field is 0x0, the recipient MUST respond with a
   664  		// connection error (Section 5.4.1) of type
   665  		// PROTOCOL_ERROR.
   666  		countError("frame_data_stream_0")
   667  		return nil, connError{ErrCodeProtocol, "DATA frame with stream ID 0"}
   668  	}
   669  	f := fc.getDataFrame()
   670  	f.FrameHeader = fh
   671  
   672  	var padSize byte
   673  	if fh.Flags.Has(FlagDataPadded) {
   674  		var err error
   675  		payload, padSize, err = readByte(payload)
   676  		if err != nil {
   677  			countError("frame_data_pad_byte_short")
   678  			return nil, err
   679  		}
   680  	}
   681  	if int(padSize) > len(payload) {
   682  		// If the length of the padding is greater than the
   683  		// length of the frame payload, the recipient MUST
   684  		// treat this as a connection error.
   685  		// Filed: https://github.com/http2/http2-spec/issues/610
   686  		countError("frame_data_pad_too_big")
   687  		return nil, connError{ErrCodeProtocol, "pad size larger than data payload"}
   688  	}
   689  	f.data = payload[:len(payload)-int(padSize)]
   690  	return f, nil
   691  }
   692  
   693  var (
   694  	errStreamID    = errors.New("invalid stream ID")
   695  	errDepStreamID = errors.New("invalid dependent stream ID")
   696  	errPadLength   = errors.New("pad length too large")
   697  	errPadBytes    = errors.New("padding bytes must all be zeros unless AllowIllegalWrites is enabled")
   698  )
   699  
   700  func validStreamIDOrZero(streamID uint32) bool {
   701  	return streamID&(1<<31) == 0
   702  }
   703  
   704  func validStreamID(streamID uint32) bool {
   705  	return streamID != 0 && streamID&(1<<31) == 0
   706  }
   707  
   708  // WriteData writes a DATA frame.
   709  //
   710  // It will perform exactly one Write to the underlying Writer.
   711  // It is the caller's responsibility not to violate the maximum frame size
   712  // and to not call other Write methods concurrently.
   713  func (f *Framer) WriteData(streamID uint32, endStream bool, data []byte) error {
   714  	return f.WriteDataPadded(streamID, endStream, data, nil)
   715  }
   716  
   717  // WriteDataPadded writes a DATA frame with optional padding.
   718  //
   719  // If pad is nil, the padding bit is not sent.
   720  // The length of pad must not exceed 255 bytes.
   721  // The bytes of pad must all be zero, unless f.AllowIllegalWrites is set.
   722  //
   723  // It will perform exactly one Write to the underlying Writer.
   724  // It is the caller's responsibility not to violate the maximum frame size
   725  // and to not call other Write methods concurrently.
   726  func (f *Framer) WriteDataPadded(streamID uint32, endStream bool, data, pad []byte) error {
   727  	if err := f.startWriteDataPadded(streamID, endStream, data, pad); err != nil {
   728  		return err
   729  	}
   730  	return f.endWrite()
   731  }
   732  
   733  // startWriteDataPadded is WriteDataPadded, but only writes the frame to the Framer's internal buffer.
   734  // The caller should call endWrite to flush the frame to the underlying writer.
   735  func (f *Framer) startWriteDataPadded(streamID uint32, endStream bool, data, pad []byte) error {
   736  	if !validStreamID(streamID) && !f.AllowIllegalWrites {
   737  		return errStreamID
   738  	}
   739  	if len(pad) > 0 {
   740  		if len(pad) > 255 {
   741  			return errPadLength
   742  		}
   743  		if !f.AllowIllegalWrites {
   744  			for _, b := range pad {
   745  				if b != 0 {
   746  					// "Padding octets MUST be set to zero when sending."
   747  					return errPadBytes
   748  				}
   749  			}
   750  		}
   751  	}
   752  	var flags Flags
   753  	if endStream {
   754  		flags |= FlagDataEndStream
   755  	}
   756  	if pad != nil {
   757  		flags |= FlagDataPadded
   758  	}
   759  	f.startWrite(FrameData, flags, streamID)
   760  	if pad != nil {
   761  		f.wbuf = append(f.wbuf, byte(len(pad)))
   762  	}
   763  	f.wbuf = append(f.wbuf, data...)
   764  	f.wbuf = append(f.wbuf, pad...)
   765  	return nil
   766  }
   767  
   768  // A SettingsFrame conveys configuration parameters that affect how
   769  // endpoints communicate, such as preferences and constraints on peer
   770  // behavior.
   771  //
   772  // See https://httpwg.org/specs/rfc7540.html#SETTINGS
   773  type SettingsFrame struct {
   774  	FrameHeader
   775  	p []byte
   776  }
   777  
   778  func parseSettingsFrame(_ *frameCache, fh FrameHeader, countError func(string), p []byte) (Frame, error) {
   779  	if fh.Flags.Has(FlagSettingsAck) && fh.Length > 0 {
   780  		// When this (ACK 0x1) bit is set, the payload of the
   781  		// SETTINGS frame MUST be empty. Receipt of a
   782  		// SETTINGS frame with the ACK flag set and a length
   783  		// field value other than 0 MUST be treated as a
   784  		// connection error (Section 5.4.1) of type
   785  		// FRAME_SIZE_ERROR.
   786  		countError("frame_settings_ack_with_length")
   787  		return nil, ConnectionError(ErrCodeFrameSize)
   788  	}
   789  	if fh.StreamID != 0 {
   790  		// SETTINGS frames always apply to a connection,
   791  		// never a single stream. The stream identifier for a
   792  		// SETTINGS frame MUST be zero (0x0).  If an endpoint
   793  		// receives a SETTINGS frame whose stream identifier
   794  		// field is anything other than 0x0, the endpoint MUST
   795  		// respond with a connection error (Section 5.4.1) of
   796  		// type PROTOCOL_ERROR.
   797  		countError("frame_settings_has_stream")
   798  		return nil, ConnectionError(ErrCodeProtocol)
   799  	}
   800  	if len(p)%6 != 0 {
   801  		countError("frame_settings_mod_6")
   802  		// Expecting even number of 6 byte settings.
   803  		return nil, ConnectionError(ErrCodeFrameSize)
   804  	}
   805  	f := &SettingsFrame{FrameHeader: fh, p: p}
   806  	if v, ok := f.Value(SettingInitialWindowSize); ok && v > (1<<31)-1 {
   807  		countError("frame_settings_window_size_too_big")
   808  		// Values above the maximum flow control window size of 2^31 - 1 MUST
   809  		// be treated as a connection error (Section 5.4.1) of type
   810  		// FLOW_CONTROL_ERROR.
   811  		return nil, ConnectionError(ErrCodeFlowControl)
   812  	}
   813  	return f, nil
   814  }
   815  
   816  func (f *SettingsFrame) IsAck() bool {
   817  	return f.FrameHeader.Flags.Has(FlagSettingsAck)
   818  }
   819  
   820  func (f *SettingsFrame) Value(id SettingID) (v uint32, ok bool) {
   821  	f.checkValid()
   822  	for i := 0; i < f.NumSettings(); i++ {
   823  		if s := f.Setting(i); s.ID == id {
   824  			return s.Val, true
   825  		}
   826  	}
   827  	return 0, false
   828  }
   829  
   830  // Setting returns the setting from the frame at the given 0-based index.
   831  // The index must be >= 0 and less than f.NumSettings().
   832  func (f *SettingsFrame) Setting(i int) Setting {
   833  	buf := f.p
   834  	return Setting{
   835  		ID:  SettingID(binary.BigEndian.Uint16(buf[i*6 : i*6+2])),
   836  		Val: binary.BigEndian.Uint32(buf[i*6+2 : i*6+6]),
   837  	}
   838  }
   839  
   840  func (f *SettingsFrame) NumSettings() int { return len(f.p) / 6 }
   841  
   842  // HasDuplicates reports whether f contains any duplicate setting IDs.
   843  func (f *SettingsFrame) HasDuplicates() bool {
   844  	num := f.NumSettings()
   845  	if num == 0 {
   846  		return false
   847  	}
   848  	// If it's small enough (the common case), just do the n^2
   849  	// thing and avoid a map allocation.
   850  	if num < 10 {
   851  		for i := range num {
   852  			idi := f.Setting(i).ID
   853  			for j := i + 1; j < num; j++ {
   854  				idj := f.Setting(j).ID
   855  				if idi == idj {
   856  					return true
   857  				}
   858  			}
   859  		}
   860  		return false
   861  	}
   862  	seen := map[SettingID]bool{}
   863  	for i := range num {
   864  		id := f.Setting(i).ID
   865  		if seen[id] {
   866  			return true
   867  		}
   868  		seen[id] = true
   869  	}
   870  	return false
   871  }
   872  
   873  // ForeachSetting runs fn for each setting.
   874  // It stops and returns the first error.
   875  func (f *SettingsFrame) ForeachSetting(fn func(Setting) error) error {
   876  	f.checkValid()
   877  	for i := 0; i < f.NumSettings(); i++ {
   878  		if err := fn(f.Setting(i)); err != nil {
   879  			return err
   880  		}
   881  	}
   882  	return nil
   883  }
   884  
   885  // WriteSettings writes a SETTINGS frame with zero or more settings
   886  // specified and the ACK bit not set.
   887  //
   888  // It will perform exactly one Write to the underlying Writer.
   889  // It is the caller's responsibility to not call other Write methods concurrently.
   890  func (f *Framer) WriteSettings(settings ...Setting) error {
   891  	f.startWrite(FrameSettings, 0, 0)
   892  	for _, s := range settings {
   893  		f.writeUint16(uint16(s.ID))
   894  		f.writeUint32(s.Val)
   895  	}
   896  	return f.endWrite()
   897  }
   898  
   899  // WriteSettingsAck writes an empty SETTINGS frame with the ACK bit set.
   900  //
   901  // It will perform exactly one Write to the underlying Writer.
   902  // It is the caller's responsibility to not call other Write methods concurrently.
   903  func (f *Framer) WriteSettingsAck() error {
   904  	f.startWrite(FrameSettings, FlagSettingsAck, 0)
   905  	return f.endWrite()
   906  }
   907  
   908  // A PingFrame is a mechanism for measuring a minimal round trip time
   909  // from the sender, as well as determining whether an idle connection
   910  // is still functional.
   911  // See https://httpwg.org/specs/rfc7540.html#rfc.section.6.7
   912  type PingFrame struct {
   913  	FrameHeader
   914  	Data [8]byte
   915  }
   916  
   917  func (f *PingFrame) IsAck() bool { return f.Flags.Has(FlagPingAck) }
   918  
   919  func parsePingFrame(_ *frameCache, fh FrameHeader, countError func(string), payload []byte) (Frame, error) {
   920  	if len(payload) != 8 {
   921  		countError("frame_ping_length")
   922  		return nil, ConnectionError(ErrCodeFrameSize)
   923  	}
   924  	if fh.StreamID != 0 {
   925  		countError("frame_ping_has_stream")
   926  		return nil, ConnectionError(ErrCodeProtocol)
   927  	}
   928  	f := &PingFrame{FrameHeader: fh}
   929  	copy(f.Data[:], payload)
   930  	return f, nil
   931  }
   932  
   933  func (f *Framer) WritePing(ack bool, data [8]byte) error {
   934  	var flags Flags
   935  	if ack {
   936  		flags = FlagPingAck
   937  	}
   938  	f.startWrite(FramePing, flags, 0)
   939  	f.writeBytes(data[:])
   940  	return f.endWrite()
   941  }
   942  
   943  // A GoAwayFrame informs the remote peer to stop creating streams on this connection.
   944  // See https://httpwg.org/specs/rfc7540.html#rfc.section.6.8
   945  type GoAwayFrame struct {
   946  	FrameHeader
   947  	LastStreamID uint32
   948  	ErrCode      ErrCode
   949  	debugData    []byte
   950  }
   951  
   952  // DebugData returns any debug data in the GOAWAY frame. Its contents
   953  // are not defined.
   954  // The caller must not retain the returned memory past the next
   955  // call to ReadFrame.
   956  func (f *GoAwayFrame) DebugData() []byte {
   957  	f.checkValid()
   958  	return f.debugData
   959  }
   960  
   961  func parseGoAwayFrame(_ *frameCache, fh FrameHeader, countError func(string), p []byte) (Frame, error) {
   962  	if fh.StreamID != 0 {
   963  		countError("frame_goaway_has_stream")
   964  		return nil, ConnectionError(ErrCodeProtocol)
   965  	}
   966  	if len(p) < 8 {
   967  		countError("frame_goaway_short")
   968  		return nil, ConnectionError(ErrCodeFrameSize)
   969  	}
   970  	return &GoAwayFrame{
   971  		FrameHeader:  fh,
   972  		LastStreamID: binary.BigEndian.Uint32(p[:4]) & (1<<31 - 1),
   973  		ErrCode:      ErrCode(binary.BigEndian.Uint32(p[4:8])),
   974  		debugData:    p[8:],
   975  	}, nil
   976  }
   977  
   978  func (f *Framer) WriteGoAway(maxStreamID uint32, code ErrCode, debugData []byte) error {
   979  	f.startWrite(FrameGoAway, 0, 0)
   980  	f.writeUint32(maxStreamID & (1<<31 - 1))
   981  	f.writeUint32(uint32(code))
   982  	f.writeBytes(debugData)
   983  	return f.endWrite()
   984  }
   985  
   986  // An UnknownFrame is the frame type returned when the frame type is unknown
   987  // or no specific frame type parser exists.
   988  type UnknownFrame struct {
   989  	FrameHeader
   990  	p []byte
   991  }
   992  
   993  // Payload returns the frame's payload (after the header).  It is not
   994  // valid to call this method after a subsequent call to
   995  // Framer.ReadFrame, nor is it valid to retain the returned slice.
   996  // The memory is owned by the Framer and is invalidated when the next
   997  // frame is read.
   998  func (f *UnknownFrame) Payload() []byte {
   999  	f.checkValid()
  1000  	return f.p
  1001  }
  1002  
  1003  func parseUnknownFrame(_ *frameCache, fh FrameHeader, countError func(string), p []byte) (Frame, error) {
  1004  	return &UnknownFrame{fh, p}, nil
  1005  }
  1006  
  1007  // A WindowUpdateFrame is used to implement flow control.
  1008  // See https://httpwg.org/specs/rfc7540.html#rfc.section.6.9
  1009  type WindowUpdateFrame struct {
  1010  	FrameHeader
  1011  	Increment uint32 // never read with high bit set
  1012  }
  1013  
  1014  func parseWindowUpdateFrame(_ *frameCache, fh FrameHeader, countError func(string), p []byte) (Frame, error) {
  1015  	if len(p) != 4 {
  1016  		countError("frame_windowupdate_bad_len")
  1017  		return nil, ConnectionError(ErrCodeFrameSize)
  1018  	}
  1019  	inc := binary.BigEndian.Uint32(p[:4]) & 0x7fffffff // mask off high reserved bit
  1020  	if inc == 0 {
  1021  		// A receiver MUST treat the receipt of a
  1022  		// WINDOW_UPDATE frame with an flow control window
  1023  		// increment of 0 as a stream error (Section 5.4.2) of
  1024  		// type PROTOCOL_ERROR; errors on the connection flow
  1025  		// control window MUST be treated as a connection
  1026  		// error (Section 5.4.1).
  1027  		if fh.StreamID == 0 {
  1028  			countError("frame_windowupdate_zero_inc_conn")
  1029  			return nil, ConnectionError(ErrCodeProtocol)
  1030  		}
  1031  		countError("frame_windowupdate_zero_inc_stream")
  1032  		return nil, streamError(fh.StreamID, ErrCodeProtocol)
  1033  	}
  1034  	return &WindowUpdateFrame{
  1035  		FrameHeader: fh,
  1036  		Increment:   inc,
  1037  	}, nil
  1038  }
  1039  
  1040  // WriteWindowUpdate writes a WINDOW_UPDATE frame.
  1041  // The increment value must be between 1 and 2,147,483,647, inclusive.
  1042  // If the Stream ID is zero, the window update applies to the
  1043  // connection as a whole.
  1044  func (f *Framer) WriteWindowUpdate(streamID, incr uint32) error {
  1045  	// "The legal range for the increment to the flow control window is 1 to 2^31-1 (2,147,483,647) octets."
  1046  	if (incr < 1 || incr > 2147483647) && !f.AllowIllegalWrites {
  1047  		return errors.New("illegal window increment value")
  1048  	}
  1049  	f.startWrite(FrameWindowUpdate, 0, streamID)
  1050  	f.writeUint32(incr)
  1051  	return f.endWrite()
  1052  }
  1053  
  1054  // A HeadersFrame is used to open a stream and additionally carries a
  1055  // header block fragment.
  1056  type HeadersFrame struct {
  1057  	FrameHeader
  1058  
  1059  	// Priority is set if FlagHeadersPriority is set in the FrameHeader.
  1060  	Priority PriorityParam
  1061  
  1062  	headerFragBuf []byte // not owned
  1063  }
  1064  
  1065  func (f *HeadersFrame) HeaderBlockFragment() []byte {
  1066  	f.checkValid()
  1067  	return f.headerFragBuf
  1068  }
  1069  
  1070  func (f *HeadersFrame) HeadersEnded() bool {
  1071  	return f.FrameHeader.Flags.Has(FlagHeadersEndHeaders)
  1072  }
  1073  
  1074  func (f *HeadersFrame) StreamEnded() bool {
  1075  	return f.FrameHeader.Flags.Has(FlagHeadersEndStream)
  1076  }
  1077  
  1078  func (f *HeadersFrame) HasPriority() bool {
  1079  	return f.FrameHeader.Flags.Has(FlagHeadersPriority)
  1080  }
  1081  
  1082  func parseHeadersFrame(_ *frameCache, fh FrameHeader, countError func(string), p []byte) (_ Frame, err error) {
  1083  	hf := &HeadersFrame{
  1084  		FrameHeader: fh,
  1085  	}
  1086  	if fh.StreamID == 0 {
  1087  		// HEADERS frames MUST be associated with a stream. If a HEADERS frame
  1088  		// is received whose stream identifier field is 0x0, the recipient MUST
  1089  		// respond with a connection error (Section 5.4.1) of type
  1090  		// PROTOCOL_ERROR.
  1091  		countError("frame_headers_zero_stream")
  1092  		return nil, connError{ErrCodeProtocol, "HEADERS frame with stream ID 0"}
  1093  	}
  1094  	var padLength uint8
  1095  	if fh.Flags.Has(FlagHeadersPadded) {
  1096  		if p, padLength, err = readByte(p); err != nil {
  1097  			countError("frame_headers_pad_short")
  1098  			return
  1099  		}
  1100  	}
  1101  	if fh.Flags.Has(FlagHeadersPriority) {
  1102  		var v uint32
  1103  		p, v, err = readUint32(p)
  1104  		if err != nil {
  1105  			countError("frame_headers_prio_short")
  1106  			return nil, err
  1107  		}
  1108  		hf.Priority.StreamDep = v & 0x7fffffff
  1109  		hf.Priority.Exclusive = (v != hf.Priority.StreamDep) // high bit was set
  1110  		p, hf.Priority.Weight, err = readByte(p)
  1111  		if err != nil {
  1112  			countError("frame_headers_prio_weight_short")
  1113  			return nil, err
  1114  		}
  1115  	}
  1116  	if len(p)-int(padLength) < 0 {
  1117  		countError("frame_headers_pad_too_big")
  1118  		return nil, streamError(fh.StreamID, ErrCodeProtocol)
  1119  	}
  1120  	hf.headerFragBuf = p[:len(p)-int(padLength)]
  1121  	return hf, nil
  1122  }
  1123  
  1124  // HeadersFrameParam are the parameters for writing a HEADERS frame.
  1125  type HeadersFrameParam struct {
  1126  	// StreamID is the required Stream ID to initiate.
  1127  	StreamID uint32
  1128  	// BlockFragment is part (or all) of a Header Block.
  1129  	BlockFragment []byte
  1130  
  1131  	// EndStream indicates that the header block is the last that
  1132  	// the endpoint will send for the identified stream. Setting
  1133  	// this flag causes the stream to enter one of "half closed"
  1134  	// states.
  1135  	EndStream bool
  1136  
  1137  	// EndHeaders indicates that this frame contains an entire
  1138  	// header block and is not followed by any
  1139  	// CONTINUATION frames.
  1140  	EndHeaders bool
  1141  
  1142  	// PadLength is the optional number of bytes of zeros to add
  1143  	// to this frame.
  1144  	PadLength uint8
  1145  
  1146  	// Priority, if non-zero, includes stream priority information
  1147  	// in the HEADER frame.
  1148  	Priority PriorityParam
  1149  }
  1150  
  1151  // WriteHeaders writes a single HEADERS frame.
  1152  //
  1153  // This is a low-level header writing method. Encoding headers and
  1154  // splitting them into any necessary CONTINUATION frames is handled
  1155  // elsewhere.
  1156  //
  1157  // It will perform exactly one Write to the underlying Writer.
  1158  // It is the caller's responsibility to not call other Write methods concurrently.
  1159  func (f *Framer) WriteHeaders(p HeadersFrameParam) error {
  1160  	if !validStreamID(p.StreamID) && !f.AllowIllegalWrites {
  1161  		return errStreamID
  1162  	}
  1163  	var flags Flags
  1164  	if p.PadLength != 0 {
  1165  		flags |= FlagHeadersPadded
  1166  	}
  1167  	if p.EndStream {
  1168  		flags |= FlagHeadersEndStream
  1169  	}
  1170  	if p.EndHeaders {
  1171  		flags |= FlagHeadersEndHeaders
  1172  	}
  1173  	if !p.Priority.IsZero() {
  1174  		flags |= FlagHeadersPriority
  1175  	}
  1176  	f.startWrite(FrameHeaders, flags, p.StreamID)
  1177  	if p.PadLength != 0 {
  1178  		f.writeByte(p.PadLength)
  1179  	}
  1180  	if !p.Priority.IsZero() {
  1181  		v := p.Priority.StreamDep
  1182  		if !validStreamIDOrZero(v) && !f.AllowIllegalWrites {
  1183  			return errDepStreamID
  1184  		}
  1185  		if p.Priority.Exclusive {
  1186  			v |= 1 << 31
  1187  		}
  1188  		f.writeUint32(v)
  1189  		f.writeByte(p.Priority.Weight)
  1190  	}
  1191  	f.wbuf = append(f.wbuf, p.BlockFragment...)
  1192  	f.wbuf = append(f.wbuf, padZeros[:p.PadLength]...)
  1193  	return f.endWrite()
  1194  }
  1195  
  1196  // A PriorityFrame specifies the sender-advised priority of a stream.
  1197  // See https://httpwg.org/specs/rfc7540.html#rfc.section.6.3
  1198  type PriorityFrame struct {
  1199  	FrameHeader
  1200  	PriorityParam
  1201  }
  1202  
  1203  // defaultRFC9218Priority determines what priority we should use as the default
  1204  // value.
  1205  //
  1206  // According to RFC 9218, by default, streams should be given an urgency of 3
  1207  // and should be non-incremental. However, making streams non-incremental by
  1208  // default would be a huge change to our historical behavior where we would
  1209  // round-robin writes across streams. When streams are non-incremental, we
  1210  // would process streams of the same urgency one-by-one to completion instead.
  1211  //
  1212  // To avoid such a sudden change which might break some HTTP/2 users, this
  1213  // function allows the caller to specify whether they can actually use the
  1214  // default value as specified in RFC 9218. If not, this function will return a
  1215  // priority value where streams are incremental by default instead: effectively
  1216  // a round-robin between stream of the same urgency.
  1217  //
  1218  // As an example, a server might not be able to use the RFC 9218 default value
  1219  // when it's not sure that the client it is serving is aware of RFC 9218.
  1220  func defaultRFC9218Priority(canUseDefault bool) PriorityParam {
  1221  	if canUseDefault {
  1222  		return PriorityParam{
  1223  			urgency:     3,
  1224  			incremental: 0,
  1225  		}
  1226  	}
  1227  	return PriorityParam{
  1228  		urgency:     3,
  1229  		incremental: 1,
  1230  	}
  1231  }
  1232  
  1233  // Note that HTTP/2 has had two different prioritization schemes, and
  1234  // PriorityParam struct below is a superset of both schemes. The exported
  1235  // symbols are from RFC 7540 and the non-exported ones are from RFC 9218.
  1236  
  1237  // PriorityParam are the stream prioritization parameters.
  1238  type PriorityParam struct {
  1239  	// StreamDep is a 31-bit stream identifier for the
  1240  	// stream that this stream depends on. Zero means no
  1241  	// dependency.
  1242  	StreamDep uint32
  1243  
  1244  	// Exclusive is whether the dependency is exclusive.
  1245  	Exclusive bool
  1246  
  1247  	// Weight is the stream's zero-indexed weight. It should be
  1248  	// set together with StreamDep, or neither should be set. Per
  1249  	// the spec, "Add one to the value to obtain a weight between
  1250  	// 1 and 256."
  1251  	Weight uint8
  1252  
  1253  	// "The urgency (u) parameter value is Integer (see Section 3.3.1 of
  1254  	// [STRUCTURED-FIELDS]), between 0 and 7 inclusive, in descending order of
  1255  	// priority. The default is 3."
  1256  	urgency uint8
  1257  
  1258  	// "The incremental (i) parameter value is Boolean (see Section 3.3.6 of
  1259  	// [STRUCTURED-FIELDS]). It indicates if an HTTP response can be processed
  1260  	// incrementally, i.e., provide some meaningful output as chunks of the
  1261  	// response arrive."
  1262  	//
  1263  	// We use uint8 (i.e. 0 is false, 1 is true) instead of bool so we can
  1264  	// avoid unnecessary type conversions and because either type takes 1 byte.
  1265  	incremental uint8
  1266  }
  1267  
  1268  func (p PriorityParam) IsZero() bool {
  1269  	return p == PriorityParam{}
  1270  }
  1271  
  1272  func parsePriorityFrame(_ *frameCache, fh FrameHeader, countError func(string), payload []byte) (Frame, error) {
  1273  	if fh.StreamID == 0 {
  1274  		countError("frame_priority_zero_stream")
  1275  		return nil, connError{ErrCodeProtocol, "PRIORITY frame with stream ID 0"}
  1276  	}
  1277  	if len(payload) != 5 {
  1278  		countError("frame_priority_bad_length")
  1279  		return nil, connError{ErrCodeFrameSize, fmt.Sprintf("PRIORITY frame payload size was %d; want 5", len(payload))}
  1280  	}
  1281  	v := binary.BigEndian.Uint32(payload[:4])
  1282  	streamID := v & 0x7fffffff // mask off high bit
  1283  	return &PriorityFrame{
  1284  		FrameHeader: fh,
  1285  		PriorityParam: PriorityParam{
  1286  			Weight:    payload[4],
  1287  			StreamDep: streamID,
  1288  			Exclusive: streamID != v, // was high bit set?
  1289  		},
  1290  	}, nil
  1291  }
  1292  
  1293  // WritePriority writes a PRIORITY frame.
  1294  //
  1295  // It will perform exactly one Write to the underlying Writer.
  1296  // It is the caller's responsibility to not call other Write methods concurrently.
  1297  func (f *Framer) WritePriority(streamID uint32, p PriorityParam) error {
  1298  	if !validStreamID(streamID) && !f.AllowIllegalWrites {
  1299  		return errStreamID
  1300  	}
  1301  	if !validStreamIDOrZero(p.StreamDep) {
  1302  		return errDepStreamID
  1303  	}
  1304  	f.startWrite(FramePriority, 0, streamID)
  1305  	v := p.StreamDep
  1306  	if p.Exclusive {
  1307  		v |= 1 << 31
  1308  	}
  1309  	f.writeUint32(v)
  1310  	f.writeByte(p.Weight)
  1311  	return f.endWrite()
  1312  }
  1313  
  1314  // PriorityUpdateFrame is a PRIORITY_UPDATE frame as described in
  1315  // https://www.rfc-editor.org/rfc/rfc9218.html#name-the-priority_update-frame.
  1316  type PriorityUpdateFrame struct {
  1317  	FrameHeader
  1318  	Priority            string
  1319  	PrioritizedStreamID uint32
  1320  }
  1321  
  1322  func parseRFC9218Priority(s string, canUseDefault bool) (p PriorityParam, ok bool) {
  1323  	p = defaultRFC9218Priority(canUseDefault)
  1324  	ok = httpsfv.ParseDictionary(s, func(key, val, _ string) {
  1325  		switch key {
  1326  		case "u":
  1327  			if u, ok := httpsfv.ParseInteger(val); ok && u >= 0 && u <= 7 {
  1328  				p.urgency = uint8(u)
  1329  			}
  1330  		case "i":
  1331  			if i, ok := httpsfv.ParseBoolean(val); ok {
  1332  				if i {
  1333  					p.incremental = 1
  1334  				} else {
  1335  					p.incremental = 0
  1336  				}
  1337  			}
  1338  		}
  1339  	})
  1340  	if !ok {
  1341  		return defaultRFC9218Priority(canUseDefault), ok
  1342  	}
  1343  	return p, true
  1344  }
  1345  
  1346  func parsePriorityUpdateFrame(_ *frameCache, fh FrameHeader, countError func(string), payload []byte) (Frame, error) {
  1347  	if fh.StreamID != 0 {
  1348  		countError("frame_priority_update_non_zero_stream")
  1349  		return nil, connError{ErrCodeProtocol, "PRIORITY_UPDATE frame with non-zero stream ID"}
  1350  	}
  1351  	if len(payload) < 4 {
  1352  		countError("frame_priority_update_bad_length")
  1353  		return nil, connError{ErrCodeFrameSize, fmt.Sprintf("PRIORITY_UPDATE frame payload size was %d; want at least 4", len(payload))}
  1354  	}
  1355  	v := binary.BigEndian.Uint32(payload[:4])
  1356  	streamID := v & 0x7fffffff // mask off high bit
  1357  	if streamID == 0 {
  1358  		countError("frame_priority_update_prioritizing_zero_stream")
  1359  		return nil, connError{ErrCodeProtocol, "PRIORITY_UPDATE frame with prioritized stream ID of zero"}
  1360  	}
  1361  	return &PriorityUpdateFrame{
  1362  		FrameHeader:         fh,
  1363  		PrioritizedStreamID: streamID,
  1364  		Priority:            string(payload[4:]),
  1365  	}, nil
  1366  }
  1367  
  1368  // WritePriorityUpdate writes a PRIORITY_UPDATE frame.
  1369  //
  1370  // It will perform exactly one Write to the underlying Writer.
  1371  // It is the caller's responsibility to not call other Write methods concurrently.
  1372  func (f *Framer) WritePriorityUpdate(streamID uint32, priority string) error {
  1373  	if !validStreamID(streamID) && !f.AllowIllegalWrites {
  1374  		return errStreamID
  1375  	}
  1376  	f.startWrite(FramePriorityUpdate, 0, 0)
  1377  	f.writeUint32(streamID)
  1378  	f.writeBytes([]byte(priority))
  1379  	return f.endWrite()
  1380  }
  1381  
  1382  // A RSTStreamFrame allows for abnormal termination of a stream.
  1383  // See https://httpwg.org/specs/rfc7540.html#rfc.section.6.4
  1384  type RSTStreamFrame struct {
  1385  	FrameHeader
  1386  	ErrCode ErrCode
  1387  }
  1388  
  1389  func parseRSTStreamFrame(_ *frameCache, fh FrameHeader, countError func(string), p []byte) (Frame, error) {
  1390  	if len(p) != 4 {
  1391  		countError("frame_rststream_bad_len")
  1392  		return nil, ConnectionError(ErrCodeFrameSize)
  1393  	}
  1394  	if fh.StreamID == 0 {
  1395  		countError("frame_rststream_zero_stream")
  1396  		return nil, ConnectionError(ErrCodeProtocol)
  1397  	}
  1398  	return &RSTStreamFrame{fh, ErrCode(binary.BigEndian.Uint32(p[:4]))}, nil
  1399  }
  1400  
  1401  // WriteRSTStream writes a RST_STREAM frame.
  1402  //
  1403  // It will perform exactly one Write to the underlying Writer.
  1404  // It is the caller's responsibility to not call other Write methods concurrently.
  1405  func (f *Framer) WriteRSTStream(streamID uint32, code ErrCode) error {
  1406  	if !validStreamID(streamID) && !f.AllowIllegalWrites {
  1407  		return errStreamID
  1408  	}
  1409  	f.startWrite(FrameRSTStream, 0, streamID)
  1410  	f.writeUint32(uint32(code))
  1411  	return f.endWrite()
  1412  }
  1413  
  1414  // A ContinuationFrame is used to continue a sequence of header block fragments.
  1415  // See https://httpwg.org/specs/rfc7540.html#rfc.section.6.10
  1416  type ContinuationFrame struct {
  1417  	FrameHeader
  1418  	headerFragBuf []byte
  1419  }
  1420  
  1421  func parseContinuationFrame(_ *frameCache, fh FrameHeader, countError func(string), p []byte) (Frame, error) {
  1422  	if fh.StreamID == 0 {
  1423  		countError("frame_continuation_zero_stream")
  1424  		return nil, connError{ErrCodeProtocol, "CONTINUATION frame with stream ID 0"}
  1425  	}
  1426  	return &ContinuationFrame{fh, p}, nil
  1427  }
  1428  
  1429  func (f *ContinuationFrame) HeaderBlockFragment() []byte {
  1430  	f.checkValid()
  1431  	return f.headerFragBuf
  1432  }
  1433  
  1434  func (f *ContinuationFrame) HeadersEnded() bool {
  1435  	return f.FrameHeader.Flags.Has(FlagContinuationEndHeaders)
  1436  }
  1437  
  1438  // WriteContinuation writes a CONTINUATION frame.
  1439  //
  1440  // It will perform exactly one Write to the underlying Writer.
  1441  // It is the caller's responsibility to not call other Write methods concurrently.
  1442  func (f *Framer) WriteContinuation(streamID uint32, endHeaders bool, headerBlockFragment []byte) error {
  1443  	if !validStreamID(streamID) && !f.AllowIllegalWrites {
  1444  		return errStreamID
  1445  	}
  1446  	var flags Flags
  1447  	if endHeaders {
  1448  		flags |= FlagContinuationEndHeaders
  1449  	}
  1450  	f.startWrite(FrameContinuation, flags, streamID)
  1451  	f.wbuf = append(f.wbuf, headerBlockFragment...)
  1452  	return f.endWrite()
  1453  }
  1454  
  1455  // A PushPromiseFrame is used to initiate a server stream.
  1456  // See https://httpwg.org/specs/rfc7540.html#rfc.section.6.6
  1457  type PushPromiseFrame struct {
  1458  	FrameHeader
  1459  	PromiseID     uint32
  1460  	headerFragBuf []byte // not owned
  1461  }
  1462  
  1463  func (f *PushPromiseFrame) HeaderBlockFragment() []byte {
  1464  	f.checkValid()
  1465  	return f.headerFragBuf
  1466  }
  1467  
  1468  func (f *PushPromiseFrame) HeadersEnded() bool {
  1469  	return f.FrameHeader.Flags.Has(FlagPushPromiseEndHeaders)
  1470  }
  1471  
  1472  func parsePushPromise(_ *frameCache, fh FrameHeader, countError func(string), p []byte) (_ Frame, err error) {
  1473  	pp := &PushPromiseFrame{
  1474  		FrameHeader: fh,
  1475  	}
  1476  	if pp.StreamID == 0 {
  1477  		// PUSH_PROMISE frames MUST be associated with an existing,
  1478  		// peer-initiated stream. The stream identifier of a
  1479  		// PUSH_PROMISE frame indicates the stream it is associated
  1480  		// with. If the stream identifier field specifies the value
  1481  		// 0x0, a recipient MUST respond with a connection error
  1482  		// (Section 5.4.1) of type PROTOCOL_ERROR.
  1483  		countError("frame_pushpromise_zero_stream")
  1484  		return nil, ConnectionError(ErrCodeProtocol)
  1485  	}
  1486  	// The PUSH_PROMISE frame includes optional padding.
  1487  	// Padding fields and flags are identical to those defined for DATA frames
  1488  	var padLength uint8
  1489  	if fh.Flags.Has(FlagPushPromisePadded) {
  1490  		if p, padLength, err = readByte(p); err != nil {
  1491  			countError("frame_pushpromise_pad_short")
  1492  			return
  1493  		}
  1494  	}
  1495  
  1496  	p, pp.PromiseID, err = readUint32(p)
  1497  	if err != nil {
  1498  		countError("frame_pushpromise_promiseid_short")
  1499  		return
  1500  	}
  1501  	pp.PromiseID = pp.PromiseID & (1<<31 - 1)
  1502  
  1503  	if int(padLength) > len(p) {
  1504  		// like the DATA frame, error out if padding is longer than the body.
  1505  		countError("frame_pushpromise_pad_too_big")
  1506  		return nil, ConnectionError(ErrCodeProtocol)
  1507  	}
  1508  	pp.headerFragBuf = p[:len(p)-int(padLength)]
  1509  	return pp, nil
  1510  }
  1511  
  1512  // PushPromiseParam are the parameters for writing a PUSH_PROMISE frame.
  1513  type PushPromiseParam struct {
  1514  	// StreamID is the required Stream ID to initiate.
  1515  	StreamID uint32
  1516  
  1517  	// PromiseID is the required Stream ID which this
  1518  	// Push Promises
  1519  	PromiseID uint32
  1520  
  1521  	// BlockFragment is part (or all) of a Header Block.
  1522  	BlockFragment []byte
  1523  
  1524  	// EndHeaders indicates that this frame contains an entire
  1525  	// header block and is not followed by any
  1526  	// CONTINUATION frames.
  1527  	EndHeaders bool
  1528  
  1529  	// PadLength is the optional number of bytes of zeros to add
  1530  	// to this frame.
  1531  	PadLength uint8
  1532  }
  1533  
  1534  // WritePushPromise writes a single PushPromise Frame.
  1535  //
  1536  // As with Header Frames, This is the low level call for writing
  1537  // individual frames. Continuation frames are handled elsewhere.
  1538  //
  1539  // It will perform exactly one Write to the underlying Writer.
  1540  // It is the caller's responsibility to not call other Write methods concurrently.
  1541  func (f *Framer) WritePushPromise(p PushPromiseParam) error {
  1542  	if !validStreamID(p.StreamID) && !f.AllowIllegalWrites {
  1543  		return errStreamID
  1544  	}
  1545  	var flags Flags
  1546  	if p.PadLength != 0 {
  1547  		flags |= FlagPushPromisePadded
  1548  	}
  1549  	if p.EndHeaders {
  1550  		flags |= FlagPushPromiseEndHeaders
  1551  	}
  1552  	f.startWrite(FramePushPromise, flags, p.StreamID)
  1553  	if p.PadLength != 0 {
  1554  		f.writeByte(p.PadLength)
  1555  	}
  1556  	if !validStreamID(p.PromiseID) && !f.AllowIllegalWrites {
  1557  		return errStreamID
  1558  	}
  1559  	f.writeUint32(p.PromiseID)
  1560  	f.wbuf = append(f.wbuf, p.BlockFragment...)
  1561  	f.wbuf = append(f.wbuf, padZeros[:p.PadLength]...)
  1562  	return f.endWrite()
  1563  }
  1564  
  1565  // WriteRawFrame writes a raw frame. This can be used to write
  1566  // extension frames unknown to this package.
  1567  func (f *Framer) WriteRawFrame(t FrameType, flags Flags, streamID uint32, payload []byte) error {
  1568  	f.startWrite(t, flags, streamID)
  1569  	f.writeBytes(payload)
  1570  	return f.endWrite()
  1571  }
  1572  
  1573  func readByte(p []byte) (remain []byte, b byte, err error) {
  1574  	if len(p) == 0 {
  1575  		return nil, 0, io.ErrUnexpectedEOF
  1576  	}
  1577  	return p[1:], p[0], nil
  1578  }
  1579  
  1580  func readUint32(p []byte) (remain []byte, v uint32, err error) {
  1581  	if len(p) < 4 {
  1582  		return nil, 0, io.ErrUnexpectedEOF
  1583  	}
  1584  	return p[4:], binary.BigEndian.Uint32(p[:4]), nil
  1585  }
  1586  
  1587  type streamEnder interface {
  1588  	StreamEnded() bool
  1589  }
  1590  
  1591  type headersEnder interface {
  1592  	HeadersEnded() bool
  1593  }
  1594  
  1595  type headersOrContinuation interface {
  1596  	headersEnder
  1597  	HeaderBlockFragment() []byte
  1598  }
  1599  
  1600  // A MetaHeadersFrame is the representation of one HEADERS frame and
  1601  // zero or more contiguous CONTINUATION frames and the decoding of
  1602  // their HPACK-encoded contents.
  1603  //
  1604  // This type of frame does not appear on the wire and is only returned
  1605  // by the Framer when Framer.ReadMetaHeaders is set.
  1606  type MetaHeadersFrame struct {
  1607  	*HeadersFrame
  1608  
  1609  	// Fields are the fields contained in the HEADERS and
  1610  	// CONTINUATION frames. The underlying slice is owned by the
  1611  	// Framer and must not be retained after the next call to
  1612  	// ReadFrame.
  1613  	//
  1614  	// Fields are guaranteed to be in the correct http2 order and
  1615  	// not have unknown pseudo header fields or invalid header
  1616  	// field names or values. Required pseudo header fields may be
  1617  	// missing, however. Use the MetaHeadersFrame.Pseudo accessor
  1618  	// method access pseudo headers.
  1619  	Fields []hpack.HeaderField
  1620  
  1621  	// Truncated is whether the max header list size limit was hit
  1622  	// and Fields is incomplete. The hpack decoder state is still
  1623  	// valid, however.
  1624  	Truncated bool
  1625  }
  1626  
  1627  // PseudoValue returns the given pseudo header field's value.
  1628  // The provided pseudo field should not contain the leading colon.
  1629  func (mh *MetaHeadersFrame) PseudoValue(pseudo string) string {
  1630  	for _, hf := range mh.Fields {
  1631  		if !hf.IsPseudo() {
  1632  			return ""
  1633  		}
  1634  		if hf.Name[1:] == pseudo {
  1635  			return hf.Value
  1636  		}
  1637  	}
  1638  	return ""
  1639  }
  1640  
  1641  // RegularFields returns the regular (non-pseudo) header fields of mh.
  1642  // The caller does not own the returned slice.
  1643  func (mh *MetaHeadersFrame) RegularFields() []hpack.HeaderField {
  1644  	for i, hf := range mh.Fields {
  1645  		if !hf.IsPseudo() {
  1646  			return mh.Fields[i:]
  1647  		}
  1648  	}
  1649  	return nil
  1650  }
  1651  
  1652  // PseudoFields returns the pseudo header fields of mh.
  1653  // The caller does not own the returned slice.
  1654  func (mh *MetaHeadersFrame) PseudoFields() []hpack.HeaderField {
  1655  	for i, hf := range mh.Fields {
  1656  		if !hf.IsPseudo() {
  1657  			return mh.Fields[:i]
  1658  		}
  1659  	}
  1660  	return mh.Fields
  1661  }
  1662  
  1663  func (mh *MetaHeadersFrame) rfc9218Priority(priorityAware bool) (p PriorityParam, priorityAwareAfter, hasIntermediary bool) {
  1664  	var s string
  1665  	for _, field := range mh.Fields {
  1666  		if field.Name == "priority" {
  1667  			s = field.Value
  1668  			priorityAware = true
  1669  		}
  1670  		if slices.Contains([]string{"via", "forwarded", "x-forwarded-for"}, field.Name) {
  1671  			hasIntermediary = true
  1672  		}
  1673  	}
  1674  	// No need to check for ok. parseRFC9218Priority will return a default
  1675  	// value if there is no priority field or if the field cannot be parsed.
  1676  	p, _ = parseRFC9218Priority(s, priorityAware && !hasIntermediary)
  1677  	return p, priorityAware, hasIntermediary
  1678  }
  1679  
  1680  func (mh *MetaHeadersFrame) checkPseudos() error {
  1681  	var isRequest, isResponse bool
  1682  	pf := mh.PseudoFields()
  1683  	for i, hf := range pf {
  1684  		switch hf.Name {
  1685  		case ":method", ":path", ":scheme", ":authority", ":protocol":
  1686  			isRequest = true
  1687  		case ":status":
  1688  			isResponse = true
  1689  		default:
  1690  			return pseudoHeaderError(hf.Name)
  1691  		}
  1692  		// Check for duplicates.
  1693  		// This would be a bad algorithm, but N is 5.
  1694  		// And this doesn't allocate.
  1695  		for _, hf2 := range pf[:i] {
  1696  			if hf.Name == hf2.Name {
  1697  				return duplicatePseudoHeaderError(hf.Name)
  1698  			}
  1699  		}
  1700  	}
  1701  	if isRequest && isResponse {
  1702  		return errMixPseudoHeaderTypes
  1703  	}
  1704  	return nil
  1705  }
  1706  
  1707  func (fr *Framer) maxHeaderStringLen() int {
  1708  	v := int(fr.maxHeaderListSize())
  1709  	if v < 0 {
  1710  		// If maxHeaderListSize overflows an int, use no limit (0).
  1711  		return 0
  1712  	}
  1713  	return v
  1714  }
  1715  
  1716  // readMetaFrame returns 0 or more CONTINUATION frames from fr and
  1717  // merge them into the provided hf and returns a MetaHeadersFrame
  1718  // with the decoded hpack values.
  1719  func (fr *Framer) readMetaFrame(hf *HeadersFrame) (Frame, error) {
  1720  	if fr.AllowIllegalReads {
  1721  		return nil, errors.New("illegal use of AllowIllegalReads with ReadMetaHeaders")
  1722  	}
  1723  	mh := &MetaHeadersFrame{
  1724  		HeadersFrame: hf,
  1725  	}
  1726  	var remainSize = fr.maxHeaderListSize()
  1727  	var sawRegular bool
  1728  	var headerCount int
  1729  
  1730  	var invalid error // pseudo header field errors
  1731  	hdec := fr.ReadMetaHeaders
  1732  	hdec.SetEmitEnabled(true)
  1733  	hdec.SetMaxStringLength(fr.maxHeaderStringLen())
  1734  	hdec.SetEmitFunc(func(hf hpack.HeaderField) {
  1735  		if VerboseLogs && fr.logReads {
  1736  			fr.debugReadLoggerf("http2: decoded hpack field %+v", hf)
  1737  		}
  1738  		headerCount++
  1739  		if limit := fr.maxHeaderValueCount(); limit > 0 && headerCount > limit {
  1740  			hdec.SetEmitEnabled(false)
  1741  			mh.Truncated = true
  1742  			remainSize = 0
  1743  			return
  1744  		}
  1745  		if !httpguts.ValidHeaderFieldValue(hf.Value) {
  1746  			// Don't include the value in the error, because it may be sensitive.
  1747  			invalid = headerFieldValueError(hf.Name)
  1748  		}
  1749  		isPseudo := strings.HasPrefix(hf.Name, ":")
  1750  		if isPseudo {
  1751  			if sawRegular {
  1752  				invalid = errPseudoAfterRegular
  1753  			}
  1754  		} else {
  1755  			sawRegular = true
  1756  			if !validWireHeaderFieldName(hf.Name) {
  1757  				invalid = headerFieldNameError(hf.Name)
  1758  			}
  1759  		}
  1760  
  1761  		if invalid != nil {
  1762  			hdec.SetEmitEnabled(false)
  1763  			return
  1764  		}
  1765  
  1766  		size := hf.Size()
  1767  		if size > remainSize {
  1768  			hdec.SetEmitEnabled(false)
  1769  			mh.Truncated = true
  1770  			remainSize = 0
  1771  			return
  1772  		}
  1773  		remainSize -= size
  1774  
  1775  		mh.Fields = append(mh.Fields, hf)
  1776  	})
  1777  	// Lose reference to MetaHeadersFrame:
  1778  	defer hdec.SetEmitFunc(func(hf hpack.HeaderField) {})
  1779  
  1780  	var hc headersOrContinuation = hf
  1781  	for {
  1782  		frag := hc.HeaderBlockFragment()
  1783  
  1784  		// Avoid parsing large amounts of headers that we will then discard.
  1785  		// If the sender exceeds the max header list size by too much,
  1786  		// skip parsing the fragment and close the connection.
  1787  		//
  1788  		// "Too much" is either any CONTINUATION frame after we've already
  1789  		// exceeded the max header list size (in which case remainSize is 0),
  1790  		// or a frame whose encoded size is more than twice the remaining
  1791  		// header list bytes we're willing to accept.
  1792  		if int64(len(frag)) > int64(2*remainSize) {
  1793  			if VerboseLogs {
  1794  				log.Printf("http2: header list too large")
  1795  			}
  1796  			// It would be nice to send a RST_STREAM before sending the GOAWAY,
  1797  			// but the structure of the server's frame writer makes this difficult.
  1798  			return mh, ConnectionError(ErrCodeProtocol)
  1799  		}
  1800  
  1801  		// Also close the connection after any CONTINUATION frame following an
  1802  		// invalid header, since we stop tracking the size of the headers after
  1803  		// an invalid one.
  1804  		if invalid != nil {
  1805  			if VerboseLogs {
  1806  				log.Printf("http2: invalid header: %v", invalid)
  1807  			}
  1808  			// It would be nice to send a RST_STREAM before sending the GOAWAY,
  1809  			// but the structure of the server's frame writer makes this difficult.
  1810  			return mh, ConnectionError(ErrCodeProtocol)
  1811  		}
  1812  
  1813  		if _, err := hdec.Write(frag); err != nil {
  1814  			return mh, ConnectionError(ErrCodeCompression)
  1815  		}
  1816  
  1817  		if hc.HeadersEnded() {
  1818  			break
  1819  		}
  1820  		if f, err := fr.ReadFrame(); err != nil {
  1821  			return nil, err
  1822  		} else {
  1823  			hc = f.(*ContinuationFrame) // guaranteed by checkFrameOrder
  1824  		}
  1825  	}
  1826  
  1827  	mh.HeadersFrame.headerFragBuf = nil
  1828  	mh.HeadersFrame.invalidate()
  1829  
  1830  	if err := hdec.Close(); err != nil {
  1831  		return mh, ConnectionError(ErrCodeCompression)
  1832  	}
  1833  	if invalid != nil {
  1834  		fr.errDetail = invalid
  1835  		if VerboseLogs {
  1836  			log.Printf("http2: invalid header: %v", invalid)
  1837  		}
  1838  		return nil, StreamError{mh.StreamID, ErrCodeProtocol, invalid}
  1839  	}
  1840  	if err := mh.checkPseudos(); err != nil {
  1841  		fr.errDetail = err
  1842  		if VerboseLogs {
  1843  			log.Printf("http2: invalid pseudo headers: %v", err)
  1844  		}
  1845  		return nil, StreamError{mh.StreamID, ErrCodeProtocol, err}
  1846  	}
  1847  	return mh, nil
  1848  }
  1849  
  1850  func summarizeFrame(f Frame) string {
  1851  	var buf bytes.Buffer
  1852  	f.Header().writeDebug(&buf)
  1853  	switch f := f.(type) {
  1854  	case *SettingsFrame:
  1855  		n := 0
  1856  		f.ForeachSetting(func(s Setting) error {
  1857  			n++
  1858  			if n == 1 {
  1859  				buf.WriteString(", settings:")
  1860  			}
  1861  			fmt.Fprintf(&buf, " %v=%v,", s.ID, s.Val)
  1862  			return nil
  1863  		})
  1864  		if n > 0 {
  1865  			buf.Truncate(buf.Len() - 1) // remove trailing comma
  1866  		}
  1867  	case *DataFrame:
  1868  		data := f.Data()
  1869  		const max = 256
  1870  		if len(data) > max {
  1871  			data = data[:max]
  1872  		}
  1873  		fmt.Fprintf(&buf, " data=%q", data)
  1874  		if len(f.Data()) > max {
  1875  			fmt.Fprintf(&buf, " (%d bytes omitted)", len(f.Data())-max)
  1876  		}
  1877  	case *WindowUpdateFrame:
  1878  		if f.StreamID == 0 {
  1879  			buf.WriteString(" (conn)")
  1880  		}
  1881  		fmt.Fprintf(&buf, " incr=%v", f.Increment)
  1882  	case *PingFrame:
  1883  		fmt.Fprintf(&buf, " ping=%q", f.Data[:])
  1884  	case *GoAwayFrame:
  1885  		fmt.Fprintf(&buf, " LastStreamID=%v ErrCode=%v Debug=%q",
  1886  			f.LastStreamID, f.ErrCode, f.debugData)
  1887  	case *RSTStreamFrame:
  1888  		fmt.Fprintf(&buf, " ErrCode=%v", f.ErrCode)
  1889  	}
  1890  	return buf.String()
  1891  }
  1892  

View as plain text