ctdb-server: Optimise local IP verification

[samba4-gss.git] / ctdb / event / event_tool.c

/*
   CTDB event daemon utility code

   Copyright (C) Amitay Isaacs  2018

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, see <http://www.gnu.org/licenses/>.
*/

#include "replace.h"
#include "system/filesys.h"
#include "system/time.h"

#include <popt.h>
#include <talloc.h>
#include <tevent.h>

#include "lib/util/debug.h"

#include "common/cmdline.h"
#include "common/logging.h"
#include "common/path.h"
#include "common/event_script.h"

#include "event/event_protocol_api.h"
#include "event/event.h"
#include "event/event_tool.h"

struct event_tool_context {
        struct cmdline_context *cmdline;
        struct tevent_context *ev;
        struct ctdb_event_context *eclient;
};

static int compact_args(TALLOC_CTX *mem_ctx,
                        const char **argv,
                        int argc,
                        int from,
                        const char **result)
{
        char *arg_str;
        int i;

        if (argc <= from) {
                *result = NULL;
                return 0;
        }

        arg_str = talloc_strdup(mem_ctx, argv[from]);
        if (arg_str == NULL) {
                return ENOMEM;
        }

        for (i = from+1; i < argc; i++) {
                arg_str = talloc_asprintf_append(arg_str, " %s", argv[i]);
                if (arg_str == NULL) {
                        return ENOMEM;
                }
        }

        *result = arg_str;
        return 0;
}

static int event_command_run(TALLOC_CTX *mem_ctx,
                             int argc,
                             const char **argv,
                             void *private_data)
{
        struct event_tool_context *ctx = talloc_get_type_abort(
                private_data, struct event_tool_context);
        struct tevent_req *req;
        struct ctdb_event_request_run request_run;
        const char *arg_str = NULL;
        const char *t;
        int timeout, ret = 0, result = 0;
        bool ok;

        if (argc < 3) {
                cmdline_usage(ctx->cmdline, "run");
                return 1;
        }

        ret = ctdb_event_init(ctx, ctx->ev, &ctx->eclient);
        if (ret != 0) {
                D_ERR("Failed to initialize event client, ret=%d\n", ret);
                return ret;
        }

        timeout = atoi(argv[0]);
        if (timeout < 0) {
                timeout = 0;
        }

        ret = compact_args(mem_ctx, argv, argc, 3, &arg_str);
        if (ret != 0) {
                D_ERR("Memory allocation error\n");
                return 1;
        }

        request_run.component = argv[1];
        request_run.event = argv[2];
        request_run.args = arg_str;
        request_run.timeout = timeout;
        request_run.flags = 0;

        t = getenv("CTDB_TEST_MODE");
        if (t != NULL) {
                t = getenv("CTDB_EVENT_RUN_ALL");
                if (t != NULL) {
                        request_run.flags = CTDB_EVENT_RUN_ALL;
                }
        }

        req = ctdb_event_run_send(mem_ctx,
                                  ctx->ev,
                                  ctx->eclient,
                                  &request_run);
        if (req == NULL) {
                D_ERR("Memory allocation error\n");
                return 1;
        }

        tevent_req_poll(req, ctx->ev);

        ok = ctdb_event_run_recv(req, &ret, &result);
        if (!ok) {
                D_ERR("Failed to run event %s in %s, ret=%d\n",
                      argv[2],
                      argv[1],
                      ret);
                return 1;
        }

        D_NOTICE("Command run finished with result=%d\n", result);

        if (result == ENOENT) {
                printf("Event dir for %s does not exist\n", argv[1]);
        } else if (result == ETIMEDOUT) {
                printf("Event %s in %s timed out\n", argv[2], argv[1]);
        } else if (result == ECANCELED) {
                printf("Event %s in %s got cancelled\n", argv[2], argv[1]);
        } else if (result == ENOEXEC) {
                printf("Event %s in %s failed\n", argv[2], argv[1]);
        } else if (result != 0) {
                printf("Failed to run event %s in %s, result=%d\n",
                       argv[2],
                       argv[1],
                       result);
        }

        ret = (result < 0) ? -result : result;
        return ret;
}

static double timeval_delta(struct timeval *tv2, struct timeval *tv)
{
        return (tv2->tv_sec - tv->tv_sec) +
               (tv2->tv_usec - tv->tv_usec) * 1.0e-6;
}

