Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1 | /* |
Florin Coras | c98ef75 | 2020-04-07 17:30:13 +0000 | [diff] [blame] | 2 | * Copyright (c) 2016-2020 Cisco and/or its affiliates. |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 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 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 16 | #include <vnet/udp/udp.h> |
| 17 | #include <vnet/session/session.h> |
| 18 | #include <vnet/dpo/load_balance.h> |
Neale Ranns | e403113 | 2020-10-26 13:00:06 +0000 | [diff] [blame] | 19 | #include <vnet/ip/ip4_inlines.h> |
| 20 | #include <vnet/ip/ip6_inlines.h> |
Florin Coras | a039620 | 2020-04-01 00:11:16 +0000 | [diff] [blame] | 21 | #include <vppinfra/sparse_vec.h> |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 22 | |
Filip Tehlar | 2c49ffe | 2019-03-06 07:16:08 -0800 | [diff] [blame] | 23 | udp_main_t udp_main; |
| 24 | |
Florin Coras | a039620 | 2020-04-01 00:11:16 +0000 | [diff] [blame] | 25 | static void |
Florin Coras | c8e4110 | 2022-03-18 10:27:29 -0700 | [diff] [blame] | 26 | udp_connection_register_port (u16 lcl_port, u8 is_ip4) |
Florin Coras | a039620 | 2020-04-01 00:11:16 +0000 | [diff] [blame] | 27 | { |
| 28 | udp_main_t *um = &udp_main; |
Florin Coras | a039620 | 2020-04-01 00:11:16 +0000 | [diff] [blame] | 29 | u16 *n; |
| 30 | |
Florin Coras | e1f2058 | 2022-11-11 11:37:36 -0800 | [diff] [blame] | 31 | /* Setup udp protocol -> next index sparse vector mapping. Do not setup |
| 32 | * udp_dst_port_info_t as that is used to distinguish between external |
| 33 | * and transport consumed ports */ |
Florin Coras | a039620 | 2020-04-01 00:11:16 +0000 | [diff] [blame] | 34 | |
Florin Coras | a039620 | 2020-04-01 00:11:16 +0000 | [diff] [blame] | 35 | if (is_ip4) |
Florin Coras | e1f2058 | 2022-11-11 11:37:36 -0800 | [diff] [blame] | 36 | n = sparse_vec_validate (um->next_by_dst_port4, lcl_port); |
Florin Coras | a039620 | 2020-04-01 00:11:16 +0000 | [diff] [blame] | 37 | else |
Florin Coras | e1f2058 | 2022-11-11 11:37:36 -0800 | [diff] [blame] | 38 | n = sparse_vec_validate (um->next_by_dst_port6, lcl_port); |
Florin Coras | a039620 | 2020-04-01 00:11:16 +0000 | [diff] [blame] | 39 | |
Florin Coras | e1f2058 | 2022-11-11 11:37:36 -0800 | [diff] [blame] | 40 | n[0] = um->local_to_input_edge[is_ip4]; |
Florin Coras | 9bc72ac | 2023-01-09 12:46:07 -0800 | [diff] [blame] | 41 | |
| 42 | __atomic_add_fetch (&um->transport_ports_refcnt[is_ip4][lcl_port], 1, |
| 43 | __ATOMIC_RELAXED); |
Florin Coras | a039620 | 2020-04-01 00:11:16 +0000 | [diff] [blame] | 44 | } |
| 45 | |
| 46 | static void |
| 47 | udp_connection_unregister_port (u16 lcl_port, u8 is_ip4) |
| 48 | { |
| 49 | udp_main_t *um = &udp_main; |
Florin Coras | e1f2058 | 2022-11-11 11:37:36 -0800 | [diff] [blame] | 50 | u16 *n; |
Florin Coras | a039620 | 2020-04-01 00:11:16 +0000 | [diff] [blame] | 51 | |
Florin Coras | 9bc72ac | 2023-01-09 12:46:07 -0800 | [diff] [blame] | 52 | /* Needed because listeners are not tracked as local endpoints */ |
| 53 | if (__atomic_sub_fetch (&um->transport_ports_refcnt[is_ip4][lcl_port], 1, |
| 54 | __ATOMIC_RELAXED)) |
| 55 | return; |
| 56 | |
Florin Coras | e1f2058 | 2022-11-11 11:37:36 -0800 | [diff] [blame] | 57 | if (is_ip4) |
| 58 | n = sparse_vec_validate (um->next_by_dst_port4, lcl_port); |
| 59 | else |
| 60 | n = sparse_vec_validate (um->next_by_dst_port6, lcl_port); |
Florin Coras | a039620 | 2020-04-01 00:11:16 +0000 | [diff] [blame] | 61 | |
Florin Coras | e1f2058 | 2022-11-11 11:37:36 -0800 | [diff] [blame] | 62 | n[0] = UDP_NO_NODE_SET; |
Florin Coras | a039620 | 2020-04-01 00:11:16 +0000 | [diff] [blame] | 63 | } |
| 64 | |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 65 | udp_connection_t * |
| 66 | udp_connection_alloc (u32 thread_index) |
| 67 | { |
Florin Coras | 4c89b18 | 2022-10-24 18:59:06 -0700 | [diff] [blame] | 68 | udp_worker_t *wrk = udp_worker_get (thread_index); |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 69 | udp_connection_t *uc; |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 70 | |
Florin Coras | 4c89b18 | 2022-10-24 18:59:06 -0700 | [diff] [blame] | 71 | pool_get_aligned_safe (wrk->connections, uc, CLIB_CACHE_LINE_BYTES); |
Florin Coras | a2b358b | 2022-03-18 12:50:03 -0700 | [diff] [blame] | 72 | |
Dave Barach | b7b9299 | 2018-10-17 10:38:51 -0400 | [diff] [blame] | 73 | clib_memset (uc, 0, sizeof (*uc)); |
Florin Coras | 4c89b18 | 2022-10-24 18:59:06 -0700 | [diff] [blame] | 74 | uc->c_c_index = uc - wrk->connections; |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 75 | uc->c_thread_index = thread_index; |
| 76 | uc->c_proto = TRANSPORT_PROTO_UDP; |
| 77 | return uc; |
| 78 | } |
| 79 | |
| 80 | void |
| 81 | udp_connection_free (udp_connection_t * uc) |
| 82 | { |
Florin Coras | 4c89b18 | 2022-10-24 18:59:06 -0700 | [diff] [blame] | 83 | udp_worker_t *wrk = udp_worker_get (uc->c_thread_index); |
| 84 | |
Florin Coras | 30fdf39 | 2020-12-02 21:14:56 -0800 | [diff] [blame] | 85 | clib_spinlock_free (&uc->rx_lock); |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 86 | if (CLIB_DEBUG) |
Dave Barach | b7b9299 | 2018-10-17 10:38:51 -0400 | [diff] [blame] | 87 | clib_memset (uc, 0xFA, sizeof (*uc)); |
Florin Coras | 4c89b18 | 2022-10-24 18:59:06 -0700 | [diff] [blame] | 88 | pool_put (wrk->connections, uc); |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 89 | } |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 90 | |
Florin Coras | 57a5a2d | 2020-04-01 23:16:11 +0000 | [diff] [blame] | 91 | static void |
| 92 | udp_connection_cleanup (udp_connection_t * uc) |
| 93 | { |
Florin Coras | e1f2058 | 2022-11-11 11:37:36 -0800 | [diff] [blame] | 94 | /* Unregister port from udp_local only if refcount went to zero */ |
| 95 | if (!transport_release_local_endpoint (TRANSPORT_PROTO_UDP, &uc->c_lcl_ip, |
| 96 | uc->c_lcl_port)) |
| 97 | udp_connection_unregister_port (uc->c_lcl_port, uc->c_is_ip4); |
Florin Coras | 57a5a2d | 2020-04-01 23:16:11 +0000 | [diff] [blame] | 98 | udp_connection_free (uc); |
| 99 | } |
| 100 | |
Florin Coras | c754239 | 2019-07-22 08:08:43 -0700 | [diff] [blame] | 101 | void |
| 102 | udp_connection_delete (udp_connection_t * uc) |
| 103 | { |
Florin Coras | c754239 | 2019-07-22 08:08:43 -0700 | [diff] [blame] | 104 | session_transport_delete_notify (&uc->connection); |
Florin Coras | 57a5a2d | 2020-04-01 23:16:11 +0000 | [diff] [blame] | 105 | udp_connection_cleanup (uc); |
Florin Coras | c754239 | 2019-07-22 08:08:43 -0700 | [diff] [blame] | 106 | } |
| 107 | |
Florin Coras | 1c29dfb | 2022-10-24 18:46:20 -0700 | [diff] [blame] | 108 | static void |
| 109 | udp_handle_cleanups (void *args) |
| 110 | { |
| 111 | u32 thread_index = (u32) pointer_to_uword (args); |
| 112 | udp_connection_t *uc; |
| 113 | udp_worker_t *wrk; |
| 114 | u32 *uc_index; |
| 115 | |
| 116 | wrk = udp_worker_get (thread_index); |
| 117 | vec_foreach (uc_index, wrk->pending_cleanups) |
| 118 | { |
| 119 | uc = udp_connection_get (*uc_index, thread_index); |
| 120 | udp_connection_delete (uc); |
| 121 | } |
| 122 | vec_reset_length (wrk->pending_cleanups); |
| 123 | } |
| 124 | |
| 125 | static void |
| 126 | udp_connection_program_cleanup (udp_connection_t *uc) |
| 127 | { |
| 128 | uword thread_index = uc->c_thread_index; |
| 129 | udp_worker_t *wrk; |
| 130 | |
| 131 | wrk = udp_worker_get (uc->c_thread_index); |
| 132 | vec_add1 (wrk->pending_cleanups, uc->c_c_index); |
| 133 | |
| 134 | if (vec_len (wrk->pending_cleanups) == 1) |
| 135 | session_send_rpc_evt_to_thread_force ( |
| 136 | thread_index, udp_handle_cleanups, |
| 137 | uword_to_pointer (thread_index, void *)); |
| 138 | } |
| 139 | |
Florin Coras | 57660d9 | 2020-04-04 22:45:34 +0000 | [diff] [blame] | 140 | static u8 |
| 141 | udp_connection_port_used_extern (u16 lcl_port, u8 is_ip4) |
| 142 | { |
| 143 | udp_main_t *um = vnet_get_udp_main (); |
| 144 | udp_dst_port_info_t *pi; |
| 145 | |
| 146 | pi = udp_get_dst_port_info (um, lcl_port, is_ip4); |
Florin Coras | e1f2058 | 2022-11-11 11:37:36 -0800 | [diff] [blame] | 147 | return (pi && udp_is_valid_dst_port (lcl_port, is_ip4)); |
Florin Coras | 57660d9 | 2020-04-04 22:45:34 +0000 | [diff] [blame] | 148 | } |
| 149 | |
Florin Coras | c98ef75 | 2020-04-07 17:30:13 +0000 | [diff] [blame] | 150 | static u16 |
| 151 | udp_default_mtu (udp_main_t * um, u8 is_ip4) |
| 152 | { |
| 153 | u16 ip_hlen = is_ip4 ? sizeof (ip4_header_t) : sizeof (ip6_header_t); |
| 154 | return (um->default_mtu - sizeof (udp_header_t) - ip_hlen); |
| 155 | } |
| 156 | |
| 157 | static u32 |
Florin Coras | 0bce71e | 2022-02-10 11:57:06 -0800 | [diff] [blame] | 158 | udp_session_bind (u32 session_index, transport_endpoint_cfg_t *lcl) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 159 | { |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 160 | udp_main_t *um = vnet_get_udp_main (); |
Florin Coras | 87b7e3d | 2020-03-27 15:06:07 +0000 | [diff] [blame] | 161 | transport_endpoint_cfg_t *lcl_ext; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 162 | udp_connection_t *listener; |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 163 | void *iface_ip; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 164 | |
Florin Coras | e1f2058 | 2022-11-11 11:37:36 -0800 | [diff] [blame] | 165 | if (udp_connection_port_used_extern (clib_net_to_host_u16 (lcl->port), |
| 166 | lcl->is_ip4)) |
Florin Coras | a039620 | 2020-04-01 00:11:16 +0000 | [diff] [blame] | 167 | { |
| 168 | clib_warning ("port already used"); |
Florin Coras | 57660d9 | 2020-04-04 22:45:34 +0000 | [diff] [blame] | 169 | return SESSION_E_PORTINUSE; |
Florin Coras | a039620 | 2020-04-01 00:11:16 +0000 | [diff] [blame] | 170 | } |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 171 | |
| 172 | pool_get (um->listener_pool, listener); |
Dave Barach | b7b9299 | 2018-10-17 10:38:51 -0400 | [diff] [blame] | 173 | clib_memset (listener, 0, sizeof (udp_connection_t)); |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 174 | |
Florin Coras | 0e49568 | 2017-09-19 22:27:18 -0700 | [diff] [blame] | 175 | listener->c_lcl_port = lcl->port; |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 176 | listener->c_c_index = listener - um->listener_pool; |
| 177 | |
| 178 | /* If we are provided a sw_if_index, bind using one of its ips */ |
| 179 | if (ip_is_zero (&lcl->ip, 1) && lcl->sw_if_index != ENDPOINT_INVALID_INDEX) |
| 180 | { |
| 181 | if ((iface_ip = ip_interface_get_first_ip (lcl->sw_if_index, |
| 182 | lcl->is_ip4))) |
| 183 | ip_set (&lcl->ip, iface_ip, lcl->is_ip4); |
| 184 | } |
| 185 | ip_copy (&listener->c_lcl_ip, &lcl->ip, lcl->is_ip4); |
| 186 | listener->c_is_ip4 = lcl->is_ip4; |
| 187 | listener->c_proto = TRANSPORT_PROTO_UDP; |
| 188 | listener->c_s_index = session_index; |
| 189 | listener->c_fib_index = lcl->fib_index; |
Steven Luong | bf12efc | 2022-07-25 09:29:23 -0700 | [diff] [blame] | 190 | listener->mss = |
| 191 | lcl->mss ? lcl->mss : udp_default_mtu (um, listener->c_is_ip4); |
Florin Coras | 9c4ec6f | 2020-04-01 02:50:13 +0000 | [diff] [blame] | 192 | listener->flags |= UDP_CONN_F_OWNS_PORT | UDP_CONN_F_LISTEN; |
Florin Coras | 87b7e3d | 2020-03-27 15:06:07 +0000 | [diff] [blame] | 193 | lcl_ext = (transport_endpoint_cfg_t *) lcl; |
| 194 | if (lcl_ext->transport_flags & TRANSPORT_CFG_F_CONNECTED) |
| 195 | listener->flags |= UDP_CONN_F_CONNECTED; |
| 196 | else |
| 197 | listener->c_flags |= TRANSPORT_CONNECTION_F_CLESS; |
Florin Coras | 7fb0fe1 | 2018-04-09 09:24:52 -0700 | [diff] [blame] | 198 | clib_spinlock_init (&listener->rx_lock); |
Florin Coras | f8ee39f | 2022-10-18 18:37:56 -0700 | [diff] [blame] | 199 | if (!um->csum_offload) |
| 200 | listener->cfg_flags |= UDP_CFG_F_NO_CSUM_OFFLOAD; |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 201 | |
Florin Coras | e1f2058 | 2022-11-11 11:37:36 -0800 | [diff] [blame] | 202 | udp_connection_register_port (listener->c_lcl_port, lcl->is_ip4); |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 203 | return listener->c_c_index; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 204 | } |
| 205 | |
Florin Coras | c98ef75 | 2020-04-07 17:30:13 +0000 | [diff] [blame] | 206 | static u32 |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 207 | udp_session_unbind (u32 listener_index) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 208 | { |
Florin Coras | a039620 | 2020-04-01 00:11:16 +0000 | [diff] [blame] | 209 | udp_main_t *um = &udp_main; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 210 | udp_connection_t *listener; |
Florin Coras | a039620 | 2020-04-01 00:11:16 +0000 | [diff] [blame] | 211 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 212 | listener = udp_listener_get (listener_index); |
Florin Coras | e1f2058 | 2022-11-11 11:37:36 -0800 | [diff] [blame] | 213 | udp_connection_unregister_port (listener->c_lcl_port, listener->c_is_ip4); |
Florin Coras | 30fdf39 | 2020-12-02 21:14:56 -0800 | [diff] [blame] | 214 | clib_spinlock_free (&listener->rx_lock); |
Florin Coras | a039620 | 2020-04-01 00:11:16 +0000 | [diff] [blame] | 215 | pool_put (um->listener_pool, listener); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 216 | return 0; |
| 217 | } |
| 218 | |
Florin Coras | c98ef75 | 2020-04-07 17:30:13 +0000 | [diff] [blame] | 219 | static transport_connection_t * |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 220 | udp_session_get_listener (u32 listener_index) |
| 221 | { |
| 222 | udp_connection_t *us; |
| 223 | |
| 224 | us = udp_listener_get (listener_index); |
| 225 | return &us->connection; |
| 226 | } |
| 227 | |
Florin Coras | f66cc80 | 2021-04-08 19:10:07 -0700 | [diff] [blame] | 228 | always_inline u32 |
| 229 | udp_push_one_header (vlib_main_t *vm, udp_connection_t *uc, vlib_buffer_t *b) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 230 | { |
Florin Coras | f8ee39f | 2022-10-18 18:37:56 -0700 | [diff] [blame] | 231 | vlib_buffer_push_udp (b, uc->c_lcl_port, uc->c_rmt_port, |
| 232 | udp_csum_offload (uc)); |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 233 | b->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED; |
Florin Coras | 15952b2 | 2022-12-19 10:55:18 -0800 | [diff] [blame] | 234 | |
| 235 | /* Handle ip header now as session layer overwrite connection details for |
| 236 | * non-connected udp. */ |
| 237 | if (uc->c_is_ip4) |
| 238 | vlib_buffer_push_ip4_custom (vm, b, &uc->c_lcl_ip4, &uc->c_rmt_ip4, |
| 239 | IP_PROTOCOL_UDP, udp_csum_offload (uc), |
| 240 | 0 /* is_df */, uc->c_dscp); |
| 241 | else |
| 242 | vlib_buffer_push_ip6 (vm, b, &uc->c_lcl_ip6, &uc->c_rmt_ip6, |
| 243 | IP_PROTOCOL_UDP); |
| 244 | |
Florin Coras | 8c1be05 | 2022-10-17 11:52:34 -0700 | [diff] [blame] | 245 | /* reuse tcp medatada for now */ |
| 246 | vnet_buffer (b)->tcp.connection_index = uc->c_c_index; |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 247 | |
Florin Coras | 15952b2 | 2022-12-19 10:55:18 -0800 | [diff] [blame] | 248 | /* Not connected udp session. Mark buffer for custom handling in |
| 249 | * udp_output */ |
| 250 | if (PREDICT_FALSE (!(uc->flags & UDP_CONN_F_CONNECTED))) |
| 251 | vnet_buffer (b)->tcp.flags |= UDP_CONN_F_LISTEN; |
| 252 | else |
| 253 | vnet_buffer (b)->tcp.flags = 0; |
| 254 | |
Florin Coras | f66cc80 | 2021-04-08 19:10:07 -0700 | [diff] [blame] | 255 | return 0; |
| 256 | } |
| 257 | |
| 258 | static u32 |
| 259 | udp_push_header (transport_connection_t *tc, vlib_buffer_t **bs, u32 n_bufs) |
| 260 | { |
| 261 | vlib_main_t *vm = vlib_get_main (); |
| 262 | udp_connection_t *uc; |
| 263 | |
| 264 | uc = udp_connection_from_transport (tc); |
| 265 | |
| 266 | while (n_bufs >= 4) |
| 267 | { |
| 268 | vlib_prefetch_buffer_header (bs[2], STORE); |
| 269 | vlib_prefetch_buffer_header (bs[3], STORE); |
| 270 | |
| 271 | udp_push_one_header (vm, uc, bs[0]); |
| 272 | udp_push_one_header (vm, uc, bs[1]); |
| 273 | |
| 274 | n_bufs -= 2; |
| 275 | bs += 2; |
| 276 | } |
| 277 | while (n_bufs) |
| 278 | { |
| 279 | if (n_bufs > 1) |
| 280 | vlib_prefetch_buffer_header (bs[1], STORE); |
| 281 | |
| 282 | udp_push_one_header (vm, uc, bs[0]); |
| 283 | |
| 284 | n_bufs -= 1; |
| 285 | bs += 1; |
| 286 | } |
| 287 | |
Florin Coras | c754239 | 2019-07-22 08:08:43 -0700 | [diff] [blame] | 288 | if (PREDICT_FALSE (uc->flags & UDP_CONN_F_CLOSING)) |
| 289 | { |
| 290 | if (!transport_max_tx_dequeue (&uc->connection)) |
Florin Coras | 1c29dfb | 2022-10-24 18:46:20 -0700 | [diff] [blame] | 291 | udp_connection_program_cleanup (uc); |
Florin Coras | c754239 | 2019-07-22 08:08:43 -0700 | [diff] [blame] | 292 | } |
| 293 | |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 294 | return 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 295 | } |
| 296 | |
Florin Coras | c98ef75 | 2020-04-07 17:30:13 +0000 | [diff] [blame] | 297 | static transport_connection_t * |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 298 | udp_session_get (u32 connection_index, u32 thread_index) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 299 | { |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 300 | udp_connection_t *uc; |
| 301 | uc = udp_connection_get (connection_index, thread_index); |
| 302 | if (uc) |
| 303 | return &uc->connection; |
| 304 | return 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 305 | } |
| 306 | |
Florin Coras | c98ef75 | 2020-04-07 17:30:13 +0000 | [diff] [blame] | 307 | static void |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 308 | udp_session_close (u32 connection_index, u32 thread_index) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 309 | { |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 310 | udp_connection_t *uc; |
Florin Coras | c754239 | 2019-07-22 08:08:43 -0700 | [diff] [blame] | 311 | |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 312 | uc = udp_connection_get (connection_index, thread_index); |
Florin Coras | 0200044 | 2021-11-16 12:45:43 -0800 | [diff] [blame] | 313 | if (!uc || (uc->flags & UDP_CONN_F_MIGRATED)) |
Florin Coras | c754239 | 2019-07-22 08:08:43 -0700 | [diff] [blame] | 314 | return; |
| 315 | |
| 316 | if (!transport_max_tx_dequeue (&uc->connection)) |
Florin Coras | 1c29dfb | 2022-10-24 18:46:20 -0700 | [diff] [blame] | 317 | udp_connection_program_cleanup (uc); |
Florin Coras | c754239 | 2019-07-22 08:08:43 -0700 | [diff] [blame] | 318 | else |
| 319 | uc->flags |= UDP_CONN_F_CLOSING; |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 320 | } |
| 321 | |
Florin Coras | c98ef75 | 2020-04-07 17:30:13 +0000 | [diff] [blame] | 322 | static void |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 323 | udp_session_cleanup (u32 connection_index, u32 thread_index) |
| 324 | { |
| 325 | udp_connection_t *uc; |
| 326 | uc = udp_connection_get (connection_index, thread_index); |
Florin Coras | d85666f | 2020-04-03 00:58:48 +0000 | [diff] [blame] | 327 | if (!uc) |
| 328 | return; |
| 329 | if (uc->flags & UDP_CONN_F_MIGRATED) |
| 330 | udp_connection_free (uc); |
| 331 | else |
Florin Coras | 57a5a2d | 2020-04-01 23:16:11 +0000 | [diff] [blame] | 332 | udp_connection_cleanup (uc); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 333 | } |
| 334 | |
Florin Coras | 70f879d | 2020-03-13 17:54:42 +0000 | [diff] [blame] | 335 | static int |
| 336 | udp_session_send_params (transport_connection_t * tconn, |
| 337 | transport_send_params_t * sp) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 338 | { |
Florin Coras | ba78e23 | 2020-04-06 21:28:59 +0000 | [diff] [blame] | 339 | udp_connection_t *uc; |
| 340 | |
Florin Coras | e759bb5 | 2020-04-08 01:55:39 +0000 | [diff] [blame] | 341 | uc = udp_connection_from_transport (tconn); |
Florin Coras | ba78e23 | 2020-04-06 21:28:59 +0000 | [diff] [blame] | 342 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 343 | /* No constraint on TX window */ |
Florin Coras | 70f879d | 2020-03-13 17:54:42 +0000 | [diff] [blame] | 344 | sp->snd_space = ~0; |
| 345 | /* TODO figure out MTU of output interface */ |
Florin Coras | ba78e23 | 2020-04-06 21:28:59 +0000 | [diff] [blame] | 346 | sp->snd_mss = uc->mss; |
Florin Coras | 70f879d | 2020-03-13 17:54:42 +0000 | [diff] [blame] | 347 | sp->tx_offset = 0; |
| 348 | sp->flags = 0; |
| 349 | return 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 350 | } |
| 351 | |
Florin Coras | c98ef75 | 2020-04-07 17:30:13 +0000 | [diff] [blame] | 352 | static int |
Florin Coras | 5665ced | 2018-10-25 18:03:45 -0700 | [diff] [blame] | 353 | udp_open_connection (transport_endpoint_cfg_t * rmt) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 354 | { |
Florin Coras | ba78e23 | 2020-04-06 21:28:59 +0000 | [diff] [blame] | 355 | udp_main_t *um = &udp_main; |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 356 | ip46_address_t lcl_addr; |
Florin Coras | 57660d9 | 2020-04-04 22:45:34 +0000 | [diff] [blame] | 357 | udp_connection_t *uc; |
Florin Coras | c8e4110 | 2022-03-18 10:27:29 -0700 | [diff] [blame] | 358 | u32 thread_index; |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 359 | u16 lcl_port; |
Florin Coras | 00e01d3 | 2019-10-21 16:07:46 -0700 | [diff] [blame] | 360 | int rv; |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 361 | |
Florin Coras | 00e01d3 | 2019-10-21 16:07:46 -0700 | [diff] [blame] | 362 | rv = transport_alloc_local_endpoint (TRANSPORT_PROTO_UDP, rmt, &lcl_addr, |
| 363 | &lcl_port); |
| 364 | if (rv) |
Florin Coras | 3d6156f | 2023-01-30 11:18:36 -0800 | [diff] [blame] | 365 | return rv; |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 366 | |
Florin Coras | d921b89 | 2023-05-25 12:04:53 -0700 | [diff] [blame^] | 367 | if (udp_connection_port_used_extern (clib_net_to_host_u16 (lcl_port), |
| 368 | rmt->is_ip4)) |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 369 | { |
Florin Coras | a039620 | 2020-04-01 00:11:16 +0000 | [diff] [blame] | 370 | /* If specific source port was requested abort */ |
| 371 | if (rmt->peer.port) |
Florin Coras | 3d6156f | 2023-01-30 11:18:36 -0800 | [diff] [blame] | 372 | { |
| 373 | transport_release_local_endpoint (TRANSPORT_PROTO_UDP, &lcl_addr, |
| 374 | lcl_port); |
| 375 | return SESSION_E_PORTINUSE; |
| 376 | } |
Florin Coras | a039620 | 2020-04-01 00:11:16 +0000 | [diff] [blame] | 377 | |
| 378 | /* Try to find a port that's not used */ |
Florin Coras | d921b89 | 2023-05-25 12:04:53 -0700 | [diff] [blame^] | 379 | while (udp_connection_port_used_extern (clib_net_to_host_u16 (lcl_port), |
| 380 | rmt->is_ip4)) |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 381 | { |
Florin Coras | 3d6156f | 2023-01-30 11:18:36 -0800 | [diff] [blame] | 382 | transport_release_local_endpoint (TRANSPORT_PROTO_UDP, &lcl_addr, |
| 383 | lcl_port); |
| 384 | lcl_port = |
| 385 | transport_alloc_local_port (TRANSPORT_PROTO_UDP, &lcl_addr, rmt); |
Florin Coras | a039620 | 2020-04-01 00:11:16 +0000 | [diff] [blame] | 386 | if (lcl_port < 1) |
Florin Coras | 00e01d3 | 2019-10-21 16:07:46 -0700 | [diff] [blame] | 387 | return SESSION_E_PORTINUSE; |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 388 | } |
| 389 | } |
| 390 | |
Florin Coras | 40903ac | 2018-06-10 14:41:23 -0700 | [diff] [blame] | 391 | /* We don't poll main thread if we have workers */ |
Florin Coras | fb50bc3 | 2021-05-18 00:28:59 -0700 | [diff] [blame] | 392 | thread_index = transport_cl_thread (); |
Florin Coras | 40903ac | 2018-06-10 14:41:23 -0700 | [diff] [blame] | 393 | |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 394 | uc = udp_connection_alloc (thread_index); |
| 395 | ip_copy (&uc->c_rmt_ip, &rmt->ip, rmt->is_ip4); |
| 396 | ip_copy (&uc->c_lcl_ip, &lcl_addr, rmt->is_ip4); |
| 397 | uc->c_rmt_port = rmt->port; |
| 398 | uc->c_lcl_port = clib_host_to_net_u16 (lcl_port); |
| 399 | uc->c_is_ip4 = rmt->is_ip4; |
| 400 | uc->c_proto = TRANSPORT_PROTO_UDP; |
| 401 | uc->c_fib_index = rmt->fib_index; |
Filip Tehlar | 3ef8bf3 | 2021-10-21 14:07:31 +0000 | [diff] [blame] | 402 | uc->c_dscp = rmt->dscp; |
Florin Coras | c98ef75 | 2020-04-07 17:30:13 +0000 | [diff] [blame] | 403 | uc->mss = rmt->mss ? rmt->mss : udp_default_mtu (um, uc->c_is_ip4); |
Steven Luong | bf12efc | 2022-07-25 09:29:23 -0700 | [diff] [blame] | 404 | if (rmt->peer.sw_if_index != ENDPOINT_INVALID_INDEX) |
| 405 | uc->sw_if_index = rmt->peer.sw_if_index; |
Florin Coras | c754239 | 2019-07-22 08:08:43 -0700 | [diff] [blame] | 406 | uc->flags |= UDP_CONN_F_OWNS_PORT; |
Florin Coras | 87b7e3d | 2020-03-27 15:06:07 +0000 | [diff] [blame] | 407 | if (rmt->transport_flags & TRANSPORT_CFG_F_CONNECTED) |
Florin Coras | 0ac5782 | 2021-03-03 08:06:12 -0800 | [diff] [blame] | 408 | { |
| 409 | uc->flags |= UDP_CONN_F_CONNECTED; |
| 410 | } |
Florin Coras | 87b7e3d | 2020-03-27 15:06:07 +0000 | [diff] [blame] | 411 | else |
Florin Coras | 0ac5782 | 2021-03-03 08:06:12 -0800 | [diff] [blame] | 412 | { |
| 413 | clib_spinlock_init (&uc->rx_lock); |
| 414 | uc->c_flags |= TRANSPORT_CONNECTION_F_CLESS; |
| 415 | } |
Florin Coras | f8ee39f | 2022-10-18 18:37:56 -0700 | [diff] [blame] | 416 | if (!um->csum_offload) |
| 417 | uc->cfg_flags |= UDP_CFG_F_NO_CSUM_OFFLOAD; |
Florin Coras | 8c1be05 | 2022-10-17 11:52:34 -0700 | [diff] [blame] | 418 | uc->next_node_index = rmt->next_node_index; |
| 419 | uc->next_node_opaque = rmt->next_node_opaque; |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 420 | |
Florin Coras | e1f2058 | 2022-11-11 11:37:36 -0800 | [diff] [blame] | 421 | udp_connection_register_port (uc->c_lcl_port, rmt->is_ip4); |
| 422 | |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 423 | return uc->c_c_index; |
| 424 | } |
| 425 | |
Florin Coras | c98ef75 | 2020-04-07 17:30:13 +0000 | [diff] [blame] | 426 | static transport_connection_t * |
Florin Coras | 40903ac | 2018-06-10 14:41:23 -0700 | [diff] [blame] | 427 | udp_session_get_half_open (u32 conn_index) |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 428 | { |
| 429 | udp_connection_t *uc; |
Florin Coras | 40903ac | 2018-06-10 14:41:23 -0700 | [diff] [blame] | 430 | u32 thread_index; |
| 431 | |
| 432 | /* We don't poll main thread if we have workers */ |
Florin Coras | fb50bc3 | 2021-05-18 00:28:59 -0700 | [diff] [blame] | 433 | thread_index = transport_cl_thread (); |
Florin Coras | 40903ac | 2018-06-10 14:41:23 -0700 | [diff] [blame] | 434 | uc = udp_connection_get (conn_index, thread_index); |
Nathan Skrzypczak | e971bc9 | 2019-06-19 13:42:37 +0200 | [diff] [blame] | 435 | if (!uc) |
| 436 | return 0; |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 437 | return &uc->connection; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 438 | } |
| 439 | |
Florin Coras | c98ef75 | 2020-04-07 17:30:13 +0000 | [diff] [blame] | 440 | static u8 * |
| 441 | format_udp_session (u8 * s, va_list * args) |
| 442 | { |
| 443 | u32 uci = va_arg (*args, u32); |
| 444 | u32 thread_index = va_arg (*args, u32); |
| 445 | u32 verbose = va_arg (*args, u32); |
| 446 | udp_connection_t *uc; |
| 447 | |
| 448 | uc = udp_connection_get (uci, thread_index); |
| 449 | return format (s, "%U", format_udp_connection, uc, verbose); |
| 450 | } |
| 451 | |
| 452 | static u8 * |
| 453 | format_udp_half_open_session (u8 * s, va_list * args) |
| 454 | { |
| 455 | u32 __clib_unused tci = va_arg (*args, u32); |
| 456 | u32 __clib_unused thread_index = va_arg (*args, u32); |
| 457 | clib_warning ("BUG"); |
| 458 | return 0; |
| 459 | } |
| 460 | |
| 461 | static u8 * |
| 462 | format_udp_listener_session (u8 * s, va_list * args) |
| 463 | { |
| 464 | u32 tci = va_arg (*args, u32); |
| 465 | u32 __clib_unused thread_index = va_arg (*args, u32); |
| 466 | u32 verbose = va_arg (*args, u32); |
| 467 | udp_connection_t *uc = udp_listener_get (tci); |
| 468 | return format (s, "%U", format_udp_connection, uc, verbose); |
| 469 | } |
| 470 | |
Florin Coras | 797562c | 2022-11-18 18:29:23 -0800 | [diff] [blame] | 471 | static void |
| 472 | udp_realloc_ports_sv (u16 **ports_nh_svp) |
| 473 | { |
| 474 | u16 port, port_no, *ports_nh_sv, *mc; |
| 475 | u32 *ports = 0, *nh = 0, msum, i; |
| 476 | sparse_vec_header_t *h; |
| 477 | uword sv_index, *mb; |
| 478 | |
| 479 | ports_nh_sv = *ports_nh_svp; |
| 480 | |
| 481 | for (port = 1; port < 65535; port++) |
| 482 | { |
| 483 | port_no = clib_host_to_net_u16 (port); |
| 484 | |
| 485 | sv_index = sparse_vec_index (ports_nh_sv, port_no); |
| 486 | if (sv_index != SPARSE_VEC_INVALID_INDEX) |
| 487 | { |
| 488 | vec_add1 (ports, port_no); |
| 489 | vec_add1 (nh, ports_nh_sv[sv_index]); |
| 490 | } |
| 491 | } |
| 492 | |
| 493 | sparse_vec_free (ports_nh_sv); |
| 494 | |
| 495 | ports_nh_sv = |
| 496 | sparse_vec_new (/* elt bytes */ sizeof (ports_nh_sv[0]), |
| 497 | /* bits in index */ BITS (((udp_header_t *) 0)->dst_port)); |
| 498 | |
| 499 | vec_resize (ports_nh_sv, 65535); |
| 500 | |
| 501 | for (port = 1; port < 65535; port++) |
Florin Coras | e1f2058 | 2022-11-11 11:37:36 -0800 | [diff] [blame] | 502 | ports_nh_sv[port] = UDP_NO_NODE_SET; |
Florin Coras | 797562c | 2022-11-18 18:29:23 -0800 | [diff] [blame] | 503 | |
| 504 | for (i = 0; i < vec_len (ports); i++) |
| 505 | ports_nh_sv[ports[i]] = nh[i]; |
| 506 | |
| 507 | h = sparse_vec_header (ports_nh_sv); |
| 508 | vec_foreach (mb, h->is_member_bitmap) |
| 509 | *mb = (uword) ~0; |
| 510 | |
| 511 | msum = 0; |
| 512 | vec_foreach (mc, h->member_counts) |
| 513 | { |
| 514 | *mc = msum; |
| 515 | msum += msum == 0 ? 63 : 64; |
| 516 | } |
| 517 | |
| 518 | vec_free (ports); |
| 519 | vec_free (nh); |
| 520 | |
| 521 | *ports_nh_svp = ports_nh_sv; |
| 522 | } |
| 523 | |
| 524 | static clib_error_t * |
| 525 | udp_enable_disable (vlib_main_t *vm, u8 is_en) |
| 526 | { |
| 527 | udp_main_t *um = &udp_main; |
| 528 | |
| 529 | /* Not ideal. The sparse vector used to map ports to next nodes assumes |
| 530 | * only a few ports are ever used. When udp transport is enabled this does |
| 531 | * not hold and, to make matters worse, ports are consumed in a random |
| 532 | * order. |
| 533 | * |
| 534 | * This can lead to a lot of slow updates to internal data structures |
| 535 | * which in turn can slow udp connection allocations until all ports are |
| 536 | * eventually consumed. |
| 537 | * |
| 538 | * Consequently, reallocate sparse vector, preallocate all ports and have |
| 539 | * them point to UDP_NO_NODE_SET. We could consider switching the sparse |
| 540 | * vector to a preallocated vector but that would increase memory |
| 541 | * consumption for vpp deployments that do not rely on host stack. |
| 542 | */ |
| 543 | |
| 544 | udp_realloc_ports_sv (&um->next_by_dst_port4); |
| 545 | udp_realloc_ports_sv (&um->next_by_dst_port6); |
| 546 | |
Florin Coras | 9bc72ac | 2023-01-09 12:46:07 -0800 | [diff] [blame] | 547 | vec_validate (um->transport_ports_refcnt[0], 65535); |
| 548 | vec_validate (um->transport_ports_refcnt[1], 65535); |
| 549 | |
Florin Coras | 797562c | 2022-11-18 18:29:23 -0800 | [diff] [blame] | 550 | return 0; |
| 551 | } |
| 552 | |
Nathan Skrzypczak | e971bc9 | 2019-06-19 13:42:37 +0200 | [diff] [blame] | 553 | static const transport_proto_vft_t udp_proto = { |
Florin Coras | 797562c | 2022-11-18 18:29:23 -0800 | [diff] [blame] | 554 | .enable = udp_enable_disable, |
Florin Coras | 1ee7830 | 2019-02-05 15:51:15 -0800 | [diff] [blame] | 555 | .start_listen = udp_session_bind, |
| 556 | .connect = udp_open_connection, |
| 557 | .stop_listen = udp_session_unbind, |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 558 | .push_header = udp_push_header, |
| 559 | .get_connection = udp_session_get, |
| 560 | .get_listener = udp_session_get_listener, |
Florin Coras | 40903ac | 2018-06-10 14:41:23 -0700 | [diff] [blame] | 561 | .get_half_open = udp_session_get_half_open, |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 562 | .close = udp_session_close, |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 563 | .cleanup = udp_session_cleanup, |
Florin Coras | 70f879d | 2020-03-13 17:54:42 +0000 | [diff] [blame] | 564 | .send_params = udp_session_send_params, |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 565 | .format_connection = format_udp_session, |
| 566 | .format_half_open = format_udp_half_open_session, |
Florin Coras | 371ca50 | 2018-02-21 12:07:41 -0800 | [diff] [blame] | 567 | .format_listener = format_udp_listener_session, |
Nathan Skrzypczak | e971bc9 | 2019-06-19 13:42:37 +0200 | [diff] [blame] | 568 | .transport_options = { |
Florin Coras | 07063b8 | 2020-03-13 04:44:51 +0000 | [diff] [blame] | 569 | .name = "udp", |
| 570 | .short_name = "U", |
Nathan Skrzypczak | e971bc9 | 2019-06-19 13:42:37 +0200 | [diff] [blame] | 571 | .tx_type = TRANSPORT_TX_DGRAM, |
| 572 | .service_type = TRANSPORT_SERVICE_CL, |
| 573 | }, |
Florin Coras | 7fb0fe1 | 2018-04-09 09:24:52 -0700 | [diff] [blame] | 574 | }; |
Florin Coras | 7fb0fe1 | 2018-04-09 09:24:52 -0700 | [diff] [blame] | 575 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 576 | static clib_error_t * |
| 577 | udp_init (vlib_main_t * vm) |
| 578 | { |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 579 | udp_main_t *um = vnet_get_udp_main (); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 580 | ip_main_t *im = &ip_main; |
| 581 | vlib_thread_main_t *tm = vlib_get_thread_main (); |
| 582 | u32 num_threads; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 583 | ip_protocol_info_t *pi; |
| 584 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 585 | /* |
| 586 | * Registrations |
| 587 | */ |
| 588 | |
| 589 | /* IP registration */ |
| 590 | pi = ip_get_protocol_info (im, IP_PROTOCOL_UDP); |
| 591 | if (pi == 0) |
| 592 | return clib_error_return (0, "UDP protocol info AWOL"); |
| 593 | pi->format_header = format_udp_header; |
| 594 | pi->unformat_pg_edit = unformat_pg_udp_header; |
| 595 | |
Florin Coras | 8c1be05 | 2022-10-17 11:52:34 -0700 | [diff] [blame] | 596 | /* Register as transport with session layer */ |
Florin Coras | 561af9b | 2017-12-09 10:19:43 -0800 | [diff] [blame] | 597 | transport_register_protocol (TRANSPORT_PROTO_UDP, &udp_proto, |
Florin Coras | 8c1be05 | 2022-10-17 11:52:34 -0700 | [diff] [blame] | 598 | FIB_PROTOCOL_IP4, udp4_output_node.index); |
Florin Coras | 561af9b | 2017-12-09 10:19:43 -0800 | [diff] [blame] | 599 | transport_register_protocol (TRANSPORT_PROTO_UDP, &udp_proto, |
Florin Coras | 8c1be05 | 2022-10-17 11:52:34 -0700 | [diff] [blame] | 600 | FIB_PROTOCOL_IP6, udp6_output_node.index); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 601 | |
| 602 | /* |
| 603 | * Initialize data structures |
| 604 | */ |
| 605 | |
| 606 | num_threads = 1 /* main thread */ + tm->n_threads; |
Florin Coras | 1c29dfb | 2022-10-24 18:46:20 -0700 | [diff] [blame] | 607 | vec_validate (um->wrk, num_threads - 1); |
Florin Coras | a039620 | 2020-04-01 00:11:16 +0000 | [diff] [blame] | 608 | |
| 609 | um->local_to_input_edge[UDP_IP4] = |
| 610 | vlib_node_add_next (vm, udp4_local_node.index, udp4_input_node.index); |
| 611 | um->local_to_input_edge[UDP_IP6] = |
| 612 | vlib_node_add_next (vm, udp6_local_node.index, udp6_input_node.index); |
Florin Coras | ba78e23 | 2020-04-06 21:28:59 +0000 | [diff] [blame] | 613 | |
| 614 | um->default_mtu = 1500; |
Florin Coras | f8ee39f | 2022-10-18 18:37:56 -0700 | [diff] [blame] | 615 | um->csum_offload = 1; |
Dave Barach | f8d5068 | 2019-05-14 18:01:44 -0400 | [diff] [blame] | 616 | return 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 617 | } |
| 618 | |
Dave Barach | f8d5068 | 2019-05-14 18:01:44 -0400 | [diff] [blame] | 619 | /* *INDENT-OFF* */ |
| 620 | VLIB_INIT_FUNCTION (udp_init) = |
| 621 | { |
| 622 | .runs_after = VLIB_INITS("ip_main_init", "ip4_lookup_init", |
| 623 | "ip6_lookup_init"), |
| 624 | }; |
| 625 | /* *INDENT-ON* */ |
| 626 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 627 | /* |
| 628 | * fd.io coding-style-patch-verification: ON |
| 629 | * |
| 630 | * Local Variables: |
| 631 | * eval: (c-set-style "gnu") |
| 632 | * End: |
| 633 | */ |