]> git.proxmox.com Git - mirror_frr.git/blame - bgpd/bgp_snmp_bgp4v2.c
projects / mirror_frr.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge pull request #12485 from opensourcerouting/fix/crash_attrinfo
[mirror_frr.git] / bgpd / bgp_snmp_bgp4v2.c
CommitLineData
ff18b7b0
DA		 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"
7718ba25 42#include "bgpd/bgp_debug.h"
ff18b7b0
DA		 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
48SNMP_LOCAL_VARIABLES
49
50static oid bgpv2_oid[] = {BGP4V2MIB};
51static struct in_addr bgp_empty_addr = {};
52
53static 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
82static 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
140static 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
149 if (exact) {
150 if (family == AF_INET) {
151 oid2in_addr(offset, IN_ADDR_SIZE, &addr->ip._v4_addr);
152 peer = peer_lookup_all_vrf(addr);
153 return peer;
154 } else if (family == AF_INET6) {
155 oid2in6_addr(offset, &addr->ip._v6_addr);
156 return peer_lookup_all_vrf(addr);
157 }
158 } else {
159 peer = peer_lookup_all_vrf_next(addr, offset, family);
160 if (peer == NULL)
161 return NULL;
162
163 switch (sockunion_family(&peer->su)) {
164 case AF_INET:
165 oid_copy_in_addr(offset, &peer->su.sin.sin_addr);
166 *length = IN_ADDR_SIZE + namelen;
167 return peer;
168 case AF_INET6:
169 oid_copy_in6_addr(offset, &peer->su.sin6.sin6_addr);
170 *length = IN6_ADDR_SIZE + namelen;
171 return peer;
172 default:
173 break;
174 }
175 }
176
177 return NULL;
178}
179
180static uint8_t *bgpv2PeerTable(struct variable *v, oid name[], size_t *length,
181 int exact, size_t *var_len,
182 WriteMethod **write_method)
183{
184 struct peer *peer;
185 struct ipaddr addr = {};
186
187 if (smux_header_table(v, name, length, exact, var_len, write_method) ==
188 MATCH_FAILED)
189 return NULL;
190
191 peer = bgpv2PeerTable_lookup(v, name, length, exact, &addr);
192 if (!peer)
193 return NULL;
194
195 switch (v->magic) {
196 case BGP4V2_PEER_INSTANCE:
197 return SNMP_INTEGER(peer->bgp->vrf_id);
198 case BGP4V2_PEER_LOCAL_ADDR_TYPE:
199 if (peer->su_local)
200 return SNMP_INTEGER(peer->su_local->sa.sa_family ==
201 AF_INET
202 ? AFI_IP
203 : AFI_IP6);
204 else
205 return SNMP_INTEGER(0);
206 case BGP4V2_PEER_LOCAL_ADDR:
207 if (peer->su_local)
208 if (peer->su_local->sa.sa_family == AF_INET)
209 return SNMP_IPADDRESS(
210 peer->su_local->sin.sin_addr);
211 else
212 return SNMP_IP6ADDRESS(
213 peer->su_local->sin6.sin6_addr);
214 else
215 return SNMP_IPADDRESS(bgp_empty_addr);
216 case BGP4V2_PEER_REMOTE_ADDR_TYPE:
217 if (peer->su_remote)
218 return SNMP_INTEGER(peer->su_remote->sa.sa_family ==
219 AF_INET
220 ? AFI_IP
221 : AFI_IP6);
222 else
223 return SNMP_INTEGER(0);
224 case BGP4V2_PEER_REMOTE_ADDR:
225 if (peer->su_remote)
226 if (peer->su_remote->sa.sa_family == AF_INET)
227 return SNMP_IPADDRESS(
228 peer->su_remote->sin.sin_addr);
229 else
230 return SNMP_IP6ADDRESS(
231 peer->su_remote->sin6.sin6_addr);
232 else
233 return SNMP_IPADDRESS(bgp_empty_addr);
234 case BGP4V2_PEER_LOCAL_PORT:
235 if (peer->su_local)
236 if (peer->su_local->sa.sa_family == AF_INET)
237 return SNMP_INTEGER(
238 ntohs(peer->su_local->sin.sin_port));
239 else
240 return SNMP_INTEGER(
241 ntohs(peer->su_local->sin6.sin6_port));
242 else
243 return SNMP_INTEGER(0);
244 case BGP4V2_PEER_LOCAL_AS:
245 return SNMP_INTEGER(peer->local_as);
246 case BGP4V2_PEER_LOCAL_IDENTIFIER:
247 return SNMP_IPADDRESS(peer->local_id);
248 case BGP4V2_PEER_REMOTE_PORT:
249 if (peer->su_remote)
250 if (peer->su_remote->sa.sa_family == AF_INET)
251 return SNMP_INTEGER(
252 ntohs(peer->su_remote->sin.sin_port));
253 else
254 return SNMP_INTEGER(
255 ntohs(peer->su_remote->sin6.sin6_port));
256 else
257 return SNMP_INTEGER(0);
258 case BGP4V2_PEER_REMOTE_AS:
259 return SNMP_INTEGER(peer->as);
260 case BGP4V2_PEER_REMOTE_IDENTIFIER:
261 return SNMP_IPADDRESS(peer->remote_id);
262 case BGP4V2_PEER_ADMIN_STATUS:
263#define BGP_PEER_ADMIN_STATUS_HALTED 1
264#define BGP_PEER_ADMIN_STATUS_RUNNING 2
265 if (BGP_PEER_START_SUPPRESSED(peer))
266 return SNMP_INTEGER(BGP_PEER_ADMIN_STATUS_HALTED);
267 else
268 return SNMP_INTEGER(BGP_PEER_ADMIN_STATUS_RUNNING);
269 case BGP4V2_PEER_STATE:
270 return SNMP_INTEGER(peer->status);
271 case BGP4V2_PEER_DESCRIPTION:
272 if (peer->desc)
273 return SNMP_STRING(peer->desc);
7718ba25
DA		 274 break;
275 default:
276 break;
277 }
278
279 return NULL;
280}
281
282static uint8_t *bgpv2PeerErrorsTable(struct variable *v, oid name[],
283 size_t *length, int exact, size_t *var_len,
284 WriteMethod **write_method)
285{
286 struct peer *peer;
287 struct ipaddr addr = {};
288
289 if (smux_header_table(v, name, length, exact, var_len, write_method) ==
290 MATCH_FAILED)
291 return NULL;
292
293 peer = bgpv2PeerTable_lookup(v, name, length, exact, &addr);
294 if (!peer)
295 return NULL;
296
297 switch (v->magic) {
298 case BGP4V2_PEER_LAST_ERROR_CODE_RECEIVED:
299 if (peer->last_reset == PEER_DOWN_NOTIFY_RECEIVED)
300 return SNMP_INTEGER(peer->notify.code);
301 else
302 return SNMP_INTEGER(0);
303 case BGP4V2_PEER_LAST_ERROR_SUBCODE_RECEIVED:
304 if (peer->last_reset == PEER_DOWN_NOTIFY_RECEIVED)
305 return SNMP_INTEGER(peer->notify.subcode);
306 else
307 return SNMP_INTEGER(0);
308 case BGP4V2_PEER_LAST_ERROR_RECEIVED_TIME:
309 if (peer->last_reset == PEER_DOWN_NOTIFY_RECEIVED)
310 return SNMP_INTEGER(peer->resettime);
311 else
312 return SNMP_INTEGER(0);
313 case BGP4V2_PEER_LAST_ERROR_RECEIVED_TEXT:
314 if (peer->last_reset == PEER_DOWN_NOTIFY_RECEIVED) {
315 struct bgp_notify notify = peer->notify;
316 char msg_buf[255];
317 const char *msg_str = NULL;
318
319 if (notify.code == BGP_NOTIFY_CEASE &&
320 (notify.subcode ==
321 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN ||
322 notify.subcode == BGP_NOTIFY_CEASE_ADMIN_RESET)) {
323 msg_str = bgp_notify_admin_message(
324 msg_buf, sizeof(msg_buf),
325 (uint8_t *)notify.data, notify.length);
326 return SNMP_STRING(msg_str);
327 }
328 }
329 return SNMP_STRING("");
330 case BGP4V2_PEER_LAST_ERROR_RECEIVED_DATA:
331 if (peer->last_reset == PEER_DOWN_NOTIFY_RECEIVED)
332 return SNMP_STRING(peer->notify.data);
333 else
334 return SNMP_STRING("");
335 case BGP4V2_PEER_LAST_ERROR_CODE_SENT:
336 if (peer->last_reset != PEER_DOWN_NOTIFY_RECEIVED)
337 return SNMP_INTEGER(peer->notify.code);
338 else
339 return SNMP_INTEGER(0);
340 case BGP4V2_PEER_LAST_ERROR_SUBCODE_SENT:
341 if (peer->last_reset != PEER_DOWN_NOTIFY_RECEIVED)
342 return SNMP_INTEGER(peer->notify.subcode);
343 else
344 return SNMP_INTEGER(0);
345 case BGP4V2_PEER_LAST_ERROR_SENT_TIME:
346 if (peer->last_reset != PEER_DOWN_NOTIFY_RECEIVED)
347 return SNMP_INTEGER(peer->resettime);
348 else
349 return SNMP_INTEGER(0);
350 case BGP4V2_PEER_LAST_ERROR_SENT_TEXT:
351 if (peer->last_reset == PEER_DOWN_NOTIFY_SEND ||
352 peer->last_reset == PEER_DOWN_RTT_SHUTDOWN ||
353 peer->last_reset == PEER_DOWN_USER_SHUTDOWN) {
354 struct bgp_notify notify = peer->notify;
355 char msg_buf[255];
356 const char *msg_str = NULL;
357
358 if (notify.code == BGP_NOTIFY_CEASE &&
359 (notify.subcode ==
360 BGP_NOTIFY_CEASE_ADMIN_SHUTDOWN ||
361 notify.subcode == BGP_NOTIFY_CEASE_ADMIN_RESET)) {
362 msg_str = bgp_notify_admin_message(
363 msg_buf, sizeof(msg_buf),
364 (uint8_t *)notify.data, notify.length);
365 return SNMP_STRING(msg_str);
366 }
367 }
368 return SNMP_STRING("");
369 case BGP4V2_PEER_LAST_ERROR_SENT_DATA:
370 if (peer->last_reset == PEER_DOWN_NOTIFY_SEND ||
371 peer->last_reset == PEER_DOWN_RTT_SHUTDOWN ||
372 peer->last_reset == PEER_DOWN_USER_SHUTDOWN)
373 return SNMP_STRING(peer->notify.data);
374 else
375 return SNMP_STRING("");
ff18b7b0
DA		 376 default:
377 break;
378 }
379
380 return NULL;
381}
382
383static struct variable bgpv2_variables[] = {
7718ba25 384 /* bgp4V2PeerEntry */
ff18b7b0
DA		 385 {BGP4V2_PEER_INSTANCE,
386 ASN_UNSIGNED,
387 RONLY,
388 bgpv2PeerTable,
389 6,
390 {1, 2, 1, BGP4V2_PEER_INSTANCE, 1, 4}},
391 {BGP4V2_PEER_INSTANCE,
392 ASN_UNSIGNED,
393 RONLY,
394 bgpv2PeerTable,
395 6,
396 {1, 2, 1, BGP4V2_PEER_INSTANCE, 2, 16}},
397 {BGP4V2_PEER_LOCAL_ADDR_TYPE,
398 ASN_INTEGER,
399 RONLY,
400 bgpv2PeerTable,
401 6,
402 {1, 2, 1, BGP4V2_PEER_LOCAL_ADDR_TYPE, 1, 4}},
403 {BGP4V2_PEER_LOCAL_ADDR_TYPE,
404 ASN_INTEGER,
405 RONLY,
406 bgpv2PeerTable,
407 6,
408 {1, 2, 1, BGP4V2_PEER_LOCAL_ADDR_TYPE, 2, 16}},
409 {BGP4V2_PEER_LOCAL_ADDR,
410 ASN_OCTET_STR,
411 RONLY,
412 bgpv2PeerTable,
413 6,
414 {1, 2, 1, BGP4V2_PEER_LOCAL_ADDR, 1, 4}},
415 {BGP4V2_PEER_LOCAL_ADDR,
416 ASN_OCTET_STR,
417 RONLY,
418 bgpv2PeerTable,
419 6,
420 {1, 2, 1, BGP4V2_PEER_LOCAL_ADDR, 2, 16}},
421 {BGP4V2_PEER_REMOTE_ADDR_TYPE,
422 ASN_INTEGER,
423 RONLY,
424 bgpv2PeerTable,
425 6,
426 {1, 2, 1, BGP4V2_PEER_REMOTE_ADDR_TYPE, 1, 4}},
427 {BGP4V2_PEER_REMOTE_ADDR_TYPE,
428 ASN_INTEGER,
429 RONLY,
430 bgpv2PeerTable,
431 6,
432 {1, 2, 1, BGP4V2_PEER_REMOTE_ADDR_TYPE, 2, 16}},
433 {BGP4V2_PEER_REMOTE_ADDR,
434 ASN_OCTET_STR,
435 RONLY,
436 bgpv2PeerTable,
437 6,
438 {1, 2, 1, BGP4V2_PEER_REMOTE_ADDR, 1, 4}},
439 {BGP4V2_PEER_REMOTE_ADDR,
440 ASN_OCTET_STR,
441 RONLY,
442 bgpv2PeerTable,
443 6,
444 {1, 2, 1, BGP4V2_PEER_REMOTE_ADDR, 2, 16}},
445 {BGP4V2_PEER_LOCAL_PORT,
446 ASN_UNSIGNED,
447 RONLY,
448 bgpv2PeerTable,
449 6,
450 {1, 2, 1, BGP4V2_PEER_LOCAL_PORT, 1, 4}},
451 {BGP4V2_PEER_LOCAL_PORT,
452 ASN_UNSIGNED,
453 RONLY,
454 bgpv2PeerTable,
455 6,
456 {1, 2, 1, BGP4V2_PEER_LOCAL_PORT, 2, 16}},
457 {BGP4V2_PEER_LOCAL_AS,
458 ASN_UNSIGNED,
459 RONLY,
460 bgpv2PeerTable,
461 6,
462 {1, 2, 1, BGP4V2_PEER_LOCAL_AS, 1, 4}},
463 {BGP4V2_PEER_LOCAL_AS,
464 ASN_UNSIGNED,
465 RONLY,
466 bgpv2PeerTable,
467 6,
468 {1, 2, 1, BGP4V2_PEER_LOCAL_AS, 2, 16}},
469 {BGP4V2_PEER_LOCAL_IDENTIFIER,
470 ASN_OCTET_STR,
471 RONLY,
472 bgpv2PeerTable,
473 6,
474 {1, 2, 1, BGP4V2_PEER_LOCAL_IDENTIFIER, 1, 4}},
475 {BGP4V2_PEER_LOCAL_IDENTIFIER,
476 ASN_OCTET_STR,
477 RONLY,
478 bgpv2PeerTable,
479 6,
480 {1, 2, 1, BGP4V2_PEER_LOCAL_IDENTIFIER, 2, 16}},
481 {BGP4V2_PEER_REMOTE_PORT,
482 ASN_UNSIGNED,
483 RONLY,
484 bgpv2PeerTable,
485 6,
486 {1, 2, 1, BGP4V2_PEER_REMOTE_PORT, 1, 4}},
487 {BGP4V2_PEER_REMOTE_PORT,
488 ASN_UNSIGNED,
489 RONLY,
490 bgpv2PeerTable,
491 6,
492 {1, 2, 1, BGP4V2_PEER_REMOTE_PORT, 2, 16}},
493 {BGP4V2_PEER_REMOTE_AS,
494 ASN_UNSIGNED,
495 RONLY,
496 bgpv2PeerTable,
497 6,
498 {1, 2, 1, BGP4V2_PEER_REMOTE_AS, 1, 4}},
499 {BGP4V2_PEER_REMOTE_AS,
500 ASN_UNSIGNED,
501 RONLY,
502 bgpv2PeerTable,
503 6,
504 {1, 2, 1, BGP4V2_PEER_REMOTE_AS, 2, 16}},
505 {BGP4V2_PEER_REMOTE_IDENTIFIER,
506 ASN_OCTET_STR,
507 RONLY,
508 bgpv2PeerTable,
509 6,
510 {1, 2, 1, BGP4V2_PEER_REMOTE_IDENTIFIER, 1, 4}},
511 {BGP4V2_PEER_REMOTE_IDENTIFIER,
512 ASN_OCTET_STR,
513 RONLY,
514 bgpv2PeerTable,
515 6,
516 {1, 2, 1, BGP4V2_PEER_REMOTE_IDENTIFIER, 2, 16}},
517 {BGP4V2_PEER_ADMIN_STATUS,
518 ASN_INTEGER,
519 RONLY,
520 bgpv2PeerTable,
521 6,
522 {1, 2, 1, BGP4V2_PEER_ADMIN_STATUS, 1, 4}},
523 {BGP4V2_PEER_ADMIN_STATUS,
524 ASN_INTEGER,
525 RONLY,
526 bgpv2PeerTable,
527 6,
528 {1, 2, 1, BGP4V2_PEER_ADMIN_STATUS, 2, 16}},
529 {BGP4V2_PEER_STATE,
530 ASN_INTEGER,
531 RONLY,
532 bgpv2PeerTable,
533 6,
534 {1, 2, 1, BGP4V2_PEER_STATE, 1, 4}},
535 {BGP4V2_PEER_STATE,
536 ASN_INTEGER,
537 RONLY,
538 bgpv2PeerTable,
539 6,
540 {1, 2, 1, BGP4V2_PEER_STATE, 2, 16}},
541 {BGP4V2_PEER_DESCRIPTION,
542 ASN_OCTET_STR,
543 RONLY,
544 bgpv2PeerTable,
545 6,
546 {1, 2, 1, BGP4V2_PEER_DESCRIPTION, 1, 4}},
547 {BGP4V2_PEER_DESCRIPTION,
548 ASN_OCTET_STR,
549 RONLY,
550 bgpv2PeerTable,
551 6,
552 {1, 2, 1, BGP4V2_PEER_DESCRIPTION, 2, 16}},
7718ba25
DA		 553 /* bgp4V2PeerErrorsEntry */
554 {BGP4V2_PEER_LAST_ERROR_CODE_RECEIVED,
555 ASN_UNSIGNED,
556 RONLY,
557 bgpv2PeerErrorsTable,
558 6,
559 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_CODE_RECEIVED, 1, 4}},
560 {BGP4V2_PEER_LAST_ERROR_CODE_RECEIVED,
561 ASN_UNSIGNED,
562 RONLY,
563 bgpv2PeerErrorsTable,
564 6,
565 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_CODE_RECEIVED, 2, 16}},
566 {BGP4V2_PEER_LAST_ERROR_SUBCODE_RECEIVED,
567 ASN_UNSIGNED,
568 RONLY,
569 bgpv2PeerErrorsTable,
570 6,
571 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SUBCODE_RECEIVED, 1, 4}},
572 {BGP4V2_PEER_LAST_ERROR_SUBCODE_RECEIVED,
573 ASN_UNSIGNED,
574 RONLY,
575 bgpv2PeerErrorsTable,
576 6,
577 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SUBCODE_RECEIVED, 2, 16}},
578 {BGP4V2_PEER_LAST_ERROR_RECEIVED_TIME,
579 ASN_UNSIGNED,
580 RONLY,
581 bgpv2PeerErrorsTable,
582 6,
583 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_RECEIVED_TIME, 1, 4}},
584 {BGP4V2_PEER_LAST_ERROR_RECEIVED_TIME,
585 ASN_UNSIGNED,
586 RONLY,
587 bgpv2PeerErrorsTable,
588 6,
589 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_RECEIVED_TIME, 2, 16}},
590 {BGP4V2_PEER_LAST_ERROR_RECEIVED_TEXT,
591 ASN_OCTET_STR,
592 RONLY,
593 bgpv2PeerErrorsTable,
594 6,
595 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_RECEIVED_TEXT, 1, 4}},
596 {BGP4V2_PEER_LAST_ERROR_RECEIVED_TEXT,
597 ASN_OCTET_STR,
598 RONLY,
599 bgpv2PeerErrorsTable,
600 6,
601 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_RECEIVED_TEXT, 2, 16}},
602 {BGP4V2_PEER_LAST_ERROR_RECEIVED_DATA,
603 ASN_OCTET_STR,
604 RONLY,
605 bgpv2PeerErrorsTable,
606 6,
607 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_RECEIVED_DATA, 1, 4}},
608 {BGP4V2_PEER_LAST_ERROR_RECEIVED_DATA,
609 ASN_OCTET_STR,
610 RONLY,
611 bgpv2PeerErrorsTable,
612 6,
613 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_RECEIVED_DATA, 2, 16}},
614 {BGP4V2_PEER_LAST_ERROR_CODE_SENT,
615 ASN_UNSIGNED,
616 RONLY,
617 bgpv2PeerErrorsTable,
618 6,
619 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_CODE_SENT, 1, 4}},
620 {BGP4V2_PEER_LAST_ERROR_CODE_SENT,
621 ASN_UNSIGNED,
622 RONLY,
623 bgpv2PeerErrorsTable,
624 6,
625 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_CODE_SENT, 2, 16}},
626 {BGP4V2_PEER_LAST_ERROR_SUBCODE_SENT,
627 ASN_UNSIGNED,
628 RONLY,
629 bgpv2PeerErrorsTable,
630 6,
631 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SUBCODE_SENT, 1, 4}},
632 {BGP4V2_PEER_LAST_ERROR_SUBCODE_SENT,
633 ASN_UNSIGNED,
634 RONLY,
635 bgpv2PeerErrorsTable,
636 6,
637 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SUBCODE_SENT, 2, 16}},
638 {BGP4V2_PEER_LAST_ERROR_SENT_TIME,
639 ASN_UNSIGNED,
640 RONLY,
641 bgpv2PeerErrorsTable,
642 6,
643 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SENT_TIME, 1, 4}},
644 {BGP4V2_PEER_LAST_ERROR_SENT_TIME,
645 ASN_UNSIGNED,
646 RONLY,
647 bgpv2PeerErrorsTable,
648 6,
649 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SENT_TIME, 2, 16}},
650 {BGP4V2_PEER_LAST_ERROR_SENT_TEXT,
651 ASN_OCTET_STR,
652 RONLY,
653 bgpv2PeerErrorsTable,
654 6,
655 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SENT_TEXT, 1, 4}},
656 {BGP4V2_PEER_LAST_ERROR_SENT_TEXT,
657 ASN_OCTET_STR,
658 RONLY,
659 bgpv2PeerErrorsTable,
660 6,
661 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SENT_TEXT, 2, 16}},
662 {BGP4V2_PEER_LAST_ERROR_SENT_DATA,
663 ASN_OCTET_STR,
664 RONLY,
665 bgpv2PeerErrorsTable,
666 6,
667 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SENT_DATA, 1, 4}},
668 {BGP4V2_PEER_LAST_ERROR_SENT_DATA,
669 ASN_OCTET_STR,
670 RONLY,
671 bgpv2PeerErrorsTable,
672 6,
673 {1, 3, 1, BGP4V2_PEER_LAST_ERROR_SENT_DATA, 2, 16}},
ff18b7b0
DA		 674};
675
676int bgp_snmp_bgp4v2_init(struct thread_master *tm)
677{
678 REGISTER_MIB("mibII/bgpv2", bgpv2_variables, variable, bgpv2_oid);
679 return 0;
680}
FRRouting mirror