/*
 * Copyright (c) 2014 The DragonFly Project.  All rights reserved.
 *
 * This code is derived from software contributed to The DragonFly Project
 * by Matthew Dillon <dillon@backplane.com>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 3. Neither the name of The DragonFly Project nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific, prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */
/*
 * SERVICE MANAGER
 *
 * This program builds an environment to run a service in and provides
 * numerous options for naming, tracking, and management.  It uses
 * reapctl(2) to corral the processes under management.
 */

#include "svc.h"

static int execute_remote(command_t *cmd, int (*func)(command_t *cmd));
static int process_jailspec(command_t *cmd, const char *spec);

int
main(int ac, char **av)
{
        command_t cmd;
        int rc;

        signal(SIGPIPE, SIG_IGN);

        rc = process_cmd(&cmd, stdout, ac, av);
        cmd.cmdline = 1;        /* commanded from front-end */
        cmd.commanded = 1;      /* commanded action (vs automatic) */
        if (rc == 0)
                rc = execute_cmd(&cmd);
        free_cmd(&cmd);

        return rc;
}

int
process_cmd(command_t *cmd, FILE *fp, int ac, char **av)
{
        const char *optstr = "dfhp:r:R:xst:u:g:G:l:c:mj:k:T:F:";
        struct group *grent;
        struct passwd *pwent;
        char *sub;
        char *cpy;
        int rc = 1;
        int ch;
        int i;

        bzero(cmd, sizeof(*cmd));
        cmd->fp = fp;                           /* error and output reporting */
        cmd->logfd = -1;
        sreplace(&cmd->piddir, "/var/run");     /* must not be NULL */
        cmd->termkill_timo = -1;                /* will use default value */
        cmd->orig_ac = ac;
        cmd->orig_av = av;
        cmd->empty_label = 1;

        optind = 1;
        opterr = 1;
        optreset = 1;

        while ((ch = getopt(ac, av, optstr)) != -1) {
                switch(ch) {
                case 'd':
                        cmd->debug = 1;
                        cmd->foreground = 1;
                        break;
                case 'f':
                        cmd->foreground = 1;
                        break;
                case 'h':
                        execute_help(cmd);
                        exit(0);
                        break;
                case 'p':
                        sreplace(&cmd->piddir, optarg);
                        break;
                case 'r':
                        cmd->restart_some = 1;
                        cmd->restart_all = 0;
                        cmd->restart_timo = strtol(optarg, NULL, 0);
                        break;
                case 'R':
                        cmd->restart_some = 0;
                        cmd->restart_all = 1;
                        cmd->restart_timo = strtol(optarg, NULL, 0);
                        break;
                case 'x':
                        cmd->exit_mode = 1;
                        break;
                case 's':
                        cmd->sync_mode = 1;
                        break;
                case 't':
                        cmd->termkill_timo = strtoul(optarg, NULL, 0);
                        break;
                case 'u':
                        if (isdigit(optarg[0])) {
                                pwent = getpwuid(strtol(optarg, NULL, 0));
                        } else {
                                pwent = getpwnam(optarg);
                        }
                        if (pwent == NULL) {
                                fprintf(fp, "Cannot find user %s: %s\n",
                                        optarg,
                                        strerror(errno));
                                goto failed;
                        }
                        cmd->uid_mode = 1;
                        sfree(&cmd->pwent.pw_name);
                        sfree(&cmd->pwent.pw_passwd);
                        sfree(&cmd->pwent.pw_class);
                        sfree(&cmd->pwent.pw_gecos);
                        sfree(&cmd->pwent.pw_dir);
                        sfree(&cmd->pwent.pw_shell);
                        cmd->pwent = *pwent;
                        sdup(&cmd->pwent.pw_name);
                        sdup(&cmd->pwent.pw_passwd);
                        sdup(&cmd->pwent.pw_class);
                        sdup(&cmd->pwent.pw_gecos);
                        sdup(&cmd->pwent.pw_dir);
                        sdup(&cmd->pwent.pw_shell);
                        break;
                case 'g':
                        setgroupent(1);
                        if (isdigit(optarg[0])) {
                                grent = getgrgid(strtol(optarg, NULL, 0));
                        } else {
                                grent = getgrnam(optarg);
                        }
                        if (grent == NULL) {
                                fprintf(fp, "Cannot find group %s: %s\n",
                                        optarg,
                                        strerror(errno));
                                goto failed;
                        }
                        cmd->gid_mode = 1;
                        sfree(&cmd->grent.gr_name);
                        sfree(&cmd->grent.gr_passwd);
                        afree(&cmd->grent.gr_mem);
                        cmd->grent = *grent;
                        sdup(&cmd->grent.gr_name);
                        sdup(&cmd->grent.gr_passwd);
                        adup(&cmd->grent.gr_mem);
                        break;
                case 'G':
                        setgroupent(1);
                        cpy = strdup(optarg);
                        sub = strtok(cpy, ",");
                        i = 0;
                        while (sub) {
                                if (isdigit(sub[0])) {
                                        grent = getgrgid(strtol(sub, NULL, 0));
                                } else {
                                        grent = getgrnam(sub);
                                }
                                if (grent == NULL) {
                                        fprintf(fp,
                                                "Cannot find group %s: %s\n",
                                                sub, strerror(errno));
                                        i = -1;
                                }
                                if (i == NGROUPS) {
                                        fprintf(fp,
                                                "Too many groups specified, "
                                                "max %d\n", NGROUPS);
                                        i = -1;
                                }
                                if (i >= 0)
                                        cmd->groups[i++] = grent->gr_gid;
                                sub = strtok(NULL, ",");
                        }
                        free(cpy);
                        if (i < 0)
                                goto failed;
                        cmd->ngroups = i;
                        break;
                case 'l':
                        sreplace(&cmd->logfile, optarg);
                        break;
                case 'c':
                        sreplace(&cmd->rootdir, optarg);
                        break;
                case 'm':
                        cmd->mountdev = 1;
                        break;
                case 'j':
                        sreplace(&cmd->jaildir, optarg);
                        break;
                case 'k':
                        rc = process_jailspec(cmd, optarg);
                        if (rc)
                                goto failed;
                        break;
                case 'T':
                        sreplace(&cmd->proctitle, optarg);
                        break;
                case 'F':
                        cmd->restart_per = 60;
                        if (sscanf(optarg, "%d:%d",
                                   &cmd->restart_count,
                                   &cmd->restart_per) < 1) {
                                fprintf(fp, "bad restart specification: %s\n",
                                        optarg);
                                goto failed;
                        }
                        break;
                default:
                        fprintf(fp, "Unknown option %c\n", ch);
                        goto failed;
                }
        }

        /*
         * directive [label] [...additional args]
         *
         * If 'all' is specified the label field is left NULL (ensure that
         * it is NULL), and empty_label is still cleared so safety code works.
         */
        i = optind;
        if (av[i]) {
                cmd->directive = strdup(av[i]);
                ++i;
                if (av[i]) {
                        cmd->empty_label = 0;
                        if (strcmp(av[i], "all") == 0)
                                sfree(&cmd->label);
                        else
                                cmd->label = strdup(av[i]);
                        ++i;
                        cmd->ext_av = av + i;
                        cmd->ext_ac = ac - i;
                        adup(&cmd->ext_av);
                }
        } else {
                fprintf(fp, "No directive specified\n");
                goto failed;
        }
        rc = 0;
failed:
        endgrent();
        endpwent();

        return rc;
}

