use crate::brokered_stream::BrokeredTcpStream;
use crate::capabilities::NseCapabilityContext;
use crate::providers::NseHostServices;
use mlua::{Lua, Result as LuaResult, Table};
use std::io::Write;
use std::time::Duration;
use crate::wrappers;
fn ftp_control_connect(
ctx: &NseCapabilityContext,
services: &NseHostServices,
host: &str,
port: u16,
operation: &'static str,
) -> std::io::Result<BrokeredTcpStream> {
let (mut stream, _endpoint) = BrokeredTcpStream::connect(
ctx,
services,
host,
port,
Duration::from_secs(10),
operation,
)
.map_err(std::io::Error::other)?;
stream.set_read_timeout(Some(Duration::from_secs(30))).ok();
stream.set_write_timeout(Some(Duration::from_secs(30))).ok();
Ok(stream)
}
fn ftp_data_connect(
ctx: &NseCapabilityContext,
services: &NseHostServices,
data_ip: &str,
data_port: u16,
operation: &'static str,
) -> std::io::Result<BrokeredTcpStream> {
let (mut stream, _endpoint) = BrokeredTcpStream::connect(
ctx,
services,
data_ip,
data_port,
Duration::from_secs(10),
operation,
)
.map_err(std::io::Error::other)?;
stream.set_read_timeout(Some(Duration::from_secs(30))).ok();
stream.set_write_timeout(Some(Duration::from_secs(30))).ok();
Ok(stream)
}
fn ftp_send_command(stream: &mut BrokeredTcpStream, cmd: &str) -> std::io::Result<String> {
stream.write_all(cmd.as_bytes())?;
stream.flush()?;
let mut response = vec![0u8; 4096];
let n = stream.read(&mut response)?;
if n > 0 {
Ok(String::from_utf8_lossy(&response[..n]).to_string())
} else {
Ok(String::new())
}
}
fn ftp_get_pasv_port(response: &str) -> Option<(String, u16)> {
if let Some(start) = response.find('(') {
if let Some(end) = response.find(')') {
let inner = &response[start + 1..end];
let parts: Vec<&str> = inner.split(',').collect();
if parts.len() == 6 {
let ip = format!("{}.{}.{}.{}", parts[0], parts[1], parts[2], parts[3]);
let port = parts[4].parse::<u16>().ok()? * 256 + parts[5].parse::<u16>().ok()?;
return Some((ip, port));
}
}
}
None
}
fn ftp_retr_file(
ctx: &NseCapabilityContext,
services: &NseHostServices,
host: &str,
port: u16,
filename: &str,
data_ip_check: &dyn Fn(&str) -> bool,
operation: &'static str,
) -> std::io::Result<String> {
let mut stream = ftp_control_connect(ctx, services, host, port, operation)?;
if stream.read(&mut vec![0u8; 4096]).is_err() {
tracing::warn!("Failed to read FTP greeting");
}
let pasv_cmd = "PASV\r\n".to_string();
let pasv_response = ftp_send_command(&mut stream, &pasv_cmd)?;
let (data_ip, data_port) = ftp_get_pasv_port(&pasv_response)
.ok_or_else(|| std::io::Error::other("Failed to get PASV port"))?;
if !data_ip_check(&data_ip) {
return Err(std::io::Error::other(format!(
"PASV data connection to {} denied by policy",
data_ip
)));
}
let retr_cmd = format!("RETR {}\r\n", filename);
let _retr_response = ftp_send_command(&mut stream, &retr_cmd)?;
let mut data_stream = ftp_data_connect(ctx, services, &data_ip, data_port, operation)?;
let mut data = vec![0u8; 1048576];
let n = data_stream.read(&mut data).unwrap_or(0);
let _response = ftp_send_command(&mut stream, "")?;
if n > 0 {
Ok(String::from_utf8_lossy(&data[..n]).to_string())
} else {
Ok(String::new())
}
}
fn ftp_stor_file(
ctx: &NseCapabilityContext,
services: &NseHostServices,
host: &str,
port: u16,
filename: &str,
data: &str,
data_ip_check: &dyn Fn(&str) -> bool,
operation: &'static str,
) -> std::io::Result<bool> {
let mut stream = ftp_control_connect(ctx, services, host, port, operation)?;
if stream.read(&mut vec![0u8; 4096]).is_err() {
tracing::warn!("Failed to read FTP greeting");
}
let pasv_cmd = "PASV\r\n".to_string();
let pasv_response = ftp_send_command(&mut stream, &pasv_cmd)?;
let (data_ip, data_port) = ftp_get_pasv_port(&pasv_response)
.ok_or_else(|| std::io::Error::other("Failed to get PASV port"))?;
if !data_ip_check(&data_ip) {
return Err(std::io::Error::other(format!(
"PASV data connection to {} denied by policy",
data_ip
)));
}
let stor_cmd = format!("STOR {}\r\n", filename);
let _stor_response = ftp_send_command(&mut stream, &stor_cmd)?;
let mut data_stream = ftp_data_connect(ctx, services, &data_ip, data_port, operation)?;
data_stream.write_all(data.as_bytes())?;
data_stream.flush()?;
drop(data_stream);
let response = ftp_send_command(&mut stream, "")?;
Ok(response.starts_with("226"))
}
fn ftp_list_directory(
ctx: &NseCapabilityContext,
services: &NseHostServices,
host: &str,
port: u16,
path: &str,
data_ip_check: &dyn Fn(&str) -> bool,
operation: &'static str,
) -> std::io::Result<Vec<(String, String, String)>> {
let mut stream = ftp_control_connect(ctx, services, host, port, operation)?;
if stream.read(&mut vec![0u8; 4096]).is_err() {
tracing::warn!("Failed to read FTP greeting");
}
let pasv_cmd = "PASV\r\n".to_string();
let pasv_response = ftp_send_command(&mut stream, &pasv_cmd)?;
let (data_ip, data_port) = ftp_get_pasv_port(&pasv_response)
.ok_or_else(|| std::io::Error::other("Failed to get PASV port"))?;
if !data_ip_check(&data_ip) {
return Err(std::io::Error::other(format!(
"PASV data connection to {} denied by policy",
data_ip
)));
}
let list_cmd = if path.is_empty() {
"LIST\r\n".to_string()
} else {
format!("LIST {}\r\n", path)
};
let _list_response = ftp_send_command(&mut stream, &list_cmd)?;
let mut data_stream = ftp_data_connect(ctx, services, &data_ip, data_port, operation)?;
let mut data = vec![0u8; 65536];
let n = data_stream.read(&mut data).unwrap_or(0);
let _response = ftp_send_command(&mut stream, "")?;
let mut files = Vec::new();
if n > 0 {
let content = String::from_utf8_lossy(&data[..n]);
for line in content.lines() {
let parts: Vec<&str> = line.split_whitespace().collect();
if parts.len() >= 9 {
let perms = parts[0].to_string();
let size = parts[4].to_string();
let name = parts[8..].join(" ");
let file_type = if perms.starts_with('d') {
"DIR"
} else {
"FILE"
}
.to_string();
files.push((name, size, file_type));
}
}
}
Ok(files)
}
fn ftp_delete_file(
ctx: &NseCapabilityContext,
services: &NseHostServices,
host: &str,
port: u16,
filename: &str,
operation: &'static str,
) -> std::io::Result<bool> {
let mut stream = ftp_control_connect(ctx, services, host, port, operation)?;
if stream.read(&mut vec![0u8; 4096]).is_err() {
tracing::warn!("Failed to read FTP greeting");
}
let dele_cmd = format!("DELE {}\r\n", filename);
let response = ftp_send_command(&mut stream, &dele_cmd)?;
Ok(response.starts_with("250"))
}
fn ftp_rename_file(
ctx: &NseCapabilityContext,
services: &NseHostServices,
host: &str,
port: u16,
from_name: &str,
to_name: &str,
operation: &'static str,
) -> std::io::Result<bool> {
let mut stream = ftp_control_connect(ctx, services, host, port, operation)?;
if stream.read(&mut vec![0u8; 4096]).is_err() {
tracing::warn!("Failed to read FTP greeting");
}
let rnfr_cmd = format!("RNFR {}\r\n", from_name);
let _rnfr_response = ftp_send_command(&mut stream, &rnfr_cmd)?;
let rnto_cmd = format!("RNTO {}\r\n", to_name);
let rnto_response = ftp_send_command(&mut stream, &rnto_cmd)?;
Ok(rnto_response.starts_with("250"))
}
fn ftp_make_directory(
ctx: &NseCapabilityContext,
services: &NseHostServices,
host: &str,
port: u16,
dirname: &str,
operation: &'static str,
) -> std::io::Result<bool> {
let mut stream = ftp_control_connect(ctx, services, host, port, operation)?;
if stream.read(&mut vec![0u8; 4096]).is_err() {
tracing::warn!("Failed to read FTP greeting");
}
let mkd_cmd = format!("MKD {}\r\n", dirname);
let response = ftp_send_command(&mut stream, &mkd_cmd)?;
Ok(response.starts_with("257") || response.starts_with("250"))
}
fn ftp_remove_directory(
ctx: &NseCapabilityContext,
services: &NseHostServices,
host: &str,
port: u16,
dirname: &str,
operation: &'static str,
) -> std::io::Result<bool> {
let mut stream = ftp_control_connect(ctx, services, host, port, operation)?;
if stream.read(&mut vec![0u8; 4096]).is_err() {
tracing::warn!("Failed to read FTP greeting");
}
let rmd_cmd = format!("RMD {}\r\n", dirname);
let response = ftp_send_command(&mut stream, &rmd_cmd)?;
Ok(response.starts_with("250"))
}
fn ftp_get_file_size(
ctx: &NseCapabilityContext,
services: &NseHostServices,
host: &str,
port: u16,
filename: &str,
operation: &'static str,
) -> std::io::Result<u64> {
let mut stream = ftp_control_connect(ctx, services, host, port, operation)?;
if stream.read(&mut vec![0u8; 4096]).is_err() {
tracing::warn!("Failed to read FTP greeting");
}
let size_cmd = format!("SIZE {}\r\n", filename);
let response = ftp_send_command(&mut stream, &size_cmd)?;
if let Some(start) = response.find("213 ") {
let size_str = response[start + 4..].trim();
return Ok(size_str.parse().unwrap_or(0));
}
Ok(0)
}
fn maybe_denied_ftp(
lua: &Lua,
ctx: &NseCapabilityContext,
host: &str,
operation: &'static str,
) -> LuaResult<Option<Table>> {
let decision = wrappers::check_network_tcp(ctx, host, operation);
if !decision.is_allowed() {
let result = lua.create_table()?;
result.set("status", "error")?;
result.set(
"error",
decision
.deny_reason()
.unwrap_or("network access denied")
.to_string(),
)?;
result.set("reason", "denied")?;
return Ok(Some(result));
}
Ok(None)
}
pub fn register_ftp_library_with_services(
lua: &Lua,
capability_ctx: &NseCapabilityContext,
services: &NseHostServices,
) -> LuaResult<()> {
let globals = lua.globals();
let ftp = lua.create_table()?;
let cap = capability_ctx.clone();
let svc = services.clone();
let connect_fn = lua.create_function(move |lua, (host, port): (String, u16)| {
if let Some(denied) = maybe_denied_ftp(lua, &cap, &host, "ftp.connect")? {
return Ok(denied);
}
let mut stream = match ftp_control_connect(&cap, &svc, &host, port, "ftp.connect") {
Ok(s) => s,
Err(e) => {
let result = lua.create_table()?;
result.set("status", "error")?;
result.set("error", e.to_string())?;
return Ok(result);
}
};
let mut buffer = vec![0u8; 4096];
let n = stream
.read(&mut buffer)
.map_err(|e| mlua::Error::RuntimeError(e.to_string()))?;
let result = lua.create_table()?;
result.set("host", host)?;
result.set("port", port)?;
result.set("status", "connected")?;
result.set("welcome", String::from_utf8_lossy(&buffer[..n]).to_string())?;
Ok(result)
})?;
ftp.set("connect", connect_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let login_fn = lua.create_function(
move |lua, (host, port, user, pass): (String, u16, String, String)| {
if let Some(denied) = maybe_denied_ftp(lua, &cap, &host, "ftp.login")? {
return Ok(denied);
}
let mut stream = match ftp_control_connect(&cap, &svc, &host, port, "ftp.login") {
Ok(s) => s,
Err(e) => {
let result = lua.create_table()?;
result.set("success", false)?;
result.set("error", e.to_string())?;
return Ok(result);
}
};
if stream.read(&mut vec![0u8; 4096]).is_err() {
tracing::warn!("Failed to read FTP greeting");
}
stream
.write_all(format!("USER {}\r\n", user).as_bytes())
.ok();
if stream.read(&mut vec![0u8; 4096]).is_err() {
tracing::warn!("Failed to read FTP greeting");
}
stream
.write_all(format!("PASS {}\r\n", pass).as_bytes())
.ok();
let mut response = vec![0u8; 4096];
if stream.read(&mut response).is_err() {
tracing::warn!("Failed to read FTP login response");
}
let result = lua.create_table()?;
result.set(
"success",
response[..3].starts_with(b"230") || response[..3].starts_with(b"202"),
)?;
Ok(result)
},
)?;
ftp.set("login", login_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let cwd_fn = lua.create_function(move |lua, (host, port, path): (String, u16, String)| {
if let Some(denied) = maybe_denied_ftp(lua, &cap, &host, "ftp.cwd")? {
return Ok(denied);
}
let mut stream = match ftp_control_connect(&cap, &svc, &host, port, "ftp.cwd") {
Ok(s) => s,
Err(e) => {
let result = lua.create_table()?;
result.set("success", false)?;
result.set("error", e.to_string())?;
return Ok(result);
}
};
if stream.read(&mut vec![0u8; 4096]).is_err() {
tracing::warn!("Failed to read FTP greeting");
}
stream
.write_all(format!("CWD {}\r\n", path).as_bytes())
.ok();
let mut response = vec![0u8; 4096];
if stream.read(&mut response).is_err() {
tracing::warn!("Failed to read FTP CWD response");
}
let result = lua.create_table()?;
result.set("success", response[..3].starts_with(b"250"))?;
result.set("path", path)?;
Ok(result)
})?;
ftp.set("cwd", cwd_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let pwd_fn = lua.create_function(move |lua, (host, port): (String, u16)| {
if let Some(denied) = maybe_denied_ftp(lua, &cap, &host, "ftp.pwd")? {
return Err(mlua::Error::RuntimeError(
denied.get::<String>("error").unwrap_or_default(),
));
}
let mut stream = match ftp_control_connect(&cap, &svc, &host, port, "ftp.pwd") {
Ok(s) => s,
Err(e) => return Err(mlua::Error::RuntimeError(e.to_string())),
};
if stream.read(&mut vec![0u8; 4096]).is_err() {
tracing::warn!("Failed to read FTP greeting");
}
stream
.write_all(b"PWD\r\n")
.map_err(|e| mlua::Error::RuntimeError(e.to_string()))?;
let mut response = vec![0u8; 4096];
if stream.read(&mut response).is_err() {
tracing::warn!("Failed to read FTP PWD response");
}
let response_str = String::from_utf8_lossy(&response);
let path = if let Some(start) = response_str.find('"') {
if let Some(end) = response_str[start + 1..].find('"') {
response_str[start + 1..start + 1 + end].to_string()
} else {
"/".to_string()
}
} else {
"/".to_string()
};
Ok(path)
})?;
ftp.set("pwd", pwd_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let list_fn = lua.create_function(
move |lua, (host, port, path): (String, u16, Option<String>)| {
if let Some(denied) = maybe_denied_ftp(lua, &cap, &host, "ftp.list")? {
return Ok(denied);
}
let path = path.unwrap_or_else(|| ".".to_string());
let cap_for_data = cap.clone();
match ftp_list_directory(
&cap,
&svc,
&host,
port,
&path,
&|data_ip: &str| {
wrappers::check_network_tcp(&cap_for_data, data_ip, "ftp.list.data")
.is_allowed()
},
"ftp.list",
) {
Ok(files) => {
let result = lua.create_table()?;
let files_table = lua.create_table()?;
for (i, (name, size, ftype)) in files.iter().enumerate() {
let file = lua.create_table()?;
file.set("name", name.clone())?;
file.set("size", size.clone())?;
file.set("type", ftype.clone())?;
files_table.set(i + 1, file)?;
}
result.set("files", files_table)?;
result.set("count", files.len())?;
result.set("status", "ok")?;
Ok(result)
}
Err(e) => {
let result = lua.create_table()?;
result.set("status", "error")?;
result.set("error", e.to_string())?;
Ok(result)
}
}
},
)?;
ftp.set("list", list_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let nlst_fn = lua.create_function(
move |lua, (host, port, path): (String, u16, Option<String>)| {
if let Some(denied) = maybe_denied_ftp(lua, &cap, &host, "ftp.nlst")? {
return Ok(denied);
}
let path = path.unwrap_or_else(|| ".".to_string());
let cap_for_data = cap.clone();
match ftp_list_directory(
&cap,
&svc,
&host,
port,
&path,
&|data_ip: &str| {
wrappers::check_network_tcp(&cap_for_data, data_ip, "ftp.nlst.data")
.is_allowed()
},
"ftp.nlst",
) {
Ok(files) => {
let result = lua.create_table()?;
for (i, (name, _size, _ftype)) in files.iter().enumerate() {
if _ftype == "FILE" {
result.set(i + 1, name.clone())?;
}
}
Ok(result)
}
Err(e) => {
let result = lua.create_table()?;
result.set("error", e.to_string())?;
Ok(result)
}
}
},
)?;
ftp.set("nlst", nlst_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let retr_fn =
lua.create_function(move |lua, (host, port, filename): (String, u16, String)| {
if let Some(denied) = maybe_denied_ftp(lua, &cap, &host, "ftp.retr")? {
return Ok(denied);
}
let cap_for_data = cap.clone();
match ftp_retr_file(
&cap,
&svc,
&host,
port,
&filename,
&|data_ip: &str| {
wrappers::check_network_tcp(&cap_for_data, data_ip, "ftp.retr.data")
.is_allowed()
},
"ftp.retr",
) {
Ok(data) => {
let data_len = data.len();
let result = lua.create_table()?;
result.set("status", "ok")?;
result.set("data", data)?;
result.set("size", data_len)?;
Ok(result)
}
Err(e) => {
let result = lua.create_table()?;
result.set("status", "error")?;
result.set("error", e.to_string())?;
Ok(result)
}
}
})?;
ftp.set("retr", retr_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let stor_fn = lua.create_function(
move |lua, (host, port, filename, data): (String, u16, String, String)| {
if let Some(denied) = maybe_denied_ftp(lua, &cap, &host, "ftp.stor")? {
return Ok(denied);
}
let cap_for_data = cap.clone();
match ftp_stor_file(
&cap,
&svc,
&host,
port,
&filename,
&data,
&|data_ip: &str| {
wrappers::check_network_tcp(&cap_for_data, data_ip, "ftp.stor.data")
.is_allowed()
},
"ftp.stor",
) {
Ok(success) => {
let result = lua.create_table()?;
result.set("success", success)?;
result.set("filename", filename)?;
result.set("size", data.len())?;
Ok(result)
}
Err(e) => {
let result = lua.create_table()?;
result.set("success", false)?;
result.set("error", e.to_string())?;
Ok(result)
}
}
},
)?;
ftp.set("stor", stor_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let dele_fn =
lua.create_function(move |lua, (host, port, filename): (String, u16, String)| {
if let Some(denied) = maybe_denied_ftp(lua, &cap, &host, "ftp.dele")? {
return Ok(denied);
}
match ftp_delete_file(&cap, &svc, &host, port, &filename, "ftp.dele") {
Ok(success) => {
let result = lua.create_table()?;
result.set("success", success)?;
result.set("deleted", filename)?;
Ok(result)
}
Err(e) => {
let result = lua.create_table()?;
result.set("success", false)?;
result.set("error", e.to_string())?;
Ok(result)
}
}
})?;
ftp.set("dele", dele_fn)?;
let rnfr_fn = lua.create_function(|lua, (_host, _port, filename): (String, u16, String)| {
let result = lua.create_table()?;
result.set("success", true)?;
result.set("from", filename)?;
result.set("status", "ready for rename")?;
Ok(result)
})?;
ftp.set("rnfr", rnfr_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let rnto_fn =
lua.create_function(move |lua, (host, port, to_name): (String, u16, String)| {
if let Some(denied) = maybe_denied_ftp(lua, &cap, &host, "ftp.rnto")? {
return Ok(denied);
}
match ftp_rename_file(&cap, &svc, &host, port, "", &to_name, "ftp.rnto") {
Ok(success) => {
let result = lua.create_table()?;
result.set("success", success)?;
result.set("to", to_name)?;
Ok(result)
}
Err(e) => {
let result = lua.create_table()?;
result.set("success", false)?;
result.set("error", e.to_string())?;
Ok(result)
}
}
})?;
ftp.set("rnto", rnto_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let mkd_fn =
lua.create_function(move |lua, (host, port, dirname): (String, u16, String)| {
if let Some(denied) = maybe_denied_ftp(lua, &cap, &host, "ftp.mkd")? {
return Ok(denied);
}
match ftp_make_directory(&cap, &svc, &host, port, &dirname, "ftp.mkd") {
Ok(success) => {
let result = lua.create_table()?;
result.set("success", success)?;
result.set("created", dirname)?;
Ok(result)
}
Err(e) => {
let result = lua.create_table()?;
result.set("success", false)?;
result.set("error", e.to_string())?;
Ok(result)
}
}
})?;
ftp.set("mkd", mkd_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let rmd_fn =
lua.create_function(move |lua, (host, port, dirname): (String, u16, String)| {
if let Some(denied) = maybe_denied_ftp(lua, &cap, &host, "ftp.rmd")? {
return Ok(denied);
}
match ftp_remove_directory(&cap, &svc, &host, port, &dirname, "ftp.rmd") {
Ok(success) => {
let result = lua.create_table()?;
result.set("success", success)?;
result.set("removed", dirname)?;
Ok(result)
}
Err(e) => {
let result = lua.create_table()?;
result.set("success", false)?;
result.set("error", e.to_string())?;
Ok(result)
}
}
})?;
ftp.set("rmd", rmd_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let size_fn =
lua.create_function(move |lua, (host, port, filename): (String, u16, String)| {
if let Some(denied) = maybe_denied_ftp(lua, &cap, &host, "ftp.size")? {
return Ok(denied);
}
match ftp_get_file_size(&cap, &svc, &host, port, &filename, "ftp.size") {
Ok(size) => {
let result = lua.create_table()?;
result.set("size", size)?;
result.set("filename", filename)?;
Ok(result)
}
Err(e) => {
let result = lua.create_table()?;
result.set("error", e.to_string())?;
Ok(result)
}
}
})?;
ftp.set("size", size_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let mdtm_fn =
lua.create_function(move |lua, (host, port, filename): (String, u16, String)| {
if let Some(denied) = maybe_denied_ftp(lua, &cap, &host, "ftp.mdtm")? {
return Ok(denied);
}
let mut stream = match ftp_control_connect(&cap, &svc, &host, port, "ftp.mdtm") {
Ok(s) => s,
Err(e) => {
let result = lua.create_table()?;
result.set("error", e.to_string())?;
return Ok(result);
}
};
if stream.read(&mut vec![0u8; 4096]).is_err() {
tracing::warn!("Failed to read FTP greeting");
}
stream
.write_all(format!("MDTM {}\r\n", filename).as_bytes())
.ok();
let mut response = vec![0u8; 4096];
if stream.read(&mut response).is_err() {
tracing::warn!("Failed to read FTP MDTM response");
}
let result = lua.create_table()?;
let response_str = String::from_utf8_lossy(&response).to_string();
if response_str.starts_with("213") {
if let Some(timestamp) = response_str.strip_prefix("213 ") {
result.set("success", true)?;
result.set("timestamp", timestamp.trim())?;
} else {
result.set("success", false)?;
}
} else {
result.set("success", false)?;
}
Ok(result)
})?;
ftp.set("mdtm", mdtm_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let mlst_fn = lua.create_function(move |lua, (host, port, path): (String, u16, String)| {
if let Some(denied) = maybe_denied_ftp(lua, &cap, &host, "ftp.mlst")? {
return Ok(denied);
}
let mut stream = match ftp_control_connect(&cap, &svc, &host, port, "ftp.mlst") {
Ok(s) => s,
Err(e) => {
let result = lua.create_table()?;
result.set("error", e.to_string())?;
return Ok(result);
}
};
if stream.read(&mut vec![0u8; 4096]).is_err() {
tracing::warn!("Failed to read FTP greeting");
}
stream
.write_all(format!("MLST {}\r\n", path).as_bytes())
.ok();
let mut response = vec![0u8; 4096];
if stream.read(&mut response).is_err() {
tracing::warn!("Failed to read FTP MLST response");
}
let result = lua.create_table()?;
let response_str = String::from_utf8_lossy(&response).to_string();
if response_str.contains("250-") {
result.set("success", true)?;
let facts = lua.create_table()?;
for line in response_str.lines() {
if line.contains("type=") {
if let Some(t) = line.split("type=").nth(1) {
let file_type = t.split_whitespace().next().unwrap_or("file");
facts.set("type", file_type)?;
}
}
if line.contains("size=") {
if let Some(s) = line.split("size=").nth(1) {
let size_str = s.split_whitespace().next().unwrap_or("0");
if let Ok(size) = size_str.parse::<u64>() {
facts.set("size", size)?;
}
}
}
if line.contains("modify=") {
if let Some(m) = line.split("modify=").nth(1) {
let modify = m.split_whitespace().next().unwrap_or("");
facts.set("modify", modify)?;
}
}
}
result.set("facts", facts)?;
} else {
result.set("success", false)?;
}
Ok(result)
})?;
ftp.set("mlst", mlst_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let feat_fn = lua.create_function(move |lua, (host, port): (String, u16)| {
if let Some(denied) = maybe_denied_ftp(lua, &cap, &host, "ftp.feat")? {
return Ok(denied);
}
let mut stream = match ftp_control_connect(&cap, &svc, &host, port, "ftp.feat") {
Ok(s) => s,
Err(e) => {
let result = lua.create_table()?;
result.set("error", e.to_string())?;
return Ok(result);
}
};
if stream.read(&mut vec![0u8; 4096]).is_err() {
tracing::warn!("Failed to read FTP greeting");
}
stream.write_all(b"FEAT\r\n").ok();
let mut response = vec![0u8; 4096];
if stream.read(&mut response).is_err() {
tracing::warn!("Failed to read FTP FEAT response");
}
let result = lua.create_table()?;
let response_str = String::from_utf8_lossy(&response).to_string();
let features = lua.create_table()?;
for line in response_str.lines() {
if line.starts_with("211-") || line.starts_with(" ") {
let feature = line.trim().trim_start_matches("211-").trim();
if !feature.is_empty() && feature != "211 End" {
let count = features.len().unwrap_or(0) + 1;
features.set(count, feature)?;
}
}
}
result.set("features", features)?;
Ok(result)
})?;
ftp.set("feat", feat_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let site_fn =
lua.create_function(move |lua, (host, port, command): (String, u16, String)| {
if let Some(denied) = maybe_denied_ftp(lua, &cap, &host, "ftp.site")? {
return Ok(denied);
}
let mut stream = match ftp_control_connect(&cap, &svc, &host, port, "ftp.site") {
Ok(s) => s,
Err(e) => {
let result = lua.create_table()?;
result.set("error", e.to_string())?;
return Ok(result);
}
};
if stream.read(&mut vec![0u8; 4096]).is_err() {
tracing::warn!("Failed to read FTP greeting");
}
stream
.write_all(format!("SITE {}\r\n", command).as_bytes())
.ok();
let mut response = vec![0u8; 4096];
if stream.read(&mut response).is_err() {
tracing::warn!("Failed to read FTP SITE response");
}
let result = lua.create_table()?;
let response_str = String::from_utf8_lossy(&response).to_string();
result.set("response", response_str.trim())?;
Ok(result)
})?;
ftp.set("site", site_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let stat_fn = lua.create_function(
move |lua, (host, port, path): (String, u16, Option<String>)| {
if let Some(denied) = maybe_denied_ftp(lua, &cap, &host, "ftp.stat")? {
return Ok(denied);
}
let mut stream = match ftp_control_connect(&cap, &svc, &host, port, "ftp.stat") {
Ok(s) => s,
Err(e) => {
let result = lua.create_table()?;
result.set("error", e.to_string())?;
return Ok(result);
}
};
if stream.read(&mut vec![0u8; 4096]).is_err() {
tracing::warn!("Failed to read FTP greeting");
}
if let Some(p) = path {
stream.write_all(format!("STAT {}\r\n", p).as_bytes()).ok();
} else {
stream.write_all(b"STAT\r\n").ok();
}
let mut response = vec![0u8; 4096];
if stream.read(&mut response).is_err() {
tracing::warn!("Failed to read FTP STAT response");
}
let result = lua.create_table()?;
result.set(
"response",
String::from_utf8_lossy(&response).trim().to_string(),
)?;
Ok(result)
},
)?;
ftp.set("stat", stat_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let noop_fn = lua.create_function(move |lua, (host, port): (String, u16)| {
if let Some(denied) = maybe_denied_ftp(lua, &cap, &host, "ftp.noop")? {
return Ok(denied);
}
let mut stream = match ftp_control_connect(&cap, &svc, &host, port, "ftp.noop") {
Ok(s) => s,
Err(e) => {
let result = lua.create_table()?;
result.set("error", e.to_string())?;
return Ok(result);
}
};
if stream.read(&mut vec![0u8; 4096]).is_err() {
tracing::warn!("Failed to read FTP greeting");
}
stream.write_all(b"NOOP\r\n").ok();
let mut response = vec![0u8; 256];
if stream.read(&mut response).is_err() {
tracing::warn!("Failed to read FTP NOOP response");
}
let result = lua.create_table()?;
result.set("success", response.starts_with(b"200"))?;
Ok(result)
})?;
ftp.set("noop", noop_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let syst_fn = lua.create_function(move |lua, (host, port): (String, u16)| {
if let Some(denied) = maybe_denied_ftp(lua, &cap, &host, "ftp.syst")? {
return Ok(denied);
}
let mut stream = match ftp_control_connect(&cap, &svc, &host, port, "ftp.syst") {
Ok(s) => s,
Err(e) => {
let result = lua.create_table()?;
result.set("error", e.to_string())?;
return Ok(result);
}
};
if stream.read(&mut vec![0u8; 4096]).is_err() {
tracing::warn!("Failed to read FTP greeting");
}
stream.write_all(b"SYST\r\n").ok();
let mut response = vec![0u8; 256];
if stream.read(&mut response).is_err() {
tracing::warn!("Failed to read FTP SYST response");
}
let result = lua.create_table()?;
let response_str = String::from_utf8_lossy(&response).to_string();
if let Some(sys) = response_str.strip_prefix("215 ") {
result.set("system", sys.trim())?;
} else {
result.set("system", "Unknown")?;
}
Ok(result)
})?;
ftp.set("syst", syst_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let type_fn =
lua.create_function(move |lua, (host, port, type_char): (String, u16, String)| {
if let Some(denied) = maybe_denied_ftp(lua, &cap, &host, "ftp.type")? {
return Ok(denied);
}
let mut stream = match ftp_control_connect(&cap, &svc, &host, port, "ftp.type") {
Ok(s) => s,
Err(e) => {
let result = lua.create_table()?;
result.set("success", false)?;
result.set("error", e.to_string())?;
return Ok(result);
}
};
if stream.read(&mut vec![0u8; 4096]).is_err() {
tracing::warn!("Failed to read FTP greeting");
}
stream
.write_all(format!("TYPE {}\r\n", type_char).as_bytes())
.ok();
let mut response = vec![0u8; 4096];
if stream.read(&mut response).is_err() {
tracing::warn!("Failed to read FTP TYPE response");
}
let result = lua.create_table()?;
result.set("success", response[..3].starts_with(b"200"))?;
result.set("type", type_char)?;
Ok(result)
})?;
ftp.set("type", type_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let pasv_fn = lua.create_function(move |lua, (host, port): (String, u16)| {
if let Some(denied) = maybe_denied_ftp(lua, &cap, &host, "ftp.pasv")? {
return Err(mlua::Error::RuntimeError(
denied.get::<String>("error").unwrap_or_default(),
));
}
let mut stream = match ftp_control_connect(&cap, &svc, &host, port, "ftp.pasv") {
Ok(s) => s,
Err(e) => return Err(mlua::Error::RuntimeError(e.to_string())),
};
if stream.read(&mut vec![0u8; 4096]).is_err() {
tracing::warn!("Failed to read FTP greeting");
}
stream
.write_all(b"PASV\r\n")
.map_err(|e| mlua::Error::RuntimeError(e.to_string()))?;
let mut response = vec![0u8; 4096];
if stream.read(&mut response).is_err() {
tracing::warn!("Failed to read FTP PASV response");
}
Ok(String::from_utf8_lossy(&response).to_string())
})?;
ftp.set("pasv", pasv_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let epsv_fn = lua.create_function(move |lua, (host, port): (String, u16)| {
if let Some(denied) = maybe_denied_ftp(lua, &cap, &host, "ftp.epsv")? {
return Err(mlua::Error::RuntimeError(
denied.get::<String>("error").unwrap_or_default(),
));
}
let mut stream = match ftp_control_connect(&cap, &svc, &host, port, "ftp.epsv") {
Ok(s) => s,
Err(e) => return Err(mlua::Error::RuntimeError(e.to_string())),
};
if stream.read(&mut vec![0u8; 4096]).is_err() {
tracing::warn!("Failed to read FTP greeting");
}
stream
.write_all(b"EPSV\r\n")
.map_err(|e| mlua::Error::RuntimeError(e.to_string()))?;
let mut response = vec![0u8; 4096];
if stream.read(&mut response).is_err() {
tracing::warn!("Failed to read FTP EPSV response");
}
Ok(String::from_utf8_lossy(&response).to_string())
})?;
ftp.set("epsv", epsv_fn)?;
let quit_fn = lua.create_function(|_lua, (_host, _port): (String, u16)| Ok(true))?;
ftp.set("quit", quit_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let async_connect_fn = lua.create_function(move |lua, (host, port): (String, u16)| {
if let Some(denied) = maybe_denied_ftp(lua, &cap, &host, "ftp.connect_async")? {
return Err(mlua::Error::RuntimeError(
denied.get::<String>("error").unwrap_or_default(),
));
}
match ftp_control_connect(&cap, &svc, &host, port, "ftp.connect_async") {
Ok(mut stream) => {
let mut buffer = vec![0u8; 4096];
let n = stream.read(&mut buffer).unwrap_or(0);
let r = lua.create_table()?;
r.set("host", host)?;
r.set("port", port)?;
r.set("status", "connected")?;
r.set("welcome", String::from_utf8_lossy(&buffer[..n]).to_string())?;
Ok(r)
}
Err(e) => Err(mlua::Error::RuntimeError(e.to_string())),
}
})?;
ftp.set("connect_async", async_connect_fn)?;
let cap = capability_ctx.clone();
let svc = services.clone();
let async_login_fn = lua.create_function(
move |lua, (host, port, user, pass): (String, u16, String, String)| {
if let Some(denied) = maybe_denied_ftp(lua, &cap, &host, "ftp.login_async")? {
return Err(mlua::Error::RuntimeError(
denied.get::<String>("error").unwrap_or_default(),
));
}
match ftp_control_connect(&cap, &svc, &host, port, "ftp.login_async") {
Ok(mut stream) => {
if stream.read(&mut vec![0u8; 4096]).is_err() {
tracing::warn!("Failed to read FTP async greeting");
}
stream
.write_all(format!("USER {}\r\n", user).as_bytes())
.ok();
if stream.read(&mut vec![0u8; 4096]).is_err() {
tracing::warn!("Failed to read FTP async USER response");
}
stream
.write_all(format!("PASS {}\r\n", pass).as_bytes())
.ok();
let mut response = vec![0u8; 4096];
if stream.read(&mut response).is_err() {
tracing::warn!("Failed to read FTP async PASS response");
}
let result = lua.create_table()?;
result.set(
"success",
response[..3].starts_with(b"230") || response[..3].starts_with(b"202"),
)?;
Ok(result)
}
Err(e) => Err(mlua::Error::RuntimeError(e.to_string())),
}
},
)?;
ftp.set("login_async", async_login_fn)?;
let version_fn = lua.create_function(|_lua, _: ()| Ok("1.0.0"))?;
ftp.set("version", version_fn)?;
globals.set("ftp", ftp)?;
Ok(())
}