/* IPV4 base transport support functions
*
* 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 (c) 2016 VMware, 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 <net-snmp/types.h>
#include <net-snmp/library/snmpUDPIPv4BaseDomain.h>
#include <stddef.h>
#include <stdio.h>
#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_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
#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/snmp_assert.h>
#include <net-snmp/library/default_store.h>
#include <net-snmp/library/snmp_transport.h>
#include <net-snmp/library/snmpSocketBaseDomain.h>
#ifndef NETSNMP_NO_SYSTEMD
#include <net-snmp/library/sd-daemon.h>
#endif
#if defined(HAVE_IP_PKTINFO) || (defined(HAVE_IP_RECVDSTADDR) && defined(HAVE_IP_SENDSRCADDR))
int netsnmp_udpipv4_recvfrom(int s, void *buf, int len, struct sockaddr *from,
socklen_t *fromlen, struct sockaddr *dstip,
socklen_t *dstlen, int *if_index)
{
return netsnmp_udpbase_recvfrom(s, buf, len, from, fromlen, dstip, dstlen,
if_index);
}
int netsnmp_udpipv4_sendto(int fd, const struct in_addr *srcip, int if_index,
const struct sockaddr *remote, const void *data,
int len)
{
return netsnmp_udpbase_sendto(fd, srcip, if_index, remote, data, len);
}
#endif /* HAVE_IP_PKTINFO || HAVE_IP_RECVDSTADDR */
netsnmp_transport *
netsnmp_udpipv4base_transport_init(const struct sockaddr_in *addr, int local)
{
netsnmp_transport *t;
u_char *addr_ptr;
if (addr == NULL || addr->sin_family != AF_INET) {
return NULL;
}
t = SNMP_MALLOC_TYPEDEF(netsnmp_transport);
if (NULL == t)
return NULL;
t->sock = -1;
addr_ptr = netsnmp_memdup(addr, sizeof(*addr));
if (NULL == addr_ptr) {
free(t);
return NULL;
}
if (local) {
/** This is a server session. */
t->local_length = sizeof(*addr);
t->local = addr_ptr;
} else {
/** This is a client session. */
t->remote = addr_ptr;
t->remote_length = sizeof(*addr);
}
DEBUGIF("netsnmp_udpbase") {
netsnmp_indexed_addr_pair addr_pair;
char *str;
memset(&addr_pair, 0, sizeof(netsnmp_indexed_addr_pair));
memcpy(&(addr_pair.remote_addr), addr, sizeof(*addr));
str = netsnmp_udp_fmtaddr(NULL, (void *)&addr_pair,
sizeof(netsnmp_indexed_addr_pair));
DEBUGMSGTL(("netsnmp_udpbase", "open %s %s\n",
local ? "local" : "remote", str));
free(str);
}
if (!local) {
netsnmp_indexed_addr_pair *addr_pair;
/*
* allocate space to save the (remote) address in the
* transport-specific data pointer for later use by netsnmp_udp_send.
*/
t->data = calloc(1, sizeof(netsnmp_indexed_addr_pair));
if (NULL == t->data) {
netsnmp_transport_free(t);
return NULL;
}
t->data_length = sizeof(netsnmp_indexed_addr_pair);
addr_pair = (netsnmp_indexed_addr_pair *)t->data;
memcpy(&addr_pair->remote_addr, addr, sizeof(*addr));
}
return t;
}
int
netsnmp_udpipv4base_transport_socket(int flags)
{
int local = flags & NETSNMP_TSPEC_LOCAL;
int sock = socket(PF_INET, SOCK_DGRAM, 0);
DEBUGMSGTL(("UDPBase", "opened socket %d as local=%d\n", sock, local));
if (sock < 0)
return -1;
_netsnmp_udp_sockopt_set(sock, local);
return sock;
}
int
netsnmp_udpipv4base_transport_bind(netsnmp_transport *t,
const struct sockaddr_in *addr, int flags)
{
#if defined(HAVE_IP_PKTINFO) || defined(HAVE_IP_RECVDSTADDR)
int sockopt = 1;
#endif
int rc;
if (flags & NETSNMP_TSPEC_LOCAL) {
#ifdef NETSNMP_NO_LISTEN_SUPPORT
return NULL;
#endif /* NETSNMP_NO_LISTEN_SUPPORT */
#ifndef WIN32
#if defined(HAVE_IP_PKTINFO)
if (setsockopt(t->sock, SOL_IP, IP_PKTINFO, &sockopt, sizeof sockopt) == -1) {
DEBUGMSGTL(("netsnmp_udpbase", "couldn't set IP_PKTINFO: %s\n",
strerror(errno)));
return 1;
}
DEBUGMSGTL(("netsnmp_udpbase", "set IP_PKTINFO\n"));
#elif defined(HAVE_IP_RECVDSTADDR)
if (setsockopt(t->sock, IPPROTO_IP, IP_RECVDSTADDR, &sockopt, sizeof sockopt) == -1) {
DEBUGMSGTL(("netsnmp_udp", "couldn't set IP_RECVDSTADDR: %s\n",
strerror(errno)));
return 1;
}
DEBUGMSGTL(("netsnmp_udp", "set IP_RECVDSTADDR\n"));
#endif
#else /* !defined(WIN32) */
{
int sockopt = 1;
if (setsockopt(t->sock, IPPROTO_IP, IP_PKTINFO, (void *)&sockopt,
sizeof(sockopt)) == -1) {
DEBUGMSGTL(("netsnmp_udpbase", "couldn't set IP_PKTINFO: %d\n",
WSAGetLastError()));
} else {
DEBUGMSGTL(("netsnmp_udpbase", "set IP_PKTINFO\n"));
}
}
#endif /* !defined(WIN32) */
}
DEBUGIF("netsnmp_udpbase") {
netsnmp_indexed_addr_pair addr_pair;
char *str;
memset(&addr_pair, 0x0, sizeof(addr_pair));
memcpy(&(addr_pair.local_addr), addr, sizeof(*addr));
str = netsnmp_udp_fmtaddr(NULL, (void *)&addr_pair,
sizeof(netsnmp_indexed_addr_pair));
DEBUGMSGTL(("netsnmp_udpbase", "binding socket: %d to %s\n",
t->sock, str));
free(str);
}
rc = bind(t->sock, (const struct sockaddr *)addr, sizeof(*addr));
if ( rc != 0 ) {
DEBUGMSGTL(("netsnmp_udpbase",
"failed to bind for clientaddr: %d %s\n",
errno, strerror(errno)));
netsnmp_socketbase_close(t);
return 1;
}
return 0;
}
void
netsnmp_udpipv4base_transport_get_bound_addr(netsnmp_transport *t)
{
netsnmp_indexed_addr_pair *addr_pair;
socklen_t local_addr_len = sizeof(addr_pair->local_addr);
int rc;
/** only for client transports: must have data and not local */
if (NULL == t || NULL != t->local || NULL == t->data ||
t->data_length < local_addr_len) {
snmp_log(LOG_ERR, "bad parameters for get bound addr\n");
return;
}
addr_pair = (netsnmp_indexed_addr_pair *)t->data;
/** get local socket address for client session */
rc = getsockname(t->sock, (struct sockaddr*)&addr_pair->local_addr,
&local_addr_len);
netsnmp_assert(rc == 0);
DEBUGIF("netsnmp_udpbase") {
char *str;
str = netsnmp_udp_fmtaddr(NULL, (void *)addr_pair,
sizeof(netsnmp_indexed_addr_pair));
DEBUGMSGTL(("netsnmp_udpbase", "socket %d bound to %s\n",
t->sock, str));
free(str);
}
}
netsnmp_transport *
netsnmp_udpipv4base_transport_with_source(const struct sockaddr_in *addr,
int local,
const struct sockaddr_in *src_addr)
{
netsnmp_transport *t = NULL;
const struct sockaddr_in *bind_addr;
int rc, flags = 0;
t = netsnmp_udpipv4base_transport_init(addr, local);
if (NULL == t)
return NULL;
if (local) {
bind_addr = addr;
flags |= NETSNMP_TSPEC_LOCAL;
#ifndef NETSNMP_NO_SYSTEMD
/*
* Maybe the socket was already provided by systemd...
*/
t->sock = netsnmp_sd_find_inet_socket(PF_INET, SOCK_DGRAM, -1,
ntohs(addr->sin_port));
#endif
}
else
bind_addr = src_addr;
if (-1 == t->sock)
t->sock = netsnmp_udpipv4base_transport_socket(flags);
if (t->sock < 0) {
netsnmp_transport_free(t);
return NULL;
}
/*
* If we've been given an address to bind to, then bind to it.
* Otherwise the OS will use "something sensible".
*/
if (NULL == bind_addr)
return t;
rc = netsnmp_udpipv4base_transport_bind(t, bind_addr, flags);
if (rc) {
netsnmp_transport_free(t);
t = NULL;
}
else if (!local)
netsnmp_udpipv4base_transport_get_bound_addr(t);
return t;
}
netsnmp_transport *
netsnmp_udpipv4base_tspec_transport(netsnmp_tdomain_spec *tspec)
{
struct sockaddr_in addr;
int local;
if (NULL == tspec)
return NULL;
local = tspec->flags & NETSNMP_TSPEC_LOCAL;
/** get address from target */
if (!netsnmp_sockaddr_in2(&addr, tspec->target, tspec->default_target))
return NULL;
if (NULL != tspec->source) {
struct sockaddr_in src_addr, *srcp = &src_addr;
/** get sockaddr from source */
if (!netsnmp_sockaddr_in2(&src_addr, tspec->source, NULL))
return NULL;
return netsnmp_udpipv4base_transport_with_source(&addr, local, srcp);
} else {
/** if no source and we do not want any default client address */
if (tspec->flags & NETSNMP_TSPEC_NO_DFTL_CLIENT_ADDR)
return netsnmp_udpipv4base_transport_with_source(&addr, local,
NULL);
}
/** no source and default client address ok */
return netsnmp_udpipv4base_transport(&addr, local);
}
netsnmp_transport *
netsnmp_udpipv4base_transport(const struct sockaddr_in *addr, int local)
{
if (!local) {
/*
* 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".
*/
const char *client_socket;
client_socket = netsnmp_ds_get_string(NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_CLIENT_ADDR);
if (client_socket) {
struct sockaddr_in client_addr;
char *client_address = NETSNMP_REMOVE_CONST(char *,client_socket);
int have_port, rc;
int uses_port =
netsnmp_ds_get_boolean(NETSNMP_DS_LIBRARY_ID,
NETSNMP_DS_LIB_CLIENT_ADDR_USES_PORT);
have_port = (strchr(client_socket, ':') != NULL);
if ((uses_port == 1) && !have_port) {
/*
* if NETSNMP_DS_LIB_CLIENT_ADDR expects a port but there
* is none specified then provide ephemeral one/
*/
client_address = malloc(strlen(client_socket) + 3);
if (client_address == NULL) {
return NULL;
}
strcpy(client_address, client_socket);
strcat(client_address, ":0");
have_port = 1;
}
rc = netsnmp_sockaddr_in2(&client_addr, client_socket, NULL);
if (client_address != client_socket)
free(client_address);
if(rc) {
if (!uses_port || !have_port) /* if port isn't from string, */
client_addr.sin_port = 0; /* ... clear it */
return netsnmp_udpipv4base_transport_with_source(addr, local,
&client_addr);
}
}
}
return netsnmp_udpipv4base_transport_with_source(addr, local, NULL);
}