]> git.proxmox.com Git - mirror_frr.git/blob - bgpd/bgp_snmp_bgp4v2.c
projects / mirror_frr.git / blob
? search:


fe0c33251e6e2fd0127b48e3bd1c5d8e5f4d1ba0
[mirror_frr.git] / bgpd / bgp_snmp_bgp4v2.c
1 /* BGP4V2-MIB SNMP support
2 *
3 * Copyright (C) 2022 Donatas Abraitis <donatas@opensourcerouting.org>
4 *
5 * This file is part of GNU Zebra.
6 *
7 * GNU Zebra is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2, or (at your option) any
10 * later version.
11 *
12 * GNU Zebra is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with this program; see the file COPYING; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 #include <zebra.h>
23
24 #include <net-snmp/net-snmp-config.h>
25 #include <net-snmp/net-snmp-includes.h>
26
27 #include "if.h"
28 #include "log.h"
29 #include "prefix.h"
30 #include "command.h"
31 #include "thread.h"
32 #include "smux.h"
33 #include "filter.h"
34 #include "hook.h"
35 #include "libfrr.h"
36 #include "lib/version.h"
37
38 #include "bgpd/bgpd.h"
39 #include "bgpd/bgp_table.h"
40 #include "bgpd/bgp_aspath.h"
41 #include "bgpd/bgp_attr.h"
42 #include "bgpd/bgp_debug.h"
43 #include "bgpd/bgp_route.h"
44 #include "bgpd/bgp_fsm.h"
45 #include "bgpd/bgp_snmp.h"
46 #include "bgpd/bgp_snmp_bgp4v2.h"
47
48 SNMP_LOCAL_VARIABLES
49
50 static oid bgpv2_oid[] = {BGP4V2MIB};
51 static struct in_addr bgp_empty_addr = {};
52
53 static struct peer *peer_lookup_all_vrf(struct ipaddr *addr)
54 {
55 struct bgp *bgp;
56 struct peer *peer;
57 struct listnode *node;
58 struct listnode *bgpnode;
59
60 for (ALL_LIST_ELEMENTS_RO(bm->bgp, bgpnode, bgp)) {
61 for (ALL_LIST_ELEMENTS_RO(bgp->peer, node, peer)) {
62 switch (sockunion_family(&peer->su)) {
63 case AF_INET:
64 if (IPV4_ADDR_SAME(&peer->su.sin.sin_addr,
65 &addr->ip._v4_addr))
66 return peer;
67 break;
68 case AF_INET6:
69 if (IPV6_ADDR_SAME(&peer->su.sin6.sin6_addr,
70 &addr->ip._v6_addr))
71 return peer;
72 break;
73 default:
74 break;
75 }
76 }
77 }
78
79 return NULL;
80 }
81
82 static struct peer *peer_lookup_all_vrf_next(struct ipaddr *addr, oid *offset,
83 sa_family_t family)
84 {
85 struct bgp *bgp;
86 struct peer *peer;
87 struct peer *next_peer = NULL;
88 struct listnode *node;
89 struct listnode *bgpnode;
90
91 for (ALL_LIST_ELEMENTS_RO(bm->bgp, bgpnode, bgp)) {
92 for (ALL_LIST_ELEMENTS_RO(bgp->peer, node, peer)) {
93 sa_family_t peer_family = sockunion_family(&peer->su);
94
95 if (peer_family != family)
96 continue;
97
98 switch (sockunion_family(&peer->su)) {
99 case AF_INET:
100 oid2in_addr(offset, IN_ADDR_SIZE,
101 &addr->ip._v4_addr);
102 if (IPV4_ADDR_CMP(&peer->su.sin.sin_addr,
103 &addr->ip._v4_addr) < 0 ||
104 IPV4_ADDR_SAME(&peer->su.sin.sin_addr,
105 &addr->ip._v4_addr))
106 continue;
107
108 if (!next_peer ||
109 IPV4_ADDR_CMP(&next_peer->su.sin.sin_addr,
110 &peer->su.sin.sin_addr) > 0)
111 next_peer = peer;
112
113 break;
114 case AF_INET6:
115 oid2in6_addr(offset, &addr->ip._v6_addr);
116 if (IPV6_ADDR_CMP(&peer->su.sin6.sin6_addr,
117 &addr->ip._v6_addr) < 0 ||
118 IPV6_ADDR_SAME(&peer->su.sin6.sin6_addr,
119 &addr->ip._v6_addr))
120 continue;
121
122 if (!next_peer ||
123 IPV6_ADDR_CMP(&next_peer->su.sin6.sin6_addr,
124 &peer->su.sin6.sin6_addr) > 0)
125 next_peer = peer;
126
127 break;
128 default:
129 break;
130 }
131 }
132 }
133
134 if (next_peer)
135 return next_peer;
136
137 return NULL;
138 }
139
140 static struct peer *bgpv2PeerTable_lookup(struct variable *v, oid name[],
141 size_t *length, int exact,
142 struct ipaddr *addr)
143 {
144 struct peer *peer = NULL;
145 size_t namelen = v ? v->namelen : BGP4V2_PEER_ENTRY_OFFSET;
146 oid *offset = name + namelen;
147 sa_family_t family = name[namelen - 1] == 4 ? AF_INET : AF_INET6;
148 int afi_len = IN_ADDR_SIZE;
149 size_t offsetlen = *length - namelen;
150
151 if (family == AF_INET6)
152 afi_len = IN6_ADDR_SIZE;
153
154 /* Somehow with net-snmp 5.7.3, every OID item in an array
155 * is uninitialized and has a max random value, let's zero it.
156 * With 5.8, 5.9, it works fine even without this hack.
157 */
158 if (!offsetlen) {
159 for (int i = 0; i < afi_len; i++)
160 *(offset + i) = 0;
161 }
162
163 if (exact) {
164 if (family == AF_INET) {
165 oid2in_addr(offset, afi_len, &addr->ip._v4_addr);
166 peer = peer_lookup_all_vrf(addr);
167 return peer;
168 } else if (family == AF_INET6) {
169 oid2in6_addr(offset, &addr->ip._v6_addr);
170 return peer_lookup_all_vrf(addr);
171 }
172 } else {
173 peer = peer_lookup_all_vrf_next(addr, offset, family);
174 if (peer == NULL)
175 return NULL;
176
177 switch (sockunion_family(&peer->su)) {
178 case AF_INET:
179 oid_copy_in_addr(offset, &peer->su.sin.sin_addr);
180 *length = afi_len + namelen;
181 return peer;
182 case AF_INET6:
183 oid_copy_in6_addr(offset, &peer->su.sin6.sin6_addr);
184 *length = afi_len + namelen;
185 return peer;
186 default:
187 break;
188 }
189 }
190
191 return NULL;
192 }
193
194 static uint8_t *bgpv2PeerTable(struct variable *v, oid name[], size_t *length,
195 int exact, size_t *var_len,
196 WriteMethod **write_method)
197 {
198 struct peer *peer;
199 struct ipaddr addr = {};
200
201 if (smux_header_table(v, name, length, exact, var_len, write_method) ==
202 MATCH_FAILED)
203 return NULL;
204
205 peer = bgpv2PeerTable_lookup(v, name, length, exact, &addr);
206 if (!peer)
207 return NULL;
208
209 switch (v->magic) {
210 case BGP4V2_PEER_INSTANCE:
211 return SNMP_INTEGER(peer->bgp->vrf_id);
212 case BGP4V2_PEER_LOCAL_ADDR_TYPE:
213 if (peer->su_local)
214 return SNMP_INTEGER(peer->su_local->sa.sa_family ==
215 AF_INET
216 ? AFI_IP
217 : AFI_IP6);
218 else
219 return SNMP_INTEGER(0);
220 case BGP4V2_PEER_LOCAL_ADDR:
221 if (peer->su_local)
222 if (peer->su_local->sa.sa_family == AF_INET)
223 return SNMP_IPADDRESS(
224 peer->su_local->sin.sin_addr);
225 else
226 return SNMP_IP6ADDRESS(
227 peer->su_local->sin6.sin6_addr);
228 else
229 return SNMP_IPADDRESS(bgp_empty_addr);
230 case BGP4V2_PEER_REMOTE_ADDR_TYPE:
231 if (peer->su_remote)
232 return SNMP_INTEGER(peer->su_remote->sa.sa_family ==
233 AF_INET
234 ? AFI_IP
235 : AFI_IP6);
236 else
237 return SNMP_INTEGER(0);
238 case BGP4V2_PEER_REMOTE_ADDR:
239 if (peer->su_remote)
240 if (peer->su_remote->sa.sa_family == AF_INET)
241 return SNMP_IPADDRESS(
242 peer->su_remote->sin.sin_addr);
243 else
244 return SNMP_IP6ADDRESS(
245 peer->su_remote->sin6.sin6_addr);
246 else
247 return SNMP_IPADDRESS(bgp_empty_addr);
248 case BGP4V2_PEER_LOCAL_PORT:
249 if (peer->su_local)
250 if (peer->su_local->sa.sa_family == AF_INET)
251 return SNMP_INTEGER(
252 ntohs(peer->su_local->sin.sin_port));
253 else
254 return SNMP_INTEGER(
255 ntohs(peer->su_local->sin6.sin6_port));
256 else
257 return SNMP_INTEGER(0);
258 case BGP4V2_PEER_LOCAL_AS:
259 return SNMP_INTEGER(peer->local_as);
260 case BGP4V2_PEER_LOCAL_IDENTIFIER:
261 return SNMP_IPADDRESS(peer->local_id);
262 case BGP4V2_PEER_REMOTE_PORT:
263 if (peer->su_remote)
264 if (peer->su_remote->sa.sa_family == AF_INET)
265 return SNMP_INTEGER(
266 ntohs(peer->su_remote->sin.sin_port));
267 else
268 return SNMP_INTEGER(
269 ntohs(peer->su_remote->sin6.sin6_port));
270 else
271 return SNMP_INTEGER(0);
272 case BGP4V2_PEER_REMOTE_AS:
273 return SNMP_INTEGER(peer->as);
274 case BGP4V2_PEER_REMOTE_IDENTIFIER:
275 return SNMP_IPADDRESS(peer->remote_id);
276 case BGP4V2_PEER_ADMIN_STATUS:
277 #define BGP_PEER_ADMIN_STATUS_HALTED 1
278 #define BGP_PEER_ADMIN_STATUS_RUNNING 2
279 if (BGP_PEER_START_SUPPRESSED(peer))
280 return SNMP_INTEGER(BGP_PEER_ADMIN_STATUS_HALTED);
281 else
282 return SNMP_INTEGER(BGP_PEER_ADMIN_STATUS_RUNNING);
283 case BGP4V2_PEER_STATE:
284 return SNMP_INTEGER(peer->status);
285 case BGP4V2_PEER_DESCRIPTION:
286 if (peer->desc)
287 return SNMP_STRING(peer->desc);
288 break;
289 default:
290 break;
291 }
292
293 return NULL;
294 }
295
296 static uint8_t *bgpv2PeerErrorsTable(struct variable *v, oid name[],
297 size_t *length, int exact, size_t *var_len,
298 WriteMethod **write_method)
299 {
300 struct peer *peer;
301 struct ipaddr addr = {};
302
303 if (smux_header_table(v, name, length, exact, var_len, write_method) ==
304 MATCH_FAILED)
305 return NULL;
306
307 peer = bgpv2PeerTable_lookup(v, name, length, exact, &addr);
308 if (!peer)
309 return NULL;
310
311 switch (v->magic) {
312 case BGP4V2_PEER_LAST_ERROR_CODE_RECEIVED:
313 if (peer->last_reset == PEER_DOWN_NOTIFY_RECEIVED)
314 return SNMP_INTEGER(peer->notify.code);
315 else
316 return SNMP_INTEGER(0);
317 case BGP4V2_PEER_LAST_ERROR_SUBCODE_RECEIVED:
318 if (peer->last_reset == PEER_DOWN_NOTIFY_RECEIVED)
319 return SNMP_INTEGER(peer->notify.subcode);
320 else
321 return SNMP_INTEGER(0);
322 case BGP4V2_PEER_LAST_ERROR_RECEIVED_TIME:
323 if (peer->last_reset == PEER_DOWN_NOTIFY_RECEIVED)
324 return SNMP_INTEGER(peer->resettime);
325 else
326 return SNMP_INTEGER(0);
327 case BGP4V2_PEER_LAST_ERROR_RECEIVED_TEXT:
328 if (peer->last_reset == PEER_DOWN_NOTIFY_RECEIVED) {
329 struct bgp_notify notify = peer->notify;
330 char msg_buf[255];
331 const char *msg_str = NULL;
332
333 if (notify.code == BGP_NOTIFY_CEASE &&
334 (notify.subcode ==
335 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN ||
336 notify.subcode == BGP_NOTIFY_CEASE_ADMIN_RESET)) {
337 msg_str = bgp_notify_admin_message(
338 msg_buf, sizeof(msg_buf),
339 (uint8_t *)notify.data, notify.length);
340 return SNMP_STRING(msg_str);
341 }
342 }
343 return SNMP_STRING("");
344 case BGP4V2_PEER_LAST_ERROR_RECEIVED_DATA:
345 if (peer->last_reset == PEER_DOWN_NOTIFY_RECEIVED)
346 return SNMP_STRING(peer->notify.data);
347 else
348 return SNMP_STRING("");
349 case BGP4V2_PEER_LAST_ERROR_CODE_SENT:
350 if (peer->last_reset != PEER_DOWN_NOTIFY_RECEIVED)
351 return SNMP_INTEGER(peer->notify.code);
352 else
353 return SNMP_INTEGER(0);
354 case BGP4V2_PEER_LAST_ERROR_SUBCODE_SENT:
355 if (peer->last_reset != PEER_DOWN_NOTIFY_RECEIVED)
356 return SNMP_INTEGER(peer->notify.subcode);
357 else
358 return SNMP_INTEGER(0);
359 case BGP4V2_PEER_LAST_ERROR_SENT_TIME:
360 if (peer->last_reset != PEER_DOWN_NOTIFY_RECEIVED)
361 return SNMP_INTEGER(peer->resettime);
362 else
363 return SNMP_INTEGER(0);
364 case BGP4V2_PEER_LAST_ERROR_SENT_TEXT:
365 if (peer->last_reset == PEER_DOWN_NOTIFY_SEND ||
366 peer->last_reset == PEER_DOWN_RTT_SHUTDOWN ||
367 peer->last_reset == PEER_DOWN_USER_SHUTDOWN) {
368 struct bgp_notify notify = peer->notify;
369 char msg_buf[255];
370 const char *msg_str = NULL;
371
372 if (notify.code == BGP_NOTIFY_CEASE &&
373 (notify.subcode ==
374 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN ||
375 notify.subcode == BGP_NOTIFY_CEASE_ADMIN_RESET)) {
376 msg_str = bgp_notify_admin_message(
377 msg_buf, sizeof(msg_buf),
378 (uint8_t *)notify.data, notify.length);
379 return SNMP_STRING(msg_str);
380 }
381 }
382 return SNMP_STRING("");
383 case BGP4V2_PEER_LAST_ERROR_SENT_DATA:
384 if ((peer->last_reset == PEER_DOWN_NOTIFY_SEND ||
385 peer->last_reset == PEER_DOWN_RTT_SHUTDOWN ||
386 peer->last_reset == PEER_DOWN_USER_SHUTDOWN) &&
387 peer->notify.data)
388 return SNMP_STRING(peer->notify.data);
389 else
390 return SNMP_STRING("");
391 default:
392 break;
393 }
394
395 return NULL;
396 }
397
398 static uint8_t *bgpv2PeerEventTimesTable(struct variable *v, oid name[],
399 size_t *length, int exact,
400 size_t *var_len,
401 WriteMethod **write_method)
402 {
403 struct peer *peer;
404 struct ipaddr addr = {};
405
406 if (smux_header_table(v, name, length, exact, var_len, write_method) ==
407 MATCH_FAILED)
408 return NULL;
409
410 peer = bgpv2PeerTable_lookup(v, name, length, exact, &addr);
411 if (!peer)
412 return NULL;
413
414 switch (v->magic) {
415 case BGP4V2_PEER_FSM_ESTABLISHED_TIME:
416 if (!peer->uptime)
417 return SNMP_INTEGER(0);
418 else
419 return SNMP_INTEGER(monotime(NULL) - peer->uptime);
420 case BGP4V2_PEER_PEER_IN_UPDATES_ELAPSED_TIME:
421 if (!peer->update_time)
422 return SNMP_INTEGER(0);
423 else
424 return SNMP_INTEGER(monotime(NULL) - peer->update_time);
425 default:
426 break;
427 }
428
429 return NULL;
430 }
431
432 static struct bgp_path_info *
433 bgp4v2PathAttrLookup(struct variable *v, oid name[], size_t *length,
434 struct bgp *bgp, struct prefix *addr, int exact)
435 {
436 oid *offset;
437 int offsetlen;
438 struct bgp_path_info *path, *min;
439 struct bgp_dest *dest;
440 union sockunion su;
441 unsigned int len;
442 struct ipaddr paddr = {};
443 size_t namelen = v ? v->namelen : BGP4V2_NLRI_ENTRY_OFFSET;
444 sa_family_t family = name[namelen - 1] == 4 ? AF_INET : AF_INET6;
445 afi_t afi = AFI_IP;
446 size_t afi_len = IN_ADDR_SIZE;
447
448 if (family == AF_INET6) {
449 afi = AFI_IP6;
450 afi_len = IN6_ADDR_SIZE;
451 }
452
453 #define BGP_NLRI_ENTRY_OFFSET (afi_len + 1 + afi_len)
454
455 sockunion_init(&su);
456
457 if (exact) {
458 if (*length - namelen != BGP_NLRI_ENTRY_OFFSET)
459 return NULL;
460
461 /* Set OID offset for prefix */
462 offset = name + namelen;
463 if (family == AF_INET)
464 oid2in_addr(offset, afi_len, &addr->u.prefix4);
465 else
466 oid2in6_addr(offset, &addr->u.prefix6);
467 offset += afi_len;
468
469 /* Prefix length */
470 addr->prefixlen = *offset;
471 addr->family = family;
472 offset++;
473
474 /* Peer address */
475 su.sin.sin_family = family;
476 if (family == AF_INET)
477 oid2in_addr(offset, afi_len, &su.sin.sin_addr);
478 else
479 oid2in6_addr(offset, &su.sin6.sin6_addr);
480
481 /* Lookup node */
482 dest = bgp_node_lookup(bgp->rib[afi][SAFI_UNICAST], addr);
483 if (dest) {
484 for (path = bgp_dest_get_bgp_path_info(dest); path;
485 path = path->next)
486 if (sockunion_same(&path->peer->su, &su))
487 return path;
488
489 bgp_dest_unlock_node(dest);
490 }
491
492 return NULL;
493 }
494
495 offset = name + namelen;
496 offsetlen = *length - namelen;
497 len = offsetlen;
498
499 if (offsetlen == 0) {
500 dest = bgp_table_top(bgp->rib[afi][SAFI_UNICAST]);
501 } else {
502 if (len > afi_len)
503 len = afi_len;
504
505 if (family == AF_INET)
506 oid2in_addr(offset, len, &addr->u.prefix4);
507 else
508 oid2in6_addr(offset, &addr->u.prefix6);
509
510 offset += afi_len;
511 offsetlen -= afi_len;
512
513 if (offsetlen > 0)
514 addr->prefixlen = *offset;
515 else
516 addr->prefixlen = len * 8;
517
518 addr->family = family;
519
520 dest = bgp_node_get(bgp->rib[afi][SAFI_UNICAST], addr);
521
522 offset++;
523 offsetlen--;
524 }
525
526 if (offsetlen > 0) {
527 len = offsetlen;
528 if (len > afi_len)
529 len = afi_len;
530
531 if (family == AF_INET)
532 oid2in_addr(offset, len, &paddr.ip._v4_addr);
533 else
534 oid2in6_addr(offset, &paddr.ip._v6_addr);
535 } else {
536 if (family == AF_INET)
537 memset(&paddr.ip._v4_addr, 0, afi_len);
538 else
539 memset(&paddr.ip._v6_addr, 0, afi_len);
540 }
541
542 if (!dest)
543 return NULL;
544
545 do {
546 min = NULL;
547
548 for (path = bgp_dest_get_bgp_path_info(dest); path;
549 path = path->next) {
550 sa_family_t path_family =
551 sockunion_family(&path->peer->su);
552
553 if (path_family == AF_INET &&
554 IPV4_ADDR_CMP(&paddr.ip._v4_addr,
555 &path->peer->su.sin.sin_addr) < 0) {
556 if (!min ||
557 (min &&
558 IPV4_ADDR_CMP(
559 &path->peer->su.sin.sin_addr,
560 &min->peer->su.sin.sin_addr) < 0))
561 min = path;
562 } else if (path_family == AF_INET6 &&
563 IPV6_ADDR_CMP(
564 &paddr.ip._v6_addr,
565 &path->peer->su.sin6.sin6_addr) <
566 0) {
567 if (!min ||
568 (min &&
569 IPV6_ADDR_CMP(
570 &path->peer->su.sin6.sin6_addr,
571 &min->peer->su.sin6.sin6_addr) <
572 0))
573 min = path;
574 }
575 }
576
577 if (min) {
578 const struct prefix *rn_p = bgp_dest_get_prefix(dest);
579
580 *length = namelen + BGP_NLRI_ENTRY_OFFSET;
581
582 offset = name + namelen;
583
584 /* Encode prefix into OID */
585 if (family == AF_INET)
586 oid_copy_in_addr(offset, &rn_p->u.prefix4);
587 else
588 oid_copy_in6_addr(offset, &rn_p->u.prefix6);
589
590 offset += afi_len;
591 *offset = rn_p->prefixlen;
592 offset++;
593
594 /* Encode peer's IP into OID */
595 if (family == AF_INET) {
596 oid_copy_in_addr(offset,
597 &min->peer->su.sin.sin_addr);
598 addr->u.prefix4 = rn_p->u.prefix4;
599 } else {
600 oid_copy_in6_addr(
601 offset, &min->peer->su.sin6.sin6_addr);
602 addr->u.prefix6 = rn_p->u.prefix6;
603 }
604
605 addr->prefixlen = rn_p->prefixlen;
606 addr->family = rn_p->family;
607
608 bgp_dest_unlock_node(dest);
609
610 return min;
611 }
612
613 if (family == AF_INET)
614 memset(&paddr.ip._v4_addr, 0, afi_len);
615 else
616 memset(&paddr.ip._v6_addr, 0, afi_len);
617 } while ((dest = bgp_route_next(dest)));
618
619 return NULL;
620 }
621
622 static uint8_t *bgp4v2PathAttrTable(struct variable *v, oid name[],
623 size_t *length, int exact, size_t *var_len,
624 WriteMethod **write_method)
625 {
626 struct bgp *bgp;
627 struct bgp_path_info *path;
628 struct peer_af *paf = NULL;
629 struct prefix addr = {};
630 const struct prefix *prefix = NULL;
631 enum bgp_af_index index;
632
633 bgp = bgp_get_default();
634 if (!bgp)
635 return NULL;
636
637 if (smux_header_table(v, name, length, exact, var_len, write_method) ==
638 MATCH_FAILED)
639 return NULL;
640
641 path = bgp4v2PathAttrLookup(v, name, length, bgp, &addr, exact);
642 if (!path)
643 return NULL;
644
645 prefix = bgp_dest_get_prefix(path->net);
646
647 AF_FOREACH (index) {
648 paf = path->peer->peer_af_array[index];
649 if (paf)
650 break;
651 }
652
653 switch (v->magic) {
654 case BGP4V2_NLRI_INDEX:
655 return SNMP_INTEGER(0);
656 case BGP4V2_NLRI_AFI:
657 if (paf)
658 return SNMP_INTEGER(paf->afi);
659 else
660 return SNMP_INTEGER(0);
661 case BGP4V2_NLRI_SAFI:
662 if (paf)
663 return SNMP_INTEGER(paf->safi);
664 else
665 return SNMP_INTEGER(0);
666 case BGP4V2_NLRI_PREFIX_TYPE:
667 if (paf)
668 return SNMP_INTEGER(paf->afi);
669 else
670 return SNMP_INTEGER(0);
671 case BGP4V2_NLRI_PREFIX:
672 if (prefix->family == AF_INET6)
673 return SNMP_IP6ADDRESS(prefix->u.prefix6);
674 else
675 return SNMP_IPADDRESS(prefix->u.prefix4);
676 case BGP4V2_NLRI_PREFIX_LEN:
677 return SNMP_INTEGER(prefix->prefixlen);
678 case BGP4V2_NLRI_BEST:
679 if (CHECK_FLAG(path->flags, BGP_PATH_SELECTED))
680 return SNMP_INTEGER(1);
681 else
682 return SNMP_INTEGER(0);
683 case BGP4V2_NLRI_CALC_LOCAL_PREF:
684 if (CHECK_FLAG(path->attr->flag,
685 ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF)))
686 return SNMP_INTEGER(path->attr->local_pref);
687 else
688 return SNMP_INTEGER(0);
689 case BGP4V2_NLRI_ORIGIN:
690 switch (path->attr->origin) {
691 case BGP_ORIGIN_IGP:
692 return SNMP_INTEGER(1);
693 case BGP_ORIGIN_EGP:
694 return SNMP_INTEGER(2);
695 case BGP_ORIGIN_INCOMPLETE:
696 return SNMP_INTEGER(3);
697 default:
698 return SNMP_INTEGER(0);
699 }
700 case BGP4V2_NLRI_NEXT_HOP_ADDR_TYPE:
701 switch (path->attr->mp_nexthop_len) {
702 case BGP_ATTR_NHLEN_IPV4:
703 return SNMP_INTEGER(1);
704 case BGP_ATTR_NHLEN_IPV6_GLOBAL:
705 return SNMP_INTEGER(2);
706 case BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL:
707 if (CHECK_FLAG(path->attr->nh_flag,
708 BGP_ATTR_NH_MP_PREFER_GLOBAL))
709 return SNMP_INTEGER(2);
710 else
711 return SNMP_INTEGER(4);
712 default:
713 return SNMP_INTEGER(1);
714 }
715 case BGP4V2_NLRI_NEXT_HOP_ADDR:
716 switch (path->attr->mp_nexthop_len) {
717 case BGP_ATTR_NHLEN_IPV4:
718 return SNMP_IPADDRESS(path->attr->mp_nexthop_global_in);
719 case BGP_ATTR_NHLEN_IPV6_GLOBAL:
720 return SNMP_IP6ADDRESS(path->attr->mp_nexthop_global);
721 case BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL:
722 if (CHECK_FLAG(path->attr->nh_flag,
723 BGP_ATTR_NH_MP_PREFER_GLOBAL))
724 return SNMP_IP6ADDRESS(
725 path->attr->mp_nexthop_global);
726 else
727 return SNMP_IP6ADDRESS(
728 path->attr->mp_nexthop_local);
729 default:
730 return SNMP_IPADDRESS(path->attr->nexthop);
731 }
732 break;
733 case BGP4V2_NLRI_LINK_LOCAL_NEXT_HOP_ADDR_TYPE:
734 case BGP4V2_NLRI_LINK_LOCAL_NEXT_HOP_ADDR:
735 /* Not properly defined in specification what should be here. */
736 break;
737 case BGP4V2_NLRI_LOCAL_PREF_PRESENT:
738 if (CHECK_FLAG(path->attr->flag,
739 ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF)))
740 return SNMP_INTEGER(1);
741 else
742 return SNMP_INTEGER(0);
743 case BGP4V2_NLRI_LOCAL_PREF:
744 if (CHECK_FLAG(path->attr->flag,
745 ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF)))
746 return SNMP_INTEGER(path->attr->local_pref);
747 else
748 return SNMP_INTEGER(0);
749 case BGP4V2_NLRI_MED_PRESENT:
750 if (CHECK_FLAG(path->attr->flag,
751 ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC)))
752 return SNMP_INTEGER(1);
753 else
754 return SNMP_INTEGER(0);
755 case BGP4V2_NLRI_MED:
756 if (CHECK_FLAG(path->attr->flag,
757 ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC)))
758 return SNMP_INTEGER(path->attr->med);
759 else
760 return SNMP_INTEGER(0);
761 case BGP4V2_NLRI_ATOMIC_AGGREGATE:
762 if (CHECK_FLAG(path->attr->flag,
763 ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE)))
764 return SNMP_INTEGER(1);
765 else
766 return SNMP_INTEGER(0);
767 case BGP4V2_NLRI_AGGREGATOR_PRESENT:
768 if (CHECK_FLAG(path->attr->flag,
769 ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR)))
770 return SNMP_INTEGER(1);
771 else
772 return SNMP_INTEGER(0);
773 case BGP4V2_NLRI_AGGREGATOR_AS:
774 if (CHECK_FLAG(path->attr->flag,
775 ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR)))
776 return SNMP_INTEGER(path->attr->aggregator_as);
777 else
778 return SNMP_INTEGER(0);
779 case BGP4V2_NLRI_AGGREGATOR_ADDR:
780 if (CHECK_FLAG(path->attr->flag,
781 ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR)))
782 return SNMP_IPADDRESS(path->attr->aggregator_addr);
783 else
784 return SNMP_IPADDRESS(bgp_empty_addr);
785 case BGP4V2_NLRI_AS_PATH_CALC_LENGTH:
786 return SNMP_INTEGER(path->attr->aspath->segments->length);
787 case BGP4V2_NLRI_AS_PATH:
788 return aspath_snmp_pathseg(path->attr->aspath, var_len);
789 case BGP4V2_NLRI_PATH_ATTR_UNKNOWN:
790 *var_len = 0;
791 return NULL;
792 }
793 return NULL;
794 }
795
796 static struct variable bgpv2_variables[] = {
797 /* bgp4V2PeerEntry */
798 {BGP4V2_PEER_INSTANCE,
799 ASN_UNSIGNED,
800 RONLY,
801 bgpv2PeerTable,
802 6,
803 {1, 2, 1, BGP4V2_PEER_INSTANCE, 1, 4}},
804 {BGP4V2_PEER_INSTANCE,
805 ASN_UNSIGNED,
806 RONLY,
807 bgpv2PeerTable,
808 6,
809 {1, 2, 1, BGP4V2_PEER_INSTANCE, 2, 16}},
810 {BGP4V2_PEER_LOCAL_ADDR_TYPE,
811 ASN_INTEGER,
812 RONLY,
813 bgpv2PeerTable,
814 6,
815 {1, 2, 1, BGP4V2_PEER_LOCAL_ADDR_TYPE, 1, 4}},
816 {BGP4V2_PEER_LOCAL_ADDR_TYPE,
817 ASN_INTEGER,
818 RONLY,
819 bgpv2PeerTable,
820 6,
821 {1, 2, 1, BGP4V2_PEER_LOCAL_ADDR_TYPE, 2, 16}},
822 {BGP4V2_PEER_LOCAL_ADDR,
823 ASN_OCTET_STR,
824 RONLY,
825 bgpv2PeerTable,
826 6,
827 {1, 2, 1, BGP4V2_PEER_LOCAL_ADDR, 1, 4}},
828 {BGP4V2_PEER_LOCAL_ADDR,
829 ASN_OCTET_STR,
830 RONLY,
831 bgpv2PeerTable,
832 6,
833 {1, 2, 1, BGP4V2_PEER_LOCAL_ADDR, 2, 16}},
834 {BGP4V2_PEER_REMOTE_ADDR_TYPE,
835 ASN_INTEGER,
836 RONLY,
837 bgpv2PeerTable,
838 6,
839 {1, 2, 1, BGP4V2_PEER_REMOTE_ADDR_TYPE, 1, 4}},
840 {BGP4V2_PEER_REMOTE_ADDR_TYPE,
841 ASN_INTEGER,
842 RONLY,
843 bgpv2PeerTable,
844 6,
845 {1, 2, 1, BGP4V2_PEER_REMOTE_ADDR_TYPE, 2, 16}},
846 {BGP4V2_PEER_REMOTE_ADDR,
847 ASN_OCTET_STR,
848 RONLY,
849 bgpv2PeerTable,
850 6,
851 {1, 2, 1, BGP4V2_PEER_REMOTE_ADDR, 1, 4}},
852 {BGP4V2_PEER_REMOTE_ADDR,
853 ASN_OCTET_STR,
854 RONLY,
855 bgpv2PeerTable,
856 6,
857 {1, 2, 1, BGP4V2_PEER_REMOTE_ADDR, 2, 16}},
858 {BGP4V2_PEER_LOCAL_PORT,
859 ASN_UNSIGNED,
860 RONLY,
861 bgpv2PeerTable,
862 6,
863 {1, 2, 1, BGP4V2_PEER_LOCAL_PORT, 1, 4}},
864 {BGP4V2_PEER_LOCAL_PORT,
865 ASN_UNSIGNED,
866 RONLY,
867 bgpv2PeerTable,
868 6,
869 {1, 2, 1, BGP4V2_PEER_LOCAL_PORT, 2, 16}},
870 {BGP4V2_PEER_LOCAL_AS,
871 ASN_UNSIGNED,
872 RONLY,
873 bgpv2PeerTable,
874 6,
875 {1, 2, 1, BGP4V2_PEER_LOCAL_AS, 1, 4}},
876 {BGP4V2_PEER_LOCAL_AS,
877 ASN_UNSIGNED,
878 RONLY,
879 bgpv2PeerTable,
880 6,
881 {1, 2, 1, BGP4V2_PEER_LOCAL_AS, 2, 16}},
882 {BGP4V2_PEER_LOCAL_IDENTIFIER,
883 ASN_OCTET_STR,
884 RONLY,
885 bgpv2PeerTable,
886 6,
887 {1, 2, 1, BGP4V2_PEER_LOCAL_IDENTIFIER, 1, 4}},
888 {BGP4V2_PEER_LOCAL_IDENTIFIER,
889 ASN_OCTET_STR,
890 RONLY,
891 bgpv2PeerTable,
892 6,
893 {1, 2, 1, BGP4V2_PEER_LOCAL_IDENTIFIER, 2, 16}},
894 {BGP4V2_PEER_REMOTE_PORT,
895 ASN_UNSIGNED,
896 RONLY,
897 bgpv2PeerTable,
898 6,
899 {1, 2, 1, BGP4V2_PEER_REMOTE_PORT, 1, 4}},
900 {BGP4V2_PEER_REMOTE_PORT,
901 ASN_UNSIGNED,
902 RONLY,
903 bgpv2PeerTable,
904 6,
905 {1, 2, 1, BGP4V2_PEER_REMOTE_PORT, 2, 16}},
906 {BGP4V2_PEER_REMOTE_AS,
907 ASN_UNSIGNED,
908 RONLY,
909 bgpv2PeerTable,
910 6,
911 {1, 2, 1, BGP4V2_PEER_REMOTE_AS, 1, 4}},
912 {BGP4V2_PEER_REMOTE_AS,
913 ASN_UNSIGNED,
914 RONLY,
915 bgpv2PeerTable,
916 6,
917 {1, 2, 1, BGP4V2_PEER_REMOTE_AS, 2, 16}},
918 {BGP4V2_PEER_REMOTE_IDENTIFIER,
919 ASN_OCTET_STR,
920 RONLY,
921 bgpv2PeerTable,
922 6,
923 {1, 2, 1, BGP4V2_PEER_REMOTE_IDENTIFIER, 1, 4}},
924 {BGP4V2_PEER_REMOTE_IDENTIFIER,
925 ASN_OCTET_STR,
926 RONLY,
927 bgpv2PeerTable,
928 6,
929 {1, 2, 1, BGP4V2_PEER_REMOTE_IDENTIFIER, 2, 16}},
930 {BGP4V2_PEER_ADMIN_STATUS,
931 ASN_INTEGER,
932 RONLY,
933 bgpv2PeerTable,
934 6,
935 {1, 2, 1, BGP4V2_PEER_ADMIN_STATUS, 1, 4}},
936 {BGP4V2_PEER_ADMIN_STATUS,
937 ASN_INTEGER,
938 RONLY,
939 bgpv2PeerTable,
940 6,
941 {1, 2, 1, BGP4V2_PEER_ADMIN_STATUS, 2, 16}},
942 {BGP4V2_PEER_STATE,
943 ASN_INTEGER,
944 RONLY,
945 bgpv2PeerTable,
946 6,
947 {1, 2, 1, BGP4V2_PEER_STATE, 1, 4}},
948 {BGP4V2_PEER_STATE,
949 ASN_INTEGER,
950 RONLY,
951 bgpv2PeerTable,
952 6,
953 {1, 2, 1, BGP4V2_PEER_STATE, 2, 16}},
954 {BGP4V2_PEER_DESCRIPTION,
955 ASN_OCTET_STR,
956 RONLY,
957 bgpv2PeerTable,
958 6,
959 {1, 2, 1, BGP4V2_PEER_DESCRIPTION, 1, 4}},
960 {BGP4V2_PEER_DESCRIPTION,
961 ASN_OCTET_STR,
962 RONLY,
963 bgpv2PeerTable,
964 6,
965 {1, 2, 1, BGP4V2_PEER_DESCRIPTION, 2, 16}},
966 /* bgp4V2PeerErrorsEntry */
967 {BGP4V2_PEER_LAST_ERROR_CODE_RECEIVED,
968 ASN_UNSIGNED,
969 RONLY,
970 bgpv2PeerErrorsTable,
971 6,
972 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_CODE_RECEIVED, 1, 4}},
973 {BGP4V2_PEER_LAST_ERROR_CODE_RECEIVED,
974 ASN_UNSIGNED,
975 RONLY,
976 bgpv2PeerErrorsTable,
977 6,
978 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_CODE_RECEIVED, 2, 16}},
979 {BGP4V2_PEER_LAST_ERROR_SUBCODE_RECEIVED,
980 ASN_UNSIGNED,
981 RONLY,
982 bgpv2PeerErrorsTable,
983 6,
984 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SUBCODE_RECEIVED, 1, 4}},
985 {BGP4V2_PEER_LAST_ERROR_SUBCODE_RECEIVED,
986 ASN_UNSIGNED,
987 RONLY,
988 bgpv2PeerErrorsTable,
989 6,
990 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SUBCODE_RECEIVED, 2, 16}},
991 {BGP4V2_PEER_LAST_ERROR_RECEIVED_TIME,
992 ASN_UNSIGNED,
993 RONLY,
994 bgpv2PeerErrorsTable,
995 6,
996 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_RECEIVED_TIME, 1, 4}},
997 {BGP4V2_PEER_LAST_ERROR_RECEIVED_TIME,
998 ASN_UNSIGNED,
999 RONLY,
1000 bgpv2PeerErrorsTable,
1001 6,
1002 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_RECEIVED_TIME, 2, 16}},
1003 {BGP4V2_PEER_LAST_ERROR_RECEIVED_TEXT,
1004 ASN_OCTET_STR,
1005 RONLY,
1006 bgpv2PeerErrorsTable,
1007 6,
1008 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_RECEIVED_TEXT, 1, 4}},
1009 {BGP4V2_PEER_LAST_ERROR_RECEIVED_TEXT,
1010 ASN_OCTET_STR,
1011 RONLY,
1012 bgpv2PeerErrorsTable,
1013 6,
1014 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_RECEIVED_TEXT, 2, 16}},
1015 {BGP4V2_PEER_LAST_ERROR_RECEIVED_DATA,
1016 ASN_OCTET_STR,
1017 RONLY,
1018 bgpv2PeerErrorsTable,
1019 6,
1020 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_RECEIVED_DATA, 1, 4}},
1021 {BGP4V2_PEER_LAST_ERROR_RECEIVED_DATA,
1022 ASN_OCTET_STR,
1023 RONLY,
1024 bgpv2PeerErrorsTable,
1025 6,
1026 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_RECEIVED_DATA, 2, 16}},
1027 {BGP4V2_PEER_LAST_ERROR_CODE_SENT,
1028 ASN_UNSIGNED,
1029 RONLY,
1030 bgpv2PeerErrorsTable,
1031 6,
1032 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_CODE_SENT, 1, 4}},
1033 {BGP4V2_PEER_LAST_ERROR_CODE_SENT,
1034 ASN_UNSIGNED,
1035 RONLY,
1036 bgpv2PeerErrorsTable,
1037 6,
1038 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_CODE_SENT, 2, 16}},
1039 {BGP4V2_PEER_LAST_ERROR_SUBCODE_SENT,
1040 ASN_UNSIGNED,
1041 RONLY,
1042 bgpv2PeerErrorsTable,
1043 6,
1044 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SUBCODE_SENT, 1, 4}},
1045 {BGP4V2_PEER_LAST_ERROR_SUBCODE_SENT,
1046 ASN_UNSIGNED,
1047 RONLY,
1048 bgpv2PeerErrorsTable,
1049 6,
1050 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SUBCODE_SENT, 2, 16}},
1051 {BGP4V2_PEER_LAST_ERROR_SENT_TIME,
1052 ASN_UNSIGNED,
1053 RONLY,
1054 bgpv2PeerErrorsTable,
1055 6,
1056 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SENT_TIME, 1, 4}},
1057 {BGP4V2_PEER_LAST_ERROR_SENT_TIME,
1058 ASN_UNSIGNED,
1059 RONLY,
1060 bgpv2PeerErrorsTable,
1061 6,
1062 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SENT_TIME, 2, 16}},
1063 {BGP4V2_PEER_LAST_ERROR_SENT_TEXT,
1064 ASN_OCTET_STR,
1065 RONLY,
1066 bgpv2PeerErrorsTable,
1067 6,
1068 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SENT_TEXT, 1, 4}},
1069 {BGP4V2_PEER_LAST_ERROR_SENT_TEXT,
1070 ASN_OCTET_STR,
1071 RONLY,
1072 bgpv2PeerErrorsTable,
1073 6,
1074 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SENT_TEXT, 2, 16}},
1075 {BGP4V2_PEER_LAST_ERROR_SENT_DATA,
1076 ASN_OCTET_STR,
1077 RONLY,
1078 bgpv2PeerErrorsTable,
1079 6,
1080 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SENT_DATA, 1, 4}},
1081 {BGP4V2_PEER_LAST_ERROR_SENT_DATA,
1082 ASN_OCTET_STR,
1083 RONLY,
1084 bgpv2PeerErrorsTable,
1085 6,
1086 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SENT_DATA, 2, 16}},
1087 /* bgp4V2PeerEventTimesEntry */
1088 {BGP4V2_PEER_FSM_ESTABLISHED_TIME,
1089 ASN_UNSIGNED,
1090 RONLY,
1091 bgpv2PeerEventTimesTable,
1092 6,
1093 {1, 4, 1, BGP4V2_PEER_FSM_ESTABLISHED_TIME, 1, 4}},
1094 {BGP4V2_PEER_FSM_ESTABLISHED_TIME,
1095 ASN_UNSIGNED,
1096 RONLY,
1097 bgpv2PeerEventTimesTable,
1098 6,
1099 {1, 4, 1, BGP4V2_PEER_FSM_ESTABLISHED_TIME, 2, 16}},
1100 {BGP4V2_PEER_PEER_IN_UPDATES_ELAPSED_TIME,
1101 ASN_UNSIGNED,
1102 RONLY,
1103 bgpv2PeerEventTimesTable,
1104 6,
1105 {1, 4, 1, BGP4V2_PEER_PEER_IN_UPDATES_ELAPSED_TIME, 1, 4}},
1106 {BGP4V2_PEER_PEER_IN_UPDATES_ELAPSED_TIME,
1107 ASN_UNSIGNED,
1108 RONLY,
1109 bgpv2PeerEventTimesTable,
1110 6,
1111 {1, 4, 1, BGP4V2_PEER_PEER_IN_UPDATES_ELAPSED_TIME, 2, 16}},
1112 /* bgp4V2NlriTable */
1113 {BGP4V2_NLRI_INDEX,
1114 ASN_UNSIGNED,
1115 RONLY,
1116 bgp4v2PathAttrTable,
1117 6,
1118 {1, 9, 1, BGP4V2_NLRI_INDEX, 1, 4}},
1119 {BGP4V2_NLRI_INDEX,
1120 ASN_UNSIGNED,
1121 RONLY,
1122 bgp4v2PathAttrTable,
1123 6,
1124 {1, 9, 1, BGP4V2_NLRI_INDEX, 2, 16}},
1125 {BGP4V2_NLRI_AFI,
1126 ASN_INTEGER,
1127 RONLY,
1128 bgp4v2PathAttrTable,
1129 6,
1130 {1, 9, 1, BGP4V2_NLRI_AFI, 1, 4}},
1131 {BGP4V2_NLRI_AFI,
1132 ASN_INTEGER,
1133 RONLY,
1134 bgp4v2PathAttrTable,
1135 6,
1136 {1, 9, 1, BGP4V2_NLRI_AFI, 2, 16}},
1137 {BGP4V2_NLRI_SAFI,
1138 ASN_INTEGER,
1139 RONLY,
1140 bgp4v2PathAttrTable,
1141 6,
1142 {1, 9, 1, BGP4V2_NLRI_SAFI, 1, 4}},
1143 {BGP4V2_NLRI_SAFI,
1144 ASN_INTEGER,
1145 RONLY,
1146 bgp4v2PathAttrTable,
1147 6,
1148 {1, 9, 1, BGP4V2_NLRI_SAFI, 2, 16}},
1149 {BGP4V2_NLRI_PREFIX_TYPE,
1150 ASN_INTEGER,
1151 RONLY,
1152 bgp4v2PathAttrTable,
1153 6,
1154 {1, 9, 1, BGP4V2_NLRI_PREFIX_TYPE, 1, 4}},
1155 {BGP4V2_NLRI_PREFIX_TYPE,
1156 ASN_INTEGER,
1157 RONLY,
1158 bgp4v2PathAttrTable,
1159 6,
1160 {1, 9, 1, BGP4V2_NLRI_PREFIX_TYPE, 2, 16}},
1161 {BGP4V2_NLRI_PREFIX,
1162 ASN_OCTET_STR,
1163 RONLY,
1164 bgp4v2PathAttrTable,
1165 6,
1166 {1, 9, 1, BGP4V2_NLRI_PREFIX, 1, 4}},
1167 {BGP4V2_NLRI_PREFIX,
1168 ASN_OCTET_STR,
1169 RONLY,
1170 bgp4v2PathAttrTable,
1171 6,
1172 {1, 9, 1, BGP4V2_NLRI_PREFIX, 2, 16}},
1173 {BGP4V2_NLRI_PREFIX_LEN,
1174 ASN_UNSIGNED,
1175 RONLY,
1176 bgp4v2PathAttrTable,
1177 6,
1178 {1, 9, 1, BGP4V2_NLRI_PREFIX_LEN, 1, 4}},
1179 {BGP4V2_NLRI_PREFIX_LEN,
1180 ASN_UNSIGNED,
1181 RONLY,
1182 bgp4v2PathAttrTable,
1183 6,
1184 {1, 9, 1, BGP4V2_NLRI_PREFIX_LEN, 2, 16}},
1185 {BGP4V2_NLRI_BEST,
1186 ASN_INTEGER,
1187 RONLY,
1188 bgp4v2PathAttrTable,
1189 6,
1190 {1, 9, 1, BGP4V2_NLRI_BEST, 1, 4}},
1191 {BGP4V2_NLRI_BEST,
1192 ASN_INTEGER,
1193 RONLY,
1194 bgp4v2PathAttrTable,
1195 6,
1196 {1, 9, 1, BGP4V2_NLRI_BEST, 2, 16}},
1197 {BGP4V2_NLRI_CALC_LOCAL_PREF,
1198 ASN_UNSIGNED,
1199 RONLY,
1200 bgp4v2PathAttrTable,
1201 6,
1202 {1, 9, 1, BGP4V2_NLRI_CALC_LOCAL_PREF, 1, 4}},
1203 {BGP4V2_NLRI_CALC_LOCAL_PREF,
1204 ASN_UNSIGNED,
1205 RONLY,
1206 bgp4v2PathAttrTable,
1207 6,
1208 {1, 9, 1, BGP4V2_NLRI_CALC_LOCAL_PREF, 2, 16}},
1209 {BGP4V2_NLRI_ORIGIN,
1210 ASN_INTEGER,
1211 RONLY,
1212 bgp4v2PathAttrTable,
1213 6,
1214 {1, 9, 1, BGP4V2_NLRI_ORIGIN, 1, 4}},
1215 {BGP4V2_NLRI_ORIGIN,
1216 ASN_INTEGER,
1217 RONLY,
1218 bgp4v2PathAttrTable,
1219 6,
1220 {1, 9, 1, BGP4V2_NLRI_ORIGIN, 2, 16}},
1221 {BGP4V2_NLRI_NEXT_HOP_ADDR_TYPE,
1222 ASN_INTEGER,
1223 RONLY,
1224 bgp4v2PathAttrTable,
1225 6,
1226 {1, 9, 1, BGP4V2_NLRI_NEXT_HOP_ADDR_TYPE, 1, 4}},
1227 {BGP4V2_NLRI_NEXT_HOP_ADDR_TYPE,
1228 ASN_INTEGER,
1229 RONLY,
1230 bgp4v2PathAttrTable,
1231 6,
1232 {1, 9, 1, BGP4V2_NLRI_NEXT_HOP_ADDR_TYPE, 2, 16}},
1233 {BGP4V2_NLRI_NEXT_HOP_ADDR,
1234 ASN_OCTET_STR,
1235 RONLY,
1236 bgp4v2PathAttrTable,
1237 6,
1238 {1, 9, 1, BGP4V2_NLRI_NEXT_HOP_ADDR, 1, 4}},
1239 {BGP4V2_NLRI_NEXT_HOP_ADDR,
1240 ASN_OCTET_STR,
1241 RONLY,
1242 bgp4v2PathAttrTable,
1243 6,
1244 {1, 9, 1, BGP4V2_NLRI_NEXT_HOP_ADDR, 2, 16}},
1245 {BGP4V2_NLRI_LINK_LOCAL_NEXT_HOP_ADDR_TYPE,
1246 ASN_INTEGER,
1247 RONLY,
1248 bgp4v2PathAttrTable,
1249 6,
1250 {1, 9, 1, BGP4V2_NLRI_LINK_LOCAL_NEXT_HOP_ADDR_TYPE, 1, 4}},
1251 {BGP4V2_NLRI_LINK_LOCAL_NEXT_HOP_ADDR_TYPE,
1252 ASN_INTEGER,
1253 RONLY,
1254 bgp4v2PathAttrTable,
1255 6,
1256 {1, 9, 1, BGP4V2_NLRI_LINK_LOCAL_NEXT_HOP_ADDR_TYPE, 2, 16}},
1257 {BGP4V2_NLRI_LINK_LOCAL_NEXT_HOP_ADDR,
1258 ASN_OCTET_STR,
1259 RONLY,
1260 bgp4v2PathAttrTable,
1261 6,
1262 {1, 9, 1, BGP4V2_NLRI_LINK_LOCAL_NEXT_HOP_ADDR, 1, 4}},
1263 {BGP4V2_NLRI_LINK_LOCAL_NEXT_HOP_ADDR,
1264 ASN_OCTET_STR,
1265 RONLY,
1266 bgp4v2PathAttrTable,
1267 6,
1268 {1, 9, 1, BGP4V2_NLRI_LINK_LOCAL_NEXT_HOP_ADDR, 2, 16}},
1269 {BGP4V2_NLRI_LOCAL_PREF_PRESENT,
1270 ASN_INTEGER,
1271 RONLY,
1272 bgp4v2PathAttrTable,
1273 6,
1274 {1, 9, 1, BGP4V2_NLRI_LOCAL_PREF_PRESENT, 1, 4}},
1275 {BGP4V2_NLRI_LOCAL_PREF_PRESENT,
1276 ASN_INTEGER,
1277 RONLY,
1278 bgp4v2PathAttrTable,
1279 6,
1280 {1, 9, 1, BGP4V2_NLRI_LOCAL_PREF_PRESENT, 2, 16}},
1281 {BGP4V2_NLRI_LOCAL_PREF,
1282 ASN_UNSIGNED,
1283 RONLY,
1284 bgp4v2PathAttrTable,
1285 6,
1286 {1, 9, 1, BGP4V2_NLRI_LOCAL_PREF, 1, 4}},
1287 {BGP4V2_NLRI_LOCAL_PREF,
1288 ASN_UNSIGNED,
1289 RONLY,
1290 bgp4v2PathAttrTable,
1291 6,
1292 {1, 9, 1, BGP4V2_NLRI_LOCAL_PREF, 2, 16}},
1293 {BGP4V2_NLRI_MED_PRESENT,
1294 ASN_INTEGER,
1295 RONLY,
1296 bgp4v2PathAttrTable,
1297 6,
1298 {1, 9, 1, BGP4V2_NLRI_MED_PRESENT, 1, 4}},
1299 {BGP4V2_NLRI_MED_PRESENT,
1300 ASN_INTEGER,
1301 RONLY,
1302 bgp4v2PathAttrTable,
1303 6,
1304 {1, 9, 1, BGP4V2_NLRI_MED_PRESENT, 2, 16}},
1305 {BGP4V2_NLRI_MED,
1306 ASN_UNSIGNED,
1307 RONLY,
1308 bgp4v2PathAttrTable,
1309 6,
1310 {1, 9, 1, BGP4V2_NLRI_MED, 1, 4}},
1311 {BGP4V2_NLRI_MED,
1312 ASN_UNSIGNED,
1313 RONLY,
1314 bgp4v2PathAttrTable,
1315 6,
1316 {1, 9, 1, BGP4V2_NLRI_MED, 2, 16}},
1317 {BGP4V2_NLRI_ATOMIC_AGGREGATE,
1318 ASN_INTEGER,
1319 RONLY,
1320 bgp4v2PathAttrTable,
1321 6,
1322 {1, 9, 1, BGP4V2_NLRI_ATOMIC_AGGREGATE, 1, 4}},
1323 {BGP4V2_NLRI_ATOMIC_AGGREGATE,
1324 ASN_INTEGER,
1325 RONLY,
1326 bgp4v2PathAttrTable,
1327 6,
1328 {1, 9, 1, BGP4V2_NLRI_ATOMIC_AGGREGATE, 2, 16}},
1329 {BGP4V2_NLRI_AGGREGATOR_PRESENT,
1330 ASN_INTEGER,
1331 RONLY,
1332 bgp4v2PathAttrTable,
1333 6,
1334 {1, 9, 1, BGP4V2_NLRI_AGGREGATOR_PRESENT, 1, 4}},
1335 {BGP4V2_NLRI_AGGREGATOR_PRESENT,
1336 ASN_INTEGER,
1337 RONLY,
1338 bgp4v2PathAttrTable,
1339 6,
1340 {1, 9, 1, BGP4V2_NLRI_AGGREGATOR_PRESENT, 2, 16}},
1341 {BGP4V2_NLRI_AGGREGATOR_AS,
1342 ASN_UNSIGNED,
1343 RONLY,
1344 bgp4v2PathAttrTable,
1345 6,
1346 {1, 9, 1, BGP4V2_NLRI_AGGREGATOR_AS, 1, 4}},
1347 {BGP4V2_NLRI_AGGREGATOR_AS,
1348 ASN_UNSIGNED,
1349 RONLY,
1350 bgp4v2PathAttrTable,
1351 6,
1352 {1, 9, 1, BGP4V2_NLRI_AGGREGATOR_AS, 2, 16}},
1353 {BGP4V2_NLRI_AGGREGATOR_ADDR,
1354 ASN_OCTET_STR,
1355 RONLY,
1356 bgp4v2PathAttrTable,
1357 6,
1358 {1, 9, 1, BGP4V2_NLRI_AGGREGATOR_ADDR, 1, 4}},
1359 {BGP4V2_NLRI_AGGREGATOR_ADDR,
1360 ASN_OCTET_STR,
1361 RONLY,
1362 bgp4v2PathAttrTable,
1363 6,
1364 {1, 9, 1, BGP4V2_NLRI_AGGREGATOR_ADDR, 2, 16}},
1365 {BGP4V2_NLRI_AS_PATH_CALC_LENGTH,
1366 ASN_UNSIGNED,
1367 RONLY,
1368 bgp4v2PathAttrTable,
1369 6,
1370 {1, 9, 1, BGP4V2_NLRI_AS_PATH_CALC_LENGTH, 1, 4}},
1371 {BGP4V2_NLRI_AS_PATH_CALC_LENGTH,
1372 ASN_UNSIGNED,
1373 RONLY,
1374 bgp4v2PathAttrTable,
1375 6,
1376 {1, 9, 1, BGP4V2_NLRI_AS_PATH_CALC_LENGTH, 2, 16}},
1377 {BGP4V2_NLRI_AS_PATH_STRING,
1378 ASN_OCTET_STR,
1379 RONLY,
1380 bgp4v2PathAttrTable,
1381 6,
1382 {1, 9, 1, BGP4V2_NLRI_AS_PATH_STRING, 1, 4}},
1383 {BGP4V2_NLRI_AS_PATH_STRING,
1384 ASN_OCTET_STR,
1385 RONLY,
1386 bgp4v2PathAttrTable,
1387 6,
1388 {1, 9, 1, BGP4V2_NLRI_AS_PATH_STRING, 2, 16}},
1389 {BGP4V2_NLRI_AS_PATH,
1390 ASN_OCTET_STR,
1391 RONLY,
1392 bgp4v2PathAttrTable,
1393 6,
1394 {1, 9, 1, BGP4V2_NLRI_AS_PATH, 1, 4}},
1395 {BGP4V2_NLRI_AS_PATH,
1396 ASN_OCTET_STR,
1397 RONLY,
1398 bgp4v2PathAttrTable,
1399 6,
1400 {1, 9, 1, BGP4V2_NLRI_AS_PATH, 2, 16}},
1401 {BGP4V2_NLRI_PATH_ATTR_UNKNOWN,
1402 ASN_OCTET_STR,
1403 RONLY,
1404 bgp4v2PathAttrTable,
1405 6,
1406 {1, 9, 1, BGP4V2_NLRI_PATH_ATTR_UNKNOWN, 1, 4}},
1407 {BGP4V2_NLRI_PATH_ATTR_UNKNOWN,
1408 ASN_OCTET_STR,
1409 RONLY,
1410 bgp4v2PathAttrTable,
1411 6,
1412 {1, 9, 1, BGP4V2_NLRI_PATH_ATTR_UNKNOWN, 2, 16}},
1413 };
1414
1415 int bgp_snmp_bgp4v2_init(struct thread_master *tm)
1416 {
1417 REGISTER_MIB("mibII/bgpv2", bgpv2_variables, variable, bgpv2_oid);
1418 return 0;
1419 }
FRRouting mirror