Changeset 2725 in MondoRescue for branches/2.2.9/mindi-busybox/debianutils/start_stop_daemon.c

Timestamp:

Feb 25, 2011, 9:26:54 PM (13 years ago)

Author:

Bruno Cornec

Message:

• Update mindi-busybox to 1.18.3 to avoid problems with the tar command which is now failing on recent versions with busybox 1.7.3

File:

• branches/2.2.9/mindi-busybox/debianutils/start_stop_daemon.c (modified) (18 diffs)

branches/2.2.9/mindi-busybox/debianutils/start_stop_daemon.c

@@ -6 +6 @@
  * Adapted for busybox David Kimdon <dwhedon@gordian.com>
  *
- * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
  */
 
-/* NB: we have a problem here with /proc/NN/exe usage, similar to
- * one fixed in killall/pidof */
-
-#include <getopt.h>
+/*
+This is how it is supposed to work:
+
+start-stop-daemon [OPTIONS] [--start|--stop] [[--] arguments...]
+
+One (only) of these must be given:
+        -S,--start              Start
+        -K,--stop               Stop
+
+Search for matching processes.
+If --stop is given, stop all matching processes (by sending a signal).
+If --start is given, start a new process unless a matching process was found.
+
+Options controlling process matching
+(if multiple conditions are specified, all must match):
+        -u,--user USERNAME|UID  Only consider this user's processes
+        -n,--name PROCESS_NAME  Look for processes by matching PROCESS_NAME
+                                with comm field in /proc/$PID/stat.
+                                Only basename is compared:
+                                "ntpd" == "./ntpd" == "/path/to/ntpd".
+[TODO: can PROCESS_NAME be a full pathname? Should we require full match then
+with /proc/$PID/exe or argv[0] (comm can't be matched, it never contains path)]
+        -x,--exec EXECUTABLE    Look for processes that were started with this
+                                command in /proc/$PID/cmdline.
+                                Unlike -n, we match against the full path:
+                                "ntpd" != "./ntpd" != "/path/to/ntpd"
+        -p,--pidfile PID_FILE   Look for processes with PID from this file
+
+Options which are valid for --start only:
+        -x,--exec EXECUTABLE    Program to run (1st arg of execvp). Mandatory.
+        -a,--startas NAME       argv[0] (defaults to EXECUTABLE)
+        -b,--background         Put process into background
+        -N,--nicelevel N        Add N to process' nice level
+        -c,--chuid USER[:[GRP]] Change to specified user [and group]
+        -m,--make-pidfile       Write PID to the pidfile
+                                (both -m and -p must be given!)
+
+Options which are valid for --stop only:
+        -s,--signal SIG         Signal to send (default:TERM)
+        -t,--test               Exit with status 0 if process is found
+                                (we don't actually start or stop daemons)
+
+Misc options:
+        -o,--oknodo             Exit with status 0 if nothing is done
+        -q,--quiet              Quiet
+        -v,--verbose            Verbose
+*/
+
 #include <sys/resource.h>
 
@@ -18 +62 @@
 #define WANT_PIDFILE 1
 #include "libbb.h"
-
-static int signal_nr = 15;
-static int user_id = -1;
-static char *userspec;
-static char *cmdname;
-static char *execname;
-static char *pidfile;
-static smallint quiet;
 
 struct pid_list {
@@ -32 +68 @@
 };
 
