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

Diff for /embedaddon/sudo/plugins/sudoers/check.c between versions 1.1 and 1.1.1.2

version 1.1, 2012/02/21 16:23:02 version 1.1.1.2, 2012/05/29 12:26:49
Line 89  static int   timestamp_status(char *, char *, char *,  Line 89  static int   timestamp_status(char *, char *, char *, 
 static char *expand_prompt(char *, char *, char *);  static char *expand_prompt(char *, char *, char *);
 static void  lecture(int);  static void  lecture(int);
 static void  update_timestamp(char *, char *);  static void  update_timestamp(char *, char *);
static int   tty_is_devpts(const char *);static bool  tty_is_devpts(const char *);
 static struct passwd *get_authpw(void);  static struct passwd *get_authpw(void);
   
 /*  /*
 * Returns TRUE if the user successfully authenticates, else FALSE. * Returns true if the user successfully authenticates, else false.
  */   */
 int  int
 check_user(int validated, int mode)  check_user(int validated, int mode)
Line 103  check_user(int validated, int mode) Line 103  check_user(int validated, int mode)
     char *timestampfile = NULL;      char *timestampfile = NULL;
     char *prompt;      char *prompt;
     struct stat sb;      struct stat sb;
    int status, rval = TRUE;    int status, rval = true;
    int need_pass = def_authenticate;    bool need_pass = def_authenticate;
     debug_decl(check_user, SUDO_DEBUG_AUTH)
   
     /*      /*
      * Init authentication system regardless of whether we need a password.       * Init authentication system regardless of whether we need a password.
Line 128  check_user(int validated, int mode) Line 129  check_user(int validated, int mode)
             if (user_uid == 0 || (user_uid == runas_pw->pw_uid &&              if (user_uid == 0 || (user_uid == runas_pw->pw_uid &&
                 (!runas_gr || user_in_group(sudo_user.pw, runas_gr->gr_name)))                  (!runas_gr || user_in_group(sudo_user.pw, runas_gr->gr_name)))
                 || user_is_exempt())                  || user_is_exempt())
                need_pass = FALSE;                need_pass = false;
         }          }
     }      }
     if (!need_pass)      if (!need_pass)
Line 169  check_user(int validated, int mode) Line 170  check_user(int validated, int mode)
         rval = verify_user(auth_pw, prompt);          rval = verify_user(auth_pw, prompt);
     }      }
     /* Only update timestamp if user was validated. */      /* Only update timestamp if user was validated. */
    if (rval == TRUE && ISSET(validated, VALIDATE_OK) &&    if (rval == true && ISSET(validated, VALIDATE_OK) &&
         !ISSET(mode, MODE_IGNORE_TICKET) && status != TS_ERROR)          !ISSET(mode, MODE_IGNORE_TICKET) && status != TS_ERROR)
         update_timestamp(timestampdir, timestampfile);          update_timestamp(timestampdir, timestampfile);
     efree(timestampdir);      efree(timestampdir);
Line 179  done: Line 180  done:
     sudo_auth_cleanup(auth_pw);      sudo_auth_cleanup(auth_pw);
     pw_delref(auth_pw);      pw_delref(auth_pw);
   
    return rval;    debug_return_bool(rval);
 }  }
   
 #define DEFAULT_LECTURE "\n" \  #define DEFAULT_LECTURE "\n" \
