src/ui.c

   1 /*
   2     Copyright (C) 2001-2011 Ben Kibbey <bjk@luxsci.net>
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02110-1301  USA
  17 */
  18 #ifdef HAVE_CONFIG_H
  19 #include <config.h>
  20 #endif
  21
  22 #include <stdio.h>
  23 #include <unistd.h>
  24 #include <stdlib.h>
  25 #include <sys/types.h>
  26 #include <sys/stat.h>
  27 #include <errno.h>
  28 #include <ctype.h>
  29 #include <pwd.h>
  30 #include <time.h>
  31
  32 #ifdef HAVE_GETOPT_H
  33 #include <getopt.h>
  34 #endif
  35
  36 #ifndef HAVE_ERR_H
  37 #include "err.c"
  38 #endif
  39
  40 #include "safe_strncat.c"
  41 #include "ui.h"
  42
  43 static void *Realloc(void *p, size_t size)
  44 {
  45     void *p2;
  46
  47     if ((p2 = realloc(p, size)) == NULL)
  48         err(EXIT_FAILURE, "%s", "realloc()");
  49
  50     return p2;
  51 }
  52
  53 /* This may be used in modules to keep a consistant time format with other
  54  * modules. */
  55 char *stamp(time_t epoch, const char *format)
  56 {
  57     static char buf[TIMEBUFSIZE];
  58     struct tm *t;
  59
  60     t = localtime(&epoch);
  61     strftime(buf, sizeof(buf), format, t);
  62     return buf;
  63 }
  64
  65 /*
  66  * This may be used in modules to add a string to the buffer (ui_module_exec()).
  67  */
  68 void add_string(char ***buf, const char *str)
  69 {
  70     char **s;
  71     int i = 0;
  72
  73     if (*buf) {
  74         for (s = *buf; *s; s++)
  75             i++;
  76     }
  77
  78     s = *buf;
  79     s = Realloc(s, (i + 2) * sizeof(char *));
  80     s[i++] = strdup(str);
  81     s[i] = NULL;
  82     *buf = s;
  83 }
  84
  85 /* This is for the field separators (-F and -m). */
  86 static int escapes(const char *str)
  87 {
  88     int c = 0;
  89
  90     if (str[0] != '\\')
  91         return str[0];
  92
  93     switch (*++str) {
  94         case 't':
  95             c = '\t';
  96             break;
  97         case 'n':
  98             c = '\n';
  99             break;
 100         case '\\':
 101             c = '\\';
 102             break;
 103         case 'v':
 104             c = '\v';
 105             break;
 106         case 'b':
 107             c = '\b';
 108             break;
 109         case 'f':
 110             c = '\f';
 111             break;
 112         case 'r':
 113             c = '\r';
 114             break;
 115         case '\'':
 116             c = '\'';
 117             break;
 118         default:
 119             c = 0;
 120             break;
 121     }
 122
 123     return c;
 124 }
 125
 126 /* Help text. Module help text is displayed after this. */
 127 static void usage_header()
 128 {
 129     printf("Usage: %s [-vhVL] [-c <filename>] [-t fmt] [-m c] [-F c] [-d]\n"
 130            "\t[[-xX] -O <module1> [options] [-- [-xX] -O <module2> [...]]]\n"
 131            "\t[- | username | -f filename] [...]\n\n", __progname);
 132 }
 133
 134 /* Help text. Module help text is displayed before this. */
 135 static void usage()
 136 {
 137     printf("  -d\tLoad the default modules (passwd.so, mail.so, and login.so).\n");
 138     printf("  -c\tRead a configuration file. Can be used more than once.\n");
 139     printf("  -O\tLoad a module. Can be used more than once.\n");
 140     printf("  -x\tChain module1's output to module2's input.\n");
 141     printf("  -X\tDon't output module1's info, only chain it.\n");
 142     printf("  -F c\tSeparate output with the specified character "
 143            "('%c').\n", delimchar);
 144     printf("  -m c\tSeparate multi-string values with the specified "
 145            "character ('%c').\n", multichar);
 146     printf("  -t tf\tstrftime(3) time format ('%s').\n", DEFAULT_TIMEFORMAT);
 147     printf("  -f\tUsers are the owners of the specified files.\n");
 148     printf("  -L\tFollow symbolic links.\n");
 149     printf("  -v\tVerbose output when possible (twice for all modules).\n");
 150     printf("  -h\tThis help text.\n");
 151     printf("  -V\tVersion information.\n\n");
 152     printf("Output key: %s=unknown/error, %s=none, %s=yes/on, "
 153            "%s=no/off\n", UNKNOWN, NONE, ON, OFF);
 154 }
 155
 156 /*
 157  * Add a module to the array of loaded modules. The index argument is the
 158  * current item number being added stored in an integer. The module is also
 159  * initialized here with ui_module_init().
 160  */
 161 static int open_module(char *filename, int *idx)
 162 {
 163     void *m;
 164     module_init *init;
 165     char *p, s[PATH_MAX];
 166     int i;
 167     int chainable = 0;
 168
 169     strncpy(s, filename, sizeof(s));
 170
 171     if ((p = strrchr(s, '/')) != NULL)
 172         p++;
 173     else {
 174         strncpy(s, filename, sizeof(s));
 175         p = s;
 176     }
 177
 178     for (i = 0; i < module_index; i++) {
 179         if (strcmp(p, modules[i].name) == 0) {
 180             if (TEST_FLAG(modules[i].flags, MODULE_DUP))
 181                 break;
 182
 183             SET_FLAG(modules[i].flags, MODULE_DUP);
 184             warnx("%s: a module by this name is already loaded", p);
 185         }
 186     }
 187
 188     if ((m = dlopen(filename, RTLD_NOW)) == NULL) {
 189         warnx("%s", dlerror());
 190         chaining = 0;
 191         chain_output = 1;
 192         return 1;
 193     }
 194
 195     modules = Realloc(modules, (module_index + 2) * sizeof(struct module));
 196     modules[module_index].m = m;
 197
 198     strncpy(modules[module_index].name, p, sizeof(modules[module_index].name));
 199     *idx = module_index++;
 200
 201     if ((init = dlsym(modules[*idx].m, "ui_module_init")) == NULL)
 202         warnx("%s", dlerror());
 203     else
 204         (*init) (&chainable);
 205
 206     if (chainable)
 207         SET_FLAG(modules[*idx].flags, MODULE_CHAINABLE);
 208
 209     if (*idx - 1 >= 0 && TEST_FLAG(modules[*idx - 1].flags, MODULE_CHAINED) &&
 210             !TEST_FLAG(modules[*idx].flags, MODULE_CHAINABLE)) {
 211         warnx("%s: this module is not chainable", modules[*idx].name);
 212         return 1;
 213     }
 214
 215     /* Module chaining. See junction() for more info. */
 216     if (chaining)
 217         SET_FLAG(modules[*idx].flags, MODULE_CHAINED);
 218
 219     if (chain_output)
 220         SET_FLAG(modules[*idx].flags, MODULE_OUTPUT);
 221
 222     if (verbose)
 223         SET_FLAG(modules[*idx].flags, MODULE_VERBOSE);
 224
 225     chaining = 0;
 226     chain_output = 1;
 227     verbose = (verbose < 2) ? 0 : 2;
 228     return 0;
 229 }
 230
 231 /* This just free's up the array of modules. The modules should clean up after
 232  * themselves via the ui_module_exit() function. */
 233 static void cleanup_modules()
 234 {
 235     int i;
 236
 237     for (i = 0; i < module_index; i++) {
 238         module_exit *e;
 239
 240         if ((e = dlsym(modules[i].m, "ui_module_exit")) == NULL)
 241             warnx("%s", dlerror());
 242         else
 243             (*e)();
 244
 245         dlclose(modules[i].m);
 246     }
 247
 248     free(modules);
 249 }
 250
 251 static void output(char **s, const int sep, int which)
 252 {
 253     char **p = s;
 254
 255     if (p) {
 256         for (; *p; p++) {
 257             printf("%s", *p);
 258
 259             if (*(p+1))
 260                 printf("%c", sep);
 261         }
 262     }
 263
 264     printf("%c", which == OUTPUT_DONE ? '\n' : sep);
 265 }
 266
 267 /* Pass the argument to each loaded module. */
 268 static int junction(const char *arg)
 269 {
 270     int i;
 271     struct passwd *pw;
 272     struct stat st;
 273     int ret = EXIT_SUCCESS;
 274     char **s = NULL;
 275
 276     if (usefile) {
 277         if ((STAT(arg, &st)) == -1) {
 278             warn("%s", arg);
 279             return EXIT_FAILURE;
 280         }
 281
 282         errno = 0;
 283
 284         if ((pw = getpwuid(st.st_uid)) == NULL) {
 285 #ifdef __NetBSD__
 286             warnx("%s: no such user", arg);
 287 #else
 288             if (errno == 0 || errno == ENOENT || errno == EPERM
 289                 || errno == EBADF || errno == ESRCH)
 290                 warnx("%s: no such uid %u", arg, st.st_uid);
 291             else
 292                 warn("%s", "getpwuid()");
 293 #endif
 294
 295             return EXIT_FAILURE;
 296         }
 297     }
 298     else {
 299         errno = 0;
 300
 301         if ((pw = getpwnam(arg)) == NULL) {
 302 #ifdef __NetBSD__
 303             warnx("%s: no such user", arg);
 304 #else
 305             if (errno == 0 || errno == ENOENT || errno == EPERM
 306                 || errno == EBADF || errno == ESRCH)
 307                 warnx("%s: no such user", arg);
 308             else
 309                 warn("%s", "getpwnam()");
 310 #endif
 311
 312             return EXIT_FAILURE;
 313         }
 314     }
 315
 316     for (i = 0; i < module_index; i++) {
 317         module_exec *m_exec;
 318
 319         if ((m_exec = dlsym(modules[i].m, "ui_module_exec")) == NULL) {
 320             warnx("%s", dlerror());
 321             continue;
 322         }
 323
 324         ret |= (*m_exec) (&s, pw, multichar,
 325                 TEST_FLAG(modules[i].flags, MODULE_VERBOSE), tf);
 326
 327         if (!TEST_FLAG(modules[i].flags, MODULE_CHAINED) ||
 328                 (TEST_FLAG(modules[i].flags, MODULE_CHAINED) &&
 329                  TEST_FLAG(modules[i].flags, MODULE_OUTPUT))) {
 330             output(s, delimchar,
 331                     ((i + 1) < module_index) ? OUTPUT_APPEND : OUTPUT_DONE);
 332
 333             if (!TEST_FLAG(modules[i].flags, MODULE_CHAINED)) {
 334                 char **p;
 335
 336                 for (p = s; *p; p++) {
 337                     free(*p);
 338                 }
 339
 340                 free(s);
 341                 s = NULL;
 342             }
 343         }
 344     }
 345
 346     return ret;
 347 }
 348
 349 /* Copy options for each module into it's own argc and argv variables stopping
 350  * at -- (getopt(3)). */
 351 static int init_module_options(int the_argc, char **the_argv, struct module mod)
 352 {
 353     char tmp[255];
 354     module_options *m;
 355     module_options_init *o;
 356     int old_optind = optind;
 357     int argc = 0;
 358     char **argv = NULL;
 359     int opt;
 360     int ret = EXIT_SUCCESS;
 361     char *optstring = NULL;
 362     char *defaults = NULL;
 363     int have_an_argument = 0;
 364
 365     if ((o = dlsym(mod.m, "ui_module_options_init")) == NULL) {
 366         warnx("%s", dlerror());
 367         return EXIT_FAILURE;
 368     }
 369
 370     if ((optstring = (*o) (&defaults))) {
 371         argv = Realloc(argv, (argc + 2) * sizeof(char *));
 372         argv[argc++] = strdup(__progname);
 373         argv[argc] = NULL;
 374
 375         /* Probably a default module. */
 376         if (the_argv == NULL)
 377             goto blah;
 378
 379         while ((opt = getopt(the_argc, the_argv, optstring)) != -1) {
 380             switch (opt) {
 381                 case '?':
 382                     warnx("%s: invalid option -- %c\n", mod.name,
 383                           optopt);
 384                     return EXIT_FAILURE;
 385                 default:
 386                     break;
 387             }
 388
 389             argv = Realloc(argv, (argc + 2) * sizeof(char *));
 390             snprintf(tmp, sizeof(tmp), "-%c%s", opt, (optarg) ? optarg : "");
 391             argv[argc++] = strdup(tmp);
 392             argv[argc] = NULL;
 393             have_an_argument = 1;
 394         }
 395     }
 396     else
 397         goto skip_option_stuff;
 398
 399 blah:
 400     /*
 401      * No options were specified for this module. Set the modules default
 402      * options (ui_module_options_init()) if any.
 403      */
 404     if (!have_an_argument && defaults) {
 405         argv = Realloc(argv, (argc + 2) * sizeof(char *));
 406         snprintf(tmp, sizeof(tmp), "-%s", defaults);
 407         argv[argc++] = strdup(tmp);
 408         argv[argc] = NULL;
 409     }
 410
 411     old_optind = optind;
 412     opterr = optind = optopt = 1;
 413
 414     if ((m = dlsym(mod.m, "ui_module_options")) == NULL) {
 415         warnx("%s", dlerror());
 416         return EXIT_FAILURE;
 417     }
 418
 419     ret |= (*m) (argc, argv);
 420     optind = old_optind;
 421
 422 skip_option_stuff:
 423     return ret;
 424 }
 425
 426 /*
 427  * parseargs.c
 428  *
 429  * This will parse a line used as an argument list for the exec() line of
 430  * functions returning a dynamically allocated array of character pointers so
 431  * you should free() it afterwards. Both ' and " quoting is supported (with
 432  * escapes) for multi-word arguments.
 433  *
 434  * This is my second attempt at it. Works alot better than the first. :)
 435  *
 436  * 2002/10/05
 437  * Ben Kibbey <bjk@luxsci.net>
 438  *
 439  * 2004/11/07
 440  *     Modified to handle argv[0] and argc. (Ben Kibbey <bjk@luxsci.net>)
 441  */
 442 static char **parseargv(char *str, const char *progname, int *me_argc)
 443 {
 444     char **pptr, *s;
 445     char arg[255];
 446     int idx = 0;
 447     int quote = 0;
 448     int lastchar = 0;
 449     int i;
 450     int my_argc = 0;
 451
 452     if (!str)
 453         return NULL;
 454
 455     if (!(pptr = malloc(sizeof(char *))))
 456         return NULL;
 457
 458     pptr = Realloc(pptr, (idx + 2) * sizeof(char *));
 459     pptr[idx++] = strdup(progname);
 460     my_argc++;
 461
 462     for (i = 0, s = str; *s; lastchar = *s++) {
 463         if ((*s == '\"' || *s == '\'') && lastchar != '\\') {
 464             quote = (quote) ? 0 : 1;
 465             continue;
 466         }
 467
 468         if (*s == ' ' && !quote) {
 469             arg[i] = 0;
 470             pptr = Realloc(pptr, (idx + 2) * sizeof(char *));
 471             pptr[idx++] = strdup(arg);
 472             my_argc++;
 473             arg[0] = i = 0;
 474             continue;
 475         }
 476
 477         if ((i + 1) == sizeof(arg))
 478             continue;
 479
 480         arg[i++] = *s;
 481     }
 482
 483     arg[i] = 0;
 484
 485     if (arg[0]) {
 486         pptr = Realloc(pptr, (idx + 2) * sizeof(char *));
 487         pptr[idx++] = strdup(arg);
 488         my_argc++;
 489     }
 490
 491     pptr[idx] = NULL;
 492     *me_argc = my_argc;
 493     return pptr;
 494 }
 495
 496 static char *get_home_directory()
 497 {
 498     struct passwd *pw;
 499     static char dir[PATH_MAX];
 500
 501     errno = 0;
 502
 503     if ((pw = getpwuid(getuid())) == NULL) {
 504         if (errno)
 505             warn("getpwuid()");
 506         else
 507             warnx("getpwuid(): no such uid");
 508
 509         return NULL;
 510     }
 511
 512     strncpy(dir, pw->pw_dir, sizeof(dir));
 513     return dir;
 514 }
 515
 516 /* Read in a configuration file adding modules to the module array and
 517  * checking any module options. */
 518 static int parse_rc_file(const char *filename)
 519 {
 520     char line[LINE_MAX], *p;
 521     FILE *fp;
 522     int idx;
 523     int old_optind = optind;
 524
 525     if ((fp = fopen(filename, "r")) == NULL) {
 526         warn("%s", filename);
 527         return 1;
 528     }
 529
 530     while ((p = fgets(line, sizeof(line), fp)) != NULL) {
 531         char name[PATH_MAX], options[LINE_MAX], tmp[PATH_MAX], *s;
 532         int my_argc;
 533         char **my_argv;
 534         int lastchar = '\0';
 535
 536         while (*p && isspace((unsigned char) *p))
 537             p++;
 538
 539         if (*p == '#')
 540             continue;
 541
 542         s = name;
 543
 544         if (*p == '>' || *p == '-') {
 545             chaining = 1;
 546
 547             if (*p == '-')
 548                 chain_output = 0;
 549
 550             p++;
 551         }
 552
 553         while (*p && *p != ' ' && *p != '\t') {
 554             if (*p == '\n') {
 555                 p++;
 556                 break;
 557             }
 558
 559             *s++ = *p++;
 560         }
 561
 562         *s = '\0';
 563
 564         if (!name[0])
 565             continue;
 566
 567         s = options;
 568
 569         while (*p && isspace((unsigned char) *p))
 570             p++;
 571
 572         lastchar = *p;
 573
 574         while (*p) {
 575             if (*p == '\n' || (*p == '#' && lastchar != '\\'))
 576                 break;
 577
 578             if (*p == '#' && lastchar == '\\') {
 579                 lastchar = *--s = *p++;
 580                 s++;
 581                 continue;
 582             }
 583
 584             lastchar = *s++ = *p++;
 585         }
 586
 587         *s = '\0';
 588         p = name;
 589
 590         if (*p == '~') {
 591             s = get_home_directory();
 592             strncpy(tmp, s, sizeof(tmp));
 593             p++;
 594             safe_strncat(tmp, p, sizeof(tmp));
 595             strncpy(name, tmp, sizeof(name));
 596         }
 597
 598         if (open_module(name, &idx))
 599             continue;
 600
 601         if ((my_argv = parseargv(options, __progname, &my_argc)) == NULL)
 602             continue;
 603
 604         optind = 0;
 605
 606         if (init_module_options(my_argc, my_argv, modules[idx])) {
 607             fclose(fp);
 608             return 2;
 609         }
 610
 611         optind = old_optind;
 612     }
 613
 614     fclose(fp);
 615     return 0;
 616 }
 617
 618 int main(int argc, char *argv[])
 619 {
 620     int i = 0;
 621     int ret = EXIT_SUCCESS;
 622     int opt;
 623     char line[LINE_MAX], *s = NULL;
 624     int want_help = 0;
 625
 626 #ifndef HAVE___PROGNAME
 627     __progname = argv[0];
 628 #endif
 629     delimchar = DEFAULT_DELIMINATING_CHAR;
 630     multichar = DEFAULT_MULTI_CHAR;
 631     strncpy(tf, DEFAULT_TIMEFORMAT, sizeof(tf));
 632     chain_output = 1;
 633
 634     while ((opt = getopt(argc, argv, "+x:X:dm:c:hO:F:t:vVLf")) != -1) {
 635         /*
 636          * See getopt(3).
 637          */
 638         opterr = 0;
 639
 640         switch (opt) {
 641             case 'd':
 642                 i = module_index;
 643
 644                 if (open_module("passwd.so", &i) == 0) {
 645                     if (init_module_options(1, NULL, modules[i]))
 646                         want_help = 1;
 647                 }
 648                 else {
 649                     ret = EXIT_FAILURE;
 650                     goto cleanup;
 651                 }
 652
 653                 if (open_module("mail.so", &i) == 0) {
 654                     if (init_module_options(1, NULL, modules[i]))
 655                         want_help = 1;
 656                 }
 657                 else {
 658                     ret = EXIT_FAILURE;
 659                     goto cleanup;
 660                 }
 661
 662                 if (open_module("login.so", &i) == 0) {
 663                     if (init_module_options(1, NULL, modules[i]))
 664                         want_help = 1;
 665                 }
 666                 else {
 667                     ret = EXIT_FAILURE;
 668                     goto cleanup;
 669                 }
 670
 671                 break;
 672             case 'm':
 673                 if ((optarg[0] != '\\' && strlen(optarg) > 1) ||
 674                     (optarg[0] == '\\' && strlen(optarg) != 2)) {
 675                     want_help = 1;
 676                     break;
 677                 }
 678
 679                 if ((multichar = escapes(optarg)) == 0)
 680                     want_help = 1;
 681
 682                 break;
 683             case 'c':
 684                 if ((ret = parse_rc_file(optarg)) != 0) {
 685                     if (ret == 2)
 686                         want_help = 1;
 687                     else
 688                         exit(EXIT_FAILURE);
 689                 }
 690                 break;
 691             case 'F':
 692                 if ((optarg[0] != '\\' && strlen(optarg) > 1) ||
 693                     (optarg[0] == '\\' && strlen(optarg) != 2)) {
 694                     want_help = 1;
 695                     break;
 696                 }
 697
 698                 if ((delimchar = escapes(optarg)) == 0)
 699                     want_help = 1;
 700
 701                 break;
 702             case 't':
 703                 strncpy(tf, optarg, sizeof(tf));
 704                 break;
 705             case 'V':
 706                 printf("%s\n%s\n", PACKAGE_STRING, COPYRIGHT);
 707                 exit(EXIT_SUCCESS);
 708                 break;
 709             case 'L':
 710                 followsymlinks = 1;
 711                 break;
 712             case 'f':
 713                 usefile = 1;
 714                 break;
 715             case 'v':
 716                 verbose++;
 717                 break;
 718             case 'X':
 719                 chain_output = 0;
 720             case 'x':
 721                 chaining = 1;
 722             case 'O':
 723                 if (open_module(optarg, &i)) {
 724                     ret = EXIT_FAILURE;
 725                     goto cleanup;
 726                 }
 727
 728                 if (init_module_options(argc, argv, modules[i]))
 729                     want_help = 1;
 730
 731                 /*
 732                  * For modules which have no options at all (to keep getopt
 733                  * from interpreting the rest as arguments.
 734                  */
 735                 if (optind < argc) {
 736                     if (strcmp(argv[optind], "--") == 0)
 737                         optind++;
 738                 }
 739
 740                 break;
 741             case 'h':
 742             default:
 743                 want_help = 1;
 744                 break;
 745         }
 746     }
 747
 748     /* The last module cannot be chained (syntax). */
 749     if (!module_index || TEST_FLAG(modules[module_index - 1].flags, MODULE_CHAINED))
 750         want_help = 1;
 751
 752     /* Cycle through the modules and output their help text. */
 753     if (want_help) {
 754         usage_header();
 755
 756         for (i = 0; i < module_index; i++) {
 757             module_help *m_help;
 758
 759             if (TEST_FLAG(modules[i].flags, MODULE_DUP))
 760                 continue;
 761
 762             if ((m_help = dlsym(modules[i].m, "ui_module_help")) == NULL) {
 763                 warnx("%s", dlerror());
 764                 continue;
 765             }
 766
 767             fprintf(stderr, "%s\n", modules[i].name);
 768             (*m_help) ();
 769         }
 770
 771         usage();
 772         cleanup_modules();
 773         exit(EXIT_FAILURE);
 774     }
 775
 776     if (argc == optind || strcmp(argv[optind], "-") == 0) {
 777         while ((s = fgets(line, sizeof(line), stdin)) != NULL) {
 778             if (s[strlen(s) - 1] == '\n')
 779                 s[strlen(s) - 1] = '\0';
 780
 781             ret |= junction(s);
 782         }
 783     }
 784     else {
 785         for (; optind < argc; optind++)
 786             ret |= junction(argv[optind]);
 787     }
 788
 789 cleanup:
 790     cleanup_modules();
 791     exit(ret);
 792 }