feat: compile c/cpp

Author: yjl9903

Cargo.lock

@@ -21,5 +21,6 @@ lazy_static = "1.4.0"
 libc-stdhandle = "0.1.0"
 log = "0.4"
 nix = { version = "0.26.2", features = ["signal", "process", "ptrace", "user"] }
+path-absolutize = "3.0.14"
 remove_dir_all = "0.7.0"
 tempfile = "3"

Cargo.toml

@@ -56,7 +56,7 @@ impl CatBoxBuilder {
 
   /// Create a compile CatBox
   pub fn compile() -> Self {
-    Self::new(Box::new(CatBoxCompileContext {}))
+    Self::new(Box::new(CatBoxCompileContext::new()))
   }
 
   /// Create a judge CatBox
@@ -335,6 +335,12 @@ impl CatBoxOptionBuilder {
     self
   }
 
+  // Add mount point
+  pub fn mount(mut self, mount_point: MountPoint) -> Self {
+    self.option.mounts.push(mount_point);
+    self
+  }
+
   /// Mount read directory
   pub fn mount_read<SP: Into<PathBuf>, DP: Into<PathBuf>>(mut self, src: SP, dst: DP) -> Self {
     self
@@ -383,7 +389,7 @@ impl CatBoxOption {
     let current_user = User::from_uid(Uid::current()).unwrap().unwrap();
     let cgroup = env::var("CATJ_CGROUP").unwrap_or(current_user.name);
 
-    let catbox_user = User::from_name("Nobody").unwrap().unwrap();
+    let catbox_user = User::from_name("nobody").unwrap().unwrap();
     let catbox_group = Group::from_name("nogroup").unwrap().unwrap();
 
     CatBoxOption {

src/context/builder.rs

@@ -50,7 +50,9 @@ pub struct CatBoxRunContext {
   results: Vec<CatBoxResult>,
 }
 
-pub struct CatBoxCompileContext {}
+pub struct CatBoxCompileContext {
+  ok: bool,
+}
 
 pub struct CatBoxJudgeContext {}
 
@@ -98,6 +100,7 @@ impl CatBox {
   /// Run all the commands
   pub fn start(&mut self) -> Result<(), CatBoxError> {
     for option in self.options.iter() {
+      dbg!(&option);
       let result = crate::run(&option)?;
       self.context.add_result(&option.label.clone(), result);
     }
@@ -244,9 +247,19 @@ impl CatBoxContext for CatBoxRunContext {
   }
 }
 
+impl CatBoxCompileContext {
+  fn new() -> Self {
+    CatBoxCompileContext { ok: true }
+  }
+}
+
 impl CatBoxContext for CatBoxCompileContext {
   fn add_result(&mut self, _label: &String, result: CatBoxResult) {
-    todo!()
+    if self.ok {
+      if result.status.unwrap_or(1) == 0 {
+        self.ok = false;
+      }
+    }
   }
 
   fn report_human(&self) {

src/context/mod.rs

@@ -10,6 +10,7 @@ use log::{error, info};
 use crate::catbox::run;
 use crate::context::{CatBox, CatBoxBuilder, CatBoxOption};
 use crate::error::{CatBoxError, CatBoxExit};
+use crate::preset::make_compile_params;
 // use crate::preset::make_compile_params;
 use crate::utils::{default_format, GidType, MemoryLimitType, TimeLimitType, UidType};
 
@@ -59,7 +60,7 @@ struct Cli {
 }
 
 #[derive(Subcommand, Debug)]
-enum Commands {
+pub(crate) enum Commands {
   #[command(about = "Run user program")]
   Run {
     #[arg(help = "Program to be executed")]
@@ -172,14 +173,9 @@ impl Cli {
         .parse_mount_read(read)?
         .parse_mount_write(write)?
         .done(),
-      Commands::Compile {
-        language,
-        submission,
-        output,
-        ..
-      } => {
+      Commands::Compile { .. } => {
         // make_compile_params(language, submission, output)?
-        unimplemented!()
+        make_compile_params(builder, self.command)?
       }
       Commands::Validate { .. } => {
         unimplemented!()

src/main.rs

@@ -19,7 +19,7 @@ lazy_static! {
           "-Wno-unused-result",
           "-static",
           "-lm",
-          "--std=c++20",
+          "-std=c17",
           "-O2",
           "-DONLINE_JUDGE",
           "-Wall"

src/preset/default/c.rs

@@ -19,7 +19,7 @@ lazy_static! {
           "-Wno-unused-result",
           "-static",
           "-lm",
-          "--std=c++20",
+          "-std=c++17",
           "-O2",
           "-DONLINE_JUDGE",
           "-Wall"

src/preset/default/cpp.rs

@@ -1,9 +1,16 @@
 use std::collections::HashMap;
+use std::fs::canonicalize;
+use std::path::PathBuf;
 
 use lazy_static::lazy_static;
+use log::info;
+use path_absolutize::*;
 
-use crate::context::CatBoxOption;
+use crate::context::{CatBoxBuilder, CatBoxOption};
 use crate::error::CatBoxError;
+use crate::preset::default::{CPP_PRESET, C_PRESET};
+use crate::preset::preset::UserType;
+use crate::Commands;
 
 mod default;
 mod preset;
@@ -42,28 +49,72 @@ fn detect_language(language: &Option<String>, submission: &String) -> Option<Str
   }
 }
 
-pub fn make_compile_params(
-  language: Option<String>,
-  submission: String,
-  _output: String,
-) -> Result<CatBoxOption, CatBoxError> {
-  let language = detect_language(&language, &submission)
-    .ok_or(CatBoxError::cli("Can not detect submission language"))?;
+pub(crate) fn make_compile_params(
+  mut builder: CatBoxBuilder,
+  command: Commands,
+) -> Result<CatBoxBuilder, CatBoxError> {
+  if let Commands::Compile {
+    language,
+    submission,
+    output,
+    ..
+  } = command
+  {
+    let language = detect_language(&language, &submission)
+      .ok_or(CatBoxError::cli("Can not detect submission language"))?;
 
-  unimplemented!()
-  // match language.as_str() {
-  //   "c" => {
-  //     let args = vec![];
-  //     let params = CatBoxOption::new("g++", args);
-  //     Ok(params)
-  //   }
-  //   "cpp" => {
-  //     let args = vec![];
-  //     let params = CatBoxOption::new("g++", args);
-  //     Ok(params)
-  //   }
-  //   _ => {
-  //     unimplemented!()
-  //   }
-  // }
+    let preset = match language.as_str() {
+      "c" => C_PRESET.clone(),
+      "cpp" => CPP_PRESET.clone(),
+      default => return Err(CatBoxError::cli("Can not find language preset")),
+    };
+
+    info!("Compile language {}", &language);
+
+    let submission = PathBuf::from(&submission);
+    let submission = submission.absolutize().unwrap();
+    let submission_dir = submission.parent().unwrap();
+    let output = PathBuf::from(&output);
+    let output = output.absolutize().unwrap();
+    let output_dir = output.parent().unwrap();
+
+    for command in preset.compile.commands.iter() {
+      let option_builder = builder
+        .command(
+          command.apply_program(submission.to_str().unwrap(), output.to_str().unwrap()),
+          command.apply_arguments(submission.to_str().unwrap(), output.to_str().unwrap()),
+        )
+        .time_limit(command.time_limit)
+        .memory_limit(command.memory_limit)
+        .set_process(Some(command.process))
+        .set_chroot(command.chroot)
+        .mount_read(submission_dir, submission_dir)
+        .mount_write(output_dir, output_dir)
+        .disable_ptrace();
+
+      let mut option_builder = match command.user {
+        UserType::Nobody => option_builder,
+        UserType::Current => option_builder.current_user(),
+        UserType::Root => {
+          unimplemented!()
+        }
+      };
+
+      for feat in command.ptrace.iter() {
+        option_builder = option_builder.ptrace(feat.clone())
+      }
+      for mount_point in command.mounts.iter() {
+        option_builder = option_builder.mount(mount_point.clone())
+      }
+      for (key, value) in command.env.iter() {
+        option_builder = option_builder.env(key, value);
+      }
+
+      builder = option_builder.done();
+    }
+
+    Ok(builder)
+  } else {
+    Err(CatBoxError::cli("unreachable"))
+  }
 }

src/preset/mod.rs

@@ -3,37 +3,42 @@ use crate::syscall::RestrictedSyscall;
 use crate::utils::mount::MountPoint;
 use crate::utils::{MemoryLimitType, TimeLimitType};
 
+#[derive(Debug, Clone)]
 pub(crate) struct LanguagePreset {
   pub(crate) compile: CompileOption,
   pub(crate) execute: ExecuteOption,
 }
 
+#[derive(Debug, Clone)]
 pub(crate) struct CompileOption {
   pub(crate) extension: String,
   pub(crate) commands: Vec<ExecuteCommand>,
 }
 
+#[derive(Debug, Clone)]
 pub(crate) struct ExecuteOption {
   pub(crate) commands: Vec<ExecuteCommand>,
 }
 
+#[derive(Debug, Clone)]
 pub(crate) enum UserType {
   Nobody,
   Current,
   Root,
 }
 
+#[derive(Debug, Clone)]
 pub struct ExecuteCommand {
-  program: String,
-  argument: Vec<String>,
-  time_limit: TimeLimitType,
-  memory_limit: MemoryLimitType,
-  user: UserType,
-  process: u64,
-  ptrace: Vec<RestrictedSyscall>,
-  chroot: bool,
-  mounts: Vec<MountPoint>,
-  env: Vec<(String, String)>,
+  pub(crate) program: String,
+  pub(crate) arguments: Vec<String>,
+  pub(crate) time_limit: TimeLimitType,
+  pub(crate) memory_limit: MemoryLimitType,
+  pub(crate) user: UserType,
+  pub(crate) process: u64,
+  pub(crate) ptrace: Vec<RestrictedSyscall>,
+  pub(crate) chroot: bool,
+  pub(crate) mounts: Vec<MountPoint>,
+  pub(crate) env: Vec<(String, String)>,
 }
 
 impl CompileOption {
@@ -65,7 +70,7 @@ impl ExecuteCommand {
   pub(crate) fn new<PS: Into<String>, AS: Into<String>>(program: PS, arguments: Vec<AS>) -> Self {
     ExecuteCommand {
       program: program.into(),
-      argument: arguments.into_iter().map(|a| a.into()).collect(),
+      arguments: arguments.into_iter().map(|a| a.into()).collect(),
       time_limit: 1000,
       memory_limit: 262144,
       user: UserType::Nobody,
@@ -77,6 +82,24 @@ impl ExecuteCommand {
     }
   }
 
+  fn apply(text: &str, source: &str, executable: &str) -> String {
+    text
+      .replace("${source}", source)
+      .replace("${executable}", executable)
+  }
+
+  pub(crate) fn apply_program(&self, source: &str, executable: &str) -> String {
+    Self::apply(self.program.as_str(), source, executable)
+  }
+
+  pub(crate) fn apply_arguments(&self, source: &str, executable: &str) -> Vec<String> {
+    self
+      .arguments
+      .iter()
+      .map(|a| Self::apply(a, source, executable))
+      .collect()
+  }
+
   pub(crate) fn default_time_limit(mut self, value: TimeLimitType) -> Self {
     self.time_limit = value;
     self