Annotation of embedaddon/sudo/plugins/sudoers/iolog.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: #include <config.h>
! 18:
! 19: #include <sys/types.h>
! 20: #include <sys/param.h>
! 21: #include <sys/stat.h>
! 22: #include <sys/time.h>
! 23: #include <stdio.h>
! 24: #ifdef STDC_HEADERS
! 25: # include <stdlib.h>
! 26: # include <stddef.h>
! 27: #else
! 28: # ifdef HAVE_STDLIB_H
! 29: # include <stdlib.h>
! 30: # endif
! 31: #endif /* STDC_HEADERS */
! 32: #ifdef HAVE_STRING_H
! 33: # include <string.h>
! 34: #endif /* HAVE_STRING_H */
! 35: #ifdef HAVE_STRINGS_H
! 36: # include <strings.h>
! 37: #endif /* HAVE_STRINGS_H */
! 38: #ifdef HAVE_UNISTD_H
! 39: # include <unistd.h>
! 40: #endif /* HAVE_UNISTD_H */
! 41: #if TIME_WITH_SYS_TIME
! 42: # include <time.h>
! 43: #endif
! 44: #include <errno.h>
! 45: #include <fcntl.h>
! 46: #include <signal.h>
! 47: #include <setjmp.h>
! 48: #include <pwd.h>
! 49: #include <grp.h>
! 50: #ifdef HAVE_ZLIB_H
! 51: # include <zlib.h>
! 52: #endif
! 53:
! 54: #include "sudoers.h"
! 55:
! 56: /* plugin_error.c */
! 57: extern sigjmp_buf error_jmp;
! 58:
! 59: union io_fd {
! 60: FILE *f;
! 61: #ifdef HAVE_ZLIB_H
! 62: gzFile g;
! 63: #endif
! 64: void *v;
! 65: };
! 66:
! 67: struct script_buf {
! 68: int len; /* buffer length (how much read in) */
! 69: int off; /* write position (how much already consumed) */
! 70: char buf[16 * 1024];
! 71: };
! 72:
! 73: /* XXX - separate sudoers.h and iolog.h? */
! 74: #undef runas_pw
! 75: #undef runas_gr
! 76:
! 77: struct iolog_details {
! 78: const char *cwd;
! 79: const char *tty;
! 80: const char *user;
! 81: const char *command;
! 82: const char *iolog_path;
! 83: struct passwd *runas_pw;
! 84: struct group *runas_gr;
! 85: int iolog_stdin;
! 86: int iolog_stdout;
! 87: int iolog_stderr;
! 88: int iolog_ttyin;
! 89: int iolog_ttyout;
! 90: };
! 91:
! 92: #define IOFD_STDIN 0
! 93: #define IOFD_STDOUT 1
! 94: #define IOFD_STDERR 2
! 95: #define IOFD_TTYIN 3
! 96: #define IOFD_TTYOUT 4
! 97: #define IOFD_TIMING 5
! 98: #define IOFD_MAX 6
! 99:
! 100: #define SESSID_MAX 2176782336U
! 101:
! 102: static int iolog_compress;
! 103: static struct timeval last_time;
! 104: static union io_fd io_fds[IOFD_MAX];
! 105: extern struct io_plugin sudoers_io;
! 106:
! 107: /*
! 108: * Create parent directories for path as needed, but not path itself.
! 109: */
! 110: static void
! 111: mkdir_parents(char *path)
! 112: {
! 113: struct stat sb;
! 114: char *slash = path;
! 115:
! 116: for (;;) {
! 117: if ((slash = strchr(slash + 1, '/')) == NULL)
! 118: break;
! 119: *slash = '\0';
! 120: if (stat(path, &sb) != 0) {
! 121: if (mkdir(path, S_IRWXU) != 0)
! 122: log_error(USE_ERRNO, _("unable to mkdir %s"), path);
! 123: } else if (!S_ISDIR(sb.st_mode)) {
! 124: log_error(0, _("%s: %s"), path, strerror(ENOTDIR));
! 125: }
! 126: *slash = '/';
! 127: }
! 128: }
! 129:
! 130: /*
! 131: * Read the on-disk sequence number, set sessid to the next
! 132: * number, and update the on-disk copy.
! 133: * Uses file locking to avoid sequence number collisions.
! 134: */
! 135: void
! 136: io_nextid(char *iolog_dir, char sessid[7])
! 137: {
! 138: struct stat sb;
! 139: char buf[32], *ep;
! 140: int fd, i;
! 141: unsigned long id = 0;
! 142: int len;
! 143: ssize_t nread;
! 144: char pathbuf[PATH_MAX];
! 145: static const char b36char[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
! 146:
! 147: /*
! 148: * Create I/O log directory if it doesn't already exist.
! 149: */
! 150: mkdir_parents(iolog_dir);
! 151: if (stat(iolog_dir, &sb) != 0) {
! 152: if (mkdir(iolog_dir, S_IRWXU) != 0)
! 153: log_error(USE_ERRNO, _("unable to mkdir %s"), iolog_dir);
! 154: } else if (!S_ISDIR(sb.st_mode)) {
! 155: log_error(0, _("%s exists but is not a directory (0%o)"),
! 156: iolog_dir, (unsigned int) sb.st_mode);
! 157: }
! 158:
! 159: /*
! 160: * Open sequence file
! 161: */
! 162: len = snprintf(pathbuf, sizeof(pathbuf), "%s/seq", iolog_dir);
! 163: if (len <= 0 || len >= sizeof(pathbuf)) {
! 164: errno = ENAMETOOLONG;
! 165: log_error(USE_ERRNO, "%s/seq", pathbuf);
! 166: }
! 167: fd = open(pathbuf, O_RDWR|O_CREAT, S_IRUSR|S_IWUSR);
! 168: if (fd == -1)
! 169: log_error(USE_ERRNO, _("unable to open %s"), pathbuf);
! 170: lock_file(fd, SUDO_LOCK);
! 171:
! 172: /* Read seq number (base 36). */
! 173: nread = read(fd, buf, sizeof(buf));
! 174: if (nread != 0) {
! 175: if (nread == -1)
! 176: log_error(USE_ERRNO, _("unable to read %s"), pathbuf);
! 177: id = strtoul(buf, &ep, 36);
! 178: if (buf == ep || id >= SESSID_MAX)
! 179: log_error(0, _("invalid sequence number %s"), pathbuf);
! 180: }
! 181: id++;
! 182:
! 183: /*
! 184: * Convert id to a string and stash in sessid.
! 185: * Note that that least significant digits go at the end of the string.
! 186: */
! 187: for (i = 5; i >= 0; i--) {
! 188: buf[i] = b36char[id % 36];
! 189: id /= 36;
! 190: }
! 191: buf[6] = '\n';
! 192:
! 193: /* Stash id logging purposes */
! 194: memcpy(sessid, buf, 6);
! 195: sessid[6] = '\0';
! 196:
! 197: /* Rewind and overwrite old seq file. */
! 198: if (lseek(fd, 0, SEEK_SET) == (off_t)-1 || write(fd, buf, 7) != 7)
! 199: log_error(USE_ERRNO, _("unable to write to %s"), pathbuf);
! 200: close(fd);
! 201: }
! 202:
! 203: /*
! 204: * Copy iolog_path to pathbuf and create the directory and any intermediate
! 205: * directories. If iolog_path ends in 'XXXXXX', use mkdtemp().
! 206: */
! 207: static size_t
! 208: mkdir_iopath(const char *iolog_path, char *pathbuf, size_t pathsize)
! 209: {
! 210: size_t len;
! 211:
! 212: len = strlcpy(pathbuf, iolog_path, pathsize);
! 213: if (len >= pathsize) {
! 214: errno = ENAMETOOLONG;
! 215: log_error(USE_ERRNO, "%s", iolog_path);
! 216: }
! 217:
! 218: /*
! 219: * Create path and intermediate subdirs as needed.
! 220: * If path ends in at least 6 Xs (ala POSIX mktemp), use mkdtemp().
! 221: */
! 222: mkdir_parents(pathbuf);
! 223: if (len >= 6 && strcmp(&pathbuf[len - 6], "XXXXXX") == 0) {
! 224: if (mkdtemp(pathbuf) == NULL)
! 225: log_error(USE_ERRNO, _("unable to create %s"), pathbuf);
! 226: } else {
! 227: if (mkdir(pathbuf, S_IRWXU) != 0)
! 228: log_error(USE_ERRNO, _("unable to create %s"), pathbuf);
! 229: }
! 230:
! 231: return len;
! 232: }
! 233:
! 234: /*
! 235: * Append suffix to pathbuf after len chars and open the resulting file.
! 236: * Note that the size of pathbuf is assumed to be PATH_MAX.
! 237: * Uses zlib if docompress is TRUE.
! 238: * Returns the open file handle which has the close-on-exec flag set.
! 239: */
! 240: static void *
! 241: open_io_fd(char *pathbuf, size_t len, const char *suffix, int docompress)
! 242: {
! 243: void *vfd = NULL;
! 244: int fd;
! 245:
! 246: pathbuf[len] = '\0';
! 247: strlcat(pathbuf, suffix, PATH_MAX);
! 248: fd = open(pathbuf, O_CREAT|O_EXCL|O_WRONLY, S_IRUSR|S_IWUSR);
! 249: if (fd != -1) {
! 250: fcntl(fd, F_SETFD, FD_CLOEXEC);
! 251: #ifdef HAVE_ZLIB_H
! 252: if (docompress)
! 253: vfd = gzdopen(fd, "w");
! 254: else
! 255: #endif
! 256: vfd = fdopen(fd, "w");
! 257: }
! 258: return vfd;
! 259: }
! 260:
! 261: /*
! 262: * Pull out I/O log related data from user_info and command_info arrays.
! 263: */
! 264: static void
! 265: iolog_deserialize_info(struct iolog_details *details, char * const user_info[],
! 266: char * const command_info[])
! 267: {
! 268: const char *runas_uid_str = "0", *runas_euid_str = NULL;
! 269: const char *runas_gid_str = "0", *runas_egid_str = NULL;
! 270: char id[MAX_UID_T_LEN + 2], *ep;
! 271: char * const *cur;
! 272: unsigned long ulval;
! 273: uid_t runas_uid = 0;
! 274: gid_t runas_gid = 0;
! 275:
! 276: memset(details, 0, sizeof(*details));
! 277:
! 278: for (cur = user_info; *cur != NULL; cur++) {
! 279: switch (**cur) {
! 280: case 'c':
! 281: if (strncmp(*cur, "cwd=", sizeof("cwd=") - 1) == 0) {
! 282: details->cwd = *cur + sizeof("cwd=") - 1;
! 283: continue;
! 284: }
! 285: break;
! 286: case 't':
! 287: if (strncmp(*cur, "tty=", sizeof("tty=") - 1) == 0) {
! 288: details->tty = *cur + sizeof("tty=") - 1;
! 289: continue;
! 290: }
! 291: break;
! 292: case 'u':
! 293: if (strncmp(*cur, "user=", sizeof("user=") - 1) == 0) {
! 294: details->user = *cur + sizeof("user=") - 1;
! 295: continue;
! 296: }
! 297: break;
! 298: }
! 299: }
! 300:
! 301: for (cur = command_info; *cur != NULL; cur++) {
! 302: switch (**cur) {
! 303: case 'c':
! 304: if (strncmp(*cur, "command=", sizeof("command=") - 1) == 0) {
! 305: details->command = *cur + sizeof("command=") - 1;
! 306: continue;
! 307: }
! 308: break;
! 309: case 'i':
! 310: if (strncmp(*cur, "iolog_path=", sizeof("iolog_path=") - 1) == 0) {
! 311: details->iolog_path = *cur + sizeof("iolog_path=") - 1;
! 312: continue;
! 313: }
! 314: if (strncmp(*cur, "iolog_stdin=", sizeof("iolog_stdin=") - 1) == 0) {
! 315: if (atobool(*cur + sizeof("iolog_stdin=") - 1) == TRUE)
! 316: details->iolog_stdin = TRUE;
! 317: continue;
! 318: }
! 319: if (strncmp(*cur, "iolog_stdout=", sizeof("iolog_stdout=") - 1) == 0) {
! 320: if (atobool(*cur + sizeof("iolog_stdout=") - 1) == TRUE)
! 321: details->iolog_stdout = TRUE;
! 322: continue;
! 323: }
! 324: if (strncmp(*cur, "iolog_stderr=", sizeof("iolog_stderr=") - 1) == 0) {
! 325: if (atobool(*cur + sizeof("iolog_stderr=") - 1) == TRUE)
! 326: details->iolog_stderr = TRUE;
! 327: continue;
! 328: }
! 329: if (strncmp(*cur, "iolog_ttyin=", sizeof("iolog_ttyin=") - 1) == 0) {
! 330: if (atobool(*cur + sizeof("iolog_ttyin=") - 1) == TRUE)
! 331: details->iolog_ttyin = TRUE;
! 332: continue;
! 333: }
! 334: if (strncmp(*cur, "iolog_ttyout=", sizeof("iolog_ttyout=") - 1) == 0) {
! 335: if (atobool(*cur + sizeof("iolog_ttyout=") - 1) == TRUE)
! 336: details->iolog_ttyout = TRUE;
! 337: continue;
! 338: }
! 339: if (strncmp(*cur, "iolog_compress=", sizeof("iolog_compress=") - 1) == 0) {
! 340: if (atobool(*cur + sizeof("iolog_compress=") - 1) == TRUE)
! 341: iolog_compress = TRUE; /* must be global */
! 342: continue;
! 343: }
! 344: break;
! 345: case 'r':
! 346: if (strncmp(*cur, "runas_gid=", sizeof("runas_gid=") - 1) == 0) {
! 347: runas_gid_str = *cur + sizeof("runas_gid=") - 1;
! 348: continue;
! 349: }
! 350: if (strncmp(*cur, "runas_egid=", sizeof("runas_egid=") - 1) == 0) {
! 351: runas_egid_str = *cur + sizeof("runas_egid=") - 1;
! 352: continue;
! 353: }
! 354: if (strncmp(*cur, "runas_uid=", sizeof("runas_uid=") - 1) == 0) {
! 355: runas_uid_str = *cur + sizeof("runas_uid=") - 1;
! 356: continue;
! 357: }
! 358: if (strncmp(*cur, "runas_euid=", sizeof("runas_euid=") - 1) == 0) {
! 359: runas_euid_str = *cur + sizeof("runas_euid=") - 1;
! 360: continue;
! 361: }
! 362: break;
! 363: }
! 364: }
! 365:
! 366: /*
! 367: * Lookup runas user and group, preferring effective over real uid/gid.
! 368: */
! 369: if (runas_euid_str != NULL)
! 370: runas_uid_str = runas_euid_str;
! 371: if (runas_uid_str != NULL) {
! 372: errno = 0;
! 373: ulval = strtoul(runas_uid_str, &ep, 0);
! 374: if (*runas_uid_str != '\0' && *ep == '\0' &&
! 375: (errno != ERANGE || ulval != ULONG_MAX)) {
! 376: runas_uid = (uid_t)ulval;
! 377: }
! 378: }
! 379: if (runas_egid_str != NULL)
! 380: runas_gid_str = runas_egid_str;
! 381: if (runas_gid_str != NULL) {
! 382: errno = 0;
! 383: ulval = strtoul(runas_gid_str, &ep, 0);
! 384: if (*runas_gid_str != '\0' && *ep == '\0' &&
! 385: (errno != ERANGE || ulval != ULONG_MAX)) {
! 386: runas_gid = (gid_t)ulval;
! 387: }
! 388: }
! 389:
! 390: details->runas_pw = sudo_getpwuid(runas_uid);
! 391: if (details->runas_pw == NULL) {
! 392: id[0] = '#';
! 393: strlcpy(&id[1], runas_uid_str, sizeof(id) - 1);
! 394: details->runas_pw = sudo_fakepwnam(id, runas_gid);
! 395: }
! 396:
! 397: if (runas_gid != details->runas_pw->pw_gid) {
! 398: details->runas_gr = sudo_getgrgid(runas_gid);
! 399: if (details->runas_gr == NULL) {
! 400: id[0] = '#';
! 401: strlcpy(&id[1], runas_gid_str, sizeof(id) - 1);
! 402: details->runas_gr = sudo_fakegrnam(id);
! 403: }
! 404: }
! 405: }
! 406:
! 407: static int
! 408: sudoers_io_open(unsigned int version, sudo_conv_t conversation,
! 409: sudo_printf_t plugin_printf, char * const settings[],
! 410: char * const user_info[], char * const command_info[],
! 411: int argc, char * const argv[], char * const user_env[])
! 412: {
! 413: struct iolog_details details;
! 414: char pathbuf[PATH_MAX], sessid[7];
! 415: char *tofree = NULL;
! 416: char * const *cur;
! 417: FILE *io_logfile;
! 418: size_t len;
! 419: int rval = -1;
! 420:
! 421: if (!sudo_conv)
! 422: sudo_conv = conversation;
! 423: if (!sudo_printf)
! 424: sudo_printf = plugin_printf;
! 425:
! 426: /* If we have no command (because -V was specified) just return. */
! 427: if (argc == 0)
! 428: return TRUE;
! 429:
! 430: if (sigsetjmp(error_jmp, 1)) {
! 431: /* called via error(), errorx() or log_error() */
! 432: rval = -1;
! 433: goto done;
! 434: }
! 435:
! 436: bindtextdomain("sudoers", LOCALEDIR);
! 437:
! 438: sudo_setpwent();
! 439: sudo_setgrent();
! 440:
! 441: /*
! 442: * Pull iolog settings out of command_info, if any.
! 443: */
! 444: iolog_deserialize_info(&details, user_info, command_info);
! 445: /* Did policy module disable I/O logging? */
! 446: if (!details.iolog_stdin && !details.iolog_ttyin &&
! 447: !details.iolog_stdout && !details.iolog_stderr &&
! 448: !details.iolog_ttyout) {
! 449: rval = FALSE;
! 450: goto done;
! 451: }
! 452:
! 453: /* If no I/O log path defined we need to figure it out ourselves. */
! 454: if (details.iolog_path == NULL) {
! 455: /* Get next session ID and convert it into a path. */
! 456: tofree = emalloc(sizeof(_PATH_SUDO_IO_LOGDIR) + sizeof(sessid) + 2);
! 457: memcpy(tofree, _PATH_SUDO_IO_LOGDIR, sizeof(_PATH_SUDO_IO_LOGDIR));
! 458: io_nextid(tofree, sessid);
! 459: snprintf(tofree + sizeof(_PATH_SUDO_IO_LOGDIR), sizeof(sessid) + 2,
! 460: "%c%c/%c%c/%c%c", sessid[0], sessid[1], sessid[2], sessid[3],
! 461: sessid[4], sessid[5]);
! 462: details.iolog_path = tofree;
! 463: }
! 464:
! 465: /*
! 466: * Make local copy of I/O log path and create it, along with any
! 467: * intermediate subdirs. Calls mkdtemp() if iolog_path ends in XXXXXX.
! 468: */
! 469: len = mkdir_iopath(details.iolog_path, pathbuf, sizeof(pathbuf));
! 470: if (len >= sizeof(pathbuf))
! 471: goto done;
! 472:
! 473: /*
! 474: * We create 7 files: a log file, a timing file and 5 for input/output.
! 475: */
! 476: io_logfile = open_io_fd(pathbuf, len, "/log", FALSE);
! 477: if (io_logfile == NULL)
! 478: log_error(USE_ERRNO, _("unable to create %s"), pathbuf);
! 479:
! 480: io_fds[IOFD_TIMING].v = open_io_fd(pathbuf, len, "/timing",
! 481: iolog_compress);
! 482: if (io_fds[IOFD_TIMING].v == NULL)
! 483: log_error(USE_ERRNO, _("unable to create %s"), pathbuf);
! 484:
! 485: if (details.iolog_ttyin) {
! 486: io_fds[IOFD_TTYIN].v = open_io_fd(pathbuf, len, "/ttyin",
! 487: iolog_compress);
! 488: if (io_fds[IOFD_TTYIN].v == NULL)
! 489: log_error(USE_ERRNO, _("unable to create %s"), pathbuf);
! 490: } else {
! 491: sudoers_io.log_ttyin = NULL;
! 492: }
! 493: if (details.iolog_stdin) {
! 494: io_fds[IOFD_STDIN].v = open_io_fd(pathbuf, len, "/stdin",
! 495: iolog_compress);
! 496: if (io_fds[IOFD_STDIN].v == NULL)
! 497: log_error(USE_ERRNO, _("unable to create %s"), pathbuf);
! 498: } else {
! 499: sudoers_io.log_stdin = NULL;
! 500: }
! 501: if (details.iolog_ttyout) {
! 502: io_fds[IOFD_TTYOUT].v = open_io_fd(pathbuf, len, "/ttyout",
! 503: iolog_compress);
! 504: if (io_fds[IOFD_TTYOUT].v == NULL)
! 505: log_error(USE_ERRNO, _("unable to create %s"), pathbuf);
! 506: } else {
! 507: sudoers_io.log_ttyout = NULL;
! 508: }
! 509: if (details.iolog_stdout) {
! 510: io_fds[IOFD_STDOUT].v = open_io_fd(pathbuf, len, "/stdout",
! 511: iolog_compress);
! 512: if (io_fds[IOFD_STDOUT].v == NULL)
! 513: log_error(USE_ERRNO, _("unable to create %s"), pathbuf);
! 514: } else {
! 515: sudoers_io.log_stdout = NULL;
! 516: }
! 517: if (details.iolog_stderr) {
! 518: io_fds[IOFD_STDERR].v = open_io_fd(pathbuf, len, "/stderr",
! 519: iolog_compress);
! 520: if (io_fds[IOFD_STDERR].v == NULL)
! 521: log_error(USE_ERRNO, _("unable to create %s"), pathbuf);
! 522: } else {
! 523: sudoers_io.log_stderr = NULL;
! 524: }
! 525:
! 526: gettimeofday(&last_time, NULL);
! 527:
! 528: fprintf(io_logfile, "%ld:%s:%s:%s:%s\n", (long)last_time.tv_sec,
! 529: details.user ? details.user : "unknown", details.runas_pw->pw_name,
! 530: details.runas_gr ? details.runas_gr->gr_name : "",
! 531: details.tty ? details.tty : "unknown");
! 532: fputs(details.cwd ? details.cwd : "unknown", io_logfile);
! 533: fputc('\n', io_logfile);
! 534: fputs(details.command ? details.command : "unknown", io_logfile);
! 535: for (cur = &argv[1]; *cur != NULL; cur++) {
! 536: fputc(' ', io_logfile);
! 537: fputs(*cur, io_logfile);
! 538: }
! 539: fputc('\n', io_logfile);
! 540: fclose(io_logfile);
! 541:
! 542: rval = TRUE;
! 543:
! 544: done:
! 545: efree(tofree);
! 546: if (details.runas_pw)
! 547: pw_delref(details.runas_pw);
! 548: sudo_endpwent();
! 549: if (details.runas_gr)
! 550: gr_delref(details.runas_gr);
! 551: sudo_endgrent();
! 552:
! 553: return rval;
! 554: }
! 555:
! 556: static void
! 557: sudoers_io_close(int exit_status, int error)
! 558: {
! 559: int i;
! 560:
! 561: if (sigsetjmp(error_jmp, 1)) {
! 562: /* called via error(), errorx() or log_error() */
! 563: return;
! 564: }
! 565:
! 566: for (i = 0; i < IOFD_MAX; i++) {
! 567: if (io_fds[i].v == NULL)
! 568: continue;
! 569: #ifdef HAVE_ZLIB_H
! 570: if (iolog_compress)
! 571: gzclose(io_fds[i].g);
! 572: else
! 573: #endif
! 574: fclose(io_fds[i].f);
! 575: }
! 576: }
! 577:
! 578: static int
! 579: sudoers_io_version(int verbose)
! 580: {
! 581: if (sigsetjmp(error_jmp, 1)) {
! 582: /* called via error(), errorx() or log_error() */
! 583: return -1;
! 584: }
! 585:
! 586: sudo_printf(SUDO_CONV_INFO_MSG, "Sudoers I/O plugin version %s\n",
! 587: PACKAGE_VERSION);
! 588:
! 589: return TRUE;
! 590: }
! 591:
! 592: /*
! 593: * Generic I/O logging function. Called by the I/O logging entry points.
! 594: */
! 595: static int
! 596: sudoers_io_log(const char *buf, unsigned int len, int idx)
! 597: {
! 598: struct timeval now, delay;
! 599:
! 600: gettimeofday(&now, NULL);
! 601:
! 602: if (sigsetjmp(error_jmp, 1)) {
! 603: /* called via error(), errorx() or log_error() */
! 604: return -1;
! 605: }
! 606:
! 607: #ifdef HAVE_ZLIB_H
! 608: if (iolog_compress)
! 609: gzwrite(io_fds[idx].g, buf, len);
! 610: else
! 611: #endif
! 612: fwrite(buf, 1, len, io_fds[idx].f);
! 613: delay.tv_sec = now.tv_sec;
! 614: delay.tv_usec = now.tv_usec;
! 615: timevalsub(&delay, &last_time);
! 616: #ifdef HAVE_ZLIB_H
! 617: if (iolog_compress)
! 618: gzprintf(io_fds[IOFD_TIMING].g, "%d %f %d\n", idx,
! 619: delay.tv_sec + ((double)delay.tv_usec / 1000000), len);
! 620: else
! 621: #endif
! 622: fprintf(io_fds[IOFD_TIMING].f, "%d %f %d\n", idx,
! 623: delay.tv_sec + ((double)delay.tv_usec / 1000000), len);
! 624: last_time.tv_sec = now.tv_sec;
! 625: last_time.tv_usec = now.tv_usec;
! 626:
! 627: return TRUE;
! 628: }
! 629:
! 630: static int
! 631: sudoers_io_log_ttyin(const char *buf, unsigned int len)
! 632: {
! 633: return sudoers_io_log(buf, len, IOFD_TTYIN);
! 634: }
! 635:
! 636: static int
! 637: sudoers_io_log_ttyout(const char *buf, unsigned int len)
! 638: {
! 639: return sudoers_io_log(buf, len, IOFD_TTYOUT);
! 640: }
! 641:
! 642: static int
! 643: sudoers_io_log_stdin(const char *buf, unsigned int len)
! 644: {
! 645: return sudoers_io_log(buf, len, IOFD_STDIN);
! 646: }
! 647:
! 648: static int
! 649: sudoers_io_log_stdout(const char *buf, unsigned int len)
! 650: {
! 651: return sudoers_io_log(buf, len, IOFD_STDOUT);
! 652: }
! 653:
! 654: static int
! 655: sudoers_io_log_stderr(const char *buf, unsigned int len)
! 656: {
! 657: return sudoers_io_log(buf, len, IOFD_STDERR);
! 658: }
! 659:
! 660: struct io_plugin sudoers_io = {
! 661: SUDO_IO_PLUGIN,
! 662: SUDO_API_VERSION,
! 663: sudoers_io_open,
! 664: sudoers_io_close,
! 665: sudoers_io_version,
! 666: sudoers_io_log_ttyin,
! 667: sudoers_io_log_ttyout,
! 668: sudoers_io_log_stdin,
! 669: sudoers_io_log_stdout,
! 670: sudoers_io_log_stderr
! 671: };
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to iolog.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sudo / plugins / sudoers