Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 1 | /*************************************************************************** |
| 2 | * _ _ ____ _ |
| 3 | * Project ___| | | | _ \| | |
| 4 | * / __| | | | |_) | | |
| 5 | * | (__| |_| | _ <| |___ |
| 6 | * \___|\___/|_| \_\_____| |
| 7 | * |
Elliott Hughes | cac3980 | 2018-04-27 16:19:43 -0700 | [diff] [blame] | 8 | * Copyright (C) 1998 - 2018, Daniel Stenberg, <daniel@haxx.se>, et al. |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 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 |
Alex Deymo | d15eaac | 2016-06-28 14:49:26 -0700 | [diff] [blame] | 12 | * are also available at https://curl.haxx.se/docs/copyright.html. |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 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 | |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 23 | #include "curl_setup.h" |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 24 | |
| 25 | #include <curl/curl.h> |
| 26 | |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 27 | #ifdef HAVE_NETINET_IN_H |
| 28 | # include <netinet/in.h> |
| 29 | #endif |
Elliott Hughes | 0128fe4 | 2018-02-27 14:57:55 -0800 | [diff] [blame] | 30 | #ifdef HAVE_NETINET_IN6_H |
| 31 | # include <netinet/in6.h> |
| 32 | #endif |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 33 | #ifdef HAVE_NETDB_H |
| 34 | # include <netdb.h> |
| 35 | #endif |
| 36 | #ifdef HAVE_ARPA_INET_H |
| 37 | # include <arpa/inet.h> |
| 38 | #endif |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 39 | #ifdef HAVE_SYS_UN_H |
| 40 | # include <sys/un.h> |
| 41 | #endif |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 42 | |
| 43 | #ifdef __VMS |
| 44 | # include <in.h> |
| 45 | # include <inet.h> |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 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 | |
Elliott Hughes | cac3980 | 2018-04-27 16:19:43 -0700 | [diff] [blame] | 53 | #if defined(WIN32) && defined(USE_UNIX_SOCKETS) |
| 54 | #include <afunix.h> |
| 55 | #endif |
| 56 | |
Elliott Hughes | 82be86d | 2017-09-20 17:00:17 -0700 | [diff] [blame] | 57 | #include <stddef.h> |
| 58 | |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 59 | #include "curl_addrinfo.h" |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 60 | #include "inet_pton.h" |
| 61 | #include "warnless.h" |
Alex Deymo | d15eaac | 2016-06-28 14:49:26 -0700 | [diff] [blame] | 62 | /* The last 3 #include files should be in this order */ |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 63 | #include "curl_printf.h" |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 64 | #include "curl_memory.h" |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 65 | #include "memdebug.h" |
| 66 | |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 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) { |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 91 | free(ca->ai_addr); |
| 92 | free(ca->ai_canonname); |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 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 | { |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 121 | const struct addrinfo *ai; |
| 122 | struct addrinfo *aihead; |
| 123 | Curl_addrinfo *cafirst = NULL; |
| 124 | Curl_addrinfo *calast = NULL; |
| 125 | Curl_addrinfo *ca; |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 126 | size_t ss_size; |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 127 | int error; |
| 128 | |
| 129 | *result = NULL; /* assume failure */ |
| 130 | |
| 131 | error = getaddrinfo(nodename, servname, hints, &aihead); |
| 132 | if(error) |
| 133 | return error; |
| 134 | |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 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; |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 157 | |
Elliott Hughes | 82be86d | 2017-09-20 17:00:17 -0700 | [diff] [blame] | 158 | ca = malloc(sizeof(Curl_addrinfo)); |
| 159 | if(!ca) { |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 160 | error = EAI_MEMORY; |
| 161 | break; |
| 162 | } |
| 163 | |
| 164 | /* copy each structure member individually, member ordering, */ |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 165 | /* size, or padding might be different for each platform. */ |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 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; |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 171 | ca->ai_addrlen = (curl_socklen_t)ss_size; |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 172 | ca->ai_addr = NULL; |
| 173 | ca->ai_canonname = NULL; |
| 174 | ca->ai_next = NULL; |
| 175 | |
Elliott Hughes | 82be86d | 2017-09-20 17:00:17 -0700 | [diff] [blame] | 176 | ca->ai_addr = malloc(ss_size); |
| 177 | if(!ca->ai_addr) { |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 178 | error = EAI_MEMORY; |
| 179 | free(ca); |
| 180 | break; |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 181 | } |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 182 | memcpy(ca->ai_addr, ai->ai_addr, ss_size); |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 183 | |
| 184 | if(ai->ai_canonname != NULL) { |
Elliott Hughes | 82be86d | 2017-09-20 17:00:17 -0700 | [diff] [blame] | 185 | ca->ai_canonname = strdup(ai->ai_canonname); |
| 186 | if(!ca->ai_canonname) { |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 187 | error = EAI_MEMORY; |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 188 | free(ca->ai_addr); |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 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 | |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 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 | } |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 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 | } |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 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 | |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 296 | for(i = 0; (curr = he->h_addr_list[i]) != NULL; i++) { |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 297 | |
| 298 | size_t ss_size; |
| 299 | #ifdef ENABLE_IPV6 |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 300 | if(he->h_addrtype == AF_INET6) |
Elliott Hughes | 82be86d | 2017-09-20 17:00:17 -0700 | [diff] [blame] | 301 | ss_size = sizeof(struct sockaddr_in6); |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 302 | else |
| 303 | #endif |
Elliott Hughes | 82be86d | 2017-09-20 17:00:17 -0700 | [diff] [blame] | 304 | ss_size = sizeof(struct sockaddr_in); |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 305 | |
Elliott Hughes | 82be86d | 2017-09-20 17:00:17 -0700 | [diff] [blame] | 306 | ai = calloc(1, sizeof(Curl_addrinfo)); |
| 307 | if(!ai) { |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 308 | result = CURLE_OUT_OF_MEMORY; |
| 309 | break; |
| 310 | } |
Elliott Hughes | 82be86d | 2017-09-20 17:00:17 -0700 | [diff] [blame] | 311 | ai->ai_canonname = strdup(he->h_name); |
| 312 | if(!ai->ai_canonname) { |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 313 | result = CURLE_OUT_OF_MEMORY; |
| 314 | free(ai); |
| 315 | break; |
| 316 | } |
Elliott Hughes | 82be86d | 2017-09-20 17:00:17 -0700 | [diff] [blame] | 317 | ai->ai_addr = calloc(1, ss_size); |
| 318 | if(!ai->ai_addr) { |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 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 | |
Elliott Hughes | 82be86d | 2017-09-20 17:00:17 -0700 | [diff] [blame] | 343 | switch(ai->ai_family) { |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 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)); |
Elliott Hughes | 1ef06ba | 2018-05-30 15:43:58 -0700 | [diff] [blame] | 348 | addr->sin_family = (CURL_SA_FAMILY_T)(he->h_addrtype); |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 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)); |
Elliott Hughes | 1ef06ba | 2018-05-30 15:43:58 -0700 | [diff] [blame] | 357 | addr6->sin6_family = (CURL_SA_FAMILY_T)(he->h_addrtype); |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 358 | addr6->sin6_port = htons((unsigned short)port); |
| 359 | break; |
| 360 | #endif |
| 361 | } |
| 362 | |
| 363 | prevai = ai; |
| 364 | } |
| 365 | |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 366 | if(result) { |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 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 | |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 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 |
Elliott Hughes | 82be86d | 2017-09-20 17:00:17 -0700 | [diff] [blame] | 479 | { |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 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. |
Elliott Hughes | 82be86d | 2017-09-20 17:00:17 -0700 | [diff] [blame] | 493 | * Set '*longpath' to TRUE if the error is a too long path. |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 494 | */ |
Elliott Hughes | 82be86d | 2017-09-20 17:00:17 -0700 | [diff] [blame] | 495 | Curl_addrinfo *Curl_unix2addr(const char *path, bool *longpath, bool abstract) |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 496 | { |
| 497 | Curl_addrinfo *ai; |
| 498 | struct sockaddr_un *sa_un; |
| 499 | size_t path_len; |
| 500 | |
Elliott Hughes | 82be86d | 2017-09-20 17:00:17 -0700 | [diff] [blame] | 501 | *longpath = FALSE; |
| 502 | |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 503 | ai = calloc(1, sizeof(Curl_addrinfo)); |
| 504 | if(!ai) |
| 505 | return NULL; |
Elliott Hughes | 82be86d | 2017-09-20 17:00:17 -0700 | [diff] [blame] | 506 | ai->ai_addr = calloc(1, sizeof(struct sockaddr_un)); |
| 507 | if(!ai->ai_addr) { |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 508 | free(ai); |
| 509 | return NULL; |
| 510 | } |
Elliott Hughes | 82be86d | 2017-09-20 17:00:17 -0700 | [diff] [blame] | 511 | |
| 512 | sa_un = (void *) ai->ai_addr; |
| 513 | sa_un->sun_family = AF_UNIX; |
| 514 | |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 515 | /* sun_path must be able to store the NUL-terminated path */ |
Elliott Hughes | 82be86d | 2017-09-20 17:00:17 -0700 | [diff] [blame] | 516 | path_len = strlen(path) + 1; |
| 517 | if(path_len > sizeof(sa_un->sun_path)) { |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 518 | free(ai->ai_addr); |
| 519 | free(ai); |
Elliott Hughes | 82be86d | 2017-09-20 17:00:17 -0700 | [diff] [blame] | 520 | *longpath = TRUE; |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 521 | return NULL; |
| 522 | } |
| 523 | |
| 524 | ai->ai_family = AF_UNIX; |
| 525 | ai->ai_socktype = SOCK_STREAM; /* assume reliable transport for HTTP */ |
Elliott Hughes | 82be86d | 2017-09-20 17:00:17 -0700 | [diff] [blame] | 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 | |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 535 | return ai; |
| 536 | } |
| 537 | #endif |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 538 | |
| 539 | #if defined(CURLDEBUG) && defined(HAVE_FREEADDRINFO) |
| 540 | /* |
| 541 | * curl_dofreeaddrinfo() |
| 542 | * |
| 543 | * This is strictly for memory tracing and are using the same style as the |
| 544 | * family otherwise present in memdebug.c. I put these ones here since they |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 545 | * require a bunch of structs I didn't want to include in memdebug.c |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 546 | */ |
| 547 | |
| 548 | void |
| 549 | curl_dofreeaddrinfo(struct addrinfo *freethis, |
| 550 | int line, const char *source) |
| 551 | { |
Alex Deymo | d15eaac | 2016-06-28 14:49:26 -0700 | [diff] [blame] | 552 | #ifdef USE_LWIPSOCK |
| 553 | lwip_freeaddrinfo(freethis); |
| 554 | #else |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 555 | (freeaddrinfo)(freethis); |
Alex Deymo | d15eaac | 2016-06-28 14:49:26 -0700 | [diff] [blame] | 556 | #endif |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 557 | curl_memlog("ADDR %s:%d freeaddrinfo(%p)\n", |
| 558 | source, line, (void *)freethis); |
| 559 | } |
| 560 | #endif /* defined(CURLDEBUG) && defined(HAVE_FREEADDRINFO) */ |
| 561 | |
| 562 | |
| 563 | #if defined(CURLDEBUG) && defined(HAVE_GETADDRINFO) |
| 564 | /* |
| 565 | * curl_dogetaddrinfo() |
| 566 | * |
| 567 | * This is strictly for memory tracing and are using the same style as the |
| 568 | * family otherwise present in memdebug.c. I put these ones here since they |
Bertrand SIMONNET | e6cd738 | 2015-07-01 15:39:44 -0700 | [diff] [blame] | 569 | * require a bunch of structs I didn't want to include in memdebug.c |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 570 | */ |
| 571 | |
| 572 | int |
| 573 | curl_dogetaddrinfo(const char *hostname, |
| 574 | const char *service, |
| 575 | const struct addrinfo *hints, |
| 576 | struct addrinfo **result, |
| 577 | int line, const char *source) |
| 578 | { |
Alex Deymo | d15eaac | 2016-06-28 14:49:26 -0700 | [diff] [blame] | 579 | #ifdef USE_LWIPSOCK |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 580 | int res = lwip_getaddrinfo(hostname, service, hints, result); |
Alex Deymo | d15eaac | 2016-06-28 14:49:26 -0700 | [diff] [blame] | 581 | #else |
Alex Deymo | 486467e | 2017-12-19 19:04:07 +0100 | [diff] [blame] | 582 | int res = (getaddrinfo)(hostname, service, hints, result); |
Alex Deymo | d15eaac | 2016-06-28 14:49:26 -0700 | [diff] [blame] | 583 | #endif |
Kristian Monsen | 5ab5018 | 2010-05-14 18:53:44 +0100 | [diff] [blame] | 584 | if(0 == res) |
| 585 | /* success */ |
| 586 | curl_memlog("ADDR %s:%d getaddrinfo() = %p\n", |
| 587 | source, line, (void *)*result); |
| 588 | else |
| 589 | curl_memlog("ADDR %s:%d getaddrinfo() failed\n", |
| 590 | source, line); |
| 591 | return res; |
| 592 | } |
| 593 | #endif /* defined(CURLDEBUG) && defined(HAVE_GETADDRINFO) */ |
| 594 | |
Alex Deymo | e3149cc | 2016-10-05 11:18:42 -0700 | [diff] [blame] | 595 | #if defined(HAVE_GETADDRINFO) && defined(USE_RESOLVE_ON_IPS) |
| 596 | /* |
| 597 | * Work-arounds the sin6_port is always zero bug on iOS 9.3.2 and Mac OS X |
| 598 | * 10.11.5. |
| 599 | */ |
| 600 | void Curl_addrinfo_set_port(Curl_addrinfo *addrinfo, int port) |
| 601 | { |
| 602 | Curl_addrinfo *ca; |
| 603 | struct sockaddr_in *addr; |
| 604 | #ifdef ENABLE_IPV6 |
| 605 | struct sockaddr_in6 *addr6; |
| 606 | #endif |
| 607 | for(ca = addrinfo; ca != NULL; ca = ca->ai_next) { |
Elliott Hughes | 82be86d | 2017-09-20 17:00:17 -0700 | [diff] [blame] | 608 | switch(ca->ai_family) { |
Alex Deymo | e3149cc | 2016-10-05 11:18:42 -0700 | [diff] [blame] | 609 | case AF_INET: |
| 610 | addr = (void *)ca->ai_addr; /* storage area for this info */ |
| 611 | addr->sin_port = htons((unsigned short)port); |
| 612 | break; |
| 613 | |
| 614 | #ifdef ENABLE_IPV6 |
| 615 | case AF_INET6: |
| 616 | addr6 = (void *)ca->ai_addr; /* storage area for this info */ |
| 617 | addr6->sin6_port = htons((unsigned short)port); |
| 618 | break; |
| 619 | #endif |
| 620 | } |
| 621 | } |
| 622 | } |
| 623 | #endif |