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

Diff for /embedaddon/sudo/plugins/sudoers/defaults.c between versions 1.1.1.1 and 1.1.1.5

version 1.1.1.1, 2012/02/21 16:23:02 version 1.1.1.5, 2013/10/14 07:56:34
Line 1 Line 1
 /*  /*
 * Copyright (c) 1999-2005, 2007-2011 * Copyright (c) 1999-2005, 2007-2013
  *      Todd C. Miller <Todd.Miller@courtesan.com>   *      Todd C. Miller <Todd.Miller@courtesan.com>
  *   *
  * Permission to use, copy, modify, and distribute this software for any   * Permission to use, copy, modify, and distribute this software for any
Line 22 Line 22
 #include <config.h>  #include <config.h>
   
 #include <sys/types.h>  #include <sys/types.h>
 #include <sys/param.h>  
 #include <stdio.h>  #include <stdio.h>
 #ifdef STDC_HEADERS  #ifdef STDC_HEADERS
 # include <stdlib.h>  # include <stdlib.h>
Line 91  static struct strmap priorities[] = { Line 90  static struct strmap priorities[] = {
 /*  /*
  * Local prototypes.   * Local prototypes.
  */   */
static int store_int(char *, struct sudo_defs_types *, int);static bool store_int(char *, struct sudo_defs_types *, int);
static int store_list(char *, struct sudo_defs_types *, int);static bool store_list(char *, struct sudo_defs_types *, int);
static int store_mode(char *, struct sudo_defs_types *, int);static bool store_mode(char *, struct sudo_defs_types *, int);
static int store_str(char *, struct sudo_defs_types *, int);static bool store_str(char *, struct sudo_defs_types *, int);
static int store_syslogfac(char *, struct sudo_defs_types *, int);static bool store_syslogfac(char *, struct sudo_defs_types *, int);
static int store_syslogpri(char *, struct sudo_defs_types *, int);static bool store_syslogpri(char *, struct sudo_defs_types *, int);
static int store_tuple(char *, struct sudo_defs_types *, int);static bool store_tuple(char *, struct sudo_defs_types *, int);
static int store_uint(char *, struct sudo_defs_types *, int);static bool store_uint(char *, struct sudo_defs_types *, int);
static int store_float(char *, struct sudo_defs_types *, int);static bool store_float(char *, struct sudo_defs_types *, int);
 static void list_op(char *, size_t, struct sudo_defs_types *, enum list_ops);  static void list_op(char *, size_t, struct sudo_defs_types *, enum list_ops);
 static const char *logfac2str(int);  static const char *logfac2str(int);
 static const char *logpri2str(int);  static const char *logpri2str(int);
Line 119  dump_defaults(void) Line 118  dump_defaults(void)
     struct list_member *item;      struct list_member *item;
     struct def_values *def;      struct def_values *def;
     char *desc;      char *desc;
       debug_decl(dump_defaults, SUDO_DEBUG_DEFAULTS)
   
     for (cur = sudo_defs_table; cur->name; cur++) {      for (cur = sudo_defs_table; cur->name; cur++) {
         if (cur->desc) {          if (cur->desc) {
Line 182  dump_defaults(void) Line 182  dump_defaults(void)
             }              }
         }          }
     }      }
       debug_return;
 }  }
   
 /*  /*
Line 191  dump_defaults(void) Line 192  dump_defaults(void)
  * Eg. you may want to turn off logging to a file for some hosts.   * Eg. you may want to turn off logging to a file for some hosts.
  * This is only meaningful for variables that are *optional*.   * This is only meaningful for variables that are *optional*.
  */   */
intbool
 set_default(char *var, char *val, int op)  set_default(char *var, char *val, int op)
 {  {
     struct sudo_defs_types *cur;      struct sudo_defs_types *cur;
     int num;      int num;
       debug_decl(set_default, SUDO_DEBUG_DEFAULTS)
   
     for (cur = sudo_defs_table, num = 0; cur->name; cur++, num++) {      for (cur = sudo_defs_table, num = 0; cur->name; cur++, num++) {
         if (strcmp(var, cur->name) == 0)          if (strcmp(var, cur->name) == 0)
Line 203  set_default(char *var, char *val, int op) Line 205  set_default(char *var, char *val, int op)
     }      }
     if (!cur->name) {      if (!cur->name) {
         warningx(_("unknown defaults entry `%s'"), var);          warningx(_("unknown defaults entry `%s'"), var);
        return FALSE;        debug_return_bool(false);
     }      }
   
     switch (cur->type & T_MASK) {      switch (cur->type & T_MASK) {
Line 214  set_default(char *var, char *val, int op) Line 216  set_default(char *var, char *val, int op)
                         val, var);                          val, var);
                 else                  else
                     warningx(_("no value specified for `%s'"), var);                      warningx(_("no value specified for `%s'"), var);
                return FALSE;                debug_return_bool(false);
             }              }
             break;              break;
         case T_LOGPRI:          case T_LOGPRI:
Line 224  set_default(char *var, char *val, int op) Line 226  set_default(char *var, char *val, int op)
                         val, var);                          val, var);
                 else                  else
                     warningx(_("no value specified for `%s'"), var);                      warningx(_("no value specified for `%s'"), var);
                return FALSE;                debug_return_bool(false);
             }              }
             break;              break;
         case T_STR:          case T_STR:
             if (!val) {              if (!val) {
                 /* Check for bogus boolean usage or lack of a value. */                  /* Check for bogus boolean usage or lack of a value. */
                if (!ISSET(cur->type, T_BOOL) || op != FALSE) {                if (!ISSET(cur->type, T_BOOL) || op != false) {
                     warningx(_("no value specified for `%s'"), var);                      warningx(_("no value specified for `%s'"), var);
                    return FALSE;                    debug_return_bool(false);
                 }                  }
             }              }
             if (ISSET(cur->type, T_PATH) && val && *val != '/') {              if (ISSET(cur->type, T_PATH) && val && *val != '/') {
                 warningx(_("values for `%s' must start with a '/'"), var);                  warningx(_("values for `%s' must start with a '/'"), var);
                return FALSE;                debug_return_bool(false);
             }              }
             if (!store_str(val, cur, op)) {              if (!store_str(val, cur, op)) {
                 warningx(_("value `%s' is invalid for option `%s'"), val, var);                  warningx(_("value `%s' is invalid for option `%s'"), val, var);
                return FALSE;                debug_return_bool(false);
             }              }
             break;              break;
         case T_INT:          case T_INT:
             if (!val) {              if (!val) {
                 /* Check for bogus boolean usage or lack of a value. */                  /* Check for bogus boolean usage or lack of a value. */
                if (!ISSET(cur->type, T_BOOL) || op != FALSE) {                if (!ISSET(cur->type, T_BOOL) || op != false) {
                     warningx(_("no value specified for `%s'"), var);                      warningx(_("no value specified for `%s'"), var);
                    return FALSE;                    debug_return_bool(false);
                 }                  }
             }              }
             if (!store_int(val, cur, op)) {              if (!store_int(val, cur, op)) {
                 warningx(_("value `%s' is invalid for option `%s'"), val, var);                  warningx(_("value `%s' is invalid for option `%s'"), val, var);
                return FALSE;                debug_return_bool(false);
             }              }
             break;              break;
         case T_UINT:          case T_UINT:
             if (!val) {              if (!val) {
                 /* Check for bogus boolean usage or lack of a value. */                  /* Check for bogus boolean usage or lack of a value. */
                if (!ISSET(cur->type, T_BOOL) || op != FALSE) {                if (!ISSET(cur->type, T_BOOL) || op != false) {
                     warningx(_("no value specified for `%s'"), var);                      warningx(_("no value specified for `%s'"), var);
                    return FALSE;                    debug_return_bool(false);
                 }                  }
             }              }
             if (!store_uint(val, cur, op)) {              if (!store_uint(val, cur, op)) {
                 warningx(_("value `%s' is invalid for option `%s'"), val, var);                  warningx(_("value `%s' is invalid for option `%s'"), val, var);
                return FALSE;                debug_return_bool(false);
             }              }
             break;              break;
         case T_FLOAT:          case T_FLOAT:
             if (!val) {              if (!val) {
                 /* Check for bogus boolean usage or lack of a value. */                  /* Check for bogus boolean usage or lack of a value. */
                if (!ISSET(cur->type, T_BOOL) || op != FALSE) {                if (!ISSET(cur->type, T_BOOL) || op != false) {
                     warningx(_("no value specified for `%s'"), var);                      warningx(_("no value specified for `%s'"), var);
                    return FALSE;                    debug_return_bool(false);
                 }                  }
             }              }
             if (!store_float(val, cur, op)) {              if (!store_float(val, cur, op)) {
                 warningx(_("value `%s' is invalid for option `%s'"), val, var);                  warningx(_("value `%s' is invalid for option `%s'"), val, var);
                return FALSE;                debug_return_bool(false);
             }              }
             break;              break;
         case T_MODE:          case T_MODE:
             if (!val) {              if (!val) {
                 /* Check for bogus boolean usage or lack of a value. */                  /* Check for bogus boolean usage or lack of a value. */
                if (!ISSET(cur->type, T_BOOL) || op != FALSE) {                if (!ISSET(cur->type, T_BOOL) || op != false) {
                     warningx(_("no value specified for `%s'"), var);                      warningx(_("no value specified for `%s'"), var);
                    return FALSE;                    debug_return_bool(false);
                 }                  }
             }              }
             if (!store_mode(val, cur, op)) {              if (!store_mode(val, cur, op)) {
                 warningx(_("value `%s' is invalid for option `%s'"), val, var);                  warningx(_("value `%s' is invalid for option `%s'"), val, var);
                return FALSE;                debug_return_bool(false);
             }              }
             break;              break;
         case T_FLAG:          case T_FLAG:
             if (val) {              if (val) {
                 warningx(_("option `%s' does not take a value"), var);                  warningx(_("option `%s' does not take a value"), var);
                return FALSE;                debug_return_bool(false);
             }              }
             cur->sd_un.flag = op;              cur->sd_un.flag = op;
             break;              break;
         case T_LIST:          case T_LIST:
             if (!val) {              if (!val) {
                 /* Check for bogus boolean usage or lack of a value. */                  /* Check for bogus boolean usage or lack of a value. */
                if (!ISSET(cur->type, T_BOOL) || op != FALSE) {                if (!ISSET(cur->type, T_BOOL) || op != false) {
                     warningx(_("no value specified for `%s'"), var);                      warningx(_("no value specified for `%s'"), var);
                    return FALSE;                    debug_return_bool(false);
                 }                  }
             }              }
             if (!store_list(val, cur, op)) {              if (!store_list(val, cur, op)) {
                 warningx(_("value `%s' is invalid for option `%s'"), val, var);                  warningx(_("value `%s' is invalid for option `%s'"), val, var);
                return FALSE;                debug_return_bool(false);
             }              }
             break;              break;
         case T_TUPLE:          case T_TUPLE:
             if (!val && !ISSET(cur->type, T_BOOL)) {              if (!val && !ISSET(cur->type, T_BOOL)) {
                 warningx(_("no value specified for `%s'"), var);                  warningx(_("no value specified for `%s'"), var);
                return FALSE;                debug_return_bool(false);
             }              }
             if (!store_tuple(val, cur, op)) {              if (!store_tuple(val, cur, op)) {
                 warningx(_("value `%s' is invalid for option `%s'"), val, var);                  warningx(_("value `%s' is invalid for option `%s'"), val, var);
                return FALSE;                debug_return_bool(false);
             }              }
             break;              break;
     }      }
   
    return TRUE;    debug_return_bool(true);
 }  }
   
 /*  /*
Line 340  init_defaults(void) Line 342  init_defaults(void)
 {  {
     static int firsttime = 1;      static int firsttime = 1;
     struct sudo_defs_types *def;      struct sudo_defs_types *def;
       debug_decl(init_defaults, SUDO_DEBUG_DEFAULTS)
   
     /* Clear any old settings. */      /* Clear any old settings. */
     if (!firsttime) {      if (!firsttime) {
Line 353  init_defaults(void) Line 356  init_defaults(void)
                     list_op(NULL, 0, def, freeall);                      list_op(NULL, 0, def, freeall);
                     break;                      break;
             }              }
            zero_bytes(&def->sd_un, sizeof(def->sd_un));            memset(&def->sd_un, 0, sizeof(def->sd_un));
         }          }
     }      }
   
     /* First initialize the flags. */      /* First initialize the flags. */
 #ifdef LONG_OTP_PROMPT  #ifdef LONG_OTP_PROMPT
    def_long_otp_prompt = TRUE;    def_long_otp_prompt = true;
 #endif  #endif
 #ifdef IGNORE_DOT_PATH  #ifdef IGNORE_DOT_PATH
    def_ignore_dot = TRUE;    def_ignore_dot = true;
 #endif  #endif
 #ifdef ALWAYS_SEND_MAIL  #ifdef ALWAYS_SEND_MAIL
    def_mail_always = TRUE;    def_mail_always = true;
 #endif  #endif
 #ifdef SEND_MAIL_WHEN_NO_USER  #ifdef SEND_MAIL_WHEN_NO_USER
    def_mail_no_user = TRUE;    def_mail_no_user = true;
 #endif  #endif
 #ifdef SEND_MAIL_WHEN_NO_HOST  #ifdef SEND_MAIL_WHEN_NO_HOST
    def_mail_no_host = TRUE;    def_mail_no_host = true;
 #endif  #endif
 #ifdef SEND_MAIL_WHEN_NOT_OK  #ifdef SEND_MAIL_WHEN_NOT_OK
    def_mail_no_perms = TRUE;    def_mail_no_perms = true;
 #endif  #endif
 #ifndef NO_TTY_TICKETS  #ifndef NO_TTY_TICKETS
    def_tty_tickets = TRUE;    def_tty_tickets = true;
 #endif  #endif
 #ifndef NO_LECTURE  #ifndef NO_LECTURE
     def_lecture = once;      def_lecture = once;
 #endif  #endif
 #ifndef NO_AUTHENTICATION  #ifndef NO_AUTHENTICATION
    def_authenticate = TRUE;    def_authenticate = true;
 #endif  #endif
 #ifndef NO_ROOT_SUDO  #ifndef NO_ROOT_SUDO
    def_root_sudo = TRUE;    def_root_sudo = true;
 #endif  #endif
 #ifdef HOST_IN_LOG  #ifdef HOST_IN_LOG
    def_log_host = TRUE;    def_log_host = true;
 #endif  #endif
 #ifdef SHELL_IF_NO_ARGS  #ifdef SHELL_IF_NO_ARGS
    def_shell_noargs = TRUE;    def_shell_noargs = true;
 #endif  #endif
 #ifdef SHELL_SETS_HOME  #ifdef SHELL_SETS_HOME
    def_set_home = TRUE;    def_set_home = true;
 #endif  #endif
 #ifndef DONT_LEAK_PATH_INFO  #ifndef DONT_LEAK_PATH_INFO
    def_path_info = TRUE;    def_path_info = true;
 #endif  #endif
 #ifdef FQDN  #ifdef FQDN
    def_fqdn = TRUE;    def_fqdn = true;
 #endif  #endif
 #ifdef USE_INSULTS  #ifdef USE_INSULTS
    def_insults = TRUE;    def_insults = true;
 #endif  #endif
 #ifdef ENV_EDITOR  #ifdef ENV_EDITOR
    def_env_editor = TRUE;    def_env_editor = true;
 #endif  #endif
 #ifdef UMASK_OVERRIDE  #ifdef UMASK_OVERRIDE
    def_umask_override = TRUE;    def_umask_override = true;
 #endif  #endif
     def_iolog_file = estrdup("%{seq}");      def_iolog_file = estrdup("%{seq}");
     def_iolog_dir = estrdup(_PATH_SUDO_IO_LOGDIR);      def_iolog_dir = estrdup(_PATH_SUDO_IO_LOGDIR);
     def_sudoers_locale = estrdup("C");      def_sudoers_locale = estrdup("C");
     def_env_reset = ENV_RESET;      def_env_reset = ENV_RESET;
    def_set_logname = TRUE;    def_set_logname = true;
     def_closefrom = STDERR_FILENO + 1;      def_closefrom = STDERR_FILENO + 1;
       def_pam_service = estrdup("sudo");
   #ifdef HAVE_PAM_LOGIN
       def_pam_login_service = estrdup("sudo-i");
   #else
       def_pam_login_service = estrdup("sudo");
   #endif
   #ifdef NO_PAM_SESSION
       def_pam_session = false;
   #else
       def_pam_session = true;
   #endif
   
     /* Syslog options need special care since they both strings and ints */      /* Syslog options need special care since they both strings and ints */
 #if (LOGGING & SLOG_SYSLOG)  #if (LOGGING & SLOG_SYSLOG)
    (void) store_syslogfac(LOGFAC, &sudo_defs_table[I_SYSLOG], TRUE);    (void) store_syslogfac(LOGFAC, &sudo_defs_table[I_SYSLOG], true);
     (void) store_syslogpri(PRI_SUCCESS, &sudo_defs_table[I_SYSLOG_GOODPRI],      (void) store_syslogpri(PRI_SUCCESS, &sudo_defs_table[I_SYSLOG_GOODPRI],
        TRUE);        true);
     (void) store_syslogpri(PRI_FAILURE, &sudo_defs_table[I_SYSLOG_BADPRI],      (void) store_syslogpri(PRI_FAILURE, &sudo_defs_table[I_SYSLOG_BADPRI],
        TRUE);        true);
 #endif  #endif
   
     /* Password flags also have a string and integer component. */      /* Password flags also have a string and integer component. */
    (void) store_tuple("any", &sudo_defs_table[I_LISTPW], TRUE);    (void) store_tuple("any", &sudo_defs_table[I_LISTPW], true);
    (void) store_tuple("all", &sudo_defs_table[I_VERIFYPW], TRUE);    (void) store_tuple("all", &sudo_defs_table[I_VERIFYPW], true);
   
     /* Then initialize the int-like things. */      /* Then initialize the int-like things. */
 #ifdef SUDO_UMASK  #ifdef SUDO_UMASK