static void print_status_one(struct ctdb_event_script *script)
{
        if (script->result == -ETIMEDOUT) {
                printf("%-20s %-10s %s",
                       script->name,
                       "TIMEDOUT",
                       ctime(&script->begin.tv_sec));
        } else if (script->result == -ENOEXEC) {
                printf("%-20s %-10s\n", script->name, "DISABLED");
        } else if (script->result < 0) {
                printf("%-20s %-10s (%s)\n",
                       script->name,
                       "CANNOT RUN",
                       strerror(-script->result));
        } else if (script->result == 0) {
                printf("%-20s %-10s %.3lf %s",
                       script->name,
                       "OK",
                       timeval_delta(&script->end, &script->begin),
                       ctime(&script->begin.tv_sec));
        } else {
                printf("%-20s %-10s %.3lf %s",
                       script->name,
                       "ERROR",
                       timeval_delta(&script->end, &script->begin),
                       ctime(&script->begin.tv_sec));
        }

        if ((script->result != 0 && script->result != -ENOEXEC) ||
            script->output != NULL) {
                /* Empty output is informative so always print it on failure */
                const char *t = script->output == NULL ? "" : script->output;
                size_t len = strlen(t);
                char output[len+1];
                char *t1, *t2;

                strlcpy(output, t, sizeof(output));

                /*
                 * Strip trailing newlines, they are clutter and
                 * interfere with multi-line detection
                 */
                t1 = output + len - 1;
                while (t1 >= output && *t1 == '\n') {
                        *t1 = '\0';
                        t1--;
                }

                /* If the output is a single line then print it inline */
                t2 = strchr(output, '\n');
                if (t2 == NULL) {
                        printf("  OUTPUT: %s\n", output);
                        return;
                }

                /*
                 * More than 1 line.  Print a header and then each
                 * line, with suitable indent.  There are more general
                 * ways to do this, but let's maintain intermediate
                 * blank lines (e.g. strv_split() loses blank lines).
                 */
                printf("  OUTPUT:\n");
                t1 = output;
                do {
                        /*
                         * Points to newline character. t2 initially
                         * set non-NULL outside loop because this loop
                         * only covers multi-line output.
                         */
                        *t2 = '\0';


                        printf("    %s\n", t1);
                        t1 = t2 + 1;

                        if (t1 >= output + len) {
                                break;
                        }

                        /* strchrnul() would be awesome, but isn't portable */
                        t2 = strchr(t1, '\n');
                        if (t2 == NULL) {
                                t2 = output + len;
                        }
                } while (true);
        }
}

static void print_status(const char *component,
                         const char *event,
                         int result,
                         struct ctdb_event_reply_status *status)
{
        int i;

        if (result != 0) {
                if (result == ENOENT) {
                        printf("Event dir for %s does not exist\n", component);
                } else if (result == EINVAL) {
                        printf("Event %s has never run in %s\n",
                               event,
                               component);
                } else {
                        printf("Unknown error (%d) for event %s in %s\n",
                               result,
                               event,
                               component);
                }
                return;
        }

        for (i=0; i<status->script_list->num_scripts; i++) {
                print_status_one(&status->script_list->script[i]);
        }
}

static int event_command_status(TALLOC_CTX *mem_ctx,
                                int argc,
                                const char **argv,
                                void *private_data)
{
        struct event_tool_context *ctx = talloc_get_type_abort(
                private_data, struct event_tool_context);
        struct tevent_req *req;
        struct ctdb_event_request_status request_status;
        struct ctdb_event_reply_status *reply_status;
        int ret = 0, result = 0;
        bool ok;

        if (argc != 2) {
                cmdline_usage(ctx->cmdline, "status");
                return 1;
        }

        ret = ctdb_event_init(ctx, ctx->ev, &ctx->eclient);
        if (ret != 0) {
                D_ERR("Failed to initialize event client, ret=%d\n", ret);
                return ret;
        }

        request_status.component = argv[0];
        request_status.event = argv[1];

        req = ctdb_event_status_send(mem_ctx,
                                     ctx->ev,
                                     ctx->eclient,
                                     &request_status);
        if (req == NULL) {
                D_ERR("Memory allocation error\n");
                return 1;
        }

        tevent_req_poll(req, ctx->ev);

        ok = ctdb_event_status_recv(req,
                                    &ret,
                                    &result,
                                    mem_ctx,
                                    &reply_status);
        if (!ok) {
                D_ERR("Failed to get status for event %s in %s, ret=%d\n",
                      argv[1],
                      argv[0],
                      ret);
                return 1;
        }

        D_NOTICE("Command status finished with result=%d\n", result);

        print_status(argv[0], argv[1], result, reply_status);

        if (reply_status == NULL) {
                ret = result;
        } else {
                ret = reply_status->summary;
                ret = (ret < 0) ? -ret : ret;
        }
        return ret;
}

