1/***************************************************************************
2 *                                  _   _ ____  _
3 *  Project                     ___| | | |  _ \| |
4 *                             / __| | | | |_) | |
5 *                            | (__| |_| |  _ <| |___
6 *                             \___|\___/|_| \_\_____|
7 *
8 * Copyright (C) 1998 - 2010, 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 ***************************************************************************/
22
23#include "setup.h"
24
25#include <string.h>
26#include <errno.h>
27
28#ifdef HAVE_SYS_SOCKET_H
29#include <sys/socket.h>
30#endif
31#ifdef HAVE_NETINET_IN_H
32#include <netinet/in.h>
33#endif
34#ifdef HAVE_NETDB_H
35#include <netdb.h>
36#endif
37#ifdef HAVE_ARPA_INET_H
38#include <arpa/inet.h>
39#endif
40#ifdef HAVE_STDLIB_H
41#include <stdlib.h>     /* required for free() prototypes */
42#endif
43#ifdef HAVE_UNISTD_H
44#include <unistd.h>     /* for the close() proto */
45#endif
46#ifdef __VMS
47#include <in.h>
48#include <inet.h>
49#include <stdlib.h>
50#endif
51
52#ifdef HAVE_PROCESS_H
53#include <process.h>
54#endif
55
56#include "urldata.h"
57#include "sendf.h"
58#include "hostip.h"
59#include "hash.h"
60#include "share.h"
61#include "strerror.h"
62#include "url.h"
63#include "inet_pton.h"
64
65#define _MPRINTF_REPLACE /* use our functions only */
66#include <curl/mprintf.h>
67
68#include "curl_memory.h"
69/* The last #include file should be: */
70#include "memdebug.h"
71
72/***********************************************************************
73 * Only for plain-ipv4 builds
74 **********************************************************************/
75#ifdef CURLRES_IPV4 /* plain ipv4 code coming up */
76/*
77 * Curl_ipvalid() checks what CURL_IPRESOLVE_* requirements that might've
78 * been set and returns TRUE if they are OK.
79 */
80bool Curl_ipvalid(struct connectdata *conn)
81{
82  if(conn->ip_version == CURL_IPRESOLVE_V6)
83    /* an ipv6 address was requested and we can't get/use one */
84    return FALSE;
85
86  return TRUE; /* OK, proceed */
87}
88
89#ifdef CURLRES_SYNCH
90
91/*
92 * Curl_getaddrinfo() - the ipv4 synchronous version.
93 *
94 * The original code to this function was from the Dancer source code, written
95 * by Bjorn Reese, it has since been patched and modified considerably.
96 *
97 * gethostbyname_r() is the thread-safe version of the gethostbyname()
98 * function. When we build for plain IPv4, we attempt to use this
99 * function. There are _three_ different gethostbyname_r() versions, and we
100 * detect which one this platform supports in the configure script and set up
101 * the HAVE_GETHOSTBYNAME_R_3, HAVE_GETHOSTBYNAME_R_5 or
102 * HAVE_GETHOSTBYNAME_R_6 defines accordingly. Note that HAVE_GETADDRBYNAME
103 * has the corresponding rules. This is primarily on *nix. Note that some unix
104 * flavours have thread-safe versions of the plain gethostbyname() etc.
105 *
106 */
107Curl_addrinfo *Curl_getaddrinfo(struct connectdata *conn,
108                                const char *hostname,
109                                int port,
110                                int *waitp)
111{
112  Curl_addrinfo *ai = NULL;
113
114#ifdef CURL_DISABLE_VERBOSE_STRINGS
115  (void)conn;
116#endif
117
118  *waitp = 0; /* synchronous response only */
119
120  ai = Curl_ipv4_resolve_r(hostname, port);
121  if(!ai)
122    infof(conn->data, "Curl_ipv4_resolve_r failed for %s\n", hostname);
123
124  return ai;
125}
126#endif /* CURLRES_SYNCH */
127#endif /* CURLRES_IPV4 */
128
129/*
130 * Curl_ipv4_resolve_r() - ipv4 threadsafe resolver function.
131 *
132 * This is used for both synchronous and asynchronous resolver builds,
133 * implying that only threadsafe code and function calls may be used.
134 *
135 */
136Curl_addrinfo *Curl_ipv4_resolve_r(const char *hostname,
137                                   int port)
138{
139#if !defined(HAVE_GETADDRINFO_THREADSAFE) && defined(HAVE_GETHOSTBYNAME_R_3)
140  int res;
141#endif
142  Curl_addrinfo *ai = NULL;
143  struct hostent *h = NULL;
144  struct in_addr in;
145  struct hostent *buf = NULL;
146
147  if(Curl_inet_pton(AF_INET, hostname, &in) > 0)
148    /* This is a dotted IP address 123.123.123.123-style */
149    return Curl_ip2addr(AF_INET, &in, hostname, port);
150
151#if defined(HAVE_GETADDRINFO_THREADSAFE)
152  else {
153    struct addrinfo hints;
154    char sbuf[NI_MAXSERV];
155    char *sbufptr = NULL;
156
157    memset(&hints, 0, sizeof(hints));
158    hints.ai_family = PF_INET;
159    hints.ai_socktype = SOCK_STREAM;
160    if(port) {
161      snprintf(sbuf, sizeof(sbuf), "%d", port);
162      sbufptr = sbuf;
163    }
164
165    (void)Curl_getaddrinfo_ex(hostname, sbufptr, &hints, &ai);
166
167#elif defined(HAVE_GETHOSTBYNAME_R)
168  /*
169   * gethostbyname_r() is the preferred resolve function for many platforms.
170   * Since there are three different versions of it, the following code is
171   * somewhat #ifdef-ridden.
172   */
173  else {
174    int h_errnop;
175
176    buf = calloc(1, CURL_HOSTENT_SIZE);
177    if(!buf)
178      return NULL; /* major failure */
179    /*
180     * The clearing of the buffer is a workaround for a gethostbyname_r bug in
181     * qnx nto and it is also _required_ for some of these functions on some
182     * platforms.
183     */
184
185#if defined(HAVE_GETHOSTBYNAME_R_5)
186    /* Solaris, IRIX and more */
187    h = gethostbyname_r(hostname,
188                        (struct hostent *)buf,
189                        (char *)buf + sizeof(struct hostent),
190                        CURL_HOSTENT_SIZE - sizeof(struct hostent),
191                        &h_errnop);
192
193    /* If the buffer is too small, it returns NULL and sets errno to
194     * ERANGE. The errno is thread safe if this is compiled with
195     * -D_REENTRANT as then the 'errno' variable is a macro defined to get
196     * used properly for threads.
197     */
198
199    if(h) {
200      ;
201    }
202    else
203#elif defined(HAVE_GETHOSTBYNAME_R_6)
204    /* Linux */
205
206    (void)gethostbyname_r(hostname,
207                        (struct hostent *)buf,
208                        (char *)buf + sizeof(struct hostent),
209                        CURL_HOSTENT_SIZE - sizeof(struct hostent),
210                        &h, /* DIFFERENCE */
211                        &h_errnop);
212    /* Redhat 8, using glibc 2.2.93 changed the behavior. Now all of a
213     * sudden this function returns EAGAIN if the given buffer size is too
214     * small. Previous versions are known to return ERANGE for the same
215     * problem.
216     *
217     * This wouldn't be such a big problem if older versions wouldn't
218     * sometimes return EAGAIN on a common failure case. Alas, we can't
219     * assume that EAGAIN *or* ERANGE means ERANGE for any given version of
220     * glibc.
221     *
222     * For now, we do that and thus we may call the function repeatedly and
223     * fail for older glibc versions that return EAGAIN, until we run out of
224     * buffer size (step_size grows beyond CURL_HOSTENT_SIZE).
225     *
226     * If anyone has a better fix, please tell us!
227     *
228     * -------------------------------------------------------------------
229     *
230     * On October 23rd 2003, Dan C dug up more details on the mysteries of
231     * gethostbyname_r() in glibc:
232     *
233     * In glibc 2.2.5 the interface is different (this has also been
234     * discovered in glibc 2.1.1-6 as shipped by Redhat 6). What I can't
235     * explain, is that tests performed on glibc 2.2.4-34 and 2.2.4-32
236     * (shipped/upgraded by Redhat 7.2) don't show this behavior!
237     *
238     * In this "buggy" version, the return code is -1 on error and 'errno'
239     * is set to the ERANGE or EAGAIN code. Note that 'errno' is not a
240     * thread-safe variable.
241     */
242
243    if(!h) /* failure */
244#elif defined(HAVE_GETHOSTBYNAME_R_3)
245    /* AIX, Digital Unix/Tru64, HPUX 10, more? */
246
247    /* For AIX 4.3 or later, we don't use gethostbyname_r() at all, because of
248     * the plain fact that it does not return unique full buffers on each
249     * call, but instead several of the pointers in the hostent structs will
250     * point to the same actual data! This have the unfortunate down-side that
251     * our caching system breaks down horribly. Luckily for us though, AIX 4.3
252     * and more recent versions have a "completely thread-safe"[*] libc where
253     * all the data is stored in thread-specific memory areas making calls to
254     * the plain old gethostbyname() work fine even for multi-threaded
255     * programs.
256     *
257     * This AIX 4.3 or later detection is all made in the configure script.
258     *
259     * Troels Walsted Hansen helped us work this out on March 3rd, 2003.
260     *
261     * [*] = much later we've found out that it isn't at all "completely
262     * thread-safe", but at least the gethostbyname() function is.
263     */
264
265    if(CURL_HOSTENT_SIZE >=
266       (sizeof(struct hostent)+sizeof(struct hostent_data))) {
267
268      /* August 22nd, 2000: Albert Chin-A-Young brought an updated version
269       * that should work! September 20: Richard Prescott worked on the buffer
270       * size dilemma.
271       */
272
273      res = gethostbyname_r(hostname,
274                            (struct hostent *)buf,
275                            (struct hostent_data *)((char *)buf +
276                                                    sizeof(struct hostent)));
277      h_errnop = SOCKERRNO; /* we don't deal with this, but set it anyway */
278    }
279    else
280      res = -1; /* failure, too smallish buffer size */
281
282    if(!res) { /* success */
283
284      h = buf; /* result expected in h */
285
286      /* This is the worst kind of the different gethostbyname_r() interfaces.
287       * Since we don't know how big buffer this particular lookup required,
288       * we can't realloc down the huge alloc without doing closer analysis of
289       * the returned data. Thus, we always use CURL_HOSTENT_SIZE for every
290       * name lookup. Fixing this would require an extra malloc() and then
291       * calling Curl_addrinfo_copy() that subsequent realloc()s down the new
292       * memory area to the actually used amount.
293       */
294    }
295    else
296#endif /* HAVE_...BYNAME_R_5 || HAVE_...BYNAME_R_6 || HAVE_...BYNAME_R_3 */
297    {
298      h = NULL; /* set return code to NULL */
299      free(buf);
300    }
301#else /* HAVE_GETADDRINFO_THREADSAFE || HAVE_GETHOSTBYNAME_R */
302    /*
303     * Here is code for platforms that don't have a thread safe
304     * getaddrinfo() nor gethostbyname_r() function or for which
305     * gethostbyname() is the preferred one.
306     */
307  else {
308    h = gethostbyname((void*)hostname);
309#endif /* HAVE_GETADDRINFO_THREADSAFE || HAVE_GETHOSTBYNAME_R */
310  }
311
312  if(h) {
313    ai = Curl_he2ai(h, port);
314
315    if(buf) /* used a *_r() function */
316      free(buf);
317  }
318
319  return ai;
320}
321