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     char *desc;
 122
 123     for (cur = sudo_defs_table; cur->name; cur++) {
 124         if (cur->desc) {
 125             desc = _(cur->desc);
 126             switch (cur->type & T_MASK) {
 127                 case T_FLAG:
 128                     if (cur->sd_un.flag)
 129                         sudo_printf(SUDO_CONV_INFO_MSG, "%s\n", desc);
 130                     break;
 131                 case T_STR:
 132                     if (cur->sd_un.str) {
 133                         sudo_printf(SUDO_CONV_INFO_MSG, desc, cur->sd_un.str);
 134                         sudo_printf(SUDO_CONV_INFO_MSG, "\n");
 135                     }
 136                     break;
 137                 case T_LOGFAC:
 138                     if (cur->sd_un.ival) {
 139                         sudo_printf(SUDO_CONV_INFO_MSG, desc,
 140                             logfac2str(cur->sd_un.ival));
 141                         sudo_printf(SUDO_CONV_INFO_MSG, "\n");
 142                     }
 143                     break;
 144                 case T_LOGPRI:
 145                     if (cur->sd_un.ival) {
 146                         sudo_printf(SUDO_CONV_INFO_MSG, desc,
 147                             logpri2str(cur->sd_un.ival));
 148                         sudo_printf(SUDO_CONV_INFO_MSG, "\n");
 149                     }
 150                     break;
 151                 case T_UINT:
 152                 case T_INT:
 153                     sudo_printf(SUDO_CONV_INFO_MSG, desc, cur->sd_un.ival);
 154                     sudo_printf(SUDO_CONV_INFO_MSG, "\n");
 155                     break;
 156                 case T_FLOAT:
 157                     sudo_printf(SUDO_CONV_INFO_MSG, desc, cur->sd_un.fval);
 158                     sudo_printf(SUDO_CONV_INFO_MSG, "\n");
 159                     break;
 160                 case T_MODE:
 161                     sudo_printf(SUDO_CONV_INFO_MSG, desc, cur->sd_un.mode);
 162                     sudo_printf(SUDO_CONV_INFO_MSG, "\n");
 163                     break;
 164                 case T_LIST:
 165                     if (cur->sd_un.list) {
 166                         sudo_printf(SUDO_CONV_INFO_MSG, "%s\n", desc);
 167                         for (item = cur->sd_un.list; item; item = item->next) {
 168                             sudo_printf(SUDO_CONV_INFO_MSG,
 169                                 "\t%s\n", item->value);
 170                         }
 171                     }
 172                     break;
 173                 case T_TUPLE:
 174                     for (def = cur->values; def->sval; def++) {
 175                         if (cur->sd_un.ival == def->ival) {
 176                             sudo_printf(SUDO_CONV_INFO_MSG, 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, *desc;
 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->desc) {
 200             desc = _(cur->desc);
 201             switch (cur->type & T_MASK) {
 202                 case T_FLAG:
 203                     sudo_printf(SUDO_CONV_INFO_MSG,
 204                         _("%s: %s\n"), cur->name, desc);
 205                     break;
 206                 default:
 207                     p = strrchr(desc, ':');
 208                     if (p) {
 209                         while (p > desc && isspace((unsigned char)p[-1]))
 210                             p--;
 211                         sudo_printf(SUDO_CONV_INFO_MSG, _("%s: %.*s\n"),
 212                             cur->name, (int) (p - desc), desc);
 213                     } else {
 214                         sudo_printf(SUDO_CONV_INFO_MSG,
 215                             _("%s: %s\n"), cur->name, desc);
 216                     }
 217                     break;
 218             }
 219         }
 220     }
 221 }
 222
 223 /*
 224  * Sets/clears an entry in the defaults structure
 225  * If a variable that takes a value is used in a boolean
 226  * context with op == 0, disable that variable.
 227  * Eg. you may want to turn off logging to a file for some hosts.
 228  * This is only meaningful for variables that are *optional*.
 229  */
 230 int
 231 set_default(char *var, char *val, int op)
 232 {
 233     struct sudo_defs_types *cur;
 234     int num;
 235
 236     for (cur = sudo_defs_table, num = 0; cur->name; cur++, num++) {
 237         if (strcmp(var, cur->name) == 0)
 238             break;
 239     }
 240     if (!cur->name) {
 241         warningx(_("unknown defaults entry `%s'"), var);
 242         return FALSE;
 243     }
 244
 245     switch (cur->type & T_MASK) {
 246         case T_LOGFAC:
 247             if (!store_syslogfac(val, cur, op)) {
 248                 if (val)
 249                     warningx(_("value `%s' is invalid for option `%s'"),
 250                         val, var);
 251                 else
 252                     warningx(_("no value specified for `%s'"), var);
 253                 return FALSE;
 254             }
 255             break;
 256         case T_LOGPRI:
 257             if (!store_syslogpri(val, cur, op)) {
 258                 if (val)
 259                     warningx(_("value `%s' is invalid for option `%s'"),
 260                         val, var);
 261                 else
 262                     warningx(_("no value specified for `%s'"), var);
 263                 return FALSE;
 264             }
 265             break;
 266         case T_STR:
 267             if (!val) {
 268                 /* Check for bogus boolean usage or lack of a value. */
 269                 if (!ISSET(cur->type, T_BOOL) || op != FALSE) {
 270                     warningx(_("no value specified for `%s'"), var);
 271                     return FALSE;
 272                 }
 273             }
 274             if (ISSET(cur->type, T_PATH) && val && *val != '/') {
 275                 warningx(_("values for `%s' must start with a '/'"), var);
 276                 return FALSE;
 277             }
 278             if (!store_str(val, cur, op)) {
 279                 warningx(_("value `%s' is invalid for option `%s'"), val, var);
 280                 return FALSE;
 281             }
 282             break;
 283         case T_INT:
 284             if (!val) {
 285                 /* Check for bogus boolean usage or lack of a value. */
 286                 if (!ISSET(cur->type, T_BOOL) || op != FALSE) {
 287                     warningx(_("no value specified for `%s'"), var);
 288                     return FALSE;
 289                 }
 290             }
 291             if (!store_int(val, cur, op)) {
 292                 warningx(_("value `%s' is invalid for option `%s'"), val, var);
 293                 return FALSE;
 294             }
 295             break;
 296         case T_UINT:
 297             if (!val) {
 298                 /* Check for bogus boolean usage or lack of a value. */
 299                 if (!ISSET(cur->type, T_BOOL) || op != FALSE) {
 300                     warningx(_("no value specified for `%s'"), var);
 301                     return FALSE;
 302                 }
 303             }
 304             if (!store_uint(val, cur, op)) {
 305                 warningx(_("value `%s' is invalid for option `%s'"), val, var);
 306                 return FALSE;
 307             }
 308             break;
 309         case T_FLOAT:
 310             if (!val) {
 311                 /* Check for bogus boolean usage or lack of a value. */
 312                 if (!ISSET(cur->type, T_BOOL) || op != FALSE) {
 313                     warningx(_("no value specified for `%s'"), var);
 314                     return FALSE;
 315                 }
 316             }
 317             if (!store_float(val, cur, op)) {
 318                 warningx(_("value `%s' is invalid for option `%s'"), val, var);
 319                 return FALSE;
 320             }
 321             break;
 322         case T_MODE:
 323             if (!val) {
 324                 /* Check for bogus boolean usage or lack of a value. */
 325                 if (!ISSET(cur->type, T_BOOL) || op != FALSE) {
 326                     warningx(_("no value specified for `%s'"), var);
 327                     return FALSE;
 328                 }
 329             }
 330             if (!store_mode(val, cur, op)) {
 331                 warningx(_("value `%s' is invalid for option `%s'"), val, var);
 332                 return FALSE;
 333             }
 334             break;
 335         case T_FLAG:
 336             if (val) {
 337                 warningx(_("option `%s' does not take a value"), var);
 338                 return FALSE;
 339             }
 340             cur->sd_un.flag = op;
 341             break;
 342         case T_LIST:
 343             if (!val) {
 344                 /* Check for bogus boolean usage or lack of a value. */
 345                 if (!ISSET(cur->type, T_BOOL) || op != FALSE) {
 346                     warningx(_("no value specified for `%s'"), var);
 347                     return FALSE;
 348                 }
 349             }
 350             if (!store_list(val, cur, op)) {
 351                 warningx(_("value `%s' is invalid for option `%s'"), val, var);
 352                 return FALSE;
 353             }
 354             break;
 355         case T_TUPLE:
 356             if (!val && !ISSET(cur->type, T_BOOL)) {
 357                 warningx(_("no value specified for `%s'"), var);
 358                 return FALSE;
 359             }
 360             if (!store_tuple(val, cur, op)) {
 361                 warningx(_("value `%s' is invalid for option `%s'"), val, var);
 362                 return FALSE;
 363             }
 364             break;
 365     }
 366
 367     return TRUE;
 368 }
 369
 370 /*
 371  * Set default options to compiled-in values.
 372  * Any of these may be overridden at runtime by a "Defaults" file.
 373  */
 374 void
 375 init_defaults(void)
 376 {
 377     static int firsttime = 1;
 378     struct sudo_defs_types *def;
 379
 380     /* Clear any old settings. */
 381     if (!firsttime) {
 382         for (def = sudo_defs_table; def->name; def++) {
 383             switch (def->type & T_MASK) {
 384                 case T_STR:
 385                     efree(def->sd_un.str);
 386                     def->sd_un.str = NULL;
 387                     break;
 388                 case T_LIST:
 389                     list_op(NULL, 0, def, freeall);
 390                     break;
 391             }
 392             zero_bytes(&def->sd_un, sizeof(def->sd_un));
 393         }
 394     }
 395
 396     /* First initialize the flags. */
 397 #ifdef LONG_OTP_PROMPT
 398     def_long_otp_prompt = TRUE;
 399 #endif
 400 #ifdef IGNORE_DOT_PATH
 401     def_ignore_dot = TRUE;
 402 #endif
 403 #ifdef ALWAYS_SEND_MAIL
 404     def_mail_always = TRUE;
 405 #endif
 406 #ifdef SEND_MAIL_WHEN_NO_USER
 407     def_mail_no_user = TRUE;
 408 #endif
 409 #ifdef SEND_MAIL_WHEN_NO_HOST
 410     def_mail_no_host = TRUE;
 411 #endif
 412 #ifdef SEND_MAIL_WHEN_NOT_OK
 413     def_mail_no_perms = TRUE;
 414 #endif
 415 #ifndef NO_TTY_TICKETS
 416     def_tty_tickets = TRUE;
 417 #endif
 418 #ifndef NO_LECTURE
 419     def_lecture = once;
 420 #endif
 421 #ifndef NO_AUTHENTICATION
 422     def_authenticate = TRUE;
 423 #endif
 424 #ifndef NO_ROOT_SUDO
 425     def_root_sudo = TRUE;
 426 #endif
 427 #ifdef HOST_IN_LOG
 428     def_log_host = TRUE;
 429 #endif
 430 #ifdef SHELL_IF_NO_ARGS
 431     def_shell_noargs = TRUE;
 432 #endif
 433 #ifdef SHELL_SETS_HOME
 434     def_set_home = TRUE;
 435 #endif
 436 #ifndef DONT_LEAK_PATH_INFO
 437     def_path_info = TRUE;
 438 #endif
 439 #ifdef FQDN
 440     def_fqdn = TRUE;
 441 #endif
 442 #ifdef USE_INSULTS
 443     def_insults = TRUE;
 444 #endif
 445 #ifdef ENV_EDITOR
 446     def_env_editor = TRUE;
 447 #endif
 448 #ifdef UMASK_OVERRIDE
 449     def_umask_override = TRUE;
 450 #endif
 451     def_iolog_file = estrdup("%{seq}");
 452     def_iolog_dir = estrdup(_PATH_SUDO_IO_LOGDIR);
 453     def_sudoers_locale = estrdup("C");
 454     def_env_reset = ENV_RESET;
 455     def_set_logname = TRUE;
 456     def_closefrom = STDERR_FILENO + 1;
 457
 458     /* Syslog options need special care since they both strings and ints */
 459 #if (LOGGING & SLOG_SYSLOG)
 460     (void) store_syslogfac(LOGFAC, &sudo_defs_table[I_SYSLOG], TRUE);
 461     (void) store_syslogpri(PRI_SUCCESS, &sudo_defs_table[I_SYSLOG_GOODPRI],
 462         TRUE);
 463     (void) store_syslogpri(PRI_FAILURE, &sudo_defs_table[I_SYSLOG_BADPRI],
 464         TRUE);
 465 #endif
 466
 467     /* Password flags also have a string and integer component. */
 468     (void) store_tuple("any", &sudo_defs_table[I_LISTPW], TRUE);
 469     (void) store_tuple("all", &sudo_defs_table[I_VERIFYPW], TRUE);
 470
 471     /* Then initialize the int-like things. */
 472 #ifdef SUDO_UMASK
 473     def_umask = SUDO_UMASK;
 474 #else
 475     def_umask = 0777;
 476 #endif
 477     def_loglinelen = MAXLOGFILELEN;
 478     def_timestamp_timeout = TIMEOUT;
 479     def_passwd_timeout = PASSWORD_TIMEOUT;
 480     def_passwd_tries = TRIES_FOR_PASSWORD;
 481 #ifdef HAVE_ZLIB_H
 482     def_compress_io = TRUE;
 483 #endif
 484
 485     /* Now do the strings */
 486     def_mailto = estrdup(MAILTO);
 487     def_mailsub = estrdup(_(MAILSUBJECT));
 488     def_badpass_message = estrdup(_(INCORRECT_PASSWORD));
 489     def_timestampdir = estrdup(_PATH_SUDO_TIMEDIR);
 490     def_passprompt = estrdup(_(PASSPROMPT));
 491     def_runas_default = estrdup(RUNAS_DEFAULT);
 492 #ifdef _PATH_SUDO_SENDMAIL
 493     def_mailerpath = estrdup(_PATH_SUDO_SENDMAIL);
 494     def_mailerflags = estrdup("-t");
 495 #endif
 496 #if (LOGGING & SLOG_FILE)
 497     def_logfile = estrdup(_PATH_SUDO_LOGFILE);
 498 #endif
 499 #ifdef EXEMPTGROUP
 500     def_exempt_group = estrdup(EXEMPTGROUP);
 501 #endif
 502 #ifdef SECURE_PATH
 503     def_secure_path = estrdup(SECURE_PATH);
 504 #endif
 505     def_editor = estrdup(EDITOR);
 506     def_set_utmp = TRUE;
 507
 508     /* Finally do the lists (currently just environment tables). */
 509     init_envtables();
 510
 511     firsttime = 0;
 512 }
 513
 514 /*
 515  * Update the defaults based on what was set by sudoers.
 516  * Pass in an OR'd list of which default types to update.
 517  */
 518 int
 519 update_defaults(int what)
 520 {
 521     struct defaults *def;
 522     int rc = TRUE;
 523
 524     tq_foreach_fwd(&defaults, def) {
 525         switch (def->type) {
 526             case DEFAULTS:
 527                 if (ISSET(what, SETDEF_GENERIC) &&
 528                     !set_default(def->var, def->val, def->op))
 529                     rc = FALSE;
 530                 break;
 531             case DEFAULTS_USER:
 532                 if (ISSET(what, SETDEF_USER) &&
 533                     userlist_matches(sudo_user.pw, &def->binding) == ALLOW &&
 534                     !set_default(def->var, def->val, def->op))
 535                     rc = FALSE;
 536                 break;
 537             case DEFAULTS_RUNAS:
 538                 if (ISSET(what, SETDEF_RUNAS) &&
 539                     runaslist_matches(&def->binding, NULL) == ALLOW &&
 540                     !set_default(def->var, def->val, def->op))
 541                     rc = FALSE;
 542                 break;
 543             case DEFAULTS_HOST:
 544                 if (ISSET(what, SETDEF_HOST) &&
 545                     hostlist_matches(&def->binding) == ALLOW &&
 546                     !set_default(def->var, def->val, def->op))
 547                     rc = FALSE;
 548                 break;
 549             case DEFAULTS_CMND:
 550                 if (ISSET(what, SETDEF_CMND) &&
 551                     cmndlist_matches(&def->binding) == ALLOW &&
 552                     !set_default(def->var, def->val, def->op))
 553                     rc = FALSE;
 554                 break;
 555         }
 556     }
 557     return rc;
 558 }
 559
 560 static int
 561 store_int(char *val, struct sudo_defs_types *def, int op)
 562 {
 563     char *endp;
 564     long l;
 565
 566     if (op == FALSE) {
 567         def->sd_un.ival = 0;
 568     } else {
 569         l = strtol(val, &endp, 10);
 570         if (*endp != '\0')
 571             return FALSE;
 572         /* XXX - should check against INT_MAX */
 573         def->sd_un.ival = (int)l;
 574     }
 575     if (def->callback)
 576         return def->callback(val);
 577     return TRUE;
 578 }
 579
 580 static int
 581 store_uint(char *val, struct sudo_defs_types *def, int op)
 582 {
 583     char *endp;
 584     long l;
 585
 586     if (op == FALSE) {
 587         def->sd_un.ival = 0;
 588     } else {
 589         l = strtol(val, &endp, 10);
 590         if (*endp != '\0' || l < 0)
 591             return FALSE;
 592         /* XXX - should check against INT_MAX */
 593         def->sd_un.ival = (unsigned int)l;
 594     }
 595     if (def->callback)
 596         return def->callback(val);
 597     return TRUE;
 598 }
 599
 600 static int
 601 store_float(char *val, struct sudo_defs_types *def, int op)
 602 {
 603     char *endp;
 604     double d;
 605
 606     if (op == FALSE) {
 607         def->sd_un.fval = 0.0;
 608     } else {
 609         d = strtod(val, &endp);
 610         if (*endp != '\0')
 611             return FALSE;
 612         /* XXX - should check against HUGE_VAL */
 613         def->sd_un.fval = d;
 614     }
 615     if (def->callback)
 616         return def->callback(val);
 617     return TRUE;
 618 }
 619
 620 static int
 621 store_tuple(char *val, struct sudo_defs_types *def, int op)
 622 {
 623     struct def_values *v;
 624
 625     /*
 626      * Since enums are really just ints we store the value as an ival.
 627      * In the future, there may be multiple enums for different tuple
 628      * types we want to avoid and special knowledge of the tuple type.
 629      * This does assume that the first entry in the tuple enum will
 630      * be the equivalent to a boolean "false".
 631      */
 632     if (!val) {
 633         def->sd_un.ival = (op == FALSE) ? 0 : 1;
 634     } else {
 635         for (v = def->values; v->sval != NULL; v++) {
 636             if (strcmp(v->sval, val) == 0) {
 637                 def->sd_un.ival = v->ival;
 638                 break;
 639             }
 640         }
 641         if (v->sval == NULL)
 642             return FALSE;
 643     }
 644     if (def->callback)
 645         return def->callback(val);
 646     return TRUE;
 647 }
 648
 649 static int
 650 store_str(char *val, struct sudo_defs_types *def, int op)
 651 {
 652
 653     efree(def->sd_un.str);
 654     if (op == FALSE)
 655         def->sd_un.str = NULL;
 656     else
 657         def->sd_un.str = estrdup(val);
 658     if (def->callback)
 659         return def->callback(val);
 660     return TRUE;
 661 }
 662
 663 static int
 664 store_list(char *str, struct sudo_defs_types *def, int op)
 665 {
 666     char *start, *end;
 667
 668     /* Remove all old members. */
 669     if (op == FALSE || op == TRUE)
 670         list_op(NULL, 0, def, freeall);
 671
 672     /* Split str into multiple space-separated words and act on each one. */
 673     if (op != FALSE) {
 674         end = str;
 675         do {
 676             /* Remove leading blanks, if nothing but blanks we are done. */
 677             for (start = end; isblank((unsigned char)*start); start++)
 678                 ;
 679             if (*start == '\0')
 680                 break;
 681
 682             /* Find end position and perform operation. */
 683             for (end = start; *end && !isblank((unsigned char)*end); end++)
 684                 ;
 685             list_op(start, end - start, def, op == '-' ? delete : add);
 686         } while (*end++ != '\0');
 687     }
 688     return TRUE;
 689 }
 690
 691 static int
 692 store_syslogfac(char *val, struct sudo_defs_types *def, int op)
 693 {
 694     struct strmap *fac;
 695
 696     if (op == FALSE) {
 697         def->sd_un.ival = FALSE;
 698         return TRUE;
 699     }
 700 #ifdef LOG_NFACILITIES
 701     if (!val)
 702         return FALSE;
 703     for (fac = facilities; fac->name && strcmp(val, fac->name); fac++)
 704         ;
 705     if (fac->name == NULL)
 706         return FALSE;                           /* not found */
 707
 708     def->sd_un.ival = fac->num;
 709 #else
 710     def->sd_un.ival = -1;
 711 #endif /* LOG_NFACILITIES */
 712     return TRUE;
 713 }
 714
 715 static const char *
 716 logfac2str(int n)
 717 {
 718 #ifdef LOG_NFACILITIES
 719     struct strmap *fac;
 720
 721     for (fac = facilities; fac->name && fac->num != n; fac++)
 722         ;
 723     return fac->name;
 724 #else
 725     return "default";
 726 #endif /* LOG_NFACILITIES */
 727 }
 728
 729 static int
 730 store_syslogpri(char *val, struct sudo_defs_types *def, int op)
 731 {
 732     struct strmap *pri;
 733
 734     if (op == FALSE || !val)
 735         return FALSE;
 736
 737     for (pri = priorities; pri->name && strcmp(val, pri->name); pri++)
 738         ;
 739     if (pri->name == NULL)
 740         return FALSE;                           /* not found */
 741
 742     def->sd_un.ival = pri->num;
 743     return TRUE;
 744 }
 745
 746 static const char *
 747 logpri2str(int n)
 748 {
 749     struct strmap *pri;
 750
 751     for (pri = priorities; pri->name && pri->num != n; pri++)
 752         ;
 753     return pri->name;
 754 }
 755
 756 static int
 757 store_mode(char *val, struct sudo_defs_types *def, int op)
 758 {
 759     char *endp;
 760     long l;
 761
 762     if (op == FALSE) {
 763         def->sd_un.mode = (mode_t)0777;
 764     } else {
 765         l = strtol(val, &endp, 8);
 766         if (*endp != '\0' || l < 0 || l > 0777)
 767             return FALSE;
 768         def->sd_un.mode = (mode_t)l;
 769     }
 770     if (def->callback)
 771         return def->callback(val);
 772     return TRUE;
 773 }
 774
 775 static void
 776 list_op(char *val, size_t len, struct sudo_defs_types *def, enum list_ops op)
 777 {
 778     struct list_member *cur, *prev, *tmp;
 779
 780     if (op == freeall) {
 781         for (cur = def->sd_un.list; cur; ) {
 782             tmp = cur;
 783             cur = tmp->next;
 784             efree(tmp->value);
 785             efree(tmp);
 786         }
 787         def->sd_un.list = NULL;
 788         return;
 789     }
 790
 791     for (cur = def->sd_un.list, prev = NULL; cur; prev = cur, cur = cur->next) {
 792         if ((strncmp(cur->value, val, len) == 0 && cur->value[len] == '\0')) {
 793
 794             if (op == add)
 795                 return;                 /* already exists */
 796
 797             /* Delete node */
 798             if (prev != NULL)
 799                 prev->next = cur->next;
 800             else
 801                 def->sd_un.list = cur->next;
 802             efree(cur->value);
 803             efree(cur);
 804             break;
 805         }
 806     }
 807
 808     /* Add new node to the head of the list. */
 809     if (op == add) {
 810         cur = emalloc(sizeof(struct list_member));
 811         cur->value = emalloc(len + 1);
 812         (void) memcpy(cur->value, val, len);
 813         cur->value[len] = '\0';
 814         cur->next = def->sd_un.list;
 815         def->sd_un.list = cur;
 816     }
 817 }