FD.io VPP  v19.04.4-rc0-5-ge88582fac
Vector Packet Processing
udp.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2016-2019 Cisco and/or its affiliates.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at:
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 /** @file
17  udp state machine, etc.
18 */
19 
20 #include <vnet/udp/udp.h>
21 #include <vnet/session/session.h>
22 #include <vnet/dpo/load_balance.h>
23 #include <vnet/fib/ip4_fib.h>
24 
26 
28 udp_connection_alloc (u32 thread_index)
29 {
30  udp_main_t *um = &udp_main;
31  udp_connection_t *uc;
32  u32 will_expand = 0;
33  pool_get_aligned_will_expand (um->connections[thread_index], will_expand,
35 
36  if (PREDICT_FALSE (will_expand))
37  {
39  [thread_index]);
40  pool_get_aligned (udp_main.connections[thread_index], uc,
43  [thread_index]);
44  }
45  else
46  {
47  pool_get_aligned (um->connections[thread_index], uc,
49  }
50  clib_memset (uc, 0, sizeof (*uc));
51  uc->c_c_index = uc - um->connections[thread_index];
52  uc->c_thread_index = thread_index;
53  uc->c_proto = TRANSPORT_PROTO_UDP;
55  return uc;
56 }
57 
58 void
60 {
61  pool_put (udp_main.connections[uc->c_thread_index], uc);
62  if (CLIB_DEBUG)
63  clib_memset (uc, 0xFA, sizeof (*uc));
64 }
65 
66 u32
68 {
72  u32 node_index;
73  void *iface_ip;
75 
76  pi = udp_get_dst_port_info (um, lcl->port, lcl->is_ip4);
77  if (pi)
78  return -1;
79 
80  pool_get (um->listener_pool, listener);
81  clib_memset (listener, 0, sizeof (udp_connection_t));
82 
83  listener->c_lcl_port = lcl->port;
84  listener->c_c_index = listener - um->listener_pool;
85 
86  /* If we are provided a sw_if_index, bind using one of its ips */
87  if (ip_is_zero (&lcl->ip, 1) && lcl->sw_if_index != ENDPOINT_INVALID_INDEX)
88  {
89  if ((iface_ip = ip_interface_get_first_ip (lcl->sw_if_index,
90  lcl->is_ip4)))
91  ip_set (&lcl->ip, iface_ip, lcl->is_ip4);
92  }
93  ip_copy (&listener->c_lcl_ip, &lcl->ip, lcl->is_ip4);
94  listener->c_is_ip4 = lcl->is_ip4;
95  listener->c_proto = TRANSPORT_PROTO_UDP;
96  listener->c_s_index = session_index;
97  listener->c_fib_index = lcl->fib_index;
98  clib_spinlock_init (&listener->rx_lock);
99 
100  node_index = lcl->is_ip4 ? udp4_input_node.index : udp6_input_node.index;
101  udp_register_dst_port (vm, clib_net_to_host_u16 (lcl->port), node_index,
102  1 /* is_ipv4 */ );
103  return listener->c_c_index;
104 }
105 
106 u32
107 udp_session_unbind (u32 listener_index)
108 {
110 
112  listener = udp_listener_get (listener_index);
113  udp_unregister_dst_port (vm, clib_net_to_host_u16 (listener->c_lcl_port),
114  listener->c_is_ip4);
115  return 0;
116 }
117 
120 {
121  udp_connection_t *us;
122 
123  us = udp_listener_get (listener_index);
124  return &us->connection;
125 }
126 
127 u32
129 {
130  udp_connection_t *uc;
132 
134 
135  vlib_buffer_push_udp (b, uc->c_lcl_port, uc->c_rmt_port, 1);
136  if (tc->is_ip4)
137  vlib_buffer_push_ip4 (vm, b, &uc->c_lcl_ip4, &uc->c_rmt_ip4,
138  IP_PROTOCOL_UDP, 1);
139  else
140  {
141  ip6_header_t *ih;
142  ih = vlib_buffer_push_ip6 (vm, b, &uc->c_lcl_ip6, &uc->c_rmt_ip6,
143  IP_PROTOCOL_UDP);
144  vnet_buffer (b)->l3_hdr_offset = (u8 *) ih - b->data;
145  }
146  vnet_buffer (b)->sw_if_index[VLIB_RX] = 0;
147  vnet_buffer (b)->sw_if_index[VLIB_TX] = uc->c_fib_index;
148  b->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED;
149 
150  return 0;
151 }
152 
154 udp_session_get (u32 connection_index, u32 thread_index)
155 {
156  udp_connection_t *uc;
157  uc = udp_connection_get (connection_index, thread_index);
158  if (uc)
159  return &uc->connection;
160  return 0;
161 }
162 
163 void
164 udp_session_close (u32 connection_index, u32 thread_index)
165 {
167  udp_connection_t *uc;
168  uc = udp_connection_get (connection_index, thread_index);
169  if (uc)
170  {
171  udp_unregister_dst_port (vm, clib_net_to_host_u16 (uc->c_lcl_port),
172  uc->c_is_ip4);
174  udp_connection_free (uc);
175  }
176 }
177 
178 void
179 udp_session_cleanup (u32 connection_index, u32 thread_index)
180 {
181  udp_connection_t *uc;
182  uc = udp_connection_get (connection_index, thread_index);
183  if (uc)
184  udp_connection_free (uc);
185 }
186 
187 u8 *
188 format_udp_connection_id (u8 * s, va_list * args)
189 {
190  udp_connection_t *uc = va_arg (*args, udp_connection_t *);
191  if (!uc)
192  return s;
193  if (uc->c_is_ip4)
194  s = format (s, "[#%d][%s] %U:%d->%U:%d", uc->c_thread_index, "U",
195  format_ip4_address, &uc->c_lcl_ip4,
196  clib_net_to_host_u16 (uc->c_lcl_port), format_ip4_address,
197  &uc->c_rmt_ip4, clib_net_to_host_u16 (uc->c_rmt_port));
198  else
199  s = format (s, "[#%d][%s] %U:%d->%U:%d", uc->c_thread_index, "U",
200  format_ip6_address, &uc->c_lcl_ip6,
201  clib_net_to_host_u16 (uc->c_lcl_port), format_ip6_address,
202  &uc->c_rmt_ip6, clib_net_to_host_u16 (uc->c_rmt_port));
203  return s;
204 }
205 
206 u8 *
207 format_udp_connection (u8 * s, va_list * args)
208 {
209  udp_connection_t *uc = va_arg (*args, udp_connection_t *);
210  u32 verbose = va_arg (*args, u32);
211  if (!uc)
212  return s;
213  s = format (s, "%-50U", format_udp_connection_id, uc);
214  if (verbose)
215  {
216  if (verbose == 1)
217  s = format (s, "%-15s\n", "-");
218  else
219  s = format (s, "\n");
220  }
221  return s;
222 }
223 
224 u8 *
225 format_udp_session (u8 * s, va_list * args)
226 {
227  u32 uci = va_arg (*args, u32);
228  u32 thread_index = va_arg (*args, u32);
229  u32 verbose = va_arg (*args, u32);
230  udp_connection_t *uc;
231 
232  uc = udp_connection_get (uci, thread_index);
233  return format (s, "%U", format_udp_connection, uc, verbose);
234 }
235 
236 u8 *
237 format_udp_half_open_session (u8 * s, va_list * args)
238 {
239  clib_warning ("BUG");
240  return 0;
241 }
242 
243 u8 *
244 format_udp_listener_session (u8 * s, va_list * args)
245 {
246  u32 tci = va_arg (*args, u32);
248  return format (s, "%U", format_udp_connection, uc);
249 }
250 
251 u16
253 {
254  /* TODO figure out MTU of output interface */
255  return 1460;
256 }
257 
258 u32
260 {
261  /* No constraint on TX window */
262  return ~0;
263 }
264 
265 int
267 {
268  udp_main_t *um = vnet_get_udp_main ();
270  u32 thread_index = vm->thread_index;
271  udp_connection_t *uc;
272  ip46_address_t lcl_addr;
273  u32 node_index;
274  u16 lcl_port;
275 
277  &lcl_port))
278  return -1;
279 
280  while (udp_get_dst_port_info (um, lcl_port, rmt->is_ip4))
281  {
282  lcl_port = transport_alloc_local_port (TRANSPORT_PROTO_UDP, &lcl_addr);
283  if (lcl_port < 1)
284  {
285  clib_warning ("Failed to allocate src port");
286  return -1;
287  }
288  }
289 
290  node_index = rmt->is_ip4 ? udp4_input_node.index : udp6_input_node.index;
291  udp_register_dst_port (vm, lcl_port, node_index, 1 /* is_ipv4 */ );
292 
293  /* We don't poll main thread if we have workers */
294  if (vlib_num_workers ())
295  thread_index = 1;
296 
297  uc = udp_connection_alloc (thread_index);
298  ip_copy (&uc->c_rmt_ip, &rmt->ip, rmt->is_ip4);
299  ip_copy (&uc->c_lcl_ip, &lcl_addr, rmt->is_ip4);
300  uc->c_rmt_port = rmt->port;
301  uc->c_lcl_port = clib_host_to_net_u16 (lcl_port);
302  uc->c_is_ip4 = rmt->is_ip4;
303  uc->c_proto = TRANSPORT_PROTO_UDP;
304  uc->c_fib_index = rmt->fib_index;
305 
306  return uc->c_c_index;
307 }
308 
311 {
312  udp_connection_t *uc;
313  u32 thread_index;
314 
315  /* We don't poll main thread if we have workers */
316  thread_index = vlib_num_workers ()? 1 : 0;
317  uc = udp_connection_get (conn_index, thread_index);
318  return &uc->connection;
319 }
320 
321 /* *INDENT-OFF* */
323  .start_listen = udp_session_bind,
324  .connect = udp_open_connection,
325  .stop_listen = udp_session_unbind,
326  .push_header = udp_push_header,
327  .get_connection = udp_session_get,
328  .get_listener = udp_session_get_listener,
329  .get_half_open = udp_session_get_half_open,
330  .close = udp_session_close,
331  .cleanup = udp_session_cleanup,
332  .send_mss = udp_send_mss,
333  .send_space = udp_send_space,
334  .format_connection = format_udp_session,
335  .format_half_open = format_udp_half_open_session,
336  .format_listener = format_udp_listener_session,
337  .tx_type = TRANSPORT_TX_DGRAM,
338  .service_type = TRANSPORT_SERVICE_CL,
339 };
340 /* *INDENT-ON* */
341 
342 
343 int
345 {
346  udp_connection_t *uc;
347  u32 uc_index;
348  uc_index = udp_open_connection (rmt);
349  uc = udp_connection_get (uc_index, vlib_get_thread_index ());
350  uc->is_connected = 1;
351  return uc_index;
352 }
353 
354 u32
356 {
358  u32 li;
359  li = udp_session_bind (session_index, lcl);
360  listener = udp_listener_get (li);
361  listener->is_connected = 1;
362  return li;
363 }
364 
365 /* *INDENT-OFF* */
367  .start_listen = udpc_connection_listen,
368  .stop_listen = udp_session_unbind,
369  .connect = udpc_connection_open,
370  .push_header = udp_push_header,
371  .get_connection = udp_session_get,
372  .get_listener = udp_session_get_listener,
373  .get_half_open = udp_session_get_half_open,
374  .close = udp_session_close,
375  .cleanup = udp_session_cleanup,
376  .send_mss = udp_send_mss,
377  .send_space = udp_send_space,
378  .format_connection = format_udp_session,
379  .format_half_open = format_udp_half_open_session,
380  .format_listener = format_udp_listener_session,
381  .tx_type = TRANSPORT_TX_DEQUEUE,
382  .service_type = TRANSPORT_SERVICE_CL,
383 };
384 /* *INDENT-ON* */
385 
386 static clib_error_t *
388 {
389  udp_main_t *um = vnet_get_udp_main ();
390  ip_main_t *im = &ip_main;
392  u32 num_threads;
393  clib_error_t *error = 0;
394  ip_protocol_info_t *pi;
395  int i;
396 
397  if ((error = vlib_call_init_function (vm, ip_main_init)))
398  return error;
399  if ((error = vlib_call_init_function (vm, ip4_lookup_init)))
400  return error;
401  if ((error = vlib_call_init_function (vm, ip6_lookup_init)))
402  return error;
403 
404  /*
405  * Registrations
406  */
407 
408  /* IP registration */
409  pi = ip_get_protocol_info (im, IP_PROTOCOL_UDP);
410  if (pi == 0)
411  return clib_error_return (0, "UDP protocol info AWOL");
414 
415  /* Register as transport with URI */
424 
425  /*
426  * Initialize data structures
427  */
428 
429  num_threads = 1 /* main thread */ + tm->n_threads;
430  vec_validate (um->connections, num_threads - 1);
431  vec_validate (um->connection_peekers, num_threads - 1);
432  vec_validate (um->peekers_readers_locks, num_threads - 1);
433  vec_validate (um->peekers_write_locks, num_threads - 1);
434 
435  if (num_threads > 1)
436  for (i = 0; i < num_threads; i++)
437  {
440  }
441  return error;
442 }
443 
445 
446 static clib_error_t *
448  vlib_cli_command_t * cmd_arg)
449 {
450  udp_main_t *um = vnet_get_udp_main ();
451 
452  clib_error_t *error = NULL;
453 
455  return clib_error_return (0, "unknown input `%U'", format_unformat_error,
456  input);
457 
458  udp_dst_port_info_t *port_info;
459  if (um->punt_unknown4)
460  {
461  vlib_cli_output (vm, "IPv4 UDP punt: enabled");
462  }
463  else
464  {
465  u8 *s = NULL;
466  vec_foreach (port_info, um->dst_port_infos[UDP_IP4])
467  {
468  if (udp_is_valid_dst_port (port_info->dst_port, 1))
469  {
470  s = format (s, (!s) ? "%d" : ", %d", port_info->dst_port);
471  }
472  }
473  s = format (s, "%c", 0);
474  vlib_cli_output (vm, "IPV4 UDP ports punt : %s", s);
475  }
476 
477  if (um->punt_unknown6)
478  {
479  vlib_cli_output (vm, "IPv6 UDP punt: enabled");
480  }
481  else
482  {
483  u8 *s = NULL;
484  vec_foreach (port_info, um->dst_port_infos[UDP_IP6])
485  {
486  if (udp_is_valid_dst_port (port_info->dst_port, 01))
487  {
488  s = format (s, (!s) ? "%d" : ", %d", port_info->dst_port);
489  }
490  }
491  s = format (s, "%c", 0);
492  vlib_cli_output (vm, "IPV6 UDP ports punt : %s", s);
493  }
494 
495  return (error);
496 }
497 /* *INDENT-OFF* */
498 VLIB_CLI_COMMAND (show_tcp_punt_command, static) =
499 {
500  .path = "show udp punt",
501  .short_help = "show udp punt [ipv4|ipv6]",
502  .function = show_udp_punt_fn,
503 };
504 /* *INDENT-ON* */
505 
506 /*
507  * fd.io coding-style-patch-verification: ON
508  *
509  * Local Variables:
510  * eval: (c-set-style "gnu")
511  * End:
512  */
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:439
static clib_error_t * show_udp_punt_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd_arg)
Definition: udp.c:447
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
void udp_session_cleanup(u32 connection_index, u32 thread_index)
Definition: udp.c:179
#define ENDPOINT_INVALID_INDEX
static udp_connection_t * udp_listener_get(u32 conn_index)
Definition: udp.h:163
u8 * format_udp_session(u8 *s, va_list *args)
Definition: udp.c:225
void ip_copy(ip46_address_t *dst, ip46_address_t *src, u8 is_ip4)
Definition: ip.c:81
format_function_t format_udp_header
Definition: format.h:101
static clib_error_t * ip4_lookup_init(vlib_main_t *vm)
Definition: ip4_forward.c:909
u32 * connection_peekers
Definition: udp.h:141
static udp_connection_t * udp_get_connection_from_transport(transport_connection_t *tc)
Definition: udp.h:175
void ip_set(ip46_address_t *dst, void *src, u8 is_ip4)
Definition: ip.c:90
#define NULL
Definition: clib.h:58
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
void session_transport_delete_notify(transport_connection_t *tc)
Notification from transport that connection is being deleted.
Definition: session.c:746
static clib_error_t * udp_init(vlib_main_t *vm)
Definition: udp.c:387
static_always_inline void clib_spinlock_unlock_if_init(clib_spinlock_t *p)
Definition: lock.h:98
transport_connection_t * udp_session_get_half_open(u32 conn_index)
Definition: udp.c:310
u32 thread_index
Definition: main.h:197
#define pool_get_aligned_will_expand(P, YESNO, A)
See if pool_get will expand the pool or not.
Definition: pool.h:242
u8 data[0]
Packet data.
Definition: buffer.h:181
int i
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
int udp_open_connection(transport_endpoint_cfg_t *rmt)
Definition: udp.c:266
transport_connection_t * udp_session_get_listener(u32 listener_index)
Definition: udp.c:119
void * ip_interface_get_first_ip(u32 sw_if_index, u8 is_ip4)
Definition: ip.c:134
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
Definition: ip.h:109
u32 udp_push_header(transport_connection_t *tc, vlib_buffer_t *b)
Definition: udp.c:128
u8 punt_unknown6
Definition: udp.h:135
static void * vlib_buffer_push_udp(vlib_buffer_t *b, u16 sp, u16 dp, u8 offload_csum)
Definition: udp.h:262
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:236
unsigned char u8
Definition: types.h:56
static udp_main_t * vnet_get_udp_main()
Definition: udp.h:169
vlib_node_registration_t ip4_lookup_node
(constructor) VLIB_REGISTER_NODE (ip4_lookup_node)
Definition: ip4_forward.c:104
format_function_t format_ip4_address
Definition: format.h:75
unformat_function_t * unformat_pg_edit
Definition: ip.h:90
void udp_connection_free(udp_connection_t *uc)
Definition: udp.c:59
int udpc_connection_open(transport_endpoint_cfg_t *rmt)
Definition: udp.c:344
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:163
u8 punt_unknown4
Definition: udp.h:134
u32 udp_session_bind(u32 session_index, transport_endpoint_t *lcl)
Definition: udp.c:67
#define clib_error_return(e, args...)
Definition: error.h:99
int transport_alloc_local_endpoint(u8 proto, transport_endpoint_cfg_t *rmt_cfg, ip46_address_t *lcl_addr, u16 *lcl_port)
Definition: transport.c:472
unsigned int u32
Definition: types.h:88
static const transport_proto_vft_t udpc_proto
Definition: udp.c:366
#define vlib_call_init_function(vm, x)
Definition: init.h:260
struct _transport_proto_vft transport_proto_vft_t
static void clib_spinlock_init(clib_spinlock_t *p)
Definition: lock.h:57
vlib_node_registration_t udp4_input_node
(constructor) VLIB_REGISTER_NODE (udp4_input_node)
Definition: udp_input.c:306
static ip_protocol_info_t * ip_get_protocol_info(ip_main_t *im, u32 protocol)
Definition: ip.h:136
format_function_t * format_header
Definition: ip.h:81
u32 udp_session_unbind(u32 listener_index)
Definition: udp.c:107
udp_dst_port_info_t * dst_port_infos[N_UDP_AF]
Definition: udp.h:124
udp_connection_t * udp_connection_alloc(u32 thread_index)
Definition: udp.c:28
struct _unformat_input_t unformat_input_t
unsigned short u16
Definition: types.h:57
clib_spinlock_t * peekers_readers_locks
Definition: udp.h:142
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:286
vlib_node_registration_t udp6_input_node
(constructor) VLIB_REGISTER_NODE (udp6_input_node)
Definition: udp_input.c:332
#define PREDICT_FALSE(x)
Definition: clib.h:111
udp_connection_t * listener_pool
Definition: udp.h:144
u16 udp_send_mss(transport_connection_t *t)
Definition: udp.c:252
Definition: udp.h:117
#define pool_get_aligned(P, E, A)
Allocate an object E from a pool P with alignment A.
Definition: pool.h:230
clib_error_t * ip_main_init(vlib_main_t *vm)
Definition: ip_init.c:45
#define UNFORMAT_END_OF_INPUT
Definition: format.h:144
static_always_inline uword vlib_get_thread_index(void)
Definition: threads.h:212
format_function_t format_ip6_address
Definition: format.h:93
vlib_main_t * vm
Definition: buffer.c:312
ip_main_t ip_main
Definition: ip_init.c:42
void udp_unregister_dst_port(vlib_main_t *vm, udp_dst_port_t dst_port, u8 is_ip4)
Definition: udp_local.c:522
#define clib_warning(format, args...)
Definition: error.h:59
unformat_function_t unformat_pg_udp_header
Definition: format.h:103
static udp_connection_t * udp_connection_get(u32 conn_index, u32 thread_index)
Definition: udp.h:155
struct _transport_connection transport_connection_t
void transport_register_protocol(transport_proto_t transport_proto, const transport_proto_vft_t *vft, fib_protocol_t fib_proto, u32 output_node)
Register transport virtual function table.
Definition: transport.c:248
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:155
vlib_node_registration_t ip6_lookup_node
(constructor) VLIB_REGISTER_NODE (ip6_lookup_node)
Definition: ip6_forward.c:552
udp_dst_port_t dst_port
Definition: udp.h:103
datagram mode
clib_spinlock_t * peekers_write_locks
Definition: udp.h:143
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
u8 * format_udp_connection(u8 *s, va_list *args)
Definition: udp.c:207
u8 ip_is_zero(ip46_address_t *ip46_address, u8 is_ip4)
Definition: ip.c:20
u32 udpc_connection_listen(u32 session_index, transport_endpoint_t *lcl)
Definition: udp.c:355
Definition: defs.h:47
static const transport_proto_vft_t udp_proto
Definition: udp.c:322
static void * vlib_buffer_push_ip6(vlib_main_t *vm, vlib_buffer_t *b, ip6_address_t *src, ip6_address_t *dst, int proto)
Push IPv6 header to buffer.
Definition: ip6.h:658
transport_connection_t connection
must be first
Definition: udp.h:41
clib_spinlock_t rx_lock
rx fifo lock
Definition: udp.h:42
bool udp_is_valid_dst_port(udp_dst_port_t dst_port, u8 is_ip4)
Definition: udp_local.c:545
void udp_session_close(u32 connection_index, u32 thread_index)
Definition: udp.c:164
VLIB buffer representation.
Definition: buffer.h:102
connectionless service
u8 * format_udp_half_open_session(u8 *s, va_list *args)
Definition: udp.c:237
u8 * format_udp_connection_id(u8 *s, va_list *args)
Definition: udp.c:188
unreliable transport protos
#define vnet_buffer(b)
Definition: buffer.h:369
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
transport_connection_t * udp_session_get(u32 connection_index, u32 thread_index)
Definition: udp.c:154
static vlib_thread_main_t * vlib_get_thread_main()
Definition: global_funcs.h:32
static u32 vlib_num_workers()
Definition: threads.h:366
#define vec_foreach(var, vec)
Vector iterator.
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
int transport_alloc_local_port(u8 proto, ip46_address_t *ip)
Allocate local port and add if successful add entry to local endpoint table to mark the pair as used...
Definition: transport.c:375
static clib_error_t * ip6_lookup_init(vlib_main_t *vm)
Definition: ip6_forward.c:2692
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:59
u32 udp_send_space(transport_connection_t *t)
Definition: udp.c:259
udp_connection_t ** connections
Definition: udp.h:140
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:762
static_always_inline void clib_spinlock_lock_if_init(clib_spinlock_t *p)
Definition: lock.h:82
static void * vlib_buffer_push_ip4(vlib_main_t *vm, vlib_buffer_t *b, ip4_address_t *src, ip4_address_t *dst, int proto, u8 csum_offload)
Push IPv4 header to buffer.
Definition: ip4.h:370
Definition: udp.h:118
Definition: defs.h:46
u8 is_connected
connected mode
Definition: udp.h:43
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:170
u8 * format_udp_listener_session(u8 *s, va_list *args)
Definition: udp.c:244