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>
37 format_ip_frag_trace (u8 * s, va_list * args)
39 CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
40 CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
41 ip_frag_trace_t *t = va_arg (*args, ip_frag_trace_t *);
42 s = format (s, "IPv%s offset: %u mtu: %u fragments: %u",
43 t->ipv6 ? "6" : "4", t->header_offset, t->mtu, t->n_fragments);
47 static u32 running_fragment_id;
50 ip4_frag_do_fragment (vlib_main_t * vm, u32 pi, u32 ** buffer,
51 ip_frag_error_t * error)
55 u16 mtu, ptr, len, max, rem, offset, ip_frag_id, ip_frag_offset;
58 vec_add1 (*buffer, pi);
59 p = vlib_get_buffer (vm, pi);
60 offset = vnet_buffer (p)->ip_frag.header_offset;
61 mtu = vnet_buffer (p)->ip_frag.mtu;
62 packet = (u8 *) vlib_buffer_get_current (p);
63 ip4 = (ip4_header_t *) (packet + offset);
65 rem = clib_net_to_host_u16 (ip4->length) - sizeof (*ip4);
67 max = (mtu - sizeof (*ip4) - vnet_buffer (p)->ip_frag.header_offset) & ~0x7;
69 if (rem > (p->current_length - offset - sizeof (*ip4)))
71 *error = IP_FRAG_ERROR_MALFORMED;
75 if (mtu < sizeof (*ip4))
77 *error = IP_FRAG_ERROR_CANT_FRAGMENT_HEADER;
81 if (ip4->flags_and_fragment_offset &
82 clib_host_to_net_u16 (IP4_HEADER_FLAG_DONT_FRAGMENT))
84 *error = IP_FRAG_ERROR_DONT_FRAGMENT_SET;
88 if (p->flags & VLIB_BUFFER_NEXT_PRESENT)
90 *error = IP_FRAG_ERROR_MALFORMED;
94 if (ip4_is_fragment (ip4))
96 ip_frag_id = ip4->fragment_id;
97 ip_frag_offset = ip4_get_fragment_offset (ip4);
99 !(!(ip4->flags_and_fragment_offset &
100 clib_host_to_net_u16 (IP4_HEADER_FLAG_MORE_FRAGMENTS)));
104 ip_frag_id = (++running_fragment_id);
109 //Do the actual fragmentation
118 (mtu - sizeof (*ip4) -
119 vnet_buffer (p)->ip_frag.header_offset)) ? max : rem;
125 fip4 = (ip4_header_t *) (vlib_buffer_get_current (b) + offset);
129 if (!vlib_buffer_alloc (vm, &bi, 1))
131 *error = IP_FRAG_ERROR_MEMORY;
134 vec_add1 (*buffer, bi);
135 b = vlib_get_buffer (vm, bi);
136 vnet_buffer (b)->sw_if_index[VLIB_RX] =
137 vnet_buffer (p)->sw_if_index[VLIB_RX];
138 vnet_buffer (b)->sw_if_index[VLIB_TX] =
139 vnet_buffer (p)->sw_if_index[VLIB_TX];
140 /* Copy Adj_index in case DPO based node is sending for the fragmentation,
141 the packet would be sent back to the proper DPO next node and Index */
142 vnet_buffer (b)->ip.adj_index[VLIB_RX] =
143 vnet_buffer (p)->ip.adj_index[VLIB_RX];
144 vnet_buffer (b)->ip.adj_index[VLIB_TX] =
145 vnet_buffer (p)->ip.adj_index[VLIB_TX];
146 fip4 = (ip4_header_t *) (vlib_buffer_get_current (b) + offset);
148 //Copy offset and ip4 header
149 clib_memcpy (b->data, packet, offset + sizeof (*ip4));
151 clib_memcpy (((u8 *) (fip4)) + sizeof (*fip4),
152 packet + offset + sizeof (*fip4) + ptr, len);
154 b->current_length = offset + len + sizeof (*fip4);
156 fip4->fragment_id = ip_frag_id;
157 fip4->flags_and_fragment_offset =
158 clib_host_to_net_u16 ((ptr >> 3) + ip_frag_offset);
159 fip4->flags_and_fragment_offset |=
160 clib_host_to_net_u16 (((len != rem) || more) << 13);
161 // ((len0 != rem0) || more0) << 13 is optimization for
162 // ((len0 != rem0) || more0) ? IP4_HEADER_FLAG_MORE_FRAGMENTS : 0
163 fip4->length = clib_host_to_net_u16 (len + sizeof (*fip4));
164 fip4->checksum = ip4_header_checksum (fip4);
166 if (vnet_buffer (p)->ip_frag.flags & IP_FRAG_FLAG_IP4_HEADER)
168 //Encapsulating ipv4 header
169 ip4_header_t *encap_header4 =
170 (ip4_header_t *) vlib_buffer_get_current (b);
171 encap_header4->length = clib_host_to_net_u16 (b->current_length);
172 encap_header4->checksum = ip4_header_checksum (encap_header4);
174 else if (vnet_buffer (p)->ip_frag.flags & IP_FRAG_FLAG_IP6_HEADER)
176 //Encapsulating ipv6 header
177 ip6_header_t *encap_header6 =
178 (ip6_header_t *) vlib_buffer_get_current (b);
179 encap_header6->payload_length =
180 clib_host_to_net_u16 (b->current_length -
181 sizeof (*encap_header6));
190 ip_frag_set_vnet_buffer (vlib_buffer_t * b, u16 offset, u16 mtu,
191 u8 next_index, u8 flags)
193 vnet_buffer (b)->ip_frag.header_offset = offset;
194 vnet_buffer (b)->ip_frag.mtu = mtu;
195 vnet_buffer (b)->ip_frag.next_index = next_index;
196 vnet_buffer (b)->ip_frag.flags = flags;
200 ip4_frag (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
202 u32 n_left_from, *from, next_index, *to_next, n_left_to_next;
203 vlib_node_runtime_t *error_node =
204 vlib_node_get_runtime (vm, ip4_frag_node.index);
205 from = vlib_frame_vector_args (frame);
206 n_left_from = frame->n_vectors;
207 next_index = node->cached_next_index;
208 u32 frag_sent = 0, small_packets = 0;
211 while (n_left_from > 0)
213 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
215 while (n_left_from > 0 && n_left_to_next > 0)
217 u32 pi0, *frag_from, frag_left;
219 ip_frag_error_t error0;
220 ip4_frag_next_t next0;
222 //Note: The packet is not enqueued now.
223 //It is instead put in a vector where other fragments
224 //will be put as well.
228 error0 = IP_FRAG_ERROR_NONE;
230 p0 = vlib_get_buffer (vm, pi0);
231 ip4_frag_do_fragment (vm, pi0, &buffer, &error0);
233 if (PREDICT_FALSE (p0->flags & VLIB_BUFFER_IS_TRACED))
235 ip_frag_trace_t *tr =
236 vlib_add_trace (vm, node, p0, sizeof (*tr));
237 tr->header_offset = vnet_buffer (p0)->ip_frag.header_offset;
238 tr->mtu = vnet_buffer (p0)->ip_frag.mtu;
240 tr->n_fragments = vec_len (buffer);
241 tr->next = vnet_buffer (p0)->ip_frag.next_index;
244 if (error0 == IP_FRAG_ERROR_DONT_FRAGMENT_SET)
246 icmp4_error_set_vnet_buffer (p0, ICMP4_destination_unreachable,
247 ICMP4_destination_unreachable_fragmentation_needed_and_dont_fragment_set,
248 vnet_buffer (p0)->ip_frag.mtu);
249 vlib_buffer_advance (p0,
250 vnet_buffer (p0)->ip_frag.header_offset);
251 next0 = IP4_FRAG_NEXT_ICMP_ERROR;
256 next0 = (error0 == IP_FRAG_ERROR_NONE) ? vnet_buffer (p0)->
257 ip_frag.next_index : IP4_FRAG_NEXT_DROP;
261 if (error0 == IP_FRAG_ERROR_NONE)
263 frag_sent += vec_len (buffer);
264 small_packets += (vec_len (buffer) == 1);
267 vlib_error_count (vm, ip4_frag_node.index, error0, 1);
269 //Send fragments that were added in the frame
271 frag_left = vec_len (buffer);
273 while (frag_left > 0)
275 while (frag_left > 0 && n_left_to_next > 0)
278 i = to_next[0] = frag_from[0];
284 vlib_get_buffer (vm, i)->error = error_node->errors[error0];
285 vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
286 to_next, n_left_to_next, i,
289 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
290 vlib_get_next_frame (vm, node, next_index, to_next,
293 vec_reset_length (buffer);
295 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
299 vlib_node_increment_counter (vm, ip4_frag_node.index,
300 IP_FRAG_ERROR_FRAGMENT_SENT, frag_sent);
301 vlib_node_increment_counter (vm, ip4_frag_node.index,
302 IP_FRAG_ERROR_SMALL_PACKET, small_packets);
304 return frame->n_vectors;
309 ip6_frag_do_fragment (vlib_main_t * vm, u32 pi, u32 ** buffer,
310 ip_frag_error_t * error)
313 ip6_header_t *ip6_hdr;
314 ip6_frag_hdr_t *frag_hdr;
315 u8 *payload, *next_header;
317 p = vlib_get_buffer (vm, pi);
319 //Parsing the IPv6 headers
321 vlib_buffer_get_current (p) + vnet_buffer (p)->ip_frag.header_offset;
322 payload = (u8 *) (ip6_hdr + 1);
323 next_header = &ip6_hdr->protocol;
324 if (*next_header == IP_PROTOCOL_IP6_HOP_BY_HOP_OPTIONS)
326 next_header = payload;
327 payload += payload[1] * 8;
330 if (*next_header == IP_PROTOCOL_IP6_DESTINATION_OPTIONS)
332 next_header = payload;
333 payload += payload[1] * 8;
336 if (*next_header == IP_PROTOCOL_IPV6_ROUTE)
338 next_header = payload;
339 payload += payload[1] * 8;
343 (payload >= (u8 *) vlib_buffer_get_current (p) + p->current_length))
345 //A malicious packet could set an extension header with a too big size
346 //and make us modify another vlib_buffer
347 *error = IP_FRAG_ERROR_MALFORMED;
351 if (p->flags & VLIB_BUFFER_NEXT_PRESENT)
353 *error = IP_FRAG_ERROR_MALFORMED;
359 if (*next_header == IP_PROTOCOL_IPV6_FRAGMENTATION)
361 //The fragmentation header is already there
362 frag_hdr = (ip6_frag_hdr_t *) payload;
363 has_more = ip6_frag_hdr_more (frag_hdr);
364 initial_offset = ip6_frag_hdr_offset (frag_hdr);
368 //Insert a fragmentation header in the packet
369 u8 nh = *next_header;
370 *next_header = IP_PROTOCOL_IPV6_FRAGMENTATION;
371 vlib_buffer_advance (p, -sizeof (*frag_hdr));
372 u8 *start = vlib_buffer_get_current (p);
373 memmove (start, start + sizeof (*frag_hdr),
374 payload - (start + sizeof (*frag_hdr)));
375 frag_hdr = (ip6_frag_hdr_t *) (payload - sizeof (*frag_hdr));
376 frag_hdr->identification = ++running_fragment_id;
377 frag_hdr->next_hdr = nh;
382 payload = (u8 *) (frag_hdr + 1);
384 u16 headers_len = payload - (u8 *) vlib_buffer_get_current (p);
385 u16 max_payload = vnet_buffer (p)->ip_frag.mtu - headers_len;
386 u16 rem = p->current_length - headers_len;
391 *error = IP_FRAG_ERROR_CANT_FRAGMENT_HEADER;
399 u16 len = (rem > max_payload) ? (max_payload & ~0x7) : rem;
404 if (!vlib_buffer_alloc (vm, &bi, 1))
406 *error = IP_FRAG_ERROR_MEMORY;
409 b = vlib_get_buffer (vm, bi);
410 vnet_buffer (b)->sw_if_index[VLIB_RX] =
411 vnet_buffer (p)->sw_if_index[VLIB_RX];
412 vnet_buffer (b)->sw_if_index[VLIB_TX] =
413 vnet_buffer (p)->sw_if_index[VLIB_TX];
415 /* Copy Adj_index in case DPO based node is sending for the fragmentation,
416 the packet would be sent back to the proper DPO next node and Index */
417 vnet_buffer (b)->ip.adj_index[VLIB_RX] =
418 vnet_buffer (p)->ip.adj_index[VLIB_RX];
419 vnet_buffer (b)->ip.adj_index[VLIB_TX] =
420 vnet_buffer (p)->ip.adj_index[VLIB_TX];
422 clib_memcpy (vlib_buffer_get_current (b),
423 vlib_buffer_get_current (p), headers_len);
424 clib_memcpy (vlib_buffer_get_current (b) + headers_len,
427 vlib_buffer_get_current (b) + headers_len - sizeof (*frag_hdr);
432 b = vlib_get_buffer (vm, bi);
433 //frag_hdr already set here
437 vlib_buffer_get_current (b) + vnet_buffer (p)->ip_frag.header_offset;
438 frag_hdr->fragment_offset_and_more =
439 ip6_frag_hdr_offset_and_more (initial_offset + (ptr >> 3),
441 b->current_length = headers_len + len;
442 ip6_hdr->payload_length =
443 clib_host_to_net_u16 (b->current_length -
444 vnet_buffer (p)->ip_frag.header_offset -
447 if (vnet_buffer (p)->ip_frag.flags & IP_FRAG_FLAG_IP4_HEADER)
449 //Encapsulating ipv4 header
450 ip4_header_t *encap_header4 =
451 (ip4_header_t *) vlib_buffer_get_current (b);
452 encap_header4->length = clib_host_to_net_u16 (b->current_length);
453 encap_header4->checksum = ip4_header_checksum (encap_header4);
455 else if (vnet_buffer (p)->ip_frag.flags & IP_FRAG_FLAG_IP6_HEADER)
457 //Encapsulating ipv6 header
458 ip6_header_t *encap_header6 =
459 (ip6_header_t *) vlib_buffer_get_current (b);
460 encap_header6->payload_length =
461 clib_host_to_net_u16 (b->current_length -
462 sizeof (*encap_header6));
465 vec_add1 (*buffer, bi);
472 ip6_frag (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
474 u32 n_left_from, *from, next_index, *to_next, n_left_to_next;
475 vlib_node_runtime_t *error_node =
476 vlib_node_get_runtime (vm, ip6_frag_node.index);
477 from = vlib_frame_vector_args (frame);
478 n_left_from = frame->n_vectors;
479 next_index = node->cached_next_index;
480 u32 frag_sent = 0, small_packets = 0;
483 while (n_left_from > 0)
485 vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
487 while (n_left_from > 0 && n_left_to_next > 0)
489 u32 pi0, *frag_from, frag_left;
491 ip_frag_error_t error0;
492 ip6_frag_next_t next0;
497 error0 = IP_FRAG_ERROR_NONE;
499 p0 = vlib_get_buffer (vm, pi0);
500 ip6_frag_do_fragment (vm, pi0, &buffer, &error0);
502 if (PREDICT_FALSE (p0->flags & VLIB_BUFFER_IS_TRACED))
504 ip_frag_trace_t *tr =
505 vlib_add_trace (vm, node, p0, sizeof (*tr));
506 tr->header_offset = vnet_buffer (p0)->ip_frag.header_offset;
507 tr->mtu = vnet_buffer (p0)->ip_frag.mtu;
509 tr->n_fragments = vec_len (buffer);
510 tr->next = vnet_buffer (p0)->ip_frag.next_index;
514 next0 = (error0 == IP_FRAG_ERROR_NONE) ? vnet_buffer (p0)->
515 ip_frag.next_index : IP6_FRAG_NEXT_DROP;
518 frag_sent += vec_len (buffer);
519 small_packets += (vec_len (buffer) == 1);
521 //Send fragments that were added in the frame
523 frag_left = vec_len (buffer);
524 while (frag_left > 0)
526 while (frag_left > 0 && n_left_to_next > 0)
529 i = to_next[0] = frag_from[0];
535 vlib_get_buffer (vm, i)->error = error_node->errors[error0];
536 vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
537 to_next, n_left_to_next, i,
540 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
541 vlib_get_next_frame (vm, node, next_index, to_next,
544 vec_reset_length (buffer);
546 vlib_put_next_frame (vm, node, next_index, n_left_to_next);
549 vlib_node_increment_counter (vm, ip6_frag_node.index,
550 IP_FRAG_ERROR_FRAGMENT_SENT, frag_sent);
551 vlib_node_increment_counter (vm, ip6_frag_node.index,
552 IP_FRAG_ERROR_SMALL_PACKET, small_packets);
554 return frame->n_vectors;
557 static char *ip4_frag_error_strings[] = {
558 #define _(sym,string) string,
559 foreach_ip_frag_error
564 VLIB_REGISTER_NODE (ip4_frag_node) = {
565 .function = ip4_frag,
566 .name = IP4_FRAG_NODE_NAME,
567 .vector_size = sizeof (u32),
568 .format_trace = format_ip_frag_trace,
569 .type = VLIB_NODE_TYPE_INTERNAL,
571 .n_errors = IP_FRAG_N_ERROR,
572 .error_strings = ip4_frag_error_strings,
574 .n_next_nodes = IP4_FRAG_N_NEXT,
576 [IP4_FRAG_NEXT_IP4_LOOKUP] = "ip4-lookup",
577 [IP4_FRAG_NEXT_IP6_LOOKUP] = "ip6-lookup",
578 [IP4_FRAG_NEXT_ICMP_ERROR] = "ip4-icmp-error",
579 [IP4_FRAG_NEXT_DROP] = "ip4-drop"
585 VLIB_REGISTER_NODE (ip6_frag_node) = {
586 .function = ip6_frag,
587 .name = IP6_FRAG_NODE_NAME,
588 .vector_size = sizeof (u32),
589 .format_trace = format_ip_frag_trace,
590 .type = VLIB_NODE_TYPE_INTERNAL,
592 .n_errors = IP_FRAG_N_ERROR,
593 .error_strings = ip4_frag_error_strings,
595 .n_next_nodes = IP6_FRAG_N_NEXT,
597 [IP6_FRAG_NEXT_IP4_LOOKUP] = "ip4-lookup",
598 [IP6_FRAG_NEXT_IP6_LOOKUP] = "ip6-lookup",
599 [IP6_FRAG_NEXT_DROP] = "ip6-drop"
605 * fd.io coding-style-patch-verification: ON
608 * eval: (c-set-style "gnu")