Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.sbin/snmpctl/../snmpd/smi.c	Lines:	26	170	15.3 %
Date:	2017-11-13	Branches:	92	506	18.2 %




/*
 * Copyright (c) 2007, 2008 Reyk Floeter <reyk@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/queue.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/tree.h>
#include <sys/sysctl.h>

#include <net/if.h>
#include <net/if_dl.h>
#include <net/if_arp.h>
#include <net/if_media.h>
#include <net/route.h>
#include <netinet/in.h>
#include <netinet/if_ether.h>
#include <arpa/inet.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <event.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
#include <limits.h>
#include <pwd.h>
#include <vis.h>

#include "snmpd.h"
#include "mib.h"

#define MINIMUM(a, b)	(((a) < (b)) ? (a) : (b))

RB_HEAD(oidtree, oid);
RB_PROTOTYPE(oidtree, oid, o_element, smi_oid_cmp);
struct oidtree smi_oidtree;

RB_HEAD(keytree, oid);
RB_PROTOTYPE(keytree, oid, o_keyword, smi_key_cmp);
struct keytree smi_keytree;

u_long
smi_getticks(void)
{
	struct timeval	 now, run;
	u_long		 ticks;

	gettimeofday(&now, NULL);
	if (timercmp(&now, &snmpd_env->sc_starttime, <=))
		return (0);
	timersub(&now, &snmpd_env->sc_starttime, &run);
	ticks = run.tv_sec * 100;
	if (run.tv_usec)
		ticks += run.tv_usec / 10000;

	return (ticks);
}

void
smi_oidlen(struct ber_oid *o)
{
	size_t	 i;

	for (i = 0; i < BER_MAX_OID_LEN && o->bo_id[i] != 0; i++)
		;
	o->bo_n = i;
}

void
smi_scalar_oidlen(struct ber_oid *o)
{
	smi_oidlen(o);

	/* Append .0. */
	if (o->bo_n < BER_MAX_OID_LEN)
		o->bo_n++;
}

char *
smi_oid2string(struct ber_oid *o, char *buf, size_t len, size_t skip)
{
	char		 str[256];
	struct oid	*value, key;
	size_t		 i, lookup = 1;

	bzero(buf, len);
	bzero(&key, sizeof(key));
	bcopy(o, &key.o_id, sizeof(struct ber_oid));
	key.o_flags |= OID_KEY;		/* do not match wildcards */

	if (snmpd_env->sc_flags & SNMPD_F_NONAMES)
		lookup = 0;

	for (i = 0; i < o->bo_n; i++) {
		key.o_oidlen = i + 1;
		if (lookup && skip > i)
			continue;
		if (lookup &&
		    (value = RB_FIND(oidtree, &smi_oidtree, &key)) != NULL)
			snprintf(str, sizeof(str), "%s", value->o_name);
		else
			snprintf(str, sizeof(str), "%d", key.o_oid[i]);
		strlcat(buf, str, len);
		if (i < (o->bo_n - 1))
			strlcat(buf, ".", len);
	}

	return (buf);
}

int
smi_string2oid(const char *oidstr, struct ber_oid *o)
{
	char			*sp, *p, str[BUFSIZ];
	const char		*errstr;
	struct oid		*oid;
	struct ber_oid		 ko;

	if (strlcpy(str, oidstr, sizeof(str)) >= sizeof(str))
		return (-1);
	bzero(o, sizeof(*o));

	/*
	 * Parse OID strings in the common form n.n.n or n-n-n.
	 * Based on ber_string2oid with additional support for symbolic names.
	 */
	for (p = sp = str; p != NULL; sp = p) {
		if ((p = strpbrk(p, ".-")) != NULL)
			*p++ = '\0';
		if ((oid = smi_findkey(sp)) != NULL) {
			bcopy(&oid->o_id, &ko, sizeof(ko));
			if (o->bo_n && ber_oid_cmp(o, &ko) != 2)
				return (-1);
			bcopy(&ko, o, sizeof(*o));
			errstr = NULL;
		} else {
			o->bo_id[o->bo_n++] =
			    strtonum(sp, 0, UINT_MAX, &errstr);
		}
		if (errstr || o->bo_n > BER_MAX_OID_LEN)
			return (-1);
	}

	return (0);
}

void
smi_delete(struct oid *oid)
{
	struct oid	 key, *value;

	bzero(&key, sizeof(key));
	bcopy(&oid->o_id, &key.o_id, sizeof(struct ber_oid));
	if ((value = RB_FIND(oidtree, &smi_oidtree, &key)) != NULL &&
	    value == oid)
		RB_REMOVE(oidtree, &smi_oidtree, value);

	free(oid->o_data);
	if (oid->o_flags & OID_DYNAMIC) {
		free(oid->o_name);
		free(oid);
	}
}

