• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2002 - 2003
3  * NetGroup, Politecnico di Torino (Italy)
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  *
10  * 1. Redistributions of source code must retain the above copyright
11  * notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  * notice, this list of conditions and the following disclaimer in the
14  * documentation and/or other materials provided with the distribution.
15  * 3. Neither the name of the Politecnico di Torino nor the names of its
16  * contributors may be used to endorse or promote products derived from
17  * this software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  *
31  */
32 
33 #ifdef HAVE_CONFIG_H
34 #include <config.h>
35 #endif
36 
37 /*
38  * \file sockutils.c
39  *
40  * The goal of this file is to provide a common set of primitives for socket
41  * manipulation.
42  *
43  * Although the socket interface defined in the RFC 2553 (and its updates)
44  * is excellent, there are still differences between the behavior of those
45  * routines on UN*X and Windows, and between UN*Xes.
46  *
47  * These calls provide an interface similar to the socket interface, but
48  * that hides the differences between operating systems.  It does not
49  * attempt to significantly improve on the socket interface in other
50  * ways.
51  */
52 
53 #include "ftmacros.h"
54 
55 #include <string.h>
56 #include <errno.h>	/* for the errno variable */
57 #include <stdio.h>	/* for the stderr file */
58 #include <stdlib.h>	/* for malloc() and free() */
59 #ifdef HAVE_LIMITS_H
60 #include <limits.h>
61 #else
62 #define INT_MAX		2147483647
63 #endif
64 
65 #include "pcap-int.h"
66 
67 #include "sockutils.h"
68 #include "portability.h"
69 
70 #ifdef _WIN32
71   /*
72    * Winsock initialization.
73    *
74    * Ask for WinSock 2.2.
75    */
76   #define WINSOCK_MAJOR_VERSION 2
77   #define WINSOCK_MINOR_VERSION 2
78 
79   static int sockcount = 0;	/*!< Variable that allows calling the WSAStartup() only one time */
80 #endif
81 
82 /* Some minor differences between UNIX and Win32 */
83 #ifdef _WIN32
84   #define SHUT_WR SD_SEND	/* The control code for shutdown() is different in Win32 */
85 #endif
86 
87 /* Size of the buffer that has to keep error messages */
88 #define SOCK_ERRBUF_SIZE 1024
89 
90 /* Constants; used in order to keep strings here */
91 #define SOCKET_NO_NAME_AVAILABLE "No name available"
92 #define SOCKET_NO_PORT_AVAILABLE "No port available"
93 #define SOCKET_NAME_NULL_DAD "Null address (possibly DAD Phase)"
94 
95 /*
96  * On UN*X, send() and recv() return ssize_t.
97  *
98  * On Windows, send() and recv() return an int.
99  *
100  *   Wth MSVC, there *is* no ssize_t.
101  *
102  *   With MinGW, there is an ssize_t type; it is either an int (32 bit)
103  *   or a long long (64 bit).
104  *
105  * So, on Windows, if we don't have ssize_t defined, define it as an
106  * int, so we can use it, on all platforms, as the type of variables
107  * that hold the return values from send() and recv().
108  */
109 #if defined(_WIN32) && !defined(_SSIZE_T_DEFINED)
110 typedef int ssize_t;
111 #endif
112 
113 /****************************************************
114  *                                                  *
115  * Locally defined functions                        *
116  *                                                  *
117  ****************************************************/
118 
119 static int sock_ismcastaddr(const struct sockaddr *saddr);
120 
121 /****************************************************
122  *                                                  *
123  * Function bodies                                  *
124  *                                                  *
125  ****************************************************/
126 
127 /*
128  * Format an error message given an errno value (UN*X) or a WinSock error
129  * (Windows).
130  */
sock_fmterror(const char * caller,int errcode,char * errbuf,int errbuflen)131 void sock_fmterror(const char *caller, int errcode, char *errbuf, int errbuflen)
132 {
133 #ifdef _WIN32
134 	int retval;
135 	char message[SOCK_ERRBUF_SIZE];	/* We're forcing "ANSI" */
136 
137 	if (errbuf == NULL)
138 		return;
139 
140 	retval = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS |
141 		FORMAT_MESSAGE_MAX_WIDTH_MASK,
142 		NULL, errcode, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
143 		message, sizeof(message) / sizeof(TCHAR), NULL);
144 
145 	if (retval == 0)
146 	{
147 		if ((caller) && (*caller))
148 			pcap_snprintf(errbuf, errbuflen, "%sUnable to get the exact error message", caller);
149 		else
150 			pcap_snprintf(errbuf, errbuflen, "Unable to get the exact error message");
151 	}
152 	else
153 	{
154 		if ((caller) && (*caller))
155 			pcap_snprintf(errbuf, errbuflen, "%s%s (code %d)", caller, message, errcode);
156 		else
157 			pcap_snprintf(errbuf, errbuflen, "%s (code %d)", message, errcode);
158 	}
159 #else
160 	char *message;
161 
162 	if (errbuf == NULL)
163 		return;
164 
165 	message = strerror(errcode);
166 
167 	if ((caller) && (*caller))
168 		pcap_snprintf(errbuf, errbuflen, "%s%s (code %d)", caller, message, errcode);
169 	else
170 		pcap_snprintf(errbuf, errbuflen, "%s (code %d)", message, errcode);
171 #endif
172 }
173 
174 /*
175  * \brief It retrieves the error message after an error occurred in the socket interface.
176  *
177  * This function is defined because of the different way errors are returned in UNIX
178  * and Win32. This function provides a consistent way to retrieve the error message
179  * (after a socket error occurred) on all the platforms.
180  *
181  * \param caller: a pointer to a user-allocated string which contains a message that has
182  * to be printed *before* the true error message. It could be, for example, 'this error
183  * comes from the recv() call at line 31'. It may be NULL.
184  *
185  * \param errbuf: a pointer to an user-allocated buffer that will contain the complete
186  * error message. This buffer has to be at least 'errbuflen' in length.
187  * It can be NULL; in this case the error cannot be printed.
188  *
189  * \param errbuflen: length of the buffer that will contains the error. The error message cannot be
190  * larger than 'errbuflen - 1' because the last char is reserved for the string terminator.
191  *
192  * \return No return values. The error message is returned in the 'string' parameter.
193  */
sock_geterror(const char * caller,char * errbuf,int errbuflen)194 void sock_geterror(const char *caller, char *errbuf, int errbuflen)
195 {
196 #ifdef _WIN32
197 	if (errbuf == NULL)
198 		return;
199 	sock_fmterror(caller, GetLastError(), errbuf, errbuflen);
200 #else
201 	if (errbuf == NULL)
202 		return;
203 	sock_fmterror(caller, errno, errbuf, errbuflen);
204 #endif
205 }
206 
207 /*
208  * \brief It initializes sockets.
209  *
210  * This function is pretty useless on UNIX, since socket initialization is not required.
211  * However it is required on Win32. In UNIX, this function appears to be completely empty.
212  *
213  * \param errbuf: a pointer to an user-allocated buffer that will contain the complete
214  * error message. This buffer has to be at least 'errbuflen' in length.
215  * It can be NULL; in this case the error cannot be printed.
216  *
217  * \param errbuflen: length of the buffer that will contains the error. The error message cannot be
218  * larger than 'errbuflen - 1' because the last char is reserved for the string terminator.
219  *
220  * \return '0' if everything is fine, '-1' if some errors occurred. The error message is returned
221  * in the 'errbuf' variable.
222  */
223 #ifdef _WIN32
sock_init(char * errbuf,int errbuflen)224 int sock_init(char *errbuf, int errbuflen)
225 {
226 	if (sockcount == 0)
227 	{
228 		WSADATA wsaData;			/* helper variable needed to initialize Winsock */
229 
230 		if (WSAStartup(MAKEWORD(WINSOCK_MAJOR_VERSION,
231 		    WINSOCK_MINOR_VERSION), &wsaData) != 0)
232 		{
233 			if (errbuf)
234 				pcap_snprintf(errbuf, errbuflen, "Failed to initialize Winsock\n");
235 
236 			WSACleanup();
237 
238 			return -1;
239 		}
240 	}
241 
242 	sockcount++;
243 #else
244 int sock_init(char *errbuf _U_, int errbuflen _U_)
245 {
246 #endif
247 	return 0;
248 }
249 
250 /*
251  * \brief It deallocates sockets.
252  *
253  * This function is pretty useless on UNIX, since socket deallocation is not required.
254  * However it is required on Win32. In UNIX, this function appears to be completely empty.
255  *
256  * \return No error values.
257  */
258 void sock_cleanup(void)
259 {
260 #ifdef _WIN32
261 	sockcount--;
262 
263 	if (sockcount == 0)
264 		WSACleanup();
265 #endif
266 }
267 
268 /*
269  * \brief It checks if the sockaddr variable contains a multicast address.
270  *
271  * \return '0' if the address is multicast, '-1' if it is not.
272  */
273 static int sock_ismcastaddr(const struct sockaddr *saddr)
274 {
275 	if (saddr->sa_family == PF_INET)
276 	{
277 		struct sockaddr_in *saddr4 = (struct sockaddr_in *) saddr;
278 		if (IN_MULTICAST(ntohl(saddr4->sin_addr.s_addr))) return 0;
279 		else return -1;
280 	}
281 	else
282 	{
283 		struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *) saddr;
284 		if (IN6_IS_ADDR_MULTICAST(&saddr6->sin6_addr)) return 0;
285 		else return -1;
286 	}
287 }
288 
289 /*
290  * \brief It initializes a network connection both from the client and the server side.
291  *
292  * In case of a client socket, this function calls socket() and connect().
293  * In the meanwhile, it checks for any socket error.
294  * If an error occurs, it writes the error message into 'errbuf'.
295  *
296  * In case of a server socket, the function calls socket(), bind() and listen().
297  *
298  * This function is usually preceeded by the sock_initaddress().
299  *
300  * \param addrinfo: pointer to an addrinfo variable which will be used to
301  * open the socket and such. This variable is the one returned by the previous call to
302  * sock_initaddress().
303  *
304  * \param server: '1' if this is a server socket, '0' otherwise.
305  *
306  * \param nconn: number of the connections that are allowed to wait into the listen() call.
307  * This value has no meanings in case of a client socket.
308  *
309  * \param errbuf: a pointer to an user-allocated buffer that will contain the complete
310  * error message. This buffer has to be at least 'errbuflen' in length.
311  * It can be NULL; in this case the error cannot be printed.
312  *
313  * \param errbuflen: length of the buffer that will contains the error. The error message cannot be
314  * larger than 'errbuflen - 1' because the last char is reserved for the string terminator.
315  *
316  * \return the socket that has been opened (that has to be used in the following sockets calls)
317  * if everything is fine, INVALID_SOCKET if some errors occurred. The error message is returned
318  * in the 'errbuf' variable.
319  */
320 SOCKET sock_open(struct addrinfo *addrinfo, int server, int nconn, char *errbuf, int errbuflen)
321 {
322 	SOCKET sock;
323 #if defined(SO_NOSIGPIPE) || defined(IPV6_V6ONLY) || defined(IPV6_BINDV6ONLY)
324 	int on = 1;
325 #endif
326 
327 	sock = socket(addrinfo->ai_family, addrinfo->ai_socktype, addrinfo->ai_protocol);
328 	if (sock == INVALID_SOCKET)
329 	{
330 		sock_geterror("socket(): ", errbuf, errbuflen);
331 		return INVALID_SOCKET;
332 	}
333 
334 	/*
335 	 * Disable SIGPIPE, if we have SO_NOSIGPIPE.  We don't want to
336 	 * have to deal with signals if the peer closes the connection,
337 	 * especially in client programs, which may not even be aware that
338 	 * they're sending to sockets.
339 	 */
340 #ifdef SO_NOSIGPIPE
341 	if (setsockopt(sock, SOL_SOCKET, SO_NOSIGPIPE, (char *)&on,
342 	    sizeof (int)) == -1)
343 	{
344 		sock_geterror("setsockopt(SO_NOSIGPIPE)", errbuf, errbuflen);
345 		closesocket(sock);
346 		return INVALID_SOCKET;
347 	}
348 #endif
349 
350 	/* This is a server socket */
351 	if (server)
352 	{
353 #if defined(IPV6_V6ONLY) || defined(IPV6_BINDV6ONLY)
354 		/*
355 		 * Force the use of IPv6-only addresses.
356 		 *
357 		 * RFC 3493 indicates that you can support IPv4 on an
358 		 * IPv6 socket:
359 		 *
360 		 *    https://tools.ietf.org/html/rfc3493#section-3.7
361 		 *
362 		 * and that this is the default behavior.  This means
363 		 * that if we first create an IPv6 socket bound to the
364 		 * "any" address, it is, in effect, also bound to the
365 		 * IPv4 "any" address, so when we create an IPv4 socket
366 		 * and try to bind it to the IPv4 "any" address, it gets
367 		 * EADDRINUSE.
368 		 *
369 		 * Not all network stacks support IPv4 on IPv6 sockets;
370 		 * pre-NT 6 Windows stacks don't support it, and the
371 		 * OpenBSD stack doesn't support it for security reasons
372 		 * (see the OpenBSD inet6(4) man page).  Therefore, we
373 		 * don't want to rely on this behavior.
374 		 *
375 		 * So we try to disable it, using either the IPV6_V6ONLY
376 		 * option from RFC 3493:
377 		 *
378 		 *    https://tools.ietf.org/html/rfc3493#section-5.3
379 		 *
380 		 * or the IPV6_BINDV6ONLY option from older UN*Xes.
381 		 */
382 #ifndef IPV6_V6ONLY
383   /* For older systems */
384   #define IPV6_V6ONLY IPV6_BINDV6ONLY
385 #endif /* IPV6_V6ONLY */
386 		if (addrinfo->ai_family == PF_INET6)
387 		{
388 			if (setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY,
389 			    (char *)&on, sizeof (int)) == -1)
390 			{
391 				if (errbuf)
392 					pcap_snprintf(errbuf, errbuflen, "setsockopt(IPV6_V6ONLY)");
393 				closesocket(sock);
394 				return INVALID_SOCKET;
395 			}
396 		}
397 #endif /* defined(IPV6_V6ONLY) || defined(IPV6_BINDV6ONLY) */
398 
399 		/* WARNING: if the address is a mcast one, I should place the proper Win32 code here */
400 		if (bind(sock, addrinfo->ai_addr, (int) addrinfo->ai_addrlen) != 0)
401 		{
402 			sock_geterror("bind(): ", errbuf, errbuflen);
403 			closesocket(sock);
404 			return INVALID_SOCKET;
405 		}
406 
407 		if (addrinfo->ai_socktype == SOCK_STREAM)
408 			if (listen(sock, nconn) == -1)
409 			{
410 				sock_geterror("listen(): ", errbuf, errbuflen);
411 				closesocket(sock);
412 				return INVALID_SOCKET;
413 			}
414 
415 		/* server side ended */
416 		return sock;
417 	}
418 	else	/* we're the client */
419 	{
420 		struct addrinfo *tempaddrinfo;
421 		char *errbufptr;
422 		size_t bufspaceleft;
423 
424 		tempaddrinfo = addrinfo;
425 		errbufptr = errbuf;
426 		bufspaceleft = errbuflen;
427 		*errbufptr = 0;
428 
429 		/*
430 		 * We have to loop though all the addinfo returned.
431 		 * For instance, we can have both IPv6 and IPv4 addresses, but the service we're trying
432 		 * to connect to is unavailable in IPv6, so we have to try in IPv4 as well
433 		 */
434 		while (tempaddrinfo)
435 		{
436 
437 			if (connect(sock, tempaddrinfo->ai_addr, (int) tempaddrinfo->ai_addrlen) == -1)
438 			{
439 				size_t msglen;
440 				char TmpBuffer[100];
441 				char SocketErrorMessage[SOCK_ERRBUF_SIZE];
442 
443 				/*
444 				 * We have to retrieve the error message before any other socket call completes, otherwise
445 				 * the error message is lost
446 				 */
447 				sock_geterror(NULL, SocketErrorMessage, sizeof(SocketErrorMessage));
448 
449 				/* Returns the numeric address of the host that triggered the error */
450 				sock_getascii_addrport((struct sockaddr_storage *) tempaddrinfo->ai_addr, TmpBuffer, sizeof(TmpBuffer), NULL, 0, NI_NUMERICHOST, TmpBuffer, sizeof(TmpBuffer));
451 
452 				pcap_snprintf(errbufptr, bufspaceleft,
453 				    "Is the server properly installed on %s?  connect() failed: %s", TmpBuffer, SocketErrorMessage);
454 
455 				/* In case more then one 'connect' fails, we manage to keep all the error messages */
456 				msglen = strlen(errbufptr);
457 
458 				errbufptr[msglen] = ' ';
459 				errbufptr[msglen + 1] = 0;
460 
461 				bufspaceleft = bufspaceleft - (msglen + 1);
462 				errbufptr += (msglen + 1);
463 
464 				tempaddrinfo = tempaddrinfo->ai_next;
465 			}
466 			else
467 				break;
468 		}
469 
470 		/*
471 		 * Check how we exit from the previous loop
472 		 * If tempaddrinfo is equal to NULL, it means that all the connect() failed.
473 		 */
474 		if (tempaddrinfo == NULL)
475 		{
476 			closesocket(sock);
477 			return INVALID_SOCKET;
478 		}
479 		else
480 			return sock;
481 	}
482 }
483 
484 /*
485  * \brief Closes the present (TCP and UDP) socket connection.
486  *
487  * This function sends a shutdown() on the socket in order to disable send() calls
488  * (while recv() ones are still allowed). Then, it closes the socket.
489  *
490  * \param sock: the socket identifier of the connection that has to be closed.
491  *
492  * \param errbuf: a pointer to an user-allocated buffer that will contain the complete
493  * error message. This buffer has to be at least 'errbuflen' in length.
494  * It can be NULL; in this case the error cannot be printed.
495  *
496  * \param errbuflen: length of the buffer that will contains the error. The error message cannot be
497  * larger than 'errbuflen - 1' because the last char is reserved for the string terminator.
498  *
499  * \return '0' if everything is fine, '-1' if some errors occurred. The error message is returned
500  * in the 'errbuf' variable.
501  */
502 int sock_close(SOCKET sock, char *errbuf, int errbuflen)
503 {
504 	/*
505 	 * SHUT_WR: subsequent calls to the send function are disallowed.
506 	 * For TCP sockets, a FIN will be sent after all data is sent and
507 	 * acknowledged by the Server.
508 	 */
509 	if (shutdown(sock, SHUT_WR))
510 	{
511 		sock_geterror("shutdown(): ", errbuf, errbuflen);
512 		/* close the socket anyway */
513 		closesocket(sock);
514 		return -1;
515 	}
516 
517 	closesocket(sock);
518 	return 0;
519 }
520 
521 /*
522  * \brief Checks that the address, port and flags given are valids and it returns an 'addrinfo' structure.
523  *
524  * This function basically calls the getaddrinfo() calls, and it performs a set of sanity checks
525  * to control that everything is fine (e.g. a TCP socket cannot have a mcast address, and such).
526  * If an error occurs, it writes the error message into 'errbuf'.
527  *
528  * \param host: a pointer to a string identifying the host. It can be
529  * a host name, a numeric literal address, or NULL or "" (useful
530  * in case of a server socket which has to bind to all addresses).
531  *
532  * \param port: a pointer to a user-allocated buffer containing the network port to use.
533  *
534  * \param hints: an addrinfo variable (passed by reference) containing the flags needed to create the
535  * addrinfo structure appropriately.
536  *
537  * \param addrinfo: it represents the true returning value. This is a pointer to an addrinfo variable
538  * (passed by reference), which will be allocated by this function and returned back to the caller.
539  * This variable will be used in the next sockets calls.
540  *
541  * \param errbuf: a pointer to an user-allocated buffer that will contain the complete
542  * error message. This buffer has to be at least 'errbuflen' in length.
543  * It can be NULL; in this case the error cannot be printed.
544  *
545  * \param errbuflen: length of the buffer that will contains the error. The error message cannot be
546  * larger than 'errbuflen - 1' because the last char is reserved for the string terminator.
547  *
548  * \return '0' if everything is fine, '-1' if some errors occurred. The error message is returned
549  * in the 'errbuf' variable. The addrinfo variable that has to be used in the following sockets calls is
550  * returned into the addrinfo parameter.
551  *
552  * \warning The 'addrinfo' variable has to be deleted by the programmer by calling freeaddrinfo() when
553  * it is no longer needed.
554  *
555  * \warning This function requires the 'hints' variable as parameter. The semantic of this variable is the same
556  * of the one of the corresponding variable used into the standard getaddrinfo() socket function. We suggest
557  * the programmer to look at that function in order to set the 'hints' variable appropriately.
558  */
559 int sock_initaddress(const char *host, const char *port,
560     struct addrinfo *hints, struct addrinfo **addrinfo, char *errbuf, int errbuflen)
561 {
562 	int retval;
563 
564 	retval = getaddrinfo(host, port, hints, addrinfo);
565 	if (retval != 0)
566 	{
567 		/*
568 		 * if the getaddrinfo() fails, you have to use gai_strerror(), instead of using the standard
569 		 * error routines (errno) in UNIX; Winsock suggests using the GetLastError() instead.
570 		 */
571 		if (errbuf)
572 		{
573 #ifdef _WIN32
574 			sock_geterror("getaddrinfo(): ", errbuf, errbuflen);
575 #else
576 			pcap_snprintf(errbuf, errbuflen, "getaddrinfo() %s", gai_strerror(retval));
577 #endif
578 		}
579 		return -1;
580 	}
581 	/*
582 	 * \warning SOCKET: I should check all the accept() in order to bind to all addresses in case
583 	 * addrinfo has more han one pointers
584 	 */
585 
586 	/*
587 	 * This software only supports PF_INET and PF_INET6.
588 	 *
589 	 * XXX - should we just check that at least *one* address is
590 	 * either PF_INET or PF_INET6, and, when using the list,
591 	 * ignore all addresses that are neither?  (What, no IPX
592 	 * support? :-))
593 	 */
594 	if (((*addrinfo)->ai_family != PF_INET) &&
595 	    ((*addrinfo)->ai_family != PF_INET6))
596 	{
597 		if (errbuf)
598 			pcap_snprintf(errbuf, errbuflen, "getaddrinfo(): socket type not supported");
599 		freeaddrinfo(*addrinfo);
600 		*addrinfo = NULL;
601 		return -1;
602 	}
603 
604 	/*
605 	 * You can't do multicast (or broadcast) TCP.
606 	 */
607 	if (((*addrinfo)->ai_socktype == SOCK_STREAM) &&
608 	    (sock_ismcastaddr((*addrinfo)->ai_addr) == 0))
609 	{
610 		if (errbuf)
611 			pcap_snprintf(errbuf, errbuflen, "getaddrinfo(): multicast addresses are not valid when using TCP streams");
612 		freeaddrinfo(*addrinfo);
613 		*addrinfo = NULL;
614 		return -1;
615 	}
616 
617 	return 0;
618 }
619 
620 /*
621  * \brief It sends the amount of data contained into 'buffer' on the given socket.
622  *
623  * This function basically calls the send() socket function and it checks that all
624  * the data specified in 'buffer' (of size 'size') will be sent. If an error occurs,
625  * it writes the error message into 'errbuf'.
626  * In case the socket buffer does not have enough space, it loops until all data
627  * has been sent.
628  *
629  * \param socket: the connected socket currently opened.
630  *
631  * \param buffer: a char pointer to a user-allocated buffer in which data is contained.
632  *
633  * \param size: number of bytes that have to be sent.
634  *
635  * \param errbuf: a pointer to an user-allocated buffer that will contain the complete
636  * error message. This buffer has to be at least 'errbuflen' in length.
637  * It can be NULL; in this case the error cannot be printed.
638  *
639  * \param errbuflen: length of the buffer that will contains the error. The error message cannot be
640  * larger than 'errbuflen - 1' because the last char is reserved for the string terminator.
641  *
642  * \return '0' if everything is fine, '-1' if an error other than
643  * "connection reset" or "peer has closed the receive side" occurred,
644  * '-2' if we got one of those errors.
645  * For errors, an error message is returned in the 'errbuf' variable.
646  */
647 int sock_send(SOCKET sock, const char *buffer, size_t size,
648     char *errbuf, int errbuflen)
649 {
650 	int remaining;
651 	ssize_t nsent;
652 
653 	if (size > INT_MAX)
654 	{
655 		if (errbuf)
656 		{
657 			pcap_snprintf(errbuf, errbuflen,
658 			    "Can't send more than %u bytes with sock_recv",
659 			    INT_MAX);
660 		}
661 		return -1;
662 	}
663 	remaining = (int)size;
664 
665 	do {
666 #ifdef MSG_NOSIGNAL
667 		/*
668 		 * Send with MSG_NOSIGNAL, so that we don't get SIGPIPE
669 		 * on errors on stream-oriented sockets when the other
670 		 * end breaks the connection.
671 		 * The EPIPE error is still returned.
672 		 */
673 		nsent = send(sock, buffer, remaining, MSG_NOSIGNAL);
674 #else
675 		nsent = send(sock, buffer, remaining, 0);
676 #endif
677 
678 		if (nsent == -1)
679 		{
680 			/*
681 			 * If the client closed the connection out from
682 			 * under us, there's no need to log that as an
683 			 * error.
684 			 */
685 			int errcode;
686 
687 #ifdef _WIN32
688 			errcode = GetLastError();
689 			if (errcode == WSAECONNRESET ||
690 			    errcode == WSAECONNABORTED)
691 			{
692 				/*
693 				 * WSAECONNABORTED appears to be the error
694 				 * returned in Winsock when you try to send
695 				 * on a connection where the peer has closed
696 				 * the receive side.
697 				 */
698 				return -2;
699 			}
700 			sock_fmterror("send(): ", errcode, errbuf, errbuflen);
701 #else
702 			errcode = errno;
703 			if (errcode == ECONNRESET || errcode == EPIPE)
704 			{
705 				/*
706 				 * EPIPE is what's returned on UN*X when
707 				 * you try to send on a connection when
708 				 * the peer has closed the receive side.
709 				 */
710 				return -2;
711 			}
712 			sock_fmterror("send(): ", errcode, errbuf, errbuflen);
713 #endif
714 			return -1;
715 		}
716 
717 		remaining -= nsent;
718 		buffer += nsent;
719 	} while (remaining != 0);
720 
721 	return 0;
722 }
723 
724 /*
725  * \brief It copies the amount of data contained into 'buffer' into 'tempbuf'.
726  * and it checks for buffer overflows.
727  *
728  * This function basically copies 'size' bytes of data contained into 'buffer'
729  * into 'tempbuf', starting at offset 'offset'. Before that, it checks that the
730  * resulting buffer will not be larger	than 'totsize'. Finally, it updates
731  * the 'offset' variable in order to point to the first empty location of the buffer.
732  *
733  * In case the function is called with 'checkonly' equal to 1, it does not copy
734  * the data into the buffer. It only checks for buffer overflows and it updates the
735  * 'offset' variable. This mode can be useful when the buffer already contains the
736  * data (maybe because the producer writes directly into the target buffer), so
737  * only the buffer overflow check has to be made.
738  * In this case, both 'buffer' and 'tempbuf' can be NULL values.
739  *
740  * This function is useful in case the userland application does not know immediately
741  * all the data it has to write into the socket. This function provides a way to create
742  * the "stream" step by step, appending the new data to the old one. Then, when all the
743  * data has been bufferized, the application can call the sock_send() function.
744  *
745  * \param buffer: a char pointer to a user-allocated buffer that keeps the data
746  * that has to be copied.
747  *
748  * \param size: number of bytes that have to be copied.
749  *
750  * \param tempbuf: user-allocated buffer (of size 'totsize') in which data
751  * has to be copied.
752  *
753  * \param offset: an index into 'tempbuf' which keeps the location of its first
754  * empty location.
755  *
756  * \param totsize: total size of the buffer in which data is being copied.
757  *
758  * \param checkonly: '1' if we do not want to copy data into the buffer and we
759  * want just do a buffer ovreflow control, '0' if data has to be copied as well.
760  *
761  * \param errbuf: a pointer to an user-allocated buffer that will contain the complete
762  * error message. This buffer has to be at least 'errbuflen' in length.
763  * It can be NULL; in this case the error cannot be printed.
764  *
765  * \param errbuflen: length of the buffer that will contains the error. The error message cannot be
766  * larger than 'errbuflen - 1' because the last char is reserved for the string terminator.
767  *
768  * \return '0' if everything is fine, '-1' if some errors occurred. The error message
769  * is returned in the 'errbuf' variable. When the function returns, 'tempbuf' will
770  * have the new string appended, and 'offset' will keep the length of that buffer.
771  * In case of 'checkonly == 1', data is not copied, but 'offset' is updated in any case.
772  *
773  * \warning This function assumes that the buffer in which data has to be stored is
774  * large 'totbuf' bytes.
775  *
776  * \warning In case of 'checkonly', be carefully to call this function *before* copying
777  * the data into the buffer. Otherwise, the control about the buffer overflow is useless.
778  */
779 int sock_bufferize(const char *buffer, int size, char *tempbuf, int *offset, int totsize, int checkonly, char *errbuf, int errbuflen)
780 {
781 	if ((*offset + size) > totsize)
782 	{
783 		if (errbuf)
784 			pcap_snprintf(errbuf, errbuflen, "Not enough space in the temporary send buffer.");
785 		return -1;
786 	}
787 
788 	if (!checkonly)
789 		memcpy(tempbuf + (*offset), buffer, size);
790 
791 	(*offset) += size;
792 
793 	return 0;
794 }
795 
796 /*
797  * \brief It waits on a connected socket and it manages to receive data.
798  *
799  * This function basically calls the recv() socket function and it checks that no
800  * error occurred. If that happens, it writes the error message into 'errbuf'.
801  *
802  * This function changes its behavior according to the 'receiveall' flag: if we
803  * want to receive exactly 'size' byte, it loops on the recv()	until all the requested
804  * data is arrived. Otherwise, it returns the data currently available.
805  *
806  * In case the socket does not have enough data available, it cycles on the recv()
807  * until the requested data (of size 'size') is arrived.
808  * In this case, it blocks until the number of bytes read is equal to 'size'.
809  *
810  * \param sock: the connected socket currently opened.
811  *
812  * \param buffer: a char pointer to a user-allocated buffer in which data has to be stored
813  *
814  * \param size: size of the allocated buffer. WARNING: this indicates the number of bytes
815  * that we are expecting to be read.
816  *
817  * \param flags:
818  *
819  *   SOCK_RECEIVALL_XXX:
820  *
821  * 	if SOCK_RECEIVEALL_NO, return as soon as some data is ready
822  *	if SOCK_RECEIVALL_YES, wait until 'size' data has been
823  *	    received (in case the socket does not have enough data available).
824  *
825  *   SOCK_EOF_XXX:
826  *
827  *	if SOCK_EOF_ISNT_ERROR, if the first read returns 0, just return 0,
828  *	    and return an error on any subsequent read that returns 0;
829  *	if SOCK_EOF_IS_ERROR, if any read returns 0, return an error.
830  *
831  * \param errbuf: a pointer to an user-allocated buffer that will contain the complete
832  * error message. This buffer has to be at least 'errbuflen' in length.
833  * It can be NULL; in this case the error cannot be printed.
834  *
835  * \param errbuflen: length of the buffer that will contains the error. The error message cannot be
836  * larger than 'errbuflen - 1' because the last char is reserved for the string terminator.
837  *
838  * \return the number of bytes read if everything is fine, '-1' if some errors occurred.
839  * The error message is returned in the 'errbuf' variable.
840  */
841 
842 int sock_recv(SOCKET sock, void *buffer, size_t size, int flags,
843     char *errbuf, int errbuflen)
844 {
845 	char *bufp = buffer;
846 	int remaining;
847 	ssize_t nread;
848 
849 	if (size == 0)
850 	{
851 		SOCK_DEBUG_MESSAGE("I have been requested to read zero bytes");
852 		return 0;
853 	}
854 	if (size > INT_MAX)
855 	{
856 		if (errbuf)
857 		{
858 			pcap_snprintf(errbuf, errbuflen,
859 			    "Can't read more than %u bytes with sock_recv",
860 			    INT_MAX);
861 		}
862 		return -1;
863 	}
864 
865 	bufp = (char *) buffer;
866 	remaining = (int) size;
867 
868 	/*
869 	 * We don't use MSG_WAITALL because it's not supported in
870 	 * Win32.
871 	 */
872 	for (;;) {
873 		nread = recv(sock, bufp, remaining, 0);
874 
875 		if (nread == -1)
876 		{
877 #ifndef _WIN32
878 			if (errno == EINTR)
879 				return -3;
880 #endif
881 			sock_geterror("recv(): ", errbuf, errbuflen);
882 			return -1;
883 		}
884 
885 		if (nread == 0)
886 		{
887 			if ((flags & SOCK_EOF_IS_ERROR) ||
888 			    (remaining != (int) size))
889 			{
890 				/*
891 				 * Either we've already read some data,
892 				 * or we're always supposed to return
893 				 * an error on EOF.
894 				 */
895 				if (errbuf)
896 				{
897 					pcap_snprintf(errbuf, errbuflen,
898 					    "The other host terminated the connection.");
899 				}
900 				return -1;
901 			}
902 			else
903 				return 0;
904 		}
905 
906 		/*
907 		 * Do we want to read the amount requested, or just return
908 		 * what we got?
909 		 */
910 		if (!(flags & SOCK_RECEIVEALL_YES))
911 		{
912 			/*
913 			 * Just return what we got.
914 			 */
915 			return (int) nread;
916 		}
917 
918 		bufp += nread;
919 		remaining -= nread;
920 
921 		if (remaining == 0)
922 			return (int) size;
923 	}
924 }
925 
926 /*
927  * Receives a datagram from a socket.
928  *
929  * Returns the size of the datagram on success or -1 on error.
930  */
931 int sock_recv_dgram(SOCKET sock, void *buffer, size_t size,
932     char *errbuf, int errbuflen)
933 {
934 	ssize_t nread;
935 #ifndef _WIN32
936 	struct msghdr message;
937 	struct iovec iov;
938 #endif
939 
940 	if (size == 0)
941 	{
942 		SOCK_DEBUG_MESSAGE("I have been requested to read zero bytes");
943 		return 0;
944 	}
945 	if (size > INT_MAX)
946 	{
947 		if (errbuf)
948 		{
949 			pcap_snprintf(errbuf, errbuflen,
950 			    "Can't read more than %u bytes with sock_recv_dgram",
951 			    INT_MAX);
952 		}
953 		return -1;
954 	}
955 
956 	/*
957 	 * This should be a datagram socket, so we should get the
958 	 * entire datagram in one recv() or recvmsg() call, and
959 	 * don't need to loop.
960 	 */
961 #ifdef _WIN32
962 	nread = recv(sock, buffer, size, 0);
963 	if (nread == SOCKET_ERROR)
964 	{
965 		/*
966 		 * To quote the MSDN documentation for recv(),
967 		 * "If the datagram or message is larger than
968 		 * the buffer specified, the buffer is filled
969 		 * with the first part of the datagram, and recv
970 		 * generates the error WSAEMSGSIZE. For unreliable
971 		 * protocols (for example, UDP) the excess data is
972 		 * lost..."
973 		 *
974 		 * So if the message is bigger than the buffer
975 		 * supplied to us, the excess data is discarded,
976 		 * and we'll report an error.
977 		 */
978 		sock_geterror("recv(): ", errbuf, errbuflen);
979 		return -1;
980 	}
981 #else /* _WIN32 */
982 	/*
983 	 * The Single UNIX Specification says that a recv() on
984 	 * a socket for a message-oriented protocol will discard
985 	 * the excess data.  It does *not* indicate that the
986 	 * receive will fail with, for example, EMSGSIZE.
987 	 *
988 	 * Therefore, we use recvmsg(), which appears to be
989 	 * the only way to get a "message truncated" indication
990 	 * when receiving a message for a message-oriented
991 	 * protocol.
992 	 */
993 	message.msg_name = NULL;	/* we don't care who it's from */
994 	message.msg_namelen = 0;
995 	iov.iov_base = buffer;
996 	iov.iov_len = size;
997 	message.msg_iov = &iov;
998 	message.msg_iovlen = 1;
999 #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL
1000 	message.msg_control = NULL;	/* we don't care about control information */
1001 	message.msg_controllen = 0;
1002 #endif
1003 #ifdef HAVE_STRUCT_MSGHDR_MSG_FLAGS
1004 	message.msg_flags = 0;
1005 #endif
1006 	nread = recvmsg(sock, &message, 0);
1007 	if (nread == -1)
1008 	{
1009 		if (errno == EINTR)
1010 			return -3;
1011 		sock_geterror("recv(): ", errbuf, errbuflen);
1012 		return -1;
1013 	}
1014 #ifdef HAVE_STRUCT_MSGHDR_MSG_FLAGS
1015 	/*
1016 	 * XXX - Solaris supports this, but only if you ask for the
1017 	 * X/Open version of recvmsg(); should we use that, or will
1018 	 * that cause other problems?
1019 	 */
1020 	if (message.msg_flags & MSG_TRUNC)
1021 	{
1022 		/*
1023 		 * Message was bigger than the specified buffer size.
1024 		 *
1025 		 * Report this as an error, as the Microsoft documentation
1026 		 * implies we'd do in a similar case on Windows.
1027 		 */
1028 		pcap_snprintf(errbuf, errbuflen, "recv(): Message too long");
1029 		return -1;
1030 	}
1031 #endif /* HAVE_STRUCT_MSGHDR_MSG_FLAGS */
1032 #endif /* _WIN32 */
1033 
1034 	/*
1035 	 * The size we're reading fits in an int, so the return value
1036 	 * will fit in an int.
1037 	 */
1038 	return (int)nread;
1039 }
1040 
1041 /*
1042  * \brief It discards N bytes that are currently waiting to be read on the current socket.
1043  *
1044  * This function is useful in case we receive a message we cannot understand (e.g.
1045  * wrong version number when receiving a network packet), so that we have to discard all
1046  * data before reading a new message.
1047  *
1048  * This function will read 'size' bytes from the socket and discard them.
1049  * It defines an internal buffer in which data will be copied; however, in case
1050  * this buffer is not large enough, it will cycle in order to read everything as well.
1051  *
1052  * \param sock: the connected socket currently opened.
1053  *
1054  * \param size: number of bytes that have to be discarded.
1055  *
1056  * \param errbuf: a pointer to an user-allocated buffer that will contain the complete
1057  * error message. This buffer has to be at least 'errbuflen' in length.
1058  * It can be NULL; in this case the error cannot be printed.
1059  *
1060  * \param errbuflen: length of the buffer that will contains the error. The error message cannot be
1061  * larger than 'errbuflen - 1' because the last char is reserved for the string terminator.
1062  *
1063  * \return '0' if everything is fine, '-1' if some errors occurred.
1064  * The error message is returned in the 'errbuf' variable.
1065  */
1066 int sock_discard(SOCKET sock, int size, char *errbuf, int errbuflen)
1067 {
1068 #define TEMP_BUF_SIZE 32768
1069 
1070 	char buffer[TEMP_BUF_SIZE];		/* network buffer, to be used when the message is discarded */
1071 
1072 	/*
1073 	 * A static allocation avoids the need of a 'malloc()' each time we want to discard a message
1074 	 * Our feeling is that a buffer if 32KB is enough for most of the application;
1075 	 * in case this is not enough, the "while" loop discards the message by calling the
1076 	 * sockrecv() several times.
1077 	 * We do not want to create a bigger variable because this causes the program to exit on
1078 	 * some platforms (e.g. BSD)
1079 	 */
1080 	while (size > TEMP_BUF_SIZE)
1081 	{
1082 		if (sock_recv(sock, buffer, TEMP_BUF_SIZE, SOCK_RECEIVEALL_YES, errbuf, errbuflen) == -1)
1083 			return -1;
1084 
1085 		size -= TEMP_BUF_SIZE;
1086 	}
1087 
1088 	/*
1089 	 * If there is still data to be discarded
1090 	 * In this case, the data can fit into the temporary buffer
1091 	 */
1092 	if (size)
1093 	{
1094 		if (sock_recv(sock, buffer, size, SOCK_RECEIVEALL_YES, errbuf, errbuflen) == -1)
1095 			return -1;
1096 	}
1097 
1098 	SOCK_DEBUG_MESSAGE("I'm currently discarding data\n");
1099 
1100 	return 0;
1101 }
1102 
1103 /*
1104  * \brief Checks that one host (identified by the sockaddr_storage structure) belongs to an 'allowed list'.
1105  *
1106  * This function is useful after an accept() call in order to check if the connecting
1107  * host is allowed to connect to me. To do that, we have a buffer that keeps the list of the
1108  * allowed host; this function checks the sockaddr_storage structure of the connecting host
1109  * against this host list, and it returns '0' is the host is included in this list.
1110  *
1111  * \param hostlist: pointer to a string that contains the list of the allowed host.
1112  *
1113  * \param sep: a string that keeps the separators used between the hosts (for example the
1114  * space character) in the host list.
1115  *
1116  * \param from: a sockaddr_storage structure, as it is returned by the accept() call.
1117  *
1118  * \param errbuf: a pointer to an user-allocated buffer that will contain the complete
1119  * error message. This buffer has to be at least 'errbuflen' in length.
1120  * It can be NULL; in this case the error cannot be printed.
1121  *
1122  * \param errbuflen: length of the buffer that will contains the error. The error message cannot be
1123  * larger than 'errbuflen - 1' because the last char is reserved for the string terminator.
1124  *
1125  * \return It returns:
1126  * - '1' if the host list is empty
1127  * - '0' if the host belongs to the host list (and therefore it is allowed to connect)
1128  * - '-1' in case the host does not belong to the host list (and therefore it is not allowed to connect
1129  * - '-2' in case or error. The error message is returned in the 'errbuf' variable.
1130  */
1131 int sock_check_hostlist(char *hostlist, const char *sep, struct sockaddr_storage *from, char *errbuf, int errbuflen)
1132 {
1133 	/* checks if the connecting host is among the ones allowed */
1134 	if ((hostlist) && (hostlist[0]))
1135 	{
1136 		char *token;					/* temp, needed to separate items into the hostlist */
1137 		struct addrinfo *addrinfo, *ai_next;
1138 		char *temphostlist;
1139 		char *lasts;
1140 
1141 		/*
1142 		 * The problem is that strtok modifies the original variable by putting '0' at the end of each token
1143 		 * So, we have to create a new temporary string in which the original content is kept
1144 		 */
1145 		temphostlist = strdup(hostlist);
1146 		if (temphostlist == NULL)
1147 		{
1148 			sock_geterror("sock_check_hostlist(), malloc() failed", errbuf, errbuflen);
1149 			return -2;
1150 		}
1151 
1152 		token = pcap_strtok_r(temphostlist, sep, &lasts);
1153 
1154 		/* it avoids a warning in the compilation ('addrinfo used but not initialized') */
1155 		addrinfo = NULL;
1156 
1157 		while (token != NULL)
1158 		{
1159 			struct addrinfo hints;
1160 			int retval;
1161 
1162 			addrinfo = NULL;
1163 			memset(&hints, 0, sizeof(struct addrinfo));
1164 			hints.ai_family = PF_UNSPEC;
1165 			hints.ai_socktype = SOCK_STREAM;
1166 
1167 			retval = getaddrinfo(token, "0", &hints, &addrinfo);
1168 			if (retval != 0)
1169 			{
1170 				if (errbuf)
1171 					pcap_snprintf(errbuf, errbuflen, "getaddrinfo() %s", gai_strerror(retval));
1172 
1173 				SOCK_DEBUG_MESSAGE(errbuf);
1174 
1175 				/* Get next token */
1176 				token = pcap_strtok_r(NULL, sep, &lasts);
1177 				continue;
1178 			}
1179 
1180 			/* ai_next is required to preserve the content of addrinfo, in order to deallocate it properly */
1181 			ai_next = addrinfo;
1182 			while (ai_next)
1183 			{
1184 				if (sock_cmpaddr(from, (struct sockaddr_storage *) ai_next->ai_addr) == 0)
1185 				{
1186 					free(temphostlist);
1187 					freeaddrinfo(addrinfo);
1188 					return 0;
1189 				}
1190 
1191 				/*
1192 				 * If we are here, it means that the current address does not matches
1193 				 * Let's try with the next one in the header chain
1194 				 */
1195 				ai_next = ai_next->ai_next;
1196 			}
1197 
1198 			freeaddrinfo(addrinfo);
1199 			addrinfo = NULL;
1200 
1201 			/* Get next token */
1202 			token = pcap_strtok_r(NULL, sep, &lasts);
1203 		}
1204 
1205 		if (addrinfo)
1206 		{
1207 			freeaddrinfo(addrinfo);
1208 			addrinfo = NULL;
1209 		}
1210 
1211 		if (errbuf)
1212 			pcap_snprintf(errbuf, errbuflen, "The host is not in the allowed host list. Connection refused.");
1213 
1214 		free(temphostlist);
1215 		return -1;
1216 	}
1217 
1218 	/* No hostlist, so we have to return 'empty list' */
1219 	return 1;
1220 }
1221 
1222 /*
1223  * \brief Compares two addresses contained into two sockaddr_storage structures.
1224  *
1225  * This function is useful to compare two addresses, given their internal representation,
1226  * i.e. an sockaddr_storage structure.
1227  *
1228  * The two structures do not need to be sockaddr_storage; you can have both 'sockaddr_in' and
1229  * sockaddr_in6, properly acsted in order to be compliant to the function interface.
1230  *
1231  * This function will return '0' if the two addresses matches, '-1' if not.
1232  *
1233  * \param first: a sockaddr_storage structure, (for example the one that is returned by an
1234  * accept() call), containing the first address to compare.
1235  *
1236  * \param second: a sockaddr_storage structure containing the second address to compare.
1237  *
1238  * \return '0' if the addresses are equal, '-1' if they are different.
1239  */
1240 int sock_cmpaddr(struct sockaddr_storage *first, struct sockaddr_storage *second)
1241 {
1242 	if (first->ss_family == second->ss_family)
1243 	{
1244 		if (first->ss_family == AF_INET)
1245 		{
1246 			if (memcmp(&(((struct sockaddr_in *) first)->sin_addr),
1247 				&(((struct sockaddr_in *) second)->sin_addr),
1248 				sizeof(struct in_addr)) == 0)
1249 				return 0;
1250 		}
1251 		else /* address family is AF_INET6 */
1252 		{
1253 			if (memcmp(&(((struct sockaddr_in6 *) first)->sin6_addr),
1254 				&(((struct sockaddr_in6 *) second)->sin6_addr),
1255 				sizeof(struct in6_addr)) == 0)
1256 				return 0;
1257 		}
1258 	}
1259 
1260 	return -1;
1261 }
1262 
1263 /*
1264  * \brief It gets the address/port the system picked for this socket (on connected sockets).
1265  *
1266  * It is used to return the address and port the server picked for our socket on the local machine.
1267  * It works only on:
1268  * - connected sockets
1269  * - server sockets
1270  *
1271  * On unconnected client sockets it does not work because the system dynamically chooses a port
1272  * only when the socket calls a send() call.
1273  *
1274  * \param sock: the connected socket currently opened.
1275  *
1276  * \param address: it contains the address that will be returned by the function. This buffer
1277  * must be properly allocated by the user. The address can be either literal or numeric depending
1278  * on the value of 'Flags'.
1279  *
1280  * \param addrlen: the length of the 'address' buffer.
1281  *
1282  * \param port: it contains the port that will be returned by the function. This buffer
1283  * must be properly allocated by the user.
1284  *
1285  * \param portlen: the length of the 'port' buffer.
1286  *
1287  * \param flags: a set of flags (the ones defined into the getnameinfo() standard socket function)
1288  * that determine if the resulting address must be in numeric / literal form, and so on.
1289  *
1290  * \param errbuf: a pointer to an user-allocated buffer that will contain the complete
1291  * error message. This buffer has to be at least 'errbuflen' in length.
1292  * It can be NULL; in this case the error cannot be printed.
1293  *
1294  * \param errbuflen: length of the buffer that will contains the error. The error message cannot be
1295  * larger than 'errbuflen - 1' because the last char is reserved for the string terminator.
1296  *
1297  * \return It returns '-1' if this function succeeds, '0' otherwise.
1298  * The address and port corresponding are returned back in the buffers 'address' and 'port'.
1299  * In any case, the returned strings are '0' terminated.
1300  *
1301  * \warning If the socket is using a connectionless protocol, the address may not be available
1302  * until I/O occurs on the socket.
1303  */
1304 int sock_getmyinfo(SOCKET sock, char *address, int addrlen, char *port, int portlen, int flags, char *errbuf, int errbuflen)
1305 {
1306 	struct sockaddr_storage mysockaddr;
1307 	socklen_t sockaddrlen;
1308 
1309 
1310 	sockaddrlen = sizeof(struct sockaddr_storage);
1311 
1312 	if (getsockname(sock, (struct sockaddr *) &mysockaddr, &sockaddrlen) == -1)
1313 	{
1314 		sock_geterror("getsockname(): ", errbuf, errbuflen);
1315 		return 0;
1316 	}
1317 
1318 	/* Returns the numeric address of the host that triggered the error */
1319 	return sock_getascii_addrport(&mysockaddr, address, addrlen, port, portlen, flags, errbuf, errbuflen);
1320 }
1321 
1322 /*
1323  * \brief It retrieves two strings containing the address and the port of a given 'sockaddr' variable.
1324  *
1325  * This function is basically an extended version of the inet_ntop(), which does not exist in
1326  * Winsock because the same result can be obtained by using the getnameinfo().
1327  * However, differently from inet_ntop(), this function is able to return also literal names
1328  * (e.g. 'localhost') dependently from the 'Flags' parameter.
1329  *
1330  * The function accepts a sockaddr_storage variable (which can be returned by several functions
1331  * like bind(), connect(), accept(), and more) and it transforms its content into a 'human'
1332  * form. So, for instance, it is able to translate an hex address (stored in binary form) into
1333  * a standard IPv6 address like "::1".
1334  *
1335  * The behavior of this function depends on the parameters we have in the 'Flags' variable, which
1336  * are the ones allowed in the standard getnameinfo() socket function.
1337  *
1338  * \param sockaddr: a 'sockaddr_in' or 'sockaddr_in6' structure containing the address that
1339  * need to be translated from network form into the presentation form. This structure must be
1340  * zero-ed prior using it, and the address family field must be filled with the proper value.
1341  * The user must cast any 'sockaddr_in' or 'sockaddr_in6' structures to 'sockaddr_storage' before
1342  * calling this function.
1343  *
1344  * \param address: it contains the address that will be returned by the function. This buffer
1345  * must be properly allocated by the user. The address can be either literal or numeric depending
1346  * on the value of 'Flags'.
1347  *
1348  * \param addrlen: the length of the 'address' buffer.
1349  *
1350  * \param port: it contains the port that will be returned by the function. This buffer
1351  * must be properly allocated by the user.
1352  *
1353  * \param portlen: the length of the 'port' buffer.
1354  *
1355  * \param flags: a set of flags (the ones defined into the getnameinfo() standard socket function)
1356  * that determine if the resulting address must be in numeric / literal form, and so on.
1357  *
1358  * \param errbuf: a pointer to an user-allocated buffer that will contain the complete
1359  * error message. This buffer has to be at least 'errbuflen' in length.
1360  * It can be NULL; in this case the error cannot be printed.
1361  *
1362  * \param errbuflen: length of the buffer that will contains the error. The error message cannot be
1363  * larger than 'errbuflen - 1' because the last char is reserved for the string terminator.
1364  *
1365  * \return It returns '-1' if this function succeeds, '0' otherwise.
1366  * The address and port corresponding to the given SockAddr are returned back in the buffers 'address'
1367  * and 'port'.
1368  * In any case, the returned strings are '0' terminated.
1369  */
1370 int sock_getascii_addrport(const struct sockaddr_storage *sockaddr, char *address, int addrlen, char *port, int portlen, int flags, char *errbuf, int errbuflen)
1371 {
1372 	socklen_t sockaddrlen;
1373 	int retval;					/* Variable that keeps the return value; */
1374 
1375 	retval = -1;
1376 
1377 #ifdef _WIN32
1378 	if (sockaddr->ss_family == AF_INET)
1379 		sockaddrlen = sizeof(struct sockaddr_in);
1380 	else
1381 		sockaddrlen = sizeof(struct sockaddr_in6);
1382 #else
1383 	sockaddrlen = sizeof(struct sockaddr_storage);
1384 #endif
1385 
1386 	if ((flags & NI_NUMERICHOST) == 0)	/* Check that we want literal names */
1387 	{
1388 		if ((sockaddr->ss_family == AF_INET6) &&
1389 			(memcmp(&((struct sockaddr_in6 *) sockaddr)->sin6_addr, "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", sizeof(struct in6_addr)) == 0))
1390 		{
1391 			if (address)
1392 				strlcpy(address, SOCKET_NAME_NULL_DAD, addrlen);
1393 			return retval;
1394 		}
1395 	}
1396 
1397 	if (getnameinfo((struct sockaddr *) sockaddr, sockaddrlen, address, addrlen, port, portlen, flags) != 0)
1398 	{
1399 		/* If the user wants to receive an error message */
1400 		if (errbuf)
1401 		{
1402 			sock_geterror("getnameinfo(): ", errbuf, errbuflen);
1403 			errbuf[errbuflen - 1] = 0;
1404 		}
1405 
1406 		if (address)
1407 		{
1408 			strlcpy(address, SOCKET_NO_NAME_AVAILABLE, addrlen);
1409 			address[addrlen - 1] = 0;
1410 		}
1411 
1412 		if (port)
1413 		{
1414 			strlcpy(port, SOCKET_NO_PORT_AVAILABLE, portlen);
1415 			port[portlen - 1] = 0;
1416 		}
1417 
1418 		retval = 0;
1419 	}
1420 
1421 	return retval;
1422 }
1423 
1424 /*
1425  * \brief It translates an address from the 'presentation' form into the 'network' form.
1426  *
1427  * This function basically replaces inet_pton(), which does not exist in Winsock because
1428  * the same result can be obtained by using the getaddrinfo().
1429  * An additional advantage is that 'Address' can be both a numeric address (e.g. '127.0.0.1',
1430  * like in inet_pton() ) and a literal name (e.g. 'localhost').
1431  *
1432  * This function does the reverse job of sock_getascii_addrport().
1433  *
1434  * \param address: a zero-terminated string which contains the name you have to
1435  * translate. The name can be either literal (e.g. 'localhost') or numeric (e.g. '::1').
1436  *
1437  * \param sockaddr: a user-allocated sockaddr_storage structure which will contains the
1438  * 'network' form of the requested address.
1439  *
1440  * \param addr_family: a constant which can assume the following values:
1441  * - 'AF_INET' if we want to ping an IPv4 host
1442  * - 'AF_INET6' if we want to ping an IPv6 host
1443  * - 'AF_UNSPEC' if we do not have preferences about the protocol used to ping the host
1444  *
1445  * \param errbuf: a pointer to an user-allocated buffer that will contain the complete
1446  * error message. This buffer has to be at least 'errbuflen' in length.
1447  * It can be NULL; in this case the error cannot be printed.
1448  *
1449  * \param errbuflen: length of the buffer that will contains the error. The error message cannot be
1450  * larger than 'errbuflen - 1' because the last char is reserved for the string terminator.
1451  *
1452  * \return '-1' if the translation succeeded, '-2' if there was some non critical error, '0'
1453  * otherwise. In case it fails, the content of the SockAddr variable remains unchanged.
1454  * A 'non critical error' can occur in case the 'Address' is a literal name, which can be mapped
1455  * to several network addresses (e.g. 'foo.bar.com' => '10.2.2.2' and '10.2.2.3'). In this case
1456  * the content of the SockAddr parameter will be the address corresponding to the first mapping.
1457  *
1458  * \warning The sockaddr_storage structure MUST be allocated by the user.
1459  */
1460 int sock_present2network(const char *address, struct sockaddr_storage *sockaddr, int addr_family, char *errbuf, int errbuflen)
1461 {
1462 	int retval;
1463 	struct addrinfo *addrinfo;
1464 	struct addrinfo hints;
1465 
1466 	memset(&hints, 0, sizeof(hints));
1467 
1468 	hints.ai_family = addr_family;
1469 
1470 	if ((retval = sock_initaddress(address, "22222" /* fake port */, &hints, &addrinfo, errbuf, errbuflen)) == -1)
1471 		return 0;
1472 
1473 	if (addrinfo->ai_family == PF_INET)
1474 		memcpy(sockaddr, addrinfo->ai_addr, sizeof(struct sockaddr_in));
1475 	else
1476 		memcpy(sockaddr, addrinfo->ai_addr, sizeof(struct sockaddr_in6));
1477 
1478 	if (addrinfo->ai_next != NULL)
1479 	{
1480 		freeaddrinfo(addrinfo);
1481 
1482 		if (errbuf)
1483 			pcap_snprintf(errbuf, errbuflen, "More than one socket requested; using the first one returned");
1484 		return -2;
1485 	}
1486 
1487 	freeaddrinfo(addrinfo);
1488 	return -1;
1489 }
1490