Line data Source code
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:
6 : *
7 : * http://www.apache.org/licenses/LICENSE-2.0
8 : *
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 : *---------------------------------------------------------------------------
15 : */
16 : /*
17 : * IPv4 Fragmentation Node
18 : *
19 : *
20 : */
21 :
22 : #include "ip_frag.h"
23 :
24 : #include <vnet/ip/ip.h>
25 :
26 : typedef struct
27 : {
28 : u16 mtu;
29 : u8 next;
30 : u16 n_fragments;
31 : u16 pkt_size;
32 : } ip_frag_trace_t;
33 :
34 : static u8 *
35 158 : format_ip_frag_trace (u8 * s, va_list * args)
36 : {
37 158 : CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
38 158 : CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
39 158 : ip_frag_trace_t *t = va_arg (*args, ip_frag_trace_t *);
40 158 : s = format (s, "mtu: %u pkt-size: %u fragments: %u next: %d", t->mtu,
41 158 : t->pkt_size, t->n_fragments, t->next);
42 158 : return s;
43 : }
44 :
45 : static u32 running_fragment_id;
46 :
47 : static void
48 3154 : frag_set_sw_if_index (vlib_buffer_t * to, vlib_buffer_t * from)
49 : {
50 3154 : vnet_buffer (to)->sw_if_index[VLIB_RX] =
51 3154 : vnet_buffer (from)->sw_if_index[VLIB_RX];
52 3154 : vnet_buffer (to)->sw_if_index[VLIB_TX] =
53 3154 : vnet_buffer (from)->sw_if_index[VLIB_TX];
54 :
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
58 : */
59 3154 : vnet_buffer (to)->ip.adj_index[VLIB_RX] =
60 3154 : vnet_buffer (from)->ip.adj_index[VLIB_RX];
61 3154 : vnet_buffer (to)->ip.adj_index[VLIB_TX] =
62 3154 : vnet_buffer (from)->ip.adj_index[VLIB_TX];
63 :
64 : /* Copy QoS Bits */
65 3154 : if (PREDICT_TRUE (from->flags & VNET_BUFFER_F_QOS_DATA_VALID))
66 : {
67 0 : vnet_buffer2 (to)->qos = vnet_buffer2 (from)->qos;
68 0 : to->flags |= VNET_BUFFER_F_QOS_DATA_VALID;
69 : }
70 3154 : }
71 :
72 : static vlib_buffer_t *
73 3154 : frag_buffer_alloc (vlib_buffer_t * org_b, u32 * bi)
74 : {
75 3154 : vlib_main_t *vm = vlib_get_main ();
76 3154 : if (vlib_buffer_alloc (vm, bi, 1) != 1)
77 0 : return 0;
78 :
79 3154 : vlib_buffer_t *b = vlib_get_buffer (vm, *bi);
80 3154 : vlib_buffer_copy_trace_flag (vm, org_b, *bi);
81 :
82 3154 : return b;
83 : }
84 :
85 : /*
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
89 : * size.
90 : * from_bi: current pointer must point to IPv4 header
91 : */
92 : ip_frag_error_t
93 1102 : ip4_frag_do_fragment (vlib_main_t * vm, u32 from_bi, u16 mtu,
94 : u16 l2unfragmentablesize, u32 ** buffer)
95 : {
96 : vlib_buffer_t *from_b;
97 : ip4_header_t *ip4;
98 : u16 len, max, rem, ip_frag_id, ip_frag_offset, head_bytes;
99 : u8 *org_from_packet, more;
100 :
101 1102 : from_b = vlib_get_buffer (vm, from_bi);
102 1102 : org_from_packet = vlib_buffer_get_current (from_b);
103 1102 : ip4 = vlib_buffer_get_current (from_b) + l2unfragmentablesize;
104 :
105 1102 : rem = clib_net_to_host_u16 (ip4->length) - sizeof (ip4_header_t);
106 1102 : head_bytes = sizeof (ip4_header_t) + l2unfragmentablesize;
107 1102 : max = (clib_min (mtu, vlib_buffer_get_default_data_size (vm)) - head_bytes) &
108 : ~0x7;
109 :
110 2204 : if (rem >
111 1102 : (vlib_buffer_length_in_chain (vm, from_b) - sizeof (ip4_header_t)))
112 : {
113 0 : return IP_FRAG_ERROR_MALFORMED;
114 : }
115 :
116 1102 : if (mtu < sizeof (ip4_header_t))
117 : {
118 0 : return IP_FRAG_ERROR_CANT_FRAGMENT_HEADER;
119 : }
120 :
121 1102 : if (ip4->flags_and_fragment_offset &
122 1102 : clib_host_to_net_u16 (IP4_HEADER_FLAG_DONT_FRAGMENT))
123 : {
124 257 : return IP_FRAG_ERROR_DONT_FRAGMENT_SET;
125 : }
126 :
127 845 : if (ip4_is_fragment (ip4))
128 : {
129 0 : ip_frag_id = ip4->fragment_id;
130 0 : ip_frag_offset = ip4_get_fragment_offset (ip4);
131 0 : more =
132 0 : !(!(ip4->flags_and_fragment_offset &
133 0 : clib_host_to_net_u16 (IP4_HEADER_FLAG_MORE_FRAGMENTS)));
134 : }
135 : else
136 : {
137 845 : ip_frag_id = (++running_fragment_id);
138 845 : ip_frag_offset = 0;
139 845 : more = 0;
140 : }
141 :
142 845 : u8 *from_data = (void *) (ip4 + 1);
143 845 : vlib_buffer_t *org_from_b = from_b;
144 845 : u16 fo = 0;
145 845 : u16 left_in_from_buffer = from_b->current_length - head_bytes;
146 845 : u16 ptr = 0;
147 :
148 : /* Do the actual fragmentation */
149 3919 : while (rem)
150 : {
151 : u32 to_bi;
152 : vlib_buffer_t *to_b;
153 : ip4_header_t *to_ip4;
154 : u8 *to_data;
155 :
156 3074 : len = (rem > max ? max : rem);
157 3074 : if (len != rem) /* Last fragment does not need to divisible by 8 */
158 2229 : len &= ~0x7;
159 3074 : if ((to_b = frag_buffer_alloc (org_from_b, &to_bi)) == 0)
160 : {
161 0 : return IP_FRAG_ERROR_MEMORY;
162 : }
163 3074 : vec_add1 (*buffer, to_bi);
164 3074 : frag_set_sw_if_index (to_b, org_from_b);
165 :
166 : /* Copy ip4 header */
167 3074 : to_data = vlib_buffer_get_current (to_b);
168 3074 : clib_memcpy_fast (to_data, org_from_packet, head_bytes);
169 3074 : to_ip4 = (ip4_header_t *) (to_data + l2unfragmentablesize);
170 3074 : to_data = (void *) (to_ip4 + 1);
171 3074 : vnet_buffer (to_b)->l3_hdr_offset = to_b->current_data;
172 3074 : vlib_buffer_copy_trace_flag (vm, from_b, to_bi);
173 3074 : to_b->flags |= VNET_BUFFER_F_L3_HDR_OFFSET_VALID;
174 :
175 3074 : if (from_b->flags & VNET_BUFFER_F_L4_HDR_OFFSET_VALID)
176 : {
177 20 : vnet_buffer (to_b)->l4_hdr_offset =
178 20 : (vnet_buffer (to_b)->l3_hdr_offset +
179 20 : (vnet_buffer (from_b)->l4_hdr_offset -
180 20 : vnet_buffer (from_b)->l3_hdr_offset));
181 20 : to_b->flags |= VNET_BUFFER_F_L4_HDR_OFFSET_VALID;
182 : }
183 :
184 : /* Spin through from buffers filling up the to buffer */
185 3074 : u16 left_in_to_buffer = len, to_ptr = 0;
186 : while (1)
187 1187 : {
188 : u16 bytes_to_copy;
189 :
190 : /* Figure out how many bytes we can safely copy */
191 4261 : bytes_to_copy = left_in_to_buffer <= left_in_from_buffer ?
192 : left_in_to_buffer : left_in_from_buffer;
193 4261 : clib_memcpy_fast (to_data + to_ptr, from_data + ptr, bytes_to_copy);
194 4261 : left_in_to_buffer -= bytes_to_copy;
195 4261 : ptr += bytes_to_copy;
196 4261 : left_in_from_buffer -= bytes_to_copy;
197 4261 : if (left_in_to_buffer == 0)
198 3074 : break;
199 :
200 1187 : ASSERT (left_in_from_buffer <= 0);
201 : /* Move buffer */
202 1187 : if (!(from_b->flags & VLIB_BUFFER_NEXT_PRESENT))
203 : {
204 0 : return IP_FRAG_ERROR_MALFORMED;
205 : }
206 1187 : from_b = vlib_get_buffer (vm, from_b->next_buffer);
207 1187 : from_data = (u8 *) vlib_buffer_get_current (from_b);
208 1187 : ptr = 0;
209 1187 : left_in_from_buffer = from_b->current_length;
210 1187 : to_ptr += bytes_to_copy;
211 : }
212 :
213 3074 : to_b->flags |= VNET_BUFFER_F_IS_IP4;
214 3074 : to_b->current_length = len + head_bytes;
215 :
216 3074 : to_ip4->fragment_id = ip_frag_id;
217 3074 : to_ip4->flags_and_fragment_offset =
218 3074 : clib_host_to_net_u16 ((fo >> 3) + ip_frag_offset);
219 3074 : to_ip4->flags_and_fragment_offset |=
220 3074 : clib_host_to_net_u16 (((len != rem) || more) << 13);
221 3074 : to_ip4->length = clib_host_to_net_u16 (len + sizeof (ip4_header_t));
222 3074 : to_ip4->checksum = ip4_header_checksum (to_ip4);
223 :
224 : /* we've just done the IP checksum .. */
225 3074 : vnet_buffer_offload_flags_clear (to_b, VNET_BUFFER_OFFLOAD_F_IP_CKSUM);
226 :
227 3074 : rem -= len;
228 3074 : fo += len;
229 : }
230 :
231 845 : return IP_FRAG_ERROR_NONE;
232 : }
233 :
234 : void
235 351 : ip_frag_set_vnet_buffer (vlib_buffer_t * b, u16 mtu, u8 next_index, u8 flags)
236 : {
237 351 : vnet_buffer (b)->ip_frag.mtu = mtu;
238 351 : vnet_buffer (b)->ip_frag.next_index = next_index;
239 351 : vnet_buffer (b)->ip_frag.flags = flags;
240 351 : }
241 :
242 :
243 : static inline uword
244 80 : frag_node_inline (vlib_main_t * vm, vlib_node_runtime_t * node,
245 : vlib_frame_t * frame, u32 node_index, bool is_ip6)
246 : {
247 : u32 n_left_from, *from, next_index, *to_next, n_left_to_next;
248 80 : vlib_node_runtime_t *error_node = vlib_node_get_runtime (vm, node_index);
249 80 : from = vlib_frame_vector_args (frame);
250 80 : n_left_from = frame->n_vectors;
251 80 : next_index = node->cached_next_index;
252 80 : u32 frag_sent = 0, small_packets = 0;
253 80 : u32 *buffer = 0;
254 :
255 160 : while (n_left_from > 0)
256 : {
257 80 : vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
258 :
259 433 : while (n_left_from > 0 && n_left_to_next > 0)
260 : {
261 : u32 pi0, *frag_from, frag_left;
262 : vlib_buffer_t *p0;
263 : ip_frag_error_t error0;
264 : int next0;
265 :
266 : /*
267 : * Note: The packet is not enqueued now. It is instead put
268 : * in a vector where other fragments will be put as well.
269 : */
270 353 : pi0 = from[0];
271 353 : from += 1;
272 353 : n_left_from -= 1;
273 :
274 353 : p0 = vlib_get_buffer (vm, pi0);
275 353 : u16 mtu = vnet_buffer (p0)->ip_frag.mtu;
276 353 : if (is_ip6)
277 23 : error0 = ip6_frag_do_fragment (vm, pi0, mtu, 0, &buffer);
278 : else
279 330 : error0 = ip4_frag_do_fragment (vm, pi0, mtu, 0, &buffer);
280 :
281 353 : if (PREDICT_FALSE (p0->flags & VLIB_BUFFER_IS_TRACED))
282 : {
283 : ip_frag_trace_t *tr =
284 353 : vlib_add_trace (vm, node, p0, sizeof (*tr));
285 353 : tr->mtu = mtu;
286 353 : tr->pkt_size = vlib_buffer_length_in_chain (vm, p0);
287 353 : tr->n_fragments = vec_len (buffer);
288 353 : tr->next = vnet_buffer (p0)->ip_frag.next_index;
289 : }
290 :
291 353 : if (!is_ip6 && error0 == IP_FRAG_ERROR_DONT_FRAGMENT_SET)
292 : {
293 0 : icmp4_error_set_vnet_buffer (p0, ICMP4_destination_unreachable,
294 : ICMP4_destination_unreachable_fragmentation_needed_and_dont_fragment_set,
295 0 : vnet_buffer (p0)->ip_frag.mtu);
296 0 : next0 = IP_FRAG_NEXT_ICMP_ERROR;
297 : }
298 : else
299 : {
300 353 : next0 = (error0 == IP_FRAG_ERROR_NONE ?
301 353 : vnet_buffer (p0)->ip_frag.next_index :
302 : IP_FRAG_NEXT_DROP);
303 : }
304 :
305 353 : if (error0 == IP_FRAG_ERROR_NONE)
306 : {
307 : /* Free original buffer chain */
308 353 : frag_sent += vec_len (buffer);
309 353 : small_packets += (vec_len (buffer) == 1);
310 353 : vlib_buffer_free_one (vm, pi0); /* Free original packet */
311 : }
312 : else
313 : {
314 0 : vlib_error_count (vm, node_index, error0, 1);
315 0 : vec_add1 (buffer, pi0); /* Get rid of the original buffer */
316 : }
317 :
318 : /* Send fragments that were added in the frame */
319 353 : frag_from = buffer;
320 353 : frag_left = vec_len (buffer);
321 :
322 708 : while (frag_left > 0)
323 : {
324 1687 : while (frag_left > 0 && n_left_to_next > 0)
325 : {
326 : u32 i;
327 1332 : i = to_next[0] = frag_from[0];
328 1332 : frag_from += 1;
329 1332 : frag_left -= 1;
330 1332 : to_next += 1;
331 1332 : n_left_to_next -= 1;
332 :
333 1332 : vlib_get_buffer (vm, i)->error = error_node->errors[error0];
334 1332 : vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
335 : to_next, n_left_to_next, i,
336 : next0);
337 : }
338 355 : vlib_put_next_frame (vm, node, next_index, n_left_to_next);
339 355 : vlib_get_next_frame (vm, node, next_index, to_next,
340 : n_left_to_next);
341 : }
342 353 : vec_reset_length (buffer);
343 : }
344 80 : vlib_put_next_frame (vm, node, next_index, n_left_to_next);
345 : }
346 80 : vec_free (buffer);
347 :
348 80 : vlib_node_increment_counter (vm, node_index,
349 : IP_FRAG_ERROR_FRAGMENT_SENT, frag_sent);
350 80 : vlib_node_increment_counter (vm, node_index,
351 : IP_FRAG_ERROR_SMALL_PACKET, small_packets);
352 :
353 80 : return frame->n_vectors;
354 : }
355 :
356 :
357 :
358 : static uword
359 57 : ip4_frag (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
360 : {
361 57 : return frag_node_inline (vm, node, frame, ip4_frag_node.index,
362 : 0 /* is_ip6 */ );
363 : }
364 :
365 : static uword
366 23 : ip6_frag (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
367 : {
368 23 : return frag_node_inline (vm, node, frame, ip6_frag_node.index,
369 : 1 /* is_ip6 */ );
370 : }
371 :
372 : /*
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
376 : */
377 : ip_frag_error_t
378 31 : ip6_frag_do_fragment (vlib_main_t * vm, u32 from_bi, u16 mtu,
379 : u16 l2unfragmentablesize, u32 ** buffer)
380 : {
381 : vlib_buffer_t *from_b;
382 : ip6_header_t *ip6;
383 : u16 len, max, rem, ip_frag_id;
384 : u8 *org_from_packet;
385 : u16 head_bytes;
386 :
387 31 : from_b = vlib_get_buffer (vm, from_bi);
388 31 : org_from_packet = vlib_buffer_get_current (from_b);
389 31 : ip6 = vlib_buffer_get_current (from_b) + l2unfragmentablesize;
390 :
391 31 : head_bytes =
392 : (sizeof (ip6_header_t) + sizeof (ip6_frag_hdr_t) + l2unfragmentablesize);
393 31 : rem = clib_net_to_host_u16 (ip6->payload_length);
394 31 : max = (clib_min (mtu, vlib_buffer_get_default_data_size (vm)) - head_bytes) &
395 : ~0x7;
396 :
397 62 : if (rem >
398 31 : (vlib_buffer_length_in_chain (vm, from_b) - sizeof (ip6_header_t)))
399 : {
400 0 : return IP_FRAG_ERROR_MALFORMED;
401 : }
402 :
403 : /* TODO: Look through header chain for fragmentation header */
404 31 : if (ip6->protocol == IP_PROTOCOL_IPV6_FRAGMENTATION)
405 : {
406 0 : return IP_FRAG_ERROR_MALFORMED;
407 : }
408 :
409 31 : u8 *from_data = (void *) (ip6 + 1);
410 31 : vlib_buffer_t *org_from_b = from_b;
411 31 : u16 fo = 0;
412 31 : u16 left_in_from_buffer =
413 31 : from_b->current_length - (l2unfragmentablesize + sizeof (ip6_header_t));
414 31 : u16 ptr = 0;
415 :
416 31 : ip_frag_id = ++running_fragment_id; // Fix
417 :
418 : /* Do the actual fragmentation */
419 111 : while (rem)
420 : {
421 : u32 to_bi;
422 : vlib_buffer_t *to_b;
423 : ip6_header_t *to_ip6;
424 : ip6_frag_hdr_t *to_frag_hdr;
425 : u8 *to_data;
426 :
427 80 : len = (rem > max ? max : rem);
428 80 : if (len != rem) /* Last fragment does not need to divisible by 8 */
429 49 : len &= ~0x7;
430 80 : if ((to_b = frag_buffer_alloc (org_from_b, &to_bi)) == 0)
431 : {
432 0 : return IP_FRAG_ERROR_MEMORY;
433 : }
434 80 : vec_add1 (*buffer, to_bi);
435 80 : frag_set_sw_if_index (to_b, org_from_b);
436 :
437 : /* Copy ip6 header */
438 80 : clib_memcpy_fast (to_b->data, org_from_packet,
439 : l2unfragmentablesize + sizeof (ip6_header_t));
440 80 : to_ip6 = vlib_buffer_get_current (to_b) + l2unfragmentablesize;
441 80 : to_frag_hdr = (ip6_frag_hdr_t *) (to_ip6 + 1);
442 80 : to_data = (void *) (to_frag_hdr + 1);
443 :
444 80 : vnet_buffer (to_b)->l3_hdr_offset = to_b->current_data;
445 80 : to_b->flags |= VNET_BUFFER_F_L3_HDR_OFFSET_VALID;
446 :
447 80 : if (from_b->flags & VNET_BUFFER_F_L4_HDR_OFFSET_VALID)
448 : {
449 0 : vnet_buffer (to_b)->l4_hdr_offset =
450 0 : (vnet_buffer (to_b)->l3_hdr_offset +
451 0 : (vnet_buffer (from_b)->l4_hdr_offset -
452 0 : vnet_buffer (from_b)->l3_hdr_offset));
453 0 : to_b->flags |= VNET_BUFFER_F_L4_HDR_OFFSET_VALID;
454 : }
455 80 : to_b->flags |= VNET_BUFFER_F_IS_IP6;
456 :
457 : /* Spin through from buffers filling up the to buffer */
458 80 : u16 left_in_to_buffer = len, to_ptr = 0;
459 : while (1)
460 23 : {
461 : u16 bytes_to_copy;
462 :
463 : /* Figure out how many bytes we can safely copy */
464 103 : bytes_to_copy = left_in_to_buffer <= left_in_from_buffer ?
465 : left_in_to_buffer : left_in_from_buffer;
466 103 : clib_memcpy_fast (to_data + to_ptr, from_data + ptr, bytes_to_copy);
467 103 : left_in_to_buffer -= bytes_to_copy;
468 103 : ptr += bytes_to_copy;
469 103 : left_in_from_buffer -= bytes_to_copy;
470 103 : if (left_in_to_buffer == 0)
471 80 : break;
472 :
473 23 : ASSERT (left_in_from_buffer <= 0);
474 : /* Move buffer */
475 23 : if (!(from_b->flags & VLIB_BUFFER_NEXT_PRESENT))
476 : {
477 0 : return IP_FRAG_ERROR_MALFORMED;
478 : }
479 23 : from_b = vlib_get_buffer (vm, from_b->next_buffer);
480 23 : from_data = (u8 *) vlib_buffer_get_current (from_b);
481 23 : ptr = 0;
482 23 : left_in_from_buffer = from_b->current_length;
483 23 : to_ptr += bytes_to_copy;
484 : }
485 :
486 80 : to_b->current_length = len + head_bytes;
487 80 : to_ip6->payload_length =
488 80 : clib_host_to_net_u16 (len + sizeof (ip6_frag_hdr_t));
489 80 : to_ip6->protocol = IP_PROTOCOL_IPV6_FRAGMENTATION;
490 80 : to_frag_hdr->fragment_offset_and_more =
491 80 : ip6_frag_hdr_offset_and_more ((fo >> 3), len != rem);
492 80 : to_frag_hdr->identification = ip_frag_id;
493 80 : to_frag_hdr->next_hdr = ip6->protocol;
494 80 : to_frag_hdr->rsv = 0;
495 :
496 80 : rem -= len;
497 80 : fo += len;
498 : }
499 :
500 31 : return IP_FRAG_ERROR_NONE;
501 : }
502 :
503 : /* *INDENT-OFF* */
504 183788 : VLIB_REGISTER_NODE (ip4_frag_node) = {
505 : .function = ip4_frag,
506 : .name = IP4_FRAG_NODE_NAME,
507 : .vector_size = sizeof (u32),
508 : .format_trace = format_ip_frag_trace,
509 : .type = VLIB_NODE_TYPE_INTERNAL,
510 :
511 : .n_errors = IP_FRAG_N_ERROR,
512 : .error_counters = ip_frag_error_counters,
513 :
514 : .n_next_nodes = IP_FRAG_N_NEXT,
515 : .next_nodes = { [IP_FRAG_NEXT_IP_REWRITE] = "ip4-rewrite",
516 : [IP_FRAG_NEXT_IP_REWRITE_MIDCHAIN] = "ip4-midchain",
517 : [IP_FRAG_NEXT_IP4_LOOKUP] = "ip4-lookup",
518 : [IP_FRAG_NEXT_IP6_LOOKUP] = "ip6-lookup",
519 : [IP_FRAG_NEXT_ICMP_ERROR] = "ip4-icmp-error",
520 : [IP_FRAG_NEXT_DROP] = "ip4-drop" },
521 : };
522 : /* *INDENT-ON* */
523 :
524 : /* *INDENT-OFF* */
525 183788 : VLIB_REGISTER_NODE (ip6_frag_node) = {
526 : .function = ip6_frag,
527 : .name = IP6_FRAG_NODE_NAME,
528 : .vector_size = sizeof (u32),
529 : .format_trace = format_ip_frag_trace,
530 : .type = VLIB_NODE_TYPE_INTERNAL,
531 :
532 : .n_errors = IP_FRAG_N_ERROR,
533 : .error_counters = ip_frag_error_counters,
534 :
535 : .n_next_nodes = IP_FRAG_N_NEXT,
536 : .next_nodes = { [IP_FRAG_NEXT_IP_REWRITE] = "ip6-rewrite",
537 : [IP_FRAG_NEXT_IP_REWRITE_MIDCHAIN] = "ip6-midchain",
538 : [IP_FRAG_NEXT_IP4_LOOKUP] = "ip4-lookup",
539 : [IP_FRAG_NEXT_IP6_LOOKUP] = "ip6-lookup",
540 : [IP_FRAG_NEXT_ICMP_ERROR] = "error-drop",
541 : [IP_FRAG_NEXT_DROP] = "ip6-drop" },
542 : };
543 : /* *INDENT-ON* */
544 :
545 : /*
546 : * fd.io coding-style-patch-verification: ON
547 : *
548 : * Local Variables:
549 : * eval: (c-set-style "gnu")
550 : * End:
551 : */
|
