1 /* 2 * HTTP address list routines for CUPS. 3 * 4 * Copyright 2007-2016 by Apple Inc. 5 * Copyright 1997-2007 by Easy Software Products, all rights reserved. 6 * 7 * These coded instructions, statements, and computer programs are the 8 * property of Apple Inc. and are protected by Federal copyright 9 * law. Distribution and use rights are outlined in the file "LICENSE.txt" 10 * which should have been included with this file. If this file is 11 * missing or damaged, see the license at "http://www.cups.org/". 12 * 13 * This file is subject to the Apple OS-Developed Software exception. 14 */ 15 16 /* 17 * Include necessary headers... 18 */ 19 20 #include "cups-private.h" 21 #ifdef HAVE_RESOLV_H 22 # include <resolv.h> 23 #endif /* HAVE_RESOLV_H */ 24 #ifdef HAVE_POLL 25 # include <poll.h> 26 #endif /* HAVE_POLL */ 27 #ifndef WIN32 28 # include <fcntl.h> 29 #endif /* WIN32 */ 30 31 32 /* 33 * 'httpAddrConnect()' - Connect to any of the addresses in the list. 34 * 35 * @since CUPS 1.2/macOS 10.5@ 36 */ 37 38 http_addrlist_t * /* O - Connected address or NULL on failure */ 39 httpAddrConnect( 40 http_addrlist_t *addrlist, /* I - List of potential addresses */ 41 int *sock) /* O - Socket */ 42 { 43 DEBUG_printf(("httpAddrConnect(addrlist=%p, sock=%p)", (void *)addrlist, (void *)sock)); 44 45 return (httpAddrConnect2(addrlist, sock, 30000, NULL)); 46 } 47 48 49 /* 50 * 'httpAddrConnect2()' - Connect to any of the addresses in the list with a 51 * timeout and optional cancel. 52 * 53 * @since CUPS 1.7/macOS 10.9@ 54 */ 55 56 http_addrlist_t * /* O - Connected address or NULL on failure */ 57 httpAddrConnect2( 58 http_addrlist_t *addrlist, /* I - List of potential addresses */ 59 int *sock, /* O - Socket */ 60 int msec, /* I - Timeout in milliseconds */ 61 int *cancel) /* I - Pointer to "cancel" variable */ 62 { 63 int val; /* Socket option value */ 64 #ifndef WIN32 65 int flags; /* Socket flags */ 66 #endif /* !WIN32 */ 67 int remaining; /* Remaining timeout */ 68 int i, /* Looping var */ 69 nfds, /* Number of file descriptors */ 70 fds[100], /* Socket file descriptors */ 71 result; /* Result from select() or poll() */ 72 http_addrlist_t *addrs[100]; /* Addresses */ 73 #ifndef HAVE_POLL 74 int max_fd = -1; /* Highest file descriptor */ 75 #endif /* !HAVE_POLL */ 76 #ifdef O_NONBLOCK 77 # ifdef HAVE_POLL 78 struct pollfd pfds[100]; /* Polled file descriptors */ 79 # else 80 fd_set input_set, /* select() input set */ 81 output_set, /* select() output set */ 82 error_set; /* select() error set */ 83 struct timeval timeout; /* Timeout */ 84 # endif /* HAVE_POLL */ 85 #endif /* O_NONBLOCK */ 86 #ifdef DEBUG 87 socklen_t len; /* Length of value */ 88 http_addr_t peer; /* Peer address */ 89 char temp[256]; /* Temporary address string */ 90 #endif /* DEBUG */ 91 92 93 DEBUG_printf(("httpAddrConnect2(addrlist=%p, sock=%p, msec=%d, cancel=%p)", (void *)addrlist, (void *)sock, msec, (void *)cancel)); 94 95 if (!sock) 96 { 97 errno = EINVAL; 98 _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(errno), 0); 99 return (NULL); 100 } 101 102 if (cancel && *cancel) 103 return (NULL); 104 105 if (msec <= 0) 106 msec = INT_MAX; 107 108 /* 109 * Loop through each address until we connect or run out of addresses... 110 */ 111 112 nfds = 0; 113 remaining = msec; 114 115 while (remaining > 0) 116 { 117 if (cancel && *cancel) 118 { 119 while (nfds > 0) 120 { 121 nfds --; 122 httpAddrClose(NULL, fds[nfds]); 123 } 124 125 return (NULL); 126 } 127 128 if (addrlist && nfds < (int)(sizeof(fds) / sizeof(fds[0]))) 129 { 130 /* 131 * Create the socket... 132 */ 133 134 DEBUG_printf(("2httpAddrConnect2: Trying %s:%d...", httpAddrString(&(addrlist->addr), temp, sizeof(temp)), httpAddrPort(&(addrlist->addr)))); 135 136 if ((fds[nfds] = (int)socket(httpAddrFamily(&(addrlist->addr)), SOCK_STREAM, 0)) < 0) 137 { 138 /* 139 * Don't abort yet, as this could just be an issue with the local 140 * system not being configured with IPv4/IPv6/domain socket enabled. 141 * 142 * Just skip this address... 143 */ 144 145 addrlist = addrlist->next; 146 continue; 147 } 148 149 /* 150 * Set options... 151 */ 152 153 val = 1; 154 setsockopt(fds[nfds], SOL_SOCKET, SO_REUSEADDR, CUPS_SOCAST &val, sizeof(val)); 155 156 #ifdef SO_REUSEPORT 157 val = 1; 158 setsockopt(fds[nfds], SOL_SOCKET, SO_REUSEPORT, CUPS_SOCAST &val, sizeof(val)); 159 #endif /* SO_REUSEPORT */ 160 161 #ifdef SO_NOSIGPIPE 162 val = 1; 163 setsockopt(fds[nfds], SOL_SOCKET, SO_NOSIGPIPE, CUPS_SOCAST &val, sizeof(val)); 164 #endif /* SO_NOSIGPIPE */ 165 166 /* 167 * Using TCP_NODELAY improves responsiveness, especially on systems 168 * with a slow loopback interface... 169 */ 170 171 val = 1; 172 setsockopt(fds[nfds], IPPROTO_TCP, TCP_NODELAY, CUPS_SOCAST &val, sizeof(val)); 173 174 #ifdef FD_CLOEXEC 175 /* 176 * Close this socket when starting another process... 177 */ 178 179 fcntl(fds[nfds], F_SETFD, FD_CLOEXEC); 180 #endif /* FD_CLOEXEC */ 181 182 #ifdef O_NONBLOCK 183 /* 184 * Do an asynchronous connect by setting the socket non-blocking... 185 */ 186 187 DEBUG_printf(("httpAddrConnect2: Setting non-blocking connect()")); 188 189 flags = fcntl(fds[nfds], F_GETFL, 0); 190 fcntl(fds[nfds], F_SETFL, flags | O_NONBLOCK); 191 #endif /* O_NONBLOCK */ 192 193 /* 194 * Then connect... 195 */ 196 197 if (!connect(fds[nfds], &(addrlist->addr.addr), (socklen_t)httpAddrLength(&(addrlist->addr)))) 198 { 199 DEBUG_printf(("1httpAddrConnect2: Connected to %s:%d...", httpAddrString(&(addrlist->addr), temp, sizeof(temp)), httpAddrPort(&(addrlist->addr)))); 200 201 #ifdef O_NONBLOCK 202 fcntl(fds[nfds], F_SETFL, flags); 203 #endif /* O_NONBLOCK */ 204 205 *sock = fds[nfds]; 206 207 while (nfds > 0) 208 { 209 nfds --; 210 httpAddrClose(NULL, fds[nfds]); 211 } 212 213 return (addrlist); 214 } 215 216 #ifdef WIN32 217 if (WSAGetLastError() != WSAEINPROGRESS && WSAGetLastError() != WSAEWOULDBLOCK) 218 #else 219 if (errno != EINPROGRESS && errno != EWOULDBLOCK) 220 #endif /* WIN32 */ 221 { 222 DEBUG_printf(("1httpAddrConnect2: Unable to connect to %s:%d: %s", httpAddrString(&(addrlist->addr), temp, sizeof(temp)), httpAddrPort(&(addrlist->addr)), strerror(errno))); 223 httpAddrClose(NULL, fds[nfds]); 224 addrlist = addrlist->next; 225 continue; 226 } 227 228 #ifndef WIN32 229 fcntl(fds[nfds], F_SETFL, flags); 230 #endif /* !WIN32 */ 231 232 #ifndef HAVE_POLL 233 if (fds[nfds] > max_fd) 234 max_fd = fds[nfds]; 235 #endif /* !HAVE_POLL */ 236 237 addrs[nfds] = addrlist; 238 nfds ++; 239 addrlist = addrlist->next; 240 } 241 242 if (!addrlist && nfds == 0) 243 break; 244 245 /* 246 * See if we can connect to any of the addresses so far... 247 */ 248 249 #ifdef O_NONBLOCK 250 DEBUG_puts("1httpAddrConnect2: Finishing async connect()"); 251 252 do 253 { 254 if (cancel && *cancel) 255 { 256 /* 257 * Close this socket and return... 258 */ 259 260 DEBUG_puts("1httpAddrConnect2: Canceled connect()"); 261 262 while (nfds > 0) 263 { 264 nfds --; 265 httpAddrClose(NULL, fds[nfds]); 266 } 267 268 *sock = -1; 269 270 return (NULL); 271 } 272 273 # ifdef HAVE_POLL 274 for (i = 0; i < nfds; i ++) 275 { 276 pfds[i].fd = fds[i]; 277 pfds[i].events = POLLIN | POLLOUT; 278 } 279 280 result = poll(pfds, (nfds_t)nfds, addrlist ? 100 : remaining > 250 ? 250 : remaining); 281 282 DEBUG_printf(("1httpAddrConnect2: poll() returned %d (%d)", result, errno)); 283 284 # else 285 FD_ZERO(&input_set); 286 for (i = 0; i < nfds; i ++) 287 FD_SET(fds[i], &input_set); 288 output_set = input_set; 289 error_set = input_set; 290 291 timeout.tv_sec = 0; 292 timeout.tv_usec = (addrlist ? 100 : remaining > 250 ? 250 : remaining) * 1000; 293 294 result = select(max_fd + 1, &input_set, &output_set, &error_set, &timeout); 295 296 DEBUG_printf(("1httpAddrConnect2: select() returned %d (%d)", result, errno)); 297 # endif /* HAVE_POLL */ 298 } 299 # ifdef WIN32 300 while (result < 0 && (WSAGetLastError() == WSAEINTR || WSAGetLastError() == WSAEWOULDBLOCK)); 301 # else 302 while (result < 0 && (errno == EINTR || errno == EAGAIN)); 303 # endif /* WIN32 */ 304 305 if (result > 0) 306 { 307 http_addrlist_t *connaddr = NULL; /* Connected address, if any */ 308 309 for (i = 0; i < nfds; i ++) 310 { 311 # ifdef HAVE_POLL 312 DEBUG_printf(("pfds[%d].revents=%x\n", i, pfds[i].revents)); 313 if (pfds[i].revents && !(pfds[i].revents & (POLLERR | POLLHUP))) 314 # else 315 if (FD_ISSET(fds[i], &input_set) && !FD_ISSET(fds[i], &error_set)) 316 # endif /* HAVE_POLL */ 317 { 318 *sock = fds[i]; 319 connaddr = addrs[i]; 320 321 # ifdef DEBUG 322 len = sizeof(peer); 323 if (!getpeername(fds[i], (struct sockaddr *)&peer, &len)) 324 DEBUG_printf(("1httpAddrConnect2: Connected to %s:%d...", httpAddrString(&peer, temp, sizeof(temp)), httpAddrPort(&peer))); 325 # endif /* DEBUG */ 326 } 327 # ifdef HAVE_POLL 328 else if (pfds[i].revents & (POLLERR | POLLHUP)) 329 # else 330 else if (FD_ISSET(fds[i], &error_set)) 331 # endif /* HAVE_POLL */ 332 { 333 /* 334 * Error on socket, remove from the "pool"... 335 */ 336 337 httpAddrClose(NULL, fds[i]); 338 nfds --; 339 if (i < nfds) 340 { 341 memmove(fds + i, fds + i + 1, (size_t)(nfds - i) * (sizeof(fds[0]))); 342 memmove(addrs + i, addrs + i + 1, (size_t)(nfds - i) * (sizeof(addrs[0]))); 343 } 344 i --; 345 } 346 } 347 348 if (connaddr) 349 return (connaddr); 350 } 351 #endif /* O_NONBLOCK */ 352 353 if (addrlist) 354 remaining -= 100; 355 else 356 remaining -= 250; 357 } 358 359 while (nfds > 0) 360 { 361 nfds --; 362 httpAddrClose(NULL, fds[nfds]); 363 } 364 365 #ifdef WIN32 366 _cupsSetError(IPP_STATUS_ERROR_SERVICE_UNAVAILABLE, "Connection failed", 0); 367 #else 368 _cupsSetError(IPP_STATUS_ERROR_SERVICE_UNAVAILABLE, strerror(errno), 0); 369 #endif /* WIN32 */ 370 371 return (NULL); 372 } 373 374 375 /* 376 * 'httpAddrCopyList()' - Copy an address list. 377 * 378 * @since CUPS 1.7/macOS 10.9@ 379 */ 380 381 http_addrlist_t * /* O - New address list or @code NULL@ on error */ 382 httpAddrCopyList( 383 http_addrlist_t *src) /* I - Source address list */ 384 { 385 http_addrlist_t *dst = NULL, /* First list entry */ 386 *prev = NULL, /* Previous list entry */ 387 *current = NULL;/* Current list entry */ 388 389 390 while (src) 391 { 392 if ((current = malloc(sizeof(http_addrlist_t))) == NULL) 393 { 394 current = dst; 395 396 while (current) 397 { 398 prev = current; 399 current = current->next; 400 401 free(prev); 402 } 403 404 return (NULL); 405 } 406 407 memcpy(current, src, sizeof(http_addrlist_t)); 408 409 current->next = NULL; 410 411 if (prev) 412 prev->next = current; 413 else 414 dst = current; 415 416 prev = current; 417 src = src->next; 418 } 419 420 return (dst); 421 } 422 423 424 /* 425 * 'httpAddrFreeList()' - Free an address list. 426 * 427 * @since CUPS 1.2/macOS 10.5@ 428 */ 429 430 void 431 httpAddrFreeList( 432 http_addrlist_t *addrlist) /* I - Address list to free */ 433 { 434 http_addrlist_t *next; /* Next address in list */ 435 436 437 /* 438 * Free each address in the list... 439 */ 440 441 while (addrlist) 442 { 443 next = addrlist->next; 444 445 free(addrlist); 446 447 addrlist = next; 448 } 449 } 450 451 452 /* 453 * 'httpAddrGetList()' - Get a list of addresses for a hostname. 454 * 455 * @since CUPS 1.2/macOS 10.5@ 456 */ 457 458 http_addrlist_t * /* O - List of addresses or NULL */ 459 httpAddrGetList(const char *hostname, /* I - Hostname, IP address, or NULL for passive listen address */ 460 int family, /* I - Address family or AF_UNSPEC */ 461 const char *service) /* I - Service name or port number */ 462 { 463 http_addrlist_t *first, /* First address in list */ 464 *addr, /* Current address in list */ 465 *temp; /* New address */ 466 _cups_globals_t *cg = _cupsGlobals(); 467 /* Global data */ 468 469 470 #ifdef DEBUG 471 _cups_debug_printf("httpAddrGetList(hostname=\"%s\", family=AF_%s, " 472 "service=\"%s\")\n", 473 hostname ? hostname : "(nil)", 474 family == AF_UNSPEC ? "UNSPEC" : 475 # ifdef AF_LOCAL 476 family == AF_LOCAL ? "LOCAL" : 477 # endif /* AF_LOCAL */ 478 # ifdef AF_INET6 479 family == AF_INET6 ? "INET6" : 480 # endif /* AF_INET6 */ 481 family == AF_INET ? "INET" : "???", service); 482 #endif /* DEBUG */ 483 484 #ifdef HAVE_RES_INIT 485 /* 486 * STR #2920: Initialize resolver after failure in cups-polld 487 * 488 * If the previous lookup failed, re-initialize the resolver to prevent 489 * temporary network errors from persisting. This *should* be handled by 490 * the resolver libraries, but apparently the glibc folks do not agree. 491 * 492 * We set a flag at the end of this function if we encounter an error that 493 * requires reinitialization of the resolver functions. We then call 494 * res_init() if the flag is set on the next call here or in httpAddrLookup(). 495 */ 496 497 if (cg->need_res_init) 498 { 499 res_init(); 500 501 cg->need_res_init = 0; 502 } 503 #endif /* HAVE_RES_INIT */ 504 505 /* 506 * Lookup the address the best way we can... 507 */ 508 509 first = addr = NULL; 510 511 #ifdef AF_LOCAL 512 if (hostname && hostname[0] == '/') 513 { 514 /* 515 * Domain socket address... 516 */ 517 518 if ((first = (http_addrlist_t *)calloc(1, sizeof(http_addrlist_t))) != NULL) 519 { 520 addr = first; 521 first->addr.un.sun_family = AF_LOCAL; 522 strlcpy(first->addr.un.sun_path, hostname, sizeof(first->addr.un.sun_path)); 523 } 524 } 525 else 526 #endif /* AF_LOCAL */ 527 if (!hostname || _cups_strcasecmp(hostname, "localhost")) 528 { 529 #ifdef HAVE_GETADDRINFO 530 struct addrinfo hints, /* Address lookup hints */ 531 *results, /* Address lookup results */ 532 *current; /* Current result */ 533 char ipv6[64], /* IPv6 address */ 534 *ipv6zone; /* Pointer to zone separator */ 535 int ipv6len; /* Length of IPv6 address */ 536 int error; /* getaddrinfo() error */ 537 538 539 /* 540 * Lookup the address as needed... 541 */ 542 543 memset(&hints, 0, sizeof(hints)); 544 hints.ai_family = family; 545 hints.ai_flags = hostname ? 0 : AI_PASSIVE; 546 hints.ai_socktype = SOCK_STREAM; 547 548 if (hostname && *hostname == '[') 549 { 550 /* 551 * Remove brackets from numeric IPv6 address... 552 */ 553 554 if (!strncmp(hostname, "[v1.", 4)) 555 { 556 /* 557 * Copy the newer address format which supports link-local addresses... 558 */ 559 560 strlcpy(ipv6, hostname + 4, sizeof(ipv6)); 561 if ((ipv6len = (int)strlen(ipv6) - 1) >= 0 && ipv6[ipv6len] == ']') 562 { 563 ipv6[ipv6len] = '\0'; 564 hostname = ipv6; 565 566 /* 567 * Convert "+zone" in address to "%zone"... 568 */ 569 570 if ((ipv6zone = strrchr(ipv6, '+')) != NULL) 571 *ipv6zone = '%'; 572 } 573 } 574 else 575 { 576 /* 577 * Copy the regular non-link-local IPv6 address... 578 */ 579 580 strlcpy(ipv6, hostname + 1, sizeof(ipv6)); 581 if ((ipv6len = (int)strlen(ipv6) - 1) >= 0 && ipv6[ipv6len] == ']') 582 { 583 ipv6[ipv6len] = '\0'; 584 hostname = ipv6; 585 } 586 } 587 } 588 589 if ((error = getaddrinfo(hostname, service, &hints, &results)) == 0) 590 { 591 /* 592 * Copy the results to our own address list structure... 593 */ 594 595 for (current = results; current; current = current->ai_next) 596 if (current->ai_family == AF_INET || current->ai_family == AF_INET6) 597 { 598 /* 599 * Copy the address over... 600 */ 601 602 temp = (http_addrlist_t *)calloc(1, sizeof(http_addrlist_t)); 603 if (!temp) 604 { 605 httpAddrFreeList(first); 606 _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(errno), 0); 607 return (NULL); 608 } 609 610 if (current->ai_family == AF_INET6) 611 memcpy(&(temp->addr.ipv6), current->ai_addr, 612 sizeof(temp->addr.ipv6)); 613 else 614 memcpy(&(temp->addr.ipv4), current->ai_addr, 615 sizeof(temp->addr.ipv4)); 616 617 /* 618 * Append the address to the list... 619 */ 620 621 if (!first) 622 first = temp; 623 624 if (addr) 625 addr->next = temp; 626 627 addr = temp; 628 } 629 630 /* 631 * Free the results from getaddrinfo()... 632 */ 633 634 freeaddrinfo(results); 635 } 636 else 637 { 638 if (error == EAI_FAIL) 639 cg->need_res_init = 1; 640 641 _cupsSetError(IPP_STATUS_ERROR_INTERNAL, gai_strerror(error), 0); 642 } 643 644 #else 645 if (hostname) 646 { 647 int i; /* Looping vars */ 648 unsigned ip[4]; /* IPv4 address components */ 649 const char *ptr; /* Pointer into hostname */ 650 struct hostent *host; /* Result of lookup */ 651 struct servent *port; /* Port number for service */ 652 int portnum; /* Port number */ 653 654 655 /* 656 * Lookup the service... 657 */ 658 659 if (!service) 660 portnum = 0; 661 else if (isdigit(*service & 255)) 662 portnum = atoi(service); 663 else if ((port = getservbyname(service, NULL)) != NULL) 664 portnum = ntohs(port->s_port); 665 else if (!strcmp(service, "http")) 666 portnum = 80; 667 else if (!strcmp(service, "https")) 668 portnum = 443; 669 else if (!strcmp(service, "ipp") || !strcmp(service, "ipps")) 670 portnum = 631; 671 else if (!strcmp(service, "lpd")) 672 portnum = 515; 673 else if (!strcmp(service, "socket")) 674 portnum = 9100; 675 else 676 return (NULL); 677 678 /* 679 * This code is needed because some operating systems have a 680 * buggy implementation of gethostbyname() that does not support 681 * IPv4 addresses. If the hostname string is an IPv4 address, then 682 * sscanf() is used to extract the IPv4 components. We then pack 683 * the components into an IPv4 address manually, since the 684 * inet_aton() function is deprecated. We use the htonl() macro 685 * to get the right byte order for the address. 686 */ 687 688 for (ptr = hostname; isdigit(*ptr & 255) || *ptr == '.'; ptr ++); 689 690 if (!*ptr) 691 { 692 /* 693 * We have an IPv4 address; break it up and create an IPv4 address... 694 */ 695 696 if (sscanf(hostname, "%u.%u.%u.%u", ip, ip + 1, ip + 2, ip + 3) == 4 && 697 ip[0] <= 255 && ip[1] <= 255 && ip[2] <= 255 && ip[3] <= 255) 698 { 699 first = (http_addrlist_t *)calloc(1, sizeof(http_addrlist_t)); 700 if (!first) 701 return (NULL); 702 703 first->addr.ipv4.sin_family = AF_INET; 704 first->addr.ipv4.sin_addr.s_addr = htonl((((((((unsigned)ip[0] << 8) | 705 (unsigned)ip[1]) << 8) | 706 (unsigned)ip[2]) << 8) | 707 (unsigned)ip[3])); 708 first->addr.ipv4.sin_port = htons(portnum); 709 } 710 } 711 else if ((host = gethostbyname(hostname)) != NULL && 712 # ifdef AF_INET6 713 (host->h_addrtype == AF_INET || host->h_addrtype == AF_INET6)) 714 # else 715 host->h_addrtype == AF_INET) 716 # endif /* AF_INET6 */ 717 { 718 for (i = 0; host->h_addr_list[i]; i ++) 719 { 720 /* 721 * Copy the address over... 722 */ 723 724 temp = (http_addrlist_t *)calloc(1, sizeof(http_addrlist_t)); 725 if (!temp) 726 { 727 httpAddrFreeList(first); 728 return (NULL); 729 } 730 731 # ifdef AF_INET6 732 if (host->h_addrtype == AF_INET6) 733 { 734 temp->addr.ipv6.sin6_family = AF_INET6; 735 memcpy(&(temp->addr.ipv6.sin6_addr), host->h_addr_list[i], 736 sizeof(temp->addr.ipv6)); 737 temp->addr.ipv6.sin6_port = htons(portnum); 738 } 739 else 740 # endif /* AF_INET6 */ 741 { 742 temp->addr.ipv4.sin_family = AF_INET; 743 memcpy(&(temp->addr.ipv4.sin_addr), host->h_addr_list[i], 744 sizeof(temp->addr.ipv4)); 745 temp->addr.ipv4.sin_port = htons(portnum); 746 } 747 748 /* 749 * Append the address to the list... 750 */ 751 752 if (!first) 753 first = temp; 754 755 if (addr) 756 addr->next = temp; 757 758 addr = temp; 759 } 760 } 761 else 762 { 763 if (h_errno == NO_RECOVERY) 764 cg->need_res_init = 1; 765 766 _cupsSetError(IPP_STATUS_ERROR_INTERNAL, hstrerror(h_errno), 0); 767 } 768 } 769 #endif /* HAVE_GETADDRINFO */ 770 } 771 772 /* 773 * Detect some common errors and handle them sanely... 774 */ 775 776 if (!addr && (!hostname || !_cups_strcasecmp(hostname, "localhost"))) 777 { 778 struct servent *port; /* Port number for service */ 779 int portnum; /* Port number */ 780 781 782 /* 783 * Lookup the service... 784 */ 785 786 if (!service) 787 portnum = 0; 788 else if (isdigit(*service & 255)) 789 portnum = atoi(service); 790 else if ((port = getservbyname(service, NULL)) != NULL) 791 portnum = ntohs(port->s_port); 792 else if (!strcmp(service, "http")) 793 portnum = 80; 794 else if (!strcmp(service, "https")) 795 portnum = 443; 796 else if (!strcmp(service, "ipp") || !strcmp(service, "ipps")) 797 portnum = 631; 798 else if (!strcmp(service, "lpd")) 799 portnum = 515; 800 else if (!strcmp(service, "socket")) 801 portnum = 9100; 802 else 803 { 804 httpAddrFreeList(first); 805 806 _cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("Unknown service name."), 1); 807 return (NULL); 808 } 809 810 if (hostname && !_cups_strcasecmp(hostname, "localhost")) 811 { 812 /* 813 * Unfortunately, some users ignore all of the warnings in the 814 * /etc/hosts file and delete "localhost" from it. If we get here 815 * then we were unable to resolve the name, so use the IPv6 and/or 816 * IPv4 loopback interface addresses... 817 */ 818 819 #ifdef AF_INET6 820 if (family != AF_INET) 821 { 822 /* 823 * Add [::1] to the address list... 824 */ 825 826 temp = (http_addrlist_t *)calloc(1, sizeof(http_addrlist_t)); 827 if (!temp) 828 { 829 _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(errno), 0); 830 httpAddrFreeList(first); 831 return (NULL); 832 } 833 834 temp->addr.ipv6.sin6_family = AF_INET6; 835 temp->addr.ipv6.sin6_port = htons(portnum); 836 # ifdef WIN32 837 temp->addr.ipv6.sin6_addr.u.Byte[15] = 1; 838 # else 839 temp->addr.ipv6.sin6_addr.s6_addr32[3] = htonl(1); 840 # endif /* WIN32 */ 841 842 if (!first) 843 first = temp; 844 845 addr = temp; 846 } 847 848 if (family != AF_INET6) 849 #endif /* AF_INET6 */ 850 { 851 /* 852 * Add 127.0.0.1 to the address list... 853 */ 854 855 temp = (http_addrlist_t *)calloc(1, sizeof(http_addrlist_t)); 856 if (!temp) 857 { 858 _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(errno), 0); 859 httpAddrFreeList(first); 860 return (NULL); 861 } 862 863 temp->addr.ipv4.sin_family = AF_INET; 864 temp->addr.ipv4.sin_port = htons(portnum); 865 temp->addr.ipv4.sin_addr.s_addr = htonl(0x7f000001); 866 867 if (!first) 868 first = temp; 869 870 if (addr) 871 addr->next = temp; 872 } 873 } 874 else if (!hostname) 875 { 876 /* 877 * Provide one or more passive listening addresses... 878 */ 879 880 #ifdef AF_INET6 881 if (family != AF_INET) 882 { 883 /* 884 * Add [::] to the address list... 885 */ 886 887 temp = (http_addrlist_t *)calloc(1, sizeof(http_addrlist_t)); 888 if (!temp) 889 { 890 _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(errno), 0); 891 httpAddrFreeList(first); 892 return (NULL); 893 } 894 895 temp->addr.ipv6.sin6_family = AF_INET6; 896 temp->addr.ipv6.sin6_port = htons(portnum); 897 898 if (!first) 899 first = temp; 900 901 addr = temp; 902 } 903 904 if (family != AF_INET6) 905 #endif /* AF_INET6 */ 906 { 907 /* 908 * Add 0.0.0.0 to the address list... 909 */ 910 911 temp = (http_addrlist_t *)calloc(1, sizeof(http_addrlist_t)); 912 if (!temp) 913 { 914 _cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(errno), 0); 915 httpAddrFreeList(first); 916 return (NULL); 917 } 918 919 temp->addr.ipv4.sin_family = AF_INET; 920 temp->addr.ipv4.sin_port = htons(portnum); 921 922 if (!first) 923 first = temp; 924 925 if (addr) 926 addr->next = temp; 927 } 928 } 929 } 930 931 /* 932 * Return the address list... 933 */ 934 935 return (first); 936 } 937
