Annotation of embedaddon/sudo/src/exec.c, revision 1.1.1.4
1.1 misho 1: /*
1.1.1.4 ! misho 2: * Copyright (c) 2009-2013 Todd C. Miller <Todd.Miller@courtesan.com>
1.1 misho 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: #include <config.h>
18:
19: #include <sys/types.h>
20: #ifdef HAVE_SYS_SYSMACROS_H
21: # include <sys/sysmacros.h>
22: #endif
23: #include <sys/socket.h>
24: #include <sys/stat.h>
25: #include <sys/time.h>
26: #include <sys/wait.h>
27: #include <sys/ioctl.h>
28: #ifdef HAVE_SYS_SELECT_H
29: # include <sys/select.h>
30: #endif /* HAVE_SYS_SELECT_H */
31: #include <stdio.h>
32: #ifdef STDC_HEADERS
33: # include <stdlib.h>
34: # include <stddef.h>
35: #else
36: # ifdef HAVE_STDLIB_H
37: # include <stdlib.h>
38: # endif
39: #endif /* STDC_HEADERS */
40: #ifdef HAVE_STRING_H
41: # include <string.h>
42: #endif /* HAVE_STRING_H */
43: #ifdef HAVE_STRINGS_H
44: # include <strings.h>
45: #endif /* HAVE_STRINGS_H */
46: #ifdef HAVE_UNISTD_H
47: # include <unistd.h>
48: #endif /* HAVE_UNISTD_H */
49: #if TIME_WITH_SYS_TIME
50: # include <time.h>
51: #endif
52: #include <errno.h>
53: #include <fcntl.h>
54: #include <signal.h>
55: #include <termios.h>
56:
57: #include "sudo.h"
58: #include "sudo_exec.h"
59: #include "sudo_plugin.h"
60: #include "sudo_plugin_int.h"
61:
62: /* We keep a tailq of signals to forward to child. */
63: struct sigforward {
64: struct sigforward *prev, *next;
65: int signo;
66: };
67: TQ_DECLARE(sigforward)
68: static struct sigforward_list sigfwd_list;
1.1.1.3 misho 69: static pid_t ppgrp = -1;
70:
71: volatile pid_t cmnd_pid = -1;
1.1 misho 72:
1.1.1.4 ! misho 73: static int dispatch_signals(int sv[2], pid_t child, int log_io,
1.1 misho 74: struct command_status *cstat);
1.1.1.4 ! misho 75: static int dispatch_pending_signals(struct command_status *cstat);
1.1 misho 76: static void forward_signals(int fd);
77: static void schedule_signal(int signo);
1.1.1.2 misho 78: #ifdef SA_SIGINFO
1.1.1.3 misho 79: static void handler_user_only(int s, siginfo_t *info, void *context);
1.1.1.2 misho 80: #endif
1.1 misho 81:
82: /*
83: * Fork and execute a command, returns the child's pid.
84: * Sends errno back on sv[1] if execve() fails.
85: */
86: static int fork_cmnd(struct command_details *details, int sv[2])
87: {
88: struct command_status cstat;
89: sigaction_t sa;
1.1.1.2 misho 90: debug_decl(fork_cmnd, SUDO_DEBUG_EXEC)
1.1 misho 91:
1.1.1.3 misho 92: ppgrp = getpgrp(); /* parent's process group */
93:
94: /*
95: * Handle suspend/restore of sudo and the command.
96: * In most cases, the command will be in the same process group as
97: * sudo and job control will "just work". However, if the command
98: * changes its process group ID and does not change it back (or is
99: * kill by SIGSTOP which is not catchable), we need to resume the
100: * command manually. Also, if SIGTSTP is sent directly to sudo,
101: * we need to suspend the command, and then suspend ourself, restoring
102: * the default SIGTSTP handler temporarily.
103: *
104: * XXX - currently we send SIGCONT upon resume in some cases where
105: * we don't need to (e.g. command pgrp == parent pgrp).
106: */
1.1.1.4 ! misho 107: memset(&sa, 0, sizeof(sa));
! 108: sigfillset(&sa.sa_mask);
1.1 misho 109: sa.sa_flags = SA_INTERRUPT; /* do not restart syscalls */
1.1.1.3 misho 110: #ifdef SA_SIGINFO
111: sa.sa_flags |= SA_SIGINFO;
112: sa.sa_sigaction = handler;
113: #else
1.1 misho 114: sa.sa_handler = handler;
1.1.1.3 misho 115: #endif
1.1.1.4 ! misho 116: sudo_sigaction(SIGCONT, &sa, NULL);
1.1.1.3 misho 117: #ifdef SA_SIGINFO
118: sa.sa_sigaction = handler_user_only;
119: #endif
1.1.1.4 ! misho 120: sudo_sigaction(SIGTSTP, &sa, NULL);
1.1 misho 121:
1.1.1.2 misho 122: /*
123: * The policy plugin's session init must be run before we fork
124: * or certain pam modules won't be able to track their state.
125: */
126: if (policy_init_session(details) != true)
1.1.1.4 ! misho 127: fatalx(_("policy plugin failed session initialization"));
1.1.1.2 misho 128:
1.1.1.3 misho 129: cmnd_pid = sudo_debug_fork();
130: switch (cmnd_pid) {
1.1 misho 131: case -1:
1.1.1.4 ! misho 132: fatal(_("unable to fork"));
1.1 misho 133: break;
134: case 0:
135: /* child */
136: close(sv[0]);
137: close(signal_pipe[0]);
138: close(signal_pipe[1]);
139: fcntl(sv[1], F_SETFD, FD_CLOEXEC);
1.1.1.4 ! misho 140: exec_cmnd(details, &cstat, &sv[1]);
1.1 misho 141: send(sv[1], &cstat, sizeof(cstat), 0);
1.1.1.2 misho 142: sudo_debug_exit_int(__func__, __FILE__, __LINE__, sudo_debug_subsys, 1);
1.1 misho 143: _exit(1);
144: }
1.1.1.3 misho 145: sudo_debug_printf(SUDO_DEBUG_INFO, "executed %s, pid %d", details->command,
146: (int)cmnd_pid);
147: debug_return_int(cmnd_pid);
1.1 misho 148: }
149:
150: /*
1.1.1.4 ! misho 151: * Setup the execution environment and execute the command.
! 152: * If SELinux is enabled, run the command via sesh, otherwise
! 153: * execute it directly.
! 154: * If the exec fails, cstat is filled in with the value of errno.
1.1 misho 155: */
156: void
1.1.1.4 ! misho 157: exec_cmnd(struct command_details *details, struct command_status *cstat,
! 158: int *errfd)
1.1 misho 159: {
1.1.1.4 ! misho 160: debug_decl(exec_cmnd, SUDO_DEBUG_EXEC)
1.1.1.2 misho 161:
1.1.1.4 ! misho 162: restore_signals();
! 163: if (exec_setup(details, NULL, -1) == true) {
! 164: /* headed for execve() */
! 165: sudo_debug_execve(SUDO_DEBUG_INFO, details->command,
! 166: details->argv, details->envp);
! 167: if (details->closefrom >= 0) {
! 168: int maxfd = details->closefrom;
! 169: /* Preserve back channel if present. */
! 170: if (errfd != NULL) {
! 171: dup2(*errfd, maxfd);
! 172: (void)fcntl(maxfd, F_SETFD, FD_CLOEXEC);
! 173: *errfd = maxfd++;
! 174: }
! 175: if (sudo_debug_fd_set(maxfd) != -1)
! 176: maxfd++;
! 177: closefrom(maxfd);
! 178: }
! 179: #ifdef HAVE_SELINUX
! 180: if (ISSET(details->flags, CD_RBAC_ENABLED)) {
! 181: selinux_execve(details->command, details->argv, details->envp,
! 182: ISSET(details->flags, CD_NOEXEC));
! 183: } else
! 184: #endif
! 185: {
! 186: sudo_execve(details->command, details->argv, details->envp,
! 187: ISSET(details->flags, CD_NOEXEC));
! 188: }
! 189: cstat->type = CMD_ERRNO;
! 190: cstat->val = errno;
! 191: sudo_debug_printf(SUDO_DEBUG_ERROR, "unable to exec %s: %s",
! 192: details->command, strerror(errno));
! 193: }
1.1.1.2 misho 194: debug_return;
1.1 misho 195: }
196:
197: /*
1.1.1.4 ! misho 198: * Execute a command, potentially in a pty with I/O loggging, and
! 199: * wait for it to finish.
1.1 misho 200: * This is a little bit tricky due to how POSIX job control works and
201: * we fact that we have two different controlling terminals to deal with.
202: */
203: int
1.1.1.2 misho 204: sudo_execute(struct command_details *details, struct command_status *cstat)
1.1 misho 205: {
1.1.1.2 misho 206: int maxfd, n, nready, sv[2];
1.1 misho 207: const char *utmp_user = NULL;
1.1.1.2 misho 208: bool log_io = false;
1.1 misho 209: fd_set *fdsr, *fdsw;
210: sigaction_t sa;
1.1.1.3 misho 211: sigset_t omask;
1.1 misho 212: pid_t child;
1.1.1.2 misho 213: debug_decl(sudo_execute, SUDO_DEBUG_EXEC)
1.1 misho 214:
1.1.1.4 ! misho 215: dispatch_pending_signals(cstat);
! 216:
1.1 misho 217: /* If running in background mode, fork and exit. */
218: if (ISSET(details->flags, CD_BACKGROUND)) {
1.1.1.2 misho 219: switch (sudo_debug_fork()) {
1.1 misho 220: case -1:
221: cstat->type = CMD_ERRNO;
222: cstat->val = errno;
1.1.1.2 misho 223: debug_return_int(-1);
1.1 misho 224: case 0:
225: /* child continues without controlling terminal */
226: (void)setpgid(0, 0);
227: break;
228: default:
229: /* parent exits (but does not flush buffers) */
1.1.1.2 misho 230: sudo_debug_exit_int(__func__, __FILE__, __LINE__,
231: sudo_debug_subsys, 0);
1.1 misho 232: _exit(0);
233: }
234: }
235:
236: /*
237: * If we have an I/O plugin or the policy plugin has requested one, we
238: * need to allocate a pty. It is OK to set log_io in the pty-only case
239: * as the io plugin tailqueue will be empty and no I/O logging will occur.
240: */
241: if (!tq_empty(&io_plugins) || ISSET(details->flags, CD_USE_PTY)) {
1.1.1.2 misho 242: log_io = true;
1.1 misho 243: if (ISSET(details->flags, CD_SET_UTMP))
244: utmp_user = details->utmp_user ? details->utmp_user : user_details.username;
1.1.1.2 misho 245: sudo_debug_printf(SUDO_DEBUG_INFO, "allocate pty for I/O logging");
1.1 misho 246: pty_setup(details->euid, user_details.tty, utmp_user);
1.1.1.4 ! misho 247: } else if (!ISSET(details->flags, CD_SET_TIMEOUT) &&
! 248: policy_plugin.u.policy->close == NULL) {
! 249: /* If no I/O logging, timeout or policy close we can exec directly. */
! 250: exec_cmnd(details, cstat, NULL);
! 251: goto done;
1.1 misho 252: }
253:
254: /*
255: * We communicate with the child over a bi-directional pair of sockets.
256: * Parent sends signal info to child and child sends back wait status.
257: */
258: if (socketpair(PF_UNIX, SOCK_DGRAM, 0, sv) == -1)
1.1.1.4 ! misho 259: fatal(_("unable to create sockets"));
1.1 misho 260:
261: /*
1.1.1.2 misho 262: * Signals to forward to the child process (excluding SIGALRM and SIGCHLD).
1.1.1.4 ! misho 263: * We block all other signals while running the signal handler.
1.1 misho 264: * Note: HP-UX select() will not be interrupted if SA_RESTART set.
265: */
1.1.1.4 ! misho 266: memset(&sa, 0, sizeof(sa));
! 267: sigfillset(&sa.sa_mask);
1.1 misho 268: sa.sa_flags = SA_INTERRUPT; /* do not restart syscalls */
1.1.1.3 misho 269: #ifdef SA_SIGINFO
270: sa.sa_flags |= SA_SIGINFO;
271: sa.sa_sigaction = handler;
272: #else
1.1 misho 273: sa.sa_handler = handler;
1.1.1.3 misho 274: #endif
1.1.1.4 ! misho 275: sudo_sigaction(SIGTERM, &sa, NULL);
! 276: sudo_sigaction(SIGALRM, &sa, NULL); /* XXX - only if there is a timeout */
! 277: sudo_sigaction(SIGCHLD, &sa, NULL);
! 278: sudo_sigaction(SIGPIPE, &sa, NULL);
! 279: sudo_sigaction(SIGUSR1, &sa, NULL);
! 280: sudo_sigaction(SIGUSR2, &sa, NULL);
1.1 misho 281:
1.1.1.2 misho 282: /*
283: * When not running the command in a pty, we do not want to
284: * forward signals generated by the kernel that the child will
285: * already have received either by virtue of being in the
286: * controlling tty's process group (SIGINT, SIGQUIT) or because
287: * the session is terminating (SIGHUP).
288: */
289: #ifdef SA_SIGINFO
290: if (!log_io) {
291: sa.sa_flags |= SA_SIGINFO;
1.1.1.3 misho 292: sa.sa_sigaction = handler_user_only;
1.1.1.2 misho 293: }
294: #endif
1.1.1.4 ! misho 295: sudo_sigaction(SIGHUP, &sa, NULL);
! 296: sudo_sigaction(SIGINT, &sa, NULL);
! 297: sudo_sigaction(SIGQUIT, &sa, NULL);
1.1.1.2 misho 298:
1.1 misho 299: /* Max fd we will be selecting on. */
300: maxfd = MAX(sv[0], signal_pipe[0]);
301:
302: /*
303: * Child will run the command in the pty, parent will pass data
304: * to and from pty. Adjusts maxfd as needed.
305: */
306: if (log_io)
1.1.1.3 misho 307: child = fork_pty(details, sv, &maxfd, &omask);
1.1 misho 308: else
309: child = fork_cmnd(details, sv);
310: close(sv[1]);
311:
312: /* Set command timeout if specified. */
313: if (ISSET(details->flags, CD_SET_TIMEOUT))
314: alarm(details->timeout);
315:
316: /*
317: * I/O logging must be in the C locale for floating point numbers
318: * to be logged consistently.
319: */
320: setlocale(LC_ALL, "C");
321:
322: /*
323: * In the event loop we pass input from user tty to master
324: * and pass output from master to stdout and IO plugin.
325: */
1.1.1.2 misho 326: fdsr = emalloc2(howmany(maxfd + 1, NFDBITS), sizeof(fd_mask));
327: fdsw = emalloc2(howmany(maxfd + 1, NFDBITS), sizeof(fd_mask));
1.1 misho 328: for (;;) {
1.1.1.2 misho 329: memset(fdsw, 0, howmany(maxfd + 1, NFDBITS) * sizeof(fd_mask));
330: memset(fdsr, 0, howmany(maxfd + 1, NFDBITS) * sizeof(fd_mask));
1.1 misho 331:
332: FD_SET(signal_pipe[0], fdsr);
333: FD_SET(sv[0], fdsr);
334: if (!tq_empty(&sigfwd_list))
335: FD_SET(sv[0], fdsw);
336: if (log_io)
337: fd_set_iobs(fdsr, fdsw); /* XXX - better name */
338: nready = select(maxfd + 1, fdsr, fdsw, NULL, NULL);
1.1.1.2 misho 339: sudo_debug_printf(SUDO_DEBUG_DEBUG, "select returns %d", nready);
1.1 misho 340: if (nready == -1) {
1.1.1.2 misho 341: if (errno == EINTR || errno == ENOMEM)
1.1 misho 342: continue;
1.1.1.2 misho 343: if (errno == EBADF || errno == EIO) {
344: /* One of the ttys must have gone away. */
345: goto do_tty_io;
346: }
347: warning(_("select failed"));
348: sudo_debug_printf(SUDO_DEBUG_ERROR,
349: "select failure, terminating child");
350: schedule_signal(SIGKILL);
351: forward_signals(sv[0]);
352: break;
1.1 misho 353: }
354: if (FD_ISSET(sv[0], fdsw)) {
355: forward_signals(sv[0]);
356: }
357: if (FD_ISSET(signal_pipe[0], fdsr)) {
1.1.1.4 ! misho 358: n = dispatch_signals(sv, child, log_io, cstat);
1.1 misho 359: if (n == 0) {
360: /* Child has exited, cstat is set, we are done. */
1.1.1.2 misho 361: break;
1.1 misho 362: }
363: if (n == -1) {
364: /* Error reading signal_pipe[0], should not happen. */
365: break;
366: }
367: /* Restart event loop so signals get sent to child immediately. */
368: continue;
369: }
370: if (FD_ISSET(sv[0], fdsr)) {
371: /* read child status */
372: n = recv(sv[0], cstat, sizeof(*cstat), 0);
1.1.1.2 misho 373: if (n != sizeof(*cstat)) {
374: if (n == -1) {
375: if (errno == EINTR)
376: continue;
377: /*
378: * If not logging I/O we may receive ECONNRESET when
379: * the command is executed and sv is closed.
380: * It is safe to ignore this.
381: */
382: if (log_io && errno != EAGAIN) {
383: cstat->type = CMD_ERRNO;
384: cstat->val = errno;
385: break;
386: }
387: sudo_debug_printf(SUDO_DEBUG_ERROR,
388: "failed to read child status: %s", strerror(errno));
389: } else {
390: /* Short read or EOF. */
391: sudo_debug_printf(SUDO_DEBUG_ERROR,
392: "failed to read child status: %s",
393: n ? "short read" : "EOF");
394: /* XXX - should set cstat */
1.1 misho 395: break;
396: }
397: }
1.1.1.3 misho 398: if (cstat->type == CMD_PID) {
399: /*
400: * Once we know the command's pid we can unblock
401: * signals which ere blocked in fork_pty(). This
402: * avoids a race between exec of the command and
403: * receipt of a fatal signal from it.
404: */
405: cmnd_pid = cstat->val;
406: sudo_debug_printf(SUDO_DEBUG_INFO, "executed %s, pid %d",
407: details->command, (int)cmnd_pid);
408: if (log_io)
409: sigprocmask(SIG_SETMASK, &omask, NULL);
410: } else if (cstat->type == CMD_WSTATUS) {
1.1 misho 411: if (WIFSTOPPED(cstat->val)) {
412: /* Suspend parent and tell child how to resume on return. */
1.1.1.2 misho 413: sudo_debug_printf(SUDO_DEBUG_INFO,
414: "child stopped, suspending parent");
1.1 misho 415: n = suspend_parent(WSTOPSIG(cstat->val));
416: schedule_signal(n);
417: continue;
418: } else {
419: /* Child exited or was killed, either way we are done. */
1.1.1.2 misho 420: sudo_debug_printf(SUDO_DEBUG_INFO, "child exited or was killed");
1.1 misho 421: break;
422: }
423: } else if (cstat->type == CMD_ERRNO) {
424: /* Child was unable to execute command or broken pipe. */
1.1.1.2 misho 425: sudo_debug_printf(SUDO_DEBUG_INFO, "errno from child: %s",
426: strerror(cstat->val));
1.1 misho 427: break;
428: }
429: }
1.1.1.2 misho 430: do_tty_io:
1.1 misho 431: if (perform_io(fdsr, fdsw, cstat) != 0) {
432: /* I/O error, kill child if still alive and finish. */
1.1.1.2 misho 433: sudo_debug_printf(SUDO_DEBUG_ERROR, "I/O error, terminating child");
1.1 misho 434: schedule_signal(SIGKILL);
435: forward_signals(sv[0]);
436: break;
437: }
438: }
439:
440: if (log_io) {
441: /* Flush any remaining output and free pty-related memory. */
442: pty_close(cstat);
443: }
444:
445: #ifdef HAVE_SELINUX
446: if (ISSET(details->flags, CD_RBAC_ENABLED)) {
447: /* This is probably not needed in log_io mode. */
448: if (selinux_restore_tty() != 0)
449: warningx(_("unable to restore tty label"));
450: }
451: #endif
452:
453: efree(fdsr);
454: efree(fdsw);
455: while (!tq_empty(&sigfwd_list)) {
456: struct sigforward *sigfwd = tq_first(&sigfwd_list);
457: tq_remove(&sigfwd_list, sigfwd);
458: efree(sigfwd);
459: }
1.1.1.4 ! misho 460: done:
1.1.1.2 misho 461: debug_return_int(cstat->type == CMD_ERRNO ? -1 : 0);
1.1 misho 462: }
463:
464: /*
1.1.1.4 ! misho 465: * Read signals on signal_pipe written by handler().
1.1 misho 466: * Returns -1 on error, 0 on child exit, else 1.
467: */
468: static int
1.1.1.4 ! misho 469: dispatch_signals(int sv[2], pid_t child, int log_io, struct command_status *cstat)
1.1 misho 470: {
1.1.1.3 misho 471: char signame[SIG2STR_MAX];
1.1 misho 472: unsigned char signo;
473: ssize_t nread;
474: int status;
475: pid_t pid;
1.1.1.4 ! misho 476: debug_decl(dispatch_signals, SUDO_DEBUG_EXEC)
1.1 misho 477:
478: for (;;) {
479: /* read signal pipe */
480: nread = read(signal_pipe[0], &signo, sizeof(signo));
481: if (nread <= 0) {
482: /* It should not be possible to get EOF but just in case. */
483: if (nread == 0)
484: errno = ECONNRESET;
485: /* Restart if interrupted by signal so the pipe doesn't fill. */
486: if (errno == EINTR)
487: continue;
488: /* If pipe is empty, we are done. */
489: if (errno == EAGAIN)
490: break;
1.1.1.2 misho 491: sudo_debug_printf(SUDO_DEBUG_ERROR, "error reading signal pipe %s",
492: strerror(errno));
1.1 misho 493: cstat->type = CMD_ERRNO;
494: cstat->val = errno;
1.1.1.2 misho 495: debug_return_int(-1);
1.1 misho 496: }
1.1.1.3 misho 497: if (sig2str(signo, signame) == -1)
498: snprintf(signame, sizeof(signame), "%d", signo);
499: sudo_debug_printf(SUDO_DEBUG_DIAG, "received SIG%s", signame);
1.1 misho 500: if (signo == SIGCHLD) {
501: /*
502: * If logging I/O, child is the intermediate process,
503: * otherwise it is the command itself.
504: */
505: do {
506: pid = waitpid(child, &status, WUNTRACED|WNOHANG);
507: } while (pid == -1 && errno == EINTR);
508: if (pid == child) {
1.1.1.2 misho 509: if (log_io) {
510: /*
511: * On BSD we get ECONNRESET on sv[0] if monitor dies
512: * and select() will return with sv[0] readable.
513: * On Linux that doesn't appear to happen so if the
514: * monitor dies, shut down the socketpair to force a
515: * select() notification.
516: */
517: (void) shutdown(sv[0], SHUT_WR);
518: } else {
1.1 misho 519: if (WIFSTOPPED(status)) {
520: /*
521: * Save the controlling terminal's process group
1.1.1.3 misho 522: * so we can restore it after we resume, if needed.
523: * Most well-behaved shells change the pgrp back to
524: * its original value before suspending so we must
525: * not try to restore in that case, lest we race with
526: * the child upon resume, potentially stopping sudo
527: * with SIGTTOU while the command continues to run.
1.1 misho 528: */
1.1.1.3 misho 529: sigaction_t sa, osa;
1.1 misho 530: pid_t saved_pgrp = (pid_t)-1;
1.1.1.3 misho 531: int signo = WSTOPSIG(status);
1.1 misho 532: int fd = open(_PATH_TTY, O_RDWR|O_NOCTTY, 0);
1.1.1.3 misho 533: if (fd != -1) {
534: if ((saved_pgrp = tcgetpgrp(fd)) == ppgrp)
535: saved_pgrp = -1;
536: }
537: if (signo == SIGTSTP) {
1.1.1.4 ! misho 538: memset(&sa, 0, sizeof(sa));
1.1.1.3 misho 539: sigemptyset(&sa.sa_mask);
1.1.1.4 ! misho 540: sa.sa_flags = SA_RESTART;
1.1.1.3 misho 541: sa.sa_handler = SIG_DFL;
1.1.1.4 ! misho 542: sudo_sigaction(SIGTSTP, &sa, &osa);
1.1 misho 543: }
1.1.1.3 misho 544: if (kill(getpid(), signo) != 0)
545: warning("kill(%d, SIG%s)", (int)getpid(), signame);
546: if (signo == SIGTSTP)
1.1.1.4 ! misho 547: sudo_sigaction(SIGTSTP, &osa, NULL);
1.1 misho 548: if (fd != -1) {
1.1.1.3 misho 549: /*
550: * Restore command's process group if different.
551: * Otherwise, we cannot resume some shells.
552: */
1.1 misho 553: if (saved_pgrp != (pid_t)-1)
554: (void)tcsetpgrp(fd, saved_pgrp);
555: close(fd);
556: }
557: } else {
558: /* Child has exited, we are done. */
559: cstat->type = CMD_WSTATUS;
560: cstat->val = status;
1.1.1.2 misho 561: debug_return_int(0);
1.1 misho 562: }
563: }
564: }
565: } else {
566: if (log_io) {
567: /* Schedule signo to be forwared to the child. */
568: schedule_signal(signo);
569: } else {
570: /* Nothing listening on sv[0], send directly. */
571: if (signo == SIGALRM)
1.1.1.3 misho 572: terminate_command(child, false);
1.1 misho 573: else if (kill(child, signo) != 0)
1.1.1.3 misho 574: warning("kill(%d, SIG%s)", (int)child, signame);
1.1 misho 575: }
576: }
577: }
1.1.1.2 misho 578: debug_return_int(1);
1.1 misho 579: }
580:
581: /*
1.1.1.4 ! misho 582: * Drain pending signals from signale_pipe written by sudo_handler().
! 583: * Handles the case where the signal was sent to us before
! 584: * we have executed the command.
! 585: * Returns 1 if we should terminate, else 0.
! 586: */
! 587: static int
! 588: dispatch_pending_signals(struct command_status *cstat)
! 589: {
! 590: ssize_t nread;
! 591: struct sigaction sa;
! 592: unsigned char signo = 0;
! 593: int rval = 0;
! 594: debug_decl(dispatch_pending_signals, SUDO_DEBUG_EXEC)
! 595:
! 596: for (;;) {
! 597: nread = read(signal_pipe[0], &signo, sizeof(signo));
! 598: if (nread <= 0) {
! 599: /* It should not be possible to get EOF but just in case. */
! 600: if (nread == 0)
! 601: errno = ECONNRESET;
! 602: /* Restart if interrupted by signal so the pipe doesn't fill. */
! 603: if (errno == EINTR)
! 604: continue;
! 605: /* If pipe is empty, we are done. */
! 606: if (errno == EAGAIN)
! 607: break;
! 608: sudo_debug_printf(SUDO_DEBUG_ERROR, "error reading signal pipe %s",
! 609: strerror(errno));
! 610: cstat->type = CMD_ERRNO;
! 611: cstat->val = errno;
! 612: rval = 1;
! 613: break;
! 614: }
! 615: /* Take the first terminal signal. */
! 616: if (signo == SIGINT || signo == SIGQUIT) {
! 617: cstat->type = CMD_WSTATUS;
! 618: cstat->val = signo + 128;
! 619: rval = 1;
! 620: break;
! 621: }
! 622: }
! 623: /* Only stop if we haven't already been terminated. */
! 624: if (signo == SIGTSTP)
! 625: {
! 626: memset(&sa, 0, sizeof(sa));
! 627: sigemptyset(&sa.sa_mask);
! 628: sa.sa_flags = SA_RESTART;
! 629: sa.sa_handler = SIG_DFL;
! 630: sudo_sigaction(SIGTSTP, &sa, NULL);
! 631: if (kill(getpid(), SIGTSTP) != 0)
! 632: warning("kill(%d, SIGTSTP)", (int)getpid());
! 633: /* No need to reinstall SIGTSTP handler. */
! 634: }
! 635: debug_return_int(rval);
! 636: }
! 637:
! 638: /*
1.1 misho 639: * Forward signals in sigfwd_list to child listening on fd.
640: */
641: static void
642: forward_signals(int sock)
643: {
1.1.1.3 misho 644: char signame[SIG2STR_MAX];
1.1 misho 645: struct sigforward *sigfwd;
646: struct command_status cstat;
647: ssize_t nsent;
1.1.1.2 misho 648: debug_decl(forward_signals, SUDO_DEBUG_EXEC)
1.1 misho 649:
650: while (!tq_empty(&sigfwd_list)) {
651: sigfwd = tq_first(&sigfwd_list);
1.1.1.4 ! misho 652: if (sigfwd->signo == SIGCONT_FG)
! 653: strlcpy(signame, "CONT_FG", sizeof(signame));
! 654: else if (sigfwd->signo == SIGCONT_BG)
! 655: strlcpy(signame, "CONT_BG", sizeof(signame));
! 656: else if (sig2str(sigfwd->signo, signame) == -1)
1.1.1.3 misho 657: snprintf(signame, sizeof(signame), "%d", sigfwd->signo);
1.1.1.2 misho 658: sudo_debug_printf(SUDO_DEBUG_INFO,
1.1.1.3 misho 659: "sending SIG%s to child over backchannel", signame);
1.1 misho 660: cstat.type = CMD_SIGNO;
661: cstat.val = sigfwd->signo;
662: do {
663: nsent = send(sock, &cstat, sizeof(cstat), 0);
664: } while (nsent == -1 && errno == EINTR);
665: tq_remove(&sigfwd_list, sigfwd);
666: efree(sigfwd);
667: if (nsent != sizeof(cstat)) {
668: if (errno == EPIPE) {
1.1.1.2 misho 669: sudo_debug_printf(SUDO_DEBUG_ERROR,
670: "broken pipe writing to child over backchannel");
1.1 misho 671: /* Other end of socket gone, empty out sigfwd_list. */
672: while (!tq_empty(&sigfwd_list)) {
673: sigfwd = tq_first(&sigfwd_list);
674: tq_remove(&sigfwd_list, sigfwd);
675: efree(sigfwd);
676: }
1.1.1.2 misho 677: /* XXX - child (monitor) is dead, we should exit too? */
1.1 misho 678: }
679: break;
680: }
681: }
1.1.1.2 misho 682: debug_return;
1.1 misho 683: }
684:
685: /*
686: * Schedule a signal to be forwared.
687: */
688: static void
689: schedule_signal(int signo)
690: {
691: struct sigforward *sigfwd;
1.1.1.3 misho 692: char signame[SIG2STR_MAX];
1.1.1.2 misho 693: debug_decl(schedule_signal, SUDO_DEBUG_EXEC)
1.1 misho 694:
1.1.1.4 ! misho 695: if (signo == SIGCONT_FG)
! 696: strlcpy(signame, "CONT_FG", sizeof(signame));
! 697: else if (signo == SIGCONT_BG)
! 698: strlcpy(signame, "CONT_BG", sizeof(signame));
! 699: else if (sig2str(signo, signame) == -1)
1.1.1.3 misho 700: snprintf(signame, sizeof(signame), "%d", signo);
1.1.1.4 ! misho 701: sudo_debug_printf(SUDO_DEBUG_DIAG, "scheduled SIG%s for child", signame);
1.1.1.2 misho 702:
703: sigfwd = ecalloc(1, sizeof(*sigfwd));
1.1 misho 704: sigfwd->prev = sigfwd;
1.1.1.2 misho 705: /* sigfwd->next = NULL; */
1.1 misho 706: sigfwd->signo = signo;
707: tq_append(&sigfwd_list, sigfwd);
1.1.1.2 misho 708:
709: debug_return;
1.1 misho 710: }
711:
712: /*
713: * Generic handler for signals passed from parent -> child.
714: * The other end of signal_pipe is checked in the main event loop.
715: */
1.1.1.3 misho 716: #ifdef SA_SIGINFO
717: void
718: handler(int s, siginfo_t *info, void *context)
719: {
720: unsigned char signo = (unsigned char)s;
721:
722: /*
723: * If the signal came from the command we ran, just ignore
724: * it since we don't want the child to indirectly kill itself.
725: * This can happen with, e.g. BSD-derived versions of reboot
726: * that call kill(-1, SIGTERM) to kill all other processes.
727: */
728: if (info != NULL && info->si_code == SI_USER && info->si_pid == cmnd_pid)
729: return;
730:
731: /*
732: * The pipe is non-blocking, if we overflow the kernel's pipe
733: * buffer we drop the signal. This is not a problem in practice.
734: */
735: ignore_result(write(signal_pipe[1], &signo, sizeof(signo)));
736: }
737: #else
1.1 misho 738: void
739: handler(int s)
740: {
741: unsigned char signo = (unsigned char)s;
742:
743: /*
744: * The pipe is non-blocking, if we overflow the kernel's pipe
745: * buffer we drop the signal. This is not a problem in practice.
746: */
1.1.1.2 misho 747: ignore_result(write(signal_pipe[1], &signo, sizeof(signo)));
748: }
1.1.1.3 misho 749: #endif
1.1.1.2 misho 750:
751: #ifdef SA_SIGINFO
752: /*
753: * Generic handler for signals passed from parent -> child.
754: * The other end of signal_pipe is checked in the main event loop.
755: * This version is for the non-pty case and does not forward
756: * signals that are generated by the kernel.
757: */
758: static void
1.1.1.3 misho 759: handler_user_only(int s, siginfo_t *info, void *context)
1.1.1.2 misho 760: {
761: unsigned char signo = (unsigned char)s;
762:
763: /* Only forward user-generated signals. */
1.1.1.3 misho 764: if (info != NULL && info->si_code == SI_USER) {
1.1.1.2 misho 765: /*
766: * The pipe is non-blocking, if we overflow the kernel's pipe
767: * buffer we drop the signal. This is not a problem in practice.
768: */
769: ignore_result(write(signal_pipe[1], &signo, sizeof(signo)));
770: }
1.1 misho 771: }
1.1.1.2 misho 772: #endif /* SA_SIGINFO */
1.1 misho 773:
774: /*
775: * Open a pipe and make both ends non-blocking.
776: * Returns 0 on success and -1 on error.
777: */
778: int
779: pipe_nonblock(int fds[2])
780: {
781: int flags, rval;
1.1.1.2 misho 782: debug_decl(pipe_nonblock, SUDO_DEBUG_EXEC)
1.1 misho 783:
784: rval = pipe(fds);
785: if (rval != -1) {
786: flags = fcntl(fds[0], F_GETFL, 0);
787: if (flags != -1 && !ISSET(flags, O_NONBLOCK))
788: rval = fcntl(fds[0], F_SETFL, flags | O_NONBLOCK);
789: if (rval != -1) {
790: flags = fcntl(fds[1], F_GETFL, 0);
791: if (flags != -1 && !ISSET(flags, O_NONBLOCK))
792: rval = fcntl(fds[1], F_SETFL, flags | O_NONBLOCK);
793: }
794: if (rval == -1) {
795: close(fds[0]);
796: close(fds[1]);
797: }
798: }
799:
1.1.1.2 misho 800: debug_return_int(rval);
1.1 misho 801: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to exec.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