src/ui.c

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