[BACK]Return to iolog.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sudo / plugins / sudoers

Diff for /embedaddon/sudo/plugins/sudoers/iolog.c between versions 1.1.1.1 and 1.1.1.2

version 1.1.1.1, 2012/02/21 16:23:02 version 1.1.1.2, 2012/05/29 12:26:49
Line 112  mkdir_parents(char *path) Line 112  mkdir_parents(char *path)
 {  {
     struct stat sb;      struct stat sb;
     char *slash = path;      char *slash = path;
       debug_decl(mkdir_parents, SUDO_DEBUG_UTIL)
   
     for (;;) {      for (;;) {
         if ((slash = strchr(slash + 1, '/')) == NULL)          if ((slash = strchr(slash + 1, '/')) == NULL)
Line 119  mkdir_parents(char *path) Line 120  mkdir_parents(char *path)
         *slash = '\0';          *slash = '\0';
         if (stat(path, &sb) != 0) {          if (stat(path, &sb) != 0) {
             if (mkdir(path, S_IRWXU) != 0)              if (mkdir(path, S_IRWXU) != 0)
                log_error(USE_ERRNO, _("unable to mkdir %s"), path);                log_fatal(USE_ERRNO, _("unable to mkdir %s"), path);
         } else if (!S_ISDIR(sb.st_mode)) {          } else if (!S_ISDIR(sb.st_mode)) {
            log_error(0, _("%s: %s"), path, strerror(ENOTDIR));            log_fatal(0, _("%s: %s"), path, strerror(ENOTDIR));
         }          }
         *slash = '/';          *slash = '/';
     }      }
       debug_return;
 }  }
   
 /*  /*
Line 143  io_nextid(char *iolog_dir, char sessid[7]) Line 145  io_nextid(char *iolog_dir, char sessid[7])
     ssize_t nread;      ssize_t nread;
     char pathbuf[PATH_MAX];      char pathbuf[PATH_MAX];
     static const char b36char[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";      static const char b36char[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
       debug_decl(io_nextid, SUDO_DEBUG_UTIL)
   
     /*      /*
      * Create I/O log directory if it doesn't already exist.       * Create I/O log directory if it doesn't already exist.
Line 150  io_nextid(char *iolog_dir, char sessid[7]) Line 153  io_nextid(char *iolog_dir, char sessid[7])
     mkdir_parents(iolog_dir);      mkdir_parents(iolog_dir);
     if (stat(iolog_dir, &sb) != 0) {      if (stat(iolog_dir, &sb) != 0) {
         if (mkdir(iolog_dir, S_IRWXU) != 0)          if (mkdir(iolog_dir, S_IRWXU) != 0)
            log_error(USE_ERRNO, _("unable to mkdir %s"), iolog_dir);            log_fatal(USE_ERRNO, _("unable to mkdir %s"), iolog_dir);
     } else if (!S_ISDIR(sb.st_mode)) {      } else if (!S_ISDIR(sb.st_mode)) {
        log_error(0, _("%s exists but is not a directory (0%o)"),        log_fatal(0, _("%s exists but is not a directory (0%o)"),
             iolog_dir, (unsigned int) sb.st_mode);              iolog_dir, (unsigned int) sb.st_mode);
     }      }
   
Line 162  io_nextid(char *iolog_dir, char sessid[7]) Line 165  io_nextid(char *iolog_dir, char sessid[7])
     len = snprintf(pathbuf, sizeof(pathbuf), "%s/seq", iolog_dir);      len = snprintf(pathbuf, sizeof(pathbuf), "%s/seq", iolog_dir);
     if (len <= 0 || len >= sizeof(pathbuf)) {      if (len <= 0 || len >= sizeof(pathbuf)) {
         errno = ENAMETOOLONG;          errno = ENAMETOOLONG;
        log_error(USE_ERRNO, "%s/seq", pathbuf);        log_fatal(USE_ERRNO, "%s/seq", pathbuf);
     }      }
     fd = open(pathbuf, O_RDWR|O_CREAT, S_IRUSR|S_IWUSR);      fd = open(pathbuf, O_RDWR|O_CREAT, S_IRUSR|S_IWUSR);
     if (fd == -1)      if (fd == -1)
        log_error(USE_ERRNO, _("unable to open %s"), pathbuf);        log_fatal(USE_ERRNO, _("unable to open %s"), pathbuf);
     lock_file(fd, SUDO_LOCK);      lock_file(fd, SUDO_LOCK);
   
     /* Read seq number (base 36). */      /* Read seq number (base 36). */
     nread = read(fd, buf, sizeof(buf));      nread = read(fd, buf, sizeof(buf));
     if (nread != 0) {      if (nread != 0) {
         if (nread == -1)          if (nread == -1)
            log_error(USE_ERRNO, _("unable to read %s"), pathbuf);            log_fatal(USE_ERRNO, _("unable to read %s"), pathbuf);
         id = strtoul(buf, &ep, 36);          id = strtoul(buf, &ep, 36);
         if (buf == ep || id >= SESSID_MAX)          if (buf == ep || id >= SESSID_MAX)
            log_error(0, _("invalid sequence number %s"), pathbuf);            log_fatal(0, _("invalid sequence number %s"), pathbuf);
     }      }
     id++;      id++;
   
