Line data Source code
1 : /*
2 : * Copyright (c) 2016 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 : * @file
18 : * @brief Local TCP/IP stack punt infrastructure.
19 : *
20 : * Provides a set of VPP nodes together with the relevant APIs and CLI
21 : * commands in order to adjust and dispatch packets from the VPP data plane
22 : * to the local TCP/IP stack
23 : */
24 :
25 : #include <vnet/ip/ip.h>
26 : #include <vnet/ethernet/ethernet.h>
27 : #include <vlib/vlib.h>
28 : #include <vnet/ip/punt.h>
29 : #include <vlib/unix/unix.h>
30 :
31 : #include <stdio.h>
32 : #include <unistd.h>
33 : #include <sys/socket.h>
34 : #include <sys/uio.h>
35 : #include <stdlib.h>
36 :
37 : typedef enum
38 : {
39 : #define punt_error(n,s) PUNT_ERROR_##n,
40 : #include <vnet/ip/punt_error.def>
41 : #undef punt_error
42 : PUNT_N_ERROR,
43 : } punt_error_t;
44 :
45 : #define foreach_punt_next \
46 : _ (PUNT4, "ip4-punt") \
47 : _ (PUNT6, "ip6-punt")
48 :
49 : typedef enum
50 : {
51 : #define _(s,n) PUNT_NEXT_##s,
52 : foreach_punt_next
53 : #undef _
54 : PUNT_N_NEXT,
55 : } punt_next_t;
56 :
57 : enum punt_socket_rx_next_e
58 : {
59 : PUNT_SOCKET_RX_NEXT_INTERFACE_OUTPUT,
60 : PUNT_SOCKET_RX_NEXT_IP4_LOOKUP,
61 : PUNT_SOCKET_RX_NEXT_IP6_LOOKUP,
62 : PUNT_SOCKET_RX_N_NEXT
63 : };
64 :
65 : #define punt_next_punt(is_ip4) (is_ip4 ? PUNT_NEXT_PUNT4 : PUNT_NEXT_PUNT6)
66 :
67 : /** @brief IPv4/IPv6 UDP punt node main loop.
68 :
69 : This is the main loop inline function for IPv4/IPv6 UDP punt
70 : transition node.
71 :
72 : @param vm vlib_main_t corresponding to the current thread
73 : @param node vlib_node_runtime_t
74 : @param frame vlib_frame_t whose contents should be dispatched
75 : @param is_ipv4 indicates if called for IPv4 or IPv6 node
76 : */
77 : always_inline uword
78 73 : udp46_punt_inline (vlib_main_t * vm,
79 : vlib_node_runtime_t * node,
80 : vlib_frame_t * from_frame, int is_ip4)
81 : {
82 : u32 n_left_from, *from, *to_next;
83 : word advance;
84 :
85 73 : from = vlib_frame_vector_args (from_frame);
86 73 : n_left_from = from_frame->n_vectors;
87 :
88 : /* udp[46]_lookup hands us the data payload, not the IP header */
89 73 : if (is_ip4)
90 41 : advance = -(sizeof (ip4_header_t) + sizeof (udp_header_t));
91 : else
92 32 : advance = -(sizeof (ip6_header_t) + sizeof (udp_header_t));
93 :
94 146 : while (n_left_from > 0)
95 : {
96 : u32 n_left_to_next;
97 :
98 73 : vlib_get_next_frame (vm, node, punt_next_punt (is_ip4), to_next,
99 : n_left_to_next);
100 :
101 10765 : while (n_left_from > 0 && n_left_to_next > 0)
102 : {
103 : u32 bi0;
104 : vlib_buffer_t *b0;
105 :
106 10692 : bi0 = from[0];
107 10692 : to_next[0] = bi0;
108 10692 : from += 1;
109 10692 : to_next += 1;
110 10692 : n_left_from -= 1;
111 10692 : n_left_to_next -= 1;
112 :
113 10692 : b0 = vlib_get_buffer (vm, bi0);
114 10692 : vlib_buffer_advance (b0, advance);
115 10692 : b0->error = node->errors[PUNT_ERROR_UDP_PORT];
116 : }
117 :
118 73 : vlib_put_next_frame (vm, node, punt_next_punt (is_ip4), n_left_to_next);
119 : }
120 :
121 73 : return from_frame->n_vectors;
122 : }
123 :
124 : static char *punt_error_strings[] = {
125 : #define punt_error(n,s) s,
126 : #include "punt_error.def"
127 : #undef punt_error
128 : };
129 :
130 : /** @brief IPv4 UDP punt node.
131 : @node ip4-udp-punt
132 :
133 : This is the IPv4 UDP punt transition node. It is registered as a next
134 : node for the "ip4-udp-lookup" handling UDP port(s) requested for punt.
135 : The buffer's current data pointer is adjusted to the original packet
136 : IPv4 header. All buffers are dispatched to "error-punt".
137 :
138 : @param vm vlib_main_t corresponding to the current thread
139 : @param node vlib_node_runtime_t
140 : @param frame vlib_frame_t whose contents should be dispatched
141 :
142 : @par Graph mechanics: next index usage
143 :
144 : @em Sets:
145 : - <code>vnet_buffer(b)->current_data</code>
146 : - <code>vnet_buffer(b)->current_len</code>
147 :
148 : <em>Next Index:</em>
149 : - Dispatches the packet to the "error-punt" node
150 : */
151 2277 : VLIB_NODE_FN (udp4_punt_node) (vlib_main_t * vm,
152 : vlib_node_runtime_t * node,
153 : vlib_frame_t * from_frame)
154 : {
155 41 : return udp46_punt_inline (vm, node, from_frame, 1 /* is_ip4 */ );
156 : }
157 :
158 : /** @brief IPv6 UDP punt node.
159 : @node ip6-udp-punt
160 :
161 : This is the IPv6 UDP punt transition node. It is registered as a next
162 : node for the "ip6-udp-lookup" handling UDP port(s) requested for punt.
163 : The buffer's current data pointer is adjusted to the original packet
164 : IPv6 header. All buffers are dispatched to "error-punt".
165 :
166 : @param vm vlib_main_t corresponding to the current thread
167 : @param node vlib_node_runtime_t
168 : @param frame vlib_frame_t whose contents should be dispatched
169 :
170 : @par Graph mechanics: next index usage
171 :
172 : @em Sets:
173 : - <code>vnet_buffer(b)->current_data</code>
174 : - <code>vnet_buffer(b)->current_len</code>
175 :
176 : <em>Next Index:</em>
177 : - Dispatches the packet to the "error-punt" node
178 : */
179 2268 : VLIB_NODE_FN (udp6_punt_node) (vlib_main_t * vm,
180 : vlib_node_runtime_t * node,
181 : vlib_frame_t * from_frame)
182 : {
183 32 : return udp46_punt_inline (vm, node, from_frame, 0 /* is_ip4 */ );
184 : }
185 :
186 : /* *INDENT-OFF* */
187 178120 : VLIB_REGISTER_NODE (udp4_punt_node) = {
188 : .name = "ip4-udp-punt",
189 : /* Takes a vector of packets. */
190 : .vector_size = sizeof (u32),
191 :
192 : .n_errors = PUNT_N_ERROR,
193 : .error_strings = punt_error_strings,
194 :
195 : .n_next_nodes = PUNT_N_NEXT,
196 : .next_nodes = {
197 : #define _(s,n) [PUNT_NEXT_##s] = n,
198 : foreach_punt_next
199 : #undef _
200 : },
201 : };
202 :
203 178120 : VLIB_REGISTER_NODE (udp6_punt_node) = {
204 : .name = "ip6-udp-punt",
205 : /* Takes a vector of packets. */
206 : .vector_size = sizeof (u32),
207 :
208 : .n_errors = PUNT_N_ERROR,
209 : .error_strings = punt_error_strings,
210 :
211 : .n_next_nodes = PUNT_N_NEXT,
212 : .next_nodes = {
213 : #define _(s,n) [PUNT_NEXT_##s] = n,
214 : foreach_punt_next
215 : #undef _
216 : },
217 : };
218 : /* *INDENT-ON* */
219 :
220 : typedef struct
221 : {
222 : punt_client_t client;
223 : u8 is_midchain;
224 : u8 packet_data[64];
225 : } udp_punt_trace_t;
226 :
227 : static u8 *
228 75 : format_udp_punt_trace (u8 * s, va_list * args)
229 : {
230 75 : CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
231 75 : CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
232 75 : udp_punt_trace_t *t = va_arg (*args, udp_punt_trace_t *);
233 75 : u32 indent = format_get_indent (s);
234 75 : s = format (s, "to: %s", t->client.caddr.sun_path);
235 75 : if (t->is_midchain)
236 : {
237 0 : s = format (s, "\n%U(buffer is part of chain)", format_white_space,
238 : indent);
239 : }
240 75 : s = format (s, "\n%U%U", format_white_space, indent,
241 75 : format_hex_bytes, t->packet_data, sizeof (t->packet_data));
242 :
243 75 : return s;
244 : }
245 :
246 : always_inline uword
247 16 : punt_socket_inline (vlib_main_t * vm,
248 : vlib_node_runtime_t * node,
249 : vlib_frame_t * frame,
250 : punt_type_t pt, ip_address_family_t af)
251 : {
252 16 : u32 *buffers = vlib_frame_vector_args (frame);
253 16 : u32 thread_index = vm->thread_index;
254 16 : uword n_packets = frame->n_vectors;
255 16 : punt_main_t *pm = &punt_main;
256 : int i;
257 :
258 16 : punt_thread_data_t *ptd = &pm->thread_data[thread_index];
259 16 : u32 node_index = (AF_IP4 == af ?
260 16 : udp4_punt_socket_node.index :
261 : udp6_punt_socket_node.index);
262 :
263 63 : for (i = 0; i < n_packets; i++)
264 : {
265 : struct iovec *iov;
266 : vlib_buffer_t *b;
267 : uword l;
268 : punt_packetdesc_t packetdesc;
269 : punt_client_t *c;
270 :
271 47 : b = vlib_get_buffer (vm, buffers[i]);
272 :
273 47 : if (PUNT_TYPE_L4 == pt)
274 : {
275 : /* Reverse UDP Punt advance */
276 : udp_header_t *udp;
277 38 : if (AF_IP4 == af)
278 : {
279 20 : vlib_buffer_advance (b, -(sizeof (ip4_header_t) +
280 : sizeof (udp_header_t)));
281 20 : ip4_header_t *ip = vlib_buffer_get_current (b);
282 20 : udp = (udp_header_t *) (ip + 1);
283 : }
284 : else
285 : {
286 18 : vlib_buffer_advance (b, -(sizeof (ip6_header_t) +
287 : sizeof (udp_header_t)));
288 18 : ip6_header_t *ip = vlib_buffer_get_current (b);
289 18 : udp = (udp_header_t *) (ip + 1);
290 : }
291 :
292 : /*
293 : * Find registerered client
294 : * If no registered client, drop packet and count
295 : */
296 38 : c = punt_client_l4_get (af, clib_net_to_host_u16 (udp->dst_port));
297 : }
298 9 : else if (PUNT_TYPE_IP_PROTO == pt)
299 : {
300 : /* Reverse UDP Punt advance */
301 : ip_protocol_t proto;
302 :
303 7 : if (AF_IP4 == af)
304 : {
305 7 : ip4_header_t *ip = vlib_buffer_get_current (b);
306 7 : proto = ip->protocol;
307 : }
308 : else
309 : {
310 0 : ip6_header_t *ip = vlib_buffer_get_current (b);
311 0 : proto = ip->protocol;
312 : }
313 :
314 7 : c = punt_client_ip_proto_get (af, proto);
315 : }
316 2 : else if (PUNT_TYPE_EXCEPTION == pt)
317 : {
318 2 : c = punt_client_exception_get (b->punt_reason);
319 : }
320 : else
321 0 : c = NULL;
322 :
323 47 : if (PREDICT_FALSE (NULL == c))
324 : {
325 0 : vlib_node_increment_counter (vm, node_index,
326 : PUNT_ERROR_SOCKET_TX_ERROR, 1);
327 0 : goto error;
328 : }
329 :
330 47 : struct sockaddr_un *caddr = &c->caddr;
331 :
332 : /* Re-set iovecs */
333 47 : vec_reset_length (ptd->iovecs);
334 :
335 : /* Add packet descriptor */
336 47 : packetdesc.sw_if_index = vnet_buffer (b)->sw_if_index[VLIB_RX];
337 47 : packetdesc.action = 0;
338 47 : vec_add2 (ptd->iovecs, iov, 1);
339 47 : iov->iov_base = &packetdesc;
340 47 : iov->iov_len = sizeof (packetdesc);
341 :
342 : /** VLIB buffer chain -> Unix iovec(s). */
343 47 : vlib_buffer_advance (b, -ethernet_buffer_header_size (b));
344 47 : vec_add2 (ptd->iovecs, iov, 1);
345 47 : iov->iov_base = b->data + b->current_data;
346 47 : iov->iov_len = l = b->current_length;
347 :
348 47 : if (PREDICT_FALSE (b->flags & VLIB_BUFFER_IS_TRACED))
349 : {
350 : udp_punt_trace_t *t;
351 47 : t = vlib_add_trace (vm, node, b, sizeof (t[0]));
352 47 : clib_memcpy_fast (&t->client, c, sizeof (t->client));
353 47 : clib_memcpy_fast (t->packet_data,
354 47 : vlib_buffer_get_current (b),
355 : sizeof (t->packet_data));
356 : }
357 :
358 47 : if (PREDICT_FALSE (b->flags & VLIB_BUFFER_NEXT_PRESENT))
359 : {
360 : do
361 : {
362 0 : b = vlib_get_buffer (vm, b->next_buffer);
363 0 : if (PREDICT_FALSE (b->flags & VLIB_BUFFER_IS_TRACED))
364 : {
365 : udp_punt_trace_t *t;
366 0 : t = vlib_add_trace (vm, node, b, sizeof (t[0]));
367 0 : clib_memcpy_fast (&t->client, c, sizeof (t->client));
368 0 : t->is_midchain = 1;
369 : }
370 :
371 0 : vec_add2 (ptd->iovecs, iov, 1);
372 :
373 0 : iov->iov_base = b->data + b->current_data;
374 0 : iov->iov_len = b->current_length;
375 0 : l += b->current_length;
376 : }
377 0 : while (b->flags & VLIB_BUFFER_NEXT_PRESENT);
378 : }
379 :
380 94 : struct msghdr msg = {
381 : .msg_name = caddr,
382 : .msg_namelen = sizeof (*caddr),
383 47 : .msg_iov = ptd->iovecs,
384 47 : .msg_iovlen = vec_len (ptd->iovecs),
385 : };
386 :
387 47 : if (sendmsg (pm->socket_fd, &msg, 0) < (ssize_t) l)
388 1 : vlib_node_increment_counter (vm, node_index,
389 : PUNT_ERROR_SOCKET_TX_ERROR, 1);
390 : else
391 46 : vlib_node_increment_counter (vm, node_index, PUNT_ERROR_SOCKET_TX, 1);
392 : }
393 :
394 16 : error:
395 16 : vlib_buffer_free (vm, buffers, n_packets);
396 :
397 16 : return n_packets;
398 : }
399 :
400 : static uword
401 7 : udp4_punt_socket (vlib_main_t * vm,
402 : vlib_node_runtime_t * node, vlib_frame_t * from_frame)
403 : {
404 7 : return punt_socket_inline (vm, node, from_frame, PUNT_TYPE_L4, AF_IP4);
405 : }
406 :
407 : static uword
408 6 : udp6_punt_socket (vlib_main_t * vm,
409 : vlib_node_runtime_t * node, vlib_frame_t * from_frame)
410 : {
411 6 : return punt_socket_inline (vm, node, from_frame, PUNT_TYPE_L4, AF_IP6);
412 : }
413 :
414 : static uword
415 1 : ip4_proto_punt_socket (vlib_main_t * vm,
416 : vlib_node_runtime_t * node, vlib_frame_t * from_frame)
417 : {
418 1 : return punt_socket_inline (vm, node, from_frame,
419 : PUNT_TYPE_IP_PROTO, AF_IP4);
420 : }
421 :
422 : static uword
423 0 : ip6_proto_punt_socket (vlib_main_t * vm,
424 : vlib_node_runtime_t * node, vlib_frame_t * from_frame)
425 : {
426 0 : return punt_socket_inline (vm, node, from_frame,
427 : PUNT_TYPE_IP_PROTO, AF_IP6);
428 : }
429 :
430 : static uword
431 2 : exception_punt_socket (vlib_main_t * vm,
432 : vlib_node_runtime_t * node, vlib_frame_t * from_frame)
433 : {
434 2 : return punt_socket_inline (vm, node, from_frame,
435 : PUNT_TYPE_EXCEPTION, AF_IP4);
436 : }
437 :
438 :
439 : /* *INDENT-OFF* */
440 178120 : VLIB_REGISTER_NODE (udp4_punt_socket_node) = {
441 : .function = udp4_punt_socket,
442 : .name = "ip4-udp-punt-socket",
443 : .format_trace = format_udp_punt_trace,
444 : .flags = VLIB_NODE_FLAG_IS_DROP,
445 : /* Takes a vector of packets. */
446 : .vector_size = sizeof (u32),
447 : .n_errors = PUNT_N_ERROR,
448 : .error_strings = punt_error_strings,
449 : };
450 178120 : VLIB_REGISTER_NODE (udp6_punt_socket_node) = {
451 : .function = udp6_punt_socket,
452 : .name = "ip6-udp-punt-socket",
453 : .format_trace = format_udp_punt_trace,
454 : .flags = VLIB_NODE_FLAG_IS_DROP,
455 : .vector_size = sizeof (u32),
456 : .n_errors = PUNT_N_ERROR,
457 : .error_strings = punt_error_strings,
458 : };
459 178120 : VLIB_REGISTER_NODE (ip4_proto_punt_socket_node) = {
460 : .function = ip4_proto_punt_socket,
461 : .name = "ip4-proto-punt-socket",
462 : .format_trace = format_udp_punt_trace,
463 : .flags = VLIB_NODE_FLAG_IS_DROP,
464 : /* Takes a vector of packets. */
465 : .vector_size = sizeof (u32),
466 : .n_errors = PUNT_N_ERROR,
467 : .error_strings = punt_error_strings,
468 : };
469 178120 : VLIB_REGISTER_NODE (ip6_proto_punt_socket_node) = {
470 : .function = ip6_proto_punt_socket,
471 : .name = "ip6-proto-punt-socket",
472 : .format_trace = format_udp_punt_trace,
473 : .flags = VLIB_NODE_FLAG_IS_DROP,
474 : .vector_size = sizeof (u32),
475 : .n_errors = PUNT_N_ERROR,
476 : .error_strings = punt_error_strings,
477 : };
478 178120 : VLIB_REGISTER_NODE (exception_punt_socket_node) = {
479 : .function = exception_punt_socket,
480 : .name = "exception-punt-socket",
481 : .format_trace = format_udp_punt_trace,
482 : .flags = VLIB_NODE_FLAG_IS_DROP,
483 : .vector_size = sizeof (u32),
484 : .n_errors = PUNT_N_ERROR,
485 : .error_strings = punt_error_strings,
486 : };
487 : /* *INDENT-ON* */
488 :
489 : typedef struct
490 : {
491 : enum punt_action_e action;
492 : u32 sw_if_index;
493 : } punt_trace_t;
494 :
495 : static u8 *
496 0 : format_punt_trace (u8 * s, va_list * va)
497 : {
498 0 : CLIB_UNUSED (vlib_main_t * vm) = va_arg (*va, vlib_main_t *);
499 0 : CLIB_UNUSED (vlib_node_t * node) = va_arg (*va, vlib_node_t *);
500 0 : vnet_main_t *vnm = vnet_get_main ();
501 0 : punt_trace_t *t = va_arg (*va, punt_trace_t *);
502 0 : s = format (s, "%U Action: %d", format_vnet_sw_if_index_name,
503 0 : vnm, t->sw_if_index, t->action);
504 0 : return s;
505 : }
506 :
507 : static uword
508 0 : punt_socket_rx_fd (vlib_main_t * vm, vlib_node_runtime_t * node, u32 fd)
509 : {
510 0 : const uword buffer_size = vlib_buffer_get_default_data_size (vm);
511 0 : u32 n_trace = vlib_get_trace_count (vm, node);
512 0 : u32 next = node->cached_next_index;
513 : u32 n_left_to_next, next_index;
514 : u32 *to_next;
515 0 : u32 error = PUNT_ERROR_NONE;
516 0 : vlib_get_next_frame (vm, node, next, to_next, n_left_to_next);
517 :
518 : /* $$$$ Only dealing with one buffer at the time for now */
519 :
520 : u32 bi;
521 : vlib_buffer_t *b;
522 : punt_packetdesc_t packetdesc;
523 : ssize_t size;
524 : struct iovec io[2];
525 :
526 0 : if (vlib_buffer_alloc (vm, &bi, 1) != 1)
527 : {
528 0 : error = PUNT_ERROR_NOBUFFER;
529 0 : goto error;
530 : }
531 :
532 0 : b = vlib_get_buffer (vm, bi);
533 0 : io[0].iov_base = &packetdesc;
534 0 : io[0].iov_len = sizeof (packetdesc);
535 0 : io[1].iov_base = b->data;
536 0 : io[1].iov_len = buffer_size;
537 :
538 0 : size = readv (fd, io, 2);
539 : /* We need at least the packet descriptor plus a header */
540 0 : if (size <= (int) (sizeof (packetdesc) + sizeof (ip4_header_t)))
541 : {
542 0 : vlib_buffer_free (vm, &bi, 1);
543 0 : error = PUNT_ERROR_READV;
544 0 : goto error;
545 : }
546 :
547 0 : b->flags = VNET_BUFFER_F_LOCALLY_ORIGINATED;
548 0 : b->current_length = size - sizeof (packetdesc);
549 :
550 0 : switch (packetdesc.action)
551 : {
552 0 : case PUNT_L2:
553 0 : vnet_buffer (b)->sw_if_index[VLIB_TX] = packetdesc.sw_if_index;
554 0 : next_index = PUNT_SOCKET_RX_NEXT_INTERFACE_OUTPUT;
555 0 : break;
556 :
557 0 : case PUNT_IP4_ROUTED:
558 0 : vnet_buffer (b)->sw_if_index[VLIB_RX] = packetdesc.sw_if_index;
559 0 : vnet_buffer (b)->sw_if_index[VLIB_TX] = ~0;
560 0 : next_index = PUNT_SOCKET_RX_NEXT_IP4_LOOKUP;
561 0 : break;
562 :
563 0 : case PUNT_IP6_ROUTED:
564 0 : vnet_buffer (b)->sw_if_index[VLIB_RX] = packetdesc.sw_if_index;
565 0 : vnet_buffer (b)->sw_if_index[VLIB_TX] = ~0;
566 0 : next_index = PUNT_SOCKET_RX_NEXT_IP6_LOOKUP;
567 0 : break;
568 :
569 0 : default:
570 0 : error = PUNT_ERROR_ACTION;
571 0 : vlib_buffer_free (vm, &bi, 1);
572 0 : goto error;
573 : }
574 :
575 0 : if (PREDICT_FALSE
576 : (n_trace > 0
577 : && vlib_trace_buffer (vm, node, next_index, b, 1 /* follow_chain */ )))
578 : {
579 : punt_trace_t *t;
580 0 : vlib_set_trace_count (vm, node, --n_trace);
581 0 : t = vlib_add_trace (vm, node, b, sizeof (*t));
582 0 : t->sw_if_index = packetdesc.sw_if_index;
583 0 : t->action = packetdesc.action;
584 : }
585 :
586 0 : to_next[0] = bi;
587 0 : to_next++;
588 0 : n_left_to_next--;
589 :
590 0 : vlib_validate_buffer_enqueue_x1 (vm, node, next, to_next, n_left_to_next,
591 : bi, next_index);
592 0 : vlib_put_next_frame (vm, node, next, n_left_to_next);
593 :
594 0 : return 1;
595 :
596 0 : error:
597 0 : vlib_put_next_frame (vm, node, next, n_left_to_next);
598 0 : vlib_node_increment_counter (vm, punt_socket_rx_node.index, error, 1);
599 0 : return 0;
600 : }
601 :
602 : static uword
603 0 : punt_socket_rx (vlib_main_t * vm,
604 : vlib_node_runtime_t * node, vlib_frame_t * frame)
605 : {
606 0 : punt_main_t *pm = &punt_main;
607 0 : u32 total_count = 0;
608 : int i;
609 :
610 0 : for (i = 0; i < vec_len (pm->ready_fds); i++)
611 : {
612 0 : total_count += punt_socket_rx_fd (vm, node, pm->ready_fds[i]);
613 0 : vec_del1 (pm->ready_fds, i);
614 : }
615 0 : return total_count;
616 : }
617 :
618 : /* *INDENT-OFF* */
619 178120 : VLIB_REGISTER_NODE (punt_socket_rx_node) =
620 : {
621 : .function = punt_socket_rx,
622 : .name = "punt-socket-rx",
623 : .flags = VLIB_NODE_FLAG_TRACE_SUPPORTED,
624 : .type = VLIB_NODE_TYPE_INPUT,
625 : .state = VLIB_NODE_STATE_INTERRUPT,
626 : .vector_size = 1,
627 : .n_errors = PUNT_N_ERROR,
628 : .error_strings = punt_error_strings,
629 : .n_next_nodes = PUNT_SOCKET_RX_N_NEXT,
630 : .next_nodes = {
631 : [PUNT_SOCKET_RX_NEXT_INTERFACE_OUTPUT] = "interface-output",
632 : [PUNT_SOCKET_RX_NEXT_IP4_LOOKUP] = "ip4-lookup",
633 : [PUNT_SOCKET_RX_NEXT_IP6_LOOKUP] = "ip6-lookup",
634 : },
635 : .format_trace = format_punt_trace,
636 : };
637 : /* *INDENT-ON* */
638 :
639 : /*
640 : * fd.io coding-style-patch-verification: ON
641 : *
642 : * Local Variables:
643 : * eval: (c-set-style "gnu")
644 : * End:
645 : */
|