Line 443  init_defaults(void) Line 457  init_defaults(void)
     def_passwd_timeout = PASSWORD_TIMEOUT;      def_passwd_timeout = PASSWORD_TIMEOUT;
     def_passwd_tries = TRIES_FOR_PASSWORD;      def_passwd_tries = TRIES_FOR_PASSWORD;
 #ifdef HAVE_ZLIB_H  #ifdef HAVE_ZLIB_H
    def_compress_io = TRUE;    def_compress_io = true;
 #endif  #endif
   
     /* Now do the strings */      /* Now do the strings */
     def_mailto = estrdup(MAILTO);      def_mailto = estrdup(MAILTO);
    def_mailsub = estrdup(_(MAILSUBJECT));    def_mailsub = estrdup(N_(MAILSUBJECT));
     def_badpass_message = estrdup(_(INCORRECT_PASSWORD));      def_badpass_message = estrdup(_(INCORRECT_PASSWORD));
     def_timestampdir = estrdup(_PATH_SUDO_TIMEDIR);      def_timestampdir = estrdup(_PATH_SUDO_TIMEDIR);
     def_passprompt = estrdup(_(PASSPROMPT));      def_passprompt = estrdup(_(PASSPROMPT));
Line 467  init_defaults(void) Line 481  init_defaults(void)
     def_secure_path = estrdup(SECURE_PATH);      def_secure_path = estrdup(SECURE_PATH);
 #endif  #endif
     def_editor = estrdup(EDITOR);      def_editor = estrdup(EDITOR);
    def_set_utmp = TRUE;    def_set_utmp = true;
   
     /* Finally do the lists (currently just environment tables). */      /* Finally do the lists (currently just environment tables). */
     init_envtables();      init_envtables();
   
     firsttime = 0;      firsttime = 0;
   
       debug_return;
 }  }
   
 /*  /*
  * Update the defaults based on what was set by sudoers.   * Update the defaults based on what was set by sudoers.
  * Pass in an OR'd list of which default types to update.   * Pass in an OR'd list of which default types to update.
  */   */
