Major hostip.c cleanup and split into multiple files and easier #ifdef (648e82f0) · Commits · CYBER - Cyber Security / TS 103 523 MSP / TLMSP / TLMSP curl

lib/Makefile.am

+2 −1

Original line number	Diff line number	Diff line
		@@ -93,7 +93,8 @@ libcurl_la_SOURCES = arpa_telnet.h file.c netrc.h timeval.c base64.c \
		content_encoding.c content_encoding.h share.c share.h http_digest.c \
		md5.c md5.h http_digest.h http_negotiate.c http_negotiate.h \
		http_ntlm.c http_ntlm.h ca-bundle.h inet_pton.c inet_pton.h \
		strtoofft.c strtoofft.h strerror.c strerror.h
		strtoofft.c strtoofft.h strerror.c strerror.h hostares.c hostasyn.c \
		hostip4.c hostip6.c hostsyn.c hostthre.c inet_ntop.c inet_ntop.h

		noinst_HEADERS = setup.h transfer.h

lib/hostares.c

0 → 100644

+298 −0

Original line number	Diff line number	Diff line
		/***************************************************************************
		* _ _ ____ _
		* Project ___\| \| \| \| _ \\| \|
		* / __\| \| \| \| \|_) \| \|
		* \| (__\| \|_\| \| _ <\| \|___
		* \___\|\___/\|_\| \_\_____\|
		*
		* Copyright (C) 1998 - 2004, Daniel Stenberg, <daniel@haxx.se>, et al.
		*
		* This software is licensed as described in the file COPYING, which
		* you should have received as part of this distribution. The terms
		* are also available at http://curl.haxx.se/docs/copyright.html.
		*
		* You may opt to use, copy, modify, merge, publish, distribute and/or sell
		* copies of the Software, and permit persons to whom the Software is
		* furnished to do so, under the terms of the COPYING file.
		*
		* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
		* KIND, either express or implied.
		*
		* $Id$
		***************************************************************************/

		#include "setup.h"

		#include <string.h>
		#include <errno.h>

		#define _REENTRANT

		#if defined(WIN32) && !defined(__GNUC__) \|\| defined(__MINGW32__)
		#include <malloc.h>
		#else
		#ifdef HAVE_SYS_TYPES_H
		#include <sys/types.h>
		#endif
		#ifdef HAVE_SYS_SOCKET_H
		#include <sys/socket.h>
		#endif
		#ifdef HAVE_NETINET_IN_H
		#include <netinet/in.h>
		#endif
		#ifdef HAVE_NETDB_H
		#include <netdb.h>
		#endif
		#ifdef HAVE_ARPA_INET_H
		#include <arpa/inet.h>
		#endif
		#ifdef HAVE_STDLIB_H
		#include <stdlib.h> /* required for free() prototypes */
		#endif
		#ifdef HAVE_UNISTD_H
		#include <unistd.h> /* for the close() proto */
		#endif
		#ifdef VMS
		#include <in.h>
		#include <inet.h>
		#include <stdlib.h>
		#endif
		#endif

		#ifdef HAVE_SETJMP_H
		#include <setjmp.h>
		#endif

		#ifdef WIN32
		#include <process.h>
		#endif

		#if (defined(NETWARE) && defined(__NOVELL_LIBC__))
		#undef in_addr_t
		#define in_addr_t unsigned long
		#endif

		#include "urldata.h"
		#include "sendf.h"
		#include "hostip.h"
		#include "hash.h"
		#include "share.h"
		#include "strerror.h"
		#include "url.h"

		#define _MPRINTF_REPLACE /* use our functions only */
		#include <curl/mprintf.h>

		#if defined(HAVE_INET_NTOA_R) && !defined(HAVE_INET_NTOA_R_DECL)
		#include "inet_ntoa_r.h"
		#endif

		/* The last #include file should be: */
		#ifdef CURLDEBUG
		#include "memdebug.h"
		#endif

		/***********************************************************************
		* Only for ares-enabled builds
		**********************************************************************/

		#ifdef CURLRES_ARES

		/*
		* Curl_fdset() is called when someone from the outside world (using
		* curl_multi_fdset()) wants to get our fd_set setup and we're talking with
		* ares. The caller must make sure that this function is only called when we
		* have a working ares channel.
		*
		* Returns: CURLE_OK always!
		*/

		CURLcode Curl_fdset(struct connectdata *conn,
		fd_set *read_fd_set,
		fd_set *write_fd_set,
		int *max_fdp)

		{
		int max = ares_fds(conn->data->state.areschannel,
		read_fd_set, write_fd_set);
		*max_fdp = max;

		return CURLE_OK;
		}

		/*
		* Curl_is_resolved() is called repeatedly to check if a previous name resolve
		* request has completed. It should also make sure to time-out if the
		* operation seems to take too long.
		*
		* Returns normal CURLcode errors.
		*/
		CURLcode Curl_is_resolved(struct connectdata *conn,
		struct Curl_dns_entry **dns)
		{
		fd_set read_fds, write_fds;
		struct timeval tv={0,0};
		int count;
		struct SessionHandle *data = conn->data;
		int nfds;

		FD_ZERO(&read_fds);
		FD_ZERO(&write_fds);

		nfds = ares_fds(data->state.areschannel, &read_fds, &write_fds);

		count = select(nfds, &read_fds, &write_fds, NULL,
		(struct timeval *)&tv);

		/* Call ares_process() unconditonally here, even if we simply timed out
		above, as otherwise the ares name resolve won't timeout! */
		ares_process(data->state.areschannel, &read_fds, &write_fds);

		*dns = NULL;

		if(conn->async.done) {
		/* we're done, kill the ares handle */
		if(!conn->async.dns)
		return CURLE_COULDNT_RESOLVE_HOST;
		*dns = conn->async.dns;
		}

		return CURLE_OK;
		}

		/*
		* Curl_wait_for_resolv() waits for a resolve to finish. This function should
		* be avoided since using this risk getting the multi interface to "hang".
		*
		* If 'entry' is non-NULL, make it point to the resolved dns entry
		*
		* Returns CURLE_COULDNT_RESOLVE_HOST if the host was not resolved, and
		* CURLE_OPERATION_TIMEDOUT if a time-out occurred.
		*/
		CURLcode Curl_wait_for_resolv(struct connectdata *conn,
		struct Curl_dns_entry **entry)
		{
		CURLcode rc=CURLE_OK;
		struct SessionHandle *data = conn->data;
		long timeout = CURL_TIMEOUT_RESOLVE; /* default name resolve timeout */

		/* now, see if there's a connect timeout or a regular timeout to
		use instead of the default one */
		if(conn->data->set.connecttimeout)
		timeout = conn->data->set.connecttimeout;
		else if(conn->data->set.timeout)
		timeout = conn->data->set.timeout;

		/* We convert the number of seconds into number of milliseconds here: */
		if(timeout < 2147483)
		/* maximum amount of seconds that can be multiplied with 1000 and
		still fit within 31 bits */
		timeout *= 1000;
		else
		timeout = 0x7fffffff; /* ridiculous amount of time anyway */

		/* Wait for the name resolve query to complete. */
		while (1) {
		int nfds=0;
		fd_set read_fds, write_fds;
		struct timeval *tvp, tv, store;
		int count;
		struct timeval now = Curl_tvnow();
		long timediff;

		store.tv_sec = (int)timeout/1000;
		store.tv_usec = (timeout%1000)*1000;

		FD_ZERO(&read_fds);
		FD_ZERO(&write_fds);
		nfds = ares_fds(data->state.areschannel, &read_fds, &write_fds);
		if (nfds == 0)
		/* no file descriptors means we're done waiting */
		break;
		tvp = ares_timeout(data->state.areschannel, &store, &tv);
		count = select(nfds, &read_fds, &write_fds, NULL, tvp);
		if (count < 0 && errno != EINVAL)
		break;

		ares_process(data->state.areschannel, &read_fds, &write_fds);

		timediff = Curl_tvdiff(Curl_tvnow(), now); /* spent time */
		timeout -= timediff?timediff:1; /* always deduct at least 1 */
		if (timeout < 0) {
		/* our timeout, so we cancel the ares operation */
		ares_cancel(data->state.areschannel);
		break;
		}
		}

		/* Operation complete, if the lookup was successful we now have the entry
		in the cache. */

		if(entry)
		*entry = conn->async.dns;

		if(!conn->async.dns) {
		/* a name was not resolved */
		if((timeout < 0) \|\| (conn->async.status == ARES_ETIMEOUT)) {
		failf(data, "Resolving host timed out: %s", conn->hostname);
		rc = CURLE_OPERATION_TIMEDOUT;
		}
		else if(conn->async.done) {
		failf(data, "Could not resolve host: %s (%s)", conn->hostname,
		ares_strerror(conn->async.status));
		rc = CURLE_COULDNT_RESOLVE_HOST;
		}
		else
		rc = CURLE_OPERATION_TIMEDOUT;

		/* close the connection, since we can't return failure here without
		cleaning up this connection properly */
		Curl_disconnect(conn);
		}

		return rc;
		}

		/*
		* Curl_getaddrinfo() - when using ares
		*
		* Returns name information about the given hostname and port number. If
		* successful, the 'hostent' is returned and the forth argument will point to
		* memory we need to free after use. That memory MUST be freed with
		* Curl_freeaddrinfo(), nothing else.
		*/
		Curl_addrinfo Curl_getaddrinfo(struct connectdata conn,
		char *hostname,
		int port,
		int *waitp)
		{
		char *bufp;
		struct SessionHandle *data = conn->data;
		in_addr_t in = inet_addr(hostname);

		*waitp = FALSE;

		if (in != CURL_INADDR_NONE)
		/* This is a dotted IP address 123.123.123.123-style */
		return Curl_ip2addr(in, hostname);

		bufp = strdup(hostname);

		if(bufp) {
		Curl_safefree(conn->async.hostname);
		conn->async.hostname = bufp;
		conn->async.port = port;
		conn->async.done = FALSE; /* not done */
		conn->async.status = 0; /* clear */
		conn->async.dns = NULL; /* clear */

		/* areschannel is already setup in the Curl_open() function */
		ares_gethostbyname(data->state.areschannel, hostname, PF_INET,
		Curl_addrinfo_callback, conn);

		waitp = TRUE; / please wait for the response */
		}
		return NULL; /* no struct yet */
		}

		#endif /* CURLRES_ARES */

