proto/radv/radv.c

   1 /*
   2  *      BIRD -- Router Advertisement
   3  *
   4  *
   5  *      Can be freely distributed and used under the terms of the GNU GPL.
   6  */
   7
   8
   9 #include <stdlib.h>
  10 #include "radv.h"
  11
  12 /**
  13  * DOC: Router Advertisements
  14  *
  15  * The RAdv protocol is implemented in two files: |radv.c| containing
  16  * the interface with BIRD core and the protocol logic and |packets.c|
  17  * handling low level protocol stuff (RX, TX and packet formats).
  18  * The protocol does not export any routes.
  19  *
  20  * The RAdv is structured in the usual way - for each handled interface
  21  * there is a structure &radv_iface that contains a state related to
  22  * that interface together with its resources (a socket, a timer).
  23  * There is also a prepared RA stored in a TX buffer of the socket
  24  * associated with an iface. These iface structures are created
  25  * and removed according to iface events from BIRD core handled by
  26  * radv_if_notify() callback.
  27  *
  28  * The main logic of RAdv consists of two functions:
  29  * radv_iface_notify(), which processes asynchronous events (specified
  30  * by RA_EV_* codes), and radv_timer(), which triggers sending RAs and
  31  * computes the next timeout.
  32  *
  33  * The RAdv protocol could receive routes (through
  34  * radv_import_control() and radv_rt_notify()), but only the
  35  * configured trigger route is tracked (in &active var).  When a radv
  36  * protocol is reconfigured, the connected routing table is examined
  37  * (in radv_check_active()) to have proper &active value in case of
  38  * the specified trigger prefix was changed.
  39  *
  40  * Supported standards:
  41  * - RFC 4861 - main RA standard
  42  * - RFC 6106 - DNS extensions (RDDNS, DNSSL)
  43  * - RFC 4191 (partial) - Default Router Preference
  44  */
  45
  46 static void
  47 radv_timer(timer *tm)
  48 {
  49   struct radv_iface *ifa = tm->data;
  50   struct radv_proto *p = ifa->ra;
  51
  52   RADV_TRACE(D_EVENTS, "Timer fired on %s", ifa->iface->name);
  53
  54   radv_send_ra(ifa, 0);
  55
  56   /* Update timer */
  57   ifa->last = now;
  58   unsigned after = ifa->cf->min_ra_int;
  59   after += random() % (ifa->cf->max_ra_int - ifa->cf->min_ra_int + 1);
  60
  61   if (ifa->initial)
  62     ifa->initial--;
  63
  64   if (ifa->initial)
  65     after = MIN(after, MAX_INITIAL_RTR_ADVERT_INTERVAL);
  66
  67   tm_start(ifa->timer, after);
  68 }
  69
  70 static char* ev_name[] = { NULL, "Init", "Change", "RS" };
  71
  72 void
  73 radv_iface_notify(struct radv_iface *ifa, int event)
  74 {
  75   struct radv_proto *p = ifa->ra;
  76
  77   if (!ifa->sk)
  78     return;
  79
  80   RADV_TRACE(D_EVENTS, "Event %s on %s", ev_name[event], ifa->iface->name);
  81
  82   switch (event)
  83   {
  84   case RA_EV_CHANGE:
  85     ifa->plen = 0;
  86   case RA_EV_INIT:
  87     ifa->initial = MAX_INITIAL_RTR_ADVERTISEMENTS;
  88     break;
  89
  90   case RA_EV_RS:
  91     break;
  92   }
  93
  94   /* Update timer */
  95   unsigned delta = now - ifa->last;
  96   unsigned after = 0;
  97
  98   if (delta < ifa->cf->min_delay)
  99     after = ifa->cf->min_delay - delta;
 100
 101   tm_start(ifa->timer, after);
 102 }
 103
 104 static void
 105 radv_iface_notify_all(struct radv_proto *p, int event)
 106 {
 107   struct radv_iface *ifa;
 108
 109   WALK_LIST(ifa, p->iface_list)
 110     radv_iface_notify(ifa, event);
 111 }
 112
 113
 114 static struct radv_iface *
 115 radv_iface_find(struct radv_proto *p, struct iface *what)
 116 {
 117   struct radv_iface *ifa;
 118
 119   WALK_LIST(ifa, p->iface_list)
 120     if (ifa->iface == what)
 121       return ifa;
 122
 123   return NULL;
 124 }
 125
 126 static void
 127 radv_iface_add(struct object_lock *lock)
 128 {
 129   struct radv_iface *ifa = lock->data;
 130   struct radv_proto *p = ifa->ra;
 131
 132   if (! radv_sk_open(ifa))
 133   {
 134     log(L_ERR "%s: Socket open failed on interface %s", p->p.name, ifa->iface->name);
 135     return;
 136   }
 137
 138   radv_iface_notify(ifa, RA_EV_INIT);
 139 }
 140
 141 static inline struct ifa *
 142 find_lladdr(struct iface *iface)
 143 {
 144   struct ifa *a;
 145   WALK_LIST(a, iface->addrs)
 146     if ((a->prefix.type == NET_IP6) && (a->scope == SCOPE_LINK))
 147       return a;
 148
 149   return NULL;
 150 }
 151
 152 static void
 153 radv_iface_new(struct radv_proto *p, struct iface *iface, struct radv_iface_config *cf)
 154 {
 155   pool *pool = p->p.pool;
 156   struct radv_iface *ifa;
 157
 158   RADV_TRACE(D_EVENTS, "Adding interface %s", iface->name);
 159
 160   ifa = mb_allocz(pool, sizeof(struct radv_iface));
 161   ifa->ra = p;
 162   ifa->cf = cf;
 163   ifa->iface = iface;
 164
 165   add_tail(&p->iface_list, NODE ifa);
 166
 167   ifa->addr = find_lladdr(iface);
 168   if (!ifa->addr)
 169   {
 170     log(L_ERR "%s: Cannot find link-locad addr on interface %s", p->p.name, iface->name);
 171     return;
 172   }
 173
 174   timer *tm = tm_new(pool);
 175   tm->hook = radv_timer;
 176   tm->data = ifa;
 177   tm->randomize = 0;
 178   tm->recurrent = 0;
 179   ifa->timer = tm;
 180
 181   struct object_lock *lock = olock_new(pool);
 182   lock->addr = IPA_NONE;
 183   lock->type = OBJLOCK_IP;
 184   lock->port = ICMPV6_PROTO;
 185   lock->iface = iface;
 186   lock->data = ifa;
 187   lock->hook = radv_iface_add;
 188   ifa->lock = lock;
 189
 190   olock_acquire(lock);
 191 }
 192
 193 static void
 194 radv_iface_remove(struct radv_iface *ifa)
 195 {
 196   struct radv_proto *p = ifa->ra;
 197   RADV_TRACE(D_EVENTS, "Removing interface %s", ifa->iface->name);
 198
 199   rem_node(NODE ifa);
 200
 201   rfree(ifa->sk);
 202   rfree(ifa->timer);
 203   rfree(ifa->lock);
 204
 205   mb_free(ifa);
 206 }
 207
 208 static void
 209 radv_if_notify(struct proto *P, unsigned flags, struct iface *iface)
 210 {
 211   struct radv_proto *p = (struct radv_proto *) P;
 212   struct radv_config *cf = (struct radv_config *) (P->cf);
 213
 214   if (iface->flags & IF_IGNORE)
 215     return;
 216
 217   if (flags & IF_CHANGE_UP)
 218   {
 219     struct radv_iface_config *ic = (struct radv_iface_config *)
 220       iface_patt_find(&cf->patt_list, iface, NULL);
 221
 222     if (ic)
 223       radv_iface_new(p, iface, ic);
 224
 225     return;
 226   }
 227
 228   struct radv_iface *ifa = radv_iface_find(p, iface);
 229   if (!ifa)
 230     return;
 231
 232   if (flags & IF_CHANGE_DOWN)
 233   {
 234     radv_iface_remove(ifa);
 235     return;
 236   }
 237
 238   if ((flags & IF_CHANGE_LINK) && (iface->flags & IF_LINK_UP))
 239     radv_iface_notify(ifa, RA_EV_INIT);
 240 }
 241
 242 static void
 243 radv_ifa_notify(struct proto *P, unsigned flags UNUSED, struct ifa *a)
 244 {
 245   struct radv_proto *p = (struct radv_proto *) P;
 246
 247   if (a->flags & IA_SECONDARY)
 248     return;
 249
 250   if (a->scope <= SCOPE_LINK)
 251     return;
 252
 253   struct radv_iface *ifa = radv_iface_find(p, a->iface);
 254
 255   if (ifa)
 256     radv_iface_notify(ifa, RA_EV_CHANGE);
 257 }
 258
 259 static inline int
 260 radv_trigger_valid(struct radv_config *cf)
 261 {
 262   return cf->trigger.type != 0;
 263 }
 264
 265 static inline int
 266 radv_net_match_trigger(struct radv_config *cf, net *n)
 267 {
 268   return radv_trigger_valid(cf) && net_equal(n->n.addr, &cf->trigger);
 269 }
 270
 271 int
 272 radv_import_control(struct proto *P, rte **new, ea_list **attrs UNUSED, struct linpool *pool UNUSED)
 273 {
 274   // struct radv_proto *p = (struct radv_proto *) P;
 275   struct radv_config *cf = (struct radv_config *) (P->cf);
 276
 277   if (radv_net_match_trigger(cf, (*new)->net))
 278     return RIC_PROCESS;
 279
 280   return RIC_DROP;
 281 }
 282
 283 static void
 284 radv_rt_notify(struct proto *P, struct channel *ch UNUSED, net *n, rte *new, rte *old UNUSED, ea_list *attrs UNUSED)
 285 {
 286   struct radv_proto *p = (struct radv_proto *) P;
 287   struct radv_config *cf = (struct radv_config *) (P->cf);
 288
 289   if (radv_net_match_trigger(cf, n))
 290   {
 291     u8 old_active = p->active;
 292     p->active = !!new;
 293
 294     if (p->active == old_active)
 295       return;
 296
 297     if (p->active)
 298       RADV_TRACE(D_EVENTS, "Triggered");
 299     else
 300       RADV_TRACE(D_EVENTS, "Suppressed");
 301
 302     radv_iface_notify_all(p, RA_EV_CHANGE);
 303   }
 304 }
 305
 306 static int
 307 radv_check_active(struct radv_proto *p)
 308 {
 309   struct radv_config *cf = (struct radv_config *) (p->p.cf);
 310
 311   if (!radv_trigger_valid(cf))
 312     return 1;
 313
 314   struct channel *c = p->p.main_channel;
 315   return rt_examine(c->table, &cf->trigger, &p->p, c->out_filter);
 316 }
 317
 318 static void
 319 radv_postconfig(struct proto_config *CF)
 320 {
 321   // struct radv_config *cf = (void *) CF;
 322
 323   /* Define default channel */
 324   if (EMPTY_LIST(CF->channels))
 325     channel_config_new(NULL, NET_IP6, CF);
 326 }
 327
 328 static struct proto *
 329 radv_init(struct proto_config *CF)
 330 {
 331   struct proto *P = proto_new(CF);
 332
 333   P->main_channel = proto_add_channel(P, proto_cf_main_channel(CF));
 334
 335   P->import_control = radv_import_control;
 336   P->rt_notify = radv_rt_notify;
 337   P->if_notify = radv_if_notify;
 338   P->ifa_notify = radv_ifa_notify;
 339
 340   return P;
 341 }
 342
 343 static int
 344 radv_start(struct proto *P)
 345 {
 346   struct radv_proto *p = (struct radv_proto *) P;
 347   struct radv_config *cf = (struct radv_config *) (P->cf);
 348
 349   init_list(&(p->iface_list));
 350   p->active = !radv_trigger_valid(cf);
 351
 352   return PS_UP;
 353 }
 354
 355 static inline void
 356 radv_iface_shutdown(struct radv_iface *ifa)
 357 {
 358   if (ifa->sk)
 359     radv_send_ra(ifa, 1);
 360 }
 361
 362 static int
 363 radv_shutdown(struct proto *P)
 364 {
 365   struct radv_proto *p = (struct radv_proto *) P;
 366
 367   struct radv_iface *ifa;
 368   WALK_LIST(ifa, p->iface_list)
 369     radv_iface_shutdown(ifa);
 370
 371   return PS_DOWN;
 372 }
 373
 374 static int
 375 radv_reconfigure(struct proto *P, struct proto_config *CF)
 376 {
 377   struct radv_proto *p = (struct radv_proto *) P;
 378   // struct radv_config *old = (struct radv_config *) (p->cf);
 379   struct radv_config *new = (struct radv_config *) CF;
 380
 381   /*
 382    * The question is why there is a reconfigure function for RAdv if
 383    * it has almost none internal state so restarting the protocol
 384    * would probably suffice. One small reason is that restarting the
 385    * protocol would lead to sending a RA with Router Lifetime 0
 386    * causing nodes to temporary remove their default routes.
 387    */
 388
 389   if (!proto_configure_channel(P, &P->main_channel, proto_cf_main_channel(CF)))
 390     return 0;
 391
 392   P->cf = CF; /* radv_check_active() requires proper p->cf */
 393   p->active = radv_check_active(p);
 394
 395   struct iface *iface;
 396   WALK_LIST(iface, iface_list)
 397   {
 398     struct radv_iface *ifa = radv_iface_find(p, iface);
 399     struct radv_iface_config *ic = (struct radv_iface_config *)
 400       iface_patt_find(&new->patt_list, iface, NULL);
 401
 402     if (ifa && ic)
 403     {
 404       ifa->cf = ic;
 405
 406       /* We cheat here - always notify the change even if there isn't
 407          any. That would leads just to a few unnecessary RAs. */
 408       radv_iface_notify(ifa, RA_EV_CHANGE);
 409     }
 410
 411     if (ifa && !ic)
 412     {
 413       radv_iface_shutdown(ifa);
 414       radv_iface_remove(ifa);
 415     }
 416
 417     if (!ifa && ic)
 418       radv_iface_new(p, iface, ic);
 419   }
 420
 421   return 1;
 422 }
 423
 424 static void
 425 radv_copy_config(struct proto_config *dest, struct proto_config *src)
 426 {
 427   struct radv_config *d = (struct radv_config *) dest;
 428   struct radv_config *s = (struct radv_config *) src;
 429
 430   /* We clean up patt_list, ifaces are non-sharable */
 431   init_list(&d->patt_list);
 432
 433   /* We copy pref_list, shallow copy suffices */
 434   cfg_copy_list(&d->pref_list, &s->pref_list, sizeof(struct radv_prefix_config));
 435 }
 436
 437 static void
 438 radv_get_status(struct proto *P, byte *buf)
 439 {
 440   struct radv_proto *p = (struct radv_proto *) P;
 441
 442   if (!p->active)
 443     strcpy(buf, "Suppressed");
 444 }
 445
 446 struct protocol proto_radv = {
 447   .name =               "RAdv",
 448   .template =           "radv%d",
 449   .channel_mask =       NB_IP6,
 450   .proto_size =         sizeof(struct radv_proto),
 451   .config_size =        sizeof(struct radv_config),
 452   .postconfig =         radv_postconfig,
 453   .init =               radv_init,
 454   .start =              radv_start,
 455   .shutdown =           radv_shutdown,
 456   .reconfigure =        radv_reconfigure,
 457   .copy_config =        radv_copy_config,
 458   .get_status =         radv_get_status
 459 };