/*

 * Copyright (c) 2002 - 2003

 * NetGroup, Politecnico di Torino (Italy)

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *

 * 1. Redistributions of source code must retain the above copyright

 * notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 * notice, this list of conditions and the following disclaimer in the

 * documentation and/or other materials provided with the distribution.

 * 3. Neither the name of the Politecnico di Torino nor the names of its

 * contributors may be used to endorse or promote products derived from

 * this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

/*

 * \file sockutils.c

 *

 * The goal of this file is to provide a common set of primitives for socket

 * manipulation.

 *

 * Although the socket interface defined in the RFC 2553 (and its updates)

 * is excellent, there are still differences between the behavior of those

 * routines on UN*X and Windows, and between UN*Xes.

 *

 * These calls provide an interface similar to the socket interface, but

 * that hides the differences between operating systems.  It does not

 * attempt to significantly improve on the socket interface in other

 * ways.

 */

#include "ftmacros.h"

#include <string.h>

#include <errno.h>	/* for the errno variable */

#include <stdio.h>	/* for the stderr file */

#include <stdlib.h>	/* for malloc() and free() */

#ifdef HAVE_LIMITS_H

#include <limits.h>

#else

#define INT_MAX		2147483647

#endif

#include "pcap-int.h"

#include "sockutils.h"

#include "portability.h"

#ifdef _WIN32

  /*

   * Winsock initialization.

   *

   * Ask for WinSock 2.2.

   */

  #define WINSOCK_MAJOR_VERSION 2

  #define WINSOCK_MINOR_VERSION 2

  static int sockcount = 0;	/*!< Variable that allows calling the WSAStartup() only one time */

#endif

/* Some minor differences between UNIX and Win32 */

#ifdef _WIN32

  #define SHUT_WR SD_SEND	/* The control code for shutdown() is different in Win32 */

#endif

/* Size of the buffer that has to keep error messages */

#define SOCK_ERRBUF_SIZE 1024

/* Constants; used in order to keep strings here */

#define SOCKET_NO_NAME_AVAILABLE "No name available"

#define SOCKET_NO_PORT_AVAILABLE "No port available"

#define SOCKET_NAME_NULL_DAD "Null address (possibly DAD Phase)"

/*

 * On UN*X, send() and recv() return ssize_t.

 *

 * On Windows, send() and recv() return an int.

 *

 *   Wth MSVC, there *is* no ssize_t.

 *

 *   With MinGW, there is an ssize_t type; it is either an int (32 bit)

 *   or a long long (64 bit).

 *

 * So, on Windows, if we don't have ssize_t defined, define it as an

 * int, so we can use it, on all platforms, as the type of variables

 * that hold the return values from send() and recv().

 */

#if defined(_WIN32) && !defined(_SSIZE_T_DEFINED)

typedef int ssize_t;

#endif

/****************************************************

 *                                                  *

 * Locally defined functions                        *

 *                                                  *

 ****************************************************/

static int sock_ismcastaddr(const struct sockaddr *saddr);

/****************************************************

 *                                                  *

 * Function bodies                                  *

 *                                                  *

 ****************************************************/

/*

 * Format an error message given an errno value (UN*X) or a WinSock error

 * (Windows).

 */

void sock_fmterror(const char *caller, int errcode, char *errbuf, int errbuflen)

{

	if (errbuf == NULL)

		return;

#ifdef _WIN32

	pcap_fmt_errmsg_for_win32_err(errbuf, errbuflen, errcode,

	    "%s", caller);

#else

	pcap_fmt_errmsg_for_errno(errbuf, errbuflen, errcode,

	    "%s", caller);

#endif

}

/*

 * \brief It retrieves the error message after an error occurred in the socket interface.

 *

 * This function is defined because of the different way errors are returned in UNIX

 * and Win32. This function provides a consistent way to retrieve the error message

 * (after a socket error occurred) on all the platforms.

 *

 * \param caller: a pointer to a user-allocated string which contains a message that has

 * to be printed *before* the true error message. It could be, for example, 'this error

 * comes from the recv() call at line 31'.

 *

 * \param errbuf: a pointer to an user-allocated buffer that will contain the complete

 * error message. This buffer has to be at least 'errbuflen' in length.

 * It can be NULL; in this case the error cannot be printed.

 *

 * \param errbuflen: length of the buffer that will contains the error. The error message cannot be

 * larger than 'errbuflen - 1' because the last char is reserved for the string terminator.

 *

 * \return No return values. The error message is returned in the 'string' parameter.

 */

