lib/libfetch/common.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  *
   4  * Copyright (c) 1998-2016 Dag-Erling Smørgrav
   5  * Copyright (c) 2013 Michael Gmelin <freebsd@grem.de>
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer
  13  *    in this position and unchanged.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 3. The name of the author may not be used to endorse or promote products
  18  *    derived from this software without specific prior written permission
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  21  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  22  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  23  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  24  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  25  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  29  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 #include <sys/param.h>
  34 #include <sys/socket.h>
  35 #include <sys/time.h>
  36 #include <sys/uio.h>
  37
  38 #include <netinet/in.h>
  39
  40 #include <ctype.h>
  41 #include <errno.h>
  42 #include <fcntl.h>
  43 #include <inttypes.h>
  44 #include <netdb.h>
  45 #include <paths.h>
  46 #include <poll.h>
  47 #include <pwd.h>
  48 #include <stdarg.h>
  49 #include <stdlib.h>
  50 #include <stdio.h>
  51 #include <string.h>
  52 #include <unistd.h>
  53
  54 #ifdef WITH_SSL
  55 #include <openssl/x509v3.h>
  56 #endif
  57
  58 #include "fetch.h"
  59 #include "common.h"
  60
  61
  62 /*** Local data **************************************************************/
  63
  64 /*
  65  * Error messages for resolver errors
  66  */
  67 static struct fetcherr netdb_errlist[] = {
  68 #ifdef EAI_ADDRFAMILY
  69         { EAI_ADDRFAMILY, FETCH_RESOLV, "Address family for host not supported" },
  70 #endif
  71 #ifdef EAI_NODATA
  72         { EAI_NODATA,   FETCH_RESOLV,   "No address for host" },
  73 #endif
  74         { EAI_AGAIN,    FETCH_TEMP,     "Transient resolver failure" },
  75         { EAI_FAIL,     FETCH_RESOLV,   "Non-recoverable resolver failure" },
  76         { EAI_NONAME,   FETCH_RESOLV,   "Host does not resolve" },
  77         { -1,           FETCH_UNKNOWN,  "Unknown resolver error" }
  78 };
  79
  80 /*
  81  * SOCKS5 error enumerations
  82  */
  83 enum SOCKS5_ERR {
  84 /* Protocol errors */
  85         SOCKS5_ERR_SELECTION,
  86         SOCKS5_ERR_READ_METHOD,
  87         SOCKS5_ERR_VER5_ONLY,
  88         SOCKS5_ERR_NOMETHODS,
  89         SOCKS5_ERR_NOTIMPLEMENTED,
  90         SOCKS5_ERR_HOSTNAME_SIZE,
  91         SOCKS5_ERR_REQUEST,
  92         SOCKS5_ERR_REPLY,
  93         SOCKS5_ERR_NON_VER5_RESP,
  94         SOCKS5_ERR_GENERAL,
  95         SOCKS5_ERR_NOT_ALLOWED,
  96         SOCKS5_ERR_NET_UNREACHABLE,
  97         SOCKS5_ERR_HOST_UNREACHABLE,
  98         SOCKS5_ERR_CONN_REFUSED,
  99         SOCKS5_ERR_TTL_EXPIRED,
 100         SOCKS5_ERR_COM_UNSUPPORTED,
 101         SOCKS5_ERR_ADDR_UNSUPPORTED,
 102         SOCKS5_ERR_UNSPECIFIED,
 103 /* Configuration errors */
 104         SOCKS5_ERR_BAD_HOST,
 105         SOCKS5_ERR_BAD_PROXY_FORMAT,
 106         SOCKS5_ERR_BAD_PORT
 107 };
 108
 109 /*
 110  * Error messages for SOCKS5 errors
 111  */
 112 static struct fetcherr socks5_errlist[] = {
 113 /* SOCKS5 protocol errors */
 114         { SOCKS5_ERR_SELECTION,         FETCH_ABORT,    "SOCKS5: Failed to send selection method" },
 115         { SOCKS5_ERR_READ_METHOD,       FETCH_ABORT,    "SOCKS5: Failed to read method" },
 116         { SOCKS5_ERR_VER5_ONLY,         FETCH_PROTO,    "SOCKS5: Only version 5 is implemented" },
 117         { SOCKS5_ERR_NOMETHODS,         FETCH_PROTO,    "SOCKS5: No acceptable methods" },
 118         { SOCKS5_ERR_NOTIMPLEMENTED,    FETCH_PROTO,    "SOCKS5: Method currently not implemented" },
 119         { SOCKS5_ERR_HOSTNAME_SIZE,     FETCH_PROTO,    "SOCKS5: Hostname size is above 256 bytes" },
 120         { SOCKS5_ERR_REQUEST,           FETCH_PROTO,    "SOCKS5: Failed to request" },
 121         { SOCKS5_ERR_REPLY,             FETCH_PROTO,    "SOCKS5: Failed to receive reply" },
 122         { SOCKS5_ERR_NON_VER5_RESP,     FETCH_PROTO,    "SOCKS5: Server responded with a non-version 5 response" },
 123         { SOCKS5_ERR_GENERAL,           FETCH_ABORT,    "SOCKS5: General server failure" },
 124         { SOCKS5_ERR_NOT_ALLOWED,       FETCH_AUTH,     "SOCKS5: Connection not allowed by ruleset" },
 125         { SOCKS5_ERR_NET_UNREACHABLE,   FETCH_NETWORK,  "SOCKS5: Network unreachable" },
 126         { SOCKS5_ERR_HOST_UNREACHABLE,  FETCH_ABORT,    "SOCKS5: Host unreachable" },
 127         { SOCKS5_ERR_CONN_REFUSED,      FETCH_ABORT,    "SOCKS5: Connection refused" },
 128         { SOCKS5_ERR_TTL_EXPIRED,       FETCH_TIMEOUT,  "SOCKS5: TTL expired" },
 129         { SOCKS5_ERR_COM_UNSUPPORTED,   FETCH_PROTO,    "SOCKS5: Command not supported" },
 130         { SOCKS5_ERR_ADDR_UNSUPPORTED,  FETCH_ABORT,    "SOCKS5: Address type not supported" },
 131         { SOCKS5_ERR_UNSPECIFIED,       FETCH_UNKNOWN,  "SOCKS5: Unspecified error" },
 132 /* Configuration error */
 133         { SOCKS5_ERR_BAD_HOST,          FETCH_ABORT,    "SOCKS5: Bad proxy host" },
 134         { SOCKS5_ERR_BAD_PROXY_FORMAT,  FETCH_ABORT,    "SOCKS5: Bad proxy format" },
 135         { SOCKS5_ERR_BAD_PORT,          FETCH_ABORT,    "SOCKS5: Bad port" }
 136 };
 137
 138 /* End-of-Line */
 139 static const char ENDL[2] = "\r\n";
 140
 141
 142 /*** Error-reporting functions ***********************************************/
 143
 144 /*
 145  * Map error code to string
 146  */
 147 static struct fetcherr *
 148 fetch_finderr(struct fetcherr *p, int e)
 149 {
 150         while (p->num != -1 && p->num != e)
 151                 p++;
 152         return (p);
 153 }
 154
 155 /*
 156  * Set error code
 157  */
 158 void
 159 fetch_seterr(struct fetcherr *p, int e)
 160 {
 161         p = fetch_finderr(p, e);
 162         fetchLastErrCode = p->cat;
 163         snprintf(fetchLastErrString, MAXERRSTRING, "%s", p->string);
 164 }
 165
 166 /*
 167  * Set error code according to errno
 168  */
 169 void
 170 fetch_syserr(void)
 171 {
 172         switch (errno) {
 173         case 0:
 174                 fetchLastErrCode = FETCH_OK;
 175                 break;
 176         case EPERM:
 177         case EACCES:
 178         case EROFS:
 179         case EAUTH:
 180         case ENEEDAUTH:
 181                 fetchLastErrCode = FETCH_AUTH;
 182                 break;
 183         case ENOENT:
 184         case EISDIR: /* XXX */
 185                 fetchLastErrCode = FETCH_UNAVAIL;
 186                 break;
 187         case ENOMEM:
 188                 fetchLastErrCode = FETCH_MEMORY;
 189                 break;
 190         case EBUSY:
 191         case EAGAIN:
 192                 fetchLastErrCode = FETCH_TEMP;
 193                 break;
 194         case EEXIST:
 195                 fetchLastErrCode = FETCH_EXISTS;
 196                 break;
 197         case ENOSPC:
 198                 fetchLastErrCode = FETCH_FULL;
 199                 break;
 200         case EADDRINUSE:
 201         case EADDRNOTAVAIL:
 202         case ENETDOWN:
 203         case ENETUNREACH:
 204         case ENETRESET:
 205         case EHOSTUNREACH:
 206                 fetchLastErrCode = FETCH_NETWORK;
 207                 break;
 208         case ECONNABORTED:
 209         case ECONNRESET:
 210                 fetchLastErrCode = FETCH_ABORT;
 211                 break;
 212         case ETIMEDOUT:
 213                 fetchLastErrCode = FETCH_TIMEOUT;
 214                 break;
 215         case ECONNREFUSED:
 216         case EHOSTDOWN:
 217                 fetchLastErrCode = FETCH_DOWN;
 218                 break;
 219         default:
 220                 fetchLastErrCode = FETCH_UNKNOWN;
 221         }
 222         snprintf(fetchLastErrString, MAXERRSTRING, "%s", strerror(errno));
 223 }
 224
 225
 226 /*
 227  * Emit status message
 228  */
 229 void
 230 fetch_info(const char *fmt, ...)
 231 {
 232         va_list ap;
 233
 234         va_start(ap, fmt);
 235         vfprintf(stderr, fmt, ap);
 236         va_end(ap);
 237         fputc('\n', stderr);
 238 }
 239
 240
 241 /*** Network-related utility functions ***************************************/
 242
 243 /*
 244  * Return the default port for a scheme
 245  */
 246 int
 247 fetch_default_port(const char *scheme)
 248 {
 249         struct servent *se;
 250
 251         if ((se = getservbyname(scheme, "tcp")) != NULL)
 252                 return (ntohs(se->s_port));
 253         if (strcmp(scheme, SCHEME_FTP) == 0)
 254                 return (FTP_DEFAULT_PORT);
 255         if (strcmp(scheme, SCHEME_HTTP) == 0)
 256                 return (HTTP_DEFAULT_PORT);
 257         return (0);
 258 }
 259
 260 /*
 261  * Return the default proxy port for a scheme
 262  */
 263 int
 264 fetch_default_proxy_port(const char *scheme)
 265 {
 266         if (strcmp(scheme, SCHEME_FTP) == 0)
 267                 return (FTP_DEFAULT_PROXY_PORT);
 268         if (strcmp(scheme, SCHEME_HTTP) == 0)
 269                 return (HTTP_DEFAULT_PROXY_PORT);
 270         return (0);
 271 }
 272
 273
 274 /*
 275  * Create a connection for an existing descriptor.
 276  */
 277 conn_t *
 278 fetch_reopen(int sd)
 279 {
 280         conn_t *conn;
 281         int opt = 1;
 282
 283         /* allocate and fill connection structure */
 284         if ((conn = calloc(1, sizeof(*conn))) == NULL)
 285                 return (NULL);
 286         fcntl(sd, F_SETFD, FD_CLOEXEC);
 287         setsockopt(sd, SOL_SOCKET, SO_NOSIGPIPE, &opt, sizeof opt);
 288         conn->sd = sd;
 289         ++conn->ref;
 290         return (conn);
 291 }
 292
 293
 294 /*
 295  * Bump a connection's reference count.
 296  */
 297 conn_t *
 298 fetch_ref(conn_t *conn)
 299 {
 300
 301         ++conn->ref;
 302         return (conn);
 303 }
 304
 305
 306 /*
 307  * Resolve an address
 308  */
 309 struct addrinfo *
 310 fetch_resolve(const char *addr, int port, int af)
 311 {
 312         char hbuf[256], sbuf[8];
 313         struct addrinfo hints, *res;
 314         const char *hb, *he, *sep;
 315         const char *host, *service;
 316         int err, len;
 317
 318         /* first, check for a bracketed IPv6 address */
 319         if (*addr == '[') {
 320                 hb = addr + 1;
 321                 if ((sep = strchr(hb, ']')) == NULL) {
 322                         errno = EINVAL;
 323                         goto syserr;
 324                 }
 325                 he = sep++;
 326         } else {
 327                 hb = addr;
 328                 sep = strchrnul(hb, ':');
 329                 he = sep;
 330         }
 331
 332         /* see if we need to copy the host name */
 333         if (*he != '\0') {
 334                 len = snprintf(hbuf, sizeof(hbuf),
 335                     "%.*s", (int)(he - hb), hb);
 336                 if (len < 0)
 337                         goto syserr;
 338                 if (len >= (int)sizeof(hbuf)) {
 339                         errno = ENAMETOOLONG;
 340                         goto syserr;
 341                 }
 342                 host = hbuf;
 343         } else {
 344                 host = hb;
 345         }
 346
 347         /* was it followed by a service name? */
 348         if (*sep == '\0' && port != 0) {
 349                 if (port < 1 || port > 65535) {
 350                         errno = EINVAL;
 351                         goto syserr;
 352                 }
 353                 if (snprintf(sbuf, sizeof(sbuf), "%d", port) < 0)
 354                         goto syserr;
 355                 service = sbuf;
 356         } else if (*sep != '\0') {
 357                 service = sep + 1;
 358         } else {
 359                 service = NULL;
 360         }
 361
 362         /* resolve */
 363         memset(&hints, 0, sizeof(hints));
 364         hints.ai_family = af;
 365         hints.ai_socktype = SOCK_STREAM;
 366         hints.ai_flags = AI_ADDRCONFIG;
 367         if ((err = getaddrinfo(host, service, &hints, &res)) != 0) {
 368                 netdb_seterr(err);
 369                 return (NULL);
 370         }
 371         return (res);
 372 syserr:
 373         fetch_syserr();
 374         return (NULL);
 375 }
 376
 377
 378 /*
 379  * Bind a socket to a specific local address
 380  */
 381 int
 382 fetch_bind(int sd, int af, const char *addr)
 383 {
 384         struct addrinfo *cliai, *ai;
 385         int err;
 386
 387         if ((cliai = fetch_resolve(addr, 0, af)) == NULL)
 388                 return (-1);
 389         for (ai = cliai; ai != NULL; ai = ai->ai_next)
 390                 if ((err = bind(sd, ai->ai_addr, ai->ai_addrlen)) == 0)
 391                         break;
 392         if (err != 0)
 393                 fetch_syserr();
 394         freeaddrinfo(cliai);
 395         return (err == 0 ? 0 : -1);
 396 }
 397
 398
 399 /*
 400  * SOCKS5 connection initiation, based on RFC 1928
 401  * Default DNS resolution over SOCKS5
 402  */
 403 int
 404 fetch_socks5_init(conn_t *conn, const char *host, int port, int verbose)
 405 {
 406         /*
 407          * Size is based on largest packet prefix (4 bytes) +
 408          * Largest FQDN (256) + one byte size (1) +
 409          * Port (2)
 410          */
 411         unsigned char buf[BUFF_SIZE];
 412         unsigned char *ptr;
 413         int ret = 1;
 414
 415         if (verbose)
 416                 fetch_info("Initializing SOCKS5 connection: %s:%d", host, port);
 417
 418         /* Connection initialization */
 419         ptr = buf;
 420         *ptr++ = SOCKS_VERSION_5;
 421         *ptr++ = SOCKS_CONNECTION;
 422         *ptr++ = SOCKS_RSV;
 423
 424         if (fetch_write(conn, buf, 3) != 3) {
 425                 ret = SOCKS5_ERR_SELECTION;
 426                 goto fail;
 427         }
 428
 429         /* Verify response from SOCKS5 server */
 430         if (fetch_read(conn, buf, 2) != 2) {
 431                 ret = SOCKS5_ERR_READ_METHOD;
 432                 goto fail;
 433         }
 434
 435         ptr = buf;
 436         if (ptr[0] != SOCKS_VERSION_5) {
 437                 ret = SOCKS5_ERR_VER5_ONLY;
 438                 goto fail;
 439         }
 440         if (ptr[1] == SOCKS_NOMETHODS) {
 441                 ret = SOCKS5_ERR_NOMETHODS;
 442                 goto fail;
 443         }
 444         else if (ptr[1] != SOCKS5_NOTIMPLEMENTED) {
 445                 ret = SOCKS5_ERR_NOTIMPLEMENTED;
 446                 goto fail;
 447         }
 448
 449         /* Send Request */
 450         *ptr++ = SOCKS_VERSION_5;
 451         *ptr++ = SOCKS_CONNECTION;
 452         *ptr++ = SOCKS_RSV;
 453         /* Encode all targets as a hostname to avoid DNS leaks */
 454         *ptr++ = SOCKS_ATYP_DOMAINNAME;
 455         if (strlen(host) > FQDN_SIZE) {
 456                 ret = SOCKS5_ERR_HOSTNAME_SIZE;
 457                 goto fail;
 458         }
 459         *ptr++ = strlen(host);
 460         memcpy(ptr, host, strlen(host));
 461         ptr = ptr + strlen(host);
 462
 463         port = htons(port);
 464         *ptr++ = port & 0x00ff;
 465         *ptr++ = (port & 0xff00) >> 8;
 466
 467         if (fetch_write(conn, buf, ptr - buf) != ptr - buf) {
 468                 ret = SOCKS5_ERR_REQUEST;
 469                 goto fail;
 470         }
 471
 472         /* BND.ADDR is variable length, read the largest on non-blocking socket */
 473         if (!fetch_read(conn, buf, BUFF_SIZE)) {
 474                 ret = SOCKS5_ERR_REPLY;
 475                 goto fail;
 476         }
 477
 478         ptr = buf;
 479         if (*ptr++ != SOCKS_VERSION_5) {
 480                 ret = SOCKS5_ERR_NON_VER5_RESP;
 481                 goto fail;
 482         }
 483
 484         switch(*ptr++) {
 485         case SOCKS_SUCCESS:
 486                 break;
 487         case SOCKS_GENERAL_FAILURE:
 488                 ret = SOCKS5_ERR_GENERAL;
 489                 goto fail;
 490         case SOCKS_CONNECTION_NOT_ALLOWED:
 491                 ret = SOCKS5_ERR_NOT_ALLOWED;
 492                 goto fail;
 493         case SOCKS_NETWORK_UNREACHABLE:
 494                 ret = SOCKS5_ERR_NET_UNREACHABLE;
 495                 goto fail;
 496         case SOCKS_HOST_UNREACHABLE:
 497                 ret = SOCKS5_ERR_HOST_UNREACHABLE;
 498                 goto fail;
 499         case SOCKS_CONNECTION_REFUSED:
 500                 ret = SOCKS5_ERR_CONN_REFUSED;
 501                 goto fail;
 502         case SOCKS_TTL_EXPIRED:
 503                 ret = SOCKS5_ERR_TTL_EXPIRED;
 504                 goto fail;
 505         case SOCKS_COMMAND_NOT_SUPPORTED:
 506                 ret = SOCKS5_ERR_COM_UNSUPPORTED;
 507                 goto fail;
 508         case SOCKS_ADDRESS_NOT_SUPPORTED:
 509                 ret = SOCKS5_ERR_ADDR_UNSUPPORTED;
 510                 goto fail;
 511         default:
 512                 ret = SOCKS5_ERR_UNSPECIFIED;
 513                 goto fail;
 514         }
 515
 516         return (ret);
 517
 518 fail:
 519         socks5_seterr(ret);
 520         return (0);
 521 }
 522
 523 /*
 524  * Perform SOCKS5 initialization
 525  */
 526 int
 527 fetch_socks5_getenv(char **host, int *port)
 528 {
 529         char *socks5env, *endptr, *ext;
 530         const char *portDelim;
 531         size_t slen;
 532
 533         portDelim = ":";
 534         if ((socks5env = getenv("SOCKS5_PROXY")) == NULL || *socks5env == '\0') {
 535                 *host = NULL;
 536                 *port = -1;
 537                 return (-1);
 538         }
 539
 540         /*
 541          * IPv6 addresses begin and end in brackets.  Set the port delimiter
 542          * accordingly and search for it so we can do appropriate validation.
 543          */
 544         if (socks5env[0] == '[')
 545                 portDelim = "]:";
 546
 547         slen = strlen(socks5env);
 548         ext = strstr(socks5env, portDelim);
 549         if (socks5env[0] == '[') {
 550                 if (socks5env[slen - 1] == ']') {
 551                         *host = strndup(socks5env, slen);
 552                 } else if (ext != NULL) {
 553                         *host = strndup(socks5env, ext - socks5env + 1);
 554                 } else {
 555                         socks5_seterr(SOCKS5_ERR_BAD_PROXY_FORMAT);
 556                         return (0);
 557                 }
 558         } else {
 559                 *host = strndup(socks5env, ext - socks5env);
 560         }
 561
 562         if (*host == NULL) {
 563                 fprintf(stderr, "Failure to allocate memory, exiting.\n");
 564                 return (-1);
 565         }
 566         if (ext == NULL) {
 567                 *port = 1080; /* Default port as defined in RFC1928 */
 568         } else {
 569                 ext += strlen(portDelim);
 570                 errno = 0;
 571                 *port = strtoimax(ext, (char **)&endptr, 10);
 572                 if (*endptr != '\0' || errno != 0 || *port < 0 ||
 573                     *port > 65535) {
 574                         free(*host);
 575                         *host = NULL;
 576                         socks5_seterr(SOCKS5_ERR_BAD_PORT);
 577                         return (0);
 578                 }
 579         }
 580
 581         return (2);
 582 }
 583
 584
 585 /*
 586  * Establish a TCP connection to the specified port on the specified host.
 587  */
 588 conn_t *
 589 fetch_connect(const char *host, int port, int af, int verbose)
 590 {
 591         struct addrinfo *cais = NULL, *sais = NULL, *cai, *sai;
 592         const char *bindaddr;
 593         conn_t *conn = NULL;
 594         int err = 0, sd = -1;
 595         char *sockshost;
 596         int socksport;
 597
 598         DEBUGF("---> %s:%d\n", host, port);
 599
 600         /*
 601          * Check if SOCKS5_PROXY env variable is set.  fetch_socks5_getenv
 602          * will either set sockshost = NULL or allocate memory in all cases.
 603          */
 604         sockshost = NULL;
 605         if (!fetch_socks5_getenv(&sockshost, &socksport))
 606                 goto fail;
 607
 608         /* Not using SOCKS5 proxy */
 609         if (sockshost == NULL) {
 610                 /* resolve server address */
 611                 if (verbose)
 612                         fetch_info("resolving server address: %s:%d", host,
 613                             port);
 614                 if ((sais = fetch_resolve(host, port, af)) == NULL)
 615                         goto fail;
 616
 617                 /* resolve client address */
 618                 bindaddr = getenv("FETCH_BIND_ADDRESS");
 619                 if (bindaddr != NULL && *bindaddr != '\0') {
 620                         if (verbose)
 621                                 fetch_info("resolving client address: %s",
 622                                     bindaddr);
 623                         if ((cais = fetch_resolve(bindaddr, 0, af)) == NULL)
 624                                 goto fail;
 625                 }
 626         } else {
 627                 /* resolve socks5 proxy address */
 628                 if (verbose)
 629                         fetch_info("resolving SOCKS5 server address: %s:%d",
 630                             sockshost, socksport);
 631                 if ((sais = fetch_resolve(sockshost, socksport, af)) == NULL) {
 632                         socks5_seterr(SOCKS5_ERR_BAD_HOST);
 633                         goto fail;
 634                 }
 635         }
 636
 637         /* try each server address in turn */
 638         for (err = 0, sai = sais; sai != NULL; sai = sai->ai_next) {
 639                 /* open socket */
 640                 if ((sd = socket(sai->ai_family, SOCK_STREAM, 0)) < 0)
 641                         goto syserr;
 642                 /* attempt to bind to client address */
 643                 for (err = 0, cai = cais; cai != NULL; cai = cai->ai_next) {
 644                         if (cai->ai_family != sai->ai_family)
 645                                 continue;
 646                         if ((err = bind(sd, cai->ai_addr, cai->ai_addrlen)) == 0)
 647                                 break;
 648                 }
 649                 if (err != 0) {
 650                         if (verbose)
 651                                 fetch_info("failed to bind to %s", bindaddr);
 652                         goto syserr;
 653                 }
 654                 /* attempt to connect to server address */
 655                 if ((err = connect(sd, sai->ai_addr, sai->ai_addrlen)) == 0)
 656                         break;
 657                 /* clean up before next attempt */
 658                 close(sd);
 659                 sd = -1;
 660         }
 661         if (err != 0) {
 662                 if (verbose && sockshost == NULL) {
 663                         fetch_info("failed to connect to %s:%d", host, port);
 664                         goto syserr;
 665                 } else if (sockshost != NULL) {
 666                         if (verbose)
 667                                 fetch_info(
 668                                     "failed to connect to SOCKS5 server %s:%d",
 669                                     sockshost, socksport);
 670                         socks5_seterr(SOCKS5_ERR_CONN_REFUSED);
 671                         goto fail;
 672                 }
 673                 goto syserr;
 674         }
 675
 676         if ((conn = fetch_reopen(sd)) == NULL)
 677                 goto syserr;
 678
 679         if (sockshost)
 680                 if (!fetch_socks5_init(conn, host, port, verbose))
 681                         goto fail;
 682         free(sockshost);
 683         if (cais != NULL)
 684                 freeaddrinfo(cais);
 685         if (sais != NULL)
 686                 freeaddrinfo(sais);
 687         return (conn);
 688 syserr:
 689         fetch_syserr();
 690 fail:
 691         free(sockshost);
 692         /* Fully close if it was opened; otherwise just don't leak the fd. */
 693         if (conn != NULL)
 694                 fetch_close(conn);
 695         else if (sd >= 0)
 696                 close(sd);
 697         if (cais != NULL)
 698                 freeaddrinfo(cais);
 699         if (sais != NULL)
 700                 freeaddrinfo(sais);
 701         return (NULL);
 702 }
 703
 704 #ifdef WITH_SSL
 705 /*
 706  * Convert characters A-Z to lowercase (intentionally avoid any locale
 707  * specific conversions).
 708  */
 709 static char
 710 fetch_ssl_tolower(char in)
 711 {
 712         if (in >= 'A' && in <= 'Z')
 713                 return (in + 32);
 714         else
 715                 return (in);
 716 }
 717
 718 /*
 719  * isalpha implementation that intentionally avoids any locale specific
 720  * conversions.
 721  */
 722 static int
 723 fetch_ssl_isalpha(char in)
 724 {
 725         return ((in >= 'A' && in <= 'Z') || (in >= 'a' && in <= 'z'));
 726 }
 727
 728 /*
 729  * Check if passed hostnames a and b are equal.
 730  */
 731 static int
 732 fetch_ssl_hname_equal(const char *a, size_t alen, const char *b,
 733     size_t blen)
 734 {
 735         size_t i;
 736
 737         if (alen != blen)
 738                 return (0);
 739         for (i = 0; i < alen; ++i) {
 740                 if (fetch_ssl_tolower(a[i]) != fetch_ssl_tolower(b[i]))
 741                         return (0);
 742         }
 743         return (1);
 744 }
 745
 746 /*
 747  * Check if domain label is traditional, meaning that only A-Z, a-z, 0-9
 748  * and '-' (hyphen) are allowed. Hyphens have to be surrounded by alpha-
 749  * numeric characters. Double hyphens (like they're found in IDN a-labels
 750  * 'xn--') are not allowed. Empty labels are invalid.
 751  */
 752 static int
 753 fetch_ssl_is_trad_domain_label(const char *l, size_t len, int wcok)
 754 {
 755         size_t i;
 756
 757         if (!len || l[0] == '-' || l[len-1] == '-')
 758                 return (0);
 759         for (i = 0; i < len; ++i) {
 760                 if (!isdigit(l[i]) &&
 761                     !fetch_ssl_isalpha(l[i]) &&
 762                     !(l[i] == '*' && wcok) &&
 763                     !(l[i] == '-' && l[i - 1] != '-'))
 764                         return (0);
 765         }
 766         return (1);
 767 }
 768
 769 /*
 770  * Check if host name consists only of numbers. This might indicate an IP
 771  * address, which is not a good idea for CN wildcard comparison.
 772  */
 773 static int
 774 fetch_ssl_hname_is_only_numbers(const char *hostname, size_t len)
 775 {
 776         size_t i;
 777
 778         for (i = 0; i < len; ++i) {
 779                 if (!((hostname[i] >= '0' && hostname[i] <= '9') ||
 780                     hostname[i] == '.'))
 781                         return (0);
 782         }
 783         return (1);
 784 }
 785
 786 /*
 787  * Check if the host name h passed matches the pattern passed in m which
 788  * is usually part of subjectAltName or CN of a certificate presented to
 789  * the client. This includes wildcard matching. The algorithm is based on
 790  * RFC6125, sections 6.4.3 and 7.2, which clarifies RFC2818 and RFC3280.
 791  */
 792 static int
 793 fetch_ssl_hname_match(const char *h, size_t hlen, const char *m,
 794     size_t mlen)
 795 {
 796         int delta, hdotidx, mdot1idx, wcidx;
 797         const char *hdot, *mdot1, *mdot2;
 798         const char *wc; /* wildcard */
 799
 800         if (!(h && *h && m && *m))
 801                 return (0);
 802         if ((wc = strnstr(m, "*", mlen)) == NULL)
 803                 return (fetch_ssl_hname_equal(h, hlen, m, mlen));
 804         wcidx = wc - m;
 805         /* hostname should not be just dots and numbers */
 806         if (fetch_ssl_hname_is_only_numbers(h, hlen))
 807                 return (0);
 808         /* only one wildcard allowed in pattern */
 809         if (strnstr(wc + 1, "*", mlen - wcidx - 1) != NULL)
 810                 return (0);
 811         /*
 812          * there must be at least two more domain labels and
 813          * wildcard has to be in the leftmost label (RFC6125)
 814          */
 815         mdot1 = strnstr(m, ".", mlen);
 816         if (mdot1 == NULL || mdot1 < wc || (mlen - (mdot1 - m)) < 4)
 817                 return (0);
 818         mdot1idx = mdot1 - m;
 819         mdot2 = strnstr(mdot1 + 1, ".", mlen - mdot1idx - 1);
 820         if (mdot2 == NULL || (mlen - (mdot2 - m)) < 2)
 821                 return (0);
 822         /* hostname must contain a dot and not be the 1st char */
 823         hdot = strnstr(h, ".", hlen);
 824         if (hdot == NULL || hdot == h)
 825                 return (0);
 826         hdotidx = hdot - h;
 827         /*
 828          * host part of hostname must be at least as long as
 829          * pattern it's supposed to match
 830          */
 831         if (hdotidx < mdot1idx)
 832                 return (0);
 833         /*
 834          * don't allow wildcards in non-traditional domain names
 835          * (IDN, A-label, U-label...)
 836          */
 837         if (!fetch_ssl_is_trad_domain_label(h, hdotidx, 0) ||
 838             !fetch_ssl_is_trad_domain_label(m, mdot1idx, 1))
 839                 return (0);
 840         /* match domain part (part after first dot) */
 841         if (!fetch_ssl_hname_equal(hdot, hlen - hdotidx, mdot1,
 842             mlen - mdot1idx))
 843                 return (0);
 844         /* match part left of wildcard */
 845         if (!fetch_ssl_hname_equal(h, wcidx, m, wcidx))
 846                 return (0);
 847         /* match part right of wildcard */
 848         delta = mdot1idx - wcidx - 1;
 849         if (!fetch_ssl_hname_equal(hdot - delta, delta,
 850             mdot1 - delta, delta))
 851                 return (0);
 852         /* all tests succeeded, it's a match */
 853         return (1);
 854 }
 855
 856 /*
 857  * Get numeric host address info - returns NULL if host was not an IP
 858  * address. The caller is responsible for deallocation using
 859  * freeaddrinfo(3).
 860  */
 861 static struct addrinfo *
 862 fetch_ssl_get_numeric_addrinfo(const char *hostname, size_t len)
 863 {
 864         struct addrinfo hints, *res;
 865         char *host;
 866
 867         host = (char *)malloc(len + 1);
 868         memcpy(host, hostname, len);
 869         host[len] = '\0';
 870         memset(&hints, 0, sizeof(hints));
 871         hints.ai_family = PF_UNSPEC;
 872         hints.ai_socktype = SOCK_STREAM;
 873         hints.ai_protocol = 0;
 874         hints.ai_flags = AI_NUMERICHOST;
 875         /* port is not relevant for this purpose */
 876         if (getaddrinfo(host, "443", &hints, &res) != 0)
 877                 res = NULL;
 878         free(host);
 879         return res;
 880 }
 881
 882 /*
 883  * Compare ip address in addrinfo with address passes.
 884  */
 885 static int
 886 fetch_ssl_ipaddr_match_bin(const struct addrinfo *lhost, const char *rhost,
 887     size_t rhostlen)
 888 {
 889         const void *left;
 890
 891         if (lhost->ai_family == AF_INET && rhostlen == 4) {
 892                 left = (void *)&((struct sockaddr_in*)(void *)
 893                     lhost->ai_addr)->sin_addr.s_addr;
 894 #ifdef INET6
 895         } else if (lhost->ai_family == AF_INET6 && rhostlen == 16) {
 896                 left = (void *)&((struct sockaddr_in6 *)(void *)
 897                     lhost->ai_addr)->sin6_addr;
 898 #endif
 899         } else
 900                 return (0);
 901         return (!memcmp(left, (const void *)rhost, rhostlen) ? 1 : 0);
 902 }
 903
 904 /*
 905  * Compare ip address in addrinfo with host passed. If host is not an IP
 906  * address, comparison will fail.
 907  */
 908 static int
 909 fetch_ssl_ipaddr_match(const struct addrinfo *laddr, const char *r,
 910     size_t rlen)
 911 {
 912         struct addrinfo *raddr;
 913         int ret;
 914         char *rip;
 915
 916         ret = 0;
 917         if ((raddr = fetch_ssl_get_numeric_addrinfo(r, rlen)) == NULL)
 918                 return 0; /* not a numeric host */
 919
 920         if (laddr->ai_family == raddr->ai_family) {
 921                 if (laddr->ai_family == AF_INET) {
 922                         rip = (char *)&((struct sockaddr_in *)(void *)
 923                             raddr->ai_addr)->sin_addr.s_addr;
 924                         ret = fetch_ssl_ipaddr_match_bin(laddr, rip, 4);
 925 #ifdef INET6
 926                 } else if (laddr->ai_family == AF_INET6) {
 927                         rip = (char *)&((struct sockaddr_in6 *)(void *)
 928                             raddr->ai_addr)->sin6_addr;
 929                         ret = fetch_ssl_ipaddr_match_bin(laddr, rip, 16);
 930 #endif
 931                 }
 932
 933         }
 934         freeaddrinfo(raddr);
 935         return (ret);
 936 }
 937
 938 /*
 939  * Verify server certificate by subjectAltName.
 940  */
 941 static int
 942 fetch_ssl_verify_altname(STACK_OF(GENERAL_NAME) *altnames,
 943     const char *host, struct addrinfo *ip)
 944 {
 945         const GENERAL_NAME *name;
 946         size_t nslen;
 947         int i;
 948         const char *ns;
 949
 950         for (i = 0; i < sk_GENERAL_NAME_num(altnames); ++i) {
 951                 name = sk_GENERAL_NAME_value(altnames, i);
 952                 ns = (const char *)ASN1_STRING_get0_data(name->d.ia5);
 953                 nslen = (size_t)ASN1_STRING_length(name->d.ia5);
 954
 955                 if (name->type == GEN_DNS && ip == NULL &&
 956                     fetch_ssl_hname_match(host, strlen(host), ns, nslen))
 957                         return (1);
 958                 else if (name->type == GEN_IPADD && ip != NULL &&
 959                     fetch_ssl_ipaddr_match_bin(ip, ns, nslen))
 960                         return (1);
 961         }
 962         return (0);
 963 }
 964
 965 /*
 966  * Verify server certificate by CN.
 967  */
 968 static int
 969 fetch_ssl_verify_cn(X509_NAME *subject, const char *host,
 970     struct addrinfo *ip)
 971 {
 972         ASN1_STRING *namedata;
 973         X509_NAME_ENTRY *nameentry;
 974         int cnlen, lastpos, loc, ret;
 975         unsigned char *cn;
 976
 977         ret = 0;
 978         lastpos = -1;
 979         loc = -1;
 980         cn = NULL;
 981         /* get most specific CN (last entry in list) and compare */
 982         while ((lastpos = X509_NAME_get_index_by_NID(subject,
 983             NID_commonName, lastpos)) != -1)
 984                 loc = lastpos;
 985
 986         if (loc > -1) {
 987                 nameentry = X509_NAME_get_entry(subject, loc);
 988                 namedata = X509_NAME_ENTRY_get_data(nameentry);
 989                 cnlen = ASN1_STRING_to_UTF8(&cn, namedata);
 990                 if (ip == NULL &&
 991                     fetch_ssl_hname_match(host, strlen(host), cn, cnlen))
 992                         ret = 1;
 993                 else if (ip != NULL && fetch_ssl_ipaddr_match(ip, cn, cnlen))
 994                         ret = 1;
 995                 OPENSSL_free(cn);
 996         }
 997         return (ret);
 998 }
 999
