use crate::BuilderError;
use crate::FrameFiller;
use crate::FrameReceiver;
use crate::H2SettingsError;
use crate::SettingsFrameBuilder;
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct H2Settings {
header_table_size: u32, enable_push: bool, max_concurrent_streams: u32, initial_window_size: u32, max_frame_size: u32, max_header_list_size: u32, }
impl Default for H2Settings {
fn default() -> Self {
Self {
header_table_size: 4_096,
enable_push: true,
max_concurrent_streams: 100,
initial_window_size: 65_535,
max_frame_size: 16_384,
max_header_list_size: 0,
}
}
}
impl H2Settings {
pub fn set_header_table_size(&mut self, v: u32) -> Result<(), H2SettingsError> {
self.header_table_size = v;
Ok(())
}
pub fn set_enable_push(&mut self, v: u32) -> Result<(), H2SettingsError> {
self.enable_push = match v {
0 => false,
1 => true,
_ => return Err(H2SettingsError::InvalidEnablePush),
};
Ok(())
}
pub fn set_max_concurrent_streams(&mut self, v: u32) -> Result<(), H2SettingsError> {
self.max_concurrent_streams = v;
Ok(())
}
pub fn set_initial_window_size(&mut self, v: u32) -> Result<(), H2SettingsError> {
self.initial_window_size = match v {
..2147483647 => v,
_ => return Err(H2SettingsError::FlowControlError),
};
Ok(())
}
pub fn set_max_frame_size(&mut self, v: u32) -> Result<(), H2SettingsError> {
self.max_frame_size = match v {
16_384..16_777_215 => v,
_ => return Err(H2SettingsError::ProtocolError),
};
Ok(())
}
pub fn set_max_header_list_size(&mut self, v: u32) -> Result<(), H2SettingsError> {
self.max_header_list_size = v;
Ok(())
}
pub fn from_payload(payload: &[u8]) -> Result<Self, H2SettingsError> {
let mut settings = H2Settings::default();
if payload.len() % 6 != 0 {
return Err(H2SettingsError::InvalidPayload);
}
for chnk in payload.chunks(6) {
let val = u32::from_be_bytes([chnk[2], chnk[3], chnk[4], chnk[5]]);
match chnk[1] {
0x01 => settings.set_header_table_size(val)?,
0x02 => settings.set_enable_push(val)?,
0x03 => settings.set_max_concurrent_streams(val)?,
0x04 => settings.set_initial_window_size(val)?,
0x05 => settings.set_max_frame_size(val)?,
0x06 => settings.set_max_header_list_size(val)?,
_ => {}
}
}
Ok(settings)
}
}
impl H2Settings {
pub fn frame_out<R: FrameReceiver + SettingsFrameBuilder>(
&self,
r: &mut R,
) -> Result<(), BuilderError> {
let mut frame_out: [u8; 60] = [0; 60];
let mut filler = FrameFiller::<60>::new();
filler.try_skip_only(3)?;
filler.try_fill_with(&mut frame_out, &[0x04])?;
let ack_flag = r.ack_flag();
let ack_byte = match ack_flag {
true => 1u8,
false => 0u8,
};
filler.try_fill_with(&mut frame_out, &[ack_byte])?;
let stream_id = r.stream_id().as_u32();
let stream_id_bytes = stream_id.to_be_bytes();
filler.try_fill_with(&mut frame_out, &stream_id_bytes)?;
let frame_header_length = filler.cur_as_u32();
let enable_push_u32: u32 = match self.enable_push {
false => 0,
true => 1,
};
let settings = [
(0x01, self.header_table_size),
(0x02, enable_push_u32),
(0x03, self.max_concurrent_streams),
(0x04, self.initial_window_size),
(0x05, self.max_frame_size),
(0x06, self.max_header_list_size),
];
for (setting_id_short, setting_val) in settings {
let val_bytes = setting_val.to_be_bytes();
filler.try_fill_with(&mut frame_out, &[0, setting_id_short])?;
filler.try_fill_with(&mut frame_out, &val_bytes)?;
}
let filled_len = filler.cur_as_u32() - frame_header_length;
let filled_len_b32 = filled_len.to_be_bytes();
frame_out[0] = filled_len_b32[1];
frame_out[1] = filled_len_b32[2];
frame_out[2] = filled_len_b32[3];
r.frame(&frame_out[..filler.cur_as_usize()]);
Ok(())
}
}
#[cfg(test)]
mod test {
use super::*;
use crate::StreamId;
#[rustfmt::skip]
#[allow(dead_code)]
const _CURL_EXPECTED: &[u8] = &[
0, 0, 18, 4, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 100, 0, 4, 0, 1, 0, 0, 0, 2, 0, 0, 0, 0, ];
#[rustfmt::skip]
#[allow(dead_code)]
const EXPECTED_DEFAULT: &[u8] = &[
0, 0, 36,
4,
0,
0, 0, 0, 0,
0, 1, 0, 0, 16, 0,
0, 2, 0, 0, 0, 1,
0, 3, 0, 0, 0, 100,
0, 4, 0, 0, 255, 255,
0, 5, 0, 0, 64, 0,
0, 6, 0, 0, 0, 0
];
#[derive(Debug, Default)]
#[allow(dead_code)] struct TestFramer {
b: Vec<u8>,
}
impl SettingsFrameBuilder for TestFramer {
fn stream_id(&mut self) -> StreamId {
StreamId::unchecked_new(0)
}
fn ack_flag(&mut self) -> bool {
false
}
}
impl FrameReceiver for TestFramer {
fn frame(&mut self, frame: &[u8]) {
self.b.extend(frame);
}
}
#[test]
fn settings_builder_test_default() {
let mut framer = TestFramer::default();
let settings = H2Settings::default();
match settings.frame_out(&mut framer) {
Ok(()) => {}
Err(e) => panic!("No frame out: {:?}", e),
}
assert_eq!(EXPECTED_DEFAULT, framer.b);
}
}