void sock_geterror(const char *caller, char *errbuf, int errbuflen)

{

#ifdef _WIN32

	sock_fmterror(caller, GetLastError(), errbuf, errbuflen);

#else

	sock_fmterror(caller, errno, errbuf, errbuflen);

#endif

}

/*

 * \brief This function initializes the socket mechanism if it hasn't

 * already been initialized or reinitializes it after it has been

 * cleaned up.

 *

 * On UN*Xes, it doesn't need to do anything; on Windows, it needs to

 * initialize Winsock.

 *

 * \param errbuf: a pointer to an user-allocated buffer that will contain

 * the complete error message. This buffer has to be at least 'errbuflen'

 * in length. It can be NULL; in this case no error message is supplied.

 *

 * \param errbuflen: length of the buffer that will contains the error.

 * The error message cannot be larger than 'errbuflen - 1' because the

 * last char is reserved for the string terminator.

 *

 * \return '0' if everything is fine, '-1' if some errors occurred. The

 * error message is returned in the buffer pointed to by 'errbuf' variable.

 */

#ifdef _WIN32

int sock_init(char *errbuf, int errbuflen)

{

	if (sockcount == 0)

	{

		WSADATA wsaData;			/* helper variable needed to initialize Winsock */

		if (WSAStartup(MAKEWORD(WINSOCK_MAJOR_VERSION,

		    WINSOCK_MINOR_VERSION), &wsaData) != 0)

		{

			if (errbuf)

				pcap_snprintf(errbuf, errbuflen, "Failed to initialize Winsock\n");

			WSACleanup();

			return -1;

		}

	}

	sockcount++;

	return 0;

}

#else

int sock_init(char *errbuf _U_, int errbuflen _U_)

{

	/*

	 * Nothing to do on UN*Xes.

	 */

	return 0;

}

#endif

/*

 * \brief This function cleans up the socket mechanism if we have no

 * sockets left open.

 *

 * On UN*Xes, it doesn't need to do anything; on Windows, it needs

 * to clean up Winsock.

 *

 * \return No error values.

 */

void sock_cleanup(void)

{

#ifdef _WIN32

	sockcount--;

	if (sockcount == 0)

		WSACleanup();

#endif

}

/*

 * \brief It checks if the sockaddr variable contains a multicast address.

 *

 * \return '0' if the address is multicast, '-1' if it is not.

 */

static int sock_ismcastaddr(const struct sockaddr *saddr)

{

	if (saddr->sa_family == PF_INET)

	{

		struct sockaddr_in *saddr4 = (struct sockaddr_in *) saddr;

		if (IN_MULTICAST(ntohl(saddr4->sin_addr.s_addr))) return 0;

		else return -1;

	}

	else

	{

		struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *) saddr;

		if (IN6_IS_ADDR_MULTICAST(&saddr6->sin6_addr)) return 0;

		else return -1;

	}

}

/*

 * \brief It initializes a network connection both from the client and the server side.

 *

 * In case of a client socket, this function calls socket() and connect().

 * In the meanwhile, it checks for any socket error.

 * If an error occurs, it writes the error message into 'errbuf'.

 *

 * In case of a server socket, the function calls socket(), bind() and listen().

 *

 * This function is usually preceeded by the sock_initaddress().

 *

 * \param addrinfo: pointer to an addrinfo variable which will be used to

 * open the socket and such. This variable is the one returned by the previous call to

 * sock_initaddress().

 *

 * \param server: '1' if this is a server socket, '0' otherwise.

 *

 * \param nconn: number of the connections that are allowed to wait into the listen() call.

 * This value has no meanings in case of a client socket.

 *

 * \param errbuf: a pointer to an user-allocated buffer that will contain the complete

 * error message. This buffer has to be at least 'errbuflen' in length.

 * It can be NULL; in this case the error cannot be printed.

 *

 * \param errbuflen: length of the buffer that will contains the error. The error message cannot be

 * larger than 'errbuflen - 1' because the last char is reserved for the string terminator.

 *

 * \return the socket that has been opened (that has to be used in the following sockets calls)

 * if everything is fine, INVALID_SOCKET if some errors occurred. The error message is returned

 * in the 'errbuf' variable.

 */

