| /* |
| * 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) |
| { |
| #ifdef _WIN32 |
| int retval; |
| char message[SOCK_ERRBUF_SIZE]; /* We're forcing "ANSI" */ |
| |
| if (errbuf == NULL) |
| return; |
| |
| retval = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS | |
| FORMAT_MESSAGE_MAX_WIDTH_MASK, |
| NULL, errcode, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), |
| message, sizeof(message) / sizeof(TCHAR), NULL); |
| |
| if (retval == 0) |
| { |
| if ((caller) && (*caller)) |
| pcap_snprintf(errbuf, errbuflen, "%sUnable to get the exact error message", caller); |
| else |
| pcap_snprintf(errbuf, errbuflen, "Unable to get the exact error message"); |
| } |
| else |
| { |
| if ((caller) && (*caller)) |
| pcap_snprintf(errbuf, errbuflen, "%s%s (code %d)", caller, message, errcode); |
| else |
| pcap_snprintf(errbuf, errbuflen, "%s (code %d)", message, errcode); |
| } |
| #else |
| char *message; |
| |
| if (errbuf == NULL) |
| return; |
| |
| message = strerror(errcode); |
| |
| if ((caller) && (*caller)) |
| pcap_snprintf(errbuf, errbuflen, "%s%s (code %d)", caller, message, errcode); |
| else |
| pcap_snprintf(errbuf, errbuflen, "%s (code %d)", message, errcode); |
| #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'. It may be NULL. |
| * |
| * \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 |
| if (errbuf == NULL) |
| return; |
| sock_fmterror(caller, GetLastError(), errbuf, errbuflen); |
| #else |
| if (errbuf == NULL) |
| return; |
| sock_fmterror(caller, errno, errbuf, errbuflen); |
| #endif |
| } |
| |
| /* |
| * \brief It initializes sockets. |
| * |
| * This function is pretty useless on UNIX, since socket initialization is not required. |
| * However it is required on Win32. In UNIX, this function appears to be completely empty. |
| * |
| * \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. |
| */ |
| #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++; |
| #else |
| int sock_init(char *errbuf _U_, int errbuflen _U_) |
| { |
| #endif |
| return 0; |
| } |
| |
| /* |
| * \brief It deallocates sockets. |
| * |
| * This function is pretty useless on UNIX, since socket deallocation is not required. |
| * However it is required on Win32. In UNIX, this function appears to be completely empty. |
| * |
| * \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) |
| { |
| #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(NULL, 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? connect() failed: %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; |
| } |
| |
| /* |
| * \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 the getaddrinfo() fails, you have to use gai_strerror(), instead of using the standard |
| * error routines (errno) in UNIX; Winsock suggests using the GetLastError() instead. |
| */ |
| if (errbuf) |
| { |
| #ifdef _WIN32 |
| sock_geterror("getaddrinfo(): ", errbuf, errbuflen); |
| #else |
| pcap_snprintf(errbuf, errbuflen, "getaddrinfo() %s", gai_strerror(retval)); |
| #endif |
| } |
| 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_recv", |
| 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. |
| * |
| * \param tempbuf: user-allocated buffer (of size 'totsize') in which data |
| * has to be copied. |
| * |
| * \param offset: an index into 'tempbuf' which keeps the location of its first |
| * empty location. |
| * |
| * \param totsize: total size of the buffer in which data is being copied. |
| * |
| * \param checkonly: '1' if we do not want to copy data into the buffer and we |
| * want just do a buffer ovreflow control, '0' if data has to be copied as well. |
| * |
| * \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. When the function returns, 'tempbuf' will |
| * have the new string appended, and 'offset' will keep the length of that buffer. |
| * In case of 'checkonly == 1', data is not copied, but 'offset' is updated in any case. |
| * |
| * \warning This function assumes that the buffer in which data has to be stored is |
| * large 'totbuf' bytes. |
| * |
| * \warning In case of 'checkonly', be carefully to call this function *before* copying |
| * the data into the buffer. Otherwise, the control about the buffer overflow is useless. |
| */ |
| int sock_bufferize(const char *buffer, int size, char *tempbuf, int *offset, int totsize, int checkonly, char *errbuf, int errbuflen) |
| { |
| if ((*offset + size) > totsize) |
| { |
| if (errbuf) |
| pcap_snprintf(errbuf, errbuflen, "Not enough space in the temporary send buffer."); |
| return -1; |
| } |
| |
| if (!checkonly) |
| memcpy(tempbuf + (*offset), buffer, size); |
| |
| (*offset) += size; |
| |
| return 0; |
| } |
| |
| /* |
| * \brief It waits on a connected socket and it manages to receive data. |
| * |
| * This function basically calls the recv() socket function and it checks that no |
| * error occurred. If that happens, it writes the error message into 'errbuf'. |
| * |
| * This function changes its behavior according to the 'receiveall' flag: if we |
| * want to receive exactly 'size' byte, it loops on the recv() until all the requested |
| * data is arrived. Otherwise, it returns the data currently available. |
| * |
| * In case the socket does not have enough data available, it cycles on the recv() |
| * until the requested data (of size 'size') is arrived. |
| * In this case, it blocks until the number of bytes read is equal to 'size'. |
| * |
| * \param sock: the connected socket currently opened. |
| * |
| * \param buffer: a char pointer to a user-allocated buffer in which data has to be stored |
| * |
| * \param size: size of the allocated buffer. WARNING: this indicates the number of bytes |
| * that we are expecting to be read. |
| * |
| * \param flags: |
| * |
| * SOCK_RECEIVALL_XXX: |
| * |
| * if SOCK_RECEIVEALL_NO, return as soon as some data is ready |
| * if SOCK_RECEIVALL_YES, wait until 'size' data has been |
| * received (in case the socket does not have enough data available). |
| * |
| * SOCK_EOF_XXX: |
| * |
| * if SOCK_EOF_ISNT_ERROR, if the first read returns 0, just return 0, |
| * and return an error on any subsequent read that returns 0; |
| * if SOCK_EOF_IS_ERROR, if any read returns 0, return an error. |
| * |
| * \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 number of bytes read if everything is fine, '-1' if some errors occurred. |
| * The error message is returned in the 'errbuf' variable. |
| */ |
| |
| int sock_recv(SOCKET sock, void *buffer, size_t size, int flags, |
| char *errbuf, int errbuflen) |
| { |
| char *bufp = buffer; |
| int remaining; |
| ssize_t nread; |
| |
| if (size == 0) |
| { |
| SOCK_DEBUG_MESSAGE("I have been requested to read zero bytes"); |
| return 0; |
| } |
| if (size > INT_MAX) |
| { |
| if (errbuf) |
| { |
| pcap_snprintf(errbuf, errbuflen, |
| "Can't read more than %u bytes with sock_recv", |
| INT_MAX); |
| } |
| return -1; |
| } |
| |
| bufp = (char *) buffer; |
| remaining = (int) size; |
| |
| /* |
| * We don't use MSG_WAITALL because it's not supported in |
| * Win32. |
| */ |
| for (;;) { |
| nread = recv(sock, bufp, remaining, 0); |
| |
| if (nread == -1) |
| { |
| #ifndef _WIN32 |
| if (errno == EINTR) |
| return -3; |
| #endif |
| sock_geterror("recv(): ", errbuf, errbuflen); |
| return -1; |
| } |
| |
| if (nread == 0) |
| { |
| if ((flags & SOCK_EOF_IS_ERROR) || |
| (remaining != (int) size)) |
| { |
| /* |
| * Either we've already read some data, |
| * or we're always supposed to return |
| * an error on EOF. |
| */ |
| if (errbuf) |
| { |
| pcap_snprintf(errbuf, errbuflen, |
| "The other host terminated the connection."); |
| } |
| return -1; |
| } |
| else |
| return 0; |
| } |
| |
| /* |
| * Do we want to read the amount requested, or just return |
| * what we got? |
| */ |
| if (!(flags & SOCK_RECEIVEALL_YES)) |
| { |
| /* |
| * Just return what we got. |
| */ |
| return (int) nread; |
| } |
| |
| bufp += nread; |
| remaining -= nread; |
| |
| if (remaining == 0) |
| return (int) size; |
| } |
| } |
| |
| /* |
| * Receives a datagram from a socket. |
| * |
| * Returns the size of the datagram on success or -1 on error. |
| */ |
| int sock_recv_dgram(SOCKET sock, void *buffer, size_t size, |
| char *errbuf, int errbuflen) |
| { |
| ssize_t nread; |
| #ifndef _WIN32 |
| struct msghdr message; |
| struct iovec iov; |
| #endif |
| |
| if (size == 0) |
| { |
| SOCK_DEBUG_MESSAGE("I have been requested to read zero bytes"); |
| return 0; |
| } |
| if (size > INT_MAX) |
| { |
| if (errbuf) |
| { |
| pcap_snprintf(errbuf, errbuflen, |
| "Can't read more than %u bytes with sock_recv_dgram", |
| INT_MAX); |
| } |
| return -1; |
| } |
| |
| /* |
| * This should be a datagram socket, so we should get the |
| * entire datagram in one recv() or recvmsg() call, and |
| * don't need to loop. |
| */ |
| #ifdef _WIN32 |
| nread = recv(sock, buffer, size, 0); |
| if (nread == SOCKET_ERROR) |
| { |
| /* |
| * To quote the MSDN documentation for recv(), |
| * "If the datagram or message is larger than |
| * the buffer specified, the buffer is filled |
| * with the first part of the datagram, and recv |
| * generates the error WSAEMSGSIZE. For unreliable |
| * protocols (for example, UDP) the excess data is |
| * lost..." |
| * |
| * So if the message is bigger than the buffer |
| * supplied to us, the excess data is discarded, |
| * and we'll report an error. |
| */ |
| sock_geterror("recv(): ", errbuf, errbuflen); |
| return -1; |
| } |
| #else /* _WIN32 */ |
| /* |
| * The Single UNIX Specification says that a recv() on |
| * a socket for a message-oriented protocol will discard |
| * the excess data. It does *not* indicate that the |
| * receive will fail with, for example, EMSGSIZE. |
| * |
| * Therefore, we use recvmsg(), which appears to be |
| * the only way to get a "message truncated" indication |
| * when receiving a message for a message-oriented |
| * protocol. |
| */ |
| message.msg_name = NULL; /* we don't care who it's from */ |
| message.msg_namelen = 0; |
| iov.iov_base = buffer; |
| iov.iov_len = size; |
| message.msg_iov = &iov; |
| message.msg_iovlen = 1; |
| #ifdef HAVE_STRUCT_MSGHDR_MSG_CONTROL |
| message.msg_control = NULL; /* we don't care about control information */ |
| message.msg_controllen = 0; |
| #endif |
| #ifdef HAVE_STRUCT_MSGHDR_MSG_FLAGS |
| message.msg_flags = 0; |
| #endif |
| nread = recvmsg(sock, &message, 0); |
| if (nread == -1) |
| { |
| if (errno == EINTR) |
| return -3; |
| sock_geterror("recv(): ", errbuf, errbuflen); |
| return -1; |
| } |
| #ifdef HAVE_STRUCT_MSGHDR_MSG_FLAGS |
| /* |
| * XXX - Solaris supports this, but only if you ask for the |
| * X/Open version of recvmsg(); should we use that, or will |
| * that cause other problems? |
| */ |
| if (message.msg_flags & MSG_TRUNC) |
| { |
| /* |
| * Message was bigger than the specified buffer size. |
| * |
| * Report this as an error, as the Microsoft documentation |
| * implies we'd do in a similar case on Windows. |
| */ |
| pcap_snprintf(errbuf, errbuflen, "recv(): Message too long"); |
| return -1; |
| } |
| #endif /* HAVE_STRUCT_MSGHDR_MSG_FLAGS */ |
| #endif /* _WIN32 */ |
| |
| /* |
| * The size we're reading fits in an int, so the return value |
| * will fit in an int. |
| */ |
| return (int)nread; |
| } |
| |
| /* |
| * \brief It discards N bytes that are currently waiting to be read on the current socket. |
| * |
| * This function is useful in case we receive a message we cannot understand (e.g. |
| * wrong version number when receiving a network packet), so that we have to discard all |
| * data before reading a new message. |
| * |
| * This function will read 'size' bytes from the socket and discard them. |
| * It defines an internal buffer in which data will be copied; however, in case |
| * this buffer is not large enough, it will cycle in order to read everything as well. |
| * |
| * \param sock: the connected socket currently opened. |
| * |
| * \param size: number of bytes that have to be discarded. |
| * |
| * \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_discard(SOCKET sock, int size, char *errbuf, int errbuflen) |
| { |
| #define TEMP_BUF_SIZE 32768 |
| |
| char buffer[TEMP_BUF_SIZE]; /* network buffer, to be used when the message is discarded */ |
| |
| /* |
| * A static allocation avoids the need of a 'malloc()' each time we want to discard a message |
| * Our feeling is that a buffer if 32KB is enough for most of the application; |
| * in case this is not enough, the "while" loop discards the message by calling the |
| * sockrecv() several times. |
| * We do not want to create a bigger variable because this causes the program to exit on |
| * some platforms (e.g. BSD) |
| */ |
| while (size > TEMP_BUF_SIZE) |
| { |
| if (sock_recv(sock, buffer, TEMP_BUF_SIZE, SOCK_RECEIVEALL_YES, errbuf, errbuflen) == -1) |
| return -1; |
| |
| size -= TEMP_BUF_SIZE; |
| } |
| |
| /* |
| * If there is still data to be discarded |
| * In this case, the data can fit into the temporary buffer |
| */ |
| if (size) |
| { |
| if (sock_recv(sock, buffer, size, SOCK_RECEIVEALL_YES, errbuf, errbuflen) == -1) |
| return -1; |
| } |
| |
| SOCK_DEBUG_MESSAGE("I'm currently discarding data\n"); |
| |
| return 0; |
| } |
| |
| /* |
| * \brief Checks that one host (identified by the sockaddr_storage structure) belongs to an 'allowed list'. |
| * |
| * This function is useful after an accept() call in order to check if the connecting |
| * host is allowed to connect to me. To do that, we have a buffer that keeps the list of the |
| * allowed host; this function checks the sockaddr_storage structure of the connecting host |
| * against this host list, and it returns '0' is the host is included in this list. |
| * |
| * \param hostlist: pointer to a string that contains the list of the allowed host. |
| * |
| * \param sep: a string that keeps the separators used between the hosts (for example the |
| * space character) in the host list. |
| * |
| * \param from: a sockaddr_storage structure, as it is returned by the accept() call. |
| * |
| * \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 It returns: |
| * - '1' if the host list is empty |
| * - '0' if the host belongs to the host list (and therefore it is allowed to connect) |
| * - '-1' in case the host does not belong to the host list (and therefore it is not allowed to connect |
| * - '-2' in case or error. The error message is returned in the 'errbuf' variable. |
| */ |
| int sock_check_hostlist(char *hostlist, const char *sep, struct sockaddr_storage *from, char *errbuf, int errbuflen) |
| { |
| /* checks if the connecting host is among the ones allowed */ |
| if ((hostlist) && (hostlist[0])) |
| { |
| char *token; /* temp, needed to separate items into the hostlist */ |
| struct addrinfo *addrinfo, *ai_next; |
| char *temphostlist; |
| char *lasts; |
| |
| /* |
| * The problem is that strtok modifies the original variable by putting '0' at the end of each token |
| * So, we have to create a new temporary string in which the original content is kept |
| */ |
| temphostlist = strdup(hostlist); |
| if (temphostlist == NULL) |
| { |
| sock_geterror("sock_check_hostlist(), malloc() failed", errbuf, errbuflen); |
| return -2; |
| } |
| |
| token = pcap_strtok_r(temphostlist, sep, &lasts); |
| |
| /* it avoids a warning in the compilation ('addrinfo used but not initialized') */ |
| addrinfo = NULL; |
| |
| while (token != NULL) |
| { |
| struct addrinfo hints; |
| int retval; |
| |
| addrinfo = NULL; |
| memset(&hints, 0, sizeof(struct addrinfo)); |
| hints.ai_family = PF_UNSPEC; |
| hints.ai_socktype = SOCK_STREAM; |
| |
| retval = getaddrinfo(token, "0", &hints, &addrinfo); |
| if (retval != 0) |
| { |
| if (errbuf) |
| pcap_snprintf(errbuf, errbuflen, "getaddrinfo() %s", gai_strerror(retval)); |
| |
| SOCK_DEBUG_MESSAGE(errbuf); |
| |
| /* Get next token */ |
| token = pcap_strtok_r(NULL, sep, &lasts); |
| continue; |
| } |
| |
| /* ai_next is required to preserve the content of addrinfo, in order to deallocate it properly */ |
| ai_next = addrinfo; |
| while (ai_next) |
| { |
| if (sock_cmpaddr(from, (struct sockaddr_storage *) ai_next->ai_addr) == 0) |
| { |
| free(temphostlist); |
| freeaddrinfo(addrinfo); |
| return 0; |
| } |
| |
| /* |
| * If we are here, it means that the current address does not matches |
| * Let's try with the next one in the header chain |
| */ |
| ai_next = ai_next->ai_next; |
| } |
| |
| freeaddrinfo(addrinfo); |
| addrinfo = NULL; |
| |
| /* Get next token */ |
| token = pcap_strtok_r(NULL, sep, &lasts); |
| } |
| |
| if (addrinfo) |
| { |
| freeaddrinfo(addrinfo); |
| addrinfo = NULL; |
| } |
| |
| if (errbuf) |
| pcap_snprintf(errbuf, errbuflen, "The host is not in the allowed host list. Connection refused."); |
| |
| free(temphostlist); |
| return -1; |
| } |
| |
| /* No hostlist, so we have to return 'empty list' */ |
| return 1; |
| } |
| |
| /* |
| * \brief Compares two addresses contained into two sockaddr_storage structures. |
| * |
| * This function is useful to compare two addresses, given their internal representation, |
| * i.e. an sockaddr_storage structure. |
| * |
| * The two structures do not need to be sockaddr_storage; you can have both 'sockaddr_in' and |
| * sockaddr_in6, properly acsted in order to be compliant to the function interface. |
| * |
| * This function will return '0' if the two addresses matches, '-1' if not. |
| * |
| * \param first: a sockaddr_storage structure, (for example the one that is returned by an |
| * accept() call), containing the first address to compare. |
| * |
| * \param second: a sockaddr_storage structure containing the second address to compare. |
| * |
| * \return '0' if the addresses are equal, '-1' if they are different. |
| */ |
| int sock_cmpaddr(struct sockaddr_storage *first, struct sockaddr_storage *second) |
| { |
| if (first->ss_family == second->ss_family) |
| { |
| if (first->ss_family == AF_INET) |
| { |
| if (memcmp(&(((struct sockaddr_in *) first)->sin_addr), |
| &(((struct sockaddr_in *) second)->sin_addr), |
| sizeof(struct in_addr)) == 0) |
| return 0; |
| } |
| else /* address family is AF_INET6 */ |
| { |
| if (memcmp(&(((struct sockaddr_in6 *) first)->sin6_addr), |
| &(((struct sockaddr_in6 *) second)->sin6_addr), |
| sizeof(struct in6_addr)) == 0) |
| return 0; |
| } |
| } |
| |
| return -1; |
| } |
| |
| /* |
| * \brief It gets the address/port the system picked for this socket (on connected sockets). |
| * |
| * It is used to return the address and port the server picked for our socket on the local machine. |
| * It works only on: |
| * - connected sockets |
| * - server sockets |
| * |
| * On unconnected client sockets it does not work because the system dynamically chooses a port |
| * only when the socket calls a send() call. |
| * |
| * \param sock: the connected socket currently opened. |
| * |
| * \param address: it contains the address that will be returned by the function. This buffer |
| * must be properly allocated by the user. The address can be either literal or numeric depending |
| * on the value of 'Flags'. |
| * |
| * \param addrlen: the length of the 'address' buffer. |
| * |
| * \param port: it contains the port that will be returned by the function. This buffer |
| * must be properly allocated by the user. |
| * |
| * \param portlen: the length of the 'port' buffer. |
| * |
| * \param flags: a set of flags (the ones defined into the getnameinfo() standard socket function) |
| * that determine if the resulting address must be in numeric / literal form, and so on. |
| * |
| * \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 It returns '-1' if this function succeeds, '0' otherwise. |
| * The address and port corresponding are returned back in the buffers 'address' and 'port'. |
| * In any case, the returned strings are '0' terminated. |
| * |
| * \warning If the socket is using a connectionless protocol, the address may not be available |
| * until I/O occurs on the socket. |
| */ |
| int sock_getmyinfo(SOCKET sock, char *address, int addrlen, char *port, int portlen, int flags, char *errbuf, int errbuflen) |
| { |
| struct sockaddr_storage mysockaddr; |
| socklen_t sockaddrlen; |
| |
| |
| sockaddrlen = sizeof(struct sockaddr_storage); |
| |
| if (getsockname(sock, (struct sockaddr *) &mysockaddr, &sockaddrlen) == -1) |
| { |
| sock_geterror("getsockname(): ", errbuf, errbuflen); |
| return 0; |
| } |
| |
| /* Returns the numeric address of the host that triggered the error */ |
| return sock_getascii_addrport(&mysockaddr, address, addrlen, port, portlen, flags, errbuf, errbuflen); |
| } |
| |
| /* |
| * \brief It retrieves two strings containing the address and the port of a given 'sockaddr' variable. |
| * |
| * This function is basically an extended version of the inet_ntop(), which does not exist in |
| * Winsock because the same result can be obtained by using the getnameinfo(). |
| * However, differently from inet_ntop(), this function is able to return also literal names |
| * (e.g. 'localhost') dependently from the 'Flags' parameter. |
| * |
| * The function accepts a sockaddr_storage variable (which can be returned by several functions |
| * like bind(), connect(), accept(), and more) and it transforms its content into a 'human' |
| * form. So, for instance, it is able to translate an hex address (stored in binary form) into |
| * a standard IPv6 address like "::1". |
| * |
| * The behavior of this function depends on the parameters we have in the 'Flags' variable, which |
| * are the ones allowed in the standard getnameinfo() socket function. |
| * |
| * \param sockaddr: a 'sockaddr_in' or 'sockaddr_in6' structure containing the address that |
| * need to be translated from network form into the presentation form. This structure must be |
| * zero-ed prior using it, and the address family field must be filled with the proper value. |
| * The user must cast any 'sockaddr_in' or 'sockaddr_in6' structures to 'sockaddr_storage' before |
| * calling this function. |
| * |
| * \param address: it contains the address that will be returned by the function. This buffer |
| * must be properly allocated by the user. The address can be either literal or numeric depending |
| * on the value of 'Flags'. |
| * |
| * \param addrlen: the length of the 'address' buffer. |
| * |
| * \param port: it contains the port that will be returned by the function. This buffer |
| * must be properly allocated by the user. |
| * |
| * \param portlen: the length of the 'port' buffer. |
| * |
| * \param flags: a set of flags (the ones defined into the getnameinfo() standard socket function) |
| * that determine if the resulting address must be in numeric / literal form, and so on. |
| * |
| * \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 It returns '-1' if this function succeeds, '0' otherwise. |
| * The address and port corresponding to the given SockAddr are returned back in the buffers 'address' |
| * and 'port'. |
| * In any case, the returned strings are '0' terminated. |
| */ |
| int sock_getascii_addrport(const struct sockaddr_storage *sockaddr, char *address, int addrlen, char *port, int portlen, int flags, char *errbuf, int errbuflen) |
| { |
| socklen_t sockaddrlen; |
| int retval; /* Variable that keeps the return value; */ |
| |
| retval = -1; |
| |
| #ifdef _WIN32 |
| if (sockaddr->ss_family == AF_INET) |
| sockaddrlen = sizeof(struct sockaddr_in); |
| else |
| sockaddrlen = sizeof(struct sockaddr_in6); |
| #else |
| sockaddrlen = sizeof(struct sockaddr_storage); |
| #endif |
| |
| if ((flags & NI_NUMERICHOST) == 0) /* Check that we want literal names */ |
| { |
| if ((sockaddr->ss_family == AF_INET6) && |
| (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)) |
| { |
| if (address) |
| strlcpy(address, SOCKET_NAME_NULL_DAD, addrlen); |
| return retval; |
| } |
| } |
| |
| if (getnameinfo((struct sockaddr *) sockaddr, sockaddrlen, address, addrlen, port, portlen, flags) != 0) |
| { |
| /* If the user wants to receive an error message */ |
| if (errbuf) |
| { |
| sock_geterror("getnameinfo(): ", errbuf, errbuflen); |
| errbuf[errbuflen - 1] = 0; |
| } |
| |
| if (address) |
| { |
| strlcpy(address, SOCKET_NO_NAME_AVAILABLE, addrlen); |
| address[addrlen - 1] = 0; |
| } |
| |
| if (port) |
| { |
| strlcpy(port, SOCKET_NO_PORT_AVAILABLE, portlen); |
| port[portlen - 1] = 0; |
| } |
| |
| retval = 0; |
| } |
| |
| return retval; |
| } |
| |
| /* |
| * \brief It translates an address from the 'presentation' form into the 'network' form. |
| * |
| * This function basically replaces inet_pton(), which does not exist in Winsock because |
| * the same result can be obtained by using the getaddrinfo(). |
| * An additional advantage is that 'Address' can be both a numeric address (e.g. '127.0.0.1', |
| * like in inet_pton() ) and a literal name (e.g. 'localhost'). |
| * |
| * This function does the reverse job of sock_getascii_addrport(). |
| * |
| * \param address: a zero-terminated string which contains the name you have to |
| * translate. The name can be either literal (e.g. 'localhost') or numeric (e.g. '::1'). |
| * |
| * \param sockaddr: a user-allocated sockaddr_storage structure which will contains the |
| * 'network' form of the requested address. |
| * |
| * \param addr_family: a constant which can assume the following values: |
| * - 'AF_INET' if we want to ping an IPv4 host |
| * - 'AF_INET6' if we want to ping an IPv6 host |
| * - 'AF_UNSPEC' if we do not have preferences about the protocol used to ping the host |
| * |
| * \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 '-1' if the translation succeeded, '-2' if there was some non critical error, '0' |
| * otherwise. In case it fails, the content of the SockAddr variable remains unchanged. |
| * A 'non critical error' can occur in case the 'Address' is a literal name, which can be mapped |
| * to several network addresses (e.g. 'foo.bar.com' => '10.2.2.2' and '10.2.2.3'). In this case |
| * the content of the SockAddr parameter will be the address corresponding to the first mapping. |
| * |
| * \warning The sockaddr_storage structure MUST be allocated by the user. |
| */ |
| int sock_present2network(const char *address, struct sockaddr_storage *sockaddr, int addr_family, char *errbuf, int errbuflen) |
| { |
| int retval; |
| struct addrinfo *addrinfo; |
| struct addrinfo hints; |
| |
| memset(&hints, 0, sizeof(hints)); |
| |
| hints.ai_family = addr_family; |
| |
| if ((retval = sock_initaddress(address, "22222" /* fake port */, &hints, &addrinfo, errbuf, errbuflen)) == -1) |
| return 0; |
| |
| if (addrinfo->ai_family == PF_INET) |
| memcpy(sockaddr, addrinfo->ai_addr, sizeof(struct sockaddr_in)); |
| else |
| memcpy(sockaddr, addrinfo->ai_addr, sizeof(struct sockaddr_in6)); |
| |
| if (addrinfo->ai_next != NULL) |
| { |
| freeaddrinfo(addrinfo); |
| |
| if (errbuf) |
| pcap_snprintf(errbuf, errbuflen, "More than one socket requested; using the first one returned"); |
| return -2; |
| } |
| |
| freeaddrinfo(addrinfo); |
| return -1; |
| } |