Annotation of src/usr.bin/sudo/logging.c, Revision 1.1
1.1 ! millert 1: /*
! 2: * Copyright (c) 1994-1996,1998-1999 Todd C. Miller <Todd.Miller@courtesan.com>
! 3: * All rights reserved.
! 4: *
! 5: * Redistribution and use in source and binary forms, with or without
! 6: * modification, are permitted provided that the following conditions
! 7: * are met:
! 8: *
! 9: * 1. Redistributions of source code must retain the above copyright
! 10: * notice, this list of conditions and the following disclaimer.
! 11: *
! 12: * 2. Redistributions in binary form must reproduce the above copyright
! 13: * notice, this list of conditions and the following disclaimer in the
! 14: * documentation and/or other materials provided with the distribution.
! 15: *
! 16: * 3. The name of the author may not be used to endorse or promote products
! 17: * derived from this software without specific prior written permission.
! 18: *
! 19: * 4. Products derived from this software may not be called "Sudo" nor
! 20: * may "Sudo" appear in their names without specific prior written
! 21: * permission from the author.
! 22: *
! 23: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
! 24: * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
! 25: * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
! 26: * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
! 27: * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
! 28: * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
! 29: * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
! 30: * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
! 31: * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
! 32: * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 33: */
! 34:
! 35: #include "config.h"
! 36:
! 37: #include <stdio.h>
! 38: #ifdef STDC_HEADERS
! 39: #include <stdlib.h>
! 40: #endif /* STDC_HEADERS */
! 41: #ifdef HAVE_UNISTD_H
! 42: #include <unistd.h>
! 43: #endif /* HAVE_UNISTD_H */
! 44: #ifdef HAVE_STRING_H
! 45: #include <string.h>
! 46: #endif /* HAVE_STRING_H */
! 47: #ifdef HAVE_STRINGS_H
! 48: #include <strings.h>
! 49: #endif /* HAVE_STRINGS_H */
! 50: #include <pwd.h>
! 51: #include <signal.h>
! 52: #include <time.h>
! 53: #include <errno.h>
! 54: #include <sys/types.h>
! 55: #include <sys/param.h>
! 56: #include <sys/stat.h>
! 57: #include <sys/wait.h>
! 58:
! 59: #include "sudo.h"
! 60:
! 61: #ifndef lint
! 62: static const char rcsid[] = "$Sudo: logging.c,v 1.139 1999/10/09 05:01:48 millert Exp $";
! 63: #endif /* lint */
! 64:
! 65: static void do_syslog __P((int, char *));
! 66: static void do_logfile __P((char *));
! 67: static void send_mail __P((char *));
! 68: static void mail_auth __P((int, char *));
! 69: static char *get_timestr __P((void));
! 70:
! 71: #ifdef BROKEN_SYSLOG
! 72: # define MAXSYSLOGTRIES 16 /* num of retries for broken syslogs */
! 73: # define SYSLOG syslog_wrapper
! 74:
! 75: static void syslog_wrapper __P((int, char *, char *, char *));
! 76:
! 77: /*
! 78: * Some versions of syslog(3) don't guarantee success and return
! 79: * an int (notably HP-UX < 10.0). So, if at first we don't succeed,
! 80: * try, try again...
! 81: */
! 82: static void
! 83: syslog_wrapper(pri, fmt, ap)
! 84: int pri;
! 85: const char *fmt;
! 86: va_list ap;
! 87: {
! 88: int i;
! 89:
! 90: for (i = 0; i < MAXSYSLOGTRIES; i++)
! 91: if (vsyslog(pri, fmt, ap) == 0)
! 92: break;
! 93: }
! 94: #else
! 95: # define SYSLOG syslog
! 96: #endif /* BROKEN_SYSLOG */
! 97:
! 98: /*
! 99: * Log a message to syslog, pre-pending the username and splitting the
! 100: * message into parts if it is longer than MAXSYSLOGLEN.
! 101: */
! 102: static void
! 103: do_syslog(pri, msg)
! 104: int pri;
! 105: char *msg;
! 106: {
! 107: int count;
! 108: char *p;
! 109: char *tmp;
! 110: char save;
! 111:
! 112: /*
! 113: * Log the full line, breaking into multiple syslog(3) calls if necessary
! 114: */
! 115: for (p = msg, count = 0; count < strlen(msg) / MAXSYSLOGLEN + 1; count++) {
! 116: if (strlen(p) > MAXSYSLOGLEN) {
! 117: /*
! 118: * Break up the line into what will fit on one syslog(3) line
! 119: * Try to break on a word boundary if possible.
! 120: */
! 121: for (tmp = p + MAXSYSLOGLEN; tmp > p && *tmp != ' '; tmp--)
! 122: ;
! 123: if (tmp <= p)
! 124: tmp = p + MAXSYSLOGLEN;
! 125:
! 126: /* NULL terminate line, but save the char to restore later */
! 127: save = *tmp;
! 128: *tmp = '\0';
! 129:
! 130: if (count == 0)
! 131: SYSLOG(pri, "%8.8s : %s", user_name, p);
! 132: else
! 133: SYSLOG(pri, "%8.8s : (command continued) %s", user_name, p);
! 134:
! 135: *tmp = save; /* restore saved character */
! 136:
! 137: /* Eliminate leading whitespace */
! 138: for (p = tmp; *p != ' '; p++)
! 139: ;
! 140: } else {
! 141: if (count == 0)
! 142: SYSLOG(pri, "%8.8s : %s", user_name, p);
! 143: else
! 144: SYSLOG(pri, "%8.8s : (command continued) %s", user_name, p);
! 145: }
! 146: }
! 147: }
! 148:
! 149: static void
! 150: do_logfile(msg)
! 151: char *msg;
! 152: {
! 153: char *full_line;
! 154: char *beg, *oldend, *end;
! 155: FILE *fp;
! 156: mode_t oldmask;
! 157: int maxlen = def_ival(I_LOGLEN);
! 158:
! 159: oldmask = umask(077);
! 160: fp = fopen(def_str(I_LOGFILE), "a");
! 161: (void) umask(oldmask);
! 162: if (fp == NULL) {
! 163: easprintf(&full_line, "Can't open log file: %s: %s",
! 164: def_str(I_LOGFILE), strerror(errno));
! 165: send_mail(full_line);
! 166: free(full_line);
! 167: } else if (!lock_file(fileno(fp), SUDO_LOCK)) {
! 168: easprintf(&full_line, "Can't lock log file: %s: %s",
! 169: def_str(I_LOGFILE), strerror(errno));
! 170: send_mail(full_line);
! 171: free(full_line);
! 172: } else {
! 173: if (def_ival(I_LOGLEN) == 0) {
! 174: /* Don't pretty-print long log file lines (hard to grep) */
! 175: if (def_flag(I_LOG_HOST))
! 176: (void) fprintf(fp, "%s : %s : HOST=%s : %s\n", get_timestr(),
! 177: user_name, user_shost, msg);
! 178: else
! 179: (void) fprintf(fp, "%s : %s : %s\n", get_timestr(),
! 180: user_name, msg);
! 181: } else {
! 182: if (def_flag(I_LOG_HOST))
! 183: easprintf(&full_line, "%s : %s : HOST=%s : %s", get_timestr(),
! 184: user_name, user_shost, msg);
! 185: else
! 186: easprintf(&full_line, "%s : %s : %s", get_timestr(),
! 187: user_name, msg);
! 188:
! 189: /*
! 190: * Print out full_line with word wrap
! 191: */
! 192: beg = end = full_line;
! 193: while (beg) {
! 194: oldend = end;
! 195: end = strchr(oldend, ' ');
! 196:
! 197: if (maxlen > 0 && end) {
! 198: *end = '\0';
! 199: if (strlen(beg) > maxlen) {
! 200: /* too far, need to back up & print the line */
! 201:
! 202: if (beg == (char *)full_line)
! 203: maxlen -= 4; /* don't indent first line */
! 204:
! 205: *end = ' ';
! 206: if (oldend != beg) {
! 207: /* rewind & print */
! 208: end = oldend-1;
! 209: while (*end == ' ')
! 210: --end;
! 211: *(++end) = '\0';
! 212: (void) fprintf(fp, "%s\n ", beg);
! 213: *end = ' ';
! 214: } else {
! 215: (void) fprintf(fp, "%s\n ", beg);
! 216: }
! 217:
! 218: /* reset beg to point to the start of the new substr */
! 219: beg = end;
! 220: while (*beg == ' ')
! 221: ++beg;
! 222: } else {
! 223: /* we still have room */
! 224: *end = ' ';
! 225: }
! 226:
! 227: /* remove leading whitespace */
! 228: while (*end == ' ')
! 229: ++end;
! 230: } else {
! 231: /* final line */
! 232: (void) fprintf(fp, "%s\n", beg);
! 233: beg = NULL; /* exit condition */
! 234: }
! 235: }
! 236: free(full_line);
! 237: }
! 238: (void) fflush(fp);
! 239: (void) lock_file(fileno(fp), SUDO_UNLOCK);
! 240: (void) fclose(fp);
! 241: }
! 242: }
! 243:
! 244: /*
! 245: * Two main functions, log_error() to log errors and log_auth() to
! 246: * log allow/deny messages.
! 247: */
! 248: void
! 249: log_auth(status, inform_user)
! 250: int status;
! 251: int inform_user;
! 252: {
! 253: char *message;
! 254: char *logline;
! 255: int pri;
! 256:
! 257: if (status & VALIDATE_OK)
! 258: pri = def_ival(I_GOODPRI);
! 259: else
! 260: pri = def_ival(I_BADPRI);
! 261:
! 262: /* Set error message, if any. */
! 263: if (status & VALIDATE_OK)
! 264: message = "";
! 265: else if (status & FLAG_NO_USER)
! 266: message = "user NOT in sudoers ; ";
! 267: else if (status & FLAG_NO_HOST)
! 268: message = "user NOT authorized on host ; ";
! 269: else if (status & VALIDATE_NOT_OK)
! 270: message = "command not allowed ; ";
! 271: else
! 272: message = "unknown error ; ";
! 273:
! 274: easprintf(&logline, "%sTTY=%s ; PWD=%s ; USER=%s ; COMMAND=%s%s%s",
! 275: message, user_tty, user_cwd, *user_runas, user_cmnd,
! 276: user_args ? " " : "", user_args ? user_args : "");
! 277:
! 278: mail_auth(status, logline); /* send mail based on status */
! 279:
! 280: /* Inform the user if they failed to authenticate. */
! 281: if (inform_user && (status & VALIDATE_NOT_OK)) {
! 282: if (status & FLAG_NO_USER)
! 283: (void) fprintf(stderr, "%s is not in the sudoers file. %s",
! 284: user_name, "This incident will be reported.\n");
! 285: else if (status & FLAG_NO_HOST)
! 286: (void) fprintf(stderr, "%s is not allowed to run sudo on %s. %s",
! 287: user_name, user_shost, "This incident will be reported.\n");
! 288: else if (status & FLAG_NO_CHECK)
! 289: (void) fprintf(stderr, "Sorry, user %s may not run sudo on %s.\n",
! 290: user_name, user_shost);
! 291: else
! 292: (void) fprintf(stderr,
! 293: "Sorry, user %s is not allowed to execute '%s%s%s' as %s on %s.\n",
! 294: user_name, user_cmnd, user_args ? " " : "",
! 295: user_args ? user_args : "", *user_runas, user_host);
! 296: }
! 297:
! 298: /*
! 299: * Log via syslog and/or a file.
! 300: */
! 301: if (def_str(I_LOGFACSTR))
! 302: do_syslog(pri, logline);
! 303: if (def_str(I_LOGFILE))
! 304: do_logfile(logline);
! 305:
! 306: free(logline);
! 307: }
! 308:
! 309: void
! 310: #ifdef __STDC__
! 311: log_error(int flags, const char *fmt, ...)
! 312: #else
! 313: log_error(va_alist)
! 314: va_dcl
! 315: #endif
! 316: {
! 317: int serrno = errno;
! 318: char *message;
! 319: char *logline;
! 320: va_list ap;
! 321: #ifdef __STDC__
! 322: va_start(ap, fmt);
! 323: #else
! 324: int flags;
! 325: const char *fmt;
! 326:
! 327: va_start(ap);
! 328: flags = va_arg(ap, int);
! 329: fmt = va_arg(ap, const char *);
! 330: #endif
! 331:
! 332: /* Become root if we are not already to avoid user control */
! 333: if (geteuid() != 0)
! 334: set_perms(PERM_ROOT, 0);
! 335:
! 336: /* Expand printf-style format + args. */
! 337: evasprintf(&message, fmt, ap);
! 338: va_end(ap);
! 339:
! 340: if (flags & MSG_ONLY)
! 341: logline = message;
! 342: else if (flags & USE_ERRNO) {
! 343: if (user_args) {
! 344: easprintf(&logline,
! 345: "%s: %s ; TTY=%s ; PWD=%s ; USER=%s ; COMMAND=%s %s",
! 346: message, strerror(serrno), user_tty, user_cwd, *user_runas,
! 347: user_cmnd, user_args);
! 348: } else {
! 349: easprintf(&logline,
! 350: "%s: %s ; TTY=%s ; PWD=%s ; USER=%s ; COMMAND=%s", message,
! 351: strerror(serrno), user_tty, user_cwd, *user_runas, user_cmnd);
! 352: }
! 353: } else {
! 354: if (user_args) {
! 355: easprintf(&logline,
! 356: "%s ; TTY=%s ; PWD=%s ; USER=%s ; COMMAND=%s %s", message,
! 357: user_tty, user_cwd, *user_runas, user_cmnd, user_args);
! 358: } else {
! 359: easprintf(&logline,
! 360: "%s ; TTY=%s ; PWD=%s ; USER=%s ; COMMAND=%s", message,
! 361: user_tty, user_cwd, *user_runas, user_cmnd);
! 362: }
! 363: }
! 364:
! 365: /*
! 366: * Tell the user.
! 367: */
! 368: (void) fprintf(stderr, "%s: %s", Argv[0], message);
! 369: if (flags & USE_ERRNO)
! 370: (void) fprintf(stderr, ": %s", strerror(serrno));
! 371: (void) fputc('\n', stderr);
! 372:
! 373: /*
! 374: * Send a copy of the error via mail.
! 375: */
! 376: if (!(flags & NO_MAIL))
! 377: send_mail(logline);
! 378:
! 379: /*
! 380: * Log to syslog and/or a file.
! 381: */
! 382: if (def_str(I_LOGFACSTR))
! 383: do_syslog(def_ival(I_BADPRI), logline);
! 384: if (def_str(I_LOGFILE))
! 385: do_logfile(logline);
! 386:
! 387: free(logline);
! 388: if (message != logline);
! 389: free(message);
! 390:
! 391: if (!(flags & NO_EXIT))
! 392: exit(1);
! 393: }
! 394:
! 395: #define MAX_MAILFLAGS 63
! 396:
! 397: /*
! 398: * Send a message to MAILTO user
! 399: */
! 400: static void
! 401: send_mail(line)
! 402: char *line;
! 403: {
! 404: FILE *mail;
! 405: char *p;
! 406: int pfd[2], pid;
! 407:
! 408: /* Just return if mailer is disabled. */
! 409: if (!def_str(I_MAILERPATH) || !def_str(I_MAILTO))
! 410: return;
! 411:
! 412: if ((pid = fork()) > 0) { /* Child. */
! 413:
! 414: /* We do an explicit wait() later on... */
! 415: (void) signal(SIGCHLD, SIG_IGN);
! 416:
! 417: if (pipe(pfd) == -1) {
! 418: (void) fprintf(stderr, "%s: cannot open pipe: %s\n",
! 419: Argv[0], strerror(errno));
! 420: exit(1);
! 421: }
! 422:
! 423: switch (pid = fork()) {
! 424: case -1:
! 425: /* Error. */
! 426: /* XXX - parent will continue, return an exit val to
! 427: let parent know and abort? */
! 428: (void) fprintf(stderr, "%s: cannot fork: %s\n",
! 429: Argv[0], strerror(errno));
! 430: exit(1);
! 431: break;
! 432: case 0:
! 433: {
! 434: char *argv[MAX_MAILFLAGS + 1];
! 435: char *mpath, *mflags;
! 436: int i;
! 437:
! 438: /* Grandchild. */
! 439: (void) close(pfd[1]);
! 440: (void) dup2(pfd[0], STDIN_FILENO);
! 441: (void) close(pfd[0]);
! 442:
! 443: /* Build up an argv based the mailer path and flags */
! 444: mflags = estrdup(def_str(I_MAILERFLAGS));
! 445: mpath = estrdup(def_str(I_MAILERPATH));
! 446: if ((argv[0] = strrchr(mpath, ' ')))
! 447: argv[0]++;
! 448: else
! 449: argv[0] = mpath;
! 450:
! 451: i = 1;
! 452: if ((p = strtok(mflags, " \t"))) {
! 453: do {
! 454: argv[i] = p;
! 455: } while (++i < MAX_MAILFLAGS && (p = strtok(NULL, " \t")));
! 456: }
! 457: argv[i] = NULL;
! 458:
! 459: /* Run mailer as root so user cannot kill it. */
! 460: set_perms(PERM_ROOT, 0);
! 461: execv(mpath, argv);
! 462: _exit(127);
! 463: }
! 464: break;
! 465: }
! 466:
! 467: mail = fdopen(pfd[1], "w");
! 468: (void) close(pfd[0]);
! 469:
! 470: /* Pipes are all setup, send message via sendmail. */
! 471: (void) fprintf(mail, "To: %s\nFrom: %s\nSubject: ",
! 472: def_str(I_MAILTO), user_name);
! 473: for (p = def_str(I_MAILSUB); *p; p++) {
! 474: /* Expand escapes in the subject */
! 475: if (*p == '%' && *(p+1) != '%') {
! 476: switch (*(++p)) {
! 477: case 'h':
! 478: (void) fputs(user_host, mail);
! 479: break;
! 480: case 'u':
! 481: (void) fputs(user_name, mail);
! 482: break;
! 483: default:
! 484: p--;
! 485: break;
! 486: }
! 487: } else
! 488: (void) fputc(*p, mail);
! 489: }
! 490: (void) fprintf(mail, "\n\n%s : %s : %s : %s\n\n", user_host,
! 491: get_timestr(), user_name, line);
! 492: fclose(mail);
! 493: reapchild(0);
! 494: _exit(0);
! 495: } else {
! 496: /* Parent, just return unless there is an error. */
! 497: if (pid == -1) {
! 498: (void) fprintf(stderr, "%s: cannot fork: %s\n",
! 499: Argv[0], strerror(errno));
! 500: exit(1);
! 501: }
! 502: }
! 503: }
! 504:
! 505: /*
! 506: * Send mail based on the value of "status" and compile-time options.
! 507: */
! 508: static void
! 509: mail_auth(status, line)
! 510: int status;
! 511: char *line;
! 512: {
! 513: int mail_mask;
! 514:
! 515: /* If any of these bits are set in status, we send mail. */
! 516: if (def_flag(I_MAIL_ALWAYS))
! 517: mail_mask =
! 518: VALIDATE_ERROR|VALIDATE_OK|FLAG_NO_USER|FLAG_NO_HOST|VALIDATE_NOT_OK;
! 519: else {
! 520: mail_mask = VALIDATE_ERROR;
! 521: if (def_flag(I_MAIL_NOUSER))
! 522: mail_mask |= FLAG_NO_USER;
! 523: if (def_flag(I_MAIL_NOHOST))
! 524: mail_mask |= FLAG_NO_HOST;
! 525: if (def_flag(I_MAIL_NOPERMS))
! 526: mail_mask |= VALIDATE_NOT_OK;
! 527: }
! 528:
! 529: if ((status & mail_mask) != 0)
! 530: send_mail(line);
! 531: }
! 532:
! 533: /*
! 534: * SIGCHLD sig handler--wait for children as they die.
! 535: */
! 536: RETSIGTYPE
! 537: reapchild(sig)
! 538: int sig;
! 539: {
! 540: int status, serrno = errno;
! 541:
! 542: #ifdef sudo_waitpid
! 543: while (sudo_waitpid(-1, &status, WNOHANG) != -1)
! 544: ;
! 545: #else
! 546: (void) wait(&status);
! 547: #endif
! 548: #ifndef POSIX_SIGNALS
! 549: (void) signal(SIGCHLD, reapchild);
! 550: #endif /* POSIX_SIGNALS */
! 551: errno = serrno;
! 552: }
! 553:
! 554: /*
! 555: * Return an ascii string with the current date + time
! 556: * Uses strftime() if available, else falls back to ctime().
! 557: */
! 558: static char *
! 559: get_timestr()
! 560: {
! 561: char *s;
! 562: time_t now = time((time_t) 0);
! 563: #ifdef HAVE_STRFTIME
! 564: static char buf[128];
! 565: struct tm *timeptr;
! 566:
! 567: timeptr = localtime(&now);
! 568: if (def_flag(I_LOG_YEAR))
! 569: s = "%h %e %T %Y";
! 570: else
! 571: s = "%h %e %T";
! 572:
! 573: /* strftime() does not guarantee to NUL-terminate so we must check. */
! 574: buf[sizeof(buf) - 1] = '\0';
! 575: if (strftime(buf, sizeof(buf), s, timeptr) && buf[sizeof(buf) - 1] == '\0')
! 576: return(buf);
! 577:
! 578: #endif /* HAVE_STRFTIME */
! 579:
! 580: s = ctime(&now) + 4; /* skip day of the week */
! 581: if (def_flag(I_LOG_YEAR))
! 582: s[20] = '\0'; /* avoid the newline */
! 583: else
! 584: s[15] = '\0'; /* don't care about year */
! 585:
! 586: return(s);
! 587: }
![[BACK]](/icons/back.gif){kind=icon}
Return to logging.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / sudo