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:
7 * http://www.apache.org/licenses/LICENSE-2.0
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.
16 * ip/ip4_forward.c: IP v4 forwarding
18 * Copyright (c) 2008 Eliot Dresselhaus
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:
28 * The above copyright notice and this permission notice shall be
29 * included in all copies or substantial portions of the Software.
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.
40 #include <vnet/vnet.h>
41 #include <vnet/ip/ip.h>
42 #include <vnet/ethernet/ethernet.h> /* for ethernet_header_t */
43 #include <vnet/ethernet/arp_packet.h> /* for ethernet_arp_header_t */
44 #include <vnet/ppp/ppp.h>
45 #include <vnet/srp/srp.h> /* for srp_hw_interface_class */
46 #include <vnet/api_errno.h> /* for API error numbers */
47 #include <vnet/fib/fib_table.h> /* for FIB table and entry creation */
48 #include <vnet/fib/fib_entry.h> /* for FIB table and entry creation */
49 #include <vnet/fib/fib_urpf_list.h> /* for FIB uRPF check */
50 #include <vnet/fib/ip4_fib.h>
51 #include <vnet/dpo/load_balance.h>
52 #include <vnet/dpo/load_balance_map.h>
53 #include <vnet/dpo/classify_dpo.h>
54 #include <vnet/mfib/mfib_table.h> /* for mFIB table and entry creation */
58 * @brief IPv4 Forwarding.
60 * This file contains the source code for IPv4 forwarding.
64 ip4_forward_next_trace (vlib_main_t * vm,
65 vlib_node_runtime_t * node,
67 vlib_rx_or_tx_t which_adj_index);
70 ip4_lookup_inline (vlib_main_t * vm,
71 vlib_node_runtime_t * node,
73 int lookup_for_responses_to_locally_received_packets)
75 ip4_main_t *im = &ip4_main;
76 vlib_combined_counter_main_t *cm = &load_balance_main.lbm_to_counters;
77 u32 n_left_from, n_left_to_next, *from, *to_next;
78 ip_lookup_next_t next;
79 u32 thread_index = vlib_get_thread_index ();
81 from = vlib_frame_vector_args (frame);
82 n_left_from = frame->n_vectors;
83 next = node->cached_next_index;
85 while (n_left_from > 0)
87 vlib_get_next_frame (vm, node, next, to_next, n_left_to_next);
89 while (n_left_from >= 8 && n_left_to_next >= 4)
91 vlib_buffer_t *p0, *p1, *p2, *p3;
92 ip4_header_t *ip0, *ip1, *ip2, *ip3;
93 ip_lookup_next_t next0, next1, next2, next3;
94 const load_balance_t *lb0, *lb1, *lb2, *lb3;
95 ip4_fib_mtrie_t *mtrie0, *mtrie1, *mtrie2, *mtrie3;
96 ip4_fib_mtrie_leaf_t leaf0, leaf1, leaf2, leaf3;
97 ip4_address_t *dst_addr0, *dst_addr1, *dst_addr2, *dst_addr3;
98 u32 pi0, fib_index0, lb_index0;
99 u32 pi1, fib_index1, lb_index1;
100 u32 pi2, fib_index2, lb_index2;
101 u32 pi3, fib_index3, lb_index3;
102 flow_hash_config_t flow_hash_config0, flow_hash_config1;
103 flow_hash_config_t flow_hash_config2, flow_hash_config3;
104 u32 hash_c0, hash_c1, hash_c2, hash_c3;
105 const dpo_id_t *dpo0, *dpo1, *dpo2, *dpo3;
107 /* Prefetch next iteration. */
109 vlib_buffer_t *p4, *p5, *p6, *p7;
111 p4 = vlib_get_buffer (vm, from[4]);
112 p5 = vlib_get_buffer (vm, from[5]);
113 p6 = vlib_get_buffer (vm, from[6]);
114 p7 = vlib_get_buffer (vm, from[7]);
116 vlib_prefetch_buffer_header (p4, LOAD);
117 vlib_prefetch_buffer_header (p5, LOAD);
118 vlib_prefetch_buffer_header (p6, LOAD);
119 vlib_prefetch_buffer_header (p7, LOAD);
121 CLIB_PREFETCH (p4->data, sizeof (ip0[0]), LOAD);
122 CLIB_PREFETCH (p5->data, sizeof (ip0[0]), LOAD);
123 CLIB_PREFETCH (p6->data, sizeof (ip0[0]), LOAD);
124 CLIB_PREFETCH (p7->data, sizeof (ip0[0]), LOAD);
127 pi0 = to_next[0] = from[0];
128 pi1 = to_next[1] = from[1];
129 pi2 = to_next[2] = from[2];
130 pi3 = to_next[3] = from[3];
137 p0 = vlib_get_buffer (vm, pi0);
138 p1 = vlib_get_buffer (vm, pi1);
139 p2 = vlib_get_buffer (vm, pi2);
140 p3 = vlib_get_buffer (vm, pi3);
142 ip0 = vlib_buffer_get_current (p0);
143 ip1 = vlib_buffer_get_current (p1);
144 ip2 = vlib_buffer_get_current (p2);
145 ip3 = vlib_buffer_get_current (p3);
147 dst_addr0 = &ip0->dst_address;
148 dst_addr1 = &ip1->dst_address;
149 dst_addr2 = &ip2->dst_address;
150 dst_addr3 = &ip3->dst_address;
153 vec_elt (im->fib_index_by_sw_if_index,
154 vnet_buffer (p0)->sw_if_index[VLIB_RX]);
156 vec_elt (im->fib_index_by_sw_if_index,
157 vnet_buffer (p1)->sw_if_index[VLIB_RX]);
159 vec_elt (im->fib_index_by_sw_if_index,
160 vnet_buffer (p2)->sw_if_index[VLIB_RX]);
162 vec_elt (im->fib_index_by_sw_if_index,
163 vnet_buffer (p3)->sw_if_index[VLIB_RX]);
165 (vnet_buffer (p0)->sw_if_index[VLIB_TX] ==
166 (u32) ~ 0) ? fib_index0 : vnet_buffer (p0)->sw_if_index[VLIB_TX];
168 (vnet_buffer (p1)->sw_if_index[VLIB_TX] ==
169 (u32) ~ 0) ? fib_index1 : vnet_buffer (p1)->sw_if_index[VLIB_TX];
171 (vnet_buffer (p2)->sw_if_index[VLIB_TX] ==
172 (u32) ~ 0) ? fib_index2 : vnet_buffer (p2)->sw_if_index[VLIB_TX];
174 (vnet_buffer (p3)->sw_if_index[VLIB_TX] ==
175 (u32) ~ 0) ? fib_index3 : vnet_buffer (p3)->sw_if_index[VLIB_TX];
178 if (!lookup_for_responses_to_locally_received_packets)
180 mtrie0 = &ip4_fib_get (fib_index0)->mtrie;
181 mtrie1 = &ip4_fib_get (fib_index1)->mtrie;
182 mtrie2 = &ip4_fib_get (fib_index2)->mtrie;
183 mtrie3 = &ip4_fib_get (fib_index3)->mtrie;
185 leaf0 = ip4_fib_mtrie_lookup_step_one (mtrie0, dst_addr0);
186 leaf1 = ip4_fib_mtrie_lookup_step_one (mtrie1, dst_addr1);
187 leaf2 = ip4_fib_mtrie_lookup_step_one (mtrie2, dst_addr2);
188 leaf3 = ip4_fib_mtrie_lookup_step_one (mtrie3, dst_addr3);
191 if (!lookup_for_responses_to_locally_received_packets)
193 leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, dst_addr0, 2);
194 leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, dst_addr1, 2);
195 leaf2 = ip4_fib_mtrie_lookup_step (mtrie2, leaf2, dst_addr2, 2);
196 leaf3 = ip4_fib_mtrie_lookup_step (mtrie3, leaf3, dst_addr3, 2);
199 if (!lookup_for_responses_to_locally_received_packets)
201 leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, dst_addr0, 3);
202 leaf1 = ip4_fib_mtrie_lookup_step (mtrie1, leaf1, dst_addr1, 3);
203 leaf2 = ip4_fib_mtrie_lookup_step (mtrie2, leaf2, dst_addr2, 3);
204 leaf3 = ip4_fib_mtrie_lookup_step (mtrie3, leaf3, dst_addr3, 3);
207 if (lookup_for_responses_to_locally_received_packets)
209 lb_index0 = vnet_buffer (p0)->ip.adj_index[VLIB_RX];
210 lb_index1 = vnet_buffer (p1)->ip.adj_index[VLIB_RX];
211 lb_index2 = vnet_buffer (p2)->ip.adj_index[VLIB_RX];
212 lb_index3 = vnet_buffer (p3)->ip.adj_index[VLIB_RX];
216 lb_index0 = ip4_fib_mtrie_leaf_get_adj_index (leaf0);
217 lb_index1 = ip4_fib_mtrie_leaf_get_adj_index (leaf1);
218 lb_index2 = ip4_fib_mtrie_leaf_get_adj_index (leaf2);
219 lb_index3 = ip4_fib_mtrie_leaf_get_adj_index (leaf3);
222 ASSERT (lb_index0 && lb_index1 && lb_index2 && lb_index3);
223 lb0 = load_balance_get (lb_index0);
224 lb1 = load_balance_get (lb_index1);
225 lb2 = load_balance_get (lb_index2);
226 lb3 = load_balance_get (lb_index3);
228 ASSERT (lb0->lb_n_buckets > 0);
229 ASSERT (is_pow2 (lb0->lb_n_buckets));
230 ASSERT (lb1->lb_n_buckets > 0);
231 ASSERT (is_pow2 (lb1->lb_n_buckets));
232 ASSERT (lb2->lb_n_buckets > 0);
233 ASSERT (is_pow2 (lb2->lb_n_buckets));
234 ASSERT (lb3->lb_n_buckets > 0);
235 ASSERT (is_pow2 (lb3->lb_n_buckets));
237 /* Use flow hash to compute multipath adjacency. */
238 hash_c0 = vnet_buffer (p0)->ip.flow_hash = 0;
239 hash_c1 = vnet_buffer (p1)->ip.flow_hash = 0;
240 hash_c2 = vnet_buffer (p2)->ip.flow_hash = 0;
241 hash_c3 = vnet_buffer (p3)->ip.flow_hash = 0;
242 if (PREDICT_FALSE (lb0->lb_n_buckets > 1))
244 flow_hash_config0 = lb0->lb_hash_config;
245 hash_c0 = vnet_buffer (p0)->ip.flow_hash =
246 ip4_compute_flow_hash (ip0, flow_hash_config0);
248 load_balance_get_fwd_bucket (lb0,
250 (lb0->lb_n_buckets_minus_1)));
254 dpo0 = load_balance_get_bucket_i (lb0, 0);
256 if (PREDICT_FALSE (lb1->lb_n_buckets > 1))
258 flow_hash_config1 = lb1->lb_hash_config;
259 hash_c1 = vnet_buffer (p1)->ip.flow_hash =
260 ip4_compute_flow_hash (ip1, flow_hash_config1);
262 load_balance_get_fwd_bucket (lb1,
264 (lb1->lb_n_buckets_minus_1)));
268 dpo1 = load_balance_get_bucket_i (lb1, 0);
270 if (PREDICT_FALSE (lb2->lb_n_buckets > 1))
272 flow_hash_config2 = lb2->lb_hash_config;
273 hash_c2 = vnet_buffer (p2)->ip.flow_hash =
274 ip4_compute_flow_hash (ip2, flow_hash_config2);
276 load_balance_get_fwd_bucket (lb2,
278 (lb2->lb_n_buckets_minus_1)));
282 dpo2 = load_balance_get_bucket_i (lb2, 0);
284 if (PREDICT_FALSE (lb3->lb_n_buckets > 1))
286 flow_hash_config3 = lb3->lb_hash_config;
287 hash_c3 = vnet_buffer (p3)->ip.flow_hash =
288 ip4_compute_flow_hash (ip3, flow_hash_config3);
290 load_balance_get_fwd_bucket (lb3,
292 (lb3->lb_n_buckets_minus_1)));
296 dpo3 = load_balance_get_bucket_i (lb3, 0);
299 next0 = dpo0->dpoi_next_node;
300 vnet_buffer (p0)->ip.adj_index[VLIB_TX] = dpo0->dpoi_index;
301 next1 = dpo1->dpoi_next_node;
302 vnet_buffer (p1)->ip.adj_index[VLIB_TX] = dpo1->dpoi_index;
303 next2 = dpo2->dpoi_next_node;
304 vnet_buffer (p2)->ip.adj_index[VLIB_TX] = dpo2->dpoi_index;
305 next3 = dpo3->dpoi_next_node;
306 vnet_buffer (p3)->ip.adj_index[VLIB_TX] = dpo3->dpoi_index;
308 vlib_increment_combined_counter
309 (cm, thread_index, lb_index0, 1,
310 vlib_buffer_length_in_chain (vm, p0));
311 vlib_increment_combined_counter
312 (cm, thread_index, lb_index1, 1,
313 vlib_buffer_length_in_chain (vm, p1));
314 vlib_increment_combined_counter
315 (cm, thread_index, lb_index2, 1,
316 vlib_buffer_length_in_chain (vm, p2));
317 vlib_increment_combined_counter
318 (cm, thread_index, lb_index3, 1,
319 vlib_buffer_length_in_chain (vm, p3));
321 vlib_validate_buffer_enqueue_x4 (vm, node, next,
322 to_next, n_left_to_next,
324 next0, next1, next2, next3);
327 while (n_left_from > 0 && n_left_to_next > 0)
331 ip_lookup_next_t next0;
332 const load_balance_t *lb0;
333 ip4_fib_mtrie_t *mtrie0;
334 ip4_fib_mtrie_leaf_t leaf0;
335 ip4_address_t *dst_addr0;
336 u32 pi0, fib_index0, lbi0;
337 flow_hash_config_t flow_hash_config0;
338 const dpo_id_t *dpo0;
344 p0 = vlib_get_buffer (vm, pi0);
346 ip0 = vlib_buffer_get_current (p0);
348 dst_addr0 = &ip0->dst_address;
351 vec_elt (im->fib_index_by_sw_if_index,
352 vnet_buffer (p0)->sw_if_index[VLIB_RX]);
354 (vnet_buffer (p0)->sw_if_index[VLIB_TX] ==
355 (u32) ~ 0) ? fib_index0 : vnet_buffer (p0)->sw_if_index[VLIB_TX];
357 if (!lookup_for_responses_to_locally_received_packets)
359 mtrie0 = &ip4_fib_get (fib_index0)->mtrie;
361 leaf0 = ip4_fib_mtrie_lookup_step_one (mtrie0, dst_addr0);
364 if (!lookup_for_responses_to_locally_received_packets)
365 leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, dst_addr0, 2);
367 if (!lookup_for_responses_to_locally_received_packets)
368 leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, dst_addr0, 3);
370 if (lookup_for_responses_to_locally_received_packets)
371 lbi0 = vnet_buffer (p0)->ip.adj_index[VLIB_RX];
374 /* Handle default route. */
375 lbi0 = ip4_fib_mtrie_leaf_get_adj_index (leaf0);
379 lb0 = load_balance_get (lbi0);
381 ASSERT (lb0->lb_n_buckets > 0);
382 ASSERT (is_pow2 (lb0->lb_n_buckets));
384 /* Use flow hash to compute multipath adjacency. */
385 hash_c0 = vnet_buffer (p0)->ip.flow_hash = 0;
386 if (PREDICT_FALSE (lb0->lb_n_buckets > 1))
388 flow_hash_config0 = lb0->lb_hash_config;
390 hash_c0 = vnet_buffer (p0)->ip.flow_hash =
391 ip4_compute_flow_hash (ip0, flow_hash_config0);
393 load_balance_get_fwd_bucket (lb0,
395 (lb0->lb_n_buckets_minus_1)));
399 dpo0 = load_balance_get_bucket_i (lb0, 0);
402 next0 = dpo0->dpoi_next_node;
403 vnet_buffer (p0)->ip.adj_index[VLIB_TX] = dpo0->dpoi_index;
405 vlib_increment_combined_counter (cm, thread_index, lbi0, 1,
406 vlib_buffer_length_in_chain (vm,
414 if (PREDICT_FALSE (next0 != next))
417 vlib_put_next_frame (vm, node, next, n_left_to_next);
419 vlib_get_next_frame (vm, node, next, to_next, n_left_to_next);
426 vlib_put_next_frame (vm, node, next, n_left_to_next);
429 if (node->flags & VLIB_NODE_FLAG_TRACE)
430 ip4_forward_next_trace (vm, node, frame, VLIB_TX);
432 return frame->n_vectors;
435 /** @brief IPv4 lookup node.
438 This is the main IPv4 lookup dispatch node.
440 @param vm vlib_main_t corresponding to the current thread
441 @param node vlib_node_runtime_t
442 @param frame vlib_frame_t whose contents should be dispatched
444 @par Graph mechanics: buffer metadata, next index usage
447 - <code>vnet_buffer(b)->sw_if_index[VLIB_RX]</code>
448 - Indicates the @c sw_if_index value of the interface that the
449 packet was received on.
450 - <code>vnet_buffer(b)->sw_if_index[VLIB_TX]</code>
451 - When the value is @c ~0 then the node performs a longest prefix
452 match (LPM) for the packet destination address in the FIB attached
453 to the receive interface.
454 - Otherwise perform LPM for the packet destination address in the
455 indicated FIB. In this case <code>[VLIB_TX]</code> is a FIB index
456 value (0, 1, ...) and not a VRF id.
459 - <code>vnet_buffer(b)->ip.adj_index[VLIB_TX]</code>
460 - The lookup result adjacency index.
463 - Dispatches the packet to the node index found in
464 ip_adjacency_t @c adj->lookup_next_index
465 (where @c adj is the lookup result adjacency).
468 ip4_lookup (vlib_main_t * vm,
469 vlib_node_runtime_t * node, vlib_frame_t * frame)
471 return ip4_lookup_inline (vm, node, frame,
472 /* lookup_for_responses_to_locally_received_packets */
477 static u8 *format_ip4_lookup_trace (u8 * s, va_list * args);
479 VLIB_REGISTER_NODE (ip4_lookup_node) =
481 .function = ip4_lookup,.name = "ip4-lookup",.vector_size =
482 sizeof (u32),.format_trace = format_ip4_lookup_trace,.n_next_nodes =
483 IP_LOOKUP_N_NEXT,.next_nodes = IP4_LOOKUP_NEXT_NODES,};
485 VLIB_NODE_FUNCTION_MULTIARCH (ip4_lookup_node, ip4_lookup);
488 ip4_load_balance (vlib_main_t * vm,
489 vlib_node_runtime_t * node, vlib_frame_t * frame)
491 vlib_combined_counter_main_t *cm = &load_balance_main.lbm_via_counters;
492 u32 n_left_from, n_left_to_next, *from, *to_next;
493 ip_lookup_next_t next;
494 u32 thread_index = vlib_get_thread_index ();
496 from = vlib_frame_vector_args (frame);
497 n_left_from = frame->n_vectors;
498 next = node->cached_next_index;
500 if (node->flags & VLIB_NODE_FLAG_TRACE)
501 ip4_forward_next_trace (vm, node, frame, VLIB_TX);
503 while (n_left_from > 0)
505 vlib_get_next_frame (vm, node, next, to_next, n_left_to_next);
508 while (n_left_from >= 4 && n_left_to_next >= 2)
510 ip_lookup_next_t next0, next1;
511 const load_balance_t *lb0, *lb1;
512 vlib_buffer_t *p0, *p1;
513 u32 pi0, lbi0, hc0, pi1, lbi1, hc1;
514 const ip4_header_t *ip0, *ip1;
515 const dpo_id_t *dpo0, *dpo1;
517 /* Prefetch next iteration. */
519 vlib_buffer_t *p2, *p3;
521 p2 = vlib_get_buffer (vm, from[2]);
522 p3 = vlib_get_buffer (vm, from[3]);
524 vlib_prefetch_buffer_header (p2, STORE);
525 vlib_prefetch_buffer_header (p3, STORE);
527 CLIB_PREFETCH (p2->data, sizeof (ip0[0]), STORE);
528 CLIB_PREFETCH (p3->data, sizeof (ip0[0]), STORE);
531 pi0 = to_next[0] = from[0];
532 pi1 = to_next[1] = from[1];
539 p0 = vlib_get_buffer (vm, pi0);
540 p1 = vlib_get_buffer (vm, pi1);
542 ip0 = vlib_buffer_get_current (p0);
543 ip1 = vlib_buffer_get_current (p1);
544 lbi0 = vnet_buffer (p0)->ip.adj_index[VLIB_TX];
545 lbi1 = vnet_buffer (p1)->ip.adj_index[VLIB_TX];
547 lb0 = load_balance_get (lbi0);
548 lb1 = load_balance_get (lbi1);
551 * this node is for via FIBs we can re-use the hash value from the
552 * to node if present.
553 * We don't want to use the same hash value at each level in the recursion
554 * graph as that would lead to polarisation
558 if (PREDICT_FALSE (lb0->lb_n_buckets > 1))
560 if (PREDICT_TRUE (vnet_buffer (p0)->ip.flow_hash))
562 hc0 = vnet_buffer (p0)->ip.flow_hash =
563 vnet_buffer (p0)->ip.flow_hash >> 1;
567 hc0 = vnet_buffer (p0)->ip.flow_hash =
568 ip4_compute_flow_hash (ip0, lb0->lb_hash_config);
570 dpo0 = load_balance_get_fwd_bucket
571 (lb0, (hc0 & (lb0->lb_n_buckets_minus_1)));
575 dpo0 = load_balance_get_bucket_i (lb0, 0);
577 if (PREDICT_FALSE (lb1->lb_n_buckets > 1))
579 if (PREDICT_TRUE (vnet_buffer (p1)->ip.flow_hash))
581 hc1 = vnet_buffer (p1)->ip.flow_hash =
582 vnet_buffer (p1)->ip.flow_hash >> 1;
586 hc1 = vnet_buffer (p1)->ip.flow_hash =
587 ip4_compute_flow_hash (ip1, lb1->lb_hash_config);
589 dpo1 = load_balance_get_fwd_bucket
590 (lb1, (hc1 & (lb1->lb_n_buckets_minus_1)));
594 dpo1 = load_balance_get_bucket_i (lb1, 0);
597 next0 = dpo0->dpoi_next_node;
598 next1 = dpo1->dpoi_next_node;
600 vnet_buffer (p0)->ip.adj_index[VLIB_TX] = dpo0->dpoi_index;
601 vnet_buffer (p1)->ip.adj_index[VLIB_TX] = dpo1->dpoi_index;
603 vlib_increment_combined_counter
604 (cm, thread_index, lbi0, 1, vlib_buffer_length_in_chain (vm, p0));
605 vlib_increment_combined_counter
606 (cm, thread_index, lbi1, 1, vlib_buffer_length_in_chain (vm, p1));
608 vlib_validate_buffer_enqueue_x2 (vm, node, next,
609 to_next, n_left_to_next,
610 pi0, pi1, next0, next1);
613 while (n_left_from > 0 && n_left_to_next > 0)
615 ip_lookup_next_t next0;
616 const load_balance_t *lb0;
619 const ip4_header_t *ip0;
620 const dpo_id_t *dpo0;
629 p0 = vlib_get_buffer (vm, pi0);
631 ip0 = vlib_buffer_get_current (p0);
632 lbi0 = vnet_buffer (p0)->ip.adj_index[VLIB_TX];
634 lb0 = load_balance_get (lbi0);
637 if (PREDICT_FALSE (lb0->lb_n_buckets > 1))
639 if (PREDICT_TRUE (vnet_buffer (p0)->ip.flow_hash))
641 hc0 = vnet_buffer (p0)->ip.flow_hash =
642 vnet_buffer (p0)->ip.flow_hash >> 1;
646 hc0 = vnet_buffer (p0)->ip.flow_hash =
647 ip4_compute_flow_hash (ip0, lb0->lb_hash_config);
649 dpo0 = load_balance_get_fwd_bucket
650 (lb0, (hc0 & (lb0->lb_n_buckets_minus_1)));
654 dpo0 = load_balance_get_bucket_i (lb0, 0);
657 next0 = dpo0->dpoi_next_node;
658 vnet_buffer (p0)->ip.adj_index[VLIB_TX] = dpo0->dpoi_index;
660 vlib_increment_combined_counter
661 (cm, thread_index, lbi0, 1, vlib_buffer_length_in_chain (vm, p0));
663 vlib_validate_buffer_enqueue_x1 (vm, node, next,
664 to_next, n_left_to_next,
668 vlib_put_next_frame (vm, node, next, n_left_to_next);
671 return frame->n_vectors;
674 VLIB_REGISTER_NODE (ip4_load_balance_node) =
676 .function = ip4_load_balance,.name = "ip4-load-balance",.vector_size =
677 sizeof (u32),.sibling_of = "ip4-lookup",.format_trace =
678 format_ip4_lookup_trace,};
680 VLIB_NODE_FUNCTION_MULTIARCH (ip4_load_balance_node, ip4_load_balance);
682 /* get first interface address */
684 ip4_interface_first_address (ip4_main_t * im, u32 sw_if_index,
685 ip_interface_address_t ** result_ia)
687 ip_lookup_main_t *lm = &im->lookup_main;
688 ip_interface_address_t *ia = 0;
689 ip4_address_t *result = 0;
692 foreach_ip_interface_address
693 (lm, ia, sw_if_index,
694 1 /* honor unnumbered */ ,
697 ip_interface_address_get_address (lm, ia);
703 *result_ia = result ? ia : 0;
708 ip4_add_interface_routes (u32 sw_if_index,
709 ip4_main_t * im, u32 fib_index,
710 ip_interface_address_t * a)
712 ip_lookup_main_t *lm = &im->lookup_main;
713 ip4_address_t *address = ip_interface_address_get_address (lm, a);
715 .fp_len = a->address_length,
716 .fp_proto = FIB_PROTOCOL_IP4,
717 .fp_addr.ip4 = *address,
720 if (pfx.fp_len <= 30)
722 /* a /30 or shorter - add a glean for the network address */
723 fib_table_entry_update_one_path (fib_index, &pfx,
724 FIB_SOURCE_INTERFACE,
725 (FIB_ENTRY_FLAG_CONNECTED |
726 FIB_ENTRY_FLAG_ATTACHED),
728 /* No next-hop address */
734 // no out-label stack
736 FIB_ROUTE_PATH_FLAG_NONE);
738 /* Add the two broadcast addresses as drop */
739 fib_prefix_t net_pfx = {
741 .fp_proto = FIB_PROTOCOL_IP4,
742 .fp_addr.ip4.as_u32 = address->as_u32 & im->fib_masks[pfx.fp_len],
744 if (net_pfx.fp_addr.ip4.as_u32 != pfx.fp_addr.ip4.as_u32)
745 fib_table_entry_special_add(fib_index,
747 FIB_SOURCE_INTERFACE,
748 (FIB_ENTRY_FLAG_DROP |
749 FIB_ENTRY_FLAG_LOOSE_URPF_EXEMPT));
750 net_pfx.fp_addr.ip4.as_u32 |= ~im->fib_masks[pfx.fp_len];
751 if (net_pfx.fp_addr.ip4.as_u32 != pfx.fp_addr.ip4.as_u32)
752 fib_table_entry_special_add(fib_index,
754 FIB_SOURCE_INTERFACE,
755 (FIB_ENTRY_FLAG_DROP |
756 FIB_ENTRY_FLAG_LOOSE_URPF_EXEMPT));
758 else if (pfx.fp_len == 31)
760 u32 mask = clib_host_to_net_u32(1);
761 fib_prefix_t net_pfx = pfx;
764 net_pfx.fp_addr.ip4.as_u32 ^= mask;
766 /* a /31 - add the other end as an attached host */
767 fib_table_entry_update_one_path (fib_index, &net_pfx,
768 FIB_SOURCE_INTERFACE,
769 (FIB_ENTRY_FLAG_ATTACHED),
777 FIB_ROUTE_PATH_FLAG_NONE);
781 if (sw_if_index < vec_len (lm->classify_table_index_by_sw_if_index))
783 u32 classify_table_index =
784 lm->classify_table_index_by_sw_if_index[sw_if_index];
785 if (classify_table_index != (u32) ~ 0)
787 dpo_id_t dpo = DPO_INVALID;
792 classify_dpo_create (DPO_PROTO_IP4, classify_table_index));
794 fib_table_entry_special_dpo_add (fib_index,
797 FIB_ENTRY_FLAG_NONE, &dpo);
802 fib_table_entry_update_one_path (fib_index, &pfx,
803 FIB_SOURCE_INTERFACE,
804 (FIB_ENTRY_FLAG_CONNECTED |
805 FIB_ENTRY_FLAG_LOCAL),
812 FIB_ROUTE_PATH_FLAG_NONE);
816 ip4_del_interface_routes (ip4_main_t * im,
818 ip4_address_t * address, u32 address_length)
821 .fp_len = address_length,
822 .fp_proto = FIB_PROTOCOL_IP4,
823 .fp_addr.ip4 = *address,
826 if (pfx.fp_len <= 30)
828 fib_prefix_t net_pfx = {
830 .fp_proto = FIB_PROTOCOL_IP4,
831 .fp_addr.ip4.as_u32 = address->as_u32 & im->fib_masks[pfx.fp_len],
833 if (net_pfx.fp_addr.ip4.as_u32 != pfx.fp_addr.ip4.as_u32)
834 fib_table_entry_special_remove(fib_index,
836 FIB_SOURCE_INTERFACE);
837 net_pfx.fp_addr.ip4.as_u32 |= ~im->fib_masks[pfx.fp_len];
838 if (net_pfx.fp_addr.ip4.as_u32 != pfx.fp_addr.ip4.as_u32)
839 fib_table_entry_special_remove(fib_index,
841 FIB_SOURCE_INTERFACE);
842 fib_table_entry_delete (fib_index, &pfx, FIB_SOURCE_INTERFACE);
844 else if (pfx.fp_len == 31)
846 u32 mask = clib_host_to_net_u32(1);
847 fib_prefix_t net_pfx = pfx;
850 net_pfx.fp_addr.ip4.as_u32 ^= mask;
852 fib_table_entry_delete (fib_index, &net_pfx, FIB_SOURCE_INTERFACE);
856 fib_table_entry_delete (fib_index, &pfx, FIB_SOURCE_INTERFACE);
860 ip4_sw_interface_enable_disable (u32 sw_if_index, u32 is_enable)
862 ip4_main_t *im = &ip4_main;
864 vec_validate_init_empty (im->ip_enabled_by_sw_if_index, sw_if_index, 0);
867 * enable/disable only on the 1<->0 transition
871 if (1 != ++im->ip_enabled_by_sw_if_index[sw_if_index])
876 ASSERT (im->ip_enabled_by_sw_if_index[sw_if_index] > 0);
877 if (0 != --im->ip_enabled_by_sw_if_index[sw_if_index])
880 vnet_feature_enable_disable ("ip4-unicast", "ip4-drop", sw_if_index,
884 vnet_feature_enable_disable ("ip4-multicast", "ip4-drop",
885 sw_if_index, !is_enable, 0, 0);
888 static clib_error_t *
889 ip4_add_del_interface_address_internal (vlib_main_t * vm,
891 ip4_address_t * address,
892 u32 address_length, u32 is_del)
894 vnet_main_t *vnm = vnet_get_main ();
895 ip4_main_t *im = &ip4_main;
896 ip_lookup_main_t *lm = &im->lookup_main;
897 clib_error_t *error = 0;
898 u32 if_address_index, elts_before;
899 ip4_address_fib_t ip4_af, *addr_fib = 0;
901 vec_validate (im->fib_index_by_sw_if_index, sw_if_index);
902 ip4_addr_fib_init (&ip4_af, address,
903 vec_elt (im->fib_index_by_sw_if_index, sw_if_index));
904 vec_add1 (addr_fib, ip4_af);
907 * there is no support for adj-fib handling in the presence of overlapping
908 * subnets on interfaces. Easy fix - disallow overlapping subnets, like
914 /* When adding an address check that it does not conflict
915 with an existing address. */
916 ip_interface_address_t *ia;
917 foreach_ip_interface_address
918 (&im->lookup_main, ia, sw_if_index,
919 0 /* honor unnumbered */ ,
922 ip_interface_address_get_address
923 (&im->lookup_main, ia);
924 if (ip4_destination_matches_route
925 (im, address, x, ia->address_length) ||
926 ip4_destination_matches_route (im,
932 ("failed to add %U which conflicts with %U for interface %U",
933 format_ip4_address_and_length, address,
935 format_ip4_address_and_length, x,
937 format_vnet_sw_if_index_name, vnm,
943 elts_before = pool_elts (lm->if_address_pool);
945 error = ip_interface_address_add_del
946 (lm, sw_if_index, addr_fib, address_length, is_del, &if_address_index);
950 ip4_sw_interface_enable_disable (sw_if_index, !is_del);
953 ip4_del_interface_routes (im, ip4_af.fib_index, address, address_length);
955 ip4_add_interface_routes (sw_if_index,
956 im, ip4_af.fib_index,
958 (lm->if_address_pool, if_address_index));
960 /* If pool did not grow/shrink: add duplicate address. */
961 if (elts_before != pool_elts (lm->if_address_pool))
963 ip4_add_del_interface_address_callback_t *cb;
964 vec_foreach (cb, im->add_del_interface_address_callbacks)
965 cb->function (im, cb->function_opaque, sw_if_index,
966 address, address_length, if_address_index, is_del);
975 ip4_add_del_interface_address (vlib_main_t * vm,
977 ip4_address_t * address,
978 u32 address_length, u32 is_del)
980 return ip4_add_del_interface_address_internal
981 (vm, sw_if_index, address, address_length, is_del);
984 /* Built-in ip4 unicast rx feature path definition */
986 VNET_FEATURE_ARC_INIT (ip4_unicast, static) =
988 .arc_name = "ip4-unicast",
989 .start_nodes = VNET_FEATURES ("ip4-input", "ip4-input-no-checksum"),
990 .arc_index_ptr = &ip4_main.lookup_main.ucast_feature_arc_index,
993 VNET_FEATURE_INIT (ip4_flow_classify, static) =
995 .arc_name = "ip4-unicast",
996 .node_name = "ip4-flow-classify",
997 .runs_before = VNET_FEATURES ("ip4-inacl"),
1000 VNET_FEATURE_INIT (ip4_inacl, static) =
1002 .arc_name = "ip4-unicast",
1003 .node_name = "ip4-inacl",
1004 .runs_before = VNET_FEATURES ("ip4-source-check-via-rx"),
1007 VNET_FEATURE_INIT (ip4_source_check_1, static) =
1009 .arc_name = "ip4-unicast",
1010 .node_name = "ip4-source-check-via-rx",
1011 .runs_before = VNET_FEATURES ("ip4-source-check-via-any"),
1014 VNET_FEATURE_INIT (ip4_source_check_2, static) =
1016 .arc_name = "ip4-unicast",
1017 .node_name = "ip4-source-check-via-any",
1018 .runs_before = VNET_FEATURES ("ip4-policer-classify"),
1021 VNET_FEATURE_INIT (ip4_source_and_port_range_check_rx, static) =
1023 .arc_name = "ip4-unicast",
1024 .node_name = "ip4-source-and-port-range-check-rx",
1025 .runs_before = VNET_FEATURES ("ip4-policer-classify"),
1028 VNET_FEATURE_INIT (ip4_policer_classify, static) =
1030 .arc_name = "ip4-unicast",
1031 .node_name = "ip4-policer-classify",
1032 .runs_before = VNET_FEATURES ("ipsec-input-ip4"),
1035 VNET_FEATURE_INIT (ip4_ipsec, static) =
1037 .arc_name = "ip4-unicast",
1038 .node_name = "ipsec-input-ip4",
1039 .runs_before = VNET_FEATURES ("vpath-input-ip4"),
1042 VNET_FEATURE_INIT (ip4_vpath, static) =
1044 .arc_name = "ip4-unicast",
1045 .node_name = "vpath-input-ip4",
1046 .runs_before = VNET_FEATURES ("ip4-vxlan-bypass"),
1049 VNET_FEATURE_INIT (ip4_vxlan_bypass, static) =
1051 .arc_name = "ip4-unicast",
1052 .node_name = "ip4-vxlan-bypass",
1053 .runs_before = VNET_FEATURES ("ip4-lookup"),
1056 VNET_FEATURE_INIT (ip4_drop, static) =
1058 .arc_name = "ip4-unicast",
1059 .node_name = "ip4-drop",
1060 .runs_before = VNET_FEATURES ("ip4-lookup"),
1063 VNET_FEATURE_INIT (ip4_lookup, static) =
1065 .arc_name = "ip4-unicast",
1066 .node_name = "ip4-lookup",
1067 .runs_before = 0, /* not before any other features */
1070 /* Built-in ip4 multicast rx feature path definition */
1071 VNET_FEATURE_ARC_INIT (ip4_multicast, static) =
1073 .arc_name = "ip4-multicast",
1074 .start_nodes = VNET_FEATURES ("ip4-input", "ip4-input-no-checksum"),
1075 .arc_index_ptr = &ip4_main.lookup_main.mcast_feature_arc_index,
1078 VNET_FEATURE_INIT (ip4_vpath_mc, static) =
1080 .arc_name = "ip4-multicast",
1081 .node_name = "vpath-input-ip4",
1082 .runs_before = VNET_FEATURES ("ip4-mfib-forward-lookup"),
1085 VNET_FEATURE_INIT (ip4_mc_drop, static) =
1087 .arc_name = "ip4-multicast",
1088 .node_name = "ip4-drop",
1089 .runs_before = VNET_FEATURES ("ip4-mfib-forward-lookup"),
1092 VNET_FEATURE_INIT (ip4_lookup_mc, static) =
1094 .arc_name = "ip4-multicast",
1095 .node_name = "ip4-mfib-forward-lookup",
1096 .runs_before = 0, /* last feature */
1099 /* Source and port-range check ip4 tx feature path definition */
1100 VNET_FEATURE_ARC_INIT (ip4_output, static) =
1102 .arc_name = "ip4-output",
1103 .start_nodes = VNET_FEATURES ("ip4-rewrite", "ip4-midchain"),
1104 .arc_index_ptr = &ip4_main.lookup_main.output_feature_arc_index,
1107 VNET_FEATURE_INIT (ip4_source_and_port_range_check_tx, static) =
1109 .arc_name = "ip4-output",
1110 .node_name = "ip4-source-and-port-range-check-tx",
1111 .runs_before = VNET_FEATURES ("ipsec-output-ip4"),
1114 VNET_FEATURE_INIT (ip4_ipsec_output, static) =
1116 .arc_name = "ip4-output",
1117 .node_name = "ipsec-output-ip4",
1118 .runs_before = VNET_FEATURES ("interface-output"),
1121 /* Built-in ip4 tx feature path definition */
1122 VNET_FEATURE_INIT (ip4_interface_output, static) =
1124 .arc_name = "ip4-output",
1125 .node_name = "interface-output",
1126 .runs_before = 0, /* not before any other features */
1130 static clib_error_t *
1131 ip4_sw_interface_add_del (vnet_main_t * vnm, u32 sw_if_index, u32 is_add)
1133 ip4_main_t *im = &ip4_main;
1135 /* Fill in lookup tables with default table (0). */
1136 vec_validate (im->fib_index_by_sw_if_index, sw_if_index);
1137 vec_validate (im->mfib_index_by_sw_if_index, sw_if_index);
1141 ip4_main_t *im4 = &ip4_main;
1142 ip_lookup_main_t *lm4 = &im4->lookup_main;
1143 ip_interface_address_t *ia = 0;
1144 ip4_address_t *address;
1145 vlib_main_t *vm = vlib_get_main ();
1148 foreach_ip_interface_address (lm4, ia, sw_if_index, 1 /* honor unnumbered */,
1150 address = ip_interface_address_get_address (lm4, ia);
1151 ip4_add_del_interface_address(vm, sw_if_index, address, ia->address_length, 1);
1156 vnet_feature_enable_disable ("ip4-unicast", "ip4-drop", sw_if_index,
1159 vnet_feature_enable_disable ("ip4-multicast", "ip4-drop", sw_if_index,
1162 return /* no error */ 0;
1165 VNET_SW_INTERFACE_ADD_DEL_FUNCTION (ip4_sw_interface_add_del);
1167 /* Global IP4 main. */
1168 ip4_main_t ip4_main;
1171 ip4_lookup_init (vlib_main_t * vm)
1173 ip4_main_t *im = &ip4_main;
1174 clib_error_t *error;
1177 if ((error = vlib_call_init_function (vm, vnet_feature_init)))
1180 for (i = 0; i < ARRAY_LEN (im->fib_masks); i++)
1185 m = pow2_mask (i) << (32 - i);
1188 im->fib_masks[i] = clib_host_to_net_u32 (m);
1191 ip_lookup_init (&im->lookup_main, /* is_ip6 */ 0);
1193 /* Create FIB with index 0 and table id of 0. */
1194 fib_table_find_or_create_and_lock (FIB_PROTOCOL_IP4, 0);
1195 mfib_table_find_or_create_and_lock (FIB_PROTOCOL_IP4, 0);
1199 pn = pg_get_node (ip4_lookup_node.index);
1200 pn->unformat_edit = unformat_pg_ip4_header;
1204 ethernet_arp_header_t h;
1206 memset (&h, 0, sizeof (h));
1208 /* Set target ethernet address to all zeros. */
1209 memset (h.ip4_over_ethernet[1].ethernet, 0,
1210 sizeof (h.ip4_over_ethernet[1].ethernet));
1212 #define _16(f,v) h.f = clib_host_to_net_u16 (v);
1213 #define _8(f,v) h.f = v;
1214 _16 (l2_type, ETHERNET_ARP_HARDWARE_TYPE_ethernet);
1215 _16 (l3_type, ETHERNET_TYPE_IP4);
1216 _8 (n_l2_address_bytes, 6);
1217 _8 (n_l3_address_bytes, 4);
1218 _16 (opcode, ETHERNET_ARP_OPCODE_request);
1222 vlib_packet_template_init (vm, &im->ip4_arp_request_packet_template,
1225 /* alloc chunk size */ 8,
1232 VLIB_INIT_FUNCTION (ip4_lookup_init);
1236 /* Adjacency taken. */
1241 /* Packet data, possibly *after* rewrite. */
1242 u8 packet_data[64 - 1 * sizeof (u32)];
1244 ip4_forward_next_trace_t;
1247 format_ip4_forward_next_trace (u8 * s, va_list * args)
1249 CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
1250 CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
1251 ip4_forward_next_trace_t *t = va_arg (*args, ip4_forward_next_trace_t *);
1252 uword indent = format_get_indent (s);
1253 s = format (s, "%U%U",
1254 format_white_space, indent,
1255 format_ip4_header, t->packet_data, sizeof (t->packet_data));
1260 format_ip4_lookup_trace (u8 * s, va_list * args)
1262 CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
1263 CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
1264 ip4_forward_next_trace_t *t = va_arg (*args, ip4_forward_next_trace_t *);
1265 uword indent = format_get_indent (s);
1267 s = format (s, "fib %d dpo-idx %d flow hash: 0x%08x",
1268 t->fib_index, t->dpo_index, t->flow_hash);
1269 s = format (s, "\n%U%U",
1270 format_white_space, indent,
1271 format_ip4_header, t->packet_data, sizeof (t->packet_data));
1276 format_ip4_rewrite_trace (u8 * s, va_list * args)
1278 CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
1279 CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
1280 ip4_forward_next_trace_t *t = va_arg (*args, ip4_forward_next_trace_t *);
1281 uword indent = format_get_indent (s);
1283 s = format (s, "tx_sw_if_index %d dpo-idx %d : %U flow hash: 0x%08x",
1284 t->fib_index, t->dpo_index, format_ip_adjacency,
1285 t->dpo_index, FORMAT_IP_ADJACENCY_NONE, t->flow_hash);
1286 s = format (s, "\n%U%U",
1287 format_white_space, indent,
1288 format_ip_adjacency_packet_data,
1289 t->dpo_index, t->packet_data, sizeof (t->packet_data));
1293 /* Common trace function for all ip4-forward next nodes. */
1295 ip4_forward_next_trace (vlib_main_t * vm,
1296 vlib_node_runtime_t * node,
1297 vlib_frame_t * frame, vlib_rx_or_tx_t which_adj_index)
1300 ip4_main_t *im = &ip4_main;
1302 n_left = frame->n_vectors;
1303 from = vlib_frame_vector_args (frame);
1308 vlib_buffer_t *b0, *b1;
1309 ip4_forward_next_trace_t *t0, *t1;
1311 /* Prefetch next iteration. */
1312 vlib_prefetch_buffer_with_index (vm, from[2], LOAD);
1313 vlib_prefetch_buffer_with_index (vm, from[3], LOAD);
1318 b0 = vlib_get_buffer (vm, bi0);
1319 b1 = vlib_get_buffer (vm, bi1);
1321 if (b0->flags & VLIB_BUFFER_IS_TRACED)
1323 t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0]));
1324 t0->dpo_index = vnet_buffer (b0)->ip.adj_index[which_adj_index];
1325 t0->flow_hash = vnet_buffer (b0)->ip.flow_hash;
1327 (vnet_buffer (b0)->sw_if_index[VLIB_TX] !=
1328 (u32) ~ 0) ? vnet_buffer (b0)->sw_if_index[VLIB_TX] :
1329 vec_elt (im->fib_index_by_sw_if_index,
1330 vnet_buffer (b0)->sw_if_index[VLIB_RX]);
1332 clib_memcpy (t0->packet_data,
1333 vlib_buffer_get_current (b0),
1334 sizeof (t0->packet_data));
1336 if (b1->flags & VLIB_BUFFER_IS_TRACED)
1338 t1 = vlib_add_trace (vm, node, b1, sizeof (t1[0]));
1339 t1->dpo_index = vnet_buffer (b1)->ip.adj_index[which_adj_index];
1340 t1->flow_hash = vnet_buffer (b1)->ip.flow_hash;
1342 (vnet_buffer (b1)->sw_if_index[VLIB_TX] !=
1343 (u32) ~ 0) ? vnet_buffer (b1)->sw_if_index[VLIB_TX] :
1344 vec_elt (im->fib_index_by_sw_if_index,
1345 vnet_buffer (b1)->sw_if_index[VLIB_RX]);
1346 clib_memcpy (t1->packet_data, vlib_buffer_get_current (b1),
1347 sizeof (t1->packet_data));
1357 ip4_forward_next_trace_t *t0;
1361 b0 = vlib_get_buffer (vm, bi0);
1363 if (b0->flags & VLIB_BUFFER_IS_TRACED)
1365 t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0]));
1366 t0->dpo_index = vnet_buffer (b0)->ip.adj_index[which_adj_index];
1367 t0->flow_hash = vnet_buffer (b0)->ip.flow_hash;
1369 (vnet_buffer (b0)->sw_if_index[VLIB_TX] !=
1370 (u32) ~ 0) ? vnet_buffer (b0)->sw_if_index[VLIB_TX] :
1371 vec_elt (im->fib_index_by_sw_if_index,
1372 vnet_buffer (b0)->sw_if_index[VLIB_RX]);
1373 clib_memcpy (t0->packet_data, vlib_buffer_get_current (b0),
1374 sizeof (t0->packet_data));
1382 ip4_drop_or_punt (vlib_main_t * vm,
1383 vlib_node_runtime_t * node,
1384 vlib_frame_t * frame, ip4_error_t error_code)
1386 u32 *buffers = vlib_frame_vector_args (frame);
1387 uword n_packets = frame->n_vectors;
1389 vlib_error_drop_buffers (vm, node, buffers,
1393 ip4_input_node.index, error_code);
1395 if (node->flags & VLIB_NODE_FLAG_TRACE)
1396 ip4_forward_next_trace (vm, node, frame, VLIB_TX);
1402 ip4_drop (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
1404 return ip4_drop_or_punt (vm, node, frame, IP4_ERROR_ADJACENCY_DROP);
1408 ip4_punt (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
1410 return ip4_drop_or_punt (vm, node, frame, IP4_ERROR_ADJACENCY_PUNT);
1414 VLIB_REGISTER_NODE (ip4_drop_node, static) =
1416 .function = ip4_drop,
1418 .vector_size = sizeof (u32),
1419 .format_trace = format_ip4_forward_next_trace,
1426 VLIB_NODE_FUNCTION_MULTIARCH (ip4_drop_node, ip4_drop);
1428 VLIB_REGISTER_NODE (ip4_punt_node, static) =
1430 .function = ip4_punt,
1432 .vector_size = sizeof (u32),
1433 .format_trace = format_ip4_forward_next_trace,
1440 VLIB_NODE_FUNCTION_MULTIARCH (ip4_punt_node, ip4_punt);
1443 /* Compute TCP/UDP/ICMP4 checksum in software. */
1445 ip4_tcp_udp_compute_checksum (vlib_main_t * vm, vlib_buffer_t * p0,
1449 u32 ip_header_length, payload_length_host_byte_order;
1450 u32 n_this_buffer, n_bytes_left;
1452 void *data_this_buffer;
1454 /* Initialize checksum with ip header. */
1455 ip_header_length = ip4_header_bytes (ip0);
1456 payload_length_host_byte_order =
1457 clib_net_to_host_u16 (ip0->length) - ip_header_length;
1459 clib_host_to_net_u32 (payload_length_host_byte_order +
1460 (ip0->protocol << 16));
1462 if (BITS (uword) == 32)
1465 ip_csum_with_carry (sum0,
1466 clib_mem_unaligned (&ip0->src_address, u32));
1468 ip_csum_with_carry (sum0,
1469 clib_mem_unaligned (&ip0->dst_address, u32));
1473 ip_csum_with_carry (sum0, clib_mem_unaligned (&ip0->src_address, u64));
1475 n_bytes_left = n_this_buffer = payload_length_host_byte_order;
1476 data_this_buffer = (void *) ip0 + ip_header_length;
1477 if (n_this_buffer + ip_header_length > p0->current_length)
1479 p0->current_length >
1480 ip_header_length ? p0->current_length - ip_header_length : 0;
1483 sum0 = ip_incremental_checksum (sum0, data_this_buffer, n_this_buffer);
1484 n_bytes_left -= n_this_buffer;
1485 if (n_bytes_left == 0)
1488 ASSERT (p0->flags & VLIB_BUFFER_NEXT_PRESENT);
1489 p0 = vlib_get_buffer (vm, p0->next_buffer);
1490 data_this_buffer = vlib_buffer_get_current (p0);
1491 n_this_buffer = p0->current_length;
1494 sum16 = ~ip_csum_fold (sum0);
1500 ip4_tcp_udp_validate_checksum (vlib_main_t * vm, vlib_buffer_t * p0)
1502 ip4_header_t *ip0 = vlib_buffer_get_current (p0);
1506 ASSERT (ip0->protocol == IP_PROTOCOL_TCP
1507 || ip0->protocol == IP_PROTOCOL_UDP);
1509 udp0 = (void *) (ip0 + 1);
1510 if (ip0->protocol == IP_PROTOCOL_UDP && udp0->checksum == 0)
1512 p0->flags |= (VNET_BUFFER_F_L4_CHECKSUM_COMPUTED
1513 | VNET_BUFFER_F_L4_CHECKSUM_CORRECT);
1517 sum16 = ip4_tcp_udp_compute_checksum (vm, p0, ip0);
1519 p0->flags |= (VNET_BUFFER_F_L4_CHECKSUM_COMPUTED
1520 | ((sum16 == 0) << VNET_BUFFER_F_LOG2_L4_CHECKSUM_CORRECT));
1526 VNET_FEATURE_ARC_INIT (ip4_local) =
1528 .arc_name = "ip4-local",
1529 .start_nodes = VNET_FEATURES ("ip4-local"),
1534 ip4_local_inline (vlib_main_t * vm,
1535 vlib_node_runtime_t * node,
1536 vlib_frame_t * frame, int head_of_feature_arc)
1538 ip4_main_t *im = &ip4_main;
1539 ip_lookup_main_t *lm = &im->lookup_main;
1540 ip_local_next_t next_index;
1541 u32 *from, *to_next, n_left_from, n_left_to_next;
1542 vlib_node_runtime_t *error_node =
1543 vlib_node_get_runtime (vm, ip4_input_node.index);
1544 u8 arc_index = vnet_feat_arc_ip4_local.feature_arc_index;
1546 from = vlib_frame_vector_args (frame);
1547 n_left_from = frame->n_vectors;
1548 next_index = node->cached_next_index;
1550 if (node->flags & VLIB_NODE_FLAG_TRACE)
1551 ip4_forward_next_trace (vm, node, frame, VLIB_TX);
1553 while (n_left_from > 0)
1555 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
1557 while (n_left_from >= 4 && n_left_to_next >= 2)
1559 vlib_buffer_t *p0, *p1;
1560 ip4_header_t *ip0, *ip1;
1561 udp_header_t *udp0, *udp1;
1562 ip4_fib_mtrie_t *mtrie0, *mtrie1;
1563 ip4_fib_mtrie_leaf_t leaf0, leaf1;
1564 const dpo_id_t *dpo0, *dpo1;
1565 const load_balance_t *lb0, *lb1;
1566 u32 pi0, ip_len0, udp_len0, flags0, next0, fib_index0, lbi0;
1567 u32 pi1, ip_len1, udp_len1, flags1, next1, fib_index1, lbi1;
1568 i32 len_diff0, len_diff1;
1569 u8 error0, is_udp0, is_tcp_udp0, good_tcp_udp0, proto0;
1570 u8 error1, is_udp1, is_tcp_udp1, good_tcp_udp1, proto1;
1571 u32 sw_if_index0, sw_if_index1;
1573 pi0 = to_next[0] = from[0];
1574 pi1 = to_next[1] = from[1];
1578 n_left_to_next -= 2;
1580 next0 = next1 = IP_LOCAL_NEXT_DROP;
1582 p0 = vlib_get_buffer (vm, pi0);
1583 p1 = vlib_get_buffer (vm, pi1);
1585 ip0 = vlib_buffer_get_current (p0);
1586 ip1 = vlib_buffer_get_current (p1);
1588 vnet_buffer (p0)->l3_hdr_offset = p0->current_data;
1589 vnet_buffer (p1)->l3_hdr_offset = p1->current_data;
1591 sw_if_index0 = vnet_buffer (p0)->sw_if_index[VLIB_RX];
1592 sw_if_index1 = vnet_buffer (p1)->sw_if_index[VLIB_RX];
1594 fib_index0 = vec_elt (im->fib_index_by_sw_if_index, sw_if_index0);
1595 fib_index1 = vec_elt (im->fib_index_by_sw_if_index, sw_if_index1);
1597 fib_index0 = vec_elt (im->fib_index_by_sw_if_index, sw_if_index0);
1599 (vnet_buffer (p0)->sw_if_index[VLIB_TX] ==
1600 (u32) ~ 0) ? fib_index0 : vnet_buffer (p0)->sw_if_index[VLIB_TX];
1602 fib_index1 = vec_elt (im->fib_index_by_sw_if_index, sw_if_index1);
1604 (vnet_buffer (p1)->sw_if_index[VLIB_TX] ==
1605 (u32) ~ 0) ? fib_index1 : vnet_buffer (p1)->sw_if_index[VLIB_TX];
1607 mtrie0 = &ip4_fib_get (fib_index0)->mtrie;
1608 mtrie1 = &ip4_fib_get (fib_index1)->mtrie;
1610 leaf0 = ip4_fib_mtrie_lookup_step_one (mtrie0, &ip0->src_address);
1611 leaf1 = ip4_fib_mtrie_lookup_step_one (mtrie1, &ip1->src_address);
1613 /* Treat IP frag packets as "experimental" protocol for now
1614 until support of IP frag reassembly is implemented */
1615 proto0 = ip4_is_fragment (ip0) ? 0xfe : ip0->protocol;
1616 proto1 = ip4_is_fragment (ip1) ? 0xfe : ip1->protocol;
1618 if (head_of_feature_arc == 0)
1620 error0 = error1 = IP4_ERROR_UNKNOWN_PROTOCOL;
1624 is_udp0 = proto0 == IP_PROTOCOL_UDP;
1625 is_udp1 = proto1 == IP_PROTOCOL_UDP;
1626 is_tcp_udp0 = is_udp0 || proto0 == IP_PROTOCOL_TCP;
1627 is_tcp_udp1 = is_udp1 || proto1 == IP_PROTOCOL_TCP;
1632 good_tcp_udp0 = (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
1633 good_tcp_udp1 = (flags1 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
1635 udp0 = ip4_next_header (ip0);
1636 udp1 = ip4_next_header (ip1);
1638 /* Don't verify UDP checksum for packets with explicit zero checksum. */
1639 good_tcp_udp0 |= is_udp0 && udp0->checksum == 0;
1640 good_tcp_udp1 |= is_udp1 && udp1->checksum == 0;
1642 /* Verify UDP length. */
1643 ip_len0 = clib_net_to_host_u16 (ip0->length);
1644 ip_len1 = clib_net_to_host_u16 (ip1->length);
1645 udp_len0 = clib_net_to_host_u16 (udp0->length);
1646 udp_len1 = clib_net_to_host_u16 (udp1->length);
1648 len_diff0 = ip_len0 - udp_len0;
1649 len_diff1 = ip_len1 - udp_len1;
1651 len_diff0 = is_udp0 ? len_diff0 : 0;
1652 len_diff1 = is_udp1 ? len_diff1 : 0;
1654 if (PREDICT_FALSE (!(is_tcp_udp0 & is_tcp_udp1
1655 & good_tcp_udp0 & good_tcp_udp1)))
1660 && !(flags0 & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED))
1661 flags0 = ip4_tcp_udp_validate_checksum (vm, p0);
1663 (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
1664 good_tcp_udp0 |= is_udp0 && udp0->checksum == 0;
1669 && !(flags1 & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED))
1670 flags1 = ip4_tcp_udp_validate_checksum (vm, p1);
1672 (flags1 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
1673 good_tcp_udp1 |= is_udp1 && udp1->checksum == 0;
1677 good_tcp_udp0 &= len_diff0 >= 0;
1678 good_tcp_udp1 &= len_diff1 >= 0;
1681 ip4_fib_mtrie_lookup_step (mtrie0, leaf0, &ip0->src_address, 2);
1683 ip4_fib_mtrie_lookup_step (mtrie1, leaf1, &ip1->src_address, 2);
1685 error0 = error1 = IP4_ERROR_UNKNOWN_PROTOCOL;
1687 error0 = len_diff0 < 0 ? IP4_ERROR_UDP_LENGTH : error0;
1688 error1 = len_diff1 < 0 ? IP4_ERROR_UDP_LENGTH : error1;
1690 ASSERT (IP4_ERROR_TCP_CHECKSUM + 1 == IP4_ERROR_UDP_CHECKSUM);
1691 error0 = (is_tcp_udp0 && !good_tcp_udp0
1692 ? IP4_ERROR_TCP_CHECKSUM + is_udp0 : error0);
1693 error1 = (is_tcp_udp1 && !good_tcp_udp1
1694 ? IP4_ERROR_TCP_CHECKSUM + is_udp1 : error1);
1697 ip4_fib_mtrie_lookup_step (mtrie0, leaf0, &ip0->src_address, 3);
1699 ip4_fib_mtrie_lookup_step (mtrie1, leaf1, &ip1->src_address, 3);
1701 vnet_buffer (p0)->ip.adj_index[VLIB_RX] = lbi0 =
1702 ip4_fib_mtrie_leaf_get_adj_index (leaf0);
1703 vnet_buffer (p0)->ip.adj_index[VLIB_TX] = lbi0;
1705 vnet_buffer (p1)->ip.adj_index[VLIB_RX] = lbi1 =
1706 ip4_fib_mtrie_leaf_get_adj_index (leaf1);
1707 vnet_buffer (p1)->ip.adj_index[VLIB_TX] = lbi1;
1709 lb0 = load_balance_get (lbi0);
1710 lb1 = load_balance_get (lbi1);
1711 dpo0 = load_balance_get_bucket_i (lb0, 0);
1712 dpo1 = load_balance_get_bucket_i (lb1, 0);
1715 * Must have a route to source otherwise we drop the packet.
1716 * ip4 broadcasts are accepted, e.g. to make dhcp client work
1719 * - the source is a recieve => it's from us => bogus, do this
1720 * first since it sets a different error code.
1721 * - uRPF check for any route to source - accept if passes.
1722 * - allow packets destined to the broadcast address from unknown sources
1724 error0 = ((error0 == IP4_ERROR_UNKNOWN_PROTOCOL &&
1725 dpo0->dpoi_type == DPO_RECEIVE) ?
1726 IP4_ERROR_SPOOFED_LOCAL_PACKETS : error0);
1727 error0 = ((error0 == IP4_ERROR_UNKNOWN_PROTOCOL &&
1728 !fib_urpf_check_size (lb0->lb_urpf) &&
1729 ip0->dst_address.as_u32 != 0xFFFFFFFF)
1730 ? IP4_ERROR_SRC_LOOKUP_MISS : error0);
1731 error1 = ((error1 == IP4_ERROR_UNKNOWN_PROTOCOL &&
1732 dpo1->dpoi_type == DPO_RECEIVE) ?
1733 IP4_ERROR_SPOOFED_LOCAL_PACKETS : error1);
1734 error1 = ((error1 == IP4_ERROR_UNKNOWN_PROTOCOL &&
1735 !fib_urpf_check_size (lb1->lb_urpf) &&
1736 ip1->dst_address.as_u32 != 0xFFFFFFFF)
1737 ? IP4_ERROR_SRC_LOOKUP_MISS : error1);
1741 next0 = lm->local_next_by_ip_protocol[proto0];
1742 next1 = lm->local_next_by_ip_protocol[proto1];
1745 error0 != IP4_ERROR_UNKNOWN_PROTOCOL ? IP_LOCAL_NEXT_DROP : next0;
1747 error1 != IP4_ERROR_UNKNOWN_PROTOCOL ? IP_LOCAL_NEXT_DROP : next1;
1749 p0->error = error0 ? error_node->errors[error0] : 0;
1750 p1->error = error1 ? error_node->errors[error1] : 0;
1752 if (head_of_feature_arc)
1754 if (PREDICT_TRUE (error0 == (u8) IP4_ERROR_UNKNOWN_PROTOCOL))
1755 vnet_feature_arc_start (arc_index, sw_if_index0, &next0, p0);
1756 if (PREDICT_TRUE (error1 == (u8) IP4_ERROR_UNKNOWN_PROTOCOL))
1757 vnet_feature_arc_start (arc_index, sw_if_index1, &next1, p1);
1760 vlib_validate_buffer_enqueue_x2 (vm, node, next_index, to_next,
1761 n_left_to_next, pi0, pi1,
1765 while (n_left_from > 0 && n_left_to_next > 0)
1770 ip4_fib_mtrie_t *mtrie0;
1771 ip4_fib_mtrie_leaf_t leaf0;
1772 u32 pi0, next0, ip_len0, udp_len0, flags0, fib_index0, lbi0;
1774 u8 error0, is_udp0, is_tcp_udp0, good_tcp_udp0, proto0;
1775 load_balance_t *lb0;
1776 const dpo_id_t *dpo0;
1779 pi0 = to_next[0] = from[0];
1783 n_left_to_next -= 1;
1785 next0 = IP_LOCAL_NEXT_DROP;
1787 p0 = vlib_get_buffer (vm, pi0);
1789 ip0 = vlib_buffer_get_current (p0);
1791 vnet_buffer (p0)->l3_hdr_offset = p0->current_data;
1793 sw_if_index0 = vnet_buffer (p0)->sw_if_index[VLIB_RX];
1795 fib_index0 = vec_elt (im->fib_index_by_sw_if_index, sw_if_index0);
1798 (vnet_buffer (p0)->sw_if_index[VLIB_TX] ==
1799 (u32) ~ 0) ? fib_index0 : vnet_buffer (p0)->sw_if_index[VLIB_TX];
1801 mtrie0 = &ip4_fib_get (fib_index0)->mtrie;
1803 leaf0 = ip4_fib_mtrie_lookup_step_one (mtrie0, &ip0->src_address);
1805 /* Treat IP frag packets as "experimental" protocol for now
1806 until support of IP frag reassembly is implemented */
1807 proto0 = ip4_is_fragment (ip0) ? 0xfe : ip0->protocol;
1809 if (head_of_feature_arc == 0)
1811 error0 = IP4_ERROR_UNKNOWN_PROTOCOL;
1815 is_udp0 = proto0 == IP_PROTOCOL_UDP;
1816 is_tcp_udp0 = is_udp0 || proto0 == IP_PROTOCOL_TCP;
1820 good_tcp_udp0 = (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
1822 udp0 = ip4_next_header (ip0);
1824 /* Don't verify UDP checksum for packets with explicit zero checksum. */
1825 good_tcp_udp0 |= is_udp0 && udp0->checksum == 0;
1827 /* Verify UDP length. */
1828 ip_len0 = clib_net_to_host_u16 (ip0->length);
1829 udp_len0 = clib_net_to_host_u16 (udp0->length);
1831 len_diff0 = ip_len0 - udp_len0;
1833 len_diff0 = is_udp0 ? len_diff0 : 0;
1835 if (PREDICT_FALSE (!(is_tcp_udp0 & good_tcp_udp0)))
1840 && !(flags0 & VNET_BUFFER_F_L4_CHECKSUM_COMPUTED))
1841 flags0 = ip4_tcp_udp_validate_checksum (vm, p0);
1843 (flags0 & VNET_BUFFER_F_L4_CHECKSUM_CORRECT) != 0;
1844 good_tcp_udp0 |= is_udp0 && udp0->checksum == 0;
1848 good_tcp_udp0 &= len_diff0 >= 0;
1851 ip4_fib_mtrie_lookup_step (mtrie0, leaf0, &ip0->src_address, 2);
1853 error0 = IP4_ERROR_UNKNOWN_PROTOCOL;
1855 error0 = len_diff0 < 0 ? IP4_ERROR_UDP_LENGTH : error0;
1857 ASSERT (IP4_ERROR_TCP_CHECKSUM + 1 == IP4_ERROR_UDP_CHECKSUM);
1858 error0 = (is_tcp_udp0 && !good_tcp_udp0
1859 ? IP4_ERROR_TCP_CHECKSUM + is_udp0 : error0);
1862 ip4_fib_mtrie_lookup_step (mtrie0, leaf0, &ip0->src_address, 3);
1864 lbi0 = ip4_fib_mtrie_leaf_get_adj_index (leaf0);
1865 vnet_buffer (p0)->ip.adj_index[VLIB_TX] = lbi0;
1867 lb0 = load_balance_get (lbi0);
1868 dpo0 = load_balance_get_bucket_i (lb0, 0);
1870 vnet_buffer (p0)->ip.adj_index[VLIB_TX] =
1871 vnet_buffer (p0)->ip.adj_index[VLIB_RX] = lbi0;
1873 error0 = ((error0 == IP4_ERROR_UNKNOWN_PROTOCOL &&
1874 dpo0->dpoi_type == DPO_RECEIVE) ?
1875 IP4_ERROR_SPOOFED_LOCAL_PACKETS : error0);
1876 error0 = ((error0 == IP4_ERROR_UNKNOWN_PROTOCOL &&
1877 !fib_urpf_check_size (lb0->lb_urpf) &&
1878 ip0->dst_address.as_u32 != 0xFFFFFFFF)
1879 ? IP4_ERROR_SRC_LOOKUP_MISS : error0);
1883 next0 = lm->local_next_by_ip_protocol[proto0];
1886 error0 != IP4_ERROR_UNKNOWN_PROTOCOL ? IP_LOCAL_NEXT_DROP : next0;
1888 p0->error = error0 ? error_node->errors[error0] : 0;
1890 if (head_of_feature_arc)
1892 if (PREDICT_TRUE (error0 == (u8) IP4_ERROR_UNKNOWN_PROTOCOL))
1893 vnet_feature_arc_start (arc_index, sw_if_index0, &next0, p0);
1896 vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
1897 n_left_to_next, pi0, next0);
1901 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1904 return frame->n_vectors;
1908 ip4_local (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
1910 return ip4_local_inline (vm, node, frame, 1 /* head of feature arc */ );
1914 VLIB_REGISTER_NODE (ip4_local_node) =
1916 .function = ip4_local,
1917 .name = "ip4-local",
1918 .vector_size = sizeof (u32),
1919 .format_trace = format_ip4_forward_next_trace,
1920 .n_next_nodes = IP_LOCAL_N_NEXT,
1923 [IP_LOCAL_NEXT_DROP] = "error-drop",
1924 [IP_LOCAL_NEXT_PUNT] = "error-punt",
1925 [IP_LOCAL_NEXT_UDP_LOOKUP] = "ip4-udp-lookup",
1926 [IP_LOCAL_NEXT_ICMP] = "ip4-icmp-input",},
1930 VLIB_NODE_FUNCTION_MULTIARCH (ip4_local_node, ip4_local);
1933 ip4_local_end_of_arc (vlib_main_t * vm,
1934 vlib_node_runtime_t * node, vlib_frame_t * frame)
1936 return ip4_local_inline (vm, node, frame, 0 /* head of feature arc */ );
1940 VLIB_REGISTER_NODE (ip4_local_end_of_arc_node,static) = {
1941 .function = ip4_local_end_of_arc,
1942 .name = "ip4-local-end-of-arc",
1943 .vector_size = sizeof (u32),
1945 .format_trace = format_ip4_forward_next_trace,
1946 .sibling_of = "ip4-local",
1949 VLIB_NODE_FUNCTION_MULTIARCH (ip4_local_end_of_arc_node, ip4_local_end_of_arc)
1951 VNET_FEATURE_INIT (ip4_local_end_of_arc, static) = {
1952 .arc_name = "ip4-local",
1953 .node_name = "ip4-local-end-of-arc",
1954 .runs_before = 0, /* not before any other features */
1959 ip4_register_protocol (u32 protocol, u32 node_index)
1961 vlib_main_t *vm = vlib_get_main ();
1962 ip4_main_t *im = &ip4_main;
1963 ip_lookup_main_t *lm = &im->lookup_main;
1965 ASSERT (protocol < ARRAY_LEN (lm->local_next_by_ip_protocol));
1966 lm->local_next_by_ip_protocol[protocol] =
1967 vlib_node_add_next (vm, ip4_local_node.index, node_index);
1970 static clib_error_t *
1971 show_ip_local_command_fn (vlib_main_t * vm,
1972 unformat_input_t * input, vlib_cli_command_t * cmd)
1974 ip4_main_t *im = &ip4_main;
1975 ip_lookup_main_t *lm = &im->lookup_main;
1978 vlib_cli_output (vm, "Protocols handled by ip4_local");
1979 for (i = 0; i < ARRAY_LEN (lm->local_next_by_ip_protocol); i++)
1981 if (lm->local_next_by_ip_protocol[i] != IP_LOCAL_NEXT_PUNT)
1982 vlib_cli_output (vm, "%d", i);
1990 * Display the set of protocols handled by the local IPv4 stack.
1993 * Example of how to display local protocol table:
1994 * @cliexstart{show ip local}
1995 * Protocols handled by ip4_local
2002 VLIB_CLI_COMMAND (show_ip_local, static) =
2004 .path = "show ip local",
2005 .function = show_ip_local_command_fn,
2006 .short_help = "show ip local",
2011 ip4_arp_inline (vlib_main_t * vm,
2012 vlib_node_runtime_t * node,
2013 vlib_frame_t * frame, int is_glean)
2015 vnet_main_t *vnm = vnet_get_main ();
2016 ip4_main_t *im = &ip4_main;
2017 ip_lookup_main_t *lm = &im->lookup_main;
2018 u32 *from, *to_next_drop;
2019 uword n_left_from, n_left_to_next_drop, next_index;
2020 static f64 time_last_seed_change = -1e100;
2021 static u32 hash_seeds[3];
2022 static uword hash_bitmap[256 / BITS (uword)];
2025 if (node->flags & VLIB_NODE_FLAG_TRACE)
2026 ip4_forward_next_trace (vm, node, frame, VLIB_TX);
2028 time_now = vlib_time_now (vm);
2029 if (time_now - time_last_seed_change > 1e-3)
2032 u32 *r = clib_random_buffer_get_data (&vm->random_buffer,
2033 sizeof (hash_seeds));
2034 for (i = 0; i < ARRAY_LEN (hash_seeds); i++)
2035 hash_seeds[i] = r[i];
2037 /* Mark all hash keys as been no-seen before. */
2038 for (i = 0; i < ARRAY_LEN (hash_bitmap); i++)
2041 time_last_seed_change = time_now;
2044 from = vlib_frame_vector_args (frame);
2045 n_left_from = frame->n_vectors;
2046 next_index = node->cached_next_index;
2047 if (next_index == IP4_ARP_NEXT_DROP)
2048 next_index = IP4_ARP_N_NEXT; /* point to first interface */
2050 while (n_left_from > 0)
2052 vlib_get_next_frame (vm, node, IP4_ARP_NEXT_DROP,
2053 to_next_drop, n_left_to_next_drop);
2055 while (n_left_from > 0 && n_left_to_next_drop > 0)
2057 u32 pi0, adj_index0, a0, b0, c0, m0, sw_if_index0, drop0;
2058 ip_adjacency_t *adj0;
2065 p0 = vlib_get_buffer (vm, pi0);
2067 adj_index0 = vnet_buffer (p0)->ip.adj_index[VLIB_TX];
2068 adj0 = adj_get (adj_index0);
2069 ip0 = vlib_buffer_get_current (p0);
2075 sw_if_index0 = adj0->rewrite_header.sw_if_index;
2076 vnet_buffer (p0)->sw_if_index[VLIB_TX] = sw_if_index0;
2081 * this is the Glean case, so we are ARPing for the
2082 * packet's destination
2084 a0 ^= ip0->dst_address.data_u32;
2088 a0 ^= adj0->sub_type.nbr.next_hop.ip4.data_u32;
2092 hash_v3_finalize32 (a0, b0, c0);
2094 c0 &= BITS (hash_bitmap) - 1;
2095 c0 = c0 / BITS (uword);
2096 m0 = (uword) 1 << (c0 % BITS (uword));
2098 bm0 = hash_bitmap[c0];
2099 drop0 = (bm0 & m0) != 0;
2101 /* Mark it as seen. */
2102 hash_bitmap[c0] = bm0 | m0;
2106 to_next_drop[0] = pi0;
2108 n_left_to_next_drop -= 1;
2111 node->errors[drop0 ? IP4_ARP_ERROR_DROP :
2112 IP4_ARP_ERROR_REQUEST_SENT];
2115 * the adj has been updated to a rewrite but the node the DPO that got
2116 * us here hasn't - yet. no big deal. we'll drop while we wait.
2118 if (IP_LOOKUP_NEXT_REWRITE == adj0->lookup_next_index)
2125 * Can happen if the control-plane is programming tables
2126 * with traffic flowing; at least that's today's lame excuse.
2128 if ((is_glean && adj0->lookup_next_index != IP_LOOKUP_NEXT_GLEAN)
2129 || (!is_glean && adj0->lookup_next_index != IP_LOOKUP_NEXT_ARP))
2131 p0->error = node->errors[IP4_ARP_ERROR_NON_ARP_ADJ];
2134 /* Send ARP request. */
2138 ethernet_arp_header_t *h0;
2139 vnet_hw_interface_t *hw_if0;
2142 vlib_packet_template_get_packet (vm,
2143 &im->ip4_arp_request_packet_template,
2146 /* Add rewrite/encap string for ARP packet. */
2147 vnet_rewrite_one_header (adj0[0], h0,
2148 sizeof (ethernet_header_t));
2150 hw_if0 = vnet_get_sup_hw_interface (vnm, sw_if_index0);
2152 /* Src ethernet address in ARP header. */
2153 clib_memcpy (h0->ip4_over_ethernet[0].ethernet,
2155 sizeof (h0->ip4_over_ethernet[0].ethernet));
2159 /* The interface's source address is stashed in the Glean Adj */
2160 h0->ip4_over_ethernet[0].ip4 =
2161 adj0->sub_type.glean.receive_addr.ip4;
2163 /* Copy in destination address we are requesting. This is the
2164 * glean case, so it's the packet's destination.*/
2165 h0->ip4_over_ethernet[1].ip4.data_u32 =
2166 ip0->dst_address.data_u32;
2170 /* Src IP address in ARP header. */
2171 if (ip4_src_address_for_packet (lm, sw_if_index0,
2173 ip4_over_ethernet[0].ip4))
2175 /* No source address available */
2177 node->errors[IP4_ARP_ERROR_NO_SOURCE_ADDRESS];
2178 vlib_buffer_free (vm, &bi0, 1);
2182 /* Copy in destination address we are requesting from the
2184 h0->ip4_over_ethernet[1].ip4.data_u32 =
2185 adj0->sub_type.nbr.next_hop.ip4.as_u32;
2188 vlib_buffer_copy_trace_flag (vm, p0, bi0);
2189 b0 = vlib_get_buffer (vm, bi0);
2190 vnet_buffer (b0)->sw_if_index[VLIB_TX] = sw_if_index0;
2192 vlib_buffer_advance (b0, -adj0->rewrite_header.data_bytes);
2194 vlib_set_next_frame_buffer (vm, node,
2195 adj0->rewrite_header.next_index,
2200 vlib_put_next_frame (vm, node, IP4_ARP_NEXT_DROP, n_left_to_next_drop);
2203 return frame->n_vectors;
2207 ip4_arp (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
2209 return (ip4_arp_inline (vm, node, frame, 0));
2213 ip4_glean (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
2215 return (ip4_arp_inline (vm, node, frame, 1));
2218 static char *ip4_arp_error_strings[] = {
2219 [IP4_ARP_ERROR_DROP] = "address overflow drops",
2220 [IP4_ARP_ERROR_REQUEST_SENT] = "ARP requests sent",
2221 [IP4_ARP_ERROR_NON_ARP_ADJ] = "ARPs to non-ARP adjacencies",
2222 [IP4_ARP_ERROR_REPLICATE_DROP] = "ARP replication completed",
2223 [IP4_ARP_ERROR_REPLICATE_FAIL] = "ARP replication failed",
2224 [IP4_ARP_ERROR_NO_SOURCE_ADDRESS] = "no source address for ARP request",
2227 VLIB_REGISTER_NODE (ip4_arp_node) =
2229 .function = ip4_arp,.name = "ip4-arp",.vector_size =
2230 sizeof (u32),.format_trace = format_ip4_forward_next_trace,.n_errors =
2231 ARRAY_LEN (ip4_arp_error_strings),.error_strings =
2232 ip4_arp_error_strings,.n_next_nodes = IP4_ARP_N_NEXT,.next_nodes =
2234 [IP4_ARP_NEXT_DROP] = "error-drop",}
2237 VLIB_REGISTER_NODE (ip4_glean_node) =
2239 .function = ip4_glean,.name = "ip4-glean",.vector_size =
2240 sizeof (u32),.format_trace = format_ip4_forward_next_trace,.n_errors =
2241 ARRAY_LEN (ip4_arp_error_strings),.error_strings =
2242 ip4_arp_error_strings,.n_next_nodes = IP4_ARP_N_NEXT,.next_nodes =
2244 [IP4_ARP_NEXT_DROP] = "error-drop",}
2247 #define foreach_notrace_ip4_arp_error \
2254 arp_notrace_init (vlib_main_t * vm)
2256 vlib_node_runtime_t *rt = vlib_node_get_runtime (vm, ip4_arp_node.index);
2258 /* don't trace ARP request packets */
2260 vnet_pcap_drop_trace_filter_add_del \
2261 (rt->errors[IP4_ARP_ERROR_##a], \
2263 foreach_notrace_ip4_arp_error;
2268 VLIB_INIT_FUNCTION (arp_notrace_init);
2271 /* Send an ARP request to see if given destination is reachable on given interface. */
2273 ip4_probe_neighbor (vlib_main_t * vm, ip4_address_t * dst, u32 sw_if_index)
2275 vnet_main_t *vnm = vnet_get_main ();
2276 ip4_main_t *im = &ip4_main;
2277 ethernet_arp_header_t *h;
2279 ip_interface_address_t *ia;
2280 ip_adjacency_t *adj;
2281 vnet_hw_interface_t *hi;
2282 vnet_sw_interface_t *si;
2287 si = vnet_get_sw_interface (vnm, sw_if_index);
2289 if (!(si->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP))
2291 return clib_error_return (0, "%U: interface %U down",
2292 format_ip4_address, dst,
2293 format_vnet_sw_if_index_name, vnm,
2298 ip4_interface_address_matching_destination (im, dst, sw_if_index, &ia);
2301 vnm->api_errno = VNET_API_ERROR_NO_MATCHING_INTERFACE;
2302 return clib_error_return
2304 "no matching interface address for destination %U (interface %U)",
2305 format_ip4_address, dst, format_vnet_sw_if_index_name, vnm,
2309 ip46_address_t nh = {
2313 ai = adj_nbr_add_or_lock (FIB_PROTOCOL_IP4,
2314 VNET_LINK_IP4, &nh, sw_if_index);
2317 h = vlib_packet_template_get_packet (vm,
2318 &im->ip4_arp_request_packet_template,
2321 hi = vnet_get_sup_hw_interface (vnm, sw_if_index);
2323 clib_memcpy (h->ip4_over_ethernet[0].ethernet, hi->hw_address,
2324 sizeof (h->ip4_over_ethernet[0].ethernet));
2326 h->ip4_over_ethernet[0].ip4 = src[0];
2327 h->ip4_over_ethernet[1].ip4 = dst[0];
2329 b = vlib_get_buffer (vm, bi);
2330 vnet_buffer (b)->sw_if_index[VLIB_RX] =
2331 vnet_buffer (b)->sw_if_index[VLIB_TX] = sw_if_index;
2333 /* Add encapsulation string for software interface (e.g. ethernet header). */
2334 vnet_rewrite_one_header (adj[0], h, sizeof (ethernet_header_t));
2335 vlib_buffer_advance (b, -adj->rewrite_header.data_bytes);
2338 vlib_frame_t *f = vlib_get_frame_to_node (vm, hi->output_node_index);
2339 u32 *to_next = vlib_frame_vector_args (f);
2342 vlib_put_frame_to_node (vm, hi->output_node_index, f);
2346 return /* no error */ 0;
2351 IP4_REWRITE_NEXT_DROP,
2352 IP4_REWRITE_NEXT_ICMP_ERROR,
2353 } ip4_rewrite_next_t;
2356 ip4_rewrite_inline (vlib_main_t * vm,
2357 vlib_node_runtime_t * node,
2358 vlib_frame_t * frame,
2359 int do_counters, int is_midchain, int is_mcast)
2361 ip_lookup_main_t *lm = &ip4_main.lookup_main;
2362 u32 *from = vlib_frame_vector_args (frame);
2363 u32 n_left_from, n_left_to_next, *to_next, next_index;
2364 vlib_node_runtime_t *error_node =
2365 vlib_node_get_runtime (vm, ip4_input_node.index);
2367 n_left_from = frame->n_vectors;
2368 next_index = node->cached_next_index;
2369 u32 thread_index = vlib_get_thread_index ();
2371 while (n_left_from > 0)
2373 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
2375 while (n_left_from >= 4 && n_left_to_next >= 2)
2377 ip_adjacency_t *adj0, *adj1;
2378 vlib_buffer_t *p0, *p1;
2379 ip4_header_t *ip0, *ip1;
2380 u32 pi0, rw_len0, next0, error0, checksum0, adj_index0;
2381 u32 pi1, rw_len1, next1, error1, checksum1, adj_index1;
2382 u32 tx_sw_if_index0, tx_sw_if_index1;
2384 /* Prefetch next iteration. */
2386 vlib_buffer_t *p2, *p3;
2388 p2 = vlib_get_buffer (vm, from[2]);
2389 p3 = vlib_get_buffer (vm, from[3]);
2391 vlib_prefetch_buffer_header (p2, STORE);
2392 vlib_prefetch_buffer_header (p3, STORE);
2394 CLIB_PREFETCH (p2->data, sizeof (ip0[0]), STORE);
2395 CLIB_PREFETCH (p3->data, sizeof (ip0[0]), STORE);
2398 pi0 = to_next[0] = from[0];
2399 pi1 = to_next[1] = from[1];
2404 n_left_to_next -= 2;
2406 p0 = vlib_get_buffer (vm, pi0);
2407 p1 = vlib_get_buffer (vm, pi1);
2409 adj_index0 = vnet_buffer (p0)->ip.adj_index[VLIB_TX];
2410 adj_index1 = vnet_buffer (p1)->ip.adj_index[VLIB_TX];
2413 * pre-fetch the per-adjacency counters
2417 vlib_prefetch_combined_counter (&adjacency_counters,
2418 thread_index, adj_index0);
2419 vlib_prefetch_combined_counter (&adjacency_counters,
2420 thread_index, adj_index1);
2423 ip0 = vlib_buffer_get_current (p0);
2424 ip1 = vlib_buffer_get_current (p1);
2426 error0 = error1 = IP4_ERROR_NONE;
2427 next0 = next1 = IP4_REWRITE_NEXT_DROP;
2429 /* Decrement TTL & update checksum.
2430 Works either endian, so no need for byte swap. */
2431 if (PREDICT_TRUE (!(p0->flags & VNET_BUFFER_F_LOCALLY_ORIGINATED)))
2433 i32 ttl0 = ip0->ttl;
2435 /* Input node should have reject packets with ttl 0. */
2436 ASSERT (ip0->ttl > 0);
2438 checksum0 = ip0->checksum + clib_host_to_net_u16 (0x0100);
2439 checksum0 += checksum0 >= 0xffff;
2441 ip0->checksum = checksum0;
2446 * If the ttl drops below 1 when forwarding, generate
2449 if (PREDICT_FALSE (ttl0 <= 0))
2451 error0 = IP4_ERROR_TIME_EXPIRED;
2452 vnet_buffer (p0)->sw_if_index[VLIB_TX] = (u32) ~ 0;
2453 icmp4_error_set_vnet_buffer (p0, ICMP4_time_exceeded,
2454 ICMP4_time_exceeded_ttl_exceeded_in_transit,
2456 next0 = IP4_REWRITE_NEXT_ICMP_ERROR;
2459 /* Verify checksum. */
2460 ASSERT ((ip0->checksum == ip4_header_checksum (ip0)) ||
2461 (p0->flags & VNET_BUFFER_F_OFFLOAD_IP_CKSUM));
2465 p0->flags &= ~VNET_BUFFER_F_LOCALLY_ORIGINATED;
2467 if (PREDICT_TRUE (!(p1->flags & VNET_BUFFER_F_LOCALLY_ORIGINATED)))
2469 i32 ttl1 = ip1->ttl;
2471 /* Input node should have reject packets with ttl 0. */
2472 ASSERT (ip1->ttl > 0);
2474 checksum1 = ip1->checksum + clib_host_to_net_u16 (0x0100);
2475 checksum1 += checksum1 >= 0xffff;
2477 ip1->checksum = checksum1;
2482 * If the ttl drops below 1 when forwarding, generate
2485 if (PREDICT_FALSE (ttl1 <= 0))
2487 error1 = IP4_ERROR_TIME_EXPIRED;
2488 vnet_buffer (p1)->sw_if_index[VLIB_TX] = (u32) ~ 0;
2489 icmp4_error_set_vnet_buffer (p1, ICMP4_time_exceeded,
2490 ICMP4_time_exceeded_ttl_exceeded_in_transit,
2492 next1 = IP4_REWRITE_NEXT_ICMP_ERROR;
2495 /* Verify checksum. */
2496 ASSERT ((ip1->checksum == ip4_header_checksum (ip1)) ||
2497 (p1->flags & VNET_BUFFER_F_OFFLOAD_IP_CKSUM));
2501 p1->flags &= ~VNET_BUFFER_F_LOCALLY_ORIGINATED;
2504 /* Rewrite packet header and updates lengths. */
2505 adj0 = adj_get (adj_index0);
2506 adj1 = adj_get (adj_index1);
2508 /* Worth pipelining. No guarantee that adj0,1 are hot... */
2509 rw_len0 = adj0[0].rewrite_header.data_bytes;
2510 rw_len1 = adj1[0].rewrite_header.data_bytes;
2511 vnet_buffer (p0)->ip.save_rewrite_length = rw_len0;
2512 vnet_buffer (p1)->ip.save_rewrite_length = rw_len1;
2514 /* Check MTU of outgoing interface. */
2516 (vlib_buffer_length_in_chain (vm, p0) >
2518 rewrite_header.max_l3_packet_bytes ? IP4_ERROR_MTU_EXCEEDED :
2521 (vlib_buffer_length_in_chain (vm, p1) >
2523 rewrite_header.max_l3_packet_bytes ? IP4_ERROR_MTU_EXCEEDED :
2526 /* Don't adjust the buffer for ttl issue; icmp-error node wants
2527 * to see the IP headerr */
2528 if (PREDICT_TRUE (error0 == IP4_ERROR_NONE))
2530 next0 = adj0[0].rewrite_header.next_index;
2531 p0->current_data -= rw_len0;
2532 p0->current_length += rw_len0;
2533 tx_sw_if_index0 = adj0[0].rewrite_header.sw_if_index;
2534 vnet_buffer (p0)->sw_if_index[VLIB_TX] = tx_sw_if_index0;
2537 (adj0[0].rewrite_header.flags & VNET_REWRITE_HAS_FEATURES))
2538 vnet_feature_arc_start (lm->output_feature_arc_index,
2539 tx_sw_if_index0, &next0, p0);
2541 if (PREDICT_TRUE (error1 == IP4_ERROR_NONE))
2543 next1 = adj1[0].rewrite_header.next_index;
2544 p1->current_data -= rw_len1;
2545 p1->current_length += rw_len1;
2547 tx_sw_if_index1 = adj1[0].rewrite_header.sw_if_index;
2548 vnet_buffer (p1)->sw_if_index[VLIB_TX] = tx_sw_if_index1;
2551 (adj1[0].rewrite_header.flags & VNET_REWRITE_HAS_FEATURES))
2552 vnet_feature_arc_start (lm->output_feature_arc_index,
2553 tx_sw_if_index1, &next1, p1);
2556 /* Guess we are only writing on simple Ethernet header. */
2557 vnet_rewrite_two_headers (adj0[0], adj1[0],
2558 ip0, ip1, sizeof (ethernet_header_t));
2561 * Bump the per-adjacency counters
2565 vlib_increment_combined_counter
2566 (&adjacency_counters,
2569 vlib_buffer_length_in_chain (vm, p0) + rw_len0);
2571 vlib_increment_combined_counter
2572 (&adjacency_counters,
2575 vlib_buffer_length_in_chain (vm, p1) + rw_len1);
2580 adj0->sub_type.midchain.fixup_func (vm, adj0, p0);
2581 adj1->sub_type.midchain.fixup_func (vm, adj1, p1);
2586 * copy bytes from the IP address into the MAC rewrite
2588 vnet_fixup_one_header (adj0[0], &ip0->dst_address, ip0);
2589 vnet_fixup_one_header (adj1[0], &ip1->dst_address, ip1);
2592 vlib_validate_buffer_enqueue_x2 (vm, node, next_index,
2593 to_next, n_left_to_next,
2594 pi0, pi1, next0, next1);
2597 while (n_left_from > 0 && n_left_to_next > 0)
2599 ip_adjacency_t *adj0;
2602 u32 pi0, rw_len0, adj_index0, next0, error0, checksum0;
2603 u32 tx_sw_if_index0;
2605 pi0 = to_next[0] = from[0];
2607 p0 = vlib_get_buffer (vm, pi0);
2609 adj_index0 = vnet_buffer (p0)->ip.adj_index[VLIB_TX];
2611 adj0 = adj_get (adj_index0);
2613 ip0 = vlib_buffer_get_current (p0);
2615 error0 = IP4_ERROR_NONE;
2616 next0 = IP4_REWRITE_NEXT_DROP; /* drop on error */
2618 /* Decrement TTL & update checksum. */
2619 if (PREDICT_TRUE (!(p0->flags & VNET_BUFFER_F_LOCALLY_ORIGINATED)))
2621 i32 ttl0 = ip0->ttl;
2623 checksum0 = ip0->checksum + clib_host_to_net_u16 (0x0100);
2625 checksum0 += checksum0 >= 0xffff;
2627 ip0->checksum = checksum0;
2629 ASSERT (ip0->ttl > 0);
2635 ASSERT ((ip0->checksum == ip4_header_checksum (ip0)) ||
2636 (p0->flags & VNET_BUFFER_F_OFFLOAD_IP_CKSUM));
2638 if (PREDICT_FALSE (ttl0 <= 0))
2641 * If the ttl drops below 1 when forwarding, generate
2644 error0 = IP4_ERROR_TIME_EXPIRED;
2645 next0 = IP4_REWRITE_NEXT_ICMP_ERROR;
2646 vnet_buffer (p0)->sw_if_index[VLIB_TX] = (u32) ~ 0;
2647 icmp4_error_set_vnet_buffer (p0, ICMP4_time_exceeded,
2648 ICMP4_time_exceeded_ttl_exceeded_in_transit,
2654 p0->flags &= ~VNET_BUFFER_F_LOCALLY_ORIGINATED;
2658 vlib_prefetch_combined_counter (&adjacency_counters,
2659 thread_index, adj_index0);
2661 /* Guess we are only writing on simple Ethernet header. */
2662 vnet_rewrite_one_header (adj0[0], ip0, sizeof (ethernet_header_t));
2666 * copy bytes from the IP address into the MAC rewrite
2668 vnet_fixup_one_header (adj0[0], &ip0->dst_address, ip0);
2671 /* Update packet buffer attributes/set output interface. */
2672 rw_len0 = adj0[0].rewrite_header.data_bytes;
2673 vnet_buffer (p0)->ip.save_rewrite_length = rw_len0;
2676 vlib_increment_combined_counter
2677 (&adjacency_counters,
2678 thread_index, adj_index0, 1,
2679 vlib_buffer_length_in_chain (vm, p0) + rw_len0);
2681 /* Check MTU of outgoing interface. */
2682 error0 = (vlib_buffer_length_in_chain (vm, p0)
2683 > adj0[0].rewrite_header.max_l3_packet_bytes
2684 ? IP4_ERROR_MTU_EXCEEDED : error0);
2686 p0->error = error_node->errors[error0];
2688 /* Don't adjust the buffer for ttl issue; icmp-error node wants
2689 * to see the IP headerr */
2690 if (PREDICT_TRUE (error0 == IP4_ERROR_NONE))
2692 p0->current_data -= rw_len0;
2693 p0->current_length += rw_len0;
2694 tx_sw_if_index0 = adj0[0].rewrite_header.sw_if_index;
2696 vnet_buffer (p0)->sw_if_index[VLIB_TX] = tx_sw_if_index0;
2697 next0 = adj0[0].rewrite_header.next_index;
2701 adj0->sub_type.midchain.fixup_func (vm, adj0, p0);
2705 (adj0[0].rewrite_header.flags & VNET_REWRITE_HAS_FEATURES))
2706 vnet_feature_arc_start (lm->output_feature_arc_index,
2707 tx_sw_if_index0, &next0, p0);
2714 n_left_to_next -= 1;
2716 vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
2717 to_next, n_left_to_next,
2721 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
2724 /* Need to do trace after rewrites to pick up new packet data. */
2725 if (node->flags & VLIB_NODE_FLAG_TRACE)
2726 ip4_forward_next_trace (vm, node, frame, VLIB_TX);
2728 return frame->n_vectors;
2732 /** @brief IPv4 rewrite node.
2735 This is the IPv4 transit-rewrite node: decrement TTL, fix the ipv4
2736 header checksum, fetch the ip adjacency, check the outbound mtu,
2737 apply the adjacency rewrite, and send pkts to the adjacency
2738 rewrite header's rewrite_next_index.
2740 @param vm vlib_main_t corresponding to the current thread
2741 @param node vlib_node_runtime_t
2742 @param frame vlib_frame_t whose contents should be dispatched
2744 @par Graph mechanics: buffer metadata, next index usage
2747 - <code>vnet_buffer(b)->ip.adj_index[VLIB_TX]</code>
2748 - the rewrite adjacency index
2749 - <code>adj->lookup_next_index</code>
2750 - Must be IP_LOOKUP_NEXT_REWRITE or IP_LOOKUP_NEXT_ARP, otherwise
2751 the packet will be dropped.
2752 - <code>adj->rewrite_header</code>
2753 - Rewrite string length, rewrite string, next_index
2756 - <code>b->current_data, b->current_length</code>
2757 - Updated net of applying the rewrite string
2759 <em>Next Indices:</em>
2760 - <code> adj->rewrite_header.next_index </code>
2764 ip4_rewrite (vlib_main_t * vm,
2765 vlib_node_runtime_t * node, vlib_frame_t * frame)
2767 if (adj_are_counters_enabled ())
2768 return ip4_rewrite_inline (vm, node, frame, 1, 0, 0);
2770 return ip4_rewrite_inline (vm, node, frame, 0, 0, 0);
2774 ip4_midchain (vlib_main_t * vm,
2775 vlib_node_runtime_t * node, vlib_frame_t * frame)
2777 if (adj_are_counters_enabled ())
2778 return ip4_rewrite_inline (vm, node, frame, 1, 1, 0);
2780 return ip4_rewrite_inline (vm, node, frame, 0, 1, 0);
2784 ip4_rewrite_mcast (vlib_main_t * vm,
2785 vlib_node_runtime_t * node, vlib_frame_t * frame)
2787 if (adj_are_counters_enabled ())
2788 return ip4_rewrite_inline (vm, node, frame, 1, 0, 1);
2790 return ip4_rewrite_inline (vm, node, frame, 0, 0, 1);
2794 ip4_mcast_midchain (vlib_main_t * vm,
2795 vlib_node_runtime_t * node, vlib_frame_t * frame)
2797 if (adj_are_counters_enabled ())
2798 return ip4_rewrite_inline (vm, node, frame, 1, 1, 1);
2800 return ip4_rewrite_inline (vm, node, frame, 0, 1, 1);
2804 VLIB_REGISTER_NODE (ip4_rewrite_node) = {
2805 .function = ip4_rewrite,
2806 .name = "ip4-rewrite",
2807 .vector_size = sizeof (u32),
2809 .format_trace = format_ip4_rewrite_trace,
2813 [IP4_REWRITE_NEXT_DROP] = "error-drop",
2814 [IP4_REWRITE_NEXT_ICMP_ERROR] = "ip4-icmp-error",
2817 VLIB_NODE_FUNCTION_MULTIARCH (ip4_rewrite_node, ip4_rewrite)
2819 VLIB_REGISTER_NODE (ip4_rewrite_mcast_node) = {
2820 .function = ip4_rewrite_mcast,
2821 .name = "ip4-rewrite-mcast",
2822 .vector_size = sizeof (u32),
2824 .format_trace = format_ip4_rewrite_trace,
2825 .sibling_of = "ip4-rewrite",
2827 VLIB_NODE_FUNCTION_MULTIARCH (ip4_rewrite_mcast_node, ip4_rewrite_mcast)
2829 VLIB_REGISTER_NODE (ip4_mcast_midchain_node, static) = {
2830 .function = ip4_mcast_midchain,
2831 .name = "ip4-mcast-midchain",
2832 .vector_size = sizeof (u32),
2834 .format_trace = format_ip4_rewrite_trace,
2835 .sibling_of = "ip4-rewrite",
2837 VLIB_NODE_FUNCTION_MULTIARCH (ip4_mcast_midchain_node, ip4_mcast_midchain)
2839 VLIB_REGISTER_NODE (ip4_midchain_node) = {
2840 .function = ip4_midchain,
2841 .name = "ip4-midchain",
2842 .vector_size = sizeof (u32),
2843 .format_trace = format_ip4_forward_next_trace,
2844 .sibling_of = "ip4-rewrite",
2846 VLIB_NODE_FUNCTION_MULTIARCH (ip4_midchain_node, ip4_midchain);
2849 static clib_error_t *
2850 add_del_interface_table (vlib_main_t * vm,
2851 unformat_input_t * input, vlib_cli_command_t * cmd)
2853 vnet_main_t *vnm = vnet_get_main ();
2854 ip_interface_address_t *ia;
2855 clib_error_t *error = 0;
2856 u32 sw_if_index, table_id;
2860 if (!unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index))
2862 error = clib_error_return (0, "unknown interface `%U'",
2863 format_unformat_error, input);
2867 if (unformat (input, "%d", &table_id))
2871 error = clib_error_return (0, "expected table id `%U'",
2872 format_unformat_error, input);
2877 * If the interface already has in IP address, then a change int
2878 * VRF is not allowed. The IP address applied must first be removed.
2879 * We do not do that automatically here, since VPP has no knowledge
2880 * of whether thoses subnets are valid in the destination VRF.
2883 foreach_ip_interface_address (&ip4_main.lookup_main,
2885 1 /* honor unnumbered */,
2889 a = ip_interface_address_get_address (&ip4_main.lookup_main, ia);
2890 error = clib_error_return (0, "interface %U has address %U",
2891 format_vnet_sw_if_index_name, vnm,
2893 format_ip4_address, a);
2899 ip4_main_t *im = &ip4_main;
2902 fib_index = fib_table_find_or_create_and_lock (FIB_PROTOCOL_IP4, table_id);
2904 vec_validate (im->fib_index_by_sw_if_index, sw_if_index);
2905 im->fib_index_by_sw_if_index[sw_if_index] = fib_index;
2907 fib_index = mfib_table_find_or_create_and_lock (FIB_PROTOCOL_IP4, table_id);
2908 vec_validate (im->mfib_index_by_sw_if_index, sw_if_index);
2909 im->mfib_index_by_sw_if_index[sw_if_index] = fib_index;
2917 * Place the indicated interface into the supplied IPv4 FIB table (also known
2918 * as a VRF). If the FIB table does not exist, this command creates it. To
2919 * display the current IPv4 FIB table, use the command '<em>show ip fib</em>'.
2920 * FIB table will only be displayed if a route has been added to the table, or
2921 * an IP Address is assigned to an interface in the table (which adds a route
2924 * @note IP addresses added after setting the interface IP table are added to
2925 * the indicated FIB table. If an IP address is added prior to changing the
2926 * table then this is an error. The control plane must remove these addresses
2927 * first and then change the table. VPP will not automatically move the
2928 * addresses from the old to the new table as it does not know the validity
2932 * Example of how to add an interface to an IPv4 FIB table (where 2 is the table-id):
2933 * @cliexcmd{set interface ip table GigabitEthernet2/0/0 2}
2936 VLIB_CLI_COMMAND (set_interface_ip_table_command, static) =
2938 .path = "set interface ip table",
2939 .function = add_del_interface_table,
2940 .short_help = "set interface ip table <interface> <table-id>",
2945 ip4_lookup_validate (ip4_address_t * a, u32 fib_index0)
2947 ip4_fib_mtrie_t *mtrie0;
2948 ip4_fib_mtrie_leaf_t leaf0;
2951 mtrie0 = &ip4_fib_get (fib_index0)->mtrie;
2953 leaf0 = ip4_fib_mtrie_lookup_step_one (mtrie0, a);
2954 leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, a, 2);
2955 leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, a, 3);
2957 lbi0 = ip4_fib_mtrie_leaf_get_adj_index (leaf0);
2959 return lbi0 == ip4_fib_table_lookup_lb (ip4_fib_get (fib_index0), a);
2962 static clib_error_t *
2963 test_lookup_command_fn (vlib_main_t * vm,
2964 unformat_input_t * input, vlib_cli_command_t * cmd)
2971 ip4_address_t ip4_base_address;
2974 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2976 if (unformat (input, "table %d", &table_id))
2978 /* Make sure the entry exists. */
2979 fib = ip4_fib_get (table_id);
2980 if ((fib) && (fib->index != table_id))
2981 return clib_error_return (0, "<fib-index> %d does not exist",
2984 else if (unformat (input, "count %f", &count))
2987 else if (unformat (input, "%U",
2988 unformat_ip4_address, &ip4_base_address))
2991 return clib_error_return (0, "unknown input `%U'",
2992 format_unformat_error, input);
2997 for (i = 0; i < n; i++)
2999 if (!ip4_lookup_validate (&ip4_base_address, table_id))
3002 ip4_base_address.as_u32 =
3003 clib_host_to_net_u32 (1 +
3004 clib_net_to_host_u32 (ip4_base_address.as_u32));
3008 vlib_cli_output (vm, "%llu errors out of %d lookups\n", errors, n);
3010 vlib_cli_output (vm, "No errors in %d lookups\n", n);
3016 * Perform a lookup of an IPv4 Address (or range of addresses) in the
3017 * given FIB table to determine if there is a conflict with the
3018 * adjacency table. The fib-id can be determined by using the
3019 * '<em>show ip fib</em>' command. If fib-id is not entered, default value
3022 * @todo This command uses fib-id, other commands use table-id (not
3023 * just a name, they are different indexes). Would like to change this
3024 * to table-id for consistency.
3027 * Example of how to run the test lookup command:
3028 * @cliexstart{test lookup 172.16.1.1 table 1 count 2}
3029 * No errors in 2 lookups
3033 VLIB_CLI_COMMAND (lookup_test_command, static) =
3035 .path = "test lookup",
3036 .short_help = "test lookup <ipv4-addr> [table <fib-id>] [count <nn>]",
3037 .function = test_lookup_command_fn,
3042 vnet_set_ip4_flow_hash (u32 table_id, u32 flow_hash_config)
3046 fib_index = fib_table_find (FIB_PROTOCOL_IP4, table_id);
3048 if (~0 == fib_index)
3049 return VNET_API_ERROR_NO_SUCH_FIB;
3051 fib_table_set_flow_hash_config (fib_index, FIB_PROTOCOL_IP4,
3057 static clib_error_t *
3058 set_ip_flow_hash_command_fn (vlib_main_t * vm,
3059 unformat_input_t * input,
3060 vlib_cli_command_t * cmd)
3064 u32 flow_hash_config = 0;
3067 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
3069 if (unformat (input, "table %d", &table_id))
3072 else if (unformat (input, #a)) { flow_hash_config |= v; matched=1;}
3073 foreach_flow_hash_bit
3080 return clib_error_return (0, "unknown input `%U'",
3081 format_unformat_error, input);
3083 rv = vnet_set_ip4_flow_hash (table_id, flow_hash_config);
3089 case VNET_API_ERROR_NO_SUCH_FIB:
3090 return clib_error_return (0, "no such FIB table %d", table_id);
3093 clib_warning ("BUG: illegal flow hash config 0x%x", flow_hash_config);
3101 * Configure the set of IPv4 fields used by the flow hash.
3104 * Example of how to set the flow hash on a given table:
3105 * @cliexcmd{set ip flow-hash table 7 dst sport dport proto}
3106 * Example of display the configured flow hash:
3107 * @cliexstart{show ip fib}
3108 * ipv4-VRF:0, fib_index 0, flow hash: src dst sport dport proto
3111 * [@0]: dpo-load-balance: [index:0 buckets:1 uRPF:0 to:[0:0]]
3112 * [0] [@0]: dpo-drop ip6
3115 * [@0]: dpo-load-balance: [index:1 buckets:1 uRPF:1 to:[0:0]]
3116 * [0] [@0]: dpo-drop ip6
3119 * [@0]: dpo-load-balance: [index:3 buckets:1 uRPF:3 to:[0:0]]
3120 * [0] [@0]: dpo-drop ip6
3123 * [@0]: dpo-load-balance: [index:30 buckets:1 uRPF:29 to:[0:0]]
3124 * [0] [@3]: arp-ipv4: via 6.0.0.1 af_packet0
3127 * [@0]: dpo-load-balance: [index:31 buckets:4 uRPF:30 to:[0:0]]
3128 * [0] [@3]: arp-ipv4: via 6.0.0.2 af_packet0
3129 * [1] [@3]: arp-ipv4: via 6.0.0.2 af_packet0
3130 * [2] [@3]: arp-ipv4: via 6.0.0.2 af_packet0
3131 * [3] [@3]: arp-ipv4: via 6.0.0.1 af_packet0
3134 * [@0]: dpo-load-balance: [index:2 buckets:1 uRPF:2 to:[0:0]]
3135 * [0] [@0]: dpo-drop ip6
3136 * 255.255.255.255/32
3138 * [@0]: dpo-load-balance: [index:4 buckets:1 uRPF:4 to:[0:0]]
3139 * [0] [@0]: dpo-drop ip6
3140 * ipv4-VRF:7, fib_index 1, flow hash: dst sport dport proto
3143 * [@0]: dpo-load-balance: [index:12 buckets:1 uRPF:11 to:[0:0]]
3144 * [0] [@0]: dpo-drop ip6
3147 * [@0]: dpo-load-balance: [index:13 buckets:1 uRPF:12 to:[0:0]]
3148 * [0] [@0]: dpo-drop ip6
3151 * [@0]: dpo-load-balance: [index:17 buckets:1 uRPF:16 to:[0:0]]
3152 * [0] [@4]: ipv4-glean: af_packet0
3155 * [@0]: dpo-load-balance: [index:18 buckets:1 uRPF:17 to:[1:84]]
3156 * [0] [@2]: dpo-receive: 172.16.1.1 on af_packet0
3159 * [@0]: dpo-load-balance: [index:21 buckets:1 uRPF:20 to:[0:0]]
3160 * [0] [@5]: ipv4 via 172.16.1.2 af_packet0: IP4: 02:fe:9e:70:7a:2b -> 26:a5:f6:9c:3a:36
3163 * [@0]: dpo-load-balance: [index:19 buckets:1 uRPF:18 to:[0:0]]
3164 * [0] [@4]: ipv4-glean: af_packet1
3167 * [@0]: dpo-load-balance: [index:20 buckets:1 uRPF:19 to:[0:0]]
3168 * [0] [@2]: dpo-receive: 172.16.2.1 on af_packet1
3171 * [@0]: dpo-load-balance: [index:15 buckets:1 uRPF:14 to:[0:0]]
3172 * [0] [@0]: dpo-drop ip6
3175 * [@0]: dpo-load-balance: [index:14 buckets:1 uRPF:13 to:[0:0]]
3176 * [0] [@0]: dpo-drop ip6
3177 * 255.255.255.255/32
3179 * [@0]: dpo-load-balance: [index:16 buckets:1 uRPF:15 to:[0:0]]
3180 * [0] [@0]: dpo-drop ip6
3184 VLIB_CLI_COMMAND (set_ip_flow_hash_command, static) =
3186 .path = "set ip flow-hash",
3188 "set ip flow-hash table <table-id> [src] [dst] [sport] [dport] [proto] [reverse]",
3189 .function = set_ip_flow_hash_command_fn,
3194 vnet_set_ip4_classify_intfc (vlib_main_t * vm, u32 sw_if_index,
3197 vnet_main_t *vnm = vnet_get_main ();
3198 vnet_interface_main_t *im = &vnm->interface_main;
3199 ip4_main_t *ipm = &ip4_main;
3200 ip_lookup_main_t *lm = &ipm->lookup_main;
3201 vnet_classify_main_t *cm = &vnet_classify_main;
3202 ip4_address_t *if_addr;
3204 if (pool_is_free_index (im->sw_interfaces, sw_if_index))
3205 return VNET_API_ERROR_NO_MATCHING_INTERFACE;
3207 if (table_index != ~0 && pool_is_free_index (cm->tables, table_index))
3208 return VNET_API_ERROR_NO_SUCH_ENTRY;
3210 vec_validate (lm->classify_table_index_by_sw_if_index, sw_if_index);
3211 lm->classify_table_index_by_sw_if_index[sw_if_index] = table_index;
3213 if_addr = ip4_interface_first_address (ipm, sw_if_index, NULL);
3215 if (NULL != if_addr)
3217 fib_prefix_t pfx = {
3219 .fp_proto = FIB_PROTOCOL_IP4,
3220 .fp_addr.ip4 = *if_addr,
3224 fib_index = fib_table_get_index_for_sw_if_index (FIB_PROTOCOL_IP4,
3228 if (table_index != (u32) ~ 0)
3230 dpo_id_t dpo = DPO_INVALID;
3235 classify_dpo_create (DPO_PROTO_IP4, table_index));
3237 fib_table_entry_special_dpo_add (fib_index,
3239 FIB_SOURCE_CLASSIFY,
3240 FIB_ENTRY_FLAG_NONE, &dpo);
3245 fib_table_entry_special_remove (fib_index,
3246 &pfx, FIB_SOURCE_CLASSIFY);
3253 static clib_error_t *
3254 set_ip_classify_command_fn (vlib_main_t * vm,
3255 unformat_input_t * input,
3256 vlib_cli_command_t * cmd)
3258 u32 table_index = ~0;
3259 int table_index_set = 0;
3260 u32 sw_if_index = ~0;
3263 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
3265 if (unformat (input, "table-index %d", &table_index))
3266 table_index_set = 1;
3267 else if (unformat (input, "intfc %U", unformat_vnet_sw_interface,
3268 vnet_get_main (), &sw_if_index))
3274 if (table_index_set == 0)
3275 return clib_error_return (0, "classify table-index must be specified");
3277 if (sw_if_index == ~0)
3278 return clib_error_return (0, "interface / subif must be specified");
3280 rv = vnet_set_ip4_classify_intfc (vm, sw_if_index, table_index);
3287 case VNET_API_ERROR_NO_MATCHING_INTERFACE:
3288 return clib_error_return (0, "No such interface");
3290 case VNET_API_ERROR_NO_SUCH_ENTRY:
3291 return clib_error_return (0, "No such classifier table");
3297 * Assign a classification table to an interface. The classification
3298 * table is created using the '<em>classify table</em>' and '<em>classify session</em>'
3299 * commands. Once the table is create, use this command to filter packets
3303 * Example of how to assign a classification table to an interface:
3304 * @cliexcmd{set ip classify intfc GigabitEthernet2/0/0 table-index 1}
3307 VLIB_CLI_COMMAND (set_ip_classify_command, static) =
3309 .path = "set ip classify",
3311 "set ip classify intfc <interface> table-index <classify-idx>",
3312 .function = set_ip_classify_command_fn,
3317 * fd.io coding-style-patch-verification: ON
3320 * eval: (c-set-style "gnu")