aiden
/
suricata
mirror of https://github.com/OISF/suricata
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

rust/clippy: fix lint: upper_case_acronyms

Browse Source
pull/8251/head
Jason Ish 2 years ago committed by Victor Julien
parent 029ac650d7
commit 7ba2dadc7f
7 changed files with 110 additions and 111 deletions
Show Stats Download Patch File Download Diff File

36
rust/src/http2/decompression.rs
Unescape Escape View File

@ -80,23 +80,23 @@ impl Read for HTTP2cursor {
}
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"),
}
}
}
@ -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<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;
}

6
rust/src/http2/detect.rs
Unescape Escape View File

@ -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,

36
rust/src/http2/http2.rs
Unescape Escape View File

@ -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;
}

4
rust/src/http2/logger.rs
Unescape Escape View File

@ -112,7 +112,7 @@ fn log_http2_frames(frames: &[HTTP2Frame], js: &mut JsonBuilder) -> Result<bool,
}
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()?;
}
@ -133,7 +133,7 @@ fn log_http2_frames(frames: &[HTTP2Frame], js: &mut JsonBuilder) -> Result<bool,
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

132
rust/src/http2/parser.rs
Unescape Escape View File

@ -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);

6
rust/src/ike/parser.rs
Unescape Escape View File

@ -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,

1
rust/src/lib.rs
Unescape Escape View File

@ -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;

Write Preview
Loading…
Cancel
Save