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 a->neighbor_probe_adj_index = ~0;
722 if (pfx.fp_len <= 30)
724 /* a /30 or shorter - add a glean for the network address */
725 fib_node_index_t fei;
727 fei = fib_table_entry_update_one_path (fib_index, &pfx,
728 FIB_SOURCE_INTERFACE,
729 (FIB_ENTRY_FLAG_CONNECTED |
730 FIB_ENTRY_FLAG_ATTACHED),
732 /* No next-hop address */
738 // no out-label stack
740 FIB_ROUTE_PATH_FLAG_NONE);
741 a->neighbor_probe_adj_index = fib_entry_get_adj (fei);
743 /* Add the two broadcast addresses as drop */
744 fib_prefix_t net_pfx = {
746 .fp_proto = FIB_PROTOCOL_IP4,
747 .fp_addr.ip4.as_u32 = address->as_u32 & im->fib_masks[pfx.fp_len],
749 if (net_pfx.fp_addr.ip4.as_u32 != pfx.fp_addr.ip4.as_u32)
750 fib_table_entry_special_add(fib_index,
752 FIB_SOURCE_INTERFACE,
753 (FIB_ENTRY_FLAG_DROP |
754 FIB_ENTRY_FLAG_LOOSE_URPF_EXEMPT));
755 net_pfx.fp_addr.ip4.as_u32 |= ~im->fib_masks[pfx.fp_len];
756 if (net_pfx.fp_addr.ip4.as_u32 != pfx.fp_addr.ip4.as_u32)
757 fib_table_entry_special_add(fib_index,
759 FIB_SOURCE_INTERFACE,
760 (FIB_ENTRY_FLAG_DROP |
761 FIB_ENTRY_FLAG_LOOSE_URPF_EXEMPT));
763 else if (pfx.fp_len == 31)
765 u32 mask = clib_host_to_net_u32(1);
766 fib_prefix_t net_pfx = pfx;
769 net_pfx.fp_addr.ip4.as_u32 ^= mask;
771 /* a /31 - add the other end as an attached host */
772 fib_table_entry_update_one_path (fib_index, &net_pfx,
773 FIB_SOURCE_INTERFACE,
774 (FIB_ENTRY_FLAG_ATTACHED),
782 FIB_ROUTE_PATH_FLAG_NONE);
786 if (sw_if_index < vec_len (lm->classify_table_index_by_sw_if_index))
788 u32 classify_table_index =
789 lm->classify_table_index_by_sw_if_index[sw_if_index];
790 if (classify_table_index != (u32) ~ 0)
792 dpo_id_t dpo = DPO_INVALID;
797 classify_dpo_create (DPO_PROTO_IP4, classify_table_index));
799 fib_table_entry_special_dpo_add (fib_index,
802 FIB_ENTRY_FLAG_NONE, &dpo);
807 fib_table_entry_update_one_path (fib_index, &pfx,
808 FIB_SOURCE_INTERFACE,
809 (FIB_ENTRY_FLAG_CONNECTED |
810 FIB_ENTRY_FLAG_LOCAL),
817 FIB_ROUTE_PATH_FLAG_NONE);
821 ip4_del_interface_routes (ip4_main_t * im,
823 ip4_address_t * address, u32 address_length)
826 .fp_len = address_length,
827 .fp_proto = FIB_PROTOCOL_IP4,
828 .fp_addr.ip4 = *address,
831 if (pfx.fp_len <= 30)
833 fib_prefix_t net_pfx = {
835 .fp_proto = FIB_PROTOCOL_IP4,
836 .fp_addr.ip4.as_u32 = address->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 net_pfx.fp_addr.ip4.as_u32 |= ~im->fib_masks[pfx.fp_len];
843 if (net_pfx.fp_addr.ip4.as_u32 != pfx.fp_addr.ip4.as_u32)
844 fib_table_entry_special_remove(fib_index,
846 FIB_SOURCE_INTERFACE);
847 fib_table_entry_delete (fib_index, &pfx, FIB_SOURCE_INTERFACE);
849 else if (pfx.fp_len == 31)
851 u32 mask = clib_host_to_net_u32(1);
852 fib_prefix_t net_pfx = pfx;
855 net_pfx.fp_addr.ip4.as_u32 ^= mask;
857 fib_table_entry_delete (fib_index, &net_pfx, FIB_SOURCE_INTERFACE);
861 fib_table_entry_delete (fib_index, &pfx, FIB_SOURCE_INTERFACE);
865 ip4_sw_interface_enable_disable (u32 sw_if_index, u32 is_enable)
867 ip4_main_t *im = &ip4_main;
869 vec_validate_init_empty (im->ip_enabled_by_sw_if_index, sw_if_index, 0);
872 * enable/disable only on the 1<->0 transition
876 if (1 != ++im->ip_enabled_by_sw_if_index[sw_if_index])
881 ASSERT (im->ip_enabled_by_sw_if_index[sw_if_index] > 0);
882 if (0 != --im->ip_enabled_by_sw_if_index[sw_if_index])
885 vnet_feature_enable_disable ("ip4-unicast", "ip4-drop", sw_if_index,
889 vnet_feature_enable_disable ("ip4-multicast", "ip4-drop",
890 sw_if_index, !is_enable, 0, 0);
893 static clib_error_t *
894 ip4_add_del_interface_address_internal (vlib_main_t * vm,
896 ip4_address_t * address,
897 u32 address_length, u32 is_del)
899 vnet_main_t *vnm = vnet_get_main ();
900 ip4_main_t *im = &ip4_main;
901 ip_lookup_main_t *lm = &im->lookup_main;
902 clib_error_t *error = 0;
903 u32 if_address_index, elts_before;
904 ip4_address_fib_t ip4_af, *addr_fib = 0;
906 vec_validate (im->fib_index_by_sw_if_index, sw_if_index);
907 ip4_addr_fib_init (&ip4_af, address,
908 vec_elt (im->fib_index_by_sw_if_index, sw_if_index));
909 vec_add1 (addr_fib, ip4_af);
912 * there is no support for adj-fib handling in the presence of overlapping
913 * subnets on interfaces. Easy fix - disallow overlapping subnets, like
919 /* When adding an address check that it does not conflict
920 with an existing address. */
921 ip_interface_address_t *ia;
922 foreach_ip_interface_address
923 (&im->lookup_main, ia, sw_if_index,
924 0 /* honor unnumbered */ ,
927 ip_interface_address_get_address
928 (&im->lookup_main, ia);
929 if (ip4_destination_matches_route
930 (im, address, x, ia->address_length) ||
931 ip4_destination_matches_route (im,
937 ("failed to add %U which conflicts with %U for interface %U",
938 format_ip4_address_and_length, address,
940 format_ip4_address_and_length, x,
942 format_vnet_sw_if_index_name, vnm,
948 elts_before = pool_elts (lm->if_address_pool);
950 error = ip_interface_address_add_del
951 (lm, sw_if_index, addr_fib, address_length, is_del, &if_address_index);
955 ip4_sw_interface_enable_disable (sw_if_index, !is_del);
958 ip4_del_interface_routes (im, ip4_af.fib_index, address, address_length);
960 ip4_add_interface_routes (sw_if_index,
961 im, ip4_af.fib_index,
963 (lm->if_address_pool, if_address_index));
965 /* If pool did not grow/shrink: add duplicate address. */
966 if (elts_before != pool_elts (lm->if_address_pool))
968 ip4_add_del_interface_address_callback_t *cb;
969 vec_foreach (cb, im->add_del_interface_address_callbacks)
970 cb->function (im, cb->function_opaque, sw_if_index,
971 address, address_length, if_address_index, is_del);
980 ip4_add_del_interface_address (vlib_main_t * vm,
982 ip4_address_t * address,
983 u32 address_length, u32 is_del)
985 return ip4_add_del_interface_address_internal
986 (vm, sw_if_index, address, address_length, is_del);
989 /* Built-in ip4 unicast rx feature path definition */
991 VNET_FEATURE_ARC_INIT (ip4_unicast, static) =
993 .arc_name = "ip4-unicast",
994 .start_nodes = VNET_FEATURES ("ip4-input", "ip4-input-no-checksum"),
995 .arc_index_ptr = &ip4_main.lookup_main.ucast_feature_arc_index,
998 VNET_FEATURE_INIT (ip4_flow_classify, static) =
1000 .arc_name = "ip4-unicast",
1001 .node_name = "ip4-flow-classify",
1002 .runs_before = VNET_FEATURES ("ip4-inacl"),
1005 VNET_FEATURE_INIT (ip4_inacl, static) =
1007 .arc_name = "ip4-unicast",
1008 .node_name = "ip4-inacl",
1009 .runs_before = VNET_FEATURES ("ip4-source-check-via-rx"),
1012 VNET_FEATURE_INIT (ip4_source_check_1, static) =
1014 .arc_name = "ip4-unicast",
1015 .node_name = "ip4-source-check-via-rx",
1016 .runs_before = VNET_FEATURES ("ip4-source-check-via-any"),
1019 VNET_FEATURE_INIT (ip4_source_check_2, static) =
1021 .arc_name = "ip4-unicast",
1022 .node_name = "ip4-source-check-via-any",
1023 .runs_before = VNET_FEATURES ("ip4-policer-classify"),
1026 VNET_FEATURE_INIT (ip4_source_and_port_range_check_rx, static) =
1028 .arc_name = "ip4-unicast",
1029 .node_name = "ip4-source-and-port-range-check-rx",
1030 .runs_before = VNET_FEATURES ("ip4-policer-classify"),
1033 VNET_FEATURE_INIT (ip4_policer_classify, static) =
1035 .arc_name = "ip4-unicast",
1036 .node_name = "ip4-policer-classify",
1037 .runs_before = VNET_FEATURES ("ipsec-input-ip4"),
1040 VNET_FEATURE_INIT (ip4_ipsec, static) =
1042 .arc_name = "ip4-unicast",
1043 .node_name = "ipsec-input-ip4",
1044 .runs_before = VNET_FEATURES ("vpath-input-ip4"),
1047 VNET_FEATURE_INIT (ip4_vpath, static) =
1049 .arc_name = "ip4-unicast",
1050 .node_name = "vpath-input-ip4",
1051 .runs_before = VNET_FEATURES ("ip4-vxlan-bypass"),
1054 VNET_FEATURE_INIT (ip4_vxlan_bypass, static) =
1056 .arc_name = "ip4-unicast",
1057 .node_name = "ip4-vxlan-bypass",
1058 .runs_before = VNET_FEATURES ("ip4-lookup"),
1061 VNET_FEATURE_INIT (ip4_drop, static) =
1063 .arc_name = "ip4-unicast",
1064 .node_name = "ip4-drop",
1065 .runs_before = VNET_FEATURES ("ip4-lookup"),
1068 VNET_FEATURE_INIT (ip4_lookup, static) =
1070 .arc_name = "ip4-unicast",
1071 .node_name = "ip4-lookup",
1072 .runs_before = 0, /* not before any other features */
1075 /* Built-in ip4 multicast rx feature path definition */
1076 VNET_FEATURE_ARC_INIT (ip4_multicast, static) =
1078 .arc_name = "ip4-multicast",
1079 .start_nodes = VNET_FEATURES ("ip4-input", "ip4-input-no-checksum"),
1080 .arc_index_ptr = &ip4_main.lookup_main.mcast_feature_arc_index,
1083 VNET_FEATURE_INIT (ip4_vpath_mc, static) =
1085 .arc_name = "ip4-multicast",
1086 .node_name = "vpath-input-ip4",
1087 .runs_before = VNET_FEATURES ("ip4-mfib-forward-lookup"),
1090 VNET_FEATURE_INIT (ip4_mc_drop, static) =
1092 .arc_name = "ip4-multicast",
1093 .node_name = "ip4-drop",
1094 .runs_before = VNET_FEATURES ("ip4-mfib-forward-lookup"),
1097 VNET_FEATURE_INIT (ip4_lookup_mc, static) =
1099 .arc_name = "ip4-multicast",
1100 .node_name = "ip4-mfib-forward-lookup",
1101 .runs_before = 0, /* last feature */
1104 /* Source and port-range check ip4 tx feature path definition */
1105 VNET_FEATURE_ARC_INIT (ip4_output, static) =
1107 .arc_name = "ip4-output",
1108 .start_nodes = VNET_FEATURES ("ip4-rewrite", "ip4-midchain"),
1109 .arc_index_ptr = &ip4_main.lookup_main.output_feature_arc_index,
1112 VNET_FEATURE_INIT (ip4_source_and_port_range_check_tx, static) =
1114 .arc_name = "ip4-output",
1115 .node_name = "ip4-source-and-port-range-check-tx",
1116 .runs_before = VNET_FEATURES ("ipsec-output-ip4"),
1119 VNET_FEATURE_INIT (ip4_ipsec_output, static) =
1121 .arc_name = "ip4-output",
1122 .node_name = "ipsec-output-ip4",
1123 .runs_before = VNET_FEATURES ("interface-output"),
1126 /* Built-in ip4 tx feature path definition */
1127 VNET_FEATURE_INIT (ip4_interface_output, static) =
1129 .arc_name = "ip4-output",
1130 .node_name = "interface-output",
1131 .runs_before = 0, /* not before any other features */
1135 static clib_error_t *
1136 ip4_sw_interface_add_del (vnet_main_t * vnm, u32 sw_if_index, u32 is_add)
1138 ip4_main_t *im = &ip4_main;
1140 /* Fill in lookup tables with default table (0). */
1141 vec_validate (im->fib_index_by_sw_if_index, sw_if_index);
1142 vec_validate (im->mfib_index_by_sw_if_index, sw_if_index);
1144 vnet_feature_enable_disable ("ip4-unicast", "ip4-drop", sw_if_index,
1147 vnet_feature_enable_disable ("ip4-multicast", "ip4-drop", sw_if_index,
1150 return /* no error */ 0;
1153 VNET_SW_INTERFACE_ADD_DEL_FUNCTION (ip4_sw_interface_add_del);
1155 /* Global IP4 main. */
1156 ip4_main_t ip4_main;
1159 ip4_lookup_init (vlib_main_t * vm)
1161 ip4_main_t *im = &ip4_main;
1162 clib_error_t *error;
1165 if ((error = vlib_call_init_function (vm, vnet_feature_init)))
1168 for (i = 0; i < ARRAY_LEN (im->fib_masks); i++)
1173 m = pow2_mask (i) << (32 - i);
1176 im->fib_masks[i] = clib_host_to_net_u32 (m);
1179 ip_lookup_init (&im->lookup_main, /* is_ip6 */ 0);
1181 /* Create FIB with index 0 and table id of 0. */
1182 fib_table_find_or_create_and_lock (FIB_PROTOCOL_IP4, 0);
1183 mfib_table_find_or_create_and_lock (FIB_PROTOCOL_IP4, 0);
1187 pn = pg_get_node (ip4_lookup_node.index);
1188 pn->unformat_edit = unformat_pg_ip4_header;
1192 ethernet_arp_header_t h;
1194 memset (&h, 0, sizeof (h));
1196 /* Set target ethernet address to all zeros. */
1197 memset (h.ip4_over_ethernet[1].ethernet, 0,
1198 sizeof (h.ip4_over_ethernet[1].ethernet));
1200 #define _16(f,v) h.f = clib_host_to_net_u16 (v);
1201 #define _8(f,v) h.f = v;
1202 _16 (l2_type, ETHERNET_ARP_HARDWARE_TYPE_ethernet);
1203 _16 (l3_type, ETHERNET_TYPE_IP4);
1204 _8 (n_l2_address_bytes, 6);
1205 _8 (n_l3_address_bytes, 4);
1206 _16 (opcode, ETHERNET_ARP_OPCODE_request);
1210 vlib_packet_template_init (vm, &im->ip4_arp_request_packet_template,
1213 /* alloc chunk size */ 8,
1220 VLIB_INIT_FUNCTION (ip4_lookup_init);
1224 /* Adjacency taken. */
1229 /* Packet data, possibly *after* rewrite. */
1230 u8 packet_data[64 - 1 * sizeof (u32)];
1232 ip4_forward_next_trace_t;
1235 format_ip4_forward_next_trace (u8 * s, va_list * args)
1237 CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
1238 CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
1239 ip4_forward_next_trace_t *t = va_arg (*args, ip4_forward_next_trace_t *);
1240 uword indent = format_get_indent (s);
1241 s = format (s, "%U%U",
1242 format_white_space, indent,
1243 format_ip4_header, t->packet_data, sizeof (t->packet_data));
1248 format_ip4_lookup_trace (u8 * s, va_list * args)
1250 CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
1251 CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
1252 ip4_forward_next_trace_t *t = va_arg (*args, ip4_forward_next_trace_t *);
1253 uword indent = format_get_indent (s);
1255 s = format (s, "fib %d dpo-idx %d flow hash: 0x%08x",
1256 t->fib_index, t->dpo_index, t->flow_hash);
1257 s = format (s, "\n%U%U",
1258 format_white_space, indent,
1259 format_ip4_header, t->packet_data, sizeof (t->packet_data));
1264 format_ip4_rewrite_trace (u8 * s, va_list * args)
1266 CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
1267 CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
1268 ip4_forward_next_trace_t *t = va_arg (*args, ip4_forward_next_trace_t *);
1269 uword indent = format_get_indent (s);
1271 s = format (s, "tx_sw_if_index %d dpo-idx %d : %U flow hash: 0x%08x",
1272 t->fib_index, t->dpo_index, format_ip_adjacency,
1273 t->dpo_index, FORMAT_IP_ADJACENCY_NONE, t->flow_hash);
1274 s = format (s, "\n%U%U",
1275 format_white_space, indent,
1276 format_ip_adjacency_packet_data,
1277 t->dpo_index, t->packet_data, sizeof (t->packet_data));
1281 /* Common trace function for all ip4-forward next nodes. */
1283 ip4_forward_next_trace (vlib_main_t * vm,
1284 vlib_node_runtime_t * node,
1285 vlib_frame_t * frame, vlib_rx_or_tx_t which_adj_index)
1288 ip4_main_t *im = &ip4_main;
1290 n_left = frame->n_vectors;
1291 from = vlib_frame_vector_args (frame);
1296 vlib_buffer_t *b0, *b1;
1297 ip4_forward_next_trace_t *t0, *t1;
1299 /* Prefetch next iteration. */
1300 vlib_prefetch_buffer_with_index (vm, from[2], LOAD);
1301 vlib_prefetch_buffer_with_index (vm, from[3], LOAD);
1306 b0 = vlib_get_buffer (vm, bi0);
1307 b1 = vlib_get_buffer (vm, bi1);
1309 if (b0->flags & VLIB_BUFFER_IS_TRACED)
1311 t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0]));
1312 t0->dpo_index = vnet_buffer (b0)->ip.adj_index[which_adj_index];
1313 t0->flow_hash = vnet_buffer (b0)->ip.flow_hash;
1315 (vnet_buffer (b0)->sw_if_index[VLIB_TX] !=
1316 (u32) ~ 0) ? vnet_buffer (b0)->sw_if_index[VLIB_TX] :
1317 vec_elt (im->fib_index_by_sw_if_index,
1318 vnet_buffer (b0)->sw_if_index[VLIB_RX]);
1320 clib_memcpy (t0->packet_data,
1321 vlib_buffer_get_current (b0),
1322 sizeof (t0->packet_data));
1324 if (b1->flags & VLIB_BUFFER_IS_TRACED)
1326 t1 = vlib_add_trace (vm, node, b1, sizeof (t1[0]));
1327 t1->dpo_index = vnet_buffer (b1)->ip.adj_index[which_adj_index];
1328 t1->flow_hash = vnet_buffer (b1)->ip.flow_hash;
1330 (vnet_buffer (b1)->sw_if_index[VLIB_TX] !=
1331 (u32) ~ 0) ? vnet_buffer (b1)->sw_if_index[VLIB_TX] :
1332 vec_elt (im->fib_index_by_sw_if_index,
1333 vnet_buffer (b1)->sw_if_index[VLIB_RX]);
1334 clib_memcpy (t1->packet_data, vlib_buffer_get_current (b1),
1335 sizeof (t1->packet_data));
1345 ip4_forward_next_trace_t *t0;
1349 b0 = vlib_get_buffer (vm, bi0);
1351 if (b0->flags & VLIB_BUFFER_IS_TRACED)
1353 t0 = vlib_add_trace (vm, node, b0, sizeof (t0[0]));
1354 t0->dpo_index = vnet_buffer (b0)->ip.adj_index[which_adj_index];
1355 t0->flow_hash = vnet_buffer (b0)->ip.flow_hash;
1357 (vnet_buffer (b0)->sw_if_index[VLIB_TX] !=
1358 (u32) ~ 0) ? vnet_buffer (b0)->sw_if_index[VLIB_TX] :
1359 vec_elt (im->fib_index_by_sw_if_index,
1360 vnet_buffer (b0)->sw_if_index[VLIB_RX]);
1361 clib_memcpy (t0->packet_data, vlib_buffer_get_current (b0),
1362 sizeof (t0->packet_data));
1370 ip4_drop_or_punt (vlib_main_t * vm,
1371 vlib_node_runtime_t * node,
1372 vlib_frame_t * frame, ip4_error_t error_code)
1374 u32 *buffers = vlib_frame_vector_args (frame);
1375 uword n_packets = frame->n_vectors;
1377 vlib_error_drop_buffers (vm, node, buffers,
1381 ip4_input_node.index, error_code);
1383 if (node->flags & VLIB_NODE_FLAG_TRACE)
1384 ip4_forward_next_trace (vm, node, frame, VLIB_TX);
1390 ip4_drop (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
1392 return ip4_drop_or_punt (vm, node, frame, IP4_ERROR_ADJACENCY_DROP);
1396 ip4_punt (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
1398 return ip4_drop_or_punt (vm, node, frame, IP4_ERROR_ADJACENCY_PUNT);
1402 VLIB_REGISTER_NODE (ip4_drop_node, static) =
1404 .function = ip4_drop,.
1406 .vector_size = sizeof (u32),
1407 .format_trace = format_ip4_forward_next_trace,
1414 VLIB_NODE_FUNCTION_MULTIARCH (ip4_drop_node, ip4_drop);
1416 VLIB_REGISTER_NODE (ip4_punt_node, static) =
1418 .function = ip4_punt,
1420 .vector_size = sizeof (u32),
1421 .format_trace = format_ip4_forward_next_trace,
1428 VLIB_NODE_FUNCTION_MULTIARCH (ip4_punt_node, ip4_punt);
1431 /* Compute TCP/UDP/ICMP4 checksum in software. */
1433 ip4_tcp_udp_compute_checksum (vlib_main_t * vm, vlib_buffer_t * p0,
1437 u32 ip_header_length, payload_length_host_byte_order;
1438 u32 n_this_buffer, n_bytes_left;
1440 void *data_this_buffer;
1442 /* Initialize checksum with ip header. */
1443 ip_header_length = ip4_header_bytes (ip0);
1444 payload_length_host_byte_order =
1445 clib_net_to_host_u16 (ip0->length) - ip_header_length;
1447 clib_host_to_net_u32 (payload_length_host_byte_order +
1448 (ip0->protocol << 16));
1450 if (BITS (uword) == 32)
1453 ip_csum_with_carry (sum0,
1454 clib_mem_unaligned (&ip0->src_address, u32));
1456 ip_csum_with_carry (sum0,
1457 clib_mem_unaligned (&ip0->dst_address, u32));
1461 ip_csum_with_carry (sum0, clib_mem_unaligned (&ip0->src_address, u64));
1463 n_bytes_left = n_this_buffer = payload_length_host_byte_order;
1464 data_this_buffer = (void *) ip0 + ip_header_length;
1465 if (n_this_buffer + ip_header_length > p0->current_length)
1467 p0->current_length >
1468 ip_header_length ? p0->current_length - ip_header_length : 0;
1471 sum0 = ip_incremental_checksum (sum0, data_this_buffer, n_this_buffer);
1472 n_bytes_left -= n_this_buffer;
1473 if (n_bytes_left == 0)
1476 ASSERT (p0->flags & VLIB_BUFFER_NEXT_PRESENT);
1477 p0 = vlib_get_buffer (vm, p0->next_buffer);
1478 data_this_buffer = vlib_buffer_get_current (p0);
1479 n_this_buffer = p0->current_length;
1482 sum16 = ~ip_csum_fold (sum0);
1488 ip4_tcp_udp_validate_checksum (vlib_main_t * vm, vlib_buffer_t * p0)
1490 ip4_header_t *ip0 = vlib_buffer_get_current (p0);
1494 ASSERT (ip0->protocol == IP_PROTOCOL_TCP
1495 || ip0->protocol == IP_PROTOCOL_UDP);
1497 udp0 = (void *) (ip0 + 1);
1498 if (ip0->protocol == IP_PROTOCOL_UDP && udp0->checksum == 0)
1500 p0->flags |= (IP_BUFFER_L4_CHECKSUM_COMPUTED
1501 | IP_BUFFER_L4_CHECKSUM_CORRECT);
1505 sum16 = ip4_tcp_udp_compute_checksum (vm, p0, ip0);
1507 p0->flags |= (IP_BUFFER_L4_CHECKSUM_COMPUTED
1508 | ((sum16 == 0) << LOG2_IP_BUFFER_L4_CHECKSUM_CORRECT));
1514 VNET_FEATURE_ARC_INIT (ip4_local) =
1516 .arc_name = "ip4-local",
1517 .start_nodes = VNET_FEATURES ("ip4-local"),
1522 ip4_local_inline (vlib_main_t * vm,
1523 vlib_node_runtime_t * node,
1524 vlib_frame_t * frame, int head_of_feature_arc)
1526 ip4_main_t *im = &ip4_main;
1527 ip_lookup_main_t *lm = &im->lookup_main;
1528 ip_local_next_t next_index;
1529 u32 *from, *to_next, n_left_from, n_left_to_next;
1530 vlib_node_runtime_t *error_node =
1531 vlib_node_get_runtime (vm, ip4_input_node.index);
1532 u8 arc_index = vnet_feat_arc_ip4_local.feature_arc_index;
1534 from = vlib_frame_vector_args (frame);
1535 n_left_from = frame->n_vectors;
1536 next_index = node->cached_next_index;
1538 if (node->flags & VLIB_NODE_FLAG_TRACE)
1539 ip4_forward_next_trace (vm, node, frame, VLIB_TX);
1541 while (n_left_from > 0)
1543 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
1545 while (n_left_from >= 4 && n_left_to_next >= 2)
1547 vlib_buffer_t *p0, *p1;
1548 ip4_header_t *ip0, *ip1;
1549 udp_header_t *udp0, *udp1;
1550 ip4_fib_mtrie_t *mtrie0, *mtrie1;
1551 ip4_fib_mtrie_leaf_t leaf0, leaf1;
1552 const dpo_id_t *dpo0, *dpo1;
1553 const load_balance_t *lb0, *lb1;
1554 u32 pi0, ip_len0, udp_len0, flags0, next0, fib_index0, lbi0;
1555 u32 pi1, ip_len1, udp_len1, flags1, next1, fib_index1, lbi1;
1556 i32 len_diff0, len_diff1;
1557 u8 error0, is_udp0, is_tcp_udp0, good_tcp_udp0, proto0;
1558 u8 error1, is_udp1, is_tcp_udp1, good_tcp_udp1, proto1;
1559 u32 sw_if_index0, sw_if_index1;
1561 pi0 = to_next[0] = from[0];
1562 pi1 = to_next[1] = from[1];
1566 n_left_to_next -= 2;
1568 next0 = next1 = IP_LOCAL_NEXT_DROP;
1570 p0 = vlib_get_buffer (vm, pi0);
1571 p1 = vlib_get_buffer (vm, pi1);
1573 ip0 = vlib_buffer_get_current (p0);
1574 ip1 = vlib_buffer_get_current (p1);
1576 vnet_buffer (p0)->ip.start_of_ip_header = p0->current_data;
1577 vnet_buffer (p1)->ip.start_of_ip_header = p1->current_data;
1579 sw_if_index0 = vnet_buffer (p0)->sw_if_index[VLIB_RX];
1580 sw_if_index1 = vnet_buffer (p1)->sw_if_index[VLIB_RX];
1582 fib_index0 = vec_elt (im->fib_index_by_sw_if_index, sw_if_index0);
1583 fib_index1 = vec_elt (im->fib_index_by_sw_if_index, sw_if_index1);
1585 fib_index0 = vec_elt (im->fib_index_by_sw_if_index, sw_if_index0);
1587 (vnet_buffer (p0)->sw_if_index[VLIB_TX] ==
1588 (u32) ~ 0) ? fib_index0 : vnet_buffer (p0)->sw_if_index[VLIB_TX];
1590 fib_index1 = vec_elt (im->fib_index_by_sw_if_index, sw_if_index1);
1592 (vnet_buffer (p1)->sw_if_index[VLIB_TX] ==
1593 (u32) ~ 0) ? fib_index1 : vnet_buffer (p1)->sw_if_index[VLIB_TX];
1595 mtrie0 = &ip4_fib_get (fib_index0)->mtrie;
1596 mtrie1 = &ip4_fib_get (fib_index1)->mtrie;
1598 leaf0 = ip4_fib_mtrie_lookup_step_one (mtrie0, &ip0->src_address);
1599 leaf1 = ip4_fib_mtrie_lookup_step_one (mtrie1, &ip1->src_address);
1601 /* Treat IP frag packets as "experimental" protocol for now
1602 until support of IP frag reassembly is implemented */
1603 proto0 = ip4_is_fragment (ip0) ? 0xfe : ip0->protocol;
1604 proto1 = ip4_is_fragment (ip1) ? 0xfe : ip1->protocol;
1606 if (head_of_feature_arc == 0)
1608 error0 = error1 = IP4_ERROR_UNKNOWN_PROTOCOL;
1612 is_udp0 = proto0 == IP_PROTOCOL_UDP;
1613 is_udp1 = proto1 == IP_PROTOCOL_UDP;
1614 is_tcp_udp0 = is_udp0 || proto0 == IP_PROTOCOL_TCP;
1615 is_tcp_udp1 = is_udp1 || proto1 == IP_PROTOCOL_TCP;
1620 good_tcp_udp0 = (flags0 & IP_BUFFER_L4_CHECKSUM_CORRECT) != 0;
1621 good_tcp_udp1 = (flags1 & IP_BUFFER_L4_CHECKSUM_CORRECT) != 0;
1623 udp0 = ip4_next_header (ip0);
1624 udp1 = ip4_next_header (ip1);
1626 /* Don't verify UDP checksum for packets with explicit zero checksum. */
1627 good_tcp_udp0 |= is_udp0 && udp0->checksum == 0;
1628 good_tcp_udp1 |= is_udp1 && udp1->checksum == 0;
1630 /* Verify UDP length. */
1631 ip_len0 = clib_net_to_host_u16 (ip0->length);
1632 ip_len1 = clib_net_to_host_u16 (ip1->length);
1633 udp_len0 = clib_net_to_host_u16 (udp0->length);
1634 udp_len1 = clib_net_to_host_u16 (udp1->length);
1636 len_diff0 = ip_len0 - udp_len0;
1637 len_diff1 = ip_len1 - udp_len1;
1639 len_diff0 = is_udp0 ? len_diff0 : 0;
1640 len_diff1 = is_udp1 ? len_diff1 : 0;
1642 if (PREDICT_FALSE (!(is_tcp_udp0 & is_tcp_udp1
1643 & good_tcp_udp0 & good_tcp_udp1)))
1648 && !(flags0 & IP_BUFFER_L4_CHECKSUM_COMPUTED))
1649 flags0 = ip4_tcp_udp_validate_checksum (vm, p0);
1651 (flags0 & IP_BUFFER_L4_CHECKSUM_CORRECT) != 0;
1652 good_tcp_udp0 |= is_udp0 && udp0->checksum == 0;
1657 && !(flags1 & IP_BUFFER_L4_CHECKSUM_COMPUTED))
1658 flags1 = ip4_tcp_udp_validate_checksum (vm, p1);
1660 (flags1 & IP_BUFFER_L4_CHECKSUM_CORRECT) != 0;
1661 good_tcp_udp1 |= is_udp1 && udp1->checksum == 0;
1665 good_tcp_udp0 &= len_diff0 >= 0;
1666 good_tcp_udp1 &= len_diff1 >= 0;
1669 ip4_fib_mtrie_lookup_step (mtrie0, leaf0, &ip0->src_address, 2);
1671 ip4_fib_mtrie_lookup_step (mtrie1, leaf1, &ip1->src_address, 2);
1673 error0 = error1 = IP4_ERROR_UNKNOWN_PROTOCOL;
1675 error0 = len_diff0 < 0 ? IP4_ERROR_UDP_LENGTH : error0;
1676 error1 = len_diff1 < 0 ? IP4_ERROR_UDP_LENGTH : error1;
1678 ASSERT (IP4_ERROR_TCP_CHECKSUM + 1 == IP4_ERROR_UDP_CHECKSUM);
1679 error0 = (is_tcp_udp0 && !good_tcp_udp0
1680 ? IP4_ERROR_TCP_CHECKSUM + is_udp0 : error0);
1681 error1 = (is_tcp_udp1 && !good_tcp_udp1
1682 ? IP4_ERROR_TCP_CHECKSUM + is_udp1 : error1);
1685 ip4_fib_mtrie_lookup_step (mtrie0, leaf0, &ip0->src_address, 3);
1687 ip4_fib_mtrie_lookup_step (mtrie1, leaf1, &ip1->src_address, 3);
1689 vnet_buffer (p0)->ip.adj_index[VLIB_RX] = lbi0 =
1690 ip4_fib_mtrie_leaf_get_adj_index (leaf0);
1691 vnet_buffer (p0)->ip.adj_index[VLIB_TX] = lbi0;
1693 vnet_buffer (p1)->ip.adj_index[VLIB_RX] = lbi1 =
1694 ip4_fib_mtrie_leaf_get_adj_index (leaf1);
1695 vnet_buffer (p1)->ip.adj_index[VLIB_TX] = lbi1;
1697 lb0 = load_balance_get (lbi0);
1698 lb1 = load_balance_get (lbi1);
1699 dpo0 = load_balance_get_bucket_i (lb0, 0);
1700 dpo1 = load_balance_get_bucket_i (lb1, 0);
1703 * Must have a route to source otherwise we drop the packet.
1704 * ip4 broadcasts are accepted, e.g. to make dhcp client work
1707 * - the source is a recieve => it's from us => bogus, do this
1708 * first since it sets a different error code.
1709 * - uRPF check for any route to source - accept if passes.
1710 * - allow packets destined to the broadcast address from unknown sources
1712 error0 = ((error0 == IP4_ERROR_UNKNOWN_PROTOCOL &&
1713 dpo0->dpoi_type == DPO_RECEIVE) ?
1714 IP4_ERROR_SPOOFED_LOCAL_PACKETS : error0);
1715 error0 = ((error0 == IP4_ERROR_UNKNOWN_PROTOCOL &&
1716 !fib_urpf_check_size (lb0->lb_urpf) &&
1717 ip0->dst_address.as_u32 != 0xFFFFFFFF)
1718 ? IP4_ERROR_SRC_LOOKUP_MISS : error0);
1719 error1 = ((error1 == IP4_ERROR_UNKNOWN_PROTOCOL &&
1720 dpo1->dpoi_type == DPO_RECEIVE) ?
1721 IP4_ERROR_SPOOFED_LOCAL_PACKETS : error1);
1722 error1 = ((error1 == IP4_ERROR_UNKNOWN_PROTOCOL &&
1723 !fib_urpf_check_size (lb1->lb_urpf) &&
1724 ip1->dst_address.as_u32 != 0xFFFFFFFF)
1725 ? IP4_ERROR_SRC_LOOKUP_MISS : error1);
1729 next0 = lm->local_next_by_ip_protocol[proto0];
1730 next1 = lm->local_next_by_ip_protocol[proto1];
1733 error0 != IP4_ERROR_UNKNOWN_PROTOCOL ? IP_LOCAL_NEXT_DROP : next0;
1735 error1 != IP4_ERROR_UNKNOWN_PROTOCOL ? IP_LOCAL_NEXT_DROP : next1;
1737 p0->error = error0 ? error_node->errors[error0] : 0;
1738 p1->error = error1 ? error_node->errors[error1] : 0;
1740 if (head_of_feature_arc)
1742 if (PREDICT_TRUE (error0 == (u8) IP4_ERROR_UNKNOWN_PROTOCOL))
1743 vnet_feature_arc_start (arc_index, sw_if_index0, &next0, p0);
1744 if (PREDICT_TRUE (error1 == (u8) IP4_ERROR_UNKNOWN_PROTOCOL))
1745 vnet_feature_arc_start (arc_index, sw_if_index1, &next1, p1);
1748 vlib_validate_buffer_enqueue_x2 (vm, node, next_index, to_next,
1749 n_left_to_next, pi0, pi1,
1753 while (n_left_from > 0 && n_left_to_next > 0)
1758 ip4_fib_mtrie_t *mtrie0;
1759 ip4_fib_mtrie_leaf_t leaf0;
1760 u32 pi0, next0, ip_len0, udp_len0, flags0, fib_index0, lbi0;
1762 u8 error0, is_udp0, is_tcp_udp0, good_tcp_udp0, proto0;
1763 load_balance_t *lb0;
1764 const dpo_id_t *dpo0;
1767 pi0 = to_next[0] = from[0];
1771 n_left_to_next -= 1;
1773 next0 = IP_LOCAL_NEXT_DROP;
1775 p0 = vlib_get_buffer (vm, pi0);
1777 ip0 = vlib_buffer_get_current (p0);
1779 vnet_buffer (p0)->ip.start_of_ip_header = p0->current_data;
1781 sw_if_index0 = vnet_buffer (p0)->sw_if_index[VLIB_RX];
1783 fib_index0 = vec_elt (im->fib_index_by_sw_if_index, sw_if_index0);
1786 (vnet_buffer (p0)->sw_if_index[VLIB_TX] ==
1787 (u32) ~ 0) ? fib_index0 : vnet_buffer (p0)->sw_if_index[VLIB_TX];
1789 mtrie0 = &ip4_fib_get (fib_index0)->mtrie;
1791 leaf0 = ip4_fib_mtrie_lookup_step_one (mtrie0, &ip0->src_address);
1793 /* Treat IP frag packets as "experimental" protocol for now
1794 until support of IP frag reassembly is implemented */
1795 proto0 = ip4_is_fragment (ip0) ? 0xfe : ip0->protocol;
1797 if (head_of_feature_arc == 0)
1799 error0 = IP4_ERROR_UNKNOWN_PROTOCOL;
1803 is_udp0 = proto0 == IP_PROTOCOL_UDP;
1804 is_tcp_udp0 = is_udp0 || proto0 == IP_PROTOCOL_TCP;
1808 good_tcp_udp0 = (flags0 & IP_BUFFER_L4_CHECKSUM_CORRECT) != 0;
1810 udp0 = ip4_next_header (ip0);
1812 /* Don't verify UDP checksum for packets with explicit zero checksum. */
1813 good_tcp_udp0 |= is_udp0 && udp0->checksum == 0;
1815 /* Verify UDP length. */
1816 ip_len0 = clib_net_to_host_u16 (ip0->length);
1817 udp_len0 = clib_net_to_host_u16 (udp0->length);
1819 len_diff0 = ip_len0 - udp_len0;
1821 len_diff0 = is_udp0 ? len_diff0 : 0;
1823 if (PREDICT_FALSE (!(is_tcp_udp0 & good_tcp_udp0)))
1828 && !(flags0 & IP_BUFFER_L4_CHECKSUM_COMPUTED))
1829 flags0 = ip4_tcp_udp_validate_checksum (vm, p0);
1831 (flags0 & IP_BUFFER_L4_CHECKSUM_CORRECT) != 0;
1832 good_tcp_udp0 |= is_udp0 && udp0->checksum == 0;
1836 good_tcp_udp0 &= len_diff0 >= 0;
1839 ip4_fib_mtrie_lookup_step (mtrie0, leaf0, &ip0->src_address, 2);
1841 error0 = IP4_ERROR_UNKNOWN_PROTOCOL;
1843 error0 = len_diff0 < 0 ? IP4_ERROR_UDP_LENGTH : error0;
1845 ASSERT (IP4_ERROR_TCP_CHECKSUM + 1 == IP4_ERROR_UDP_CHECKSUM);
1846 error0 = (is_tcp_udp0 && !good_tcp_udp0
1847 ? IP4_ERROR_TCP_CHECKSUM + is_udp0 : error0);
1850 ip4_fib_mtrie_lookup_step (mtrie0, leaf0, &ip0->src_address, 3);
1852 lbi0 = ip4_fib_mtrie_leaf_get_adj_index (leaf0);
1853 vnet_buffer (p0)->ip.adj_index[VLIB_TX] = lbi0;
1855 lb0 = load_balance_get (lbi0);
1856 dpo0 = load_balance_get_bucket_i (lb0, 0);
1858 vnet_buffer (p0)->ip.adj_index[VLIB_TX] =
1859 vnet_buffer (p0)->ip.adj_index[VLIB_RX] = lbi0;
1861 error0 = ((error0 == IP4_ERROR_UNKNOWN_PROTOCOL &&
1862 dpo0->dpoi_type == DPO_RECEIVE) ?
1863 IP4_ERROR_SPOOFED_LOCAL_PACKETS : error0);
1864 error0 = ((error0 == IP4_ERROR_UNKNOWN_PROTOCOL &&
1865 !fib_urpf_check_size (lb0->lb_urpf) &&
1866 ip0->dst_address.as_u32 != 0xFFFFFFFF)
1867 ? IP4_ERROR_SRC_LOOKUP_MISS : error0);
1871 next0 = lm->local_next_by_ip_protocol[proto0];
1874 error0 != IP4_ERROR_UNKNOWN_PROTOCOL ? IP_LOCAL_NEXT_DROP : next0;
1876 p0->error = error0 ? error_node->errors[error0] : 0;
1878 if (head_of_feature_arc)
1880 if (PREDICT_TRUE (error0 == (u8) IP4_ERROR_UNKNOWN_PROTOCOL))
1881 vnet_feature_arc_start (arc_index, sw_if_index0, &next0, p0);
1884 vlib_validate_buffer_enqueue_x1 (vm, node, next_index, to_next,
1885 n_left_to_next, pi0, next0);
1889 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
1892 return frame->n_vectors;
1896 ip4_local (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
1898 return ip4_local_inline (vm, node, frame, 1 /* head of feature arc */ );
1902 VLIB_REGISTER_NODE (ip4_local_node) =
1904 .function = ip4_local,
1905 .name = "ip4-local",
1906 .vector_size = sizeof (u32),
1907 .format_trace = format_ip4_forward_next_trace,
1908 .n_next_nodes = IP_LOCAL_N_NEXT,
1911 [IP_LOCAL_NEXT_DROP] = "error-drop",
1912 [IP_LOCAL_NEXT_PUNT] = "error-punt",
1913 [IP_LOCAL_NEXT_UDP_LOOKUP] = "ip4-udp-lookup",
1914 [IP_LOCAL_NEXT_ICMP] = "ip4-icmp-input",},
1918 VLIB_NODE_FUNCTION_MULTIARCH (ip4_local_node, ip4_local);
1921 ip4_local_end_of_arc (vlib_main_t * vm,
1922 vlib_node_runtime_t * node, vlib_frame_t * frame)
1924 return ip4_local_inline (vm, node, frame, 0 /* head of feature arc */ );
1928 VLIB_REGISTER_NODE (ip4_local_end_of_arc_node,static) = {
1929 .function = ip4_local_end_of_arc,
1930 .name = "ip4-local-end-of-arc",
1931 .vector_size = sizeof (u32),
1933 .format_trace = format_ip4_forward_next_trace,
1934 .sibling_of = "ip4-local",
1937 VLIB_NODE_FUNCTION_MULTIARCH (ip4_local_end_of_arc_node, ip4_local_end_of_arc)
1939 VNET_FEATURE_INIT (ip4_local_end_of_arc, static) = {
1940 .arc_name = "ip4-local",
1941 .node_name = "ip4-local-end-of-arc",
1942 .runs_before = 0, /* not before any other features */
1947 ip4_register_protocol (u32 protocol, u32 node_index)
1949 vlib_main_t *vm = vlib_get_main ();
1950 ip4_main_t *im = &ip4_main;
1951 ip_lookup_main_t *lm = &im->lookup_main;
1953 ASSERT (protocol < ARRAY_LEN (lm->local_next_by_ip_protocol));
1954 lm->local_next_by_ip_protocol[protocol] =
1955 vlib_node_add_next (vm, ip4_local_node.index, node_index);
1958 static clib_error_t *
1959 show_ip_local_command_fn (vlib_main_t * vm,
1960 unformat_input_t * input, vlib_cli_command_t * cmd)
1962 ip4_main_t *im = &ip4_main;
1963 ip_lookup_main_t *lm = &im->lookup_main;
1966 vlib_cli_output (vm, "Protocols handled by ip4_local");
1967 for (i = 0; i < ARRAY_LEN (lm->local_next_by_ip_protocol); i++)
1969 if (lm->local_next_by_ip_protocol[i] != IP_LOCAL_NEXT_PUNT)
1970 vlib_cli_output (vm, "%d", i);
1978 * Display the set of protocols handled by the local IPv4 stack.
1981 * Example of how to display local protocol table:
1982 * @cliexstart{show ip local}
1983 * Protocols handled by ip4_local
1990 VLIB_CLI_COMMAND (show_ip_local, static) =
1992 .path = "show ip local",
1993 .function = show_ip_local_command_fn,
1994 .short_help = "show ip local",
1999 ip4_arp_inline (vlib_main_t * vm,
2000 vlib_node_runtime_t * node,
2001 vlib_frame_t * frame, int is_glean)
2003 vnet_main_t *vnm = vnet_get_main ();
2004 ip4_main_t *im = &ip4_main;
2005 ip_lookup_main_t *lm = &im->lookup_main;
2006 u32 *from, *to_next_drop;
2007 uword n_left_from, n_left_to_next_drop, next_index;
2008 static f64 time_last_seed_change = -1e100;
2009 static u32 hash_seeds[3];
2010 static uword hash_bitmap[256 / BITS (uword)];
2013 if (node->flags & VLIB_NODE_FLAG_TRACE)
2014 ip4_forward_next_trace (vm, node, frame, VLIB_TX);
2016 time_now = vlib_time_now (vm);
2017 if (time_now - time_last_seed_change > 1e-3)
2020 u32 *r = clib_random_buffer_get_data (&vm->random_buffer,
2021 sizeof (hash_seeds));
2022 for (i = 0; i < ARRAY_LEN (hash_seeds); i++)
2023 hash_seeds[i] = r[i];
2025 /* Mark all hash keys as been no-seen before. */
2026 for (i = 0; i < ARRAY_LEN (hash_bitmap); i++)
2029 time_last_seed_change = time_now;
2032 from = vlib_frame_vector_args (frame);
2033 n_left_from = frame->n_vectors;
2034 next_index = node->cached_next_index;
2035 if (next_index == IP4_ARP_NEXT_DROP)
2036 next_index = IP4_ARP_N_NEXT; /* point to first interface */
2038 while (n_left_from > 0)
2040 vlib_get_next_frame (vm, node, IP4_ARP_NEXT_DROP,
2041 to_next_drop, n_left_to_next_drop);
2043 while (n_left_from > 0 && n_left_to_next_drop > 0)
2045 u32 pi0, adj_index0, a0, b0, c0, m0, sw_if_index0, drop0;
2046 ip_adjacency_t *adj0;
2053 p0 = vlib_get_buffer (vm, pi0);
2055 adj_index0 = vnet_buffer (p0)->ip.adj_index[VLIB_TX];
2056 adj0 = adj_get (adj_index0);
2057 ip0 = vlib_buffer_get_current (p0);
2063 sw_if_index0 = adj0->rewrite_header.sw_if_index;
2064 vnet_buffer (p0)->sw_if_index[VLIB_TX] = sw_if_index0;
2069 * this is the Glean case, so we are ARPing for the
2070 * packet's destination
2072 a0 ^= ip0->dst_address.data_u32;
2076 a0 ^= adj0->sub_type.nbr.next_hop.ip4.data_u32;
2080 hash_v3_finalize32 (a0, b0, c0);
2082 c0 &= BITS (hash_bitmap) - 1;
2083 c0 = c0 / BITS (uword);
2084 m0 = (uword) 1 << (c0 % BITS (uword));
2086 bm0 = hash_bitmap[c0];
2087 drop0 = (bm0 & m0) != 0;
2089 /* Mark it as seen. */
2090 hash_bitmap[c0] = bm0 | m0;
2094 to_next_drop[0] = pi0;
2096 n_left_to_next_drop -= 1;
2099 node->errors[drop0 ? IP4_ARP_ERROR_DROP :
2100 IP4_ARP_ERROR_REQUEST_SENT];
2103 * the adj has been updated to a rewrite but the node the DPO that got
2104 * us here hasn't - yet. no big deal. we'll drop while we wait.
2106 if (IP_LOOKUP_NEXT_REWRITE == adj0->lookup_next_index)
2113 * Can happen if the control-plane is programming tables
2114 * with traffic flowing; at least that's today's lame excuse.
2116 if ((is_glean && adj0->lookup_next_index != IP_LOOKUP_NEXT_GLEAN)
2117 || (!is_glean && adj0->lookup_next_index != IP_LOOKUP_NEXT_ARP))
2119 p0->error = node->errors[IP4_ARP_ERROR_NON_ARP_ADJ];
2122 /* Send ARP request. */
2126 ethernet_arp_header_t *h0;
2127 vnet_hw_interface_t *hw_if0;
2130 vlib_packet_template_get_packet (vm,
2131 &im->ip4_arp_request_packet_template,
2134 /* Add rewrite/encap string for ARP packet. */
2135 vnet_rewrite_one_header (adj0[0], h0,
2136 sizeof (ethernet_header_t));
2138 hw_if0 = vnet_get_sup_hw_interface (vnm, sw_if_index0);
2140 /* Src ethernet address in ARP header. */
2141 clib_memcpy (h0->ip4_over_ethernet[0].ethernet,
2143 sizeof (h0->ip4_over_ethernet[0].ethernet));
2147 /* The interface's source address is stashed in the Glean Adj */
2148 h0->ip4_over_ethernet[0].ip4 =
2149 adj0->sub_type.glean.receive_addr.ip4;
2151 /* Copy in destination address we are requesting. This is the
2152 * glean case, so it's the packet's destination.*/
2153 h0->ip4_over_ethernet[1].ip4.data_u32 =
2154 ip0->dst_address.data_u32;
2158 /* Src IP address in ARP header. */
2159 if (ip4_src_address_for_packet (lm, sw_if_index0,
2161 ip4_over_ethernet[0].ip4))
2163 /* No source address available */
2165 node->errors[IP4_ARP_ERROR_NO_SOURCE_ADDRESS];
2166 vlib_buffer_free (vm, &bi0, 1);
2170 /* Copy in destination address we are requesting from the
2172 h0->ip4_over_ethernet[1].ip4.data_u32 =
2173 adj0->sub_type.nbr.next_hop.ip4.as_u32;
2176 vlib_buffer_copy_trace_flag (vm, p0, bi0);
2177 b0 = vlib_get_buffer (vm, bi0);
2178 vnet_buffer (b0)->sw_if_index[VLIB_TX] = sw_if_index0;
2180 vlib_buffer_advance (b0, -adj0->rewrite_header.data_bytes);
2182 vlib_set_next_frame_buffer (vm, node,
2183 adj0->rewrite_header.next_index,
2188 vlib_put_next_frame (vm, node, IP4_ARP_NEXT_DROP, n_left_to_next_drop);
2191 return frame->n_vectors;
2195 ip4_arp (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
2197 return (ip4_arp_inline (vm, node, frame, 0));
2201 ip4_glean (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
2203 return (ip4_arp_inline (vm, node, frame, 1));
2206 static char *ip4_arp_error_strings[] = {
2207 [IP4_ARP_ERROR_DROP] = "address overflow drops",
2208 [IP4_ARP_ERROR_REQUEST_SENT] = "ARP requests sent",
2209 [IP4_ARP_ERROR_NON_ARP_ADJ] = "ARPs to non-ARP adjacencies",
2210 [IP4_ARP_ERROR_REPLICATE_DROP] = "ARP replication completed",
2211 [IP4_ARP_ERROR_REPLICATE_FAIL] = "ARP replication failed",
2212 [IP4_ARP_ERROR_NO_SOURCE_ADDRESS] = "no source address for ARP request",
2215 VLIB_REGISTER_NODE (ip4_arp_node) =
2217 .function = ip4_arp,.name = "ip4-arp",.vector_size =
2218 sizeof (u32),.format_trace = format_ip4_forward_next_trace,.n_errors =
2219 ARRAY_LEN (ip4_arp_error_strings),.error_strings =
2220 ip4_arp_error_strings,.n_next_nodes = IP4_ARP_N_NEXT,.next_nodes =
2222 [IP4_ARP_NEXT_DROP] = "error-drop",}
2225 VLIB_REGISTER_NODE (ip4_glean_node) =
2227 .function = ip4_glean,.name = "ip4-glean",.vector_size =
2228 sizeof (u32),.format_trace = format_ip4_forward_next_trace,.n_errors =
2229 ARRAY_LEN (ip4_arp_error_strings),.error_strings =
2230 ip4_arp_error_strings,.n_next_nodes = IP4_ARP_N_NEXT,.next_nodes =
2232 [IP4_ARP_NEXT_DROP] = "error-drop",}
2235 #define foreach_notrace_ip4_arp_error \
2242 arp_notrace_init (vlib_main_t * vm)
2244 vlib_node_runtime_t *rt = vlib_node_get_runtime (vm, ip4_arp_node.index);
2246 /* don't trace ARP request packets */
2248 vnet_pcap_drop_trace_filter_add_del \
2249 (rt->errors[IP4_ARP_ERROR_##a], \
2251 foreach_notrace_ip4_arp_error;
2256 VLIB_INIT_FUNCTION (arp_notrace_init);
2259 /* Send an ARP request to see if given destination is reachable on given interface. */
2261 ip4_probe_neighbor (vlib_main_t * vm, ip4_address_t * dst, u32 sw_if_index)
2263 vnet_main_t *vnm = vnet_get_main ();
2264 ip4_main_t *im = &ip4_main;
2265 ethernet_arp_header_t *h;
2267 ip_interface_address_t *ia;
2268 ip_adjacency_t *adj;
2269 vnet_hw_interface_t *hi;
2270 vnet_sw_interface_t *si;
2274 si = vnet_get_sw_interface (vnm, sw_if_index);
2276 if (!(si->flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP))
2278 return clib_error_return (0, "%U: interface %U down",
2279 format_ip4_address, dst,
2280 format_vnet_sw_if_index_name, vnm,
2285 ip4_interface_address_matching_destination (im, dst, sw_if_index, &ia);
2288 vnm->api_errno = VNET_API_ERROR_NO_MATCHING_INTERFACE;
2289 return clib_error_return
2291 "no matching interface address for destination %U (interface %U)",
2292 format_ip4_address, dst, format_vnet_sw_if_index_name, vnm,
2296 adj = adj_get (ia->neighbor_probe_adj_index);
2299 vlib_packet_template_get_packet (vm,
2300 &im->ip4_arp_request_packet_template,
2303 hi = vnet_get_sup_hw_interface (vnm, sw_if_index);
2305 clib_memcpy (h->ip4_over_ethernet[0].ethernet, hi->hw_address,
2306 sizeof (h->ip4_over_ethernet[0].ethernet));
2308 h->ip4_over_ethernet[0].ip4 = src[0];
2309 h->ip4_over_ethernet[1].ip4 = dst[0];
2311 b = vlib_get_buffer (vm, bi);
2312 vnet_buffer (b)->sw_if_index[VLIB_RX] =
2313 vnet_buffer (b)->sw_if_index[VLIB_TX] = sw_if_index;
2315 /* Add encapsulation string for software interface (e.g. ethernet header). */
2316 vnet_rewrite_one_header (adj[0], h, sizeof (ethernet_header_t));
2317 vlib_buffer_advance (b, -adj->rewrite_header.data_bytes);
2320 vlib_frame_t *f = vlib_get_frame_to_node (vm, hi->output_node_index);
2321 u32 *to_next = vlib_frame_vector_args (f);
2324 vlib_put_frame_to_node (vm, hi->output_node_index, f);
2327 return /* no error */ 0;
2332 IP4_REWRITE_NEXT_DROP,
2333 IP4_REWRITE_NEXT_ICMP_ERROR,
2334 } ip4_rewrite_next_t;
2337 ip4_rewrite_inline (vlib_main_t * vm,
2338 vlib_node_runtime_t * node,
2339 vlib_frame_t * frame,
2340 int do_counters, int is_midchain, int is_mcast)
2342 ip_lookup_main_t *lm = &ip4_main.lookup_main;
2343 u32 *from = vlib_frame_vector_args (frame);
2344 u32 n_left_from, n_left_to_next, *to_next, next_index;
2345 vlib_node_runtime_t *error_node =
2346 vlib_node_get_runtime (vm, ip4_input_node.index);
2348 n_left_from = frame->n_vectors;
2349 next_index = node->cached_next_index;
2350 u32 thread_index = vlib_get_thread_index ();
2352 while (n_left_from > 0)
2354 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
2356 while (n_left_from >= 4 && n_left_to_next >= 2)
2358 ip_adjacency_t *adj0, *adj1;
2359 vlib_buffer_t *p0, *p1;
2360 ip4_header_t *ip0, *ip1;
2361 u32 pi0, rw_len0, next0, error0, checksum0, adj_index0;
2362 u32 pi1, rw_len1, next1, error1, checksum1, adj_index1;
2363 u32 tx_sw_if_index0, tx_sw_if_index1;
2365 /* Prefetch next iteration. */
2367 vlib_buffer_t *p2, *p3;
2369 p2 = vlib_get_buffer (vm, from[2]);
2370 p3 = vlib_get_buffer (vm, from[3]);
2372 vlib_prefetch_buffer_header (p2, STORE);
2373 vlib_prefetch_buffer_header (p3, STORE);
2375 CLIB_PREFETCH (p2->data, sizeof (ip0[0]), STORE);
2376 CLIB_PREFETCH (p3->data, sizeof (ip0[0]), STORE);
2379 pi0 = to_next[0] = from[0];
2380 pi1 = to_next[1] = from[1];
2385 n_left_to_next -= 2;
2387 p0 = vlib_get_buffer (vm, pi0);
2388 p1 = vlib_get_buffer (vm, pi1);
2390 adj_index0 = vnet_buffer (p0)->ip.adj_index[VLIB_TX];
2391 adj_index1 = vnet_buffer (p1)->ip.adj_index[VLIB_TX];
2394 * pre-fetch the per-adjacency counters
2398 vlib_prefetch_combined_counter (&adjacency_counters,
2399 thread_index, adj_index0);
2400 vlib_prefetch_combined_counter (&adjacency_counters,
2401 thread_index, adj_index1);
2404 ip0 = vlib_buffer_get_current (p0);
2405 ip1 = vlib_buffer_get_current (p1);
2407 error0 = error1 = IP4_ERROR_NONE;
2408 next0 = next1 = IP4_REWRITE_NEXT_DROP;
2410 /* Decrement TTL & update checksum.
2411 Works either endian, so no need for byte swap. */
2412 if (PREDICT_TRUE (!(p0->flags & VNET_BUFFER_LOCALLY_ORIGINATED)))
2414 i32 ttl0 = ip0->ttl;
2416 /* Input node should have reject packets with ttl 0. */
2417 ASSERT (ip0->ttl > 0);
2419 checksum0 = ip0->checksum + clib_host_to_net_u16 (0x0100);
2420 checksum0 += checksum0 >= 0xffff;
2422 ip0->checksum = checksum0;
2427 * If the ttl drops below 1 when forwarding, generate
2430 if (PREDICT_FALSE (ttl0 <= 0))
2432 error0 = IP4_ERROR_TIME_EXPIRED;
2433 vnet_buffer (p0)->sw_if_index[VLIB_TX] = (u32) ~ 0;
2434 icmp4_error_set_vnet_buffer (p0, ICMP4_time_exceeded,
2435 ICMP4_time_exceeded_ttl_exceeded_in_transit,
2437 next0 = IP4_REWRITE_NEXT_ICMP_ERROR;
2440 /* Verify checksum. */
2441 ASSERT (ip0->checksum == ip4_header_checksum (ip0));
2445 p0->flags &= ~VNET_BUFFER_LOCALLY_ORIGINATED;
2447 if (PREDICT_TRUE (!(p1->flags & VNET_BUFFER_LOCALLY_ORIGINATED)))
2449 i32 ttl1 = ip1->ttl;
2451 /* Input node should have reject packets with ttl 0. */
2452 ASSERT (ip1->ttl > 0);
2454 checksum1 = ip1->checksum + clib_host_to_net_u16 (0x0100);
2455 checksum1 += checksum1 >= 0xffff;
2457 ip1->checksum = checksum1;
2462 * If the ttl drops below 1 when forwarding, generate
2465 if (PREDICT_FALSE (ttl1 <= 0))
2467 error1 = IP4_ERROR_TIME_EXPIRED;
2468 vnet_buffer (p1)->sw_if_index[VLIB_TX] = (u32) ~ 0;
2469 icmp4_error_set_vnet_buffer (p1, ICMP4_time_exceeded,
2470 ICMP4_time_exceeded_ttl_exceeded_in_transit,
2472 next1 = IP4_REWRITE_NEXT_ICMP_ERROR;
2475 /* Verify checksum. */
2476 ASSERT (ip0->checksum == ip4_header_checksum (ip0));
2477 ASSERT (ip1->checksum == ip4_header_checksum (ip1));
2481 p1->flags &= ~VNET_BUFFER_LOCALLY_ORIGINATED;
2484 /* Rewrite packet header and updates lengths. */
2485 adj0 = adj_get (adj_index0);
2486 adj1 = adj_get (adj_index1);
2488 /* Worth pipelining. No guarantee that adj0,1 are hot... */
2489 rw_len0 = adj0[0].rewrite_header.data_bytes;
2490 rw_len1 = adj1[0].rewrite_header.data_bytes;
2491 vnet_buffer (p0)->ip.save_rewrite_length = rw_len0;
2492 vnet_buffer (p1)->ip.save_rewrite_length = rw_len1;
2494 /* Check MTU of outgoing interface. */
2496 (vlib_buffer_length_in_chain (vm, p0) >
2498 rewrite_header.max_l3_packet_bytes ? IP4_ERROR_MTU_EXCEEDED :
2501 (vlib_buffer_length_in_chain (vm, p1) >
2503 rewrite_header.max_l3_packet_bytes ? IP4_ERROR_MTU_EXCEEDED :
2506 /* Don't adjust the buffer for ttl issue; icmp-error node wants
2507 * to see the IP headerr */
2508 if (PREDICT_TRUE (error0 == IP4_ERROR_NONE))
2510 next0 = adj0[0].rewrite_header.next_index;
2511 p0->current_data -= rw_len0;
2512 p0->current_length += rw_len0;
2513 tx_sw_if_index0 = adj0[0].rewrite_header.sw_if_index;
2514 vnet_buffer (p0)->sw_if_index[VLIB_TX] = tx_sw_if_index0;
2517 (adj0[0].rewrite_header.flags & VNET_REWRITE_HAS_FEATURES))
2518 vnet_feature_arc_start (lm->output_feature_arc_index,
2519 tx_sw_if_index0, &next0, p0);
2521 if (PREDICT_TRUE (error1 == IP4_ERROR_NONE))
2523 next1 = adj1[0].rewrite_header.next_index;
2524 p1->current_data -= rw_len1;
2525 p1->current_length += rw_len1;
2527 tx_sw_if_index1 = adj1[0].rewrite_header.sw_if_index;
2528 vnet_buffer (p1)->sw_if_index[VLIB_TX] = tx_sw_if_index1;
2531 (adj1[0].rewrite_header.flags & VNET_REWRITE_HAS_FEATURES))
2532 vnet_feature_arc_start (lm->output_feature_arc_index,
2533 tx_sw_if_index1, &next1, p1);
2536 /* Guess we are only writing on simple Ethernet header. */
2537 vnet_rewrite_two_headers (adj0[0], adj1[0],
2538 ip0, ip1, sizeof (ethernet_header_t));
2541 * Bump the per-adjacency counters
2545 vlib_increment_combined_counter
2546 (&adjacency_counters,
2549 vlib_buffer_length_in_chain (vm, p0) + rw_len0);
2551 vlib_increment_combined_counter
2552 (&adjacency_counters,
2555 vlib_buffer_length_in_chain (vm, p1) + rw_len1);
2560 adj0->sub_type.midchain.fixup_func (vm, adj0, p0);
2561 adj1->sub_type.midchain.fixup_func (vm, adj1, p1);
2566 * copy bytes from the IP address into the MAC rewrite
2568 vnet_fixup_one_header (adj0[0], &ip0->dst_address, ip0);
2569 vnet_fixup_one_header (adj1[0], &ip1->dst_address, ip1);
2572 vlib_validate_buffer_enqueue_x2 (vm, node, next_index,
2573 to_next, n_left_to_next,
2574 pi0, pi1, next0, next1);
2577 while (n_left_from > 0 && n_left_to_next > 0)
2579 ip_adjacency_t *adj0;
2582 u32 pi0, rw_len0, adj_index0, next0, error0, checksum0;
2583 u32 tx_sw_if_index0;
2585 pi0 = to_next[0] = from[0];
2587 p0 = vlib_get_buffer (vm, pi0);
2589 adj_index0 = vnet_buffer (p0)->ip.adj_index[VLIB_TX];
2591 adj0 = adj_get (adj_index0);
2593 ip0 = vlib_buffer_get_current (p0);
2595 error0 = IP4_ERROR_NONE;
2596 next0 = IP4_REWRITE_NEXT_DROP; /* drop on error */
2598 /* Decrement TTL & update checksum. */
2599 if (PREDICT_TRUE (!(p0->flags & VNET_BUFFER_LOCALLY_ORIGINATED)))
2601 i32 ttl0 = ip0->ttl;
2603 checksum0 = ip0->checksum + clib_host_to_net_u16 (0x0100);
2605 checksum0 += checksum0 >= 0xffff;
2607 ip0->checksum = checksum0;
2609 ASSERT (ip0->ttl > 0);
2615 ASSERT (ip0->checksum == ip4_header_checksum (ip0));
2617 if (PREDICT_FALSE (ttl0 <= 0))
2620 * If the ttl drops below 1 when forwarding, generate
2623 error0 = IP4_ERROR_TIME_EXPIRED;
2624 next0 = IP4_REWRITE_NEXT_ICMP_ERROR;
2625 vnet_buffer (p0)->sw_if_index[VLIB_TX] = (u32) ~ 0;
2626 icmp4_error_set_vnet_buffer (p0, ICMP4_time_exceeded,
2627 ICMP4_time_exceeded_ttl_exceeded_in_transit,
2633 p0->flags &= ~VNET_BUFFER_LOCALLY_ORIGINATED;
2637 vlib_prefetch_combined_counter (&adjacency_counters,
2638 thread_index, adj_index0);
2640 /* Guess we are only writing on simple Ethernet header. */
2641 vnet_rewrite_one_header (adj0[0], ip0, sizeof (ethernet_header_t));
2645 * copy bytes from the IP address into the MAC rewrite
2647 vnet_fixup_one_header (adj0[0], &ip0->dst_address, ip0);
2650 /* Update packet buffer attributes/set output interface. */
2651 rw_len0 = adj0[0].rewrite_header.data_bytes;
2652 vnet_buffer (p0)->ip.save_rewrite_length = rw_len0;
2655 vlib_increment_combined_counter
2656 (&adjacency_counters,
2657 thread_index, adj_index0, 1,
2658 vlib_buffer_length_in_chain (vm, p0) + rw_len0);
2660 /* Check MTU of outgoing interface. */
2661 error0 = (vlib_buffer_length_in_chain (vm, p0)
2662 > adj0[0].rewrite_header.max_l3_packet_bytes
2663 ? IP4_ERROR_MTU_EXCEEDED : error0);
2665 p0->error = error_node->errors[error0];
2667 /* Don't adjust the buffer for ttl issue; icmp-error node wants
2668 * to see the IP headerr */
2669 if (PREDICT_TRUE (error0 == IP4_ERROR_NONE))
2671 p0->current_data -= rw_len0;
2672 p0->current_length += rw_len0;
2673 tx_sw_if_index0 = adj0[0].rewrite_header.sw_if_index;
2675 vnet_buffer (p0)->sw_if_index[VLIB_TX] = tx_sw_if_index0;
2676 next0 = adj0[0].rewrite_header.next_index;
2680 adj0->sub_type.midchain.fixup_func (vm, adj0, p0);
2684 (adj0[0].rewrite_header.flags & VNET_REWRITE_HAS_FEATURES))
2685 vnet_feature_arc_start (lm->output_feature_arc_index,
2686 tx_sw_if_index0, &next0, p0);
2693 n_left_to_next -= 1;
2695 vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
2696 to_next, n_left_to_next,
2700 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
2703 /* Need to do trace after rewrites to pick up new packet data. */
2704 if (node->flags & VLIB_NODE_FLAG_TRACE)
2705 ip4_forward_next_trace (vm, node, frame, VLIB_TX);
2707 return frame->n_vectors;
2711 /** @brief IPv4 rewrite node.
2714 This is the IPv4 transit-rewrite node: decrement TTL, fix the ipv4
2715 header checksum, fetch the ip adjacency, check the outbound mtu,
2716 apply the adjacency rewrite, and send pkts to the adjacency
2717 rewrite header's rewrite_next_index.
2719 @param vm vlib_main_t corresponding to the current thread
2720 @param node vlib_node_runtime_t
2721 @param frame vlib_frame_t whose contents should be dispatched
2723 @par Graph mechanics: buffer metadata, next index usage
2726 - <code>vnet_buffer(b)->ip.adj_index[VLIB_TX]</code>
2727 - the rewrite adjacency index
2728 - <code>adj->lookup_next_index</code>
2729 - Must be IP_LOOKUP_NEXT_REWRITE or IP_LOOKUP_NEXT_ARP, otherwise
2730 the packet will be dropped.
2731 - <code>adj->rewrite_header</code>
2732 - Rewrite string length, rewrite string, next_index
2735 - <code>b->current_data, b->current_length</code>
2736 - Updated net of applying the rewrite string
2738 <em>Next Indices:</em>
2739 - <code> adj->rewrite_header.next_index </code>
2743 ip4_rewrite (vlib_main_t * vm,
2744 vlib_node_runtime_t * node, vlib_frame_t * frame)
2746 if (adj_are_counters_enabled ())
2747 return ip4_rewrite_inline (vm, node, frame, 1, 0, 0);
2749 return ip4_rewrite_inline (vm, node, frame, 0, 0, 0);
2753 ip4_midchain (vlib_main_t * vm,
2754 vlib_node_runtime_t * node, vlib_frame_t * frame)
2756 if (adj_are_counters_enabled ())
2757 return ip4_rewrite_inline (vm, node, frame, 1, 1, 0);
2759 return ip4_rewrite_inline (vm, node, frame, 0, 1, 0);
2763 ip4_rewrite_mcast (vlib_main_t * vm,
2764 vlib_node_runtime_t * node, vlib_frame_t * frame)
2766 if (adj_are_counters_enabled ())
2767 return ip4_rewrite_inline (vm, node, frame, 1, 0, 1);
2769 return ip4_rewrite_inline (vm, node, frame, 0, 0, 1);
2773 ip4_mcast_midchain (vlib_main_t * vm,
2774 vlib_node_runtime_t * node, vlib_frame_t * frame)
2776 if (adj_are_counters_enabled ())
2777 return ip4_rewrite_inline (vm, node, frame, 1, 1, 1);
2779 return ip4_rewrite_inline (vm, node, frame, 0, 1, 1);
2783 VLIB_REGISTER_NODE (ip4_rewrite_node) = {
2784 .function = ip4_rewrite,
2785 .name = "ip4-rewrite",
2786 .vector_size = sizeof (u32),
2788 .format_trace = format_ip4_rewrite_trace,
2792 [IP4_REWRITE_NEXT_DROP] = "error-drop",
2793 [IP4_REWRITE_NEXT_ICMP_ERROR] = "ip4-icmp-error",
2796 VLIB_NODE_FUNCTION_MULTIARCH (ip4_rewrite_node, ip4_rewrite)
2798 VLIB_REGISTER_NODE (ip4_rewrite_mcast_node) = {
2799 .function = ip4_rewrite_mcast,
2800 .name = "ip4-rewrite-mcast",
2801 .vector_size = sizeof (u32),
2803 .format_trace = format_ip4_rewrite_trace,
2804 .sibling_of = "ip4-rewrite",
2806 VLIB_NODE_FUNCTION_MULTIARCH (ip4_rewrite_mcast_node, ip4_rewrite_mcast)
2808 VLIB_REGISTER_NODE (ip4_mcast_midchain_node, static) = {
2809 .function = ip4_mcast_midchain,
2810 .name = "ip4-mcast-midchain",
2811 .vector_size = sizeof (u32),
2813 .format_trace = format_ip4_rewrite_trace,
2814 .sibling_of = "ip4-rewrite",
2816 VLIB_NODE_FUNCTION_MULTIARCH (ip4_mcast_midchain_node, ip4_mcast_midchain)
2818 VLIB_REGISTER_NODE (ip4_midchain_node) = {
2819 .function = ip4_midchain,
2820 .name = "ip4-midchain",
2821 .vector_size = sizeof (u32),
2822 .format_trace = format_ip4_forward_next_trace,
2823 .sibling_of = "ip4-rewrite",
2825 VLIB_NODE_FUNCTION_MULTIARCH (ip4_midchain_node, ip4_midchain);
2828 static clib_error_t *
2829 add_del_interface_table (vlib_main_t * vm,
2830 unformat_input_t * input, vlib_cli_command_t * cmd)
2832 vnet_main_t *vnm = vnet_get_main ();
2833 ip_interface_address_t *ia;
2834 clib_error_t *error = 0;
2835 u32 sw_if_index, table_id;
2839 if (!unformat_user (input, unformat_vnet_sw_interface, vnm, &sw_if_index))
2841 error = clib_error_return (0, "unknown interface `%U'",
2842 format_unformat_error, input);
2846 if (unformat (input, "%d", &table_id))
2850 error = clib_error_return (0, "expected table id `%U'",
2851 format_unformat_error, input);
2856 * If the interface already has in IP address, then a change int
2857 * VRF is not allowed. The IP address applied must first be removed.
2858 * We do not do that automatically here, since VPP has no knowledge
2859 * of whether thoses subnets are valid in the destination VRF.
2862 foreach_ip_interface_address (&ip4_main.lookup_main,
2864 1 /* honor unnumbered */,
2868 a = ip_interface_address_get_address (&ip4_main.lookup_main, ia);
2869 error = clib_error_return (0, "interface %U has address %U",
2870 format_vnet_sw_if_index_name, vnm,
2872 format_ip4_address, a);
2878 ip4_main_t *im = &ip4_main;
2881 fib_index = fib_table_find_or_create_and_lock (FIB_PROTOCOL_IP4, table_id);
2883 vec_validate (im->fib_index_by_sw_if_index, sw_if_index);
2884 im->fib_index_by_sw_if_index[sw_if_index] = fib_index;
2886 fib_index = mfib_table_find_or_create_and_lock (FIB_PROTOCOL_IP4, table_id);
2887 vec_validate (im->mfib_index_by_sw_if_index, sw_if_index);
2888 im->mfib_index_by_sw_if_index[sw_if_index] = fib_index;
2896 * Place the indicated interface into the supplied IPv4 FIB table (also known
2897 * as a VRF). If the FIB table does not exist, this command creates it. To
2898 * display the current IPv4 FIB table, use the command '<em>show ip fib</em>'.
2899 * FIB table will only be displayed if a route has been added to the table, or
2900 * an IP Address is assigned to an interface in the table (which adds a route
2903 * @note IP addresses added after setting the interface IP table are added to
2904 * the indicated FIB table. If an IP address is added prior to changing the
2905 * table then this is an error. The control plane must remove these addresses
2906 * first and then change the table. VPP will not automatically move the
2907 * addresses from the old to the new table as it does not know the validity
2911 * Example of how to add an interface to an IPv4 FIB table (where 2 is the table-id):
2912 * @cliexcmd{set interface ip table GigabitEthernet2/0/0 2}
2915 VLIB_CLI_COMMAND (set_interface_ip_table_command, static) =
2917 .path = "set interface ip table",
2918 .function = add_del_interface_table,
2919 .short_help = "set interface ip table <interface> <table-id>",
2924 ip4_lookup_validate (ip4_address_t * a, u32 fib_index0)
2926 ip4_fib_mtrie_t *mtrie0;
2927 ip4_fib_mtrie_leaf_t leaf0;
2930 mtrie0 = &ip4_fib_get (fib_index0)->mtrie;
2932 leaf0 = ip4_fib_mtrie_lookup_step_one (mtrie0, a);
2933 leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, a, 2);
2934 leaf0 = ip4_fib_mtrie_lookup_step (mtrie0, leaf0, a, 3);
2936 lbi0 = ip4_fib_mtrie_leaf_get_adj_index (leaf0);
2938 return lbi0 == ip4_fib_table_lookup_lb (ip4_fib_get (fib_index0), a);
2941 static clib_error_t *
2942 test_lookup_command_fn (vlib_main_t * vm,
2943 unformat_input_t * input, vlib_cli_command_t * cmd)
2950 ip4_address_t ip4_base_address;
2953 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2955 if (unformat (input, "table %d", &table_id))
2957 /* Make sure the entry exists. */
2958 fib = ip4_fib_get (table_id);
2959 if ((fib) && (fib->index != table_id))
2960 return clib_error_return (0, "<fib-index> %d does not exist",
2963 else if (unformat (input, "count %f", &count))
2966 else if (unformat (input, "%U",
2967 unformat_ip4_address, &ip4_base_address))
2970 return clib_error_return (0, "unknown input `%U'",
2971 format_unformat_error, input);
2976 for (i = 0; i < n; i++)
2978 if (!ip4_lookup_validate (&ip4_base_address, table_id))
2981 ip4_base_address.as_u32 =
2982 clib_host_to_net_u32 (1 +
2983 clib_net_to_host_u32 (ip4_base_address.as_u32));
2987 vlib_cli_output (vm, "%llu errors out of %d lookups\n", errors, n);
2989 vlib_cli_output (vm, "No errors in %d lookups\n", n);
2995 * Perform a lookup of an IPv4 Address (or range of addresses) in the
2996 * given FIB table to determine if there is a conflict with the
2997 * adjacency table. The fib-id can be determined by using the
2998 * '<em>show ip fib</em>' command. If fib-id is not entered, default value
3001 * @todo This command uses fib-id, other commands use table-id (not
3002 * just a name, they are different indexes). Would like to change this
3003 * to table-id for consistency.
3006 * Example of how to run the test lookup command:
3007 * @cliexstart{test lookup 172.16.1.1 table 1 count 2}
3008 * No errors in 2 lookups
3012 VLIB_CLI_COMMAND (lookup_test_command, static) =
3014 .path = "test lookup",
3015 .short_help = "test lookup <ipv4-addr> [table <fib-id>] [count <nn>]",
3016 .function = test_lookup_command_fn,
3021 vnet_set_ip4_flow_hash (u32 table_id, u32 flow_hash_config)
3026 fib_index = fib_table_find (FIB_PROTOCOL_IP4, table_id);
3028 if (~0 == fib_index)
3029 return VNET_API_ERROR_NO_SUCH_FIB;
3031 fib = ip4_fib_get (fib_index);
3033 fib->flow_hash_config = flow_hash_config;
3037 static clib_error_t *
3038 set_ip_flow_hash_command_fn (vlib_main_t * vm,
3039 unformat_input_t * input,
3040 vlib_cli_command_t * cmd)
3044 u32 flow_hash_config = 0;
3047 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
3049 if (unformat (input, "table %d", &table_id))
3052 else if (unformat (input, #a)) { flow_hash_config |= v; matched=1;}
3053 foreach_flow_hash_bit
3060 return clib_error_return (0, "unknown input `%U'",
3061 format_unformat_error, input);
3063 rv = vnet_set_ip4_flow_hash (table_id, flow_hash_config);
3069 case VNET_API_ERROR_NO_SUCH_FIB:
3070 return clib_error_return (0, "no such FIB table %d", table_id);
3073 clib_warning ("BUG: illegal flow hash config 0x%x", flow_hash_config);
3081 * Configure the set of IPv4 fields used by the flow hash.
3084 * Example of how to set the flow hash on a given table:
3085 * @cliexcmd{set ip flow-hash table 7 dst sport dport proto}
3086 * Example of display the configured flow hash:
3087 * @cliexstart{show ip fib}
3088 * ipv4-VRF:0, fib_index 0, flow hash: src dst sport dport proto
3091 * [@0]: dpo-load-balance: [index:0 buckets:1 uRPF:0 to:[0:0]]
3092 * [0] [@0]: dpo-drop ip6
3095 * [@0]: dpo-load-balance: [index:1 buckets:1 uRPF:1 to:[0:0]]
3096 * [0] [@0]: dpo-drop ip6
3099 * [@0]: dpo-load-balance: [index:3 buckets:1 uRPF:3 to:[0:0]]
3100 * [0] [@0]: dpo-drop ip6
3103 * [@0]: dpo-load-balance: [index:30 buckets:1 uRPF:29 to:[0:0]]
3104 * [0] [@3]: arp-ipv4: via 6.0.0.1 af_packet0
3107 * [@0]: dpo-load-balance: [index:31 buckets:4 uRPF:30 to:[0:0]]
3108 * [0] [@3]: arp-ipv4: via 6.0.0.2 af_packet0
3109 * [1] [@3]: arp-ipv4: via 6.0.0.2 af_packet0
3110 * [2] [@3]: arp-ipv4: via 6.0.0.2 af_packet0
3111 * [3] [@3]: arp-ipv4: via 6.0.0.1 af_packet0
3114 * [@0]: dpo-load-balance: [index:2 buckets:1 uRPF:2 to:[0:0]]
3115 * [0] [@0]: dpo-drop ip6
3116 * 255.255.255.255/32
3118 * [@0]: dpo-load-balance: [index:4 buckets:1 uRPF:4 to:[0:0]]
3119 * [0] [@0]: dpo-drop ip6
3120 * ipv4-VRF:7, fib_index 1, flow hash: dst sport dport proto
3123 * [@0]: dpo-load-balance: [index:12 buckets:1 uRPF:11 to:[0:0]]
3124 * [0] [@0]: dpo-drop ip6
3127 * [@0]: dpo-load-balance: [index:13 buckets:1 uRPF:12 to:[0:0]]
3128 * [0] [@0]: dpo-drop ip6
3131 * [@0]: dpo-load-balance: [index:17 buckets:1 uRPF:16 to:[0:0]]
3132 * [0] [@4]: ipv4-glean: af_packet0
3135 * [@0]: dpo-load-balance: [index:18 buckets:1 uRPF:17 to:[1:84]]
3136 * [0] [@2]: dpo-receive: 172.16.1.1 on af_packet0
3139 * [@0]: dpo-load-balance: [index:21 buckets:1 uRPF:20 to:[0:0]]
3140 * [0] [@5]: ipv4 via 172.16.1.2 af_packet0: IP4: 02:fe:9e:70:7a:2b -> 26:a5:f6:9c:3a:36
3143 * [@0]: dpo-load-balance: [index:19 buckets:1 uRPF:18 to:[0:0]]
3144 * [0] [@4]: ipv4-glean: af_packet1
3147 * [@0]: dpo-load-balance: [index:20 buckets:1 uRPF:19 to:[0:0]]
3148 * [0] [@2]: dpo-receive: 172.16.2.1 on af_packet1
3151 * [@0]: dpo-load-balance: [index:15 buckets:1 uRPF:14 to:[0:0]]
3152 * [0] [@0]: dpo-drop ip6
3155 * [@0]: dpo-load-balance: [index:14 buckets:1 uRPF:13 to:[0:0]]
3156 * [0] [@0]: dpo-drop ip6
3157 * 255.255.255.255/32
3159 * [@0]: dpo-load-balance: [index:16 buckets:1 uRPF:15 to:[0:0]]
3160 * [0] [@0]: dpo-drop ip6
3164 VLIB_CLI_COMMAND (set_ip_flow_hash_command, static) =
3166 .path = "set ip flow-hash",
3168 "set ip flow-hash table <table-id> [src] [dst] [sport] [dport] [proto] [reverse]",
3169 .function = set_ip_flow_hash_command_fn,
3174 vnet_set_ip4_classify_intfc (vlib_main_t * vm, u32 sw_if_index,
3177 vnet_main_t *vnm = vnet_get_main ();
3178 vnet_interface_main_t *im = &vnm->interface_main;
3179 ip4_main_t *ipm = &ip4_main;
3180 ip_lookup_main_t *lm = &ipm->lookup_main;
3181 vnet_classify_main_t *cm = &vnet_classify_main;
3182 ip4_address_t *if_addr;
3184 if (pool_is_free_index (im->sw_interfaces, sw_if_index))
3185 return VNET_API_ERROR_NO_MATCHING_INTERFACE;
3187 if (table_index != ~0 && pool_is_free_index (cm->tables, table_index))
3188 return VNET_API_ERROR_NO_SUCH_ENTRY;
3190 vec_validate (lm->classify_table_index_by_sw_if_index, sw_if_index);
3191 lm->classify_table_index_by_sw_if_index[sw_if_index] = table_index;
3193 if_addr = ip4_interface_first_address (ipm, sw_if_index, NULL);
3195 if (NULL != if_addr)
3197 fib_prefix_t pfx = {
3199 .fp_proto = FIB_PROTOCOL_IP4,
3200 .fp_addr.ip4 = *if_addr,
3204 fib_index = fib_table_get_index_for_sw_if_index (FIB_PROTOCOL_IP4,
3208 if (table_index != (u32) ~ 0)
3210 dpo_id_t dpo = DPO_INVALID;
3215 classify_dpo_create (DPO_PROTO_IP4, table_index));
3217 fib_table_entry_special_dpo_add (fib_index,
3219 FIB_SOURCE_CLASSIFY,
3220 FIB_ENTRY_FLAG_NONE, &dpo);
3225 fib_table_entry_special_remove (fib_index,
3226 &pfx, FIB_SOURCE_CLASSIFY);
3233 static clib_error_t *
3234 set_ip_classify_command_fn (vlib_main_t * vm,
3235 unformat_input_t * input,
3236 vlib_cli_command_t * cmd)
3238 u32 table_index = ~0;
3239 int table_index_set = 0;
3240 u32 sw_if_index = ~0;
3243 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
3245 if (unformat (input, "table-index %d", &table_index))
3246 table_index_set = 1;
3247 else if (unformat (input, "intfc %U", unformat_vnet_sw_interface,
3248 vnet_get_main (), &sw_if_index))
3254 if (table_index_set == 0)
3255 return clib_error_return (0, "classify table-index must be specified");
3257 if (sw_if_index == ~0)
3258 return clib_error_return (0, "interface / subif must be specified");
3260 rv = vnet_set_ip4_classify_intfc (vm, sw_if_index, table_index);
3267 case VNET_API_ERROR_NO_MATCHING_INTERFACE:
3268 return clib_error_return (0, "No such interface");
3270 case VNET_API_ERROR_NO_SUCH_ENTRY:
3271 return clib_error_return (0, "No such classifier table");
3277 * Assign a classification table to an interface. The classification
3278 * table is created using the '<em>classify table</em>' and '<em>classify session</em>'
3279 * commands. Once the table is create, use this command to filter packets
3283 * Example of how to assign a classification table to an interface:
3284 * @cliexcmd{set ip classify intfc GigabitEthernet2/0/0 table-index 1}
3287 VLIB_CLI_COMMAND (set_ip_classify_command, static) =
3289 .path = "set ip classify",
3291 "set ip classify intfc <interface> table-index <classify-idx>",
3292 .function = set_ip_classify_command_fn,
3297 * fd.io coding-style-patch-verification: ON
3300 * eval: (c-set-style "gnu")