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