FD.io VPP  v19.04.4-rc0-5-ge88582fac
Vector Packet Processing
udp_local.c
Go to the documentation of this file.
1 /*
2  * node.c: udp packet processing
3  *
4  * Copyright (c) 2013-2019 Cisco and/or its affiliates.
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at:
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17 
18 #include <vlib/vlib.h>
19 #include <vnet/pg/pg.h>
20 #include <vnet/udp/udp.h>
21 #include <vnet/udp/udp_packet.h>
22 #include <vppinfra/sparse_vec.h>
23 
24 #define foreach_udp_local_next \
25  _ (PUNT4, "ip4-punt") \
26  _ (PUNT6, "ip6-punt") \
27  _ (DROP4, "ip4-drop") \
28  _ (DROP6, "ip6-drop") \
29  _ (ICMP4_ERROR, "ip4-icmp-error") \
30  _ (ICMP6_ERROR, "ip6-icmp-error")
31 
32 typedef enum
33 {
34 #define _(s,n) UDP_LOCAL_NEXT_##s,
36 #undef _
39 
40 #define udp_local_next_drop(is_ip4) ((is_ip4) ? UDP_LOCAL_NEXT_DROP4 : UDP_LOCAL_NEXT_DROP6)
41 #define udp_local_next_punt(is_ip4) ((is_ip4) ? UDP_LOCAL_NEXT_PUNT4 : UDP_LOCAL_NEXT_PUNT6)
42 
43 typedef struct
44 {
49 
50 #ifndef CLIB_MARCH_VARIANT
51 u8 *
52 format_udp_rx_trace (u8 * s, va_list * args)
53 {
54  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
55  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
56  udp_local_rx_trace_t *t = va_arg (*args, udp_local_rx_trace_t *);
57 
58  s = format (s, "UDP: src-port %d dst-port %d%s",
59  clib_net_to_host_u16 (t->src_port),
60  clib_net_to_host_u16 (t->dst_port),
61  t->bound ? "" : " (no listener)");
62  return s;
63 }
64 #endif /* CLIB_MARCH_VARIANT */
65 
68  vlib_node_runtime_t * node,
69  vlib_frame_t * from_frame, int is_ip4)
70 {
71  udp_main_t *um = &udp_main;
72  __attribute__ ((unused)) u32 n_left_from, next_index, *from, *to_next;
73  word n_no_listener = 0;
74  u8 punt_unknown = is_ip4 ? um->punt_unknown4 : um->punt_unknown6;
75 
76  from = vlib_frame_vector_args (from_frame);
77  n_left_from = from_frame->n_vectors;
78 
79  next_index = node->cached_next_index;
80 
81  while (n_left_from > 0)
82  {
83  u32 n_left_to_next;
84 
85  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
86 
87  while (n_left_from >= 4 && n_left_to_next >= 2)
88  {
89  u32 bi0, bi1;
90  vlib_buffer_t *b0, *b1;
91  udp_header_t *h0 = 0, *h1 = 0;
92  u32 i0, i1, dst_port0, dst_port1;
93  u32 advance0, advance1;
94  u32 error0, next0, error1, next1;
95 
96  /* Prefetch next iteration. */
97  {
98  vlib_buffer_t *p2, *p3;
99 
100  p2 = vlib_get_buffer (vm, from[2]);
101  p3 = vlib_get_buffer (vm, from[3]);
102 
103  vlib_prefetch_buffer_header (p2, LOAD);
104  vlib_prefetch_buffer_header (p3, LOAD);
105 
106  CLIB_PREFETCH (p2->data, sizeof (h0[0]), LOAD);
107  CLIB_PREFETCH (p3->data, sizeof (h1[0]), LOAD);
108  }
109 
110  bi0 = from[0];
111  bi1 = from[1];
112  to_next[0] = bi0;
113  to_next[1] = bi1;
114  from += 2;
115  to_next += 2;
116  n_left_to_next -= 2;
117  n_left_from -= 2;
118 
119  b0 = vlib_get_buffer (vm, bi0);
120  b1 = vlib_get_buffer (vm, bi1);
121 
122  /* ip4/6_local hands us the ip header, not the udp header */
123  if (is_ip4)
124  {
125  advance0 = sizeof (ip4_header_t);
126  advance1 = sizeof (ip4_header_t);
127  }
128  else
129  {
130  advance0 = sizeof (ip6_header_t);
131  advance1 = sizeof (ip6_header_t);
132  }
133 
134  if (PREDICT_FALSE (b0->current_length < advance0 + sizeof (*h0)))
135  {
136  error0 = UDP_ERROR_LENGTH_ERROR;
137  next0 = udp_local_next_drop (is_ip4);
138  }
139  else
140  {
141  vlib_buffer_advance (b0, advance0);
142  h0 = vlib_buffer_get_current (b0);
143  error0 = next0 = 0;
144  if (PREDICT_FALSE (clib_net_to_host_u16 (h0->length) >
145  vlib_buffer_length_in_chain (vm, b0)))
146  {
147  error0 = UDP_ERROR_LENGTH_ERROR;
148  next0 = udp_local_next_drop (is_ip4);
149  }
150  }
151 
152  if (PREDICT_FALSE (b1->current_length < advance1 + sizeof (*h1)))
153  {
154  error1 = UDP_ERROR_LENGTH_ERROR;
155  next1 = udp_local_next_drop (is_ip4);
156  }
157  else
158  {
159  vlib_buffer_advance (b1, advance1);
160  h1 = vlib_buffer_get_current (b1);
161  error1 = next1 = 0;
162  if (PREDICT_FALSE (clib_net_to_host_u16 (h1->length) >
163  vlib_buffer_length_in_chain (vm, b1)))
164  {
165  error1 = UDP_ERROR_LENGTH_ERROR;
166  next1 = udp_local_next_drop (is_ip4);
167  }
168  }
169 
170  /* Index sparse array with network byte order. */
171  dst_port0 = (error0 == 0) ? h0->dst_port : 0;
172  dst_port1 = (error1 == 0) ? h1->dst_port : 0;
173  sparse_vec_index2 (is_ip4 ? um->next_by_dst_port4 :
174  um->next_by_dst_port6,
175  dst_port0, dst_port1, &i0, &i1);
176  next0 = (error0 == 0) ?
177  vec_elt (is_ip4 ? um->next_by_dst_port4 : um->next_by_dst_port6,
178  i0) : next0;
179  next1 = (error1 == 0) ?
180  vec_elt (is_ip4 ? um->next_by_dst_port4 : um->next_by_dst_port6,
181  i1) : next1;
182 
184  {
185  // move the pointer back so icmp-error can find the
186  // ip packet header
187  vlib_buffer_advance (b0, -(word) advance0);
188 
189  if (PREDICT_FALSE (punt_unknown))
190  {
191  b0->error = node->errors[UDP_ERROR_PUNT];
192  next0 = udp_local_next_punt (is_ip4);
193  }
194  else if (is_ip4)
195  {
197  ICMP4_destination_unreachable,
198  ICMP4_destination_unreachable_port_unreachable,
199  0);
200  next0 = UDP_LOCAL_NEXT_ICMP4_ERROR;
201  n_no_listener++;
202  }
203  else
204  {
206  ICMP6_destination_unreachable,
207  ICMP6_destination_unreachable_port_unreachable,
208  0);
209  next0 = UDP_LOCAL_NEXT_ICMP6_ERROR;
210  n_no_listener++;
211  }
212  }
213  else
214  {
215  b0->error = node->errors[UDP_ERROR_NONE];
216  // advance to the payload
217  vlib_buffer_advance (b0, sizeof (*h0));
218  }
219 
221  {
222  // move the pointer back so icmp-error can find the
223  // ip packet header
224  vlib_buffer_advance (b1, -(word) advance1);
225 
226  if (PREDICT_FALSE (punt_unknown))
227  {
228  b1->error = node->errors[UDP_ERROR_PUNT];
229  next1 = udp_local_next_punt (is_ip4);
230  }
231  else if (is_ip4)
232  {
234  ICMP4_destination_unreachable,
235  ICMP4_destination_unreachable_port_unreachable,
236  0);
237  next1 = UDP_LOCAL_NEXT_ICMP4_ERROR;
238  n_no_listener++;
239  }
240  else
241  {
243  ICMP6_destination_unreachable,
244  ICMP6_destination_unreachable_port_unreachable,
245  0);
246  next1 = UDP_LOCAL_NEXT_ICMP6_ERROR;
247  n_no_listener++;
248  }
249  }
250  else
251  {
252  b1->error = node->errors[UDP_ERROR_NONE];
253  // advance to the payload
254  vlib_buffer_advance (b1, sizeof (*h1));
255  }
256 
257  if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
258  {
259  udp_local_rx_trace_t *tr = vlib_add_trace (vm, node,
260  b0, sizeof (*tr));
261  if (b0->error != node->errors[UDP_ERROR_LENGTH_ERROR])
262  {
263  tr->src_port = h0 ? h0->src_port : 0;
264  tr->dst_port = h0 ? h0->dst_port : 0;
265  tr->bound = (next0 != UDP_LOCAL_NEXT_ICMP4_ERROR &&
266  next0 != UDP_LOCAL_NEXT_ICMP6_ERROR);
267  }
268  }
269  if (PREDICT_FALSE (b1->flags & VLIB_BUFFER_IS_TRACED))
270  {
271  udp_local_rx_trace_t *tr = vlib_add_trace (vm, node,
272  b1, sizeof (*tr));
273  if (b1->error != node->errors[UDP_ERROR_LENGTH_ERROR])
274  {
275  tr->src_port = h1 ? h1->src_port : 0;
276  tr->dst_port = h1 ? h1->dst_port : 0;
277  tr->bound = (next1 != UDP_LOCAL_NEXT_ICMP4_ERROR &&
278  next1 != UDP_LOCAL_NEXT_ICMP6_ERROR);
279  }
280  }
281 
282  vlib_validate_buffer_enqueue_x2 (vm, node, next_index,
283  to_next, n_left_to_next,
284  bi0, bi1, next0, next1);
285  }
286 
287  while (n_left_from > 0 && n_left_to_next > 0)
288  {
289  u32 bi0;
290  vlib_buffer_t *b0;
291  udp_header_t *h0 = 0;
292  u32 i0, next0;
293  u32 advance0;
294 
295  bi0 = from[0];
296  to_next[0] = bi0;
297  from += 1;
298  to_next += 1;
299  n_left_from -= 1;
300  n_left_to_next -= 1;
301 
302  b0 = vlib_get_buffer (vm, bi0);
303 
304  /* ip4/6_local hands us the ip header, not the udp header */
305  if (is_ip4)
306  advance0 = sizeof (ip4_header_t);
307  else
308  advance0 = sizeof (ip6_header_t);
309 
310  if (PREDICT_FALSE (b0->current_length < advance0 + sizeof (*h0)))
311  {
312  b0->error = node->errors[UDP_ERROR_LENGTH_ERROR];
313  next0 = udp_local_next_drop (is_ip4);
314  goto trace_x1;
315  }
316 
317  vlib_buffer_advance (b0, advance0);
318 
319  h0 = vlib_buffer_get_current (b0);
320 
321  if (PREDICT_TRUE (clib_net_to_host_u16 (h0->length) <=
322  vlib_buffer_length_in_chain (vm, b0)))
323  {
324  i0 = sparse_vec_index (is_ip4 ? um->next_by_dst_port4 :
325  um->next_by_dst_port6, h0->dst_port);
326  next0 = vec_elt (is_ip4 ? um->next_by_dst_port4 :
327  um->next_by_dst_port6, i0);
328 
330  {
331  // move the pointer back so icmp-error can find the
332  // ip packet header
333  vlib_buffer_advance (b0, -(word) advance0);
334 
335  if (PREDICT_FALSE (punt_unknown))
336  {
337  b0->error = node->errors[UDP_ERROR_PUNT];
338  next0 = udp_local_next_punt (is_ip4);
339  }
340  else if (is_ip4)
341  {
343  ICMP4_destination_unreachable,
344  ICMP4_destination_unreachable_port_unreachable,
345  0);
346  next0 = UDP_LOCAL_NEXT_ICMP4_ERROR;
347  n_no_listener++;
348  }
349  else
350  {
352  ICMP6_destination_unreachable,
353  ICMP6_destination_unreachable_port_unreachable,
354  0);
355  next0 = UDP_LOCAL_NEXT_ICMP6_ERROR;
356  n_no_listener++;
357  }
358  }
359  else
360  {
361  b0->error = node->errors[UDP_ERROR_NONE];
362  // advance to the payload
363  vlib_buffer_advance (b0, sizeof (*h0));
364  }
365  }
366  else
367  {
368  b0->error = node->errors[UDP_ERROR_LENGTH_ERROR];
369  next0 = udp_local_next_drop (is_ip4);
370  }
371 
372  trace_x1:
373  if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
374  {
375  udp_local_rx_trace_t *tr = vlib_add_trace (vm, node,
376  b0, sizeof (*tr));
377  if (b0->error != node->errors[UDP_ERROR_LENGTH_ERROR])
378  {
379  tr->src_port = h0->src_port;
380  tr->dst_port = h0->dst_port;
381  tr->bound = (next0 != UDP_LOCAL_NEXT_ICMP4_ERROR &&
382  next0 != UDP_LOCAL_NEXT_ICMP6_ERROR);
383  }
384  }
385 
386  vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
387  to_next, n_left_to_next,
388  bi0, next0);
389  }
390 
391  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
392  }
393  vlib_error_count (vm, node->node_index, UDP_ERROR_NO_LISTENER,
394  n_no_listener);
395  return from_frame->n_vectors;
396 }
397 
398 static char *udp_error_strings[] = {
399 #define udp_error(n,s) s,
400 #include "udp_error.def"
401 #undef udp_error
402 };
403 
405  vlib_node_runtime_t * node,
406  vlib_frame_t * from_frame)
407 {
408  return udp46_local_inline (vm, node, from_frame, 1 /* is_ip4 */ );
409 }
410 
412  vlib_node_runtime_t * node,
413  vlib_frame_t * from_frame)
414 {
415  return udp46_local_inline (vm, node, from_frame, 0 /* is_ip4 */ );
416 }
417 
418 /* *INDENT-OFF* */
420  .name = "ip4-udp-lookup",
421  /* Takes a vector of packets. */
422  .vector_size = sizeof (u32),
423 
424  .n_errors = UDP_N_ERROR,
425  .error_strings = udp_error_strings,
426 
427  .n_next_nodes = UDP_LOCAL_N_NEXT,
428  .next_nodes = {
429 #define _(s,n) [UDP_LOCAL_NEXT_##s] = n,
431 #undef _
432  },
433 
434  .format_buffer = format_udp_header,
435  .format_trace = format_udp_rx_trace,
436  .unformat_buffer = unformat_udp_header,
437 };
438 /* *INDENT-ON* */
439 
440 /* *INDENT-OFF* */
442  .name = "ip6-udp-lookup",
443  /* Takes a vector of packets. */
444  .vector_size = sizeof (u32),
445 
446  .n_errors = UDP_N_ERROR,
447  .error_strings = udp_error_strings,
448 
449  .n_next_nodes = UDP_LOCAL_N_NEXT,
450  .next_nodes = {
451 #define _(s,n) [UDP_LOCAL_NEXT_##s] = n,
453 #undef _
454  },
455 
456  .format_buffer = format_udp_header,
457  .format_trace = format_udp_rx_trace,
458  .unformat_buffer = unformat_udp_header,
459 };
460 /* *INDENT-ON* */
461 
462 #ifndef CLIB_MARCH_VARIANT
463 static void
465  udp_dst_port_t dst_port, char *dst_port_name, u8 is_ip4)
466 {
468  u32 i;
469 
470  vec_add2 (um->dst_port_infos[is_ip4], pi, 1);
471  i = pi - um->dst_port_infos[is_ip4];
472 
473  pi->name = dst_port_name;
474  pi->dst_port = dst_port;
475  pi->next_index = pi->node_index = ~0;
476 
477  hash_set (um->dst_port_info_by_dst_port[is_ip4], dst_port, i);
478 
479  if (pi->name)
480  hash_set_mem (um->dst_port_info_by_name[is_ip4], pi->name, i);
481 }
482 
483 void
485  udp_dst_port_t dst_port, u32 node_index, u8 is_ip4)
486 {
487  udp_main_t *um = &udp_main;
489  u16 *n;
490 
491  {
493  if (error)
494  clib_error_report (error);
495  }
496 
497  pi = udp_get_dst_port_info (um, dst_port, is_ip4);
498  if (!pi)
499  {
500  add_dst_port (um, dst_port, 0, is_ip4);
501  pi = udp_get_dst_port_info (um, dst_port, is_ip4);
502  ASSERT (pi);
503  }
504 
505  pi->node_index = node_index;
506  pi->next_index = vlib_node_add_next (vm,
507  is_ip4 ? udp4_local_node.index
508  : udp6_local_node.index, node_index);
509 
510  /* Setup udp protocol -> next index sparse vector mapping. */
511  if (is_ip4)
513  clib_host_to_net_u16 (dst_port));
514  else
516  clib_host_to_net_u16 (dst_port));
517 
518  n[0] = pi->next_index;
519 }
520 
521 void
523 {
524  udp_main_t *um = &udp_main;
526  u16 *n;
527 
528  pi = udp_get_dst_port_info (um, dst_port, is_ip4);
529  /* Not registered? Fagedaboudit */
530  if (!pi)
531  return;
532 
533  /* Kill the mapping. Don't bother killing the pi, it may be back. */
534  if (is_ip4)
536  clib_host_to_net_u16 (dst_port));
537  else
539  clib_host_to_net_u16 (dst_port));
540 
542 }
543 
544 bool
546 {
547  udp_main_t *um = &udp_main;
548  u16 *n;
549 
550  if (is_ip4)
552  clib_host_to_net_u16 (dst_port));
553  else
555  clib_host_to_net_u16 (dst_port));
556 
557  return (n[0] != SPARSE_VEC_INVALID_INDEX);
558 }
559 
560 void
562 {
563  udp_main_t *um = &udp_main;
564  {
566  if (error)
567  clib_error_report (error);
568  }
569 
570  if (is_ip4)
571  um->punt_unknown4 = is_add;
572  else
573  um->punt_unknown6 = is_add;
574 }
575 
576 /* Parse a UDP header. */
577 uword
578 unformat_udp_header (unformat_input_t * input, va_list * args)
579 {
580  u8 **result = va_arg (*args, u8 **);
581  udp_header_t *udp;
582  __attribute__ ((unused)) int old_length;
584 
585  /* Allocate space for IP header. */
586  {
587  void *p;
588 
589  old_length = vec_len (*result);
590  vec_add2 (*result, p, sizeof (ip4_header_t));
591  udp = p;
592  }
593 
594  clib_memset (udp, 0, sizeof (udp[0]));
595  if (unformat (input, "src-port %d dst-port %d", &src_port, &dst_port))
596  {
597  udp->src_port = clib_host_to_net_u16 (src_port);
598  udp->dst_port = clib_host_to_net_u16 (dst_port);
599  return 1;
600  }
601  return 0;
602 }
603 
604 static void
605 udp_setup_node (vlib_main_t * vm, u32 node_index)
606 {
607  vlib_node_t *n = vlib_get_node (vm, node_index);
608  pg_node_t *pn = pg_get_node (node_index);
609 
613 }
614 
615 clib_error_t *
617 {
618  udp_main_t *um = &udp_main;
619  int i;
620 
621  {
622  clib_error_t *error;
623  error = vlib_call_init_function (vm, udp_init);
624  if (error)
625  clib_error_report (error);
626  }
627 
628 
629  for (i = 0; i < 2; i++)
630  {
631  um->dst_port_info_by_name[i] = hash_create_string (0, sizeof (uword));
632  um->dst_port_info_by_dst_port[i] = hash_create (0, sizeof (uword));
633  }
634 
635  udp_setup_node (vm, udp4_local_node.index);
636  udp_setup_node (vm, udp6_local_node.index);
637 
638  um->punt_unknown4 = 0;
639  um->punt_unknown6 = 0;
640 
642  ( /* elt bytes */ sizeof (um->next_by_dst_port4[0]),
643  /* bits in index */ BITS (((udp_header_t *) 0)->dst_port));
644 
646  ( /* elt bytes */ sizeof (um->next_by_dst_port6[0]),
647  /* bits in index */ BITS (((udp_header_t *) 0)->dst_port));
648 
649 #define _(n,s) add_dst_port (um, UDP_DST_PORT_##s, #s, 1 /* is_ip4 */);
651 #undef _
652 #define _(n,s) add_dst_port (um, UDP_DST_PORT_##s, #s, 0 /* is_ip4 */);
654 #undef _
655  ip4_register_protocol (IP_PROTOCOL_UDP, udp4_local_node.index);
656  /* Note: ip6 differs from ip4, UDP is hotwired to ip6-udp-lookup */
657  return 0;
658 }
659 
661 #endif /* CLIB_MARCH_VARIANT */
662 
663 /*
664  * fd.io coding-style-patch-verification: ON
665  *
666  * Local Variables:
667  * eval: (c-set-style "gnu")
668  * End:
669  */
void udp_unregister_dst_port(vlib_main_t *vm, udp_dst_port_t dst_port, u8 is_ip4)
Definition: udp_local.c:522
u32 flags
buffer flags: VLIB_BUFFER_FREE_LIST_INDEX_MASK: bits used to store free list index, VLIB_BUFFER_IS_TRACED: trace this buffer.
Definition: buffer.h:124
udp_main_t udp_main
Definition: udp.c:25
bool udp_is_valid_dst_port(udp_dst_port_t dst_port, u8 is_ip4)
Definition: udp_local.c:545
#define hash_set(h, key, value)
Definition: hash.h:255
#define CLIB_UNUSED(x)
Definition: clib.h:82
u16 * next_by_dst_port6
Definition: udp.h:133
format_function_t format_udp_header
Definition: format.h:101
clib_error_t * udp_local_init(vlib_main_t *vm)
Definition: udp_local.c:616
static char * udp_error_strings[]
Definition: udp_local.c:398
#define PREDICT_TRUE(x)
Definition: clib.h:112
uword * dst_port_info_by_dst_port[N_UDP_AF]
Definition: udp.h:128
static void vlib_error_count(vlib_main_t *vm, uword node_index, uword counter, uword increment)
Definition: error_funcs.h:57
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
static clib_error_t * udp_init(vlib_main_t *vm)
Definition: udp.c:387
u16 current_length
Nbytes between current data and the end of this buffer.
Definition: buffer.h:113
udp_local_next_t
Definition: udp_local.c:32
u8 data[0]
Packet data.
Definition: buffer.h:181
#define vec_add2(V, P, N)
Add N elements to end of vector V, return pointer to new elements in P.
Definition: vec.h:560
int i
void udp_register_dst_port(vlib_main_t *vm, udp_dst_port_t dst_port, u32 node_index, u8 is_ip4)
Definition: udp_local.c:484
#define hash_set_mem(h, key, value)
Definition: hash.h:275
static udp_dst_port_info_t * udp_get_dst_port_info(udp_main_t *um, udp_dst_port_t dst_port, u8 is_ip4)
Definition: udp.h:242
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
#define VLIB_NODE_FN(node)
Definition: node.h:201
u8 punt_unknown6
Definition: udp.h:135
void ip4_register_protocol(u32 protocol, u32 node_index)
Definition: ip4_forward.c:1702
vlib_error_t * errors
Vector of errors for this node.
Definition: node.h:468
static uword vlib_buffer_length_in_chain(vlib_main_t *vm, vlib_buffer_t *b)
Get length in bytes of the buffer chain.
Definition: buffer_funcs.h:366
static uword vlib_node_add_next(vlib_main_t *vm, uword node, uword next_node)
Definition: node_funcs.h:1092
unsigned char u8
Definition: types.h:56
static void add_dst_port(udp_main_t *um, udp_dst_port_t dst_port, char *dst_port_name, u8 is_ip4)
Definition: udp_local.c:464
static pg_node_t * pg_get_node(uword node_index)
Definition: pg.h:357
u16 src_port
Definition: udp.api:41
#define udp_local_next_punt(is_ip4)
Definition: udp_local.c:41
i64 word
Definition: types.h:111
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:163
#define always_inline
Definition: clib.h:98
vlib_node_registration_t udp6_local_node
(constructor) VLIB_REGISTER_NODE (udp6_local_node)
Definition: udp_local.c:441
u8 punt_unknown4
Definition: udp.h:134
#define sparse_vec_validate(v, i)
Definition: sparse_vec.h:231
#define vlib_prefetch_buffer_header(b, type)
Prefetch buffer metadata.
Definition: buffer.h:203
unsigned int u32
Definition: types.h:88
static void sparse_vec_index2(void *v, u32 si0, u32 si1, u32 *i0_return, u32 *i1_return)
Definition: sparse_vec.h:169
#define vlib_call_init_function(vm, x)
Definition: init.h:260
#define hash_create_string(elts, value_bytes)
Definition: hash.h:690
void icmp6_error_set_vnet_buffer(vlib_buffer_t *b, u8 type, u8 code, u32 data)
Definition: icmp6.c:446
vlib_error_t error
Error code for buffers to be enqueued to error handler.
Definition: buffer.h:136
u16 * next_by_dst_port4
Definition: udp.h:132
udp_dst_port_info_t * dst_port_infos[N_UDP_AF]
Definition: udp.h:124
struct _unformat_input_t unformat_input_t
unsigned short u16
Definition: types.h:57
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:229
static uword udp46_local_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame, int is_ip4)
Definition: udp_local.c:67
uword * dst_port_info_by_name[N_UDP_AF]
Definition: udp.h:127
#define PREDICT_FALSE(x)
Definition: clib.h:111
format_function_t * format_buffer
Definition: node.h:356
u32 node_index
Node index.
Definition: node.h:494
#define vlib_validate_buffer_enqueue_x2(vm, node, next_index, to_next, n_left_to_next, bi0, bi1, next0, next1)
Finish enqueueing two buffers forward in the graph.
Definition: buffer_node.h:70
#define vlib_validate_buffer_enqueue_x1(vm, node, next_index, to_next, n_left_to_next, bi0, next0)
Finish enqueueing one buffer forward in the graph.
Definition: buffer_node.h:218
#define vlib_get_next_frame(vm, node, next_index, vectors, n_vectors_left)
Get pointer to next frame vector data by (vlib_node_runtime_t, next_index).
Definition: node_funcs.h:338
#define foreach_udp_local_next
Definition: udp_local.c:24
static void udp_setup_node(vlib_main_t *vm, u32 node_index)
Definition: udp_local.c:605
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:169
u16 n_vectors
Definition: node.h:395
#define CLIB_PREFETCH(addr, size, type)
Definition: cache.h:80
vlib_main_t * vm
Definition: buffer.c:312
void icmp4_error_set_vnet_buffer(vlib_buffer_t *b, u8 type, u8 code, u32 data)
Definition: icmp4.c:431
unformat_function_t unformat_pg_udp_header
Definition: format.h:103
unformat_function_t * unformat_buffer
Definition: node.h:357
unformat_function_t * unformat_edit
Definition: pg.h:310
void vlib_put_next_frame(vlib_main_t *vm, vlib_node_runtime_t *r, u32 next_index, u32 n_vectors_left)
Release pointer to next frame vector data.
Definition: main.c:458
void udp_punt_unknown(vlib_main_t *vm, u8 is_ip4, u8 is_add)
Definition: udp_local.c:561
udp_dst_port_t
Definition: udp.h:83
vlib_node_registration_t udp4_local_node
(constructor) VLIB_REGISTER_NODE (udp4_local_node)
Definition: udp_local.c:419
#define hash_create(elts, value_bytes)
Definition: hash.h:696
static uword sparse_vec_index(void *v, uword sparse_index)
Definition: sparse_vec.h:161
u16 cached_next_index
Next frame index that vector arguments were last enqueued to last time this node ran.
Definition: node.h:513
#define foreach_udp4_dst_port
Definition: udp.h:46
#define ASSERT(truth)
u8 is_add
Definition: ipsec_gre.api:36
udp_dst_port_t dst_port
Definition: udp.h:103
char * name
Definition: udp.h:100
#define clib_error_report(e)
Definition: error.h:113
static void vlib_buffer_advance(vlib_buffer_t *b, word l)
Advance current data pointer by the supplied (signed!) amount.
Definition: buffer.h:248
static void * vlib_add_trace(vlib_main_t *vm, vlib_node_runtime_t *r, vlib_buffer_t *b, u32 n_data_bytes)
Definition: trace_funcs.h:57
#define vec_elt(v, i)
Get vector value at index i.
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
VLIB buffer representation.
Definition: buffer.h:102
u64 uword
Definition: types.h:112
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
Definition: node_funcs.h:244
uword unformat_udp_header(unformat_input_t *input, va_list *args)
Definition: udp_local.c:578
u8 * format_udp_rx_trace(u8 *s, va_list *args)
Definition: udp_local.c:52
static vlib_node_t * vlib_get_node(vlib_main_t *vm, u32 i)
Get vlib node by index.
Definition: node_funcs.h:59
u16 dst_port
Definition: udp.api:42
static void * sparse_vec_new(uword elt_bytes, uword sparse_index_bits)
Definition: sparse_vec.h:71
#define BITS(x)
Definition: clib.h:61
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
Definition: buffer_funcs.h:85
Definition: pg.h:307
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:972
#define udp_local_next_drop(is_ip4)
Definition: udp_local.c:40
#define SPARSE_VEC_INVALID_INDEX
Definition: sparse_vec.h:68