#![deny(clippy::all)]
use std::env;
use std::ffi::OsString;
use std::io;
use std::io::Write;
use std::net::TcpListener;
use std::os::fd::AsFd;
use std::os::fd::BorrowedFd;
use std::os::fd::IntoRawFd;
use std::os::unix::process::CommandExt;
use std::path::Path;
use std::path::PathBuf;
use std::process::Command;
use std::process::ExitCode;
const REVERSE_DAP: &str = include_str!("hermit-dap-reverse.py");
#[derive(Debug, PartialEq)]
struct ReplayOptions {
id: OsString,
data_dir: Option<OsString>,
gdbserver_port: u16,
}
#[derive(Debug, PartialEq)]
struct Options {
gdb: OsString,
replay: Option<ReplayOptions>,
listen: Option<Listen>,
}
#[derive(Debug, PartialEq)]
enum Listen {
Address(String),
Fd(i32),
}
fn usage() {
println!(
"Usage: hermit-dap [--gdb PATH] [--listen [HOST:]PORT | --listen-fd FD] [--replay ID [--data-dir DIR] [--gdbserver-port PORT]]\n\n\
Start a Debug Adapter Protocol server for a Hermit GDB remote target.\n\
The DAP attach request must include the guest executable as 'program'\n\
and the Hermit GDB server address as 'target'.\n\n\
By default the DAP client speaks to hermit-dap on stdin and stdout.\n\
With --listen, hermit-dap instead waits for one DAP client on a TCP port\n\
(HOST defaults to 127.0.0.1; port 0 picks a free one), writes\n\
`hermit-dap: listening on HOST:PORT` to stderr, and serves that client.\n\
--listen-fd FD does the same on a TCP socket already bound and listening\n\
on descriptor FD, which `hermit run --dap-listen` uses so that it, not\n\
hermit-dap, reports an address it cannot listen on.\n\n\
With --replay, hermit-dap starts and manages `hermit replay --serve-only`,\n\
enabling source-level stepBack and reverseContinue by replaying from the beginning."
);
}
fn default_gdb() -> OsString {
let system_gdb = Path::new("/usr/bin/gdb");
if system_gdb.is_file() {
system_gdb.as_os_str().to_owned()
} else {
OsString::from("gdb")
}
}
fn parse_options<I>(arguments: I) -> Result<Option<Options>, String>
where
I: IntoIterator<Item = OsString>,
{
let mut gdb = None;
let mut listen = None;
let mut replay = None;
let mut data_dir = None;
let mut gdbserver_port = 1234;
let mut gdbserver_port_set = false;
let mut args = arguments.into_iter();
while let Some(argument) = args.next() {
if argument == "--gdb" {
let path = args
.next()
.ok_or_else(|| "--gdb requires a path".to_owned())?;
if gdb.replace(path).is_some() {
return Err("--gdb may only be specified once".to_owned());
}
} else if argument == "--listen" {
let address = args
.next()
.ok_or_else(|| "--listen requires [HOST:]PORT".to_owned())?;
let address = listen_address(&address.to_string_lossy())?;
if listen.replace(Listen::Address(address)).is_some() {
return Err("--listen and --listen-fd may only be specified once".to_owned());
}
} else if argument == "--listen-fd" {
let fd = args
.next()
.ok_or_else(|| "--listen-fd requires a descriptor".to_owned())?
.to_string_lossy()
.parse::<i32>()
.ok()
.filter(|fd| *fd > 2)
.ok_or_else(|| "--listen-fd requires a descriptor above 2".to_owned())?;
if listen.replace(Listen::Fd(fd)).is_some() {
return Err("--listen and --listen-fd may only be specified once".to_owned());
}
} else if argument == "--replay" {
let id = args
.next()
.ok_or_else(|| "--replay requires a recording ID".to_owned())?;
if replay.replace(id).is_some() {
return Err("--replay may only be specified once".to_owned());
}
} else if argument == "--data-dir" {
let path = args
.next()
.ok_or_else(|| "--data-dir requires a path".to_owned())?;
if data_dir.replace(path).is_some() {
return Err("--data-dir may only be specified once".to_owned());
}
} else if argument == "--gdbserver-port" {
let port = args
.next()
.ok_or_else(|| "--gdbserver-port requires a port".to_owned())?;
gdbserver_port_set = true;
gdbserver_port = port
.to_string_lossy()
.parse()
.map_err(|_| "--gdbserver-port requires a valid port".to_owned())?;
} else if argument == "-h" || argument == "--help" {
usage();
return Ok(None);
} else {
return Err(format!(
"unrecognized argument: {}",
argument.to_string_lossy()
));
}
}
if replay.is_none() && data_dir.is_some() {
return Err("--data-dir requires --replay".to_owned());
}
if replay.is_none() && gdbserver_port_set {
return Err("--gdbserver-port requires --replay".to_owned());
}
Ok(Some(Options {
gdb: gdb.unwrap_or_else(default_gdb),
listen,
replay: replay.map(|id| ReplayOptions {
id,
data_dir,
gdbserver_port,
}),
}))
}
fn listen_address(argument: &str) -> Result<String, String> {
let (host, port) = match argument.rsplit_once(':') {
Some((host, port)) => (host, port),
None => ("127.0.0.1", argument),
};
if host.is_empty() {
return Err("--listen requires a host before ':'".to_owned());
}
let port: u16 = port
.parse()
.map_err(|_| "--listen requires a valid port".to_owned())?;
Ok(format!("{host}:{port}"))
}
fn accept_client(listen: &Listen) -> Result<(), String> {
let listener = match listen {
Listen::Address(address) => TcpListener::bind(address).map_err(|error| {
format!(
"could not listen on {address}: {error}; pass another port, or port 0 \
to let the system pick a free one"
)
})?,
Listen::Fd(fd) => {
if unsafe { libc::fcntl(*fd, libc::F_SETFD, libc::FD_CLOEXEC) } == -1 {
return Err(format!(
"--listen-fd {fd} is not a usable descriptor: {}",
io::Error::last_os_error()
));
}
unsafe { <TcpListener as std::os::fd::FromRawFd>::from_raw_fd(*fd) }
}
};
let local = listener
.local_addr()
.map_err(|error| format!("--listen-fd's descriptor is not a TCP socket: {error}"))?;
let _ = io::stderr().write_all(format!("hermit-dap: listening on {local}\n").as_bytes());
let _ = io::stderr().flush();
let (client, peer) = listener
.accept()
.map_err(|error| format!("could not accept a DAP client on {local}: {error}"))?;
drop(listener);
nix::unistd::dup2_stdin(&client)
.and_then(|()| nix::unistd::dup2_stdout(&client))
.map_err(|error| format!("could not serve the DAP client {peer}: {error}"))?;
eprintln!("hermit-dap: serving the DAP client at {peer}");
Ok(())
}
fn replay_command(options: &ReplayOptions) -> Result<Vec<String>, String> {
let hermit = env::current_exe()
.map_err(|error| format!("failed to locate hermit-dap: {error}"))?
.with_file_name("hermit");
if !hermit.is_file() {
return Err(format!(
"could not find the hermit executable beside hermit-dap: {}",
hermit.display()
));
}
let mut args = vec![
"replay".to_owned(),
options.id.to_string_lossy().into_owned(),
"--serve-only".to_owned(),
format!("--gdbserver-port={}", options.gdbserver_port),
];
if let Some(data_dir) = &options.data_dir {
args.push("--data-dir".to_owned());
args.push(data_dir.to_string_lossy().into_owned());
}
let mut serialized = vec![hermit.to_string_lossy().into_owned()];
serialized.extend(args);
Ok(serialized)
}
fn client_fds() -> String {
let duplicate = |name: &'static str, fd: BorrowedFd<'_>| {
nix::unistd::dup(fd).map_err(|error| format!("{name} ({error})"))
};
match (
duplicate("stdin", io::stdin().as_fd()),
duplicate("stdout", io::stdout().as_fd()),
duplicate("stderr", io::stderr().as_fd()),
) {
(Ok(input), Ok(output), Ok(error)) => format!(
"({}, {}, {})",
input.into_raw_fd(),
output.into_raw_fd(),
error.into_raw_fd()
),
(input, output, error) => {
let failed: Vec<String> = [input.err(), output.err(), error.err()]
.into_iter()
.flatten()
.collect();
eprintln!(
"hermit-dap: could not duplicate {}; if managed replay refuses to \
start, its reason goes only to GDB's stderr, which GDB's DAP \
interpreter does not pass to the client",
failed.join(", ")
);
"None".to_string()
}
}
}
fn main() -> ExitCode {
let options = match parse_options(env::args_os().skip(1)) {
Ok(Some(options)) => options,
Ok(None) => return ExitCode::SUCCESS,
Err(error) => {
eprintln!("hermit-dap: {error}");
eprintln!("Try 'hermit-dap --help' for more information.");
return ExitCode::FAILURE;
}
};
if let Some(listen) = &options.listen {
if let Err(error) = accept_client(listen) {
eprintln!("hermit-dap: {error}");
return ExitCode::FAILURE;
}
}
let mut gdb_command = Command::new(&options.gdb);
gdb_command
.arg("--quiet")
.arg("--nx")
.arg("--init-eval-command=set debuginfod enabled off")
.arg("--init-eval-command=set sysroot /");
if let Some(replay) = &options.replay {
let replay_command = match replay_command(replay).and_then(|command| {
serde_json::to_string(&command)
.map_err(|error| format!("failed to encode hermit replay command: {error}"))
}) {
Ok(command) => command,
Err(error) => {
eprintln!("hermit-dap: {error}");
return ExitCode::FAILURE;
}
};
let replay_target = format!("127.0.0.1:{}", replay.gdbserver_port);
let client_fds = client_fds();
let extension = format!(
"python HERMIT_REPLAY_COMMAND = {replay_command}; \
HERMIT_REPLAY_TARGET = {replay_target:?}; \
HERMIT_CLIENT_FDS = {client_fds}; exec({REVERSE_DAP:?})"
);
gdb_command.arg(format!("--init-eval-command={extension}"));
}
let error = gdb_command.arg("--interpreter=dap").exec();
eprintln!(
"hermit-dap: failed to execute {}: {error}",
PathBuf::from(&options.gdb).display()
);
ExitCode::FAILURE
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn replay_options_use_existing_command_vocabulary() {
let options = parse_options([
"--replay".into(),
"recording-id".into(),
"--data-dir".into(),
"/tmp/recordings".into(),
"--gdbserver-port".into(),
"2345".into(),
])
.unwrap()
.unwrap();
assert_eq!(
options.replay,
Some(ReplayOptions {
id: "recording-id".into(),
data_dir: Some("/tmp/recordings".into()),
gdbserver_port: 2345,
})
);
}
#[test]
fn listen_defaults_to_loopback() {
let listen = |argument: &str| {
parse_options(["--listen".into(), argument.into()])
.map(|options| options.unwrap().listen)
};
let address = |text: &str| Ok(Some(Listen::Address(text.to_owned())));
assert_eq!(listen("4711"), address("127.0.0.1:4711"));
assert_eq!(listen("0.0.0.0:0"), address("0.0.0.0:0"));
assert_eq!(listen("[::1]:4711"), address("[::1]:4711"));
assert_eq!(
listen(":4711"),
Err("--listen requires a host before ':'".to_owned())
);
assert_eq!(
listen("70000"),
Err("--listen requires a valid port".to_owned())
);
assert_eq!(
parse_options(["--listen".into(), "1".into(), "--listen".into(), "2".into()]),
Err("--listen and --listen-fd may only be specified once".to_owned())
);
let listen_fd = |argument: &str| {
parse_options(["--listen-fd".into(), argument.into()])
.map(|options| options.unwrap().listen)
};
assert_eq!(listen_fd("7"), Ok(Some(Listen::Fd(7))));
for refused in ["1", "x", "-3"] {
assert_eq!(
listen_fd(refused),
Err("--listen-fd requires a descriptor above 2".to_owned())
);
}
assert_eq!(
parse_options([
"--listen".into(),
"1".into(),
"--listen-fd".into(),
"7".into()
]),
Err("--listen and --listen-fd may only be specified once".to_owned())
);
}
#[test]
fn gdbserver_port_without_replay_is_rejected() {
let error = parse_options(["--gdbserver-port".into(), "2345".into()]).unwrap_err();
assert_eq!(error, "--gdbserver-port requires --replay");
}
#[test]
fn data_dir_without_replay_is_rejected() {
let error = parse_options(["--data-dir".into(), "/tmp/recordings".into()]).unwrap_err();
assert_eq!(error, "--data-dir requires --replay");
}
}