intbool
 update_defaults(int what)  update_defaults(int what)
 {  {
     struct defaults *def;      struct defaults *def;
    int rc = TRUE;    bool rc = true;
     debug_decl(update_defaults, SUDO_DEBUG_DEFAULTS)
   
     tq_foreach_fwd(&defaults, def) {      tq_foreach_fwd(&defaults, def) {
         switch (def->type) {          switch (def->type) {
             case DEFAULTS:              case DEFAULTS:
                 if (ISSET(what, SETDEF_GENERIC) &&                  if (ISSET(what, SETDEF_GENERIC) &&
                     !set_default(def->var, def->val, def->op))                      !set_default(def->var, def->val, def->op))
                    rc = FALSE;                    rc = false;
                 break;                  break;
             case DEFAULTS_USER:              case DEFAULTS_USER:
   #if 1
                   if (ISSET(what, SETDEF_USER)) {
                       int m;
                       m = userlist_matches(sudo_user.pw, &def->binding);
                       if (m == ALLOW) {
                           if (!set_default(def->var, def->val, def->op))
                               rc = false;
                       }
                   }
   #else
                 if (ISSET(what, SETDEF_USER) &&                  if (ISSET(what, SETDEF_USER) &&
                     userlist_matches(sudo_user.pw, &def->binding) == ALLOW &&                      userlist_matches(sudo_user.pw, &def->binding) == ALLOW &&
                     !set_default(def->var, def->val, def->op))                      !set_default(def->var, def->val, def->op))
                    rc = FALSE;                    rc = false;
 #endif
                 break;                  break;
             case DEFAULTS_RUNAS:              case DEFAULTS_RUNAS:
                 if (ISSET(what, SETDEF_RUNAS) &&                  if (ISSET(what, SETDEF_RUNAS) &&
                    runaslist_matches(&def->binding, NULL) == ALLOW &&                    runaslist_matches(&def->binding, NULL, NULL, NULL) == ALLOW &&
                     !set_default(def->var, def->val, def->op))                      !set_default(def->var, def->val, def->op))
                    rc = FALSE;                    rc = false;
                 break;                  break;
             case DEFAULTS_HOST:              case DEFAULTS_HOST:
                 if (ISSET(what, SETDEF_HOST) &&                  if (ISSET(what, SETDEF_HOST) &&
                     hostlist_matches(&def->binding) == ALLOW &&                      hostlist_matches(&def->binding) == ALLOW &&
                     !set_default(def->var, def->val, def->op))                      !set_default(def->var, def->val, def->op))
                    rc = FALSE;                    rc = false;
                 break;                  break;
             case DEFAULTS_CMND:              case DEFAULTS_CMND:
                 if (ISSET(what, SETDEF_CMND) &&                  if (ISSET(what, SETDEF_CMND) &&
                     cmndlist_matches(&def->binding) == ALLOW &&                      cmndlist_matches(&def->binding) == ALLOW &&
                     !set_default(def->var, def->val, def->op))                      !set_default(def->var, def->val, def->op))
                    rc = FALSE;                    rc = false;
                 break;                  break;
         }          }
     }      }
    return rc;    debug_return_bool(rc);
 }  }
   