#define EVENT_SCRIPT_DISABLED      ' '
#define EVENT_SCRIPT_ENABLED       '*'

static int event_command_script_list(TALLOC_CTX *mem_ctx,
                                     int argc,
                                     const char **argv,
                                     void *private_data)
{
        struct event_tool_context *ctx = talloc_get_type_abort(
                private_data, struct event_tool_context);
        char *subdir = NULL;
        char *data_dir = NULL;
        char *etc_dir = NULL;
        char *t = NULL;
        struct event_script_list *data_list = NULL;
        struct event_script_list *etc_list = NULL;
        unsigned int i, j, matched;
        int ret = 0;

        if (argc != 1) {
                cmdline_usage(ctx->cmdline, "script list");
                return 1;
        }

        subdir = talloc_asprintf(mem_ctx, "events/%s", argv[0]);
        if (subdir == NULL) {
                return ENOMEM;
        }

        data_dir = path_datadir_append(mem_ctx, subdir);
        if (data_dir == NULL) {
                return ENOMEM;
        }

        t = talloc_size(mem_ctx, PATH_MAX);
        if (t == NULL) {
                return ENOMEM;
        }

        data_dir = realpath(data_dir, t);
        if (data_dir == NULL) {
                if (errno != ENOENT) {
                        return errno;
                }
                D_ERR("Command script list finished with result=%d\n", ENOENT);
                return ENOENT;
        }

        etc_dir = path_etcdir_append(mem_ctx, subdir);
        if (etc_dir == NULL) {
                return ENOMEM;
        }

        /*
         * Ignore error on ENOENT for cut down (e.g. fixed/embedded)
         * installs that don't use symlinks but just populate etc_dir
         * directly
         */
        ret = event_script_get_list(mem_ctx, data_dir, &data_list);
        if (ret != 0 && ret != ENOENT) {
                D_ERR("Command script list finished with result=%d\n", ret);
                goto done;
        }

        ret = event_script_get_list(mem_ctx, etc_dir, &etc_list);
        if (ret != 0) {
                D_ERR("Command script list finished with result=%d\n", ret);
                goto done;
        }

        D_NOTICE("Command script list finished with result=%d\n", ret);

        if (data_list == NULL) {
                goto list_enabled_only;
        }

        /*
         * First list scripts provided by CTDB.  Flag those that are
         * enabled via a symlink and arrange for them to be excluded
         * from the subsequent list of local scripts.
         *
         * Both lists are sorted, so walk the list of enabled scripts
         * only once in this pass.
         */
        j = 0;
        matched = 0;
        for (i = 0; i < data_list->num_scripts; i++) {
                struct event_script *d = data_list->script[i];
                char flag = EVENT_SCRIPT_DISABLED;
                char buf[PATH_MAX];
                ssize_t len;

                /* Check to see if this script is enabled */
                while (j < etc_list->num_scripts) {
                        struct event_script *e = etc_list->script[j];

                        ret = strcmp(e->name, d->name);

                        if (ret > 0) {
                                /*
                                 * Enabled name is greater, so needs
                                 * to be considered later: done
                                 */
                                break;
                        }

                        if (ret < 0) {
                                /* Enabled name is less: next */
                                j++;
                                continue;
                        }

                        len = readlink(e->path, buf, sizeof(buf));
                        if (len == -1 || (size_t)len >= sizeof(buf)) {
                                /*
                                 * Not a link?  Disappeared?  Invalid
                                 * link target?  Something else?
                                 *
                                 * Doesn't match provided script: next, done
                                 */
                                j++;
                                break;
                        }

                        /* readlink() does not NUL-terminate */
                        buf[len] = '\0';

                        ret = strcmp(buf, d->path);
                        if (ret != 0) {
                                /* Enabled link doesn't match: next, done */
                                j++;
                                break;
                        }

                        /*
                         * Enabled script's symlink matches our
                         * script: flag our script as enabled
                         *
                         * Also clear the enabled script so it can be
                         * trivially skipped in the next pass
                         */
                        flag = EVENT_SCRIPT_ENABLED;
                        TALLOC_FREE(etc_list->script[j]);
                        j++;
                        matched++;
                        break;
                }

                printf("%c %s\n", flag, d->name);
        }

        /* Print blank line if both provided and local lists are being printed */
        if (data_list->num_scripts > 0 && matched != etc_list->num_scripts) {
                printf("\n");
        }

list_enabled_only:

        /* Now print details of local scripts, after a blank line */
        for (j = 0; j < etc_list->num_scripts; j++) {
                struct event_script *e = etc_list->script[j];
                char flag = EVENT_SCRIPT_DISABLED;

                if (e == NULL) {
                        /* Matched in previous pass: next */
                        continue;
                }

                /* Script is local: if executable then flag as enabled */
                if (e->enabled) {
                        flag = EVENT_SCRIPT_ENABLED;
                }

                printf("%c %s\n", flag, e->name);
        }

        ret = 0;

done:
        talloc_free(subdir);
        talloc_free(data_dir);
        talloc_free(etc_dir);
        talloc_free(data_list);
        talloc_free(etc_list);

        return ret;
}

