vnet/vnet/ip/ip6_neighbor.c

   1 /*
   2  * ip/ip6_neighbor.c: IP6 neighbor handling
   3  *
   4  * Copyright (c) 2010 Cisco and/or its affiliates.
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at:
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #include <vnet/ip/ip.h>
  19 #include <vnet/ethernet/ethernet.h>
  20 #include <vppinfra/mhash.h>
  21 #include <vppinfra/md5.h>
  22 #include <vnet/adj/adj.h>
  23 #include <vnet/fib/fib_table.h>
  24 #include <vnet/fib/ip6_fib.h>
  25
  26 /**
  27  * @file
  28  * @brief IPv6 Neighbor Adjacency and Neighbor Discovery.
  29  *
  30  * The files contains the API and CLI code for managing IPv6 neighbor
  31  * adjacency tables and neighbor discovery logic.
  32  */
  33
  34 typedef struct {
  35   ip6_address_t ip6_address;
  36   u32 sw_if_index;
  37   u32 pad;
  38 } ip6_neighbor_key_t;
  39
  40 /* can't use sizeof link_layer_address, that's 8 */
  41 #define ETHER_MAC_ADDR_LEN 6
  42
  43 typedef struct {
  44   ip6_neighbor_key_t key;
  45   u8 link_layer_address[8];
  46   u16 flags;
  47 #define IP6_NEIGHBOR_FLAG_STATIC (1 << 0)
  48 #define IP6_NEIGHBOR_FLAG_DYNAMIC  (2 << 0)
  49   u64 cpu_time_last_updated;
  50   fib_node_index_t fib_entry_index;
  51 } ip6_neighbor_t;
  52
  53 /* advertised prefix option */
  54 typedef struct {
  55   /* basic advertised information */
  56   ip6_address_t prefix;
  57   u8 prefix_len;
  58   int adv_on_link_flag;
  59   int adv_autonomous_flag;
  60   u32 adv_valid_lifetime_in_secs;
  61   u32 adv_pref_lifetime_in_secs;
  62
  63   /* advertised values are computed from these times if decrementing */
  64   f64 valid_lifetime_expires;
  65   f64  pref_lifetime_expires;
  66
  67   /* local information */
  68   int enabled;
  69   int deprecated_prefix_flag;
  70   int decrement_lifetime_flag;
  71
  72 #define MIN_ADV_VALID_LIFETIME 7203     /* seconds */
  73 #define DEF_ADV_VALID_LIFETIME  2592000
  74 #define DEF_ADV_PREF_LIFETIME 604800
  75
  76   /* extensions are added here, mobile, DNS etc.. */
  77 } ip6_radv_prefix_t;
  78
  79
  80 typedef struct {
  81   /* group information */
  82   u8 type;
  83   ip6_address_t mcast_address;
  84   u16 num_sources;
  85   ip6_address_t *mcast_source_address_pool;
  86 } ip6_mldp_group_t;
  87
  88 /* configured router advertisement information per ipv6 interface */
  89 typedef struct {
  90
  91   /* advertised config information, zero means unspecified  */
  92   u8  curr_hop_limit;
  93   int adv_managed_flag;
  94   int adv_other_flag;
  95   u16 adv_router_lifetime_in_sec;
  96   u32 adv_neighbor_reachable_time_in_msec;
  97   u32 adv_time_in_msec_between_retransmitted_neighbor_solicitations;
  98
  99   /* mtu option */
 100   u32 adv_link_mtu;
 101
 102   /* source link layer option */
 103   u8  link_layer_address[8];
 104   u8  link_layer_addr_len;
 105
 106   /* prefix option */
 107   ip6_radv_prefix_t * adv_prefixes_pool;
 108
 109   /* Hash table mapping address to index in interface advertised  prefix pool. */
 110   mhash_t address_to_prefix_index;
 111
 112   /* MLDP  group information */
 113   ip6_mldp_group_t  * mldp_group_pool;
 114
 115   /* Hash table mapping address to index in mldp address pool. */
 116   mhash_t address_to_mldp_index;
 117
 118   /* local information */
 119   u32 sw_if_index;
 120   u32 fib_index;
 121   int send_radv;              /* radv on/off on this interface -  set by config */
 122   int cease_radv;           /* we are ceasing  to send  - set byf config */
 123   int send_unicast;
 124   int adv_link_layer_address;
 125   int prefix_option;
 126   int failed_device_check;
 127   int all_routers_mcast;
 128   u32 seed;
 129   u64 randomizer;
 130   int ref_count;
 131   adj_index_t all_nodes_adj_index;
 132   adj_index_t all_routers_adj_index;
 133   adj_index_t all_mldv2_routers_adj_index;
 134
 135   /* timing information */
 136 #define DEF_MAX_RADV_INTERVAL 200
 137 #define DEF_MIN_RADV_INTERVAL .75 * DEF_MAX_RADV_INTERVAL
 138 #define DEF_CURR_HOP_LIMIT  64
 139 #define DEF_DEF_RTR_LIFETIME   3 * DEF_MAX_RADV_INTERVAL
 140 #define MAX_DEF_RTR_LIFETIME   9000
 141
 142 #define MAX_INITIAL_RTR_ADVERT_INTERVAL   16  /* seconds */
 143 #define MAX_INITIAL_RTR_ADVERTISEMENTS        3    /*transmissions */
 144 #define MIN_DELAY_BETWEEN_RAS                              3  /* seconds */
 145 #define MAX_DELAY_BETWEEN_RAS                    1800  /* seconds */
 146 #define MAX_RA_DELAY_TIME                                          .5 /* seconds */
 147
 148   f64 max_radv_interval;
 149   f64 min_radv_interval;
 150   f64 min_delay_between_radv;
 151   f64 max_delay_between_radv;
 152   f64 max_rtr_default_lifetime;
 153
 154   f64 last_radv_time;
 155   f64 last_multicast_time;
 156   f64 next_multicast_time;
 157
 158
 159   u32 initial_adverts_count;
 160   f64 initial_adverts_interval;
 161   u32 initial_adverts_sent;
 162
 163   /* stats */
 164   u32 n_advertisements_sent;
 165   u32 n_solicitations_rcvd;
 166   u32 n_solicitations_dropped;
 167
 168   /* Link local address to use (defaults to underlying physical for logical interfaces */
 169   ip6_address_t link_local_address;
 170   u8 link_local_prefix_len;
 171
 172 } ip6_radv_t;
 173
 174 typedef struct {
 175   u32 next_index;
 176   uword node_index;
 177   uword type_opaque;
 178   uword data;
 179   /* Used for nd event notification only */
 180   void * data_callback;
 181   u32 pid;
 182 } pending_resolution_t;
 183
 184
 185 typedef struct {
 186   /* Hash tables mapping name to opcode. */
 187   uword * opcode_by_name;
 188
 189   /* lite beer "glean" adjacency handling */
 190   mhash_t pending_resolutions_by_address;
 191   pending_resolution_t * pending_resolutions;
 192
 193   /* Mac address change notification */
 194   mhash_t mac_changes_by_address;
 195   pending_resolution_t * mac_changes;
 196
 197   u32 * neighbor_input_next_index_by_hw_if_index;
 198
 199   ip6_neighbor_t * neighbor_pool;
 200
 201   mhash_t neighbor_index_by_key;
 202
 203   u32 * if_radv_pool_index_by_sw_if_index;
 204
 205   ip6_radv_t * if_radv_pool;
 206
 207   /* Neighbor attack mitigation */
 208   u32 limit_neighbor_cache_size;
 209   u32 neighbor_delete_rotor;
 210
 211 } ip6_neighbor_main_t;
 212
 213 static ip6_neighbor_main_t ip6_neighbor_main;
 214 static ip6_address_t ip6a_zero;    /* ip6 address 0 */
 215
 216 static u8 * format_ip6_neighbor_ip6_entry (u8 * s, va_list * va)
 217 {
 218   vlib_main_t * vm = va_arg (*va, vlib_main_t *);
 219   ip6_neighbor_t * n = va_arg (*va, ip6_neighbor_t *);
 220   vnet_main_t * vnm = vnet_get_main();
 221   vnet_sw_interface_t * si;
 222   u8 * flags = 0;
 223
 224   if (! n)
 225     return format (s, "%=12s%=20s%=6s%=20s%=40s", "Time", "Address", "Flags", "Link layer", "Interface");
 226
 227   if (n->flags & IP6_NEIGHBOR_FLAG_DYNAMIC)
 228     flags = format(flags, "D");
 229
 230   if (n->flags & IP6_NEIGHBOR_FLAG_STATIC)
 231     flags = format(flags, "S");
 232
 233   si = vnet_get_sw_interface (vnm, n->key.sw_if_index);
 234   s = format (s, "%=12U%=20U%=6s%=20U%=40U",
 235               format_vlib_cpu_time, vm, n->cpu_time_last_updated,
 236               format_ip6_address, &n->key.ip6_address,
 237               flags ? (char *)flags : "",
 238               format_ethernet_address, n->link_layer_address,
 239               format_vnet_sw_interface_name, vnm, si);
 240
 241   vec_free(flags);
 242   return s;
 243 }
 244
 245 static clib_error_t *
 246 ip6_neighbor_sw_interface_up_down (vnet_main_t * vnm,
 247                                    u32 sw_if_index,
 248                                    u32 flags)
 249 {
 250   ip6_neighbor_main_t * nm = &ip6_neighbor_main;
 251   ip6_neighbor_t * n;
 252
 253   if (! (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP))
 254     {
 255       u32 i, * to_delete = 0;
 256
 257       pool_foreach (n, nm->neighbor_pool, ({
 258         if (n->key.sw_if_index == sw_if_index)
 259           vec_add1 (to_delete, n - nm->neighbor_pool);
 260       }));
 261
 262       for (i = 0; i < vec_len (to_delete); i++)
 263         {
 264           n = pool_elt_at_index (nm->neighbor_pool, to_delete[i]);
 265           mhash_unset (&nm->neighbor_index_by_key, &n->key, 0);
 266           fib_table_entry_delete_index (n->fib_entry_index,  FIB_SOURCE_ADJ);
 267           pool_put (nm->neighbor_pool, n);
 268         }
 269
 270       vec_free (to_delete);
 271     }
 272
 273   return 0;
 274 }
 275
 276 VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION (ip6_neighbor_sw_interface_up_down);
 277
 278 static void unset_random_neighbor_entry (void)
 279 {
 280   ip6_neighbor_main_t * nm = &ip6_neighbor_main;
 281   vnet_main_t * vnm = vnet_get_main();
 282   vlib_main_t * vm = vnm->vlib_main;
 283   ip6_neighbor_t * e;
 284   u32 index;
 285
 286   index = pool_next_index (nm->neighbor_pool, nm->neighbor_delete_rotor);
 287   nm->neighbor_delete_rotor = index;
 288
 289   /* Try again from elt 0, could happen if an intfc goes down */
 290   if (index == ~0)
 291     {
 292       index = pool_next_index (nm->neighbor_pool, nm->neighbor_delete_rotor);
 293       nm->neighbor_delete_rotor = index;
 294     }
 295
 296   /* Nothing left in the pool */
 297   if (index == ~0)
 298     return;
 299
 300   e = pool_elt_at_index (nm->neighbor_pool, index);
 301
 302   vnet_unset_ip6_ethernet_neighbor (vm, e->key.sw_if_index,
 303                                     &e->key.ip6_address,
 304                                     e->link_layer_address,
 305                                     ETHER_MAC_ADDR_LEN);
 306 }
 307
 308 typedef struct {
 309   u8 is_add;
 310   u8 is_static;
 311   u8 link_layer_address[6];
 312   u32 sw_if_index;
 313   ip6_address_t addr;
 314 } ip6_neighbor_set_unset_rpc_args_t;
 315
 316 static void ip6_neighbor_set_unset_rpc_callback
 317 ( ip6_neighbor_set_unset_rpc_args_t * a);
 318
 319 static void set_unset_ip6_neighbor_rpc
 320 (vlib_main_t * vm,
 321  u32 sw_if_index,
 322  ip6_address_t * a,
 323  u8 *link_layer_addreess,
 324  int is_add, int is_static)
 325 {
 326   ip6_neighbor_set_unset_rpc_args_t args;
 327   void vl_api_rpc_call_main_thread (void *fp, u8 * data, u32 data_length);
 328
 329   args.sw_if_index = sw_if_index;
 330   args.is_add = is_add;
 331   args.is_static = is_static;
 332   clib_memcpy (&args.addr, a, sizeof (*a));
 333   clib_memcpy (args.link_layer_address, link_layer_addreess, 6);
 334
 335   vl_api_rpc_call_main_thread (ip6_neighbor_set_unset_rpc_callback,
 336                                (u8 *) &args, sizeof (args));
 337 }
 338
 339 static void
 340 ip6_nbr_probe (ip_adjacency_t *adj)
 341 {
 342   icmp6_neighbor_solicitation_header_t * h;
 343   vnet_main_t * vnm = vnet_get_main();
 344   ip6_main_t * im = &ip6_main;
 345   ip_interface_address_t * ia;
 346   ip6_address_t * dst, *src;
 347   vnet_hw_interface_t * hi;
 348   vnet_sw_interface_t * si;
 349   vlib_buffer_t * b;
 350   int bogus_length;
 351   vlib_main_t * vm;
 352   u32 bi = 0;
 353
 354   vm = vlib_get_main();
 355
 356   si = vnet_get_sw_interface(vnm, adj->rewrite_header.sw_if_index);
 357   dst = &adj->sub_type.nbr.next_hop.ip6;
 358
 359   if (!(si->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP))
 360     {
 361       return;
 362     }
 363   src = ip6_interface_address_matching_destination(im, dst,
 364                                                    adj->rewrite_header.sw_if_index,
 365                                                    &ia);
 366   if (! src)
 367     {
 368       return;
 369     }
 370
 371   h = vlib_packet_template_get_packet(vm,
 372                                       &im->discover_neighbor_packet_template,
 373                                       &bi);
 374
 375   hi = vnet_get_sup_hw_interface(vnm, adj->rewrite_header.sw_if_index);
 376
 377   h->ip.dst_address.as_u8[13] = dst->as_u8[13];
 378   h->ip.dst_address.as_u8[14] = dst->as_u8[14];
 379   h->ip.dst_address.as_u8[15] = dst->as_u8[15];
 380   h->ip.src_address = src[0];
 381   h->neighbor.target_address = dst[0];
 382
 383   clib_memcpy (h->link_layer_option.ethernet_address,
 384                hi->hw_address,
 385                vec_len(hi->hw_address));
 386
 387   h->neighbor.icmp.checksum =
 388       ip6_tcp_udp_icmp_compute_checksum(vm, 0, &h->ip, &bogus_length);
 389   ASSERT(bogus_length == 0);
 390
 391   b = vlib_get_buffer (vm, bi);
 392   vnet_buffer (b)->sw_if_index[VLIB_RX] =
 393       vnet_buffer (b)->sw_if_index[VLIB_TX] =
 394       adj->rewrite_header.sw_if_index;
 395
 396   /* Add encapsulation string for software interface (e.g. ethernet header). */
 397   vnet_rewrite_one_header(adj[0], h, sizeof (ethernet_header_t));
 398   vlib_buffer_advance(b, -adj->rewrite_header.data_bytes);
 399
 400   {
 401       vlib_frame_t * f = vlib_get_frame_to_node(vm, hi->output_node_index);
 402       u32 * to_next = vlib_frame_vector_args(f);
 403       to_next[0] = bi;
 404       f->n_vectors = 1;
 405       vlib_put_frame_to_node(vm, hi->output_node_index, f);
 406   }
 407 }
 408
 409 static void
 410 ip6_nd_mk_complete (adj_index_t ai, ip6_neighbor_t * nbr)
 411 {
 412   adj_nbr_update_rewrite (ai, ADJ_NBR_REWRITE_FLAG_COMPLETE,
 413                           ethernet_build_rewrite (vnet_get_main (),
 414                                                   nbr->key.sw_if_index,
 415                                                   adj_get_link_type(ai),
 416                                                   nbr->link_layer_address));
 417 }
 418
 419 static void
 420 ip6_nd_mk_incomplete (adj_index_t ai, ip6_neighbor_t * nbr)
 421 {
 422   adj_nbr_update_rewrite (
 423       ai,
 424       ADJ_NBR_REWRITE_FLAG_INCOMPLETE,
 425       ethernet_build_rewrite (vnet_get_main (),
 426                               nbr->key.sw_if_index,
 427                               adj_get_link_type(ai),
 428                               VNET_REWRITE_FOR_SW_INTERFACE_ADDRESS_BROADCAST));
 429 }
 430
 431 #define IP6_NBR_MK_KEY(k, sw_if_index, addr) \
 432 {                                            \
 433     k.sw_if_index = sw_if_index;             \
 434     k.ip6_address = *addr;                   \
 435     k.pad = 0;                               \
 436 }
 437
 438 static ip6_neighbor_t *
 439 ip6_nd_find (u32 sw_if_index,
 440              const ip6_address_t * addr)
 441 {
 442   ip6_neighbor_main_t * nm = &ip6_neighbor_main;
 443   ip6_neighbor_t * n = NULL;
 444   ip6_neighbor_key_t k;
 445   uword *p;
 446
 447   IP6_NBR_MK_KEY(k, sw_if_index, addr);
 448
 449   p = mhash_get (&nm->neighbor_index_by_key, &k);
 450   if (p) {
 451     n = pool_elt_at_index (nm->neighbor_pool, p[0]);
 452   }
 453
 454   return (n);
 455 }
 456
 457 static adj_walk_rc_t
 458 ip6_nd_mk_complete_walk (adj_index_t ai, void *ctx)
 459 {
 460   ip6_neighbor_t *nbr = ctx;
 461
 462   ip6_nd_mk_complete (ai, nbr);
 463
 464   return (ADJ_WALK_RC_CONTINUE);
 465 }
 466
 467 static adj_walk_rc_t
 468 ip6_nd_mk_incomplete_walk (adj_index_t ai, void *ctx)
 469 {
 470   ip6_neighbor_t *nbr = ctx;
 471
 472   ip6_nd_mk_incomplete (ai, nbr);
 473
 474   return (ADJ_WALK_RC_CONTINUE);
 475 }
 476
 477 void
 478 ip6_ethernet_update_adjacency (vnet_main_t * vnm,
 479                                u32 sw_if_index,
 480                                u32 ai)
 481 {
 482   ip6_neighbor_t *nbr;
 483   ip_adjacency_t *adj;
 484
 485   adj = adj_get (ai);
 486
 487   nbr = ip6_nd_find (sw_if_index, &adj->sub_type.nbr.next_hop.ip6);
 488
 489   if (NULL != nbr)
 490     {
 491       adj_nbr_walk_nh6 (sw_if_index, &nbr->key.ip6_address,
 492                         ip6_nd_mk_complete_walk, nbr);
 493     }
 494   else
 495     {
 496       /*
 497        * no matching ND entry.
 498        * construct the rewrite required to for an ND packet, and stick
 499        * that in the adj's pipe to smoke.
 500        */
 501       adj_nbr_update_rewrite (ai,
 502                               ADJ_NBR_REWRITE_FLAG_INCOMPLETE,
 503                               ethernet_build_rewrite (vnm,
 504                                                       sw_if_index,
 505                                                       VNET_LINK_IP6,
 506                                                       VNET_REWRITE_FOR_SW_INTERFACE_ADDRESS_BROADCAST));
 507
 508       /*
 509        * since the FIB has added this adj for a route, it makes sense it may
 510        * want to forward traffic sometime soon. Let's send a speculative ND.
 511        * just one. If we were to do periodically that wouldn't be bad either,
 512        * but that's more code than i'm prepared to write at this time for
 513        * relatively little reward.
 514        */
 515       ip6_nbr_probe (adj);
 516     }
 517 }
 518
 519 int
 520 vnet_set_ip6_ethernet_neighbor (vlib_main_t * vm,
 521                                 u32 sw_if_index,
 522                                 ip6_address_t * a,
 523                                 u8 * link_layer_address,
 524                                 uword n_bytes_link_layer_address,
 525                                 int is_static)
 526 {
 527   ip6_neighbor_main_t * nm = &ip6_neighbor_main;
 528   ip6_neighbor_key_t k;
 529   ip6_neighbor_t * n = 0;
 530   int make_new_nd_cache_entry=1;
 531   uword * p;
 532   u32 next_index;
 533   pending_resolution_t * pr, * mc;
 534
 535   if (os_get_cpu_number())
 536     {
 537       set_unset_ip6_neighbor_rpc (vm, sw_if_index, a, link_layer_address,
 538                                   1 /* set new neighbor */, is_static);
 539       return 0;
 540     }
 541
 542   k.sw_if_index = sw_if_index;
 543   k.ip6_address = a[0];
 544   k.pad = 0;
 545
 546   p = mhash_get (&nm->neighbor_index_by_key, &k);
 547   if (p) {
 548     n = pool_elt_at_index (nm->neighbor_pool, p[0]);
 549     /* Refuse to over-write static neighbor entry. */
 550     if (!is_static &&
 551         (n->flags & IP6_NEIGHBOR_FLAG_STATIC))
 552       return -2;
 553     make_new_nd_cache_entry = 0;
 554   }
 555
 556   if (make_new_nd_cache_entry) {
 557       fib_prefix_t pfx = {
 558           .fp_len = 128,
 559           .fp_proto = FIB_PROTOCOL_IP6,
 560           .fp_addr = {
 561               .ip6 = k.ip6_address,
 562           },
 563       };
 564       u32 fib_index;
 565
 566     pool_get (nm->neighbor_pool, n);
 567     mhash_set (&nm->neighbor_index_by_key, &k, n - nm->neighbor_pool,
 568                /* old value */ 0);
 569     n->key = k;
 570
 571     clib_memcpy (n->link_layer_address,
 572                  link_layer_address,
 573                  n_bytes_link_layer_address);
 574
 575     /*
 576      * create the adj-fib. the entry in the FIB table for and to the peer.
 577      */
 578     fib_index = ip6_main.fib_index_by_sw_if_index[n->key.sw_if_index];
 579     n->fib_entry_index =
 580         fib_table_entry_update_one_path(fib_index,
 581                                         &pfx,
 582                                         FIB_SOURCE_ADJ,
 583                                         FIB_ENTRY_FLAG_NONE,
 584                                         FIB_PROTOCOL_IP6,
 585                                         &pfx.fp_addr,
 586                                         n->key.sw_if_index,
 587                                         ~0,
 588                                         1,
 589                                         NULL, // no label stack
 590                                         FIB_ROUTE_PATH_FLAG_NONE);
 591   }
 592   else
 593   {
 594     /*
 595      * prevent a DoS attack from the data-plane that
 596      * spams us with no-op updates to the MAC address
 597      */
 598     if (0 == memcmp(n->link_layer_address,
 599                     link_layer_address,
 600                     n_bytes_link_layer_address))
 601       return -1;
 602
 603     clib_memcpy (n->link_layer_address,
 604                  link_layer_address,
 605                  n_bytes_link_layer_address);
 606   }
 607
 608   /* Update time stamp and flags. */
 609   n->cpu_time_last_updated = clib_cpu_time_now ();
 610   if (is_static)
 611     n->flags |= IP6_NEIGHBOR_FLAG_STATIC;
 612   else
 613     n->flags |= IP6_NEIGHBOR_FLAG_DYNAMIC;
 614
 615   adj_nbr_walk_nh6 (sw_if_index,
 616                     &n->key.ip6_address,
 617                     ip6_nd_mk_complete_walk, n);
 618
 619   /* Customer(s) waiting for this address to be resolved? */
 620   p = mhash_get (&nm->pending_resolutions_by_address, a);
 621   if (p)
 622     {
 623       next_index = p[0];
 624
 625       while (next_index != (u32)~0)
 626         {
 627           pr = pool_elt_at_index (nm->pending_resolutions, next_index);
 628           vlib_process_signal_event (vm, pr->node_index,
 629                                      pr->type_opaque,
 630                                      pr->data);
 631           next_index = pr->next_index;
 632           pool_put (nm->pending_resolutions, pr);
 633         }
 634
 635       mhash_unset (&nm->pending_resolutions_by_address, a, 0);
 636     }
 637
 638   /* Customer(s) requesting ND event for this address? */
 639   p = mhash_get (&nm->mac_changes_by_address, a);
 640   if (p)
 641     {
 642       next_index = p[0];
 643
 644       while (next_index != (u32)~0)
 645         {
 646           int (*fp)(u32, u8 *, u32, ip6_address_t *);
 647           int rv = 1;
 648           mc = pool_elt_at_index (nm->mac_changes, next_index);
 649           fp = mc->data_callback;
 650
 651           /* Call the user's data callback, return 1 to suppress dup events */
 652           if (fp)
 653             rv = (*fp)(mc->data, link_layer_address, sw_if_index, &ip6a_zero);
 654           /*
 655            * Signal the resolver process, as long as the user
 656            * says they want to be notified
 657            */
 658           if (rv == 0)
 659             vlib_process_signal_event (vm, mc->node_index,
 660                                        mc->type_opaque,
 661                                        mc->data);
 662           next_index = mc->next_index;
 663         }
 664     }
 665
 666   return 0;
 667 }
 668
 669 int
 670 vnet_unset_ip6_ethernet_neighbor (vlib_main_t * vm,
 671                                   u32 sw_if_index,
 672                                   ip6_address_t * a,
 673                                   u8 * link_layer_address,
 674                                   uword n_bytes_link_layer_address)
 675 {
 676   ip6_neighbor_main_t * nm = &ip6_neighbor_main;
 677   ip6_neighbor_key_t k;
 678   ip6_neighbor_t * n;
 679   uword * p;
 680   int rv = 0;
 681
 682   if (os_get_cpu_number())
 683     {
 684       set_unset_ip6_neighbor_rpc (vm, sw_if_index, a, link_layer_address,
 685                                   0 /* unset */, 0);
 686       return 0;
 687     }
 688
 689   k.sw_if_index = sw_if_index;
 690   k.ip6_address = a[0];
 691   k.pad = 0;
 692
 693   p = mhash_get (&nm->neighbor_index_by_key, &k);
 694   if (p == 0)
 695     {
 696       rv = -1;
 697       goto out;
 698     }
 699
 700   n = pool_elt_at_index (nm->neighbor_pool, p[0]);
 701
 702   adj_nbr_walk_nh6 (sw_if_index,
 703                     &n->key.ip6_address,
 704                     ip6_nd_mk_incomplete_walk,
 705                     n);
 706
 707   mhash_unset (&nm->neighbor_index_by_key, &n->key, 0);
 708   fib_table_entry_delete_index (n->fib_entry_index,  FIB_SOURCE_ADJ);
 709   pool_put (nm->neighbor_pool, n);
 710
 711  out:
 712   return rv;
 713 }
 714
 715 static void ip6_neighbor_set_unset_rpc_callback
 716 ( ip6_neighbor_set_unset_rpc_args_t * a)
 717 {
 718   vlib_main_t * vm = vlib_get_main();
 719   if (a->is_add)
 720       vnet_set_ip6_ethernet_neighbor (vm, a->sw_if_index, &a->addr,
 721                                       a->link_layer_address, 6, a->is_static);
 722   else
 723     vnet_unset_ip6_ethernet_neighbor (vm, a->sw_if_index, &a->addr,
 724                                       a->link_layer_address, 6);
 725 }
 726
 727 static int
 728 ip6_neighbor_sort (void *a1, void *a2)
 729 {
 730   vnet_main_t * vnm = vnet_get_main();
 731   ip6_neighbor_t * n1 = a1, * n2 = a2;
 732   int cmp;
 733   cmp = vnet_sw_interface_compare (vnm, n1->key.sw_if_index,
 734                                    n2->key.sw_if_index);
 735   if (! cmp)
 736     cmp = ip6_address_compare (&n1->key.ip6_address, &n2->key.ip6_address);
 737   return cmp;
 738 }
 739
 740 static clib_error_t *
 741 show_ip6_neighbors (vlib_main_t * vm,
 742                     unformat_input_t * input,
 743                     vlib_cli_command_t * cmd)
 744 {
 745   vnet_main_t * vnm = vnet_get_main();
 746   ip6_neighbor_main_t * nm = &ip6_neighbor_main;
 747   ip6_neighbor_t * n, * ns;
 748   clib_error_t * error = 0;
 749   u32 sw_if_index;
 750
 751   /* Filter entries by interface if given. */
 752   sw_if_index = ~0;
 753   (void) unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index);
 754
 755   ns = 0;
 756   pool_foreach (n, nm->neighbor_pool, ({ vec_add1 (ns, n[0]); }));
 757   if (ns)
 758     {
 759       vec_sort_with_function (ns, ip6_neighbor_sort);
 760       vlib_cli_output (vm, "%U", format_ip6_neighbor_ip6_entry, vm, 0);
 761       vec_foreach (n, ns) {
 762         if (sw_if_index != ~0 && n->key.sw_if_index != sw_if_index)
 763           continue;
 764         vlib_cli_output (vm, "%U", format_ip6_neighbor_ip6_entry, vm, n);
 765       }
 766       vec_free (ns);
 767     }
 768
 769   return error;
 770 }
 771
 772 /*?
 773  * This command is used to display the adjacent IPv6 hosts found via
 774  * neighbor discovery. Optionally, limit the output to the specified
 775  * interface.
 776  *
 777  * @cliexpar
 778  * Example of how to display the IPv6 neighbor adjacency table:
 779  * @cliexstart{show ip6 neighbors}
 780  *     Time           Address       Flags     Link layer                     Interface
 781  *      34.0910     ::a:1:1:0:7            02:fe:6a:07:39:6f                GigabitEthernet2/0/0
 782  *     173.2916     ::b:5:1:c:2            02:fe:50:62:3a:94                GigabitEthernet2/0/0
 783  *     886.6654     ::1:1:c:0:9       S    02:fe:e4:45:27:5b                GigabitEthernet3/0/0
 784  * @cliexend
 785  * Example of how to display the IPv6 neighbor adjacency table for given interface:
 786  * @cliexstart{show ip6 neighbors GigabitEthernet2/0/0}
 787  *     Time           Address       Flags     Link layer                     Interface
 788  *      34.0910     ::a:1:1:0:7            02:fe:6a:07:39:6f                GigabitEthernet2/0/0
 789  *     173.2916     ::b:5:1:c:2            02:fe:50:62:3a:94                GigabitEthernet2/0/0
 790  * @cliexend
 791 ?*/
 792 /* *INDENT-OFF* */
 793 VLIB_CLI_COMMAND (show_ip6_neighbors_command, static) = {
 794   .path = "show ip6 neighbors",
 795   .function = show_ip6_neighbors,
 796   .short_help = "show ip6 neighbors [<interface>]",
 797 };
 798 /* *INDENT-ON* */
 799
 800 static clib_error_t *
 801 set_ip6_neighbor (vlib_main_t * vm,
 802                   unformat_input_t * input,
 803                   vlib_cli_command_t * cmd)
 804 {
 805   vnet_main_t * vnm = vnet_get_main();
 806   ip6_address_t addr;
 807   u8 mac_address[6];
 808   int addr_valid = 0;
 809   int is_del = 0;
 810   int is_static = 0;
 811   u32 sw_if_index;
 812
 813   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 814     {
 815       /* intfc, ip6-address, mac-address */
 816       if (unformat (input, "%U %U %U",
 817                     unformat_vnet_sw_interface, vnm, &sw_if_index,
 818                     unformat_ip6_address, &addr,
 819                     unformat_ethernet_address, mac_address))
 820         addr_valid = 1;
 821
 822       else if (unformat (input, "delete") || unformat (input, "del"))
 823         is_del = 1;
 824       else if (unformat (input, "static"))
 825         is_static = 1;
 826       else
 827         break;
 828     }
 829
 830   if (!addr_valid)
 831     return clib_error_return (0, "Missing interface, ip6 or hw address");
 832
 833   if (!is_del)
 834     vnet_set_ip6_ethernet_neighbor (vm, sw_if_index, &addr,
 835                                     mac_address, sizeof(mac_address), is_static);
 836   else
 837     vnet_unset_ip6_ethernet_neighbor (vm, sw_if_index, &addr,
 838                                       mac_address, sizeof(mac_address));
 839   return 0;
 840 }
 841
 842 /*?
 843  * This command is used to manually add an entry to the IPv6 neighbor
 844  * adjacency table. Optionally, the entry can be added as static. It is
 845  * also used to remove an entry from the table. Use the '<em>show ip6
 846  * neighbors</em>' command to display all learned and manually entered entries.
 847  *
 848  * @cliexpar
 849  * Example of how to add a static entry to the IPv6 neighbor adjacency table:
 850  * @cliexcmd{set ip6 neighbor GigabitEthernet2/0/0 ::1:1:c:0:9 02:fe:e4:45:27:5b static}
 851  * Example of how to delete an entry from the IPv6 neighbor adjacency table:
 852  * @cliexcmd{set ip6 neighbor del GigabitEthernet2/0/0 ::1:1:c:0:9 02:fe:e4:45:27:5b}
 853 ?*/
 854 /* *INDENT-OFF* */
 855 VLIB_CLI_COMMAND (set_ip6_neighbor_command, static) = {
 856   .path = "set ip6 neighbor",
 857   .function = set_ip6_neighbor,
 858   .short_help = "set ip6 neighbor [del] <interface> <ip6-address> <mac-address> [static]",
 859 };
 860 /* *INDENT-ON* */
 861
 862 typedef enum {
 863   ICMP6_NEIGHBOR_SOLICITATION_NEXT_DROP,
 864   ICMP6_NEIGHBOR_SOLICITATION_NEXT_REPLY,
 865   ICMP6_NEIGHBOR_SOLICITATION_N_NEXT,
 866 } icmp6_neighbor_solicitation_or_advertisement_next_t;
 867
 868 static_always_inline uword
 869 icmp6_neighbor_solicitation_or_advertisement (vlib_main_t * vm,
 870                                               vlib_node_runtime_t * node,
 871                                               vlib_frame_t * frame,
 872                                               uword is_solicitation)
 873 {
 874   vnet_main_t * vnm = vnet_get_main();
 875   ip6_main_t * im = &ip6_main;
 876   uword n_packets = frame->n_vectors;
 877   u32 * from, * to_next;
 878   u32 n_left_from, n_left_to_next, next_index, n_advertisements_sent;
 879   icmp6_neighbor_discovery_option_type_t option_type;
 880   vlib_node_runtime_t * error_node = vlib_node_get_runtime (vm, ip6_icmp_input_node.index);
 881   int bogus_length;
 882
 883   from = vlib_frame_vector_args (frame);
 884   n_left_from = n_packets;
 885   next_index = node->cached_next_index;
 886
 887   if (node->flags & VLIB_NODE_FLAG_TRACE)
 888     vlib_trace_frame_buffers_only (vm, node, from, frame->n_vectors,
 889                                    /* stride */ 1,
 890                                    sizeof (icmp6_input_trace_t));
 891
 892   option_type =
 893     (is_solicitation
 894      ? ICMP6_NEIGHBOR_DISCOVERY_OPTION_source_link_layer_address
 895      : ICMP6_NEIGHBOR_DISCOVERY_OPTION_target_link_layer_address);
 896   n_advertisements_sent = 0;
 897
 898   while (n_left_from > 0)
 899     {
 900       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 901
 902       while (n_left_from > 0 && n_left_to_next > 0)
 903         {
 904           vlib_buffer_t * p0;
 905           ip6_header_t * ip0;
 906           icmp6_neighbor_solicitation_or_advertisement_header_t * h0;
 907           icmp6_neighbor_discovery_ethernet_link_layer_address_option_t * o0;
 908           u32 bi0, options_len0, sw_if_index0, next0, error0;
 909           u32 ip6_sadd_link_local, ip6_sadd_unspecified;
 910           int is_rewrite0;
 911           u32 ni0;
 912
 913           bi0 = to_next[0] = from[0];
 914
 915           from += 1;
 916           to_next += 1;
 917           n_left_from -= 1;
 918           n_left_to_next -= 1;
 919
 920           p0 = vlib_get_buffer (vm, bi0);
 921           ip0 = vlib_buffer_get_current (p0);
 922           h0 = ip6_next_header (ip0);
 923           options_len0 = clib_net_to_host_u16 (ip0->payload_length) - sizeof (h0[0]);
 924
 925           error0 = ICMP6_ERROR_NONE;
 926           sw_if_index0 = vnet_buffer (p0)->sw_if_index[VLIB_RX];
 927           ip6_sadd_link_local = ip6_address_is_link_local_unicast(&ip0->src_address);
 928           ip6_sadd_unspecified = ip6_address_is_unspecified (&ip0->src_address);
 929
 930           /* Check that source address is unspecified, link-local or else on-link. */
 931           if (!ip6_sadd_unspecified && !ip6_sadd_link_local)
 932             {
 933               u32 src_adj_index0 = ip6_src_lookup_for_packet (im, p0, ip0);
 934
 935               if (ADJ_INDEX_INVALID != src_adj_index0)
 936                 {
 937                   ip_adjacency_t * adj0 = ip_get_adjacency (&im->lookup_main, src_adj_index0);
 938
 939                   /* Allow all realistic-looking rewrite adjacencies to pass */
 940                   ni0 = adj0->lookup_next_index;
 941                   is_rewrite0 = (ni0 >= IP_LOOKUP_NEXT_ARP) &&
 942                       (ni0 < IP6_LOOKUP_N_NEXT);
 943
 944                   error0 = ((adj0->rewrite_header.sw_if_index != sw_if_index0
 945                              || ! is_rewrite0)
 946                             ? ICMP6_ERROR_NEIGHBOR_SOLICITATION_SOURCE_NOT_ON_LINK
 947                             : error0);
 948                 }
 949               else
 950                 {
 951                   error0 = ICMP6_ERROR_NEIGHBOR_SOLICITATION_SOURCE_NOT_ON_LINK;
 952                 }
 953             }
 954
 955           o0 = (void *) (h0 + 1);
 956           o0 = ((options_len0 == 8 && o0->header.type == option_type
 957                  && o0->header.n_data_u64s == 1) ? o0 : 0);
 958
 959           /* If src address unspecified or link local, donot learn neighbor MAC */
 960           if (PREDICT_TRUE (error0 == ICMP6_ERROR_NONE && o0 != 0 &&
 961                             !ip6_sadd_unspecified && !ip6_sadd_link_local))
 962             {
 963               ip6_neighbor_main_t * nm = &ip6_neighbor_main;
 964               if (nm->limit_neighbor_cache_size &&
 965                   pool_elts (nm->neighbor_pool) >= nm->limit_neighbor_cache_size)
 966                   unset_random_neighbor_entry();
 967               vnet_set_ip6_ethernet_neighbor (
 968                   vm, sw_if_index0,
 969                   is_solicitation ? &ip0->src_address : &h0->target_address,
 970                   o0->ethernet_address, sizeof (o0->ethernet_address), 0);
 971             }
 972
 973           if (is_solicitation && error0 == ICMP6_ERROR_NONE)
 974             {
 975               /* Check that target address is local to this router. */
 976               fib_node_index_t fei;
 977               u32 fib_index;
 978
 979               fib_index = ip6_fib_table_get_index_for_sw_if_index(sw_if_index0);
 980
 981               if (~0 == fib_index)
 982                 {
 983                   error0 = ICMP6_ERROR_NEIGHBOR_SOLICITATION_SOURCE_UNKNOWN;
 984                 }
 985               else
 986                 {
 987                   fei = ip6_fib_table_lookup_exact_match(fib_index,
 988                                                          &h0->target_address,
 989                                                          128);
 990
 991                   if (FIB_NODE_INDEX_INVALID == fei ||
 992                       !(FIB_ENTRY_FLAG_LOCAL &
 993                         fib_entry_get_flags_for_source(fei, FIB_SOURCE_INTERFACE)))
 994                     {
 995                       error0 = ICMP6_ERROR_NEIGHBOR_SOLICITATION_SOURCE_UNKNOWN;
 996                     }
 997                 }
 998             }
 999
1000           if (is_solicitation)
1001             next0 = (error0 != ICMP6_ERROR_NONE
1002                      ? ICMP6_NEIGHBOR_SOLICITATION_NEXT_DROP
1003                      : ICMP6_NEIGHBOR_SOLICITATION_NEXT_REPLY);
1004           else
1005             {
1006               next0 = 0;
1007               error0 = error0 == ICMP6_ERROR_NONE ?
1008                   ICMP6_ERROR_NEIGHBOR_ADVERTISEMENTS_RX : error0;
1009             }
1010
1011           if (is_solicitation && error0 == ICMP6_ERROR_NONE)
1012             {
1013               vnet_sw_interface_t * sw_if0;
1014               ethernet_interface_t * eth_if0;
1015               ethernet_header_t *eth0;
1016
1017               /* dst address is either source address or the all-nodes mcast addr */
1018               if(!ip6_sadd_unspecified)
1019                   ip0->dst_address = ip0->src_address;
1020               else
1021                   ip6_set_reserved_multicast_address(&ip0->dst_address,
1022                                                      IP6_MULTICAST_SCOPE_link_local,
1023                                                      IP6_MULTICAST_GROUP_ID_all_hosts);
1024
1025               ip0->src_address = h0->target_address;
1026               ip0->hop_limit = 255;
1027               h0->icmp.type = ICMP6_neighbor_advertisement;
1028
1029               sw_if0 = vnet_get_sup_sw_interface (vnm, sw_if_index0);
1030               ASSERT (sw_if0->type == VNET_SW_INTERFACE_TYPE_HARDWARE);
1031               eth_if0 = ethernet_get_interface (&ethernet_main, sw_if0->hw_if_index);
1032               if (eth_if0 && o0)
1033                 {
1034                   clib_memcpy (o0->ethernet_address, eth_if0->address, 6);
1035                   o0->header.type =
1036                       ICMP6_NEIGHBOR_DISCOVERY_OPTION_target_link_layer_address;
1037                 }
1038
1039               h0->advertisement_flags = clib_host_to_net_u32
1040                 (ICMP6_NEIGHBOR_ADVERTISEMENT_FLAG_SOLICITED
1041                  | ICMP6_NEIGHBOR_ADVERTISEMENT_FLAG_OVERRIDE);
1042
1043               h0->icmp.checksum = 0;
1044               h0->icmp.checksum =
1045                   ip6_tcp_udp_icmp_compute_checksum (vm, p0, ip0,
1046                                                      &bogus_length);
1047               ASSERT(bogus_length == 0);
1048
1049               /* Reuse current MAC header, copy SMAC to DMAC and
1050                * interface MAC to SMAC */
1051               vlib_buffer_advance(p0, - ethernet_buffer_header_size(p0));
1052               eth0 = vlib_buffer_get_current(p0);
1053               clib_memcpy(eth0->dst_address, eth0->src_address, 6);
1054               if (eth_if0)
1055                 clib_memcpy(eth0->src_address, eth_if0->address, 6);
1056
1057               /* Setup input and output sw_if_index for packet */
1058               ASSERT(vnet_buffer(p0)->sw_if_index[VLIB_RX] == sw_if_index0);
1059               vnet_buffer(p0)->sw_if_index[VLIB_TX] = sw_if_index0;
1060               vnet_buffer(p0)->sw_if_index[VLIB_RX] =
1061                   vnet_main.local_interface_sw_if_index;
1062
1063               n_advertisements_sent++;
1064             }
1065
1066           p0->error = error_node->errors[error0];
1067
1068           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
1069                                            to_next, n_left_to_next,
1070                                            bi0, next0);
1071         }
1072
1073       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1074     }
1075
1076   /* Account for advertisements sent. */
1077   vlib_error_count (vm, error_node->node_index, ICMP6_ERROR_NEIGHBOR_ADVERTISEMENTS_TX, n_advertisements_sent);
1078
1079   return frame->n_vectors;
1080 }
1081
1082 /* for "syslogging" - use elog for now */
1083 #define foreach_log_level            \
1084   _ (DEBUG, "DEBUG")                         \
1085   _ (INFO, "INFORMATION")            \
1086   _ (NOTICE, "NOTICE")               \
1087   _ (WARNING, "WARNING")             \
1088   _ (ERR, "ERROR")                                    \
1089   _ (CRIT, "CRITICAL")                        \
1090   _ (ALERT, "ALERT")                          \
1091   _ (EMERG,  "EMERGENCY")
1092
1093 typedef enum {
1094 #define _(f,s) LOG_##f,
1095   foreach_log_level
1096 #undef _
1097 } log_level_t;
1098
1099 static char * log_level_strings[] = {
1100 #define _(f,s) s,
1101   foreach_log_level
1102 #undef _
1103 };
1104
1105 static  int logmask = 1 << LOG_DEBUG;
1106
1107 static void
1108 ip6_neighbor_syslog(vlib_main_t *vm,  int priority,  char * fmt, ...)
1109 {
1110   /* just use elog for now */
1111   u8 *what;
1112   va_list va;
1113
1114   if( (priority > LOG_EMERG) ||
1115       !(logmask & (1 << priority)))
1116       return;
1117
1118   va_start (va, fmt);
1119   if(fmt)
1120     {
1121       what = va_format (0, fmt, &va);
1122
1123       ELOG_TYPE_DECLARE (e) = {
1124         .format = "ip6 nd:  (%s): %s",
1125         .format_args = "T4T4",
1126       };
1127       struct { u32 s[2]; } * ed;
1128       ed = ELOG_DATA (&vm->elog_main, e);
1129       ed->s[0] = elog_string(&vm->elog_main,  log_level_strings[priority]);
1130       ed->s[1] = elog_string(&vm->elog_main,  (char *)what);
1131     }
1132   va_end (va);
1133   return;
1134 }
1135
1136 /* ipv6 neighbor discovery - router advertisements */
1137 typedef enum {
1138   ICMP6_ROUTER_SOLICITATION_NEXT_DROP,
1139   ICMP6_ROUTER_SOLICITATION_NEXT_REPLY_RW,
1140   ICMP6_ROUTER_SOLICITATION_NEXT_REPLY_TX,
1141   ICMP6_ROUTER_SOLICITATION_N_NEXT,
1142 } icmp6_router_solicitation_or_advertisement_next_t;
1143
1144 static_always_inline uword
1145 icmp6_router_solicitation(vlib_main_t * vm,
1146                           vlib_node_runtime_t * node,
1147                           vlib_frame_t * frame)
1148 {
1149   vnet_main_t * vnm = vnet_get_main();
1150   ip6_main_t * im = &ip6_main;
1151   ip6_neighbor_main_t * nm = &ip6_neighbor_main;
1152   uword n_packets = frame->n_vectors;
1153   u32 * from, * to_next;
1154   u32 n_left_from, n_left_to_next, next_index;
1155   u32  n_advertisements_sent = 0;
1156   int bogus_length;
1157
1158   icmp6_neighbor_discovery_option_type_t option_type;
1159
1160   vlib_node_runtime_t * error_node = vlib_node_get_runtime (vm, ip6_icmp_input_node.index);
1161
1162   from = vlib_frame_vector_args (frame);
1163   n_left_from = n_packets;
1164   next_index = node->cached_next_index;
1165
1166   if (node->flags & VLIB_NODE_FLAG_TRACE)
1167     vlib_trace_frame_buffers_only (vm, node, from, frame->n_vectors,
1168                                    /* stride */ 1,
1169                                    sizeof (icmp6_input_trace_t));
1170
1171   /* source may append his LL address */
1172   option_type = ICMP6_NEIGHBOR_DISCOVERY_OPTION_source_link_layer_address;
1173
1174   while (n_left_from > 0)
1175     {
1176       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
1177
1178       while (n_left_from > 0 && n_left_to_next > 0)
1179         {
1180           vlib_buffer_t * p0;
1181           ip6_header_t * ip0;
1182           ip6_radv_t *radv_info = 0;
1183
1184           icmp6_neighbor_discovery_header_t * h0;
1185           icmp6_neighbor_discovery_ethernet_link_layer_address_option_t * o0;
1186
1187           u32 bi0, options_len0, sw_if_index0, next0, error0;
1188           u32 is_solicitation = 1, is_dropped  = 0;
1189           u32 is_unspecified, is_link_local;
1190
1191           bi0 = to_next[0] = from[0];
1192
1193           from += 1;
1194           to_next += 1;
1195           n_left_from -= 1;
1196           n_left_to_next -= 1;
1197
1198           p0 = vlib_get_buffer (vm, bi0);
1199           ip0 = vlib_buffer_get_current (p0);
1200           h0 = ip6_next_header (ip0);
1201           options_len0 = clib_net_to_host_u16 (ip0->payload_length) - sizeof (h0[0]);
1202           is_unspecified = ip6_address_is_unspecified (&ip0->src_address);
1203           is_link_local = ip6_address_is_link_local_unicast (&ip0->src_address);
1204
1205           error0 = ICMP6_ERROR_NONE;
1206           sw_if_index0 = vnet_buffer (p0)->sw_if_index[VLIB_RX];
1207
1208           /* check if solicitation  (not from nd_timer node) */
1209           if (ip6_address_is_unspecified (&ip0->dst_address))
1210             is_solicitation = 0;
1211
1212           /* Check that source address is unspecified, link-local or else on-link. */
1213           if (!is_unspecified && !is_link_local)
1214             {
1215               u32 src_adj_index0 = ip6_src_lookup_for_packet (im, p0, ip0);
1216
1217               if (ADJ_INDEX_INVALID != src_adj_index0)
1218                 {
1219                   ip_adjacency_t * adj0 = ip_get_adjacency (&im->lookup_main,
1220                                                             src_adj_index0);
1221
1222                   error0 = (adj0->rewrite_header.sw_if_index != sw_if_index0
1223                             ? ICMP6_ERROR_ROUTER_SOLICITATION_SOURCE_NOT_ON_LINK
1224                             : error0);
1225                 }
1226               else
1227                 {
1228                   error0 = ICMP6_ERROR_ROUTER_SOLICITATION_SOURCE_NOT_ON_LINK;
1229                 }
1230           }
1231
1232           /* check for source LL option and process */
1233           o0 = (void *) (h0 + 1);
1234           o0 = ((options_len0 == 8
1235                  && o0->header.type == option_type
1236                  && o0->header.n_data_u64s == 1)
1237                 ? o0
1238                 : 0);
1239
1240           /* if src address unspecified IGNORE any options */
1241           if (PREDICT_TRUE (error0 == ICMP6_ERROR_NONE && o0 != 0 &&
1242                             !is_unspecified && !is_link_local)) {
1243               ip6_neighbor_main_t * nm = &ip6_neighbor_main;
1244               if (nm->limit_neighbor_cache_size &&
1245                   pool_elts (nm->neighbor_pool) >= nm->limit_neighbor_cache_size)
1246                       unset_random_neighbor_entry();
1247
1248               vnet_set_ip6_ethernet_neighbor (vm, sw_if_index0,
1249                                               &ip0->src_address,
1250                                               o0->ethernet_address,
1251                                               sizeof (o0->ethernet_address), 0);
1252           }
1253
1254           /* default is to drop */
1255           next0 = ICMP6_ROUTER_SOLICITATION_NEXT_DROP;
1256
1257           if (error0 == ICMP6_ERROR_NONE)
1258             {
1259               vnet_sw_interface_t * sw_if0;
1260               ethernet_interface_t * eth_if0;
1261               u32 adj_index0;
1262
1263               sw_if0 = vnet_get_sup_sw_interface (vnm, sw_if_index0);
1264               ASSERT (sw_if0->type == VNET_SW_INTERFACE_TYPE_HARDWARE);
1265               eth_if0 = ethernet_get_interface (&ethernet_main, sw_if0->hw_if_index);
1266
1267               /* only support ethernet interface type for now */
1268               error0 = (!eth_if0) ?  ICMP6_ERROR_ROUTER_SOLICITATION_UNSUPPORTED_INTF : error0;
1269
1270               if (error0 == ICMP6_ERROR_NONE)
1271                 {
1272                   u32 ri;
1273
1274                   /* adjust the sizeof the buffer to just include the ipv6 header */
1275                   p0->current_length -= (options_len0 + sizeof(icmp6_neighbor_discovery_header_t));
1276
1277                   /* look up the radv_t information for this interface */
1278                   vec_validate_init_empty (nm->if_radv_pool_index_by_sw_if_index, sw_if_index0, ~0);
1279
1280                   ri = nm->if_radv_pool_index_by_sw_if_index[sw_if_index0];
1281
1282                   if(ri != ~0)
1283                       radv_info = pool_elt_at_index (nm->if_radv_pool, ri);
1284
1285                   error0 = ((!radv_info) ?  ICMP6_ERROR_ROUTER_SOLICITATION_RADV_NOT_CONFIG : error0);
1286
1287                   if (error0 == ICMP6_ERROR_NONE)
1288                     {
1289                       f64 now = vlib_time_now (vm);
1290
1291                       /* for solicited adverts - need to rate limit */
1292                       if(is_solicitation)
1293                         {
1294                           if( (now - radv_info->last_radv_time)  <  MIN_DELAY_BETWEEN_RAS )
1295                               is_dropped = 1;
1296                           else
1297                             radv_info->last_radv_time = now;
1298                         }
1299
1300                       /* send now  */
1301                       icmp6_router_advertisement_header_t rh;
1302
1303                       rh.icmp.type = ICMP6_router_advertisement;
1304                       rh.icmp.code = 0;
1305                       rh.icmp.checksum = 0;
1306
1307                       rh.current_hop_limit = radv_info->curr_hop_limit;
1308                       rh.router_lifetime_in_sec = clib_host_to_net_u16(radv_info->adv_router_lifetime_in_sec);
1309                       rh.time_in_msec_between_retransmitted_neighbor_solicitations =
1310                         clib_host_to_net_u32(radv_info->adv_time_in_msec_between_retransmitted_neighbor_solicitations);
1311                       rh.neighbor_reachable_time_in_msec =
1312                         clib_host_to_net_u32(radv_info->adv_neighbor_reachable_time_in_msec);
1313
1314                       rh.flags = (radv_info->adv_managed_flag) ? ICMP6_ROUTER_DISCOVERY_FLAG_ADDRESS_CONFIG_VIA_DHCP : 0;
1315                       rh.flags |= ( (radv_info->adv_other_flag) ? ICMP6_ROUTER_DISCOVERY_FLAG_OTHER_CONFIG_VIA_DHCP : 0);
1316
1317
1318                       u16 payload_length = sizeof(icmp6_router_advertisement_header_t);
1319
1320                       vlib_buffer_add_data (vm,
1321                                             p0->free_list_index,
1322                                             bi0,
1323                                             (void *)&rh, sizeof(icmp6_router_advertisement_header_t));
1324
1325                       if(radv_info->adv_link_layer_address)
1326                         {
1327                           icmp6_neighbor_discovery_ethernet_link_layer_address_option_t h;
1328
1329                           h.header.type = ICMP6_NEIGHBOR_DISCOVERY_OPTION_source_link_layer_address;
1330                           h.header.n_data_u64s = 1;
1331
1332                           /* copy ll address */
1333                           clib_memcpy(&h.ethernet_address[0], eth_if0->address,  6);
1334
1335                           vlib_buffer_add_data (vm,
1336                                                 p0->free_list_index,
1337                                                 bi0,
1338                                                 (void *)&h, sizeof(icmp6_neighbor_discovery_ethernet_link_layer_address_option_t));
1339
1340                           payload_length += sizeof(icmp6_neighbor_discovery_ethernet_link_layer_address_option_t);
1341                         }
1342
1343                       /* add MTU option */
1344                       if(radv_info->adv_link_mtu)
1345                         {
1346                           icmp6_neighbor_discovery_mtu_option_t h;
1347
1348                           h.unused = 0;
1349                           h.mtu =  clib_host_to_net_u32(radv_info->adv_link_mtu);
1350                           h.header.type = ICMP6_NEIGHBOR_DISCOVERY_OPTION_mtu;
1351                           h.header.n_data_u64s = 1;
1352
1353                           payload_length += sizeof( icmp6_neighbor_discovery_mtu_option_t);
1354
1355                           vlib_buffer_add_data (vm,
1356                                                 p0->free_list_index,
1357                                                 bi0,
1358                                                 (void *)&h, sizeof(icmp6_neighbor_discovery_mtu_option_t));
1359                         }
1360
1361                       /* add advertised prefix options  */
1362                       ip6_radv_prefix_t *pr_info;
1363
1364                       pool_foreach (pr_info, radv_info->adv_prefixes_pool, ({
1365
1366                             if(pr_info->enabled &&
1367                                (!pr_info->decrement_lifetime_flag  || (pr_info->pref_lifetime_expires >0)))
1368                               {
1369                                 /* advertise this prefix */
1370                                 icmp6_neighbor_discovery_prefix_information_option_t h;
1371
1372                                 h.header.type = ICMP6_NEIGHBOR_DISCOVERY_OPTION_prefix_information;
1373                                 h.header.n_data_u64s  =  (sizeof(icmp6_neighbor_discovery_prefix_information_option_t) >> 3);
1374
1375                                 h.dst_address_length  = pr_info->prefix_len;
1376
1377                                 h.flags  = (pr_info->adv_on_link_flag) ? ICMP6_NEIGHBOR_DISCOVERY_PREFIX_INFORMATION_FLAG_ON_LINK : 0;
1378                                 h.flags |= (pr_info->adv_autonomous_flag) ?  ICMP6_NEIGHBOR_DISCOVERY_PREFIX_INFORMATION_AUTO :  0;
1379
1380                                 if(radv_info->cease_radv && pr_info->deprecated_prefix_flag)
1381                                   {
1382                                     h.valid_time = clib_host_to_net_u32(MIN_ADV_VALID_LIFETIME);
1383                                     h.preferred_time  = 0;
1384                                   }
1385                                 else
1386                                   {
1387                                     if(pr_info->decrement_lifetime_flag)
1388                                       {
1389                                         pr_info->adv_valid_lifetime_in_secs = ((pr_info->valid_lifetime_expires  > now)) ?
1390                                           (pr_info->valid_lifetime_expires  - now) : 0;
1391
1392                                         pr_info->adv_pref_lifetime_in_secs = ((pr_info->pref_lifetime_expires  > now)) ?
1393                                           (pr_info->pref_lifetime_expires  - now) : 0;
1394                                       }
1395
1396                                     h.valid_time = clib_host_to_net_u32(pr_info->adv_valid_lifetime_in_secs);
1397                                     h.preferred_time  = clib_host_to_net_u32(pr_info->adv_pref_lifetime_in_secs) ;
1398                                   }
1399                                 h.unused  = 0;
1400
1401                                 clib_memcpy(&h.dst_address, &pr_info->prefix,  sizeof(ip6_address_t));
1402
1403                                 payload_length += sizeof( icmp6_neighbor_discovery_prefix_information_option_t);
1404
1405                                 vlib_buffer_add_data (vm,
1406                                                       p0->free_list_index,
1407                                                       bi0,
1408                                                       (void *)&h, sizeof(icmp6_neighbor_discovery_prefix_information_option_t));
1409
1410                               }
1411                           }));
1412
1413                       /* add additional options before here */
1414
1415                       /* finish building the router advertisement... */
1416                       if(!is_unspecified && radv_info->send_unicast)
1417                         {
1418                           ip0->dst_address = ip0->src_address;
1419                         }
1420                       else
1421                         {
1422                           /* target address is all-nodes mcast addr */
1423                           ip6_set_reserved_multicast_address(&ip0->dst_address,
1424                                                              IP6_MULTICAST_SCOPE_link_local,
1425                                                              IP6_MULTICAST_GROUP_ID_all_hosts);
1426                         }
1427
1428                       /* source address MUST be the link-local address */
1429                       ip0->src_address = radv_info->link_local_address;
1430
1431                       ip0->hop_limit = 255;
1432                       ip0->payload_length = clib_host_to_net_u16 (payload_length);
1433
1434                       icmp6_router_advertisement_header_t * rh0 = (icmp6_router_advertisement_header_t *)(ip0 + 1);
1435                       rh0->icmp.checksum =
1436                           ip6_tcp_udp_icmp_compute_checksum (vm, p0, ip0,
1437                                                              &bogus_length);
1438                       ASSERT(bogus_length == 0);
1439
1440                       /* setup output if and adjacency */
1441                       vnet_buffer (p0)->sw_if_index[VLIB_RX] =
1442                         vnet_main.local_interface_sw_if_index;
1443
1444                       if (is_solicitation)
1445                         {
1446                           ethernet_header_t *eth0;
1447                           /* Reuse current MAC header, copy SMAC to DMAC and
1448                            * interface MAC to SMAC */
1449                           vlib_buffer_reset (p0);
1450                           eth0 = vlib_buffer_get_current(p0);
1451                           clib_memcpy(eth0->dst_address, eth0->src_address, 6);
1452                           clib_memcpy(eth0->src_address, eth_if0->address, 6);
1453                           next0 = is_dropped ?
1454                               next0 : ICMP6_ROUTER_SOLICITATION_NEXT_REPLY_TX;
1455                           vnet_buffer(p0)->sw_if_index[VLIB_TX] = sw_if_index0;
1456                         }
1457                       else
1458                         {
1459                           adj_index0 = radv_info->all_nodes_adj_index;
1460                           if (adj_index0 == 0)
1461                               error0 = ICMP6_ERROR_DST_LOOKUP_MISS;
1462                           else
1463                             {
1464                               ip_adjacency_t * adj0 = ip_get_adjacency (&im->lookup_main, adj_index0);
1465                               error0 =
1466                                   ((adj0->rewrite_header.sw_if_index != sw_if_index0
1467                                     || adj0->lookup_next_index != IP_LOOKUP_NEXT_REWRITE)
1468                                    ? ICMP6_ERROR_ROUTER_SOLICITATION_DEST_UNKNOWN
1469                                    : error0);
1470                               next0 = is_dropped ?
1471                                   next0 : ICMP6_ROUTER_SOLICITATION_NEXT_REPLY_RW;
1472                               vnet_buffer (p0)->ip.adj_index[VLIB_RX] = adj_index0;
1473                            }
1474                         }
1475
1476                       radv_info->n_solicitations_dropped  += is_dropped;
1477                       radv_info->n_solicitations_rcvd  += is_solicitation;
1478
1479                       if((error0 ==  ICMP6_ERROR_NONE) && !is_dropped)
1480                         {
1481                           radv_info->n_advertisements_sent++;
1482                           n_advertisements_sent++;
1483                         }
1484                     }
1485                 }
1486             }
1487
1488           p0->error = error_node->errors[error0];
1489
1490           if(error0 != ICMP6_ERROR_NONE)
1491             vlib_error_count (vm, error_node->node_index, error0, 1);
1492
1493           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
1494                                            to_next, n_left_to_next,
1495                                            bi0, next0);
1496
1497         }
1498
1499       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1500     }
1501
1502   /* Account for router advertisements sent. */
1503   vlib_error_count (vm, error_node->node_index, ICMP6_ERROR_ROUTER_ADVERTISEMENTS_TX, n_advertisements_sent);
1504
1505   return frame->n_vectors;
1506 }
1507
1508  /* validate advertised info for consistancy (see RFC-4861 section 6.2.7) - log any inconsistencies, packet will always  be dropped  */
1509 static_always_inline uword
1510 icmp6_router_advertisement(vlib_main_t * vm,
1511                            vlib_node_runtime_t * node,
1512                            vlib_frame_t * frame)
1513 {
1514   vnet_main_t * vnm = vnet_get_main();
1515   ip6_neighbor_main_t * nm = &ip6_neighbor_main;
1516   uword n_packets = frame->n_vectors;
1517   u32 * from, * to_next;
1518   u32 n_left_from, n_left_to_next, next_index;
1519   u32 n_advertisements_rcvd = 0;
1520
1521   vlib_node_runtime_t * error_node = vlib_node_get_runtime (vm, ip6_icmp_input_node.index);
1522
1523   from = vlib_frame_vector_args (frame);
1524   n_left_from = n_packets;
1525   next_index = node->cached_next_index;
1526
1527   if (node->flags & VLIB_NODE_FLAG_TRACE)
1528     vlib_trace_frame_buffers_only (vm, node, from, frame->n_vectors,
1529                                    /* stride */ 1,
1530                                    sizeof (icmp6_input_trace_t));
1531
1532   while (n_left_from > 0)
1533     {
1534       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
1535
1536       while (n_left_from > 0 && n_left_to_next > 0)
1537         {
1538           vlib_buffer_t * p0;
1539           ip6_header_t * ip0;
1540           ip6_radv_t *radv_info = 0;
1541           icmp6_router_advertisement_header_t * h0;
1542           u32 bi0, options_len0, sw_if_index0, next0, error0;
1543
1544           bi0 = to_next[0] = from[0];
1545
1546           from += 1;
1547           to_next += 1;
1548           n_left_from -= 1;
1549           n_left_to_next -= 1;
1550
1551           p0 = vlib_get_buffer (vm, bi0);
1552           ip0 = vlib_buffer_get_current (p0);
1553           h0 = ip6_next_header (ip0);
1554           options_len0 = clib_net_to_host_u16 (ip0->payload_length) - sizeof (h0[0]);
1555
1556           error0 = ICMP6_ERROR_NONE;
1557           sw_if_index0 = vnet_buffer (p0)->sw_if_index[VLIB_RX];
1558
1559           /* Check that source address is link-local*/
1560           error0 = (!ip6_address_is_link_local_unicast (&ip0->src_address)) ?
1561             ICMP6_ERROR_ROUTER_ADVERTISEMENT_SOURCE_NOT_LINK_LOCAL : error0;
1562
1563           /* default is to drop */
1564           next0 = ICMP6_ROUTER_SOLICITATION_NEXT_DROP;
1565
1566           n_advertisements_rcvd++;
1567
1568           if (error0 == ICMP6_ERROR_NONE)
1569             {
1570               vnet_sw_interface_t * sw_if0;
1571               ethernet_interface_t * eth_if0;
1572
1573               sw_if0 = vnet_get_sup_sw_interface (vnm, sw_if_index0);
1574               ASSERT (sw_if0->type == VNET_SW_INTERFACE_TYPE_HARDWARE);
1575               eth_if0 = ethernet_get_interface (&ethernet_main, sw_if0->hw_if_index);
1576
1577               /* only support ethernet interface type for now */
1578               error0 = (!eth_if0) ?  ICMP6_ERROR_ROUTER_SOLICITATION_UNSUPPORTED_INTF : error0;
1579
1580               if (error0 == ICMP6_ERROR_NONE)
1581                 {
1582                   u32 ri;
1583
1584                   /* look up the radv_t information for this interface */
1585                   vec_validate_init_empty (nm->if_radv_pool_index_by_sw_if_index, sw_if_index0, ~0);
1586
1587                   ri = nm->if_radv_pool_index_by_sw_if_index[sw_if_index0];
1588
1589                   if(ri != ~0)
1590                       radv_info = pool_elt_at_index (nm->if_radv_pool, ri);
1591
1592                   error0 = ((!radv_info) ?  ICMP6_ERROR_ROUTER_SOLICITATION_RADV_NOT_CONFIG : error0);
1593
1594                   if (error0 == ICMP6_ERROR_NONE)
1595                     {
1596                       /* validate advertised information */
1597                       if((h0->current_hop_limit && radv_info->curr_hop_limit) &&
1598                          (h0->current_hop_limit != radv_info->curr_hop_limit))
1599                         {
1600                           ip6_neighbor_syslog(vm,  LOG_WARNING,
1601                                               "our AdvCurHopLimit on %U doesn't agree with %U",
1602                                               format_vnet_sw_if_index_name, vnm, sw_if_index0, format_ip6_address, &ip0->src_address);
1603                         }
1604
1605                       if((h0->flags &  ICMP6_ROUTER_DISCOVERY_FLAG_ADDRESS_CONFIG_VIA_DHCP)  !=
1606                          radv_info->adv_managed_flag)
1607                         {
1608                           ip6_neighbor_syslog(vm,  LOG_WARNING,
1609                                               "our AdvManagedFlag on %U doesn't agree with %U",
1610                                               format_vnet_sw_if_index_name, vnm, sw_if_index0, format_ip6_address, &ip0->src_address);
1611                         }
1612
1613                       if((h0->flags &   ICMP6_ROUTER_DISCOVERY_FLAG_OTHER_CONFIG_VIA_DHCP)   !=
1614                          radv_info->adv_other_flag)
1615                         {
1616                           ip6_neighbor_syslog(vm,  LOG_WARNING,
1617                                               "our AdvOtherConfigFlag on %U doesn't agree with %U",
1618                                               format_vnet_sw_if_index_name, vnm, sw_if_index0, format_ip6_address, &ip0->src_address);
1619                         }
1620
1621                       if((h0->time_in_msec_between_retransmitted_neighbor_solicitations &&
1622                           radv_info->adv_time_in_msec_between_retransmitted_neighbor_solicitations) &&
1623                          (h0->time_in_msec_between_retransmitted_neighbor_solicitations !=
1624                           clib_host_to_net_u32(radv_info->adv_time_in_msec_between_retransmitted_neighbor_solicitations)))
1625                         {
1626                           ip6_neighbor_syslog(vm,  LOG_WARNING,
1627                                               "our AdvRetransTimer on %U doesn't agree with %U",
1628                                               format_vnet_sw_if_index_name, vnm, sw_if_index0, format_ip6_address, &ip0->src_address);
1629                         }
1630
1631                       if((h0->neighbor_reachable_time_in_msec &&
1632                           radv_info->adv_neighbor_reachable_time_in_msec) &&
1633                          (h0->neighbor_reachable_time_in_msec !=
1634                           clib_host_to_net_u32(radv_info->adv_neighbor_reachable_time_in_msec)))
1635                         {
1636                           ip6_neighbor_syslog(vm,  LOG_WARNING,
1637                                               "our AdvReachableTime on %U doesn't agree with %U",
1638                                               format_vnet_sw_if_index_name, vnm, sw_if_index0, format_ip6_address, &ip0->src_address);
1639                         }
1640
1641                       /* check for MTU or prefix options or .. */
1642                       u8 * opt_hdr = (u8 *)(h0 + 1);
1643                       while( options_len0 > 0)
1644                         {
1645                           icmp6_neighbor_discovery_option_header_t *o0 = ( icmp6_neighbor_discovery_option_header_t *)opt_hdr;
1646                           int opt_len = o0->n_data_u64s << 3;
1647                           icmp6_neighbor_discovery_option_type_t option_type = o0->type;
1648
1649                           if(options_len0 < 2)
1650                             {
1651                               ip6_neighbor_syslog(vm,  LOG_ERR,
1652                                                   "malformed RA packet on %U from %U",
1653                                                   format_vnet_sw_if_index_name, vnm, sw_if_index0, format_ip6_address, &ip0->src_address);
1654                               break;
1655                             }
1656
1657                           if(opt_len == 0)
1658                             {
1659                               ip6_neighbor_syslog(vm,  LOG_ERR,
1660                                                   " zero length option in RA on %U from %U",
1661                                                   format_vnet_sw_if_index_name, vnm, sw_if_index0, format_ip6_address, &ip0->src_address);
1662                               break;
1663                             }
1664                           else if( opt_len > options_len0)
1665                             {
1666                               ip6_neighbor_syslog(vm,  LOG_ERR,
1667                                                   "option length in RA packet  greater than total length on %U from %U",
1668                                                   format_vnet_sw_if_index_name, vnm, sw_if_index0, format_ip6_address, &ip0->src_address);
1669                               break;
1670                             }
1671
1672                           options_len0 -= opt_len;
1673                           opt_hdr += opt_len;
1674
1675                           switch(option_type)
1676                             {
1677                             case ICMP6_NEIGHBOR_DISCOVERY_OPTION_mtu:
1678                               {
1679                                 icmp6_neighbor_discovery_mtu_option_t *h =
1680                                   (icmp6_neighbor_discovery_mtu_option_t *)(o0);
1681
1682                                 if(opt_len < sizeof(*h))
1683                                   break;
1684
1685                                 if((h->mtu && radv_info->adv_link_mtu) &&
1686                                    (h->mtu != clib_host_to_net_u32(radv_info->adv_link_mtu)))
1687                                   {
1688                                     ip6_neighbor_syslog(vm,  LOG_WARNING,
1689                                                         "our AdvLinkMTU on %U doesn't agree with %U",
1690                                                         format_vnet_sw_if_index_name, vnm, sw_if_index0, format_ip6_address, &ip0->src_address);
1691                                   }
1692                               }
1693                               break;
1694
1695                             case ICMP6_NEIGHBOR_DISCOVERY_OPTION_prefix_information:
1696                               {
1697                                 icmp6_neighbor_discovery_prefix_information_option_t *h =
1698                                   (icmp6_neighbor_discovery_prefix_information_option_t *)(o0);
1699
1700                                 /* validate advertised prefix options  */
1701                                 ip6_radv_prefix_t *pr_info;
1702                                 u32 preferred, valid;
1703
1704                                 if(opt_len < sizeof(*h))
1705                                   break;
1706
1707                                 preferred =  clib_net_to_host_u32(h->preferred_time);
1708                                 valid =  clib_net_to_host_u32(h->valid_time);
1709
1710                                 /* look for matching prefix - if we our advertising it, it better be consistant */
1711                                 pool_foreach (pr_info, radv_info->adv_prefixes_pool, ({
1712
1713                                       ip6_address_t mask;
1714                                       ip6_address_mask_from_width(&mask, pr_info->prefix_len);
1715
1716                                       if(pr_info->enabled &&
1717                                        (pr_info->prefix_len == h->dst_address_length) &&
1718                                          ip6_address_is_equal_masked (&pr_info->prefix,  &h->dst_address, &mask))
1719                                         {
1720                                           /* found it */
1721                                           if(!pr_info->decrement_lifetime_flag &&
1722                                              valid != pr_info->adv_valid_lifetime_in_secs)
1723                                             {
1724                                               ip6_neighbor_syslog(vm,  LOG_WARNING,
1725                                                                   "our ADV validlifetime on  %U for %U does not  agree with %U",
1726                                                                   format_vnet_sw_if_index_name, vnm, sw_if_index0,format_ip6_address, &pr_info->prefix,
1727                                                                   format_ip6_address, &h->dst_address);
1728                                             }
1729                                           if(!pr_info->decrement_lifetime_flag &&
1730                                              preferred != pr_info->adv_pref_lifetime_in_secs)
1731                                             {
1732                                               ip6_neighbor_syslog(vm,  LOG_WARNING,
1733                                                                   "our ADV preferredlifetime on  %U for %U does not  agree with %U",
1734                                                                   format_vnet_sw_if_index_name, vnm, sw_if_index0,format_ip6_address, &pr_info->prefix,
1735                                                                   format_ip6_address, &h->dst_address);
1736                                             }
1737                                         }
1738                                       break;
1739                                     }));
1740                                 break;
1741                               }
1742                             default:
1743                               /* skip this one */
1744                               break;
1745                             }
1746                         }
1747                     }
1748                 }
1749             }
1750
1751           p0->error = error_node->errors[error0];
1752
1753           if(error0 != ICMP6_ERROR_NONE)
1754             vlib_error_count (vm, error_node->node_index, error0, 1);
1755
1756           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
1757                                            to_next, n_left_to_next,
1758                                            bi0, next0);
1759         }
1760
1761       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1762     }
1763
1764   /* Account for router advertisements sent. */
1765   vlib_error_count (vm, error_node->node_index, ICMP6_ERROR_ROUTER_ADVERTISEMENTS_RX, n_advertisements_rcvd);
1766
1767   return frame->n_vectors;
1768 }
1769
1770 /* create and initialize router advertisement parameters with default values for this intfc */
1771 static u32
1772 ip6_neighbor_sw_interface_add_del (vnet_main_t * vnm,
1773                                    u32 sw_if_index,
1774                                    u32 is_add)
1775 {
1776   ip6_neighbor_main_t * nm = &ip6_neighbor_main;
1777   ip6_radv_t * a= 0;
1778   u32 ri = ~0;
1779   vnet_sw_interface_t * sw_if0;
1780   ethernet_interface_t * eth_if0 = 0;
1781
1782   /* lookup radv container  - ethernet interfaces only */
1783   sw_if0 = vnet_get_sup_sw_interface (vnm, sw_if_index);
1784   if(sw_if0->type == VNET_SW_INTERFACE_TYPE_HARDWARE)
1785     eth_if0 = ethernet_get_interface (&ethernet_main, sw_if0->hw_if_index);
1786
1787   if(!eth_if0)
1788     return ri;
1789
1790   vec_validate_init_empty (nm->if_radv_pool_index_by_sw_if_index, sw_if_index, ~0);
1791   ri = nm->if_radv_pool_index_by_sw_if_index[sw_if_index];
1792
1793   if(ri != ~0)
1794     {
1795       a = pool_elt_at_index (nm->if_radv_pool, ri);
1796
1797       if(!is_add)
1798         {
1799           u32 i, * to_delete = 0;
1800           ip6_radv_prefix_t  *p;
1801           ip6_mldp_group_t *m;
1802
1803           /* remove adjacencies */
1804           adj_unlock(a->all_nodes_adj_index);
1805           adj_unlock(a->all_routers_adj_index);
1806           adj_unlock(a->all_mldv2_routers_adj_index);
1807
1808           /* clean up prefix_pool */
1809           pool_foreach (p, a->adv_prefixes_pool, ({
1810                 vec_add1 (to_delete, p  -  a->adv_prefixes_pool);
1811               }));
1812
1813           for (i = 0; i < vec_len (to_delete); i++)
1814             {
1815               p = pool_elt_at_index (a->adv_prefixes_pool, to_delete[i]);
1816               mhash_unset (&a->address_to_prefix_index, &p->prefix, 0);
1817               pool_put (a->adv_prefixes_pool, p);
1818             }
1819
1820           vec_free (to_delete);
1821           to_delete = 0;
1822
1823           /* clean up mldp group pool */
1824           pool_foreach (m, a->mldp_group_pool, ({
1825                 vec_add1 (to_delete, m  -  a->mldp_group_pool);
1826               }));
1827
1828           for (i = 0; i < vec_len (to_delete); i++)
1829             {
1830               m = pool_elt_at_index (a->mldp_group_pool, to_delete[i]);
1831               mhash_unset (&a->address_to_mldp_index, &m->mcast_address, 0);
1832               pool_put (a->mldp_group_pool, m);
1833             }
1834
1835           vec_free (to_delete);
1836
1837           pool_put (nm->if_radv_pool,  a);
1838           nm->if_radv_pool_index_by_sw_if_index[sw_if_index] = ~0;
1839           ri = ~0;
1840         }
1841     }
1842  else
1843    {
1844      if(is_add)
1845        {
1846          vnet_hw_interface_t * hw_if0;
1847
1848          hw_if0 = vnet_get_sup_hw_interface (vnm, sw_if_index);
1849
1850          pool_get (nm->if_radv_pool, a);
1851
1852          ri = a - nm->if_radv_pool;
1853          nm->if_radv_pool_index_by_sw_if_index[sw_if_index] = ri;
1854
1855          /* initialize default values (most of which are zero) */
1856          memset (a, 0, sizeof (a[0]));
1857
1858          a->sw_if_index = sw_if_index;
1859          a->fib_index = ~0;
1860          a->max_radv_interval = DEF_MAX_RADV_INTERVAL;
1861          a->min_radv_interval =  DEF_MIN_RADV_INTERVAL;
1862          a->curr_hop_limit = DEF_CURR_HOP_LIMIT;
1863          a->adv_router_lifetime_in_sec = DEF_DEF_RTR_LIFETIME;
1864
1865          a->adv_link_layer_address = 1;  /* send ll address source address option */
1866
1867          a->min_delay_between_radv = MIN_DELAY_BETWEEN_RAS;
1868          a->max_delay_between_radv = MAX_DELAY_BETWEEN_RAS;
1869          a->max_rtr_default_lifetime = MAX_DEF_RTR_LIFETIME;
1870          a->seed = (u32) clib_cpu_time_now();
1871          (void) random_u32 (&a->seed);
1872          a->randomizer = clib_cpu_time_now();
1873          (void) random_u64 (&a->randomizer);
1874
1875          a->initial_adverts_count = MAX_INITIAL_RTR_ADVERTISEMENTS ;
1876          a->initial_adverts_sent = a->initial_adverts_count-1;
1877          a->initial_adverts_interval = MAX_INITIAL_RTR_ADVERT_INTERVAL;
1878
1879          /* deafult is to send */
1880          a->send_radv = 1;
1881
1882          /* fill in radv_info for this interface that will be needed later */
1883          a->adv_link_mtu = hw_if0->max_l3_packet_bytes[VLIB_RX];
1884
1885          clib_memcpy (a->link_layer_address, eth_if0->address, 6);
1886
1887          /* fill in default link-local address  (this may be overridden) */
1888          ip6_link_local_address_from_ethernet_address (&a->link_local_address, eth_if0->address);
1889          a->link_local_prefix_len = 64;
1890
1891          mhash_init (&a->address_to_prefix_index, sizeof (uword), sizeof (ip6_address_t));
1892          mhash_init (&a->address_to_mldp_index, sizeof (uword), sizeof (ip6_address_t));
1893
1894          {
1895            u8 link_layer_address[6] =
1896              {0x33, 0x33, 0x00, 0x00, 0x00, IP6_MULTICAST_GROUP_ID_all_hosts};
1897
1898            a->all_nodes_adj_index = adj_rewrite_add_and_lock(FIB_PROTOCOL_IP6,
1899                                                              VNET_LINK_IP6,
1900                                                              sw_if_index,
1901                                                              link_layer_address);
1902          }
1903
1904          {
1905            u8 link_layer_address[6] =
1906              {0x33, 0x33, 0x00, 0x00, 0x00, IP6_MULTICAST_GROUP_ID_all_routers};
1907
1908            a->all_routers_adj_index = adj_rewrite_add_and_lock(FIB_PROTOCOL_IP6,
1909                                                                VNET_LINK_IP6,
1910                                                                sw_if_index,
1911                                                                link_layer_address);
1912          }
1913
1914          {
1915            u8 link_layer_address[6] =
1916              {0x33, 0x33, 0x00, 0x00, 0x00, IP6_MULTICAST_GROUP_ID_mldv2_routers};
1917
1918            a->all_mldv2_routers_adj_index =
1919                adj_rewrite_add_and_lock(FIB_PROTOCOL_IP6,
1920                                         VNET_LINK_IP6,
1921                                         sw_if_index,
1922                                         link_layer_address);
1923          }
1924
1925          /* add multicast groups we will always be reporting  */
1926          ip6_address_t addr;
1927          ip6_mldp_group_t  *mcast_group_info;
1928
1929          ip6_set_reserved_multicast_address (&addr,
1930                                              IP6_MULTICAST_SCOPE_link_local,
1931                                              IP6_MULTICAST_GROUP_ID_all_hosts);
1932
1933          /* lookup  mldp info for this interface */
1934
1935          uword * p = mhash_get (&a->address_to_mldp_index,  &addr);
1936          mcast_group_info = p ? pool_elt_at_index (a->mldp_group_pool, p[0]) : 0;
1937
1938          /* add address */
1939          if(!mcast_group_info)
1940            {
1941              /* add */
1942              u32 mi;
1943              pool_get (a->mldp_group_pool, mcast_group_info);
1944
1945              mi = mcast_group_info - a->mldp_group_pool;
1946              mhash_set (&a->address_to_mldp_index,  &addr,  mi, /* old_value */ 0);
1947
1948              mcast_group_info->type = 4;
1949              mcast_group_info->mcast_source_address_pool = 0;
1950              mcast_group_info->num_sources = 0;
1951              clib_memcpy(&mcast_group_info->mcast_address, &addr, sizeof(ip6_address_t));
1952            }
1953
1954          ip6_set_reserved_multicast_address (&addr,
1955                                              IP6_MULTICAST_SCOPE_link_local,
1956                                              IP6_MULTICAST_GROUP_ID_all_routers);
1957
1958          p = mhash_get (&a->address_to_mldp_index,  &addr);
1959          mcast_group_info = p ? pool_elt_at_index (a->mldp_group_pool, p[0]) : 0;
1960
1961          if(!mcast_group_info)
1962            {
1963              /* add */
1964              u32 mi;
1965              pool_get (a->mldp_group_pool, mcast_group_info);
1966
1967              mi = mcast_group_info - a->mldp_group_pool;
1968              mhash_set (&a->address_to_mldp_index,  &addr,  mi, /* old_value */ 0);
1969
1970              mcast_group_info->type = 4;
1971              mcast_group_info->mcast_source_address_pool = 0;
1972              mcast_group_info->num_sources = 0;
1973              clib_memcpy(&mcast_group_info->mcast_address, &addr, sizeof(ip6_address_t));
1974            }
1975
1976          ip6_set_reserved_multicast_address (&addr,
1977                                              IP6_MULTICAST_SCOPE_link_local,
1978                                              IP6_MULTICAST_GROUP_ID_mldv2_routers);
1979
1980          p = mhash_get (&a->address_to_mldp_index,  &addr);
1981          mcast_group_info = p ? pool_elt_at_index (a->mldp_group_pool, p[0]) : 0;
1982
1983          if(!mcast_group_info)
1984            {
1985              /* add */
1986              u32 mi;
1987              pool_get (a->mldp_group_pool, mcast_group_info);
1988
1989              mi = mcast_group_info - a->mldp_group_pool;
1990              mhash_set (&a->address_to_mldp_index,  &addr,  mi, /* old_value */ 0);
1991
1992              mcast_group_info->type = 4;
1993              mcast_group_info->mcast_source_address_pool = 0;
1994              mcast_group_info->num_sources = 0;
1995              clib_memcpy(&mcast_group_info->mcast_address, &addr, sizeof(ip6_address_t));
1996            }
1997        }
1998    }
1999   return  ri;
2000 }
2001
2002 /* send an mldpv2 report  */
2003 static void
2004 ip6_neighbor_send_mldpv2_report(u32 sw_if_index)
2005 {
2006   vnet_main_t * vnm = vnet_get_main();
2007   vlib_main_t * vm = vnm->vlib_main;
2008   ip6_neighbor_main_t * nm = &ip6_neighbor_main;
2009   vnet_sw_interface_t * sw_if0;
2010   ethernet_interface_t * eth_if0;
2011   u32 ri;
2012   int bogus_length;
2013
2014   ip6_radv_t *radv_info;
2015   u16 payload_length;
2016   vlib_buffer_t * b0;
2017   ip6_header_t * ip0;
2018   u32 * to_next;
2019   vlib_frame_t * f;
2020   u32 bo0;
2021   u32 n_to_alloc = 1;
2022   u32 n_allocated;
2023
2024   icmp6_multicast_listener_report_header_t *rh0;
2025   icmp6_multicast_listener_report_packet_t *rp0;
2026
2027   sw_if0 = vnet_get_sup_sw_interface (vnm, sw_if_index);
2028   ASSERT (sw_if0->type == VNET_SW_INTERFACE_TYPE_HARDWARE);
2029   eth_if0 = ethernet_get_interface (&ethernet_main, sw_if0->hw_if_index);
2030
2031   if (!eth_if0 || !vnet_sw_interface_is_admin_up (vnm, sw_if_index))
2032     return;
2033
2034   /* look up the radv_t  information for this interface */
2035   vec_validate_init_empty (nm->if_radv_pool_index_by_sw_if_index, sw_if_index, ~0);
2036
2037   ri = nm->if_radv_pool_index_by_sw_if_index[sw_if_index];
2038
2039   if(ri == ~0)
2040     return;
2041
2042   /* send report now - build a mldpv2 report packet  */
2043   n_allocated = vlib_buffer_alloc_from_free_list(vm,
2044                                                  &bo0,
2045                                                  n_to_alloc,
2046                                                  VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
2047   if (PREDICT_FALSE(n_allocated == 0))
2048     {
2049       clib_warning ("buffer allocation failure");
2050       return;
2051     }
2052
2053   b0 = vlib_get_buffer (vm, bo0);
2054
2055   /* adjust the sizeof the buffer to just include the ipv6 header */
2056   b0->current_length  = sizeof(icmp6_multicast_listener_report_packet_t);
2057
2058   payload_length = sizeof(icmp6_multicast_listener_report_header_t);
2059
2060   b0->error = ICMP6_ERROR_NONE;
2061
2062   rp0 = vlib_buffer_get_current (b0);
2063   ip0 = (ip6_header_t *)&rp0-> ip;
2064   rh0 = (icmp6_multicast_listener_report_header_t *)&rp0-> report_hdr;
2065
2066   memset (rp0 , 0x0, sizeof (icmp6_multicast_listener_report_packet_t));
2067
2068   ip0->ip_version_traffic_class_and_flow_label = clib_host_to_net_u32 (0x6 << 28);
2069
2070   ip0->protocol = IP_PROTOCOL_IP6_HOP_BY_HOP_OPTIONS;
2071   /* for DEBUG - vnet driver won't seem to emit router alerts */
2072   /* ip0->protocol = IP_PROTOCOL_ICMP6; */
2073   ip0->hop_limit = 1;
2074
2075   rh0->icmp.type = ICMP6_multicast_listener_report_v2;
2076
2077   /* source address MUST be the link-local address */
2078   radv_info = pool_elt_at_index (nm->if_radv_pool,  ri);
2079   ip0->src_address = radv_info->link_local_address;
2080
2081   /* destination is all mldpv2 routers */
2082   ip6_set_reserved_multicast_address(&ip0->dst_address,
2083                                      IP6_MULTICAST_SCOPE_link_local,
2084                                      IP6_MULTICAST_GROUP_ID_mldv2_routers);
2085
2086   /* add reports here */
2087   ip6_mldp_group_t *m;
2088   int num_addr_records = 0;
2089   icmp6_multicast_address_record_t rr;
2090
2091   /* fill in the hop-by-hop extension header (router alert) info */
2092   rh0->ext_hdr.next_hdr = IP_PROTOCOL_ICMP6;
2093   rh0->ext_hdr.n_data_u64s = 0;
2094
2095   rh0->alert.type = IP6_MLDP_ALERT_TYPE;
2096   rh0->alert.len = 2;
2097   rh0->alert.value = 0;
2098
2099   rh0->pad.type = 1;
2100   rh0->pad.len = 0;
2101
2102   rh0->icmp.checksum = 0;
2103
2104   pool_foreach (m, radv_info->mldp_group_pool, ({
2105
2106         rr.type = m->type;
2107         rr.aux_data_len_u32s = 0;
2108         rr.num_sources = clib_host_to_net_u16 (m->num_sources);
2109         clib_memcpy(&rr.mcast_addr, &m->mcast_address, sizeof(ip6_address_t));
2110
2111         num_addr_records++;
2112
2113         vlib_buffer_add_data (vm,
2114                               b0->free_list_index,
2115                               bo0,
2116                               (void *)&rr, sizeof(icmp6_multicast_address_record_t));
2117
2118         payload_length += sizeof( icmp6_multicast_address_record_t);
2119       }));
2120
2121   rh0->rsvd = 0;
2122   rh0->num_addr_records =  clib_host_to_net_u16(num_addr_records);
2123
2124   /* update lengths */
2125   ip0->payload_length = clib_host_to_net_u16 (payload_length);
2126
2127   rh0->icmp.checksum = ip6_tcp_udp_icmp_compute_checksum (vm, b0, ip0,
2128                                                           &bogus_length);
2129   ASSERT(bogus_length == 0);
2130
2131   /*
2132    * OK to override w/ no regard for actual FIB, because
2133    * ip6-rewrite-local only looks at the adjacency.
2134    */
2135   vnet_buffer (b0)->sw_if_index[VLIB_RX] =
2136     vnet_main.local_interface_sw_if_index;
2137
2138   vnet_buffer (b0)->ip.adj_index[VLIB_RX]  =
2139     radv_info->all_mldv2_routers_adj_index;
2140
2141   vlib_node_t * node = vlib_get_node_by_name (vm, (u8 *) "ip6-rewrite-local");
2142
2143   f = vlib_get_frame_to_node (vm, node->index);
2144   to_next = vlib_frame_vector_args (f);
2145   to_next[0] = bo0;
2146   f->n_vectors = 1;
2147
2148   vlib_put_frame_to_node (vm, node->index, f);
2149   return;
2150 }
2151
2152 VLIB_REGISTER_NODE (ip6_icmp_router_solicitation_node,static) = {
2153   .function = icmp6_router_solicitation,
2154   .name = "icmp6-router-solicitation",
2155
2156   .vector_size = sizeof (u32),
2157
2158   .format_trace = format_icmp6_input_trace,
2159
2160   .n_next_nodes = ICMP6_ROUTER_SOLICITATION_N_NEXT,
2161   .next_nodes = {
2162     [ICMP6_ROUTER_SOLICITATION_NEXT_DROP] = "error-drop",
2163     [ICMP6_ROUTER_SOLICITATION_NEXT_REPLY_RW] = "ip6-rewrite-local",
2164     [ICMP6_ROUTER_SOLICITATION_NEXT_REPLY_TX] = "interface-output",
2165   },
2166 };
2167
2168 /* send a RA or update the timer info etc.. */
2169 static uword
2170 ip6_neighbor_process_timer_event (vlib_main_t * vm,
2171                                            vlib_node_runtime_t * node,
2172                                            vlib_frame_t * frame)
2173 {
2174   vnet_main_t * vnm = vnet_get_main();
2175   ip6_neighbor_main_t * nm = &ip6_neighbor_main;
2176   ip6_radv_t *radv_info;
2177   vlib_frame_t * f = 0;
2178   u32 n_this_frame = 0;
2179   u32 n_left_to_next = 0;
2180   u32 * to_next = 0;
2181   u32 bo0;
2182   icmp6_router_solicitation_header_t * h0;
2183   vlib_buffer_t * b0;
2184   f64 now = vlib_time_now (vm);
2185
2186   /* Interface ip6 radv info list */
2187   pool_foreach (radv_info, nm->if_radv_pool, ({
2188
2189         if( !vnet_sw_interface_is_admin_up (vnm, radv_info->sw_if_index))
2190           {
2191             radv_info->initial_adverts_sent = radv_info->initial_adverts_count-1;
2192             radv_info->next_multicast_time = now;
2193             radv_info->last_multicast_time = now;
2194             radv_info->last_radv_time = 0;
2195             radv_info->all_routers_mcast = 0;
2196             continue;
2197           }
2198
2199         /* Make sure that we've joined the all-routers multicast group */
2200         if(!radv_info->all_routers_mcast)
2201           {
2202             /* send MDLP_REPORT_EVENT message */
2203             ip6_neighbor_send_mldpv2_report(radv_info->sw_if_index);
2204             radv_info->all_routers_mcast = 1;
2205           }
2206
2207         /* is it time to send a multicast  RA on this interface? */
2208         if(radv_info->send_radv && (now >=  radv_info->next_multicast_time))
2209           {
2210             u32 n_to_alloc = 1;
2211             u32 n_allocated;
2212
2213             f64 rfn = (radv_info->max_radv_interval - radv_info->min_radv_interval) *
2214               random_f64 (&radv_info->seed) + radv_info->min_radv_interval;
2215
2216             /* multicast send - compute next multicast send time */
2217             if( radv_info->initial_adverts_sent > 0)
2218               {
2219                 radv_info->initial_adverts_sent--;
2220                 if(rfn > radv_info-> initial_adverts_interval)
2221                   rfn =  radv_info-> initial_adverts_interval;
2222
2223                 /* check to see if we are ceasing to send */
2224                 if( radv_info->initial_adverts_sent  == 0)
2225                   if(radv_info->cease_radv)
2226                     radv_info->send_radv = 0;
2227               }
2228
2229             radv_info->next_multicast_time =  rfn + now;
2230             radv_info->last_multicast_time = now;
2231
2232             /* send advert now - build a "solicted" router advert with unspecified source address */
2233             n_allocated = vlib_buffer_alloc_from_free_list(vm,
2234                                                            &bo0,
2235                                                            n_to_alloc,
2236                                                            VLIB_BUFFER_DEFAULT_FREE_LIST_INDEX);
2237
2238             if (PREDICT_FALSE(n_allocated == 0))
2239               {
2240                 clib_warning ("buffer allocation failure");
2241                 continue;
2242               }
2243             b0 = vlib_get_buffer (vm, bo0);
2244             b0->current_length = sizeof( icmp6_router_solicitation_header_t);
2245             b0->error = ICMP6_ERROR_NONE;
2246             vnet_buffer (b0)->sw_if_index[VLIB_RX] = radv_info->sw_if_index;
2247
2248             h0 =  vlib_buffer_get_current (b0);
2249
2250             memset (h0, 0, sizeof (icmp6_router_solicitation_header_t));
2251
2252             h0->ip.ip_version_traffic_class_and_flow_label = clib_host_to_net_u32 (0x6 << 28);
2253             h0->ip.payload_length = clib_host_to_net_u16 (sizeof (icmp6_router_solicitation_header_t)
2254                                                           - STRUCT_OFFSET_OF (icmp6_router_solicitation_header_t, neighbor));
2255             h0->ip.protocol = IP_PROTOCOL_ICMP6;
2256             h0->ip.hop_limit = 255;
2257
2258             /* set src/dst address as "unspecified" this marks this packet as internally generated rather than recieved */
2259             h0->ip.src_address.as_u64[0] = 0;
2260             h0->ip.src_address.as_u64[1] = 0;
2261
2262             h0->ip.dst_address.as_u64[0] = 0;
2263             h0->ip.dst_address.as_u64[1] = 0;
2264
2265             h0->neighbor.icmp.type = ICMP6_router_solicitation;
2266
2267             if (PREDICT_FALSE(f == 0))
2268               {
2269                 f = vlib_get_frame_to_node (vm, ip6_icmp_router_solicitation_node.index);
2270                 to_next = vlib_frame_vector_args (f);
2271                 n_left_to_next = VLIB_FRAME_SIZE;
2272                 n_this_frame = 0;
2273               }
2274
2275             n_this_frame++;
2276             n_left_to_next--;
2277             to_next[0] = bo0;
2278             to_next += 1;
2279
2280             if (PREDICT_FALSE(n_left_to_next == 0))
2281               {
2282                 f->n_vectors = n_this_frame;
2283                 vlib_put_frame_to_node (vm, ip6_icmp_router_solicitation_node.index, f);
2284                 f = 0;
2285               }
2286           }
2287       }));
2288
2289   if (f)
2290     {
2291       ASSERT(n_this_frame);
2292       f->n_vectors = n_this_frame;
2293       vlib_put_frame_to_node (vm, ip6_icmp_router_solicitation_node.index, f);
2294     }
2295   return  0;
2296 }
2297
2298 static uword
2299 ip6_icmp_neighbor_discovery_event_process (vlib_main_t * vm,
2300                                            vlib_node_runtime_t * node,
2301                                            vlib_frame_t * frame)
2302 {
2303   uword event_type;
2304   ip6_icmp_neighbor_discovery_event_data_t * event_data;
2305
2306   /* init code here */
2307
2308   while (1)
2309     {
2310       vlib_process_wait_for_event_or_clock (vm,  1. /* seconds */);
2311
2312       event_data = vlib_process_get_event_data (vm,  &event_type);
2313
2314       if(!event_data)
2315         {
2316           /* No events found: timer expired. */
2317           /* process interface list and send RAs as appropriate, update timer info */
2318           ip6_neighbor_process_timer_event (vm,  node,  frame);
2319         }
2320       else
2321         {
2322           switch (event_type) {
2323
2324           case ICMP6_ND_EVENT_INIT:
2325             break;
2326
2327           case ~0:
2328             break;
2329
2330           default:
2331             ASSERT (0);
2332           }
2333
2334           if (event_data)
2335             _vec_len (event_data) = 0;
2336         }
2337     }
2338   return frame->n_vectors;
2339 }
2340
2341 VLIB_REGISTER_NODE (ip6_icmp_router_advertisement_node,static) = {
2342   .function = icmp6_router_advertisement,
2343   .name = "icmp6-router-advertisement",
2344
2345   .vector_size = sizeof (u32),
2346
2347   .format_trace = format_icmp6_input_trace,
2348
2349   .n_next_nodes = 1,
2350   .next_nodes = {
2351     [0] = "error-drop",
2352   },
2353 };
2354
2355 vlib_node_registration_t ip6_icmp_neighbor_discovery_event_node = {
2356
2357   .function = ip6_icmp_neighbor_discovery_event_process,
2358   .name = "ip6-icmp-neighbor-discovery-event-process",
2359   .type = VLIB_NODE_TYPE_PROCESS,
2360 };
2361
2362 static uword
2363 icmp6_neighbor_solicitation (vlib_main_t * vm,
2364                              vlib_node_runtime_t * node,
2365                              vlib_frame_t * frame)
2366 { return icmp6_neighbor_solicitation_or_advertisement (vm, node, frame, /* is_solicitation */ 1); }
2367
2368 static uword
2369 icmp6_neighbor_advertisement (vlib_main_t * vm,
2370                               vlib_node_runtime_t * node,
2371                               vlib_frame_t * frame)
2372 { return icmp6_neighbor_solicitation_or_advertisement (vm, node, frame, /* is_solicitation */ 0); }
2373
2374 VLIB_REGISTER_NODE (ip6_icmp_neighbor_solicitation_node,static) = {
2375   .function = icmp6_neighbor_solicitation,
2376   .name = "icmp6-neighbor-solicitation",
2377
2378   .vector_size = sizeof (u32),
2379
2380   .format_trace = format_icmp6_input_trace,
2381
2382   .n_next_nodes = ICMP6_NEIGHBOR_SOLICITATION_N_NEXT,
2383   .next_nodes = {
2384     [ICMP6_NEIGHBOR_SOLICITATION_NEXT_DROP] = "error-drop",
2385     [ICMP6_NEIGHBOR_SOLICITATION_NEXT_REPLY] = "interface-output",
2386   },
2387 };
2388
2389 VLIB_REGISTER_NODE (ip6_icmp_neighbor_advertisement_node,static) = {
2390   .function = icmp6_neighbor_advertisement,
2391   .name = "icmp6-neighbor-advertisement",
2392
2393   .vector_size = sizeof (u32),
2394
2395   .format_trace = format_icmp6_input_trace,
2396
2397   .n_next_nodes = 1,
2398   .next_nodes = {
2399     [0] = "error-drop",
2400   },
2401 };
2402
2403 /* API  support functions */
2404 int
2405 ip6_neighbor_ra_config(vlib_main_t * vm, u32 sw_if_index,
2406                        u8 suppress, u8 managed, u8 other,
2407                        u8 ll_option,  u8 send_unicast,  u8 cease,
2408                        u8 use_lifetime,  u32 lifetime,
2409                        u32 initial_count,  u32 initial_interval,
2410                        u32 max_interval,  u32 min_interval,
2411                        u8 is_no)
2412 {
2413   ip6_neighbor_main_t * nm = &ip6_neighbor_main;
2414   int  error;
2415   u32 ri;
2416
2417   /* look up the radv_t  information for this interface */
2418   vec_validate_init_empty (nm->if_radv_pool_index_by_sw_if_index, sw_if_index, ~0);
2419   ri = nm->if_radv_pool_index_by_sw_if_index[sw_if_index];
2420   error = (ri != ~0) ? 0 :  VNET_API_ERROR_INVALID_SW_IF_INDEX;
2421
2422   if(!error)
2423     {
2424
2425       ip6_radv_t * radv_info;
2426       radv_info = pool_elt_at_index (nm->if_radv_pool,  ri);
2427
2428       if((max_interval != 0) && (min_interval ==0))
2429         min_interval =  .75 * max_interval;
2430
2431       max_interval  = (max_interval != 0) ? ( (is_no) ?  DEF_MAX_RADV_INTERVAL :  max_interval) :  radv_info->max_radv_interval;
2432       min_interval  = (min_interval != 0) ? ( (is_no) ?  DEF_MIN_RADV_INTERVAL :  min_interval) :  radv_info->min_radv_interval;
2433       lifetime  = (use_lifetime != 0) ? ( (is_no) ?  DEF_DEF_RTR_LIFETIME :  lifetime) :  radv_info->adv_router_lifetime_in_sec;
2434
2435       if(lifetime)
2436         {
2437           if(lifetime  > MAX_DEF_RTR_LIFETIME)
2438             lifetime = MAX_DEF_RTR_LIFETIME;
2439
2440           if(lifetime <= max_interval)
2441             return VNET_API_ERROR_INVALID_VALUE;
2442         }
2443
2444       if(min_interval  != 0)
2445         {
2446           if((min_interval > .75 * max_interval) ||
2447              (min_interval  < 3))
2448             return VNET_API_ERROR_INVALID_VALUE;
2449         }
2450
2451       if((initial_count  > MAX_INITIAL_RTR_ADVERTISEMENTS) ||
2452          (initial_interval  > MAX_INITIAL_RTR_ADVERT_INTERVAL))
2453         return VNET_API_ERROR_INVALID_VALUE;
2454
2455       /*
2456          if "flag" is set and is_no is true then restore default value else set value corresponding to "flag"
2457          if "flag" is clear  don't change corresponding value
2458       */
2459       radv_info->send_radv =  (suppress != 0) ? ( (is_no  != 0) ? 1 : 0 ) : radv_info->send_radv;
2460       radv_info->adv_managed_flag = ( managed  != 0) ? ( (is_no) ? 0 : 1) : radv_info->adv_managed_flag;
2461       radv_info->adv_other_flag  = (other  != 0) ? ( (is_no) ?  0: 1) : radv_info->adv_other_flag;
2462       radv_info->adv_link_layer_address = ( ll_option != 0) ? ( (is_no) ? 1 : 0) : radv_info->adv_link_layer_address;
2463       radv_info->send_unicast  = (send_unicast  != 0) ? ( (is_no) ? 0 : 1) : radv_info->send_unicast;
2464       radv_info->cease_radv = ( cease != 0) ? ( (is_no) ?  0 : 1) : radv_info->cease_radv;
2465
2466       radv_info->min_radv_interval  =  min_interval;
2467       radv_info->max_radv_interval = max_interval;
2468       radv_info->adv_router_lifetime_in_sec = lifetime;
2469
2470       radv_info->initial_adverts_count =
2471         (initial_count  != 0) ? ( (is_no) ?   MAX_INITIAL_RTR_ADVERTISEMENTS  :  initial_count) : radv_info->initial_adverts_count ;
2472       radv_info->initial_adverts_interval =
2473         (initial_interval  != 0) ? ( (is_no) ?  MAX_INITIAL_RTR_ADVERT_INTERVAL  :  initial_interval) : radv_info->initial_adverts_interval;
2474
2475       /* restart */
2476       if((cease != 0) && (is_no))
2477          radv_info-> send_radv = 1;
2478
2479       radv_info->initial_adverts_sent  = radv_info->initial_adverts_count -1;
2480       radv_info->next_multicast_time =  vlib_time_now (vm);
2481       radv_info->last_multicast_time = vlib_time_now (vm);
2482       radv_info->last_radv_time = 0;
2483     }
2484   return(error);
2485 }
2486
2487 int
2488 ip6_neighbor_ra_prefix(vlib_main_t * vm, u32 sw_if_index,
2489                        ip6_address_t *prefix_addr,  u8 prefix_len,
2490                        u8 use_default,  u32 val_lifetime, u32 pref_lifetime,
2491                        u8 no_advertise,  u8 off_link, u8 no_autoconfig, u8 no_onlink,
2492                        u8 is_no)
2493 {
2494   ip6_neighbor_main_t * nm = &ip6_neighbor_main;
2495   int error;
2496
2497   u32 ri;
2498
2499   /* look up the radv_t  information for this interface */
2500   vec_validate_init_empty (nm->if_radv_pool_index_by_sw_if_index, sw_if_index, ~0);
2501
2502   ri = nm->if_radv_pool_index_by_sw_if_index[sw_if_index];
2503
2504   error = (ri != ~0) ? 0 : VNET_API_ERROR_INVALID_SW_IF_INDEX;
2505
2506   if(!error)
2507     {
2508       f64 now = vlib_time_now (vm);
2509       ip6_radv_t * radv_info;
2510       radv_info = pool_elt_at_index (nm->if_radv_pool,  ri);
2511
2512       /* prefix info add, delete or update */
2513       ip6_radv_prefix_t * prefix;
2514
2515       /* lookup  prefix info for this  address on this interface */
2516       uword * p = mhash_get (&radv_info->address_to_prefix_index,  prefix_addr);
2517
2518       prefix = p ? pool_elt_at_index (radv_info->adv_prefixes_pool, p[0]) : 0;
2519
2520       if(is_no)
2521         {
2522           /* delete */
2523           if(!prefix)
2524             return VNET_API_ERROR_INVALID_VALUE; /* invalid prefix */
2525
2526           if(prefix->prefix_len != prefix_len)
2527             return VNET_API_ERROR_INVALID_VALUE_2;
2528
2529           /* FIXME - Should the DP do this or the CP ?*/
2530           /* do specific delete processing here before returning */
2531           /* try to remove from routing table */
2532
2533           mhash_unset (&radv_info->address_to_prefix_index, prefix_addr,/* old_value */ 0);
2534           pool_put (radv_info->adv_prefixes_pool, prefix);
2535
2536           radv_info->initial_adverts_sent  = radv_info->initial_adverts_count -1;
2537           radv_info->next_multicast_time =  vlib_time_now (vm);
2538           radv_info->last_multicast_time = vlib_time_now (vm);
2539           radv_info->last_radv_time = 0;
2540           return(error);
2541         }
2542
2543       /* adding or changing */
2544       if(!prefix)
2545         {
2546           /* add */
2547           u32 pi;
2548           pool_get (radv_info->adv_prefixes_pool, prefix);
2549           pi = prefix - radv_info->adv_prefixes_pool;
2550           mhash_set (&radv_info->address_to_prefix_index,  prefix_addr,  pi, /* old_value */ 0);
2551
2552           memset(prefix, 0x0, sizeof(ip6_radv_prefix_t));
2553
2554           prefix->prefix_len = prefix_len;
2555           clib_memcpy(&prefix->prefix,  prefix_addr, sizeof(ip6_address_t));
2556
2557           /* initialize default values */
2558           prefix->adv_on_link_flag = 1;      /* L bit set */
2559           prefix->adv_autonomous_flag = 1;  /* A bit set */
2560           prefix->adv_valid_lifetime_in_secs =  DEF_ADV_VALID_LIFETIME;
2561           prefix->adv_pref_lifetime_in_secs = DEF_ADV_PREF_LIFETIME;
2562           prefix->enabled = 1;
2563           prefix->decrement_lifetime_flag = 1;
2564           prefix->deprecated_prefix_flag = 1;
2565
2566           if(off_link == 0)
2567             {
2568               /* FIXME - Should the DP do this or the CP ?*/
2569               /* insert prefix into routing table as a connected prefix */
2570             }
2571
2572           if(use_default)
2573             goto restart;
2574         }
2575       else
2576         {
2577
2578           if(prefix->prefix_len != prefix_len)
2579             return VNET_API_ERROR_INVALID_VALUE_2;
2580
2581           if(off_link  != 0)
2582             {
2583               /* FIXME - Should the DP do this or the CP ?*/
2584               /* remove from routing table if already there */
2585             }
2586         }
2587
2588       if((val_lifetime == ~0) || (pref_lifetime == ~0))
2589         {
2590           prefix->adv_valid_lifetime_in_secs =  ~0;
2591           prefix->adv_pref_lifetime_in_secs = ~0;
2592           prefix->decrement_lifetime_flag = 0;
2593         }
2594       else
2595         {
2596           prefix->adv_valid_lifetime_in_secs =  val_lifetime;;
2597           prefix->adv_pref_lifetime_in_secs =  pref_lifetime;
2598         }
2599
2600       /* copy  remaining */
2601       prefix->enabled = !(no_advertise != 0);
2602       prefix->adv_on_link_flag = !((off_link != 0) || (no_onlink != 0));
2603       prefix->adv_autonomous_flag = !(no_autoconfig != 0);
2604
2605  restart:
2606       /* restart */
2607       /* fill in the expiration times  */
2608       prefix->valid_lifetime_expires = now + prefix->adv_valid_lifetime_in_secs;
2609       prefix->pref_lifetime_expires = now + prefix->adv_pref_lifetime_in_secs;
2610
2611       radv_info->initial_adverts_sent  = radv_info->initial_adverts_count -1;
2612       radv_info->next_multicast_time =  vlib_time_now (vm);
2613       radv_info->last_multicast_time = vlib_time_now (vm);
2614       radv_info->last_radv_time = 0;
2615     }
2616   return(error);
2617 }
2618
2619 clib_error_t *
2620 ip6_neighbor_cmd(vlib_main_t * vm, unformat_input_t * main_input, vlib_cli_command_t * cmd)
2621 {
2622   vnet_main_t * vnm = vnet_get_main();
2623   ip6_neighbor_main_t * nm = &ip6_neighbor_main;
2624   clib_error_t * error = 0;
2625   u8 is_no = 0;
2626   u8 suppress = 0,  managed = 0,  other = 0;
2627   u8 suppress_ll_option = 0,  send_unicast = 0,  cease= 0;
2628   u8 use_lifetime = 0;
2629   u32 sw_if_index, ra_lifetime = 0, ra_initial_count = 0, ra_initial_interval = 0;
2630   u32 ra_max_interval = 0 , ra_min_interval = 0;
2631
2632   unformat_input_t _line_input, * line_input = &_line_input;
2633   vnet_sw_interface_t * sw_if0;
2634
2635   int add_radv_info = 1;
2636   __attribute__((unused)) ip6_radv_t * radv_info = 0;
2637   ip6_address_t ip6_addr;
2638   u32 addr_len;
2639
2640
2641   /* Get a line of input. */
2642   if (! unformat_user (main_input, unformat_line_input, line_input))
2643     return 0;
2644
2645   /* get basic radv info for this interface */
2646   if(unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
2647     {
2648
2649       if (unformat_user (line_input,
2650                          unformat_vnet_sw_interface, vnm, &sw_if_index))
2651         {
2652           u32 ri;
2653           ethernet_interface_t * eth_if0 = 0;
2654
2655           sw_if0 = vnet_get_sup_sw_interface (vnm, sw_if_index);
2656           if(sw_if0->type == VNET_SW_INTERFACE_TYPE_HARDWARE)
2657             eth_if0 = ethernet_get_interface (&ethernet_main, sw_if0->hw_if_index);
2658
2659           if(!eth_if0)
2660             {
2661               error = clib_error_return (0, "Interface must be of ethernet type");
2662               goto done;
2663             }
2664
2665           /* look up the radv_t  information for this interface */
2666           vec_validate_init_empty (nm->if_radv_pool_index_by_sw_if_index, sw_if_index, ~0);
2667
2668           ri = nm->if_radv_pool_index_by_sw_if_index[sw_if_index];
2669
2670           if(ri != ~0)
2671             {
2672               radv_info = pool_elt_at_index (nm->if_radv_pool,  ri);
2673             }
2674           else
2675             {
2676               error = clib_error_return (0, "unknown interface %U'",
2677                                          format_unformat_error, line_input);
2678               goto done;
2679             }
2680         }
2681       else
2682         {
2683           error = clib_error_return (0, "invalid interface name %U'",
2684                                      format_unformat_error, line_input);
2685           goto done;
2686         }
2687     }
2688
2689   /* get the rest of the command */
2690   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
2691     {
2692       if (unformat (line_input, "no"))
2693          is_no = 1;
2694       else if(unformat (line_input, "prefix %U/%d",
2695                         unformat_ip6_address, &ip6_addr,
2696                         &addr_len))
2697         {
2698           add_radv_info = 0;
2699           break;
2700         }
2701       else if (unformat (line_input, "ra-managed-config-flag"))
2702         {
2703           managed = 1;
2704           break;
2705         }
2706       else if (unformat (line_input, "ra-other-config-flag"))
2707         {
2708           other = 1;
2709           break;
2710         }
2711       else if (unformat (line_input, "ra-suppress") ||
2712                       unformat (line_input, "ra-surpress"))
2713         {
2714           suppress = 1;
2715           break;
2716         }
2717       else if (unformat (line_input, "ra-suppress-link-layer") ||
2718                       unformat (line_input, "ra-surpress-link-layer"))
2719         {
2720           suppress_ll_option = 1;
2721           break;
2722         }
2723       else if (unformat (line_input, "ra-send-unicast"))
2724         {
2725           send_unicast = 1;
2726           break;
2727         }
2728       else if (unformat (line_input, "ra-lifetime"))
2729         {
2730           if (!unformat (line_input, "%d", &ra_lifetime))
2731             return(error = unformat_parse_error (line_input));
2732           use_lifetime = 1;
2733           break;
2734         }
2735       else if (unformat (line_input, "ra-initial"))
2736         {
2737           if (!unformat (line_input, "%d %d", &ra_initial_count, &ra_initial_interval))
2738             return(error = unformat_parse_error (line_input));
2739           break;
2740         }
2741       else if (unformat (line_input, "ra-interval"))
2742         {
2743           if (!unformat (line_input, "%d", &ra_max_interval))
2744             return(error = unformat_parse_error (line_input));
2745
2746           if (!unformat (line_input, "%d", &ra_min_interval))
2747             ra_min_interval = 0;
2748           break;
2749         }
2750       else if(unformat (line_input, "ra-cease"))
2751         {
2752           cease = 1;
2753           break;
2754         }
2755       else
2756         return(unformat_parse_error (line_input));
2757     }
2758
2759   if(add_radv_info)
2760     {
2761       ip6_neighbor_ra_config(vm,  sw_if_index,
2762                              suppress, managed, other,
2763                              suppress_ll_option,  send_unicast,  cease,
2764                              use_lifetime,  ra_lifetime,
2765                              ra_initial_count,  ra_initial_interval,
2766                              ra_max_interval,  ra_min_interval,
2767                              is_no);
2768     }
2769   else
2770     {
2771       u32 valid_lifetime_in_secs =  0;
2772       u32 pref_lifetime_in_secs = 0;
2773       u8 use_prefix_default_values = 0;
2774       u8  no_advertise = 0;
2775       u8 off_link= 0;
2776       u8 no_autoconfig = 0;
2777       u8 no_onlink= 0;
2778
2779       /* get the rest of the command */
2780       while(unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
2781         {
2782           if(unformat (line_input, "default"))
2783             {
2784               use_prefix_default_values = 1;
2785               break;
2786             }
2787           else if(unformat (line_input, "infinite"))
2788             {
2789               valid_lifetime_in_secs =  ~0;
2790               pref_lifetime_in_secs = ~0;
2791               break;
2792             }
2793           else if(unformat (line_input, "%d %d", &valid_lifetime_in_secs,
2794                             &pref_lifetime_in_secs))
2795             break;
2796           else
2797             break;
2798         }
2799
2800
2801       /* get the rest of the command */
2802       while (!use_prefix_default_values &&
2803              unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
2804         {
2805           if(unformat (line_input, "no-advertise"))
2806             no_advertise = 1;
2807           else if(unformat (line_input, "off-link"))
2808             off_link = 1;
2809           else if(unformat (line_input, "no-autoconfig"))
2810             no_autoconfig = 1;
2811           else if(unformat (line_input, "no-onlink"))
2812             no_onlink = 1;
2813           else
2814             return(unformat_parse_error (line_input));
2815         }
2816
2817       ip6_neighbor_ra_prefix(vm, sw_if_index,
2818                              &ip6_addr,  addr_len,
2819                              use_prefix_default_values,
2820                              valid_lifetime_in_secs,
2821                              pref_lifetime_in_secs,
2822                              no_advertise,
2823                              off_link,
2824                              no_autoconfig,
2825                              no_onlink,
2826                              is_no);
2827     }
2828
2829   unformat_free (line_input);
2830
2831  done:
2832   return error;
2833 }
2834
2835 static void
2836 ip6_print_addrs(vlib_main_t * vm,
2837                 u32 *addrs)
2838 {
2839   ip_lookup_main_t * lm = &ip6_main.lookup_main;
2840   u32 i;
2841
2842   for (i = 0; i < vec_len (addrs); i++)
2843     {
2844       ip_interface_address_t * a = pool_elt_at_index(lm->if_address_pool, addrs[i]);
2845       ip6_address_t * address = ip_interface_address_get_address (lm, a);
2846
2847       vlib_cli_output (vm, "\t\t%U/%d",
2848                        format_ip6_address, address,
2849                        a->address_length);
2850     }
2851 }
2852
2853 static clib_error_t *
2854 show_ip6_interface_cmd (vlib_main_t * vm,
2855                     unformat_input_t * input,
2856                     vlib_cli_command_t * cmd)
2857 {
2858   vnet_main_t * vnm = vnet_get_main();
2859   ip6_neighbor_main_t * nm = &ip6_neighbor_main;
2860   clib_error_t * error = 0;
2861   u32 sw_if_index;
2862
2863   sw_if_index = ~0;
2864
2865  if (unformat_user (input,
2866                       unformat_vnet_sw_interface, vnm, &sw_if_index))
2867     {
2868       u32 ri;
2869
2870       /* look up the radv_t  information for this interface */
2871       vec_validate_init_empty (nm->if_radv_pool_index_by_sw_if_index, sw_if_index, ~0);
2872
2873       ri = nm->if_radv_pool_index_by_sw_if_index[sw_if_index];
2874
2875       if(ri != ~0)
2876         {
2877           ip_lookup_main_t * lm = &ip6_main.lookup_main;
2878           ip6_radv_t * radv_info;
2879           radv_info = pool_elt_at_index (nm->if_radv_pool,  ri);
2880
2881           vlib_cli_output (vm, "%U is admin %s\n", format_vnet_sw_interface_name, vnm,
2882                            vnet_get_sw_interface (vnm, sw_if_index),
2883                            (vnet_sw_interface_is_admin_up (vnm, sw_if_index) ? "up" : "down"));
2884
2885           u32 ai;
2886           u32 *link_scope = 0, *global_scope = 0;
2887           u32 *local_scope = 0, *unknown_scope = 0;
2888           ip_interface_address_t * a;
2889
2890           vec_validate_init_empty (lm->if_address_pool_index_by_sw_if_index, sw_if_index, ~0);
2891           ai = lm->if_address_pool_index_by_sw_if_index[sw_if_index];
2892
2893           while (ai != (u32)~0)
2894             {
2895               a = pool_elt_at_index(lm->if_address_pool, ai);
2896               ip6_address_t * address = ip_interface_address_get_address (lm, a);
2897
2898               if (ip6_address_is_link_local_unicast (address))
2899                 vec_add1 (link_scope, ai);
2900               else if(ip6_address_is_global_unicast (address))
2901                 vec_add1 (global_scope, ai);
2902               else if(ip6_address_is_local_unicast (address))
2903                 vec_add1 (local_scope, ai);
2904               else
2905                 vec_add1 (unknown_scope, ai);
2906
2907               ai = a->next_this_sw_interface;
2908             }
2909
2910           if (vec_len (link_scope))
2911             {
2912               vlib_cli_output (vm, "\tLink-local address(es):\n");
2913               ip6_print_addrs (vm, link_scope);
2914               vec_free (link_scope);
2915             }
2916
2917           if (vec_len (local_scope))
2918             {
2919               vlib_cli_output (vm, "\tLocal unicast address(es):\n");
2920               ip6_print_addrs (vm, local_scope);
2921               vec_free (local_scope);
2922             }
2923
2924           if (vec_len (global_scope))
2925             {
2926               vlib_cli_output (vm, "\tGlobal unicast address(es):\n");
2927               ip6_print_addrs (vm, global_scope);
2928               vec_free (global_scope);
2929             }
2930
2931           if (vec_len (unknown_scope))
2932             {
2933               vlib_cli_output (vm, "\tOther-scope address(es):\n");
2934               ip6_print_addrs (vm, unknown_scope);
2935               vec_free (unknown_scope);
2936             }
2937
2938           vlib_cli_output (vm, "\tJoined group address(es):\n");
2939           ip6_mldp_group_t *m;
2940           pool_foreach (m, radv_info->mldp_group_pool, ({
2941                 vlib_cli_output (vm, "\t\t%U\n", format_ip6_address, &m->mcast_address);
2942               }));
2943
2944           vlib_cli_output (vm, "\tAdvertised Prefixes:\n");
2945           ip6_radv_prefix_t * p;
2946           pool_foreach (p, radv_info->adv_prefixes_pool, ({
2947                 vlib_cli_output (vm, "\t\tprefix %U,  length %d\n",
2948                                  format_ip6_address, &p->prefix, p->prefix_len);
2949               }));
2950
2951           vlib_cli_output (vm, "\tMTU is %d\n",  radv_info->adv_link_mtu);
2952           vlib_cli_output (vm, "\tICMP error messages are unlimited\n");
2953           vlib_cli_output (vm, "\tICMP redirects are disabled\n");
2954           vlib_cli_output (vm, "\tICMP unreachables are not sent\n");
2955           vlib_cli_output (vm, "\tND DAD is disabled\n");
2956           //vlib_cli_output (vm, "\tND reachable time is %d milliseconds\n",);
2957           vlib_cli_output (vm, "\tND advertised reachable time is %d\n",
2958                            radv_info->adv_neighbor_reachable_time_in_msec);
2959           vlib_cli_output (vm, "\tND advertised retransmit interval is %d (msec)\n",
2960                            radv_info->adv_time_in_msec_between_retransmitted_neighbor_solicitations);
2961
2962           u32 ra_interval = radv_info->max_radv_interval;
2963           u32 ra_interval_min = radv_info->min_radv_interval;
2964           vlib_cli_output (vm, "\tND router advertisements are sent every %d seconds (min interval is %d)\n",
2965                            ra_interval, ra_interval_min);
2966           vlib_cli_output (vm, "\tND router advertisements live for %d seconds\n",
2967                            radv_info->adv_router_lifetime_in_sec);
2968           vlib_cli_output (vm, "\tHosts %s stateless autoconfig for addresses\n",
2969                              (radv_info->adv_managed_flag) ? "use" :" don't use");
2970           vlib_cli_output (vm, "\tND router advertisements sent %d\n",  radv_info->n_advertisements_sent);
2971           vlib_cli_output (vm, "\tND router solicitations received %d\n",  radv_info->n_solicitations_rcvd);
2972           vlib_cli_output (vm, "\tND router solicitations dropped %d\n",  radv_info->n_solicitations_dropped);
2973         }
2974       else
2975         {
2976           error = clib_error_return (0, "IPv6 not enabled on interface",
2977                                      format_unformat_error, input);
2978
2979         }
2980     }
2981   return error;
2982 }
2983
2984 /*?
2985  * This command is used to display various IPv6 attributes on a given
2986  * interface.
2987  *
2988  * @cliexpar
2989  * Example of how to display IPv6 settings:
2990  * @cliexstart{show ip6 interface GigabitEthernet2/0/0}
2991  * GigabitEthernet2/0/0 is admin up
2992  *         Link-local address(es):
2993  *                 fe80::ab8/64
2994  *         Joined group address(es):
2995  *                 ff02::1
2996  *                 ff02::2
2997  *                 ff02::16
2998  *                 ff02::1:ff00:ab8
2999  *         Advertised Prefixes:
3000  *                 prefix fe80::fe:28ff:fe9c:75b3,  length 64
3001  *         MTU is 1500
3002  *         ICMP error messages are unlimited
3003  *         ICMP redirects are disabled
3004  *         ICMP unreachables are not sent
3005  *         ND DAD is disabled
3006  *         ND advertised reachable time is 0
3007  *         ND advertised retransmit interval is 0 (msec)
3008  *         ND router advertisements are sent every 200 seconds (min interval is 150)
3009  *         ND router advertisements live for 600 seconds
3010  *         Hosts use stateless autoconfig for addresses
3011  *         ND router advertisements sent 19336
3012  *         ND router solicitations received 0
3013  *         ND router solicitations dropped 0
3014  * @cliexend
3015  * Example of output if IPv6 is not enabled on the interface:
3016  * @cliexstart{show ip6 interface GigabitEthernet2/0/0}
3017  * show ip6 interface: IPv6 not enabled on interface
3018  * @cliexend
3019 ?*/
3020 /* *INDENT-OFF* */
3021 VLIB_CLI_COMMAND (show_ip6_interface_command, static) = {
3022   .path = "show ip6 interface",
3023   .function = show_ip6_interface_cmd,
3024   .short_help = "show ip6 interface <interface>",
3025 };
3026 /* *INDENT-ON* */
3027
3028 clib_error_t *
3029 disable_ip6_interface(vlib_main_t * vm,
3030                       u32 sw_if_index)
3031 {
3032   clib_error_t * error = 0;
3033   ip6_neighbor_main_t * nm = &ip6_neighbor_main;
3034   u32 ri;
3035
3036   /* look up the radv_t  information for this interface */
3037   vec_validate_init_empty (nm->if_radv_pool_index_by_sw_if_index, sw_if_index, ~0);
3038   ri = nm->if_radv_pool_index_by_sw_if_index[sw_if_index];
3039
3040   /* if not created - do nothing */
3041   if(ri != ~0)
3042     {
3043       vnet_main_t * vnm = vnet_get_main();
3044       ip6_radv_t * radv_info;
3045
3046       radv_info = pool_elt_at_index (nm->if_radv_pool,  ri);
3047
3048       /* check radv_info ref count for other ip6 addresses on this interface */
3049       if(radv_info->ref_count == 0 )
3050         {
3051           /* essentially "disables" ipv6 on this interface */
3052           error = ip6_add_del_interface_address (vm, sw_if_index,
3053                                                  &radv_info->link_local_address,
3054                                                  radv_info->link_local_prefix_len,
3055                                                  1 /* is_del */);
3056
3057           ip6_neighbor_sw_interface_add_del (vnm, sw_if_index,  0/* is_add */);
3058         }
3059     }
3060   return error;
3061 }
3062
3063 int
3064 ip6_interface_enabled(vlib_main_t * vm,
3065                       u32 sw_if_index)
3066 {
3067     ip6_neighbor_main_t * nm = &ip6_neighbor_main;
3068     u32 ri = ~0;
3069
3070     /* look up the radv_t  information for this interface */
3071     vec_validate_init_empty (nm->if_radv_pool_index_by_sw_if_index, sw_if_index, ~0);
3072
3073     ri = nm->if_radv_pool_index_by_sw_if_index[sw_if_index];
3074
3075     return ri != ~0;
3076 }
3077
3078 clib_error_t *
3079 enable_ip6_interface(vlib_main_t * vm,
3080                     u32 sw_if_index)
3081 {
3082   clib_error_t * error = 0;
3083   ip6_neighbor_main_t * nm = &ip6_neighbor_main;
3084   u32 ri;
3085   int is_add = 1;
3086
3087   /* look up the radv_t  information for this interface */
3088   vec_validate_init_empty (nm->if_radv_pool_index_by_sw_if_index, sw_if_index, ~0);
3089
3090   ri = nm->if_radv_pool_index_by_sw_if_index[sw_if_index];
3091
3092   /* if not created yet */
3093   if(ri == ~0)
3094     {
3095       vnet_main_t * vnm = vnet_get_main();
3096       vnet_sw_interface_t * sw_if0;
3097
3098       sw_if0 = vnet_get_sup_sw_interface (vnm, sw_if_index);
3099       if(sw_if0->type == VNET_SW_INTERFACE_TYPE_HARDWARE)
3100         {
3101           ethernet_interface_t * eth_if0;
3102
3103           eth_if0 = ethernet_get_interface (&ethernet_main, sw_if0->hw_if_index);
3104           if(eth_if0)
3105             {
3106               /* create radv_info. for this interface.  This holds all the info needed for router adverts */
3107               ri = ip6_neighbor_sw_interface_add_del (vnm, sw_if_index, is_add);
3108
3109               if(ri != ~0)
3110                 {
3111                   ip6_radv_t * radv_info;
3112                   ip6_address_t link_local_address;
3113
3114                   radv_info = pool_elt_at_index (nm->if_radv_pool,  ri);
3115
3116                   ip6_link_local_address_from_ethernet_mac_address (&link_local_address,
3117                                                                     eth_if0->address);
3118
3119                   sw_if0 = vnet_get_sw_interface (vnm, sw_if_index);
3120                   if(sw_if0->type == VNET_SW_INTERFACE_TYPE_SUB)
3121                     {
3122                       /* make up  an interface id */
3123                       md5_context_t m;
3124                       u8 digest[16];
3125
3126                       link_local_address.as_u64[0] = radv_info->randomizer;
3127
3128                       md5_init (&m);
3129                       md5_add (&m, &link_local_address, 16);
3130                       md5_finish (&m,  digest);
3131
3132                       clib_memcpy(&link_local_address, digest, 16);
3133
3134                       radv_info->randomizer = link_local_address.as_u64[0];
3135
3136                       link_local_address.as_u64[0] = clib_host_to_net_u64 (0xFE80000000000000ULL);
3137                       /* clear u bit */
3138                       link_local_address.as_u8[8] &= 0xfd;
3139                     }
3140
3141                   /* essentially "enables" ipv6 on this interface */
3142                   error = ip6_add_del_interface_address (vm, sw_if_index,
3143                                                          &link_local_address,
3144                                                          128 /* address width */,
3145                                                          0 /* is_del */);
3146
3147                   if(error)
3148                       ip6_neighbor_sw_interface_add_del (vnm, sw_if_index, !is_add);
3149                   else
3150                     {
3151                       radv_info->link_local_address =  link_local_address;
3152                       radv_info->link_local_prefix_len  = 64;
3153                     }
3154                 }
3155             }
3156         }
3157     }
3158   return error;
3159 }
3160
3161 static clib_error_t *
3162 enable_ip6_interface_cmd (vlib_main_t * vm,
3163                     unformat_input_t * input,
3164                     vlib_cli_command_t * cmd)
3165 {
3166   vnet_main_t * vnm = vnet_get_main();
3167   clib_error_t * error = 0;
3168   u32 sw_if_index;
3169
3170   sw_if_index = ~0;
3171
3172  if (unformat_user (input,
3173                       unformat_vnet_sw_interface, vnm, &sw_if_index))
3174     {
3175       enable_ip6_interface(vm, sw_if_index);
3176     }
3177  else
3178    {
3179      error = clib_error_return (0, "unknown interface\n'",
3180                                 format_unformat_error, input);
3181
3182    }
3183   return error;
3184 }
3185
3186 /*?
3187  * This command is used to enable IPv6 on a given interface.
3188  *
3189  * @cliexpar
3190  * Example of how enable IPv6 on a given interface:
3191  * @cliexcmd{enable ip6 interface GigabitEthernet2/0/0}
3192 ?*/
3193 /* *INDENT-OFF* */
3194 VLIB_CLI_COMMAND (enable_ip6_interface_command, static) = {
3195   .path = "enable ip6 interface",
3196   .function = enable_ip6_interface_cmd,
3197   .short_help = "enable ip6 interface <interface>",
3198 };
3199 /* *INDENT-ON* */
3200
3201 static clib_error_t *
3202 disable_ip6_interface_cmd (vlib_main_t * vm,
3203                     unformat_input_t * input,
3204                     vlib_cli_command_t * cmd)
3205 {
3206   vnet_main_t * vnm = vnet_get_main();
3207   clib_error_t * error = 0;
3208   u32 sw_if_index;
3209
3210   sw_if_index = ~0;
3211
3212  if (unformat_user (input,
3213                       unformat_vnet_sw_interface, vnm, &sw_if_index))
3214     {
3215       error = disable_ip6_interface(vm, sw_if_index);
3216     }
3217  else
3218    {
3219      error = clib_error_return (0, "unknown interface\n'",
3220                                 format_unformat_error, input);
3221
3222    }
3223   return error;
3224 }
3225
3226 /*?
3227  * This command is used to disable IPv6 on a given interface.
3228  *
3229  * @cliexpar
3230  * Example of how disable IPv6 on a given interface:
3231  * @cliexcmd{disable ip6 interface GigabitEthernet2/0/0}
3232 ?*/
3233 /* *INDENT-OFF* */
3234 VLIB_CLI_COMMAND (disable_ip6_interface_command, static) = {
3235   .path = "disable ip6 interface",
3236   .function = disable_ip6_interface_cmd,
3237   .short_help = "disable ip6 interface <interface>",
3238 };
3239 /* *INDENT-ON* */
3240
3241 /*?
3242  * This command is used to configure the neighbor discovery
3243  * parameters on a given interface. Use the '<em>show ip6 interface</em>'
3244  * command to display some of the current neighbor discovery parameters
3245  * on a given interface. This command has three formats:
3246  *
3247  *
3248  * <b>Format 1 - Router Advertisement Options:</b> (Only one can be entered in a single command)
3249  *
3250  * '<em><b>ip6 nd <interface> [no] [ra-managed-config-flag] | [ra-other-config-flag] | [ra-suppress] | [ra-suppress-link-layer] | [ra-send-unicast] | [ra-lifetime <lifetime>] | [ra-initial <cnt> <interval>] | [ra-interval <max-interval> [<min-interval>]] | [ra-cease]</b></em>'
3251  *
3252  * Where:
3253  *
3254  * <em>[no] ra-managed-config-flag</em> - Advertises in ICMPv6
3255  * router-advertisement messages to use stateful address
3256  * auto-configuration to obtain address information (sets the M-bit).
3257  * Default is the M-bit is not set and the '<em>no</em>' option
3258  * returns it to this default state.
3259  *
3260  * <em>[no] ra-other-config-flag</em> - Indicates in ICMPv6
3261  * router-advertisement messages that hosts use stateful auto
3262  * configuration to obtain nonaddress related information (sets
3263  * the O-bit). Default is the O-bit is not set and the '<em>no</em>'
3264  * option returns it to this default state.
3265  *
3266  * <em>[no] ra-suppress</em> - Disables sending ICMPv6 router-advertisement
3267  * messages. The '<em>no</em>' option implies to enable sending ICMPv6
3268  * router-advertisement messages.
3269  *
3270  * <em>[no] ra-suppress-link-layer</em> - Indicates not to include the
3271  * optional source link-layer address in the ICMPv6 router-advertisement
3272  * messages. Default is to include the optional source link-layer address
3273  * and the '<em>no</em>' option returns it to this default state.
3274  *
3275  * <em>[no] ra-send-unicast</em> - Use the source address of the
3276  * router-solicitation message if availiable. The default is to use
3277  * multicast address of all nodes, and the '<em>no</em>' option returns
3278  * it to this default state.
3279  *
3280  * <em>[no] ra-lifetime <lifetime></em> - Advertises the lifetime of a
3281  * default router in ICMPv6 router-advertisement messages. The range is
3282  * from 0 to 9000 seconds. '<em><lifetime></em>' must be greater than
3283  * '<em><max-interval></em>'. The default value is 600 seconds and the
3284  * '<em>no</em>' option returns it to this default value.
3285  *
3286  * <em>[no] ra-initial <cnt> <interval></em> - Number of initial ICMPv6
3287  * router-advertisement messages sent and the interval between each
3288  * message. Range for count is 1 - 3 and default is 3. Range for interval
3289  * is 1 to 16 seconds, and default is 16 seconds. The '<em>no</em>' option
3290  * returns both to their default value.
3291  *
3292  * <em>[no] ra-interval <max-interval> [<min-interval>]</em> - Configures the
3293  * interval between sending ICMPv6 router-advertisement messages. The
3294  * range for max-interval is from 4 to 200 seconds. min-interval can not
3295  * be more than 75% of max-interval. If not set, min-interval will be
3296  * set to 75% of max-interval. The range for min-interval is from 3 to
3297  * 150 seconds.  The '<em>no</em>' option returns both to their default
3298  * value.
3299  *
3300  * <em>[no] ra-cease</em> - Cease sending ICMPv6 router-advertisement messages.
3301  * The '<em>no</em>' options implies to start (or restart) sending
3302  * ICMPv6 router-advertisement messages.
3303  *
3304  *
3305  * <b>Format 2 - Prefix Options:</b>
3306  *
3307  * '<em><b>ip6 nd <interface> [no] prefix <ip6-address>/<width> [<valid-lifetime> <pref-lifetime> | infinite] [no-advertise] [off-link] [no-autoconfig] [no-onlink]</b></em>'
3308  *
3309  * Where:
3310  *
3311  * <em>no</em> - All additional flags are ignored and the prefix is deleted.
3312  *
3313  * <em><valid-lifetime> <pref-lifetime></em> - '<em><valid-lifetime></em>' is the
3314  * length of time in seconds during what the prefix is valid for the purpose of
3315  * on-link determination. Range is 7203 to 2592000 seconds and default is 2592000
3316  * seconds (30 days). '<em><pref-lifetime></em>' is the prefered-lifetime and is the
3317  * length of time in seconds during what addresses generated from the prefix remain
3318  * preferred. Range is 0 to 604800 seconds and default is 604800 seconds (7 days).
3319  *
3320  * <em>infinite</em> - Both '<em><valid-lifetime></em>' and '<em><<pref-lifetime></em>'
3321  * are inifinte, no timeout.
3322  *
3323  * <em>no-advertise</em> - Do not send full router address in prefix
3324  * advertisement. Default is to advertise (i.e. - This flag is off by default).
3325  *
3326  * <em>off-link</em> - Prefix is off-link, clear L-bit in packet. Default is on-link
3327  * (i.e. - This flag is off and L-bit in packet is set by default and this prefix can
3328  * be used for on-link determination). '<em>no-onlink</em>' also controls the L-bit.
3329  *
3330  * <em>no-autoconfig</em> - Do not use prefix for autoconfiguration, clear A-bit in packet.
3331  * Default is autoconfig (i.e. - This flag is off and A-bit in packet is set by default.
3332  *
3333  * <em>no-onlink</em> - Do not use prefix for onlink determination, clear L-bit in packet.
3334  * Default is on-link (i.e. - This flag is off and L-bit in packet is set by default and
3335  * this prefix can be used for on-link determination). '<em>off-link</em>' also controls
3336  * the L-bit.
3337  *
3338  *
3339  * <b>Format 3: - Default of Prefix:</b>
3340  *
3341  * '<em><b>ip6 nd <interface> [no] prefix <ip6-address>/<width> default</b></em>'
3342  *
3343  * When a new prefix is added (or existing one is being overwritten) <em>default</em>
3344  * uses default values for the prefix. If <em>no</em> is used, the <em>default</em>
3345  * is ignored and the prefix is deleted.
3346  *
3347  *
3348  * @cliexpar
3349  * Example of how set a router advertisement option:
3350  * @cliexcmd{ip6 nd GigabitEthernet2/0/0 ra-interval 100 20}
3351  * Example of how to add a prefix:
3352  * @cliexcmd{ip6 nd GigabitEthernet2/0/0 prefix fe80::fe:28ff:fe9c:75b3/64 infinite no-advertise}
3353  * Example of how to delete a prefix:
3354  * @cliexcmd{ip6 nd GigabitEthernet2/0/0 no prefix fe80::fe:28ff:fe9c:75b3/64}
3355 ?*/
3356 /* *INDENT-OFF* */
3357 VLIB_CLI_COMMAND (ip6_nd_command, static) = {
3358   .path = "ip6 nd",
3359   .short_help = "ip6 nd <interface> ...",
3360   .function = ip6_neighbor_cmd,
3361 };
3362 /* *INDENT-ON* */
3363
3364 clib_error_t *
3365 set_ip6_link_local_address(vlib_main_t * vm,
3366                            u32 sw_if_index,
3367                            ip6_address_t *address,
3368                            u8 address_length)
3369 {
3370   clib_error_t * error = 0;
3371   ip6_neighbor_main_t * nm = &ip6_neighbor_main;
3372   u32 ri;
3373   ip6_radv_t * radv_info;
3374   vnet_main_t * vnm = vnet_get_main();
3375
3376   if( !ip6_address_is_link_local_unicast (address))
3377     {
3378       vnm->api_errno = VNET_API_ERROR_ADDRESS_NOT_LINK_LOCAL;
3379       return(error = clib_error_return (0, "address not link-local",
3380                                         format_unformat_error));
3381     }
3382
3383   /* call enable ipv6  */
3384   enable_ip6_interface(vm, sw_if_index);
3385
3386   ri = nm->if_radv_pool_index_by_sw_if_index[sw_if_index];
3387
3388   if(ri != ~0)
3389     {
3390       radv_info = pool_elt_at_index (nm->if_radv_pool,  ri);
3391
3392       /* save if link local address (overwrite default) */
3393
3394       /* delete the old one */
3395       error = ip6_add_del_interface_address (vm, sw_if_index,
3396                                              &radv_info->link_local_address,
3397                                              radv_info->link_local_prefix_len  /* address width */,
3398                                              1 /* is_del */);
3399
3400       if(!error)
3401         {
3402           /* add the new one */
3403           error = ip6_add_del_interface_address (vm, sw_if_index,
3404                                                  address ,
3405                                                  address_length  /* address width */,
3406                                                  0/* is_del */);
3407
3408           if(!error)
3409             {
3410               radv_info->link_local_address = *address;
3411               radv_info->link_local_prefix_len  = address_length;
3412             }
3413         }
3414     }
3415   else
3416     {
3417       vnm->api_errno = VNET_API_ERROR_IP6_NOT_ENABLED;
3418       error = clib_error_return (0, "ip6 not enabled for interface",
3419                                  format_unformat_error);
3420     }
3421   return error;
3422 }
3423
3424 clib_error_t *
3425 set_ip6_link_local_address_cmd (vlib_main_t * vm,
3426                                 unformat_input_t * input,
3427                                 vlib_cli_command_t * cmd)
3428 {
3429   vnet_main_t * vnm = vnet_get_main();
3430   clib_error_t * error = 0;
3431   u32 sw_if_index;
3432   ip6_address_t ip6_addr;
3433   u32 addr_len = 0;
3434
3435   if (unformat_user (input,
3436                      unformat_vnet_sw_interface, vnm, &sw_if_index))
3437     {
3438       /* get the rest of the command */
3439       while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
3440         {
3441           if(unformat (input, "%U/%d",
3442                        unformat_ip6_address, &ip6_addr,
3443                        &addr_len))
3444             break;
3445           else
3446             return(unformat_parse_error (input));
3447         }
3448     }
3449   error = set_ip6_link_local_address(vm,
3450                                      sw_if_index,
3451                                      &ip6_addr,
3452                                      addr_len);
3453   return error;
3454 }
3455
3456 /*?
3457  * This command is used to assign an IPv6 Link-local address to an
3458  * interface. This command will enable IPv6 on an interface if it
3459  * is not already enabled. Use the '<em>show ip6 interface</em>' command
3460  * to display the assigned Link-local address.
3461  *
3462  * @cliexpar
3463  * Example of how to assign an IPv6 Link-local address to an interface:
3464  * @cliexcmd{set ip6 link-local address GigabitEthernet2/0/0 FE80::AB8/64}
3465 ?*/
3466 /* *INDENT-OFF* */
3467 VLIB_CLI_COMMAND (set_ip6_link_local_address_command, static) = {
3468   .path = "set ip6 link-local address",
3469   .short_help = "set ip6 link-local address <interface> <ip6-address>/<width>",
3470   .function = set_ip6_link_local_address_cmd,
3471 };
3472 /* *INDENT-ON* */
3473
3474 /* callback when an interface address is added or deleted */
3475 static void
3476 ip6_neighbor_add_del_interface_address (ip6_main_t * im,
3477                                         uword opaque,
3478                                         u32 sw_if_index,
3479                                         ip6_address_t * address,
3480                                         u32 address_length,
3481                                         u32 if_address_index,
3482                                         u32 is_delete)
3483 {
3484   vnet_main_t * vnm = vnet_get_main();
3485   ip6_neighbor_main_t * nm = &ip6_neighbor_main;
3486   u32 ri;
3487   vlib_main_t * vm = vnm->vlib_main;
3488   ip6_radv_t * radv_info;
3489   ip6_address_t a;
3490   ip6_mldp_group_t  *mcast_group_info;
3491
3492   /* create solicited node multicast address for this interface adddress */
3493   ip6_set_solicited_node_multicast_address (&a, 0);
3494
3495   a.as_u8[0xd] = address->as_u8[0xd];
3496   a.as_u8[0xe] = address->as_u8[0xe];
3497   a.as_u8[0xf] = address->as_u8[0xf];
3498
3499   if(!is_delete)
3500     {
3501       /* try to  create radv_info - does nothing if ipv6 already enabled */
3502       enable_ip6_interface(vm, sw_if_index);
3503
3504       /* look up the radv_t  information for this interface */
3505       vec_validate_init_empty (nm->if_radv_pool_index_by_sw_if_index, sw_if_index, ~0);
3506       ri = nm->if_radv_pool_index_by_sw_if_index[sw_if_index];
3507       if(ri != ~0)
3508         {
3509           /* get radv_info */
3510           radv_info = pool_elt_at_index (nm->if_radv_pool, ri);
3511
3512           /* add address */
3513           if( !ip6_address_is_link_local_unicast (address))
3514             radv_info->ref_count++;
3515
3516           /* lookup  prefix info for this  address on this interface */
3517           uword * p = mhash_get (&radv_info->address_to_mldp_index,  &a);
3518           mcast_group_info = p ? pool_elt_at_index (radv_info->mldp_group_pool, p[0]) : 0;
3519
3520           /* add -solicted node multicast address  */
3521           if(!mcast_group_info)
3522             {
3523               /* add */
3524               u32 mi;
3525               pool_get (radv_info->mldp_group_pool, mcast_group_info);
3526
3527               mi = mcast_group_info - radv_info->mldp_group_pool;
3528               mhash_set (&radv_info->address_to_mldp_index,  &a,  mi, /* old_value */ 0);
3529
3530               mcast_group_info->type = 4;
3531               mcast_group_info->mcast_source_address_pool = 0;
3532               mcast_group_info->num_sources = 0;
3533               clib_memcpy(&mcast_group_info->mcast_address, &a, sizeof(ip6_address_t));
3534             }
3535         }
3536     }
3537   else
3538     {
3539
3540       /* delete */
3541       /* look up the radv_t  information for this interface */
3542       vec_validate_init_empty (nm->if_radv_pool_index_by_sw_if_index, sw_if_index, ~0);
3543       ri = nm->if_radv_pool_index_by_sw_if_index[sw_if_index];
3544       if(ri != ~0)
3545         {
3546           /* get radv_info */
3547           radv_info = pool_elt_at_index (nm->if_radv_pool, ri);
3548
3549           /* lookup  prefix info for this  address on this interface */
3550           uword * p = mhash_get (&radv_info->address_to_mldp_index,  &a);
3551           mcast_group_info = p ? pool_elt_at_index (radv_info->mldp_group_pool, p[0]) : 0;
3552
3553           if(mcast_group_info)
3554             {
3555               mhash_unset (&radv_info->address_to_mldp_index, &a,/* old_value */ 0);
3556               pool_put (radv_info->mldp_group_pool, mcast_group_info);
3557             }
3558
3559           /* if interface up send MLDP "report" */
3560           radv_info->all_routers_mcast = 0;
3561
3562           /* add address */
3563           if( !ip6_address_is_link_local_unicast (address))
3564             radv_info->ref_count--;
3565         }
3566     }
3567 }
3568
3569 clib_error_t *ip6_set_neighbor_limit (u32 neighbor_limit)
3570 {
3571   ip6_neighbor_main_t * nm = &ip6_neighbor_main;
3572
3573   nm->limit_neighbor_cache_size = neighbor_limit;
3574   return 0;
3575 }
3576
3577 static clib_error_t * ip6_neighbor_init (vlib_main_t * vm)
3578 {
3579   ip6_neighbor_main_t * nm = &ip6_neighbor_main;
3580   ip6_main_t * im = &ip6_main;
3581
3582   mhash_init (&nm->neighbor_index_by_key,
3583               /* value size */ sizeof (uword),
3584               /* key size */ sizeof (ip6_neighbor_key_t));
3585
3586   icmp6_register_type (vm, ICMP6_neighbor_solicitation, ip6_icmp_neighbor_solicitation_node.index);
3587   icmp6_register_type (vm, ICMP6_neighbor_advertisement, ip6_icmp_neighbor_advertisement_node.index);
3588   icmp6_register_type (vm, ICMP6_router_solicitation, ip6_icmp_router_solicitation_node.index);
3589   icmp6_register_type (vm, ICMP6_router_advertisement, ip6_icmp_router_advertisement_node.index);
3590
3591   /* handler node for ip6 neighbor discovery events and timers */
3592   vlib_register_node (vm, &ip6_icmp_neighbor_discovery_event_node);
3593
3594   /* add call backs */
3595   ip6_add_del_interface_address_callback_t cb;
3596   memset(&cb, 0x0, sizeof(ip6_add_del_interface_address_callback_t));
3597
3598   /* when an interface address changes... */
3599   cb.function = ip6_neighbor_add_del_interface_address;
3600   cb.function_opaque = 0;
3601   vec_add1 (im->add_del_interface_address_callbacks, cb);
3602
3603   mhash_init (&nm->pending_resolutions_by_address,
3604               /* value size */ sizeof (uword),
3605               /* key size */ sizeof (ip6_address_t));
3606
3607   mhash_init (&nm->mac_changes_by_address,
3608               /* value size */ sizeof (uword),
3609               /* key size */ sizeof (ip6_address_t));
3610
3611   /* default, configurable */
3612   nm->limit_neighbor_cache_size = 50000;
3613
3614 #if 0
3615   /* $$$$ Hack fix for today */
3616   vec_validate_init_empty
3617       (im->discover_neighbor_next_index_by_hw_if_index, 32, 0 /* drop */);
3618 #endif
3619
3620   return 0;
3621 }
3622
3623 VLIB_INIT_FUNCTION (ip6_neighbor_init);
3624
3625
3626 void vnet_register_ip6_neighbor_resolution_event (vnet_main_t * vnm,
3627                                                   void * address_arg,
3628                                                   uword node_index,
3629                                                   uword type_opaque,
3630                                                   uword data)
3631 {
3632   ip6_neighbor_main_t * nm = &ip6_neighbor_main;
3633   ip6_address_t * address = address_arg;
3634   uword * p;
3635   pending_resolution_t * pr;
3636
3637   pool_get (nm->pending_resolutions, pr);
3638
3639   pr->next_index = ~0;
3640   pr->node_index = node_index;
3641   pr->type_opaque = type_opaque;
3642   pr->data = data;
3643
3644   p = mhash_get (&nm->pending_resolutions_by_address, address);
3645   if (p)
3646     {
3647       /* Insert new resolution at the head of the list */
3648       pr->next_index = p[0];
3649       mhash_unset (&nm->pending_resolutions_by_address, address, 0);
3650     }
3651
3652   mhash_set (&nm->pending_resolutions_by_address, address,
3653              pr - nm->pending_resolutions, 0 /* old value */);
3654 }
3655
3656 int vnet_add_del_ip6_nd_change_event (vnet_main_t * vnm,
3657                                       void * data_callback,
3658                                       u32 pid,
3659                                       void * address_arg,
3660                                       uword node_index,
3661                                       uword type_opaque,
3662                                       uword data,
3663                                       int is_add)
3664 {
3665   ip6_neighbor_main_t * nm = &ip6_neighbor_main;
3666   ip6_address_t * address = address_arg;
3667   uword * p;
3668   pending_resolution_t * mc;
3669   void (*fp)(u32, u8 *) = data_callback;
3670
3671   if (is_add)
3672     {
3673       pool_get (nm->mac_changes, mc);
3674
3675       mc->next_index = ~0;
3676       mc->node_index = node_index;
3677       mc->type_opaque = type_opaque;
3678       mc->data = data;
3679       mc->data_callback = data_callback;
3680       mc->pid = pid;
3681
3682       p = mhash_get (&nm->mac_changes_by_address, address);
3683       if (p)
3684         {
3685           /* Insert new resolution at the head of the list */
3686           mc->next_index = p[0];
3687           mhash_unset (&nm->mac_changes_by_address, address, 0);
3688         }
3689
3690       mhash_set (&nm->mac_changes_by_address, address,
3691                  mc - nm->mac_changes, 0);
3692       return 0;
3693     }
3694   else
3695     {
3696       u32 index;
3697       pending_resolution_t * mc_last = 0;
3698
3699       p = mhash_get (&nm->mac_changes_by_address, address);
3700       if (p == 0)
3701         return VNET_API_ERROR_NO_SUCH_ENTRY;
3702
3703       index = p[0];
3704
3705       while (index != (u32)~0)
3706         {
3707           mc = pool_elt_at_index (nm->mac_changes, index);
3708           if (mc->node_index == node_index &&
3709               mc->type_opaque == type_opaque &&
3710               mc->pid == pid)
3711             {
3712               /* Clients may need to clean up pool entries, too */
3713               if (fp)
3714                 (*fp)(mc->data, 0 /* no new mac addrs */);
3715               if (index == p[0])
3716                 {
3717                   mhash_unset (&nm->mac_changes_by_address, address, 0);
3718                   if (mc->next_index != ~0)
3719                     mhash_set (&nm->mac_changes_by_address, address,
3720                                mc->next_index, 0);
3721                   pool_put (nm->mac_changes, mc);
3722                   return 0;
3723                 }
3724               else
3725                 {
3726                   ASSERT(mc_last);
3727                   mc_last->next_index = mc->next_index;
3728                   pool_put (nm->mac_changes, mc);
3729                   return 0;
3730                 }
3731             }
3732           mc_last = mc;
3733           index = mc->next_index;
3734         }
3735
3736       return VNET_API_ERROR_NO_SUCH_ENTRY;
3737     }
3738 }
3739
3740 int vnet_ip6_nd_term (vlib_main_t * vm,
3741                       vlib_node_runtime_t * node,
3742                       vlib_buffer_t * p0,
3743                       ethernet_header_t * eth,
3744                       ip6_header_t * ip,
3745                       u32 sw_if_index,
3746                       u16 bd_index,
3747                       u8 shg)
3748 {
3749   ip6_neighbor_main_t * nm = &ip6_neighbor_main;
3750   icmp6_neighbor_solicitation_or_advertisement_header_t * ndh;
3751   pending_resolution_t * mc;
3752   uword *p;
3753
3754   ndh = ip6_next_header (ip);
3755   if (ndh->icmp.type != ICMP6_neighbor_solicitation &&
3756       ndh->icmp.type != ICMP6_neighbor_advertisement)
3757       return 0;
3758
3759   if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) &&
3760                      (p0->flags & VLIB_BUFFER_IS_TRACED)))
3761     {
3762       u8 *t0 = vlib_add_trace (vm, node, p0,
3763                                sizeof (icmp6_input_trace_t));
3764       clib_memcpy (t0, ip, sizeof (icmp6_input_trace_t));
3765     }
3766
3767   /* Check if anyone want ND events for L2 BDs */
3768   p = mhash_get (&nm->mac_changes_by_address, &ip6a_zero);
3769   if (p && shg == 0 && /* Only SHG 0 interface which is more likely local */
3770       !ip6_address_is_link_local_unicast (&ip->src_address))
3771     {
3772       u32 next_index = p[0];
3773       while (next_index != (u32)~0)
3774         {
3775           int (*fp)(u32, u8 *, u32, ip6_address_t *);
3776           int rv = 1;
3777           mc = pool_elt_at_index (nm->mac_changes, next_index);
3778           fp = mc->data_callback;
3779           /* Call the callback, return 1 to suppress dup events */
3780           if (fp) rv = (*fp)(mc->data,
3781                              eth->src_address,
3782                              sw_if_index,
3783                              &ip->src_address);
3784           /* Signal the resolver process */
3785           if (rv == 0)
3786              vlib_process_signal_event (vm, mc->node_index,
3787                                         mc->type_opaque,
3788                                         mc->data);
3789           next_index = mc->next_index;
3790         }
3791     }
3792
3793   /* Check if MAC entry exsist for solicited target IP */
3794   if (ndh->icmp.type == ICMP6_neighbor_solicitation)
3795     {
3796       icmp6_neighbor_discovery_ethernet_link_layer_address_option_t * opt;
3797       l2_bridge_domain_t *bd_config;
3798       u8 * macp;
3799
3800       opt = (void *) (ndh + 1);
3801       if ((opt->header.type !=
3802            ICMP6_NEIGHBOR_DISCOVERY_OPTION_source_link_layer_address) ||
3803           (opt->header.n_data_u64s != 1))
3804           return 0; /* source link layer address option not present */
3805
3806       bd_config = vec_elt_at_index (l2input_main.bd_configs, bd_index);
3807       macp = (u8 *) hash_get_mem (bd_config->mac_by_ip6, &ndh->target_address);
3808       if (macp)
3809         { /* found ip-mac entry, generate eighbor advertisement response */
3810           int bogus_length;
3811           vlib_node_runtime_t * error_node =
3812               vlib_node_get_runtime (vm, ip6_icmp_input_node.index);
3813           ip->dst_address = ip->src_address;
3814           ip->src_address = ndh->target_address;
3815           ip->hop_limit = 255;
3816           opt->header.type =
3817               ICMP6_NEIGHBOR_DISCOVERY_OPTION_target_link_layer_address;
3818           clib_memcpy (opt->ethernet_address, macp, 6);
3819           ndh->icmp.type = ICMP6_neighbor_advertisement;
3820           ndh->advertisement_flags = clib_host_to_net_u32
3821               (ICMP6_NEIGHBOR_ADVERTISEMENT_FLAG_SOLICITED |
3822                ICMP6_NEIGHBOR_ADVERTISEMENT_FLAG_OVERRIDE);
3823           ndh->icmp.checksum = 0;
3824           ndh->icmp.checksum = ip6_tcp_udp_icmp_compute_checksum(vm, p0, ip,
3825                                                                  &bogus_length);
3826           clib_memcpy(eth->dst_address, eth->src_address, 6);
3827           clib_memcpy(eth->src_address, macp, 6);
3828           vlib_error_count (vm, error_node->node_index,
3829                             ICMP6_ERROR_NEIGHBOR_ADVERTISEMENTS_TX, 1);
3830           return 1;
3831         }
3832     }
3833
3834   return 0;
3835
3836 }
3837
3838 void
3839 ethernet_ndp_change_mac (vlib_main_t * vm, u32 sw_if_index)
3840 {
3841   ip6_neighbor_main_t * nm = &ip6_neighbor_main;
3842   ip6_neighbor_t * n;
3843
3844   /* *INDENT-OFF* */
3845   pool_foreach (n, nm->neighbor_pool, ({
3846     if (n->key.sw_if_index == sw_if_index)
3847     {
3848         adj_nbr_walk_nh6 (sw_if_index,
3849                           &n->key.ip6_address,
3850                           ip6_nd_mk_complete_walk, n);
3851     }
3852   }));
3853   /* *INDENT-ON* */
3854 }