static int/*
  * Check the defaults entries without actually setting them.
  * Pass in an OR'd list of which default types to check.
  */
 bool
 check_defaults(int what, bool quiet)
 {
     struct sudo_defs_types *cur;
     struct defaults *def;
     bool rc = true;
     debug_decl(check_defaults, SUDO_DEBUG_DEFAULTS)
 
     tq_foreach_fwd(&defaults, def) {
         switch (def->type) {
             case DEFAULTS:
                 if (!ISSET(what, SETDEF_GENERIC))
                     continue;
                 break;
             case DEFAULTS_USER:
                 if (!ISSET(what, SETDEF_USER))
                     continue;
                 break;
             case DEFAULTS_RUNAS:
                 if (!ISSET(what, SETDEF_RUNAS))
                     continue;
                 break;
             case DEFAULTS_HOST:
                 if (!ISSET(what, SETDEF_HOST))
                     continue;
                 break;
             case DEFAULTS_CMND:
                 if (!ISSET(what, SETDEF_CMND))
                     continue;
                 break;
         }
         for (cur = sudo_defs_table; cur->name != NULL; cur++) {
             if (strcmp(def->var, cur->name) == 0)
                 break;
         }
         if (cur->name == NULL) {
             if (!quiet)
                 warningx(_("unknown defaults entry `%s'"), def->var);
             rc = false;
         }
     }
     debug_return_bool(rc);
 }
 
 static bool
 store_int(char *val, struct sudo_defs_types *def, int op)  store_int(char *val, struct sudo_defs_types *def, int op)
 {  {
     char *endp;      char *endp;
     long l;      long l;
       debug_decl(store_int, SUDO_DEBUG_DEFAULTS)
   
    if (op == FALSE) {    if (op == false) {
         def->sd_un.ival = 0;          def->sd_un.ival = 0;
     } else {      } else {
         l = strtol(val, &endp, 10);          l = strtol(val, &endp, 10);
         if (*endp != '\0')          if (*endp != '\0')
            return FALSE;            debug_return_bool(false);
         /* XXX - should check against INT_MAX */          /* XXX - should check against INT_MAX */
         def->sd_un.ival = (int)l;          def->sd_un.ival = (int)l;
     }      }
     if (def->callback)      if (def->callback)
        return def->callback(val);        debug_return_bool(def->callback(val));
    return TRUE;    debug_return_bool(true);
 }  }
   
