sip: rustfmt

As this is new Rust code, format with rustfmt using default
styling.

rust/src/sip/detect.rs

@@ -17,16 +17,16 @@
 
 // written by Giuseppe Longo <giuseppe@glongo.it>
 
-use std::ptr;
 use core::{STREAM_TOCLIENT, STREAM_TOSERVER};
 use sip::sip::SIPTransaction;
+use std::ptr;
 
 #[no_mangle]
-pub unsafe extern "C" fn rs_sip_tx_get_method(tx:  &mut SIPTransaction,
+pub unsafe extern "C" fn rs_sip_tx_get_method(
+    tx: &mut SIPTransaction,
     buffer: *mut *const u8,
-                                              buffer_len: *mut u32)
-                                              -> u8
-{
+    buffer_len: *mut u32,
+) -> u8 {
     if let Some(ref r) = tx.request {
         let m = &r.method;
         if m.len() > 0 {
@@ -43,11 +43,11 @@ pub unsafe extern "C" fn rs_sip_tx_get_method(tx:  &mut SIPTransaction,
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn rs_sip_tx_get_uri(tx:  &mut SIPTransaction,
+pub unsafe extern "C" fn rs_sip_tx_get_uri(
+    tx: &mut SIPTransaction,
     buffer: *mut *const u8,
-                                           buffer_len: *mut u32)
-                                           -> u8
-{
+    buffer_len: *mut u32,
+) -> u8 {
     if let Some(ref r) = tx.request {
         let p = &r.path;
         if p.len() > 0 {
@@ -64,12 +64,12 @@ pub unsafe extern "C" fn rs_sip_tx_get_uri(tx:  &mut SIPTransaction,
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn rs_sip_tx_get_protocol(tx:  &mut SIPTransaction,
+pub unsafe extern "C" fn rs_sip_tx_get_protocol(
+    tx: &mut SIPTransaction,
     buffer: *mut *const u8,
     buffer_len: *mut u32,
-                                                direction: u8)
-                                                -> u8
-{
+    direction: u8,
+) -> u8 {
     match direction {
         STREAM_TOSERVER => {
             if let Some(ref r) = tx.request {
@@ -101,11 +101,11 @@ pub unsafe extern "C" fn rs_sip_tx_get_protocol(tx:  &mut SIPTransaction,
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn rs_sip_tx_get_stat_code(tx:  &mut SIPTransaction,
+pub unsafe extern "C" fn rs_sip_tx_get_stat_code(
+    tx: &mut SIPTransaction,
     buffer: *mut *const u8,
-                                                 buffer_len: *mut u32)
-                                                 -> u8
-{
+    buffer_len: *mut u32,
+) -> u8 {
     if let Some(ref r) = tx.response {
         let c = &r.code;
         if c.len() > 0 {
@@ -122,11 +122,11 @@ pub unsafe extern "C" fn rs_sip_tx_get_stat_code(tx:  &mut SIPTransaction,
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn rs_sip_tx_get_stat_msg(tx:  &mut SIPTransaction,
+pub unsafe extern "C" fn rs_sip_tx_get_stat_msg(
+    tx: &mut SIPTransaction,
     buffer: *mut *const u8,
-                                                buffer_len: *mut u32)
-                                                -> u8
-{
+    buffer_len: *mut u32,
+) -> u8 {
     if let Some(ref r) = tx.response {
         let re = &r.reason;
         if re.len() > 0 {
@@ -143,11 +143,11 @@ pub unsafe extern "C" fn rs_sip_tx_get_stat_msg(tx:  &mut SIPTransaction,
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn rs_sip_tx_get_request_line(tx:  &mut SIPTransaction,
+pub unsafe extern "C" fn rs_sip_tx_get_request_line(
+    tx: &mut SIPTransaction,
     buffer: *mut *const u8,
-                                                    buffer_len: *mut u32)
-                                                    -> u8
-{
+    buffer_len: *mut u32,
+) -> u8 {
     if let Some(ref r) = tx.request_line {
         if r.len() > 0 {
             *buffer = r.as_ptr();
@@ -163,11 +163,11 @@ pub unsafe extern "C" fn rs_sip_tx_get_request_line(tx:  &mut SIPTransaction,
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn rs_sip_tx_get_response_line(tx:  &mut SIPTransaction,
+pub unsafe extern "C" fn rs_sip_tx_get_response_line(
+    tx: &mut SIPTransaction,
     buffer: *mut *const u8,
-                                                     buffer_len: *mut u32)
-                                                     -> u8
-{
+    buffer_len: *mut u32,
+) -> u8 {
     if let Some(ref r) = tx.response_line {
         if r.len() > 0 {
             *buffer = r.as_ptr();

rust/src/sip/log.rs

@@ -21,8 +21,7 @@ use json::*;
 use sip::sip::{SIPState, SIPTransaction};
 
 #[no_mangle]
-pub extern "C" fn rs_sip_log_json(_state: &mut SIPState, tx: &mut SIPTransaction) -> *mut JsonT
-{
+pub extern "C" fn rs_sip_log_json(_state: &mut SIPState, tx: &mut SIPTransaction) -> *mut JsonT {
     let js = Json::object();
 
     match tx.request {
@@ -30,13 +29,13 @@ pub extern "C" fn rs_sip_log_json(_state: &mut SIPState, tx: &mut SIPTransaction
             js.set_string("method", &req.method);
             js.set_string("uri", &req.path);
             js.set_string("version", &req.version);
-        },
+        }
         None => {}
     }
     match tx.request_line {
         Some(ref req_line) => {
             js.set_string("request_line", &req_line);
-        },
+        }
         None => {}
     }
     match tx.response {
@@ -44,13 +43,13 @@ pub extern "C" fn rs_sip_log_json(_state: &mut SIPState, tx: &mut SIPTransaction
             js.set_string("version", &resp.version);
             js.set_string("code", &resp.code);
             js.set_string("reason", &resp.reason);
-        },
+        }
         None => {}
     }
     match tx.response_line {
         Some(ref resp_line) => {
             js.set_string("response_line", &resp_line);
-        },
+        }
         None => {}
     }
 

rust/src/sip/mod.rs

@@ -17,7 +17,7 @@
 
 // written by Giuseppe Longo <giuseppe@glongo.it>
 
-pub mod sip;
-pub mod parser;
-pub mod log;
 pub mod detect;
+pub mod log;
+pub mod parser;
+pub mod sip;

rust/src/sip/parser.rs

@@ -17,10 +17,10 @@
 
 // written by Giuseppe Longo <giuseppe@glono.it>
 
+use nom::*;
+use nom::{crlf, IResult};
 use std;
 use std::collections::HashMap;
-use nom::{IResult,crlf};
-use nom::*;
 
 #[derive(Debug)]
 pub struct Header {
@@ -33,14 +33,14 @@ pub struct Request {
     pub method: String,
     pub path: String,
     pub version: String,
-    pub headers: HashMap<String, String>
+    pub headers: HashMap<String, String>,
 }
 
 #[derive(Debug)]
 pub struct Response {
     pub version: String,
     pub code: String,
-    pub reason: String
+    pub reason: String,
 }
 
 #[derive(PartialEq, Debug, Clone)]
@@ -130,19 +130,24 @@ named!(#[inline], header_value<&[u8], &str>,
     map_res!(parse_header_value, std::str::from_utf8)
 );
 
-named!(hcolon<char>, delimited!(
-    take_while!(is_space),
-    char!(':'),
-    take_while!(is_space)
-));
+named!(
+    hcolon<char>,
+    delimited!(take_while!(is_space), char!(':'), take_while!(is_space))
+);
 
-named!(message_header<Header>, do_parse!(
-    n: header_name >>
-    hcolon >>
-    v: header_value >>
-    crlf >>
-    (Header{ name: String::from(n), value: String::from(v) })
-));
+named!(
+    message_header<Header>,
+    do_parse!(
+        n: header_name
+            >> hcolon
+            >> v: header_value
+            >> crlf
+            >> (Header {
+                name: String::from(n),
+                value: String::from(v)
+            })
+    )
+);
 
 named!(pub sip_take_line<&[u8], Option<String> >,
     do_parse!(
@@ -151,8 +156,7 @@ named!(pub sip_take_line<&[u8], Option<String> >,
     )
 );
 
-pub fn parse_headers(mut input: &[u8]) -> IResult<&[u8],HashMap<String, String>>
-{
+pub fn parse_headers(mut input: &[u8]) -> IResult<&[u8], HashMap<String, String>> {
     let mut headers_map: HashMap<String, String> = HashMap::new();
     loop {
         match crlf(input) {
@@ -215,7 +219,8 @@ mod tests {
                           From: <sip:voi18063@sip.cybercity.dk>;tag=903df0a\r\n\
                           To: <sip:voi18063@sip.cybercity.dk>\r\n\
                           Content-Length: 0\r\n\
-                          \r\n".as_bytes();
+                          \r\n"
+            .as_bytes();
 
         match sip_parse_request(buf) {
             Ok((_, req)) => {
@@ -233,7 +238,8 @@ mod tests {
     #[test]
     fn test_parse_response() {
         let buf: &[u8] = "SIP/2.0 401 Unauthorized\r\n\
-                          \r\n".as_bytes();
+                          \r\n"
+            .as_bytes();
 
         match sip_parse_response(buf) {
             Ok((_, resp)) => {

rust/src/sip/sip.rs

@@ -19,15 +19,15 @@
 
 extern crate nom;
 
-use std;
-use std::ffi::{CStr,CString};
 use applayer;
+use conf;
 use core;
-use core::{AppProto,Flow,ALPROTO_UNKNOWN,sc_detect_engine_state_free};
-use parser::*;
+use core::{sc_detect_engine_state_free, AppProto, Flow, ALPROTO_UNKNOWN};
 use log::*;
+use parser::*;
 use sip::parser::*;
-use conf;
+use std;
+use std::ffi::{CStr, CString};
 
 #[repr(u32)]
 pub enum SIPEvent {
@@ -83,7 +83,10 @@ impl SIPState {
     }
 
     fn free_tx(&mut self, tx_id: u64) {
-        let tx = self.transactions.iter().position(|ref tx| tx.id == tx_id + 1);
+        let tx = self
+            .transactions
+            .iter()
+            .position(|ref tx| tx.id == tx_id + 1);
         debug_assert!(tx != None);
         if let Some(idx) = tx {
             let _ = self.transactions.remove(idx);
@@ -182,10 +185,10 @@ pub extern "C" fn rs_sip_state_free(state: *mut std::os::raw::c_void) {
 }
 
 #[no_mangle]
-pub extern "C" fn rs_sip_state_get_tx(state: *mut std::os::raw::c_void,
-                                      tx_id: u64)
-                                      -> *mut std::os::raw::c_void
-{
+pub extern "C" fn rs_sip_state_get_tx(
+    state: *mut std::os::raw::c_void,
+    tx_id: u64,
+) -> *mut std::os::raw::c_void {
     let state = cast_pointer!(state, SIPState);
     match state.get_tx_by_id(tx_id) {
         Some(tx) => unsafe { std::mem::transmute(tx) },
@@ -194,61 +197,54 @@ pub extern "C" fn rs_sip_state_get_tx(state: *mut std::os::raw::c_void,
 }
 
 #[no_mangle]
-pub extern "C" fn rs_sip_state_get_tx_count(state: *mut std::os::raw::c_void)
-                                            -> u64
-{
+pub extern "C" fn rs_sip_state_get_tx_count(state: *mut std::os::raw::c_void) -> u64 {
     let state = cast_pointer!(state, SIPState);
     state.tx_id
 }
 
 #[no_mangle]
-pub extern "C" fn rs_sip_state_tx_free(state: *mut std::os::raw::c_void,
-                                       tx_id: u64)
-{
+pub extern "C" fn rs_sip_state_tx_free(state: *mut std::os::raw::c_void, tx_id: u64) {
     let state = cast_pointer!(state, SIPState);
     state.free_tx(tx_id);
 }
 
 #[no_mangle]
-pub extern "C" fn rs_sip_state_progress_completion_status(
-    _direction: u8)
-    -> std::os::raw::c_int
-{
+pub extern "C" fn rs_sip_state_progress_completion_status(_direction: u8) -> std::os::raw::c_int {
     return 1;
 }
 
 #[no_mangle]
-pub extern "C" fn rs_sip_tx_get_alstate_progress(_tx: *mut std::os::raw::c_void,
-                                                 _direction: u8)
-                                                 -> std::os::raw::c_int
-{
+pub extern "C" fn rs_sip_tx_get_alstate_progress(
+    _tx: *mut std::os::raw::c_void,
+    _direction: u8,
+) -> std::os::raw::c_int {
     1
 }
 
 #[no_mangle]
-pub extern "C" fn rs_sip_tx_set_logged(_state: *mut std::os::raw::c_void,
+pub extern "C" fn rs_sip_tx_set_logged(
+    _state: *mut std::os::raw::c_void,
     tx: *mut std::os::raw::c_void,
-                                       logged: u32)
-{
+    logged: u32,
+) {
     let tx = cast_pointer!(tx, SIPTransaction);
     tx.logged.set(logged);
 }
 
 #[no_mangle]
-pub extern "C" fn rs_sip_tx_get_logged(_state: *mut std::os::raw::c_void,
-                                       tx: *mut std::os::raw::c_void)
-                                       -> u32
-{
+pub extern "C" fn rs_sip_tx_get_logged(
+    _state: *mut std::os::raw::c_void,
+    tx: *mut std::os::raw::c_void,
+) -> u32 {
     let tx = cast_pointer!(tx, SIPTransaction);
     return tx.logged.get();
 }
 
-
 #[no_mangle]
 pub extern "C" fn rs_sip_state_set_tx_detect_state(
     tx: *mut std::os::raw::c_void,
-    de_state: &mut core::DetectEngineState) -> std::os::raw::c_int
-{
+    de_state: &mut core::DetectEngineState,
+) -> std::os::raw::c_int {
     let tx = cast_pointer!(tx, SIPTransaction);
     tx.de_state = Some(de_state);
     0
@@ -256,9 +252,8 @@ pub extern "C" fn rs_sip_state_set_tx_detect_state(
 
 #[no_mangle]
 pub extern "C" fn rs_sip_state_get_tx_detect_state(
-    tx: *mut std::os::raw::c_void)
-    -> *mut core::DetectEngineState
-{
+    tx: *mut std::os::raw::c_void,
+) -> *mut core::DetectEngineState {
     let tx = cast_pointer!(tx, SIPTransaction);
     match tx.de_state {
         Some(ds) => ds,
@@ -266,22 +261,23 @@ pub extern "C" fn rs_sip_state_get_tx_detect_state(
     }
 }
 
-
 #[no_mangle]
-pub extern "C" fn rs_sip_state_get_events(tx: *mut std::os::raw::c_void)
-                                          -> *mut core::AppLayerDecoderEvents
-{
+pub extern "C" fn rs_sip_state_get_events(
+    tx: *mut std::os::raw::c_void,
+) -> *mut core::AppLayerDecoderEvents {
     let tx = cast_pointer!(tx, SIPTransaction);
-    return tx.events
+    return tx.events;
 }
 
 #[no_mangle]
-pub extern "C" fn rs_sip_state_get_event_info(event_name: *const std::os::raw::c_char,
+pub extern "C" fn rs_sip_state_get_event_info(
+    event_name: *const std::os::raw::c_char,
     event_id: *mut std::os::raw::c_int,
-                                              event_type: *mut core::AppLayerEventType)
-                                              -> std::os::raw::c_int
-{
-    if event_name == std::ptr::null() { return -1; }
+    event_type: *mut core::AppLayerEventType,
+) -> std::os::raw::c_int {
+    if event_name == std::ptr::null() {
+        return -1;
+    }
     let c_event_name: &CStr = unsafe { CStr::from_ptr(event_name) };
     let event = match c_event_name.to_str() {
         Ok(s) => {
@@ -290,7 +286,7 @@ pub extern "C" fn rs_sip_state_get_event_info(event_name: *const std::os::raw::c
                 "invalid_data" => SIPEvent::InvalidData as i32,
                 _ => -1, // unknown event
             }
-        },
+        }
         Err(_) => -1, // UTF-8 conversion failed
     };
     unsafe {
@@ -301,15 +297,15 @@ pub extern "C" fn rs_sip_state_get_event_info(event_name: *const std::os::raw::c
 }
 
 #[no_mangle]
-pub extern "C" fn rs_sip_state_get_event_info_by_id(event_id: std::os::raw::c_int,
+pub extern "C" fn rs_sip_state_get_event_info_by_id(
+    event_id: std::os::raw::c_int,
     event_name: *mut *const std::os::raw::c_char,
-                                                    event_type: *mut core::AppLayerEventType)
-                                                    -> i8
-{
+    event_type: *mut core::AppLayerEventType,
+) -> i8 {
     if let Some(e) = SIPEvent::from_i32(event_id as i32) {
         let estr = match e {
-            SIPEvent::IncompleteData    => { "incomplete_data\0" },
-            SIPEvent::InvalidData       => { "invalid_data\0" },
+            SIPEvent::IncompleteData => "incomplete_data\0",
+            SIPEvent::InvalidData => "invalid_data\0",
         };
         unsafe {
             *event_name = estr.as_ptr() as *const std::os::raw::c_char;
@@ -324,11 +320,13 @@ pub extern "C" fn rs_sip_state_get_event_info_by_id(event_id: std::os::raw::c_in
 static mut ALPROTO_SIP: AppProto = ALPROTO_UNKNOWN;
 
 #[no_mangle]
-pub extern "C" fn rs_sip_probing_parser_ts(_flow: *const Flow,
+pub extern "C" fn rs_sip_probing_parser_ts(
+    _flow: *const Flow,
     _direction: u8,
-        input:*const u8, input_len: u32,
-        _rdir: *mut u8) -> AppProto
-{
+    input: *const u8,
+    input_len: u32,
+    _rdir: *mut u8,
+) -> AppProto {
     let buf = build_slice!(input, input_len as usize);
     if sip_parse_request(buf).is_ok() {
         return unsafe { ALPROTO_SIP };
@@ -337,12 +335,13 @@ pub extern "C" fn rs_sip_probing_parser_ts(_flow: *const Flow,
 }
 
 #[no_mangle]
-pub extern "C" fn rs_sip_probing_parser_tc(_flow: *const Flow,
+pub extern "C" fn rs_sip_probing_parser_tc(
+    _flow: *const Flow,
     _direction: u8,
     input: *const u8,
     input_len: u32,
-                                           _rdir: *mut u8) -> AppProto
-{
+    _rdir: *mut u8,
+) -> AppProto {
     let buf = build_slice!(input, input_len as usize);
     if sip_parse_response(buf).is_ok() {
         return unsafe { ALPROTO_SIP };
@@ -351,13 +350,15 @@ pub extern "C" fn rs_sip_probing_parser_tc(_flow: *const Flow,
 }
 
 #[no_mangle]
-pub extern "C" fn rs_sip_parse_request(_flow: *const core::Flow,
+pub extern "C" fn rs_sip_parse_request(
+    _flow: *const core::Flow,
     state: *mut std::os::raw::c_void,
     _pstate: *mut std::os::raw::c_void,
     input: *const u8,
     input_len: u32,
     _data: *const std::os::raw::c_void,
-                                       _flags: u8) -> i32 {
+    _flags: u8,
+) -> i32 {
     let buf = build_slice!(input, input_len as usize);
     let state = cast_pointer!(state, SIPState);
     if state.parse_request(buf) {
@@ -368,13 +369,15 @@ pub extern "C" fn rs_sip_parse_request(_flow: *const core::Flow,
 }
 
 #[no_mangle]
-pub extern "C" fn rs_sip_parse_response(_flow: *const core::Flow,
+pub extern "C" fn rs_sip_parse_response(
+    _flow: *const core::Flow,
     state: *mut std::os::raw::c_void,
     _pstate: *mut std::os::raw::c_void,
     input: *const u8,
     input_len: u32,
     _data: *const std::os::raw::c_void,
-                                       _flags: u8) -> i32 {
+    _flags: u8,
+) -> i32 {
     let buf = build_slice!(input, input_len as usize);
     let state = cast_pointer!(state, SIPState);
     if state.parse_response(buf) {