FD.io VPP  v19.08-27-gf4dcae4
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/ip_neighbor.h>
20 #include <vnet/ip/ip6.h>
21 #include <vnet/ethernet/ethernet.h>
22 #include <vnet/ethernet/arp.h>
23 #include <vnet/l2/l2_input.h>
24 #include <vppinfra/mhash.h>
25 #include <vnet/fib/ip4_fib.h>
26 #include <vnet/fib/fib_entry_src.h>
27 #include <vnet/adj/adj_nbr.h>
28 #include <vnet/adj/adj_mcast.h>
29 #include <vnet/mpls/mpls.h>
30 #include <vnet/l2/feat_bitmap.h>
31 
32 #include <vlibmemory/api.h>
33 
34 /**
35  * @file
36  * @brief IPv4 ARP.
37  *
38  * This file contains code to manage the IPv4 ARP tables (IP Address
39  * to MAC Address lookup).
40  */
41 
42 
43 /**
44  * @brief Per-interface ARP configuration and state
45  */
47 {
48  /**
49  * Hash table of ARP entries.
50  * Since this hash table is per-interface, the key is only the IPv4 address.
51  */
53  /**
54  * Is ARP enabled on this interface
55  */
57  /**
58  * Is Proxy ARP enabled on this interface
59  */
62 
63 typedef struct
64 {
69 
70 typedef struct
71 {
76  /* Used for arp event notification only */
80 
81 typedef struct
82 {
83  /* Hash tables mapping name to opcode. */
85 
86  /* lite beer "glean" adjacency handling */
89 
90  /* Mac address change notification */
93 
95 
96  /* ARP attack mitigation */
99 
100  /** Per interface state */
102 
103  /* Proxy arp vector */
105 
108 
109  /* ARP feature arc index */
112 
114 
115 typedef struct
116 {
122 #define ETHERNET_ARP_ARGS_REMOVE (1<<0)
123 #define ETHERNET_ARP_ARGS_FLUSH (1<<1)
124 #define ETHERNET_ARP_ARGS_POPULATE (1<<2)
125 #define ETHERNET_ARP_ARGS_WC_PUB (1<<3)
127 
128 static const u8 vrrp_prefix[] = { 0x00, 0x00, 0x5E, 0x00, 0x01 };
129 
130 /* Node index for send_garp_na_process */
132 
133 static void
135  * a);
136 
137 static u8 *
139 {
141  char *t = 0;
142  switch (h)
143  {
144 #define _(n,f) case n: t = #f; break;
146 #undef _
147 
148  default:
149  return format (s, "unknown 0x%x", h);
150  }
151 
152  return format (s, "%s", t);
153 }
154 
155 static u8 *
156 format_ethernet_arp_opcode (u8 * s, va_list * va)
157 {
159  char *t = 0;
160  switch (o)
161  {
162 #define _(f) case ETHERNET_ARP_OPCODE_##f: t = #f; break;
164 #undef _
165 
166  default:
167  return format (s, "unknown 0x%x", o);
168  }
169 
170  return format (s, "%s", t);
171 }
172 
173 static uword
175  va_list * args)
176 {
177  int *result = va_arg (*args, int *);
179  int x, i;
180 
181  /* Numeric opcode. */
182  if (unformat (input, "0x%x", &x) || unformat (input, "%d", &x))
183  {
184  if (x >= (1 << 16))
185  return 0;
186  *result = x;
187  return 1;
188  }
189 
190  /* Named type. */
192  am->opcode_by_name, &i))
193  {
194  *result = i;
195  return 1;
196  }
197 
198  return 0;
199 }
200 
201 static uword
203  va_list * args)
204 {
205  int *result = va_arg (*args, int *);
206  if (!unformat_user
208  return 0;
209 
210  *result = clib_host_to_net_u16 ((u16) * result);
211  return 1;
212 }
213 
214 static u8 *
215 format_ethernet_arp_header (u8 * s, va_list * va)
216 {
217  ethernet_arp_header_t *a = va_arg (*va, ethernet_arp_header_t *);
218  u32 max_header_bytes = va_arg (*va, u32);
219  u32 indent;
220  u16 l2_type, l3_type;
221 
222  if (max_header_bytes != 0 && sizeof (a[0]) > max_header_bytes)
223  return format (s, "ARP header truncated");
224 
225  l2_type = clib_net_to_host_u16 (a->l2_type);
226  l3_type = clib_net_to_host_u16 (a->l3_type);
227 
228  indent = format_get_indent (s);
229 
230  s = format (s, "%U, type %U/%U, address size %d/%d",
231  format_ethernet_arp_opcode, clib_net_to_host_u16 (a->opcode),
233  format_ethernet_type, l3_type,
235 
236  if (l2_type == ETHERNET_ARP_HARDWARE_TYPE_ethernet
237  && l3_type == ETHERNET_TYPE_IP4)
238  {
239  s = format (s, "\n%U%U/%U -> %U/%U",
240  format_white_space, indent,
245  }
246  else
247  {
248  uword n2 = a->n_l2_address_bytes;
249  uword n3 = a->n_l3_address_bytes;
250  s = format (s, "\n%U%U/%U -> %U/%U",
251  format_white_space, indent,
252  format_hex_bytes, a->data + 0 * n2 + 0 * n3, n2,
253  format_hex_bytes, a->data + 1 * n2 + 0 * n3, n3,
254  format_hex_bytes, a->data + 1 * n2 + 1 * n3, n2,
255  format_hex_bytes, a->data + 2 * n2 + 1 * n3, n3);
256  }
257 
258  return s;
259 }
260 
261 u8 *
263 {
264  vnet_main_t *vnm = va_arg (*va, vnet_main_t *);
267 
268  if (!e)
269  return format (s, "%=12s%=16s%=6s%=20s%=24s", "Time", "IP4",
270  "Flags", "Ethernet", "Interface");
271 
272  si = vnet_get_sw_interface (vnm, e->sw_if_index);
273 
274  return format (s, "%=12U%=16U%=6U%=20U%U",
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;
328  vlib_buffer_t *b;
329  vlib_main_t *vm;
330  u32 bi = 0;
331 
332  vm = vlib_get_main ();
333 
334  si = vnet_get_sw_interface (vnm, adj->rewrite_header.sw_if_index);
335 
337  {
338  return;
339  }
340 
341  src =
343  &adj->sub_type.nbr.next_hop.
344  ip4,
345  adj->rewrite_header.
346  sw_if_index, &ia);
347  if (!src)
348  {
349  return;
350  }
351 
352  h =
354  &bi);
355  if (!h)
356  return;
357 
358  hi = vnet_get_sup_hw_interface (vnm, adj->rewrite_header.sw_if_index);
359 
361 
362  h->ip4_over_ethernet[0].ip4 = src[0];
363  h->ip4_over_ethernet[1].ip4 = adj->sub_type.nbr.next_hop.ip4;
364 
365  b = vlib_get_buffer (vm, bi);
366  vnet_buffer (b)->sw_if_index[VLIB_RX] =
367  vnet_buffer (b)->sw_if_index[VLIB_TX] = adj->rewrite_header.sw_if_index;
368 
369  /* Add encapsulation string for software interface (e.g. ethernet header). */
370  vnet_rewrite_one_header (adj[0], h, sizeof (ethernet_header_t));
371  vlib_buffer_advance (b, -adj->rewrite_header.data_bytes);
372 
373  {
375  u32 *to_next = vlib_frame_vector_args (f);
376  to_next[0] = bi;
377  f->n_vectors = 1;
379  }
380 }
381 
382 static void
384 {
388  e->sw_if_index,
389  adj_get_link_type (ai), &e->mac));
390 }
391 
392 static void
394 {
395  ip_adjacency_t *adj = adj_get (ai);
396 
398  (ai,
401  adj->rewrite_header.sw_if_index,
404 }
405 
408 {
411  uword *p;
412 
413  if (NULL != eai->arp_entries)
414  {
415  p = hash_get (eai->arp_entries, addr->as_u32);
416  if (!p)
417  return (NULL);
418 
419  e = pool_elt_at_index (am->ip4_entry_pool, p[0]);
420  }
421 
422  return (e);
423 }
424 
425 static adj_walk_rc_t
427 {
429 
430  arp_mk_complete (ai, e);
431 
432  return (ADJ_WALK_RC_CONTINUE);
433 }
434 
435 static adj_walk_rc_t
437 {
438  arp_mk_incomplete (ai);
439 
440  return (ADJ_WALK_RC_CONTINUE);
441 }
442 
443 static int
445 {
446  if (vec_len (am->ethernet_arp_by_sw_if_index) <= sw_if_index)
447  return 0;
448 
449  return (am->ethernet_arp_by_sw_if_index[sw_if_index].enabled);
450 }
451 
452 static void
454 {
455  if (arp_is_enabled (am, sw_if_index))
456  return;
457 
458  vec_validate (am->ethernet_arp_by_sw_if_index, sw_if_index);
459 
461 
462  vnet_feature_enable_disable ("arp", "arp-reply", sw_if_index, 1, NULL, 0);
463  vnet_feature_enable_disable ("arp", "arp-disabled", sw_if_index, 0, NULL,
464  0);
465 }
466 
467 static int
470  * args);
471 
472 static void
474 {
477  u32 i, *to_delete = 0;
478  hash_pair_t *pair;
479 
480  if (!arp_is_enabled (am, sw_if_index))
481  return;
482 
483  vnet_feature_enable_disable ("arp", "arp-disabled", sw_if_index, 1, NULL,
484  0);
485  vnet_feature_enable_disable ("arp", "arp-reply", sw_if_index, 0, NULL, 0);
486 
488 
489 
490  /* *INDENT-OFF* */
491  hash_foreach_pair (pair, eai->arp_entries,
492  ({
493  e = pool_elt_at_index(am->ip4_entry_pool,
494  pair->value[0]);
495  vec_add1 (to_delete, e - am->ip4_entry_pool);
496  }));
497  /* *INDENT-ON* */
498 
499  for (i = 0; i < vec_len (to_delete); i++)
500  {
501  e = pool_elt_at_index (am->ip4_entry_pool, to_delete[i]);
502 
505  .sw_if_index = e->sw_if_index,
506  .flags = ETHERNET_ARP_ARGS_FLUSH,
507  };
508  mac_address_copy (&delme.mac, &e->mac);
509 
511  }
512 
513  vec_free (to_delete);
514 
515  eai->enabled = 0;
516 }
517 
518 void
520 {
522  ethernet_arp_interface_t *arp_int;
524  ip_adjacency_t *adj;
525 
526  adj = adj_get (ai);
527 
528  arp_enable (am, sw_if_index);
530  e = arp_entry_find (arp_int, &adj->sub_type.nbr.next_hop.ip4);
531 
532  switch (adj->lookup_next_index)
533  {
536  break;
537  case IP_LOOKUP_NEXT_ARP:
538  if (NULL != e)
539  {
540  adj_nbr_walk_nh4 (sw_if_index,
542  }
543  else
544  {
545  /*
546  * no matching ARP entry.
547  * construct the rewrite required to for an ARP packet, and stick
548  * that in the adj's pipe to smoke.
549  */
551  (ai,
554  (vnm,
555  sw_if_index,
558 
559  /*
560  * since the FIB has added this adj for a route, it makes sense it
561  * may want to forward traffic sometime soon. Let's send a
562  * speculative ARP. just one. If we were to do periodically that
563  * wouldn't be bad either, but that's more code than i'm prepared to
564  * write at this time for relatively little reward.
565  */
566  arp_nbr_probe (adj);
567  }
568  break;
573  (vnm,
574  sw_if_index,
577  break;
579  {
580  /*
581  * Construct a partial rewrite from the known ethernet mcast dest MAC
582  */
583  u8 *rewrite;
584  u8 offset;
585 
586  rewrite = ethernet_build_rewrite (vnm,
587  sw_if_index,
588  adj->ia_link,
590  offset = vec_len (rewrite) - 2;
591 
592  /*
593  * Complete the remaining fields of the adj's rewrite to direct the
594  * complete of the rewrite at switch time by copying in the IP
595  * dst address's bytes.
596  * Offset is 2 bytes into the MAC destination address.
597  */
598  adj_mcast_update_rewrite (ai, rewrite, offset);
599 
600  break;
601  }
602  case IP_LOOKUP_NEXT_DROP:
603  case IP_LOOKUP_NEXT_PUNT:
609  case IP_LOOKUP_N_NEXT:
610  ASSERT (0);
611  break;
612  }
613 }
614 
615 static void
617 {
618  fib_prefix_t pfx = {
619  .fp_len = 32,
620  .fp_proto = FIB_PROTOCOL_IP4,
621  .fp_addr.ip4 = e->ip4_address,
622  };
623 
624  e->fib_entry_index =
625  fib_table_entry_path_add (fib_index, &pfx, FIB_SOURCE_ADJ,
627  DPO_PROTO_IP4, &pfx.fp_addr,
628  e->sw_if_index, ~0, 1, NULL,
631 }
632 
633 static void
635 {
637  {
638  fib_prefix_t pfx = {
639  .fp_len = 32,
640  .fp_proto = FIB_PROTOCOL_IP4,
641  .fp_addr.ip4 = e->ip4_address,
642  };
643  u32 fib_index;
644 
646 
647  fib_table_entry_path_remove (fib_index, &pfx,
650  &pfx.fp_addr,
651  e->sw_if_index, ~0, 1,
654  }
655 }
656 
659 {
662  u32 count = 0;
664  if (index == ~0) /* Try again from elt 0 */
665  index = pool_next_index (am->ip4_entry_pool, index);
666 
667  /* Find a non-static random entry to free up for reuse */
668  do
669  {
670  if ((count++ == 100) || (index == ~0))
671  return NULL; /* give up after 100 entries */
672  e = pool_elt_at_index (am->ip4_entry_pool, index);
673  am->arp_delete_rotor = index;
674  index = pool_next_index (am->ip4_entry_pool, index);
675  }
676  while (e->flags & IP_NEIGHBOR_FLAG_STATIC);
677 
678  /* Remove ARP entry from its interface and update fib */
679  hash_unset
681  e->ip4_address.as_u32);
686  return e;
687 }
688 
689 static int
692  * args)
693 {
697  int make_new_arp_cache_entry = 1;
698  uword *p;
699  pending_resolution_t *pr, *mc;
700  ethernet_arp_interface_t *arp_int;
701  u32 sw_if_index = args->sw_if_index;
702 
703  arp_enable (am, sw_if_index);
704 
706 
707  if (NULL != arp_int->arp_entries)
708  {
709  p = hash_get (arp_int->arp_entries, args->ip4.as_u32);
710  if (p)
711  {
712  e = pool_elt_at_index (am->ip4_entry_pool, p[0]);
713 
714  /* Refuse to over-write static arp. */
715  if (!(args->nbr_flags & IP_NEIGHBOR_FLAG_STATIC) &&
717  {
718  /* if MAC address match, still check to send event */
719  if (mac_address_equal (&e->mac, &args->mac))
720  goto check_customers;
721  return -2;
722  }
723  make_new_arp_cache_entry = 0;
724  }
725  }
726 
727  if (make_new_arp_cache_entry)
728  {
729  if (am->limit_arp_cache_size &&
731  {
732  e = force_reuse_arp_entry ();
733  if (NULL == e)
734  return -2;
735  }
736  else
737  pool_get (am->ip4_entry_pool, e);
738 
739  if (NULL == arp_int->arp_entries)
740  arp_int->arp_entries = hash_create (0, sizeof (u32));
741 
742  hash_set (arp_int->arp_entries, args->ip4.as_u32,
743  e - am->ip4_entry_pool);
744 
746  e->ip4_address = args->ip4;
748  mac_address_copy (&e->mac, &args->mac);
749 
751  {
752  arp_adj_fib_add (e,
754  (e->sw_if_index));
755  }
756  else
757  {
759  }
760  }
761  else
762  {
763  /*
764  * prevent a DoS attack from the data-plane that
765  * spams us with no-op updates to the MAC address
766  */
767  if (mac_address_equal (&e->mac, &args->mac))
768  {
770  goto check_customers;
771  }
772 
773  /* Update ethernet address. */
774  mac_address_copy (&e->mac, &args->mac);
775  }
776 
777  /* Update time stamp and flags. */
780  {
783  }
784  else
785  {
788  }
789 
790  adj_nbr_walk_nh4 (sw_if_index, &e->ip4_address, arp_mk_complete_walk, e);
791 
792 check_customers:
793  /* Customer(s) waiting for this address to be resolved? */
795  if (p)
796  {
797  u32 next_index;
798  next_index = p[0];
799 
800  while (next_index != (u32) ~ 0)
801  {
802  pr = pool_elt_at_index (am->pending_resolutions, next_index);
804  pr->type_opaque, pr->data);
805  next_index = pr->next_index;
806  pool_put (am->pending_resolutions, pr);
807  }
808 
810  }
811 
812  /* Customer(s) requesting ARP event for this address? */
813  p = hash_get (am->mac_changes_by_address, args->ip4.as_u32);
814  if (p)
815  {
816  u32 next_index;
817  next_index = p[0];
818 
819  while (next_index != (u32) ~ 0)
820  {
821  int rv = 1;
822  mc = pool_elt_at_index (am->mac_changes, next_index);
823 
824  /* Call the user's data callback, return 1 to suppress dup events */
825  if (mc->data_callback)
826  rv = (mc->data_callback) (mc->data, &args->mac, sw_if_index, 0);
827 
828  /*
829  * Signal the resolver process, as long as the user
830  * says they want to be notified
831  */
832  if (rv == 0)
834  mc->type_opaque, mc->data);
835  next_index = mc->next_index;
836  }
837  }
838 
839  return 0;
840 }
841 
842 void
844  void *address_arg,
845  uword node_index,
846  uword type_opaque, uword data)
847 {
849  ip4_address_t *address = address_arg;
850  uword *p;
852 
853  pool_get (am->pending_resolutions, pr);
854 
855  pr->next_index = ~0;
856  pr->node_index = node_index;
857  pr->type_opaque = type_opaque;
858  pr->data = data;
859  pr->data_callback = 0;
860 
861  p = hash_get (am->pending_resolutions_by_address, address->as_u32);
862  if (p)
863  {
864  /* Insert new resolution at the head of the list */
865  pr->next_index = p[0];
867  }
868 
870  pr - am->pending_resolutions);
871 }
872 
873 int
876  u32 pid,
877  void *address_arg,
878  uword node_index,
879  uword type_opaque, uword data, int is_add)
880 {
882  ip4_address_t *address = address_arg;
883 
884  /* Try to find an existing entry */
885  u32 *first = (u32 *) hash_get (am->mac_changes_by_address, address->as_u32);
886  u32 *p = first;
888  while (p && *p != ~0)
889  {
890  mc = pool_elt_at_index (am->mac_changes, *p);
891  if (mc->node_index == node_index && mc->type_opaque == type_opaque
892  && mc->pid == pid)
893  break;
894  p = &mc->next_index;
895  }
896 
897  int found = p && *p != ~0;
898  if (is_add)
899  {
900  if (found)
901  return VNET_API_ERROR_ENTRY_ALREADY_EXISTS;
902 
903  pool_get (am->mac_changes, mc);
904  /* *INDENT-OFF* */
905  *mc = (pending_resolution_t)
906  {
907  .next_index = ~0,
908  .node_index = node_index,
909  .type_opaque = type_opaque,
910  .data = data,
911  .data_callback = data_callback,
912  .pid = pid,
913  };
914  /* *INDENT-ON* */
915 
916  /* Insert new resolution at the end of the list */
917  u32 new_idx = mc - am->mac_changes;
918  if (p)
919  p[0] = new_idx;
920  else
921  hash_set (am->mac_changes_by_address, address->as_u32, new_idx);
922  }
923  else
924  {
925  if (!found)
926  return VNET_API_ERROR_NO_SUCH_ENTRY;
927 
928  /* Clients may need to clean up pool entries, too */
929  if (data_callback)
930  /* no new mac addrs */
931  (data_callback) (mc->data, NULL, ~0, NULL);
932 
933  /* Remove the entry from the list and delete the entry */
934  *p = mc->next_index;
935  pool_put (am->mac_changes, mc);
936 
937  /* Remove from hash if we deleted the last entry */
938  if (*p == ~0 && p == first)
939  hash_unset (am->mac_changes_by_address, address->as_u32);
940  }
941  return 0;
942 }
943 
944 /* Either we drop the packet or we send a reply to the sender. */
945 typedef enum
946 {
951 
952 #define foreach_ethernet_arp_error \
953  _ (replies_sent, "ARP replies sent") \
954  _ (l2_type_not_ethernet, "L2 type not ethernet") \
955  _ (l3_type_not_ip4, "L3 type not IP4") \
956  _ (l3_src_address_not_local, "IP4 source address not local to subnet") \
957  _ (l3_dst_address_not_local, "IP4 destination address not local to subnet") \
958  _ (l3_dst_address_unset, "IP4 destination address is unset") \
959  _ (l3_src_address_is_local, "IP4 source address matches local interface") \
960  _ (l3_src_address_learned, "ARP request IP4 source address learned") \
961  _ (replies_received, "ARP replies received") \
962  _ (opcode_not_request, "ARP opcode not request") \
963  _ (proxy_arp_replies_sent, "Proxy ARP replies sent") \
964  _ (l2_address_mismatch, "ARP hw addr does not match L2 frame src addr") \
965  _ (gratuitous_arp, "ARP probe or announcement dropped") \
966  _ (interface_no_table, "Interface is not mapped to an IP table") \
967  _ (interface_not_ip_enabled, "Interface is not IP enabled") \
968  _ (unnumbered_mismatch, "RX interface is unnumbered to different subnet") \
969 
970 typedef enum
971 {
972 #define _(sym,string) ETHERNET_ARP_ERROR_##sym,
974 #undef _
977 
978 static int
980  u32 input_sw_if_index, u32 conn_sw_if_index)
981 {
982  vnet_main_t *vnm = vnet_get_main ();
985 
986  /* verify that the input interface is unnumbered to the connected.
987  * the connected interface is the interface on which the subnet is
988  * configured */
989  si = &vim->sw_interfaces[input_sw_if_index];
990 
992  (si->unnumbered_sw_if_index == conn_sw_if_index)))
993  {
994  /* the input interface is not unnumbered to the interface on which
995  * the sub-net is configured that covers the ARP request.
996  * So this is not the case for unnumbered.. */
997  return 0;
998  }
999 
1000  return !0;
1001 }
1002 
1003 static u32
1006  const ethernet_arp_ip4_over_ethernet_address_t * addr)
1007 {
1008  vnet_arp_set_ip4_over_ethernet (vnm, sw_if_index, addr, 0);
1009  return (ETHERNET_ARP_ERROR_l3_src_address_learned);
1010 }
1011 
1012 typedef enum arp_input_next_t_
1013 {
1018 
1019 static uword
1021 {
1022  u32 n_left_from, next_index, *from, *to_next, n_left_to_next;
1024 
1025  from = vlib_frame_vector_args (frame);
1026  n_left_from = frame->n_vectors;
1027  next_index = node->cached_next_index;
1028 
1029  if (node->flags & VLIB_NODE_FLAG_TRACE)
1030  vlib_trace_frame_buffers_only (vm, node, from, frame->n_vectors,
1031  /* stride */ 1,
1032  sizeof (ethernet_arp_input_trace_t));
1033 
1034  while (n_left_from > 0)
1035  {
1036  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
1037 
1038  while (n_left_from > 0 && n_left_to_next > 0)
1039  {
1040  const ethernet_arp_header_t *arp0;
1041  arp_input_next_t next0;
1042  vlib_buffer_t *p0;
1043  u32 pi0, error0;
1044 
1045  pi0 = to_next[0] = from[0];
1046  from += 1;
1047  to_next += 1;
1048  n_left_from -= 1;
1049  n_left_to_next -= 1;
1050 
1051  p0 = vlib_get_buffer (vm, pi0);
1052  arp0 = vlib_buffer_get_current (p0);
1053 
1054  error0 = ETHERNET_ARP_ERROR_replies_sent;
1055  next0 = ARP_INPUT_NEXT_DROP;
1056 
1057  error0 =
1058  (arp0->l2_type !=
1059  clib_net_to_host_u16 (ETHERNET_ARP_HARDWARE_TYPE_ethernet) ?
1060  ETHERNET_ARP_ERROR_l2_type_not_ethernet : error0);
1061  error0 =
1062  (arp0->l3_type !=
1063  clib_net_to_host_u16 (ETHERNET_TYPE_IP4) ?
1064  ETHERNET_ARP_ERROR_l3_type_not_ip4 : error0);
1065  error0 =
1066  (0 == arp0->ip4_over_ethernet[0].ip4.as_u32 ?
1067  ETHERNET_ARP_ERROR_l3_dst_address_unset : error0);
1068 
1069  if (ETHERNET_ARP_ERROR_replies_sent == error0)
1070  {
1071  next0 = ARP_INPUT_NEXT_DISABLED;
1074  &next0, p0);
1075  }
1076  else
1077  p0->error = node->errors[error0];
1078 
1079  vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
1080  n_left_to_next, pi0, next0);
1081  }
1082 
1083  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1084  }
1085 
1086  return frame->n_vectors;
1087 }
1088 
1090 {
1094 
1095 #define foreach_arp_disabled_error \
1096  _ (DISABLED, "ARP Disabled on this interface") \
1097 
1098 typedef enum
1099 {
1100 #define _(sym,string) ARP_DISABLED_ERROR_##sym,
1102 #undef _
1105 
1106 static char *arp_disabled_error_strings[] = {
1107 #define _(sym,string) string,
1109 #undef _
1110 };
1111 
1112 static uword
1114  vlib_node_runtime_t * node, vlib_frame_t * frame)
1115 {
1116  u32 n_left_from, next_index, *from, *to_next, n_left_to_next;
1117 
1118  from = vlib_frame_vector_args (frame);
1119  n_left_from = frame->n_vectors;
1120  next_index = node->cached_next_index;
1121 
1122  if (node->flags & VLIB_NODE_FLAG_TRACE)
1123  vlib_trace_frame_buffers_only (vm, node, from, frame->n_vectors,
1124  /* stride */ 1,
1125  sizeof (ethernet_arp_input_trace_t));
1126 
1127  while (n_left_from > 0)
1128  {
1129  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
1130 
1131  while (n_left_from > 0 && n_left_to_next > 0)
1132  {
1134  vlib_buffer_t *p0;
1135  u32 pi0, error0;
1136 
1137  next0 = ARP_DISABLED_NEXT_DROP;
1138  error0 = ARP_DISABLED_ERROR_DISABLED;
1139 
1140  pi0 = to_next[0] = from[0];
1141  from += 1;
1142  to_next += 1;
1143  n_left_from -= 1;
1144  n_left_to_next -= 1;
1145 
1146  p0 = vlib_get_buffer (vm, pi0);
1147  p0->error = node->errors[error0];
1148 
1149  vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
1150  n_left_to_next, pi0, next0);
1151  }
1152 
1153  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1154  }
1155 
1156  return frame->n_vectors;
1157 }
1158 
1161  vlib_buffer_t * p0,
1162  u32 sw_if_index0,
1163  const ip4_address_t * if_addr0,
1164  ethernet_arp_header_t * arp0, ethernet_header_t * eth_rx)
1165 {
1166  vnet_hw_interface_t *hw_if0;
1167  u8 *rewrite0, rewrite0_len;
1168  ethernet_header_t *eth_tx;
1169  u32 next0;
1170 
1171  /* Send a reply.
1172  An adjacency to the sender is not always present,
1173  so we use the interface to build us a rewrite string
1174  which will contain all the necessary tags. */
1175  rewrite0 = ethernet_build_rewrite (vnm, sw_if_index0,
1176  VNET_LINK_ARP, eth_rx->src_address);
1177  rewrite0_len = vec_len (rewrite0);
1178 
1179  /* Figure out how much to rewind current data from adjacency. */
1180  vlib_buffer_advance (p0, -rewrite0_len);
1181  eth_tx = vlib_buffer_get_current (p0);
1182 
1183  vnet_buffer (p0)->sw_if_index[VLIB_TX] = sw_if_index0;
1184  hw_if0 = vnet_get_sup_hw_interface (vnm, sw_if_index0);
1185 
1186  /* Send reply back through input interface */
1187  vnet_buffer (p0)->sw_if_index[VLIB_TX] = sw_if_index0;
1188  next0 = ARP_REPLY_NEXT_REPLY_TX;
1189 
1190  arp0->opcode = clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_reply);
1191 
1192  arp0->ip4_over_ethernet[1] = arp0->ip4_over_ethernet[0];
1193 
1195  hw_if0->hw_address);
1196  clib_mem_unaligned (&arp0->ip4_over_ethernet[0].ip4.data_u32, u32) =
1197  if_addr0->data_u32;
1198 
1199  /* Hardware must be ethernet-like. */
1200  ASSERT (vec_len (hw_if0->hw_address) == 6);
1201 
1202  /* the rx nd tx ethernet headers wil overlap in the case
1203  * when we received a tagged VLAN=0 packet, but we are sending
1204  * back untagged */
1205  clib_memcpy_fast (eth_tx, rewrite0, vec_len (rewrite0));
1206  vec_free (rewrite0);
1207 
1208  return (next0);
1209 }
1210 
1212 {
1216 };
1217 
1218 /*
1219  * we're looking for FIB sources that indicate the destination
1220  * is attached. There may be interposed DPO prior to the one
1221  * we are looking for
1222  */
1223 static enum arp_dst_fib_type
1225 {
1226  const fib_entry_t *entry = fib_entry_get (fei);
1227  const fib_entry_src_t *entry_src;
1228  fib_source_t src;
1229  /* *INDENT-OFF* */
1230  FOR_EACH_SRC_ADDED(entry, entry_src, src,
1231  ({
1232  *flags = fib_entry_get_flags_for_source (fei, src);
1234  return ARP_DST_FIB_ADJ;
1235  else if (FIB_ENTRY_FLAG_CONNECTED & *flags)
1236  return ARP_DST_FIB_CONN;
1237  }))
1238  /* *INDENT-ON* */
1239 
1240  return ARP_DST_FIB_NONE;
1241 }
1242 
1243 static uword
1245 {
1247  vnet_main_t *vnm = vnet_get_main ();
1248  u32 n_left_from, next_index, *from, *to_next;
1249  u32 n_replies_sent = 0;
1250 
1251  from = vlib_frame_vector_args (frame);
1252  n_left_from = frame->n_vectors;
1253  next_index = node->cached_next_index;
1254 
1255  if (node->flags & VLIB_NODE_FLAG_TRACE)
1256  vlib_trace_frame_buffers_only (vm, node, from, frame->n_vectors,
1257  /* stride */ 1,
1258  sizeof (ethernet_arp_input_trace_t));
1259 
1260  while (n_left_from > 0)
1261  {
1262  u32 n_left_to_next;
1263 
1264  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
1265 
1266  while (n_left_from > 0 && n_left_to_next > 0)
1267  {
1268  vlib_buffer_t *p0;
1269  ethernet_arp_header_t *arp0;
1270  ethernet_header_t *eth_rx;
1271  const ip4_address_t *if_addr0;
1272  u32 pi0, error0, next0, sw_if_index0, conn_sw_if_index0, fib_index0;
1273  u8 dst_is_local0, is_vrrp_reply0;
1274  fib_node_index_t dst_fei, src_fei;
1275  const fib_prefix_t *pfx0;
1276  fib_entry_flag_t src_flags, dst_flags;
1277 
1278  pi0 = from[0];
1279  to_next[0] = pi0;
1280  from += 1;
1281  to_next += 1;
1282  n_left_from -= 1;
1283  n_left_to_next -= 1;
1284 
1285  p0 = vlib_get_buffer (vm, pi0);
1286  arp0 = vlib_buffer_get_current (p0);
1287  /* Fill in ethernet header. */
1288  eth_rx = ethernet_buffer_get_header (p0);
1289 
1290  next0 = ARP_REPLY_NEXT_DROP;
1291  error0 = ETHERNET_ARP_ERROR_replies_sent;
1292  sw_if_index0 = vnet_buffer (p0)->sw_if_index[VLIB_RX];
1293 
1294  /* Check that IP address is local and matches incoming interface. */
1295  fib_index0 = ip4_fib_table_get_index_for_sw_if_index (sw_if_index0);
1296  if (~0 == fib_index0)
1297  {
1298  error0 = ETHERNET_ARP_ERROR_interface_no_table;
1299  goto drop;
1300 
1301  }
1302 
1303  {
1304  /*
1305  * we're looking for FIB entries that indicate the source
1306  * is attached. There may be more specific non-attached
1307  * routes that match the source, but these do not influence
1308  * whether we respond to an ARP request, i.e. they do not
1309  * influence whether we are the correct way for the sender
1310  * to reach us, they only affect how we reach the sender.
1311  */
1312  fib_entry_t *src_fib_entry;
1313  const fib_prefix_t *pfx;
1315  fib_source_t source;
1316  int attached;
1317  int mask;
1318 
1319  mask = 32;
1320  attached = 0;
1321 
1322  do
1323  {
1324  src_fei = ip4_fib_table_lookup (ip4_fib_get (fib_index0),
1325  &arp0->
1326  ip4_over_ethernet[0].ip4,
1327  mask);
1328  src_fib_entry = fib_entry_get (src_fei);
1329 
1330  /*
1331  * It's possible that the source that provides the
1332  * flags we need, or the flags we must not have,
1333  * is not the best source, so check then all.
1334  */
1335  /* *INDENT-OFF* */
1336  FOR_EACH_SRC_ADDED(src_fib_entry, src, source,
1337  ({
1338  src_flags = fib_entry_get_flags_for_source (src_fei, source);
1339 
1340  /* Reject requests/replies with our local interface
1341  address. */
1342  if (FIB_ENTRY_FLAG_LOCAL & src_flags)
1343  {
1344  error0 = ETHERNET_ARP_ERROR_l3_src_address_is_local;
1345  /*
1346  * When VPP has an interface whose address is also
1347  * applied to a TAP interface on the host, then VPP's
1348  * TAP interface will be unnumbered to the 'real'
1349  * interface and do proxy ARP from the host.
1350  * The curious aspect of this setup is that ARP requests
1351  * from the host will come from the VPP's own address.
1352  * So don't drop immediately here, instead go see if this
1353  * is a proxy ARP case.
1354  */
1355  goto next_feature;
1356  }
1357  /* A Source must also be local to subnet of matching
1358  * interface address. */
1359  if ((FIB_ENTRY_FLAG_ATTACHED & src_flags) ||
1360  (FIB_ENTRY_FLAG_CONNECTED & src_flags))
1361  {
1362  attached = 1;
1363  break;
1364  }
1365  /*
1366  * else
1367  * The packet was sent from an address that is not
1368  * connected nor attached i.e. it is not from an
1369  * address that is covered by a link's sub-net,
1370  * nor is it a already learned host resp.
1371  */
1372  }));
1373  /* *INDENT-ON* */
1374 
1375  /*
1376  * shorter mask lookup for the next iteration.
1377  */
1378  pfx = fib_entry_get_prefix (src_fei);
1379  mask = pfx->fp_len - 1;
1380 
1381  /*
1382  * continue until we hit the default route or we find
1383  * the attached we are looking for. The most likely
1384  * outcome is we find the attached with the first source
1385  * on the first lookup.
1386  */
1387  }
1388  while (!attached &&
1390 
1391  if (!attached)
1392  {
1393  /*
1394  * the matching route is a not attached, i.e. it was
1395  * added as a result of routing, rather than interface/ARP
1396  * configuration. If the matching route is not a host route
1397  * (i.e. a /32)
1398  */
1399  error0 = ETHERNET_ARP_ERROR_l3_src_address_not_local;
1400  goto drop;
1401  }
1402  }
1403 
1404  dst_fei = ip4_fib_table_lookup (ip4_fib_get (fib_index0),
1405  &arp0->ip4_over_ethernet[1].ip4,
1406  32);
1407  switch (arp_dst_fib_check (dst_fei, &dst_flags))
1408  {
1409  case ARP_DST_FIB_ADJ:
1410  /*
1411  * We matched an adj-fib on ths source subnet (a /32 previously
1412  * added as a result of ARP). If this request is a gratuitous
1413  * ARP, then learn from it.
1414  * The check for matching an adj-fib, is to prevent hosts
1415  * from spamming us with gratuitous ARPS that might otherwise
1416  * blow our ARP cache
1417  */
1418  if (arp0->ip4_over_ethernet[0].ip4.as_u32 ==
1419  arp0->ip4_over_ethernet[1].ip4.as_u32)
1420  error0 = arp_learn (vnm, am, sw_if_index0,
1421  &arp0->ip4_over_ethernet[0]);
1422  goto drop;
1423  case ARP_DST_FIB_CONN:
1424  /* destination is connected, continue to process */
1425  break;
1426  case ARP_DST_FIB_NONE:
1427  /* destination is not connected, stop here */
1428  error0 = ETHERNET_ARP_ERROR_l3_dst_address_not_local;
1429  goto next_feature;
1430  }
1431 
1432  dst_is_local0 = (FIB_ENTRY_FLAG_LOCAL & dst_flags);
1433  pfx0 = fib_entry_get_prefix (dst_fei);
1434  if_addr0 = &pfx0->fp_addr.ip4;
1435 
1436  is_vrrp_reply0 =
1437  ((arp0->opcode ==
1438  clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_reply))
1439  &&
1440  (!memcmp
1441  (arp0->ip4_over_ethernet[0].mac.bytes, vrrp_prefix,
1442  sizeof (vrrp_prefix))));
1443 
1444  /* Trash ARP packets whose ARP-level source addresses do not
1445  match their L2-frame-level source addresses, unless it's
1446  a reply from a VRRP virtual router */
1448  (eth_rx->src_address,
1449  arp0->ip4_over_ethernet[0].mac.bytes) && !is_vrrp_reply0)
1450  {
1451  error0 = ETHERNET_ARP_ERROR_l2_address_mismatch;
1452  goto drop;
1453  }
1454 
1455  /* Learn or update sender's mapping only for replies to addresses
1456  * that are local to the subnet */
1457  if (arp0->opcode ==
1458  clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_reply))
1459  {
1460  if (dst_is_local0)
1461  error0 = arp_learn (vnm, am, sw_if_index0,
1462  &arp0->ip4_over_ethernet[0]);
1463  else
1464  /* a reply for a non-local destination could be a GARP.
1465  * GARPs for hosts we know were handled above, so this one
1466  * we drop */
1467  error0 = ETHERNET_ARP_ERROR_l3_dst_address_not_local;
1468 
1469  goto next_feature;
1470  }
1471  else if (arp0->opcode ==
1472  clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_request) &&
1473  (dst_is_local0 == 0))
1474  {
1475  goto next_feature;
1476  }
1477 
1478  /* Honor unnumbered interface, if any */
1479  conn_sw_if_index0 = fib_entry_get_resolving_interface (dst_fei);
1480  if (sw_if_index0 != conn_sw_if_index0 ||
1481  sw_if_index0 != fib_entry_get_resolving_interface (src_fei))
1482  {
1483  /*
1484  * The interface the ARP is sent to or was received on is not the
1485  * interface on which the covering prefix is configured.
1486  * Maybe this is a case for unnumbered.
1487  */
1488  if (!arp_unnumbered (p0, sw_if_index0, conn_sw_if_index0))
1489  {
1490  error0 = ETHERNET_ARP_ERROR_unnumbered_mismatch;
1491  goto drop;
1492  }
1493  }
1494  if (arp0->ip4_over_ethernet[0].ip4.as_u32 ==
1495  arp0->ip4_over_ethernet[1].ip4.as_u32)
1496  {
1497  error0 = ETHERNET_ARP_ERROR_gratuitous_arp;
1498  goto drop;
1499  }
1500 
1501  next0 = arp_mk_reply (vnm, p0, sw_if_index0,
1502  if_addr0, arp0, eth_rx);
1503 
1504  /* We are going to reply to this request, so, in the absence of
1505  errors, learn the sender */
1506  if (!error0)
1507  error0 = arp_learn (vnm, am, sw_if_index0,
1508  &arp0->ip4_over_ethernet[1]);
1509 
1510  n_replies_sent += 1;
1511  goto enqueue;
1512 
1513  next_feature:
1514  vnet_feature_next (&next0, p0);
1515  goto enqueue;
1516 
1517  drop:
1518  p0->error = node->errors[error0];
1519 
1520  enqueue:
1521  vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
1522  n_left_to_next, pi0, next0);
1523  }
1524 
1525  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1526  }
1527 
1528  vlib_error_count (vm, node->node_index,
1529  ETHERNET_ARP_ERROR_replies_sent, n_replies_sent);
1530 
1531  return frame->n_vectors;
1532 }
1533 
1534 static uword
1536 {
1538  vnet_main_t *vnm = vnet_get_main ();
1539  u32 n_left_from, next_index, *from, *to_next;
1540  u32 n_arp_replies_sent = 0;
1541 
1542  from = vlib_frame_vector_args (frame);
1543  n_left_from = frame->n_vectors;
1544  next_index = node->cached_next_index;
1545 
1546  if (node->flags & VLIB_NODE_FLAG_TRACE)
1547  vlib_trace_frame_buffers_only (vm, node, from, frame->n_vectors,
1548  /* stride */ 1,
1549  sizeof (ethernet_arp_input_trace_t));
1550 
1551  while (n_left_from > 0)
1552  {
1553  u32 n_left_to_next;
1554 
1555  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
1556 
1557  while (n_left_from > 0 && n_left_to_next > 0)
1558  {
1559  vlib_buffer_t *p0;
1560  ethernet_arp_header_t *arp0;
1561  ethernet_header_t *eth_rx;
1562  ip4_address_t proxy_src;
1563  u32 pi0, error0, next0, sw_if_index0, fib_index0;
1564  u8 is_request0;
1566 
1567  pi0 = from[0];
1568  to_next[0] = pi0;
1569  from += 1;
1570  to_next += 1;
1571  n_left_from -= 1;
1572  n_left_to_next -= 1;
1573 
1574  p0 = vlib_get_buffer (vm, pi0);
1575  arp0 = vlib_buffer_get_current (p0);
1576  /* Fill in ethernet header. */
1577  eth_rx = ethernet_buffer_get_header (p0);
1578 
1579  is_request0 = arp0->opcode
1580  == clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_request);
1581 
1582  error0 = ETHERNET_ARP_ERROR_replies_sent;
1583  sw_if_index0 = vnet_buffer (p0)->sw_if_index[VLIB_RX];
1584  next0 = ARP_REPLY_NEXT_DROP;
1585 
1586  fib_index0 = ip4_fib_table_get_index_for_sw_if_index (sw_if_index0);
1587  if (~0 == fib_index0)
1588  {
1589  error0 = ETHERNET_ARP_ERROR_interface_no_table;
1590  }
1591 
1592  if (0 == error0 && is_request0)
1593  {
1594  u32 this_addr = clib_net_to_host_u32
1595  (arp0->ip4_over_ethernet[1].ip4.as_u32);
1596 
1597  vec_foreach (pa, am->proxy_arps)
1598  {
1599  u32 lo_addr = clib_net_to_host_u32 (pa->lo_addr.as_u32);
1600  u32 hi_addr = clib_net_to_host_u32 (pa->hi_addr.as_u32);
1601 
1602  /* an ARP request hit in the proxy-arp table? */
1603  if ((this_addr >= lo_addr && this_addr <= hi_addr) &&
1604  (fib_index0 == pa->fib_index))
1605  {
1606  proxy_src.as_u32 =
1607  arp0->ip4_over_ethernet[1].ip4.data_u32;
1608 
1609  /*
1610  * change the interface address to the proxied
1611  */
1612  n_arp_replies_sent++;
1613 
1614  next0 =
1615  arp_mk_reply (vnm, p0, sw_if_index0, &proxy_src, arp0,
1616  eth_rx);
1617  }
1618  }
1619  }
1620  else
1621  {
1622  p0->error = node->errors[error0];
1623  }
1624 
1625  vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
1626  n_left_to_next, pi0, next0);
1627  }
1628 
1629  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1630  }
1631 
1632  vlib_error_count (vm, node->node_index,
1633  ETHERNET_ARP_ERROR_replies_sent, n_arp_replies_sent);
1634 
1635  return frame->n_vectors;
1636 }
1637 
1638 static char *ethernet_arp_error_strings[] = {
1639 #define _(sym,string) string,
1641 #undef _
1642 };
1643 
1644 /* *INDENT-OFF* */
1645 
1647 {
1648  .function = arp_input,
1649  .name = "arp-input",
1650  .vector_size = sizeof (u32),
1651  .n_errors = ETHERNET_ARP_N_ERROR,
1652  .error_strings = ethernet_arp_error_strings,
1653  .n_next_nodes = ARP_INPUT_N_NEXT,
1654  .next_nodes = {
1655  [ARP_INPUT_NEXT_DROP] = "error-drop",
1656  [ARP_INPUT_NEXT_DISABLED] = "arp-disabled",
1657  },
1658  .format_buffer = format_ethernet_arp_header,
1659  .format_trace = format_ethernet_arp_input_trace,
1660 };
1661 
1663 {
1664  .function = arp_disabled,
1665  .name = "arp-disabled",
1666  .vector_size = sizeof (u32),
1667  .n_errors = ARP_DISABLED_N_ERROR,
1668  .error_strings = arp_disabled_error_strings,
1669  .n_next_nodes = ARP_DISABLED_N_NEXT,
1670  .next_nodes = {
1671  [ARP_INPUT_NEXT_DROP] = "error-drop",
1672  },
1673  .format_buffer = format_ethernet_arp_header,
1674  .format_trace = format_ethernet_arp_input_trace,
1675 };
1676 
1678 {
1679  .function = arp_reply,
1680  .name = "arp-reply",
1681  .vector_size = sizeof (u32),
1682  .n_errors = ETHERNET_ARP_N_ERROR,
1683  .error_strings = ethernet_arp_error_strings,
1684  .n_next_nodes = ARP_REPLY_N_NEXT,
1685  .next_nodes = {
1686  [ARP_REPLY_NEXT_DROP] = "error-drop",
1687  [ARP_REPLY_NEXT_REPLY_TX] = "interface-output",
1688  },
1689  .format_buffer = format_ethernet_arp_header,
1690  .format_trace = format_ethernet_arp_input_trace,
1691 };
1692 
1694 {
1695  .function = arp_proxy,
1696  .name = "arp-proxy",
1697  .vector_size = sizeof (u32),
1698  .n_errors = ETHERNET_ARP_N_ERROR,
1699  .error_strings = ethernet_arp_error_strings,
1700  .n_next_nodes = ARP_REPLY_N_NEXT,
1701  .next_nodes = {
1702  [ARP_REPLY_NEXT_DROP] = "error-drop",
1703  [ARP_REPLY_NEXT_REPLY_TX] = "interface-output",
1704  },
1705  .format_buffer = format_ethernet_arp_header,
1706  .format_trace = format_ethernet_arp_input_trace,
1707 };
1708 
1709 /* Built-in ARP rx feature path definition */
1710 VNET_FEATURE_ARC_INIT (arp_feat, static) =
1711 {
1712  .arc_name = "arp",
1713  .start_nodes = VNET_FEATURES ("arp-input"),
1714  .last_in_arc = "arp-disabled",
1715  .arc_index_ptr = &ethernet_arp_main.feature_arc_index,
1716 };
1717 
1718 VNET_FEATURE_INIT (arp_reply_feat_node, static) =
1719 {
1720  .arc_name = "arp",
1721  .node_name = "arp-reply",
1722  .runs_before = VNET_FEATURES ("arp-disabled"),
1723 };
1724 
1725 VNET_FEATURE_INIT (arp_proxy_feat_node, static) =
1726 {
1727  .arc_name = "arp",
1728  .node_name = "arp-proxy",
1729  .runs_after = VNET_FEATURES ("arp-reply"),
1730  .runs_before = VNET_FEATURES ("arp-disabled"),
1731 };
1732 
1733 VNET_FEATURE_INIT (arp_disabled_feat_node, static) =
1734 {
1735  .arc_name = "arp",
1736  .node_name = "arp-disabled",
1737  .runs_before = VNET_FEATURES ("error-drop"),
1738 };
1739 
1740 VNET_FEATURE_INIT (arp_drop_feat_node, static) =
1741 {
1742  .arc_name = "arp",
1743  .node_name = "error-drop",
1744  .runs_before = 0, /* last feature */
1745 };
1746 
1747 /* *INDENT-ON* */
1748 
1749 static int
1750 ip4_arp_entry_sort (void *a1, void *a2)
1751 {
1752  ethernet_arp_ip4_entry_t *e1 = a1;
1753  ethernet_arp_ip4_entry_t *e2 = a2;
1754 
1755  int cmp;
1756  vnet_main_t *vnm = vnet_get_main ();
1757 
1758  cmp = vnet_sw_interface_compare (vnm, e1->sw_if_index, e2->sw_if_index);
1759  if (!cmp)
1760  cmp = ip4_address_compare (&e1->ip4_address, &e2->ip4_address);
1761  return cmp;
1762 }
1763 
1766 {
1768  return am->ip4_entry_pool;
1769 }
1770 
1773 {
1775  ethernet_arp_ip4_entry_t *n, *ns = 0;
1776 
1777  /* *INDENT-OFF* */
1778  pool_foreach (n, am->ip4_entry_pool, ({
1779  if (sw_if_index != ~0 && n->sw_if_index != sw_if_index)
1780  continue;
1781  vec_add1 (ns, n[0]);
1782  }));
1783  /* *INDENT-ON* */
1784 
1785  if (ns)
1787  return ns;
1788 }
1789 
1790 static clib_error_t *
1792  unformat_input_t * input, vlib_cli_command_t * cmd)
1793 {
1794  vnet_main_t *vnm = vnet_get_main ();
1796  ethernet_arp_ip4_entry_t *e, *es;
1798  clib_error_t *error = 0;
1799  u32 sw_if_index;
1800 
1801  /* Filter entries by interface if given. */
1802  sw_if_index = ~0;
1803  (void) unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index);
1804 
1805  es = ip4_neighbor_entries (sw_if_index);
1806  if (es)
1807  {
1808  vlib_cli_output (vm, "%U", format_ethernet_arp_ip4_entry, vnm, 0);
1809  vec_foreach (e, es)
1810  {
1811  vlib_cli_output (vm, "%U", format_ethernet_arp_ip4_entry, vnm, e);
1812  }
1813  vec_free (es);
1814  }
1815 
1816  if (vec_len (am->proxy_arps))
1817  {
1818  vlib_cli_output (vm, "Proxy arps enabled for:");
1819  vec_foreach (pa, am->proxy_arps)
1820  {
1821  vlib_cli_output (vm, "Fib_index %d %U - %U ",
1822  pa->fib_index,
1824  format_ip4_address, &pa->hi_addr);
1825  }
1826  }
1827 
1828  return error;
1829 }
1830 
1831 /*?
1832  * Display all the IPv4 ARP entries.
1833  *
1834  * @cliexpar
1835  * Example of how to display the IPv4 ARP table:
1836  * @cliexstart{show ip arp}
1837  * Time FIB IP4 Flags Ethernet Interface
1838  * 346.3028 0 6.1.1.3 de:ad:be:ef:ba:be GigabitEthernet2/0/0
1839  * 3077.4271 0 6.1.1.4 S de:ad:be:ef:ff:ff GigabitEthernet2/0/0
1840  * 2998.6409 1 6.2.2.3 de:ad:be:ef:00:01 GigabitEthernet2/0/0
1841  * Proxy arps enabled for:
1842  * Fib_index 0 6.0.0.1 - 6.0.0.11
1843  * @cliexend
1844  ?*/
1845 /* *INDENT-OFF* */
1846 VLIB_CLI_COMMAND (show_ip4_arp_command, static) = {
1847  .path = "show ip arp",
1848  .function = show_ip4_arp,
1849  .short_help = "show ip arp",
1850 };
1851 /* *INDENT-ON* */
1852 
1853 typedef struct
1854 {
1855  pg_edit_t l2_type, l3_type;
1856  pg_edit_t n_l2_address_bytes, n_l3_address_bytes;
1858  struct
1859  {
1862  } ip4_over_ethernet[2];
1864 
1865 static inline void
1867 {
1868  /* Initialize fields that are not bit fields in the IP header. */
1869 #define _(f) pg_edit_init (&p->f, ethernet_arp_header_t, f);
1870  _(l2_type);
1871  _(l3_type);
1872  _(n_l2_address_bytes);
1873  _(n_l3_address_bytes);
1874  _(opcode);
1875  _(ip4_over_ethernet[0].mac);
1876  _(ip4_over_ethernet[0].ip4);
1877  _(ip4_over_ethernet[1].mac);
1878  _(ip4_over_ethernet[1].ip4);
1879 #undef _
1880 }
1881 
1882 uword
1883 unformat_pg_arp_header (unformat_input_t * input, va_list * args)
1884 {
1885  pg_stream_t *s = va_arg (*args, pg_stream_t *);
1887  u32 group_index;
1888 
1889  p = pg_create_edit_group (s, sizeof (p[0]), sizeof (ethernet_arp_header_t),
1890  &group_index);
1892 
1893  /* Defaults. */
1894  pg_edit_set_fixed (&p->l2_type, ETHERNET_ARP_HARDWARE_TYPE_ethernet);
1895  pg_edit_set_fixed (&p->l3_type, ETHERNET_TYPE_IP4);
1898 
1899  if (!unformat (input, "%U: %U/%U -> %U/%U",
1910  {
1911  /* Free up any edits we may have added. */
1912  pg_free_edit_group (s);
1913  return 0;
1914  }
1915  return 1;
1916 }
1917 
1918 clib_error_t *
1920 {
1922 
1923  am->limit_arp_cache_size = arp_limit;
1924  return 0;
1925 }
1926 
1927 /**
1928  * @brief Control Plane hook to remove an ARP entry
1929  */
1930 int
1932  u32 sw_if_index,
1933  const
1934  ethernet_arp_ip4_over_ethernet_address_t *
1935  a)
1936 {
1939  .flags = ETHERNET_ARP_ARGS_REMOVE,
1940  .ip4 = a->ip4,
1941  .mac = a->mac,
1942  };
1943 
1945  (u8 *) & args, sizeof (args));
1946  return 0;
1947 }
1948 
1949 /**
1950  * @brief publish wildcard arp event
1951  * @param sw_if_index The interface on which the ARP entries are acted
1952  */
1953 static int
1955  const ethernet_arp_ip4_over_ethernet_address_t * a)
1956 {
1959  .sw_if_index = sw_if_index,
1960  .ip4 = a->ip4,
1961  .mac = a->mac,
1962  };
1963 
1965  (u8 *) & args, sizeof (args));
1966  return 0;
1967 }
1968 
1969 static void
1972  args)
1973 {
1977  uword et = am->wc_ip4_arp_publisher_et;
1978 
1979  if (ni == (uword) ~ 0)
1980  return;
1981  wc_arp_report_t *r =
1982  vlib_process_signal_event_data (vm, ni, et, 1, sizeof *r);
1983  r->ip.as_u32 = args->ip4.as_u32;
1984  r->sw_if_index = args->sw_if_index;
1985  mac_address_copy (&r->mac, &args->mac);
1986 }
1987 
1988 void
1989 wc_arp_set_publisher_node (uword node_index, uword event_type)
1990 {
1992  am->wc_ip4_arp_publisher_node = node_index;
1993  am->wc_ip4_arp_publisher_et = event_type;
1994 }
1995 
1996 static void
1998 
1999 static int
2002  * args)
2003 {
2007 
2008  if (vec_len (am->ethernet_arp_by_sw_if_index) <= args->sw_if_index)
2009  return 0;
2010 
2011  eai = &am->ethernet_arp_by_sw_if_index[args->sw_if_index];
2012 
2013  e = arp_entry_find (eai, &args->ip4);
2014 
2015  if (NULL != e)
2016  {
2019 
2020  /*
2021  * The difference between flush and unset, is that an unset
2022  * means delete for static and dynamic entries. A flush
2023  * means delete only for dynamic. Flushing is what the DP
2024  * does in response to interface events. unset is only done
2025  * by the control plane.
2026  */
2027  if (e->flags & IP_NEIGHBOR_FLAG_STATIC)
2028  {
2030  }
2031  else if (e->flags & IP_NEIGHBOR_FLAG_DYNAMIC)
2032  {
2033  arp_entry_free (eai, e);
2034  }
2035  }
2036  return (0);
2037 }
2038 
2039 /*
2040  * arp_add_del_interface_address
2041  *
2042  * callback when an interface address is added or deleted
2043  */
2044 static void
2046  uword opaque, u32 sw_if_index, u32 is_enable)
2047 {
2049 
2050  if (is_enable)
2051  arp_enable (am, sw_if_index);
2052  else
2053  arp_disable (am, sw_if_index);
2054 }
2055 
2056 /*
2057  * arp_add_del_interface_address
2058  *
2059  * callback when an interface address is added or deleted
2060  */
2061 static void
2063  uword opaque,
2064  u32 sw_if_index,
2066  u32 address_length,
2067  u32 if_address_index, u32 is_del)
2068 {
2069  /*
2070  * Flush the ARP cache of all entries covered by the address
2071  * that is being removed.
2072  */
2075 
2076  if (vec_len (am->ethernet_arp_by_sw_if_index) <= sw_if_index)
2077  return;
2078 
2079  if (is_del)
2080  {
2082  u32 i, *to_delete = 0;
2083  hash_pair_t *pair;
2084 
2086 
2087  /* *INDENT-OFF* */
2088  hash_foreach_pair (pair, eai->arp_entries,
2089  ({
2090  e = pool_elt_at_index(am->ip4_entry_pool,
2091  pair->value[0]);
2092  if (ip4_destination_matches_route (im, &e->ip4_address,
2093  address, address_length))
2094  {
2095  vec_add1 (to_delete, e - am->ip4_entry_pool);
2096  }
2097  }));
2098  /* *INDENT-ON* */
2099 
2100  for (i = 0; i < vec_len (to_delete); i++)
2101  {
2102  e = pool_elt_at_index (am->ip4_entry_pool, to_delete[i]);
2103 
2105  .ip4.as_u32 = e->ip4_address.as_u32,
2106  .sw_if_index = e->sw_if_index,
2107  .flags = ETHERNET_ARP_ARGS_FLUSH,
2108  };
2109  mac_address_copy (&delme.mac, &e->mac);
2110 
2112  &delme);
2113  }
2114 
2115  vec_free (to_delete);
2116  }
2117 }
2118 
2119 static void
2121  uword opaque,
2122  u32 sw_if_index, u32 new_fib_index, u32 old_fib_index)
2123 {
2127  hash_pair_t *pair;
2128 
2129  /*
2130  * the IP table that the interface is bound to has changed.
2131  * reinstall all the adj fibs.
2132  */
2133 
2134  if (vec_len (am->ethernet_arp_by_sw_if_index) <= sw_if_index)
2135  return;
2136 
2138 
2139  /* *INDENT-OFF* */
2140  hash_foreach_pair (pair, eai->arp_entries,
2141  ({
2142  e = pool_elt_at_index(am->ip4_entry_pool,
2143  pair->value[0]);
2144  /*
2145  * remove the adj-fib from the old table and add to the new
2146  */
2147  arp_adj_fib_remove(e, old_fib_index);
2148  arp_adj_fib_add(e, new_fib_index);
2149  }));
2150  /* *INDENT-ON* */
2151 
2152 }
2153 
2154 static clib_error_t *
2156 {
2158  ip4_main_t *im = &ip4_main;
2159  pg_node_t *pn;
2160 
2161  ethernet_register_input_type (vm, ETHERNET_TYPE_ARP, arp_input_node.index);
2162 
2163  pn = pg_get_node (arp_input_node.index);
2165 
2166  am->opcode_by_name = hash_create_string (0, sizeof (uword));
2167 #define _(o) hash_set_mem (am->opcode_by_name, #o, ETHERNET_ARP_OPCODE_##o);
2169 #undef _
2170 
2171  /* $$$ configurable */
2172  am->limit_arp_cache_size = 50000;
2173 
2174  am->pending_resolutions_by_address = hash_create (0, sizeof (uword));
2175  am->mac_changes_by_address = hash_create (0, sizeof (uword));
2176  am->wc_ip4_arp_publisher_node = (uword) ~ 0;
2177 
2178  /* don't trace ARP error packets */
2179  {
2180  vlib_node_runtime_t *rt =
2182 
2183 #define _(a,b) \
2184  vnet_pcap_drop_trace_filter_add_del \
2185  (rt->errors[ETHERNET_ARP_ERROR_##a], \
2186  1 /* is_add */);
2188 #undef _
2189  }
2190 
2193  cb.function_opaque = 0;
2195 
2198  cbe.function_opaque = 0;
2200 
2202  cbt.function = arp_table_bind;
2203  cbt.function_opaque = 0;
2204  vec_add1 (im->table_bind_callbacks, cbt);
2205 
2206  return 0;
2207 }
2208 /* *INDENT-OFF* */
2210 {
2211  .runs_after = VLIB_INITS("ethernet_init"),
2212 };
2213 /* *INDENT-ON* */
2214 
2215 static void
2217 {
2219 
2223  pool_put (am->ip4_entry_pool, e);
2224 }
2225 
2226 static inline int
2229  * args)
2230 {
2234 
2235  if (vec_len (am->ethernet_arp_by_sw_if_index) <= args->sw_if_index)
2236  return 0;
2237 
2238  eai = &am->ethernet_arp_by_sw_if_index[args->sw_if_index];
2239 
2240  e = arp_entry_find (eai, &args->ip4);
2241 
2242  if (NULL != e)
2243  {
2246  arp_entry_free (eai, e);
2247  }
2248 
2249  return 0;
2250 }
2251 
2252 
2253 static int
2256  * args)
2257 {
2261 
2262  arp_enable (am, args->sw_if_index);
2263  eai = &am->ethernet_arp_by_sw_if_index[args->sw_if_index];
2264 
2265  e = arp_entry_find (eai, &args->ip4);
2266 
2267  if (NULL != e)
2268  {
2271  }
2272  return (0);
2273 }
2274 
2275 static void
2277  * a)
2278 {
2280  ASSERT (vlib_get_thread_index () == 0);
2281 
2284  else if (a->flags & ETHERNET_ARP_ARGS_FLUSH)
2286  else if (a->flags & ETHERNET_ARP_ARGS_POPULATE)
2288  else if (a->flags & ETHERNET_ARP_ARGS_WC_PUB)
2290  else
2292 }
2293 
2294 /**
2295  * @brief Invoked when the interface's admin state changes
2296  */
2297 static clib_error_t *
2300 {
2303  u32 i, *to_update = 0;
2304 
2305  /* *INDENT-OFF* */
2306  pool_foreach (e, am->ip4_entry_pool,
2307  ({
2308  if (e->sw_if_index == sw_if_index)
2309  vec_add1 (to_update,
2310  e - am->ip4_entry_pool);
2311  }));
2312  /* *INDENT-ON* */
2313 
2314  for (i = 0; i < vec_len (to_update); i++)
2315  {
2316  e = pool_elt_at_index (am->ip4_entry_pool, to_update[i]);
2317 
2319  .ip4.as_u32 = e->ip4_address.as_u32,
2320  .sw_if_index = e->sw_if_index,
2321  };
2322  mac_address_copy (&update_me.mac, &e->mac);
2323 
2324  if (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP)
2325  {
2326  update_me.flags = ETHERNET_ARP_ARGS_POPULATE;
2328  }
2329  else
2330  {
2331  update_me.flags = ETHERNET_ARP_ARGS_FLUSH;
2333  }
2334  }
2335  vec_free (to_update);
2336 
2337  return 0;
2338 }
2339 
2341 
2342 static void
2343 increment_ip4_and_mac_address (ethernet_arp_ip4_over_ethernet_address_t * a)
2344 {
2345  u8 old;
2346  int i;
2347 
2348  for (i = 3; i >= 0; i--)
2349  {
2350  old = a->ip4.as_u8[i];
2351  a->ip4.as_u8[i] += 1;
2352  if (old < a->ip4.as_u8[i])
2353  break;
2354  }
2355 
2356  for (i = 5; i >= 0; i--)
2357  {
2358  old = a->mac.bytes[i];
2359  a->mac.bytes[i] += 1;
2360  if (old < a->mac.bytes[i])
2361  break;
2362  }
2363 }
2364 
2365 int
2367  u32 sw_if_index,
2368  const ethernet_arp_ip4_over_ethernet_address_t
2370 {
2373  .nbr_flags = flags,
2374  .flags = 0,
2375  .ip4.as_u32 = a->ip4.as_u32,
2376  .mac = a->mac,
2377  };
2378 
2380  (u8 *) & args, sizeof (args));
2381  return 0;
2382 }
2383 
2384 void
2386 {
2389 
2390  vec_foreach (pa, am->proxy_arps)
2391  {
2392  if (!cb (&pa->lo_addr, &pa->hi_addr, pa->fib_index, data))
2393  break;
2394  }
2395 }
2396 
2397 int
2399 {
2402 
2403  vec_validate (am->ethernet_arp_by_sw_if_index, sw_if_index);
2404 
2406 
2407  if (enable)
2408  {
2409  if (!eai->proxy_enabled)
2410  {
2411  vnet_feature_enable_disable ("arp", "arp-proxy",
2412  sw_if_index, 1, NULL, 0);
2413  }
2414  eai->proxy_enabled = 1;
2415  }
2416  else
2417  {
2418  if (eai->proxy_enabled)
2419  {
2420  vnet_feature_enable_disable ("arp", "arp-proxy",
2421  sw_if_index, 0, NULL, 0);
2422  }
2423  eai->proxy_enabled = 0;
2424  }
2425 
2426  return (0);
2427 }
2428 
2429 int
2431  ip4_address_t * hi_addr, u32 fib_index, int is_del)
2432 {
2435  u32 found_at_index = ~0;
2436 
2437  vec_foreach (pa, am->proxy_arps)
2438  {
2439  if (pa->lo_addr.as_u32 == lo_addr->as_u32 &&
2440  pa->hi_addr.as_u32 == hi_addr->as_u32 && pa->fib_index == fib_index)
2441  {
2442  found_at_index = pa - am->proxy_arps;
2443  break;
2444  }
2445  }
2446 
2447  if (found_at_index != ~0)
2448  {
2449  /* Delete, otherwise it's already in the table */
2450  if (is_del)
2451  vec_delete (am->proxy_arps, 1, found_at_index);
2452  return 0;
2453  }
2454  /* delete, no such entry */
2455  if (is_del)
2456  return VNET_API_ERROR_NO_SUCH_ENTRY;
2457 
2458  /* add, not in table */
2459  vec_add2 (am->proxy_arps, pa, 1);
2460  pa->lo_addr.as_u32 = lo_addr->as_u32;
2461  pa->hi_addr.as_u32 = hi_addr->as_u32;
2462  pa->fib_index = fib_index;
2463  return 0;
2464 }
2465 
2466 void
2468 {
2471 
2473  {
2474  if (eai->proxy_enabled)
2475  cb (eai - am->ethernet_arp_by_sw_if_index, data);
2476  }
2477 }
2478 
2479 /*
2480  * Remove any proxy arp entries associated with the
2481  * specified fib.
2482  */
2483 int
2485 {
2488  u32 *entries_to_delete = 0;
2489  u32 fib_index;
2490  int i;
2491 
2492  fib_index = fib_table_find (FIB_PROTOCOL_IP4, fib_id);
2493  if (~0 == fib_index)
2494  return VNET_API_ERROR_NO_SUCH_ENTRY;
2495 
2496  vec_foreach (pa, am->proxy_arps)
2497  {
2498  if (pa->fib_index == fib_index)
2499  {
2500  vec_add1 (entries_to_delete, pa - am->proxy_arps);
2501  }
2502  }
2503 
2504  for (i = 0; i < vec_len (entries_to_delete); i++)
2505  {
2506  vec_delete (am->proxy_arps, 1, entries_to_delete[i]);
2507  }
2508 
2509  vec_free (entries_to_delete);
2510 
2511  return 0;
2512 }
2513 
2514 static clib_error_t *
2516  unformat_input_t * input, vlib_cli_command_t * cmd)
2517 {
2518  vnet_main_t *vnm = vnet_get_main ();
2519  u32 sw_if_index;
2520  ethernet_arp_ip4_over_ethernet_address_t lo_addr, hi_addr, addr;
2521  int addr_valid = 0;
2522  int is_del = 0;
2523  int count = 1;
2524  u32 fib_index = 0;
2525  u32 fib_id;
2526  int is_proxy = 0;
2528 
2529  flags = IP_NEIGHBOR_FLAG_NONE;
2530 
2531  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2532  {
2533  /* set ip arp TenGigE1/1/0/1 1.2.3.4 aa:bb:... or aabb.ccdd... */
2534  if (unformat (input, "%U %U %U",
2535  unformat_vnet_sw_interface, vnm, &sw_if_index,
2536  unformat_ip4_address, &addr.ip4,
2537  unformat_mac_address_t, &addr.mac))
2538  addr_valid = 1;
2539 
2540  else if (unformat (input, "delete") || unformat (input, "del"))
2541  is_del = 1;
2542 
2543  else if (unformat (input, "static"))
2544  flags |= IP_NEIGHBOR_FLAG_STATIC;
2545 
2546  else if (unformat (input, "no-fib-entry"))
2548 
2549  else if (unformat (input, "count %d", &count))
2550  ;
2551 
2552  else if (unformat (input, "fib-id %d", &fib_id))
2553  {
2554  fib_index = fib_table_find (FIB_PROTOCOL_IP4, fib_id);
2555 
2556  if (~0 == fib_index)
2557  return clib_error_return (0, "fib ID %d doesn't exist\n", fib_id);
2558  }
2559 
2560  else if (unformat (input, "proxy %U - %U",
2561  unformat_ip4_address, &lo_addr.ip4,
2562  unformat_ip4_address, &hi_addr.ip4))
2563  is_proxy = 1;
2564  else
2565  break;
2566  }
2567 
2568  if (is_proxy)
2569  {
2570  (void) vnet_proxy_arp_add_del (&lo_addr.ip4, &hi_addr.ip4,
2571  fib_index, is_del);
2572  return 0;
2573  }
2574 
2575  if (addr_valid)
2576  {
2577  int i;
2578 
2579  for (i = 0; i < count; i++)
2580  {
2581  if (is_del == 0)
2582  {
2583  uword event_type, *event_data = 0;
2584 
2585  /* Park the debug CLI until the arp entry is installed */
2587  (vnm, &addr.ip4, vlib_current_process (vm),
2588  1 /* type */ , 0 /* data */ );
2589 
2590  vnet_arp_set_ip4_over_ethernet (vnm, sw_if_index, &addr, flags);
2591 
2593  event_type = vlib_process_get_events (vm, &event_data);
2594  vec_reset_length (event_data);
2595  if (event_type != 1)
2596  clib_warning ("event type %d unexpected", event_type);
2597  }
2598  else
2599  vnet_arp_unset_ip4_over_ethernet (vnm, sw_if_index, &addr);
2600 
2602  }
2603  }
2604  else
2605  {
2606  return clib_error_return (0, "unknown input `%U'",
2607  format_unformat_error, input);
2608  }
2609 
2610  return 0;
2611 }
2612 
2613 /* *INDENT-OFF* */
2614 /*?
2615  * Add or delete IPv4 ARP cache entries.
2616  *
2617  * @note 'set ip arp' options (e.g. delete, static, 'fib-id <id>',
2618  * 'count <number>', 'interface ip4_addr mac_addr') can be added in
2619  * any order and combination.
2620  *
2621  * @cliexpar
2622  * @parblock
2623  * Add or delete IPv4 ARP cache entries as follows. MAC Address can be in
2624  * either aa:bb:cc:dd:ee:ff format or aabb.ccdd.eeff format.
2625  * @cliexcmd{set ip arp GigabitEthernet2/0/0 6.0.0.3 dead.beef.babe}
2626  * @cliexcmd{set ip arp delete GigabitEthernet2/0/0 6.0.0.3 de:ad:be:ef:ba:be}
2627  *
2628  * To add or delete an IPv4 ARP cache entry to or from a specific fib
2629  * table:
2630  * @cliexcmd{set ip arp fib-id 1 GigabitEthernet2/0/0 6.0.0.3 dead.beef.babe}
2631  * @cliexcmd{set ip arp fib-id 1 delete GigabitEthernet2/0/0 6.0.0.3 dead.beef.babe}
2632  *
2633  * Add or delete IPv4 static ARP cache entries as follows:
2634  * @cliexcmd{set ip arp static GigabitEthernet2/0/0 6.0.0.3 dead.beef.babe}
2635  * @cliexcmd{set ip arp static delete GigabitEthernet2/0/0 6.0.0.3 dead.beef.babe}
2636  *
2637  * For testing / debugging purposes, the 'set ip arp' command can add or
2638  * delete multiple entries. Supply the 'count N' parameter:
2639  * @cliexcmd{set ip arp count 10 GigabitEthernet2/0/0 6.0.0.3 dead.beef.babe}
2640  * @endparblock
2641  ?*/
2642 VLIB_CLI_COMMAND (ip_arp_add_del_command, static) = {
2643  .path = "set ip arp",
2644  .short_help =
2645  "set ip arp [del] <intfc> <ip-address> <mac-address> [static] [no-fib-entry] [count <count>] [fib-id <fib-id>] [proxy <lo-addr> - <hi-addr>]",
2646  .function = ip_arp_add_del_command_fn,
2647 };
2648 /* *INDENT-ON* */
2649 
2650 static clib_error_t *
2653  input, vlib_cli_command_t * cmd)
2654 {
2655  vnet_main_t *vnm = vnet_get_main ();
2656  u32 sw_if_index;
2657  int enable = 0;
2658 
2659  sw_if_index = ~0;
2660 
2661  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2662  {
2663  if (unformat (input, "%U", unformat_vnet_sw_interface,
2664  vnm, &sw_if_index))
2665  ;
2666  else if (unformat (input, "enable") || unformat (input, "on"))
2667  enable = 1;
2668  else if (unformat (input, "disable") || unformat (input, "off"))
2669  enable = 0;
2670  else
2671  break;
2672  }
2673 
2674  if (~0 == sw_if_index)
2675  return clib_error_return (0, "unknown input '%U'",
2676  format_unformat_error, input);
2677 
2678  vnet_proxy_arp_enable_disable (vnm, sw_if_index, enable);
2679 
2680  return 0;
2681 }
2682 
2683 /* *INDENT-OFF* */
2684 /*?
2685  * Enable proxy-arp on an interface. The vpp stack will answer ARP
2686  * requests for the indicated address range. Multiple proxy-arp
2687  * ranges may be provisioned.
2688  *
2689  * @note Proxy ARP as a technology is infamous for blackholing traffic.
2690  * Also, the underlying implementation has not been performance-tuned.
2691  * Avoid creating an unnecessarily large set of ranges.
2692  *
2693  * @cliexpar
2694  * To enable proxy arp on a range of addresses, use:
2695  * @cliexcmd{set ip arp proxy 6.0.0.1 - 6.0.0.11}
2696  * Append 'del' to delete a range of proxy ARP addresses:
2697  * @cliexcmd{set ip arp proxy 6.0.0.1 - 6.0.0.11 del}
2698  * You must then specifically enable proxy arp on individual interfaces:
2699  * @cliexcmd{set interface proxy-arp GigabitEthernet0/8/0 enable}
2700  * To disable proxy arp on an individual interface:
2701  * @cliexcmd{set interface proxy-arp GigabitEthernet0/8/0 disable}
2702  ?*/
2703 VLIB_CLI_COMMAND (set_int_proxy_enable_command, static) = {
2704  .path = "set interface proxy-arp",
2705  .short_help =
2706  "set interface proxy-arp <intfc> [enable|disable]",
2707  .function = set_int_proxy_arp_command_fn,
2708 };
2709 /* *INDENT-ON* */
2710 
2711 
2712 /*
2713  * ARP/ND Termination in a L2 Bridge Domain based on IP4/IP6 to MAC
2714  * hash tables mac_by_ip4 and mac_by_ip6 for each BD.
2715  */
2716 typedef enum
2717 {
2721 } arp_term_next_t;
2722 
2724 
2725 static uword
2727  vlib_node_runtime_t * node, vlib_frame_t * frame)
2728 {
2729  l2input_main_t *l2im = &l2input_main;
2730  u32 n_left_from, next_index, *from, *to_next;
2731  u32 n_replies_sent = 0;
2732  u16 last_bd_index = ~0;
2733  l2_bridge_domain_t *last_bd_config = 0;
2734  l2_input_config_t *cfg0;
2735 
2736  from = vlib_frame_vector_args (frame);
2737  n_left_from = frame->n_vectors;
2738  next_index = node->cached_next_index;
2739 
2740  while (n_left_from > 0)
2741  {
2742  u32 n_left_to_next;
2743 
2744  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
2745 
2746  while (n_left_from > 0 && n_left_to_next > 0)
2747  {
2748  vlib_buffer_t *p0;
2749  ethernet_header_t *eth0;
2750  ethernet_arp_header_t *arp0;
2751  ip6_header_t *iph0;
2752  u8 *l3h0;
2753  u32 pi0, error0, next0, sw_if_index0;
2754  u16 ethertype0;
2755  u16 bd_index0;
2756  u32 ip0;
2757  u8 *macp0;
2758 
2759  pi0 = from[0];
2760  to_next[0] = pi0;
2761  from += 1;
2762  to_next += 1;
2763  n_left_from -= 1;
2764  n_left_to_next -= 1;
2765 
2766  p0 = vlib_get_buffer (vm, pi0);
2767  // Terminate only local (SHG == 0) ARP
2768  if (vnet_buffer (p0)->l2.shg != 0)
2769  goto next_l2_feature;
2770 
2771  eth0 = vlib_buffer_get_current (p0);
2772  l3h0 = (u8 *) eth0 + vnet_buffer (p0)->l2.l2_len;
2773  ethertype0 = clib_net_to_host_u16 (*(u16 *) (l3h0 - 2));
2774  arp0 = (ethernet_arp_header_t *) l3h0;
2775 
2776  if (ethertype0 != ETHERNET_TYPE_ARP)
2777  goto check_ip6_nd;
2778 
2779  if ((arp0->opcode !=
2780  clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_request)) &&
2781  (arp0->opcode !=
2782  clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_reply)))
2783  goto check_ip6_nd;
2784 
2785  /* Must be ARP request/reply packet here */
2786  if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) &&
2787  (p0->flags & VLIB_BUFFER_IS_TRACED)))
2788  {
2789  u8 *t0 = vlib_add_trace (vm, node, p0,
2790  sizeof (ethernet_arp_input_trace_t));
2791  clib_memcpy_fast (t0, l3h0,
2792  sizeof (ethernet_arp_input_trace_t));
2793  }
2794 
2795  error0 = 0;
2796  error0 =
2797  (arp0->l2_type !=
2798  clib_net_to_host_u16 (ETHERNET_ARP_HARDWARE_TYPE_ethernet)
2799  ? ETHERNET_ARP_ERROR_l2_type_not_ethernet : error0);
2800  error0 =
2801  (arp0->l3_type !=
2802  clib_net_to_host_u16 (ETHERNET_TYPE_IP4) ?
2803  ETHERNET_ARP_ERROR_l3_type_not_ip4 : error0);
2804 
2805  sw_if_index0 = vnet_buffer (p0)->sw_if_index[VLIB_RX];
2806 
2807  if (error0)
2808  goto drop;
2809 
2810  /* Trash ARP packets whose ARP-level source addresses do not
2811  match, or if requester address is mcast */
2812  if (PREDICT_FALSE
2814  arp0->ip4_over_ethernet[0].
2815  mac.bytes))
2816  || ethernet_address_cast (arp0->ip4_over_ethernet[0].mac.bytes))
2817  {
2818  /* VRRP virtual MAC may be different to SMAC in ARP reply */
2820  (arp0->ip4_over_ethernet[0].mac.bytes, vrrp_prefix))
2821  {
2822  error0 = ETHERNET_ARP_ERROR_l2_address_mismatch;
2823  goto drop;
2824  }
2825  }
2826  if (PREDICT_FALSE
2827  (ip4_address_is_multicast (&arp0->ip4_over_ethernet[0].ip4)))
2828  {
2829  error0 = ETHERNET_ARP_ERROR_l3_src_address_not_local;
2830  goto drop;
2831  }
2832 
2833  /* Check if anyone want ARP request events for L2 BDs */
2834  {
2836  if (am->wc_ip4_arp_publisher_node != (uword) ~ 0)
2837  vnet_arp_wc_publish (sw_if_index0, &arp0->ip4_over_ethernet[0]);
2838  }
2839 
2840  /* lookup BD mac_by_ip4 hash table for MAC entry */
2841  ip0 = arp0->ip4_over_ethernet[1].ip4.as_u32;
2842  bd_index0 = vnet_buffer (p0)->l2.bd_index;
2843  if (PREDICT_FALSE ((bd_index0 != last_bd_index)
2844  || (last_bd_index == (u16) ~ 0)))
2845  {
2846  last_bd_index = bd_index0;
2847  last_bd_config = vec_elt_at_index (l2im->bd_configs, bd_index0);
2848  }
2849  macp0 = (u8 *) hash_get (last_bd_config->mac_by_ip4, ip0);
2850 
2851  if (PREDICT_FALSE (!macp0))
2852  goto next_l2_feature; /* MAC not found */
2853  if (PREDICT_FALSE (arp0->ip4_over_ethernet[0].ip4.as_u32 ==
2854  arp0->ip4_over_ethernet[1].ip4.as_u32))
2855  goto next_l2_feature; /* GARP */
2856 
2857  /* MAC found, send ARP reply -
2858  Convert ARP request packet to ARP reply */
2859  arp0->opcode = clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_reply);
2860  arp0->ip4_over_ethernet[1] = arp0->ip4_over_ethernet[0];
2861  arp0->ip4_over_ethernet[0].ip4.as_u32 = ip0;
2862  mac_address_from_bytes (&arp0->ip4_over_ethernet[0].mac, macp0);
2863  clib_memcpy_fast (eth0->dst_address, eth0->src_address, 6);
2864  clib_memcpy_fast (eth0->src_address, macp0, 6);
2865  n_replies_sent += 1;
2866 
2867  output_response:
2868  /* For BVI, need to use l2-fwd node to send ARP reply as
2869  l2-output node cannot output packet to BVI properly */
2870  cfg0 = vec_elt_at_index (l2im->configs, sw_if_index0);
2871  if (PREDICT_FALSE (cfg0->bvi))
2872  {
2873  vnet_buffer (p0)->l2.feature_bitmap |= L2INPUT_FEAT_FWD;
2874  vnet_buffer (p0)->sw_if_index[VLIB_RX] = 0;
2875  goto next_l2_feature;
2876  }
2877 
2878  /* Send ARP/ND reply back out input interface through l2-output */
2879  vnet_buffer (p0)->sw_if_index[VLIB_TX] = sw_if_index0;
2880  next0 = ARP_TERM_NEXT_L2_OUTPUT;
2881  vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
2882  to_next, n_left_to_next, pi0,
2883  next0);
2884  continue;
2885 
2886  check_ip6_nd:
2887  /* IP6 ND event notification or solicitation handling to generate
2888  local response instead of flooding */
2889  iph0 = (ip6_header_t *) l3h0;
2890  if (PREDICT_FALSE (ethertype0 == ETHERNET_TYPE_IP6 &&
2891  iph0->protocol == IP_PROTOCOL_ICMP6 &&
2893  (&iph0->src_address)))
2894  {
2895  sw_if_index0 = vnet_buffer (p0)->sw_if_index[VLIB_RX];
2896  if (vnet_ip6_nd_term
2897  (vm, node, p0, eth0, iph0, sw_if_index0,
2898  vnet_buffer (p0)->l2.bd_index))
2899  goto output_response;
2900  }
2901 
2902  next_l2_feature:
2903  {
2905  L2INPUT_FEAT_ARP_TERM);
2906  vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
2907  to_next, n_left_to_next,
2908  pi0, next0);
2909  continue;
2910  }
2911 
2912  drop:
2913  if (0 == arp0->ip4_over_ethernet[0].ip4.as_u32 ||
2914  (arp0->ip4_over_ethernet[0].ip4.as_u32 ==
2915  arp0->ip4_over_ethernet[1].ip4.as_u32))
2916  {
2917  error0 = ETHERNET_ARP_ERROR_gratuitous_arp;
2918  }
2919  next0 = ARP_TERM_NEXT_DROP;
2920  p0->error = node->errors[error0];
2921 
2922  vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
2923  to_next, n_left_to_next, pi0,
2924  next0);
2925  }
2926 
2927  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
2928  }
2929 
2930  vlib_error_count (vm, node->node_index,
2931  ETHERNET_ARP_ERROR_replies_sent, n_replies_sent);
2932  return frame->n_vectors;
2933 }
2934 
2935 /* *INDENT-OFF* */
2937  .function = arp_term_l2bd,
2938  .name = "arp-term-l2bd",
2939  .vector_size = sizeof (u32),
2940  .n_errors = ETHERNET_ARP_N_ERROR,
2941  .error_strings = ethernet_arp_error_strings,
2942  .n_next_nodes = ARP_TERM_N_NEXT,
2943  .next_nodes = {
2944  [ARP_TERM_NEXT_L2_OUTPUT] = "l2-output",
2945  [ARP_TERM_NEXT_DROP] = "error-drop",
2946  },
2947  .format_buffer = format_ethernet_arp_header,
2948  .format_trace = format_arp_term_input_trace,
2949 };
2950 /* *INDENT-ON* */
2951 
2952 clib_error_t *
2954 {
2955  // Initialize the feature next-node indexes
2957  arp_term_l2bd_node.index,
2961  return 0;
2962 }
2963 
2965 
2966 void
2968 {
2969  if (e->sw_if_index == sw_if_index)
2970  {
2973  }
2974 }
2975 
2976 void
2978 {
2981  adj_index_t ai;
2982 
2983  /* *INDENT-OFF* */
2984  pool_foreach (e, am->ip4_entry_pool,
2985  ({
2986  change_arp_mac (sw_if_index, e);
2987  }));
2988  /* *INDENT-ON* */
2989 
2990  ai = adj_glean_get (FIB_PROTOCOL_IP4, sw_if_index);
2991 
2992  if (ADJ_INDEX_INVALID != ai)
2994 }
2995 
2996 void
2998 {
2999  ip4_main_t *i4m = &ip4_main;
3000  ip4_address_t *ip4_addr = ip4_interface_first_address (i4m, sw_if_index, 0);
3001 
3002  send_ip4_garp_w_addr (vm, ip4_addr, sw_if_index);
3003 }
3004 
3005 void
3007  const ip4_address_t * ip4_addr, u32 sw_if_index)
3008 {
3009  ip4_main_t *i4m = &ip4_main;
3010  vnet_main_t *vnm = vnet_get_main ();
3011  u8 *rewrite, rewrite_len;
3012  vnet_hw_interface_t *hi = vnet_get_sup_hw_interface (vnm, sw_if_index);
3013 
3014  if (ip4_addr)
3015  {
3016  clib_warning ("Sending GARP for IP4 address %U on sw_if_idex %d",
3017  format_ip4_address, ip4_addr, sw_if_index);
3018 
3019  /* Form GARP packet for output - Gratuitous ARP is an ARP request packet
3020  where the interface IP/MAC pair is used for both source and request
3021  MAC/IP pairs in the request */
3022  u32 bi = 0;
3024  (vm, &i4m->ip4_arp_request_packet_template, &bi);
3025 
3026  if (!h)
3027  return;
3028 
3031  h->ip4_over_ethernet[0].ip4 = ip4_addr[0];
3032  h->ip4_over_ethernet[1].ip4 = ip4_addr[0];
3033 
3034  /* Setup MAC header with ARP Etype and broadcast DMAC */
3035  vlib_buffer_t *b = vlib_get_buffer (vm, bi);
3036  rewrite =
3037  ethernet_build_rewrite (vnm, sw_if_index, VNET_LINK_ARP,
3039  rewrite_len = vec_len (rewrite);
3040  vlib_buffer_advance (b, -rewrite_len);
3042  clib_memcpy_fast (e->dst_address, rewrite, rewrite_len);
3043  vec_free (rewrite);
3044 
3045  /* Send GARP packet out the specified interface */
3046  vnet_buffer (b)->sw_if_index[VLIB_RX] =
3047  vnet_buffer (b)->sw_if_index[VLIB_TX] = sw_if_index;
3049  u32 *to_next = vlib_frame_vector_args (f);
3050  to_next[0] = bi;
3051  f->n_vectors = 1;
3053  }
3054 }
3055 
3056 /*
3057  * Remove any arp entries associated with the specified interface
3058  */
3059 static clib_error_t *
3061 {
3063 
3064  if (!is_add && sw_if_index != ~0)
3065  {
3067  /* *INDENT-OFF* */
3068  pool_foreach (e, am->ip4_entry_pool, ({
3069  if (e->sw_if_index != sw_if_index)
3070  continue;
3071  vnet_arp_set_ip4_over_ethernet_rpc_args_t args = {
3072  .sw_if_index = sw_if_index,
3073  .ip4 = e->ip4_address,
3074  };
3076  }));
3077  /* *INDENT-ON* */
3078  arp_disable (am, sw_if_index);
3079  }
3080  else if (is_add)
3081  {
3082  vnet_feature_enable_disable ("arp", "arp-disabled",
3083  sw_if_index, 1, NULL, 0);
3084  }
3085 
3086  return (NULL);
3087 }
3088 
3090 
3091 /*
3092  * fd.io coding-style-patch-verification: ON
3093  *
3094  * Local Variables:
3095  * eval: (c-set-style "gnu")
3096  * End:
3097  */
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:439
ip_neighbor_flags_t flags
Definition: arp.h:31
#define vnet_rewrite_one_header(rw0, p0, most_likely_size)
Definition: rewrite.h:198
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:124
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:2276
static vlib_node_registration_t arp_proxy_node
(constructor) VLIB_REGISTER_NODE (arp_proxy_node)
Definition: arp.c:1693
vmrglw vmrglh hi
int vnet_arp_set_ip4_over_ethernet(vnet_main_t *vnm, u32 sw_if_index, const ethernet_arp_ip4_over_ethernet_address_t *a, ip_neighbor_flags_t flags)
Definition: arp.c:2366
#define pool_next_index(P, I)
Return next occupied pool index after i, useful for safe iteration.
Definition: pool.h:522
fib_node_index_t fib_table_entry_path_add(u32 fib_index, const fib_prefix_t *prefix, fib_source_t source, fib_entry_flag_t flags, dpo_proto_t next_hop_proto, const ip46_address_t *next_hop, u32 next_hop_sw_if_index, u32 next_hop_fib_index, u32 next_hop_weight, fib_mpls_label_t *next_hop_labels, fib_route_path_flags_t path_flags)
Add one path to an entry (aka route) in the FIB.
Definition: fib_table.c:532
struct pg_ethernet_arp_header_t::@131 ip4_over_ethernet[2]
typedef address
Definition: ip_types.api:83
#define VNET_REWRITE_FOR_SW_INTERFACE_ADDRESS_BROADCAST
Definition: rewrite.h:221
static uword arp_term_l2bd(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
Definition: arp.c:2726
#define hash_set(h, key, value)
Definition: hash.h:255
l2_input_config_t * configs
Definition: l2_input.h:61
u32 flags
Definition: vhost_user.h:141
static void arp_enable(ethernet_arp_main_t *am, u32 sw_if_index)
Definition: arp.c:453
An entry in a FIB table.
Definition: fib_entry.h:468
ip4_table_bind_function_t * function
Definition: ip4.h:92
static uword arp_disabled(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
Definition: arp.c:1113
#define CLIB_UNUSED(x)
Definition: clib.h:82
u8 * format_ethernet_arp_ip4_entry(u8 *s, va_list *va)
Definition: arp.c:262
arp_dst_fib_type
Definition: arp.c:1211
ip4_add_del_interface_address_callback_t * add_del_interface_address_callbacks
Functions to call when interface address changes.
Definition: ip4.h:139
vl_api_mac_address_t mac
Definition: l2.api:490
#define hash_unset(h, key)
Definition: hash.h:261
a
Definition: bitmap.h:538
int vnet_arp_unset_ip4_over_ethernet(vnet_main_t *vnm, u32 sw_if_index, const ethernet_arp_ip4_over_ethernet_address_t *a)
Control Plane hook to remove an ARP entry.
Definition: arp.c:1931
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:593
static uword arp_reply(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
Definition: arp.c:1244
u32 enabled
Is ARP enabled on this interface.
Definition: arp.c:56
uword unformat_pg_arp_header(unformat_input_t *input, va_list *args)
Definition: arp.c:1883
static void pg_ethernet_arp_header_init(pg_ethernet_arp_header_t *p)
Definition: arp.c:1866
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:2227
static void increment_ip4_and_mac_address(ethernet_arp_ip4_over_ethernet_address_t *a)
Definition: arp.c:2343
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:400
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:2062
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:1791
vnet_interface_main_t interface_main
Definition: vnet.h:56
pending_resolution_t * pending_resolutions
Definition: arp.c:88
u32 sw_if_index
Definition: arp.h:94
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
#define clib_memcpy_fast(a, b, c)
Definition: string.h:81
static vlib_node_registration_t arp_reply_node
(constructor) VLIB_REGISTER_NODE (arp_reply_node)
Definition: arp.c:1677
vnet_link_t adj_get_link_type(adj_index_t ai)
Return the link type of the adjacency.
Definition: adj.c:468
#define NULL
Definition: clib.h:58
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:278
static f64 vlib_time_now(vlib_main_t *vm)
Definition: main.h:258
Broadcasr Adjacency.
Definition: adj.h:85
IP unicast adjacency.
Definition: adj.h:221
Information related to the source of a FIB entry.
Definition: fib_entry.h:360
struct ethernet_arp_interface_t_ ethernet_arp_interface_t
Per-interface ARP configuration and state.
#define foreach_arp_disabled_error
Definition: arp.c:1095
void change_arp_mac(u32 sw_if_index, ethernet_arp_ip4_entry_t *e)
Definition: arp.c:2967
static u8 * format_ethernet_arp_header(u8 *s, va_list *va)
Definition: arp.c:215
u8 src_address[6]
Definition: packet.h:56
static clib_error_t * set_int_proxy_arp_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: arp.c:2651
clib_error_t * ip4_set_arp_limit(u32 arp_limit)
Definition: arp.c:1919
static uword arp_input(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
Definition: arp.c:1020
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:522
word vnet_sw_interface_compare(vnet_main_t *vnm, uword sw_if_index0, uword sw_if_index1)
Definition: interface.c:1206
void arp_update_adjacency(vnet_main_t *vnm, u32 sw_if_index, u32 ai)
Definition: arp.c:519
static vlib_node_registration_t arp_disabled_node
(constructor) VLIB_REGISTER_NODE (arp_disabled_node)
Definition: arp.c:1662
vl_api_address_t src
Definition: gre.api:51
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:2120
static uword unformat_ethernet_arp_opcode_host_byte_order(unformat_input_t *input, va_list *args)
Definition: arp.c:174
#define vec_add2(V, P, N)
Add N elements to end of vector V, return pointer to new elements in P.
Definition: vec.h:560
int i
static_always_inline void mac_address_copy(mac_address_t *dst, const mac_address_t *src)
Definition: mac_address.h:128
adj_index_t adj_glean_get(fib_protocol_t proto, u32 sw_if_index)
Get an existing glean.
Definition: adj_glean.c:119
uword unformat_user(unformat_input_t *input, unformat_function_t *func,...)
Definition: unformat.c:989
arp_reply_next_t
Definition: arp.c:945
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:598
static void arp_enable_disable_interface(ip4_main_t *im, uword opaque, u32 sw_if_index, u32 is_enable)
Definition: arp.c:2045
pg_edit_t l2_type
Definition: arp.c:1855
static vnet_sw_interface_t * vnet_get_sw_interface(vnet_main_t *vnm, u32 sw_if_index)
const fib_prefix_t * fib_entry_get_prefix(fib_node_index_t fib_entry_index)
Definition: fib_entry.c:1681
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
uword * opcode_by_name
Definition: arp.c:84
unformat_function_t unformat_vnet_sw_interface
u8 data[128]
Definition: ipsec.api:249
u8 feature_arc_index
Definition: arp.c:110
static uword ip4_address_is_multicast(const ip4_address_t *a)
Definition: ip4_packet.h:318
vlib_error_t * errors
Vector of errors for this node.
Definition: node.h:468
Definition: fib_entry.h:283
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:236
vhost_vring_addr_t addr
Definition: vhost_user.h:147
ip6_address_t src_address
Definition: ip6_packet.h:383
unsigned char u8
Definition: types.h:56
static u32 vnet_l2_feature_next(vlib_buffer_t *b, u32 *next_nodes, u32 feat_bit)
Return the graph node index for the feature corresponding to the next set bit after clearing the curr...
Definition: feat_bitmap.h:94
#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:360
vnet_link_t ia_link
link/ether-type 1 bytes
Definition: adj.h:242
union ip_adjacency_t_::@48 sub_type
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:2254
u32 send_garp_na_process_node_index
Definition: arp.c:131
Adjacency to punt this packet.
Definition: adj.h:55
VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION(ethernet_arp_sw_interface_up_down)
void adj_glean_update_rewrite(adj_index_t adj_index)
adj_glean_update_rewrite
Definition: adj_glean.c:101
static const u8 vrrp_prefix[]
Definition: arp.c:128
u32 ip4_fib_table_get_index_for_sw_if_index(u32 sw_if_index)
Definition: ip4_fib.c:224
format_function_t format_ip4_address
Definition: format.h:75
static ip_adjacency_t * adj_get(adj_index_t adj_index)
Get a pointer to an adjacency object from its index.
Definition: adj.h:433
pg_edit_t n_l3_address_bytes
Definition: arp.c:1856
#define static_always_inline
Definition: clib.h:99
void * vlib_packet_template_get_packet(vlib_main_t *vm, vlib_packet_template_t *t, u32 *bi_result)
Definition: buffer.c:389
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:493
ip4_enable_disable_interface_callback_t * enable_disable_interface_callbacks
Functions to call when interface becomes IPv4 enabled/disable.
Definition: ip4.h:143
unformat_function_t unformat_ip4_address
Definition: format.h:70
vl_api_interface_index_t sw_if_index
Definition: gre.api:50
ethernet_arp_ip4_over_ethernet_address_t ip4_over_ethernet[2]
Definition: arp_packet.h:141
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:173
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:516
static ethernet_arp_ip4_entry_t * force_reuse_arp_entry(void)
Definition: arp.c:658
static uword ethernet_address_cast(u8 *a)
Definition: packet.h:67
pending_resolution_t * mac_changes
Definition: arp.c:92
enum ip_neighbor_flags_t_ ip_neighbor_flags_t
u8 dst_address[6]
Definition: packet.h:55
static int vnet_arp_set_ip4_over_ethernet_internal(vnet_main_t *vnm, vnet_arp_set_ip4_over_ethernet_rpc_args_t *args)
Definition: arp.c:690
u8 * format_white_space(u8 *s, va_list *va)
Definition: std-formats.c:129
static int ip4_arp_entry_sort(void *a1, void *a2)
Definition: arp.c:1750
enum adj_walk_rc_t_ adj_walk_rc_t
return codes from a adjacency walker callback function
void proxy_arp_walk(proxy_arp_walk_t cb, void *data)
Definition: arp.c:2385
enum arp_input_next_t_ arp_input_next_t
#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:203
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:187
#define clib_error_return(e, args...)
Definition: error.h:99
ethernet_arp_hardware_type_t
Definition: arp_packet.h:91
static u8 * format_ethernet_arp_input_trace(u8 *s, va_list *va)
Definition: arp.c:288
void vl_api_rpc_call_main_thread(void *fp, u8 *data, u32 data_length)
Definition: vlib_api.c:600
#define foreach_ethernet_arp_opcode
Definition: arp_packet.h:63
uword * pending_resolutions_by_address
Definition: arp.c:87
unsigned int u32
Definition: types.h:88
static void * pg_create_edit_group(pg_stream_t *s, int n_edit_bytes, int n_packet_bytes, u32 *group_index)
Definition: pg.h:228
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:1075
u16 fp_len
The mask length.
Definition: fib_types.h:207
static enum arp_dst_fib_type arp_dst_fib_check(const fib_node_index_t fei, fib_entry_flag_t *flags)
Definition: arp.c:1224
int(* arp_change_event_cb_t)(u32 pool_index, const mac_address_t *mac, u32 sw_if_index, const ip4_address_t *address)
Definition: arp.h:72
static ethernet_arp_ip4_entry_t * arp_entry_find(ethernet_arp_interface_t *eai, const ip4_address_t *addr)
Definition: arp.c:407
#define hash_create_string(elts, value_bytes)
Definition: hash.h:690
pg_edit_t l3_type
Definition: arp.c:1855
static adj_walk_rc_t arp_mk_complete_walk(adj_index_t ai, void *ctx)
Definition: arp.c:426
Per-interface ARP configuration and state.
Definition: arp.c:46
static heap_elt_t * first(heap_header_t *h)
Definition: heap.c:59
vlib_error_t error
Error code for buffers to be enqueued to error handler.
Definition: buffer.h:136
#define FOR_EACH_SRC_ADDED(_entry, _src, _source, action)
static int arp_is_enabled(ethernet_arp_main_t *am, u32 sw_if_index)
Definition: arp.c:444
Definition: fib_entry.h:286
#define hash_get(h, key)
Definition: hash.h:249
format_function_t format_vnet_sw_interface_name
void adj_mcast_update_rewrite(adj_index_t adj_index, u8 *rewrite, u8 offset)
adj_mcast_update_rewrite
Definition: adj_mcast.c:102
#define ADJ_INDEX_INVALID
Invalid ADJ index - used when no adj is known likewise blazoned capitals INVALID speak volumes where ...
Definition: adj_types.h:36
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:514
static ethernet_header_t * ethernet_buffer_get_header(vlib_buffer_t *b)
Definition: ethernet.h:376
static_always_inline void mac_address_from_bytes(mac_address_t *mac, const u8 *bytes)
Definition: mac_address.h:92
#define foreach_ethernet_arp_error
Definition: arp.c:952
vlib_main_t * vlib_main
Definition: vnet.h:80
int vnet_proxy_arp_enable_disable(vnet_main_t *vnm, u32 sw_if_index, u8 enable)
Definition: arp.c:2398
static void arp_mk_complete(adj_index_t ai, ethernet_arp_ip4_entry_t *e)
Definition: arp.c:383
static void vlib_process_signal_event(vlib_main_t *vm, uword node_index, uword type_opaque, uword data)
Definition: node_funcs.h:934
Adjacency source.
Definition: fib_entry.h:113
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:226
uword type_opaque
Definition: arp.c:74
vlib_frame_t * data_callback(flow_report_main_t *frm, flow_report_t *fr, vlib_frame_t *f, u32 *to_next, u32 node_index)
#define ETHERNET_ARP_ARGS_FLUSH
Definition: arp.c:123
ip4_address_t ip4_address
Definition: arp.h:27
long ctx[MAX_CONNS]
Definition: main.c:144
mac_address_t mac
Definition: arp.h:29
struct _unformat_input_t unformat_input_t
u32 sw_if_index
Definition: arp.h:26
unsigned short u16
Definition: types.h:57
ethernet_arp_ip4_entry_t * ip4_neighbors_pool(void)
Definition: arp.c:1765
void vlib_put_frame_to_node(vlib_main_t *vm, u32 to_node_index, vlib_frame_t *f)
Definition: main.c:196
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:229
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:286
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:828
#define PREDICT_FALSE(x)
Definition: clib.h:111
This packet matches an "interface route" and packets need to be passed to ARP to find rewrite string ...
Definition: adj.h:68
vnet_sw_interface_flags_t flags
Definition: interface.h:699
ethernet_arp_interface_t * ethernet_arp_by_sw_if_index
Per interface state.
Definition: arp.c:101
u32 node_index
Node index.
Definition: node.h:494
static clib_error_t * ethernet_arp_init(vlib_main_t *vm)
Definition: arp.c:2155
static_always_inline int mac_address_equal(const mac_address_t *a, const mac_address_t *b)
Definition: mac_address.h:140
#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:338
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:1248
static clib_error_t * vnet_arp_delete_sw_interface(vnet_main_t *vnm, u32 sw_if_index, u32 is_add)
Definition: arp.c:3060
ethernet_arp_opcode_t
Definition: arp_packet.h:98
uword unformat_mac_address_t(unformat_input_t *input, va_list *args)
Definition: mac_address.c:37
u32 fib_entry_get_resolving_interface(fib_node_index_t entry_index)
Definition: fib_entry.c:1448
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:2515
u8 * format_ethernet_type(u8 *s, va_list *args)
Definition: format.c:64
fib_node_index_t ip4_fib_table_lookup(const ip4_fib_t *fib, const ip4_address_t *addr, u32 len)
Definition: ip4_fib.c:291
static void arp_adj_fib_add(ethernet_arp_ip4_entry_t *e, u32 fib_index)
Definition: arp.c:616
struct ip_adjacency_t_::@48::@49 nbr
IP_LOOKUP_NEXT_ARP/IP_LOOKUP_NEXT_REWRITE.
ethernet_proxy_arp_t * proxy_arps
Definition: arp.c:104
This packet matches an "incomplete adjacency" and packets need to be passed to ARP to find rewrite st...
Definition: adj.h:63
void send_ip4_garp(vlib_main_t *vm, u32 sw_if_index)
Definition: arp.c:2997
int fib_entry_is_sourced(fib_node_index_t fib_entry_index, fib_source_t source)
Adjacency to drop this packet.
Definition: adj.h:53
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:169
#define UNFORMAT_END_OF_INPUT
Definition: format.h:145
u16 n_vectors
Definition: node.h:395
static_always_inline uword vlib_get_thread_index(void)
Definition: threads.h:213
static void arp_mk_incomplete(adj_index_t ai)
Definition: arp.c:393
vlib_main_t * vm
Definition: buffer.c:312
int ip4_address_compare(ip4_address_t *a1, ip4_address_t *a2)
Definition: ip46_cli.c:53
pg_edit_t n_l2_address_bytes
Definition: arp.c:1856
static void arp_disable(ethernet_arp_main_t *am, u32 sw_if_index)
Definition: arp.c:473
ip4_enable_disable_interface_function_t * function
Definition: ip4.h:82
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:341
static_always_inline void vnet_feature_next(u32 *next0, vlib_buffer_t *b0)
Definition: feature.h:295
ip4_add_del_interface_address_function_t * function
Definition: ip4.h:73
static ethernet_arp_main_t ethernet_arp_main
Definition: arp.c:113
static ip4_fib_t * ip4_fib_get(u32 index)
Get the FIB at the given index.
Definition: ip4_fib.h:113
static void feat_bitmap_init_next_nodes(vlib_main_t *vm, u32 node_index, u32 num_features, char **feat_names, u32 *next_nodes)
Initialize the feature next-node indexes of a graph node.
Definition: feat_bitmap.h:43
Multicast Midchain Adjacency.
Definition: adj.h:89
static int ethernet_mac_address_equal(const u8 *a, const u8 *b)
Definition: mac_address.h:85
static char * ethernet_arp_error_strings[]
Definition: arp.c:1638
#define ETHERNET_ARP_ARGS_POPULATE
Definition: arp.c:124
#define clib_warning(format, args...)
Definition: error.h:59
static vlib_node_runtime_t * vlib_node_get_runtime(vlib_main_t *vm, u32 node_index)
Get node runtime by node index.
Definition: node_funcs.h:89
ethernet_arp_reply_error_t
Definition: arp.c:970
unformat_function_t * unformat_edit
Definition: pg.h:312
u8 * format_ip_neighbor_flags(u8 *s, va_list *args)
Definition: ip_neighbor.c:51
uword * mac_changes_by_address
Definition: arp.c:91
uword wc_ip4_arp_publisher_et
Definition: arp.c:107
void wc_arp_set_publisher_node(uword node_index, uword event_type)
Definition: arp.c:1989
static void arp_adj_fib_remove(ethernet_arp_ip4_entry_t *e, u32 fib_index)
Definition: arp.c:634
u32 fib_node_index_t
A typedef of a node index.
Definition: fib_types.h:30
u32 adj_index_t
An index for adjacencies.
Definition: adj_types.h:30
void vlib_put_next_frame(vlib_main_t *vm, vlib_node_runtime_t *r, u32 next_index, u32 n_vectors_left)
Release pointer to next frame vector data.
Definition: main.c:458
int vnet_add_del_ip4_arp_change_event(vnet_main_t *vnm, arp_change_event_cb_t data_callback, u32 pid, void *address_arg, uword node_index, uword type_opaque, uword data, int is_add)
Definition: arp.c:874
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:843
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:2298
char ** l2input_get_feat_names(void)
Return an array of strings containing graph node names of each feature.
Definition: l2_input.c:62
fib_entry_t * fib_entry_get(fib_node_index_t index)
Definition: fib_entry.c:52
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:2430
enum fib_entry_flag_t_ fib_entry_flag_t
static u8 * format_ethernet_arp_opcode(u8 *s, va_list *va)
Definition: arp.c:156
void send_ip4_garp_w_addr(vlib_main_t *vm, const ip4_address_t *ip4_addr, u32 sw_if_index)
Definition: arp.c:3006
ip_neighbor_flags_t nbr_flags
Definition: arp.c:120
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:1268
u32 proxy_enabled
Is Proxy ARP enabled on this interface.
Definition: arp.c:60
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:155
This packets follow a mid-chain adjacency.
Definition: adj.h:76
clib_error_t * arp_term_init(vlib_main_t *vm)
Definition: arp.c:2953
vlib_packet_template_t ip4_arp_request_packet_template
Template used to generate IP4 ARP packets.
Definition: ip4.h:149
arp_disabled_error_t
Definition: arp.c:1098
#define hash_create(elts, value_bytes)
Definition: hash.h:696
#define ETHERNET_ARP_ARGS_REMOVE
Definition: arp.c:122
u16 cached_next_index
Next frame index that vector arguments were last enqueued to last time this node ran.
Definition: node.h:513
static int vnet_arp_wc_publish(u32 sw_if_index, const ethernet_arp_ip4_over_ethernet_address_t *a)
publish wildcard arp event
Definition: arp.c:1954
#define ASSERT(truth)
u32 arp_term_next_node_index[32]
Definition: arp.c:2723
#define vec_delete(V, N, M)
Delete N elements starting at element M.
Definition: vec.h:784
VNET_FEATURE_ARC_INIT(arp_feat, static)
The default route source.
Definition: fib_entry.h:142
IPv4 main type.
Definition: ip4.h:105
uword unformat_vlib_number_by_name(unformat_input_t *input, va_list *args)
Definition: format.c:157
void proxy_arp_intfc_walk(proxy_arp_intf_walk_t cb, void *data)
Definition: arp.c:2467
static void pg_free_edit_group(pg_stream_t *s)
Definition: pg.h:281
static_always_inline u32 arp_mk_reply(vnet_main_t *vnm, vlib_buffer_t *p0, u32 sw_if_index0, const ip4_address_t *if_addr0, ethernet_arp_header_t *arp0, ethernet_header_t *eth_rx)
Definition: arp.c:1160
arp_input_next_t_
Definition: arp.c:1012
u32 arp_delete_rotor
Definition: arp.c:97
static void vlib_buffer_advance(vlib_buffer_t *b, word l)
Advance current data pointer by the supplied (signed!) amount.
Definition: buffer.h:248
size_t count
Definition: vapi.c:47
VNET_FEATURE_INIT(arp_reply_feat_node, static)
#define clib_mem_unaligned(pointer, type)
Definition: types.h:155
format_function_t format_ip6_header
Definition: format.h:97
static char * arp_disabled_error_strings[]
Definition: arp.c:1106
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:693
static void arp_nbr_probe(ip_adjacency_t *adj)
Definition: arp.c:319
Definition: pg.h:94
#define VNET_FEATURES(...)
Definition: feature.h:435
void ethernet_register_input_type(vlib_main_t *vm, ethernet_type_t type, u32 node_index)
Definition: node.c:2053
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:2936
uword * arp_entries
Hash table of ARP entries.
Definition: arp.c:52
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
ip4_table_bind_callback_t * table_bind_callbacks
Functions to call when interface to table biding changes.
Definition: ip4.h:146
f64 time_last_updated
Definition: arp.h:33
static u32 arp_learn(vnet_main_t *vnm, ethernet_arp_main_t *am, u32 sw_if_index, const ethernet_arp_ip4_over_ethernet_address_t *addr)
Definition: arp.c:1004
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:47
ip4_address_t hi_addr
Definition: arp.c:66
l2input_main_t l2input_main
Definition: l2_input.c:128
static vlib_node_registration_t arp_input_node
(constructor) VLIB_REGISTER_NODE (arp_input_node)
Definition: arp.c:1646
#define FIB_NODE_INDEX_INVALID
Definition: fib_types.h:31
int vnet_proxy_arp_fib_reset(u32 fib_id)
Definition: arp.c:2484
fib_node_index_t fib_entry_index
The index of the adj-fib entry created.
Definition: arp.h:38
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
ip_lookup_next_t lookup_next_index
Next hop after ip4-lookup.
Definition: adj.h:236
#define hash_foreach_pair(p, v, body)
Iterate over hash pairs.
Definition: hash.h:373
Definition: fib_entry.h:282
VLIB buffer representation.
Definition: buffer.h:102
u64 uword
Definition: types.h:112
format_function_t format_vlib_time
Definition: node_funcs.h:1145
#define vec_sort_with_function(vec, f)
Sort a vector using the supplied element comparison function.
Definition: vec.h:980
#define ETHERNET_ARP_ARGS_WC_PUB
Definition: arp.c:125
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:2000
vnet_sw_interface_t * sw_interfaces
Definition: interface.h:833
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
Definition: node_funcs.h:244
static u8 * format_ethernet_arp_hardware_type(u8 *s, va_list *va)
Definition: arp.c:138
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:81
l2_bridge_domain_t * bd_configs
Definition: l2_input.h:64
static void arp_entry_free(ethernet_arp_interface_t *eai, ethernet_arp_ip4_entry_t *e)
Definition: arp.c:2216
pg_edit_t opcode
Definition: arp.c:1857
static uword arp_proxy(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
Definition: arp.c:1535
arp_term_next_t
Definition: arp.c:2716
static void vnet_arp_wc_publish_internal(vnet_main_t *vnm, vnet_arp_set_ip4_over_ethernet_rpc_args_t *args)
Definition: arp.c:1970
struct clib_bihash_value offset
template key/value backing page structure
mac_address_t mac
Definition: arp.h:96
u32 limit_arp_cache_size
Definition: arp.c:98
static uword ip6_address_is_unspecified(const ip6_address_t *a)
Definition: ip6_packet.h:310
ip4_address_t ip
Definition: arp.h:95
ip4_address_t lo_addr
Definition: arp.c:65
#define vnet_buffer(b)
Definition: buffer.h:361
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
enum arp_disabled_next_t_ arp_disabled_next_t
ip4_main_t ip4_main
Global ip4 main structure.
Definition: ip4_forward.c:921
uword node_index
Definition: arp.c:73
u8 * format_mac_address_t(u8 *s, va_list *args)
Definition: mac_address.c:27
#define vec_foreach(var, vec)
Vector iterator.
arp_change_event_cb_t data_callback
Definition: arp.c:77
uword * mac_by_ip4
Definition: l2_bd.h:101
u16 flags
Copy of main node flags.
Definition: node.h:507
static int arp_unnumbered(vlib_buffer_t *p0, u32 input_sw_if_index, u32 conn_sw_if_index)
Definition: arp.c:979
ethernet_arp_ip4_entry_t * ip4_neighbor_entries(u32 sw_if_index)
Definition: arp.c:1772
uword wc_ip4_arp_publisher_node
Definition: arp.c:106
VNET_SW_INTERFACE_ADD_DEL_FUNCTION(vnet_arp_delete_sw_interface)
walk_rc_t( proxy_arp_intf_walk_t)(u32 sw_if_index, void *data)
call back function when walking the DB of proxy ARP interface
Definition: arp.h:113
#define VLIB_NODE_FLAG_TRACE
Definition: node.h:301
arp_disabled_next_t_
Definition: arp.c:1089
static uword unformat_ethernet_arp_opcode_net_byte_order(unformat_input_t *input, va_list *args)
Definition: arp.c:202
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:298
void ethernet_arp_change_mac(u32 sw_if_index)
Definition: arp.c:2977
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:768
ethernet_arp_ip4_entry_t * ip4_entry_pool
Definition: arp.c:94
#define VLIB_INITS(...)
Definition: init.h:344
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
Definition: buffer_funcs.h:85
Definition: pg.h:309
const u8 * ethernet_ip4_mcast_dst_addr(void)
Definition: interface.c:57
walk_rc_t( proxy_arp_walk_t)(const ip4_address_t *lo_addr, const ip4_address_t *hi_addr, u32 fib_index, void *dat)
call back function when walking the DB of proxy ARPs
Definition: arp.h:103
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:978
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
int vnet_feature_enable_disable(const char *arc_name, const char *node_name, u32 sw_if_index, int enable_disable, void *feature_config, u32 n_feature_config_bytes)
Definition: feature.c:274
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:171
Definition: arp.h:24
static adj_walk_rc_t arp_mk_incomplete_walk(adj_index_t ai, void *ctx)
Definition: arp.c:436
static_always_inline void vnet_feature_arc_start(u8 arc, u32 sw_if_index, u32 *next0, vlib_buffer_t *b0)
Definition: feature.h:275
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:232
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:128