1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (c) 2006 Shteryana Shopova <syrinx@FreeBSD.org> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 * 28 * Bridge MIB implementation for SNMPd. 29 * Bridge interface objects. 30 * 31 * $FreeBSD$ 32 */ 33 34 #include <sys/queue.h> 35 #include <sys/socket.h> 36 #include <sys/time.h> 37 #include <sys/types.h> 38 39 #include <net/ethernet.h> 40 #include <net/if.h> 41 #include <net/if_mib.h> 42 #include <net/if_types.h> 43 44 #include <errno.h> 45 #include <stdarg.h> 46 #include <stdlib.h> 47 #include <string.h> 48 #include <syslog.h> 49 50 #include <bsnmp/snmpmod.h> 51 #include <bsnmp/snmp_mibII.h> 52 53 #define SNMPTREE_TYPES 54 #include "bridge_tree.h" 55 #include "bridge_snmp.h" 56 #include "bridge_oid.h" 57 58 static const struct asn_oid oid_newRoot = OIDX_newRoot; 59 static const struct asn_oid oid_TopologyChange = OIDX_topologyChange; 60 static const struct asn_oid oid_begemotBrigeName = \ 61 OIDX_begemotBridgeBaseName; 62 static const struct asn_oid oid_begemotNewRoot = OIDX_begemotBridgeNewRoot; 63 static const struct asn_oid oid_begemotTopologyChange = \ 64 OIDX_begemotBridgeTopologyChange; 65 66 TAILQ_HEAD(bridge_ifs, bridge_if); 67 68 /* 69 * Free the bridge interface list. 70 */ 71 static void 72 bridge_ifs_free(struct bridge_ifs *headp) 73 { 74 struct bridge_if *b; 75 76 while ((b = TAILQ_FIRST(headp)) != NULL) { 77 TAILQ_REMOVE(headp, b, b_if); 78 free(b); 79 } 80 } 81 82 /* 83 * Insert an entry in the bridge interface TAILQ. Keep the 84 * TAILQ sorted by the bridge's interface name. 85 */ 86 static void 87 bridge_ifs_insert(struct bridge_ifs *headp, 88 struct bridge_if *b) 89 { 90 struct bridge_if *temp; 91 92 if ((temp = TAILQ_FIRST(headp)) == NULL || 93 strcmp(b->bif_name, temp->bif_name) < 0) { 94 TAILQ_INSERT_HEAD(headp, b, b_if); 95 return; 96 } 97 98 TAILQ_FOREACH(temp, headp, b_if) 99 if(strcmp(b->bif_name, temp->bif_name) < 0) 100 TAILQ_INSERT_BEFORE(temp, b, b_if); 101 102 TAILQ_INSERT_TAIL(headp, b, b_if); 103 } 104 105 /* The global bridge interface list. */ 106 static struct bridge_ifs bridge_ifs = TAILQ_HEAD_INITIALIZER(bridge_ifs); 107 static time_t bridge_list_age; 108 109 /* 110 * Free the global list. 111 */ 112 void 113 bridge_ifs_fini(void) 114 { 115 bridge_ifs_free(&bridge_ifs); 116 } 117 118 /* 119 * Find a bridge interface entry by the bridge interface system index. 120 */ 121 struct bridge_if * 122 bridge_if_find_ifs(uint32_t sysindex) 123 { 124 struct bridge_if *b; 125 126 TAILQ_FOREACH(b, &bridge_ifs, b_if) 127 if (b->sysindex == sysindex) 128 return (b); 129 130 return (NULL); 131 } 132 133 /* 134 * Find a bridge interface entry by the bridge interface name. 135 */ 136 struct bridge_if * 137 bridge_if_find_ifname(const char *b_name) 138 { 139 struct bridge_if *b; 140 141 TAILQ_FOREACH(b, &bridge_ifs, b_if) 142 if (strcmp(b_name, b->bif_name) == 0) 143 return (b); 144 145 return (NULL); 146 } 147 148 /* 149 * Find a bridge name by the bridge interface system index. 150 */ 151 const char * 152 bridge_if_find_name(uint32_t sysindex) 153 { 154 struct bridge_if *b; 155 156 TAILQ_FOREACH(b, &bridge_ifs, b_if) 157 if (b->sysindex == sysindex) 158 return (b->bif_name); 159 160 return (NULL); 161 } 162 163 /* 164 * Given two bridge interfaces' system indexes, find their 165 * corresponding names and return the result of the name 166 * comparison. Returns: 167 * error : -2 168 * i1 < i2 : -1 169 * i1 > i2 : +1 170 * i1 = i2 : 0 171 */ 172 int 173 bridge_compare_sysidx(uint32_t i1, uint32_t i2) 174 { 175 int c; 176 const char *b1, *b2; 177 178 if (i1 == i2) 179 return (0); 180 181 if ((b1 = bridge_if_find_name(i1)) == NULL) { 182 syslog(LOG_ERR, "Bridge interface %d does not exist", i1); 183 return (-2); 184 } 185 186 if ((b2 = bridge_if_find_name(i2)) == NULL) { 187 syslog(LOG_ERR, "Bridge interface %d does not exist", i2); 188 return (-2); 189 } 190 191 if ((c = strcmp(b1, b2)) < 0) 192 return (-1); 193 else if (c > 0) 194 return (1); 195 196 return (0); 197 } 198 199 /* 200 * Fetch the first bridge interface from the list. 201 */ 202 struct bridge_if * 203 bridge_first_bif(void) 204 { 205 return (TAILQ_FIRST(&bridge_ifs)); 206 } 207 208 /* 209 * Fetch the next bridge interface from the list. 210 */ 211 struct bridge_if * 212 bridge_next_bif(struct bridge_if *b_pr) 213 { 214 return (TAILQ_NEXT(b_pr, b_if)); 215 } 216 217 /* 218 * Create a new entry for a bridge interface and insert 219 * it in the list. 220 */ 221 static struct bridge_if * 222 bridge_new_bif(const char *bif_n, uint32_t sysindex, const u_char *physaddr) 223 { 224 struct bridge_if *bif; 225 226 if ((bif = (struct bridge_if *) malloc(sizeof(*bif)))== NULL) { 227 syslog(LOG_ERR, "bridge new interface failed: %s", 228 strerror(errno)); 229 return (NULL); 230 } 231 232 bzero(bif, sizeof(struct bridge_if)); 233 strlcpy(bif->bif_name, bif_n, IFNAMSIZ); 234 bcopy(physaddr, bif->br_addr.octet, ETHER_ADDR_LEN); 235 bif->sysindex = sysindex; 236 bif->br_type = BaseType_transparent_only; 237 /* 1 - all bridges default hold time * 100 - centi-seconds */ 238 bif->hold_time = 1 * 100; 239 bif->prot_spec = dot1dStpProtocolSpecification_ieee8021d; 240 bridge_ifs_insert(&bridge_ifs, bif); 241 242 return (bif); 243 } 244 245 /* 246 * Remove a bridge interface from the list, freeing all it's ports 247 * and address entries. 248 */ 249 void 250 bridge_remove_bif(struct bridge_if *bif) 251 { 252 bridge_members_free(bif); 253 bridge_addrs_free(bif); 254 TAILQ_REMOVE(&bridge_ifs, bif, b_if); 255 free(bif); 256 } 257 258 259 /* 260 * Prepare the variable (bridge interface name) for the private 261 * begemot notifications. 262 */ 263 static struct snmp_value* 264 bridge_basename_var(struct bridge_if *bif, struct snmp_value* b_val) 265 { 266 uint i; 267 268 b_val->var = oid_begemotBrigeName; 269 b_val->var.subs[b_val->var.len++] = strlen(bif->bif_name); 270 271 if ((b_val->v.octetstring.octets = (u_char *) 272 malloc(strlen(bif->bif_name))) == NULL) 273 return (NULL); 274 275 for (i = 0; i < strlen(bif->bif_name); i++) 276 b_val->var.subs[b_val->var.len++] = bif->bif_name[i]; 277 278 b_val->v.octetstring.len = strlen(bif->bif_name); 279 bcopy(bif->bif_name, b_val->v.octetstring.octets, 280 strlen(bif->bif_name)); 281 b_val->syntax = SNMP_SYNTAX_OCTETSTRING; 282 283 return (b_val); 284 } 285 286 /* 287 * Compare the values of the old and the new root port and 288 * send a new root notification, if they are not matching. 289 */ 290 static void 291 bridge_new_root(struct bridge_if *bif) 292 { 293 struct snmp_value bif_idx; 294 295 if (bridge_get_default() == bif) 296 snmp_send_trap(&oid_newRoot, (struct snmp_value *) NULL); 297 298 if (bridge_basename_var(bif, &bif_idx) == NULL) 299 return; 300 301 snmp_send_trap(&oid_begemotTopologyChange, 302 &bif_idx, (struct snmp_value *) NULL); 303 } 304 305 /* 306 * Compare the new and old topology change times and send a 307 * topology change notification if necessary. 308 */ 309 static void 310 bridge_top_change(struct bridge_if *bif) 311 { 312 struct snmp_value bif_idx; 313 314 if (bridge_get_default() == bif) 315 snmp_send_trap(&oid_TopologyChange, 316 (struct snmp_value *) NULL); 317 318 if (bridge_basename_var(bif, &bif_idx) == NULL) 319 return; 320 321 snmp_send_trap(&oid_begemotNewRoot, 322 &bif_idx, (struct snmp_value *) NULL); 323 } 324 325 static int 326 bridge_if_create(const char* b_name, int8_t up) 327 { 328 if (bridge_create(b_name) < 0) 329 return (-1); 330 331 if (up == 1 && (bridge_set_if_up(b_name, 1) < 0)) 332 return (-1); 333 334 /* 335 * Do not create a new bridge entry here - 336 * wait until the mibII module notifies us. 337 */ 338 return (0); 339 } 340 341 static int 342 bridge_if_destroy(struct bridge_if *bif) 343 { 344 if (bridge_destroy(bif->bif_name) < 0) 345 return (-1); 346 347 bridge_remove_bif(bif); 348 349 return (0); 350 } 351 352 /* 353 * Calculate the timeticks since the last topology change. 354 */ 355 static int 356 bridge_get_time_since_tc(struct bridge_if *bif, uint32_t *ticks) 357 { 358 struct timeval ct; 359 360 if (gettimeofday(&ct, NULL) < 0) { 361 syslog(LOG_ERR, "bridge get time since last TC:" 362 "gettimeofday failed: %s", strerror(errno)); 363 return (-1); 364 } 365 366 if (ct.tv_usec - bif->last_tc_time.tv_usec < 0) { 367 ct.tv_sec -= 1; 368 ct.tv_usec += 1000000; 369 } 370 371 ct.tv_sec -= bif->last_tc_time.tv_sec; 372 ct.tv_usec -= bif->last_tc_time.tv_usec; 373 374 *ticks = ct.tv_sec * 100 + ct.tv_usec/10000; 375 376 return (0); 377 } 378 379 /* 380 * Update the info we have for a single bridge interface. 381 * Return: 382 * 1, if successful 383 * 0, if the interface was deleted 384 * -1, error occurred while fetching the info from the kernel. 385 */ 386 static int 387 bridge_update_bif(struct bridge_if *bif) 388 { 389 struct mibif *ifp; 390 391 /* Walk through the mibII interface list. */ 392 for (ifp = mib_first_if(); ifp != NULL; ifp = mib_next_if(ifp)) 393 if (strcmp(ifp->name, bif->bif_name) == 0) 394 break; 395 396 if (ifp == NULL) { 397 /* Ops, we do not exist anymore. */ 398 bridge_remove_bif(bif); 399 return (0); 400 } 401 402 if (ifp->physaddr != NULL ) 403 bcopy(ifp->physaddr, bif->br_addr.octet, ETHER_ADDR_LEN); 404 else 405 bridge_get_basemac(bif->bif_name, bif->br_addr.octet, 406 ETHER_ADDR_LEN); 407 408 if (ifp->mib.ifmd_flags & IFF_RUNNING) 409 bif->if_status = RowStatus_active; 410 else 411 bif->if_status = RowStatus_notInService; 412 413 switch (bridge_getinfo_bif(bif)) { 414 case 2: 415 bridge_new_root(bif); 416 break; 417 case 1: 418 bridge_top_change(bif); 419 break; 420 case -1: 421 bridge_remove_bif(bif); 422 return (-1); 423 default: 424 break; 425 } 426 427 /* 428 * The number of ports is accessible via SNMP - 429 * update the ports each time the bridge interface data 430 * is refreshed too. 431 */ 432 bif->num_ports = bridge_update_memif(bif); 433 bif->entry_age = time(NULL); 434 435 return (1); 436 } 437 438 /* 439 * Update all bridge interfaces' ports only - 440 * make sure each bridge interface exists first. 441 */ 442 void 443 bridge_update_all_ports(void) 444 { 445 struct mibif *ifp; 446 struct bridge_if *bif, *t_bif; 447 448 for (bif = bridge_first_bif(); bif != NULL; bif = t_bif) { 449 t_bif = bridge_next_bif(bif); 450 451 for (ifp = mib_first_if(); ifp != NULL; 452 ifp = mib_next_if(ifp)) 453 if (strcmp(ifp->name, bif->bif_name) == 0) 454 break; 455 456 if (ifp != NULL) 457 bif->num_ports = bridge_update_memif(bif); 458 else /* Ops, we do not exist anymore. */ 459 bridge_remove_bif(bif); 460 } 461 462 bridge_ports_update_listage(); 463 } 464 465 /* 466 * Update all addresses only. 467 */ 468 void 469 bridge_update_all_addrs(void) 470 { 471 struct mibif *ifp; 472 struct bridge_if *bif, *t_bif; 473 474 for (bif = bridge_first_bif(); bif != NULL; bif = t_bif) { 475 t_bif = bridge_next_bif(bif); 476 477 for (ifp = mib_first_if(); ifp != NULL; 478 ifp = mib_next_if(ifp)) 479 if (strcmp(ifp->name, bif->bif_name) == 0) 480 break; 481 482 if (ifp != NULL) 483 bif->num_addrs = bridge_update_addrs(bif); 484 else /* Ops, we don't exist anymore. */ 485 bridge_remove_bif(bif); 486 } 487 488 bridge_addrs_update_listage(); 489 } 490 491 /* 492 * Update only the bridge interfaces' data - skip addresses. 493 */ 494 void 495 bridge_update_all_ifs(void) 496 { 497 struct bridge_if *bif, *t_bif; 498 499 for (bif = bridge_first_bif(); bif != NULL; bif = t_bif) { 500 t_bif = bridge_next_bif(bif); 501 bridge_update_bif(bif); 502 } 503 504 bridge_ports_update_listage(); 505 bridge_list_age = time(NULL); 506 } 507 508 /* 509 * Update all info we have for all bridges. 510 */ 511 void 512 bridge_update_all(void *arg __unused) 513 { 514 struct bridge_if *bif, *t_bif; 515 516 for (bif = bridge_first_bif(); bif != NULL; bif = t_bif) { 517 t_bif = bridge_next_bif(bif); 518 if (bridge_update_bif(bif) <= 0) 519 continue; 520 521 /* Update our learnt addresses. */ 522 bif->num_addrs = bridge_update_addrs(bif); 523 } 524 525 bridge_list_age = time(NULL); 526 bridge_ports_update_listage(); 527 bridge_addrs_update_listage(); 528 } 529 530 /* 531 * Callback for polling our last topology change time - 532 * check whether we are root or whether a TC was detected once every 533 * 30 seconds, so that we can send the newRoot and TopologyChange traps 534 * on time. The rest of the data is polled only once every 5 min. 535 */ 536 void 537 bridge_update_tc_time(void *arg __unused) 538 { 539 struct bridge_if *bif; 540 struct mibif *ifp; 541 542 TAILQ_FOREACH(bif, &bridge_ifs, b_if) { 543 /* Walk through the mibII interface list. */ 544 for (ifp = mib_first_if(); ifp != NULL; ifp = mib_next_if(ifp)) 545 if (strcmp(ifp->name, bif->bif_name) == 0) 546 break; 547 548 if (ifp == NULL) { 549 bridge_remove_bif(bif); 550 continue; 551 } 552 553 switch (bridge_get_op_param(bif)) { 554 case 2: 555 bridge_new_root(bif); 556 break; 557 case 1: 558 bridge_top_change(bif); 559 break; 560 } 561 } 562 } 563 564 /* 565 * Callback for handling new bridge interface creation. 566 */ 567 int 568 bridge_attach_newif(struct mibif *ifp) 569 { 570 u_char mac[ETHER_ADDR_LEN]; 571 struct bridge_if *bif; 572 573 if (ifp->mib.ifmd_data.ifi_type != IFT_BRIDGE) 574 return (0); 575 576 /* Make sure it does not exist in our list. */ 577 TAILQ_FOREACH(bif, &bridge_ifs, b_if) 578 if(strcmp(bif->bif_name, ifp->name) == 0) { 579 syslog(LOG_ERR, "bridge interface %s already " 580 "in list", bif->bif_name); 581 return (-1); 582 } 583 584 if (ifp->physaddr == NULL) { 585 if (bridge_get_basemac(ifp->name, mac, sizeof(mac)) == NULL) { 586 syslog(LOG_ERR, "bridge attach new %s failed - " 587 "no bridge mac address", ifp->name); 588 return (-1); 589 } 590 } else 591 bcopy(ifp->physaddr, &mac, sizeof(mac)); 592 593 if ((bif = bridge_new_bif(ifp->name, ifp->sysindex, mac)) == NULL) 594 return (-1); 595 596 if (ifp->mib.ifmd_flags & IFF_RUNNING) 597 bif->if_status = RowStatus_active; 598 else 599 bif->if_status = RowStatus_notInService; 600 601 /* Skip sending notifications if the interface was just created. */ 602 if (bridge_getinfo_bif(bif) < 0 || 603 (bif->num_ports = bridge_getinfo_bif_ports(bif)) < 0 || 604 (bif->num_addrs = bridge_getinfo_bif_addrs(bif)) < 0) { 605 bridge_remove_bif(bif); 606 return (-1); 607 } 608 609 /* Check whether we are the default bridge interface. */ 610 if (strcmp(ifp->name, bridge_get_default_name()) == 0) 611 bridge_set_default(bif); 612 613 return (0); 614 } 615 616 void 617 bridge_ifs_dump(void) 618 { 619 struct bridge_if *bif; 620 621 for (bif = bridge_first_bif(); bif != NULL; 622 bif = bridge_next_bif(bif)) { 623 syslog(LOG_ERR, "Bridge %s, index - %d", bif->bif_name, 624 bif->sysindex); 625 bridge_ports_dump(bif); 626 bridge_addrs_dump(bif); 627 } 628 } 629 630 /* 631 * RFC4188 specifics. 632 */ 633 int 634 op_dot1d_base(struct snmp_context *ctx __unused, struct snmp_value *value, 635 uint sub, uint iidx __unused, enum snmp_op op) 636 { 637 struct bridge_if *bif; 638 639 if ((bif = bridge_get_default()) == NULL) 640 return (SNMP_ERR_NOSUCHNAME); 641 642 if (time(NULL) - bif->entry_age > bridge_get_data_maxage() && 643 bridge_update_bif(bif) <= 0) /* It was just deleted. */ 644 return (SNMP_ERR_NOSUCHNAME); 645 646 switch (op) { 647 case SNMP_OP_GET: 648 switch (value->var.subs[sub - 1]) { 649 case LEAF_dot1dBaseBridgeAddress: 650 return (string_get(value, bif->br_addr.octet, 651 ETHER_ADDR_LEN)); 652 case LEAF_dot1dBaseNumPorts: 653 value->v.integer = bif->num_ports; 654 return (SNMP_ERR_NOERROR); 655 case LEAF_dot1dBaseType: 656 value->v.integer = bif->br_type; 657 return (SNMP_ERR_NOERROR); 658 } 659 abort(); 660 661 case SNMP_OP_SET: 662 return (SNMP_ERR_NOT_WRITEABLE); 663 664 case SNMP_OP_GETNEXT: 665 case SNMP_OP_ROLLBACK: 666 case SNMP_OP_COMMIT: 667 break; 668 } 669 670 abort(); 671 } 672 673 int 674 op_dot1d_stp(struct snmp_context *ctx, struct snmp_value *val, uint sub, 675 uint iidx __unused, enum snmp_op op) 676 { 677 struct bridge_if *bif; 678 679 if ((bif = bridge_get_default()) == NULL) 680 return (SNMP_ERR_NOSUCHNAME); 681 682 if (time(NULL) - bif->entry_age > bridge_get_data_maxage() && 683 bridge_update_bif(bif) <= 0) /* It was just deleted. */ 684 return (SNMP_ERR_NOSUCHNAME); 685 686 switch (op) { 687 case SNMP_OP_GET: 688 switch (val->var.subs[sub - 1]) { 689 case LEAF_dot1dStpProtocolSpecification: 690 val->v.integer = bif->prot_spec; 691 return (SNMP_ERR_NOERROR); 692 693 case LEAF_dot1dStpPriority: 694 val->v.integer = bif->priority; 695 return (SNMP_ERR_NOERROR); 696 697 case LEAF_dot1dStpTimeSinceTopologyChange: 698 if (bridge_get_time_since_tc(bif, 699 &(val->v.uint32)) < 0) 700 return (SNMP_ERR_GENERR); 701 return (SNMP_ERR_NOERROR); 702 703 case LEAF_dot1dStpTopChanges: 704 val->v.uint32 = bif->top_changes; 705 return (SNMP_ERR_NOERROR); 706 707 case LEAF_dot1dStpDesignatedRoot: 708 return (string_get(val, bif->design_root, 709 SNMP_BRIDGE_ID_LEN)); 710 711 case LEAF_dot1dStpRootCost: 712 val->v.integer = bif->root_cost; 713 return (SNMP_ERR_NOERROR); 714 715 case LEAF_dot1dStpRootPort: 716 val->v.integer = bif->root_port; 717 return (SNMP_ERR_NOERROR); 718 719 case LEAF_dot1dStpMaxAge: 720 val->v.integer = bif->max_age; 721 return (SNMP_ERR_NOERROR); 722 723 case LEAF_dot1dStpHelloTime: 724 val->v.integer = bif->hello_time; 725 return (SNMP_ERR_NOERROR); 726 727 case LEAF_dot1dStpHoldTime: 728 val->v.integer = bif->hold_time; 729 return (SNMP_ERR_NOERROR); 730 731 case LEAF_dot1dStpForwardDelay: 732 val->v.integer = bif->fwd_delay; 733 return (SNMP_ERR_NOERROR); 734 735 case LEAF_dot1dStpBridgeMaxAge: 736 val->v.integer = bif->bridge_max_age; 737 return (SNMP_ERR_NOERROR); 738 739 case LEAF_dot1dStpBridgeHelloTime: 740 val->v.integer = bif->bridge_hello_time; 741 return (SNMP_ERR_NOERROR); 742 743 case LEAF_dot1dStpBridgeForwardDelay: 744 val->v.integer = bif->bridge_fwd_delay; 745 return (SNMP_ERR_NOERROR); 746 747 case LEAF_dot1dStpVersion: 748 val->v.integer = bif->stp_version; 749 return (SNMP_ERR_NOERROR); 750 751 case LEAF_dot1dStpTxHoldCount: 752 val->v.integer = bif->tx_hold_count; 753 return (SNMP_ERR_NOERROR); 754 } 755 abort(); 756 757 case SNMP_OP_GETNEXT: 758 abort(); 759 760 case SNMP_OP_SET: 761 switch (val->var.subs[sub - 1]) { 762 case LEAF_dot1dStpPriority: 763 if (val->v.integer > SNMP_BRIDGE_MAX_PRIORITY || 764 val->v.integer % 4096 != 0) 765 return (SNMP_ERR_WRONG_VALUE); 766 767 ctx->scratch->int1 = bif->priority; 768 if (bridge_set_priority(bif, val->v.integer) < 0) 769 return (SNMP_ERR_GENERR); 770 return (SNMP_ERR_NOERROR); 771 772 case LEAF_dot1dStpBridgeMaxAge: 773 if (val->v.integer < SNMP_BRIDGE_MIN_MAGE || 774 val->v.integer > SNMP_BRIDGE_MAX_MAGE) 775 return (SNMP_ERR_WRONG_VALUE); 776 777 ctx->scratch->int1 = bif->bridge_max_age; 778 if (bridge_set_maxage(bif, val->v.integer) < 0) 779 return (SNMP_ERR_GENERR); 780 return (SNMP_ERR_NOERROR); 781 782 case LEAF_dot1dStpBridgeHelloTime: 783 if (val->v.integer < SNMP_BRIDGE_MIN_HTIME || 784 val->v.integer > SNMP_BRIDGE_MAX_HTIME) 785 return (SNMP_ERR_WRONG_VALUE); 786 787 ctx->scratch->int1 = bif->bridge_hello_time; 788 if (bridge_set_hello_time(bif, val->v.integer) < 0) 789 return (SNMP_ERR_GENERR); 790 return (SNMP_ERR_NOERROR); 791 792 case LEAF_dot1dStpBridgeForwardDelay: 793 if (val->v.integer < SNMP_BRIDGE_MIN_FDELAY || 794 val->v.integer > SNMP_BRIDGE_MAX_FDELAY) 795 return (SNMP_ERR_WRONG_VALUE); 796 797 ctx->scratch->int1 = bif->bridge_fwd_delay; 798 if (bridge_set_forward_delay(bif, val->v.integer) < 0) 799 return (SNMP_ERR_GENERR); 800 return (SNMP_ERR_NOERROR); 801 802 case LEAF_dot1dStpVersion: 803 if (val->v.integer != dot1dStpVersion_stpCompatible && 804 val->v.integer != dot1dStpVersion_rstp) 805 return (SNMP_ERR_WRONG_VALUE); 806 807 ctx->scratch->int1 = bif->stp_version; 808 if (bridge_set_stp_version(bif, val->v.integer) < 0) 809 return (SNMP_ERR_GENERR); 810 return (SNMP_ERR_NOERROR); 811 812 case LEAF_dot1dStpTxHoldCount: 813 if (val->v.integer < SNMP_BRIDGE_MIN_TXHC || 814 val->v.integer > SNMP_BRIDGE_MAX_TXHC) 815 return (SNMP_ERR_WRONG_VALUE); 816 817 ctx->scratch->int1 = bif->tx_hold_count; 818 if (bridge_set_tx_hold_count(bif, val->v.integer) < 0) 819 return (SNMP_ERR_GENERR); 820 return (SNMP_ERR_NOERROR); 821 822 case LEAF_dot1dStpProtocolSpecification: 823 case LEAF_dot1dStpTimeSinceTopologyChange: 824 case LEAF_dot1dStpTopChanges: 825 case LEAF_dot1dStpDesignatedRoot: 826 case LEAF_dot1dStpRootCost: 827 case LEAF_dot1dStpRootPort: 828 case LEAF_dot1dStpMaxAge: 829 case LEAF_dot1dStpHelloTime: 830 case LEAF_dot1dStpHoldTime: 831 case LEAF_dot1dStpForwardDelay: 832 return (SNMP_ERR_NOT_WRITEABLE); 833 } 834 abort(); 835 836 case SNMP_OP_ROLLBACK: 837 switch (val->var.subs[sub - 1]) { 838 case LEAF_dot1dStpPriority: 839 bridge_set_priority(bif, ctx->scratch->int1); 840 break; 841 case LEAF_dot1dStpBridgeMaxAge: 842 bridge_set_maxage(bif, ctx->scratch->int1); 843 break; 844 case LEAF_dot1dStpBridgeHelloTime: 845 bridge_set_hello_time(bif, ctx->scratch->int1); 846 break; 847 case LEAF_dot1dStpBridgeForwardDelay: 848 bridge_set_forward_delay(bif, ctx->scratch->int1); 849 break; 850 case LEAF_dot1dStpVersion: 851 bridge_set_stp_version(bif, ctx->scratch->int1); 852 break; 853 case LEAF_dot1dStpTxHoldCount: 854 bridge_set_tx_hold_count(bif, ctx->scratch->int1); 855 break; 856 } 857 return (SNMP_ERR_NOERROR); 858 859 case SNMP_OP_COMMIT: 860 return (SNMP_ERR_NOERROR); 861 } 862 863 abort(); 864 } 865 866 int 867 op_dot1d_tp(struct snmp_context *ctx, struct snmp_value *value, 868 uint sub, uint iidx __unused, enum snmp_op op) 869 { 870 struct bridge_if *bif; 871 872 if ((bif = bridge_get_default()) == NULL) 873 return (SNMP_ERR_NOSUCHNAME); 874 875 if (time(NULL) - bif->entry_age > bridge_get_data_maxage() && 876 bridge_update_bif(bif) <= 0) /* It was just deleted. */ 877 return (SNMP_ERR_NOSUCHNAME); 878 879 switch (op) { 880 case SNMP_OP_GET: 881 switch (value->var.subs[sub - 1]) { 882 case LEAF_dot1dTpLearnedEntryDiscards: 883 value->v.uint32 = bif->lrnt_drops; 884 return (SNMP_ERR_NOERROR); 885 case LEAF_dot1dTpAgingTime: 886 value->v.integer = bif->age_time; 887 return (SNMP_ERR_NOERROR); 888 } 889 abort(); 890 891 case SNMP_OP_GETNEXT: 892 abort(); 893 894 case SNMP_OP_SET: 895 switch (value->var.subs[sub - 1]) { 896 case LEAF_dot1dTpLearnedEntryDiscards: 897 return (SNMP_ERR_NOT_WRITEABLE); 898 899 case LEAF_dot1dTpAgingTime: 900 if (value->v.integer < SNMP_BRIDGE_MIN_AGE_TIME || 901 value->v.integer > SNMP_BRIDGE_MAX_AGE_TIME) 902 return (SNMP_ERR_WRONG_VALUE); 903 904 ctx->scratch->int1 = bif->age_time; 905 if (bridge_set_aging_time(bif, value->v.integer) < 0) 906 return (SNMP_ERR_GENERR); 907 return (SNMP_ERR_NOERROR); 908 } 909 abort(); 910 911 case SNMP_OP_ROLLBACK: 912 if (value->var.subs[sub - 1] == LEAF_dot1dTpAgingTime) 913 bridge_set_aging_time(bif, ctx->scratch->int1); 914 return (SNMP_ERR_NOERROR); 915 916 case SNMP_OP_COMMIT: 917 return (SNMP_ERR_NOERROR); 918 } 919 920 abort(); 921 } 922 923 /* 924 * Private BEGEMOT-BRIDGE-MIB specifics. 925 */ 926 927 /* 928 * Get the bridge name from an OID index. 929 */ 930 static char * 931 bridge_name_index_get(const struct asn_oid *oid, uint sub, char *b_name) 932 { 933 uint i; 934 935 if (oid->len - sub != oid->subs[sub] + 1 || oid->subs[sub] >= IFNAMSIZ) 936 return (NULL); 937 938 for (i = 0; i < oid->subs[sub]; i++) 939 b_name[i] = oid->subs[sub + i + 1]; 940 b_name[i] = '\0'; 941 942 return (b_name); 943 } 944 945 static void 946 bridge_if_index_append(struct asn_oid *oid, uint sub, 947 const struct bridge_if *bif) 948 { 949 uint i; 950 951 oid->len = sub + strlen(bif->bif_name) + 1; 952 oid->subs[sub] = strlen(bif->bif_name); 953 954 for (i = 1; i <= strlen(bif->bif_name); i++) 955 oid->subs[sub + i] = bif->bif_name[i - 1]; 956 } 957 958 static struct bridge_if * 959 bridge_if_index_get(const struct asn_oid *oid, uint sub) 960 { 961 uint i; 962 char bif_name[IFNAMSIZ]; 963 964 if (oid->len - sub != oid->subs[sub] + 1 || oid->subs[sub] >= IFNAMSIZ) 965 return (NULL); 966 967 for (i = 0; i < oid->subs[sub]; i++) 968 bif_name[i] = oid->subs[sub + i + 1]; 969 bif_name[i] = '\0'; 970 971 return (bridge_if_find_ifname(bif_name)); 972 } 973 974 static struct bridge_if * 975 bridge_if_index_getnext(const struct asn_oid *oid, uint sub) 976 { 977 uint i; 978 char bif_name[IFNAMSIZ]; 979 struct bridge_if *bif; 980 981 if (oid->len - sub == 0) 982 return (bridge_first_bif()); 983 984 if (oid->len - sub != oid->subs[sub] + 1 || oid->subs[sub] >= IFNAMSIZ) 985 return (NULL); 986 987 for (i = 0; i < oid->subs[sub]; i++) 988 bif_name[i] = oid->subs[sub + i + 1]; 989 bif_name[i] = '\0'; 990 991 if ((bif = bridge_if_find_ifname(bif_name)) == NULL) 992 return (NULL); 993 994 return (bridge_next_bif(bif)); 995 } 996 997 static int 998 bridge_set_if_status(struct snmp_context *ctx, 999 struct snmp_value *val, uint sub) 1000 { 1001 struct bridge_if *bif; 1002 char bif_name[IFNAMSIZ]; 1003 1004 bif = bridge_if_index_get(&val->var, sub); 1005 1006 switch (val->v.integer) { 1007 case RowStatus_active: 1008 if (bif == NULL) 1009 return (SNMP_ERR_INCONS_VALUE); 1010 1011 ctx->scratch->int1 = bif->if_status; 1012 1013 switch (bif->if_status) { 1014 case RowStatus_active: 1015 return (SNMP_ERR_NOERROR); 1016 case RowStatus_notInService: 1017 if (bridge_set_if_up(bif->bif_name, 1) < 0) 1018 return (SNMP_ERR_GENERR); 1019 return (SNMP_ERR_NOERROR); 1020 default: 1021 break; 1022 } 1023 return (SNMP_ERR_INCONS_VALUE); 1024 1025 case RowStatus_notInService: 1026 if (bif == NULL) 1027 return (SNMP_ERR_INCONS_VALUE); 1028 1029 ctx->scratch->int1 = bif->if_status; 1030 1031 switch (bif->if_status) { 1032 case RowStatus_active: 1033 if (bridge_set_if_up(bif->bif_name, 1) < 0) 1034 return (SNMP_ERR_GENERR); 1035 return (SNMP_ERR_NOERROR); 1036 case RowStatus_notInService: 1037 return (SNMP_ERR_NOERROR); 1038 default: 1039 break; 1040 } 1041 return (SNMP_ERR_INCONS_VALUE); 1042 1043 case RowStatus_notReady: 1044 return (SNMP_ERR_INCONS_VALUE); 1045 1046 case RowStatus_createAndGo: 1047 if (bif != NULL) 1048 return (SNMP_ERR_INCONS_VALUE); 1049 1050 ctx->scratch->int1 = RowStatus_destroy; 1051 1052 if (bridge_name_index_get(&val->var, sub, bif_name) == NULL) 1053 return (SNMP_ERR_BADVALUE); 1054 if (bridge_if_create(bif_name, 1) < 0) 1055 return (SNMP_ERR_GENERR); 1056 return (SNMP_ERR_NOERROR); 1057 1058 case RowStatus_createAndWait: 1059 if (bif != NULL) 1060 return (SNMP_ERR_INCONS_VALUE); 1061 1062 if (bridge_name_index_get(&val->var, sub, bif_name) == NULL) 1063 return (SNMP_ERR_BADVALUE); 1064 1065 ctx->scratch->int1 = RowStatus_destroy; 1066 1067 if (bridge_if_create(bif_name, 0) < 0) 1068 return (SNMP_ERR_GENERR); 1069 return (SNMP_ERR_NOERROR); 1070 1071 case RowStatus_destroy: 1072 if (bif == NULL) 1073 return (SNMP_ERR_NOSUCHNAME); 1074 1075 ctx->scratch->int1 = bif->if_status; 1076 bif->if_status = RowStatus_destroy; 1077 } 1078 1079 return (SNMP_ERR_NOERROR); 1080 } 1081 1082 static int 1083 bridge_rollback_if_status(struct snmp_context *ctx, 1084 struct snmp_value *val, uint sub) 1085 { 1086 struct bridge_if *bif; 1087 1088 if ((bif = bridge_if_index_get(&val->var, sub)) == NULL) 1089 return (SNMP_ERR_GENERR); 1090 1091 switch (ctx->scratch->int1) { 1092 case RowStatus_destroy: 1093 bridge_if_destroy(bif); 1094 return (SNMP_ERR_NOERROR); 1095 1096 case RowStatus_notInService: 1097 if (bif->if_status != ctx->scratch->int1) 1098 bridge_set_if_up(bif->bif_name, 0); 1099 bif->if_status = RowStatus_notInService; 1100 return (SNMP_ERR_NOERROR); 1101 1102 case RowStatus_active: 1103 if (bif->if_status != ctx->scratch->int1) 1104 bridge_set_if_up(bif->bif_name, 1); 1105 bif->if_status = RowStatus_active; 1106 return (SNMP_ERR_NOERROR); 1107 } 1108 1109 abort(); 1110 } 1111 1112 static int 1113 bridge_commit_if_status(struct snmp_value *val, uint sub) 1114 { 1115 struct bridge_if *bif; 1116 1117 if ((bif = bridge_if_index_get(&val->var, sub)) == NULL) 1118 return (SNMP_ERR_GENERR); 1119 1120 if (bif->if_status == RowStatus_destroy && 1121 bridge_if_destroy(bif) < 0) 1122 return (SNMP_ERR_COMMIT_FAILED); 1123 1124 return (SNMP_ERR_NOERROR); 1125 } 1126 1127 int 1128 op_begemot_base_bridge(struct snmp_context *ctx, struct snmp_value *val, 1129 uint sub, uint iidx __unused, enum snmp_op op) 1130 { 1131 struct bridge_if *bif; 1132 1133 if (time(NULL) - bridge_list_age > bridge_get_data_maxage()) 1134 bridge_update_all_ifs(); 1135 1136 switch (op) { 1137 case SNMP_OP_GET: 1138 if ((bif = bridge_if_index_get(&val->var, sub)) == NULL) 1139 return (SNMP_ERR_NOSUCHNAME); 1140 goto get; 1141 1142 case SNMP_OP_GETNEXT: 1143 if ((bif = bridge_if_index_getnext(&val->var, sub)) == NULL) 1144 return (SNMP_ERR_NOSUCHNAME); 1145 bridge_if_index_append(&val->var, sub, bif); 1146 goto get; 1147 1148 case SNMP_OP_SET: 1149 switch (val->var.subs[sub - 1]) { 1150 case LEAF_begemotBridgeBaseStatus: 1151 return (bridge_set_if_status(ctx, val, sub)); 1152 case LEAF_begemotBridgeBaseName: 1153 case LEAF_begemotBridgeBaseAddress: 1154 case LEAF_begemotBridgeBaseNumPorts: 1155 case LEAF_begemotBridgeBaseType: 1156 return (SNMP_ERR_NOT_WRITEABLE); 1157 } 1158 abort(); 1159 1160 case SNMP_OP_ROLLBACK: 1161 return (bridge_rollback_if_status(ctx, val, sub)); 1162 1163 case SNMP_OP_COMMIT: 1164 return (bridge_commit_if_status(val, sub)); 1165 } 1166 abort(); 1167 1168 get: 1169 switch (val->var.subs[sub - 1]) { 1170 case LEAF_begemotBridgeBaseName: 1171 return (string_get(val, bif->bif_name, -1)); 1172 1173 case LEAF_begemotBridgeBaseAddress: 1174 return (string_get(val, bif->br_addr.octet, ETHER_ADDR_LEN)); 1175 1176 case LEAF_begemotBridgeBaseNumPorts: 1177 val->v.integer = bif->num_ports; 1178 return (SNMP_ERR_NOERROR); 1179 1180 case LEAF_begemotBridgeBaseType: 1181 val->v.integer = bif->br_type; 1182 return (SNMP_ERR_NOERROR); 1183 1184 case LEAF_begemotBridgeBaseStatus: 1185 val->v.integer = bif->if_status; 1186 return (SNMP_ERR_NOERROR); 1187 } 1188 1189 abort(); 1190 } 1191 1192 int 1193 op_begemot_stp(struct snmp_context *ctx, struct snmp_value *val, 1194 uint sub, uint iidx __unused, enum snmp_op op) 1195 { 1196 struct bridge_if *bif; 1197 1198 if (time(NULL) - bridge_list_age > bridge_get_data_maxage()) 1199 bridge_update_all_ifs(); 1200 1201 switch (op) { 1202 case SNMP_OP_GET: 1203 if ((bif = bridge_if_index_get(&val->var, sub)) == NULL) 1204 return (SNMP_ERR_NOSUCHNAME); 1205 goto get; 1206 1207 case SNMP_OP_GETNEXT: 1208 if ((bif = bridge_if_index_getnext(&val->var, sub)) == NULL) 1209 return (SNMP_ERR_NOSUCHNAME); 1210 bridge_if_index_append(&val->var, sub, bif); 1211 goto get; 1212 1213 case SNMP_OP_SET: 1214 if ((bif = bridge_if_index_get(&val->var, sub)) == NULL) 1215 return (SNMP_ERR_NOSUCHNAME); 1216 1217 switch (val->var.subs[sub - 1]) { 1218 case LEAF_begemotBridgeStpPriority: 1219 if (val->v.integer > SNMP_BRIDGE_MAX_PRIORITY || 1220 val->v.integer % 4096 != 0) 1221 return (SNMP_ERR_WRONG_VALUE); 1222 1223 ctx->scratch->int1 = bif->priority; 1224 if (bridge_set_priority(bif, val->v.integer) < 0) 1225 return (SNMP_ERR_GENERR); 1226 return (SNMP_ERR_NOERROR); 1227 1228 case LEAF_begemotBridgeStpBridgeMaxAge: 1229 if (val->v.integer < SNMP_BRIDGE_MIN_MAGE || 1230 val->v.integer > SNMP_BRIDGE_MAX_MAGE) 1231 return (SNMP_ERR_WRONG_VALUE); 1232 1233 ctx->scratch->int1 = bif->bridge_max_age; 1234 if (bridge_set_maxage(bif, val->v.integer) < 0) 1235 return (SNMP_ERR_GENERR); 1236 return (SNMP_ERR_NOERROR); 1237 1238 case LEAF_begemotBridgeStpBridgeHelloTime: 1239 if (val->v.integer < SNMP_BRIDGE_MIN_HTIME || 1240 val->v.integer > SNMP_BRIDGE_MAX_HTIME) 1241 return (SNMP_ERR_WRONG_VALUE); 1242 1243 ctx->scratch->int1 = bif->bridge_hello_time; 1244 if (bridge_set_hello_time(bif, val->v.integer) < 0) 1245 return (SNMP_ERR_GENERR); 1246 return (SNMP_ERR_NOERROR); 1247 1248 case LEAF_begemotBridgeStpBridgeForwardDelay: 1249 if (val->v.integer < SNMP_BRIDGE_MIN_FDELAY || 1250 val->v.integer > SNMP_BRIDGE_MAX_FDELAY) 1251 return (SNMP_ERR_WRONG_VALUE); 1252 1253 ctx->scratch->int1 = bif->bridge_fwd_delay; 1254 if (bridge_set_forward_delay(bif, val->v.integer) < 0) 1255 return (SNMP_ERR_GENERR); 1256 return (SNMP_ERR_NOERROR); 1257 1258 case LEAF_begemotBridgeStpVersion: 1259 if (val->v.integer != 1260 begemotBridgeStpVersion_stpCompatible && 1261 val->v.integer != begemotBridgeStpVersion_rstp) 1262 return (SNMP_ERR_WRONG_VALUE); 1263 1264 ctx->scratch->int1 = bif->stp_version; 1265 if (bridge_set_stp_version(bif, val->v.integer) < 0) 1266 return (SNMP_ERR_GENERR); 1267 return (SNMP_ERR_NOERROR); 1268 1269 case LEAF_begemotBridgeStpTxHoldCount: 1270 if (val->v.integer < SNMP_BRIDGE_MIN_TXHC || 1271 val->v.integer > SNMP_BRIDGE_MAX_TXHC) 1272 return (SNMP_ERR_WRONG_VALUE); 1273 1274 ctx->scratch->int1 = bif->tx_hold_count; 1275 if (bridge_set_tx_hold_count(bif, val->v.integer) < 0) 1276 return (SNMP_ERR_GENERR); 1277 return (SNMP_ERR_NOERROR); 1278 1279 case LEAF_begemotBridgeStpProtocolSpecification: 1280 case LEAF_begemotBridgeStpTimeSinceTopologyChange: 1281 case LEAF_begemotBridgeStpTopChanges: 1282 case LEAF_begemotBridgeStpDesignatedRoot: 1283 case LEAF_begemotBridgeStpRootCost: 1284 case LEAF_begemotBridgeStpRootPort: 1285 case LEAF_begemotBridgeStpMaxAge: 1286 case LEAF_begemotBridgeStpHelloTime: 1287 case LEAF_begemotBridgeStpHoldTime: 1288 case LEAF_begemotBridgeStpForwardDelay: 1289 return (SNMP_ERR_NOT_WRITEABLE); 1290 } 1291 abort(); 1292 1293 case SNMP_OP_ROLLBACK: 1294 if ((bif = bridge_if_index_get(&val->var, sub)) == NULL) 1295 return (SNMP_ERR_NOSUCHNAME); 1296 1297 switch (val->var.subs[sub - 1]) { 1298 case LEAF_begemotBridgeStpPriority: 1299 bridge_set_priority(bif, ctx->scratch->int1); 1300 break; 1301 1302 case LEAF_begemotBridgeStpBridgeMaxAge: 1303 bridge_set_maxage(bif, ctx->scratch->int1); 1304 break; 1305 1306 case LEAF_begemotBridgeStpBridgeHelloTime: 1307 bridge_set_hello_time(bif, ctx->scratch->int1); 1308 break; 1309 1310 case LEAF_begemotBridgeStpBridgeForwardDelay: 1311 bridge_set_forward_delay(bif, ctx->scratch->int1); 1312 break; 1313 1314 case LEAF_begemotBridgeStpVersion: 1315 bridge_set_stp_version(bif, ctx->scratch->int1); 1316 break; 1317 1318 case LEAF_begemotBridgeStpTxHoldCount: 1319 bridge_set_tx_hold_count(bif, ctx->scratch->int1); 1320 break; 1321 } 1322 return (SNMP_ERR_NOERROR); 1323 1324 case SNMP_OP_COMMIT: 1325 return (SNMP_ERR_NOERROR); 1326 } 1327 abort(); 1328 1329 get: 1330 switch (val->var.subs[sub - 1]) { 1331 case LEAF_begemotBridgeStpProtocolSpecification: 1332 val->v.integer = bif->prot_spec; 1333 return (SNMP_ERR_NOERROR); 1334 1335 case LEAF_begemotBridgeStpPriority: 1336 val->v.integer = bif->priority; 1337 return (SNMP_ERR_NOERROR); 1338 1339 case LEAF_begemotBridgeStpTimeSinceTopologyChange: 1340 if (bridge_get_time_since_tc(bif, &(val->v.uint32)) < 0) 1341 return (SNMP_ERR_GENERR); 1342 return (SNMP_ERR_NOERROR); 1343 1344 case LEAF_begemotBridgeStpTopChanges: 1345 val->v.uint32 = bif->top_changes; 1346 return (SNMP_ERR_NOERROR); 1347 1348 case LEAF_begemotBridgeStpDesignatedRoot: 1349 return (string_get(val, bif->design_root, SNMP_BRIDGE_ID_LEN)); 1350 1351 case LEAF_begemotBridgeStpRootCost: 1352 val->v.integer = bif->root_cost; 1353 return (SNMP_ERR_NOERROR); 1354 1355 case LEAF_begemotBridgeStpRootPort: 1356 val->v.integer = bif->root_port; 1357 return (SNMP_ERR_NOERROR); 1358 1359 case LEAF_begemotBridgeStpMaxAge: 1360 val->v.integer = bif->max_age; 1361 return (SNMP_ERR_NOERROR); 1362 1363 case LEAF_begemotBridgeStpHelloTime: 1364 val->v.integer = bif->hello_time; 1365 return (SNMP_ERR_NOERROR); 1366 1367 case LEAF_begemotBridgeStpHoldTime: 1368 val->v.integer = bif->hold_time; 1369 return (SNMP_ERR_NOERROR); 1370 1371 case LEAF_begemotBridgeStpForwardDelay: 1372 val->v.integer = bif->fwd_delay; 1373 return (SNMP_ERR_NOERROR); 1374 1375 case LEAF_begemotBridgeStpBridgeMaxAge: 1376 val->v.integer = bif->bridge_max_age; 1377 return (SNMP_ERR_NOERROR); 1378 1379 case LEAF_begemotBridgeStpBridgeHelloTime: 1380 val->v.integer = bif->bridge_hello_time; 1381 return (SNMP_ERR_NOERROR); 1382 1383 case LEAF_begemotBridgeStpBridgeForwardDelay: 1384 val->v.integer = bif->bridge_fwd_delay; 1385 return (SNMP_ERR_NOERROR); 1386 1387 case LEAF_begemotBridgeStpVersion: 1388 val->v.integer = bif->stp_version; 1389 return (SNMP_ERR_NOERROR); 1390 1391 case LEAF_begemotBridgeStpTxHoldCount: 1392 val->v.integer = bif->tx_hold_count; 1393 return (SNMP_ERR_NOERROR); 1394 } 1395 1396 abort(); 1397 } 1398 1399 int 1400 op_begemot_tp(struct snmp_context *ctx, struct snmp_value *val, 1401 uint sub, uint iidx __unused, enum snmp_op op) 1402 { 1403 struct bridge_if *bif; 1404 1405 if (time(NULL) - bridge_list_age > bridge_get_data_maxage()) 1406 bridge_update_all_ifs(); 1407 1408 switch (op) { 1409 case SNMP_OP_GET: 1410 if ((bif = bridge_if_index_get(&val->var, sub)) == NULL) 1411 return (SNMP_ERR_NOSUCHNAME); 1412 goto get; 1413 1414 case SNMP_OP_GETNEXT: 1415 if ((bif = bridge_if_index_getnext(&val->var, sub)) == NULL) 1416 return (SNMP_ERR_NOSUCHNAME); 1417 bridge_if_index_append(&val->var, sub, bif); 1418 goto get; 1419 1420 case SNMP_OP_SET: 1421 if ((bif = bridge_if_index_get(&val->var, sub)) == NULL) 1422 return (SNMP_ERR_NOSUCHNAME); 1423 1424 switch (val->var.subs[sub - 1]) { 1425 case LEAF_begemotBridgeTpAgingTime: 1426 if (val->v.integer < SNMP_BRIDGE_MIN_AGE_TIME || 1427 val->v.integer > SNMP_BRIDGE_MAX_AGE_TIME) 1428 return (SNMP_ERR_WRONG_VALUE); 1429 1430 ctx->scratch->int1 = bif->age_time; 1431 if (bridge_set_aging_time(bif, val->v.integer) < 0) 1432 return (SNMP_ERR_GENERR); 1433 return (SNMP_ERR_NOERROR); 1434 1435 case LEAF_begemotBridgeTpMaxAddresses: 1436 ctx->scratch->int1 = bif->max_addrs; 1437 if (bridge_set_max_cache(bif, val->v.integer) < 0) 1438 return (SNMP_ERR_GENERR); 1439 return (SNMP_ERR_NOERROR); 1440 1441 case LEAF_begemotBridgeTpLearnedEntryDiscards: 1442 return (SNMP_ERR_NOT_WRITEABLE); 1443 } 1444 abort(); 1445 1446 case SNMP_OP_ROLLBACK: 1447 if ((bif = bridge_if_index_get(&val->var, sub)) == NULL) 1448 return (SNMP_ERR_GENERR); 1449 1450 switch (val->var.subs[sub - 1]) { 1451 case LEAF_begemotBridgeTpAgingTime: 1452 bridge_set_aging_time(bif, ctx->scratch->int1); 1453 break; 1454 1455 case LEAF_begemotBridgeTpMaxAddresses: 1456 bridge_set_max_cache(bif, ctx->scratch->int1); 1457 break; 1458 } 1459 return (SNMP_ERR_NOERROR); 1460 1461 case SNMP_OP_COMMIT: 1462 return (SNMP_ERR_NOERROR); 1463 } 1464 abort(); 1465 1466 get: 1467 switch (val->var.subs[sub - 1]) { 1468 case LEAF_begemotBridgeTpLearnedEntryDiscards: 1469 val->v.uint32 = bif->lrnt_drops; 1470 return (SNMP_ERR_NOERROR); 1471 1472 case LEAF_begemotBridgeTpAgingTime: 1473 val->v.integer = bif->age_time; 1474 return (SNMP_ERR_NOERROR); 1475 1476 case LEAF_begemotBridgeTpMaxAddresses: 1477 val->v.integer = bif->max_addrs; 1478 return (SNMP_ERR_NOERROR); 1479 } 1480 1481 abort(); 1482 } 1483