Add build-artifact command that builds user and kernel code and puts them in a folder

.gitignore

@@ -16,3 +16,6 @@ Cargo.lock
 
 # Data files
 data/
+
+# Artifacts
+bin/

responder/Cargo.toml

@@ -4,6 +4,10 @@ version = "0.1.0"
 edition = "2021"
 publish = false
 
+[features]
+
+default_artifact_build = []
+
 [dependencies]
 # aya = { version = ">=0.11", features=["async_tokio"] }
 # aya-log = "0.1"

responder/src/main.rs

@@ -11,6 +11,15 @@ use tokio::signal;
 use csv::ReaderBuilder;
 use serde::Deserialize;
 
+#[cfg(all(debug_assertions, not(feature = "default_artifact_build")))]
+const DEFAULT_TARGET: &str = "target/bpfel-unknown-none/debug";
+
+#[cfg(all(not(debug_assertions), not(feature = "default_artifact_build")))]
+const DEFAULT_TARGET: &str = "target/bpfel-unknown-none/release";
+
+#[cfg(feature = "default_artifact_build")]
+const DEFAULT_TARGET: &str = "bin/ebpf";
+
 #[derive(Debug, Parser)]
 struct Opt {
     #[clap(short, long, default_value = "lo")]
@@ -19,8 +28,8 @@ struct Opt {
     scan_type: String,
     #[clap(short, long)]
     csv: Option<String>,
-    #[clap(default_value = "bpfel-unknown-none", long)]
-    target: String,
+    #[clap(default_value = DEFAULT_TARGET, long)]
+    target: PathBuf,
 }
 
 #[derive(Debug, Deserialize, Eq, PartialEq)]
@@ -35,15 +44,8 @@ async fn main() -> Result<(), anyhow::Error> {
     env_logger::Builder::from_env(Env::default().default_filter_or("info")).init();
 
     let mut bpf_path = PathBuf::new();
-    bpf_path.push("target");
     bpf_path.push(opt.target);
 
-    #[cfg(debug_assertions)]
-    bpf_path.push("debug");
-
-    #[cfg(not(debug_assertions))]
-    bpf_path.push("release");
-
     let xdp_name = opt.scan_type;
     bpf_path.push(xdp_name.clone());
 

xtask/src/build.rs

@@ -0,0 +1,80 @@
+use std::{fs, path::PathBuf, process::Command};
+
+use anyhow::Context as _;
+use clap::Parser;
+
+use crate::build_ebpf::{self, build_ebpf, Architecture};
+
+#[derive(Debug, Parser)]
+pub struct Options {
+    /// Set the endianness of the BPF target
+    #[clap(default_value = "bpfel-unknown-none", long)]
+    pub bpf_target: Architecture,
+    // Output folder
+    #[clap(short, long, default_value = "bin")]
+    pub output_folder: PathBuf,
+}
+
+fn build_user(_opts: &Options) -> Result<(), anyhow::Error> {
+    let status = Command::new("cargo")
+        .args(["build", "--release", "--features=default_artifact_build"])
+        .status()
+        .expect("failed to build responder userspace program");
+    if !status.success() {
+        return Err(anyhow::anyhow!(
+            "cargo build --release failed to run: {}",
+            status.to_string()
+        ));
+    }
+    Ok(())
+}
+
+pub fn build(opts: Options) -> Result<(), anyhow::Error> {
+    fs::create_dir_all(&opts.output_folder).context(format!(
+        "Error creating dirs for path: {}",
+        opts.output_folder
+            .to_str()
+            .unwrap_or("[path not valid unicode]")
+    ))?;
+
+    build_ebpf(build_ebpf::Options {
+        target: opts.bpf_target,
+        release: true,
+    })
+    .context("Error while building eBPF program")?;
+
+    for entry in fs::read_dir(
+        [r"target", opts.bpf_target.to_string().as_str(), r"release"]
+            .iter()
+            .collect::<PathBuf>(),
+    )? {
+        let ebpf_bin = opts.output_folder.join(r"ebpf");
+        fs::create_dir_all(&ebpf_bin)?;
+        if let Ok(entry) = entry {
+            let path = entry.path();
+            if path.is_file()
+                && !path
+                    .file_name()
+                    .unwrap()
+                    .to_str()
+                    .map(|s| s.contains("."))
+                    .unwrap_or(true)
+            {
+                let to = ebpf_bin.join(path.file_name().unwrap());
+                fs::copy(&path, &to).context(format!(
+                    "Error copying from {} to {}",
+                    path.to_str().unwrap_or("[path not valid unicode]"),
+                    to.to_str().unwrap_or("[path not valid unicode]")
+                ))?;
+            }
+        }
+    }
+
+    build_user(&opts).context("Error while building userspace application")?;
+    fs::copy(
+        "target/release/responder",
+        opts.output_folder.join("responder"),
+    )?;
+
+    Ok(())
+}

xtask/src/main.rs

@@ -1,4 +1,5 @@
 mod build_ebpf;
+mod build;
 mod run;
 mod codegen;
 
@@ -16,6 +17,7 @@ pub struct Options {
 #[derive(Debug, Parser)]
 enum Command {
     BuildEbpf(build_ebpf::Options),
+    BuildArtifacts(build::Options),
     Run(run::Options),
     CodeGen,
 }
@@ -26,6 +28,7 @@ fn main() {
     use Command::*;
     let ret = match opts.command {
         BuildEbpf(opts) => build_ebpf::build_ebpf(opts),
+        BuildArtifacts(opts) => build::build(opts),
         Run(opts) => run::run(opts),
         CodeGen => codegen::generate(),
     };