int
smi_insert(struct oid *oid)
{
	struct oid		 key, *value;

	if ((oid->o_flags & OID_TABLE) && oid->o_get == NULL)
		fatalx("smi_insert: invalid MIB table");

	bzero(&key, sizeof(key));
	bcopy(&oid->o_id, &key.o_id, sizeof(struct ber_oid));
	value = RB_FIND(oidtree, &smi_oidtree, &key);
	if (value != NULL)
		return (-1);

	RB_INSERT(oidtree, &smi_oidtree, oid);
	return (0);
}

void
smi_mibtree(struct oid *oids)
{
	struct oid	*oid, *decl;
	size_t		 i;

	for (i = 0; oids[i].o_oid[0] != 0; i++) {
		oid = &oids[i];
		smi_oidlen(&oid->o_id);
		if (oid->o_name != NULL) {
			if ((oid->o_flags & OID_TABLE) && oid->o_get == NULL)
				fatalx("smi_mibtree: invalid MIB table");
			RB_INSERT(oidtree, &smi_oidtree, oid);
			RB_INSERT(keytree, &smi_keytree, oid);
			continue;
		}
		decl = RB_FIND(oidtree, &smi_oidtree, oid);
		if (decl == NULL)
			fatalx("smi_mibtree: undeclared MIB");
		decl->o_flags = oid->o_flags;
		decl->o_get = oid->o_get;
		decl->o_set = oid->o_set;
		decl->o_table = oid->o_table;
		decl->o_val = oid->o_val;
		decl->o_data = oid->o_data;
	}
}

int
smi_init(void)
{
	/* Initialize the Structure of Managed Information (SMI) */
	RB_INIT(&smi_oidtree);
	mib_init();
	return (0);
}

struct oid *
smi_find(struct oid *oid)
{
	return (RB_FIND(oidtree, &smi_oidtree, oid));
}

struct oid *
smi_findkey(char *name)
{
	struct oid	oid;
	if (name == NULL)
		return (NULL);
	oid.o_name = name;
	return (RB_FIND(keytree, &smi_keytree, &oid));
}

struct oid *
smi_next(struct oid *oid)
{
	return (RB_NEXT(oidtree, &smi_oidtree, oid));
}

struct oid *
smi_foreach(struct oid *oid, u_int flags)
{
	/*
	 * Traverse the tree of MIBs with the option to check
	 * for specific OID flags.
	 */
	if (oid == NULL) {
		oid = RB_MIN(oidtree, &smi_oidtree);
		if (oid == NULL)
			return (NULL);
		if (flags == 0 || (oid->o_flags & flags))
			return (oid);
	}
	for (;;) {
		oid = RB_NEXT(oidtree, &smi_oidtree, oid);
		if (oid == NULL)
			break;
		if (flags == 0 || (oid->o_flags & flags))
			return (oid);
	}

	return (oid);
}

