HTTP2 协议解析

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

type FrameType uint8

const (
    FrameData         FrameType = 0x0
    FrameHeaders      FrameType = 0x1
    FramePriority     FrameType = 0x2
    FrameRSTStream    FrameType = 0x3
    FrameSettings     FrameType = 0x4
    FramePushPromise  FrameType = 0x5
    FramePing         FrameType = 0x6
    FrameGoAway       FrameType = 0x7
    FrameWindowUpdate FrameType = 0x8
    FrameContinuation FrameType = 0x9
)

type Flags uint8

func (f Flags) Has(v Flags) bool {
    return (f & v) == v
}

const (
    // Data Frame
    FlagDataEndStream Flags = 0x1
    FlagDataPadded    Flags = 0x8

    // Headers Frame
    FlagHeadersEndStream  Flags = 0x1
    FlagHeadersEndHeaders Flags = 0x4
    FlagHeadersPadded     Flags = 0x8
    FlagHeadersPriority   Flags = 0x20

    // Settings Frame
    FlagSettingsAck Flags = 0x1

    // Ping Frame
    FlagPingAck Flags = 0x1

    // Continuation Frame
    FlagContinuationEndHeaders Flags = 0x4

    FlagPushPromiseEndHeaders Flags = 0x4
    FlagPushPromisePadded     Flags = 0x8
)

// or (1<<31) - 1
const PadBit uint32 = 0x7fffffff

1
2
3
4
5
6
7
8
9

 +-----------------------------------------------+
 |                 Length (24)                   |
 +---------------+---------------+---------------+
 |   Type (8)    |   Flags (8)   |
 +-+-------------+---------------+-------------------------------+
 |R|                 Stream Identifier (31)                      |
 +=+=============================================================+
 |                   Frame Payload (0...)                      ...
 +---------------------------------------------------------------+

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

const (
    frameHeaderLen = 9
)
type FrameHeader struct {
    valid bool // caller can access []byte fields in the Frame

    // Type is the 1 byte frame type. There are ten standard frame
    // types, but extension frame types may be written by WriteRawFrame
    // and will be returned by ReadFrame (as UnknownFrame).
    Type FrameType

    // Flags are the 1 byte of 8 potential bit flags per frame.
    // They are specific to the frame type.
    Flags Flags

    // Length is the length of the frame, not including the 9 byte header.
    // The maximum size is one byte less than 16MB (uint24), but only
    // frames up to 16KB are allowed without peer agreement.
    Length uint32

    // StreamID is which stream this frame is for. Certain frames
    // are not stream-specific, in which case this field is 0.
    StreamID uint32
}
// 统一错误输出
type ErrCode uint32

const (
    ErrCodeNo                 ErrCode = 0x0
    ErrCodeProtocol           ErrCode = 0x1
    ErrCodeInternal           ErrCode = 0x2
    ErrCodeFlowControl        ErrCode = 0x3
    ErrCodeSettingsTimeout    ErrCode = 0x4
    ErrCodeStreamClosed       ErrCode = 0x5
    ErrCodeFrameSize          ErrCode = 0x6
    ErrCodeRefusedStream      ErrCode = 0x7
    ErrCodeCancel             ErrCode = 0x8
    ErrCodeCompression        ErrCode = 0x9
    ErrCodeConnect            ErrCode = 0xa
    ErrCodeEnhanceYourCalm    ErrCode = 0xb
    ErrCodeInadequateSecurity ErrCode = 0xc
    ErrCodeHTTP11Required     ErrCode = 0xd
)

var errCodeName = map[ErrCode]string{
    ErrCodeNo:                 "NO_ERROR",
    ErrCodeProtocol:           "PROTOCOL_ERROR",
    ErrCodeInternal:           "INTERNAL_ERROR",
    ErrCodeFlowControl:        "FLOW_CONTROL_ERROR",
    ErrCodeSettingsTimeout:    "SETTINGS_TIMEOUT",
    ErrCodeStreamClosed:       "STREAM_CLOSED",
    ErrCodeFrameSize:          "FRAME_SIZE_ERROR",
    ErrCodeRefusedStream:      "REFUSED_STREAM",
    ErrCodeCancel:             "CANCEL",
    ErrCodeCompression:        "COMPRESSION_ERROR",
    ErrCodeConnect:            "CONNECT_ERROR",
    ErrCodeEnhanceYourCalm:    "ENHANCE_YOUR_CALM",
    ErrCodeInadequateSecurity: "INADEQUATE_SECURITY",
    ErrCodeHTTP11Required:     "HTTP_1_1_REQUIRED",
}

