1/*
2 * Copyright (c) 2001-2003
3 *	Fraunhofer Institute for Open Communication Systems (FhG Fokus).
4 *	All rights reserved.
5 *
6 * Author: Harti Brandt <harti@freebsd.org>
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 *    notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 *    notice, this list of conditions and the following disclaimer in the
15 *    documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 * $Begemot: bsnmp/snmp_mibII/mibII_route.c,v 1.9 2005/10/06 07:15:00 brandt_h Exp $
30 *
31 * Routing table
32 */
33
34#ifdef HAVE_SYS_TREE_H
35#include <sys/tree.h>
36#else
37#include "tree.h"
38#endif
39
40#include "mibII.h"
41#include "mibII_oid.h"
42
43struct sroute {
44	RB_ENTRY(sroute) link;
45	uint32_t	ifindex;
46	uint8_t		index[13];
47	uint8_t		type;
48	uint8_t		proto;
49};
50RB_HEAD(sroutes, sroute) sroutes = RB_INITIALIZER(&sroutes);
51
52RB_PROTOTYPE(sroutes, sroute, link, sroute_compare);
53
54#define	ROUTE_UPDATE_INTERVAL	(100 * 60 * 10)	/* 10 min */
55static uint64_t route_tick;
56static u_int route_total;
57
58/*
59 * Compare two routes
60 */
61static int
62sroute_compare(struct sroute *s1, struct sroute *s2)
63{
64
65	return (memcmp(s1->index, s2->index, 13));
66}
67
68static void
69sroute_index_append(struct asn_oid *oid, u_int sub, const struct sroute *s)
70{
71	int i;
72
73	oid->len = sub + 13;
74	for (i = 0; i < 13; i++)
75		oid->subs[sub + i] = s->index[i];
76}
77
78#if 0
79static void
80sroute_print(const struct sroute *r)
81{
82	u_int i;
83
84	for (i = 0; i < 13 - 1; i++)
85		printf("%u.", r->index[i]);
86	printf("%u proto=%u type=%u", r->index[i], r->proto, r->type);
87}
88#endif
89
90/*
91 * process routing message
92 */
93void
94mib_sroute_process(struct rt_msghdr *rtm, struct sockaddr *gw,
95    struct sockaddr *dst, struct sockaddr *mask)
96{
97	struct sockaddr_in *in_dst, *in_gw;
98	struct in_addr in_mask;
99	struct mibif *ifp;
100	struct sroute key;
101	struct sroute *r, *r1;
102	in_addr_t ha;
103
104	if (dst == NULL || gw == NULL || dst->sa_family != AF_INET ||
105	    gw->sa_family != AF_INET)
106		return;
107
108	in_dst = (struct sockaddr_in *)(void *)dst;
109	in_gw = (struct sockaddr_in *)(void *)gw;
110
111	if (rtm->rtm_flags & RTF_HOST)
112		in_mask.s_addr = 0xffffffff;
113	else if (mask == NULL || mask->sa_len == 0)
114		in_mask.s_addr = 0;
115	else
116		in_mask = ((struct sockaddr_in *)(void *)mask)->sin_addr;
117
118	/* build the index */
119	ha = ntohl(in_dst->sin_addr.s_addr);
120	key.index[0] = (ha >> 24) & 0xff;
121	key.index[1] = (ha >> 16) & 0xff;
122	key.index[2] = (ha >>  8) & 0xff;
123	key.index[3] = (ha >>  0) & 0xff;
124
125	ha = ntohl(in_mask.s_addr);
126	key.index[4] = (ha >> 24) & 0xff;
127	key.index[5] = (ha >> 16) & 0xff;
128	key.index[6] = (ha >>  8) & 0xff;
129	key.index[7] = (ha >>  0) & 0xff;
130
131	/* ToS */
132	key.index[8] = 0;
133
134	ha = ntohl(in_gw->sin_addr.s_addr);
135	key.index[9] = (ha >> 24) & 0xff;
136	key.index[10] = (ha >> 16) & 0xff;
137	key.index[11] = (ha >>  8) & 0xff;
138	key.index[12] = (ha >>  0) & 0xff;
139
140	if (rtm->rtm_type == RTM_DELETE) {
141		r = RB_FIND(sroutes, &sroutes, &key);
142		if (r == 0) {
143#ifdef DEBUG_ROUTE
144			syslog(LOG_WARNING, "%s: DELETE: %u.%u.%u.%u "
145			    "%u.%u.%u.%u %u %u.%u.%u.%u not found", __func__,
146			    key.index[0], key.index[1], key.index[2],
147			    key.index[3], key.index[4], key.index[5],
148			    key.index[6], key.index[7], key.index[8],
149			    key.index[9], key.index[10], key.index[11],
150			    key.index[12]);
151#endif
152			return;
153		}
154		RB_REMOVE(sroutes, &sroutes, r);
155		free(r);
156		route_total--;
157#ifdef DEBUG_ROUTE
158		printf("%s: DELETE: %u.%u.%u.%u "
159		    "%u.%u.%u.%u %u %u.%u.%u.%u\n", __func__,
160		    key.index[0], key.index[1], key.index[2],
161		    key.index[3], key.index[4], key.index[5],
162		    key.index[6], key.index[7], key.index[8],
163		    key.index[9], key.index[10], key.index[11],
164		    key.index[12]);
165#endif
166		return;
167	}
168
169	/* GET or ADD */
170	ifp = NULL;
171	if ((ifp = mib_find_if_sys(rtm->rtm_index)) == NULL) {
172		if (rtm->rtm_type == RTM_ADD) {
173			/* make it a get so the kernel fills the index */
174			mib_send_rtmsg(rtm, gw, dst, mask);
175			return;
176		}
177		mib_iflist_bad = 1;
178	}
179
180	if ((r = malloc(sizeof(*r))) == NULL) {
181		syslog(LOG_ERR, "%m");
182		return;
183	}
184
185	memcpy(r->index, key.index, sizeof(r->index));
186	r->ifindex = (ifp == NULL) ? 0 : ifp->index;
187
188	r->type = (rtm->rtm_flags & RTF_REJECT) ? 2 : 4;
189
190	/* cannot really know, what protocol it runs */
191	r->proto = (rtm->rtm_flags & RTF_LOCAL) ? 2 :
192	    (rtm->rtm_flags & RTF_STATIC) ? 3 :
193	    (rtm->rtm_flags & RTF_DYNAMIC) ? 4 : 10;
194
195	r1 = RB_INSERT(sroutes, &sroutes, r);
196	if (r1 != NULL) {
197#ifdef DEBUG_ROUTE
198		syslog(LOG_WARNING, "%s: %u.%u.%u.%u "
199		    "%u.%u.%u.%u %u %u.%u.%u.%u duplicate route", __func__,
200		    key.index[0], key.index[1], key.index[2],
201		    key.index[3], key.index[4], key.index[5],
202		    key.index[6], key.index[7], key.index[8],
203		    key.index[9], key.index[10], key.index[11],
204		    key.index[12]);
205#endif
206		r1->ifindex = r->ifindex;
207		r1->type = r->type;
208		r1->proto = r->proto;
209		free(r);
210		return;
211	}
212
213	route_total++;
214#ifdef DEBUG_ROUTE
215	printf("%s: ADD/GET: %u.%u.%u.%u "
216	    "%u.%u.%u.%u %u %u.%u.%u.%u\n", __func__,
217	    key.index[0], key.index[1], key.index[2],
218	    key.index[3], key.index[4], key.index[5],
219	    key.index[6], key.index[7], key.index[8],
220	    key.index[9], key.index[10], key.index[11],
221	    key.index[12]);
222#endif
223}
224
225int
226mib_fetch_route(void)
227{
228	u_char *rtab, *next;
229	size_t len;
230	struct sroute *r, *r1;
231	struct rt_msghdr *rtm;
232	struct sockaddr *addrs[RTAX_MAX];
233
234	if (route_tick != 0 && route_tick + ROUTE_UPDATE_INTERVAL > this_tick)
235		return (0);
236
237	/*
238	 * Remove all routes
239	 */
240	r = RB_MIN(sroutes, &sroutes);
241	while (r != NULL) {
242		r1 = RB_NEXT(sroutes, &sroutes, r);
243		RB_REMOVE(sroutes, &sroutes, r);
244		free(r);
245		r = r1;
246	}
247	route_total = 0;
248
249	if ((rtab = mib_fetch_rtab(AF_INET, NET_RT_DUMP, 0, &len)) == NULL)
250		return (-1);
251
252	next = rtab;
253	for (next = rtab; next < rtab + len; next += rtm->rtm_msglen) {
254		rtm = (struct rt_msghdr *)(void *)next;
255		if (rtm->rtm_type != RTM_GET ||
256		    !(rtm->rtm_flags & RTF_UP))
257			continue;
258		mib_extract_addrs(rtm->rtm_addrs, (u_char *)(rtm + 1), addrs);
259
260
261		mib_sroute_process(rtm, addrs[RTAX_GATEWAY], addrs[RTAX_DST],
262		    addrs[RTAX_NETMASK]);
263	}
264
265#if 0
266	u_int n = 0;
267	r = RB_MIN(sroutes, &sroutes);
268	while (r != NULL) {
269		printf("%u: ", n++);
270		sroute_print(r);
271		printf("\n");
272		r = RB_NEXT(sroutes, &sroutes, r);
273	}
274#endif
275	free(rtab);
276	route_tick = get_ticks();
277
278	return (0);
279}
280
281/**
282 * Find a route in the table.
283 */
284static struct sroute *
285sroute_get(const struct asn_oid *oid, u_int sub)
286{
287	struct sroute key;
288	int i;
289
290	if (oid->len - sub != 13)
291		return (NULL);
292	for (i = 0; i < 13; i++)
293		key.index[i] = oid->subs[sub + i];
294	return (RB_FIND(sroutes, &sroutes, &key));
295}
296
297/**
298 * Find next route in the table. There is no such RB_ macro, so must
299 * dig into the innards of the RB stuff.
300 */
301static struct sroute *
302sroute_getnext(struct asn_oid *oid, u_int sub)
303{
304	u_int i;
305	int comp;
306	struct sroute key;
307	struct sroute *best;
308	struct sroute *s;
309
310	/*
311	 * We now, that the OID is at least the tableEntry OID. If it is,
312	 * the user wants the first route.
313	 */
314	if (oid->len == sub)
315		return (RB_MIN(sroutes, &sroutes));
316
317	/*
318	 * This is also true for any index that consists of zeros and is
319	 * shorter than the full index.
320	 */
321	if (oid->len < sub + 13) {
322		for (i = sub; i < oid->len; i++)
323			if (oid->subs[i] != 0)
324				break;
325		if (i == oid->len)
326			return (RB_MIN(sroutes, &sroutes));
327
328		/*
329		 * Now if the index is too short, we fill it with zeros and then
330		 * subtract one from the index. We can do this, because we now,
331		 * that there is at least one index element that is not zero.
332		 */
333		for (i = oid->len; i < sub + 13; i++)
334			oid->subs[i] = 0;
335
336		for (i = sub + 13 - 1; i >= sub; i--) {
337			if (oid->subs[i] != 0) {
338				oid->subs[i]--;
339				break;
340			}
341			oid->subs[i] = ASN_MAXID;
342		}
343		oid->len = sub + 13;
344	}
345
346	/* build the index */
347	for (i = sub; i < sub + 13; i++)
348		key.index[i - sub] = oid->subs[i];
349
350	/* now find the element */
351	best = NULL;
352	s = RB_ROOT(&sroutes);
353
354	while (s != NULL) {
355		comp = sroute_compare(&key, s);
356		if (comp >= 0) {
357			/* The current element is smaller than what we search.
358			 * Forget about it and move to the right subtree. */
359			s = RB_RIGHT(s, link);
360			continue;
361		}
362		/* the current element is larger than what we search.
363		 * forget about the right subtree (its even larger), but
364		 * the current element may be what we need. */
365		if (best == NULL || sroute_compare(s, best) < 0)
366			/* this one's better */
367			best = s;
368
369		s = RB_LEFT(s, link);
370	}
371	return (best);
372}
373
374/*
375 * Table
376 */
377int
378op_route_table(struct snmp_context *ctx __unused, struct snmp_value *value,
379    u_int sub, u_int iidx __unused, enum snmp_op op)
380{
381	struct sroute *r;
382
383	if (mib_fetch_route() == -1)
384		return (SNMP_ERR_GENERR);
385
386	switch (op) {
387
388	  case SNMP_OP_GETNEXT:
389		if ((r = sroute_getnext(&value->var, sub)) == NULL)
390			return (SNMP_ERR_NOSUCHNAME);
391		sroute_index_append(&value->var, sub, r);
392		break;
393
394	  case SNMP_OP_GET:
395		if ((r = sroute_get(&value->var, sub)) == NULL)
396			return (SNMP_ERR_NOSUCHNAME);
397		break;
398
399	  case SNMP_OP_SET:
400		if ((r = sroute_get(&value->var, sub)) == NULL)
401			return (SNMP_ERR_NOSUCHNAME);
402		return (SNMP_ERR_NOT_WRITEABLE);
403
404	  case SNMP_OP_ROLLBACK:
405	  case SNMP_OP_COMMIT:
406		abort();
407
408	  default:
409		abort();
410	}
411
412	switch (value->var.subs[sub - 1]) {
413
414	  case LEAF_ipCidrRouteDest:
415		value->v.ipaddress[0] = r->index[0];
416		value->v.ipaddress[1] = r->index[1];
417		value->v.ipaddress[2] = r->index[2];
418		value->v.ipaddress[3] = r->index[3];
419		break;
420
421	  case LEAF_ipCidrRouteMask:
422		value->v.ipaddress[0] = r->index[4];
423		value->v.ipaddress[1] = r->index[5];
424		value->v.ipaddress[2] = r->index[6];
425		value->v.ipaddress[3] = r->index[7];
426		break;
427
428	  case LEAF_ipCidrRouteTos:
429		value->v.integer = r->index[8];
430		break;
431
432	  case LEAF_ipCidrRouteNextHop:
433		value->v.ipaddress[0] = r->index[9];
434		value->v.ipaddress[1] = r->index[10];
435		value->v.ipaddress[2] = r->index[11];
436		value->v.ipaddress[3] = r->index[12];
437		break;
438
439	  case LEAF_ipCidrRouteIfIndex:
440		value->v.integer = r->ifindex;
441		break;
442
443	  case LEAF_ipCidrRouteType:
444		value->v.integer = r->type;
445		break;
446
447	  case LEAF_ipCidrRouteProto:
448		value->v.integer = r->proto;
449		break;
450
451	  case LEAF_ipCidrRouteAge:
452		value->v.integer = 0;
453		break;
454
455	  case LEAF_ipCidrRouteInfo:
456		value->v.oid = oid_zeroDotZero;
457		break;
458
459	  case LEAF_ipCidrRouteNextHopAS:
460		value->v.integer = 0;
461		break;
462
463	  case LEAF_ipCidrRouteMetric1:
464	  case LEAF_ipCidrRouteMetric2:
465	  case LEAF_ipCidrRouteMetric3:
466	  case LEAF_ipCidrRouteMetric4:
467	  case LEAF_ipCidrRouteMetric5:
468		value->v.integer = -1;
469		break;
470
471	  case LEAF_ipCidrRouteStatus:
472		value->v.integer = 1;
473		break;
474	}
475	return (SNMP_ERR_NOERROR);
476}
477
478/*
479 * scalars
480 */
481int
482op_route(struct snmp_context *ctx __unused, struct snmp_value *value,
483    u_int sub, u_int iidx __unused, enum snmp_op op)
484{
485	switch (op) {
486
487	  case SNMP_OP_GETNEXT:
488		abort();
489
490	  case SNMP_OP_GET:
491		break;
492
493	  case SNMP_OP_SET:
494		return (SNMP_ERR_NOT_WRITEABLE);
495
496	  case SNMP_OP_ROLLBACK:
497	  case SNMP_OP_COMMIT:
498		abort();
499	}
500
501	if (mib_fetch_route() == -1)
502		return (SNMP_ERR_GENERR);
503
504	switch (value->var.subs[sub - 1]) {
505
506	  case LEAF_ipCidrRouteNumber:
507		value->v.uint32 = route_total;
508		break;
509
510	}
511	return (SNMP_ERR_NOERROR);
512}
513
514RB_GENERATE(sroutes, sroute, link, sroute_compare);
515