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,
-                                              buffer: *mut *const u8,
-                                              buffer_len: *mut u32)
-                                              -> u8
-{
+pub unsafe extern "C" fn rs_sip_tx_get_method(
+    tx: &mut SIPTransaction,
+    buffer: *mut *const 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,
-                                           buffer: *mut *const u8,
-                                           buffer_len: *mut u32)
-                                           -> u8
-{
+pub unsafe extern "C" fn rs_sip_tx_get_uri(
+    tx: &mut SIPTransaction,
+    buffer: *mut *const 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,
-                                                buffer: *mut *const u8,
-                                                buffer_len: *mut u32,
-                                                direction: u8)
-                                                -> u8
-{
+pub unsafe extern "C" fn rs_sip_tx_get_protocol(
+    tx: &mut SIPTransaction,
+    buffer: *mut *const u8,
+    buffer_len: *mut u32,
+    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,
-                                                 buffer: *mut *const u8,
-                                                 buffer_len: *mut u32)
-                                                 -> u8
-{
+pub unsafe extern "C" fn rs_sip_tx_get_stat_code(
+    tx: &mut SIPTransaction,
+    buffer: *mut *const 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,
-                                                buffer: *mut *const u8,
-                                                buffer_len: *mut u32)
-                                                -> u8
-{
+pub unsafe extern "C" fn rs_sip_tx_get_stat_msg(
+    tx: &mut SIPTransaction,
+    buffer: *mut *const 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,
-                                                    buffer: *mut *const u8,
-                                                    buffer_len: *mut u32)
-                                                    -> u8
-{
+pub unsafe extern "C" fn rs_sip_tx_get_request_line(
+    tx: &mut SIPTransaction,
+    buffer: *mut *const 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,
-                                                     buffer: *mut *const u8,
-                                                     buffer_len: *mut u32)
-                                                     -> u8
-{
+pub unsafe extern "C" fn rs_sip_tx_get_response_line(
+    tx: &mut SIPTransaction,
+    buffer: *mut *const 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) => {
+        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) => {
+        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,17 +33,17 @@ 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)]
+#[derive(PartialEq, Debug, Clone)]
 pub enum Method {
     Register,
     Custom(String),
@@ -74,7 +74,7 @@ fn is_reason_phrase(b: u8) -> bool {
     is_alphanumeric(b) || is_token_char(b) || b"$&(),/:;=?@[\\]^ ".contains(&b)
 }
 
-fn is_header_name(b :u8) -> bool {
+fn is_header_name(b: u8) -> bool {
     is_alphanumeric(b) || is_token_char(b)
 }
 
@@ -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 {
@@ -63,7 +63,7 @@ pub struct SIPTransaction {
 
 impl SIPState {
     pub fn new() -> SIPState {
-        SIPState{
+        SIPState {
             transactions: Vec::new(),
             tx_id: 0,
         }
@@ -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);
@@ -144,7 +147,7 @@ impl SIPState {
 
 impl SIPTransaction {
     pub fn new(id: u64) -> SIPTransaction {
-        SIPTransaction{
+        SIPTransaction {
             id: id,
             de_state: None,
             request: None,
@@ -172,128 +175,121 @@ impl Drop for SIPTransaction {
 pub extern "C" fn rs_sip_state_new() -> *mut std::os::raw::c_void {
     let state = SIPState::new();
     let boxed = Box::new(state);
-    return unsafe{std::mem::transmute(boxed)};
+    return unsafe { std::mem::transmute(boxed) };
 }
 
 #[no_mangle]
 pub extern "C" fn rs_sip_state_free(state: *mut std::os::raw::c_void) {
-    let mut state: Box<SIPState> = unsafe{std::mem::transmute(state)};
+    let mut state: Box<SIPState> = unsafe { std::mem::transmute(state) };
     state.free();
 }
 
 #[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
-{
-    let state = cast_pointer!(state,SIPState);
+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)},
-        None     => std::ptr::null_mut(),
+        Some(tx) => unsafe { std::mem::transmute(tx) },
+        None => std::ptr::null_mut(),
     }
 }
 
 #[no_mangle]
-pub extern "C" fn rs_sip_state_get_tx_count(state: *mut std::os::raw::c_void)
-                                            -> u64
-{
-    let state = cast_pointer!(state,SIPState);
+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)
-{
-    let state = cast_pointer!(state,SIPState);
+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,
-                                       tx: *mut std::os::raw::c_void,
-                                       logged: u32)
-{
-    let tx = cast_pointer!(tx,SIPTransaction);
+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,
+) {
+    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
-{
-    let tx = cast_pointer!(tx,SIPTransaction);
+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
-{
-    let tx = cast_pointer!(tx,SIPTransaction);
+    de_state: &mut core::DetectEngineState,
+) -> std::os::raw::c_int {
+    let tx = cast_pointer!(tx, SIPTransaction);
     tx.de_state = Some(de_state);
     0
 }
 
 #[no_mangle]
 pub extern "C" fn rs_sip_state_get_tx_detect_state(
-    tx: *mut std::os::raw::c_void)
-    -> *mut core::DetectEngineState
-{
-    let tx = cast_pointer!(tx,SIPTransaction);
+    tx: *mut std::os::raw::c_void,
+) -> *mut core::DetectEngineState {
+    let tx = cast_pointer!(tx, SIPTransaction);
     match tx.de_state {
         Some(ds) => ds,
         None => std::ptr::null_mut(),
     }
 }
 
-
 #[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,
-                                              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; }
+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;
+    }
     let c_event_name: &CStr = unsafe { CStr::from_ptr(event_name) };
     let event = match c_event_name.to_str() {
         Ok(s) => {
             match s {
-                "incomplete_data"     => SIPEvent::IncompleteData as i32,
-                "invalid_data"        => SIPEvent::InvalidData as i32,
-                _                     => -1, // unknown event
+                "incomplete_data" => SIPEvent::IncompleteData as i32,
+                "invalid_data" => SIPEvent::InvalidData as i32,
+                _ => -1, // unknown event
             }
-        },
+        }
         Err(_) => -1, // UTF-8 conversion failed
     };
-    unsafe{
+    unsafe {
         *event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
         *event_id = event as std::os::raw::c_int;
     };
@@ -301,17 +297,17 @@ 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,
-                                                    event_name: *mut *const std::os::raw::c_char,
-                                                    event_type: *mut core::AppLayerEventType)
-                                                    -> i8
-{
+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 {
     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{
+        unsafe {
             *event_name = estr.as_ptr() as *const std::os::raw::c_char;
             *event_type = core::APP_LAYER_EVENT_TYPE_TRANSACTION;
         };
@@ -321,28 +317,31 @@ 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;
+static mut ALPROTO_SIP: AppProto = ALPROTO_UNKNOWN;
 
 #[no_mangle]
-pub extern "C" fn rs_sip_probing_parser_ts(_flow: *const Flow,
-        _direction: u8,
-        input:*const u8, input_len: u32,
-        _rdir: *mut u8) -> AppProto
-{
+pub extern "C" fn rs_sip_probing_parser_ts(
+    _flow: *const Flow,
+    _direction: u8,
+    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 };
+        return unsafe { ALPROTO_SIP };
     }
     return ALPROTO_UNKNOWN;
 }
 
 #[no_mangle]
-pub extern "C" fn rs_sip_probing_parser_tc(_flow: *const Flow,
-                                           _direction: u8,
-                                           input: *const u8,
-                                           input_len: u32,
-                                           _rdir: *mut u8) -> AppProto
-{
+pub extern "C" fn rs_sip_probing_parser_tc(
+    _flow: *const Flow,
+    _direction: u8,
+    input: *const u8,
+    input_len: u32,
+    _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,15 +350,17 @@ 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,
-                                       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 {
-    let buf = build_slice!(input,input_len as usize);
-    let state = cast_pointer!(state,SIPState);
+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 {
+    let buf = build_slice!(input, input_len as usize);
+    let state = cast_pointer!(state, SIPState);
     if state.parse_request(buf) {
         1
     } else {
@@ -368,15 +369,17 @@ 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,
-                                       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 {
-    let buf = build_slice!(input,input_len as usize);
-    let state = cast_pointer!(state,SIPState);
+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 {
+    let buf = build_slice!(input, input_len as usize);
+    let state = cast_pointer!(state, SIPState);
     if state.parse_response(buf) {
         1
     } else {
@@ -384,41 +387,41 @@ pub extern "C" fn rs_sip_parse_response(_flow: *const core::Flow,
     }
 }
 
-const PARSER_NAME : &'static [u8] = b"sip\0";
+const PARSER_NAME: &'static [u8] = b"sip\0";
 
 #[no_mangle]
 pub unsafe extern "C" fn rs_sip_register_parser() {
     let default_port = CString::new("5060").unwrap();
     let parser = RustParser {
-        name               : PARSER_NAME.as_ptr() as *const std::os::raw::c_char,
-        default_port       : default_port.as_ptr(),
-        ipproto            : core::IPPROTO_UDP,
-        probe_ts           : rs_sip_probing_parser_ts,
-        probe_tc           : rs_sip_probing_parser_tc,
-        min_depth          : 0,
-        max_depth          : 16,
-        state_new          : rs_sip_state_new,
-        state_free         : rs_sip_state_free,
-        tx_free            : rs_sip_state_tx_free,
-        parse_ts           : rs_sip_parse_request,
-        parse_tc           : rs_sip_parse_response,
-        get_tx_count       : rs_sip_state_get_tx_count,
-        get_tx             : rs_sip_state_get_tx,
-        tx_get_comp_st     : rs_sip_state_progress_completion_status,
-        tx_get_progress    : rs_sip_tx_get_alstate_progress,
-        get_tx_logged      : Some(rs_sip_tx_get_logged),
-        set_tx_logged      : Some(rs_sip_tx_set_logged),
-        get_de_state       : rs_sip_state_get_tx_detect_state,
-        set_de_state       : rs_sip_state_set_tx_detect_state,
-        get_events         : Some(rs_sip_state_get_events),
-        get_eventinfo      : Some(rs_sip_state_get_event_info),
-        get_eventinfo_byid : Some(rs_sip_state_get_event_info_by_id),
-        localstorage_new   : None,
-        localstorage_free  : None,
-        get_tx_mpm_id      : None,
-        set_tx_mpm_id      : None,
-        get_files          : None,
-        get_tx_iterator    : None,
+        name: PARSER_NAME.as_ptr() as *const std::os::raw::c_char,
+        default_port: default_port.as_ptr(),
+        ipproto: core::IPPROTO_UDP,
+        probe_ts: rs_sip_probing_parser_ts,
+        probe_tc: rs_sip_probing_parser_tc,
+        min_depth: 0,
+        max_depth: 16,
+        state_new: rs_sip_state_new,
+        state_free: rs_sip_state_free,
+        tx_free: rs_sip_state_tx_free,
+        parse_ts: rs_sip_parse_request,
+        parse_tc: rs_sip_parse_response,
+        get_tx_count: rs_sip_state_get_tx_count,
+        get_tx: rs_sip_state_get_tx,
+        tx_get_comp_st: rs_sip_state_progress_completion_status,
+        tx_get_progress: rs_sip_tx_get_alstate_progress,
+        get_tx_logged: Some(rs_sip_tx_get_logged),
+        set_tx_logged: Some(rs_sip_tx_set_logged),
+        get_de_state: rs_sip_state_get_tx_detect_state,
+        set_de_state: rs_sip_state_set_tx_detect_state,
+        get_events: Some(rs_sip_state_get_events),
+        get_eventinfo: Some(rs_sip_state_get_event_info),
+        get_eventinfo_byid: Some(rs_sip_state_get_event_info_by_id),
+        localstorage_new: None,
+        localstorage_free: None,
+        get_tx_mpm_id: None,
+        set_tx_mpm_id: None,
+        get_files: None,
+        get_tx_iterator: None,
     };
 
     /* For 5.0 we want this disabled by default, so check that it