FD.io VPP  v20.01-48-g3e0dafb74
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 typedef enum
25 {
31 
32 typedef struct
33 {
38 
39 #define UDP_NO_NODE_SET ((u16) ~0)
40 
41 #ifndef CLIB_MARCH_VARIANT
42 u8 *
43 format_udp_rx_trace (u8 * s, va_list * args)
44 {
45  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
46  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
47  udp_local_rx_trace_t *t = va_arg (*args, udp_local_rx_trace_t *);
48 
49  s = format (s, "UDP: src-port %d dst-port %d%s",
50  clib_net_to_host_u16 (t->src_port),
51  clib_net_to_host_u16 (t->dst_port),
52  t->bound ? "" : " (no listener)");
53  return s;
54 }
55 #endif /* CLIB_MARCH_VARIANT */
56 
60  vlib_frame_t * from_frame, int is_ip4)
61 {
62  udp_main_t *um = &udp_main;
63  __attribute__ ((unused)) u32 n_left_from, next_index, *from, *to_next;
64  word n_no_listener = 0;
65  u8 punt_unknown = is_ip4 ? um->punt_unknown4 : um->punt_unknown6;
66  u16 *next_by_dst_port = (is_ip4 ?
68  from = vlib_frame_vector_args (from_frame);
69  n_left_from = from_frame->n_vectors;
70 
71  next_index = node->cached_next_index;
72 
73  while (n_left_from > 0)
74  {
75  u32 n_left_to_next;
76 
77  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
78 
79  while (n_left_from >= 4 && n_left_to_next >= 2)
80  {
81  u32 bi0, bi1;
82  vlib_buffer_t *b0, *b1;
83  udp_header_t *h0 = 0, *h1 = 0;
84  u32 i0, i1, dst_port0, dst_port1;
85  u32 advance0, advance1;
86  u32 error0, next0, error1, next1;
87 
88  /* Prefetch next iteration. */
89  {
90  vlib_buffer_t *p2, *p3;
91 
92  p2 = vlib_get_buffer (vm, from[2]);
93  p3 = vlib_get_buffer (vm, from[3]);
94 
95  vlib_prefetch_buffer_header (p2, LOAD);
96  vlib_prefetch_buffer_header (p3, LOAD);
97 
98  CLIB_PREFETCH (p2->data, sizeof (h0[0]), LOAD);
99  CLIB_PREFETCH (p3->data, sizeof (h1[0]), LOAD);
100  }
101 
102  bi0 = from[0];
103  bi1 = from[1];
104  to_next[0] = bi0;
105  to_next[1] = bi1;
106  from += 2;
107  to_next += 2;
108  n_left_to_next -= 2;
109  n_left_from -= 2;
110 
111  b0 = vlib_get_buffer (vm, bi0);
112  b1 = vlib_get_buffer (vm, bi1);
113 
114  /* ip4/6_local hands us the ip header, not the udp header */
115  if (is_ip4)
116  {
117  advance0 = sizeof (ip4_header_t);
118  advance1 = sizeof (ip4_header_t);
119  }
120  else
121  {
122  advance0 = sizeof (ip6_header_t);
123  advance1 = sizeof (ip6_header_t);
124  }
125 
126  if (PREDICT_FALSE (b0->current_length < advance0 + sizeof (*h0)))
127  {
128  error0 = UDP_ERROR_LENGTH_ERROR;
129  next0 = UDP_LOCAL_NEXT_DROP;
130  }
131  else
132  {
133  vlib_buffer_advance (b0, advance0);
134  h0 = vlib_buffer_get_current (b0);
135  error0 = UDP_ERROR_NONE;
136  next0 = UDP_LOCAL_NEXT_PUNT;
137  if (PREDICT_FALSE (clib_net_to_host_u16 (h0->length) >
138  vlib_buffer_length_in_chain (vm, b0)))
139  {
140  error0 = UDP_ERROR_LENGTH_ERROR;
141  next0 = UDP_LOCAL_NEXT_DROP;
142  }
143  }
144 
145  if (PREDICT_FALSE (b1->current_length < advance1 + sizeof (*h1)))
146  {
147  error1 = UDP_ERROR_LENGTH_ERROR;
148  next1 = UDP_LOCAL_NEXT_DROP;
149  }
150  else
151  {
152  vlib_buffer_advance (b1, advance1);
153  h1 = vlib_buffer_get_current (b1);
154  error1 = UDP_ERROR_NONE;
155  next1 = UDP_LOCAL_NEXT_PUNT;
156  if (PREDICT_FALSE (clib_net_to_host_u16 (h1->length) >
157  vlib_buffer_length_in_chain (vm, b1)))
158  {
159  error1 = UDP_ERROR_LENGTH_ERROR;
160  next1 = UDP_LOCAL_NEXT_DROP;
161  }
162  }
163 
164  /* Index sparse array with network byte order. */
165  dst_port0 = (error0 == 0) ? h0->dst_port : 0;
166  dst_port1 = (error1 == 0) ? h1->dst_port : 0;
167  sparse_vec_index2 (next_by_dst_port, dst_port0, dst_port1, &i0,
168  &i1);
169  next0 = (error0 == 0) ? vec_elt (next_by_dst_port, i0) : next0;
170  next1 = (error1 == 0) ? vec_elt (next_by_dst_port, i1) : next1;
171 
173  next0 == UDP_NO_NODE_SET))
174  {
175  // move the pointer back so icmp-error can find the
176  // ip packet header
177  vlib_buffer_advance (b0, -(word) advance0);
178 
179  if (PREDICT_FALSE (punt_unknown))
180  {
181  b0->error = node->errors[UDP_ERROR_PUNT];
182  next0 = UDP_LOCAL_NEXT_PUNT;
183  }
184  else if (is_ip4)
185  {
187  ICMP4_destination_unreachable,
188  ICMP4_destination_unreachable_port_unreachable,
189  0);
190  next0 = UDP_LOCAL_NEXT_ICMP;
191  n_no_listener++;
192  }
193  else
194  {
196  ICMP6_destination_unreachable,
197  ICMP6_destination_unreachable_port_unreachable,
198  0);
199  next0 = UDP_LOCAL_NEXT_ICMP;
200  n_no_listener++;
201  }
202  }
203  else
204  {
205  b0->error = node->errors[UDP_ERROR_NONE];
206  // advance to the payload
207  vlib_buffer_advance (b0, sizeof (*h0));
208  }
209 
211  next1 == UDP_NO_NODE_SET))
212  {
213  // move the pointer back so icmp-error can find the
214  // ip packet header
215  vlib_buffer_advance (b1, -(word) advance1);
216 
217  if (PREDICT_FALSE (punt_unknown))
218  {
219  b1->error = node->errors[UDP_ERROR_PUNT];
220  next1 = UDP_LOCAL_NEXT_PUNT;
221  }
222  else if (is_ip4)
223  {
225  ICMP4_destination_unreachable,
226  ICMP4_destination_unreachable_port_unreachable,
227  0);
228  next1 = UDP_LOCAL_NEXT_ICMP;
229  n_no_listener++;
230  }
231  else
232  {
234  ICMP6_destination_unreachable,
235  ICMP6_destination_unreachable_port_unreachable,
236  0);
237  next1 = UDP_LOCAL_NEXT_ICMP;
238  n_no_listener++;
239  }
240  }
241  else
242  {
243  b1->error = node->errors[UDP_ERROR_NONE];
244  // advance to the payload
245  vlib_buffer_advance (b1, sizeof (*h1));
246  }
247 
248  if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
249  {
250  udp_local_rx_trace_t *tr = vlib_add_trace (vm, node,
251  b0, sizeof (*tr));
252  if (b0->error != node->errors[UDP_ERROR_LENGTH_ERROR])
253  {
254  tr->src_port = h0 ? h0->src_port : 0;
255  tr->dst_port = h0 ? h0->dst_port : 0;
256  tr->bound = (next0 != UDP_LOCAL_NEXT_ICMP);
257  }
258  }
259  if (PREDICT_FALSE (b1->flags & VLIB_BUFFER_IS_TRACED))
260  {
261  udp_local_rx_trace_t *tr = vlib_add_trace (vm, node,
262  b1, sizeof (*tr));
263  if (b1->error != node->errors[UDP_ERROR_LENGTH_ERROR])
264  {
265  tr->src_port = h1 ? h1->src_port : 0;
266  tr->dst_port = h1 ? h1->dst_port : 0;
267  tr->bound = (next1 != UDP_LOCAL_NEXT_ICMP);
268  }
269  }
270 
271  vlib_validate_buffer_enqueue_x2 (vm, node, next_index,
272  to_next, n_left_to_next,
273  bi0, bi1, next0, next1);
274  }
275 
276  while (n_left_from > 0 && n_left_to_next > 0)
277  {
278  u32 bi0;
279  vlib_buffer_t *b0;
280  udp_header_t *h0 = 0;
281  u32 i0, next0;
282  u32 advance0;
283 
284  bi0 = from[0];
285  to_next[0] = bi0;
286  from += 1;
287  to_next += 1;
288  n_left_from -= 1;
289  n_left_to_next -= 1;
290 
291  b0 = vlib_get_buffer (vm, bi0);
292 
293  /* ip4/6_local hands us the ip header, not the udp header */
294  if (is_ip4)
295  advance0 = sizeof (ip4_header_t);
296  else
297  advance0 = sizeof (ip6_header_t);
298 
299  if (PREDICT_FALSE (b0->current_length < advance0 + sizeof (*h0)))
300  {
301  b0->error = node->errors[UDP_ERROR_LENGTH_ERROR];
302  next0 = UDP_LOCAL_NEXT_DROP;
303  goto trace_x1;
304  }
305 
306  vlib_buffer_advance (b0, advance0);
307 
308  h0 = vlib_buffer_get_current (b0);
309 
310  if (PREDICT_TRUE (clib_net_to_host_u16 (h0->length) <=
311  vlib_buffer_length_in_chain (vm, b0)))
312  {
313  i0 = sparse_vec_index (next_by_dst_port, h0->dst_port);
314  next0 = vec_elt (next_by_dst_port, i0);
315 
317  next0 == UDP_NO_NODE_SET))
318  {
319  // move the pointer back so icmp-error can find the
320  // ip packet header
321  vlib_buffer_advance (b0, -(word) advance0);
322 
323  if (PREDICT_FALSE (punt_unknown))
324  {
325  b0->error = node->errors[UDP_ERROR_PUNT];
326  next0 = UDP_LOCAL_NEXT_PUNT;
327  }
328  else if (is_ip4)
329  {
331  ICMP4_destination_unreachable,
332  ICMP4_destination_unreachable_port_unreachable,
333  0);
334  next0 = UDP_LOCAL_NEXT_ICMP;
335  n_no_listener++;
336  }
337  else
338  {
340  ICMP6_destination_unreachable,
341  ICMP6_destination_unreachable_port_unreachable,
342  0);
343  next0 = UDP_LOCAL_NEXT_ICMP;
344  n_no_listener++;
345  }
346  }
347  else
348  {
349  b0->error = node->errors[UDP_ERROR_NONE];
350  // advance to the payload
351  vlib_buffer_advance (b0, sizeof (*h0));
352  }
353  }
354  else
355  {
356  b0->error = node->errors[UDP_ERROR_LENGTH_ERROR];
357  next0 = UDP_LOCAL_NEXT_DROP;
358  }
359 
360  trace_x1:
361  if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
362  {
363  udp_local_rx_trace_t *tr = vlib_add_trace (vm, node,
364  b0, sizeof (*tr));
365  if (b0->error != node->errors[UDP_ERROR_LENGTH_ERROR])
366  {
367  tr->src_port = h0->src_port;
368  tr->dst_port = h0->dst_port;
369  tr->bound = (next0 != UDP_LOCAL_NEXT_ICMP);
370  }
371  }
372 
373  vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
374  to_next, n_left_to_next,
375  bi0, next0);
376  }
377 
378  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
379  }
380  vlib_error_count (vm, node->node_index, UDP_ERROR_NO_LISTENER,
381  n_no_listener);
382  return from_frame->n_vectors;
383 }
384 
385 static char *udp_error_strings[] = {
386 #define udp_error(n,s) s,
387 #include "udp_error.def"
388 #undef udp_error
389 };
390 
393  vlib_frame_t * from_frame)
394 {
395  return udp46_local_inline (vm, node, from_frame, 1 /* is_ip4 */ );
396 }
397 
400  vlib_frame_t * from_frame)
401 {
402  return udp46_local_inline (vm, node, from_frame, 0 /* is_ip4 */ );
403 }
404 
405 /* *INDENT-OFF* */
407  .name = "ip4-udp-lookup",
408  /* Takes a vector of packets. */
409  .vector_size = sizeof (u32),
410 
411  .n_errors = UDP_N_ERROR,
412  .error_strings = udp_error_strings,
413 
414  .n_next_nodes = UDP_LOCAL_N_NEXT,
415  .next_nodes = {
416  [UDP_LOCAL_NEXT_PUNT]= "ip4-punt",
417  [UDP_LOCAL_NEXT_DROP]= "ip4-drop",
418  [UDP_LOCAL_NEXT_ICMP]= "ip4-icmp-error",
419  },
420 
421  .format_buffer = format_udp_header,
422  .format_trace = format_udp_rx_trace,
423  .unformat_buffer = unformat_udp_header,
424 };
425 /* *INDENT-ON* */
426 
427 /* *INDENT-OFF* */
429  .name = "ip6-udp-lookup",
430  /* Takes a vector of packets. */
431  .vector_size = sizeof (u32),
432 
433  .n_errors = UDP_N_ERROR,
434  .error_strings = udp_error_strings,
435 
436  .n_next_nodes = UDP_LOCAL_N_NEXT,
437  .next_nodes = {
438  [UDP_LOCAL_NEXT_PUNT]= "ip6-punt",
439  [UDP_LOCAL_NEXT_DROP]= "ip6-drop",
440  [UDP_LOCAL_NEXT_ICMP]= "ip6-icmp-error",
441  },
442 
443  .format_buffer = format_udp_header,
444  .format_trace = format_udp_rx_trace,
445  .unformat_buffer = unformat_udp_header,
446 };
447 /* *INDENT-ON* */
448 
449 #ifndef CLIB_MARCH_VARIANT
450 static void
452  udp_dst_port_t dst_port, char *dst_port_name, u8 is_ip4)
453 {
455  u32 i;
456 
457  vec_add2 (um->dst_port_infos[is_ip4], pi, 1);
458  i = pi - um->dst_port_infos[is_ip4];
459 
460  pi->name = dst_port_name;
461  pi->dst_port = dst_port;
462  pi->next_index = pi->node_index = ~0;
463 
464  hash_set (um->dst_port_info_by_dst_port[is_ip4], dst_port, i);
465 
466  if (pi->name)
467  hash_set_mem (um->dst_port_info_by_name[is_ip4], pi->name, i);
468 }
469 
470 void
472  udp_dst_port_t dst_port, u32 node_index, u8 is_ip4)
473 {
474  udp_main_t *um = &udp_main;
476  u16 *n;
477 
478  {
480  if (error)
481  clib_error_report (error);
482  }
483 
484  pi = udp_get_dst_port_info (um, dst_port, is_ip4);
485  if (!pi)
486  {
487  add_dst_port (um, dst_port, 0, is_ip4);
488  pi = udp_get_dst_port_info (um, dst_port, is_ip4);
489  ASSERT (pi);
490  }
491 
492  pi->node_index = node_index;
493  pi->next_index = vlib_node_add_next (vm,
494  is_ip4 ? udp4_local_node.index
495  : udp6_local_node.index, node_index);
496 
497  /* Setup udp protocol -> next index sparse vector mapping. */
498  if (is_ip4)
500  clib_host_to_net_u16 (dst_port));
501  else
503  clib_host_to_net_u16 (dst_port));
504 
505  n[0] = pi->next_index;
506 }
507 
508 void
510 {
511  udp_main_t *um = &udp_main;
513  u16 *n;
514 
515  pi = udp_get_dst_port_info (um, dst_port, is_ip4);
516  /* Not registered? Fagedaboudit */
517  if (!pi)
518  return;
519 
520  /* Kill the mapping. Don't bother killing the pi, it may be back. */
521  if (is_ip4)
523  clib_host_to_net_u16 (dst_port));
524  else
526  clib_host_to_net_u16 (dst_port));
527 
528  n[0] = UDP_NO_NODE_SET;
529 }
530 
531 bool
533 {
534  udp_main_t *um = &udp_main;
535  u16 *n;
536 
537  if (is_ip4)
539  clib_host_to_net_u16 (dst_port));
540  else
542  clib_host_to_net_u16 (dst_port));
543 
544  return (n[0] != SPARSE_VEC_INVALID_INDEX && n[0] != UDP_NO_NODE_SET);
545 }
546 
547 void
549 {
550  udp_main_t *um = &udp_main;
551  {
553  if (error)
554  clib_error_report (error);
555  }
556 
557  if (is_ip4)
558  um->punt_unknown4 = is_add;
559  else
560  um->punt_unknown6 = is_add;
561 }
562 
563 /* Parse a UDP header. */
564 uword
565 unformat_udp_header (unformat_input_t * input, va_list * args)
566 {
567  u8 **result = va_arg (*args, u8 **);
568  udp_header_t *udp;
569  __attribute__ ((unused)) int old_length;
571 
572  /* Allocate space for IP header. */
573  {
574  void *p;
575 
576  old_length = vec_len (*result);
577  vec_add2 (*result, p, sizeof (ip4_header_t));
578  udp = p;
579  }
580 
581  clib_memset (udp, 0, sizeof (udp[0]));
582  if (unformat (input, "src-port %d dst-port %d", &src_port, &dst_port))
583  {
584  udp->src_port = clib_host_to_net_u16 (src_port);
585  udp->dst_port = clib_host_to_net_u16 (dst_port);
586  return 1;
587  }
588  return 0;
589 }
590 
591 static void
592 udp_setup_node (vlib_main_t * vm, u32 node_index)
593 {
594  vlib_node_t *n = vlib_get_node (vm, node_index);
595  pg_node_t *pn = pg_get_node (node_index);
596 
600 }
601 
602 clib_error_t *
604 {
605  udp_main_t *um = &udp_main;
606  int i;
607 
608  {
609  clib_error_t *error;
610  error = vlib_call_init_function (vm, udp_init);
611  if (error)
612  clib_error_report (error);
613  }
614 
615 
616  for (i = 0; i < 2; i++)
617  {
618  um->dst_port_info_by_name[i] = hash_create_string (0, sizeof (uword));
619  um->dst_port_info_by_dst_port[i] = hash_create (0, sizeof (uword));
620  }
621 
622  udp_setup_node (vm, udp4_local_node.index);
623  udp_setup_node (vm, udp6_local_node.index);
624 
625  um->punt_unknown4 = 0;
626  um->punt_unknown6 = 0;
627 
629  ( /* elt bytes */ sizeof (um->next_by_dst_port4[0]),
630  /* bits in index */ BITS (((udp_header_t *) 0)->dst_port));
631 
633  ( /* elt bytes */ sizeof (um->next_by_dst_port6[0]),
634  /* bits in index */ BITS (((udp_header_t *) 0)->dst_port));
635 
636 #define _(n,s) add_dst_port (um, UDP_DST_PORT_##s, #s, 1 /* is_ip4 */);
638 #undef _
639 #define _(n,s) add_dst_port (um, UDP_DST_PORT_##s, #s, 0 /* is_ip4 */);
641 #undef _
642  ip4_register_protocol (IP_PROTOCOL_UDP, udp4_local_node.index);
643  /* Note: ip6 differs from ip4, UDP is hotwired to ip6-udp-lookup */
644  return 0;
645 }
646 
648 #endif /* CLIB_MARCH_VARIANT */
649 
650 /*
651  * fd.io coding-style-patch-verification: ON
652  *
653  * Local Variables:
654  * eval: (c-set-style "gnu")
655  * End:
656  */
void udp_unregister_dst_port(vlib_main_t *vm, udp_dst_port_t dst_port, u8 is_ip4)
Definition: udp_local.c:509
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:532
#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:140
format_function_t format_udp_header
Definition: format.h:100
clib_error_t * udp_local_init(vlib_main_t *vm)
Definition: udp_local.c:603
static char * udp_error_strings[]
Definition: udp_local.c:385
#define UDP_NO_NODE_SET
Definition: udp_local.c:39
#define PREDICT_TRUE(x)
Definition: clib.h:112
uword * dst_port_info_by_dst_port[N_UDP_AF]
Definition: udp.h:135
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:428
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:24
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:561
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:471
#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:250
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
#define VLIB_NODE_FN(node)
Definition: node.h:202
u8 punt_unknown6
Definition: udp.h:142
void ip4_register_protocol(u32 protocol, u32 node_index)
Definition: ip4_forward.c:1866
vlib_error_t * errors
Vector of errors for this node.
Definition: node.h:470
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:451
static pg_node_t * pg_get_node(uword node_index)
Definition: pg.h:363
u16 src_port
Definition: udp.api:41
i64 word
Definition: types.h:111
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:173
vlib_node_registration_t udp6_local_node
(constructor) VLIB_REGISTER_NODE (udp6_local_node)
Definition: udp_local.c:428
u8 punt_unknown4
Definition: udp.h:141
#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:270
#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:139
udp_dst_port_info_t * dst_port_infos[N_UDP_AF]
Definition: udp.h:131
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:58
uword * dst_port_info_by_name[N_UDP_AF]
Definition: udp.h:134
#define PREDICT_FALSE(x)
Definition: clib.h:111
#define always_inline
Definition: ipsec.h:28
format_function_t * format_buffer
Definition: node.h:358
u32 node_index
Node index.
Definition: node.h:496
#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
vlib_main_t * vm
Definition: in2out_ed.c:1810
static void udp_setup_node(vlib_main_t *vm, u32 node_index)
Definition: udp_local.c:592
u8 is_ip4
Definition: lisp_gpe.api:232
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:169
u16 n_vectors
Definition: node.h:397
#define CLIB_PREFETCH(addr, size, type)
Definition: cache.h:80
unformat_function_t unformat_pg_udp_header
Definition: format.h:102
unformat_function_t * unformat_buffer
Definition: node.h:359
unformat_function_t * unformat_edit
Definition: pg.h:315
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:456
void udp_punt_unknown(vlib_main_t *vm, u8 is_ip4, u8 is_add)
Definition: udp_local.c:548
vlib_main_t vlib_node_runtime_t * node
Definition: in2out_ed.c:1810
udp_dst_port_t
Definition: udp.h:90
vlib_node_registration_t udp4_local_node
(constructor) VLIB_REGISTER_NODE (udp4_local_node)
Definition: udp_local.c:406
#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:515
#define foreach_udp4_dst_port
Definition: udp.h:53
#define ASSERT(truth)
udp_dst_port_t dst_port
Definition: udp.h:110
char * name
Definition: udp.h:107
#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:55
#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:565
u8 * format_udp_rx_trace(u8 *s, va_list *args)
Definition: udp_local.c:43
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_always_inline void icmp4_error_set_vnet_buffer(vlib_buffer_t *b, u8 type, u8 code, u32 data)
Definition: icmp4.h:51
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:312
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:978
#define SPARSE_VEC_INVALID_INDEX
Definition: sparse_vec.h:68