#ifdef DEBUG
void
smi_debug_elements(struct ber_element *root)
{
	static int	 indent = 0;
	char		*value;
	int		 constructed;

	/* calculate lengths */
	ber_calc_len(root);

	switch (root->be_encoding) {
	case BER_TYPE_SEQUENCE:
	case BER_TYPE_SET:
		constructed = root->be_encoding;
		break;
	default:
		constructed = 0;
		break;
	}

	fprintf(stderr, "%*slen %lu ", indent, "", root->be_len);
	switch (root->be_class) {
	case BER_CLASS_UNIVERSAL:
		fprintf(stderr, "class: universal(%u) type: ", root->be_class);
		switch (root->be_type) {
		case BER_TYPE_EOC:
			fprintf(stderr, "end-of-content");
			break;
		case BER_TYPE_BOOLEAN:
			fprintf(stderr, "boolean");
			break;
		case BER_TYPE_INTEGER:
			fprintf(stderr, "integer");
			break;
		case BER_TYPE_BITSTRING:
			fprintf(stderr, "bit-string");
			break;
		case BER_TYPE_OCTETSTRING:
			fprintf(stderr, "octet-string");
			break;
		case BER_TYPE_NULL:
			fprintf(stderr, "null");
			break;
		case BER_TYPE_OBJECT:
			fprintf(stderr, "object");
			break;
		case BER_TYPE_ENUMERATED:
			fprintf(stderr, "enumerated");
			break;
		case BER_TYPE_SEQUENCE:
			fprintf(stderr, "sequence");
			break;
		case BER_TYPE_SET:
			fprintf(stderr, "set");
			break;
		}
		break;
	case BER_CLASS_APPLICATION:
		fprintf(stderr, "class: application(%u) type: ",
		    root->be_class);
		switch (root->be_type) {
		case SNMP_T_IPADDR:
			fprintf(stderr, "ipaddr");
			break;
		case SNMP_T_COUNTER32:
			fprintf(stderr, "counter32");
			break;
		case SNMP_T_GAUGE32:
			fprintf(stderr, "gauge32");
			break;
		case SNMP_T_TIMETICKS:
			fprintf(stderr, "timeticks");
			break;
		case SNMP_T_OPAQUE:
			fprintf(stderr, "opaque");
			break;
		case SNMP_T_COUNTER64:
			fprintf(stderr, "counter64");
			break;
		}
		break;
	case BER_CLASS_CONTEXT:
		fprintf(stderr, "class: context(%u) type: ",
		    root->be_class);
		switch (root->be_type) {
		case SNMP_C_GETREQ:
			fprintf(stderr, "getreq");
			break;
		case SNMP_C_GETNEXTREQ:
			fprintf(stderr, "nextreq");
			break;
		case SNMP_C_GETRESP:
			fprintf(stderr, "getresp");
			break;
		case SNMP_C_SETREQ:
			fprintf(stderr, "setreq");
			break;
		case SNMP_C_TRAP:
			fprintf(stderr, "trap");
			break;
		case SNMP_C_GETBULKREQ:
			fprintf(stderr, "getbulkreq");
			break;
		case SNMP_C_INFORMREQ:
			fprintf(stderr, "informreq");
			break;
		case SNMP_C_TRAPV2:
			fprintf(stderr, "trapv2");
			break;
		case SNMP_C_REPORT:
			fprintf(stderr, "report");
			break;
		}
		break;
	case BER_CLASS_PRIVATE:
		fprintf(stderr, "class: private(%u) type: ", root->be_class);
		break;
	default:
		fprintf(stderr, "class: <INVALID>(%u) type: ", root->be_class);
		break;
	}
	fprintf(stderr, "(%lu) encoding %lu ",
	    root->be_type, root->be_encoding);

	if ((value = smi_print_element(root)) == NULL)
		goto invalid;

	switch (root->be_encoding) {
	case BER_TYPE_BOOLEAN:
		fprintf(stderr, "%s", value);
		break;
	case BER_TYPE_INTEGER:
	case BER_TYPE_ENUMERATED:
		fprintf(stderr, "value %s", value);
		break;
	case BER_TYPE_BITSTRING:
		fprintf(stderr, "hexdump %s", value);
		break;
	case BER_TYPE_OBJECT:
		fprintf(stderr, "oid %s", value);
		break;
	case BER_TYPE_OCTETSTRING:
		if (root->be_class == BER_CLASS_APPLICATION &&
		    root->be_type == SNMP_T_IPADDR) {
			fprintf(stderr, "addr %s", value);
		} else {
			fprintf(stderr, "string %s", value);
		}
		break;
	case BER_TYPE_NULL:	/* no payload */
	case BER_TYPE_EOC:
	case BER_TYPE_SEQUENCE:
	case BER_TYPE_SET:
	default:
		fprintf(stderr, "%s", value);
		break;
	}

 invalid:
	if (value == NULL)
		fprintf(stderr, "<INVALID>");
	else
		free(value);
	fprintf(stderr, "\n");

	if (constructed)
		root->be_encoding = constructed;

	if (constructed && root->be_sub) {
		indent += 2;
		smi_debug_elements(root->be_sub);
		indent -= 2;
	}
	if (root->be_next)
		smi_debug_elements(root->be_next);
}
#endif

