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