contrib/bsnmp/snmp_mibII/mibII_route.c

   1 /*
   2  * Copyright (c) 2001-2003
   3  *      Fraunhofer Institute for Open Communication Systems (FhG Fokus).
   4  *      All rights reserved.
   5  *
   6  * Author: Harti Brandt <harti@freebsd.org>
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  * $Begemot: bsnmp/snmp_mibII/mibII_route.c,v 1.9 2005/10/06 07:15:00 brandt_h Exp $
  30  *
  31  * Routing table
  32  */
  33
  34 #ifdef HAVE_SYS_TREE_H
  35 #include <sys/tree.h>
  36 #else
  37 #include "tree.h"
  38 #endif
  39
  40 #include "mibII.h"
  41 #include "mibII_oid.h"
  42
  43 struct sroute {
  44         RB_ENTRY(sroute) link;
  45         uint32_t        ifindex;
  46         uint8_t         index[13];
  47         uint8_t         type;
  48         uint8_t         proto;
  49 };
  50 RB_HEAD(sroutes, sroute) sroutes = RB_INITIALIZER(&sroutes);
  51
  52 RB_PROTOTYPE(sroutes, sroute, link, sroute_compare);
  53
  54 #define ROUTE_UPDATE_INTERVAL   (100 * 60 * 10) /* 10 min */
  55 static uint64_t route_tick;
  56 static u_int route_total;
  57
  58 /*
  59  * Compare two routes
  60  */
  61 static int
  62 sroute_compare(struct sroute *s1, struct sroute *s2)
  63 {
  64
  65         return (memcmp(s1->index, s2->index, 13));
  66 }
  67
  68 static void
  69 sroute_index_append(struct asn_oid *oid, u_int sub, const struct sroute *s)
  70 {
  71         int i;
  72
  73         oid->len = sub + 13;
  74         for (i = 0; i < 13; i++)
  75                 oid->subs[sub + i] = s->index[i];
  76 }
  77
  78 #if 0
  79 static void
  80 sroute_print(const struct sroute *r)
  81 {
  82         u_int i;
  83
  84         for (i = 0; i < 13 - 1; i++)
  85                 printf("%u.", r->index[i]);
  86         printf("%u proto=%u type=%u", r->index[i], r->proto, r->type);
  87 }
  88 #endif
  89
  90 /*
  91  * process routing message
  92  */
  93 void
  94 mib_sroute_process(struct rt_msghdr *rtm, struct sockaddr *gw,
  95     struct sockaddr *dst, struct sockaddr *mask)
  96 {
  97         struct sockaddr_in *in_dst, *in_gw;
  98         struct in_addr in_mask;
  99         struct mibif *ifp;
 100         struct sroute key;
 101         struct sroute *r, *r1;
 102         in_addr_t ha;
 103
 104         if (dst == NULL || gw == NULL || dst->sa_family != AF_INET ||
 105             gw->sa_family != AF_INET)
 106                 return;
 107
 108         in_dst = (struct sockaddr_in *)(void *)dst;
 109         in_gw = (struct sockaddr_in *)(void *)gw;
 110
 111         if (rtm->rtm_flags & RTF_HOST)
 112                 in_mask.s_addr = 0xffffffff;
 113         else if (mask == NULL || mask->sa_len == 0)
 114                 in_mask.s_addr = 0;
 115         else
 116                 in_mask = ((struct sockaddr_in *)(void *)mask)->sin_addr;
 117
 118         /* build the index */
 119         ha = ntohl(in_dst->sin_addr.s_addr);
 120         key.index[0] = (ha >> 24) & 0xff;
 121         key.index[1] = (ha >> 16) & 0xff;
 122         key.index[2] = (ha >>  8) & 0xff;
 123         key.index[3] = (ha >>  0) & 0xff;
 124
 125         ha = ntohl(in_mask.s_addr);
 126         key.index[4] = (ha >> 24) & 0xff;
 127         key.index[5] = (ha >> 16) & 0xff;
 128         key.index[6] = (ha >>  8) & 0xff;
 129         key.index[7] = (ha >>  0) & 0xff;
 130
 131         /* ToS */
 132         key.index[8] = 0;
 133
 134         ha = ntohl(in_gw->sin_addr.s_addr);
 135         key.index[9] = (ha >> 24) & 0xff;
 136         key.index[10] = (ha >> 16) & 0xff;
 137         key.index[11] = (ha >>  8) & 0xff;
 138         key.index[12] = (ha >>  0) & 0xff;
 139
 140         if (rtm->rtm_type == RTM_DELETE) {
 141                 r = RB_FIND(sroutes, &sroutes, &key);
 142                 if (r == 0) {
 143 #ifdef DEBUG_ROUTE
 144                         syslog(LOG_WARNING, "%s: DELETE: %u.%u.%u.%u "
 145                             "%u.%u.%u.%u %u %u.%u.%u.%u not found", __func__,
 146                             key.index[0], key.index[1], key.index[2],
 147                             key.index[3], key.index[4], key.index[5],
 148                             key.index[6], key.index[7], key.index[8],
 149                             key.index[9], key.index[10], key.index[11],
 150                             key.index[12]);
 151 #endif
 152                         return;
 153                 }
 154                 RB_REMOVE(sroutes, &sroutes, r);
 155                 free(r);
 156                 route_total--;
 157 #ifdef DEBUG_ROUTE
 158                 printf("%s: DELETE: %u.%u.%u.%u "
 159                     "%u.%u.%u.%u %u %u.%u.%u.%u\n", __func__,
 160                     key.index[0], key.index[1], key.index[2],
 161                     key.index[3], key.index[4], key.index[5],
 162                     key.index[6], key.index[7], key.index[8],
 163                     key.index[9], key.index[10], key.index[11],
 164                     key.index[12]);
 165 #endif
 166                 return;
 167         }
 168
 169         /* GET or ADD */
 170         ifp = NULL;
 171         if ((ifp = mib_find_if_sys(rtm->rtm_index)) == NULL) {
 172                 if (rtm->rtm_type == RTM_ADD) {
 173                         /* make it a get so the kernel fills the index */
 174                         mib_send_rtmsg(rtm, gw, dst, mask);
 175                         return;
 176                 }
 177                 mib_iflist_bad = 1;
 178         }
 179
 180         if ((r = malloc(sizeof(*r))) == NULL) {
 181                 syslog(LOG_ERR, "%m");
 182                 return;
 183         }
 184
 185         memcpy(r->index, key.index, sizeof(r->index));
 186         r->ifindex = (ifp == NULL) ? 0 : ifp->index;
 187
 188         r->type = (rtm->rtm_flags & RTF_REJECT) ? 2 : 4;
 189
 190         /* cannot really know, what protocol it runs */
 191         r->proto = (rtm->rtm_flags & RTF_LOCAL) ? 2 :
 192             (rtm->rtm_flags & RTF_STATIC) ? 3 :
 193             (rtm->rtm_flags & RTF_DYNAMIC) ? 4 : 10;
 194
 195         r1 = RB_INSERT(sroutes, &sroutes, r);
 196         if (r1 != NULL) {
 197 #ifdef DEBUG_ROUTE
 198                 syslog(LOG_WARNING, "%s: %u.%u.%u.%u "
 199                     "%u.%u.%u.%u %u %u.%u.%u.%u duplicate route", __func__,
 200                     key.index[0], key.index[1], key.index[2],
 201                     key.index[3], key.index[4], key.index[5],
 202                     key.index[6], key.index[7], key.index[8],
 203                     key.index[9], key.index[10], key.index[11],
 204                     key.index[12]);
 205 #endif
 206                 r1->ifindex = r->ifindex;
 207                 r1->type = r->type;
 208                 r1->proto = r->proto;
 209                 free(r);
 210                 return;
 211         }
 212
 213         route_total++;
 214 #ifdef DEBUG_ROUTE
 215         printf("%s: ADD/GET: %u.%u.%u.%u "
 216             "%u.%u.%u.%u %u %u.%u.%u.%u\n", __func__,
 217             key.index[0], key.index[1], key.index[2],
 218             key.index[3], key.index[4], key.index[5],
 219             key.index[6], key.index[7], key.index[8],
 220             key.index[9], key.index[10], key.index[11],
 221             key.index[12]);
 222 #endif
 223 }
 224
 225 int
 226 mib_fetch_route(void)
 227 {
 228         u_char *rtab, *next;
 229         size_t len;
 230         struct sroute *r, *r1;
 231         struct rt_msghdr *rtm;
 232         struct sockaddr *addrs[RTAX_MAX];
 233
 234         if (route_tick != 0 && route_tick + ROUTE_UPDATE_INTERVAL > this_tick)
 235                 return (0);
 236
 237         /*
 238          * Remove all routes
 239          */
 240         r = RB_MIN(sroutes, &sroutes);
 241         while (r != NULL) {
 242                 r1 = RB_NEXT(sroutes, &sroutes, r);
 243                 RB_REMOVE(sroutes, &sroutes, r);
 244                 free(r);
 245                 r = r1;
 246         }
 247         route_total = 0;
 248
 249         if ((rtab = mib_fetch_rtab(AF_INET, NET_RT_DUMP, 0, &len)) == NULL)
 250                 return (-1);
 251
 252         next = rtab;
 253         for (next = rtab; next < rtab + len; next += rtm->rtm_msglen) {
 254                 rtm = (struct rt_msghdr *)(void *)next;
 255                 if (rtm->rtm_type != RTM_GET ||
 256                     !(rtm->rtm_flags & RTF_UP))
 257                         continue;
 258                 mib_extract_addrs(rtm->rtm_addrs, (u_char *)(rtm + 1), addrs);
 259
 260
 261                 mib_sroute_process(rtm, addrs[RTAX_GATEWAY], addrs[RTAX_DST],
 262                     addrs[RTAX_NETMASK]);
 263         }
 264
 265 #if 0
 266         u_int n = 0;
 267         r = RB_MIN(sroutes, &sroutes);
 268         while (r != NULL) {
 269                 printf("%u: ", n++);
 270                 sroute_print(r);
 271                 printf("\n");
 272                 r = RB_NEXT(sroutes, &sroutes, r);
 273         }
 274 #endif
 275         free(rtab);
 276         route_tick = get_ticks();
 277
 278         return (0);
 279 }
 280
 281 /**
 282  * Find a route in the table.
 283  */
 284 static struct sroute *
 285 sroute_get(const struct asn_oid *oid, u_int sub)
 286 {
 287         struct sroute key;
 288         int i;
 289
 290         if (oid->len - sub != 13)
 291                 return (NULL);
 292         for (i = 0; i < 13; i++)
 293                 key.index[i] = oid->subs[sub + i];
 294         return (RB_FIND(sroutes, &sroutes, &key));
 295 }
 296
 297 /**
 298  * Find next route in the table. There is no such RB_ macro, so must
 299  * dig into the innards of the RB stuff.
 300  */
 301 static struct sroute *
 302 sroute_getnext(struct asn_oid *oid, u_int sub)
 303 {
 304         u_int i;
 305         int comp;
 306         struct sroute key;
 307         struct sroute *best;
 308         struct sroute *s;
 309
 310         /*
 311          * We now, that the OID is at least the tableEntry OID. If it is,
 312          * the user wants the first route.
 313          */
 314         if (oid->len == sub)
 315                 return (RB_MIN(sroutes, &sroutes));
 316
 317         /*
 318          * This is also true for any index that consists of zeros and is
 319          * shorter than the full index.
 320          */
 321         if (oid->len < sub + 13) {
 322                 for (i = sub; i < oid->len; i++)
 323                         if (oid->subs[i] != 0)
 324                                 break;
 325                 if (i == oid->len)
 326                         return (RB_MIN(sroutes, &sroutes));
 327
 328                 /*
 329                  * Now if the index is too short, we fill it with zeros and then
 330                  * subtract one from the index. We can do this, because we now,
 331                  * that there is at least one index element that is not zero.
 332                  */
 333                 for (i = oid->len; i < sub + 13; i++)
 334                         oid->subs[i] = 0;
 335
 336                 for (i = sub + 13 - 1; i >= sub; i--) {
 337                         if (oid->subs[i] != 0) {
 338                                 oid->subs[i]--;
 339                                 break;
 340                         }
 341                         oid->subs[i] = ASN_MAXID;
 342                 }
 343                 oid->len = sub + 13;
 344         }
 345
 346         /* build the index */
 347         for (i = sub; i < sub + 13; i++)
 348                 key.index[i - sub] = oid->subs[i];
 349
 350         /* now find the element */
 351         best = NULL;
 352         s = RB_ROOT(&sroutes);
 353
 354         while (s != NULL) {
 355                 comp = sroute_compare(&key, s);
 356                 if (comp >= 0) {
 357                         /* The current element is smaller than what we search.
 358                          * Forget about it and move to the right subtree. */
 359                         s = RB_RIGHT(s, link);
 360                         continue;
 361                 }
 362                 /* the current element is larger than what we search.
 363                  * forget about the right subtree (its even larger), but
 364                  * the current element may be what we need. */
 365                 if (best == NULL || sroute_compare(s, best) < 0)
 366                         /* this one's better */
 367                         best = s;
 368
 369                 s = RB_LEFT(s, link);
 370         }
 371         return (best);
 372 }
 373
 374 /*
 375  * Table
 376  */
 377 int
 378 op_route_table(struct snmp_context *ctx __unused, struct snmp_value *value,
 379     u_int sub, u_int iidx __unused, enum snmp_op op)
 380 {
 381         struct sroute *r;
 382
 383         if (mib_fetch_route() == -1)
 384                 return (SNMP_ERR_GENERR);
 385
 386         switch (op) {
 387
 388           case SNMP_OP_GETNEXT:
 389                 if ((r = sroute_getnext(&value->var, sub)) == NULL)
 390                         return (SNMP_ERR_NOSUCHNAME);
 391                 sroute_index_append(&value->var, sub, r);
 392                 break;
 393
 394           case SNMP_OP_GET:
 395                 if ((r = sroute_get(&value->var, sub)) == NULL)
 396                         return (SNMP_ERR_NOSUCHNAME);
 397                 break;
 398
 399           case SNMP_OP_SET:
 400                 if ((r = sroute_get(&value->var, sub)) == NULL)
 401                         return (SNMP_ERR_NOSUCHNAME);
 402                 return (SNMP_ERR_NOT_WRITEABLE);
 403
 404           case SNMP_OP_ROLLBACK:
 405           case SNMP_OP_COMMIT:
 406                 abort();
 407
 408           default:
 409                 abort();
 410         }
 411
 412         switch (value->var.subs[sub - 1]) {
 413
 414           case LEAF_ipCidrRouteDest:
 415                 value->v.ipaddress[0] = r->index[0];
 416                 value->v.ipaddress[1] = r->index[1];
 417                 value->v.ipaddress[2] = r->index[2];
 418                 value->v.ipaddress[3] = r->index[3];
 419                 break;
 420
 421           case LEAF_ipCidrRouteMask:
 422                 value->v.ipaddress[0] = r->index[4];
 423                 value->v.ipaddress[1] = r->index[5];
 424                 value->v.ipaddress[2] = r->index[6];
 425                 value->v.ipaddress[3] = r->index[7];
 426                 break;
 427
 428           case LEAF_ipCidrRouteTos:
 429                 value->v.integer = r->index[8];
 430                 break;
 431
 432           case LEAF_ipCidrRouteNextHop:
 433                 value->v.ipaddress[0] = r->index[9];
 434                 value->v.ipaddress[1] = r->index[10];
 435                 value->v.ipaddress[2] = r->index[11];
 436                 value->v.ipaddress[3] = r->index[12];
 437                 break;
 438
 439           case LEAF_ipCidrRouteIfIndex:
 440                 value->v.integer = r->ifindex;
 441                 break;
 442
 443           case LEAF_ipCidrRouteType:
 444                 value->v.integer = r->type;
 445                 break;
 446
 447           case LEAF_ipCidrRouteProto:
 448                 value->v.integer = r->proto;
 449                 break;
 450
 451           case LEAF_ipCidrRouteAge:
 452                 value->v.integer = 0;
 453                 break;
 454
 455           case LEAF_ipCidrRouteInfo:
 456                 value->v.oid = oid_zeroDotZero;
 457                 break;
 458
 459           case LEAF_ipCidrRouteNextHopAS:
 460                 value->v.integer = 0;
 461                 break;
 462
 463           case LEAF_ipCidrRouteMetric1:
 464           case LEAF_ipCidrRouteMetric2:
 465           case LEAF_ipCidrRouteMetric3:
 466           case LEAF_ipCidrRouteMetric4:
 467           case LEAF_ipCidrRouteMetric5:
 468                 value->v.integer = -1;
 469                 break;
 470
 471           case LEAF_ipCidrRouteStatus:
 472                 value->v.integer = 1;
 473                 break;
 474         }
 475         return (SNMP_ERR_NOERROR);
 476 }
 477
 478 /*
 479  * scalars
 480  */
 481 int
 482 op_route(struct snmp_context *ctx __unused, struct snmp_value *value,
 483     u_int sub, u_int iidx __unused, enum snmp_op op)
 484 {
 485         switch (op) {
 486
 487           case SNMP_OP_GETNEXT:
 488                 abort();
 489
 490           case SNMP_OP_GET:
 491                 break;
 492
 493           case SNMP_OP_SET:
 494                 return (SNMP_ERR_NOT_WRITEABLE);
 495
 496           case SNMP_OP_ROLLBACK:
 497           case SNMP_OP_COMMIT:
 498                 abort();
 499         }
 500
 501         if (mib_fetch_route() == -1)
 502                 return (SNMP_ERR_GENERR);
 503
 504         switch (value->var.subs[sub - 1]) {
 505
 506           case LEAF_ipCidrRouteNumber:
 507                 value->v.uint32 = route_total;
 508                 break;
 509
 510         }
 511         return (SNMP_ERR_NOERROR);
 512 }
 513
 514 RB_GENERATE(sroutes, sroute, link, sroute_compare);