Annotation of embedaddon/bird2/proto/rip/rip.c, revision 1.1
1.1 ! misho 1: /*
! 2: * BIRD -- Routing Information Protocol (RIP)
! 3: *
! 4: * (c) 1998--1999 Pavel Machek <pavel@ucw.cz>
! 5: * (c) 2004--2013 Ondrej Filip <feela@network.cz>
! 6: * (c) 2009--2015 Ondrej Zajicek <santiago@crfreenet.org>
! 7: * (c) 2009--2015 CZ.NIC z.s.p.o.
! 8: *
! 9: * Can be freely distributed and used under the terms of the GNU GPL.
! 10: */
! 11:
! 12: /**
! 13: * DOC: Routing Information Protocol (RIP)
! 14: *
! 15: * The RIP protocol is implemented in two files: |rip.c| containing the protocol
! 16: * logic, route management and the protocol glue with BIRD core, and |packets.c|
! 17: * handling RIP packet processing, RX, TX and protocol sockets.
! 18: *
! 19: * Each instance of RIP is described by a structure &rip_proto, which contains
! 20: * an internal RIP routing table, a list of protocol interfaces and the main
! 21: * timer responsible for RIP routing table cleanup.
! 22: *
! 23: * RIP internal routing table contains incoming and outgoing routes. For each
! 24: * network (represented by structure &rip_entry) there is one outgoing route
! 25: * stored directly in &rip_entry and an one-way linked list of incoming routes
! 26: * (structures &rip_rte). The list contains incoming routes from different RIP
! 27: * neighbors, but only routes with the lowest metric are stored (i.e., all
! 28: * stored incoming routes have the same metric).
! 29: *
! 30: * Note that RIP itself does not select outgoing route, that is done by the core
! 31: * routing table. When a new incoming route is received, it is propagated to the
! 32: * RIP table by rip_update_rte() and possibly stored in the list of incoming
! 33: * routes. Then the change may be propagated to the core by rip_announce_rte().
! 34: * The core selects the best route and propagate it to RIP by rip_rt_notify(),
! 35: * which updates outgoing route part of &rip_entry and possibly triggers route
! 36: * propagation by rip_trigger_update().
! 37: *
! 38: * RIP interfaces are represented by structures &rip_iface. A RIP interface
! 39: * contains a per-interface socket, a list of associated neighbors, interface
! 40: * configuration, and state information related to scheduled interface events
! 41: * and running update sessions. RIP interfaces are added and removed based on
! 42: * core interface notifications.
! 43: *
! 44: * There are two RIP interface events - regular updates and triggered updates.
! 45: * Both are managed from the RIP interface timer (rip_iface_timer()). Regular
! 46: * updates are called at fixed interval and propagate the whole routing table,
! 47: * while triggered updates are scheduled by rip_trigger_update() due to some
! 48: * routing table change and propagate only the routes modified since the time
! 49: * they were scheduled. There are also unicast-destined requested updates, but
! 50: * these are sent directly as a reaction to received RIP request message. The
! 51: * update session is started by rip_send_table(). There may be at most one
! 52: * active update session per interface, as the associated state (including the
! 53: * fib iterator) is stored directly in &rip_iface structure.
! 54: *
! 55: * RIP neighbors are represented by structures &rip_neighbor. Compared to
! 56: * neighbor handling in other routing protocols, RIP does not have explicit
! 57: * neighbor discovery and adjacency maintenance, which makes the &rip_neighbor
! 58: * related code a bit peculiar. RIP neighbors are interlinked with core neighbor
! 59: * structures (&neighbor) and use core neighbor notifications to ensure that RIP
! 60: * neighbors are timely removed. RIP neighbors are added based on received route
! 61: * notifications and removed based on core neighbor and RIP interface events.
! 62: *
! 63: * RIP neighbors are linked by RIP routes and use counter to track the number of
! 64: * associated routes, but when these RIP routes timeout, associated RIP neighbor
! 65: * is still alive (with zero counter). When RIP neighbor is removed but still
! 66: * has some associated routes, it is not freed, just changed to detached state
! 67: * (core neighbors and RIP ifaces are unlinked), then during the main timer
! 68: * cleanup phase the associated routes are removed and the &rip_neighbor
! 69: * structure is finally freed.
! 70: *
! 71: * Supported standards:
! 72: * - RFC 1058 - RIPv1
! 73: * - RFC 2453 - RIPv2
! 74: * - RFC 2080 - RIPng
! 75: * - RFC 4822 - RIP cryptographic authentication
! 76: */
! 77:
! 78: #include <stdlib.h>
! 79: #include "rip.h"
! 80:
! 81:
! 82: static inline void rip_lock_neighbor(struct rip_neighbor *n);
! 83: static inline void rip_unlock_neighbor(struct rip_neighbor *n);
! 84: static inline int rip_iface_link_up(struct rip_iface *ifa);
! 85: static inline void rip_kick_timer(struct rip_proto *p);
! 86: static inline void rip_iface_kick_timer(struct rip_iface *ifa);
! 87: static void rip_iface_timer(timer *timer);
! 88: static void rip_trigger_update(struct rip_proto *p);
! 89:
! 90:
! 91: /*
! 92: * RIP routes
! 93: */
! 94:
! 95: static struct rip_rte *
! 96: rip_add_rte(struct rip_proto *p, struct rip_rte **rp, struct rip_rte *src)
! 97: {
! 98: struct rip_rte *rt = sl_alloc(p->rte_slab);
! 99:
! 100: memcpy(rt, src, sizeof(struct rip_rte));
! 101: rt->next = *rp;
! 102: *rp = rt;
! 103:
! 104: rip_lock_neighbor(rt->from);
! 105:
! 106: return rt;
! 107: }
! 108:
! 109: static inline void
! 110: rip_remove_rte(struct rip_proto *p, struct rip_rte **rp)
! 111: {
! 112: struct rip_rte *rt = *rp;
! 113:
! 114: rip_unlock_neighbor(rt->from);
! 115:
! 116: *rp = rt->next;
! 117: sl_free(p->rte_slab, rt);
! 118: }
! 119:
! 120: static inline int rip_same_rte(struct rip_rte *a, struct rip_rte *b)
! 121: { return a->metric == b->metric && a->tag == b->tag && ipa_equal(a->next_hop, b->next_hop); }
! 122:
! 123: static inline int rip_valid_rte(struct rip_rte *rt)
! 124: { return rt->from->ifa != NULL; }
! 125:
! 126: /**
! 127: * rip_announce_rte - announce route from RIP routing table to the core
! 128: * @p: RIP instance
! 129: * @en: related network
! 130: *
! 131: * The function takes a list of incoming routes from @en, prepare appropriate
! 132: * &rte for the core and propagate it by rte_update().
! 133: */
! 134: static void
! 135: rip_announce_rte(struct rip_proto *p, struct rip_entry *en)
! 136: {
! 137: struct rip_rte *rt = en->routes;
! 138:
! 139: /* Find first valid rte */
! 140: while (rt && !rip_valid_rte(rt))
! 141: rt = rt->next;
! 142:
! 143: if (rt)
! 144: {
! 145: /* Update */
! 146: rta a0 = {
! 147: .src = p->p.main_source,
! 148: .source = RTS_RIP,
! 149: .scope = SCOPE_UNIVERSE,
! 150: .dest = RTD_UNICAST,
! 151: };
! 152:
! 153: u8 rt_metric = rt->metric;
! 154: u16 rt_tag = rt->tag;
! 155:
! 156: if (p->ecmp)
! 157: {
! 158: /* ECMP route */
! 159: struct nexthop *nhs = NULL;
! 160: int num = 0;
! 161:
! 162: for (rt = en->routes; rt && (num < p->ecmp); rt = rt->next)
! 163: {
! 164: if (!rip_valid_rte(rt))
! 165: continue;
! 166:
! 167: struct nexthop *nh = allocz(sizeof(struct nexthop));
! 168:
! 169: nh->gw = rt->next_hop;
! 170: nh->iface = rt->from->nbr->iface;
! 171: nh->weight = rt->from->ifa->cf->ecmp_weight;
! 172:
! 173: nexthop_insert(&nhs, nh);
! 174: num++;
! 175:
! 176: if (rt->tag != rt_tag)
! 177: rt_tag = 0;
! 178: }
! 179:
! 180: a0.nh = *nhs;
! 181: }
! 182: else
! 183: {
! 184: /* Unipath route */
! 185: a0.from = rt->from->nbr->addr;
! 186: a0.nh.gw = rt->next_hop;
! 187: a0.nh.iface = rt->from->nbr->iface;
! 188: }
! 189:
! 190: rta *a = rta_lookup(&a0);
! 191: rte *e = rte_get_temp(a);
! 192:
! 193: e->u.rip.from = a0.nh.iface;
! 194: e->u.rip.metric = rt_metric;
! 195: e->u.rip.tag = rt_tag;
! 196: e->pflags = EA_ID_FLAG(EA_RIP_METRIC) | EA_ID_FLAG(EA_RIP_TAG);
! 197:
! 198: rte_update(&p->p, en->n.addr, e);
! 199: }
! 200: else
! 201: {
! 202: /* Withdraw */
! 203: rte_update(&p->p, en->n.addr, NULL);
! 204: }
! 205: }
! 206:
! 207: /**
! 208: * rip_update_rte - enter a route update to RIP routing table
! 209: * @p: RIP instance
! 210: * @addr: network address
! 211: * @new: a &rip_rte representing the new route
! 212: *
! 213: * The function is called by the RIP packet processing code whenever it receives
! 214: * a reachable route. The appropriate routing table entry is found and the list
! 215: * of incoming routes is updated. Eventually, the change is also propagated to
! 216: * the core by rip_announce_rte(). Note that for unreachable routes,
! 217: * rip_withdraw_rte() should be called instead of rip_update_rte().
! 218: */
! 219: void
! 220: rip_update_rte(struct rip_proto *p, net_addr *n, struct rip_rte *new)
! 221: {
! 222: struct rip_entry *en = fib_get(&p->rtable, n);
! 223: struct rip_rte *rt, **rp;
! 224: int changed = 0;
! 225:
! 226: /* If the new route is better, remove all current routes */
! 227: if (en->routes && new->metric < en->routes->metric)
! 228: while (en->routes)
! 229: rip_remove_rte(p, &en->routes);
! 230:
! 231: /* Find the old route (also set rp for later) */
! 232: for (rp = &en->routes; rt = *rp; rp = &rt->next)
! 233: if (rt->from == new->from)
! 234: {
! 235: if (rip_same_rte(rt, new))
! 236: {
! 237: rt->expires = new->expires;
! 238: return;
! 239: }
! 240:
! 241: /* Remove the old route */
! 242: rip_remove_rte(p, rp);
! 243: changed = 1;
! 244: break;
! 245: }
! 246:
! 247: /* If the new route is optimal, add it to the list */
! 248: if (!en->routes || new->metric == en->routes->metric)
! 249: {
! 250: rt = rip_add_rte(p, rp, new);
! 251: changed = 1;
! 252: }
! 253:
! 254: /* Announce change if on relevant position (the first or any for ECMP) */
! 255: if (changed && (rp == &en->routes || p->ecmp))
! 256: rip_announce_rte(p, en);
! 257: }
! 258:
! 259: /**
! 260: * rip_withdraw_rte - enter a route withdraw to RIP routing table
! 261: * @p: RIP instance
! 262: * @addr: network address
! 263: * @from: a &rip_neighbor propagating the withdraw
! 264: *
! 265: * The function is called by the RIP packet processing code whenever it receives
! 266: * an unreachable route. The incoming route for given network from nbr @from is
! 267: * removed. Eventually, the change is also propagated by rip_announce_rte().
! 268: */
! 269: void
! 270: rip_withdraw_rte(struct rip_proto *p, net_addr *n, struct rip_neighbor *from)
! 271: {
! 272: struct rip_entry *en = fib_find(&p->rtable, n);
! 273: struct rip_rte *rt, **rp;
! 274:
! 275: if (!en)
! 276: return;
! 277:
! 278: /* Find the old route */
! 279: for (rp = &en->routes; rt = *rp; rp = &rt->next)
! 280: if (rt->from == from)
! 281: break;
! 282:
! 283: if (!rt)
! 284: return;
! 285:
! 286: /* Remove the old route */
! 287: rip_remove_rte(p, rp);
! 288:
! 289: /* Announce change if on relevant position */
! 290: if (rp == &en->routes || p->ecmp)
! 291: rip_announce_rte(p, en);
! 292: }
! 293:
! 294: /*
! 295: * rip_rt_notify - core tells us about new route, so store
! 296: * it into our data structures.
! 297: */
! 298: static void
! 299: rip_rt_notify(struct proto *P, struct channel *ch UNUSED, struct network *net, struct rte *new,
! 300: struct rte *old UNUSED)
! 301: {
! 302: struct rip_proto *p = (struct rip_proto *) P;
! 303: struct rip_entry *en;
! 304: int old_metric;
! 305:
! 306: if (new)
! 307: {
! 308: /* Update */
! 309: u32 rt_metric = ea_get_int(new->attrs->eattrs, EA_RIP_METRIC, 1);
! 310: u32 rt_tag = ea_get_int(new->attrs->eattrs, EA_RIP_TAG, 0);
! 311:
! 312: if (rt_metric > p->infinity)
! 313: {
! 314: log(L_WARN "%s: Invalid rip_metric value %u for route %N",
! 315: p->p.name, rt_metric, net->n.addr);
! 316: rt_metric = p->infinity;
! 317: }
! 318:
! 319: if (rt_tag > 0xffff)
! 320: {
! 321: log(L_WARN "%s: Invalid rip_tag value %u for route %N",
! 322: p->p.name, rt_tag, net->n.addr);
! 323: rt_metric = p->infinity;
! 324: rt_tag = 0;
! 325: }
! 326:
! 327: /*
! 328: * Note that we accept exported routes with infinity metric (this could
! 329: * happen if rip_metric is modified in filters). Such entry has infinity
! 330: * metric but is RIP_ENTRY_VALID and therefore is not subject to garbage
! 331: * collection.
! 332: */
! 333:
! 334: en = fib_get(&p->rtable, net->n.addr);
! 335:
! 336: old_metric = en->valid ? en->metric : -1;
! 337:
! 338: en->valid = RIP_ENTRY_VALID;
! 339: en->metric = rt_metric;
! 340: en->tag = rt_tag;
! 341: en->from = (new->attrs->src->proto == P) ? new->u.rip.from : NULL;
! 342: en->iface = new->attrs->nh.iface;
! 343: en->next_hop = new->attrs->nh.gw;
! 344: }
! 345: else
! 346: {
! 347: /* Withdraw */
! 348: en = fib_find(&p->rtable, net->n.addr);
! 349:
! 350: if (!en || en->valid != RIP_ENTRY_VALID)
! 351: return;
! 352:
! 353: old_metric = en->metric;
! 354:
! 355: en->valid = RIP_ENTRY_STALE;
! 356: en->metric = p->infinity;
! 357: en->tag = 0;
! 358: en->from = NULL;
! 359: en->iface = NULL;
! 360: en->next_hop = IPA_NONE;
! 361: }
! 362:
! 363: /* Activate triggered updates */
! 364: if (en->metric != old_metric)
! 365: {
! 366: en->changed = current_time();
! 367: rip_trigger_update(p);
! 368: }
! 369: }
! 370:
! 371:
! 372: /*
! 373: * RIP neighbors
! 374: */
! 375:
! 376: struct rip_neighbor *
! 377: rip_get_neighbor(struct rip_proto *p, ip_addr *a, struct rip_iface *ifa)
! 378: {
! 379: neighbor *nbr = neigh_find(&p->p, *a, ifa->iface, 0);
! 380:
! 381: if (!nbr || (nbr->scope == SCOPE_HOST) || !rip_iface_link_up(ifa))
! 382: return NULL;
! 383:
! 384: if (nbr->data)
! 385: return nbr->data;
! 386:
! 387: TRACE(D_EVENTS, "New neighbor %I on %s", *a, ifa->iface->name);
! 388:
! 389: struct rip_neighbor *n = mb_allocz(p->p.pool, sizeof(struct rip_neighbor));
! 390: n->ifa = ifa;
! 391: n->nbr = nbr;
! 392: nbr->data = n;
! 393: n->csn = nbr->aux;
! 394:
! 395: add_tail(&ifa->neigh_list, NODE n);
! 396:
! 397: return n;
! 398: }
! 399:
! 400: static void
! 401: rip_remove_neighbor(struct rip_proto *p, struct rip_neighbor *n)
! 402: {
! 403: neighbor *nbr = n->nbr;
! 404:
! 405: TRACE(D_EVENTS, "Removing neighbor %I on %s", nbr->addr, nbr->iface->name);
! 406:
! 407: rem_node(NODE n);
! 408: n->ifa = NULL;
! 409: n->nbr = NULL;
! 410: nbr->data = NULL;
! 411: nbr->aux = n->csn;
! 412:
! 413: rfree(n->bfd_req);
! 414: n->bfd_req = NULL;
! 415: n->last_seen = 0;
! 416:
! 417: if (!n->uc)
! 418: mb_free(n);
! 419:
! 420: /* Related routes are removed in rip_timer() */
! 421: rip_kick_timer(p);
! 422: }
! 423:
! 424: static inline void
! 425: rip_lock_neighbor(struct rip_neighbor *n)
! 426: {
! 427: n->uc++;
! 428: }
! 429:
! 430: static inline void
! 431: rip_unlock_neighbor(struct rip_neighbor *n)
! 432: {
! 433: n->uc--;
! 434:
! 435: if (!n->nbr && !n->uc)
! 436: mb_free(n);
! 437: }
! 438:
! 439: static void
! 440: rip_neigh_notify(struct neighbor *nbr)
! 441: {
! 442: struct rip_proto *p = (struct rip_proto *) nbr->proto;
! 443: struct rip_neighbor *n = nbr->data;
! 444:
! 445: if (!n)
! 446: return;
! 447:
! 448: /*
! 449: * We assume that rip_neigh_notify() is called before rip_if_notify() for
! 450: * IF_CHANGE_DOWN and therefore n->ifa is still valid. We have no such
! 451: * ordering assumption for IF_CHANGE_LINK, so we test link state of the
! 452: * underlying iface instead of just rip_iface state.
! 453: */
! 454: if ((nbr->scope <= 0) || !rip_iface_link_up(n->ifa))
! 455: rip_remove_neighbor(p, n);
! 456: }
! 457:
! 458: static void
! 459: rip_bfd_notify(struct bfd_request *req)
! 460: {
! 461: struct rip_neighbor *n = req->data;
! 462: struct rip_proto *p = n->ifa->rip;
! 463:
! 464: if (req->down)
! 465: {
! 466: TRACE(D_EVENTS, "BFD session down for nbr %I on %s",
! 467: n->nbr->addr, n->ifa->iface->name);
! 468: rip_remove_neighbor(p, n);
! 469: }
! 470: }
! 471:
! 472: void
! 473: rip_update_bfd(struct rip_proto *p, struct rip_neighbor *n)
! 474: {
! 475: int use_bfd = n->ifa->cf->bfd && n->last_seen;
! 476:
! 477: if (use_bfd && !n->bfd_req)
! 478: {
! 479: /*
! 480: * For RIPv2, use the same address as rip_open_socket(). For RIPng, neighbor
! 481: * should contain an address from the same prefix, thus also link-local. It
! 482: * may cause problems if two link-local addresses are assigned to one iface.
! 483: */
! 484: ip_addr saddr = rip_is_v2(p) ? n->ifa->sk->saddr : n->nbr->ifa->ip;
! 485: n->bfd_req = bfd_request_session(p->p.pool, n->nbr->addr, saddr,
! 486: n->nbr->iface, p->p.vrf,
! 487: rip_bfd_notify, n);
! 488: }
! 489:
! 490: if (!use_bfd && n->bfd_req)
! 491: {
! 492: rfree(n->bfd_req);
! 493: n->bfd_req = NULL;
! 494: }
! 495: }
! 496:
! 497:
! 498: /*
! 499: * RIP interfaces
! 500: */
! 501:
! 502: static void
! 503: rip_iface_start(struct rip_iface *ifa)
! 504: {
! 505: struct rip_proto *p = ifa->rip;
! 506:
! 507: TRACE(D_EVENTS, "Starting interface %s", ifa->iface->name);
! 508:
! 509: ifa->next_regular = current_time() + (random() % ifa->cf->update_time) + 100 MS;
! 510: ifa->next_triggered = current_time(); /* Available immediately */
! 511: ifa->want_triggered = 1; /* All routes in triggered update */
! 512: tm_start(ifa->timer, 100 MS);
! 513: ifa->up = 1;
! 514:
! 515: if (!ifa->cf->passive)
! 516: rip_send_request(ifa->rip, ifa);
! 517: }
! 518:
! 519: static void
! 520: rip_iface_stop(struct rip_iface *ifa)
! 521: {
! 522: struct rip_proto *p = ifa->rip;
! 523: struct rip_neighbor *n;
! 524:
! 525: TRACE(D_EVENTS, "Stopping interface %s", ifa->iface->name);
! 526:
! 527: rip_reset_tx_session(p, ifa);
! 528:
! 529: WALK_LIST_FIRST(n, ifa->neigh_list)
! 530: rip_remove_neighbor(p, n);
! 531:
! 532: tm_stop(ifa->timer);
! 533: ifa->up = 0;
! 534: }
! 535:
! 536: static inline int
! 537: rip_iface_link_up(struct rip_iface *ifa)
! 538: {
! 539: return !ifa->cf->check_link || (ifa->iface->flags & IF_LINK_UP);
! 540: }
! 541:
! 542: static void
! 543: rip_iface_update_state(struct rip_iface *ifa)
! 544: {
! 545: int up = ifa->sk && rip_iface_link_up(ifa);
! 546:
! 547: if (up == ifa->up)
! 548: return;
! 549:
! 550: if (up)
! 551: rip_iface_start(ifa);
! 552: else
! 553: rip_iface_stop(ifa);
! 554: }
! 555:
! 556: static void
! 557: rip_iface_update_buffers(struct rip_iface *ifa)
! 558: {
! 559: if (!ifa->sk)
! 560: return;
! 561:
! 562: uint rbsize = ifa->cf->rx_buffer ?: ifa->iface->mtu;
! 563: uint tbsize = ifa->cf->tx_length ?: ifa->iface->mtu;
! 564: rbsize = MAX(rbsize, tbsize);
! 565:
! 566: sk_set_rbsize(ifa->sk, rbsize);
! 567: sk_set_tbsize(ifa->sk, tbsize);
! 568:
! 569: uint headers = (rip_is_v2(ifa->rip) ? IP4_HEADER_LENGTH : IP6_HEADER_LENGTH) + UDP_HEADER_LENGTH;
! 570: ifa->tx_plen = tbsize - headers;
! 571:
! 572: if (ifa->cf->auth_type == RIP_AUTH_CRYPTO)
! 573: ifa->tx_plen -= RIP_AUTH_TAIL_LENGTH + max_mac_length(ifa->cf->passwords);
! 574: }
! 575:
! 576: static inline void
! 577: rip_iface_update_bfd(struct rip_iface *ifa)
! 578: {
! 579: struct rip_proto *p = ifa->rip;
! 580: struct rip_neighbor *n;
! 581:
! 582: WALK_LIST(n, ifa->neigh_list)
! 583: rip_update_bfd(p, n);
! 584: }
! 585:
! 586:
! 587: static void
! 588: rip_iface_locked(struct object_lock *lock)
! 589: {
! 590: struct rip_iface *ifa = lock->data;
! 591: struct rip_proto *p = ifa->rip;
! 592:
! 593: if (!rip_open_socket(ifa))
! 594: {
! 595: log(L_ERR "%s: Cannot open socket for %s", p->p.name, ifa->iface->name);
! 596: return;
! 597: }
! 598:
! 599: rip_iface_update_buffers(ifa);
! 600: rip_iface_update_state(ifa);
! 601: }
! 602:
! 603:
! 604: static struct rip_iface *
! 605: rip_find_iface(struct rip_proto *p, struct iface *what)
! 606: {
! 607: struct rip_iface *ifa;
! 608:
! 609: WALK_LIST(ifa, p->iface_list)
! 610: if (ifa->iface == what)
! 611: return ifa;
! 612:
! 613: return NULL;
! 614: }
! 615:
! 616: static void
! 617: rip_add_iface(struct rip_proto *p, struct iface *iface, struct rip_iface_config *ic)
! 618: {
! 619: struct rip_iface *ifa;
! 620:
! 621: TRACE(D_EVENTS, "Adding interface %s", iface->name);
! 622:
! 623: ifa = mb_allocz(p->p.pool, sizeof(struct rip_iface));
! 624: ifa->rip = p;
! 625: ifa->iface = iface;
! 626: ifa->cf = ic;
! 627:
! 628: if (ipa_nonzero(ic->address))
! 629: ifa->addr = ic->address;
! 630: else if (ic->mode == RIP_IM_MULTICAST)
! 631: ifa->addr = rip_is_v2(p) ? IP4_RIP_ROUTERS : IP6_RIP_ROUTERS;
! 632: else /* Broadcast */
! 633: ifa->addr = iface->addr4->brd;
! 634: /*
! 635: * The above is just a workaround for BSD as it can't send broadcasts
! 636: * to 255.255.255.255. BSD systems need the network broadcast address instead.
! 637: *
! 638: * TODO: move this to sysdep code
! 639: */
! 640:
! 641: init_list(&ifa->neigh_list);
! 642:
! 643: add_tail(&p->iface_list, NODE ifa);
! 644:
! 645: ifa->timer = tm_new_init(p->p.pool, rip_iface_timer, ifa, 0, 0);
! 646:
! 647: struct object_lock *lock = olock_new(p->p.pool);
! 648: lock->type = OBJLOCK_UDP;
! 649: lock->port = ic->port;
! 650: lock->iface = iface;
! 651: lock->data = ifa;
! 652: lock->hook = rip_iface_locked;
! 653: ifa->lock = lock;
! 654:
! 655: olock_acquire(lock);
! 656: }
! 657:
! 658: static void
! 659: rip_remove_iface(struct rip_proto *p, struct rip_iface *ifa)
! 660: {
! 661: rip_iface_stop(ifa);
! 662:
! 663: TRACE(D_EVENTS, "Removing interface %s", ifa->iface->name);
! 664:
! 665: rem_node(NODE ifa);
! 666:
! 667: rfree(ifa->sk);
! 668: rfree(ifa->lock);
! 669: rfree(ifa->timer);
! 670:
! 671: mb_free(ifa);
! 672: }
! 673:
! 674: static int
! 675: rip_reconfigure_iface(struct rip_proto *p, struct rip_iface *ifa, struct rip_iface_config *new)
! 676: {
! 677: struct rip_iface_config *old = ifa->cf;
! 678:
! 679: /* Change of these options would require to reset the iface socket */
! 680: if ((new->mode != old->mode) ||
! 681: (new->port != old->port) ||
! 682: (new->tx_tos != old->tx_tos) ||
! 683: (new->tx_priority != old->tx_priority) ||
! 684: (new->ttl_security != old->ttl_security))
! 685: return 0;
! 686:
! 687: TRACE(D_EVENTS, "Reconfiguring interface %s", ifa->iface->name);
! 688:
! 689: ifa->cf = new;
! 690:
! 691: rip_iface_update_buffers(ifa);
! 692:
! 693: if (ifa->next_regular > (current_time() + new->update_time))
! 694: ifa->next_regular = current_time() + (random() % new->update_time) + 100 MS;
! 695:
! 696: if (new->check_link != old->check_link)
! 697: rip_iface_update_state(ifa);
! 698:
! 699: if (new->bfd != old->bfd)
! 700: rip_iface_update_bfd(ifa);
! 701:
! 702: if (ifa->up)
! 703: rip_iface_kick_timer(ifa);
! 704:
! 705: return 1;
! 706: }
! 707:
! 708: static void
! 709: rip_reconfigure_ifaces(struct rip_proto *p, struct rip_config *cf)
! 710: {
! 711: struct iface *iface;
! 712:
! 713: WALK_LIST(iface, iface_list)
! 714: {
! 715: if (!(iface->flags & IF_UP))
! 716: continue;
! 717:
! 718: /* Ignore ifaces without appropriate address */
! 719: if (rip_is_v2(p) ? !iface->addr4 : !iface->llv6)
! 720: continue;
! 721:
! 722: struct rip_iface *ifa = rip_find_iface(p, iface);
! 723: struct rip_iface_config *ic = (void *) iface_patt_find(&cf->patt_list, iface, NULL);
! 724:
! 725: if (ifa && ic)
! 726: {
! 727: if (rip_reconfigure_iface(p, ifa, ic))
! 728: continue;
! 729:
! 730: /* Hard restart */
! 731: log(L_INFO "%s: Restarting interface %s", p->p.name, ifa->iface->name);
! 732: rip_remove_iface(p, ifa);
! 733: rip_add_iface(p, iface, ic);
! 734: }
! 735:
! 736: if (ifa && !ic)
! 737: rip_remove_iface(p, ifa);
! 738:
! 739: if (!ifa && ic)
! 740: rip_add_iface(p, iface, ic);
! 741: }
! 742: }
! 743:
! 744: static void
! 745: rip_if_notify(struct proto *P, unsigned flags, struct iface *iface)
! 746: {
! 747: struct rip_proto *p = (void *) P;
! 748: struct rip_config *cf = (void *) P->cf;
! 749: struct rip_iface *ifa = rip_find_iface(p, iface);
! 750:
! 751: if (iface->flags & IF_IGNORE)
! 752: return;
! 753:
! 754: /* Add, remove or restart interface */
! 755: if (flags & (IF_CHANGE_UPDOWN | (rip_is_v2(p) ? IF_CHANGE_ADDR4 : IF_CHANGE_LLV6)))
! 756: {
! 757: if (ifa)
! 758: rip_remove_iface(p, ifa);
! 759:
! 760: if (!(iface->flags & IF_UP))
! 761: return;
! 762:
! 763: /* Ignore ifaces without appropriate address */
! 764: if (rip_is_v2(p) ? !iface->addr4 : !iface->llv6)
! 765: return;
! 766:
! 767: struct rip_iface_config *ic = (void *) iface_patt_find(&cf->patt_list, iface, NULL);
! 768: if (ic)
! 769: rip_add_iface(p, iface, ic);
! 770:
! 771: return;
! 772: }
! 773:
! 774: if (!ifa)
! 775: return;
! 776:
! 777: if (flags & IF_CHANGE_MTU)
! 778: rip_iface_update_buffers(ifa);
! 779:
! 780: if (flags & IF_CHANGE_LINK)
! 781: rip_iface_update_state(ifa);
! 782: }
! 783:
! 784:
! 785: /*
! 786: * RIP timer events
! 787: */
! 788:
! 789: /**
! 790: * rip_timer - RIP main timer hook
! 791: * @t: timer
! 792: *
! 793: * The RIP main timer is responsible for routing table maintenance. Invalid or
! 794: * expired routes (&rip_rte) are removed and garbage collection of stale routing
! 795: * table entries (&rip_entry) is done. Changes are propagated to core tables,
! 796: * route reload is also done here. Note that garbage collection uses a maximal
! 797: * GC time, while interfaces maintain an illusion of per-interface GC times in
! 798: * rip_send_response().
! 799: *
! 800: * Keeping incoming routes and the selected outgoing route are two independent
! 801: * functions, therefore after garbage collection some entries now considered
! 802: * invalid (RIP_ENTRY_DUMMY) still may have non-empty list of incoming routes,
! 803: * while some valid entries (representing an outgoing route) may have that list
! 804: * empty.
! 805: *
! 806: * The main timer is not scheduled periodically but it uses the time of the
! 807: * current next event and the minimal interval of any possible event to compute
! 808: * the time of the next run.
! 809: */
! 810: static void
! 811: rip_timer(timer *t)
! 812: {
! 813: struct rip_proto *p = t->data;
! 814: struct rip_config *cf = (void *) (p->p.cf);
! 815: struct rip_iface *ifa;
! 816: struct rip_neighbor *n, *nn;
! 817: struct fib_iterator fit;
! 818: btime now_ = current_time();
! 819: btime next = now_ + MIN(cf->min_timeout_time, cf->max_garbage_time);
! 820: btime expires = 0;
! 821:
! 822: TRACE(D_EVENTS, "Main timer fired");
! 823:
! 824: FIB_ITERATE_INIT(&fit, &p->rtable);
! 825:
! 826: loop:
! 827: FIB_ITERATE_START(&p->rtable, &fit, struct rip_entry, en)
! 828: {
! 829: struct rip_rte *rt, **rp;
! 830: int changed = 0;
! 831:
! 832: /* Checking received routes for timeout and for dead neighbors */
! 833: for (rp = &en->routes; rt = *rp; /* rp = &rt->next */)
! 834: {
! 835: if (!rip_valid_rte(rt) || (rt->expires <= now_))
! 836: {
! 837: rip_remove_rte(p, rp);
! 838: changed = 1;
! 839: continue;
! 840: }
! 841:
! 842: next = MIN(next, rt->expires);
! 843: rp = &rt->next;
! 844: }
! 845:
! 846: /* Propagating eventual change */
! 847: if (changed || p->rt_reload)
! 848: {
! 849: /*
! 850: * We have to restart the iteration because there may be a cascade of
! 851: * synchronous events rip_announce_rte() -> nest table change ->
! 852: * rip_rt_notify() -> p->rtable change, invalidating hidden variables.
! 853: */
! 854:
! 855: FIB_ITERATE_PUT_NEXT(&fit, &p->rtable);
! 856: rip_announce_rte(p, en);
! 857: goto loop;
! 858: }
! 859:
! 860: /* Checking stale entries for garbage collection timeout */
! 861: if (en->valid == RIP_ENTRY_STALE)
! 862: {
! 863: expires = en->changed + cf->max_garbage_time;
! 864:
! 865: if (expires <= now_)
! 866: {
! 867: // TRACE(D_EVENTS, "entry is too old: %N", en->n.addr);
! 868: en->valid = 0;
! 869: }
! 870: else
! 871: next = MIN(next, expires);
! 872: }
! 873:
! 874: /* Remove empty nodes */
! 875: if (!en->valid && !en->routes)
! 876: {
! 877: FIB_ITERATE_PUT(&fit);
! 878: fib_delete(&p->rtable, en);
! 879: goto loop;
! 880: }
! 881: }
! 882: FIB_ITERATE_END;
! 883:
! 884: p->rt_reload = 0;
! 885:
! 886: /* Handling neighbor expiration */
! 887: WALK_LIST(ifa, p->iface_list)
! 888: WALK_LIST_DELSAFE(n, nn, ifa->neigh_list)
! 889: if (n->last_seen)
! 890: {
! 891: expires = n->last_seen + n->ifa->cf->timeout_time;
! 892:
! 893: if (expires <= now_)
! 894: rip_remove_neighbor(p, n);
! 895: else
! 896: next = MIN(next, expires);
! 897: }
! 898:
! 899: tm_start(p->timer, MAX(next - now_, 100 MS));
! 900: }
! 901:
! 902: static inline void
! 903: rip_kick_timer(struct rip_proto *p)
! 904: {
! 905: if (p->timer->expires > (current_time() + 100 MS))
! 906: tm_start(p->timer, 100 MS);
! 907: }
! 908:
! 909: /**
! 910: * rip_iface_timer - RIP interface timer hook
! 911: * @t: timer
! 912: *
! 913: * RIP interface timers are responsible for scheduling both regular and
! 914: * triggered updates. Fixed, delay-independent period is used for regular
! 915: * updates, while minimal separating interval is enforced for triggered updates.
! 916: * The function also ensures that a new update is not started when the old one
! 917: * is still running.
! 918: */
! 919: static void
! 920: rip_iface_timer(timer *t)
! 921: {
! 922: struct rip_iface *ifa = t->data;
! 923: struct rip_proto *p = ifa->rip;
! 924: btime now_ = current_time();
! 925: btime period = ifa->cf->update_time;
! 926:
! 927: if (ifa->cf->passive)
! 928: return;
! 929:
! 930: TRACE(D_EVENTS, "Interface timer fired for %s", ifa->iface->name);
! 931:
! 932: if (ifa->tx_active)
! 933: {
! 934: if (now_ < (ifa->next_regular + period))
! 935: { tm_start(ifa->timer, 100 MS); return; }
! 936:
! 937: /* We are too late, reset is done by rip_send_table() */
! 938: log(L_WARN "%s: Too slow update on %s, resetting", p->p.name, ifa->iface->name);
! 939: }
! 940:
! 941: if (now_ >= ifa->next_regular)
! 942: {
! 943: /* Send regular update, set timer for next period (or following one if necessay) */
! 944: TRACE(D_EVENTS, "Sending regular updates for %s", ifa->iface->name);
! 945: rip_send_table(p, ifa, ifa->addr, 0);
! 946: ifa->next_regular += period * (1 + ((now_ - ifa->next_regular) / period));
! 947: ifa->want_triggered = 0;
! 948: p->triggered = 0;
! 949: }
! 950: else if (ifa->want_triggered && (now_ >= ifa->next_triggered))
! 951: {
! 952: /* Send triggered update, enforce interval between triggered updates */
! 953: TRACE(D_EVENTS, "Sending triggered updates for %s", ifa->iface->name);
! 954: rip_send_table(p, ifa, ifa->addr, ifa->want_triggered);
! 955: ifa->next_triggered = now_ + MIN(5 S, period / 2);
! 956: ifa->want_triggered = 0;
! 957: p->triggered = 0;
! 958: }
! 959:
! 960: tm_start(ifa->timer, ifa->want_triggered ? (1 S) : (ifa->next_regular - now_));
! 961: }
! 962:
! 963: static inline void
! 964: rip_iface_kick_timer(struct rip_iface *ifa)
! 965: {
! 966: if (ifa->timer->expires > (current_time() + 100 MS))
! 967: tm_start(ifa->timer, 100 MS);
! 968: }
! 969:
! 970: static void
! 971: rip_trigger_update(struct rip_proto *p)
! 972: {
! 973: if (p->triggered)
! 974: return;
! 975:
! 976: struct rip_iface *ifa;
! 977: WALK_LIST(ifa, p->iface_list)
! 978: {
! 979: /* Interface not active */
! 980: if (! ifa->up)
! 981: continue;
! 982:
! 983: /* Already scheduled */
! 984: if (ifa->want_triggered)
! 985: continue;
! 986:
! 987: TRACE(D_EVENTS, "Scheduling triggered updates for %s", ifa->iface->name);
! 988: ifa->want_triggered = current_time();
! 989: rip_iface_kick_timer(ifa);
! 990: }
! 991:
! 992: p->triggered = 1;
! 993: }
! 994:
! 995:
! 996: /*
! 997: * RIP protocol glue
! 998: */
! 999:
! 1000: static void
! 1001: rip_reload_routes(struct channel *C)
! 1002: {
! 1003: struct rip_proto *p = (struct rip_proto *) C->proto;
! 1004:
! 1005: if (p->rt_reload)
! 1006: return;
! 1007:
! 1008: TRACE(D_EVENTS, "Scheduling route reload");
! 1009: p->rt_reload = 1;
! 1010: rip_kick_timer(p);
! 1011: }
! 1012:
! 1013: static void
! 1014: rip_make_tmp_attrs(struct rte *rt, struct linpool *pool)
! 1015: {
! 1016: rte_init_tmp_attrs(rt, pool, 2);
! 1017: rte_make_tmp_attr(rt, EA_RIP_METRIC, EAF_TYPE_INT, rt->u.rip.metric);
! 1018: rte_make_tmp_attr(rt, EA_RIP_TAG, EAF_TYPE_INT, rt->u.rip.tag);
! 1019: }
! 1020:
! 1021: static void
! 1022: rip_store_tmp_attrs(struct rte *rt, struct linpool *pool)
! 1023: {
! 1024: rte_init_tmp_attrs(rt, pool, 2);
! 1025: rt->u.rip.metric = rte_store_tmp_attr(rt, EA_RIP_METRIC);
! 1026: rt->u.rip.tag = rte_store_tmp_attr(rt, EA_RIP_TAG);
! 1027: }
! 1028:
! 1029: static int
! 1030: rip_rte_better(struct rte *new, struct rte *old)
! 1031: {
! 1032: return new->u.rip.metric < old->u.rip.metric;
! 1033: }
! 1034:
! 1035: static int
! 1036: rip_rte_same(struct rte *new, struct rte *old)
! 1037: {
! 1038: return ((new->u.rip.metric == old->u.rip.metric) &&
! 1039: (new->u.rip.tag == old->u.rip.tag) &&
! 1040: (new->u.rip.from == old->u.rip.from));
! 1041: }
! 1042:
! 1043:
! 1044: static void
! 1045: rip_postconfig(struct proto_config *CF)
! 1046: {
! 1047: // struct rip_config *cf = (void *) CF;
! 1048:
! 1049: /* Define default channel */
! 1050: if (EMPTY_LIST(CF->channels))
! 1051: channel_config_new(NULL, net_label[CF->net_type], CF->net_type, CF);
! 1052: }
! 1053:
! 1054: static struct proto *
! 1055: rip_init(struct proto_config *CF)
! 1056: {
! 1057: struct proto *P = proto_new(CF);
! 1058:
! 1059: P->main_channel = proto_add_channel(P, proto_cf_main_channel(CF));
! 1060:
! 1061: P->if_notify = rip_if_notify;
! 1062: P->rt_notify = rip_rt_notify;
! 1063: P->neigh_notify = rip_neigh_notify;
! 1064: P->reload_routes = rip_reload_routes;
! 1065: P->make_tmp_attrs = rip_make_tmp_attrs;
! 1066: P->store_tmp_attrs = rip_store_tmp_attrs;
! 1067: P->rte_better = rip_rte_better;
! 1068: P->rte_same = rip_rte_same;
! 1069:
! 1070: return P;
! 1071: }
! 1072:
! 1073: static int
! 1074: rip_start(struct proto *P)
! 1075: {
! 1076: struct rip_proto *p = (void *) P;
! 1077: struct rip_config *cf = (void *) (P->cf);
! 1078:
! 1079: init_list(&p->iface_list);
! 1080: fib_init(&p->rtable, P->pool, cf->rip2 ? NET_IP4 : NET_IP6,
! 1081: sizeof(struct rip_entry), OFFSETOF(struct rip_entry, n), 0, NULL);
! 1082: p->rte_slab = sl_new(P->pool, sizeof(struct rip_rte));
! 1083: p->timer = tm_new_init(P->pool, rip_timer, p, 0, 0);
! 1084:
! 1085: p->rip2 = cf->rip2;
! 1086: p->ecmp = cf->ecmp;
! 1087: p->infinity = cf->infinity;
! 1088: p->triggered = 0;
! 1089:
! 1090: p->log_pkt_tbf = (struct tbf){ .rate = 1, .burst = 5 };
! 1091: p->log_rte_tbf = (struct tbf){ .rate = 4, .burst = 20 };
! 1092:
! 1093: tm_start(p->timer, MIN(cf->min_timeout_time, cf->max_garbage_time));
! 1094:
! 1095: return PS_UP;
! 1096: }
! 1097:
! 1098: static int
! 1099: rip_reconfigure(struct proto *P, struct proto_config *CF)
! 1100: {
! 1101: struct rip_proto *p = (void *) P;
! 1102: struct rip_config *new = (void *) CF;
! 1103: // struct rip_config *old = (void *) (P->cf);
! 1104:
! 1105: if (new->rip2 != p->rip2)
! 1106: return 0;
! 1107:
! 1108: if (new->infinity != p->infinity)
! 1109: return 0;
! 1110:
! 1111: if (!proto_configure_channel(P, &P->main_channel, proto_cf_main_channel(CF)))
! 1112: return 0;
! 1113:
! 1114: TRACE(D_EVENTS, "Reconfiguring");
! 1115:
! 1116: p->p.cf = CF;
! 1117: p->ecmp = new->ecmp;
! 1118: rip_reconfigure_ifaces(p, new);
! 1119:
! 1120: p->rt_reload = 1;
! 1121: rip_kick_timer(p);
! 1122:
! 1123: return 1;
! 1124: }
! 1125:
! 1126: static void
! 1127: rip_get_route_info(rte *rte, byte *buf)
! 1128: {
! 1129: buf += bsprintf(buf, " (%d/%d)", rte->pref, rte->u.rip.metric);
! 1130:
! 1131: if (rte->u.rip.tag)
! 1132: bsprintf(buf, " [%04x]", rte->u.rip.tag);
! 1133: }
! 1134:
! 1135: static int
! 1136: rip_get_attr(eattr *a, byte *buf, int buflen UNUSED)
! 1137: {
! 1138: switch (a->id)
! 1139: {
! 1140: case EA_RIP_METRIC:
! 1141: bsprintf(buf, "metric: %d", a->u.data);
! 1142: return GA_FULL;
! 1143:
! 1144: case EA_RIP_TAG:
! 1145: bsprintf(buf, "tag: %04x", a->u.data);
! 1146: return GA_FULL;
! 1147:
! 1148: default:
! 1149: return GA_UNKNOWN;
! 1150: }
! 1151: }
! 1152:
! 1153: void
! 1154: rip_show_interfaces(struct proto *P, char *iff)
! 1155: {
! 1156: struct rip_proto *p = (void *) P;
! 1157: struct rip_iface *ifa = NULL;
! 1158: struct rip_neighbor *n = NULL;
! 1159:
! 1160: if (p->p.proto_state != PS_UP)
! 1161: {
! 1162: cli_msg(-1021, "%s: is not up", p->p.name);
! 1163: cli_msg(0, "");
! 1164: return;
! 1165: }
! 1166:
! 1167: cli_msg(-1021, "%s:", p->p.name);
! 1168: cli_msg(-1021, "%-10s %-6s %6s %6s %7s",
! 1169: "Interface", "State", "Metric", "Nbrs", "Timer");
! 1170:
! 1171: WALK_LIST(ifa, p->iface_list)
! 1172: {
! 1173: if (iff && !patmatch(iff, ifa->iface->name))
! 1174: continue;
! 1175:
! 1176: int nbrs = 0;
! 1177: WALK_LIST(n, ifa->neigh_list)
! 1178: if (n->last_seen)
! 1179: nbrs++;
! 1180:
! 1181: btime now_ = current_time();
! 1182: btime timer = (ifa->next_regular > now_) ? (ifa->next_regular - now_) : 0;
! 1183: cli_msg(-1021, "%-10s %-6s %6u %6u %7t",
! 1184: ifa->iface->name, (ifa->up ? "Up" : "Down"), ifa->cf->metric, nbrs, timer);
! 1185: }
! 1186:
! 1187: cli_msg(0, "");
! 1188: }
! 1189:
! 1190: void
! 1191: rip_show_neighbors(struct proto *P, char *iff)
! 1192: {
! 1193: struct rip_proto *p = (void *) P;
! 1194: struct rip_iface *ifa = NULL;
! 1195: struct rip_neighbor *n = NULL;
! 1196:
! 1197: if (p->p.proto_state != PS_UP)
! 1198: {
! 1199: cli_msg(-1022, "%s: is not up", p->p.name);
! 1200: cli_msg(0, "");
! 1201: return;
! 1202: }
! 1203:
! 1204: cli_msg(-1022, "%s:", p->p.name);
! 1205: cli_msg(-1022, "%-25s %-10s %6s %6s %7s",
! 1206: "IP address", "Interface", "Metric", "Routes", "Seen");
! 1207:
! 1208: WALK_LIST(ifa, p->iface_list)
! 1209: {
! 1210: if (iff && !patmatch(iff, ifa->iface->name))
! 1211: continue;
! 1212:
! 1213: WALK_LIST(n, ifa->neigh_list)
! 1214: {
! 1215: if (!n->last_seen)
! 1216: continue;
! 1217:
! 1218: btime timer = current_time() - n->last_seen;
! 1219: cli_msg(-1022, "%-25I %-10s %6u %6u %7t",
! 1220: n->nbr->addr, ifa->iface->name, ifa->cf->metric, n->uc, timer);
! 1221: }
! 1222: }
! 1223:
! 1224: cli_msg(0, "");
! 1225: }
! 1226:
! 1227: static void
! 1228: rip_dump(struct proto *P)
! 1229: {
! 1230: struct rip_proto *p = (struct rip_proto *) P;
! 1231: struct rip_iface *ifa;
! 1232: int i;
! 1233:
! 1234: i = 0;
! 1235: FIB_WALK(&p->rtable, struct rip_entry, en)
! 1236: {
! 1237: debug("RIP: entry #%d: %N via %I dev %s valid %d metric %d age %t\n",
! 1238: i++, en->n.addr, en->next_hop, en->iface->name,
! 1239: en->valid, en->metric, current_time() - en->changed);
! 1240: }
! 1241: FIB_WALK_END;
! 1242:
! 1243: i = 0;
! 1244: WALK_LIST(ifa, p->iface_list)
! 1245: {
! 1246: debug("RIP: interface #%d: %s, %I, up = %d, busy = %d\n",
! 1247: i++, ifa->iface->name, ifa->sk ? ifa->sk->daddr : IPA_NONE,
! 1248: ifa->up, ifa->tx_active);
! 1249: }
! 1250: }
! 1251:
! 1252:
! 1253: struct protocol proto_rip = {
! 1254: .name = "RIP",
! 1255: .template = "rip%d",
! 1256: .class = PROTOCOL_RIP,
! 1257: .preference = DEF_PREF_RIP,
! 1258: .channel_mask = NB_IP,
! 1259: .proto_size = sizeof(struct rip_proto),
! 1260: .config_size = sizeof(struct rip_config),
! 1261: .postconfig = rip_postconfig,
! 1262: .init = rip_init,
! 1263: .dump = rip_dump,
! 1264: .start = rip_start,
! 1265: .reconfigure = rip_reconfigure,
! 1266: .get_route_info = rip_get_route_info,
! 1267: .get_attr = rip_get_attr
! 1268: };
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to rip.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird2 / proto / rip