Deleted Added
sdiff udiff text old ( 165046 ) new ( 165253 )
full compact
bridge_port.c (165046) bridge_port.c (165253)
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

--- 12 unchanged lines hidden (view full) ---

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 ports.
28 *
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

--- 12 unchanged lines hidden (view full) ---

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 ports.
28 *
29 * $FreeBSD: head/usr.sbin/bsnmpd/modules/snmp_bridge/bridge_port.c 165046 2006-12-09 20:58:26Z syrinx $
29 * $FreeBSD: head/usr.sbin/bsnmpd/modules/snmp_bridge/bridge_port.c 165253 2006-12-15 20:01:57Z syrinx $
30 */
31
32#include <sys/queue.h>
33#include <sys/socket.h>
34#include <sys/types.h>
35
36#include <net/ethernet.h>
37#include <net/if.h>

--- 317 unchanged lines hidden (view full) ---

355
356 switch (op) {
357 case SNMP_OP_GET:
358 if (val->var.len - sub != 1)
359 return (SNMP_ERR_NOSUCHNAME);
360 if ((bp = bridge_port_find(val->var.subs[sub],
361 bif)) == NULL)
362 return (SNMP_ERR_NOSUCHNAME);
30 */
31
32#include <sys/queue.h>
33#include <sys/socket.h>
34#include <sys/types.h>
35
36#include <net/ethernet.h>
37#include <net/if.h>

--- 317 unchanged lines hidden (view full) ---

355
356 switch (op) {
357 case SNMP_OP_GET:
358 if (val->var.len - sub != 1)
359 return (SNMP_ERR_NOSUCHNAME);
360 if ((bp = bridge_port_find(val->var.subs[sub],
361 bif)) == NULL)
362 return (SNMP_ERR_NOSUCHNAME);
363 break;
363 goto get;
364
365 case SNMP_OP_GETNEXT:
366 if (val->var.len - sub == 0) {
367 if ((bp = bridge_port_bif_first(bif)) == NULL)
368 return (SNMP_ERR_NOSUCHNAME);
369 } else {
370 if ((bp = bridge_port_find(val->var.subs[sub],
371 bif)) == NULL ||
372 (bp = bridge_port_bif_next(bp)) == NULL)
373 return (SNMP_ERR_NOSUCHNAME);
374 }
375 val->var.len = sub + 1;
376 val->var.subs[sub] = bp->port_no;
364
365 case SNMP_OP_GETNEXT:
366 if (val->var.len - sub == 0) {
367 if ((bp = bridge_port_bif_first(bif)) == NULL)
368 return (SNMP_ERR_NOSUCHNAME);
369 } else {
370 if ((bp = bridge_port_find(val->var.subs[sub],
371 bif)) == NULL ||
372 (bp = bridge_port_bif_next(bp)) == NULL)
373 return (SNMP_ERR_NOSUCHNAME);
374 }
375 val->var.len = sub + 1;
376 val->var.subs[sub] = bp->port_no;
377 break;
377 goto get;
378
379 case SNMP_OP_SET:
380 return (SNMP_ERR_NOT_WRITEABLE);
381
382 case SNMP_OP_ROLLBACK:
383 case SNMP_OP_COMMIT:
378
379 case SNMP_OP_SET:
380 return (SNMP_ERR_NOT_WRITEABLE);
381
382 case SNMP_OP_ROLLBACK:
383 case SNMP_OP_COMMIT:
384 default:
385 abort();
384 break;
386 }
385 }
386 abort();
387
387
388get:
388 switch (val->var.subs[sub - 1]) {
389 case LEAF_dot1dBasePort:
390 val->v.integer = bp->port_no;
389 switch (val->var.subs[sub - 1]) {
390 case LEAF_dot1dBasePort:
391 val->v.integer = bp->port_no;
391 break;
392 return (SNMP_ERR_NOERROR);
393
392 case LEAF_dot1dBasePortIfIndex:
393 val->v.integer = bp->if_idx;
394 case LEAF_dot1dBasePortIfIndex:
395 val->v.integer = bp->if_idx;
394 break;
396 return (SNMP_ERR_NOERROR);
397
395 case LEAF_dot1dBasePortCircuit:
396 val->v.oid = bp->circuit;
398 case LEAF_dot1dBasePortCircuit:
399 val->v.oid = bp->circuit;
397 break;
400 return (SNMP_ERR_NOERROR);
401
398 case LEAF_dot1dBasePortDelayExceededDiscards:
399 val->v.uint32 = bp->dly_ex_drops;
402 case LEAF_dot1dBasePortDelayExceededDiscards:
403 val->v.uint32 = bp->dly_ex_drops;
400 break;
404 return (SNMP_ERR_NOERROR);
405
401 case LEAF_dot1dBasePortMtuExceededDiscards:
402 val->v.uint32 = bp->dly_mtu_drops;
406 case LEAF_dot1dBasePortMtuExceededDiscards:
407 val->v.uint32 = bp->dly_mtu_drops;
403 break;
408 return (SNMP_ERR_NOERROR);
404 }
405
409 }
410
406 return (SNMP_ERR_NOERROR);
411 abort();
407}
408
409int
410op_dot1d_stp_port(struct snmp_context *ctx, struct snmp_value *val,
411 uint sub, uint iidx __unused, enum snmp_op op)
412{
412}
413
414int
415op_dot1d_stp_port(struct snmp_context *ctx, struct snmp_value *val,
416 uint sub, uint iidx __unused, enum snmp_op op)
417{
413 int ret;
414 struct bridge_if *bif;
415 struct bridge_port *bp;
416
417 if ((bif = bridge_get_default()) == NULL)
418 return (SNMP_ERR_NOSUCHNAME);
419
420 if (time(NULL) - bif->ports_age > bridge_get_data_maxage() &&
421 bridge_update_memif(bif) <= 0)
422 return (SNMP_ERR_NOSUCHNAME);
423
424 switch (op) {
425 case SNMP_OP_GET:
426 if (val->var.len - sub != 1)
427 return (SNMP_ERR_NOSUCHNAME);
428 if ((bp = bridge_port_find(val->var.subs[sub],
429 bif)) == NULL)
430 return (SNMP_ERR_NOSUCHNAME);
418 struct bridge_if *bif;
419 struct bridge_port *bp;
420
421 if ((bif = bridge_get_default()) == NULL)
422 return (SNMP_ERR_NOSUCHNAME);
423
424 if (time(NULL) - bif->ports_age > bridge_get_data_maxage() &&
425 bridge_update_memif(bif) <= 0)
426 return (SNMP_ERR_NOSUCHNAME);
427
428 switch (op) {
429 case SNMP_OP_GET:
430 if (val->var.len - sub != 1)
431 return (SNMP_ERR_NOSUCHNAME);
432 if ((bp = bridge_port_find(val->var.subs[sub],
433 bif)) == NULL)
434 return (SNMP_ERR_NOSUCHNAME);
431 break;
435 goto get;
432
433 case SNMP_OP_GETNEXT:
434 if (val->var.len - sub == 0) {
435 if ((bp = bridge_port_bif_first(bif)) == NULL)
436 return (SNMP_ERR_NOSUCHNAME);
437 } else {
438 if ((bp = bridge_port_find(val->var.subs[sub],
439 bif)) == NULL ||
440 (bp = bridge_port_bif_next(bp)) == NULL)
441 return (SNMP_ERR_NOSUCHNAME);
442 }
443 val->var.len = sub + 1;
444 val->var.subs[sub] = bp->port_no;
436
437 case SNMP_OP_GETNEXT:
438 if (val->var.len - sub == 0) {
439 if ((bp = bridge_port_bif_first(bif)) == NULL)
440 return (SNMP_ERR_NOSUCHNAME);
441 } else {
442 if ((bp = bridge_port_find(val->var.subs[sub],
443 bif)) == NULL ||
444 (bp = bridge_port_bif_next(bp)) == NULL)
445 return (SNMP_ERR_NOSUCHNAME);
446 }
447 val->var.len = sub + 1;
448 val->var.subs[sub] = bp->port_no;
445 break;
449 goto get;
446
447 case SNMP_OP_SET:
448 if (val->var.len - sub != 1)
449 return (SNMP_ERR_NOSUCHNAME);
450 if ((bp = bridge_port_find(val->var.subs[sub],
451 bif)) == NULL)
452 return (SNMP_ERR_NOSUCHNAME);
453
454 switch (val->var.subs[sub - 1]) {
455 case LEAF_dot1dStpPortPriority:
450
451 case SNMP_OP_SET:
452 if (val->var.len - sub != 1)
453 return (SNMP_ERR_NOSUCHNAME);
454 if ((bp = bridge_port_find(val->var.subs[sub],
455 bif)) == NULL)
456 return (SNMP_ERR_NOSUCHNAME);
457
458 switch (val->var.subs[sub - 1]) {
459 case LEAF_dot1dStpPortPriority:
460 if (val->v.integer < 0 || val->v.integer > 255)
461 return (SNMP_ERR_WRONG_VALUE);
462
456 ctx->scratch->int1 = bp->priority;
463 ctx->scratch->int1 = bp->priority;
457 ret = bridge_port_set_priority(bif->bif_name, bp,
458 val->v.integer);
459 break;
464 if (bridge_port_set_priority(bif->bif_name, bp,
465 val->v.integer) < 0)
466 return (SNMP_ERR_GENERR);
467 return (SNMP_ERR_NOERROR);
468
460 case LEAF_dot1dStpPortEnable:
469 case LEAF_dot1dStpPortEnable:
470 if (val->v.integer != dot1dStpPortEnable_enabled &&
471 val->v.integer != dot1dStpPortEnable_disabled)
472 return (SNMP_ERR_WRONG_VALUE);
473
461 ctx->scratch->int1 = bp->enable;
474 ctx->scratch->int1 = bp->enable;
462 ret = bridge_port_set_stp_enable(bif->bif_name,
463 bp, val->v.integer);
464 break;
475 if (bridge_port_set_stp_enable(bif->bif_name,
476 bp, val->v.integer) < 0)
477 return (SNMP_ERR_GENERR);
478 return (SNMP_ERR_NOERROR);
479
465 case LEAF_dot1dStpPortPathCost:
480 case LEAF_dot1dStpPortPathCost:
481 if (val->v.integer < SNMP_PORT_MIN_PATHCOST ||
482 val->v.integer > SNMP_PORT_MAX_PATHCOST)
483 return (SNMP_ERR_WRONG_VALUE);
484
466 ctx->scratch->int1 = bp->path_cost;
485 ctx->scratch->int1 = bp->path_cost;
467 ret = bridge_port_set_path_cost(bif->bif_name, bp,
468 val->v.integer);
469 break;
486 if (bridge_port_set_path_cost(bif->bif_name, bp,
487 val->v.integer) < 0)
488 return (SNMP_ERR_GENERR);
489 return (SNMP_ERR_NOERROR);
490
470 case LEAF_dot1dStpPort:
471 case LEAF_dot1dStpPortState:
472 case LEAF_dot1dStpPortDesignatedRoot:
473 case LEAF_dot1dStpPortDesignatedCost:
474 case LEAF_dot1dStpPortDesignatedBridge:
475 case LEAF_dot1dStpPortDesignatedPort:
476 case LEAF_dot1dStpPortForwardTransitions:
477 return (SNMP_ERR_NOT_WRITEABLE);
491 case LEAF_dot1dStpPort:
492 case LEAF_dot1dStpPortState:
493 case LEAF_dot1dStpPortDesignatedRoot:
494 case LEAF_dot1dStpPortDesignatedCost:
495 case LEAF_dot1dStpPortDesignatedBridge:
496 case LEAF_dot1dStpPortDesignatedPort:
497 case LEAF_dot1dStpPortForwardTransitions:
498 return (SNMP_ERR_NOT_WRITEABLE);
478 default:
479 return (SNMP_ERR_NOSUCHNAME);
480 }
499 }
481 if (ret == 0)
482 return (SNMP_ERR_NOERROR);
483 else if (ret == -2)
484 return (SNMP_ERR_WRONG_VALUE);
485 return (SNMP_ERR_GENERR);
500 abort();
486
487 case SNMP_OP_ROLLBACK:
488 if ((bp = bridge_port_find(val->var.subs[sub],
489 bif)) == NULL)
490 return (SNMP_ERR_GENERR);
491 switch (val->var.subs[sub - 1]) {
492 case LEAF_dot1dStpPortPriority:
493 bridge_port_set_priority(bif->bif_name, bp,

--- 7 unchanged lines hidden (view full) ---

501 bridge_port_set_path_cost(bif->bif_name, bp,
502 ctx->scratch->int1);
503 break;
504 }
505 return (SNMP_ERR_NOERROR);
506
507 case SNMP_OP_COMMIT:
508 return (SNMP_ERR_NOERROR);
501
502 case SNMP_OP_ROLLBACK:
503 if ((bp = bridge_port_find(val->var.subs[sub],
504 bif)) == NULL)
505 return (SNMP_ERR_GENERR);
506 switch (val->var.subs[sub - 1]) {
507 case LEAF_dot1dStpPortPriority:
508 bridge_port_set_priority(bif->bif_name, bp,

--- 7 unchanged lines hidden (view full) ---

516 bridge_port_set_path_cost(bif->bif_name, bp,
517 ctx->scratch->int1);
518 break;
519 }
520 return (SNMP_ERR_NOERROR);
521
522 case SNMP_OP_COMMIT:
523 return (SNMP_ERR_NOERROR);
509
510 default:
511 abort();
512 }
524 }
525 abort();
513
526
514 ret = SNMP_ERR_NOERROR;
527get:
515 switch (val->var.subs[sub - 1]) {
516 case LEAF_dot1dStpPort:
517 val->v.integer = bp->port_no;
528 switch (val->var.subs[sub - 1]) {
529 case LEAF_dot1dStpPort:
530 val->v.integer = bp->port_no;
518 break;
531 return (SNMP_ERR_NOERROR);
532
519 case LEAF_dot1dStpPortPriority:
520 val->v.integer = bp->priority;
533 case LEAF_dot1dStpPortPriority:
534 val->v.integer = bp->priority;
521 break;
535 return (SNMP_ERR_NOERROR);
536
522 case LEAF_dot1dStpPortState:
523 val->v.integer = bp->state;
537 case LEAF_dot1dStpPortState:
538 val->v.integer = bp->state;
524 break;
539 return (SNMP_ERR_NOERROR);
540
525 case LEAF_dot1dStpPortEnable:
526 val->v.integer = bp->enable;
541 case LEAF_dot1dStpPortEnable:
542 val->v.integer = bp->enable;
527 break;
543 return (SNMP_ERR_NOERROR);
544
528 case LEAF_dot1dStpPortPathCost:
529 val->v.integer = bp->path_cost;
545 case LEAF_dot1dStpPortPathCost:
546 val->v.integer = bp->path_cost;
530 break;
547 return (SNMP_ERR_NOERROR);
548
531 case LEAF_dot1dStpPortDesignatedRoot:
549 case LEAF_dot1dStpPortDesignatedRoot:
532 ret = string_get(val, bp->design_root,
533 SNMP_BRIDGE_ID_LEN);
534 break;
550 return (string_get(val, bp->design_root,
551 SNMP_BRIDGE_ID_LEN));
552
535 case LEAF_dot1dStpPortDesignatedCost:
536 val->v.integer = bp->design_cost;
553 case LEAF_dot1dStpPortDesignatedCost:
554 val->v.integer = bp->design_cost;
537 break;
555 return (SNMP_ERR_NOERROR);
556
538 case LEAF_dot1dStpPortDesignatedBridge:
557 case LEAF_dot1dStpPortDesignatedBridge:
539 ret = string_get(val, bp->design_bridge,
540 SNMP_BRIDGE_ID_LEN);
541 break;
558 return (string_get(val, bp->design_bridge,
559 SNMP_BRIDGE_ID_LEN));
560
542 case LEAF_dot1dStpPortDesignatedPort:
561 case LEAF_dot1dStpPortDesignatedPort:
543 ret = string_get(val, bp->design_port, 2);
544 break;
562 return (string_get(val, bp->design_port, 2));
563
545 case LEAF_dot1dStpPortForwardTransitions:
546 val->v.uint32 = bp->fwd_trans;
564 case LEAF_dot1dStpPortForwardTransitions:
565 val->v.uint32 = bp->fwd_trans;
547 break;
566 return (SNMP_ERR_NOERROR);
548 }
549
567 }
568
550 return (ret);
569 abort();
551}
552
553int
554op_dot1d_stp_ext_port(struct snmp_context *ctx, struct snmp_value *val,
555 uint sub, uint iidx __unused, enum snmp_op op)
556{
570}
571
572int
573op_dot1d_stp_ext_port(struct snmp_context *ctx, struct snmp_value *val,
574 uint sub, uint iidx __unused, enum snmp_op op)
575{
557 int ret;
558 struct bridge_if *bif;
559 struct bridge_port *bp;
560
561 if ((bif = bridge_get_default()) == NULL)
562 return (SNMP_ERR_NOSUCHNAME);
563
564 if (time(NULL) - bif->ports_age > bridge_get_data_maxage() &&
565 bridge_update_memif(bif) <= 0)
566 return (SNMP_ERR_NOSUCHNAME);
567
568 switch (op) {
569 case SNMP_OP_GET:
570 if (val->var.len - sub != 1)
571 return (SNMP_ERR_NOSUCHNAME);
572 if ((bp = bridge_port_find(val->var.subs[sub],
573 bif)) == NULL)
574 return (SNMP_ERR_NOSUCHNAME);
576 struct bridge_if *bif;
577 struct bridge_port *bp;
578
579 if ((bif = bridge_get_default()) == NULL)
580 return (SNMP_ERR_NOSUCHNAME);
581
582 if (time(NULL) - bif->ports_age > bridge_get_data_maxage() &&
583 bridge_update_memif(bif) <= 0)
584 return (SNMP_ERR_NOSUCHNAME);
585
586 switch (op) {
587 case SNMP_OP_GET:
588 if (val->var.len - sub != 1)
589 return (SNMP_ERR_NOSUCHNAME);
590 if ((bp = bridge_port_find(val->var.subs[sub],
591 bif)) == NULL)
592 return (SNMP_ERR_NOSUCHNAME);
575 break;
593 goto get;
576
577 case SNMP_OP_GETNEXT:
578 if (val->var.len - sub == 0) {
579 if ((bp = bridge_port_bif_first(bif)) == NULL)
580 return (SNMP_ERR_NOSUCHNAME);
581 } else {
582 if ((bp = bridge_port_find(val->var.subs[sub],
583 bif)) == NULL ||
584 (bp = bridge_port_bif_next(bp)) == NULL)
585 return (SNMP_ERR_NOSUCHNAME);
586 }
587 val->var.len = sub + 1;
588 val->var.subs[sub] = bp->port_no;
594
595 case SNMP_OP_GETNEXT:
596 if (val->var.len - sub == 0) {
597 if ((bp = bridge_port_bif_first(bif)) == NULL)
598 return (SNMP_ERR_NOSUCHNAME);
599 } else {
600 if ((bp = bridge_port_find(val->var.subs[sub],
601 bif)) == NULL ||
602 (bp = bridge_port_bif_next(bp)) == NULL)
603 return (SNMP_ERR_NOSUCHNAME);
604 }
605 val->var.len = sub + 1;
606 val->var.subs[sub] = bp->port_no;
589 break;
607 goto get;
590
591 case SNMP_OP_SET:
592 if (val->var.len - sub != 1)
593 return (SNMP_ERR_NOSUCHNAME);
594 if ((bp = bridge_port_find(val->var.subs[sub],
595 bif)) == NULL)
596 return (SNMP_ERR_NOSUCHNAME);
597
598 switch (val->var.subs[sub - 1]) {
599 case LEAF_dot1dStpPortAdminEdgePort:
608
609 case SNMP_OP_SET:
610 if (val->var.len - sub != 1)
611 return (SNMP_ERR_NOSUCHNAME);
612 if ((bp = bridge_port_find(val->var.subs[sub],
613 bif)) == NULL)
614 return (SNMP_ERR_NOSUCHNAME);
615
616 switch (val->var.subs[sub - 1]) {
617 case LEAF_dot1dStpPortAdminEdgePort:
618 if (val->v.integer != TruthValue_true &&
619 val->v.integer != TruthValue_false)
620 return (SNMP_ERR_WRONG_VALUE);
621
600 ctx->scratch->int1 = bp->admin_edge;
622 ctx->scratch->int1 = bp->admin_edge;
601 ret = bridge_port_set_admin_edge(bif->bif_name, bp,
602 val->v.integer);
603 break;
623 if (bridge_port_set_admin_edge(bif->bif_name, bp,
624 val->v.integer) < 0)
625 return (SNMP_ERR_GENERR);
626 return (SNMP_ERR_NOERROR);
627
604 case LEAF_dot1dStpPortAdminPointToPoint:
628 case LEAF_dot1dStpPortAdminPointToPoint:
629 if (val->v.integer < 0 || val->v.integer >
630 StpPortAdminPointToPointType_auto)
631 return (SNMP_ERR_WRONG_VALUE);
632
605 ctx->scratch->int1 = bp->admin_p2p;
633 ctx->scratch->int1 = bp->admin_p2p;
606 ret = bridge_port_set_admin_p2p(bif->bif_name, bp,
607 val->v.integer);
608 break;
634 if (bridge_port_set_admin_p2p(bif->bif_name, bp,
635 val->v.integer) < 0)
636 return (SNMP_ERR_GENERR);
637 return (SNMP_ERR_NOERROR);
638
609 case LEAF_dot1dStpPortAdminPathCost:
639 case LEAF_dot1dStpPortAdminPathCost:
640 if (val->v.integer < SNMP_PORT_MIN_PATHCOST ||
641 val->v.integer > SNMP_PORT_MAX_PATHCOST)
642 return (SNMP_ERR_WRONG_VALUE);
643
610 ctx->scratch->int1 = bp->admin_path_cost;
644 ctx->scratch->int1 = bp->admin_path_cost;
611 ret = bridge_port_set_path_cost(bif->bif_name, bp,
612 val->v.integer);
613 break;
645 if (bridge_port_set_path_cost(bif->bif_name, bp,
646 val->v.integer) < 0)
647 return (SNMP_ERR_GENERR);
648 return (SNMP_ERR_NOERROR);
649
614 case LEAF_dot1dStpPortProtocolMigration:
615 case LEAF_dot1dStpPortOperEdgePort:
616 case LEAF_dot1dStpPortOperPointToPoint:
617 return (SNMP_ERR_NOT_WRITEABLE);
650 case LEAF_dot1dStpPortProtocolMigration:
651 case LEAF_dot1dStpPortOperEdgePort:
652 case LEAF_dot1dStpPortOperPointToPoint:
653 return (SNMP_ERR_NOT_WRITEABLE);
618 default:
619 return (SNMP_ERR_NOSUCHNAME);
620 }
654 }
655 abort();
621
656
622 if (ret == 0)
623 return (SNMP_ERR_NOERROR);
624 else if (ret == -2)
625 return (SNMP_ERR_WRONG_VALUE);
626 return (SNMP_ERR_GENERR);
627
628 case SNMP_OP_ROLLBACK:
629 if ((bp = bridge_port_find(val->var.subs[sub],
630 bif)) == NULL)
631 return (SNMP_ERR_GENERR);
632
633 switch (val->var.subs[sub - 1]) {
634 case LEAF_dot1dStpPortAdminEdgePort:
635 bridge_port_set_admin_edge(bif->bif_name, bp,

--- 7 unchanged lines hidden (view full) ---

643 bridge_port_set_path_cost(bif->bif_name, bp,
644 ctx->scratch->int1);
645 break;
646 }
647 return (SNMP_ERR_NOERROR);
648
649 case SNMP_OP_COMMIT:
650 return (SNMP_ERR_NOERROR);
657 case SNMP_OP_ROLLBACK:
658 if ((bp = bridge_port_find(val->var.subs[sub],
659 bif)) == NULL)
660 return (SNMP_ERR_GENERR);
661
662 switch (val->var.subs[sub - 1]) {
663 case LEAF_dot1dStpPortAdminEdgePort:
664 bridge_port_set_admin_edge(bif->bif_name, bp,

--- 7 unchanged lines hidden (view full) ---

672 bridge_port_set_path_cost(bif->bif_name, bp,
673 ctx->scratch->int1);
674 break;
675 }
676 return (SNMP_ERR_NOERROR);
677
678 case SNMP_OP_COMMIT:
679 return (SNMP_ERR_NOERROR);
651
652 default:
653 abort();
654 }
680 }
681 abort();
655
682
683get:
656 switch (val->var.subs[sub - 1]) {
657 case LEAF_dot1dStpPortProtocolMigration:
658 val->v.integer = bp->proto_migr;
684 switch (val->var.subs[sub - 1]) {
685 case LEAF_dot1dStpPortProtocolMigration:
686 val->v.integer = bp->proto_migr;
659 break;
687 return (SNMP_ERR_NOERROR);
688
660 case LEAF_dot1dStpPortAdminEdgePort:
661 val->v.integer = bp->admin_edge;
689 case LEAF_dot1dStpPortAdminEdgePort:
690 val->v.integer = bp->admin_edge;
662 break;
691 return (SNMP_ERR_NOERROR);
692
663 case LEAF_dot1dStpPortOperEdgePort:
664 val->v.integer = bp->oper_edge;
693 case LEAF_dot1dStpPortOperEdgePort:
694 val->v.integer = bp->oper_edge;
665 break;
695 return (SNMP_ERR_NOERROR);
696
666 case LEAF_dot1dStpPortAdminPointToPoint:
667 val->v.integer = bp->admin_p2p;
697 case LEAF_dot1dStpPortAdminPointToPoint:
698 val->v.integer = bp->admin_p2p;
668 break;
699 return (SNMP_ERR_NOERROR);
700
669 case LEAF_dot1dStpPortOperPointToPoint:
670 val->v.integer = bp->oper_p2p;
701 case LEAF_dot1dStpPortOperPointToPoint:
702 val->v.integer = bp->oper_p2p;
671 break;
703 return (SNMP_ERR_NOERROR);
704
672 case LEAF_dot1dStpPortAdminPathCost:
673 val->v.integer = bp->admin_path_cost;
705 case LEAF_dot1dStpPortAdminPathCost:
706 val->v.integer = bp->admin_path_cost;
674 break;
707 return (SNMP_ERR_NOERROR);
675 }
676
708 }
709
677 return (SNMP_ERR_NOERROR);
710 abort();
678}
679
680int
681op_dot1d_tp_port(struct snmp_context *c __unused, struct snmp_value *val,
682 uint sub, uint iidx __unused, enum snmp_op op)
683{
684 struct bridge_if *bif;
685 struct bridge_port *bp;

--- 7 unchanged lines hidden (view full) ---

693
694 switch (op) {
695 case SNMP_OP_GET:
696 if (val->var.len - sub != 1)
697 return (SNMP_ERR_NOSUCHNAME);
698 if ((bp = bridge_port_find(val->var.subs[sub],
699 bif)) == NULL)
700 return (SNMP_ERR_NOSUCHNAME);
711}
712
713int
714op_dot1d_tp_port(struct snmp_context *c __unused, struct snmp_value *val,
715 uint sub, uint iidx __unused, enum snmp_op op)
716{
717 struct bridge_if *bif;
718 struct bridge_port *bp;

--- 7 unchanged lines hidden (view full) ---

726
727 switch (op) {
728 case SNMP_OP_GET:
729 if (val->var.len - sub != 1)
730 return (SNMP_ERR_NOSUCHNAME);
731 if ((bp = bridge_port_find(val->var.subs[sub],
732 bif)) == NULL)
733 return (SNMP_ERR_NOSUCHNAME);
701 break;
734 goto get;
702
703 case SNMP_OP_GETNEXT:
704 if (val->var.len - sub == 0) {
705 if ((bp = bridge_port_bif_first(bif)) == NULL)
706 return (SNMP_ERR_NOSUCHNAME);
707 } else {
708 if ((bp = bridge_port_find(val->var.subs[sub],
709 bif)) == NULL ||
710 (bp = bridge_port_bif_next(bp)) == NULL)
711 return (SNMP_ERR_NOSUCHNAME);
712 }
713 val->var.len = sub + 1;
714 val->var.subs[sub] = bp->port_no;
735
736 case SNMP_OP_GETNEXT:
737 if (val->var.len - sub == 0) {
738 if ((bp = bridge_port_bif_first(bif)) == NULL)
739 return (SNMP_ERR_NOSUCHNAME);
740 } else {
741 if ((bp = bridge_port_find(val->var.subs[sub],
742 bif)) == NULL ||
743 (bp = bridge_port_bif_next(bp)) == NULL)
744 return (SNMP_ERR_NOSUCHNAME);
745 }
746 val->var.len = sub + 1;
747 val->var.subs[sub] = bp->port_no;
715 break;
748 goto get;
716
717 case SNMP_OP_SET:
718 return (SNMP_ERR_NOT_WRITEABLE);
719
720 case SNMP_OP_ROLLBACK:
721 case SNMP_OP_COMMIT:
749
750 case SNMP_OP_SET:
751 return (SNMP_ERR_NOT_WRITEABLE);
752
753 case SNMP_OP_ROLLBACK:
754 case SNMP_OP_COMMIT:
722 default:
723 abort();
755 break;
724 }
756 }
757 abort();
725
758
759get:
726 switch (val->var.subs[sub - 1]) {
727 case LEAF_dot1dTpPort:
728 val->v.integer = bp->port_no;
760 switch (val->var.subs[sub - 1]) {
761 case LEAF_dot1dTpPort:
762 val->v.integer = bp->port_no;
729 break;
763 return (SNMP_ERR_NOERROR);
764
730 case LEAF_dot1dTpPortMaxInfo:
731 val->v.integer = bp->max_info;
765 case LEAF_dot1dTpPortMaxInfo:
766 val->v.integer = bp->max_info;
732 break;
767 return (SNMP_ERR_NOERROR);
768
733 case LEAF_dot1dTpPortInFrames:
734 val->v.uint32 = bp->in_frames;
769 case LEAF_dot1dTpPortInFrames:
770 val->v.uint32 = bp->in_frames;
735 break;
771 return (SNMP_ERR_NOERROR);
772
736 case LEAF_dot1dTpPortOutFrames:
737 val->v.uint32 = bp->out_frames;
773 case LEAF_dot1dTpPortOutFrames:
774 val->v.uint32 = bp->out_frames;
738 break;
775 return (SNMP_ERR_NOERROR);
776
739 case LEAF_dot1dTpPortInDiscards:
740 val->v.uint32 = bp->in_drops;
777 case LEAF_dot1dTpPortInDiscards:
778 val->v.uint32 = bp->in_drops;
741 break;
779 return (SNMP_ERR_NOERROR);
742 }
743
780 }
781
744 return (SNMP_ERR_NOERROR);
782 abort();
745}
746
747/*
748 * Private BEGEMOT-BRIDGE-MIB specifics.
749 */
750
751/*
752 * Construct a bridge port entry index.

--- 278 unchanged lines hidden (view full) ---

1031 return (SNMP_ERR_NOERROR);
1032}
1033
1034int
1035op_begemot_base_port(struct snmp_context *ctx, struct snmp_value *val,
1036 uint sub, uint iidx __unused, enum snmp_op op)
1037{
1038 int8_t status, which;
783}
784
785/*
786 * Private BEGEMOT-BRIDGE-MIB specifics.
787 */
788
789/*
790 * Construct a bridge port entry index.

--- 278 unchanged lines hidden (view full) ---

1069 return (SNMP_ERR_NOERROR);
1070}
1071
1072int
1073op_begemot_base_port(struct snmp_context *ctx, struct snmp_value *val,
1074 uint sub, uint iidx __unused, enum snmp_op op)
1075{
1076 int8_t status, which;
1039 struct bridge_port *bp = NULL;
1077 struct bridge_port *bp;
1040
1041 if (time(NULL) - ports_list_age > bridge_get_data_maxage())
1042 bridge_update_all_ports();
1043
1044 which = val->var.subs[sub - 1];
1045 status = 0;
1046
1047 switch (op) {
1048 case SNMP_OP_GET:
1049 if (which == LEAF_begemotBridgeBaseSpanEnabled ||
1050 which == LEAF_begemotBridgeBasePortStatus)
1051 status = 1;
1052 if ((bp = bridge_port_index_get(&val->var, sub,
1053 status)) == NULL)
1054 return (SNMP_ERR_NOSUCHNAME);
1078
1079 if (time(NULL) - ports_list_age > bridge_get_data_maxage())
1080 bridge_update_all_ports();
1081
1082 which = val->var.subs[sub - 1];
1083 status = 0;
1084
1085 switch (op) {
1086 case SNMP_OP_GET:
1087 if (which == LEAF_begemotBridgeBaseSpanEnabled ||
1088 which == LEAF_begemotBridgeBasePortStatus)
1089 status = 1;
1090 if ((bp = bridge_port_index_get(&val->var, sub,
1091 status)) == NULL)
1092 return (SNMP_ERR_NOSUCHNAME);
1055 break;
1093 goto get;
1056
1057 case SNMP_OP_GETNEXT:
1058 if (which == LEAF_begemotBridgeBaseSpanEnabled ||
1059 which == LEAF_begemotBridgeBasePortStatus)
1060 status = 1;
1061 if ((bp = bridge_port_index_getnext(&val->var, sub,
1062 status)) == NULL ||
1063 bridge_port_index_append(&val->var, sub, bp) < 0)
1064 return (SNMP_ERR_NOSUCHNAME);
1094
1095 case SNMP_OP_GETNEXT:
1096 if (which == LEAF_begemotBridgeBaseSpanEnabled ||
1097 which == LEAF_begemotBridgeBasePortStatus)
1098 status = 1;
1099 if ((bp = bridge_port_index_getnext(&val->var, sub,
1100 status)) == NULL ||
1101 bridge_port_index_append(&val->var, sub, bp) < 0)
1102 return (SNMP_ERR_NOSUCHNAME);
1065 break;
1103 goto get;
1066
1067 case SNMP_OP_SET:
1068 switch (which) {
1069 case LEAF_begemotBridgeBaseSpanEnabled:
1070 return (bridge_port_set_span_enable(ctx, val, sub));
1071
1072 case LEAF_begemotBridgeBasePortStatus:
1073 return (bridge_port_set_status(ctx, val, sub));

--- 16 unchanged lines hidden (view full) ---

1090 return (SNMP_ERR_NOERROR);
1091
1092 case SNMP_OP_COMMIT:
1093 if (which == LEAF_begemotBridgeBasePortStatus)
1094 return (bridge_port_commit_status(val, sub));
1095
1096 return (SNMP_ERR_NOERROR);
1097 }
1104
1105 case SNMP_OP_SET:
1106 switch (which) {
1107 case LEAF_begemotBridgeBaseSpanEnabled:
1108 return (bridge_port_set_span_enable(ctx, val, sub));
1109
1110 case LEAF_begemotBridgeBasePortStatus:
1111 return (bridge_port_set_status(ctx, val, sub));

--- 16 unchanged lines hidden (view full) ---

1128 return (SNMP_ERR_NOERROR);
1129
1130 case SNMP_OP_COMMIT:
1131 if (which == LEAF_begemotBridgeBasePortStatus)
1132 return (bridge_port_commit_status(val, sub));
1133
1134 return (SNMP_ERR_NOERROR);
1135 }
1136 abort();
1098
1137
1138get:
1099 switch (which) {
1100 case LEAF_begemotBridgeBasePort:
1101 val->v.integer = bp->port_no;
1139 switch (which) {
1140 case LEAF_begemotBridgeBasePort:
1141 val->v.integer = bp->port_no;
1102 break;
1142 return (SNMP_ERR_NOERROR);
1143
1103 case LEAF_begemotBridgeBasePortIfIndex:
1104 val->v.integer = bp->if_idx;
1144 case LEAF_begemotBridgeBasePortIfIndex:
1145 val->v.integer = bp->if_idx;
1105 break;
1146 return (SNMP_ERR_NOERROR);
1147
1106 case LEAF_begemotBridgeBaseSpanEnabled:
1107 val->v.integer = bp->span_enable;
1148 case LEAF_begemotBridgeBaseSpanEnabled:
1149 val->v.integer = bp->span_enable;
1108 break;
1150 return (SNMP_ERR_NOERROR);
1151
1109 case LEAF_begemotBridgeBasePortDelayExceededDiscards:
1110 val->v.uint32 = bp->dly_ex_drops;
1152 case LEAF_begemotBridgeBasePortDelayExceededDiscards:
1153 val->v.uint32 = bp->dly_ex_drops;
1111 break;
1154 return (SNMP_ERR_NOERROR);
1155
1112 case LEAF_begemotBridgeBasePortMtuExceededDiscards:
1113 val->v.uint32 = bp->dly_mtu_drops;
1156 case LEAF_begemotBridgeBasePortMtuExceededDiscards:
1157 val->v.uint32 = bp->dly_mtu_drops;
1114 break;
1158 return (SNMP_ERR_NOERROR);
1159
1115 case LEAF_begemotBridgeBasePortStatus:
1116 val->v.integer = bp->status;
1160 case LEAF_begemotBridgeBasePortStatus:
1161 val->v.integer = bp->status;
1117 break;
1162 return (SNMP_ERR_NOERROR);
1118 }
1119
1163 }
1164
1120 return (SNMP_ERR_NOERROR);
1165 abort();
1121}
1122
1123int
1124op_begemot_stp_port(struct snmp_context *ctx, struct snmp_value *val,
1125 uint sub, uint iidx __unused, enum snmp_op op)
1126{
1166}
1167
1168int
1169op_begemot_stp_port(struct snmp_context *ctx, struct snmp_value *val,
1170 uint sub, uint iidx __unused, enum snmp_op op)
1171{
1127 int ret;
1128 struct bridge_port *bp;
1129 const char *b_name;
1130
1131 if (time(NULL) - ports_list_age > bridge_get_data_maxage())
1132 bridge_update_all_ports();
1133
1134 switch (op) {
1135 case SNMP_OP_GET:
1136 if ((bp = bridge_port_index_get(&val->var, sub, 0)) == NULL)
1137 return (SNMP_ERR_NOSUCHNAME);
1172 struct bridge_port *bp;
1173 const char *b_name;
1174
1175 if (time(NULL) - ports_list_age > bridge_get_data_maxage())
1176 bridge_update_all_ports();
1177
1178 switch (op) {
1179 case SNMP_OP_GET:
1180 if ((bp = bridge_port_index_get(&val->var, sub, 0)) == NULL)
1181 return (SNMP_ERR_NOSUCHNAME);
1138 break;
1182 goto get;
1139
1140 case SNMP_OP_GETNEXT:
1141 if ((bp = bridge_port_index_getnext(&val->var, sub, 0)) ==
1142 NULL || bridge_port_index_append(&val->var, sub, bp) < 0)
1143 return (SNMP_ERR_NOSUCHNAME);
1183
1184 case SNMP_OP_GETNEXT:
1185 if ((bp = bridge_port_index_getnext(&val->var, sub, 0)) ==
1186 NULL || bridge_port_index_append(&val->var, sub, bp) < 0)
1187 return (SNMP_ERR_NOSUCHNAME);
1144 break;
1188 goto get;
1145
1146 case SNMP_OP_SET:
1147 if ((bp = bridge_port_index_get(&val->var, sub, 0)) == NULL)
1148 return (SNMP_ERR_NOSUCHNAME);
1149 if ((b_name = bridge_if_find_name(bp->sysindex)) == NULL)
1150 return (SNMP_ERR_GENERR);
1151
1189
1190 case SNMP_OP_SET:
1191 if ((bp = bridge_port_index_get(&val->var, sub, 0)) == NULL)
1192 return (SNMP_ERR_NOSUCHNAME);
1193 if ((b_name = bridge_if_find_name(bp->sysindex)) == NULL)
1194 return (SNMP_ERR_GENERR);
1195
1152 ret = SNMP_ERR_NOERROR;
1153 switch (val->var.subs[sub - 1]) {
1154 case LEAF_begemotBridgeStpPortPriority:
1196 switch (val->var.subs[sub - 1]) {
1197 case LEAF_begemotBridgeStpPortPriority:
1198 if (val->v.integer < 0 || val->v.integer > 255)
1199 return (SNMP_ERR_WRONG_VALUE);
1200
1155 ctx->scratch->int1 = bp->priority;
1201 ctx->scratch->int1 = bp->priority;
1156 ret = bridge_port_set_priority(b_name, bp,
1157 val->v.integer);
1158 break;
1202 if (bridge_port_set_priority(b_name, bp,
1203 val->v.integer) < 0)
1204 return (SNMP_ERR_GENERR);
1205 return (SNMP_ERR_NOERROR);
1206
1159 case LEAF_begemotBridgeStpPortEnable:
1207 case LEAF_begemotBridgeStpPortEnable:
1208 if (val->v.integer !=
1209 begemotBridgeStpPortEnable_enabled ||
1210 val->v.integer !=
1211 begemotBridgeStpPortEnable_disabled)
1212 return (SNMP_ERR_WRONG_VALUE);
1213
1160 ctx->scratch->int1 = bp->enable;
1214 ctx->scratch->int1 = bp->enable;
1161 ret = bridge_port_set_stp_enable(b_name, bp,
1162 val->v.integer);
1163 break;
1215 if (bridge_port_set_stp_enable(b_name, bp,
1216 val->v.integer) < 0)
1217 return (SNMP_ERR_GENERR);
1218 return (SNMP_ERR_NOERROR);
1219
1164 case LEAF_begemotBridgeStpPortPathCost:
1220 case LEAF_begemotBridgeStpPortPathCost:
1221 if (val->v.integer < SNMP_PORT_MIN_PATHCOST ||
1222 val->v.integer > SNMP_PORT_MAX_PATHCOST)
1223 return (SNMP_ERR_WRONG_VALUE);
1224
1165 ctx->scratch->int1 = bp->path_cost;
1225 ctx->scratch->int1 = bp->path_cost;
1166 ret = bridge_port_set_path_cost(b_name, bp,
1167 val->v.integer);
1168 break;
1226 if (bridge_port_set_path_cost(b_name, bp,
1227 val->v.integer) < 0)
1228 return (SNMP_ERR_GENERR);
1229 return (SNMP_ERR_NOERROR);
1230
1169 case LEAF_begemotBridgeStpPort:
1170 case LEAF_begemotBridgeStpPortState:
1171 case LEAF_begemotBridgeStpPortDesignatedRoot:
1172 case LEAF_begemotBridgeStpPortDesignatedCost:
1173 case LEAF_begemotBridgeStpPortDesignatedBridge:
1174 case LEAF_begemotBridgeStpPortDesignatedPort:
1175 case LEAF_begemotBridgeStpPortForwardTransitions:
1176 return (SNMP_ERR_NOT_WRITEABLE);
1177 }
1231 case LEAF_begemotBridgeStpPort:
1232 case LEAF_begemotBridgeStpPortState:
1233 case LEAF_begemotBridgeStpPortDesignatedRoot:
1234 case LEAF_begemotBridgeStpPortDesignatedCost:
1235 case LEAF_begemotBridgeStpPortDesignatedBridge:
1236 case LEAF_begemotBridgeStpPortDesignatedPort:
1237 case LEAF_begemotBridgeStpPortForwardTransitions:
1238 return (SNMP_ERR_NOT_WRITEABLE);
1239 }
1178 if (ret == 0)
1179 return (SNMP_ERR_NOERROR);
1180 else if (ret == -2)
1181 return (SNMP_ERR_WRONG_VALUE);
1182 return (SNMP_ERR_GENERR);
1240 abort();
1183
1184 case SNMP_OP_ROLLBACK:
1185 if ((bp = bridge_port_index_get(&val->var, sub, 0)) == NULL ||
1186 (b_name = bridge_if_find_name(bp->sysindex)) == NULL)
1187 return (SNMP_ERR_GENERR);
1188
1189 switch (val->var.subs[sub - 1]) {
1190 case LEAF_begemotBridgeStpPortPriority:

--- 8 unchanged lines hidden (view full) ---

1199 bridge_port_set_path_cost(b_name, bp,
1200 ctx->scratch->int1);
1201 break;
1202 }
1203 return (SNMP_ERR_NOERROR);
1204
1205 case SNMP_OP_COMMIT:
1206 return (SNMP_ERR_NOERROR);
1241
1242 case SNMP_OP_ROLLBACK:
1243 if ((bp = bridge_port_index_get(&val->var, sub, 0)) == NULL ||
1244 (b_name = bridge_if_find_name(bp->sysindex)) == NULL)
1245 return (SNMP_ERR_GENERR);
1246
1247 switch (val->var.subs[sub - 1]) {
1248 case LEAF_begemotBridgeStpPortPriority:

--- 8 unchanged lines hidden (view full) ---

1257 bridge_port_set_path_cost(b_name, bp,
1258 ctx->scratch->int1);
1259 break;
1260 }
1261 return (SNMP_ERR_NOERROR);
1262
1263 case SNMP_OP_COMMIT:
1264 return (SNMP_ERR_NOERROR);
1207
1208 default:
1209 abort();
1210 }
1265 }
1266 abort();
1211
1267
1212 ret = SNMP_ERR_NOERROR;
1268get:
1213 switch (val->var.subs[sub - 1]) {
1214 case LEAF_begemotBridgeStpPort:
1215 val->v.integer = bp->port_no;
1269 switch (val->var.subs[sub - 1]) {
1270 case LEAF_begemotBridgeStpPort:
1271 val->v.integer = bp->port_no;
1216 break;
1272 return (SNMP_ERR_NOERROR);
1273
1217 case LEAF_begemotBridgeStpPortPriority:
1218 val->v.integer = bp->priority;
1274 case LEAF_begemotBridgeStpPortPriority:
1275 val->v.integer = bp->priority;
1219 break;
1276 return (SNMP_ERR_NOERROR);
1277
1220 case LEAF_begemotBridgeStpPortState:
1221 val->v.integer = bp->state;
1278 case LEAF_begemotBridgeStpPortState:
1279 val->v.integer = bp->state;
1222 break;
1280 return (SNMP_ERR_NOERROR);
1281
1223 case LEAF_begemotBridgeStpPortEnable:
1224 val->v.integer = bp->enable;
1282 case LEAF_begemotBridgeStpPortEnable:
1283 val->v.integer = bp->enable;
1225 break;
1284 return (SNMP_ERR_NOERROR);
1285
1226 case LEAF_begemotBridgeStpPortPathCost:
1227 val->v.integer = bp->path_cost;
1286 case LEAF_begemotBridgeStpPortPathCost:
1287 val->v.integer = bp->path_cost;
1228 break;
1288 return (SNMP_ERR_NOERROR);
1289
1229 case LEAF_begemotBridgeStpPortDesignatedRoot:
1290 case LEAF_begemotBridgeStpPortDesignatedRoot:
1230 ret = string_get(val, bp->design_root, SNMP_BRIDGE_ID_LEN);
1231 break;
1291 return (string_get(val, bp->design_root, SNMP_BRIDGE_ID_LEN));
1292
1232 case LEAF_begemotBridgeStpPortDesignatedCost:
1233 val->v.integer = bp->design_cost;
1293 case LEAF_begemotBridgeStpPortDesignatedCost:
1294 val->v.integer = bp->design_cost;
1234 break;
1295 return (SNMP_ERR_NOERROR);
1296
1235 case LEAF_begemotBridgeStpPortDesignatedBridge:
1297 case LEAF_begemotBridgeStpPortDesignatedBridge:
1236 ret = string_get(val, bp->design_bridge, SNMP_BRIDGE_ID_LEN);
1237 break;
1298 return (string_get(val, bp->design_bridge, SNMP_BRIDGE_ID_LEN));
1299
1238 case LEAF_begemotBridgeStpPortDesignatedPort:
1300 case LEAF_begemotBridgeStpPortDesignatedPort:
1239 ret = string_get(val, bp->design_port, 2);
1240 break;
1301 return (string_get(val, bp->design_port, 2));
1302
1241 case LEAF_begemotBridgeStpPortForwardTransitions:
1242 val->v.uint32 = bp->fwd_trans;
1303 case LEAF_begemotBridgeStpPortForwardTransitions:
1304 val->v.uint32 = bp->fwd_trans;
1243 break;
1305 return (SNMP_ERR_NOERROR);
1244 }
1245
1306 }
1307
1246 return (ret);
1308 abort();
1247}
1248
1249int
1250op_begemot_stp_ext_port(struct snmp_context *ctx, struct snmp_value *val,
1251 uint sub, uint iidx __unused, enum snmp_op op)
1252{
1309}
1310
1311int
1312op_begemot_stp_ext_port(struct snmp_context *ctx, struct snmp_value *val,
1313 uint sub, uint iidx __unused, enum snmp_op op)
1314{
1253 int ret;
1254 struct bridge_port *bp;
1255 const char *b_name;
1256
1257 if (time(NULL) - ports_list_age > bridge_get_data_maxage())
1258 bridge_update_all_ports();
1259
1260 switch (op) {
1261 case SNMP_OP_GET:
1262 if ((bp = bridge_port_index_get(&val->var, sub, 0)) == NULL)
1263 return (SNMP_ERR_NOSUCHNAME);
1315 struct bridge_port *bp;
1316 const char *b_name;
1317
1318 if (time(NULL) - ports_list_age > bridge_get_data_maxage())
1319 bridge_update_all_ports();
1320
1321 switch (op) {
1322 case SNMP_OP_GET:
1323 if ((bp = bridge_port_index_get(&val->var, sub, 0)) == NULL)
1324 return (SNMP_ERR_NOSUCHNAME);
1264 break;
1325 goto get;
1265
1266 case SNMP_OP_GETNEXT:
1267 if ((bp = bridge_port_index_getnext(&val->var, sub, 0)) ==
1268 NULL || bridge_port_index_append(&val->var, sub, bp) < 0)
1269 return (SNMP_ERR_NOSUCHNAME);
1326
1327 case SNMP_OP_GETNEXT:
1328 if ((bp = bridge_port_index_getnext(&val->var, sub, 0)) ==
1329 NULL || bridge_port_index_append(&val->var, sub, bp) < 0)
1330 return (SNMP_ERR_NOSUCHNAME);
1270 break;
1331 goto get;
1271
1272 case SNMP_OP_SET:
1273 if ((bp = bridge_port_index_get(&val->var, sub, 0)) == NULL)
1274 return (SNMP_ERR_NOSUCHNAME);
1275 if ((b_name = bridge_if_find_name(bp->sysindex)) == NULL)
1276 return (SNMP_ERR_GENERR);
1277
1278 switch (val->var.subs[sub - 1]) {
1279 case LEAF_begemotBridgeStpPortAdminEdgePort:
1332
1333 case SNMP_OP_SET:
1334 if ((bp = bridge_port_index_get(&val->var, sub, 0)) == NULL)
1335 return (SNMP_ERR_NOSUCHNAME);
1336 if ((b_name = bridge_if_find_name(bp->sysindex)) == NULL)
1337 return (SNMP_ERR_GENERR);
1338
1339 switch (val->var.subs[sub - 1]) {
1340 case LEAF_begemotBridgeStpPortAdminEdgePort:
1341 if (val->v.integer != TruthValue_true &&
1342 val->v.integer != TruthValue_false)
1343 return (SNMP_ERR_WRONG_VALUE);
1344
1280 ctx->scratch->int1 = bp->admin_edge;
1345 ctx->scratch->int1 = bp->admin_edge;
1281 ret = bridge_port_set_admin_edge(b_name, bp,
1282 val->v.integer);
1283 break;
1346 if (bridge_port_set_admin_edge(b_name, bp,
1347 val->v.integer) < 0)
1348 return (SNMP_ERR_GENERR);
1349 return (SNMP_ERR_NOERROR);
1350
1284 case LEAF_begemotBridgeStpPortAdminPointToPoint:
1351 case LEAF_begemotBridgeStpPortAdminPointToPoint:
1352 if (val->v.integer < 0 || val->v.integer >
1353 StpPortAdminPointToPointType_auto)
1354 return (SNMP_ERR_WRONG_VALUE);
1355
1285 ctx->scratch->int1 = bp->admin_p2p;
1356 ctx->scratch->int1 = bp->admin_p2p;
1286 ret = bridge_port_set_admin_p2p(b_name, bp,
1287 val->v.integer);
1288 break;
1357 if (bridge_port_set_admin_p2p(b_name, bp,
1358 val->v.integer) < 0)
1359 return (SNMP_ERR_GENERR);
1360 return (SNMP_ERR_NOERROR);
1361
1289 case LEAF_begemotBridgeStpPortAdminPathCost:
1362 case LEAF_begemotBridgeStpPortAdminPathCost:
1363 if (val->v.integer < SNMP_PORT_MIN_PATHCOST ||
1364 val->v.integer > SNMP_PORT_MAX_PATHCOST)
1365 return (SNMP_ERR_WRONG_VALUE);
1366
1290 ctx->scratch->int1 = bp->admin_path_cost;
1367 ctx->scratch->int1 = bp->admin_path_cost;
1291 ret = bridge_port_set_path_cost(b_name, bp,
1292 val->v.integer);
1293 break;
1368 if (bridge_port_set_path_cost(b_name, bp,
1369 val->v.integer) < 0)
1370 return (SNMP_ERR_GENERR);
1371 return (SNMP_ERR_NOERROR);
1372
1294 case LEAF_begemotBridgeStpPortProtocolMigration:
1295 case LEAF_begemotBridgeStpPortOperEdgePort:
1296 case LEAF_begemotBridgeStpPortOperPointToPoint:
1297 return (SNMP_ERR_NOT_WRITEABLE);
1373 case LEAF_begemotBridgeStpPortProtocolMigration:
1374 case LEAF_begemotBridgeStpPortOperEdgePort:
1375 case LEAF_begemotBridgeStpPortOperPointToPoint:
1376 return (SNMP_ERR_NOT_WRITEABLE);
1298 default:
1299 return (SNMP_ERR_NOSUCHNAME);
1300 }
1377 }
1378 abort();
1301
1379
1302 if (ret == 0)
1303 return (SNMP_ERR_NOERROR);
1304 else if (ret == -2)
1305 return (SNMP_ERR_WRONG_VALUE);
1306 return (SNMP_ERR_GENERR);
1307
1308 case SNMP_OP_ROLLBACK:
1309 if ((bp = bridge_port_index_get(&val->var, sub, 0)) == NULL ||
1310 (b_name = bridge_if_find_name(bp->sysindex)) == NULL)
1311 return (SNMP_ERR_GENERR);
1312
1313 switch (val->var.subs[sub - 1]) {
1314 case LEAF_begemotBridgeStpPortAdminEdgePort:
1315 bridge_port_set_admin_edge(b_name, bp,

--- 7 unchanged lines hidden (view full) ---

1323 bridge_port_set_path_cost(b_name, bp,
1324 ctx->scratch->int1);
1325 break;
1326 }
1327 return (SNMP_ERR_NOERROR);
1328
1329 case SNMP_OP_COMMIT:
1330 return (SNMP_ERR_NOERROR);
1380 case SNMP_OP_ROLLBACK:
1381 if ((bp = bridge_port_index_get(&val->var, sub, 0)) == NULL ||
1382 (b_name = bridge_if_find_name(bp->sysindex)) == NULL)
1383 return (SNMP_ERR_GENERR);
1384
1385 switch (val->var.subs[sub - 1]) {
1386 case LEAF_begemotBridgeStpPortAdminEdgePort:
1387 bridge_port_set_admin_edge(b_name, bp,

--- 7 unchanged lines hidden (view full) ---

1395 bridge_port_set_path_cost(b_name, bp,
1396 ctx->scratch->int1);
1397 break;
1398 }
1399 return (SNMP_ERR_NOERROR);
1400
1401 case SNMP_OP_COMMIT:
1402 return (SNMP_ERR_NOERROR);
1331
1332 default:
1333 abort();
1334 }
1403 }
1404 abort();
1335
1405
1406get:
1336 switch (val->var.subs[sub - 1]) {
1337 case LEAF_begemotBridgeStpPortProtocolMigration:
1338 val->v.integer = bp->proto_migr;
1407 switch (val->var.subs[sub - 1]) {
1408 case LEAF_begemotBridgeStpPortProtocolMigration:
1409 val->v.integer = bp->proto_migr;
1339 break;
1410 return (SNMP_ERR_NOERROR);
1411
1340 case LEAF_begemotBridgeStpPortAdminEdgePort:
1341 val->v.integer = bp->admin_edge;
1412 case LEAF_begemotBridgeStpPortAdminEdgePort:
1413 val->v.integer = bp->admin_edge;
1342 break;
1414 return (SNMP_ERR_NOERROR);
1415
1343 case LEAF_begemotBridgeStpPortOperEdgePort:
1344 val->v.integer = bp->oper_edge;
1416 case LEAF_begemotBridgeStpPortOperEdgePort:
1417 val->v.integer = bp->oper_edge;
1345 break;
1418 return (SNMP_ERR_NOERROR);
1419
1346 case LEAF_begemotBridgeStpPortAdminPointToPoint:
1347 val->v.integer = bp->admin_p2p;
1420 case LEAF_begemotBridgeStpPortAdminPointToPoint:
1421 val->v.integer = bp->admin_p2p;
1348 break;
1422 return (SNMP_ERR_NOERROR);
1423
1349 case LEAF_begemotBridgeStpPortOperPointToPoint:
1350 val->v.integer = bp->oper_p2p;
1424 case LEAF_begemotBridgeStpPortOperPointToPoint:
1425 val->v.integer = bp->oper_p2p;
1351 break;
1426 return (SNMP_ERR_NOERROR);
1427
1352 case LEAF_begemotBridgeStpPortAdminPathCost:
1353 val->v.integer = bp->admin_path_cost;
1428 case LEAF_begemotBridgeStpPortAdminPathCost:
1429 val->v.integer = bp->admin_path_cost;
1354 break;
1430 return (SNMP_ERR_NOERROR);
1355 }
1356
1431 }
1432
1357 return (SNMP_ERR_NOERROR);
1433 abort();
1358}
1359
1360int
1361op_begemot_tp_port(struct snmp_context *c __unused, struct snmp_value *val,
1362 uint sub, uint iidx __unused, enum snmp_op op)
1363{
1364 struct bridge_port *bp;
1365
1366 if (time(NULL) - ports_list_age > bridge_get_data_maxage())
1367 bridge_update_all_ports();
1368
1369 switch (op) {
1370 case SNMP_OP_GET:
1371 if ((bp = bridge_port_index_get(&val->var, sub, 0)) == NULL)
1372 return (SNMP_ERR_NOSUCHNAME);
1434}
1435
1436int
1437op_begemot_tp_port(struct snmp_context *c __unused, struct snmp_value *val,
1438 uint sub, uint iidx __unused, enum snmp_op op)
1439{
1440 struct bridge_port *bp;
1441
1442 if (time(NULL) - ports_list_age > bridge_get_data_maxage())
1443 bridge_update_all_ports();
1444
1445 switch (op) {
1446 case SNMP_OP_GET:
1447 if ((bp = bridge_port_index_get(&val->var, sub, 0)) == NULL)
1448 return (SNMP_ERR_NOSUCHNAME);
1373 break;
1449 goto get;
1374
1375 case SNMP_OP_GETNEXT:
1376 if ((bp = bridge_port_index_getnext(&val->var, sub, 0)) ==
1377 NULL || bridge_port_index_append(&val->var, sub, bp) < 0)
1378 return (SNMP_ERR_NOSUCHNAME);
1450
1451 case SNMP_OP_GETNEXT:
1452 if ((bp = bridge_port_index_getnext(&val->var, sub, 0)) ==
1453 NULL || bridge_port_index_append(&val->var, sub, bp) < 0)
1454 return (SNMP_ERR_NOSUCHNAME);
1379 break;
1455 goto get;
1380
1381 case SNMP_OP_SET:
1382 return (SNMP_ERR_NOT_WRITEABLE);
1383
1384 case SNMP_OP_ROLLBACK:
1385 case SNMP_OP_COMMIT:
1456
1457 case SNMP_OP_SET:
1458 return (SNMP_ERR_NOT_WRITEABLE);
1459
1460 case SNMP_OP_ROLLBACK:
1461 case SNMP_OP_COMMIT:
1386 default:
1387 abort();
1462 break;
1388 }
1463 }
1464 abort();
1389
1465
1466get:
1390 switch (val->var.subs[sub - 1]) {
1391 case LEAF_begemotBridgeTpPort:
1392 val->v.integer = bp->port_no;
1467 switch (val->var.subs[sub - 1]) {
1468 case LEAF_begemotBridgeTpPort:
1469 val->v.integer = bp->port_no;
1393 break;
1470 return (SNMP_ERR_NOERROR);
1471
1394 case LEAF_begemotBridgeTpPortMaxInfo:
1395 val->v.integer = bp->max_info;
1472 case LEAF_begemotBridgeTpPortMaxInfo:
1473 val->v.integer = bp->max_info;
1396 break;
1474 return (SNMP_ERR_NOERROR);
1475
1397 case LEAF_begemotBridgeTpPortInFrames:
1398 val->v.uint32 = bp->in_frames;
1476 case LEAF_begemotBridgeTpPortInFrames:
1477 val->v.uint32 = bp->in_frames;
1399 break;
1478 return (SNMP_ERR_NOERROR);
1479
1400 case LEAF_begemotBridgeTpPortOutFrames:
1401 val->v.uint32 = bp->out_frames;
1480 case LEAF_begemotBridgeTpPortOutFrames:
1481 val->v.uint32 = bp->out_frames;
1402 break;
1482 return (SNMP_ERR_NOERROR);
1483
1403 case LEAF_begemotBridgeTpPortInDiscards:
1404 val->v.uint32 = bp->in_drops;
1484 case LEAF_begemotBridgeTpPortInDiscards:
1485 val->v.uint32 = bp->in_drops;
1405 break;
1486 return (SNMP_ERR_NOERROR);
1406 }
1407
1487 }
1488
1408 return (SNMP_ERR_NOERROR);
1489 abort();
1409}
1490}