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