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: mibII.c 516 2006-10-27 15:54:02Z brandt_h $
30 *
31 * Implementation of the standard interfaces and ip MIB.
32 */
33 #include "mibII.h"
34 #include "mibII_oid.h"
35 #include <net/if.h>
36 #include <net/if_types.h>
37
38
39 /*****************************/
40
41 /* our module */
42 static struct lmodule *module;
43
44 /* routing socket */
45 static int route;
46 static void *route_fd;
47
48 /* if-index allocator */
49 static uint32_t next_if_index = 1;
50
51 /* currently fetching the arp table */
52 static int in_update_arp;
53
54 /* OR registrations */
55 static u_int ifmib_reg;
56 static u_int ipmib_reg;
57 static u_int tcpmib_reg;
58 static u_int udpmib_reg;
59 static u_int ipForward_reg;
60
61 /*****************************/
62
63 /* list of all IP addresses */
64 struct mibifa_list mibifa_list = TAILQ_HEAD_INITIALIZER(mibifa_list);
65
66 /* list of all interfaces */
67 struct mibif_list mibif_list = TAILQ_HEAD_INITIALIZER(mibif_list);
68
69 /* list of dynamic interface names */
70 struct mibdynif_list mibdynif_list = SLIST_HEAD_INITIALIZER(mibdynif_list);
71
72 /* list of all interface index mappings */
73 struct mibindexmap_list mibindexmap_list = STAILQ_HEAD_INITIALIZER(mibindexmap_list);
74
75 /* list of all stacking entries */
76 struct mibifstack_list mibifstack_list = TAILQ_HEAD_INITIALIZER(mibifstack_list);
77
78 /* list of all receive addresses */
79 struct mibrcvaddr_list mibrcvaddr_list = TAILQ_HEAD_INITIALIZER(mibrcvaddr_list);
80
81 /* list of all NetToMedia entries */
82 struct mibarp_list mibarp_list = TAILQ_HEAD_INITIALIZER(mibarp_list);
83
84 /* number of interfaces */
85 int32_t mib_if_number;
86
87 /* last change of table */
88 uint64_t mib_iftable_last_change;
89
90 /* last change of stack table */
91 uint64_t mib_ifstack_last_change;
92
93 /* if this is set, one of our lists may be bad. refresh them when idle */
94 int mib_iflist_bad;
95
96 /* network socket */
97 int mib_netsock;
98
99 /* last time refreshed */
100 uint64_t mibarpticks;
101
102 /* info on system clocks */
103 struct clockinfo clockinfo;
104
105 /* list of all New if registrations */
106 static struct newifreg_list newifreg_list = TAILQ_HEAD_INITIALIZER(newifreg_list);
107
108 /* baud rate of fastest interface */
109 uint64_t mibif_maxspeed;
110
111 /* user-forced update interval */
112 u_int mibif_force_hc_update_interval;
113
114 /* current update interval */
115 u_int mibif_hc_update_interval;
116
117 /* HC update timer handle */
118 static void *hc_update_timer;
119
120 /* Idle poll timer */
121 static void *mibII_poll_timer;
122
123 /* interfaces' data poll interval */
124 u_int mibII_poll_ticks;
125
126 /* Idle poll hook */
127 static void mibII_idle(void *arg __unused);
128
129 /*****************************/
130
131 static const struct asn_oid oid_ifMIB = OIDX_ifMIB;
132 static const struct asn_oid oid_ipMIB = OIDX_ipMIB;
133 static const struct asn_oid oid_tcpMIB = OIDX_tcpMIB;
134 static const struct asn_oid oid_udpMIB = OIDX_udpMIB;
135 static const struct asn_oid oid_ipForward = OIDX_ipForward;
136 static const struct asn_oid oid_linkDown = OIDX_linkDown;
137 static const struct asn_oid oid_linkUp = OIDX_linkUp;
138 static const struct asn_oid oid_ifIndex = OIDX_ifIndex;
139
140 /*****************************/
141
142 /*
143 * Find an interface
144 */
145 struct mibif *
mib_find_if(u_int idx)146 mib_find_if(u_int idx)
147 {
148 struct mibif *ifp;
149
150 TAILQ_FOREACH(ifp, &mibif_list, link)
151 if (ifp->index == idx)
152 return (ifp);
153 return (NULL);
154 }
155
156 struct mibif *
mib_find_if_sys(u_int sysindex)157 mib_find_if_sys(u_int sysindex)
158 {
159 struct mibif *ifp;
160
161 TAILQ_FOREACH(ifp, &mibif_list, link)
162 if (ifp->sysindex == sysindex)
163 return (ifp);
164 return (NULL);
165 }
166
167 struct mibif *
mib_find_if_name(const char * name)168 mib_find_if_name(const char *name)
169 {
170 struct mibif *ifp;
171
172 TAILQ_FOREACH(ifp, &mibif_list, link)
173 if (strcmp(ifp->name, name) == 0)
174 return (ifp);
175 return (NULL);
176 }
177
178 /*
179 * Check whether an interface is dynamic. The argument may include the
180 * unit number. This assumes, that the name part does NOT contain digits.
181 */
182 int
mib_if_is_dyn(const char * name)183 mib_if_is_dyn(const char *name)
184 {
185 size_t len;
186 struct mibdynif *d;
187
188 for (len = 0; name[len] != '\0' && isalpha(name[len]) ; len++)
189 ;
190 SLIST_FOREACH(d, &mibdynif_list, link)
191 if (strlen(d->name) == len && strncmp(d->name, name, len) == 0)
192 return (1);
193 return (0);
194 }
195
196 /* set an interface name to dynamic mode */
197 void
mib_if_set_dyn(const char * name)198 mib_if_set_dyn(const char *name)
199 {
200 struct mibdynif *d;
201
202 SLIST_FOREACH(d, &mibdynif_list, link)
203 if (strcmp(name, d->name) == 0)
204 return;
205 if ((d = malloc(sizeof(*d))) == NULL)
206 err(1, NULL);
207 strcpy(d->name, name);
208 SLIST_INSERT_HEAD(&mibdynif_list, d, link);
209 }
210
211 /*
212 * register for interface creations
213 */
214 int
mib_register_newif(int (* func)(struct mibif *),const struct lmodule * mod)215 mib_register_newif(int (*func)(struct mibif *), const struct lmodule *mod)
216 {
217 struct newifreg *reg;
218
219 TAILQ_FOREACH(reg, &newifreg_list, link)
220 if (reg->mod == mod) {
221 reg->func = func;
222 return (0);
223 }
224 if ((reg = malloc(sizeof(*reg))) == NULL) {
225 syslog(LOG_ERR, "newifreg: %m");
226 return (-1);
227 }
228 reg->mod = mod;
229 reg->func = func;
230 TAILQ_INSERT_TAIL(&newifreg_list, reg, link);
231
232 return (0);
233 }
234
235 void
mib_unregister_newif(const struct lmodule * mod)236 mib_unregister_newif(const struct lmodule *mod)
237 {
238 struct newifreg *reg;
239
240 TAILQ_FOREACH(reg, &newifreg_list, link)
241 if (reg->mod == mod) {
242 TAILQ_REMOVE(&newifreg_list, reg, link);
243 free(reg);
244 return;
245 }
246
247 }
248
249 struct mibif *
mib_first_if(void)250 mib_first_if(void)
251 {
252 return (TAILQ_FIRST(&mibif_list));
253 }
254 struct mibif *
mib_next_if(const struct mibif * ifp)255 mib_next_if(const struct mibif *ifp)
256 {
257 return (TAILQ_NEXT(ifp, link));
258 }
259
260 /*
261 * Change the admin status of an interface
262 */
263 int
mib_if_admin(struct mibif * ifp,int up)264 mib_if_admin(struct mibif *ifp, int up)
265 {
266 struct ifreq ifr;
267
268 strncpy(ifr.ifr_name, ifp->name, sizeof(ifr.ifr_name));
269 if (ioctl(mib_netsock, SIOCGIFFLAGS, &ifr) == -1) {
270 syslog(LOG_ERR, "SIOCGIFFLAGS(%s): %m", ifp->name);
271 return (-1);
272 }
273 if (up)
274 ifr.ifr_flags |= IFF_UP;
275 else
276 ifr.ifr_flags &= ~IFF_UP;
277 if (ioctl(mib_netsock, SIOCSIFFLAGS, &ifr) == -1) {
278 syslog(LOG_ERR, "SIOCSIFFLAGS(%s): %m", ifp->name);
279 return (-1);
280 }
281
282 (void)mib_fetch_ifmib(ifp);
283
284 return (0);
285 }
286
287 /*
288 * Generate a link up/down trap
289 */
290 static void
link_trap(struct mibif * ifp,int up)291 link_trap(struct mibif *ifp, int up)
292 {
293 struct snmp_value ifindex;
294
295 ifindex.var = oid_ifIndex;
296 ifindex.var.subs[ifindex.var.len++] = ifp->index;
297 ifindex.syntax = SNMP_SYNTAX_INTEGER;
298 ifindex.v.integer = ifp->index;
299
300 snmp_send_trap(up ? &oid_linkUp : &oid_linkDown, &ifindex,
301 (struct snmp_value *)NULL);
302 }
303
304 /**
305 * Fetch the GENERIC IFMIB and update the HC counters
306 */
307 static int
fetch_generic_mib(struct mibif * ifp,const struct ifmibdata * old)308 fetch_generic_mib(struct mibif *ifp, const struct ifmibdata *old)
309 {
310 int name[6];
311 size_t len;
312 struct mibif_private *p = ifp->private;
313
314 name[0] = CTL_NET;
315 name[1] = PF_LINK;
316 name[2] = NETLINK_GENERIC;
317 name[3] = IFMIB_IFDATA;
318 name[4] = ifp->sysindex;
319 name[5] = IFDATA_GENERAL;
320
321 len = sizeof(ifp->mib);
322 if (sysctl(name, 6, &ifp->mib, &len, NULL, 0) == -1) {
323 if (errno != ENOENT)
324 syslog(LOG_WARNING, "sysctl(ifmib, %s) failed %m",
325 ifp->name);
326 return (-1);
327 }
328
329 /*
330 * Assume that one of the two following compounds is optimized away
331 */
332 if (ULONG_MAX >= 0xffffffffffffffffULL) {
333 p->hc_inoctets = ifp->mib.ifmd_data.ifi_ibytes;
334 p->hc_outoctets = ifp->mib.ifmd_data.ifi_obytes;
335 p->hc_omcasts = ifp->mib.ifmd_data.ifi_omcasts;
336 p->hc_opackets = ifp->mib.ifmd_data.ifi_opackets;
337 p->hc_imcasts = ifp->mib.ifmd_data.ifi_imcasts;
338 p->hc_ipackets = ifp->mib.ifmd_data.ifi_ipackets;
339
340 } else if (ULONG_MAX >= 0xffffffff) {
341
342 #define UPDATE(HC, MIB) \
343 if (old->ifmd_data.MIB > ifp->mib.ifmd_data.MIB) \
344 p->HC += (0x100000000ULL + \
345 ifp->mib.ifmd_data.MIB) - \
346 old->ifmd_data.MIB; \
347 else \
348 p->HC += ifp->mib.ifmd_data.MIB - \
349 old->ifmd_data.MIB;
350
351 UPDATE(hc_inoctets, ifi_ibytes)
352 UPDATE(hc_outoctets, ifi_obytes)
353 UPDATE(hc_omcasts, ifi_omcasts)
354 UPDATE(hc_opackets, ifi_opackets)
355 UPDATE(hc_imcasts, ifi_imcasts)
356 UPDATE(hc_ipackets, ifi_ipackets)
357
358 #undef UPDATE
359 } else
360 abort();
361 return (0);
362 }
363
364 /**
365 * Update the 64-bit interface counters
366 */
367 static void
update_hc_counters(void * arg __unused)368 update_hc_counters(void *arg __unused)
369 {
370 struct mibif *ifp;
371 struct ifmibdata oldmib;
372
373 TAILQ_FOREACH(ifp, &mibif_list, link) {
374 oldmib = ifp->mib;
375 (void)fetch_generic_mib(ifp, &oldmib);
376 }
377 }
378
379 /**
380 * Recompute the poll timer for the HC counters
381 */
382 void
mibif_reset_hc_timer(void)383 mibif_reset_hc_timer(void)
384 {
385 u_int ticks;
386
387 if ((ticks = mibif_force_hc_update_interval) == 0) {
388 if (mibif_maxspeed <= IF_Mbps(10)) {
389 /* at 10Mbps overflow needs 3436 seconds */
390 ticks = 3000 * 100; /* 50 minutes */
391 } else if (mibif_maxspeed <= IF_Mbps(100)) {
392 /* at 100Mbps overflow needs 343 seconds */
393 ticks = 300 * 100; /* 5 minutes */
394 } else if (mibif_maxspeed < IF_Mbps(622)) {
395 /* at 622Mbps overflow needs 53 seconds */
396 ticks = 40 * 100; /* 40 seconds */
397 } else if (mibif_maxspeed <= IF_Mbps(1000)) {
398 /* at 1Gbps overflow needs 34 seconds */
399 ticks = 20 * 100; /* 20 seconds */
400 } else {
401 /* at 10Gbps overflow needs 3.4 seconds */
402 ticks = 100; /* 1 seconds */
403 }
404 }
405
406 if (ticks == mibif_hc_update_interval)
407 return;
408
409 if (hc_update_timer != NULL) {
410 timer_stop(hc_update_timer);
411 hc_update_timer = NULL;
412 }
413 update_hc_counters(NULL);
414 if ((hc_update_timer = timer_start_repeat(ticks * 10, ticks * 10,
415 update_hc_counters, NULL, module)) == NULL) {
416 syslog(LOG_ERR, "timer_start(%u): %m", ticks);
417 return;
418 }
419 mibif_hc_update_interval = ticks;
420 }
421
422 /**
423 * Restart the idle poll timer.
424 */
425 void
mibif_restart_mibII_poll_timer(void)426 mibif_restart_mibII_poll_timer(void)
427 {
428 if (mibII_poll_timer != NULL)
429 timer_stop(mibII_poll_timer);
430
431 if ((mibII_poll_timer = timer_start_repeat(mibII_poll_ticks * 10,
432 mibII_poll_ticks * 10, mibII_idle, NULL, module)) == NULL)
433 syslog(LOG_ERR, "timer_start(%u): %m", mibII_poll_ticks);
434 }
435
436 /*
437 * Fetch new MIB data.
438 */
439 int
mib_fetch_ifmib(struct mibif * ifp)440 mib_fetch_ifmib(struct mibif *ifp)
441 {
442 int name[6];
443 size_t len;
444 void *newmib;
445 struct ifmibdata oldmib = ifp->mib;
446
447 if (fetch_generic_mib(ifp, &oldmib) == -1)
448 return (-1);
449
450 /*
451 * Quoting RFC2863, 3.1.15: "... LinkUp and linkDown traps are
452 * generated just after ifOperStatus leaves, or just before it
453 * enters, the down state, respectively;"
454 */
455 if (ifp->trap_enable && ifp->mib.ifmd_data.ifi_link_state !=
456 oldmib.ifmd_data.ifi_link_state &&
457 (ifp->mib.ifmd_data.ifi_link_state == LINK_STATE_DOWN ||
458 oldmib.ifmd_data.ifi_link_state == LINK_STATE_DOWN))
459 link_trap(ifp, ifp->mib.ifmd_data.ifi_link_state ==
460 LINK_STATE_UP ? 1 : 0);
461
462 ifp->flags &= ~(MIBIF_HIGHSPEED | MIBIF_VERYHIGHSPEED);
463 if (ifp->mib.ifmd_data.ifi_baudrate > 20000000) {
464 ifp->flags |= MIBIF_HIGHSPEED;
465 if (ifp->mib.ifmd_data.ifi_baudrate > 650000000)
466 ifp->flags |= MIBIF_VERYHIGHSPEED;
467 }
468 if (ifp->mib.ifmd_data.ifi_baudrate > mibif_maxspeed) {
469 mibif_maxspeed = ifp->mib.ifmd_data.ifi_baudrate;
470 mibif_reset_hc_timer();
471 }
472
473 /*
474 * linkspecific MIB
475 */
476 name[0] = CTL_NET;
477 name[1] = PF_LINK;
478 name[2] = NETLINK_GENERIC;
479 name[3] = IFMIB_IFDATA;
480 name[4] = ifp->sysindex;
481 name[5] = IFDATA_LINKSPECIFIC;
482 if (sysctl(name, 6, NULL, &len, NULL, 0) == -1) {
483 syslog(LOG_WARNING, "sysctl linkmib estimate (%s): %m",
484 ifp->name);
485 if (ifp->specmib != NULL) {
486 ifp->specmib = NULL;
487 ifp->specmiblen = 0;
488 }
489 goto out;
490 }
491 if (len == 0) {
492 if (ifp->specmib != NULL) {
493 ifp->specmib = NULL;
494 ifp->specmiblen = 0;
495 }
496 goto out;
497 }
498
499 if (ifp->specmiblen != len) {
500 if ((newmib = realloc(ifp->specmib, len)) == NULL) {
501 ifp->specmib = NULL;
502 ifp->specmiblen = 0;
503 goto out;
504 }
505 ifp->specmib = newmib;
506 ifp->specmiblen = len;
507 }
508 if (sysctl(name, 6, ifp->specmib, &len, NULL, 0) == -1) {
509 syslog(LOG_WARNING, "sysctl linkmib (%s): %m", ifp->name);
510 if (ifp->specmib != NULL) {
511 ifp->specmib = NULL;
512 ifp->specmiblen = 0;
513 }
514 }
515
516 out:
517 ifp->mibtick = get_ticks();
518 return (0);
519 }
520
521 /* find first/next address for a given interface */
522 struct mibifa *
mib_first_ififa(const struct mibif * ifp)523 mib_first_ififa(const struct mibif *ifp)
524 {
525 struct mibifa *ifa;
526
527 TAILQ_FOREACH(ifa, &mibifa_list, link)
528 if (ifp->index == ifa->ifindex)
529 return (ifa);
530 return (NULL);
531 }
532
533 struct mibifa *
mib_next_ififa(struct mibifa * ifa0)534 mib_next_ififa(struct mibifa *ifa0)
535 {
536 struct mibifa *ifa;
537
538 ifa = ifa0;
539 while ((ifa = TAILQ_NEXT(ifa, link)) != NULL)
540 if (ifa->ifindex == ifa0->ifindex)
541 return (ifa);
542 return (NULL);
543 }
544
545 /*
546 * Allocate a new IFA
547 */
548 static struct mibifa *
alloc_ifa(u_int ifindex,struct in_addr addr)549 alloc_ifa(u_int ifindex, struct in_addr addr)
550 {
551 struct mibifa *ifa;
552 uint32_t ha;
553
554 if ((ifa = malloc(sizeof(struct mibifa))) == NULL) {
555 syslog(LOG_ERR, "ifa: %m");
556 return (NULL);
557 }
558 ifa->inaddr = addr;
559 ifa->ifindex = ifindex;
560
561 ha = ntohl(ifa->inaddr.s_addr);
562 ifa->index.len = 4;
563 ifa->index.subs[0] = (ha >> 24) & 0xff;
564 ifa->index.subs[1] = (ha >> 16) & 0xff;
565 ifa->index.subs[2] = (ha >> 8) & 0xff;
566 ifa->index.subs[3] = (ha >> 0) & 0xff;
567
568 ifa->flags = 0;
569 ifa->inbcast.s_addr = 0;
570 ifa->inmask.s_addr = 0xffffffff;
571
572 INSERT_OBJECT_OID(ifa, &mibifa_list);
573
574 return (ifa);
575 }
576
577 /*
578 * Delete an interface address
579 */
580 static void
destroy_ifa(struct mibifa * ifa)581 destroy_ifa(struct mibifa *ifa)
582 {
583 TAILQ_REMOVE(&mibifa_list, ifa, link);
584 free(ifa);
585 }
586
587
588 /*
589 * Helper routine to extract the sockaddr structures from a routing
590 * socket message.
591 */
592 void
mib_extract_addrs(int addrs,u_char * info,struct sockaddr ** out)593 mib_extract_addrs(int addrs, u_char *info, struct sockaddr **out)
594 {
595 u_int i;
596
597 for (i = 0; i < RTAX_MAX; i++) {
598 if ((addrs & (1 << i)) != 0) {
599 *out = (struct sockaddr *)(void *)info;
600 info += roundup((*out)->sa_len, sizeof(long));
601 } else
602 *out = NULL;
603 out++;
604 }
605 }
606
607 /*
608 * save the phys address of an interface. Handle receive address entries here.
609 */
610 static void
get_physaddr(struct mibif * ifp,struct sockaddr_dl * sdl,u_char * ptr)611 get_physaddr(struct mibif *ifp, struct sockaddr_dl *sdl, u_char *ptr)
612 {
613 u_char *np;
614 struct mibrcvaddr *rcv;
615
616 if (sdl->sdl_alen == 0) {
617 /* no address */
618 if (ifp->physaddrlen != 0) {
619 if ((rcv = mib_find_rcvaddr(ifp->index, ifp->physaddr,
620 ifp->physaddrlen)) != NULL)
621 mib_rcvaddr_delete(rcv);
622 free(ifp->physaddr);
623 ifp->physaddr = NULL;
624 ifp->physaddrlen = 0;
625 }
626 return;
627 }
628
629 if (ifp->physaddrlen != sdl->sdl_alen) {
630 /* length changed */
631 if (ifp->physaddrlen) {
632 /* delete olf receive address */
633 if ((rcv = mib_find_rcvaddr(ifp->index, ifp->physaddr,
634 ifp->physaddrlen)) != NULL)
635 mib_rcvaddr_delete(rcv);
636 }
637 if ((np = realloc(ifp->physaddr, sdl->sdl_alen)) == NULL) {
638 free(ifp->physaddr);
639 ifp->physaddr = NULL;
640 ifp->physaddrlen = 0;
641 return;
642 }
643 ifp->physaddr = np;
644 ifp->physaddrlen = sdl->sdl_alen;
645
646 } else if (memcmp(ifp->physaddr, ptr, ifp->physaddrlen) == 0) {
647 /* no change */
648 return;
649
650 } else {
651 /* address changed */
652
653 /* delete olf receive address */
654 if ((rcv = mib_find_rcvaddr(ifp->index, ifp->physaddr,
655 ifp->physaddrlen)) != NULL)
656 mib_rcvaddr_delete(rcv);
657 }
658
659 memcpy(ifp->physaddr, ptr, ifp->physaddrlen);
660
661 /* make new receive address */
662 if ((rcv = mib_rcvaddr_create(ifp, ifp->physaddr, ifp->physaddrlen)) != NULL)
663 rcv->flags |= MIBRCVADDR_HW;
664 }
665
666 /*
667 * Free an interface
668 */
669 static void
mibif_free(struct mibif * ifp)670 mibif_free(struct mibif *ifp)
671 {
672 struct mibif *ifp1;
673 struct mibindexmap *map;
674 struct mibifa *ifa, *ifa1;
675 struct mibrcvaddr *rcv, *rcv1;
676 struct mibarp *at, *at1;
677
678 if (ifp->xnotify != NULL)
679 (*ifp->xnotify)(ifp, MIBIF_NOTIFY_DESTROY, ifp->xnotify_data);
680
681 (void)mib_ifstack_delete(ifp, NULL);
682 (void)mib_ifstack_delete(NULL, ifp);
683
684 TAILQ_REMOVE(&mibif_list, ifp, link);
685
686 /* if this was the fastest interface - recompute this */
687 if (ifp->mib.ifmd_data.ifi_baudrate == mibif_maxspeed) {
688 mibif_maxspeed = ifp->mib.ifmd_data.ifi_baudrate;
689 TAILQ_FOREACH(ifp1, &mibif_list, link)
690 if (ifp1->mib.ifmd_data.ifi_baudrate > mibif_maxspeed)
691 mibif_maxspeed =
692 ifp1->mib.ifmd_data.ifi_baudrate;
693 mibif_reset_hc_timer();
694 }
695
696 free(ifp->private);
697 if (ifp->physaddr != NULL)
698 free(ifp->physaddr);
699 if (ifp->specmib != NULL)
700 free(ifp->specmib);
701
702 STAILQ_FOREACH(map, &mibindexmap_list, link)
703 if (map->mibif == ifp) {
704 map->mibif = NULL;
705 break;
706 }
707
708 /* purge interface addresses */
709 ifa = TAILQ_FIRST(&mibifa_list);
710 while (ifa != NULL) {
711 ifa1 = TAILQ_NEXT(ifa, link);
712 if (ifa->ifindex == ifp->index)
713 destroy_ifa(ifa);
714 ifa = ifa1;
715 }
716
717 /* purge receive addresses */
718 rcv = TAILQ_FIRST(&mibrcvaddr_list);
719 while (rcv != NULL) {
720 rcv1 = TAILQ_NEXT(rcv, link);
721 if (rcv->ifindex == ifp->index)
722 mib_rcvaddr_delete(rcv);
723 rcv = rcv1;
724 }
725
726 /* purge ARP entries */
727 at = TAILQ_FIRST(&mibarp_list);
728 while (at != NULL) {
729 at1 = TAILQ_NEXT(at, link);
730 if (at->index.subs[0] == ifp->index)
731 mib_arp_delete(at);
732 at = at1;
733 }
734
735
736 free(ifp);
737 mib_if_number--;
738 mib_iftable_last_change = this_tick;
739 }
740
741 /*
742 * Create a new interface
743 */
744 static struct mibif *
mibif_create(u_int sysindex,const char * name)745 mibif_create(u_int sysindex, const char *name)
746 {
747 struct mibif *ifp;
748 struct mibindexmap *map;
749
750 if ((ifp = malloc(sizeof(*ifp))) == NULL) {
751 syslog(LOG_WARNING, "%s: %m", __func__);
752 return (NULL);
753 }
754 memset(ifp, 0, sizeof(*ifp));
755 if ((ifp->private = malloc(sizeof(struct mibif_private))) == NULL) {
756 syslog(LOG_WARNING, "%s: %m", __func__);
757 free(ifp);
758 return (NULL);
759 }
760 memset(ifp->private, 0, sizeof(struct mibif_private));
761
762 ifp->sysindex = sysindex;
763 strcpy(ifp->name, name);
764 strcpy(ifp->descr, name);
765 ifp->spec_oid = oid_zeroDotZero;
766
767 map = NULL;
768 if (!mib_if_is_dyn(ifp->name)) {
769 /* non-dynamic. look whether we know the interface */
770 STAILQ_FOREACH(map, &mibindexmap_list, link)
771 if (strcmp(map->name, ifp->name) == 0) {
772 ifp->index = map->ifindex;
773 map->mibif = ifp;
774 break;
775 }
776 /* assume it has a connector if it is not dynamic */
777 ifp->has_connector = 1;
778 ifp->trap_enable = 1;
779 }
780 if (map == NULL) {
781 /* new interface - get new index */
782 if (next_if_index > 0x7fffffff)
783 errx(1, "ifindex wrap");
784
785 if ((map = malloc(sizeof(*map))) == NULL) {
786 syslog(LOG_ERR, "ifmap: %m");
787 free(ifp);
788 return (NULL);
789 }
790 map->ifindex = next_if_index++;
791 map->sysindex = ifp->sysindex;
792 strcpy(map->name, ifp->name);
793 map->mibif = ifp;
794 STAILQ_INSERT_TAIL(&mibindexmap_list, map, link);
795 } else {
796 /* re-instantiate. Introduce a counter discontinuity */
797 ifp->counter_disc = get_ticks();
798 }
799 ifp->index = map->ifindex;
800 ifp->mib.ifmd_data.ifi_link_state = LINK_STATE_UNKNOWN;
801
802 INSERT_OBJECT_INT(ifp, &mibif_list);
803 mib_if_number++;
804 mib_iftable_last_change = this_tick;
805
806 /* instantiate default ifStack entries */
807 (void)mib_ifstack_create(ifp, NULL);
808 (void)mib_ifstack_create(NULL, ifp);
809
810 return (ifp);
811 }
812
813 /*
814 * Inform all interested parties about a new interface
815 */
816 static void
notify_newif(struct mibif * ifp)817 notify_newif(struct mibif *ifp)
818 {
819 struct newifreg *reg;
820
821 TAILQ_FOREACH(reg, &newifreg_list, link)
822 if ((*reg->func)(ifp))
823 return;
824 }
825
826 /*
827 * This is called for new interfaces after we have fetched the interface
828 * MIB. If this is a broadcast interface try to guess the broadcast address
829 * depending on the interface type.
830 */
831 static void
check_llbcast(struct mibif * ifp)832 check_llbcast(struct mibif *ifp)
833 {
834 static u_char ether_bcast[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
835 static u_char arcnet_bcast = 0;
836 struct mibrcvaddr *rcv;
837
838 if (!(ifp->mib.ifmd_flags & IFF_BROADCAST))
839 return;
840
841 switch (ifp->mib.ifmd_data.ifi_type) {
842
843 case IFT_ETHER:
844 case IFT_FDDI:
845 case IFT_ISO88025:
846 case IFT_L2VLAN:
847 if (mib_find_rcvaddr(ifp->index, ether_bcast, 6) == NULL &&
848 (rcv = mib_rcvaddr_create(ifp, ether_bcast, 6)) != NULL)
849 rcv->flags |= MIBRCVADDR_BCAST;
850 break;
851
852 case IFT_ARCNET:
853 if (mib_find_rcvaddr(ifp->index, &arcnet_bcast, 1) == NULL &&
854 (rcv = mib_rcvaddr_create(ifp, &arcnet_bcast, 1)) != NULL)
855 rcv->flags |= MIBRCVADDR_BCAST;
856 break;
857 }
858 }
859
860
861 /*
862 * Retrieve the current interface list from the system.
863 */
864 void
mib_refresh_iflist(void)865 mib_refresh_iflist(void)
866 {
867 struct mibif *ifp, *ifp1;
868 size_t len;
869 u_short idx;
870 int name[6];
871 int count;
872 struct ifmibdata mib;
873
874 TAILQ_FOREACH(ifp, &mibif_list, link)
875 ifp->flags &= ~MIBIF_FOUND;
876
877 len = sizeof(count);
878 if (sysctlbyname("net.link.generic.system.ifcount", &count, &len,
879 NULL, 0) == -1) {
880 syslog(LOG_ERR, "ifcount: %m");
881 return;
882 }
883 name[0] = CTL_NET;
884 name[1] = PF_LINK;
885 name[2] = NETLINK_GENERIC;
886 name[3] = IFMIB_IFDATA;
887 name[5] = IFDATA_GENERAL;
888 for (idx = 1; idx <= count; idx++) {
889 name[4] = idx;
890 len = sizeof(mib);
891 if (sysctl(name, 6, &mib, &len, NULL, 0) == -1) {
892 if (errno == ENOENT)
893 continue;
894 syslog(LOG_ERR, "ifmib(%u): %m", idx);
895 return;
896 }
897 if ((ifp = mib_find_if_sys(idx)) != NULL) {
898 ifp->flags |= MIBIF_FOUND;
899 continue;
900 }
901 /* Unknown interface - create */
902 if ((ifp = mibif_create(idx, mib.ifmd_name)) != NULL) {
903 ifp->flags |= MIBIF_FOUND;
904 (void)mib_fetch_ifmib(ifp);
905 check_llbcast(ifp);
906 notify_newif(ifp);
907 }
908 }
909
910 /*
911 * Purge interfaces that disappeared
912 */
913 ifp = TAILQ_FIRST(&mibif_list);
914 while (ifp != NULL) {
915 ifp1 = TAILQ_NEXT(ifp, link);
916 if (!(ifp->flags & MIBIF_FOUND))
917 mibif_free(ifp);
918 ifp = ifp1;
919 }
920 }
921
922 /*
923 * Find an interface address
924 */
925 struct mibifa *
mib_find_ifa(struct in_addr addr)926 mib_find_ifa(struct in_addr addr)
927 {
928 struct mibifa *ifa;
929
930 TAILQ_FOREACH(ifa, &mibifa_list, link)
931 if (ifa->inaddr.s_addr == addr.s_addr)
932 return (ifa);
933 return (NULL);
934 }
935
936 /*
937 * Process a new ARP entry
938 */
939 static void
process_arp(const struct rt_msghdr * rtm,const struct sockaddr_dl * sdl,const struct sockaddr_in * sa)940 process_arp(const struct rt_msghdr *rtm, const struct sockaddr_dl *sdl,
941 const struct sockaddr_in *sa)
942 {
943 struct mibif *ifp;
944 struct mibarp *at;
945
946 /* IP arp table entry */
947 if (sdl->sdl_alen == 0)
948 return;
949 if ((ifp = mib_find_if_sys(sdl->sdl_index)) == NULL)
950 return;
951 /* have a valid entry */
952 if ((at = mib_find_arp(ifp, sa->sin_addr)) == NULL &&
953 (at = mib_arp_create(ifp, sa->sin_addr,
954 sdl->sdl_data + sdl->sdl_nlen, sdl->sdl_alen)) == NULL)
955 return;
956
957 if (rtm->rtm_rmx.rmx_expire == 0)
958 at->flags |= MIBARP_PERM;
959 else
960 at->flags &= ~MIBARP_PERM;
961 at->flags |= MIBARP_FOUND;
962 }
963
964 /*
965 * Handle a routing socket message.
966 */
967 static void
handle_rtmsg(struct rt_msghdr * rtm)968 handle_rtmsg(struct rt_msghdr *rtm)
969 {
970 struct sockaddr *addrs[RTAX_MAX];
971 struct if_msghdr *ifm;
972 struct ifa_msghdr ifam;
973 struct ifma_msghdr *ifmam;
974 #ifdef RTM_IFANNOUNCE
975 struct if_announcemsghdr *ifan;
976 #endif
977 struct mibif *ifp;
978 struct sockaddr_dl *sdl;
979 struct sockaddr_in *sa;
980 struct mibifa *ifa;
981 struct mibrcvaddr *rcv;
982 u_char *ptr;
983
984 if (rtm->rtm_version != RTM_VERSION) {
985 syslog(LOG_ERR, "Bogus RTM version %u", rtm->rtm_version);
986 return;
987 }
988
989 switch (rtm->rtm_type) {
990
991 case RTM_NEWADDR:
992 memcpy(&ifam, rtm, sizeof(ifam));
993 mib_extract_addrs(ifam.ifam_addrs, (u_char *)(&ifam + 1), addrs);
994 if (addrs[RTAX_IFA] == NULL || addrs[RTAX_NETMASK] == NULL)
995 break;
996
997 sa = (struct sockaddr_in *)(void *)addrs[RTAX_IFA];
998 if ((ifa = mib_find_ifa(sa->sin_addr)) == NULL) {
999 /* unknown address */
1000 if ((ifp = mib_find_if_sys(ifam.ifam_index)) == NULL) {
1001 syslog(LOG_WARNING, "RTM_NEWADDR for unknown "
1002 "interface %u", ifam.ifam_index);
1003 break;
1004 }
1005 if ((ifa = alloc_ifa(ifp->index, sa->sin_addr)) == NULL)
1006 break;
1007 }
1008 sa = (struct sockaddr_in *)(void *)addrs[RTAX_NETMASK];
1009 ifa->inmask = sa->sin_addr;
1010
1011 if (addrs[RTAX_BRD] != NULL) {
1012 sa = (struct sockaddr_in *)(void *)addrs[RTAX_BRD];
1013 ifa->inbcast = sa->sin_addr;
1014 }
1015 ifa->flags |= MIBIFA_FOUND;
1016 break;
1017
1018 case RTM_DELADDR:
1019 memcpy(&ifam, rtm, sizeof(ifam));
1020 mib_extract_addrs(ifam.ifam_addrs, (u_char *)(&ifam + 1), addrs);
1021 if (addrs[RTAX_IFA] == NULL)
1022 break;
1023
1024 sa = (struct sockaddr_in *)(void *)addrs[RTAX_IFA];
1025 if ((ifa = mib_find_ifa(sa->sin_addr)) != NULL) {
1026 ifa->flags |= MIBIFA_FOUND;
1027 if (!(ifa->flags & MIBIFA_DESTROYED))
1028 destroy_ifa(ifa);
1029 }
1030 break;
1031
1032 case RTM_NEWMADDR:
1033 ifmam = (struct ifma_msghdr *)rtm;
1034 mib_extract_addrs(ifmam->ifmam_addrs, (u_char *)(ifmam + 1), addrs);
1035 if (addrs[RTAX_IFA] == NULL ||
1036 addrs[RTAX_IFA]->sa_family != AF_LINK)
1037 break;
1038 sdl = (struct sockaddr_dl *)(void *)addrs[RTAX_IFA];
1039 if ((rcv = mib_find_rcvaddr(sdl->sdl_index,
1040 sdl->sdl_data + sdl->sdl_nlen, sdl->sdl_alen)) == NULL) {
1041 /* unknown address */
1042 if ((ifp = mib_find_if_sys(sdl->sdl_index)) == NULL) {
1043 syslog(LOG_WARNING, "RTM_NEWMADDR for unknown "
1044 "interface %u", sdl->sdl_index);
1045 break;
1046 }
1047 if ((rcv = mib_rcvaddr_create(ifp,
1048 sdl->sdl_data + sdl->sdl_nlen, sdl->sdl_alen)) == NULL)
1049 break;
1050 rcv->flags |= MIBRCVADDR_VOLATILE;
1051 }
1052 rcv->flags |= MIBRCVADDR_FOUND;
1053 break;
1054
1055 case RTM_DELMADDR:
1056 ifmam = (struct ifma_msghdr *)rtm;
1057 mib_extract_addrs(ifmam->ifmam_addrs, (u_char *)(ifmam + 1), addrs);
1058 if (addrs[RTAX_IFA] == NULL ||
1059 addrs[RTAX_IFA]->sa_family != AF_LINK)
1060 break;
1061 sdl = (struct sockaddr_dl *)(void *)addrs[RTAX_IFA];
1062 if ((rcv = mib_find_rcvaddr(sdl->sdl_index,
1063 sdl->sdl_data + sdl->sdl_nlen, sdl->sdl_alen)) != NULL)
1064 mib_rcvaddr_delete(rcv);
1065 break;
1066
1067 case RTM_IFINFO:
1068 ifm = (struct if_msghdr *)(void *)rtm;
1069 mib_extract_addrs(ifm->ifm_addrs, (u_char *)(ifm + 1), addrs);
1070 if ((ifp = mib_find_if_sys(ifm->ifm_index)) == NULL)
1071 break;
1072 if (addrs[RTAX_IFP] != NULL &&
1073 addrs[RTAX_IFP]->sa_family == AF_LINK) {
1074 sdl = (struct sockaddr_dl *)(void *)addrs[RTAX_IFP];
1075 ptr = sdl->sdl_data + sdl->sdl_nlen;
1076 get_physaddr(ifp, sdl, ptr);
1077 }
1078 (void)mib_fetch_ifmib(ifp);
1079 break;
1080
1081 #ifdef RTM_IFANNOUNCE
1082 case RTM_IFANNOUNCE:
1083 ifan = (struct if_announcemsghdr *)rtm;
1084 ifp = mib_find_if_sys(ifan->ifan_index);
1085
1086 switch (ifan->ifan_what) {
1087
1088 case IFAN_ARRIVAL:
1089 if (ifp == NULL && (ifp = mibif_create(ifan->ifan_index,
1090 ifan->ifan_name)) != NULL) {
1091 (void)mib_fetch_ifmib(ifp);
1092 check_llbcast(ifp);
1093 notify_newif(ifp);
1094 }
1095 break;
1096
1097 case IFAN_DEPARTURE:
1098 if (ifp != NULL)
1099 mibif_free(ifp);
1100 break;
1101 }
1102 break;
1103 #endif
1104 case RTM_GET:
1105 case RTM_ADD:
1106 mib_extract_addrs(rtm->rtm_addrs, (u_char *)(rtm + 1), addrs);
1107 if (rtm->rtm_flags & RTF_LLINFO) {
1108 if (addrs[RTAX_DST] == NULL ||
1109 addrs[RTAX_GATEWAY] == NULL ||
1110 addrs[RTAX_DST]->sa_family != AF_INET ||
1111 addrs[RTAX_GATEWAY]->sa_family != AF_LINK)
1112 break;
1113 process_arp(rtm,
1114 (struct sockaddr_dl *)(void *)addrs[RTAX_GATEWAY],
1115 (struct sockaddr_in *)(void *)addrs[RTAX_DST]);
1116 } else {
1117 if (rtm->rtm_errno == 0 && (rtm->rtm_flags & RTF_UP))
1118 mib_sroute_process(rtm, addrs[RTAX_GATEWAY],
1119 addrs[RTAX_DST], addrs[RTAX_NETMASK]);
1120 }
1121 break;
1122
1123 case RTM_DELETE:
1124 mib_extract_addrs(rtm->rtm_addrs, (u_char *)(rtm + 1), addrs);
1125
1126 if (rtm->rtm_errno == 0 && (rtm->rtm_flags & RTF_UP))
1127 mib_sroute_process(rtm, addrs[RTAX_GATEWAY],
1128 addrs[RTAX_DST], addrs[RTAX_NETMASK]);
1129 break;
1130 }
1131 }
1132
1133 /*
1134 * send a routing message
1135 */
1136 void
mib_send_rtmsg(struct rt_msghdr * rtm,struct sockaddr * gw,struct sockaddr * dst,struct sockaddr * mask)1137 mib_send_rtmsg(struct rt_msghdr *rtm, struct sockaddr *gw,
1138 struct sockaddr *dst, struct sockaddr *mask)
1139 {
1140 size_t len;
1141 struct rt_msghdr *msg;
1142 char *cp;
1143 ssize_t sent;
1144
1145 len = sizeof(*rtm) + SA_SIZE(gw) + SA_SIZE(dst) + SA_SIZE(mask);
1146 if ((msg = malloc(len)) == NULL) {
1147 syslog(LOG_ERR, "%s: %m", __func__);
1148 return;
1149 }
1150 cp = (char *)(msg + 1);
1151
1152 memset(msg, 0, sizeof(*msg));
1153 msg->rtm_flags = 0;
1154 msg->rtm_version = RTM_VERSION;
1155 msg->rtm_addrs = RTA_DST | RTA_GATEWAY;
1156
1157 memcpy(cp, dst, SA_SIZE(dst));
1158 cp += SA_SIZE(dst);
1159 memcpy(cp, gw, SA_SIZE(gw));
1160 cp += SA_SIZE(gw);
1161 if (mask != NULL) {
1162 memcpy(cp, mask, SA_SIZE(mask));
1163 cp += SA_SIZE(mask);
1164 msg->rtm_addrs |= RTA_NETMASK;
1165 }
1166 msg->rtm_msglen = cp - (char *)msg;
1167 msg->rtm_type = RTM_GET;
1168 if ((sent = write(route, msg, msg->rtm_msglen)) == -1) {
1169 syslog(LOG_ERR, "%s: write: %m", __func__);
1170 free(msg);
1171 return;
1172 }
1173 if (sent != msg->rtm_msglen) {
1174 syslog(LOG_ERR, "%s: short write", __func__);
1175 free(msg);
1176 return;
1177 }
1178 free(msg);
1179 }
1180
1181 /*
1182 * Fetch the routing table via sysctl
1183 */
1184 u_char *
mib_fetch_rtab(int af,int info,int arg,size_t * lenp)1185 mib_fetch_rtab(int af, int info, int arg, size_t *lenp)
1186 {
1187 int name[6];
1188 u_char *buf, *newbuf;
1189
1190 name[0] = CTL_NET;
1191 name[1] = PF_ROUTE;
1192 name[2] = 0;
1193 name[3] = af;
1194 name[4] = info;
1195 name[5] = arg;
1196
1197 *lenp = 0;
1198
1199 /* initial estimate */
1200 if (sysctl(name, 6, NULL, lenp, NULL, 0) == -1) {
1201 syslog(LOG_ERR, "sysctl estimate (%d,%d,%d,%d,%d,%d): %m",
1202 name[0], name[1], name[2], name[3], name[4], name[5]);
1203 return (NULL);
1204 }
1205 if (*lenp == 0)
1206 return (NULL);
1207
1208 buf = NULL;
1209 for (;;) {
1210 if ((newbuf = realloc(buf, *lenp)) == NULL) {
1211 syslog(LOG_ERR, "sysctl buffer: %m");
1212 free(buf);
1213 return (NULL);
1214 }
1215 buf = newbuf;
1216
1217 if (sysctl(name, 6, buf, lenp, NULL, 0) == 0)
1218 break;
1219
1220 if (errno != ENOMEM) {
1221 syslog(LOG_ERR, "sysctl get: %m");
1222 free(buf);
1223 return (NULL);
1224 }
1225 *lenp += *lenp / 8 + 1;
1226 }
1227
1228 return (buf);
1229 }
1230
1231 /*
1232 * Update the following info: interface, interface addresses, interface
1233 * receive addresses, arp-table.
1234 * This does not change the interface list itself.
1235 */
1236 static void
update_ifa_info(void)1237 update_ifa_info(void)
1238 {
1239 u_char *buf, *next;
1240 struct rt_msghdr *rtm;
1241 struct mibifa *ifa, *ifa1;
1242 struct mibrcvaddr *rcv, *rcv1;
1243 size_t needed;
1244 static const int infos[][3] = {
1245 { 0, NET_RT_IFLIST, 0 },
1246 #ifdef NET_RT_IFMALIST
1247 { AF_LINK, NET_RT_IFMALIST, 0 },
1248 #endif
1249 };
1250 u_int i;
1251
1252 TAILQ_FOREACH(ifa, &mibifa_list, link)
1253 ifa->flags &= ~MIBIFA_FOUND;
1254 TAILQ_FOREACH(rcv, &mibrcvaddr_list, link)
1255 rcv->flags &= ~MIBRCVADDR_FOUND;
1256
1257 for (i = 0; i < sizeof(infos) / sizeof(infos[0]); i++) {
1258 if ((buf = mib_fetch_rtab(infos[i][0], infos[i][1], infos[i][2],
1259 &needed)) == NULL)
1260 continue;
1261
1262 next = buf;
1263 while (next < buf + needed) {
1264 rtm = (struct rt_msghdr *)(void *)next;
1265 next += rtm->rtm_msglen;
1266 handle_rtmsg(rtm);
1267 }
1268 free(buf);
1269 }
1270
1271 /*
1272 * Purge the address list of unused entries. These may happen for
1273 * interface aliases that are on the same subnet. We don't receive
1274 * routing socket messages for them.
1275 */
1276 ifa = TAILQ_FIRST(&mibifa_list);
1277 while (ifa != NULL) {
1278 ifa1 = TAILQ_NEXT(ifa, link);
1279 if (!(ifa->flags & MIBIFA_FOUND))
1280 destroy_ifa(ifa);
1281 ifa = ifa1;
1282 }
1283
1284 rcv = TAILQ_FIRST(&mibrcvaddr_list);
1285 while (rcv != NULL) {
1286 rcv1 = TAILQ_NEXT(rcv, link);
1287 if (!(rcv->flags & (MIBRCVADDR_FOUND | MIBRCVADDR_BCAST |
1288 MIBRCVADDR_HW)))
1289 mib_rcvaddr_delete(rcv);
1290 rcv = rcv1;
1291 }
1292 }
1293
1294 /*
1295 * Update arp table
1296 *
1297 */
1298 void
mib_arp_update(void)1299 mib_arp_update(void)
1300 {
1301 struct mibarp *at, *at1;
1302 size_t needed;
1303 u_char *buf, *next;
1304 struct rt_msghdr *rtm;
1305
1306 if (in_update_arp)
1307 return; /* Aaargh */
1308 in_update_arp = 1;
1309
1310 TAILQ_FOREACH(at, &mibarp_list, link)
1311 at->flags &= ~MIBARP_FOUND;
1312
1313 if ((buf = mib_fetch_rtab(AF_INET, NET_RT_FLAGS, 0, &needed)) == NULL) {
1314 in_update_arp = 0;
1315 return;
1316 }
1317
1318 next = buf;
1319 while (next < buf + needed) {
1320 rtm = (struct rt_msghdr *)(void *)next;
1321 next += rtm->rtm_msglen;
1322 handle_rtmsg(rtm);
1323 }
1324 free(buf);
1325
1326 at = TAILQ_FIRST(&mibarp_list);
1327 while (at != NULL) {
1328 at1 = TAILQ_NEXT(at, link);
1329 if (!(at->flags & MIBARP_FOUND))
1330 mib_arp_delete(at);
1331 at = at1;
1332 }
1333 mibarpticks = get_ticks();
1334 in_update_arp = 0;
1335 }
1336
1337
1338 /*
1339 * Intput on the routing socket.
1340 */
1341 static void
route_input(int fd,void * udata __unused)1342 route_input(int fd, void *udata __unused)
1343 {
1344 u_char buf[1024 * 16];
1345 ssize_t n;
1346 struct rt_msghdr *rtm;
1347
1348 if ((n = read(fd, buf, sizeof(buf))) == -1)
1349 err(1, "read(rt_socket)");
1350
1351 if (n == 0)
1352 errx(1, "EOF on rt_socket");
1353
1354 rtm = (struct rt_msghdr *)(void *)buf;
1355 if ((size_t)n != rtm->rtm_msglen)
1356 errx(1, "n=%zu, rtm_msglen=%u", (size_t)n, rtm->rtm_msglen);
1357
1358 handle_rtmsg(rtm);
1359 }
1360
1361 /*
1362 * execute and SIOCAIFADDR
1363 */
1364 static int
siocaifaddr(char * ifname,struct in_addr addr,struct in_addr mask,struct in_addr bcast)1365 siocaifaddr(char *ifname, struct in_addr addr, struct in_addr mask,
1366 struct in_addr bcast)
1367 {
1368 struct ifaliasreq addreq;
1369 struct sockaddr_in *sa;
1370
1371 memset(&addreq, 0, sizeof(addreq));
1372 strncpy(addreq.ifra_name, ifname, sizeof(addreq.ifra_name));
1373
1374 sa = (struct sockaddr_in *)(void *)&addreq.ifra_addr;
1375 sa->sin_family = AF_INET;
1376 sa->sin_len = sizeof(*sa);
1377 sa->sin_addr = addr;
1378
1379 sa = (struct sockaddr_in *)(void *)&addreq.ifra_mask;
1380 sa->sin_family = AF_INET;
1381 sa->sin_len = sizeof(*sa);
1382 sa->sin_addr = mask;
1383
1384 sa = (struct sockaddr_in *)(void *)&addreq.ifra_broadaddr;
1385 sa->sin_family = AF_INET;
1386 sa->sin_len = sizeof(*sa);
1387 sa->sin_addr = bcast;
1388
1389 return (ioctl(mib_netsock, SIOCAIFADDR, &addreq));
1390 }
1391
1392 /*
1393 * Exececute a SIOCDIFADDR
1394 */
1395 static int
siocdifaddr(const char * ifname,struct in_addr addr)1396 siocdifaddr(const char *ifname, struct in_addr addr)
1397 {
1398 struct ifreq delreq;
1399 struct sockaddr_in *sa;
1400
1401 memset(&delreq, 0, sizeof(delreq));
1402 strncpy(delreq.ifr_name, ifname, sizeof(delreq.ifr_name));
1403 sa = (struct sockaddr_in *)(void *)&delreq.ifr_addr;
1404 sa->sin_family = AF_INET;
1405 sa->sin_len = sizeof(*sa);
1406 sa->sin_addr = addr;
1407
1408 return (ioctl(mib_netsock, SIOCDIFADDR, &delreq));
1409 }
1410
1411 /*
1412 * Verify an interface address without fetching the entire list
1413 */
1414 static int
verify_ifa(const char * name,struct mibifa * ifa)1415 verify_ifa(const char *name, struct mibifa *ifa)
1416 {
1417 struct ifreq req;
1418 struct sockaddr_in *sa;
1419
1420 memset(&req, 0, sizeof(req));
1421 strncpy(req.ifr_name, name, sizeof(req.ifr_name));
1422 sa = (struct sockaddr_in *)(void *)&req.ifr_addr;
1423 sa->sin_family = AF_INET;
1424 sa->sin_len = sizeof(*sa);
1425 sa->sin_addr = ifa->inaddr;
1426
1427 if (ioctl(mib_netsock, SIOCGIFADDR, &req) == -1)
1428 return (-1);
1429 if (ifa->inaddr.s_addr != sa->sin_addr.s_addr) {
1430 syslog(LOG_ERR, "%s: address mismatch", __func__);
1431 return (-1);
1432 }
1433
1434 if (ioctl(mib_netsock, SIOCGIFNETMASK, &req) == -1)
1435 return (-1);
1436 if (ifa->inmask.s_addr != sa->sin_addr.s_addr) {
1437 syslog(LOG_ERR, "%s: netmask mismatch", __func__);
1438 return (-1);
1439 }
1440 return (0);
1441 }
1442
1443 /*
1444 * Restore a deleted interface address. Don't wait for the routing socket
1445 * to update us.
1446 */
1447 void
mib_undestroy_ifa(struct mibifa * ifa)1448 mib_undestroy_ifa(struct mibifa *ifa)
1449 {
1450 struct mibif *ifp;
1451
1452 if ((ifp = mib_find_if(ifa->ifindex)) == NULL)
1453 /* keep it destroyed */
1454 return;
1455
1456 if (siocaifaddr(ifp->name, ifa->inaddr, ifa->inmask, ifa->inbcast))
1457 /* keep it destroyed */
1458 return;
1459
1460 ifa->flags &= ~MIBIFA_DESTROYED;
1461 }
1462
1463 /*
1464 * Destroy an interface address
1465 */
1466 int
mib_destroy_ifa(struct mibifa * ifa)1467 mib_destroy_ifa(struct mibifa *ifa)
1468 {
1469 struct mibif *ifp;
1470
1471 if ((ifp = mib_find_if(ifa->ifindex)) == NULL) {
1472 /* ups. */
1473 mib_iflist_bad = 1;
1474 return (-1);
1475 }
1476 if (siocdifaddr(ifp->name, ifa->inaddr)) {
1477 /* ups. */
1478 syslog(LOG_ERR, "SIOCDIFADDR: %m");
1479 mib_iflist_bad = 1;
1480 return (-1);
1481 }
1482 ifa->flags |= MIBIFA_DESTROYED;
1483 return (0);
1484 }
1485
1486 /*
1487 * Rollback the modification of an address. Don't bother to wait for
1488 * the routing socket.
1489 */
1490 void
mib_unmodify_ifa(struct mibifa * ifa)1491 mib_unmodify_ifa(struct mibifa *ifa)
1492 {
1493 struct mibif *ifp;
1494
1495 if ((ifp = mib_find_if(ifa->ifindex)) == NULL) {
1496 /* ups. */
1497 mib_iflist_bad = 1;
1498 return;
1499 }
1500
1501 if (siocaifaddr(ifp->name, ifa->inaddr, ifa->inmask, ifa->inbcast)) {
1502 /* ups. */
1503 mib_iflist_bad = 1;
1504 return;
1505 }
1506 }
1507
1508 /*
1509 * Modify an IFA.
1510 */
1511 int
mib_modify_ifa(struct mibifa * ifa)1512 mib_modify_ifa(struct mibifa *ifa)
1513 {
1514 struct mibif *ifp;
1515
1516 if ((ifp = mib_find_if(ifa->ifindex)) == NULL) {
1517 /* ups. */
1518 mib_iflist_bad = 1;
1519 return (-1);
1520 }
1521
1522 if (siocaifaddr(ifp->name, ifa->inaddr, ifa->inmask, ifa->inbcast)) {
1523 /* ups. */
1524 mib_iflist_bad = 1;
1525 return (-1);
1526 }
1527
1528 if (verify_ifa(ifp->name, ifa)) {
1529 /* ups. */
1530 mib_iflist_bad = 1;
1531 return (-1);
1532 }
1533
1534 return (0);
1535 }
1536
1537 /*
1538 * Destroy a freshly created interface address. Don't bother to wait for
1539 * the routing socket.
1540 */
1541 void
mib_uncreate_ifa(struct mibifa * ifa)1542 mib_uncreate_ifa(struct mibifa *ifa)
1543 {
1544 struct mibif *ifp;
1545
1546 if ((ifp = mib_find_if(ifa->ifindex)) == NULL) {
1547 /* ups. */
1548 mib_iflist_bad = 1;
1549 return;
1550 }
1551 if (siocdifaddr(ifp->name, ifa->inaddr)) {
1552 /* ups. */
1553 mib_iflist_bad = 1;
1554 return;
1555 }
1556
1557 destroy_ifa(ifa);
1558 }
1559
1560 /*
1561 * Create a new ifa and verify it
1562 */
1563 struct mibifa *
mib_create_ifa(u_int ifindex,struct in_addr addr,struct in_addr mask,struct in_addr bcast)1564 mib_create_ifa(u_int ifindex, struct in_addr addr, struct in_addr mask,
1565 struct in_addr bcast)
1566 {
1567 struct mibif *ifp;
1568 struct mibifa *ifa;
1569
1570 if ((ifp = mib_find_if(ifindex)) == NULL)
1571 return (NULL);
1572 if ((ifa = alloc_ifa(ifindex, addr)) == NULL)
1573 return (NULL);
1574 ifa->inmask = mask;
1575 ifa->inbcast = bcast;
1576
1577 if (siocaifaddr(ifp->name, ifa->inaddr, ifa->inmask, ifa->inbcast)) {
1578 syslog(LOG_ERR, "%s: %m", __func__);
1579 destroy_ifa(ifa);
1580 return (NULL);
1581 }
1582 if (verify_ifa(ifp->name, ifa)) {
1583 destroy_ifa(ifa);
1584 return (NULL);
1585 }
1586 return (ifa);
1587 }
1588
1589 /*
1590 * Get all cloning interfaces and make them dynamic.
1591 * Hah! Whe should probably do this on a periodic basis (XXX).
1592 */
1593 static void
get_cloners(void)1594 get_cloners(void)
1595 {
1596 struct if_clonereq req;
1597 char *buf, *cp;
1598 int i;
1599
1600 memset(&req, 0, sizeof(req));
1601 if (ioctl(mib_netsock, SIOCIFGCLONERS, &req) == -1) {
1602 syslog(LOG_ERR, "get cloners: %m");
1603 return;
1604 }
1605 if ((buf = malloc(req.ifcr_total * IFNAMSIZ)) == NULL) {
1606 syslog(LOG_ERR, "%m");
1607 return;
1608 }
1609 req.ifcr_count = req.ifcr_total;
1610 req.ifcr_buffer = buf;
1611 if (ioctl(mib_netsock, SIOCIFGCLONERS, &req) == -1) {
1612 syslog(LOG_ERR, "get cloners: %m");
1613 free(buf);
1614 return;
1615 }
1616 for (cp = buf, i = 0; i < req.ifcr_total; i++, cp += IFNAMSIZ)
1617 mib_if_set_dyn(cp);
1618 free(buf);
1619 }
1620
1621 /*
1622 * Idle function
1623 */
1624 static void
mibII_idle(void * arg __unused)1625 mibII_idle(void *arg __unused)
1626 {
1627 struct mibifa *ifa;
1628
1629 if (mib_iflist_bad) {
1630 TAILQ_FOREACH(ifa, &mibifa_list, link)
1631 ifa->flags &= ~MIBIFA_DESTROYED;
1632
1633 /* assume, that all cloning interfaces are dynamic */
1634 get_cloners();
1635
1636 mib_refresh_iflist();
1637 update_ifa_info();
1638 mib_arp_update();
1639 mib_iflist_bad = 0;
1640 }
1641
1642 mib_arp_update();
1643 }
1644
1645
1646 /*
1647 * Start the module
1648 */
1649 static void
mibII_start(void)1650 mibII_start(void)
1651 {
1652 if ((route_fd = fd_select(route, route_input, NULL, module)) == NULL) {
1653 syslog(LOG_ERR, "fd_select(route): %m");
1654 return;
1655 }
1656 mib_refresh_iflist();
1657 update_ifa_info();
1658 mib_arp_update();
1659 (void)mib_fetch_route();
1660 mib_iftable_last_change = 0;
1661 mib_ifstack_last_change = 0;
1662
1663 ifmib_reg = or_register(&oid_ifMIB,
1664 "The MIB module to describe generic objects for network interface"
1665 " sub-layers.", module);
1666
1667 ipmib_reg = or_register(&oid_ipMIB,
1668 "The MIB module for managing IP and ICMP implementations, but "
1669 "excluding their management of IP routes.", module);
1670
1671 tcpmib_reg = or_register(&oid_tcpMIB,
1672 "The MIB module for managing TCP implementations.", module);
1673
1674 udpmib_reg = or_register(&oid_udpMIB,
1675 "The MIB module for managing UDP implementations.", module);
1676
1677 ipForward_reg = or_register(&oid_ipForward,
1678 "The MIB module for the display of CIDR multipath IP Routes.",
1679 module);
1680
1681 mibII_poll_timer = NULL;
1682 mibII_poll_ticks = MIBII_POLL_TICKS;
1683 mibif_restart_mibII_poll_timer();
1684 }
1685
1686 /*
1687 * Initialize the module
1688 */
1689 static int
mibII_init(struct lmodule * mod,int argc __unused,char * argv[]__unused)1690 mibII_init(struct lmodule *mod, int argc __unused, char *argv[] __unused)
1691 {
1692 size_t len;
1693
1694 module = mod;
1695
1696 len = sizeof(clockinfo);
1697 if (sysctlbyname("kern.clockrate", &clockinfo, &len, NULL, 0) == -1) {
1698 syslog(LOG_ERR, "kern.clockrate: %m");
1699 return (-1);
1700 }
1701 if (len != sizeof(clockinfo)) {
1702 syslog(LOG_ERR, "kern.clockrate: wrong size");
1703 return (-1);
1704 }
1705
1706 if ((route = socket(PF_ROUTE, SOCK_RAW, AF_UNSPEC)) == -1) {
1707 syslog(LOG_ERR, "PF_ROUTE: %m");
1708 return (-1);
1709 }
1710
1711 if ((mib_netsock = socket(PF_INET, SOCK_DGRAM, 0)) == -1) {
1712 syslog(LOG_ERR, "PF_INET: %m");
1713 (void)close(route);
1714 return (-1);
1715 }
1716 (void)shutdown(mib_netsock, SHUT_RDWR);
1717
1718 /* assume, that all cloning interfaces are dynamic */
1719 get_cloners();
1720
1721 return (0);
1722 }
1723
1724 static int
mibII_fini(void)1725 mibII_fini(void)
1726 {
1727 if (mibII_poll_timer != NULL ) {
1728 timer_stop(mibII_poll_timer);
1729 mibII_poll_timer = NULL;
1730 }
1731
1732 if (route_fd != NULL)
1733 fd_deselect(route_fd);
1734 if (route != -1)
1735 (void)close(route);
1736 if (mib_netsock != -1)
1737 (void)close(mib_netsock);
1738 /* XXX free memory */
1739
1740 or_unregister(ipForward_reg);
1741 or_unregister(udpmib_reg);
1742 or_unregister(tcpmib_reg);
1743 or_unregister(ipmib_reg);
1744 or_unregister(ifmib_reg);
1745
1746 return (0);
1747 }
1748
1749 static void
mibII_loading(const struct lmodule * mod,int loaded)1750 mibII_loading(const struct lmodule *mod, int loaded)
1751 {
1752 struct mibif *ifp;
1753
1754 if (loaded == 1)
1755 return;
1756
1757 TAILQ_FOREACH(ifp, &mibif_list, link)
1758 if (ifp->xnotify_mod == mod) {
1759 ifp->xnotify_mod = NULL;
1760 ifp->xnotify_data = NULL;
1761 ifp->xnotify = NULL;
1762 }
1763
1764 mib_unregister_newif(mod);
1765 }
1766
1767 const struct snmp_module config = {
1768 "This module implements the interface and ip groups.",
1769 mibII_init,
1770 mibII_fini,
1771 NULL, /* idle */
1772 NULL, /* dump */
1773 NULL, /* config */
1774 mibII_start,
1775 NULL,
1776 mibII_ctree,
1777 mibII_CTREE_SIZE,
1778 mibII_loading
1779 };
1780
1781 /*
1782 * Should have a list of these attached to each interface.
1783 */
1784 void *
mibif_notify(struct mibif * ifp,const struct lmodule * mod,mibif_notify_f func,void * data)1785 mibif_notify(struct mibif *ifp, const struct lmodule *mod,
1786 mibif_notify_f func, void *data)
1787 {
1788 ifp->xnotify = func;
1789 ifp->xnotify_data = data;
1790 ifp->xnotify_mod = mod;
1791
1792 return (ifp);
1793 }
1794
1795 void
mibif_unnotify(void * arg)1796 mibif_unnotify(void *arg)
1797 {
1798 struct mibif *ifp = arg;
1799
1800 ifp->xnotify = NULL;
1801 ifp->xnotify_data = NULL;
1802 ifp->xnotify_mod = NULL;
1803 }
1804