Line 190  io_nextid(char *iolog_dir, char sessid[7]) Line 193  io_nextid(char *iolog_dir, char sessid[7])
     }      }
     buf[6] = '\n';      buf[6] = '\n';
   
    /* Stash id logging purposes */    /* Stash id for logging purposes. */
     memcpy(sessid, buf, 6);      memcpy(sessid, buf, 6);
     sessid[6] = '\0';      sessid[6] = '\0';
   
     /* Rewind and overwrite old seq file. */      /* Rewind and overwrite old seq file. */
     if (lseek(fd, 0, SEEK_SET) == (off_t)-1 || write(fd, buf, 7) != 7)      if (lseek(fd, 0, SEEK_SET) == (off_t)-1 || write(fd, buf, 7) != 7)
        log_error(USE_ERRNO, _("unable to write to %s"), pathbuf);        log_fatal(USE_ERRNO, _("unable to write to %s"), pathbuf);
     close(fd);      close(fd);
   
       debug_return;
 }  }
   
 /*  /*
Line 208  static size_t Line 213  static size_t
 mkdir_iopath(const char *iolog_path, char *pathbuf, size_t pathsize)  mkdir_iopath(const char *iolog_path, char *pathbuf, size_t pathsize)
 {  {
     size_t len;      size_t len;
       debug_decl(mkdir_iopath, SUDO_DEBUG_UTIL)
   
     len = strlcpy(pathbuf, iolog_path, pathsize);      len = strlcpy(pathbuf, iolog_path, pathsize);
     if (len >= pathsize) {      if (len >= pathsize) {
         errno = ENAMETOOLONG;          errno = ENAMETOOLONG;
        log_error(USE_ERRNO, "%s", iolog_path);        log_fatal(USE_ERRNO, "%s", iolog_path);
     }      }
   
     /*      /*
Line 222  mkdir_iopath(const char *iolog_path, char *pathbuf, si Line 228  mkdir_iopath(const char *iolog_path, char *pathbuf, si
     mkdir_parents(pathbuf);      mkdir_parents(pathbuf);
     if (len >= 6 && strcmp(&pathbuf[len - 6], "XXXXXX") == 0) {      if (len >= 6 && strcmp(&pathbuf[len - 6], "XXXXXX") == 0) {
         if (mkdtemp(pathbuf) == NULL)          if (mkdtemp(pathbuf) == NULL)
            log_error(USE_ERRNO, _("unable to create %s"), pathbuf);            log_fatal(USE_ERRNO, _("unable to create %s"), pathbuf);
     } else {      } else {
         if (mkdir(pathbuf, S_IRWXU) != 0)          if (mkdir(pathbuf, S_IRWXU) != 0)
            log_error(USE_ERRNO, _("unable to create %s"), pathbuf);            log_fatal(USE_ERRNO, _("unable to create %s"), pathbuf);
     }      }
   
    return len;    debug_return_size_t(len);
 }  }
   
 /*  /*
  * Append suffix to pathbuf after len chars and open the resulting file.   * Append suffix to pathbuf after len chars and open the resulting file.
  * Note that the size of pathbuf is assumed to be PATH_MAX.   * Note that the size of pathbuf is assumed to be PATH_MAX.
 * Uses zlib if docompress is TRUE. * Uses zlib if docompress is true.
  * Returns the open file handle which has the close-on-exec flag set.   * Returns the open file handle which has the close-on-exec flag set.
  */   */
 static void *  static void *
