blob: 5e062cced3d2f0443948d7920b288cf430791b53 [file] [log] [blame]
/* Portions of this file are subject to the following copyright(s). See
* the Net-SNMP's COPYING file for more details and other copyrights
* that may apply:
*/
/*
* Portions of this file are copyrighted by:
* Copyright Copyright 2003 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms specified in the COPYING file
* distributed with the Net-SNMP package.
*/
#include <net-snmp/net-snmp-config.h>
#include <stdio.h>
#include <sys/types.h>
#include <ctype.h>
#include <errno.h>
#if HAVE_STRING_H
#include <string.h>
#else
#include <strings.h>
#endif
#if HAVE_STDLIB_H
#include <stdlib.h>
#endif
#if HAVE_UNISTD_H
#include <unistd.h>
#endif
#if HAVE_SYS_SOCKET_H
#include <sys/socket.h>
#endif
#if HAVE_NETINET_IN_H
#include <netinet/in.h>
#endif
#if HAVE_ARPA_INET_H
#include <arpa/inet.h>
#endif
#if HAVE_NETDB_H
#include <netdb.h>
#endif
#if HAVE_SYS_UIO_H
#include <sys/uio.h>
#endif
#if HAVE_WINSOCK_H
#include <winsock2.h>
#include <ws2tcpip.h>
#endif
#if HAVE_DMALLOC_H
#include <dmalloc.h>
#endif
#include <net-snmp/types.h>
#include <net-snmp/output_api.h>
#include <net-snmp/config_api.h>
#include <net-snmp/library/snmp_transport.h>
#include <net-snmp/library/snmpUDPDomain.h>
#include <net-snmp/library/system.h>
#include <net-snmp/library/tools.h>
#ifndef INADDR_NONE
#define INADDR_NONE -1
#endif
#ifdef MSG_DONTWAIT
#define NETSNMP_DONTWAIT MSG_DONTWAIT
#else
#define NETSNMP_DONTWAIT 0
#endif
static netsnmp_tdomain udpDomain;
typedef struct netsnmp_udp_addr_pair_s {
struct sockaddr_in remote_addr;
struct in_addr local_addr;
} netsnmp_udp_addr_pair;
/*
* not static, since snmpUDPIPv6Domain needs it, but not public, either.
* (ie don't put it in a public header.)
*/
void _netsnmp_udp_sockopt_set(int fd, int server);
int
netsnmp_sockaddr_in2(struct sockaddr_in *addr,
const char *inpeername, const char *default_target);
/*
* Return a string representing the address in data, or else the "far end"
* address if data is NULL.
*/
static char *
netsnmp_udp_fmtaddr(netsnmp_transport *t, void *data, int len)
{
netsnmp_udp_addr_pair *addr_pair = NULL;
if (data != NULL && len == sizeof(netsnmp_udp_addr_pair)) {
addr_pair = (netsnmp_udp_addr_pair *) data;
} else if (t != NULL && t->data != NULL) {
addr_pair = (netsnmp_udp_addr_pair *) t->data;
}
if (addr_pair == NULL) {
return strdup("UDP: unknown");
} else {
struct sockaddr_in *to = NULL;
char tmp[64];
to = (struct sockaddr_in *) &(addr_pair->remote_addr);
if (to == NULL) {
sprintf(tmp, "UDP: unknown->[%s]",
inet_ntoa(addr_pair->local_addr));
} else {
sprintf(tmp, "UDP: [%s]:%hu->",
inet_ntoa(to->sin_addr), ntohs(to->sin_port));
sprintf(tmp + strlen(tmp), "[%s]", inet_ntoa(addr_pair->local_addr));
}
return strdup(tmp);
}
}
#if defined(linux) && defined(IP_PKTINFO)
# define netsnmp_dstaddr(x) (&(((struct in_pktinfo *)(CMSG_DATA(x)))->ipi_addr))
static int netsnmp_udp_recvfrom(int s, void *buf, int len, struct sockaddr *from, socklen_t *fromlen, struct in_addr *dstip)
{
int r;
struct iovec iov[1];
char cmsg[CMSG_SPACE(sizeof(struct in_pktinfo))];
struct cmsghdr *cmsgptr;
struct msghdr msg;
iov[0].iov_base = buf;
iov[0].iov_len = len;
memset(&msg, 0, sizeof msg);
msg.msg_name = from;
msg.msg_namelen = *fromlen;
msg.msg_iov = iov;
msg.msg_iovlen = 1;
msg.msg_control = &cmsg;
msg.msg_controllen = sizeof(cmsg);
r = recvmsg(s, &msg, NETSNMP_DONTWAIT);
if (r == -1) {
return -1;
}
DEBUGMSGTL(("netsnmp_udp", "got source addr: %s\n", inet_ntoa(((struct sockaddr_in *)from)->sin_addr)));
for (cmsgptr = CMSG_FIRSTHDR(&msg); cmsgptr != NULL; cmsgptr = CMSG_NXTHDR(&msg, cmsgptr)) {
if (cmsgptr->cmsg_level == SOL_IP && cmsgptr->cmsg_type == IP_PKTINFO) {
memcpy((void *) dstip, netsnmp_dstaddr(cmsgptr), sizeof(struct in_addr));
DEBUGMSGTL(("netsnmp_udp", "got destination (local) addr %s\n",
inet_ntoa(*dstip)));
}
}
return r;
}
static int netsnmp_udp_sendto(int fd, struct in_addr *srcip, struct sockaddr *remote,
void *data, int len)
{
struct iovec iov = { data, len };
struct {
struct cmsghdr cm;
struct in_pktinfo ipi;
} cmsg;
struct msghdr m;
memset(&cmsg, 0, sizeof(cmsg));
cmsg.cm.cmsg_len = sizeof(struct cmsghdr) + sizeof(struct in_pktinfo);
cmsg.cm.cmsg_level = SOL_IP;
cmsg.cm.cmsg_type = IP_PKTINFO;
cmsg.ipi.ipi_ifindex = 0;
cmsg.ipi.ipi_spec_dst.s_addr = (srcip ? srcip->s_addr : INADDR_ANY);
m.msg_name = remote;
m.msg_namelen = sizeof(struct sockaddr_in);
m.msg_iov = &iov;
m.msg_iovlen = 1;
m.msg_control = &cmsg;
m.msg_controllen = sizeof(cmsg);
m.msg_flags = 0;
return sendmsg(fd, &m, MSG_NOSIGNAL|MSG_DONTWAIT);
}
#endif /* linux && IP_PKTINFO */
/*
* You can write something into opaque that will subsequently get passed back
* to your send function if you like. For instance, you might want to
* remember where a PDU came from, so that you can send a reply there...
*/
static int
netsnmp_udp_recv(netsnmp_transport *t, void *buf, int size,
void **opaque, int *olength)
{
int rc = -1;
socklen_t fromlen = sizeof(struct sockaddr);
netsnmp_udp_addr_pair *addr_pair = NULL;
struct sockaddr *from;
if (t != NULL && t->sock >= 0) {
addr_pair = (netsnmp_udp_addr_pair *) malloc(sizeof(netsnmp_udp_addr_pair));
if (addr_pair == NULL) {
*opaque = NULL;
*olength = 0;
return -1;
} else {
memset(addr_pair, 0, sizeof(netsnmp_udp_addr_pair));
from = (struct sockaddr *) &(addr_pair->remote_addr);
}
while (rc < 0) {
#if defined(linux) && defined(IP_PKTINFO)
rc = netsnmp_udp_recvfrom(t->sock, buf, size, from, &fromlen, &(addr_pair->local_addr));
#else
rc = recvfrom(t->sock, buf, size, NETSNMP_DONTWAIT, from, &fromlen);
#endif /* linux && IP_PKTINFO */
if (rc < 0 && errno != EINTR) {
break;
}
}
if (rc >= 0) {
char *str = netsnmp_udp_fmtaddr(NULL, addr_pair, sizeof(netsnmp_udp_addr_pair));
DEBUGMSGTL(("netsnmp_udp",
"recvfrom fd %d got %d bytes (from %s)\n",
t->sock, rc, str));
free(str);
} else {
DEBUGMSGTL(("netsnmp_udp", "recvfrom fd %d err %d (\"%s\")\n",
t->sock, errno, strerror(errno)));
}
*opaque = (void *)addr_pair;
*olength = sizeof(netsnmp_udp_addr_pair);
}
return rc;
}
static int
netsnmp_udp_send(netsnmp_transport *t, void *buf, int size,
void **opaque, int *olength)
{
int rc = -1;
netsnmp_udp_addr_pair *addr_pair = NULL;
struct sockaddr *to = NULL;
if (opaque != NULL && *opaque != NULL &&
*olength == sizeof(netsnmp_udp_addr_pair)) {
addr_pair = (netsnmp_udp_addr_pair *) (*opaque);
} else if (t != NULL && t->data != NULL &&
t->data_length == sizeof(netsnmp_udp_addr_pair)) {
addr_pair = (netsnmp_udp_addr_pair *) (t->data);
}
to = (struct sockaddr *) &(addr_pair->remote_addr);
if (to != NULL && t != NULL && t->sock >= 0) {
char *str = netsnmp_udp_fmtaddr(NULL, (void *) addr_pair,
sizeof(netsnmp_udp_addr_pair));
DEBUGMSGTL(("netsnmp_udp", "send %d bytes from %p to %s on fd %d\n",
size, buf, str, t->sock));
free(str);
while (rc < 0) {
#if defined(linux) && defined(IP_PKTINFO)
rc = netsnmp_udp_sendto(t->sock, addr_pair ? &(addr_pair->local_addr) : NULL, to, buf, size);
#else
rc = sendto(t->sock, buf, size, 0, to, sizeof(struct sockaddr));
#endif /* linux && IP_PKTINFO */
if (rc < 0 && errno != EINTR) {
DEBUGMSGTL(("netsnmp_udp", "sendto error, rc %d (errno %d)\n",
rc, errno));
break;
}
}
}
return rc;
}
static int
netsnmp_udp_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;
size_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;
size_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
}
/*
* Open a UDP-based transport for SNMP. Local is TRUE if addr is the local
* address to bind to (i.e. this is a server-type session); otherwise addr is
* the remote address to send things to.
*/
netsnmp_transport *
netsnmp_udp_transport(struct sockaddr_in *addr, int local)
{
netsnmp_transport *t = NULL;
int rc = 0;
char *str = NULL;
char *client_socket = NULL;
netsnmp_udp_addr_pair addr_pair;
if (addr == NULL || addr->sin_family != AF_INET) {
return NULL;
}
memset(&addr_pair, 0, sizeof(netsnmp_udp_addr_pair));
memcpy(&(addr_pair.remote_addr), addr, sizeof(struct sockaddr_in));
t = (netsnmp_transport *) malloc(sizeof(netsnmp_transport));
if (t == NULL) {
return NULL;
}
str = netsnmp_udp_fmtaddr(NULL, (void *)&addr_pair,
sizeof(netsnmp_udp_addr_pair));
DEBUGMSGTL(("netsnmp_udp", "open %s %s\n", local ? "local" : "remote",
str));
free(str);
memset(t, 0, sizeof(netsnmp_transport));
t->domain = netsnmpUDPDomain;
t->domain_length = netsnmpUDPDomain_len;
t->sock = socket(PF_INET, SOCK_DGRAM, 0);
if (t->sock < 0) {
netsnmp_transport_free(t);
return NULL;
}
_netsnmp_udp_sockopt_set(t->sock, local);
if (local) {
/*
* This session is inteneded as a server, so we must bind on to the
* given IP address, which may include an interface address, or could
* be INADDR_ANY, but certainly includes a port number.
*/
t->local = (u_char *) malloc(6);
if (t->local == NULL) {
netsnmp_transport_free(t);
return NULL;
}
memcpy(t->local, (u_char *) & (addr->sin_addr.s_addr), 4);
t->local[4] = (htons(addr->sin_port) & 0xff00) >> 8;
t->local[5] = (htons(addr->sin_port) & 0x00ff) >> 0;
t->local_length = 6;
#if defined(linux) && defined(IP_PKTINFO)
{
int sockopt = 1;
if (setsockopt(t->sock, SOL_IP, IP_PKTINFO, &sockopt, sizeof sockopt) == -1) {
DEBUGMSGTL(("netsnmp_udp", "couldn't set IP_PKTINFO: %s\n",
strerror(errno)));
netsnmp_transport_free(t);
return NULL;
}
DEBUGMSGTL(("netsnmp_udp", "set IP_PKTINFO\n"));
}
#endif
rc = bind(t->sock, (struct sockaddr *) addr,
sizeof(struct sockaddr));
if (rc != 0) {
netsnmp_udp_close(t);
netsnmp_transport_free(t);
return NULL;
}
t->data = NULL;
t->data_length = 0;
} else {
/*
* This is a client session. If we've been given a
* client address to send from, then bind to that.
* Otherwise the send will use "something sensible".
*/
client_socket = netsnmp_ds_get_string(NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_CLIENT_ADDR);
if (client_socket) {
struct sockaddr_in client_addr;
netsnmp_sockaddr_in2(&client_addr, client_socket, NULL);
addr_pair.local_addr = client_addr.sin_addr;
rc = bind(t->sock, (struct sockaddr *)&client_addr,
sizeof(struct sockaddr));
if ( rc != 0 ) {
DEBUGMSGTL(("netsnmp_udp", "failed to bind for clientaddr: %d %s\n",
errno, strerror(errno)));
netsnmp_udp_close(t);
netsnmp_transport_free(t);
return NULL;
}
}
str = netsnmp_udp_fmtaddr(NULL, (void *)&addr_pair,
sizeof(netsnmp_udp_addr_pair));
DEBUGMSGTL(("netsnmp_udp", "client open %s\n", str));
free(str);
/*
* Save the (remote) address in the
* transport-specific data pointer for later use by netsnmp_udp_send.
*/
t->data = malloc(sizeof(netsnmp_udp_addr_pair));
t->remote = (u_char *)malloc(6);
if (t->data == NULL || t->remote == NULL) {
netsnmp_transport_free(t);
return NULL;
}
memcpy(t->remote, (u_char *) & (addr->sin_addr.s_addr), 4);
t->remote[4] = (htons(addr->sin_port) & 0xff00) >> 8;
t->remote[5] = (htons(addr->sin_port) & 0x00ff) >> 0;
t->remote_length = 6;
memcpy(t->data, &addr_pair, sizeof(netsnmp_udp_addr_pair));
t->data_length = sizeof(netsnmp_udp_addr_pair);
}
/*
* 16-bit length field, 8 byte UDP header, 20 byte IPv4 header
*/
t->msgMaxSize = 0xffff - 8 - 20;
t->f_recv = netsnmp_udp_recv;
t->f_send = netsnmp_udp_send;
t->f_close = netsnmp_udp_close;
t->f_accept = NULL;
t->f_fmtaddr = netsnmp_udp_fmtaddr;
return t;
}
void
_netsnmp_udp_sockopt_set(int fd, int local)
{
#ifdef SO_BSDCOMPAT
/*
* Patch for Linux. Without this, UDP packets that fail get an ICMP
* response. Linux turns the failed ICMP response into an error message
* and return value, unlike all other OS's.
*/
if (0 == netsnmp_os_prematch("Linux","2.4"))
{
int one = 1;
DEBUGMSGTL(("socket:option", "setting socket option SO_BSDCOMPAT\n"));
setsockopt(fd, SOL_SOCKET, SO_BSDCOMPAT, (void *) &one,
sizeof(one));
}
#endif /*SO_BSDCOMPAT */
/*
* SO_REUSEADDR will allow multiple apps to open the same port at
* the same time. Only the last one to open the socket will get
* data. Obviously, for an agent, this is a bad thing. There should
* only be one listener.
*/
#ifdef ALLOW_PORT_HIJACKING
#ifdef SO_REUSEADDR
/*
* Allow the same port to be specified multiple times without failing.
* (useful for a listener)
*/
{
int one = 1;
DEBUGMSGTL(("socket:option", "setting socket option SO_REUSEADDR\n"));
setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (void *) &one,
sizeof(one));
}
#endif /*SO_REUSEADDR */
#endif
/*
* Try to set the send and receive buffers to a reasonably large value, so
* that we can send and receive big PDUs (defaults to 8192 bytes (!) on
* Solaris, for instance). Don't worry too much about errors -- just
* plough on regardless.
*/
netsnmp_sock_buffer_set(fd, SO_SNDBUF, local, 0);
netsnmp_sock_buffer_set(fd, SO_RCVBUF, local, 0);
}
int
netsnmp_sockaddr_in2(struct sockaddr_in *addr,
const char *inpeername, const char *default_target)
{
#if HAVE_GETADDRINFO
struct addrinfo *addrs = NULL;
struct addrinfo hint;
int err;
#elif HAVE_GETIPNODEBYNAME
struct hostent *hp = NULL;
int err;
#elif HAVE_GETHOSTBYNAME
struct hostent *hp = NULL;
#endif
if (addr == NULL) {
return 0;
}
DEBUGMSGTL(("netsnmp_sockaddr_in",
"addr %p, inpeername \"%s\", default_target \"%s\"\n",
addr, inpeername ? inpeername : "[NIL]",
default_target ? default_target : "[NIL]"));
memset(addr, 0, sizeof(struct sockaddr_in));
addr->sin_addr.s_addr = htonl(INADDR_ANY);
addr->sin_family = AF_INET;
addr->sin_port = htons((u_short)SNMP_PORT);
{
int port = netsnmp_ds_get_int(NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_DEFAULT_PORT);
if (port != 0) {
addr->sin_port = htons((u_short)port);
} else if (default_target != NULL)
netsnmp_sockaddr_in2(addr, default_target, NULL);
}
if (inpeername != NULL && *inpeername != '\0') {
const char *host, *port;
char *peername = NULL;
char *cp;
/*
* Duplicate the peername because we might want to mank around with
* it.
*/
peername = strdup(inpeername);
if (peername == NULL) {
return 0;
}
/*
* Try and extract an appended port number.
*/
cp = strchr(peername, ':');
if (cp != NULL) {
*cp = '\0';
port = cp + 1;
host = peername;
} else {
host = NULL;
port = peername;
}
/*
* Try to convert the user port specifier
*/
if (port && *port == '\0')
port = NULL;
if (port != NULL) {
long int l;
char* ep;
DEBUGMSGTL(("netsnmp_sockaddr_in", "check user service %s\n",
port));
l = strtol(port, &ep, 10);
if (ep != port && *ep == '\0' && 0 <= l && l <= 0x0ffff)
addr->sin_port = htons((u_short)l);
else {
if (host == NULL) {
DEBUGMSGTL(("netsnmp_sockaddr_in",
"servname not numeric, "
"check if it really is a destination)"));
host = port;
port = NULL;
} else {
DEBUGMSGTL(("netsnmp_sockaddr_in",
"servname not numeric"));
free(peername);
return 0;
}
}
}
/*
* Try to convert the user host specifier
*/
if (host && *host == '\0')
host = NULL;
if (host != NULL) {
DEBUGMSGTL(("netsnmp_sockaddr_in",
"check destination %s\n", host));
#if HAVE_GETADDRINFO
memset(&hint, 0, sizeof hint);
hint.ai_flags = 0;
hint.ai_family = PF_INET;
hint.ai_socktype = SOCK_DGRAM;
hint.ai_protocol = 0;
err = getaddrinfo(peername, NULL, &hint, &addrs);
if (err != 0) {
#if HAVE_GAI_STRERROR
snmp_log(LOG_ERR, "getaddrinfo: %s %s\n", peername,
gai_strerror(err));
#else
snmp_log(LOG_ERR, "getaddrinfo: %s (error %d)\n", peername,
err);
#endif
free(peername);
return 0;
}
if (addrs != NULL) {
DEBUGMSGTL(("netsnmp_sockaddr_in",
"hostname (resolved okay)\n"));
memcpy(&addr->sin_addr,
&((struct sockaddr_in *) addrs->ai_addr)->sin_addr,
sizeof(struct in_addr));
freeaddrinfo(addrs);
}
else {
DEBUGMSGTL(("netsnmp_sockaddr_in",
"Failed to resolve IPv4 hostname\n"));
}
#elif HAVE_GETHOSTBYNAME
hp = gethostbyname(host);
if (hp == NULL) {
DEBUGMSGTL(("netsnmp_sockaddr_in",
"hostname (couldn't resolve)\n"));
free(peername);
return 0;
} else if (hp->h_addrtype != AF_INET) {
DEBUGMSGTL(("netsnmp_sockaddr_in",
"hostname (not AF_INET!)\n"));
free(peername);
return 0;
} else {
DEBUGMSGTL(("netsnmp_sockaddr_in",
"hostname (resolved okay)\n"));
memcpy(&addr->sin_addr, hp->h_addr, hp->h_length);
}
#elif HAVE_GETIPNODEBYNAME
hp = getipnodebyname(peername, AF_INET, 0, &err);
if (hp == NULL) {
DEBUGMSGTL(("netsnmp_sockaddr_in",
"hostname (couldn't resolve = %d)\n", err));
free(peername);
return 0;
}
DEBUGMSGTL(("netsnmp_sockaddr_in",
"hostname (resolved okay)\n"));
memcpy(&(addr->sin_addr), hp->h_addr, hp->h_length);
#else /* HAVE_GETIPNODEBYNAME */
/*
* There is no name resolving function available.
*/
DEBUGMSGTL(("netsnmp_sockaddr_in",
"no getaddrinfo()/getipnodebyname()/gethostbyname()\n"));
free(peername);
return 0;
#endif /* HAVE_GETHOSTBYNAME */
}
free(peername);
}
/*
* Finished
*/
DEBUGMSGTL(("netsnmp_sockaddr_in", "return { AF_INET, %s:%hu }\n",
inet_ntoa(addr->sin_addr), ntohs(addr->sin_port)));
return 1;
}
int
netsnmp_sockaddr_in(struct sockaddr_in *addr,
const char *inpeername, int remote_port)
{
char buf[sizeof(int) * 3 + 2];
sprintf(buf, ":%u", remote_port);
return netsnmp_sockaddr_in2(addr, inpeername, remote_port ? buf : NULL);
}
#if !defined(NETSNMP_DISABLE_SNMPV1) || !defined(NETSNMP_DISABLE_SNMPV2C)
/*
* The following functions provide the "com2sec" configuration token
* functionality for compatibility.
*/
#define EXAMPLE_NETWORK "NETWORK"
#define EXAMPLE_COMMUNITY "COMMUNITY"
typedef struct _com2SecEntry {
char community[COMMUNITY_MAX_LEN];
unsigned long network;
unsigned long mask;
char secName[VACMSTRINGLEN];
char contextName[VACMSTRINGLEN];
struct _com2SecEntry *next;
} com2SecEntry;
com2SecEntry *com2SecList = NULL, *com2SecListLast = NULL;
void
netsnmp_udp_parse_security(const char *token, char *param)
{
char secName[VACMSTRINGLEN];
char contextName[VACMSTRINGLEN];
char community[COMMUNITY_MAX_LEN];
char source[SNMP_MAXBUF_SMALL];
char *cp = NULL;
const char *strmask = NULL;
com2SecEntry *e = NULL;
in_addr_t network = 0, mask = 0;
/*
* Get security, source address/netmask and community strings.
*/
cp = copy_nword( param, secName, sizeof(secName));
if (strcmp(secName, "-Cn") == 0) {
if (!cp) {
config_perror("missing CONTEXT_NAME parameter");
return;
}
cp = copy_nword( cp, contextName, sizeof(contextName));
cp = copy_nword( cp, secName, sizeof(secName));
} else {
contextName[0] = '\0';
}
if (secName[0] == '\0') {
config_perror("missing NAME parameter");
return;
} else if (strlen(secName) > (VACMSTRINGLEN - 1)) {
config_perror("security name too long");
return;
}
cp = copy_nword( cp, source, sizeof(source));
if (source[0] == '\0') {
config_perror("missing SOURCE parameter");
return;
} else if (strncmp(source, EXAMPLE_NETWORK, strlen(EXAMPLE_NETWORK)) ==
0) {
config_perror("example config NETWORK not properly configured");
return;
}
cp = copy_nword( cp, community, sizeof(community));
if (community[0] == '\0') {
config_perror("missing COMMUNITY parameter\n");
return;
} else
if (strncmp
(community, EXAMPLE_COMMUNITY, strlen(EXAMPLE_COMMUNITY))
== 0) {
config_perror("example config COMMUNITY not properly configured");
return;
} else if (strlen(community) > (COMMUNITY_MAX_LEN - 1)) {
config_perror("community name too long");
return;
}
/*
* Process the source address/netmask string.
*/
cp = strchr(source, '/');
if (cp != NULL) {
/*
* Mask given.
*/
*cp = '\0';
strmask = cp + 1;
}
/*
* Deal with the network part first.
*/
if ((strcmp(source, "default") == 0)
|| (strcmp(source, "0.0.0.0") == 0)) {
network = 0;
strmask = "0.0.0.0";
} else {
/*
* Try interpreting as a dotted quad.
*/
network = inet_addr(source);
if (network == (in_addr_t) -1) {
/*
* Nope, wasn't a dotted quad. Must be a hostname.
*/
#ifdef HAVE_GETHOSTBYNAME
struct hostent *hp = gethostbyname(source);
if (hp == NULL) {
config_perror("bad source address");
return;
} else {
if (hp->h_addrtype != AF_INET) {
config_perror("no IP address for source hostname");
return;
}
network = *((in_addr_t *) hp->h_addr);
}
#else /*HAVE_GETHOSTBYNAME */
/*
* Oh dear.
*/
config_perror("cannot resolve source hostname");
return;
#endif /*HAVE_GETHOSTBYNAME */
}
}
/*
* Now work out the mask.
*/
if (strmask == NULL || *strmask == '\0') {
/*
* No mask was given. Use 255.255.255.255.
*/
mask = 0xffffffffL;
} else {
if (strchr(strmask, '.')) {
/*
* Try to interpret mask as a dotted quad.
*/
mask = inet_addr(strmask);
if (mask == (in_addr_t) -1 &&
strncmp(strmask, "255.255.255.255", 15) != 0) {
config_perror("bad mask");
return;
}
} else {
/*
* Try to interpret mask as a "number of 1 bits".
*/
int maskLen = atoi(strmask), maskBit = 0x80000000L;
if (maskLen <= 0 || maskLen > 32) {
config_perror("bad mask length");
return;
}
while (maskLen--) {
mask |= maskBit;
maskBit >>= 1;
}
mask = htonl(mask);
}
}
/*
* Check that the network and mask are consistent.
*/
if (network & ~mask) {
config_perror("source/mask mismatch");
return;
}
e = (com2SecEntry *) malloc(sizeof(com2SecEntry));
if (e == NULL) {
config_perror("memory error");
return;
}
/*
* Everything is okay. Copy the parameters to the structure allocated
* above and add it to END of the list.
*/
DEBUGMSGTL(("netsnmp_udp_parse_security",
"<\"%s\", 0x%08x/0x%08x> => \"%s\"\n", community, network,
mask, secName));
strcpy(e->contextName, contextName);
strcpy(e->secName, secName);
strcpy(e->community, community);
e->network = network;
e->mask = mask;
e->next = NULL;
if (com2SecListLast != NULL) {
com2SecListLast->next = e;
com2SecListLast = e;
} else {
com2SecListLast = com2SecList = e;
}
}
void
netsnmp_udp_com2SecList_free(void)
{
com2SecEntry *e = com2SecList;
while (e != NULL) {
com2SecEntry *tmp = e;
e = e->next;
free(tmp);
}
com2SecList = com2SecListLast = NULL;
}
#endif /* support for community based SNMP */
void
netsnmp_udp_agent_config_tokens_register(void)
{
#if !defined(NETSNMP_DISABLE_SNMPV1) || !defined(NETSNMP_DISABLE_SNMPV2C)
register_app_config_handler("com2sec", netsnmp_udp_parse_security,
netsnmp_udp_com2SecList_free,
"[-Cn CONTEXT] secName IPv4-network-address[/netmask] community");
#endif /* support for community based SNMP */
}
/*
* Return 0 if there are no com2sec entries, or return 1 if there ARE com2sec
* entries. On return, if a com2sec entry matched the passed parameters,
* then *secName points at the appropriate security name, or is NULL if the
* parameters did not match any com2sec entry.
*/
#if !defined(NETSNMP_DISABLE_SNMPV1) || !defined(NETSNMP_DISABLE_SNMPV2C)
int
netsnmp_udp_getSecName(void *opaque, int olength,
const char *community,
size_t community_len, char **secName,
char **contextName)
{
com2SecEntry *c;
netsnmp_udp_addr_pair *addr_pair = (netsnmp_udp_addr_pair *) opaque;
struct sockaddr_in *from = (struct sockaddr_in *) &(addr_pair->remote_addr);
char *ztcommunity = NULL;
if (secName != NULL) {
*secName = NULL; /* Haven't found anything yet */
}
/*
* Special case if there are NO entries (as opposed to no MATCHING
* entries).
*/
if (com2SecList == NULL) {
DEBUGMSGTL(("netsnmp_udp_getSecName", "no com2sec entries\n"));
return 0;
}
/*
* If there is no IPv4 source address, then there can be no valid security
* name.
*/
if (opaque == NULL || olength != sizeof(netsnmp_udp_addr_pair) ||
from->sin_family != AF_INET) {
DEBUGMSGTL(("netsnmp_udp_getSecName",
"no IPv4 source address in PDU?\n"));
return 1;
}
DEBUGIF("netsnmp_udp_getSecName") {
ztcommunity = (char *)malloc(community_len + 1);
if (ztcommunity != NULL) {
memcpy(ztcommunity, community, community_len);
ztcommunity[community_len] = '\0';
}
DEBUGMSGTL(("netsnmp_udp_getSecName", "resolve <\"%s\", 0x%08lx>\n",
ztcommunity ? ztcommunity : "<malloc error>",
(unsigned long)(from->sin_addr.s_addr)));
}
for (c = com2SecList; c != NULL; c = c->next) {
DEBUGMSGTL(("netsnmp_udp_getSecName","compare <\"%s\", 0x%08x/0x%08x>",
c->community, c->network, c->mask));
if ((community_len == strlen(c->community)) &&
(memcmp(community, c->community, community_len) == 0) &&
((from->sin_addr.s_addr & c->mask) == c->network)) {
DEBUGMSG(("netsnmp_udp_getSecName", "... SUCCESS\n"));
if (secName != NULL) {
*secName = c->secName;
*contextName = c->contextName;
}
break;
}
DEBUGMSG(("netsnmp_udp_getSecName", "... nope\n"));
}
if (ztcommunity != NULL) {
free(ztcommunity);
}
return 1;
}
#endif /* support for community based SNMP */
netsnmp_transport *
netsnmp_udp_create_tstring(const char *str, int local,
const char *default_target)
{
struct sockaddr_in addr;
if (netsnmp_sockaddr_in2(&addr, str, default_target)) {
return netsnmp_udp_transport(&addr, local);
} else {
return NULL;
}
}
netsnmp_transport *
netsnmp_udp_create_ostring(const u_char * o, size_t o_len, int local)
{
struct sockaddr_in addr;
if (o_len == 6) {
unsigned short porttmp = (o[4] << 8) + o[5];
addr.sin_family = AF_INET;
memcpy((u_char *) & (addr.sin_addr.s_addr), o, 4);
addr.sin_port = htons(porttmp);
return netsnmp_udp_transport(&addr, local);
}
return NULL;
}
void
netsnmp_udp_ctor(void)
{
udpDomain.name = netsnmpUDPDomain;
udpDomain.name_length = netsnmpUDPDomain_len;
udpDomain.prefix = (const char**)calloc(2, sizeof(char *));
udpDomain.prefix[0] = "udp";
udpDomain.f_create_from_tstring = NULL;
udpDomain.f_create_from_tstring_new = netsnmp_udp_create_tstring;
udpDomain.f_create_from_ostring = netsnmp_udp_create_ostring;
netsnmp_tdomain_register(&udpDomain);
}