debianutils/start_stop_daemon.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * Mini start-stop-daemon implementation(s) for busybox
   4  *
   5  * Written by Marek Michalkiewicz <marekm@i17linuxb.ists.pwr.wroc.pl>,
   6  * public domain.
   7  * Adapted for busybox David Kimdon <dwhedon@gordian.com>
   8  */
   9
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include <stdarg.h>
  14 #include <signal.h>
  15 #include <errno.h>
  16 #include <sys/stat.h>
  17 #include <dirent.h>
  18 #include <unistd.h>
  19 #include <getopt.h> /* struct option */
  20
  21 #include "busybox.h"
  22 #include "pwd_.h"
  23
  24 static int signal_nr = 15;
  25 static int user_id = -1;
  26 static int quiet = 0;
  27 static char *userspec = NULL;
  28 static char *cmdname = NULL;
  29 static char *execname = NULL;
  30 static char *pidfile = NULL;
  31
  32 struct pid_list {
  33         struct pid_list *next;
  34         pid_t pid;
  35 };
  36
  37 static struct pid_list *found = NULL;
  38
  39 static inline void
  40 push(pid_t pid)
  41 {
  42         struct pid_list *p;
  43
  44         p = xmalloc(sizeof(*p));
  45         p->next = found;
  46         p->pid = pid;
  47         found = p;
  48 }
  49
  50 static int
  51 pid_is_exec(pid_t pid, const char *name)
  52 {
  53         char buf[32];
  54         struct stat sb, exec_stat;
  55
  56         if (name)
  57                 xstat(name, &exec_stat);
  58
  59         sprintf(buf, "/proc/%d/exe", pid);
  60         if (stat(buf, &sb) != 0)
  61                 return 0;
  62         return (sb.st_dev == exec_stat.st_dev && sb.st_ino == exec_stat.st_ino);
  63 }
  64
  65 static int
  66 pid_is_user(int pid, int uid)
  67 {
  68         struct stat sb;
  69         char buf[32];
  70
  71         sprintf(buf, "/proc/%d", pid);
  72         if (stat(buf, &sb) != 0)
  73                 return 0;
  74         return (sb.st_uid == uid);
  75 }
  76
  77 static int
  78 pid_is_cmd(pid_t pid, const char *name)
  79 {
  80         char buf[32];
  81         FILE *f;
  82         int c;
  83
  84         sprintf(buf, "/proc/%d/stat", pid);
  85         f = fopen(buf, "r");
  86         if (!f)
  87                 return 0;
  88         while ((c = getc(f)) != EOF && c != '(')
  89                 ;
  90         if (c != '(') {
  91                 fclose(f);
  92                 return 0;
  93         }
  94         /* this hopefully handles command names containing ')' */
  95         while ((c = getc(f)) != EOF && c == *name)
  96                 name++;
  97         fclose(f);
  98         return (c == ')' && *name == '\0');
  99 }
 100
 101
 102 static void
 103 check(int pid)
 104 {
 105         if (execname && !pid_is_exec(pid, execname)) {
 106                 return;
 107         }
 108         if (userspec && !pid_is_user(pid, user_id)) {
 109                 return;
 110         }
 111         if (cmdname && !pid_is_cmd(pid, cmdname)) {
 112                 return;
 113         }
 114         push(pid);
 115 }
 116
 117
 118 static void
 119 do_pidfile(void)
 120 {
 121         FILE *f;
 122         pid_t pid;
 123
 124         f = fopen(pidfile, "r");
 125         if (f) {
 126                 if (fscanf(f, "%d", &pid) == 1)
 127                         check(pid);
 128                 fclose(f);
 129         } else if (errno != ENOENT)
 130                 bb_perror_msg_and_die("open pidfile %s", pidfile);
 131
 132 }
 133
 134 static void
 135 do_procinit(void)
 136 {
 137         DIR *procdir;
 138         struct dirent *entry;
 139         int foundany, pid;
 140
 141         if (pidfile) {
 142                 do_pidfile();
 143                 return;
 144         }
 145
 146         procdir = opendir("/proc");
 147         if (!procdir)
 148                 bb_perror_msg_and_die ("opendir /proc");
 149
 150         foundany = 0;
 151         while ((entry = readdir(procdir)) != NULL) {
 152                 if (sscanf(entry->d_name, "%d", &pid) != 1)
 153                         continue;
 154                 foundany++;
 155                 check(pid);
 156         }
 157         closedir(procdir);
 158         if (!foundany)
 159                 bb_error_msg_and_die ("nothing in /proc - not mounted?");
 160 }
 161
 162
 163 static void
 164 do_stop(void)
 165 {
 166         char what[1024];
 167         struct pid_list *p;
 168         int killed = 0;
 169
 170         do_procinit();
 171
 172         if (cmdname)
 173                 strcpy(what, cmdname);
 174         else if (execname)
 175                 strcpy(what, execname);
 176         else if (pidfile)
 177                 sprintf(what, "process in pidfile `%.200s'", pidfile);
 178         else if (userspec)
 179                 sprintf(what, "process(es) owned by `%s'", userspec);
 180         else
 181                 bb_error_msg_and_die ("internal error, please report");
 182
 183         if (!found) {
 184                 if (!quiet)
 185                         printf("no %s found; none killed.\n", what);
 186                 return;
 187         }
 188         for (p = found; p; p = p->next) {
 189                 if (kill(p->pid, signal_nr) == 0) {
 190                         p->pid = -p->pid;
 191                         killed++;
 192                 } else {
 193                         bb_perror_msg("warning: failed to kill %d", p->pid);
 194                 }
 195         }
 196         if (!quiet && killed) {
 197                 printf("stopped %s (pid", what);
 198                 for (p = found; p; p = p->next)
 199                         if(p->pid < 0)
 200                                 printf(" %d", -p->pid);
 201                 printf(").\n");
 202         }
 203 }
 204
 205
 206 static const struct option ssd_long_options[] = {
 207         { "stop",                       0,              NULL,           'K' },
 208         { "start",                      0,              NULL,           'S' },
 209         { "background",                 0,              NULL,           'b' },
 210         { "quiet",                      0,              NULL,           'q' },
 211         { "make-pidfile",               0,              NULL,           'm' },
 212         { "startas",                    1,              NULL,           'a' },
 213         { "name",                       1,              NULL,           'n' },
 214         { "signal",                     1,              NULL,           's' },
 215         { "user",                       1,              NULL,           'u' },
 216         { "exec",                       1,              NULL,           'x' },
 217         { "pidfile",                    1,              NULL,           'p' },
 218         { 0,                            0,              0,              0 }
 219 };
 220
 221 #define SSD_CTX_STOP            1
 222 #define SSD_CTX_START           2
 223 #define SSD_OPT_BACKGROUND      4
 224 #define SSD_OPT_QUIET           8
 225 #define SSD_OPT_MAKEPID         16
 226
 227 int
 228 start_stop_daemon_main(int argc, char **argv)
 229 {
 230         unsigned long opt;
 231         char *signame = NULL;
 232         char *startas = NULL;
 233
 234         bb_applet_long_options = ssd_long_options;
 235
 236         /* Check required one context option was given */
 237         bb_opt_complementally = "K:S:?:K--S:S--K";
 238         opt = bb_getopt_ulflags(argc, argv, "KSbqma:n:s:u:x:p:",
 239                 &startas, &cmdname, &signame, &userspec, &execname, &pidfile);
 240
 241
 242         quiet = opt & SSD_OPT_QUIET;
 243
 244         if (signame) {
 245                 signal_nr = bb_xgetlarg(signame, 10, 0, NSIG);
 246         }
 247
 248         if (!execname && !pidfile && !userspec && !cmdname)
 249                 bb_error_msg_and_die ("need at least one of -x, -p, -u, or -n");
 250
 251         if (!startas)
 252                 startas = execname;
 253
 254         if ((opt & SSD_CTX_START) && !startas)
 255                 bb_error_msg_and_die ("-S needs -x or -a");
 256
 257         if ((opt & SSD_OPT_MAKEPID) && pidfile == NULL)
 258                 bb_error_msg_and_die ("-m needs -p");
 259
 260         argc -= optind;
 261         argv += optind;
 262
 263         if (userspec && sscanf(userspec, "%d", &user_id) != 1)
 264                 user_id = bb_xgetpwnam(userspec);
 265
 266         if (opt & SSD_CTX_STOP) {
 267                 do_stop();
 268                 return EXIT_SUCCESS;
 269         }
 270
 271         do_procinit();
 272
 273         if (found) {
 274                 if (!quiet)
 275                         printf("%s already running.\n%d\n", execname ,found->pid);
 276                 return EXIT_SUCCESS;
 277         }
 278         *--argv = startas;
 279         if (opt & SSD_OPT_BACKGROUND) {
 280                 if (daemon(0, 0) == -1)
 281                         bb_perror_msg_and_die ("unable to fork");
 282                 setsid();
 283         }
 284         if (opt & SSD_OPT_MAKEPID) {
 285                 /* user wants _us_ to make the pidfile */
 286                 FILE *pidf = fopen(pidfile, "w");
 287                 pid_t pidt = getpid();
 288                 if (pidf == NULL)
 289                         bb_perror_msg_and_die("Unable to write pidfile '%s'", pidfile);
 290                 fprintf(pidf, "%d\n", pidt);
 291                 fclose(pidf);
 292         }
 293         execv(startas, argv);
 294         bb_perror_msg_and_die ("unable to start %s", startas);
 295 }