git.gag.com Git - debian/sudo/blob - plugins/sudoers/defaults.c

   1 /*
   2  * Copyright (c) 1999-2005, 2007-2011
   3  *      Todd C. Miller <Todd.Miller@courtesan.com>
   4  *
   5  * Permission to use, copy, modify, and distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16  *
  17  * Sponsored in part by the Defense Advanced Research Projects
  18  * Agency (DARPA) and Air Force Research Laboratory, Air Force
  19  * Materiel Command, USAF, under agreement number F39502-99-1-0512.
  20  */
  21
  22 #include <config.h>
  23
  24 #include <sys/types.h>
  25 #include <sys/param.h>
  26 #include <stdio.h>
  27 #ifdef STDC_HEADERS
  28 # include <stdlib.h>
  29 # include <stddef.h>
  30 #else
  31 # ifdef HAVE_STDLIB_H
  32 #  include <stdlib.h>
  33 # endif
  34 #endif /* STDC_HEADERS */
  35 #ifdef HAVE_STRING_H
  36 # include <string.h>
  37 #endif /* HAVE_STRING_H */
  38 #ifdef HAVE_STRINGS_H
  39 # include <strings.h>
  40 #endif /* HAVE_STRINGS_H */
  41 # ifdef HAVE_UNISTD_H
  42 #include <unistd.h>
  43 #endif /* HAVE_UNISTD_H */
  44 #include <pwd.h>
  45 #include <ctype.h>
  46
  47 #include "sudoers.h"
  48 #include "parse.h"
  49 #include <gram.h>
  50
  51 /*
  52  * For converting between syslog numbers and strings.
  53  */
  54 struct strmap {
  55     char *name;
  56     int num;
  57 };
  58
  59 #ifdef LOG_NFACILITIES
  60 static struct strmap facilities[] = {
  61 #ifdef LOG_AUTHPRIV
  62         { "authpriv",   LOG_AUTHPRIV },
  63 #endif
  64         { "auth",       LOG_AUTH },
  65         { "daemon",     LOG_DAEMON },
  66         { "user",       LOG_USER },
  67         { "local0",     LOG_LOCAL0 },
  68         { "local1",     LOG_LOCAL1 },
  69         { "local2",     LOG_LOCAL2 },
  70         { "local3",     LOG_LOCAL3 },
  71         { "local4",     LOG_LOCAL4 },
  72         { "local5",     LOG_LOCAL5 },
  73         { "local6",     LOG_LOCAL6 },
  74         { "local7",     LOG_LOCAL7 },
  75         { NULL,         -1 }
  76 };
  77 #endif /* LOG_NFACILITIES */
  78
  79 static struct strmap priorities[] = {
  80         { "alert",      LOG_ALERT },
  81         { "crit",       LOG_CRIT },
  82         { "debug",      LOG_DEBUG },
  83         { "emerg",      LOG_EMERG },
  84         { "err",        LOG_ERR },
  85         { "info",       LOG_INFO },
  86         { "notice",     LOG_NOTICE },
  87         { "warning",    LOG_WARNING },
  88         { NULL,         -1 }
  89 };
  90
  91 /*
  92  * Local prototypes.
  93  */
  94 static int store_int(char *, struct sudo_defs_types *, int);
  95 static int store_list(char *, struct sudo_defs_types *, int);
  96 static int store_mode(char *, struct sudo_defs_types *, int);
  97 static int store_str(char *, struct sudo_defs_types *, int);
  98 static int store_syslogfac(char *, struct sudo_defs_types *, int);
  99 static int store_syslogpri(char *, struct sudo_defs_types *, int);
 100 static int store_tuple(char *, struct sudo_defs_types *, int);
 101 static int store_uint(char *, struct sudo_defs_types *, int);
 102 static int store_float(char *, struct sudo_defs_types *, int);
 103 static void list_op(char *, size_t, struct sudo_defs_types *, enum list_ops);
 104 static const char *logfac2str(int);
 105 static const char *logpri2str(int);
 106
 107 /*
 108  * Table describing compile-time and run-time options.
 109  */
 110 #include <def_data.c>
 111
 112 /*
 113  * Print version and configure info.
 114  */
 115 void
 116 dump_defaults(void)
 117 {
 118     struct sudo_defs_types *cur;
 119     struct list_member *item;
 120     struct def_values *def;
 121
 122     for (cur = sudo_defs_table; cur->name; cur++) {
 123         if (cur->desc) {
 124             switch (cur->type & T_MASK) {
 125                 case T_FLAG:
 126                     if (cur->sd_un.flag)
 127                         sudo_printf(SUDO_CONV_INFO_MSG, "%s\n", cur->desc);
 128                     break;
 129                 case T_STR:
 130                     if (cur->sd_un.str) {
 131                         sudo_printf(SUDO_CONV_INFO_MSG,
 132                             cur->desc, cur->sd_un.str);
 133                         sudo_printf(SUDO_CONV_INFO_MSG, "\n");
 134                     }
 135                     break;
 136                 case T_LOGFAC:
 137                     if (cur->sd_un.ival) {
 138                         sudo_printf(SUDO_CONV_INFO_MSG,
 139                             cur->desc, logfac2str(cur->sd_un.ival));
 140                         sudo_printf(SUDO_CONV_INFO_MSG, "\n");
 141                     }
 142                     break;
 143                 case T_LOGPRI:
 144                     if (cur->sd_un.ival) {
 145                         sudo_printf(SUDO_CONV_INFO_MSG,
 146                             cur->desc, logpri2str(cur->sd_un.ival));
 147                         sudo_printf(SUDO_CONV_INFO_MSG, "\n");
 148                     }
 149                     break;
 150                 case T_UINT:
 151                 case T_INT:
 152                     sudo_printf(SUDO_CONV_INFO_MSG, cur->desc, cur->sd_un.ival);
 153                     sudo_printf(SUDO_CONV_INFO_MSG, "\n");
 154                     break;
 155                 case T_FLOAT:
 156                     sudo_printf(SUDO_CONV_INFO_MSG, cur->desc, cur->sd_un.fval);
 157                     sudo_printf(SUDO_CONV_INFO_MSG, "\n");
 158                     break;
 159                 case T_MODE:
 160                     sudo_printf(SUDO_CONV_INFO_MSG, cur->desc, cur->sd_un.mode);
 161                     sudo_printf(SUDO_CONV_INFO_MSG, "\n");
 162                     break;
 163                 case T_LIST:
 164                     if (cur->sd_un.list) {
 165                         sudo_printf(SUDO_CONV_INFO_MSG, "%s\n", cur->desc);
 166                         for (item = cur->sd_un.list; item; item = item->next) {
 167                             sudo_printf(SUDO_CONV_INFO_MSG,
 168                                 "\t%s\n", item->value);
 169                         }
 170                     }
 171                     break;
 172                 case T_TUPLE:
 173                     for (def = cur->values; def->sval; def++) {
 174                         if (cur->sd_un.ival == def->ival) {
 175                             sudo_printf(SUDO_CONV_INFO_MSG,
 176                                 cur->desc, def->sval);
 177                             break;
 178                         }
 179                     }
 180                     sudo_printf(SUDO_CONV_INFO_MSG, "\n");
 181                     break;
 182             }
 183         }
 184     }
 185 }
 186
 187 /*
 188  * List each option along with its description.
 189  */
 190 void
 191 list_options(void)
 192 {
 193     struct sudo_defs_types *cur;
 194     char *p;
 195
 196     sudo_printf(SUDO_CONV_INFO_MSG,
 197         "Available options in a sudoers ``Defaults'' line:\n\n");
 198     for (cur = sudo_defs_table; cur->name; cur++) {
 199         if (cur->name && cur->desc) {
 200             switch (cur->type & T_MASK) {
 201                 case T_FLAG:
 202                     sudo_printf(SUDO_CONV_INFO_MSG,
 203                         "%s: %s\n", cur->name, cur->desc);
 204                     break;
 205                 default:
 206                     p = strrchr(cur->desc, ':');
 207                     if (p) {
 208                         sudo_printf(SUDO_CONV_INFO_MSG, "%s: %.*s\n",
 209                             cur->name, (int) (p - cur->desc), cur->desc);
 210                     } else {
 211                         sudo_printf(SUDO_CONV_INFO_MSG,
 212                             "%s: %s\n", cur->name, cur->desc);
 213                     }
 214                     break;
 215             }
 216         }
 217     }
 218 }
 219
 220 /*
 221  * Sets/clears an entry in the defaults structure
 222  * If a variable that takes a value is used in a boolean
 223  * context with op == 0, disable that variable.
 224  * Eg. you may want to turn off logging to a file for some hosts.
 225  * This is only meaningful for variables that are *optional*.
 226  */
 227 int
 228 set_default(char *var, char *val, int op)
 229 {
 230     struct sudo_defs_types *cur;
 231     int num;
 232
 233     for (cur = sudo_defs_table, num = 0; cur->name; cur++, num++) {
 234         if (strcmp(var, cur->name) == 0)
 235             break;
 236     }
 237     if (!cur->name) {
 238         warningx("unknown defaults entry `%s'", var);
 239         return FALSE;
 240     }
 241
 242     switch (cur->type & T_MASK) {
 243         case T_LOGFAC:
 244             if (!store_syslogfac(val, cur, op)) {
 245                 if (val)
 246                     warningx("value `%s' is invalid for option `%s'", val, var);
 247                 else
 248                     warningx("no value specified for `%s'", var);
 249                 return FALSE;
 250             }
 251             break;
 252         case T_LOGPRI:
 253             if (!store_syslogpri(val, cur, op)) {
 254                 if (val)
 255                     warningx("value `%s' is invalid for option `%s'", val, var);
 256                 else
 257                     warningx("no value specified for `%s'", var);
 258                 return FALSE;
 259             }
 260             break;
 261         case T_STR:
 262             if (!val) {
 263                 /* Check for bogus boolean usage or lack of a value. */
 264                 if (!ISSET(cur->type, T_BOOL) || op != FALSE) {
 265                     warningx("no value specified for `%s'", var);
 266                     return FALSE;
 267                 }
 268             }
 269             if (ISSET(cur->type, T_PATH) && val && *val != '/') {
 270                 warningx("values for `%s' must start with a '/'", var);
 271                 return FALSE;
 272             }
 273             if (!store_str(val, cur, op)) {
 274                 warningx("value `%s' is invalid for option `%s'", val, var);
 275                 return FALSE;
 276             }
 277             break;
 278         case T_INT:
 279             if (!val) {
 280                 /* Check for bogus boolean usage or lack of a value. */
 281                 if (!ISSET(cur->type, T_BOOL) || op != FALSE) {
 282                     warningx("no value specified for `%s'", var);
 283                     return FALSE;
 284                 }
 285             }
 286             if (!store_int(val, cur, op)) {
 287                 warningx("value `%s' is invalid for option `%s'", val, var);
 288                 return FALSE;
 289             }
 290             break;
 291         case T_UINT:
 292             if (!val) {
 293                 /* Check for bogus boolean usage or lack of a value. */
 294                 if (!ISSET(cur->type, T_BOOL) || op != FALSE) {
 295                     warningx("no value specified for `%s'", var);
 296                     return FALSE;
 297                 }
 298             }
 299             if (!store_uint(val, cur, op)) {
 300                 warningx("value `%s' is invalid for option `%s'", val, var);
 301                 return FALSE;
 302             }
 303             break;
 304         case T_FLOAT:
 305             if (!val) {
 306                 /* Check for bogus boolean usage or lack of a value. */
 307                 if (!ISSET(cur->type, T_BOOL) || op != FALSE) {
 308                     warningx("no value specified for `%s'", var);
 309                     return FALSE;
 310                 }
 311             }
 312             if (!store_float(val, cur, op)) {
 313                 warningx("value `%s' is invalid for option `%s'", val, var);
 314                 return FALSE;
 315             }
 316             break;
 317         case T_MODE:
 318             if (!val) {
 319                 /* Check for bogus boolean usage or lack of a value. */
 320                 if (!ISSET(cur->type, T_BOOL) || op != FALSE) {
 321                     warningx("no value specified for `%s'", var);
 322                     return FALSE;
 323                 }
 324             }
 325             if (!store_mode(val, cur, op)) {
 326                 warningx("value `%s' is invalid for option `%s'", val, var);
 327                 return FALSE;
 328             }
 329             break;
 330         case T_FLAG:
 331             if (val) {
 332                 warningx("option `%s' does not take a value", var);
 333                 return FALSE;
 334             }
 335             cur->sd_un.flag = op;
 336             break;
 337         case T_LIST:
 338             if (!val) {
 339                 /* Check for bogus boolean usage or lack of a value. */
 340                 if (!ISSET(cur->type, T_BOOL) || op != FALSE) {
 341                     warningx("no value specified for `%s'", var);
 342                     return FALSE;
 343                 }
 344             }
 345             if (!store_list(val, cur, op)) {
 346                 warningx("value `%s' is invalid for option `%s'", val, var);
 347                 return FALSE;
 348             }
 349             break;
 350         case T_TUPLE:
 351             if (!val && !ISSET(cur->type, T_BOOL)) {
 352                 warningx("no value specified for `%s'", var);
 353                 return FALSE;
 354             }
 355             if (!store_tuple(val, cur, op)) {
 356                 warningx("value `%s' is invalid for option `%s'", val, var);
 357                 return FALSE;
 358             }
 359             break;
 360     }
 361
 362     return TRUE;
 363 }
 364
 365 /*
 366  * Set default options to compiled-in values.
 367  * Any of these may be overridden at runtime by a "Defaults" file.
 368  */
 369 void
 370 init_defaults(void)
 371 {
 372     static int firsttime = 1;
 373     struct sudo_defs_types *def;
 374
 375     /* Clear any old settings. */
 376     if (!firsttime) {
 377         for (def = sudo_defs_table; def->name; def++) {
 378             switch (def->type & T_MASK) {
 379                 case T_STR:
 380                     efree(def->sd_un.str);
 381                     def->sd_un.str = NULL;
 382                     break;
 383                 case T_LIST:
 384                     list_op(NULL, 0, def, freeall);
 385                     break;
 386             }
 387             zero_bytes(&def->sd_un, sizeof(def->sd_un));
 388         }
 389     }
 390
 391     /* First initialize the flags. */
 392 #ifdef LONG_OTP_PROMPT
 393     def_long_otp_prompt = TRUE;
 394 #endif
 395 #ifdef IGNORE_DOT_PATH
 396     def_ignore_dot = TRUE;
 397 #endif
 398 #ifdef ALWAYS_SEND_MAIL
 399     def_mail_always = TRUE;
 400 #endif
 401 #ifdef SEND_MAIL_WHEN_NO_USER
 402     def_mail_no_user = TRUE;
 403 #endif
 404 #ifdef SEND_MAIL_WHEN_NO_HOST
 405     def_mail_no_host = TRUE;
 406 #endif
 407 #ifdef SEND_MAIL_WHEN_NOT_OK
 408     def_mail_no_perms = TRUE;
 409 #endif
 410 #ifndef NO_TTY_TICKETS
 411     def_tty_tickets = TRUE;
 412 #endif
 413 #ifndef NO_LECTURE
 414     def_lecture = once;
 415 #endif
 416 #ifndef NO_AUTHENTICATION
 417     def_authenticate = TRUE;
 418 #endif
 419 #ifndef NO_ROOT_SUDO
 420     def_root_sudo = TRUE;
 421 #endif
 422 #ifdef HOST_IN_LOG
 423     def_log_host = TRUE;
 424 #endif
 425 #ifdef SHELL_IF_NO_ARGS
 426     def_shell_noargs = TRUE;
 427 #endif
 428 #ifdef SHELL_SETS_HOME
 429     def_set_home = TRUE;
 430 #endif
 431 #ifndef DONT_LEAK_PATH_INFO
 432     def_path_info = TRUE;
 433 #endif
 434 #ifdef FQDN
 435     def_fqdn = TRUE;
 436 #endif
 437 #ifdef USE_INSULTS
 438     def_insults = TRUE;
 439 #endif
 440 #ifdef ENV_EDITOR
 441     def_env_editor = TRUE;
 442 #endif
 443 #ifdef UMASK_OVERRIDE
 444     def_umask_override = TRUE;
 445 #endif
 446     def_iolog_file = estrdup("%{seq}");
 447     def_iolog_dir = estrdup(_PATH_SUDO_IO_LOGDIR);
 448     def_sudoers_locale = estrdup("C");
 449     def_env_reset = ENV_RESET;
 450     def_set_logname = TRUE;
 451     def_closefrom = STDERR_FILENO + 1;
 452
 453     /* Syslog options need special care since they both strings and ints */
 454 #if (LOGGING & SLOG_SYSLOG)
 455     (void) store_syslogfac(LOGFAC, &sudo_defs_table[I_SYSLOG], TRUE);
 456     (void) store_syslogpri(PRI_SUCCESS, &sudo_defs_table[I_SYSLOG_GOODPRI],
 457         TRUE);
 458     (void) store_syslogpri(PRI_FAILURE, &sudo_defs_table[I_SYSLOG_BADPRI],
 459         TRUE);
 460 #endif
 461
 462     /* Password flags also have a string and integer component. */
 463     (void) store_tuple("any", &sudo_defs_table[I_LISTPW], TRUE);
 464     (void) store_tuple("all", &sudo_defs_table[I_VERIFYPW], TRUE);
 465
 466     /* Then initialize the int-like things. */
 467 #ifdef SUDO_UMASK
 468     def_umask = SUDO_UMASK;
 469 #else
 470     def_umask = 0777;
 471 #endif
 472     def_loglinelen = MAXLOGFILELEN;
 473     def_timestamp_timeout = TIMEOUT;
 474     def_passwd_timeout = PASSWORD_TIMEOUT;
 475     def_passwd_tries = TRIES_FOR_PASSWORD;
 476 #ifdef HAVE_ZLIB_H
 477     def_compress_io = TRUE;
 478 #endif
 479
 480     /* Now do the strings */
 481     def_mailto = estrdup(MAILTO);
 482     def_mailsub = estrdup(MAILSUBJECT);
 483     def_badpass_message = estrdup(INCORRECT_PASSWORD);
 484     def_timestampdir = estrdup(_PATH_SUDO_TIMEDIR);
 485     def_passprompt = estrdup(PASSPROMPT);
 486     def_runas_default = estrdup(RUNAS_DEFAULT);
 487 #ifdef _PATH_SUDO_SENDMAIL
 488     def_mailerpath = estrdup(_PATH_SUDO_SENDMAIL);
 489     def_mailerflags = estrdup("-t");
 490 #endif
 491 #if (LOGGING & SLOG_FILE)
 492     def_logfile = estrdup(_PATH_SUDO_LOGFILE);
 493 #endif
 494 #ifdef EXEMPTGROUP
 495     def_exempt_group = estrdup(EXEMPTGROUP);
 496 #endif
 497 #ifdef SECURE_PATH
 498     def_secure_path = estrdup(SECURE_PATH);
 499 #endif
 500     def_editor = estrdup(EDITOR);
 501     def_set_utmp = TRUE;
 502
 503     /* Finally do the lists (currently just environment tables). */
 504     init_envtables();
 505
 506     firsttime = 0;
 507 }
 508
 509 /*
 510  * Update the defaults based on what was set by sudoers.
 511  * Pass in an OR'd list of which default types to update.
 512  */
 513 int
 514 update_defaults(int what)
 515 {
 516     struct defaults *def;
 517     int rc = TRUE;
 518
 519     tq_foreach_fwd(&defaults, def) {
 520         switch (def->type) {
 521             case DEFAULTS:
 522                 if (ISSET(what, SETDEF_GENERIC) &&
 523                     !set_default(def->var, def->val, def->op))
 524                     rc = FALSE;
 525                 break;
 526             case DEFAULTS_USER:
 527                 if (ISSET(what, SETDEF_USER) &&
 528                     userlist_matches(sudo_user.pw, &def->binding) == ALLOW &&
 529                     !set_default(def->var, def->val, def->op))
 530                     rc = FALSE;
 531                 break;
 532             case DEFAULTS_RUNAS:
 533                 if (ISSET(what, SETDEF_RUNAS) &&
 534                     runaslist_matches(&def->binding, NULL) == ALLOW &&
 535                     !set_default(def->var, def->val, def->op))
 536                     rc = FALSE;
 537                 break;
 538             case DEFAULTS_HOST:
 539                 if (ISSET(what, SETDEF_HOST) &&
 540                     hostlist_matches(&def->binding) == ALLOW &&
 541                     !set_default(def->var, def->val, def->op))
 542                     rc = FALSE;
 543                 break;
 544             case DEFAULTS_CMND:
 545                 if (ISSET(what, SETDEF_CMND) &&
 546                     cmndlist_matches(&def->binding) == ALLOW &&
 547                     !set_default(def->var, def->val, def->op))
 548                     rc = FALSE;
 549                 break;
 550         }
 551     }
 552     return rc;
 553 }
 554
 555 static int
 556 store_int(char *val, struct sudo_defs_types *def, int op)
 557 {
 558     char *endp;
 559     long l;
 560
 561     if (op == FALSE) {
 562         def->sd_un.ival = 0;
 563     } else {
 564         l = strtol(val, &endp, 10);
 565         if (*endp != '\0')
 566             return FALSE;
 567         /* XXX - should check against INT_MAX */
 568         def->sd_un.ival = (int)l;
 569     }
 570     if (def->callback)
 571         return def->callback(val);
 572     return TRUE;
 573 }
 574
 575 static int
 576 store_uint(char *val, struct sudo_defs_types *def, int op)
 577 {
 578     char *endp;
 579     long l;
 580
 581     if (op == FALSE) {
 582         def->sd_un.ival = 0;
 583     } else {
 584         l = strtol(val, &endp, 10);
 585         if (*endp != '\0' || l < 0)
 586             return FALSE;
 587         /* XXX - should check against INT_MAX */
 588         def->sd_un.ival = (unsigned int)l;
 589     }
 590     if (def->callback)
 591         return def->callback(val);
 592     return TRUE;
 593 }
 594
 595 static int
 596 store_float(char *val, struct sudo_defs_types *def, int op)
 597 {
 598     char *endp;
 599     double d;
 600
 601     if (op == FALSE) {
 602         def->sd_un.fval = 0.0;
 603     } else {
 604         d = strtod(val, &endp);
 605         if (*endp != '\0')
 606             return FALSE;
 607         /* XXX - should check against HUGE_VAL */
 608         def->sd_un.fval = d;
 609     }
 610     if (def->callback)
 611         return def->callback(val);
 612     return TRUE;
 613 }
 614
 615 static int
 616 store_tuple(char *val, struct sudo_defs_types *def, int op)
 617 {
 618     struct def_values *v;
 619
 620     /*
 621      * Since enums are really just ints we store the value as an ival.
 622      * In the future, there may be multiple enums for different tuple
 623      * types we want to avoid and special knowledge of the tuple type.
 624      * This does assume that the first entry in the tuple enum will
 625      * be the equivalent to a boolean "false".
 626      */
 627     if (!val) {
 628         def->sd_un.ival = (op == FALSE) ? 0 : 1;
 629     } else {
 630         for (v = def->values; v->sval != NULL; v++) {
 631             if (strcmp(v->sval, val) == 0) {
 632                 def->sd_un.ival = v->ival;
 633                 break;
 634             }
 635         }
 636         if (v->sval == NULL)
 637             return FALSE;
 638     }
 639     if (def->callback)
 640         return def->callback(val);
 641     return TRUE;
 642 }
 643
 644 static int
 645 store_str(char *val, struct sudo_defs_types *def, int op)
 646 {
 647
 648     efree(def->sd_un.str);
 649     if (op == FALSE)
 650         def->sd_un.str = NULL;
 651     else
 652         def->sd_un.str = estrdup(val);
 653     if (def->callback)
 654         return def->callback(val);
 655     return TRUE;
 656 }
 657
 658 static int
 659 store_list(char *str, struct sudo_defs_types *def, int op)
 660 {
 661     char *start, *end;
 662
 663     /* Remove all old members. */
 664     if (op == FALSE || op == TRUE)
 665         list_op(NULL, 0, def, freeall);
 666
 667     /* Split str into multiple space-separated words and act on each one. */
 668     if (op != FALSE) {
 669         end = str;
 670         do {
 671             /* Remove leading blanks, if nothing but blanks we are done. */
 672             for (start = end; isblank((unsigned char)*start); start++)
 673                 ;
 674             if (*start == '\0')
 675                 break;
 676
 677             /* Find end position and perform operation. */
 678             for (end = start; *end && !isblank((unsigned char)*end); end++)
 679                 ;
 680             list_op(start, end - start, def, op == '-' ? delete : add);
 681         } while (*end++ != '\0');
 682     }
 683     return TRUE;
 684 }
 685
 686 static int
 687 store_syslogfac(char *val, struct sudo_defs_types *def, int op)
 688 {
 689     struct strmap *fac;
 690
 691     if (op == FALSE) {
 692         def->sd_un.ival = FALSE;
 693         return TRUE;
 694     }
 695 #ifdef LOG_NFACILITIES
 696     if (!val)
 697         return FALSE;
 698     for (fac = facilities; fac->name && strcmp(val, fac->name); fac++)
 699         ;
 700     if (fac->name == NULL)
 701         return FALSE;                           /* not found */
 702
 703     def->sd_un.ival = fac->num;
 704 #else
 705     def->sd_un.ival = -1;
 706 #endif /* LOG_NFACILITIES */
 707     return TRUE;
 708 }
 709
 710 static const char *
 711 logfac2str(int n)
 712 {
 713 #ifdef LOG_NFACILITIES
 714     struct strmap *fac;
 715
 716     for (fac = facilities; fac->name && fac->num != n; fac++)
 717         ;
 718     return fac->name;
 719 #else
 720     return "default";
 721 #endif /* LOG_NFACILITIES */
 722 }
 723
 724 static int
 725 store_syslogpri(char *val, struct sudo_defs_types *def, int op)
 726 {
 727     struct strmap *pri;
 728
 729     if (op == FALSE || !val)
 730         return FALSE;
 731
 732     for (pri = priorities; pri->name && strcmp(val, pri->name); pri++)
 733         ;
 734     if (pri->name == NULL)
 735         return FALSE;                           /* not found */
 736
 737     def->sd_un.ival = pri->num;
 738     return TRUE;
 739 }
 740
 741 static const char *
 742 logpri2str(int n)
 743 {
 744     struct strmap *pri;
 745
 746     for (pri = priorities; pri->name && pri->num != n; pri++)
 747         ;
 748     return pri->name;
 749 }
 750
 751 static int
 752 store_mode(char *val, struct sudo_defs_types *def, int op)
 753 {
 754     char *endp;
 755     long l;
 756
 757     if (op == FALSE) {
 758         def->sd_un.mode = (mode_t)0777;
 759     } else {
 760         l = strtol(val, &endp, 8);
 761         if (*endp != '\0' || l < 0 || l > 0777)
 762             return FALSE;
 763         def->sd_un.mode = (mode_t)l;
 764     }
 765     if (def->callback)
 766         return def->callback(val);
 767     return TRUE;
 768 }
 769
 770 static void
 771 list_op(char *val, size_t len, struct sudo_defs_types *def, enum list_ops op)
 772 {
 773     struct list_member *cur, *prev, *tmp;
 774
 775     if (op == freeall) {
 776         for (cur = def->sd_un.list; cur; ) {
 777             tmp = cur;
 778             cur = tmp->next;
 779             efree(tmp->value);
 780             efree(tmp);
 781         }
 782         def->sd_un.list = NULL;
 783         return;
 784     }
 785
 786     for (cur = def->sd_un.list, prev = NULL; cur; prev = cur, cur = cur->next) {
 787         if ((strncmp(cur->value, val, len) == 0 && cur->value[len] == '\0')) {
 788
 789             if (op == add)
 790                 return;                 /* already exists */
 791
 792             /* Delete node */
 793             if (prev != NULL)
 794                 prev->next = cur->next;
 795             else
 796                 def->sd_un.list = cur->next;
 797             efree(cur->value);
 798             efree(cur);
 799             break;
 800         }
 801     }
 802
 803     /* Add new node to the head of the list. */
 804     if (op == add) {
 805         cur = emalloc(sizeof(struct list_member));
 806         cur->value = emalloc(len + 1);
 807         (void) memcpy(cur->value, val, len);
 808         cur->value[len] = '\0';
 809         cur->next = def->sd_un.list;
 810         def->sd_un.list = cur;
 811     }
 812 }