Internet on FIRE

{

  struct babel_entry *e = E;

  init_list(&e->sources);

  init_list(&e->routes);

}

  s = sl_alloc(p->source_slab);

  s->router_id = router_id;

  s->seqno = 0;

  s->metric = BABEL_INFINITY;

  add_tail(&e->sources, NODE s);

{

  struct babel_proto *p = e->proto;

  struct babel_source *n, *nx;

  WALK_LIST_DELSAFE(n, nx, e->sources)

  {

    {

      rem_node(NODE n);

      sl_free(p->source_slab, n);

  if (nbr)

  {

    r->neigh = nbr;

    add_tail(&nbr->routes, NODE &r->neigh_route);

  }

  if (r->metric < BABEL_INFINITY)

  {

    r->metric = BABEL_INFINITY;

  }

  else

  {

{

  struct babel_route *r, *rx;

  struct fib_iterator fit;

  FIB_ITERATE_INIT(&fit, rtable);

    WALK_LIST_DELSAFE(r, rx, e->routes)

    {

	babel_refresh_route(r);

      {

	babel_expire_route(r);

	changed = 1;

{

  struct babel_iface *ifa;

  struct babel_neighbor *nbr, *nbx;

  WALK_LIST(ifa, p->interfaces)

  {

    WALK_LIST_DELSAFE(nbr, nbx, ifa->neigh_list)

    {

        babel_expire_ihu(nbr);

        babel_expire_hello(nbr);

    }

  }

	  e->n.addr, cur->router_id, cur->metric);

    e->selected_in = cur;

    babel_announce_rte(p, e);

  }

  else if (!cur || cur->metric == BABEL_INFINITY)

	    e->n.addr);

      e->selected_in->metric = BABEL_INFINITY;

      babel_send_seqno_request(e);

      babel_announce_rte(p, e);

      TRACE(D_EVENTS, "Flushing route for prefix %N", e->n.addr);

      e->selected_in = NULL;

      babel_announce_rte(p, e);

    }

  }

  msg->ihu.rxcost = babel_compute_rxcost(n);

  msg->ihu.interval = ifa->cf->ihu_interval;

}

static void

  msg.hello.seqno = ifa->hello_seqno++;

  msg.hello.interval = ifa->cf->hello_interval;

  babel_enqueue(&msg, ifa);

 * transmitted entry is updated.

 */

static void

{

  struct babel_proto *p = ifa->proto;

    if ((r->router_id == p->router_id) && (r->seqno < p->update_seqno))

    {

      r->seqno = p->update_seqno;

    }

    /* Skip routes that weren't updated since 'changed' time */

    if (!OUR_ROUTE(r))

    {

      struct babel_source *s = babel_get_source(e, r->router_id);

      if ((msg.update.seqno > s->seqno) ||

	  ((msg.update.seqno == s->seqno) && (msg.update.metric < s->metric)))

}

static void

{

  struct babel_proto *p = ifa->proto;

  TRACE(D_EVENTS, "Scheduling triggered updates for %s seqno %d",

	ifa->iface->name, p->update_seqno);

  babel_iface_kick_timer(ifa);

}

/* Update hello history according to Appendix A1 of the RFC */

static void

{

  /*

   * Compute the difference between expected and received seqno (modulo 2^16).

  n->hello_map = (n->hello_map << 1) | 1;

  n->next_hello_seqno = seqno+1;

  if (n->hello_cnt < 16) n->hello_cnt++;

}

static void

babel_expire_seqno_requests(struct babel_proto *p)

{

  struct babel_seqno_request *n, *nx;

  WALK_LIST_DELSAFE(n, nx, p->seqno_cache)

  {

    {

      rem_node(NODE n);

      sl_free(p->seqno_slab, n);

  net_copy(&r->net, n);

  r->router_id = router_id;

  r->seqno = seqno;

  add_tail(&p->seqno_cache, NODE r);

  return 1;

  struct babel_proto *p = ifa->proto;

  struct babel_msg_ack_req *msg = &m->ack_req;

  babel_send_ack(ifa, msg->sender, msg->nonce);

}

  struct babel_proto *p = ifa->proto;

  struct babel_msg_hello *msg = &m->hello;

  struct babel_neighbor *n = babel_get_neighbor(ifa, msg->sender);

  babel_update_hello_history(n, msg->seqno, msg->interval);

  if ((msg->ae != BABEL_AE_WILDCARD) && !ipa_equal(msg->addr, ifa->addr))

    return;

  struct babel_neighbor *n = babel_get_neighbor(ifa, msg->sender);

  n->txcost = msg->rxcost;

}

/**

    r->seqno = msg->seqno;

    r->expiry_interval = BABEL_ROUTE_EXPIRY_FACTOR(msg->interval);

    if (r->expiry_interval > BABEL_ROUTE_REFRESH_INTERVAL)

    /* If the route is not feasible at this point, it means it is from another

       neighbour than the one currently selected; so send a unicast seqno

  else

  {

    babel_trigger_iface_update(ifa);

  }

}

  if ((r->router_id != msg->router_id) || ge_mod64k(r->seqno, msg->seqno))

  {

    babel_trigger_iface_update(ifa);

    return;

  }

{

  struct babel_iface *ifa = t->data;

  struct babel_proto *p = ifa->proto;

  {

    babel_send_hello(ifa, (ifa->cf->type == BABEL_IFACE_TYPE_WIRELESS ||

                           ifa->hello_seqno % BABEL_IHU_INTERVAL_FACTOR == 0));

  }

  {

    TRACE(D_EVENTS, "Sending regular updates on %s", ifa->ifname);

    babel_send_update(ifa, 0);

    ifa->want_triggered = 0;

    p->triggered = 0;

  }

  {

    TRACE(D_EVENTS, "Sending triggered updates on %s", ifa->ifname);

    babel_send_update(ifa, ifa->want_triggered);

    ifa->want_triggered = 0;

    p->triggered = 0;

  }

}

static inline void

babel_iface_kick_timer(struct babel_iface *ifa)

{

}

static void

  TRACE(D_EVENTS, "Starting interface %s", ifa->ifname);

  ifa->want_triggered = 0;	/* We send an immediate update (below) */

  ifa->up = 1;

  babel_send_hello(ifa, 0);

  struct babel_neighbor *nbr;

  struct babel_route *r;

  node *n;

  TRACE(D_EVENTS, "Stopping interface %s", ifa->ifname);

    {

      r = SKIP_BACK(struct babel_route, neigh_route, n);

      r->metric = BABEL_INFINITY;

      babel_select_route(r->e);

    }

  }

  ifa->up = 0;

}

  init_list(&ifa->neigh_list);

  ifa->hello_seqno = 1;

  init_list(&ifa->msg_queue);

  ifa->send_event = ev_new(ifa->pool);

  if (ipa_zero(ifa->next_hop_ip4) && p->ip4_channel)

    log(L_WARN "%s: Cannot find IPv4 next hop addr on %s", p->p.name, ifa->ifname);

  if ((new->tx_length != old->tx_length) || (new->rx_buffer != old->rx_buffer))

    babel_iface_update_buffers(ifa);

static void

babel_dump_source(struct babel_source *s)

{

}

static void

babel_dump_route(struct babel_route *r)

{

	r->neigh ? r->neigh->addr : IPA_NONE,

        r->neigh ? r->neigh->ifa->ifname : "(none)",

}

static void

static void

babel_dump_neighbor(struct babel_neighbor *n)

{

	n->addr, n->txcost, n->hello_map, n->next_hello_seqno,

}

static void

{

  struct babel_neighbor *n;

	ifa->ifname, ifa->addr, ifa->cf->rxcost, ifa->cf->type, ifa->hello_seqno,

	ifa->cf->hello_interval, ifa->cf->update_interval);

  debug(" next hop v4 %I next hop v6 %I\n", ifa->next_hop_ip4, ifa->next_hop_ip6);

  }

  cli_msg(-1023, "%s:", p->p.name);

	  "Interface", "State", "RX cost", "Nbrs", "Timer",

	  "Next hop (v4)", "Next hop (v6)");

    WALK_LIST(nbr, ifa->neigh_list)

	nbrs++;

	    ifa->iface->name, (ifa->up ? "Up" : "Down"),

	    ifa->cf->rxcost, nbrs, MAX(timer, 0),

	    ifa->next_hop_ip4, ifa->next_hop_ip6);

  }

  cli_msg(-1024, "%s:", p->p.name);

  WALK_LIST(ifa, p->interfaces)

  {

      WALK_LIST(r, n->routes)

        rts++;

    }

  }

      else

        bsprintf(ridbuf, "%lR", r->router_id);

	      e->n.addr, ridbuf, r->metric, r->seqno, MAX(time, 0), srcs);

    }

    else

