Annotation of embedaddon/sudo/src/sudo.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Copyright (c) 2009-2011 Todd C. Miller <Todd.Miller@courtesan.com>
! 3: *
! 4: * Permission to use, copy, modify, and distribute this software for any
! 5: * purpose with or without fee is hereby granted, provided that the above
! 6: * copyright notice and this permission notice appear in all copies.
! 7: *
! 8: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
! 9: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
! 10: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
! 11: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
! 12: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
! 13: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
! 14: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
! 15: */
! 16:
! 17: #ifdef __TANDEM
! 18: # include <floss.h>
! 19: #endif
! 20:
! 21: #include <config.h>
! 22:
! 23: #include <sys/types.h>
! 24: #include <sys/param.h>
! 25: #include <sys/stat.h>
! 26: #include <sys/wait.h>
! 27: #include <sys/socket.h>
! 28: #ifdef HAVE_SYS_SELECT_H
! 29: # include <sys/select.h>
! 30: #endif /* HAVE_SYS_SELECT_H */
! 31: #include <sys/time.h>
! 32: #include <sys/resource.h>
! 33: #include <stdio.h>
! 34: #ifdef STDC_HEADERS
! 35: # include <stdlib.h>
! 36: # include <stddef.h>
! 37: #else
! 38: # ifdef HAVE_STDLIB_H
! 39: # include <stdlib.h>
! 40: # endif
! 41: #endif /* STDC_HEADERS */
! 42: #ifdef HAVE_STRING_H
! 43: # if defined(HAVE_MEMORY_H) && !defined(STDC_HEADERS)
! 44: # include <memory.h>
! 45: # endif
! 46: # include <string.h>
! 47: #endif /* HAVE_STRING_H */
! 48: #ifdef HAVE_STRINGS_H
! 49: # include <strings.h>
! 50: #endif /* HAVE_STRINGS_H */
! 51: #ifdef HAVE_UNISTD_H
! 52: # include <unistd.h>
! 53: #endif /* HAVE_UNISTD_H */
! 54: #include <ctype.h>
! 55: #include <errno.h>
! 56: #include <fcntl.h>
! 57: #include <limits.h>
! 58: #include <signal.h>
! 59: #include <grp.h>
! 60: #include <pwd.h>
! 61: #if TIME_WITH_SYS_TIME
! 62: # include <time.h>
! 63: #endif
! 64: #ifdef HAVE_SETLOCALE
! 65: # include <locale.h>
! 66: #endif
! 67: #ifdef HAVE_LOGIN_CAP_H
! 68: # include <login_cap.h>
! 69: #endif
! 70: #ifdef HAVE_PROJECT_H
! 71: # include <project.h>
! 72: # include <sys/task.h>
! 73: #endif
! 74: #ifdef HAVE_SELINUX
! 75: # include <selinux/selinux.h>
! 76: #endif
! 77: #ifdef HAVE_SETAUTHDB
! 78: # include <usersec.h>
! 79: #endif /* HAVE_SETAUTHDB */
! 80: #if defined(HAVE_GETPRPWNAM) && defined(HAVE_SET_AUTH_PARAMETERS)
! 81: # ifdef __hpux
! 82: # undef MAXINT
! 83: # include <hpsecurity.h>
! 84: # else
! 85: # include <sys/security.h>
! 86: # endif /* __hpux */
! 87: # include <prot.h>
! 88: #endif /* HAVE_GETPRPWNAM && HAVE_SET_AUTH_PARAMETERS */
! 89: #ifdef HAVE_PRIV_SET
! 90: # include <priv.h>
! 91: #endif
! 92:
! 93: #include "sudo.h"
! 94: #include "sudo_plugin.h"
! 95: #include "sudo_plugin_int.h"
! 96: #include <sudo_usage.h>
! 97:
! 98: /*
! 99: * Local variables
! 100: */
! 101: struct plugin_container policy_plugin;
! 102: struct plugin_container_list io_plugins;
! 103: struct user_details user_details;
! 104: const char *list_user, *runas_user, *runas_group; /* extern for parse_args.c */
! 105: int debug_level;
! 106:
! 107: /*
! 108: * Local functions
! 109: */
! 110: static void fix_fds(void);
! 111: static void disable_coredumps(void);
! 112: static char **get_user_info(struct user_details *);
! 113: static void command_info_to_details(char * const info[],
! 114: struct command_details *details);
! 115: static int policy_open(struct plugin_container *plugin, char * const settings[],
! 116: char * const user_info[], char * const user_env[]);
! 117: static void policy_close(struct plugin_container *plugin, int exit_status,
! 118: int error);
! 119: static int iolog_open(struct plugin_container *plugin, char * const settings[],
! 120: char * const user_info[], char * const command_details[],
! 121: int argc, char * const argv[], char * const user_env[]);
! 122: static void iolog_close(struct plugin_container *plugin, int exit_status,
! 123: int error);
! 124:
! 125: /* Policy plugin convenience functions. */
! 126: static int policy_open(struct plugin_container *plugin, char * const settings[],
! 127: char * const user_info[], char * const user_env[]);
! 128: static void policy_close(struct plugin_container *plugin, int exit_status,
! 129: int error);
! 130: static int policy_show_version(struct plugin_container *plugin, int verbose);
! 131: static int policy_check(struct plugin_container *plugin, int argc,
! 132: char * const argv[], char *env_add[], char **command_info[],
! 133: char **argv_out[], char **user_env_out[]);
! 134: static int policy_list(struct plugin_container *plugin, int argc,
! 135: char * const argv[], int verbose, const char *list_user);
! 136: static int policy_validate(struct plugin_container *plugin);
! 137: static void policy_invalidate(struct plugin_container *plugin, int remove);
! 138: static int policy_init_session(struct plugin_container *plugin,
! 139: struct passwd *pwd);
! 140:
! 141: /* I/O log plugin convenience functions. */
! 142: static int iolog_open(struct plugin_container *plugin, char * const settings[],
! 143: char * const user_info[], char * const command_details[],
! 144: int argc, char * const argv[], char * const user_env[]);
! 145: static void iolog_close(struct plugin_container *plugin, int exit_status,
! 146: int error);
! 147: static int iolog_show_version(struct plugin_container *plugin, int verbose);
! 148:
! 149: #if defined(RLIMIT_CORE) && !defined(SUDO_DEVEL)
! 150: static struct rlimit corelimit;
! 151: #endif /* RLIMIT_CORE && !SUDO_DEVEL */
! 152: #if defined(__linux__)
! 153: static struct rlimit nproclimit;
! 154: #endif
! 155:
! 156: int
! 157: main(int argc, char *argv[], char *envp[])
! 158: {
! 159: int nargc, sudo_mode, exitcode = 0;
! 160: char **nargv, **settings, **env_add;
! 161: char **user_info, **command_info, **argv_out, **user_env_out;
! 162: struct plugin_container *plugin, *next;
! 163: struct command_details command_details;
! 164: sigset_t mask;
! 165: int ok;
! 166: #if defined(SUDO_DEVEL) && defined(__OpenBSD__)
! 167: extern char *malloc_options;
! 168: malloc_options = "AFGJPR";
! 169: #endif
! 170:
! 171: #if !defined(HAVE_GETPROGNAME) && !defined(HAVE___PROGNAME)
! 172: if (argc > 0)
! 173: setprogname(argv[0]);
! 174: #endif
! 175:
! 176: #ifdef HAVE_SETLOCALE
! 177: setlocale(LC_ALL, "");
! 178: #endif
! 179: bindtextdomain(PACKAGE_NAME, LOCALEDIR);
! 180: textdomain(PACKAGE_NAME);
! 181:
! 182: /* Must be done before we do any password lookups */
! 183: #if defined(HAVE_GETPRPWNAM) && defined(HAVE_SET_AUTH_PARAMETERS)
! 184: (void) set_auth_parameters(argc, argv);
! 185: # ifdef HAVE_INITPRIVS
! 186: initprivs();
! 187: # endif
! 188: #endif /* HAVE_GETPRPWNAM && HAVE_SET_AUTH_PARAMETERS */
! 189:
! 190: if (geteuid() != 0)
! 191: errorx(1, _("must be setuid root"));
! 192:
! 193: /* Reset signal mask, disable core dumps and make sure fds 0-2 are open. */
! 194: (void) sigemptyset(&mask);
! 195: (void) sigprocmask(SIG_SETMASK, &mask, NULL);
! 196: disable_coredumps();
! 197: fix_fds();
! 198:
! 199: /* Fill in user_info with user name, uid, cwd, etc. */
! 200: memset(&user_details, 0, sizeof(user_details));
! 201: user_info = get_user_info(&user_details);
! 202:
! 203: /* Parse command line arguments. */
! 204: sudo_mode = parse_args(argc, argv, &nargc, &nargv, &settings, &env_add);
! 205: sudo_debug(9, "sudo_mode %d", sudo_mode);
! 206:
! 207: /* Print sudo version early, in case of plugin init failure. */
! 208: if (ISSET(sudo_mode, MODE_VERSION)) {
! 209: printf(_("Sudo version %s\n"), PACKAGE_VERSION);
! 210: if (user_details.uid == ROOT_UID)
! 211: (void) printf(_("Configure options: %s\n"), CONFIGURE_ARGS);
! 212: }
! 213:
! 214: /* Read sudo.conf and load plugins. */
! 215: if (!sudo_load_plugins(_PATH_SUDO_CONF, &policy_plugin, &io_plugins))
! 216: errorx(1, _("fatal error, unable to load plugins"));
! 217:
! 218: /* Open policy plugin. */
! 219: ok = policy_open(&policy_plugin, settings, user_info, envp);
! 220: if (ok != TRUE) {
! 221: if (ok == -2)
! 222: usage(1);
! 223: else
! 224: errorx(1, _("unable to initialize policy plugin"));
! 225: }
! 226:
! 227: switch (sudo_mode & MODE_MASK) {
! 228: case MODE_VERSION:
! 229: policy_show_version(&policy_plugin, !user_details.uid);
! 230: tq_foreach_fwd(&io_plugins, plugin) {
! 231: ok = iolog_open(plugin, settings, user_info, NULL,
! 232: nargc, nargv, envp);
! 233: if (ok == TRUE)
! 234: iolog_show_version(plugin, !user_details.uid);
! 235: }
! 236: break;
! 237: case MODE_VALIDATE:
! 238: case MODE_VALIDATE|MODE_INVALIDATE:
! 239: ok = policy_validate(&policy_plugin);
! 240: exit(ok != TRUE);
! 241: case MODE_KILL:
! 242: case MODE_INVALIDATE:
! 243: policy_invalidate(&policy_plugin, sudo_mode == MODE_KILL);
! 244: exit(0);
! 245: break;
! 246: case MODE_CHECK:
! 247: case MODE_CHECK|MODE_INVALIDATE:
! 248: case MODE_LIST:
! 249: case MODE_LIST|MODE_INVALIDATE:
! 250: ok = policy_list(&policy_plugin, nargc, nargv,
! 251: ISSET(sudo_mode, MODE_LONG_LIST), list_user);
! 252: exit(ok != TRUE);
! 253: case MODE_EDIT:
! 254: case MODE_RUN:
! 255: ok = policy_check(&policy_plugin, nargc, nargv, env_add,
! 256: &command_info, &argv_out, &user_env_out);
! 257: sudo_debug(8, "policy plugin returns %d", ok);
! 258: if (ok != TRUE) {
! 259: if (ok == -2)
! 260: usage(1);
! 261: exit(1); /* plugin printed error message */
! 262: }
! 263: /* Open I/O plugins once policy plugin succeeds. */
! 264: for (plugin = io_plugins.first; plugin != NULL; plugin = next) {
! 265: next = plugin->next;
! 266: ok = iolog_open(plugin, settings, user_info,
! 267: command_info, nargc, nargv, envp);
! 268: switch (ok) {
! 269: case TRUE:
! 270: break;
! 271: case FALSE:
! 272: /* I/O plugin asked to be disabled, remove from list. */
! 273: tq_remove(&io_plugins, plugin);
! 274: break;
! 275: case -2:
! 276: usage(1);
! 277: break;
! 278: default:
! 279: errorx(1, _("error initializing I/O plugin %s"),
! 280: plugin->name);
! 281: }
! 282: }
! 283: command_info_to_details(command_info, &command_details);
! 284: command_details.argv = argv_out;
! 285: command_details.envp = user_env_out;
! 286: if (ISSET(sudo_mode, MODE_BACKGROUND))
! 287: SET(command_details.flags, CD_BACKGROUND);
! 288: /* Restore coredumpsize resource limit before running. */
! 289: #if defined(RLIMIT_CORE) && !defined(SUDO_DEVEL)
! 290: (void) setrlimit(RLIMIT_CORE, &corelimit);
! 291: #endif /* RLIMIT_CORE && !SUDO_DEVEL */
! 292: if (ISSET(command_details.flags, CD_SUDOEDIT)) {
! 293: exitcode = sudo_edit(&command_details);
! 294: } else {
! 295: exitcode = run_command(&command_details);
! 296: }
! 297: /* The close method was called by sudo_edit/run_command. */
! 298: break;
! 299: default:
! 300: errorx(1, _("unexpected sudo mode 0x%x"), sudo_mode);
! 301: }
! 302: exit(exitcode);
! 303: }
! 304:
! 305: /*
! 306: * Ensure that stdin, stdout and stderr are open; set to /dev/null if not.
! 307: * Some operating systems do this automatically in the kernel or libc.
! 308: */
! 309: static void
! 310: fix_fds(void)
! 311: {
! 312: int miss[3], devnull = -1;
! 313:
! 314: /*
! 315: * stdin, stdout and stderr must be open; set them to /dev/null
! 316: * if they are closed.
! 317: */
! 318: miss[STDIN_FILENO] = fcntl(STDIN_FILENO, F_GETFL, 0) == -1;
! 319: miss[STDOUT_FILENO] = fcntl(STDOUT_FILENO, F_GETFL, 0) == -1;
! 320: miss[STDERR_FILENO] = fcntl(STDERR_FILENO, F_GETFL, 0) == -1;
! 321: if (miss[STDIN_FILENO] || miss[STDOUT_FILENO] || miss[STDERR_FILENO]) {
! 322: if ((devnull = open(_PATH_DEVNULL, O_RDWR, 0644)) == -1)
! 323: error(1, _("unable to open %s"), _PATH_DEVNULL);
! 324: if (miss[STDIN_FILENO] && dup2(devnull, STDIN_FILENO) == -1)
! 325: error(1, "dup2");
! 326: if (miss[STDOUT_FILENO] && dup2(devnull, STDOUT_FILENO) == -1)
! 327: error(1, "dup2");
! 328: if (miss[STDERR_FILENO] && dup2(devnull, STDERR_FILENO) == -1)
! 329: error(1, "dup2");
! 330: if (devnull > STDERR_FILENO)
! 331: close(devnull);
! 332: }
! 333: }
! 334:
! 335: /*
! 336: * Allocate space for groups and fill in using getgrouplist()
! 337: * for when we cannot use getgroups().
! 338: */
! 339: static int
! 340: fill_group_list(struct user_details *ud)
! 341: {
! 342: int maxgroups, tries, rval = -1;
! 343:
! 344: #if defined(HAVE_SYSCONF) && defined(_SC_NGROUPS_MAX)
! 345: maxgroups = (int)sysconf(_SC_NGROUPS_MAX);
! 346: if (maxgroups < 0)
! 347: #endif
! 348: maxgroups = NGROUPS_MAX;
! 349:
! 350: /*
! 351: * It is possible to belong to more groups in the group database
! 352: * than NGROUPS_MAX. We start off with NGROUPS_MAX * 2 entries
! 353: * and double this as needed.
! 354: */
! 355: ud->groups = NULL;
! 356: ud->ngroups = maxgroups;
! 357: for (tries = 0; tries < 10 && rval == -1; tries++) {
! 358: ud->ngroups *= 2;
! 359: efree(ud->groups);
! 360: ud->groups = emalloc2(ud->ngroups, sizeof(GETGROUPS_T));
! 361: rval = getgrouplist(ud->username, ud->gid, ud->groups, &ud->ngroups);
! 362: }
! 363: return rval;
! 364: }
! 365:
! 366: static char *
! 367: get_user_groups(struct user_details *ud)
! 368: {
! 369: char *cp, *gid_list = NULL;
! 370: size_t glsize;
! 371: int i, len;
! 372:
! 373: /*
! 374: * Systems with mbr_check_membership() support more than NGROUPS_MAX
! 375: * groups so we cannot use getgroups().
! 376: */
! 377: ud->groups = NULL;
! 378: #ifndef HAVE_MBR_CHECK_MEMBERSHIP
! 379: if ((ud->ngroups = getgroups(0, NULL)) > 0) {
! 380: ud->groups = emalloc2(ud->ngroups, sizeof(GETGROUPS_T));
! 381: if (getgroups(ud->ngroups, ud->groups) < 0) {
! 382: efree(ud->groups);
! 383: ud->groups = NULL;
! 384: }
! 385: }
! 386: #endif /* HAVE_MBR_CHECK_MEMBERSHIP */
! 387: if (ud->groups == NULL) {
! 388: if (fill_group_list(ud) == -1)
! 389: error(1, _("unable to get group vector"));
! 390: }
! 391:
! 392: /*
! 393: * Format group list as a comma-separated string of gids.
! 394: */
! 395: glsize = sizeof("groups=") - 1 + (ud->ngroups * (MAX_UID_T_LEN + 1));
! 396: gid_list = emalloc(glsize);
! 397: memcpy(gid_list, "groups=", sizeof("groups=") - 1);
! 398: cp = gid_list + sizeof("groups=") - 1;
! 399: for (i = 0; i < ud->ngroups; i++) {
! 400: /* XXX - check rval */
! 401: len = snprintf(cp, glsize - (cp - gid_list), "%s%u",
! 402: i ? "," : "", (unsigned int)ud->groups[i]);
! 403: cp += len;
! 404: }
! 405: return gid_list;
! 406: }
! 407:
! 408: /*
! 409: * Return user information as an array of name=value pairs.
! 410: * and fill in struct user_details (which shares the same strings).
! 411: */
! 412: static char **
! 413: get_user_info(struct user_details *ud)
! 414: {
! 415: char cwd[PATH_MAX];
! 416: char host[MAXHOSTNAMELEN];
! 417: char **user_info, *cp;
! 418: struct passwd *pw;
! 419: int i = 0;
! 420:
! 421: /* XXX - bound check number of entries */
! 422: user_info = emalloc2(32, sizeof(char *));
! 423:
! 424: ud->uid = getuid();
! 425: ud->euid = geteuid();
! 426: ud->gid = getgid();
! 427: ud->egid = getegid();
! 428:
! 429: pw = getpwuid(ud->uid);
! 430: if (pw == NULL)
! 431: errorx(1, _("unknown uid %u: who are you?"), (unsigned int)ud->uid);
! 432:
! 433: user_info[i] = fmt_string("user", pw->pw_name);
! 434: if (user_info[i] == NULL)
! 435: errorx(1, _("unable to allocate memory"));
! 436: ud->username = user_info[i] + sizeof("user=") - 1;
! 437:
! 438: /* Stash user's shell for use with the -s flag; don't pass to plugin. */
! 439: if ((ud->shell = getenv("SHELL")) == NULL || ud->shell[0] == '\0') {
! 440: ud->shell = pw->pw_shell[0] ? pw->pw_shell : _PATH_BSHELL;
! 441: }
! 442: ud->shell = estrdup(ud->shell);
! 443:
! 444: easprintf(&user_info[++i], "uid=%u", (unsigned int)ud->uid);
! 445: easprintf(&user_info[++i], "euid=%u", (unsigned int)ud->euid);
! 446: easprintf(&user_info[++i], "gid=%u", (unsigned int)ud->gid);
! 447: easprintf(&user_info[++i], "egid=%u", (unsigned int)ud->egid);
! 448:
! 449: if ((cp = get_user_groups(ud)) != NULL)
! 450: user_info[++i] = cp;
! 451:
! 452: if (getcwd(cwd, sizeof(cwd)) != NULL) {
! 453: user_info[++i] = fmt_string("cwd", cwd);
! 454: if (user_info[i] == NULL)
! 455: errorx(1, _("unable to allocate memory"));
! 456: ud->cwd = user_info[i] + sizeof("cwd=") - 1;
! 457: }
! 458:
! 459: if ((cp = ttyname(STDIN_FILENO)) || (cp = ttyname(STDOUT_FILENO)) ||
! 460: (cp = ttyname(STDERR_FILENO))) {
! 461: user_info[++i] = fmt_string("tty", cp);
! 462: if (user_info[i] == NULL)
! 463: errorx(1, _("unable to allocate memory"));
! 464: ud->tty = user_info[i] + sizeof("tty=") - 1;
! 465: }
! 466:
! 467: if (gethostname(host, sizeof(host)) == 0)
! 468: host[sizeof(host) - 1] = '\0';
! 469: else
! 470: strlcpy(host, "localhost", sizeof(host));
! 471: user_info[++i] = fmt_string("host", host);
! 472: if (user_info[i] == NULL)
! 473: errorx(1, _("unable to allocate memory"));
! 474: ud->host = user_info[i] + sizeof("host=") - 1;
! 475:
! 476: get_ttysize(&ud->ts_lines, &ud->ts_cols);
! 477: easprintf(&user_info[++i], "lines=%d", ud->ts_lines);
! 478: easprintf(&user_info[++i], "cols=%d", ud->ts_cols);
! 479:
! 480: user_info[++i] = NULL;
! 481:
! 482: return user_info;
! 483: }
! 484:
! 485: /*
! 486: * Convert a command_info array into a command_details structure.
! 487: */
! 488: static void
! 489: command_info_to_details(char * const info[], struct command_details *details)
! 490: {
! 491: int i;
! 492: long lval;
! 493: unsigned long ulval;
! 494: char *cp, *ep;
! 495:
! 496: memset(details, 0, sizeof(*details));
! 497: details->closefrom = -1;
! 498:
! 499: #define SET_STRING(s, n) \
! 500: if (strncmp(s, info[i], sizeof(s) - 1) == 0 && info[i][sizeof(s) - 1]) { \
! 501: details->n = info[i] + sizeof(s) - 1; \
! 502: break; \
! 503: }
! 504:
! 505: for (i = 0; info[i] != NULL; i++) {
! 506: sudo_debug(9, "command info: %s", info[i]);
! 507: switch (info[i][0]) {
! 508: case 'c':
! 509: SET_STRING("chroot=", chroot)
! 510: SET_STRING("command=", command)
! 511: SET_STRING("cwd=", cwd)
! 512: if (strncmp("closefrom=", info[i], sizeof("closefrom=") - 1) == 0) {
! 513: cp = info[i] + sizeof("closefrom=") - 1;
! 514: if (*cp == '\0')
! 515: break;
! 516: errno = 0;
! 517: lval = strtol(cp, &ep, 0);
! 518: if (*cp != '\0' && *ep == '\0' &&
! 519: !(errno == ERANGE &&
! 520: (lval == LONG_MAX || lval == LONG_MIN)) &&
! 521: lval < INT_MAX && lval > INT_MIN) {
! 522: details->closefrom = (int)lval;
! 523: }
! 524: break;
! 525: }
! 526: break;
! 527: case 'l':
! 528: SET_STRING("login_class=", login_class)
! 529: break;
! 530: case 'n':
! 531: /* XXX - bounds check -NZERO to NZERO (inclusive). */
! 532: if (strncmp("nice=", info[i], sizeof("nice=") - 1) == 0) {
! 533: cp = info[i] + sizeof("nice=") - 1;
! 534: if (*cp == '\0')
! 535: break;
! 536: errno = 0;
! 537: lval = strtol(cp, &ep, 0);
! 538: if (*cp != '\0' && *ep == '\0' &&
! 539: !(errno == ERANGE &&
! 540: (lval == LONG_MAX || lval == LONG_MIN)) &&
! 541: lval < INT_MAX && lval > INT_MIN) {
! 542: details->priority = (int)lval;
! 543: SET(details->flags, CD_SET_PRIORITY);
! 544: }
! 545: break;
! 546: }
! 547: if (strncmp("noexec=", info[i], sizeof("noexec=") - 1) == 0) {
! 548: if (atobool(info[i] + sizeof("noexec=") - 1) == TRUE)
! 549: SET(details->flags, CD_NOEXEC);
! 550: break;
! 551: }
! 552: #ifdef _PATH_SUDO_NOEXEC
! 553: /* XXX - deprecated */
! 554: if (strncmp("noexec_file=", info[i], sizeof("noexec_file=") - 1) == 0) {
! 555: noexec_path = info[i] + sizeof("noexec_file=") - 1;
! 556: break;
! 557: }
! 558: #endif /* _PATH_SUDO_NOEXEC */
! 559: break;
! 560: case 'p':
! 561: if (strncmp("preserve_groups=", info[i], sizeof("preserve_groups=") - 1) == 0) {
! 562: if (atobool(info[i] + sizeof("preserve_groups=") - 1) == TRUE)
! 563: SET(details->flags, CD_PRESERVE_GROUPS);
! 564: break;
! 565: }
! 566: break;
! 567: case 'r':
! 568: if (strncmp("runas_egid=", info[i], sizeof("runas_egid=") - 1) == 0) {
! 569: cp = info[i] + sizeof("runas_egid=") - 1;
! 570: if (*cp == '\0')
! 571: break;
! 572: errno = 0;
! 573: ulval = strtoul(cp, &ep, 0);
! 574: if (*cp != '\0' && *ep == '\0' &&
! 575: (errno != ERANGE || ulval != ULONG_MAX)) {
! 576: details->egid = (gid_t)ulval;
! 577: SET(details->flags, CD_SET_EGID);
! 578: }
! 579: break;
! 580: }
! 581: if (strncmp("runas_euid=", info[i], sizeof("runas_euid=") - 1) == 0) {
! 582: cp = info[i] + sizeof("runas_euid=") - 1;
! 583: if (*cp == '\0')
! 584: break;
! 585: errno = 0;
! 586: ulval = strtoul(cp, &ep, 0);
! 587: if (*cp != '\0' && *ep == '\0' &&
! 588: (errno != ERANGE || ulval != ULONG_MAX)) {
! 589: details->euid = (uid_t)ulval;
! 590: SET(details->flags, CD_SET_EUID);
! 591: }
! 592: break;
! 593: }
! 594: if (strncmp("runas_gid=", info[i], sizeof("runas_gid=") - 1) == 0) {
! 595: cp = info[i] + sizeof("runas_gid=") - 1;
! 596: if (*cp == '\0')
! 597: break;
! 598: errno = 0;
! 599: ulval = strtoul(cp, &ep, 0);
! 600: if (*cp != '\0' && *ep == '\0' &&
! 601: (errno != ERANGE || ulval != ULONG_MAX)) {
! 602: details->gid = (gid_t)ulval;
! 603: SET(details->flags, CD_SET_GID);
! 604: }
! 605: break;
! 606: }
! 607: if (strncmp("runas_groups=", info[i], sizeof("runas_groups=") - 1) == 0) {
! 608: int j;
! 609:
! 610: /* count groups, alloc and fill in */
! 611: cp = info[i] + sizeof("runas_groups=") - 1;
! 612: if (*cp == '\0')
! 613: break;
! 614: for (;;) {
! 615: details->ngroups++;
! 616: if ((cp = strchr(cp, ',')) == NULL)
! 617: break;
! 618: cp++;
! 619: }
! 620: if (details->ngroups != 0) {
! 621: details->groups =
! 622: emalloc2(details->ngroups, sizeof(GETGROUPS_T));
! 623: cp = info[i] + sizeof("runas_groups=") - 1;
! 624: for (j = 0; j < details->ngroups;) {
! 625: errno = 0;
! 626: ulval = strtoul(cp, &ep, 0);
! 627: if (*cp == '\0' || (*ep != ',' && *ep != '\0') ||
! 628: (ulval == ULONG_MAX && errno == ERANGE)) {
! 629: break;
! 630: }
! 631: details->groups[j++] = (gid_t)ulval;
! 632: cp = ep + 1;
! 633: }
! 634: details->ngroups = j;
! 635: }
! 636: break;
! 637: }
! 638: if (strncmp("runas_uid=", info[i], sizeof("runas_uid=") - 1) == 0) {
! 639: cp = info[i] + sizeof("runas_uid=") - 1;
! 640: if (*cp == '\0')
! 641: break;
! 642: errno = 0;
! 643: ulval = strtoul(cp, &ep, 0);
! 644: if (*cp != '\0' && *ep == '\0' &&
! 645: (errno != ERANGE || ulval != ULONG_MAX)) {
! 646: details->uid = (uid_t)ulval;
! 647: SET(details->flags, CD_SET_UID);
! 648: }
! 649: break;
! 650: }
! 651: break;
! 652: case 's':
! 653: SET_STRING("selinux_role=", selinux_role)
! 654: SET_STRING("selinux_type=", selinux_type)
! 655: if (strncmp("set_utmp=", info[i], sizeof("set_utmp=") - 1) == 0) {
! 656: if (atobool(info[i] + sizeof("set_utmp=") - 1) == TRUE)
! 657: SET(details->flags, CD_SET_UTMP);
! 658: break;
! 659: }
! 660: if (strncmp("sudoedit=", info[i], sizeof("sudoedit=") - 1) == 0) {
! 661: if (atobool(info[i] + sizeof("sudoedit=") - 1) == TRUE)
! 662: SET(details->flags, CD_SUDOEDIT);
! 663: break;
! 664: }
! 665: break;
! 666: case 't':
! 667: if (strncmp("timeout=", info[i], sizeof("timeout=") - 1) == 0) {
! 668: cp = info[i] + sizeof("timeout=") - 1;
! 669: if (*cp == '\0')
! 670: break;
! 671: errno = 0;
! 672: lval = strtol(cp, &ep, 0);
! 673: if (*cp != '\0' && *ep == '\0' &&
! 674: !(errno == ERANGE &&
! 675: (lval == LONG_MAX || lval == LONG_MIN)) &&
! 676: lval <= INT_MAX && lval >= 0) {
! 677: details->timeout = (int)lval;
! 678: SET(details->flags, CD_SET_TIMEOUT);
! 679: }
! 680: break;
! 681: }
! 682: break;
! 683: case 'u':
! 684: if (strncmp("umask=", info[i], sizeof("umask=") - 1) == 0) {
! 685: cp = info[i] + sizeof("umask=") - 1;
! 686: if (*cp == '\0')
! 687: break;
! 688: errno = 0;
! 689: ulval = strtoul(cp, &ep, 8);
! 690: if (*cp != '\0' && *ep == '\0' &&
! 691: (errno != ERANGE || ulval != ULONG_MAX)) {
! 692: details->umask = (uid_t)ulval;
! 693: SET(details->flags, CD_SET_UMASK);
! 694: }
! 695: break;
! 696: }
! 697: if (strncmp("use_pty=", info[i], sizeof("use_pty=") - 1) == 0) {
! 698: if (atobool(info[i] + sizeof("use_pty=") - 1) == TRUE)
! 699: SET(details->flags, CD_USE_PTY);
! 700: break;
! 701: }
! 702: SET_STRING("utmp_user=", utmp_user)
! 703: break;
! 704: }
! 705: }
! 706:
! 707: if (!ISSET(details->flags, CD_SET_EUID))
! 708: details->euid = details->uid;
! 709:
! 710: #ifdef HAVE_SELINUX
! 711: if (details->selinux_role != NULL && is_selinux_enabled() > 0)
! 712: SET(details->flags, CD_RBAC_ENABLED);
! 713: #endif
! 714: }
! 715:
! 716: /*
! 717: * Disable core dumps to avoid dropping a core with user password in it.
! 718: * We will reset this limit before executing the command.
! 719: * Not all operating systems disable core dumps for setuid processes.
! 720: */
! 721: static void
! 722: disable_coredumps(void)
! 723: {
! 724: #if defined(__linux__) || (defined(RLIMIT_CORE) && !defined(SUDO_DEVEL))
! 725: struct rlimit rl;
! 726: #endif
! 727:
! 728: #if defined(__linux__)
! 729: /*
! 730: * Unlimit the number of processes since Linux's setuid() will
! 731: * apply resource limits when changing uid and return EAGAIN if
! 732: * nproc would be violated by the uid switch.
! 733: */
! 734: (void) getrlimit(RLIMIT_NPROC, &nproclimit);
! 735: rl.rlim_cur = rl.rlim_max = RLIM_INFINITY;
! 736: if (setrlimit(RLIMIT_NPROC, &rl)) {
! 737: memcpy(&rl, &nproclimit, sizeof(struct rlimit));
! 738: rl.rlim_cur = rl.rlim_max;
! 739: (void)setrlimit(RLIMIT_NPROC, &rl);
! 740: }
! 741: #endif /* __linux__ */
! 742: #if defined(RLIMIT_CORE) && !defined(SUDO_DEVEL)
! 743: /*
! 744: * Turn off core dumps.
! 745: */
! 746: (void) getrlimit(RLIMIT_CORE, &corelimit);
! 747: memcpy(&rl, &corelimit, sizeof(struct rlimit));
! 748: rl.rlim_cur = 0;
! 749: (void) setrlimit(RLIMIT_CORE, &rl);
! 750: #endif /* RLIMIT_CORE && !SUDO_DEVEL */
! 751: }
! 752:
! 753: #ifdef HAVE_PROJECT_H
! 754: static void
! 755: set_project(struct passwd *pw)
! 756: {
! 757: struct project proj;
! 758: char buf[PROJECT_BUFSZ];
! 759: int errval;
! 760:
! 761: /*
! 762: * Collect the default project for the user and settaskid
! 763: */
! 764: setprojent();
! 765: if (getdefaultproj(pw->pw_name, &proj, buf, sizeof(buf)) != NULL) {
! 766: errval = setproject(proj.pj_name, pw->pw_name, TASK_NORMAL);
! 767: switch(errval) {
! 768: case 0:
! 769: break;
! 770: case SETPROJ_ERR_TASK:
! 771: switch (errno) {
! 772: case EAGAIN:
! 773: warningx(_("resource control limit has been reached"));
! 774: break;
! 775: case ESRCH:
! 776: warningx(_("user \"%s\" is not a member of project \"%s\""),
! 777: pw->pw_name, proj.pj_name);
! 778: break;
! 779: case EACCES:
! 780: warningx(_("the invoking task is final"));
! 781: break;
! 782: default:
! 783: warningx(_("could not join project \"%s\""), proj.pj_name);
! 784: }
! 785: case SETPROJ_ERR_POOL:
! 786: switch (errno) {
! 787: case EACCES:
! 788: warningx(_("no resource pool accepting default bindings "
! 789: "exists for project \"%s\""), proj.pj_name);
! 790: break;
! 791: case ESRCH:
! 792: warningx(_("specified resource pool does not exist for "
! 793: "project \"%s\""), proj.pj_name);
! 794: break;
! 795: default:
! 796: warningx(_("could not bind to default resource pool for "
! 797: "project \"%s\""), proj.pj_name);
! 798: }
! 799: break;
! 800: default:
! 801: if (errval <= 0) {
! 802: warningx(_("setproject failed for project \"%s\""), proj.pj_name);
! 803: } else {
! 804: warningx(_("warning, resource control assignment failed for "
! 805: "project \"%s\""), proj.pj_name);
! 806: }
! 807: }
! 808: } else {
! 809: warning("getdefaultproj");
! 810: }
! 811: endprojent();
! 812: }
! 813: #endif /* HAVE_PROJECT_H */
! 814:
! 815: /*
! 816: * Disable execution of child processes in the command we are about
! 817: * to run. On systems with privilege sets, we can remove the exec
! 818: * privilege. On other systems we use LD_PRELOAD and the like.
! 819: */
! 820: static void
! 821: disable_execute(struct command_details *details)
! 822: {
! 823: #ifdef _PATH_SUDO_NOEXEC
! 824: char *cp, **ev, **nenvp;
! 825: int env_len = 0, env_size = 128;
! 826: #endif /* _PATH_SUDO_NOEXEC */
! 827:
! 828: #ifdef HAVE_PRIV_SET
! 829: /* Solaris privileges, remove PRIV_PROC_EXEC post-execve. */
! 830: if (priv_set(PRIV_OFF, PRIV_LIMIT, "PRIV_PROC_EXEC", NULL) == 0)
! 831: return;
! 832: warning(_("unable to remove PRIV_PROC_EXEC from PRIV_LIMIT"));
! 833: #endif /* HAVE_PRIV_SET */
! 834:
! 835: #ifdef _PATH_SUDO_NOEXEC
! 836: nenvp = emalloc2(env_size, sizeof(char *));
! 837: for (ev = details->envp; *ev != NULL; ev++) {
! 838: if (env_len + 2 > env_size) {
! 839: env_size += 128;
! 840: nenvp = erealloc3(nenvp, env_size, sizeof(char *));
! 841: }
! 842: /*
! 843: * Prune out existing preloaded libraries.
! 844: * XXX - should save and append instead of replacing.
! 845: */
! 846: # if defined(__darwin__) || defined(__APPLE__)
! 847: if (strncmp(*ev, "DYLD_INSERT_LIBRARIES=", sizeof("DYLD_INSERT_LIBRARIES=") - 1) == 0)
! 848: continue;
! 849: if (strncmp(*ev, "DYLD_FORCE_FLAT_NAMESPACE=", sizeof("DYLD_INSERT_LIBRARIES=") - 1) == 0)
! 850: continue;
! 851: # elif defined(__osf__) || defined(__sgi)
! 852: if (strncmp(*ev, "_RLD_LIST=", sizeof("_RLD_LIST=") - 1) == 0)
! 853: continue;
! 854: # elif defined(_AIX)
! 855: if (strncmp(*ev, "LDR_PRELOAD=", sizeof("LDR_PRELOAD=") - 1) == 0)
! 856: continue;
! 857: # else
! 858: if (strncmp(*ev, "LD_PRELOAD=", sizeof("LD_PRELOAD=") - 1) == 0)
! 859: continue;
! 860: # endif
! 861: nenvp[env_len++] = *ev;
! 862: }
! 863:
! 864: /*
! 865: * Preload a noexec file? For a list of LD_PRELOAD-alikes, see
! 866: * http://www.fortran-2000.com/ArnaudRecipes/sharedlib.html
! 867: * XXX - need to support 32-bit and 64-bit variants
! 868: */
! 869: # if defined(__darwin__) || defined(__APPLE__)
! 870: nenvp[env_len++] = "DYLD_FORCE_FLAT_NAMESPACE=";
! 871: cp = fmt_string("DYLD_INSERT_LIBRARIES", noexec_path);
! 872: # elif defined(__osf__) || defined(__sgi)
! 873: easprintf(&cp, "_RLD_LIST=%s:DEFAULT", noexec_path);
! 874: # elif defined(_AIX)
! 875: cp = fmt_string("LDR_PRELOAD", noexec_path);
! 876: # else
! 877: cp = fmt_string("LD_PRELOAD", noexec_path);
! 878: # endif
! 879: if (cp == NULL)
! 880: error(1, NULL);
! 881: nenvp[env_len++] = cp;
! 882: nenvp[env_len] = NULL;
! 883:
! 884: details->envp = nenvp;
! 885: #endif /* _PATH_SUDO_NOEXEC */
! 886: }
! 887:
! 888: /*
! 889: * Setup the execution environment immediately prior to the call to execve()
! 890: * Returns TRUE on success and FALSE on failure.
! 891: */
! 892: int
! 893: exec_setup(struct command_details *details, const char *ptyname, int ptyfd)
! 894: {
! 895: int rval = FALSE;
! 896: struct passwd *pw;
! 897:
! 898: #ifdef HAVE_SETAUTHDB
! 899: aix_setauthdb(IDtouser(details->euid));
! 900: #endif
! 901: pw = getpwuid(details->euid);
! 902: #ifdef HAVE_SETAUTHDB
! 903: aix_restoreauthdb();
! 904: #endif
! 905:
! 906: /*
! 907: * Call policy plugin's session init before other setup occurs.
! 908: * The session init code is expected to print an error as needed.
! 909: */
! 910: if (policy_init_session(&policy_plugin, pw) != TRUE)
! 911: goto done;
! 912:
! 913: #ifdef HAVE_SELINUX
! 914: if (ISSET(details->flags, CD_RBAC_ENABLED)) {
! 915: if (selinux_setup(details->selinux_role, details->selinux_type,
! 916: ptyname ? ptyname : user_details.tty, ptyfd) == -1)
! 917: goto done;
! 918: }
! 919: #endif
! 920:
! 921: if (pw != NULL) {
! 922: #ifdef HAVE_PROJECT_H
! 923: set_project(pw);
! 924: #endif
! 925: #ifdef HAVE_GETUSERATTR
! 926: aix_prep_user(pw->pw_name, ptyname ? ptyname : user_details.tty);
! 927: #endif
! 928: #ifdef HAVE_LOGIN_CAP_H
! 929: if (details->login_class) {
! 930: int flags;
! 931: login_cap_t *lc;
! 932:
! 933: /*
! 934: * We only use setusercontext() to set the nice value and rlimits.
! 935: */
! 936: lc = login_getclass((char *)details->login_class);
! 937: if (!lc) {
! 938: warningx(_("unknown login class %s"), details->login_class);
! 939: errno = ENOENT;
! 940: goto done;
! 941: }
! 942: flags = LOGIN_SETRESOURCES|LOGIN_SETPRIORITY;
! 943: if (setusercontext(lc, pw, pw->pw_uid, flags)) {
! 944: if (pw->pw_uid != ROOT_UID) {
! 945: warning(_("unable to set user context"));
! 946: goto done;
! 947: } else
! 948: warning(_("unable to set user context"));
! 949: }
! 950: }
! 951: #endif /* HAVE_LOGIN_CAP_H */
! 952: }
! 953:
! 954: /*
! 955: * Set groups, including supplementary group vector.
! 956: */
! 957: #ifdef HAVE_SETEUID
! 958: if (ISSET(details->flags, CD_SET_EGID) && setegid(details->egid)) {
! 959: warning(_("unable to set effective gid to runas gid %u"),
! 960: (unsigned int)details->egid);
! 961: goto done;
! 962: }
! 963: #endif
! 964: if (ISSET(details->flags, CD_SET_GID) && setgid(details->gid)) {
! 965: warning(_("unable to set gid to runas gid %u"),
! 966: (unsigned int)details->gid);
! 967: goto done;
! 968: }
! 969:
! 970: if (!ISSET(details->flags, CD_PRESERVE_GROUPS)) {
! 971: if (details->ngroups >= 0) {
! 972: if (sudo_setgroups(details->ngroups, details->groups) < 0) {
! 973: warning(_("unable to set supplementary group IDs"));
! 974: goto done;
! 975: }
! 976: }
! 977: }
! 978:
! 979: if (ISSET(details->flags, CD_SET_PRIORITY)) {
! 980: if (setpriority(PRIO_PROCESS, 0, details->priority) != 0) {
! 981: warning(_("unable to set process priority"));
! 982: goto done;
! 983: }
! 984: }
! 985: if (ISSET(details->flags, CD_SET_UMASK))
! 986: (void) umask(details->umask);
! 987: if (details->chroot) {
! 988: if (chroot(details->chroot) != 0 || chdir("/") != 0) {
! 989: warning(_("unable to change root to %s"), details->chroot);
! 990: goto done;
! 991: }
! 992: }
! 993:
! 994: if (ISSET(details->flags, CD_NOEXEC))
! 995: disable_execute(details);
! 996:
! 997: #ifdef HAVE_SETRESUID
! 998: if (setresuid(details->uid, details->euid, details->euid) != 0) {
! 999: warning(_("unable to change to runas uid (%u, %u)"), details->uid,
! 1000: details->euid);
! 1001: goto done;
! 1002: }
! 1003: #elif HAVE_SETREUID
! 1004: if (setreuid(details->uid, details->euid) != 0) {
! 1005: warning(_("unable to change to runas uid (%u, %u)"),
! 1006: (unsigned int)details->uid, (unsigned int)details->euid);
! 1007: goto done;
! 1008: }
! 1009: #else
! 1010: if (seteuid(details->euid) != 0 || setuid(details->euid) != 0) {
! 1011: warning(_("unable to change to runas uid (%u, %u)"), details->uid,
! 1012: details->euid);
! 1013: goto done;
! 1014: }
! 1015: #endif /* !HAVE_SETRESUID && !HAVE_SETREUID */
! 1016:
! 1017: /*
! 1018: * Only change cwd if we have chroot()ed or the policy modules
! 1019: * specifies a different cwd. Must be done after uid change.
! 1020: */
! 1021: if (details->cwd) {
! 1022: if (details->chroot || strcmp(details->cwd, user_details.cwd) != 0) {
! 1023: /* Note: cwd is relative to the new root, if any. */
! 1024: if (chdir(details->cwd) != 0) {
! 1025: warning(_("unable to change directory to %s"), details->cwd);
! 1026: goto done;
! 1027: }
! 1028: }
! 1029: }
! 1030:
! 1031: /*
! 1032: * Restore nproc resource limit if pam_limits didn't do it for us.
! 1033: * We must do this *after* the uid change to avoid potential EAGAIN
! 1034: * from setuid().
! 1035: */
! 1036: #if defined(__linux__)
! 1037: {
! 1038: struct rlimit rl;
! 1039: if (getrlimit(RLIMIT_NPROC, &rl) == 0) {
! 1040: if (rl.rlim_cur == RLIM_INFINITY && rl.rlim_max == RLIM_INFINITY)
! 1041: (void) setrlimit(RLIMIT_NPROC, &nproclimit);
! 1042: }
! 1043: }
! 1044: #endif
! 1045:
! 1046: rval = TRUE;
! 1047:
! 1048: done:
! 1049: return rval;
! 1050: }
! 1051:
! 1052: /*
! 1053: * Run the command and wait for it to complete.
! 1054: */
! 1055: int
! 1056: run_command(struct command_details *details)
! 1057: {
! 1058: struct plugin_container *plugin;
! 1059: struct command_status cstat;
! 1060: int exitcode = 1;
! 1061:
! 1062: cstat.type = CMD_INVALID;
! 1063: cstat.val = 0;
! 1064:
! 1065: sudo_execve(details, &cstat);
! 1066:
! 1067: switch (cstat.type) {
! 1068: case CMD_ERRNO:
! 1069: /* exec_setup() or execve() returned an error. */
! 1070: sudo_debug(9, "calling policy close with errno");
! 1071: policy_close(&policy_plugin, 0, cstat.val);
! 1072: tq_foreach_fwd(&io_plugins, plugin) {
! 1073: sudo_debug(9, "calling I/O close with errno");
! 1074: iolog_close(plugin, 0, cstat.val);
! 1075: }
! 1076: exitcode = 1;
! 1077: break;
! 1078: case CMD_WSTATUS:
! 1079: /* Command ran, exited or was killed. */
! 1080: sudo_debug(9, "calling policy close with wait status");
! 1081: policy_close(&policy_plugin, cstat.val, 0);
! 1082: tq_foreach_fwd(&io_plugins, plugin) {
! 1083: sudo_debug(9, "calling I/O close with wait status");
! 1084: iolog_close(plugin, cstat.val, 0);
! 1085: }
! 1086: if (WIFEXITED(cstat.val))
! 1087: exitcode = WEXITSTATUS(cstat.val);
! 1088: else if (WIFSIGNALED(cstat.val))
! 1089: exitcode = WTERMSIG(cstat.val) | 128;
! 1090: break;
! 1091: default:
! 1092: warningx(_("unexpected child termination condition: %d"), cstat.type);
! 1093: break;
! 1094: }
! 1095: return exitcode;
! 1096: }
! 1097:
! 1098: static int
! 1099: policy_open(struct plugin_container *plugin, char * const settings[],
! 1100: char * const user_info[], char * const user_env[])
! 1101: {
! 1102: return plugin->u.policy->open(SUDO_API_VERSION, sudo_conversation,
! 1103: _sudo_printf, settings, user_info, user_env);
! 1104: }
! 1105:
! 1106: static void
! 1107: policy_close(struct plugin_container *plugin, int exit_status, int error)
! 1108: {
! 1109: plugin->u.policy->close(exit_status, error);
! 1110: }
! 1111:
! 1112: static int
! 1113: policy_show_version(struct plugin_container *plugin, int verbose)
! 1114: {
! 1115: return plugin->u.policy->show_version(verbose);
! 1116: }
! 1117:
! 1118: static int
! 1119: policy_check(struct plugin_container *plugin, int argc, char * const argv[],
! 1120: char *env_add[], char **command_info[], char **argv_out[],
! 1121: char **user_env_out[])
! 1122: {
! 1123: return plugin->u.policy->check_policy(argc, argv, env_add, command_info,
! 1124: argv_out, user_env_out);
! 1125: }
! 1126:
! 1127: static int
! 1128: policy_list(struct plugin_container *plugin, int argc, char * const argv[],
! 1129: int verbose, const char *list_user)
! 1130: {
! 1131: if (plugin->u.policy->list == NULL) {
! 1132: warningx(_("policy plugin %s does not support listing privileges"),
! 1133: plugin->name);
! 1134: return FALSE;
! 1135: }
! 1136: return plugin->u.policy->list(argc, argv, verbose, list_user);
! 1137: }
! 1138:
! 1139: static int
! 1140: policy_validate(struct plugin_container *plugin)
! 1141: {
! 1142: if (plugin->u.policy->validate == NULL) {
! 1143: warningx(_("policy plugin %s does not support the -v option"),
! 1144: plugin->name);
! 1145: return FALSE;
! 1146: }
! 1147: return plugin->u.policy->validate();
! 1148: }
! 1149:
! 1150: static void
! 1151: policy_invalidate(struct plugin_container *plugin, int remove)
! 1152: {
! 1153: if (plugin->u.policy->invalidate == NULL) {
! 1154: errorx(1, _("policy plugin %s does not support the -k/-K options"),
! 1155: plugin->name);
! 1156: }
! 1157: plugin->u.policy->invalidate(remove);
! 1158: }
! 1159:
! 1160: static int
! 1161: policy_init_session(struct plugin_container *plugin, struct passwd *pwd)
! 1162: {
! 1163: if (plugin->u.policy->init_session)
! 1164: return plugin->u.policy->init_session(pwd);
! 1165: return TRUE;
! 1166: }
! 1167:
! 1168: static int
! 1169: iolog_open(struct plugin_container *plugin, char * const settings[],
! 1170: char * const user_info[], char * const command_info[],
! 1171: int argc, char * const argv[], char * const user_env[])
! 1172: {
! 1173: int rval;
! 1174:
! 1175: /*
! 1176: * Backwards compatibility for API major 1, minor 0
! 1177: */
! 1178: switch (plugin->u.generic->version) {
! 1179: case SUDO_API_MKVERSION(1, 0):
! 1180: rval = plugin->u.io_1_0->open(plugin->u.io_1_0->version,
! 1181: sudo_conversation, _sudo_printf, settings, user_info, argc, argv,
! 1182: user_env);
! 1183: break;
! 1184: default:
! 1185: rval = plugin->u.io->open(SUDO_API_VERSION, sudo_conversation,
! 1186: _sudo_printf, settings, user_info, command_info, argc, argv,
! 1187: user_env);
! 1188: }
! 1189: return rval;
! 1190: }
! 1191:
! 1192: static void
! 1193: iolog_close(struct plugin_container *plugin, int exit_status, int error)
! 1194: {
! 1195: plugin->u.io->close(exit_status, error);
! 1196: }
! 1197:
! 1198: static int
! 1199: iolog_show_version(struct plugin_container *plugin, int verbose)
! 1200: {
! 1201: return plugin->u.io->show_version(verbose);
! 1202: }
! 1203:
! 1204: /*
! 1205: * Simple debugging/logging.
! 1206: */
! 1207: void
! 1208: sudo_debug(int level, const char *fmt, ...)
! 1209: {
! 1210: va_list ap;
! 1211: char *buf;
! 1212:
! 1213: if (level > debug_level)
! 1214: return;
! 1215:
! 1216: /* Bracket fmt with program name and a newline to make it a single write */
! 1217: va_start(ap, fmt);
! 1218: evasprintf(&buf, fmt, ap);
! 1219: va_end(ap);
! 1220: fprintf(stderr, "%s: %s\n", getprogname(), buf);
! 1221: efree(buf);
! 1222: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to sudo.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 / src