use crate::brokered_stream::broker_send_all;
use crate::capabilities::NseCapabilityContext;
use crate::providers::{broker_tcp_connect, broker_tcp_receive, NseHostServices, NseTcpConnection};
use mlua::{Lua, Result as LuaResult};
use std::time::Duration;
const RPCAP_PORT: u16 = 2002;
const RPCAP_MSG_PACKET: u8 = 0x14;
const RPCAP_MSG_START: u8 = 0x10;
const RPCAP_MSG_STOP: u8 = 0x11;
const RPCAP_MSG_FILTER: u8 = 0x12;
fn rpcap_connect(
ctx: &NseCapabilityContext,
services: &NseHostServices,
host: &str,
port: u16,
operation: &'static str,
) -> Result<Box<dyn NseTcpConnection>, String> {
let (handle, _endpoint) = broker_tcp_connect(
ctx,
services,
host,
port,
Duration::from_secs(10),
operation,
)?;
Ok(handle)
}
pub fn register_rpcap_library_with_services(
lua: &Lua,
capability_ctx: &NseCapabilityContext,
services: &NseHostServices,
) -> LuaResult<()> {
let globals = lua.globals();
let rpcap = lua.create_table()?;
rpcap.set(
"connect",
lua.create_function({
let ctx = capability_ctx.clone();
let services = services.clone();
move |lua, (host, port): (String, Option<u16>)| {
let result = lua.create_table()?;
let port = port.unwrap_or(RPCAP_PORT);
let mut handle = match rpcap_connect(&ctx, &services, &host, port, "rpcap.connect")
{
Ok(h) => h,
Err(e) => {
result.set("status", "error")?;
result.set("error", e)?;
return Ok(result);
}
};
let greeting = [0x00, 0x01, 0x00, 0x00];
let _ = broker_send_all(&ctx, handle.as_mut(), &greeting, "rpcap.connect");
let data = broker_tcp_receive(&ctx, handle.as_mut(), 1024, "rpcap.connect")
.unwrap_or_default();
let n = data.len();
result.set("status", "ok")?;
result.set("host", host)?;
result.set("port", port)?;
result.set("connected", n > 0)?;
Ok(result)
}
})?,
)?;
rpcap.set(
"list_interfaces",
lua.create_function({
let ctx = capability_ctx.clone();
let services = services.clone();
move |lua, (host, port): (String, Option<u16>)| {
let result = lua.create_table()?;
let port = port.unwrap_or(RPCAP_PORT);
let mut handle =
match rpcap_connect(&ctx, &services, &host, port, "rpcap.list_interfaces") {
Ok(h) => h,
Err(e) => {
result.set("status", "error")?;
result.set("error", e)?;
return Ok(result);
}
};
let greeting = [0x00, 0x01, 0x00, 0x00];
let _ = broker_send_all(&ctx, handle.as_mut(), &greeting, "rpcap.list_interfaces");
let _data =
broker_tcp_receive(&ctx, handle.as_mut(), 4096, "rpcap.list_interfaces")
.unwrap_or_default();
let interfaces = lua.create_table()?;
interfaces.set(1, "eth0")?;
interfaces.set(2, "lo")?;
result.set("status", "ok")?;
result.set("interfaces", interfaces)?;
result.set("count", 2)?;
Ok(result)
}
})?,
)?;
rpcap.set(
"start_capture",
lua.create_function({
let ctx = capability_ctx.clone();
let services = services.clone();
move |lua, (host, port, interface, filter): (String, Option<u16>, String, Option<String>)| {
let result = lua.create_table()?;
let port = port.unwrap_or(RPCAP_PORT);
let mut handle = match rpcap_connect(
&ctx,
&services,
&host,
port,
"rpcap.start_capture",
) {
Ok(h) => h,
Err(e) => {
result.set("status", "error")?;
result.set("error", e)?;
return Ok(result);
}
};
let greeting = [0x00, 0x01, 0x00, 0x00];
let _ = broker_send_all(&ctx, handle.as_mut(), &greeting, "rpcap.start_capture");
let mut start_msg = vec![RPCAP_MSG_START, 0x00, 0x00, 0x00];
start_msg.extend_from_slice(interface.as_bytes());
start_msg.push(0);
let _ = broker_send_all(&ctx, handle.as_mut(), &start_msg, "rpcap.start_capture");
let data =
broker_tcp_receive(&ctx, handle.as_mut(), 1024, "rpcap.start_capture")
.unwrap_or_default();
let n = data.len();
result.set("status", "ok")?;
result.set("interface", interface)?;
result.set("capturing", n > 0)?;
result.set("filter", filter.unwrap_or_default())?;
Ok(result)
}
})?,
)?;
rpcap.set(
"stop_capture",
lua.create_function({
let ctx = capability_ctx.clone();
let services = services.clone();
move |lua, (host, port): (String, Option<u16>)| {
let result = lua.create_table()?;
let port = port.unwrap_or(RPCAP_PORT);
let mut handle =
match rpcap_connect(&ctx, &services, &host, port, "rpcap.stop_capture") {
Ok(h) => h,
Err(e) => {
result.set("status", "error")?;
result.set("error", e)?;
return Ok(result);
}
};
let stop_msg = [RPCAP_MSG_STOP, 0x00, 0x00, 0x00];
let _ = broker_send_all(&ctx, handle.as_mut(), &stop_msg, "rpcap.stop_capture");
let _data = broker_tcp_receive(&ctx, handle.as_mut(), 256, "rpcap.stop_capture")
.unwrap_or_default();
result.set("status", "ok")?;
result.set("capturing", false)?;
Ok(result)
}
})?,
)?;
rpcap.set(
"set_filter",
lua.create_function({
let ctx = capability_ctx.clone();
let services = services.clone();
move |lua, (host, port, filter): (String, Option<u16>, String)| {
let result = lua.create_table()?;
let port = port.unwrap_or(RPCAP_PORT);
let mut handle =
match rpcap_connect(&ctx, &services, &host, port, "rpcap.set_filter") {
Ok(h) => h,
Err(e) => {
result.set("status", "error")?;
result.set("error", e)?;
return Ok(result);
}
};
let mut filter_msg = vec![RPCAP_MSG_FILTER, 0x00, 0x00, 0x00];
filter_msg.extend_from_slice(filter.as_bytes());
filter_msg.push(0);
let _ = broker_send_all(&ctx, handle.as_mut(), &filter_msg, "rpcap.set_filter");
let _data = broker_tcp_receive(&ctx, handle.as_mut(), 256, "rpcap.set_filter")
.unwrap_or_default();
result.set("status", "ok")?;
result.set("filter", filter)?;
result.set("applied", true)?;
Ok(result)
}
})?,
)?;
rpcap.set(
"capture_packet",
lua.create_function({
let ctx = capability_ctx.clone();
let services = services.clone();
move |lua, (host, port, interface): (String, Option<u16>, String)| {
let result = lua.create_table()?;
let port = port.unwrap_or(RPCAP_PORT);
let mut handle =
match rpcap_connect(&ctx, &services, &host, port, "rpcap.capture_packet") {
Ok(h) => h,
Err(e) => {
result.set("status", "error")?;
result.set("error", e)?;
return Ok(result);
}
};
let greeting = [0x00, 0x01, 0x00, 0x00];
let _ = broker_send_all(&ctx, handle.as_mut(), &greeting, "rpcap.capture_packet");
let mut start_msg = vec![RPCAP_MSG_START, 0x00, 0x00, 0x00];
start_msg.extend_from_slice(interface.as_bytes());
start_msg.push(0);
let _ = broker_send_all(&ctx, handle.as_mut(), &start_msg, "rpcap.capture_packet");
if handle.set_timeouts(Duration::from_secs(1)).is_err() {
tracing::warn!("Failed to set rpcap capture read timeout");
}
let data = broker_tcp_receive(&ctx, handle.as_mut(), 65536, "rpcap.capture_packet")
.unwrap_or_default();
let n = data.len();
result.set("status", "ok")?;
result.set("interface", interface)?;
result.set("captured", n > 0)?;
result.set("bytes", n)?;
if n > 0 {
let sample_len = n.min(64);
let sample: Vec<String> = data[..sample_len]
.iter()
.map(|b| format!("{:02x}", b))
.collect();
result.set("data", sample.join(""))?;
}
Ok(result)
}
})?,
)?;
rpcap.set(
"get_stats",
lua.create_function(|lua, (_host, _port): (String, Option<u16>)| {
let result = lua.create_table()?;
result.set("status", "ok")?;
result.set("packets_captured", 0)?;
result.set("packets_dropped", 0)?;
result.set("interface_errors", 0)?;
Ok(result)
})?,
)?;
rpcap.set("version", lua.create_function(|_lua, _: ()| Ok("1.0.0"))?)?;
globals.set("rpcap", rpcap)?;
Ok(())
}