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

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   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 ports.
  30  *
  31  * $FreeBSD$
  32  */
  33
  34 #include <sys/queue.h>
  35 #include <sys/socket.h>
  36 #include <sys/types.h>
  37
  38 #include <net/ethernet.h>
  39 #include <net/if.h>
  40 #include <net/if_mib.h>
  41
  42 #include <assert.h>
  43 #include <errno.h>
  44 #include <stdarg.h>
  45 #include <string.h>
  46 #include <stdlib.h>
  47 #include <syslog.h>
  48
  49 #include <bsnmp/snmpmod.h>
  50 #include <bsnmp/snmp_mibII.h>
  51
  52 #define SNMPTREE_TYPES
  53 #include "bridge_tree.h"
  54 #include "bridge_snmp.h"
  55
  56 TAILQ_HEAD(bridge_ports, bridge_port);
  57
  58 /*
  59  * Free the bridge base ports list.
  60  */
  61 static void
  62 bridge_ports_free(struct bridge_ports *headp)
  63 {
  64         struct bridge_port *bp;
  65
  66         while ((bp = TAILQ_FIRST(headp)) != NULL) {
  67                 TAILQ_REMOVE(headp, bp, b_p);
  68                 free(bp);
  69         }
  70 }
  71
  72 /*
  73  * Free the bridge base ports from the base ports list,
  74  * members of a specified bridge interface only.
  75  */
  76 static void
  77 bridge_port_memif_free(struct bridge_ports *headp,
  78         struct bridge_if *bif)
  79 {
  80         struct bridge_port *bp;
  81
  82         while (bif->f_bp != NULL && bif->sysindex == bif->f_bp->sysindex) {
  83                 bp = TAILQ_NEXT(bif->f_bp, b_p);
  84                 TAILQ_REMOVE(headp, bif->f_bp, b_p);
  85                 free(bif->f_bp);
  86                 bif->f_bp = bp;
  87         }
  88 }
  89
  90 /*
  91  * Insert a port entry in the base port TAILQ starting to search
  92  * for its place from the position of the first bridge port for the bridge
  93  * interface. Update the first bridge port if necessary.
  94  */
  95 static void
  96 bridge_port_insert_at(struct bridge_ports *headp,
  97         struct bridge_port *bp, struct bridge_port **f_bp)
  98 {
  99         struct bridge_port *t1;
 100
 101         assert(f_bp != NULL);
 102
 103         for (t1 = *f_bp;
 104             t1 != NULL && bp->sysindex == t1->sysindex;
 105             t1 = TAILQ_NEXT(t1, b_p)) {
 106                 if (bp->if_idx < t1->if_idx) {
 107                         TAILQ_INSERT_BEFORE(t1, bp, b_p);
 108                         if (*f_bp == t1)
 109                                 *f_bp = bp;
 110                         return;
 111                 }
 112         }
 113
 114         /*
 115          * Handle the case when our first port was actually the
 116          * last element of the TAILQ.
 117          */
 118         if (t1 == NULL)
 119                 TAILQ_INSERT_TAIL(headp, bp, b_p);
 120         else
 121                 TAILQ_INSERT_BEFORE(t1, bp, b_p);
 122 }
 123
 124 /*
 125  * Find a port entry's position in the ports list according
 126  * to it's parent bridge interface name. Returns a NULL if
 127  * we should be at the TAILQ head, otherwise the entry after
 128  * which we should be inserted.
 129  */
 130 static struct bridge_port *
 131 bridge_port_find_pos(struct bridge_ports *headp, uint32_t b_idx)
 132 {
 133         uint32_t t_idx;
 134         struct bridge_port *t1;
 135
 136         if ((t1 = TAILQ_FIRST(headp)) == NULL ||
 137             bridge_compare_sysidx(b_idx, t1->sysindex) < 0)
 138                 return (NULL);
 139
 140         t_idx = t1->sysindex;
 141
 142         for (t1 = TAILQ_NEXT(t1, b_p); t1 != NULL; t1 = TAILQ_NEXT(t1, b_p)) {
 143                 if (t1->sysindex != t_idx) {
 144                         if (bridge_compare_sysidx(b_idx, t1->sysindex) < 0)
 145                                 return (TAILQ_PREV(t1, bridge_ports, b_p));
 146                         else
 147                                 t_idx = t1->sysindex;
 148                 }
 149         }
 150
 151         if (t1 == NULL)
 152                 t1 = TAILQ_LAST(headp, bridge_ports);
 153
 154         return (t1);
 155 }
 156
 157 /*
 158  * Insert a bridge member interface in the ports TAILQ.
 159  */
 160 static void
 161 bridge_port_memif_insert(struct bridge_ports *headp,
 162         struct bridge_port *bp, struct bridge_port **f_bp)
 163 {
 164         struct bridge_port *temp;
 165
 166         if (*f_bp != NULL)
 167                 bridge_port_insert_at(headp, bp, f_bp);
 168         else {
 169                 temp = bridge_port_find_pos(headp, bp->sysindex);
 170
 171                 if (temp == NULL)
 172                         TAILQ_INSERT_HEAD(headp, bp, b_p);
 173                 else
 174                         TAILQ_INSERT_AFTER(headp, temp, bp, b_p);
 175                 *f_bp = bp;
 176         }
 177 }
 178
 179 /* The global ports list. */
 180 static struct bridge_ports bridge_ports = TAILQ_HEAD_INITIALIZER(bridge_ports);
 181 static time_t ports_list_age;
 182
 183 void
 184 bridge_ports_update_listage(void)
 185 {
 186         ports_list_age = time(NULL);
 187 }
 188
 189 void
 190 bridge_ports_fini(void)
 191 {
 192         bridge_ports_free(&bridge_ports);
 193 }
 194
 195 void
 196 bridge_members_free(struct bridge_if *bif)
 197 {
 198         bridge_port_memif_free(&bridge_ports, bif);
 199 }
 200
 201 /*
 202  * Find the first port in the ports list.
 203  */
 204 static struct bridge_port *
 205 bridge_port_first(void)
 206 {
 207         return (TAILQ_FIRST(&bridge_ports));
 208 }
 209
 210 /*
 211  * Find the next port in the ports list.
 212  */
 213 static struct bridge_port *
 214 bridge_port_next(struct bridge_port *bp)
 215 {
 216         return (TAILQ_NEXT(bp, b_p));
 217 }
 218
 219 /*
 220  * Find the first member of the specified bridge interface.
 221  */
 222 struct bridge_port *
 223 bridge_port_bif_first(struct bridge_if *bif)
 224 {
 225         return (bif->f_bp);
 226 }
 227
 228 /*
 229  * Find the next member of the specified bridge interface.
 230  */
 231 struct bridge_port *
 232 bridge_port_bif_next(struct bridge_port *bp)
 233 {
 234         struct bridge_port *bp_next;
 235
 236         if ((bp_next = TAILQ_NEXT(bp, b_p)) == NULL ||
 237             bp_next->sysindex != bp->sysindex)
 238                 return (NULL);
 239
 240         return (bp_next);
 241 }
 242
 243 /*
 244  * Remove a bridge port from the ports list.
 245  */
 246 void
 247 bridge_port_remove(struct bridge_port *bp, struct bridge_if *bif)
 248 {
 249         if (bif->f_bp == bp)
 250                 bif->f_bp = bridge_port_bif_next(bp);
 251
 252         TAILQ_REMOVE(&bridge_ports, bp, b_p);
 253         free(bp);
 254 }
 255
 256 /*
 257  * Allocate memory for a new bridge port and insert it
 258  * in the base ports list. Return a pointer to the port's
 259  * structure in case we want to do anything else with it.
 260  */
 261 struct bridge_port *
 262 bridge_new_port(struct mibif *mif, struct bridge_if *bif)
 263 {
 264         struct bridge_port *bp;
 265
 266         if ((bp = (struct bridge_port *) malloc(sizeof(*bp))) == NULL) {
 267                 syslog(LOG_ERR, "bridge new member: failed: %s",
 268                         strerror(errno));
 269                 return (NULL);
 270         }
 271
 272         bzero(bp, sizeof(*bp));
 273
 274         bp->sysindex = bif->sysindex;
 275         bp->if_idx = mif->index;
 276         bp->port_no = mif->sysindex;
 277         strlcpy(bp->p_name, mif->name, IFNAMSIZ);
 278         bp->circuit = oid_zeroDotZero;
 279
 280         /*
 281          * Initialize all rstpMib specific values to false/default.
 282          * These will be set to their true values later if the bridge
 283          * supports RSTP.
 284          */
 285         bp->proto_migr = TruthValue_false;
 286         bp->admin_edge = TruthValue_false;
 287         bp->oper_edge = TruthValue_false;
 288         bp->oper_ptp = TruthValue_false;
 289         bp->admin_ptp = StpPortAdminPointToPointType_auto;
 290
 291         bridge_port_memif_insert(&bridge_ports, bp, &(bif->f_bp));
 292
 293         return (bp);
 294 }
 295
 296 /*
 297  * Update our info from the corresponding mibII interface info.
 298  */
 299 void
 300 bridge_port_getinfo_mibif(struct mibif *m_if, struct bridge_port *bp)
 301 {
 302         bp->max_info = m_if->mib.ifmd_data.ifi_mtu;
 303         bp->in_frames = m_if->mib.ifmd_data.ifi_ipackets;
 304         bp->out_frames = m_if->mib.ifmd_data.ifi_opackets;
 305         bp->in_drops = m_if->mib.ifmd_data.ifi_iqdrops;
 306 }
 307
 308 /*
 309  * Find a port, whose SNMP's mibII ifIndex matches one of the ports,
 310  * members of the specified bridge interface.
 311  */
 312 struct bridge_port *
 313 bridge_port_find(int32_t if_idx, struct bridge_if *bif)
 314 {
 315         struct bridge_port *bp;
 316
 317         for (bp = bif->f_bp; bp != NULL; bp = TAILQ_NEXT(bp, b_p)) {
 318                 if (bp->sysindex != bif->sysindex) {
 319                         bp = NULL;
 320                         break;
 321                 }
 322
 323                 if (bp->if_idx == if_idx)
 324                         break;
 325         }
 326
 327         return (bp);
 328 }
 329
 330 void
 331 bridge_ports_dump(struct bridge_if *bif)
 332 {
 333         struct bridge_port *bp;
 334
 335         for (bp = bridge_port_bif_first(bif); bp != NULL;
 336             bp = bridge_port_bif_next(bp)) {
 337                 syslog(LOG_ERR, "memif - %s, index - %d",
 338                 bp->p_name, bp->port_no);
 339         }
 340 }
 341
 342 /*
 343  * RFC4188 specifics.
 344  */
 345 int
 346 op_dot1d_base_port(struct snmp_context *c __unused, struct snmp_value *val,
 347         uint sub, uint iidx __unused, enum snmp_op op)
 348 {
 349         struct bridge_if *bif;
 350         struct bridge_port *bp;
 351
 352         if ((bif = bridge_get_default()) == NULL)
 353                 return (SNMP_ERR_NOSUCHNAME);
 354
 355         if (time(NULL) - bif->ports_age > bridge_get_data_maxage() &&
 356             bridge_update_memif(bif) <= 0)
 357                 return (SNMP_ERR_NOSUCHNAME);
 358
 359         switch (op) {
 360                 case SNMP_OP_GET:
 361                     if (val->var.len - sub != 1)
 362                         return (SNMP_ERR_NOSUCHNAME);
 363                     if ((bp = bridge_port_find(val->var.subs[sub],
 364                         bif)) == NULL)
 365                             return (SNMP_ERR_NOSUCHNAME);
 366                     goto get;
 367
 368                 case SNMP_OP_GETNEXT:
 369                     if (val->var.len - sub == 0) {
 370                         if ((bp = bridge_port_bif_first(bif)) == NULL)
 371                             return (SNMP_ERR_NOSUCHNAME);
 372                     } else {
 373                         if ((bp = bridge_port_find(val->var.subs[sub],
 374                             bif)) == NULL ||
 375                             (bp = bridge_port_bif_next(bp)) == NULL)
 376                                 return (SNMP_ERR_NOSUCHNAME);
 377                     }
 378                     val->var.len = sub + 1;
 379                     val->var.subs[sub] = bp->port_no;
 380                     goto get;
 381
 382                 case SNMP_OP_SET:
 383                     return (SNMP_ERR_NOT_WRITEABLE);
 384
 385                 case SNMP_OP_ROLLBACK:
 386                 case SNMP_OP_COMMIT:
 387                     break;
 388         }
 389         abort();
 390
 391 get:
 392         switch (val->var.subs[sub - 1]) {
 393             case LEAF_dot1dBasePort:
 394                 val->v.integer = bp->port_no;
 395                 return (SNMP_ERR_NOERROR);
 396
 397             case LEAF_dot1dBasePortIfIndex:
 398                 val->v.integer = bp->if_idx;
 399                 return (SNMP_ERR_NOERROR);
 400
 401             case LEAF_dot1dBasePortCircuit:
 402                 val->v.oid = bp->circuit;
 403                 return (SNMP_ERR_NOERROR);
 404
 405             case LEAF_dot1dBasePortDelayExceededDiscards:
 406                 val->v.uint32 = bp->dly_ex_drops;
 407                 return (SNMP_ERR_NOERROR);
 408
 409             case LEAF_dot1dBasePortMtuExceededDiscards:
 410                 val->v.uint32 = bp->dly_mtu_drops;
 411                 return (SNMP_ERR_NOERROR);
 412         }
 413
 414         abort();
 415 }
 416
 417 int
 418 op_dot1d_stp_port(struct snmp_context *ctx, struct snmp_value *val,
 419          uint sub, uint iidx __unused, enum snmp_op op)
 420 {
 421         struct bridge_if *bif;
 422         struct bridge_port *bp;
 423
 424         if ((bif = bridge_get_default()) == NULL)
 425                 return (SNMP_ERR_NOSUCHNAME);
 426
 427         if (time(NULL) - bif->ports_age > bridge_get_data_maxage() &&
 428             bridge_update_memif(bif) <= 0)
 429                 return (SNMP_ERR_NOSUCHNAME);
 430
 431         switch (op) {
 432                 case SNMP_OP_GET:
 433                     if (val->var.len - sub != 1)
 434                         return (SNMP_ERR_NOSUCHNAME);
 435                     if ((bp = bridge_port_find(val->var.subs[sub],
 436                         bif)) == NULL)
 437                             return (SNMP_ERR_NOSUCHNAME);
 438                     goto get;
 439
 440                 case SNMP_OP_GETNEXT:
 441                     if (val->var.len - sub == 0) {
 442                         if ((bp = bridge_port_bif_first(bif)) == NULL)
 443                             return (SNMP_ERR_NOSUCHNAME);
 444                     } else {
 445                         if ((bp = bridge_port_find(val->var.subs[sub],
 446                             bif)) == NULL ||
 447                             (bp = bridge_port_bif_next(bp)) == NULL)
 448                                 return (SNMP_ERR_NOSUCHNAME);
 449                     }
 450                     val->var.len = sub + 1;
 451                     val->var.subs[sub] = bp->port_no;
 452                     goto get;
 453
 454                 case SNMP_OP_SET:
 455                     if (val->var.len - sub != 1)
 456                         return (SNMP_ERR_NOSUCHNAME);
 457                     if ((bp = bridge_port_find(val->var.subs[sub],
 458                         bif)) == NULL)
 459                             return (SNMP_ERR_NOSUCHNAME);
 460
 461                     switch (val->var.subs[sub - 1]) {
 462                         case LEAF_dot1dStpPortPriority:
 463                             if (val->v.integer < 0 || val->v.integer > 255)
 464                                 return (SNMP_ERR_WRONG_VALUE);
 465
 466                             ctx->scratch->int1 = bp->priority;
 467                             if (bridge_port_set_priority(bif->bif_name, bp,
 468                                 val->v.integer) < 0)
 469                                 return (SNMP_ERR_GENERR);
 470                             return (SNMP_ERR_NOERROR);
 471
 472                         case LEAF_dot1dStpPortEnable:
 473                             if (val->v.integer != dot1dStpPortEnable_enabled &&
 474                                 val->v.integer != dot1dStpPortEnable_disabled)
 475                                 return (SNMP_ERR_WRONG_VALUE);
 476
 477                             ctx->scratch->int1 = bp->enable;
 478                             if (bridge_port_set_stp_enable(bif->bif_name,
 479                                 bp, val->v.integer) < 0)
 480                                 return (SNMP_ERR_GENERR);
 481                             return (SNMP_ERR_NOERROR);
 482
 483                         case LEAF_dot1dStpPortPathCost:
 484                             if (val->v.integer < SNMP_PORT_MIN_PATHCOST ||
 485                                 val->v.integer > SNMP_PORT_MAX_PATHCOST)
 486                                 return (SNMP_ERR_WRONG_VALUE);
 487
 488                             ctx->scratch->int1 = bp->path_cost;
 489                             if (bridge_port_set_path_cost(bif->bif_name, bp,
 490                                 val->v.integer) < 0)
 491                                 return (SNMP_ERR_GENERR);
 492                             return (SNMP_ERR_NOERROR);
 493
 494                         case LEAF_dot1dStpPort:
 495                         case LEAF_dot1dStpPortState:
 496                         case LEAF_dot1dStpPortDesignatedRoot:
 497                         case LEAF_dot1dStpPortDesignatedCost:
 498                         case LEAF_dot1dStpPortDesignatedBridge:
 499                         case LEAF_dot1dStpPortDesignatedPort:
 500                         case LEAF_dot1dStpPortForwardTransitions:
 501                             return (SNMP_ERR_NOT_WRITEABLE);
 502                     }
 503                     abort();
 504
 505                 case SNMP_OP_ROLLBACK:
 506                     if ((bp = bridge_port_find(val->var.subs[sub],
 507                         bif)) == NULL)
 508                             return (SNMP_ERR_GENERR);
 509                     switch (val->var.subs[sub - 1]) {
 510                         case LEAF_dot1dStpPortPriority:
 511                             bridge_port_set_priority(bif->bif_name, bp,
 512                                 ctx->scratch->int1);
 513                             break;
 514                         case LEAF_dot1dStpPortEnable:
 515                             bridge_port_set_stp_enable(bif->bif_name, bp,
 516                                 ctx->scratch->int1);
 517                             break;
 518                         case LEAF_dot1dStpPortPathCost:
 519                             bridge_port_set_path_cost(bif->bif_name, bp,
 520                                 ctx->scratch->int1);
 521                             break;
 522                     }
 523                     return (SNMP_ERR_NOERROR);
 524
 525                 case SNMP_OP_COMMIT:
 526                     return (SNMP_ERR_NOERROR);
 527         }
 528         abort();
 529
 530 get:
 531         switch (val->var.subs[sub - 1]) {
 532                 case LEAF_dot1dStpPort:
 533                         val->v.integer = bp->port_no;
 534                         return (SNMP_ERR_NOERROR);
 535
 536                 case LEAF_dot1dStpPortPriority:
 537                         val->v.integer = bp->priority;
 538                         return (SNMP_ERR_NOERROR);
 539
 540                 case LEAF_dot1dStpPortState:
 541                         val->v.integer = bp->state;
 542                         return (SNMP_ERR_NOERROR);
 543
 544                 case LEAF_dot1dStpPortEnable:
 545                         val->v.integer = bp->enable;
 546                         return (SNMP_ERR_NOERROR);
 547
 548                 case LEAF_dot1dStpPortPathCost:
 549                         val->v.integer = bp->path_cost;
 550                         return (SNMP_ERR_NOERROR);
 551
 552                 case LEAF_dot1dStpPortDesignatedRoot:
 553                         return (string_get(val, bp->design_root,
 554                             SNMP_BRIDGE_ID_LEN));
 555
 556                 case LEAF_dot1dStpPortDesignatedCost:
 557                         val->v.integer = bp->design_cost;
 558                         return (SNMP_ERR_NOERROR);
 559
 560                 case LEAF_dot1dStpPortDesignatedBridge:
 561                         return (string_get(val, bp->design_bridge,
 562                             SNMP_BRIDGE_ID_LEN));
 563
 564                 case LEAF_dot1dStpPortDesignatedPort:
 565                         return (string_get(val, bp->design_port, 2));
 566
 567                 case LEAF_dot1dStpPortForwardTransitions:
 568                         val->v.uint32 = bp->fwd_trans;
 569                         return (SNMP_ERR_NOERROR);
 570         }
 571
 572         abort();
 573 }
 574
 575 int
 576 op_dot1d_stp_ext_port(struct snmp_context *ctx, struct snmp_value *val,
 577     uint sub, uint iidx __unused, enum snmp_op op)
 578 {
 579         struct bridge_if *bif;
 580         struct bridge_port *bp;
 581
 582         if ((bif = bridge_get_default()) == NULL)
 583                 return (SNMP_ERR_NOSUCHNAME);
 584
 585         if (time(NULL) - bif->ports_age > bridge_get_data_maxage() &&
 586             bridge_update_memif(bif) <= 0)
 587                 return (SNMP_ERR_NOSUCHNAME);
 588
 589         switch (op) {
 590                 case SNMP_OP_GET:
 591                     if (val->var.len - sub != 1)
 592                         return (SNMP_ERR_NOSUCHNAME);
 593                     if ((bp = bridge_port_find(val->var.subs[sub],
 594                         bif)) == NULL)
 595                             return (SNMP_ERR_NOSUCHNAME);
 596                     goto get;
 597
 598                 case SNMP_OP_GETNEXT:
 599                     if (val->var.len - sub == 0) {
 600                         if ((bp = bridge_port_bif_first(bif)) == NULL)
 601                             return (SNMP_ERR_NOSUCHNAME);
 602                     } else {
 603                         if ((bp = bridge_port_find(val->var.subs[sub],
 604                             bif)) == NULL ||
 605                             (bp = bridge_port_bif_next(bp)) == NULL)
 606                                 return (SNMP_ERR_NOSUCHNAME);
 607                     }
 608                     val->var.len = sub + 1;
 609                     val->var.subs[sub] = bp->port_no;
 610                     goto get;
 611
 612                 case SNMP_OP_SET:
 613                     if (val->var.len - sub != 1)
 614                         return (SNMP_ERR_NOSUCHNAME);
 615                     if ((bp = bridge_port_find(val->var.subs[sub],
 616                         bif)) == NULL)
 617                             return (SNMP_ERR_NOSUCHNAME);
 618
 619                     switch (val->var.subs[sub - 1]) {
 620                         case LEAF_dot1dStpPortAdminEdgePort:
 621                             if (val->v.integer != TruthValue_true &&
 622                                 val->v.integer != TruthValue_false)
 623                                 return (SNMP_ERR_WRONG_VALUE);
 624
 625                             ctx->scratch->int1 = bp->admin_edge;
 626                             if (bridge_port_set_admin_edge(bif->bif_name, bp,
 627                                 val->v.integer) < 0)
 628                                 return (SNMP_ERR_GENERR);
 629                             return (SNMP_ERR_NOERROR);
 630
 631                         case LEAF_dot1dStpPortAdminPointToPoint:
 632                             if (val->v.integer < 0 || val->v.integer >
 633                                 StpPortAdminPointToPointType_auto)
 634                                 return (SNMP_ERR_WRONG_VALUE);
 635
 636                             ctx->scratch->int1 = bp->admin_ptp;
 637                             if (bridge_port_set_admin_ptp(bif->bif_name, bp,
 638                                 val->v.integer) < 0)
 639                                 return (SNMP_ERR_GENERR);
 640                             return (SNMP_ERR_NOERROR);
 641
 642                         case LEAF_dot1dStpPortAdminPathCost:
 643                             if (val->v.integer < SNMP_PORT_MIN_PATHCOST ||
 644                                 val->v.integer > SNMP_PORT_MAX_PATHCOST)
 645                                 return (SNMP_ERR_WRONG_VALUE);
 646
 647                             ctx->scratch->int1 = bp->admin_path_cost;
 648                             if (bridge_port_set_path_cost(bif->bif_name, bp,
 649                                 val->v.integer) < 0)
 650                                 return (SNMP_ERR_GENERR);
 651                             return (SNMP_ERR_NOERROR);
 652
 653                         case LEAF_dot1dStpPortProtocolMigration:
 654                         case LEAF_dot1dStpPortOperEdgePort:
 655                         case LEAF_dot1dStpPortOperPointToPoint:
 656                             return (SNMP_ERR_NOT_WRITEABLE);
 657                     }
 658                     abort();
 659
 660                 case SNMP_OP_ROLLBACK:
 661                     if ((bp = bridge_port_find(val->var.subs[sub],
 662                         bif)) == NULL)
 663                             return (SNMP_ERR_GENERR);
 664
 665                     switch (val->var.subs[sub - 1]) {
 666                         case LEAF_dot1dStpPortAdminEdgePort:
 667                             bridge_port_set_admin_edge(bif->bif_name, bp,
 668                                 ctx->scratch->int1);
 669                             break;
 670                         case LEAF_dot1dStpPortAdminPointToPoint:
 671                             bridge_port_set_admin_ptp(bif->bif_name, bp,
 672                                 ctx->scratch->int1);
 673                             break;
 674                         case LEAF_dot1dStpPortAdminPathCost:
 675                             bridge_port_set_path_cost(bif->bif_name, bp,
 676                                 ctx->scratch->int1);
 677                             break;
 678                     }
 679                     return (SNMP_ERR_NOERROR);
 680
 681                 case SNMP_OP_COMMIT:
 682                     return (SNMP_ERR_NOERROR);
 683         }
 684         abort();
 685
 686 get:
 687         switch (val->var.subs[sub - 1]) {
 688                 case LEAF_dot1dStpPortProtocolMigration:
 689                         val->v.integer = bp->proto_migr;
 690                         return (SNMP_ERR_NOERROR);
 691
 692                 case LEAF_dot1dStpPortAdminEdgePort:
 693                         val->v.integer = bp->admin_edge;
 694                         return (SNMP_ERR_NOERROR);
 695
 696                 case LEAF_dot1dStpPortOperEdgePort:
 697                         val->v.integer = bp->oper_edge;
 698                         return (SNMP_ERR_NOERROR);
 699
 700                 case LEAF_dot1dStpPortAdminPointToPoint:
 701                         val->v.integer = bp->admin_ptp;
 702                         return (SNMP_ERR_NOERROR);
 703
 704                 case LEAF_dot1dStpPortOperPointToPoint:
 705                         val->v.integer = bp->oper_ptp;
 706                         return (SNMP_ERR_NOERROR);
 707
 708                 case LEAF_dot1dStpPortAdminPathCost:
 709                         val->v.integer = bp->admin_path_cost;
 710                         return (SNMP_ERR_NOERROR);
 711         }
 712
 713         abort();
 714 }
 715
 716 int
 717 op_dot1d_tp_port(struct snmp_context *c __unused, struct snmp_value *val,
 718     uint sub, uint iidx __unused, enum snmp_op op)
 719 {
 720         struct bridge_if *bif;
 721         struct bridge_port *bp;
 722
 723         if ((bif = bridge_get_default()) == NULL)
 724                 return (SNMP_ERR_NOSUCHNAME);
 725
 726         if (time(NULL) - bif->ports_age > bridge_get_data_maxage() &&
 727             bridge_update_memif(bif) <= 0)
 728                 return (SNMP_ERR_NOSUCHNAME);
 729
 730         switch (op) {
 731                 case SNMP_OP_GET:
 732                     if (val->var.len - sub != 1)
 733                         return (SNMP_ERR_NOSUCHNAME);
 734                     if ((bp = bridge_port_find(val->var.subs[sub],
 735                         bif)) == NULL)
 736                             return (SNMP_ERR_NOSUCHNAME);
 737                     goto get;
 738
 739                 case SNMP_OP_GETNEXT:
 740                     if (val->var.len - sub == 0) {
 741                         if ((bp = bridge_port_bif_first(bif)) == NULL)
 742                             return (SNMP_ERR_NOSUCHNAME);
 743                     } else {
 744                         if ((bp = bridge_port_find(val->var.subs[sub],
 745                             bif)) == NULL ||
 746                             (bp = bridge_port_bif_next(bp)) == NULL)
 747                                 return (SNMP_ERR_NOSUCHNAME);
 748                     }
 749                     val->var.len = sub + 1;
 750                     val->var.subs[sub] = bp->port_no;
 751                     goto get;
 752
 753                 case SNMP_OP_SET:
 754                     return (SNMP_ERR_NOT_WRITEABLE);
 755
 756                 case SNMP_OP_ROLLBACK:
 757                 case SNMP_OP_COMMIT:
 758                     break;
 759         }
 760         abort();
 761
 762 get:
 763         switch (val->var.subs[sub - 1]) {
 764                 case LEAF_dot1dTpPort:
 765                         val->v.integer = bp->port_no;
 766                         return (SNMP_ERR_NOERROR);
 767
 768                 case LEAF_dot1dTpPortMaxInfo:
 769                         val->v.integer = bp->max_info;
 770                         return (SNMP_ERR_NOERROR);
 771
 772                 case LEAF_dot1dTpPortInFrames:
 773                         val->v.uint32 = bp->in_frames;
 774                         return (SNMP_ERR_NOERROR);
 775
 776                 case LEAF_dot1dTpPortOutFrames:
 777                         val->v.uint32 = bp->out_frames;
 778                         return (SNMP_ERR_NOERROR);
 779
 780                 case LEAF_dot1dTpPortInDiscards:
 781                         val->v.uint32 = bp->in_drops;
 782                         return (SNMP_ERR_NOERROR);
 783         }
 784
 785         abort();
 786 }
 787
 788 /*
 789  * Private BEGEMOT-BRIDGE-MIB specifics.
 790  */
 791
 792 /*
 793  * Construct a bridge port entry index.
 794  */
 795 static int
 796 bridge_port_index_append(struct asn_oid *oid, uint sub,
 797         const struct bridge_port *bp)
 798 {
 799         uint i;
 800         const char *b_name;
 801
 802         if ((b_name = bridge_if_find_name(bp->sysindex)) == NULL)
 803                 return (-1);
 804
 805         oid->len = sub + strlen(b_name) + 1 + 1;
 806         oid->subs[sub] = strlen(b_name);
 807
 808         for (i = 1; i <= strlen(b_name); i++)
 809                 oid->subs[sub + i] = b_name[i - 1];
 810
 811         oid->subs[sub + i] = bp->port_no;
 812
 813         return (0);
 814 }
 815
 816 /*
 817  * Get the port entry from an entry's index.
 818  */
 819 static struct bridge_port *
 820 bridge_port_index_get(const struct asn_oid *oid, uint sub, int8_t status)
 821 {
 822         uint i;
 823         int32_t port_no;
 824         char bif_name[IFNAMSIZ];
 825         struct bridge_if *bif;
 826         struct bridge_port *bp;
 827
 828         if (oid->len - sub != oid->subs[sub] + 2 ||
 829             oid->subs[sub] >= IFNAMSIZ)
 830                 return (NULL);
 831
 832         for (i = 0; i < oid->subs[sub]; i++)
 833                 bif_name[i] = oid->subs[sub + i + 1];
 834         bif_name[i] = '\0';
 835
 836         port_no = oid->subs[sub + i + 1];
 837
 838         if ((bif = bridge_if_find_ifname(bif_name)) == NULL)
 839                 return (NULL);
 840
 841         if ((bp = bridge_port_find(port_no, bif)) == NULL ||
 842             (status == 0 && bp->status != RowStatus_active))
 843                 return (NULL);
 844
 845         return (bp);
 846 }
 847
 848 /*
 849  * Get the next port entry from an entry's index.
 850  */
 851 static struct bridge_port *
 852 bridge_port_index_getnext(const struct asn_oid *oid, uint sub, int8_t status)
 853 {
 854         uint i;
 855         int32_t port_no;
 856         char bif_name[IFNAMSIZ];
 857         struct bridge_if *bif;
 858         struct bridge_port *bp;
 859
 860         if (oid->len - sub == 0)
 861                 bp = bridge_port_first();
 862         else {
 863                 if (oid->len - sub != oid->subs[sub] + 2 ||
 864                     oid->subs[sub] >= IFNAMSIZ)
 865                         return (NULL);
 866
 867                 for (i = 0; i < oid->subs[sub]; i++)
 868                         bif_name[i] = oid->subs[sub + i + 1];
 869                 bif_name[i] = '\0';
 870
 871                 port_no = oid->subs[sub + i + 1];
 872
 873                 if ((bif = bridge_if_find_ifname(bif_name)) == NULL ||
 874                     (bp = bridge_port_find(port_no, bif)) == NULL)
 875                         return (NULL);
 876
 877                 bp = bridge_port_next(bp);
 878         }
 879
 880         if (status == 1)
 881                 return (bp);
 882
 883         while (bp != NULL) {
 884                 if (bp->status == RowStatus_active)
 885                         break;
 886                 bp = bridge_port_next(bp);
 887         }
 888
 889         return (bp);
 890 }
 891
 892 /*
 893  * Read the bridge name and port index from a ASN OID structure.
 894  */
 895 static int
 896 bridge_port_index_decode(const struct asn_oid *oid, uint sub,
 897         char *b_name, int32_t *idx)
 898 {
 899         uint i;
 900
 901         if (oid->len - sub != oid->subs[sub] + 2 ||
 902             oid->subs[sub] >= IFNAMSIZ)
 903                 return (-1);
 904
 905         for (i = 0; i < oid->subs[sub]; i++)
 906                 b_name[i] = oid->subs[sub + i + 1];
 907         b_name[i] = '\0';
 908
 909         *idx = oid->subs[sub + i + 1];
 910         return (0);
 911 }
 912
 913 static int
 914 bridge_port_set_status(struct snmp_context *ctx,
 915         struct snmp_value *val, uint sub)
 916 {
 917         int32_t if_idx;
 918         char b_name[IFNAMSIZ];
 919         struct bridge_if *bif;
 920         struct bridge_port *bp;
 921         struct mibif *mif;
 922
 923         if (bridge_port_index_decode(&val->var, sub, b_name, &if_idx) < 0)
 924                 return (SNMP_ERR_INCONS_VALUE);
 925
 926         if ((bif = bridge_if_find_ifname(b_name)) == NULL ||
 927             (mif = mib_find_if(if_idx)) == NULL)
 928                 return (SNMP_ERR_INCONS_VALUE);
 929
 930         bp = bridge_port_find(if_idx, bif);
 931
 932         switch (val->v.integer) {
 933             case RowStatus_active:
 934                 if (bp == NULL)
 935                     return (SNMP_ERR_INCONS_VALUE);
 936
 937                 if (bp->span_enable == 0)
 938                     return (SNMP_ERR_INCONS_VALUE);
 939
 940                 ctx->scratch->int1 = bp->status;
 941                 bp->status = RowStatus_active;
 942                 break;
 943
 944             case RowStatus_notInService:
 945                 if (bp == NULL || bp->span_enable == 0 ||
 946                     bp->status == RowStatus_active)
 947                         return (SNMP_ERR_INCONS_VALUE);
 948
 949                 ctx->scratch->int1 = bp->status;
 950                 bp->status = RowStatus_notInService;
 951
 952             case RowStatus_notReady:
 953                 /* FALLTHROUGH */
 954             case RowStatus_createAndGo:
 955                 return (SNMP_ERR_INCONS_VALUE);
 956
 957             case RowStatus_createAndWait:
 958                 if (bp != NULL)
 959                     return (SNMP_ERR_INCONS_VALUE);
 960
 961                 if ((bp = bridge_new_port(mif, bif)) == NULL)
 962                         return (SNMP_ERR_GENERR);
 963
 964                 ctx->scratch->int1 = RowStatus_destroy;
 965                 bp->status = RowStatus_notReady;
 966                 break;
 967
 968             case RowStatus_destroy:
 969                 if (bp == NULL)
 970                     return (SNMP_ERR_INCONS_VALUE);
 971
 972                 ctx->scratch->int1 = bp->status;
 973                 bp->status = RowStatus_destroy;
 974                 break;
 975         }
 976
 977         return (SNMP_ERR_NOERROR);
 978 }
 979
 980 static int
 981 bridge_port_rollback_status(struct snmp_context *ctx,
 982         struct snmp_value *val, uint sub)
 983 {
 984         int32_t if_idx;
 985         char b_name[IFNAMSIZ];
 986         struct bridge_if *bif;
 987         struct bridge_port *bp;
 988
 989         if (bridge_port_index_decode(&val->var, sub, b_name, &if_idx) < 0)
 990                 return (SNMP_ERR_GENERR);
 991
 992         if ((bif = bridge_if_find_ifname(b_name)) == NULL ||
 993             (bp = bridge_port_find(if_idx, bif)) == NULL)
 994                 return (SNMP_ERR_GENERR);
 995
 996         if (ctx->scratch->int1 == RowStatus_destroy)
 997                 bridge_port_remove(bp, bif);
 998         else
 999                 bp->status = ctx->scratch->int1;
1000
1001         return (SNMP_ERR_NOERROR);
1002 }
1003
1004 static int
1005 bridge_port_commit_status(struct snmp_value *val, uint sub)
1006 {
1007         int32_t if_idx;
1008         char b_name[IFNAMSIZ];
1009         struct bridge_if *bif;
1010         struct bridge_port *bp;
1011
1012         if (bridge_port_index_decode(&val->var, sub, b_name, &if_idx) < 0)
1013                 return (SNMP_ERR_GENERR);
1014
1015         if ((bif = bridge_if_find_ifname(b_name)) == NULL ||
1016             (bp = bridge_port_find(if_idx, bif)) == NULL)
1017                 return (SNMP_ERR_GENERR);
1018
1019         switch (bp->status) {
1020                 case RowStatus_active:
1021                         if (bridge_port_addm(bp, b_name) < 0)
1022                                 return (SNMP_ERR_COMMIT_FAILED);
1023                         break;
1024
1025                 case RowStatus_destroy:
1026                         if (bridge_port_delm(bp, b_name) < 0)
1027                                 return (SNMP_ERR_COMMIT_FAILED);
1028                         bridge_port_remove(bp, bif);
1029                         break;
1030         }
1031
1032         return (SNMP_ERR_NOERROR);
1033 }
1034
1035 static int
1036 bridge_port_set_span_enable(struct snmp_context *ctx,
1037                 struct snmp_value *val, uint sub)
1038 {
1039         int32_t if_idx;
1040         char b_name[IFNAMSIZ];
1041         struct bridge_if *bif;
1042         struct bridge_port *bp;
1043         struct mibif *mif;
1044
1045         if (val->v.integer != begemotBridgeBaseSpanEnabled_enabled &&
1046             val->v.integer != begemotBridgeBaseSpanEnabled_disabled)
1047                 return (SNMP_ERR_BADVALUE);
1048
1049         if (bridge_port_index_decode(&val->var, sub, b_name, &if_idx) < 0)
1050                 return (SNMP_ERR_INCONS_VALUE);
1051
1052         if ((bif = bridge_if_find_ifname(b_name)) == NULL)
1053                 return (SNMP_ERR_INCONS_VALUE);
1054
1055         if ((bp = bridge_port_find(if_idx, bif)) == NULL) {
1056                 if ((mif = mib_find_if(if_idx)) == NULL)
1057                         return (SNMP_ERR_INCONS_VALUE);
1058
1059                 if ((bp = bridge_new_port(mif, bif)) == NULL)
1060                         return (SNMP_ERR_GENERR);
1061
1062                 ctx->scratch->int1 = RowStatus_destroy;
1063         } else if (bp->status == RowStatus_active) {
1064                 return (SNMP_ERR_INCONS_VALUE);
1065         } else {
1066                 ctx->scratch->int1 = bp->status;
1067         }
1068
1069         bp->span_enable = val->v.integer;
1070         bp->status = RowStatus_notInService;
1071
1072         return (SNMP_ERR_NOERROR);
1073 }
1074
1075 int
1076 op_begemot_base_port(struct snmp_context *ctx, struct snmp_value *val,
1077         uint sub, uint iidx __unused, enum snmp_op op)
1078 {
1079         int8_t status, which;
1080         const char *bname;
1081         struct bridge_port *bp;
1082
1083         if (time(NULL) - ports_list_age > bridge_get_data_maxage())
1084                 bridge_update_all_ports();
1085
1086         which = val->var.subs[sub - 1];
1087         status = 0;
1088
1089         switch (op) {
1090             case SNMP_OP_GET:
1091                 if (which == LEAF_begemotBridgeBaseSpanEnabled ||
1092                     which == LEAF_begemotBridgeBasePortStatus)
1093                         status = 1;
1094                 if ((bp = bridge_port_index_get(&val->var, sub,
1095                     status)) == NULL)
1096                         return (SNMP_ERR_NOSUCHNAME);
1097                 goto get;
1098
1099             case SNMP_OP_GETNEXT:
1100                 if (which == LEAF_begemotBridgeBaseSpanEnabled ||
1101                     which == LEAF_begemotBridgeBasePortStatus)
1102                         status = 1;
1103                 if ((bp = bridge_port_index_getnext(&val->var, sub,
1104                     status)) == NULL ||
1105                     bridge_port_index_append(&val->var, sub, bp) < 0)
1106                         return (SNMP_ERR_NOSUCHNAME);
1107                 goto get;
1108
1109             case SNMP_OP_SET:
1110                 switch (which) {
1111                     case LEAF_begemotBridgeBaseSpanEnabled:
1112                         return (bridge_port_set_span_enable(ctx, val, sub));
1113
1114                     case LEAF_begemotBridgeBasePortStatus:
1115                         return (bridge_port_set_status(ctx, val, sub));
1116
1117                     case LEAF_begemotBridgeBasePortPrivate:
1118                         if ((bp = bridge_port_index_get(&val->var, sub,
1119                             status)) == NULL)
1120                                 return (SNMP_ERR_NOSUCHNAME);
1121                         if ((bname = bridge_if_find_name(bp->sysindex)) == NULL)
1122                                 return (SNMP_ERR_GENERR);
1123                         ctx->scratch->int1 = bp->priv_set;
1124                         return (bridge_port_set_private(bname, bp,
1125                             val->v.integer));
1126
1127                     case LEAF_begemotBridgeBasePort:
1128                     case LEAF_begemotBridgeBasePortIfIndex:
1129                     case LEAF_begemotBridgeBasePortDelayExceededDiscards:
1130                     case LEAF_begemotBridgeBasePortMtuExceededDiscards:
1131                         return (SNMP_ERR_NOT_WRITEABLE);
1132                 }
1133                 abort();
1134
1135             case SNMP_OP_ROLLBACK:
1136                 switch (which) {
1137                     case LEAF_begemotBridgeBaseSpanEnabled:
1138                         /* FALLTHROUGH */
1139                     case LEAF_begemotBridgeBasePortStatus:
1140                         return (bridge_port_rollback_status(ctx, val, sub));
1141                     case LEAF_begemotBridgeBasePortPrivate:
1142                         if ((bp = bridge_port_index_get(&val->var, sub,
1143                             status)) == NULL)
1144                                 return (SNMP_ERR_GENERR);
1145                         if ((bname = bridge_if_find_name(bp->sysindex)) == NULL)
1146                                 return (SNMP_ERR_GENERR);
1147                         return (bridge_port_set_private(bname, bp,
1148                             ctx->scratch->int1));
1149                 }
1150                 return (SNMP_ERR_NOERROR);
1151
1152             case SNMP_OP_COMMIT:
1153                 if (which == LEAF_begemotBridgeBasePortStatus)
1154                         return (bridge_port_commit_status(val, sub));
1155
1156                 return (SNMP_ERR_NOERROR);
1157         }
1158         abort();
1159
1160 get:
1161         switch (which) {
1162             case LEAF_begemotBridgeBasePort:
1163                 val->v.integer = bp->port_no;
1164                 return (SNMP_ERR_NOERROR);
1165
1166             case LEAF_begemotBridgeBasePortIfIndex:
1167                 val->v.integer = bp->if_idx;
1168                 return (SNMP_ERR_NOERROR);
1169
1170             case LEAF_begemotBridgeBaseSpanEnabled:
1171                 val->v.integer = bp->span_enable;
1172                 return (SNMP_ERR_NOERROR);
1173
1174             case LEAF_begemotBridgeBasePortDelayExceededDiscards:
1175                 val->v.uint32 = bp->dly_ex_drops;
1176                 return (SNMP_ERR_NOERROR);
1177
1178             case LEAF_begemotBridgeBasePortMtuExceededDiscards:
1179                 val->v.uint32 = bp->dly_mtu_drops;
1180                 return (SNMP_ERR_NOERROR);
1181
1182             case LEAF_begemotBridgeBasePortStatus:
1183                 val->v.integer = bp->status;
1184                 return (SNMP_ERR_NOERROR);
1185
1186             case LEAF_begemotBridgeBasePortPrivate:
1187                 val->v.integer = bp->priv_set;
1188                 return (SNMP_ERR_NOERROR);
1189         }
1190
1191         abort();
1192 }
1193
1194 int
1195 op_begemot_stp_port(struct snmp_context *ctx, struct snmp_value *val,
1196         uint sub, uint iidx __unused, enum snmp_op op)
1197 {
1198         struct bridge_port *bp;
1199         const char *b_name;
1200
1201         if (time(NULL) - ports_list_age > bridge_get_data_maxage())
1202                 bridge_update_all_ports();
1203
1204         switch (op) {
1205             case SNMP_OP_GET:
1206                 if ((bp = bridge_port_index_get(&val->var, sub, 0)) == NULL)
1207                     return (SNMP_ERR_NOSUCHNAME);
1208                 goto get;
1209
1210             case SNMP_OP_GETNEXT:
1211                 if ((bp = bridge_port_index_getnext(&val->var, sub, 0)) ==
1212                     NULL || bridge_port_index_append(&val->var, sub, bp) < 0)
1213                         return (SNMP_ERR_NOSUCHNAME);
1214                 goto get;
1215
1216             case SNMP_OP_SET:
1217                 if ((bp = bridge_port_index_get(&val->var, sub, 0)) == NULL)
1218                         return (SNMP_ERR_NOSUCHNAME);
1219                 if ((b_name = bridge_if_find_name(bp->sysindex)) == NULL)
1220                         return (SNMP_ERR_GENERR);
1221
1222                 switch (val->var.subs[sub - 1]) {
1223                     case LEAF_begemotBridgeStpPortPriority:
1224                         if (val->v.integer < 0 || val->v.integer > 255)
1225                             return (SNMP_ERR_WRONG_VALUE);
1226
1227                         ctx->scratch->int1 = bp->priority;
1228                         if (bridge_port_set_priority(b_name, bp,
1229                             val->v.integer) < 0)
1230                             return (SNMP_ERR_GENERR);
1231                         return (SNMP_ERR_NOERROR);
1232
1233                     case LEAF_begemotBridgeStpPortEnable:
1234                         if (val->v.integer !=
1235                             (int32_t)begemotBridgeStpPortEnable_enabled ||
1236                             val->v.integer !=
1237                             (int32_t)begemotBridgeStpPortEnable_disabled)
1238                             return (SNMP_ERR_WRONG_VALUE);
1239
1240                         ctx->scratch->int1 = bp->enable;
1241                         if (bridge_port_set_stp_enable(b_name, bp,
1242                             val->v.integer) < 0)
1243                             return (SNMP_ERR_GENERR);
1244                         return (SNMP_ERR_NOERROR);
1245
1246                     case LEAF_begemotBridgeStpPortPathCost:
1247                         if (val->v.integer < SNMP_PORT_MIN_PATHCOST ||
1248                             val->v.integer > SNMP_PORT_MAX_PATHCOST)
1249                             return (SNMP_ERR_WRONG_VALUE);
1250
1251                         ctx->scratch->int1 = bp->path_cost;
1252                         if (bridge_port_set_path_cost(b_name, bp,
1253                             val->v.integer) < 0)
1254                             return (SNMP_ERR_GENERR);
1255                         return (SNMP_ERR_NOERROR);
1256
1257                     case LEAF_begemotBridgeStpPort:
1258                     case LEAF_begemotBridgeStpPortState:
1259                     case LEAF_begemotBridgeStpPortDesignatedRoot:
1260                     case LEAF_begemotBridgeStpPortDesignatedCost:
1261                     case LEAF_begemotBridgeStpPortDesignatedBridge:
1262                     case LEAF_begemotBridgeStpPortDesignatedPort:
1263                     case LEAF_begemotBridgeStpPortForwardTransitions:
1264                         return (SNMP_ERR_NOT_WRITEABLE);
1265                 }
1266                 abort();
1267
1268             case SNMP_OP_ROLLBACK:
1269                 if ((bp = bridge_port_index_get(&val->var, sub, 0)) == NULL ||
1270                     (b_name = bridge_if_find_name(bp->sysindex)) == NULL)
1271                         return (SNMP_ERR_GENERR);
1272
1273                 switch (val->var.subs[sub - 1]) {
1274                     case LEAF_begemotBridgeStpPortPriority:
1275                         bridge_port_set_priority(b_name, bp,
1276                             ctx->scratch->int1);
1277                         break;
1278                     case LEAF_begemotBridgeStpPortEnable:
1279                         bridge_port_set_stp_enable(b_name, bp,
1280                             ctx->scratch->int1);
1281                         break;
1282                     case LEAF_begemotBridgeStpPortPathCost:
1283                         bridge_port_set_path_cost(b_name, bp,
1284                             ctx->scratch->int1);
1285                         break;
1286                 }
1287                 return (SNMP_ERR_NOERROR);
1288
1289             case SNMP_OP_COMMIT:
1290                 return (SNMP_ERR_NOERROR);
1291         }
1292         abort();
1293
1294 get:
1295         switch (val->var.subs[sub - 1]) {
1296             case LEAF_begemotBridgeStpPort:
1297                 val->v.integer = bp->port_no;
1298                 return (SNMP_ERR_NOERROR);
1299
1300             case LEAF_begemotBridgeStpPortPriority:
1301                 val->v.integer = bp->priority;
1302                 return (SNMP_ERR_NOERROR);
1303
1304             case LEAF_begemotBridgeStpPortState:
1305                 val->v.integer = bp->state;
1306                 return (SNMP_ERR_NOERROR);
1307
1308             case LEAF_begemotBridgeStpPortEnable:
1309                 val->v.integer = bp->enable;
1310                 return (SNMP_ERR_NOERROR);
1311
1312             case LEAF_begemotBridgeStpPortPathCost:
1313                 val->v.integer = bp->path_cost;
1314                 return (SNMP_ERR_NOERROR);
1315
1316             case LEAF_begemotBridgeStpPortDesignatedRoot:
1317                 return (string_get(val, bp->design_root, SNMP_BRIDGE_ID_LEN));
1318
1319             case LEAF_begemotBridgeStpPortDesignatedCost:
1320                 val->v.integer = bp->design_cost;
1321                 return (SNMP_ERR_NOERROR);
1322
1323             case LEAF_begemotBridgeStpPortDesignatedBridge:
1324                 return (string_get(val, bp->design_bridge, SNMP_BRIDGE_ID_LEN));
1325
1326             case LEAF_begemotBridgeStpPortDesignatedPort:
1327                 return (string_get(val, bp->design_port, 2));
1328
1329             case LEAF_begemotBridgeStpPortForwardTransitions:
1330                 val->v.uint32 = bp->fwd_trans;
1331                 return (SNMP_ERR_NOERROR);
1332         }
1333
1334         abort();
1335 }
1336
1337 int
1338 op_begemot_stp_ext_port(struct snmp_context *ctx, struct snmp_value *val,
1339     uint sub, uint iidx __unused, enum snmp_op op)
1340 {
1341         struct bridge_port *bp;
1342         const char *b_name;
1343
1344         if (time(NULL) - ports_list_age > bridge_get_data_maxage())
1345                 bridge_update_all_ports();
1346
1347         switch (op) {
1348             case SNMP_OP_GET:
1349                 if ((bp = bridge_port_index_get(&val->var, sub, 0)) == NULL)
1350                     return (SNMP_ERR_NOSUCHNAME);
1351                 goto get;
1352
1353             case SNMP_OP_GETNEXT:
1354                 if ((bp = bridge_port_index_getnext(&val->var, sub, 0)) ==
1355                     NULL || bridge_port_index_append(&val->var, sub, bp) < 0)
1356                         return (SNMP_ERR_NOSUCHNAME);
1357                 goto get;
1358
1359             case SNMP_OP_SET:
1360                 if ((bp = bridge_port_index_get(&val->var, sub, 0)) == NULL)
1361                         return (SNMP_ERR_NOSUCHNAME);
1362                 if ((b_name = bridge_if_find_name(bp->sysindex)) == NULL)
1363                         return (SNMP_ERR_GENERR);
1364
1365                 switch (val->var.subs[sub - 1]) {
1366                     case LEAF_begemotBridgeStpPortAdminEdgePort:
1367                         if (val->v.integer != TruthValue_true &&
1368                             val->v.integer != TruthValue_false)
1369                             return (SNMP_ERR_WRONG_VALUE);
1370
1371                         ctx->scratch->int1 = bp->admin_edge;
1372                         if (bridge_port_set_admin_edge(b_name, bp,
1373                             val->v.integer) < 0)
1374                             return (SNMP_ERR_GENERR);
1375                         return (SNMP_ERR_NOERROR);
1376
1377                     case LEAF_begemotBridgeStpPortAdminPointToPoint:
1378                         if (val->v.integer < 0 || val->v.integer >
1379                             StpPortAdminPointToPointType_auto)
1380                             return (SNMP_ERR_WRONG_VALUE);
1381
1382                         ctx->scratch->int1 = bp->admin_ptp;
1383                         if (bridge_port_set_admin_ptp(b_name, bp,
1384                             val->v.integer) < 0)
1385                             return (SNMP_ERR_GENERR);
1386                         return (SNMP_ERR_NOERROR);
1387
1388                     case LEAF_begemotBridgeStpPortAdminPathCost:
1389                         if (val->v.integer < SNMP_PORT_MIN_PATHCOST ||
1390                             val->v.integer > SNMP_PORT_MAX_PATHCOST)
1391                             return (SNMP_ERR_WRONG_VALUE);
1392
1393                         ctx->scratch->int1 = bp->admin_path_cost;
1394                         if (bridge_port_set_path_cost(b_name, bp,
1395                             val->v.integer) < 0)
1396                             return (SNMP_ERR_GENERR);
1397                         return (SNMP_ERR_NOERROR);
1398
1399                     case LEAF_begemotBridgeStpPortProtocolMigration:
1400                     case LEAF_begemotBridgeStpPortOperEdgePort:
1401                     case LEAF_begemotBridgeStpPortOperPointToPoint:
1402                         return (SNMP_ERR_NOT_WRITEABLE);
1403                 }
1404                 abort();
1405
1406             case SNMP_OP_ROLLBACK:
1407                 if ((bp = bridge_port_index_get(&val->var, sub, 0)) == NULL ||
1408                     (b_name = bridge_if_find_name(bp->sysindex)) == NULL)
1409                         return (SNMP_ERR_GENERR);
1410
1411                 switch (val->var.subs[sub - 1]) {
1412                     case LEAF_begemotBridgeStpPortAdminEdgePort:
1413                         bridge_port_set_admin_edge(b_name, bp,
1414                             ctx->scratch->int1);
1415                         break;
1416                     case LEAF_begemotBridgeStpPortAdminPointToPoint:
1417                         bridge_port_set_admin_ptp(b_name, bp,
1418                             ctx->scratch->int1);
1419                         break;
1420                     case LEAF_begemotBridgeStpPortAdminPathCost:
1421                         bridge_port_set_path_cost(b_name, bp,
1422                             ctx->scratch->int1);
1423                         break;
1424                 }
1425                 return (SNMP_ERR_NOERROR);
1426
1427             case SNMP_OP_COMMIT:
1428                 return (SNMP_ERR_NOERROR);
1429         }
1430         abort();
1431
1432 get:
1433         switch (val->var.subs[sub - 1]) {
1434                 case LEAF_begemotBridgeStpPortProtocolMigration:
1435                         val->v.integer = bp->proto_migr;
1436                         return (SNMP_ERR_NOERROR);
1437
1438                 case LEAF_begemotBridgeStpPortAdminEdgePort:
1439                         val->v.integer = bp->admin_edge;
1440                         return (SNMP_ERR_NOERROR);
1441
1442                 case LEAF_begemotBridgeStpPortOperEdgePort:
1443                         val->v.integer = bp->oper_edge;
1444                         return (SNMP_ERR_NOERROR);
1445
1446                 case LEAF_begemotBridgeStpPortAdminPointToPoint:
1447                         val->v.integer = bp->admin_ptp;
1448                         return (SNMP_ERR_NOERROR);
1449
1450                 case LEAF_begemotBridgeStpPortOperPointToPoint:
1451                         val->v.integer = bp->oper_ptp;
1452                         return (SNMP_ERR_NOERROR);
1453
1454                 case LEAF_begemotBridgeStpPortAdminPathCost:
1455                         val->v.integer = bp->admin_path_cost;
1456                         return (SNMP_ERR_NOERROR);
1457         }
1458
1459         abort();
1460 }
1461
1462 int
1463 op_begemot_tp_port(struct snmp_context *c __unused, struct snmp_value *val,
1464         uint sub, uint iidx __unused, enum snmp_op op)
1465 {
1466         struct bridge_port *bp;
1467
1468         if (time(NULL) - ports_list_age > bridge_get_data_maxage())
1469                 bridge_update_all_ports();
1470
1471         switch (op) {
1472             case SNMP_OP_GET:
1473                 if ((bp = bridge_port_index_get(&val->var, sub, 0)) == NULL)
1474                     return (SNMP_ERR_NOSUCHNAME);
1475                 goto get;
1476
1477             case SNMP_OP_GETNEXT:
1478                 if ((bp = bridge_port_index_getnext(&val->var, sub, 0)) ==
1479                     NULL || bridge_port_index_append(&val->var, sub, bp) < 0)
1480                     return (SNMP_ERR_NOSUCHNAME);
1481                 goto get;
1482
1483             case SNMP_OP_SET:
1484                 return (SNMP_ERR_NOT_WRITEABLE);
1485
1486             case SNMP_OP_ROLLBACK:
1487             case SNMP_OP_COMMIT:
1488                 break;
1489         }
1490         abort();
1491
1492 get:
1493         switch (val->var.subs[sub - 1]) {
1494             case LEAF_begemotBridgeTpPort:
1495                 val->v.integer = bp->port_no;
1496                 return (SNMP_ERR_NOERROR);
1497
1498             case LEAF_begemotBridgeTpPortMaxInfo:
1499                 val->v.integer = bp->max_info;
1500                 return (SNMP_ERR_NOERROR);
1501
1502             case LEAF_begemotBridgeTpPortInFrames:
1503                 val->v.uint32 = bp->in_frames;
1504                 return (SNMP_ERR_NOERROR);
1505
1506             case LEAF_begemotBridgeTpPortOutFrames:
1507                 val->v.uint32 = bp->out_frames;
1508                 return (SNMP_ERR_NOERROR);
1509
1510             case LEAF_begemotBridgeTpPortInDiscards:
1511                 val->v.uint32 = bp->in_drops;
1512                 return (SNMP_ERR_NOERROR);
1513         }
1514
1515         abort();
1516 }