blob: d5cf011b677e4ad9c5bf04b4abb345e2ce233dcd [file] [log] [blame]
Ed Warnickecb9cada2015-12-08 15:45:58 -07001/*
2 * Copyright (c) 2015 Cisco and/or its affiliates.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at:
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15/*
16 * ip/ip4_forward.c: IP v4 forwarding
17 *
18 * Copyright (c) 2008 Eliot Dresselhaus
19 *
20 * Permission is hereby granted, free of charge, to any person obtaining
21 * a copy of this software and associated documentation files (the
22 * "Software"), to deal in the Software without restriction, including
23 * without limitation the rights to use, copy, modify, merge, publish,
24 * distribute, sublicense, and/or sell copies of the Software, and to
25 * permit persons to whom the Software is furnished to do so, subject to
26 * the following conditions:
27 *
28 * The above copyright notice and this permission notice shall be
29 * included in all copies or substantial portions of the Software.
30 *
31 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
32 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
33 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
34 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
35 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
36 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
37 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
38 */
39
40#include <vnet/vnet.h>
41#include <vnet/ip/ip.h>
Ole Troan313f7e22018-04-10 16:02:51 +020042#include <vnet/ip/ip_frag.h>
Neale Ranns0bfe5d82016-08-25 15:29:12 +010043#include <vnet/ethernet/ethernet.h> /* for ethernet_header_t */
44#include <vnet/ethernet/arp_packet.h> /* for ethernet_arp_header_t */
Ed Warnickecb9cada2015-12-08 15:45:58 -070045#include <vnet/ppp/ppp.h>
Neale Ranns0bfe5d82016-08-25 15:29:12 +010046#include <vnet/srp/srp.h> /* for srp_hw_interface_class */
Dave Barachd7cb1b52016-12-09 09:52:16 -050047#include <vnet/api_errno.h> /* for API error numbers */
48#include <vnet/fib/fib_table.h> /* for FIB table and entry creation */
49#include <vnet/fib/fib_entry.h> /* for FIB table and entry creation */
50#include <vnet/fib/fib_urpf_list.h> /* for FIB uRPF check */
Neale Ranns0bfe5d82016-08-25 15:29:12 +010051#include <vnet/fib/ip4_fib.h>
52#include <vnet/dpo/load_balance.h>
Neale Rannsf12a83f2017-04-18 09:09:40 -070053#include <vnet/dpo/load_balance_map.h>
Neale Ranns0bfe5d82016-08-25 15:29:12 +010054#include <vnet/dpo/classify_dpo.h>
Neale Ranns32e1c012016-11-22 17:07:28 +000055#include <vnet/mfib/mfib_table.h> /* for mFIB table and entry creation */
Ed Warnickecb9cada2015-12-08 15:45:58 -070056
Vijayabhaskar Katamreddyacbde662018-01-23 13:39:40 -080057#include <vnet/ip/ip4_forward.h>
Ed Warnickecb9cada2015-12-08 15:45:58 -070058
Chris Luke8e5b0412016-07-26 13:06:10 -040059/** @brief IPv4 lookup node.
Dave Barach9770e202016-07-06 10:29:27 -040060 @node ip4-lookup
61
62 This is the main IPv4 lookup dispatch node.
63
64 @param vm vlib_main_t corresponding to the current thread
65 @param node vlib_node_runtime_t
66 @param frame vlib_frame_t whose contents should be dispatched
67
68 @par Graph mechanics: buffer metadata, next index usage
69
70 @em Uses:
71 - <code>vnet_buffer(b)->sw_if_index[VLIB_RX]</code>
72 - Indicates the @c sw_if_index value of the interface that the
73 packet was received on.
74 - <code>vnet_buffer(b)->sw_if_index[VLIB_TX]</code>
75 - When the value is @c ~0 then the node performs a longest prefix
76 match (LPM) for the packet destination address in the FIB attached
77 to the receive interface.
78 - Otherwise perform LPM for the packet destination address in the
79 indicated FIB. In this case <code>[VLIB_TX]</code> is a FIB index
80 value (0, 1, ...) and not a VRF id.
81
82 @em Sets:
83 - <code>vnet_buffer(b)->ip.adj_index[VLIB_TX]</code>
84 - The lookup result adjacency index.
85
86 <em>Next Index:</em>
87 - Dispatches the packet to the node index found in
88 ip_adjacency_t @c adj->lookup_next_index
89 (where @c adj is the lookup result adjacency).
90*/
Damjan Marionc9dad5d2018-08-11 22:10:29 +020091VLIB_NODE_FN (ip4_lookup_node) (vlib_main_t * vm, vlib_node_runtime_t * node,
92 vlib_frame_t * frame)
Ed Warnickecb9cada2015-12-08 15:45:58 -070093{
Damjan Marionaca64c92016-04-13 09:48:56 +020094 return ip4_lookup_inline (vm, node, frame,
Dave Barachd7cb1b52016-12-09 09:52:16 -050095 /* lookup_for_responses_to_locally_received_packets */
96 0);
Ed Warnickecb9cada2015-12-08 15:45:58 -070097
98}
99
Dave Barachd7cb1b52016-12-09 09:52:16 -0500100static u8 *format_ip4_lookup_trace (u8 * s, va_list * args);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100101
Neale Rannsf8686322017-11-29 02:39:53 -0800102/* *INDENT-OFF* */
Dave Barachd7cb1b52016-12-09 09:52:16 -0500103VLIB_REGISTER_NODE (ip4_lookup_node) =
104{
Neale Rannsf8686322017-11-29 02:39:53 -0800105 .name = "ip4-lookup",
106 .vector_size = sizeof (u32),
107 .format_trace = format_ip4_lookup_trace,
108 .n_next_nodes = IP_LOOKUP_N_NEXT,
109 .next_nodes = IP4_LOOKUP_NEXT_NODES,
110};
111/* *INDENT-ON* */
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100112
Damjan Marionc9dad5d2018-08-11 22:10:29 +0200113VLIB_NODE_FN (ip4_load_balance_node) (vlib_main_t * vm,
114 vlib_node_runtime_t * node,
115 vlib_frame_t * frame)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700116{
Dave Barachd7cb1b52016-12-09 09:52:16 -0500117 vlib_combined_counter_main_t *cm = &load_balance_main.lbm_via_counters;
118 u32 n_left_from, n_left_to_next, *from, *to_next;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100119 ip_lookup_next_t next;
Damjan Marion067cd622018-07-11 12:47:43 +0200120 u32 thread_index = vm->thread_index;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700121
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100122 from = vlib_frame_vector_args (frame);
123 n_left_from = frame->n_vectors;
124 next = node->cached_next_index;
125
126 if (node->flags & VLIB_NODE_FLAG_TRACE)
Dave Barachd7cb1b52016-12-09 09:52:16 -0500127 ip4_forward_next_trace (vm, node, frame, VLIB_TX);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100128
129 while (n_left_from > 0)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700130 {
Dave Barachd7cb1b52016-12-09 09:52:16 -0500131 vlib_get_next_frame (vm, node, next, to_next, n_left_to_next);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100132
Dave Barach75fc8542016-10-11 16:16:02 -0400133
Neale Ranns2be95c12016-11-19 13:50:04 +0000134 while (n_left_from >= 4 && n_left_to_next >= 2)
Dave Barachd7cb1b52016-12-09 09:52:16 -0500135 {
136 ip_lookup_next_t next0, next1;
Neale Ranns2be95c12016-11-19 13:50:04 +0000137 const load_balance_t *lb0, *lb1;
Dave Barachd7cb1b52016-12-09 09:52:16 -0500138 vlib_buffer_t *p0, *p1;
Neale Ranns2be95c12016-11-19 13:50:04 +0000139 u32 pi0, lbi0, hc0, pi1, lbi1, hc1;
140 const ip4_header_t *ip0, *ip1;
141 const dpo_id_t *dpo0, *dpo1;
142
Dave Barachd7cb1b52016-12-09 09:52:16 -0500143 /* Prefetch next iteration. */
144 {
145 vlib_buffer_t *p2, *p3;
Neale Ranns2be95c12016-11-19 13:50:04 +0000146
147 p2 = vlib_get_buffer (vm, from[2]);
148 p3 = vlib_get_buffer (vm, from[3]);
149
150 vlib_prefetch_buffer_header (p2, STORE);
151 vlib_prefetch_buffer_header (p3, STORE);
152
153 CLIB_PREFETCH (p2->data, sizeof (ip0[0]), STORE);
154 CLIB_PREFETCH (p3->data, sizeof (ip0[0]), STORE);
Dave Barachd7cb1b52016-12-09 09:52:16 -0500155 }
Neale Ranns2be95c12016-11-19 13:50:04 +0000156
157 pi0 = to_next[0] = from[0];
158 pi1 = to_next[1] = from[1];
159
160 from += 2;
161 n_left_from -= 2;
162 to_next += 2;
163 n_left_to_next -= 2;
164
165 p0 = vlib_get_buffer (vm, pi0);
166 p1 = vlib_get_buffer (vm, pi1);
167
168 ip0 = vlib_buffer_get_current (p0);
169 ip1 = vlib_buffer_get_current (p1);
170 lbi0 = vnet_buffer (p0)->ip.adj_index[VLIB_TX];
171 lbi1 = vnet_buffer (p1)->ip.adj_index[VLIB_TX];
172
Dave Barachd7cb1b52016-12-09 09:52:16 -0500173 lb0 = load_balance_get (lbi0);
174 lb1 = load_balance_get (lbi1);
Neale Ranns2be95c12016-11-19 13:50:04 +0000175
Dave Barachd7cb1b52016-12-09 09:52:16 -0500176 /*
177 * this node is for via FIBs we can re-use the hash value from the
178 * to node if present.
179 * We don't want to use the same hash value at each level in the recursion
180 * graph as that would lead to polarisation
181 */
AkshayaNadahalli153b8712017-03-06 18:22:29 +0000182 hc0 = hc1 = 0;
Neale Ranns2be95c12016-11-19 13:50:04 +0000183
Dave Barachd7cb1b52016-12-09 09:52:16 -0500184 if (PREDICT_FALSE (lb0->lb_n_buckets > 1))
185 {
186 if (PREDICT_TRUE (vnet_buffer (p0)->ip.flow_hash))
187 {
188 hc0 = vnet_buffer (p0)->ip.flow_hash =
189 vnet_buffer (p0)->ip.flow_hash >> 1;
190 }
191 else
192 {
193 hc0 = vnet_buffer (p0)->ip.flow_hash =
AkshayaNadahalli153b8712017-03-06 18:22:29 +0000194 ip4_compute_flow_hash (ip0, lb0->lb_hash_config);
Dave Barachd7cb1b52016-12-09 09:52:16 -0500195 }
Neale Rannsf12a83f2017-04-18 09:09:40 -0700196 dpo0 = load_balance_get_fwd_bucket
197 (lb0, (hc0 & (lb0->lb_n_buckets_minus_1)));
198 }
199 else
200 {
201 dpo0 = load_balance_get_bucket_i (lb0, 0);
Dave Barachd7cb1b52016-12-09 09:52:16 -0500202 }
203 if (PREDICT_FALSE (lb1->lb_n_buckets > 1))
204 {
205 if (PREDICT_TRUE (vnet_buffer (p1)->ip.flow_hash))
206 {
207 hc1 = vnet_buffer (p1)->ip.flow_hash =
208 vnet_buffer (p1)->ip.flow_hash >> 1;
209 }
210 else
211 {
212 hc1 = vnet_buffer (p1)->ip.flow_hash =
AkshayaNadahalli153b8712017-03-06 18:22:29 +0000213 ip4_compute_flow_hash (ip1, lb1->lb_hash_config);
Dave Barachd7cb1b52016-12-09 09:52:16 -0500214 }
Neale Rannsf12a83f2017-04-18 09:09:40 -0700215 dpo1 = load_balance_get_fwd_bucket
216 (lb1, (hc1 & (lb1->lb_n_buckets_minus_1)));
Dave Barachd7cb1b52016-12-09 09:52:16 -0500217 }
Neale Rannsf12a83f2017-04-18 09:09:40 -0700218 else
219 {
220 dpo1 = load_balance_get_bucket_i (lb1, 0);
221 }
Neale Ranns2be95c12016-11-19 13:50:04 +0000222
223 next0 = dpo0->dpoi_next_node;
224 next1 = dpo1->dpoi_next_node;
225
226 vnet_buffer (p0)->ip.adj_index[VLIB_TX] = dpo0->dpoi_index;
227 vnet_buffer (p1)->ip.adj_index[VLIB_TX] = dpo1->dpoi_index;
228
229 vlib_increment_combined_counter
Damjan Marion586afd72017-04-05 19:18:20 +0200230 (cm, thread_index, lbi0, 1, vlib_buffer_length_in_chain (vm, p0));
Neale Ranns2be95c12016-11-19 13:50:04 +0000231 vlib_increment_combined_counter
Damjan Marion586afd72017-04-05 19:18:20 +0200232 (cm, thread_index, lbi1, 1, vlib_buffer_length_in_chain (vm, p1));
Neale Ranns2be95c12016-11-19 13:50:04 +0000233
234 vlib_validate_buffer_enqueue_x2 (vm, node, next,
235 to_next, n_left_to_next,
236 pi0, pi1, next0, next1);
Dave Barachd7cb1b52016-12-09 09:52:16 -0500237 }
Neale Ranns2be95c12016-11-19 13:50:04 +0000238
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100239 while (n_left_from > 0 && n_left_to_next > 0)
240 {
241 ip_lookup_next_t next0;
242 const load_balance_t *lb0;
Dave Barachd7cb1b52016-12-09 09:52:16 -0500243 vlib_buffer_t *p0;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100244 u32 pi0, lbi0, hc0;
245 const ip4_header_t *ip0;
246 const dpo_id_t *dpo0;
247
248 pi0 = from[0];
249 to_next[0] = pi0;
Neale Ranns2be95c12016-11-19 13:50:04 +0000250 from += 1;
251 to_next += 1;
252 n_left_to_next -= 1;
253 n_left_from -= 1;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100254
255 p0 = vlib_get_buffer (vm, pi0);
256
257 ip0 = vlib_buffer_get_current (p0);
258 lbi0 = vnet_buffer (p0)->ip.adj_index[VLIB_TX];
259
Dave Barachd7cb1b52016-12-09 09:52:16 -0500260 lb0 = load_balance_get (lbi0);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100261
AkshayaNadahalli153b8712017-03-06 18:22:29 +0000262 hc0 = 0;
Dave Barachd7cb1b52016-12-09 09:52:16 -0500263 if (PREDICT_FALSE (lb0->lb_n_buckets > 1))
264 {
265 if (PREDICT_TRUE (vnet_buffer (p0)->ip.flow_hash))
266 {
267 hc0 = vnet_buffer (p0)->ip.flow_hash =
268 vnet_buffer (p0)->ip.flow_hash >> 1;
269 }
270 else
271 {
272 hc0 = vnet_buffer (p0)->ip.flow_hash =
AkshayaNadahalli153b8712017-03-06 18:22:29 +0000273 ip4_compute_flow_hash (ip0, lb0->lb_hash_config);
Dave Barachd7cb1b52016-12-09 09:52:16 -0500274 }
Neale Rannsf12a83f2017-04-18 09:09:40 -0700275 dpo0 = load_balance_get_fwd_bucket
276 (lb0, (hc0 & (lb0->lb_n_buckets_minus_1)));
Dave Barachd7cb1b52016-12-09 09:52:16 -0500277 }
Neale Rannsf12a83f2017-04-18 09:09:40 -0700278 else
279 {
280 dpo0 = load_balance_get_bucket_i (lb0, 0);
281 }
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100282
283 next0 = dpo0->dpoi_next_node;
284 vnet_buffer (p0)->ip.adj_index[VLIB_TX] = dpo0->dpoi_index;
285
Dave Barach75fc8542016-10-11 16:16:02 -0400286 vlib_increment_combined_counter
Damjan Marion586afd72017-04-05 19:18:20 +0200287 (cm, thread_index, lbi0, 1, vlib_buffer_length_in_chain (vm, p0));
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100288
Neale Ranns2be95c12016-11-19 13:50:04 +0000289 vlib_validate_buffer_enqueue_x1 (vm, node, next,
290 to_next, n_left_to_next,
291 pi0, next0);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100292 }
293
294 vlib_put_next_frame (vm, node, next, n_left_to_next);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700295 }
296
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100297 return frame->n_vectors;
298}
299
Neale Rannsf8686322017-11-29 02:39:53 -0800300/* *INDENT-OFF* */
Dave Barachd7cb1b52016-12-09 09:52:16 -0500301VLIB_REGISTER_NODE (ip4_load_balance_node) =
302{
Neale Rannsf8686322017-11-29 02:39:53 -0800303 .name = "ip4-load-balance",
304 .vector_size = sizeof (u32),
305 .sibling_of = "ip4-lookup",
Damjan Marionc9dad5d2018-08-11 22:10:29 +0200306 .format_trace = format_ip4_lookup_trace,
Neale Rannsf8686322017-11-29 02:39:53 -0800307};
308/* *INDENT-ON* */
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100309
Damjan Marionc9dad5d2018-08-11 22:10:29 +0200310#ifndef CLIB_MARCH_VARIANT
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100311/* get first interface address */
312ip4_address_t *
313ip4_interface_first_address (ip4_main_t * im, u32 sw_if_index,
Dave Barachd7cb1b52016-12-09 09:52:16 -0500314 ip_interface_address_t ** result_ia)
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100315{
Dave Barachd7cb1b52016-12-09 09:52:16 -0500316 ip_lookup_main_t *lm = &im->lookup_main;
317 ip_interface_address_t *ia = 0;
318 ip4_address_t *result = 0;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100319
Neale Ranns32e1c012016-11-22 17:07:28 +0000320 /* *INDENT-OFF* */
321 foreach_ip_interface_address
322 (lm, ia, sw_if_index,
323 1 /* honor unnumbered */ ,
324 ({
325 ip4_address_t * a =
326 ip_interface_address_get_address (lm, ia);
327 result = a;
328 break;
329 }));
330 /* *INDENT-OFF* */
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100331 if (result_ia)
332 *result_ia = result ? ia : 0;
333 return result;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700334}
335
336static void
Neale Ranns1855b8e2018-07-11 10:31:26 -0700337ip4_add_subnet_bcast_route (u32 fib_index,
338 fib_prefix_t *pfx,
339 u32 sw_if_index)
340{
341 vnet_sw_interface_flags_t iflags;
342
343 iflags = vnet_sw_interface_get_flags(vnet_get_main(), sw_if_index);
344
345 fib_table_entry_special_remove(fib_index,
346 pfx,
347 FIB_SOURCE_INTERFACE);
348
349 if (iflags & VNET_SW_INTERFACE_FLAG_DIRECTED_BCAST)
350 {
351 fib_table_entry_update_one_path (fib_index, pfx,
352 FIB_SOURCE_INTERFACE,
353 FIB_ENTRY_FLAG_NONE,
354 DPO_PROTO_IP4,
355 /* No next-hop address */
356 &ADJ_BCAST_ADDR,
357 sw_if_index,
358 // invalid FIB index
359 ~0,
360 1,
361 // no out-label stack
362 NULL,
363 FIB_ROUTE_PATH_FLAG_NONE);
364 }
365 else
366 {
367 fib_table_entry_special_add(fib_index,
368 pfx,
369 FIB_SOURCE_INTERFACE,
370 (FIB_ENTRY_FLAG_DROP |
371 FIB_ENTRY_FLAG_LOOSE_URPF_EXEMPT));
372 }
373}
374
375static void
Ed Warnickecb9cada2015-12-08 15:45:58 -0700376ip4_add_interface_routes (u32 sw_if_index,
377 ip4_main_t * im, u32 fib_index,
378 ip_interface_address_t * a)
379{
Dave Barachd7cb1b52016-12-09 09:52:16 -0500380 ip_lookup_main_t *lm = &im->lookup_main;
381 ip4_address_t *address = ip_interface_address_get_address (lm, a);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100382 fib_prefix_t pfx = {
Dave Barachd7cb1b52016-12-09 09:52:16 -0500383 .fp_len = a->address_length,
384 .fp_proto = FIB_PROTOCOL_IP4,
385 .fp_addr.ip4 = *address,
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100386 };
Ed Warnickecb9cada2015-12-08 15:45:58 -0700387
Neale Ranns9a69a602017-03-26 10:56:33 -0700388 if (pfx.fp_len <= 30)
Dave Barachd7cb1b52016-12-09 09:52:16 -0500389 {
Neale Ranns9a69a602017-03-26 10:56:33 -0700390 /* a /30 or shorter - add a glean for the network address */
Neale Ranns7a272742017-05-30 02:08:14 -0700391 fib_table_entry_update_one_path (fib_index, &pfx,
392 FIB_SOURCE_INTERFACE,
393 (FIB_ENTRY_FLAG_CONNECTED |
394 FIB_ENTRY_FLAG_ATTACHED),
Neale Rannsda78f952017-05-24 09:15:43 -0700395 DPO_PROTO_IP4,
Neale Ranns7a272742017-05-30 02:08:14 -0700396 /* No next-hop address */
397 NULL,
398 sw_if_index,
399 // invalid FIB index
400 ~0,
401 1,
402 // no out-label stack
403 NULL,
404 FIB_ROUTE_PATH_FLAG_NONE);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100405
Neale Ranns9a69a602017-03-26 10:56:33 -0700406 /* Add the two broadcast addresses as drop */
407 fib_prefix_t net_pfx = {
408 .fp_len = 32,
409 .fp_proto = FIB_PROTOCOL_IP4,
410 .fp_addr.ip4.as_u32 = address->as_u32 & im->fib_masks[pfx.fp_len],
411 };
412 if (net_pfx.fp_addr.ip4.as_u32 != pfx.fp_addr.ip4.as_u32)
413 fib_table_entry_special_add(fib_index,
414 &net_pfx,
415 FIB_SOURCE_INTERFACE,
416 (FIB_ENTRY_FLAG_DROP |
Neale Rannsa0558302017-04-13 00:44:52 -0700417 FIB_ENTRY_FLAG_LOOSE_URPF_EXEMPT));
Neale Ranns9a69a602017-03-26 10:56:33 -0700418 net_pfx.fp_addr.ip4.as_u32 |= ~im->fib_masks[pfx.fp_len];
419 if (net_pfx.fp_addr.ip4.as_u32 != pfx.fp_addr.ip4.as_u32)
Neale Ranns1855b8e2018-07-11 10:31:26 -0700420 ip4_add_subnet_bcast_route(fib_index, &net_pfx, sw_if_index);
Neale Ranns9a69a602017-03-26 10:56:33 -0700421 }
422 else if (pfx.fp_len == 31)
423 {
424 u32 mask = clib_host_to_net_u32(1);
425 fib_prefix_t net_pfx = pfx;
426
427 net_pfx.fp_len = 32;
428 net_pfx.fp_addr.ip4.as_u32 ^= mask;
429
430 /* a /31 - add the other end as an attached host */
431 fib_table_entry_update_one_path (fib_index, &net_pfx,
432 FIB_SOURCE_INTERFACE,
433 (FIB_ENTRY_FLAG_ATTACHED),
Neale Rannsda78f952017-05-24 09:15:43 -0700434 DPO_PROTO_IP4,
Neale Ranns9a69a602017-03-26 10:56:33 -0700435 &net_pfx.fp_addr,
436 sw_if_index,
437 // invalid FIB index
438 ~0,
439 1,
440 NULL,
441 FIB_ROUTE_PATH_FLAG_NONE);
442 }
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100443 pfx.fp_len = 32;
444
445 if (sw_if_index < vec_len (lm->classify_table_index_by_sw_if_index))
Dave Barachd7cb1b52016-12-09 09:52:16 -0500446 {
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100447 u32 classify_table_index =
Dave Barachd7cb1b52016-12-09 09:52:16 -0500448 lm->classify_table_index_by_sw_if_index[sw_if_index];
449 if (classify_table_index != (u32) ~ 0)
450 {
451 dpo_id_t dpo = DPO_INVALID;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100452
Dave Barachd7cb1b52016-12-09 09:52:16 -0500453 dpo_set (&dpo,
454 DPO_CLASSIFY,
455 DPO_PROTO_IP4,
456 classify_dpo_create (DPO_PROTO_IP4, classify_table_index));
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100457
Dave Barachd7cb1b52016-12-09 09:52:16 -0500458 fib_table_entry_special_dpo_add (fib_index,
459 &pfx,
460 FIB_SOURCE_CLASSIFY,
461 FIB_ENTRY_FLAG_NONE, &dpo);
462 dpo_reset (&dpo);
463 }
464 }
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100465
Neale Ranns32e1c012016-11-22 17:07:28 +0000466 fib_table_entry_update_one_path (fib_index, &pfx,
467 FIB_SOURCE_INTERFACE,
468 (FIB_ENTRY_FLAG_CONNECTED |
469 FIB_ENTRY_FLAG_LOCAL),
Neale Rannsda78f952017-05-24 09:15:43 -0700470 DPO_PROTO_IP4,
Neale Ranns32e1c012016-11-22 17:07:28 +0000471 &pfx.fp_addr,
472 sw_if_index,
473 // invalid FIB index
474 ~0,
475 1, NULL,
Dave Barachd7cb1b52016-12-09 09:52:16 -0500476 FIB_ROUTE_PATH_FLAG_NONE);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700477}
478
479static void
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100480ip4_del_interface_routes (ip4_main_t * im,
481 u32 fib_index,
Dave Barachd7cb1b52016-12-09 09:52:16 -0500482 ip4_address_t * address, u32 address_length)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700483{
Dave Barachd7cb1b52016-12-09 09:52:16 -0500484 fib_prefix_t pfx = {
485 .fp_len = address_length,
486 .fp_proto = FIB_PROTOCOL_IP4,
487 .fp_addr.ip4 = *address,
488 };
Ed Warnickecb9cada2015-12-08 15:45:58 -0700489
Neale Ranns9a69a602017-03-26 10:56:33 -0700490 if (pfx.fp_len <= 30)
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100491 {
Neale Ranns9a69a602017-03-26 10:56:33 -0700492 fib_prefix_t net_pfx = {
493 .fp_len = 32,
494 .fp_proto = FIB_PROTOCOL_IP4,
495 .fp_addr.ip4.as_u32 = address->as_u32 & im->fib_masks[pfx.fp_len],
496 };
497 if (net_pfx.fp_addr.ip4.as_u32 != pfx.fp_addr.ip4.as_u32)
498 fib_table_entry_special_remove(fib_index,
499 &net_pfx,
500 FIB_SOURCE_INTERFACE);
501 net_pfx.fp_addr.ip4.as_u32 |= ~im->fib_masks[pfx.fp_len];
502 if (net_pfx.fp_addr.ip4.as_u32 != pfx.fp_addr.ip4.as_u32)
503 fib_table_entry_special_remove(fib_index,
504 &net_pfx,
505 FIB_SOURCE_INTERFACE);
Dave Barachd7cb1b52016-12-09 09:52:16 -0500506 fib_table_entry_delete (fib_index, &pfx, FIB_SOURCE_INTERFACE);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100507 }
Neale Ranns9a69a602017-03-26 10:56:33 -0700508 else if (pfx.fp_len == 31)
509 {
510 u32 mask = clib_host_to_net_u32(1);
511 fib_prefix_t net_pfx = pfx;
512
513 net_pfx.fp_len = 32;
514 net_pfx.fp_addr.ip4.as_u32 ^= mask;
515
516 fib_table_entry_delete (fib_index, &net_pfx, FIB_SOURCE_INTERFACE);
517 }
Ed Warnickecb9cada2015-12-08 15:45:58 -0700518
Dave Barachd7cb1b52016-12-09 09:52:16 -0500519 pfx.fp_len = 32;
520 fib_table_entry_delete (fib_index, &pfx, FIB_SOURCE_INTERFACE);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700521}
522
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100523void
Dave Barachd7cb1b52016-12-09 09:52:16 -0500524ip4_sw_interface_enable_disable (u32 sw_if_index, u32 is_enable)
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100525{
Dave Barachd7cb1b52016-12-09 09:52:16 -0500526 ip4_main_t *im = &ip4_main;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700527
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100528 vec_validate_init_empty (im->ip_enabled_by_sw_if_index, sw_if_index, 0);
529
530 /*
531 * enable/disable only on the 1<->0 transition
532 */
533 if (is_enable)
534 {
535 if (1 != ++im->ip_enabled_by_sw_if_index[sw_if_index])
Dave Barachd7cb1b52016-12-09 09:52:16 -0500536 return;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100537 }
538 else
539 {
Dave Barachd7cb1b52016-12-09 09:52:16 -0500540 ASSERT (im->ip_enabled_by_sw_if_index[sw_if_index] > 0);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100541 if (0 != --im->ip_enabled_by_sw_if_index[sw_if_index])
Dave Barachd7cb1b52016-12-09 09:52:16 -0500542 return;
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100543 }
Neale Ranns8269d3d2018-01-30 09:02:20 -0800544 vnet_feature_enable_disable ("ip4-unicast", "ip4-not-enabled", sw_if_index,
Damjan Marion4d489932016-12-09 03:21:27 -0800545 !is_enable, 0, 0);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100546
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100547
Neale Ranns8269d3d2018-01-30 09:02:20 -0800548 vnet_feature_enable_disable ("ip4-multicast", "ip4-not-enabled",
Neale Ranns180279b2017-03-16 15:49:09 -0400549 sw_if_index, !is_enable, 0, 0);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100550}
Ed Warnickecb9cada2015-12-08 15:45:58 -0700551
Ed Warnickecb9cada2015-12-08 15:45:58 -0700552static clib_error_t *
553ip4_add_del_interface_address_internal (vlib_main_t * vm,
554 u32 sw_if_index,
555 ip4_address_t * address,
Dave Barachd7cb1b52016-12-09 09:52:16 -0500556 u32 address_length, u32 is_del)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700557{
Dave Barachd7cb1b52016-12-09 09:52:16 -0500558 vnet_main_t *vnm = vnet_get_main ();
559 ip4_main_t *im = &ip4_main;
560 ip_lookup_main_t *lm = &im->lookup_main;
561 clib_error_t *error = 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700562 u32 if_address_index, elts_before;
Dave Barachd7cb1b52016-12-09 09:52:16 -0500563 ip4_address_fib_t ip4_af, *addr_fib = 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700564
Pavel Kotucek57808982017-08-02 08:20:19 +0200565 /* local0 interface doesn't support IP addressing */
566 if (sw_if_index == 0)
567 {
568 return
569 clib_error_create ("local0 interface doesn't support IP addressing");
570 }
571
Ed Warnickecb9cada2015-12-08 15:45:58 -0700572 vec_validate (im->fib_index_by_sw_if_index, sw_if_index);
573 ip4_addr_fib_init (&ip4_af, address,
574 vec_elt (im->fib_index_by_sw_if_index, sw_if_index));
575 vec_add1 (addr_fib, ip4_af);
576
Neale Ranns744902e2017-08-14 10:35:44 -0700577 /*
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100578 * there is no support for adj-fib handling in the presence of overlapping
579 * subnets on interfaces. Easy fix - disallow overlapping subnets, like
580 * most routers do.
581 */
Neale Ranns32e1c012016-11-22 17:07:28 +0000582 /* *INDENT-OFF* */
Dave Barachd7cb1b52016-12-09 09:52:16 -0500583 if (!is_del)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700584 {
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100585 /* When adding an address check that it does not conflict
Neale Ranns744902e2017-08-14 10:35:44 -0700586 with an existing address on any interface in this table. */
Dave Barachd7cb1b52016-12-09 09:52:16 -0500587 ip_interface_address_t *ia;
Neale Ranns744902e2017-08-14 10:35:44 -0700588 vnet_sw_interface_t *sif;
589
590 pool_foreach(sif, vnm->interface_main.sw_interfaces,
591 ({
592 if (im->fib_index_by_sw_if_index[sw_if_index] ==
593 im->fib_index_by_sw_if_index[sif->sw_if_index])
594 {
595 foreach_ip_interface_address
596 (&im->lookup_main, ia, sif->sw_if_index,
597 0 /* honor unnumbered */ ,
598 ({
599 ip4_address_t * x =
600 ip_interface_address_get_address
601 (&im->lookup_main, ia);
602 if (ip4_destination_matches_route
603 (im, address, x, ia->address_length) ||
604 ip4_destination_matches_route (im,
605 x,
606 address,
607 address_length))
608 {
609 vnm->api_errno = VNET_API_ERROR_DUPLICATE_IF_ADDRESS;
610
611 return
612 clib_error_create
613 ("failed to add %U which conflicts with %U for interface %U",
614 format_ip4_address_and_length, address,
615 address_length,
616 format_ip4_address_and_length, x,
617 ia->address_length,
618 format_vnet_sw_if_index_name, vnm,
619 sif->sw_if_index);
620 }
621 }));
622 }
623 }));
Ed Warnickecb9cada2015-12-08 15:45:58 -0700624 }
Neale Ranns32e1c012016-11-22 17:07:28 +0000625 /* *INDENT-ON* */
Ed Warnickecb9cada2015-12-08 15:45:58 -0700626
Ed Warnickecb9cada2015-12-08 15:45:58 -0700627 elts_before = pool_elts (lm->if_address_pool);
628
629 error = ip_interface_address_add_del
Dave Barachd7cb1b52016-12-09 09:52:16 -0500630 (lm, sw_if_index, addr_fib, address_length, is_del, &if_address_index);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700631 if (error)
632 goto done;
Dave Barach75fc8542016-10-11 16:16:02 -0400633
Dave Barachd7cb1b52016-12-09 09:52:16 -0500634 ip4_sw_interface_enable_disable (sw_if_index, !is_del);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100635
636 if (is_del)
Dave Barachd7cb1b52016-12-09 09:52:16 -0500637 ip4_del_interface_routes (im, ip4_af.fib_index, address, address_length);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100638 else
Dave Barachd7cb1b52016-12-09 09:52:16 -0500639 ip4_add_interface_routes (sw_if_index,
640 im, ip4_af.fib_index,
641 pool_elt_at_index
642 (lm->if_address_pool, if_address_index));
Ed Warnickecb9cada2015-12-08 15:45:58 -0700643
644 /* If pool did not grow/shrink: add duplicate address. */
645 if (elts_before != pool_elts (lm->if_address_pool))
646 {
Dave Barachd7cb1b52016-12-09 09:52:16 -0500647 ip4_add_del_interface_address_callback_t *cb;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700648 vec_foreach (cb, im->add_del_interface_address_callbacks)
649 cb->function (im, cb->function_opaque, sw_if_index,
Dave Barachd7cb1b52016-12-09 09:52:16 -0500650 address, address_length, if_address_index, is_del);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700651 }
652
Dave Barachd7cb1b52016-12-09 09:52:16 -0500653done:
Ed Warnickecb9cada2015-12-08 15:45:58 -0700654 vec_free (addr_fib);
655 return error;
656}
657
658clib_error_t *
Neale Ranns32e1c012016-11-22 17:07:28 +0000659ip4_add_del_interface_address (vlib_main_t * vm,
660 u32 sw_if_index,
661 ip4_address_t * address,
662 u32 address_length, u32 is_del)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700663{
664 return ip4_add_del_interface_address_internal
Dave Barachd7cb1b52016-12-09 09:52:16 -0500665 (vm, sw_if_index, address, address_length, is_del);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700666}
667
Neale Ranns1855b8e2018-07-11 10:31:26 -0700668void
669ip4_directed_broadcast (u32 sw_if_index, u8 enable)
670{
671 ip_interface_address_t *ia;
672 ip4_main_t *im;
673
674 im = &ip4_main;
675
676 /*
677 * when directed broadcast is enabled, the subnet braodcast route will forward
678 * packets using an adjacency with a broadcast MAC. otherwise it drops
679 */
680 /* *INDENT-OFF* */
681 foreach_ip_interface_address(&im->lookup_main, ia,
682 sw_if_index, 0,
683 ({
684 if (ia->address_length <= 30)
685 {
686 ip4_address_t *ipa;
687
688 ipa = ip_interface_address_get_address (&im->lookup_main, ia);
689
690 fib_prefix_t pfx = {
691 .fp_len = 32,
692 .fp_proto = FIB_PROTOCOL_IP4,
693 .fp_addr = {
694 .ip4.as_u32 = (ipa->as_u32 | ~im->fib_masks[ia->address_length]),
695 },
696 };
697
698 ip4_add_subnet_bcast_route
699 (fib_table_get_index_for_sw_if_index(FIB_PROTOCOL_IP4,
700 sw_if_index),
701 &pfx, sw_if_index);
702 }
703 }));
704 /* *INDENT-ON* */
705}
Damjan Marionc9dad5d2018-08-11 22:10:29 +0200706#endif
Neale Ranns1855b8e2018-07-11 10:31:26 -0700707
Dave Barachd6534602016-06-14 18:38:02 -0400708/* Built-in ip4 unicast rx feature path definition */
Dave Barachd7cb1b52016-12-09 09:52:16 -0500709/* *INDENT-OFF* */
Damjan Marion8b3191e2016-11-09 19:54:20 +0100710VNET_FEATURE_ARC_INIT (ip4_unicast, static) =
711{
Dave Barachd7cb1b52016-12-09 09:52:16 -0500712 .arc_name = "ip4-unicast",
Damjan Marion892e0762016-12-09 18:52:05 +0100713 .start_nodes = VNET_FEATURES ("ip4-input", "ip4-input-no-checksum"),
714 .arc_index_ptr = &ip4_main.lookup_main.ucast_feature_arc_index,
715};
Damjan Marion8b3191e2016-11-09 19:54:20 +0100716
Dave Barachd7cb1b52016-12-09 09:52:16 -0500717VNET_FEATURE_INIT (ip4_flow_classify, static) =
718{
Damjan Marion8b3191e2016-11-09 19:54:20 +0100719 .arc_name = "ip4-unicast",
Juraj Sloboda506b2452016-08-07 23:45:24 -0700720 .node_name = "ip4-flow-classify",
Damjan Marion8b3191e2016-11-09 19:54:20 +0100721 .runs_before = VNET_FEATURES ("ip4-inacl"),
Juraj Sloboda506b2452016-08-07 23:45:24 -0700722};
723
Dave Barachd7cb1b52016-12-09 09:52:16 -0500724VNET_FEATURE_INIT (ip4_inacl, static) =
725{
Damjan Marion8b3191e2016-11-09 19:54:20 +0100726 .arc_name = "ip4-unicast",
Dave Barach75fc8542016-10-11 16:16:02 -0400727 .node_name = "ip4-inacl",
Damjan Marion8b3191e2016-11-09 19:54:20 +0100728 .runs_before = VNET_FEATURES ("ip4-source-check-via-rx"),
Dave Barachd6534602016-06-14 18:38:02 -0400729};
730
Dave Barachd7cb1b52016-12-09 09:52:16 -0500731VNET_FEATURE_INIT (ip4_source_check_1, static) =
732{
Damjan Marion8b3191e2016-11-09 19:54:20 +0100733 .arc_name = "ip4-unicast",
Dave Barachd6534602016-06-14 18:38:02 -0400734 .node_name = "ip4-source-check-via-rx",
Damjan Marion8b3191e2016-11-09 19:54:20 +0100735 .runs_before = VNET_FEATURES ("ip4-source-check-via-any"),
Dave Barachd6534602016-06-14 18:38:02 -0400736};
737
Dave Barachd7cb1b52016-12-09 09:52:16 -0500738VNET_FEATURE_INIT (ip4_source_check_2, static) =
739{
Damjan Marion8b3191e2016-11-09 19:54:20 +0100740 .arc_name = "ip4-unicast",
Dave Barachd6534602016-06-14 18:38:02 -0400741 .node_name = "ip4-source-check-via-any",
Damjan Marion8b3191e2016-11-09 19:54:20 +0100742 .runs_before = VNET_FEATURES ("ip4-policer-classify"),
Dave Barachd6534602016-06-14 18:38:02 -0400743};
744
Dave Barachd7cb1b52016-12-09 09:52:16 -0500745VNET_FEATURE_INIT (ip4_source_and_port_range_check_rx, static) =
746{
Damjan Marion8b3191e2016-11-09 19:54:20 +0100747 .arc_name = "ip4-unicast",
Dave Barach5331c722016-08-17 11:54:30 -0400748 .node_name = "ip4-source-and-port-range-check-rx",
Damjan Marion8b3191e2016-11-09 19:54:20 +0100749 .runs_before = VNET_FEATURES ("ip4-policer-classify"),
Dave Barach6f9bca22016-04-30 10:25:32 -0400750};
751
Dave Barachd7cb1b52016-12-09 09:52:16 -0500752VNET_FEATURE_INIT (ip4_policer_classify, static) =
753{
Damjan Marion8b3191e2016-11-09 19:54:20 +0100754 .arc_name = "ip4-unicast",
Matus Fabian70e6a8d2016-06-20 08:10:42 -0700755 .node_name = "ip4-policer-classify",
Damjan Marion8b3191e2016-11-09 19:54:20 +0100756 .runs_before = VNET_FEATURES ("ipsec-input-ip4"),
Matus Fabian70e6a8d2016-06-20 08:10:42 -0700757};
758
Dave Barachd7cb1b52016-12-09 09:52:16 -0500759VNET_FEATURE_INIT (ip4_ipsec, static) =
760{
Damjan Marion8b3191e2016-11-09 19:54:20 +0100761 .arc_name = "ip4-unicast",
Dave Barachd6534602016-06-14 18:38:02 -0400762 .node_name = "ipsec-input-ip4",
Damjan Marion8b3191e2016-11-09 19:54:20 +0100763 .runs_before = VNET_FEATURES ("vpath-input-ip4"),
Dave Barachd6534602016-06-14 18:38:02 -0400764};
765
Dave Barachd7cb1b52016-12-09 09:52:16 -0500766VNET_FEATURE_INIT (ip4_vpath, static) =
767{
Damjan Marion8b3191e2016-11-09 19:54:20 +0100768 .arc_name = "ip4-unicast",
Dave Barachd6534602016-06-14 18:38:02 -0400769 .node_name = "vpath-input-ip4",
John Lo37682e12016-11-30 12:51:39 -0500770 .runs_before = VNET_FEATURES ("ip4-vxlan-bypass"),
771};
772
Dave Barachd7cb1b52016-12-09 09:52:16 -0500773VNET_FEATURE_INIT (ip4_vxlan_bypass, static) =
774{
John Lo37682e12016-11-30 12:51:39 -0500775 .arc_name = "ip4-unicast",
776 .node_name = "ip4-vxlan-bypass",
Damjan Marion8b3191e2016-11-09 19:54:20 +0100777 .runs_before = VNET_FEATURES ("ip4-lookup"),
Dave Barachd6534602016-06-14 18:38:02 -0400778};
779
Neale Ranns8269d3d2018-01-30 09:02:20 -0800780VNET_FEATURE_INIT (ip4_not_enabled, static) =
Dave Barachd7cb1b52016-12-09 09:52:16 -0500781{
Damjan Marion8b3191e2016-11-09 19:54:20 +0100782 .arc_name = "ip4-unicast",
Neale Ranns8269d3d2018-01-30 09:02:20 -0800783 .node_name = "ip4-not-enabled",
Neale Ranns180279b2017-03-16 15:49:09 -0400784 .runs_before = VNET_FEATURES ("ip4-lookup"),
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100785};
786
Neale Ranns180279b2017-03-16 15:49:09 -0400787VNET_FEATURE_INIT (ip4_lookup, static) =
788{
789 .arc_name = "ip4-unicast",
790 .node_name = "ip4-lookup",
791 .runs_before = 0, /* not before any other features */
792};
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100793
Dave Barachd6534602016-06-14 18:38:02 -0400794/* Built-in ip4 multicast rx feature path definition */
Damjan Marion8b3191e2016-11-09 19:54:20 +0100795VNET_FEATURE_ARC_INIT (ip4_multicast, static) =
796{
Dave Barachd7cb1b52016-12-09 09:52:16 -0500797 .arc_name = "ip4-multicast",
Damjan Marion8b3191e2016-11-09 19:54:20 +0100798 .start_nodes = VNET_FEATURES ("ip4-input", "ip4-input-no-checksum"),
799 .arc_index_ptr = &ip4_main.lookup_main.mcast_feature_arc_index,
800};
801
Dave Barachd7cb1b52016-12-09 09:52:16 -0500802VNET_FEATURE_INIT (ip4_vpath_mc, static) =
803{
Damjan Marion8b3191e2016-11-09 19:54:20 +0100804 .arc_name = "ip4-multicast",
Dave Barachd6534602016-06-14 18:38:02 -0400805 .node_name = "vpath-input-ip4",
Neale Ranns32e1c012016-11-22 17:07:28 +0000806 .runs_before = VNET_FEATURES ("ip4-mfib-forward-lookup"),
Dave Barachd6534602016-06-14 18:38:02 -0400807};
808
Neale Ranns8269d3d2018-01-30 09:02:20 -0800809VNET_FEATURE_INIT (ip4_mc_not_enabled, static) =
Dave Barachd7cb1b52016-12-09 09:52:16 -0500810{
Damjan Marion8b3191e2016-11-09 19:54:20 +0100811 .arc_name = "ip4-multicast",
Neale Ranns8269d3d2018-01-30 09:02:20 -0800812 .node_name = "ip4-not-enabled",
Neale Ranns180279b2017-03-16 15:49:09 -0400813 .runs_before = VNET_FEATURES ("ip4-mfib-forward-lookup"),
814};
815
816VNET_FEATURE_INIT (ip4_lookup_mc, static) =
817{
818 .arc_name = "ip4-multicast",
819 .node_name = "ip4-mfib-forward-lookup",
Dave Barachd7cb1b52016-12-09 09:52:16 -0500820 .runs_before = 0, /* last feature */
Neale Ranns5e575b12016-10-03 09:40:25 +0100821};
Dave Barach5331c722016-08-17 11:54:30 -0400822
823/* Source and port-range check ip4 tx feature path definition */
Damjan Marion8b3191e2016-11-09 19:54:20 +0100824VNET_FEATURE_ARC_INIT (ip4_output, static) =
825{
Dave Barachd7cb1b52016-12-09 09:52:16 -0500826 .arc_name = "ip4-output",
Neale Rannsf068c3e2018-01-03 04:18:48 -0800827 .start_nodes = VNET_FEATURES ("ip4-rewrite", "ip4-midchain", "ip4-dvr-dpo"),
Damjan Marion8b3191e2016-11-09 19:54:20 +0100828 .arc_index_ptr = &ip4_main.lookup_main.output_feature_arc_index,
829};
Dave Barach5331c722016-08-17 11:54:30 -0400830
Dave Barachd7cb1b52016-12-09 09:52:16 -0500831VNET_FEATURE_INIT (ip4_source_and_port_range_check_tx, static) =
832{
Damjan Marion8b3191e2016-11-09 19:54:20 +0100833 .arc_name = "ip4-output",
834 .node_name = "ip4-source-and-port-range-check-tx",
Andrew Yourtchenko815d7d52018-02-07 11:37:02 +0100835 .runs_before = VNET_FEATURES ("ip4-outacl"),
836};
837
838VNET_FEATURE_INIT (ip4_outacl, static) =
839{
840 .arc_name = "ip4-output",
841 .node_name = "ip4-outacl",
Matus Fabian08a6f012016-11-15 06:08:51 -0800842 .runs_before = VNET_FEATURES ("ipsec-output-ip4"),
843};
844
Dave Barachd7cb1b52016-12-09 09:52:16 -0500845VNET_FEATURE_INIT (ip4_ipsec_output, static) =
846{
Matus Fabian08a6f012016-11-15 06:08:51 -0800847 .arc_name = "ip4-output",
848 .node_name = "ipsec-output-ip4",
Damjan Marion8b3191e2016-11-09 19:54:20 +0100849 .runs_before = VNET_FEATURES ("interface-output"),
Dave Barach5331c722016-08-17 11:54:30 -0400850};
851
852/* Built-in ip4 tx feature path definition */
Dave Barachd7cb1b52016-12-09 09:52:16 -0500853VNET_FEATURE_INIT (ip4_interface_output, static) =
854{
Damjan Marion8b3191e2016-11-09 19:54:20 +0100855 .arc_name = "ip4-output",
Dave Barach5331c722016-08-17 11:54:30 -0400856 .node_name = "interface-output",
Dave Barachd7cb1b52016-12-09 09:52:16 -0500857 .runs_before = 0, /* not before any other features */
Dave Barach5331c722016-08-17 11:54:30 -0400858};
Dave Barachd7cb1b52016-12-09 09:52:16 -0500859/* *INDENT-ON* */
Dave Barachd6534602016-06-14 18:38:02 -0400860
Ed Warnickecb9cada2015-12-08 15:45:58 -0700861static clib_error_t *
Dave Barachd7cb1b52016-12-09 09:52:16 -0500862ip4_sw_interface_add_del (vnet_main_t * vnm, u32 sw_if_index, u32 is_add)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700863{
Dave Barachd7cb1b52016-12-09 09:52:16 -0500864 ip4_main_t *im = &ip4_main;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700865
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100866 /* Fill in lookup tables with default table (0). */
867 vec_validate (im->fib_index_by_sw_if_index, sw_if_index);
Neale Ranns32e1c012016-11-22 17:07:28 +0000868 vec_validate (im->mfib_index_by_sw_if_index, sw_if_index);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100869
Pavel Kotucek9f5a2b62017-06-14 13:56:55 +0200870 if (!is_add)
871 {
872 ip4_main_t *im4 = &ip4_main;
873 ip_lookup_main_t *lm4 = &im4->lookup_main;
874 ip_interface_address_t *ia = 0;
875 ip4_address_t *address;
876 vlib_main_t *vm = vlib_get_main ();
877
Neale Ranns2ae2bc52018-03-16 03:22:39 -0700878 vnet_sw_interface_update_unnumbered (sw_if_index, ~0, 0);
Pavel Kotucek9f5a2b62017-06-14 13:56:55 +0200879 /* *INDENT-OFF* */
Neale Ranns2ae2bc52018-03-16 03:22:39 -0700880 foreach_ip_interface_address (lm4, ia, sw_if_index, 0,
Pavel Kotucek9f5a2b62017-06-14 13:56:55 +0200881 ({
882 address = ip_interface_address_get_address (lm4, ia);
883 ip4_add_del_interface_address(vm, sw_if_index, address, ia->address_length, 1);
884 }));
885 /* *INDENT-ON* */
886 }
887
Neale Ranns8269d3d2018-01-30 09:02:20 -0800888 vnet_feature_enable_disable ("ip4-unicast", "ip4-not-enabled", sw_if_index,
Damjan Marion8b3191e2016-11-09 19:54:20 +0100889 is_add, 0, 0);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700890
Neale Ranns8269d3d2018-01-30 09:02:20 -0800891 vnet_feature_enable_disable ("ip4-multicast", "ip4-not-enabled",
892 sw_if_index, is_add, 0, 0);
Ed Warnickecb9cada2015-12-08 15:45:58 -0700893
Ed Warnickecb9cada2015-12-08 15:45:58 -0700894 return /* no error */ 0;
895}
896
897VNET_SW_INTERFACE_ADD_DEL_FUNCTION (ip4_sw_interface_add_del);
898
Ed Warnickecb9cada2015-12-08 15:45:58 -0700899/* Global IP4 main. */
900ip4_main_t ip4_main;
901
Damjan Marionc9dad5d2018-08-11 22:10:29 +0200902static clib_error_t *
Ed Warnickecb9cada2015-12-08 15:45:58 -0700903ip4_lookup_init (vlib_main_t * vm)
904{
Dave Barachd7cb1b52016-12-09 09:52:16 -0500905 ip4_main_t *im = &ip4_main;
906 clib_error_t *error;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700907 uword i;
908
Damjan Marion8b3191e2016-11-09 19:54:20 +0100909 if ((error = vlib_call_init_function (vm, vnet_feature_init)))
910 return error;
Neale Ranns1ec36522017-11-29 05:20:37 -0800911 if ((error = vlib_call_init_function (vm, ip4_mtrie_module_init)))
912 return (error);
913 if ((error = vlib_call_init_function (vm, fib_module_init)))
914 return error;
915 if ((error = vlib_call_init_function (vm, mfib_module_init)))
916 return error;
Damjan Marion8b3191e2016-11-09 19:54:20 +0100917
Ed Warnickecb9cada2015-12-08 15:45:58 -0700918 for (i = 0; i < ARRAY_LEN (im->fib_masks); i++)
919 {
920 u32 m;
921
922 if (i < 32)
923 m = pow2_mask (i) << (32 - i);
Dave Barach75fc8542016-10-11 16:16:02 -0400924 else
Ed Warnickecb9cada2015-12-08 15:45:58 -0700925 m = ~0;
926 im->fib_masks[i] = clib_host_to_net_u32 (m);
927 }
928
Ed Warnickecb9cada2015-12-08 15:45:58 -0700929 ip_lookup_init (&im->lookup_main, /* is_ip6 */ 0);
930
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100931 /* Create FIB with index 0 and table id of 0. */
Neale Ranns15002542017-09-10 04:39:11 -0700932 fib_table_find_or_create_and_lock (FIB_PROTOCOL_IP4, 0,
933 FIB_SOURCE_DEFAULT_ROUTE);
934 mfib_table_find_or_create_and_lock (FIB_PROTOCOL_IP4, 0,
935 MFIB_SOURCE_DEFAULT_ROUTE);
Neale Ranns0bfe5d82016-08-25 15:29:12 +0100936
Ed Warnickecb9cada2015-12-08 15:45:58 -0700937 {
Dave Barachd7cb1b52016-12-09 09:52:16 -0500938 pg_node_t *pn;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700939 pn = pg_get_node (ip4_lookup_node.index);
940 pn->unformat_edit = unformat_pg_ip4_header;
941 }
942
943 {
944 ethernet_arp_header_t h;
945
946 memset (&h, 0, sizeof (h));
947
948 /* Set target ethernet address to all zeros. */
Dave Barachd7cb1b52016-12-09 09:52:16 -0500949 memset (h.ip4_over_ethernet[1].ethernet, 0,
950 sizeof (h.ip4_over_ethernet[1].ethernet));
Ed Warnickecb9cada2015-12-08 15:45:58 -0700951
952#define _16(f,v) h.f = clib_host_to_net_u16 (v);
953#define _8(f,v) h.f = v;
954 _16 (l2_type, ETHERNET_ARP_HARDWARE_TYPE_ethernet);
955 _16 (l3_type, ETHERNET_TYPE_IP4);
956 _8 (n_l2_address_bytes, 6);
957 _8 (n_l3_address_bytes, 4);
958 _16 (opcode, ETHERNET_ARP_OPCODE_request);
959#undef _16
960#undef _8
961
Dave Barachd7cb1b52016-12-09 09:52:16 -0500962 vlib_packet_template_init (vm, &im->ip4_arp_request_packet_template,
Ed Warnickecb9cada2015-12-08 15:45:58 -0700963 /* data */ &h,
964 sizeof (h),
965 /* alloc chunk size */ 8,
966 "ip4 arp");
967 }
968
Dave Barach203c6322016-06-26 10:29:03 -0400969 return error;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700970}
971
972VLIB_INIT_FUNCTION (ip4_lookup_init);
973
Dave Barachd7cb1b52016-12-09 09:52:16 -0500974typedef struct
975{
Ed Warnickecb9cada2015-12-08 15:45:58 -0700976 /* Adjacency taken. */
Vengada Govindanf1544482016-09-28 02:45:57 -0700977 u32 dpo_index;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700978 u32 flow_hash;
979 u32 fib_index;
980
981 /* Packet data, possibly *after* rewrite. */
Dave Barachd7cb1b52016-12-09 09:52:16 -0500982 u8 packet_data[64 - 1 * sizeof (u32)];
983}
984ip4_forward_next_trace_t;
Ed Warnickecb9cada2015-12-08 15:45:58 -0700985
Damjan Marionc9dad5d2018-08-11 22:10:29 +0200986#ifndef CLIB_MARCH_VARIANT
Dave Barachd7cb1b52016-12-09 09:52:16 -0500987u8 *
988format_ip4_forward_next_trace (u8 * s, va_list * args)
Ed Warnickecb9cada2015-12-08 15:45:58 -0700989{
990 CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
991 CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
Dave Barachd7cb1b52016-12-09 09:52:16 -0500992 ip4_forward_next_trace_t *t = va_arg (*args, ip4_forward_next_trace_t *);
Christophe Fontained3c008d2017-10-02 18:10:54 +0200993 u32 indent = format_get_indent (s);
Pierre Pfistera38c3df2016-06-13 10:28:09 +0100994 s = format (s, "%U%U",
John Loac8146c2016-09-27 17:44:02 -0400995 format_white_space, indent,
996 format_ip4_header, t->packet_data, sizeof (t->packet_data));
Pierre Pfistera38c3df2016-06-13 10:28:09 +0100997 return s;
998}
Damjan Marionc9dad5d2018-08-11 22:10:29 +0200999#endif
Pierre Pfistera38c3df2016-06-13 10:28:09 +01001000
Dave Barachd7cb1b52016-12-09 09:52:16 -05001001static u8 *
1002format_ip4_lookup_trace (u8 * s, va_list * args)
Pierre Pfistera38c3df2016-06-13 10:28:09 +01001003{
1004 CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
1005 CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
Dave Barachd7cb1b52016-12-09 09:52:16 -05001006 ip4_forward_next_trace_t *t = va_arg (*args, ip4_forward_next_trace_t *);
Christophe Fontained3c008d2017-10-02 18:10:54 +02001007 u32 indent = format_get_indent (s);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001008
John Loac8146c2016-09-27 17:44:02 -04001009 s = format (s, "fib %d dpo-idx %d flow hash: 0x%08x",
Dave Barachd7cb1b52016-12-09 09:52:16 -05001010 t->fib_index, t->dpo_index, t->flow_hash);
Pierre Pfistera38c3df2016-06-13 10:28:09 +01001011 s = format (s, "\n%U%U",
Dave Barachd7cb1b52016-12-09 09:52:16 -05001012 format_white_space, indent,
1013 format_ip4_header, t->packet_data, sizeof (t->packet_data));
Pierre Pfistera38c3df2016-06-13 10:28:09 +01001014 return s;
1015}
Ed Warnickecb9cada2015-12-08 15:45:58 -07001016
Dave Barachd7cb1b52016-12-09 09:52:16 -05001017static u8 *
1018format_ip4_rewrite_trace (u8 * s, va_list * args)
Pierre Pfistera38c3df2016-06-13 10:28:09 +01001019{
1020 CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
1021 CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
Dave Barachd7cb1b52016-12-09 09:52:16 -05001022 ip4_forward_next_trace_t *t = va_arg (*args, ip4_forward_next_trace_t *);
Christophe Fontained3c008d2017-10-02 18:10:54 +02001023 u32 indent = format_get_indent (s);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001024
Vengada Govindanf1544482016-09-28 02:45:57 -07001025 s = format (s, "tx_sw_if_index %d dpo-idx %d : %U flow hash: 0x%08x",
Dave Barachd7cb1b52016-12-09 09:52:16 -05001026 t->fib_index, t->dpo_index, format_ip_adjacency,
1027 t->dpo_index, FORMAT_IP_ADJACENCY_NONE, t->flow_hash);
Pierre Pfistera38c3df2016-06-13 10:28:09 +01001028 s = format (s, "\n%U%U",
Dave Barachd7cb1b52016-12-09 09:52:16 -05001029 format_white_space, indent,
1030 format_ip_adjacency_packet_data,
Neale Rannsb069a692017-03-15 12:34:25 -04001031 t->dpo_index, t->packet_data, sizeof (t->packet_data));
Ed Warnickecb9cada2015-12-08 15:45:58 -07001032 return s;
1033}
1034
Damjan Marionc9dad5d2018-08-11 22:10:29 +02001035#ifndef CLIB_MARCH_VARIANT
Ed Warnickecb9cada2015-12-08 15:45:58 -07001036/* Common trace function for all ip4-forward next nodes. */
1037void
1038ip4_forward_next_trace (vlib_main_t * vm,
1039 vlib_node_runtime_t * node,
Dave Barachd7cb1b52016-12-09 09:52:16 -05001040 vlib_frame_t * frame, vlib_rx_or_tx_t which_adj_index)
Ed Warnickecb9cada2015-12-08 15:45:58 -07001041{
Dave Barachd7cb1b52016-12-09 09:52:16 -05001042 u32 *from, n_left;
1043 ip4_main_t *im = &ip4_main;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001044
1045 n_left = frame->n_vectors;
1046 from = vlib_frame_vector_args (frame);
Dave Barach75fc8542016-10-11 16:16:02 -04001047
Ed Warnickecb9cada2015-12-08 15:45:58 -07001048 while (n_left >= 4)
1049 {
1050 u32 bi0, bi1;
Dave Barachd7cb1b52016-12-09 09:52:16 -05001051 vlib_buffer_t *b0, *b1;
1052 ip4_forward_next_trace_t *t0, *t1;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001053
1054 /* Prefetch next iteration. */
1055 vlib_prefetch_buffer_with_index (vm, from[2], LOAD);
1056 vlib_prefetch_buffer_with_index (vm, from[3], LOAD);
1057
1058 bi0 = from[0];
1059 bi1 = from[1];
1060
1061 b0 = vlib_get_buffer (vm, bi0);
1062 b1 = vlib_get_buffer (vm, bi1);
1063
1064 if (b0->flags & VLIB_BUFFER_IS_TRACED)
1065 {
1066 t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0]));
Vengada Govindanf1544482016-09-28 02:45:57 -07001067 t0->dpo_index = vnet_buffer (b0)->ip.adj_index[which_adj_index];
Ed Warnickecb9cada2015-12-08 15:45:58 -07001068 t0->flow_hash = vnet_buffer (b0)->ip.flow_hash;
Dave Barachd7cb1b52016-12-09 09:52:16 -05001069 t0->fib_index =
1070 (vnet_buffer (b0)->sw_if_index[VLIB_TX] !=
1071 (u32) ~ 0) ? vnet_buffer (b0)->sw_if_index[VLIB_TX] :
1072 vec_elt (im->fib_index_by_sw_if_index,
1073 vnet_buffer (b0)->sw_if_index[VLIB_RX]);
Pierre Pfister0febaf12016-06-08 12:23:21 +01001074
Damjan Marionf1213b82016-03-13 02:22:06 +01001075 clib_memcpy (t0->packet_data,
Dave Barachd7cb1b52016-12-09 09:52:16 -05001076 vlib_buffer_get_current (b0),
1077 sizeof (t0->packet_data));
Ed Warnickecb9cada2015-12-08 15:45:58 -07001078 }
1079 if (b1->flags & VLIB_BUFFER_IS_TRACED)
1080 {
1081 t1 = vlib_add_trace (vm, node, b1, sizeof (t1[0]));
Vengada Govindanf1544482016-09-28 02:45:57 -07001082 t1->dpo_index = vnet_buffer (b1)->ip.adj_index[which_adj_index];
Ed Warnickecb9cada2015-12-08 15:45:58 -07001083 t1->flow_hash = vnet_buffer (b1)->ip.flow_hash;
Dave Barachd7cb1b52016-12-09 09:52:16 -05001084 t1->fib_index =
1085 (vnet_buffer (b1)->sw_if_index[VLIB_TX] !=
1086 (u32) ~ 0) ? vnet_buffer (b1)->sw_if_index[VLIB_TX] :
1087 vec_elt (im->fib_index_by_sw_if_index,
1088 vnet_buffer (b1)->sw_if_index[VLIB_RX]);
1089 clib_memcpy (t1->packet_data, vlib_buffer_get_current (b1),
1090 sizeof (t1->packet_data));
Ed Warnickecb9cada2015-12-08 15:45:58 -07001091 }
1092 from += 2;
1093 n_left -= 2;
1094 }
1095
1096 while (n_left >= 1)
1097 {
1098 u32 bi0;
Dave Barachd7cb1b52016-12-09 09:52:16 -05001099 vlib_buffer_t *b0;
1100 ip4_forward_next_trace_t *t0;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001101
1102 bi0 = from[0];
1103
1104 b0 = vlib_get_buffer (vm, bi0);
1105
1106 if (b0->flags & VLIB_BUFFER_IS_TRACED)
1107 {
1108 t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0]));
Vengada Govindanf1544482016-09-28 02:45:57 -07001109 t0->dpo_index = vnet_buffer (b0)->ip.adj_index[which_adj_index];
Ed Warnickecb9cada2015-12-08 15:45:58 -07001110 t0->flow_hash = vnet_buffer (b0)->ip.flow_hash;
Dave Barachd7cb1b52016-12-09 09:52:16 -05001111 t0->fib_index =
1112 (vnet_buffer (b0)->sw_if_index[VLIB_TX] !=
1113 (u32) ~ 0) ? vnet_buffer (b0)->sw_if_index[VLIB_TX] :
1114 vec_elt (im->fib_index_by_sw_if_index,
1115 vnet_buffer (b0)->sw_if_index[VLIB_RX]);
1116 clib_memcpy (t0->packet_data, vlib_buffer_get_current (b0),
1117 sizeof (t0->packet_data));
Ed Warnickecb9cada2015-12-08 15:45:58 -07001118 }
1119 from += 1;
1120 n_left -= 1;
1121 }
1122}
1123
Ed Warnickecb9cada2015-12-08 15:45:58 -07001124/* Compute TCP/UDP/ICMP4 checksum in software. */
1125u16
1126ip4_tcp_udp_compute_checksum (vlib_main_t * vm, vlib_buffer_t * p0,
1127 ip4_header_t * ip0)
1128{
1129 ip_csum_t sum0;
1130 u32 ip_header_length, payload_length_host_byte_order;
Florin Corasb2215d62017-08-01 16:56:58 -07001131 u32 n_this_buffer, n_bytes_left, n_ip_bytes_this_buffer;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001132 u16 sum16;
Dave Barachd7cb1b52016-12-09 09:52:16 -05001133 void *data_this_buffer;
Dave Barach75fc8542016-10-11 16:16:02 -04001134
Ed Warnickecb9cada2015-12-08 15:45:58 -07001135 /* Initialize checksum with ip header. */
1136 ip_header_length = ip4_header_bytes (ip0);
Dave Barachd7cb1b52016-12-09 09:52:16 -05001137 payload_length_host_byte_order =
1138 clib_net_to_host_u16 (ip0->length) - ip_header_length;
1139 sum0 =
1140 clib_host_to_net_u32 (payload_length_host_byte_order +
1141 (ip0->protocol << 16));
Ed Warnickecb9cada2015-12-08 15:45:58 -07001142
1143 if (BITS (uword) == 32)
1144 {
Dave Barachd7cb1b52016-12-09 09:52:16 -05001145 sum0 =
1146 ip_csum_with_carry (sum0,
1147 clib_mem_unaligned (&ip0->src_address, u32));
1148 sum0 =
1149 ip_csum_with_carry (sum0,
1150 clib_mem_unaligned (&ip0->dst_address, u32));
Ed Warnickecb9cada2015-12-08 15:45:58 -07001151 }
1152 else
Dave Barachd7cb1b52016-12-09 09:52:16 -05001153 sum0 =
1154 ip_csum_with_carry (sum0, clib_mem_unaligned (&ip0->src_address, u64));
Ed Warnickecb9cada2015-12-08 15:45:58 -07001155
1156 n_bytes_left = n_this_buffer = payload_length_host_byte_order;
1157 data_this_buffer = (void *) ip0 + ip_header_length;
Neale Rannsd91c1db2017-07-31 02:30:50 -07001158 n_ip_bytes_this_buffer =
1159 p0->current_length - (((u8 *) ip0 - p0->data) - p0->current_data);
Florin Corasb2215d62017-08-01 16:56:58 -07001160 if (n_this_buffer + ip_header_length > n_ip_bytes_this_buffer)
1161 {
1162 n_this_buffer = n_ip_bytes_this_buffer > ip_header_length ?
Neale Rannsd91c1db2017-07-31 02:30:50 -07001163 n_ip_bytes_this_buffer - ip_header_length : 0;
Florin Corasb2215d62017-08-01 16:56:58 -07001164 }
Ed Warnickecb9cada2015-12-08 15:45:58 -07001165 while (1)
1166 {
1167 sum0 = ip_incremental_checksum (sum0, data_this_buffer, n_this_buffer);
1168 n_bytes_left -= n_this_buffer;
1169 if (n_bytes_left == 0)
1170 break;
1171
1172 ASSERT (p0->flags & VLIB_BUFFER_NEXT_PRESENT);
1173 p0 = vlib_get_buffer (vm, p0->next_buffer);
1174 data_this_buffer = vlib_buffer_get_current (p0);
1175 n_this_buffer = p0->current_length;
1176 }
1177
Dave Barachd7cb1b52016-12-09 09:52:16 -05001178 sum16 = ~ip_csum_fold (sum0);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001179
1180 return sum16;
1181}
1182
John Lo37682e12016-11-30 12:51:39 -05001183u32
Ed Warnickecb9cada2015-12-08 15:45:58 -07001184ip4_tcp_udp_validate_checksum (vlib_main_t * vm, vlib_buffer_t * p0)
1185{
Dave Barachd7cb1b52016-12-09 09:52:16 -05001186 ip4_header_t *ip0 = vlib_buffer_get_current (p0);
1187 udp_header_t *udp0;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001188 u16 sum16;
1189
1190 ASSERT (ip0->protocol == IP_PROTOCOL_TCP
1191 || ip0->protocol == IP_PROTOCOL_UDP);
1192
1193 udp0 = (void *) (ip0 + 1);
1194 if (ip0->protocol == IP_PROTOCOL_UDP && udp0->checksum == 0)
1195 {
Damjan Marion213b5aa2017-07-13 21:19:27 +02001196 p0->flags |= (VNET_BUFFER_F_L4_CHECKSUM_COMPUTED
1197 | VNET_BUFFER_F_L4_CHECKSUM_CORRECT);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001198 return p0->flags;
1199 }
1200
1201 sum16 = ip4_tcp_udp_compute_checksum (vm, p0, ip0);
1202
Damjan Marion213b5aa2017-07-13 21:19:27 +02001203 p0->flags |= (VNET_BUFFER_F_L4_CHECKSUM_COMPUTED
1204 | ((sum16 == 0) << VNET_BUFFER_F_LOG2_L4_CHECKSUM_CORRECT));
Ed Warnickecb9cada2015-12-08 15:45:58 -07001205
1206 return p0->flags;
1207}
Damjan Marionc9dad5d2018-08-11 22:10:29 +02001208#endif
Ed Warnickecb9cada2015-12-08 15:45:58 -07001209
Dave Barach68b0fb02017-02-28 15:15:56 -05001210/* *INDENT-OFF* */
1211VNET_FEATURE_ARC_INIT (ip4_local) =
1212{
1213 .arc_name = "ip4-local",
1214 .start_nodes = VNET_FEATURES ("ip4-local"),
1215};
1216/* *INDENT-ON* */
1217
Florin Coras20a14b92017-08-15 22:47:22 -07001218static inline void
Florin Coras1b255522018-06-01 12:22:23 -07001219ip4_local_l4_csum_validate (vlib_main_t * vm, vlib_buffer_t * p,
1220 ip4_header_t * ip, u8 is_udp, u8 * error,
1221 u8 * good_tcp_udp)
Florin Coras20a14b92017-08-15 22:47:22 -07001222{
1223 u32 flags0;
1224 flags0 = ip4_tcp_udp_validate_checksum (vm, p);
1225 *good_tcp_udp = (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
1226 if (is_udp)
1227 {
1228 udp_header_t *udp;
1229 u32 ip_len, udp_len;
1230 i32 len_diff;
1231 udp = ip4_next_header (ip);
1232 /* Verify UDP length. */
1233 ip_len = clib_net_to_host_u16 (ip->length);
1234 udp_len = clib_net_to_host_u16 (udp->length);
1235
1236 len_diff = ip_len - udp_len;
1237 *good_tcp_udp &= len_diff >= 0;
1238 *error = len_diff < 0 ? IP4_ERROR_UDP_LENGTH : *error;
1239 }
1240}
1241
Florin Coras1b255522018-06-01 12:22:23 -07001242#define ip4_local_csum_is_offloaded(_b) \
1243 _b->flags & VNET_BUFFER_F_OFFLOAD_TCP_CKSUM \
1244 || _b->flags & VNET_BUFFER_F_OFFLOAD_UDP_CKSUM
1245
1246#define ip4_local_need_csum_check(is_tcp_udp, _b) \
1247 (is_tcp_udp && !(_b->flags & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED \
1248 || ip4_local_csum_is_offloaded (_b)))
1249
1250#define ip4_local_csum_is_valid(_b) \
1251 (_b->flags & VNET_BUFFER_F_L4_CHECKSUM_CORRECT \
1252 || (ip4_local_csum_is_offloaded (_b))) != 0
1253
1254static inline void
1255ip4_local_check_l4_csum (vlib_main_t * vm, vlib_buffer_t * b,
1256 ip4_header_t * ih, u8 * error)
1257{
1258 u8 is_udp, is_tcp_udp, good_tcp_udp;
1259
1260 is_udp = ih->protocol == IP_PROTOCOL_UDP;
1261 is_tcp_udp = is_udp || ih->protocol == IP_PROTOCOL_TCP;
1262
1263 if (PREDICT_FALSE (ip4_local_need_csum_check (is_tcp_udp, b)))
1264 ip4_local_l4_csum_validate (vm, b, ih, is_udp, error, &good_tcp_udp);
1265 else
1266 good_tcp_udp = ip4_local_csum_is_valid (b);
1267
1268 ASSERT (IP4_ERROR_TCP_CHECKSUM + 1 == IP4_ERROR_UDP_CHECKSUM);
1269 *error = (is_tcp_udp && !good_tcp_udp
1270 ? IP4_ERROR_TCP_CHECKSUM + is_udp : *error);
1271}
1272
1273static inline void
1274ip4_local_check_l4_csum_x2 (vlib_main_t * vm, vlib_buffer_t ** b,
1275 ip4_header_t ** ih, u8 * error)
1276{
1277 u8 is_udp[2], is_tcp_udp[2], good_tcp_udp[2];
1278
1279 is_udp[0] = ih[0]->protocol == IP_PROTOCOL_UDP;
1280 is_udp[1] = ih[1]->protocol == IP_PROTOCOL_UDP;
1281
1282 is_tcp_udp[0] = is_udp[0] || ih[0]->protocol == IP_PROTOCOL_TCP;
1283 is_tcp_udp[1] = is_udp[1] || ih[1]->protocol == IP_PROTOCOL_TCP;
1284
1285 good_tcp_udp[0] = ip4_local_csum_is_valid (b[0]);
1286 good_tcp_udp[1] = ip4_local_csum_is_valid (b[1]);
1287
1288 if (PREDICT_FALSE (ip4_local_need_csum_check (is_tcp_udp[0], b[0])
1289 || ip4_local_need_csum_check (is_tcp_udp[1], b[1])))
1290 {
1291 if (is_tcp_udp[0])
1292 ip4_local_l4_csum_validate (vm, b[0], ih[0], is_udp[0], &error[0],
1293 &good_tcp_udp[0]);
1294 if (is_tcp_udp[1])
1295 ip4_local_l4_csum_validate (vm, b[1], ih[1], is_udp[1], &error[1],
1296 &good_tcp_udp[1]);
1297 }
1298
1299 error[0] = (is_tcp_udp[0] && !good_tcp_udp[0] ?
1300 IP4_ERROR_TCP_CHECKSUM + is_udp[0] : error[0]);
1301 error[1] = (is_tcp_udp[1] && !good_tcp_udp[1] ?
1302 IP4_ERROR_TCP_CHECKSUM + is_udp[1] : error[1]);
1303}
1304
1305static inline void
1306ip4_local_set_next_and_error (vlib_node_runtime_t * error_node,
1307 vlib_buffer_t * b, u16 * next, u8 error,
1308 u8 head_of_feature_arc)
1309{
1310 u8 arc_index = vnet_feat_arc_ip4_local.feature_arc_index;
1311 u32 next_index;
1312
1313 *next = error != IP4_ERROR_UNKNOWN_PROTOCOL ? IP_LOCAL_NEXT_DROP : *next;
1314 b->error = error ? error_node->errors[error] : 0;
1315 if (head_of_feature_arc)
1316 {
1317 next_index = *next;
1318 if (PREDICT_TRUE (error == (u8) IP4_ERROR_UNKNOWN_PROTOCOL))
1319 {
1320 vnet_feature_arc_start (arc_index,
1321 vnet_buffer (b)->sw_if_index[VLIB_RX],
1322 &next_index, b);
1323 *next = next_index;
1324 }
1325 }
1326}
1327
1328typedef struct
1329{
1330 ip4_address_t src;
1331 u32 lbi;
1332 u8 error;
1333} ip4_local_last_check_t;
1334
1335static inline void
1336ip4_local_check_src (vlib_buffer_t * b, ip4_header_t * ip0,
1337 ip4_local_last_check_t * last_check, u8 * error0)
1338{
1339 ip4_fib_mtrie_leaf_t leaf0;
1340 ip4_fib_mtrie_t *mtrie0;
1341 const dpo_id_t *dpo0;
1342 load_balance_t *lb0;
1343 u32 lbi0;
1344
1345 vnet_buffer (b)->ip.fib_index =
1346 vnet_buffer (b)->sw_if_index[VLIB_TX] != ~0 ?
1347 vnet_buffer (b)->sw_if_index[VLIB_TX] : vnet_buffer (b)->ip.fib_index;
1348
1349 if (PREDICT_FALSE (last_check->src.as_u32 != ip0->src_address.as_u32))
1350 {
1351 mtrie0 = &ip4_fib_get (vnet_buffer (b)->ip.fib_index)->mtrie;
1352 leaf0 = ip4_fib_mtrie_lookup_step_one (mtrie0, &ip0->src_address);
1353 leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, &ip0->src_address, 2);
1354 leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, &ip0->src_address, 3);
1355 lbi0 = ip4_fib_mtrie_leaf_get_adj_index (leaf0);
1356
1357 vnet_buffer (b)->ip.adj_index[VLIB_TX] = lbi0;
1358 vnet_buffer (b)->ip.adj_index[VLIB_RX] = lbi0;
1359
1360 lb0 = load_balance_get (lbi0);
1361 dpo0 = load_balance_get_bucket_i (lb0, 0);
1362
1363 /*
1364 * Must have a route to source otherwise we drop the packet.
1365 * ip4 broadcasts are accepted, e.g. to make dhcp client work
1366 *
1367 * The checks are:
1368 * - the source is a recieve => it's from us => bogus, do this
1369 * first since it sets a different error code.
1370 * - uRPF check for any route to source - accept if passes.
1371 * - allow packets destined to the broadcast address from unknown sources
1372 */
1373
1374 *error0 = ((*error0 == IP4_ERROR_UNKNOWN_PROTOCOL
1375 && dpo0->dpoi_type == DPO_RECEIVE) ?
1376 IP4_ERROR_SPOOFED_LOCAL_PACKETS : *error0);
1377 *error0 = ((*error0 == IP4_ERROR_UNKNOWN_PROTOCOL
1378 && !fib_urpf_check_size (lb0->lb_urpf)
1379 && ip0->dst_address.as_u32 != 0xFFFFFFFF) ?
1380 IP4_ERROR_SRC_LOOKUP_MISS : *error0);
1381
1382 last_check->src.as_u32 = ip0->src_address.as_u32;
1383 last_check->lbi = lbi0;
1384 last_check->error = *error0;
1385 }
1386 else
1387 {
1388 vnet_buffer (b)->ip.adj_index[VLIB_TX] = last_check->lbi;
1389 vnet_buffer (b)->ip.adj_index[VLIB_RX] = last_check->lbi;
1390 *error0 = last_check->error;
1391 }
1392}
1393
1394static inline void
1395ip4_local_check_src_x2 (vlib_buffer_t ** b, ip4_header_t ** ip,
1396 ip4_local_last_check_t * last_check, u8 * error)
1397{
1398 ip4_fib_mtrie_leaf_t leaf[2];
1399 ip4_fib_mtrie_t *mtrie[2];
1400 const dpo_id_t *dpo[2];
1401 load_balance_t *lb[2];
1402 u32 not_last_hit = 0;
1403 u32 lbi[2];
1404
1405 not_last_hit |= ip[0]->src_address.as_u32 ^ last_check->src.as_u32;
1406 not_last_hit |= ip[1]->src_address.as_u32 ^ last_check->src.as_u32;
1407
1408 vnet_buffer (b[0])->ip.fib_index =
1409 vnet_buffer (b[0])->sw_if_index[VLIB_TX] != ~0 ?
1410 vnet_buffer (b[0])->sw_if_index[VLIB_TX] :
1411 vnet_buffer (b[0])->ip.fib_index;
1412
1413 vnet_buffer (b[1])->ip.fib_index =
1414 vnet_buffer (b[1])->sw_if_index[VLIB_TX] != ~0 ?
1415 vnet_buffer (b[1])->sw_if_index[VLIB_TX] :
1416 vnet_buffer (b[1])->ip.fib_index;
1417
1418 if (PREDICT_FALSE (not_last_hit))
1419 {
1420 mtrie[0] = &ip4_fib_get (vnet_buffer (b[0])->ip.fib_index)->mtrie;
1421 mtrie[1] = &ip4_fib_get (vnet_buffer (b[1])->ip.fib_index)->mtrie;
1422
1423 leaf[0] = ip4_fib_mtrie_lookup_step_one (mtrie[0], &ip[0]->src_address);
1424 leaf[1] = ip4_fib_mtrie_lookup_step_one (mtrie[1], &ip[1]->src_address);
1425
1426 leaf[0] = ip4_fib_mtrie_lookup_step (mtrie[0], leaf[0],
1427 &ip[0]->src_address, 2);
1428 leaf[1] = ip4_fib_mtrie_lookup_step (mtrie[1], leaf[1],
1429 &ip[1]->src_address, 2);
1430
1431 leaf[0] = ip4_fib_mtrie_lookup_step (mtrie[0], leaf[0],
1432 &ip[0]->src_address, 3);
1433 leaf[1] = ip4_fib_mtrie_lookup_step (mtrie[1], leaf[1],
1434 &ip[1]->src_address, 3);
1435
1436 lbi[0] = ip4_fib_mtrie_leaf_get_adj_index (leaf[0]);
1437 lbi[1] = ip4_fib_mtrie_leaf_get_adj_index (leaf[1]);
1438
1439 vnet_buffer (b[0])->ip.adj_index[VLIB_TX] = lbi[0];
1440 vnet_buffer (b[0])->ip.adj_index[VLIB_RX] = lbi[0];
1441
1442 vnet_buffer (b[1])->ip.adj_index[VLIB_TX] = lbi[1];
1443 vnet_buffer (b[1])->ip.adj_index[VLIB_RX] = lbi[1];
1444
1445 lb[0] = load_balance_get (lbi[0]);
1446 lb[1] = load_balance_get (lbi[1]);
1447
1448 dpo[0] = load_balance_get_bucket_i (lb[0], 0);
1449 dpo[1] = load_balance_get_bucket_i (lb[1], 0);
1450
1451 error[0] = ((error[0] == IP4_ERROR_UNKNOWN_PROTOCOL &&
1452 dpo[0]->dpoi_type == DPO_RECEIVE) ?
1453 IP4_ERROR_SPOOFED_LOCAL_PACKETS : error[0]);
1454 error[0] = ((error[0] == IP4_ERROR_UNKNOWN_PROTOCOL &&
1455 !fib_urpf_check_size (lb[0]->lb_urpf) &&
1456 ip[0]->dst_address.as_u32 != 0xFFFFFFFF)
1457 ? IP4_ERROR_SRC_LOOKUP_MISS : error[0]);
1458
1459 error[1] = ((error[1] == IP4_ERROR_UNKNOWN_PROTOCOL &&
1460 dpo[1]->dpoi_type == DPO_RECEIVE) ?
1461 IP4_ERROR_SPOOFED_LOCAL_PACKETS : error[1]);
1462 error[1] = ((error[1] == IP4_ERROR_UNKNOWN_PROTOCOL &&
1463 !fib_urpf_check_size (lb[1]->lb_urpf) &&
1464 ip[1]->dst_address.as_u32 != 0xFFFFFFFF)
1465 ? IP4_ERROR_SRC_LOOKUP_MISS : error[1]);
1466
1467 last_check->src.as_u32 = ip[1]->src_address.as_u32;
1468 last_check->lbi = lbi[1];
1469 last_check->error = error[1];
1470 }
1471 else
1472 {
1473 vnet_buffer (b[0])->ip.adj_index[VLIB_TX] = last_check->lbi;
1474 vnet_buffer (b[0])->ip.adj_index[VLIB_RX] = last_check->lbi;
1475
1476 vnet_buffer (b[1])->ip.adj_index[VLIB_TX] = last_check->lbi;
1477 vnet_buffer (b[1])->ip.adj_index[VLIB_RX] = last_check->lbi;
1478
1479 error[0] = last_check->error;
1480 error[1] = last_check->error;
1481 }
1482}
Florin Coras20a14b92017-08-15 22:47:22 -07001483
Dave Barach68b0fb02017-02-28 15:15:56 -05001484static inline uword
1485ip4_local_inline (vlib_main_t * vm,
1486 vlib_node_runtime_t * node,
1487 vlib_frame_t * frame, int head_of_feature_arc)
Ed Warnickecb9cada2015-12-08 15:45:58 -07001488{
Dave Barachd7cb1b52016-12-09 09:52:16 -05001489 ip4_main_t *im = &ip4_main;
1490 ip_lookup_main_t *lm = &im->lookup_main;
Florin Coras1b255522018-06-01 12:22:23 -07001491 u32 *from, n_left_from;
Dave Barachd7cb1b52016-12-09 09:52:16 -05001492 vlib_node_runtime_t *error_node =
1493 vlib_node_get_runtime (vm, ip4_input_node.index);
Florin Coras1b255522018-06-01 12:22:23 -07001494 u16 nexts[VLIB_FRAME_SIZE], *next;
1495 vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b;
1496 ip4_header_t *ip[2];
1497 u8 error[2];
1498
1499 ip4_local_last_check_t last_check = {
1500 .src = {.as_u32 = 0},
1501 .lbi = ~0,
1502 .error = IP4_ERROR_UNKNOWN_PROTOCOL
1503 };
Ed Warnickecb9cada2015-12-08 15:45:58 -07001504
1505 from = vlib_frame_vector_args (frame);
1506 n_left_from = frame->n_vectors;
Dave Barach75fc8542016-10-11 16:16:02 -04001507
Ed Warnickecb9cada2015-12-08 15:45:58 -07001508 if (node->flags & VLIB_NODE_FLAG_TRACE)
1509 ip4_forward_next_trace (vm, node, frame, VLIB_TX);
1510
Florin Coras1b255522018-06-01 12:22:23 -07001511 vlib_get_buffers (vm, from, bufs, n_left_from);
1512 b = bufs;
1513 next = nexts;
1514
1515 while (n_left_from >= 6)
Ed Warnickecb9cada2015-12-08 15:45:58 -07001516 {
Florin Coras1b255522018-06-01 12:22:23 -07001517 u32 is_nat, not_batch = 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001518
Florin Coras1b255522018-06-01 12:22:23 -07001519 /* Prefetch next iteration. */
1520 {
1521 vlib_prefetch_buffer_header (b[4], LOAD);
1522 vlib_prefetch_buffer_header (b[5], LOAD);
1523
1524 CLIB_PREFETCH (b[4]->data, CLIB_CACHE_LINE_BYTES, LOAD);
1525 CLIB_PREFETCH (b[5]->data, CLIB_CACHE_LINE_BYTES, LOAD);
1526 }
1527
1528 error[0] = error[1] = IP4_ERROR_UNKNOWN_PROTOCOL;
1529
1530 ip[0] = vlib_buffer_get_current (b[0]);
1531 ip[1] = vlib_buffer_get_current (b[1]);
1532
1533 vnet_buffer (b[0])->l3_hdr_offset = b[0]->current_data;
1534 vnet_buffer (b[1])->l3_hdr_offset = b[1]->current_data;
1535
1536 is_nat = b[0]->flags & VNET_BUFFER_F_IS_NATED;
1537 not_batch |= is_nat ^ (b[1]->flags & VNET_BUFFER_F_IS_NATED);
1538
1539 if (head_of_feature_arc == 0 || (is_nat && not_batch == 0))
1540 goto skip_checks;
1541
1542 if (PREDICT_TRUE (not_batch == 0))
Dave Barachd7cb1b52016-12-09 09:52:16 -05001543 {
Florin Coras1b255522018-06-01 12:22:23 -07001544 ip4_local_check_l4_csum_x2 (vm, b, ip, error);
1545 ip4_local_check_src_x2 (b, ip, &last_check, error);
1546 }
1547 else
1548 {
1549 if (!(b[0]->flags & VNET_BUFFER_F_IS_NATED))
Florin Coras20a14b92017-08-15 22:47:22 -07001550 {
Florin Coras1b255522018-06-01 12:22:23 -07001551 ip4_local_check_l4_csum (vm, b[0], ip[0], &error[0]);
1552 ip4_local_check_src (b[0], ip[0], &last_check, &error[0]);
Florin Coras20a14b92017-08-15 22:47:22 -07001553 }
Florin Coras1b255522018-06-01 12:22:23 -07001554 if (!(b[1]->flags & VNET_BUFFER_F_IS_NATED))
Ed Warnickecb9cada2015-12-08 15:45:58 -07001555 {
Florin Coras1b255522018-06-01 12:22:23 -07001556 ip4_local_check_l4_csum (vm, b[1], ip[1], &error[1]);
1557 ip4_local_check_src (b[1], ip[1], &last_check, &error[1]);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001558 }
1559 }
1560
Florin Coras1b255522018-06-01 12:22:23 -07001561 skip_checks:
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001562
Florin Coras1b255522018-06-01 12:22:23 -07001563 next[0] = lm->local_next_by_ip_protocol[ip[0]->protocol];
1564 next[1] = lm->local_next_by_ip_protocol[ip[1]->protocol];
1565 ip4_local_set_next_and_error (error_node, b[0], &next[0], error[0],
1566 head_of_feature_arc);
1567 ip4_local_set_next_and_error (error_node, b[1], &next[1], error[1],
1568 head_of_feature_arc);
Dave Barach75fc8542016-10-11 16:16:02 -04001569
Florin Coras1b255522018-06-01 12:22:23 -07001570 b += 2;
1571 next += 2;
1572 n_left_from -= 2;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001573 }
1574
Florin Coras1b255522018-06-01 12:22:23 -07001575 while (n_left_from > 0)
1576 {
1577 error[0] = IP4_ERROR_UNKNOWN_PROTOCOL;
1578
1579 ip[0] = vlib_buffer_get_current (b[0]);
1580 vnet_buffer (b[0])->l3_hdr_offset = b[0]->current_data;
1581
1582 if (head_of_feature_arc == 0 || (b[0]->flags & VNET_BUFFER_F_IS_NATED))
1583 goto skip_check;
1584
1585 ip4_local_check_l4_csum (vm, b[0], ip[0], &error[0]);
1586 ip4_local_check_src (b[0], ip[0], &last_check, &error[0]);
1587
1588 skip_check:
1589
1590 next[0] = lm->local_next_by_ip_protocol[ip[0]->protocol];
1591 ip4_local_set_next_and_error (error_node, b[0], &next[0], error[0],
1592 head_of_feature_arc);
1593
1594 b += 1;
1595 next += 1;
1596 n_left_from -= 1;
1597 }
1598
1599 vlib_buffer_enqueue_to_next (vm, node, from, nexts, frame->n_vectors);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001600 return frame->n_vectors;
1601}
1602
Damjan Marionc9dad5d2018-08-11 22:10:29 +02001603VLIB_NODE_FN (ip4_local_node) (vlib_main_t * vm, vlib_node_runtime_t * node,
1604 vlib_frame_t * frame)
Dave Barach68b0fb02017-02-28 15:15:56 -05001605{
1606 return ip4_local_inline (vm, node, frame, 1 /* head of feature arc */ );
1607}
1608
1609/* *INDENT-OFF* */
Neale Ranns32e1c012016-11-22 17:07:28 +00001610VLIB_REGISTER_NODE (ip4_local_node) =
Ed Warnickecb9cada2015-12-08 15:45:58 -07001611{
Dave Barach68b0fb02017-02-28 15:15:56 -05001612 .name = "ip4-local",
1613 .vector_size = sizeof (u32),
1614 .format_trace = format_ip4_forward_next_trace,
1615 .n_next_nodes = IP_LOCAL_N_NEXT,
1616 .next_nodes =
Dave Barachd7cb1b52016-12-09 09:52:16 -05001617 {
Neale Rannsd91c1db2017-07-31 02:30:50 -07001618 [IP_LOCAL_NEXT_DROP] = "ip4-drop",
1619 [IP_LOCAL_NEXT_PUNT] = "ip4-punt",
Dave Barach68b0fb02017-02-28 15:15:56 -05001620 [IP_LOCAL_NEXT_UDP_LOOKUP] = "ip4-udp-lookup",
Florin Coras20a14b92017-08-15 22:47:22 -07001621 [IP_LOCAL_NEXT_ICMP] = "ip4-icmp-input",
1622 },
Dave Barach68b0fb02017-02-28 15:15:56 -05001623};
1624/* *INDENT-ON* */
Dave Barachd7cb1b52016-12-09 09:52:16 -05001625
Dave Barachd7cb1b52016-12-09 09:52:16 -05001626
Damjan Marionc9dad5d2018-08-11 22:10:29 +02001627VLIB_NODE_FN (ip4_local_end_of_arc_node) (vlib_main_t * vm,
1628 vlib_node_runtime_t * node,
1629 vlib_frame_t * frame)
Dave Barach68b0fb02017-02-28 15:15:56 -05001630{
1631 return ip4_local_inline (vm, node, frame, 0 /* head of feature arc */ );
1632}
1633
1634/* *INDENT-OFF* */
Damjan Marionc9dad5d2018-08-11 22:10:29 +02001635VLIB_REGISTER_NODE (ip4_local_end_of_arc_node) = {
Dave Barach68b0fb02017-02-28 15:15:56 -05001636 .name = "ip4-local-end-of-arc",
1637 .vector_size = sizeof (u32),
1638
1639 .format_trace = format_ip4_forward_next_trace,
1640 .sibling_of = "ip4-local",
1641};
1642
Dave Barach68b0fb02017-02-28 15:15:56 -05001643VNET_FEATURE_INIT (ip4_local_end_of_arc, static) = {
1644 .arc_name = "ip4-local",
1645 .node_name = "ip4-local-end-of-arc",
1646 .runs_before = 0, /* not before any other features */
1647};
1648/* *INDENT-ON* */
1649
Damjan Marionc9dad5d2018-08-11 22:10:29 +02001650#ifndef CLIB_MARCH_VARIANT
Dave Barachd7cb1b52016-12-09 09:52:16 -05001651void
1652ip4_register_protocol (u32 protocol, u32 node_index)
1653{
1654 vlib_main_t *vm = vlib_get_main ();
1655 ip4_main_t *im = &ip4_main;
1656 ip_lookup_main_t *lm = &im->lookup_main;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001657
1658 ASSERT (protocol < ARRAY_LEN (lm->local_next_by_ip_protocol));
Dave Barachd7cb1b52016-12-09 09:52:16 -05001659 lm->local_next_by_ip_protocol[protocol] =
1660 vlib_node_add_next (vm, ip4_local_node.index, node_index);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001661}
Damjan Marionc9dad5d2018-08-11 22:10:29 +02001662#endif
Ed Warnickecb9cada2015-12-08 15:45:58 -07001663
1664static clib_error_t *
1665show_ip_local_command_fn (vlib_main_t * vm,
Dave Barachd7cb1b52016-12-09 09:52:16 -05001666 unformat_input_t * input, vlib_cli_command_t * cmd)
Ed Warnickecb9cada2015-12-08 15:45:58 -07001667{
Dave Barachd7cb1b52016-12-09 09:52:16 -05001668 ip4_main_t *im = &ip4_main;
1669 ip_lookup_main_t *lm = &im->lookup_main;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001670 int i;
1671
1672 vlib_cli_output (vm, "Protocols handled by ip4_local");
Dave Barachd7cb1b52016-12-09 09:52:16 -05001673 for (i = 0; i < ARRAY_LEN (lm->local_next_by_ip_protocol); i++)
Ed Warnickecb9cada2015-12-08 15:45:58 -07001674 {
1675 if (lm->local_next_by_ip_protocol[i] != IP_LOCAL_NEXT_PUNT)
Pierre Pfister1bfd3722017-09-18 11:40:32 +02001676 {
1677 u32 node_index = vlib_get_node (vm,
1678 ip4_local_node.index)->
1679 next_nodes[lm->local_next_by_ip_protocol[i]];
1680 vlib_cli_output (vm, "%d: %U", i, format_vlib_node_name, vm,
1681 node_index);
1682 }
Ed Warnickecb9cada2015-12-08 15:45:58 -07001683 }
1684 return 0;
1685}
1686
1687
1688
Billy McFall0683c9c2016-10-13 08:27:31 -04001689/*?
1690 * Display the set of protocols handled by the local IPv4 stack.
1691 *
1692 * @cliexpar
1693 * Example of how to display local protocol table:
1694 * @cliexstart{show ip local}
1695 * Protocols handled by ip4_local
1696 * 1
1697 * 17
1698 * 47
1699 * @cliexend
1700?*/
1701/* *INDENT-OFF* */
Dave Barachd7cb1b52016-12-09 09:52:16 -05001702VLIB_CLI_COMMAND (show_ip_local, static) =
1703{
Ed Warnickecb9cada2015-12-08 15:45:58 -07001704 .path = "show ip local",
1705 .function = show_ip_local_command_fn,
Billy McFall0683c9c2016-10-13 08:27:31 -04001706 .short_help = "show ip local",
Ed Warnickecb9cada2015-12-08 15:45:58 -07001707};
Billy McFall0683c9c2016-10-13 08:27:31 -04001708/* *INDENT-ON* */
Ed Warnickecb9cada2015-12-08 15:45:58 -07001709
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001710always_inline uword
1711ip4_arp_inline (vlib_main_t * vm,
1712 vlib_node_runtime_t * node,
Dave Barachd7cb1b52016-12-09 09:52:16 -05001713 vlib_frame_t * frame, int is_glean)
Ed Warnickecb9cada2015-12-08 15:45:58 -07001714{
Dave Barachd7cb1b52016-12-09 09:52:16 -05001715 vnet_main_t *vnm = vnet_get_main ();
1716 ip4_main_t *im = &ip4_main;
1717 ip_lookup_main_t *lm = &im->lookup_main;
1718 u32 *from, *to_next_drop;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001719 uword n_left_from, n_left_to_next_drop, next_index;
Dave Barach49433ad2018-08-08 17:59:03 -04001720 u32 thread_index = vm->thread_index;
1721 u32 seed;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001722
1723 if (node->flags & VLIB_NODE_FLAG_TRACE)
1724 ip4_forward_next_trace (vm, node, frame, VLIB_TX);
1725
Neale Rannsc8352bc2018-08-29 10:23:58 -07001726 seed = throttle_seed (&im->arp_throttle, thread_index, vlib_time_now (vm));
Ed Warnickecb9cada2015-12-08 15:45:58 -07001727
1728 from = vlib_frame_vector_args (frame);
1729 n_left_from = frame->n_vectors;
1730 next_index = node->cached_next_index;
1731 if (next_index == IP4_ARP_NEXT_DROP)
Dave Barachd7cb1b52016-12-09 09:52:16 -05001732 next_index = IP4_ARP_N_NEXT; /* point to first interface */
Ed Warnickecb9cada2015-12-08 15:45:58 -07001733
1734 while (n_left_from > 0)
1735 {
1736 vlib_get_next_frame (vm, node, IP4_ARP_NEXT_DROP,
1737 to_next_drop, n_left_to_next_drop);
1738
1739 while (n_left_from > 0 && n_left_to_next_drop > 0)
1740 {
Neale Rannsc8352bc2018-08-29 10:23:58 -07001741 u32 pi0, adj_index0, r0, sw_if_index0, drop0;
Dave Barachd7cb1b52016-12-09 09:52:16 -05001742 ip_adjacency_t *adj0;
1743 vlib_buffer_t *p0;
1744 ip4_header_t *ip0;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001745
1746 pi0 = from[0];
1747
1748 p0 = vlib_get_buffer (vm, pi0);
1749
1750 adj_index0 = vnet_buffer (p0)->ip.adj_index[VLIB_TX];
Neale Ranns107e7d42017-04-11 09:55:19 -07001751 adj0 = adj_get (adj_index0);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001752 ip0 = vlib_buffer_get_current (p0);
1753
Ed Warnickecb9cada2015-12-08 15:45:58 -07001754 sw_if_index0 = adj0->rewrite_header.sw_if_index;
1755 vnet_buffer (p0)->sw_if_index[VLIB_TX] = sw_if_index0;
1756
Dave Barach49433ad2018-08-08 17:59:03 -04001757 if (PREDICT_TRUE (is_glean))
Dave Barachd7cb1b52016-12-09 09:52:16 -05001758 {
Neale Ranns948e00f2016-10-20 13:39:34 +01001759 /*
1760 * this is the Glean case, so we are ARPing for the
1761 * packet's destination
1762 */
Dave Barach49433ad2018-08-08 17:59:03 -04001763 r0 = ip0->dst_address.data_u32;
Dave Barachd7cb1b52016-12-09 09:52:16 -05001764 }
1765 else
1766 {
Dave Barach49433ad2018-08-08 17:59:03 -04001767 r0 = adj0->sub_type.nbr.next_hop.ip4.data_u32;
Dave Barachd7cb1b52016-12-09 09:52:16 -05001768 }
Ed Warnickecb9cada2015-12-08 15:45:58 -07001769
Neale Rannsc8352bc2018-08-29 10:23:58 -07001770 drop0 = throttle_check (&im->arp_throttle, thread_index, r0, seed);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001771
1772 from += 1;
1773 n_left_from -= 1;
1774 to_next_drop[0] = pi0;
1775 to_next_drop += 1;
1776 n_left_to_next_drop -= 1;
1777
Dave Barachd7cb1b52016-12-09 09:52:16 -05001778 p0->error =
1779 node->errors[drop0 ? IP4_ARP_ERROR_DROP :
1780 IP4_ARP_ERROR_REQUEST_SENT];
Ed Warnickecb9cada2015-12-08 15:45:58 -07001781
Neale Rannsb80c5362016-10-08 13:03:40 +01001782 /*
1783 * the adj has been updated to a rewrite but the node the DPO that got
1784 * us here hasn't - yet. no big deal. we'll drop while we wait.
1785 */
1786 if (IP_LOOKUP_NEXT_REWRITE == adj0->lookup_next_index)
1787 continue;
1788
Ed Warnickecb9cada2015-12-08 15:45:58 -07001789 if (drop0)
1790 continue;
1791
Dave Barachd7cb1b52016-12-09 09:52:16 -05001792 /*
1793 * Can happen if the control-plane is programming tables
1794 * with traffic flowing; at least that's today's lame excuse.
1795 */
Neale Ranns32e1c012016-11-22 17:07:28 +00001796 if ((is_glean && adj0->lookup_next_index != IP_LOOKUP_NEXT_GLEAN)
1797 || (!is_glean && adj0->lookup_next_index != IP_LOOKUP_NEXT_ARP))
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001798 {
Dave Barachd7cb1b52016-12-09 09:52:16 -05001799 p0->error = node->errors[IP4_ARP_ERROR_NON_ARP_ADJ];
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001800 }
Dave Barachd7cb1b52016-12-09 09:52:16 -05001801 else
1802 /* Send ARP request. */
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001803 {
Dave Barachd7cb1b52016-12-09 09:52:16 -05001804 u32 bi0 = 0;
1805 vlib_buffer_t *b0;
1806 ethernet_arp_header_t *h0;
1807 vnet_hw_interface_t *hw_if0;
1808
1809 h0 =
1810 vlib_packet_template_get_packet (vm,
1811 &im->ip4_arp_request_packet_template,
1812 &bi0);
1813
Florin Corasd172a622017-10-14 11:02:37 -07001814 /* Seems we're out of buffers */
1815 if (PREDICT_FALSE (!h0))
1816 continue;
1817
Dave Barachd7cb1b52016-12-09 09:52:16 -05001818 /* Add rewrite/encap string for ARP packet. */
1819 vnet_rewrite_one_header (adj0[0], h0,
1820 sizeof (ethernet_header_t));
1821
1822 hw_if0 = vnet_get_sup_hw_interface (vnm, sw_if_index0);
1823
1824 /* Src ethernet address in ARP header. */
1825 clib_memcpy (h0->ip4_over_ethernet[0].ethernet,
1826 hw_if0->hw_address,
1827 sizeof (h0->ip4_over_ethernet[0].ethernet));
1828
1829 if (is_glean)
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001830 {
Dave Barachd7cb1b52016-12-09 09:52:16 -05001831 /* The interface's source address is stashed in the Glean Adj */
1832 h0->ip4_over_ethernet[0].ip4 =
1833 adj0->sub_type.glean.receive_addr.ip4;
1834
1835 /* Copy in destination address we are requesting. This is the
1836 * glean case, so it's the packet's destination.*/
1837 h0->ip4_over_ethernet[1].ip4.data_u32 =
1838 ip0->dst_address.data_u32;
1839 }
1840 else
1841 {
1842 /* Src IP address in ARP header. */
1843 if (ip4_src_address_for_packet (lm, sw_if_index0,
1844 &h0->
1845 ip4_over_ethernet[0].ip4))
1846 {
1847 /* No source address available */
1848 p0->error =
1849 node->errors[IP4_ARP_ERROR_NO_SOURCE_ADDRESS];
1850 vlib_buffer_free (vm, &bi0, 1);
1851 continue;
1852 }
1853
1854 /* Copy in destination address we are requesting from the
1855 incomplete adj */
1856 h0->ip4_over_ethernet[1].ip4.data_u32 =
1857 adj0->sub_type.nbr.next_hop.ip4.as_u32;
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001858 }
1859
Dave Barachd7cb1b52016-12-09 09:52:16 -05001860 vlib_buffer_copy_trace_flag (vm, p0, bi0);
1861 b0 = vlib_get_buffer (vm, bi0);
Florin Coras2f9b0c02017-09-11 20:54:15 -04001862 VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b0);
Dave Barachd7cb1b52016-12-09 09:52:16 -05001863 vnet_buffer (b0)->sw_if_index[VLIB_TX] = sw_if_index0;
1864
1865 vlib_buffer_advance (b0, -adj0->rewrite_header.data_bytes);
1866
1867 vlib_set_next_frame_buffer (vm, node,
1868 adj0->rewrite_header.next_index,
1869 bi0);
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001870 }
Ed Warnickecb9cada2015-12-08 15:45:58 -07001871 }
1872
1873 vlib_put_next_frame (vm, node, IP4_ARP_NEXT_DROP, n_left_to_next_drop);
1874 }
1875
1876 return frame->n_vectors;
1877}
1878
Damjan Marionc9dad5d2018-08-11 22:10:29 +02001879VLIB_NODE_FN (ip4_arp_node) (vlib_main_t * vm, vlib_node_runtime_t * node,
1880 vlib_frame_t * frame)
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001881{
Dave Barachd7cb1b52016-12-09 09:52:16 -05001882 return (ip4_arp_inline (vm, node, frame, 0));
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001883}
1884
Damjan Marionc9dad5d2018-08-11 22:10:29 +02001885VLIB_NODE_FN (ip4_glean_node) (vlib_main_t * vm, vlib_node_runtime_t * node,
1886 vlib_frame_t * frame)
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001887{
Dave Barachd7cb1b52016-12-09 09:52:16 -05001888 return (ip4_arp_inline (vm, node, frame, 1));
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001889}
1890
Dave Barachd7cb1b52016-12-09 09:52:16 -05001891static char *ip4_arp_error_strings[] = {
Ed Warnickecb9cada2015-12-08 15:45:58 -07001892 [IP4_ARP_ERROR_DROP] = "address overflow drops",
1893 [IP4_ARP_ERROR_REQUEST_SENT] = "ARP requests sent",
1894 [IP4_ARP_ERROR_NON_ARP_ADJ] = "ARPs to non-ARP adjacencies",
1895 [IP4_ARP_ERROR_REPLICATE_DROP] = "ARP replication completed",
1896 [IP4_ARP_ERROR_REPLICATE_FAIL] = "ARP replication failed",
Pierre Pfisterd076f192016-06-22 12:58:30 +01001897 [IP4_ARP_ERROR_NO_SOURCE_ADDRESS] = "no source address for ARP request",
Ed Warnickecb9cada2015-12-08 15:45:58 -07001898};
1899
Neale Rannsf8686322017-11-29 02:39:53 -08001900/* *INDENT-OFF* */
Dave Barachd7cb1b52016-12-09 09:52:16 -05001901VLIB_REGISTER_NODE (ip4_arp_node) =
1902{
Neale Rannsf8686322017-11-29 02:39:53 -08001903 .name = "ip4-arp",
1904 .vector_size = sizeof (u32),
1905 .format_trace = format_ip4_forward_next_trace,
1906 .n_errors = ARRAY_LEN (ip4_arp_error_strings),
1907 .error_strings = ip4_arp_error_strings,
1908 .n_next_nodes = IP4_ARP_N_NEXT,
1909 .next_nodes =
Dave Barachd7cb1b52016-12-09 09:52:16 -05001910 {
Neale Rannsf8686322017-11-29 02:39:53 -08001911 [IP4_ARP_NEXT_DROP] = "error-drop",
1912 },
1913};
Ed Warnickecb9cada2015-12-08 15:45:58 -07001914
Dave Barachd7cb1b52016-12-09 09:52:16 -05001915VLIB_REGISTER_NODE (ip4_glean_node) =
1916{
Neale Rannsf8686322017-11-29 02:39:53 -08001917 .name = "ip4-glean",
1918 .vector_size = sizeof (u32),
1919 .format_trace = format_ip4_forward_next_trace,
1920 .n_errors = ARRAY_LEN (ip4_arp_error_strings),
1921 .error_strings = ip4_arp_error_strings,
1922 .n_next_nodes = IP4_ARP_N_NEXT,
1923 .next_nodes = {
1924 [IP4_ARP_NEXT_DROP] = "error-drop",
1925 },
1926};
1927/* *INDENT-ON* */
Neale Ranns0bfe5d82016-08-25 15:29:12 +01001928
Ed Warnickecb9cada2015-12-08 15:45:58 -07001929#define foreach_notrace_ip4_arp_error \
1930_(DROP) \
1931_(REQUEST_SENT) \
1932_(REPLICATE_DROP) \
1933_(REPLICATE_FAIL)
1934
Damjan Marionc9dad5d2018-08-11 22:10:29 +02001935static clib_error_t *
Dave Barachd7cb1b52016-12-09 09:52:16 -05001936arp_notrace_init (vlib_main_t * vm)
Ed Warnickecb9cada2015-12-08 15:45:58 -07001937{
Dave Barachd7cb1b52016-12-09 09:52:16 -05001938 vlib_node_runtime_t *rt = vlib_node_get_runtime (vm, ip4_arp_node.index);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001939
1940 /* don't trace ARP request packets */
1941#define _(a) \
1942 vnet_pcap_drop_trace_filter_add_del \
1943 (rt->errors[IP4_ARP_ERROR_##a], \
1944 1 /* is_add */);
Dave Barachd7cb1b52016-12-09 09:52:16 -05001945 foreach_notrace_ip4_arp_error;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001946#undef _
1947 return 0;
1948}
1949
Dave Barachd7cb1b52016-12-09 09:52:16 -05001950VLIB_INIT_FUNCTION (arp_notrace_init);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001951
1952
Damjan Marionc9dad5d2018-08-11 22:10:29 +02001953#ifndef CLIB_MARCH_VARIANT
Ed Warnickecb9cada2015-12-08 15:45:58 -07001954/* Send an ARP request to see if given destination is reachable on given interface. */
1955clib_error_t *
John Lo86376342018-06-11 20:14:49 -04001956ip4_probe_neighbor (vlib_main_t * vm, ip4_address_t * dst, u32 sw_if_index,
1957 u8 refresh)
Ed Warnickecb9cada2015-12-08 15:45:58 -07001958{
Dave Barachd7cb1b52016-12-09 09:52:16 -05001959 vnet_main_t *vnm = vnet_get_main ();
1960 ip4_main_t *im = &ip4_main;
1961 ethernet_arp_header_t *h;
1962 ip4_address_t *src;
1963 ip_interface_address_t *ia;
1964 ip_adjacency_t *adj;
1965 vnet_hw_interface_t *hi;
1966 vnet_sw_interface_t *si;
1967 vlib_buffer_t *b;
Neale Ranns7a272742017-05-30 02:08:14 -07001968 adj_index_t ai;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001969 u32 bi = 0;
John Lo86376342018-06-11 20:14:49 -04001970 u8 unicast_rewrite = 0;
Ed Warnickecb9cada2015-12-08 15:45:58 -07001971
1972 si = vnet_get_sw_interface (vnm, sw_if_index);
1973
1974 if (!(si->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP))
1975 {
1976 return clib_error_return (0, "%U: interface %U down",
Dave Barachd7cb1b52016-12-09 09:52:16 -05001977 format_ip4_address, dst,
1978 format_vnet_sw_if_index_name, vnm,
1979 sw_if_index);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001980 }
1981
Dave Barachd7cb1b52016-12-09 09:52:16 -05001982 src =
1983 ip4_interface_address_matching_destination (im, dst, sw_if_index, &ia);
1984 if (!src)
Ed Warnickecb9cada2015-12-08 15:45:58 -07001985 {
1986 vnm->api_errno = VNET_API_ERROR_NO_MATCHING_INTERFACE;
Dave Barach75fc8542016-10-11 16:16:02 -04001987 return clib_error_return
Neale Ranns32e1c012016-11-22 17:07:28 +00001988 (0,
1989 "no matching interface address for destination %U (interface %U)",
1990 format_ip4_address, dst, format_vnet_sw_if_index_name, vnm,
1991 sw_if_index);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001992 }
1993
Neale Ranns7a272742017-05-30 02:08:14 -07001994 h = vlib_packet_template_get_packet (vm,
1995 &im->ip4_arp_request_packet_template,
1996 &bi);
Ed Warnickecb9cada2015-12-08 15:45:58 -07001997
John Lo084606b2018-06-19 15:27:48 -04001998 if (!h)
1999 return clib_error_return (0, "ARP request packet allocation failed");
2000
Ed Warnickecb9cada2015-12-08 15:45:58 -07002001 hi = vnet_get_sup_hw_interface (vnm, sw_if_index);
Pavel Kotucek57808982017-08-02 08:20:19 +02002002 if (PREDICT_FALSE (!hi->hw_address))
2003 {
2004 return clib_error_return (0, "%U: interface %U do not support ip probe",
2005 format_ip4_address, dst,
2006 format_vnet_sw_if_index_name, vnm,
2007 sw_if_index);
2008 }
Ed Warnickecb9cada2015-12-08 15:45:58 -07002009
Dave Barachd7cb1b52016-12-09 09:52:16 -05002010 clib_memcpy (h->ip4_over_ethernet[0].ethernet, hi->hw_address,
2011 sizeof (h->ip4_over_ethernet[0].ethernet));
Ed Warnickecb9cada2015-12-08 15:45:58 -07002012
2013 h->ip4_over_ethernet[0].ip4 = src[0];
2014 h->ip4_over_ethernet[1].ip4 = dst[0];
2015
2016 b = vlib_get_buffer (vm, bi);
Dave Barachd7cb1b52016-12-09 09:52:16 -05002017 vnet_buffer (b)->sw_if_index[VLIB_RX] =
2018 vnet_buffer (b)->sw_if_index[VLIB_TX] = sw_if_index;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002019
Dave Barach59b25652017-09-10 15:04:27 -04002020 ip46_address_t nh = {
2021 .ip4 = *dst,
2022 };
2023
2024 ai = adj_nbr_add_or_lock (FIB_PROTOCOL_IP4,
2025 VNET_LINK_IP4, &nh, sw_if_index);
2026 adj = adj_get (ai);
2027
2028 /* Peer has been previously resolved, retrieve glean adj instead */
2029 if (adj->lookup_next_index == IP_LOOKUP_NEXT_REWRITE)
2030 {
John Lo86376342018-06-11 20:14:49 -04002031 if (refresh)
2032 unicast_rewrite = 1;
2033 else
2034 {
2035 adj_unlock (ai);
2036 ai = adj_glean_add_or_lock (FIB_PROTOCOL_IP4,
2037 VNET_LINK_IP4, sw_if_index, &nh);
2038 adj = adj_get (ai);
2039 }
Dave Barach59b25652017-09-10 15:04:27 -04002040 }
2041
Ed Warnickecb9cada2015-12-08 15:45:58 -07002042 /* Add encapsulation string for software interface (e.g. ethernet header). */
2043 vnet_rewrite_one_header (adj[0], h, sizeof (ethernet_header_t));
John Lo86376342018-06-11 20:14:49 -04002044 if (unicast_rewrite)
2045 {
2046 u16 *etype = vlib_buffer_get_current (b) - 2;
2047 etype[0] = clib_host_to_net_u16 (ETHERNET_TYPE_ARP);
2048 }
Ed Warnickecb9cada2015-12-08 15:45:58 -07002049 vlib_buffer_advance (b, -adj->rewrite_header.data_bytes);
2050
2051 {
Dave Barachd7cb1b52016-12-09 09:52:16 -05002052 vlib_frame_t *f = vlib_get_frame_to_node (vm, hi->output_node_index);
2053 u32 *to_next = vlib_frame_vector_args (f);
Ed Warnickecb9cada2015-12-08 15:45:58 -07002054 to_next[0] = bi;
2055 f->n_vectors = 1;
2056 vlib_put_frame_to_node (vm, hi->output_node_index, f);
2057 }
2058
Neale Ranns7a272742017-05-30 02:08:14 -07002059 adj_unlock (ai);
Ed Warnickecb9cada2015-12-08 15:45:58 -07002060 return /* no error */ 0;
2061}
Damjan Marionc9dad5d2018-08-11 22:10:29 +02002062#endif
Ed Warnickecb9cada2015-12-08 15:45:58 -07002063
Dave Barachd7cb1b52016-12-09 09:52:16 -05002064typedef enum
2065{
Ed Warnickecb9cada2015-12-08 15:45:58 -07002066 IP4_REWRITE_NEXT_DROP,
Chris Luke816f3e12016-06-14 16:24:47 -04002067 IP4_REWRITE_NEXT_ICMP_ERROR,
Ole Troan313f7e22018-04-10 16:02:51 +02002068 IP4_REWRITE_NEXT_FRAGMENT,
2069 IP4_REWRITE_N_NEXT /* Last */
Ed Warnickecb9cada2015-12-08 15:45:58 -07002070} ip4_rewrite_next_t;
2071
Neale Ranns889fe942017-06-01 05:43:19 -04002072/**
2073 * This bits of an IPv4 address to mask to construct a multicast
2074 * MAC address
2075 */
2076#if CLIB_ARCH_IS_BIG_ENDIAN
2077#define IP4_MCAST_ADDR_MASK 0x007fffff
2078#else
2079#define IP4_MCAST_ADDR_MASK 0xffff7f00
2080#endif
2081
Ole Troan8a9c8f12018-05-18 11:01:31 +02002082always_inline void
2083ip4_mtu_check (vlib_buffer_t * b, u16 packet_len,
Damjan Marionca3ff1a2018-08-23 09:49:46 +02002084 u16 adj_packet_bytes, bool df, u16 * next, u32 * error)
Ole Troan8a9c8f12018-05-18 11:01:31 +02002085{
2086 if (packet_len > adj_packet_bytes)
2087 {
2088 *error = IP4_ERROR_MTU_EXCEEDED;
2089 if (df)
2090 {
2091 icmp4_error_set_vnet_buffer
2092 (b, ICMP4_destination_unreachable,
2093 ICMP4_destination_unreachable_fragmentation_needed_and_dont_fragment_set,
2094 adj_packet_bytes);
2095 *next = IP4_REWRITE_NEXT_ICMP_ERROR;
2096 }
2097 else
2098 {
Ole Troan313f7e22018-04-10 16:02:51 +02002099 /* IP fragmentation */
2100 ip_frag_set_vnet_buffer (b, 0, adj_packet_bytes,
Ole Troanb3655e52018-08-16 22:08:49 +02002101 IP4_FRAG_NEXT_IP4_REWRITE, 0);
Ole Troan313f7e22018-04-10 16:02:51 +02002102 *next = IP4_REWRITE_NEXT_FRAGMENT;
Ole Troan8a9c8f12018-05-18 11:01:31 +02002103 }
2104 }
2105}
2106
Damjan Marionca3ff1a2018-08-23 09:49:46 +02002107/* Decrement TTL & update checksum.
2108 Works either endian, so no need for byte swap. */
2109static_always_inline void
2110ip4_ttl_and_checksum_check (vlib_buffer_t * b, ip4_header_t * ip, u16 * next,
2111 u32 * error)
2112{
2113 i32 ttl;
2114 u32 checksum;
2115 if (PREDICT_FALSE (b->flags & VNET_BUFFER_F_LOCALLY_ORIGINATED))
2116 {
2117 b->flags &= ~VNET_BUFFER_F_LOCALLY_ORIGINATED;
2118 return;
2119 }
2120
2121 ttl = ip->ttl;
2122
2123 /* Input node should have reject packets with ttl 0. */
2124 ASSERT (ip->ttl > 0);
2125
2126 checksum = ip->checksum + clib_host_to_net_u16 (0x0100);
2127 checksum += checksum >= 0xffff;
2128
2129 ip->checksum = checksum;
2130 ttl -= 1;
2131 ip->ttl = ttl;
2132
2133 /*
2134 * If the ttl drops below 1 when forwarding, generate
2135 * an ICMP response.
2136 */
2137 if (PREDICT_FALSE (ttl <= 0))
2138 {
2139 *error = IP4_ERROR_TIME_EXPIRED;
2140 vnet_buffer (b)->sw_if_index[VLIB_TX] = (u32) ~ 0;
2141 icmp4_error_set_vnet_buffer (b, ICMP4_time_exceeded,
2142 ICMP4_time_exceeded_ttl_exceeded_in_transit,
2143 0);
2144 *next = IP4_REWRITE_NEXT_ICMP_ERROR;
2145 }
2146
2147 /* Verify checksum. */
2148 ASSERT ((ip->checksum == ip4_header_checksum (ip)) ||
2149 (b->flags & VNET_BUFFER_F_OFFLOAD_IP_CKSUM));
2150}
2151
2152
Ed Warnickecb9cada2015-12-08 15:45:58 -07002153always_inline uword
2154ip4_rewrite_inline (vlib_main_t * vm,
2155 vlib_node_runtime_t * node,
Neale Ranns9c6a6132017-02-21 05:33:14 -08002156 vlib_frame_t * frame,
2157 int do_counters, int is_midchain, int is_mcast)
Ed Warnickecb9cada2015-12-08 15:45:58 -07002158{
Dave Barachd7cb1b52016-12-09 09:52:16 -05002159 ip_lookup_main_t *lm = &ip4_main.lookup_main;
2160 u32 *from = vlib_frame_vector_args (frame);
Damjan Marionca3ff1a2018-08-23 09:49:46 +02002161 vlib_buffer_t *bufs[VLIB_FRAME_SIZE], **b;
2162 u16 nexts[VLIB_FRAME_SIZE], *next;
2163 u32 n_left_from;
Dave Barachd7cb1b52016-12-09 09:52:16 -05002164 vlib_node_runtime_t *error_node =
2165 vlib_node_get_runtime (vm, ip4_input_node.index);
Ed Warnickecb9cada2015-12-08 15:45:58 -07002166
2167 n_left_from = frame->n_vectors;
Damjan Marion067cd622018-07-11 12:47:43 +02002168 u32 thread_index = vm->thread_index;
Dave Barach75fc8542016-10-11 16:16:02 -04002169
Damjan Marionca3ff1a2018-08-23 09:49:46 +02002170 vlib_get_buffers (vm, from, bufs, n_left_from);
2171 clib_memset_u16 (nexts, IP4_REWRITE_NEXT_DROP, n_left_from);
2172
2173 if (n_left_from >= 6)
2174 {
2175 int i;
2176 for (i = 0; i < 6; i++)
2177 vlib_prefetch_buffer_header (bufs[i], LOAD);
2178 }
2179
2180 next = nexts;
2181 b = bufs;
2182 while (n_left_from >= 8)
2183 {
2184 ip_adjacency_t *adj0, *adj1;
2185 ip4_header_t *ip0, *ip1;
2186 u32 rw_len0, error0, adj_index0;
2187 u32 rw_len1, error1, adj_index1;
2188 u32 tx_sw_if_index0, tx_sw_if_index1;
2189 u8 *p;
2190
2191 vlib_prefetch_buffer_header (b[6], LOAD);
2192 vlib_prefetch_buffer_header (b[7], LOAD);
2193
2194 adj_index0 = vnet_buffer (b[0])->ip.adj_index[VLIB_TX];
2195 adj_index1 = vnet_buffer (b[1])->ip.adj_index[VLIB_TX];
2196
2197 /*
2198 * pre-fetch the per-adjacency counters
2199 */
2200 if (do_counters)
2201 {
2202 vlib_prefetch_combined_counter (&adjacency_counters,
2203 thread_index, adj_index0);
2204 vlib_prefetch_combined_counter (&adjacency_counters,
2205 thread_index, adj_index1);
2206 }
2207
2208 ip0 = vlib_buffer_get_current (b[0]);
2209 ip1 = vlib_buffer_get_current (b[1]);
2210
2211 error0 = error1 = IP4_ERROR_NONE;
2212
2213 ip4_ttl_and_checksum_check (b[0], ip0, next + 0, &error0);
2214 ip4_ttl_and_checksum_check (b[1], ip1, next + 1, &error1);
2215
2216 /* Rewrite packet header and updates lengths. */
2217 adj0 = adj_get (adj_index0);
2218 adj1 = adj_get (adj_index1);
2219
2220 /* Worth pipelining. No guarantee that adj0,1 are hot... */
2221 rw_len0 = adj0[0].rewrite_header.data_bytes;
2222 rw_len1 = adj1[0].rewrite_header.data_bytes;
2223 vnet_buffer (b[0])->ip.save_rewrite_length = rw_len0;
2224 vnet_buffer (b[1])->ip.save_rewrite_length = rw_len1;
2225
2226 p = vlib_buffer_get_current (b[2]);
2227 CLIB_PREFETCH (p - CLIB_CACHE_LINE_BYTES, CLIB_CACHE_LINE_BYTES, STORE);
2228 CLIB_PREFETCH (p, CLIB_CACHE_LINE_BYTES, LOAD);
2229
2230 p = vlib_buffer_get_current (b[3]);
2231 CLIB_PREFETCH (p - CLIB_CACHE_LINE_BYTES, CLIB_CACHE_LINE_BYTES, STORE);
2232 CLIB_PREFETCH (p, CLIB_CACHE_LINE_BYTES, LOAD);
2233
2234 /* Check MTU of outgoing interface. */
2235 ip4_mtu_check (b[0], clib_net_to_host_u16 (ip0->length),
2236 adj0[0].rewrite_header.max_l3_packet_bytes,
2237 ip0->flags_and_fragment_offset &
2238 clib_host_to_net_u16 (IP4_HEADER_FLAG_DONT_FRAGMENT),
2239 next + 0, &error0);
2240 ip4_mtu_check (b[1], clib_net_to_host_u16 (ip1->length),
2241 adj1[0].rewrite_header.max_l3_packet_bytes,
2242 ip1->flags_and_fragment_offset &
2243 clib_host_to_net_u16 (IP4_HEADER_FLAG_DONT_FRAGMENT),
2244 next + 1, &error1);
2245
2246 if (is_mcast)
2247 {
2248 error0 = ((adj0[0].rewrite_header.sw_if_index ==
2249 vnet_buffer (b[0])->sw_if_index[VLIB_RX]) ?
2250 IP4_ERROR_SAME_INTERFACE : error0);
2251 error1 = ((adj1[0].rewrite_header.sw_if_index ==
2252 vnet_buffer (b[1])->sw_if_index[VLIB_RX]) ?
2253 IP4_ERROR_SAME_INTERFACE : error1);
2254 }
2255
2256 b[0]->error = error_node->errors[error0];
2257 b[1]->error = error_node->errors[error1];
2258 /* Don't adjust the buffer for ttl issue; icmp-error node wants
2259 * to see the IP headerr */
2260 if (PREDICT_TRUE (error0 == IP4_ERROR_NONE))
2261 {
2262 u32 next_index = adj0[0].rewrite_header.next_index;
2263 b[0]->current_data -= rw_len0;
2264 b[0]->current_length += rw_len0;
2265 tx_sw_if_index0 = adj0[0].rewrite_header.sw_if_index;
2266 vnet_buffer (b[0])->sw_if_index[VLIB_TX] = tx_sw_if_index0;
2267
2268 if (PREDICT_FALSE
2269 (adj0[0].rewrite_header.flags & VNET_REWRITE_HAS_FEATURES))
2270 vnet_feature_arc_start (lm->output_feature_arc_index,
2271 tx_sw_if_index0, &next_index, b[0]);
2272 next[0] = next_index;
2273 }
2274 if (PREDICT_TRUE (error1 == IP4_ERROR_NONE))
2275 {
2276 u32 next_index = adj1[0].rewrite_header.next_index;
2277 b[1]->current_data -= rw_len1;
2278 b[1]->current_length += rw_len1;
2279
2280 tx_sw_if_index1 = adj1[0].rewrite_header.sw_if_index;
2281 vnet_buffer (b[1])->sw_if_index[VLIB_TX] = tx_sw_if_index1;
2282
2283 if (PREDICT_FALSE
2284 (adj1[0].rewrite_header.flags & VNET_REWRITE_HAS_FEATURES))
2285 vnet_feature_arc_start (lm->output_feature_arc_index,
2286 tx_sw_if_index1, &next_index, b[1]);
2287 next[1] = next_index;
2288 }
2289
2290 /* Guess we are only writing on simple Ethernet header. */
2291 vnet_rewrite_two_headers (adj0[0], adj1[0],
2292 ip0, ip1, sizeof (ethernet_header_t));
2293
2294 /*
2295 * Bump the per-adjacency counters
2296 */
2297 if (do_counters)
2298 {
2299 vlib_increment_combined_counter
2300 (&adjacency_counters,
2301 thread_index,
2302 adj_index0, 1, vlib_buffer_length_in_chain (vm, b[0]) + rw_len0);
2303
2304 vlib_increment_combined_counter
2305 (&adjacency_counters,
2306 thread_index,
2307 adj_index1, 1, vlib_buffer_length_in_chain (vm, b[1]) + rw_len1);
2308 }
2309
2310 if (is_midchain)
2311 {
2312 adj0->sub_type.midchain.fixup_func
2313 (vm, adj0, b[0], adj0->sub_type.midchain.fixup_data);
2314 adj1->sub_type.midchain.fixup_func
2315 (vm, adj1, b[1], adj0->sub_type.midchain.fixup_data);
2316 }
2317
2318 if (is_mcast)
2319 {
2320 /*
2321 * copy bytes from the IP address into the MAC rewrite
2322 */
2323 vnet_ip_mcast_fixup_header (IP4_MCAST_ADDR_MASK,
2324 adj0->rewrite_header.dst_mcast_offset,
2325 &ip0->dst_address.as_u32, (u8 *) ip0);
2326 vnet_ip_mcast_fixup_header (IP4_MCAST_ADDR_MASK,
2327 adj0->rewrite_header.dst_mcast_offset,
2328 &ip1->dst_address.as_u32, (u8 *) ip1);
2329 }
2330
2331 next += 2;
2332 b += 2;
2333 n_left_from -= 2;
2334 }
2335
Ed Warnickecb9cada2015-12-08 15:45:58 -07002336 while (n_left_from > 0)
2337 {
Damjan Marionca3ff1a2018-08-23 09:49:46 +02002338 ip_adjacency_t *adj0;
2339 ip4_header_t *ip0;
2340 u32 rw_len0, adj_index0, error0;
2341 u32 tx_sw_if_index0;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002342
Damjan Marionca3ff1a2018-08-23 09:49:46 +02002343 adj_index0 = vnet_buffer (b[0])->ip.adj_index[VLIB_TX];
2344
2345 adj0 = adj_get (adj_index0);
2346
2347 if (do_counters)
2348 vlib_prefetch_combined_counter (&adjacency_counters,
2349 thread_index, adj_index0);
2350
2351 ip0 = vlib_buffer_get_current (b[0]);
2352
2353 error0 = IP4_ERROR_NONE;
2354
2355 ip4_ttl_and_checksum_check (b[0], ip0, next + 0, &error0);
2356
2357
2358 /* Update packet buffer attributes/set output interface. */
2359 rw_len0 = adj0[0].rewrite_header.data_bytes;
2360 vnet_buffer (b[0])->ip.save_rewrite_length = rw_len0;
2361
2362 /* Check MTU of outgoing interface. */
2363 ip4_mtu_check (b[0], clib_net_to_host_u16 (ip0->length),
2364 adj0[0].rewrite_header.max_l3_packet_bytes,
2365 ip0->flags_and_fragment_offset &
2366 clib_host_to_net_u16 (IP4_HEADER_FLAG_DONT_FRAGMENT),
2367 next + 0, &error0);
2368
2369 if (is_mcast)
Ed Warnickecb9cada2015-12-08 15:45:58 -07002370 {
Damjan Marionca3ff1a2018-08-23 09:49:46 +02002371 error0 = ((adj0[0].rewrite_header.sw_if_index ==
2372 vnet_buffer (b[0])->sw_if_index[VLIB_RX]) ?
2373 IP4_ERROR_SAME_INTERFACE : error0);
2374 }
2375 b[0]->error = error_node->errors[error0];
Neale Ranns0bfe5d82016-08-25 15:29:12 +01002376
Damjan Marionca3ff1a2018-08-23 09:49:46 +02002377 /* Don't adjust the buffer for ttl issue; icmp-error node wants
2378 * to see the IP headerr */
2379 if (PREDICT_TRUE (error0 == IP4_ERROR_NONE))
2380 {
2381 u32 next_index = adj0[0].rewrite_header.next_index;
2382 b[0]->current_data -= rw_len0;
2383 b[0]->current_length += rw_len0;
2384 tx_sw_if_index0 = adj0[0].rewrite_header.sw_if_index;
2385 vnet_buffer (b[0])->sw_if_index[VLIB_TX] = tx_sw_if_index0;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002386
Damjan Marionca3ff1a2018-08-23 09:49:46 +02002387 if (PREDICT_FALSE
2388 (adj0[0].rewrite_header.flags & VNET_REWRITE_HAS_FEATURES))
2389 vnet_feature_arc_start (lm->output_feature_arc_index,
2390 tx_sw_if_index0, &next_index, b[0]);
2391 next[0] = next_index;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002392 }
2393
Damjan Marionca3ff1a2018-08-23 09:49:46 +02002394 /* Guess we are only writing on simple Ethernet header. */
2395 vnet_rewrite_one_header (adj0[0], ip0, sizeof (ethernet_header_t));
2396
2397 if (do_counters)
2398 vlib_increment_combined_counter
2399 (&adjacency_counters,
2400 thread_index, adj_index0, 1,
2401 vlib_buffer_length_in_chain (vm, b[0]) + rw_len0);
2402
2403 if (is_midchain)
Ed Warnickecb9cada2015-12-08 15:45:58 -07002404 {
Damjan Marionca3ff1a2018-08-23 09:49:46 +02002405 adj0->sub_type.midchain.fixup_func
2406 (vm, adj0, b[0], adj0->sub_type.midchain.fixup_data);
Ed Warnickecb9cada2015-12-08 15:45:58 -07002407 }
Dave Barach75fc8542016-10-11 16:16:02 -04002408
Damjan Marionca3ff1a2018-08-23 09:49:46 +02002409 if (is_mcast)
2410 {
2411 /*
2412 * copy bytes from the IP address into the MAC rewrite
2413 */
2414 vnet_ip_mcast_fixup_header (IP4_MCAST_ADDR_MASK,
2415 adj0->rewrite_header.dst_mcast_offset,
2416 &ip0->dst_address.as_u32, (u8 *) ip0);
2417 }
2418
2419 next += 1;
2420 b += 1;
2421 n_left_from -= 1;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002422 }
2423
Damjan Marionca3ff1a2018-08-23 09:49:46 +02002424
Ed Warnickecb9cada2015-12-08 15:45:58 -07002425 /* Need to do trace after rewrites to pick up new packet data. */
2426 if (node->flags & VLIB_NODE_FLAG_TRACE)
Neale Rannsf06aea52016-11-29 06:51:37 -08002427 ip4_forward_next_trace (vm, node, frame, VLIB_TX);
Ed Warnickecb9cada2015-12-08 15:45:58 -07002428
Damjan Marionca3ff1a2018-08-23 09:49:46 +02002429 vlib_buffer_enqueue_to_next (vm, node, from, nexts, frame->n_vectors);
Ed Warnickecb9cada2015-12-08 15:45:58 -07002430 return frame->n_vectors;
2431}
2432
Dave Barach132d51d2016-07-07 10:10:17 -04002433
Neale Rannsf06aea52016-11-29 06:51:37 -08002434/** @brief IPv4 rewrite node.
2435 @node ip4-rewrite
Dave Barach132d51d2016-07-07 10:10:17 -04002436
2437 This is the IPv4 transit-rewrite node: decrement TTL, fix the ipv4
2438 header checksum, fetch the ip adjacency, check the outbound mtu,
2439 apply the adjacency rewrite, and send pkts to the adjacency
2440 rewrite header's rewrite_next_index.
2441
2442 @param vm vlib_main_t corresponding to the current thread
2443 @param node vlib_node_runtime_t
2444 @param frame vlib_frame_t whose contents should be dispatched
2445
2446 @par Graph mechanics: buffer metadata, next index usage
2447
2448 @em Uses:
2449 - <code>vnet_buffer(b)->ip.adj_index[VLIB_TX]</code>
2450 - the rewrite adjacency index
2451 - <code>adj->lookup_next_index</code>
2452 - Must be IP_LOOKUP_NEXT_REWRITE or IP_LOOKUP_NEXT_ARP, otherwise
Dave Barach75fc8542016-10-11 16:16:02 -04002453 the packet will be dropped.
Dave Barach132d51d2016-07-07 10:10:17 -04002454 - <code>adj->rewrite_header</code>
2455 - Rewrite string length, rewrite string, next_index
2456
2457 @em Sets:
2458 - <code>b->current_data, b->current_length</code>
2459 - Updated net of applying the rewrite string
2460
2461 <em>Next Indices:</em>
2462 - <code> adj->rewrite_header.next_index </code>
Vijayabhaskar Katamreddyce074122017-11-15 13:50:26 -08002463 or @c ip4-drop
Dave Barach132d51d2016-07-07 10:10:17 -04002464*/
Damjan Marionc9dad5d2018-08-11 22:10:29 +02002465
2466VLIB_NODE_FN (ip4_rewrite_node) (vlib_main_t * vm, vlib_node_runtime_t * node,
2467 vlib_frame_t * frame)
Ed Warnickecb9cada2015-12-08 15:45:58 -07002468{
Neale Ranns9c6a6132017-02-21 05:33:14 -08002469 if (adj_are_counters_enabled ())
2470 return ip4_rewrite_inline (vm, node, frame, 1, 0, 0);
2471 else
2472 return ip4_rewrite_inline (vm, node, frame, 0, 0, 0);
Ed Warnickecb9cada2015-12-08 15:45:58 -07002473}
2474
Damjan Marionc9dad5d2018-08-11 22:10:29 +02002475VLIB_NODE_FN (ip4_rewrite_bcast_node) (vlib_main_t * vm,
2476 vlib_node_runtime_t * node,
2477 vlib_frame_t * frame)
Neale Ranns1855b8e2018-07-11 10:31:26 -07002478{
2479 if (adj_are_counters_enabled ())
2480 return ip4_rewrite_inline (vm, node, frame, 1, 0, 0);
2481 else
2482 return ip4_rewrite_inline (vm, node, frame, 0, 0, 0);
2483}
2484
Damjan Marionc9dad5d2018-08-11 22:10:29 +02002485VLIB_NODE_FN (ip4_midchain_node) (vlib_main_t * vm,
2486 vlib_node_runtime_t * node,
2487 vlib_frame_t * frame)
Neale Ranns0bfe5d82016-08-25 15:29:12 +01002488{
Neale Ranns9c6a6132017-02-21 05:33:14 -08002489 if (adj_are_counters_enabled ())
2490 return ip4_rewrite_inline (vm, node, frame, 1, 1, 0);
2491 else
2492 return ip4_rewrite_inline (vm, node, frame, 0, 1, 0);
Neale Ranns0bfe5d82016-08-25 15:29:12 +01002493}
2494
Damjan Marionc9dad5d2018-08-11 22:10:29 +02002495VLIB_NODE_FN (ip4_rewrite_mcast_node) (vlib_main_t * vm,
2496 vlib_node_runtime_t * node,
2497 vlib_frame_t * frame)
Dave Barachd7cb1b52016-12-09 09:52:16 -05002498{
Neale Ranns9c6a6132017-02-21 05:33:14 -08002499 if (adj_are_counters_enabled ())
2500 return ip4_rewrite_inline (vm, node, frame, 1, 0, 1);
2501 else
2502 return ip4_rewrite_inline (vm, node, frame, 0, 0, 1);
Neale Ranns32e1c012016-11-22 17:07:28 +00002503}
Ed Warnickecb9cada2015-12-08 15:45:58 -07002504
Damjan Marionc9dad5d2018-08-11 22:10:29 +02002505VLIB_NODE_FN (ip4_mcast_midchain_node) (vlib_main_t * vm,
2506 vlib_node_runtime_t * node,
2507 vlib_frame_t * frame)
Neale Ranns0f26c5a2017-03-01 15:12:11 -08002508{
2509 if (adj_are_counters_enabled ())
2510 return ip4_rewrite_inline (vm, node, frame, 1, 1, 1);
2511 else
2512 return ip4_rewrite_inline (vm, node, frame, 0, 1, 1);
2513}
2514
Neale Ranns32e1c012016-11-22 17:07:28 +00002515/* *INDENT-OFF* */
2516VLIB_REGISTER_NODE (ip4_rewrite_node) = {
Neale Ranns32e1c012016-11-22 17:07:28 +00002517 .name = "ip4-rewrite",
2518 .vector_size = sizeof (u32),
Ed Warnickecb9cada2015-12-08 15:45:58 -07002519
Neale Ranns32e1c012016-11-22 17:07:28 +00002520 .format_trace = format_ip4_rewrite_trace,
Ed Warnickecb9cada2015-12-08 15:45:58 -07002521
Ole Troan313f7e22018-04-10 16:02:51 +02002522 .n_next_nodes = IP4_REWRITE_N_NEXT,
Neale Ranns32e1c012016-11-22 17:07:28 +00002523 .next_nodes = {
Vijayabhaskar Katamreddyce074122017-11-15 13:50:26 -08002524 [IP4_REWRITE_NEXT_DROP] = "ip4-drop",
Neale Ranns32e1c012016-11-22 17:07:28 +00002525 [IP4_REWRITE_NEXT_ICMP_ERROR] = "ip4-icmp-error",
Ole Troan313f7e22018-04-10 16:02:51 +02002526 [IP4_REWRITE_NEXT_FRAGMENT] = "ip4-frag",
Neale Ranns32e1c012016-11-22 17:07:28 +00002527 },
2528};
Neale Ranns1855b8e2018-07-11 10:31:26 -07002529
2530VLIB_REGISTER_NODE (ip4_rewrite_bcast_node) = {
Neale Ranns1855b8e2018-07-11 10:31:26 -07002531 .name = "ip4-rewrite-bcast",
2532 .vector_size = sizeof (u32),
2533
2534 .format_trace = format_ip4_rewrite_trace,
2535 .sibling_of = "ip4-rewrite",
2536};
Neale Ranns32e1c012016-11-22 17:07:28 +00002537
2538VLIB_REGISTER_NODE (ip4_rewrite_mcast_node) = {
Neale Ranns32e1c012016-11-22 17:07:28 +00002539 .name = "ip4-rewrite-mcast",
2540 .vector_size = sizeof (u32),
2541
2542 .format_trace = format_ip4_rewrite_trace,
2543 .sibling_of = "ip4-rewrite",
2544};
Neale Ranns32e1c012016-11-22 17:07:28 +00002545
Damjan Marionc9dad5d2018-08-11 22:10:29 +02002546VLIB_REGISTER_NODE (ip4_mcast_midchain_node) = {
Neale Ranns0f26c5a2017-03-01 15:12:11 -08002547 .name = "ip4-mcast-midchain",
2548 .vector_size = sizeof (u32),
2549
2550 .format_trace = format_ip4_rewrite_trace,
2551 .sibling_of = "ip4-rewrite",
2552};
Neale Ranns0f26c5a2017-03-01 15:12:11 -08002553
Neale Ranns32e1c012016-11-22 17:07:28 +00002554VLIB_REGISTER_NODE (ip4_midchain_node) = {
Neale Ranns32e1c012016-11-22 17:07:28 +00002555 .name = "ip4-midchain",
2556 .vector_size = sizeof (u32),
2557 .format_trace = format_ip4_forward_next_trace,
2558 .sibling_of = "ip4-rewrite",
2559};
Neale Ranns32e1c012016-11-22 17:07:28 +00002560/* *INDENT-ON */
Damjan Marion1c80e832016-05-11 23:07:18 +02002561
Damjan Marionc9dad5d2018-08-11 22:10:29 +02002562static int
Dave Barachd7cb1b52016-12-09 09:52:16 -05002563ip4_lookup_validate (ip4_address_t * a, u32 fib_index0)
2564{
2565 ip4_fib_mtrie_t *mtrie0;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002566 ip4_fib_mtrie_leaf_t leaf0;
Neale Ranns0bfe5d82016-08-25 15:29:12 +01002567 u32 lbi0;
Dave Barach75fc8542016-10-11 16:16:02 -04002568
Neale Ranns0bfe5d82016-08-25 15:29:12 +01002569 mtrie0 = &ip4_fib_get (fib_index0)->mtrie;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002570
Neale Ranns04a75e32017-03-23 06:46:01 -07002571 leaf0 = ip4_fib_mtrie_lookup_step_one (mtrie0, a);
Ed Warnickecb9cada2015-12-08 15:45:58 -07002572 leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, a, 2);
2573 leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, a, 3);
Dave Barach75fc8542016-10-11 16:16:02 -04002574
Neale Ranns0bfe5d82016-08-25 15:29:12 +01002575 lbi0 = ip4_fib_mtrie_leaf_get_adj_index (leaf0);
Dave Barach75fc8542016-10-11 16:16:02 -04002576
Dave Barachd7cb1b52016-12-09 09:52:16 -05002577 return lbi0 == ip4_fib_table_lookup_lb (ip4_fib_get (fib_index0), a);
Ed Warnickecb9cada2015-12-08 15:45:58 -07002578}
Dave Barach75fc8542016-10-11 16:16:02 -04002579
Ed Warnickecb9cada2015-12-08 15:45:58 -07002580static clib_error_t *
2581test_lookup_command_fn (vlib_main_t * vm,
Dave Barachd7cb1b52016-12-09 09:52:16 -05002582 unformat_input_t * input, vlib_cli_command_t * cmd)
Ed Warnickecb9cada2015-12-08 15:45:58 -07002583{
Billy McFall309fe062016-10-14 07:37:33 -04002584 ip4_fib_t *fib;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002585 u32 table_id = 0;
2586 f64 count = 1;
2587 u32 n;
2588 int i;
2589 ip4_address_t ip4_base_address;
2590 u64 errors = 0;
2591
Dave Barachd7cb1b52016-12-09 09:52:16 -05002592 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2593 {
Ed Warnickecb9cada2015-12-08 15:45:58 -07002594 if (unformat (input, "table %d", &table_id))
Dave Barachd7cb1b52016-12-09 09:52:16 -05002595 {
2596 /* Make sure the entry exists. */
2597 fib = ip4_fib_get (table_id);
2598 if ((fib) && (fib->index != table_id))
2599 return clib_error_return (0, "<fib-index> %d does not exist",
2600 table_id);
2601 }
Ed Warnickecb9cada2015-12-08 15:45:58 -07002602 else if (unformat (input, "count %f", &count))
2603 ;
2604
2605 else if (unformat (input, "%U",
2606 unformat_ip4_address, &ip4_base_address))
Dave Barachd7cb1b52016-12-09 09:52:16 -05002607 ;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002608 else
Dave Barachd7cb1b52016-12-09 09:52:16 -05002609 return clib_error_return (0, "unknown input `%U'",
2610 format_unformat_error, input);
2611 }
Ed Warnickecb9cada2015-12-08 15:45:58 -07002612
2613 n = count;
2614
2615 for (i = 0; i < n; i++)
2616 {
2617 if (!ip4_lookup_validate (&ip4_base_address, table_id))
Dave Barachd7cb1b52016-12-09 09:52:16 -05002618 errors++;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002619
Dave Barach75fc8542016-10-11 16:16:02 -04002620 ip4_base_address.as_u32 =
Dave Barachd7cb1b52016-12-09 09:52:16 -05002621 clib_host_to_net_u32 (1 +
2622 clib_net_to_host_u32 (ip4_base_address.as_u32));
Ed Warnickecb9cada2015-12-08 15:45:58 -07002623 }
2624
Dave Barach75fc8542016-10-11 16:16:02 -04002625 if (errors)
Ed Warnickecb9cada2015-12-08 15:45:58 -07002626 vlib_cli_output (vm, "%llu errors out of %d lookups\n", errors, n);
2627 else
2628 vlib_cli_output (vm, "No errors in %d lookups\n", n);
2629
2630 return 0;
2631}
2632
Billy McFall0683c9c2016-10-13 08:27:31 -04002633/*?
2634 * Perform a lookup of an IPv4 Address (or range of addresses) in the
2635 * given FIB table to determine if there is a conflict with the
2636 * adjacency table. The fib-id can be determined by using the
2637 * '<em>show ip fib</em>' command. If fib-id is not entered, default value
2638 * of 0 is used.
2639 *
2640 * @todo This command uses fib-id, other commands use table-id (not
2641 * just a name, they are different indexes). Would like to change this
2642 * to table-id for consistency.
2643 *
2644 * @cliexpar
2645 * Example of how to run the test lookup command:
2646 * @cliexstart{test lookup 172.16.1.1 table 1 count 2}
2647 * No errors in 2 lookups
2648 * @cliexend
2649?*/
2650/* *INDENT-OFF* */
Dave Barachd7cb1b52016-12-09 09:52:16 -05002651VLIB_CLI_COMMAND (lookup_test_command, static) =
2652{
2653 .path = "test lookup",
2654 .short_help = "test lookup <ipv4-addr> [table <fib-id>] [count <nn>]",
2655 .function = test_lookup_command_fn,
Ed Warnickecb9cada2015-12-08 15:45:58 -07002656};
Billy McFall0683c9c2016-10-13 08:27:31 -04002657/* *INDENT-ON* */
Ed Warnickecb9cada2015-12-08 15:45:58 -07002658
Damjan Marionc9dad5d2018-08-11 22:10:29 +02002659#ifndef CLIB_MARCH_VARIANT
Dave Barachd7cb1b52016-12-09 09:52:16 -05002660int
2661vnet_set_ip4_flow_hash (u32 table_id, u32 flow_hash_config)
Ed Warnickecb9cada2015-12-08 15:45:58 -07002662{
Neale Ranns107e7d42017-04-11 09:55:19 -07002663 u32 fib_index;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002664
Neale Ranns107e7d42017-04-11 09:55:19 -07002665 fib_index = fib_table_find (FIB_PROTOCOL_IP4, table_id);
2666
2667 if (~0 == fib_index)
Ed Warnickecb9cada2015-12-08 15:45:58 -07002668 return VNET_API_ERROR_NO_SUCH_FIB;
2669
Neale Ranns227038a2017-04-21 01:07:59 -07002670 fib_table_set_flow_hash_config (fib_index, FIB_PROTOCOL_IP4,
2671 flow_hash_config);
Ed Warnickecb9cada2015-12-08 15:45:58 -07002672
Ed Warnickecb9cada2015-12-08 15:45:58 -07002673 return 0;
2674}
Damjan Marionc9dad5d2018-08-11 22:10:29 +02002675#endif
Dave Barach75fc8542016-10-11 16:16:02 -04002676
Ed Warnickecb9cada2015-12-08 15:45:58 -07002677static clib_error_t *
2678set_ip_flow_hash_command_fn (vlib_main_t * vm,
Dave Barachd7cb1b52016-12-09 09:52:16 -05002679 unformat_input_t * input,
2680 vlib_cli_command_t * cmd)
Ed Warnickecb9cada2015-12-08 15:45:58 -07002681{
2682 int matched = 0;
2683 u32 table_id = 0;
2684 u32 flow_hash_config = 0;
2685 int rv;
2686
Dave Barachd7cb1b52016-12-09 09:52:16 -05002687 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2688 {
2689 if (unformat (input, "table %d", &table_id))
2690 matched = 1;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002691#define _(a,v) \
2692 else if (unformat (input, #a)) { flow_hash_config |= v; matched=1;}
Dave Barachd7cb1b52016-12-09 09:52:16 -05002693 foreach_flow_hash_bit
Ed Warnickecb9cada2015-12-08 15:45:58 -07002694#undef _
Dave Barachd7cb1b52016-12-09 09:52:16 -05002695 else
2696 break;
2697 }
Dave Barach75fc8542016-10-11 16:16:02 -04002698
Ed Warnickecb9cada2015-12-08 15:45:58 -07002699 if (matched == 0)
2700 return clib_error_return (0, "unknown input `%U'",
Dave Barachd7cb1b52016-12-09 09:52:16 -05002701 format_unformat_error, input);
Dave Barach75fc8542016-10-11 16:16:02 -04002702
Ed Warnickecb9cada2015-12-08 15:45:58 -07002703 rv = vnet_set_ip4_flow_hash (table_id, flow_hash_config);
2704 switch (rv)
2705 {
2706 case 0:
2707 break;
Dave Barach75fc8542016-10-11 16:16:02 -04002708
Ed Warnickecb9cada2015-12-08 15:45:58 -07002709 case VNET_API_ERROR_NO_SUCH_FIB:
2710 return clib_error_return (0, "no such FIB table %d", table_id);
Dave Barach75fc8542016-10-11 16:16:02 -04002711
Ed Warnickecb9cada2015-12-08 15:45:58 -07002712 default:
2713 clib_warning ("BUG: illegal flow hash config 0x%x", flow_hash_config);
2714 break;
2715 }
Dave Barach75fc8542016-10-11 16:16:02 -04002716
Ed Warnickecb9cada2015-12-08 15:45:58 -07002717 return 0;
2718}
Dave Barach75fc8542016-10-11 16:16:02 -04002719
Billy McFall0683c9c2016-10-13 08:27:31 -04002720/*?
2721 * Configure the set of IPv4 fields used by the flow hash.
2722 *
2723 * @cliexpar
2724 * Example of how to set the flow hash on a given table:
2725 * @cliexcmd{set ip flow-hash table 7 dst sport dport proto}
2726 * Example of display the configured flow hash:
2727 * @cliexstart{show ip fib}
Billy McFallebb9a6a2016-10-17 11:35:32 -04002728 * ipv4-VRF:0, fib_index 0, flow hash: src dst sport dport proto
2729 * 0.0.0.0/0
2730 * unicast-ip4-chain
2731 * [@0]: dpo-load-balance: [index:0 buckets:1 uRPF:0 to:[0:0]]
2732 * [0] [@0]: dpo-drop ip6
2733 * 0.0.0.0/32
2734 * unicast-ip4-chain
2735 * [@0]: dpo-load-balance: [index:1 buckets:1 uRPF:1 to:[0:0]]
2736 * [0] [@0]: dpo-drop ip6
2737 * 224.0.0.0/8
2738 * unicast-ip4-chain
2739 * [@0]: dpo-load-balance: [index:3 buckets:1 uRPF:3 to:[0:0]]
2740 * [0] [@0]: dpo-drop ip6
2741 * 6.0.1.2/32
2742 * unicast-ip4-chain
2743 * [@0]: dpo-load-balance: [index:30 buckets:1 uRPF:29 to:[0:0]]
2744 * [0] [@3]: arp-ipv4: via 6.0.0.1 af_packet0
2745 * 7.0.0.1/32
2746 * unicast-ip4-chain
2747 * [@0]: dpo-load-balance: [index:31 buckets:4 uRPF:30 to:[0:0]]
2748 * [0] [@3]: arp-ipv4: via 6.0.0.2 af_packet0
2749 * [1] [@3]: arp-ipv4: via 6.0.0.2 af_packet0
2750 * [2] [@3]: arp-ipv4: via 6.0.0.2 af_packet0
2751 * [3] [@3]: arp-ipv4: via 6.0.0.1 af_packet0
2752 * 240.0.0.0/8
2753 * unicast-ip4-chain
2754 * [@0]: dpo-load-balance: [index:2 buckets:1 uRPF:2 to:[0:0]]
2755 * [0] [@0]: dpo-drop ip6
2756 * 255.255.255.255/32
2757 * unicast-ip4-chain
2758 * [@0]: dpo-load-balance: [index:4 buckets:1 uRPF:4 to:[0:0]]
2759 * [0] [@0]: dpo-drop ip6
2760 * ipv4-VRF:7, fib_index 1, flow hash: dst sport dport proto
2761 * 0.0.0.0/0
2762 * unicast-ip4-chain
2763 * [@0]: dpo-load-balance: [index:12 buckets:1 uRPF:11 to:[0:0]]
2764 * [0] [@0]: dpo-drop ip6
2765 * 0.0.0.0/32
2766 * unicast-ip4-chain
2767 * [@0]: dpo-load-balance: [index:13 buckets:1 uRPF:12 to:[0:0]]
2768 * [0] [@0]: dpo-drop ip6
2769 * 172.16.1.0/24
2770 * unicast-ip4-chain
2771 * [@0]: dpo-load-balance: [index:17 buckets:1 uRPF:16 to:[0:0]]
2772 * [0] [@4]: ipv4-glean: af_packet0
2773 * 172.16.1.1/32
2774 * unicast-ip4-chain
2775 * [@0]: dpo-load-balance: [index:18 buckets:1 uRPF:17 to:[1:84]]
2776 * [0] [@2]: dpo-receive: 172.16.1.1 on af_packet0
2777 * 172.16.1.2/32
2778 * unicast-ip4-chain
2779 * [@0]: dpo-load-balance: [index:21 buckets:1 uRPF:20 to:[0:0]]
2780 * [0] [@5]: ipv4 via 172.16.1.2 af_packet0: IP4: 02:fe:9e:70:7a:2b -> 26:a5:f6:9c:3a:36
2781 * 172.16.2.0/24
2782 * unicast-ip4-chain
2783 * [@0]: dpo-load-balance: [index:19 buckets:1 uRPF:18 to:[0:0]]
2784 * [0] [@4]: ipv4-glean: af_packet1
2785 * 172.16.2.1/32
2786 * unicast-ip4-chain
2787 * [@0]: dpo-load-balance: [index:20 buckets:1 uRPF:19 to:[0:0]]
2788 * [0] [@2]: dpo-receive: 172.16.2.1 on af_packet1
2789 * 224.0.0.0/8
2790 * unicast-ip4-chain
2791 * [@0]: dpo-load-balance: [index:15 buckets:1 uRPF:14 to:[0:0]]
2792 * [0] [@0]: dpo-drop ip6
2793 * 240.0.0.0/8
2794 * unicast-ip4-chain
2795 * [@0]: dpo-load-balance: [index:14 buckets:1 uRPF:13 to:[0:0]]
2796 * [0] [@0]: dpo-drop ip6
2797 * 255.255.255.255/32
2798 * unicast-ip4-chain
2799 * [@0]: dpo-load-balance: [index:16 buckets:1 uRPF:15 to:[0:0]]
2800 * [0] [@0]: dpo-drop ip6
Billy McFall0683c9c2016-10-13 08:27:31 -04002801 * @cliexend
2802?*/
2803/* *INDENT-OFF* */
Dave Barachd7cb1b52016-12-09 09:52:16 -05002804VLIB_CLI_COMMAND (set_ip_flow_hash_command, static) =
2805{
Ed Warnickecb9cada2015-12-08 15:45:58 -07002806 .path = "set ip flow-hash",
Dave Barach75fc8542016-10-11 16:16:02 -04002807 .short_help =
Billy McFall0683c9c2016-10-13 08:27:31 -04002808 "set ip flow-hash table <table-id> [src] [dst] [sport] [dport] [proto] [reverse]",
Ed Warnickecb9cada2015-12-08 15:45:58 -07002809 .function = set_ip_flow_hash_command_fn,
2810};
Billy McFall0683c9c2016-10-13 08:27:31 -04002811/* *INDENT-ON* */
Dave Barach75fc8542016-10-11 16:16:02 -04002812
Damjan Marionc9dad5d2018-08-11 22:10:29 +02002813#ifndef CLIB_MARCH_VARIANT
Dave Barachd7cb1b52016-12-09 09:52:16 -05002814int
2815vnet_set_ip4_classify_intfc (vlib_main_t * vm, u32 sw_if_index,
2816 u32 table_index)
Ed Warnickecb9cada2015-12-08 15:45:58 -07002817{
Dave Barachd7cb1b52016-12-09 09:52:16 -05002818 vnet_main_t *vnm = vnet_get_main ();
2819 vnet_interface_main_t *im = &vnm->interface_main;
2820 ip4_main_t *ipm = &ip4_main;
2821 ip_lookup_main_t *lm = &ipm->lookup_main;
2822 vnet_classify_main_t *cm = &vnet_classify_main;
Neale Rannsdf089a82016-10-02 16:39:06 +01002823 ip4_address_t *if_addr;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002824
2825 if (pool_is_free_index (im->sw_interfaces, sw_if_index))
2826 return VNET_API_ERROR_NO_MATCHING_INTERFACE;
2827
2828 if (table_index != ~0 && pool_is_free_index (cm->tables, table_index))
2829 return VNET_API_ERROR_NO_SUCH_ENTRY;
2830
2831 vec_validate (lm->classify_table_index_by_sw_if_index, sw_if_index);
Dave Barachd7cb1b52016-12-09 09:52:16 -05002832 lm->classify_table_index_by_sw_if_index[sw_if_index] = table_index;
Ed Warnickecb9cada2015-12-08 15:45:58 -07002833
Neale Rannsdf089a82016-10-02 16:39:06 +01002834 if_addr = ip4_interface_first_address (ipm, sw_if_index, NULL);
2835
2836 if (NULL != if_addr)
Dave Barachd7cb1b52016-12-09 09:52:16 -05002837 {
Neale Rannsdf089a82016-10-02 16:39:06 +01002838 fib_prefix_t pfx = {
Dave Barachd7cb1b52016-12-09 09:52:16 -05002839 .fp_len = 32,
2840 .fp_proto = FIB_PROTOCOL_IP4,
2841 .fp_addr.ip4 = *if_addr,
Neale Rannsdf089a82016-10-02 16:39:06 +01002842 };
2843 u32 fib_index;
2844
Dave Barachd7cb1b52016-12-09 09:52:16 -05002845 fib_index = fib_table_get_index_for_sw_if_index (FIB_PROTOCOL_IP4,
2846 sw_if_index);
Neale Rannsdf089a82016-10-02 16:39:06 +01002847
2848
Dave Barachd7cb1b52016-12-09 09:52:16 -05002849 if (table_index != (u32) ~ 0)
2850 {
2851 dpo_id_t dpo = DPO_INVALID;
Neale Rannsdf089a82016-10-02 16:39:06 +01002852
Dave Barachd7cb1b52016-12-09 09:52:16 -05002853 dpo_set (&dpo,
2854 DPO_CLASSIFY,
2855 DPO_PROTO_IP4,
2856 classify_dpo_create (DPO_PROTO_IP4, table_index));
Neale Rannsdf089a82016-10-02 16:39:06 +01002857
Dave Barachd7cb1b52016-12-09 09:52:16 -05002858 fib_table_entry_special_dpo_add (fib_index,
2859 &pfx,
2860 FIB_SOURCE_CLASSIFY,
2861 FIB_ENTRY_FLAG_NONE, &dpo);
2862 dpo_reset (&dpo);
2863 }
Neale Rannsdf089a82016-10-02 16:39:06 +01002864 else
Dave Barachd7cb1b52016-12-09 09:52:16 -05002865 {
2866 fib_table_entry_special_remove (fib_index,
2867 &pfx, FIB_SOURCE_CLASSIFY);
2868 }
2869 }
Neale Rannsdf089a82016-10-02 16:39:06 +01002870
Ed Warnickecb9cada2015-12-08 15:45:58 -07002871 return 0;
2872}
Damjan Marionc9dad5d2018-08-11 22:10:29 +02002873#endif
Ed Warnickecb9cada2015-12-08 15:45:58 -07002874
2875static clib_error_t *
2876set_ip_classify_command_fn (vlib_main_t * vm,
Dave Barachd7cb1b52016-12-09 09:52:16 -05002877 unformat_input_t * input,
2878 vlib_cli_command_t * cmd)
Ed Warnickecb9cada2015-12-08 15:45:58 -07002879{
2880 u32 table_index = ~0;
2881 int table_index_set = 0;
2882 u32 sw_if_index = ~0;
2883 int rv;
Dave Barach75fc8542016-10-11 16:16:02 -04002884
Dave Barachd7cb1b52016-12-09 09:52:16 -05002885 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2886 {
2887 if (unformat (input, "table-index %d", &table_index))
2888 table_index_set = 1;
2889 else if (unformat (input, "intfc %U", unformat_vnet_sw_interface,
2890 vnet_get_main (), &sw_if_index))
2891 ;
2892 else
2893 break;
2894 }
Dave Barach75fc8542016-10-11 16:16:02 -04002895
Ed Warnickecb9cada2015-12-08 15:45:58 -07002896 if (table_index_set == 0)
2897 return clib_error_return (0, "classify table-index must be specified");
2898
2899 if (sw_if_index == ~0)
2900 return clib_error_return (0, "interface / subif must be specified");
2901
2902 rv = vnet_set_ip4_classify_intfc (vm, sw_if_index, table_index);
2903
2904 switch (rv)
2905 {
2906 case 0:
2907 break;
2908
2909 case VNET_API_ERROR_NO_MATCHING_INTERFACE:
2910 return clib_error_return (0, "No such interface");
2911
2912 case VNET_API_ERROR_NO_SUCH_ENTRY:
2913 return clib_error_return (0, "No such classifier table");
2914 }
2915 return 0;
2916}
2917
Billy McFall0683c9c2016-10-13 08:27:31 -04002918/*?
2919 * Assign a classification table to an interface. The classification
2920 * table is created using the '<em>classify table</em>' and '<em>classify session</em>'
2921 * commands. Once the table is create, use this command to filter packets
2922 * on an interface.
2923 *
2924 * @cliexpar
2925 * Example of how to assign a classification table to an interface:
2926 * @cliexcmd{set ip classify intfc GigabitEthernet2/0/0 table-index 1}
2927?*/
2928/* *INDENT-OFF* */
Dave Barachd7cb1b52016-12-09 09:52:16 -05002929VLIB_CLI_COMMAND (set_ip_classify_command, static) =
2930{
Ed Warnickecb9cada2015-12-08 15:45:58 -07002931 .path = "set ip classify",
Dave Barach75fc8542016-10-11 16:16:02 -04002932 .short_help =
Billy McFall0683c9c2016-10-13 08:27:31 -04002933 "set ip classify intfc <interface> table-index <classify-idx>",
Ed Warnickecb9cada2015-12-08 15:45:58 -07002934 .function = set_ip_classify_command_fn,
2935};
Billy McFall0683c9c2016-10-13 08:27:31 -04002936/* *INDENT-ON* */
Dave Barachd7cb1b52016-12-09 09:52:16 -05002937
Neale Ranns1ec36522017-11-29 05:20:37 -08002938static clib_error_t *
2939ip4_config (vlib_main_t * vm, unformat_input_t * input)
2940{
2941 ip4_main_t *im = &ip4_main;
2942 uword heapsize = 0;
2943
2944 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2945 {
2946 if (unformat (input, "heap-size %U", unformat_memory_size, &heapsize))
2947 ;
2948 else
2949 return clib_error_return (0,
2950 "invalid heap-size parameter `%U'",
2951 format_unformat_error, input);
2952 }
2953
2954 im->mtrie_heap_size = heapsize;
2955
2956 return 0;
2957}
2958
2959VLIB_EARLY_CONFIG_FUNCTION (ip4_config, "ip");
2960
Dave Barachd7cb1b52016-12-09 09:52:16 -05002961/*
2962 * fd.io coding-style-patch-verification: ON
2963 *
2964 * Local Variables:
2965 * eval: (c-set-style "gnu")
2966 * End:
2967 */