1 /* $OpenBSD: readconf.c,v 1.220 2014/07/15 15:54:14 millert Exp $ */ 2 /* 3 * Author: Tatu Ylonen <ylo@cs.hut.fi> 4 * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland 5 * All rights reserved 6 * Functions for reading the configuration files. 7 * 8 * As far as I am concerned, the code I have written for this software 9 * can be used freely for any purpose. Any derived versions of this 10 * software must be clearly marked as such, and if the derived work is 11 * incompatible with the protocol description in the RFC file, it must be 12 * called by a name other than "ssh" or "Secure Shell". 13 */ 14 15 #include "includes.h" 16 17 #include <sys/types.h> 18 #include <sys/stat.h> 19 #include <sys/socket.h> 20 #include <sys/wait.h> 21 #include <sys/un.h> 22 23 #include <netinet/in.h> 24 #include <netinet/in_systm.h> 25 #include <netinet/ip.h> 26 #include <arpa/inet.h> 27 28 #include <ctype.h> 29 #include <errno.h> 30 #include <fcntl.h> 31 #include <netdb.h> 32 #ifdef HAVE_PATHS_H 33 # include <paths.h> 34 #endif 35 #include <pwd.h> 36 #include <signal.h> 37 #include <stdarg.h> 38 #include <stdio.h> 39 #include <string.h> 40 #include <unistd.h> 41 #ifdef HAVE_UTIL_H 42 #include <util.h> 43 #endif 44 45 #include "xmalloc.h" 46 #include "ssh.h" 47 #include "compat.h" 48 #include "cipher.h" 49 #include "pathnames.h" 50 #include "log.h" 51 #include "key.h" 52 #include "misc.h" 53 #include "readconf.h" 54 #include "match.h" 55 #include "buffer.h" 56 #include "kex.h" 57 #include "mac.h" 58 #include "uidswap.h" 59 #include "version.h" 60 61 /* Format of the configuration file: 62 63 # Configuration data is parsed as follows: 64 # 1. command line options 65 # 2. user-specific file 66 # 3. system-wide file 67 # Any configuration value is only changed the first time it is set. 68 # Thus, host-specific definitions should be at the beginning of the 69 # configuration file, and defaults at the end. 70 71 # Host-specific declarations. These may override anything above. A single 72 # host may match multiple declarations; these are processed in the order 73 # that they are given in. 74 75 Host *.ngs.fi ngs.fi 76 User foo 77 78 Host fake.com 79 HostName another.host.name.real.org 80 User blaah 81 Port 34289 82 ForwardX11 no 83 ForwardAgent no 84 85 Host books.com 86 RemoteForward 9999 shadows.cs.hut.fi:9999 87 Cipher 3des 88 89 Host fascist.blob.com 90 Port 23123 91 User tylonen 92 PasswordAuthentication no 93 94 Host puukko.hut.fi 95 User t35124p 96 ProxyCommand ssh-proxy %h %p 97 98 Host *.fr 99 PublicKeyAuthentication no 100 101 Host *.su 102 Cipher none 103 PasswordAuthentication no 104 105 Host vpn.fake.com 106 Tunnel yes 107 TunnelDevice 3 108 109 # Defaults for various options 110 Host * 111 ForwardAgent no 112 ForwardX11 no 113 PasswordAuthentication yes 114 RSAAuthentication yes 115 RhostsRSAAuthentication yes 116 StrictHostKeyChecking yes 117 TcpKeepAlive no 118 IdentityFile ~/.ssh/identity 119 Port 22 120 EscapeChar ~ 121 122 */ 123 124 /* Keyword tokens. */ 125 126 typedef enum { 127 oBadOption, 128 oHost, oMatch, 129 oForwardAgent, oForwardX11, oForwardX11Trusted, oForwardX11Timeout, 130 oGatewayPorts, oExitOnForwardFailure, 131 oPasswordAuthentication, oRSAAuthentication, 132 oChallengeResponseAuthentication, oXAuthLocation, 133 oIdentityFile, oHostName, oPort, oCipher, oRemoteForward, oLocalForward, 134 oUser, oEscapeChar, oRhostsRSAAuthentication, oProxyCommand, 135 oGlobalKnownHostsFile, oUserKnownHostsFile, oConnectionAttempts, 136 oBatchMode, oCheckHostIP, oStrictHostKeyChecking, oCompression, 137 oCompressionLevel, oTCPKeepAlive, oNumberOfPasswordPrompts, 138 oUsePrivilegedPort, oLogLevel, oCiphers, oProtocol, oMacs, 139 oGlobalKnownHostsFile2, oUserKnownHostsFile2, oPubkeyAuthentication, 140 oKbdInteractiveAuthentication, oKbdInteractiveDevices, oHostKeyAlias, 141 oDynamicForward, oPreferredAuthentications, oHostbasedAuthentication, 142 oHostKeyAlgorithms, oBindAddress, oPKCS11Provider, 143 oClearAllForwardings, oNoHostAuthenticationForLocalhost, 144 oEnableSSHKeysign, oRekeyLimit, oVerifyHostKeyDNS, oConnectTimeout, 145 oAddressFamily, oGssAuthentication, oGssDelegateCreds, 146 oServerAliveInterval, oServerAliveCountMax, oIdentitiesOnly, 147 oVersionAddendum, 148 oSendEnv, oControlPath, oControlMaster, oControlPersist, 149 oHashKnownHosts, 150 oTunnel, oTunnelDevice, oLocalCommand, oPermitLocalCommand, 151 oTcpRcvBufPoll, oTcpRcvBuf, oHPNDisabled, oHPNBufferSize, 152 oNoneEnabled, oNoneSwitch, 153 oVisualHostKey, oUseRoaming, 154 oKexAlgorithms, oIPQoS, oRequestTTY, oIgnoreUnknown, oProxyUseFdpass, 155 oCanonicalDomains, oCanonicalizeHostname, oCanonicalizeMaxDots, 156 oCanonicalizeFallbackLocal, oCanonicalizePermittedCNAMEs, 157 oStreamLocalBindMask, oStreamLocalBindUnlink, 158 oIgnoredUnknownOption, oDeprecated, oUnsupported 159 } OpCodes; 160 161 /* Textual representations of the tokens. */ 162 163 static struct { 164 const char *name; 165 OpCodes opcode; 166 } keywords[] = { 167 { "forwardagent", oForwardAgent }, 168 { "forwardx11", oForwardX11 }, 169 { "forwardx11trusted", oForwardX11Trusted }, 170 { "forwardx11timeout", oForwardX11Timeout }, 171 { "exitonforwardfailure", oExitOnForwardFailure }, 172 { "xauthlocation", oXAuthLocation }, 173 { "gatewayports", oGatewayPorts }, 174 { "useprivilegedport", oUsePrivilegedPort }, 175 { "rhostsauthentication", oDeprecated }, 176 { "passwordauthentication", oPasswordAuthentication }, 177 { "kbdinteractiveauthentication", oKbdInteractiveAuthentication }, 178 { "kbdinteractivedevices", oKbdInteractiveDevices }, 179 { "rsaauthentication", oRSAAuthentication }, 180 { "pubkeyauthentication", oPubkeyAuthentication }, 181 { "dsaauthentication", oPubkeyAuthentication }, /* alias */ 182 { "rhostsrsaauthentication", oRhostsRSAAuthentication }, 183 { "hostbasedauthentication", oHostbasedAuthentication }, 184 { "challengeresponseauthentication", oChallengeResponseAuthentication }, 185 { "skeyauthentication", oChallengeResponseAuthentication }, /* alias */ 186 { "tisauthentication", oChallengeResponseAuthentication }, /* alias */ 187 { "kerberosauthentication", oUnsupported }, 188 { "kerberostgtpassing", oUnsupported }, 189 { "afstokenpassing", oUnsupported }, 190 #if defined(GSSAPI) 191 { "gssapiauthentication", oGssAuthentication }, 192 { "gssapidelegatecredentials", oGssDelegateCreds }, 193 #else 194 { "gssapiauthentication", oUnsupported }, 195 { "gssapidelegatecredentials", oUnsupported }, 196 #endif 197 { "fallbacktorsh", oDeprecated }, 198 { "usersh", oDeprecated }, 199 { "identityfile", oIdentityFile }, 200 { "identityfile2", oIdentityFile }, /* obsolete */ 201 { "identitiesonly", oIdentitiesOnly }, 202 { "hostname", oHostName }, 203 { "hostkeyalias", oHostKeyAlias }, 204 { "proxycommand", oProxyCommand }, 205 { "port", oPort }, 206 { "cipher", oCipher }, 207 { "ciphers", oCiphers }, 208 { "macs", oMacs }, 209 { "protocol", oProtocol }, 210 { "remoteforward", oRemoteForward }, 211 { "localforward", oLocalForward }, 212 { "user", oUser }, 213 { "host", oHost }, 214 { "match", oMatch }, 215 { "escapechar", oEscapeChar }, 216 { "globalknownhostsfile", oGlobalKnownHostsFile }, 217 { "globalknownhostsfile2", oDeprecated }, 218 { "userknownhostsfile", oUserKnownHostsFile }, 219 { "userknownhostsfile2", oDeprecated }, 220 { "connectionattempts", oConnectionAttempts }, 221 { "batchmode", oBatchMode }, 222 { "checkhostip", oCheckHostIP }, 223 { "stricthostkeychecking", oStrictHostKeyChecking }, 224 { "compression", oCompression }, 225 { "compressionlevel", oCompressionLevel }, 226 { "tcpkeepalive", oTCPKeepAlive }, 227 { "keepalive", oTCPKeepAlive }, /* obsolete */ 228 { "numberofpasswordprompts", oNumberOfPasswordPrompts }, 229 { "loglevel", oLogLevel }, 230 { "dynamicforward", oDynamicForward }, 231 { "preferredauthentications", oPreferredAuthentications }, 232 { "hostkeyalgorithms", oHostKeyAlgorithms }, 233 { "bindaddress", oBindAddress }, 234 #ifdef ENABLE_PKCS11 235 { "smartcarddevice", oPKCS11Provider }, 236 { "pkcs11provider", oPKCS11Provider }, 237 #else 238 { "smartcarddevice", oUnsupported }, 239 { "pkcs11provider", oUnsupported }, 240 #endif 241 { "clearallforwardings", oClearAllForwardings }, 242 { "enablesshkeysign", oEnableSSHKeysign }, 243 { "verifyhostkeydns", oVerifyHostKeyDNS }, 244 { "nohostauthenticationforlocalhost", oNoHostAuthenticationForLocalhost }, 245 { "rekeylimit", oRekeyLimit }, 246 { "connecttimeout", oConnectTimeout }, 247 { "addressfamily", oAddressFamily }, 248 { "serveraliveinterval", oServerAliveInterval }, 249 { "serveralivecountmax", oServerAliveCountMax }, 250 { "versionaddendum", oVersionAddendum }, 251 { "sendenv", oSendEnv }, 252 { "controlpath", oControlPath }, 253 { "controlmaster", oControlMaster }, 254 { "controlpersist", oControlPersist }, 255 { "hashknownhosts", oHashKnownHosts }, 256 { "tunnel", oTunnel }, 257 { "tunneldevice", oTunnelDevice }, 258 { "localcommand", oLocalCommand }, 259 { "permitlocalcommand", oPermitLocalCommand }, 260 { "visualhostkey", oVisualHostKey }, 261 { "useroaming", oUseRoaming }, 262 { "kexalgorithms", oKexAlgorithms }, 263 { "ipqos", oIPQoS }, 264 { "requesttty", oRequestTTY }, 265 { "noneenabled", oNoneEnabled }, 266 { "noneswitch", oNoneSwitch }, 267 { "tcprcvbufpoll", oTcpRcvBufPoll }, 268 { "tcprcvbuf", oTcpRcvBuf }, 269 { "hpndisabled", oHPNDisabled }, 270 { "hpnbuffersize", oHPNBufferSize }, 271 { "proxyusefdpass", oProxyUseFdpass }, 272 { "canonicaldomains", oCanonicalDomains }, 273 { "canonicalizefallbacklocal", oCanonicalizeFallbackLocal }, 274 { "canonicalizehostname", oCanonicalizeHostname }, 275 { "canonicalizemaxdots", oCanonicalizeMaxDots }, 276 { "canonicalizepermittedcnames", oCanonicalizePermittedCNAMEs }, 277 { "streamlocalbindmask", oStreamLocalBindMask }, 278 { "streamlocalbindunlink", oStreamLocalBindUnlink }, 279 { "ignoreunknown", oIgnoreUnknown }, 280 281 { NULL, oBadOption } 282 }; 283 284 /* 285 * Adds a local TCP/IP port forward to options. Never returns if there is an 286 * error. 287 */ 288 289 void 290 add_local_forward(Options *options, const struct Forward *newfwd) 291 { 292 struct Forward *fwd; 293 #ifndef NO_IPPORT_RESERVED_CONCEPT 294 extern uid_t original_real_uid; 295 if (newfwd->listen_port < IPPORT_RESERVED && original_real_uid != 0 && 296 newfwd->listen_path == NULL) 297 fatal("Privileged ports can only be forwarded by root."); 298 #endif 299 options->local_forwards = xrealloc(options->local_forwards, 300 options->num_local_forwards + 1, 301 sizeof(*options->local_forwards)); 302 fwd = &options->local_forwards[options->num_local_forwards++]; 303 304 fwd->listen_host = newfwd->listen_host; 305 fwd->listen_port = newfwd->listen_port; 306 fwd->listen_path = newfwd->listen_path; 307 fwd->connect_host = newfwd->connect_host; 308 fwd->connect_port = newfwd->connect_port; 309 fwd->connect_path = newfwd->connect_path; 310 } 311 312 /* 313 * Adds a remote TCP/IP port forward to options. Never returns if there is 314 * an error. 315 */ 316 317 void 318 add_remote_forward(Options *options, const struct Forward *newfwd) 319 { 320 struct Forward *fwd; 321 322 options->remote_forwards = xrealloc(options->remote_forwards, 323 options->num_remote_forwards + 1, 324 sizeof(*options->remote_forwards)); 325 fwd = &options->remote_forwards[options->num_remote_forwards++]; 326 327 fwd->listen_host = newfwd->listen_host; 328 fwd->listen_port = newfwd->listen_port; 329 fwd->listen_path = newfwd->listen_path; 330 fwd->connect_host = newfwd->connect_host; 331 fwd->connect_port = newfwd->connect_port; 332 fwd->connect_path = newfwd->connect_path; 333 fwd->handle = newfwd->handle; 334 fwd->allocated_port = 0; 335 } 336 337 static void 338 clear_forwardings(Options *options) 339 { 340 int i; 341 342 for (i = 0; i < options->num_local_forwards; i++) { 343 free(options->local_forwards[i].listen_host); 344 free(options->local_forwards[i].listen_path); 345 free(options->local_forwards[i].connect_host); 346 free(options->local_forwards[i].connect_path); 347 } 348 if (options->num_local_forwards > 0) { 349 free(options->local_forwards); 350 options->local_forwards = NULL; 351 } 352 options->num_local_forwards = 0; 353 for (i = 0; i < options->num_remote_forwards; i++) { 354 free(options->remote_forwards[i].listen_host); 355 free(options->remote_forwards[i].listen_path); 356 free(options->remote_forwards[i].connect_host); 357 free(options->remote_forwards[i].connect_path); 358 } 359 if (options->num_remote_forwards > 0) { 360 free(options->remote_forwards); 361 options->remote_forwards = NULL; 362 } 363 options->num_remote_forwards = 0; 364 options->tun_open = SSH_TUNMODE_NO; 365 } 366 367 void 368 add_identity_file(Options *options, const char *dir, const char *filename, 369 int userprovided) 370 { 371 char *path; 372 int i; 373 374 if (options->num_identity_files >= SSH_MAX_IDENTITY_FILES) 375 fatal("Too many identity files specified (max %d)", 376 SSH_MAX_IDENTITY_FILES); 377 378 if (dir == NULL) /* no dir, filename is absolute */ 379 path = xstrdup(filename); 380 else 381 (void)xasprintf(&path, "%.100s%.100s", dir, filename); 382 383 /* Avoid registering duplicates */ 384 for (i = 0; i < options->num_identity_files; i++) { 385 if (options->identity_file_userprovided[i] == userprovided && 386 strcmp(options->identity_files[i], path) == 0) { 387 debug2("%s: ignoring duplicate key %s", __func__, path); 388 free(path); 389 return; 390 } 391 } 392 393 options->identity_file_userprovided[options->num_identity_files] = 394 userprovided; 395 options->identity_files[options->num_identity_files++] = path; 396 } 397 398 int 399 default_ssh_port(void) 400 { 401 static int port; 402 struct servent *sp; 403 404 if (port == 0) { 405 sp = getservbyname(SSH_SERVICE_NAME, "tcp"); 406 port = sp ? ntohs(sp->s_port) : SSH_DEFAULT_PORT; 407 } 408 return port; 409 } 410 411 /* 412 * Execute a command in a shell. 413 * Return its exit status or -1 on abnormal exit. 414 */ 415 static int 416 execute_in_shell(const char *cmd) 417 { 418 char *shell, *command_string; 419 pid_t pid; 420 int devnull, status; 421 extern uid_t original_real_uid; 422 423 if ((shell = getenv("SHELL")) == NULL) 424 shell = _PATH_BSHELL; 425 426 /* 427 * Use "exec" to avoid "sh -c" processes on some platforms 428 * (e.g. Solaris) 429 */ 430 xasprintf(&command_string, "exec %s", cmd); 431 432 /* Need this to redirect subprocess stdin/out */ 433 if ((devnull = open(_PATH_DEVNULL, O_RDWR)) == -1) 434 fatal("open(/dev/null): %s", strerror(errno)); 435 436 debug("Executing command: '%.500s'", cmd); 437 438 /* Fork and execute the command. */ 439 if ((pid = fork()) == 0) { 440 char *argv[4]; 441 442 /* Child. Permanently give up superuser privileges. */ 443 permanently_drop_suid(original_real_uid); 444 445 /* Redirect child stdin and stdout. Leave stderr */ 446 if (dup2(devnull, STDIN_FILENO) == -1) 447 fatal("dup2: %s", strerror(errno)); 448 if (dup2(devnull, STDOUT_FILENO) == -1) 449 fatal("dup2: %s", strerror(errno)); 450 if (devnull > STDERR_FILENO) 451 close(devnull); 452 closefrom(STDERR_FILENO + 1); 453 454 argv[0] = shell; 455 argv[1] = "-c"; 456 argv[2] = command_string; 457 argv[3] = NULL; 458 459 execv(argv[0], argv); 460 error("Unable to execute '%.100s': %s", cmd, strerror(errno)); 461 /* Die with signal to make this error apparent to parent. */ 462 signal(SIGTERM, SIG_DFL); 463 kill(getpid(), SIGTERM); 464 _exit(1); 465 } 466 /* Parent. */ 467 if (pid < 0) 468 fatal("%s: fork: %.100s", __func__, strerror(errno)); 469 470 close(devnull); 471 free(command_string); 472 473 while (waitpid(pid, &status, 0) == -1) { 474 if (errno != EINTR && errno != EAGAIN) 475 fatal("%s: waitpid: %s", __func__, strerror(errno)); 476 } 477 if (!WIFEXITED(status)) { 478 error("command '%.100s' exited abnormally", cmd); 479 return -1; 480 } 481 debug3("command returned status %d", WEXITSTATUS(status)); 482 return WEXITSTATUS(status); 483 } 484 485 /* 486 * Parse and execute a Match directive. 487 */ 488 static int 489 match_cfg_line(Options *options, char **condition, struct passwd *pw, 490 const char *host_arg, const char *filename, int linenum) 491 { 492 char *arg, *attrib, *cmd, *cp = *condition, *host; 493 const char *ruser; 494 int r, port, result = 1, attributes = 0; 495 size_t len; 496 char thishost[NI_MAXHOST], shorthost[NI_MAXHOST], portstr[NI_MAXSERV]; 497 498 /* 499 * Configuration is likely to be incomplete at this point so we 500 * must be prepared to use default values. 501 */ 502 port = options->port <= 0 ? default_ssh_port() : options->port; 503 ruser = options->user == NULL ? pw->pw_name : options->user; 504 if (options->hostname != NULL) { 505 /* NB. Please keep in sync with ssh.c:main() */ 506 host = percent_expand(options->hostname, 507 "h", host_arg, (char *)NULL); 508 } else 509 host = xstrdup(host_arg); 510 511 debug3("checking match for '%s' host %s", cp, host); 512 while ((attrib = strdelim(&cp)) && *attrib != '\0') { 513 attributes++; 514 if (strcasecmp(attrib, "all") == 0) { 515 if (attributes != 1 || 516 ((arg = strdelim(&cp)) != NULL && *arg != '\0')) { 517 error("'all' cannot be combined with other " 518 "Match attributes"); 519 result = -1; 520 goto out; 521 } 522 *condition = cp; 523 result = 1; 524 goto out; 525 } 526 if ((arg = strdelim(&cp)) == NULL || *arg == '\0') { 527 error("Missing Match criteria for %s", attrib); 528 result = -1; 529 goto out; 530 } 531 len = strlen(arg); 532 if (strcasecmp(attrib, "host") == 0) { 533 if (match_hostname(host, arg, len) != 1) 534 result = 0; 535 else 536 debug("%.200s line %d: matched 'Host %.100s' ", 537 filename, linenum, host); 538 } else if (strcasecmp(attrib, "originalhost") == 0) { 539 if (match_hostname(host_arg, arg, len) != 1) 540 result = 0; 541 else 542 debug("%.200s line %d: matched " 543 "'OriginalHost %.100s' ", 544 filename, linenum, host_arg); 545 } else if (strcasecmp(attrib, "user") == 0) { 546 if (match_pattern_list(ruser, arg, len, 0) != 1) 547 result = 0; 548 else 549 debug("%.200s line %d: matched 'User %.100s' ", 550 filename, linenum, ruser); 551 } else if (strcasecmp(attrib, "localuser") == 0) { 552 if (match_pattern_list(pw->pw_name, arg, len, 0) != 1) 553 result = 0; 554 else 555 debug("%.200s line %d: matched " 556 "'LocalUser %.100s' ", 557 filename, linenum, pw->pw_name); 558 } else if (strcasecmp(attrib, "exec") == 0) { 559 if (gethostname(thishost, sizeof(thishost)) == -1) 560 fatal("gethostname: %s", strerror(errno)); 561 strlcpy(shorthost, thishost, sizeof(shorthost)); 562 shorthost[strcspn(thishost, ".")] = '\0'; 563 snprintf(portstr, sizeof(portstr), "%d", port); 564 565 cmd = percent_expand(arg, 566 "L", shorthost, 567 "d", pw->pw_dir, 568 "h", host, 569 "l", thishost, 570 "n", host_arg, 571 "p", portstr, 572 "r", ruser, 573 "u", pw->pw_name, 574 (char *)NULL); 575 if (result != 1) { 576 /* skip execution if prior predicate failed */ 577 debug("%.200s line %d: skipped exec \"%.100s\"", 578 filename, linenum, cmd); 579 } else { 580 r = execute_in_shell(cmd); 581 if (r == -1) { 582 fatal("%.200s line %d: match exec " 583 "'%.100s' error", filename, 584 linenum, cmd); 585 } else if (r == 0) { 586 debug("%.200s line %d: matched " 587 "'exec \"%.100s\"'", filename, 588 linenum, cmd); 589 } else { 590 debug("%.200s line %d: no match " 591 "'exec \"%.100s\"'", filename, 592 linenum, cmd); 593 result = 0; 594 } 595 } 596 free(cmd); 597 } else { 598 error("Unsupported Match attribute %s", attrib); 599 result = -1; 600 goto out; 601 } 602 } 603 if (attributes == 0) { 604 error("One or more attributes required for Match"); 605 result = -1; 606 goto out; 607 } 608 debug3("match %sfound", result ? "" : "not "); 609 *condition = cp; 610 out: 611 free(host); 612 return result; 613 } 614 615 /* Check and prepare a domain name: removes trailing '.' and lowercases */ 616 static void 617 valid_domain(char *name, const char *filename, int linenum) 618 { 619 size_t i, l = strlen(name); 620 u_char c, last = '\0'; 621 622 if (l == 0) 623 fatal("%s line %d: empty hostname suffix", filename, linenum); 624 if (!isalpha((u_char)name[0]) && !isdigit((u_char)name[0])) 625 fatal("%s line %d: hostname suffix \"%.100s\" " 626 "starts with invalid character", filename, linenum, name); 627 for (i = 0; i < l; i++) { 628 c = tolower((u_char)name[i]); 629 name[i] = (char)c; 630 if (last == '.' && c == '.') 631 fatal("%s line %d: hostname suffix \"%.100s\" contains " 632 "consecutive separators", filename, linenum, name); 633 if (c != '.' && c != '-' && !isalnum(c) && 634 c != '_') /* technically invalid, but common */ 635 fatal("%s line %d: hostname suffix \"%.100s\" contains " 636 "invalid characters", filename, linenum, name); 637 last = c; 638 } 639 if (name[l - 1] == '.') 640 name[l - 1] = '\0'; 641 } 642 643 /* 644 * Returns the number of the token pointed to by cp or oBadOption. 645 */ 646 static OpCodes 647 parse_token(const char *cp, const char *filename, int linenum, 648 const char *ignored_unknown) 649 { 650 int i; 651 652 for (i = 0; keywords[i].name; i++) 653 if (strcmp(cp, keywords[i].name) == 0) 654 return keywords[i].opcode; 655 if (ignored_unknown != NULL && match_pattern_list(cp, ignored_unknown, 656 strlen(ignored_unknown), 1) == 1) 657 return oIgnoredUnknownOption; 658 error("%s: line %d: Bad configuration option: %s", 659 filename, linenum, cp); 660 return oBadOption; 661 } 662 663 /* Multistate option parsing */ 664 struct multistate { 665 char *key; 666 int value; 667 }; 668 static const struct multistate multistate_flag[] = { 669 { "true", 1 }, 670 { "false", 0 }, 671 { "yes", 1 }, 672 { "no", 0 }, 673 { NULL, -1 } 674 }; 675 static const struct multistate multistate_yesnoask[] = { 676 { "true", 1 }, 677 { "false", 0 }, 678 { "yes", 1 }, 679 { "no", 0 }, 680 { "ask", 2 }, 681 { NULL, -1 } 682 }; 683 static const struct multistate multistate_addressfamily[] = { 684 { "inet", AF_INET }, 685 { "inet6", AF_INET6 }, 686 { "any", AF_UNSPEC }, 687 { NULL, -1 } 688 }; 689 static const struct multistate multistate_controlmaster[] = { 690 { "true", SSHCTL_MASTER_YES }, 691 { "yes", SSHCTL_MASTER_YES }, 692 { "false", SSHCTL_MASTER_NO }, 693 { "no", SSHCTL_MASTER_NO }, 694 { "auto", SSHCTL_MASTER_AUTO }, 695 { "ask", SSHCTL_MASTER_ASK }, 696 { "autoask", SSHCTL_MASTER_AUTO_ASK }, 697 { NULL, -1 } 698 }; 699 static const struct multistate multistate_tunnel[] = { 700 { "ethernet", SSH_TUNMODE_ETHERNET }, 701 { "point-to-point", SSH_TUNMODE_POINTOPOINT }, 702 { "true", SSH_TUNMODE_DEFAULT }, 703 { "yes", SSH_TUNMODE_DEFAULT }, 704 { "false", SSH_TUNMODE_NO }, 705 { "no", SSH_TUNMODE_NO }, 706 { NULL, -1 } 707 }; 708 static const struct multistate multistate_requesttty[] = { 709 { "true", REQUEST_TTY_YES }, 710 { "yes", REQUEST_TTY_YES }, 711 { "false", REQUEST_TTY_NO }, 712 { "no", REQUEST_TTY_NO }, 713 { "force", REQUEST_TTY_FORCE }, 714 { "auto", REQUEST_TTY_AUTO }, 715 { NULL, -1 } 716 }; 717 static const struct multistate multistate_canonicalizehostname[] = { 718 { "true", SSH_CANONICALISE_YES }, 719 { "false", SSH_CANONICALISE_NO }, 720 { "yes", SSH_CANONICALISE_YES }, 721 { "no", SSH_CANONICALISE_NO }, 722 { "always", SSH_CANONICALISE_ALWAYS }, 723 { NULL, -1 } 724 }; 725 726 /* 727 * Processes a single option line as used in the configuration files. This 728 * only sets those values that have not already been set. 729 */ 730 #define WHITESPACE " \t\r\n" 731 int 732 process_config_line(Options *options, struct passwd *pw, const char *host, 733 char *line, const char *filename, int linenum, int *activep, int userconfig) 734 { 735 char *s, **charptr, *endofnumber, *keyword, *arg, *arg2; 736 char **cpptr, fwdarg[256]; 737 u_int i, *uintptr, max_entries = 0; 738 int negated, opcode, *intptr, value, value2, cmdline = 0; 739 LogLevel *log_level_ptr; 740 long long val64; 741 size_t len; 742 struct Forward fwd; 743 const struct multistate *multistate_ptr; 744 struct allowed_cname *cname; 745 746 if (activep == NULL) { /* We are processing a command line directive */ 747 cmdline = 1; 748 activep = &cmdline; 749 } 750 751 /* Strip trailing whitespace */ 752 for (len = strlen(line) - 1; len > 0; len--) { 753 if (strchr(WHITESPACE, line[len]) == NULL) 754 break; 755 line[len] = '\0'; 756 } 757 758 s = line; 759 /* Get the keyword. (Each line is supposed to begin with a keyword). */ 760 if ((keyword = strdelim(&s)) == NULL) 761 return 0; 762 /* Ignore leading whitespace. */ 763 if (*keyword == '\0') 764 keyword = strdelim(&s); 765 if (keyword == NULL || !*keyword || *keyword == '\n' || *keyword == '#') 766 return 0; 767 /* Match lowercase keyword */ 768 lowercase(keyword); 769 770 opcode = parse_token(keyword, filename, linenum, 771 options->ignored_unknown); 772 773 switch (opcode) { 774 case oBadOption: 775 /* don't panic, but count bad options */ 776 return -1; 777 /* NOTREACHED */ 778 case oIgnoredUnknownOption: 779 debug("%s line %d: Ignored unknown option \"%s\"", 780 filename, linenum, keyword); 781 return 0; 782 case oConnectTimeout: 783 intptr = &options->connection_timeout; 784 parse_time: 785 arg = strdelim(&s); 786 if (!arg || *arg == '\0') 787 fatal("%s line %d: missing time value.", 788 filename, linenum); 789 if ((value = convtime(arg)) == -1) 790 fatal("%s line %d: invalid time value.", 791 filename, linenum); 792 if (*activep && *intptr == -1) 793 *intptr = value; 794 break; 795 796 case oForwardAgent: 797 intptr = &options->forward_agent; 798 parse_flag: 799 multistate_ptr = multistate_flag; 800 parse_multistate: 801 arg = strdelim(&s); 802 if (!arg || *arg == '\0') 803 fatal("%s line %d: missing argument.", 804 filename, linenum); 805 value = -1; 806 for (i = 0; multistate_ptr[i].key != NULL; i++) { 807 if (strcasecmp(arg, multistate_ptr[i].key) == 0) { 808 value = multistate_ptr[i].value; 809 break; 810 } 811 } 812 if (value == -1) 813 fatal("%s line %d: unsupported option \"%s\".", 814 filename, linenum, arg); 815 if (*activep && *intptr == -1) 816 *intptr = value; 817 break; 818 819 case oForwardX11: 820 intptr = &options->forward_x11; 821 goto parse_flag; 822 823 case oForwardX11Trusted: 824 intptr = &options->forward_x11_trusted; 825 goto parse_flag; 826 827 case oForwardX11Timeout: 828 intptr = &options->forward_x11_timeout; 829 goto parse_time; 830 831 case oGatewayPorts: 832 intptr = &options->fwd_opts.gateway_ports; 833 goto parse_flag; 834 835 case oExitOnForwardFailure: 836 intptr = &options->exit_on_forward_failure; 837 goto parse_flag; 838 839 case oUsePrivilegedPort: 840 intptr = &options->use_privileged_port; 841 goto parse_flag; 842 843 case oPasswordAuthentication: 844 intptr = &options->password_authentication; 845 goto parse_flag; 846 847 case oKbdInteractiveAuthentication: 848 intptr = &options->kbd_interactive_authentication; 849 goto parse_flag; 850 851 case oKbdInteractiveDevices: 852 charptr = &options->kbd_interactive_devices; 853 goto parse_string; 854 855 case oPubkeyAuthentication: 856 intptr = &options->pubkey_authentication; 857 goto parse_flag; 858 859 case oRSAAuthentication: 860 intptr = &options->rsa_authentication; 861 goto parse_flag; 862 863 case oRhostsRSAAuthentication: 864 intptr = &options->rhosts_rsa_authentication; 865 goto parse_flag; 866 867 case oHostbasedAuthentication: 868 intptr = &options->hostbased_authentication; 869 goto parse_flag; 870 871 case oChallengeResponseAuthentication: 872 intptr = &options->challenge_response_authentication; 873 goto parse_flag; 874 875 case oGssAuthentication: 876 intptr = &options->gss_authentication; 877 goto parse_flag; 878 879 case oGssDelegateCreds: 880 intptr = &options->gss_deleg_creds; 881 goto parse_flag; 882 883 case oBatchMode: 884 intptr = &options->batch_mode; 885 goto parse_flag; 886 887 case oCheckHostIP: 888 intptr = &options->check_host_ip; 889 goto parse_flag; 890 891 case oHPNDisabled: 892 intptr = &options->hpn_disabled; 893 goto parse_flag; 894 895 case oHPNBufferSize: 896 intptr = &options->hpn_buffer_size; 897 goto parse_int; 898 899 case oTcpRcvBufPoll: 900 intptr = &options->tcp_rcv_buf_poll; 901 goto parse_flag; 902 903 case oNoneEnabled: 904 intptr = &options->none_enabled; 905 goto parse_flag; 906 907 /* we check to see if the command comes from the */ 908 /* command line or not. If it does then enable it */ 909 /* otherwise fail. NONE should never be a default configuration */ 910 case oNoneSwitch: 911 if(strcmp(filename,"command-line") == 0) { 912 intptr = &options->none_switch; 913 goto parse_flag; 914 } else { 915 error("NoneSwitch is found in %.200s.\nYou may only use this configuration option from the command line", filename); 916 error("Continuing..."); 917 debug("NoneSwitch directive found in %.200s.", filename); 918 return 0; 919 } 920 921 case oVerifyHostKeyDNS: 922 intptr = &options->verify_host_key_dns; 923 multistate_ptr = multistate_yesnoask; 924 goto parse_multistate; 925 926 case oStrictHostKeyChecking: 927 intptr = &options->strict_host_key_checking; 928 multistate_ptr = multistate_yesnoask; 929 goto parse_multistate; 930 931 case oCompression: 932 intptr = &options->compression; 933 goto parse_flag; 934 935 case oTCPKeepAlive: 936 intptr = &options->tcp_keep_alive; 937 goto parse_flag; 938 939 case oNoHostAuthenticationForLocalhost: 940 intptr = &options->no_host_authentication_for_localhost; 941 goto parse_flag; 942 943 case oNumberOfPasswordPrompts: 944 intptr = &options->number_of_password_prompts; 945 goto parse_int; 946 947 case oCompressionLevel: 948 intptr = &options->compression_level; 949 goto parse_int; 950 951 case oRekeyLimit: 952 arg = strdelim(&s); 953 if (!arg || *arg == '\0') 954 fatal("%.200s line %d: Missing argument.", filename, 955 linenum); 956 if (strcmp(arg, "default") == 0) { 957 val64 = 0; 958 } else { 959 if (scan_scaled(arg, &val64) == -1) 960 fatal("%.200s line %d: Bad number '%s': %s", 961 filename, linenum, arg, strerror(errno)); 962 /* check for too-large or too-small limits */ 963 if (val64 > UINT_MAX) 964 fatal("%.200s line %d: RekeyLimit too large", 965 filename, linenum); 966 if (val64 != 0 && val64 < 16) 967 fatal("%.200s line %d: RekeyLimit too small", 968 filename, linenum); 969 } 970 if (*activep && options->rekey_limit == -1) 971 options->rekey_limit = (u_int32_t)val64; 972 if (s != NULL) { /* optional rekey interval present */ 973 if (strcmp(s, "none") == 0) { 974 (void)strdelim(&s); /* discard */ 975 break; 976 } 977 intptr = &options->rekey_interval; 978 goto parse_time; 979 } 980 break; 981 982 case oIdentityFile: 983 arg = strdelim(&s); 984 if (!arg || *arg == '\0') 985 fatal("%.200s line %d: Missing argument.", filename, linenum); 986 if (*activep) { 987 intptr = &options->num_identity_files; 988 if (*intptr >= SSH_MAX_IDENTITY_FILES) 989 fatal("%.200s line %d: Too many identity files specified (max %d).", 990 filename, linenum, SSH_MAX_IDENTITY_FILES); 991 add_identity_file(options, NULL, arg, userconfig); 992 } 993 break; 994 995 case oXAuthLocation: 996 charptr=&options->xauth_location; 997 goto parse_string; 998 999 case oUser: 1000 charptr = &options->user; 1001 parse_string: 1002 arg = strdelim(&s); 1003 if (!arg || *arg == '\0') 1004 fatal("%.200s line %d: Missing argument.", 1005 filename, linenum); 1006 if (*activep && *charptr == NULL) 1007 *charptr = xstrdup(arg); 1008 break; 1009 1010 case oGlobalKnownHostsFile: 1011 cpptr = (char **)&options->system_hostfiles; 1012 uintptr = &options->num_system_hostfiles; 1013 max_entries = SSH_MAX_HOSTS_FILES; 1014 parse_char_array: 1015 if (*activep && *uintptr == 0) { 1016 while ((arg = strdelim(&s)) != NULL && *arg != '\0') { 1017 if ((*uintptr) >= max_entries) 1018 fatal("%s line %d: " 1019 "too many authorized keys files.", 1020 filename, linenum); 1021 cpptr[(*uintptr)++] = xstrdup(arg); 1022 } 1023 } 1024 return 0; 1025 1026 case oUserKnownHostsFile: 1027 cpptr = (char **)&options->user_hostfiles; 1028 uintptr = &options->num_user_hostfiles; 1029 max_entries = SSH_MAX_HOSTS_FILES; 1030 goto parse_char_array; 1031 1032 case oHostName: 1033 charptr = &options->hostname; 1034 goto parse_string; 1035 1036 case oHostKeyAlias: 1037 charptr = &options->host_key_alias; 1038 goto parse_string; 1039 1040 case oPreferredAuthentications: 1041 charptr = &options->preferred_authentications; 1042 goto parse_string; 1043 1044 case oBindAddress: 1045 charptr = &options->bind_address; 1046 goto parse_string; 1047 1048 case oPKCS11Provider: 1049 charptr = &options->pkcs11_provider; 1050 goto parse_string; 1051 1052 case oProxyCommand: 1053 charptr = &options->proxy_command; 1054 parse_command: 1055 if (s == NULL) 1056 fatal("%.200s line %d: Missing argument.", filename, linenum); 1057 len = strspn(s, WHITESPACE "="); 1058 if (*activep && *charptr == NULL) 1059 *charptr = xstrdup(s + len); 1060 return 0; 1061 1062 case oPort: 1063 intptr = &options->port; 1064 parse_int: 1065 arg = strdelim(&s); 1066 if (!arg || *arg == '\0') 1067 fatal("%.200s line %d: Missing argument.", filename, linenum); 1068 if (arg[0] < '0' || arg[0] > '9') 1069 fatal("%.200s line %d: Bad number.", filename, linenum); 1070 1071 /* Octal, decimal, or hex format? */ 1072 value = strtol(arg, &endofnumber, 0); 1073 if (arg == endofnumber) 1074 fatal("%.200s line %d: Bad number.", filename, linenum); 1075 if (*activep && *intptr == -1) 1076 *intptr = value; 1077 break; 1078 1079 case oConnectionAttempts: 1080 intptr = &options->connection_attempts; 1081 goto parse_int; 1082 1083 case oTcpRcvBuf: 1084 intptr = &options->tcp_rcv_buf; 1085 goto parse_int; 1086 1087 case oCipher: 1088 intptr = &options->cipher; 1089 arg = strdelim(&s); 1090 if (!arg || *arg == '\0') 1091 fatal("%.200s line %d: Missing argument.", filename, linenum); 1092 value = cipher_number(arg); 1093 if (value == -1) 1094 fatal("%.200s line %d: Bad cipher '%s'.", 1095 filename, linenum, arg ? arg : "<NONE>"); 1096 if (*activep && *intptr == -1) 1097 *intptr = value; 1098 break; 1099 1100 case oCiphers: 1101 arg = strdelim(&s); 1102 if (!arg || *arg == '\0') 1103 fatal("%.200s line %d: Missing argument.", filename, linenum); 1104 if (!ciphers_valid(arg)) 1105 fatal("%.200s line %d: Bad SSH2 cipher spec '%s'.", 1106 filename, linenum, arg ? arg : "<NONE>"); 1107 if (*activep && options->ciphers == NULL) 1108 options->ciphers = xstrdup(arg); 1109 break; 1110 1111 case oMacs: 1112 arg = strdelim(&s); 1113 if (!arg || *arg == '\0') 1114 fatal("%.200s line %d: Missing argument.", filename, linenum); 1115 if (!mac_valid(arg)) 1116 fatal("%.200s line %d: Bad SSH2 Mac spec '%s'.", 1117 filename, linenum, arg ? arg : "<NONE>"); 1118 if (*activep && options->macs == NULL) 1119 options->macs = xstrdup(arg); 1120 break; 1121 1122 case oKexAlgorithms: 1123 arg = strdelim(&s); 1124 if (!arg || *arg == '\0') 1125 fatal("%.200s line %d: Missing argument.", 1126 filename, linenum); 1127 if (!kex_names_valid(arg)) 1128 fatal("%.200s line %d: Bad SSH2 KexAlgorithms '%s'.", 1129 filename, linenum, arg ? arg : "<NONE>"); 1130 if (*activep && options->kex_algorithms == NULL) 1131 options->kex_algorithms = xstrdup(arg); 1132 break; 1133 1134 case oHostKeyAlgorithms: 1135 arg = strdelim(&s); 1136 if (!arg || *arg == '\0') 1137 fatal("%.200s line %d: Missing argument.", filename, linenum); 1138 if (!key_names_valid2(arg)) 1139 fatal("%.200s line %d: Bad protocol 2 host key algorithms '%s'.", 1140 filename, linenum, arg ? arg : "<NONE>"); 1141 if (*activep && options->hostkeyalgorithms == NULL) 1142 options->hostkeyalgorithms = xstrdup(arg); 1143 break; 1144 1145 case oProtocol: 1146 intptr = &options->protocol; 1147 arg = strdelim(&s); 1148 if (!arg || *arg == '\0') 1149 fatal("%.200s line %d: Missing argument.", filename, linenum); 1150 value = proto_spec(arg); 1151 if (value == SSH_PROTO_UNKNOWN) 1152 fatal("%.200s line %d: Bad protocol spec '%s'.", 1153 filename, linenum, arg ? arg : "<NONE>"); 1154 if (*activep && *intptr == SSH_PROTO_UNKNOWN) 1155 *intptr = value; 1156 break; 1157 1158 case oLogLevel: 1159 log_level_ptr = &options->log_level; 1160 arg = strdelim(&s); 1161 value = log_level_number(arg); 1162 if (value == SYSLOG_LEVEL_NOT_SET) 1163 fatal("%.200s line %d: unsupported log level '%s'", 1164 filename, linenum, arg ? arg : "<NONE>"); 1165 if (*activep && *log_level_ptr == SYSLOG_LEVEL_NOT_SET) 1166 *log_level_ptr = (LogLevel) value; 1167 break; 1168 1169 case oLocalForward: 1170 case oRemoteForward: 1171 case oDynamicForward: 1172 arg = strdelim(&s); 1173 if (arg == NULL || *arg == '\0') 1174 fatal("%.200s line %d: Missing port argument.", 1175 filename, linenum); 1176 1177 if (opcode == oLocalForward || 1178 opcode == oRemoteForward) { 1179 arg2 = strdelim(&s); 1180 if (arg2 == NULL || *arg2 == '\0') 1181 fatal("%.200s line %d: Missing target argument.", 1182 filename, linenum); 1183 1184 /* construct a string for parse_forward */ 1185 snprintf(fwdarg, sizeof(fwdarg), "%s:%s", arg, arg2); 1186 } else if (opcode == oDynamicForward) { 1187 strlcpy(fwdarg, arg, sizeof(fwdarg)); 1188 } 1189 1190 if (parse_forward(&fwd, fwdarg, 1191 opcode == oDynamicForward ? 1 : 0, 1192 opcode == oRemoteForward ? 1 : 0) == 0) 1193 fatal("%.200s line %d: Bad forwarding specification.", 1194 filename, linenum); 1195 1196 if (*activep) { 1197 if (opcode == oLocalForward || 1198 opcode == oDynamicForward) 1199 add_local_forward(options, &fwd); 1200 else if (opcode == oRemoteForward) 1201 add_remote_forward(options, &fwd); 1202 } 1203 break; 1204 1205 case oClearAllForwardings: 1206 intptr = &options->clear_forwardings; 1207 goto parse_flag; 1208 1209 case oHost: 1210 if (cmdline) 1211 fatal("Host directive not supported as a command-line " 1212 "option"); 1213 *activep = 0; 1214 arg2 = NULL; 1215 while ((arg = strdelim(&s)) != NULL && *arg != '\0') { 1216 negated = *arg == '!'; 1217 if (negated) 1218 arg++; 1219 if (match_pattern(host, arg)) { 1220 if (negated) { 1221 debug("%.200s line %d: Skipping Host " 1222 "block because of negated match " 1223 "for %.100s", filename, linenum, 1224 arg); 1225 *activep = 0; 1226 break; 1227 } 1228 if (!*activep) 1229 arg2 = arg; /* logged below */ 1230 *activep = 1; 1231 } 1232 } 1233 if (*activep) 1234 debug("%.200s line %d: Applying options for %.100s", 1235 filename, linenum, arg2); 1236 /* Avoid garbage check below, as strdelim is done. */ 1237 return 0; 1238 1239 case oMatch: 1240 if (cmdline) 1241 fatal("Host directive not supported as a command-line " 1242 "option"); 1243 value = match_cfg_line(options, &s, pw, host, 1244 filename, linenum); 1245 if (value < 0) 1246 fatal("%.200s line %d: Bad Match condition", filename, 1247 linenum); 1248 *activep = value; 1249 break; 1250 1251 case oEscapeChar: 1252 intptr = &options->escape_char; 1253 arg = strdelim(&s); 1254 if (!arg || *arg == '\0') 1255 fatal("%.200s line %d: Missing argument.", filename, linenum); 1256 if (arg[0] == '^' && arg[2] == 0 && 1257 (u_char) arg[1] >= 64 && (u_char) arg[1] < 128) 1258 value = (u_char) arg[1] & 31; 1259 else if (strlen(arg) == 1) 1260 value = (u_char) arg[0]; 1261 else if (strcmp(arg, "none") == 0) 1262 value = SSH_ESCAPECHAR_NONE; 1263 else { 1264 fatal("%.200s line %d: Bad escape character.", 1265 filename, linenum); 1266 /* NOTREACHED */ 1267 value = 0; /* Avoid compiler warning. */ 1268 } 1269 if (*activep && *intptr == -1) 1270 *intptr = value; 1271 break; 1272 1273 case oAddressFamily: 1274 intptr = &options->address_family; 1275 multistate_ptr = multistate_addressfamily; 1276 goto parse_multistate; 1277 1278 case oEnableSSHKeysign: 1279 intptr = &options->enable_ssh_keysign; 1280 goto parse_flag; 1281 1282 case oIdentitiesOnly: 1283 intptr = &options->identities_only; 1284 goto parse_flag; 1285 1286 case oServerAliveInterval: 1287 intptr = &options->server_alive_interval; 1288 goto parse_time; 1289 1290 case oServerAliveCountMax: 1291 intptr = &options->server_alive_count_max; 1292 goto parse_int; 1293 1294 case oVersionAddendum: 1295 if (s == NULL) 1296 fatal("%.200s line %d: Missing argument.", filename, 1297 linenum); 1298 len = strspn(s, WHITESPACE); 1299 if (*activep && options->version_addendum == NULL) { 1300 if (strcasecmp(s + len, "none") == 0) 1301 options->version_addendum = xstrdup(""); 1302 else if (strchr(s + len, '\r') != NULL) 1303 fatal("%.200s line %d: Invalid argument", 1304 filename, linenum); 1305 else 1306 options->version_addendum = xstrdup(s + len); 1307 } 1308 return 0; 1309 1310 case oSendEnv: 1311 while ((arg = strdelim(&s)) != NULL && *arg != '\0') { 1312 if (strchr(arg, '=') != NULL) 1313 fatal("%s line %d: Invalid environment name.", 1314 filename, linenum); 1315 if (!*activep) 1316 continue; 1317 if (options->num_send_env >= MAX_SEND_ENV) 1318 fatal("%s line %d: too many send env.", 1319 filename, linenum); 1320 options->send_env[options->num_send_env++] = 1321 xstrdup(arg); 1322 } 1323 break; 1324 1325 case oControlPath: 1326 charptr = &options->control_path; 1327 goto parse_string; 1328 1329 case oControlMaster: 1330 intptr = &options->control_master; 1331 multistate_ptr = multistate_controlmaster; 1332 goto parse_multistate; 1333 1334 case oControlPersist: 1335 /* no/false/yes/true, or a time spec */ 1336 intptr = &options->control_persist; 1337 arg = strdelim(&s); 1338 if (!arg || *arg == '\0') 1339 fatal("%.200s line %d: Missing ControlPersist" 1340 " argument.", filename, linenum); 1341 value = 0; 1342 value2 = 0; /* timeout */ 1343 if (strcmp(arg, "no") == 0 || strcmp(arg, "false") == 0) 1344 value = 0; 1345 else if (strcmp(arg, "yes") == 0 || strcmp(arg, "true") == 0) 1346 value = 1; 1347 else if ((value2 = convtime(arg)) >= 0) 1348 value = 1; 1349 else 1350 fatal("%.200s line %d: Bad ControlPersist argument.", 1351 filename, linenum); 1352 if (*activep && *intptr == -1) { 1353 *intptr = value; 1354 options->control_persist_timeout = value2; 1355 } 1356 break; 1357 1358 case oHashKnownHosts: 1359 intptr = &options->hash_known_hosts; 1360 goto parse_flag; 1361 1362 case oTunnel: 1363 intptr = &options->tun_open; 1364 multistate_ptr = multistate_tunnel; 1365 goto parse_multistate; 1366 1367 case oTunnelDevice: 1368 arg = strdelim(&s); 1369 if (!arg || *arg == '\0') 1370 fatal("%.200s line %d: Missing argument.", filename, linenum); 1371 value = a2tun(arg, &value2); 1372 if (value == SSH_TUNID_ERR) 1373 fatal("%.200s line %d: Bad tun device.", filename, linenum); 1374 if (*activep) { 1375 options->tun_local = value; 1376 options->tun_remote = value2; 1377 } 1378 break; 1379 1380 case oLocalCommand: 1381 charptr = &options->local_command; 1382 goto parse_command; 1383 1384 case oPermitLocalCommand: 1385 intptr = &options->permit_local_command; 1386 goto parse_flag; 1387 1388 case oVisualHostKey: 1389 intptr = &options->visual_host_key; 1390 goto parse_flag; 1391 1392 case oIPQoS: 1393 arg = strdelim(&s); 1394 if ((value = parse_ipqos(arg)) == -1) 1395 fatal("%s line %d: Bad IPQoS value: %s", 1396 filename, linenum, arg); 1397 arg = strdelim(&s); 1398 if (arg == NULL) 1399 value2 = value; 1400 else if ((value2 = parse_ipqos(arg)) == -1) 1401 fatal("%s line %d: Bad IPQoS value: %s", 1402 filename, linenum, arg); 1403 if (*activep) { 1404 options->ip_qos_interactive = value; 1405 options->ip_qos_bulk = value2; 1406 } 1407 break; 1408 1409 case oUseRoaming: 1410 intptr = &options->use_roaming; 1411 goto parse_flag; 1412 1413 case oRequestTTY: 1414 intptr = &options->request_tty; 1415 multistate_ptr = multistate_requesttty; 1416 goto parse_multistate; 1417 1418 case oIgnoreUnknown: 1419 charptr = &options->ignored_unknown; 1420 goto parse_string; 1421 1422 case oProxyUseFdpass: 1423 intptr = &options->proxy_use_fdpass; 1424 goto parse_flag; 1425 1426 case oCanonicalDomains: 1427 value = options->num_canonical_domains != 0; 1428 while ((arg = strdelim(&s)) != NULL && *arg != '\0') { 1429 valid_domain(arg, filename, linenum); 1430 if (!*activep || value) 1431 continue; 1432 if (options->num_canonical_domains >= MAX_CANON_DOMAINS) 1433 fatal("%s line %d: too many hostname suffixes.", 1434 filename, linenum); 1435 options->canonical_domains[ 1436 options->num_canonical_domains++] = xstrdup(arg); 1437 } 1438 break; 1439 1440 case oCanonicalizePermittedCNAMEs: 1441 value = options->num_permitted_cnames != 0; 1442 while ((arg = strdelim(&s)) != NULL && *arg != '\0') { 1443 /* Either '*' for everything or 'list:list' */ 1444 if (strcmp(arg, "*") == 0) 1445 arg2 = arg; 1446 else { 1447 lowercase(arg); 1448 if ((arg2 = strchr(arg, ':')) == NULL || 1449 arg2[1] == '\0') { 1450 fatal("%s line %d: " 1451 "Invalid permitted CNAME \"%s\"", 1452 filename, linenum, arg); 1453 } 1454 *arg2 = '\0'; 1455 arg2++; 1456 } 1457 if (!*activep || value) 1458 continue; 1459 if (options->num_permitted_cnames >= MAX_CANON_DOMAINS) 1460 fatal("%s line %d: too many permitted CNAMEs.", 1461 filename, linenum); 1462 cname = options->permitted_cnames + 1463 options->num_permitted_cnames++; 1464 cname->source_list = xstrdup(arg); 1465 cname->target_list = xstrdup(arg2); 1466 } 1467 break; 1468 1469 case oCanonicalizeHostname: 1470 intptr = &options->canonicalize_hostname; 1471 multistate_ptr = multistate_canonicalizehostname; 1472 goto parse_multistate; 1473 1474 case oCanonicalizeMaxDots: 1475 intptr = &options->canonicalize_max_dots; 1476 goto parse_int; 1477 1478 case oCanonicalizeFallbackLocal: 1479 intptr = &options->canonicalize_fallback_local; 1480 goto parse_flag; 1481 1482 case oStreamLocalBindMask: 1483 arg = strdelim(&s); 1484 if (!arg || *arg == '\0') 1485 fatal("%.200s line %d: Missing StreamLocalBindMask argument.", filename, linenum); 1486 /* Parse mode in octal format */ 1487 value = strtol(arg, &endofnumber, 8); 1488 if (arg == endofnumber || value < 0 || value > 0777) 1489 fatal("%.200s line %d: Bad mask.", filename, linenum); 1490 options->fwd_opts.streamlocal_bind_mask = (mode_t)value; 1491 break; 1492 1493 case oStreamLocalBindUnlink: 1494 intptr = &options->fwd_opts.streamlocal_bind_unlink; 1495 goto parse_flag; 1496 1497 case oDeprecated: 1498 debug("%s line %d: Deprecated option \"%s\"", 1499 filename, linenum, keyword); 1500 return 0; 1501 1502 case oUnsupported: 1503 error("%s line %d: Unsupported option \"%s\"", 1504 filename, linenum, keyword); 1505 return 0; 1506 1507 default: 1508 fatal("process_config_line: Unimplemented opcode %d", opcode); 1509 } 1510 1511 /* Check that there is no garbage at end of line. */ 1512 if ((arg = strdelim(&s)) != NULL && *arg != '\0') { 1513 fatal("%.200s line %d: garbage at end of line; \"%.200s\".", 1514 filename, linenum, arg); 1515 } 1516 return 0; 1517 } 1518 1519 1520 /* 1521 * Reads the config file and modifies the options accordingly. Options 1522 * should already be initialized before this call. This never returns if 1523 * there is an error. If the file does not exist, this returns 0. 1524 */ 1525 1526 int 1527 read_config_file(const char *filename, struct passwd *pw, const char *host, 1528 Options *options, int flags) 1529 { 1530 FILE *f; 1531 char line[1024]; 1532 int active, linenum; 1533 int bad_options = 0; 1534 1535 if ((f = fopen(filename, "r")) == NULL) 1536 return 0; 1537 1538 if (flags & SSHCONF_CHECKPERM) { 1539 struct stat sb; 1540 1541 if (fstat(fileno(f), &sb) == -1) 1542 fatal("fstat %s: %s", filename, strerror(errno)); 1543 if (((sb.st_uid != 0 && sb.st_uid != getuid()) || 1544 (sb.st_mode & 022) != 0)) 1545 fatal("Bad owner or permissions on %s", filename); 1546 } 1547 1548 debug("Reading configuration data %.200s", filename); 1549 1550 /* 1551 * Mark that we are now processing the options. This flag is turned 1552 * on/off by Host specifications. 1553 */ 1554 active = 1; 1555 linenum = 0; 1556 while (fgets(line, sizeof(line), f)) { 1557 /* Update line number counter. */ 1558 linenum++; 1559 if (process_config_line(options, pw, host, line, filename, 1560 linenum, &active, flags & SSHCONF_USERCONF) != 0) 1561 bad_options++; 1562 } 1563 fclose(f); 1564 if (bad_options > 0) 1565 fatal("%s: terminating, %d bad configuration options", 1566 filename, bad_options); 1567 return 1; 1568 } 1569 1570 /* Returns 1 if a string option is unset or set to "none" or 0 otherwise. */ 1571 int 1572 option_clear_or_none(const char *o) 1573 { 1574 return o == NULL || strcasecmp(o, "none") == 0; 1575 } 1576 1577 /* 1578 * Initializes options to special values that indicate that they have not yet 1579 * been set. Read_config_file will only set options with this value. Options 1580 * are processed in the following order: command line, user config file, 1581 * system config file. Last, fill_default_options is called. 1582 */ 1583 1584 void 1585 initialize_options(Options * options) 1586 { 1587 memset(options, 'X', sizeof(*options)); 1588 options->forward_agent = -1; 1589 options->forward_x11 = -1; 1590 options->forward_x11_trusted = -1; 1591 options->forward_x11_timeout = -1; 1592 options->exit_on_forward_failure = -1; 1593 options->xauth_location = NULL; 1594 options->fwd_opts.gateway_ports = -1; 1595 options->fwd_opts.streamlocal_bind_mask = (mode_t)-1; 1596 options->fwd_opts.streamlocal_bind_unlink = -1; 1597 options->use_privileged_port = -1; 1598 options->rsa_authentication = -1; 1599 options->pubkey_authentication = -1; 1600 options->challenge_response_authentication = -1; 1601 options->gss_authentication = -1; 1602 options->gss_deleg_creds = -1; 1603 options->password_authentication = -1; 1604 options->kbd_interactive_authentication = -1; 1605 options->kbd_interactive_devices = NULL; 1606 options->rhosts_rsa_authentication = -1; 1607 options->hostbased_authentication = -1; 1608 options->batch_mode = -1; 1609 options->check_host_ip = -1; 1610 options->strict_host_key_checking = -1; 1611 options->compression = -1; 1612 options->tcp_keep_alive = -1; 1613 options->compression_level = -1; 1614 options->port = -1; 1615 options->address_family = -1; 1616 options->connection_attempts = -1; 1617 options->connection_timeout = -1; 1618 options->number_of_password_prompts = -1; 1619 options->cipher = -1; 1620 options->ciphers = NULL; 1621 options->macs = NULL; 1622 options->kex_algorithms = NULL; 1623 options->hostkeyalgorithms = NULL; 1624 options->protocol = SSH_PROTO_UNKNOWN; 1625 options->num_identity_files = 0; 1626 options->hostname = NULL; 1627 options->host_key_alias = NULL; 1628 options->proxy_command = NULL; 1629 options->user = NULL; 1630 options->escape_char = -1; 1631 options->num_system_hostfiles = 0; 1632 options->num_user_hostfiles = 0; 1633 options->local_forwards = NULL; 1634 options->num_local_forwards = 0; 1635 options->remote_forwards = NULL; 1636 options->num_remote_forwards = 0; 1637 options->clear_forwardings = -1; 1638 options->log_level = SYSLOG_LEVEL_NOT_SET; 1639 options->preferred_authentications = NULL; 1640 options->bind_address = NULL; 1641 options->pkcs11_provider = NULL; 1642 options->enable_ssh_keysign = - 1; 1643 options->no_host_authentication_for_localhost = - 1; 1644 options->identities_only = - 1; 1645 options->rekey_limit = - 1; 1646 options->rekey_interval = -1; 1647 options->verify_host_key_dns = -1; 1648 options->server_alive_interval = -1; 1649 options->server_alive_count_max = -1; 1650 options->num_send_env = 0; 1651 options->control_path = NULL; 1652 options->control_master = -1; 1653 options->control_persist = -1; 1654 options->control_persist_timeout = 0; 1655 options->hash_known_hosts = -1; 1656 options->tun_open = -1; 1657 options->tun_local = -1; 1658 options->tun_remote = -1; 1659 options->local_command = NULL; 1660 options->permit_local_command = -1; 1661 options->use_roaming = 0; /* default off CVE-2016-0777,0778 */ 1662 options->visual_host_key = -1; 1663 options->ip_qos_interactive = -1; 1664 options->ip_qos_bulk = -1; 1665 options->request_tty = -1; 1666 options->version_addendum = NULL; 1667 options->none_switch = -1; 1668 options->none_enabled = -1; 1669 options->hpn_disabled = -1; 1670 options->hpn_buffer_size = -1; 1671 options->tcp_rcv_buf_poll = -1; 1672 options->tcp_rcv_buf = -1; 1673 options->proxy_use_fdpass = -1; 1674 options->ignored_unknown = NULL; 1675 options->num_canonical_domains = 0; 1676 options->num_permitted_cnames = 0; 1677 options->canonicalize_max_dots = -1; 1678 options->canonicalize_fallback_local = -1; 1679 options->canonicalize_hostname = -1; 1680 } 1681 1682 /* 1683 * A petite version of fill_default_options() that just fills the options 1684 * needed for hostname canonicalization to proceed. 1685 */ 1686 void 1687 fill_default_options_for_canonicalization(Options *options) 1688 { 1689 if (options->canonicalize_max_dots == -1) 1690 options->canonicalize_max_dots = 1; 1691 if (options->canonicalize_fallback_local == -1) 1692 options->canonicalize_fallback_local = 1; 1693 if (options->canonicalize_hostname == -1) 1694 options->canonicalize_hostname = SSH_CANONICALISE_NO; 1695 } 1696 1697 /* 1698 * Called after processing other sources of option data, this fills those 1699 * options for which no value has been specified with their default values. 1700 */ 1701 void 1702 fill_default_options(Options * options) 1703 { 1704 if (options->forward_agent == -1) 1705 options->forward_agent = 0; 1706 if (options->forward_x11 == -1) 1707 options->forward_x11 = 0; 1708 if (options->forward_x11_trusted == -1) 1709 options->forward_x11_trusted = 0; 1710 if (options->forward_x11_timeout == -1) 1711 options->forward_x11_timeout = 1200; 1712 if (options->exit_on_forward_failure == -1) 1713 options->exit_on_forward_failure = 0; 1714 if (options->xauth_location == NULL) 1715 options->xauth_location = _PATH_XAUTH; 1716 if (options->fwd_opts.gateway_ports == -1) 1717 options->fwd_opts.gateway_ports = 0; 1718 if (options->fwd_opts.streamlocal_bind_mask == (mode_t)-1) 1719 options->fwd_opts.streamlocal_bind_mask = 0177; 1720 if (options->fwd_opts.streamlocal_bind_unlink == -1) 1721 options->fwd_opts.streamlocal_bind_unlink = 0; 1722 if (options->use_privileged_port == -1) 1723 options->use_privileged_port = 0; 1724 if (options->rsa_authentication == -1) 1725 options->rsa_authentication = 1; 1726 if (options->pubkey_authentication == -1) 1727 options->pubkey_authentication = 1; 1728 if (options->challenge_response_authentication == -1) 1729 options->challenge_response_authentication = 1; 1730 if (options->gss_authentication == -1) 1731 options->gss_authentication = 0; 1732 if (options->gss_deleg_creds == -1) 1733 options->gss_deleg_creds = 0; 1734 if (options->password_authentication == -1) 1735 options->password_authentication = 1; 1736 if (options->kbd_interactive_authentication == -1) 1737 options->kbd_interactive_authentication = 1; 1738 if (options->rhosts_rsa_authentication == -1) 1739 options->rhosts_rsa_authentication = 0; 1740 if (options->hostbased_authentication == -1) 1741 options->hostbased_authentication = 0; 1742 if (options->batch_mode == -1) 1743 options->batch_mode = 0; 1744 if (options->check_host_ip == -1) 1745 options->check_host_ip = 0; 1746 if (options->strict_host_key_checking == -1) 1747 options->strict_host_key_checking = 2; /* 2 is default */ 1748 if (options->compression == -1) 1749 options->compression = 0; 1750 if (options->tcp_keep_alive == -1) 1751 options->tcp_keep_alive = 1; 1752 if (options->compression_level == -1) 1753 options->compression_level = 6; 1754 if (options->port == -1) 1755 options->port = 0; /* Filled in ssh_connect. */ 1756 if (options->address_family == -1) 1757 options->address_family = AF_UNSPEC; 1758 if (options->connection_attempts == -1) 1759 options->connection_attempts = 1; 1760 if (options->number_of_password_prompts == -1) 1761 options->number_of_password_prompts = 3; 1762 /* Selected in ssh_login(). */ 1763 if (options->cipher == -1) 1764 options->cipher = SSH_CIPHER_NOT_SET; 1765 /* options->ciphers, default set in myproposals.h */ 1766 /* options->macs, default set in myproposals.h */ 1767 /* options->kex_algorithms, default set in myproposals.h */ 1768 /* options->hostkeyalgorithms, default set in myproposals.h */ 1769 if (options->protocol == SSH_PROTO_UNKNOWN) 1770 options->protocol = SSH_PROTO_2; 1771 if (options->num_identity_files == 0) { 1772 if (options->protocol & SSH_PROTO_1) { 1773 add_identity_file(options, "~/", 1774 _PATH_SSH_CLIENT_IDENTITY, 0); 1775 } 1776 if (options->protocol & SSH_PROTO_2) { 1777 add_identity_file(options, "~/", 1778 _PATH_SSH_CLIENT_ID_RSA, 0); 1779 add_identity_file(options, "~/", 1780 _PATH_SSH_CLIENT_ID_DSA, 0); 1781 #ifdef OPENSSL_HAS_ECC 1782 add_identity_file(options, "~/", 1783 _PATH_SSH_CLIENT_ID_ECDSA, 0); 1784 #endif 1785 add_identity_file(options, "~/", 1786 _PATH_SSH_CLIENT_ID_ED25519, 0); 1787 } 1788 } 1789 if (options->escape_char == -1) 1790 options->escape_char = '~'; 1791 if (options->num_system_hostfiles == 0) { 1792 options->system_hostfiles[options->num_system_hostfiles++] = 1793 xstrdup(_PATH_SSH_SYSTEM_HOSTFILE); 1794 options->system_hostfiles[options->num_system_hostfiles++] = 1795 xstrdup(_PATH_SSH_SYSTEM_HOSTFILE2); 1796 } 1797 if (options->num_user_hostfiles == 0) { 1798 options->user_hostfiles[options->num_user_hostfiles++] = 1799 xstrdup(_PATH_SSH_USER_HOSTFILE); 1800 options->user_hostfiles[options->num_user_hostfiles++] = 1801 xstrdup(_PATH_SSH_USER_HOSTFILE2); 1802 } 1803 if (options->log_level == SYSLOG_LEVEL_NOT_SET) 1804 options->log_level = SYSLOG_LEVEL_INFO; 1805 if (options->clear_forwardings == 1) 1806 clear_forwardings(options); 1807 if (options->no_host_authentication_for_localhost == - 1) 1808 options->no_host_authentication_for_localhost = 0; 1809 if (options->identities_only == -1) 1810 options->identities_only = 0; 1811 if (options->enable_ssh_keysign == -1) 1812 options->enable_ssh_keysign = 0; 1813 if (options->rekey_limit == -1) 1814 options->rekey_limit = 0; 1815 if (options->rekey_interval == -1) 1816 options->rekey_interval = 0; 1817 if (options->verify_host_key_dns == -1) 1818 options->verify_host_key_dns = 0; 1819 if (options->server_alive_interval == -1) 1820 options->server_alive_interval = 0; 1821 if (options->server_alive_count_max == -1) 1822 options->server_alive_count_max = 3; 1823 if (options->version_addendum == NULL) 1824 options->version_addendum = xstrdup(SSH_VERSION_DRAGONFLY); 1825 if (options->none_switch == -1) 1826 options->none_switch = 0; 1827 if (options->none_enabled == -1) 1828 options->none_enabled = 0; 1829 if (options->hpn_disabled == -1) 1830 options->hpn_disabled = 0; 1831 if (options->hpn_buffer_size > -1) 1832 { 1833 /* if a user tries to set the size to 0 set it to 1KB */ 1834 if (options->hpn_buffer_size == 0) 1835 options->hpn_buffer_size = 1; 1836 /*limit the buffer to 64MB*/ 1837 if (options->hpn_buffer_size > 64*1024) 1838 { 1839 options->hpn_buffer_size = 64*1024*1024; 1840 debug("User requested buffer larger than 64MB. Request reverted to 64MB"); 1841 } 1842 else options->hpn_buffer_size *= 1024; 1843 debug("hpn_buffer_size set to %d", options->hpn_buffer_size); 1844 } 1845 if (options->tcp_rcv_buf == 0) 1846 options->tcp_rcv_buf = 1; 1847 if (options->tcp_rcv_buf > -1) 1848 options->tcp_rcv_buf *=1024; 1849 if (options->tcp_rcv_buf_poll == -1) 1850 options->tcp_rcv_buf_poll = 1; 1851 if (options->control_master == -1) 1852 options->control_master = 0; 1853 if (options->control_persist == -1) { 1854 options->control_persist = 0; 1855 options->control_persist_timeout = 0; 1856 } 1857 if (options->hash_known_hosts == -1) 1858 options->hash_known_hosts = 0; 1859 if (options->tun_open == -1) 1860 options->tun_open = SSH_TUNMODE_NO; 1861 if (options->tun_local == -1) 1862 options->tun_local = SSH_TUNID_ANY; 1863 if (options->tun_remote == -1) 1864 options->tun_remote = SSH_TUNID_ANY; 1865 if (options->permit_local_command == -1) 1866 options->permit_local_command = 0; 1867 options->use_roaming = 0; /* force off CVE-2016-0777,0778 */ 1868 if (options->visual_host_key == -1) 1869 options->visual_host_key = 0; 1870 if (options->ip_qos_interactive == -1) 1871 options->ip_qos_interactive = IPTOS_LOWDELAY; 1872 if (options->ip_qos_bulk == -1) 1873 options->ip_qos_bulk = IPTOS_THROUGHPUT; 1874 if (options->request_tty == -1) 1875 options->request_tty = REQUEST_TTY_AUTO; 1876 if (options->proxy_use_fdpass == -1) 1877 options->proxy_use_fdpass = 0; 1878 if (options->canonicalize_max_dots == -1) 1879 options->canonicalize_max_dots = 1; 1880 if (options->canonicalize_fallback_local == -1) 1881 options->canonicalize_fallback_local = 1; 1882 if (options->canonicalize_hostname == -1) 1883 options->canonicalize_hostname = SSH_CANONICALISE_NO; 1884 #define CLEAR_ON_NONE(v) \ 1885 do { \ 1886 if (option_clear_or_none(v)) { \ 1887 free(v); \ 1888 v = NULL; \ 1889 } \ 1890 } while(0) 1891 CLEAR_ON_NONE(options->local_command); 1892 CLEAR_ON_NONE(options->proxy_command); 1893 CLEAR_ON_NONE(options->control_path); 1894 /* options->user will be set in the main program if appropriate */ 1895 /* options->hostname will be set in the main program if appropriate */ 1896 /* options->host_key_alias should not be set by default */ 1897 /* options->preferred_authentications will be set in ssh */ 1898 } 1899 1900 struct fwdarg { 1901 char *arg; 1902 int ispath; 1903 }; 1904 1905 /* 1906 * parse_fwd_field 1907 * parses the next field in a port forwarding specification. 1908 * sets fwd to the parsed field and advances p past the colon 1909 * or sets it to NULL at end of string. 1910 * returns 0 on success, else non-zero. 1911 */ 1912 static int 1913 parse_fwd_field(char **p, struct fwdarg *fwd) 1914 { 1915 char *ep, *cp = *p; 1916 int ispath = 0; 1917 1918 if (*cp == '\0') { 1919 *p = NULL; 1920 return -1; /* end of string */ 1921 } 1922 1923 /* 1924 * A field escaped with square brackets is used literally. 1925 * XXX - allow ']' to be escaped via backslash? 1926 */ 1927 if (*cp == '[') { 1928 /* find matching ']' */ 1929 for (ep = cp + 1; *ep != ']' && *ep != '\0'; ep++) { 1930 if (*ep == '/') 1931 ispath = 1; 1932 } 1933 /* no matching ']' or not at end of field. */ 1934 if (ep[0] != ']' || (ep[1] != ':' && ep[1] != '\0')) 1935 return -1; 1936 /* NUL terminate the field and advance p past the colon */ 1937 *ep++ = '\0'; 1938 if (*ep != '\0') 1939 *ep++ = '\0'; 1940 fwd->arg = cp + 1; 1941 fwd->ispath = ispath; 1942 *p = ep; 1943 return 0; 1944 } 1945 1946 for (cp = *p; *cp != '\0'; cp++) { 1947 switch (*cp) { 1948 case '\\': 1949 memmove(cp, cp + 1, strlen(cp + 1) + 1); 1950 cp++; 1951 break; 1952 case '/': 1953 ispath = 1; 1954 break; 1955 case ':': 1956 *cp++ = '\0'; 1957 goto done; 1958 } 1959 } 1960 done: 1961 fwd->arg = *p; 1962 fwd->ispath = ispath; 1963 *p = cp; 1964 return 0; 1965 } 1966 1967 /* 1968 * parse_forward 1969 * parses a string containing a port forwarding specification of the form: 1970 * dynamicfwd == 0 1971 * [listenhost:]listenport|listenpath:connecthost:connectport|connectpath 1972 * listenpath:connectpath 1973 * dynamicfwd == 1 1974 * [listenhost:]listenport 1975 * returns number of arguments parsed or zero on error 1976 */ 1977 int 1978 parse_forward(struct Forward *fwd, const char *fwdspec, int dynamicfwd, int remotefwd) 1979 { 1980 struct fwdarg fwdargs[4]; 1981 char *p, *cp; 1982 int i; 1983 1984 memset(fwd, 0, sizeof(*fwd)); 1985 memset(fwdargs, 0, sizeof(fwdargs)); 1986 1987 cp = p = xstrdup(fwdspec); 1988 1989 /* skip leading spaces */ 1990 while (isspace((u_char)*cp)) 1991 cp++; 1992 1993 for (i = 0; i < 4; ++i) { 1994 if (parse_fwd_field(&cp, &fwdargs[i]) != 0) 1995 break; 1996 } 1997 1998 /* Check for trailing garbage */ 1999 if (cp != NULL && *cp != '\0') { 2000 i = 0; /* failure */ 2001 } 2002 2003 switch (i) { 2004 case 1: 2005 if (fwdargs[0].ispath) { 2006 fwd->listen_path = xstrdup(fwdargs[0].arg); 2007 fwd->listen_port = PORT_STREAMLOCAL; 2008 } else { 2009 fwd->listen_host = NULL; 2010 fwd->listen_port = a2port(fwdargs[0].arg); 2011 } 2012 fwd->connect_host = xstrdup("socks"); 2013 break; 2014 2015 case 2: 2016 if (fwdargs[0].ispath && fwdargs[1].ispath) { 2017 fwd->listen_path = xstrdup(fwdargs[0].arg); 2018 fwd->listen_port = PORT_STREAMLOCAL; 2019 fwd->connect_path = xstrdup(fwdargs[1].arg); 2020 fwd->connect_port = PORT_STREAMLOCAL; 2021 } else if (fwdargs[1].ispath) { 2022 fwd->listen_host = NULL; 2023 fwd->listen_port = a2port(fwdargs[0].arg); 2024 fwd->connect_path = xstrdup(fwdargs[1].arg); 2025 fwd->connect_port = PORT_STREAMLOCAL; 2026 } else { 2027 fwd->listen_host = xstrdup(fwdargs[0].arg); 2028 fwd->listen_port = a2port(fwdargs[1].arg); 2029 fwd->connect_host = xstrdup("socks"); 2030 } 2031 break; 2032 2033 case 3: 2034 if (fwdargs[0].ispath) { 2035 fwd->listen_path = xstrdup(fwdargs[0].arg); 2036 fwd->listen_port = PORT_STREAMLOCAL; 2037 fwd->connect_host = xstrdup(fwdargs[1].arg); 2038 fwd->connect_port = a2port(fwdargs[2].arg); 2039 } else if (fwdargs[2].ispath) { 2040 fwd->listen_host = xstrdup(fwdargs[0].arg); 2041 fwd->listen_port = a2port(fwdargs[1].arg); 2042 fwd->connect_path = xstrdup(fwdargs[2].arg); 2043 fwd->connect_port = PORT_STREAMLOCAL; 2044 } else { 2045 fwd->listen_host = NULL; 2046 fwd->listen_port = a2port(fwdargs[0].arg); 2047 fwd->connect_host = xstrdup(fwdargs[1].arg); 2048 fwd->connect_port = a2port(fwdargs[2].arg); 2049 } 2050 break; 2051 2052 case 4: 2053 fwd->listen_host = xstrdup(fwdargs[0].arg); 2054 fwd->listen_port = a2port(fwdargs[1].arg); 2055 fwd->connect_host = xstrdup(fwdargs[2].arg); 2056 fwd->connect_port = a2port(fwdargs[3].arg); 2057 break; 2058 default: 2059 i = 0; /* failure */ 2060 } 2061 2062 free(p); 2063 2064 if (dynamicfwd) { 2065 if (!(i == 1 || i == 2)) 2066 goto fail_free; 2067 } else { 2068 if (!(i == 3 || i == 4)) { 2069 if (fwd->connect_path == NULL && 2070 fwd->listen_path == NULL) 2071 goto fail_free; 2072 } 2073 if (fwd->connect_port <= 0 && fwd->connect_path == NULL) 2074 goto fail_free; 2075 } 2076 2077 if ((fwd->listen_port < 0 && fwd->listen_path == NULL) || 2078 (!remotefwd && fwd->listen_port == 0)) 2079 goto fail_free; 2080 if (fwd->connect_host != NULL && 2081 strlen(fwd->connect_host) >= NI_MAXHOST) 2082 goto fail_free; 2083 /* XXX - if connecting to a remote socket, max sun len may not match this host */ 2084 if (fwd->connect_path != NULL && 2085 strlen(fwd->connect_path) >= PATH_MAX_SUN) 2086 goto fail_free; 2087 if (fwd->listen_host != NULL && 2088 strlen(fwd->listen_host) >= NI_MAXHOST) 2089 goto fail_free; 2090 if (fwd->listen_path != NULL && 2091 strlen(fwd->listen_path) >= PATH_MAX_SUN) 2092 goto fail_free; 2093 2094 return (i); 2095 2096 fail_free: 2097 free(fwd->connect_host); 2098 fwd->connect_host = NULL; 2099 free(fwd->connect_path); 2100 fwd->connect_path = NULL; 2101 free(fwd->listen_host); 2102 fwd->listen_host = NULL; 2103 free(fwd->listen_path); 2104 fwd->listen_path = NULL; 2105 return (0); 2106 } 2107