Main Page Modules Data Structures File List Data Fields Globals Related Pages

# sockutils.c File Reference

`#include "sockutils.h"`
`#include <string.h>`
`#include <errno.h>`
`#include <stdio.h>`

Go to the source code of this file.

## Defines
#define | WINSOCK_MAJOR_VERSION 2
#define | WINSOCK_MINOR_VERSION 2
#define | SHUT_WR SD_SEND
#define | snprintf _snprintf
#define | TEMP_BUF_SIZE 65536
## Functions
int | sock_ismcastaddr (const struct sockaddr *saddr)
| It checks if the sockaddr variable contains a multicast address.
void | sock_geterror (const char *caller, char *string, int size)
| It retrieves the error message after an error occurred in the socket interface.
int | sock_init (char *errbuf)
| It initializes sockets.
void | sock_cleanup ()
| It deallocates sockets.
int | sock_open (struct addrinfo *addrinfo, int server, int nconn, char *errbuf)
| It initializes a network connection both from the client and the server side.
int | sock_close (SOCKET sock, char *errbuf)
| Closes the present (TCP and UDP) socket connection.
int | sock_validaddr (const char *address, const char *port, struct addrinfo *hints, struct addrinfo **addrinfo, char *errbuf)
| Checks that the address, port and flags given are valids and it returns an 'addrinfo' stucture.
int | sock_send (SOCKET socket, const char *buffer, int size, char *errbuf)
| It sends the amount of data contained into 'buffer' on the given socket.
int | sock_bufferize (const char *buffer, int size, char *tempbuf, int *offset, int totsize, int checkonly, char *errbuf)
| It copies the amount of data contained into 'buffer' into 'tempbuf'. and it checks for buffer overflows.
int | sock_recv (SOCKET sock, char *buffer, int size, char *errbuf)
| It waits on a connected socket and it manages to receive exactly 'size' bytes.
int | sock_recv_dgram (SOCKET sock, char *buffer, int size, char *errbuf)
| It waits on a connected socket and it manages to receive one message.
int | sock_discard (SOCKET sock, int size, char *errbuf)
| It discards N bytes that are currently waiting to be read on the current socket.
int | sock_check_hostlist (char *hostlist, const char *sep, struct sockaddr_storage *from, char *errbuf)
| Checks that one host (identified by the sockaddr_storage structure) belongs to an 'allowed list'.
int | sock_cmpaddr (struct sockaddr_storage *first, struct sockaddr_storage *second)
| Compares two addresses contained into two sockaddr_storage structures.
## Variables
int | sockcount = 0
char | fakeerrbuf [SOCK_ERRBUF_SIZE+1]

## Detailed Description

The goal of this file it to provide a common set of primitives for socket manipulation. Although the socket interface defined in the RFC 2553 (and its updates) is excellent, several minor issues are still hidden when we want to operate on several operating systems.

These calls do not want to provide a better socket interface; vice versa, they want to provide a set of calls that is portable among several operating systems, hiding their differences.

Definition in file sockutils.c.

## Define Documentation

#define SHUT_WR SD_SEND

| The control code for shutdown() is different in Win32 Definition at line 63 of file sockutils.c.

#define snprintf _snprintf

| The snprintf is called _snprintf() in Win32 Definition at line 64 of file sockutils.c. Referenced by add_addr_to_iflist(), add_or_find_if(), daemon_AuthUserPwd(), daemon_checkauth(), daemon_startcapture(), daemon_thrdatamain(), daemon_unpackapplyfilter(), fileconf_read(), main(), main_active(), main_passive(), pcap_compile(), pcap_createsrcstr(), pcap_dump_open(), pcap_findalldevs_ex(), pcap_getnonblock(), pcap_list_datalinks(), pcap_open(), pcap_open_live(), pcap_open_offline(), pcap_opensource_remote(), pcap_parsesrcstr(), pcap_read(), pcap_remoteact_accept(), pcap_remoteact_close(), pcap_remoteact_list(), pcap_sendpacket(), pcap_sendqueue_transmit(), pcap_set_datalink(), pcap_setbuff(), pcap_setfilter(), pcap_setmintocopy(), pcap_setmode(), pcap_setnonblock(), pcap_startcapture_remote(), pcap_stats(), pcap_stats_ex(), pcap_strerror(), rpcap_checkmsg(), rpcap_checkver(), rpcap_deseraddr(), rpcap_remoteact_getsock(), rpcap_sendauth(), rpcap_stats_remote(), sf_next_packet(), sock_bufferize(), sock_check_hostlist(), sock_geterror(), sock_init(), sock_open(), sock_recv(), sock_validaddr(), and svc_geterr().