char *
smi_print_element(struct ber_element *root)
{
	char		*str = NULL, *buf, *p;
	size_t		 len, i;
	long long	 v;
	int		 d;
	struct ber_oid	 o;
	char		 strbuf[BUFSIZ];

	switch (root->be_encoding) {
	case BER_TYPE_BOOLEAN:
		if (ber_get_boolean(root, &d) == -1)
			goto fail;
		if (asprintf(&str, "%s(%d)", d ? "true" : "false", d) == -1)
			goto fail;
		break;
	case BER_TYPE_INTEGER:
	case BER_TYPE_ENUMERATED:
		if (ber_get_integer(root, &v) == -1)
			goto fail;
		if (asprintf(&str, "%lld", v) == -1)
			goto fail;
		break;
	case BER_TYPE_BITSTRING:
		if (ber_get_bitstring(root, (void *)&buf, &len) == -1)
			goto fail;
		if ((str = calloc(1, len * 2 + 1)) == NULL)
			goto fail;
		for (p = str, i = 0; i < len; i++) {
			snprintf(p, 3, "%02x", buf[i]);
			p += 2;
		}
		break;
	case BER_TYPE_OBJECT:
		if (ber_get_oid(root, &o) == -1)
			goto fail;
		if (asprintf(&str, "%s",
		    smi_oid2string(&o, strbuf, sizeof(strbuf), 0)) == -1)
			goto fail;
		break;
	case BER_TYPE_OCTETSTRING:
		if (ber_get_string(root, &buf) == -1)
			goto fail;
		if (root->be_class == BER_CLASS_APPLICATION &&
		    root->be_type == SNMP_T_IPADDR) {
			if (asprintf(&str, "%s",
			    inet_ntoa(*(struct in_addr *)buf)) == -1)
				goto fail;
		} else {
			if ((p = reallocarray(NULL, 4, root->be_len + 1)) == NULL)
				goto fail;
			strvisx(p, buf, root->be_len, VIS_NL);
			if (asprintf(&str, "\"%s\"", p) == -1) {
				free(p);
				goto fail;
			}
			free(p);
		}
		break;
	case BER_TYPE_NULL:	/* no payload */
	case BER_TYPE_EOC:
	case BER_TYPE_SEQUENCE:
	case BER_TYPE_SET:
	default:
		str = strdup("");
		break;
	}

	return (str);

 fail:
	free(str);
	return (NULL);
}

unsigned long
smi_application(struct ber_element *elm)
{
	if (elm->be_class != BER_CLASS_APPLICATION)
		return (BER_TYPE_OCTETSTRING);

	switch (elm->be_type) {
	case SNMP_T_IPADDR:
		return (BER_TYPE_OCTETSTRING);
	case SNMP_T_COUNTER32:
	case SNMP_T_GAUGE32:
	case SNMP_T_TIMETICKS:
	case SNMP_T_OPAQUE:
	case SNMP_T_COUNTER64:
		return (BER_TYPE_INTEGER);
	default:
		break;
	}
	return (BER_TYPE_OCTETSTRING);
}

int
smi_oid_cmp(struct oid *a, struct oid *b)
{
	size_t	 i;

	for (i = 0; i < MINIMUM(a->o_oidlen, b->o_oidlen); i++)
		if (a->o_oid[i] != b->o_oid[i])
			return (a->o_oid[i] - b->o_oid[i]);

	/*
	 * Return success if the matched object is a table
	 * or a MIB registered by a subagent
	 * (it will match any sub-elements)
	 */
	if ((b->o_flags & OID_TABLE ||
	    b->o_flags & OID_REGISTERED) &&
	    (a->o_flags & OID_KEY) == 0 &&
	    (a->o_oidlen > b->o_oidlen))
		return (0);

	return (a->o_oidlen - b->o_oidlen);
}

RB_GENERATE(oidtree, oid, o_element, smi_oid_cmp);

int
smi_key_cmp(struct oid *a, struct oid *b)
{
	if (a->o_name == NULL || b->o_name == NULL)
		return (-1);
	return (strcasecmp(a->o_name, b->o_name));
}