func (e ErrCode) String() string {
    if s, ok := errCodeName[e]; ok {
        return s
    }
    return fmt.Sprintf("unknown error code 0x%x", uint32(e))
}
type connError struct {
    Code   ErrCode // the ConnectionError error code
    Reason string  // additional reason
}

func (e connError) Error() string {
    return fmt.Sprintf("http2: connection error: %v: %v", e.Code, e.Reason)
}

type StreamError struct {
    StreamID uint32
    Code     ErrCode
    Cause    error // optional additional detail
}

func streamError(id uint32, code ErrCode) StreamError {
    return StreamError{StreamID: id, Code: code}
}

func (e StreamError) Error() string {
    if e.Cause != nil {
        return fmt.Sprintf("stream error: stream ID %d; %v; %v", e.StreamID, e.Code, e.Cause)
    }
    return fmt.Sprintf("stream error: stream ID %d; %v", e.StreamID, e.Code)
}
//
func readByte(p []byte) ([]byte, byte, error) {
    if len(p) == 0 {
        return nil, 0, io.ErrUnexpectedEOF
    }
    return p[1:], p[0], nil
}

func readUint32(p []byte) ([]byte, uint32, error) {
    if len(p) < 4 {
        return nil, 0, io.ErrUnexpectedEOF
    }
    return p[4:], binary.BigEndian.Uint32(p[:4]), nil
}

func readFrameHeader(buf []byte, r io.Reader) (*FrameHeader, error) {
    // 读出 9 个字节的 Frame 的头。
    _, err := io.ReadFull(r, buf[:frameHeaderLen])
    if err != nil {
        return nil, err
    }
    return &FrameHeader{
        // 把长度解析为 uint32, 由于长度不足 32 bit 手动通过位操作
        Length:   (uint32(buf[0])<<16 | uint32(buf[1])<<8 | uint32(buf[2])),
        // type 转为 uint8
        Type:     FrameType(buf[3]),
        // flags 也为 uint8
        Flags:    Flags(buf[4]),
        // StreamID 正好长度为 32bit 通过binary.BigEndian.Uint32进行转换。
        StreamID: binary.BigEndian.Uint32(buf[5:]) & PadBit,
        valid:    true,
    }, nil
}

func ReadFrame(r io.Reader) {
    // buf可以考虑通过池子复用
    buf := make([]byte, frameHeaderLen)
    header, err := readFrameHeader(buf, r)
    if err != nil {
        return
    }
    payload := make([]byte, header.Length)
    _, err = io.ReadFull(r, payload)
    if err != nil {
        return
    }
    // Frame Parser
}

1
2
3
4
5
6
7

 +---------------+
 |Pad Length? (8)|
 +---------------+-----------------------------------------------+
 |                            Data (*)                         ...
 +---------------------------------------------------------------+
 |                           Padding (*)                       ...
 +---------------------------------------------------------------+

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

