zebra/zebra_snmp.c

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