}
pub enum HTTP2Decompresser {
- UNASSIGNED,
+ Unassigned,
// Box because large.
- GZIP(Box<GzDecoder<HTTP2cursor>>),
+ Gzip(Box<GzDecoder<HTTP2cursor>>),
// Box because large.
- BROTLI(Box<brotli::Decompressor<HTTP2cursor>>),
+ Brotli(Box<brotli::Decompressor<HTTP2cursor>>),
// This one is not so large, at 88 bytes as of doing this, but box
// for consistency.
- DEFLATE(Box<DeflateDecoder<HTTP2cursor>>),
+ Deflate(Box<DeflateDecoder<HTTP2cursor>>),
}
impl std::fmt::Debug for HTTP2Decompresser {
fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
match self {
- HTTP2Decompresser::UNASSIGNED => write!(f, "UNASSIGNED"),
- HTTP2Decompresser::GZIP(_) => write!(f, "GZIP"),
- HTTP2Decompresser::BROTLI(_) => write!(f, "BROTLI"),
- HTTP2Decompresser::DEFLATE(_) => write!(f, "DEFLATE"),
+ HTTP2Decompresser::Unassigned => write!(f, "UNASSIGNED"),
+ HTTP2Decompresser::Gzip(_) => write!(f, "GZIP"),
+ HTTP2Decompresser::Brotli(_) => write!(f, "BROTLI"),
+ HTTP2Decompresser::Deflate(_) => write!(f, "DEFLATE"),
}
}
}
pub fn new() -> HTTP2DecoderHalf {
HTTP2DecoderHalf {
encoding: HTTP2ContentEncoding::Unknown,
- decoder: HTTP2Decompresser::UNASSIGNED,
+ decoder: HTTP2Decompresser::Unassigned,
}
}
if self.encoding == HTTP2ContentEncoding::Unknown {
if input == b"gzip" {
self.encoding = HTTP2ContentEncoding::Gzip;
- self.decoder = HTTP2Decompresser::GZIP(Box::new(GzDecoder::new(HTTP2cursor::new())));
+ self.decoder = HTTP2Decompresser::Gzip(Box::new(GzDecoder::new(HTTP2cursor::new())));
} else if input == b"deflate" {
self.encoding = HTTP2ContentEncoding::Deflate;
- self.decoder = HTTP2Decompresser::DEFLATE(Box::new(DeflateDecoder::new(HTTP2cursor::new())));
+ self.decoder = HTTP2Decompresser::Deflate(Box::new(DeflateDecoder::new(HTTP2cursor::new())));
} else if input == b"br" {
self.encoding = HTTP2ContentEncoding::Br;
- self.decoder = HTTP2Decompresser::BROTLI(Box::new(brotli::Decompressor::new(
+ self.decoder = HTTP2Decompresser::Brotli(Box::new(brotli::Decompressor::new(
HTTP2cursor::new(),
HTTP2_DECOMPRESSION_CHUNK_SIZE,
)));
&mut self, input: &'a [u8], output: &'a mut Vec<u8>,
) -> io::Result<&'a [u8]> {
match self.decoder {
- HTTP2Decompresser::GZIP(ref mut gzip_decoder) => {
+ HTTP2Decompresser::Gzip(ref mut gzip_decoder) => {
let r = http2_decompress(&mut *gzip_decoder.as_mut(), input, output);
if r.is_err() {
- self.decoder = HTTP2Decompresser::UNASSIGNED;
+ self.decoder = HTTP2Decompresser::Unassigned;
}
return r;
}
- HTTP2Decompresser::BROTLI(ref mut br_decoder) => {
+ HTTP2Decompresser::Brotli(ref mut br_decoder) => {
let r = http2_decompress(&mut *br_decoder.as_mut(), input, output);
if r.is_err() {
- self.decoder = HTTP2Decompresser::UNASSIGNED;
+ self.decoder = HTTP2Decompresser::Unassigned;
}
return r;
}
- HTTP2Decompresser::DEFLATE(ref mut df_decoder) => {
+ HTTP2Decompresser::Deflate(ref mut df_decoder) => {
let r = http2_decompress(&mut *df_decoder.as_mut(), input, output);
if r.is_err() {
- self.decoder = HTTP2Decompresser::UNASSIGNED;
+ self.decoder = HTTP2Decompresser::Unassigned;
}
return r;
}
fn http2_tx_set_header(state: &mut HTTP2State, name: &[u8], input: &[u8]) {
let head = parser::HTTP2FrameHeader {
length: 0,
- ftype: parser::HTTP2FrameType::HEADERS as u8,
+ ftype: parser::HTTP2FrameType::Headers as u8,
flags: 0,
reserved: 0,
stream_id: 1,
let head = parser::HTTP2FrameHeader {
length: dec.len() as u32,
- ftype: parser::HTTP2FrameType::SETTINGS as u8,
+ ftype: parser::HTTP2FrameType::Settings as u8,
flags: 0,
reserved: 0,
stream_id: 0,
let mut tx = HTTP2Transaction::new();
let head = parser::HTTP2FrameHeader {
length: 0,
- ftype: parser::HTTP2FrameType::HEADERS as u8,
+ ftype: parser::HTTP2FrameType::Headers as u8,
flags: 0,
reserved: 0,
stream_id: 1,
}
}
}
- } else if header.ftype == parser::HTTP2FrameType::DATA as u8 {
+ } else if header.ftype == parser::HTTP2FrameType::Data as u8 {
//not end of stream
if dir == Direction::ToServer {
if self.state < HTTP2TransactionState::HTTP2StateDataClient {
if index > 0 {
if self.transactions[index - 1].state == HTTP2TransactionState::HTTP2StateClosed {
//these frames can be received in this state for a short period
- if header.ftype != parser::HTTP2FrameType::RSTSTREAM as u8
- && header.ftype != parser::HTTP2FrameType::WINDOWUPDATE as u8
- && header.ftype != parser::HTTP2FrameType::PRIORITY as u8
+ if header.ftype != parser::HTTP2FrameType::RstStream as u8
+ && header.ftype != parser::HTTP2FrameType::WindowUpdate as u8
+ && header.ftype != parser::HTTP2FrameType::Priority as u8
{
self.set_event(HTTP2Event::StreamIdReuse);
}
&mut self, ftype: u8, input: &[u8], complete: bool, hflags: u8, dir: Direction,
) -> HTTP2FrameTypeData {
match num::FromPrimitive::from_u8(ftype) {
- Some(parser::HTTP2FrameType::GOAWAY) => {
+ Some(parser::HTTP2FrameType::GoAway) => {
if input.len() < HTTP2_FRAME_GOAWAY_LEN {
self.set_event(HTTP2Event::InvalidFrameLength);
return HTTP2FrameTypeData::UNHANDLED(HTTP2FrameUnhandled {
}
}
}
- Some(parser::HTTP2FrameType::SETTINGS) => {
+ Some(parser::HTTP2FrameType::Settings) => {
match parser::http2_parse_frame_settings(input) {
Ok((_, set)) => {
for e in &set {
- if e.id == parser::HTTP2SettingsId::SETTINGSHEADERTABLESIZE {
+ if e.id == parser::HTTP2SettingsId::HeaderTableSize {
//reverse order as this is what we accept from the other endpoint
let dyn_headers = if dir == Direction::ToClient {
&mut self.dynamic_headers_ts
}
}
}
- Some(parser::HTTP2FrameType::RSTSTREAM) => {
+ Some(parser::HTTP2FrameType::RstStream) => {
if input.len() != HTTP2_FRAME_RSTSTREAM_LEN {
self.set_event(HTTP2Event::InvalidFrameLength);
return HTTP2FrameTypeData::UNHANDLED(HTTP2FrameUnhandled {
}
}
}
- Some(parser::HTTP2FrameType::PRIORITY) => {
+ Some(parser::HTTP2FrameType::Priority) => {
if input.len() != HTTP2_FRAME_PRIORITY_LEN {
self.set_event(HTTP2Event::InvalidFrameLength);
return HTTP2FrameTypeData::UNHANDLED(HTTP2FrameUnhandled {
}
}
}
- Some(parser::HTTP2FrameType::WINDOWUPDATE) => {
+ Some(parser::HTTP2FrameType::WindowUpdate) => {
if input.len() != HTTP2_FRAME_WINDOWUPDATE_LEN {
self.set_event(HTTP2Event::InvalidFrameLength);
return HTTP2FrameTypeData::UNHANDLED(HTTP2FrameUnhandled {
}
}
}
- Some(parser::HTTP2FrameType::PUSHPROMISE) => {
+ Some(parser::HTTP2FrameType::PushPromise) => {
let dyn_headers = if dir == Direction::ToClient {
&mut self.dynamic_headers_tc
} else {
}
}
}
- Some(parser::HTTP2FrameType::DATA) => {
+ Some(parser::HTTP2FrameType::Data) => {
return HTTP2FrameTypeData::DATA;
}
- Some(parser::HTTP2FrameType::CONTINUATION) => {
+ Some(parser::HTTP2FrameType::Continuation) => {
let dyn_headers = if dir == Direction::ToClient {
&mut self.dynamic_headers_tc
} else {
}
}
}
- Some(parser::HTTP2FrameType::HEADERS) => {
+ Some(parser::HTTP2FrameType::Headers) => {
let dyn_headers = if dir == Direction::ToClient {
&mut self.dynamic_headers_tc
} else {
}
}
}
- Some(parser::HTTP2FrameType::PING) => {
+ Some(parser::HTTP2FrameType::Ping) => {
return HTTP2FrameTypeData::PING;
}
_ => {
(hl, true)
};
- if head.length == 0 && head.ftype == parser::HTTP2FrameType::SETTINGS as u8 {
+ if head.length == 0 && head.ftype == parser::HTTP2FrameType::Settings as u8 {
input = &rem[hlsafe..];
continue;
}
data: txdata,
});
}
- if ftype == parser::HTTP2FrameType::DATA as u8 {
+ if ftype == parser::HTTP2FrameType::Data as u8 {
match unsafe { SURICATA_HTTP2_FILE_CONFIG } {
Some(sfcm) => {
//borrow checker forbids to reuse directly tx
if header.reserved != 0
|| header.length > HTTP2_DEFAULT_MAX_FRAME_SIZE
|| header.flags & 0xFE != 0
- || header.ftype != parser::HTTP2FrameType::SETTINGS as u8
+ || header.ftype != parser::HTTP2FrameType::Settings as u8
{
return ALPROTO_FAILED;
}
}
for e in set {
js.start_object()?;
- js.set_string("settings_id", &e.id.to_string())?;
+ js.set_string("settings_id", &format!("SETTINGS{}", &e.id.to_string().to_uppercase()))?;
js.set_uint("settings_value", e.value as u64)?;
js.close()?;
}
num::FromPrimitive::from_u32(goaway.errorcode);
match errcode {
Some(errstr) => {
- js.set_string("error_code", &errstr.to_string())?;
+ js.set_string("error_code", &errstr.to_string().to_uppercase())?;
}
None => {
//use uint32
#[repr(u8)]
#[derive(Clone, Copy, PartialEq, Eq, FromPrimitive, Debug)]
pub enum HTTP2FrameType {
- DATA = 0,
- HEADERS = 1,
- PRIORITY = 2,
- RSTSTREAM = 3,
- SETTINGS = 4,
- PUSHPROMISE = 5,
- PING = 6,
- GOAWAY = 7,
- WINDOWUPDATE = 8,
- CONTINUATION = 9,
+ Data = 0,
+ Headers = 1,
+ Priority = 2,
+ RstStream = 3,
+ Settings = 4,
+ PushPromise = 5,
+ Ping = 6,
+ GoAway = 7,
+ WindowUpdate = 8,
+ Continuation = 9,
}
impl fmt::Display for HTTP2FrameType {
let su = s.to_uppercase();
let su_slice: &str = &su;
match su_slice {
- "DATA" => Ok(HTTP2FrameType::DATA),
- "HEADERS" => Ok(HTTP2FrameType::HEADERS),
- "PRIORITY" => Ok(HTTP2FrameType::PRIORITY),
- "RSTSTREAM" => Ok(HTTP2FrameType::RSTSTREAM),
- "SETTINGS" => Ok(HTTP2FrameType::SETTINGS),
- "PUSHPROMISE" => Ok(HTTP2FrameType::PUSHPROMISE),
- "PING" => Ok(HTTP2FrameType::PING),
- "GOAWAY" => Ok(HTTP2FrameType::GOAWAY),
- "WINDOWUPDATE" => Ok(HTTP2FrameType::WINDOWUPDATE),
- "CONTINUATION" => Ok(HTTP2FrameType::CONTINUATION),
+ "DATA" => Ok(HTTP2FrameType::Data),
+ "HEADERS" => Ok(HTTP2FrameType::Headers),
+ "PRIORITY" => Ok(HTTP2FrameType::Priority),
+ "RSTSTREAM" => Ok(HTTP2FrameType::RstStream),
+ "SETTINGS" => Ok(HTTP2FrameType::Settings),
+ "PUSHPROMISE" => Ok(HTTP2FrameType::PushPromise),
+ "PING" => Ok(HTTP2FrameType::Ping),
+ "GOAWAY" => Ok(HTTP2FrameType::GoAway),
+ "WINDOWUPDATE" => Ok(HTTP2FrameType::WindowUpdate),
+ "CONTINUATION" => Ok(HTTP2FrameType::Continuation),
_ => Err(format!("'{}' is not a valid value for HTTP2FrameType", s)),
}
}
#[repr(u32)]
#[derive(Clone, Copy, PartialEq, Eq, FromPrimitive, Debug)]
pub enum HTTP2ErrorCode {
- NOERROR = 0,
- PROTOCOLERROR = 1,
- INTERNALERROR = 2,
- FLOWCONTROLERROR = 3,
- SETTINGSTIMEOUT = 4,
- STREAMCLOSED = 5,
- FRAMESIZEERROR = 6,
- REFUSEDSTREAM = 7,
- CANCEL = 8,
- COMPRESSIONERROR = 9,
- CONNECTERROR = 10,
- ENHANCEYOURCALM = 11,
- INADEQUATESECURITY = 12,
- HTTP11REQUIRED = 13,
+ NoError = 0,
+ ProtocolError = 1,
+ InternalError = 2,
+ FlowControlError = 3,
+ SettingsTimeout = 4,
+ StreamClosed = 5,
+ FrameSizeError = 6,
+ RefusedStream = 7,
+ Cancel = 8,
+ CompressionError = 9,
+ ConnectError = 10,
+ EnhanceYourCalm = 11,
+ InadequateSecurity = 12,
+ Http11Required = 13,
}
impl fmt::Display for HTTP2ErrorCode {
let su = s.to_uppercase();
let su_slice: &str = &su;
match su_slice {
- "NO_ERROR" => Ok(HTTP2ErrorCode::NOERROR),
- "PROTOCOL_ERROR" => Ok(HTTP2ErrorCode::PROTOCOLERROR),
- "FLOW_CONTROL_ERROR" => Ok(HTTP2ErrorCode::FLOWCONTROLERROR),
- "SETTINGS_TIMEOUT" => Ok(HTTP2ErrorCode::SETTINGSTIMEOUT),
- "STREAM_CLOSED" => Ok(HTTP2ErrorCode::STREAMCLOSED),
- "FRAME_SIZE_ERROR" => Ok(HTTP2ErrorCode::FRAMESIZEERROR),
- "REFUSED_STREAM" => Ok(HTTP2ErrorCode::REFUSEDSTREAM),
- "CANCEL" => Ok(HTTP2ErrorCode::CANCEL),
- "COMPRESSION_ERROR" => Ok(HTTP2ErrorCode::COMPRESSIONERROR),
- "CONNECT_ERROR" => Ok(HTTP2ErrorCode::CONNECTERROR),
- "ENHANCE_YOUR_CALM" => Ok(HTTP2ErrorCode::ENHANCEYOURCALM),
- "INADEQUATE_SECURITY" => Ok(HTTP2ErrorCode::INADEQUATESECURITY),
- "HTTP_1_1_REQUIRED" => Ok(HTTP2ErrorCode::HTTP11REQUIRED),
+ "NO_ERROR" => Ok(HTTP2ErrorCode::NoError),
+ "PROTOCOL_ERROR" => Ok(HTTP2ErrorCode::ProtocolError),
+ "FLOW_CONTROL_ERROR" => Ok(HTTP2ErrorCode::FlowControlError),
+ "SETTINGS_TIMEOUT" => Ok(HTTP2ErrorCode::SettingsTimeout),
+ "STREAM_CLOSED" => Ok(HTTP2ErrorCode::StreamClosed),
+ "FRAME_SIZE_ERROR" => Ok(HTTP2ErrorCode::FrameSizeError),
+ "REFUSED_STREAM" => Ok(HTTP2ErrorCode::RefusedStream),
+ "CANCEL" => Ok(HTTP2ErrorCode::Cancel),
+ "COMPRESSION_ERROR" => Ok(HTTP2ErrorCode::CompressionError),
+ "CONNECT_ERROR" => Ok(HTTP2ErrorCode::ConnectError),
+ "ENHANCE_YOUR_CALM" => Ok(HTTP2ErrorCode::EnhanceYourCalm),
+ "INADEQUATE_SECURITY" => Ok(HTTP2ErrorCode::InadequateSecurity),
+ "HTTP_1_1_REQUIRED" => Ok(HTTP2ErrorCode::Http11Required),
_ => Err(format!("'{}' is not a valid value for HTTP2ErrorCode", s)),
}
}
#[repr(u16)]
#[derive(Clone, Copy, PartialEq, Eq, FromPrimitive, Debug)]
pub enum HTTP2SettingsId {
- SETTINGSHEADERTABLESIZE = 1,
- SETTINGSENABLEPUSH = 2,
- SETTINGSMAXCONCURRENTSTREAMS = 3,
- SETTINGSINITIALWINDOWSIZE = 4,
- SETTINGSMAXFRAMESIZE = 5,
- SETTINGSMAXHEADERLISTSIZE = 6,
+ HeaderTableSize = 1,
+ EnablePush = 2,
+ MaxConcurrentStreams = 3,
+ InitialWindowSize = 4,
+ MaxFrameSize = 5,
+ MaxHeaderListSize = 6,
}
impl fmt::Display for HTTP2SettingsId {
let su = s.to_uppercase();
let su_slice: &str = &su;
match su_slice {
- "SETTINGS_HEADER_TABLE_SIZE" => Ok(HTTP2SettingsId::SETTINGSHEADERTABLESIZE),
- "SETTINGS_ENABLE_PUSH" => Ok(HTTP2SettingsId::SETTINGSENABLEPUSH),
- "SETTINGS_MAX_CONCURRENT_STREAMS" => Ok(HTTP2SettingsId::SETTINGSMAXCONCURRENTSTREAMS),
- "SETTINGS_INITIAL_WINDOW_SIZE" => Ok(HTTP2SettingsId::SETTINGSINITIALWINDOWSIZE),
- "SETTINGS_MAX_FRAME_SIZE" => Ok(HTTP2SettingsId::SETTINGSMAXFRAMESIZE),
- "SETTINGS_MAX_HEADER_LIST_SIZE" => Ok(HTTP2SettingsId::SETTINGSMAXHEADERLISTSIZE),
+ "SETTINGS_HEADER_TABLE_SIZE" => Ok(HTTP2SettingsId::HeaderTableSize),
+ "SETTINGS_ENABLE_PUSH" => Ok(HTTP2SettingsId::EnablePush),
+ "SETTINGS_MAX_CONCURRENT_STREAMS" => Ok(HTTP2SettingsId::MaxConcurrentStreams),
+ "SETTINGS_INITIAL_WINDOW_SIZE" => Ok(HTTP2SettingsId::InitialWindowSize),
+ "SETTINGS_MAX_FRAME_SIZE" => Ok(HTTP2SettingsId::MaxFrameSize),
+ "SETTINGS_MAX_HEADER_LIST_SIZE" => Ok(HTTP2SettingsId::MaxHeaderListSize),
_ => Err(format!("'{}' is not a valid value for HTTP2SettingsId", s)),
}
}
let r = http2_parse_settingsctx(s);
match r {
Ok((rem, ctx)) => {
- assert_eq!(ctx.id, HTTP2SettingsId::SETTINGSENABLEPUSH);
+ assert_eq!(ctx.id, HTTP2SettingsId::EnablePush);
match ctx.value {
Some(_) => {
panic!("Unexpected value");
let r1 = http2_parse_settingsctx(s1);
match r1 {
Ok((rem, ctx)) => {
- assert_eq!(ctx.id, HTTP2SettingsId::SETTINGSENABLEPUSH);
+ assert_eq!(ctx.id, HTTP2SettingsId::EnablePush);
if ctx.value.is_some() {
panic!("Unexpected value");
}
let r2 = http2_parse_settingsctx(s2);
match r2 {
Ok((rem, ctx)) => {
- assert_eq!(ctx.id, HTTP2SettingsId::SETTINGSMAXCONCURRENTSTREAMS);
+ assert_eq!(ctx.id, HTTP2SettingsId::MaxConcurrentStreams);
match ctx.value {
Some(ctxval) => {
assert_eq!(ctxval.arg1, 42);
let r3 = http2_parse_settingsctx(s3);
match r3 {
Ok((rem, ctx)) => {
- assert_eq!(ctx.id, HTTP2SettingsId::SETTINGSMAXCONCURRENTSTREAMS);
+ assert_eq!(ctx.id, HTTP2SettingsId::MaxConcurrentStreams);
match ctx.value {
Some(ctxval) => {
assert_eq!(ctxval.arg1, 42);
let r4 = http2_parse_settingsctx(s4);
match r4 {
Ok((rem, ctx)) => {
- assert_eq!(ctx.id, HTTP2SettingsId::SETTINGSMAXCONCURRENTSTREAMS);
+ assert_eq!(ctx.id, HTTP2SettingsId::MaxConcurrentStreams);
match ctx.value {
Some(ctxval) => {
assert_eq!(ctxval.arg1, 54);
let r5 = http2_parse_settingsctx(s5);
match r5 {
Ok((rem, ctx)) => {
- assert_eq!(ctx.id, HTTP2SettingsId::SETTINGSMAXCONCURRENTSTREAMS);
+ assert_eq!(ctx.id, HTTP2SettingsId::MaxConcurrentStreams);
match ctx.value {
Some(ctxval) => {
assert_eq!(ctxval.arg1, 76);
Ok((remainder, frame)) => {
// Check the first message.
assert_eq!(frame.length, 6);
- assert_eq!(frame.ftype, HTTP2FrameType::SETTINGS as u8);
+ assert_eq!(frame.ftype, HTTP2FrameType::Settings as u8);
assert_eq!(frame.flags, 0);
assert_eq!(frame.reserved, 0);
assert_eq!(frame.stream_id, 0);
GroupCurveB = 10,
LifeType = 11,
LifeDuration = 12,
- PRF = 13,
+ Prf = 13,
KeyLength = 14,
FieldSize = 15,
GroupOrder = 16,
AttributeType::GroupCurveB => write!(f, "sa_group_curve_b"),
AttributeType::LifeType => write!(f, "sa_life_type"),
AttributeType::LifeDuration => write!(f, "sa_life_duration"),
- AttributeType::PRF => write!(f, "alg_prf"),
+ AttributeType::Prf => write!(f, "alg_prf"),
AttributeType::KeyLength => write!(f, "sa_key_length"),
AttributeType::FieldSize => write!(f, "sa_field_size"),
AttributeType::GroupOrder => write!(f, "sa_group_order"),
10 => AttributeType::GroupCurveB,
11 => AttributeType::LifeType,
12 => AttributeType::LifeDuration,
- 13 => AttributeType::PRF,
+ 13 => AttributeType::Prf,
14 => AttributeType::KeyLength,
15 => AttributeType::FieldSize,
16 => AttributeType::GroupOrder,
#![allow(clippy::module_inception)]
#![allow(clippy::result_unit_err)]
#![allow(clippy::type_complexity)]
-#![allow(clippy::upper_case_acronyms)]
#[macro_use]
extern crate bitflags;
projects / thirdparty / suricata.git / commitdiff
