1: /*
2: * Copyright (c) 2009-2013 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/stat.h>
25: #include <sys/wait.h>
26: #include <sys/socket.h>
27: #include <sys/time.h>
28: #include <sys/resource.h>
29: #include <stdio.h>
30: #ifdef STDC_HEADERS
31: # include <stdlib.h>
32: # include <stddef.h>
33: #else
34: # ifdef HAVE_STDLIB_H
35: # include <stdlib.h>
36: # endif
37: #endif /* STDC_HEADERS */
38: #ifdef HAVE_STRING_H
39: # if defined(HAVE_MEMORY_H) && !defined(STDC_HEADERS)
40: # include <memory.h>
41: # endif
42: # include <string.h>
43: #endif /* HAVE_STRING_H */
44: #ifdef HAVE_STRINGS_H
45: # include <strings.h>
46: #endif /* HAVE_STRINGS_H */
47: #ifdef HAVE_UNISTD_H
48: # include <unistd.h>
49: #endif /* HAVE_UNISTD_H */
50: #include <ctype.h>
51: #include <errno.h>
52: #include <fcntl.h>
53: #include <limits.h>
54: #include <signal.h>
55: #include <grp.h>
56: #include <pwd.h>
57: #if TIME_WITH_SYS_TIME
58: # include <time.h>
59: #endif
60: #ifdef HAVE_LOGIN_CAP_H
61: # include <login_cap.h>
62: # ifndef LOGIN_SETENV
63: # define LOGIN_SETENV 0
64: # endif
65: #endif
66: #ifdef HAVE_PROJECT_H
67: # include <project.h>
68: # include <sys/task.h>
69: #endif
70: #ifdef HAVE_SELINUX
71: # include <selinux/selinux.h>
72: #endif
73: #ifdef HAVE_SETAUTHDB
74: # include <usersec.h>
75: #endif /* HAVE_SETAUTHDB */
76: #if defined(HAVE_GETPRPWNAM) && defined(HAVE_SET_AUTH_PARAMETERS)
77: # ifdef __hpux
78: # undef MAXINT
79: # include <hpsecurity.h>
80: # else
81: # include <sys/security.h>
82: # endif /* __hpux */
83: # include <prot.h>
84: #endif /* HAVE_GETPRPWNAM && HAVE_SET_AUTH_PARAMETERS */
85:
86: #include "sudo.h"
87: #include "sudo_plugin.h"
88: #include "sudo_plugin_int.h"
89: #include "sudo_usage.h"
90:
91: /*
92: * Local variables
93: */
94: struct plugin_container policy_plugin;
95: struct plugin_container_list io_plugins;
96: struct user_details user_details;
97: const char *list_user, *runas_user, *runas_group; /* extern for parse_args.c */
98: static struct command_details command_details;
99: static int sudo_mode;
100:
101: /*
102: * Local functions
103: */
104: static void fix_fds(void);
105: static void disable_coredumps(void);
106: static void sudo_check_suid(const char *path);
107: static char **get_user_info(struct user_details *);
108: static void command_info_to_details(char * const info[],
109: struct command_details *details);
110:
111: /* Policy plugin convenience functions. */
112: static int policy_open(struct plugin_container *plugin, char * const settings[],
113: char * const user_info[], char * const user_env[]);
114: static void policy_close(struct plugin_container *plugin, int exit_status,
115: int error);
116: static int policy_show_version(struct plugin_container *plugin, int verbose);
117: static int policy_check(struct plugin_container *plugin, int argc,
118: char * const argv[], char *env_add[], char **command_info[],
119: char **argv_out[], char **user_env_out[]);
120: static int policy_list(struct plugin_container *plugin, int argc,
121: char * const argv[], int verbose, const char *list_user);
122: static int policy_validate(struct plugin_container *plugin);
123: static void policy_invalidate(struct plugin_container *plugin, int remove);
124:
125: /* I/O log plugin convenience functions. */
126: static int iolog_open(struct plugin_container *plugin, char * const settings[],
127: char * const user_info[], char * const command_details[],
128: int argc, char * const argv[], char * const user_env[]);
129: static void iolog_close(struct plugin_container *plugin, int exit_status,
130: int error);
131: static int iolog_show_version(struct plugin_container *plugin, int verbose);
132: static void iolog_unlink(struct plugin_container *plugin);
133:
134: #ifdef RLIMIT_CORE
135: static struct rlimit corelimit;
136: #endif /* RLIMIT_CORE */
137: #if defined(__linux__)
138: static struct rlimit nproclimit;
139: #endif
140:
141: __dso_public int main(int argc, char *argv[], char *envp[]);
142:
143: int
144: main(int argc, char *argv[], char *envp[])
145: {
146: int nargc, ok, exitcode = 0;
147: char **nargv, **settings, **env_add;
148: char **user_info, **command_info, **argv_out, **user_env_out;
149: struct plugin_container *plugin, *next;
150: sigset_t mask;
151: debug_decl(main, SUDO_DEBUG_MAIN)
152:
153: os_init(argc, argv, envp);
154:
155: setlocale(LC_ALL, "");
156: bindtextdomain(PACKAGE_NAME, LOCALEDIR);
157: textdomain(PACKAGE_NAME);
158:
159: #ifdef HAVE_TZSET
160: (void) tzset();
161: #endif /* HAVE_TZSET */
162:
163: /* Must be done before we do any password lookups */
164: #if defined(HAVE_GETPRPWNAM) && defined(HAVE_SET_AUTH_PARAMETERS)
165: (void) set_auth_parameters(argc, argv);
166: # ifdef HAVE_INITPRIVS
167: initprivs();
168: # endif
169: #endif /* HAVE_GETPRPWNAM && HAVE_SET_AUTH_PARAMETERS */
170:
171: /* Make sure we are setuid root. */
172: sudo_check_suid(argv[0]);
173:
174: /* Reset signal mask, save signal state and make sure fds 0-2 are open. */
175: (void) sigemptyset(&mask);
176: (void) sigprocmask(SIG_SETMASK, &mask, NULL);
177: save_signals();
178: fix_fds();
179:
180: /* Read sudo.conf. */
181: sudo_conf_read(NULL);
182:
183: /* Fill in user_info with user name, uid, cwd, etc. */
184: memset(&user_details, 0, sizeof(user_details));
185: user_info = get_user_info(&user_details);
186:
187: /* Disable core dumps if not enabled in sudo.conf. */
188: disable_coredumps();
189:
190: /* Parse command line arguments. */
191: sudo_mode = parse_args(argc, argv, &nargc, &nargv, &settings, &env_add);
192: sudo_debug_printf(SUDO_DEBUG_DEBUG, "sudo_mode %d", sudo_mode);
193:
194: /* Print sudo version early, in case of plugin init failure. */
195: if (ISSET(sudo_mode, MODE_VERSION)) {
196: printf(_("Sudo version %s\n"), PACKAGE_VERSION);
197: if (user_details.uid == ROOT_UID)
198: (void) printf(_("Configure options: %s\n"), CONFIGURE_ARGS);
199: }
200:
201: /* Load plugins. */
202: if (!sudo_load_plugins(&policy_plugin, &io_plugins))
203: fatalx(_("fatal error, unable to load plugins"));
204:
205: /* Open policy plugin. */
206: ok = policy_open(&policy_plugin, settings, user_info, envp);
207: if (ok != 1) {
208: if (ok == -2)
209: usage(1);
210: else
211: fatalx(_("unable to initialize policy plugin"));
212: }
213:
214: init_signals();
215:
216: switch (sudo_mode & MODE_MASK) {
217: case MODE_VERSION:
218: policy_show_version(&policy_plugin, !user_details.uid);
219: tq_foreach_fwd(&io_plugins, plugin) {
220: ok = iolog_open(plugin, settings, user_info, NULL,
221: nargc, nargv, envp);
222: if (ok != -1)
223: iolog_show_version(plugin, !user_details.uid);
224: }
225: break;
226: case MODE_VALIDATE:
227: case MODE_VALIDATE|MODE_INVALIDATE:
228: ok = policy_validate(&policy_plugin);
229: exit(ok != 1);
230: case MODE_KILL:
231: case MODE_INVALIDATE:
232: policy_invalidate(&policy_plugin, sudo_mode == MODE_KILL);
233: exit(0);
234: break;
235: case MODE_CHECK:
236: case MODE_CHECK|MODE_INVALIDATE:
237: case MODE_LIST:
238: case MODE_LIST|MODE_INVALIDATE:
239: ok = policy_list(&policy_plugin, nargc, nargv,
240: ISSET(sudo_mode, MODE_LONG_LIST), list_user);
241: exit(ok != 1);
242: case MODE_EDIT:
243: case MODE_RUN:
244: ok = policy_check(&policy_plugin, nargc, nargv, env_add,
245: &command_info, &argv_out, &user_env_out);
246: sudo_debug_printf(SUDO_DEBUG_INFO, "policy plugin returns %d", ok);
247: if (ok != 1) {
248: if (ok == -2)
249: usage(1);
250: exit(1); /* plugin printed error message */
251: }
252: /* Open I/O plugins once policy plugin succeeds. */
253: for (plugin = io_plugins.first; plugin != NULL; plugin = next) {
254: next = plugin->next;
255: ok = iolog_open(plugin, settings, user_info,
256: command_info, nargc, nargv, envp);
257: switch (ok) {
258: case 1:
259: break;
260: case 0:
261: /* I/O plugin asked to be disabled, remove and free. */
262: iolog_unlink(plugin);
263: break;
264: case -2:
265: usage(1);
266: break;
267: default:
268: fatalx(_("error initializing I/O plugin %s"),
269: plugin->name);
270: }
271: }
272: /* Setup command details and run command/edit. */
273: command_info_to_details(command_info, &command_details);
274: command_details.argv = argv_out;
275: command_details.envp = user_env_out;
276: if (ISSET(sudo_mode, MODE_BACKGROUND))
277: SET(command_details.flags, CD_BACKGROUND);
278: /* Become full root (not just setuid) so user cannot kill us. */
279: if (setuid(ROOT_UID) == -1)
280: warning("setuid(%d)", ROOT_UID);
281: /* Restore coredumpsize resource limit before running. */
282: #ifdef RLIMIT_CORE
283: if (sudo_conf_disable_coredump())
284: (void) setrlimit(RLIMIT_CORE, &corelimit);
285: #endif /* RLIMIT_CORE */
286: if (ISSET(command_details.flags, CD_SUDOEDIT)) {
287: exitcode = sudo_edit(&command_details);
288: } else {
289: exitcode = run_command(&command_details);
290: }
291: /* The close method was called by sudo_edit/run_command. */
292: break;
293: default:
294: fatalx(_("unexpected sudo mode 0x%x"), sudo_mode);
295: }
296: sudo_debug_exit_int(__func__, __FILE__, __LINE__, sudo_debug_subsys, exitcode);
297: exit(exitcode);
298: }
299:
300: int
301: os_init_common(int argc, char *argv[], char *envp[])
302: {
303: #if !defined(HAVE_GETPROGNAME) && !defined(HAVE___PROGNAME)
304: if (argc > 0)
305: setprogname(argv[0]);
306: #endif
307: return 0;
308: }
309:
310: /*
311: * Ensure that stdin, stdout and stderr are open; set to /dev/null if not.
312: * Some operating systems do this automatically in the kernel or libc.
313: */
314: static void
315: fix_fds(void)
316: {
317: int miss[3], devnull = -1;
318: debug_decl(fix_fds, SUDO_DEBUG_UTIL)
319:
320: /*
321: * stdin, stdout and stderr must be open; set them to /dev/null
322: * if they are closed.
323: */
324: miss[STDIN_FILENO] = fcntl(STDIN_FILENO, F_GETFL, 0) == -1;
325: miss[STDOUT_FILENO] = fcntl(STDOUT_FILENO, F_GETFL, 0) == -1;
326: miss[STDERR_FILENO] = fcntl(STDERR_FILENO, F_GETFL, 0) == -1;
327: if (miss[STDIN_FILENO] || miss[STDOUT_FILENO] || miss[STDERR_FILENO]) {
328: if ((devnull = open(_PATH_DEVNULL, O_RDWR, 0644)) == -1)
329: fatal(_("unable to open %s"), _PATH_DEVNULL);
330: if (miss[STDIN_FILENO] && dup2(devnull, STDIN_FILENO) == -1)
331: fatal("dup2");
332: if (miss[STDOUT_FILENO] && dup2(devnull, STDOUT_FILENO) == -1)
333: fatal("dup2");
334: if (miss[STDERR_FILENO] && dup2(devnull, STDERR_FILENO) == -1)
335: fatal("dup2");
336: if (devnull > STDERR_FILENO)
337: close(devnull);
338: }
339: debug_return;
340: }
341:
342: /*
343: * Allocate space for groups and fill in using getgrouplist()
344: * for when we cannot (or don't want to) use getgroups().
345: */
346: static int
347: fill_group_list(struct user_details *ud, int system_maxgroups)
348: {
349: int tries, rval = -1;
350: debug_decl(fill_group_list, SUDO_DEBUG_UTIL)
351:
352: /*
353: * If user specified a max number of groups, use it, otherwise keep
354: * trying getgrouplist() until we have enough room in the array.
355: */
356: ud->ngroups = sudo_conf_max_groups();
357: if (ud->ngroups != -1) {
358: ud->groups = emalloc2(ud->ngroups, sizeof(GETGROUPS_T));
359: /* No error on insufficient space if user specified max_groups. */
360: (void)getgrouplist(ud->username, ud->gid, ud->groups, &ud->ngroups);
361: rval = 0;
362: } else {
363: /*
364: * It is possible to belong to more groups in the group database
365: * than NGROUPS_MAX. We start off with NGROUPS_MAX * 4 entries
366: * and double this as needed.
367: */
368: ud->groups = NULL;
369: ud->ngroups = system_maxgroups << 1;
370: for (tries = 0; tries < 10 && rval == -1; tries++) {
371: ud->ngroups <<= 1;
372: efree(ud->groups);
373: ud->groups = emalloc2(ud->ngroups, sizeof(GETGROUPS_T));
374: rval = getgrouplist(ud->username, ud->gid, ud->groups, &ud->ngroups);
375: }
376: }
377: debug_return_int(rval);
378: }
379:
380: static char *
381: get_user_groups(struct user_details *ud)
382: {
383: char *cp, *gid_list = NULL;
384: size_t glsize;
385: int i, len, maxgroups, group_source;
386: debug_decl(get_user_groups, SUDO_DEBUG_UTIL)
387:
388: #if defined(HAVE_SYSCONF) && defined(_SC_NGROUPS_MAX)
389: maxgroups = (int)sysconf(_SC_NGROUPS_MAX);
390: if (maxgroups < 0)
391: #endif
392: maxgroups = NGROUPS_MAX;
393:
394: ud->groups = NULL;
395: group_source = sudo_conf_group_source();
396: if (group_source != GROUP_SOURCE_DYNAMIC) {
397: if ((ud->ngroups = getgroups(0, NULL)) > 0) {
398: /* Use groups from kernel if not too many or source is static. */
399: if (ud->ngroups < maxgroups || group_source == GROUP_SOURCE_STATIC) {
400: ud->groups = emalloc2(ud->ngroups, sizeof(GETGROUPS_T));
401: if (getgroups(ud->ngroups, ud->groups) < 0) {
402: efree(ud->groups);
403: ud->groups = NULL;
404: }
405: }
406: }
407: }
408: if (ud->groups == NULL) {
409: /*
410: * Query group database if kernel list is too small or disabled.
411: * Typically, this is because NFS can only support up to 16 groups.
412: */
413: if (fill_group_list(ud, maxgroups) == -1)
414: fatal(_("unable to get group vector"));
415: }
416:
417: /*
418: * Format group list as a comma-separated string of gids.
419: */
420: glsize = sizeof("groups=") - 1 + (ud->ngroups * (MAX_UID_T_LEN + 1));
421: gid_list = emalloc(glsize);
422: memcpy(gid_list, "groups=", sizeof("groups=") - 1);
423: cp = gid_list + sizeof("groups=") - 1;
424: for (i = 0; i < ud->ngroups; i++) {
425: /* XXX - check rval */
426: len = snprintf(cp, glsize - (cp - gid_list), "%s%u",
427: i ? "," : "", (unsigned int)ud->groups[i]);
428: cp += len;
429: }
430: debug_return_str(gid_list);
431: }
432:
433: /*
434: * Return user information as an array of name=value pairs.
435: * and fill in struct user_details (which shares the same strings).
436: */
437: static char **
438: get_user_info(struct user_details *ud)
439: {
440: char *cp, **user_info, cwd[PATH_MAX], host[HOST_NAME_MAX + 1];
441: struct passwd *pw;
442: int fd, i = 0;
443: debug_decl(get_user_info, SUDO_DEBUG_UTIL)
444:
445: /* XXX - bound check number of entries */
446: user_info = emalloc2(32, sizeof(char *));
447:
448: ud->pid = getpid();
449: ud->ppid = getppid();
450: ud->pgid = getpgid(0);
451: ud->tcpgid = (pid_t)-1;
452: fd = open(_PATH_TTY, O_RDWR|O_NOCTTY|O_NONBLOCK, 0);
453: if (fd != -1) {
454: ud->tcpgid = tcgetpgrp(fd);
455: close(fd);
456: }
457: ud->sid = getsid(0);
458:
459: ud->uid = getuid();
460: ud->euid = geteuid();
461: ud->gid = getgid();
462: ud->egid = getegid();
463:
464: pw = getpwuid(ud->uid);
465: if (pw == NULL)
466: fatalx(_("unknown uid %u: who are you?"), (unsigned int)ud->uid);
467:
468: user_info[i] = fmt_string("user", pw->pw_name);
469: if (user_info[i] == NULL)
470: fatalx(NULL);
471: ud->username = user_info[i] + sizeof("user=") - 1;
472:
473: /* Stash user's shell for use with the -s flag; don't pass to plugin. */
474: if ((ud->shell = getenv("SHELL")) == NULL || ud->shell[0] == '\0') {
475: ud->shell = pw->pw_shell[0] ? pw->pw_shell : _PATH_BSHELL;
476: }
477: ud->shell = estrdup(ud->shell);
478:
479: easprintf(&user_info[++i], "pid=%d", (int)ud->pid);
480: easprintf(&user_info[++i], "ppid=%d", (int)ud->ppid);
481: easprintf(&user_info[++i], "pgid=%d", (int)ud->pgid);
482: easprintf(&user_info[++i], "tcpgid=%d", (int)ud->tcpgid);
483: easprintf(&user_info[++i], "sid=%d", (int)ud->sid);
484:
485: easprintf(&user_info[++i], "uid=%u", (unsigned int)ud->uid);
486: easprintf(&user_info[++i], "euid=%u", (unsigned int)ud->euid);
487: easprintf(&user_info[++i], "gid=%u", (unsigned int)ud->gid);
488: easprintf(&user_info[++i], "egid=%u", (unsigned int)ud->egid);
489:
490: if ((cp = get_user_groups(ud)) != NULL)
491: user_info[++i] = cp;
492:
493: if (getcwd(cwd, sizeof(cwd)) != NULL) {
494: user_info[++i] = fmt_string("cwd", cwd);
495: if (user_info[i] == NULL)
496: fatalx(NULL);
497: ud->cwd = user_info[i] + sizeof("cwd=") - 1;
498: }
499:
500: if ((cp = get_process_ttyname()) != NULL) {
501: user_info[++i] = fmt_string("tty", cp);
502: if (user_info[i] == NULL)
503: fatalx(NULL);
504: ud->tty = user_info[i] + sizeof("tty=") - 1;
505: efree(cp);
506: }
507:
508: if (gethostname(host, sizeof(host)) == 0)
509: host[sizeof(host) - 1] = '\0';
510: else
511: strlcpy(host, "localhost", sizeof(host));
512: user_info[++i] = fmt_string("host", host);
513: if (user_info[i] == NULL)
514: fatalx(NULL);
515: ud->host = user_info[i] + sizeof("host=") - 1;
516:
517: get_ttysize(&ud->ts_lines, &ud->ts_cols);
518: easprintf(&user_info[++i], "lines=%d", ud->ts_lines);
519: easprintf(&user_info[++i], "cols=%d", ud->ts_cols);
520:
521: user_info[++i] = NULL;
522:
523: debug_return_ptr(user_info);
524: }
525:
526: /*
527: * Convert a command_info array into a command_details structure.
528: */
529: static void
530: command_info_to_details(char * const info[], struct command_details *details)
531: {
532: int i;
533: long lval;
534: unsigned long ulval;
535: char *cp, *ep;
536: debug_decl(command_info_to_details, SUDO_DEBUG_PCOMM)
537:
538: memset(details, 0, sizeof(*details));
539: details->closefrom = -1;
540:
541: #define SET_STRING(s, n) \
542: if (strncmp(s, info[i], sizeof(s) - 1) == 0 && info[i][sizeof(s) - 1]) { \
543: details->n = info[i] + sizeof(s) - 1; \
544: break; \
545: }
546:
547: sudo_debug_printf(SUDO_DEBUG_INFO, "command info from plugin:");
548: for (i = 0; info[i] != NULL; i++) {
549: sudo_debug_printf(SUDO_DEBUG_INFO, " %d: %s", i, info[i]);
550: switch (info[i][0]) {
551: case 'c':
552: SET_STRING("chroot=", chroot)
553: SET_STRING("command=", command)
554: SET_STRING("cwd=", cwd)
555: if (strncmp("closefrom=", info[i], sizeof("closefrom=") - 1) == 0) {
556: cp = info[i] + sizeof("closefrom=") - 1;
557: if (*cp == '\0')
558: break;
559: errno = 0;
560: lval = strtol(cp, &ep, 0);
561: if (*cp != '\0' && *ep == '\0' &&
562: !(errno == ERANGE &&
563: (lval == LONG_MAX || lval == LONG_MIN)) &&
564: lval < INT_MAX && lval > INT_MIN) {
565: details->closefrom = (int)lval;
566: }
567: break;
568: }
569: break;
570: case 'e':
571: if (strncmp("exec_background=", info[i], sizeof("exec_background=") - 1) == 0) {
572: if (atobool(info[i] + sizeof("exec_background=") - 1) == true)
573: SET(details->flags, CD_EXEC_BG);
574: break;
575: }
576: break;
577: case 'l':
578: SET_STRING("login_class=", login_class)
579: break;
580: case 'n':
581: /* XXX - bounds check -NZERO to NZERO (inclusive). */
582: if (strncmp("nice=", info[i], sizeof("nice=") - 1) == 0) {
583: cp = info[i] + sizeof("nice=") - 1;
584: if (*cp == '\0')
585: break;
586: errno = 0;
587: lval = strtol(cp, &ep, 0);
588: if (*cp != '\0' && *ep == '\0' &&
589: !(errno == ERANGE &&
590: (lval == LONG_MAX || lval == LONG_MIN)) &&
591: lval < INT_MAX && lval > INT_MIN) {
592: details->priority = (int)lval;
593: SET(details->flags, CD_SET_PRIORITY);
594: }
595: break;
596: }
597: if (strncmp("noexec=", info[i], sizeof("noexec=") - 1) == 0) {
598: if (atobool(info[i] + sizeof("noexec=") - 1) == true)
599: SET(details->flags, CD_NOEXEC);
600: break;
601: }
602: break;
603: case 'p':
604: if (strncmp("preserve_groups=", info[i], sizeof("preserve_groups=") - 1) == 0) {
605: if (atobool(info[i] + sizeof("preserve_groups=") - 1) == true)
606: SET(details->flags, CD_PRESERVE_GROUPS);
607: break;
608: }
609: break;
610: case 'r':
611: if (strncmp("runas_egid=", info[i], sizeof("runas_egid=") - 1) == 0) {
612: cp = info[i] + sizeof("runas_egid=") - 1;
613: if (*cp == '\0')
614: break;
615: errno = 0;
616: ulval = strtoul(cp, &ep, 0);
617: if (*cp != '\0' && *ep == '\0' &&
618: (errno != ERANGE || ulval != ULONG_MAX)) {
619: details->egid = (gid_t)ulval;
620: SET(details->flags, CD_SET_EGID);
621: }
622: break;
623: }
624: if (strncmp("runas_euid=", info[i], sizeof("runas_euid=") - 1) == 0) {
625: cp = info[i] + sizeof("runas_euid=") - 1;
626: if (*cp == '\0')
627: break;
628: errno = 0;
629: ulval = strtoul(cp, &ep, 0);
630: if (*cp != '\0' && *ep == '\0' &&
631: (errno != ERANGE || ulval != ULONG_MAX)) {
632: details->euid = (uid_t)ulval;
633: SET(details->flags, CD_SET_EUID);
634: }
635: break;
636: }
637: if (strncmp("runas_gid=", info[i], sizeof("runas_gid=") - 1) == 0) {
638: cp = info[i] + sizeof("runas_gid=") - 1;
639: if (*cp == '\0')
640: break;
641: errno = 0;
642: ulval = strtoul(cp, &ep, 0);
643: if (*cp != '\0' && *ep == '\0' &&
644: (errno != ERANGE || ulval != ULONG_MAX)) {
645: details->gid = (gid_t)ulval;
646: SET(details->flags, CD_SET_GID);
647: }
648: break;
649: }
650: if (strncmp("runas_groups=", info[i], sizeof("runas_groups=") - 1) == 0) {
651: int j;
652:
653: /* count groups, alloc and fill in */
654: cp = info[i] + sizeof("runas_groups=") - 1;
655: if (*cp == '\0')
656: break;
657: for (;;) {
658: details->ngroups++;
659: if ((cp = strchr(cp, ',')) == NULL)
660: break;
661: cp++;
662: }
663: if (details->ngroups != 0) {
664: details->groups =
665: emalloc2(details->ngroups, sizeof(GETGROUPS_T));
666: cp = info[i] + sizeof("runas_groups=") - 1;
667: for (j = 0; j < details->ngroups;) {
668: errno = 0;
669: ulval = strtoul(cp, &ep, 0);
670: if (*cp == '\0' || (*ep != ',' && *ep != '\0') ||
671: (ulval == ULONG_MAX && errno == ERANGE)) {
672: break;
673: }
674: details->groups[j++] = (gid_t)ulval;
675: cp = ep + 1;
676: }
677: details->ngroups = j;
678: }
679: break;
680: }
681: if (strncmp("runas_uid=", info[i], sizeof("runas_uid=") - 1) == 0) {
682: cp = info[i] + sizeof("runas_uid=") - 1;
683: if (*cp == '\0')
684: break;
685: errno = 0;
686: ulval = strtoul(cp, &ep, 0);
687: if (*cp != '\0' && *ep == '\0' &&
688: (errno != ERANGE || ulval != ULONG_MAX)) {
689: details->uid = (uid_t)ulval;
690: SET(details->flags, CD_SET_UID);
691: }
692: break;
693: }
694: #ifdef HAVE_PRIV_SET
695: if (strncmp("runas_privs=", info[i], sizeof("runas_privs=") - 1) == 0) {
696: const char *endp;
697: cp = info[i] + sizeof("runas_privs=") - 1;
698: if (*cp == '\0')
699: break;
700: errno = 0;
701: details->privs = priv_str_to_set(cp, ",", &endp);
702: if (details->privs == NULL)
703: warning("invalid runas_privs %s", endp);
704: }
705: if (strncmp("runas_limitprivs=", info[i], sizeof("runas_limitprivs=") - 1) == 0) {
706: const char *endp;
707: cp = info[i] + sizeof("runas_limitprivs=") - 1;
708: if (*cp == '\0')
709: break;
710: errno = 0;
711: details->limitprivs = priv_str_to_set(cp, ",", &endp);
712: if (details->limitprivs == NULL)
713: warning("invalid runas_limitprivs %s", endp);
714: }
715: #endif /* HAVE_PRIV_SET */
716: break;
717: case 's':
718: SET_STRING("selinux_role=", selinux_role)
719: SET_STRING("selinux_type=", selinux_type)
720: if (strncmp("set_utmp=", info[i], sizeof("set_utmp=") - 1) == 0) {
721: if (atobool(info[i] + sizeof("set_utmp=") - 1) == true)
722: SET(details->flags, CD_SET_UTMP);
723: break;
724: }
725: if (strncmp("sudoedit=", info[i], sizeof("sudoedit=") - 1) == 0) {
726: if (atobool(info[i] + sizeof("sudoedit=") - 1) == true)
727: SET(details->flags, CD_SUDOEDIT);
728: break;
729: }
730: break;
731: case 't':
732: if (strncmp("timeout=", info[i], sizeof("timeout=") - 1) == 0) {
733: cp = info[i] + sizeof("timeout=") - 1;
734: if (*cp == '\0')
735: break;
736: errno = 0;
737: lval = strtol(cp, &ep, 0);
738: if (*cp != '\0' && *ep == '\0' &&
739: !(errno == ERANGE &&
740: (lval == LONG_MAX || lval == LONG_MIN)) &&
741: lval <= INT_MAX && lval >= 0) {
742: details->timeout = (int)lval;
743: SET(details->flags, CD_SET_TIMEOUT);
744: }
745: break;
746: }
747: break;
748: case 'u':
749: if (strncmp("umask=", info[i], sizeof("umask=") - 1) == 0) {
750: cp = info[i] + sizeof("umask=") - 1;
751: if (*cp == '\0')
752: break;
753: errno = 0;
754: ulval = strtoul(cp, &ep, 8);
755: if (*cp != '\0' && *ep == '\0' &&
756: (errno != ERANGE || ulval != ULONG_MAX)) {
757: details->umask = (uid_t)ulval;
758: SET(details->flags, CD_SET_UMASK);
759: }
760: break;
761: }
762: if (strncmp("use_pty=", info[i], sizeof("use_pty=") - 1) == 0) {
763: if (atobool(info[i] + sizeof("use_pty=") - 1) == true)
764: SET(details->flags, CD_USE_PTY);
765: break;
766: }
767: SET_STRING("utmp_user=", utmp_user)
768: break;
769: }
770: }
771:
772: if (!ISSET(details->flags, CD_SET_EUID))
773: details->euid = details->uid;
774:
775: #ifdef HAVE_SETAUTHDB
776: aix_setauthdb(IDtouser(details->euid));
777: #endif
778: details->pw = getpwuid(details->euid);
779: if (details->pw != NULL && (details->pw = pw_dup(details->pw)) == NULL)
780: fatalx(NULL);
781: #ifdef HAVE_SETAUTHDB
782: aix_restoreauthdb();
783: #endif
784:
785: #ifdef HAVE_SELINUX
786: if (details->selinux_role != NULL && is_selinux_enabled() > 0)
787: SET(details->flags, CD_RBAC_ENABLED);
788: #endif
789: debug_return;
790: }
791:
792: static void
793: sudo_check_suid(const char *path)
794: {
795: struct stat sb;
796: debug_decl(sudo_check_suid, SUDO_DEBUG_PCOMM)
797:
798: if (geteuid() != 0) {
799: if (strchr(path, '/') != NULL && stat(path, &sb) == 0) {
800: /* Try to determine why sudo was not running as root. */
801: if (sb.st_uid != ROOT_UID || !ISSET(sb.st_mode, S_ISUID)) {
802: fatalx(
803: _("%s must be owned by uid %d and have the setuid bit set"),
804: path, ROOT_UID);
805: } else {
806: fatalx(_("effective uid is not %d, is %s on a file system "
807: "with the 'nosuid' option set or an NFS file system without"
808: " root privileges?"), ROOT_UID, path);
809: }
810: } else {
811: fatalx(
812: _("effective uid is not %d, is sudo installed setuid root?"),
813: ROOT_UID);
814: }
815: }
816: debug_return;
817: }
818:
819: /*
820: * Disable core dumps to avoid dropping a core with user password in it.
821: * We will reset this limit before executing the command.
822: * Not all operating systems disable core dumps for setuid processes.
823: */
824: static void
825: disable_coredumps(void)
826: {
827: #if defined(__linux__) || defined(RLIMIT_CORE)
828: struct rlimit rl;
829: #endif
830: debug_decl(disable_coredumps, SUDO_DEBUG_UTIL)
831:
832: #if defined(__linux__)
833: /*
834: * Unlimit the number of processes since Linux's setuid() will
835: * apply resource limits when changing uid and return EAGAIN if
836: * nproc would be violated by the uid switch.
837: */
838: (void) getrlimit(RLIMIT_NPROC, &nproclimit);
839: rl.rlim_cur = rl.rlim_max = RLIM_INFINITY;
840: if (setrlimit(RLIMIT_NPROC, &rl)) {
841: memcpy(&rl, &nproclimit, sizeof(struct rlimit));
842: rl.rlim_cur = rl.rlim_max;
843: (void)setrlimit(RLIMIT_NPROC, &rl);
844: }
845: #endif /* __linux__ */
846: #ifdef RLIMIT_CORE
847: /*
848: * Turn off core dumps?
849: */
850: if (sudo_conf_disable_coredump()) {
851: (void) getrlimit(RLIMIT_CORE, &corelimit);
852: memcpy(&rl, &corelimit, sizeof(struct rlimit));
853: rl.rlim_cur = 0;
854: (void) setrlimit(RLIMIT_CORE, &rl);
855: }
856: #endif /* RLIMIT_CORE */
857: debug_return;
858: }
859:
860: /*
861: * Setup the execution environment immediately prior to the call to execve()
862: * Returns true on success and false on failure.
863: */
864: bool
865: exec_setup(struct command_details *details, const char *ptyname, int ptyfd)
866: {
867: bool rval = false;
868: debug_decl(exec_setup, SUDO_DEBUG_EXEC)
869:
870: #ifdef HAVE_SELINUX
871: if (ISSET(details->flags, CD_RBAC_ENABLED)) {
872: if (selinux_setup(details->selinux_role, details->selinux_type,
873: ptyname ? ptyname : user_details.tty, ptyfd) == -1)
874: goto done;
875: }
876: #endif
877:
878: if (details->pw != NULL) {
879: #ifdef HAVE_PROJECT_H
880: set_project(details->pw);
881: #endif
882: #ifdef HAVE_PRIV_SET
883: if (details->privs != NULL) {
884: if (setppriv(PRIV_SET, PRIV_INHERITABLE, details->privs) != 0) {
885: warning("unable to set privileges");
886: goto done;
887: }
888: }
889: if (details->limitprivs != NULL) {
890: if (setppriv(PRIV_SET, PRIV_LIMIT, details->limitprivs) != 0) {
891: warning("unable to set limit privileges");
892: goto done;
893: }
894: } else if (details->privs != NULL) {
895: if (setppriv(PRIV_SET, PRIV_LIMIT, details->privs) != 0) {
896: warning("unable to set limit privileges");
897: goto done;
898: }
899: }
900: #endif /* HAVE_PRIV_SET */
901:
902: #ifdef HAVE_GETUSERATTR
903: aix_prep_user(details->pw->pw_name, ptyname ? ptyname : user_details.tty);
904: #endif
905: #ifdef HAVE_LOGIN_CAP_H
906: if (details->login_class) {
907: int flags;
908: login_cap_t *lc;
909:
910: /*
911: * We only use setusercontext() to set the nice value and rlimits
912: * unless this is a login shell (sudo -i).
913: */
914: lc = login_getclass((char *)details->login_class);
915: if (!lc) {
916: warningx(_("unknown login class %s"), details->login_class);
917: errno = ENOENT;
918: goto done;
919: }
920: if (ISSET(sudo_mode, MODE_LOGIN_SHELL)) {
921: /* Set everything except user, group and login name. */
922: flags = LOGIN_SETALL;
923: CLR(flags, LOGIN_SETGROUP|LOGIN_SETLOGIN|LOGIN_SETUSER|LOGIN_SETENV|LOGIN_SETPATH);
924: CLR(details->flags, CD_SET_UMASK); /* LOGIN_UMASK instead */
925: } else {
926: flags = LOGIN_SETRESOURCES|LOGIN_SETPRIORITY;
927: }
928: if (setusercontext(lc, details->pw, details->pw->pw_uid, flags)) {
929: if (details->pw->pw_uid != ROOT_UID) {
930: warning(_("unable to set user context"));
931: goto done;
932: } else
933: warning(_("unable to set user context"));
934: }
935: }
936: #endif /* HAVE_LOGIN_CAP_H */
937: }
938:
939: /*
940: * Set groups, including supplementary group vector.
941: */
942: if (!ISSET(details->flags, CD_PRESERVE_GROUPS)) {
943: if (details->ngroups >= 0) {
944: if (sudo_setgroups(details->ngroups, details->groups) < 0) {
945: warning(_("unable to set supplementary group IDs"));
946: goto done;
947: }
948: }
949: }
950: #ifdef HAVE_SETEUID
951: if (ISSET(details->flags, CD_SET_EGID) && setegid(details->egid)) {
952: warning(_("unable to set effective gid to runas gid %u"),
953: (unsigned int)details->egid);
954: goto done;
955: }
956: #endif
957: if (ISSET(details->flags, CD_SET_GID) && setgid(details->gid)) {
958: warning(_("unable to set gid to runas gid %u"),
959: (unsigned int)details->gid);
960: goto done;
961: }
962:
963: if (ISSET(details->flags, CD_SET_PRIORITY)) {
964: if (setpriority(PRIO_PROCESS, 0, details->priority) != 0) {
965: warning(_("unable to set process priority"));
966: goto done;
967: }
968: }
969: if (ISSET(details->flags, CD_SET_UMASK))
970: (void) umask(details->umask);
971: if (details->chroot) {
972: if (chroot(details->chroot) != 0 || chdir("/") != 0) {
973: warning(_("unable to change root to %s"), details->chroot);
974: goto done;
975: }
976: }
977:
978: #ifdef HAVE_SETRESUID
979: if (setresuid(details->uid, details->euid, details->euid) != 0) {
980: warning(_("unable to change to runas uid (%u, %u)"), details->uid,
981: details->euid);
982: goto done;
983: }
984: #elif HAVE_SETREUID
985: if (setreuid(details->uid, details->euid) != 0) {
986: warning(_("unable to change to runas uid (%u, %u)"),
987: (unsigned int)details->uid, (unsigned int)details->euid);
988: goto done;
989: }
990: #else
991: if (seteuid(details->euid) != 0 || setuid(details->euid) != 0) {
992: warning(_("unable to change to runas uid (%u, %u)"), details->uid,
993: details->euid);
994: goto done;
995: }
996: #endif /* !HAVE_SETRESUID && !HAVE_SETREUID */
997:
998: /*
999: * Only change cwd if we have chroot()ed or the policy modules
1000: * specifies a different cwd. Must be done after uid change.
1001: */
1002: if (details->cwd) {
1003: if (details->chroot || strcmp(details->cwd, user_details.cwd) != 0) {
1004: /* Note: cwd is relative to the new root, if any. */
1005: if (chdir(details->cwd) != 0) {
1006: warning(_("unable to change directory to %s"), details->cwd);
1007: goto done;
1008: }
1009: }
1010: }
1011:
1012: /*
1013: * SuSE Enterprise Linux uses RLIMIT_NPROC and _SC_CHILD_MAX
1014: * interchangably. This causes problems when setting RLIMIT_NPROC
1015: * to RLIM_INFINITY due to a bug in bash where bash tries to honor
1016: * the value of _SC_CHILD_MAX but treats a value of -1 as an error,
1017: * and uses a default value of 32 instead.
1018: *
1019: * To work around this problem, we restore the nproc resource limit
1020: * if sysconf(_SC_CHILD_MAX) is negative. In most cases, pam_limits
1021: * will set RLIMIT_NPROC for us.
1022: *
1023: * We must do this *after* the uid change to avoid potential EAGAIN
1024: * from setuid().
1025: */
1026: #if defined(__linux__) && defined(_SC_CHILD_MAX)
1027: {
1028: struct rlimit rl;
1029: long l;
1030: errno = 0;
1031: l = sysconf(_SC_CHILD_MAX);
1032: if (l == -1 && errno == 0 && getrlimit(RLIMIT_NPROC, &rl) == 0) {
1033: if (rl.rlim_cur == RLIM_INFINITY && rl.rlim_max == RLIM_INFINITY)
1034: (void) setrlimit(RLIMIT_NPROC, &nproclimit);
1035: }
1036: }
1037: #endif
1038:
1039: rval = true;
1040:
1041: done:
1042: debug_return_bool(rval);
1043: }
1044:
1045: /*
1046: * Run the command and wait for it to complete.
1047: */
1048: int
1049: run_command(struct command_details *details)
1050: {
1051: struct plugin_container *plugin;
1052: struct command_status cstat;
1053: int exitcode = 1;
1054: debug_decl(run_command, SUDO_DEBUG_EXEC)
1055:
1056: cstat.type = CMD_INVALID;
1057: cstat.val = 0;
1058:
1059: sudo_execute(details, &cstat);
1060:
1061: switch (cstat.type) {
1062: case CMD_ERRNO:
1063: /* exec_setup() or execve() returned an error. */
1064: sudo_debug_printf(SUDO_DEBUG_DEBUG,
1065: "calling policy close with errno %d", cstat.val);
1066: policy_close(&policy_plugin, 0, cstat.val);
1067: tq_foreach_fwd(&io_plugins, plugin) {
1068: sudo_debug_printf(SUDO_DEBUG_DEBUG,
1069: "calling I/O close with errno %d", cstat.val);
1070: iolog_close(plugin, 0, cstat.val);
1071: }
1072: exitcode = 1;
1073: break;
1074: case CMD_WSTATUS:
1075: /* Command ran, exited or was killed. */
1076: sudo_debug_printf(SUDO_DEBUG_DEBUG,
1077: "calling policy close with wait status %d", cstat.val);
1078: policy_close(&policy_plugin, cstat.val, 0);
1079: tq_foreach_fwd(&io_plugins, plugin) {
1080: sudo_debug_printf(SUDO_DEBUG_DEBUG,
1081: "calling I/O close with wait status %d", cstat.val);
1082: iolog_close(plugin, cstat.val, 0);
1083: }
1084: if (WIFEXITED(cstat.val))
1085: exitcode = WEXITSTATUS(cstat.val);
1086: else if (WIFSIGNALED(cstat.val))
1087: exitcode = WTERMSIG(cstat.val) | 128;
1088: break;
1089: default:
1090: warningx(_("unexpected child termination condition: %d"), cstat.type);
1091: break;
1092: }
1093: debug_return_int(exitcode);
1094: }
1095:
1096: static int
1097: policy_open(struct plugin_container *plugin, char * const settings[],
1098: char * const user_info[], char * const user_env[])
1099: {
1100: int rval;
1101: debug_decl(policy_open, SUDO_DEBUG_PCOMM)
1102:
1103: /*
1104: * Backwards compatibility for older API versions
1105: */
1106: switch (plugin->u.generic->version) {
1107: case SUDO_API_MKVERSION(1, 0):
1108: case SUDO_API_MKVERSION(1, 1):
1109: rval = plugin->u.policy_1_0->open(plugin->u.io_1_0->version,
1110: sudo_conversation, _sudo_printf, settings, user_info, user_env);
1111: break;
1112: default:
1113: rval = plugin->u.policy->open(SUDO_API_VERSION, sudo_conversation,
1114: _sudo_printf, settings, user_info, user_env, plugin->options);
1115: }
1116:
1117: debug_return_bool(rval);
1118: }
1119:
1120: static void
1121: policy_close(struct plugin_container *plugin, int exit_status, int error)
1122: {
1123: debug_decl(policy_close, SUDO_DEBUG_PCOMM)
1124: if (plugin->u.policy->close != NULL)
1125: plugin->u.policy->close(exit_status, error);
1126: else
1127: warning(_("unable to execute %s"), command_details.command);
1128: debug_return;
1129: }
1130:
1131: static int
1132: policy_show_version(struct plugin_container *plugin, int verbose)
1133: {
1134: debug_decl(policy_show_version, SUDO_DEBUG_PCOMM)
1135: if (plugin->u.policy->show_version == NULL)
1136: debug_return_bool(true);
1137: debug_return_bool(plugin->u.policy->show_version(verbose));
1138: }
1139:
1140: static int
1141: policy_check(struct plugin_container *plugin, int argc, char * const argv[],
1142: char *env_add[], char **command_info[], char **argv_out[],
1143: char **user_env_out[])
1144: {
1145: debug_decl(policy_check, SUDO_DEBUG_PCOMM)
1146: if (plugin->u.policy->check_policy == NULL) {
1147: fatalx(_("policy plugin %s is missing the `check_policy' method"),
1148: plugin->name);
1149: }
1150: debug_return_bool(plugin->u.policy->check_policy(argc, argv, env_add,
1151: command_info, argv_out, user_env_out));
1152: }
1153:
1154: static int
1155: policy_list(struct plugin_container *plugin, int argc, char * const argv[],
1156: int verbose, const char *list_user)
1157: {
1158: debug_decl(policy_list, SUDO_DEBUG_PCOMM)
1159: if (plugin->u.policy->list == NULL) {
1160: warningx(_("policy plugin %s does not support listing privileges"),
1161: plugin->name);
1162: debug_return_bool(false);
1163: }
1164: debug_return_bool(plugin->u.policy->list(argc, argv, verbose, list_user));
1165: }
1166:
1167: static int
1168: policy_validate(struct plugin_container *plugin)
1169: {
1170: debug_decl(policy_validate, SUDO_DEBUG_PCOMM)
1171: if (plugin->u.policy->validate == NULL) {
1172: warningx(_("policy plugin %s does not support the -v option"),
1173: plugin->name);
1174: debug_return_bool(false);
1175: }
1176: debug_return_bool(plugin->u.policy->validate());
1177: }
1178:
1179: static void
1180: policy_invalidate(struct plugin_container *plugin, int remove)
1181: {
1182: debug_decl(policy_invalidate, SUDO_DEBUG_PCOMM)
1183: if (plugin->u.policy->invalidate == NULL) {
1184: fatalx(_("policy plugin %s does not support the -k/-K options"),
1185: plugin->name);
1186: }
1187: plugin->u.policy->invalidate(remove);
1188: debug_return;
1189: }
1190:
1191: int
1192: policy_init_session(struct command_details *details)
1193: {
1194: int rval = true;
1195: debug_decl(policy_init_session, SUDO_DEBUG_PCOMM)
1196:
1197: if (policy_plugin.u.policy->init_session) {
1198: /*
1199: * Backwards compatibility for older API versions
1200: */
1201: switch (policy_plugin.u.generic->version) {
1202: case SUDO_API_MKVERSION(1, 0):
1203: case SUDO_API_MKVERSION(1, 1):
1204: rval = policy_plugin.u.policy_1_0->init_session(details->pw);
1205: break;
1206: default:
1207: rval = policy_plugin.u.policy->init_session(details->pw,
1208: &details->envp);
1209: }
1210: }
1211: debug_return_bool(rval);
1212: }
1213:
1214: static int
1215: iolog_open(struct plugin_container *plugin, char * const settings[],
1216: char * const user_info[], char * const command_info[],
1217: int argc, char * const argv[], char * const user_env[])
1218: {
1219: int rval;
1220: debug_decl(iolog_open, SUDO_DEBUG_PCOMM)
1221:
1222: /*
1223: * Backwards compatibility for older API versions
1224: */
1225: switch (plugin->u.generic->version) {
1226: case SUDO_API_MKVERSION(1, 0):
1227: rval = plugin->u.io_1_0->open(plugin->u.io_1_0->version,
1228: sudo_conversation, _sudo_printf, settings, user_info, argc, argv,
1229: user_env);
1230: break;
1231: case SUDO_API_MKVERSION(1, 1):
1232: rval = plugin->u.io_1_1->open(plugin->u.io_1_1->version,
1233: sudo_conversation, _sudo_printf, settings, user_info,
1234: command_info, argc, argv, user_env);
1235: break;
1236: default:
1237: rval = plugin->u.io->open(SUDO_API_VERSION, sudo_conversation,
1238: _sudo_printf, settings, user_info, command_info,
1239: argc, argv, user_env, plugin->options);
1240: }
1241: debug_return_bool(rval);
1242: }
1243:
1244: static void
1245: iolog_close(struct plugin_container *plugin, int exit_status, int error)
1246: {
1247: debug_decl(iolog_close, SUDO_DEBUG_PCOMM)
1248: if (plugin->u.io->close != NULL)
1249: plugin->u.io->close(exit_status, error);
1250: debug_return;
1251: }
1252:
1253: static int
1254: iolog_show_version(struct plugin_container *plugin, int verbose)
1255: {
1256: debug_decl(iolog_show_version, SUDO_DEBUG_PCOMM)
1257: if (plugin->u.io->show_version == NULL)
1258: debug_return_bool(true);
1259: debug_return_bool(plugin->u.io->show_version(verbose));
1260: }
1261:
1262: /*
1263: * Remove the specified I/O logging plugin from the io_plugins list.
1264: * Deregisters any hooks before unlinking, then frees the container.
1265: */
1266: static void
1267: iolog_unlink(struct plugin_container *plugin)
1268: {
1269: debug_decl(iolog_unlink, SUDO_DEBUG_PCOMM)
1270:
1271: /* Deregister hooks, if any. */
1272: if (plugin->u.io->version >= SUDO_API_MKVERSION(1, 2)) {
1273: if (plugin->u.io->deregister_hooks != NULL)
1274: plugin->u.io->deregister_hooks(SUDO_HOOK_VERSION,
1275: deregister_hook);
1276: }
1277: /* Remove from io_plugins list and free. */
1278: tq_remove(&io_plugins, plugin);
1279: efree(plugin);
1280:
1281: debug_return;
1282: }
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