feat: added SIGHUP handling for crond

Author: vadimb892

cron/Cargo.toml

@@ -29,5 +29,5 @@ name = "crond"
 path = "./crond.rs"
 
 [lib]
-name = "job"
-path = "./job.rs"
+name = "cron"
+path = "./lib.rs"

cron/crond.rs

@@ -7,43 +7,85 @@
 // SPDX-License-Identifier: MIT
 //
 
-pub mod job;
-
-use crate::job::Database;
+use cron::job::Database;
 use chrono::Local;
 use gettextrs::{bind_textdomain_codeset, setlocale, textdomain, LocaleCategory};
 use std::env;
 use std::error::Error;
-use std::fs;
 use std::str::FromStr;
+use std::fs;
+use std::time::UNIX_EPOCH;
+use std::fmt;
+use std::sync::Mutex;
 
-fn parse_cronfile(username: &str) -> Result<Database, Box<dyn Error>> {
-    #[cfg(target_os = "linux")]
-    let file = format!("/var/spool/cron/{username}");
-    #[cfg(target_os = "macos")]
-    let file = format!("/var/at/tabs/{username}");
-    let s = fs::read_to_string(&file)?;
-    Ok(s.lines()
-        .filter_map(|x| Database::from_str(x).ok())
-        .fold(Database(vec![]), |acc, next| acc.merge(next)))
+static CRONTAB: Mutex<Option<Database>> = Mutex::new(None);
+static LAST_MODIFIED: Mutex<Option<u64>> = Mutex::new(None);
+
+#[derive(Debug)]
+enum CronError{
+    Fork,
+    NoLogname,
+    NoCrontab
 }
 
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    setlocale(LocaleCategory::LcAll, "");
-    textdomain("posixutils-rs")?;
-    bind_textdomain_codeset("posixutils-rs", "UTF-8")?;
+impl Error for CronError {}
+
+impl fmt::Display for CronError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self{
+            Self::NoLogname => write!(f, "Could not obtain the user's logname"),
+            Self::NoCrontab => write!(f, "Could not format database"),
+            Self::Fork => write!(f, "Could not create child process")
+        }
+    }
+}
+
+/// Check if logname file is changed
+fn is_file_changed(filepath: &str) -> Result<bool, Box<dyn Error>> {
+    let last_modified = fs::metadata(filepath)?
+        .modified()?
+        .duration_since(UNIX_EPOCH)?
+        .as_secs();
+    
+    let Some(last_checked) = *LAST_MODIFIED.lock().unwrap() else{
+        *LAST_MODIFIED.lock().unwrap() = Some(last_modified);
+        return Ok(true);
+    };
+    if last_checked <= last_modified{
+        *LAST_MODIFIED.lock().unwrap() = Some(last_modified);
+        Ok(true)
+    }else{
+        Ok(false)
+    }
+}
 
+/// Update [`CRONTAB`] if logname file is changed
+fn sync_cronfile() -> Result<(), Box<dyn Error>> {
     let Ok(logname) = env::var("LOGNAME") else {
-        panic!("Could not obtain the user's logname.")
+        return Err(Box::new(CronError::NoLogname));
     };
+    #[cfg(target_os = "linux")]
+    let file = format!("/var/spool/cron/{logname}");
+    #[cfg(target_os = "macos")]
+    let file = format!("/var/at/tabs/{logname}");
+    if (*CRONTAB.lock().unwrap()).is_none() || is_file_changed(&file)?{
+        let s = fs::read_to_string(&file)?;
+        let crontab = s.lines()
+            .filter_map(|x| Database::from_str(x).ok())
+            .fold(Database(vec![]), |acc, next| acc.merge(next));
+        *CRONTAB.lock().unwrap() = Some(crontab); 
+    }
+    Ok(())
+}
 
