1 /*---------------------------------------------------------------------------
2 * Copyright (c) 2009-2014 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.
14 *---------------------------------------------------------------------------
17 * IPv4 Fragmentation Node
24 #include <vnet/ip/ip.h>
27 * Copy the mpls header if present.
28 * The current is pointing to the ip header.
29 * Adjust the buffer and point to the mpls headers on these fragments
30 * before sending the packet back to mpls-output node.
33 copy_mpls_hdr (vlib_buffer_t * to_b, vlib_buffer_t * from_b)
35 if ((vnet_buffer (from_b)->ip_frag.flags) & IP_FRAG_FLAG_MPLS_HEADER)
37 u8 mpls_hdr_length = vnet_buffer (from_b)->mpls.mpls_hdr_length;
38 u8 *org_from_mpls_packet =
39 from_b->data + (from_b->current_data - mpls_hdr_length);
40 clib_memcpy_fast ((to_b->data - mpls_hdr_length), org_from_mpls_packet,
42 vlib_buffer_advance (to_b, -vnet_buffer (to_b)->mpls.mpls_hdr_length);
55 format_ip_frag_trace (u8 * s, va_list * args)
57 CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
58 CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
59 ip_frag_trace_t *t = va_arg (*args, ip_frag_trace_t *);
60 s = format (s, "IPv%s mtu: %u fragments: %u next: %d",
61 t->ipv6 ? "6" : "4", t->mtu, t->n_fragments, t->next);
65 static u32 running_fragment_id;
68 frag_set_sw_if_index (vlib_buffer_t * to, vlib_buffer_t * from)
70 vnet_buffer (to)->sw_if_index[VLIB_RX] =
71 vnet_buffer (from)->sw_if_index[VLIB_RX];
72 vnet_buffer (to)->sw_if_index[VLIB_TX] =
73 vnet_buffer (from)->sw_if_index[VLIB_TX];
75 /* Copy adj_index in case DPO based node is sending for the
76 * fragmentation, the packet would be sent back to the proper
77 * DPO next node and Index
79 vnet_buffer (to)->ip.adj_index[VLIB_RX] =
80 vnet_buffer (from)->ip.adj_index[VLIB_RX];
81 vnet_buffer (to)->ip.adj_index[VLIB_TX] =
82 vnet_buffer (from)->ip.adj_index[VLIB_TX];
85 if (PREDICT_TRUE (from->flags & VNET_BUFFER_F_QOS_DATA_VALID))
87 vnet_buffer2 (to)->qos = vnet_buffer2 (from)->qos;
88 to->flags |= VNET_BUFFER_F_QOS_DATA_VALID;
91 /* Copy mpls opaque data */
92 if ((vnet_buffer (from)->ip_frag.flags) & IP_FRAG_FLAG_MPLS_HEADER)
94 vnet_buffer (to)->mpls.pyld_proto = vnet_buffer (from)->mpls.pyld_proto;
95 vnet_buffer (to)->mpls.mpls_hdr_length =
96 vnet_buffer (from)->mpls.mpls_hdr_length;
100 static vlib_buffer_t *
101 frag_buffer_alloc (vlib_buffer_t * org_b, u32 * bi)
103 vlib_main_t *vm = vlib_get_main ();
104 if (vlib_buffer_alloc (vm, bi, 1) != 1)
107 vlib_buffer_t *b = vlib_get_buffer (vm, *bi);
108 VLIB_BUFFER_TRACE_TRAJECTORY_INIT (b);
109 vlib_buffer_copy_trace_flag (vm, org_b, *bi);
115 * Limitation: Does follow buffer chains in the packet to fragment,
116 * but does not generate buffer chains. I.e. a fragment is always
117 * contained with in a single buffer and limited to the max buffer
121 ip4_frag_do_fragment (vlib_main_t * vm, u32 from_bi, u32 ** buffer,
122 ip_frag_error_t * error)
124 vlib_buffer_t *from_b;
126 u16 mtu, len, max, rem, ip_frag_id, ip_frag_offset;
127 u8 *org_from_packet, more;
129 from_b = vlib_get_buffer (vm, from_bi);
130 mtu = vnet_buffer (from_b)->ip_frag.mtu;
131 org_from_packet = vlib_buffer_get_current (from_b);
132 ip4 = (ip4_header_t *) vlib_buffer_get_current (from_b);
134 rem = clib_net_to_host_u16 (ip4->length) - sizeof (ip4_header_t);
136 (clib_min (mtu, vlib_buffer_get_default_data_size (vm)) -
137 sizeof (ip4_header_t)) & ~0x7;
140 (vlib_buffer_length_in_chain (vm, from_b) - sizeof (ip4_header_t)))
142 *error = IP_FRAG_ERROR_MALFORMED;
146 if (mtu < sizeof (ip4_header_t))
148 *error = IP_FRAG_ERROR_CANT_FRAGMENT_HEADER;
152 if (ip4->flags_and_fragment_offset &
153 clib_host_to_net_u16 (IP4_HEADER_FLAG_DONT_FRAGMENT))
155 *error = IP_FRAG_ERROR_DONT_FRAGMENT_SET;
159 if (ip4_is_fragment (ip4))
161 ip_frag_id = ip4->fragment_id;
162 ip_frag_offset = ip4_get_fragment_offset (ip4);
164 !(!(ip4->flags_and_fragment_offset &
165 clib_host_to_net_u16 (IP4_HEADER_FLAG_MORE_FRAGMENTS)));
169 ip_frag_id = (++running_fragment_id);
174 u8 *from_data = (void *) (ip4 + 1);
175 vlib_buffer_t *org_from_b = from_b;
177 u16 left_in_from_buffer = from_b->current_length - sizeof (ip4_header_t);
180 /* Do the actual fragmentation */
185 ip4_header_t *to_ip4;
188 len = (rem > max ? max : rem);
189 if (len != rem) /* Last fragment does not need to divisible by 8 */
191 if ((to_b = frag_buffer_alloc (org_from_b, &to_bi)) == 0)
193 *error = IP_FRAG_ERROR_MEMORY;
196 vec_add1 (*buffer, to_bi);
197 frag_set_sw_if_index (to_b, org_from_b);
199 /* Copy ip4 header */
200 clib_memcpy_fast (to_b->data, org_from_packet, sizeof (ip4_header_t));
201 to_ip4 = vlib_buffer_get_current (to_b);
202 to_data = (void *) (to_ip4 + 1);
203 vnet_buffer (to_b)->l3_hdr_offset = to_b->current_data;
204 to_b->flags |= VNET_BUFFER_F_L3_HDR_OFFSET_VALID;
206 if (from_b->flags & VNET_BUFFER_F_L4_HDR_OFFSET_VALID)
208 vnet_buffer (to_b)->l4_hdr_offset =
209 (vnet_buffer (to_b)->l3_hdr_offset +
210 (vnet_buffer (from_b)->l4_hdr_offset -
211 vnet_buffer (from_b)->l3_hdr_offset));
212 to_b->flags |= VNET_BUFFER_F_L4_HDR_OFFSET_VALID;
215 /* Spin through from buffers filling up the to buffer */
216 u16 left_in_to_buffer = len, to_ptr = 0;
221 /* Figure out how many bytes we can safely copy */
222 bytes_to_copy = left_in_to_buffer <= left_in_from_buffer ?
223 left_in_to_buffer : left_in_from_buffer;
224 clib_memcpy_fast (to_data + to_ptr, from_data + ptr, bytes_to_copy);
225 left_in_to_buffer -= bytes_to_copy;
226 ptr += bytes_to_copy;
227 left_in_from_buffer -= bytes_to_copy;
228 if (left_in_to_buffer == 0)
231 ASSERT (left_in_from_buffer <= 0);
233 if (!(from_b->flags & VLIB_BUFFER_NEXT_PRESENT))
235 *error = IP_FRAG_ERROR_MALFORMED;
238 from_b = vlib_get_buffer (vm, from_b->next_buffer);
239 from_data = (u8 *) vlib_buffer_get_current (from_b);
241 left_in_from_buffer = from_b->current_length;
242 to_ptr += bytes_to_copy;
245 to_b->current_length = len + sizeof (ip4_header_t);
246 to_b->flags |= VNET_BUFFER_F_IS_IP4;
248 to_ip4->fragment_id = ip_frag_id;
249 to_ip4->flags_and_fragment_offset =
250 clib_host_to_net_u16 ((fo >> 3) + ip_frag_offset);
251 to_ip4->flags_and_fragment_offset |=
252 clib_host_to_net_u16 (((len != rem) || more) << 13);
253 to_ip4->length = clib_host_to_net_u16 (len + sizeof (ip4_header_t));
254 to_ip4->checksum = ip4_header_checksum (to_ip4);
256 /* we've just done the IP checksum .. */
257 to_b->flags &= ~VNET_BUFFER_F_OFFLOAD_IP_CKSUM;
259 if (vnet_buffer (org_from_b)->ip_frag.flags & IP_FRAG_FLAG_IP4_HEADER)
261 /* Encapsulating ipv4 header */
262 ip4_header_t *encap_header4 =
263 (ip4_header_t *) vlib_buffer_get_current (to_b);
264 encap_header4->length = clib_host_to_net_u16 (to_b->current_length);
265 encap_header4->checksum = ip4_header_checksum (encap_header4);
267 else if (vnet_buffer (org_from_b)->
268 ip_frag.flags & IP_FRAG_FLAG_IP6_HEADER)
270 /* Encapsulating ipv6 header */
271 ip6_header_t *encap_header6 =
272 (ip6_header_t *) vlib_buffer_get_current (to_b);
273 encap_header6->payload_length =
274 clib_host_to_net_u16 (to_b->current_length -
275 sizeof (*encap_header6));
278 /* Copy mpls header if present */
279 copy_mpls_hdr (to_b, org_from_b);
287 ip_frag_set_vnet_buffer (vlib_buffer_t * b, u16 mtu, u8 next_index, u8 flags)
289 vnet_buffer (b)->ip_frag.mtu = mtu;
290 vnet_buffer (b)->ip_frag.next_index = next_index;
291 vnet_buffer (b)->ip_frag.flags = flags;
296 frag_node_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
297 vlib_frame_t * frame, u32 node_index, bool is_ip6)
299 u32 n_left_from, *from, next_index, *to_next, n_left_to_next;
300 vlib_node_runtime_t *error_node = vlib_node_get_runtime (vm, node_index);
301 from = vlib_frame_vector_args (frame);
302 n_left_from = frame->n_vectors;
303 next_index = node->cached_next_index;
304 u32 frag_sent = 0, small_packets = 0;
307 while (n_left_from > 0)
309 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
311 while (n_left_from > 0 && n_left_to_next > 0)
313 u32 pi0, *frag_from, frag_left;
315 ip_frag_error_t error0;
319 * Note: The packet is not enqueued now. It is instead put
320 * in a vector where other fragments will be put as well.
325 error0 = IP_FRAG_ERROR_NONE;
327 p0 = vlib_get_buffer (vm, pi0);
329 ip6_frag_do_fragment (vm, pi0, &buffer, &error0);
331 ip4_frag_do_fragment (vm, pi0, &buffer, &error0);
333 if (PREDICT_FALSE (p0->flags & VLIB_BUFFER_IS_TRACED))
335 ip_frag_trace_t *tr =
336 vlib_add_trace (vm, node, p0, sizeof (*tr));
337 tr->mtu = vnet_buffer (p0)->ip_frag.mtu;
338 tr->ipv6 = is_ip6 ? 1 : 0;
339 tr->n_fragments = vec_len (buffer);
340 tr->next = vnet_buffer (p0)->ip_frag.next_index;
343 if (!is_ip6 && error0 == IP_FRAG_ERROR_DONT_FRAGMENT_SET)
345 icmp4_error_set_vnet_buffer (p0, ICMP4_destination_unreachable,
346 ICMP4_destination_unreachable_fragmentation_needed_and_dont_fragment_set,
347 vnet_buffer (p0)->ip_frag.mtu);
348 next0 = IP4_FRAG_NEXT_ICMP_ERROR;
355 IP_FRAG_ERROR_NONE) ? vnet_buffer (p0)->
356 ip_frag.next_index : IP6_FRAG_NEXT_DROP;
360 IP_FRAG_ERROR_NONE) ? vnet_buffer (p0)->
361 ip_frag.next_index : IP4_FRAG_NEXT_DROP;
364 if (error0 == IP_FRAG_ERROR_NONE)
366 /* Free original buffer chain */
367 frag_sent += vec_len (buffer);
368 small_packets += (vec_len (buffer) == 1);
369 vlib_buffer_free_one (vm, pi0); /* Free original packet */
373 vlib_error_count (vm, node_index, error0, 1);
374 vec_add1 (buffer, pi0); /* Get rid of the original buffer */
377 /* Send fragments that were added in the frame */
379 frag_left = vec_len (buffer);
381 while (frag_left > 0)
383 while (frag_left > 0 && n_left_to_next > 0)
386 i = to_next[0] = frag_from[0];
392 vlib_get_buffer (vm, i)->error = error_node->errors[error0];
393 vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
394 to_next, n_left_to_next, i,
397 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
398 vlib_get_next_frame (vm, node, next_index, to_next,
401 vec_reset_length (buffer);
403 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
407 vlib_node_increment_counter (vm, node_index,
408 IP_FRAG_ERROR_FRAGMENT_SENT, frag_sent);
409 vlib_node_increment_counter (vm, node_index,
410 IP_FRAG_ERROR_SMALL_PACKET, small_packets);
412 return frame->n_vectors;
418 ip4_frag (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
420 return frag_node_inline (vm, node, frame, ip4_frag_node.index,
425 ip6_frag (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
427 return frag_node_inline (vm, node, frame, ip6_frag_node.index,
432 * Fragments the packet given in from_bi. Fragments are returned in the buffer vector.
433 * Caller must ensure the original packet is freed.
436 ip6_frag_do_fragment (vlib_main_t * vm, u32 from_bi, u32 ** buffer,
437 ip_frag_error_t * error)
439 vlib_buffer_t *from_b;
441 u16 mtu, len, max, rem, ip_frag_id;
443 from_b = vlib_get_buffer (vm, from_bi);
444 mtu = vnet_buffer (from_b)->ip_frag.mtu;
445 ip6 = (ip6_header_t *) vlib_buffer_get_current (from_b);
447 rem = clib_net_to_host_u16 (ip6->payload_length);
448 max = (mtu - sizeof (ip6_header_t) - sizeof (ip6_frag_hdr_t)) & ~0x7; // TODO: Is max correct??
451 (vlib_buffer_length_in_chain (vm, from_b) - sizeof (ip6_header_t)))
453 *error = IP_FRAG_ERROR_MALFORMED;
457 /* TODO: Look through header chain for fragmentation header */
458 if (ip6->protocol == IP_PROTOCOL_IPV6_FRAGMENTATION)
460 *error = IP_FRAG_ERROR_MALFORMED;
464 u8 *from_data = (void *) (ip6 + 1);
465 vlib_buffer_t *org_from_b = from_b;
467 u16 left_in_from_buffer = from_b->current_length - sizeof (ip6_header_t);
470 ip_frag_id = ++running_fragment_id; // Fix
472 /* Do the actual fragmentation */
477 ip6_header_t *to_ip6;
478 ip6_frag_hdr_t *to_frag_hdr;
483 (mtu - sizeof (ip6_header_t) - sizeof (ip6_frag_hdr_t)) ? max : rem);
484 if (len != rem) /* Last fragment does not need to divisible by 8 */
486 if ((to_b = frag_buffer_alloc (org_from_b, &to_bi)) == 0)
488 *error = IP_FRAG_ERROR_MEMORY;
491 vec_add1 (*buffer, to_bi);
492 frag_set_sw_if_index (to_b, org_from_b);
494 /* Copy ip6 header */
495 clib_memcpy_fast (to_b->data, ip6, sizeof (ip6_header_t));
496 to_ip6 = vlib_buffer_get_current (to_b);
497 to_frag_hdr = (ip6_frag_hdr_t *) (to_ip6 + 1);
498 to_data = (void *) (to_frag_hdr + 1);
500 vnet_buffer (to_b)->l3_hdr_offset = to_b->current_data;
501 to_b->flags |= VNET_BUFFER_F_L3_HDR_OFFSET_VALID;
503 if (from_b->flags & VNET_BUFFER_F_L4_HDR_OFFSET_VALID)
505 vnet_buffer (to_b)->l4_hdr_offset =
506 (vnet_buffer (to_b)->l3_hdr_offset +
507 (vnet_buffer (from_b)->l4_hdr_offset -
508 vnet_buffer (from_b)->l3_hdr_offset));
509 to_b->flags |= VNET_BUFFER_F_L4_HDR_OFFSET_VALID;
511 to_b->flags |= VNET_BUFFER_F_IS_IP6;
513 /* Spin through from buffers filling up the to buffer */
514 u16 left_in_to_buffer = len, to_ptr = 0;
519 /* Figure out how many bytes we can safely copy */
520 bytes_to_copy = left_in_to_buffer <= left_in_from_buffer ?
521 left_in_to_buffer : left_in_from_buffer;
522 clib_memcpy_fast (to_data + to_ptr, from_data + ptr, bytes_to_copy);
523 left_in_to_buffer -= bytes_to_copy;
524 ptr += bytes_to_copy;
525 left_in_from_buffer -= bytes_to_copy;
526 if (left_in_to_buffer == 0)
529 ASSERT (left_in_from_buffer <= 0);
531 if (!(from_b->flags & VLIB_BUFFER_NEXT_PRESENT))
533 *error = IP_FRAG_ERROR_MALFORMED;
536 from_b = vlib_get_buffer (vm, from_b->next_buffer);
537 from_data = (u8 *) vlib_buffer_get_current (from_b);
539 left_in_from_buffer = from_b->current_length;
540 to_ptr += bytes_to_copy;
543 to_b->current_length =
544 len + sizeof (ip6_header_t) + sizeof (ip6_frag_hdr_t);
545 to_ip6->payload_length =
546 clib_host_to_net_u16 (len + sizeof (ip6_frag_hdr_t));
547 to_ip6->protocol = IP_PROTOCOL_IPV6_FRAGMENTATION;
548 to_frag_hdr->fragment_offset_and_more =
549 ip6_frag_hdr_offset_and_more ((fo >> 3), len != rem);
550 to_frag_hdr->identification = ip_frag_id;
551 to_frag_hdr->next_hdr = ip6->protocol;
552 to_frag_hdr->rsv = 0;
554 /* Copy mpls header if present */
555 copy_mpls_hdr (to_b, org_from_b);
562 static char *ip4_frag_error_strings[] = {
563 #define _(sym,string) string,
564 foreach_ip_frag_error
569 VLIB_REGISTER_NODE (ip4_frag_node) = {
570 .function = ip4_frag,
571 .name = IP4_FRAG_NODE_NAME,
572 .vector_size = sizeof (u32),
573 .format_trace = format_ip_frag_trace,
574 .type = VLIB_NODE_TYPE_INTERNAL,
576 .n_errors = IP_FRAG_N_ERROR,
577 .error_strings = ip4_frag_error_strings,
579 .n_next_nodes = IP4_FRAG_N_NEXT,
581 [IP4_FRAG_NEXT_IP4_REWRITE] = "ip4-rewrite",
582 [IP4_FRAG_NEXT_IP4_REWRITE_MIDCHAIN] = "ip4-midchain",
583 [IP4_FRAG_NEXT_IP4_LOOKUP] = "ip4-lookup",
584 [IP4_FRAG_NEXT_IP6_LOOKUP] = "ip6-lookup",
585 [IP4_FRAG_NEXT_MPLS_OUTPUT] = "mpls-output",
586 [IP4_FRAG_NEXT_ICMP_ERROR] = "ip4-icmp-error",
587 [IP4_FRAG_NEXT_DROP] = "ip4-drop"
593 VLIB_REGISTER_NODE (ip6_frag_node) = {
594 .function = ip6_frag,
595 .name = IP6_FRAG_NODE_NAME,
596 .vector_size = sizeof (u32),
597 .format_trace = format_ip_frag_trace,
598 .type = VLIB_NODE_TYPE_INTERNAL,
600 .n_errors = IP_FRAG_N_ERROR,
601 .error_strings = ip4_frag_error_strings,
603 .n_next_nodes = IP6_FRAG_N_NEXT,
605 [IP6_FRAG_NEXT_IP6_REWRITE] = "ip6-rewrite",
606 [IP6_FRAG_NEXT_IP6_REWRITE_MIDCHAIN] = "ip6-midchain",
607 [IP6_FRAG_NEXT_IP4_LOOKUP] = "ip4-lookup",
608 [IP6_FRAG_NEXT_IP6_LOOKUP] = "ip6-lookup",
609 [IP6_FRAG_NEXT_MPLS_OUTPUT] = "mpls-output",
610 [IP6_FRAG_NEXT_DROP] = "ip6-drop"
616 * fd.io coding-style-patch-verification: ON
619 * eval: (c-set-style "gnu")