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