1000 /*
1001  * Verify that server certificate subjectAltName/CN matches
1002  * hostname. First check, if there are alternative subject names. If yes,
1003  * those have to match. Only if those don't exist it falls back to
1004  * checking the subject's CN.
1005  */
1006 static int
1007 fetch_ssl_verify_hname(X509 *cert, const char *host)
1008 {
1009         struct addrinfo *ip;
1010         STACK_OF(GENERAL_NAME) *altnames;
1011         X509_NAME *subject;
1012         int ret;
1013
1014         ret = 0;
1015         ip = fetch_ssl_get_numeric_addrinfo(host, strlen(host));
1016         altnames = X509_get_ext_d2i(cert, NID_subject_alt_name,
1017             NULL, NULL);
1018
1019         if (altnames != NULL) {
1020                 ret = fetch_ssl_verify_altname(altnames, host, ip);
1021         } else {
1022                 subject = X509_get_subject_name(cert);
1023                 if (subject != NULL)
1024                         ret = fetch_ssl_verify_cn(subject, host, ip);
1025         }
1026
1027         if (ip != NULL)
1028                 freeaddrinfo(ip);
1029         if (altnames != NULL)
1030                 GENERAL_NAMES_free(altnames);
1031         return (ret);
1032 }
1033
1034 /*
1035  * Configure transport security layer based on environment.
1036  */
1037 static void
1038 fetch_ssl_setup_transport_layer(SSL_CTX *ctx, int verbose)
1039 {
1040         long ssl_ctx_options;
1041
1042         ssl_ctx_options = SSL_OP_ALL | SSL_OP_NO_SSLv3 | SSL_OP_NO_TICKET;
1043         if (getenv("SSL_NO_TLS1") != NULL)
1044                 ssl_ctx_options |= SSL_OP_NO_TLSv1;
1045         if (getenv("SSL_NO_TLS1_1") != NULL)
1046                 ssl_ctx_options |= SSL_OP_NO_TLSv1_1;
1047         if (getenv("SSL_NO_TLS1_2") != NULL)
1048                 ssl_ctx_options |= SSL_OP_NO_TLSv1_2;
1049         if (verbose)
1050                 fetch_info("SSL options: %lx", ssl_ctx_options);
1051         SSL_CTX_set_options(ctx, ssl_ctx_options);
1052 }
1053
1054
1055 /*
1056  * Configure peer verification based on environment.
1057  */
1058 #define LOCAL_CERT_FILE _PATH_LOCALBASE "/etc/ssl/cert.pem"
1059 #define BASE_CERT_FILE  "/etc/ssl/cert.pem"
1060 static int
1061 fetch_ssl_setup_peer_verification(SSL_CTX *ctx, int verbose)
1062 {
1063         X509_LOOKUP *crl_lookup;
1064         X509_STORE *crl_store;
1065         const char *ca_cert_file, *ca_cert_path, *crl_file;
1066
1067         if (getenv("SSL_NO_VERIFY_PEER") == NULL) {
1068                 ca_cert_file = getenv("SSL_CA_CERT_FILE");
1069                 if (ca_cert_file == NULL &&
1070                     access(LOCAL_CERT_FILE, R_OK) == 0)
1071                         ca_cert_file = LOCAL_CERT_FILE;
1072                 if (ca_cert_file == NULL &&
1073                     access(BASE_CERT_FILE, R_OK) == 0)
1074                         ca_cert_file = BASE_CERT_FILE;
1075                 ca_cert_path = getenv("SSL_CA_CERT_PATH");
1076                 if (verbose) {
1077                         fetch_info("Peer verification enabled");
1078                         if (ca_cert_file != NULL)
1079                                 fetch_info("Using CA cert file: %s",
1080                                     ca_cert_file);
1081                         if (ca_cert_path != NULL)
1082                                 fetch_info("Using CA cert path: %s",
1083                                     ca_cert_path);
1084                         if (ca_cert_file == NULL && ca_cert_path == NULL)
1085                                 fetch_info("Using OpenSSL default "
1086                                     "CA cert file and path");
1087                 }
1088                 SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER,
1089                     fetch_ssl_cb_verify_crt);
1090                 if (ca_cert_file != NULL || ca_cert_path != NULL)
1091                         SSL_CTX_load_verify_locations(ctx, ca_cert_file,
1092                             ca_cert_path);
1093                 else
1094                         SSL_CTX_set_default_verify_paths(ctx);
1095                 if ((crl_file = getenv("SSL_CRL_FILE")) != NULL) {
1096                         if (verbose)
1097                                 fetch_info("Using CRL file: %s", crl_file);
1098                         crl_store = SSL_CTX_get_cert_store(ctx);
1099                         crl_lookup = X509_STORE_add_lookup(crl_store,
1100                             X509_LOOKUP_file());
1101                         if (crl_lookup == NULL ||
1102                             !X509_load_crl_file(crl_lookup, crl_file,
1103                                 X509_FILETYPE_PEM)) {
1104                                 fprintf(stderr,
1105                                     "Could not load CRL file %s\n",
1106                                     crl_file);
1107                                 return (0);
1108                         }
1109                         X509_STORE_set_flags(crl_store,
1110                             X509_V_FLAG_CRL_CHECK |
1111                             X509_V_FLAG_CRL_CHECK_ALL);
1112                 }
1113         }
1114         return (1);
1115 }
1116
1117 /*
1118  * Configure client certificate based on environment.
1119  */
1120 static int
1121 fetch_ssl_setup_client_certificate(SSL_CTX *ctx, int verbose)
1122 {
1123         const char *client_cert_file, *client_key_file;
1124
1125         if ((client_cert_file = getenv("SSL_CLIENT_CERT_FILE")) != NULL) {
1126                 client_key_file = getenv("SSL_CLIENT_KEY_FILE") != NULL ?
1127                     getenv("SSL_CLIENT_KEY_FILE") : client_cert_file;
1128                 if (verbose) {
1129                         fetch_info("Using client cert file: %s",
1130                             client_cert_file);
1131                         fetch_info("Using client key file: %s",
1132                             client_key_file);
1133                 }
1134                 if (SSL_CTX_use_certificate_chain_file(ctx,
1135                         client_cert_file) != 1) {
1136                         fprintf(stderr,
1137                             "Could not load client certificate %s\n",
1138                             client_cert_file);
1139                         return (0);
1140                 }
1141                 if (SSL_CTX_use_PrivateKey_file(ctx, client_key_file,
1142                         SSL_FILETYPE_PEM) != 1) {
1143                         fprintf(stderr,
1144                             "Could not load client key %s\n",
1145                             client_key_file);
1146                         return (0);
1147                 }
1148         }
1149         return (1);
1150 }
1151
1152 /*
1153  * Callback for SSL certificate verification, this is called on server
1154  * cert verification. It takes no decision, but informs the user in case
1155  * verification failed.
1156  */
1157 int
1158 fetch_ssl_cb_verify_crt(int verified, X509_STORE_CTX *ctx)
1159 {
1160         X509 *crt;
1161         X509_NAME *name;
1162         char *str;
1163
1164         str = NULL;
1165         if (!verified) {
1166                 if ((crt = X509_STORE_CTX_get_current_cert(ctx)) != NULL &&
1167                     (name = X509_get_subject_name(crt)) != NULL)
1168                         str = X509_NAME_oneline(name, 0, 0);
1169                 fprintf(stderr, "Certificate verification failed for %s\n",
1170                     str != NULL ? str : "no relevant certificate");
1171                 OPENSSL_free(str);
1172         }
1173         return (verified);
1174 }
1175
1176 #endif
1177
1178 /*
1179  * Enable SSL on a connection.
1180  */
1181 int
1182 fetch_ssl(conn_t *conn, const struct url *URL, int verbose)
1183 {
1184 #ifdef WITH_SSL
1185         int ret, ssl_err;
1186         X509_NAME *name;
1187         char *str;
1188
1189         conn->ssl_meth = SSLv23_client_method();
1190         conn->ssl_ctx = SSL_CTX_new(conn->ssl_meth);
1191         SSL_CTX_set_mode(conn->ssl_ctx, SSL_MODE_AUTO_RETRY);
1192
1193         fetch_ssl_setup_transport_layer(conn->ssl_ctx, verbose);
1194         if (!fetch_ssl_setup_peer_verification(conn->ssl_ctx, verbose))
1195                 return (-1);
1196         if (!fetch_ssl_setup_client_certificate(conn->ssl_ctx, verbose))
1197                 return (-1);
1198
1199         conn->ssl = SSL_new(conn->ssl_ctx);
1200         if (conn->ssl == NULL) {
1201                 fprintf(stderr, "SSL context creation failed\n");
1202                 return (-1);
1203         }
1204         SSL_set_fd(conn->ssl, conn->sd);
1205
1206 #if !defined(OPENSSL_NO_TLSEXT)
1207         if (!SSL_set_tlsext_host_name(conn->ssl,
1208             __DECONST(struct url *, URL)->host)) {
1209                 fprintf(stderr,
1210                     "TLS server name indication extension failed for host %s\n",
1211                     URL->host);
1212                 return (-1);
1213         }
1214 #endif
1215         while ((ret = SSL_connect(conn->ssl)) == -1) {
1216                 ssl_err = SSL_get_error(conn->ssl, ret);
1217                 if (ssl_err != SSL_ERROR_WANT_READ &&
1218                     ssl_err != SSL_ERROR_WANT_WRITE) {
1219                         ERR_print_errors_fp(stderr);
1220                         return (-1);
1221                 }
1222         }
1223         conn->ssl_cert = SSL_get_peer_certificate(conn->ssl);
1224
1225         if (conn->ssl_cert == NULL) {
1226                 fprintf(stderr, "No server SSL certificate\n");
1227                 return (-1);
1228         }
1229
1230         if (getenv("SSL_NO_VERIFY_HOSTNAME") == NULL) {
1231                 if (verbose)
1232                         fetch_info("Verify hostname");
1233                 if (!fetch_ssl_verify_hname(conn->ssl_cert, URL->host)) {
1234                         fprintf(stderr,
1235                             "SSL certificate subject doesn't match host %s\n",
1236                             URL->host);
1237                         return (-1);
1238                 }
1239         }
1240
1241         if (verbose) {
1242                 fetch_info("%s connection established using %s",
1243                     SSL_get_version(conn->ssl), SSL_get_cipher(conn->ssl));
1244                 name = X509_get_subject_name(conn->ssl_cert);
1245                 str = X509_NAME_oneline(name, 0, 0);
1246                 fetch_info("Certificate subject: %s", str);
1247                 OPENSSL_free(str);
1248                 name = X509_get_issuer_name(conn->ssl_cert);
1249                 str = X509_NAME_oneline(name, 0, 0);
1250                 fetch_info("Certificate issuer: %s", str);
1251                 OPENSSL_free(str);
1252         }
1253
1254         return (0);
1255 #else
1256         (void)conn;
1257         (void)verbose;
1258         (void)URL;
1259         fprintf(stderr, "SSL support disabled\n");
1260         return (-1);
1261 #endif
1262 }
1263
1264 #define FETCH_READ_WAIT         -2
1265 #define FETCH_READ_ERROR        -1
1266 #define FETCH_READ_DONE          0
1267
1268 #ifdef WITH_SSL
1269 static ssize_t
1270 fetch_ssl_read(SSL *ssl, char *buf, size_t len)
1271 {
1272         ssize_t rlen;
1273         int ssl_err;
1274
1275         rlen = SSL_read(ssl, buf, len);
1276         if (rlen < 0) {
1277                 ssl_err = SSL_get_error(ssl, rlen);
1278                 if (ssl_err == SSL_ERROR_WANT_READ ||
1279                     ssl_err == SSL_ERROR_WANT_WRITE) {
1280                         return (FETCH_READ_WAIT);
1281                 } else {
1282                         ERR_print_errors_fp(stderr);
1283                         return (FETCH_READ_ERROR);
1284                 }
1285         }
1286         return (rlen);
1287 }
1288 #endif
1289
1290 static ssize_t
1291 fetch_socket_read(int sd, char *buf, size_t len)
1292 {
1293         ssize_t rlen;
1294
1295         rlen = read(sd, buf, len);
1296         if (rlen < 0) {
1297                 if (errno == EAGAIN || (errno == EINTR && fetchRestartCalls))
1298                         return (FETCH_READ_WAIT);
1299                 else
1300                         return (FETCH_READ_ERROR);
1301         }
1302         return (rlen);
1303 }
1304
1305 /*
1306  * Read a character from a connection w/ timeout
1307  */
1308 ssize_t
1309 fetch_read(conn_t *conn, char *buf, size_t len)
1310 {
1311         struct timeval now, timeout, delta;
1312         struct pollfd pfd;
1313         ssize_t rlen;
1314         int deltams;
1315
1316         if (fetchTimeout > 0) {
1317                 gettimeofday(&timeout, NULL);
1318                 timeout.tv_sec += fetchTimeout;
1319         }
1320
1321         deltams = INFTIM;
1322         memset(&pfd, 0, sizeof pfd);
1323         pfd.fd = conn->sd;
1324         pfd.events = POLLIN | POLLERR;
1325
1326         for (;;) {
1327                 /*
1328                  * The socket is non-blocking.  Instead of the canonical
1329                  * poll() -> read(), we do the following:
1330                  *
1331                  * 1) call read() or SSL_read().
1332                  * 2) if we received some data, return it.
1333                  * 3) if an error occurred, return -1.
1334                  * 4) if read() or SSL_read() signaled EOF, return.
1335                  * 5) if we did not receive any data but we're not at EOF,
1336                  *    call poll().
1337                  *
1338                  * In the SSL case, this is necessary because if we
1339                  * receive a close notification, we have to call
1340                  * SSL_read() one additional time after we've read
1341                  * everything we received.
1342                  *
1343                  * In the non-SSL case, it may improve performance (very
1344                  * slightly) when reading small amounts of data.
1345                  */
1346 #ifdef WITH_SSL
1347                 if (conn->ssl != NULL)
1348                         rlen = fetch_ssl_read(conn->ssl, buf, len);
1349                 else
1350 #endif
1351                         rlen = fetch_socket_read(conn->sd, buf, len);
1352                 if (rlen >= 0) {
1353                         break;
1354                 } else if (rlen == FETCH_READ_ERROR) {
1355                         fetch_syserr();
1356                         return (-1);
1357                 }
1358                 // assert(rlen == FETCH_READ_WAIT);
1359                 if (fetchTimeout > 0) {
1360                         gettimeofday(&now, NULL);
1361                         if (!timercmp(&timeout, &now, >)) {
1362                                 errno = ETIMEDOUT;
1363                                 fetch_syserr();
1364                                 return (-1);
1365                         }
1366                         timersub(&timeout, &now, &delta);
1367                         deltams = delta.tv_sec * 1000 +
1368                             delta.tv_usec / 1000;;
1369                 }
1370                 errno = 0;
1371                 pfd.revents = 0;
1372                 if (poll(&pfd, 1, deltams) < 0) {
1373                         if (errno == EINTR && fetchRestartCalls)
1374                                 continue;
1375                         fetch_syserr();
1376                         return (-1);
1377                 }
1378         }
1379         return (rlen);
1380 }
1381
1382
1383 /*
1384  * Read a line of text from a connection w/ timeout
1385  */
1386 #define MIN_BUF_SIZE 1024
1387
1388 int
1389 fetch_getln(conn_t *conn)
1390 {
1391         char *tmp;
1392         size_t tmpsize;
1393         ssize_t len;
1394         char c;
1395
1396         if (conn->buf == NULL) {
1397                 if ((conn->buf = malloc(MIN_BUF_SIZE)) == NULL) {
1398                         errno = ENOMEM;
1399                         return (-1);
1400                 }
1401                 conn->bufsize = MIN_BUF_SIZE;
1402         }
1403
1404         conn->buf[0] = '\0';
1405         conn->buflen = 0;
1406
1407         do {
1408                 len = fetch_read(conn, &c, 1);
1409                 if (len == -1)
1410                         return (-1);
1411                 if (len == 0)
1412                         break;
1413                 conn->buf[conn->buflen++] = c;
1414                 if (conn->buflen == conn->bufsize) {
1415                         tmp = conn->buf;
1416                         tmpsize = conn->bufsize * 2 + 1;
1417                         if ((tmp = realloc(tmp, tmpsize)) == NULL) {
1418                                 errno = ENOMEM;
1419                                 return (-1);
1420                         }
1421                         conn->buf = tmp;
1422                         conn->bufsize = tmpsize;
1423                 }
1424         } while (c != '\n');
1425
1426         conn->buf[conn->buflen] = '\0';
1427         DEBUGF("<<< %s", conn->buf);
1428         return (0);
1429 }
1430
1431
1432 /*
1433  * Write to a connection w/ timeout
1434  */
1435 ssize_t
1436 fetch_write(conn_t *conn, const char *buf, size_t len)
1437 {
1438         struct iovec iov;
1439
1440         iov.iov_base = __DECONST(char *, buf);
1441         iov.iov_len = len;
1442         return fetch_writev(conn, &iov, 1);
1443 }
1444
1445 /*
1446  * Write a vector to a connection w/ timeout
1447  * Note: can modify the iovec.
1448  */
1449 ssize_t
1450 fetch_writev(conn_t *conn, struct iovec *iov, int iovcnt)
1451 {
1452         struct timeval now, timeout, delta;
1453         struct pollfd pfd;
1454         ssize_t wlen, total;
1455         int deltams;
1456
1457         memset(&pfd, 0, sizeof pfd);
1458         if (fetchTimeout) {
1459                 pfd.fd = conn->sd;
1460                 pfd.events = POLLOUT | POLLERR;
1461                 gettimeofday(&timeout, NULL);
1462                 timeout.tv_sec += fetchTimeout;
1463         }
1464
1465         total = 0;
1466         while (iovcnt > 0) {
1467                 while (fetchTimeout && pfd.revents == 0) {
1468                         gettimeofday(&now, NULL);
1469                         if (!timercmp(&timeout, &now, >)) {
1470                                 errno = ETIMEDOUT;
1471                                 fetch_syserr();
1472                                 return (-1);
1473                         }
1474                         timersub(&timeout, &now, &delta);
1475                         deltams = delta.tv_sec * 1000 +
1476                             delta.tv_usec / 1000;
1477                         errno = 0;
1478                         pfd.revents = 0;
1479                         if (poll(&pfd, 1, deltams) < 0) {
1480                                 /* POSIX compliance */
1481                                 if (errno == EAGAIN)
1482                                         continue;
1483                                 if (errno == EINTR && fetchRestartCalls)
1484                                         continue;
1485                                 return (-1);
1486                         }
1487                 }
1488                 errno = 0;
1489 #ifdef WITH_SSL
1490                 if (conn->ssl != NULL)
1491                         wlen = SSL_write(conn->ssl,
1492                             iov->iov_base, iov->iov_len);
1493                 else
1494 #endif
1495                         wlen = writev(conn->sd, iov, iovcnt);
1496                 if (wlen == 0) {
1497                         /* we consider a short write a failure */
1498                         /* XXX perhaps we shouldn't in the SSL case */
1499                         errno = EPIPE;
1500                         fetch_syserr();
1501                         return (-1);
1502                 }
1503                 if (wlen < 0) {
1504                         if (errno == EINTR && fetchRestartCalls)
1505                                 continue;
1506                         return (-1);
1507                 }
1508                 total += wlen;
1509                 while (iovcnt > 0 && wlen >= (ssize_t)iov->iov_len) {
1510                         wlen -= iov->iov_len;
1511                         iov++;
1512                         iovcnt--;
1513                 }
1514                 if (iovcnt > 0) {
1515                         iov->iov_len -= wlen;
1516                         iov->iov_base = __DECONST(char *, iov->iov_base) + wlen;
1517                 }
1518         }
1519         return (total);
1520 }
1521
1522
1523 /*
1524  * Write a line of text to a connection w/ timeout
1525  */
1526 int
1527 fetch_putln(conn_t *conn, const char *str, size_t len)
1528 {
1529         struct iovec iov[2];
1530         int ret;
1531
1532         DEBUGF(">>> %s\n", str);
1533         iov[0].iov_base = __DECONST(char *, str);
1534         iov[0].iov_len = len;
1535         iov[1].iov_base = __DECONST(char *, ENDL);
1536         iov[1].iov_len = sizeof(ENDL);
1537         if (len == 0)
1538                 ret = fetch_writev(conn, &iov[1], 1);
1539         else
1540                 ret = fetch_writev(conn, iov, 2);
1541         if (ret == -1)
1542                 return (-1);
1543         return (0);
1544 }
1545
1546
1547 /*
1548  * Close connection
1549  */
1550 int
1551 fetch_close(conn_t *conn)
1552 {
1553         int ret;
1554
1555         if (--conn->ref > 0)
1556                 return (0);
1557 #ifdef WITH_SSL
1558         if (conn->ssl) {
1559                 SSL_shutdown(conn->ssl);
1560                 SSL_set_connect_state(conn->ssl);
1561                 SSL_free(conn->ssl);
1562                 conn->ssl = NULL;
1563         }
1564         if (conn->ssl_ctx) {
1565                 SSL_CTX_free(conn->ssl_ctx);
1566                 conn->ssl_ctx = NULL;
1567         }
1568         if (conn->ssl_cert) {
1569                 X509_free(conn->ssl_cert);
1570                 conn->ssl_cert = NULL;
1571         }
1572 #endif
1573         ret = close(conn->sd);
1574         free(conn->buf);
1575         free(conn);
1576         return (ret);
1577 }
1578
1579
1580 /*** Directory-related utility functions *************************************/
1581
1582 int
1583 fetch_add_entry(struct url_ent **p, int *size, int *len,
1584     const char *name, struct url_stat *us)
1585 {
1586         struct url_ent *tmp;
1587
1588         if (*p == NULL) {
1589                 *size = 0;
1590                 *len = 0;
1591         }
1592
1593         if (*len >= *size - 1) {
1594                 tmp = reallocarray(*p, *size * 2 + 1, sizeof(**p));
1595                 if (tmp == NULL) {
1596                         errno = ENOMEM;
1597                         fetch_syserr();
1598                         return (-1);
1599                 }
1600                 *size = (*size * 2 + 1);
1601                 *p = tmp;
1602         }
1603
1604         tmp = *p + *len;
1605         snprintf(tmp->name, PATH_MAX, "%s", name);
1606         memcpy(&tmp->stat, us, sizeof(*us));
1607
1608         (*len)++;
1609         (++tmp)->name[0] = 0;
1610
1611         return (0);
1612 }
1613
1614
1615 /*** Authentication-related utility functions ********************************/
1616
1617 static const char *
1618 fetch_read_word(FILE *f)
1619 {
1620         static char word[1024];
1621
1622         if (fscanf(f, " %1023s ", word) != 1)
1623                 return (NULL);
1624         return (word);
1625 }
1626
1627 static int
1628 fetch_netrc_open(void)
1629 {
1630         struct passwd *pwd;
1631         char fn[PATH_MAX];
1632         const char *p;
1633         int fd, serrno;
1634
1635         if ((p = getenv("NETRC")) != NULL) {
1636                 DEBUGF("NETRC=%s\n", p);
1637                 if (snprintf(fn, sizeof(fn), "%s", p) >= (int)sizeof(fn)) {
1638                         fetch_info("$NETRC specifies a file name "
1639                             "longer than PATH_MAX");
1640                         return (-1);
1641                 }
1642         } else {
1643                 if ((p = getenv("HOME")) == NULL) {
1644                         if ((pwd = getpwuid(getuid())) == NULL ||
1645                             (p = pwd->pw_dir) == NULL)
1646                                 return (-1);
1647                 }
1648                 if (snprintf(fn, sizeof(fn), "%s/.netrc", p) >= (int)sizeof(fn))
1649                         return (-1);
1650         }
1651
1652         if ((fd = open(fn, O_RDONLY)) < 0) {
1653                 serrno = errno;
1654                 DEBUGF("%s: %s\n", fn, strerror(serrno));
1655                 errno = serrno;
1656         }
1657         return (fd);
1658 }
1659
1660 /*
1661  * Get authentication data for a URL from .netrc
1662  */
1663 int
1664 fetch_netrc_auth(struct url *url)
1665 {
1666         const char *word;
1667         int serrno;
1668         FILE *f;
1669
1670         if (url->netrcfd < 0)
1671                 url->netrcfd = fetch_netrc_open();
1672         if (url->netrcfd < 0)
1673                 return (-1);
1674         if ((f = fdopen(url->netrcfd, "r")) == NULL) {
1675                 serrno = errno;
1676                 DEBUGF("fdopen(netrcfd): %s", strerror(errno));
1677                 close(url->netrcfd);
1678                 url->netrcfd = -1;
1679                 errno = serrno;
1680                 return (-1);
1681         }
1682         rewind(f);
1683         DEBUGF("searching netrc for %s\n", url->host);
1684         while ((word = fetch_read_word(f)) != NULL) {
1685                 if (strcmp(word, "default") == 0) {
1686                         DEBUGF("using default netrc settings\n");
1687                         break;
1688                 }
1689                 if (strcmp(word, "machine") == 0 &&
1690                     (word = fetch_read_word(f)) != NULL &&
1691                     strcasecmp(word, url->host) == 0) {
1692                         DEBUGF("using netrc settings for %s\n", word);
1693                         break;
1694                 }
1695         }
1696         if (word == NULL)
1697                 goto ferr;
1698         while ((word = fetch_read_word(f)) != NULL) {
1699                 if (strcmp(word, "login") == 0) {
1700                         if ((word = fetch_read_word(f)) == NULL)
1701                                 goto ferr;
1702                         if (snprintf(url->user, sizeof(url->user),
1703                                 "%s", word) > (int)sizeof(url->user)) {
1704                                 fetch_info("login name in .netrc is too long");
1705                                 url->user[0] = '\0';
1706                         }
1707                 } else if (strcmp(word, "password") == 0) {
1708                         if ((word = fetch_read_word(f)) == NULL)
1709                                 goto ferr;
1710                         if (snprintf(url->pwd, sizeof(url->pwd),
1711                                 "%s", word) > (int)sizeof(url->pwd)) {
1712                                 fetch_info("password in .netrc is too long");
1713                                 url->pwd[0] = '\0';
1714                         }
1715                 } else if (strcmp(word, "account") == 0) {
1716                         if ((word = fetch_read_word(f)) == NULL)
1717                                 goto ferr;
1718                         /* XXX not supported! */
1719                 } else {
1720                         break;
1721                 }
1722         }
1723         fclose(f);
1724         url->netrcfd = -1;
1725         return (0);
1726 ferr:
1727         serrno = errno;
1728         fclose(f);
1729         url->netrcfd = -1;
1730         errno = serrno;
1731         return (-1);
1732 }
1733
1734 /*
1735  * The no_proxy environment variable specifies a set of domains for
1736  * which the proxy should not be consulted; the contents is a comma-,
1737  * or space-separated list of domain names.  A single asterisk will
1738  * override all proxy variables and no transactions will be proxied
1739  * (for compatibility with lynx and curl, see the discussion at
1740  * <http://curl.haxx.se/mail/archive_pre_oct_99/0009.html>).
1741  */
1742 int
1743 fetch_no_proxy_match(const char *host)
1744 {
1745         const char *no_proxy, *p, *q;
1746         size_t h_len, d_len;
1747
1748         if ((no_proxy = getenv("NO_PROXY")) == NULL &&
1749             (no_proxy = getenv("no_proxy")) == NULL)
1750                 return (0);
1751
1752         /* asterisk matches any hostname */
1753         if (strcmp(no_proxy, "*") == 0)
1754                 return (1);
1755
1756         h_len = strlen(host);
1757         p = no_proxy;
1758         do {
1759                 /* position p at the beginning of a domain suffix */
1760                 while (*p == ',' || isspace((unsigned char)*p))
1761                         p++;
1762
1763                 /* position q at the first separator character */
1764                 for (q = p; *q; ++q)
1765                         if (*q == ',' || isspace((unsigned char)*q))
1766                                 break;
1767
1768                 d_len = q - p;
1769                 if (d_len > 0 && h_len >= d_len &&
1770                     strncasecmp(host + h_len - d_len,
1771                         p, d_len) == 0) {
1772                         /* domain name matches */
1773                         return (1);
1774                 }
1775
1776                 p = q + 1;
1777         } while (*q);
1778
1779         return (0);
1780 }