| /** |
| * @file snmpSocketBaseDomain.c |
| * |
| * @brief Socket support functions. |
| */ |
| |
| #include <net-snmp/net-snmp-config.h> |
| |
| #include <net-snmp/types.h> |
| #include <net-snmp/library/snmpSocketBaseDomain.h> |
| |
| #include <stddef.h> |
| #include <stdio.h> |
| #if HAVE_UNISTD_H |
| #include <unistd.h> |
| #endif |
| #include <sys/types.h> |
| #include <ctype.h> |
| #if HAVE_STDLIB_H |
| #include <stdlib.h> |
| #endif |
| #if HAVE_STRING_H |
| #include <string.h> |
| #else |
| #include <strings.h> |
| #endif |
| #if HAVE_FCNTL_H |
| #include <fcntl.h> |
| #endif |
| #if HAVE_SYS_SOCKET_H |
| #include <sys/socket.h> |
| #endif |
| #include <errno.h> |
| |
| #include <net-snmp/types.h> |
| #include <net-snmp/library/snmp_debug.h> |
| #include <net-snmp/library/tools.h> |
| #include <net-snmp/library/default_store.h> |
| #include <net-snmp/library/system.h> |
| #include <net-snmp/library/snmp_assert.h> |
| |
| /* all sockets pretty much close the same way */ |
| int netsnmp_socketbase_close(netsnmp_transport *t) { |
| int rc = -1; |
| if (t->sock >= 0) { |
| #ifndef HAVE_CLOSESOCKET |
| rc = close(t->sock); |
| #else |
| rc = closesocket(t->sock); |
| #endif |
| t->sock = -1; |
| } |
| return rc; |
| } |
| |
| /* |
| * find largest possible buffer between current size and specified size. |
| * |
| * Try to maximize the current buffer of type "optname" |
| * to the maximum allowable size by the OS (as close to |
| * size as possible) |
| */ |
| static int |
| _sock_buffer_maximize(int s, int optname, const char *buftype, int size) |
| { |
| int curbuf = 0; |
| socklen_t curbuflen = sizeof(int); |
| int lo, mid, hi; |
| |
| /* |
| * First we need to determine our current buffer |
| */ |
| if ((getsockopt(s, SOL_SOCKET, optname, (void *) &curbuf, |
| &curbuflen) == 0) |
| && (curbuflen == sizeof(int))) { |
| |
| DEBUGMSGTL(("verbose:socket:buffer:max", "Current %s is %d\n", |
| buftype, curbuf)); |
| |
| /* |
| * Let's not be stupid ... if we were asked for less than what we |
| * already have, then forget about it |
| */ |
| if (size <= curbuf) { |
| DEBUGMSGTL(("verbose:socket:buffer:max", |
| "Requested %s <= current buffer\n", buftype)); |
| return curbuf; |
| } |
| |
| /* |
| * Do a binary search the optimal buffer within 1k of the point of |
| * failure. This is rather bruteforce, but simple |
| */ |
| hi = size; |
| lo = curbuf; |
| |
| while (hi - lo > 1024) { |
| mid = (lo + hi) / 2; |
| if (setsockopt(s, SOL_SOCKET, optname, (void *) &mid, |
| sizeof(int)) == 0) { |
| lo = mid; /* Success: search between mid and hi */ |
| } else { |
| hi = mid; /* Failed: search between lo and mid */ |
| } |
| } |
| |
| /* |
| * Now print if this optimization helped or not |
| */ |
| if (getsockopt(s,SOL_SOCKET, optname, (void *) &curbuf, |
| &curbuflen) == 0) { |
| DEBUGMSGTL(("socket:buffer:max", |
| "Maximized %s: %d\n",buftype, curbuf)); |
| } |
| } else { |
| /* |
| * There is really not a lot we can do anymore. |
| * If the OS doesn't give us the current buffer, then what's the |
| * point in trying to make it better |
| */ |
| DEBUGMSGTL(("socket:buffer:max", "Get %s failed ... giving up!\n", |
| buftype)); |
| curbuf = -1; |
| } |
| |
| return curbuf; |
| } |
| |
| |
| static const char * |
| _sock_buf_type_get(int optname, int local) |
| { |
| if (optname == SO_SNDBUF) { |
| if (local) |
| return "server send buffer"; |
| else |
| return "client send buffer"; |
| } else if (optname == SO_RCVBUF) { |
| if (local) |
| return "server receive buffer"; |
| else |
| return "client receive buffer"; |
| } |
| |
| return "unknown buffer"; |
| } |
| |
| /* |
| * |
| * Get the requested buffersize, based on |
| * - sockettype : client (local = 0) or server (local = 1) |
| * - buffertype : send (optname = SO_SNDBUF) or recv (SO_RCVBUF) |
| * |
| * In case a compile time buffer was specified, then use that one |
| * if there was no runtime configuration override |
| */ |
| static int |
| _sock_buffer_size_get(int optname, int local, const char **buftype) |
| { |
| int size; |
| |
| if (NULL != buftype) |
| *buftype = _sock_buf_type_get(optname, local); |
| |
| if (optname == SO_SNDBUF) { |
| if (local) { |
| size = netsnmp_ds_get_int(NETSNMP_DS_LIBRARY_ID, |
| NETSNMP_DS_LIB_SERVERSENDBUF); |
| #ifdef NETSNMP_DEFAULT_SERVER_SEND_BUF |
| if (size <= 0) |
| size = NETSNMP_DEFAULT_SERVER_SEND_BUF; |
| #endif |
| } else { |
| size = netsnmp_ds_get_int(NETSNMP_DS_LIBRARY_ID, |
| NETSNMP_DS_LIB_CLIENTSENDBUF); |
| #ifdef NETSNMP_DEFAULT_CLIENT_SEND_BUF |
| if (size <= 0) |
| size = NETSNMP_DEFAULT_CLIENT_SEND_BUF; |
| #endif |
| } |
| } else if (optname == SO_RCVBUF) { |
| if (local) { |
| size = netsnmp_ds_get_int(NETSNMP_DS_LIBRARY_ID, |
| NETSNMP_DS_LIB_SERVERRECVBUF); |
| #ifdef NETSNMP_DEFAULT_SERVER_RECV_BUF |
| if (size <= 0) |
| size = NETSNMP_DEFAULT_SERVER_RECV_BUF; |
| #endif |
| } else { |
| size = netsnmp_ds_get_int(NETSNMP_DS_LIBRARY_ID, |
| NETSNMP_DS_LIB_CLIENTRECVBUF); |
| #ifdef NETSNMP_DEFAULT_CLIENT_RECV_BUF |
| if (size <= 0) |
| size = NETSNMP_DEFAULT_CLIENT_RECV_BUF; |
| #endif |
| } |
| } else { |
| size = 0; |
| } |
| |
| DEBUGMSGTL(("socket:buffer", "Requested %s is %d\n", |
| (buftype) ? *buftype : "unknown buffer", size)); |
| |
| return(size); |
| } |
| |
| /* |
| * set socket buffer size |
| * |
| * @param ss : socket |
| * @param optname: SO_SNDBUF or SO_RCVBUF |
| * @param local : 1 for server, 0 for client |
| * @param reqbuf : requested size, or 0 for default |
| * |
| * @retval -1 : error |
| * @retval >0 : new buffer size |
| */ |
| int |
| netsnmp_sock_buffer_set(int s, int optname, int local, int size) |
| { |
| #if ! defined(SO_SNDBUF) && ! defined(SO_RCVBUF) |
| DEBUGMSGTL(("socket:buffer", "Changing socket buffer is not supported\n")); |
| return -1; |
| #else |
| const char *buftype; |
| int curbuf = 0; |
| socklen_t curbuflen = sizeof(int); |
| |
| # ifndef SO_SNDBUF |
| if (SO_SNDBUF == optname) { |
| DEBUGMSGTL(("socket:buffer", |
| "Changing socket send buffer is not supported\n")); |
| return -1; |
| } |
| # endif /*SO_SNDBUF */ |
| # ifndef SO_RCVBUF |
| if (SO_RCVBUF == optname) { |
| DEBUGMSGTL(("socket:buffer", |
| "Changing socket receive buffer is not supported\n")); |
| return -1; |
| } |
| # endif /*SO_RCVBUF */ |
| |
| /* |
| * What is the requested buffer size ? |
| */ |
| if (0 == size) |
| size = _sock_buffer_size_get(optname, local, &buftype); |
| else { |
| buftype = _sock_buf_type_get(optname, local); |
| DEBUGMSGT(("verbose:socket:buffer", "Requested %s is %d\n", |
| buftype, size)); |
| } |
| |
| if ((getsockopt(s, SOL_SOCKET, optname, (void *) &curbuf, |
| &curbuflen) == 0) |
| && (curbuflen == sizeof(int))) { |
| |
| DEBUGMSGT(("verbose:socket:buffer", "Original %s is %d\n", |
| buftype, curbuf)); |
| if (curbuf >= size) { |
| DEBUGMSGT(("verbose:socket:buffer", |
| "New %s size is smaller than original!\n", buftype)); |
| } |
| } |
| |
| /* |
| * If the buffersize was not specified or it was a negative value |
| * then don't change the OS buffers at all |
| */ |
| if (size <= 0) { |
| DEBUGMSGT(("socket:buffer", |
| "%s not valid or not specified; using OS default(%d)\n", |
| buftype,curbuf)); |
| return curbuf; |
| } |
| |
| /* |
| * Try to set the requested send buffer |
| */ |
| if (setsockopt(s, SOL_SOCKET, optname, (void *) &size, sizeof(int)) == 0) { |
| /* |
| * Because some platforms lie about the actual buffer that has been |
| * set (Linux will always say it worked ...), we print some |
| * diagnostic output for debugging |
| */ |
| DEBUGIF("socket:buffer") { |
| DEBUGMSGT(("socket:buffer", "Set %s to %d\n", |
| buftype, size)); |
| if ((getsockopt(s, SOL_SOCKET, optname, (void *) &curbuf, |
| &curbuflen) == 0) |
| && (curbuflen == sizeof(int))) { |
| |
| DEBUGMSGT(("verbose:socket:buffer", |
| "Now %s is %d\n", buftype, curbuf)); |
| } |
| } |
| /* |
| * If the new buffer is smaller than the size we requested, we will |
| * try to increment the new buffer with 1k increments |
| * (this will sometime allow us to reach a more optimal buffer.) |
| * For example : On Solaris, if the max OS buffer is 100k and you |
| * request 110k, you end up with the default 8k :-( |
| */ |
| if (curbuf < size) { |
| curbuf = _sock_buffer_maximize(s, optname, buftype, size); |
| if(-1 != curbuf) |
| size = curbuf; |
| } |
| |
| } else { |
| /* |
| * Obviously changing the buffer failed, most like like because we |
| * requested a buffer greater than the OS limit. |
| * Therefore we need to search for an optimal buffer that is close |
| * enough to the point of failure. |
| * This will allow us to reach a more optimal buffer. |
| * For example : On Solaris, if the max OS buffer is 100k and you |
| * request 110k, you end up with the default 8k :-( |
| * After this quick seach we would get 1k close to 100k (the max) |
| */ |
| DEBUGMSGTL(("socket:buffer", "couldn't set %s to %d\n", |
| buftype, size)); |
| |
| curbuf = _sock_buffer_maximize(s, optname, buftype, size); |
| if(-1 != curbuf) |
| size = curbuf; |
| } |
| |
| return size; |
| #endif |
| } |
| |
| |
| /** |
| * Sets the mode of a socket for all subsequent I/O operations. |
| * |
| * @param[in] sock Socket descriptor (Unix) or socket handle (Windows). |
| * @param[in] non_blocking_mode I/O mode: non-zero selects non-blocking mode; |
| * zero selects blocking mode. |
| * |
| * @return zero upon success and a negative value upon error. |
| */ |
| int |
| netsnmp_set_non_blocking_mode(int sock, int non_blocking_mode) |
| { |
| #ifdef WIN32 |
| u_long arg; |
| |
| arg = non_blocking_mode; |
| return ioctlsocket(sock, FIONBIO, &arg); |
| #else |
| int sockflags; |
| |
| if ((sockflags = fcntl(sock, F_GETFL, 0)) >= 0) { |
| return fcntl(sock, F_SETFL, |
| non_blocking_mode ? sockflags | O_NONBLOCK |
| : sockflags & ~O_NONBLOCK); |
| } else |
| return -1; |
| #endif |
| } |
