diff --git a/rust/src/http2/decompression.rs b/rust/src/http2/decompression.rs index 431517b4eb..99f8af3903 100644 --- a/rust/src/http2/decompression.rs +++ b/rust/src/http2/decompression.rs @@ -80,23 +80,23 @@ impl Read for HTTP2cursor { } pub enum HTTP2Decompresser { - UNASSIGNED, + Unassigned, // Box because large. - GZIP(Box>), + Gzip(Box>), // Box because large. - BROTLI(Box>), + Brotli(Box>), // This one is not so large, at 88 bytes as of doing this, but box // for consistency. - DEFLATE(Box>), + Deflate(Box>), } 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"), } } } @@ -169,7 +169,7 @@ impl HTTP2DecoderHalf { pub fn new() -> HTTP2DecoderHalf { HTTP2DecoderHalf { encoding: HTTP2ContentEncoding::Unknown, - decoder: HTTP2Decompresser::UNASSIGNED, + decoder: HTTP2Decompresser::Unassigned, } } @@ -178,13 +178,13 @@ impl HTTP2DecoderHalf { 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, ))); @@ -198,24 +198,24 @@ impl HTTP2DecoderHalf { &mut self, input: &'a [u8], output: &'a mut Vec, ) -> 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; } diff --git a/rust/src/http2/detect.rs b/rust/src/http2/detect.rs index 5ed5cd1c44..31b534efa5 100644 --- a/rust/src/http2/detect.rs +++ b/rust/src/http2/detect.rs @@ -841,7 +841,7 @@ pub unsafe extern "C" fn rs_http2_tx_get_header( 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, @@ -894,7 +894,7 @@ fn http2_tx_set_settings(state: &mut HTTP2State, input: &[u8]) { 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, @@ -997,7 +997,7 @@ mod tests { 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, diff --git a/rust/src/http2/http2.rs b/rust/src/http2/http2.rs index 9f4fc7f30a..df9a30fbf2 100644 --- a/rust/src/http2/http2.rs +++ b/rust/src/http2/http2.rs @@ -346,7 +346,7 @@ impl HTTP2Transaction { } } } - } 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 { @@ -595,9 +595,9 @@ impl HTTP2State { 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); } @@ -666,7 +666,7 @@ impl HTTP2State { &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 { @@ -685,11 +685,11 @@ impl HTTP2State { } } } - 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 @@ -729,7 +729,7 @@ impl HTTP2State { } } } - Some(parser::HTTP2FrameType::RSTSTREAM) => { + Some(parser::HTTP2FrameType::RstStream) => { if input.len() != HTTP2_FRAME_RSTSTREAM_LEN { self.set_event(HTTP2Event::InvalidFrameLength); return HTTP2FrameTypeData::UNHANDLED(HTTP2FrameUnhandled { @@ -749,7 +749,7 @@ impl HTTP2State { } } } - Some(parser::HTTP2FrameType::PRIORITY) => { + Some(parser::HTTP2FrameType::Priority) => { if input.len() != HTTP2_FRAME_PRIORITY_LEN { self.set_event(HTTP2Event::InvalidFrameLength); return HTTP2FrameTypeData::UNHANDLED(HTTP2FrameUnhandled { @@ -769,7 +769,7 @@ impl HTTP2State { } } } - Some(parser::HTTP2FrameType::WINDOWUPDATE) => { + Some(parser::HTTP2FrameType::WindowUpdate) => { if input.len() != HTTP2_FRAME_WINDOWUPDATE_LEN { self.set_event(HTTP2Event::InvalidFrameLength); return HTTP2FrameTypeData::UNHANDLED(HTTP2FrameUnhandled { @@ -789,7 +789,7 @@ impl HTTP2State { } } } - Some(parser::HTTP2FrameType::PUSHPROMISE) => { + Some(parser::HTTP2FrameType::PushPromise) => { let dyn_headers = if dir == Direction::ToClient { &mut self.dynamic_headers_tc } else { @@ -820,10 +820,10 @@ impl HTTP2State { } } } - 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 { @@ -854,7 +854,7 @@ impl HTTP2State { } } } - Some(parser::HTTP2FrameType::HEADERS) => { + Some(parser::HTTP2FrameType::Headers) => { let dyn_headers = if dir == Direction::ToClient { &mut self.dynamic_headers_tc } else { @@ -889,7 +889,7 @@ impl HTTP2State { } } } - Some(parser::HTTP2FrameType::PING) => { + Some(parser::HTTP2FrameType::Ping) => { return HTTP2FrameTypeData::PING; } _ => { @@ -934,7 +934,7 @@ impl HTTP2State { (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; } @@ -963,7 +963,7 @@ impl HTTP2State { 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 @@ -1095,7 +1095,7 @@ pub unsafe extern "C" fn rs_http2_probing_parser_tc( 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; } diff --git a/rust/src/http2/logger.rs b/rust/src/http2/logger.rs index cf3f30217d..d25f852c43 100644 --- a/rust/src/http2/logger.rs +++ b/rust/src/http2/logger.rs @@ -112,7 +112,7 @@ fn log_http2_frames(frames: &[HTTP2Frame], js: &mut JsonBuilder) -> Result Result { - js.set_string("error_code", &errstr.to_string())?; + js.set_string("error_code", &errstr.to_string().to_uppercase())?; } None => { //use uint32 diff --git a/rust/src/http2/parser.rs b/rust/src/http2/parser.rs index bd7f661d72..6ed570e09a 100644 --- a/rust/src/http2/parser.rs +++ b/rust/src/http2/parser.rs @@ -34,16 +34,16 @@ use std::str::FromStr; #[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 { @@ -59,16 +59,16 @@ impl std::str::FromStr 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)), } } @@ -105,20 +105,20 @@ pub fn http2_parse_frame_header(i: &[u8]) -> IResult<&[u8], HTTP2FrameHeader> { #[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 { @@ -134,19 +134,19 @@ impl std::str::FromStr 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)), } } @@ -683,12 +683,12 @@ pub fn http2_parse_frame_continuation<'a>( #[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 { @@ -704,12 +704,12 @@ impl std::str::FromStr 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)), } } @@ -872,7 +872,7 @@ mod tests { 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"); @@ -891,7 +891,7 @@ mod tests { 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"); } @@ -906,7 +906,7 @@ mod tests { 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); @@ -926,7 +926,7 @@ mod tests { 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); @@ -948,7 +948,7 @@ mod tests { 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); @@ -969,7 +969,7 @@ mod tests { 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); @@ -1025,7 +1025,7 @@ mod tests { 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); diff --git a/rust/src/ike/parser.rs b/rust/src/ike/parser.rs index 94b0f3140c..6947696df1 100644 --- a/rust/src/ike/parser.rs +++ b/rust/src/ike/parser.rs @@ -144,7 +144,7 @@ pub enum AttributeType { GroupCurveB = 10, LifeType = 11, LifeDuration = 12, - PRF = 13, + Prf = 13, KeyLength = 14, FieldSize = 15, GroupOrder = 16, @@ -165,7 +165,7 @@ impl fmt::Display for AttributeType { 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"), @@ -351,7 +351,7 @@ fn get_attribute_type(v: u16) -> AttributeType { 10 => AttributeType::GroupCurveB, 11 => AttributeType::LifeType, 12 => AttributeType::LifeDuration, - 13 => AttributeType::PRF, + 13 => AttributeType::Prf, 14 => AttributeType::KeyLength, 15 => AttributeType::FieldSize, 16 => AttributeType::GroupOrder, diff --git a/rust/src/lib.rs b/rust/src/lib.rs index a9bff56436..d74f88527b 100644 --- a/rust/src/lib.rs +++ b/rust/src/lib.rs @@ -31,7 +31,6 @@ #![allow(clippy::module_inception)] #![allow(clippy::result_unit_err)] #![allow(clippy::type_complexity)] -#![allow(clippy::upper_case_acronyms)] #[macro_use] extern crate bitflags;