Adding upstream version 8.4.4.upstream/8.4.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 406 insertions, 0 deletions

diff --git a/lib/agentx.c b/lib/agentx.c
new file mode 100644
index 0000000..4c08721
--- /dev/null
+++ b/lib/agentx.c
@@ -0,0 +1,406 @@
+/* SNMP support
+ * Copyright (C) 2012 Vincent Bernat <bernat@luffy.cx>
+ *
+ * This file is part of GNU Zebra.
+ *
+ * GNU Zebra is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2, or (at your option) any
+ * later version.
+ *
+ * GNU Zebra is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; see the file COPYING; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <zebra.h>
+
+#ifdef SNMP_AGENTX
+#include <net-snmp/net-snmp-config.h>
+#include <net-snmp/net-snmp-includes.h>
+#include <net-snmp/agent/net-snmp-agent-includes.h>
+#include <net-snmp/agent/snmp_vars.h>
+
+#include "command.h"
+#include "smux.h"
+#include "memory.h"
+#include "linklist.h"
+#include "lib/version.h"
+#include "lib_errors.h"
+#include "xref.h"
+
+XREF_SETUP();
+
+DEFINE_HOOK(agentx_enabled, (), ());
+
+static int agentx_enabled = 0;
+
+static struct thread_master *agentx_tm;
+static struct thread *timeout_thr = NULL;
+static struct list *events = NULL;
+
+static void agentx_events_update(void);
+
+static void agentx_timeout(struct thread *t)
+{
+	timeout_thr = NULL;
+
+	snmp_timeout();
+	run_alarms();
+	netsnmp_check_outstanding_agent_requests();
+	agentx_events_update();
+}
+
+static void agentx_read(struct thread *t)
+{
+	fd_set fds;
+	int flags, new_flags = 0;
+	int nonblock = false;
+	struct listnode *ln = THREAD_ARG(t);
+	struct thread **thr = listgetdata(ln);
+	XFREE(MTYPE_TMP, thr);
+	list_delete_node(events, ln);
+
+	/* fix for non blocking socket */
+	flags = fcntl(THREAD_FD(t), F_GETFL, 0);
+	if (-1 == flags) {
+		flog_err(EC_LIB_SYSTEM_CALL, "Failed to get FD settings fcntl: %s(%d)",
+			 strerror(errno), errno);
+		return;
+	}
+
+	if (flags & O_NONBLOCK)
+		nonblock = true;
+	else
+		new_flags = fcntl(THREAD_FD(t), F_SETFL, flags | O_NONBLOCK);
+
+	if (new_flags == -1)
+		flog_err(EC_LIB_SYSTEM_CALL, "Failed to set snmp fd non blocking: %s(%d)",
+			 strerror(errno), errno);
+
+	FD_ZERO(&fds);
+	FD_SET(THREAD_FD(t), &fds);
+	snmp_read(&fds);
+
+	/* Reset the flag */
+	if (!nonblock) {
+		new_flags = fcntl(THREAD_FD(t), F_SETFL, flags);
+
+		if (new_flags == -1)
+			flog_err(
+				EC_LIB_SYSTEM_CALL,
+				"Failed to set snmp fd back to original settings: %s(%d)",
+				strerror(errno), errno);
+	}
+
+	netsnmp_check_outstanding_agent_requests();
+	agentx_events_update();
+}
+
+static void agentx_events_update(void)
+{
+	int maxfd = 0;
+	int block = 1;
+	struct timeval timeout = {.tv_sec = 0, .tv_usec = 0};
+	fd_set fds;
+	struct listnode *ln;
+	struct thread **thr;
+	int fd, thr_fd;
+
+	thread_cancel(&timeout_thr);
+
+	FD_ZERO(&fds);
+	snmp_select_info(&maxfd, &fds, &timeout, &block);
+
+	if (!block) {
+		thread_add_timer_tv(agentx_tm, agentx_timeout, NULL, &timeout,
+				    &timeout_thr);
+	}
+
+	ln = listhead(events);
+	thr = ln ? listgetdata(ln) : NULL;
+	thr_fd = thr ? THREAD_FD(*thr) : -1;
+
+	/* "two-pointer" / two-list simultaneous iteration
+	 * ln/thr/thr_fd point to the next existing event listener to hit while
+	 * fd counts to catch up */
+	for (fd = 0; fd < maxfd; fd++) {
+		/* caught up */
+		if (thr_fd == fd) {
+			struct listnode *nextln = listnextnode(ln);
+			if (!FD_ISSET(fd, &fds)) {
+				thread_cancel(thr);
+				XFREE(MTYPE_TMP, thr);
+				list_delete_node(events, ln);
+			}
+			ln = nextln;
+			thr = ln ? listgetdata(ln) : NULL;
+			thr_fd = thr ? THREAD_FD(*thr) : -1;
+		}
+		/* need listener, but haven't hit one where it would be */
+		else if (FD_ISSET(fd, &fds)) {
+			struct listnode *newln;
+			thr = XCALLOC(MTYPE_TMP, sizeof(struct thread *));
+
+			newln = listnode_add_before(events, ln, thr);
+			thread_add_read(agentx_tm, agentx_read, newln, fd, thr);
+		}
+	}
+
+	/* leftover event listeners at this point have fd > maxfd, delete them
+	 */
+	while (ln) {
+		struct listnode *nextln = listnextnode(ln);
+		thr = listgetdata(ln);
+		thread_cancel(thr);
+		XFREE(MTYPE_TMP, thr);
+		list_delete_node(events, ln);
+		ln = nextln;
+	}
+}
+
+/* AgentX node. */
+static int config_write_agentx(struct vty *vty);
+static struct cmd_node agentx_node = {
+	.name = "smux",
+	.node = SMUX_NODE,
+	.prompt = "",
+	.config_write = config_write_agentx,
+};
+
+/* Logging NetSNMP messages */
+static int agentx_log_callback(int major, int minor, void *serverarg,
+			       void *clientarg)
+{
+	struct snmp_log_message *slm = (struct snmp_log_message *)serverarg;
+	char *msg = XSTRDUP(MTYPE_TMP, slm->msg);
+	if (msg)
+		msg[strlen(msg) - 1] = '\0';
+	switch (slm->priority) {
+	case LOG_EMERG:
+		flog_err(EC_LIB_SNMP, "snmp[emerg]: %s", msg ? msg : slm->msg);
+		break;
+	case LOG_ALERT:
+		flog_err(EC_LIB_SNMP, "snmp[alert]: %s", msg ? msg : slm->msg);
+		break;
+	case LOG_CRIT:
+		flog_err(EC_LIB_SNMP, "snmp[crit]: %s", msg ? msg : slm->msg);
+		break;
+	case LOG_ERR:
+		flog_err(EC_LIB_SNMP, "snmp[err]: %s", msg ? msg : slm->msg);
+		break;
+	case LOG_WARNING:
+		flog_warn(EC_LIB_SNMP, "snmp[warning]: %s",
+			  msg ? msg : slm->msg);
+		break;
+	case LOG_NOTICE:
+		zlog_notice("snmp[notice]: %s", msg ? msg : slm->msg);
+		break;
+	case LOG_INFO:
+		zlog_info("snmp[info]: %s", msg ? msg : slm->msg);
+		break;
+	case LOG_DEBUG:
+		zlog_debug("snmp[debug]: %s", msg ? msg : slm->msg);
+		break;
+	}
+	XFREE(MTYPE_TMP, msg);
+	return SNMP_ERR_NOERROR;
+}
+
+static int config_write_agentx(struct vty *vty)
+{
+	if (agentx_enabled)
+		vty_out(vty, "agentx\n");
+	return 1;
+}
+
+DEFUN (agentx_enable,
+       agentx_enable_cmd,
+       "agentx",
+       "SNMP AgentX protocol settings\n")
+{
+	if (!agentx_enabled) {
+		init_snmp(FRR_SMUX_NAME);
+		events = list_new();
+		agentx_events_update();
+		agentx_enabled = 1;
+		hook_call(agentx_enabled);
+	}
+
+	return CMD_SUCCESS;
+}
+
+DEFUN (no_agentx,
+       no_agentx_cmd,
+       "no agentx",
+       NO_STR
+       "SNMP AgentX protocol settings\n")
+{
+	if (!agentx_enabled)
+		return CMD_SUCCESS;
+	vty_out(vty, "SNMP AgentX support cannot be disabled once enabled\n");
+	return CMD_WARNING_CONFIG_FAILED;
+}
+
+int smux_enabled(void)
+{
+	return agentx_enabled;
+}
+
+void smux_init(struct thread_master *tm)
+{
+	agentx_tm = tm;
+
+	netsnmp_enable_subagent();
+	snmp_disable_log();
+	snmp_enable_calllog();
+	snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_LOGGING,
+			       agentx_log_callback, NULL);
+	init_agent(FRR_SMUX_NAME);
+
+	install_node(&agentx_node);
+	install_element(CONFIG_NODE, &agentx_enable_cmd);
+	install_element(CONFIG_NODE, &no_agentx_cmd);
+}
+
+void smux_agentx_enable(void)
+{
+	if (!agentx_enabled) {
+		init_snmp(FRR_SMUX_NAME);
+		events = list_new();
+		agentx_events_update();
+		agentx_enabled = 1;
+	}
+}
+
+void smux_register_mib(const char *descr, struct variable *var, size_t width,
+		       int num, oid name[], size_t namelen)
+{
+	register_mib(descr, var, width, num, name, namelen);
+}
+
+void smux_trap(struct variable *vp, size_t vp_len, const oid *ename,
+	       size_t enamelen, const oid *name, size_t namelen,
+	       const oid *iname, size_t inamelen,
+	       const struct trap_object *trapobj, size_t trapobjlen,
+	       uint8_t sptrap)
+{
+	struct index_oid trap_index[1];
+
+	/* copy the single index into the multi-index format */
+	oid_copy(trap_index[0].indexname, iname, inamelen);
+	trap_index[0].indexlen = inamelen;
+
+	smux_trap_multi_index(vp, vp_len, ename, enamelen, name, namelen,
+			      trap_index, array_size(trap_index), trapobj,
+			      trapobjlen, sptrap);
+}
+
+int smux_trap_multi_index(struct variable *vp, size_t vp_len, const oid *ename,
+			  size_t enamelen, const oid *name, size_t namelen,
+			  struct index_oid *iname, size_t index_len,
+			  const struct trap_object *trapobj, size_t trapobjlen,
+			  uint8_t sptrap)
+{
+	oid objid_snmptrap[] = {1, 3, 6, 1, 6, 3, 1, 1, 4, 1, 0};
+	size_t objid_snmptrap_len = sizeof(objid_snmptrap) / sizeof(oid);
+	oid notification_oid[MAX_OID_LEN];
+	size_t notification_oid_len;
+	unsigned int i;
+
+	netsnmp_variable_list *notification_vars = NULL;
+	if (!agentx_enabled)
+		return 0;
+
+	/* snmpTrapOID */
+	oid_copy(notification_oid, ename, enamelen);
+	notification_oid[enamelen] = sptrap;
+	notification_oid_len = enamelen + 1;
+	snmp_varlist_add_variable(&notification_vars, objid_snmptrap,
+				  objid_snmptrap_len, ASN_OBJECT_ID,
+				  (uint8_t *)notification_oid,
+				  notification_oid_len * sizeof(oid));
+
+	/* Provided bindings */
+	for (i = 0; i < trapobjlen; i++) {
+		unsigned int j;
+		oid oid[MAX_OID_LEN];
+		size_t oid_len, onamelen;
+		uint8_t *val;
+		size_t val_len;
+		WriteMethod *wm = NULL;
+		struct variable cvp;
+		unsigned int iindex;
+		/*
+		 * this allows the behaviour of smux_trap with a singe index
+		 * for all objects to be maintained whilst allowing traps which
+		 * have different indices per object to be supported
+		 */
+		iindex = (index_len == 1) ? 0 : i;
+
+		/* Make OID. */
+		if (trapobj[i].namelen > 0) {
+			/* Columnar object */
+			onamelen = trapobj[i].namelen;
+			oid_copy(oid, name, namelen);
+			oid_copy(oid + namelen, trapobj[i].name, onamelen);
+			oid_copy(oid + namelen + onamelen,
+				 iname[iindex].indexname,
+				 iname[iindex].indexlen);
+			oid_len = namelen + onamelen + iname[iindex].indexlen;
+		} else {
+			/* Scalar object */
+			onamelen = trapobj[i].namelen * (-1);
+			oid_copy(oid, name, namelen);
+			oid_copy(oid + namelen, trapobj[i].name, onamelen);
+			oid[onamelen + namelen] = 0;
+			oid_len = namelen + onamelen + 1;
+		}
+
+		/* Locate the appropriate function and type in the MIB registry.
+		 */
+		for (j = 0; j < vp_len; j++) {
+			if (oid_compare(trapobj[i].name, onamelen, vp[j].name,
+					vp[j].namelen)
+			    != 0)
+				continue;
+			/* We found the appropriate variable in the MIB
+			 * registry. */
+			oid_copy(cvp.name, name, namelen);
+			oid_copy(cvp.name + namelen, vp[j].name, vp[j].namelen);
+			cvp.namelen = namelen + vp[j].namelen;
+			cvp.type = vp[j].type;
+			cvp.magic = vp[j].magic;
+			cvp.acl = vp[j].acl;
+			cvp.findVar = vp[j].findVar;
+
+			/* Grab the result. */
+			val = cvp.findVar(&cvp, oid, &oid_len, 1, &val_len,
+					  &wm);
+			if (!val)
+				break;
+			snmp_varlist_add_variable(&notification_vars, oid,
+						  oid_len, vp[j].type, val,
+						  val_len);
+			break;
+		}
+	}
+
+
+	send_v2trap(notification_vars);
+	snmp_free_varbind(notification_vars);
+	agentx_events_update();
+	return 1;
+}
+
+void smux_events_update(void)
+{
+	agentx_events_update();
+}
+
+#endif /* SNMP_AGENTX */