-    // Daemon setup
+/// Create new daemon process of crond
+fn setup() -> i32{
     unsafe {
         use libc::*;
 
         let pid = fork();
-        if pid > 0 {
-            return Ok(());
+        if pid != 0 {
+            return pid;
         }
 
         setsid();
@@ -52,12 +94,28 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         close(STDIN_FILENO);
         close(STDOUT_FILENO);
         close(STDERR_FILENO);
+        
+        return pid;
     }
+}
 
-    // Daemon code
+/// Handles incoming signals
+fn handle_signals(signal_code: libc::c_int) {
+    if signal_code == libc::SIGHUP {
+        if let Err(err) = sync_cronfile(){
+            eprintln!("{err}");
+            std::process::exit(1);
+        }
+    }
+}
 
+/// Daemon loop
+fn daemon_loop() -> Result<(), Box<dyn Error>> {
     loop {
-        let db = parse_cronfile(&logname)?;
+        sync_cronfile()?;
+        let Some(db) = CRONTAB.lock().unwrap().clone() else{
+            return Err(Box::new(CronError::NoCrontab));
+        };
         let Some(x) = db.nearest_job() else {
             sleep(60);
             continue;
@@ -79,6 +137,26 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     }
 }
 
+fn main() -> Result<(), Box<dyn Error>> {
+    setlocale(LocaleCategory::LcAll, "");
+    textdomain("posixutils-rs")?;
+    bind_textdomain_codeset("posixutils-rs", "UTF-8")?;
+
+    let pid = setup();
+
+    if pid < 0{
+        return Err(Box::new(CronError::Fork));
+    }else if pid > 0{
+        return Ok(());
+    }
+
+    unsafe {
+        libc::signal(libc::SIGHUP, handle_signals as usize);
+    }
+
+    daemon_loop()
+}
+
 fn sleep(target: u32) {
     unsafe { libc::sleep(target) };
-}
+}

cron/job.rs

@@ -118,6 +118,7 @@ pub struct CronJob {
     pub command: String,
 }
 
+#[derive(Clone)]
 pub struct Database(pub Vec<CronJob>);
 
 impl Database {

cron/lib.rs

@@ -0,0 +1,10 @@
+//
+// Copyright (c) 2024 Hemi Labs, Inc.
+//
+// This file is part of the posixutils-rs project covered under
+// the MIT License.  For the full license text, please see the LICENSE
+// file in the root directory of this project.
+// SPDX-License-Identifier: MIT
+//
+
+pub mod job;

cron/tests/crond/mod.rs

@@ -7,10 +7,13 @@
 // SPDX-License-Identifier: MIT
 //
 
+mod pid;
+
 use chrono::{NaiveDate, NaiveDateTime, NaiveTime};
-use job::Database;
+use cron::job::Database;
 use std::io::Write;
 use std::process::{Command, Output, Stdio};
+use std::str::FromStr;
 use std::thread;
 use std::time::Duration;
 
@@ -212,3 +215,43 @@ fn test_month() {
             .unwrap()
     );
 }
+
+#[test]
+fn test_signal() {
+    std::env::set_var("LOGNAME", "root");
+    let logname = std::env::var("LOGNAME").unwrap_or("root".to_string());
+    #[cfg(target_os = "linux")]
+    let file = format!("/var/spool/cron/{logname}");
+    #[cfg(target_os = "macos")]
+    let file = format!("/var/at/tabs/{logname}");
+    let mut tmp_file_created = false;
+    let filepath = std::path::PathBuf::from_str(&file).unwrap();
+    if !filepath.exists(){
+        std::fs::File::create(&file).unwrap();
+        tmp_file_created = true;
+    }
+
+    let output = run_test_base("crond", &vec![], b"");
+    assert_eq!(output.status.code(), Some(0));
+
+    let pids = pid::get_pids("target/debug/crond").unwrap();
+    assert!(!pids.is_empty());
+    for pid in &pids{
+        unsafe{
+            libc::kill(*pid, libc::SIGHUP);
+        }
+    }
+
+    let mut old_pids = pids;
+    let mut pids = pid::get_pids("target/debug/crond").unwrap();
+
+    pids.sort();
+    old_pids.sort();
+    assert!(pids == old_pids || !pids.is_empty());
+
+    let _ = pid::kill("target/debug/crond").unwrap();
+
+    if tmp_file_created && filepath.starts_with("/var/at/tabs"){
+        let _ = std::fs::remove_file(file);
+    }
+}

cron/tests/crond/pid.rs

@@ -0,0 +1,99 @@
+use std::process::{Command, Output, Stdio};
+use std::string::FromUtf8Error;
+
+fn run_command(cmd: &mut Command) -> Result<Output, String> {
+    cmd.stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .output()
+        .map_err(|e| format!("Failed to execute command: {}", e))
+}
+
+pub fn get_pids(process_name: &str) -> Result<Vec<i32>, String> {
+    // Use '[v]i' pattern to prevent grep from matching itself
+    let grep_pattern =
+        format!("[{}]", process_name.chars().next().unwrap_or('?')) + &process_name[1..];
+    let list_cmd_str = format!("ps aux | grep '{}'", grep_pattern);
+
+    let mut list_cmd = Command::new("sh");
+    list_cmd.arg("-c").arg(&list_cmd_str);
+
+    let output = run_command(&mut list_cmd)?;
+
+    if !output.status.success() {
+        // `grep` returns non-zero if no lines match, which isn't necessarily a hard error here.
+        // Check stderr for actual execution errors from `ps` or `sh`.
+        if !output.stderr.is_empty() && output.stdout.is_empty() {
+            return Err(format!(
+                "Process listing command failed with status {}: {}",
+                output.status,
+                String::from_utf8_lossy(&output.stderr).trim()
+            ));
+        }
+    }
+
+    let stdout_str = String::from_utf8(output.stdout.clone())
+        .map_err(|e: FromUtf8Error| format!("Failed to parse stdout as UTF-8: {}", e))?;
+
+    println!("{}", stdout_str);
+    let mut pids = Vec::new();
+    for line in stdout_str.lines() {
+        let parts: Vec<&str> = line.split_whitespace().collect();
+        // `ps aux` typically has PID in the second column (index 1)
+        if parts.len() > 1 {
+            if let Ok(pid) = parts[1].parse::<i32>() {
+                // Double-check it's not the grep command itself if the simple pattern was used
+                if !line.contains("grep") {
+                    pids.push(pid);
+                }
+            }
+        }
+    }
+
+    Ok(pids)
+}
+
+pub fn kill(process_name: &str) -> Result<(), String> {
+    let pids = get_pids(process_name)?;
+
+    if pids.is_empty() {
+        return Ok(());
+    }
+
+    let mut kill_errors = Vec::new();
+
+    for pid in pids {
+        let mut kill_cmd = Command::new("kill");
+        kill_cmd.arg("-9").arg(pid.to_string()); // Send SIGKILL
+
+        match run_command(&mut kill_cmd) {
+            Ok(kill_output) => {
+                if !kill_output.status.success() {
+                    // Kill can fail due to permissions or if the process died already
+                    let err_msg = format!(
+                        "Failed to kill PID {}: Exit status: {}, Stderr: {}",
+                        pid,
+                        kill_output.status,
+                        String::from_utf8_lossy(&kill_output.stderr).trim()
+                    );
+                    eprintln!("{}", err_msg); // Print immediately
+                    kill_errors.push(err_msg);
+                }
+            }
+            Err(e) => {
+                // Error executing the kill command itself
+                let err_msg = format!("Failed to execute kill command for PID {}: {}", pid, e);
+                eprintln!("{}", err_msg);
+                kill_errors.push(err_msg);
+            }
+        }
+    }
+
+    if kill_errors.is_empty() {
+        Ok(())
+    } else {
+        Err(format!(
+            "Encountered errors while killing processes:\n{}",
+            kill_errors.join("\n")
+        ))
+    }
+}