Line 200  lecture(int status) Line 201  lecture(int status)
     ssize_t nread;      ssize_t nread;
     struct sudo_conv_message msg;      struct sudo_conv_message msg;
     struct sudo_conv_reply repl;      struct sudo_conv_reply repl;
       debug_decl(lecture, SUDO_DEBUG_AUTH)
   
     if (def_lecture == never ||      if (def_lecture == never ||
         (def_lecture == once && status != TS_MISSING && status != TS_ERROR))          (def_lecture == once && status != TS_MISSING && status != TS_ERROR))
        return;        debug_return;
   
     memset(&msg, 0, sizeof(msg));      memset(&msg, 0, sizeof(msg));
     memset(&repl, 0, sizeof(repl));      memset(&repl, 0, sizeof(repl));
   
     if (def_lecture_file && (fp = fopen(def_lecture_file, "r")) != NULL) {      if (def_lecture_file && (fp = fopen(def_lecture_file, "r")) != NULL) {
         while ((nread = fread(buf, sizeof(char), sizeof(buf) - 1, fp)) != 0) {          while ((nread = fread(buf, sizeof(char), sizeof(buf) - 1, fp)) != 0) {
            buf[sizeof(buf) - 1] = '\0';            buf[nread] = '\0';
             msg.msg_type = SUDO_CONV_ERROR_MSG;              msg.msg_type = SUDO_CONV_ERROR_MSG;
             msg.msg = buf;              msg.msg = buf;
             sudo_conv(1, &msg, &repl);              sudo_conv(1, &msg, &repl);
Line 221  lecture(int status) Line 223  lecture(int status)
         msg.msg = _(DEFAULT_LECTURE);          msg.msg = _(DEFAULT_LECTURE);
         sudo_conv(1, &msg, &repl);          sudo_conv(1, &msg, &repl);
     }      }
       debug_return;
 }  }
   
 /*  /*
Line 229  lecture(int status) Line 232  lecture(int status)
 static void  static void
 update_timestamp(char *timestampdir, char *timestampfile)  update_timestamp(char *timestampdir, char *timestampfile)
 {  {
       debug_decl(update_timestamp, SUDO_DEBUG_AUTH)
   
     /* If using tty timestamps but we have no tty there is nothing to do. */      /* If using tty timestamps but we have no tty there is nothing to do. */
     if (def_tty_tickets && !user_ttypath)      if (def_tty_tickets && !user_ttypath)
        return;        debug_return;
   
     if (timestamp_uid != 0)      if (timestamp_uid != 0)
         set_perms(PERM_TIMESTAMP);          set_perms(PERM_TIMESTAMP);
