usr.sbin/bsnmpd/modules/snmp_bridge/bridge_if.c

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