RB_GENERATE(keytree, oid, o_keyword, smi_key_cmp);


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1
2
3			/*
4			* Copyright (c) 2007, 2008 Reyk Floeter <reyk@openbsd.org>
5			*
6			* Permission to use, copy, modify, and distribute this software for any
7			* purpose with or without fee is hereby granted, provided that the above
8			* copyright notice and this permission notice appear in all copies.
9			*
10			* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11			* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12			* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13			* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14			* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15			* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16			* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17			*/
18
19			#include <sys/queue.h>
20			#include <sys/types.h>
21			#include <sys/stat.h>
22			#include <sys/socket.h>
23			#include <sys/un.h>
24			#include <sys/tree.h>
25			#include <sys/sysctl.h>
26
27			#include <net/if.h>
28			#include <net/if_dl.h>
29			#include <net/if_arp.h>
30			#include <net/if_media.h>
31			#include <net/route.h>
32			#include <netinet/in.h>
33			#include <netinet/if_ether.h>
34			#include <arpa/inet.h>
35
36			#include <stdlib.h>
37			#include <stdio.h>
38			#include <errno.h>
39			#include <event.h>
40			#include <fcntl.h>
41			#include <string.h>
42			#include <unistd.h>
43			#include <limits.h>
44			#include <pwd.h>
45			#include <vis.h>
46
47			#include "snmpd.h"
48			#include "mib.h"
49
50			#define MINIMUM(a, b) (((a) < (b)) ? (a) : (b))
51
52			RB_HEAD(oidtree, oid);
53			RB_PROTOTYPE(oidtree, oid, o_element, smi_oid_cmp);
54			struct oidtree smi_oidtree;
55
56			RB_HEAD(keytree, oid);
57			RB_PROTOTYPE(keytree, oid, o_keyword, smi_key_cmp);
58			struct keytree smi_keytree;
59
60			u_long
61			smi_getticks(void)
62			{
63			struct timeval now, run;
64			u_long ticks;
65
66			gettimeofday(&now, NULL);
67			if (timercmp(&now, &snmpd_env->sc_starttime, <=))
68			return (0);
69			timersub(&now, &snmpd_env->sc_starttime, &run);
70			ticks = run.tv_sec * 100;
71			if (run.tv_usec)
72			ticks += run.tv_usec / 10000;
73
74			return (ticks);
75			}
76
77			void
78			smi_oidlen(struct ber_oid *o)
79			{
80			size_t i;
81
82	✓✗✓✓	77032	for (i = 0; i < BER_MAX_OID_LEN && o->bo_id[i] != 0; i++)
83			;
84		2356	o->bo_n = i;
85		2356	}
86
87			void
88			smi_scalar_oidlen(struct ber_oid *o)
89			{
90			smi_oidlen(o);
91
92			/* Append .0. */
93			if (o->bo_n < BER_MAX_OID_LEN)
94			o->bo_n++;
95			}
96
97			char *
98			smi_oid2string(struct ber_oid o, char buf, size_t len, size_t skip)
99			{
100			char str[256];
101			struct oid *value, key;
102			size_t i, lookup = 1;
103
104			bzero(buf, len);
105			bzero(&key, sizeof(key));
106			bcopy(o, &key.o_id, sizeof(struct ber_oid));
107			key.o_flags \|= OID_KEY; /* do not match wildcards */
108
109			if (snmpd_env->sc_flags & SNMPD_F_NONAMES)
110			lookup = 0;
111
112			for (i = 0; i < o->bo_n; i++) {
113			key.o_oidlen = i + 1;
114			if (lookup && skip > i)
115			continue;
116			if (lookup &&
117			(value = RB_FIND(oidtree, &smi_oidtree, &key)) != NULL)
118			snprintf(str, sizeof(str), "%s", value->o_name);
119			else
120			snprintf(str, sizeof(str), "%d", key.o_oid[i]);
121			strlcat(buf, str, len);
122			if (i < (o->bo_n - 1))
123			strlcat(buf, ".", len);
124			}
125
126			return (buf);
127			}
128
129			int
130			smi_string2oid(const char oidstr, struct ber_oid o)
131			{
132			char sp, p, str[BUFSIZ];
133			const char *errstr;
134			struct oid *oid;
135			struct ber_oid ko;
136
137			if (strlcpy(str, oidstr, sizeof(str)) >= sizeof(str))
138			return (-1);
139			bzero(o, sizeof(*o));
140
141			/*
142			* Parse OID strings in the common form n.n.n or n-n-n.
143			* Based on ber_string2oid with additional support for symbolic names.
144			*/
145			for (p = sp = str; p != NULL; sp = p) {
146			if ((p = strpbrk(p, ".-")) != NULL)
147			*p++ = '\0';
148			if ((oid = smi_findkey(sp)) != NULL) {
149			bcopy(&oid->o_id, &ko, sizeof(ko));
150			if (o->bo_n && ber_oid_cmp(o, &ko) != 2)
151			return (-1);
152			bcopy(&ko, o, sizeof(*o));
153			errstr = NULL;
154			} else {
155			o->bo_id[o->bo_n++] =
156			strtonum(sp, 0, UINT_MAX, &errstr);
157			}
158			if (errstr \|\| o->bo_n > BER_MAX_OID_LEN)
159			return (-1);
160			}
161
162			return (0);
163			}
164
165			void
166			smi_delete(struct oid *oid)
167			{
168			struct oid key, *value;
169
170			bzero(&key, sizeof(key));
171			bcopy(&oid->o_id, &key.o_id, sizeof(struct ber_oid));
172			if ((value = RB_FIND(oidtree, &smi_oidtree, &key)) != NULL &&
173			value == oid)
174			RB_REMOVE(oidtree, &smi_oidtree, value);
175
176			free(oid->o_data);
177			if (oid->o_flags & OID_DYNAMIC) {
178			free(oid->o_name);
179			free(oid);
180			}
181			}
182
183			int
184			smi_insert(struct oid *oid)
185			{
186			struct oid key, *value;
187
188			if ((oid->o_flags & OID_TABLE) && oid->o_get == NULL)
189			fatalx("smi_insert: invalid MIB table");
190
191			bzero(&key, sizeof(key));
192			bcopy(&oid->o_id, &key.o_id, sizeof(struct ber_oid));
193			value = RB_FIND(oidtree, &smi_oidtree, &key);
194			if (value != NULL)
195			return (-1);
196
197			RB_INSERT(oidtree, &smi_oidtree, oid);
198			return (0);
199			}
200
201			void
202			smi_mibtree(struct oid *oids)
203			{
204			struct oid oid, decl;
205			size_t i;
206
207	✓✓	4724	for (i = 0; oids[i].o_oid[0] != 0; i++) {
208			oid = &oids[i];
209		2356	smi_oidlen(&oid->o_id);
210	✓✗	2356	if (oid->o_name != NULL) {
211	✗✓✗✗	2356	if ((oid->o_flags & OID_TABLE) && oid->o_get == NULL)
212			fatalx("smi_mibtree: invalid MIB table");
213		2356	RB_INSERT(oidtree, &smi_oidtree, oid);
214		2356	RB_INSERT(keytree, &smi_keytree, oid);
215		2356	continue;
216			}
217			decl = RB_FIND(oidtree, &smi_oidtree, oid);
218			if (decl == NULL)
219			fatalx("smi_mibtree: undeclared MIB");
220			decl->o_flags = oid->o_flags;
221			decl->o_get = oid->o_get;
222			decl->o_set = oid->o_set;
223			decl->o_table = oid->o_table;
224			decl->o_val = oid->o_val;
225			decl->o_data = oid->o_data;
226			}
227		4	}
228
229			int
230			smi_init(void)
231			{
232			/* Initialize the Structure of Managed Information (SMI) */
233		8	RB_INIT(&smi_oidtree);
234		4	mib_init();
235		4	return (0);
236			}
237
238			struct oid *
239			smi_find(struct oid *oid)
240			{
241			return (RB_FIND(oidtree, &smi_oidtree, oid));
242			}
243
244			struct oid *
245			smi_findkey(char *name)
246			{
247			struct oid oid;
248			if (name == NULL)
249			return (NULL);
250			oid.o_name = name;
251			return (RB_FIND(keytree, &smi_keytree, &oid));
252			}
253
254			struct oid *
255			smi_next(struct oid *oid)
256			{
257			return (RB_NEXT(oidtree, &smi_oidtree, oid));
258			}
259
260			struct oid *
261			smi_foreach(struct oid *oid, u_int flags)
262			{
263			/*
264			* Traverse the tree of MIBs with the option to check
265			* for specific OID flags.
266			*/
267			if (oid == NULL) {
268			oid = RB_MIN(oidtree, &smi_oidtree);
269			if (oid == NULL)
270			return (NULL);
271			if (flags == 0 \|\| (oid->o_flags & flags))
272			return (oid);
273			}
274			for (;;) {
275			oid = RB_NEXT(oidtree, &smi_oidtree, oid);
276			if (oid == NULL)
277			break;
278			if (flags == 0 \|\| (oid->o_flags & flags))
279			return (oid);
280			}
281
282			return (oid);
283			}
284
285			#ifdef DEBUG
286			void
287			smi_debug_elements(struct ber_element *root)
288			{
289			static int indent = 0;
290			char *value;
291			int constructed;
292
293			/* calculate lengths */
294			ber_calc_len(root);
295
296			switch (root->be_encoding) {
297			case BER_TYPE_SEQUENCE:
298			case BER_TYPE_SET:
299			constructed = root->be_encoding;
300			break;
301			default:
302			constructed = 0;
303			break;
304			}
305
306			fprintf(stderr, "%*slen %lu ", indent, "", root->be_len);
307			switch (root->be_class) {
308			case BER_CLASS_UNIVERSAL:
309			fprintf(stderr, "class: universal(%u) type: ", root->be_class);
310			switch (root->be_type) {
311			case BER_TYPE_EOC:
312			fprintf(stderr, "end-of-content");
313			break;
314			case BER_TYPE_BOOLEAN:
315			fprintf(stderr, "boolean");
316			break;
317			case BER_TYPE_INTEGER:
318			fprintf(stderr, "integer");
319			break;
320			case BER_TYPE_BITSTRING:
321			fprintf(stderr, "bit-string");
322			break;
323			case BER_TYPE_OCTETSTRING:
324			fprintf(stderr, "octet-string");
325			break;
326			case BER_TYPE_NULL:
327			fprintf(stderr, "null");
328			break;
329			case BER_TYPE_OBJECT:
330			fprintf(stderr, "object");
331			break;
332			case BER_TYPE_ENUMERATED:
333			fprintf(stderr, "enumerated");
334			break;
335			case BER_TYPE_SEQUENCE:
336			fprintf(stderr, "sequence");
337			break;
338			case BER_TYPE_SET:
339			fprintf(stderr, "set");
340			break;
341			}
342			break;
343			case BER_CLASS_APPLICATION:
344			fprintf(stderr, "class: application(%u) type: ",
345			root->be_class);
346			switch (root->be_type) {
347			case SNMP_T_IPADDR:
348			fprintf(stderr, "ipaddr");
349			break;
350			case SNMP_T_COUNTER32:
351			fprintf(stderr, "counter32");
352			break;
353			case SNMP_T_GAUGE32:
354			fprintf(stderr, "gauge32");
355			break;
356			case SNMP_T_TIMETICKS:
357			fprintf(stderr, "timeticks");
358			break;
359			case SNMP_T_OPAQUE:
360			fprintf(stderr, "opaque");
361			break;
362			case SNMP_T_COUNTER64:
363			fprintf(stderr, "counter64");
364			break;
365			}
366			break;
367			case BER_CLASS_CONTEXT:
368			fprintf(stderr, "class: context(%u) type: ",
369			root->be_class);
370			switch (root->be_type) {
371			case SNMP_C_GETREQ:
372			fprintf(stderr, "getreq");
373			break;
374			case SNMP_C_GETNEXTREQ:
375			fprintf(stderr, "nextreq");
376			break;
377			case SNMP_C_GETRESP:
378			fprintf(stderr, "getresp");
379			break;
380			case SNMP_C_SETREQ:
381			fprintf(stderr, "setreq");
382			break;
383			case SNMP_C_TRAP:
384			fprintf(stderr, "trap");
385			break;
386			case SNMP_C_GETBULKREQ:
387			fprintf(stderr, "getbulkreq");
388			break;
389			case SNMP_C_INFORMREQ:
390			fprintf(stderr, "informreq");
391			break;
392			case SNMP_C_TRAPV2:
393			fprintf(stderr, "trapv2");
394			break;
395			case SNMP_C_REPORT:
396			fprintf(stderr, "report");
397			break;
398			}
399			break;
400			case BER_CLASS_PRIVATE:
401			fprintf(stderr, "class: private(%u) type: ", root->be_class);
402			break;
403			default:
404			fprintf(stderr, "class: <INVALID>(%u) type: ", root->be_class);
405			break;
406			}
407			fprintf(stderr, "(%lu) encoding %lu ",
408			root->be_type, root->be_encoding);
409
410			if ((value = smi_print_element(root)) == NULL)
411			goto invalid;
412
413			switch (root->be_encoding) {
414			case BER_TYPE_BOOLEAN:
415			fprintf(stderr, "%s", value);
416			break;
417			case BER_TYPE_INTEGER:
418			case BER_TYPE_ENUMERATED:
419			fprintf(stderr, "value %s", value);
420			break;
421			case BER_TYPE_BITSTRING:
422			fprintf(stderr, "hexdump %s", value);
423			break;
424			case BER_TYPE_OBJECT:
425			fprintf(stderr, "oid %s", value);
426			break;
427			case BER_TYPE_OCTETSTRING:
428			if (root->be_class == BER_CLASS_APPLICATION &&
429			root->be_type == SNMP_T_IPADDR) {
430			fprintf(stderr, "addr %s", value);
431			} else {
432			fprintf(stderr, "string %s", value);
433			}
434			break;
435			case BER_TYPE_NULL: /* no payload */
436			case BER_TYPE_EOC:
437			case BER_TYPE_SEQUENCE:
438			case BER_TYPE_SET:
439			default:
440			fprintf(stderr, "%s", value);
441			break;
442			}
443
444			invalid:
445			if (value == NULL)
446			fprintf(stderr, "<INVALID>");
447			else
448			free(value);
449			fprintf(stderr, "\n");
450
451			if (constructed)
452			root->be_encoding = constructed;
453
454			if (constructed && root->be_sub) {
455			indent += 2;
456			smi_debug_elements(root->be_sub);
457			indent -= 2;
458			}
459			if (root->be_next)
460			smi_debug_elements(root->be_next);
461			}
462			#endif
463
464			char *
465			smi_print_element(struct ber_element *root)
466			{
467			char str = NULL, buf, *p;
468			size_t len, i;
469			long long v;
470			int d;
471			struct ber_oid o;
472			char strbuf[BUFSIZ];
473
474			switch (root->be_encoding) {
475			case BER_TYPE_BOOLEAN:
476			if (ber_get_boolean(root, &d) == -1)
477			goto fail;
478			if (asprintf(&str, "%s(%d)", d ? "true" : "false", d) == -1)
479			goto fail;
480			break;
481			case BER_TYPE_INTEGER:
482			case BER_TYPE_ENUMERATED:
483			if (ber_get_integer(root, &v) == -1)
484			goto fail;
485			if (asprintf(&str, "%lld", v) == -1)
486			goto fail;
487			break;
488			case BER_TYPE_BITSTRING:
489			if (ber_get_bitstring(root, (void *)&buf, &len) == -1)
490			goto fail;
491			if ((str = calloc(1, len * 2 + 1)) == NULL)
492			goto fail;
493			for (p = str, i = 0; i < len; i++) {
494			snprintf(p, 3, "%02x", buf[i]);
495			p += 2;
496			}
497			break;
498			case BER_TYPE_OBJECT:
499			if (ber_get_oid(root, &o) == -1)
500			goto fail;
501			if (asprintf(&str, "%s",
502			smi_oid2string(&o, strbuf, sizeof(strbuf), 0)) == -1)
503			goto fail;
504			break;
505			case BER_TYPE_OCTETSTRING:
506			if (ber_get_string(root, &buf) == -1)
507			goto fail;
508			if (root->be_class == BER_CLASS_APPLICATION &&
509			root->be_type == SNMP_T_IPADDR) {
510			if (asprintf(&str, "%s",
511			inet_ntoa((struct in_addr )buf)) == -1)
512			goto fail;
513			} else {
514			if ((p = reallocarray(NULL, 4, root->be_len + 1)) == NULL)
515			goto fail;
516			strvisx(p, buf, root->be_len, VIS_NL);
517			if (asprintf(&str, "\"%s\"", p) == -1) {
518			free(p);
519			goto fail;
520			}
521			free(p);
522			}
523			break;
524			case BER_TYPE_NULL: /* no payload */
525			case BER_TYPE_EOC:
526			case BER_TYPE_SEQUENCE:
527			case BER_TYPE_SET:
528			default:
529			str = strdup("");
530			break;
531			}
532
533			return (str);
534
535			fail:
536			free(str);
537			return (NULL);
538			}
539
540			unsigned long
541			smi_application(struct ber_element *elm)
542			{
543			if (elm->be_class != BER_CLASS_APPLICATION)
544			return (BER_TYPE_OCTETSTRING);
545
546			switch (elm->be_type) {
547			case SNMP_T_IPADDR:
548			return (BER_TYPE_OCTETSTRING);
549			case SNMP_T_COUNTER32:
550			case SNMP_T_GAUGE32:
551			case SNMP_T_TIMETICKS:
552			case SNMP_T_OPAQUE:
553			case SNMP_T_COUNTER64:
554			return (BER_TYPE_INTEGER);
555			default:
556			break;
557			}
558			return (BER_TYPE_OCTETSTRING);
559			}
560
561			int
562			smi_oid_cmp(struct oid a, struct oid b)
563			{
564			size_t i;
565
566	✓✓	464876	for (i = 0; i < MINIMUM(a->o_oidlen, b->o_oidlen); i++)
567	✓✓	216204	if (a->o_oid[i] != b->o_oid[i])
568		26360	return (a->o_oid[i] - b->o_oid[i]);
569
570			/*
571			* Return success if the matched object is a table
572			* or a MIB registered by a subagent
573			* (it will match any sub-elements)
574			*/
575	✓✗✗✗	2036	if ((b->o_flags & OID_TABLE \|\|
576	✗✓	2036	b->o_flags & OID_REGISTERED) &&
577			(a->o_flags & OID_KEY) == 0 &&
578			(a->o_oidlen > b->o_oidlen))
579			return (0);
580
581		2036	return (a->o_oidlen - b->o_oidlen);
582		28396	}
583
584	✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✓ ✓✓✓✗ ✓✓✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✗✓✓ ✓✗✓✓ ✓✓✓✓ ✓✓✓✗ ✓✓✓✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗	205136	RB_GENERATE(oidtree, oid, o_element, smi_oid_cmp);
585
586			int
587			smi_key_cmp(struct oid a, struct oid b)
588			{
589	✓✗✗✓	65364	if (a->o_name == NULL \|\| b->o_name == NULL)
590			return (-1);
591		21788	return (strcasecmp(a->o_name, b->o_name));
592		21788	}
593
594	✓✓✓✓ ✓✗✓✓ ✗✗✗✗ ✗✗✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✓ ✓✗✓✓ ✓✓✓✓ ✓✓✓✓ ✓✓✓✗ ✓✓✓✓ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗ ✗✗✗✗	150056	RB_GENERATE(keytree, oid, o_keyword, smi_key_cmp);