1 /*************************************************************************** 2 * _ _ ____ _ 3 * Project ___| | | | _ \| | 4 * / __| | | | |_) | | 5 * | (__| |_| | _ <| |___ 6 * \___|\___/|_| \_\_____| 7 * 8 * Copyright (C) 1998 - 2019, Daniel Stenberg, <daniel (at) haxx.se>, et al. 9 * 10 * This software is licensed as described in the file COPYING, which 11 * you should have received as part of this distribution. The terms 12 * are also available at https://curl.haxx.se/docs/copyright.html. 13 * 14 * You may opt to use, copy, modify, merge, publish, distribute and/or sell 15 * copies of the Software, and permit persons to whom the Software is 16 * furnished to do so, under the terms of the COPYING file. 17 * 18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY 19 * KIND, either express or implied. 20 * 21 ***************************************************************************/ 22 23 #include "curl_setup.h" 24 25 #include <curl/curl.h> 26 27 #ifdef HAVE_NETINET_IN_H 28 # include <netinet/in.h> 29 #endif 30 #ifdef HAVE_NETINET_IN6_H 31 # include <netinet/in6.h> 32 #endif 33 #ifdef HAVE_NETDB_H 34 # include <netdb.h> 35 #endif 36 #ifdef HAVE_ARPA_INET_H 37 # include <arpa/inet.h> 38 #endif 39 #ifdef HAVE_SYS_UN_H 40 # include <sys/un.h> 41 #endif 42 43 #ifdef __VMS 44 # include <in.h> 45 # include <inet.h> 46 #endif 47 48 #if defined(NETWARE) && defined(__NOVELL_LIBC__) 49 # undef in_addr_t 50 # define in_addr_t unsigned long 51 #endif 52 53 #if defined(WIN32) && defined(USE_UNIX_SOCKETS) 54 #include <afunix.h> 55 #endif 56 57 #include <stddef.h> 58 59 #include "curl_addrinfo.h" 60 #include "inet_pton.h" 61 #include "warnless.h" 62 /* The last 3 #include files should be in this order */ 63 #include "curl_printf.h" 64 #include "curl_memory.h" 65 #include "memdebug.h" 66 67 /* 68 * Curl_freeaddrinfo() 69 * 70 * This is used to free a linked list of Curl_addrinfo structs along 71 * with all its associated allocated storage. This function should be 72 * called once for each successful call to Curl_getaddrinfo_ex() or to 73 * any function call which actually allocates a Curl_addrinfo struct. 74 */ 75 76 #if defined(__INTEL_COMPILER) && (__INTEL_COMPILER == 910) && \ 77 defined(__OPTIMIZE__) && defined(__unix__) && defined(__i386__) 78 /* workaround icc 9.1 optimizer issue */ 79 # define vqualifier volatile 80 #else 81 # define vqualifier 82 #endif 83 84 void 85 Curl_freeaddrinfo(Curl_addrinfo *cahead) 86 { 87 Curl_addrinfo *vqualifier canext; 88 Curl_addrinfo *ca; 89 90 for(ca = cahead; ca != NULL; ca = canext) { 91 free(ca->ai_addr); 92 free(ca->ai_canonname); 93 canext = ca->ai_next; 94 95 free(ca); 96 } 97 } 98 99 100 #ifdef HAVE_GETADDRINFO 101 /* 102 * Curl_getaddrinfo_ex() 103 * 104 * This is a wrapper function around system's getaddrinfo(), with 105 * the only difference that instead of returning a linked list of 106 * addrinfo structs this one returns a linked list of Curl_addrinfo 107 * ones. The memory allocated by this function *MUST* be free'd with 108 * Curl_freeaddrinfo(). For each successful call to this function 109 * there must be an associated call later to Curl_freeaddrinfo(). 110 * 111 * There should be no single call to system's getaddrinfo() in the 112 * whole library, any such call should be 'routed' through this one. 113 */ 114 115 int 116 Curl_getaddrinfo_ex(const char *nodename, 117 const char *servname, 118 const struct addrinfo *hints, 119 Curl_addrinfo **result) 120 { 121 const struct addrinfo *ai; 122 struct addrinfo *aihead; 123 Curl_addrinfo *cafirst = NULL; 124 Curl_addrinfo *calast = NULL; 125 Curl_addrinfo *ca; 126 size_t ss_size; 127 int error; 128 129 *result = NULL; /* assume failure */ 130 131 error = getaddrinfo(nodename, servname, hints, &aihead); 132 if(error) 133 return error; 134 135 /* traverse the addrinfo list */ 136 137 for(ai = aihead; ai != NULL; ai = ai->ai_next) { 138 139 /* ignore elements with unsupported address family, */ 140 /* settle family-specific sockaddr structure size. */ 141 if(ai->ai_family == AF_INET) 142 ss_size = sizeof(struct sockaddr_in); 143 #ifdef ENABLE_IPV6 144 else if(ai->ai_family == AF_INET6) 145 ss_size = sizeof(struct sockaddr_in6); 146 #endif 147 else 148 continue; 149 150 /* ignore elements without required address info */ 151 if((ai->ai_addr == NULL) || !(ai->ai_addrlen > 0)) 152 continue; 153 154 /* ignore elements with bogus address size */ 155 if((size_t)ai->ai_addrlen < ss_size) 156 continue; 157 158 ca = malloc(sizeof(Curl_addrinfo)); 159 if(!ca) { 160 error = EAI_MEMORY; 161 break; 162 } 163 164 /* copy each structure member individually, member ordering, */ 165 /* size, or padding might be different for each platform. */ 166 167 ca->ai_flags = ai->ai_flags; 168 ca->ai_family = ai->ai_family; 169 ca->ai_socktype = ai->ai_socktype; 170 ca->ai_protocol = ai->ai_protocol; 171 ca->ai_addrlen = (curl_socklen_t)ss_size; 172 ca->ai_addr = NULL; 173 ca->ai_canonname = NULL; 174 ca->ai_next = NULL; 175 176 ca->ai_addr = malloc(ss_size); 177 if(!ca->ai_addr) { 178 error = EAI_MEMORY; 179 free(ca); 180 break; 181 } 182 memcpy(ca->ai_addr, ai->ai_addr, ss_size); 183 184 if(ai->ai_canonname != NULL) { 185 ca->ai_canonname = strdup(ai->ai_canonname); 186 if(!ca->ai_canonname) { 187 error = EAI_MEMORY; 188 free(ca->ai_addr); 189 free(ca); 190 break; 191 } 192 } 193 194 /* if the return list is empty, this becomes the first element */ 195 if(!cafirst) 196 cafirst = ca; 197 198 /* add this element last in the return list */ 199 if(calast) 200 calast->ai_next = ca; 201 calast = ca; 202 203 } 204 205 /* destroy the addrinfo list */ 206 if(aihead) 207 freeaddrinfo(aihead); 208 209 /* if we failed, also destroy the Curl_addrinfo list */ 210 if(error) { 211 Curl_freeaddrinfo(cafirst); 212 cafirst = NULL; 213 } 214 else if(!cafirst) { 215 #ifdef EAI_NONAME 216 /* rfc3493 conformant */ 217 error = EAI_NONAME; 218 #else 219 /* rfc3493 obsoleted */ 220 error = EAI_NODATA; 221 #endif 222 #ifdef USE_WINSOCK 223 SET_SOCKERRNO(error); 224 #endif 225 } 226 227 *result = cafirst; 228 229 /* This is not a CURLcode */ 230 return error; 231 } 232 #endif /* HAVE_GETADDRINFO */ 233 234 235 /* 236 * Curl_he2ai() 237 * 238 * This function returns a pointer to the first element of a newly allocated 239 * Curl_addrinfo struct linked list filled with the data of a given hostent. 240 * Curl_addrinfo is meant to work like the addrinfo struct does for a IPv6 241 * stack, but usable also for IPv4, all hosts and environments. 242 * 243 * The memory allocated by this function *MUST* be free'd later on calling 244 * Curl_freeaddrinfo(). For each successful call to this function there 245 * must be an associated call later to Curl_freeaddrinfo(). 246 * 247 * Curl_addrinfo defined in "lib/curl_addrinfo.h" 248 * 249 * struct Curl_addrinfo { 250 * int ai_flags; 251 * int ai_family; 252 * int ai_socktype; 253 * int ai_protocol; 254 * curl_socklen_t ai_addrlen; * Follow rfc3493 struct addrinfo * 255 * char *ai_canonname; 256 * struct sockaddr *ai_addr; 257 * struct Curl_addrinfo *ai_next; 258 * }; 259 * typedef struct Curl_addrinfo Curl_addrinfo; 260 * 261 * hostent defined in <netdb.h> 262 * 263 * struct hostent { 264 * char *h_name; 265 * char **h_aliases; 266 * int h_addrtype; 267 * int h_length; 268 * char **h_addr_list; 269 * }; 270 * 271 * for backward compatibility: 272 * 273 * #define h_addr h_addr_list[0] 274 */ 275 276 Curl_addrinfo * 277 Curl_he2ai(const struct hostent *he, int port) 278 { 279 Curl_addrinfo *ai; 280 Curl_addrinfo *prevai = NULL; 281 Curl_addrinfo *firstai = NULL; 282 struct sockaddr_in *addr; 283 #ifdef ENABLE_IPV6 284 struct sockaddr_in6 *addr6; 285 #endif 286 CURLcode result = CURLE_OK; 287 int i; 288 char *curr; 289 290 if(!he) 291 /* no input == no output! */ 292 return NULL; 293 294 DEBUGASSERT((he->h_name != NULL) && (he->h_addr_list != NULL)); 295 296 for(i = 0; (curr = he->h_addr_list[i]) != NULL; i++) { 297 298 size_t ss_size; 299 #ifdef ENABLE_IPV6 300 if(he->h_addrtype == AF_INET6) 301 ss_size = sizeof(struct sockaddr_in6); 302 else 303 #endif 304 ss_size = sizeof(struct sockaddr_in); 305 306 ai = calloc(1, sizeof(Curl_addrinfo)); 307 if(!ai) { 308 result = CURLE_OUT_OF_MEMORY; 309 break; 310 } 311 ai->ai_canonname = strdup(he->h_name); 312 if(!ai->ai_canonname) { 313 result = CURLE_OUT_OF_MEMORY; 314 free(ai); 315 break; 316 } 317 ai->ai_addr = calloc(1, ss_size); 318 if(!ai->ai_addr) { 319 result = CURLE_OUT_OF_MEMORY; 320 free(ai->ai_canonname); 321 free(ai); 322 break; 323 } 324 325 if(!firstai) 326 /* store the pointer we want to return from this function */ 327 firstai = ai; 328 329 if(prevai) 330 /* make the previous entry point to this */ 331 prevai->ai_next = ai; 332 333 ai->ai_family = he->h_addrtype; 334 335 /* we return all names as STREAM, so when using this address for TFTP 336 the type must be ignored and conn->socktype be used instead! */ 337 ai->ai_socktype = SOCK_STREAM; 338 339 ai->ai_addrlen = (curl_socklen_t)ss_size; 340 341 /* leave the rest of the struct filled with zero */ 342 343 switch(ai->ai_family) { 344 case AF_INET: 345 addr = (void *)ai->ai_addr; /* storage area for this info */ 346 347 memcpy(&addr->sin_addr, curr, sizeof(struct in_addr)); 348 addr->sin_family = (CURL_SA_FAMILY_T)(he->h_addrtype); 349 addr->sin_port = htons((unsigned short)port); 350 break; 351 352 #ifdef ENABLE_IPV6 353 case AF_INET6: 354 addr6 = (void *)ai->ai_addr; /* storage area for this info */ 355 356 memcpy(&addr6->sin6_addr, curr, sizeof(struct in6_addr)); 357 addr6->sin6_family = (CURL_SA_FAMILY_T)(he->h_addrtype); 358 addr6->sin6_port = htons((unsigned short)port); 359 break; 360 #endif 361 } 362 363 prevai = ai; 364 } 365 366 if(result) { 367 Curl_freeaddrinfo(firstai); 368 firstai = NULL; 369 } 370 371 return firstai; 372 } 373 374 375 struct namebuff { 376 struct hostent hostentry; 377 union { 378 struct in_addr ina4; 379 #ifdef ENABLE_IPV6 380 struct in6_addr ina6; 381 #endif 382 } addrentry; 383 char *h_addr_list[2]; 384 }; 385 386 387 /* 388 * Curl_ip2addr() 389 * 390 * This function takes an internet address, in binary form, as input parameter 391 * along with its address family and the string version of the address, and it 392 * returns a Curl_addrinfo chain filled in correctly with information for the 393 * given address/host 394 */ 395 396 Curl_addrinfo * 397 Curl_ip2addr(int af, const void *inaddr, const char *hostname, int port) 398 { 399 Curl_addrinfo *ai; 400 401 #if defined(__VMS) && \ 402 defined(__INITIAL_POINTER_SIZE) && (__INITIAL_POINTER_SIZE == 64) 403 #pragma pointer_size save 404 #pragma pointer_size short 405 #pragma message disable PTRMISMATCH 406 #endif 407 408 struct hostent *h; 409 struct namebuff *buf; 410 char *addrentry; 411 char *hoststr; 412 size_t addrsize; 413 414 DEBUGASSERT(inaddr && hostname); 415 416 buf = malloc(sizeof(struct namebuff)); 417 if(!buf) 418 return NULL; 419 420 hoststr = strdup(hostname); 421 if(!hoststr) { 422 free(buf); 423 return NULL; 424 } 425 426 switch(af) { 427 case AF_INET: 428 addrsize = sizeof(struct in_addr); 429 addrentry = (void *)&buf->addrentry.ina4; 430 memcpy(addrentry, inaddr, sizeof(struct in_addr)); 431 break; 432 #ifdef ENABLE_IPV6 433 case AF_INET6: 434 addrsize = sizeof(struct in6_addr); 435 addrentry = (void *)&buf->addrentry.ina6; 436 memcpy(addrentry, inaddr, sizeof(struct in6_addr)); 437 break; 438 #endif 439 default: 440 free(hoststr); 441 free(buf); 442 return NULL; 443 } 444 445 h = &buf->hostentry; 446 h->h_name = hoststr; 447 h->h_aliases = NULL; 448 h->h_addrtype = (short)af; 449 h->h_length = (short)addrsize; 450 h->h_addr_list = &buf->h_addr_list[0]; 451 h->h_addr_list[0] = addrentry; 452 h->h_addr_list[1] = NULL; /* terminate list of entries */ 453 454 #if defined(__VMS) && \ 455 defined(__INITIAL_POINTER_SIZE) && (__INITIAL_POINTER_SIZE == 64) 456 #pragma pointer_size restore 457 #pragma message enable PTRMISMATCH 458 #endif 459 460 ai = Curl_he2ai(h, port); 461 462 free(hoststr); 463 free(buf); 464 465 return ai; 466 } 467 468 /* 469 * Given an IPv4 or IPv6 dotted string address, this converts it to a proper 470 * allocated Curl_addrinfo struct and returns it. 471 */ 472 Curl_addrinfo *Curl_str2addr(char *address, int port) 473 { 474 struct in_addr in; 475 if(Curl_inet_pton(AF_INET, address, &in) > 0) 476 /* This is a dotted IP address 123.123.123.123-style */ 477 return Curl_ip2addr(AF_INET, &in, address, port); 478 #ifdef ENABLE_IPV6 479 { 480 struct in6_addr in6; 481 if(Curl_inet_pton(AF_INET6, address, &in6) > 0) 482 /* This is a dotted IPv6 address ::1-style */ 483 return Curl_ip2addr(AF_INET6, &in6, address, port); 484 } 485 #endif 486 return NULL; /* bad input format */ 487 } 488 489 #ifdef USE_UNIX_SOCKETS 490 /** 491 * Given a path to a Unix domain socket, return a newly allocated Curl_addrinfo 492 * struct initialized with this path. 493 * Set '*longpath' to TRUE if the error is a too long path. 494 */ 495 Curl_addrinfo *Curl_unix2addr(const char *path, bool *longpath, bool abstract) 496 { 497 Curl_addrinfo *ai; 498 struct sockaddr_un *sa_un; 499 size_t path_len; 500 501 *longpath = FALSE; 502 503 ai = calloc(1, sizeof(Curl_addrinfo)); 504 if(!ai) 505 return NULL; 506 ai->ai_addr = calloc(1, sizeof(struct sockaddr_un)); 507 if(!ai->ai_addr) { 508 free(ai); 509 return NULL; 510 } 511 512 sa_un = (void *) ai->ai_addr; 513 sa_un->sun_family = AF_UNIX; 514 515 /* sun_path must be able to store the NUL-terminated path */ 516 path_len = strlen(path) + 1; 517 if(path_len > sizeof(sa_un->sun_path)) { 518 free(ai->ai_addr); 519 free(ai); 520 *longpath = TRUE; 521 return NULL; 522 } 523 524 ai->ai_family = AF_UNIX; 525 ai->ai_socktype = SOCK_STREAM; /* assume reliable transport for HTTP */ 526 ai->ai_addrlen = (curl_socklen_t) 527 ((offsetof(struct sockaddr_un, sun_path) + path_len) & 0x7FFFFFFF); 528 529 /* Abstract Unix domain socket have NULL prefix instead of suffix */ 530 if(abstract) 531 memcpy(sa_un->sun_path + 1, path, path_len - 1); 532 else 533 memcpy(sa_un->sun_path, path, path_len); /* copy NUL byte */ 534 535 return ai; 536 } 537 #endif 538 539 #if defined(CURLDEBUG) && defined(HAVE_GETADDRINFO) && \ 540 defined(HAVE_FREEADDRINFO) 541 /* 542 * curl_dbg_freeaddrinfo() 543 * 544 * This is strictly for memory tracing and are using the same style as the 545 * family otherwise present in memdebug.c. I put these ones here since they 546 * require a bunch of structs I didn't want to include in memdebug.c 547 */ 548 549 void 550 curl_dbg_freeaddrinfo(struct addrinfo *freethis, 551 int line, const char *source) 552 { 553 curl_dbg_log("ADDR %s:%d freeaddrinfo(%p)\n", 554 source, line, (void *)freethis); 555 #ifdef USE_LWIPSOCK 556 lwip_freeaddrinfo(freethis); 557 #else 558 (freeaddrinfo)(freethis); 559 #endif 560 } 561 #endif /* defined(CURLDEBUG) && defined(HAVE_FREEADDRINFO) */ 562 563 564 #if defined(CURLDEBUG) && defined(HAVE_GETADDRINFO) 565 /* 566 * curl_dbg_getaddrinfo() 567 * 568 * This is strictly for memory tracing and are using the same style as the 569 * family otherwise present in memdebug.c. I put these ones here since they 570 * require a bunch of structs I didn't want to include in memdebug.c 571 */ 572 573 int 574 curl_dbg_getaddrinfo(const char *hostname, 575 const char *service, 576 const struct addrinfo *hints, 577 struct addrinfo **result, 578 int line, const char *source) 579 { 580 #ifdef USE_LWIPSOCK 581 int res = lwip_getaddrinfo(hostname, service, hints, result); 582 #else 583 int res = (getaddrinfo)(hostname, service, hints, result); 584 #endif 585 if(0 == res) 586 /* success */ 587 curl_dbg_log("ADDR %s:%d getaddrinfo() = %p\n", 588 source, line, (void *)*result); 589 else 590 curl_dbg_log("ADDR %s:%d getaddrinfo() failed\n", 591 source, line); 592 return res; 593 } 594 #endif /* defined(CURLDEBUG) && defined(HAVE_GETADDRINFO) */ 595 596 #if defined(HAVE_GETADDRINFO) && defined(USE_RESOLVE_ON_IPS) 597 /* 598 * Work-arounds the sin6_port is always zero bug on iOS 9.3.2 and Mac OS X 599 * 10.11.5. 600 */ 601 void Curl_addrinfo_set_port(Curl_addrinfo *addrinfo, int port) 602 { 603 Curl_addrinfo *ca; 604 struct sockaddr_in *addr; 605 #ifdef ENABLE_IPV6 606 struct sockaddr_in6 *addr6; 607 #endif 608 for(ca = addrinfo; ca != NULL; ca = ca->ai_next) { 609 switch(ca->ai_family) { 610 case AF_INET: 611 addr = (void *)ca->ai_addr; /* storage area for this info */ 612 addr->sin_port = htons((unsigned short)port); 613 break; 614 615 #ifdef ENABLE_IPV6 616 case AF_INET6: 617 addr6 = (void *)ca->ai_addr; /* storage area for this info */ 618 addr6->sin6_port = htons((unsigned short)port); 619 break; 620 #endif 621 } 622 } 623 } 624 #endif 625
