http2: rustfmt

rust/src/http2/decompression.rs

@@ -178,10 +178,12 @@ 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(

rust/src/http2/detect.rs

@@ -627,16 +627,14 @@ fn http2_normalize_host(value: &[u8]) -> &[u8] {
                 }
             }
         }
-        None => {
-            match value.iter().position(|&x| x == b':') {
+        None => match value.iter().position(|&x| x == b':') {
             Some(i) => {
                 return &value[..i];
             }
             None => {
                 return value;
             }
-            }
-        }
+        },
     }
 }
 

rust/src/http2/http2.rs

@@ -239,7 +239,8 @@ impl HTTP2Transaction {
     }
 
     fn decompress<'a>(
-        &'a mut self, input: &'a [u8], dir: Direction, sfcm: &'static SuricataFileContext, over: bool, flow: *const Flow,
+        &'a mut self, input: &'a [u8], dir: Direction, sfcm: &'static SuricataFileContext,
+        over: bool, flow: *const Flow,
     ) -> io::Result<()> {
         let mut output = Vec::with_capacity(decompression::HTTP2_DECOMPRESSION_CHUNK_SIZE);
         let decompressed = self.decoder.decompress(input, &mut output, dir)?;
@@ -258,7 +259,14 @@ impl HTTP2Transaction {
                 ) {
                     match range::http2_parse_check_content_range(&value) {
                         Ok((_, v)) => {
-                            range::http2_range_open(self, &v, flow, sfcm, Direction::ToClient, decompressed);
+                            range::http2_range_open(
+                                self,
+                                &v,
+                                flow,
+                                sfcm,
+                                Direction::ToClient,
+                                decompressed,
+                            );
                             if over && !self.file_range.is_null() {
                                 range::http2_range_close(self, Direction::ToClient, &[])
                             }
@@ -688,9 +696,7 @@ impl HTTP2State {
         for block in blocks {
             if block.error >= parser::HTTP2HeaderDecodeStatus::HTTP2HeaderDecodeError {
                 self.set_event(HTTP2Event::InvalidHeader);
-            } else if block.error
-                == parser::HTTP2HeaderDecodeStatus::HTTP2HeaderDecodeSizeUpdate
-            {
+            } else if block.error == parser::HTTP2HeaderDecodeStatus::HTTP2HeaderDecodeSizeUpdate {
                 update = true;
                 if block.sizeupdate > sizeup {
                     sizeup = block.sizeupdate;
@@ -1090,12 +1096,7 @@ impl HTTP2State {
                                     if padded && !rem.is_empty() && usize::from(rem[0]) < hlsafe {
                                         dinput = &rem[1..hlsafe - usize::from(rem[0])];
                                     }
-                                    if tx_same.decompress(
-                                        dinput,
-                                        dir,
-                                        sfcm,
-                                        over,
-                                        flow).is_err() {
+                                    if tx_same.decompress(dinput, dir, sfcm, over, flow).is_err() {
                                         self.set_event(HTTP2Event::FailedDecompression);
                                     }
                                 }
@@ -1324,9 +1325,15 @@ pub unsafe extern "C" fn rs_http2_getfiles(
     let tx = cast_pointer!(tx, HTTP2Transaction);
     if let Some(sfcm) = { SURICATA_HTTP2_FILE_CONFIG } {
         if direction & STREAM_TOSERVER != 0 {
-            return AppLayerGetFileState { fc: &mut tx.ft_ts.file, cfg: sfcm.files_sbcfg }
+            return AppLayerGetFileState {
+                fc: &mut tx.ft_ts.file,
+                cfg: sfcm.files_sbcfg,
+            };
         } else {
-            return AppLayerGetFileState { fc: &mut tx.ft_tc.file, cfg: sfcm.files_sbcfg }
+            return AppLayerGetFileState {
+                fc: &mut tx.ft_tc.file,
+                cfg: sfcm.files_sbcfg,
+            };
         }
     }
     AppLayerGetFileState::err()

rust/src/http2/logger.rs

@@ -125,7 +125,10 @@ fn log_http2_frames(frames: &[HTTP2Frame], js: &mut JsonBuilder) -> Result<bool,
             }
             for e in set {
                 js.start_object()?;
-                js.set_string("settings_id", &format!("SETTINGS{}", &e.id.to_string().to_uppercase()))?;
+                js.set_string(
+                    "settings_id",
+                    &format!("SETTINGS{}", &e.id.to_string().to_uppercase()),
+                )?;
                 js.set_uint("settings_value", e.value as u64)?;
                 js.close()?;
             }

rust/src/http2/parser.rs

@@ -463,8 +463,9 @@ fn http2_parse_headers_block_literal_incindex<'a>(
                 while dyn_headers.current_size > dyn_headers.max_size
                     && toremove < dyn_headers.table.len()
                 {
-                    dyn_headers.current_size -=
-                        32 + dyn_headers.table[toremove].name.len() + dyn_headers.table[toremove].value.len();
+                    dyn_headers.current_size -= 32
+                        + dyn_headers.table[toremove].name.len()
+                        + dyn_headers.table[toremove].value.len();
                     toremove += 1;
                 }
                 dyn_headers.table.drain(0..toremove);

rust/src/http2/range.rs

@@ -131,7 +131,11 @@ pub fn http2_range_open(
         // whole file in one range
         return;
     }
-    let flags = if dir == Direction::ToServer { tx.ft_ts.file_flags } else { tx.ft_tc.file_flags };
+    let flags = if dir == Direction::ToServer {
+        tx.ft_ts.file_flags
+    } else {
+        tx.ft_tc.file_flags
+    };
     if let Ok((key, index)) = http2_range_key_get(tx) {
         let name = &key[index..];
         tx.file_range = unsafe {
@@ -151,15 +155,15 @@ pub fn http2_range_open(
     }
 }
 
-pub fn http2_range_append(cfg: &'static SuricataFileContext, fr: *mut HttpRangeContainerBlock, data: &[u8]) {
+pub fn http2_range_append(
+    cfg: &'static SuricataFileContext, fr: *mut HttpRangeContainerBlock, data: &[u8],
+) {
     unsafe {
         HttpRangeAppendData(cfg.files_sbcfg, fr, data.as_ptr(), data.len() as u32);
     }
 }
 
-pub fn http2_range_close(
-    tx: &mut HTTP2Transaction, dir: Direction, data: &[u8],
-) {
+pub fn http2_range_close(tx: &mut HTTP2Transaction, dir: Direction, data: &[u8]) {
     let added = if let Some(c) = unsafe { SC } {
         if let Some(sfcm) = unsafe { SURICATA_HTTP2_FILE_CONFIG } {
             let (files, flags) = if dir == Direction::ToServer {
@@ -197,7 +201,8 @@ extern "C" {
         data: *const c_uchar, data_len: u32,
     ) -> *mut HttpRangeContainerBlock;
     pub fn HttpRangeAppendData(
-        cfg: *const StreamingBufferConfig, c: *mut HttpRangeContainerBlock, data: *const c_uchar, data_len: u32,
+        cfg: *const StreamingBufferConfig, c: *mut HttpRangeContainerBlock, data: *const c_uchar,
+        data_len: u32,
     ) -> std::os::raw::c_int;
 }