Annotation of embedaddon/quagga/zebra/zebra_snmp.c, revision 1.1
1.1 ! misho 1: /* FIB SNMP.
! 2: * Copyright (C) 1999 Kunihiro Ishiguro
! 3: *
! 4: * This file is part of GNU Zebra.
! 5: *
! 6: * GNU Zebra is free software; you can redistribute it and/or modify it
! 7: * under the terms of the GNU General Public License as published by the
! 8: * Free Software Foundation; either version 2, or (at your option) any
! 9: * later version.
! 10: *
! 11: * GNU Zebra is distributed in the hope that it will be useful, but
! 12: * WITHOUT ANY WARRANTY; without even the implied warranty of
! 13: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
! 14: * General Public License for more details.
! 15: *
! 16: * You should have received a copy of the GNU General Public License
! 17: * along with GNU Zebra; see the file COPYING. If not, write to the Free
! 18: * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
! 19: * 02111-1307, USA.
! 20: */
! 21:
! 22: #include <zebra.h>
! 23:
! 24: #ifdef HAVE_SNMP
! 25: #ifdef HAVE_NETSNMP
! 26: #include <net-snmp/net-snmp-config.h>
! 27: #include <net-snmp/net-snmp-includes.h>
! 28: #else
! 29: #include <asn1.h>
! 30: #include <snmp.h>
! 31: #include <snmp_impl.h>
! 32: #endif
! 33:
! 34: #include "if.h"
! 35: #include "log.h"
! 36: #include "prefix.h"
! 37: #include "command.h"
! 38: #include "smux.h"
! 39: #include "table.h"
! 40:
! 41: #include "zebra/rib.h"
! 42: #include "zebra/zserv.h"
! 43:
! 44: #define IPFWMIB 1,3,6,1,2,1,4,24
! 45:
! 46: /* ipForwardTable */
! 47: #define IPFORWARDDEST 1
! 48: #define IPFORWARDMASK 2
! 49: #define IPFORWARDPOLICY 3
! 50: #define IPFORWARDNEXTHOP 4
! 51: #define IPFORWARDIFINDEX 5
! 52: #define IPFORWARDTYPE 6
! 53: #define IPFORWARDPROTO 7
! 54: #define IPFORWARDAGE 8
! 55: #define IPFORWARDINFO 9
! 56: #define IPFORWARDNEXTHOPAS 10
! 57: #define IPFORWARDMETRIC1 11
! 58: #define IPFORWARDMETRIC2 12
! 59: #define IPFORWARDMETRIC3 13
! 60: #define IPFORWARDMETRIC4 14
! 61: #define IPFORWARDMETRIC5 15
! 62:
! 63: /* ipCidrRouteTable */
! 64: #define IPCIDRROUTEDEST 1
! 65: #define IPCIDRROUTEMASK 2
! 66: #define IPCIDRROUTETOS 3
! 67: #define IPCIDRROUTENEXTHOP 4
! 68: #define IPCIDRROUTEIFINDEX 5
! 69: #define IPCIDRROUTETYPE 6
! 70: #define IPCIDRROUTEPROTO 7
! 71: #define IPCIDRROUTEAGE 8
! 72: #define IPCIDRROUTEINFO 9
! 73: #define IPCIDRROUTENEXTHOPAS 10
! 74: #define IPCIDRROUTEMETRIC1 11
! 75: #define IPCIDRROUTEMETRIC2 12
! 76: #define IPCIDRROUTEMETRIC3 13
! 77: #define IPCIDRROUTEMETRIC4 14
! 78: #define IPCIDRROUTEMETRIC5 15
! 79: #define IPCIDRROUTESTATUS 16
! 80:
! 81: #define INTEGER32 ASN_INTEGER
! 82: #define GAUGE32 ASN_GAUGE
! 83: #define ENUMERATION ASN_INTEGER
! 84: #define ROWSTATUS ASN_INTEGER
! 85: #define IPADDRESS ASN_IPADDRESS
! 86: #define OBJECTIDENTIFIER ASN_OBJECT_ID
! 87:
! 88: extern struct zebra_t zebrad;
! 89:
! 90: oid ipfw_oid [] = { IPFWMIB };
! 91:
! 92: /* Hook functions. */
! 93: static u_char * ipFwNumber (struct variable *, oid [], size_t *,
! 94: int, size_t *, WriteMethod **);
! 95: static u_char * ipFwTable (struct variable *, oid [], size_t *,
! 96: int, size_t *, WriteMethod **);
! 97: static u_char * ipCidrNumber (struct variable *, oid [], size_t *,
! 98: int, size_t *, WriteMethod **);
! 99: static u_char * ipCidrTable (struct variable *, oid [], size_t *,
! 100: int, size_t *, WriteMethod **);
! 101:
! 102: struct variable zebra_variables[] =
! 103: {
! 104: {0, GAUGE32, RONLY, ipFwNumber, 1, {1}},
! 105: {IPFORWARDDEST, IPADDRESS, RONLY, ipFwTable, 3, {2, 1, 1}},
! 106: {IPFORWARDMASK, IPADDRESS, RONLY, ipFwTable, 3, {2, 1, 2}},
! 107: {IPFORWARDPOLICY, INTEGER32, RONLY, ipFwTable, 3, {2, 1, 3}},
! 108: {IPFORWARDNEXTHOP, IPADDRESS, RONLY, ipFwTable, 3, {2, 1, 4}},
! 109: {IPFORWARDIFINDEX, INTEGER32, RONLY, ipFwTable, 3, {2, 1, 5}},
! 110: {IPFORWARDTYPE, ENUMERATION, RONLY, ipFwTable, 3, {2, 1, 6}},
! 111: {IPFORWARDPROTO, ENUMERATION, RONLY, ipFwTable, 3, {2, 1, 7}},
! 112: {IPFORWARDAGE, INTEGER32, RONLY, ipFwTable, 3, {2, 1, 8}},
! 113: {IPFORWARDINFO, OBJECTIDENTIFIER, RONLY, ipFwTable, 3, {2, 1, 9}},
! 114: {IPFORWARDNEXTHOPAS, INTEGER32, RONLY, ipFwTable, 3, {2, 1, 10}},
! 115: {IPFORWARDMETRIC1, INTEGER32, RONLY, ipFwTable, 3, {2, 1, 11}},
! 116: {IPFORWARDMETRIC2, INTEGER32, RONLY, ipFwTable, 3, {2, 1, 12}},
! 117: {IPFORWARDMETRIC3, INTEGER32, RONLY, ipFwTable, 3, {2, 1, 13}},
! 118: {IPFORWARDMETRIC4, INTEGER32, RONLY, ipFwTable, 3, {2, 1, 14}},
! 119: {IPFORWARDMETRIC5, INTEGER32, RONLY, ipFwTable, 3, {2, 1, 15}},
! 120: {0, GAUGE32, RONLY, ipCidrNumber, 1, {3}},
! 121: {IPCIDRROUTEDEST, IPADDRESS, RONLY, ipCidrTable, 3, {4, 1, 1}},
! 122: {IPCIDRROUTEMASK, IPADDRESS, RONLY, ipCidrTable, 3, {4, 1, 2}},
! 123: {IPCIDRROUTETOS, INTEGER32, RONLY, ipCidrTable, 3, {4, 1, 3}},
! 124: {IPCIDRROUTENEXTHOP, IPADDRESS, RONLY, ipCidrTable, 3, {4, 1, 4}},
! 125: {IPCIDRROUTEIFINDEX, INTEGER32, RONLY, ipCidrTable, 3, {4, 1, 5}},
! 126: {IPCIDRROUTETYPE, ENUMERATION, RONLY, ipCidrTable, 3, {4, 1, 6}},
! 127: {IPCIDRROUTEPROTO, ENUMERATION, RONLY, ipCidrTable, 3, {4, 1, 7}},
! 128: {IPCIDRROUTEAGE, INTEGER32, RONLY, ipCidrTable, 3, {4, 1, 8}},
! 129: {IPCIDRROUTEINFO, OBJECTIDENTIFIER, RONLY, ipCidrTable, 3, {4, 1, 9}},
! 130: {IPCIDRROUTENEXTHOPAS, INTEGER32, RONLY, ipCidrTable, 3, {4, 1, 10}},
! 131: {IPCIDRROUTEMETRIC1, INTEGER32, RONLY, ipCidrTable, 3, {4, 1, 11}},
! 132: {IPCIDRROUTEMETRIC2, INTEGER32, RONLY, ipCidrTable, 3, {4, 1, 12}},
! 133: {IPCIDRROUTEMETRIC3, INTEGER32, RONLY, ipCidrTable, 3, {4, 1, 13}},
! 134: {IPCIDRROUTEMETRIC4, INTEGER32, RONLY, ipCidrTable, 3, {4, 1, 14}},
! 135: {IPCIDRROUTEMETRIC5, INTEGER32, RONLY, ipCidrTable, 3, {4, 1, 15}},
! 136: {IPCIDRROUTESTATUS, ROWSTATUS, RONLY, ipCidrTable, 3, {4, 1, 16}}
! 137: };
! 138:
! 139:
! 140: static u_char *
! 141: ipFwNumber (struct variable *v, oid objid[], size_t *objid_len,
! 142: int exact, size_t *val_len, WriteMethod **write_method)
! 143: {
! 144: static int result;
! 145: struct route_table *table;
! 146: struct route_node *rn;
! 147: struct rib *rib;
! 148:
! 149: if (smux_header_generic(v, objid, objid_len, exact, val_len, write_method) == MATCH_FAILED)
! 150: return NULL;
! 151:
! 152: table = vrf_table (AFI_IP, SAFI_UNICAST, 0);
! 153: if (! table)
! 154: return NULL;
! 155:
! 156: /* Return number of routing entries. */
! 157: result = 0;
! 158: for (rn = route_top (table); rn; rn = route_next (rn))
! 159: for (rib = rn->info; rib; rib = rib->next)
! 160: result++;
! 161:
! 162: return (u_char *)&result;
! 163: }
! 164:
! 165: static u_char *
! 166: ipCidrNumber (struct variable *v, oid objid[], size_t *objid_len,
! 167: int exact, size_t *val_len, WriteMethod **write_method)
! 168: {
! 169: static int result;
! 170: struct route_table *table;
! 171: struct route_node *rn;
! 172: struct rib *rib;
! 173:
! 174: if (smux_header_generic(v, objid, objid_len, exact, val_len, write_method) == MATCH_FAILED)
! 175: return NULL;
! 176:
! 177: table = vrf_table (AFI_IP, SAFI_UNICAST, 0);
! 178: if (! table)
! 179: return 0;
! 180:
! 181: /* Return number of routing entries. */
! 182: result = 0;
! 183: for (rn = route_top (table); rn; rn = route_next (rn))
! 184: for (rib = rn->info; rib; rib = rib->next)
! 185: result++;
! 186:
! 187: return (u_char *)&result;
! 188: }
! 189:
! 190: static int
! 191: in_addr_cmp(u_char *p1, u_char *p2)
! 192: {
! 193: int i;
! 194:
! 195: for (i=0; i<4; i++)
! 196: {
! 197: if (*p1 < *p2)
! 198: return -1;
! 199: if (*p1 > *p2)
! 200: return 1;
! 201: p1++; p2++;
! 202: }
! 203: return 0;
! 204: }
! 205:
! 206: static int
! 207: in_addr_add(u_char *p, int num)
! 208: {
! 209: int i, ip0;
! 210:
! 211: ip0 = *p;
! 212: p += 4;
! 213: for (i = 3; 0 <= i; i--) {
! 214: p--;
! 215: if (*p + num > 255) {
! 216: *p += num;
! 217: num = 1;
! 218: } else {
! 219: *p += num;
! 220: return 1;
! 221: }
! 222: }
! 223: if (ip0 > *p) {
! 224: /* ip + num > 0xffffffff */
! 225: return 0;
! 226: }
! 227:
! 228: return 1;
! 229: }
! 230:
! 231: static int
! 232: proto_trans(int type)
! 233: {
! 234: switch (type)
! 235: {
! 236: case ZEBRA_ROUTE_SYSTEM:
! 237: return 1; /* other */
! 238: case ZEBRA_ROUTE_KERNEL:
! 239: return 1; /* other */
! 240: case ZEBRA_ROUTE_CONNECT:
! 241: return 2; /* local interface */
! 242: case ZEBRA_ROUTE_STATIC:
! 243: return 3; /* static route */
! 244: case ZEBRA_ROUTE_RIP:
! 245: return 8; /* rip */
! 246: case ZEBRA_ROUTE_RIPNG:
! 247: return 1; /* shouldn't happen */
! 248: case ZEBRA_ROUTE_OSPF:
! 249: return 13; /* ospf */
! 250: case ZEBRA_ROUTE_OSPF6:
! 251: return 1; /* shouldn't happen */
! 252: case ZEBRA_ROUTE_BGP:
! 253: return 14; /* bgp */
! 254: default:
! 255: return 1; /* other */
! 256: }
! 257: }
! 258:
! 259: static void
! 260: check_replace(struct route_node *np2, struct rib *rib2,
! 261: struct route_node **np, struct rib **rib)
! 262: {
! 263: int proto, proto2;
! 264:
! 265: if (!*np)
! 266: {
! 267: *np = np2;
! 268: *rib = rib2;
! 269: return;
! 270: }
! 271:
! 272: if (in_addr_cmp(&(*np)->p.u.prefix, &np2->p.u.prefix) < 0)
! 273: return;
! 274: if (in_addr_cmp(&(*np)->p.u.prefix, &np2->p.u.prefix) > 0)
! 275: {
! 276: *np = np2;
! 277: *rib = rib2;
! 278: return;
! 279: }
! 280:
! 281: proto = proto_trans((*rib)->type);
! 282: proto2 = proto_trans(rib2->type);
! 283:
! 284: if (proto2 > proto)
! 285: return;
! 286: if (proto2 < proto)
! 287: {
! 288: *np = np2;
! 289: *rib = rib2;
! 290: return;
! 291: }
! 292:
! 293: if (in_addr_cmp((u_char *)&(*rib)->nexthop->gate.ipv4,
! 294: (u_char *)&rib2->nexthop->gate.ipv4) <= 0)
! 295: return;
! 296:
! 297: *np = np2;
! 298: *rib = rib2;
! 299: return;
! 300: }
! 301:
! 302: static void
! 303: get_fwtable_route_node(struct variable *v, oid objid[], size_t *objid_len,
! 304: int exact, struct route_node **np, struct rib **rib)
! 305: {
! 306: struct in_addr dest;
! 307: struct route_table *table;
! 308: struct route_node *np2;
! 309: struct rib *rib2;
! 310: int proto;
! 311: int policy;
! 312: struct in_addr nexthop;
! 313: u_char *pnt;
! 314: int i;
! 315:
! 316: /* Init index variables */
! 317:
! 318: pnt = (u_char *) &dest;
! 319: for (i = 0; i < 4; i++)
! 320: *pnt++ = 0;
! 321:
! 322: pnt = (u_char *) &nexthop;
! 323: for (i = 0; i < 4; i++)
! 324: *pnt++ = 0;
! 325:
! 326: proto = 0;
! 327: policy = 0;
! 328:
! 329: /* Init return variables */
! 330:
! 331: *np = NULL;
! 332: *rib = NULL;
! 333:
! 334: /* Short circuit exact matches of wrong length */
! 335:
! 336: if (exact && (*objid_len != (unsigned) v->namelen + 10))
! 337: return;
! 338:
! 339: table = vrf_table (AFI_IP, SAFI_UNICAST, 0);
! 340: if (! table)
! 341: return;
! 342:
! 343: /* Get INDEX information out of OID.
! 344: * ipForwardDest, ipForwardProto, ipForwardPolicy, ipForwardNextHop
! 345: */
! 346:
! 347: if (*objid_len > (unsigned) v->namelen)
! 348: oid2in_addr (objid + v->namelen, MIN(4, *objid_len - v->namelen), &dest);
! 349:
! 350: if (*objid_len > (unsigned) v->namelen + 4)
! 351: proto = objid[v->namelen + 4];
! 352:
! 353: if (*objid_len > (unsigned) v->namelen + 5)
! 354: policy = objid[v->namelen + 5];
! 355:
! 356: if (*objid_len > (unsigned) v->namelen + 6)
! 357: oid2in_addr (objid + v->namelen + 6, MIN(4, *objid_len - v->namelen - 6),
! 358: &nexthop);
! 359:
! 360: /* Apply GETNEXT on not exact search */
! 361:
! 362: if (!exact && (*objid_len >= (unsigned) v->namelen + 10))
! 363: {
! 364: if (! in_addr_add((u_char *) &nexthop, 1))
! 365: return;
! 366: }
! 367:
! 368: /* For exact: search matching entry in rib table. */
! 369:
! 370: if (exact)
! 371: {
! 372: if (policy) /* Not supported (yet?) */
! 373: return;
! 374: for (*np = route_top (table); *np; *np = route_next (*np))
! 375: {
! 376: if (!in_addr_cmp(&(*np)->p.u.prefix, (u_char *)&dest))
! 377: {
! 378: for (*rib = (*np)->info; *rib; *rib = (*rib)->next)
! 379: {
! 380: if (!in_addr_cmp((u_char *)&(*rib)->nexthop->gate.ipv4,
! 381: (u_char *)&nexthop))
! 382: if (proto == proto_trans((*rib)->type))
! 383: return;
! 384: }
! 385: }
! 386: }
! 387: return;
! 388: }
! 389:
! 390: /* Search next best entry */
! 391:
! 392: for (np2 = route_top (table); np2; np2 = route_next (np2))
! 393: {
! 394:
! 395: /* Check destination first */
! 396: if (in_addr_cmp(&np2->p.u.prefix, (u_char *)&dest) > 0)
! 397: for (rib2 = np2->info; rib2; rib2 = rib2->next)
! 398: check_replace(np2, rib2, np, rib);
! 399:
! 400: if (in_addr_cmp(&np2->p.u.prefix, (u_char *)&dest) == 0)
! 401: { /* have to look at each rib individually */
! 402: for (rib2 = np2->info; rib2; rib2 = rib2->next)
! 403: {
! 404: int proto2, policy2;
! 405:
! 406: proto2 = proto_trans(rib2->type);
! 407: policy2 = 0;
! 408:
! 409: if ((policy < policy2)
! 410: || ((policy == policy2) && (proto < proto2))
! 411: || ((policy == policy2) && (proto == proto2)
! 412: && (in_addr_cmp((u_char *)&rib2->nexthop->gate.ipv4,
! 413: (u_char *) &nexthop) >= 0)
! 414: ))
! 415: check_replace(np2, rib2, np, rib);
! 416: }
! 417: }
! 418: }
! 419:
! 420: if (!*rib)
! 421: return;
! 422:
! 423: policy = 0;
! 424: proto = proto_trans((*rib)->type);
! 425:
! 426: *objid_len = v->namelen + 10;
! 427: pnt = (u_char *) &(*np)->p.u.prefix;
! 428: for (i = 0; i < 4; i++)
! 429: objid[v->namelen + i] = *pnt++;
! 430:
! 431: objid[v->namelen + 4] = proto;
! 432: objid[v->namelen + 5] = policy;
! 433:
! 434: {
! 435: struct nexthop *nexthop;
! 436:
! 437: nexthop = (*rib)->nexthop;
! 438: if (nexthop)
! 439: {
! 440: pnt = (u_char *) &nexthop->gate.ipv4;
! 441: for (i = 0; i < 4; i++)
! 442: objid[i + v->namelen + 6] = *pnt++;
! 443: }
! 444: }
! 445:
! 446: return;
! 447: }
! 448:
! 449: static u_char *
! 450: ipFwTable (struct variable *v, oid objid[], size_t *objid_len,
! 451: int exact, size_t *val_len, WriteMethod **write_method)
! 452: {
! 453: struct route_node *np;
! 454: struct rib *rib;
! 455: static int result;
! 456: static int resarr[2];
! 457: static struct in_addr netmask;
! 458: struct nexthop *nexthop;
! 459:
! 460: get_fwtable_route_node(v, objid, objid_len, exact, &np, &rib);
! 461: if (!np)
! 462: return NULL;
! 463:
! 464: nexthop = rib->nexthop;
! 465: if (! nexthop)
! 466: return NULL;
! 467:
! 468: switch (v->magic)
! 469: {
! 470: case IPFORWARDDEST:
! 471: *val_len = 4;
! 472: return &np->p.u.prefix;
! 473: break;
! 474: case IPFORWARDMASK:
! 475: masklen2ip(np->p.prefixlen, &netmask);
! 476: *val_len = 4;
! 477: return (u_char *)&netmask;
! 478: break;
! 479: case IPFORWARDPOLICY:
! 480: result = 0;
! 481: *val_len = sizeof(int);
! 482: return (u_char *)&result;
! 483: break;
! 484: case IPFORWARDNEXTHOP:
! 485: *val_len = 4;
! 486: return (u_char *)&nexthop->gate.ipv4;
! 487: break;
! 488: case IPFORWARDIFINDEX:
! 489: *val_len = sizeof(int);
! 490: return (u_char *)&nexthop->ifindex;
! 491: break;
! 492: case IPFORWARDTYPE:
! 493: if (nexthop->type == NEXTHOP_TYPE_IFINDEX
! 494: || nexthop->type == NEXTHOP_TYPE_IFNAME)
! 495: result = 3;
! 496: else
! 497: result = 4;
! 498: *val_len = sizeof(int);
! 499: return (u_char *)&result;
! 500: break;
! 501: case IPFORWARDPROTO:
! 502: result = proto_trans(rib->type);
! 503: *val_len = sizeof(int);
! 504: return (u_char *)&result;
! 505: break;
! 506: case IPFORWARDAGE:
! 507: result = 0;
! 508: *val_len = sizeof(int);
! 509: return (u_char *)&result;
! 510: break;
! 511: case IPFORWARDINFO:
! 512: resarr[0] = 0;
! 513: resarr[1] = 0;
! 514: *val_len = 2 * sizeof(int);
! 515: return (u_char *)resarr;
! 516: break;
! 517: case IPFORWARDNEXTHOPAS:
! 518: result = -1;
! 519: *val_len = sizeof(int);
! 520: return (u_char *)&result;
! 521: break;
! 522: case IPFORWARDMETRIC1:
! 523: result = 0;
! 524: *val_len = sizeof(int);
! 525: return (u_char *)&result;
! 526: break;
! 527: case IPFORWARDMETRIC2:
! 528: result = 0;
! 529: *val_len = sizeof(int);
! 530: return (u_char *)&result;
! 531: break;
! 532: case IPFORWARDMETRIC3:
! 533: result = 0;
! 534: *val_len = sizeof(int);
! 535: return (u_char *)&result;
! 536: break;
! 537: case IPFORWARDMETRIC4:
! 538: result = 0;
! 539: *val_len = sizeof(int);
! 540: return (u_char *)&result;
! 541: break;
! 542: case IPFORWARDMETRIC5:
! 543: result = 0;
! 544: *val_len = sizeof(int);
! 545: return (u_char *)&result;
! 546: break;
! 547: default:
! 548: return NULL;
! 549: break;
! 550: }
! 551: return NULL;
! 552: }
! 553:
! 554: static u_char *
! 555: ipCidrTable (struct variable *v, oid objid[], size_t *objid_len,
! 556: int exact, size_t *val_len, WriteMethod **write_method)
! 557: {
! 558: switch (v->magic)
! 559: {
! 560: case IPCIDRROUTEDEST:
! 561: break;
! 562: default:
! 563: return NULL;
! 564: break;
! 565: }
! 566: return NULL;
! 567: }
! 568:
! 569: void
! 570: zebra_snmp_init ()
! 571: {
! 572: smux_init (zebrad.master);
! 573: REGISTER_MIB("mibII/ipforward", zebra_variables, variable, ipfw_oid);
! 574: }
! 575: #endif /* HAVE_SNMP */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to zebra_snmp.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / zebra