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