SOCKET sock_open(struct addrinfo *addrinfo, int server, int nconn, char *errbuf, int errbuflen)

{

	SOCKET sock;

#if defined(SO_NOSIGPIPE) || defined(IPV6_V6ONLY) || defined(IPV6_BINDV6ONLY)

	int on = 1;

#endif

	sock = socket(addrinfo->ai_family, addrinfo->ai_socktype, addrinfo->ai_protocol);

	if (sock == INVALID_SOCKET)

	{

		sock_geterror("socket()", errbuf, errbuflen);

		return INVALID_SOCKET;

	}

	/*

	 * Disable SIGPIPE, if we have SO_NOSIGPIPE.  We don't want to

	 * have to deal with signals if the peer closes the connection,

	 * especially in client programs, which may not even be aware that

	 * they're sending to sockets.

	 */

#ifdef SO_NOSIGPIPE

	if (setsockopt(sock, SOL_SOCKET, SO_NOSIGPIPE, (char *)&on,

	    sizeof (int)) == -1)

	{

		sock_geterror("setsockopt(SO_NOSIGPIPE)", errbuf, errbuflen);

		closesocket(sock);

		return INVALID_SOCKET;

	}

#endif

	/* This is a server socket */

	if (server)

	{

		/*

		 * Allow a new server to bind the socket after the old one

		 * exited, even if lingering sockets are still present.

		 *

		 * Don't treat an error as a failure.

		 */

		int optval = 1;

		(void)setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,

		    (char *)&optval, sizeof (optval));

#if defined(IPV6_V6ONLY) || defined(IPV6_BINDV6ONLY)

		/*

		 * Force the use of IPv6-only addresses.

		 *

		 * RFC 3493 indicates that you can support IPv4 on an

		 * IPv6 socket:

		 *

		 *    https://tools.ietf.org/html/rfc3493#section-3.7

		 *

		 * and that this is the default behavior.  This means

		 * that if we first create an IPv6 socket bound to the

		 * "any" address, it is, in effect, also bound to the

		 * IPv4 "any" address, so when we create an IPv4 socket

		 * and try to bind it to the IPv4 "any" address, it gets

		 * EADDRINUSE.

		 *

		 * Not all network stacks support IPv4 on IPv6 sockets;

		 * pre-NT 6 Windows stacks don't support it, and the

		 * OpenBSD stack doesn't support it for security reasons

		 * (see the OpenBSD inet6(4) man page).  Therefore, we

		 * don't want to rely on this behavior.

		 *

		 * So we try to disable it, using either the IPV6_V6ONLY

		 * option from RFC 3493:

		 *

		 *    https://tools.ietf.org/html/rfc3493#section-5.3

		 *

		 * or the IPV6_BINDV6ONLY option from older UN*Xes.

		 */

#ifndef IPV6_V6ONLY

  /* For older systems */

  #define IPV6_V6ONLY IPV6_BINDV6ONLY

#endif /* IPV6_V6ONLY */

		if (addrinfo->ai_family == PF_INET6)

		{

			if (setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY,

			    (char *)&on, sizeof (int)) == -1)

			{

				if (errbuf)

					pcap_snprintf(errbuf, errbuflen, "setsockopt(IPV6_V6ONLY)");

				closesocket(sock);

				return INVALID_SOCKET;

			}

		}

