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