FD.io VPP  v17.04-9-g99c0734
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_input_next \
27  _ (PUNT, "error-punt") \
28  _ (DROP, "error-drop") \
29  _ (ICMP4_ERROR, "ip4-icmp-error") \
30  _ (ICMP6_ERROR, "ip6-icmp-error")
31 
32 typedef enum
33 {
34 #define _(s,n) UDP_INPUT_NEXT_##s,
36 #undef _
39 
40 typedef struct
41 {
46 
47 u8 *
48 format_udp_rx_trace (u8 * s, va_list * args)
49 {
50  CLIB_UNUSED (vlib_main_t * vm) = va_arg (*args, vlib_main_t *);
51  CLIB_UNUSED (vlib_node_t * node) = va_arg (*args, vlib_node_t *);
52  udp_rx_trace_t *t = va_arg (*args, udp_rx_trace_t *);
53 
54  s = format (s, "UDP: src-port %d dst-port %d%s",
55  clib_net_to_host_u16 (t->src_port),
56  clib_net_to_host_u16 (t->dst_port),
57  t->bound ? "" : " (no listener)");
58  return s;
59 }
60 
63 
66  vlib_node_runtime_t * node,
67  vlib_frame_t * from_frame, int is_ip4)
68 {
69  udp_main_t *um = &udp_main;
70  __attribute__ ((unused)) u32 n_left_from, next_index, *from, *to_next;
71  word n_no_listener = 0;
72  u8 punt_unknown = is_ip4 ? um->punt_unknown4 : um->punt_unknown6;
73 
74  from = vlib_frame_vector_args (from_frame);
75  n_left_from = from_frame->n_vectors;
76 
77  next_index = node->cached_next_index;
78 
79  while (n_left_from > 0)
80  {
81  u32 n_left_to_next;
82 
83  vlib_get_next_frame (vm, node, next_index, to_next, n_left_to_next);
84 
85  while (n_left_from >= 4 && n_left_to_next >= 2)
86  {
87  u32 bi0, bi1;
88  vlib_buffer_t *b0, *b1;
89  udp_header_t *h0 = 0, *h1 = 0;
90  u32 i0, i1, dst_port0, dst_port1;
91  u32 advance0, advance1;
92  u32 error0, next0, error1, next1;
93 
94  /* Prefetch next iteration. */
95  {
96  vlib_buffer_t *p2, *p3;
97 
98  p2 = vlib_get_buffer (vm, from[2]);
99  p3 = vlib_get_buffer (vm, from[3]);
100 
101  vlib_prefetch_buffer_header (p2, LOAD);
102  vlib_prefetch_buffer_header (p3, LOAD);
103 
104  CLIB_PREFETCH (p2->data, sizeof (h0[0]), LOAD);
105  CLIB_PREFETCH (p3->data, sizeof (h1[0]), LOAD);
106  }
107 
108  bi0 = from[0];
109  bi1 = from[1];
110  to_next[0] = bi0;
111  to_next[1] = bi1;
112  from += 2;
113  to_next += 2;
114  n_left_to_next -= 2;
115  n_left_from -= 2;
116 
117  b0 = vlib_get_buffer (vm, bi0);
118  b1 = vlib_get_buffer (vm, bi1);
119 
120  /* ip4/6_local hands us the ip header, not the udp header */
121  if (is_ip4)
122  {
123  advance0 = sizeof (ip4_header_t);
124  advance1 = sizeof (ip4_header_t);
125  }
126  else
127  {
128  advance0 = sizeof (ip6_header_t);
129  advance1 = sizeof (ip6_header_t);
130  }
131 
132  if (PREDICT_FALSE (b0->current_length < advance0 + sizeof (*h0)))
133  {
134  error0 = UDP_ERROR_LENGTH_ERROR;
135  next0 = UDP_INPUT_NEXT_DROP;
136  }
137  else
138  {
139  vlib_buffer_advance (b0, advance0);
140  h0 = vlib_buffer_get_current (b0);
141  error0 = next0 = 0;
142  if (PREDICT_FALSE (clib_net_to_host_u16 (h0->length) >
143  vlib_buffer_length_in_chain (vm, b0)))
144  {
145  error0 = UDP_ERROR_LENGTH_ERROR;
146  next0 = UDP_INPUT_NEXT_DROP;
147  }
148  }
149 
150  if (PREDICT_FALSE (b1->current_length < advance1 + sizeof (*h1)))
151  {
152  error1 = UDP_ERROR_LENGTH_ERROR;
153  next1 = UDP_INPUT_NEXT_DROP;
154  }
155  else
156  {
157  vlib_buffer_advance (b1, advance1);
158  h1 = vlib_buffer_get_current (b1);
159  error1 = next1 = 0;
160  if (PREDICT_FALSE (clib_net_to_host_u16 (h1->length) >
161  vlib_buffer_length_in_chain (vm, b1)))
162  {
163  error1 = UDP_ERROR_LENGTH_ERROR;
164  next1 = UDP_INPUT_NEXT_DROP;
165  }
166  }
167 
168  /* Index sparse array with network byte order. */
169  dst_port0 = (error0 == 0) ? h0->dst_port : 0;
170  dst_port1 = (error1 == 0) ? h1->dst_port : 0;
171  sparse_vec_index2 (is_ip4 ? um->next_by_dst_port4 :
172  um->next_by_dst_port6,
173  dst_port0, dst_port1, &i0, &i1);
174  next0 = (error0 == 0) ?
175  vec_elt (is_ip4 ? um->next_by_dst_port4 : um->next_by_dst_port6,
176  i0) : next0;
177  next1 = (error1 == 0) ?
178  vec_elt (is_ip4 ? um->next_by_dst_port4 : um->next_by_dst_port6,
179  i1) : next1;
180 
182  {
183  // move the pointer back so icmp-error can find the
184  // ip packet header
185  vlib_buffer_advance (b0, -(word) advance0);
186 
187  if (PREDICT_FALSE (punt_unknown))
188  {
189  b0->error = node->errors[UDP_ERROR_PUNT];
190  next0 = UDP_INPUT_NEXT_PUNT;
191  }
192  else if (is_ip4)
193  {
195  ICMP4_destination_unreachable,
196  ICMP4_destination_unreachable_port_unreachable,
197  0);
198  next0 = UDP_INPUT_NEXT_ICMP4_ERROR;
199  n_no_listener++;
200  }
201  else
202  {
204  ICMP6_destination_unreachable,
205  ICMP6_destination_unreachable_port_unreachable,
206  0);
207  next0 = UDP_INPUT_NEXT_ICMP6_ERROR;
208  n_no_listener++;
209  }
210  }
211  else
212  {
213  b0->error = node->errors[UDP_ERROR_NONE];
214  // advance to the payload
215  vlib_buffer_advance (b0, sizeof (*h0));
216  }
217 
219  {
220  // move the pointer back so icmp-error can find the
221  // ip packet header
222  vlib_buffer_advance (b1, -(word) advance1);
223 
224  if (PREDICT_FALSE (punt_unknown))
225  {
226  b1->error = node->errors[UDP_ERROR_PUNT];
227  next1 = UDP_INPUT_NEXT_PUNT;
228  }
229  else if (is_ip4)
230  {
232  ICMP4_destination_unreachable,
233  ICMP4_destination_unreachable_port_unreachable,
234  0);
235  next1 = UDP_INPUT_NEXT_ICMP4_ERROR;
236  n_no_listener++;
237  }
238  else
239  {
241  ICMP6_destination_unreachable,
242  ICMP6_destination_unreachable_port_unreachable,
243  0);
244  next1 = UDP_INPUT_NEXT_ICMP6_ERROR;
245  n_no_listener++;
246  }
247  }
248  else
249  {
250  b1->error = node->errors[UDP_ERROR_NONE];
251  // advance to the payload
252  vlib_buffer_advance (b1, sizeof (*h1));
253  }
254 
256  {
257  udp_rx_trace_t *tr = vlib_add_trace (vm, node,
258  b0, sizeof (*tr));
259  if (b0->error != node->errors[UDP_ERROR_LENGTH_ERROR])
260  {
261  tr->src_port = h0 ? h0->src_port : 0;
262  tr->dst_port = h0 ? h0->dst_port : 0;
263  tr->bound = (next0 != UDP_INPUT_NEXT_ICMP4_ERROR &&
264  next0 != UDP_INPUT_NEXT_ICMP6_ERROR);
265  }
266  }
268  {
269  udp_rx_trace_t *tr = vlib_add_trace (vm, node,
270  b1, sizeof (*tr));
271  if (b1->error != node->errors[UDP_ERROR_LENGTH_ERROR])
272  {
273  tr->src_port = h1 ? h1->src_port : 0;
274  tr->dst_port = h1 ? h1->dst_port : 0;
275  tr->bound = (next1 != UDP_INPUT_NEXT_ICMP4_ERROR &&
276  next1 != UDP_INPUT_NEXT_ICMP6_ERROR);
277  }
278  }
279 
280  vlib_validate_buffer_enqueue_x2 (vm, node, next_index,
281  to_next, n_left_to_next,
282  bi0, bi1, next0, next1);
283  }
284 
285  while (n_left_from > 0 && n_left_to_next > 0)
286  {
287  u32 bi0;
288  vlib_buffer_t *b0;
289  udp_header_t *h0 = 0;
290  u32 i0, next0;
291  u32 advance0;
292 
293  bi0 = from[0];
294  to_next[0] = bi0;
295  from += 1;
296  to_next += 1;
297  n_left_from -= 1;
298  n_left_to_next -= 1;
299 
300  b0 = vlib_get_buffer (vm, bi0);
301 
302  /* ip4/6_local hands us the ip header, not the udp header */
303  if (is_ip4)
304  advance0 = sizeof (ip4_header_t);
305  else
306  advance0 = sizeof (ip6_header_t);
307 
308  if (PREDICT_FALSE (b0->current_length < advance0 + sizeof (*h0)))
309  {
310  b0->error = node->errors[UDP_ERROR_LENGTH_ERROR];
311  next0 = UDP_INPUT_NEXT_DROP;
312  goto trace_x1;
313  }
314 
315  vlib_buffer_advance (b0, advance0);
316 
317  h0 = vlib_buffer_get_current (b0);
318 
319  if (PREDICT_TRUE (clib_net_to_host_u16 (h0->length) <=
320  vlib_buffer_length_in_chain (vm, b0)))
321  {
322  i0 = sparse_vec_index (is_ip4 ? um->next_by_dst_port4 :
323  um->next_by_dst_port6, h0->dst_port);
324  next0 = vec_elt (is_ip4 ? um->next_by_dst_port4 :
325  um->next_by_dst_port6, i0);
326 
328  {
329  // move the pointer back so icmp-error can find the
330  // ip packet header
331  vlib_buffer_advance (b0, -(word) advance0);
332 
333  if (PREDICT_FALSE (punt_unknown))
334  {
335  b0->error = node->errors[UDP_ERROR_PUNT];
336  next0 = UDP_INPUT_NEXT_PUNT;
337  }
338  else if (is_ip4)
339  {
341  ICMP4_destination_unreachable,
342  ICMP4_destination_unreachable_port_unreachable,
343  0);
344  next0 = UDP_INPUT_NEXT_ICMP4_ERROR;
345  n_no_listener++;
346  }
347  else
348  {
350  ICMP6_destination_unreachable,
351  ICMP6_destination_unreachable_port_unreachable,
352  0);
353  next0 = UDP_INPUT_NEXT_ICMP6_ERROR;
354  n_no_listener++;
355  }
356  }
357  else
358  {
359  b0->error = node->errors[UDP_ERROR_NONE];
360  // advance to the payload
361  vlib_buffer_advance (b0, sizeof (*h0));
362  }
363  }
364  else
365  {
366  b0->error = node->errors[UDP_ERROR_LENGTH_ERROR];
367  next0 = UDP_INPUT_NEXT_DROP;
368  }
369 
370  trace_x1:
372  {
373  udp_rx_trace_t *tr = vlib_add_trace (vm, node,
374  b0, sizeof (*tr));
375  if (b0->error != node->errors[UDP_ERROR_LENGTH_ERROR])
376  {
377  tr->src_port = h0->src_port;
378  tr->dst_port = h0->dst_port;
379  tr->bound = (next0 != UDP_INPUT_NEXT_ICMP4_ERROR &&
380  next0 != UDP_INPUT_NEXT_ICMP6_ERROR);
381  }
382  }
383 
384  vlib_validate_buffer_enqueue_x1 (vm, node, next_index,
385  to_next, n_left_to_next,
386  bi0, next0);
387  }
388 
389  vlib_put_next_frame (vm, node, next_index, n_left_to_next);
390  }
391  vlib_error_count (vm, node->node_index, UDP_ERROR_NO_LISTENER,
392  n_no_listener);
393  return from_frame->n_vectors;
394 }
395 
396 static char *udp_error_strings[] = {
397 #define udp_error(n,s) s,
398 #include "udp_error.def"
399 #undef udp_error
400 };
401 
402 static uword
404  vlib_node_runtime_t * node, vlib_frame_t * from_frame)
405 {
406  return udp46_input_inline (vm, node, from_frame, 1 /* is_ip4 */ );
407 }
408 
409 static uword
411  vlib_node_runtime_t * node, vlib_frame_t * from_frame)
412 {
413  return udp46_input_inline (vm, node, from_frame, 0 /* is_ip4 */ );
414 }
415 
416 
417 /* *INDENT-OFF* */
419  .function = udp4_input,
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_INPUT_N_NEXT,
428  .next_nodes = {
429 #define _(s,n) [UDP_INPUT_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 
441 
442 /* *INDENT-OFF* */
444  .function = udp6_input,
445  .name = "ip6-udp-lookup",
446  /* Takes a vector of packets. */
447  .vector_size = sizeof (u32),
448 
449  .n_errors = UDP_N_ERROR,
450  .error_strings = udp_error_strings,
451 
452  .n_next_nodes = UDP_INPUT_N_NEXT,
453  .next_nodes = {
454 #define _(s,n) [UDP_INPUT_NEXT_##s] = n,
456 #undef _
457  },
458 
459  .format_buffer = format_udp_header,
460  .format_trace = format_udp_rx_trace,
461  .unformat_buffer = unformat_udp_header,
462 };
463 /* *INDENT-ON* */
464 
466 
467 static void
469  udp_dst_port_t dst_port, char *dst_port_name, u8 is_ip4)
470 {
472  u32 i;
473 
474  vec_add2 (um->dst_port_infos[is_ip4], pi, 1);
475  i = pi - um->dst_port_infos[is_ip4];
476 
477  pi->name = dst_port_name;
478  pi->dst_port = dst_port;
479  pi->next_index = pi->node_index = ~0;
480 
481  hash_set (um->dst_port_info_by_dst_port[is_ip4], dst_port, i);
482 
483  if (pi->name)
484  hash_set_mem (um->dst_port_info_by_name[is_ip4], pi->name, i);
485 }
486 
487 void
489  udp_dst_port_t dst_port, u32 node_index, u8 is_ip4)
490 {
491  udp_main_t *um = &udp_main;
493  u16 *n;
494 
495  {
497  if (error)
498  clib_error_report (error);
499  }
500 
501  pi = udp_get_dst_port_info (um, dst_port, is_ip4);
502  if (!pi)
503  {
504  add_dst_port (um, dst_port, 0, is_ip4);
505  pi = udp_get_dst_port_info (um, dst_port, is_ip4);
506  ASSERT (pi);
507  }
508 
509  pi->node_index = node_index;
510  pi->next_index = vlib_node_add_next (vm,
511  is_ip4 ? udp4_input_node.index
512  : udp6_input_node.index, node_index);
513 
514  /* Setup udp protocol -> next index sparse vector mapping. */
515  if (is_ip4)
517  clib_host_to_net_u16 (dst_port));
518  else
520  clib_host_to_net_u16 (dst_port));
521 
522  n[0] = pi->next_index;
523 }
524 
525 void
527 {
528  udp_main_t *um = &udp_main;
530  u16 *n;
531 
532  pi = udp_get_dst_port_info (um, dst_port, is_ip4);
533  /* Not registered? Fagedaboudit */
534  if (!pi)
535  return;
536 
537  /* Kill the mapping. Don't bother killing the pi, it may be back. */
538  if (is_ip4)
540  clib_host_to_net_u16 (dst_port));
541  else
543  clib_host_to_net_u16 (dst_port));
544 
546 }
547 
548 void
549 udp_punt_unknown (vlib_main_t * vm, u8 is_ip4, u8 is_add)
550 {
551  udp_main_t *um = &udp_main;
552  {
554  if (error)
555  clib_error_report (error);
556  }
557 
558  if (is_ip4)
559  um->punt_unknown4 = is_add;
560  else
561  um->punt_unknown6 = is_add;
562 }
563 
564 /* Parse a UDP header. */
565 uword
566 unformat_udp_header (unformat_input_t * input, va_list * args)
567 {
568  u8 **result = va_arg (*args, u8 **);
569  udp_header_t *udp;
570  __attribute__ ((unused)) int old_length;
571  u16 src_port, dst_port;
572 
573  /* Allocate space for IP header. */
574  {
575  void *p;
576 
577  old_length = vec_len (*result);
578  vec_add2 (*result, p, sizeof (ip4_header_t));
579  udp = p;
580  }
581 
582  memset (udp, 0, sizeof (udp[0]));
583  if (unformat (input, "src-port %d dst-port %d", &src_port, &dst_port))
584  {
585  udp->src_port = clib_host_to_net_u16 (src_port);
586  udp->dst_port = clib_host_to_net_u16 (dst_port);
587  return 1;
588  }
589  return 0;
590 }
591 
592 static void
594 {
595  vlib_node_t *n = vlib_get_node (vm, node_index);
596  pg_node_t *pn = pg_get_node (node_index);
597 
601 }
602 
603 clib_error_t *
605 {
606  udp_main_t *um = &udp_main;
607  int i;
608 
609  {
610  clib_error_t *error;
611  error = vlib_call_init_function (vm, udp_init);
612  if (error)
613  clib_error_report (error);
614  }
615 
616 
617  for (i = 0; i < 2; i++)
618  {
619  um->dst_port_info_by_name[i] = hash_create_string (0, sizeof (uword));
620  um->dst_port_info_by_dst_port[i] = hash_create (0, sizeof (uword));
621  }
622 
623  udp_setup_node (vm, udp4_input_node.index);
624  udp_setup_node (vm, udp6_input_node.index);
625 
626  um->punt_unknown4 = 0;
627  um->punt_unknown6 = 0;
628 
630  ( /* elt bytes */ sizeof (um->next_by_dst_port4[0]),
631  /* bits in index */ BITS (((udp_header_t *) 0)->dst_port));
632 
634  ( /* elt bytes */ sizeof (um->next_by_dst_port6[0]),
635  /* bits in index */ BITS (((udp_header_t *) 0)->dst_port));
636 
637 #define _(n,s) add_dst_port (um, UDP_DST_PORT_##s, #s, 1 /* is_ip4 */);
639 #undef _
640 #define _(n,s) add_dst_port (um, UDP_DST_PORT_##s, #s, 0 /* is_ip4 */);
642 #undef _
643  ip4_register_protocol (IP_PROTOCOL_UDP, udp4_input_node.index);
644  /* Note: ip6 differs from ip4, UDP is hotwired to ip6-udp-lookup */
645  return 0;
646 }
647 
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:526
#define hash_set(h, key, value)
Definition: hash.h:254
sll srl srl sll sra u16x4 i
Definition: vector_sse2.h:343
#define CLIB_UNUSED(x)
Definition: clib.h:79
u16 * next_by_dst_port6
Definition: udp.h:152
format_function_t format_udp_header
Definition: format.h:102
clib_error_t * udp_local_init(vlib_main_t *vm)
Definition: udp_local.c:604
static char * udp_error_strings[]
Definition: udp_local.c:396
udp_main_t udp_main
Definition: udp_local.c:24
#define PREDICT_TRUE(x)
Definition: clib.h:98
uword * dst_port_info_by_dst_port[N_UDP_AF]
Definition: udp.h:147
static void vlib_error_count(vlib_main_t *vm, uword node_index, uword counter, uword increment)
Definition: error_funcs.h:57
static clib_error_t * udp_init(vlib_main_t *vm)
Definition: udp.c:291
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:459
struct _vlib_node_registration vlib_node_registration_t
#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
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:488
#define hash_set_mem(h, key, value)
Definition: hash.h:274
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:161
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:418
u8 punt_unknown6
Definition: udp.h:154
void ip4_register_protocol(u32 protocol, u32 node_index)
Definition: ip4_forward.c:1932
vlib_error_t * errors
Vector of errors for this node.
Definition: node.h:418
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:100
static uword vlib_node_add_next(vlib_main_t *vm, uword node, uword next_node)
Definition: node_funcs.h:1062
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:468
static pg_node_t * pg_get_node(uword node_index)
Definition: pg.h:350
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:111
#define always_inline
Definition: clib.h:84
u8 punt_unknown4
Definition: udp.h:153
#define sparse_vec_validate(v, i)
Definition: sparse_vec.h:214
#define vlib_prefetch_buffer_header(b, type)
Prefetch buffer metadata.
Definition: buffer.h:164
static void sparse_vec_index2(void *v, u32 si0, u32 si1, u32 *i0_return, u32 *i1_return)
Definition: sparse_vec.h:160
#define vlib_call_init_function(vm, x)
Definition: init.h:162
#define hash_create_string(elts, value_bytes)
Definition: hash.h:652
void icmp6_error_set_vnet_buffer(vlib_buffer_t *b, u8 type, u8 code, u32 data)
Definition: icmp6.c:509
u16 * next_by_dst_port4
Definition: udp.h:151
u16 current_length
Nbytes between current data and the end of this buffer.
Definition: buffer.h:71
udp_dst_port_info_t * dst_port_infos[N_UDP_AF]
Definition: udp.h:143
struct _unformat_input_t unformat_input_t
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:188
uword * dst_port_info_by_name[N_UDP_AF]
Definition: udp.h:146
#define PREDICT_FALSE(x)
Definition: clib.h:97
format_function_t * format_buffer
Definition: node.h:311
u32 node_index
Node index.
Definition: node.h:436
#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:216
#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:350
VLIB_NODE_FUNCTION_MULTIARCH(udp4_input_node, udp4_input)
vlib_error_t error
Error code for buffers to be enqueued to error handler.
Definition: buffer.h:113
static void udp_setup_node(vlib_main_t *vm, u32 node_index)
Definition: udp_local.c:593
u16 n_vectors
Definition: node.h:344
#define CLIB_PREFETCH(addr, size, type)
Definition: cache.h:82
vlib_main_t * vm
Definition: buffer.c:276
vlib_node_registration_t udp4_input_node
(constructor) VLIB_REGISTER_NODE (udp4_input_node)
Definition: udp_local.c:61
void icmp4_error_set_vnet_buffer(vlib_buffer_t *b, u8 type, u8 code, u32 data)
Definition: icmp4.c:431
#define VLIB_BUFFER_IS_TRACED
Definition: buffer.h:85
unformat_function_t unformat_pg_udp_header
Definition: format.h:104
unformat_function_t * unformat_buffer
Definition: node.h:312
unformat_function_t * unformat_edit
Definition: pg.h:307
static uword udp46_input_inline(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame, int is_ip4)
Definition: udp_local.c:65
void udp_punt_unknown(vlib_main_t *vm, u8 is_ip4, u8 is_add)
Definition: udp_local.c:549
vlib_node_registration_t udp6_input_node
(constructor) VLIB_REGISTER_NODE (udp6_input_node)
Definition: udp_local.c:62
udp_dst_port_t
Definition: udp.h:105
#define hash_create(elts, value_bytes)
Definition: hash.h:658
static uword sparse_vec_index(void *v, uword sparse_index)
Definition: sparse_vec.h:152
u16 cached_next_index
Next frame index that vector arguments were last enqueued to last time this node ran.
Definition: node.h:455
#define foreach_udp4_dst_port
Definition: udp.h:80
#define ASSERT(truth)
unsigned int u32
Definition: types.h:88
udp_input_next_t
Definition: udp_local.c:32
#define foreach_udp_input_next
Definition: udp_local.c:26
udp_dst_port_t dst_port
Definition: udp.h:125
char * name
Definition: udp.h:122
static uword udp6_input(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
Definition: udp_local.c:410
#define clib_error_report(e)
Definition: error.h:125
static void vlib_buffer_advance(vlib_buffer_t *b, word l)
Advance current data pointer by the supplied (signed!) amount.
Definition: buffer.h:201
u64 uword
Definition: types.h:112
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.
static uword udp4_input(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame)
Definition: udp_local.c:403
unsigned short u16
Definition: types.h:57
i64 word
Definition: types.h:111
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
unsigned char u8
Definition: types.h:56
static void * vlib_frame_vector_args(vlib_frame_t *f)
Get pointer to frame vector data.
Definition: node_funcs.h:253
uword unformat_udp_header(unformat_input_t *input, va_list *args)
Definition: udp_local.c:566
u8 * format_udp_rx_trace(u8 *s, va_list *args)
Definition: udp_local.c:48
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:143
u8 data[0]
Packet data.
Definition: buffer.h:152
static vlib_node_t * vlib_get_node(vlib_main_t *vm, u32 i)
Get vlib node by index.
Definition: node_funcs.h:58
static void * sparse_vec_new(uword elt_bytes, uword sparse_index_bits)
Definition: sparse_vec.h:71
u32 flags
buffer flags: VLIB_BUFFER_IS_TRACED: trace this buffer.
Definition: buffer.h:74
#define BITS(x)
Definition: clib.h:58
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
Definition: buffer_funcs.h:57
Definition: pg.h:304
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:971
#define SPARSE_VEC_INVALID_INDEX
Definition: sparse_vec.h:68