#define TEMP_BUF_SIZE 65536

#define WINSOCK_MAJOR_VERSION 2

| Ask for Winsock 2.2 Definition at line 56 of file sockutils.c.

#define WINSOCK_MINOR_VERSION 2

| Ask for Winsock 2.2 Definition at line 57 of file sockutils.c.

## Function Documentation

int sock_bufferize | ( | const char * | buffer,
|  | int | size,
|  | char * | tempbuf,
|  | int * | offset,
|  | int | totsize,
|  | int | checkonly,
|  | char * | errbuf
| ) |

  | 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. Parameters:
  buffer: | a char pointer to a user-allocated buffer that keeps the data that has to be copied.
  size: | number of bytes that have to be copied.
  tempbuf: | user-allocated buffer (of size 'totsize') in which data has to be copied.
  offset: | an index into 'tempbuf' which keeps the location of its first empty location.
  totsize: | total size of the buffer in which data is being copied.
  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.
  errbuf: | a pointer to a user-allocated buffer (of size SOCK_ERRBUF_SIZE) that will contain the error message (in case there is one).
Returns: '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. 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. Definition at line 524 of file sockutils.c. References offset, size, and snprintf. Referenced by daemon_findalldevs(), daemon_getstats(), daemon_getstatsnopcap(), daemon_opensource(), daemon_startcapture(), daemon_thrdatamain(), pcap_opensource_remote(), pcap_pack_bpffilter(), pcap_startcapture_remote(), pcap_updatefilter_remote(), rpcap_sendauth(), and rpcap_senderror().

int sock_check_hostlist | ( | char * | hostlist,
|  | const char * | sep,
|  | struct sockaddr_storage * | from,
|  | char * | errbuf
| ) |

  | 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. Parameters:
  hostlist: | a string that contains the list of the allowed host.
  sep: | a string that keeps the separators used between the hosts (for example the space character) in the host list.
  from: | a sockaddr_storage structure, as it is returned by the accept() call.
  errbuf: | a pointer to a user-allocated buffer (of size SOCK_ERRBUF_SIZE) that will contain the error message (in case there is one).
Returns: '0' if everything is fine, '-1' if some errors occurred. The error message is returned in the 'errbuf' variable. Definition at line 726 of file sockutils.c. References hostlist, snprintf, SOCK_ASSERT, sock_cmpaddr(), and sock_geterror(). Referenced by main_passive(), and pcap_remoteact_accept().

void sock_cleanup | ( |  | ) |

| 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. Returns: No error values. Definition at line 192 of file sockutils.c. References sockcount. Referenced by main_cleanup(), pcap_close_remote(), pcap_findalldevs_ex(), pcap_remoteact_cleanup(), and pcap_remoteact_close().

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

  | 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. Parameters:
  sock: | the socket identifier of the connection that has to be closed.
  errbuf: | a pointer to a user-allocated buffer (of size SOCK_ERRBUF_SIZE) that will contain the error message (in case there is one).
Returns: '0' if everything is fine, '-1' if some errors occurred. The error message is returned in the 'errbuf' variable. Definition at line 334 of file sockutils.c. References sock_geterror(). Referenced by daemon_endcapture(), daemon_serviceloop(), daemon_startcapture(), main_passive(), pcap_close_remote(), pcap_findalldevs_ex(), pcap_opensource_remote(), pcap_remoteact_accept(), pcap_remoteact_close(), and pcap_startcapture_remote().

int sock_cmpaddr | ( | struct sockaddr_storage * | first,
|  | struct sockaddr_storage * | second
| ) |

  | 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. Parameters:
  first: | a sockaddr_storage structure, (for example the one that is returned by an accept() call), containing the first address to compare.
  second: | a sockaddr_storage structure containing the second address to compare.
Returns: '0' if the addresses are equal, '-1' if they are different. Definition at line 823 of file sockutils.c. Referenced by pcap_remoteact_accept(), pcap_remoteact_close(), rpcap_remoteact_getsock(), and sock_check_hostlist().

