1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
use std::any::Any;
use std::convert::TryFrom;
use std::ffi::{CString, OsStr, OsString};
use std::fs::File;
use std::io::prelude::*;
use std::path::{Path, PathBuf};
use std::process::exit;
use nix::sys::stat::{Mode, umask};
#[cfg(not(target_os = "macos"))]
use nix::unistd::{
chdir, chown, fork, ForkResult, getpid, Gid, initgroups, Pid, setgid, setsid,
setuid, Uid,
};
#[cfg(target_os = "macos")]
use nix::unistd::{
chdir, chown, close, dup2, fork, ForkResult, getpid, Gid, Pid, setgid, setsid, setuid, Uid,
};
use crate::{DaemonError, Result};
use crate::DaemonError::{InvalidGroup, InvalidUser};
use crate::ffi::{PasswdRecord, set_proc_name};
use crate::group::Group;
use crate::stdio::{redirect_stdio, Stdio};
use crate::user::User;
/// Basic daemonization consists of:
/// forking the process, getting a new sid, setting the umask, changing the standard io streams
/// to files and finally dropping privileges.
///
/// Options:
/// * user [optional], if set will drop privileges to the specified user **NOTE**: This library is strict and makes no assumptions if you provide a user you must provide a group
/// * group [optional(**see note on user**)], if set will drop privileges to specified group
/// * umask [optional], umask for the process defaults to 0o027
/// * pid_file [optional], if set a pid file will be created default is that no file is created *
/// * stdio [optional][**recommended**], this determines where standard output will be piped to since daemons have no console it's highly recommended to set this
/// * stderr [optional][**recommended**], same as above but for standard error
/// * chdir [optional], default is "/"
/// * name [optional], set the daemon process name eg what shows in `ps` default is to not set a process name
/// * before_fork_hook [optional], called before the fork with the current pid as argument
/// * after_fork_parent_hook [optional], called after the fork with the parent pid as argument, can be used to continue some work on the parent after the fork (do not return)
/// * after_fork_child_hook [optional], called after the fork with the parent and child pid as arguments
///
/// * See the setter function documentation for more details
///
/// **Beware there is no escalation back if dropping privileges**
pub struct Daemon<'a> {
pub(crate) chdir: PathBuf,
pub(crate) pid_file: Option<PathBuf>,
pub(crate) chown_pid_file: bool,
pub(crate) user: Option<User>,
pub(crate) group: Option<Group>,
pub(crate) umask: u16,
// stdin is practically always null
pub(crate) stdin: Stdio,
pub(crate) stdout: Stdio,
pub(crate) stderr: Stdio,
pub(crate) name: Option<OsString>,
pub(crate) before_fork_hook: Option<fn(pid: i32)>,
pub(crate) after_fork_parent_hook: Option<fn(parent_pid: i32, child_pid: i32) -> !>,
pub(crate) after_fork_child_hook: Option<fn(parent_pid: i32, child_pid: i32) -> ()>,
pub(crate) after_init_hook_data: Option<&'a dyn Any>,
pub(crate) after_init_hook: Option<fn(Option<&'a dyn Any>)>,
}
impl<'a> Daemon<'a> {
pub fn new() -> Self {
Daemon {
chdir: Path::new("/").to_owned(),
pid_file: None,
chown_pid_file: false,
user: None,
group: None,
umask: 0o027,
stdin: Stdio::devnull(),
stdout: Stdio::devnull(),
stderr: Stdio::devnull(),
name: None,
before_fork_hook: None,
after_fork_parent_hook: None,
after_fork_child_hook: None,
after_init_hook_data: None,
after_init_hook: None,
}
}
/// This is a setter to give your daemon a pid file
/// # Arguments
/// * `path` - path to the file suggested `/var/run/my_program_name.pid`
/// * `chmod` - if set a chmod of the file to the user and group passed will be attempted (**this being true makes setting an user and group mandatory**)
pub fn pid_file<T: AsRef<Path>>(mut self, path: T, chmod: Option<bool>) -> Self {
self.pid_file = Some(path.as_ref().to_owned());
self.chown_pid_file = chmod.unwrap_or(false);
self
}
/// As the last step the code will change the working directory to this one defaults to `/`
pub fn work_dir<T: AsRef<Path>>(mut self, path: T) -> Self {
self.chdir = path.as_ref().to_owned();
self
}
/// The code will attempt to drop privileges with `setuid` to the provided user
pub fn user<T: Into<User>>(mut self, user: T) -> Self {
self.user = Some(user.into());
self
}
/// The code will attempt to drop privileges with `setgid` to the provided group, you mut provide a group if you provide an user
pub fn group<T: Into<Group>>(mut self, group: T) -> Self {
self.group = Some(group.into());
self
}
pub fn group_copy_user(mut self) -> Result<Self> {
if let Some(user) = &self.user {
self.group = Some(Group::try_from(&user.name)?);
Ok(self)
} else {
Err(InvalidUser)
}
}
pub fn umask(mut self, mask: u16) -> Self {
self.umask = mask;
self
}
pub fn stdin<T: Into<Stdio>>(mut self, stdio: T) -> Self {
self.stdin = stdio.into();
self
}
pub fn stdout<T: Into<Stdio>>(mut self, stdio: T) -> Self {
self.stdout = stdio.into();
self
}
pub fn stderr<T: Into<Stdio>>(mut self, stdio: T) -> Self {
self.stderr = stdio.into();
self
}
pub fn name(mut self, name: &OsStr) -> Self {
self.name = Some(OsString::from(name));
self
}
pub fn setup_pre_fork_hook(mut self, pre_fork_hook: fn(pid: i32)) -> Self {
self.before_fork_hook = Some(pre_fork_hook);
self
}
pub fn setup_post_fork_parent_hook(mut self, post_fork_parent_hook: fn(parent_pid: i32, child_pid: i32) -> !) -> Self {
self.after_fork_parent_hook = Some(post_fork_parent_hook);
self
}
pub fn setup_post_fork_child_hook(mut self, post_fork_child_hook: fn(parent_pid: i32, child_pid: i32) -> ()) -> Self {
self.after_fork_child_hook = Some(post_fork_child_hook);
self
}
pub fn setup_post_init_hook(mut self, post_fork_child_hook: fn(ctx: Option<&'a dyn Any>),
data: Option<&'a dyn Any>) -> Self {
self.after_init_hook = Some(post_fork_child_hook);
self.after_init_hook_data = data;
self
}
/// Using the parameters set, daemonize the process
pub fn start(self) -> Result<()> {
let mut pid: Pid;
let parent_pid = getpid();
// resolve options to concrete values to please the borrow checker
let has_pid_file = self.pid_file.is_some();
let pid_file_path = match self.pid_file {
Some(path) => path.clone(),
None => Path::new("").to_path_buf(),
};
// If the hook is set call it with the parent pid
if let Some(hook) = self.before_fork_hook {
hook(parent_pid.as_raw());
}
// Fork and if the process is the parent exit gracefully
// if the process is the child just continue execution
// this was made unsafe by the nix upstream in between versions
// thus the unsafe block is required here
unsafe {
match fork() {
Ok(ForkResult::Parent { child: cpid }) => {
if let Some(hook) = self.after_fork_parent_hook {
hook(parent_pid.as_raw(), cpid.as_raw());
} else {
exit(0)
}
}
Ok(ForkResult::Child) => {
// Set up stream redirection as early as possible
redirect_stdio(&self.stdin, &self.stdout, &self.stderr)?;
pid = getpid();
if let Some(hook) = self.after_fork_child_hook {
hook(parent_pid.as_raw(), pid.as_raw());
}
()
}
Err(_) => return Err(DaemonError::Fork),
}
}
if self.chown_pid_file && (self.user.is_none() || self.group.is_none()) {
return Err(DaemonError::InvalidUserGroupPair);
} else if (self.user.is_some() || self.group.is_some())
&& (self.user.is_none() || self.group.is_none())
{
return Err(DaemonError::InvalidUserGroupPair);
}
if let Some(proc_name) = &self.name {
match set_proc_name(proc_name.as_ref()) {
Ok(()) => (),
Err(e) => return Err(e)
}
}
// Set the umask either to 0o027 (rwxr-x---) or provided value
let umask_mode = match Mode::from_bits(self.umask as _) {
Some(mode) => mode,
None => return Err(DaemonError::InvalidUmaskBits),
};
umask(umask_mode);
// Set the sid so the process isn't session orphan
if let Err(_) = setsid() {
return Err(DaemonError::SetSid);
};
if let Err(_) = chdir::<Path>(self.chdir.as_path()) {
return Err(DaemonError::ChDir);
};
pid = getpid();
// create pid file and if configured to, chmod it
if has_pid_file {
// chmod of the pid file is deferred to after checking for the presence of the user and group
let pid_file = &pid_file_path;
match File::create(pid_file) {
Ok(mut fp) => {
if let Err(_) = fp.write_all(pid.to_string().as_ref()) {
return Err(DaemonError::WritePid);
}
}
Err(_) => return Err(DaemonError::WritePid),
};
}
// Drop privileges and chown the requested files
if self.user.is_some() && self.group.is_some() {
let user = match self.user {
Some(user) => Uid::from_raw(user.id),
None => return Err(InvalidUser),
};
let uname = match PasswdRecord::lookup_record_by_id(user.as_raw()) {
Ok(record) => record.pw_name,
Err(_) => return Err(DaemonError::InvalidUser),
};
let gr = match self.group {
Some(grp) => Gid::from_raw(grp.id),
None => return Err(InvalidGroup),
};
if self.chown_pid_file && has_pid_file {
match chown(&pid_file_path, Some(user), Some(gr)) {
Ok(_) => (),
Err(_) => return Err(DaemonError::ChownPid),
};
}
match setgid(gr) {
Ok(_) => (),
Err(_) => return Err(DaemonError::SetGid),
};
#[cfg(not(target_os = "macos"))]
{
let u_cstr = match CString::new(uname) {
Ok(cstr) => cstr,
Err(_) => return Err(DaemonError::SetGid),
};
match initgroups(&u_cstr, gr) {
Ok(_) => (),
Err(_) => return Err(DaemonError::InitGroups),
};
}
match setuid(user) {
Ok(_) => (),
Err(_) => return Err(DaemonError::SetUid),
}
};
// chdir
let chdir_path = self.chdir.to_owned();
match chdir::<Path>(chdir_path.as_ref()) {
Ok(_) => (),
Err(_) => return Err(DaemonError::ChDir),
};
// Now this process should be a daemon, we run the hook and return or just return
if let Some(hook) = self.after_init_hook {
hook(self.after_init_hook_data);
Ok(())
} else {
Ok(())
}
}
}