#endif /* defined(IPV6_V6ONLY) || defined(IPV6_BINDV6ONLY) */

		/* WARNING: if the address is a mcast one, I should place the proper Win32 code here */

		if (bind(sock, addrinfo->ai_addr, (int) addrinfo->ai_addrlen) != 0)

		{

			sock_geterror("bind()", errbuf, errbuflen);

			closesocket(sock);

			return INVALID_SOCKET;

		}

		if (addrinfo->ai_socktype == SOCK_STREAM)

			if (listen(sock, nconn) == -1)

			{

				sock_geterror("listen()", errbuf, errbuflen);

				closesocket(sock);

				return INVALID_SOCKET;

			}

		/* server side ended */

		return sock;

	}

	else	/* we're the client */

	{

		struct addrinfo *tempaddrinfo;

		char *errbufptr;

		size_t bufspaceleft;

		tempaddrinfo = addrinfo;

		errbufptr = errbuf;

		bufspaceleft = errbuflen;

		*errbufptr = 0;

		/*

		 * We have to loop though all the addinfo returned.

		 * For instance, we can have both IPv6 and IPv4 addresses, but the service we're trying

		 * to connect to is unavailable in IPv6, so we have to try in IPv4 as well

		 */

		while (tempaddrinfo)

		{

			if (connect(sock, tempaddrinfo->ai_addr, (int) tempaddrinfo->ai_addrlen) == -1)

			{

				size_t msglen;

				char TmpBuffer[100];

				char SocketErrorMessage[SOCK_ERRBUF_SIZE];

				/*

				 * We have to retrieve the error message before any other socket call completes, otherwise

				 * the error message is lost

				 */

				sock_geterror("Connect to socket failed",

				    SocketErrorMessage, sizeof(SocketErrorMessage));

				/* Returns the numeric address of the host that triggered the error */

				sock_getascii_addrport((struct sockaddr_storage *) tempaddrinfo->ai_addr, TmpBuffer, sizeof(TmpBuffer), NULL, 0, NI_NUMERICHOST, TmpBuffer, sizeof(TmpBuffer));

				pcap_snprintf(errbufptr, bufspaceleft,

				    "Is the server properly installed on %s?  %s", TmpBuffer, SocketErrorMessage);

				/* In case more then one 'connect' fails, we manage to keep all the error messages */

				msglen = strlen(errbufptr);

				errbufptr[msglen] = ' ';

				errbufptr[msglen + 1] = 0;

				bufspaceleft = bufspaceleft - (msglen + 1);

				errbufptr += (msglen + 1);

				tempaddrinfo = tempaddrinfo->ai_next;

			}

			else

				break;

		}

		/*

		 * Check how we exit from the previous loop

		 * If tempaddrinfo is equal to NULL, it means that all the connect() failed.

		 */

		if (tempaddrinfo == NULL)

		{

			closesocket(sock);

			return INVALID_SOCKET;

		}

		else

			return sock;

	}

}

/*

 * \brief Closes the present (TCP and UDP) socket connection.

 *

 * This function sends a shutdown() on the socket in order to disable send() calls

 * (while recv() ones are still allowed). Then, it closes the socket.

 *

 * \param sock: the socket identifier of the connection that has to be closed.

 *

 * \param errbuf: a pointer to an user-allocated buffer that will contain the complete

 * error message. This buffer has to be at least 'errbuflen' in length.

 * It can be NULL; in this case the error cannot be printed.

 *

 * \param errbuflen: length of the buffer that will contains the error. The error message cannot be

 * larger than 'errbuflen - 1' because the last char is reserved for the string terminator.

 *

 * \return '0' if everything is fine, '-1' if some errors occurred. The error message is returned

 * in the 'errbuf' variable.

 */

int sock_close(SOCKET sock, char *errbuf, int errbuflen)

{

	/*

	 * SHUT_WR: subsequent calls to the send function are disallowed.

	 * For TCP sockets, a FIN will be sent after all data is sent and

	 * acknowledged by the Server.

	 */

	if (shutdown(sock, SHUT_WR))

	{

		sock_geterror("shutdown()", errbuf, errbuflen);

		/* close the socket anyway */

		closesocket(sock);

		return -1;

	}

	closesocket(sock);

	return 0;

}

/*

 * gai_errstring() has some problems:

 *

 * 1) on Windows, Microsoft explicitly says it's not thread-safe;

 * 2) on UN*X, the Single UNIX Specification doesn't say it *is*

 *    thread-safe, so an implementation might use a static buffer

 *    for unknown error codes;

 * 3) the error message for the most likely error, EAI_NONAME, is

 *    truly horrible on several platforms ("nodename nor servname

 *    provided, or not known"?  It's typically going to be "not

 *    known", not "oopsie, I passed null pointers for the host name

 *    and service name", not to mention they forgot the "neither");

 *

 * so we roll our own.

 */

