lib/curl_addrinfo.c

   1 /***************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * Copyright (C) 1998 - 2008, Daniel Stenberg, <daniel@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 http://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  * $Id$
  22  ***************************************************************************/
  23
  24 #include "setup.h"
  25
  26 #include <curl/curl.h>
  27
  28 #ifdef NEED_MALLOC_H
  29 #  include <malloc.h>
  30 #endif
  31 #ifdef HAVE_SYS_SOCKET_H
  32 #  include <sys/socket.h>
  33 #endif
  34 #ifdef HAVE_NETINET_IN_H
  35 #  include <netinet/in.h>
  36 #endif
  37 #ifdef HAVE_NETDB_H
  38 #  include <netdb.h>
  39 #endif
  40 #ifdef HAVE_ARPA_INET_H
  41 #  include <arpa/inet.h>
  42 #endif
  43
  44 #ifdef  VMS
  45 #  include <in.h>
  46 #  include <inet.h>
  47 #  include <stdlib.h>
  48 #endif
  49
  50 #if defined(NETWARE) && defined(__NOVELL_LIBC__)
  51 #  undef  in_addr_t
  52 #  define in_addr_t unsigned long
  53 #endif
  54
  55 #include "curl_addrinfo.h"
  56
  57 #define _MPRINTF_REPLACE /* use our functions only */
  58 #include <curl/mprintf.h>
  59
  60 #include "memory.h"
  61 /* The last #include file should be: */
  62 #include "memdebug.h"
  63
  64
  65 /*
  66  * Curl_freeaddrinfo()
  67  *
  68  * This is used to free a linked list of Curl_addrinfo structs along
  69  * with all its associated allocated storage. This function should be
  70  * called once for each successful call to Curl_getaddrinfo_ex() or to
  71  * any function call which actually allocates a Curl_addrinfo struct.
  72  */
  73
  74 void
  75 Curl_freeaddrinfo(Curl_addrinfo *cahead)
  76 {
  77   Curl_addrinfo *ca, *canext;
  78
  79   for(ca = cahead; ca != NULL; ca = canext) {
  80
  81     if(ca->ai_addr)
  82       free(ca->ai_addr);
  83
  84     if(ca->ai_canonname)
  85       free(ca->ai_canonname);
  86
  87     canext = ca->ai_next;
  88
  89     free(ca);
  90   }
  91 }
  92
  93
  94 #ifdef HAVE_GETADDRINFO
  95 /*
  96  * Curl_getaddrinfo_ex()
  97  *
  98  * This is a wrapper function around system's getaddrinfo(), with
  99  * the only difference that instead of returning a linked list of
 100  * addrinfo structs this one returns a linked list of Curl_addrinfo
 101  * ones. The memory allocated by this function *MUST* be free'd with
 102  * Curl_freeaddrinfo().  For each successful call to this function
 103  * there must be an associated call later to Curl_freeaddrinfo().
 104  *
 105  * There should be no single call to system's getaddrinfo() in the
 106  * whole library, any such call should be 'routed' through this one.
 107  */
 108
 109 int
 110 Curl_getaddrinfo_ex(const char *nodename,
 111                     const char *servname,
 112                     const struct addrinfo *hints,
 113                     Curl_addrinfo **result)
 114 {
 115   const struct addrinfo *ainext;
 116   const struct addrinfo *ai;
 117   struct addrinfo *aihead;
 118   Curl_addrinfo *cafirst = NULL;
 119   Curl_addrinfo *calast = NULL;
 120   Curl_addrinfo *ca;
 121   int error;
 122
 123   *result = NULL; /* assume failure */
 124
 125   error = getaddrinfo(nodename, servname, hints, &aihead);
 126   if(error)
 127     return error;
 128
 129   for(ai = aihead; ai != NULL; ai = ainext) {
 130
 131     if((ca = malloc(sizeof(Curl_addrinfo))) == NULL) {
 132       error = EAI_MEMORY;
 133       break;
 134     }
 135
 136     /* copy each structure member individually, member ordering, */
 137     /* size, or padding might be different for each structure.   */
 138
 139     ca->ai_flags     = ai->ai_flags;
 140     ca->ai_family    = ai->ai_family;
 141     ca->ai_socktype  = ai->ai_socktype;
 142     ca->ai_protocol  = ai->ai_protocol;
 143     ca->ai_addrlen   = 0;
 144     ca->ai_addr      = NULL;
 145     ca->ai_canonname = NULL;
 146     ca->ai_next      = NULL;
 147
 148     if((ai->ai_addrlen > 0) && (ai->ai_addr != NULL)) {
 149       ca->ai_addrlen  = ai->ai_addrlen;
 150       if((ca->ai_addr = malloc(ca->ai_addrlen)) == NULL) {
 151         error = EAI_MEMORY;
 152         free(ca);
 153         break;
 154       }
 155       memcpy(ca->ai_addr, ai->ai_addr, ca->ai_addrlen);
 156     }
 157
 158     if(ai->ai_canonname != NULL) {
 159       if((ca->ai_canonname = strdup(ai->ai_canonname)) == NULL) {
 160         error = EAI_MEMORY;
 161         if(ca->ai_addr)
 162           free(ca->ai_addr);
 163         free(ca);
 164         break;
 165       }
 166     }
 167
 168     /* if the return list is empty, this becomes the first element */
 169     if(!cafirst)
 170       cafirst = ca;
 171
 172     /* add this element last in the return list */
 173     if(calast)
 174       calast->ai_next = ca;
 175     calast = ca;
 176
 177     /* fetch next element fom the addrinfo list */
 178     ainext = ai->ai_next;
 179   }
 180
 181   /* destroy the addrinfo list */
 182   if(aihead)
 183     freeaddrinfo(aihead);
 184
 185   /* if we failed, also destroy the Curl_addrinfo list */
 186   if(error) {
 187     Curl_freeaddrinfo(cafirst);
 188     cafirst = NULL;
 189   }
 190
 191   *result = cafirst;
 192
 193   return error; /* This is not a CURLcode */
 194 }
 195 #endif /* HAVE_GETADDRINFO */
 196
 197
 198 /*
 199  * Curl_he2ai()
 200  *
 201  * This function returns a pointer to the first element of a newly allocated
 202  * Curl_addrinfo struct linked list filled with the data of a given hostent.
 203  * Curl_addrinfo is meant to work like the addrinfo struct does for a IPv6
 204  * stack, but usable also for IPv4, all hosts and environments.
 205  *
 206  * The memory allocated by this function *MUST* be free'd later on calling
 207  * Curl_freeaddrinfo().  For each successful call to this function there
 208  * must be an associated call later to Curl_freeaddrinfo().
 209  *
 210  *   Curl_addrinfo defined in "lib/curl_addrinfo.h"
 211  *
 212  *     struct Curl_addrinfo {
 213  *       int                   ai_flags;
 214  *       int                   ai_family;
 215  *       int                   ai_socktype;
 216  *       int                   ai_protocol;
 217  *       socklen_t             ai_addrlen;   * Follow rfc3493 struct addrinfo *
 218  *       char                 *ai_canonname;
 219  *       struct sockaddr      *ai_addr;
 220  *       struct Curl_addrinfo *ai_next;
 221  *     };
 222  *     typedef struct Curl_addrinfo Curl_addrinfo;
 223  *
 224  *   hostent defined in <netdb.h>
 225  *
 226  *     struct hostent {
 227  *       char    *h_name;
 228  *       char    **h_aliases;
 229  *       int     h_addrtype;
 230  *       int     h_length;
 231  *       char    **h_addr_list;
 232  *     };
 233  *
 234  *   for backward compatibility:
 235  *
 236  *     #define h_addr  h_addr_list[0]
 237  */
 238
 239 Curl_addrinfo *
 240 Curl_he2ai(const struct hostent *he, int port)
 241 {
 242   Curl_addrinfo *ai;
 243   Curl_addrinfo *prevai = NULL;
 244   Curl_addrinfo *firstai = NULL;
 245   struct sockaddr_in *addr;
 246 #ifdef ENABLE_IPV6
 247   struct sockaddr_in6 *addr6;
 248 #endif
 249   CURLcode result = CURLE_OK;
 250   int i;
 251   char *curr;
 252
 253   if(!he)
 254     /* no input == no output! */
 255     return NULL;
 256
 257   for(i=0; (curr = he->h_addr_list[i]) != NULL; i++) {
 258
 259     int ss_size;
 260 #ifdef ENABLE_IPV6
 261     if (he->h_addrtype == AF_INET6)
 262       ss_size = sizeof (struct sockaddr_in6);
 263     else
 264 #endif
 265       ss_size = sizeof (struct sockaddr_in);
 266
 267     if((ai = calloc(1, sizeof(Curl_addrinfo))) == NULL) {
 268       result = CURLE_OUT_OF_MEMORY;
 269       break;
 270     }
 271     if((ai->ai_canonname = strdup(he->h_name)) == NULL) {
 272       result = CURLE_OUT_OF_MEMORY;
 273       free(ai);
 274       break;
 275     }
 276     if((ai->ai_addr = calloc(1, ss_size)) == NULL) {
 277       result = CURLE_OUT_OF_MEMORY;
 278       free(ai->ai_canonname);
 279       free(ai);
 280       break;
 281     }
 282
 283     if(!firstai)
 284       /* store the pointer we want to return from this function */
 285       firstai = ai;
 286
 287     if(prevai)
 288       /* make the previous entry point to this */
 289       prevai->ai_next = ai;
 290
 291     ai->ai_family = he->h_addrtype;
 292
 293     /* we return all names as STREAM, so when using this address for TFTP
 294        the type must be ignored and conn->socktype be used instead! */
 295     ai->ai_socktype = SOCK_STREAM;
 296
 297     ai->ai_addrlen = ss_size;
 298
 299     /* leave the rest of the struct filled with zero */
 300
 301     switch (ai->ai_family) {
 302     case AF_INET:
 303       addr = (struct sockaddr_in *)ai->ai_addr; /* storage area for this info */
 304
 305       memcpy(&addr->sin_addr, curr, sizeof(struct in_addr));
 306       addr->sin_family = (unsigned short)(he->h_addrtype);
 307       addr->sin_port = htons((unsigned short)port);
 308       break;
 309
 310 #ifdef ENABLE_IPV6
 311     case AF_INET6:
 312       addr6 = (struct sockaddr_in6 *)ai->ai_addr; /* storage area for this info */
 313
 314       memcpy(&addr6->sin6_addr, curr, sizeof(struct in6_addr));
 315       addr6->sin6_family = (unsigned short)(he->h_addrtype);
 316       addr6->sin6_port = htons((unsigned short)port);
 317       break;
 318 #endif
 319     }
 320
 321     prevai = ai;
 322   }
 323
 324   if(result != CURLE_OK) {
 325     Curl_freeaddrinfo(firstai);
 326     firstai = NULL;
 327   }
 328
 329   return firstai;
 330 }
 331
 332
 333 #if defined(CURLDEBUG) && defined(HAVE_FREEADDRINFO)
 334 /*
 335  * curl_dofreeaddrinfo()
 336  *
 337  * This is strictly for memory tracing and are using the same style as the
 338  * family otherwise present in memdebug.c. I put these ones here since they
 339  * require a bunch of structs I didn't wanna include in memdebug.c
 340  */
 341
 342 void
 343 curl_dofreeaddrinfo(struct addrinfo *freethis,
 344                     int line, const char *source)
 345 {
 346   (freeaddrinfo)(freethis);
 347   if(logfile)
 348     fprintf(logfile, "ADDR %s:%d freeaddrinfo(%p)\n",
 349             source, line, (void *)freethis);
 350 }
 351 #endif /* defined(CURLDEBUG) && defined(HAVE_FREEADDRINFO) */
 352
 353
 354 #if defined(CURLDEBUG) && defined(HAVE_GETADDRINFO)
 355 /*
 356  * curl_dogetaddrinfo()
 357  *
 358  * This is strictly for memory tracing and are using the same style as the
 359  * family otherwise present in memdebug.c. I put these ones here since they
 360  * require a bunch of structs I didn't wanna include in memdebug.c
 361  */
 362
 363 int
 364 curl_dogetaddrinfo(const char *hostname,
 365                    const char *service,
 366                    const struct addrinfo *hints,
 367                    struct addrinfo **result,
 368                    int line, const char *source)
 369 {
 370   int res=(getaddrinfo)(hostname, service, hints, result);
 371   if(0 == res) {
 372     /* success */
 373     if(logfile)
 374       fprintf(logfile, "ADDR %s:%d getaddrinfo() = %p\n",
 375               source, line, (void *)*result);
 376   }
 377   else {
 378     if(logfile)
 379       fprintf(logfile, "ADDR %s:%d getaddrinfo() failed\n",
 380               source, line);
 381   }
 382   return res;
 383 }
 384 #endif /* defined(CURLDEBUG) && defined(HAVE_GETADDRINFO) */
 385