Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1 | /* |
Florin Coras | c5df8c7 | 2019-04-08 07:42:30 -0700 | [diff] [blame] | 2 | * Copyright (c) 2016-2019 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 | |
| 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 | |
Filip Tehlar | 2c49ffe | 2019-03-06 07:16:08 -0800 | [diff] [blame] | 25 | udp_main_t udp_main; |
| 26 | |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 27 | udp_connection_t * |
| 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, |
| 34 | CLIB_CACHE_LINE_BYTES); |
| 35 | |
| 36 | if (PREDICT_FALSE (will_expand)) |
| 37 | { |
| 38 | clib_spinlock_lock_if_init (&udp_main.peekers_write_locks |
| 39 | [thread_index]); |
| 40 | pool_get_aligned (udp_main.connections[thread_index], uc, |
| 41 | CLIB_CACHE_LINE_BYTES); |
| 42 | clib_spinlock_unlock_if_init (&udp_main.peekers_write_locks |
| 43 | [thread_index]); |
| 44 | } |
| 45 | else |
| 46 | { |
| 47 | pool_get_aligned (um->connections[thread_index], uc, |
| 48 | CLIB_CACHE_LINE_BYTES); |
| 49 | } |
Dave Barach | b7b9299 | 2018-10-17 10:38:51 -0400 | [diff] [blame] | 50 | clib_memset (uc, 0, sizeof (*uc)); |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 51 | uc->c_c_index = uc - um->connections[thread_index]; |
| 52 | uc->c_thread_index = thread_index; |
| 53 | uc->c_proto = TRANSPORT_PROTO_UDP; |
Florin Coras | 7fb0fe1 | 2018-04-09 09:24:52 -0700 | [diff] [blame] | 54 | clib_spinlock_init (&uc->rx_lock); |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 55 | return uc; |
| 56 | } |
| 57 | |
| 58 | void |
| 59 | udp_connection_free (udp_connection_t * uc) |
| 60 | { |
Benoît Ganne | d4aeb84 | 2019-07-18 18:38:42 +0200 | [diff] [blame] | 61 | u32 thread_index = uc->c_thread_index; |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 62 | if (CLIB_DEBUG) |
Dave Barach | b7b9299 | 2018-10-17 10:38:51 -0400 | [diff] [blame] | 63 | clib_memset (uc, 0xFA, sizeof (*uc)); |
Benoît Ganne | d4aeb84 | 2019-07-18 18:38:42 +0200 | [diff] [blame] | 64 | pool_put (udp_main.connections[thread_index], uc); |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 65 | } |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 66 | |
Florin Coras | c754239 | 2019-07-22 08:08:43 -0700 | [diff] [blame] | 67 | void |
| 68 | udp_connection_delete (udp_connection_t * uc) |
| 69 | { |
| 70 | if ((uc->flags & UDP_CONN_F_OWNS_PORT) |
| 71 | || !(uc->flags & UDP_CONN_F_CONNECTED)) |
| 72 | udp_unregister_dst_port (vlib_get_main (), |
| 73 | clib_net_to_host_u16 (uc->c_lcl_port), |
| 74 | uc->c_is_ip4); |
| 75 | session_transport_delete_notify (&uc->connection); |
| 76 | udp_connection_free (uc); |
| 77 | } |
| 78 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 79 | u32 |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 80 | udp_session_bind (u32 session_index, transport_endpoint_t * lcl) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 81 | { |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 82 | udp_main_t *um = vnet_get_udp_main (); |
| 83 | vlib_main_t *vm = vlib_get_main (); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 84 | udp_connection_t *listener; |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 85 | u32 node_index; |
| 86 | void *iface_ip; |
| 87 | udp_dst_port_info_t *pi; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 88 | |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 89 | pi = udp_get_dst_port_info (um, lcl->port, lcl->is_ip4); |
| 90 | if (pi) |
| 91 | return -1; |
| 92 | |
| 93 | pool_get (um->listener_pool, listener); |
Dave Barach | b7b9299 | 2018-10-17 10:38:51 -0400 | [diff] [blame] | 94 | clib_memset (listener, 0, sizeof (udp_connection_t)); |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 95 | |
Florin Coras | 0e49568 | 2017-09-19 22:27:18 -0700 | [diff] [blame] | 96 | listener->c_lcl_port = lcl->port; |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 97 | listener->c_c_index = listener - um->listener_pool; |
| 98 | |
| 99 | /* If we are provided a sw_if_index, bind using one of its ips */ |
| 100 | if (ip_is_zero (&lcl->ip, 1) && lcl->sw_if_index != ENDPOINT_INVALID_INDEX) |
| 101 | { |
| 102 | if ((iface_ip = ip_interface_get_first_ip (lcl->sw_if_index, |
| 103 | lcl->is_ip4))) |
| 104 | ip_set (&lcl->ip, iface_ip, lcl->is_ip4); |
| 105 | } |
| 106 | ip_copy (&listener->c_lcl_ip, &lcl->ip, lcl->is_ip4); |
| 107 | listener->c_is_ip4 = lcl->is_ip4; |
| 108 | listener->c_proto = TRANSPORT_PROTO_UDP; |
| 109 | listener->c_s_index = session_index; |
| 110 | listener->c_fib_index = lcl->fib_index; |
Florin Coras | c754239 | 2019-07-22 08:08:43 -0700 | [diff] [blame] | 111 | listener->flags |= UDP_CONN_F_OWNS_PORT; |
Florin Coras | 7fb0fe1 | 2018-04-09 09:24:52 -0700 | [diff] [blame] | 112 | clib_spinlock_init (&listener->rx_lock); |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 113 | |
| 114 | node_index = lcl->is_ip4 ? udp4_input_node.index : udp6_input_node.index; |
| 115 | udp_register_dst_port (vm, clib_net_to_host_u16 (lcl->port), node_index, |
Florin Coras | ff2fad1 | 2020-01-15 02:32:07 +0000 | [diff] [blame] | 116 | lcl->is_ip4); |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 117 | return listener->c_c_index; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 118 | } |
| 119 | |
| 120 | u32 |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 121 | udp_session_unbind (u32 listener_index) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 122 | { |
Florin Coras | e69f495 | 2017-03-07 10:06:24 -0800 | [diff] [blame] | 123 | vlib_main_t *vm = vlib_get_main (); |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 124 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 125 | udp_connection_t *listener; |
| 126 | listener = udp_listener_get (listener_index); |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 127 | udp_unregister_dst_port (vm, clib_net_to_host_u16 (listener->c_lcl_port), |
| 128 | listener->c_is_ip4); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 129 | return 0; |
| 130 | } |
| 131 | |
| 132 | transport_connection_t * |
| 133 | udp_session_get_listener (u32 listener_index) |
| 134 | { |
| 135 | udp_connection_t *us; |
| 136 | |
| 137 | us = udp_listener_get (listener_index); |
| 138 | return &us->connection; |
| 139 | } |
| 140 | |
| 141 | u32 |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 142 | udp_push_header (transport_connection_t * tc, vlib_buffer_t * b) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 143 | { |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 144 | udp_connection_t *uc; |
| 145 | vlib_main_t *vm = vlib_get_main (); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 146 | |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 147 | uc = udp_get_connection_from_transport (tc); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 148 | |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 149 | vlib_buffer_push_udp (b, uc->c_lcl_port, uc->c_rmt_port, 1); |
| 150 | if (tc->is_ip4) |
| 151 | vlib_buffer_push_ip4 (vm, b, &uc->c_lcl_ip4, &uc->c_rmt_ip4, |
| 152 | IP_PROTOCOL_UDP, 1); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 153 | else |
| 154 | { |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 155 | ip6_header_t *ih; |
| 156 | ih = vlib_buffer_push_ip6 (vm, b, &uc->c_lcl_ip6, &uc->c_rmt_ip6, |
| 157 | IP_PROTOCOL_UDP); |
| 158 | vnet_buffer (b)->l3_hdr_offset = (u8 *) ih - b->data; |
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 | vnet_buffer (b)->sw_if_index[VLIB_RX] = 0; |
Florin Coras | 7fb0fe1 | 2018-04-09 09:24:52 -0700 | [diff] [blame] | 161 | vnet_buffer (b)->sw_if_index[VLIB_TX] = uc->c_fib_index; |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 162 | b->flags |= VNET_BUFFER_F_LOCALLY_ORIGINATED; |
| 163 | |
Florin Coras | c754239 | 2019-07-22 08:08:43 -0700 | [diff] [blame] | 164 | if (PREDICT_FALSE (uc->flags & UDP_CONN_F_CLOSING)) |
| 165 | { |
| 166 | if (!transport_max_tx_dequeue (&uc->connection)) |
| 167 | udp_connection_delete (uc); |
| 168 | } |
| 169 | |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 170 | return 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 171 | } |
| 172 | |
| 173 | transport_connection_t * |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 174 | udp_session_get (u32 connection_index, u32 thread_index) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 175 | { |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 176 | udp_connection_t *uc; |
| 177 | uc = udp_connection_get (connection_index, thread_index); |
| 178 | if (uc) |
| 179 | return &uc->connection; |
| 180 | return 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 181 | } |
| 182 | |
| 183 | void |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 184 | udp_session_close (u32 connection_index, u32 thread_index) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 185 | { |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 186 | udp_connection_t *uc; |
Florin Coras | c754239 | 2019-07-22 08:08:43 -0700 | [diff] [blame] | 187 | |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 188 | uc = udp_connection_get (connection_index, thread_index); |
Florin Coras | c754239 | 2019-07-22 08:08:43 -0700 | [diff] [blame] | 189 | if (!uc) |
| 190 | return; |
| 191 | |
| 192 | if (!transport_max_tx_dequeue (&uc->connection)) |
| 193 | udp_connection_delete (uc); |
| 194 | else |
| 195 | uc->flags |= UDP_CONN_F_CLOSING; |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 196 | } |
| 197 | |
| 198 | void |
| 199 | udp_session_cleanup (u32 connection_index, u32 thread_index) |
| 200 | { |
| 201 | udp_connection_t *uc; |
| 202 | uc = udp_connection_get (connection_index, thread_index); |
| 203 | if (uc) |
| 204 | udp_connection_free (uc); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 205 | } |
| 206 | |
| 207 | u8 * |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 208 | format_udp_connection_id (u8 * s, va_list * args) |
| 209 | { |
| 210 | udp_connection_t *uc = va_arg (*args, udp_connection_t *); |
| 211 | if (!uc) |
| 212 | return s; |
| 213 | if (uc->c_is_ip4) |
| 214 | s = format (s, "[#%d][%s] %U:%d->%U:%d", uc->c_thread_index, "U", |
| 215 | format_ip4_address, &uc->c_lcl_ip4, |
| 216 | clib_net_to_host_u16 (uc->c_lcl_port), format_ip4_address, |
| 217 | &uc->c_rmt_ip4, clib_net_to_host_u16 (uc->c_rmt_port)); |
| 218 | else |
| 219 | s = format (s, "[#%d][%s] %U:%d->%U:%d", uc->c_thread_index, "U", |
| 220 | format_ip6_address, &uc->c_lcl_ip6, |
| 221 | clib_net_to_host_u16 (uc->c_lcl_port), format_ip6_address, |
| 222 | &uc->c_rmt_ip6, clib_net_to_host_u16 (uc->c_rmt_port)); |
| 223 | return s; |
| 224 | } |
| 225 | |
| 226 | u8 * |
| 227 | format_udp_connection (u8 * s, va_list * args) |
| 228 | { |
| 229 | udp_connection_t *uc = va_arg (*args, udp_connection_t *); |
| 230 | u32 verbose = va_arg (*args, u32); |
| 231 | if (!uc) |
| 232 | return s; |
| 233 | s = format (s, "%-50U", format_udp_connection_id, uc); |
| 234 | if (verbose) |
| 235 | { |
| 236 | if (verbose == 1) |
Aloys Augustin | 95dd1fe | 2019-07-12 17:11:04 +0200 | [diff] [blame] | 237 | s = format (s, "%-15s", "-"); |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 238 | else |
| 239 | s = format (s, "\n"); |
| 240 | } |
| 241 | return s; |
| 242 | } |
| 243 | |
| 244 | u8 * |
| 245 | format_udp_session (u8 * s, va_list * args) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 246 | { |
| 247 | u32 uci = va_arg (*args, u32); |
| 248 | u32 thread_index = va_arg (*args, u32); |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 249 | u32 verbose = va_arg (*args, u32); |
| 250 | udp_connection_t *uc; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 251 | |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 252 | uc = udp_connection_get (uci, thread_index); |
| 253 | return format (s, "%U", format_udp_connection, uc, verbose); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 254 | } |
| 255 | |
| 256 | u8 * |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 257 | format_udp_half_open_session (u8 * s, va_list * args) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 258 | { |
Dave Wallace | 3df5682 | 2019-05-22 18:56:57 -0400 | [diff] [blame] | 259 | u32 __clib_unused tci = va_arg (*args, u32); |
Aloys Augustin | a0abbff | 2019-07-12 12:16:16 +0200 | [diff] [blame] | 260 | u32 __clib_unused thread_index = va_arg (*args, u32); |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 261 | clib_warning ("BUG"); |
| 262 | return 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 263 | } |
| 264 | |
| 265 | u8 * |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 266 | format_udp_listener_session (u8 * s, va_list * args) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 267 | { |
| 268 | u32 tci = va_arg (*args, u32); |
Aloys Augustin | a0abbff | 2019-07-12 12:16:16 +0200 | [diff] [blame] | 269 | u32 __clib_unused thread_index = va_arg (*args, u32); |
Aloys Augustin | 95dd1fe | 2019-07-12 17:11:04 +0200 | [diff] [blame] | 270 | u32 verbose = va_arg (*args, u32); |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 271 | udp_connection_t *uc = udp_listener_get (tci); |
Aloys Augustin | 95dd1fe | 2019-07-12 17:11:04 +0200 | [diff] [blame] | 272 | return format (s, "%U", format_udp_connection, uc, verbose); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 273 | } |
| 274 | |
| 275 | u16 |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 276 | udp_send_mss (transport_connection_t * t) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 277 | { |
| 278 | /* TODO figure out MTU of output interface */ |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 279 | return 1460; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 280 | } |
| 281 | |
| 282 | u32 |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 283 | udp_send_space (transport_connection_t * t) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 284 | { |
| 285 | /* No constraint on TX window */ |
| 286 | return ~0; |
| 287 | } |
| 288 | |
| 289 | int |
Florin Coras | 5665ced | 2018-10-25 18:03:45 -0700 | [diff] [blame] | 290 | udp_open_connection (transport_endpoint_cfg_t * rmt) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 291 | { |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 292 | udp_main_t *um = vnet_get_udp_main (); |
| 293 | vlib_main_t *vm = vlib_get_main (); |
Damjan Marion | 067cd62 | 2018-07-11 12:47:43 +0200 | [diff] [blame] | 294 | u32 thread_index = vm->thread_index; |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 295 | udp_connection_t *uc; |
| 296 | ip46_address_t lcl_addr; |
| 297 | u32 node_index; |
| 298 | u16 lcl_port; |
| 299 | |
| 300 | if (transport_alloc_local_endpoint (TRANSPORT_PROTO_UDP, rmt, &lcl_addr, |
| 301 | &lcl_port)) |
| 302 | return -1; |
| 303 | |
| 304 | while (udp_get_dst_port_info (um, lcl_port, rmt->is_ip4)) |
| 305 | { |
| 306 | lcl_port = transport_alloc_local_port (TRANSPORT_PROTO_UDP, &lcl_addr); |
| 307 | if (lcl_port < 1) |
| 308 | { |
| 309 | clib_warning ("Failed to allocate src port"); |
| 310 | return -1; |
| 311 | } |
| 312 | } |
| 313 | |
| 314 | node_index = rmt->is_ip4 ? udp4_input_node.index : udp6_input_node.index; |
| 315 | udp_register_dst_port (vm, lcl_port, node_index, 1 /* is_ipv4 */ ); |
| 316 | |
Florin Coras | 40903ac | 2018-06-10 14:41:23 -0700 | [diff] [blame] | 317 | /* We don't poll main thread if we have workers */ |
| 318 | if (vlib_num_workers ()) |
| 319 | thread_index = 1; |
| 320 | |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 321 | uc = udp_connection_alloc (thread_index); |
| 322 | ip_copy (&uc->c_rmt_ip, &rmt->ip, rmt->is_ip4); |
| 323 | ip_copy (&uc->c_lcl_ip, &lcl_addr, rmt->is_ip4); |
| 324 | uc->c_rmt_port = rmt->port; |
| 325 | uc->c_lcl_port = clib_host_to_net_u16 (lcl_port); |
| 326 | uc->c_is_ip4 = rmt->is_ip4; |
| 327 | uc->c_proto = TRANSPORT_PROTO_UDP; |
| 328 | uc->c_fib_index = rmt->fib_index; |
Florin Coras | c754239 | 2019-07-22 08:08:43 -0700 | [diff] [blame] | 329 | uc->flags |= UDP_CONN_F_OWNS_PORT; |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 330 | |
| 331 | return uc->c_c_index; |
| 332 | } |
| 333 | |
| 334 | transport_connection_t * |
Florin Coras | 40903ac | 2018-06-10 14:41:23 -0700 | [diff] [blame] | 335 | udp_session_get_half_open (u32 conn_index) |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 336 | { |
| 337 | udp_connection_t *uc; |
Florin Coras | 40903ac | 2018-06-10 14:41:23 -0700 | [diff] [blame] | 338 | u32 thread_index; |
| 339 | |
| 340 | /* We don't poll main thread if we have workers */ |
| 341 | thread_index = vlib_num_workers ()? 1 : 0; |
| 342 | uc = udp_connection_get (conn_index, thread_index); |
Nathan Skrzypczak | e971bc9 | 2019-06-19 13:42:37 +0200 | [diff] [blame] | 343 | if (!uc) |
| 344 | return 0; |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 345 | return &uc->connection; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 346 | } |
| 347 | |
| 348 | /* *INDENT-OFF* */ |
Nathan Skrzypczak | e971bc9 | 2019-06-19 13:42:37 +0200 | [diff] [blame] | 349 | static const transport_proto_vft_t udp_proto = { |
Florin Coras | 1ee7830 | 2019-02-05 15:51:15 -0800 | [diff] [blame] | 350 | .start_listen = udp_session_bind, |
| 351 | .connect = udp_open_connection, |
| 352 | .stop_listen = udp_session_unbind, |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 353 | .push_header = udp_push_header, |
| 354 | .get_connection = udp_session_get, |
| 355 | .get_listener = udp_session_get_listener, |
Florin Coras | 40903ac | 2018-06-10 14:41:23 -0700 | [diff] [blame] | 356 | .get_half_open = udp_session_get_half_open, |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 357 | .close = udp_session_close, |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 358 | .cleanup = udp_session_cleanup, |
| 359 | .send_mss = udp_send_mss, |
| 360 | .send_space = udp_send_space, |
| 361 | .format_connection = format_udp_session, |
| 362 | .format_half_open = format_udp_half_open_session, |
Florin Coras | 371ca50 | 2018-02-21 12:07:41 -0800 | [diff] [blame] | 363 | .format_listener = format_udp_listener_session, |
Nathan Skrzypczak | e971bc9 | 2019-06-19 13:42:37 +0200 | [diff] [blame] | 364 | .transport_options = { |
| 365 | .tx_type = TRANSPORT_TX_DGRAM, |
| 366 | .service_type = TRANSPORT_SERVICE_CL, |
| 367 | }, |
Florin Coras | 7fb0fe1 | 2018-04-09 09:24:52 -0700 | [diff] [blame] | 368 | }; |
| 369 | /* *INDENT-ON* */ |
| 370 | |
| 371 | |
| 372 | int |
Florin Coras | 5665ced | 2018-10-25 18:03:45 -0700 | [diff] [blame] | 373 | udpc_connection_open (transport_endpoint_cfg_t * rmt) |
Florin Coras | 7fb0fe1 | 2018-04-09 09:24:52 -0700 | [diff] [blame] | 374 | { |
| 375 | udp_connection_t *uc; |
Aloys Augustin | 8e58499 | 2019-04-24 13:21:43 +0200 | [diff] [blame] | 376 | /* Reproduce the logic of udp_open_connection to find the correct thread */ |
| 377 | u32 thread_index = vlib_num_workers ()? 1 : vlib_get_main ()->thread_index; |
Florin Coras | 7fb0fe1 | 2018-04-09 09:24:52 -0700 | [diff] [blame] | 378 | u32 uc_index; |
| 379 | uc_index = udp_open_connection (rmt); |
Nathan Skrzypczak | 50f4a41 | 2019-07-04 14:20:17 +0200 | [diff] [blame] | 380 | if (uc_index == (u32) ~ 0) |
| 381 | return -1; |
Aloys Augustin | 8e58499 | 2019-04-24 13:21:43 +0200 | [diff] [blame] | 382 | uc = udp_connection_get (uc_index, thread_index); |
Florin Coras | c754239 | 2019-07-22 08:08:43 -0700 | [diff] [blame] | 383 | uc->flags |= UDP_CONN_F_CONNECTED; |
Florin Coras | 7fb0fe1 | 2018-04-09 09:24:52 -0700 | [diff] [blame] | 384 | return uc_index; |
| 385 | } |
| 386 | |
| 387 | u32 |
| 388 | udpc_connection_listen (u32 session_index, transport_endpoint_t * lcl) |
| 389 | { |
| 390 | udp_connection_t *listener; |
Nathan Skrzypczak | 50f4a41 | 2019-07-04 14:20:17 +0200 | [diff] [blame] | 391 | u32 li_index; |
| 392 | li_index = udp_session_bind (session_index, lcl); |
| 393 | if (li_index == (u32) ~ 0) |
| 394 | return -1; |
| 395 | listener = udp_listener_get (li_index); |
Florin Coras | c754239 | 2019-07-22 08:08:43 -0700 | [diff] [blame] | 396 | listener->flags |= UDP_CONN_F_CONNECTED; |
Florin Coras | 95cd864 | 2019-12-30 21:53:19 -0800 | [diff] [blame] | 397 | /* Fake udp listener, i.e., make sure session layer adds a udp instead of |
| 398 | * udpc listener to the lookup table */ |
| 399 | ((session_endpoint_cfg_t *) lcl)->transport_proto = TRANSPORT_PROTO_UDP; |
Nathan Skrzypczak | 50f4a41 | 2019-07-04 14:20:17 +0200 | [diff] [blame] | 400 | return li_index; |
Florin Coras | 7fb0fe1 | 2018-04-09 09:24:52 -0700 | [diff] [blame] | 401 | } |
| 402 | |
| 403 | /* *INDENT-OFF* */ |
Nathan Skrzypczak | e971bc9 | 2019-06-19 13:42:37 +0200 | [diff] [blame] | 404 | static const transport_proto_vft_t udpc_proto = { |
Florin Coras | 1ee7830 | 2019-02-05 15:51:15 -0800 | [diff] [blame] | 405 | .start_listen = udpc_connection_listen, |
| 406 | .stop_listen = udp_session_unbind, |
| 407 | .connect = udpc_connection_open, |
Florin Coras | 7fb0fe1 | 2018-04-09 09:24:52 -0700 | [diff] [blame] | 408 | .push_header = udp_push_header, |
| 409 | .get_connection = udp_session_get, |
| 410 | .get_listener = udp_session_get_listener, |
Florin Coras | 40903ac | 2018-06-10 14:41:23 -0700 | [diff] [blame] | 411 | .get_half_open = udp_session_get_half_open, |
Florin Coras | 7fb0fe1 | 2018-04-09 09:24:52 -0700 | [diff] [blame] | 412 | .close = udp_session_close, |
| 413 | .cleanup = udp_session_cleanup, |
| 414 | .send_mss = udp_send_mss, |
| 415 | .send_space = udp_send_space, |
| 416 | .format_connection = format_udp_session, |
| 417 | .format_half_open = format_udp_half_open_session, |
| 418 | .format_listener = format_udp_listener_session, |
Nathan Skrzypczak | e971bc9 | 2019-06-19 13:42:37 +0200 | [diff] [blame] | 419 | .transport_options = { |
| 420 | .tx_type = TRANSPORT_TX_DGRAM, |
| 421 | .service_type = TRANSPORT_SERVICE_VC, |
Nathan Skrzypczak | a26349d | 2019-06-26 13:53:08 +0200 | [diff] [blame] | 422 | .half_open_has_fifos = 1 |
Nathan Skrzypczak | e971bc9 | 2019-06-19 13:42:37 +0200 | [diff] [blame] | 423 | }, |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 424 | }; |
| 425 | /* *INDENT-ON* */ |
| 426 | |
| 427 | static clib_error_t * |
| 428 | udp_init (vlib_main_t * vm) |
| 429 | { |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 430 | udp_main_t *um = vnet_get_udp_main (); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 431 | ip_main_t *im = &ip_main; |
| 432 | vlib_thread_main_t *tm = vlib_get_thread_main (); |
| 433 | u32 num_threads; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 434 | ip_protocol_info_t *pi; |
Florin Coras | 29ca16f | 2017-11-02 18:14:17 -0400 | [diff] [blame] | 435 | int i; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 436 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 437 | /* |
| 438 | * Registrations |
| 439 | */ |
| 440 | |
| 441 | /* IP registration */ |
| 442 | pi = ip_get_protocol_info (im, IP_PROTOCOL_UDP); |
| 443 | if (pi == 0) |
| 444 | return clib_error_return (0, "UDP protocol info AWOL"); |
| 445 | pi->format_header = format_udp_header; |
| 446 | pi->unformat_pg_edit = unformat_pg_udp_header; |
| 447 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 448 | /* Register as transport with URI */ |
Florin Coras | 561af9b | 2017-12-09 10:19:43 -0800 | [diff] [blame] | 449 | transport_register_protocol (TRANSPORT_PROTO_UDP, &udp_proto, |
| 450 | FIB_PROTOCOL_IP4, ip4_lookup_node.index); |
| 451 | transport_register_protocol (TRANSPORT_PROTO_UDP, &udp_proto, |
| 452 | FIB_PROTOCOL_IP6, ip6_lookup_node.index); |
Florin Coras | 7fb0fe1 | 2018-04-09 09:24:52 -0700 | [diff] [blame] | 453 | transport_register_protocol (TRANSPORT_PROTO_UDPC, &udpc_proto, |
| 454 | FIB_PROTOCOL_IP4, ip4_lookup_node.index); |
| 455 | transport_register_protocol (TRANSPORT_PROTO_UDPC, &udpc_proto, |
| 456 | FIB_PROTOCOL_IP6, ip6_lookup_node.index); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 457 | |
| 458 | /* |
| 459 | * Initialize data structures |
| 460 | */ |
| 461 | |
| 462 | num_threads = 1 /* main thread */ + tm->n_threads; |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 463 | vec_validate (um->connections, num_threads - 1); |
| 464 | vec_validate (um->connection_peekers, num_threads - 1); |
| 465 | vec_validate (um->peekers_readers_locks, num_threads - 1); |
| 466 | vec_validate (um->peekers_write_locks, num_threads - 1); |
Florin Coras | 29ca16f | 2017-11-02 18:14:17 -0400 | [diff] [blame] | 467 | |
| 468 | if (num_threads > 1) |
| 469 | for (i = 0; i < num_threads; i++) |
| 470 | { |
| 471 | clib_spinlock_init (&um->peekers_readers_locks[i]); |
| 472 | clib_spinlock_init (&um->peekers_write_locks[i]); |
| 473 | } |
Dave Barach | f8d5068 | 2019-05-14 18:01:44 -0400 | [diff] [blame] | 474 | return 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 475 | } |
| 476 | |
Dave Barach | f8d5068 | 2019-05-14 18:01:44 -0400 | [diff] [blame] | 477 | /* *INDENT-OFF* */ |
| 478 | VLIB_INIT_FUNCTION (udp_init) = |
| 479 | { |
| 480 | .runs_after = VLIB_INITS("ip_main_init", "ip4_lookup_init", |
| 481 | "ip6_lookup_init"), |
| 482 | }; |
| 483 | /* *INDENT-ON* */ |
| 484 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 485 | |
Pavel Kotucek | e88865d | 2018-11-28 07:42:11 +0100 | [diff] [blame] | 486 | static clib_error_t * |
| 487 | show_udp_punt_fn (vlib_main_t * vm, unformat_input_t * input, |
| 488 | vlib_cli_command_t * cmd_arg) |
| 489 | { |
| 490 | udp_main_t *um = vnet_get_udp_main (); |
| 491 | |
| 492 | clib_error_t *error = NULL; |
| 493 | |
| 494 | if (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) |
| 495 | return clib_error_return (0, "unknown input `%U'", format_unformat_error, |
| 496 | input); |
| 497 | |
| 498 | udp_dst_port_info_t *port_info; |
| 499 | if (um->punt_unknown4) |
| 500 | { |
| 501 | vlib_cli_output (vm, "IPv4 UDP punt: enabled"); |
| 502 | } |
| 503 | else |
| 504 | { |
| 505 | u8 *s = NULL; |
| 506 | vec_foreach (port_info, um->dst_port_infos[UDP_IP4]) |
| 507 | { |
| 508 | if (udp_is_valid_dst_port (port_info->dst_port, 1)) |
| 509 | { |
| 510 | s = format (s, (!s) ? "%d" : ", %d", port_info->dst_port); |
| 511 | } |
| 512 | } |
| 513 | s = format (s, "%c", 0); |
| 514 | vlib_cli_output (vm, "IPV4 UDP ports punt : %s", s); |
| 515 | } |
| 516 | |
| 517 | if (um->punt_unknown6) |
| 518 | { |
| 519 | vlib_cli_output (vm, "IPv6 UDP punt: enabled"); |
| 520 | } |
| 521 | else |
| 522 | { |
| 523 | u8 *s = NULL; |
| 524 | vec_foreach (port_info, um->dst_port_infos[UDP_IP6]) |
| 525 | { |
| 526 | if (udp_is_valid_dst_port (port_info->dst_port, 01)) |
| 527 | { |
| 528 | s = format (s, (!s) ? "%d" : ", %d", port_info->dst_port); |
| 529 | } |
| 530 | } |
| 531 | s = format (s, "%c", 0); |
| 532 | vlib_cli_output (vm, "IPV6 UDP ports punt : %s", s); |
| 533 | } |
| 534 | |
| 535 | return (error); |
| 536 | } |
| 537 | /* *INDENT-OFF* */ |
| 538 | VLIB_CLI_COMMAND (show_tcp_punt_command, static) = |
| 539 | { |
| 540 | .path = "show udp punt", |
| 541 | .short_help = "show udp punt [ipv4|ipv6]", |
| 542 | .function = show_udp_punt_fn, |
| 543 | }; |
| 544 | /* *INDENT-ON* */ |
| 545 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 546 | /* |
| 547 | * fd.io coding-style-patch-verification: ON |
| 548 | * |
| 549 | * Local Variables: |
| 550 | * eval: (c-set-style "gnu") |
| 551 | * End: |
| 552 | */ |