int
execute_cmd(command_t *cmd)
{
        const char *directive;
        int rc;

        directive = cmd->directive;

        /*
         * Safely, require a label for directives that do not match
         * this list, or 'all'.  Do not default to all if no label
         * is specified.  e.g. things like 'kill' or 'exit' could
         * blow up the system.
         */
        if (cmd->empty_label) {
                if (strcmp(directive, "status") != 0 &&
                    strcmp(directive, "list") != 0 &&
                    strcmp(directive, "log") != 0 &&
                    strcmp(directive, "logf") != 0 &&
                    strcmp(directive, "help") != 0 &&
                    strcmp(directive, "tailf") != 0)  {
                        fprintf(cmd->fp,
                                "Directive requires a label or 'all': %s\n",
                                directive);
                        rc = 1;
                        return rc;
                }
        }

        /*
         * Process directives.  If we are on the remote already the
         * execute_remote() function will simply chain to the passed-in
         * function.
         */
        if (strcmp(directive, "init") == 0) {
                rc = execute_init(cmd);
        } else if (strcmp(directive, "help") == 0) {
                rc = execute_help(cmd);
        } else if (strcmp(directive, "start") == 0) {
                rc = execute_remote(cmd, execute_start);
        } else if (strcmp(directive, "stop") == 0) {
                rc = execute_remote(cmd, execute_stop);
        } else if (strcmp(directive, "stopall") == 0) {
                cmd->restart_some = 0;
                cmd->restart_all = 1;
                rc = execute_remote(cmd, execute_stop);
        } else if (strcmp(directive, "restart") == 0) {
                rc = execute_remote(cmd, execute_restart);
        } else if (strcmp(directive, "exit") == 0) {
                cmd->restart_some = 0;
                cmd->restart_all = 1;           /* stop everything */
                cmd->force_remove_files = 1;
                rc = execute_remote(cmd, execute_exit);
        } else if (strcmp(directive, "kill") == 0) {
                cmd->restart_some = 0;
                cmd->restart_all = 1;           /* stop everything */
                cmd->termkill_timo = 0;         /* force immediate SIGKILL */
                cmd->force_remove_files = 1;
                rc = execute_remote(cmd, execute_exit);
        } else if (strcmp(directive, "list") == 0) {
                rc = execute_remote(cmd, execute_list);
        } else if (strcmp(directive, "status") == 0) {
                rc = execute_remote(cmd, execute_status);
        } else if (strcmp(directive, "log") == 0) {
                rc = execute_remote(cmd, execute_log);
        } else if (strcmp(directive, "logf") == 0) {
                cmd->tail_mode = 1;
                rc = execute_remote(cmd, execute_log);
        } else if (strcmp(directive, "tailf") == 0) {
                cmd->tail_mode = 2;
                rc = execute_remote(cmd, execute_log);
        } else if (strcmp(directive, "logfile") == 0) {
                rc = execute_remote(cmd, execute_logfile);
        } else {
                fprintf(cmd->fp, "Unknown directive: %s\n", directive);
                rc = 1;
        }
        return rc;
}