lib/hostasyn.c

0 → 100644

+152 −0

Original line number	Diff line number	Diff line
		/***************************************************************************
		* _ _ ____ _
		* Project ___\| \| \| \| _ \\| \|
		* / __\| \| \| \| \|_) \| \|
		* \| (__\| \|_\| \| _ <\| \|___
		* \___\|\___/\|_\| \_\_____\|
		*
		* Copyright (C) 1998 - 2004, Daniel Stenberg, <daniel@haxx.se>, et al.
		*
		* This software is licensed as described in the file COPYING, which
		* you should have received as part of this distribution. The terms
		* are also available at http://curl.haxx.se/docs/copyright.html.
		*
		* You may opt to use, copy, modify, merge, publish, distribute and/or sell
		* copies of the Software, and permit persons to whom the Software is
		* furnished to do so, under the terms of the COPYING file.
		*
		* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
		* KIND, either express or implied.
		*
		* $Id$
		***************************************************************************/

		#include "setup.h"

		#include <string.h>
		#include <errno.h>

		#define _REENTRANT

		#if defined(WIN32) && !defined(__GNUC__) \|\| defined(__MINGW32__)
		#include <malloc.h>
		#else
		#ifdef HAVE_SYS_TYPES_H
		#include <sys/types.h>
		#endif
		#ifdef HAVE_SYS_SOCKET_H
		#include <sys/socket.h>
		#endif
		#ifdef HAVE_NETINET_IN_H
		#include <netinet/in.h>
		#endif
		#ifdef HAVE_NETDB_H
		#include <netdb.h>
		#endif
		#ifdef HAVE_ARPA_INET_H
		#include <arpa/inet.h>
		#endif
		#ifdef HAVE_STDLIB_H
		#include <stdlib.h> /* required for free() prototypes */
		#endif
		#ifdef HAVE_UNISTD_H
		#include <unistd.h> /* for the close() proto */
		#endif
		#ifdef VMS
		#include <in.h>
		#include <inet.h>
		#include <stdlib.h>
		#endif
		#endif

		#ifdef HAVE_SETJMP_H
		#include <setjmp.h>
		#endif

		#ifdef WIN32
		#include <process.h>
		#endif

		#if (defined(NETWARE) && defined(__NOVELL_LIBC__))
		#undef in_addr_t
		#define in_addr_t unsigned long
		#endif

		#include "urldata.h"
		#include "sendf.h"
		#include "hostip.h"
		#include "hash.h"
		#include "share.h"
		#include "strerror.h"
		#include "url.h"

		#define _MPRINTF_REPLACE /* use our functions only */
		#include <curl/mprintf.h>

		#if defined(HAVE_INET_NTOA_R) && !defined(HAVE_INET_NTOA_R_DECL)
		#include "inet_ntoa_r.h"
		#endif

		/* The last #include file should be: */
		#ifdef CURLDEBUG
		#include "memdebug.h"
		#endif

		/***********************************************************************
		* Only for builds using asynchronous name resolves
		**********************************************************************/
		#ifdef CURLRES_ASYNCH
		/*
		* Curl_addrinfo_callback() gets called by ares/gethostbyname_thread() when we
		* got the name resolved (or not!).
		*
		* If the status argument is CURL_ASYNC_SUCCESS, we might need to copy the
		* address field since it might be freed when this function returns. This
		* operation stores the resolved data in the DNS cache.
		*
		* NOTE: for IPv6 operations, Curl_addrinfo_copy() returns the same
		* pointer it is given as argument!
		*
		* The storage operation locks and unlocks the DNS cache.
		*/
		void Curl_addrinfo_callback(void arg, / "struct connectdata " /
		int status,
		Curl_addrinfo *hostent)
		{
		struct connectdata conn = (struct connectdata )arg;
		struct Curl_dns_entry *dns = NULL;

		conn->async.done = TRUE;
		conn->async.status = status;

		if(CURL_ASYNC_SUCCESS == status) {

		/*
		* IPv4: Curl_addrinfo_copy() copies the address and returns an allocated
		* version.
		*
		* IPv6: Curl_addrinfo_copy() returns the input pointer!
		*/
		Curl_addrinfo *he = Curl_addrinfo_copy(hostent);
		if(he) {
		struct SessionHandle *data = conn->data;

		if(data->share)
		Curl_share_lock(data, CURL_LOCK_DATA_DNS, CURL_LOCK_ACCESS_SINGLE);

		dns = Curl_cache_addr(data, he,
		conn->async.hostname,
		conn->async.port);

		if(data->share)
		Curl_share_unlock(data, CURL_LOCK_DATA_DNS);
		}
		}

		conn->async.dns = dns;

		/* ipv4: The input hostent struct will be freed by ares when we return from
		this function */
		}

		#endif /* CURLRES_ASYNC */

