sbin/svc/svc.c

   1 /*
   2  * Copyright (c) 2014 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Matthew Dillon <dillon@backplane.com>
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  * 3. Neither the name of The DragonFly Project nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific, prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34 /*
  35  * SERVICE MANAGER
  36  *
  37  * This program builds an environment to run a service in and provides
  38  * numerous options for naming, tracking, and management.  It uses
  39  * reapctl(2) to corral the processes under management.
  40  */
  41
  42 #include "svc.h"
  43
  44 static int execute_remote(command_t *cmd, int (*func)(command_t *cmd));
  45 static int process_jailspec(command_t *cmd, const char *spec);
  46
  47 int
  48 main(int ac, char **av)
  49 {
  50         command_t cmd;
  51         int rc;
  52
  53         signal(SIGPIPE, SIG_IGN);
  54
  55         rc = process_cmd(&cmd, stdout, ac, av);
  56         cmd.cmdline = 1;        /* commanded from front-end */
  57         cmd.commanded = 1;      /* commanded action (vs automatic) */
  58         if (rc == 0)
  59                 rc = execute_cmd(&cmd);
  60         free_cmd(&cmd);
  61
  62         return rc;
  63 }
  64
  65 int
  66 process_cmd(command_t *cmd, FILE *fp, int ac, char **av)
  67 {
  68         const char *optstr = "dfhp:r:R:xst:u:g:G:l:c:mj:k:T:F:";
  69         struct group *grent;
  70         struct passwd *pwent;
  71         char *sub;
  72         char *cpy;
  73         int rc = 1;
  74         int ch;
  75         int i;
  76
  77         bzero(cmd, sizeof(*cmd));
  78         cmd->fp = fp;                           /* error and output reporting */
  79         cmd->logfd = -1;
  80         sreplace(&cmd->piddir, "/var/run");     /* must not be NULL */
  81         cmd->termkill_timo = -1;                /* will use default value */
  82         cmd->orig_ac = ac;
  83         cmd->orig_av = av;
  84         cmd->empty_label = 1;
  85
  86         optind = 1;
  87         opterr = 1;
  88         optreset = 1;
  89
  90         while ((ch = getopt(ac, av, optstr)) != -1) {
  91                 switch(ch) {
  92                 case 'd':
  93                         cmd->debug = 1;
  94                         cmd->foreground = 1;
  95                         break;
  96                 case 'f':
  97                         cmd->foreground = 1;
  98                         break;
  99                 case 'h':
 100                         execute_help(cmd);
 101                         exit(0);
 102                         break;
 103                 case 'p':
 104                         sreplace(&cmd->piddir, optarg);
 105                         break;
 106                 case 'r':
 107                         cmd->restart_some = 1;
 108                         cmd->restart_all = 0;
 109                         cmd->restart_timo = strtol(optarg, NULL, 0);
 110                         break;
 111                 case 'R':
 112                         cmd->restart_some = 0;
 113                         cmd->restart_all = 1;
 114                         cmd->restart_timo = strtol(optarg, NULL, 0);
 115                         break;
 116                 case 'x':
 117                         cmd->exit_mode = 1;
 118                         break;
 119                 case 's':
 120                         cmd->sync_mode = 1;
 121                         break;
 122                 case 't':
 123                         cmd->termkill_timo = strtoul(optarg, NULL, 0);
 124                         break;
 125                 case 'u':
 126                         if (isdigit(optarg[0])) {
 127                                 pwent = getpwuid(strtol(optarg, NULL, 0));
 128                         } else {
 129                                 pwent = getpwnam(optarg);
 130                         }
 131                         if (pwent == NULL) {
 132                                 fprintf(fp, "Cannot find user %s: %s\n",
 133                                         optarg,
 134                                         strerror(errno));
 135                                 goto failed;
 136                         }
 137                         cmd->uid_mode = 1;
 138                         sfree(&cmd->pwent.pw_name);
 139                         sfree(&cmd->pwent.pw_passwd);
 140                         sfree(&cmd->pwent.pw_class);
 141                         sfree(&cmd->pwent.pw_gecos);
 142                         sfree(&cmd->pwent.pw_dir);
 143                         sfree(&cmd->pwent.pw_shell);
 144                         cmd->pwent = *pwent;
 145                         sdup(&cmd->pwent.pw_name);
 146                         sdup(&cmd->pwent.pw_passwd);
 147                         sdup(&cmd->pwent.pw_class);
 148                         sdup(&cmd->pwent.pw_gecos);
 149                         sdup(&cmd->pwent.pw_dir);
 150                         sdup(&cmd->pwent.pw_shell);
 151                         break;
 152                 case 'g':
 153                         setgroupent(1);
 154                         if (isdigit(optarg[0])) {
 155                                 grent = getgrgid(strtol(optarg, NULL, 0));
 156                         } else {
 157                                 grent = getgrnam(optarg);
 158                         }
 159                         if (grent == NULL) {
 160                                 fprintf(fp, "Cannot find group %s: %s\n",
 161                                         optarg,
 162                                         strerror(errno));
 163                                 goto failed;
 164                         }
 165                         cmd->gid_mode = 1;
 166                         sfree(&cmd->grent.gr_name);
 167                         sfree(&cmd->grent.gr_passwd);
 168                         afree(&cmd->grent.gr_mem);
 169                         cmd->grent = *grent;
 170                         sdup(&cmd->grent.gr_name);
 171                         sdup(&cmd->grent.gr_passwd);
 172                         adup(&cmd->grent.gr_mem);
 173                         break;
 174                 case 'G':
 175                         setgroupent(1);
 176                         cpy = strdup(optarg);
 177                         sub = strtok(cpy, ",");
 178                         i = 0;
 179                         while (sub) {
 180                                 if (isdigit(sub[0])) {
 181                                         grent = getgrgid(strtol(sub, NULL, 0));
 182                                 } else {
 183                                         grent = getgrnam(sub);
 184                                 }
 185                                 if (grent == NULL) {
 186                                         fprintf(fp,
 187                                                 "Cannot find group %s: %s\n",
 188                                                 sub, strerror(errno));
 189                                         i = -1;
 190                                 }
 191                                 if (i == NGROUPS) {
 192                                         fprintf(fp,
 193                                                 "Too many groups specified, "
 194                                                 "max %d\n", NGROUPS);
 195                                         i = -1;
 196                                 }
 197                                 if (i >= 0)
 198                                         cmd->groups[i++] = grent->gr_gid;
 199                                 sub = strtok(NULL, ",");
 200                         }
 201                         free(cpy);
 202                         if (i < 0)
 203                                 goto failed;
 204                         cmd->ngroups = i;
 205                         break;
 206                 case 'l':
 207                         sreplace(&cmd->logfile, optarg);
 208                         break;
 209                 case 'c':
 210                         sreplace(&cmd->rootdir, optarg);
 211                         break;
 212                 case 'm':
 213                         cmd->mountdev = 1;
 214                         break;
 215                 case 'j':
 216                         sreplace(&cmd->jaildir, optarg);
 217                         break;
 218                 case 'k':
 219                         rc = process_jailspec(cmd, optarg);
 220                         if (rc)
 221                                 goto failed;
 222                         break;
 223                 case 'T':
 224                         sreplace(&cmd->proctitle, optarg);
 225                         break;
 226                 case 'F':
 227                         cmd->restart_per = 60;
 228                         if (sscanf(optarg, "%d:%d",
 229                                    &cmd->restart_count,
 230                                    &cmd->restart_per) < 1) {
 231                                 fprintf(fp, "bad restart specification: %s\n",
 232                                         optarg);
 233                                 goto failed;
 234                         }
 235                         break;
 236                 default:
 237                         fprintf(fp, "Unknown option %c\n", ch);
 238                         goto failed;
 239                 }
 240         }
 241
 242         /*
 243          * directive [label] [...additional args]
 244          *
 245          * If 'all' is specified the label field is left NULL (ensure that
 246          * it is NULL), and empty_label is still cleared so safety code works.
 247          */
 248         i = optind;
 249         if (av[i]) {
 250                 cmd->directive = strdup(av[i]);
 251                 ++i;
 252                 if (av[i]) {
 253                         cmd->empty_label = 0;
 254                         if (strcmp(av[i], "all") == 0)
 255                                 sfree(&cmd->label);
 256                         else
 257                                 cmd->label = strdup(av[i]);
 258                         ++i;
 259                         cmd->ext_av = av + i;
 260                         cmd->ext_ac = ac - i;
 261                         adup(&cmd->ext_av);
 262                 }
 263         } else {
 264                 fprintf(fp, "No directive specified\n");
 265                 goto failed;
 266         }
 267         rc = 0;
 268 failed:
 269         endgrent();
 270         endpwent();
 271
 272         return rc;
 273 }
 274
 275 int
 276 execute_cmd(command_t *cmd)
 277 {
 278         const char *directive;
 279         int rc;
 280
 281         directive = cmd->directive;
 282
 283         /*
 284          * Safely, require a label for directives that do not match
 285          * this list, or 'all'.  Do not default to all if no label
 286          * is specified.  e.g. things like 'kill' or 'exit' could
 287          * blow up the system.
 288          */
 289         if (cmd->empty_label) {
 290                 if (strcmp(directive, "status") != 0 &&
 291                     strcmp(directive, "list") != 0 &&
 292                     strcmp(directive, "log") != 0 &&
 293                     strcmp(directive, "logf") != 0 &&
 294                     strcmp(directive, "help") != 0 &&
 295                     strcmp(directive, "tailf") != 0)  {
 296                         fprintf(cmd->fp,
 297                                 "Directive requires a label or 'all': %s\n",
 298                                 directive);
 299                         rc = 1;
 300                         return rc;
 301                 }
 302         }
 303
 304         /*
 305          * Process directives.  If we are on the remote already the
 306          * execute_remote() function will simply chain to the passed-in
 307          * function.
 308          */
 309         if (strcmp(directive, "init") == 0) {
 310                 rc = execute_init(cmd);
 311         } else if (strcmp(directive, "help") == 0) {
 312                 rc = execute_help(cmd);
 313         } else if (strcmp(directive, "start") == 0) {
 314                 rc = execute_remote(cmd, execute_start);
 315         } else if (strcmp(directive, "stop") == 0) {
 316                 rc = execute_remote(cmd, execute_stop);
 317         } else if (strcmp(directive, "stopall") == 0) {
 318                 cmd->restart_some = 0;
 319                 cmd->restart_all = 1;
 320                 rc = execute_remote(cmd, execute_stop);
 321         } else if (strcmp(directive, "restart") == 0) {
 322                 rc = execute_remote(cmd, execute_restart);
 323         } else if (strcmp(directive, "exit") == 0) {
 324                 cmd->restart_some = 0;
 325                 cmd->restart_all = 1;           /* stop everything */
 326                 cmd->force_remove_files = 1;
 327                 rc = execute_remote(cmd, execute_exit);
 328         } else if (strcmp(directive, "kill") == 0) {
 329                 cmd->restart_some = 0;
 330                 cmd->restart_all = 1;           /* stop everything */
 331                 cmd->termkill_timo = 0;         /* force immediate SIGKILL */
 332                 cmd->force_remove_files = 1;
 333                 rc = execute_remote(cmd, execute_exit);
 334         } else if (strcmp(directive, "list") == 0) {
 335                 rc = execute_remote(cmd, execute_list);
 336         } else if (strcmp(directive, "status") == 0) {
 337                 rc = execute_remote(cmd, execute_status);
 338         } else if (strcmp(directive, "log") == 0) {
 339                 rc = execute_remote(cmd, execute_log);
 340         } else if (strcmp(directive, "logf") == 0) {
 341                 cmd->tail_mode = 1;
 342                 rc = execute_remote(cmd, execute_log);
 343         } else if (strcmp(directive, "tailf") == 0) {
 344                 cmd->tail_mode = 2;
 345                 rc = execute_remote(cmd, execute_log);
 346         } else if (strcmp(directive, "logfile") == 0) {
 347                 rc = execute_remote(cmd, execute_logfile);
 348         } else {
 349                 fprintf(cmd->fp, "Uknown directive: %s\n", directive);
 350                 rc = 1;
 351         }
 352         return rc;
 353 }
 354
 355 static
 356 int
 357 execute_remote(command_t *cmd, int (*func)(command_t *cmd))
 358 {
 359         DIR *dir;
 360         struct dirent *den;
 361         const char *p1;
 362         const char *p2;
 363         char *plab;
 364         size_t cmdlen;
 365         size_t len;
 366         int rc;
 367
 368         /*
 369          * If already on the remote service just execute the operation
 370          * as requested.
 371          */
 372         if (cmd->cmdline == 0) {
 373                 return (func(cmd));
 374         }
 375
 376         /*
 377          * Look for label(s).  If no exact match or label is NULL, scan
 378          * piddir for matches.
 379          */
 380         if ((dir = opendir(cmd->piddir)) == NULL) {
 381                 fprintf(cmd->fp, "Unable to scan \"%s\"\n", cmd->piddir);
 382                 return 1;
 383         }
 384
 385         rc = 0;
 386         cmdlen = (cmd->label ? strlen(cmd->label) : 0);
 387
 388         while ((den = readdir(dir)) != NULL) {
 389                 /*
 390                  * service. prefix.
 391                  */
 392                 if (strncmp(den->d_name, "service.", 8) != 0)
 393                         continue;
 394
 395                 /*
 396                  * .sk suffix
 397                  */
 398                 p1 = den->d_name + 8;
 399                 p2 = strrchr(p1, '.');
 400                 if (p2 == NULL || p2 < p1 || strcmp(p2, ".sk") != 0)
 401                         continue;
 402
 403                 /*
 404                  * Extract the label from the service.<label>.sk name.
 405                  */
 406                 len = p2 - p1;
 407                 plab = strdup(p1);
 408                 *strrchr(plab, '.') = 0;
 409
 410                 /*
 411                  * Start remote execution (in parallel) for all matching
 412                  * labels.  This will generally create some asynchronous
 413                  * threads.
 414                  */
 415                 if (cmdlen == 0 ||
 416                     (cmdlen <= len && strncmp(cmd->label, plab, cmdlen) == 0)) {
 417                         remote_execute(cmd, plab);
 418                 }
 419                 free(plab);
 420         }
 421         closedir(dir);
 422
 423         /*
 424          * Wait for completion of remote commands and dump output.
 425          */
 426         rc = remote_wait();
 427
 428         return rc;
 429 }
 430
 431 void
 432 free_cmd(command_t *cmd)
 433 {
 434         sfree(&cmd->piddir);
 435
 436         sfree(&cmd->pwent.pw_name);
 437         sfree(&cmd->pwent.pw_passwd);
 438         sfree(&cmd->pwent.pw_class);
 439         sfree(&cmd->pwent.pw_gecos);
 440         sfree(&cmd->pwent.pw_dir);
 441         sfree(&cmd->pwent.pw_shell);
 442
 443         sfree(&cmd->grent.gr_name);
 444         sfree(&cmd->grent.gr_passwd);
 445         afree(&cmd->grent.gr_mem);
 446
 447         sfree(&cmd->logfile);
 448         sfree(&cmd->rootdir);
 449         sfree(&cmd->jaildir);
 450         sfree(&cmd->proctitle);
 451         sfree(&cmd->directive);
 452         sfree(&cmd->label);
 453         afree(&cmd->ext_av);
 454
 455         if (cmd->logfd >= 0) {
 456                 close(cmd->logfd);
 457                 cmd->logfd = -1;
 458         }
 459
 460         bzero(cmd, sizeof(*cmd));
 461 }
 462
 463 static
 464 int
 465 process_jailspec(command_t *cmd, const char *spec)
 466 {
 467         char *cpy = strdup(spec);
 468         char *ptr;
 469         int rc = 0;
 470
 471         ptr = strtok(cpy, ",");
 472         while (ptr) {
 473                 if (strcmp(ptr, "clean") == 0) {
 474                         cmd->jail_clean = 1;
 475                 } else if (strncmp(ptr, "ip=", 3) == 0) {
 476                         assert(0); /* XXX TODO */
 477                 } else {
 478                         fprintf(cmd->fp, "jail-spec '%s' not understood\n",
 479                                 ptr);
 480                         rc = 1;
 481                 }
 482                 ptr = strtok(NULL, ",");
 483         }
 484         free(cpy);
 485
 486         return rc;
 487 }