3 * Copyright (C) 2020 Volta Networks, Inc.
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License as published by the Free
7 * Software Foundation; either version 2 of the License, or (at your option)
10 * This program is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 * You should have received a copy of the GNU General Public License along
16 * with this program; see the file COPYING; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
21 * This is minimal read-only implementations providing
22 * mplsLdpModuleReadOnlyCompliance as described in RFC 3815.
27 #include <net-snmp/net-snmp-config.h>
28 #include <net-snmp/net-snmp-includes.h>
43 /* SNMP value hack. */
44 #define COUNTER32 ASN_COUNTER
45 #define INTEGER ASN_INTEGER
46 #define UNSIGNED32 ASN_GAUGE
47 #define TIMESTAMP ASN_TIMETICKS
48 #define TIMETICKS ASN_TIMETICKS
49 #define STRING ASN_OCTET_STR
50 #define IPADDRESS ASN_IPADDRESS
52 #define LDP_LSRID_IDX_LEN 6
53 #define LDP_ENTITY_IDX_LEN 1
54 #define LDP_ADJACENCY_IDX_LEN 1
56 /* MPLS-LDP-STD-MIB. */
57 #define MPLS_LDP_STD_MIB 1, 3, 6, 1, 2, 1, 10, 166, 4
59 #define MPLS_LDP_LSR_ID 0
60 #define MPLS_LDP_LSR_LOOP_DETECTION_CAPABLE 0
61 #define MPLS_LDP_ENTITY_LAST_CHANGE 0
62 #define MPLS_LDP_ENTITY_INDEX_NEXT 0
64 /* Declare static local variables for convenience. */
67 /* LDP-MIB instances. */
68 static oid ldp_oid
[] = {MPLS_LDP_STD_MIB
};
69 static oid ldp_trap_oid
[] = {MPLS_LDP_STD_MIB
, 0};
71 static uint8_t snmp_ldp_rtrid
[6] = {0, 0, 0, 0, 0};
73 #define LDP_DEFAULT_ENTITY_INDEX 1
75 #define MPLSLDPLSRLOOPDETECTIONCAPABLE_NONE 1
76 #define MPLSLDPLSRLOOPDETECTIONCAPABLE_OTHER 2
77 #define MPLSLDPLSRLOOPDETECTIONCAPABLE_HOPCOUNT 3
78 #define MPLSLDPLSRLOOPDETECTIONCAPABLE_PATHVECTOR 4
79 #define MPLSLDPLSRLOOPDETECTIONCAPABLE_HOPCOUNTANDPATHVECTOR 5
81 /* MPLS LDP mplsLdpHelloAdjacencyTable. */
82 #define MPLSLDPHELLOADJACENCYINDEX 1
83 #define MPLSLDPHELLOADJACENCYHOLDTIMEREM 2
84 #define MPLSLDPHELLOADJACENCYHOLDTIME 3
85 #define MPLSLDPHELLOADJACENCYTYPE 4
87 /* enums for column mplsLdpHelloAdjacencyType */
88 #define MPLSLDPHELLOADJACENCYTYPE_LINK 1
89 #define MPLSLDPHELLOADJACENCYTYPE_TARGETED 2
91 #define MPLSLDPPEERTRANSPORTADDRTYPE_UNKNOWN 0
92 #define MPLSLDPPEERTRANSPORTADDRTYPE_IPV4 1
93 #define MPLSLDPPEERTRANSPORTADDRTYPE_IPV6 2
94 #define MPLSLDPPEERTRANSPORTADDRTYPE_IPV4Z 3
95 #define MPLSLDPPEERTRANSPORTADDRTYPE_IPV6Z 4
96 #define MPLSLDPPEERTRANSPORTADDRTYPE_DNS 16
98 #define DOWNSTREAMONDEMAND 1
99 #define DOWNSTREAMUNSOLICITED 2
101 #define CONSERVATIVERETENTION 1
102 #define LIBERALRETENTION 2
104 #define TRANSPORTADDRINTERFACE 1
105 #define TRANSPORTADDRLOOPBACK 2
107 #define LABELTYPEGENERIC 1
109 #define STORAGETYPENONVOLATILE 3
111 #define ROWSTATUSACTIVE 4
113 #define ADMINSTATUSENABLED 1
115 #define OPERSTATUSENABLED 2
117 /* MPLS LDP mplsLdpPeerTable */
118 #define MPLSLDPPEERLDPID 1
119 #define MPLSLDPPEERLABELDISTMETHOD 2
120 #define MPLSLDPPEERPATHVECTORLIMIT 3
121 #define MPLSLDPPEERTRANSPORTADDRTYPE 4
122 #define MPLSLDPPEERTRANSPORTADDR 5
124 #define MPLSLDPSESSIONROLE_UNKNOWN 1
125 #define MPLSLDPSESSIONROLE_ACTIVE 2
126 #define MPLSLDPSESSIONROLE_PASSIVE 3
128 #define MPLSLDPSESSIONSTATE_NONEXISTENT 1
129 #define MPLSLDPSESSIONSTATE_INITIALIZED 2
130 #define MPLSLDPSESSIONSTATE_OPENREC 3
131 #define MPLSLDPSESSIONSTATE_OPENSENT 4
132 #define MPLSLDPSESSIONSTATE_OPERATIONAL 5
134 /* MPLS LDP mplsLdpSessionTable */
135 #define MPLSLDPSESSIONSTATELASTCHANGE 1
136 #define MPLSLDPSESSIONSTATE 2
137 #define MPLSLDPSESSIONROLE 3
138 #define MPLSLDPSESSIONPROTOCOLVERSION 4
139 #define MPLSLDPSESSIONKEEPALIVEHOLDTIMEREM 5
140 #define MPLSLDPSESSIONKEEPALIVETIME 6
141 #define MPLSLDPSESSIONMAXPDULENGTH 7
142 #define MPLSLDPSESSIONDISCONTINUITYTIME 8
144 /* MPLS LDP mplsLdpEntityTable */
145 #define MPLSLDPENTITYLDPID 1
146 #define MPLSLDPENTITYINDEX 2
147 #define MPLSLDPENTITYPROTOCOLVERSION 3
148 #define MPLSLDPENTITYADMINSTATUS 4
149 #define MPLSLDPENTITYOPERSTATUS 5
150 #define MPLSLDPENTITYTCPPORT 6
151 #define MPLSLDPENTITYUDPDSCPORT 7
152 #define MPLSLDPENTITYMAXPDULENGTH 8
153 #define MPLSLDPENTITYKEEPALIVEHOLDTIMER 9
154 #define MPLSLDPENTITYHELLOHOLDTIMER 10
155 #define MPLSLDPENTITYINITSESSIONTHRESHOLD 11
156 #define MPLSLDPENTITYLABELDISTMETHOD 12
157 #define MPLSLDPENTITYLABELRETENTIONMODE 13
158 #define MPLSLDPENTITYPATHVECTORLIMIT 14
159 #define MPLSLDPENTITYHOPCOUNTLIMIT 15
160 #define MPLSLDPENTITYTRANSPORTADDRKIND 16
161 #define MPLSLDPENTITYTARGETPEER 17
162 #define MPLSLDPENTITYTARGETPEERADDRTYPE 18
163 #define MPLSLDPENTITYTARGETPEERADDR 19
164 #define MPLSLDPENTITYLABELTYPE 20
165 #define MPLSLDPENTITYDISCONTINUITYTIME 21
166 #define MPLSLDPENTITYSTORAGETYPE 22
167 #define MPLSLDPENTITYROWSTATUS 23
169 /* MPLS LDP mplsLdpEntityStatsTable */
170 #define MPLSLDPENTITYSTATSSESSIONATTEMPTS 1
171 #define MPLSLDPENTITYSTATSSESSIONREJHELLO 2
172 #define MPLSLDPENTITYSTATSSESSIONREJAD 3
173 #define MPLSLDPENTITYSTATSSESSIONREJMAXPDU 4
174 #define MPLSLDPENTITYSTATSSESSIONREJLR 5
175 #define MPLSLDPENTITYSTATSBADLDPID 6
176 #define MPLSLDPENTITYSTATSBADPDULENGTH 7
177 #define MPLSLDPENTITYSTATSBADMSGLENGTH 8
178 #define MPLSLDPENTITYSTATSBADTLVLENGTH 9
179 #define MPLSLDPENTITYSTATSMALFORMEDTLV 10
180 #define MPLSLDPENTITYSTATSKEEPALIVEEXP 11
181 #define MPLSLDPENTITYSTATSSHUTDOWNRCVNOTIFY 12
182 #define MPLSLDPENTITYSTATSSHUTDOWNSENTNOTIFY 13
184 #define MPLSLDPSESSIONSTATSUNKNOWNMESTYPEERRORS 1
185 #define MPLSLDPSESSIONSTATSUNKNOWNTLVERRORS 2
187 static uint8_t *ldpLsrId(struct variable
*v
, oid name
[], size_t *length
,
188 int exact
, size_t *var_len
,
189 WriteMethod
**write_method
)
191 if (smux_header_generic(v
, name
, length
, exact
, var_len
, write_method
)
196 return (uint8_t *)&leconf
->rtr_id
.s_addr
;
199 static uint8_t *ldpLoopDetectCap(struct variable
*v
, oid name
[], size_t *length
,
200 int exact
, size_t *var_len
,
201 WriteMethod
**write_method
)
203 if (smux_header_generic(v
, name
, length
, exact
, var_len
, write_method
)
207 return SNMP_INTEGER(MPLSLDPLSRLOOPDETECTIONCAPABLE_NONE
);
210 extern uint32_t ldp_start_time
;
211 static uint8_t *ldpEntityLastChange(struct variable
*v
, oid name
[],
213 int exact
, size_t *var_len
,
214 WriteMethod
**write_method
)
216 if (smux_header_generic(v
, name
, length
, exact
, var_len
, write_method
)
220 *var_len
= sizeof(time_t);
221 return (uint8_t *) &(leconf
->config_change_time
);
225 static uint8_t *ldpEntityIndexNext(struct variable
*v
, oid name
[],
226 size_t *length
,int exact
, size_t *var_len
,
227 WriteMethod
**write_method
)
229 if (smux_header_generic(v
, name
, length
, exact
, var_len
, write_method
)
233 return SNMP_INTEGER(0);
236 #define LDP_ENTITY_TOTAL_LEN 21
237 #define LDP_ENTITY_MAX_IDX_LEN 6
239 static struct ldpd_af_conf
*ldpEntityTable_lookup(struct variable
*v
, oid
*name
,
240 size_t *length
, int exact
,
244 struct ldpd_af_conf
*af_v4
, *af_v6
;
246 af_v4
= &leconf
->ipv4
;
247 af_v6
= &leconf
->ipv6
;
250 if (*length
!= LDP_ENTITY_TOTAL_LEN
)
253 if (leconf
->trans_pref
== DUAL_STACK_LDPOV6
&&
254 af_v6
->flags
& F_LDPD_AF_ENABLED
) {
262 /* only support one router id so can just skip */
263 len
= *length
- v
->namelen
- LDP_ENTITY_MAX_IDX_LEN
;
265 if (leconf
->trans_pref
== DUAL_STACK_LDPOV6
&&
266 af_v6
->flags
& F_LDPD_AF_ENABLED
) {
278 static uint8_t *ldpEntityTable(struct variable
*v
, oid name
[], size_t *length
,
279 int exact
, size_t *var_len
,
280 WriteMethod
**write_method
)
282 struct ldpd_af_conf
*af
;
283 struct in_addr entityLdpId
= {.s_addr
= 0};
286 *write_method
= NULL
;
288 if (smux_header_table(v
, name
, length
, exact
, var_len
, write_method
)
292 af
= ldpEntityTable_lookup(v
, name
, length
, exact
, &index
);
297 entityLdpId
.s_addr
= ldp_rtr_id_get(leconf
);
299 /* Copy the name out */
300 memcpy(name
, v
->name
, v
->namelen
* sizeof(oid
));
303 *length
= LDP_ENTITY_TOTAL_LEN
;
304 oid_copy_addr(name
+ v
->namelen
, &entityLdpId
,
306 name
[v
->namelen
+ 4] = 0;
307 name
[v
->namelen
+ 5] = 0;
308 name
[v
->namelen
+ 6] = LDP_DEFAULT_ENTITY_INDEX
;
311 /* Return the current value of the variable */
313 case MPLSLDPENTITYLDPID
:
315 memcpy (snmp_ldp_rtrid
, &entityLdpId
, IN_ADDR_SIZE
);
316 return (uint8_t *)snmp_ldp_rtrid
;
317 case MPLSLDPENTITYINDEX
:
318 return SNMP_INTEGER(LDP_DEFAULT_ENTITY_INDEX
);
319 case MPLSLDPENTITYPROTOCOLVERSION
:
320 return SNMP_INTEGER(LDP_VERSION
);
321 case MPLSLDPENTITYADMINSTATUS
:
322 return SNMP_INTEGER(ADMINSTATUSENABLED
);
323 case MPLSLDPENTITYOPERSTATUS
:
324 return SNMP_INTEGER(OPERSTATUSENABLED
);
325 case MPLSLDPENTITYTCPPORT
:
326 return SNMP_INTEGER(LDP_PORT
);
327 case MPLSLDPENTITYUDPDSCPORT
:
328 return SNMP_INTEGER(LDP_PORT
);
329 case MPLSLDPENTITYMAXPDULENGTH
:
330 return SNMP_INTEGER(LDP_MAX_LEN
);
331 case MPLSLDPENTITYKEEPALIVEHOLDTIMER
:
332 return SNMP_INTEGER(af
->keepalive
);
333 case MPLSLDPENTITYHELLOHOLDTIMER
:
334 return SNMP_INTEGER(af
->lhello_holdtime
);
335 case MPLSLDPENTITYINITSESSIONTHRESHOLD
:
336 return SNMP_INTEGER(0); /* not supported */
337 case MPLSLDPENTITYLABELDISTMETHOD
:
338 return SNMP_INTEGER(DOWNSTREAMUNSOLICITED
);
339 case MPLSLDPENTITYLABELRETENTIONMODE
:
340 return SNMP_INTEGER(LIBERALRETENTION
);
341 case MPLSLDPENTITYPATHVECTORLIMIT
:
342 return SNMP_INTEGER(0); /* not supported */
343 case MPLSLDPENTITYHOPCOUNTLIMIT
:
344 return SNMP_INTEGER(0);
345 case MPLSLDPENTITYTRANSPORTADDRKIND
:
346 return SNMP_INTEGER(TRANSPORTADDRLOOPBACK
);
347 case MPLSLDPENTITYTARGETPEER
:
348 return SNMP_INTEGER(1);
349 case MPLSLDPENTITYTARGETPEERADDRTYPE
:
351 return SNMP_INTEGER(MPLSLDPPEERTRANSPORTADDRTYPE_IPV4
);
353 return SNMP_INTEGER(MPLSLDPPEERTRANSPORTADDRTYPE_IPV6
);
354 case MPLSLDPENTITYTARGETPEERADDR
:
356 *var_len
= sizeof(af
->trans_addr
.v4
);
357 return ((uint8_t *)&af
->trans_addr
.v4
);
359 *var_len
= sizeof(af
->trans_addr
.v6
);
360 return ((uint8_t *)&af
->trans_addr
.v6
);
362 case MPLSLDPENTITYLABELTYPE
:
363 return SNMP_INTEGER(LABELTYPEGENERIC
);
364 case MPLSLDPENTITYDISCONTINUITYTIME
:
365 return SNMP_INTEGER(0);
366 case MPLSLDPENTITYSTORAGETYPE
:
367 return SNMP_INTEGER(STORAGETYPENONVOLATILE
);
368 case MPLSLDPENTITYROWSTATUS
:
369 return SNMP_INTEGER(ROWSTATUSACTIVE
);
377 static uint8_t *ldpEntityStatsTable(struct variable
*v
, oid name
[],
378 size_t *length
, int exact
, size_t *var_len
,
379 WriteMethod
**write_method
)
381 struct in_addr entityLdpId
= {.s_addr
= 0};
384 *write_method
= NULL
;
386 if (smux_header_table(v
, name
, length
, exact
, var_len
, write_method
)
391 if (*length
!= LDP_ENTITY_TOTAL_LEN
)
394 len
= *length
- v
->namelen
- LDP_ENTITY_MAX_IDX_LEN
;
398 entityLdpId
.s_addr
= ldp_rtr_id_get(leconf
);
400 /* Copy the name out */
401 memcpy(name
, v
->name
, v
->namelen
* sizeof(oid
));
404 *length
= LDP_ENTITY_TOTAL_LEN
;
405 oid_copy_addr(name
+ v
->namelen
, &entityLdpId
,
407 name
[v
->namelen
+ 4] = 0;
408 name
[v
->namelen
+ 5] = 0;
409 name
[v
->namelen
+ 6] = LDP_DEFAULT_ENTITY_INDEX
;
412 /* Return the current value of the variable */
414 case MPLSLDPENTITYSTATSSESSIONATTEMPTS
:
415 return SNMP_INTEGER(leconf
->stats
.session_attempts
);
416 case MPLSLDPENTITYSTATSSESSIONREJHELLO
:
417 return SNMP_INTEGER(leconf
->stats
.session_rejects_hello
);
418 case MPLSLDPENTITYSTATSSESSIONREJAD
:
419 return SNMP_INTEGER(leconf
->stats
.session_rejects_ad
);
420 case MPLSLDPENTITYSTATSSESSIONREJMAXPDU
:
421 return SNMP_INTEGER(leconf
->stats
.session_rejects_max_pdu
);
422 case MPLSLDPENTITYSTATSSESSIONREJLR
:
423 return SNMP_INTEGER(leconf
->stats
.session_rejects_lr
);
424 case MPLSLDPENTITYSTATSBADLDPID
:
425 return SNMP_INTEGER(leconf
->stats
.bad_ldp_id
);
426 case MPLSLDPENTITYSTATSBADPDULENGTH
:
427 return SNMP_INTEGER(leconf
->stats
.bad_pdu_len
);
428 case MPLSLDPENTITYSTATSBADMSGLENGTH
:
429 return SNMP_INTEGER(leconf
->stats
.bad_msg_len
);
430 case MPLSLDPENTITYSTATSBADTLVLENGTH
:
431 return SNMP_INTEGER(leconf
->stats
.bad_tlv_len
);
432 case MPLSLDPENTITYSTATSMALFORMEDTLV
:
433 return SNMP_INTEGER(leconf
->stats
.malformed_tlv
);
434 case MPLSLDPENTITYSTATSKEEPALIVEEXP
:
435 return SNMP_INTEGER(leconf
->stats
.keepalive_timer_exp
);
436 case MPLSLDPENTITYSTATSSHUTDOWNRCVNOTIFY
:
437 return SNMP_INTEGER(leconf
->stats
.shutdown_rcv_notify
);
438 case MPLSLDPENTITYSTATSSHUTDOWNSENTNOTIFY
:
439 return SNMP_INTEGER(leconf
->stats
.shutdown_send_notify
);
447 #define LDP_ADJACENCY_ENTRY_MAX_IDX_LEN 14
449 static void ldpHelloAdjacencyTable_oid_to_index(
450 struct variable
*v
, oid name
[],
452 struct in_addr
*entityLdpId
,
453 uint32_t *entityIndex
,
454 struct in_addr
*peerLdpId
,
455 uint32_t *adjacencyIndex
)
457 oid
*offset
= name
+ v
->namelen
;
458 int offsetlen
= *length
- v
->namelen
;
461 if (len
> LDP_ADJACENCY_ENTRY_MAX_IDX_LEN
)
462 len
= LDP_ADJACENCY_ENTRY_MAX_IDX_LEN
;
464 if (len
>= LDP_LSRID_IDX_LEN
)
465 oid2in_addr(offset
, sizeof(struct in_addr
), entityLdpId
);
467 offset
+= LDP_LSRID_IDX_LEN
;
468 offsetlen
-= LDP_LSRID_IDX_LEN
;
471 if (len
> LDP_ENTITY_IDX_LEN
)
472 len
= LDP_ENTITY_IDX_LEN
;
474 if (len
>= LDP_ENTITY_IDX_LEN
)
475 *entityIndex
= offset
[0];
477 offset
+= LDP_ENTITY_IDX_LEN
;
478 offsetlen
-= LDP_ENTITY_IDX_LEN
;
481 if (len
> LDP_LSRID_IDX_LEN
)
482 len
= LDP_LSRID_IDX_LEN
;
484 if (len
>= LDP_LSRID_IDX_LEN
)
485 oid2in_addr(offset
, sizeof(struct in_addr
), peerLdpId
);
487 offset
+= LDP_LSRID_IDX_LEN
;
488 offsetlen
-= LDP_LSRID_IDX_LEN
;
491 if (len
> LDP_ADJACENCY_IDX_LEN
)
492 len
= LDP_ADJACENCY_IDX_LEN
;
494 if (len
>= LDP_ADJACENCY_IDX_LEN
)
495 *adjacencyIndex
= offset
[0];
499 nbr_get_adj_by_index(struct nbr
*nbr
, uint32_t adjacencyIndex
)
504 RB_FOREACH(adj
, nbr_adj_head
, &nbr
->adj_tree
)
505 if (++i
== adjacencyIndex
)
511 static struct ctl_adj
*
512 ldpHelloAdjacencyTable_lookup_helper(
513 struct in_addr
*entityLdpId
,
514 uint32_t *entityIndex
,
515 struct in_addr
*peerLdpId
,
516 uint32_t *adjacencyIndex
)
518 struct ctl_adj
*ctl_adj
= NULL
;
519 struct adj
*adj
= NULL
;
520 struct nbr
*cur_nbr
= nbr_find_ldpid(peerLdpId
->s_addr
);
523 /* If found nbr, then look to see if the
526 adj
= nbr_get_adj_by_index(cur_nbr
, *adjacencyIndex
);
529 ctl_adj
= adj_to_ctl(adj
);
534 static struct ctl_adj
*
535 ldpHelloAdjacencyTable_next_helper(
537 struct in_addr
*entityLdpId
,
538 uint32_t *entityIndex
,
539 struct in_addr
*peerLdpId
,
540 uint32_t *adjacencyIndex
)
542 struct ctl_adj
*ctl_adj
= NULL
;
543 struct nbr
*nbr
= NULL
;
544 struct adj
*adj
= NULL
;
547 nbr
= nbr_get_first_ldpid();
549 struct nbr
*cur_nbr
= nbr_find_ldpid(peerLdpId
->s_addr
);
551 /* If found nbr, then look to see if the
554 adj
= nbr_get_adj_by_index(cur_nbr
, *adjacencyIndex
+ 1);
556 *adjacencyIndex
+= 1;
558 nbr
= nbr_get_next_ldpid(peerLdpId
->s_addr
);
562 adj
= RB_MIN(nbr_adj_head
, &nbr
->adj_tree
);
567 ctl_adj
= adj_to_ctl(adj
);
572 #define HELLO_ADJ_MAX_IDX_LEN 14
574 static struct ctl_adj
*
575 ldpHelloAdjacencyTable_lookup(struct variable
*v
, oid name
[],
576 size_t *length
, int exact
,
577 struct in_addr
*entityLdpId
,
578 uint32_t *entityIndex
,
579 struct in_addr
*peerLdpId
,
580 uint32_t *adjacencyIndex
)
582 struct ctl_adj
*hello_adj
= NULL
;
585 if (*length
< HELLO_ADJ_MAX_IDX_LEN
)
588 ldpHelloAdjacencyTable_oid_to_index(
590 entityLdpId
, entityIndex
, peerLdpId
, adjacencyIndex
);
592 hello_adj
= ldpHelloAdjacencyTable_lookup_helper(
593 entityLdpId
, entityIndex
, peerLdpId
, adjacencyIndex
);
596 int offsetlen
= *length
- v
->namelen
;
598 if (offsetlen
< HELLO_ADJ_MAX_IDX_LEN
)
601 ldpHelloAdjacencyTable_oid_to_index(
603 entityLdpId
, entityIndex
, peerLdpId
, adjacencyIndex
);
605 hello_adj
= ldpHelloAdjacencyTable_next_helper(first
,
606 entityLdpId
, entityIndex
, peerLdpId
, adjacencyIndex
);
612 static uint8_t *ldpHelloAdjacencyTable(struct variable
*v
, oid name
[], size_t *length
,
613 int exact
, size_t *var_len
,
614 WriteMethod
**write_method
)
616 struct in_addr entityLdpId
= {.s_addr
= 0};
617 uint32_t entityIndex
= 0;
618 struct in_addr peerLdpId
= {.s_addr
= 0};
619 uint32_t adjacencyIndex
= 0;
621 if (smux_header_table(v
, name
, length
, exact
, var_len
, write_method
)
625 struct ctl_adj
*ctl_adj
= ldpHelloAdjacencyTable_lookup(v
, name
,
627 &entityLdpId
, &entityIndex
, &peerLdpId
, &adjacencyIndex
);
634 /* Copy the name out */
635 memcpy(name
, v
->name
, v
->namelen
* sizeof(oid
));
638 struct in_addr entityLdpId
= {.s_addr
= 0};
639 entityLdpId
.s_addr
= ldp_rtr_id_get(leconf
);
641 struct in_addr peerLdpId
= ctl_adj
->id
;
643 oid_copy_addr(name
+ v
->namelen
, &entityLdpId
,
644 sizeof(struct in_addr
));
645 name
[v
->namelen
+ 4] = 0;
646 name
[v
->namelen
+ 5] = 0;
647 name
[v
->namelen
+ 6] = LDP_DEFAULT_ENTITY_INDEX
;
648 oid_copy_addr(name
+ v
->namelen
+ 7, &peerLdpId
,
649 sizeof(struct in_addr
));
650 name
[v
->namelen
+ 11] = 0;
651 name
[v
->namelen
+ 12] = 0;
652 name
[v
->namelen
+ 13] = adjacencyIndex
;
655 *length
= v
->namelen
+ HELLO_ADJ_MAX_IDX_LEN
;
659 case MPLSLDPHELLOADJACENCYINDEX
:
660 return SNMP_INTEGER(adjacencyIndex
);
661 case MPLSLDPHELLOADJACENCYHOLDTIMEREM
:
662 return SNMP_INTEGER(ctl_adj
->holdtime_remaining
);
663 case MPLSLDPHELLOADJACENCYHOLDTIME
:
664 return SNMP_INTEGER(ctl_adj
->holdtime
);
665 case MPLSLDPHELLOADJACENCYTYPE
:
666 if (ctl_adj
->type
== HELLO_LINK
)
667 return SNMP_INTEGER(MPLSLDPHELLOADJACENCYTYPE_LINK
);
668 return SNMP_INTEGER(MPLSLDPHELLOADJACENCYTYPE_TARGETED
);
676 #define LDP_LSRID_IDX_LEN 6
677 #define LDP_ENTITY_IDX_LEN 1
678 #define LDP_PEER_ENTRY_MAX_IDX_LEN 13
680 static void ldpPeerTable_oid_to_index(
681 struct variable
*v
, oid name
[],
683 struct in_addr
*entityLdpId
,
684 uint32_t *entityIndex
,
685 struct in_addr
*peerLdpId
)
687 oid
*offset
= name
+ v
->namelen
;
688 int offsetlen
= *length
- v
->namelen
;
691 if (len
> LDP_PEER_ENTRY_MAX_IDX_LEN
)
692 len
= LDP_PEER_ENTRY_MAX_IDX_LEN
;
694 if (len
>= LDP_LSRID_IDX_LEN
)
695 oid2in_addr(offset
, sizeof(struct in_addr
), entityLdpId
);
697 offset
+= LDP_LSRID_IDX_LEN
;
698 offsetlen
-= LDP_LSRID_IDX_LEN
;
701 if (len
> LDP_ENTITY_IDX_LEN
)
702 len
= LDP_ENTITY_IDX_LEN
;
704 if (len
>= LDP_ENTITY_IDX_LEN
)
705 *entityIndex
= offset
[0];
707 offset
+= LDP_ENTITY_IDX_LEN
;
708 offsetlen
-= LDP_ENTITY_IDX_LEN
;
711 if (len
> LDP_LSRID_IDX_LEN
)
712 len
= LDP_LSRID_IDX_LEN
;
714 if (len
>= LDP_LSRID_IDX_LEN
)
715 oid2in_addr(offset
, sizeof(struct in_addr
), peerLdpId
);
718 static struct ctl_nbr
*
719 ldpPeerTable_lookup_next(int first
,
720 struct in_addr peerLdpId
)
722 struct nbr
*nbr
= NULL
;
723 struct ctl_nbr
*ctl_nbr
= NULL
;;
726 nbr
= nbr_get_first_ldpid();
728 nbr
= nbr_get_next_ldpid(peerLdpId
.s_addr
);
731 ctl_nbr
= nbr_to_ctl(nbr
);
736 static struct ctl_nbr
*
737 ldpPeerTable_lookup(struct variable
*v
, oid name
[],
738 size_t *length
, int exact
,
739 struct in_addr
*entityLdpId
,
740 uint32_t *entityIndex
,
741 struct in_addr
*peerLdpId
)
743 struct ctl_nbr
*ctl_nbr
= NULL
;
744 struct nbr
*nbr
= NULL
;
748 if (*length
< (long unsigned int)v
->namelen
749 + LDP_PEER_ENTRY_MAX_IDX_LEN
)
752 ldpPeerTable_oid_to_index(
754 entityLdpId
, entityIndex
, peerLdpId
);
756 nbr
= nbr_find_ldpid(peerLdpId
->s_addr
);
758 ctl_nbr
= nbr_to_ctl(nbr
);
763 int offsetlen
= *length
- v
->namelen
;
764 if (offsetlen
< LDP_LSRID_IDX_LEN
)
767 ldpPeerTable_oid_to_index(
769 entityLdpId
, entityIndex
, peerLdpId
);
771 ctl_nbr
= ldpPeerTable_lookup_next(first
, *peerLdpId
);
777 static uint8_t *ldpPeerTable(struct variable
*v
, oid name
[], size_t *length
,
778 int exact
, size_t *var_len
,
779 WriteMethod
**write_method
)
781 struct in_addr entityLdpId
= {.s_addr
= 0};
782 uint32_t entityIndex
= 0;
783 struct in_addr peerLdpId
= {.s_addr
= 0};
784 struct ctl_nbr
*ctl_nbr
;
787 if (smux_header_table(v
, name
, length
, exact
, var_len
, write_method
)
791 ctl_nbr
= ldpPeerTable_lookup(v
, name
, length
, exact
, &entityLdpId
,
792 &entityIndex
, &peerLdpId
);
799 entityLdpId
.s_addr
= ldp_rtr_id_get(leconf
);
800 entityIndex
= LDP_DEFAULT_ENTITY_INDEX
;
801 peerLdpId
= ctl_nbr
->id
;
803 /* Copy the name out */
804 memcpy(name
, v
->name
, v
->namelen
* sizeof(oid
));
807 oid_copy_addr(name
+ v
->namelen
, &entityLdpId
,
808 sizeof(struct in_addr
));
810 name
[v
->namelen
+ 4] = 0;
811 name
[v
->namelen
+ 5] = 0;
812 name
[v
->namelen
+ 6] = entityIndex
;
813 oid_copy_addr(name
+ v
->namelen
+ 7, &peerLdpId
,
814 sizeof(struct in_addr
));
815 name
[v
->namelen
+ 11] = 0;
816 name
[v
->namelen
+ 12] = 0;
819 *length
= v
->namelen
+ LDP_PEER_ENTRY_MAX_IDX_LEN
;
823 case MPLSLDPPEERLDPID
:
825 memcpy(snmp_ldp_rtrid
, &ctl_nbr
->id
, IN_ADDR_SIZE
);
826 return snmp_ldp_rtrid
;
827 case MPLSLDPPEERLABELDISTMETHOD
:
828 return SNMP_INTEGER(DOWNSTREAMUNSOLICITED
);
829 case MPLSLDPPEERPATHVECTORLIMIT
:
830 return SNMP_INTEGER(0);
831 case MPLSLDPPEERTRANSPORTADDRTYPE
:
832 if (ctl_nbr
->af
== AF_INET
)
833 return SNMP_INTEGER(MPLSLDPPEERTRANSPORTADDRTYPE_IPV4
);
835 return SNMP_INTEGER(MPLSLDPPEERTRANSPORTADDRTYPE_IPV6
);
836 case MPLSLDPPEERTRANSPORTADDR
:
837 if (ctl_nbr
->af
== AF_INET
) {
838 *var_len
= sizeof(ctl_nbr
->raddr
.v4
);
839 return ((uint8_t *)&ctl_nbr
->raddr
.v4
);
841 *var_len
= sizeof(ctl_nbr
->raddr
.v6
);
842 return ((uint8_t *)&ctl_nbr
->raddr
.v6
);
850 static uint8_t *ldpSessionTable(struct variable
*v
, oid name
[], size_t *length
,
851 int exact
, size_t *var_len
,
852 WriteMethod
**write_method
)
854 struct in_addr entityLdpId
= {.s_addr
= 0};
855 uint32_t entityIndex
= 0;
856 struct in_addr peerLdpId
= {.s_addr
= 0};
857 struct ctl_nbr
*ctl_nbr
;
859 if (smux_header_table(v
, name
, length
, exact
, var_len
, write_method
)
863 ctl_nbr
= ldpPeerTable_lookup(v
, name
, length
, exact
, &entityLdpId
,
864 &entityIndex
, &peerLdpId
);
870 entityLdpId
.s_addr
= ldp_rtr_id_get(leconf
);
871 entityIndex
= LDP_DEFAULT_ENTITY_INDEX
;
872 peerLdpId
= ctl_nbr
->id
;
874 /* Copy the name out */
875 memcpy(name
, v
->name
, v
->namelen
* sizeof(oid
));
878 oid_copy_addr(name
+ v
->namelen
, &entityLdpId
,
879 sizeof(struct in_addr
));
881 name
[v
->namelen
+ 4] = 0;
882 name
[v
->namelen
+ 5] = 0;
883 name
[v
->namelen
+ 6] = entityIndex
;
884 oid_copy_addr(name
+ v
->namelen
+ 7, &peerLdpId
,
885 sizeof(struct in_addr
));
886 name
[v
->namelen
+ 11] = 0;
887 name
[v
->namelen
+ 12] = 0;
890 *length
= v
->namelen
+ LDP_PEER_ENTRY_MAX_IDX_LEN
;
894 case MPLSLDPSESSIONSTATELASTCHANGE
:
895 *var_len
= sizeof(time_t);
896 return (uint8_t *) &(ctl_nbr
->uptime
);
897 case MPLSLDPSESSIONSTATE
:
898 switch (ctl_nbr
->nbr_state
) {
899 case NBR_STA_INITIAL
:
900 return SNMP_INTEGER(MPLSLDPSESSIONSTATE_INITIALIZED
);
901 case NBR_STA_OPENREC
:
902 return SNMP_INTEGER(MPLSLDPSESSIONSTATE_OPENREC
);
903 case NBR_STA_OPENSENT
:
904 return SNMP_INTEGER(MPLSLDPSESSIONSTATE_OPENSENT
);
906 return SNMP_INTEGER(MPLSLDPSESSIONSTATE_OPERATIONAL
);
908 return SNMP_INTEGER(MPLSLDPSESSIONSTATE_NONEXISTENT
);
910 case MPLSLDPSESSIONROLE
:
911 if (ldp_addrcmp(ctl_nbr
->af
, &ctl_nbr
->laddr
, &ctl_nbr
->raddr
)
913 return SNMP_INTEGER(MPLSLDPSESSIONROLE_ACTIVE
);
915 return SNMP_INTEGER(MPLSLDPSESSIONROLE_PASSIVE
);
916 case MPLSLDPSESSIONPROTOCOLVERSION
:
917 return SNMP_INTEGER(LDP_VERSION
);
918 case MPLSLDPSESSIONKEEPALIVEHOLDTIMEREM
:
919 return SNMP_INTEGER(ctl_nbr
->hold_time_remaining
);
920 case MPLSLDPSESSIONKEEPALIVETIME
:
921 return SNMP_INTEGER(ctl_nbr
->holdtime
);
922 case MPLSLDPSESSIONMAXPDULENGTH
:
923 if (ctl_nbr
->nbr_state
== NBR_STA_OPER
)
924 return SNMP_INTEGER(ctl_nbr
->max_pdu_len
);
926 return SNMP_INTEGER(LDP_MAX_LEN
);
927 case MPLSLDPSESSIONDISCONTINUITYTIME
:
928 return SNMP_INTEGER(0); /* not supported */
936 static uint8_t *ldpSessionStatsTable(struct variable
*v
, oid name
[],
938 int exact
, size_t *var_len
,
939 WriteMethod
**write_method
)
941 struct in_addr entityLdpId
= {.s_addr
= 0};
942 uint32_t entityIndex
= 0;
943 struct in_addr peerLdpId
= {.s_addr
= 0};
945 if (smux_header_table(v
, name
, length
, exact
, var_len
, write_method
)
949 struct ctl_nbr
*ctl_nbr
= ldpPeerTable_lookup(v
, name
, length
, exact
,
950 &entityLdpId
, &entityIndex
, &peerLdpId
);
956 entityLdpId
.s_addr
= ldp_rtr_id_get(leconf
);
957 entityIndex
= LDP_DEFAULT_ENTITY_INDEX
;
958 peerLdpId
= ctl_nbr
->id
;
960 /* Copy the name out */
961 memcpy(name
, v
->name
, v
->namelen
* sizeof(oid
));
964 oid_copy_addr(name
+ v
->namelen
, &entityLdpId
,
965 sizeof(struct in_addr
));
966 name
[v
->namelen
+ 4] = 0;
967 name
[v
->namelen
+ 5] = 0;
968 name
[v
->namelen
+ 6] = entityIndex
;
969 oid_copy_addr(name
+ v
->namelen
+ 7, &peerLdpId
,
970 sizeof(struct in_addr
));
971 name
[v
->namelen
+ 11] = 0;
972 name
[v
->namelen
+ 12] = 0;
974 *length
= v
->namelen
+ LDP_PEER_ENTRY_MAX_IDX_LEN
;
978 case MPLSLDPSESSIONSTATSUNKNOWNMESTYPEERRORS
:
979 return SNMP_INTEGER(ctl_nbr
->stats
.unknown_msg
);
980 case MPLSLDPSESSIONSTATSUNKNOWNTLVERRORS
:
981 return SNMP_INTEGER(ctl_nbr
->stats
.unknown_tlv
);
989 static struct variable ldpe_variables
[] = {
990 {MPLS_LDP_LSR_ID
, STRING
, RONLY
, ldpLsrId
, 3, {1, 1, 1}},
991 {MPLS_LDP_LSR_LOOP_DETECTION_CAPABLE
, INTEGER
, RONLY
,
992 ldpLoopDetectCap
, 3, {1, 1, 2}},
993 {MPLS_LDP_ENTITY_LAST_CHANGE
, TIMESTAMP
, RONLY
, ldpEntityLastChange
,
995 {MPLS_LDP_ENTITY_INDEX_NEXT
, UNSIGNED32
, RONLY
, ldpEntityIndexNext
,
998 /* MPLS LDP mplsLdpEntityTable. */
999 {MPLSLDPENTITYLDPID
, STRING
, RONLY
, ldpEntityTable
,
1000 5, {1, 2, 3, 1, 1}},
1001 {MPLSLDPENTITYINDEX
, UNSIGNED32
, RONLY
, ldpEntityTable
,
1002 5, {1, 2, 3, 1, 2}},
1003 {MPLSLDPENTITYPROTOCOLVERSION
, UNSIGNED32
, RONLY
, ldpEntityTable
,
1004 5, {1, 2, 3, 1, 3}},
1005 {MPLSLDPENTITYADMINSTATUS
, INTEGER
, RONLY
, ldpEntityTable
,
1006 5, {1, 2, 3, 1, 4}},
1007 {MPLSLDPENTITYOPERSTATUS
, INTEGER
, RONLY
, ldpEntityTable
,
1008 5, {1, 2, 3, 1, 5}},
1009 {MPLSLDPENTITYTCPPORT
, UNSIGNED32
, RONLY
, ldpEntityTable
,
1010 5, {1, 2, 3, 1, 6}},
1011 {MPLSLDPENTITYUDPDSCPORT
, UNSIGNED32
, RONLY
, ldpEntityTable
,
1012 5, {1, 2, 3, 1, 7}},
1013 {MPLSLDPENTITYMAXPDULENGTH
, UNSIGNED32
, RONLY
, ldpEntityTable
,
1014 5, {1, 2, 3, 1, 8}},
1015 {MPLSLDPENTITYKEEPALIVEHOLDTIMER
, UNSIGNED32
, RONLY
, ldpEntityTable
,
1016 5, {1, 2, 3, 1, 9}},
1017 {MPLSLDPENTITYHELLOHOLDTIMER
, UNSIGNED32
, RONLY
, ldpEntityTable
,
1018 5, {1, 2, 3, 1, 10}},
1019 {MPLSLDPENTITYINITSESSIONTHRESHOLD
, INTEGER
, RONLY
, ldpEntityTable
,
1020 5, {1, 2, 3, 1, 11}},
1021 {MPLSLDPENTITYLABELDISTMETHOD
, INTEGER
, RONLY
, ldpEntityTable
,
1022 5, {1, 2, 3, 1, 12}},
1023 {MPLSLDPENTITYLABELRETENTIONMODE
, INTEGER
, RONLY
, ldpEntityTable
,
1024 5, {1, 2, 3, 1, 13}},
1025 {MPLSLDPENTITYPATHVECTORLIMIT
, INTEGER
, RONLY
, ldpEntityTable
,
1026 5, {1, 2, 3, 1, 14}},
1027 {MPLSLDPENTITYHOPCOUNTLIMIT
, INTEGER
, RONLY
, ldpEntityTable
,
1028 5, {1, 2, 3, 1, 15}},
1029 {MPLSLDPENTITYTRANSPORTADDRKIND
, INTEGER
, RONLY
, ldpEntityTable
,
1030 5, {1, 2, 3, 1, 16}},
1031 {MPLSLDPENTITYTARGETPEER
, INTEGER
, RONLY
, ldpEntityTable
,
1032 5, {1, 2, 3, 1, 17}},
1033 {MPLSLDPENTITYTARGETPEERADDRTYPE
, INTEGER
, RONLY
, ldpEntityTable
,
1034 5, {1, 2, 3, 1, 18}},
1035 {MPLSLDPENTITYTARGETPEERADDR
, STRING
, RONLY
, ldpEntityTable
,
1036 5, {1, 2, 3, 1, 19}},
1037 {MPLSLDPENTITYLABELTYPE
, INTEGER
, RONLY
, ldpEntityTable
,
1038 5, {1, 2, 3, 1, 20}},
1039 {MPLSLDPENTITYDISCONTINUITYTIME
, TIMESTAMP
, RONLY
, ldpEntityTable
,
1040 5, {1, 2, 3, 1, 21}},
1041 {MPLSLDPENTITYSTORAGETYPE
, INTEGER
, RONLY
, ldpEntityTable
,
1042 5, {1, 2, 3, 1, 22}},
1043 {MPLSLDPENTITYROWSTATUS
, INTEGER
, RONLY
, ldpEntityTable
,
1044 5, {1, 2, 3, 1, 23}},
1046 /* MPLS LDP mplsLdpEntityStatsTable. */
1047 { MPLSLDPENTITYSTATSSESSIONATTEMPTS
, COUNTER32
, RONLY
,
1048 ldpEntityStatsTable
, 5, {1, 2, 4, 1, 1}},
1049 { MPLSLDPENTITYSTATSSESSIONREJHELLO
, COUNTER32
, RONLY
,
1050 ldpEntityStatsTable
, 5, {1, 2, 4, 1, 2}},
1051 { MPLSLDPENTITYSTATSSESSIONREJAD
, COUNTER32
, RONLY
,
1052 ldpEntityStatsTable
, 5, {1, 2, 4, 1, 3}},
1053 { MPLSLDPENTITYSTATSSESSIONREJMAXPDU
, COUNTER32
, RONLY
,
1054 ldpEntityStatsTable
, 5, {1, 2, 4, 1, 4}},
1055 { MPLSLDPENTITYSTATSSESSIONREJLR
, COUNTER32
, RONLY
,
1056 ldpEntityStatsTable
, 5, {1, 2, 4, 1, 5}},
1057 { MPLSLDPENTITYSTATSBADLDPID
, COUNTER32
, RONLY
,
1058 ldpEntityStatsTable
, 5, {1, 2, 4, 1, 6}},
1059 { MPLSLDPENTITYSTATSBADPDULENGTH
, COUNTER32
, RONLY
,
1060 ldpEntityStatsTable
, 5, {1, 2, 4, 1, 7}},
1061 { MPLSLDPENTITYSTATSBADMSGLENGTH
, COUNTER32
, RONLY
,
1062 ldpEntityStatsTable
, 5, {1, 2, 4, 1, 8}},
1063 { MPLSLDPENTITYSTATSBADTLVLENGTH
, COUNTER32
, RONLY
,
1064 ldpEntityStatsTable
, 5, {1, 2, 4, 1, 9}},
1065 { MPLSLDPENTITYSTATSMALFORMEDTLV
, COUNTER32
, RONLY
,
1066 ldpEntityStatsTable
, 5, {1, 2, 4, 1, 10}},
1067 { MPLSLDPENTITYSTATSKEEPALIVEEXP
, COUNTER32
, RONLY
,
1068 ldpEntityStatsTable
, 5, {1, 2, 4, 1, 11}},
1069 { MPLSLDPENTITYSTATSSHUTDOWNRCVNOTIFY
, COUNTER32
, RONLY
,
1070 ldpEntityStatsTable
, 5, {1, 2, 4, 1, 12}},
1071 { MPLSLDPENTITYSTATSSHUTDOWNSENTNOTIFY
, COUNTER32
, RONLY
,
1072 ldpEntityStatsTable
, 5, {1, 2, 4, 1, 13}},
1074 /* MPLS LDP mplsLdpPeerTable */
1075 {MPLSLDPPEERLDPID
, STRING
, RONLY
, ldpPeerTable
, 5, {1, 3, 2, 1, 1}},
1076 {MPLSLDPPEERLABELDISTMETHOD
, INTEGER
, RONLY
, ldpPeerTable
,
1077 5, {1, 3, 2, 1, 2}},
1078 {MPLSLDPPEERPATHVECTORLIMIT
, INTEGER
, RONLY
, ldpPeerTable
,
1079 5, {1, 3, 2, 1, 3}},
1080 {MPLSLDPPEERTRANSPORTADDRTYPE
, INTEGER
, RONLY
, ldpPeerTable
,
1081 5, {1, 3, 2, 1, 4}},
1082 {MPLSLDPPEERTRANSPORTADDR
, STRING
, RONLY
, ldpPeerTable
,
1083 5, {1, 3, 2, 1, 5}},
1085 /* MPLS LDP mplsLdpSessionTable */
1086 {MPLSLDPSESSIONSTATELASTCHANGE
, TIMESTAMP
, RONLY
, ldpSessionTable
,
1087 5, {1, 3, 3, 1, 1}},
1088 {MPLSLDPSESSIONSTATE
, INTEGER
, RONLY
, ldpSessionTable
,
1089 5, {1, 3, 3, 1, 2}},
1090 {MPLSLDPSESSIONROLE
, INTEGER
, RONLY
, ldpSessionTable
,
1091 5, {1, 3, 3, 1, 3}},
1092 {MPLSLDPSESSIONPROTOCOLVERSION
, UNSIGNED32
, RONLY
, ldpSessionTable
,
1093 5, {1, 3, 3, 1, 4}},
1094 {MPLSLDPSESSIONKEEPALIVEHOLDTIMEREM
, INTEGER
, RONLY
, ldpSessionTable
,
1095 5, {1, 3, 3, 1, 5}},
1096 {MPLSLDPSESSIONKEEPALIVETIME
, UNSIGNED32
, RONLY
, ldpSessionTable
,
1097 5, {1, 3, 3, 1, 6}},
1098 {MPLSLDPSESSIONMAXPDULENGTH
, UNSIGNED32
, RONLY
, ldpSessionTable
,
1099 5, {1, 3, 3, 1, 7}},
1100 {MPLSLDPSESSIONDISCONTINUITYTIME
, TIMESTAMP
, RONLY
, ldpSessionTable
,
1101 5, {1, 3, 3, 1, 8}},
1103 /* MPLS LDP mplsLdpSessionStatsTable */
1104 {MPLSLDPSESSIONSTATSUNKNOWNMESTYPEERRORS
, COUNTER32
, RONLY
,
1105 ldpSessionStatsTable
, 5, {1, 3, 4, 1, 1}},
1106 {MPLSLDPSESSIONSTATSUNKNOWNTLVERRORS
, COUNTER32
, RONLY
,
1107 ldpSessionStatsTable
, 5, {1, 3, 4, 1, 2}},
1109 /* MPLS LDP mplsLdpHelloAdjacencyTable. */
1110 {MPLSLDPHELLOADJACENCYINDEX
, UNSIGNED32
, RONLY
,
1111 ldpHelloAdjacencyTable
, 6, {1, 3, 5, 1, 1, 1}},
1112 {MPLSLDPHELLOADJACENCYHOLDTIMEREM
, INTEGER
, RONLY
,
1113 ldpHelloAdjacencyTable
, 6, {1, 3, 5, 1, 1, 2}},
1114 {MPLSLDPHELLOADJACENCYHOLDTIME
, UNSIGNED32
, RONLY
,
1115 ldpHelloAdjacencyTable
, 6, {1, 3, 5, 1, 1, 3}},
1116 {MPLSLDPHELLOADJACENCYTYPE
, INTEGER
, RONLY
,
1117 ldpHelloAdjacencyTable
, 6, {1, 3, 5, 1, 1, 4}},
1120 static struct variable lde_variables
[] = {
1123 static struct trap_object ldpSessionTrapList
[] = {
1124 {5, {1, 3, 3, 1, MPLSLDPSESSIONSTATE
}},
1125 {5, {1, 3, 3, 1, MPLSLDPSESSIONDISCONTINUITYTIME
}},
1126 {5, {1, 3, 4, 1, MPLSLDPSESSIONSTATSUNKNOWNMESTYPEERRORS
}},
1127 {5, {1, 3, 4, 1, MPLSLDPSESSIONSTATSUNKNOWNTLVERRORS
}}};
1130 #define LDPINITSESSIONTHRESHOLDEXCEEDED 1
1131 #define LDPPATHVECTORLIMITMISMATCH 2
1132 #define LDPSESSIONUP 3
1133 #define LDPSESSIONDOWN 4
1136 ldpTrapSession(struct nbr
* nbr
, unsigned int sptrap
)
1138 oid index
[sizeof(oid
) * (LDP_PEER_ENTRY_MAX_IDX_LEN
+ 1)];
1140 struct in_addr entityLdpId
= {.s_addr
= 0};
1141 uint32_t entityIndex
= 0;
1142 struct in_addr peerLdpId
= {.s_addr
= 0};
1144 struct ctl_nbr
*ctl_nbr
= nbr_to_ctl(nbr
);
1146 entityLdpId
.s_addr
= ldp_rtr_id_get(leconf
);
1147 entityIndex
= LDP_DEFAULT_ENTITY_INDEX
;
1148 peerLdpId
= ctl_nbr
->id
;
1150 oid_copy_addr(index
, &entityLdpId
, sizeof(struct in_addr
));
1153 index
[6] = entityIndex
;
1154 oid_copy_addr(&index
[7], &peerLdpId
, sizeof(struct in_addr
));
1158 index
[LDP_PEER_ENTRY_MAX_IDX_LEN
] = 0;
1160 smux_trap(ldpe_variables
, array_size(ldpe_variables
), ldp_trap_oid
,
1161 array_size(ldp_trap_oid
), ldp_oid
,
1162 sizeof(ldp_oid
) / sizeof(oid
), index
,
1163 LDP_PEER_ENTRY_MAX_IDX_LEN
+ 1,
1164 ldpSessionTrapList
, array_size(ldpSessionTrapList
), sptrap
);
1168 ldpTrapSessionUp(struct nbr
* nbr
)
1170 ldpTrapSession(nbr
, LDPSESSIONUP
);
1174 ldpTrapSessionDown(struct nbr
* nbr
)
1176 ldpTrapSession(nbr
, LDPSESSIONDOWN
);
1179 static int ldp_snmp_agentx_enabled()
1181 main_imsg_compose_both(IMSG_AGENTX_ENABLED
, NULL
, 0);
1186 static int ldp_snmp_nbr_state_change(struct nbr
* nbr
, int old_state
)
1188 if (old_state
== nbr
->state
)
1191 if (nbr
->state
== NBR_STA_OPER
)
1192 ldpTrapSessionUp(nbr
);
1193 else if (old_state
== NBR_STA_OPER
)
1194 ldpTrapSessionDown(nbr
);
1199 static int ldp_snmp_init(struct thread_master
*tm
)
1201 hook_register(agentx_enabled
, ldp_snmp_agentx_enabled
);
1208 static int ldp_snmp_register_mib(struct thread_master
*tm
)
1210 static int registered
= 0;
1219 smux_agentx_enable();
1221 if (ldpd_process
== PROC_LDE_ENGINE
)
1222 REGISTER_MIB("mibII/ldp", lde_variables
, variable
, ldp_oid
);
1223 else if (ldpd_process
== PROC_LDP_ENGINE
) {
1224 REGISTER_MIB("mibII/ldp", ldpe_variables
, variable
, ldp_oid
);
1226 hook_register(ldp_nbr_state_change
, ldp_snmp_nbr_state_change
);
1232 static int ldp_snmp_module_init(void)
1234 if (ldpd_process
== PROC_MAIN
)
1235 hook_register(frr_late_init
, ldp_snmp_init
);
1237 hook_register(ldp_register_mib
, ldp_snmp_register_mib
);
1244 .version
= FRR_VERSION
,
1245 .description
= "ldp AgentX SNMP module",
1246 .init
= ldp_snmp_module_init
,