static inline void

babel_kick_timer(struct babel_proto *p)

{

}

    if (r != e->selected_out)

    {

      babel_trigger_update(p);

    }

  }

  else

       * expiry time. This causes a retraction to be sent, and later the route

       * to be flushed once the hold time has passed.

       */

      babel_trigger_update(p);

    }

    else

    {

	   OFFSETOF(struct babel_entry, n), 0, babel_init_entry);

  init_list(&p->interfaces);

  p->update_seqno = 1;

  p->router_id = proto_get_router_id(&cf->c);

#define BABEL_INFINITY		0xFFFF

#define BABEL_UPDATE_INTERVAL_FACTOR	4

#define BABEL_IHU_INTERVAL_FACTOR	3

#define BABEL_RXCOST_WIRED		96

#define BABEL_RXCOST_WIRELESS		256

#define BABEL_INITIAL_HOP_COUNT		255

/* Max interval that will not overflow when carried as 16-bit centiseconds */

#define BABEL_OVERHEAD		(IP6_HEADER_LENGTH+UDP_HEADER_LENGTH)

#define BABEL_MIN_MTU		(512 + BABEL_OVERHEAD)

  u8 type;

  u8 check_link;

  uint port;

  u16 rx_buffer;			/* RX buffer size, 0 for MTU */

  u16 tx_length;			/* TX packet length limit (including headers), 0 for MTU */

  u16 hello_seqno;			/* To be increased on each hello */

  timer *timer;

  event *send_event;

  u16 hello_map;

  u16 next_hello_seqno;

  /* expiry timers */

  list routes;				/* Routes this neighbour has sent us (struct babel_route) */

};

  u64 router_id;

  u16 seqno;

  u16 metric;

};

