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)->nexthop->gate.ipv4,
 289                         (u_char *)&re2->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((u_char *)&(*re)
 374                                                                  ->nexthop->gate
 375                                                                  .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((u_char *)&re2->nexthop
 408                                                                 ->gate.ipv4,
 409                                                         (u_char *)&nexthop)
 410                                             >= 0)))
 411                                         check_replace(np2, re2, np, re);
 412                         }
 413                 }
 414         }
 415
 416         if (!*re)
 417                 return;
 418
 419         policy = 0;
 420         proto = proto_trans((*re)->type);
 421
 422         *objid_len = v->namelen + 10;
 423         pnt = (u_char *)&(*np)->p.u.prefix;
 424         for (i = 0; i < 4; i++)
 425                 objid[v->namelen + i] = *pnt++;
 426
 427         objid[v->namelen + 4] = proto;
 428         objid[v->namelen + 5] = policy;
 429
 430         {
 431                 struct nexthop *nexthop;
 432
 433                 nexthop = (*re)->nexthop;
 434                 if (nexthop) {
 435                         pnt = (u_char *)&nexthop->gate.ipv4;
 436                         for (i = 0; i < 4; i++)
 437                                 objid[i + v->namelen + 6] = *pnt++;
 438                 }
 439         }
 440
 441         return;
 442 }
 443
 444 static u_char *ipFwTable(struct variable *v, oid objid[], size_t *objid_len,
 445                          int exact, size_t *val_len, WriteMethod **write_method)
 446 {
 447         struct route_node *np;
 448         struct route_entry *re;
 449         static int result;
 450         static int resarr[2];
 451         static struct in_addr netmask;
 452         struct nexthop *nexthop;
 453
 454         if (smux_header_table(v, objid, objid_len, exact, val_len, write_method)
 455             == MATCH_FAILED)
 456                 return NULL;
 457
 458         get_fwtable_route_node(v, objid, objid_len, exact, &np, &re);
 459         if (!np)
 460                 return NULL;
 461
 462         nexthop = re->nexthop;
 463         if (!nexthop)
 464                 return NULL;
 465
 466         switch (v->magic) {
 467         case IPFORWARDDEST:
 468                 *val_len = 4;
 469                 return &np->p.u.prefix;
 470                 break;
 471         case IPFORWARDMASK:
 472                 masklen2ip(np->p.prefixlen, &netmask);
 473                 *val_len = 4;
 474                 return (u_char *)&netmask;
 475                 break;
 476         case IPFORWARDPOLICY:
 477                 result = 0;
 478                 *val_len = sizeof(int);
 479                 return (u_char *)&result;
 480                 break;
 481         case IPFORWARDNEXTHOP:
 482                 *val_len = 4;
 483                 return (u_char *)&nexthop->gate.ipv4;
 484                 break;
 485         case IPFORWARDIFINDEX:
 486                 *val_len = sizeof(int);
 487                 return (u_char *)&nexthop->ifindex;
 488                 break;
 489         case IPFORWARDTYPE:
 490                 if (nexthop->type == NEXTHOP_TYPE_IFINDEX)
 491                         result = 3;
 492                 else
 493                         result = 4;
 494                 *val_len = sizeof(int);
 495                 return (u_char *)&result;
 496                 break;
 497         case IPFORWARDPROTO:
 498                 result = proto_trans(re->type);
 499                 *val_len = sizeof(int);
 500                 return (u_char *)&result;
 501                 break;
 502         case IPFORWARDAGE:
 503                 result = 0;
 504                 *val_len = sizeof(int);
 505                 return (u_char *)&result;
 506                 break;
 507         case IPFORWARDINFO:
 508                 resarr[0] = 0;
 509                 resarr[1] = 0;
 510                 *val_len = 2 * sizeof(int);
 511                 return (u_char *)resarr;
 512                 break;
 513         case IPFORWARDNEXTHOPAS:
 514                 result = -1;
 515                 *val_len = sizeof(int);
 516                 return (u_char *)&result;
 517                 break;
 518         case IPFORWARDMETRIC1:
 519                 result = 0;
 520                 *val_len = sizeof(int);
 521                 return (u_char *)&result;
 522                 break;
 523         case IPFORWARDMETRIC2:
 524                 result = 0;
 525                 *val_len = sizeof(int);
 526                 return (u_char *)&result;
 527                 break;
 528         case IPFORWARDMETRIC3:
 529                 result = 0;
 530                 *val_len = sizeof(int);
 531                 return (u_char *)&result;
 532                 break;
 533         case IPFORWARDMETRIC4:
 534                 result = 0;
 535                 *val_len = sizeof(int);
 536                 return (u_char *)&result;
 537                 break;
 538         case IPFORWARDMETRIC5:
 539                 result = 0;
 540                 *val_len = sizeof(int);
 541                 return (u_char *)&result;
 542                 break;
 543         default:
 544                 return NULL;
 545                 break;
 546         }
 547         return NULL;
 548 }
 549
 550 static u_char *ipCidrTable(struct variable *v, oid objid[], size_t *objid_len,
 551                            int exact, size_t *val_len,
 552                            WriteMethod **write_method)
 553 {
 554         if (smux_header_table(v, objid, objid_len, exact, val_len, write_method)
 555             == MATCH_FAILED)
 556                 return NULL;
 557
 558         switch (v->magic) {
 559         case IPCIDRROUTEDEST:
 560                 break;
 561         default:
 562                 return NULL;
 563                 break;
 564         }
 565         return NULL;
 566 }
 567
 568 static int zebra_snmp_init(struct thread_master *tm)
 569 {
 570         smux_init(tm);
 571         REGISTER_MIB("mibII/ipforward", zebra_variables, variable, ipfw_oid);
 572         return 0;
 573 }
 574
 575 static int zebra_snmp_module_init(void)
 576 {
 577         hook_register(frr_late_init, zebra_snmp_init);
 578         return 0;
 579 }
 580
 581 FRR_MODULE_SETUP(.name = "zebra_snmp", .version = FRR_VERSION,
 582                  .description = "zebra AgentX SNMP module",
 583                  .init = zebra_snmp_module_init, )