servconf.c

   1 /*
   2  * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
   3  *                    All rights reserved
   4  *
   5  * As far as I am concerned, the code I have written for this software
   6  * can be used freely for any purpose.  Any derived versions of this
   7  * software must be clearly marked as such, and if the derived work is
   8  * incompatible with the protocol description in the RFC file, it must be
   9  * called by a name other than "ssh" or "Secure Shell".
  10  */
  11
  12 #include "includes.h"
  13 RCSID("$OpenBSD: servconf.c,v 1.119 2003/05/15 01:48:10 jakob Exp $");
  14
  15 #if defined(KRB4)
  16 #include <krb.h>
  17 #endif
  18
  19 #if defined(KRB5)
  20 # ifdef HEIMDAL
  21 #  include <krb.h>
  22 # else
  23 /*
  24  * XXX: Bodge - but then, so is using the kerberos IV KEYFILE to get a
  25  * Kerberos V keytab
  26  */
  27 #  define KEYFILE "/etc/krb5.keytab"
  28 # endif
  29 #endif
  30
  31 #ifdef AFS
  32 #include <kafs.h>
  33 #endif
  34
  35 #include "ssh.h"
  36 #include "log.h"
  37 #include "servconf.h"
  38 #include "xmalloc.h"
  39 #include "compat.h"
  40 #include "pathnames.h"
  41 #include "tildexpand.h"
  42 #include "misc.h"
  43 #include "cipher.h"
  44 #include "kex.h"
  45 #include "mac.h"
  46
  47 static void add_listen_addr(ServerOptions *, char *, u_short);
  48 static void add_one_listen_addr(ServerOptions *, char *, u_short);
  49
  50 /* AF_UNSPEC or AF_INET or AF_INET6 */
  51 extern int IPv4or6;
  52 /* Use of privilege separation or not */
  53 extern int use_privsep;
  54
  55 /* Initializes the server options to their default values. */
  56
  57 void
  58 initialize_server_options(ServerOptions *options)
  59 {
  60         memset(options, 0, sizeof(*options));
  61
  62         /* Portable-specific options */
  63         options->use_pam = -1;
  64
  65         /* Standard Options */
  66         options->num_ports = 0;
  67         options->ports_from_cmdline = 0;
  68         options->listen_addrs = NULL;
  69         options->num_host_key_files = 0;
  70         options->pid_file = NULL;
  71         options->server_key_bits = -1;
  72         options->login_grace_time = -1;
  73         options->key_regeneration_time = -1;
  74         options->permit_root_login = PERMIT_NOT_SET;
  75         options->ignore_rhosts = -1;
  76         options->ignore_user_known_hosts = -1;
  77         options->print_motd = -1;
  78         options->print_lastlog = -1;
  79         options->x11_forwarding = -1;
  80         options->x11_display_offset = -1;
  81         options->x11_use_localhost = -1;
  82         options->xauth_location = NULL;
  83         options->strict_modes = -1;
  84         options->keepalives = -1;
  85         options->log_facility = SYSLOG_FACILITY_NOT_SET;
  86         options->log_level = SYSLOG_LEVEL_NOT_SET;
  87         options->rhosts_authentication = -1;
  88         options->rhosts_rsa_authentication = -1;
  89         options->hostbased_authentication = -1;
  90         options->hostbased_uses_name_from_packet_only = -1;
  91         options->rsa_authentication = -1;
  92         options->pubkey_authentication = -1;
  93         options->kerberos_authentication = -1;
  94         options->kerberos_or_local_passwd = -1;
  95         options->kerberos_ticket_cleanup = -1;
  96         options->kerberos_tgt_passing = -1;
  97         options->afs_token_passing = -1;
  98         options->password_authentication = -1;
  99         options->kbd_interactive_authentication = -1;
 100         options->challenge_response_authentication = -1;
 101         options->permit_empty_passwd = -1;
 102         options->permit_user_env = -1;
 103         options->use_login = -1;
 104         options->compression = -1;
 105         options->allow_tcp_forwarding = -1;
 106         options->num_allow_users = 0;
 107         options->num_deny_users = 0;
 108         options->num_allow_groups = 0;
 109         options->num_deny_groups = 0;
 110         options->ciphers = NULL;
 111         options->macs = NULL;
 112         options->protocol = SSH_PROTO_UNKNOWN;
 113         options->gateway_ports = -1;
 114         options->num_subsystems = 0;
 115         options->max_startups_begin = -1;
 116         options->max_startups_rate = -1;
 117         options->max_startups = -1;
 118         options->banner = NULL;
 119         options->verify_reverse_mapping = -1;
 120         options->client_alive_interval = -1;
 121         options->client_alive_count_max = -1;
 122         options->authorized_keys_file = NULL;
 123         options->authorized_keys_file2 = NULL;
 124
 125         /* Needs to be accessable in many places */
 126         use_privsep = -1;
 127 }
 128
 129 void
 130 fill_default_server_options(ServerOptions *options)
 131 {
 132         /* Portable-specific options */
 133         if (options->use_pam == -1)
 134                 options->use_pam = 0;
 135
 136         /* Standard Options */
 137         if (options->protocol == SSH_PROTO_UNKNOWN)
 138                 options->protocol = SSH_PROTO_1|SSH_PROTO_2;
 139         if (options->num_host_key_files == 0) {
 140                 /* fill default hostkeys for protocols */
 141                 if (options->protocol & SSH_PROTO_1)
 142                         options->host_key_files[options->num_host_key_files++] =
 143                             _PATH_HOST_KEY_FILE;
 144                 if (options->protocol & SSH_PROTO_2) {
 145                         options->host_key_files[options->num_host_key_files++] =
 146                             _PATH_HOST_RSA_KEY_FILE;
 147                         options->host_key_files[options->num_host_key_files++] =
 148                             _PATH_HOST_DSA_KEY_FILE;
 149                 }
 150         }
 151         if (options->num_ports == 0)
 152                 options->ports[options->num_ports++] = SSH_DEFAULT_PORT;
 153         if (options->listen_addrs == NULL)
 154                 add_listen_addr(options, NULL, 0);
 155         if (options->pid_file == NULL)
 156                 options->pid_file = _PATH_SSH_DAEMON_PID_FILE;
 157         if (options->server_key_bits == -1)
 158                 options->server_key_bits = 768;
 159         if (options->login_grace_time == -1)
 160                 options->login_grace_time = 120;
 161         if (options->key_regeneration_time == -1)
 162                 options->key_regeneration_time = 3600;
 163         if (options->permit_root_login == PERMIT_NOT_SET)
 164                 options->permit_root_login = PERMIT_YES;
 165         if (options->ignore_rhosts == -1)
 166                 options->ignore_rhosts = 1;
 167         if (options->ignore_user_known_hosts == -1)
 168                 options->ignore_user_known_hosts = 0;
 169         if (options->print_motd == -1)
 170                 options->print_motd = 1;
 171         if (options->print_lastlog == -1)
 172                 options->print_lastlog = 1;
 173         if (options->x11_forwarding == -1)
 174                 options->x11_forwarding = 0;
 175         if (options->x11_display_offset == -1)
 176                 options->x11_display_offset = 10;
 177         if (options->x11_use_localhost == -1)
 178                 options->x11_use_localhost = 1;
 179         if (options->xauth_location == NULL)
 180                 options->xauth_location = _PATH_XAUTH;
 181         if (options->strict_modes == -1)
 182                 options->strict_modes = 1;
 183         if (options->keepalives == -1)
 184                 options->keepalives = 1;
 185         if (options->log_facility == SYSLOG_FACILITY_NOT_SET)
 186                 options->log_facility = SYSLOG_FACILITY_AUTH;
 187         if (options->log_level == SYSLOG_LEVEL_NOT_SET)
 188                 options->log_level = SYSLOG_LEVEL_INFO;
 189         if (options->rhosts_authentication == -1)
 190                 options->rhosts_authentication = 0;
 191         if (options->rhosts_rsa_authentication == -1)
 192                 options->rhosts_rsa_authentication = 0;
 193         if (options->hostbased_authentication == -1)
 194                 options->hostbased_authentication = 0;
 195         if (options->hostbased_uses_name_from_packet_only == -1)
 196                 options->hostbased_uses_name_from_packet_only = 0;
 197         if (options->rsa_authentication == -1)
 198                 options->rsa_authentication = 1;
 199         if (options->pubkey_authentication == -1)
 200                 options->pubkey_authentication = 1;
 201         if (options->kerberos_authentication == -1)
 202                 options->kerberos_authentication = 0;
 203         if (options->kerberos_or_local_passwd == -1)
 204                 options->kerberos_or_local_passwd = 1;
 205         if (options->kerberos_ticket_cleanup == -1)
 206                 options->kerberos_ticket_cleanup = 1;
 207         if (options->kerberos_tgt_passing == -1)
 208                 options->kerberos_tgt_passing = 0;
 209         if (options->afs_token_passing == -1)
 210                 options->afs_token_passing = 0;
 211         if (options->password_authentication == -1)
 212                 options->password_authentication = 1;
 213         if (options->kbd_interactive_authentication == -1)
 214                 options->kbd_interactive_authentication = 0;
 215         if (options->challenge_response_authentication == -1)
 216                 options->challenge_response_authentication = 1;
 217         if (options->permit_empty_passwd == -1)
 218                 options->permit_empty_passwd = 0;
 219         if (options->permit_user_env == -1)
 220                 options->permit_user_env = 0;
 221         if (options->use_login == -1)
 222                 options->use_login = 0;
 223         if (options->compression == -1)
 224                 options->compression = 1;
 225         if (options->allow_tcp_forwarding == -1)
 226                 options->allow_tcp_forwarding = 1;
 227         if (options->gateway_ports == -1)
 228                 options->gateway_ports = 0;
 229         if (options->max_startups == -1)
 230                 options->max_startups = 10;
 231         if (options->max_startups_rate == -1)
 232                 options->max_startups_rate = 100;               /* 100% */
 233         if (options->max_startups_begin == -1)
 234                 options->max_startups_begin = options->max_startups;
 235         if (options->verify_reverse_mapping == -1)
 236                 options->verify_reverse_mapping = 0;
 237         if (options->client_alive_interval == -1)
 238                 options->client_alive_interval = 0;
 239         if (options->client_alive_count_max == -1)
 240                 options->client_alive_count_max = 3;
 241         if (options->authorized_keys_file2 == NULL) {
 242                 /* authorized_keys_file2 falls back to authorized_keys_file */
 243                 if (options->authorized_keys_file != NULL)
 244                         options->authorized_keys_file2 = options->authorized_keys_file;
 245                 else
 246                         options->authorized_keys_file2 = _PATH_SSH_USER_PERMITTED_KEYS2;
 247         }
 248         if (options->authorized_keys_file == NULL)
 249                 options->authorized_keys_file = _PATH_SSH_USER_PERMITTED_KEYS;
 250
 251         /* Turn privilege separation on by default */
 252         if (use_privsep == -1)
 253                 use_privsep = 1;
 254
 255 #ifndef HAVE_MMAP
 256         if (use_privsep && options->compression == 1) {
 257                 error("This platform does not support both privilege "
 258                     "separation and compression");
 259                 error("Compression disabled");
 260                 options->compression = 0;
 261         }
 262 #endif
 263
 264 }
 265
 266 /* Keyword tokens. */
 267 typedef enum {
 268         sBadOption,             /* == unknown option */
 269         /* Portable-specific options */
 270         sUsePAM,
 271         /* Standard Options */
 272         sPort, sHostKeyFile, sServerKeyBits, sLoginGraceTime, sKeyRegenerationTime,
 273         sPermitRootLogin, sLogFacility, sLogLevel,
 274         sRhostsAuthentication, sRhostsRSAAuthentication, sRSAAuthentication,
 275         sKerberosAuthentication, sKerberosOrLocalPasswd, sKerberosTicketCleanup,
 276         sKerberosTgtPassing, sAFSTokenPassing, sChallengeResponseAuthentication,
 277         sPasswordAuthentication, sKbdInteractiveAuthentication, sListenAddress,
 278         sPrintMotd, sPrintLastLog, sIgnoreRhosts,
 279         sX11Forwarding, sX11DisplayOffset, sX11UseLocalhost,
 280         sStrictModes, sEmptyPasswd, sKeepAlives,
 281         sPermitUserEnvironment, sUseLogin, sAllowTcpForwarding, sCompression,
 282         sAllowUsers, sDenyUsers, sAllowGroups, sDenyGroups,
 283         sIgnoreUserKnownHosts, sCiphers, sMacs, sProtocol, sPidFile,
 284         sGatewayPorts, sPubkeyAuthentication, sXAuthLocation, sSubsystem, sMaxStartups,
 285         sBanner, sVerifyReverseMapping, sHostbasedAuthentication,
 286         sHostbasedUsesNameFromPacketOnly, sClientAliveInterval,
 287         sClientAliveCountMax, sAuthorizedKeysFile, sAuthorizedKeysFile2,
 288         sUsePrivilegeSeparation,
 289         sDeprecated
 290 } ServerOpCodes;
 291
 292 /* Textual representation of the tokens. */
 293 static struct {
 294         const char *name;
 295         ServerOpCodes opcode;
 296 } keywords[] = {
 297         /* Portable-specific options */
 298         { "UsePAM", sUsePAM },
 299         /* Standard Options */
 300         { "port", sPort },
 301         { "hostkey", sHostKeyFile },
 302         { "hostdsakey", sHostKeyFile },                                 /* alias */
 303         { "pidfile", sPidFile },
 304         { "serverkeybits", sServerKeyBits },
 305         { "logingracetime", sLoginGraceTime },
 306         { "keyregenerationinterval", sKeyRegenerationTime },
 307         { "permitrootlogin", sPermitRootLogin },
 308         { "syslogfacility", sLogFacility },
 309         { "loglevel", sLogLevel },
 310         { "rhostsauthentication", sRhostsAuthentication },
 311         { "rhostsrsaauthentication", sRhostsRSAAuthentication },
 312         { "hostbasedauthentication", sHostbasedAuthentication },
 313         { "hostbasedusesnamefrompacketonly", sHostbasedUsesNameFromPacketOnly },
 314         { "rsaauthentication", sRSAAuthentication },
 315         { "pubkeyauthentication", sPubkeyAuthentication },
 316         { "dsaauthentication", sPubkeyAuthentication },                 /* alias */
 317         { "kerberosauthentication", sKerberosAuthentication },
 318         { "kerberosorlocalpasswd", sKerberosOrLocalPasswd },
 319         { "kerberosticketcleanup", sKerberosTicketCleanup },
 320         { "kerberostgtpassing", sKerberosTgtPassing },
 321         { "afstokenpassing", sAFSTokenPassing },
 322         { "passwordauthentication", sPasswordAuthentication },
 323         { "kbdinteractiveauthentication", sKbdInteractiveAuthentication },
 324         { "challengeresponseauthentication", sChallengeResponseAuthentication },
 325         { "skeyauthentication", sChallengeResponseAuthentication }, /* alias */
 326         { "checkmail", sDeprecated },
 327         { "listenaddress", sListenAddress },
 328         { "printmotd", sPrintMotd },
 329         { "printlastlog", sPrintLastLog },
 330         { "ignorerhosts", sIgnoreRhosts },
 331         { "ignoreuserknownhosts", sIgnoreUserKnownHosts },
 332         { "x11forwarding", sX11Forwarding },
 333         { "x11displayoffset", sX11DisplayOffset },
 334         { "x11uselocalhost", sX11UseLocalhost },
 335         { "xauthlocation", sXAuthLocation },
 336         { "strictmodes", sStrictModes },
 337         { "permitemptypasswords", sEmptyPasswd },
 338         { "permituserenvironment", sPermitUserEnvironment },
 339         { "uselogin", sUseLogin },
 340         { "compression", sCompression },
 341         { "keepalive", sKeepAlives },
 342         { "allowtcpforwarding", sAllowTcpForwarding },
 343         { "allowusers", sAllowUsers },
 344         { "denyusers", sDenyUsers },
 345         { "allowgroups", sAllowGroups },
 346         { "denygroups", sDenyGroups },
 347         { "ciphers", sCiphers },
 348         { "macs", sMacs },
 349         { "protocol", sProtocol },
 350         { "gatewayports", sGatewayPorts },
 351         { "subsystem", sSubsystem },
 352         { "maxstartups", sMaxStartups },
 353         { "banner", sBanner },
 354         { "verifyreversemapping", sVerifyReverseMapping },
 355         { "reversemappingcheck", sVerifyReverseMapping },
 356         { "clientaliveinterval", sClientAliveInterval },
 357         { "clientalivecountmax", sClientAliveCountMax },
 358         { "authorizedkeysfile", sAuthorizedKeysFile },
 359         { "authorizedkeysfile2", sAuthorizedKeysFile2 },
 360         { "useprivilegeseparation", sUsePrivilegeSeparation},
 361         { NULL, sBadOption }
 362 };
 363
 364 /*
 365  * Returns the number of the token pointed to by cp or sBadOption.
 366  */
 367
 368 static ServerOpCodes
 369 parse_token(const char *cp, const char *filename,
 370             int linenum)
 371 {
 372         u_int i;
 373
 374         for (i = 0; keywords[i].name; i++)
 375                 if (strcasecmp(cp, keywords[i].name) == 0)
 376                         return keywords[i].opcode;
 377
 378         error("%s: line %d: Bad configuration option: %s",
 379             filename, linenum, cp);
 380         return sBadOption;
 381 }
 382
 383 static void
 384 add_listen_addr(ServerOptions *options, char *addr, u_short port)
 385 {
 386         int i;
 387
 388         if (options->num_ports == 0)
 389                 options->ports[options->num_ports++] = SSH_DEFAULT_PORT;
 390         if (port == 0)
 391                 for (i = 0; i < options->num_ports; i++)
 392                         add_one_listen_addr(options, addr, options->ports[i]);
 393         else
 394                 add_one_listen_addr(options, addr, port);
 395 }
 396
 397 static void
 398 add_one_listen_addr(ServerOptions *options, char *addr, u_short port)
 399 {
 400         struct addrinfo hints, *ai, *aitop;
 401         char strport[NI_MAXSERV];
 402         int gaierr;
 403
 404         memset(&hints, 0, sizeof(hints));
 405         hints.ai_family = IPv4or6;
 406         hints.ai_socktype = SOCK_STREAM;
 407         hints.ai_flags = (addr == NULL) ? AI_PASSIVE : 0;
 408         snprintf(strport, sizeof strport, "%u", port);
 409         if ((gaierr = getaddrinfo(addr, strport, &hints, &aitop)) != 0)
 410                 fatal("bad addr or host: %s (%s)",
 411                     addr ? addr : "<NULL>",
 412                     gai_strerror(gaierr));
 413         for (ai = aitop; ai->ai_next; ai = ai->ai_next)
 414                 ;
 415         ai->ai_next = options->listen_addrs;
 416         options->listen_addrs = aitop;
 417 }
 418
 419 int
 420 process_server_config_line(ServerOptions *options, char *line,
 421     const char *filename, int linenum)
 422 {
 423         char *cp, **charptr, *arg, *p;
 424         int *intptr, value, i, n;
 425         ServerOpCodes opcode;
 426
 427         cp = line;
 428         arg = strdelim(&cp);
 429         /* Ignore leading whitespace */
 430         if (*arg == '\0')
 431                 arg = strdelim(&cp);
 432         if (!arg || !*arg || *arg == '#')
 433                 return 0;
 434         intptr = NULL;
 435         charptr = NULL;
 436         opcode = parse_token(arg, filename, linenum);
 437         switch (opcode) {
 438         /* Portable-specific options */
 439         case sUsePAM:
 440                 intptr = &options->use_pam;
 441                 goto parse_flag;
 442
 443         /* Standard Options */
 444         case sBadOption:
 445                 return -1;
 446         case sPort:
 447                 /* ignore ports from configfile if cmdline specifies ports */
 448                 if (options->ports_from_cmdline)
 449                         return 0;
 450                 if (options->listen_addrs != NULL)
 451                         fatal("%s line %d: ports must be specified before "
 452                             "ListenAddress.", filename, linenum);
 453                 if (options->num_ports >= MAX_PORTS)
 454                         fatal("%s line %d: too many ports.",
 455                             filename, linenum);
 456                 arg = strdelim(&cp);
 457                 if (!arg || *arg == '\0')
 458                         fatal("%s line %d: missing port number.",
 459                             filename, linenum);
 460                 options->ports[options->num_ports++] = a2port(arg);
 461                 if (options->ports[options->num_ports-1] == 0)
 462                         fatal("%s line %d: Badly formatted port number.",
 463                             filename, linenum);
 464                 break;
 465
 466         case sServerKeyBits:
 467                 intptr = &options->server_key_bits;
 468 parse_int:
 469                 arg = strdelim(&cp);
 470                 if (!arg || *arg == '\0')
 471                         fatal("%s line %d: missing integer value.",
 472                             filename, linenum);
 473                 value = atoi(arg);
 474                 if (*intptr == -1)
 475                         *intptr = value;
 476                 break;
 477
 478         case sLoginGraceTime:
 479                 intptr = &options->login_grace_time;
 480 parse_time:
 481                 arg = strdelim(&cp);
 482                 if (!arg || *arg == '\0')
 483                         fatal("%s line %d: missing time value.",
 484                             filename, linenum);
 485                 if ((value = convtime(arg)) == -1)
 486                         fatal("%s line %d: invalid time value.",
 487                             filename, linenum);
 488                 if (*intptr == -1)
 489                         *intptr = value;
 490                 break;
 491
 492         case sKeyRegenerationTime:
 493                 intptr = &options->key_regeneration_time;
 494                 goto parse_time;
 495
 496         case sListenAddress:
 497                 arg = strdelim(&cp);
 498                 if (!arg || *arg == '\0' || strncmp(arg, "[]", 2) == 0)
 499                         fatal("%s line %d: missing inet addr.",
 500                             filename, linenum);
 501                 if (*arg == '[') {
 502                         if ((p = strchr(arg, ']')) == NULL)
 503                                 fatal("%s line %d: bad ipv6 inet addr usage.",
 504                                     filename, linenum);
 505                         arg++;
 506                         memmove(p, p+1, strlen(p+1)+1);
 507                 } else if (((p = strchr(arg, ':')) == NULL) ||
 508                             (strchr(p+1, ':') != NULL)) {
 509                         add_listen_addr(options, arg, 0);
 510                         break;
 511                 }
 512                 if (*p == ':') {
 513                         u_short port;
 514
 515                         p++;
 516                         if (*p == '\0')
 517                                 fatal("%s line %d: bad inet addr:port usage.",
 518                                     filename, linenum);
 519                         else {
 520                                 *(p-1) = '\0';
 521                                 if ((port = a2port(p)) == 0)
 522                                         fatal("%s line %d: bad port number.",
 523                                             filename, linenum);
 524                                 add_listen_addr(options, arg, port);
 525                         }
 526                 } else if (*p == '\0')
 527                         add_listen_addr(options, arg, 0);
 528                 else
 529                         fatal("%s line %d: bad inet addr usage.",
 530                             filename, linenum);
 531                 break;
 532
 533         case sHostKeyFile:
 534                 intptr = &options->num_host_key_files;
 535                 if (*intptr >= MAX_HOSTKEYS)
 536                         fatal("%s line %d: too many host keys specified (max %d).",
 537                             filename, linenum, MAX_HOSTKEYS);
 538                 charptr = &options->host_key_files[*intptr];
 539 parse_filename:
 540                 arg = strdelim(&cp);
 541                 if (!arg || *arg == '\0')
 542                         fatal("%s line %d: missing file name.",
 543                             filename, linenum);
 544                 if (*charptr == NULL) {
 545                         *charptr = tilde_expand_filename(arg, getuid());
 546                         /* increase optional counter */
 547                         if (intptr != NULL)
 548                                 *intptr = *intptr + 1;
 549                 }
 550                 break;
 551
 552         case sPidFile:
 553                 charptr = &options->pid_file;
 554                 goto parse_filename;
 555
 556         case sPermitRootLogin:
 557                 intptr = &options->permit_root_login;
 558                 arg = strdelim(&cp);
 559                 if (!arg || *arg == '\0')
 560                         fatal("%s line %d: missing yes/"
 561                             "without-password/forced-commands-only/no "
 562                             "argument.", filename, linenum);
 563                 value = 0;      /* silence compiler */
 564                 if (strcmp(arg, "without-password") == 0)
 565                         value = PERMIT_NO_PASSWD;
 566                 else if (strcmp(arg, "forced-commands-only") == 0)
 567                         value = PERMIT_FORCED_ONLY;
 568                 else if (strcmp(arg, "yes") == 0)
 569                         value = PERMIT_YES;
 570                 else if (strcmp(arg, "no") == 0)
 571                         value = PERMIT_NO;
 572                 else
 573                         fatal("%s line %d: Bad yes/"
 574                             "without-password/forced-commands-only/no "
 575                             "argument: %s", filename, linenum, arg);
 576                 if (*intptr == -1)
 577                         *intptr = value;
 578                 break;
 579
 580         case sIgnoreRhosts:
 581                 intptr = &options->ignore_rhosts;
 582 parse_flag:
 583                 arg = strdelim(&cp);
 584                 if (!arg || *arg == '\0')
 585                         fatal("%s line %d: missing yes/no argument.",
 586                             filename, linenum);
 587                 value = 0;      /* silence compiler */
 588                 if (strcmp(arg, "yes") == 0)
 589                         value = 1;
 590                 else if (strcmp(arg, "no") == 0)
 591                         value = 0;
 592                 else
 593                         fatal("%s line %d: Bad yes/no argument: %s",
 594                                 filename, linenum, arg);
 595                 if (*intptr == -1)
 596                         *intptr = value;
 597                 break;
 598
 599         case sIgnoreUserKnownHosts:
 600                 intptr = &options->ignore_user_known_hosts;
 601                 goto parse_flag;
 602
 603         case sRhostsAuthentication:
 604                 intptr = &options->rhosts_authentication;
 605                 goto parse_flag;
 606
 607         case sRhostsRSAAuthentication:
 608                 intptr = &options->rhosts_rsa_authentication;
 609                 goto parse_flag;
 610
 611         case sHostbasedAuthentication:
 612                 intptr = &options->hostbased_authentication;
 613                 goto parse_flag;
 614
 615         case sHostbasedUsesNameFromPacketOnly:
 616                 intptr = &options->hostbased_uses_name_from_packet_only;
 617                 goto parse_flag;
 618
 619         case sRSAAuthentication:
 620                 intptr = &options->rsa_authentication;
 621                 goto parse_flag;
 622
 623         case sPubkeyAuthentication:
 624                 intptr = &options->pubkey_authentication;
 625                 goto parse_flag;
 626
 627         case sKerberosAuthentication:
 628                 intptr = &options->kerberos_authentication;
 629                 goto parse_flag;
 630
 631         case sKerberosOrLocalPasswd:
 632                 intptr = &options->kerberos_or_local_passwd;
 633                 goto parse_flag;
 634
 635         case sKerberosTicketCleanup:
 636                 intptr = &options->kerberos_ticket_cleanup;
 637                 goto parse_flag;
 638
 639         case sKerberosTgtPassing:
 640                 intptr = &options->kerberos_tgt_passing;
 641                 goto parse_flag;
 642
 643         case sAFSTokenPassing:
 644                 intptr = &options->afs_token_passing;
 645                 goto parse_flag;
 646
 647         case sPasswordAuthentication:
 648                 intptr = &options->password_authentication;
 649                 goto parse_flag;
 650
 651         case sKbdInteractiveAuthentication:
 652                 intptr = &options->kbd_interactive_authentication;
 653                 goto parse_flag;
 654
 655         case sChallengeResponseAuthentication:
 656                 intptr = &options->challenge_response_authentication;
 657                 goto parse_flag;
 658
 659         case sPrintMotd:
 660                 intptr = &options->print_motd;
 661                 goto parse_flag;
 662
 663         case sPrintLastLog:
 664                 intptr = &options->print_lastlog;
 665                 goto parse_flag;
 666
 667         case sX11Forwarding:
 668                 intptr = &options->x11_forwarding;
 669                 goto parse_flag;
 670
 671         case sX11DisplayOffset:
 672                 intptr = &options->x11_display_offset;
 673                 goto parse_int;
 674
 675         case sX11UseLocalhost:
 676                 intptr = &options->x11_use_localhost;
 677                 goto parse_flag;
 678
 679         case sXAuthLocation:
 680                 charptr = &options->xauth_location;
 681                 goto parse_filename;
 682
 683         case sStrictModes:
 684                 intptr = &options->strict_modes;
 685                 goto parse_flag;
 686
 687         case sKeepAlives:
 688                 intptr = &options->keepalives;
 689                 goto parse_flag;
 690
 691         case sEmptyPasswd:
 692                 intptr = &options->permit_empty_passwd;
 693                 goto parse_flag;
 694
 695         case sPermitUserEnvironment:
 696                 intptr = &options->permit_user_env;
 697                 goto parse_flag;
 698
 699         case sUseLogin:
 700                 intptr = &options->use_login;
 701                 goto parse_flag;
 702
 703         case sCompression:
 704                 intptr = &options->compression;
 705                 goto parse_flag;
 706
 707         case sGatewayPorts:
 708                 intptr = &options->gateway_ports;
 709                 goto parse_flag;
 710
 711         case sVerifyReverseMapping:
 712                 intptr = &options->verify_reverse_mapping;
 713                 goto parse_flag;
 714
 715         case sLogFacility:
 716                 intptr = (int *) &options->log_facility;
 717                 arg = strdelim(&cp);
 718                 value = log_facility_number(arg);
 719                 if (value == SYSLOG_FACILITY_NOT_SET)
 720                         fatal("%.200s line %d: unsupported log facility '%s'",
 721                             filename, linenum, arg ? arg : "<NONE>");
 722                 if (*intptr == -1)
 723                         *intptr = (SyslogFacility) value;
 724                 break;
 725
 726         case sLogLevel:
 727                 intptr = (int *) &options->log_level;
 728                 arg = strdelim(&cp);
 729                 value = log_level_number(arg);
 730                 if (value == SYSLOG_LEVEL_NOT_SET)
 731                         fatal("%.200s line %d: unsupported log level '%s'",
 732                             filename, linenum, arg ? arg : "<NONE>");
 733                 if (*intptr == -1)
 734                         *intptr = (LogLevel) value;
 735                 break;
 736
 737         case sAllowTcpForwarding:
 738                 intptr = &options->allow_tcp_forwarding;
 739                 goto parse_flag;
 740
 741         case sUsePrivilegeSeparation:
 742                 intptr = &use_privsep;
 743                 goto parse_flag;
 744
 745         case sAllowUsers:
 746                 while ((arg = strdelim(&cp)) && *arg != '\0') {
 747                         if (options->num_allow_users >= MAX_ALLOW_USERS)
 748                                 fatal("%s line %d: too many allow users.",
 749                                     filename, linenum);
 750                         options->allow_users[options->num_allow_users++] =
 751                             xstrdup(arg);
 752                 }
 753                 break;
 754
 755         case sDenyUsers:
 756                 while ((arg = strdelim(&cp)) && *arg != '\0') {
 757                         if (options->num_deny_users >= MAX_DENY_USERS)
 758                                 fatal( "%s line %d: too many deny users.",
 759                                     filename, linenum);
 760                         options->deny_users[options->num_deny_users++] =
 761                             xstrdup(arg);
 762                 }
 763                 break;
 764
 765         case sAllowGroups:
 766                 while ((arg = strdelim(&cp)) && *arg != '\0') {
 767                         if (options->num_allow_groups >= MAX_ALLOW_GROUPS)
 768                                 fatal("%s line %d: too many allow groups.",
 769                                     filename, linenum);
 770                         options->allow_groups[options->num_allow_groups++] =
 771                             xstrdup(arg);
 772                 }
 773                 break;
 774
 775         case sDenyGroups:
 776                 while ((arg = strdelim(&cp)) && *arg != '\0') {
 777                         if (options->num_deny_groups >= MAX_DENY_GROUPS)
 778                                 fatal("%s line %d: too many deny groups.",
 779                                     filename, linenum);
 780                         options->deny_groups[options->num_deny_groups++] = xstrdup(arg);
 781                 }
 782                 break;
 783
 784         case sCiphers:
 785                 arg = strdelim(&cp);
 786                 if (!arg || *arg == '\0')
 787                         fatal("%s line %d: Missing argument.", filename, linenum);
 788                 if (!ciphers_valid(arg))
 789                         fatal("%s line %d: Bad SSH2 cipher spec '%s'.",
 790                             filename, linenum, arg ? arg : "<NONE>");
 791                 if (options->ciphers == NULL)
 792                         options->ciphers = xstrdup(arg);
 793                 break;
 794
 795         case sMacs:
 796                 arg = strdelim(&cp);
 797                 if (!arg || *arg == '\0')
 798                         fatal("%s line %d: Missing argument.", filename, linenum);
 799                 if (!mac_valid(arg))
 800                         fatal("%s line %d: Bad SSH2 mac spec '%s'.",
 801                             filename, linenum, arg ? arg : "<NONE>");
 802                 if (options->macs == NULL)
 803                         options->macs = xstrdup(arg);
 804                 break;
 805
 806         case sProtocol:
 807                 intptr = &options->protocol;
 808                 arg = strdelim(&cp);
 809                 if (!arg || *arg == '\0')
 810                         fatal("%s line %d: Missing argument.", filename, linenum);
 811                 value = proto_spec(arg);
 812                 if (value == SSH_PROTO_UNKNOWN)
 813                         fatal("%s line %d: Bad protocol spec '%s'.",
 814                             filename, linenum, arg ? arg : "<NONE>");
 815                 if (*intptr == SSH_PROTO_UNKNOWN)
 816                         *intptr = value;
 817                 break;
 818
 819         case sSubsystem:
 820                 if (options->num_subsystems >= MAX_SUBSYSTEMS) {
 821                         fatal("%s line %d: too many subsystems defined.",
 822                             filename, linenum);
 823                 }
 824                 arg = strdelim(&cp);
 825                 if (!arg || *arg == '\0')
 826                         fatal("%s line %d: Missing subsystem name.",
 827                             filename, linenum);
 828                 for (i = 0; i < options->num_subsystems; i++)
 829                         if (strcmp(arg, options->subsystem_name[i]) == 0)
 830                                 fatal("%s line %d: Subsystem '%s' already defined.",
 831                                     filename, linenum, arg);
 832                 options->subsystem_name[options->num_subsystems] = xstrdup(arg);
 833                 arg = strdelim(&cp);
 834                 if (!arg || *arg == '\0')
 835                         fatal("%s line %d: Missing subsystem command.",
 836                             filename, linenum);
 837                 options->subsystem_command[options->num_subsystems] = xstrdup(arg);
 838                 options->num_subsystems++;
 839                 break;
 840
 841         case sMaxStartups:
 842                 arg = strdelim(&cp);
 843                 if (!arg || *arg == '\0')
 844                         fatal("%s line %d: Missing MaxStartups spec.",
 845                             filename, linenum);
 846                 if ((n = sscanf(arg, "%d:%d:%d",
 847                     &options->max_startups_begin,
 848                     &options->max_startups_rate,
 849                     &options->max_startups)) == 3) {
 850                         if (options->max_startups_begin >
 851                             options->max_startups ||
 852                             options->max_startups_rate > 100 ||
 853                             options->max_startups_rate < 1)
 854                                 fatal("%s line %d: Illegal MaxStartups spec.",
 855                                     filename, linenum);
 856                 } else if (n != 1)
 857                         fatal("%s line %d: Illegal MaxStartups spec.",
 858                             filename, linenum);
 859                 else
 860                         options->max_startups = options->max_startups_begin;
 861                 break;
 862
 863         case sBanner:
 864                 charptr = &options->banner;
 865                 goto parse_filename;
 866         /*
 867          * These options can contain %X options expanded at
 868          * connect time, so that you can specify paths like:
 869          *
 870          * AuthorizedKeysFile   /etc/ssh_keys/%u
 871          */
 872         case sAuthorizedKeysFile:
 873         case sAuthorizedKeysFile2:
 874                 charptr = (opcode == sAuthorizedKeysFile ) ?
 875                     &options->authorized_keys_file :
 876                     &options->authorized_keys_file2;
 877                 goto parse_filename;
 878
 879         case sClientAliveInterval:
 880                 intptr = &options->client_alive_interval;
 881                 goto parse_time;
 882
 883         case sClientAliveCountMax:
 884                 intptr = &options->client_alive_count_max;
 885                 goto parse_int;
 886
 887         case sDeprecated:
 888                 logit("%s line %d: Deprecated option %s",
 889                     filename, linenum, arg);
 890                 while (arg)
 891                     arg = strdelim(&cp);
 892                 break;
 893
 894         default:
 895                 fatal("%s line %d: Missing handler for opcode %s (%d)",
 896                     filename, linenum, arg, opcode);
 897         }
 898         if ((arg = strdelim(&cp)) != NULL && *arg != '\0')
 899                 fatal("%s line %d: garbage at end of line; \"%.200s\".",
 900                     filename, linenum, arg);
 901         return 0;
 902 }
 903
 904 /* Reads the server configuration file. */
 905
 906 void
 907 read_server_config(ServerOptions *options, const char *filename)
 908 {
 909         int linenum, bad_options = 0;
 910         char line[1024];
 911         FILE *f;
 912
 913         debug2("read_server_config: filename %s", filename);
 914         f = fopen(filename, "r");
 915         if (!f) {
 916                 perror(filename);
 917                 exit(1);
 918         }
 919         linenum = 0;
 920         while (fgets(line, sizeof(line), f)) {
 921                 /* Update line number counter. */
 922                 linenum++;
 923                 if (process_server_config_line(options, line, filename, linenum) != 0)
 924                         bad_options++;
 925         }
 926         fclose(f);
 927         if (bad_options > 0)
 928                 fatal("%s: terminating, %d bad configuration options",
 929                     filename, bad_options);
 930 }