dhcp: cleanup visibility and naming

- remove "rs_" prefix from functions that are not exported
- prefix exported functions with "SC"
- don't export functions that are only used by pointer

Ticket: 7498

diff --git a/rust/src/dhcp/detect.rs b/rust/src/dhcp/detect.rs
index 7c458da4e92689c2969c38ba3e2b154dc6966ace..9c8fe581d47b1c622151d07d2a8ee0dd1bb2c7bd 100644 (file)
--- a/rust/src/dhcp/detect.rs
+++ b/rust/src/dhcp/detect.rs
@@ -29,7 +29,7 @@ use crate::detect::{
 };
 use std::os::raw::{c_int, c_void};
 
-fn rs_dhcp_tx_get_time(tx: &DHCPTransaction, code: u8) -> Option<u64> {
+fn dhcp_tx_get_time(tx: &DHCPTransaction, code: u8) -> Option<u64> {
     for option in &tx.message.options {
         if option.code == code {
             if let DHCPOptionWrapper::TimeValue(ref time_value) = option.option {
@@ -78,7 +78,7 @@ unsafe extern "C" fn dhcp_detect_leasetime_match(
 ) -> c_int {
     let tx = cast_pointer!(tx, DHCPTransaction);
     let ctx = cast_pointer!(ctx, DetectUintData<u64>);
-    if let Some(val) = rs_dhcp_tx_get_time(tx, DHCP_OPT_ADDRESS_TIME) {
+    if let Some(val) = dhcp_tx_get_time(tx, DHCP_OPT_ADDRESS_TIME) {
         return rs_detect_u64_match(val, ctx);
     }
     return 0;
@@ -121,7 +121,7 @@ unsafe extern "C" fn dhcp_detect_rebindingtime_match(
 ) -> c_int {
     let tx = cast_pointer!(tx, DHCPTransaction);
     let ctx = cast_pointer!(ctx, DetectUintData<u64>);
-    if let Some(val) = rs_dhcp_tx_get_time(tx, DHCP_OPT_REBINDING_TIME) {
+    if let Some(val) = dhcp_tx_get_time(tx, DHCP_OPT_REBINDING_TIME) {
         return rs_detect_u64_match(val, ctx);
     }
     return 0;
@@ -158,14 +158,14 @@ unsafe extern "C" fn dhcp_detect_renewaltime_match(
 ) -> c_int {
     let tx = cast_pointer!(tx, DHCPTransaction);
     let ctx = cast_pointer!(ctx, DetectUintData<u64>);
-    if let Some(val) = rs_dhcp_tx_get_time(tx, DHCP_OPT_RENEWAL_TIME) {
+    if let Some(val) = dhcp_tx_get_time(tx, DHCP_OPT_RENEWAL_TIME) {
         return rs_detect_u64_match(val, ctx);
     }
     return 0;
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn ScDetectDHCPRegister() {
+pub unsafe extern "C" fn SCDetectDHCPRegister() {
     let kw = SCSigTableElmt {
         name: b"dhcp.leasetime\0".as_ptr() as *const libc::c_char,
         desc: b"match DHCP leasetime\0".as_ptr() as *const libc::c_char,

diff --git a/rust/src/dhcp/dhcp.rs b/rust/src/dhcp/dhcp.rs
index 599f188d751d84015232d37f26c3584105abfcb0..ec22c9459278783cf65765497e537ffaeb09ceb8 100644 (file)
--- a/rust/src/dhcp/dhcp.rs
+++ b/rust/src/dhcp/dhcp.rs
@@ -127,7 +127,7 @@ impl DHCPState {
     }
 
     pub fn parse(&mut self, input: &[u8]) -> bool {
-        match dhcp_parse(input) {
+        match parse_dhcp(input) {
             Ok((_, message)) => {
                 let malformed_options = message.malformed_options;
                 let truncated_options = message.truncated_options;
@@ -177,8 +177,7 @@ impl DHCPState {
     }
 }
 
-#[no_mangle]
-pub unsafe extern "C" fn rs_dhcp_probing_parser(_flow: *const Flow,
+unsafe extern "C" fn dhcp_probing_parser(_flow: *const Flow,
                                          _direction: u8,
                                          input: *const u8,
                                          input_len: u32,
@@ -199,15 +198,13 @@ pub unsafe extern "C" fn rs_dhcp_probing_parser(_flow: *const Flow,
     }
 }
 
-#[no_mangle]
-pub extern "C" fn rs_dhcp_tx_get_alstate_progress(_tx: *mut std::os::raw::c_void,
+extern "C" fn dhcp_tx_get_alstate_progress(_tx: *mut std::os::raw::c_void,
                                                   _direction: u8) -> std::os::raw::c_int {
     // As this is a stateless parser, simply use 1.
     return 1;
 }
 
-#[no_mangle]
-pub unsafe extern "C" fn rs_dhcp_state_get_tx(state: *mut std::os::raw::c_void,
+unsafe extern "C" fn dhcp_state_get_tx(state: *mut std::os::raw::c_void,
                                        tx_id: u64) -> *mut std::os::raw::c_void {
     let state = cast_pointer!(state, DHCPState);
     match state.get_tx(tx_id) {
@@ -220,14 +217,12 @@ pub unsafe extern "C" fn rs_dhcp_state_get_tx(state: *mut std::os::raw::c_void,
     }
 }
 
-#[no_mangle]
-pub unsafe extern "C" fn rs_dhcp_state_get_tx_count(state: *mut std::os::raw::c_void) -> u64 {
+unsafe extern "C" fn dhcp_state_get_tx_count(state: *mut std::os::raw::c_void) -> u64 {
     let state = cast_pointer!(state, DHCPState);
     return state.tx_id;
 }
 
-#[no_mangle]
-pub unsafe extern "C" fn rs_dhcp_parse(_flow: *const Flow,
+unsafe extern "C" fn dhcp_parse(_flow: *const Flow,
                                 state: *mut std::os::raw::c_void,
                                 _pstate: *mut std::os::raw::c_void,
                                 stream_slice: StreamSlice,
@@ -240,8 +235,7 @@ pub unsafe extern "C" fn rs_dhcp_parse(_flow: *const Flow,
     return AppLayerResult::err();
 }
 
-#[no_mangle]
-pub unsafe extern "C" fn rs_dhcp_state_tx_free(
+pub unsafe extern "C" fn dhcp_state_tx_free(
     state: *mut std::os::raw::c_void,
     tx_id: u64)
 {
@@ -249,15 +243,13 @@ pub unsafe extern "C" fn rs_dhcp_state_tx_free(
     state.free_tx(tx_id);
 }
 
-#[no_mangle]
-pub extern "C" fn rs_dhcp_state_new(_orig_state: *mut std::os::raw::c_void, _orig_proto: AppProto) -> *mut std::os::raw::c_void {
+extern "C" fn dhcp_state_new(_orig_state: *mut std::os::raw::c_void, _orig_proto: AppProto) -> *mut std::os::raw::c_void {
     let state = DHCPState::new();
     let boxed = Box::new(state);
     return Box::into_raw(boxed) as *mut _;
 }
 
-#[no_mangle]
-pub unsafe extern "C" fn rs_dhcp_state_free(state: *mut std::os::raw::c_void) {
+unsafe extern "C" fn dhcp_state_free(state: *mut std::os::raw::c_void) {
     std::mem::drop(Box::from_raw(state as *mut DHCPState));
 }
 
@@ -267,27 +259,27 @@ export_state_data_get!(dhcp_get_state_data, DHCPState);
 const PARSER_NAME: &[u8] = b"dhcp\0";
 
 #[no_mangle]
-pub unsafe extern "C" fn rs_dhcp_register_parser() {
+pub unsafe extern "C" fn SCRegisterDhcpParser() {
     SCLogDebug!("Registering DHCP parser.");
     let ports = CString::new("[67,68]").unwrap();
     let parser = RustParser {
         name: PARSER_NAME.as_ptr() as *const std::os::raw::c_char,
         default_port       : ports.as_ptr(),
         ipproto            : IPPROTO_UDP,
-        probe_ts           : Some(rs_dhcp_probing_parser),
-        probe_tc           : Some(rs_dhcp_probing_parser),
+        probe_ts           : Some(dhcp_probing_parser),
+        probe_tc           : Some(dhcp_probing_parser),
         min_depth          : 0,
         max_depth          : 16,
-        state_new          : rs_dhcp_state_new,
-        state_free         : rs_dhcp_state_free,
-        tx_free            : rs_dhcp_state_tx_free,
-        parse_ts           : rs_dhcp_parse,
-        parse_tc           : rs_dhcp_parse,
-        get_tx_count       : rs_dhcp_state_get_tx_count,
-        get_tx             : rs_dhcp_state_get_tx,
+        state_new          : dhcp_state_new,
+        state_free         : dhcp_state_free,
+        tx_free            : dhcp_state_tx_free,
+        parse_ts           : dhcp_parse,
+        parse_tc           : dhcp_parse,
+        get_tx_count       : dhcp_state_get_tx_count,
+        get_tx             : dhcp_state_get_tx,
         tx_comp_st_ts      : 1,
         tx_comp_st_tc      : 1,
-        tx_get_progress    : rs_dhcp_tx_get_alstate_progress,
+        tx_get_progress    : dhcp_tx_get_alstate_progress,
         get_eventinfo      : Some(DHCPEvent::get_event_info),
         get_eventinfo_byid : Some(DHCPEvent::get_event_info_by_id),
         localstorage_new   : None,

diff --git a/rust/src/dhcp/logger.rs b/rust/src/dhcp/logger.rs
index a9d8d983b6cb49186a106742207ffbb49b1f2bbb..766272a3ac27318488ce512b1332500a08a42fbf 100644 (file)
--- a/rust/src/dhcp/logger.rs
+++ b/rust/src/dhcp/logger.rs
@@ -256,19 +256,19 @@ fn format_addr_hex(input: &[u8]) -> String {
 }
 
 #[no_mangle]
-pub extern "C" fn rs_dhcp_logger_new(conf: *const c_void) -> *mut std::os::raw::c_void {
+pub extern "C" fn SCDhcpLoggerNew(conf: *const c_void) -> *mut std::os::raw::c_void {
     let conf = ConfNode::wrap(conf);
     let boxed = Box::new(DHCPLogger::new(conf));
     return Box::into_raw(boxed) as *mut _;
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn rs_dhcp_logger_free(logger: *mut std::os::raw::c_void) {
+pub unsafe extern "C" fn SCDhcpLoggerFree(logger: *mut std::os::raw::c_void) {
     std::mem::drop(Box::from_raw(logger as *mut DHCPLogger));
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn rs_dhcp_logger_log(logger: *mut std::os::raw::c_void,
+pub unsafe extern "C" fn SCDhcpLoggerLog(logger: *mut std::os::raw::c_void,
                                      tx: *mut std::os::raw::c_void,
                                      js: &mut JsonBuilder) -> bool {
     let logger = cast_pointer!(logger, DHCPLogger);
@@ -277,7 +277,7 @@ pub unsafe extern "C" fn rs_dhcp_logger_log(logger: *mut std::os::raw::c_void,
 }
 
 #[no_mangle]
-pub unsafe extern "C" fn rs_dhcp_logger_do_log(logger: *mut std::os::raw::c_void,
+pub unsafe extern "C" fn SCDhcpLoggerDoLog(logger: *mut std::os::raw::c_void,
                                         tx: *mut std::os::raw::c_void)
                                         -> bool {
     let logger = cast_pointer!(logger, DHCPLogger);

diff --git a/rust/src/dhcp/parser.rs b/rust/src/dhcp/parser.rs
index 698462f301a1b97b18aace91876672a9c383b269..c5de4fd24afdc0e23bdd50bc2b85958f19cbafd6 100644 (file)
--- a/rust/src/dhcp/parser.rs
+++ b/rust/src/dhcp/parser.rs
@@ -195,7 +195,7 @@ pub fn parse_option(i: &[u8]) -> IResult<&[u8], DHCPOption> {
     }
 }
 
-pub fn dhcp_parse(input: &[u8]) -> IResult<&[u8], DHCPMessage> {
+pub fn parse_dhcp(input: &[u8]) -> IResult<&[u8], DHCPMessage> {
     match parse_header(input) {
         Ok((rem, header)) => {
             let mut options = Vec::new();
@@ -242,7 +242,7 @@ mod tests {
         let pcap = include_bytes!("discover.pcap");
         let payload = &pcap[24 + 16 + 42..];
 
-        let (_rem, message) = dhcp_parse(payload).unwrap();
+        let (_rem, message) = parse_dhcp(payload).unwrap();
         let header = message.header;
         assert_eq!(header.opcode, BOOTP_REQUEST);
         assert_eq!(header.htype, 1);

diff --git a/src/app-layer-parser.c b/src/app-layer-parser.c
index 6285b67d256cf9812caadfd1a362b0198da43efa..ec263aeb7859654b209604186d5999ff4d32c9d0 100644 (file)
--- a/src/app-layer-parser.c
+++ b/src/app-layer-parser.c
@@ -1747,7 +1747,7 @@ void AppLayerParserRegisterProtocolParsers(void)
     RegisterTFTPParsers();
     RegisterIKEParsers();
     rs_register_krb5_parser();
-    rs_dhcp_register_parser();
+    SCRegisterDhcpParser();
     rs_register_snmp_parser();
     rs_sip_register_parser();
     rs_quic_register_parser();

diff --git a/src/detect-engine-register.c b/src/detect-engine-register.c
index b9faff49bae8e8dc75bfe3828ce80df68b57f375..9bf86f64b753b8c5ff220deb0abaae0d7862ea82 100644 (file)
--- a/src/detect-engine-register.c
+++ b/src/detect-engine-register.c
@@ -731,7 +731,7 @@ void SigTableSetup(void)
     DetectVlanLayersRegister();
 
     ScDetectSNMPRegister();
-    ScDetectDHCPRegister();
+    SCDetectDHCPRegister();
     ScDetectWebsocketRegister();
     ScDetectEnipRegister();
     ScDetectMqttRegister();

diff --git a/src/output-json-dhcp.c b/src/output-json-dhcp.c
index a4a4a29990e83bdec809deab9f3ec1658ea0477e..b2bccc7999f4a7815cbd70e81634be81ed71d530 100644 (file)
--- a/src/output-json-dhcp.c
+++ b/src/output-json-dhcp.c
@@ -61,7 +61,7 @@ static int JsonDHCPLogger(ThreadVars *tv, void *thread_data,
     LogDHCPLogThread *thread = thread_data;
     LogDHCPFileCtx *ctx = thread->dhcplog_ctx;
 
-    if (!rs_dhcp_logger_do_log(ctx->rs_logger, tx)) {
+    if (!SCDhcpLoggerDoLog(ctx->rs_logger, tx)) {
         return TM_ECODE_OK;
     }
 
@@ -70,7 +70,7 @@ static int JsonDHCPLogger(ThreadVars *tv, void *thread_data,
         return TM_ECODE_FAILED;
     }
 
-    rs_dhcp_logger_log(ctx->rs_logger, tx, js);
+    SCDhcpLoggerLog(ctx->rs_logger, tx, js);
 
     OutputJsonBuilderBuffer(tv, p, p->flow, js, thread->thread);
     jb_free(js);
@@ -81,7 +81,7 @@ static int JsonDHCPLogger(ThreadVars *tv, void *thread_data,
 static void OutputDHCPLogDeInitCtxSub(OutputCtx *output_ctx)
 {
     LogDHCPFileCtx *dhcplog_ctx = (LogDHCPFileCtx *)output_ctx->data;
-    rs_dhcp_logger_free(dhcplog_ctx->rs_logger);
+    SCDhcpLoggerFree(dhcplog_ctx->rs_logger);
     SCFree(dhcplog_ctx);
     SCFree(output_ctx);
 }
@@ -105,7 +105,7 @@ static OutputInitResult OutputDHCPLogInitSub(ConfNode *conf,
     output_ctx->data = dhcplog_ctx;
     output_ctx->DeInit = OutputDHCPLogDeInitCtxSub;
 
-    dhcplog_ctx->rs_logger = rs_dhcp_logger_new(conf);
+    dhcplog_ctx->rs_logger = SCDhcpLoggerNew(conf);
 
     AppLayerParserRegisterLogger(IPPROTO_UDP, ALPROTO_DHCP);