-static struct pid_list *found;
-
-static int pid_is_exec(pid_t pid, const char *name)
-{
-    char buf[sizeof("/proc//exe") + sizeof(int)*3];
-    char *execbuf;
-    int n;
-
-    sprintf(buf, "/proc/%u/exe", pid);
-    n = strlen(name) + 1;
-    execbuf = xzalloc(n + 1);
-    readlink(buf, execbuf, n);
-
-    /* if readlink fails, execbuf still contains "" */
-    n = strcmp(execbuf, name);
-    if (ENABLE_FEATURE_CLEAN_UP)
-        free(execbuf);
-    return !n; /* nonzero (true) if execbuf == name */
-}
-
-static int pid_is_user(int pid, int uid)
+enum {
+    CTX_STOP       = (1 <<  0),
+    CTX_START      = (1 <<  1),
+    OPT_BACKGROUND = (1 <<  2), // -b
+    OPT_QUIET      = (1 <<  3), // -q
+    OPT_TEST       = (1 <<  4), // -t
+    OPT_MAKEPID    = (1 <<  5), // -m
+    OPT_a          = (1 <<  6), // -a
+    OPT_n          = (1 <<  7), // -n
+    OPT_s          = (1 <<  8), // -s
+    OPT_u          = (1 <<  9), // -u
+    OPT_c          = (1 << 10), // -c
+    OPT_x          = (1 << 11), // -x
+    OPT_p          = (1 << 12), // -p
+    OPT_OKNODO     = (1 << 13) * ENABLE_FEATURE_START_STOP_DAEMON_FANCY, // -o
+    OPT_VERBOSE    = (1 << 14) * ENABLE_FEATURE_START_STOP_DAEMON_FANCY, // -v
+    OPT_NICELEVEL  = (1 << 15) * ENABLE_FEATURE_START_STOP_DAEMON_FANCY, // -N
+};
+#define QUIET (option_mask32 & OPT_QUIET)
+#define TEST  (option_mask32 & OPT_TEST)
+
+struct globals {
+    struct pid_list *found_procs;
+    char *userspec;
+    char *cmdname;
+    char *execname;
+    char *pidfile;
+    char *execname_cmpbuf;
+    unsigned execname_sizeof;
+    int user_id;
+    smallint signal_nr;
+} FIX_ALIASING;
+#define G (*(struct globals*)&bb_common_bufsiz1)
+#define userspec          (G.userspec            )
+#define cmdname           (G.cmdname             )
+#define execname          (G.execname            )
+#define pidfile           (G.pidfile             )
+#define user_id           (G.user_id             )
+#define signal_nr         (G.signal_nr           )
+#define INIT_G() do { \
+    user_id = -1; \
+    signal_nr = 15; \
+} while (0)
+
+#ifdef OLDER_VERSION_OF_X
+/* -x,--exec EXECUTABLE
+ * Look for processes with matching /proc/$PID/exe.
+ * Match is performed using device+inode.
+ */
+static int pid_is_exec(pid_t pid)
+{
+    struct stat st;
+    char buf[sizeof("/proc/%u/exe") + sizeof(int)*3];
+
+    sprintf(buf, "/proc/%u/exe", (unsigned)pid);
+    if (stat(buf, &st) < 0)
+        return 0;
+    if (st.st_dev == execstat.st_dev
+     && st.st_ino == execstat.st_ino)
+        return 1;
+    return 0;
+}
+#endif
+
+static int pid_is_exec(pid_t pid)
+{
+    ssize_t bytes;
+    char buf[sizeof("/proc/%u/cmdline") + sizeof(int)*3];
+
+    sprintf(buf, "/proc/%u/cmdline", (unsigned)pid);
+    bytes = open_read_close(buf, G.execname_cmpbuf, G.execname_sizeof);
+    if (bytes > 0) {
+        G.execname_cmpbuf[bytes] = '\0';
+        return strcmp(execname, G.execname_cmpbuf) == 0;
+    }
+    return 0;
+}
+
+static int pid_is_name(pid_t pid)
+{
+    /* /proc/PID/stat is "PID (comm_15_bytes_max) ..." */
+    char buf[32]; /* should be enough */
+    char *p, *pe;
+
+    sprintf(buf, "/proc/%u/stat", (unsigned)pid);
+    if (open_read_close(buf, buf, sizeof(buf) - 1) < 0)
+        return 0;
+    buf[sizeof(buf) - 1] = '\0'; /* paranoia */
+    p = strchr(buf, '(');
+    if (!p)
+        return 0;
+    pe = strrchr(++p, ')');
+    if (!pe)
+        return 0;
+    *pe = '\0';
+    /* we require comm to match and to not be truncated */
+    /* in Linux, if comm is 15 chars, it may be a truncated
+     * name, so we don't allow that to match */
+    if (strlen(p) >= COMM_LEN - 1) /* COMM_LEN is 16 */
+        return 0;
+    return strcmp(p, cmdname) == 0;
+}
+
+static int pid_is_user(int pid)
 {
     struct stat sb;
     char buf[sizeof("/proc/") + sizeof(int)*3];
 
-    sprintf(buf, "/proc/%u", pid);
+    sprintf(buf, "/proc/%u", (unsigned)pid);
     if (stat(buf, &sb) != 0)
         return 0;
-    return (sb.st_uid == uid);
-}
-
-static int pid_is_cmd(pid_t pid, const char *name)
-{
-    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);
-    }
-    return r;
+    return (sb.st_uid == (uid_t)user_id);
 }
 
@@ -89 +186 @@
     struct pid_list *p;
 