open_io_fd(char *pathbuf, size_t len, const char *suffix, int docompress)open_io_fd(char *pathbuf, size_t len, const char *suffix, bool docompress)
 {  {
     void *vfd = NULL;      void *vfd = NULL;
     int fd;      int fd;
       debug_decl(open_io_fd, SUDO_DEBUG_UTIL)
   
     pathbuf[len] = '\0';      pathbuf[len] = '\0';
     strlcat(pathbuf, suffix, PATH_MAX);      strlcat(pathbuf, suffix, PATH_MAX);
Line 255  open_io_fd(char *pathbuf, size_t len, const char *suff Line 262  open_io_fd(char *pathbuf, size_t len, const char *suff
 #endif  #endif
             vfd = fdopen(fd, "w");              vfd = fdopen(fd, "w");
     }      }
    return vfd;    debug_return_ptr(vfd);
 }  }
   
 /*  /*
Line 272  iolog_deserialize_info(struct iolog_details *details,  Line 279  iolog_deserialize_info(struct iolog_details *details, 
     unsigned long ulval;      unsigned long ulval;
     uid_t runas_uid = 0;      uid_t runas_uid = 0;
     gid_t runas_gid = 0;      gid_t runas_gid = 0;
       debug_decl(iolog_deserialize_info, SUDO_DEBUG_UTIL)
   
     memset(details, 0, sizeof(*details));      memset(details, 0, sizeof(*details));
   
Line 312  iolog_deserialize_info(struct iolog_details *details,  Line 320  iolog_deserialize_info(struct iolog_details *details, 
                 continue;                  continue;
             }              }
             if (strncmp(*cur, "iolog_stdin=", sizeof("iolog_stdin=") - 1) == 0) {              if (strncmp(*cur, "iolog_stdin=", sizeof("iolog_stdin=") - 1) == 0) {
                if (atobool(*cur + sizeof("iolog_stdin=") - 1) == TRUE)                if (atobool(*cur + sizeof("iolog_stdin=") - 1) == true)
                    details->iolog_stdin = TRUE;                    details->iolog_stdin = true;
                 continue;                  continue;
             }              }
             if (strncmp(*cur, "iolog_stdout=", sizeof("iolog_stdout=") - 1) == 0) {              if (strncmp(*cur, "iolog_stdout=", sizeof("iolog_stdout=") - 1) == 0) {
                if (atobool(*cur + sizeof("iolog_stdout=") - 1) == TRUE)                if (atobool(*cur + sizeof("iolog_stdout=") - 1) == true)
                    details->iolog_stdout = TRUE;                    details->iolog_stdout = true;
                 continue;                  continue;
             }              }
             if (strncmp(*cur, "iolog_stderr=", sizeof("iolog_stderr=") - 1) == 0) {              if (strncmp(*cur, "iolog_stderr=", sizeof("iolog_stderr=") - 1) == 0) {
                if (atobool(*cur + sizeof("iolog_stderr=") - 1) == TRUE)                if (atobool(*cur + sizeof("iolog_stderr=") - 1) == true)
                    details->iolog_stderr = TRUE;                    details->iolog_stderr = true;
                 continue;                  continue;
             }              }
             if (strncmp(*cur, "iolog_ttyin=", sizeof("iolog_ttyin=") - 1) == 0) {              if (strncmp(*cur, "iolog_ttyin=", sizeof("iolog_ttyin=") - 1) == 0) {
                if (atobool(*cur + sizeof("iolog_ttyin=") - 1) == TRUE)                if (atobool(*cur + sizeof("iolog_ttyin=") - 1) == true)
                    details->iolog_ttyin = TRUE;                    details->iolog_ttyin = true;
                 continue;                  continue;
             }              }
             if (strncmp(*cur, "iolog_ttyout=", sizeof("iolog_ttyout=") - 1) == 0) {              if (strncmp(*cur, "iolog_ttyout=", sizeof("iolog_ttyout=") - 1) == 0) {
                if (atobool(*cur + sizeof("iolog_ttyout=") - 1) == TRUE)                if (atobool(*cur + sizeof("iolog_ttyout=") - 1) == true)
                    details->iolog_ttyout = TRUE;                    details->iolog_ttyout = true;
                 continue;                  continue;
             }              }
             if (strncmp(*cur, "iolog_compress=", sizeof("iolog_compress=") - 1) == 0) {              if (strncmp(*cur, "iolog_compress=", sizeof("iolog_compress=") - 1) == 0) {
                if (atobool(*cur + sizeof("iolog_compress=") - 1) == TRUE)                if (atobool(*cur + sizeof("iolog_compress=") - 1) == true)
                    iolog_compress = TRUE; /* must be global */                    iolog_compress = true; /* must be global */
                 continue;                  continue;
             }              }
             break;              break;