static
int
execute_remote(command_t *cmd, int (*func)(command_t *cmd))
{
        DIR *dir;
        struct dirent *den;
        const char *p1;
        const char *p2;
        char *plab;
        size_t cmdlen;
        size_t len;
        int rc;

        /*
         * If already on the remote service just execute the operation
         * as requested.
         */
        if (cmd->cmdline == 0) {
                return (func(cmd));
        }

        /*
         * Look for label(s).  If no exact match or label is NULL, scan
         * piddir for matches.
         */
        if ((dir = opendir(cmd->piddir)) == NULL) {
                fprintf(cmd->fp, "Unable to scan \"%s\"\n", cmd->piddir);
                return 1;
        }

        rc = 0;
        cmdlen = (cmd->label ? strlen(cmd->label) : 0);

        while ((den = readdir(dir)) != NULL) {
                /*
                 * service. prefix.
                 */
                if (strncmp(den->d_name, "service.", 8) != 0)
                        continue;

                /*
                 * .sk suffix
                 */
                p1 = den->d_name + 8;
                p2 = strrchr(p1, '.');
                if (p2 == NULL || p2 < p1 || strcmp(p2, ".sk") != 0)
                        continue;

                /*
                 * Extract the label from the service.<label>.sk name.
                 */
                len = p2 - p1;
                plab = strdup(p1);
                *strrchr(plab, '.') = 0;

                /*
                 * Start remote execution (in parallel) for all matching
                 * labels.  This will generally create some asynchronous
                 * threads.
                 */
                if (cmdlen == 0 ||
                    (cmdlen <= len && strncmp(cmd->label, plab, cmdlen) == 0)) {
                        remote_execute(cmd, plab);
                }
                free(plab);
        }
        closedir(dir);

        /*
         * Wait for completion of remote commands and dump output.
         */
        rc = remote_wait();

        return rc;
}

void
free_cmd(command_t *cmd)
{
        sfree(&cmd->piddir);

        sfree(&cmd->pwent.pw_name);
        sfree(&cmd->pwent.pw_passwd);
        sfree(&cmd->pwent.pw_class);
        sfree(&cmd->pwent.pw_gecos);
        sfree(&cmd->pwent.pw_dir);
        sfree(&cmd->pwent.pw_shell);

        sfree(&cmd->grent.gr_name);
        sfree(&cmd->grent.gr_passwd);
        afree(&cmd->grent.gr_mem);

        sfree(&cmd->logfile);
        sfree(&cmd->rootdir);
        sfree(&cmd->jaildir);
        sfree(&cmd->proctitle);
        sfree(&cmd->directive);
        sfree(&cmd->label);
        afree(&cmd->ext_av);

        if (cmd->logfd >= 0) {
                close(cmd->logfd);
                cmd->logfd = -1;
        }

        bzero(cmd, sizeof(*cmd));
}

static
int
process_jailspec(command_t *cmd, const char *spec)
{
        char *cpy = strdup(spec);
        char *ptr;
        int rc = 0;

        ptr = strtok(cpy, ",");
        while (ptr) {
                if (strcmp(ptr, "clean") == 0) {
                        cmd->jail_clean = 1;
                } else if (strncmp(ptr, "ip=", 3) == 0) {
                        assert(0); /* XXX TODO */
                } else {
                        fprintf(cmd->fp, "jail-spec '%s' not understood\n",
                                ptr);
                        rc = 1;
                }
                ptr = strtok(NULL, ",");
        }
        free(cpy);

        return rc;
}