-    if (execname && !pid_is_exec(pid, execname)) {
+    if (execname && !pid_is_exec(pid)) {
         return;
     }
-    if (userspec && !pid_is_user(pid, user_id)) {
+    if (cmdname && !pid_is_name(pid)) {
         return;
     }
-    if (cmdname && !pid_is_cmd(pid, cmdname)) {
+    if (userspec && !pid_is_user(pid)) {
         return;
     }
     p = xmalloc(sizeof(*p));
-    p->next = found;
+    p->next = G.found_procs;
     p->pid = pid;
-    found = p;
+    G.found_procs = p;
 }
 
@@ -109 +206 @@
     unsigned pid;
 
-    f = fopen(pidfile, "r");
+    f = fopen_for_read(pidfile);
     if (f) {
         if (fscanf(f, "%u", &pid) == 1)
@@ -122 +219 @@
     DIR *procdir;
     struct dirent *entry;
-    int foundany, pid;
+    int pid;
 
     if (pidfile) {
@@ -131 +228 @@
     procdir = xopendir("/proc");
 
-    foundany = 0;
-    while ((entry = readdir(procdir)) != NULL) {
+    pid = 0;
+    while (1) {
+        errno = 0; /* clear any previous error */
+        entry = readdir(procdir);
+// TODO: this check is too generic, it's better
+// to check for exact errno(s) which mean that we got stale entry
+        if (errno) /* Stale entry, process has died after opendir */
+            continue;
+        if (!entry) /* EOF, no more entries */
+            break;
         pid = bb_strtou(entry->d_name, NULL, 10);
-        if (errno)
+        if (errno) /* NaN */
             continue;
-        foundany++;
         check(pid);
     }
     closedir(procdir);
-    if (!foundany)
+    if (!pid)
         bb_error_msg_and_die("nothing in /proc - not mounted?");
 }
@@ -149 +253 @@
     struct pid_list *p;
     int killed = 0;
-
-    do_procinit();
 
     if (cmdname) {
@@ -158 +260 @@
         if (ENABLE_FEATURE_CLEAN_UP) what = xstrdup(execname);
         if (!ENABLE_FEATURE_CLEAN_UP) what = execname;
-    } else if (pidfile)
+    } else if (pidfile) {
         what = xasprintf("process in pidfile '%s'", pidfile);
-    else if (userspec)
+    } else if (userspec) {
         what = xasprintf("process(es) owned by '%s'", userspec);
-    else
+    } else {
         bb_error_msg_and_die("internal error, please report");
-
-    if (!found) {
-        if (!quiet)
+    }
+
+    if (!G.found_procs) {
+        if (!QUIET)
             printf("no %s found; none killed\n", what);
         killed = -1;
         goto ret;
     }
-    for (p = found; p; p = p->next) {
-        if (kill(p->pid, signal_nr) == 0) {
-            p->pid = - p->pid;
+    for (p = G.found_procs; p; p = p->next) {
+        if (TEST || kill(p->pid, signal_nr) == 0) {
             killed++;
         } else {
-            bb_perror_msg("warning: killing process %u", p->pid);
+            p->pid = 0;
+            bb_perror_msg("warning: killing process %u", (unsigned)p->pid);
         }
     }
-    if (!quiet && killed) {
+    if (!QUIET && killed) {
         printf("stopped %s (pid", what);
-        for (p = found; p; p = p->next)
-            if (p->pid < 0)
-                printf(" %u", - p->pid);
+        for (p = G.found_procs; p; p = p->next)
+            if (p->pid)
+                printf(" %u", (unsigned)p->pid);
         puts(")");
     }
@@ -198 +301 @@
     "background\0"   No_argument       "b"
     "quiet\0"        No_argument       "q"
+    "test\0"         No_argument       "t"
     "make-pidfile\0" No_argument       "m"
 #if ENABLE_FEATURE_START_STOP_DAEMON_FANCY
@@ -217 +321 @@
 #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)
+int start_stop_daemon_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
+int start_stop_daemon_main(int argc UNUSED_PARAM, char **argv)
 {
     unsigned opt;
@@ -242 +328 @@
     char *startas;
     char *chuid;
+#ifdef OLDER_VERSION_OF_X
+    struct stat execstat;
+#endif
 #if ENABLE_FEATURE_START_STOP_DAEMON_FANCY
 //  char *retry_arg = NULL;
@@ -247 +336 @@
     char *opt_N;
 #endif
+
+    INIT_G();
+
 #if ENABLE_FEATURE_START_STOP_DAEMON_LONG_OPTIONS
     applet_long_options = start_stop_daemon_longopts;
 #endif
 
-    /* Check required one context option was given */
-    opt_complementary = "K:S:K--S:S--K:m?p:K?xpun:S?xa";
-    opt = getopt32(argv, "KSbqma:n:s:u:c:x:p:"
-        USE_FEATURE_START_STOP_DAEMON_FANCY("ovN:"),
-//      USE_FEATURE_START_STOP_DAEMON_FANCY("ovN:R:"),
+    /* -K or -S is required; they are mutually exclusive */
+    /* -p is required if -m is given */
+    /* -xpun (at least one) is required if -K is given */
+    /* -xa (at least one) is required if -S is given */
+    /* -q turns off -v */
+    opt_complementary = "K:S:K--S:S--K:m?p:K?xpun:S?xa"
+        IF_FEATURE_START_STOP_DAEMON_FANCY("q-v");
+    opt = getopt32(argv, "KSbqtma:n:s:u:c:x:p:"
+        IF_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)
+        IF_FEATURE_START_STOP_DAEMON_FANCY(,&opt_N)
+        /* We accept and ignore -R <param> / --retry <param> */
+        IF_FEATURE_START_STOP_DAEMON_FANCY(,NULL)
     );
-
-    quiet = (opt & OPT_QUIET) && !(opt & OPT_VERBOSE);
 
     if (opt & OPT_s) {
@@ -270 +365 @@
     if (!(opt & OPT_a))
         startas = execname;
-
-//  USE_FEATURE_START_STOP_DAEMON_FANCY(
+    if (!execname) /* in case -a is given and -x is not */
+        execname = startas;
+    if (execname) {
+        G.execname_sizeof = strlen(execname) + 1;
+        G.execname_cmpbuf = xmalloc(G.execname_sizeof + 1);
+    }
+
+//  IF_FEATURE_START_STOP_DAEMON_FANCY(
 //      if (retry_arg)
-//          retries = xatoi_u(retry_arg);
+//          retries = xatoi_positive(retry_arg);
 //  )
-    argc -= optind;
+    //argc -= optind;
     argv += optind;
 
@@ -283 +384 @@
             user_id = xuname2uid(userspec);
     }
+    /* Both start and stop need to know current processes */
+    do_procinit();
 
     if (opt & CTX_STOP) {
@@ -289 +392 @@
     }
 
-    do_procinit();
-
-    if (found) {
-        if (!quiet)
-            printf("%s already running\n%d\n", execname, found->pid);
+    if (G.found_procs) {
+        if (!QUIET)
+            printf("%s is already running\n%u\n", execname, (unsigned)G.found_procs->pid);
         return !(opt & OPT_OKNODO);
     }
+
+#ifdef OLDER_VERSION_OF_X
+    if (execname)
+        xstat(execname, &execstat);
+#endif
+
     *--argv = startas;
     if (opt & OPT_BACKGROUND) {
 #if BB_MMU
-        bb_daemonize(0);
+        bb_daemonize(DAEMON_DEVNULL_STDIO + DAEMON_CLOSE_EXTRA_FDS);
+        /* DAEMON_DEVNULL_STDIO is superfluous -
+         * it's always done by bb_daemonize() */
 #else
-        pid_t pid = vfork();
-        if (pid < 0) /* error */
-            bb_perror_msg_and_die("vfork");
+        pid_t pid = xvfork();
         if (pid != 0) {
             /* parent */
             /* why _exit? the child may have changed the stack,
              * so "return 0" may do bad things */
-            _exit(0);
+            _exit(EXIT_SUCCESS);
         }
-        /* child */
+        /* Child */
         setsid(); /* detach from controlling tty */
         /* Redirect stdio to /dev/null, close extra FDs.
          * We do not actually daemonize because of DAEMON_ONLY_SANITIZE */
-        bb_daemonize_or_rexec(
-            DAEMON_DEVNULL_STDIO
+        bb_daemonize_or_rexec(DAEMON_DEVNULL_STDIO
             + DAEMON_CLOSE_EXTRA_FDS
             + DAEMON_ONLY_SANITIZE,
@@ -322 +428 @@
     }
     if (opt & OPT_MAKEPID) {
-        /* user wants _us_ to make the pidfile */
+        /* User wants _us_ to make the pidfile */
         write_pidfile(pidfile);
     }
     if (opt & OPT_c) {
-        struct bb_uidgid_t ugid;
+        struct bb_uidgid_t ugid = { -1, -1 };
         parse_chown_usergroup_or_die(&ugid, chuid);
         if (ugid.gid != (gid_t) -1) xsetgid(ugid.gid);
@@ -340 +446 @@
     }
 #endif
-    execv(startas, argv);
-    bb_perror_msg_and_die("cannot start %s", startas);
-}
+    execvp(startas, argv);
+    bb_perror_msg_and_die("can't execute '%s'", startas);
+}