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

dhcp: cleanup visibility and naming

Browse Source 
- 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
pull/12445/head
Jason Ish 1 month ago committed by Victor Julien
parent c86b2608aa
commit c5089ac5f4
7 changed files with 37 additions and 45 deletions
Show Stats Download Patch File Download Diff File

10
rust/src/dhcp/detect.rs
Unescape Escape View File

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

48
rust/src/dhcp/dhcp.rs
Unescape Escape View File

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

8
rust/src/dhcp/logger.rs
Unescape Escape View File

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

4
rust/src/dhcp/parser.rs
Unescape Escape View File

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

2
src/app-layer-parser.c
Unescape Escape View File

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

2
src/detect-engine-register.c
Unescape Escape View File

@ -731,7 +731,7 @@ void SigTableSetup(void)
DetectVlanLayersRegister();
ScDetectSNMPRegister();
ScDetectDHCPRegister();
SCDetectDHCPRegister();
ScDetectWebsocketRegister();
ScDetectEnipRegister();
ScDetectMqttRegister();

8
src/output-json-dhcp.c
Unescape Escape View File

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

Write Preview
Loading…
Cancel
Save