FD.io VPP  v17.10-9-gd594711
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  uword indent;
207  u16 l2_type, l3_type;
208 
209  if (max_header_bytes != 0 && sizeof (a[0]) > max_header_bytes)
210  return format (s, "ARP header truncated");
211 
212  l2_type = clib_net_to_host_u16 (a->l2_type);
213  l3_type = clib_net_to_host_u16 (a->l3_type);
214 
215  indent = format_get_indent (s);
216 
217  s = format (s, "%U, type %U/%U, address size %d/%d",
218  format_ethernet_arp_opcode, clib_net_to_host_u16 (a->opcode),
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 
1127  send_reply:
1128  /* Send a reply.
1129  An adjacency to the sender is not always present,
1130  so we use the interface to build us a rewrite string
1131  which will contain all the necessary tags. */
1132  rewrite0 = ethernet_build_rewrite (vnm, sw_if_index0,
1133  VNET_LINK_ARP,
1134  eth_rx->src_address);
1135  rewrite0_len = vec_len (rewrite0);
1136 
1137  /* Figure out how much to rewind current data from adjacency. */
1138  vlib_buffer_advance (p0, -rewrite0_len);
1139  eth_tx = vlib_buffer_get_current (p0);
1140 
1141  vnet_buffer (p0)->sw_if_index[VLIB_TX] = sw_if_index0;
1142  hw_if0 = vnet_get_sup_hw_interface (vnm, sw_if_index0);
1143 
1144  /* Send reply back through input interface */
1145  vnet_buffer (p0)->sw_if_index[VLIB_TX] = sw_if_index0;
1146  next0 = ARP_INPUT_NEXT_REPLY_TX;
1147 
1148  arp0->opcode = clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_reply);
1149 
1150  arp0->ip4_over_ethernet[1] = arp0->ip4_over_ethernet[0];
1151 
1152  clib_memcpy (arp0->ip4_over_ethernet[0].ethernet,
1153  hw_if0->hw_address, 6);
1154  clib_mem_unaligned (&arp0->ip4_over_ethernet[0].ip4.data_u32, u32) =
1155  if_addr0->data_u32;
1156 
1157  /* Hardware must be ethernet-like. */
1158  ASSERT (vec_len (hw_if0->hw_address) == 6);
1159 
1160  /* the rx nd tx ethernet headers wil overlap in the case
1161  * when we received a tagged VLAN=0 packet, but we are sending
1162  * back untagged */
1163  clib_memcpy (eth_tx, rewrite0, vec_len (rewrite0));
1164  vec_free (rewrite0);
1165 
1166  if (NULL == pa)
1167  {
1168  if (is_unnum0)
1169  {
1170  if (!arp_unnumbered (p0, sw_if_index0, conn_sw_if_index0))
1171  goto drop2;
1172  }
1173  }
1174 
1175  /* We are going to reply to this request, so, in the absence of
1176  errors, learn the sender */
1177  if (!error0)
1178  error0 = arp_learn (vnm, am, sw_if_index0,
1179  &arp0->ip4_over_ethernet[1]);
1180 
1181  vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
1182  n_left_to_next, pi0, next0);
1183 
1184  n_replies_sent += 1;
1185  continue;
1186 
1187  drop1:
1188  if (0 == arp0->ip4_over_ethernet[0].ip4.as_u32 ||
1189  (arp0->ip4_over_ethernet[0].ip4.as_u32 ==
1190  arp0->ip4_over_ethernet[1].ip4.as_u32))
1191  {
1192  error0 = ETHERNET_ARP_ERROR_gratuitous_arp;
1193  goto drop2;
1194  }
1195  /* See if proxy arp is configured for the address */
1196  if (is_request0)
1197  {
1198  vnet_sw_interface_t *si;
1199  u32 this_addr = clib_net_to_host_u32
1200  (arp0->ip4_over_ethernet[1].ip4.as_u32);
1201  u32 fib_index0;
1202 
1203  si = vnet_get_sw_interface (vnm, sw_if_index0);
1204 
1206  goto drop2;
1207 
1208  fib_index0 = vec_elt (im4->fib_index_by_sw_if_index,
1209  sw_if_index0);
1210 
1211  vec_foreach (pa, am->proxy_arps)
1212  {
1213  u32 lo_addr = clib_net_to_host_u32 (pa->lo_addr);
1214  u32 hi_addr = clib_net_to_host_u32 (pa->hi_addr);
1215 
1216  /* an ARP request hit in the proxy-arp table? */
1217  if ((this_addr >= lo_addr && this_addr <= hi_addr) &&
1218  (fib_index0 == pa->fib_index))
1219  {
1220  proxy_src.as_u32 =
1221  arp0->ip4_over_ethernet[1].ip4.data_u32;
1222 
1223  /*
1224  * change the interface address to the proxied
1225  */
1226  if_addr0 = &proxy_src;
1227  is_unnum0 = 0;
1228  n_proxy_arp_replies_sent++;
1229  goto send_reply;
1230  }
1231  }
1232  }
1233 
1234  drop2:
1235 
1236  next0 = ARP_INPUT_NEXT_DROP;
1237  p0->error = node->errors[error0];
1238 
1239  vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
1240  n_left_to_next, pi0, next0);
1241  }
1242 
1243  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1244  }
1245 
1246  vlib_error_count (vm, node->node_index,
1247  ETHERNET_ARP_ERROR_replies_sent,
1248  n_replies_sent - n_proxy_arp_replies_sent);
1249 
1250  vlib_error_count (vm, node->node_index,
1251  ETHERNET_ARP_ERROR_proxy_arp_replies_sent,
1252  n_proxy_arp_replies_sent);
1253  return frame->n_vectors;
1254 }
1255 
1256 static char *ethernet_arp_error_strings[] = {
1257 #define _(sym,string) string,
1259 #undef _
1260 };
1261 
1262 /* *INDENT-OFF* */
1264 {
1265  .function = arp_input,
1266  .name = "arp-input",
1267  .vector_size = sizeof (u32),
1268  .n_errors = ETHERNET_ARP_N_ERROR,
1269  .error_strings = ethernet_arp_error_strings,
1270  .n_next_nodes = ARP_INPUT_N_NEXT,
1271  .next_nodes = {
1272  [ARP_INPUT_NEXT_DROP] = "error-drop",
1273  [ARP_INPUT_NEXT_REPLY_TX] = "interface-output",
1274  },
1275  .format_buffer = format_ethernet_arp_header,
1276  .format_trace = format_ethernet_arp_input_trace,
1277 };
1278 /* *INDENT-ON* */
1279 
1280 static int
1281 ip4_arp_entry_sort (void *a1, void *a2)
1282 {
1283  ethernet_arp_ip4_entry_t *e1 = a1;
1284  ethernet_arp_ip4_entry_t *e2 = a2;
1285 
1286  int cmp;
1287  vnet_main_t *vnm = vnet_get_main ();
1288 
1289  cmp = vnet_sw_interface_compare (vnm, e1->sw_if_index, e2->sw_if_index);
1290  if (!cmp)
1291  cmp = ip4_address_compare (&e1->ip4_address, &e2->ip4_address);
1292  return cmp;
1293 }
1294 
1297 {
1299  ethernet_arp_ip4_entry_t *n, *ns = 0;
1300 
1301  /* *INDENT-OFF* */
1302  pool_foreach (n, am->ip4_entry_pool, ({
1303  if (sw_if_index != ~0 && n->sw_if_index != sw_if_index)
1304  continue;
1305  vec_add1 (ns, n[0]);
1306  }));
1307  /* *INDENT-ON* */
1308 
1309  if (ns)
1311  return ns;
1312 }
1313 
1314 static clib_error_t *
1316  unformat_input_t * input, vlib_cli_command_t * cmd)
1317 {
1318  vnet_main_t *vnm = vnet_get_main ();
1320  ethernet_arp_ip4_entry_t *e, *es;
1322  clib_error_t *error = 0;
1323  u32 sw_if_index;
1324 
1325  /* Filter entries by interface if given. */
1326  sw_if_index = ~0;
1327  (void) unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index);
1328 
1329  es = ip4_neighbor_entries (sw_if_index);
1330  if (es)
1331  {
1332  vlib_cli_output (vm, "%U", format_ethernet_arp_ip4_entry, vnm, 0);
1333  vec_foreach (e, es)
1334  {
1335  vlib_cli_output (vm, "%U", format_ethernet_arp_ip4_entry, vnm, e);
1336  }
1337  vec_free (es);
1338  }
1339 
1340  if (vec_len (am->proxy_arps))
1341  {
1342  vlib_cli_output (vm, "Proxy arps enabled for:");
1343  vec_foreach (pa, am->proxy_arps)
1344  {
1345  vlib_cli_output (vm, "Fib_index %d %U - %U ",
1346  pa->fib_index,
1348  format_ip4_address, &pa->hi_addr);
1349  }
1350  }
1351 
1352  return error;
1353 }
1354 
1355 /*?
1356  * Display all the IPv4 ARP entries.
1357  *
1358  * @cliexpar
1359  * Example of how to display the IPv4 ARP table:
1360  * @cliexstart{show ip arp}
1361  * Time FIB IP4 Flags Ethernet Interface
1362  * 346.3028 0 6.1.1.3 de:ad:be:ef:ba:be GigabitEthernet2/0/0
1363  * 3077.4271 0 6.1.1.4 S de:ad:be:ef:ff:ff GigabitEthernet2/0/0
1364  * 2998.6409 1 6.2.2.3 de:ad:be:ef:00:01 GigabitEthernet2/0/0
1365  * Proxy arps enabled for:
1366  * Fib_index 0 6.0.0.1 - 6.0.0.11
1367  * @cliexend
1368  ?*/
1369 /* *INDENT-OFF* */
1370 VLIB_CLI_COMMAND (show_ip4_arp_command, static) = {
1371  .path = "show ip arp",
1372  .function = show_ip4_arp,
1373  .short_help = "show ip arp",
1374 };
1375 /* *INDENT-ON* */
1376 
1377 typedef struct
1378 {
1379  pg_edit_t l2_type, l3_type;
1380  pg_edit_t n_l2_address_bytes, n_l3_address_bytes;
1382  struct
1383  {
1386  } ip4_over_ethernet[2];
1388 
1389 static inline void
1391 {
1392  /* Initialize fields that are not bit fields in the IP header. */
1393 #define _(f) pg_edit_init (&p->f, ethernet_arp_header_t, f);
1394  _(l2_type);
1395  _(l3_type);
1396  _(n_l2_address_bytes);
1397  _(n_l3_address_bytes);
1398  _(opcode);
1399  _(ip4_over_ethernet[0].ethernet);
1400  _(ip4_over_ethernet[0].ip4);
1401  _(ip4_over_ethernet[1].ethernet);
1402  _(ip4_over_ethernet[1].ip4);
1403 #undef _
1404 }
1405 
1406 uword
1407 unformat_pg_arp_header (unformat_input_t * input, va_list * args)
1408 {
1409  pg_stream_t *s = va_arg (*args, pg_stream_t *);
1411  u32 group_index;
1412 
1413  p = pg_create_edit_group (s, sizeof (p[0]), sizeof (ethernet_arp_header_t),
1414  &group_index);
1416 
1417  /* Defaults. */
1418  pg_edit_set_fixed (&p->l2_type, ETHERNET_ARP_HARDWARE_TYPE_ethernet);
1419  pg_edit_set_fixed (&p->l3_type, ETHERNET_TYPE_IP4);
1422 
1423  if (!unformat (input, "%U: %U/%U -> %U/%U",
1434  {
1435  /* Free up any edits we may have added. */
1436  pg_free_edit_group (s);
1437  return 0;
1438  }
1439  return 1;
1440 }
1441 
1442 clib_error_t *
1444 {
1446 
1447  am->limit_arp_cache_size = arp_limit;
1448  return 0;
1449 }
1450 
1451 /**
1452  * @brief Control Plane hook to remove an ARP entry
1453  */
1454 int
1456  u32 sw_if_index, void *a_arg)
1457 {
1458  ethernet_arp_ip4_over_ethernet_address_t *a = a_arg;
1460 
1461  args.sw_if_index = sw_if_index;
1463  clib_memcpy (&args.a, a, sizeof (*a));
1464 
1466  (u8 *) & args, sizeof (args));
1467  return 0;
1468 }
1469 
1470 /**
1471  * @brief Internally generated event to flush the ARP cache on an
1472  * interface state change event.
1473  * A flush will remove dynamic ARP entries, and for statics remove the MAC
1474  * address from the corresponding adjacencies.
1475  */
1476 static int
1478  u32 sw_if_index, void *a_arg)
1479 {
1480  ethernet_arp_ip4_over_ethernet_address_t *a = a_arg;
1482 
1483  args.sw_if_index = sw_if_index;
1485  clib_memcpy (&args.a, a, sizeof (*a));
1486 
1488  (u8 *) & args, sizeof (args));
1489  return 0;
1490 }
1491 
1492 /**
1493  * @brief Internally generated event to populate the ARP cache on an
1494  * interface state change event.
1495  * For static entries this will re-source the adjacencies.
1496  *
1497  * @param sw_if_index The interface on which the ARP entires are acted
1498  */
1499 static int
1501  u32 sw_if_index, void *a_arg)
1502 {
1503  ethernet_arp_ip4_over_ethernet_address_t *a = a_arg;
1505 
1506  args.sw_if_index = sw_if_index;
1508  clib_memcpy (&args.a, a, sizeof (*a));
1509 
1511  (u8 *) & args, sizeof (args));
1512  return 0;
1513 }
1514 
1515 /**
1516  * @brief publish wildcard arp event
1517  * @param sw_if_index The interface on which the ARP entires are acted
1518  */
1519 static int
1520 vnet_arp_wc_publish (u32 sw_if_index, void *a_arg)
1521 {
1522  ethernet_arp_ip4_over_ethernet_address_t *a = a_arg;
1525  .sw_if_index = sw_if_index,
1526  .a = *a
1527  };
1528 
1530  (u8 *) & args, sizeof (args));
1531  return 0;
1532 }
1533 
1534 static void
1537  args)
1538 {
1542  uword et = am->wc_ip4_arp_publisher_et;
1543 
1544  if (ni == (uword) ~ 0)
1545  return;
1546  wc_arp_report_t *r =
1547  vlib_process_signal_event_data (vm, ni, et, 1, sizeof *r);
1548  r->ip4 = args->a.ip4.as_u32;
1549  r->sw_if_index = args->sw_if_index;
1550  memcpy (r->mac, args->a.ethernet, sizeof r->mac);
1551 }
1552 
1553 void
1554 wc_arp_set_publisher_node (uword node_index, uword event_type)
1555 {
1557  am->wc_ip4_arp_publisher_node = node_index;
1558  am->wc_ip4_arp_publisher_et = event_type;
1559 }
1560 
1561 /*
1562  * arp_add_del_interface_address
1563  *
1564  * callback when an interface address is added or deleted
1565  */
1566 static void
1568  uword opaque,
1569  u32 sw_if_index,
1570  ip4_address_t * address,
1571  u32 address_length,
1572  u32 if_address_index, u32 is_del)
1573 {
1574  /*
1575  * Flush the ARP cache of all entries covered by the address
1576  * that is being removed.
1577  */
1580 
1581  if (vec_len (am->ethernet_arp_by_sw_if_index) <= sw_if_index)
1582  return;
1583 
1584  if (is_del)
1585  {
1587  u32 i, *to_delete = 0;
1588  hash_pair_t *pair;
1589 
1590  eai = &am->ethernet_arp_by_sw_if_index[sw_if_index];
1591 
1592  /* *INDENT-OFF* */
1593  hash_foreach_pair (pair, eai->arp_entries,
1594  ({
1595  e = pool_elt_at_index(am->ip4_entry_pool,
1596  pair->value[0]);
1597  if (ip4_destination_matches_route (im, &e->ip4_address,
1598  address, address_length))
1599  {
1600  vec_add1 (to_delete, e - am->ip4_entry_pool);
1601  }
1602  }));
1603  /* *INDENT-ON* */
1604 
1605  for (i = 0; i < vec_len (to_delete); i++)
1606  {
1607  ethernet_arp_ip4_over_ethernet_address_t delme;
1608  e = pool_elt_at_index (am->ip4_entry_pool, to_delete[i]);
1609 
1610  clib_memcpy (&delme.ethernet, e->ethernet_address, 6);
1611  delme.ip4.as_u32 = e->ip4_address.as_u32;
1612 
1614  e->sw_if_index, &delme);
1615  }
1616 
1617  vec_free (to_delete);
1618  }
1619 }
1620 
1621 void
1623 {
1625  {
1626  fib_prefix_t pfx = {
1627  .fp_len = 32,
1628  .fp_proto = FIB_PROTOCOL_IP4,
1629  .fp_addr.ip4 = e->ip4_address,
1630  };
1631  u32 fib_index;
1632 
1634 
1635  fib_table_entry_path_remove (fib_index, &pfx,
1637  DPO_PROTO_IP4,
1638  &pfx.fp_addr,
1639  e->sw_if_index, ~0, 1,
1642  }
1643 }
1644 
1645 static void
1647  uword opaque,
1648  u32 sw_if_index, u32 new_fib_index, u32 old_fib_index)
1649 {
1653  hash_pair_t *pair;
1654 
1655  /*
1656  * the IP table that the interface is bound to has changed.
1657  * reinstall all the adj fibs.
1658  */
1659 
1660  if (vec_len (am->ethernet_arp_by_sw_if_index) <= sw_if_index)
1661  return;
1662 
1663  eai = &am->ethernet_arp_by_sw_if_index[sw_if_index];
1664 
1665  /* *INDENT-OFF* */
1666  hash_foreach_pair (pair, eai->arp_entries,
1667  ({
1668  e = pool_elt_at_index(am->ip4_entry_pool,
1669  pair->value[0]);
1670  /*
1671  * remove the adj-fib from the old table and add to the new
1672  */
1673  arp_adj_fib_remove(e, old_fib_index);
1674  arp_adj_fib_add(e, new_fib_index);
1675  }));
1676  /* *INDENT-ON* */
1677 
1678 }
1679 
1680 static clib_error_t *
1682 {
1684  ip4_main_t *im = &ip4_main;
1685  clib_error_t *error;
1686  pg_node_t *pn;
1687 
1688  if ((error = vlib_call_init_function (vm, ethernet_init)))
1689  return error;
1690 
1691  ethernet_register_input_type (vm, ETHERNET_TYPE_ARP, arp_input_node.index);
1692 
1693  pn = pg_get_node (arp_input_node.index);
1695 
1696  am->opcode_by_name = hash_create_string (0, sizeof (uword));
1697 #define _(o) hash_set_mem (am->opcode_by_name, #o, ETHERNET_ARP_OPCODE_##o);
1699 #undef _
1700 
1701  /* $$$ configurable */
1702  am->limit_arp_cache_size = 50000;
1703 
1704  am->pending_resolutions_by_address = hash_create (0, sizeof (uword));
1705  am->mac_changes_by_address = hash_create (0, sizeof (uword));
1706  am->wc_ip4_arp_publisher_node = (uword) ~ 0;
1707 
1708  /* don't trace ARP error packets */
1709  {
1710  vlib_node_runtime_t *rt =
1712 
1713 #define _(a,b) \
1714  vnet_pcap_drop_trace_filter_add_del \
1715  (rt->errors[ETHERNET_ARP_ERROR_##a], \
1716  1 /* is_add */);
1718 #undef _
1719  }
1720 
1723  cb.function_opaque = 0;
1725 
1727  cbt.function = arp_table_bind;
1728  cbt.function_opaque = 0;
1729  vec_add1 (im->table_bind_callbacks, cbt);
1730 
1731  return 0;
1732 }
1733 
1735 
1736 static void
1738 {
1740 
1741  arp_adj_fib_remove (e,
1743  (e->sw_if_index));
1745  pool_put (am->ip4_entry_pool, e);
1746 }
1747 
1748 static inline int
1751  * args)
1752 {
1756 
1757  if (vec_len (am->ethernet_arp_by_sw_if_index) <= args->sw_if_index)
1758  return 0;
1759 
1760  eai = &am->ethernet_arp_by_sw_if_index[args->sw_if_index];
1761 
1762  e = arp_entry_find (eai, &args->a.ip4);
1763 
1764  if (NULL != e)
1765  {
1766  arp_entry_free (eai, e);
1767 
1770  }
1771 
1772  return 0;
1773 }
1774 
1775 static int
1778  * args)
1779 {
1783 
1784  if (vec_len (am->ethernet_arp_by_sw_if_index) <= args->sw_if_index)
1785  return 0;
1786 
1787  eai = &am->ethernet_arp_by_sw_if_index[args->sw_if_index];
1788 
1789  e = arp_entry_find (eai, &args->a.ip4);
1790 
1791  if (NULL != e)
1792  {
1795 
1796  /*
1797  * The difference between flush and unset, is that an unset
1798  * means delete for static and dynamic entries. A flush
1799  * means delete only for dynamic. Flushing is what the DP
1800  * does in response to interface events. unset is only done
1801  * by the control plane.
1802  */
1804  {
1806  }
1808  {
1809  arp_entry_free (eai, e);
1810  }
1811  }
1812  return (0);
1813 }
1814 
1815 static int
1818  * args)
1819 {
1823 
1825  eai = &am->ethernet_arp_by_sw_if_index[args->sw_if_index];
1826 
1827  e = arp_entry_find (eai, &args->a.ip4);
1828 
1829  if (NULL != e)
1830  {
1833  }
1834  return (0);
1835 }
1836 
1837 static void
1839  * a)
1840 {
1842  ASSERT (vlib_get_thread_index () == 0);
1843 
1846  else if (a->flags & ETHERNET_ARP_ARGS_FLUSH)
1848  else if (a->flags & ETHERNET_ARP_ARGS_POPULATE)
1850  else if (a->flags & ETHERNET_ARP_ARGS_WC_PUB)
1852  else
1854 }
1855 
1856 /**
1857  * @brief Invoked when the interface's admin state changes
1858  */
1859 static clib_error_t *
1861  u32 sw_if_index, u32 flags)
1862 {
1865  u32 i, *to_delete = 0;
1866 
1867  /* *INDENT-OFF* */
1868  pool_foreach (e, am->ip4_entry_pool,
1869  ({
1870  if (e->sw_if_index == sw_if_index)
1871  vec_add1 (to_delete,
1872  e - am->ip4_entry_pool);
1873  }));
1874  /* *INDENT-ON* */
1875 
1876  for (i = 0; i < vec_len (to_delete); i++)
1877  {
1878  ethernet_arp_ip4_over_ethernet_address_t delme;
1879  e = pool_elt_at_index (am->ip4_entry_pool, to_delete[i]);
1880 
1881  clib_memcpy (&delme.ethernet, e->ethernet_address, 6);
1882  delme.ip4.as_u32 = e->ip4_address.as_u32;
1883 
1884  if (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP)
1885  {
1887  }
1888  else
1889  {
1891  }
1892 
1893  }
1894  vec_free (to_delete);
1895 
1896  return 0;
1897 }
1898 
1900 
1901 static void
1902 increment_ip4_and_mac_address (ethernet_arp_ip4_over_ethernet_address_t * a)
1903 {
1904  u8 old;
1905  int i;
1906 
1907  for (i = 3; i >= 0; i--)
1908  {
1909  old = a->ip4.as_u8[i];
1910  a->ip4.as_u8[i] += 1;
1911  if (old < a->ip4.as_u8[i])
1912  break;
1913  }
1914 
1915  for (i = 5; i >= 0; i--)
1916  {
1917  old = a->ethernet[i];
1918  a->ethernet[i] += 1;
1919  if (old < a->ethernet[i])
1920  break;
1921  }
1922 }
1923 
1924 int
1926  u32 sw_if_index, void *a_arg,
1927  int is_static, int is_no_fib_entry)
1928 {
1929  ethernet_arp_ip4_over_ethernet_address_t *a = a_arg;
1931 
1932  args.sw_if_index = sw_if_index;
1933  args.is_static = is_static;
1934  args.is_no_fib_entry = is_no_fib_entry;
1935  args.flags = 0;
1936  clib_memcpy (&args.a, a, sizeof (*a));
1937 
1939  (u8 *) & args, sizeof (args));
1940  return 0;
1941 }
1942 
1943 int
1945  ip4_address_t * hi_addr, u32 fib_index, int is_del)
1946 {
1949  u32 found_at_index = ~0;
1950 
1951  vec_foreach (pa, am->proxy_arps)
1952  {
1953  if (pa->lo_addr == lo_addr->as_u32
1954  && pa->hi_addr == hi_addr->as_u32 && pa->fib_index == fib_index)
1955  {
1956  found_at_index = pa - am->proxy_arps;
1957  break;
1958  }
1959  }
1960 
1961  if (found_at_index != ~0)
1962  {
1963  /* Delete, otherwise it's already in the table */
1964  if (is_del)
1965  vec_delete (am->proxy_arps, 1, found_at_index);
1966  return 0;
1967  }
1968  /* delete, no such entry */
1969  if (is_del)
1970  return VNET_API_ERROR_NO_SUCH_ENTRY;
1971 
1972  /* add, not in table */
1973  vec_add2 (am->proxy_arps, pa, 1);
1974  pa->lo_addr = lo_addr->as_u32;
1975  pa->hi_addr = hi_addr->as_u32;
1976  pa->fib_index = fib_index;
1977  return 0;
1978 }
1979 
1980 /*
1981  * Remove any proxy arp entries asdociated with the
1982  * specificed fib.
1983  */
1984 int
1986 {
1989  u32 *entries_to_delete = 0;
1990  u32 fib_index;
1991  int i;
1992 
1993  fib_index = fib_table_find (FIB_PROTOCOL_IP4, fib_id);
1994  if (~0 == fib_index)
1995  return VNET_API_ERROR_NO_SUCH_ENTRY;
1996 
1997  vec_foreach (pa, am->proxy_arps)
1998  {
1999  if (pa->fib_index == fib_index)
2000  {
2001  vec_add1 (entries_to_delete, pa - am->proxy_arps);
2002  }
2003  }
2004 
2005  for (i = 0; i < vec_len (entries_to_delete); i++)
2006  {
2007  vec_delete (am->proxy_arps, 1, entries_to_delete[i]);
2008  }
2009 
2010  vec_free (entries_to_delete);
2011 
2012  return 0;
2013 }
2014 
2015 static clib_error_t *
2017  unformat_input_t * input, vlib_cli_command_t * cmd)
2018 {
2019  vnet_main_t *vnm = vnet_get_main ();
2020  u32 sw_if_index;
2021  ethernet_arp_ip4_over_ethernet_address_t lo_addr, hi_addr, addr;
2022  int addr_valid = 0;
2023  int is_del = 0;
2024  int count = 1;
2025  u32 fib_index = 0;
2026  u32 fib_id;
2027  int is_static = 0;
2028  int is_no_fib_entry = 0;
2029  int is_proxy = 0;
2030 
2031  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2032  {
2033  /* set ip arp TenGigE1/1/0/1 1.2.3.4 aa:bb:... or aabb.ccdd... */
2034  if (unformat (input, "%U %U %U",
2035  unformat_vnet_sw_interface, vnm, &sw_if_index,
2036  unformat_ip4_address, &addr.ip4,
2037  unformat_ethernet_address, &addr.ethernet))
2038  addr_valid = 1;
2039 
2040  else if (unformat (input, "delete") || unformat (input, "del"))
2041  is_del = 1;
2042 
2043  else if (unformat (input, "static"))
2044  is_static = 1;
2045 
2046  else if (unformat (input, "no-fib-entry"))
2047  is_no_fib_entry = 1;
2048 
2049  else if (unformat (input, "count %d", &count))
2050  ;
2051 
2052  else if (unformat (input, "fib-id %d", &fib_id))
2053  {
2054  fib_index = fib_table_find (FIB_PROTOCOL_IP4, fib_id);
2055 
2056  if (~0 == fib_index)
2057  return clib_error_return (0, "fib ID %d doesn't exist\n", fib_id);
2058  }
2059 
2060  else if (unformat (input, "proxy %U - %U",
2061  unformat_ip4_address, &lo_addr.ip4,
2062  unformat_ip4_address, &hi_addr.ip4))
2063  is_proxy = 1;
2064  else
2065  break;
2066  }
2067 
2068  if (is_proxy)
2069  {
2070  (void) vnet_proxy_arp_add_del (&lo_addr.ip4, &hi_addr.ip4,
2071  fib_index, is_del);
2072  return 0;
2073  }
2074 
2075  if (addr_valid)
2076  {
2077  int i;
2078 
2079  for (i = 0; i < count; i++)
2080  {
2081  if (is_del == 0)
2082  {
2083  uword event_type, *event_data = 0;
2084 
2085  /* Park the debug CLI until the arp entry is installed */
2087  (vnm, &addr.ip4, vlib_current_process (vm),
2088  1 /* type */ , 0 /* data */ );
2089 
2091  (vnm, sw_if_index, &addr, is_static, is_no_fib_entry);
2092 
2094  event_type = vlib_process_get_events (vm, &event_data);
2095  vec_reset_length (event_data);
2096  if (event_type != 1)
2097  clib_warning ("event type %d unexpected", event_type);
2098  }
2099  else
2100  vnet_arp_unset_ip4_over_ethernet (vnm, sw_if_index, &addr);
2101 
2103  }
2104  }
2105  else
2106  {
2107  return clib_error_return (0, "unknown input `%U'",
2108  format_unformat_error, input);
2109  }
2110 
2111  return 0;
2112 }
2113 
2114 /* *INDENT-OFF* */
2115 /*?
2116  * Add or delete IPv4 ARP cache entries.
2117  *
2118  * @note 'set ip arp' options (e.g. delete, static, 'fib-id <id>',
2119  * 'count <number>', 'interface ip4_addr mac_addr') can be added in
2120  * any order and combination.
2121  *
2122  * @cliexpar
2123  * @parblock
2124  * Add or delete IPv4 ARP cache entries as follows. MAC Address can be in
2125  * either aa:bb:cc:dd:ee:ff format or aabb.ccdd.eeff format.
2126  * @cliexcmd{set ip arp GigabitEthernet2/0/0 6.0.0.3 dead.beef.babe}
2127  * @cliexcmd{set ip arp delete GigabitEthernet2/0/0 6.0.0.3 de:ad:be:ef:ba:be}
2128  *
2129  * To add or delete an IPv4 ARP cache entry to or from a specific fib
2130  * table:
2131  * @cliexcmd{set ip arp fib-id 1 GigabitEthernet2/0/0 6.0.0.3 dead.beef.babe}
2132  * @cliexcmd{set ip arp fib-id 1 delete GigabitEthernet2/0/0 6.0.0.3 dead.beef.babe}
2133  *
2134  * Add or delete IPv4 static ARP cache entries as follows:
2135  * @cliexcmd{set ip arp static GigabitEthernet2/0/0 6.0.0.3 dead.beef.babe}
2136  * @cliexcmd{set ip arp static delete GigabitEthernet2/0/0 6.0.0.3 dead.beef.babe}
2137  *
2138  * For testing / debugging purposes, the 'set ip arp' command can add or
2139  * delete multiple entries. Supply the 'count N' parameter:
2140  * @cliexcmd{set ip arp count 10 GigabitEthernet2/0/0 6.0.0.3 dead.beef.babe}
2141  * @endparblock
2142  ?*/
2143 VLIB_CLI_COMMAND (ip_arp_add_del_command, static) = {
2144  .path = "set ip arp",
2145  .short_help =
2146  "set ip arp [del] <intfc> <ip-address> <mac-address> [static] [no-fib-entry] [count <count>] [fib-id <fib-id>] [proxy <lo-addr> - <hi-addr>]",
2147  .function = ip_arp_add_del_command_fn,
2148 };
2149 /* *INDENT-ON* */
2150 
2151 static clib_error_t *
2154  input, vlib_cli_command_t * cmd)
2155 {
2156  vnet_main_t *vnm = vnet_get_main ();
2157  u32 sw_if_index;
2158  vnet_sw_interface_t *si;
2159  int enable = 0;
2160  int intfc_set = 0;
2161 
2162  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2163  {
2164  if (unformat (input, "%U", unformat_vnet_sw_interface,
2165  vnm, &sw_if_index))
2166  intfc_set = 1;
2167  else if (unformat (input, "enable") || unformat (input, "on"))
2168  enable = 1;
2169  else if (unformat (input, "disable") || unformat (input, "off"))
2170  enable = 0;
2171  else
2172  break;
2173  }
2174 
2175  if (intfc_set == 0)
2176  return clib_error_return (0, "unknown input '%U'",
2177  format_unformat_error, input);
2178 
2179  si = vnet_get_sw_interface (vnm, sw_if_index);
2180  ASSERT (si);
2181  if (enable)
2183  else
2185 
2186  return 0;
2187 }
2188 
2189 /* *INDENT-OFF* */
2190 /*?
2191  * Enable proxy-arp on an interface. The vpp stack will answer ARP
2192  * requests for the indicated address range. Multiple proxy-arp
2193  * ranges may be provisioned.
2194  *
2195  * @note Proxy ARP as a technology is infamous for blackholing traffic.
2196  * Also, the underlying implementation has not been performance-tuned.
2197  * Avoid creating an unnecessarily large set of ranges.
2198  *
2199  * @cliexpar
2200  * To enable proxy arp on a range of addresses, use:
2201  * @cliexcmd{set ip arp proxy 6.0.0.1 - 6.0.0.11}
2202  * Append 'del' to delete a range of proxy ARP addresses:
2203  * @cliexcmd{set ip arp proxy 6.0.0.1 - 6.0.0.11 del}
2204  * You must then specifically enable proxy arp on individual interfaces:
2205  * @cliexcmd{set interface proxy-arp GigabitEthernet0/8/0 enable}
2206  * To disable proxy arp on an individual interface:
2207  * @cliexcmd{set interface proxy-arp GigabitEthernet0/8/0 disable}
2208  ?*/
2209 VLIB_CLI_COMMAND (set_int_proxy_enable_command, static) = {
2210  .path = "set interface proxy-arp",
2211  .short_help =
2212  "set interface proxy-arp <intfc> [enable|disable]",
2213  .function = set_int_proxy_arp_command_fn,
2214 };
2215 /* *INDENT-ON* */
2216 
2217 
2218 /*
2219  * ARP/ND Termination in a L2 Bridge Domain based on IP4/IP6 to MAC
2220  * hash tables mac_by_ip4 and mac_by_ip6 for each BD.
2221  */
2222 typedef enum
2223 {
2227 } arp_term_next_t;
2228 
2230 
2231 static uword
2233  vlib_node_runtime_t * node, vlib_frame_t * frame)
2234 {
2235  l2input_main_t *l2im = &l2input_main;
2236  u32 n_left_from, next_index, *from, *to_next;
2237  u32 n_replies_sent = 0;
2238  u16 last_bd_index = ~0;
2239  l2_bridge_domain_t *last_bd_config = 0;
2240  l2_input_config_t *cfg0;
2241 
2242  from = vlib_frame_vector_args (frame);
2243  n_left_from = frame->n_vectors;
2244  next_index = node->cached_next_index;
2245 
2246  while (n_left_from > 0)
2247  {
2248  u32 n_left_to_next;
2249 
2250  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
2251 
2252  while (n_left_from > 0 && n_left_to_next > 0)
2253  {
2254  vlib_buffer_t *p0;
2255  ethernet_header_t *eth0;
2256  ethernet_arp_header_t *arp0;
2257  ip6_header_t *iph0;
2258  u8 *l3h0;
2259  u32 pi0, error0, next0, sw_if_index0;
2260  u16 ethertype0;
2261  u16 bd_index0;
2262  u32 ip0;
2263  u8 *macp0;
2264  u8 is_vrrp_reply0;
2265 
2266  pi0 = from[0];
2267  to_next[0] = pi0;
2268  from += 1;
2269  to_next += 1;
2270  n_left_from -= 1;
2271  n_left_to_next -= 1;
2272 
2273  p0 = vlib_get_buffer (vm, pi0);
2274  // Terminate only local (SHG == 0) ARP
2275  if (vnet_buffer (p0)->l2.shg != 0)
2276  goto next_l2_feature;
2277 
2278  eth0 = vlib_buffer_get_current (p0);
2279  l3h0 = (u8 *) eth0 + vnet_buffer (p0)->l2.l2_len;
2280  ethertype0 = clib_net_to_host_u16 (*(u16 *) (l3h0 - 2));
2281  arp0 = (ethernet_arp_header_t *) l3h0;
2282 
2283  if (PREDICT_FALSE ((ethertype0 != ETHERNET_TYPE_ARP) ||
2284  (arp0->opcode !=
2285  clib_host_to_net_u16
2286  (ETHERNET_ARP_OPCODE_request))))
2287  goto check_ip6_nd;
2288 
2289  /* Must be ARP request packet here */
2290  if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) &&
2291  (p0->flags & VLIB_BUFFER_IS_TRACED)))
2292  {
2293  u8 *t0 = vlib_add_trace (vm, node, p0,
2294  sizeof (ethernet_arp_input_trace_t));
2295  clib_memcpy (t0, l3h0, sizeof (ethernet_arp_input_trace_t));
2296  }
2297 
2298  error0 = ETHERNET_ARP_ERROR_replies_sent;
2299  error0 =
2300  (arp0->l2_type !=
2301  clib_net_to_host_u16 (ETHERNET_ARP_HARDWARE_TYPE_ethernet)
2302  ? ETHERNET_ARP_ERROR_l2_type_not_ethernet : error0);
2303  error0 =
2304  (arp0->l3_type !=
2305  clib_net_to_host_u16 (ETHERNET_TYPE_IP4) ?
2306  ETHERNET_ARP_ERROR_l3_type_not_ip4 : error0);
2307 
2308  sw_if_index0 = vnet_buffer (p0)->sw_if_index[VLIB_RX];
2309 
2310  if (error0)
2311  goto drop;
2312 
2313  is_vrrp_reply0 =
2314  ((arp0->opcode ==
2315  clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_reply))
2316  &&
2317  (!memcmp
2318  (arp0->ip4_over_ethernet[0].ethernet, vrrp_prefix,
2319  sizeof (vrrp_prefix))));
2320 
2321  /* Trash ARP packets whose ARP-level source addresses do not
2322  match their L2-frame-level source addresses, unless it's
2323  a reply from a VRRP virtual router */
2324  if (PREDICT_FALSE
2325  (memcmp (eth0->src_address, arp0->ip4_over_ethernet[0].ethernet,
2326  sizeof (eth0->src_address)) && !is_vrrp_reply0))
2327  {
2328  error0 = ETHERNET_ARP_ERROR_l2_address_mismatch;
2329  goto drop;
2330  }
2331 
2332  /* Check if anyone want ARP request events for L2 BDs */
2333  {
2335  if (am->wc_ip4_arp_publisher_node != (uword) ~ 0)
2336  vnet_arp_wc_publish (sw_if_index0, &arp0->ip4_over_ethernet[0]);
2337  }
2338 
2339  /* lookup BD mac_by_ip4 hash table for MAC entry */
2340  ip0 = arp0->ip4_over_ethernet[1].ip4.as_u32;
2341  bd_index0 = vnet_buffer (p0)->l2.bd_index;
2342  if (PREDICT_FALSE ((bd_index0 != last_bd_index)
2343  || (last_bd_index == (u16) ~ 0)))
2344  {
2345  last_bd_index = bd_index0;
2346  last_bd_config = vec_elt_at_index (l2im->bd_configs, bd_index0);
2347  }
2348  macp0 = (u8 *) hash_get (last_bd_config->mac_by_ip4, ip0);
2349 
2350  if (PREDICT_FALSE (!macp0))
2351  goto next_l2_feature; /* MAC not found */
2352 
2353  /* MAC found, send ARP reply -
2354  Convert ARP request packet to ARP reply */
2355  arp0->opcode = clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_reply);
2356  arp0->ip4_over_ethernet[1] = arp0->ip4_over_ethernet[0];
2357  arp0->ip4_over_ethernet[0].ip4.as_u32 = ip0;
2358  clib_memcpy (arp0->ip4_over_ethernet[0].ethernet, macp0, 6);
2359  clib_memcpy (eth0->dst_address, eth0->src_address, 6);
2360  clib_memcpy (eth0->src_address, macp0, 6);
2361  n_replies_sent += 1;
2362 
2363  output_response:
2364  /* For BVI, need to use l2-fwd node to send ARP reply as
2365  l2-output node cannot output packet to BVI properly */
2366  cfg0 = vec_elt_at_index (l2im->configs, sw_if_index0);
2367  if (PREDICT_FALSE (cfg0->bvi))
2368  {
2369  vnet_buffer (p0)->l2.feature_bitmap |= L2INPUT_FEAT_FWD;
2370  vnet_buffer (p0)->sw_if_index[VLIB_RX] = 0;
2371  goto next_l2_feature;
2372  }
2373 
2374  /* Send ARP/ND reply back out input interface through l2-output */
2375  vnet_buffer (p0)->sw_if_index[VLIB_TX] = sw_if_index0;
2376  next0 = ARP_TERM_NEXT_L2_OUTPUT;
2377  vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
2378  to_next, n_left_to_next, pi0,
2379  next0);
2380  continue;
2381 
2382  check_ip6_nd:
2383  /* IP6 ND event notification or solicitation handling to generate
2384  local response instead of flooding */
2385  iph0 = (ip6_header_t *) l3h0;
2386  if (PREDICT_FALSE (ethertype0 == ETHERNET_TYPE_IP6 &&
2387  iph0->protocol == IP_PROTOCOL_ICMP6 &&
2389  (&iph0->src_address)))
2390  {
2391  sw_if_index0 = vnet_buffer (p0)->sw_if_index[VLIB_RX];
2392  if (vnet_ip6_nd_term
2393  (vm, node, p0, eth0, iph0, sw_if_index0,
2394  vnet_buffer (p0)->l2.bd_index))
2395  goto output_response;
2396  }
2397 
2398  next_l2_feature:
2399  {
2401  L2INPUT_FEAT_ARP_TERM);
2402  vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
2403  to_next, n_left_to_next,
2404  pi0, next0);
2405  continue;
2406  }
2407 
2408  drop:
2409  if (0 == arp0->ip4_over_ethernet[0].ip4.as_u32 ||
2410  (arp0->ip4_over_ethernet[0].ip4.as_u32 ==
2411  arp0->ip4_over_ethernet[1].ip4.as_u32))
2412  {
2413  error0 = ETHERNET_ARP_ERROR_gratuitous_arp;
2414  }
2415  next0 = ARP_TERM_NEXT_DROP;
2416  p0->error = node->errors[error0];
2417 
2418  vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
2419  to_next, n_left_to_next, pi0,
2420  next0);
2421  }
2422 
2423  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
2424  }
2425 
2426  vlib_error_count (vm, node->node_index,
2427  ETHERNET_ARP_ERROR_replies_sent, n_replies_sent);
2428  return frame->n_vectors;
2429 }
2430 
2431 /* *INDENT-OFF* */
2433  .function = arp_term_l2bd,
2434  .name = "arp-term-l2bd",
2435  .vector_size = sizeof (u32),
2436  .n_errors = ETHERNET_ARP_N_ERROR,
2437  .error_strings = ethernet_arp_error_strings,
2438  .n_next_nodes = ARP_TERM_N_NEXT,
2439  .next_nodes = {
2440  [ARP_TERM_NEXT_L2_OUTPUT] = "l2-output",
2441  [ARP_TERM_NEXT_DROP] = "error-drop",
2442  },
2443  .format_buffer = format_ethernet_arp_header,
2444  .format_trace = format_arp_term_input_trace,
2445 };
2446 /* *INDENT-ON* */
2447 
2448 clib_error_t *
2450 {
2451  // Initialize the feature next-node indexes
2453  arp_term_l2bd_node.index,
2457  return 0;
2458 }
2459 
2461 
2462 void
2464 {
2465  if (e->sw_if_index == sw_if_index)
2466  {
2469  }
2470 }
2471 
2472 void
2474 {
2477 
2478  /* *INDENT-OFF* */
2479  pool_foreach (e, am->ip4_entry_pool,
2480  ({
2481  change_arp_mac (sw_if_index, e);
2482  }));
2483  /* *INDENT-ON* */
2484 }
2485 
2486 void
2488 {
2489  ip4_main_t *i4m = &ip4_main;
2490  u32 sw_if_index = hi->sw_if_index;
2491  ip4_address_t *ip4_addr = ip4_interface_first_address (i4m, sw_if_index, 0);
2492 
2493  if (ip4_addr)
2494  {
2495  clib_warning ("Sending GARP for IP4 address %U on sw_if_idex %d",
2496  format_ip4_address, ip4_addr, sw_if_index);
2497 
2498  /* Form GARP packet for output - Gratuitous ARP is an ARP request packet
2499  where the interface IP/MAC pair is used for both source and request
2500  MAC/IP pairs in the request */
2501  u32 bi = 0;
2503  (vm, &i4m->ip4_arp_request_packet_template, &bi);
2504  clib_memcpy (h->ip4_over_ethernet[0].ethernet, hi->hw_address,
2505  sizeof (h->ip4_over_ethernet[0].ethernet));
2506  clib_memcpy (h->ip4_over_ethernet[1].ethernet, hi->hw_address,
2507  sizeof (h->ip4_over_ethernet[1].ethernet));
2508  h->ip4_over_ethernet[0].ip4 = ip4_addr[0];
2509  h->ip4_over_ethernet[1].ip4 = ip4_addr[0];
2510 
2511  /* Setup MAC header with ARP Etype and broadcast DMAC */
2512  vlib_buffer_t *b = vlib_get_buffer (vm, bi);
2513  vlib_buffer_advance (b, -sizeof (ethernet_header_t));
2515  e->type = clib_host_to_net_u16 (ETHERNET_TYPE_ARP);
2516  clib_memcpy (e->src_address, hi->hw_address, sizeof (e->src_address));
2517  memset (e->dst_address, 0xff, sizeof (e->dst_address));
2518 
2519  /* Send GARP packet out the specified interface */
2520  vnet_buffer (b)->sw_if_index[VLIB_RX] =
2521  vnet_buffer (b)->sw_if_index[VLIB_TX] = sw_if_index;
2523  u32 *to_next = vlib_frame_vector_args (f);
2524  to_next[0] = bi;
2525  f->n_vectors = 1;
2527  }
2528 }
2529 
2530 /*
2531  * fd.io coding-style-patch-verification: ON
2532  *
2533  * Local Variables:
2534  * eval: (c-set-style "gnu")
2535  * End:
2536  */
#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:1838
#define VNET_SW_INTERFACE_FLAG_UNNUMBERED
Definition: interface.h:579
vmrglw vmrglh hi
#define pool_next_index(P, I)
Return next occupied pool index after i, useful for safe iteration.
Definition: pool.h:466
#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:2232
#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:375
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:1407
static void pg_ethernet_arp_header_init(pg_ethernet_arp_header_t *p)
Definition: arp.c:1390
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:1749
static void increment_ip4_and_mac_address(ethernet_arp_ip4_over_ethernet_address_t *a)
Definition: arp.c:1902
An indication that the rewrite is complete, i.e.
Definition: adj_nbr.h:98
vnet_main_t * vnet_get_main(void)
Definition: misc.c:46
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:1567
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:1315
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:1547
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:355
#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:684
IP unicast adjacency.
Definition: adj.h:174
Information related to the source of a FIB entry.
Definition: fib_entry.h:284
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:2463
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:2152
clib_error_t * ip4_set_arp_limit(u32 arp_limit)
Definition: arp.c:1443
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:1127
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:1646
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
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:1379
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:1520
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:1517
vlib_error_t * errors
Vector of errors for this node.
Definition: node.h:415
Definition: fib_entry.h:230
#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:1384
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:1816
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:1622
u32 ip4_fib_table_get_index_for_sw_if_index(u32 sw_if_index)
Definition: ip4_fib.c:223
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:1380
u8 * format_ethernet_address(u8 *s, va_list *args)
Definition: format.c:44
#define VNET_SW_INTERFACE_FLAG_PROXY_ARP
Definition: interface.h:577
void * vlib_packet_template_get_packet(vlib_main_t *vm, vlib_packet_template_t *t, u32 *bi_result)
Definition: buffer.c:834
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:437
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
static uword format_get_indent(u8 *s)
Definition: format.h:72
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:1281
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:160
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:1477
#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:1025
u16 fp_len
The mask length.
Definition: fib_types.h:164
#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:1455
#define hash_create_string(elts, value_bytes)
Definition: hash.h:652
pg_edit_t l3_type
Definition: arp.c:1379
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:233
#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:458
static ethernet_header_t * ethernet_buffer_get_header(vlib_buffer_t *b)
Definition: ethernet.h:346
#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:92
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:183
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:2487
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:193
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:270
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:97
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:1681
#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:216
#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:1177
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:1353
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:2016
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:290
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:1380
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:1256
#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:69
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:1554
u32 fib_node_index_t
A typedef of a node index.
Definition: fib_types.h:28
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:1860
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:1944
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:1206
#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:2449
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:658
#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:572
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:2229
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:95
The default route source.
Definition: fib_entry.h:121
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:206
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:40
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:664
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:1333
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:2432
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:1263
#define FIB_NODE_INDEX_INVALID
Definition: fib_types.h:29
int vnet_proxy_arp_fib_reset(u32 fib_id)
Definition: arp.c:1985
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:349
Definition: fib_entry.h:229
#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:1776
vnet_sw_interface_t * sw_interfaces
Definition: interface.h:659
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:1737
pg_edit_t opcode
Definition: arp.c:1381
#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:2222
static void vnet_arp_wc_publish_internal(vnet_main_t *vnm, vnet_arp_set_ip4_over_ethernet_rpc_args_t *args)
Definition: arp.c:1535
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:306
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:143
ip4_main_t ip4_main
Global ip4 main structure.
Definition: ip4_forward.c:1175
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
struct pg_ethernet_arp_header_t::@100 ip4_over_ethernet[2]
ethernet_arp_ip4_entry_t * ip4_neighbor_entries(u32 sw_if_index)
Definition: arp.c:1296
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:1925
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:1500
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:2473
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:504
fib_entry_flag_t fib_entry_get_flags(fib_node_index_t fib_entry_index)
Definition: fib_entry.c:267
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:218
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:128