int sock_discard | ( | SOCKET | sock,
|  | int | size,
|  | char * | errbuf
| ) |

  | 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 undestand (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. Parameters:
  sock: | the connected socket currently opened.
  size: | number of bytes that have to be discarded.
  errbuf: | a pointer to a user-allocated buffer (of size SOCK_ERRBUF_SIZE) that will contain the error message (in case there is one), due to a network problem.
Returns: '0' if everything is fine, '-1' if some errors occurred. The error message is returned in the 'errbuf' variable. Definition at line 672 of file sockutils.c. References size, SOCK_ASSERT, and sock_recv(). Referenced by daemon_checkauth(), daemon_opensource(), daemon_serviceloop(), daemon_startcapture(), daemon_updatefilter(), pcap_close_remote(), pcap_findalldevs_ex(), pcap_opensource_remote(), pcap_startcapture_remote(), pcap_updatefilter_remote(), rpcap_checkmsg(), rpcap_checkver(), rpcap_sendauth(), rpcap_stats_remote(), and rpcap_thrdatamain_stream().

void sock_geterror | ( | const char * | caller,
|  | char * | string,
|  | int | size
| ) |

  | 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. Parameters:
  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'.
  string: | a pointer to an user-allocated buffer that will contain the complete error message. This buffer has to be at least 'size' in length.
  size: | the size of the buffer in which the error message will be copied.
Returns: No return values. The error message is returned in the 'string' parameter. Definition at line 116 of file sockutils.c. References snprintf, and SOCK_ERRBUF_SIZE. Referenced by daemon_serviceloop(), daemon_startcapture(), main_passive(), pcap_remoteact_accept(), pcap_remoteact_list(), pcap_startcapture_remote(), rpcap_thrdatamain_dgram(), rpcap_thrdatamain_stream(), sock_check_hostlist(), sock_close(), sock_open(), sock_recv(), sock_recv_dgram(), and sock_send().

int sock_init | ( | char * | errbuf | ) |

  | 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. Parameters:
  errbuf: | a pointer to a user-allocated buffer (of size SOCK_ERRBUF_SIZE) that will contain the error message (in case there is one).
Returns: '0' if everything is fine, '-1' if some errors occurred. The error message is returned in the 'errbuf' variable. Definition at line 160 of file sockutils.c. References snprintf, and sockcount. Referenced by main(), pcap_findalldevs_ex(), pcap_opensource_remote(), and pcap_remoteact_accept().

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

  | 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(). In no cases this fucntion will authenticate the user on the remote host. This function has to be done in the rpcap_sendauth(). Parameters:
  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 sockvalidateaddr().
  server: | '1' if this is a server socket, '0' otherwise.
  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.
  errbuf: | a pointer to a user-allocated buffer (of size SOCK_ERRBUF_SIZE) that will contain the error message (in case there is one).
Returns: the socket that has been opened (that has to be used in the following sockets calls) if everything is fine, '-1' if some errors occurred. The error message is returned in the 'errbuf' variable. Definition at line 254 of file sockutils.c. References snprintf, sock_geterror(), and SOCKET. Referenced by daemon_startcapture(), main_active(), main_startup(), pcap_findalldevs_ex(), pcap_opensource_remote(), pcap_remoteact_accept(), and pcap_startcapture_remote().

int sock_recv | ( | SOCKET | sock,
|  | char * | buffer,
|  | int | size,
|  | char * | errbuf
| ) |

  | It waits on a connected socket and it manages to receive exactly 'size' bytes. 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'. In case the socket does not have enough data available, it cycles on the recv() util the requested data (of size 'size') is arrived. Parameters:
  sock: | the connected socket currently opened.
  buffer: | a char pointer to a user-allocated buffer in which data has to be stored
  size: | size of the allocated buffer. WARNING: this indicates the number of bytes that we are expecting to be read. This function (differenctly from the rpcap_recv_dgram() ) block until the number of bytes read is equal to 'size'.
  errbuf: | a pointer to a user-allocated buffer (of size SOCK_ERRBUF_SIZE) that will contain the error message (in case there is one), due to a network problem.
Returns: the number of bytes read if everything is fine, '-1' if some errors occurred. The error message is returned in the 'errbuf' variable. Definition at line 566 of file sockutils.c. References size, snprintf, SOCK_ASSERT, and sock_geterror(). Referenced by daemon_checkauth(), daemon_opensource(), daemon_serviceloop(), daemon_startcapture(), daemon_unpackapplyfilter(), pcap_close_remote(), pcap_findalldevs_ex(), pcap_opensource_remote(), pcap_startcapture_remote(), pcap_updatefilter_remote(), rpcap_checkmsg(), rpcap_sendauth(), rpcap_stats_remote(), rpcap_thrdatamain_stream(), and sock_discard().

int sock_recv_dgram | ( | SOCKET | sock,
|  | char * | buffer,
|  | int | size,
|  | char * | errbuf
| ) |

  | It waits on a connected socket and it manages to receive one message. There is a difference here between this function and the sock_recv(): the previous one will loop until 'size' bytes are read (i.e. until a message with the expected size has arrived); here just one recv() is done, and all what is waiting in the socket bufer is read all at once. This function is required for UDP sockets, in which the message has to be read all at once, otherwise it is discarded. Therefore we have to call this function with a large buffer, in order to be sure no data is lost. It follow that the number of bytes received is usually less than the size buffer: therefore we must exit anyway, even if the number of bytes read is less than the size of the buffer. Parameters:
  sock: | the connected socket currently opened.
  buffer: | a char pointer to a user-allocated buffer in which data has to be stored.
  size: | size of the allocated buffer. WARNING: this indicates the maximum number of bytes that we can read. This function (differenctly from the rpcap_recv_dgram() ) does not block if the number of bytes read is equal to 'size'.
  errbuf: | a pointer to a user-allocated buffer (of size SOCK_ERRBUF_SIZE) that will contain the error message (in case there is one), due to a network problem.
Returns: the number of bytes read if everything is fine, '-1' if some errors occurred. The error message is returned in the 'errbuf' variable. Definition at line 635 of file sockutils.c. References sock_geterror(). Referenced by rpcap_thrdatamain_dgram().

int sock_send | ( | SOCKET | socket,
|  | const char * | buffer,
|  | int | size,
|  | char * | errbuf
| ) |

  | 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. Parameters:
  socket: | the connected socket currently opened.
  buffer: | a char pointer to a user-allocated buffer in which data is contained.
  size: | number of bytes that have to be sent.
  errbuf: | a pointer to a user-allocated buffer (of size SOCK_ERRBUF_SIZE) that will contain the error message (in case there is one).
Returns: '0' if everything is fine, '-1' if some errors occurred. The error message is returned in the 'errbuf' variable. Definition at line 443 of file sockutils.c. References size, and sock_geterror(). Referenced by daemon_checkauth(), daemon_endcapture(), daemon_findalldevs(), daemon_getstats(), daemon_getstatsnopcap(), daemon_opensource(), daemon_startcapture(), daemon_thrdatamain(), daemon_updatefilter(), pcap_close_remote(), pcap_findalldevs_ex(), pcap_opensource_remote(), pcap_remoteact_close(), pcap_startcapture_remote(), pcap_updatefilter_remote(), rpcap_sendauth(), rpcap_senderror(), and rpcap_stats_remote().

int sock_validaddr | ( | const char * | address,
|  | const char * | port,
|  | struct addrinfo * | hints,
|  | struct addrinfo ** | addrinfo,
|  | char * | errbuf
| ) |

  | Checks that the address, port and flags given are valids and it returns an 'addrinfo' stucture. 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'. Parameters:
  address: | a pointer to a user-allocated buffer containing the network address to check. It could be both a numeric - literal address, and it can be NULL or "" (useful in case of a server socket which has to bind to all addresses).
  port: | a pointer to a user-allocated buffer containing the network port to use.
  hints: | an addrinfo variable (passed by reference) containing the flags needed to create the addrinfo structure appropriately.
  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.
  errbuf: | a pointer to a user-allocated buffer (of size SOCK_ERRBUF_SIZE) that will contain the error message (in case there is one).
Returns: '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. SOCKET: I should check all the accept() in order to bind to all addresses (in case addrinfo has more han one pointers, and all connect() to use all addresses (in the case the firs one fails) Definition at line 386 of file sockutils.c. References snprintf, and sock_ismcastaddr(). Referenced by daemon_startcapture(), main_active(), main_startup(), pcap_findalldevs_ex(), pcap_opensource_remote(), pcap_remoteact_accept(), and pcap_startcapture_remote().

## Variable Documentation

char fakeerrbuf[SOCK_ERRBUF_SIZE + 1]

| Definition at line 85 of file sockutils.c. Referenced by main_passive().

int sockcount = 0

| Variable that allows calling the WSAStartup() only one time Definition at line 58 of file sockutils.c. Referenced by sock_cleanup(), and sock_init().

documentation. Copyright (c) 2002-2003 Politecnico di Torino. All rights reserved.