2 * Copyright (c) 2001-2003
3 * Fraunhofer Institute for Open Communication Systems (FhG Fokus).
6 * Author: Harti Brandt <harti@freebsd.org>
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
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.
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
29 * $Begemot: bsnmp/snmp_mibII/mibII.c,v 1.24 2006/02/14 09:04:18 brandt_h Exp $
31 * Implementation of the standard interfaces and ip MIB.
34 #include "mibII_oid.h"
35 #include <net/if_types.h>
38 /*****************************/
41 static struct lmodule *module;
45 static void *route_fd;
47 /* if-index allocator */
48 static uint32_t next_if_index = 1;
50 /* re-fetch arp table */
51 static int update_arp;
52 static int in_update_arp;
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;
61 /*****************************/
63 /* list of all IP addresses */
64 struct mibifa_list mibifa_list = TAILQ_HEAD_INITIALIZER(mibifa_list);
66 /* list of all interfaces */
67 struct mibif_list mibif_list = TAILQ_HEAD_INITIALIZER(mibif_list);
69 /* list of dynamic interface names */
70 struct mibdynif_list mibdynif_list = SLIST_HEAD_INITIALIZER(mibdynif_list);
72 /* list of all interface index mappings */
73 struct mibindexmap_list mibindexmap_list = STAILQ_HEAD_INITIALIZER(mibindexmap_list);
75 /* list of all stacking entries */
76 struct mibifstack_list mibifstack_list = TAILQ_HEAD_INITIALIZER(mibifstack_list);
78 /* list of all receive addresses */
79 struct mibrcvaddr_list mibrcvaddr_list = TAILQ_HEAD_INITIALIZER(mibrcvaddr_list);
81 /* list of all NetToMedia entries */
82 struct mibarp_list mibarp_list = TAILQ_HEAD_INITIALIZER(mibarp_list);
84 /* number of interfaces */
85 int32_t mib_if_number;
87 /* last change of table */
88 uint64_t mib_iftable_last_change;
90 /* last change of stack table */
91 uint64_t mib_ifstack_last_change;
93 /* if this is set, one of our lists may be bad. refresh them when idle */
99 /* last time refreshed */
100 uint64_t mibarpticks;
102 /* info on system clocks */
103 struct clockinfo clockinfo;
105 /* list of all New if registrations */
106 static struct newifreg_list newifreg_list = TAILQ_HEAD_INITIALIZER(newifreg_list);
108 /* baud rate of fastest interface */
109 uint64_t mibif_maxspeed;
111 /* user-forced update interval */
112 u_int mibif_force_hc_update_interval;
114 /* current update interval */
115 u_int mibif_hc_update_interval;
117 /* HC update timer handle */
118 static void *hc_update_timer;
120 /*****************************/
122 static const struct asn_oid oid_ifMIB = OIDX_ifMIB;
123 static const struct asn_oid oid_ipMIB = OIDX_ipMIB;
124 static const struct asn_oid oid_tcpMIB = OIDX_tcpMIB;
125 static const struct asn_oid oid_udpMIB = OIDX_udpMIB;
126 static const struct asn_oid oid_ipForward = OIDX_ipForward;
127 static const struct asn_oid oid_linkDown = OIDX_linkDown;
128 static const struct asn_oid oid_linkUp = OIDX_linkUp;
129 static const struct asn_oid oid_ifIndex = OIDX_ifIndex;
131 /*****************************/
137 mib_find_if(u_int idx)
141 TAILQ_FOREACH(ifp, &mibif_list, link)
142 if (ifp->index == idx)
148 mib_find_if_sys(u_int sysindex)
152 TAILQ_FOREACH(ifp, &mibif_list, link)
153 if (ifp->sysindex == sysindex)
159 mib_find_if_name(const char *name)
163 TAILQ_FOREACH(ifp, &mibif_list, link)
164 if (strcmp(ifp->name, name) == 0)
170 * Check whether an interface is dynamic. The argument may include the
171 * unit number. This assumes, that the name part does NOT contain digits.
174 mib_if_is_dyn(const char *name)
179 for (len = 0; name[len] != '\0' && isalpha(name[len]) ; len++)
181 SLIST_FOREACH(d, &mibdynif_list, link)
182 if (strlen(d->name) == len && strncmp(d->name, name, len) == 0)
187 /* set an interface name to dynamic mode */
189 mib_if_set_dyn(const char *name)
193 SLIST_FOREACH(d, &mibdynif_list, link)
194 if (strcmp(name, d->name) == 0)
196 if ((d = malloc(sizeof(*d))) == NULL)
198 strcpy(d->name, name);
199 SLIST_INSERT_HEAD(&mibdynif_list, d, link);
203 * register for interface creations
206 mib_register_newif(int (*func)(struct mibif *), const struct lmodule *mod)
208 struct newifreg *reg;
210 TAILQ_FOREACH(reg, &newifreg_list, link)
211 if (reg->mod == mod) {
215 if ((reg = malloc(sizeof(*reg))) == NULL) {
216 syslog(LOG_ERR, "newifreg: %m");
221 TAILQ_INSERT_TAIL(&newifreg_list, reg, link);
227 mib_unregister_newif(const struct lmodule *mod)
229 struct newifreg *reg;
231 TAILQ_FOREACH(reg, &newifreg_list, link)
232 if (reg->mod == mod) {
233 TAILQ_REMOVE(&newifreg_list, reg, link);
243 return (TAILQ_FIRST(&mibif_list));
246 mib_next_if(const struct mibif *ifp)
248 return (TAILQ_NEXT(ifp, link));
252 * Change the admin status of an interface
255 mib_if_admin(struct mibif *ifp, int up)
259 strncpy(ifr.ifr_name, ifp->name, sizeof(ifr.ifr_name));
260 if (ioctl(mib_netsock, SIOCGIFFLAGS, &ifr) == -1) {
261 syslog(LOG_ERR, "SIOCGIFFLAGS(%s): %m", ifp->name);
265 ifr.ifr_flags |= IFF_UP;
267 ifr.ifr_flags &= ~IFF_UP;
268 if (ioctl(mib_netsock, SIOCSIFFLAGS, &ifr) == -1) {
269 syslog(LOG_ERR, "SIOCSIFFLAGS(%s): %m", ifp->name);
273 (void)mib_fetch_ifmib(ifp);
279 * Generate a link up/down trap
282 link_trap(struct mibif *ifp, int up)
284 struct snmp_value ifindex;
286 ifindex.var = oid_ifIndex;
287 ifindex.var.subs[ifindex.var.len++] = ifp->index;
288 ifindex.syntax = SNMP_SYNTAX_INTEGER;
289 ifindex.v.integer = ifp->index;
291 snmp_send_trap(up ? &oid_linkUp : &oid_linkDown, &ifindex,
292 (struct snmp_value *)NULL);
296 * Fetch the GENERIC IFMIB and update the HC counters
299 fetch_generic_mib(struct mibif *ifp, const struct ifmibdata *old)
303 struct mibif_private *p = ifp->private;
307 name[2] = NETLINK_GENERIC;
308 name[3] = IFMIB_IFDATA;
309 name[4] = ifp->sysindex;
310 name[5] = IFDATA_GENERAL;
312 len = sizeof(ifp->mib);
313 if (sysctl(name, 6, &ifp->mib, &len, NULL, 0) == -1) {
315 syslog(LOG_WARNING, "sysctl(ifmib, %s) failed %m",
321 * Assume that one of the two following compounds is optimized away
323 if (ULONG_MAX >= 0xffffffffffffffffULL) {
324 p->hc_inoctets = ifp->mib.ifmd_data.ifi_ibytes;
325 p->hc_outoctets = ifp->mib.ifmd_data.ifi_obytes;
326 p->hc_omcasts = ifp->mib.ifmd_data.ifi_omcasts;
327 p->hc_opackets = ifp->mib.ifmd_data.ifi_opackets;
328 p->hc_imcasts = ifp->mib.ifmd_data.ifi_imcasts;
329 p->hc_ipackets = ifp->mib.ifmd_data.ifi_ipackets;
331 } else if (ULONG_MAX >= 0xffffffff) {
333 #define UPDATE(HC, MIB) \
334 if (old->ifmd_data.MIB > ifp->mib.ifmd_data.MIB) \
335 p->HC += (0x100000000ULL + \
336 ifp->mib.ifmd_data.MIB) - \
337 old->ifmd_data.MIB; \
339 p->HC += ifp->mib.ifmd_data.MIB - \
342 UPDATE(hc_inoctets, ifi_ibytes)
343 UPDATE(hc_outoctets, ifi_obytes)
344 UPDATE(hc_omcasts, ifi_omcasts)
345 UPDATE(hc_opackets, ifi_opackets)
346 UPDATE(hc_imcasts, ifi_imcasts)
347 UPDATE(hc_ipackets, ifi_ipackets)
356 * Update the 64-bit interface counters
359 update_hc_counters(void *arg __unused)
362 struct ifmibdata oldmib;
364 TAILQ_FOREACH(ifp, &mibif_list, link) {
366 (void)fetch_generic_mib(ifp, &oldmib);
371 * Recompute the poll timer for the HC counters
374 mibif_reset_hc_timer(void)
378 if ((ticks = mibif_force_hc_update_interval) == 0) {
379 if (mibif_maxspeed <= 10000000) {
380 /* at 10Mbps overflow needs 3436 seconds */
381 ticks = 3000 * 100; /* 50 minutes */
382 } else if (mibif_maxspeed <= 100000000) {
383 /* at 100Mbps overflow needs 343 seconds */
384 ticks = 300 * 100; /* 5 minutes */
385 } else if (mibif_maxspeed < 650000000) {
386 /* at 622Mbps overflow needs 53 seconds */
387 ticks = 40 * 100; /* 40 seconds */
388 } else if (mibif_maxspeed <= 1000000000) {
389 /* at 1Gbps overflow needs 34 seconds */
390 ticks = 20 * 100; /* 20 seconds */
392 /* at 10Gbps overflow needs 3.4 seconds */
393 ticks = 100; /* 1 seconds */
397 if (ticks == mibif_hc_update_interval)
400 if (hc_update_timer != NULL) {
401 timer_stop(hc_update_timer);
402 hc_update_timer = NULL;
404 update_hc_counters(NULL);
405 if ((hc_update_timer = timer_start_repeat(ticks * 10, ticks * 10,
406 update_hc_counters, NULL, module)) == NULL) {
407 syslog(LOG_ERR, "timer_start(%u): %m", ticks);
410 mibif_hc_update_interval = ticks;
414 * Fetch new MIB data.
417 mib_fetch_ifmib(struct mibif *ifp)
422 struct ifmibdata oldmib = ifp->mib;
424 if (fetch_generic_mib(ifp, &oldmib) == -1)
428 * Quoting RFC2863, 3.1.15: "... LinkUp and linkDown traps are
429 * generated just after ifOperStatus leaves, or just before it
430 * enters, the down state, respectively;"
432 if (ifp->trap_enable && ifp->mib.ifmd_data.ifi_link_state !=
433 oldmib.ifmd_data.ifi_link_state &&
434 (ifp->mib.ifmd_data.ifi_link_state == LINK_STATE_DOWN ||
435 oldmib.ifmd_data.ifi_link_state == LINK_STATE_DOWN))
436 link_trap(ifp, ifp->mib.ifmd_data.ifi_link_state ==
437 LINK_STATE_UP ? 1 : 0);
439 ifp->flags &= ~(MIBIF_HIGHSPEED | MIBIF_VERYHIGHSPEED);
440 if (ifp->mib.ifmd_data.ifi_baudrate > 20000000) {
441 ifp->flags |= MIBIF_HIGHSPEED;
442 if (ifp->mib.ifmd_data.ifi_baudrate > 650000000)
443 ifp->flags |= MIBIF_VERYHIGHSPEED;
445 if (ifp->mib.ifmd_data.ifi_baudrate > mibif_maxspeed) {
446 mibif_maxspeed = ifp->mib.ifmd_data.ifi_baudrate;
447 mibif_reset_hc_timer();
455 name[2] = NETLINK_GENERIC;
456 name[3] = IFMIB_IFDATA;
457 name[4] = ifp->sysindex;
458 name[5] = IFDATA_LINKSPECIFIC;
459 if (sysctl(name, 6, NULL, &len, NULL, 0) == -1) {
460 syslog(LOG_WARNING, "sysctl linkmib estimate (%s): %m",
462 if (ifp->specmib != NULL) {
469 if (ifp->specmib != NULL) {
476 if (ifp->specmiblen != len) {
477 if ((newmib = realloc(ifp->specmib, len)) == NULL) {
482 ifp->specmib = newmib;
483 ifp->specmiblen = len;
485 if (sysctl(name, 6, ifp->specmib, &len, NULL, 0) == -1) {
486 syslog(LOG_WARNING, "sysctl linkmib (%s): %m", ifp->name);
487 if (ifp->specmib != NULL) {
494 ifp->mibtick = get_ticks();
498 /* find first/next address for a given interface */
500 mib_first_ififa(const struct mibif *ifp)
504 TAILQ_FOREACH(ifa, &mibifa_list, link)
505 if (ifp->index == ifa->ifindex)
511 mib_next_ififa(struct mibifa *ifa0)
516 while ((ifa = TAILQ_NEXT(ifa, link)) != NULL)
517 if (ifa->ifindex == ifa0->ifindex)
525 static struct mibifa *
526 alloc_ifa(u_int ifindex, struct in_addr addr)
531 if ((ifa = malloc(sizeof(struct mibifa))) == NULL) {
532 syslog(LOG_ERR, "ifa: %m");
536 ifa->ifindex = ifindex;
538 ha = ntohl(ifa->inaddr.s_addr);
540 ifa->index.subs[0] = (ha >> 24) & 0xff;
541 ifa->index.subs[1] = (ha >> 16) & 0xff;
542 ifa->index.subs[2] = (ha >> 8) & 0xff;
543 ifa->index.subs[3] = (ha >> 0) & 0xff;
546 ifa->inbcast.s_addr = 0;
547 ifa->inmask.s_addr = 0xffffffff;
549 INSERT_OBJECT_OID(ifa, &mibifa_list);
555 * Delete an interface address
558 destroy_ifa(struct mibifa *ifa)
560 TAILQ_REMOVE(&mibifa_list, ifa, link);
566 * Helper routine to extract the sockaddr structures from a routing
570 mib_extract_addrs(int addrs, u_char *info, struct sockaddr **out)
574 for (i = 0; i < RTAX_MAX; i++) {
575 if ((addrs & (1 << i)) != 0) {
576 *out = (struct sockaddr *)(void *)info;
577 info += roundup((*out)->sa_len, sizeof(long));
585 * save the phys address of an interface. Handle receive address entries here.
588 get_physaddr(struct mibif *ifp, struct sockaddr_dl *sdl, u_char *ptr)
591 struct mibrcvaddr *rcv;
593 if (sdl->sdl_alen == 0) {
595 if (ifp->physaddrlen != 0) {
596 if ((rcv = mib_find_rcvaddr(ifp->index, ifp->physaddr,
597 ifp->physaddrlen)) != NULL)
598 mib_rcvaddr_delete(rcv);
600 ifp->physaddr = NULL;
601 ifp->physaddrlen = 0;
606 if (ifp->physaddrlen != sdl->sdl_alen) {
608 if (ifp->physaddrlen) {
609 /* delete olf receive address */
610 if ((rcv = mib_find_rcvaddr(ifp->index, ifp->physaddr,
611 ifp->physaddrlen)) != NULL)
612 mib_rcvaddr_delete(rcv);
614 if ((np = realloc(ifp->physaddr, sdl->sdl_alen)) == NULL) {
616 ifp->physaddr = NULL;
617 ifp->physaddrlen = 0;
621 ifp->physaddrlen = sdl->sdl_alen;
623 } else if (memcmp(ifp->physaddr, ptr, ifp->physaddrlen) == 0) {
628 /* address changed */
630 /* delete olf receive address */
631 if ((rcv = mib_find_rcvaddr(ifp->index, ifp->physaddr,
632 ifp->physaddrlen)) != NULL)
633 mib_rcvaddr_delete(rcv);
636 memcpy(ifp->physaddr, ptr, ifp->physaddrlen);
638 /* make new receive address */
639 if ((rcv = mib_rcvaddr_create(ifp, ifp->physaddr, ifp->physaddrlen)) != NULL)
640 rcv->flags |= MIBRCVADDR_HW;
647 mibif_free(struct mibif *ifp)
650 struct mibindexmap *map;
651 struct mibifa *ifa, *ifa1;
652 struct mibrcvaddr *rcv, *rcv1;
653 struct mibarp *at, *at1;
655 if (ifp->xnotify != NULL)
656 (*ifp->xnotify)(ifp, MIBIF_NOTIFY_DESTROY, ifp->xnotify_data);
658 (void)mib_ifstack_delete(ifp, NULL);
659 (void)mib_ifstack_delete(NULL, ifp);
661 TAILQ_REMOVE(&mibif_list, ifp, link);
663 /* if this was the fastest interface - recompute this */
664 if (ifp->mib.ifmd_data.ifi_baudrate == mibif_maxspeed) {
665 mibif_maxspeed = ifp->mib.ifmd_data.ifi_baudrate;
666 TAILQ_FOREACH(ifp1, &mibif_list, link)
667 if (ifp1->mib.ifmd_data.ifi_baudrate > mibif_maxspeed)
669 ifp1->mib.ifmd_data.ifi_baudrate;
670 mibif_reset_hc_timer();
674 if (ifp->physaddr != NULL)
676 if (ifp->specmib != NULL)
679 STAILQ_FOREACH(map, &mibindexmap_list, link)
680 if (map->mibif == ifp) {
685 /* purge interface addresses */
686 ifa = TAILQ_FIRST(&mibifa_list);
687 while (ifa != NULL) {
688 ifa1 = TAILQ_NEXT(ifa, link);
689 if (ifa->ifindex == ifp->index)
694 /* purge receive addresses */
695 rcv = TAILQ_FIRST(&mibrcvaddr_list);
696 while (rcv != NULL) {
697 rcv1 = TAILQ_NEXT(rcv, link);
698 if (rcv->ifindex == ifp->index)
699 mib_rcvaddr_delete(rcv);
703 /* purge ARP entries */
704 at = TAILQ_FIRST(&mibarp_list);
706 at1 = TAILQ_NEXT(at, link);
707 if (at->index.subs[0] == ifp->index)
715 mib_iftable_last_change = this_tick;
719 * Create a new interface
721 static struct mibif *
722 mibif_create(u_int sysindex, const char *name)
725 struct mibindexmap *map;
727 if ((ifp = malloc(sizeof(*ifp))) == NULL) {
728 syslog(LOG_WARNING, "%s: %m", __func__);
731 memset(ifp, 0, sizeof(*ifp));
732 if ((ifp->private = malloc(sizeof(struct mibif_private))) == NULL) {
733 syslog(LOG_WARNING, "%s: %m", __func__);
737 memset(ifp->private, 0, sizeof(struct mibif_private));
739 ifp->sysindex = sysindex;
740 strcpy(ifp->name, name);
741 strcpy(ifp->descr, name);
742 ifp->spec_oid = oid_zeroDotZero;
745 if (!mib_if_is_dyn(ifp->name)) {
746 /* non-dynamic. look whether we know the interface */
747 STAILQ_FOREACH(map, &mibindexmap_list, link)
748 if (strcmp(map->name, ifp->name) == 0) {
749 ifp->index = map->ifindex;
753 /* assume it has a connector if it is not dynamic */
754 ifp->has_connector = 1;
755 ifp->trap_enable = 1;
758 /* new interface - get new index */
759 if (next_if_index > 0x7fffffff)
760 errx(1, "ifindex wrap");
762 if ((map = malloc(sizeof(*map))) == NULL) {
763 syslog(LOG_ERR, "ifmap: %m");
767 map->ifindex = next_if_index++;
768 map->sysindex = ifp->sysindex;
769 strcpy(map->name, ifp->name);
771 STAILQ_INSERT_TAIL(&mibindexmap_list, map, link);
773 /* re-instantiate. Introduce a counter discontinuity */
774 ifp->counter_disc = get_ticks();
776 ifp->index = map->ifindex;
777 ifp->mib.ifmd_data.ifi_link_state = LINK_STATE_UNKNOWN;
779 INSERT_OBJECT_INT(ifp, &mibif_list);
781 mib_iftable_last_change = this_tick;
783 /* instantiate default ifStack entries */
784 (void)mib_ifstack_create(ifp, NULL);
785 (void)mib_ifstack_create(NULL, ifp);
791 * Inform all interested parties about a new interface
794 notify_newif(struct mibif *ifp)
796 struct newifreg *reg;
798 TAILQ_FOREACH(reg, &newifreg_list, link)
799 if ((*reg->func)(ifp))
804 * This is called for new interfaces after we have fetched the interface
805 * MIB. If this is a broadcast interface try to guess the broadcast address
806 * depending on the interface type.
809 check_llbcast(struct mibif *ifp)
811 static u_char ether_bcast[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
812 static u_char arcnet_bcast = 0;
813 struct mibrcvaddr *rcv;
815 if (!(ifp->mib.ifmd_flags & IFF_BROADCAST))
818 switch (ifp->mib.ifmd_data.ifi_type) {
823 if (mib_find_rcvaddr(ifp->index, ether_bcast, 6) == NULL &&
824 (rcv = mib_rcvaddr_create(ifp, ether_bcast, 6)) != NULL)
825 rcv->flags |= MIBRCVADDR_BCAST;
829 if (mib_find_rcvaddr(ifp->index, &arcnet_bcast, 1) == NULL &&
830 (rcv = mib_rcvaddr_create(ifp, &arcnet_bcast, 1)) != NULL)
831 rcv->flags |= MIBRCVADDR_BCAST;
838 * Retrieve the current interface list from the system.
841 mib_refresh_iflist(void)
843 struct mibif *ifp, *ifp1;
848 struct ifmibdata mib;
850 TAILQ_FOREACH(ifp, &mibif_list, link)
851 ifp->flags &= ~MIBIF_FOUND;
854 if (sysctlbyname("net.link.generic.system.ifcount", &count, &len,
856 syslog(LOG_ERR, "ifcount: %m");
861 name[2] = NETLINK_GENERIC;
862 name[3] = IFMIB_IFDATA;
863 name[5] = IFDATA_GENERAL;
864 for (idx = 1; idx <= count; idx++) {
867 if (sysctl(name, 6, &mib, &len, NULL, 0) == -1) {
870 syslog(LOG_ERR, "ifmib(%u): %m", idx);
873 if ((ifp = mib_find_if_sys(idx)) != NULL) {
874 ifp->flags |= MIBIF_FOUND;
877 /* Unknown interface - create */
878 if ((ifp = mibif_create(idx, mib.ifmd_name)) != NULL) {
879 ifp->flags |= MIBIF_FOUND;
880 (void)mib_fetch_ifmib(ifp);
887 * Purge interfaces that disappeared
889 ifp = TAILQ_FIRST(&mibif_list);
890 while (ifp != NULL) {
891 ifp1 = TAILQ_NEXT(ifp, link);
892 if (!(ifp->flags & MIBIF_FOUND))
899 * Find an interface address
902 mib_find_ifa(struct in_addr addr)
906 TAILQ_FOREACH(ifa, &mibifa_list, link)
907 if (ifa->inaddr.s_addr == addr.s_addr)
913 * Process a new ARP entry
916 process_arp(const struct rt_msghdr *rtm, const struct sockaddr_dl *sdl,
917 const struct sockaddr_in *sa)
922 /* IP arp table entry */
923 if (sdl->sdl_alen == 0) {
927 if ((ifp = mib_find_if_sys(sdl->sdl_index)) == NULL)
929 /* have a valid entry */
930 if ((at = mib_find_arp(ifp, sa->sin_addr)) == NULL &&
931 (at = mib_arp_create(ifp, sa->sin_addr,
932 sdl->sdl_data + sdl->sdl_nlen, sdl->sdl_alen)) == NULL)
935 if (rtm->rtm_rmx.rmx_expire == 0)
936 at->flags |= MIBARP_PERM;
938 at->flags &= ~MIBARP_PERM;
939 at->flags |= MIBARP_FOUND;
943 * Handle a routing socket message.
946 handle_rtmsg(struct rt_msghdr *rtm)
948 struct sockaddr *addrs[RTAX_MAX];
949 struct if_msghdr *ifm;
950 struct ifa_msghdr *ifam;
951 struct ifma_msghdr *ifmam;
952 #ifdef RTM_IFANNOUNCE
953 struct if_announcemsghdr *ifan;
956 struct sockaddr_dl *sdl;
957 struct sockaddr_in *sa;
959 struct mibrcvaddr *rcv;
962 if (rtm->rtm_version != RTM_VERSION) {
963 syslog(LOG_ERR, "Bogus RTM version %u", rtm->rtm_version);
967 switch (rtm->rtm_type) {
970 ifam = (struct ifa_msghdr *)rtm;
971 mib_extract_addrs(ifam->ifam_addrs, (u_char *)(ifam + 1), addrs);
972 if (addrs[RTAX_IFA] == NULL || addrs[RTAX_NETMASK] == NULL)
975 sa = (struct sockaddr_in *)(void *)addrs[RTAX_IFA];
976 if ((ifa = mib_find_ifa(sa->sin_addr)) == NULL) {
977 /* unknown address */
978 if ((ifp = mib_find_if_sys(ifam->ifam_index)) == NULL) {
979 syslog(LOG_WARNING, "RTM_NEWADDR for unknown "
980 "interface %u", ifam->ifam_index);
983 if ((ifa = alloc_ifa(ifp->index, sa->sin_addr)) == NULL)
986 sa = (struct sockaddr_in *)(void *)addrs[RTAX_NETMASK];
987 ifa->inmask = sa->sin_addr;
989 if (addrs[RTAX_BRD] != NULL) {
990 sa = (struct sockaddr_in *)(void *)addrs[RTAX_BRD];
991 ifa->inbcast = sa->sin_addr;
993 ifa->flags |= MIBIFA_FOUND;
997 ifam = (struct ifa_msghdr *)rtm;
998 mib_extract_addrs(ifam->ifam_addrs, (u_char *)(ifam + 1), addrs);
999 if (addrs[RTAX_IFA] == NULL)
1002 sa = (struct sockaddr_in *)(void *)addrs[RTAX_IFA];
1003 if ((ifa = mib_find_ifa(sa->sin_addr)) != NULL) {
1004 ifa->flags |= MIBIFA_FOUND;
1005 if (!(ifa->flags & MIBIFA_DESTROYED))
1011 ifmam = (struct ifma_msghdr *)rtm;
1012 mib_extract_addrs(ifmam->ifmam_addrs, (u_char *)(ifmam + 1), addrs);
1013 if (addrs[RTAX_IFA] == NULL ||
1014 addrs[RTAX_IFA]->sa_family != AF_LINK)
1016 sdl = (struct sockaddr_dl *)(void *)addrs[RTAX_IFA];
1017 if ((rcv = mib_find_rcvaddr(sdl->sdl_index,
1018 sdl->sdl_data + sdl->sdl_nlen, sdl->sdl_alen)) == NULL) {
1019 /* unknown address */
1020 if ((ifp = mib_find_if_sys(sdl->sdl_index)) == NULL) {
1021 syslog(LOG_WARNING, "RTM_NEWMADDR for unknown "
1022 "interface %u", sdl->sdl_index);
1025 if ((rcv = mib_rcvaddr_create(ifp,
1026 sdl->sdl_data + sdl->sdl_nlen, sdl->sdl_alen)) == NULL)
1028 rcv->flags |= MIBRCVADDR_VOLATILE;
1030 rcv->flags |= MIBRCVADDR_FOUND;
1034 ifmam = (struct ifma_msghdr *)rtm;
1035 mib_extract_addrs(ifmam->ifmam_addrs, (u_char *)(ifmam + 1), addrs);
1036 if (addrs[RTAX_IFA] == NULL ||
1037 addrs[RTAX_IFA]->sa_family != AF_LINK)
1039 sdl = (struct sockaddr_dl *)(void *)addrs[RTAX_IFA];
1040 if ((rcv = mib_find_rcvaddr(sdl->sdl_index,
1041 sdl->sdl_data + sdl->sdl_nlen, sdl->sdl_alen)) != NULL)
1042 mib_rcvaddr_delete(rcv);
1046 ifm = (struct if_msghdr *)rtm;
1047 mib_extract_addrs(ifm->ifm_addrs, (u_char *)(ifm + 1), addrs);
1048 if ((ifp = mib_find_if_sys(ifm->ifm_index)) == NULL)
1050 if (addrs[RTAX_IFP] != NULL &&
1051 addrs[RTAX_IFP]->sa_family == AF_LINK) {
1052 sdl = (struct sockaddr_dl *)(void *)addrs[RTAX_IFP];
1053 ptr = sdl->sdl_data + sdl->sdl_nlen;
1054 get_physaddr(ifp, sdl, ptr);
1056 (void)mib_fetch_ifmib(ifp);
1059 #ifdef RTM_IFANNOUNCE
1060 case RTM_IFANNOUNCE:
1061 ifan = (struct if_announcemsghdr *)rtm;
1062 ifp = mib_find_if_sys(ifan->ifan_index);
1064 switch (ifan->ifan_what) {
1067 if (ifp == NULL && (ifp = mibif_create(ifan->ifan_index,
1068 ifan->ifan_name)) != NULL) {
1069 (void)mib_fetch_ifmib(ifp);
1075 case IFAN_DEPARTURE:
1084 mib_extract_addrs(rtm->rtm_addrs, (u_char *)(rtm + 1), addrs);
1085 if (rtm->rtm_flags & RTF_LLINFO) {
1086 if (addrs[RTAX_DST] == NULL ||
1087 addrs[RTAX_GATEWAY] == NULL ||
1088 addrs[RTAX_DST]->sa_family != AF_INET ||
1089 addrs[RTAX_GATEWAY]->sa_family != AF_LINK)
1092 (struct sockaddr_dl *)(void *)addrs[RTAX_GATEWAY],
1093 (struct sockaddr_in *)(void *)addrs[RTAX_DST]);
1095 if (rtm->rtm_errno == 0 && (rtm->rtm_flags & RTF_UP))
1096 mib_sroute_process(rtm, addrs[RTAX_GATEWAY],
1097 addrs[RTAX_DST], addrs[RTAX_NETMASK]);
1102 mib_extract_addrs(rtm->rtm_addrs, (u_char *)(rtm + 1), addrs);
1103 if (rtm->rtm_flags & RTF_LLINFO) {
1104 if (addrs[RTAX_DST] == NULL ||
1105 addrs[RTAX_GATEWAY] == NULL ||
1106 addrs[RTAX_DST]->sa_family != AF_INET ||
1107 addrs[RTAX_GATEWAY]->sa_family != AF_LINK)
1110 (struct sockaddr_dl *)(void *)addrs[RTAX_GATEWAY],
1111 (struct sockaddr_in *)(void *)addrs[RTAX_DST]);
1113 if (rtm->rtm_errno == 0 && (rtm->rtm_flags & RTF_UP))
1114 mib_sroute_process(rtm, addrs[RTAX_GATEWAY],
1115 addrs[RTAX_DST], addrs[RTAX_NETMASK]);
1120 mib_extract_addrs(rtm->rtm_addrs, (u_char *)(rtm + 1), addrs);
1121 if (rtm->rtm_errno == 0 && !(rtm->rtm_flags & RTF_LLINFO))
1122 mib_sroute_process(rtm, addrs[RTAX_GATEWAY],
1123 addrs[RTAX_DST], addrs[RTAX_NETMASK]);
1129 * send a routing message
1132 mib_send_rtmsg(struct rt_msghdr *rtm, struct sockaddr *gw,
1133 struct sockaddr *dst, struct sockaddr *mask)
1136 struct rt_msghdr *msg;
1140 len = sizeof(*rtm) + SA_SIZE(gw) + SA_SIZE(dst) + SA_SIZE(mask);
1141 if ((msg = malloc(len)) == NULL) {
1142 syslog(LOG_ERR, "%s: %m", __func__);
1145 cp = (char *)(msg + 1);
1147 memset(msg, 0, sizeof(*msg));
1149 msg->rtm_version = RTM_VERSION;
1150 msg->rtm_addrs = RTA_DST | RTA_GATEWAY;
1152 memcpy(cp, dst, SA_SIZE(dst));
1154 memcpy(cp, gw, SA_SIZE(gw));
1157 memcpy(cp, mask, SA_SIZE(mask));
1158 cp += SA_SIZE(mask);
1159 msg->rtm_addrs |= RTA_NETMASK;
1161 msg->rtm_msglen = cp - (char *)msg;
1162 msg->rtm_type = RTM_GET;
1163 if ((sent = write(route, msg, msg->rtm_msglen)) == -1) {
1164 syslog(LOG_ERR, "%s: write: %m", __func__);
1168 if (sent != msg->rtm_msglen) {
1169 syslog(LOG_ERR, "%s: short write", __func__);
1177 * Fetch the routing table via sysctl
1180 mib_fetch_rtab(int af, int info, int arg, size_t *lenp)
1183 u_char *buf, *newbuf;
1194 /* initial estimate */
1195 if (sysctl(name, 6, NULL, lenp, NULL, 0) == -1) {
1196 syslog(LOG_ERR, "sysctl estimate (%d,%d,%d,%d,%d,%d): %m",
1197 name[0], name[1], name[2], name[3], name[4], name[5]);
1205 if ((newbuf = realloc(buf, *lenp)) == NULL) {
1206 syslog(LOG_ERR, "sysctl buffer: %m");
1212 if (sysctl(name, 6, buf, lenp, NULL, 0) == 0)
1215 if (errno != ENOMEM) {
1216 syslog(LOG_ERR, "sysctl get: %m");
1220 *lenp += *lenp / 8 + 1;
1227 * Update the following info: interface, interface addresses, interface
1228 * receive addresses, arp-table.
1229 * This does not change the interface list itself.
1232 update_ifa_info(void)
1235 struct rt_msghdr *rtm;
1236 struct mibifa *ifa, *ifa1;
1237 struct mibrcvaddr *rcv, *rcv1;
1239 static const int infos[][3] = {
1240 { 0, NET_RT_IFLIST, 0 },
1241 #ifdef NET_RT_IFMALIST
1242 { AF_LINK, NET_RT_IFMALIST, 0 },
1247 TAILQ_FOREACH(ifa, &mibifa_list, link)
1248 ifa->flags &= ~MIBIFA_FOUND;
1249 TAILQ_FOREACH(rcv, &mibrcvaddr_list, link)
1250 rcv->flags &= ~MIBRCVADDR_FOUND;
1252 for (i = 0; i < sizeof(infos) / sizeof(infos[0]); i++) {
1253 if ((buf = mib_fetch_rtab(infos[i][0], infos[i][1], infos[i][2],
1258 while (next < buf + needed) {
1259 rtm = (struct rt_msghdr *)(void *)next;
1260 next += rtm->rtm_msglen;
1267 * Purge the address list of unused entries. These may happen for
1268 * interface aliases that are on the same subnet. We don't receive
1269 * routing socket messages for them.
1271 ifa = TAILQ_FIRST(&mibifa_list);
1272 while (ifa != NULL) {
1273 ifa1 = TAILQ_NEXT(ifa, link);
1274 if (!(ifa->flags & MIBIFA_FOUND))
1279 rcv = TAILQ_FIRST(&mibrcvaddr_list);
1280 while (rcv != NULL) {
1281 rcv1 = TAILQ_NEXT(rcv, link);
1282 if (!(rcv->flags & (MIBRCVADDR_FOUND | MIBRCVADDR_BCAST |
1284 mib_rcvaddr_delete(rcv);
1293 mib_arp_update(void)
1295 struct mibarp *at, *at1;
1298 struct rt_msghdr *rtm;
1301 return; /* Aaargh */
1304 TAILQ_FOREACH(at, &mibarp_list, link)
1305 at->flags &= ~MIBARP_FOUND;
1307 if ((buf = mib_fetch_rtab(AF_INET, NET_RT_FLAGS, RTF_LLINFO, &needed)) == NULL) {
1313 while (next < buf + needed) {
1314 rtm = (struct rt_msghdr *)(void *)next;
1315 next += rtm->rtm_msglen;
1320 at = TAILQ_FIRST(&mibarp_list);
1321 while (at != NULL) {
1322 at1 = TAILQ_NEXT(at, link);
1323 if (!(at->flags & MIBARP_FOUND))
1327 mibarpticks = get_ticks();
1334 * Intput on the routing socket.
1337 route_input(int fd, void *udata __unused)
1339 u_char buf[1024 * 16];
1341 struct rt_msghdr *rtm;
1343 if ((n = read(fd, buf, sizeof(buf))) == -1)
1344 err(1, "read(rt_socket)");
1347 errx(1, "EOF on rt_socket");
1349 rtm = (struct rt_msghdr *)(void *)buf;
1350 if ((size_t)n != rtm->rtm_msglen)
1351 errx(1, "n=%zu, rtm_msglen=%u", (size_t)n, rtm->rtm_msglen);
1357 * execute and SIOCAIFADDR
1360 siocaifaddr(char *ifname, struct in_addr addr, struct in_addr mask,
1361 struct in_addr bcast)
1363 struct ifaliasreq addreq;
1364 struct sockaddr_in *sa;
1366 memset(&addreq, 0, sizeof(addreq));
1367 strncpy(addreq.ifra_name, ifname, sizeof(addreq.ifra_name));
1369 sa = (struct sockaddr_in *)(void *)&addreq.ifra_addr;
1370 sa->sin_family = AF_INET;
1371 sa->sin_len = sizeof(*sa);
1372 sa->sin_addr = addr;
1374 sa = (struct sockaddr_in *)(void *)&addreq.ifra_mask;
1375 sa->sin_family = AF_INET;
1376 sa->sin_len = sizeof(*sa);
1377 sa->sin_addr = mask;
1379 sa = (struct sockaddr_in *)(void *)&addreq.ifra_broadaddr;
1380 sa->sin_family = AF_INET;
1381 sa->sin_len = sizeof(*sa);
1382 sa->sin_addr = bcast;
1384 return (ioctl(mib_netsock, SIOCAIFADDR, &addreq));
1388 * Exececute a SIOCDIFADDR
1391 siocdifaddr(const char *ifname, struct in_addr addr)
1393 struct ifreq delreq;
1394 struct sockaddr_in *sa;
1396 memset(&delreq, 0, sizeof(delreq));
1397 strncpy(delreq.ifr_name, ifname, sizeof(delreq.ifr_name));
1398 sa = (struct sockaddr_in *)(void *)&delreq.ifr_addr;
1399 sa->sin_family = AF_INET;
1400 sa->sin_len = sizeof(*sa);
1401 sa->sin_addr = addr;
1403 return (ioctl(mib_netsock, SIOCDIFADDR, &delreq));
1407 * Verify an interface address without fetching the entire list
1410 verify_ifa(const char *name, struct mibifa *ifa)
1413 struct sockaddr_in *sa;
1415 memset(&req, 0, sizeof(req));
1416 strncpy(req.ifr_name, name, sizeof(req.ifr_name));
1417 sa = (struct sockaddr_in *)(void *)&req.ifr_addr;
1418 sa->sin_family = AF_INET;
1419 sa->sin_len = sizeof(*sa);
1420 sa->sin_addr = ifa->inaddr;
1422 if (ioctl(mib_netsock, SIOCGIFADDR, &req) == -1)
1424 if (ifa->inaddr.s_addr != sa->sin_addr.s_addr) {
1425 syslog(LOG_ERR, "%s: address mismatch", __func__);
1429 if (ioctl(mib_netsock, SIOCGIFNETMASK, &req) == -1)
1431 if (ifa->inmask.s_addr != sa->sin_addr.s_addr) {
1432 syslog(LOG_ERR, "%s: netmask mismatch", __func__);
1439 * Restore a deleted interface address. Don't wait for the routing socket
1443 mib_undestroy_ifa(struct mibifa *ifa)
1447 if ((ifp = mib_find_if(ifa->ifindex)) == NULL)
1448 /* keep it destroyed */
1451 if (siocaifaddr(ifp->name, ifa->inaddr, ifa->inmask, ifa->inbcast))
1452 /* keep it destroyed */
1455 ifa->flags &= ~MIBIFA_DESTROYED;
1459 * Destroy an interface address
1462 mib_destroy_ifa(struct mibifa *ifa)
1466 if ((ifp = mib_find_if(ifa->ifindex)) == NULL) {
1471 if (siocdifaddr(ifp->name, ifa->inaddr)) {
1473 syslog(LOG_ERR, "SIOCDIFADDR: %m");
1477 ifa->flags |= MIBIFA_DESTROYED;
1482 * Rollback the modification of an address. Don't bother to wait for
1483 * the routing socket.
1486 mib_unmodify_ifa(struct mibifa *ifa)
1490 if ((ifp = mib_find_if(ifa->ifindex)) == NULL) {
1496 if (siocaifaddr(ifp->name, ifa->inaddr, ifa->inmask, ifa->inbcast)) {
1507 mib_modify_ifa(struct mibifa *ifa)
1511 if ((ifp = mib_find_if(ifa->ifindex)) == NULL) {
1517 if (siocaifaddr(ifp->name, ifa->inaddr, ifa->inmask, ifa->inbcast)) {
1523 if (verify_ifa(ifp->name, ifa)) {
1533 * Destroy a freshly created interface address. Don't bother to wait for
1534 * the routing socket.
1537 mib_uncreate_ifa(struct mibifa *ifa)
1541 if ((ifp = mib_find_if(ifa->ifindex)) == NULL) {
1546 if (siocdifaddr(ifp->name, ifa->inaddr)) {
1556 * Create a new ifa and verify it
1559 mib_create_ifa(u_int ifindex, struct in_addr addr, struct in_addr mask,
1560 struct in_addr bcast)
1565 if ((ifp = mib_find_if(ifindex)) == NULL)
1567 if ((ifa = alloc_ifa(ifindex, addr)) == NULL)
1570 ifa->inbcast = bcast;
1572 if (siocaifaddr(ifp->name, ifa->inaddr, ifa->inmask, ifa->inbcast)) {
1573 syslog(LOG_ERR, "%s: %m", __func__);
1577 if (verify_ifa(ifp->name, ifa)) {
1585 * Get all cloning interfaces and make them dynamic.
1586 * Hah! Whe should probably do this on a periodic basis (XXX).
1591 struct if_clonereq req;
1595 memset(&req, 0, sizeof(req));
1596 if (ioctl(mib_netsock, SIOCIFGCLONERS, &req) == -1) {
1597 syslog(LOG_ERR, "get cloners: %m");
1600 if ((buf = malloc(req.ifcr_total * IFNAMSIZ)) == NULL) {
1601 syslog(LOG_ERR, "%m");
1604 req.ifcr_count = req.ifcr_total;
1605 req.ifcr_buffer = buf;
1606 if (ioctl(mib_netsock, SIOCIFGCLONERS, &req) == -1) {
1607 syslog(LOG_ERR, "get cloners: %m");
1611 for (cp = buf, i = 0; i < req.ifcr_total; i++, cp += IFNAMSIZ)
1624 if (mib_iflist_bad) {
1625 TAILQ_FOREACH(ifa, &mibifa_list, link)
1626 ifa->flags &= ~MIBIFA_DESTROYED;
1628 /* assume, that all cloning interfaces are dynamic */
1631 mib_refresh_iflist();
1647 if ((route_fd = fd_select(route, route_input, NULL, module)) == NULL) {
1648 syslog(LOG_ERR, "fd_select(route): %m");
1651 mib_refresh_iflist();
1654 (void)mib_fetch_route();
1655 mib_iftable_last_change = 0;
1656 mib_ifstack_last_change = 0;
1658 ifmib_reg = or_register(&oid_ifMIB,
1659 "The MIB module to describe generic objects for network interface"
1660 " sub-layers.", module);
1662 ipmib_reg = or_register(&oid_ipMIB,
1663 "The MIB module for managing IP and ICMP implementations, but "
1664 "excluding their management of IP routes.", module);
1666 tcpmib_reg = or_register(&oid_tcpMIB,
1667 "The MIB module for managing TCP implementations.", module);
1669 udpmib_reg = or_register(&oid_udpMIB,
1670 "The MIB module for managing UDP implementations.", module);
1672 ipForward_reg = or_register(&oid_ipForward,
1673 "The MIB module for the display of CIDR multipath IP Routes.",
1678 * Initialize the module
1681 mibII_init(struct lmodule *mod, int argc __unused, char *argv[] __unused)
1687 len = sizeof(clockinfo);
1688 if (sysctlbyname("kern.clockrate", &clockinfo, &len, NULL, 0) == -1) {
1689 syslog(LOG_ERR, "kern.clockrate: %m");
1692 if (len != sizeof(clockinfo)) {
1693 syslog(LOG_ERR, "kern.clockrate: wrong size");
1697 if ((route = socket(PF_ROUTE, SOCK_RAW, AF_UNSPEC)) == -1) {
1698 syslog(LOG_ERR, "PF_ROUTE: %m");
1702 if ((mib_netsock = socket(PF_INET, SOCK_DGRAM, 0)) == -1) {
1703 syslog(LOG_ERR, "PF_INET: %m");
1707 (void)shutdown(mib_netsock, SHUT_RDWR);
1709 /* assume, that all cloning interfaces are dynamic */
1718 if (route_fd != NULL)
1719 fd_deselect(route_fd);
1722 if (mib_netsock != -1)
1723 (void)close(mib_netsock);
1724 /* XXX free memory */
1726 or_unregister(ipForward_reg);
1727 or_unregister(udpmib_reg);
1728 or_unregister(tcpmib_reg);
1729 or_unregister(ipmib_reg);
1730 or_unregister(ifmib_reg);
1736 mibII_loading(const struct lmodule *mod, int loaded)
1743 TAILQ_FOREACH(ifp, &mibif_list, link)
1744 if (ifp->xnotify_mod == mod) {
1745 ifp->xnotify_mod = NULL;
1746 ifp->xnotify_data = NULL;
1747 ifp->xnotify = NULL;
1750 mib_unregister_newif(mod);
1753 const struct snmp_module config = {
1754 "This module implements the interface and ip groups.",
1757 mibII_idle, /* idle */
1768 * Should have a list of these attached to each interface.
1771 mibif_notify(struct mibif *ifp, const struct lmodule *mod,
1772 mibif_notify_f func, void *data)
1774 ifp->xnotify = func;
1775 ifp->xnotify_data = data;
1776 ifp->xnotify_mod = mod;
1782 mibif_unnotify(void *arg)
1784 struct mibif *ifp = arg;
1786 ifp->xnotify = NULL;
1787 ifp->xnotify_data = NULL;
1788 ifp->xnotify_mod = NULL;