lib/hostip.c

+100 −1037

File changed.

Preview size limit exceeded, changes collapsed.

lib/hostip.h

+131 −10

Original line number	Diff line number	Diff line
		@@ -51,17 +51,37 @@ struct Curl_dns_entry {
		* The returned data MUST be "unlocked" with Curl_resolv_unlock() after
		* use, or we'll leak memory!
		*/

		int Curl_resolv(struct connectdata *conn,
		char *hostname,
		int port,
		struct Curl_dns_entry **dnsentry);

		/*
		* Curl_ipvalid() checks what CURL_IPRESOLVE_* requirements that might've
		* been set and returns TRUE if they are OK.
		*/
		bool Curl_ipvalid(struct SessionHandle *data);

		/*
		* Curl_getaddrinfo() is the generic low-level name resolve API within this
		* source file. There are several versions of this function - for different
		* name resolve layers (selected at build-time). They all take this same set
		* of arguments
		*/
		Curl_addrinfo Curl_getaddrinfo(struct connectdata conn,
		char *hostname,
		int port,
		int *waitp);

		CURLcode Curl_is_resolved(struct connectdata *conn,
		struct Curl_dns_entry **dns);
		CURLcode Curl_wait_for_resolv(struct connectdata *conn,
		struct Curl_dns_entry **dnsentry);
		CURLcode Curl_multi_ares_fdset(struct connectdata *conn,

		/* Curl_fdset() is a generic function that exists in multiple versions
		depending on what name resolve technology we've built to use. The function
		is called from the curl_multi_fdset() function */
		CURLcode Curl_fdset(struct connectdata *conn,
		fd_set *read_fd_set,
		fd_set *write_fd_set,
		int *max_fdp);
		@@ -81,19 +101,120 @@ curl_hash *Curl_mk_dnscache(void);
		void Curl_hostcache_prune(struct SessionHandle *data);

		#ifdef CURLDEBUG
		void curl_freeaddrinfo(struct addrinfo *freethis,
		void curl_dofreeaddrinfo(struct addrinfo *freethis,
		int line, const char *source);
		int curl_getaddrinfo(char hostname, char service,
		int curl_dogetaddrinfo(char hostname, char service,
		struct addrinfo *hints,
		struct addrinfo **result,
		int line, const char *source);
		int curl_dogetnameinfo(const struct sockaddr *sa, socklen_t salen,
		char *host, size_t hostlen,
		char *serv, size_t servlen, int flags,
		int line, const char *source);
		#endif

		/* This is the callback function that is used when we build with asynch
		resolve */
		void Curl_addrinfo_callback(void *arg,
		int status,
		Curl_addrinfo *hostent);

		/* This is a utility-function for ipv4-builds to create a hostent struct
		from a numerical-only IP address */
		Curl_addrinfo Curl_ip2addr(unsigned long num, char hostname);

		/* relocate a hostent struct */
		void Curl_hostent_relocate(struct hostent *h, long offset);

		/* copy a Curl_addrinfo struct, currently this only supports copying
		a hostent (ipv4-style) struct */
		Curl_addrinfo Curl_addrinfo_copy(Curl_addrinfo orig);

		/*
		* (IPv6) Curl_printable_address() returns a printable version of the
		* ai->ai_addr address given in the 2nd argument. The first should be the
		* ai->ai_family and the result will be stored in the buf that is bufsize
		* bytes big.
		*/
		const char Curl_printable_address(int af, void addr,
		char *buf, size_t bufsize);

		/*
		* Curl_cache_addr() stores a 'Curl_addrinfo' struct in the DNS cache.
		*
		* Returns the Curl_dns_entry entry pointer or NULL if the storage failed.
		*/
		struct Curl_dns_entry *
		Curl_cache_addr(struct SessionHandle data, Curl_addrinfo addr,
		char *hostname, int port);

		#ifndef INADDR_NONE
		#define CURL_INADDR_NONE (in_addr_t) ~0
		#else
		#define CURL_INADDR_NONE INADDR_NONE
		#endif

		/*
		* Setup comfortable CURLRES_* defines to use in the host*.c sources.
		*/

		#ifdef USE_ARES
		#define CURLRES_ASYNCH
		#define CURLRES_ARES
		#endif

		#ifdef USE_THREADING_GETHOSTBYNAME
		#define CURLRES_ASYNCH
		#define CURLRES_THREADED
		#endif

		#ifdef USE_THREADING_GETADDRINFO
		#define CURLRES_ASYNCH
		#define CURLRES_THREADED
		#endif

		#ifdef ENABLE_IPV6
		#define CURLRES_IPV6
		#else
		#define CURLRES_IPV4
		#endif

		#ifdef CURLRES_IPV4
		#if !defined(HAVE_GETHOSTBYNAME_R) \|\| defined(CURLRES_ASYNCH)
		/* If built for ipv4 and missing gethostbyname_r(), or if using async name
		resolve, we need the Curl_addrinfo_copy() function (which itself needs the
		Curl_hostent_relocate() function)) */
		#define CURLRES_ADDRINFO_COPY
		#define CURLRES_HOSTENT_RELOCATE
		#endif
		#endif /* IPv4-only */

		#ifdef HAVE_GETHOSTBYNAME_R_6
		#define CURLRES_HOSTENT_RELOCATE
		#endif

		#ifdef HAVE_GETHOSTBYNAME_R_5
		#define CURLRES_HOSTENT_RELOCATE
		#endif

		#ifndef CURLRES_ASYNCH
		#define CURLRES_SYNCH
		#endif

		/* Allocate enough memory to hold the full name information structs and
		* everything. OSF1 is known to require at least 8872 bytes. The buffer
		* required for storing all possible aliases and IP numbers is according to
		* Stevens' Unix Network Programming 2nd edition, p. 304: 8192 bytes!
		*/
		#define CURL_HOSTENT_SIZE 9000

		#define CURL_TIMEOUT_RESOLVE 300 /* when using asynch methods, we allow this
		many seconds for a name resolve */

		#ifdef CURLRES_ARES
		#define CURL_ASYNC_SUCCESS ARES_SUCCESS
		#else
		#define CURL_ASYNC_SUCCESS CURLE_OK
		#endif

		#endif