static intstatic bool
 store_uint(char *val, struct sudo_defs_types *def, int op)  store_uint(char *val, struct sudo_defs_types *def, int op)
 {  {
     char *endp;      char *endp;
     long l;      long l;
       debug_decl(store_uint, SUDO_DEBUG_DEFAULTS)
   
    if (op == FALSE) {    if (op == false) {
         def->sd_un.ival = 0;          def->sd_un.ival = 0;
     } else {      } else {
         l = strtol(val, &endp, 10);          l = strtol(val, &endp, 10);
         if (*endp != '\0' || l < 0)          if (*endp != '\0' || l < 0)
            return FALSE;            debug_return_bool(false);
         /* XXX - should check against INT_MAX */          /* XXX - should check against INT_MAX */
         def->sd_un.ival = (unsigned int)l;          def->sd_un.ival = (unsigned int)l;
     }      }
     if (def->callback)      if (def->callback)
        return def->callback(val);        debug_return_bool(def->callback(val));
    return TRUE;    debug_return_bool(true);
 }  }
   
static intstatic bool
 store_float(char *val, struct sudo_defs_types *def, int op)  store_float(char *val, struct sudo_defs_types *def, int op)
 {  {
     char *endp;      char *endp;
     double d;      double d;
       debug_decl(store_float, SUDO_DEBUG_DEFAULTS)
   
    if (op == FALSE) {    if (op == false) {
         def->sd_un.fval = 0.0;          def->sd_un.fval = 0.0;
     } else {      } else {
         d = strtod(val, &endp);          d = strtod(val, &endp);
         if (*endp != '\0')          if (*endp != '\0')
            return FALSE;            debug_return_bool(false);
         /* XXX - should check against HUGE_VAL */          /* XXX - should check against HUGE_VAL */
         def->sd_un.fval = d;          def->sd_un.fval = d;
     }      }
     if (def->callback)      if (def->callback)
        return def->callback(val);        debug_return_bool(def->callback(val));
    return TRUE;    debug_return_bool(true);
 }  }
   
