ctdb/server/eventscript.c

   1 /*
   2    event script handling
   3
   4    Copyright (C) Andrew Tridgell  2007
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #include "replace.h"
  21 #include "system/filesys.h"
  22 #include "system/network.h"
  23 #include "system/wait.h"
  24 #include "system/dir.h"
  25 #include "system/locale.h"
  26 #include "system/time.h"
  27
  28 #include <talloc.h>
  29 #include <tevent.h>
  30
  31 #include "lib/util/dlinklist.h"
  32 #include "lib/util/debug.h"
  33 #include "lib/util/samba_util.h"
  34
  35 #include "ctdb_private.h"
  36 #include "ctdb_logging.h"
  37
  38 #include "common/rb_tree.h"
  39 #include "common/system.h"
  40 #include "common/common.h"
  41
  42
  43 static void ctdb_event_script_timeout(struct tevent_context *ev,
  44                                       struct tevent_timer *te,
  45                                       struct timeval t, void *p);
  46
  47 /* This is attached to the event script state. */
  48 struct event_script_callback {
  49         struct event_script_callback *next, *prev;
  50         struct ctdb_context *ctdb;
  51
  52         /* Warning: this can free us! */
  53         void (*fn)(struct ctdb_context *, int, void *);
  54         void *private_data;
  55 };
  56
  57 struct ctdb_event_script_state {
  58         struct ctdb_context *ctdb;
  59         struct event_script_callback *callback;
  60         pid_t child;
  61         int fd[2];
  62         enum ctdb_event call;
  63         const char *options;
  64         struct timeval timeout;
  65
  66         unsigned int current;
  67         struct ctdb_script_list_old *scripts;
  68 };
  69
  70 static struct ctdb_script *get_current_script(struct ctdb_event_script_state *state)
  71 {
  72         return &state->scripts->scripts[state->current];
  73 }
  74
  75 /* called from ctdb_logging when we have received output on STDERR from
  76  * one of the eventscripts
  77  */
  78 static void log_event_script_output(const char *str, uint16_t len, void *p)
  79 {
  80         struct ctdb_event_script_state *state
  81                 = talloc_get_type(p, struct ctdb_event_script_state);
  82         struct ctdb_script *current;
  83         unsigned int slen, min;
  84
  85         /* We may have been aborted to run something else.  Discard */
  86         if (state->scripts == NULL) {
  87                 return;
  88         }
  89
  90         current = get_current_script(state);
  91
  92         /* Append, but don't overfill buffer.  It starts zero-filled. */
  93         slen = strlen(current->output);
  94         min = MIN(len, sizeof(current->output) - slen - 1);
  95
  96         memcpy(current->output + slen, str, min);
  97 }
  98
  99 int32_t ctdb_control_get_event_script_status(struct ctdb_context *ctdb,
 100                                              uint32_t call_type,
 101                                              TDB_DATA *outdata)
 102 {
 103         if (call_type >= CTDB_EVENT_MAX) {
 104                 return -1;
 105         }
 106
 107         if (ctdb->last_status[call_type] == NULL) {
 108                 /* If it's never been run, return nothing so they can tell. */
 109                 outdata->dsize = 0;
 110         } else {
 111                 outdata->dsize = talloc_get_size(ctdb->last_status[call_type]);
 112                 outdata->dptr  = (uint8_t *)ctdb->last_status[call_type];
 113         }
 114         return 0;
 115 }
 116
 117 /* To ignore directory entry return 0, else return non-zero */
 118 static int script_filter(const struct dirent *de)
 119 {
 120         int namelen = strlen(de->d_name);
 121
 122         /* Ignore . and .. */
 123         if (namelen < 3) {
 124                 return 0;
 125         }
 126
 127         /* Skip temporary files left behind by emacs */
 128         if (de->d_name[namelen-1] == '~') {
 129                 return 0;
 130         }
 131
 132         /* Filename should start with [0-9][0-9]. */
 133         if (!isdigit(de->d_name[0]) || !isdigit(de->d_name[1]) ||
 134             de->d_name[2] != '.') {
 135                 return 0;
 136         }
 137
 138         if (namelen > MAX_SCRIPT_NAME) {
 139                 return 0;
 140         }
 141
 142         return 1;
 143 }
 144
 145 /* Return true if OK, otherwise set errno. */
 146 static bool check_executable(const char *dir, const char *name)
 147 {
 148         char *full;
 149         struct stat st;
 150
 151         full = talloc_asprintf(NULL, "%s/%s", dir, name);
 152         if (!full)
 153                 return false;
 154
 155         if (stat(full, &st) != 0) {
 156                 DEBUG(DEBUG_ERR,("Could not stat event script %s: %s\n",
 157                                  full, strerror(errno)));
 158                 talloc_free(full);
 159                 return false;
 160         }
 161
 162         if (!(st.st_mode & S_IXUSR)) {
 163                 DEBUG(DEBUG_DEBUG,("Event script %s is not executable. Ignoring this event script\n", full));
 164                 errno = ENOEXEC;
 165                 talloc_free(full);
 166                 return false;
 167         }
 168
 169         talloc_free(full);
 170         return true;
 171 }
 172
 173 static struct ctdb_script_list_old *ctdb_get_script_list(
 174                                                 struct ctdb_context *ctdb,
 175                                                 TALLOC_CTX *mem_ctx)
 176 {
 177         struct dirent **namelist;
 178         struct ctdb_script_list_old *scripts;
 179         int i, count;
 180
 181         /* scan all directory entries and insert all valid scripts into the
 182            tree
 183         */
 184         count = scandir(ctdb->event_script_dir, &namelist, script_filter, alphasort);
 185         if (count == -1) {
 186                 DEBUG(DEBUG_CRIT, ("Failed to read event script directory '%s' - %s\n",
 187                                    ctdb->event_script_dir, strerror(errno)));
 188                 return NULL;
 189         }
 190
 191         /* Overallocates by one, but that's OK */
 192         scripts = talloc_zero_size(mem_ctx,
 193                                    sizeof(*scripts)
 194                                    + sizeof(scripts->scripts[0]) * count);
 195         if (scripts == NULL) {
 196                 DEBUG(DEBUG_ERR, (__location__ " Failed to allocate scripts\n"));
 197                 goto done;
 198         }
 199         scripts->num_scripts = count;
 200
 201         for (i = 0; i < count; i++) {
 202                 struct ctdb_script *s = &scripts->scripts[i];
 203
 204                 if (strlcpy(s->name, namelist[i]->d_name, sizeof(s->name)) >=
 205                     sizeof(s->name)) {
 206                         s->status = -ENAMETOOLONG;
 207                         continue;
 208                 }
 209
 210                 s->status = 0;
 211                 if (!check_executable(ctdb->event_script_dir,
 212                                       namelist[i]->d_name)) {
 213                         s->status = -errno;
 214                 }
 215         }
 216
 217 done:
 218         for (i=0; i<count; i++) {
 219                 free(namelist[i]);
 220         }
 221         free(namelist);
 222         return scripts;
 223 }
 224
 225
 226 /* There cannot be more than 10 arguments to command helper. */
 227 #define MAX_HELPER_ARGS         (10)
 228
 229 static bool child_helper_args(TALLOC_CTX *mem_ctx, struct ctdb_context *ctdb,
 230                               enum ctdb_event call,
 231                               const char *options,
 232                               struct ctdb_script *current, int fd,
 233                               int *argc, const char ***argv)
 234 {
 235         const char **tmp;
 236         int n, i;
 237         char *t, *saveptr, *opt;
 238
 239         tmp = talloc_array(mem_ctx, const char *, 10+1);
 240         if (tmp == NULL)  goto failed;
 241
 242         tmp[0] = talloc_asprintf(tmp, "%d", fd);
 243         tmp[1] = talloc_asprintf(tmp, "%s/%s", ctdb->event_script_dir, current->name);
 244         tmp[2] = talloc_asprintf(tmp, "%s", ctdb_eventscript_call_names[call]);
 245         n = 3;
 246
 247         /* Split options into individual arguments */
 248         opt = talloc_strdup(mem_ctx, options);
 249         if (opt == NULL) {
 250                 goto failed;
 251         }
 252
 253         t = strtok_r(opt, " ", &saveptr);
 254         while (t != NULL) {
 255                 tmp[n++] = talloc_strdup(tmp, t);
 256                 if (n > MAX_HELPER_ARGS) {
 257                         goto args_failed;
 258                 }
 259                 t = strtok_r(NULL, " ", &saveptr);
 260         }
 261
 262         for (i=0; i<n; i++) {
 263                 if (tmp[i] == NULL) {
 264                         goto failed;
 265                 }
 266         }
 267
 268         /* Last argument should be NULL */
 269         tmp[n++] = NULL;
 270
 271         *argc = n;
 272         *argv = tmp;
 273         return true;
 274
 275
 276 args_failed:
 277         DEBUG(DEBUG_ERR, (__location__ " too many arguments '%s' to eventscript '%s'\n",
 278                           options, ctdb_eventscript_call_names[call]));
 279
 280 failed:
 281         if (tmp) {
 282                 talloc_free(tmp);
 283         }
 284         return false;
 285
 286 }
 287
 288 static void ctdb_event_script_handler(struct tevent_context *ev,
 289                                       struct tevent_fd *fde,
 290                                       uint16_t flags, void *p);
 291
 292 static char helper_prog[PATH_MAX+1] = "";
 293
 294 static int fork_child_for_script(struct ctdb_context *ctdb,
 295                                  struct ctdb_event_script_state *state)
 296 {
 297         int r;
 298         struct tevent_fd *fde;
 299         struct ctdb_script *current = get_current_script(state);
 300         int argc;
 301         const char **argv;
 302
 303         if (!ctdb_set_helper("event helper", helper_prog, sizeof(helper_prog),
 304                              "CTDB_EVENT_HELPER",
 305                              CTDB_HELPER_BINDIR, "ctdb_event_helper")) {
 306                 ctdb_die(ctdb, __location__
 307                          " Unable to set event helper\n");
 308         }
 309
 310         current->start = timeval_current();
 311
 312         r = pipe(state->fd);
 313         if (r != 0) {
 314                 DEBUG(DEBUG_ERR, (__location__ " pipe failed for child eventscript process\n"));
 315                 return -errno;
 316         }
 317
 318         /* Arguments for helper */
 319         if (!child_helper_args(state, ctdb, state->call, state->options, current,
 320                                state->fd[1], &argc, &argv)) {
 321                 DEBUG(DEBUG_ERR, (__location__ " failed to create arguments for eventscript helper\n"));
 322                 r = -ENOMEM;
 323                 close(state->fd[0]);
 324                 close(state->fd[1]);
 325                 return r;
 326         }
 327
 328         if (!ctdb_vfork_with_logging(state, ctdb, current->name,
 329                                      helper_prog, argc, argv,
 330                                      log_event_script_output,
 331                                      state, &state->child)) {
 332                 talloc_free(argv);
 333                 r = -errno;
 334                 close(state->fd[0]);
 335                 close(state->fd[1]);
 336                 return r;
 337         }
 338
 339         talloc_free(argv);
 340
 341         close(state->fd[1]);
 342         set_close_on_exec(state->fd[0]);
 343
 344         /* Set ourselves up to be called when that's done. */
 345         fde = tevent_add_fd(ctdb->ev, state, state->fd[0], TEVENT_FD_READ,
 346                             ctdb_event_script_handler, state);
 347         tevent_fd_set_auto_close(fde);
 348
 349         return 0;
 350 }
 351
 352 /*
 353  Summarize status of this run of scripts.
 354  */
 355 static int script_status(struct ctdb_script_list_old *scripts)
 356 {
 357         unsigned int i;
 358
 359         for (i = 0; i < scripts->num_scripts; i++) {
 360                 switch (scripts->scripts[i].status) {
 361                 case -ENAMETOOLONG:
 362                 case -ENOENT:
 363                 case -ENOEXEC:
 364                         /* Disabled or missing; that's OK. */
 365                         break;
 366                 case 0:
 367                         /* No problem. */
 368                         break;
 369                 default:
 370                         return scripts->scripts[i].status;
 371                 }
 372         }
 373
 374         /* All OK! */
 375         return 0;
 376 }
 377
 378 /* called when child is finished */
 379 static void ctdb_event_script_handler(struct tevent_context *ev,
 380                                       struct tevent_fd *fde,
 381                                       uint16_t flags, void *p)
 382 {
 383         struct ctdb_event_script_state *state =
 384                 talloc_get_type(p, struct ctdb_event_script_state);
 385         struct ctdb_script *current = get_current_script(state);
 386         struct ctdb_context *ctdb = state->ctdb;
 387         int r, status;
 388
 389         if (ctdb == NULL) {
 390                 DEBUG(DEBUG_ERR,("Eventscript finished but ctdb is NULL\n"));
 391                 return;
 392         }
 393
 394         r = sys_read(state->fd[0], &current->status, sizeof(current->status));
 395         if (r < 0) {
 396                 current->status = -errno;
 397         } else if (r == 0) {
 398                 current->status = -EINTR;
 399         } else if (r != sizeof(current->status)) {
 400                 current->status = -EIO;
 401         }
 402
 403         current->finished = timeval_current();
 404         /* valgrind gets overloaded if we run next script as it's still doing
 405          * post-execution analysis, so kill finished child here. */
 406         if (ctdb->valgrinding) {
 407                 ctdb_kill(ctdb, state->child, SIGKILL);
 408         }
 409
 410         state->child = 0;
 411
 412         status = script_status(state->scripts);
 413
 414         /* Aborted or finished all scripts?  We're done. */
 415         if (status != 0 || state->current+1 == state->scripts->num_scripts) {
 416                 if (status != 0) {
 417                         DEBUG(DEBUG_INFO,
 418                               ("Eventscript %s %s finished with state %d\n",
 419                                ctdb_eventscript_call_names[state->call],
 420                                state->options, status));
 421                 }
 422
 423                 ctdb->event_script_timeouts = 0;
 424                 talloc_free(state);
 425                 return;
 426         }
 427
 428         /* Forget about that old fd. */
 429         talloc_free(fde);
 430
 431         /* Next script! */
 432         state->current++;
 433         current++;
 434         current->status = fork_child_for_script(ctdb, state);
 435         if (current->status != 0) {
 436                 /* This calls the callback. */
 437                 talloc_free(state);
 438         }
 439 }
 440
 441 struct debug_hung_script_state {
 442         struct ctdb_context *ctdb;
 443         pid_t child;
 444         enum ctdb_event call;
 445 };
 446
 447 static int debug_hung_script_state_destructor(struct debug_hung_script_state *state)
 448 {
 449         if (state->child) {
 450                 ctdb_kill(state->ctdb, state->child, SIGKILL);
 451         }
 452         return 0;
 453 }
 454
 455 static void debug_hung_script_timeout(struct tevent_context *ev, struct tevent_timer *te,
 456                                       struct timeval t, void *p)
 457 {
 458         struct debug_hung_script_state *state =
 459                 talloc_get_type(p, struct debug_hung_script_state);
 460
 461         talloc_free(state);
 462 }
 463
 464 static void debug_hung_script_done(struct tevent_context *ev, struct tevent_fd *fde,
 465                                    uint16_t flags, void *p)
 466 {
 467         struct debug_hung_script_state *state =
 468                 talloc_get_type(p, struct debug_hung_script_state);
 469
 470         talloc_free(state);
 471 }
 472
 473 static void ctdb_run_debug_hung_script(struct ctdb_context *ctdb, struct debug_hung_script_state *state)
 474 {
 475         pid_t pid;
 476         const char * debug_hung_script = CTDB_ETCDIR "/debug-hung-script.sh";
 477         int fd[2];
 478         struct tevent_timer *ttimer;
 479         struct tevent_fd *tfd;
 480         const char **argv;
 481         int i;
 482
 483         if (pipe(fd) < 0) {
 484                 DEBUG(DEBUG_ERR,("Failed to create pipe fd for debug hung script\n"));
 485                 return;
 486         }
 487
 488         if (getenv("CTDB_DEBUG_HUNG_SCRIPT") != NULL) {
 489                 debug_hung_script = getenv("CTDB_DEBUG_HUNG_SCRIPT");
 490         }
 491
 492         argv = talloc_array(state, const char *, 5);
 493
 494         argv[0] = talloc_asprintf(argv, "%d", fd[1]);
 495         argv[1] = talloc_strdup(argv, debug_hung_script);
 496         argv[2] = talloc_asprintf(argv, "%d", state->child);
 497         argv[3] = talloc_strdup(argv, ctdb_eventscript_call_names[state->call]);
 498         argv[4] = NULL;
 499
 500         for (i=0; i<4; i++) {
 501                 if (argv[i] == NULL) {
 502                         close(fd[0]);
 503                         close(fd[1]);
 504                         talloc_free(argv);
 505                         return;
 506                 }
 507         }
 508
 509
 510         if (!ctdb_vfork_with_logging(state, ctdb, "Hung-script",
 511                                      helper_prog, 5, argv, NULL, NULL, &pid)) {
 512                 DEBUG(DEBUG_ERR,("Failed to fork a child to track hung event script\n"));
 513                 talloc_free(argv);
 514                 close(fd[0]);
 515                 close(fd[1]);
 516                 return;
 517         }
 518
 519         talloc_free(argv);
 520         close(fd[1]);
 521
 522         ttimer = tevent_add_timer(ctdb->ev, state,
 523                                   timeval_current_ofs(ctdb->tunable.script_timeout, 0),
 524                                   debug_hung_script_timeout, state);
 525         if (ttimer == NULL) {
 526                 close(fd[0]);
 527                 return;
 528         }
 529
 530         tfd = tevent_add_fd(ctdb->ev, state, fd[0], TEVENT_FD_READ,
 531                             debug_hung_script_done, state);
 532         if (tfd == NULL) {
 533                 talloc_free(ttimer);
 534                 close(fd[0]);
 535                 return;
 536         }
 537         tevent_fd_set_auto_close(tfd);
 538 }
 539
 540 /* called when child times out */
 541 static void ctdb_event_script_timeout(struct tevent_context *ev,
 542                                       struct tevent_timer *te,
 543                                       struct timeval t, void *p)
 544 {
 545         struct ctdb_event_script_state *state = talloc_get_type(p, struct ctdb_event_script_state);
 546         struct ctdb_context *ctdb = state->ctdb;
 547         struct ctdb_script *current = get_current_script(state);
 548         struct debug_hung_script_state *debug_state;
 549
 550         DEBUG(DEBUG_ERR,("Event script '%s %s %s' timed out after %.1fs, count: %u, pid: %d\n",
 551                          current->name, ctdb_eventscript_call_names[state->call], state->options,
 552                          timeval_elapsed(&current->start),
 553                          ctdb->event_script_timeouts, state->child));
 554
 555         /* ignore timeouts for these events */
 556         switch (state->call) {
 557         case CTDB_EVENT_START_RECOVERY:
 558         case CTDB_EVENT_RECOVERED:
 559         case CTDB_EVENT_TAKE_IP:
 560         case CTDB_EVENT_RELEASE_IP:
 561                 state->scripts->scripts[state->current].status = 0;
 562                 DEBUG(DEBUG_ERR,("Ignoring hung script for %s call %d\n", state->options, state->call));
 563                 break;
 564         default:
 565                 state->scripts->scripts[state->current].status = -ETIME;
 566         }
 567
 568         debug_state = talloc_zero(ctdb, struct debug_hung_script_state);
 569         if (debug_state == NULL) {
 570                 talloc_free(state);
 571                 return;
 572         }
 573
 574         /* Save information useful for running debug hung script, so
 575          * eventscript state can be freed.
 576          */
 577         debug_state->ctdb = ctdb;
 578         debug_state->child = state->child;
 579         debug_state->call = state->call;
 580
 581         /* This destructor will actually kill the hung event script */
 582         talloc_set_destructor(debug_state, debug_hung_script_state_destructor);
 583
 584         state->child = 0;
 585         talloc_free(state);
 586
 587         ctdb_run_debug_hung_script(ctdb, debug_state);
 588 }
 589
 590 /*
 591   destroy an event script: kill it if ->child != 0.
 592  */
 593 static int event_script_destructor(struct ctdb_event_script_state *state)
 594 {
 595         int status;
 596         struct event_script_callback *callback;
 597
 598         if (state->child) {
 599                 DEBUG(DEBUG_ERR,(__location__ " Sending SIGTERM to child pid:%d\n", state->child));
 600
 601                 if (ctdb_kill(state->ctdb, state->child, SIGTERM) != 0) {
 602                         DEBUG(DEBUG_ERR,("Failed to kill child process for eventscript, errno %s(%d)\n", strerror(errno), errno));
 603                 }
 604         }
 605
 606         /* If we were the current monitor, we no longer are. */
 607         if (state->ctdb->current_monitor == state) {
 608                 state->ctdb->current_monitor = NULL;
 609         }
 610
 611         /* Save our scripts as the last executed status, if we have them.
 612          * See ctdb_event_script_callback_v where we abort monitor event. */
 613         if (state->scripts) {
 614                 talloc_free(state->ctdb->last_status[state->call]);
 615                 state->ctdb->last_status[state->call] = state->scripts;
 616                 if (state->current < state->ctdb->last_status[state->call]->num_scripts) {
 617                         state->ctdb->last_status[state->call]->num_scripts = state->current+1;
 618                 }
 619         }
 620
 621         /* Use last status as result, or "OK" if none. */
 622         if (state->ctdb->last_status[state->call]) {
 623                 status = script_status(state->ctdb->last_status[state->call]);
 624         } else {
 625                 status = 0;
 626         }
 627
 628         state->ctdb->active_events--;
 629         if (state->ctdb->active_events < 0) {
 630                 ctdb_fatal(state->ctdb, "Active events < 0");
 631         }
 632
 633         /* This is allowed to free us; talloc will prevent double free anyway,
 634          * but beware if you call this outside the destructor!
 635          * the callback hangs off a different context so we walk the list
 636          * of "active" callbacks until we find the one state points to.
 637          * if we cant find it it means the callback has been removed.
 638          */
 639         for (callback = state->ctdb->script_callbacks; callback != NULL; callback = callback->next) {
 640                 if (callback == state->callback) {
 641                         break;
 642                 }
 643         }
 644
 645         state->callback = NULL;
 646
 647         if (callback) {
 648                 /* Make sure destructor doesn't free itself! */
 649                 talloc_steal(NULL, callback);
 650                 callback->fn(state->ctdb, status, callback->private_data);
 651                 talloc_free(callback);
 652         }
 653
 654         return 0;
 655 }
 656
 657 static unsigned int count_words(const char *options)
 658 {
 659         unsigned int words = 0;
 660
 661         options += strspn(options, " \t");
 662         while (*options) {
 663                 words++;
 664                 options += strcspn(options, " \t");
 665                 options += strspn(options, " \t");
 666         }
 667         return words;
 668 }
 669
 670 static bool check_options(enum ctdb_event call, const char *options)
 671 {
 672         switch (call) {
 673         /* These all take no arguments. */
 674         case CTDB_EVENT_INIT:
 675         case CTDB_EVENT_SETUP:
 676         case CTDB_EVENT_STARTUP:
 677         case CTDB_EVENT_START_RECOVERY:
 678         case CTDB_EVENT_RECOVERED:
 679         case CTDB_EVENT_MONITOR:
 680         case CTDB_EVENT_SHUTDOWN:
 681         case CTDB_EVENT_IPREALLOCATED:
 682                 return count_words(options) == 0;
 683
 684         case CTDB_EVENT_TAKE_IP: /* interface, IP address, netmask bits. */
 685         case CTDB_EVENT_RELEASE_IP:
 686                 return count_words(options) == 3;
 687
 688         case CTDB_EVENT_UPDATE_IP: /* old interface, new interface, IP address, netmask bits. */
 689                 return count_words(options) == 4;
 690
 691         default:
 692                 DEBUG(DEBUG_ERR,(__location__ "Unknown ctdb_event %u\n", call));
 693                 return false;
 694         }
 695 }
 696
 697 static int remove_callback(struct event_script_callback *callback)
 698 {
 699         DLIST_REMOVE(callback->ctdb->script_callbacks, callback);
 700         return 0;
 701 }
 702
 703 /*
 704   run the event script in the background, calling the callback when
 705   finished
 706  */
 707 static int ctdb_event_script_callback_v(struct ctdb_context *ctdb,
 708                                         const void *mem_ctx,
 709                                         void (*callback)(struct ctdb_context *, int, void *),
 710                                         void *private_data,
 711                                         enum ctdb_event call,
 712                                         const char *fmt, va_list ap)
 713 {
 714         struct ctdb_event_script_state *state;
 715
 716         if (ctdb->recovery_mode != CTDB_RECOVERY_NORMAL) {
 717                 /* we guarantee that only some specifically allowed event scripts are run
 718                    while in recovery */
 719                 const enum ctdb_event allowed_calls[] = {
 720                         CTDB_EVENT_INIT,
 721                         CTDB_EVENT_SETUP,
 722                         CTDB_EVENT_START_RECOVERY,
 723                         CTDB_EVENT_SHUTDOWN,
 724                         CTDB_EVENT_RELEASE_IP,
 725                         CTDB_EVENT_IPREALLOCATED,
 726                 };
 727                 int i;
 728                 for (i=0;i<ARRAY_SIZE(allowed_calls);i++) {
 729                         if (call == allowed_calls[i]) break;
 730                 }
 731                 if (i == ARRAY_SIZE(allowed_calls)) {
 732                         DEBUG(DEBUG_ERR,("Refusing to run event scripts call '%s' while in recovery\n",
 733                                  ctdb_eventscript_call_names[call]));
 734                         return -1;
 735                 }
 736         }
 737
 738         /* Do not run new monitor events if some event is already
 739          * running, unless the running event is a monitor event, in
 740          * which case running a new one should cancel the old one. */
 741         if (call == CTDB_EVENT_MONITOR &&
 742             ctdb->active_events > 0 &&
 743             ctdb->current_monitor == NULL) {
 744                 if (callback != NULL) {
 745                         callback(ctdb, -ECANCELED, private_data);
 746                 }
 747                 return 0;
 748         }
 749
 750         /* Kill off any running monitor events to run this event. */
 751         if (ctdb->current_monitor) {
 752                 struct ctdb_event_script_state *ms = talloc_get_type(ctdb->current_monitor, struct ctdb_event_script_state);
 753
 754                 /* Cancel current monitor callback state only if monitoring
 755                  * context ctdb->monitor->monitor_context has not been freed */
 756                 if (ms->callback != NULL && !ctdb_stopped_monitoring(ctdb)) {
 757                         ms->callback->fn(ctdb, -ECANCELED, ms->callback->private_data);
 758                         talloc_free(ms->callback);
 759                 }
 760
 761                 /* Discard script status so we don't save to last_status */
 762                 talloc_free(ctdb->current_monitor->scripts);
 763                 ctdb->current_monitor->scripts = NULL;
 764                 talloc_free(ctdb->current_monitor);
 765                 ctdb->current_monitor = NULL;
 766         }
 767
 768         state = talloc(ctdb->event_script_ctx, struct ctdb_event_script_state);
 769         CTDB_NO_MEMORY(ctdb, state);
 770
 771         /* The callback isn't done if the context is freed. */
 772         state->callback = talloc(mem_ctx, struct event_script_callback);
 773         CTDB_NO_MEMORY(ctdb, state->callback);
 774         DLIST_ADD(ctdb->script_callbacks, state->callback);
 775         talloc_set_destructor(state->callback, remove_callback);
 776         state->callback->ctdb         = ctdb;
 777         state->callback->fn           = callback;
 778         state->callback->private_data = private_data;
 779
 780         state->ctdb = ctdb;
 781         state->call = call;
 782         state->options = talloc_vasprintf(state, fmt, ap);
 783         state->timeout = timeval_set(ctdb->tunable.script_timeout, 0);
 784         state->scripts = NULL;
 785         if (state->options == NULL) {
 786                 DEBUG(DEBUG_ERR, (__location__ " could not allocate state->options\n"));
 787                 talloc_free(state);
 788                 return -1;
 789         }
 790         if (!check_options(state->call, state->options)) {
 791                 DEBUG(DEBUG_ERR, ("Bad eventscript options '%s' for '%s'\n",
 792                                   state->options,
 793                                   ctdb_eventscript_call_names[state->call]));
 794                 talloc_free(state);
 795                 return -1;
 796         }
 797
 798         DEBUG(DEBUG_INFO,(__location__ " Starting eventscript %s %s\n",
 799                           ctdb_eventscript_call_names[state->call],
 800                           state->options));
 801
 802         /* This is not a child of state, since we save it in destructor. */
 803         state->scripts = ctdb_get_script_list(ctdb, ctdb);
 804         if (state->scripts == NULL) {
 805                 talloc_free(state);
 806                 return -1;
 807         }
 808         state->current = 0;
 809         state->child = 0;
 810
 811         if (call == CTDB_EVENT_MONITOR) {
 812                 ctdb->current_monitor = state;
 813         }
 814
 815         talloc_set_destructor(state, event_script_destructor);
 816
 817         ctdb->active_events++;
 818
 819         /* Nothing to do? */
 820         if (state->scripts->num_scripts == 0) {
 821                 callback(ctdb, 0, private_data);
 822                 talloc_free(state);
 823                 return 0;
 824         }
 825
 826         state->scripts->scripts[0].status = fork_child_for_script(ctdb, state);
 827         if (state->scripts->scripts[0].status != 0) {
 828                 /* Callback is called from destructor, with fail result. */
 829                 talloc_free(state);
 830                 return 0;
 831         }
 832
 833         if (!timeval_is_zero(&state->timeout)) {
 834                 tevent_add_timer(ctdb->ev, state,
 835                                  timeval_current_ofs(state->timeout.tv_sec,
 836                                                      state->timeout.tv_usec),
 837                                  ctdb_event_script_timeout, state);
 838         } else {
 839                 DEBUG(DEBUG_ERR, (__location__ " eventscript %s %s called with no timeout\n",
 840                                   ctdb_eventscript_call_names[state->call],
 841                                   state->options));
 842         }
 843
 844         return 0;
 845 }
 846
 847
 848 /*
 849   run the event script in the background, calling the callback when
 850   finished.  If mem_ctx is freed, callback will never be called.
 851  */
 852 int ctdb_event_script_callback(struct ctdb_context *ctdb,
 853                                TALLOC_CTX *mem_ctx,
 854                                void (*callback)(struct ctdb_context *, int, void *),
 855                                void *private_data,
 856                                enum ctdb_event call,
 857                                const char *fmt, ...)
 858 {
 859         va_list ap;
 860         int ret;
 861
 862         va_start(ap, fmt);
 863         ret = ctdb_event_script_callback_v(ctdb, mem_ctx, callback, private_data, call, fmt, ap);
 864         va_end(ap);
 865
 866         return ret;
 867 }
 868
 869
 870 struct callback_status {
 871         bool done;
 872         int status;
 873 };
 874
 875 /*
 876   called when ctdb_event_script() finishes
 877  */
 878 static void event_script_callback(struct ctdb_context *ctdb, int status, void *private_data)
 879 {
 880         struct callback_status *s = (struct callback_status *)private_data;
 881         s->done = true;
 882         s->status = status;
 883 }
 884
 885 /*
 886   run the event script, waiting for it to complete. Used when the caller
 887   doesn't want to continue till the event script has finished.
 888  */
 889 int ctdb_event_script_args(struct ctdb_context *ctdb, enum ctdb_event call,
 890                            const char *fmt, ...)
 891 {
 892         va_list ap;
 893         int ret;
 894         struct callback_status status = {
 895                 .status = -1,
 896                 .done = false,
 897         };
 898
 899         va_start(ap, fmt);
 900         ret = ctdb_event_script_callback_v(ctdb, ctdb,
 901                         event_script_callback, &status, call, fmt, ap);
 902         va_end(ap);
 903         if (ret != 0) {
 904                 return ret;
 905         }
 906
 907         while (status.done == false && tevent_loop_once(ctdb->ev) == 0) /* noop */;
 908
 909         if (status.status == -ETIME) {
 910                 DEBUG(DEBUG_ERR, (__location__ " eventscript for '%s' timedout."
 911                                   " Immediately banning ourself for %d seconds\n",
 912                                   ctdb_eventscript_call_names[call],
 913                                   ctdb->tunable.recovery_ban_period));
 914
 915                 /* Don't ban self if CTDB is starting up or shutting down */
 916                 if (call != CTDB_EVENT_INIT && call != CTDB_EVENT_SHUTDOWN) {
 917                         ctdb_ban_self(ctdb);
 918                 }
 919         }
 920
 921         return status.status;
 922 }
 923
 924 int ctdb_event_script(struct ctdb_context *ctdb, enum ctdb_event call)
 925 {
 926         /* GCC complains about empty format string, so use %s and "". */
 927         return ctdb_event_script_args(ctdb, call, "%s", "");
 928 }
 929
 930 struct eventscript_callback_state {
 931         struct ctdb_req_control_old *c;
 932 };
 933
 934 /*
 935   called when a forced eventscript run has finished
 936  */
 937 static void run_eventscripts_callback(struct ctdb_context *ctdb, int status,
 938                                  void *private_data)
 939 {
 940         const char *errmsg = NULL;
 941
 942         struct eventscript_callback_state *state =
 943                 talloc_get_type(private_data, struct eventscript_callback_state);
 944
 945         if (status != 0) {
 946                 if (status == -ECANCELED) {
 947                         DEBUG(DEBUG_WARNING,
 948                               (__location__ " Eventscript cancelled\n"));
 949                         errmsg = "cancelled";
 950                 } else {
 951                         DEBUG(DEBUG_ERR,
 952                               (__location__ " Failed to run eventscripts\n"));
 953                 }
 954         }
 955
 956         ctdb_request_control_reply(ctdb, state->c, NULL, status, errmsg);
 957         /* This will free the struct ctdb_event_script_state we are in! */
 958         talloc_free(state);
 959         return;
 960 }
 961
 962
 963 /* Returns rest of string, or NULL if no match. */
 964 static const char *get_call(const char *p, enum ctdb_event *call)
 965 {
 966         unsigned int len;
 967
 968         /* Skip any initial whitespace. */
 969         p += strspn(p, " \t");
 970
 971         /* See if we match any. */
 972         for (*call = 0; *call < CTDB_EVENT_MAX; (*call)++) {
 973                 len = strlen(ctdb_eventscript_call_names[*call]);
 974                 if (strncmp(p, ctdb_eventscript_call_names[*call], len) == 0) {
 975                         /* If end of string or whitespace, we're done. */
 976                         if (strcspn(p + len, " \t") == 0) {
 977                                 return p + len;
 978                         }
 979                 }
 980         }
 981         return NULL;
 982 }
 983
 984 /*
 985   A control to force running of the eventscripts from the ctdb client tool
 986 */
 987 int32_t ctdb_run_eventscripts(struct ctdb_context *ctdb,
 988                 struct ctdb_req_control_old *c,
 989                 TDB_DATA indata, bool *async_reply)
 990 {
 991         int ret;
 992         struct eventscript_callback_state *state;
 993         const char *options;
 994         enum ctdb_event call;
 995
 996         /* Figure out what call they want. */
 997         options = get_call((const char *)indata.dptr, &call);
 998         if (!options) {
 999                 DEBUG(DEBUG_ERR, (__location__ " Invalid event name \"%s\"\n", (const char *)indata.dptr));
1000                 return -1;
1001         }
1002
1003         if (ctdb->recovery_mode != CTDB_RECOVERY_NORMAL) {
1004                 DEBUG(DEBUG_ERR, (__location__ " Aborted running eventscript \"%s\" while in RECOVERY mode\n", indata.dptr));
1005                 return -1;
1006         }
1007
1008         state = talloc(ctdb->event_script_ctx, struct eventscript_callback_state);
1009         CTDB_NO_MEMORY(ctdb, state);
1010
1011         state->c = talloc_steal(state, c);
1012
1013         DEBUG(DEBUG_NOTICE,("Running eventscripts with arguments %s\n", indata.dptr));
1014
1015         ret = ctdb_event_script_callback(ctdb,
1016                          ctdb, run_eventscripts_callback, state,
1017                          call, "%s", options);
1018
1019         if (ret != 0) {
1020                 DEBUG(DEBUG_ERR,(__location__ " Failed to run eventscripts with arguments %s\n", indata.dptr));
1021                 talloc_free(state);
1022                 return -1;
1023         }
1024
1025         /* tell ctdb_control.c that we will be replying asynchronously */
1026         *async_reply = true;
1027
1028         return 0;
1029 }
1030
1031
1032
1033 int32_t ctdb_control_enable_script(struct ctdb_context *ctdb, TDB_DATA indata)
1034 {
1035         const char *script;
1036         struct stat st;
1037         char *filename;
1038         TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
1039
1040         script = (char *)indata.dptr;
1041         if (indata.dsize == 0) {
1042                 DEBUG(DEBUG_ERR,(__location__ " No script specified.\n"));
1043                 talloc_free(tmp_ctx);
1044                 return -1;
1045         }
1046         if (indata.dptr[indata.dsize - 1] != '\0') {
1047                 DEBUG(DEBUG_ERR,(__location__ " String is not null terminated.\n"));
1048                 talloc_free(tmp_ctx);
1049                 return -1;
1050         }
1051         if (index(script,'/') != NULL) {
1052                 DEBUG(DEBUG_ERR,(__location__ " Script name contains '/'. Failed to enable script %s\n", script));
1053                 talloc_free(tmp_ctx);
1054                 return -1;
1055         }
1056
1057
1058         if (stat(ctdb->event_script_dir, &st) != 0 &&
1059             errno == ENOENT) {
1060                 DEBUG(DEBUG_CRIT,("No event script directory found at '%s'\n", ctdb->event_script_dir));
1061                 talloc_free(tmp_ctx);
1062                 return -1;
1063         }
1064
1065
1066         filename = talloc_asprintf(tmp_ctx, "%s/%s", ctdb->event_script_dir, script);
1067         if (filename == NULL) {
1068                 DEBUG(DEBUG_ERR,(__location__ " Failed to create script path\n"));
1069                 talloc_free(tmp_ctx);
1070                 return -1;
1071         }
1072
1073         if (stat(filename, &st) != 0) {
1074                 DEBUG(DEBUG_ERR,("Could not stat event script %s. Failed to enable script.\n", filename));
1075                 talloc_free(tmp_ctx);
1076                 return -1;
1077         }
1078
1079         if (chmod(filename, st.st_mode | S_IXUSR) == -1) {
1080                 DEBUG(DEBUG_ERR,("Could not chmod %s. Failed to enable script.\n", filename));
1081                 talloc_free(tmp_ctx);
1082                 return -1;
1083         }
1084
1085         talloc_free(tmp_ctx);
1086         return 0;
1087 }
1088
1089 int32_t ctdb_control_disable_script(struct ctdb_context *ctdb, TDB_DATA indata)
1090 {
1091         const char *script;
1092         struct stat st;
1093         char *filename;
1094         TALLOC_CTX *tmp_ctx = talloc_new(ctdb);
1095
1096         script = (char *)indata.dptr;
1097         if (indata.dsize == 0) {
1098                 DEBUG(DEBUG_ERR,(__location__ " No script specified.\n"));
1099                 talloc_free(tmp_ctx);
1100                 return -1;
1101         }
1102         if (indata.dptr[indata.dsize - 1] != '\0') {
1103                 DEBUG(DEBUG_ERR,(__location__ " String is not null terminated.\n"));
1104                 talloc_free(tmp_ctx);
1105                 return -1;
1106         }
1107         if (index(script,'/') != NULL) {
1108                 DEBUG(DEBUG_ERR,(__location__ " Script name contains '/'. Failed to disable script %s\n", script));
1109                 talloc_free(tmp_ctx);
1110                 return -1;
1111         }
1112
1113
1114         if (stat(ctdb->event_script_dir, &st) != 0 &&
1115             errno == ENOENT) {
1116                 DEBUG(DEBUG_CRIT,("No event script directory found at '%s'\n", ctdb->event_script_dir));
1117                 talloc_free(tmp_ctx);
1118                 return -1;
1119         }
1120
1121
1122         filename = talloc_asprintf(tmp_ctx, "%s/%s", ctdb->event_script_dir, script);
1123         if (filename == NULL) {
1124                 DEBUG(DEBUG_ERR,(__location__ " Failed to create script path\n"));
1125                 talloc_free(tmp_ctx);
1126                 return -1;
1127         }
1128
1129         if (stat(filename, &st) != 0) {
1130                 DEBUG(DEBUG_ERR,("Could not stat event script %s. Failed to disable script.\n", filename));
1131                 talloc_free(tmp_ctx);
1132                 return -1;
1133         }
1134
1135         if (chmod(filename, st.st_mode & ~(S_IXUSR|S_IXGRP|S_IXOTH)) == -1) {
1136                 DEBUG(DEBUG_ERR,("Could not chmod %s. Failed to disable script.\n", filename));
1137                 talloc_free(tmp_ctx);
1138                 return -1;
1139         }
1140
1141         talloc_free(tmp_ctx);
1142         return 0;
1143 }