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