Deleted Added
sdiff udiff text old ( 165046 ) new ( 165253 )
full compact
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 $
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;
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;
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();
386 }
387
388 switch (val->var.subs[sub - 1]) {
389 case LEAF_dot1dBasePort:
390 val->v.integer = bp->port_no;
391 break;
392 case LEAF_dot1dBasePortIfIndex:
393 val->v.integer = bp->if_idx;
394 break;
395 case LEAF_dot1dBasePortCircuit:
396 val->v.oid = bp->circuit;
397 break;
398 case LEAF_dot1dBasePortDelayExceededDiscards:
399 val->v.uint32 = bp->dly_ex_drops;
400 break;
401 case LEAF_dot1dBasePortMtuExceededDiscards:
402 val->v.uint32 = bp->dly_mtu_drops;
403 break;
404 }
405
406 return (SNMP_ERR_NOERROR);
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{
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);
431 break;
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;
445 break;
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:
456 ctx->scratch->int1 = bp->priority;
457 ret = bridge_port_set_priority(bif->bif_name, bp,
458 val->v.integer);
459 break;
460 case LEAF_dot1dStpPortEnable:
461 ctx->scratch->int1 = bp->enable;
462 ret = bridge_port_set_stp_enable(bif->bif_name,
463 bp, val->v.integer);
464 break;
465 case LEAF_dot1dStpPortPathCost:
466 ctx->scratch->int1 = bp->path_cost;
467 ret = bridge_port_set_path_cost(bif->bif_name, bp,
468 val->v.integer);
469 break;
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);
478 default:
479 return (SNMP_ERR_NOSUCHNAME);
480 }
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);
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);
509
510 default:
511 abort();
512 }
513
514 ret = SNMP_ERR_NOERROR;
515 switch (val->var.subs[sub - 1]) {
516 case LEAF_dot1dStpPort:
517 val->v.integer = bp->port_no;
518 break;
519 case LEAF_dot1dStpPortPriority:
520 val->v.integer = bp->priority;
521 break;
522 case LEAF_dot1dStpPortState:
523 val->v.integer = bp->state;
524 break;
525 case LEAF_dot1dStpPortEnable:
526 val->v.integer = bp->enable;
527 break;
528 case LEAF_dot1dStpPortPathCost:
529 val->v.integer = bp->path_cost;
530 break;
531 case LEAF_dot1dStpPortDesignatedRoot:
532 ret = string_get(val, bp->design_root,
533 SNMP_BRIDGE_ID_LEN);
534 break;
535 case LEAF_dot1dStpPortDesignatedCost:
536 val->v.integer = bp->design_cost;
537 break;
538 case LEAF_dot1dStpPortDesignatedBridge:
539 ret = string_get(val, bp->design_bridge,
540 SNMP_BRIDGE_ID_LEN);
541 break;
542 case LEAF_dot1dStpPortDesignatedPort:
543 ret = string_get(val, bp->design_port, 2);
544 break;
545 case LEAF_dot1dStpPortForwardTransitions:
546 val->v.uint32 = bp->fwd_trans;
547 break;
548 }
549
550 return (ret);
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{
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);
575 break;
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;
589 break;
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:
600 ctx->scratch->int1 = bp->admin_edge;
601 ret = bridge_port_set_admin_edge(bif->bif_name, bp,
602 val->v.integer);
603 break;
604 case LEAF_dot1dStpPortAdminPointToPoint:
605 ctx->scratch->int1 = bp->admin_p2p;
606 ret = bridge_port_set_admin_p2p(bif->bif_name, bp,
607 val->v.integer);
608 break;
609 case LEAF_dot1dStpPortAdminPathCost:
610 ctx->scratch->int1 = bp->admin_path_cost;
611 ret = bridge_port_set_path_cost(bif->bif_name, bp,
612 val->v.integer);
613 break;
614 case LEAF_dot1dStpPortProtocolMigration:
615 case LEAF_dot1dStpPortOperEdgePort:
616 case LEAF_dot1dStpPortOperPointToPoint:
617 return (SNMP_ERR_NOT_WRITEABLE);
618 default:
619 return (SNMP_ERR_NOSUCHNAME);
620 }
621
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);
651
652 default:
653 abort();
654 }
655
656 switch (val->var.subs[sub - 1]) {
657 case LEAF_dot1dStpPortProtocolMigration:
658 val->v.integer = bp->proto_migr;
659 break;
660 case LEAF_dot1dStpPortAdminEdgePort:
661 val->v.integer = bp->admin_edge;
662 break;
663 case LEAF_dot1dStpPortOperEdgePort:
664 val->v.integer = bp->oper_edge;
665 break;
666 case LEAF_dot1dStpPortAdminPointToPoint:
667 val->v.integer = bp->admin_p2p;
668 break;
669 case LEAF_dot1dStpPortOperPointToPoint:
670 val->v.integer = bp->oper_p2p;
671 break;
672 case LEAF_dot1dStpPortAdminPathCost:
673 val->v.integer = bp->admin_path_cost;
674 break;
675 }
676
677 return (SNMP_ERR_NOERROR);
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);
701 break;
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;
715 break;
716
717 case SNMP_OP_SET:
718 return (SNMP_ERR_NOT_WRITEABLE);
719
720 case SNMP_OP_ROLLBACK:
721 case SNMP_OP_COMMIT:
722 default:
723 abort();
724 }
725
726 switch (val->var.subs[sub - 1]) {
727 case LEAF_dot1dTpPort:
728 val->v.integer = bp->port_no;
729 break;
730 case LEAF_dot1dTpPortMaxInfo:
731 val->v.integer = bp->max_info;
732 break;
733 case LEAF_dot1dTpPortInFrames:
734 val->v.uint32 = bp->in_frames;
735 break;
736 case LEAF_dot1dTpPortOutFrames:
737 val->v.uint32 = bp->out_frames;
738 break;
739 case LEAF_dot1dTpPortInDiscards:
740 val->v.uint32 = bp->in_drops;
741 break;
742 }
743
744 return (SNMP_ERR_NOERROR);
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;
1039 struct bridge_port *bp = NULL;
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);
1055 break;
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);
1065 break;
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 }
1098
1099 switch (which) {
1100 case LEAF_begemotBridgeBasePort:
1101 val->v.integer = bp->port_no;
1102 break;
1103 case LEAF_begemotBridgeBasePortIfIndex:
1104 val->v.integer = bp->if_idx;
1105 break;
1106 case LEAF_begemotBridgeBaseSpanEnabled:
1107 val->v.integer = bp->span_enable;
1108 break;
1109 case LEAF_begemotBridgeBasePortDelayExceededDiscards:
1110 val->v.uint32 = bp->dly_ex_drops;
1111 break;
1112 case LEAF_begemotBridgeBasePortMtuExceededDiscards:
1113 val->v.uint32 = bp->dly_mtu_drops;
1114 break;
1115 case LEAF_begemotBridgeBasePortStatus:
1116 val->v.integer = bp->status;
1117 break;
1118 }
1119
1120 return (SNMP_ERR_NOERROR);
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{
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);
1138 break;
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);
1144 break;
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
1152 ret = SNMP_ERR_NOERROR;
1153 switch (val->var.subs[sub - 1]) {
1154 case LEAF_begemotBridgeStpPortPriority:
1155 ctx->scratch->int1 = bp->priority;
1156 ret = bridge_port_set_priority(b_name, bp,
1157 val->v.integer);
1158 break;
1159 case LEAF_begemotBridgeStpPortEnable:
1160 ctx->scratch->int1 = bp->enable;
1161 ret = bridge_port_set_stp_enable(b_name, bp,
1162 val->v.integer);
1163 break;
1164 case LEAF_begemotBridgeStpPortPathCost:
1165 ctx->scratch->int1 = bp->path_cost;
1166 ret = bridge_port_set_path_cost(b_name, bp,
1167 val->v.integer);
1168 break;
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 }
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);
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);
1207
1208 default:
1209 abort();
1210 }
1211
1212 ret = SNMP_ERR_NOERROR;
1213 switch (val->var.subs[sub - 1]) {
1214 case LEAF_begemotBridgeStpPort:
1215 val->v.integer = bp->port_no;
1216 break;
1217 case LEAF_begemotBridgeStpPortPriority:
1218 val->v.integer = bp->priority;
1219 break;
1220 case LEAF_begemotBridgeStpPortState:
1221 val->v.integer = bp->state;
1222 break;
1223 case LEAF_begemotBridgeStpPortEnable:
1224 val->v.integer = bp->enable;
1225 break;
1226 case LEAF_begemotBridgeStpPortPathCost:
1227 val->v.integer = bp->path_cost;
1228 break;
1229 case LEAF_begemotBridgeStpPortDesignatedRoot:
1230 ret = string_get(val, bp->design_root, SNMP_BRIDGE_ID_LEN);
1231 break;
1232 case LEAF_begemotBridgeStpPortDesignatedCost:
1233 val->v.integer = bp->design_cost;
1234 break;
1235 case LEAF_begemotBridgeStpPortDesignatedBridge:
1236 ret = string_get(val, bp->design_bridge, SNMP_BRIDGE_ID_LEN);
1237 break;
1238 case LEAF_begemotBridgeStpPortDesignatedPort:
1239 ret = string_get(val, bp->design_port, 2);
1240 break;
1241 case LEAF_begemotBridgeStpPortForwardTransitions:
1242 val->v.uint32 = bp->fwd_trans;
1243 break;
1244 }
1245
1246 return (ret);
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{
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);
1264 break;
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);
1270 break;
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:
1280 ctx->scratch->int1 = bp->admin_edge;
1281 ret = bridge_port_set_admin_edge(b_name, bp,
1282 val->v.integer);
1283 break;
1284 case LEAF_begemotBridgeStpPortAdminPointToPoint:
1285 ctx->scratch->int1 = bp->admin_p2p;
1286 ret = bridge_port_set_admin_p2p(b_name, bp,
1287 val->v.integer);
1288 break;
1289 case LEAF_begemotBridgeStpPortAdminPathCost:
1290 ctx->scratch->int1 = bp->admin_path_cost;
1291 ret = bridge_port_set_path_cost(b_name, bp,
1292 val->v.integer);
1293 break;
1294 case LEAF_begemotBridgeStpPortProtocolMigration:
1295 case LEAF_begemotBridgeStpPortOperEdgePort:
1296 case LEAF_begemotBridgeStpPortOperPointToPoint:
1297 return (SNMP_ERR_NOT_WRITEABLE);
1298 default:
1299 return (SNMP_ERR_NOSUCHNAME);
1300 }
1301
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);
1331
1332 default:
1333 abort();
1334 }
1335
1336 switch (val->var.subs[sub - 1]) {
1337 case LEAF_begemotBridgeStpPortProtocolMigration:
1338 val->v.integer = bp->proto_migr;
1339 break;
1340 case LEAF_begemotBridgeStpPortAdminEdgePort:
1341 val->v.integer = bp->admin_edge;
1342 break;
1343 case LEAF_begemotBridgeStpPortOperEdgePort:
1344 val->v.integer = bp->oper_edge;
1345 break;
1346 case LEAF_begemotBridgeStpPortAdminPointToPoint:
1347 val->v.integer = bp->admin_p2p;
1348 break;
1349 case LEAF_begemotBridgeStpPortOperPointToPoint:
1350 val->v.integer = bp->oper_p2p;
1351 break;
1352 case LEAF_begemotBridgeStpPortAdminPathCost:
1353 val->v.integer = bp->admin_path_cost;
1354 break;
1355 }
1356
1357 return (SNMP_ERR_NOERROR);
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);
1373 break;
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);
1379 break;
1380
1381 case SNMP_OP_SET:
1382 return (SNMP_ERR_NOT_WRITEABLE);
1383
1384 case SNMP_OP_ROLLBACK:
1385 case SNMP_OP_COMMIT:
1386 default:
1387 abort();
1388 }
1389
1390 switch (val->var.subs[sub - 1]) {
1391 case LEAF_begemotBridgeTpPort:
1392 val->v.integer = bp->port_no;
1393 break;
1394 case LEAF_begemotBridgeTpPortMaxInfo:
1395 val->v.integer = bp->max_info;
1396 break;
1397 case LEAF_begemotBridgeTpPortInFrames:
1398 val->v.uint32 = bp->in_frames;
1399 break;
1400 case LEAF_begemotBridgeTpPortOutFrames:
1401 val->v.uint32 = bp->out_frames;
1402 break;
1403 case LEAF_begemotBridgeTpPortInDiscards:
1404 val->v.uint32 = bp->in_drops;
1405 break;
1406 }
1407
1408 return (SNMP_ERR_NOERROR);
1409}