1
/***************************************************************************
3
* Project ___| | | | _ \| |
5
* | (__| |_| | _ <| |___
6
* \___|\___/|_| \_\_____|
8
* Copyright (C) 1998 - 2008, Daniel Stenberg, <daniel@haxx.se>, et al.
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.
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.
18
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19
* KIND, either express or implied.
21
* $Id: curl_addrinfo.c,v 1.5 2008-11-06 17:19:57 yangtse Exp $
22
***************************************************************************/
26
#include <curl/curl.h>
31
#ifdef HAVE_SYS_SOCKET_H
32
# include <sys/socket.h>
34
#ifdef HAVE_NETINET_IN_H
35
# include <netinet/in.h>
40
#ifdef HAVE_ARPA_INET_H
41
# include <arpa/inet.h>
50
#if defined(NETWARE) && defined(__NOVELL_LIBC__)
52
# define in_addr_t unsigned long
55
#include "curl_addrinfo.h"
57
#define _MPRINTF_REPLACE /* use our functions only */
58
#include <curl/mprintf.h>
61
/* The last #include file should be: */
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.
75
Curl_freeaddrinfo(Curl_addrinfo *cahead)
77
Curl_addrinfo *ca, *canext;
79
for(ca = cahead; ca != NULL; ca = canext) {
85
free(ca->ai_canonname);
94
#ifdef HAVE_GETADDRINFO
96
* Curl_getaddrinfo_ex()
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().
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.
110
Curl_getaddrinfo_ex(const char *nodename,
111
const char *servname,
112
const struct addrinfo *hints,
113
Curl_addrinfo **result)
115
const struct addrinfo *ainext;
116
const struct addrinfo *ai;
117
struct addrinfo *aihead;
118
Curl_addrinfo *cafirst = NULL;
119
Curl_addrinfo *calast = NULL;
123
*result = NULL; /* assume failure */
125
error = getaddrinfo(nodename, servname, hints, &aihead);
129
for(ai = aihead; ai != NULL; ai = ainext) {
131
if((ca = malloc(sizeof(Curl_addrinfo))) == NULL) {
136
/* copy each structure member individually, member ordering, */
137
/* size, or padding might be different for each structure. */
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;
145
ca->ai_canonname = NULL;
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) {
155
memcpy(ca->ai_addr, ai->ai_addr, ca->ai_addrlen);
158
if(ai->ai_canonname != NULL) {
159
if((ca->ai_canonname = strdup(ai->ai_canonname)) == NULL) {
168
/* if the return list is empty, this becomes the first element */
172
/* add this element last in the return list */
174
calast->ai_next = ca;
177
/* fetch next element fom the addrinfo list */
178
ainext = ai->ai_next;
181
/* destroy the addrinfo list */
183
freeaddrinfo(aihead);
185
/* if we failed, also destroy the Curl_addrinfo list */
187
Curl_freeaddrinfo(cafirst);
193
/* This is not a CURLcode */
196
#endif /* HAVE_GETADDRINFO */
202
* This function returns a pointer to the first element of a newly allocated
203
* Curl_addrinfo struct linked list filled with the data of a given hostent.
204
* Curl_addrinfo is meant to work like the addrinfo struct does for a IPv6
205
* stack, but usable also for IPv4, all hosts and environments.
207
* The memory allocated by this function *MUST* be free'd later on calling
208
* Curl_freeaddrinfo(). For each successful call to this function there
209
* must be an associated call later to Curl_freeaddrinfo().
211
* Curl_addrinfo defined in "lib/curl_addrinfo.h"
213
* struct Curl_addrinfo {
218
* socklen_t ai_addrlen; * Follow rfc3493 struct addrinfo *
219
* char *ai_canonname;
220
* struct sockaddr *ai_addr;
221
* struct Curl_addrinfo *ai_next;
223
* typedef struct Curl_addrinfo Curl_addrinfo;
225
* hostent defined in <netdb.h>
232
* char **h_addr_list;
235
* for backward compatibility:
237
* #define h_addr h_addr_list[0]
241
Curl_he2ai(const struct hostent *he, int port)
244
Curl_addrinfo *prevai = NULL;
245
Curl_addrinfo *firstai = NULL;
246
struct sockaddr_in *addr;
248
struct sockaddr_in6 *addr6;
250
CURLcode result = CURLE_OK;
255
/* no input == no output! */
258
DEBUGASSERT((he->h_name != NULL) && (he->h_addr_list != NULL));
260
for(i=0; (curr = he->h_addr_list[i]) != NULL; i++) {
264
if (he->h_addrtype == AF_INET6)
265
ss_size = sizeof (struct sockaddr_in6);
268
ss_size = sizeof (struct sockaddr_in);
270
if((ai = calloc(1, sizeof(Curl_addrinfo))) == NULL) {
271
result = CURLE_OUT_OF_MEMORY;
274
if((ai->ai_canonname = strdup(he->h_name)) == NULL) {
275
result = CURLE_OUT_OF_MEMORY;
279
if((ai->ai_addr = calloc(1, ss_size)) == NULL) {
280
result = CURLE_OUT_OF_MEMORY;
281
free(ai->ai_canonname);
287
/* store the pointer we want to return from this function */
291
/* make the previous entry point to this */
292
prevai->ai_next = ai;
294
ai->ai_family = he->h_addrtype;
296
/* we return all names as STREAM, so when using this address for TFTP
297
the type must be ignored and conn->socktype be used instead! */
298
ai->ai_socktype = SOCK_STREAM;
300
ai->ai_addrlen = ss_size;
302
/* leave the rest of the struct filled with zero */
304
switch (ai->ai_family) {
306
addr = (void *)ai->ai_addr; /* storage area for this info */
308
memcpy(&addr->sin_addr, curr, sizeof(struct in_addr));
309
addr->sin_family = (unsigned short)(he->h_addrtype);
310
addr->sin_port = htons((unsigned short)port);
315
addr6 = (void *)ai->ai_addr; /* storage area for this info */
317
memcpy(&addr6->sin6_addr, curr, sizeof(struct in6_addr));
318
addr6->sin6_family = (unsigned short)(he->h_addrtype);
319
addr6->sin6_port = htons((unsigned short)port);
327
if(result != CURLE_OK) {
328
Curl_freeaddrinfo(firstai);
337
struct hostent hostentry;
341
struct in6_addr ina6;
344
char *h_addr_list[2];
351
* This function takes an internet address, in binary form, as input parameter
352
* along with its address family and the string version of the address, and it
353
* returns a Curl_addrinfo chain filled in correctly with information for the
358
Curl_ip2addr(int af, const void *inaddr, const char *hostname, int port)
362
#if defined(VMS) && \
363
defined(__INITIAL_POINTER_SIZE) && (__INITIAL_POINTER_SIZE == 64)
364
#pragma pointer_size save
365
#pragma pointer_size short
366
#pragma message disable PTRMISMATCH
370
struct namebuff *buf;
375
DEBUGASSERT(inaddr && hostname);
377
buf = malloc(sizeof(struct namebuff));
381
hoststr = strdup(hostname);
389
addrsize = sizeof(struct in_addr);
390
addrentry = (void *)&buf->addrentry.ina4;
391
memcpy(addrentry, inaddr, sizeof(struct in_addr));
395
addrsize = sizeof(struct in6_addr);
396
addrentry = (void *)&buf->addrentry.ina6;
397
memcpy(addrentry, inaddr, sizeof(struct in6_addr));
409
h->h_addrtype = (short)af;
410
h->h_length = (short)addrsize;
411
h->h_addr_list = &buf->h_addr_list[0];
412
h->h_addr_list[0] = addrentry;
413
h->h_addr_list[1] = NULL; /* terminate list of entries */
415
#if defined(VMS) && \
416
defined(__INITIAL_POINTER_SIZE) && (__INITIAL_POINTER_SIZE == 64)
417
#pragma pointer_size restore
418
#pragma message enable PTRMISMATCH
421
ai = Curl_he2ai(h, port);
430
#if defined(CURLDEBUG) && defined(HAVE_FREEADDRINFO)
432
* curl_dofreeaddrinfo()
434
* This is strictly for memory tracing and are using the same style as the
435
* family otherwise present in memdebug.c. I put these ones here since they
436
* require a bunch of structs I didn't wanna include in memdebug.c
440
curl_dofreeaddrinfo(struct addrinfo *freethis,
441
int line, const char *source)
443
(freeaddrinfo)(freethis);
445
fprintf(logfile, "ADDR %s:%d freeaddrinfo(%p)\n",
446
source, line, (void *)freethis);
448
#endif /* defined(CURLDEBUG) && defined(HAVE_FREEADDRINFO) */
451
#if defined(CURLDEBUG) && defined(HAVE_GETADDRINFO)
453
* curl_dogetaddrinfo()
455
* This is strictly for memory tracing and are using the same style as the
456
* family otherwise present in memdebug.c. I put these ones here since they
457
* require a bunch of structs I didn't wanna include in memdebug.c
461
curl_dogetaddrinfo(const char *hostname,
463
const struct addrinfo *hints,
464
struct addrinfo **result,
465
int line, const char *source)
467
int res=(getaddrinfo)(hostname, service, hints, result);
471
fprintf(logfile, "ADDR %s:%d getaddrinfo() = %p\n",
472
source, line, (void *)*result);
476
fprintf(logfile, "ADDR %s:%d getaddrinfo() failed\n",
481
#endif /* defined(CURLDEBUG) && defined(HAVE_GETADDRINFO) */
added
removed
lib/curl_addrinfo.c