type DataFrame struct {
    FrameHeader
    Data []byte
}
func ParseDataFrame(fh *FrameHeader, payload []byte) (*DataFrame, error) {
	if fh.StreamID == 0 {
		return nil, ConnError{ErrCodeProtocol, "DATA frame with stream ID 0"}
	}
	f := &DataFrame{FrameHeader: *fh}

	var padSize byte
	if fh.Flags.Has(FlagDataPadded) {
		var err error
		payload, padSize, err = readByte(payload)
		if err != nil {
			return nil, err
		}
	}
	if int(padSize) > len(payload) {
		return nil, ConnError{ErrCodeProtocol, "pad size larger than data payload"}
	}
	f.Data = payload[:len(payload)-int(padSize)]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

 +---------------+
 |Pad Length? (8)|
 +-+-------------+-----------------------------------------------+
 |E|                 Stream Dependency? (31)                     |
 +-+-------------+-----------------------------------------------+
 |  Weight? (8)  |
 +-+-------------+-----------------------------------------------+
 |                   Header Block Fragment (*)                 ...
 +---------------------------------------------------------------+
 |                           Padding (*)                       ...
 +---------------------------------------------------------------+

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

type HeadersFrame struct {
    FrameHeader
    Priority PriorityParam
    HeaderFragBuf []byte
}
func ParseHeadersFrame(fh *FrameHeader, p []byte) (*HeadersFrame, error) {
    var err error
    hf := &HeadersFrame{
        FrameHeader: *fh,
    }
    if fh.StreamID == 0 {
        return nil, ConnError{ErrCodeProtocol, "HEADERS frame with stream ID 0"}
    }
    var padLength uint8
    if fh.Flags.Has(FlagHeadersPadded) {
        if p, padLength, err = readByte(p); err != nil {
            return nil, err
        }
    }
    if fh.Flags.Has(FlagHeadersPriority) {
        var v uint32
        p, v, err = readUint32(p)
        if err != nil {
            return nil, err
        }
        hf.Priority.StreamDep = v & PadBit
        hf.Priority.Exclusive = (v != hf.Priority.StreamDep) // high bit was set
        p, hf.Priority.Weight, err = readByte(p)
        if err != nil {
            return nil, err
        }
    }
    if len(p)-int(padLength) <= 0 {
        return nil, streamError(fh.StreamID, ErrCodeProtocol)
    }
    hf.HeaderFragBuf = p[:len(p)-int(padLength)]
    return hf, nil
}

1
2
3
4
5

 +-+-------------------------------------------------------------+
 |E|                  Stream Dependency (31)                     |
 +-+-------------+-----------------------------------------------+
 |   Weight (8)  |
 +-+-------------+

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

type PriorityParam struct {
    StreamDep uint32

    Exclusive bool

    Weight uint8
}
type PriorityFrame struct {
    FrameHeader
    PriorityParam
}
func ParsePriorityFrame(fh *FrameHeader, payload []byte) (*PriorityFrame, error) {
    if fh.StreamID == 0 {
        return nil, connError{
            ErrCodeProtocol,
            "PRIORITY frame with stream ID 0",
        }
    }
    var payloadLength = len(payload)
    if payloadLength != 5 {
        return nil, connError{
            ErrCodeFrameSize,
            fmt.Sprintf(
                "PRIORITY frame payload size was %d; want 5",
                payloadLength,
            ),
        }
    }
    v := binary.BigEndian.Uint32(payload[:4])
    // E 不处理
    streamID := v & PadBit // mask off high bit
    return &PriorityFrame{
        FrameHeader: *fh,
        PriorityParam: PriorityParam{
            Weight:    payload[4],
            StreamDep: streamID,
            Exclusive: streamID != v, // was high bit set?
        },
    }, nil
}

1
2
3

 +---------------------------------------------------------------+
 |                        Error Code (32)                        |
 +---------------------------------------------------------------+

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

type RSTStreamFrame struct {
    FrameHeader
    ErrCode ErrCode
}
func ParseRSTStreamFrame(fh *FrameHeader, p []byte) (*RSTStreamFrame, error) {
    if len(p) != 4 {
        return nil, ConnectionError(ErrCodeFrameSize)
    }
    if fh.StreamID == 0 {
        return nil, ConnectionError(ErrCodeProtocol)
    }
    return &RSTStreamFrame{*fh, ErrCode(binary.BigEndian.Uint32(p[:4]))}, nil
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

 +-------------------------------+
 |       Identifier (16)         |
 +-------------------------------+-------------------------------+
 |                        Value (32)                             |
 +---------------------------------------------------------------+
 +-------------------------------+
 |       Identifier (16)         |
 +-------------------------------+-------------------------------+
 |                        Value (32)                             |
 +---------------------------------------------------------------+
 ...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

type SettingID uint16
type Setting struct {
    ID  SettingID
    Val uint32
}

// SettingFrame setting frame
type SettingFrame struct {
	FrameHeader
	Settings map[SettingID]Setting
}
func ParserSettings(header *FrameHeader, payload []byte) (*SettingFrame, error) {
	settings := map[SettingID]Setting{}
	num := len(payload) / 6
	for i := 0; i < num; i++ {
		id := SettingID(binary.BigEndian.Uint16(payload[i*6 : i*6+2]))
		s := Setting{
			ID:  id,
			Val: binary.BigEndian.Uint32(payload[i*6+2 : i*6+6]),
		}
		settings[id] = s
	}
	return &SettingFrame{
		*header,
		settings,
	}, nil
}

1
2
3
4
5
6
7
8
9

 +---------------+
 |Pad Length? (8)|
 +-+-------------+-----------------------------------------------+
 |R|                  Promised Stream ID (31)                    |
 +-+-----------------------------+-------------------------------+
 |                   Header Block Fragment (*)                 ...
 +---------------------------------------------------------------+
 |                           Padding (*)                       ...
 +---------------------------------------------------------------+

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

type PushPromiseFrame struct {
    FrameHeader
    PromiseID     uint32
    HeaderFragBuf []byte // not owned
}
func ParsePushPromise(fh *FrameHeader, p []byte) (*PushPromiseFrame, error) {
    var err error
    pp := &PushPromiseFrame{
        FrameHeader: *fh,
    }
    if pp.StreamID == 0 {
        return nil, ConnectionError(ErrCodeProtocol)
    }
    var padLength uint8
    if fh.Flags.Has(FlagPushPromisePadded) {
        if p, padLength, err = readByte(p); err != nil {
            return nil, err
        }
    }
    p, pp.PromiseID, err = readUint32(p)
    if err != nil {
        return nil, err
    }
    pp.PromiseID = pp.PromiseID & PadBit
    var payloadLength = len(p)
    if int(padLength) > payloadLength {
        return nil, ConnectionError(ErrCodeProtocol)
    }
    pp.HeaderFragBuf = p[:payloadLength-int(padLength)]
    return pp, nil
}

1
2
3
4
5

 +---------------------------------------------------------------+
 |                                                               |
 |                      Opaque Data (64)                         |
 |                                                               |
 +---------------------------------------------------------------+

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

type PingFrame struct {
    FrameHeader
    Data [8]byte
}
func parsePingFrame(fh FrameHeader, payload []byte) (*PingFrame, error) {
    if len(payload) != 8 {
        return nil, ConnectionError(ErrCodeFrameSize)
    }
    if fh.StreamID != 0 {
        return nil, ConnectionError(ErrCodeProtocol)
    }
    f := &PingFrame{FrameHeader: fh}
    copy(f.Data[:], payload)
    return f, nil
}

1
2
3
4
5
6
7

 +-+-------------------------------------------------------------+
 |R|                  Last-Stream-ID (31)                        |
 +-+-------------------------------------------------------------+
 |                      Error Code (32)                          |
 +---------------------------------------------------------------+
 |                  Additional Debug Data (*)                    |
 +---------------------------------------------------------------+

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

type GoAwayFrame struct {
    FrameHeader
    LastStreamID uint32
    ErrCode      ErrCode
    DebugData    []byte
}
func parseGoAwayFrame(fh FrameHeader, p []byte) (*GoAwayFrame, error) {
    if fh.StreamID != 0 {
        return nil, ConnectionError(ErrCodeProtocol)
    }
    if len(p) < 8 {
        return nil, ConnectionError(ErrCodeFrameSize)
    }
    return &GoAwayFrame{
        FrameHeader:  fh,
        LastStreamID: binary.BigEndian.Uint32(p[:4]) & PadBit,
        ErrCode:      ErrCode(binary.BigEndian.Uint32(p[4:8])),
        debugData:    p[8:],
    }, nil
}

1
2
3

 +-+-------------------------------------------------------------+
 |R|              Window Size Increment (31)                     |
 +-+-------------------------------------------------------------+

1
2
3

func ParserWindowUpdate(header FrameHeader, payload []byte) uint32 {
    return binary.BigEndian.Uint32(payload[:4]) & PadBit
}

1
2
3

+---------------------------------------------------------------+
 |                   Header Block Fragment (*)                 ...
 +---------------------------------------------------------------+

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

type ContinuationFrame struct {
    FrameHeader
    HeaderFragBuf []byte
}

func parseContinuationFrame(fh FrameHeader, p []byte) (*ContinuationFrame, error) {
    if fh.StreamID == 0 {
        return nil, connError{ErrCodeProtocol, "CONTINUATION frame with stream ID 0"}
    }
    return &ContinuationFrame{fh, p}, nil
}