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>
35 format_ip_frag_trace (u8 * s, va_list * args)
37 CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
38 CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
39 ip_frag_trace_t *t = va_arg (*args, ip_frag_trace_t *);
40 s = format (s, "mtu: %u pkt-size: %u fragments: %u next: %d", t->mtu,
41 t->pkt_size, t->n_fragments, t->next);
45 static u32 running_fragment_id;
48 frag_set_sw_if_index (vlib_buffer_t * to, vlib_buffer_t * from)
50 vnet_buffer (to)->sw_if_index[VLIB_RX] =
51 vnet_buffer (from)->sw_if_index[VLIB_RX];
52 vnet_buffer (to)->sw_if_index[VLIB_TX] =
53 vnet_buffer (from)->sw_if_index[VLIB_TX];
55 /* Copy adj_index in case DPO based node is sending for the
56 * fragmentation, the packet would be sent back to the proper
57 * DPO next node and Index
59 vnet_buffer (to)->ip.adj_index[VLIB_RX] =
60 vnet_buffer (from)->ip.adj_index[VLIB_RX];
61 vnet_buffer (to)->ip.adj_index[VLIB_TX] =
62 vnet_buffer (from)->ip.adj_index[VLIB_TX];
65 if (PREDICT_TRUE (from->flags & VNET_BUFFER_F_QOS_DATA_VALID))
67 vnet_buffer2 (to)->qos = vnet_buffer2 (from)->qos;
68 to->flags |= VNET_BUFFER_F_QOS_DATA_VALID;
72 static vlib_buffer_t *
73 frag_buffer_alloc (vlib_buffer_t * org_b, u32 * bi)
75 vlib_main_t *vm = vlib_get_main ();
76 if (vlib_buffer_alloc (vm, bi, 1) != 1)
79 vlib_buffer_t *b = vlib_get_buffer (vm, *bi);
80 vlib_buffer_copy_trace_flag (vm, org_b, *bi);
86 * Limitation: Does follow buffer chains in the packet to fragment,
87 * but does not generate buffer chains. I.e. a fragment is always
88 * contained with in a single buffer and limited to the max buffer
90 * from_bi: current pointer must point to IPv4 header
93 ip4_frag_do_fragment (vlib_main_t * vm, u32 from_bi, u16 mtu,
94 u16 l2unfragmentablesize, u32 ** buffer)
96 vlib_buffer_t *from_b;
98 u16 len, max, rem, ip_frag_id, ip_frag_offset, head_bytes;
99 u8 *org_from_packet, more;
101 from_b = vlib_get_buffer (vm, from_bi);
102 org_from_packet = vlib_buffer_get_current (from_b);
103 ip4 = vlib_buffer_get_current (from_b) + l2unfragmentablesize;
105 rem = clib_net_to_host_u16 (ip4->length) - sizeof (ip4_header_t);
106 head_bytes = sizeof (ip4_header_t) + l2unfragmentablesize;
107 max = (clib_min (mtu, vlib_buffer_get_default_data_size (vm)) - head_bytes) &
111 (vlib_buffer_length_in_chain (vm, from_b) - sizeof (ip4_header_t)))
113 return IP_FRAG_ERROR_MALFORMED;
116 if (mtu < sizeof (ip4_header_t))
118 return IP_FRAG_ERROR_CANT_FRAGMENT_HEADER;
121 if (ip4->flags_and_fragment_offset &
122 clib_host_to_net_u16 (IP4_HEADER_FLAG_DONT_FRAGMENT))
124 return IP_FRAG_ERROR_DONT_FRAGMENT_SET;
127 if (ip4_is_fragment (ip4))
129 ip_frag_id = ip4->fragment_id;
130 ip_frag_offset = ip4_get_fragment_offset (ip4);
132 !(!(ip4->flags_and_fragment_offset &
133 clib_host_to_net_u16 (IP4_HEADER_FLAG_MORE_FRAGMENTS)));
137 ip_frag_id = (++running_fragment_id);
142 u8 *from_data = (void *) (ip4 + 1);
143 vlib_buffer_t *org_from_b = from_b;
145 u16 left_in_from_buffer = from_b->current_length - head_bytes;
148 /* Do the actual fragmentation */
153 ip4_header_t *to_ip4;
156 len = (rem > max ? max : rem);
157 if (len != rem) /* Last fragment does not need to divisible by 8 */
159 if ((to_b = frag_buffer_alloc (org_from_b, &to_bi)) == 0)
161 return IP_FRAG_ERROR_MEMORY;
163 vec_add1 (*buffer, to_bi);
164 frag_set_sw_if_index (to_b, org_from_b);
166 /* Copy ip4 header */
167 to_data = vlib_buffer_get_current (to_b);
168 clib_memcpy_fast (to_data, org_from_packet, head_bytes);
169 to_ip4 = (ip4_header_t *) (to_data + l2unfragmentablesize);
170 to_data = (void *) (to_ip4 + 1);
171 vnet_buffer (to_b)->l3_hdr_offset = to_b->current_data;
172 vlib_buffer_copy_trace_flag (vm, from_b, to_bi);
173 to_b->flags |= VNET_BUFFER_F_L3_HDR_OFFSET_VALID;
175 if (from_b->flags & VNET_BUFFER_F_L4_HDR_OFFSET_VALID)
177 vnet_buffer (to_b)->l4_hdr_offset =
178 (vnet_buffer (to_b)->l3_hdr_offset +
179 (vnet_buffer (from_b)->l4_hdr_offset -
180 vnet_buffer (from_b)->l3_hdr_offset));
181 to_b->flags |= VNET_BUFFER_F_L4_HDR_OFFSET_VALID;
184 /* Spin through from buffers filling up the to buffer */
185 u16 left_in_to_buffer = len, to_ptr = 0;
190 /* Figure out how many bytes we can safely copy */
191 bytes_to_copy = left_in_to_buffer <= left_in_from_buffer ?
192 left_in_to_buffer : left_in_from_buffer;
193 clib_memcpy_fast (to_data + to_ptr, from_data + ptr, bytes_to_copy);
194 left_in_to_buffer -= bytes_to_copy;
195 ptr += bytes_to_copy;
196 left_in_from_buffer -= bytes_to_copy;
197 if (left_in_to_buffer == 0)
200 ASSERT (left_in_from_buffer <= 0);
202 if (!(from_b->flags & VLIB_BUFFER_NEXT_PRESENT))
204 return IP_FRAG_ERROR_MALFORMED;
206 from_b = vlib_get_buffer (vm, from_b->next_buffer);
207 from_data = (u8 *) vlib_buffer_get_current (from_b);
209 left_in_from_buffer = from_b->current_length;
210 to_ptr += bytes_to_copy;
213 to_b->flags |= VNET_BUFFER_F_IS_IP4;
214 to_b->current_length = len + head_bytes;
216 to_ip4->fragment_id = ip_frag_id;
217 to_ip4->flags_and_fragment_offset =
218 clib_host_to_net_u16 ((fo >> 3) + ip_frag_offset);
219 to_ip4->flags_and_fragment_offset |=
220 clib_host_to_net_u16 (((len != rem) || more) << 13);
221 to_ip4->length = clib_host_to_net_u16 (len + sizeof (ip4_header_t));
222 to_ip4->checksum = ip4_header_checksum (to_ip4);
224 /* we've just done the IP checksum .. */
225 vnet_buffer_offload_flags_clear (to_b, VNET_BUFFER_OFFLOAD_F_IP_CKSUM);
231 return IP_FRAG_ERROR_NONE;
235 ip_frag_set_vnet_buffer (vlib_buffer_t * b, u16 mtu, u8 next_index, u8 flags)
237 vnet_buffer (b)->ip_frag.mtu = mtu;
238 vnet_buffer (b)->ip_frag.next_index = next_index;
239 vnet_buffer (b)->ip_frag.flags = flags;
244 frag_node_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
245 vlib_frame_t * frame, u32 node_index, bool is_ip6)
247 u32 n_left_from, *from, next_index, *to_next, n_left_to_next;
248 vlib_node_runtime_t *error_node = vlib_node_get_runtime (vm, node_index);
249 from = vlib_frame_vector_args (frame);
250 n_left_from = frame->n_vectors;
251 next_index = node->cached_next_index;
252 u32 frag_sent = 0, small_packets = 0;
255 while (n_left_from > 0)
257 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
259 while (n_left_from > 0 && n_left_to_next > 0)
261 u32 pi0, *frag_from, frag_left;
263 ip_frag_error_t error0;
267 * Note: The packet is not enqueued now. It is instead put
268 * in a vector where other fragments will be put as well.
274 p0 = vlib_get_buffer (vm, pi0);
275 u16 mtu = vnet_buffer (p0)->ip_frag.mtu;
277 error0 = ip6_frag_do_fragment (vm, pi0, mtu, 0, &buffer);
279 error0 = ip4_frag_do_fragment (vm, pi0, mtu, 0, &buffer);
281 if (PREDICT_FALSE (p0->flags & VLIB_BUFFER_IS_TRACED))
283 ip_frag_trace_t *tr =
284 vlib_add_trace (vm, node, p0, sizeof (*tr));
286 tr->pkt_size = vlib_buffer_length_in_chain (vm, p0);
287 tr->n_fragments = vec_len (buffer);
288 tr->next = vnet_buffer (p0)->ip_frag.next_index;
291 if (!is_ip6 && error0 == IP_FRAG_ERROR_DONT_FRAGMENT_SET)
293 icmp4_error_set_vnet_buffer (p0, ICMP4_destination_unreachable,
294 ICMP4_destination_unreachable_fragmentation_needed_and_dont_fragment_set,
295 vnet_buffer (p0)->ip_frag.mtu);
296 next0 = IP_FRAG_NEXT_ICMP_ERROR;
300 next0 = (error0 == IP_FRAG_ERROR_NONE ?
301 vnet_buffer (p0)->ip_frag.next_index :
305 if (error0 == IP_FRAG_ERROR_NONE)
307 /* Free original buffer chain */
308 frag_sent += vec_len (buffer);
309 small_packets += (vec_len (buffer) == 1);
310 vlib_buffer_free_one (vm, pi0); /* Free original packet */
314 vlib_error_count (vm, node_index, error0, 1);
315 vec_add1 (buffer, pi0); /* Get rid of the original buffer */
318 /* Send fragments that were added in the frame */
320 frag_left = vec_len (buffer);
322 while (frag_left > 0)
324 while (frag_left > 0 && n_left_to_next > 0)
327 i = to_next[0] = frag_from[0];
333 vlib_get_buffer (vm, i)->error = error_node->errors[error0];
334 vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
335 to_next, n_left_to_next, i,
338 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
339 vlib_get_next_frame (vm, node, next_index, to_next,
342 vec_reset_length (buffer);
344 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
348 vlib_node_increment_counter (vm, node_index,
349 IP_FRAG_ERROR_FRAGMENT_SENT, frag_sent);
350 vlib_node_increment_counter (vm, node_index,
351 IP_FRAG_ERROR_SMALL_PACKET, small_packets);
353 return frame->n_vectors;
359 ip4_frag (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
361 return frag_node_inline (vm, node, frame, ip4_frag_node.index,
366 ip6_frag (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
368 return frag_node_inline (vm, node, frame, ip6_frag_node.index,
373 * Fragments the packet given in from_bi. Fragments are returned in the buffer vector.
374 * Caller must ensure the original packet is freed.
375 * from_bi: current pointer must point to IPv6 header
378 ip6_frag_do_fragment (vlib_main_t * vm, u32 from_bi, u16 mtu,
379 u16 l2unfragmentablesize, u32 ** buffer)
381 vlib_buffer_t *from_b;
383 u16 len, max, rem, ip_frag_id;
387 from_b = vlib_get_buffer (vm, from_bi);
388 org_from_packet = vlib_buffer_get_current (from_b);
389 ip6 = vlib_buffer_get_current (from_b) + l2unfragmentablesize;
392 (sizeof (ip6_header_t) + sizeof (ip6_frag_hdr_t) + l2unfragmentablesize);
393 rem = clib_net_to_host_u16 (ip6->payload_length);
394 max = (clib_min (mtu, vlib_buffer_get_default_data_size (vm)) - head_bytes) &
398 (vlib_buffer_length_in_chain (vm, from_b) - sizeof (ip6_header_t)))
400 return IP_FRAG_ERROR_MALFORMED;
403 /* TODO: Look through header chain for fragmentation header */
404 if (ip6->protocol == IP_PROTOCOL_IPV6_FRAGMENTATION)
406 return IP_FRAG_ERROR_MALFORMED;
409 u8 *from_data = (void *) (ip6 + 1);
410 vlib_buffer_t *org_from_b = from_b;
412 u16 left_in_from_buffer =
413 from_b->current_length - (l2unfragmentablesize + sizeof (ip6_header_t));
416 ip_frag_id = ++running_fragment_id; // Fix
418 /* Do the actual fragmentation */
423 ip6_header_t *to_ip6;
424 ip6_frag_hdr_t *to_frag_hdr;
427 len = (rem > max ? max : rem);
428 if (len != rem) /* Last fragment does not need to divisible by 8 */
430 if ((to_b = frag_buffer_alloc (org_from_b, &to_bi)) == 0)
432 return IP_FRAG_ERROR_MEMORY;
434 vec_add1 (*buffer, to_bi);
435 frag_set_sw_if_index (to_b, org_from_b);
437 /* Copy ip6 header */
438 clib_memcpy_fast (to_b->data, org_from_packet,
439 l2unfragmentablesize + sizeof (ip6_header_t));
440 to_ip6 = vlib_buffer_get_current (to_b) + l2unfragmentablesize;
441 to_frag_hdr = (ip6_frag_hdr_t *) (to_ip6 + 1);
442 to_data = (void *) (to_frag_hdr + 1);
444 vnet_buffer (to_b)->l3_hdr_offset = to_b->current_data;
445 to_b->flags |= VNET_BUFFER_F_L3_HDR_OFFSET_VALID;
447 if (from_b->flags & VNET_BUFFER_F_L4_HDR_OFFSET_VALID)
449 vnet_buffer (to_b)->l4_hdr_offset =
450 (vnet_buffer (to_b)->l3_hdr_offset +
451 (vnet_buffer (from_b)->l4_hdr_offset -
452 vnet_buffer (from_b)->l3_hdr_offset));
453 to_b->flags |= VNET_BUFFER_F_L4_HDR_OFFSET_VALID;
455 to_b->flags |= VNET_BUFFER_F_IS_IP6;
457 /* Spin through from buffers filling up the to buffer */
458 u16 left_in_to_buffer = len, to_ptr = 0;
463 /* Figure out how many bytes we can safely copy */
464 bytes_to_copy = left_in_to_buffer <= left_in_from_buffer ?
465 left_in_to_buffer : left_in_from_buffer;
466 clib_memcpy_fast (to_data + to_ptr, from_data + ptr, bytes_to_copy);
467 left_in_to_buffer -= bytes_to_copy;
468 ptr += bytes_to_copy;
469 left_in_from_buffer -= bytes_to_copy;
470 if (left_in_to_buffer == 0)
473 ASSERT (left_in_from_buffer <= 0);
475 if (!(from_b->flags & VLIB_BUFFER_NEXT_PRESENT))
477 return IP_FRAG_ERROR_MALFORMED;
479 from_b = vlib_get_buffer (vm, from_b->next_buffer);
480 from_data = (u8 *) vlib_buffer_get_current (from_b);
482 left_in_from_buffer = from_b->current_length;
483 to_ptr += bytes_to_copy;
486 to_b->current_length = len + head_bytes;
487 to_ip6->payload_length =
488 clib_host_to_net_u16 (len + sizeof (ip6_frag_hdr_t));
489 to_ip6->protocol = IP_PROTOCOL_IPV6_FRAGMENTATION;
490 to_frag_hdr->fragment_offset_and_more =
491 ip6_frag_hdr_offset_and_more ((fo >> 3), len != rem);
492 to_frag_hdr->identification = ip_frag_id;
493 to_frag_hdr->next_hdr = ip6->protocol;
494 to_frag_hdr->rsv = 0;
500 return IP_FRAG_ERROR_NONE;
503 VLIB_REGISTER_NODE (ip4_frag_node) = {
504 .function = ip4_frag,
505 .name = IP4_FRAG_NODE_NAME,
506 .vector_size = sizeof (u32),
507 .format_trace = format_ip_frag_trace,
508 .type = VLIB_NODE_TYPE_INTERNAL,
510 .n_errors = IP_FRAG_N_ERROR,
511 .error_counters = ip_frag_error_counters,
513 .n_next_nodes = IP_FRAG_N_NEXT,
514 .next_nodes = { [IP_FRAG_NEXT_IP_REWRITE] = "ip4-rewrite",
515 [IP_FRAG_NEXT_IP_REWRITE_MIDCHAIN] = "ip4-midchain",
516 [IP_FRAG_NEXT_IP4_LOOKUP] = "ip4-lookup",
517 [IP_FRAG_NEXT_IP6_LOOKUP] = "ip6-lookup",
518 [IP_FRAG_NEXT_ICMP_ERROR] = "ip4-icmp-error",
519 [IP_FRAG_NEXT_DROP] = "ip4-drop" },
522 VLIB_REGISTER_NODE (ip6_frag_node) = {
523 .function = ip6_frag,
524 .name = IP6_FRAG_NODE_NAME,
525 .vector_size = sizeof (u32),
526 .format_trace = format_ip_frag_trace,
527 .type = VLIB_NODE_TYPE_INTERNAL,
529 .n_errors = IP_FRAG_N_ERROR,
530 .error_counters = ip_frag_error_counters,
532 .n_next_nodes = IP_FRAG_N_NEXT,
533 .next_nodes = { [IP_FRAG_NEXT_IP_REWRITE] = "ip6-rewrite",
534 [IP_FRAG_NEXT_IP_REWRITE_MIDCHAIN] = "ip6-midchain",
535 [IP_FRAG_NEXT_IP4_LOOKUP] = "ip4-lookup",
536 [IP_FRAG_NEXT_IP6_LOOKUP] = "ip6-lookup",
537 [IP_FRAG_NEXT_ICMP_ERROR] = "error-drop",
538 [IP_FRAG_NEXT_DROP] = "ip6-drop" },
542 * fd.io coding-style-patch-verification: ON
545 * eval: (c-set-style "gnu")