static intstatic bool
 store_tuple(char *val, struct sudo_defs_types *def, int op)  store_tuple(char *val, struct sudo_defs_types *def, int op)
 {  {
     struct def_values *v;      struct def_values *v;
       debug_decl(store_tuple, SUDO_DEBUG_DEFAULTS)
   
     /*      /*
      * Since enums are really just ints we store the value as an ival.       * Since enums are really just ints we store the value as an ival.
Line 594  store_tuple(char *val, struct sudo_defs_types *def, in Line 674  store_tuple(char *val, struct sudo_defs_types *def, in
      * be the equivalent to a boolean "false".       * be the equivalent to a boolean "false".
      */       */
     if (!val) {      if (!val) {
        def->sd_un.ival = (op == FALSE) ? 0 : 1;        def->sd_un.ival = (op == false) ? 0 : 1;
     } else {      } else {
         for (v = def->values; v->sval != NULL; v++) {          for (v = def->values; v->sval != NULL; v++) {
             if (strcmp(v->sval, val) == 0) {              if (strcmp(v->sval, val) == 0) {
Line 603  store_tuple(char *val, struct sudo_defs_types *def, in Line 683  store_tuple(char *val, struct sudo_defs_types *def, in
             }              }
         }          }
         if (v->sval == NULL)          if (v->sval == NULL)
            return FALSE;            debug_return_bool(false);
     }      }
     if (def->callback)      if (def->callback)
        return def->callback(val);        debug_return_bool(def->callback(val));
    return TRUE;    debug_return_bool(true);
 }  }
   
static intstatic bool
 store_str(char *val, struct sudo_defs_types *def, int op)  store_str(char *val, struct sudo_defs_types *def, int op)
 {  {
       debug_decl(store_str, SUDO_DEBUG_DEFAULTS)
   
     efree(def->sd_un.str);      efree(def->sd_un.str);
    if (op == FALSE)    if (op == false)
         def->sd_un.str = NULL;          def->sd_un.str = NULL;
     else      else
         def->sd_un.str = estrdup(val);          def->sd_un.str = estrdup(val);
     if (def->callback)      if (def->callback)
        return def->callback(val);        debug_return_bool(def->callback(val));
    return TRUE;    debug_return_bool(true);
 }  }
   
static intstatic bool
 store_list(char *str, struct sudo_defs_types *def, int op)  store_list(char *str, struct sudo_defs_types *def, int op)
 {  {
     char *start, *end;      char *start, *end;
       debug_decl(store_list, SUDO_DEBUG_DEFAULTS)
   
     /* Remove all old members. */      /* Remove all old members. */
    if (op == FALSE || op == TRUE)    if (op == false || op == true)
         list_op(NULL, 0, def, freeall);          list_op(NULL, 0, def, freeall);
   
     /* Split str into multiple space-separated words and act on each one. */      /* Split str into multiple space-separated words and act on each one. */
    if (op != FALSE) {    if (op != false) {
         end = str;          end = str;
         do {          do {
             /* Remove leading blanks, if nothing but blanks we are done. */              /* Remove leading blanks, if nothing but blanks we are done. */
Line 649  store_list(char *str, struct sudo_defs_types *def, int Line 731  store_list(char *str, struct sudo_defs_types *def, int
             list_op(start, end - start, def, op == '-' ? delete : add);              list_op(start, end - start, def, op == '-' ? delete : add);
         } while (*end++ != '\0');          } while (*end++ != '\0');
     }      }
    return TRUE;    debug_return_bool(true);
 }  }
   
static intstatic bool
 store_syslogfac(char *val, struct sudo_defs_types *def, int op)  store_syslogfac(char *val, struct sudo_defs_types *def, int op)
 {  {
     struct strmap *fac;      struct strmap *fac;
       debug_decl(store_syslogfac, SUDO_DEBUG_DEFAULTS)
   
    if (op == FALSE) {    if (op == false) {
        def->sd_un.ival = FALSE;        def->sd_un.ival = false;
        return TRUE;        debug_return_bool(true);
     }      }
 #ifdef LOG_NFACILITIES  #ifdef LOG_NFACILITIES
     if (!val)      if (!val)
        return FALSE;        debug_return_bool(false);
     for (fac = facilities; fac->name && strcmp(val, fac->name); fac++)      for (fac = facilities; fac->name && strcmp(val, fac->name); fac++)
         ;          ;
     if (fac->name == NULL)      if (fac->name == NULL)
        return FALSE;                          /* not found */        debug_return_bool(false);                /* not found */
   
     def->sd_un.ival = fac->num;      def->sd_un.ival = fac->num;
 #else  #else
     def->sd_un.ival = -1;      def->sd_un.ival = -1;
 #endif /* LOG_NFACILITIES */  #endif /* LOG_NFACILITIES */
    return TRUE;    debug_return_bool(true);
 }  }
   
 static const char *  static const char *
Line 681  logfac2str(int n) Line 764  logfac2str(int n)
 {  {
 #ifdef LOG_NFACILITIES  #ifdef LOG_NFACILITIES
     struct strmap *fac;      struct strmap *fac;
       debug_decl(logfac2str, SUDO_DEBUG_DEFAULTS)
   
     for (fac = facilities; fac->name && fac->num != n; fac++)      for (fac = facilities; fac->name && fac->num != n; fac++)
         ;          ;
    return fac->name;    debug_return_str(fac->name);
 #else  #else
     return "default";      return "default";
 #endif /* LOG_NFACILITIES */  #endif /* LOG_NFACILITIES */
 }  }
   
static intstatic bool
 store_syslogpri(char *val, struct sudo_defs_types *def, int op)  store_syslogpri(char *val, struct sudo_defs_types *def, int op)
 {  {
     struct strmap *pri;      struct strmap *pri;
       debug_decl(store_syslogpri, SUDO_DEBUG_DEFAULTS)
   
    if (op == FALSE || !val)    if (op == false || !val)
        return FALSE;        debug_return_bool(false);
   
     for (pri = priorities; pri->name && strcmp(val, pri->name); pri++)      for (pri = priorities; pri->name && strcmp(val, pri->name); pri++)
         ;          ;
     if (pri->name == NULL)      if (pri->name == NULL)
        return FALSE;                          /* not found */        debug_return_bool(false);   /* not found */
   
     def->sd_un.ival = pri->num;      def->sd_un.ival = pri->num;
    return TRUE;    debug_return_bool(true);
 }  }
   
 static const char *  static const char *
 logpri2str(int n)  logpri2str(int n)
 {  {
     struct strmap *pri;      struct strmap *pri;
       debug_decl(logpri2str, SUDO_DEBUG_DEFAULTS)
   
     for (pri = priorities; pri->name && pri->num != n; pri++)      for (pri = priorities; pri->name && pri->num != n; pri++)
         ;          ;
    return pri->name;    debug_return_str(pri->name);
 }  }
   
static intstatic bool
 store_mode(char *val, struct sudo_defs_types *def, int op)  store_mode(char *val, struct sudo_defs_types *def, int op)
 {  {
     char *endp;      char *endp;
     long l;      long l;
       debug_decl(store_mode, SUDO_DEBUG_DEFAULTS)
   
    if (op == FALSE) {    if (op == false) {
         def->sd_un.mode = (mode_t)0777;          def->sd_un.mode = (mode_t)0777;
     } else {      } else {
         l = strtol(val, &endp, 8);          l = strtol(val, &endp, 8);
         if (*endp != '\0' || l < 0 || l > 0777)          if (*endp != '\0' || l < 0 || l > 0777)
            return FALSE;            debug_return_bool(false);
         def->sd_un.mode = (mode_t)l;          def->sd_un.mode = (mode_t)l;
     }      }
     if (def->callback)      if (def->callback)
        return def->callback(val);        debug_return_bool(def->callback(val));
    return TRUE;    debug_return_bool(true);
 }  }
   
 static void  static void
 list_op(char *val, size_t len, struct sudo_defs_types *def, enum list_ops op)  list_op(char *val, size_t len, struct sudo_defs_types *def, enum list_ops op)
 {  {
     struct list_member *cur, *prev, *tmp;      struct list_member *cur, *prev, *tmp;
       debug_decl(list_op, SUDO_DEBUG_DEFAULTS)
   
     if (op == freeall) {      if (op == freeall) {
         for (cur = def->sd_un.list; cur; ) {          for (cur = def->sd_un.list; cur; ) {
Line 749  list_op(char *val, size_t len, struct sudo_defs_types  Line 837  list_op(char *val, size_t len, struct sudo_defs_types 
             efree(tmp);              efree(tmp);
         }          }
         def->sd_un.list = NULL;          def->sd_un.list = NULL;
        return;        debug_return;
     }      }
   
     for (cur = def->sd_un.list, prev = NULL; cur; prev = cur, cur = cur->next) {      for (cur = def->sd_un.list, prev = NULL; cur; prev = cur, cur = cur->next) {
         if ((strncmp(cur->value, val, len) == 0 && cur->value[len] == '\0')) {          if ((strncmp(cur->value, val, len) == 0 && cur->value[len] == '\0')) {
   
             if (op == add)              if (op == add)
                return;                 /* already exists */                debug_return;         /* already exists */
   
             /* Delete node */              /* Delete node */
             if (prev != NULL)              if (prev != NULL)
Line 771  list_op(char *val, size_t len, struct sudo_defs_types  Line 859  list_op(char *val, size_t len, struct sudo_defs_types 
   
     /* Add new node to the head of the list. */      /* Add new node to the head of the list. */
     if (op == add) {      if (op == add) {
        cur = emalloc(sizeof(struct list_member));        cur = ecalloc(1, sizeof(struct list_member));
        cur->value = emalloc(len + 1);        cur->value = estrndup(val, len);
        (void) memcpy(cur->value, val, len); 
        cur->value[len] = '\0'; 
         cur->next = def->sd_un.list;          cur->next = def->sd_un.list;
         def->sd_un.list = cur;          def->sd_un.list = cur;
     }      }
       debug_return;
 }  }
Removed from v.1.1.1.1  
changed lines
  Added in v.1.1.1.5

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