struct babel_route {

  u16 metric;

  u64 router_id;

  ip_addr next_hop;

};

struct babel_entry {

  struct babel_route *selected_in;

  struct babel_route *selected_out;

  list sources;				/* Source entries for this prefix (struct babel_source). */

  list routes;				/* Routes for this prefix (struct babel_route) */

  net_addr net;

  u64 router_id;

  u16 seqno;

};

struct babel_msg_ack_req {

  u8 type;

  u16 nonce;

  ip_addr sender;

};

struct babel_msg_hello {

  u8 type;

  u16 seqno;

  ip_addr sender;

};

  u8 type;

  u8 ae;

  u16 rxcost;

  ip_addr addr;

  ip_addr sender;

};

struct babel_msg_update {

  u8 type;

  u8 wildcard;

  u16 seqno;

  u16 metric;

  u64 router_id;

babel_iface_item:

 | PORT expr { BABEL_IFACE->port = $2; if (($2<1) || ($2>65535)) cf_error("Invalid port number"); }

 | RXCOST expr { BABEL_IFACE->rxcost = $2; if (($2<1) || ($2>65535)) cf_error("Invalid rxcost"); }

 | TYPE WIRED { BABEL_IFACE->type = BABEL_IFACE_TYPE_WIRED; }

 | TYPE WIRELESS { BABEL_IFACE->type = BABEL_IFACE_TYPE_WIRELESS; }

 | RX BUFFER expr { BABEL_IFACE->rx_buffer = $3; if (($3<256) || ($3>65535)) cf_error("RX buffer must be in range 256-65535"); }

 | TX LENGTH expr { BABEL_IFACE->tx_length = $3; if (($3<256) || ($3>65535)) cf_error("TX length must be in range 256-65535"); }

 | TX tos { BABEL_IFACE->tx_tos = $2; }

  return i;

}

get_time16(const void *p)

{

}

static inline void

{

}

static inline void