src/vnet/ethernet/arp.c

   1 /*
   2  * ethernet/arp.c: IP v4 ARP node
   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/ip/ip6.h>
  20 #include <vnet/ethernet/ethernet.h>
  21 #include <vnet/ethernet/arp_packet.h>
  22 #include <vnet/l2/l2_input.h>
  23 #include <vppinfra/mhash.h>
  24 #include <vnet/fib/ip4_fib.h>
  25 #include <vnet/fib/fib_entry_src.h>
  26 #include <vnet/adj/adj_nbr.h>
  27 #include <vnet/adj/adj_mcast.h>
  28 #include <vnet/mpls/mpls.h>
  29
  30 /**
  31  * @file
  32  * @brief IPv4 ARP.
  33  *
  34  * This file contains code to manage the IPv4 ARP tables (IP Address
  35  * to MAC Address lookup).
  36  */
  37
  38
  39 void vl_api_rpc_call_main_thread (void *fp, u8 * data, u32 data_length);
  40
  41 /**
  42  * @brief Per-interface ARP configuration and state
  43  */
  44 typedef struct ethernet_arp_interface_t_
  45 {
  46   /**
  47    * Hash table of ARP entries.
  48    * Since this hash table is per-interface, the key is only the IPv4 address.
  49    */
  50   uword *arp_entries;
  51 } ethernet_arp_interface_t;
  52
  53 typedef struct
  54 {
  55   u32 lo_addr;
  56   u32 hi_addr;
  57   u32 fib_index;
  58 } ethernet_proxy_arp_t;
  59
  60 typedef struct
  61 {
  62   u32 next_index;
  63   uword node_index;
  64   uword type_opaque;
  65   uword data;
  66   /* Used for arp event notification only */
  67   void *data_callback;
  68   u32 pid;
  69 } pending_resolution_t;
  70
  71 typedef struct
  72 {
  73   /* Hash tables mapping name to opcode. */
  74   uword *opcode_by_name;
  75
  76   /* lite beer "glean" adjacency handling */
  77   uword *pending_resolutions_by_address;
  78   pending_resolution_t *pending_resolutions;
  79
  80   /* Mac address change notification */
  81   uword *mac_changes_by_address;
  82   pending_resolution_t *mac_changes;
  83
  84   ethernet_arp_ip4_entry_t *ip4_entry_pool;
  85
  86   /* ARP attack mitigation */
  87   u32 arp_delete_rotor;
  88   u32 limit_arp_cache_size;
  89
  90   /** Per interface state */
  91   ethernet_arp_interface_t *ethernet_arp_by_sw_if_index;
  92
  93   /* Proxy arp vector */
  94   ethernet_proxy_arp_t *proxy_arps;
  95
  96   uword wc_ip4_arp_publisher_node;
  97   uword wc_ip4_arp_publisher_et;
  98 } ethernet_arp_main_t;
  99
 100 static ethernet_arp_main_t ethernet_arp_main;
 101
 102 typedef struct
 103 {
 104   u32 sw_if_index;
 105   ethernet_arp_ip4_over_ethernet_address_t a;
 106   int is_static;
 107   int is_no_fib_entry;
 108   int flags;
 109 #define ETHERNET_ARP_ARGS_REMOVE (1<<0)
 110 #define ETHERNET_ARP_ARGS_FLUSH  (1<<1)
 111 #define ETHERNET_ARP_ARGS_POPULATE  (1<<2)
 112 #define ETHERNET_ARP_ARGS_WC_PUB  (1<<3)
 113 } vnet_arp_set_ip4_over_ethernet_rpc_args_t;
 114
 115 static const u8 vrrp_prefix[] = { 0x00, 0x00, 0x5E, 0x00, 0x01 };
 116
 117 /* Node index for send_garp_na_process */
 118 u32 send_garp_na_process_node_index;
 119
 120 static void
 121 set_ip4_over_ethernet_rpc_callback (vnet_arp_set_ip4_over_ethernet_rpc_args_t
 122                                     * a);
 123
 124 static u8 *
 125 format_ethernet_arp_hardware_type (u8 * s, va_list * va)
 126 {
 127   ethernet_arp_hardware_type_t h = va_arg (*va, ethernet_arp_hardware_type_t);
 128   char *t = 0;
 129   switch (h)
 130     {
 131 #define _(n,f) case n: t = #f; break;
 132       foreach_ethernet_arp_hardware_type;
 133 #undef _
 134
 135     default:
 136       return format (s, "unknown 0x%x", h);
 137     }
 138
 139   return format (s, "%s", t);
 140 }
 141
 142 static u8 *
 143 format_ethernet_arp_opcode (u8 * s, va_list * va)
 144 {
 145   ethernet_arp_opcode_t o = va_arg (*va, ethernet_arp_opcode_t);
 146   char *t = 0;
 147   switch (o)
 148     {
 149 #define _(f) case ETHERNET_ARP_OPCODE_##f: t = #f; break;
 150       foreach_ethernet_arp_opcode;
 151 #undef _
 152
 153     default:
 154       return format (s, "unknown 0x%x", o);
 155     }
 156
 157   return format (s, "%s", t);
 158 }
 159
 160 static uword
 161 unformat_ethernet_arp_opcode_host_byte_order (unformat_input_t * input,
 162                                               va_list * args)
 163 {
 164   int *result = va_arg (*args, int *);
 165   ethernet_arp_main_t *am = &ethernet_arp_main;
 166   int x, i;
 167
 168   /* Numeric opcode. */
 169   if (unformat (input, "0x%x", &x) || unformat (input, "%d", &x))
 170     {
 171       if (x >= (1 << 16))
 172         return 0;
 173       *result = x;
 174       return 1;
 175     }
 176
 177   /* Named type. */
 178   if (unformat_user (input, unformat_vlib_number_by_name,
 179                      am->opcode_by_name, &i))
 180     {
 181       *result = i;
 182       return 1;
 183     }
 184
 185   return 0;
 186 }
 187
 188 static uword
 189 unformat_ethernet_arp_opcode_net_byte_order (unformat_input_t * input,
 190                                              va_list * args)
 191 {
 192   int *result = va_arg (*args, int *);
 193   if (!unformat_user
 194       (input, unformat_ethernet_arp_opcode_host_byte_order, result))
 195     return 0;
 196
 197   *result = clib_host_to_net_u16 ((u16) * result);
 198   return 1;
 199 }
 200
 201 static u8 *
 202 format_ethernet_arp_header (u8 * s, va_list * va)
 203 {
 204   ethernet_arp_header_t *a = va_arg (*va, ethernet_arp_header_t *);
 205   u32 max_header_bytes = va_arg (*va, u32);
 206   uword indent;
 207   u16 l2_type, l3_type;
 208
 209   if (max_header_bytes != 0 && sizeof (a[0]) > max_header_bytes)
 210     return format (s, "ARP header truncated");
 211
 212   l2_type = clib_net_to_host_u16 (a->l2_type);
 213   l3_type = clib_net_to_host_u16 (a->l3_type);
 214
 215   indent = format_get_indent (s);
 216
 217   s = format (s, "%U, type %U/%U, address size %d/%d",
 218               format_ethernet_arp_opcode, clib_net_to_host_u16 (a->opcode),
 219               format_ethernet_arp_hardware_type, l2_type,
 220               format_ethernet_type, l3_type,
 221               a->n_l2_address_bytes, a->n_l3_address_bytes);
 222
 223   if (l2_type == ETHERNET_ARP_HARDWARE_TYPE_ethernet
 224       && l3_type == ETHERNET_TYPE_IP4)
 225     {
 226       s = format (s, "\n%U%U/%U -> %U/%U",
 227                   format_white_space, indent,
 228                   format_ethernet_address, a->ip4_over_ethernet[0].ethernet,
 229                   format_ip4_address, &a->ip4_over_ethernet[0].ip4,
 230                   format_ethernet_address, a->ip4_over_ethernet[1].ethernet,
 231                   format_ip4_address, &a->ip4_over_ethernet[1].ip4);
 232     }
 233   else
 234     {
 235       uword n2 = a->n_l2_address_bytes;
 236       uword n3 = a->n_l3_address_bytes;
 237       s = format (s, "\n%U%U/%U -> %U/%U",
 238                   format_white_space, indent,
 239                   format_hex_bytes, a->data + 0 * n2 + 0 * n3, n2,
 240                   format_hex_bytes, a->data + 1 * n2 + 0 * n3, n3,
 241                   format_hex_bytes, a->data + 1 * n2 + 1 * n3, n2,
 242                   format_hex_bytes, a->data + 2 * n2 + 1 * n3, n3);
 243     }
 244
 245   return s;
 246 }
 247
 248 u8 *
 249 format_ethernet_arp_ip4_entry (u8 * s, va_list * va)
 250 {
 251   vnet_main_t *vnm = va_arg (*va, vnet_main_t *);
 252   ethernet_arp_ip4_entry_t *e = va_arg (*va, ethernet_arp_ip4_entry_t *);
 253   vnet_sw_interface_t *si;
 254   u8 *flags = 0;
 255
 256   if (!e)
 257     return format (s, "%=12s%=16s%=6s%=20s%=24s", "Time", "IP4",
 258                    "Flags", "Ethernet", "Interface");
 259
 260   si = vnet_get_sw_interface (vnm, e->sw_if_index);
 261
 262   if (e->flags & ETHERNET_ARP_IP4_ENTRY_FLAG_STATIC)
 263     flags = format (flags, "S");
 264
 265   if (e->flags & ETHERNET_ARP_IP4_ENTRY_FLAG_DYNAMIC)
 266     flags = format (flags, "D");
 267
 268   if (e->flags & ETHERNET_ARP_IP4_ENTRY_FLAG_NO_FIB_ENTRY)
 269     flags = format (flags, "N");
 270
 271   s = format (s, "%=12U%=16U%=6s%=20U%U",
 272               format_vlib_cpu_time, vnm->vlib_main, e->cpu_time_last_updated,
 273               format_ip4_address, &e->ip4_address,
 274               flags ? (char *) flags : "",
 275               format_ethernet_address, e->ethernet_address,
 276               format_vnet_sw_interface_name, vnm, si);
 277
 278   vec_free (flags);
 279   return s;
 280 }
 281
 282 typedef struct
 283 {
 284   u8 packet_data[64];
 285 } ethernet_arp_input_trace_t;
 286
 287 static u8 *
 288 format_ethernet_arp_input_trace (u8 * s, va_list * va)
 289 {
 290   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*va, vlib_main_t *);
 291   CLIB_UNUSED (vlib_node_t * node) = va_arg (*va, vlib_node_t *);
 292   ethernet_arp_input_trace_t *t = va_arg (*va, ethernet_arp_input_trace_t *);
 293
 294   s = format (s, "%U",
 295               format_ethernet_arp_header,
 296               t->packet_data, sizeof (t->packet_data));
 297
 298   return s;
 299 }
 300
 301 static u8 *
 302 format_arp_term_input_trace (u8 * s, va_list * va)
 303 {
 304   CLIB_UNUSED (vlib_main_t * vm) = va_arg (*va, vlib_main_t *);
 305   CLIB_UNUSED (vlib_node_t * node) = va_arg (*va, vlib_node_t *);
 306   ethernet_arp_input_trace_t *t = va_arg (*va, ethernet_arp_input_trace_t *);
 307
 308   /* arp-term trace data saved is either arp or ip6/icmp6 packet:
 309      - for arp, the 1st 16-bit field is hw type of value of 0x0001.
 310      - for ip6, the first nibble has value of 6. */
 311   s = format (s, "%U", t->packet_data[0] == 0 ?
 312               format_ethernet_arp_header : format_ip6_header,
 313               t->packet_data, sizeof (t->packet_data));
 314
 315   return s;
 316 }
 317
 318 static void
 319 arp_nbr_probe (ip_adjacency_t * adj)
 320 {
 321   vnet_main_t *vnm = vnet_get_main ();
 322   ip4_main_t *im = &ip4_main;
 323   ip_interface_address_t *ia;
 324   ethernet_arp_header_t *h;
 325   vnet_hw_interface_t *hi;
 326   vnet_sw_interface_t *si;
 327   ip4_address_t *src;
 328   vlib_buffer_t *b;
 329   vlib_main_t *vm;
 330   u32 bi = 0;
 331
 332   vm = vlib_get_main ();
 333
 334   si = vnet_get_sw_interface (vnm, adj->rewrite_header.sw_if_index);
 335
 336   if (!(si->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP))
 337     {
 338       return;
 339     }
 340
 341   src =
 342     ip4_interface_address_matching_destination (im,
 343                                                 &adj->sub_type.nbr.next_hop.
 344                                                 ip4,
 345                                                 adj->rewrite_header.
 346                                                 sw_if_index, &ia);
 347   if (!src)
 348     {
 349       return;
 350     }
 351
 352   h =
 353     vlib_packet_template_get_packet (vm, &im->ip4_arp_request_packet_template,
 354                                      &bi);
 355
 356   hi = vnet_get_sup_hw_interface (vnm, adj->rewrite_header.sw_if_index);
 357
 358   clib_memcpy (h->ip4_over_ethernet[0].ethernet,
 359                hi->hw_address, sizeof (h->ip4_over_ethernet[0].ethernet));
 360
 361   h->ip4_over_ethernet[0].ip4 = src[0];
 362   h->ip4_over_ethernet[1].ip4 = adj->sub_type.nbr.next_hop.ip4;
 363
 364   b = vlib_get_buffer (vm, bi);
 365   vnet_buffer (b)->sw_if_index[VLIB_RX] =
 366     vnet_buffer (b)->sw_if_index[VLIB_TX] = adj->rewrite_header.sw_if_index;
 367
 368   /* Add encapsulation string for software interface (e.g. ethernet header). */
 369   vnet_rewrite_one_header (adj[0], h, sizeof (ethernet_header_t));
 370   vlib_buffer_advance (b, -adj->rewrite_header.data_bytes);
 371
 372   {
 373     vlib_frame_t *f = vlib_get_frame_to_node (vm, hi->output_node_index);
 374     u32 *to_next = vlib_frame_vector_args (f);
 375     to_next[0] = bi;
 376     f->n_vectors = 1;
 377     vlib_put_frame_to_node (vm, hi->output_node_index, f);
 378   }
 379 }
 380
 381 static void
 382 arp_mk_complete (adj_index_t ai, ethernet_arp_ip4_entry_t * e)
 383 {
 384   adj_nbr_update_rewrite
 385     (ai, ADJ_NBR_REWRITE_FLAG_COMPLETE,
 386      ethernet_build_rewrite (vnet_get_main (),
 387                              e->sw_if_index,
 388                              adj_get_link_type (ai), e->ethernet_address));
 389 }
 390
 391 static void
 392 arp_mk_incomplete (adj_index_t ai)
 393 {
 394   ip_adjacency_t *adj = adj_get (ai);
 395
 396   adj_nbr_update_rewrite
 397     (ai,
 398      ADJ_NBR_REWRITE_FLAG_INCOMPLETE,
 399      ethernet_build_rewrite (vnet_get_main (),
 400                              adj->rewrite_header.sw_if_index,
 401                              VNET_LINK_ARP,
 402                              VNET_REWRITE_FOR_SW_INTERFACE_ADDRESS_BROADCAST));
 403 }
 404
 405 static ethernet_arp_ip4_entry_t *
 406 arp_entry_find (ethernet_arp_interface_t * eai, const ip4_address_t * addr)
 407 {
 408   ethernet_arp_main_t *am = &ethernet_arp_main;
 409   ethernet_arp_ip4_entry_t *e = NULL;
 410   uword *p;
 411
 412   if (NULL != eai->arp_entries)
 413     {
 414       p = hash_get (eai->arp_entries, addr->as_u32);
 415       if (!p)
 416         return (NULL);
 417
 418       e = pool_elt_at_index (am->ip4_entry_pool, p[0]);
 419     }
 420
 421   return (e);
 422 }
 423
 424 static adj_walk_rc_t
 425 arp_mk_complete_walk (adj_index_t ai, void *ctx)
 426 {
 427   ethernet_arp_ip4_entry_t *e = ctx;
 428
 429   arp_mk_complete (ai, e);
 430
 431   return (ADJ_WALK_RC_CONTINUE);
 432 }
 433
 434 static adj_walk_rc_t
 435 arp_mk_incomplete_walk (adj_index_t ai, void *ctx)
 436 {
 437   arp_mk_incomplete (ai);
 438
 439   return (ADJ_WALK_RC_CONTINUE);
 440 }
 441
 442 void
 443 arp_update_adjacency (vnet_main_t * vnm, u32 sw_if_index, u32 ai)
 444 {
 445   ethernet_arp_main_t *am = &ethernet_arp_main;
 446   ethernet_arp_interface_t *arp_int;
 447   ethernet_arp_ip4_entry_t *e;
 448   ip_adjacency_t *adj;
 449
 450   adj = adj_get (ai);
 451
 452   vec_validate (am->ethernet_arp_by_sw_if_index, sw_if_index);
 453   arp_int = &am->ethernet_arp_by_sw_if_index[sw_if_index];
 454   e = arp_entry_find (arp_int, &adj->sub_type.nbr.next_hop.ip4);
 455
 456   switch (adj->lookup_next_index)
 457     {
 458     case IP_LOOKUP_NEXT_ARP:
 459     case IP_LOOKUP_NEXT_GLEAN:
 460       if (NULL != e)
 461         {
 462           adj_nbr_walk_nh4 (sw_if_index,
 463                             &e->ip4_address, arp_mk_complete_walk, e);
 464         }
 465       else
 466         {
 467           /*
 468            * no matching ARP entry.
 469            * construct the rewrite required to for an ARP packet, and stick
 470            * that in the adj's pipe to smoke.
 471            */
 472           adj_nbr_update_rewrite
 473             (ai,
 474              ADJ_NBR_REWRITE_FLAG_INCOMPLETE,
 475              ethernet_build_rewrite
 476              (vnm,
 477               sw_if_index,
 478               VNET_LINK_ARP,
 479               VNET_REWRITE_FOR_SW_INTERFACE_ADDRESS_BROADCAST));
 480
 481           /*
 482            * since the FIB has added this adj for a route, it makes sense it
 483            * may want to forward traffic sometime soon. Let's send a
 484            * speculative ARP. just one. If we were to do periodically that
 485            * wouldn't be bad either, but that's more code than i'm prepared to
 486            * write at this time for relatively little reward.
 487            */
 488           arp_nbr_probe (adj);
 489         }
 490       break;
 491     case IP_LOOKUP_NEXT_MCAST:
 492       {
 493         /*
 494          * Construct a partial rewrite from the known ethernet mcast dest MAC
 495          */
 496         u8 *rewrite;
 497         u8 offset;
 498
 499         rewrite = ethernet_build_rewrite (vnm,
 500                                           sw_if_index,
 501                                           adj->ia_link,
 502                                           ethernet_ip4_mcast_dst_addr ());
 503         offset = vec_len (rewrite) - 2;
 504
 505         /*
 506          * Complete the remaining fields of the adj's rewrite to direct the
 507          * complete of the rewrite at switch time by copying in the IP
 508          * dst address's bytes.
 509          * Ofset is 2 bytes into the MAC desintation address. And we copy 23 bits
 510          * from the address.
 511          */
 512         adj_mcast_update_rewrite (ai, rewrite, offset, 0x007fffff);
 513
 514         break;
 515       }
 516     case IP_LOOKUP_NEXT_DROP:
 517     case IP_LOOKUP_NEXT_PUNT:
 518     case IP_LOOKUP_NEXT_LOCAL:
 519     case IP_LOOKUP_NEXT_REWRITE:
 520     case IP_LOOKUP_NEXT_MCAST_MIDCHAIN:
 521     case IP_LOOKUP_NEXT_MIDCHAIN:
 522     case IP_LOOKUP_NEXT_ICMP_ERROR:
 523     case IP_LOOKUP_N_NEXT:
 524       ASSERT (0);
 525       break;
 526     }
 527 }
 528
 529 static void
 530 arp_adj_fib_add (ethernet_arp_ip4_entry_t * e, u32 fib_index)
 531 {
 532   fib_prefix_t pfx = {
 533     .fp_len = 32,
 534     .fp_proto = FIB_PROTOCOL_IP4,
 535     .fp_addr.ip4 = e->ip4_address,
 536   };
 537
 538   e->fib_entry_index =
 539     fib_table_entry_path_add (fib_index, &pfx, FIB_SOURCE_ADJ,
 540                               FIB_ENTRY_FLAG_ATTACHED,
 541                               DPO_PROTO_IP4, &pfx.fp_addr,
 542                               e->sw_if_index, ~0, 1, NULL,
 543                               FIB_ROUTE_PATH_FLAG_NONE);
 544   fib_table_lock (fib_index, FIB_PROTOCOL_IP4, FIB_SOURCE_ADJ);
 545 }
 546
 547 static int
 548 vnet_arp_set_ip4_over_ethernet_internal (vnet_main_t * vnm,
 549                                          vnet_arp_set_ip4_over_ethernet_rpc_args_t
 550                                          * args)
 551 {
 552   ethernet_arp_ip4_entry_t *e = 0;
 553   ethernet_arp_main_t *am = &ethernet_arp_main;
 554   ethernet_arp_ip4_over_ethernet_address_t *a = &args->a;
 555   vlib_main_t *vm = vlib_get_main ();
 556   int make_new_arp_cache_entry = 1;
 557   uword *p;
 558   pending_resolution_t *pr, *mc;
 559   ethernet_arp_interface_t *arp_int;
 560   int is_static = args->is_static;
 561   u32 sw_if_index = args->sw_if_index;
 562   int is_no_fib_entry = args->is_no_fib_entry;
 563
 564   vec_validate (am->ethernet_arp_by_sw_if_index, sw_if_index);
 565
 566   arp_int = &am->ethernet_arp_by_sw_if_index[sw_if_index];
 567
 568   if (NULL != arp_int->arp_entries)
 569     {
 570       p = hash_get (arp_int->arp_entries, a->ip4.as_u32);
 571       if (p)
 572         {
 573           e = pool_elt_at_index (am->ip4_entry_pool, p[0]);
 574
 575           /* Refuse to over-write static arp. */
 576           if (!is_static && (e->flags & ETHERNET_ARP_IP4_ENTRY_FLAG_STATIC))
 577             return -2;
 578           make_new_arp_cache_entry = 0;
 579         }
 580     }
 581
 582   if (make_new_arp_cache_entry)
 583     {
 584       pool_get (am->ip4_entry_pool, e);
 585
 586       if (NULL == arp_int->arp_entries)
 587         {
 588           arp_int->arp_entries = hash_create (0, sizeof (u32));
 589         }
 590
 591       hash_set (arp_int->arp_entries, a->ip4.as_u32, e - am->ip4_entry_pool);
 592
 593       e->sw_if_index = sw_if_index;
 594       e->ip4_address = a->ip4;
 595       e->fib_entry_index = FIB_NODE_INDEX_INVALID;
 596       clib_memcpy (e->ethernet_address,
 597                    a->ethernet, sizeof (e->ethernet_address));
 598
 599       if (!is_no_fib_entry)
 600         {
 601           arp_adj_fib_add (e,
 602                            ip4_fib_table_get_index_for_sw_if_index
 603                            (e->sw_if_index));
 604         }
 605       else
 606         {
 607           e->flags |= ETHERNET_ARP_IP4_ENTRY_FLAG_NO_FIB_ENTRY;
 608         }
 609     }
 610   else
 611     {
 612       /*
 613        * prevent a DoS attack from the data-plane that
 614        * spams us with no-op updates to the MAC address
 615        */
 616       if (0 == memcmp (e->ethernet_address,
 617                        a->ethernet, sizeof (e->ethernet_address)))
 618         return -1;
 619
 620       /* Update time stamp and ethernet address. */
 621       clib_memcpy (e->ethernet_address, a->ethernet,
 622                    sizeof (e->ethernet_address));
 623     }
 624
 625   e->cpu_time_last_updated = clib_cpu_time_now ();
 626   if (is_static)
 627     e->flags |= ETHERNET_ARP_IP4_ENTRY_FLAG_STATIC;
 628   else
 629     e->flags |= ETHERNET_ARP_IP4_ENTRY_FLAG_DYNAMIC;
 630
 631   adj_nbr_walk_nh4 (sw_if_index, &e->ip4_address, arp_mk_complete_walk, e);
 632
 633   /* Customer(s) waiting for this address to be resolved? */
 634   p = hash_get (am->pending_resolutions_by_address, a->ip4.as_u32);
 635   if (p)
 636     {
 637       u32 next_index;
 638       next_index = p[0];
 639
 640       while (next_index != (u32) ~ 0)
 641         {
 642           pr = pool_elt_at_index (am->pending_resolutions, next_index);
 643           vlib_process_signal_event (vm, pr->node_index,
 644                                      pr->type_opaque, pr->data);
 645           next_index = pr->next_index;
 646           pool_put (am->pending_resolutions, pr);
 647         }
 648
 649       hash_unset (am->pending_resolutions_by_address, a->ip4.as_u32);
 650     }
 651
 652   /* Customer(s) requesting ARP event for this address? */
 653   p = hash_get (am->mac_changes_by_address, a->ip4.as_u32);
 654   if (p)
 655     {
 656       u32 next_index;
 657       next_index = p[0];
 658
 659       while (next_index != (u32) ~ 0)
 660         {
 661           int (*fp) (u32, u8 *, u32, u32);
 662           int rv = 1;
 663           mc = pool_elt_at_index (am->mac_changes, next_index);
 664           fp = mc->data_callback;
 665
 666           /* Call the user's data callback, return 1 to suppress dup events */
 667           if (fp)
 668             rv = (*fp) (mc->data, a->ethernet, sw_if_index, 0);
 669
 670           /*
 671            * Signal the resolver process, as long as the user
 672            * says they want to be notified
 673            */
 674           if (rv == 0)
 675             vlib_process_signal_event (vm, mc->node_index,
 676                                        mc->type_opaque, mc->data);
 677           next_index = mc->next_index;
 678         }
 679     }
 680
 681   return 0;
 682 }
 683
 684 void
 685 vnet_register_ip4_arp_resolution_event (vnet_main_t * vnm,
 686                                         void *address_arg,
 687                                         uword node_index,
 688                                         uword type_opaque, uword data)
 689 {
 690   ethernet_arp_main_t *am = &ethernet_arp_main;
 691   ip4_address_t *address = address_arg;
 692   uword *p;
 693   pending_resolution_t *pr;
 694
 695   pool_get (am->pending_resolutions, pr);
 696
 697   pr->next_index = ~0;
 698   pr->node_index = node_index;
 699   pr->type_opaque = type_opaque;
 700   pr->data = data;
 701   pr->data_callback = 0;
 702
 703   p = hash_get (am->pending_resolutions_by_address, address->as_u32);
 704   if (p)
 705     {
 706       /* Insert new resolution at the head of the list */
 707       pr->next_index = p[0];
 708       hash_unset (am->pending_resolutions_by_address, address->as_u32);
 709     }
 710
 711   hash_set (am->pending_resolutions_by_address, address->as_u32,
 712             pr - am->pending_resolutions);
 713 }
 714
 715 int
 716 vnet_add_del_ip4_arp_change_event (vnet_main_t * vnm,
 717                                    void *data_callback,
 718                                    u32 pid,
 719                                    void *address_arg,
 720                                    uword node_index,
 721                                    uword type_opaque, uword data, int is_add)
 722 {
 723   ethernet_arp_main_t *am = &ethernet_arp_main;
 724   ip4_address_t *address = address_arg;
 725
 726   /* Try to find an existing entry */
 727   u32 *first = (u32 *) hash_get (am->mac_changes_by_address, address->as_u32);
 728   u32 *p = first;
 729   pending_resolution_t *mc;
 730   while (p && *p != ~0)
 731     {
 732       mc = pool_elt_at_index (am->mac_changes, *p);
 733       if (mc->node_index == node_index && mc->type_opaque == type_opaque
 734           && mc->pid == pid)
 735         break;
 736       p = &mc->next_index;
 737     }
 738
 739   int found = p && *p != ~0;
 740   if (is_add)
 741     {
 742       if (found)
 743         return VNET_API_ERROR_ENTRY_ALREADY_EXISTS;
 744
 745       pool_get (am->mac_changes, mc);
 746       *mc = (pending_resolution_t)
 747       {
 748       .next_index = ~0,.node_index = node_index,.type_opaque =
 749           type_opaque,.data = data,.data_callback = data_callback,.pid =
 750           pid,};
 751
 752       /* Insert new resolution at the end of the list */
 753       u32 new_idx = mc - am->mac_changes;
 754       if (p)
 755         p[0] = new_idx;
 756       else
 757         hash_set (am->mac_changes_by_address, address->as_u32, new_idx);
 758     }
 759   else
 760     {
 761       if (!found)
 762         return VNET_API_ERROR_NO_SUCH_ENTRY;
 763
 764       /* Clients may need to clean up pool entries, too */
 765       void (*fp) (u32, u8 *) = data_callback;
 766       if (fp)
 767         (*fp) (mc->data, 0 /* no new mac addrs */ );
 768
 769       /* Remove the entry from the list and delete the entry */
 770       *p = mc->next_index;
 771       pool_put (am->mac_changes, mc);
 772
 773       /* Remove from hash if we deleted the last entry */
 774       if (*p == ~0 && p == first)
 775         hash_unset (am->mac_changes_by_address, address->as_u32);
 776     }
 777   return 0;
 778 }
 779
 780 /* Either we drop the packet or we send a reply to the sender. */
 781 typedef enum
 782 {
 783   ARP_INPUT_NEXT_DROP,
 784   ARP_INPUT_NEXT_REPLY_TX,
 785   ARP_INPUT_N_NEXT,
 786 } arp_input_next_t;
 787
 788 #define foreach_ethernet_arp_error                                      \
 789   _ (replies_sent, "ARP replies sent")                                  \
 790   _ (l2_type_not_ethernet, "L2 type not ethernet")                      \
 791   _ (l3_type_not_ip4, "L3 type not IP4")                                \
 792   _ (l3_src_address_not_local, "IP4 source address not local to subnet") \
 793   _ (l3_dst_address_not_local, "IP4 destination address not local to subnet") \
 794   _ (l3_src_address_is_local, "IP4 source address matches local interface") \
 795   _ (l3_src_address_learned, "ARP request IP4 source address learned")  \
 796   _ (replies_received, "ARP replies received")                          \
 797   _ (opcode_not_request, "ARP opcode not request")                      \
 798   _ (proxy_arp_replies_sent, "Proxy ARP replies sent")                  \
 799   _ (l2_address_mismatch, "ARP hw addr does not match L2 frame src addr") \
 800   _ (gratuitous_arp, "ARP probe or announcement dropped") \
 801   _ (interface_no_table, "Interface is not mapped to an IP table") \
 802   _ (interface_not_ip_enabled, "Interface is not IP enabled") \
 803
 804 typedef enum
 805 {
 806 #define _(sym,string) ETHERNET_ARP_ERROR_##sym,
 807   foreach_ethernet_arp_error
 808 #undef _
 809     ETHERNET_ARP_N_ERROR,
 810 } ethernet_arp_input_error_t;
 811
 812
 813 static void
 814 unset_random_arp_entry (void)
 815 {
 816   ethernet_arp_main_t *am = &ethernet_arp_main;
 817   ethernet_arp_ip4_entry_t *e;
 818   vnet_main_t *vnm = vnet_get_main ();
 819   ethernet_arp_ip4_over_ethernet_address_t delme;
 820   u32 index;
 821
 822   index = pool_next_index (am->ip4_entry_pool, am->arp_delete_rotor);
 823   am->arp_delete_rotor = index;
 824
 825   /* Try again from elt 0, could happen if an intfc goes down */
 826   if (index == ~0)
 827     {
 828       index = pool_next_index (am->ip4_entry_pool, am->arp_delete_rotor);
 829       am->arp_delete_rotor = index;
 830     }
 831
 832   /* Nothing left in the pool */
 833   if (index == ~0)
 834     return;
 835
 836   e = pool_elt_at_index (am->ip4_entry_pool, index);
 837
 838   clib_memcpy (&delme.ethernet, e->ethernet_address, 6);
 839   delme.ip4.as_u32 = e->ip4_address.as_u32;
 840
 841   vnet_arp_unset_ip4_over_ethernet (vnm, e->sw_if_index, &delme);
 842 }
 843
 844 static int
 845 arp_unnumbered (vlib_buffer_t * p0,
 846                 u32 input_sw_if_index, u32 conn_sw_if_index)
 847 {
 848   vnet_main_t *vnm = vnet_get_main ();
 849   vnet_interface_main_t *vim = &vnm->interface_main;
 850   vnet_sw_interface_t *si;
 851
 852   /* verify that the input interface is unnumbered to the connected.
 853    * the connected interface is the interface on which the subnet is
 854    * configured */
 855   si = &vim->sw_interfaces[input_sw_if_index];
 856
 857   if (!(si->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED &&
 858         (si->unnumbered_sw_if_index == conn_sw_if_index)))
 859     {
 860       /* the input interface is not unnumbered to the interface on which
 861        * the sub-net is configured that covers the ARP request.
 862        * So this is not the case for unnumbered.. */
 863       return 0;
 864     }
 865
 866   return !0;
 867 }
 868
 869 static u32
 870 arp_learn (vnet_main_t * vnm,
 871            ethernet_arp_main_t * am, u32 sw_if_index, void *addr)
 872 {
 873   if (am->limit_arp_cache_size &&
 874       pool_elts (am->ip4_entry_pool) >= am->limit_arp_cache_size)
 875     unset_random_arp_entry ();
 876
 877   vnet_arp_set_ip4_over_ethernet (vnm, sw_if_index, addr, 0, 0);
 878   return (ETHERNET_ARP_ERROR_l3_src_address_learned);
 879 }
 880
 881 static uword
 882 arp_input (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
 883 {
 884   ethernet_arp_main_t *am = &ethernet_arp_main;
 885   vnet_main_t *vnm = vnet_get_main ();
 886   ip4_main_t *im4 = &ip4_main;
 887   u32 n_left_from, next_index, *from, *to_next;
 888   u32 n_replies_sent = 0, n_proxy_arp_replies_sent = 0;
 889
 890   from = vlib_frame_vector_args (frame);
 891   n_left_from = frame->n_vectors;
 892   next_index = node->cached_next_index;
 893
 894   if (node->flags & VLIB_NODE_FLAG_TRACE)
 895     vlib_trace_frame_buffers_only (vm, node, from, frame->n_vectors,
 896                                    /* stride */ 1,
 897                                    sizeof (ethernet_arp_input_trace_t));
 898
 899   while (n_left_from > 0)
 900     {
 901       u32 n_left_to_next;
 902
 903       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
 904
 905       while (n_left_from > 0 && n_left_to_next > 0)
 906         {
 907           vlib_buffer_t *p0;
 908           vnet_hw_interface_t *hw_if0;
 909           ethernet_arp_header_t *arp0;
 910           ethernet_header_t *eth_rx, *eth_tx;
 911           ip4_address_t *if_addr0, proxy_src;
 912           u32 pi0, error0, next0, sw_if_index0, conn_sw_if_index0, fib_index0;
 913           u8 is_request0, dst_is_local0, is_unnum0, is_vrrp_reply0;
 914           ethernet_proxy_arp_t *pa;
 915           fib_node_index_t dst_fei, src_fei;
 916           fib_prefix_t pfx0;
 917           fib_entry_flag_t src_flags, dst_flags;
 918           u8 *rewrite0, rewrite0_len;
 919
 920           pi0 = from[0];
 921           to_next[0] = pi0;
 922           from += 1;
 923           to_next += 1;
 924           n_left_from -= 1;
 925           n_left_to_next -= 1;
 926           pa = 0;
 927
 928           p0 = vlib_get_buffer (vm, pi0);
 929           arp0 = vlib_buffer_get_current (p0);
 930           /* Fill in ethernet header. */
 931           eth_rx = ethernet_buffer_get_header (p0);
 932
 933           is_request0 = arp0->opcode
 934             == clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_request);
 935
 936           error0 = ETHERNET_ARP_ERROR_replies_sent;
 937
 938           error0 =
 939             (arp0->l2_type !=
 940              clib_net_to_host_u16 (ETHERNET_ARP_HARDWARE_TYPE_ethernet) ?
 941              ETHERNET_ARP_ERROR_l2_type_not_ethernet : error0);
 942           error0 =
 943             (arp0->l3_type !=
 944              clib_net_to_host_u16 (ETHERNET_TYPE_IP4) ?
 945              ETHERNET_ARP_ERROR_l3_type_not_ip4 : error0);
 946
 947           sw_if_index0 = vnet_buffer (p0)->sw_if_index[VLIB_RX];
 948
 949           /* not playing the ARP game if the interface is not IPv4 enabled */
 950           error0 =
 951             (im4->ip_enabled_by_sw_if_index[sw_if_index0] == 0 ?
 952              ETHERNET_ARP_ERROR_interface_not_ip_enabled : error0);
 953
 954           if (error0)
 955             goto drop2;
 956
 957           /* Check that IP address is local and matches incoming interface. */
 958           fib_index0 = ip4_fib_table_get_index_for_sw_if_index (sw_if_index0);
 959           if (~0 == fib_index0)
 960             {
 961               error0 = ETHERNET_ARP_ERROR_interface_no_table;
 962               goto drop2;
 963
 964             }
 965           dst_fei = ip4_fib_table_lookup (ip4_fib_get (fib_index0),
 966                                           &arp0->ip4_over_ethernet[1].ip4,
 967                                           32);
 968           dst_flags = fib_entry_get_flags (dst_fei);
 969
 970           conn_sw_if_index0 = fib_entry_get_resolving_interface (dst_fei);
 971
 972           /* Honor unnumbered interface, if any */
 973           is_unnum0 = sw_if_index0 != conn_sw_if_index0;
 974
 975           {
 976             /*
 977              * we're looking for FIB entries that indicate the source
 978              * is attached. There may be more specific non-attached
 979              * routes tht match the source, but these do not influence
 980              * whether we respond to an ARP request, i.e. they do not
 981              * influence whether we are the correct way for the sender
 982              * to reach us, they only affect how we reach the sender.
 983              */
 984             fib_entry_t *src_fib_entry;
 985             fib_entry_src_t *src;
 986             fib_source_t source;
 987             fib_prefix_t pfx;
 988             int attached;
 989             int mask;
 990
 991             mask = 32;
 992             attached = 0;
 993
 994             do
 995               {
 996                 src_fei = ip4_fib_table_lookup (ip4_fib_get (fib_index0),
 997                                                 &arp0->
 998                                                 ip4_over_ethernet[0].ip4,
 999                                                 mask);
1000                 src_fib_entry = fib_entry_get (src_fei);
1001
1002                 /*
1003                  * It's possible that the source that provides the
1004                  * flags we need, or the flags we must not have,
1005                  * is not the best source, so check then all.
1006                  */
1007                 /* *INDENT-OFF* */
1008                 FOR_EACH_SRC_ADDED(src_fib_entry, src, source,
1009                 ({
1010                   src_flags = fib_entry_get_flags_for_source (src_fei, source);
1011
1012                   /* Reject requests/replies with our local interface
1013                      address. */
1014                   if (FIB_ENTRY_FLAG_LOCAL & src_flags)
1015                     {
1016                       error0 = ETHERNET_ARP_ERROR_l3_src_address_is_local;
1017                       /*
1018                        * When VPP has an interface whose address is also
1019                        * applied to a TAP interface on the host, then VPP's
1020                        * TAP interface will be unnumbered  to the 'real'
1021                        * interface and do proxy ARP from the host.
1022                        * The curious aspect of this setup is that ARP requests
1023                        * from the host will come from the VPP's own address.
1024                        * So don't drop immediately here, instead go see if this
1025                        * is a proxy ARP case.
1026                        */
1027                       goto drop1;
1028                     }
1029                   /* A Source must also be local to subnet of matching
1030                    * interface address. */
1031                   if ((FIB_ENTRY_FLAG_ATTACHED & src_flags) ||
1032                       (FIB_ENTRY_FLAG_CONNECTED & src_flags))
1033                     {
1034                       attached = 1;
1035                       break;
1036                     }
1037                   /*
1038                    * else
1039                    *  The packet was sent from an address that is not
1040                    *  connected nor attached i.e. it is not from an
1041                    *  address that is covered by a link's sub-net,
1042                    *  nor is it a already learned host resp.
1043                    */
1044                 }));
1045                 /* *INDENT-ON* */
1046
1047                 /*
1048                  * shorter mask lookup for the next iteration.
1049                  */
1050                 fib_entry_get_prefix (src_fei, &pfx);
1051                 mask = pfx.fp_len - 1;
1052
1053                 /*
1054                  * continue until we hit the default route or we find
1055                  * the attached we are looking for. The most likely
1056                  * outcome is we find the attached with the first source
1057                  * on the first lookup.
1058                  */
1059               }
1060             while (!attached &&
1061                    !fib_entry_is_sourced (src_fei, FIB_SOURCE_DEFAULT_ROUTE));
1062
1063             if (!attached)
1064               {
1065                 /*
1066                  * the matching route is a not attached, i.e. it was
1067                  * added as a result of routing, rather than interface/ARP
1068                  * configuration. If the matching route is not a host route
1069                  * (i.e. a /32)
1070                  */
1071                 error0 = ETHERNET_ARP_ERROR_l3_src_address_not_local;
1072                 goto drop2;
1073               }
1074           }
1075
1076           if (!(FIB_ENTRY_FLAG_CONNECTED & dst_flags))
1077             {
1078               error0 = ETHERNET_ARP_ERROR_l3_dst_address_not_local;
1079               goto drop1;
1080             }
1081
1082           if (sw_if_index0 != fib_entry_get_resolving_interface (src_fei))
1083             {
1084               /*
1085                * The interface the ARP was received on is not the interface
1086                * on which the covering prefix is configured. Maybe this is a
1087                * case for unnumbered.
1088                */
1089               is_unnum0 = 1;
1090             }
1091
1092           dst_is_local0 = (FIB_ENTRY_FLAG_LOCAL & dst_flags);
1093           fib_entry_get_prefix (dst_fei, &pfx0);
1094           if_addr0 = &pfx0.fp_addr.ip4;
1095
1096           is_vrrp_reply0 =
1097             ((arp0->opcode ==
1098               clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_reply))
1099              &&
1100              (!memcmp
1101               (arp0->ip4_over_ethernet[0].ethernet, vrrp_prefix,
1102                sizeof (vrrp_prefix))));
1103
1104           /* Trash ARP packets whose ARP-level source addresses do not
1105              match their L2-frame-level source addresses, unless it's
1106              a reply from a VRRP virtual router */
1107           if (memcmp
1108               (eth_rx->src_address, arp0->ip4_over_ethernet[0].ethernet,
1109                sizeof (eth_rx->src_address)) && !is_vrrp_reply0)
1110             {
1111               error0 = ETHERNET_ARP_ERROR_l2_address_mismatch;
1112               goto drop2;
1113             }
1114
1115           /* Learn or update sender's mapping only for replies to addresses
1116            * that are local to the subnet */
1117           if (arp0->opcode ==
1118               clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_reply) &&
1119               dst_is_local0)
1120             {
1121               error0 = arp_learn (vnm, am, sw_if_index0,
1122                                   &arp0->ip4_over_ethernet[0]);
1123               goto drop1;
1124             }
1125
1126         send_reply:
1127           /* Send a reply.
1128              An adjacency to the sender is not always present,
1129              so we use the interface to build us a rewrite string
1130              which will contain all the necessary tags. */
1131           rewrite0 = ethernet_build_rewrite (vnm, sw_if_index0,
1132                                              VNET_LINK_ARP,
1133                                              eth_rx->src_address);
1134           rewrite0_len = vec_len (rewrite0);
1135
1136           /* Figure out how much to rewind current data from adjacency. */
1137           vlib_buffer_advance (p0, -rewrite0_len);
1138           eth_tx = vlib_buffer_get_current (p0);
1139
1140           vnet_buffer (p0)->sw_if_index[VLIB_TX] = sw_if_index0;
1141           hw_if0 = vnet_get_sup_hw_interface (vnm, sw_if_index0);
1142
1143           /* Send reply back through input interface */
1144           vnet_buffer (p0)->sw_if_index[VLIB_TX] = sw_if_index0;
1145           next0 = ARP_INPUT_NEXT_REPLY_TX;
1146
1147           arp0->opcode = clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_reply);
1148
1149           arp0->ip4_over_ethernet[1] = arp0->ip4_over_ethernet[0];
1150
1151           clib_memcpy (arp0->ip4_over_ethernet[0].ethernet,
1152                        hw_if0->hw_address, 6);
1153           clib_mem_unaligned (&arp0->ip4_over_ethernet[0].ip4.data_u32, u32) =
1154             if_addr0->data_u32;
1155
1156           /* Hardware must be ethernet-like. */
1157           ASSERT (vec_len (hw_if0->hw_address) == 6);
1158
1159           /* the rx nd tx ethernet headers wil overlap in the case
1160            * when we received a tagged VLAN=0 packet, but we are sending
1161            * back untagged */
1162           clib_memcpy (eth_tx, rewrite0, vec_len (rewrite0));
1163           vec_free (rewrite0);
1164
1165           if (NULL == pa)
1166             {
1167               if (is_unnum0)
1168                 {
1169                   if (!arp_unnumbered (p0, sw_if_index0, conn_sw_if_index0))
1170                     goto drop2;
1171                 }
1172             }
1173
1174           /* We are going to reply to this request, so, in the absence of
1175              errors, learn the sender */
1176           if (!error0)
1177             error0 = arp_learn (vnm, am, sw_if_index0,
1178                                 &arp0->ip4_over_ethernet[1]);
1179
1180           vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
1181                                            n_left_to_next, pi0, next0);
1182
1183           n_replies_sent += 1;
1184           continue;
1185
1186         drop1:
1187           if (0 == arp0->ip4_over_ethernet[0].ip4.as_u32 ||
1188               (arp0->ip4_over_ethernet[0].ip4.as_u32 ==
1189                arp0->ip4_over_ethernet[1].ip4.as_u32))
1190             {
1191               error0 = ETHERNET_ARP_ERROR_gratuitous_arp;
1192               goto drop2;
1193             }
1194           /* See if proxy arp is configured for the address */
1195           if (is_request0)
1196             {
1197               vnet_sw_interface_t *si;
1198               u32 this_addr = clib_net_to_host_u32
1199                 (arp0->ip4_over_ethernet[1].ip4.as_u32);
1200               u32 fib_index0;
1201
1202               si = vnet_get_sw_interface (vnm, sw_if_index0);
1203
1204               if (!(si->flags & VNET_SW_INTERFACE_FLAG_PROXY_ARP))
1205                 goto drop2;
1206
1207               fib_index0 = vec_elt (im4->fib_index_by_sw_if_index,
1208                                     sw_if_index0);
1209
1210               vec_foreach (pa, am->proxy_arps)
1211               {
1212                 u32 lo_addr = clib_net_to_host_u32 (pa->lo_addr);
1213                 u32 hi_addr = clib_net_to_host_u32 (pa->hi_addr);
1214
1215                 /* an ARP request hit in the proxy-arp table? */
1216                 if ((this_addr >= lo_addr && this_addr <= hi_addr) &&
1217                     (fib_index0 == pa->fib_index))
1218                   {
1219                     proxy_src.as_u32 =
1220                       arp0->ip4_over_ethernet[1].ip4.data_u32;
1221
1222                     /*
1223                      * change the interface address to the proxied
1224                      */
1225                     if_addr0 = &proxy_src;
1226                     is_unnum0 = 0;
1227                     n_proxy_arp_replies_sent++;
1228                     goto send_reply;
1229                   }
1230               }
1231             }
1232
1233         drop2:
1234
1235           next0 = ARP_INPUT_NEXT_DROP;
1236           p0->error = node->errors[error0];
1237
1238           vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
1239                                            n_left_to_next, pi0, next0);
1240         }
1241
1242       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1243     }
1244
1245   vlib_error_count (vm, node->node_index,
1246                     ETHERNET_ARP_ERROR_replies_sent,
1247                     n_replies_sent - n_proxy_arp_replies_sent);
1248
1249   vlib_error_count (vm, node->node_index,
1250                     ETHERNET_ARP_ERROR_proxy_arp_replies_sent,
1251                     n_proxy_arp_replies_sent);
1252   return frame->n_vectors;
1253 }
1254
1255 static char *ethernet_arp_error_strings[] = {
1256 #define _(sym,string) string,
1257   foreach_ethernet_arp_error
1258 #undef _
1259 };
1260
1261 /* *INDENT-OFF* */
1262 VLIB_REGISTER_NODE (arp_input_node, static) =
1263 {
1264   .function = arp_input,
1265   .name = "arp-input",
1266   .vector_size = sizeof (u32),
1267   .n_errors = ETHERNET_ARP_N_ERROR,
1268   .error_strings = ethernet_arp_error_strings,
1269   .n_next_nodes = ARP_INPUT_N_NEXT,
1270   .next_nodes = {
1271     [ARP_INPUT_NEXT_DROP] = "error-drop",
1272     [ARP_INPUT_NEXT_REPLY_TX] = "interface-output",
1273   },
1274   .format_buffer = format_ethernet_arp_header,
1275   .format_trace = format_ethernet_arp_input_trace,
1276 };
1277 /* *INDENT-ON* */
1278
1279 static int
1280 ip4_arp_entry_sort (void *a1, void *a2)
1281 {
1282   ethernet_arp_ip4_entry_t *e1 = a1;
1283   ethernet_arp_ip4_entry_t *e2 = a2;
1284
1285   int cmp;
1286   vnet_main_t *vnm = vnet_get_main ();
1287
1288   cmp = vnet_sw_interface_compare (vnm, e1->sw_if_index, e2->sw_if_index);
1289   if (!cmp)
1290     cmp = ip4_address_compare (&e1->ip4_address, &e2->ip4_address);
1291   return cmp;
1292 }
1293
1294 ethernet_arp_ip4_entry_t *
1295 ip4_neighbor_entries (u32 sw_if_index)
1296 {
1297   ethernet_arp_main_t *am = &ethernet_arp_main;
1298   ethernet_arp_ip4_entry_t *n, *ns = 0;
1299
1300   /* *INDENT-OFF* */
1301   pool_foreach (n, am->ip4_entry_pool, ({
1302     if (sw_if_index != ~0 && n->sw_if_index != sw_if_index)
1303       continue;
1304     vec_add1 (ns, n[0]);
1305   }));
1306   /* *INDENT-ON* */
1307
1308   if (ns)
1309     vec_sort_with_function (ns, ip4_arp_entry_sort);
1310   return ns;
1311 }
1312
1313 static clib_error_t *
1314 show_ip4_arp (vlib_main_t * vm,
1315               unformat_input_t * input, vlib_cli_command_t * cmd)
1316 {
1317   vnet_main_t *vnm = vnet_get_main ();
1318   ethernet_arp_main_t *am = &ethernet_arp_main;
1319   ethernet_arp_ip4_entry_t *e, *es;
1320   ethernet_proxy_arp_t *pa;
1321   clib_error_t *error = 0;
1322   u32 sw_if_index;
1323
1324   /* Filter entries by interface if given. */
1325   sw_if_index = ~0;
1326   (void) unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index);
1327
1328   es = ip4_neighbor_entries (sw_if_index);
1329   if (es)
1330     {
1331       vlib_cli_output (vm, "%U", format_ethernet_arp_ip4_entry, vnm, 0);
1332       vec_foreach (e, es)
1333       {
1334         vlib_cli_output (vm, "%U", format_ethernet_arp_ip4_entry, vnm, e);
1335       }
1336       vec_free (es);
1337     }
1338
1339   if (vec_len (am->proxy_arps))
1340     {
1341       vlib_cli_output (vm, "Proxy arps enabled for:");
1342       vec_foreach (pa, am->proxy_arps)
1343       {
1344         vlib_cli_output (vm, "Fib_index %d   %U - %U ",
1345                          pa->fib_index,
1346                          format_ip4_address, &pa->lo_addr,
1347                          format_ip4_address, &pa->hi_addr);
1348       }
1349     }
1350
1351   return error;
1352 }
1353
1354 /*?
1355  * Display all the IPv4 ARP entries.
1356  *
1357  * @cliexpar
1358  * Example of how to display the IPv4 ARP table:
1359  * @cliexstart{show ip arp}
1360  *    Time      FIB        IP4       Flags      Ethernet              Interface
1361  *    346.3028   0       6.1.1.3            de:ad:be:ef:ba:be   GigabitEthernet2/0/0
1362  *   3077.4271   0       6.1.1.4       S    de:ad:be:ef:ff:ff   GigabitEthernet2/0/0
1363  *   2998.6409   1       6.2.2.3            de:ad:be:ef:00:01   GigabitEthernet2/0/0
1364  * Proxy arps enabled for:
1365  * Fib_index 0   6.0.0.1 - 6.0.0.11
1366  * @cliexend
1367  ?*/
1368 /* *INDENT-OFF* */
1369 VLIB_CLI_COMMAND (show_ip4_arp_command, static) = {
1370   .path = "show ip arp",
1371   .function = show_ip4_arp,
1372   .short_help = "show ip arp",
1373 };
1374 /* *INDENT-ON* */
1375
1376 typedef struct
1377 {
1378   pg_edit_t l2_type, l3_type;
1379   pg_edit_t n_l2_address_bytes, n_l3_address_bytes;
1380   pg_edit_t opcode;
1381   struct
1382   {
1383     pg_edit_t ethernet;
1384     pg_edit_t ip4;
1385   } ip4_over_ethernet[2];
1386 } pg_ethernet_arp_header_t;
1387
1388 static inline void
1389 pg_ethernet_arp_header_init (pg_ethernet_arp_header_t * p)
1390 {
1391   /* Initialize fields that are not bit fields in the IP header. */
1392 #define _(f) pg_edit_init (&p->f, ethernet_arp_header_t, f);
1393   _(l2_type);
1394   _(l3_type);
1395   _(n_l2_address_bytes);
1396   _(n_l3_address_bytes);
1397   _(opcode);
1398   _(ip4_over_ethernet[0].ethernet);
1399   _(ip4_over_ethernet[0].ip4);
1400   _(ip4_over_ethernet[1].ethernet);
1401   _(ip4_over_ethernet[1].ip4);
1402 #undef _
1403 }
1404
1405 uword
1406 unformat_pg_arp_header (unformat_input_t * input, va_list * args)
1407 {
1408   pg_stream_t *s = va_arg (*args, pg_stream_t *);
1409   pg_ethernet_arp_header_t *p;
1410   u32 group_index;
1411
1412   p = pg_create_edit_group (s, sizeof (p[0]), sizeof (ethernet_arp_header_t),
1413                             &group_index);
1414   pg_ethernet_arp_header_init (p);
1415
1416   /* Defaults. */
1417   pg_edit_set_fixed (&p->l2_type, ETHERNET_ARP_HARDWARE_TYPE_ethernet);
1418   pg_edit_set_fixed (&p->l3_type, ETHERNET_TYPE_IP4);
1419   pg_edit_set_fixed (&p->n_l2_address_bytes, 6);
1420   pg_edit_set_fixed (&p->n_l3_address_bytes, 4);
1421
1422   if (!unformat (input, "%U: %U/%U -> %U/%U",
1423                  unformat_pg_edit,
1424                  unformat_ethernet_arp_opcode_net_byte_order, &p->opcode,
1425                  unformat_pg_edit,
1426                  unformat_ethernet_address, &p->ip4_over_ethernet[0].ethernet,
1427                  unformat_pg_edit,
1428                  unformat_ip4_address, &p->ip4_over_ethernet[0].ip4,
1429                  unformat_pg_edit,
1430                  unformat_ethernet_address, &p->ip4_over_ethernet[1].ethernet,
1431                  unformat_pg_edit,
1432                  unformat_ip4_address, &p->ip4_over_ethernet[1].ip4))
1433     {
1434       /* Free up any edits we may have added. */
1435       pg_free_edit_group (s);
1436       return 0;
1437     }
1438   return 1;
1439 }
1440
1441 clib_error_t *
1442 ip4_set_arp_limit (u32 arp_limit)
1443 {
1444   ethernet_arp_main_t *am = &ethernet_arp_main;
1445
1446   am->limit_arp_cache_size = arp_limit;
1447   return 0;
1448 }
1449
1450 /**
1451  * @brief Control Plane hook to remove an ARP entry
1452  */
1453 int
1454 vnet_arp_unset_ip4_over_ethernet (vnet_main_t * vnm,
1455                                   u32 sw_if_index, void *a_arg)
1456 {
1457   ethernet_arp_ip4_over_ethernet_address_t *a = a_arg;
1458   vnet_arp_set_ip4_over_ethernet_rpc_args_t args;
1459
1460   args.sw_if_index = sw_if_index;
1461   args.flags = ETHERNET_ARP_ARGS_REMOVE;
1462   clib_memcpy (&args.a, a, sizeof (*a));
1463
1464   vl_api_rpc_call_main_thread (set_ip4_over_ethernet_rpc_callback,
1465                                (u8 *) & args, sizeof (args));
1466   return 0;
1467 }
1468
1469 /**
1470  * @brief Internally generated event to flush the ARP cache on an
1471  * interface state change event.
1472  * A flush will remove dynamic ARP entries, and for statics remove the MAC
1473  * address from the corresponding adjacencies.
1474  */
1475 static int
1476 vnet_arp_flush_ip4_over_ethernet (vnet_main_t * vnm,
1477                                   u32 sw_if_index, void *a_arg)
1478 {
1479   ethernet_arp_ip4_over_ethernet_address_t *a = a_arg;
1480   vnet_arp_set_ip4_over_ethernet_rpc_args_t args;
1481
1482   args.sw_if_index = sw_if_index;
1483   args.flags = ETHERNET_ARP_ARGS_FLUSH;
1484   clib_memcpy (&args.a, a, sizeof (*a));
1485
1486   vl_api_rpc_call_main_thread (set_ip4_over_ethernet_rpc_callback,
1487                                (u8 *) & args, sizeof (args));
1488   return 0;
1489 }
1490
1491 /**
1492  * @brief Internally generated event to populate the ARP cache on an
1493  * interface state change event.
1494  * For static entries this will re-source the adjacencies.
1495  *
1496  * @param sw_if_index The interface on which the ARP entires are acted
1497  */
1498 static int
1499 vnet_arp_populate_ip4_over_ethernet (vnet_main_t * vnm,
1500                                      u32 sw_if_index, void *a_arg)
1501 {
1502   ethernet_arp_ip4_over_ethernet_address_t *a = a_arg;
1503   vnet_arp_set_ip4_over_ethernet_rpc_args_t args;
1504
1505   args.sw_if_index = sw_if_index;
1506   args.flags = ETHERNET_ARP_ARGS_POPULATE;
1507   clib_memcpy (&args.a, a, sizeof (*a));
1508
1509   vl_api_rpc_call_main_thread (set_ip4_over_ethernet_rpc_callback,
1510                                (u8 *) & args, sizeof (args));
1511   return 0;
1512 }
1513
1514 /**
1515  * @brief publish wildcard arp event
1516  * @param sw_if_index The interface on which the ARP entires are acted
1517  */
1518 static int
1519 vnet_arp_wc_publish (u32 sw_if_index, void *a_arg)
1520 {
1521   ethernet_arp_ip4_over_ethernet_address_t *a = a_arg;
1522   vnet_arp_set_ip4_over_ethernet_rpc_args_t args = {
1523     .flags = ETHERNET_ARP_ARGS_WC_PUB,
1524     .sw_if_index = sw_if_index,
1525     .a = *a
1526   };
1527
1528   vl_api_rpc_call_main_thread (set_ip4_over_ethernet_rpc_callback,
1529                                (u8 *) & args, sizeof (args));
1530   return 0;
1531 }
1532
1533 static void
1534 vnet_arp_wc_publish_internal (vnet_main_t * vnm,
1535                               vnet_arp_set_ip4_over_ethernet_rpc_args_t *
1536                               args)
1537 {
1538   vlib_main_t *vm = vlib_get_main ();
1539   ethernet_arp_main_t *am = &ethernet_arp_main;
1540   uword ni = am->wc_ip4_arp_publisher_node;
1541   uword et = am->wc_ip4_arp_publisher_et;
1542
1543   if (ni == (uword) ~ 0)
1544     return;
1545   wc_arp_report_t *r =
1546     vlib_process_signal_event_data (vm, ni, et, 1, sizeof *r);
1547   r->ip4 = args->a.ip4.as_u32;
1548   r->sw_if_index = args->sw_if_index;
1549   memcpy (r->mac, args->a.ethernet, sizeof r->mac);
1550 }
1551
1552 void
1553 wc_arp_set_publisher_node (uword node_index, uword event_type)
1554 {
1555   ethernet_arp_main_t *am = &ethernet_arp_main;
1556   am->wc_ip4_arp_publisher_node = node_index;
1557   am->wc_ip4_arp_publisher_et = event_type;
1558 }
1559
1560 /*
1561  * arp_add_del_interface_address
1562  *
1563  * callback when an interface address is added or deleted
1564  */
1565 static void
1566 arp_add_del_interface_address (ip4_main_t * im,
1567                                uword opaque,
1568                                u32 sw_if_index,
1569                                ip4_address_t * address,
1570                                u32 address_length,
1571                                u32 if_address_index, u32 is_del)
1572 {
1573   /*
1574    * Flush the ARP cache of all entries covered by the address
1575    * that is being removed.
1576    */
1577   ethernet_arp_main_t *am = &ethernet_arp_main;
1578   ethernet_arp_ip4_entry_t *e;
1579
1580   if (vec_len (am->ethernet_arp_by_sw_if_index) <= sw_if_index)
1581     return;
1582
1583   if (is_del)
1584     {
1585       ethernet_arp_interface_t *eai;
1586       u32 i, *to_delete = 0;
1587       hash_pair_t *pair;
1588
1589       eai = &am->ethernet_arp_by_sw_if_index[sw_if_index];
1590
1591       /* *INDENT-OFF* */
1592       hash_foreach_pair (pair, eai->arp_entries,
1593       ({
1594         e = pool_elt_at_index(am->ip4_entry_pool,
1595                               pair->value[0]);
1596         if (ip4_destination_matches_route (im, &e->ip4_address,
1597                                            address, address_length))
1598           {
1599             vec_add1 (to_delete, e - am->ip4_entry_pool);
1600           }
1601       }));
1602       /* *INDENT-ON* */
1603
1604       for (i = 0; i < vec_len (to_delete); i++)
1605         {
1606           ethernet_arp_ip4_over_ethernet_address_t delme;
1607           e = pool_elt_at_index (am->ip4_entry_pool, to_delete[i]);
1608
1609           clib_memcpy (&delme.ethernet, e->ethernet_address, 6);
1610           delme.ip4.as_u32 = e->ip4_address.as_u32;
1611
1612           vnet_arp_flush_ip4_over_ethernet (vnet_get_main (),
1613                                             e->sw_if_index, &delme);
1614         }
1615
1616       vec_free (to_delete);
1617     }
1618 }
1619
1620 void
1621 arp_adj_fib_remove (ethernet_arp_ip4_entry_t * e, u32 fib_index)
1622 {
1623   if (FIB_NODE_INDEX_INVALID != e->fib_entry_index)
1624     {
1625       fib_prefix_t pfx = {
1626         .fp_len = 32,
1627         .fp_proto = FIB_PROTOCOL_IP4,
1628         .fp_addr.ip4 = e->ip4_address,
1629       };
1630       u32 fib_index;
1631
1632       fib_index = ip4_fib_table_get_index_for_sw_if_index (e->sw_if_index);
1633
1634       fib_table_entry_path_remove (fib_index, &pfx,
1635                                    FIB_SOURCE_ADJ,
1636                                    DPO_PROTO_IP4,
1637                                    &pfx.fp_addr,
1638                                    e->sw_if_index, ~0, 1,
1639                                    FIB_ROUTE_PATH_FLAG_NONE);
1640       fib_table_unlock (fib_index, FIB_PROTOCOL_IP4, FIB_SOURCE_ADJ);
1641     }
1642 }
1643
1644 static void
1645 arp_table_bind (ip4_main_t * im,
1646                 uword opaque,
1647                 u32 sw_if_index, u32 new_fib_index, u32 old_fib_index)
1648 {
1649   ethernet_arp_main_t *am = &ethernet_arp_main;
1650   ethernet_arp_interface_t *eai;
1651   ethernet_arp_ip4_entry_t *e;
1652   hash_pair_t *pair;
1653
1654   /*
1655    * the IP table that the interface is bound to has changed.
1656    * reinstall all the adj fibs.
1657    */
1658
1659   if (vec_len (am->ethernet_arp_by_sw_if_index) <= sw_if_index)
1660     return;
1661
1662   eai = &am->ethernet_arp_by_sw_if_index[sw_if_index];
1663
1664   /* *INDENT-OFF* */
1665   hash_foreach_pair (pair, eai->arp_entries,
1666   ({
1667     e = pool_elt_at_index(am->ip4_entry_pool,
1668                           pair->value[0]);
1669     /*
1670      * remove the adj-fib from the old table and add to the new
1671      */
1672     arp_adj_fib_remove(e, old_fib_index);
1673     arp_adj_fib_add(e, new_fib_index);
1674   }));
1675   /* *INDENT-ON* */
1676
1677 }
1678
1679 static clib_error_t *
1680 ethernet_arp_init (vlib_main_t * vm)
1681 {
1682   ethernet_arp_main_t *am = &ethernet_arp_main;
1683   ip4_main_t *im = &ip4_main;
1684   clib_error_t *error;
1685   pg_node_t *pn;
1686
1687   if ((error = vlib_call_init_function (vm, ethernet_init)))
1688     return error;
1689
1690   ethernet_register_input_type (vm, ETHERNET_TYPE_ARP, arp_input_node.index);
1691
1692   pn = pg_get_node (arp_input_node.index);
1693   pn->unformat_edit = unformat_pg_arp_header;
1694
1695   am->opcode_by_name = hash_create_string (0, sizeof (uword));
1696 #define _(o) hash_set_mem (am->opcode_by_name, #o, ETHERNET_ARP_OPCODE_##o);
1697   foreach_ethernet_arp_opcode;
1698 #undef _
1699
1700   /* $$$ configurable */
1701   am->limit_arp_cache_size = 50000;
1702
1703   am->pending_resolutions_by_address = hash_create (0, sizeof (uword));
1704   am->mac_changes_by_address = hash_create (0, sizeof (uword));
1705   am->wc_ip4_arp_publisher_node = (uword) ~ 0;
1706
1707   /* don't trace ARP error packets */
1708   {
1709     vlib_node_runtime_t *rt =
1710       vlib_node_get_runtime (vm, arp_input_node.index);
1711
1712 #define _(a,b)                                  \
1713     vnet_pcap_drop_trace_filter_add_del         \
1714         (rt->errors[ETHERNET_ARP_ERROR_##a],    \
1715          1 /* is_add */);
1716     foreach_ethernet_arp_error
1717 #undef _
1718   }
1719
1720   ip4_add_del_interface_address_callback_t cb;
1721   cb.function = arp_add_del_interface_address;
1722   cb.function_opaque = 0;
1723   vec_add1 (im->add_del_interface_address_callbacks, cb);
1724
1725   ip4_table_bind_callback_t cbt;
1726   cbt.function = arp_table_bind;
1727   cbt.function_opaque = 0;
1728   vec_add1 (im->table_bind_callbacks, cbt);
1729
1730   return 0;
1731 }
1732
1733 VLIB_INIT_FUNCTION (ethernet_arp_init);
1734
1735 static void
1736 arp_entry_free (ethernet_arp_interface_t * eai, ethernet_arp_ip4_entry_t * e)
1737 {
1738   ethernet_arp_main_t *am = &ethernet_arp_main;
1739
1740   arp_adj_fib_remove (e,
1741                       ip4_fib_table_get_index_for_sw_if_index
1742                       (e->sw_if_index));
1743   hash_unset (eai->arp_entries, e->ip4_address.as_u32);
1744   pool_put (am->ip4_entry_pool, e);
1745 }
1746
1747 static inline int
1748 vnet_arp_unset_ip4_over_ethernet_internal (vnet_main_t * vnm,
1749                                            vnet_arp_set_ip4_over_ethernet_rpc_args_t
1750                                            * args)
1751 {
1752   ethernet_arp_main_t *am = &ethernet_arp_main;
1753   ethernet_arp_ip4_entry_t *e;
1754   ethernet_arp_interface_t *eai;
1755
1756   if (vec_len (am->ethernet_arp_by_sw_if_index) <= args->sw_if_index)
1757     return 0;
1758
1759   eai = &am->ethernet_arp_by_sw_if_index[args->sw_if_index];
1760
1761   e = arp_entry_find (eai, &args->a.ip4);
1762
1763   if (NULL != e)
1764     {
1765       arp_entry_free (eai, e);
1766
1767       adj_nbr_walk_nh4 (e->sw_if_index,
1768                         &e->ip4_address, arp_mk_incomplete_walk, NULL);
1769     }
1770
1771   return 0;
1772 }
1773
1774 static int
1775 vnet_arp_flush_ip4_over_ethernet_internal (vnet_main_t * vnm,
1776                                            vnet_arp_set_ip4_over_ethernet_rpc_args_t
1777                                            * args)
1778 {
1779   ethernet_arp_main_t *am = &ethernet_arp_main;
1780   ethernet_arp_ip4_entry_t *e;
1781   ethernet_arp_interface_t *eai;
1782
1783   if (vec_len (am->ethernet_arp_by_sw_if_index) <= args->sw_if_index)
1784     return 0;
1785
1786   eai = &am->ethernet_arp_by_sw_if_index[args->sw_if_index];
1787
1788   e = arp_entry_find (eai, &args->a.ip4);
1789
1790   if (NULL != e)
1791     {
1792       adj_nbr_walk_nh4 (e->sw_if_index,
1793                         &e->ip4_address, arp_mk_incomplete_walk, e);
1794
1795       /*
1796        * The difference between flush and unset, is that an unset
1797        * means delete for static and dynamic entries. A flush
1798        * means delete only for dynamic. Flushing is what the DP
1799        * does in response to interface events. unset is only done
1800        * by the control plane.
1801        */
1802       if (e->flags & ETHERNET_ARP_IP4_ENTRY_FLAG_STATIC)
1803         {
1804           e->flags &= ETHERNET_ARP_IP4_ENTRY_FLAG_DYNAMIC;
1805         }
1806       else if (e->flags & ETHERNET_ARP_IP4_ENTRY_FLAG_DYNAMIC)
1807         {
1808           arp_entry_free (eai, e);
1809         }
1810     }
1811   return (0);
1812 }
1813
1814 static int
1815 vnet_arp_populate_ip4_over_ethernet_internal (vnet_main_t * vnm,
1816                                               vnet_arp_set_ip4_over_ethernet_rpc_args_t
1817                                               * args)
1818 {
1819   ethernet_arp_main_t *am = &ethernet_arp_main;
1820   ethernet_arp_ip4_entry_t *e;
1821   ethernet_arp_interface_t *eai;
1822
1823   vec_validate (am->ethernet_arp_by_sw_if_index, args->sw_if_index);
1824   eai = &am->ethernet_arp_by_sw_if_index[args->sw_if_index];
1825
1826   e = arp_entry_find (eai, &args->a.ip4);
1827
1828   if (NULL != e)
1829     {
1830       adj_nbr_walk_nh4 (e->sw_if_index,
1831                         &e->ip4_address, arp_mk_complete_walk, e);
1832     }
1833   return (0);
1834 }
1835
1836 static void
1837 set_ip4_over_ethernet_rpc_callback (vnet_arp_set_ip4_over_ethernet_rpc_args_t
1838                                     * a)
1839 {
1840   vnet_main_t *vm = vnet_get_main ();
1841   ASSERT (vlib_get_thread_index () == 0);
1842
1843   if (a->flags & ETHERNET_ARP_ARGS_REMOVE)
1844     vnet_arp_unset_ip4_over_ethernet_internal (vm, a);
1845   else if (a->flags & ETHERNET_ARP_ARGS_FLUSH)
1846     vnet_arp_flush_ip4_over_ethernet_internal (vm, a);
1847   else if (a->flags & ETHERNET_ARP_ARGS_POPULATE)
1848     vnet_arp_populate_ip4_over_ethernet_internal (vm, a);
1849   else if (a->flags & ETHERNET_ARP_ARGS_WC_PUB)
1850     vnet_arp_wc_publish_internal (vm, a);
1851   else
1852     vnet_arp_set_ip4_over_ethernet_internal (vm, a);
1853 }
1854
1855 /**
1856  * @brief Invoked when the interface's admin state changes
1857  */
1858 static clib_error_t *
1859 ethernet_arp_sw_interface_up_down (vnet_main_t * vnm,
1860                                    u32 sw_if_index, u32 flags)
1861 {
1862   ethernet_arp_main_t *am = &ethernet_arp_main;
1863   ethernet_arp_ip4_entry_t *e;
1864   u32 i, *to_delete = 0;
1865
1866   /* *INDENT-OFF* */
1867   pool_foreach (e, am->ip4_entry_pool,
1868   ({
1869     if (e->sw_if_index == sw_if_index)
1870       vec_add1 (to_delete,
1871                 e - am->ip4_entry_pool);
1872   }));
1873   /* *INDENT-ON* */
1874
1875   for (i = 0; i < vec_len (to_delete); i++)
1876     {
1877       ethernet_arp_ip4_over_ethernet_address_t delme;
1878       e = pool_elt_at_index (am->ip4_entry_pool, to_delete[i]);
1879
1880       clib_memcpy (&delme.ethernet, e->ethernet_address, 6);
1881       delme.ip4.as_u32 = e->ip4_address.as_u32;
1882
1883       if (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP)
1884         {
1885           vnet_arp_populate_ip4_over_ethernet (vnm, e->sw_if_index, &delme);
1886         }
1887       else
1888         {
1889           vnet_arp_flush_ip4_over_ethernet (vnm, e->sw_if_index, &delme);
1890         }
1891
1892     }
1893   vec_free (to_delete);
1894
1895   return 0;
1896 }
1897
1898 VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION (ethernet_arp_sw_interface_up_down);
1899
1900 static void
1901 increment_ip4_and_mac_address (ethernet_arp_ip4_over_ethernet_address_t * a)
1902 {
1903   u8 old;
1904   int i;
1905
1906   for (i = 3; i >= 0; i--)
1907     {
1908       old = a->ip4.as_u8[i];
1909       a->ip4.as_u8[i] += 1;
1910       if (old < a->ip4.as_u8[i])
1911         break;
1912     }
1913
1914   for (i = 5; i >= 0; i--)
1915     {
1916       old = a->ethernet[i];
1917       a->ethernet[i] += 1;
1918       if (old < a->ethernet[i])
1919         break;
1920     }
1921 }
1922
1923 int
1924 vnet_arp_set_ip4_over_ethernet (vnet_main_t * vnm,
1925                                 u32 sw_if_index, void *a_arg,
1926                                 int is_static, int is_no_fib_entry)
1927 {
1928   ethernet_arp_ip4_over_ethernet_address_t *a = a_arg;
1929   vnet_arp_set_ip4_over_ethernet_rpc_args_t args;
1930
1931   args.sw_if_index = sw_if_index;
1932   args.is_static = is_static;
1933   args.is_no_fib_entry = is_no_fib_entry;
1934   args.flags = 0;
1935   clib_memcpy (&args.a, a, sizeof (*a));
1936
1937   vl_api_rpc_call_main_thread (set_ip4_over_ethernet_rpc_callback,
1938                                (u8 *) & args, sizeof (args));
1939   return 0;
1940 }
1941
1942 int
1943 vnet_proxy_arp_add_del (ip4_address_t * lo_addr,
1944                         ip4_address_t * hi_addr, u32 fib_index, int is_del)
1945 {
1946   ethernet_arp_main_t *am = &ethernet_arp_main;
1947   ethernet_proxy_arp_t *pa;
1948   u32 found_at_index = ~0;
1949
1950   vec_foreach (pa, am->proxy_arps)
1951   {
1952     if (pa->lo_addr == lo_addr->as_u32
1953         && pa->hi_addr == hi_addr->as_u32 && pa->fib_index == fib_index)
1954       {
1955         found_at_index = pa - am->proxy_arps;
1956         break;
1957       }
1958   }
1959
1960   if (found_at_index != ~0)
1961     {
1962       /* Delete, otherwise it's already in the table */
1963       if (is_del)
1964         vec_delete (am->proxy_arps, 1, found_at_index);
1965       return 0;
1966     }
1967   /* delete, no such entry */
1968   if (is_del)
1969     return VNET_API_ERROR_NO_SUCH_ENTRY;
1970
1971   /* add, not in table */
1972   vec_add2 (am->proxy_arps, pa, 1);
1973   pa->lo_addr = lo_addr->as_u32;
1974   pa->hi_addr = hi_addr->as_u32;
1975   pa->fib_index = fib_index;
1976   return 0;
1977 }
1978
1979 /*
1980  * Remove any proxy arp entries asdociated with the
1981  * specificed fib.
1982  */
1983 int
1984 vnet_proxy_arp_fib_reset (u32 fib_id)
1985 {
1986   ethernet_arp_main_t *am = &ethernet_arp_main;
1987   ethernet_proxy_arp_t *pa;
1988   u32 *entries_to_delete = 0;
1989   u32 fib_index;
1990   int i;
1991
1992   fib_index = fib_table_find (FIB_PROTOCOL_IP4, fib_id);
1993   if (~0 == fib_index)
1994     return VNET_API_ERROR_NO_SUCH_ENTRY;
1995
1996   vec_foreach (pa, am->proxy_arps)
1997   {
1998     if (pa->fib_index == fib_index)
1999       {
2000         vec_add1 (entries_to_delete, pa - am->proxy_arps);
2001       }
2002   }
2003
2004   for (i = 0; i < vec_len (entries_to_delete); i++)
2005     {
2006       vec_delete (am->proxy_arps, 1, entries_to_delete[i]);
2007     }
2008
2009   vec_free (entries_to_delete);
2010
2011   return 0;
2012 }
2013
2014 static clib_error_t *
2015 ip_arp_add_del_command_fn (vlib_main_t * vm,
2016                            unformat_input_t * input, vlib_cli_command_t * cmd)
2017 {
2018   vnet_main_t *vnm = vnet_get_main ();
2019   u32 sw_if_index;
2020   ethernet_arp_ip4_over_ethernet_address_t lo_addr, hi_addr, addr;
2021   int addr_valid = 0;
2022   int is_del = 0;
2023   int count = 1;
2024   u32 fib_index = 0;
2025   u32 fib_id;
2026   int is_static = 0;
2027   int is_no_fib_entry = 0;
2028   int is_proxy = 0;
2029
2030   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2031     {
2032       /* set ip arp TenGigE1/1/0/1 1.2.3.4 aa:bb:... or aabb.ccdd... */
2033       if (unformat (input, "%U %U %U",
2034                     unformat_vnet_sw_interface, vnm, &sw_if_index,
2035                     unformat_ip4_address, &addr.ip4,
2036                     unformat_ethernet_address, &addr.ethernet))
2037         addr_valid = 1;
2038
2039       else if (unformat (input, "delete") || unformat (input, "del"))
2040         is_del = 1;
2041
2042       else if (unformat (input, "static"))
2043         is_static = 1;
2044
2045       else if (unformat (input, "no-fib-entry"))
2046         is_no_fib_entry = 1;
2047
2048       else if (unformat (input, "count %d", &count))
2049         ;
2050
2051       else if (unformat (input, "fib-id %d", &fib_id))
2052         {
2053           fib_index = fib_table_find (FIB_PROTOCOL_IP4, fib_id);
2054
2055           if (~0 == fib_index)
2056             return clib_error_return (0, "fib ID %d doesn't exist\n", fib_id);
2057         }
2058
2059       else if (unformat (input, "proxy %U - %U",
2060                          unformat_ip4_address, &lo_addr.ip4,
2061                          unformat_ip4_address, &hi_addr.ip4))
2062         is_proxy = 1;
2063       else
2064         break;
2065     }
2066
2067   if (is_proxy)
2068     {
2069       (void) vnet_proxy_arp_add_del (&lo_addr.ip4, &hi_addr.ip4,
2070                                      fib_index, is_del);
2071       return 0;
2072     }
2073
2074   if (addr_valid)
2075     {
2076       int i;
2077
2078       for (i = 0; i < count; i++)
2079         {
2080           if (is_del == 0)
2081             {
2082               uword event_type, *event_data = 0;
2083
2084               /* Park the debug CLI until the arp entry is installed */
2085               vnet_register_ip4_arp_resolution_event
2086                 (vnm, &addr.ip4, vlib_current_process (vm),
2087                  1 /* type */ , 0 /* data */ );
2088
2089               vnet_arp_set_ip4_over_ethernet
2090                 (vnm, sw_if_index, &addr, is_static, is_no_fib_entry);
2091
2092               vlib_process_wait_for_event (vm);
2093               event_type = vlib_process_get_events (vm, &event_data);
2094               vec_reset_length (event_data);
2095               if (event_type != 1)
2096                 clib_warning ("event type %d unexpected", event_type);
2097             }
2098           else
2099             vnet_arp_unset_ip4_over_ethernet (vnm, sw_if_index, &addr);
2100
2101           increment_ip4_and_mac_address (&addr);
2102         }
2103     }
2104   else
2105     {
2106       return clib_error_return (0, "unknown input `%U'",
2107                                 format_unformat_error, input);
2108     }
2109
2110   return 0;
2111 }
2112
2113 /* *INDENT-OFF* */
2114 /*?
2115  * Add or delete IPv4 ARP cache entries.
2116  *
2117  * @note 'set ip arp' options (e.g. delete, static, 'fib-id <id>',
2118  * 'count <number>', 'interface ip4_addr mac_addr') can be added in
2119  * any order and combination.
2120  *
2121  * @cliexpar
2122  * @parblock
2123  * Add or delete IPv4 ARP cache entries as follows. MAC Address can be in
2124  * either aa:bb:cc:dd:ee:ff format or aabb.ccdd.eeff format.
2125  * @cliexcmd{set ip arp GigabitEthernet2/0/0 6.0.0.3 dead.beef.babe}
2126  * @cliexcmd{set ip arp delete GigabitEthernet2/0/0 6.0.0.3 de:ad:be:ef:ba:be}
2127  *
2128  * To add or delete an IPv4 ARP cache entry to or from a specific fib
2129  * table:
2130  * @cliexcmd{set ip arp fib-id 1 GigabitEthernet2/0/0 6.0.0.3 dead.beef.babe}
2131  * @cliexcmd{set ip arp fib-id 1 delete GigabitEthernet2/0/0 6.0.0.3 dead.beef.babe}
2132  *
2133  * Add or delete IPv4 static ARP cache entries as follows:
2134  * @cliexcmd{set ip arp static GigabitEthernet2/0/0 6.0.0.3 dead.beef.babe}
2135  * @cliexcmd{set ip arp static delete GigabitEthernet2/0/0 6.0.0.3 dead.beef.babe}
2136  *
2137  * For testing / debugging purposes, the 'set ip arp' command can add or
2138  * delete multiple entries. Supply the 'count N' parameter:
2139  * @cliexcmd{set ip arp count 10 GigabitEthernet2/0/0 6.0.0.3 dead.beef.babe}
2140  * @endparblock
2141  ?*/
2142 VLIB_CLI_COMMAND (ip_arp_add_del_command, static) = {
2143   .path = "set ip arp",
2144   .short_help =
2145   "set ip arp [del] <intfc> <ip-address> <mac-address> [static] [no-fib-entry] [count <count>] [fib-id <fib-id>] [proxy <lo-addr> - <hi-addr>]",
2146   .function = ip_arp_add_del_command_fn,
2147 };
2148 /* *INDENT-ON* */
2149
2150 static clib_error_t *
2151 set_int_proxy_arp_command_fn (vlib_main_t * vm,
2152                               unformat_input_t *
2153                               input, vlib_cli_command_t * cmd)
2154 {
2155   vnet_main_t *vnm = vnet_get_main ();
2156   u32 sw_if_index;
2157   vnet_sw_interface_t *si;
2158   int enable = 0;
2159   int intfc_set = 0;
2160
2161   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2162     {
2163       if (unformat (input, "%U", unformat_vnet_sw_interface,
2164                     vnm, &sw_if_index))
2165         intfc_set = 1;
2166       else if (unformat (input, "enable") || unformat (input, "on"))
2167         enable = 1;
2168       else if (unformat (input, "disable") || unformat (input, "off"))
2169         enable = 0;
2170       else
2171         break;
2172     }
2173
2174   if (intfc_set == 0)
2175     return clib_error_return (0, "unknown input '%U'",
2176                               format_unformat_error, input);
2177
2178   si = vnet_get_sw_interface (vnm, sw_if_index);
2179   ASSERT (si);
2180   if (enable)
2181     si->flags |= VNET_SW_INTERFACE_FLAG_PROXY_ARP;
2182   else
2183     si->flags &= ~VNET_SW_INTERFACE_FLAG_PROXY_ARP;
2184
2185   return 0;
2186 }
2187
2188 /* *INDENT-OFF* */
2189 /*?
2190  * Enable proxy-arp on an interface. The vpp stack will answer ARP
2191  * requests for the indicated address range. Multiple proxy-arp
2192  * ranges may be provisioned.
2193  *
2194  * @note Proxy ARP as a technology is infamous for blackholing traffic.
2195  * Also, the underlying implementation has not been performance-tuned.
2196  * Avoid creating an unnecessarily large set of ranges.
2197  *
2198  * @cliexpar
2199  * To enable proxy arp on a range of addresses, use:
2200  * @cliexcmd{set ip arp proxy 6.0.0.1 - 6.0.0.11}
2201  * Append 'del' to delete a range of proxy ARP addresses:
2202  * @cliexcmd{set ip arp proxy 6.0.0.1 - 6.0.0.11 del}
2203  * You must then specifically enable proxy arp on individual interfaces:
2204  * @cliexcmd{set interface proxy-arp GigabitEthernet0/8/0 enable}
2205  * To disable proxy arp on an individual interface:
2206  * @cliexcmd{set interface proxy-arp GigabitEthernet0/8/0 disable}
2207  ?*/
2208 VLIB_CLI_COMMAND (set_int_proxy_enable_command, static) = {
2209   .path = "set interface proxy-arp",
2210   .short_help =
2211   "set interface proxy-arp <intfc> [enable|disable]",
2212   .function = set_int_proxy_arp_command_fn,
2213 };
2214 /* *INDENT-ON* */
2215
2216
2217 /*
2218  * ARP/ND Termination in a L2 Bridge Domain based on IP4/IP6 to MAC
2219  * hash tables mac_by_ip4 and mac_by_ip6 for each BD.
2220  */
2221 typedef enum
2222 {
2223   ARP_TERM_NEXT_L2_OUTPUT,
2224   ARP_TERM_NEXT_DROP,
2225   ARP_TERM_N_NEXT,
2226 } arp_term_next_t;
2227
2228 u32 arp_term_next_node_index[32];
2229
2230 static uword
2231 arp_term_l2bd (vlib_main_t * vm,
2232                vlib_node_runtime_t * node, vlib_frame_t * frame)
2233 {
2234   l2input_main_t *l2im = &l2input_main;
2235   u32 n_left_from, next_index, *from, *to_next;
2236   u32 n_replies_sent = 0;
2237   u16 last_bd_index = ~0;
2238   l2_bridge_domain_t *last_bd_config = 0;
2239   l2_input_config_t *cfg0;
2240
2241   from = vlib_frame_vector_args (frame);
2242   n_left_from = frame->n_vectors;
2243   next_index = node->cached_next_index;
2244
2245   while (n_left_from > 0)
2246     {
2247       u32 n_left_to_next;
2248
2249       vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
2250
2251       while (n_left_from > 0 && n_left_to_next > 0)
2252         {
2253           vlib_buffer_t *p0;
2254           ethernet_header_t *eth0;
2255           ethernet_arp_header_t *arp0;
2256           ip6_header_t *iph0;
2257           u8 *l3h0;
2258           u32 pi0, error0, next0, sw_if_index0;
2259           u16 ethertype0;
2260           u16 bd_index0;
2261           u32 ip0;
2262           u8 *macp0;
2263           u8 is_vrrp_reply0;
2264
2265           pi0 = from[0];
2266           to_next[0] = pi0;
2267           from += 1;
2268           to_next += 1;
2269           n_left_from -= 1;
2270           n_left_to_next -= 1;
2271
2272           p0 = vlib_get_buffer (vm, pi0);
2273           // Terminate only local (SHG == 0) ARP
2274           if (vnet_buffer (p0)->l2.shg != 0)
2275             goto next_l2_feature;
2276
2277           eth0 = vlib_buffer_get_current (p0);
2278           l3h0 = (u8 *) eth0 + vnet_buffer (p0)->l2.l2_len;
2279           ethertype0 = clib_net_to_host_u16 (*(u16 *) (l3h0 - 2));
2280           arp0 = (ethernet_arp_header_t *) l3h0;
2281
2282           if (PREDICT_FALSE ((ethertype0 != ETHERNET_TYPE_ARP) ||
2283                              (arp0->opcode !=
2284                               clib_host_to_net_u16
2285                               (ETHERNET_ARP_OPCODE_request))))
2286             goto check_ip6_nd;
2287
2288           /* Must be ARP request packet here */
2289           if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) &&
2290                              (p0->flags & VLIB_BUFFER_IS_TRACED)))
2291             {
2292               u8 *t0 = vlib_add_trace (vm, node, p0,
2293                                        sizeof (ethernet_arp_input_trace_t));
2294               clib_memcpy (t0, l3h0, sizeof (ethernet_arp_input_trace_t));
2295             }
2296
2297           error0 = ETHERNET_ARP_ERROR_replies_sent;
2298           error0 =
2299             (arp0->l2_type !=
2300              clib_net_to_host_u16 (ETHERNET_ARP_HARDWARE_TYPE_ethernet)
2301              ? ETHERNET_ARP_ERROR_l2_type_not_ethernet : error0);
2302           error0 =
2303             (arp0->l3_type !=
2304              clib_net_to_host_u16 (ETHERNET_TYPE_IP4) ?
2305              ETHERNET_ARP_ERROR_l3_type_not_ip4 : error0);
2306
2307           sw_if_index0 = vnet_buffer (p0)->sw_if_index[VLIB_RX];
2308
2309           if (error0)
2310             goto drop;
2311
2312           is_vrrp_reply0 =
2313             ((arp0->opcode ==
2314               clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_reply))
2315              &&
2316              (!memcmp
2317               (arp0->ip4_over_ethernet[0].ethernet, vrrp_prefix,
2318                sizeof (vrrp_prefix))));
2319
2320           /* Trash ARP packets whose ARP-level source addresses do not
2321              match their L2-frame-level source addresses, unless it's
2322              a reply from a VRRP virtual router */
2323           if (PREDICT_FALSE
2324               (memcmp (eth0->src_address, arp0->ip4_over_ethernet[0].ethernet,
2325                        sizeof (eth0->src_address)) && !is_vrrp_reply0))
2326             {
2327               error0 = ETHERNET_ARP_ERROR_l2_address_mismatch;
2328               goto drop;
2329             }
2330
2331           /* Check if anyone want ARP request events for L2 BDs */
2332           {
2333             ethernet_arp_main_t *am = &ethernet_arp_main;
2334             if (am->wc_ip4_arp_publisher_node != (uword) ~ 0)
2335               vnet_arp_wc_publish (sw_if_index0, &arp0->ip4_over_ethernet[0]);
2336           }
2337
2338           /* lookup BD mac_by_ip4 hash table for MAC entry */
2339           ip0 = arp0->ip4_over_ethernet[1].ip4.as_u32;
2340           bd_index0 = vnet_buffer (p0)->l2.bd_index;
2341           if (PREDICT_FALSE ((bd_index0 != last_bd_index)
2342                              || (last_bd_index == (u16) ~ 0)))
2343             {
2344               last_bd_index = bd_index0;
2345               last_bd_config = vec_elt_at_index (l2im->bd_configs, bd_index0);
2346             }
2347           macp0 = (u8 *) hash_get (last_bd_config->mac_by_ip4, ip0);
2348
2349           if (PREDICT_FALSE (!macp0))
2350             goto next_l2_feature;       /* MAC not found */
2351
2352           /* MAC found, send ARP reply -
2353              Convert ARP request packet to ARP reply */
2354           arp0->opcode = clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_reply);
2355           arp0->ip4_over_ethernet[1] = arp0->ip4_over_ethernet[0];
2356           arp0->ip4_over_ethernet[0].ip4.as_u32 = ip0;
2357           clib_memcpy (arp0->ip4_over_ethernet[0].ethernet, macp0, 6);
2358           clib_memcpy (eth0->dst_address, eth0->src_address, 6);
2359           clib_memcpy (eth0->src_address, macp0, 6);
2360           n_replies_sent += 1;
2361
2362         output_response:
2363           /* For BVI, need to use l2-fwd node to send ARP reply as
2364              l2-output node cannot output packet to BVI properly */
2365           cfg0 = vec_elt_at_index (l2im->configs, sw_if_index0);
2366           if (PREDICT_FALSE (cfg0->bvi))
2367             {
2368               vnet_buffer (p0)->l2.feature_bitmap |= L2INPUT_FEAT_FWD;
2369               vnet_buffer (p0)->sw_if_index[VLIB_RX] = 0;
2370               goto next_l2_feature;
2371             }
2372
2373           /* Send ARP/ND reply back out input interface through l2-output */
2374           vnet_buffer (p0)->sw_if_index[VLIB_TX] = sw_if_index0;
2375           next0 = ARP_TERM_NEXT_L2_OUTPUT;
2376           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
2377                                            to_next, n_left_to_next, pi0,
2378                                            next0);
2379           continue;
2380
2381         check_ip6_nd:
2382           /* IP6 ND event notification or solicitation handling to generate
2383              local response instead of flooding */
2384           iph0 = (ip6_header_t *) l3h0;
2385           if (PREDICT_FALSE (ethertype0 == ETHERNET_TYPE_IP6 &&
2386                              iph0->protocol == IP_PROTOCOL_ICMP6 &&
2387                              !ip6_address_is_unspecified
2388                              (&iph0->src_address)))
2389             {
2390               sw_if_index0 = vnet_buffer (p0)->sw_if_index[VLIB_RX];
2391               if (vnet_ip6_nd_term
2392                   (vm, node, p0, eth0, iph0, sw_if_index0,
2393                    vnet_buffer (p0)->l2.bd_index))
2394                 goto output_response;
2395             }
2396
2397         next_l2_feature:
2398           {
2399             next0 = vnet_l2_feature_next (p0, arp_term_next_node_index,
2400                                           L2INPUT_FEAT_ARP_TERM);
2401             vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
2402                                              to_next, n_left_to_next,
2403                                              pi0, next0);
2404             continue;
2405           }
2406
2407         drop:
2408           if (0 == arp0->ip4_over_ethernet[0].ip4.as_u32 ||
2409               (arp0->ip4_over_ethernet[0].ip4.as_u32 ==
2410                arp0->ip4_over_ethernet[1].ip4.as_u32))
2411             {
2412               error0 = ETHERNET_ARP_ERROR_gratuitous_arp;
2413             }
2414           next0 = ARP_TERM_NEXT_DROP;
2415           p0->error = node->errors[error0];
2416
2417           vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
2418                                            to_next, n_left_to_next, pi0,
2419                                            next0);
2420         }
2421
2422       vlib_put_next_frame (vm, node, next_index, n_left_to_next);
2423     }
2424
2425   vlib_error_count (vm, node->node_index,
2426                     ETHERNET_ARP_ERROR_replies_sent, n_replies_sent);
2427   return frame->n_vectors;
2428 }
2429
2430 /* *INDENT-OFF* */
2431 VLIB_REGISTER_NODE (arp_term_l2bd_node, static) = {
2432   .function = arp_term_l2bd,
2433   .name = "arp-term-l2bd",
2434   .vector_size = sizeof (u32),
2435   .n_errors = ETHERNET_ARP_N_ERROR,
2436   .error_strings = ethernet_arp_error_strings,
2437   .n_next_nodes = ARP_TERM_N_NEXT,
2438   .next_nodes = {
2439     [ARP_TERM_NEXT_L2_OUTPUT] = "l2-output",
2440     [ARP_TERM_NEXT_DROP] = "error-drop",
2441   },
2442   .format_buffer = format_ethernet_arp_header,
2443   .format_trace = format_arp_term_input_trace,
2444 };
2445 /* *INDENT-ON* */
2446
2447 clib_error_t *
2448 arp_term_init (vlib_main_t * vm)
2449 {
2450   // Initialize the feature next-node indexes
2451   feat_bitmap_init_next_nodes (vm,
2452                                arp_term_l2bd_node.index,
2453                                L2INPUT_N_FEAT,
2454                                l2input_get_feat_names (),
2455                                arp_term_next_node_index);
2456   return 0;
2457 }
2458
2459 VLIB_INIT_FUNCTION (arp_term_init);
2460
2461 void
2462 change_arp_mac (u32 sw_if_index, ethernet_arp_ip4_entry_t * e)
2463 {
2464   if (e->sw_if_index == sw_if_index)
2465     {
2466       adj_nbr_walk_nh4 (e->sw_if_index,
2467                         &e->ip4_address, arp_mk_complete_walk, e);
2468     }
2469 }
2470
2471 void
2472 ethernet_arp_change_mac (u32 sw_if_index)
2473 {
2474   ethernet_arp_main_t *am = &ethernet_arp_main;
2475   ethernet_arp_ip4_entry_t *e;
2476
2477   /* *INDENT-OFF* */
2478   pool_foreach (e, am->ip4_entry_pool,
2479   ({
2480     change_arp_mac (sw_if_index, e);
2481   }));
2482   /* *INDENT-ON* */
2483 }
2484
2485 void static
2486 send_ip4_garp (vlib_main_t * vm, vnet_hw_interface_t * hi)
2487 {
2488   ip4_main_t *i4m = &ip4_main;
2489   u32 sw_if_index = hi->sw_if_index;
2490   ip4_address_t *ip4_addr = ip4_interface_first_address (i4m, sw_if_index, 0);
2491
2492   if (ip4_addr)
2493     {
2494       clib_warning ("Sending GARP for IP4 address %U on sw_if_idex %d",
2495                     format_ip4_address, ip4_addr, sw_if_index);
2496
2497       /* Form GARP packet for output - Gratuitous ARP is an ARP request packet
2498          where the interface IP/MAC pair is used for both source and request
2499          MAC/IP pairs in the request */
2500       u32 bi = 0;
2501       ethernet_arp_header_t *h = vlib_packet_template_get_packet
2502         (vm, &i4m->ip4_arp_request_packet_template, &bi);
2503       clib_memcpy (h->ip4_over_ethernet[0].ethernet, hi->hw_address,
2504                    sizeof (h->ip4_over_ethernet[0].ethernet));
2505       clib_memcpy (h->ip4_over_ethernet[1].ethernet, hi->hw_address,
2506                    sizeof (h->ip4_over_ethernet[1].ethernet));
2507       h->ip4_over_ethernet[0].ip4 = ip4_addr[0];
2508       h->ip4_over_ethernet[1].ip4 = ip4_addr[0];
2509
2510       /* Setup MAC header with ARP Etype and broadcast DMAC */
2511       vlib_buffer_t *b = vlib_get_buffer (vm, bi);
2512       vlib_buffer_advance (b, -sizeof (ethernet_header_t));
2513       ethernet_header_t *e = vlib_buffer_get_current (b);
2514       e->type = clib_host_to_net_u16 (ETHERNET_TYPE_ARP);
2515       clib_memcpy (e->src_address, hi->hw_address, sizeof (e->src_address));
2516       memset (e->dst_address, 0xff, sizeof (e->dst_address));
2517
2518       /* Send GARP packet out the specified interface */
2519       vnet_buffer (b)->sw_if_index[VLIB_RX] =
2520         vnet_buffer (b)->sw_if_index[VLIB_TX] = sw_if_index;
2521       vlib_frame_t *f = vlib_get_frame_to_node (vm, hi->output_node_index);
2522       u32 *to_next = vlib_frame_vector_args (f);
2523       to_next[0] = bi;
2524       f->n_vectors = 1;
2525       vlib_put_frame_to_node (vm, hi->output_node_index, f);
2526     }
2527 }
2528
2529 static vlib_node_registration_t send_garp_na_proc_node;
2530
2531 static uword
2532 send_garp_na_process (vlib_main_t * vm,
2533                       vlib_node_runtime_t * rt, vlib_frame_t * f)
2534 {
2535   vnet_main_t *vnm = vnet_get_main ();
2536   uword event_type, *event_data = 0;
2537
2538   send_garp_na_process_node_index = send_garp_na_proc_node.index;
2539
2540   while (1)
2541     {
2542       vlib_process_wait_for_event (vm);
2543       event_type = vlib_process_get_events (vm, &event_data);
2544       if ((event_type == SEND_GARP_NA) && (vec_len (event_data) >= 1))
2545         {
2546           u32 hw_if_index = event_data[0];
2547           vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
2548           send_ip4_garp (vm, hi);
2549           send_ip6_na (vm, hi);
2550         }
2551       vec_reset_length (event_data);
2552     }
2553   return 0;
2554 }
2555
2556
2557 /* *INDENT-OFF* */
2558 VLIB_REGISTER_NODE (send_garp_na_proc_node, static) = {
2559     .function = send_garp_na_process,
2560     .type = VLIB_NODE_TYPE_PROCESS,
2561     .name = "send-garp-na-process",
2562 };
2563 /* *INDENT-ON* */
2564
2565 /*
2566  * fd.io coding-style-patch-verification: ON
2567  *
2568  * Local Variables:
2569  * eval: (c-set-style "gnu")
2570  * End:
2571  */