static void

get_gai_errstring(char *errbuf, int errbuflen, const char *prefix, int err,

    const char *hostname, const char *portname)

{

	char hostport[PCAP_ERRBUF_SIZE];

	if (hostname != NULL && portname != NULL)

		pcap_snprintf(hostport, PCAP_ERRBUF_SIZE, "%s:%s",

		    hostname, portname);

	else if (hostname != NULL)

		pcap_snprintf(hostport, PCAP_ERRBUF_SIZE, "%s",

		    hostname);

	else if (portname != NULL)

		pcap_snprintf(hostport, PCAP_ERRBUF_SIZE, ":%s",

		    portname);

	else

		pcap_snprintf(hostport, PCAP_ERRBUF_SIZE, "<no host or port!>");

	switch (err)

	{

#ifdef EAI_ADDRFAMILY

		case EAI_ADDRFAMILY:

			pcap_snprintf(errbuf, errbuflen,

			    "%sAddress family for %s not supported",

			    prefix, hostport);

			break;

#endif

		case EAI_AGAIN:

			pcap_snprintf(errbuf, errbuflen,

			    "%s%s could not be resolved at this time",

			    prefix, hostport);

			break;

		case EAI_BADFLAGS:

			pcap_snprintf(errbuf, errbuflen,

			    "%sThe ai_flags parameter for looking up %s had an invalid value",

			    prefix, hostport);

			break;

		case EAI_FAIL:

			pcap_snprintf(errbuf, errbuflen,

			    "%sA non-recoverable error occurred when attempting to resolve %s",

			    prefix, hostport);

			break;

		case EAI_FAMILY:

			pcap_snprintf(errbuf, errbuflen,

			    "%sThe address family for looking up %s was not recognized",

			    prefix, hostport);

			break;

		case EAI_MEMORY:

			pcap_snprintf(errbuf, errbuflen,

			    "%sOut of memory trying to allocate storage when looking up %s",

			    prefix, hostport);

			break;

		/*

		 * RFC 2553 had both EAI_NODATA and EAI_NONAME.

		 *

		 * RFC 3493 has only EAI_NONAME.

		 *

		 * Some implementations define EAI_NODATA and EAI_NONAME

		 * to the same value, others don't.  If EAI_NODATA is

		 * defined and isn't the same as EAI_NONAME, we handle

		 * EAI_NODATA.

		 */

#if defined(EAI_NODATA) && EAI_NODATA != EAI_NONAME

		case EAI_NODATA:

			pcap_snprintf(errbuf, errbuflen,

			    "%sNo address associated with %s",

			    prefix, hostport);

			break;

#endif

		case EAI_NONAME:

			pcap_snprintf(errbuf, errbuflen,

			    "%sThe host name %s couldn't be resolved",

			    prefix, hostport);

			break;

		case EAI_SERVICE:

			pcap_snprintf(errbuf, errbuflen,

			    "%sThe service value specified when looking up %s as not recognized for the socket type",

			    prefix, hostport);

			break;

		case EAI_SOCKTYPE:

			pcap_snprintf(errbuf, errbuflen,

			    "%sThe socket type specified when looking up %s as not recognized",

			    prefix, hostport);

			break;

#ifdef EAI_SYSTEM

		case EAI_SYSTEM:

			/*

			 * Assumed to be UN*X.

			 */

			pcap_snprintf(errbuf, errbuflen,

			    "%sAn error occurred when looking up %s: %s",

			    prefix, hostport, pcap_strerror(errno));

			break;

#endif

#ifdef EAI_BADHINTS

		case EAI_BADHINTS:

			pcap_snprintf(errbuf, errbuflen,

			    "%sInvalid value for hints when looking up %s",

			    prefix, hostport);

			break;

#endif

#ifdef EAI_PROTOCOL

		case EAI_PROTOCOL:

			pcap_snprintf(errbuf, errbuflen,

			    "%sResolved protocol when looking up %s is unknown",

			    prefix, hostport);

			break;

#endif

#ifdef EAI_OVERFLOW

		case EAI_OVERFLOW:

			pcap_snprintf(errbuf, errbuflen,

			    "%sArgument buffer overflow when looking up %s",

			    prefix, hostport);

			break;

#endif

		default:

			pcap_snprintf(errbuf, errbuflen,

			    "%sgetaddrinfo() error %d when looking up %s",

			    prefix, err, hostport);

			break;

	}

}

