[BACK]Return to servconf.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / ssh

Diff for /src/usr.bin/ssh/servconf.c between version 1.24 and 1.25

version 1.24, 1999/11/19 20:03:35 version 1.25, 1999/11/23 22:25:54
Line 20 
Line 20 
   
 /* Initializes the server options to their default values. */  /* Initializes the server options to their default values. */
   
 void initialize_server_options(ServerOptions *options)  void
   initialize_server_options(ServerOptions *options)
 {  {
   memset(options, 0, sizeof(*options));          memset(options, 0, sizeof(*options));
   options->port = -1;          options->port = -1;
   options->listen_addr.s_addr = htonl(INADDR_ANY);          options->listen_addr.s_addr = htonl(INADDR_ANY);
   options->host_key_file = NULL;          options->host_key_file = NULL;
   options->server_key_bits = -1;          options->server_key_bits = -1;
   options->login_grace_time = -1;          options->login_grace_time = -1;
   options->key_regeneration_time = -1;          options->key_regeneration_time = -1;
   options->permit_root_login = -1;          options->permit_root_login = -1;
   options->ignore_rhosts = -1;          options->ignore_rhosts = -1;
   options->ignore_user_known_hosts = -1;          options->ignore_user_known_hosts = -1;
   options->print_motd = -1;          options->print_motd = -1;
   options->check_mail = -1;          options->check_mail = -1;
   options->x11_forwarding = -1;          options->x11_forwarding = -1;
   options->x11_display_offset = -1;          options->x11_display_offset = -1;
   options->strict_modes = -1;          options->strict_modes = -1;
   options->keepalives = -1;          options->keepalives = -1;
   options->log_facility = (SyslogFacility)-1;          options->log_facility = (SyslogFacility) - 1;
   options->log_level = (LogLevel)-1;          options->log_level = (LogLevel) - 1;
   options->rhosts_authentication = -1;          options->rhosts_authentication = -1;
   options->rhosts_rsa_authentication = -1;          options->rhosts_rsa_authentication = -1;
   options->rsa_authentication = -1;          options->rsa_authentication = -1;
 #ifdef KRB4  #ifdef KRB4
   options->kerberos_authentication = -1;          options->kerberos_authentication = -1;
   options->kerberos_or_local_passwd = -1;          options->kerberos_or_local_passwd = -1;
   options->kerberos_ticket_cleanup = -1;          options->kerberos_ticket_cleanup = -1;
 #endif  #endif
 #ifdef AFS  #ifdef AFS
   options->kerberos_tgt_passing = -1;          options->kerberos_tgt_passing = -1;
   options->afs_token_passing = -1;          options->afs_token_passing = -1;
 #endif  #endif
   options->password_authentication = -1;          options->password_authentication = -1;
 #ifdef SKEY  #ifdef SKEY
   options->skey_authentication = -1;          options->skey_authentication = -1;
 #endif  #endif
   options->permit_empty_passwd = -1;          options->permit_empty_passwd = -1;
   options->use_login = -1;          options->use_login = -1;
   options->num_allow_users = 0;          options->num_allow_users = 0;
   options->num_deny_users = 0;          options->num_deny_users = 0;
   options->num_allow_groups = 0;          options->num_allow_groups = 0;
   options->num_deny_groups = 0;          options->num_deny_groups = 0;
 }  }
   
 void fill_default_server_options(ServerOptions *options)  void
   fill_default_server_options(ServerOptions *options)
 {  {
   if (options->port == -1)          if (options->port == -1) {
     {                  struct servent *sp;
       struct servent *sp;  
   
       sp = getservbyname(SSH_SERVICE_NAME, "tcp");                  sp = getservbyname(SSH_SERVICE_NAME, "tcp");
       if (sp)                  if (sp)
         options->port = ntohs(sp->s_port);                          options->port = ntohs(sp->s_port);
       else                  else
         options->port = SSH_DEFAULT_PORT;                          options->port = SSH_DEFAULT_PORT;
       endservent();                  endservent();
     }          }
   if (options->host_key_file == NULL)          if (options->host_key_file == NULL)
     options->host_key_file = HOST_KEY_FILE;                  options->host_key_file = HOST_KEY_FILE;
   if (options->server_key_bits == -1)          if (options->server_key_bits == -1)
     options->server_key_bits = 768;                  options->server_key_bits = 768;
   if (options->login_grace_time == -1)          if (options->login_grace_time == -1)
     options->login_grace_time = 600;                  options->login_grace_time = 600;
   if (options->key_regeneration_time == -1)          if (options->key_regeneration_time == -1)
     options->key_regeneration_time = 3600;                  options->key_regeneration_time = 3600;
   if (options->permit_root_login == -1)          if (options->permit_root_login == -1)
     options->permit_root_login = 1;              /* yes */                  options->permit_root_login = 1;                 /* yes */
   if (options->ignore_rhosts == -1)          if (options->ignore_rhosts == -1)
     options->ignore_rhosts = 0;                  options->ignore_rhosts = 0;
   if (options->ignore_user_known_hosts == -1)          if (options->ignore_user_known_hosts == -1)
     options->ignore_user_known_hosts = 0;                  options->ignore_user_known_hosts = 0;
   if (options->check_mail == -1)          if (options->check_mail == -1)
     options->check_mail = 0;                  options->check_mail = 0;
   if (options->print_motd == -1)          if (options->print_motd == -1)
     options->print_motd = 1;                  options->print_motd = 1;
   if (options->x11_forwarding == -1)          if (options->x11_forwarding == -1)
     options->x11_forwarding = 1;                  options->x11_forwarding = 1;
   if (options->x11_display_offset == -1)          if (options->x11_display_offset == -1)
     options->x11_display_offset = 1;                  options->x11_display_offset = 1;
   if (options->strict_modes == -1)          if (options->strict_modes == -1)
     options->strict_modes = 1;                  options->strict_modes = 1;
   if (options->keepalives == -1)          if (options->keepalives == -1)
     options->keepalives = 1;                  options->keepalives = 1;
   if (options->log_facility == (SyslogFacility)(-1))          if (options->log_facility == (SyslogFacility) (-1))
     options->log_facility = SYSLOG_FACILITY_AUTH;                  options->log_facility = SYSLOG_FACILITY_AUTH;
   if (options->log_level == (LogLevel)(-1))          if (options->log_level == (LogLevel) (-1))
     options->log_level = SYSLOG_LEVEL_INFO;                  options->log_level = SYSLOG_LEVEL_INFO;
   if (options->rhosts_authentication == -1)          if (options->rhosts_authentication == -1)
     options->rhosts_authentication = 0;                  options->rhosts_authentication = 0;
   if (options->rhosts_rsa_authentication == -1)          if (options->rhosts_rsa_authentication == -1)
     options->rhosts_rsa_authentication = 1;                  options->rhosts_rsa_authentication = 1;
   if (options->rsa_authentication == -1)          if (options->rsa_authentication == -1)
     options->rsa_authentication = 1;                  options->rsa_authentication = 1;
 #ifdef KRB4  #ifdef KRB4
   if (options->kerberos_authentication == -1)          if (options->kerberos_authentication == -1)
     options->kerberos_authentication = (access(KEYFILE, R_OK) == 0);                  options->kerberos_authentication = (access(KEYFILE, R_OK) == 0);
   if (options->kerberos_or_local_passwd == -1)          if (options->kerberos_or_local_passwd == -1)
     options->kerberos_or_local_passwd = 1;                  options->kerberos_or_local_passwd = 1;
   if (options->kerberos_ticket_cleanup == -1)          if (options->kerberos_ticket_cleanup == -1)
     options->kerberos_ticket_cleanup = 1;                  options->kerberos_ticket_cleanup = 1;
 #endif /* KRB4 */  #endif /* KRB4 */
 #ifdef AFS  #ifdef AFS
   if (options->kerberos_tgt_passing == -1)          if (options->kerberos_tgt_passing == -1)
     options->kerberos_tgt_passing = 0;                  options->kerberos_tgt_passing = 0;
   if (options->afs_token_passing == -1)          if (options->afs_token_passing == -1)
     options->afs_token_passing = k_hasafs();                  options->afs_token_passing = k_hasafs();
 #endif /* AFS */  #endif /* AFS */
   if (options->password_authentication == -1)          if (options->password_authentication == -1)
     options->password_authentication = 1;                  options->password_authentication = 1;
 #ifdef SKEY  #ifdef SKEY
   if (options->skey_authentication == -1)          if (options->skey_authentication == -1)
     options->skey_authentication = 1;                  options->skey_authentication = 1;
 #endif  #endif
   if (options->permit_empty_passwd == -1)          if (options->permit_empty_passwd == -1)
     options->permit_empty_passwd = 1;                  options->permit_empty_passwd = 1;
   if (options->use_login == -1)          if (options->use_login == -1)
     options->use_login = 0;                  options->use_login = 0;
 }  }
   
 #define WHITESPACE " \t\r\n"  #define WHITESPACE " \t\r\n"
   
 /* Keyword tokens. */  /* Keyword tokens. */
 typedef enum  typedef enum {
 {          sBadOption,             /* == unknown option */
   sBadOption, /* == unknown option */          sPort, sHostKeyFile, sServerKeyBits, sLoginGraceTime, sKeyRegenerationTime,
   sPort, sHostKeyFile, sServerKeyBits, sLoginGraceTime, sKeyRegenerationTime,          sPermitRootLogin, sLogFacility, sLogLevel,
   sPermitRootLogin, sLogFacility, sLogLevel,          sRhostsAuthentication, sRhostsRSAAuthentication, sRSAAuthentication,
   sRhostsAuthentication, sRhostsRSAAuthentication, sRSAAuthentication,  
 #ifdef KRB4  #ifdef KRB4
   sKerberosAuthentication, sKerberosOrLocalPasswd, sKerberosTicketCleanup,          sKerberosAuthentication, sKerberosOrLocalPasswd, sKerberosTicketCleanup,
 #endif  #endif
 #ifdef AFS  #ifdef AFS
   sKerberosTgtPassing, sAFSTokenPassing,          sKerberosTgtPassing, sAFSTokenPassing,
 #endif  #endif
 #ifdef SKEY  #ifdef SKEY
   sSkeyAuthentication,          sSkeyAuthentication,
 #endif  #endif
   sPasswordAuthentication, sListenAddress,          sPasswordAuthentication, sListenAddress,
   sPrintMotd, sIgnoreRhosts, sX11Forwarding, sX11DisplayOffset,          sPrintMotd, sIgnoreRhosts, sX11Forwarding, sX11DisplayOffset,
   sStrictModes, sEmptyPasswd, sRandomSeedFile, sKeepAlives, sCheckMail,          sStrictModes, sEmptyPasswd, sRandomSeedFile, sKeepAlives, sCheckMail,
   sUseLogin, sAllowUsers, sDenyUsers, sAllowGroups, sDenyGroups,          sUseLogin, sAllowUsers, sDenyUsers, sAllowGroups, sDenyGroups,
   sIgnoreUserKnownHosts          sIgnoreUserKnownHosts
 } ServerOpCodes;  } ServerOpCodes;
   
 /* Textual representation of the tokens. */  /* Textual representation of the tokens. */
 static struct  static struct {
 {          const char *name;
   const char *name;          ServerOpCodes opcode;
   ServerOpCodes opcode;  } keywords[] = {
 } keywords[] =          { "port", sPort },
 {          { "hostkey", sHostKeyFile },
   { "port", sPort },          { "serverkeybits", sServerKeyBits },
   { "hostkey", sHostKeyFile },          { "logingracetime", sLoginGraceTime },
   { "serverkeybits", sServerKeyBits },          { "keyregenerationinterval", sKeyRegenerationTime },
   { "logingracetime", sLoginGraceTime },          { "permitrootlogin", sPermitRootLogin },
   { "keyregenerationinterval", sKeyRegenerationTime },          { "syslogfacility", sLogFacility },
   { "permitrootlogin", sPermitRootLogin },          { "loglevel", sLogLevel },
   { "syslogfacility", sLogFacility },          { "rhostsauthentication", sRhostsAuthentication },
   { "loglevel", sLogLevel },          { "rhostsrsaauthentication", sRhostsRSAAuthentication },
   { "rhostsauthentication", sRhostsAuthentication },          { "rsaauthentication", sRSAAuthentication },
   { "rhostsrsaauthentication", sRhostsRSAAuthentication },  
   { "rsaauthentication", sRSAAuthentication },  
 #ifdef KRB4  #ifdef KRB4
   { "kerberosauthentication", sKerberosAuthentication },          { "kerberosauthentication", sKerberosAuthentication },
   { "kerberosorlocalpasswd", sKerberosOrLocalPasswd },          { "kerberosorlocalpasswd", sKerberosOrLocalPasswd },
   { "kerberosticketcleanup", sKerberosTicketCleanup },          { "kerberosticketcleanup", sKerberosTicketCleanup },
 #endif  #endif
 #ifdef AFS  #ifdef AFS
   { "kerberostgtpassing", sKerberosTgtPassing },          { "kerberostgtpassing", sKerberosTgtPassing },
   { "afstokenpassing", sAFSTokenPassing },          { "afstokenpassing", sAFSTokenPassing },
 #endif  #endif
   { "passwordauthentication", sPasswordAuthentication },          { "passwordauthentication", sPasswordAuthentication },
 #ifdef SKEY  #ifdef SKEY
   { "skeyauthentication", sSkeyAuthentication },          { "skeyauthentication", sSkeyAuthentication },
 #endif  #endif
   { "checkmail", sCheckMail },          { "checkmail", sCheckMail },
   { "listenaddress", sListenAddress },          { "listenaddress", sListenAddress },
   { "printmotd", sPrintMotd },          { "printmotd", sPrintMotd },
   { "ignorerhosts", sIgnoreRhosts },          { "ignorerhosts", sIgnoreRhosts },
   { "ignoreuserknownhosts", sIgnoreUserKnownHosts },          { "ignoreuserknownhosts", sIgnoreUserKnownHosts },
   { "x11forwarding", sX11Forwarding },          { "x11forwarding", sX11Forwarding },
   { "x11displayoffset", sX11DisplayOffset },          { "x11displayoffset", sX11DisplayOffset },
   { "strictmodes", sStrictModes },          { "strictmodes", sStrictModes },
   { "permitemptypasswords", sEmptyPasswd },          { "permitemptypasswords", sEmptyPasswd },
   { "uselogin", sUseLogin },          { "uselogin", sUseLogin },
   { "randomseed", sRandomSeedFile },          { "randomseed", sRandomSeedFile },
   { "keepalive", sKeepAlives },          { "keepalive", sKeepAlives },
   { "allowusers", sAllowUsers },          { "allowusers", sAllowUsers },
   { "denyusers", sDenyUsers },          { "denyusers", sDenyUsers },
   { "allowgroups", sAllowGroups },          { "allowgroups", sAllowGroups },
   { "denygroups", sDenyGroups },          { "denygroups", sDenyGroups },
   { NULL, 0 }          { NULL, 0 }
 };  };
   
 /* Returns the number of the token pointed to by cp of length len.  /* Returns the number of the token pointed to by cp of length len.
    Never returns if the token is not known. */     Never returns if the token is not known. */
   
 static ServerOpCodes parse_token(const char *cp, const char *filename,  static ServerOpCodes
                                  int linenum)  parse_token(const char *cp, const char *filename,
               int linenum)
 {  {
   unsigned int i;          unsigned int i;
   
   for (i = 0; keywords[i].name; i++)          for (i = 0; keywords[i].name; i++)
     if (strcmp(cp, keywords[i].name) == 0)                  if (strcmp(cp, keywords[i].name) == 0)
       return keywords[i].opcode;                          return keywords[i].opcode;
   
   fprintf(stderr, "%s: line %d: Bad configuration option: %s\n",          fprintf(stderr, "%s: line %d: Bad configuration option: %s\n",
           filename, linenum, cp);                  filename, linenum, cp);
   return sBadOption;          return sBadOption;
 }  }
   
 /* Reads the server configuration file. */  /* Reads the server configuration file. */
   
 void read_server_config(ServerOptions *options, const char *filename)  void
   read_server_config(ServerOptions *options, const char *filename)
 {  {
   FILE *f;          FILE *f;
   char line[1024];          char line[1024];
   char *cp, **charptr;          char *cp, **charptr;
   int linenum, *intptr, value;          int linenum, *intptr, value;
   int bad_options = 0;          int bad_options = 0;
   ServerOpCodes opcode;          ServerOpCodes opcode;
   
   f = fopen(filename, "r");          f = fopen(filename, "r");
   if (!f)          if (!f) {
     {                  perror(filename);
       perror(filename);                  exit(1);
       exit(1);          }
     }          linenum = 0;
           while (fgets(line, sizeof(line), f)) {
                   linenum++;
                   cp = line + strspn(line, WHITESPACE);
                   if (!*cp || *cp == '#')
                           continue;
                   cp = strtok(cp, WHITESPACE);
                   {
                           char *t = cp;
                           for (; *t != 0; t++)
                                   if ('A' <= *t && *t <= 'Z')
                                           *t = *t - 'A' + 'a';    /* tolower */
   
   linenum = 0;                  }
   while (fgets(line, sizeof(line), f))                  opcode = parse_token(cp, filename, linenum);
     {                  switch (opcode) {
       linenum++;                  case sBadOption:
       cp = line + strspn(line, WHITESPACE);                          bad_options++;
       if (!*cp || *cp == '#')                          continue;
         continue;                  case sPort:
       cp = strtok(cp, WHITESPACE);                          intptr = &options->port;
       {  parse_int:
         char *t = cp;                          cp = strtok(NULL, WHITESPACE);
         for (; *t != 0; t++)                          if (!cp) {
           if ('A' <= *t && *t <= 'Z')                                  fprintf(stderr, "%s line %d: missing integer value.\n",
             *t = *t - 'A' + 'a';        /* tolower */                                          filename, linenum);
                                   exit(1);
       }                          }
       opcode = parse_token(cp, filename, linenum);                          value = atoi(cp);
       switch (opcode)                          if (*intptr == -1)
         {                                  *intptr = value;
         case sBadOption:                          break;
           bad_options++;  
           continue;  
         case sPort:  
           intptr = &options->port;  
         parse_int:  
           cp = strtok(NULL, WHITESPACE);  
           if (!cp)  
             {  
               fprintf(stderr, "%s line %d: missing integer value.\n",  
                       filename, linenum);  
               exit(1);  
             }  
           value = atoi(cp);  
           if (*intptr == -1)  
             *intptr = value;  
           break;  
   
         case sServerKeyBits:                  case sServerKeyBits:
           intptr = &options->server_key_bits;                          intptr = &options->server_key_bits;
           goto parse_int;                          goto parse_int;
   
         case sLoginGraceTime:                  case sLoginGraceTime:
           intptr = &options->login_grace_time;                          intptr = &options->login_grace_time;
           goto parse_int;                          goto parse_int;
   
         case sKeyRegenerationTime:  
           intptr = &options->key_regeneration_time;  
           goto parse_int;  
   
         case sListenAddress:                  case sKeyRegenerationTime:
           cp = strtok(NULL, WHITESPACE);                          intptr = &options->key_regeneration_time;
           if (!cp)                          goto parse_int;
             {  
               fprintf(stderr, "%s line %d: missing inet addr.\n",  
                       filename, linenum);  
               exit(1);  
             }  
           options->listen_addr.s_addr = inet_addr(cp);  
           break;  
   
         case sHostKeyFile:                  case sListenAddress:
           charptr = &options->host_key_file;                          cp = strtok(NULL, WHITESPACE);
           cp = strtok(NULL, WHITESPACE);                          if (!cp) {
           if (!cp)                                  fprintf(stderr, "%s line %d: missing inet addr.\n",
             {                                          filename, linenum);
               fprintf(stderr, "%s line %d: missing file name.\n",                                  exit(1);
                       filename, linenum);                          }
               exit(1);                          options->listen_addr.s_addr = inet_addr(cp);
             }                          break;
           if (*charptr == NULL)  
             *charptr = tilde_expand_filename(cp, getuid());  
           break;  
   
         case sRandomSeedFile:                  case sHostKeyFile:
           fprintf(stderr, "%s line %d: \"randomseed\" option is obsolete.\n",                          charptr = &options->host_key_file;
                   filename, linenum);                          cp = strtok(NULL, WHITESPACE);
           cp = strtok(NULL, WHITESPACE);                          if (!cp) {
           break;                                  fprintf(stderr, "%s line %d: missing file name.\n",
                                           filename, linenum);
                                   exit(1);
                           }
                           if (*charptr == NULL)
                                   *charptr = tilde_expand_filename(cp, getuid());
                           break;
   
         case sPermitRootLogin:                  case sRandomSeedFile:
           intptr = &options->permit_root_login;                          fprintf(stderr, "%s line %d: \"randomseed\" option is obsolete.\n",
           cp = strtok(NULL, WHITESPACE);                                  filename, linenum);
           if (!cp)                          cp = strtok(NULL, WHITESPACE);
             {                          break;
               fprintf(stderr, "%s line %d: missing yes/without-password/no argument.\n",  
                       filename, linenum);  
               exit(1);  
             }  
           if (strcmp(cp, "without-password") == 0)  
             value = 2;  
           else if (strcmp(cp, "yes") == 0)  
             value = 1;  
           else if (strcmp(cp, "no") == 0)  
             value = 0;  
           else  
             {  
               fprintf(stderr, "%s line %d: Bad yes/without-password/no argument: %s\n",  
                 filename, linenum, cp);  
               exit(1);  
             }  
           if (*intptr == -1)  
             *intptr = value;  
           break;  
   
         case sIgnoreRhosts:                  case sPermitRootLogin:
           intptr = &options->ignore_rhosts;                          intptr = &options->permit_root_login;
         parse_flag:                          cp = strtok(NULL, WHITESPACE);
           cp = strtok(NULL, WHITESPACE);                          if (!cp) {
           if (!cp)                                  fprintf(stderr, "%s line %d: missing yes/without-password/no argument.\n",
             {                                          filename, linenum);
               fprintf(stderr, "%s line %d: missing yes/no argument.\n",                                  exit(1);
                       filename, linenum);                          }
               exit(1);                          if (strcmp(cp, "without-password") == 0)
             }                                  value = 2;
           if (strcmp(cp, "yes") == 0)                          else if (strcmp(cp, "yes") == 0)
             value = 1;                                  value = 1;
           else                          else if (strcmp(cp, "no") == 0)
             if (strcmp(cp, "no") == 0)                                  value = 0;
               value = 0;                          else {
             else                                  fprintf(stderr, "%s line %d: Bad yes/without-password/no argument: %s\n",
               {                                          filename, linenum, cp);
                 fprintf(stderr, "%s line %d: Bad yes/no argument: %s\n",                                  exit(1);
                         filename, linenum, cp);                          }
                 exit(1);                          if (*intptr == -1)
               }                                  *intptr = value;
           if (*intptr == -1)                          break;
             *intptr = value;  
           break;  
   
         case sIgnoreUserKnownHosts:                  case sIgnoreRhosts:
           intptr = &options->ignore_user_known_hosts;                          intptr = &options->ignore_rhosts;
           goto parse_int;  parse_flag:
                           cp = strtok(NULL, WHITESPACE);
                           if (!cp) {
                                   fprintf(stderr, "%s line %d: missing yes/no argument.\n",
                                           filename, linenum);
                                   exit(1);
                           }
                           if (strcmp(cp, "yes") == 0)
                                   value = 1;
                           else if (strcmp(cp, "no") == 0)
                                   value = 0;
                           else {
                                   fprintf(stderr, "%s line %d: Bad yes/no argument: %s\n",
                                           filename, linenum, cp);
                                   exit(1);
                           }
                           if (*intptr == -1)
                                   *intptr = value;
                           break;
   
         case sRhostsAuthentication:                  case sIgnoreUserKnownHosts:
           intptr = &options->rhosts_authentication;                          intptr = &options->ignore_user_known_hosts;
           goto parse_flag;                          goto parse_int;
   
         case sRhostsRSAAuthentication:                  case sRhostsAuthentication:
           intptr = &options->rhosts_rsa_authentication;                          intptr = &options->rhosts_authentication;
           goto parse_flag;                          goto parse_flag;
   
         case sRSAAuthentication:                  case sRhostsRSAAuthentication:
           intptr = &options->rsa_authentication;                          intptr = &options->rhosts_rsa_authentication;
           goto parse_flag;                          goto parse_flag;
   
                   case sRSAAuthentication:
                           intptr = &options->rsa_authentication;
                           goto parse_flag;
   
 #ifdef KRB4  #ifdef KRB4
         case sKerberosAuthentication:                  case sKerberosAuthentication:
           intptr = &options->kerberos_authentication;                          intptr = &options->kerberos_authentication;
           goto parse_flag;                          goto parse_flag;
   
         case sKerberosOrLocalPasswd:  
           intptr = &options->kerberos_or_local_passwd;  
           goto parse_flag;  
   
         case sKerberosTicketCleanup:                  case sKerberosOrLocalPasswd:
           intptr = &options->kerberos_ticket_cleanup;                          intptr = &options->kerberos_or_local_passwd;
           goto parse_flag;                          goto parse_flag;
   
                   case sKerberosTicketCleanup:
                           intptr = &options->kerberos_ticket_cleanup;
                           goto parse_flag;
 #endif  #endif
   
 #ifdef AFS  #ifdef AFS
         case sKerberosTgtPassing:                  case sKerberosTgtPassing:
           intptr = &options->kerberos_tgt_passing;                          intptr = &options->kerberos_tgt_passing;
           goto parse_flag;                          goto parse_flag;
   
         case sAFSTokenPassing:                  case sAFSTokenPassing:
           intptr = &options->afs_token_passing;                          intptr = &options->afs_token_passing;
           goto parse_flag;                          goto parse_flag;
 #endif  #endif
   
         case sPasswordAuthentication:                  case sPasswordAuthentication:
           intptr = &options->password_authentication;                          intptr = &options->password_authentication;
           goto parse_flag;                          goto parse_flag;
   
         case sCheckMail:                  case sCheckMail:
           intptr = &options->check_mail;                          intptr = &options->check_mail;
           goto parse_flag;                          goto parse_flag;
   
 #ifdef SKEY  #ifdef SKEY
         case sSkeyAuthentication:                  case sSkeyAuthentication:
           intptr = &options->skey_authentication;                          intptr = &options->skey_authentication;
           goto parse_flag;                          goto parse_flag;
 #endif  #endif
   
         case sPrintMotd:                  case sPrintMotd:
           intptr = &options->print_motd;                          intptr = &options->print_motd;
           goto parse_flag;                          goto parse_flag;
   
         case sX11Forwarding:                  case sX11Forwarding:
           intptr = &options->x11_forwarding;                          intptr = &options->x11_forwarding;
           goto parse_flag;                          goto parse_flag;
   
         case sX11DisplayOffset:                  case sX11DisplayOffset:
           intptr = &options->x11_display_offset;                          intptr = &options->x11_display_offset;
           goto parse_int;                          goto parse_int;
   
         case sStrictModes:                  case sStrictModes:
           intptr = &options->strict_modes;                          intptr = &options->strict_modes;
           goto parse_flag;                          goto parse_flag;
   
         case sKeepAlives:                  case sKeepAlives:
           intptr = &options->keepalives;                          intptr = &options->keepalives;
           goto parse_flag;                          goto parse_flag;
   
         case sEmptyPasswd:  
           intptr = &options->permit_empty_passwd;  
           goto parse_flag;  
   
         case sUseLogin:                  case sEmptyPasswd:
           intptr = &options->use_login;                          intptr = &options->permit_empty_passwd;
           goto parse_flag;                          goto parse_flag;
   
         case sLogFacility:                  case sUseLogin:
           intptr = (int *)&options->log_facility;                          intptr = &options->use_login;
           cp = strtok(NULL, WHITESPACE);                          goto parse_flag;
           value = log_facility_number(cp);  
           if (value == (SyslogFacility)-1)  
             fatal("%.200s line %d: unsupported log facility '%s'\n",  
               filename, linenum, cp ? cp : "<NONE>");  
           if (*intptr == -1)  
             *intptr = (SyslogFacility)value;  
           break;  
   
         case sLogLevel:                  case sLogFacility:
           intptr = (int *)&options->log_level;                          intptr = (int *) &options->log_facility;
           cp = strtok(NULL, WHITESPACE);                          cp = strtok(NULL, WHITESPACE);
           value = log_level_number(cp);                          value = log_facility_number(cp);
           if (value == (LogLevel)-1)                          if (value == (SyslogFacility) - 1)
             fatal("%.200s line %d: unsupported log level '%s'\n",                                  fatal("%.200s line %d: unsupported log facility '%s'\n",
               filename, linenum, cp ? cp : "<NONE>");                                    filename, linenum, cp ? cp : "<NONE>");
           if (*intptr == -1)                          if (*intptr == -1)
             *intptr = (LogLevel)value;                                  *intptr = (SyslogFacility) value;
           break;                          break;
   
         case sAllowUsers:  
           while ((cp = strtok(NULL, WHITESPACE)))  
             {  
               if (options->num_allow_users >= MAX_ALLOW_USERS)  
                 {  
                   fprintf(stderr, "%s line %d: too many allow users.\n",  
                           filename, linenum);  
                   exit(1);  
                 }  
               options->allow_users[options->num_allow_users++] = xstrdup(cp);  
             }  
           break;  
   
         case sDenyUsers:                  case sLogLevel:
           while ((cp = strtok(NULL, WHITESPACE)))                          intptr = (int *) &options->log_level;
             {                          cp = strtok(NULL, WHITESPACE);
               if (options->num_deny_users >= MAX_DENY_USERS)                          value = log_level_number(cp);
                 {                          if (value == (LogLevel) - 1)
                   fprintf(stderr, "%s line %d: too many deny users.\n",                                  fatal("%.200s line %d: unsupported log level '%s'\n",
                           filename, linenum);                                    filename, linenum, cp ? cp : "<NONE>");
                   exit(1);                          if (*intptr == -1)
                 }                                  *intptr = (LogLevel) value;
               options->deny_users[options->num_deny_users++] = xstrdup(cp);                          break;
             }  
           break;  
   
         case sAllowGroups:                  case sAllowUsers:
           while ((cp = strtok(NULL, WHITESPACE)))                          while ((cp = strtok(NULL, WHITESPACE))) {
             {                                  if (options->num_allow_users >= MAX_ALLOW_USERS) {
               if (options->num_allow_groups >= MAX_ALLOW_GROUPS)                                          fprintf(stderr, "%s line %d: too many allow users.\n",
                 {                                                  filename, linenum);
                   fprintf(stderr, "%s line %d: too many allow groups.\n",                                          exit(1);
                           filename, linenum);                                  }
                   exit(1);                                  options->allow_users[options->num_allow_users++] = xstrdup(cp);
                 }                          }
               options->allow_groups[options->num_allow_groups++] = xstrdup(cp);                          break;
             }  
           break;  
   
         case sDenyGroups:                  case sDenyUsers:
           while ((cp = strtok(NULL, WHITESPACE)))                          while ((cp = strtok(NULL, WHITESPACE))) {
             {                                  if (options->num_deny_users >= MAX_DENY_USERS) {
               if (options->num_deny_groups >= MAX_DENY_GROUPS)                                          fprintf(stderr, "%s line %d: too many deny users.\n",
                 {                                                  filename, linenum);
                   fprintf(stderr, "%s line %d: too many deny groups.\n",                                          exit(1);
                           filename, linenum);                                  }
                   exit(1);                                  options->deny_users[options->num_deny_users++] = xstrdup(cp);
                 }                          }
               options->deny_groups[options->num_deny_groups++] = xstrdup(cp);                          break;
             }  
           break;  
   
         default:                  case sAllowGroups:
           fprintf(stderr, "%s line %d: Missing handler for opcode %s (%d)\n",                          while ((cp = strtok(NULL, WHITESPACE))) {
                   filename, linenum, cp, opcode);                                  if (options->num_allow_groups >= MAX_ALLOW_GROUPS) {
           exit(1);                                          fprintf(stderr, "%s line %d: too many allow groups.\n",
                                                   filename, linenum);
                                           exit(1);
                                   }
                                   options->allow_groups[options->num_allow_groups++] = xstrdup(cp);
                           }
                           break;
   
                   case sDenyGroups:
                           while ((cp = strtok(NULL, WHITESPACE))) {
                                   if (options->num_deny_groups >= MAX_DENY_GROUPS) {
                                           fprintf(stderr, "%s line %d: too many deny groups.\n",
                                                   filename, linenum);
                                           exit(1);
                                   }
                                   options->deny_groups[options->num_deny_groups++] = xstrdup(cp);
                           }
                           break;
   
                   default:
                           fprintf(stderr, "%s line %d: Missing handler for opcode %s (%d)\n",
                                   filename, linenum, cp, opcode);
                           exit(1);
                   }
                   if (strtok(NULL, WHITESPACE) != NULL) {
                           fprintf(stderr, "%s line %d: garbage at end of line.\n",
                                   filename, linenum);
                           exit(1);
                   }
         }          }
       if (strtok(NULL, WHITESPACE) != NULL)          fclose(f);
         {          if (bad_options > 0) {
           fprintf(stderr, "%s line %d: garbage at end of line.\n",                  fprintf(stderr, "%s: terminating, %d bad configuration options\n",
                   filename, linenum);                          filename, bad_options);
           exit(1);                  exit(1);
         }          }
     }  
   fclose(f);  
   if (bad_options > 0) {  
     fprintf(stderr, "%s: terminating, %d bad configuration options\n",  
             filename, bad_options);  
     exit(1);  
   }  
 }  }
Legend:
Removed from v.1.24  
changed lines
  Added in v.1.25