Line 241  update_timestamp(char *timestampdir, char *timestampfi Line 246  update_timestamp(char *timestampdir, char *timestampfi
          */           */
         int fd = open(timestampfile, O_WRONLY|O_CREAT, 0600);          int fd = open(timestampfile, O_WRONLY|O_CREAT, 0600);
         if (fd == -1)          if (fd == -1)
            log_error(NO_EXIT|USE_ERRNO, _("unable to open %s"), timestampfile);            log_error(USE_ERRNO, _("unable to open %s"), timestampfile);
         else {          else {
             lock_file(fd, SUDO_LOCK);              lock_file(fd, SUDO_LOCK);
             if (write(fd, &tty_info, sizeof(tty_info)) != sizeof(tty_info)) {              if (write(fd, &tty_info, sizeof(tty_info)) != sizeof(tty_info)) {
                log_error(NO_EXIT|USE_ERRNO, _("unable to write to %s"),                log_error(USE_ERRNO, _("unable to write to %s"),
                     timestampfile);                      timestampfile);
             }              }
             close(fd);              close(fd);
Line 253  update_timestamp(char *timestampdir, char *timestampfi Line 258  update_timestamp(char *timestampdir, char *timestampfi
     } else {      } else {
         if (touch(-1, timestampdir, NULL) == -1) {          if (touch(-1, timestampdir, NULL) == -1) {
             if (mkdir(timestampdir, 0700) == -1) {              if (mkdir(timestampdir, 0700) == -1) {
                log_error(NO_EXIT|USE_ERRNO, _("unable to mkdir %s"),                log_error(USE_ERRNO, _("unable to mkdir %s"),
                     timestampdir);                      timestampdir);
             }              }
         }          }
     }      }
     if (timestamp_uid != 0)      if (timestamp_uid != 0)
         restore_perms();          restore_perms();
       debug_return;
 }  }
   
 /*  /*
Line 272  expand_prompt(char *old_prompt, char *user, char *host Line 278  expand_prompt(char *old_prompt, char *user, char *host
     size_t len, n;      size_t len, n;
     int subst;      int subst;
     char *p, *np, *new_prompt, *endp;      char *p, *np, *new_prompt, *endp;
       debug_decl(expand_prompt, SUDO_DEBUG_AUTH)
   
     /* How much space do we need to malloc for the prompt? */      /* How much space do we need to malloc for the prompt? */
     subst = 0;      subst = 0;
Line 382  expand_prompt(char *old_prompt, char *user, char *host Line 389  expand_prompt(char *old_prompt, char *user, char *host
     } else      } else
         new_prompt = old_prompt;          new_prompt = old_prompt;
   
    return new_prompt;    debug_return_str(new_prompt);
   
 oflow:  oflow:
     /* We pre-allocate enough space, so this should never happen. */      /* We pre-allocate enough space, so this should never happen. */
Line 392  oflow: Line 399  oflow:
 /*  /*
  * Checks if the user is exempt from supplying a password.   * Checks if the user is exempt from supplying a password.
  */   */
intbool
 user_is_exempt(void)  user_is_exempt(void)
 {  {
    if (!def_exempt_group)    bool rval = false;
        return FALSE;    debug_decl(user_is_exempt, SUDO_DEBUG_AUTH)
    return user_in_group(sudo_user.pw, def_exempt_group);
     if (def_exempt_group)
         rval = user_in_group(sudo_user.pw, def_exempt_group);
     debug_return_bool(rval);
 }  }
   
 /*  /*
Line 408  build_timestamp(char **timestampdir, char **timestampf Line 418  build_timestamp(char **timestampdir, char **timestampf
 {  {
     char *dirparent;      char *dirparent;
     int len;      int len;
       debug_decl(build_timestamp, SUDO_DEBUG_AUTH)
   
     dirparent = def_timestampdir;      dirparent = def_timestampdir;
     len = easprintf(timestampdir, "%s/%s", dirparent, user_name);      len = easprintf(timestampdir, "%s/%s", dirparent, user_name);
Line 440  build_timestamp(char **timestampdir, char **timestampf Line 451  build_timestamp(char **timestampdir, char **timestampf
     } else      } else
         *timestampfile = NULL;          *timestampfile = NULL;
   
    return len;    debug_return_int(len);
 bad:  bad:
    log_error(0, _("timestamp path too long: %s"), *timestampfile);    log_fatal(0, _("timestamp path too long: %s"), *timestampfile);
    return -1;    debug_return_int(-1);
 }  }
   
 /*  /*
Line 457  timestamp_status(char *timestampdir, char *timestampfi Line 468  timestamp_status(char *timestampdir, char *timestampfi
     time_t now;      time_t now;
     char *dirparent = def_timestampdir;      char *dirparent = def_timestampdir;
     int status = TS_ERROR;              /* assume the worst */      int status = TS_ERROR;              /* assume the worst */
       debug_decl(timestamp_status, SUDO_DEBUG_AUTH)
   
     if (timestamp_uid != 0)      if (timestamp_uid != 0)
         set_perms(PERM_TIMESTAMP);          set_perms(PERM_TIMESTAMP);
Line 470  timestamp_status(char *timestampdir, char *timestampfi Line 482  timestamp_status(char *timestampdir, char *timestampfi
      */       */
     if (lstat(dirparent, &sb) == 0) {      if (lstat(dirparent, &sb) == 0) {
         if (!S_ISDIR(sb.st_mode))          if (!S_ISDIR(sb.st_mode))
            log_error(NO_EXIT, _("%s exists but is not a directory (0%o)"),            log_error(0, _("%s exists but is not a directory (0%o)"),
                 dirparent, (unsigned int) sb.st_mode);                  dirparent, (unsigned int) sb.st_mode);
         else if (sb.st_uid != timestamp_uid)          else if (sb.st_uid != timestamp_uid)
            log_error(NO_EXIT, _("%s owned by uid %u, should be uid %u"),            log_error(0, _("%s owned by uid %u, should be uid %u"),
                 dirparent, (unsigned int) sb.st_uid,                  dirparent, (unsigned int) sb.st_uid,
                 (unsigned int) timestamp_uid);                  (unsigned int) timestamp_uid);
         else if ((sb.st_mode & 0000022))          else if ((sb.st_mode & 0000022))
            log_error(NO_EXIT,            log_error(0,
                 _("%s writable by non-owner (0%o), should be mode 0700"),                  _("%s writable by non-owner (0%o), should be mode 0700"),
                 dirparent, (unsigned int) sb.st_mode);                  dirparent, (unsigned int) sb.st_mode);
         else {          else {
Line 486  timestamp_status(char *timestampdir, char *timestampfi Line 498  timestamp_status(char *timestampdir, char *timestampfi
             status = TS_MISSING;              status = TS_MISSING;
         }          }
     } else if (errno != ENOENT) {      } else if (errno != ENOENT) {
        log_error(NO_EXIT|USE_ERRNO, _("unable to stat %s"), dirparent);        log_error(USE_ERRNO, _("unable to stat %s"), dirparent);
     } else {      } else {
         /* No dirparent, try to make one. */          /* No dirparent, try to make one. */
         if (ISSET(flags, TS_MAKE_DIRS)) {          if (ISSET(flags, TS_MAKE_DIRS)) {
             if (mkdir(dirparent, S_IRWXU))              if (mkdir(dirparent, S_IRWXU))
                log_error(NO_EXIT|USE_ERRNO, _("unable to mkdir %s"),                log_error(USE_ERRNO, _("unable to mkdir %s"),
                     dirparent);                      dirparent);
             else              else
                 status = TS_MISSING;                  status = TS_MISSING;
Line 514  timestamp_status(char *timestampdir, char *timestampfi Line 526  timestamp_status(char *timestampdir, char *timestampfi
                 if (unlink(timestampdir) == 0)                  if (unlink(timestampdir) == 0)
                     status = TS_MISSING;                      status = TS_MISSING;
             } else              } else
                log_error(NO_EXIT, _("%s exists but is not a directory (0%o)"),                log_error(0, _("%s exists but is not a directory (0%o)"),
                     timestampdir, (unsigned int) sb.st_mode);                      timestampdir, (unsigned int) sb.st_mode);
         } else if (sb.st_uid != timestamp_uid)          } else if (sb.st_uid != timestamp_uid)
            log_error(NO_EXIT, _("%s owned by uid %u, should be uid %u"),            log_error(0, _("%s owned by uid %u, should be uid %u"),
                 timestampdir, (unsigned int) sb.st_uid,                  timestampdir, (unsigned int) sb.st_uid,
                 (unsigned int) timestamp_uid);                  (unsigned int) timestamp_uid);
         else if ((sb.st_mode & 0000022))          else if ((sb.st_mode & 0000022))
            log_error(NO_EXIT,            log_error(0,
                 _("%s writable by non-owner (0%o), should be mode 0700"),                  _("%s writable by non-owner (0%o), should be mode 0700"),
                 timestampdir, (unsigned int) sb.st_mode);                  timestampdir, (unsigned int) sb.st_mode);
         else {          else {
Line 530  timestamp_status(char *timestampdir, char *timestampfi Line 542  timestamp_status(char *timestampdir, char *timestampfi
             status = TS_OLD;            /* do date check later */              status = TS_OLD;            /* do date check later */
         }          }
     } else if (errno != ENOENT) {      } else if (errno != ENOENT) {
        log_error(NO_EXIT|USE_ERRNO, _("unable to stat %s"), timestampdir);        log_error(USE_ERRNO, _("unable to stat %s"), timestampdir);
     } else      } else
         status = TS_MISSING;          status = TS_MISSING;
   
Line 541  timestamp_status(char *timestampdir, char *timestampfi Line 553  timestamp_status(char *timestampdir, char *timestampfi
     if (status == TS_MISSING && timestampfile && ISSET(flags, TS_MAKE_DIRS)) {      if (status == TS_MISSING && timestampfile && ISSET(flags, TS_MAKE_DIRS)) {
         if (mkdir(timestampdir, S_IRWXU) == -1) {          if (mkdir(timestampdir, S_IRWXU) == -1) {
             status = TS_ERROR;              status = TS_ERROR;
            log_error(NO_EXIT|USE_ERRNO, _("unable to mkdir %s"), timestampdir);            log_error(USE_ERRNO, _("unable to mkdir %s"), timestampdir);
         }          }
     }      }
   
Line 556  timestamp_status(char *timestampdir, char *timestampfi Line 568  timestamp_status(char *timestampdir, char *timestampfi
         if (lstat(timestampfile, &sb) == 0) {          if (lstat(timestampfile, &sb) == 0) {
             if (!S_ISREG(sb.st_mode)) {              if (!S_ISREG(sb.st_mode)) {
                 status = TS_ERROR;                  status = TS_ERROR;
                log_error(NO_EXIT, _("%s exists but is not a regular file (0%o)"),                log_error(0, _("%s exists but is not a regular file (0%o)"),
                     timestampfile, (unsigned int) sb.st_mode);                      timestampfile, (unsigned int) sb.st_mode);
             } else {              } else {
                 /* If bad uid or file mode, complain and kill the bogus file. */                  /* If bad uid or file mode, complain and kill the bogus file. */
                 if (sb.st_uid != timestamp_uid) {                  if (sb.st_uid != timestamp_uid) {
                    log_error(NO_EXIT,                    log_error(0,
                         _("%s owned by uid %u, should be uid %u"),                          _("%s owned by uid %u, should be uid %u"),
                         timestampfile, (unsigned int) sb.st_uid,                          timestampfile, (unsigned int) sb.st_uid,
                         (unsigned int) timestamp_uid);                          (unsigned int) timestamp_uid);
                     (void) unlink(timestampfile);                      (void) unlink(timestampfile);
                 } else if ((sb.st_mode & 0000022)) {                  } else if ((sb.st_mode & 0000022)) {
                    log_error(NO_EXIT,                    log_error(0,
                         _("%s writable by non-owner (0%o), should be mode 0600"),                          _("%s writable by non-owner (0%o), should be mode 0600"),
                         timestampfile, (unsigned int) sb.st_mode);                          timestampfile, (unsigned int) sb.st_mode);
                     (void) unlink(timestampfile);                      (void) unlink(timestampfile);
Line 598  timestamp_status(char *timestampdir, char *timestampfi Line 610  timestamp_status(char *timestampdir, char *timestampfi
                 }                  }
             }              }
         } else if (errno != ENOENT) {          } else if (errno != ENOENT) {
            log_error(NO_EXIT|USE_ERRNO, _("unable to stat %s"), timestampfile);            log_error(USE_ERRNO, _("unable to stat %s"), timestampfile);
             status = TS_ERROR;              status = TS_ERROR;
         }          }
     }      }
Line 621  timestamp_status(char *timestampdir, char *timestampfi Line 633  timestamp_status(char *timestampdir, char *timestampfi
                  */                   */
                 if (mtime.tv_sec > now + 60 * def_timestamp_timeout * 2) {                  if (mtime.tv_sec > now + 60 * def_timestamp_timeout * 2) {
                     time_t tv_sec = (time_t)mtime.tv_sec;                      time_t tv_sec = (time_t)mtime.tv_sec;
                    log_error(NO_EXIT,                    log_error(0,
                         _("timestamp too far in the future: %20.20s"),                          _("timestamp too far in the future: %20.20s"),
                         4 + ctime(&tv_sec));                          4 + ctime(&tv_sec));
                     if (timestampfile)                      if (timestampfile)
Line 641  timestamp_status(char *timestampdir, char *timestampfi Line 653  timestamp_status(char *timestampdir, char *timestampfi
 done:  done:
     if (timestamp_uid != 0)      if (timestamp_uid != 0)
         restore_perms();          restore_perms();
    return status;    debug_return_int(status);
 }  }
   
 /*  /*
  * Remove the timestamp ticket file/dir.   * Remove the timestamp ticket file/dir.
  */   */
 void  void
remove_timestamp(int remove)remove_timestamp(bool remove)
 {  {
     struct timeval tv;      struct timeval tv;
     char *timestampdir, *timestampfile, *path;      char *timestampdir, *timestampfile, *path;
     int status;      int status;
       debug_decl(remove_timestamp, SUDO_DEBUG_AUTH)
   
     if (build_timestamp(&timestampdir, &timestampfile) == -1)      if (build_timestamp(&timestampdir, &timestampfile) == -1)
        return;        debug_return;
   
     status = timestamp_status(timestampdir, timestampfile, user_name,      status = timestamp_status(timestampdir, timestampfile, user_name,
         TS_REMOVE);          TS_REMOVE);
Line 667  remove_timestamp(int remove) Line 680  remove_timestamp(int remove)
             else              else
                 status = rmdir(timestampdir);                  status = rmdir(timestampdir);
             if (status == -1 && errno != ENOENT) {              if (status == -1 && errno != ENOENT) {
                log_error(NO_EXIT,                log_error(0,
                     _("unable to remove %s (%s), will reset to the epoch"),                      _("unable to remove %s (%s), will reset to the epoch"),
                     path, strerror(errno));                      path, strerror(errno));
                remove = FALSE;                remove = false;
             }              }
         }          }
         if (!remove) {          if (!remove) {
Line 679  remove_timestamp(int remove) Line 692  remove_timestamp(int remove)
                 error(1, _("unable to reset %s to the epoch"), path);                  error(1, _("unable to reset %s to the epoch"), path);
         }          }
     }      }
   
     efree(timestampdir);      efree(timestampdir);
     efree(timestampfile);      efree(timestampfile);
   
       debug_return;
 }  }
   
 /*  /*
 * Returns TRUE if tty lives on a devpts or /devices filesystem, else FALSE. * Returns true if tty lives on a devpts, /dev or /devices filesystem, else
 * Unlike most filesystems, the ctime of devpts nodes is not updated when * false.  Unlike most filesystems, the ctime of devpts nodes is not updated
 * the device node is written to, only when the inode's status changes, * when the device node is written to, only when the inode's status changes,
  * typically via the chmod, chown, link, rename, or utimes system calls.   * typically via the chmod, chown, link, rename, or utimes system calls.
  * Since the ctime is "stable" in this case, we can stash it the tty ticket   * Since the ctime is "stable" in this case, we can stash it the tty ticket
  * file and use it to determine whether the tty ticket file is stale.   * file and use it to determine whether the tty ticket file is stale.
  */   */
static intstatic bool
 tty_is_devpts(const char *tty)  tty_is_devpts(const char *tty)
 {  {
    int retval = FALSE;    bool retval = false;
 #ifdef __linux__  #ifdef __linux__
     struct statfs sfs;      struct statfs sfs;
       debug_decl(tty_is_devpts, SUDO_DEBUG_PTY)
   
 #ifndef DEVPTS_SUPER_MAGIC  #ifndef DEVPTS_SUPER_MAGIC
 # define DEVPTS_SUPER_MAGIC 0x1cd1  # define DEVPTS_SUPER_MAGIC 0x1cd1
Line 705  tty_is_devpts(const char *tty) Line 720  tty_is_devpts(const char *tty)
   
     if (statfs(tty, &sfs) == 0) {      if (statfs(tty, &sfs) == 0) {
         if (sfs.f_type == DEVPTS_SUPER_MAGIC)          if (sfs.f_type == DEVPTS_SUPER_MAGIC)
            retval = TRUE;            retval = true;
     }      }
 #elif defined(__sun) && defined(__SVR4)  #elif defined(__sun) && defined(__SVR4)
     struct statvfs sfs;      struct statvfs sfs;
       debug_decl(tty_is_devpts, SUDO_DEBUG_PTY)
   
     if (statvfs(tty, &sfs) == 0) {      if (statvfs(tty, &sfs) == 0) {
        if (strcmp(sfs.f_fstr, "devices") == 0)        if (strcmp(sfs.f_fstr, "dev") == 0 || strcmp(sfs.f_fstr, "devices") == 0)
            retval = TRUE;            retval = true;
     }      }
   #else
       debug_decl(tty_is_devpts, SUDO_DEBUG_PTY)
 #endif /* __linux__ */  #endif /* __linux__ */
    return retval;    debug_return_bool(retval);
 }  }
   
 /*  /*
Line 727  static struct passwd * Line 745  static struct passwd *
 get_authpw(void)  get_authpw(void)
 {  {
     struct passwd *pw;      struct passwd *pw;
       debug_decl(get_authpw, SUDO_DEBUG_AUTH)
   
     if (def_rootpw) {      if (def_rootpw) {
         if ((pw = sudo_getpwuid(ROOT_UID)) == NULL)          if ((pw = sudo_getpwuid(ROOT_UID)) == NULL)
            log_error(0, _("unknown uid: %u"), ROOT_UID);            log_fatal(0, _("unknown uid: %u"), ROOT_UID);
     } else if (def_runaspw) {      } else if (def_runaspw) {
         if ((pw = sudo_getpwnam(def_runas_default)) == NULL)          if ((pw = sudo_getpwnam(def_runas_default)) == NULL)
            log_error(0, _("unknown user: %s"), def_runas_default);            log_fatal(0, _("unknown user: %s"), def_runas_default);
     } else if (def_targetpw) {      } else if (def_targetpw) {
         if (runas_pw->pw_name == NULL)          if (runas_pw->pw_name == NULL)
            log_error(NO_MAIL|MSG_ONLY, _("unknown uid: %u"),            log_fatal(NO_MAIL|MSG_ONLY, _("unknown uid: %u"),
                 (unsigned int) runas_pw->pw_uid);                  (unsigned int) runas_pw->pw_uid);
         pw_addref(runas_pw);          pw_addref(runas_pw);
         pw = runas_pw;          pw = runas_pw;
Line 745  get_authpw(void) Line 764  get_authpw(void)
         pw = sudo_user.pw;          pw = sudo_user.pw;
     }      }
   
    return pw;    debug_return_ptr(pw);
 }  }
Removed from v.1.1  
changed lines
  Added in v.1.1.1.2

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