/*

 * \brief Checks that the address, port and flags given are valids and it returns an 'addrinfo' structure.

 *

 * This function basically calls the getaddrinfo() calls, and it performs a set of sanity checks

 * to control that everything is fine (e.g. a TCP socket cannot have a mcast address, and such).

 * If an error occurs, it writes the error message into 'errbuf'.

 *

 * \param host: a pointer to a string identifying the host. It can be

 * a host name, a numeric literal address, or NULL or "" (useful

 * in case of a server socket which has to bind to all addresses).

 *

 * \param port: a pointer to a user-allocated buffer containing the network port to use.

 *

 * \param hints: an addrinfo variable (passed by reference) containing the flags needed to create the

 * addrinfo structure appropriately.

 *

 * \param addrinfo: it represents the true returning value. This is a pointer to an addrinfo variable

 * (passed by reference), which will be allocated by this function and returned back to the caller.

 * This variable will be used in the next sockets calls.

 *

 * \param errbuf: a pointer to an user-allocated buffer that will contain the complete

 * error message. This buffer has to be at least 'errbuflen' in length.

 * It can be NULL; in this case the error cannot be printed.

 *

 * \param errbuflen: length of the buffer that will contains the error. The error message cannot be

 * larger than 'errbuflen - 1' because the last char is reserved for the string terminator.

 *

 * \return '0' if everything is fine, '-1' if some errors occurred. The error message is returned

 * in the 'errbuf' variable. The addrinfo variable that has to be used in the following sockets calls is

 * returned into the addrinfo parameter.

 *

 * \warning The 'addrinfo' variable has to be deleted by the programmer by calling freeaddrinfo() when

 * it is no longer needed.

 *

 * \warning This function requires the 'hints' variable as parameter. The semantic of this variable is the same

 * of the one of the corresponding variable used into the standard getaddrinfo() socket function. We suggest

 * the programmer to look at that function in order to set the 'hints' variable appropriately.

 */

int sock_initaddress(const char *host, const char *port,

    struct addrinfo *hints, struct addrinfo **addrinfo, char *errbuf, int errbuflen)

{

	int retval;

	retval = getaddrinfo(host, port, hints, addrinfo);

	if (retval != 0)

	{

		if (errbuf)

		{

			get_gai_errstring(errbuf, errbuflen, "", retval,

			    host, port);

		}

		return -1;

	}

	/*

	 * \warning SOCKET: I should check all the accept() in order to bind to all addresses in case

	 * addrinfo has more han one pointers

	 */

	/*

	 * This software only supports PF_INET and PF_INET6.

	 *

	 * XXX - should we just check that at least *one* address is

	 * either PF_INET or PF_INET6, and, when using the list,

	 * ignore all addresses that are neither?  (What, no IPX

	 * support? :-))

	 */

	if (((*addrinfo)->ai_family != PF_INET) &&

	    ((*addrinfo)->ai_family != PF_INET6))

	{

		if (errbuf)

			pcap_snprintf(errbuf, errbuflen, "getaddrinfo(): socket type not supported");

		freeaddrinfo(*addrinfo);

		*addrinfo = NULL;

		return -1;

	}

	/*

	 * You can't do multicast (or broadcast) TCP.

	 */

	if (((*addrinfo)->ai_socktype == SOCK_STREAM) &&

	    (sock_ismcastaddr((*addrinfo)->ai_addr) == 0))

	{

		if (errbuf)

			pcap_snprintf(errbuf, errbuflen, "getaddrinfo(): multicast addresses are not valid when using TCP streams");

		freeaddrinfo(*addrinfo);

		*addrinfo = NULL;

		return -1;

	}

	return 0;

}