Line 402  iolog_deserialize_info(struct iolog_details *details,  Line 410  iolog_deserialize_info(struct iolog_details *details, 
             details->runas_gr = sudo_fakegrnam(id);              details->runas_gr = sudo_fakegrnam(id);
         }          }
     }      }
       debug_return;
 }  }
   
 static int  static int
 sudoers_io_open(unsigned int version, sudo_conv_t conversation,  sudoers_io_open(unsigned int version, sudo_conv_t conversation,
     sudo_printf_t plugin_printf, char * const settings[],      sudo_printf_t plugin_printf, char * const settings[],
     char * const user_info[], char * const command_info[],      char * const user_info[], char * const command_info[],
    int argc, char * const argv[], char * const user_env[])    int argc, char * const argv[], char * const user_env[], char * const args[])
 {  {
     struct iolog_details details;      struct iolog_details details;
     char pathbuf[PATH_MAX], sessid[7];      char pathbuf[PATH_MAX], sessid[7];
     char *tofree = NULL;      char *tofree = NULL;
     char * const *cur;      char * const *cur;
       const char *debug_flags = NULL;
     FILE *io_logfile;      FILE *io_logfile;
     size_t len;      size_t len;
     int rval = -1;      int rval = -1;
       debug_decl(sudoers_io_open, SUDO_DEBUG_PLUGIN)
   
     if (!sudo_conv)      if (!sudo_conv)
         sudo_conv = conversation;          sudo_conv = conversation;
Line 425  sudoers_io_open(unsigned int version, sudo_conv_t conv Line 436  sudoers_io_open(unsigned int version, sudo_conv_t conv
   
     /* If we have no command (because -V was specified) just return. */      /* If we have no command (because -V was specified) just return. */
     if (argc == 0)      if (argc == 0)
        return TRUE;        debug_return_bool(true);
   
     if (sigsetjmp(error_jmp, 1)) {      if (sigsetjmp(error_jmp, 1)) {
        /* called via error(), errorx() or log_error() */        /* called via error(), errorx() or log_fatal() */
         rval = -1;          rval = -1;
         goto done;          goto done;
     }      }
Line 439  sudoers_io_open(unsigned int version, sudo_conv_t conv Line 450  sudoers_io_open(unsigned int version, sudo_conv_t conv
     sudo_setgrent();      sudo_setgrent();
   
     /*      /*
        * Check for debug flags in settings list.
        */
       for (cur = settings; *cur != NULL; cur++) {
           if (strncmp(*cur, "debug_flags=", sizeof("debug_flags=") - 1) == 0)
               debug_flags = *cur + sizeof("debug_flags=") - 1;
       }
       if (debug_flags != NULL)
           sudo_debug_init(NULL, debug_flags);
   
       /*
      * Pull iolog settings out of command_info, if any.       * Pull iolog settings out of command_info, if any.
      */       */
     iolog_deserialize_info(&details, user_info, command_info);      iolog_deserialize_info(&details, user_info, command_info);
Line 446  sudoers_io_open(unsigned int version, sudo_conv_t conv Line 467  sudoers_io_open(unsigned int version, sudo_conv_t conv
     if (!details.iolog_stdin && !details.iolog_ttyin &&      if (!details.iolog_stdin && !details.iolog_ttyin &&
         !details.iolog_stdout && !details.iolog_stderr &&          !details.iolog_stdout && !details.iolog_stderr &&
         !details.iolog_ttyout) {          !details.iolog_ttyout) {
        rval = FALSE;        rval = false;
         goto done;          goto done;
     }      }
   
Line 473  sudoers_io_open(unsigned int version, sudo_conv_t conv Line 494  sudoers_io_open(unsigned int version, sudo_conv_t conv
     /*      /*
      * We create 7 files: a log file, a timing file and 5 for input/output.       * We create 7 files: a log file, a timing file and 5 for input/output.
      */       */
    io_logfile = open_io_fd(pathbuf, len, "/log", FALSE);    io_logfile = open_io_fd(pathbuf, len, "/log", false);
     if (io_logfile == NULL)      if (io_logfile == NULL)
        log_error(USE_ERRNO, _("unable to create %s"), pathbuf);        log_fatal(USE_ERRNO, _("unable to create %s"), pathbuf);
   
     io_fds[IOFD_TIMING].v = open_io_fd(pathbuf, len, "/timing",      io_fds[IOFD_TIMING].v = open_io_fd(pathbuf, len, "/timing",
         iolog_compress);          iolog_compress);
     if (io_fds[IOFD_TIMING].v == NULL)      if (io_fds[IOFD_TIMING].v == NULL)
        log_error(USE_ERRNO, _("unable to create %s"), pathbuf);        log_fatal(USE_ERRNO, _("unable to create %s"), pathbuf);
   
     if (details.iolog_ttyin) {      if (details.iolog_ttyin) {
         io_fds[IOFD_TTYIN].v = open_io_fd(pathbuf, len, "/ttyin",          io_fds[IOFD_TTYIN].v = open_io_fd(pathbuf, len, "/ttyin",
             iolog_compress);              iolog_compress);
         if (io_fds[IOFD_TTYIN].v == NULL)          if (io_fds[IOFD_TTYIN].v == NULL)
            log_error(USE_ERRNO, _("unable to create %s"), pathbuf);            log_fatal(USE_ERRNO, _("unable to create %s"), pathbuf);
     } else {      } else {
         sudoers_io.log_ttyin = NULL;          sudoers_io.log_ttyin = NULL;
     }      }
Line 494  sudoers_io_open(unsigned int version, sudo_conv_t conv Line 515  sudoers_io_open(unsigned int version, sudo_conv_t conv
         io_fds[IOFD_STDIN].v = open_io_fd(pathbuf, len, "/stdin",          io_fds[IOFD_STDIN].v = open_io_fd(pathbuf, len, "/stdin",
             iolog_compress);              iolog_compress);
         if (io_fds[IOFD_STDIN].v == NULL)          if (io_fds[IOFD_STDIN].v == NULL)
            log_error(USE_ERRNO, _("unable to create %s"), pathbuf);            log_fatal(USE_ERRNO, _("unable to create %s"), pathbuf);
     } else {      } else {
         sudoers_io.log_stdin = NULL;          sudoers_io.log_stdin = NULL;
     }      }
Line 502  sudoers_io_open(unsigned int version, sudo_conv_t conv Line 523  sudoers_io_open(unsigned int version, sudo_conv_t conv
         io_fds[IOFD_TTYOUT].v = open_io_fd(pathbuf, len, "/ttyout",          io_fds[IOFD_TTYOUT].v = open_io_fd(pathbuf, len, "/ttyout",
             iolog_compress);              iolog_compress);
         if (io_fds[IOFD_TTYOUT].v == NULL)          if (io_fds[IOFD_TTYOUT].v == NULL)
            log_error(USE_ERRNO, _("unable to create %s"), pathbuf);            log_fatal(USE_ERRNO, _("unable to create %s"), pathbuf);
     } else {      } else {
         sudoers_io.log_ttyout = NULL;          sudoers_io.log_ttyout = NULL;
     }      }
Line 510  sudoers_io_open(unsigned int version, sudo_conv_t conv Line 531  sudoers_io_open(unsigned int version, sudo_conv_t conv
         io_fds[IOFD_STDOUT].v = open_io_fd(pathbuf, len, "/stdout",          io_fds[IOFD_STDOUT].v = open_io_fd(pathbuf, len, "/stdout",
             iolog_compress);              iolog_compress);
         if (io_fds[IOFD_STDOUT].v == NULL)          if (io_fds[IOFD_STDOUT].v == NULL)
            log_error(USE_ERRNO, _("unable to create %s"), pathbuf);            log_fatal(USE_ERRNO, _("unable to create %s"), pathbuf);
     } else {      } else {
         sudoers_io.log_stdout = NULL;          sudoers_io.log_stdout = NULL;
     }      }
Line 518  sudoers_io_open(unsigned int version, sudo_conv_t conv Line 539  sudoers_io_open(unsigned int version, sudo_conv_t conv
         io_fds[IOFD_STDERR].v = open_io_fd(pathbuf, len, "/stderr",          io_fds[IOFD_STDERR].v = open_io_fd(pathbuf, len, "/stderr",
             iolog_compress);              iolog_compress);
         if (io_fds[IOFD_STDERR].v == NULL)          if (io_fds[IOFD_STDERR].v == NULL)
            log_error(USE_ERRNO, _("unable to create %s"), pathbuf);            log_fatal(USE_ERRNO, _("unable to create %s"), pathbuf);
     } else {      } else {
         sudoers_io.log_stderr = NULL;          sudoers_io.log_stderr = NULL;
     }      }
Line 539  sudoers_io_open(unsigned int version, sudo_conv_t conv Line 560  sudoers_io_open(unsigned int version, sudo_conv_t conv
     fputc('\n', io_logfile);      fputc('\n', io_logfile);
     fclose(io_logfile);      fclose(io_logfile);
   
    rval = TRUE;    rval = true;
   
 done:  done:
     efree(tofree);      efree(tofree);
Line 550  done: Line 571  done:
         gr_delref(details.runas_gr);          gr_delref(details.runas_gr);
     sudo_endgrent();      sudo_endgrent();
   
    return rval;    debug_return_bool(rval);
 }  }
   
 static void  static void
 sudoers_io_close(int exit_status, int error)  sudoers_io_close(int exit_status, int error)
 {  {
     int i;      int i;
       debug_decl(sudoers_io_close, SUDO_DEBUG_PLUGIN)
   
     if (sigsetjmp(error_jmp, 1)) {      if (sigsetjmp(error_jmp, 1)) {
        /* called via error(), errorx() or log_error() */        /* called via error(), errorx() or log_fatal() */
        return;        debug_return;
     }      }
   
     for (i = 0; i < IOFD_MAX; i++) {      for (i = 0; i < IOFD_MAX; i++) {
Line 573  sudoers_io_close(int exit_status, int error) Line 595  sudoers_io_close(int exit_status, int error)
 #endif  #endif
             fclose(io_fds[i].f);              fclose(io_fds[i].f);
     }      }
       debug_return;
 }  }
   
 static int  static int
 sudoers_io_version(int verbose)  sudoers_io_version(int verbose)
 {  {
       debug_decl(sudoers_io_version, SUDO_DEBUG_PLUGIN)
   
     if (sigsetjmp(error_jmp, 1)) {      if (sigsetjmp(error_jmp, 1)) {
        /* called via error(), errorx() or log_error() */        /* called via error(), errorx() or log_fatal() */
        return -1;        debug_return_bool(-1);
     }      }
   
     sudo_printf(SUDO_CONV_INFO_MSG, "Sudoers I/O plugin version %s\n",      sudo_printf(SUDO_CONV_INFO_MSG, "Sudoers I/O plugin version %s\n",
         PACKAGE_VERSION);          PACKAGE_VERSION);
   
    return TRUE;    debug_return_bool(true);
 }  }
   
 /*  /*
Line 596  static int Line 621  static int
 sudoers_io_log(const char *buf, unsigned int len, int idx)  sudoers_io_log(const char *buf, unsigned int len, int idx)
 {  {
     struct timeval now, delay;      struct timeval now, delay;
       debug_decl(sudoers_io_version, SUDO_DEBUG_PLUGIN)
   
     gettimeofday(&now, NULL);      gettimeofday(&now, NULL);
   
     if (sigsetjmp(error_jmp, 1)) {      if (sigsetjmp(error_jmp, 1)) {
        /* called via error(), errorx() or log_error() */        /* called via error(), errorx() or log_fatal() */
        return -1;        debug_return_bool(-1);
     }      }
   
 #ifdef HAVE_ZLIB_H  #ifdef HAVE_ZLIB_H
     if (iolog_compress)      if (iolog_compress)
        gzwrite(io_fds[idx].g, buf, len);        ignore_result(gzwrite(io_fds[idx].g, (const voidp)buf, len));
     else      else
 #endif  #endif
        fwrite(buf, 1, len, io_fds[idx].f);        ignore_result(fwrite(buf, 1, len, io_fds[idx].f));
     delay.tv_sec = now.tv_sec;      delay.tv_sec = now.tv_sec;
     delay.tv_usec = now.tv_usec;      delay.tv_usec = now.tv_usec;
     timevalsub(&delay, &last_time);      timevalsub(&delay, &last_time);
Line 624  sudoers_io_log(const char *buf, unsigned int len, int  Line 650  sudoers_io_log(const char *buf, unsigned int len, int 
     last_time.tv_sec = now.tv_sec;      last_time.tv_sec = now.tv_sec;
     last_time.tv_usec = now.tv_usec;      last_time.tv_usec = now.tv_usec;
   
    return TRUE;    debug_return_bool(true);
 }  }
   
 static int  static int
Removed from v.1.1.1.1  
changed lines
  Added in v.1.1.1.2

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>