usr.sbin/installer/libinstaller/commands.c

   1 /*
   2  * Copyright (c)2004 The DragonFly Project.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  *   Redistributions of source code must retain the above copyright
   9  *   notice, this list of conditions and the following disclaimer.
  10  *
  11  *   Redistributions in binary form must reproduce the above copyright
  12  *   notice, this list of conditions and the following disclaimer in
  13  *   the documentation and/or other materials provided with the
  14  *   distribution.
  15  *
  16  *   Neither the name of the DragonFly Project nor the names of its
  17  *   contributors may be used to endorse or promote products derived
  18  *   from this software without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  23  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  24  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  25  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  26  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  27  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  29  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  30  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  31  * OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 /*
  35  * commands.c
  36  * Execute a queued series of commands, updating a DFUI progress bar
  37  * as each is executed.
  38  * $Id: commands.c,v 1.27 2005/03/12 04:32:14 cpressey Exp $
  39  */
  40
  41 #include <sys/time.h>
  42 #include <sys/types.h>
  43
  44 #include <libgen.h>
  45 #include <signal.h>
  46 #include <stdarg.h>
  47 #include <stdlib.h>
  48 #include <string.h>
  49 #include <unistd.h>
  50
  51 #include "libaura/mem.h"
  52 #include "libaura/buffer.h"
  53 #include "libaura/popen.h"
  54
  55 #include "libdfui/dfui.h"
  56
  57 #define NEEDS_COMMANDS_STRUCTURE_DEFINITIONS
  58 #include "commands.h"
  59 #undef  NEEDS_COMMANDS_STRUCTURE_DEFINITIONS
  60
  61 #include "diskutil.h"
  62 #include "functions.h"
  63 #include "uiutil.h"
  64
  65 /*
  66  * Create a new queue of commands.
  67  */
  68 struct commands *
  69 commands_new(void)
  70 {
  71         struct commands *cmds;
  72
  73         AURA_MALLOC(cmds, commands);
  74
  75         cmds->head = NULL;
  76         cmds->tail = NULL;
  77
  78         return(cmds);
  79 }
  80
  81 /*
  82  * Add a new, empty command to an existing queue of commands.
  83  */
  84 static struct command *
  85 command_new(struct commands *cmds)
  86 {
  87         struct command *cmd;
  88
  89         AURA_MALLOC(cmd, command);
  90
  91         cmd->cmdline = NULL;
  92         cmd->desc = NULL;
  93         cmd->log_mode = COMMAND_LOG_VERBOSE;
  94         cmd->failure_mode = COMMAND_FAILURE_ABORT;
  95         cmd->tag = NULL;
  96         cmd->result = COMMAND_RESULT_NEVER_EXECUTED;
  97         cmd->output = NULL;
  98
  99         cmd->next = NULL;
 100         if (cmds->head == NULL)
 101                 cmds->head = cmd;
 102         else
 103                 cmds->tail->next = cmd;
 104
 105         cmd->prev = cmds->tail;
 106         cmds->tail = cmd;
 107
 108         return(cmd);
 109 }
 110
 111 /*
 112  * Add a new shell command to an existing queue of commands.
 113  * The command can be specified as a format string followed by
 114  * any number of arguments, in the style of "sprintf".
 115  */
 116 struct command *
 117 command_add(struct commands *cmds, const char *fmt, ...)
 118 {
 119         va_list args;
 120         struct command *cmd;
 121
 122         cmd = command_new(cmds);
 123
 124         va_start(args, fmt);
 125         vasprintf(&cmd->cmdline, fmt, args);
 126         va_end(args);
 127
 128         return(cmd);
 129 }
 130
 131 /*
 132  * Set the log mode of the given command.
 133  * Valid log modes are:
 134  *   COMMAND_LOG_SILENT - do not log anything at all
 135  *   COMMAND_LOG_QUIET - only log command name and exit code, not output
 136  *   COMMAND_LOG_VERBOSE - log everything
 137  */
 138 void
 139 command_set_log_mode(struct command *cmd, int log_mode)
 140 {
 141         cmd->log_mode = log_mode;
 142 }
 143
 144 /*
 145  * Set the failure mode of the given command.
 146  * Valid failure modes are:
 147  *   COMMAND_FAILURE_IGNORE - ignore failures and carry on
 148  *   COMMAND_FAILURE_WARN - issue a non-critical warning
 149  *   COMMAND_FAILURE_ABORT - halt the command chain and ask the user
 150  */
 151 void
 152 command_set_failure_mode(struct command *cmd, int failure_mode)
 153 {
 154         cmd->failure_mode = failure_mode;
 155 }
 156
 157 /*
 158  * Set the description of the given command.  If present, it will
 159  * be displayed in the progress bar instead of the command line.
 160  */
 161 void
 162 command_set_desc(struct command *cmd, const char *fmt, ...)
 163 {
 164         va_list args;
 165
 166         if (cmd->desc != NULL)
 167                 free(cmd->desc);
 168
 169         va_start(args, fmt);
 170         vasprintf(&cmd->desc, fmt, args);
 171         va_end(args);
 172 }
 173
 174 /*
 175  * Set an arbitrary tag on the command.
 176  */
 177 void
 178 command_set_tag(struct command *cmd, const char *fmt, ...)
 179 {
 180         va_list args;
 181
 182         if (cmd->tag != NULL)
 183                 free(cmd->tag);
 184
 185         va_start(args, fmt);
 186         vasprintf(&cmd->tag, fmt, args);
 187         va_end(args);
 188 }
 189
 190 struct command *
 191 command_get_first(const struct commands *cmds)
 192 {
 193         return(cmds->head);
 194 }
 195
 196 struct command *
 197 command_get_next(const struct command *cmd)
 198 {
 199         return(cmd->next);
 200 }
 201
 202 char *
 203 command_get_cmdline(const struct command *cmd)
 204 {
 205         return(cmd->cmdline);
 206 }
 207
 208 char *
 209 command_get_tag(const struct command *cmd)
 210 {
 211         return(cmd->tag);
 212 }
 213
 214 int
 215 command_get_result(const struct command *cmd)
 216 {
 217         return(cmd->result);
 218 }
 219
 220 /*
 221  * Allow the user to view the command log.
 222  */
 223 void
 224 view_command_log(struct i_fn_args *a)
 225 {
 226         struct dfui_form *f;
 227         struct dfui_response *r;
 228         struct aura_buffer *error_log;
 229
 230         error_log = aura_buffer_new(1024);
 231         aura_buffer_cat_file(error_log, "%sinstall.log", a->tmp);
 232
 233         f = dfui_form_create(
 234             "error_log",
 235             "Error Log",
 236             aura_buffer_buf(error_log),
 237             "",
 238
 239             "p",        "role", "informative",
 240             "p",        "minimum_width", "72",
 241             "p",        "monospaced", "true",
 242
 243             "a",        "ok", "OK", "", "",
 244             NULL);
 245
 246         if (!dfui_be_present(a->c, f, &r))
 247                 abort_backend();
 248
 249         dfui_form_free(f);
 250         dfui_response_free(r);
 251
 252         aura_buffer_free(error_log);
 253 }
 254
 255 /*
 256  * Preview a set of commands.
 257  */
 258 void
 259 commands_preview(struct dfui_connection *c, const struct commands *cmds)
 260 {
 261         struct command *cmd;
 262         struct aura_buffer *preview;
 263
 264         preview = aura_buffer_new(1024);
 265
 266         for (cmd = cmds->head; cmd != NULL; cmd = cmd->next) {
 267                 aura_buffer_cat(preview, cmd->cmdline);
 268                 aura_buffer_cat(preview, "\n");
 269         }
 270
 271         inform(c, "%s", aura_buffer_buf(preview));
 272
 273         aura_buffer_free(preview);
 274 }
 275
 276 /*
 277  * The command chain executing engine proper follows.
 278  */
 279
 280 /*
 281  * Read from the pipe that was opened to the executing commands
 282  * and update the progress bar as data comes and (and/or as the
 283  * read from the pipe times out.)
 284  */
 285 static int
 286 pipe_loop(struct i_fn_args *a, struct dfui_progress *pr,
 287           struct command *cmd, int *cancelled)
 288 {
 289         FILE *cmdout = NULL;
 290         struct timeval tv = { 1, 0 };
 291         char cline[256];
 292         char *command;
 293         pid_t pid;
 294         fd_set r;
 295         int n;
 296
 297         asprintf(&command, "(%s) 2>&1 </dev/null", cmd->cmdline);
 298         fflush(stdout);
 299         cmdout = aura_popen("%s", command, "r");
 300         free(command);
 301
 302         if (cmdout == NULL) {
 303                 i_log(a, "! could not aura_popen() command");
 304                 return(COMMAND_RESULT_POPEN_ERR);
 305         }
 306         pid = aura_pgetpid(cmdout);
 307 #ifdef DEBUG
 308         fprintf(stderr, "+ pid = %d\n", pid);
 309 #endif
 310
 311         /*
 312          * Loop, selecting on the command and a timeout.
 313          */
 314         for (;;) {
 315                 if (*cancelled)
 316                         break;
 317                 FD_ZERO(&r);
 318                 FD_SET(fileno(cmdout), &r);
 319                 n = select(fileno(cmdout) + 1, &r, NULL, NULL, &tv);
 320 #ifdef DEBUG
 321                 fprintf(stderr, "+ select() = %d\n", n);
 322 #endif
 323                 if (n < 0) {
 324                         /* Error */
 325                         i_log(a, "! select() failed\n");
 326                         aura_pclose(cmdout);
 327                         return(COMMAND_RESULT_SELECT_ERR);
 328                 } else if (n == 0) {
 329                         /* Timeout */
 330                         if (!dfui_be_progress_update(a->c, pr, cancelled))
 331                                 abort_backend();
 332 #ifdef DEBUG
 333                         fprintf(stderr, "+ cancelled = %d\n", *cancelled);
 334 #endif
 335                 } else {
 336                         /* Data came in */
 337                         fgets(cline, 255, cmdout);
 338                         while (strlen(cline) > 0 && cline[strlen(cline) - 1] == '\n')
 339                                 cline[strlen(cline) - 1] = '\0';
 340                         if (feof(cmdout))
 341                                 break;
 342                         if (!dfui_be_progress_update(a->c, pr, cancelled))
 343                                 abort_backend();
 344                         if (cmd->log_mode == COMMAND_LOG_VERBOSE) {
 345                                 i_log(a, "| %s", cline);
 346                         } else if (cmd->log_mode != COMMAND_LOG_SILENT) {
 347                                 fprintf(stderr, "| %s\n", cline);
 348                         }
 349                 }
 350         }
 351
 352         if (*cancelled) {
 353 #ifdef DEBUG
 354                 fprintf(stderr, "+ killing %d\n", pid);
 355 #endif
 356                 n = kill(pid, SIGTERM);
 357 #ifdef DEBUG
 358                 fprintf(stderr, "+ kill() = %d\n", n);
 359 #endif
 360         }
 361
 362 #ifdef DEBUG
 363         fprintf(stderr, "+ pclosing %d\n", fileno(cmdout));
 364 #endif
 365         n = aura_pclose(cmdout) / 256;
 366 #ifdef DEBUG
 367         fprintf(stderr, "+ pclose() = %d\n", n);
 368 #endif
 369         return(n);
 370 }
 371
 372 /*
 373  * Execute a single command.
 374  * Return value is a COMMAND_RESULT_* constant, or
 375  * a value from 0 to 255 to indicate the exit code
 376  * from the utility.
 377  */
 378 static int
 379 command_execute(struct i_fn_args *a, struct dfui_progress *pr,
 380                 struct command *cmd)
 381 {
 382         FILE *log = NULL;
 383         char *filename;
 384         int cancelled = 0, done = 0, report_done = 0;
 385
 386         if (cmd->desc != NULL)
 387                 dfui_info_set_short_desc(dfui_progress_get_info(pr), cmd->desc);
 388         else
 389                 dfui_info_set_short_desc(dfui_progress_get_info(pr), cmd->cmdline);
 390
 391         if (!dfui_be_progress_update(a->c, pr, &cancelled))
 392                   abort_backend();
 393
 394         while (!done) {
 395                 asprintf(&filename, "%sinstall.log", a->tmp);
 396                 log = fopen(filename, "a");
 397                 free(filename);
 398
 399                 if (cmd->log_mode != COMMAND_LOG_SILENT)
 400                         i_log(a, ",-<<< Executing `%s'", cmd->cmdline);
 401                 cmd->result = pipe_loop(a, pr, cmd, &cancelled);
 402                 if (cmd->log_mode != COMMAND_LOG_SILENT)
 403                         i_log(a, "`->>> Exit status: %d\n", cmd->result);
 404
 405                 if (log != NULL)
 406                         fclose(log);
 407
 408                 if (cancelled) {
 409                         if (!dfui_be_progress_end(a->c))
 410                                 abort_backend();
 411
 412                         report_done = 0;
 413                         while (!report_done) {
 414                                 switch (dfui_be_present_dialog(a->c, "Cancelled",
 415                                     "View Log|Retry|Cancel|Skip",
 416                                     "Execution of the command\n\n%s\n\n"
 417                                     "was cancelled.",
 418                                     cmd->cmdline)) {
 419                                 case 1:
 420                                         /* View Log */
 421                                         view_command_log(a);
 422                                         break;
 423                                 case 2:
 424                                         /* Retry */
 425                                         cancelled = 0;
 426                                         report_done = 1;
 427                                         break;
 428                                 case 3:
 429                                         /* Cancel */
 430                                         cmd->result = COMMAND_RESULT_CANCELLED;
 431                                         report_done = 1;
 432                                         done = 1;
 433                                         break;
 434                                 case 4:
 435                                         /* Skip */
 436                                         cmd->result = COMMAND_RESULT_SKIPPED;
 437                                         report_done = 1;
 438                                         done = 1;
 439                                         break;
 440                                 }
 441                         }
 442
 443                         if (!dfui_be_progress_begin(a->c, pr))
 444                                 abort_backend();
 445
 446                 } else if (cmd->failure_mode == COMMAND_FAILURE_IGNORE) {
 447                         cmd->result = 0;
 448                         done = 1;
 449                 } else if (cmd->result != 0 && cmd->failure_mode != COMMAND_FAILURE_WARN) {
 450                         if (!dfui_be_progress_end(a->c))
 451                                 abort_backend();
 452
 453                         report_done = 0;
 454                         while (!report_done) {
 455                                 switch (dfui_be_present_dialog(a->c, "Command Failed!",
 456                                     "View Log|Retry|Cancel|Skip",
 457                                     "Execution of the command\n\n%s\n\n"
 458                                     "FAILED with a return code of %d.",
 459                                     cmd->cmdline, cmd->result)) {
 460                                 case 1:
 461                                         /* View Log */
 462                                         view_command_log(a);
 463                                         break;
 464                                 case 2:
 465                                         /* Retry */
 466                                         report_done = 1;
 467                                         break;
 468                                 case 3:
 469                                         /* Cancel */
 470                                         /* XXX need a better way to retain actual result */
 471                                         cmd->result = COMMAND_RESULT_CANCELLED;
 472                                         report_done = 1;
 473                                         done = 1;
 474                                         break;
 475                                 case 4:
 476                                         /* Skip */
 477                                         /* XXX need a better way to retain actual result */
 478                                         cmd->result = COMMAND_RESULT_SKIPPED;
 479                                         report_done = 1;
 480                                         done = 1;
 481                                         break;
 482                                 }
 483                         }
 484
 485                         if (!dfui_be_progress_begin(a->c, pr))
 486                                 abort_backend();
 487
 488                 } else {
 489                         done = 1;
 490                 }
 491         }
 492
 493         return(cmd->result);
 494 }
 495
 496 /*
 497  * Execute a series of external utility programs.
 498  * Returns 1 if everything executed OK, 0 if one of the
 499  * critical commands failed or if the user cancelled.
 500  */
 501 int
 502 commands_execute(struct i_fn_args *a, struct commands *cmds)
 503 {
 504         struct dfui_progress *pr;
 505         struct command *cmd;
 506         int i;
 507         int n = 0;
 508         int result = 0;
 509         int return_val = 1;
 510
 511         cmd = cmds->head;
 512         while (cmd != NULL) {
 513                 n++;
 514                 cmd = cmd->next;
 515         }
 516
 517         pr = dfui_progress_new(dfui_info_new(
 518             "Executing Commands",
 519             "Executing Commands",
 520             ""),
 521             0);
 522
 523         if (!dfui_be_progress_begin(a->c, pr))
 524                 abort_backend();
 525
 526         i = 1;
 527         for (cmd = cmds->head; cmd != NULL; cmd = cmd->next, i++) {
 528                 result = command_execute(a, pr, cmd);
 529                 if (result == COMMAND_RESULT_CANCELLED) {
 530                         return_val = 0;
 531                         break;
 532                 }
 533                 if (result > 0 && result < 256) {
 534                         return_val = 0;
 535                         if (cmd->failure_mode == COMMAND_FAILURE_ABORT) {
 536                                 break;
 537                         }
 538                 }
 539                 dfui_progress_set_amount(pr, (i * 100) / n);
 540         }
 541
 542         if (!dfui_be_progress_end(a->c))
 543                 abort_backend();
 544
 545         dfui_progress_free(pr);
 546
 547         return(return_val);
 548 }
 549
 550 /*
 551  * Free the memory allocated for a queue of commands.  This invalidates
 552  * the pointer passed to it.
 553  */
 554 void
 555 commands_free(struct commands *cmds)
 556 {
 557         struct command *cmd, *next;
 558
 559         cmd = cmds->head;
 560         while (cmd != NULL) {
 561                 next = cmd->next;
 562                 if (cmd->cmdline != NULL)
 563                         free(cmd->cmdline);
 564                 if (cmd->desc != NULL)
 565                         free(cmd->desc);
 566                 if (cmd->tag != NULL)
 567                         free(cmd->tag);
 568                 AURA_FREE(cmd, command);
 569                 cmd = next;
 570         }
 571         AURA_FREE(cmds, commands);
 572 }