static int event_command_script(TALLOC_CTX *mem_ctx,
                                struct event_tool_context *ctx,
                                const char *component,
                                const char *script,
                                bool enable)
{
        char *subdir, *etc_dir;
        int result = 0;

        subdir = talloc_asprintf(mem_ctx, "events/%s", component);
        if (subdir == NULL) {
                return ENOMEM;
        }

        etc_dir = path_etcdir_append(mem_ctx, subdir);
        if (etc_dir == NULL) {
                return ENOMEM;
        }

        if (enable) {
                result = event_script_chmod(etc_dir, script, true);
        } else {
                result = event_script_chmod(etc_dir, script, false);
        }

        talloc_free(subdir);
        talloc_free(etc_dir);

        D_NOTICE("Command script finished with result=%d\n", result);

        if (result == EINVAL) {
                printf("Script %s is invalid in %s\n", script, component);
        } else if (result == ENOENT) {
                printf("Script %s does not exist in %s\n", script, component);
        }

        return result;
}

static int event_command_script_enable(TALLOC_CTX *mem_ctx,
                                       int argc,
                                       const char **argv,
                                       void *private_data)
{
        struct event_tool_context *ctx = talloc_get_type_abort(
                private_data, struct event_tool_context);
        struct stat statbuf;
        char *script, *etc_script;
        int ret;

        if (argc != 2) {
                cmdline_usage(ctx->cmdline, "script enable");
                return 1;
        }

        script = talloc_asprintf(mem_ctx, "events/%s/%s.script", argv[0], argv[1]);
        if (script == NULL) {
                return ENOMEM;
        }

        etc_script = path_etcdir_append(mem_ctx, script);
        if (etc_script == NULL) {
                return ENOMEM;
        }

        ret = lstat(etc_script, &statbuf);
        if (ret == 0) {
                if (S_ISLNK(statbuf.st_mode)) {
                        /* Link already exists */
                        return 0;
                } else if (S_ISREG(statbuf.st_mode)) {
                        return event_command_script(mem_ctx,
                                                    ctx,
                                                    argv[0],
                                                    argv[1],
                                                    true);
                }

                printf("Script %s is not a file or a link\n", etc_script);
                return EINVAL;
        } else {
                if (errno == ENOENT) {
                        char *t;
                        char *data_script;

                        data_script = path_datadir_append(mem_ctx, script);
                        if (data_script == NULL) {
                                return ENOMEM;
                        }

                        t = talloc_size(mem_ctx, PATH_MAX);
                        if (t == NULL) {
                                return ENOMEM;
                        }

                        data_script = realpath(data_script, t);
                        if (data_script == NULL) {
                                if (errno != ENOENT) {
                                        return errno;
                                }
                                printf("Script %s does not exist in %s\n",
                                       argv[1],
                                       argv[0]);
                                return ENOENT;
                        }

                        ret = stat(data_script, &statbuf);
                        if (ret != 0) {
                                printf("Script %s does not exist in %s\n",
                                       argv[1], argv[0]);
                                return ENOENT;
                        }

                        ret = symlink(data_script, etc_script);
                        if (ret != 0) {
                                printf("Failed to create symlink %s\n",
                                      etc_script);
                                return EIO;
                        }

                        return 0;
                }

                printf("Script %s does not exist\n", etc_script);
                return EINVAL;
        }
}

