* Mini start-stop-daemon implementation(s) for busybox
*
* Written by Marek Michalkiewicz <marekm@i17linuxb.ists.pwr.wroc.pl>,
- * public domain.
* Adapted for busybox David Kimdon <dwhedon@gordian.com>
+ *
+ * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
*/
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdarg.h>
-#include <signal.h>
-#include <errno.h>
-#include <sys/stat.h>
-#include <dirent.h>
-#include <unistd.h>
-
#include "busybox.h"
-#include "pwd.h"
+#include <getopt.h>
+#include <sys/resource.h>
-static int start = 0;
-static int stop = 0;
-static int fork_before_exec = 0;
static int signal_nr = 15;
static int user_id = -1;
-static const char *userspec = NULL;
-static const char *cmdname = NULL;
-static char *execname = NULL;
-static char *startas = NULL;
+static char *userspec;
+static char *cmdname;
+static char *execname;
+static char *pidfile;
+static smallint quiet;
-typedef struct pid_list {
+struct pid_list {
struct pid_list *next;
- int pid;
-} pid_list;
+ pid_t pid;
+};
-static pid_list *found = NULL;
+static struct pid_list *found;
-static inline void
-push(int pid)
+static inline void push(pid_t pid)
{
- pid_list *p;
+ struct pid_list *p;
p = xmalloc(sizeof(*p));
p->next = found;
found = p;
}
-
-static void
-parse_options(int argc, char * const *argv)
-{
-
- int c;
-
- for (;;) {
- c = getopt (argc, argv, "a:n:s:u:x:KSb");
- if (c == EOF)
- break;
- switch (c) {
- case 'K':
- stop = 1;
- break;
- case 'S':
- start = 1;
- break;
- case 'a':
- startas = optarg;
- break;
- case 'n':
- cmdname = optarg;
- break;
- case 's':
- if (sscanf(optarg, "%d", &signal_nr) != 1)
- error_msg_and_die ("-s takes a numeric argument");
- break;
- case 'u':
- userspec = optarg;
- break;
- case 'x':
- execname = optarg;
- break;
- case 'b':
- fork_before_exec = 1;
- break;
- default:
- show_usage();
- }
- }
-
- if (start == stop)
- error_msg_and_die ("need one of -S or -K");
-
- if (!execname && !userspec)
- error_msg_and_die ("need at least one of -x or -u");
-
- if (!startas)
- startas = execname;
-
- if (start && !startas)
- error_msg_and_die ("-S needs -x or -a");
-}
-
-
-static int
-pid_is_exec(int pid, const char *exec)
+static int pid_is_exec(pid_t pid, const char *name)
{
- char buf[PATH_MAX];
- FILE *fp;
-
- sprintf(buf, "/proc/%d/cmdline", pid);
- fp = fopen(buf, "r");
- if (fp && fgets (buf, sizeof (buf), fp) ) {
- if (strncmp (buf, exec, strlen(exec)) == 0)
- return 1;
- }
- return 0;
+ char buf[sizeof("/proc//exe") + sizeof(int)*3];
+ char *execbuf;
+ int sz;
+ int equal;
+
+ sprintf(buf, "/proc/%d/exe", pid);
+ sz = strlen(name) + 1;
+ execbuf = xzalloc(sz);
+ readlink(buf, execbuf, sz);
+
+ /* if readlink fails, execbuf still contains "" */
+ equal = !strcmp(execbuf, name);
+ if (ENABLE_FEATURE_CLEAN_UP)
+ free(execbuf);
+ return equal;
}
-
-static int
-pid_is_user(int pid, int uid)
+static int pid_is_user(int pid, int uid)
{
struct stat sb;
- char buf[32];
+ char buf[sizeof("/proc/") + sizeof(int)*3];
- sprintf(buf, "/proc/%d", pid);
+ sprintf(buf, "/proc/%u", pid);
if (stat(buf, &sb) != 0)
return 0;
return (sb.st_uid == uid);
}
-
-static int
-pid_is_cmd(int pid, const char *name)
+static int pid_is_cmd(pid_t pid, const char *name)
{
- char buf[32];
- FILE *f;
- int c;
-
- sprintf(buf, "/proc/%d/stat", pid);
- f = fopen(buf, "r");
- if (!f)
- return 0;
- while ((c = getc(f)) != EOF && c != '(')
- ;
- if (c != '(') {
- fclose(f);
- return 0;
+ char fname[sizeof("/proc//stat") + sizeof(int)*3];
+ char *buf;
+ int r = 0;
+
+ sprintf(fname, "/proc/%u/stat", pid);
+ buf = xmalloc_open_read_close(fname, NULL);
+ if (buf) {
+ char *p = strchr(buf, '(');
+ if (p) {
+ char *pe = strrchr(++p, ')');
+ if (pe) {
+ *pe = '\0';
+ r = !strcmp(p, name);
+ }
+ }
+ free(buf);
}
- /* this hopefully handles command names containing ')' */
- while ((c = getc(f)) != EOF && c == *name)
- name++;
- fclose(f);
- return (c == ')' && *name == '\0');
+ return r;
}
-static void
-check(int pid)
+static void check(int pid)
{
if (execname && !pid_is_exec(pid, execname)) {
return;
}
+static void do_pidfile(void)
+{
+ FILE *f;
+ pid_t pid;
+
+ f = fopen(pidfile, "r");
+ if (f) {
+ if (fscanf(f, "%u", &pid) == 1)
+ check(pid);
+ fclose(f);
+ } else if (errno != ENOENT)
+ bb_perror_msg_and_die("open pidfile %s", pidfile);
+}
-static void
-do_procfs(void)
+static void do_procinit(void)
{
DIR *procdir;
struct dirent *entry;
int foundany, pid;
- procdir = opendir("/proc");
- if (!procdir)
- perror_msg_and_die ("opendir /proc");
+ if (pidfile) {
+ do_pidfile();
+ return;
+ }
+
+ procdir = xopendir("/proc");
foundany = 0;
while ((entry = readdir(procdir)) != NULL) {
- if (sscanf(entry->d_name, "%d", &pid) != 1)
+ pid = bb_strtou(entry->d_name, NULL, 10);
+ if (errno)
continue;
foundany++;
check(pid);
}
closedir(procdir);
if (!foundany)
- error_msg_and_die ("nothing in /proc - not mounted?");
+ bb_error_msg_and_die ("nothing in /proc - not mounted?");
}
-static void
-do_stop(void)
+static int do_stop(void)
{
- char what[1024];
- pid_list *p;
+ char *what;
+ struct pid_list *p;
int killed = 0;
+ do_procinit();
+
if (cmdname)
- strcpy(what, cmdname);
+ what = xstrdup(cmdname);
else if (execname)
- strcpy(what, execname);
+ what = xstrdup(execname);
+ else if (pidfile)
+ what = xasprintf("process in pidfile '%s'", pidfile);
else if (userspec)
- sprintf(what, "process(es) owned by `%s'", userspec);
+ what = xasprintf("process(es) owned by '%s'", userspec);
else
- error_msg_and_die ("internal error, please report");
+ bb_error_msg_and_die("internal error, please report");
if (!found) {
- printf("no %s found; none killed.\n", what);
- return;
+ if (!quiet)
+ printf("no %s found; none killed\n", what);
+ if (ENABLE_FEATURE_CLEAN_UP)
+ free(what);
+ return -1;
}
for (p = found; p; p = p->next) {
if (kill(p->pid, signal_nr) == 0) {
p->pid = -p->pid;
killed++;
} else {
- perror_msg("warning: failed to kill %d:", p->pid);
+ bb_perror_msg("warning: failed to kill %d", p->pid);
}
}
- if (killed) {
+ if (!quiet && killed) {
printf("stopped %s (pid", what);
for (p = found; p; p = p->next)
if(p->pid < 0)
printf(" %d", -p->pid);
- printf(").\n");
+ puts(")");
}
+ if (ENABLE_FEATURE_CLEAN_UP)
+ free(what);
+ return killed;
}
-
-int
-start_stop_daemon_main(int argc, char **argv)
+#if ENABLE_FEATURE_START_STOP_DAEMON_LONG_OPTIONS
+static const struct option long_options[] = {
+ { "stop", 0, NULL, 'K' },
+ { "start", 0, NULL, 'S' },
+ { "background", 0, NULL, 'b' },
+ { "quiet", 0, NULL, 'q' },
+ { "make-pidfile", 0, NULL, 'm' },
+#if ENABLE_FEATURE_START_STOP_DAEMON_FANCY
+ { "oknodo", 0, NULL, 'o' },
+ { "verbose", 0, NULL, 'v' },
+ { "nicelevel", 1, NULL, 'N' },
+#endif
+ { "startas", 1, NULL, 'a' },
+ { "name", 1, NULL, 'n' },
+ { "signal", 1, NULL, 's' },
+ { "user", 1, NULL, 'u' },
+ { "chuid", 1, NULL, 'c' },
+ { "exec", 1, NULL, 'x' },
+ { "pidfile", 1, NULL, 'p' },
+#if ENABLE_FEATURE_START_STOP_DAEMON_FANCY
+ { "retry", 1, NULL, 'R' },
+#endif
+ { 0, 0, 0, 0 }
+};
+#endif
+
+enum {
+ CTX_STOP = 0x1,
+ CTX_START = 0x2,
+ OPT_BACKGROUND = 0x4, // -b
+ OPT_QUIET = 0x8, // -q
+ OPT_MAKEPID = 0x10, // -m
+ OPT_a = 0x20, // -a
+ OPT_n = 0x40, // -n
+ OPT_s = 0x80, // -s
+ OPT_u = 0x100, // -u
+ OPT_c = 0x200, // -c
+ OPT_x = 0x400, // -x
+ OPT_p = 0x800, // -p
+ OPT_OKNODO = 0x1000 * ENABLE_FEATURE_START_STOP_DAEMON_FANCY, // -o
+ OPT_VERBOSE = 0x2000 * ENABLE_FEATURE_START_STOP_DAEMON_FANCY, // -v
+ OPT_NICELEVEL = 0x4000 * ENABLE_FEATURE_START_STOP_DAEMON_FANCY, // -N
+};
+
+int start_stop_daemon_main(int argc, char **argv);
+int start_stop_daemon_main(int argc, char **argv)
{
- parse_options(argc, argv);
+ unsigned opt;
+ char *signame;
+ char *startas;
+ char *chuid;
+#if ENABLE_FEATURE_START_STOP_DAEMON_FANCY
+// char *retry_arg = NULL;
+// int retries = -1;
+ char *opt_N;
+#endif
+#if ENABLE_FEATURE_START_STOP_DAEMON_LONG_OPTIONS
+ applet_long_options = long_options;
+#endif
+
+ /* Check required one context option was given */
+ opt_complementary = "K:S:?:K--S:S--K:m?p:K?xpun:S?xa";
+ opt = getopt32(argc, argv, "KSbqma:n:s:u:c:x:p:"
+ USE_FEATURE_START_STOP_DAEMON_FANCY("ovN:"),
+// USE_FEATURE_START_STOP_DAEMON_FANCY("ovN:R:"),
+ &startas, &cmdname, &signame, &userspec, &chuid, &execname, &pidfile
+ USE_FEATURE_START_STOP_DAEMON_FANCY(,&opt_N)
+// USE_FEATURE_START_STOP_DAEMON_FANCY(,&retry_arg)
+ );
+
+ quiet = (opt & OPT_QUIET) && !(opt & OPT_VERBOSE);
+
+ if (opt & OPT_s) {
+ signal_nr = get_signum(signame);
+ if (signal_nr < 0) bb_show_usage();
+ }
+
+ if (!(opt & OPT_a))
+ startas = execname;
+
+// USE_FEATURE_START_STOP_DAEMON_FANCY(
+// if (retry_arg)
+// retries = xatoi_u(retry_arg);
+// )
argc -= optind;
argv += optind;
- if (userspec && sscanf(userspec, "%d", &user_id) != 1)
- user_id = my_getpwnam(userspec);
-
- do_procfs();
+ if (userspec) {
+ user_id = bb_strtou(userspec, NULL, 10);
+ if (errno)
+ user_id = xuname2uid(userspec);
+ }
- if (stop) {
- do_stop();
- return EXIT_SUCCESS;
+ if (opt & CTX_STOP) {
+ int i = do_stop();
+ return (opt & OPT_OKNODO) ? 0 : (i<=0);
}
+ do_procinit();
+
if (found) {
- printf("%s already running.\n%d\n", execname ,found->pid);
- return EXIT_SUCCESS;
+ if (!quiet)
+ printf("%s already running\n%d\n", execname, found->pid);
+ return !(opt & OPT_OKNODO);
}
*--argv = startas;
- if (fork_before_exec) {
- if (daemon(0, 0) == -1)
- perror_msg_and_die ("unable to fork");
+ if (opt & OPT_BACKGROUND) {
+ bb_daemonize(0);
}
- setsid();
+ if (opt & OPT_MAKEPID) {
+ /* user wants _us_ to make the pidfile */
+ FILE *pidf = xfopen(pidfile, "w");
+
+ pid_t pidt = getpid();
+ fprintf(pidf, "%d\n", pidt);
+ fclose(pidf);
+ }
+ if (opt & OPT_c) {
+ struct bb_uidgid_t ugid;
+ parse_chown_usergroup_or_die(&ugid, chuid);
+ if (ugid.gid != (gid_t) -1) xsetgid(ugid.gid);
+ if (ugid.uid != (uid_t) -1) xsetuid(ugid.uid);
+ }
+#if ENABLE_FEATURE_START_STOP_DAEMON_FANCY
+ if (opt & OPT_NICELEVEL) {
+ /* Set process priority */
+ int prio = getpriority(PRIO_PROCESS, 0) + xatoi_range(opt_N, INT_MIN/2, INT_MAX/2);
+ if (setpriority(PRIO_PROCESS, 0, prio) < 0) {
+ bb_perror_msg_and_die("setpriority(%d)", prio);
+ }
+ }
+#endif
execv(startas, argv);
- perror_msg_and_die ("unable to start %s", startas);
+ bb_perror_msg_and_die("cannot start %s", startas);
}
-