1 /* $NetBSD: common.c,v 1.4 2023/01/24 08:02:57 mlelstv Exp $ */ 2 /*- 3 * Copyright (c) 1998-2004 Dag-Erling Co�dan Sm�rgrav 4 * Copyright (c) 2008, 2010 Joerg Sonnenberger <joerg@NetBSD.org> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer 12 * in this position and unchanged. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. The name of the author may not be used to endorse or promote products 17 * derived from this software without specific prior written permission 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 20 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 21 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 22 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 24 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 28 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 * 30 * $FreeBSD: common.c,v 1.53 2007/12/19 00:26:36 des Exp $ 31 */ 32 33 #if HAVE_CONFIG_H 34 #include "config.h" 35 #endif 36 #ifndef NETBSD 37 #include <nbcompat.h> 38 #endif 39 40 #include <sys/types.h> 41 #include <sys/socket.h> 42 #include <sys/time.h> 43 #include <sys/uio.h> 44 45 #include <netinet/in.h> 46 #include <arpa/inet.h> 47 48 #include <ctype.h> 49 #include <errno.h> 50 #if defined(HAVE_INTTYPES_H) || defined(NETBSD) 51 #include <inttypes.h> 52 #endif 53 #ifndef NETBSD 54 #include <nbcompat/netdb.h> 55 #else 56 #include <netdb.h> 57 #endif 58 #include <pwd.h> 59 #include <stdarg.h> 60 #include <stdlib.h> 61 #include <stdio.h> 62 #include <string.h> 63 #include <unistd.h> 64 65 #ifndef MSG_NOSIGNAL 66 #include <signal.h> 67 #endif 68 69 #include "fetch.h" 70 #include "common.h" 71 72 /*** Local data **************************************************************/ 73 74 /* 75 * Error messages for resolver errors 76 */ 77 static struct fetcherr netdb_errlist[] = { 78 #ifdef EAI_NODATA 79 { EAI_NODATA, FETCH_RESOLV, "Host not found" }, 80 #endif 81 { EAI_AGAIN, FETCH_TEMP, "Transient resolver failure" }, 82 { EAI_FAIL, FETCH_RESOLV, "Non-recoverable resolver failure" }, 83 { EAI_NONAME, FETCH_RESOLV, "No address record" }, 84 { -1, FETCH_UNKNOWN, "Unknown resolver error" } 85 }; 86 87 /*** Error-reporting functions ***********************************************/ 88 89 /* 90 * Map error code to string 91 */ 92 static struct fetcherr * 93 fetch_finderr(struct fetcherr *p, int e) 94 { 95 while (p->num != -1 && p->num != e) 96 p++; 97 return (p); 98 } 99 100 /* 101 * Set error code 102 */ 103 void 104 fetch_seterr(struct fetcherr *p, int e) 105 { 106 p = fetch_finderr(p, e); 107 fetchLastErrCode = p->cat; 108 snprintf(fetchLastErrString, MAXERRSTRING, "%s", p->string); 109 } 110 111 /* 112 * Set error code according to errno 113 */ 114 void 115 fetch_syserr(void) 116 { 117 switch (errno) { 118 case 0: 119 fetchLastErrCode = FETCH_OK; 120 break; 121 case EPERM: 122 case EACCES: 123 case EROFS: 124 #ifdef EAUTH 125 case EAUTH: 126 #endif 127 #ifdef ENEEDAUTH 128 case ENEEDAUTH: 129 #endif 130 fetchLastErrCode = FETCH_AUTH; 131 break; 132 case ENOENT: 133 case EISDIR: /* XXX */ 134 fetchLastErrCode = FETCH_UNAVAIL; 135 break; 136 case ENOMEM: 137 fetchLastErrCode = FETCH_MEMORY; 138 break; 139 case EBUSY: 140 case EAGAIN: 141 fetchLastErrCode = FETCH_TEMP; 142 break; 143 case EEXIST: 144 fetchLastErrCode = FETCH_EXISTS; 145 break; 146 case ENOSPC: 147 fetchLastErrCode = FETCH_FULL; 148 break; 149 case EADDRINUSE: 150 case EADDRNOTAVAIL: 151 case ENETDOWN: 152 case ENETUNREACH: 153 case ENETRESET: 154 case EHOSTUNREACH: 155 fetchLastErrCode = FETCH_NETWORK; 156 break; 157 case ECONNABORTED: 158 case ECONNRESET: 159 fetchLastErrCode = FETCH_ABORT; 160 break; 161 case ETIMEDOUT: 162 fetchLastErrCode = FETCH_TIMEOUT; 163 break; 164 case ECONNREFUSED: 165 case EHOSTDOWN: 166 fetchLastErrCode = FETCH_DOWN; 167 break; 168 default: 169 fetchLastErrCode = FETCH_UNKNOWN; 170 } 171 snprintf(fetchLastErrString, MAXERRSTRING, "%s", strerror(errno)); 172 } 173 174 175 /* 176 * Emit status message 177 */ 178 void 179 fetch_info(const char *fmt, ...) 180 { 181 va_list ap; 182 183 va_start(ap, fmt); 184 vfprintf(stderr, fmt, ap); 185 va_end(ap); 186 fputc('\n', stderr); 187 } 188 189 190 /*** Network-related utility functions ***************************************/ 191 192 /* 193 * Return the default port for a scheme 194 */ 195 int 196 fetch_default_port(const char *scheme) 197 { 198 struct servent *se; 199 200 if ((se = getservbyname(scheme, "tcp")) != NULL) 201 return (ntohs(se->s_port)); 202 if (strcasecmp(scheme, SCHEME_FTP) == 0) 203 return (FTP_DEFAULT_PORT); 204 if (strcasecmp(scheme, SCHEME_HTTP) == 0) 205 return (HTTP_DEFAULT_PORT); 206 return (0); 207 } 208 209 /* 210 * Return the default proxy port for a scheme 211 */ 212 int 213 fetch_default_proxy_port(const char *scheme) 214 { 215 if (strcasecmp(scheme, SCHEME_FTP) == 0) 216 return (FTP_DEFAULT_PROXY_PORT); 217 if (strcasecmp(scheme, SCHEME_HTTP) == 0) 218 return (HTTP_DEFAULT_PROXY_PORT); 219 return (0); 220 } 221 222 223 /* 224 * Create a connection for an existing descriptor. 225 */ 226 conn_t * 227 fetch_reopen(int sd) 228 { 229 conn_t *conn; 230 231 /* allocate and fill connection structure */ 232 if ((conn = calloc(1, sizeof(*conn))) == NULL) 233 return (NULL); 234 conn->ftp_home = NULL; 235 conn->cache_url = NULL; 236 conn->next_buf = NULL; 237 conn->next_len = 0; 238 conn->sd = sd; 239 return (conn); 240 } 241 242 243 /* 244 * Bind a socket to a specific local address 245 */ 246 int 247 fetch_bind(int sd, int af, const char *addr) 248 { 249 struct addrinfo hints, *res, *res0; 250 251 memset(&hints, 0, sizeof(hints)); 252 hints.ai_family = af; 253 hints.ai_socktype = SOCK_STREAM; 254 hints.ai_protocol = 0; 255 if (getaddrinfo(addr, NULL, &hints, &res0)) 256 return (-1); 257 for (res = res0; res; res = res->ai_next) { 258 if (bind(sd, res->ai_addr, res->ai_addrlen) == 0) 259 return (0); 260 } 261 return (-1); 262 } 263 264 265 /* 266 * Establish a TCP connection to the specified port on the specified host. 267 */ 268 conn_t * 269 fetch_connect(struct url *url, int af, int verbose) 270 { 271 conn_t *conn; 272 char pbuf[10]; 273 const char *bindaddr; 274 struct addrinfo hints, *res, *res0; 275 int sd, error; 276 277 if (verbose) 278 fetch_info("looking up %s", url->host); 279 280 /* look up host name and set up socket address structure */ 281 snprintf(pbuf, sizeof(pbuf), "%d", url->port); 282 memset(&hints, 0, sizeof(hints)); 283 hints.ai_family = af; 284 hints.ai_socktype = SOCK_STREAM; 285 hints.ai_protocol = 0; 286 if ((error = getaddrinfo(url->host, pbuf, &hints, &res0)) != 0) { 287 netdb_seterr(error); 288 return (NULL); 289 } 290 bindaddr = getenv("FETCH_BIND_ADDRESS"); 291 292 if (verbose) 293 fetch_info("connecting to %s:%d", url->host, url->port); 294 295 /* try to connect */ 296 for (sd = -1, res = res0; res; sd = -1, res = res->ai_next) { 297 if ((sd = socket(res->ai_family, res->ai_socktype, 298 res->ai_protocol)) == -1) 299 continue; 300 if (bindaddr != NULL && *bindaddr != '\0' && 301 fetch_bind(sd, res->ai_family, bindaddr) != 0) { 302 fetch_info("failed to bind to '%s'", bindaddr); 303 close(sd); 304 continue; 305 } 306 if (connect(sd, res->ai_addr, res->ai_addrlen) == 0) 307 break; 308 close(sd); 309 } 310 freeaddrinfo(res0); 311 if (sd == -1) { 312 fetch_syserr(); 313 return (NULL); 314 } 315 316 if ((conn = fetch_reopen(sd)) == NULL) { 317 fetch_syserr(); 318 close(sd); 319 } 320 conn->cache_url = fetchCopyURL(url); 321 conn->cache_af = af; 322 return (conn); 323 } 324 325 static conn_t *connection_cache; 326 static int cache_global_limit = 0; 327 static int cache_per_host_limit = 0; 328 329 /* 330 * Initialise cache with the given limits. 331 */ 332 void 333 fetchConnectionCacheInit(int global_limit, int per_host_limit) 334 { 335 336 if (global_limit < 0) 337 cache_global_limit = INT_MAX; 338 else if (per_host_limit > global_limit) 339 cache_global_limit = per_host_limit; 340 else 341 cache_global_limit = global_limit; 342 if (per_host_limit < 0) 343 cache_per_host_limit = INT_MAX; 344 else 345 cache_per_host_limit = per_host_limit; 346 } 347 348 /* 349 * Flush cache and free all associated resources. 350 */ 351 void 352 fetchConnectionCacheClose(void) 353 { 354 conn_t *conn; 355 356 while ((conn = connection_cache) != NULL) { 357 connection_cache = conn->next_cached; 358 (*conn->cache_close)(conn); 359 } 360 } 361 362 /* 363 * Check connection cache for an existing entry matching 364 * protocol/host/port/user/password/family. 365 */ 366 conn_t * 367 fetch_cache_get(const struct url *url, int af) 368 { 369 conn_t *conn, *last_conn = NULL; 370 371 for (conn = connection_cache; conn; conn = conn->next_cached) { 372 if (conn->cache_url->port == url->port && 373 strcmp(conn->cache_url->scheme, url->scheme) == 0 && 374 strcmp(conn->cache_url->host, url->host) == 0 && 375 strcmp(conn->cache_url->user, url->user) == 0 && 376 strcmp(conn->cache_url->pwd, url->pwd) == 0 && 377 (conn->cache_af == AF_UNSPEC || af == AF_UNSPEC || 378 conn->cache_af == af)) { 379 if (last_conn != NULL) 380 last_conn->next_cached = conn->next_cached; 381 else 382 connection_cache = conn->next_cached; 383 return conn; 384 } 385 } 386 387 return NULL; 388 } 389 390 /* 391 * Put the connection back into the cache for reuse. 392 * If the connection is freed due to LRU or if the cache 393 * is explicitly closed, the given callback is called. 394 */ 395 void 396 fetch_cache_put(conn_t *conn, int (*closecb)(conn_t *)) 397 { 398 conn_t *iter, *last; 399 int global_count, host_count; 400 401 if (conn->cache_url == NULL || cache_global_limit == 0) { 402 (*closecb)(conn); 403 return; 404 } 405 406 global_count = host_count = 0; 407 last = NULL; 408 for (iter = connection_cache; iter; 409 last = iter, iter = iter->next_cached) { 410 ++global_count; 411 if (strcmp(conn->cache_url->host, iter->cache_url->host) == 0) 412 ++host_count; 413 if (global_count < cache_global_limit && 414 host_count < cache_per_host_limit) 415 continue; 416 --global_count; 417 if (last != NULL) 418 last->next_cached = iter->next_cached; 419 else 420 connection_cache = iter->next_cached; 421 (*iter->cache_close)(iter); 422 } 423 424 conn->cache_close = closecb; 425 conn->next_cached = connection_cache; 426 connection_cache = conn; 427 } 428 429 /* 430 * Enable SSL on a connection. 431 */ 432 int 433 fetch_ssl(conn_t *conn, int verbose) 434 { 435 436 #ifdef WITH_SSL 437 /* Init the SSL library and context */ 438 if (!SSL_library_init()){ 439 fprintf(stderr, "SSL library init failed\n"); 440 return (-1); 441 } 442 443 SSL_load_error_strings(); 444 445 conn->ssl_meth = SSLv23_client_method(); 446 conn->ssl_ctx = SSL_CTX_new(conn->ssl_meth); 447 SSL_CTX_set_mode(conn->ssl_ctx, SSL_MODE_AUTO_RETRY); 448 449 conn->ssl = SSL_new(conn->ssl_ctx); 450 if (conn->ssl == NULL){ 451 fprintf(stderr, "SSL context creation failed\n"); 452 return (-1); 453 } 454 SSL_set_fd(conn->ssl, conn->sd); 455 if (!SSL_set_tlsext_host_name(conn->ssl, conn->cache_url->host)) { 456 fprintf(stderr, "SSL hostname setting failed\n"); 457 return (-1); 458 } 459 if (SSL_connect(conn->ssl) == -1){ 460 ERR_print_errors_fp(stderr); 461 return (-1); 462 } 463 464 if (verbose) { 465 X509_NAME *name; 466 char *str; 467 468 fprintf(stderr, "SSL connection established using %s\n", 469 SSL_get_cipher(conn->ssl)); 470 conn->ssl_cert = SSL_get_peer_certificate(conn->ssl); 471 name = X509_get_subject_name(conn->ssl_cert); 472 str = X509_NAME_oneline(name, 0, 0); 473 printf("Certificate subject: %s\n", str); 474 free(str); 475 name = X509_get_issuer_name(conn->ssl_cert); 476 str = X509_NAME_oneline(name, 0, 0); 477 printf("Certificate issuer: %s\n", str); 478 free(str); 479 } 480 481 return (0); 482 #else 483 (void)conn; 484 (void)verbose; 485 fprintf(stderr, "SSL support disabled\n"); 486 return (-1); 487 #endif 488 } 489 490 491 /* 492 * Read a character from a connection w/ timeout 493 */ 494 ssize_t 495 fetch_read(conn_t *conn, char *buf, size_t len) 496 { 497 struct timeval now, timeout, waittv; 498 fd_set readfds; 499 ssize_t rlen; 500 int r; 501 502 if (len == 0) 503 return 0; 504 505 if (conn->next_len != 0) { 506 if (conn->next_len < len) 507 len = conn->next_len; 508 memmove(buf, conn->next_buf, len); 509 conn->next_len -= len; 510 conn->next_buf += len; 511 return len; 512 } 513 514 if (fetchTimeout) { 515 FD_ZERO(&readfds); 516 gettimeofday(&timeout, NULL); 517 timeout.tv_sec += fetchTimeout; 518 } 519 520 for (;;) { 521 while (fetchTimeout && !FD_ISSET(conn->sd, &readfds)) { 522 FD_SET(conn->sd, &readfds); 523 gettimeofday(&now, NULL); 524 waittv.tv_sec = timeout.tv_sec - now.tv_sec; 525 waittv.tv_usec = timeout.tv_usec - now.tv_usec; 526 if (waittv.tv_usec < 0) { 527 waittv.tv_usec += 1000000; 528 waittv.tv_sec--; 529 } 530 if (waittv.tv_sec < 0) { 531 errno = ETIMEDOUT; 532 fetch_syserr(); 533 return (-1); 534 } 535 errno = 0; 536 r = select(conn->sd + 1, &readfds, NULL, NULL, &waittv); 537 if (r == -1) { 538 if (errno == EINTR && fetchRestartCalls) 539 continue; 540 fetch_syserr(); 541 return (-1); 542 } 543 } 544 #ifdef WITH_SSL 545 if (conn->ssl != NULL) 546 rlen = SSL_read(conn->ssl, buf, (int)len); 547 else 548 #endif 549 rlen = read(conn->sd, buf, len); 550 if (rlen >= 0) 551 break; 552 553 if (errno != EINTR || !fetchRestartCalls) 554 return (-1); 555 } 556 return (rlen); 557 } 558 559 560 /* 561 * Read a line of text from a connection w/ timeout 562 */ 563 #define MIN_BUF_SIZE 1024 564 565 int 566 fetch_getln(conn_t *conn) 567 { 568 char *tmp, *next; 569 size_t tmpsize; 570 ssize_t len; 571 572 if (conn->buf == NULL) { 573 if ((conn->buf = malloc(MIN_BUF_SIZE)) == NULL) { 574 errno = ENOMEM; 575 return (-1); 576 } 577 conn->bufsize = MIN_BUF_SIZE; 578 } 579 580 conn->buflen = 0; 581 next = NULL; 582 583 do { 584 /* 585 * conn->bufsize != conn->buflen at this point, 586 * so the buffer can be NUL-terminated below for 587 * the case of len == 0. 588 */ 589 len = fetch_read(conn, conn->buf + conn->buflen, 590 conn->bufsize - conn->buflen); 591 if (len == -1) 592 return (-1); 593 if (len == 0) 594 break; 595 next = memchr(conn->buf + conn->buflen, '\n', (size_t)len); 596 conn->buflen += len; 597 if (conn->buflen == conn->bufsize && next == NULL) { 598 tmp = conn->buf; 599 tmpsize = conn->bufsize * 2; 600 if (tmpsize < conn->bufsize) { 601 errno = ENOMEM; 602 return (-1); 603 } 604 if ((tmp = realloc(tmp, tmpsize)) == NULL) { 605 errno = ENOMEM; 606 return (-1); 607 } 608 conn->buf = tmp; 609 conn->bufsize = tmpsize; 610 } 611 } while (next == NULL); 612 613 if (next != NULL) { 614 *next = '\0'; 615 conn->next_buf = next + 1; 616 conn->next_len = conn->buflen - (conn->next_buf - conn->buf); 617 conn->buflen = next - conn->buf; 618 } else { 619 conn->buf[conn->buflen] = '\0'; 620 conn->next_len = 0; 621 } 622 return (0); 623 } 624 625 /* 626 * Write a vector to a connection w/ timeout 627 * Note: can modify the iovec. 628 */ 629 ssize_t 630 fetch_write(conn_t *conn, const void *buf, size_t len) 631 { 632 struct timeval now, timeout, waittv; 633 fd_set writefds; 634 ssize_t wlen, total; 635 int r; 636 #ifndef MSG_NOSIGNAL 637 static int killed_sigpipe; 638 #endif 639 640 #ifndef MSG_NOSIGNAL 641 if (!killed_sigpipe) { 642 signal(SIGPIPE, SIG_IGN); 643 killed_sigpipe = 1; 644 } 645 #endif 646 647 648 if (fetchTimeout) { 649 FD_ZERO(&writefds); 650 gettimeofday(&timeout, NULL); 651 timeout.tv_sec += fetchTimeout; 652 } 653 654 total = 0; 655 while (len) { 656 while (fetchTimeout && !FD_ISSET(conn->sd, &writefds)) { 657 FD_SET(conn->sd, &writefds); 658 gettimeofday(&now, NULL); 659 waittv.tv_sec = timeout.tv_sec - now.tv_sec; 660 waittv.tv_usec = timeout.tv_usec - now.tv_usec; 661 if (waittv.tv_usec < 0) { 662 waittv.tv_usec += 1000000; 663 waittv.tv_sec--; 664 } 665 if (waittv.tv_sec < 0) { 666 errno = ETIMEDOUT; 667 fetch_syserr(); 668 return (-1); 669 } 670 errno = 0; 671 r = select(conn->sd + 1, NULL, &writefds, NULL, &waittv); 672 if (r == -1) { 673 if (errno == EINTR && fetchRestartCalls) 674 continue; 675 return (-1); 676 } 677 } 678 errno = 0; 679 #ifdef WITH_SSL 680 if (conn->ssl != NULL) 681 wlen = SSL_write(conn->ssl, buf, (int)len); 682 else 683 #endif 684 #ifndef MSG_NOSIGNAL 685 wlen = send(conn->sd, buf, len, 0); 686 #else 687 wlen = send(conn->sd, buf, len, MSG_NOSIGNAL); 688 #endif 689 if (wlen == 0) { 690 /* we consider a short write a failure */ 691 errno = EPIPE; 692 fetch_syserr(); 693 return (-1); 694 } 695 if (wlen < 0) { 696 if (errno == EINTR && fetchRestartCalls) 697 continue; 698 return (-1); 699 } 700 total += wlen; 701 buf = (const char *)buf + wlen; 702 len -= wlen; 703 } 704 return (total); 705 } 706 707 708 /* 709 * Close connection 710 */ 711 int 712 fetch_close(conn_t *conn) 713 { 714 int ret; 715 716 #ifdef WITH_SSL 717 if (conn->ssl) { 718 SSL_shutdown(conn->ssl); 719 SSL_set_connect_state(conn->ssl); 720 SSL_free(conn->ssl); 721 conn->ssl = NULL; 722 } 723 if (conn->ssl_ctx) { 724 SSL_CTX_free(conn->ssl_ctx); 725 conn->ssl_ctx = NULL; 726 } 727 if (conn->ssl_cert) { 728 X509_free(conn->ssl_cert); 729 conn->ssl_cert = NULL; 730 } 731 #endif 732 ret = close(conn->sd); 733 if (conn->cache_url) 734 fetchFreeURL(conn->cache_url); 735 free(conn->ftp_home); 736 free(conn->buf); 737 free(conn); 738 return (ret); 739 } 740 741 742 /*** Directory-related utility functions *************************************/ 743 744 int 745 fetch_add_entry(struct url_list *ue, struct url *base, const char *name, 746 int pre_quoted) 747 { 748 struct url *tmp; 749 char *tmp_name; 750 size_t base_doc_len, name_len, i; 751 unsigned char c; 752 753 if (strchr(name, '/') != NULL || 754 strcmp(name, "..") == 0 || 755 strcmp(name, ".") == 0) 756 return 0; 757 758 if (strcmp(base->doc, "/") == 0) 759 base_doc_len = 0; 760 else 761 base_doc_len = strlen(base->doc); 762 763 name_len = 1; 764 for (i = 0; name[i] != '\0'; ++i) { 765 if ((!pre_quoted && name[i] == '%') || 766 !fetch_urlpath_safe(name[i])) 767 name_len += 3; 768 else 769 ++name_len; 770 } 771 772 tmp_name = malloc( base_doc_len + name_len + 1); 773 if (tmp_name == NULL) { 774 errno = ENOMEM; 775 fetch_syserr(); 776 return (-1); 777 } 778 779 if (ue->length + 1 >= ue->alloc_size) { 780 tmp = realloc(ue->urls, (ue->alloc_size * 2 + 1) * sizeof(*tmp)); 781 if (tmp == NULL) { 782 free(tmp_name); 783 errno = ENOMEM; 784 fetch_syserr(); 785 return (-1); 786 } 787 ue->alloc_size = ue->alloc_size * 2 + 1; 788 ue->urls = tmp; 789 } 790 791 tmp = ue->urls + ue->length; 792 strcpy(tmp->scheme, base->scheme); 793 strcpy(tmp->user, base->user); 794 strcpy(tmp->pwd, base->pwd); 795 strcpy(tmp->host, base->host); 796 tmp->port = base->port; 797 tmp->doc = tmp_name; 798 memcpy(tmp->doc, base->doc, base_doc_len); 799 tmp->doc[base_doc_len] = '/'; 800 801 for (i = base_doc_len + 1; *name != '\0'; ++name) { 802 if ((!pre_quoted && *name == '%') || 803 !fetch_urlpath_safe(*name)) { 804 tmp->doc[i++] = '%'; 805 c = (unsigned char)*name / 16; 806 if (c < 10) 807 tmp->doc[i++] = '0' + c; 808 else 809 tmp->doc[i++] = 'a' - 10 + c; 810 c = (unsigned char)*name % 16; 811 if (c < 10) 812 tmp->doc[i++] = '0' + c; 813 else 814 tmp->doc[i++] = 'a' - 10 + c; 815 } else { 816 tmp->doc[i++] = *name; 817 } 818 } 819 tmp->doc[i] = '\0'; 820 821 tmp->offset = 0; 822 tmp->length = 0; 823 tmp->last_modified = -1; 824 825 ++ue->length; 826 827 return (0); 828 } 829 830 void 831 fetchInitURLList(struct url_list *ue) 832 { 833 ue->length = ue->alloc_size = 0; 834 ue->urls = NULL; 835 } 836 837 int 838 fetchAppendURLList(struct url_list *dst, const struct url_list *src) 839 { 840 size_t i, j, len; 841 842 len = dst->length + src->length; 843 if (len > dst->alloc_size) { 844 struct url *tmp; 845 846 tmp = realloc(dst->urls, len * sizeof(*tmp)); 847 if (tmp == NULL) { 848 errno = ENOMEM; 849 fetch_syserr(); 850 return (-1); 851 } 852 dst->alloc_size = len; 853 dst->urls = tmp; 854 } 855 856 for (i = 0, j = dst->length; i < src->length; ++i, ++j) { 857 dst->urls[j] = src->urls[i]; 858 dst->urls[j].doc = strdup(src->urls[i].doc); 859 if (dst->urls[j].doc == NULL) { 860 while (i-- > 0) 861 free(dst->urls[j].doc); 862 fetch_syserr(); 863 return -1; 864 } 865 } 866 dst->length = len; 867 868 return 0; 869 } 870 871 void 872 fetchFreeURLList(struct url_list *ue) 873 { 874 size_t i; 875 876 for (i = 0; i < ue->length; ++i) 877 free(ue->urls[i].doc); 878 free(ue->urls); 879 ue->length = ue->alloc_size = 0; 880 } 881 882 883 /*** Authentication-related utility functions ********************************/ 884 885 static const char * 886 fetch_read_word(FILE *f) 887 { 888 static char word[1024]; 889 890 if (fscanf(f, " %1023s ", word) != 1) 891 return (NULL); 892 return (word); 893 } 894 895 /* 896 * Get authentication data for a URL from .netrc 897 */ 898 int 899 fetch_netrc_auth(struct url *url) 900 { 901 char fn[PATH_MAX]; 902 const char *word; 903 char *p; 904 FILE *f; 905 906 if ((p = getenv("NETRC")) != NULL) { 907 if (snprintf(fn, sizeof(fn), "%s", p) >= (int)sizeof(fn)) { 908 fetch_info("$NETRC specifies a file name " 909 "longer than PATH_MAX"); 910 return (-1); 911 } 912 } else { 913 if ((p = getenv("HOME")) != NULL) { 914 struct passwd *pwd; 915 916 if ((pwd = getpwuid(getuid())) == NULL || 917 (p = pwd->pw_dir) == NULL) 918 return (-1); 919 } 920 if (snprintf(fn, sizeof(fn), "%s/.netrc", p) >= (int)sizeof(fn)) 921 return (-1); 922 } 923 924 if ((f = fopen(fn, "r")) == NULL) 925 return (-1); 926 while ((word = fetch_read_word(f)) != NULL) { 927 if (strcmp(word, "default") == 0) 928 break; 929 if (strcmp(word, "machine") == 0 && 930 (word = fetch_read_word(f)) != NULL && 931 strcasecmp(word, url->host) == 0) { 932 break; 933 } 934 } 935 if (word == NULL) 936 goto ferr; 937 while ((word = fetch_read_word(f)) != NULL) { 938 if (strcmp(word, "login") == 0) { 939 if ((word = fetch_read_word(f)) == NULL) 940 goto ferr; 941 if (snprintf(url->user, sizeof(url->user), 942 "%s", word) > (int)sizeof(url->user)) { 943 fetch_info("login name in .netrc is too long"); 944 url->user[0] = '\0'; 945 } 946 } else if (strcmp(word, "password") == 0) { 947 if ((word = fetch_read_word(f)) == NULL) 948 goto ferr; 949 if (snprintf(url->pwd, sizeof(url->pwd), 950 "%s", word) > (int)sizeof(url->pwd)) { 951 fetch_info("password in .netrc is too long"); 952 url->pwd[0] = '\0'; 953 } 954 } else if (strcmp(word, "account") == 0) { 955 if ((word = fetch_read_word(f)) == NULL) 956 goto ferr; 957 /* XXX not supported! */ 958 } else { 959 break; 960 } 961 } 962 fclose(f); 963 return (0); 964 ferr: 965 fclose(f); 966 return (-1); 967 } 968 969 /* 970 * The no_proxy environment variable specifies a set of domains for 971 * which the proxy should not be consulted; the contents is a comma-, 972 * or space-separated list of domain names. A single asterisk will 973 * override all proxy variables and no transactions will be proxied 974 * (for compatability with lynx and curl, see the discussion at 975 * <http://curl.haxx.se/mail/archive_pre_oct_99/0009.html>). 976 */ 977 int 978 fetch_no_proxy_match(const char *host) 979 { 980 const char *no_proxy, *p, *q; 981 size_t h_len, d_len; 982 983 if ((no_proxy = getenv("NO_PROXY")) == NULL && 984 (no_proxy = getenv("no_proxy")) == NULL) 985 return (0); 986 987 /* asterisk matches any hostname */ 988 if (strcmp(no_proxy, "*") == 0) 989 return (1); 990 991 h_len = strlen(host); 992 p = no_proxy; 993 do { 994 /* position p at the beginning of a domain suffix */ 995 while (*p == ',' || isspace((unsigned char)*p)) 996 p++; 997 998 /* position q at the first separator character */ 999 for (q = p; *q; ++q) 1000 if (*q == ',' || isspace((unsigned char)*q)) 1001 break; 1002 1003 d_len = q - p; 1004 if (d_len > 0 && h_len > d_len && 1005 strncasecmp(host + h_len - d_len, 1006 p, d_len) == 0) { 1007 /* domain name matches */ 1008 return (1); 1009 } 1010 1011 p = q + 1; 1012 } while (*q); 1013 1014 return (0); 1015 } 1016 1017 struct fetchIO { 1018 void *io_cookie; 1019 ssize_t (*io_read)(void *, void *, size_t); 1020 ssize_t (*io_write)(void *, const void *, size_t); 1021 void (*io_close)(void *); 1022 }; 1023 1024 void 1025 fetchIO_close(fetchIO *f) 1026 { 1027 if (f->io_close != NULL) 1028 (*f->io_close)(f->io_cookie); 1029 1030 free(f); 1031 } 1032 1033 fetchIO * 1034 fetchIO_unopen(void *io_cookie, ssize_t (*io_read)(void *, void *, size_t), 1035 ssize_t (*io_write)(void *, const void *, size_t), 1036 void (*io_close)(void *)) 1037 { 1038 fetchIO *f; 1039 1040 f = malloc(sizeof(*f)); 1041 if (f == NULL) 1042 return f; 1043 1044 f->io_cookie = io_cookie; 1045 f->io_read = io_read; 1046 f->io_write = io_write; 1047 f->io_close = io_close; 1048 1049 return f; 1050 } 1051 1052 ssize_t 1053 fetchIO_read(fetchIO *f, void *buf, size_t len) 1054 { 1055 if (f->io_read == NULL) 1056 return EBADF; 1057 return (*f->io_read)(f->io_cookie, buf, len); 1058 } 1059 1060 ssize_t 1061 fetchIO_write(fetchIO *f, const void *buf, size_t len) 1062 { 1063 if (f->io_read == NULL) 1064 return EBADF; 1065 return (*f->io_write)(f->io_cookie, buf, len); 1066 } 1067