static int event_command_script_disable(TALLOC_CTX *mem_ctx,
                                        int argc,
                                        const char **argv,
                                        void *private_data)
{
        struct event_tool_context *ctx = talloc_get_type_abort(
                private_data, struct event_tool_context);
        struct stat statbuf;
        char *script, *etc_script;
        int ret;


        if (argc != 2) {
                cmdline_usage(ctx->cmdline, "script disable");
                return 1;
        }

        script = talloc_asprintf(mem_ctx, "events/%s/%s.script", argv[0], argv[1]);
        if (script == NULL) {
                return ENOMEM;
        }

        etc_script = path_etcdir_append(mem_ctx, script);
        if (etc_script == NULL) {
                return ENOMEM;
        }

        ret = lstat(etc_script, &statbuf);
        if (ret == 0) {
                if (S_ISLNK(statbuf.st_mode)) {
                        /* Link exists */
                        ret = unlink(etc_script);
                        if (ret != 0) {
                                printf("Failed to remove symlink %s\n",
                                       etc_script);
                                return EIO;
                        }

                        return 0;
                } else if (S_ISREG(statbuf.st_mode)) {
                        return event_command_script(mem_ctx,
                                                    ctx,
                                                    argv[0],
                                                    argv[1],
                                                    false);
                }

                printf("Script %s is not a file or a link\n", etc_script);
                return EINVAL;
        }

        return 0;
}

struct cmdline_command event_commands[] = {
        { "run", event_command_run,
                "Run an event", "<timeout> <component> <event> <args>" },
        { "status", event_command_status,
                "Get status of an event", "<component> <event>" },
        { "script list", event_command_script_list,
                "List event scripts", "<component>" },
        { "script enable", event_command_script_enable,
                "Enable an event script", "<component> <script>" },
        { "script disable", event_command_script_disable,
                "Disable an event script", "<component> <script>" },
        CMDLINE_TABLEEND
};

int event_tool_init(TALLOC_CTX *mem_ctx,
                    const char *prog,
                    struct poptOption *options,
                    int argc,
                    const char **argv,
                    bool parse_options,
                    struct event_tool_context **result)
{
        struct event_tool_context *ctx;
        int ret;

        ctx = talloc_zero(mem_ctx, struct event_tool_context);
        if (ctx == NULL) {
                D_ERR("Memory allocation error\n");
                return ENOMEM;
        }

        ret = cmdline_init(mem_ctx,
                           prog,
                           options,
                           NULL,
                           event_commands,
                           &ctx->cmdline);
        if (ret != 0) {
                D_ERR("Failed to initialize cmdline, ret=%d\n", ret);
                talloc_free(ctx);
                return ret;
        }

        ret = cmdline_parse(ctx->cmdline, argc, argv, parse_options);
        if (ret != 0) {
                cmdline_usage(ctx->cmdline, NULL);
                talloc_free(ctx);
                return ret;
        }

        *result = ctx;
        return 0;
}

int event_tool_run(struct event_tool_context *ctx, int *result)
{
        int ret;

        ctx->ev = tevent_context_init(ctx);
        if (ctx->ev == NULL) {
                D_ERR("Failed to initialize tevent\n");
                return ENOMEM;
        }

        ret = cmdline_run(ctx->cmdline, ctx, result);
        return ret;
}

#ifdef CTDB_EVENT_TOOL

static struct {
        const char *debug;
} event_data = {
        .debug = "ERROR",
};

struct poptOption event_options[] = {
        { "debug", 'd', POPT_ARG_STRING, &event_data.debug, 0,
                "debug level", "ERROR|WARNING|NOTICE|INFO|DEBUG" },
        POPT_TABLEEND
};

int main(int argc, const char **argv)
{
        TALLOC_CTX *mem_ctx;
        struct event_tool_context *ctx;
        int ret, result = 0;
        int level;
        bool ok;

        mem_ctx = talloc_new(NULL);
        if (mem_ctx == NULL) {
                fprintf(stderr, "Memory allocation error\n");
                exit(1);
        }

        ret = event_tool_init(mem_ctx,
                              "ctdb-event",
                              event_options,
                              argc,
                              argv,
                              true,
                              &ctx);
        if (ret != 0) {
                talloc_free(mem_ctx);
                exit(1);
        }

        setup_logging("ctdb-event", DEBUG_STDERR);
        ok = debug_level_parse(event_data.debug, &level);
        if (!ok) {
                level = DEBUG_ERR;
        }
        debuglevel_set(level);

        ret = event_tool_run(ctx, &result);
        if (ret != 0) {
                exit(1);
        }

        talloc_free(mem_ctx);
        exit(result);
}

#endif /* CTDB_EVENT_TOOL */