/*

 * \brief It sends the amount of data contained into 'buffer' on the given socket.

 *

 * This function basically calls the send() socket function and it checks that all

 * the data specified in 'buffer' (of size 'size') will be sent. If an error occurs,

 * it writes the error message into 'errbuf'.

 * In case the socket buffer does not have enough space, it loops until all data

 * has been sent.

 *

 * \param socket: the connected socket currently opened.

 *

 * \param buffer: a char pointer to a user-allocated buffer in which data is contained.

 *

 * \param size: number of bytes that have to be sent.

 *

 * \param errbuf: a pointer to an user-allocated buffer that will contain the complete

 * error message. This buffer has to be at least 'errbuflen' in length.

 * It can be NULL; in this case the error cannot be printed.

 *

 * \param errbuflen: length of the buffer that will contains the error. The error message cannot be

 * larger than 'errbuflen - 1' because the last char is reserved for the string terminator.

 *

 * \return '0' if everything is fine, '-1' if an error other than

 * "connection reset" or "peer has closed the receive side" occurred,

 * '-2' if we got one of those errors.

 * For errors, an error message is returned in the 'errbuf' variable.

 */

int sock_send(SOCKET sock, const char *buffer, size_t size,

    char *errbuf, int errbuflen)

{

	int remaining;

	ssize_t nsent;

	if (size > INT_MAX)

	{

		if (errbuf)

		{

			pcap_snprintf(errbuf, errbuflen,

			    "Can't send more than %u bytes with sock_send",

			    INT_MAX);

		}

		return -1;

	}

	remaining = (int)size;

	do {

#ifdef MSG_NOSIGNAL

		/*

		 * Send with MSG_NOSIGNAL, so that we don't get SIGPIPE

		 * on errors on stream-oriented sockets when the other

		 * end breaks the connection.

		 * The EPIPE error is still returned.

		 */

		nsent = send(sock, buffer, remaining, MSG_NOSIGNAL);

#else

		nsent = send(sock, buffer, remaining, 0);

#endif

		if (nsent == -1)

		{

			/*

			 * If the client closed the connection out from

			 * under us, there's no need to log that as an

			 * error.

			 */

			int errcode;

#ifdef _WIN32

			errcode = GetLastError();

			if (errcode == WSAECONNRESET ||

			    errcode == WSAECONNABORTED)

			{

				/*

				 * WSAECONNABORTED appears to be the error

				 * returned in Winsock when you try to send

				 * on a connection where the peer has closed

				 * the receive side.

				 */

				return -2;

			}

			sock_fmterror("send()", errcode, errbuf, errbuflen);

#else

			errcode = errno;

			if (errcode == ECONNRESET || errcode == EPIPE)

			{

				/*

				 * EPIPE is what's returned on UN*X when

				 * you try to send on a connection when

				 * the peer has closed the receive side.

				 */

				return -2;

			}

			sock_fmterror("send()", errcode, errbuf, errbuflen);

#endif

			return -1;

		}

		remaining -= nsent;

		buffer += nsent;

	} while (remaining != 0);

	return 0;

}

/*

 * \brief It copies the amount of data contained into 'buffer' into 'tempbuf'.

 * and it checks for buffer overflows.

 *

 * This function basically copies 'size' bytes of data contained into 'buffer'

 * into 'tempbuf', starting at offset 'offset'. Before that, it checks that the

 * resulting buffer will not be larger	than 'totsize'. Finally, it updates

 * the 'offset' variable in order to point to the first empty location of the buffer.

 *

 * In case the function is called with 'checkonly' equal to 1, it does not copy

 * the data into the buffer. It only checks for buffer overflows and it updates the

 * 'offset' variable. This mode can be useful when the buffer already contains the

 * data (maybe because the producer writes directly into the target buffer), so

 * only the buffer overflow check has to be made.

 * In this case, both 'buffer' and 'tempbuf' can be NULL values.

 *

 * This function is useful in case the userland application does not know immediately

 * all the data it has to write into the socket. This function provides a way to create

 * the "stream" step by step, appending the new data to the old one. Then, when all the

 * data has been bufferized, the application can call the sock_send() function.

 *

 * \param buffer: a char pointer to a user-allocated buffer that keeps the data

 * that has to be copied.

 *

 * \param size: number of bytes that have to be copied.

 *