httpbis 0.9.1

Rust implementation of HTTP/2 protocol
Documentation 
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
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159

use bytes::Buf;
use bytes::Bytes;

use crate::solicit::frame::builder::FrameBuilder;
use crate::solicit::frame::parse_padded_payload;
use crate::solicit::frame::Frame;
use crate::solicit::frame::FrameHeader;
use crate::solicit::frame::FrameIR;
use crate::solicit::frame::ParseFrameError;
use crate::solicit::frame::ParseFrameResult;
use crate::solicit::frame::RawFrame;

use super::flags::Flag;
use super::flags::Flags;
use crate::codec::write_buffer::WriteBuffer;
use crate::solicit::stream_id::StreamId;

pub const PUSH_PROMISE_FRAME_TYPE: u8 = 0x5;

/// `PUSH_PROMISE` frame.
#[derive(Clone, PartialEq, Eq, Debug)]
pub struct PushPromiseFrame {
    /// The set of flags for the frame, packed into a single byte.
    pub flags: Flags<PushPromiseFlag>,
    /// The ID of the stream with which this frame is associated
    pub stream_id: StreamId,
    /// Promised Stream ID
    pub promised_stream_id: StreamId,
    /// The header fragment bytes stored within the frame.
    pub header_fragment: Bytes,
    /// The length of the padding, if any.
    pub padding_len: u8,
}

/// `PUSH_PROMISE` frame flag.
#[derive(PartialEq, Eq, Copy, Clone, Debug)]
pub enum PushPromiseFlag {
    /// Flag
    EndHeaders = 0x4,
    /// Flag
    Padded = 0x8,
}

impl Flag for PushPromiseFlag {
    fn bitmask(&self) -> u8 {
        *self as u8
    }

    fn flags() -> &'static [PushPromiseFlag] {
        static FLAGS: &'static [PushPromiseFlag] =
            &[PushPromiseFlag::EndHeaders, PushPromiseFlag::Padded];
        FLAGS
    }
}

impl PushPromiseFrame {
    /// Returns the length of the payload of the current frame, including any
    /// possible padding in the number of bytes.
    fn payload_len(&self) -> u32 {
        let padding = if self.flags.is_set(PushPromiseFlag::Padded) {
            1 + self.padding_len as u32
        } else {
            0
        };

        let stream_id_len = 4;

        self.header_fragment.len() as u32 + stream_id_len + padding
    }
}

impl Frame for PushPromiseFrame {
    type FlagType = PushPromiseFlag;

    fn from_raw(raw_frame: &RawFrame) -> ParseFrameResult<PushPromiseFrame> {
        // Unpack the header
        let FrameHeader {
            payload_len,
            frame_type,
            flags,
            stream_id,
        } = raw_frame.header();
        // Check that the frame type is correct for this frame implementation
        if frame_type != PUSH_PROMISE_FRAME_TYPE {
            return Err(ParseFrameError::InternalError);
        }

        // Check that the length given in the header matches the payload
        // length; if not, something went wrong and we do not consider this a
        // valid frame.
        if (payload_len as usize) != raw_frame.payload().len() {
            return Err(ParseFrameError::InternalError);
        }

        let flags = Flags::new(flags);

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

        let padded = flags.is_set(PushPromiseFlag::Padded);

        let (payload, padding_len) = parse_padded_payload(raw_frame.payload(), padded)?;

        let mut buf = &payload[..];

        let promised_stream_id = buf.get_u32();

        let header_fragment =
            payload.slice((payload_len as usize) - buf.remaining()..payload.len());

        Ok(PushPromiseFrame {
            header_fragment,
            stream_id,
            padding_len,
            flags,
            promised_stream_id,
        })
    }

    fn flags(&self) -> Flags<PushPromiseFlag> {
        self.flags
    }

    fn get_stream_id(&self) -> StreamId {
        self.stream_id
    }

    fn get_header(&self) -> FrameHeader {
        FrameHeader {
            payload_len: self.payload_len(),
            frame_type: PUSH_PROMISE_FRAME_TYPE,
            flags: self.flags.0,
            stream_id: self.stream_id,
        }
    }
}

impl FrameIR for PushPromiseFrame {
    fn serialize_into(self, b: &mut WriteBuffer) {
        b.write_header(self.get_header());
        let padded = self.flags.is_set(PushPromiseFlag::Padded);
        if padded {
            b.extend_from_slice(&[self.padding_len]);
        }
        // Now the actual headers fragment
        b.extend_from_bytes(self.header_fragment);
        // Finally, add the trailing padding, if required
        if padded {
            b.write_padding(self.padding_len);
        }
    }
}