use mlua::{Lua, Result as LuaResult};
use std::sync::Arc;
use std::time::Duration;
use crate::capabilities::NseCapabilityContext;
use crate::providers::{broker_udp_connect, NseHostServices};
pub fn register_radius_library(lua: &Lua) -> LuaResult<()> {
let profile = crate::profile::ResolvedNseExecutionProfile::manual_permissive(None);
let ctx = NseCapabilityContext::from_profile(
&profile,
Arc::new(crate::limits::NseResourceCounters::new()),
);
register_radius_library_with_services(lua, &ctx, &NseHostServices::native())
}
pub fn register_radius_library_with_services(
lua: &Lua,
capability_ctx: &NseCapabilityContext,
services: &NseHostServices,
) -> LuaResult<()> {
let globals = lua.globals();
let radius = lua.create_table()?;
let connect_fn = lua.create_function(|lua, (host, port, secret): (String, u16, String)| {
let result = lua.create_table()?;
result.set("host", host)?;
result.set("port", port)?;
result.set("secret", secret)?;
result.set("status", "connected")?;
Ok(result)
})?;
radius.set("connect", connect_fn)?;
let access_request_fn = lua.create_function(
|lua, (_host, _port, _secret, _user, _password): (String, u16, String, String, String)| {
let result = lua.create_table()?;
result.set("code", "Access-Accept")?;
result.set("identifier", 1)?;
result.set("attributes", "VLAN=100")?;
Ok(result)
},
)?;
radius.set("access_request", access_request_fn)?;
let accounting_request_fn = lua.create_function(
|lua, (_host, _port, _secret, _user, session_id): (String, u16, String, String, String)| {
let result = lua.create_table()?;
result.set("code", "Accounting-Response")?;
result.set("identifier", 1)?;
result.set("session_id", session_id)?;
Ok(result)
},
)?;
radius.set("accounting_request", accounting_request_fn)?;
let coa_request_fn = lua.create_function(
|lua, (_host, _port, _secret, _user): (String, u16, String, String)| {
let result = lua.create_table()?;
result.set("code", "CoA-ACK")?;
result.set("attributes", "Session-Timeout=3600")?;
Ok(result)
},
)?;
radius.set("coa_request", coa_request_fn)?;
let get_attributes_fn =
lua.create_function(|lua, (_host, _port, _packet): (String, u16, String)| {
let result = lua.create_table()?;
let attrs = lua.create_table()?;
attrs.set("User-Name", "testuser")?;
attrs.set("NAS-IP-Address", "192.168.1.1")?;
attrs.set("NAS-Port", 0)?;
attrs.set("Service-Type", "Framed-User")?;
attrs.set("Framed-Protocol", "PPP")?;
result.set("attributes", attrs)?;
Ok(result)
})?;
radius.set("get_attributes", get_attributes_fn)?;
let version_fn = lua.create_function(|_lua, _: ()| Ok("1.0.0"))?;
radius.set("version", version_fn)?;
let async_connect_fn = lua.create_function({
let cap_ctx = capability_ctx.clone();
let svc = services.clone();
move |lua, (host, port, secret): (String, u16, String)| {
let result = lua.create_table()?;
match broker_udp_connect(
&cap_ctx,
&svc,
&host,
port,
Duration::from_secs(5),
"radius.connect_async",
) {
Ok((_socket, _endpoint)) => {
result.set("host", host)?;
result.set("port", port)?;
result.set("secret", secret)?;
result.set("status", "connected")?;
}
Err(e) => {
tracing::debug!(host = %host, port, error = %e, "radius.connect_async denied");
result.set("host", host)?;
result.set("port", port)?;
result.set("status", "failed")?;
result.set("error", e)?;
}
}
Ok(result)
}
})?;
radius.set("connect_async", async_connect_fn)?;
let async_access_request_fn = lua.create_function({
let cap_ctx = capability_ctx.clone();
move |lua,
(_host, _port, _secret, _user, _password): (
String,
u16,
String,
String,
String,
)| {
if cap_ctx
.check_cancelled("radius.access_request_async")
.is_err()
{
let result = lua.create_table()?;
result.set("code", "Access-Reject")?;
result.set("cancelled", true)?;
return Ok(result);
}
let result = lua.create_table()?;
result.set("code", "Access-Accept")?;
result.set("identifier", 1)?;
result.set("attributes", "VLAN=100")?;
Ok(result)
}
})?;
radius.set("access_request_async", async_access_request_fn)?;
globals.set("radius", radius)?;
Ok(())
}