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