blob: 149f0a5dc96e4484aabc0e6d571f95babdc2b41e [file] [log] [blame]
Ed Warnickecb9cada2015-12-08 15:45:58 -07001/*
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>
John Lo1edfba92016-08-27 01:11:57 -040019#include <vnet/ip/ip6.h>
Ed Warnickecb9cada2015-12-08 15:45:58 -070020#include <vnet/ethernet/ethernet.h>
21#include <vnet/ethernet/arp_packet.h>
22#include <vnet/l2/l2_input.h>
23#include <vppinfra/mhash.h>
Neale Ranns0bfe5d82016-08-25 15:29:12 +010024#include <vnet/fib/ip4_fib.h>
Neale Rannsca193612017-06-14 06:50:08 -070025#include <vnet/fib/fib_entry_src.h>
Neale Rannsb80c5362016-10-08 13:03:40 +010026#include <vnet/adj/adj_nbr.h>
Neale Ranns32e1c012016-11-22 17:07:28 +000027#include <vnet/adj/adj_mcast.h>
Neale Ranns0bfe5d82016-08-25 15:29:12 +010028#include <vnet/mpls/mpls.h>
Ed Warnickecb9cada2015-12-08 15:45:58 -070029
Billy McFall2d085d92016-09-13 21:47:55 -040030/**
31 * @file
32 * @brief IPv4 ARP.
33 *
34 * This file contains code to manage the IPv4 ARP tables (IP Address
35 * to MAC Address lookup).
36 */
37
38
Dave Barachf9bd6202015-12-14 13:22:11 -050039void vl_api_rpc_call_main_thread (void *fp, u8 * data, u32 data_length);
40
Neale Ranns0bfe5d82016-08-25 15:29:12 +010041/**
42 * @brief Per-interface ARP configuration and state
43 */
44typedef struct ethernet_arp_interface_t_
45{
Neale Rannsb80c5362016-10-08 13:03:40 +010046 /**
47 * Hash table of ARP entries.
48 * Since this hash table is per-interface, the key is only the IPv4 address.
49 */
Neale Ranns0bfe5d82016-08-25 15:29:12 +010050 uword *arp_entries;
Neale Ranns0bfe5d82016-08-25 15:29:12 +010051} ethernet_arp_interface_t;
52
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -070053typedef struct
54{
Ed Warnickecb9cada2015-12-08 15:45:58 -070055 u32 lo_addr;
56 u32 hi_addr;
57 u32 fib_index;
58} ethernet_proxy_arp_t;
59
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -070060typedef struct
61{
Ed Warnickecb9cada2015-12-08 15:45:58 -070062 u32 next_index;
63 uword node_index;
64 uword type_opaque;
65 uword data;
66 /* Used for arp event notification only */
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -070067 void *data_callback;
Ed Warnickecb9cada2015-12-08 15:45:58 -070068 u32 pid;
69} pending_resolution_t;
70
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -070071typedef struct
72{
Ed Warnickecb9cada2015-12-08 15:45:58 -070073 /* Hash tables mapping name to opcode. */
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -070074 uword *opcode_by_name;
Ed Warnickecb9cada2015-12-08 15:45:58 -070075
76 /* lite beer "glean" adjacency handling */
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -070077 uword *pending_resolutions_by_address;
78 pending_resolution_t *pending_resolutions;
Ed Warnickecb9cada2015-12-08 15:45:58 -070079
80 /* Mac address change notification */
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -070081 uword *mac_changes_by_address;
82 pending_resolution_t *mac_changes;
Ed Warnickecb9cada2015-12-08 15:45:58 -070083
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -070084 ethernet_arp_ip4_entry_t *ip4_entry_pool;
Ed Warnickecb9cada2015-12-08 15:45:58 -070085
Ed Warnickecb9cada2015-12-08 15:45:58 -070086 /* ARP attack mitigation */
87 u32 arp_delete_rotor;
88 u32 limit_arp_cache_size;
89
Neale Ranns0bfe5d82016-08-25 15:29:12 +010090 /** Per interface state */
91 ethernet_arp_interface_t *ethernet_arp_by_sw_if_index;
92
Ed Warnickecb9cada2015-12-08 15:45:58 -070093 /* Proxy arp vector */
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -070094 ethernet_proxy_arp_t *proxy_arps;
Eyal Bari20197482017-09-13 12:29:08 +030095
96 uword wc_ip4_arp_publisher_node;
Eyal Baric125ecc2017-09-20 11:29:17 +030097 uword wc_ip4_arp_publisher_et;
Ed Warnickecb9cada2015-12-08 15:45:58 -070098} ethernet_arp_main_t;
99
100static ethernet_arp_main_t ethernet_arp_main;
101
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100102typedef struct
103{
104 u32 sw_if_index;
105 ethernet_arp_ip4_over_ethernet_address_t a;
106 int is_static;
Neale Rannsb3b2de72017-03-08 05:17:22 -0800107 int is_no_fib_entry;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100108 int flags;
109#define ETHERNET_ARP_ARGS_REMOVE (1<<0)
110#define ETHERNET_ARP_ARGS_FLUSH (1<<1)
111#define ETHERNET_ARP_ARGS_POPULATE (1<<2)
Eyal Bari20197482017-09-13 12:29:08 +0300112#define ETHERNET_ARP_ARGS_WC_PUB (1<<3)
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100113} vnet_arp_set_ip4_over_ethernet_rpc_args_t;
114
Matthew Smithcb9ab472017-05-16 21:35:56 -0500115static const u8 vrrp_prefix[] = { 0x00, 0x00, 0x5E, 0x00, 0x01 };
116
John Lo8b81cb42017-06-26 01:40:20 -0400117/* Node index for send_garp_na_process */
118u32 send_garp_na_process_node_index;
119
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100120static void
121set_ip4_over_ethernet_rpc_callback (vnet_arp_set_ip4_over_ethernet_rpc_args_t
122 * a);
123
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700124static u8 *
125format_ethernet_arp_hardware_type (u8 * s, va_list * va)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700126{
127 ethernet_arp_hardware_type_t h = va_arg (*va, ethernet_arp_hardware_type_t);
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700128 char *t = 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700129 switch (h)
130 {
131#define _(n,f) case n: t = #f; break;
132 foreach_ethernet_arp_hardware_type;
133#undef _
134
135 default:
136 return format (s, "unknown 0x%x", h);
137 }
138
139 return format (s, "%s", t);
140}
141
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700142static u8 *
143format_ethernet_arp_opcode (u8 * s, va_list * va)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700144{
145 ethernet_arp_opcode_t o = va_arg (*va, ethernet_arp_opcode_t);
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700146 char *t = 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700147 switch (o)
148 {
149#define _(f) case ETHERNET_ARP_OPCODE_##f: t = #f; break;
150 foreach_ethernet_arp_opcode;
151#undef _
152
153 default:
154 return format (s, "unknown 0x%x", o);
155 }
156
157 return format (s, "%s", t);
158}
159
160static uword
161unformat_ethernet_arp_opcode_host_byte_order (unformat_input_t * input,
162 va_list * args)
163{
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700164 int *result = va_arg (*args, int *);
165 ethernet_arp_main_t *am = &ethernet_arp_main;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700166 int x, i;
167
168 /* Numeric opcode. */
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700169 if (unformat (input, "0x%x", &x) || unformat (input, "%d", &x))
Ed Warnickecb9cada2015-12-08 15:45:58 -0700170 {
171 if (x >= (1 << 16))
172 return 0;
173 *result = x;
174 return 1;
175 }
176
177 /* Named type. */
178 if (unformat_user (input, unformat_vlib_number_by_name,
179 am->opcode_by_name, &i))
180 {
181 *result = i;
182 return 1;
183 }
184
185 return 0;
186}
187
188static uword
189unformat_ethernet_arp_opcode_net_byte_order (unformat_input_t * input,
190 va_list * args)
191{
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700192 int *result = va_arg (*args, int *);
193 if (!unformat_user
194 (input, unformat_ethernet_arp_opcode_host_byte_order, result))
Ed Warnickecb9cada2015-12-08 15:45:58 -0700195 return 0;
196
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700197 *result = clib_host_to_net_u16 ((u16) * result);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700198 return 1;
199}
200
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700201static u8 *
202format_ethernet_arp_header (u8 * s, va_list * va)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700203{
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700204 ethernet_arp_header_t *a = va_arg (*va, ethernet_arp_header_t *);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700205 u32 max_header_bytes = va_arg (*va, u32);
Christophe Fontained3c008d2017-10-02 18:10:54 +0200206 u32 indent;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700207 u16 l2_type, l3_type;
208
209 if (max_header_bytes != 0 && sizeof (a[0]) > max_header_bytes)
210 return format (s, "ARP header truncated");
211
212 l2_type = clib_net_to_host_u16 (a->l2_type);
213 l3_type = clib_net_to_host_u16 (a->l3_type);
214
215 indent = format_get_indent (s);
216
217 s = format (s, "%U, type %U/%U, address size %d/%d",
218 format_ethernet_arp_opcode, clib_net_to_host_u16 (a->opcode),
219 format_ethernet_arp_hardware_type, l2_type,
220 format_ethernet_type, l3_type,
221 a->n_l2_address_bytes, a->n_l3_address_bytes);
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700222
Ed Warnickecb9cada2015-12-08 15:45:58 -0700223 if (l2_type == ETHERNET_ARP_HARDWARE_TYPE_ethernet
224 && l3_type == ETHERNET_TYPE_IP4)
225 {
226 s = format (s, "\n%U%U/%U -> %U/%U",
227 format_white_space, indent,
228 format_ethernet_address, a->ip4_over_ethernet[0].ethernet,
229 format_ip4_address, &a->ip4_over_ethernet[0].ip4,
230 format_ethernet_address, a->ip4_over_ethernet[1].ethernet,
231 format_ip4_address, &a->ip4_over_ethernet[1].ip4);
232 }
233 else
234 {
235 uword n2 = a->n_l2_address_bytes;
236 uword n3 = a->n_l3_address_bytes;
237 s = format (s, "\n%U%U/%U -> %U/%U",
238 format_white_space, indent,
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700239 format_hex_bytes, a->data + 0 * n2 + 0 * n3, n2,
240 format_hex_bytes, a->data + 1 * n2 + 0 * n3, n3,
241 format_hex_bytes, a->data + 1 * n2 + 1 * n3, n2,
242 format_hex_bytes, a->data + 2 * n2 + 1 * n3, n3);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700243 }
244
245 return s;
246}
247
Pavel Kotucek3e046ea2016-12-05 08:27:37 +0100248u8 *
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700249format_ethernet_arp_ip4_entry (u8 * s, va_list * va)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700250{
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700251 vnet_main_t *vnm = va_arg (*va, vnet_main_t *);
252 ethernet_arp_ip4_entry_t *e = va_arg (*va, ethernet_arp_ip4_entry_t *);
253 vnet_sw_interface_t *si;
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700254 u8 *flags = 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700255
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700256 if (!e)
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100257 return format (s, "%=12s%=16s%=6s%=20s%=24s", "Time", "IP4",
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700258 "Flags", "Ethernet", "Interface");
Ed Warnickecb9cada2015-12-08 15:45:58 -0700259
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100260 si = vnet_get_sw_interface (vnm, e->sw_if_index);
Damjan Marion102ec522016-03-29 13:18:17 +0200261
262 if (e->flags & ETHERNET_ARP_IP4_ENTRY_FLAG_STATIC)
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700263 flags = format (flags, "S");
Damjan Marion102ec522016-03-29 13:18:17 +0200264
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100265 if (e->flags & ETHERNET_ARP_IP4_ENTRY_FLAG_DYNAMIC)
266 flags = format (flags, "D");
267
Neale Rannsb3b2de72017-03-08 05:17:22 -0800268 if (e->flags & ETHERNET_ARP_IP4_ENTRY_FLAG_NO_FIB_ENTRY)
269 flags = format (flags, "N");
270
Neale Ranns5c994c12017-08-04 06:22:23 -0700271 s = format (s, "%=12U%=16U%=6s%=20U%U",
Ed Warnickecb9cada2015-12-08 15:45:58 -0700272 format_vlib_cpu_time, vnm->vlib_main, e->cpu_time_last_updated,
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100273 format_ip4_address, &e->ip4_address,
Damjan Marion102ec522016-03-29 13:18:17 +0200274 flags ? (char *) flags : "",
Ed Warnickecb9cada2015-12-08 15:45:58 -0700275 format_ethernet_address, e->ethernet_address,
276 format_vnet_sw_interface_name, vnm, si);
277
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700278 vec_free (flags);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700279 return s;
280}
281
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700282typedef struct
283{
Ed Warnickecb9cada2015-12-08 15:45:58 -0700284 u8 packet_data[64];
285} ethernet_arp_input_trace_t;
286
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700287static u8 *
288format_ethernet_arp_input_trace (u8 * s, va_list * va)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700289{
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 *);
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700292 ethernet_arp_input_trace_t *t = va_arg (*va, ethernet_arp_input_trace_t *);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700293
294 s = format (s, "%U",
295 format_ethernet_arp_header,
296 t->packet_data, sizeof (t->packet_data));
297
298 return s;
299}
300
John Lo1edfba92016-08-27 01:11:57 -0400301static u8 *
302format_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 *);
306 ethernet_arp_input_trace_t *t = va_arg (*va, ethernet_arp_input_trace_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 ?
312 format_ethernet_arp_header : format_ip6_header,
313 t->packet_data, sizeof (t->packet_data));
314
315 return s;
316}
317
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100318static void
Neale Rannsb80c5362016-10-08 13:03:40 +0100319arp_nbr_probe (ip_adjacency_t * adj)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700320{
Neale Rannsb80c5362016-10-08 13:03:40 +0100321 vnet_main_t *vnm = vnet_get_main ();
322 ip4_main_t *im = &ip4_main;
323 ip_interface_address_t *ia;
324 ethernet_arp_header_t *h;
325 vnet_hw_interface_t *hi;
326 vnet_sw_interface_t *si;
327 ip4_address_t *src;
328 vlib_buffer_t *b;
329 vlib_main_t *vm;
330 u32 bi = 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700331
Neale Rannsb80c5362016-10-08 13:03:40 +0100332 vm = vlib_get_main ();
John Locbec1a12016-07-05 18:34:40 -0400333
Neale Rannsb80c5362016-10-08 13:03:40 +0100334 si = vnet_get_sw_interface (vnm, adj->rewrite_header.sw_if_index);
335
336 if (!(si->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP))
Ed Warnickecb9cada2015-12-08 15:45:58 -0700337 {
Neale Rannsb80c5362016-10-08 13:03:40 +0100338 return;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700339 }
Neale Rannsb80c5362016-10-08 13:03:40 +0100340
341 src =
342 ip4_interface_address_matching_destination (im,
343 &adj->sub_type.nbr.next_hop.
344 ip4,
345 adj->rewrite_header.
346 sw_if_index, &ia);
347 if (!src)
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100348 {
Neale Rannsb80c5362016-10-08 13:03:40 +0100349 return;
350 }
351
352 h =
353 vlib_packet_template_get_packet (vm, &im->ip4_arp_request_packet_template,
354 &bi);
355
356 hi = vnet_get_sup_hw_interface (vnm, adj->rewrite_header.sw_if_index);
357
358 clib_memcpy (h->ip4_over_ethernet[0].ethernet,
359 hi->hw_address, sizeof (h->ip4_over_ethernet[0].ethernet));
360
361 h->ip4_over_ethernet[0].ip4 = src[0];
362 h->ip4_over_ethernet[1].ip4 = adj->sub_type.nbr.next_hop.ip4;
363
364 b = vlib_get_buffer (vm, bi);
365 vnet_buffer (b)->sw_if_index[VLIB_RX] =
366 vnet_buffer (b)->sw_if_index[VLIB_TX] = adj->rewrite_header.sw_if_index;
367
368 /* Add encapsulation string for software interface (e.g. ethernet header). */
369 vnet_rewrite_one_header (adj[0], h, sizeof (ethernet_header_t));
370 vlib_buffer_advance (b, -adj->rewrite_header.data_bytes);
371
372 {
373 vlib_frame_t *f = vlib_get_frame_to_node (vm, hi->output_node_index);
374 u32 *to_next = vlib_frame_vector_args (f);
375 to_next[0] = bi;
376 f->n_vectors = 1;
377 vlib_put_frame_to_node (vm, hi->output_node_index, f);
378 }
379}
380
381static void
382arp_mk_complete (adj_index_t ai, ethernet_arp_ip4_entry_t * e)
383{
384 adj_nbr_update_rewrite
385 (ai, ADJ_NBR_REWRITE_FLAG_COMPLETE,
386 ethernet_build_rewrite (vnet_get_main (),
387 e->sw_if_index,
388 adj_get_link_type (ai), e->ethernet_address));
389}
390
391static void
Neale Ranns19c68d22016-12-07 15:38:14 +0000392arp_mk_incomplete (adj_index_t ai)
Neale Rannsb80c5362016-10-08 13:03:40 +0100393{
Neale Ranns19c68d22016-12-07 15:38:14 +0000394 ip_adjacency_t *adj = adj_get (ai);
395
Neale Rannsb80c5362016-10-08 13:03:40 +0100396 adj_nbr_update_rewrite
397 (ai,
398 ADJ_NBR_REWRITE_FLAG_INCOMPLETE,
399 ethernet_build_rewrite (vnet_get_main (),
Neale Ranns19c68d22016-12-07 15:38:14 +0000400 adj->rewrite_header.sw_if_index,
Neale Rannsb80c5362016-10-08 13:03:40 +0100401 VNET_LINK_ARP,
402 VNET_REWRITE_FOR_SW_INTERFACE_ADDRESS_BROADCAST));
403}
404
405static ethernet_arp_ip4_entry_t *
406arp_entry_find (ethernet_arp_interface_t * eai, const ip4_address_t * addr)
407{
408 ethernet_arp_main_t *am = &ethernet_arp_main;
409 ethernet_arp_ip4_entry_t *e = NULL;
410 uword *p;
411
412 if (NULL != eai->arp_entries)
413 {
414 p = hash_get (eai->arp_entries, addr->as_u32);
415 if (!p)
416 return (NULL);
417
418 e = pool_elt_at_index (am->ip4_entry_pool, p[0]);
419 }
420
421 return (e);
422}
423
424static adj_walk_rc_t
425arp_mk_complete_walk (adj_index_t ai, void *ctx)
426{
427 ethernet_arp_ip4_entry_t *e = ctx;
428
429 arp_mk_complete (ai, e);
430
431 return (ADJ_WALK_RC_CONTINUE);
432}
433
434static adj_walk_rc_t
435arp_mk_incomplete_walk (adj_index_t ai, void *ctx)
436{
Neale Ranns19c68d22016-12-07 15:38:14 +0000437 arp_mk_incomplete (ai);
Neale Rannsb80c5362016-10-08 13:03:40 +0100438
439 return (ADJ_WALK_RC_CONTINUE);
440}
441
442void
443arp_update_adjacency (vnet_main_t * vnm, u32 sw_if_index, u32 ai)
444{
445 ethernet_arp_main_t *am = &ethernet_arp_main;
446 ethernet_arp_interface_t *arp_int;
447 ethernet_arp_ip4_entry_t *e;
448 ip_adjacency_t *adj;
449
450 adj = adj_get (ai);
451
452 vec_validate (am->ethernet_arp_by_sw_if_index, sw_if_index);
453 arp_int = &am->ethernet_arp_by_sw_if_index[sw_if_index];
454 e = arp_entry_find (arp_int, &adj->sub_type.nbr.next_hop.ip4);
455
Neale Ranns32e1c012016-11-22 17:07:28 +0000456 switch (adj->lookup_next_index)
Neale Rannsb80c5362016-10-08 13:03:40 +0100457 {
Neale Ranns32e1c012016-11-22 17:07:28 +0000458 case IP_LOOKUP_NEXT_ARP:
459 case IP_LOOKUP_NEXT_GLEAN:
460 if (NULL != e)
461 {
462 adj_nbr_walk_nh4 (sw_if_index,
463 &e->ip4_address, arp_mk_complete_walk, e);
464 }
465 else
466 {
467 /*
468 * no matching ARP entry.
469 * construct the rewrite required to for an ARP packet, and stick
470 * that in the adj's pipe to smoke.
471 */
472 adj_nbr_update_rewrite
473 (ai,
474 ADJ_NBR_REWRITE_FLAG_INCOMPLETE,
475 ethernet_build_rewrite
476 (vnm,
477 sw_if_index,
478 VNET_LINK_ARP,
479 VNET_REWRITE_FOR_SW_INTERFACE_ADDRESS_BROADCAST));
480
481 /*
482 * since the FIB has added this adj for a route, it makes sense it
483 * may want to forward traffic sometime soon. Let's send a
484 * speculative ARP. just one. If we were to do periodically that
485 * wouldn't be bad either, but that's more code than i'm prepared to
486 * write at this time for relatively little reward.
487 */
488 arp_nbr_probe (adj);
489 }
490 break;
491 case IP_LOOKUP_NEXT_MCAST:
Neale Ranns2e7fbcc2017-03-15 04:22:25 -0700492 {
493 /*
494 * Construct a partial rewrite from the known ethernet mcast dest MAC
495 */
496 u8 *rewrite;
497 u8 offset;
Neale Rannsb80c5362016-10-08 13:03:40 +0100498
Neale Ranns2e7fbcc2017-03-15 04:22:25 -0700499 rewrite = ethernet_build_rewrite (vnm,
500 sw_if_index,
501 adj->ia_link,
502 ethernet_ip4_mcast_dst_addr ());
503 offset = vec_len (rewrite) - 2;
Neale Ranns32e1c012016-11-22 17:07:28 +0000504
Neale Ranns2e7fbcc2017-03-15 04:22:25 -0700505 /*
506 * Complete the remaining fields of the adj's rewrite to direct the
507 * complete of the rewrite at switch time by copying in the IP
508 * dst address's bytes.
509 * Ofset is 2 bytes into the MAC desintation address. And we copy 23 bits
510 * from the address.
511 */
512 adj_mcast_update_rewrite (ai, rewrite, offset, 0x007fffff);
Neale Ranns32e1c012016-11-22 17:07:28 +0000513
Neale Ranns2e7fbcc2017-03-15 04:22:25 -0700514 break;
515 }
Neale Ranns32e1c012016-11-22 17:07:28 +0000516 case IP_LOOKUP_NEXT_DROP:
517 case IP_LOOKUP_NEXT_PUNT:
518 case IP_LOOKUP_NEXT_LOCAL:
519 case IP_LOOKUP_NEXT_REWRITE:
Neale Ranns0f26c5a2017-03-01 15:12:11 -0800520 case IP_LOOKUP_NEXT_MCAST_MIDCHAIN:
Neale Ranns32e1c012016-11-22 17:07:28 +0000521 case IP_LOOKUP_NEXT_MIDCHAIN:
522 case IP_LOOKUP_NEXT_ICMP_ERROR:
523 case IP_LOOKUP_N_NEXT:
524 ASSERT (0);
525 break;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100526 }
Ed Warnickecb9cada2015-12-08 15:45:58 -0700527}
528
Neale Ranns15002542017-09-10 04:39:11 -0700529static void
Neale Ranns6b3a8ef2017-09-11 10:34:33 -0700530arp_adj_fib_add (ethernet_arp_ip4_entry_t * e, u32 fib_index)
Neale Ranns15002542017-09-10 04:39:11 -0700531{
532 fib_prefix_t pfx = {
533 .fp_len = 32,
534 .fp_proto = FIB_PROTOCOL_IP4,
535 .fp_addr.ip4 = e->ip4_address,
536 };
537
538 e->fib_entry_index =
539 fib_table_entry_path_add (fib_index, &pfx, FIB_SOURCE_ADJ,
540 FIB_ENTRY_FLAG_ATTACHED,
541 DPO_PROTO_IP4, &pfx.fp_addr,
542 e->sw_if_index, ~0, 1, NULL,
543 FIB_ROUTE_PATH_FLAG_NONE);
544 fib_table_lock (fib_index, FIB_PROTOCOL_IP4, FIB_SOURCE_ADJ);
545}
546
Eyal Bari20197482017-09-13 12:29:08 +0300547static int
Ed Warnickecb9cada2015-12-08 15:45:58 -0700548vnet_arp_set_ip4_over_ethernet_internal (vnet_main_t * vnm,
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100549 vnet_arp_set_ip4_over_ethernet_rpc_args_t
550 * args)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700551{
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700552 ethernet_arp_ip4_entry_t *e = 0;
553 ethernet_arp_main_t *am = &ethernet_arp_main;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100554 ethernet_arp_ip4_over_ethernet_address_t *a = &args->a;
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700555 vlib_main_t *vm = vlib_get_main ();
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700556 int make_new_arp_cache_entry = 1;
557 uword *p;
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700558 pending_resolution_t *pr, *mc;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100559 ethernet_arp_interface_t *arp_int;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100560 int is_static = args->is_static;
561 u32 sw_if_index = args->sw_if_index;
Neale Rannsb3b2de72017-03-08 05:17:22 -0800562 int is_no_fib_entry = args->is_no_fib_entry;
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700563
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100564 vec_validate (am->ethernet_arp_by_sw_if_index, sw_if_index);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700565
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100566 arp_int = &am->ethernet_arp_by_sw_if_index[sw_if_index];
Ed Warnickecb9cada2015-12-08 15:45:58 -0700567
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100568 if (NULL != arp_int->arp_entries)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700569 {
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100570 p = hash_get (arp_int->arp_entries, a->ip4.as_u32);
571 if (p)
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700572 {
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100573 e = pool_elt_at_index (am->ip4_entry_pool, p[0]);
574
575 /* Refuse to over-write static arp. */
576 if (!is_static && (e->flags & ETHERNET_ARP_IP4_ENTRY_FLAG_STATIC))
577 return -2;
578 make_new_arp_cache_entry = 0;
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700579 }
Damjan Marion102ec522016-03-29 13:18:17 +0200580 }
581
Ed Warnickecb9cada2015-12-08 15:45:58 -0700582 if (make_new_arp_cache_entry)
583 {
584 pool_get (am->ip4_entry_pool, e);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100585
586 if (NULL == arp_int->arp_entries)
587 {
588 arp_int->arp_entries = hash_create (0, sizeof (u32));
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100589 }
590
591 hash_set (arp_int->arp_entries, a->ip4.as_u32, e - am->ip4_entry_pool);
592
593 e->sw_if_index = sw_if_index;
594 e->ip4_address = a->ip4;
Neale Rannsd5b6aa12017-05-16 08:46:45 -0700595 e->fib_entry_index = FIB_NODE_INDEX_INVALID;
Neale Rannsb80c5362016-10-08 13:03:40 +0100596 clib_memcpy (e->ethernet_address,
597 a->ethernet, sizeof (e->ethernet_address));
598
Neale Rannsb3b2de72017-03-08 05:17:22 -0800599 if (!is_no_fib_entry)
600 {
Neale Ranns15002542017-09-10 04:39:11 -0700601 arp_adj_fib_add (e,
602 ip4_fib_table_get_index_for_sw_if_index
603 (e->sw_if_index));
Neale Ranns2a3ea492017-04-19 05:24:40 -0700604 }
605 else
606 {
Neale Rannsb3b2de72017-03-08 05:17:22 -0800607 e->flags |= ETHERNET_ARP_IP4_ENTRY_FLAG_NO_FIB_ENTRY;
608 }
Ed Warnickecb9cada2015-12-08 15:45:58 -0700609 }
Neale Ranns33a7dd52016-10-07 15:14:33 +0100610 else
611 {
612 /*
613 * prevent a DoS attack from the data-plane that
614 * spams us with no-op updates to the MAC address
615 */
616 if (0 == memcmp (e->ethernet_address,
617 a->ethernet, sizeof (e->ethernet_address)))
Dave Barach59b25652017-09-10 15:04:27 -0400618 goto check_customers;
Neale Rannsb80c5362016-10-08 13:03:40 +0100619
620 /* Update time stamp and ethernet address. */
621 clib_memcpy (e->ethernet_address, a->ethernet,
622 sizeof (e->ethernet_address));
Neale Ranns33a7dd52016-10-07 15:14:33 +0100623 }
Ed Warnickecb9cada2015-12-08 15:45:58 -0700624
Ed Warnickecb9cada2015-12-08 15:45:58 -0700625 e->cpu_time_last_updated = clib_cpu_time_now ();
626 if (is_static)
627 e->flags |= ETHERNET_ARP_IP4_ENTRY_FLAG_STATIC;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100628 else
629 e->flags |= ETHERNET_ARP_IP4_ENTRY_FLAG_DYNAMIC;
630
Neale Rannsb80c5362016-10-08 13:03:40 +0100631 adj_nbr_walk_nh4 (sw_if_index, &e->ip4_address, arp_mk_complete_walk, e);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700632
Dave Barach59b25652017-09-10 15:04:27 -0400633check_customers:
Ed Warnickecb9cada2015-12-08 15:45:58 -0700634 /* Customer(s) waiting for this address to be resolved? */
635 p = hash_get (am->pending_resolutions_by_address, a->ip4.as_u32);
636 if (p)
637 {
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100638 u32 next_index;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700639 next_index = p[0];
640
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700641 while (next_index != (u32) ~ 0)
642 {
643 pr = pool_elt_at_index (am->pending_resolutions, next_index);
644 vlib_process_signal_event (vm, pr->node_index,
645 pr->type_opaque, pr->data);
646 next_index = pr->next_index;
647 pool_put (am->pending_resolutions, pr);
648 }
649
Ed Warnickecb9cada2015-12-08 15:45:58 -0700650 hash_unset (am->pending_resolutions_by_address, a->ip4.as_u32);
651 }
652
653 /* Customer(s) requesting ARP event for this address? */
654 p = hash_get (am->mac_changes_by_address, a->ip4.as_u32);
655 if (p)
656 {
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100657 u32 next_index;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700658 next_index = p[0];
659
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700660 while (next_index != (u32) ~ 0)
661 {
662 int (*fp) (u32, u8 *, u32, u32);
663 int rv = 1;
664 mc = pool_elt_at_index (am->mac_changes, next_index);
665 fp = mc->data_callback;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700666
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700667 /* Call the user's data callback, return 1 to suppress dup events */
668 if (fp)
669 rv = (*fp) (mc->data, a->ethernet, sw_if_index, 0);
670
Damjan Marion607de1a2016-08-16 22:53:54 +0200671 /*
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700672 * Signal the resolver process, as long as the user
673 * says they want to be notified
674 */
675 if (rv == 0)
676 vlib_process_signal_event (vm, mc->node_index,
677 mc->type_opaque, mc->data);
678 next_index = mc->next_index;
679 }
Ed Warnickecb9cada2015-12-08 15:45:58 -0700680 }
681
682 return 0;
683}
684
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700685void
686vnet_register_ip4_arp_resolution_event (vnet_main_t * vnm,
687 void *address_arg,
688 uword node_index,
689 uword type_opaque, uword data)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700690{
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700691 ethernet_arp_main_t *am = &ethernet_arp_main;
692 ip4_address_t *address = address_arg;
693 uword *p;
694 pending_resolution_t *pr;
695
Ed Warnickecb9cada2015-12-08 15:45:58 -0700696 pool_get (am->pending_resolutions, pr);
697
698 pr->next_index = ~0;
699 pr->node_index = node_index;
700 pr->type_opaque = type_opaque;
701 pr->data = data;
702 pr->data_callback = 0;
703
704 p = hash_get (am->pending_resolutions_by_address, address->as_u32);
705 if (p)
706 {
707 /* Insert new resolution at the head of the list */
708 pr->next_index = p[0];
709 hash_unset (am->pending_resolutions_by_address, address->as_u32);
710 }
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700711
712 hash_set (am->pending_resolutions_by_address, address->as_u32,
713 pr - am->pending_resolutions);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700714}
715
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700716int
717vnet_add_del_ip4_arp_change_event (vnet_main_t * vnm,
718 void *data_callback,
719 u32 pid,
720 void *address_arg,
721 uword node_index,
722 uword type_opaque, uword data, int is_add)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700723{
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700724 ethernet_arp_main_t *am = &ethernet_arp_main;
725 ip4_address_t *address = address_arg;
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700726
Eyal Bari8db1de82017-03-31 02:15:17 +0300727 /* Try to find an existing entry */
728 u32 *first = (u32 *) hash_get (am->mac_changes_by_address, address->as_u32);
729 u32 *p = first;
730 pending_resolution_t *mc;
731 while (p && *p != ~0)
732 {
733 mc = pool_elt_at_index (am->mac_changes, *p);
734 if (mc->node_index == node_index && mc->type_opaque == type_opaque
735 && mc->pid == pid)
736 break;
737 p = &mc->next_index;
738 }
739
740 int found = p && *p != ~0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700741 if (is_add)
742 {
Eyal Bari8db1de82017-03-31 02:15:17 +0300743 if (found)
744 return VNET_API_ERROR_ENTRY_ALREADY_EXISTS;
745
Ed Warnickecb9cada2015-12-08 15:45:58 -0700746 pool_get (am->mac_changes, mc);
Eyal Bari8db1de82017-03-31 02:15:17 +0300747 *mc = (pending_resolution_t)
748 {
749 .next_index = ~0,.node_index = node_index,.type_opaque =
750 type_opaque,.data = data,.data_callback = data_callback,.pid =
751 pid,};
Ed Warnickecb9cada2015-12-08 15:45:58 -0700752
Eyal Bari8db1de82017-03-31 02:15:17 +0300753 /* Insert new resolution at the end of the list */
754 u32 new_idx = mc - am->mac_changes;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700755 if (p)
Eyal Bari8db1de82017-03-31 02:15:17 +0300756 p[0] = new_idx;
757 else
758 hash_set (am->mac_changes_by_address, address->as_u32, new_idx);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700759 }
760 else
761 {
Eyal Bari8db1de82017-03-31 02:15:17 +0300762 if (!found)
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700763 return VNET_API_ERROR_NO_SUCH_ENTRY;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700764
Eyal Bari8db1de82017-03-31 02:15:17 +0300765 /* Clients may need to clean up pool entries, too */
766 void (*fp) (u32, u8 *) = data_callback;
767 if (fp)
768 (*fp) (mc->data, 0 /* no new mac addrs */ );
Ed Warnickecb9cada2015-12-08 15:45:58 -0700769
Eyal Bari8db1de82017-03-31 02:15:17 +0300770 /* Remove the entry from the list and delete the entry */
771 *p = mc->next_index;
772 pool_put (am->mac_changes, mc);
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700773
Eyal Bari8db1de82017-03-31 02:15:17 +0300774 /* Remove from hash if we deleted the last entry */
775 if (*p == ~0 && p == first)
776 hash_unset (am->mac_changes_by_address, address->as_u32);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700777 }
Eyal Bari8db1de82017-03-31 02:15:17 +0300778 return 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700779}
780
781/* Either we drop the packet or we send a reply to the sender. */
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700782typedef enum
783{
Ed Warnickecb9cada2015-12-08 15:45:58 -0700784 ARP_INPUT_NEXT_DROP,
John Lod1f5d042016-04-12 18:20:39 -0400785 ARP_INPUT_NEXT_REPLY_TX,
Ed Warnickecb9cada2015-12-08 15:45:58 -0700786 ARP_INPUT_N_NEXT,
787} arp_input_next_t;
788
789#define foreach_ethernet_arp_error \
790 _ (replies_sent, "ARP replies sent") \
791 _ (l2_type_not_ethernet, "L2 type not ethernet") \
792 _ (l3_type_not_ip4, "L3 type not IP4") \
793 _ (l3_src_address_not_local, "IP4 source address not local to subnet") \
794 _ (l3_dst_address_not_local, "IP4 destination address not local to subnet") \
795 _ (l3_src_address_is_local, "IP4 source address matches local interface") \
796 _ (l3_src_address_learned, "ARP request IP4 source address learned") \
797 _ (replies_received, "ARP replies received") \
798 _ (opcode_not_request, "ARP opcode not request") \
799 _ (proxy_arp_replies_sent, "Proxy ARP replies sent") \
800 _ (l2_address_mismatch, "ARP hw addr does not match L2 frame src addr") \
Ed Warnickecb9cada2015-12-08 15:45:58 -0700801 _ (gratuitous_arp, "ARP probe or announcement dropped") \
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100802 _ (interface_no_table, "Interface is not mapped to an IP table") \
Neale Rannsd96bad82017-03-08 01:12:54 -0800803 _ (interface_not_ip_enabled, "Interface is not IP enabled") \
Ed Warnickecb9cada2015-12-08 15:45:58 -0700804
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700805typedef enum
806{
Ed Warnickecb9cada2015-12-08 15:45:58 -0700807#define _(sym,string) ETHERNET_ARP_ERROR_##sym,
808 foreach_ethernet_arp_error
809#undef _
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700810 ETHERNET_ARP_N_ERROR,
Ed Warnickecb9cada2015-12-08 15:45:58 -0700811} ethernet_arp_input_error_t;
812
Ed Warnickecb9cada2015-12-08 15:45:58 -0700813
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700814static void
815unset_random_arp_entry (void)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700816{
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700817 ethernet_arp_main_t *am = &ethernet_arp_main;
818 ethernet_arp_ip4_entry_t *e;
819 vnet_main_t *vnm = vnet_get_main ();
820 ethernet_arp_ip4_over_ethernet_address_t delme;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700821 u32 index;
822
823 index = pool_next_index (am->ip4_entry_pool, am->arp_delete_rotor);
824 am->arp_delete_rotor = index;
825
826 /* Try again from elt 0, could happen if an intfc goes down */
827 if (index == ~0)
828 {
829 index = pool_next_index (am->ip4_entry_pool, am->arp_delete_rotor);
830 am->arp_delete_rotor = index;
831 }
832
833 /* Nothing left in the pool */
834 if (index == ~0)
835 return;
836
837 e = pool_elt_at_index (am->ip4_entry_pool, index);
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700838
Damjan Marionf1213b82016-03-13 02:22:06 +0100839 clib_memcpy (&delme.ethernet, e->ethernet_address, 6);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100840 delme.ip4.as_u32 = e->ip4_address.as_u32;
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700841
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100842 vnet_arp_unset_ip4_over_ethernet (vnm, e->sw_if_index, &delme);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700843}
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700844
Neale Ranns436d06b2016-11-30 07:41:53 -0800845static int
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700846arp_unnumbered (vlib_buffer_t * p0,
Neale Rannsd5b6aa12017-05-16 08:46:45 -0700847 u32 input_sw_if_index, u32 conn_sw_if_index)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700848{
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700849 vnet_main_t *vnm = vnet_get_main ();
850 vnet_interface_main_t *vim = &vnm->interface_main;
851 vnet_sw_interface_t *si;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700852
Neale Rannsd5b6aa12017-05-16 08:46:45 -0700853 /* verify that the input interface is unnumbered to the connected.
854 * the connected interface is the interface on which the subnet is
855 * configured */
856 si = &vim->sw_interfaces[input_sw_if_index];
857
858 if (!(si->flags & VNET_SW_INTERFACE_FLAG_UNNUMBERED &&
859 (si->unnumbered_sw_if_index == conn_sw_if_index)))
860 {
861 /* the input interface is not unnumbered to the interface on which
862 * the sub-net is configured that covers the ARP request.
863 * So this is not the case for unnumbered.. */
864 return 0;
865 }
866
Neale Ranns436d06b2016-11-30 07:41:53 -0800867 return !0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700868}
869
Neale Rannsd5b6aa12017-05-16 08:46:45 -0700870static u32
871arp_learn (vnet_main_t * vnm,
872 ethernet_arp_main_t * am, u32 sw_if_index, void *addr)
873{
874 if (am->limit_arp_cache_size &&
875 pool_elts (am->ip4_entry_pool) >= am->limit_arp_cache_size)
876 unset_random_arp_entry ();
877
878 vnet_arp_set_ip4_over_ethernet (vnm, sw_if_index, addr, 0, 0);
879 return (ETHERNET_ARP_ERROR_l3_src_address_learned);
880}
881
Ed Warnickecb9cada2015-12-08 15:45:58 -0700882static uword
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700883arp_input (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700884{
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700885 ethernet_arp_main_t *am = &ethernet_arp_main;
886 vnet_main_t *vnm = vnet_get_main ();
887 ip4_main_t *im4 = &ip4_main;
888 u32 n_left_from, next_index, *from, *to_next;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700889 u32 n_replies_sent = 0, n_proxy_arp_replies_sent = 0;
890
891 from = vlib_frame_vector_args (frame);
892 n_left_from = frame->n_vectors;
893 next_index = node->cached_next_index;
894
895 if (node->flags & VLIB_NODE_FLAG_TRACE)
896 vlib_trace_frame_buffers_only (vm, node, from, frame->n_vectors,
897 /* stride */ 1,
898 sizeof (ethernet_arp_input_trace_t));
899
900 while (n_left_from > 0)
901 {
902 u32 n_left_to_next;
903
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700904 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700905
906 while (n_left_from > 0 && n_left_to_next > 0)
907 {
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700908 vlib_buffer_t *p0;
909 vnet_hw_interface_t *hw_if0;
910 ethernet_arp_header_t *arp0;
Neale Ranns30d0fd42017-05-30 07:30:04 -0700911 ethernet_header_t *eth_rx, *eth_tx;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100912 ip4_address_t *if_addr0, proxy_src;
913 u32 pi0, error0, next0, sw_if_index0, conn_sw_if_index0, fib_index0;
Matthew Smithcb9ab472017-05-16 21:35:56 -0500914 u8 is_request0, dst_is_local0, is_unnum0, is_vrrp_reply0;
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700915 ethernet_proxy_arp_t *pa;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100916 fib_node_index_t dst_fei, src_fei;
917 fib_prefix_t pfx0;
918 fib_entry_flag_t src_flags, dst_flags;
Neale Rannsa3a3a9d2017-08-08 12:35:11 -0700919 u8 *rewrite0, rewrite0_len;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700920
921 pi0 = from[0];
922 to_next[0] = pi0;
923 from += 1;
924 to_next += 1;
925 n_left_from -= 1;
926 n_left_to_next -= 1;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100927 pa = 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700928
929 p0 = vlib_get_buffer (vm, pi0);
930 arp0 = vlib_buffer_get_current (p0);
Neale Ranns30d0fd42017-05-30 07:30:04 -0700931 /* Fill in ethernet header. */
932 eth_rx = ethernet_buffer_get_header (p0);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700933
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700934 is_request0 = arp0->opcode
935 == clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_request);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700936
937 error0 = ETHERNET_ARP_ERROR_replies_sent;
938
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -0700939 error0 =
940 (arp0->l2_type !=
941 clib_net_to_host_u16 (ETHERNET_ARP_HARDWARE_TYPE_ethernet) ?
942 ETHERNET_ARP_ERROR_l2_type_not_ethernet : error0);
943 error0 =
944 (arp0->l3_type !=
945 clib_net_to_host_u16 (ETHERNET_TYPE_IP4) ?
946 ETHERNET_ARP_ERROR_l3_type_not_ip4 : error0);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700947
948 sw_if_index0 = vnet_buffer (p0)->sw_if_index[VLIB_RX];
949
Neale Rannsd96bad82017-03-08 01:12:54 -0800950 /* not playing the ARP game if the interface is not IPv4 enabled */
951 error0 =
952 (im4->ip_enabled_by_sw_if_index[sw_if_index0] == 0 ?
953 ETHERNET_ARP_ERROR_interface_not_ip_enabled : error0);
954
Ed Warnickecb9cada2015-12-08 15:45:58 -0700955 if (error0)
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100956 goto drop2;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700957
958 /* Check that IP address is local and matches incoming interface. */
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100959 fib_index0 = ip4_fib_table_get_index_for_sw_if_index (sw_if_index0);
960 if (~0 == fib_index0)
961 {
962 error0 = ETHERNET_ARP_ERROR_interface_no_table;
963 goto drop2;
964
965 }
966 dst_fei = ip4_fib_table_lookup (ip4_fib_get (fib_index0),
967 &arp0->ip4_over_ethernet[1].ip4,
968 32);
Matus Fabiandccbee32017-01-31 22:20:30 -0800969 dst_flags = fib_entry_get_flags (dst_fei);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100970
Matus Fabiandccbee32017-01-31 22:20:30 -0800971 conn_sw_if_index0 = fib_entry_get_resolving_interface (dst_fei);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100972
Neale Rannsca193612017-06-14 06:50:08 -0700973 /* Honor unnumbered interface, if any */
974 is_unnum0 = sw_if_index0 != conn_sw_if_index0;
975
976 {
977 /*
978 * we're looking for FIB entries that indicate the source
979 * is attached. There may be more specific non-attached
980 * routes tht match the source, but these do not influence
981 * whether we respond to an ARP request, i.e. they do not
982 * influence whether we are the correct way for the sender
983 * to reach us, they only affect how we reach the sender.
984 */
985 fib_entry_t *src_fib_entry;
986 fib_entry_src_t *src;
987 fib_source_t source;
988 fib_prefix_t pfx;
989 int attached;
990 int mask;
991
992 mask = 32;
993 attached = 0;
994
995 do
996 {
997 src_fei = ip4_fib_table_lookup (ip4_fib_get (fib_index0),
998 &arp0->
999 ip4_over_ethernet[0].ip4,
1000 mask);
1001 src_fib_entry = fib_entry_get (src_fei);
1002
1003 /*
1004 * It's possible that the source that provides the
1005 * flags we need, or the flags we must not have,
1006 * is not the best source, so check then all.
1007 */
1008 /* *INDENT-OFF* */
1009 FOR_EACH_SRC_ADDED(src_fib_entry, src, source,
1010 ({
1011 src_flags = fib_entry_get_flags_for_source (src_fei, source);
1012
1013 /* Reject requests/replies with our local interface
1014 address. */
1015 if (FIB_ENTRY_FLAG_LOCAL & src_flags)
1016 {
1017 error0 = ETHERNET_ARP_ERROR_l3_src_address_is_local;
Neale Ranns24b170a2017-08-15 05:33:11 -07001018 /*
1019 * When VPP has an interface whose address is also
1020 * applied to a TAP interface on the host, then VPP's
1021 * TAP interface will be unnumbered to the 'real'
1022 * interface and do proxy ARP from the host.
1023 * The curious aspect of this setup is that ARP requests
1024 * from the host will come from the VPP's own address.
1025 * So don't drop immediately here, instead go see if this
1026 * is a proxy ARP case.
1027 */
1028 goto drop1;
Neale Rannsca193612017-06-14 06:50:08 -07001029 }
1030 /* A Source must also be local to subnet of matching
1031 * interface address. */
1032 if ((FIB_ENTRY_FLAG_ATTACHED & src_flags) ||
1033 (FIB_ENTRY_FLAG_CONNECTED & src_flags))
1034 {
1035 attached = 1;
1036 break;
1037 }
1038 /*
1039 * else
1040 * The packet was sent from an address that is not
1041 * connected nor attached i.e. it is not from an
1042 * address that is covered by a link's sub-net,
1043 * nor is it a already learned host resp.
1044 */
1045 }));
1046 /* *INDENT-ON* */
1047
1048 /*
1049 * shorter mask lookup for the next iteration.
1050 */
1051 fib_entry_get_prefix (src_fei, &pfx);
1052 mask = pfx.fp_len - 1;
1053
1054 /*
1055 * continue until we hit the default route or we find
1056 * the attached we are looking for. The most likely
1057 * outcome is we find the attached with the first source
1058 * on the first lookup.
1059 */
1060 }
1061 while (!attached &&
1062 !fib_entry_is_sourced (src_fei, FIB_SOURCE_DEFAULT_ROUTE));
1063
1064 if (!attached)
1065 {
1066 /*
1067 * the matching route is a not attached, i.e. it was
1068 * added as a result of routing, rather than interface/ARP
1069 * configuration. If the matching route is not a host route
1070 * (i.e. a /32)
1071 */
1072 error0 = ETHERNET_ARP_ERROR_l3_src_address_not_local;
1073 goto drop2;
1074 }
1075 }
1076
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001077 if (!(FIB_ENTRY_FLAG_CONNECTED & dst_flags))
Ed Warnickecb9cada2015-12-08 15:45:58 -07001078 {
1079 error0 = ETHERNET_ARP_ERROR_l3_dst_address_not_local;
1080 goto drop1;
1081 }
1082
Neale Ranns797235a2017-01-09 14:33:38 +01001083 if (sw_if_index0 != fib_entry_get_resolving_interface (src_fei))
1084 {
1085 /*
1086 * The interface the ARP was received on is not the interface
Neale Rannsca193612017-06-14 06:50:08 -07001087 * on which the covering prefix is configured. Maybe this is a
1088 * case for unnumbered.
Neale Ranns797235a2017-01-09 14:33:38 +01001089 */
1090 is_unnum0 = 1;
1091 }
Ed Warnickecb9cada2015-12-08 15:45:58 -07001092
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001093 dst_is_local0 = (FIB_ENTRY_FLAG_LOCAL & dst_flags);
1094 fib_entry_get_prefix (dst_fei, &pfx0);
1095 if_addr0 = &pfx0.fp_addr.ip4;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001096
Matthew Smithcb9ab472017-05-16 21:35:56 -05001097 is_vrrp_reply0 =
1098 ((arp0->opcode ==
1099 clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_reply))
1100 &&
1101 (!memcmp
1102 (arp0->ip4_over_ethernet[0].ethernet, vrrp_prefix,
1103 sizeof (vrrp_prefix))));
1104
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001105 /* Trash ARP packets whose ARP-level source addresses do not
Matthew Smithcb9ab472017-05-16 21:35:56 -05001106 match their L2-frame-level source addresses, unless it's
1107 a reply from a VRRP virtual router */
Neale Ranns30d0fd42017-05-30 07:30:04 -07001108 if (memcmp
1109 (eth_rx->src_address, arp0->ip4_over_ethernet[0].ethernet,
1110 sizeof (eth_rx->src_address)) && !is_vrrp_reply0)
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001111 {
1112 error0 = ETHERNET_ARP_ERROR_l2_address_mismatch;
1113 goto drop2;
1114 }
Ed Warnickecb9cada2015-12-08 15:45:58 -07001115
Neale Rannsd5b6aa12017-05-16 08:46:45 -07001116 /* Learn or update sender's mapping only for replies to addresses
1117 * that are local to the subnet */
1118 if (arp0->opcode ==
1119 clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_reply) &&
1120 dst_is_local0)
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001121 {
Neale Rannsd5b6aa12017-05-16 08:46:45 -07001122 error0 = arp_learn (vnm, am, sw_if_index0,
1123 &arp0->ip4_over_ethernet[0]);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001124 goto drop1;
1125 }
zhaoqinglingb4c42cd2017-12-23 15:20:59 +08001126 else if (arp0->opcode ==
1127 clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_request) &&
1128 (dst_is_local0 == 0))
1129 {
1130 goto drop1;
1131 }
Ed Warnickecb9cada2015-12-08 15:45:58 -07001132
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001133 send_reply:
Neale Rannsa3a3a9d2017-08-08 12:35:11 -07001134 /* Send a reply.
1135 An adjacency to the sender is not always present,
1136 so we use the interface to build us a rewrite string
1137 which will contain all the necessary tags. */
1138 rewrite0 = ethernet_build_rewrite (vnm, sw_if_index0,
1139 VNET_LINK_ARP,
1140 eth_rx->src_address);
1141 rewrite0_len = vec_len (rewrite0);
1142
Neale Ranns30d0fd42017-05-30 07:30:04 -07001143 /* Figure out how much to rewind current data from adjacency. */
Neale Rannsa3a3a9d2017-08-08 12:35:11 -07001144 vlib_buffer_advance (p0, -rewrite0_len);
Neale Ranns30d0fd42017-05-30 07:30:04 -07001145 eth_tx = vlib_buffer_get_current (p0);
1146
Ed Warnickecb9cada2015-12-08 15:45:58 -07001147 vnet_buffer (p0)->sw_if_index[VLIB_TX] = sw_if_index0;
1148 hw_if0 = vnet_get_sup_hw_interface (vnm, sw_if_index0);
1149
John Lod1f5d042016-04-12 18:20:39 -04001150 /* Send reply back through input interface */
1151 vnet_buffer (p0)->sw_if_index[VLIB_TX] = sw_if_index0;
1152 next0 = ARP_INPUT_NEXT_REPLY_TX;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001153
1154 arp0->opcode = clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_reply);
1155
1156 arp0->ip4_over_ethernet[1] = arp0->ip4_over_ethernet[0];
1157
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001158 clib_memcpy (arp0->ip4_over_ethernet[0].ethernet,
1159 hw_if0->hw_address, 6);
1160 clib_mem_unaligned (&arp0->ip4_over_ethernet[0].ip4.data_u32, u32) =
1161 if_addr0->data_u32;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001162
1163 /* Hardware must be ethernet-like. */
1164 ASSERT (vec_len (hw_if0->hw_address) == 6);
1165
Neale Ranns30d0fd42017-05-30 07:30:04 -07001166 /* the rx nd tx ethernet headers wil overlap in the case
1167 * when we received a tagged VLAN=0 packet, but we are sending
1168 * back untagged */
Neale Rannsa3a3a9d2017-08-08 12:35:11 -07001169 clib_memcpy (eth_tx, rewrite0, vec_len (rewrite0));
1170 vec_free (rewrite0);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001171
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001172 if (NULL == pa)
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001173 {
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001174 if (is_unnum0)
Neale Ranns436d06b2016-11-30 07:41:53 -08001175 {
Neale Ranns30d0fd42017-05-30 07:30:04 -07001176 if (!arp_unnumbered (p0, sw_if_index0, conn_sw_if_index0))
Neale Ranns436d06b2016-11-30 07:41:53 -08001177 goto drop2;
1178 }
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001179 }
Neale Ranns4b919a52017-03-11 05:55:21 -08001180
Neale Ranns24b170a2017-08-15 05:33:11 -07001181 /* We are going to reply to this request, so, in the absence of
1182 errors, learn the sender */
1183 if (!error0)
1184 error0 = arp_learn (vnm, am, sw_if_index0,
1185 &arp0->ip4_over_ethernet[1]);
Neale Rannsd5b6aa12017-05-16 08:46:45 -07001186
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001187 vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
1188 n_left_to_next, pi0, next0);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001189
1190 n_replies_sent += 1;
1191 continue;
1192
1193 drop1:
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001194 if (0 == arp0->ip4_over_ethernet[0].ip4.as_u32 ||
1195 (arp0->ip4_over_ethernet[0].ip4.as_u32 ==
1196 arp0->ip4_over_ethernet[1].ip4.as_u32))
1197 {
1198 error0 = ETHERNET_ARP_ERROR_gratuitous_arp;
1199 goto drop2;
1200 }
1201 /* See if proxy arp is configured for the address */
1202 if (is_request0)
1203 {
1204 vnet_sw_interface_t *si;
1205 u32 this_addr = clib_net_to_host_u32
1206 (arp0->ip4_over_ethernet[1].ip4.as_u32);
1207 u32 fib_index0;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001208
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001209 si = vnet_get_sw_interface (vnm, sw_if_index0);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001210
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001211 if (!(si->flags & VNET_SW_INTERFACE_FLAG_PROXY_ARP))
1212 goto drop2;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001213
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001214 fib_index0 = vec_elt (im4->fib_index_by_sw_if_index,
1215 sw_if_index0);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001216
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001217 vec_foreach (pa, am->proxy_arps)
1218 {
1219 u32 lo_addr = clib_net_to_host_u32 (pa->lo_addr);
1220 u32 hi_addr = clib_net_to_host_u32 (pa->hi_addr);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001221
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001222 /* an ARP request hit in the proxy-arp table? */
1223 if ((this_addr >= lo_addr && this_addr <= hi_addr) &&
1224 (fib_index0 == pa->fib_index))
1225 {
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001226 proxy_src.as_u32 =
1227 arp0->ip4_over_ethernet[1].ip4.data_u32;
1228
Damjan Marion607de1a2016-08-16 22:53:54 +02001229 /*
Neale Ranns30d0fd42017-05-30 07:30:04 -07001230 * change the interface address to the proxied
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001231 */
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001232 if_addr0 = &proxy_src;
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001233 is_unnum0 = 0;
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001234 n_proxy_arp_replies_sent++;
1235 goto send_reply;
1236 }
1237 }
1238 }
1239
1240 drop2:
Ed Warnickecb9cada2015-12-08 15:45:58 -07001241
1242 next0 = ARP_INPUT_NEXT_DROP;
1243 p0->error = node->errors[error0];
1244
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001245 vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
1246 n_left_to_next, pi0, next0);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001247 }
1248
1249 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1250 }
1251
1252 vlib_error_count (vm, node->node_index,
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001253 ETHERNET_ARP_ERROR_replies_sent,
1254 n_replies_sent - n_proxy_arp_replies_sent);
1255
Ed Warnickecb9cada2015-12-08 15:45:58 -07001256 vlib_error_count (vm, node->node_index,
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001257 ETHERNET_ARP_ERROR_proxy_arp_replies_sent,
1258 n_proxy_arp_replies_sent);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001259 return frame->n_vectors;
1260}
1261
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001262static char *ethernet_arp_error_strings[] = {
Ed Warnickecb9cada2015-12-08 15:45:58 -07001263#define _(sym,string) string,
1264 foreach_ethernet_arp_error
1265#undef _
1266};
1267
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001268/* *INDENT-OFF* */
1269VLIB_REGISTER_NODE (arp_input_node, static) =
1270{
Ed Warnickecb9cada2015-12-08 15:45:58 -07001271 .function = arp_input,
1272 .name = "arp-input",
1273 .vector_size = sizeof (u32),
Ed Warnickecb9cada2015-12-08 15:45:58 -07001274 .n_errors = ETHERNET_ARP_N_ERROR,
1275 .error_strings = ethernet_arp_error_strings,
Ed Warnickecb9cada2015-12-08 15:45:58 -07001276 .n_next_nodes = ARP_INPUT_N_NEXT,
1277 .next_nodes = {
1278 [ARP_INPUT_NEXT_DROP] = "error-drop",
John Lod1f5d042016-04-12 18:20:39 -04001279 [ARP_INPUT_NEXT_REPLY_TX] = "interface-output",
Ed Warnickecb9cada2015-12-08 15:45:58 -07001280 },
Ed Warnickecb9cada2015-12-08 15:45:58 -07001281 .format_buffer = format_ethernet_arp_header,
1282 .format_trace = format_ethernet_arp_input_trace,
1283};
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001284/* *INDENT-ON* */
Ed Warnickecb9cada2015-12-08 15:45:58 -07001285
Ed Warnickecb9cada2015-12-08 15:45:58 -07001286static int
1287ip4_arp_entry_sort (void *a1, void *a2)
1288{
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001289 ethernet_arp_ip4_entry_t *e1 = a1;
1290 ethernet_arp_ip4_entry_t *e2 = a2;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001291
1292 int cmp;
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001293 vnet_main_t *vnm = vnet_get_main ();
Ed Warnickecb9cada2015-12-08 15:45:58 -07001294
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001295 cmp = vnet_sw_interface_compare (vnm, e1->sw_if_index, e2->sw_if_index);
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001296 if (!cmp)
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001297 cmp = ip4_address_compare (&e1->ip4_address, &e2->ip4_address);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001298 return cmp;
1299}
1300
Pavel Kotucek3e046ea2016-12-05 08:27:37 +01001301ethernet_arp_ip4_entry_t *
1302ip4_neighbor_entries (u32 sw_if_index)
1303{
1304 ethernet_arp_main_t *am = &ethernet_arp_main;
1305 ethernet_arp_ip4_entry_t *n, *ns = 0;
1306
1307 /* *INDENT-OFF* */
1308 pool_foreach (n, am->ip4_entry_pool, ({
1309 if (sw_if_index != ~0 && n->sw_if_index != sw_if_index)
1310 continue;
1311 vec_add1 (ns, n[0]);
1312 }));
1313 /* *INDENT-ON* */
1314
1315 if (ns)
1316 vec_sort_with_function (ns, ip4_arp_entry_sort);
1317 return ns;
1318}
1319
Ed Warnickecb9cada2015-12-08 15:45:58 -07001320static clib_error_t *
1321show_ip4_arp (vlib_main_t * vm,
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001322 unformat_input_t * input, vlib_cli_command_t * cmd)
Ed Warnickecb9cada2015-12-08 15:45:58 -07001323{
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001324 vnet_main_t *vnm = vnet_get_main ();
1325 ethernet_arp_main_t *am = &ethernet_arp_main;
1326 ethernet_arp_ip4_entry_t *e, *es;
1327 ethernet_proxy_arp_t *pa;
1328 clib_error_t *error = 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001329 u32 sw_if_index;
1330
1331 /* Filter entries by interface if given. */
1332 sw_if_index = ~0;
1333 (void) unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index);
1334
Pavel Kotucek3e046ea2016-12-05 08:27:37 +01001335 es = ip4_neighbor_entries (sw_if_index);
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001336 if (es)
Keith Wilescb466842016-02-11 19:21:10 -06001337 {
Keith Wilescb466842016-02-11 19:21:10 -06001338 vlib_cli_output (vm, "%U", format_ethernet_arp_ip4_entry, vnm, 0);
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001339 vec_foreach (e, es)
1340 {
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001341 vlib_cli_output (vm, "%U", format_ethernet_arp_ip4_entry, vnm, e);
Keith Wilescb466842016-02-11 19:21:10 -06001342 }
1343 vec_free (es);
1344 }
Ed Warnickecb9cada2015-12-08 15:45:58 -07001345
1346 if (vec_len (am->proxy_arps))
1347 {
1348 vlib_cli_output (vm, "Proxy arps enabled for:");
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001349 vec_foreach (pa, am->proxy_arps)
1350 {
1351 vlib_cli_output (vm, "Fib_index %d %U - %U ",
1352 pa->fib_index,
1353 format_ip4_address, &pa->lo_addr,
1354 format_ip4_address, &pa->hi_addr);
1355 }
Ed Warnickecb9cada2015-12-08 15:45:58 -07001356 }
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001357
Ed Warnickecb9cada2015-12-08 15:45:58 -07001358 return error;
1359}
1360
Billy McFall2d085d92016-09-13 21:47:55 -04001361/*?
1362 * Display all the IPv4 ARP entries.
1363 *
1364 * @cliexpar
1365 * Example of how to display the IPv4 ARP table:
1366 * @cliexstart{show ip arp}
1367 * Time FIB IP4 Flags Ethernet Interface
1368 * 346.3028 0 6.1.1.3 de:ad:be:ef:ba:be GigabitEthernet2/0/0
1369 * 3077.4271 0 6.1.1.4 S de:ad:be:ef:ff:ff GigabitEthernet2/0/0
1370 * 2998.6409 1 6.2.2.3 de:ad:be:ef:00:01 GigabitEthernet2/0/0
1371 * Proxy arps enabled for:
1372 * Fib_index 0 6.0.0.1 - 6.0.0.11
1373 * @cliexend
1374 ?*/
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001375/* *INDENT-OFF* */
Ed Warnickecb9cada2015-12-08 15:45:58 -07001376VLIB_CLI_COMMAND (show_ip4_arp_command, static) = {
1377 .path = "show ip arp",
1378 .function = show_ip4_arp,
Billy McFall2d085d92016-09-13 21:47:55 -04001379 .short_help = "show ip arp",
Ed Warnickecb9cada2015-12-08 15:45:58 -07001380};
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001381/* *INDENT-ON* */
Ed Warnickecb9cada2015-12-08 15:45:58 -07001382
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001383typedef struct
1384{
Ed Warnickecb9cada2015-12-08 15:45:58 -07001385 pg_edit_t l2_type, l3_type;
1386 pg_edit_t n_l2_address_bytes, n_l3_address_bytes;
1387 pg_edit_t opcode;
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001388 struct
1389 {
Ed Warnickecb9cada2015-12-08 15:45:58 -07001390 pg_edit_t ethernet;
1391 pg_edit_t ip4;
1392 } ip4_over_ethernet[2];
1393} pg_ethernet_arp_header_t;
1394
1395static inline void
1396pg_ethernet_arp_header_init (pg_ethernet_arp_header_t * p)
1397{
1398 /* Initialize fields that are not bit fields in the IP header. */
1399#define _(f) pg_edit_init (&p->f, ethernet_arp_header_t, f);
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001400 _(l2_type);
1401 _(l3_type);
1402 _(n_l2_address_bytes);
1403 _(n_l3_address_bytes);
1404 _(opcode);
1405 _(ip4_over_ethernet[0].ethernet);
1406 _(ip4_over_ethernet[0].ip4);
1407 _(ip4_over_ethernet[1].ethernet);
1408 _(ip4_over_ethernet[1].ip4);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001409#undef _
1410}
1411
1412uword
1413unformat_pg_arp_header (unformat_input_t * input, va_list * args)
1414{
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001415 pg_stream_t *s = va_arg (*args, pg_stream_t *);
1416 pg_ethernet_arp_header_t *p;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001417 u32 group_index;
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001418
Ed Warnickecb9cada2015-12-08 15:45:58 -07001419 p = pg_create_edit_group (s, sizeof (p[0]), sizeof (ethernet_arp_header_t),
1420 &group_index);
1421 pg_ethernet_arp_header_init (p);
1422
1423 /* Defaults. */
1424 pg_edit_set_fixed (&p->l2_type, ETHERNET_ARP_HARDWARE_TYPE_ethernet);
1425 pg_edit_set_fixed (&p->l3_type, ETHERNET_TYPE_IP4);
1426 pg_edit_set_fixed (&p->n_l2_address_bytes, 6);
1427 pg_edit_set_fixed (&p->n_l3_address_bytes, 4);
1428
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001429 if (!unformat (input, "%U: %U/%U -> %U/%U",
1430 unformat_pg_edit,
1431 unformat_ethernet_arp_opcode_net_byte_order, &p->opcode,
1432 unformat_pg_edit,
1433 unformat_ethernet_address, &p->ip4_over_ethernet[0].ethernet,
1434 unformat_pg_edit,
1435 unformat_ip4_address, &p->ip4_over_ethernet[0].ip4,
1436 unformat_pg_edit,
1437 unformat_ethernet_address, &p->ip4_over_ethernet[1].ethernet,
1438 unformat_pg_edit,
1439 unformat_ip4_address, &p->ip4_over_ethernet[1].ip4))
Ed Warnickecb9cada2015-12-08 15:45:58 -07001440 {
1441 /* Free up any edits we may have added. */
1442 pg_free_edit_group (s);
1443 return 0;
1444 }
1445 return 1;
1446}
1447
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001448clib_error_t *
1449ip4_set_arp_limit (u32 arp_limit)
Ed Warnickecb9cada2015-12-08 15:45:58 -07001450{
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001451 ethernet_arp_main_t *am = &ethernet_arp_main;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001452
1453 am->limit_arp_cache_size = arp_limit;
1454 return 0;
1455}
1456
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001457/**
1458 * @brief Control Plane hook to remove an ARP entry
1459 */
1460int
1461vnet_arp_unset_ip4_over_ethernet (vnet_main_t * vnm,
1462 u32 sw_if_index, void *a_arg)
Damjan Marion102ec522016-03-29 13:18:17 +02001463{
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001464 ethernet_arp_ip4_over_ethernet_address_t *a = a_arg;
1465 vnet_arp_set_ip4_over_ethernet_rpc_args_t args;
Damjan Marion102ec522016-03-29 13:18:17 +02001466
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001467 args.sw_if_index = sw_if_index;
1468 args.flags = ETHERNET_ARP_ARGS_REMOVE;
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001469 clib_memcpy (&args.a, a, sizeof (*a));
1470
1471 vl_api_rpc_call_main_thread (set_ip4_over_ethernet_rpc_callback,
1472 (u8 *) & args, sizeof (args));
1473 return 0;
1474}
1475
1476/**
1477 * @brief Internally generated event to flush the ARP cache on an
1478 * interface state change event.
1479 * A flush will remove dynamic ARP entries, and for statics remove the MAC
1480 * address from the corresponding adjacencies.
1481 */
1482static int
1483vnet_arp_flush_ip4_over_ethernet (vnet_main_t * vnm,
Neale Rannsb80c5362016-10-08 13:03:40 +01001484 u32 sw_if_index, void *a_arg)
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001485{
1486 ethernet_arp_ip4_over_ethernet_address_t *a = a_arg;
1487 vnet_arp_set_ip4_over_ethernet_rpc_args_t args;
1488
1489 args.sw_if_index = sw_if_index;
1490 args.flags = ETHERNET_ARP_ARGS_FLUSH;
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001491 clib_memcpy (&args.a, a, sizeof (*a));
1492
1493 vl_api_rpc_call_main_thread (set_ip4_over_ethernet_rpc_callback,
1494 (u8 *) & args, sizeof (args));
1495 return 0;
1496}
1497
1498/**
1499 * @brief Internally generated event to populate the ARP cache on an
1500 * interface state change event.
1501 * For static entries this will re-source the adjacencies.
1502 *
1503 * @param sw_if_index The interface on which the ARP entires are acted
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001504 */
1505static int
1506vnet_arp_populate_ip4_over_ethernet (vnet_main_t * vnm,
Neale Rannsb80c5362016-10-08 13:03:40 +01001507 u32 sw_if_index, void *a_arg)
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001508{
1509 ethernet_arp_ip4_over_ethernet_address_t *a = a_arg;
1510 vnet_arp_set_ip4_over_ethernet_rpc_args_t args;
1511
1512 args.sw_if_index = sw_if_index;
1513 args.flags = ETHERNET_ARP_ARGS_POPULATE;
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001514 clib_memcpy (&args.a, a, sizeof (*a));
1515
1516 vl_api_rpc_call_main_thread (set_ip4_over_ethernet_rpc_callback,
1517 (u8 *) & args, sizeof (args));
1518 return 0;
1519}
1520
Eyal Bari20197482017-09-13 12:29:08 +03001521/**
1522 * @brief publish wildcard arp event
1523 * @param sw_if_index The interface on which the ARP entires are acted
1524 */
1525static int
1526vnet_arp_wc_publish (u32 sw_if_index, void *a_arg)
1527{
1528 ethernet_arp_ip4_over_ethernet_address_t *a = a_arg;
1529 vnet_arp_set_ip4_over_ethernet_rpc_args_t args = {
1530 .flags = ETHERNET_ARP_ARGS_WC_PUB,
1531 .sw_if_index = sw_if_index,
1532 .a = *a
1533 };
1534
1535 vl_api_rpc_call_main_thread (set_ip4_over_ethernet_rpc_callback,
1536 (u8 *) & args, sizeof (args));
1537 return 0;
1538}
1539
1540static void
1541vnet_arp_wc_publish_internal (vnet_main_t * vnm,
1542 vnet_arp_set_ip4_over_ethernet_rpc_args_t *
1543 args)
1544{
1545 vlib_main_t *vm = vlib_get_main ();
1546 ethernet_arp_main_t *am = &ethernet_arp_main;
Eyal Baric125ecc2017-09-20 11:29:17 +03001547 uword ni = am->wc_ip4_arp_publisher_node;
1548 uword et = am->wc_ip4_arp_publisher_et;
1549
1550 if (ni == (uword) ~ 0)
Eyal Bari20197482017-09-13 12:29:08 +03001551 return;
1552 wc_arp_report_t *r =
Eyal Baric125ecc2017-09-20 11:29:17 +03001553 vlib_process_signal_event_data (vm, ni, et, 1, sizeof *r);
Eyal Bari20197482017-09-13 12:29:08 +03001554 r->ip4 = args->a.ip4.as_u32;
1555 r->sw_if_index = args->sw_if_index;
1556 memcpy (r->mac, args->a.ethernet, sizeof r->mac);
1557}
1558
1559void
Eyal Baric125ecc2017-09-20 11:29:17 +03001560wc_arp_set_publisher_node (uword node_index, uword event_type)
Eyal Bari20197482017-09-13 12:29:08 +03001561{
1562 ethernet_arp_main_t *am = &ethernet_arp_main;
1563 am->wc_ip4_arp_publisher_node = node_index;
Eyal Baric125ecc2017-09-20 11:29:17 +03001564 am->wc_ip4_arp_publisher_et = event_type;
Eyal Bari20197482017-09-13 12:29:08 +03001565}
1566
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001567/*
1568 * arp_add_del_interface_address
1569 *
1570 * callback when an interface address is added or deleted
1571 */
1572static void
1573arp_add_del_interface_address (ip4_main_t * im,
1574 uword opaque,
1575 u32 sw_if_index,
1576 ip4_address_t * address,
1577 u32 address_length,
1578 u32 if_address_index, u32 is_del)
1579{
1580 /*
1581 * Flush the ARP cache of all entries covered by the address
1582 * that is being removed.
1583 */
1584 ethernet_arp_main_t *am = &ethernet_arp_main;
1585 ethernet_arp_ip4_entry_t *e;
1586
Neale Ranns177bbdc2016-11-15 09:46:51 +00001587 if (vec_len (am->ethernet_arp_by_sw_if_index) <= sw_if_index)
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001588 return;
1589
1590 if (is_del)
Damjan Marion102ec522016-03-29 13:18:17 +02001591 {
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001592 ethernet_arp_interface_t *eai;
1593 u32 i, *to_delete = 0;
1594 hash_pair_t *pair;
1595
1596 eai = &am->ethernet_arp_by_sw_if_index[sw_if_index];
1597
Neale Rannsb80c5362016-10-08 13:03:40 +01001598 /* *INDENT-OFF* */
1599 hash_foreach_pair (pair, eai->arp_entries,
1600 ({
1601 e = pool_elt_at_index(am->ip4_entry_pool,
1602 pair->value[0]);
1603 if (ip4_destination_matches_route (im, &e->ip4_address,
1604 address, address_length))
1605 {
1606 vec_add1 (to_delete, e - am->ip4_entry_pool);
1607 }
1608 }));
1609 /* *INDENT-ON* */
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001610
1611 for (i = 0; i < vec_len (to_delete); i++)
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001612 {
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001613 ethernet_arp_ip4_over_ethernet_address_t delme;
1614 e = pool_elt_at_index (am->ip4_entry_pool, to_delete[i]);
1615
1616 clib_memcpy (&delme.ethernet, e->ethernet_address, 6);
1617 delme.ip4.as_u32 = e->ip4_address.as_u32;
1618
1619 vnet_arp_flush_ip4_over_ethernet (vnet_get_main (),
Neale Rannsb80c5362016-10-08 13:03:40 +01001620 e->sw_if_index, &delme);
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001621 }
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001622
1623 vec_free (to_delete);
Damjan Marion102ec522016-03-29 13:18:17 +02001624 }
1625}
1626
Neale Ranns15002542017-09-10 04:39:11 -07001627void
Neale Ranns6b3a8ef2017-09-11 10:34:33 -07001628arp_adj_fib_remove (ethernet_arp_ip4_entry_t * e, u32 fib_index)
Neale Ranns15002542017-09-10 04:39:11 -07001629{
1630 if (FIB_NODE_INDEX_INVALID != e->fib_entry_index)
1631 {
1632 fib_prefix_t pfx = {
1633 .fp_len = 32,
1634 .fp_proto = FIB_PROTOCOL_IP4,
1635 .fp_addr.ip4 = e->ip4_address,
1636 };
1637 u32 fib_index;
1638
1639 fib_index = ip4_fib_table_get_index_for_sw_if_index (e->sw_if_index);
1640
1641 fib_table_entry_path_remove (fib_index, &pfx,
1642 FIB_SOURCE_ADJ,
1643 DPO_PROTO_IP4,
1644 &pfx.fp_addr,
1645 e->sw_if_index, ~0, 1,
1646 FIB_ROUTE_PATH_FLAG_NONE);
1647 fib_table_unlock (fib_index, FIB_PROTOCOL_IP4, FIB_SOURCE_ADJ);
1648 }
1649}
1650
1651static void
1652arp_table_bind (ip4_main_t * im,
1653 uword opaque,
1654 u32 sw_if_index, u32 new_fib_index, u32 old_fib_index)
1655{
1656 ethernet_arp_main_t *am = &ethernet_arp_main;
1657 ethernet_arp_interface_t *eai;
1658 ethernet_arp_ip4_entry_t *e;
1659 hash_pair_t *pair;
1660
1661 /*
1662 * the IP table that the interface is bound to has changed.
1663 * reinstall all the adj fibs.
1664 */
1665
1666 if (vec_len (am->ethernet_arp_by_sw_if_index) <= sw_if_index)
1667 return;
1668
1669 eai = &am->ethernet_arp_by_sw_if_index[sw_if_index];
1670
1671 /* *INDENT-OFF* */
1672 hash_foreach_pair (pair, eai->arp_entries,
1673 ({
1674 e = pool_elt_at_index(am->ip4_entry_pool,
1675 pair->value[0]);
1676 /*
1677 * remove the adj-fib from the old table and add to the new
1678 */
1679 arp_adj_fib_remove(e, old_fib_index);
1680 arp_adj_fib_add(e, new_fib_index);
1681 }));
1682 /* *INDENT-ON* */
1683
1684}
1685
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001686static clib_error_t *
1687ethernet_arp_init (vlib_main_t * vm)
Ed Warnickecb9cada2015-12-08 15:45:58 -07001688{
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001689 ethernet_arp_main_t *am = &ethernet_arp_main;
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001690 ip4_main_t *im = &ip4_main;
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001691 clib_error_t *error;
1692 pg_node_t *pn;
Dave Barach1f49ed62016-02-24 11:29:06 -05001693
1694 if ((error = vlib_call_init_function (vm, ethernet_init)))
1695 return error;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001696
1697 ethernet_register_input_type (vm, ETHERNET_TYPE_ARP, arp_input_node.index);
1698
1699 pn = pg_get_node (arp_input_node.index);
1700 pn->unformat_edit = unformat_pg_arp_header;
1701
1702 am->opcode_by_name = hash_create_string (0, sizeof (uword));
1703#define _(o) hash_set_mem (am->opcode_by_name, #o, ETHERNET_ARP_OPCODE_##o);
1704 foreach_ethernet_arp_opcode;
1705#undef _
1706
Ed Warnickecb9cada2015-12-08 15:45:58 -07001707 /* $$$ configurable */
1708 am->limit_arp_cache_size = 50000;
1709
1710 am->pending_resolutions_by_address = hash_create (0, sizeof (uword));
1711 am->mac_changes_by_address = hash_create (0, sizeof (uword));
Eyal Bari20197482017-09-13 12:29:08 +03001712 am->wc_ip4_arp_publisher_node = (uword) ~ 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001713
1714 /* don't trace ARP error packets */
1715 {
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001716 vlib_node_runtime_t *rt =
Ed Warnickecb9cada2015-12-08 15:45:58 -07001717 vlib_node_get_runtime (vm, arp_input_node.index);
1718
1719#define _(a,b) \
1720 vnet_pcap_drop_trace_filter_add_del \
1721 (rt->errors[ETHERNET_ARP_ERROR_##a], \
1722 1 /* is_add */);
1723 foreach_ethernet_arp_error
1724#undef _
1725 }
Damjan Marion102ec522016-03-29 13:18:17 +02001726
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001727 ip4_add_del_interface_address_callback_t cb;
1728 cb.function = arp_add_del_interface_address;
1729 cb.function_opaque = 0;
1730 vec_add1 (im->add_del_interface_address_callbacks, cb);
1731
Neale Ranns15002542017-09-10 04:39:11 -07001732 ip4_table_bind_callback_t cbt;
1733 cbt.function = arp_table_bind;
1734 cbt.function_opaque = 0;
1735 vec_add1 (im->table_bind_callbacks, cbt);
1736
Ed Warnickecb9cada2015-12-08 15:45:58 -07001737 return 0;
1738}
1739
1740VLIB_INIT_FUNCTION (ethernet_arp_init);
1741
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001742static void
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001743arp_entry_free (ethernet_arp_interface_t * eai, ethernet_arp_ip4_entry_t * e)
1744{
1745 ethernet_arp_main_t *am = &ethernet_arp_main;
1746
Neale Ranns15002542017-09-10 04:39:11 -07001747 arp_adj_fib_remove (e,
1748 ip4_fib_table_get_index_for_sw_if_index
1749 (e->sw_if_index));
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001750 hash_unset (eai->arp_entries, e->ip4_address.as_u32);
1751 pool_put (am->ip4_entry_pool, e);
1752}
1753
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001754static inline int
Ed Warnickecb9cada2015-12-08 15:45:58 -07001755vnet_arp_unset_ip4_over_ethernet_internal (vnet_main_t * vnm,
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001756 vnet_arp_set_ip4_over_ethernet_rpc_args_t
1757 * args)
Ed Warnickecb9cada2015-12-08 15:45:58 -07001758{
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001759 ethernet_arp_main_t *am = &ethernet_arp_main;
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001760 ethernet_arp_ip4_entry_t *e;
1761 ethernet_arp_interface_t *eai;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001762
Matthew Smith66c0adf2017-08-09 16:30:43 -05001763 if (vec_len (am->ethernet_arp_by_sw_if_index) <= args->sw_if_index)
1764 return 0;
1765
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001766 eai = &am->ethernet_arp_by_sw_if_index[args->sw_if_index];
Ed Warnickecb9cada2015-12-08 15:45:58 -07001767
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001768 e = arp_entry_find (eai, &args->a.ip4);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001769
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001770 if (NULL != e)
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001771 {
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001772 arp_entry_free (eai, e);
Neale Ranns19c68d22016-12-07 15:38:14 +00001773
1774 adj_nbr_walk_nh4 (e->sw_if_index,
1775 &e->ip4_address, arp_mk_incomplete_walk, NULL);
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001776 }
Ed Warnickecb9cada2015-12-08 15:45:58 -07001777
Ed Warnickecb9cada2015-12-08 15:45:58 -07001778 return 0;
1779}
1780
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001781static int
1782vnet_arp_flush_ip4_over_ethernet_internal (vnet_main_t * vnm,
1783 vnet_arp_set_ip4_over_ethernet_rpc_args_t
1784 * args)
1785{
1786 ethernet_arp_main_t *am = &ethernet_arp_main;
1787 ethernet_arp_ip4_entry_t *e;
1788 ethernet_arp_interface_t *eai;
1789
Matthew Smith66c0adf2017-08-09 16:30:43 -05001790 if (vec_len (am->ethernet_arp_by_sw_if_index) <= args->sw_if_index)
1791 return 0;
1792
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001793 eai = &am->ethernet_arp_by_sw_if_index[args->sw_if_index];
1794
1795 e = arp_entry_find (eai, &args->a.ip4);
1796
1797 if (NULL != e)
1798 {
Neale Rannsb80c5362016-10-08 13:03:40 +01001799 adj_nbr_walk_nh4 (e->sw_if_index,
1800 &e->ip4_address, arp_mk_incomplete_walk, e);
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001801
1802 /*
1803 * The difference between flush and unset, is that an unset
1804 * means delete for static and dynamic entries. A flush
1805 * means delete only for dynamic. Flushing is what the DP
1806 * does in response to interface events. unset is only done
1807 * by the control plane.
1808 */
Neale Ranns15002542017-09-10 04:39:11 -07001809 if (e->flags & ETHERNET_ARP_IP4_ENTRY_FLAG_STATIC)
1810 {
1811 e->flags &= ETHERNET_ARP_IP4_ENTRY_FLAG_DYNAMIC;
1812 }
1813 else if (e->flags & ETHERNET_ARP_IP4_ENTRY_FLAG_DYNAMIC)
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001814 {
1815 arp_entry_free (eai, e);
1816 }
1817 }
1818 return (0);
1819}
1820
1821static int
1822vnet_arp_populate_ip4_over_ethernet_internal (vnet_main_t * vnm,
1823 vnet_arp_set_ip4_over_ethernet_rpc_args_t
1824 * args)
1825{
1826 ethernet_arp_main_t *am = &ethernet_arp_main;
1827 ethernet_arp_ip4_entry_t *e;
1828 ethernet_arp_interface_t *eai;
1829
Matthew Smith66c0adf2017-08-09 16:30:43 -05001830 vec_validate (am->ethernet_arp_by_sw_if_index, args->sw_if_index);
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001831 eai = &am->ethernet_arp_by_sw_if_index[args->sw_if_index];
1832
1833 e = arp_entry_find (eai, &args->a.ip4);
1834
1835 if (NULL != e)
1836 {
Neale Rannsb80c5362016-10-08 13:03:40 +01001837 adj_nbr_walk_nh4 (e->sw_if_index,
1838 &e->ip4_address, arp_mk_complete_walk, e);
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001839 }
1840 return (0);
1841}
1842
1843static void
1844set_ip4_over_ethernet_rpc_callback (vnet_arp_set_ip4_over_ethernet_rpc_args_t
1845 * a)
1846{
1847 vnet_main_t *vm = vnet_get_main ();
Damjan Marion586afd72017-04-05 19:18:20 +02001848 ASSERT (vlib_get_thread_index () == 0);
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001849
1850 if (a->flags & ETHERNET_ARP_ARGS_REMOVE)
1851 vnet_arp_unset_ip4_over_ethernet_internal (vm, a);
1852 else if (a->flags & ETHERNET_ARP_ARGS_FLUSH)
1853 vnet_arp_flush_ip4_over_ethernet_internal (vm, a);
1854 else if (a->flags & ETHERNET_ARP_ARGS_POPULATE)
1855 vnet_arp_populate_ip4_over_ethernet_internal (vm, a);
Eyal Bari20197482017-09-13 12:29:08 +03001856 else if (a->flags & ETHERNET_ARP_ARGS_WC_PUB)
1857 vnet_arp_wc_publish_internal (vm, a);
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001858 else
1859 vnet_arp_set_ip4_over_ethernet_internal (vm, a);
1860}
1861
1862/**
1863 * @brief Invoked when the interface's admin state changes
1864 */
1865static clib_error_t *
1866ethernet_arp_sw_interface_up_down (vnet_main_t * vnm,
1867 u32 sw_if_index, u32 flags)
1868{
1869 ethernet_arp_main_t *am = &ethernet_arp_main;
1870 ethernet_arp_ip4_entry_t *e;
1871 u32 i, *to_delete = 0;
1872
1873 /* *INDENT-OFF* */
1874 pool_foreach (e, am->ip4_entry_pool,
1875 ({
1876 if (e->sw_if_index == sw_if_index)
Neale Rannsb80c5362016-10-08 13:03:40 +01001877 vec_add1 (to_delete,
1878 e - am->ip4_entry_pool);
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001879 }));
1880 /* *INDENT-ON* */
1881
1882 for (i = 0; i < vec_len (to_delete); i++)
1883 {
1884 ethernet_arp_ip4_over_ethernet_address_t delme;
1885 e = pool_elt_at_index (am->ip4_entry_pool, to_delete[i]);
1886
1887 clib_memcpy (&delme.ethernet, e->ethernet_address, 6);
1888 delme.ip4.as_u32 = e->ip4_address.as_u32;
1889
1890 if (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP)
1891 {
Neale Rannsb80c5362016-10-08 13:03:40 +01001892 vnet_arp_populate_ip4_over_ethernet (vnm, e->sw_if_index, &delme);
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001893 }
1894 else
1895 {
Neale Rannsb80c5362016-10-08 13:03:40 +01001896 vnet_arp_flush_ip4_over_ethernet (vnm, e->sw_if_index, &delme);
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001897 }
1898
1899 }
1900 vec_free (to_delete);
1901
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001902 return 0;
1903}
1904
1905VNET_SW_INTERFACE_ADMIN_UP_DOWN_FUNCTION (ethernet_arp_sw_interface_up_down);
1906
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001907static void
1908increment_ip4_and_mac_address (ethernet_arp_ip4_over_ethernet_address_t * a)
Ed Warnickecb9cada2015-12-08 15:45:58 -07001909{
1910 u8 old;
1911 int i;
1912
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001913 for (i = 3; i >= 0; i--)
Ed Warnickecb9cada2015-12-08 15:45:58 -07001914 {
1915 old = a->ip4.as_u8[i];
1916 a->ip4.as_u8[i] += 1;
1917 if (old < a->ip4.as_u8[i])
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001918 break;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001919 }
1920
1921 for (i = 5; i >= 0; i--)
1922 {
1923 old = a->ethernet[i];
1924 a->ethernet[i] += 1;
1925 if (old < a->ethernet[i])
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001926 break;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001927 }
1928}
1929
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001930int
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001931vnet_arp_set_ip4_over_ethernet (vnet_main_t * vnm,
Neale Rannsb3b2de72017-03-08 05:17:22 -08001932 u32 sw_if_index, void *a_arg,
1933 int is_static, int is_no_fib_entry)
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001934{
1935 ethernet_arp_ip4_over_ethernet_address_t *a = a_arg;
1936 vnet_arp_set_ip4_over_ethernet_rpc_args_t args;
1937
1938 args.sw_if_index = sw_if_index;
1939 args.is_static = is_static;
Neale Rannsb3b2de72017-03-08 05:17:22 -08001940 args.is_no_fib_entry = is_no_fib_entry;
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001941 args.flags = 0;
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001942 clib_memcpy (&args.a, a, sizeof (*a));
1943
1944 vl_api_rpc_call_main_thread (set_ip4_over_ethernet_rpc_callback,
1945 (u8 *) & args, sizeof (args));
1946 return 0;
1947}
1948
1949int
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001950vnet_proxy_arp_add_del (ip4_address_t * lo_addr,
1951 ip4_address_t * hi_addr, u32 fib_index, int is_del)
Ed Warnickecb9cada2015-12-08 15:45:58 -07001952{
1953 ethernet_arp_main_t *am = &ethernet_arp_main;
1954 ethernet_proxy_arp_t *pa;
1955 u32 found_at_index = ~0;
1956
1957 vec_foreach (pa, am->proxy_arps)
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001958 {
1959 if (pa->lo_addr == lo_addr->as_u32
1960 && pa->hi_addr == hi_addr->as_u32 && pa->fib_index == fib_index)
1961 {
1962 found_at_index = pa - am->proxy_arps;
1963 break;
1964 }
1965 }
Ed Warnickecb9cada2015-12-08 15:45:58 -07001966
1967 if (found_at_index != ~0)
1968 {
1969 /* Delete, otherwise it's already in the table */
1970 if (is_del)
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001971 vec_delete (am->proxy_arps, 1, found_at_index);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001972 return 0;
1973 }
1974 /* delete, no such entry */
1975 if (is_del)
1976 return VNET_API_ERROR_NO_SUCH_ENTRY;
1977
1978 /* add, not in table */
1979 vec_add2 (am->proxy_arps, pa, 1);
1980 pa->lo_addr = lo_addr->as_u32;
1981 pa->hi_addr = hi_addr->as_u32;
1982 pa->fib_index = fib_index;
1983 return 0;
1984}
1985
1986/*
Damjan Marion607de1a2016-08-16 22:53:54 +02001987 * Remove any proxy arp entries asdociated with the
Ed Warnickecb9cada2015-12-08 15:45:58 -07001988 * specificed fib.
1989 */
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001990int
1991vnet_proxy_arp_fib_reset (u32 fib_id)
Ed Warnickecb9cada2015-12-08 15:45:58 -07001992{
Ed Warnickecb9cada2015-12-08 15:45:58 -07001993 ethernet_arp_main_t *am = &ethernet_arp_main;
1994 ethernet_proxy_arp_t *pa;
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07001995 u32 *entries_to_delete = 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001996 u32 fib_index;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001997 int i;
1998
Neale Ranns107e7d42017-04-11 09:55:19 -07001999 fib_index = fib_table_find (FIB_PROTOCOL_IP4, fib_id);
2000 if (~0 == fib_index)
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002001 return VNET_API_ERROR_NO_SUCH_ENTRY;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002002
2003 vec_foreach (pa, am->proxy_arps)
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002004 {
2005 if (pa->fib_index == fib_index)
2006 {
2007 vec_add1 (entries_to_delete, pa - am->proxy_arps);
2008 }
2009 }
Ed Warnickecb9cada2015-12-08 15:45:58 -07002010
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002011 for (i = 0; i < vec_len (entries_to_delete); i++)
Ed Warnickecb9cada2015-12-08 15:45:58 -07002012 {
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002013 vec_delete (am->proxy_arps, 1, entries_to_delete[i]);
2014 }
Ed Warnickecb9cada2015-12-08 15:45:58 -07002015
2016 vec_free (entries_to_delete);
2017
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002018 return 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002019}
2020
2021static clib_error_t *
2022ip_arp_add_del_command_fn (vlib_main_t * vm,
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002023 unformat_input_t * input, vlib_cli_command_t * cmd)
Ed Warnickecb9cada2015-12-08 15:45:58 -07002024{
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002025 vnet_main_t *vnm = vnet_get_main ();
Ed Warnickecb9cada2015-12-08 15:45:58 -07002026 u32 sw_if_index;
2027 ethernet_arp_ip4_over_ethernet_address_t lo_addr, hi_addr, addr;
2028 int addr_valid = 0;
2029 int is_del = 0;
2030 int count = 1;
2031 u32 fib_index = 0;
2032 u32 fib_id;
2033 int is_static = 0;
Neale Rannsb3b2de72017-03-08 05:17:22 -08002034 int is_no_fib_entry = 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002035 int is_proxy = 0;
2036
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002037 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
Ed Warnickecb9cada2015-12-08 15:45:58 -07002038 {
2039 /* set ip arp TenGigE1/1/0/1 1.2.3.4 aa:bb:... or aabb.ccdd... */
2040 if (unformat (input, "%U %U %U",
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002041 unformat_vnet_sw_interface, vnm, &sw_if_index,
2042 unformat_ip4_address, &addr.ip4,
2043 unformat_ethernet_address, &addr.ethernet))
2044 addr_valid = 1;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002045
2046 else if (unformat (input, "delete") || unformat (input, "del"))
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002047 is_del = 1;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002048
2049 else if (unformat (input, "static"))
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002050 is_static = 1;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002051
Neale Rannsb3b2de72017-03-08 05:17:22 -08002052 else if (unformat (input, "no-fib-entry"))
2053 is_no_fib_entry = 1;
2054
Ed Warnickecb9cada2015-12-08 15:45:58 -07002055 else if (unformat (input, "count %d", &count))
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002056 ;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002057
2058 else if (unformat (input, "fib-id %d", &fib_id))
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002059 {
Neale Ranns107e7d42017-04-11 09:55:19 -07002060 fib_index = fib_table_find (FIB_PROTOCOL_IP4, fib_id);
2061
2062 if (~0 == fib_index)
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002063 return clib_error_return (0, "fib ID %d doesn't exist\n", fib_id);
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002064 }
Ed Warnickecb9cada2015-12-08 15:45:58 -07002065
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002066 else if (unformat (input, "proxy %U - %U",
2067 unformat_ip4_address, &lo_addr.ip4,
2068 unformat_ip4_address, &hi_addr.ip4))
2069 is_proxy = 1;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002070 else
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002071 break;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002072 }
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002073
Ed Warnickecb9cada2015-12-08 15:45:58 -07002074 if (is_proxy)
2075 {
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002076 (void) vnet_proxy_arp_add_del (&lo_addr.ip4, &hi_addr.ip4,
2077 fib_index, is_del);
Ed Warnickecb9cada2015-12-08 15:45:58 -07002078 return 0;
2079 }
2080
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002081 if (addr_valid)
Ed Warnickecb9cada2015-12-08 15:45:58 -07002082 {
2083 int i;
2084
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002085 for (i = 0; i < count; i++)
2086 {
2087 if (is_del == 0)
2088 {
2089 uword event_type, *event_data = 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002090
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002091 /* Park the debug CLI until the arp entry is installed */
2092 vnet_register_ip4_arp_resolution_event
2093 (vnm, &addr.ip4, vlib_current_process (vm),
2094 1 /* type */ , 0 /* data */ );
Ed Warnickecb9cada2015-12-08 15:45:58 -07002095
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002096 vnet_arp_set_ip4_over_ethernet
Neale Rannsb3b2de72017-03-08 05:17:22 -08002097 (vnm, sw_if_index, &addr, is_static, is_no_fib_entry);
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002098
2099 vlib_process_wait_for_event (vm);
2100 event_type = vlib_process_get_events (vm, &event_data);
2101 vec_reset_length (event_data);
2102 if (event_type != 1)
2103 clib_warning ("event type %d unexpected", event_type);
2104 }
2105 else
Neale Ranns0bfe5d82016-08-25 15:29:12 +01002106 vnet_arp_unset_ip4_over_ethernet (vnm, sw_if_index, &addr);
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002107
2108 increment_ip4_and_mac_address (&addr);
2109 }
Ed Warnickecb9cada2015-12-08 15:45:58 -07002110 }
2111 else
2112 {
2113 return clib_error_return (0, "unknown input `%U'",
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002114 format_unformat_error, input);
Ed Warnickecb9cada2015-12-08 15:45:58 -07002115 }
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002116
Ed Warnickecb9cada2015-12-08 15:45:58 -07002117 return 0;
2118}
2119
Neale Rannsb80c5362016-10-08 13:03:40 +01002120/* *INDENT-OFF* */
Keith Burns (alagalah)6ef7bb92016-09-10 14:55:04 -07002121/*?
Billy McFall2d085d92016-09-13 21:47:55 -04002122 * Add or delete IPv4 ARP cache entries.
2123 *
2124 * @note 'set ip arp' options (e.g. delete, static, 'fib-id <id>',
2125 * 'count <number>', 'interface ip4_addr mac_addr') can be added in
2126 * any order and combination.
Keith Burns (alagalah)6ef7bb92016-09-10 14:55:04 -07002127 *
2128 * @cliexpar
Billy McFall2d085d92016-09-13 21:47:55 -04002129 * @parblock
2130 * Add or delete IPv4 ARP cache entries as follows. MAC Address can be in
2131 * either aa:bb:cc:dd:ee:ff format or aabb.ccdd.eeff format.
2132 * @cliexcmd{set ip arp GigabitEthernet2/0/0 6.0.0.3 dead.beef.babe}
2133 * @cliexcmd{set ip arp delete GigabitEthernet2/0/0 6.0.0.3 de:ad:be:ef:ba:be}
2134 *
2135 * To add or delete an IPv4 ARP cache entry to or from a specific fib
2136 * table:
2137 * @cliexcmd{set ip arp fib-id 1 GigabitEthernet2/0/0 6.0.0.3 dead.beef.babe}
2138 * @cliexcmd{set ip arp fib-id 1 delete GigabitEthernet2/0/0 6.0.0.3 dead.beef.babe}
2139 *
2140 * Add or delete IPv4 static ARP cache entries as follows:
2141 * @cliexcmd{set ip arp static GigabitEthernet2/0/0 6.0.0.3 dead.beef.babe}
2142 * @cliexcmd{set ip arp static delete GigabitEthernet2/0/0 6.0.0.3 dead.beef.babe}
2143 *
2144 * For testing / debugging purposes, the 'set ip arp' command can add or
2145 * delete multiple entries. Supply the 'count N' parameter:
2146 * @cliexcmd{set ip arp count 10 GigabitEthernet2/0/0 6.0.0.3 dead.beef.babe}
2147 * @endparblock
Keith Burns (alagalah)6ef7bb92016-09-10 14:55:04 -07002148 ?*/
Ed Warnickecb9cada2015-12-08 15:45:58 -07002149VLIB_CLI_COMMAND (ip_arp_add_del_command, static) = {
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002150 .path = "set ip arp",
2151 .short_help =
Neale Rannsb3b2de72017-03-08 05:17:22 -08002152 "set ip arp [del] <intfc> <ip-address> <mac-address> [static] [no-fib-entry] [count <count>] [fib-id <fib-id>] [proxy <lo-addr> - <hi-addr>]",
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002153 .function = ip_arp_add_del_command_fn,
Ed Warnickecb9cada2015-12-08 15:45:58 -07002154};
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002155/* *INDENT-ON* */
Ed Warnickecb9cada2015-12-08 15:45:58 -07002156
2157static clib_error_t *
2158set_int_proxy_arp_command_fn (vlib_main_t * vm,
Neale Rannsb80c5362016-10-08 13:03:40 +01002159 unformat_input_t *
2160 input, vlib_cli_command_t * cmd)
Ed Warnickecb9cada2015-12-08 15:45:58 -07002161{
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002162 vnet_main_t *vnm = vnet_get_main ();
Ed Warnickecb9cada2015-12-08 15:45:58 -07002163 u32 sw_if_index;
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002164 vnet_sw_interface_t *si;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002165 int enable = 0;
2166 int intfc_set = 0;
2167
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002168 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
Ed Warnickecb9cada2015-12-08 15:45:58 -07002169 {
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002170 if (unformat (input, "%U", unformat_vnet_sw_interface,
2171 vnm, &sw_if_index))
2172 intfc_set = 1;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002173 else if (unformat (input, "enable") || unformat (input, "on"))
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002174 enable = 1;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002175 else if (unformat (input, "disable") || unformat (input, "off"))
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002176 enable = 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002177 else
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002178 break;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002179 }
2180
2181 if (intfc_set == 0)
2182 return clib_error_return (0, "unknown input '%U'",
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002183 format_unformat_error, input);
Ed Warnickecb9cada2015-12-08 15:45:58 -07002184
2185 si = vnet_get_sw_interface (vnm, sw_if_index);
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002186 ASSERT (si);
Ed Warnickecb9cada2015-12-08 15:45:58 -07002187 if (enable)
2188 si->flags |= VNET_SW_INTERFACE_FLAG_PROXY_ARP;
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002189 else
Ed Warnickecb9cada2015-12-08 15:45:58 -07002190 si->flags &= ~VNET_SW_INTERFACE_FLAG_PROXY_ARP;
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002191
Ed Warnickecb9cada2015-12-08 15:45:58 -07002192 return 0;
2193}
2194
Neale Rannsb80c5362016-10-08 13:03:40 +01002195/* *INDENT-OFF* */
Keith Burns (alagalah)6ef7bb92016-09-10 14:55:04 -07002196/*?
Billy McFall2d085d92016-09-13 21:47:55 -04002197 * Enable proxy-arp on an interface. The vpp stack will answer ARP
2198 * requests for the indicated address range. Multiple proxy-arp
2199 * ranges may be provisioned.
2200 *
2201 * @note Proxy ARP as a technology is infamous for blackholing traffic.
2202 * Also, the underlying implementation has not been performance-tuned.
2203 * Avoid creating an unnecessarily large set of ranges.
Keith Burns (alagalah)6ef7bb92016-09-10 14:55:04 -07002204 *
2205 * @cliexpar
Keith Burns (alagalah)6ef7bb92016-09-10 14:55:04 -07002206 * To enable proxy arp on a range of addresses, use:
Billy McFall2d085d92016-09-13 21:47:55 -04002207 * @cliexcmd{set ip arp proxy 6.0.0.1 - 6.0.0.11}
2208 * Append 'del' to delete a range of proxy ARP addresses:
2209 * @cliexcmd{set ip arp proxy 6.0.0.1 - 6.0.0.11 del}
2210 * You must then specifically enable proxy arp on individual interfaces:
2211 * @cliexcmd{set interface proxy-arp GigabitEthernet0/8/0 enable}
2212 * To disable proxy arp on an individual interface:
2213 * @cliexcmd{set interface proxy-arp GigabitEthernet0/8/0 disable}
Keith Burns (alagalah)6ef7bb92016-09-10 14:55:04 -07002214 ?*/
Ed Warnickecb9cada2015-12-08 15:45:58 -07002215VLIB_CLI_COMMAND (set_int_proxy_enable_command, static) = {
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002216 .path = "set interface proxy-arp",
2217 .short_help =
Neale Rannsb80c5362016-10-08 13:03:40 +01002218 "set interface proxy-arp <intfc> [enable|disable]",
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002219 .function = set_int_proxy_arp_command_fn,
Ed Warnickecb9cada2015-12-08 15:45:58 -07002220};
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002221/* *INDENT-ON* */
Ed Warnickecb9cada2015-12-08 15:45:58 -07002222
2223
2224/*
John Lo1edfba92016-08-27 01:11:57 -04002225 * ARP/ND Termination in a L2 Bridge Domain based on IP4/IP6 to MAC
2226 * hash tables mac_by_ip4 and mac_by_ip6 for each BD.
Ed Warnickecb9cada2015-12-08 15:45:58 -07002227 */
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002228typedef enum
2229{
Ed Warnickecb9cada2015-12-08 15:45:58 -07002230 ARP_TERM_NEXT_L2_OUTPUT,
2231 ARP_TERM_NEXT_DROP,
2232 ARP_TERM_N_NEXT,
2233} arp_term_next_t;
2234
2235u32 arp_term_next_node_index[32];
2236
2237static uword
2238arp_term_l2bd (vlib_main_t * vm,
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002239 vlib_node_runtime_t * node, vlib_frame_t * frame)
Ed Warnickecb9cada2015-12-08 15:45:58 -07002240{
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002241 l2input_main_t *l2im = &l2input_main;
2242 u32 n_left_from, next_index, *from, *to_next;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002243 u32 n_replies_sent = 0;
2244 u16 last_bd_index = ~0;
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002245 l2_bridge_domain_t *last_bd_config = 0;
2246 l2_input_config_t *cfg0;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002247
2248 from = vlib_frame_vector_args (frame);
2249 n_left_from = frame->n_vectors;
2250 next_index = node->cached_next_index;
2251
2252 while (n_left_from > 0)
2253 {
2254 u32 n_left_to_next;
2255
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002256 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
Ed Warnickecb9cada2015-12-08 15:45:58 -07002257
2258 while (n_left_from > 0 && n_left_to_next > 0)
2259 {
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002260 vlib_buffer_t *p0;
2261 ethernet_header_t *eth0;
2262 ethernet_arp_header_t *arp0;
John Lo1edfba92016-08-27 01:11:57 -04002263 ip6_header_t *iph0;
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002264 u8 *l3h0;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002265 u32 pi0, error0, next0, sw_if_index0;
2266 u16 ethertype0;
2267 u16 bd_index0;
2268 u32 ip0;
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002269 u8 *macp0;
Matthew Smithcb9ab472017-05-16 21:35:56 -05002270 u8 is_vrrp_reply0;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002271
2272 pi0 = from[0];
2273 to_next[0] = pi0;
2274 from += 1;
2275 to_next += 1;
2276 n_left_from -= 1;
2277 n_left_to_next -= 1;
2278
2279 p0 = vlib_get_buffer (vm, pi0);
Eyal Baria0623f82017-03-30 03:05:06 +03002280 // Terminate only local (SHG == 0) ARP
2281 if (vnet_buffer (p0)->l2.shg != 0)
2282 goto next_l2_feature;
2283
Ed Warnickecb9cada2015-12-08 15:45:58 -07002284 eth0 = vlib_buffer_get_current (p0);
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002285 l3h0 = (u8 *) eth0 + vnet_buffer (p0)->l2.l2_len;
2286 ethertype0 = clib_net_to_host_u16 (*(u16 *) (l3h0 - 2));
Ed Warnickecb9cada2015-12-08 15:45:58 -07002287 arp0 = (ethernet_arp_header_t *) l3h0;
2288
John Lo1edfba92016-08-27 01:11:57 -04002289 if (PREDICT_FALSE ((ethertype0 != ETHERNET_TYPE_ARP) ||
2290 (arp0->opcode !=
2291 clib_host_to_net_u16
2292 (ETHERNET_ARP_OPCODE_request))))
2293 goto check_ip6_nd;
2294
2295 /* Must be ARP request packet here */
Ed Warnickecb9cada2015-12-08 15:45:58 -07002296 if (PREDICT_FALSE ((node->flags & VLIB_NODE_FLAG_TRACE) &&
2297 (p0->flags & VLIB_BUFFER_IS_TRACED)))
2298 {
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002299 u8 *t0 = vlib_add_trace (vm, node, p0,
2300 sizeof (ethernet_arp_input_trace_t));
2301 clib_memcpy (t0, l3h0, sizeof (ethernet_arp_input_trace_t));
Ed Warnickecb9cada2015-12-08 15:45:58 -07002302 }
2303
Ed Warnickecb9cada2015-12-08 15:45:58 -07002304 error0 = ETHERNET_ARP_ERROR_replies_sent;
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002305 error0 =
2306 (arp0->l2_type !=
Neale Rannsb80c5362016-10-08 13:03:40 +01002307 clib_net_to_host_u16 (ETHERNET_ARP_HARDWARE_TYPE_ethernet)
2308 ? ETHERNET_ARP_ERROR_l2_type_not_ethernet : error0);
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002309 error0 =
2310 (arp0->l3_type !=
2311 clib_net_to_host_u16 (ETHERNET_TYPE_IP4) ?
2312 ETHERNET_ARP_ERROR_l3_type_not_ip4 : error0);
Ed Warnickecb9cada2015-12-08 15:45:58 -07002313
2314 sw_if_index0 = vnet_buffer (p0)->sw_if_index[VLIB_RX];
2315
2316 if (error0)
2317 goto drop;
2318
Matthew Smithcb9ab472017-05-16 21:35:56 -05002319 is_vrrp_reply0 =
2320 ((arp0->opcode ==
2321 clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_reply))
2322 &&
2323 (!memcmp
2324 (arp0->ip4_over_ethernet[0].ethernet, vrrp_prefix,
2325 sizeof (vrrp_prefix))));
2326
John Lo1edfba92016-08-27 01:11:57 -04002327 /* Trash ARP packets whose ARP-level source addresses do not
Matthew Smithcb9ab472017-05-16 21:35:56 -05002328 match their L2-frame-level source addresses, unless it's
2329 a reply from a VRRP virtual router */
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002330 if (PREDICT_FALSE
Matthew Smithcb9ab472017-05-16 21:35:56 -05002331 (memcmp (eth0->src_address, arp0->ip4_over_ethernet[0].ethernet,
2332 sizeof (eth0->src_address)) && !is_vrrp_reply0))
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002333 {
2334 error0 = ETHERNET_ARP_ERROR_l2_address_mismatch;
2335 goto drop;
2336 }
Ed Warnickecb9cada2015-12-08 15:45:58 -07002337
John Lo1edfba92016-08-27 01:11:57 -04002338 /* Check if anyone want ARP request events for L2 BDs */
Ed Warnickecb9cada2015-12-08 15:45:58 -07002339 {
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002340 ethernet_arp_main_t *am = &ethernet_arp_main;
Eyal Bari20197482017-09-13 12:29:08 +03002341 if (am->wc_ip4_arp_publisher_node != (uword) ~ 0)
2342 vnet_arp_wc_publish (sw_if_index0, &arp0->ip4_over_ethernet[0]);
Ed Warnickecb9cada2015-12-08 15:45:58 -07002343 }
2344
John Lo1edfba92016-08-27 01:11:57 -04002345 /* lookup BD mac_by_ip4 hash table for MAC entry */
Ed Warnickecb9cada2015-12-08 15:45:58 -07002346 ip0 = arp0->ip4_over_ethernet[1].ip4.as_u32;
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002347 bd_index0 = vnet_buffer (p0)->l2.bd_index;
2348 if (PREDICT_FALSE ((bd_index0 != last_bd_index)
2349 || (last_bd_index == (u16) ~ 0)))
Ed Warnickecb9cada2015-12-08 15:45:58 -07002350 {
2351 last_bd_index = bd_index0;
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002352 last_bd_config = vec_elt_at_index (l2im->bd_configs, bd_index0);
Ed Warnickecb9cada2015-12-08 15:45:58 -07002353 }
2354 macp0 = (u8 *) hash_get (last_bd_config->mac_by_ip4, ip0);
2355
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002356 if (PREDICT_FALSE (!macp0))
John Lo1edfba92016-08-27 01:11:57 -04002357 goto next_l2_feature; /* MAC not found */
Ed Warnickecb9cada2015-12-08 15:45:58 -07002358
John Lo1edfba92016-08-27 01:11:57 -04002359 /* MAC found, send ARP reply -
2360 Convert ARP request packet to ARP reply */
Ed Warnickecb9cada2015-12-08 15:45:58 -07002361 arp0->opcode = clib_host_to_net_u16 (ETHERNET_ARP_OPCODE_reply);
2362 arp0->ip4_over_ethernet[1] = arp0->ip4_over_ethernet[0];
2363 arp0->ip4_over_ethernet[0].ip4.as_u32 = ip0;
Damjan Marionf1213b82016-03-13 02:22:06 +01002364 clib_memcpy (arp0->ip4_over_ethernet[0].ethernet, macp0, 6);
2365 clib_memcpy (eth0->dst_address, eth0->src_address, 6);
2366 clib_memcpy (eth0->src_address, macp0, 6);
Ed Warnickecb9cada2015-12-08 15:45:58 -07002367 n_replies_sent += 1;
2368
John Lo1edfba92016-08-27 01:11:57 -04002369 output_response:
2370 /* For BVI, need to use l2-fwd node to send ARP reply as
2371 l2-output node cannot output packet to BVI properly */
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002372 cfg0 = vec_elt_at_index (l2im->configs, sw_if_index0);
Ed Warnickecb9cada2015-12-08 15:45:58 -07002373 if (PREDICT_FALSE (cfg0->bvi))
2374 {
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002375 vnet_buffer (p0)->l2.feature_bitmap |= L2INPUT_FEAT_FWD;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002376 vnet_buffer (p0)->sw_if_index[VLIB_RX] = 0;
2377 goto next_l2_feature;
2378 }
2379
John Lo1edfba92016-08-27 01:11:57 -04002380 /* Send ARP/ND reply back out input interface through l2-output */
Ed Warnickecb9cada2015-12-08 15:45:58 -07002381 vnet_buffer (p0)->sw_if_index[VLIB_TX] = sw_if_index0;
2382 next0 = ARP_TERM_NEXT_L2_OUTPUT;
Neale Rannsb80c5362016-10-08 13:03:40 +01002383 vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
2384 to_next, n_left_to_next, pi0,
2385 next0);
Ed Warnickecb9cada2015-12-08 15:45:58 -07002386 continue;
2387
John Lo1edfba92016-08-27 01:11:57 -04002388 check_ip6_nd:
2389 /* IP6 ND event notification or solicitation handling to generate
2390 local response instead of flooding */
2391 iph0 = (ip6_header_t *) l3h0;
2392 if (PREDICT_FALSE (ethertype0 == ETHERNET_TYPE_IP6 &&
2393 iph0->protocol == IP_PROTOCOL_ICMP6 &&
John Lo1edfba92016-08-27 01:11:57 -04002394 !ip6_address_is_unspecified
2395 (&iph0->src_address)))
2396 {
2397 sw_if_index0 = vnet_buffer (p0)->sw_if_index[VLIB_RX];
Neale Rannsb80c5362016-10-08 13:03:40 +01002398 if (vnet_ip6_nd_term
2399 (vm, node, p0, eth0, iph0, sw_if_index0,
Eyal Baria0623f82017-03-30 03:05:06 +03002400 vnet_buffer (p0)->l2.bd_index))
John Lo1edfba92016-08-27 01:11:57 -04002401 goto output_response;
2402 }
2403
Ed Warnickecb9cada2015-12-08 15:45:58 -07002404 next_l2_feature:
2405 {
John Lobeb0b2e2017-07-22 00:21:36 -04002406 next0 = vnet_l2_feature_next (p0, arp_term_next_node_index,
2407 L2INPUT_FEAT_ARP_TERM);
Neale Rannsb80c5362016-10-08 13:03:40 +01002408 vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
2409 to_next, n_left_to_next,
2410 pi0, next0);
Ed Warnickecb9cada2015-12-08 15:45:58 -07002411 continue;
2412 }
2413
2414 drop:
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002415 if (0 == arp0->ip4_over_ethernet[0].ip4.as_u32 ||
2416 (arp0->ip4_over_ethernet[0].ip4.as_u32 ==
2417 arp0->ip4_over_ethernet[1].ip4.as_u32))
2418 {
2419 error0 = ETHERNET_ARP_ERROR_gratuitous_arp;
2420 }
Ed Warnickecb9cada2015-12-08 15:45:58 -07002421 next0 = ARP_TERM_NEXT_DROP;
2422 p0->error = node->errors[error0];
2423
Neale Rannsb80c5362016-10-08 13:03:40 +01002424 vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
2425 to_next, n_left_to_next, pi0,
2426 next0);
Ed Warnickecb9cada2015-12-08 15:45:58 -07002427 }
2428
2429 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
2430 }
2431
2432 vlib_error_count (vm, node->node_index,
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002433 ETHERNET_ARP_ERROR_replies_sent, n_replies_sent);
Ed Warnickecb9cada2015-12-08 15:45:58 -07002434 return frame->n_vectors;
2435}
2436
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002437/* *INDENT-OFF* */
2438VLIB_REGISTER_NODE (arp_term_l2bd_node, static) = {
Ed Warnickecb9cada2015-12-08 15:45:58 -07002439 .function = arp_term_l2bd,
2440 .name = "arp-term-l2bd",
2441 .vector_size = sizeof (u32),
Ed Warnickecb9cada2015-12-08 15:45:58 -07002442 .n_errors = ETHERNET_ARP_N_ERROR,
2443 .error_strings = ethernet_arp_error_strings,
Ed Warnickecb9cada2015-12-08 15:45:58 -07002444 .n_next_nodes = ARP_TERM_N_NEXT,
2445 .next_nodes = {
2446 [ARP_TERM_NEXT_L2_OUTPUT] = "l2-output",
2447 [ARP_TERM_NEXT_DROP] = "error-drop",
2448 },
Ed Warnickecb9cada2015-12-08 15:45:58 -07002449 .format_buffer = format_ethernet_arp_header,
John Lo1edfba92016-08-27 01:11:57 -04002450 .format_trace = format_arp_term_input_trace,
Ed Warnickecb9cada2015-12-08 15:45:58 -07002451};
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002452/* *INDENT-ON* */
Ed Warnickecb9cada2015-12-08 15:45:58 -07002453
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002454clib_error_t *
2455arp_term_init (vlib_main_t * vm)
Neale Rannsb80c5362016-10-08 13:03:40 +01002456{
2457 // Initialize the feature next-node indexes
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002458 feat_bitmap_init_next_nodes (vm,
2459 arp_term_l2bd_node.index,
2460 L2INPUT_N_FEAT,
2461 l2input_get_feat_names (),
2462 arp_term_next_node_index);
Ed Warnickecb9cada2015-12-08 15:45:58 -07002463 return 0;
2464}
2465
2466VLIB_INIT_FUNCTION (arp_term_init);
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002467
Pavel Kotucekc631f2d2016-09-26 10:40:02 +02002468void
2469change_arp_mac (u32 sw_if_index, ethernet_arp_ip4_entry_t * e)
2470{
2471 if (e->sw_if_index == sw_if_index)
2472 {
Neale Rannsb80c5362016-10-08 13:03:40 +01002473 adj_nbr_walk_nh4 (e->sw_if_index,
2474 &e->ip4_address, arp_mk_complete_walk, e);
Pavel Kotucekc631f2d2016-09-26 10:40:02 +02002475 }
2476}
2477
2478void
Neale Ranns3be6b282016-12-20 14:24:01 +00002479ethernet_arp_change_mac (u32 sw_if_index)
Pavel Kotucekc631f2d2016-09-26 10:40:02 +02002480{
2481 ethernet_arp_main_t *am = &ethernet_arp_main;
2482 ethernet_arp_ip4_entry_t *e;
2483
2484 /* *INDENT-OFF* */
2485 pool_foreach (e, am->ip4_entry_pool,
Neale Rannsb80c5362016-10-08 13:03:40 +01002486 ({
2487 change_arp_mac (sw_if_index, e);
2488 }));
Pavel Kotucekc631f2d2016-09-26 10:40:02 +02002489 /* *INDENT-ON* */
2490}
2491
John Lo7e9743a2017-09-23 08:59:58 -04002492void
John Lo8b81cb42017-06-26 01:40:20 -04002493send_ip4_garp (vlib_main_t * vm, vnet_hw_interface_t * hi)
2494{
2495 ip4_main_t *i4m = &ip4_main;
2496 u32 sw_if_index = hi->sw_if_index;
2497 ip4_address_t *ip4_addr = ip4_interface_first_address (i4m, sw_if_index, 0);
2498
2499 if (ip4_addr)
2500 {
2501 clib_warning ("Sending GARP for IP4 address %U on sw_if_idex %d",
2502 format_ip4_address, ip4_addr, sw_if_index);
2503
2504 /* Form GARP packet for output - Gratuitous ARP is an ARP request packet
2505 where the interface IP/MAC pair is used for both source and request
2506 MAC/IP pairs in the request */
2507 u32 bi = 0;
2508 ethernet_arp_header_t *h = vlib_packet_template_get_packet
2509 (vm, &i4m->ip4_arp_request_packet_template, &bi);
2510 clib_memcpy (h->ip4_over_ethernet[0].ethernet, hi->hw_address,
2511 sizeof (h->ip4_over_ethernet[0].ethernet));
2512 clib_memcpy (h->ip4_over_ethernet[1].ethernet, hi->hw_address,
2513 sizeof (h->ip4_over_ethernet[1].ethernet));
2514 h->ip4_over_ethernet[0].ip4 = ip4_addr[0];
2515 h->ip4_over_ethernet[1].ip4 = ip4_addr[0];
2516
2517 /* Setup MAC header with ARP Etype and broadcast DMAC */
2518 vlib_buffer_t *b = vlib_get_buffer (vm, bi);
2519 vlib_buffer_advance (b, -sizeof (ethernet_header_t));
2520 ethernet_header_t *e = vlib_buffer_get_current (b);
2521 e->type = clib_host_to_net_u16 (ETHERNET_TYPE_ARP);
2522 clib_memcpy (e->src_address, hi->hw_address, sizeof (e->src_address));
2523 memset (e->dst_address, 0xff, sizeof (e->dst_address));
2524
2525 /* Send GARP packet out the specified interface */
2526 vnet_buffer (b)->sw_if_index[VLIB_RX] =
2527 vnet_buffer (b)->sw_if_index[VLIB_TX] = sw_if_index;
2528 vlib_frame_t *f = vlib_get_frame_to_node (vm, hi->output_node_index);
2529 u32 *to_next = vlib_frame_vector_args (f);
2530 to_next[0] = bi;
2531 f->n_vectors = 1;
2532 vlib_put_frame_to_node (vm, hi->output_node_index, f);
2533 }
2534}
2535
Keith Burns (alagalah)e70dcc82016-08-15 18:33:19 -07002536/*
2537 * fd.io coding-style-patch-verification: ON
2538 *
2539 * Local Variables:
2540 * eval: (c-set-style "gnu")
2541 * End:
2542 */