Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 1 | /* |
| 2 | *------------------------------------------------------------------ |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 3 | * socket_api.c |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 4 | * |
| 5 | * Copyright (c) 2009 Cisco and/or its affiliates. |
| 6 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 7 | * you may not use this file except in compliance with the License. |
| 8 | * You may obtain a copy of the License at: |
| 9 | * |
| 10 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 11 | * |
| 12 | * Unless required by applicable law or agreed to in writing, software |
| 13 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 14 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 15 | * See the License for the specific language governing permissions and |
| 16 | * limitations under the License. |
| 17 | *------------------------------------------------------------------ |
| 18 | */ |
| 19 | |
| 20 | #include <sys/types.h> |
| 21 | #include <sys/socket.h> |
| 22 | #include <netinet/in.h> |
| 23 | #include <sys/ioctl.h> |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 24 | #include <fcntl.h> |
| 25 | #include <sys/stat.h> |
| 26 | |
Florin Coras | e86a8ed | 2018-01-05 03:20:25 -0800 | [diff] [blame] | 27 | #include <vppinfra/byte_order.h> |
Florin Coras | 4d9b9d8 | 2018-01-14 12:25:50 -0800 | [diff] [blame] | 28 | #include <svm/ssvm.h> |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 29 | #include <vlibmemory/api.h> |
| 30 | |
| 31 | #include <vlibmemory/vl_memory_msg_enum.h> |
| 32 | |
| 33 | #define vl_typedefs /* define message structures */ |
| 34 | #include <vlibmemory/vl_memory_api_h.h> |
| 35 | #undef vl_typedefs |
| 36 | |
| 37 | /* instantiate all the print functions we know about */ |
| 38 | #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__) |
| 39 | #define vl_printfun |
| 40 | #include <vlibmemory/vl_memory_api_h.h> |
| 41 | #undef vl_printfun |
| 42 | |
| 43 | /* instantiate all the endian swap functions we know about */ |
| 44 | #define vl_endianfun |
| 45 | #include <vlibmemory/vl_memory_api_h.h> |
| 46 | #undef vl_endianfun |
| 47 | |
Klement Sekera | 9b7e8ac | 2021-11-22 21:26:20 +0100 | [diff] [blame] | 48 | #define vl_calcsizefun |
| 49 | #include <vlibmemory/vl_memory_api_h.h> |
| 50 | #undef vl_calcsizefun |
| 51 | |
Florin Coras | e86a8ed | 2018-01-05 03:20:25 -0800 | [diff] [blame] | 52 | socket_main_t socket_main; |
| 53 | |
Florin Coras | 2881dec | 2018-10-02 18:29:25 -0700 | [diff] [blame] | 54 | #define SOCK_API_REG_HANDLE_BIT (1<<31) |
| 55 | |
| 56 | static u32 |
| 57 | sock_api_registration_handle (vl_api_registration_t * regp) |
| 58 | { |
| 59 | ASSERT (regp->vl_api_registration_pool_index < SOCK_API_REG_HANDLE_BIT); |
| 60 | return regp->vl_api_registration_pool_index | SOCK_API_REG_HANDLE_BIT; |
| 61 | } |
| 62 | |
| 63 | static u32 |
| 64 | socket_api_registration_handle_to_index (u32 reg_index) |
| 65 | { |
| 66 | return (reg_index & ~SOCK_API_REG_HANDLE_BIT); |
| 67 | } |
| 68 | |
| 69 | u8 |
| 70 | vl_socket_api_registration_handle_is_valid (u32 reg_handle) |
| 71 | { |
| 72 | return ((reg_handle & SOCK_API_REG_HANDLE_BIT) != 0); |
| 73 | } |
| 74 | |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 75 | void |
Florin Coras | e86a8ed | 2018-01-05 03:20:25 -0800 | [diff] [blame] | 76 | vl_sock_api_dump_clients (vlib_main_t * vm, api_main_t * am) |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 77 | { |
| 78 | vl_api_registration_t *reg; |
| 79 | socket_main_t *sm = &socket_main; |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 80 | clib_file_t *f; |
| 81 | |
| 82 | /* |
| 83 | * Must have at least one active client, not counting the |
| 84 | * REGISTRATION_TYPE_SOCKET_LISTEN bind/accept socket |
| 85 | */ |
| 86 | if (pool_elts (sm->registration_pool) < 2) |
| 87 | return; |
| 88 | |
| 89 | vlib_cli_output (vm, "Socket clients"); |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 90 | vlib_cli_output (vm, "%20s %8s", "Name", "Fildesc"); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 91 | /* *INDENT-OFF* */ |
Damjan Marion | b2c31b6 | 2020-12-13 21:47:40 +0100 | [diff] [blame] | 92 | pool_foreach (reg, sm->registration_pool) |
| 93 | { |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 94 | if (reg->registration_type == REGISTRATION_TYPE_SOCKET_SERVER) { |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 95 | f = vl_api_registration_file (reg); |
| 96 | vlib_cli_output (vm, "%20s %8d", reg->name, f->file_descriptor); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 97 | } |
Damjan Marion | b2c31b6 | 2020-12-13 21:47:40 +0100 | [diff] [blame] | 98 | } |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 99 | /* *INDENT-ON* */ |
| 100 | } |
| 101 | |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 102 | vl_api_registration_t * |
Florin Coras | 2881dec | 2018-10-02 18:29:25 -0700 | [diff] [blame] | 103 | vl_socket_api_client_handle_to_registration (u32 handle) |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 104 | { |
| 105 | socket_main_t *sm = &socket_main; |
Florin Coras | 2881dec | 2018-10-02 18:29:25 -0700 | [diff] [blame] | 106 | u32 index = socket_api_registration_handle_to_index (handle); |
| 107 | if (pool_is_free_index (sm->registration_pool, index)) |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 108 | { |
| 109 | #if DEBUG > 2 |
Florin Coras | 2881dec | 2018-10-02 18:29:25 -0700 | [diff] [blame] | 110 | clib_warning ("Invalid index %d\n", index); |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 111 | #endif |
| 112 | return 0; |
| 113 | } |
Florin Coras | 2881dec | 2018-10-02 18:29:25 -0700 | [diff] [blame] | 114 | return pool_elt_at_index (sm->registration_pool, index); |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 115 | } |
| 116 | |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 117 | void |
| 118 | vl_socket_api_send (vl_api_registration_t * rp, u8 * elem) |
| 119 | { |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 120 | #if CLIB_DEBUG > 1 |
| 121 | u32 output_length; |
| 122 | #endif |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 123 | socket_main_t *sm = &socket_main; |
| 124 | u16 msg_id = ntohs (*(u16 *) elem); |
Dave Barach | 39d6911 | 2019-11-27 11:42:13 -0500 | [diff] [blame] | 125 | api_main_t *am = vlibapi_get_main (); |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 126 | msgbuf_t *mb = (msgbuf_t *) (elem - offsetof (msgbuf_t, data)); |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 127 | vl_api_registration_t *sock_rp; |
Florin Coras | 8023ad4 | 2018-08-02 12:16:03 -0700 | [diff] [blame] | 128 | clib_file_main_t *fm = &file_main; |
| 129 | clib_error_t *error; |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 130 | clib_file_t *cf; |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 131 | |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 132 | cf = vl_api_registration_file (rp); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 133 | ASSERT (rp->registration_type > REGISTRATION_TYPE_SHMEM); |
| 134 | |
| 135 | if (msg_id >= vec_len (am->api_trace_cfg)) |
| 136 | { |
| 137 | clib_warning ("id out of range: %d", msg_id); |
| 138 | vl_msg_api_free ((void *) elem); |
| 139 | return; |
| 140 | } |
| 141 | |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 142 | sock_rp = pool_elt_at_index (sm->registration_pool, |
| 143 | rp->vl_api_registration_pool_index); |
| 144 | ASSERT (sock_rp); |
| 145 | |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 146 | /* Add the msgbuf_t to the output vector */ |
Florin Coras | 8023ad4 | 2018-08-02 12:16:03 -0700 | [diff] [blame] | 147 | vec_add (sock_rp->output_vector, (u8 *) mb, sizeof (*mb)); |
| 148 | |
| 149 | /* Try to send the message and save any error like |
| 150 | * we do in the input epoll loop */ |
| 151 | vec_add (sock_rp->output_vector, elem, ntohl (mb->data_len)); |
| 152 | error = clib_file_write (cf); |
| 153 | unix_save_error (&unix_main, error); |
| 154 | |
| 155 | /* If we didn't finish sending everything, wait for tx space */ |
| 156 | if (vec_len (sock_rp->output_vector) > 0 |
| 157 | && !(cf->flags & UNIX_FILE_DATA_AVAILABLE_TO_WRITE)) |
| 158 | { |
| 159 | cf->flags |= UNIX_FILE_DATA_AVAILABLE_TO_WRITE; |
| 160 | fm->file_update (cf, UNIX_FILE_UPDATE_MODIFY); |
| 161 | } |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 162 | |
| 163 | #if CLIB_DEBUG > 1 |
| 164 | output_length = sizeof (*mb) + ntohl (mb->data_len); |
| 165 | clib_warning ("wrote %u bytes to fd %d", output_length, |
| 166 | cf->file_descriptor); |
| 167 | #endif |
| 168 | |
| 169 | vl_msg_api_free ((void *) elem); |
| 170 | } |
| 171 | |
| 172 | void |
Florin Coras | e86a8ed | 2018-01-05 03:20:25 -0800 | [diff] [blame] | 173 | vl_socket_free_registration_index (u32 pool_index) |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 174 | { |
| 175 | int i; |
| 176 | vl_api_registration_t *rp; |
Dave Barach | 38ca6e6 | 2020-07-17 17:16:34 -0400 | [diff] [blame] | 177 | void vl_api_call_reaper_functions (u32 client_index); |
| 178 | |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 179 | if (pool_is_free_index (socket_main.registration_pool, pool_index)) |
| 180 | { |
| 181 | clib_warning ("main pool index %d already free", pool_index); |
| 182 | return; |
| 183 | } |
| 184 | rp = pool_elt_at_index (socket_main.registration_pool, pool_index); |
| 185 | |
Neale Ranns | 8df4baa | 2021-12-15 12:59:26 +0000 | [diff] [blame] | 186 | vl_api_call_reaper_functions ( |
| 187 | clib_host_to_net_u32 (sock_api_registration_handle (rp))); |
Dave Barach | 38ca6e6 | 2020-07-17 17:16:34 -0400 | [diff] [blame] | 188 | |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 189 | ASSERT (rp->registration_type != REGISTRATION_TYPE_FREE); |
| 190 | for (i = 0; i < vec_len (rp->additional_fds_to_close); i++) |
| 191 | if (close (rp->additional_fds_to_close[i]) < 0) |
| 192 | clib_unix_warning ("close"); |
| 193 | vec_free (rp->additional_fds_to_close); |
| 194 | vec_free (rp->name); |
| 195 | vec_free (rp->unprocessed_input); |
| 196 | vec_free (rp->output_vector); |
| 197 | rp->registration_type = REGISTRATION_TYPE_FREE; |
| 198 | pool_put (socket_main.registration_pool, rp); |
| 199 | } |
| 200 | |
| 201 | void |
Florin Coras | 5224b5c | 2019-12-06 17:05:08 -0800 | [diff] [blame] | 202 | vl_socket_process_api_msg (vl_api_registration_t * rp, i8 * input_v) |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 203 | { |
| 204 | msgbuf_t *mbp = (msgbuf_t *) input_v; |
| 205 | |
| 206 | u8 *the_msg = (u8 *) (mbp->data); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 207 | socket_main.current_rp = rp; |
Klement Sekera | 9b7e8ac | 2021-11-22 21:26:20 +0100 | [diff] [blame] | 208 | vl_msg_api_socket_handler (the_msg, ntohl (mbp->data_len)); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 209 | socket_main.current_rp = 0; |
| 210 | } |
| 211 | |
Andrew Yourtchenko | 162b70d | 2021-03-11 12:54:11 +0000 | [diff] [blame] | 212 | int |
| 213 | is_being_removed_reg_index (u32 reg_index) |
| 214 | { |
| 215 | vl_api_registration_t *rp = vl_socket_get_registration (reg_index); |
| 216 | ALWAYS_ASSERT (rp != 0); |
| 217 | return (rp->is_being_removed); |
| 218 | } |
| 219 | |
| 220 | static void |
| 221 | socket_cleanup_pending_remove_registration_cb (u32 *preg_index) |
| 222 | { |
| 223 | vl_api_registration_t *rp = vl_socket_get_registration (*preg_index); |
| 224 | clib_file_main_t *fm = &file_main; |
| 225 | u32 pending_remove_file_index = vl_api_registration_file_index (rp); |
| 226 | |
| 227 | clib_file_t *zf = fm->file_pool + pending_remove_file_index; |
| 228 | |
| 229 | clib_file_del (fm, zf); |
| 230 | vl_socket_free_registration_index (rp - socket_main.registration_pool); |
| 231 | } |
| 232 | |
| 233 | static void |
| 234 | vl_socket_request_remove_reg_index (u32 reg_index) |
| 235 | { |
| 236 | vl_api_registration_t *rp = vl_socket_get_registration (reg_index); |
| 237 | ALWAYS_ASSERT (rp != 0); |
| 238 | if (rp->is_being_removed) |
| 239 | { |
| 240 | return; |
| 241 | } |
| 242 | rp->is_being_removed = 1; |
| 243 | vl_api_force_rpc_call_main_thread ( |
| 244 | socket_cleanup_pending_remove_registration_cb, (void *) ®_index, |
| 245 | sizeof (u32)); |
| 246 | } |
| 247 | |
Vratko Polak | 6a6af6e | 2019-10-07 14:52:53 +0200 | [diff] [blame] | 248 | /* |
| 249 | * Read function for API socket. |
| 250 | * |
| 251 | * Read data from socket, invoke SOCKET_READ_EVENT |
| 252 | * for each fully read API message, return 0. |
| 253 | * Store incomplete data for next invocation to continue. |
| 254 | * |
| 255 | * On severe read error, the file is closed. |
| 256 | * |
| 257 | * As reading is single threaded, |
| 258 | * socket_main.input_buffer is used temporarily. |
| 259 | * Even its length is modified, but always restored before return. |
| 260 | * |
| 261 | * Incomplete data is copied into a vector, |
| 262 | * pointer saved in registration's unprocessed_input. |
| 263 | */ |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 264 | clib_error_t * |
| 265 | vl_socket_read_ready (clib_file_t * uf) |
| 266 | { |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 267 | vlib_main_t *vm = vlib_get_main (); |
| 268 | vl_api_registration_t *rp; |
Vratko Polak | 6a6af6e | 2019-10-07 14:52:53 +0200 | [diff] [blame] | 269 | /* n is the size of data read to input_buffer */ |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 270 | int n; |
Vratko Polak | 6a6af6e | 2019-10-07 14:52:53 +0200 | [diff] [blame] | 271 | /* msg_buffer vector can point to input_buffer or unprocessed_input */ |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 272 | i8 *msg_buffer = 0; |
Vratko Polak | 6a6af6e | 2019-10-07 14:52:53 +0200 | [diff] [blame] | 273 | /* data_for_process is a vector containing one full message, incl msgbuf_t */ |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 274 | u8 *data_for_process; |
Vratko Polak | 6a6af6e | 2019-10-07 14:52:53 +0200 | [diff] [blame] | 275 | /* msgbuf_len is the size of one message, including sizeof (msgbuf_t) */ |
| 276 | u32 msgbuf_len; |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 277 | u32 save_input_buffer_length = vec_len (socket_main.input_buffer); |
| 278 | vl_socket_args_for_process_t *a; |
Florin Coras | 5224b5c | 2019-12-06 17:05:08 -0800 | [diff] [blame] | 279 | u32 reg_index = uf->private_data; |
Andrew Yourtchenko | 162b70d | 2021-03-11 12:54:11 +0000 | [diff] [blame] | 280 | if (is_being_removed_reg_index (reg_index)) |
| 281 | { |
| 282 | return 0; |
| 283 | } |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 284 | |
Florin Coras | 5224b5c | 2019-12-06 17:05:08 -0800 | [diff] [blame] | 285 | rp = vl_socket_get_registration (reg_index); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 286 | |
Vratko Polak | 6a6af6e | 2019-10-07 14:52:53 +0200 | [diff] [blame] | 287 | /* Ignore unprocessed_input for now, n describes input_buffer for now. */ |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 288 | n = read (uf->file_descriptor, socket_main.input_buffer, |
| 289 | vec_len (socket_main.input_buffer)); |
| 290 | |
Vratko Polak | 6a6af6e | 2019-10-07 14:52:53 +0200 | [diff] [blame] | 291 | if (n <= 0) |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 292 | { |
Vratko Polak | 6a6af6e | 2019-10-07 14:52:53 +0200 | [diff] [blame] | 293 | if (errno != EAGAIN) |
| 294 | { |
| 295 | /* Severe error, close the file. */ |
Andrew Yourtchenko | 162b70d | 2021-03-11 12:54:11 +0000 | [diff] [blame] | 296 | vl_socket_request_remove_reg_index (reg_index); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 297 | } |
Vratko Polak | 6a6af6e | 2019-10-07 14:52:53 +0200 | [diff] [blame] | 298 | /* EAGAIN means we do not close the file, but no data to process anyway. */ |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 299 | return 0; |
| 300 | } |
| 301 | |
Vratko Polak | 6a6af6e | 2019-10-07 14:52:53 +0200 | [diff] [blame] | 302 | /* Fake smaller length teporarily, so input_buffer can be used as msg_buffer. */ |
Benoît Ganne | f017b81 | 2021-06-22 11:58:27 +0200 | [diff] [blame] | 303 | vec_set_len (socket_main.input_buffer, n); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 304 | |
| 305 | /* |
| 306 | * Look for bugs here. This code is tricky because |
| 307 | * data read from a stream socket does not honor message |
| 308 | * boundaries. In the case of a long message (>4K bytes) |
| 309 | * we have to do (at least) 2 reads, etc. |
| 310 | */ |
Vratko Polak | 6a6af6e | 2019-10-07 14:52:53 +0200 | [diff] [blame] | 311 | /* Determine msg_buffer. */ |
| 312 | if (vec_len (rp->unprocessed_input)) |
| 313 | { |
| 314 | vec_append (rp->unprocessed_input, socket_main.input_buffer); |
| 315 | msg_buffer = rp->unprocessed_input; |
| 316 | } |
| 317 | else |
| 318 | { |
| 319 | msg_buffer = socket_main.input_buffer; |
| 320 | } |
| 321 | /* Loop to process any full messages. */ |
| 322 | ASSERT (vec_len (msg_buffer) > 0); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 323 | do |
| 324 | { |
Vratko Polak | 6a6af6e | 2019-10-07 14:52:53 +0200 | [diff] [blame] | 325 | /* Here, we are not sure how big a chunk of message we have left. */ |
| 326 | /* Do we at least know how big the full message will be? */ |
| 327 | if (vec_len (msg_buffer) <= sizeof (msgbuf_t)) |
| 328 | /* No, so fragment is not a full message. */ |
| 329 | goto save_and_split; |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 330 | |
Vratko Polak | 6a6af6e | 2019-10-07 14:52:53 +0200 | [diff] [blame] | 331 | /* Now we know how big the full message will be. */ |
| 332 | msgbuf_len = |
| 333 | ntohl (((msgbuf_t *) msg_buffer)->data_len) + sizeof (msgbuf_t); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 334 | |
Vratko Polak | 6a6af6e | 2019-10-07 14:52:53 +0200 | [diff] [blame] | 335 | /* But do we have a full message? */ |
| 336 | if (msgbuf_len > vec_len (msg_buffer)) |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 337 | { |
| 338 | save_and_split: |
Vratko Polak | 6a6af6e | 2019-10-07 14:52:53 +0200 | [diff] [blame] | 339 | /* We don't have the entire message yet. */ |
| 340 | /* If msg_buffer is unprocessed_input, nothing needs to be done. */ |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 341 | if (msg_buffer == socket_main.input_buffer) |
Vratko Polak | 6a6af6e | 2019-10-07 14:52:53 +0200 | [diff] [blame] | 342 | /* But if we were using the input buffer, save the fragment. */ |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 343 | { |
| 344 | ASSERT (vec_len (rp->unprocessed_input) == 0); |
| 345 | vec_validate (rp->unprocessed_input, vec_len (msg_buffer) - 1); |
Dave Barach | 178cf49 | 2018-11-13 16:34:13 -0500 | [diff] [blame] | 346 | clib_memcpy_fast (rp->unprocessed_input, msg_buffer, |
| 347 | vec_len (msg_buffer)); |
Benoît Ganne | f017b81 | 2021-06-22 11:58:27 +0200 | [diff] [blame] | 348 | vec_set_len (rp->unprocessed_input, vec_len (msg_buffer)); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 349 | } |
Vratko Polak | 6a6af6e | 2019-10-07 14:52:53 +0200 | [diff] [blame] | 350 | /* No more full messages, restore original input_buffer length. */ |
Benoît Ganne | f017b81 | 2021-06-22 11:58:27 +0200 | [diff] [blame] | 351 | vec_set_len (socket_main.input_buffer, save_input_buffer_length); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 352 | return 0; |
| 353 | } |
| 354 | |
Vratko Polak | 6a6af6e | 2019-10-07 14:52:53 +0200 | [diff] [blame] | 355 | /* |
| 356 | * We have at least one full message. |
| 357 | * But msg_buffer can contain more data, so copy one message data |
| 358 | * so we can overwrite its length to what single message has. |
| 359 | */ |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 360 | data_for_process = (u8 *) vec_dup (msg_buffer); |
Benoît Ganne | f017b81 | 2021-06-22 11:58:27 +0200 | [diff] [blame] | 361 | vec_set_len (data_for_process, msgbuf_len); |
Vratko Polak | 6a6af6e | 2019-10-07 14:52:53 +0200 | [diff] [blame] | 362 | /* Everything is ready to signal the SOCKET_READ_EVENT. */ |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 363 | pool_get (socket_main.process_args, a); |
Florin Coras | 5224b5c | 2019-12-06 17:05:08 -0800 | [diff] [blame] | 364 | a->reg_index = reg_index; |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 365 | a->data = data_for_process; |
| 366 | |
Florin Coras | e86a8ed | 2018-01-05 03:20:25 -0800 | [diff] [blame] | 367 | vlib_process_signal_event (vm, vl_api_clnt_node.index, |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 368 | SOCKET_READ_EVENT, |
| 369 | a - socket_main.process_args); |
Vratko Polak | 6a6af6e | 2019-10-07 14:52:53 +0200 | [diff] [blame] | 370 | if (vec_len (msg_buffer) > msgbuf_len) |
| 371 | /* There are some fragments left. Shrink the msg_buffer to simplify logic. */ |
| 372 | vec_delete (msg_buffer, msgbuf_len, 0); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 373 | else |
Vratko Polak | 6a6af6e | 2019-10-07 14:52:53 +0200 | [diff] [blame] | 374 | /* We are done with msg_buffer. */ |
Benoît Ganne | f017b81 | 2021-06-22 11:58:27 +0200 | [diff] [blame] | 375 | vec_set_len (msg_buffer, 0); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 376 | } |
Vratko Polak | 6a6af6e | 2019-10-07 14:52:53 +0200 | [diff] [blame] | 377 | while (vec_len (msg_buffer) > 0); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 378 | |
Vratko Polak | 6a6af6e | 2019-10-07 14:52:53 +0200 | [diff] [blame] | 379 | /* Restore input_buffer, it could have been msg_buffer. */ |
Benoît Ganne | f017b81 | 2021-06-22 11:58:27 +0200 | [diff] [blame] | 380 | vec_set_len (socket_main.input_buffer, save_input_buffer_length); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 381 | return 0; |
| 382 | } |
| 383 | |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 384 | clib_error_t * |
| 385 | vl_socket_write_ready (clib_file_t * uf) |
| 386 | { |
| 387 | clib_file_main_t *fm = &file_main; |
| 388 | vl_api_registration_t *rp; |
| 389 | int n; |
| 390 | |
Andrew Yourtchenko | 162b70d | 2021-03-11 12:54:11 +0000 | [diff] [blame] | 391 | u32 reg_index = uf->private_data; |
| 392 | if (is_being_removed_reg_index (reg_index)) |
| 393 | { |
| 394 | return 0; |
| 395 | } |
| 396 | |
| 397 | rp = pool_elt_at_index (socket_main.registration_pool, reg_index); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 398 | |
| 399 | /* Flush output vector. */ |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 400 | size_t total_bytes = vec_len (rp->output_vector); |
| 401 | size_t bytes_to_send, remaining_bytes = total_bytes; |
| 402 | void *p = rp->output_vector; |
| 403 | while (remaining_bytes > 0) |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 404 | { |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 405 | bytes_to_send = remaining_bytes > 4096 ? 4096 : remaining_bytes; |
| 406 | n = write (uf->file_descriptor, p, bytes_to_send); |
| 407 | if (n < 0) |
Florin Coras | 8023ad4 | 2018-08-02 12:16:03 -0700 | [diff] [blame] | 408 | { |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 409 | if (errno == EAGAIN) |
| 410 | { |
| 411 | break; |
| 412 | } |
| 413 | #if DEBUG > 2 |
| 414 | clib_warning ("write error, close the file...\n"); |
| 415 | #endif |
Andrew Yourtchenko | 162b70d | 2021-03-11 12:54:11 +0000 | [diff] [blame] | 416 | vl_socket_request_remove_reg_index (reg_index); |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 417 | return 0; |
Florin Coras | 8023ad4 | 2018-08-02 12:16:03 -0700 | [diff] [blame] | 418 | } |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 419 | remaining_bytes -= bytes_to_send; |
| 420 | p += bytes_to_send; |
| 421 | } |
| 422 | |
| 423 | vec_delete (rp->output_vector, total_bytes - remaining_bytes, 0); |
| 424 | if (vec_len (rp->output_vector) <= 0 |
| 425 | && (uf->flags & UNIX_FILE_DATA_AVAILABLE_TO_WRITE)) |
| 426 | { |
| 427 | uf->flags &= ~UNIX_FILE_DATA_AVAILABLE_TO_WRITE; |
| 428 | fm->file_update (uf, UNIX_FILE_UPDATE_MODIFY); |
Florin Coras | 8023ad4 | 2018-08-02 12:16:03 -0700 | [diff] [blame] | 429 | } |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 430 | |
| 431 | return 0; |
| 432 | } |
| 433 | |
| 434 | clib_error_t * |
| 435 | vl_socket_error_ready (clib_file_t * uf) |
| 436 | { |
Andrew Yourtchenko | 162b70d | 2021-03-11 12:54:11 +0000 | [diff] [blame] | 437 | u32 reg_index = uf->private_data; |
| 438 | vl_socket_request_remove_reg_index (reg_index); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 439 | return 0; |
| 440 | } |
| 441 | |
| 442 | void |
| 443 | socksvr_file_add (clib_file_main_t * fm, int fd) |
| 444 | { |
| 445 | vl_api_registration_t *rp; |
| 446 | clib_file_t template = { 0 }; |
| 447 | |
| 448 | pool_get (socket_main.registration_pool, rp); |
Dave Barach | b7b9299 | 2018-10-17 10:38:51 -0400 | [diff] [blame] | 449 | clib_memset (rp, 0, sizeof (*rp)); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 450 | |
| 451 | template.read_function = vl_socket_read_ready; |
| 452 | template.write_function = vl_socket_write_ready; |
| 453 | template.error_function = vl_socket_error_ready; |
| 454 | template.file_descriptor = fd; |
Paul Vinciguerra | 5481ad4 | 2020-01-28 14:47:17 -0500 | [diff] [blame] | 455 | template.description = format (0, "socksrv"); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 456 | template.private_data = rp - socket_main.registration_pool; |
| 457 | |
| 458 | rp->registration_type = REGISTRATION_TYPE_SOCKET_SERVER; |
| 459 | rp->vl_api_registration_pool_index = rp - socket_main.registration_pool; |
| 460 | rp->clib_file_index = clib_file_add (fm, &template); |
| 461 | } |
| 462 | |
| 463 | static clib_error_t * |
| 464 | socksvr_accept_ready (clib_file_t * uf) |
| 465 | { |
| 466 | clib_file_main_t *fm = &file_main; |
| 467 | socket_main_t *sm = &socket_main; |
| 468 | clib_socket_t *sock = &sm->socksvr_listen_socket; |
| 469 | clib_socket_t client; |
| 470 | clib_error_t *error; |
| 471 | |
| 472 | error = clib_socket_accept (sock, &client); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 473 | if (error) |
| 474 | return error; |
| 475 | |
| 476 | socksvr_file_add (fm, client.fd); |
| 477 | return 0; |
| 478 | } |
| 479 | |
| 480 | static clib_error_t * |
| 481 | socksvr_bogus_write (clib_file_t * uf) |
| 482 | { |
| 483 | clib_warning ("why am I here?"); |
| 484 | return 0; |
| 485 | } |
| 486 | |
| 487 | /* |
| 488 | * vl_api_sockclnt_create_t_handler |
| 489 | */ |
| 490 | void |
| 491 | vl_api_sockclnt_create_t_handler (vl_api_sockclnt_create_t * mp) |
| 492 | { |
| 493 | vl_api_registration_t *regp; |
| 494 | vl_api_sockclnt_create_reply_t *rp; |
Dave Barach | 39d6911 | 2019-11-27 11:42:13 -0500 | [diff] [blame] | 495 | api_main_t *am = vlibapi_get_main (); |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 496 | hash_pair_t *hp; |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 497 | int rv = 0; |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 498 | u32 nmsg = hash_elts (am->msg_index_by_name_and_crc); |
| 499 | u32 i = 0; |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 500 | |
| 501 | regp = socket_main.current_rp; |
| 502 | |
Filip Tehlar | 36217e3 | 2021-07-23 08:51:10 +0000 | [diff] [blame] | 503 | /* client already connected through shared memory? */ |
| 504 | if (!regp || regp->registration_type != REGISTRATION_TYPE_SOCKET_SERVER) |
| 505 | { |
| 506 | clib_warning ( |
| 507 | "unsupported API call: already connected though shared memory?"); |
| 508 | return; |
| 509 | } |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 510 | |
Ole Troan | 7adaa22 | 2019-08-27 15:05:27 +0200 | [diff] [blame] | 511 | regp->name = format (0, "%s%c", mp->name, 0); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 512 | |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 513 | u32 size = sizeof (*rp) + (nmsg * sizeof (vl_api_message_table_entry_t)); |
Vratko Polak | fc4828c | 2019-07-02 11:07:24 +0200 | [diff] [blame] | 514 | rp = vl_msg_api_alloc_zero (size); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 515 | rp->_vl_msg_id = htons (VL_API_SOCKCLNT_CREATE_REPLY); |
Florin Coras | 2881dec | 2018-10-02 18:29:25 -0700 | [diff] [blame] | 516 | rp->index = htonl (sock_api_registration_handle (regp)); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 517 | rp->context = mp->context; |
| 518 | rp->response = htonl (rv); |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 519 | rp->count = htons (nmsg); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 520 | |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 521 | /* *INDENT-OFF* */ |
| 522 | hash_foreach_pair (hp, am->msg_index_by_name_and_crc, |
| 523 | ({ |
| 524 | rp->message_table[i].index = htons(hp->value[0]); |
Dave Barach | a6ef36b | 2020-02-11 10:29:13 -0500 | [diff] [blame] | 525 | (void) strncpy_s((char *)rp->message_table[i].name, |
| 526 | 64 /* bytes of space at dst */, |
| 527 | (char *)hp->key, |
| 528 | 64-1 /* chars to copy, without zero byte. */); |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 529 | i++; |
| 530 | })); |
| 531 | /* *INDENT-ON* */ |
Florin Coras | e86a8ed | 2018-01-05 03:20:25 -0800 | [diff] [blame] | 532 | vl_api_send_msg (regp, (u8 *) rp); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 533 | } |
| 534 | |
| 535 | /* |
| 536 | * vl_api_sockclnt_delete_t_handler |
| 537 | */ |
| 538 | void |
| 539 | vl_api_sockclnt_delete_t_handler (vl_api_sockclnt_delete_t * mp) |
| 540 | { |
| 541 | vl_api_registration_t *regp; |
| 542 | vl_api_sockclnt_delete_reply_t *rp; |
| 543 | |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 544 | regp = vl_api_client_index_to_registration (mp->client_index); |
| 545 | if (!regp) |
| 546 | return; |
| 547 | |
Ole Troan | 3c1cf2c | 2019-01-05 11:27:54 +0100 | [diff] [blame] | 548 | u32 reg_index = socket_api_registration_handle_to_index (ntohl (mp->index)); |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 549 | rp = vl_msg_api_alloc (sizeof (*rp)); |
| 550 | rp->_vl_msg_id = htons (VL_API_SOCKCLNT_DELETE_REPLY); |
| 551 | rp->context = mp->context; |
| 552 | |
| 553 | if (!pool_is_free_index (socket_main.registration_pool, reg_index)) |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 554 | { |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 555 | rp->response = htonl (1); |
Florin Coras | e86a8ed | 2018-01-05 03:20:25 -0800 | [diff] [blame] | 556 | vl_api_send_msg (regp, (u8 *) rp); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 557 | |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 558 | vl_api_registration_del_file (regp); |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 559 | vl_socket_free_registration_index (reg_index); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 560 | } |
| 561 | else |
| 562 | { |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 563 | clib_warning ("unknown client ID %d", reg_index); |
| 564 | rp->response = htonl (-1); |
| 565 | vl_api_send_msg (regp, (u8 *) rp); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 566 | } |
| 567 | } |
| 568 | |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 569 | clib_error_t * |
Florin Coras | 466f289 | 2018-08-03 02:50:43 -0700 | [diff] [blame] | 570 | vl_sock_api_send_fd_msg (int socket_fd, int fds[], int n_fds) |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 571 | { |
| 572 | struct msghdr mh = { 0 }; |
| 573 | struct iovec iov[1]; |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 574 | char ctl[CMSG_SPACE (sizeof (int) * n_fds)]; |
Florin Coras | 466f289 | 2018-08-03 02:50:43 -0700 | [diff] [blame] | 575 | struct cmsghdr *cmsg; |
| 576 | char *msg = "fdmsg"; |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 577 | int rv; |
| 578 | |
| 579 | iov[0].iov_base = msg; |
| 580 | iov[0].iov_len = strlen (msg); |
| 581 | mh.msg_iov = iov; |
| 582 | mh.msg_iovlen = 1; |
| 583 | |
Dave Barach | b7b9299 | 2018-10-17 10:38:51 -0400 | [diff] [blame] | 584 | clib_memset (&ctl, 0, sizeof (ctl)); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 585 | mh.msg_control = ctl; |
| 586 | mh.msg_controllen = sizeof (ctl); |
| 587 | cmsg = CMSG_FIRSTHDR (&mh); |
Florin Coras | 466f289 | 2018-08-03 02:50:43 -0700 | [diff] [blame] | 588 | cmsg->cmsg_len = CMSG_LEN (sizeof (int) * n_fds); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 589 | cmsg->cmsg_level = SOL_SOCKET; |
| 590 | cmsg->cmsg_type = SCM_RIGHTS; |
Dave Barach | 178cf49 | 2018-11-13 16:34:13 -0500 | [diff] [blame] | 591 | clib_memcpy_fast (CMSG_DATA (cmsg), fds, sizeof (int) * n_fds); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 592 | |
Florin Coras | 587ea45 | 2020-08-17 20:46:34 -0700 | [diff] [blame] | 593 | while ((rv = sendmsg (socket_fd, &mh, 0)) < 0 && errno == EAGAIN) |
| 594 | ; |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 595 | if (rv < 0) |
| 596 | return clib_error_return_unix (0, "sendmsg"); |
| 597 | return 0; |
| 598 | } |
| 599 | |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 600 | vl_api_shm_elem_config_t * |
| 601 | vl_api_make_shm_config (vl_api_sock_init_shm_t * mp) |
| 602 | { |
| 603 | vl_api_shm_elem_config_t *config = 0, *c; |
| 604 | u64 cfg; |
| 605 | int i; |
| 606 | |
| 607 | if (!mp->nitems) |
| 608 | { |
Dave Barach | 7895872 | 2018-05-10 16:44:27 -0400 | [diff] [blame] | 609 | vec_validate (config, 6); |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 610 | config[0].type = VL_API_VLIB_RING; |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 611 | config[0].size = 256; |
Dave Barach | 7895872 | 2018-05-10 16:44:27 -0400 | [diff] [blame] | 612 | config[0].count = 32; |
| 613 | |
| 614 | config[1].type = VL_API_VLIB_RING; |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 615 | config[1].size = 1024; |
Dave Barach | 7895872 | 2018-05-10 16:44:27 -0400 | [diff] [blame] | 616 | config[1].count = 16; |
| 617 | |
| 618 | config[2].type = VL_API_VLIB_RING; |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 619 | config[2].size = 4096; |
Dave Barach | 7895872 | 2018-05-10 16:44:27 -0400 | [diff] [blame] | 620 | config[2].count = 2; |
| 621 | |
| 622 | config[3].type = VL_API_CLIENT_RING; |
| 623 | config[3].size = 256; |
| 624 | config[3].count = 32; |
| 625 | |
| 626 | config[4].type = VL_API_CLIENT_RING; |
| 627 | config[4].size = 1024; |
| 628 | config[4].count = 16; |
| 629 | |
| 630 | config[5].type = VL_API_CLIENT_RING; |
| 631 | config[5].size = 4096; |
| 632 | config[5].count = 2; |
| 633 | |
| 634 | config[6].type = VL_API_QUEUE; |
| 635 | config[6].count = 128; |
| 636 | config[6].size = sizeof (uword); |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 637 | } |
| 638 | else |
| 639 | { |
| 640 | vec_validate (config, mp->nitems - 1); |
| 641 | for (i = 0; i < mp->nitems; i++) |
| 642 | { |
| 643 | cfg = mp->configs[i]; |
| 644 | /* Pretty much a hack but it avoids defining our own api type |
| 645 | * in memclnt.api */ |
| 646 | c = (vl_api_shm_elem_config_t *) & cfg; |
| 647 | config[i].type = c->type; |
| 648 | config[i].count = c->count; |
| 649 | config[i].size = c->size; |
| 650 | } |
| 651 | } |
| 652 | return config; |
| 653 | } |
| 654 | |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 655 | /* |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 656 | * Bootstrap shm api using the socket api |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 657 | */ |
| 658 | void |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 659 | vl_api_sock_init_shm_t_handler (vl_api_sock_init_shm_t * mp) |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 660 | { |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 661 | vl_api_sock_init_shm_reply_t *rmp; |
Florin Coras | 4d9b9d8 | 2018-01-14 12:25:50 -0800 | [diff] [blame] | 662 | ssvm_private_t _memfd_private, *memfd = &_memfd_private; |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 663 | svm_map_region_args_t _args, *a = &_args; |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 664 | vl_api_registration_t *regp; |
Dave Barach | 39d6911 | 2019-11-27 11:42:13 -0500 | [diff] [blame] | 665 | api_main_t *am = vlibapi_get_main (); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 666 | svm_region_t *vlib_rp; |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 667 | clib_file_t *cf; |
| 668 | vl_api_shm_elem_config_t *config = 0; |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 669 | vl_shmem_hdr_t *shmem_hdr; |
Florin Coras | 1f30a59 | 2019-05-08 19:57:24 -0700 | [diff] [blame] | 670 | int rv, tries = 1000; |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 671 | |
| 672 | regp = vl_api_client_index_to_registration (mp->client_index); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 673 | if (regp == 0) |
| 674 | { |
| 675 | clib_warning ("API client disconnected"); |
| 676 | return; |
| 677 | } |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 678 | if (regp->registration_type != REGISTRATION_TYPE_SOCKET_SERVER) |
| 679 | { |
wanghanlin | ec2c4c4 | 2021-03-02 17:18:06 +0800 | [diff] [blame] | 680 | clib_warning ("Invalid registration"); |
| 681 | return; |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 682 | } |
| 683 | |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 684 | /* |
| 685 | * Set up a memfd segment of the requested size wherein the |
| 686 | * shmem data structures will be initialized |
| 687 | */ |
Dave Barach | b7b9299 | 2018-10-17 10:38:51 -0400 | [diff] [blame] | 688 | clib_memset (memfd, 0, sizeof (*memfd)); |
Florin Coras | 4d9b9d8 | 2018-01-14 12:25:50 -0800 | [diff] [blame] | 689 | memfd->ssvm_size = mp->requested_size; |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 690 | memfd->requested_va = 0ULL; |
Florin Coras | 5220a26 | 2020-09-29 18:11:24 -0700 | [diff] [blame] | 691 | memfd->is_server = 1; |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 692 | memfd->name = format (0, "%s%c", regp->name, 0); |
| 693 | |
Florin Coras | 5220a26 | 2020-09-29 18:11:24 -0700 | [diff] [blame] | 694 | if ((rv = ssvm_server_init_memfd (memfd))) |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 695 | goto reply; |
| 696 | |
Benoît Ganne | df601ae | 2020-10-20 14:31:55 +0200 | [diff] [blame] | 697 | /* delete the unused heap created in ssvm_server_init_memfd and mark it |
| 698 | * accessible again for ASAN */ |
| 699 | clib_mem_destroy_heap (memfd->sh->heap); |
Damjan Marion | 79934e8 | 2022-04-05 12:40:31 +0200 | [diff] [blame^] | 700 | clib_mem_unpoison ((void *) memfd->sh->ssvm_va, memfd->ssvm_size); |
Benoît Ganne | df601ae | 2020-10-20 14:31:55 +0200 | [diff] [blame] | 701 | |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 702 | /* Remember to close this fd when the socket connection goes away */ |
| 703 | vec_add1 (regp->additional_fds_to_close, memfd->fd); |
| 704 | |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 705 | /* |
| 706 | * Create a plausible svm_region in the memfd backed segment |
| 707 | */ |
Dave Barach | b7b9299 | 2018-10-17 10:38:51 -0400 | [diff] [blame] | 708 | clib_memset (a, 0, sizeof (*a)); |
Florin Coras | 4d9b9d8 | 2018-01-14 12:25:50 -0800 | [diff] [blame] | 709 | a->baseva = memfd->sh->ssvm_va + MMAP_PAGESIZE; |
| 710 | a->size = memfd->ssvm_size - MMAP_PAGESIZE; |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 711 | /* $$$$ might want a different config parameter */ |
| 712 | a->pvt_heap_size = am->api_pvt_heap_size; |
| 713 | a->flags = SVM_FLAGS_MHEAP; |
| 714 | svm_region_init_mapped_region (a, (svm_region_t *) a->baseva); |
| 715 | |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 716 | /* |
| 717 | * Part deux, initialize the svm_region_t shared-memory header |
| 718 | * api allocation rings, and so on. |
| 719 | */ |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 720 | config = vl_api_make_shm_config (mp); |
| 721 | vlib_rp = (svm_region_t *) a->baseva; |
| 722 | vl_init_shmem (vlib_rp, config, 1 /* is_vlib (dont-care) */ , |
| 723 | 1 /* is_private */ ); |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 724 | |
| 725 | /* Remember who created this. Needs to be post vl_init_shmem */ |
| 726 | shmem_hdr = (vl_shmem_hdr_t *) vlib_rp->user_ctx; |
| 727 | shmem_hdr->clib_file_index = vl_api_registration_file_index (regp); |
| 728 | |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 729 | vec_add1 (am->vlib_private_rps, vlib_rp); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 730 | memfd->sh->ready = 1; |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 731 | vec_free (config); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 732 | |
| 733 | /* Recompute the set of input queues to poll in memclnt_process */ |
| 734 | vec_reset_length (vl_api_queue_cursizes); |
| 735 | |
| 736 | reply: |
| 737 | |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 738 | rmp = vl_msg_api_alloc (sizeof (*rmp)); |
| 739 | rmp->_vl_msg_id = htons (VL_API_SOCK_INIT_SHM_REPLY); |
| 740 | rmp->context = mp->context; |
| 741 | rmp->retval = htonl (rv); |
| 742 | |
Florin Coras | 8023ad4 | 2018-08-02 12:16:03 -0700 | [diff] [blame] | 743 | /* |
| 744 | * Note: The reply message needs to make it out the back door |
| 745 | * before we send the magic fd message. That's taken care of by |
| 746 | * the send function. |
| 747 | */ |
| 748 | vl_socket_api_send (regp, (u8 *) rmp); |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 749 | |
| 750 | if (rv != 0) |
| 751 | return; |
| 752 | |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 753 | /* Send the magic "here's your sign (aka fd)" socket message */ |
Florin Coras | 8023ad4 | 2018-08-02 12:16:03 -0700 | [diff] [blame] | 754 | cf = vl_api_registration_file (regp); |
wanghanlin | ec2c4c4 | 2021-03-02 17:18:06 +0800 | [diff] [blame] | 755 | if (!cf) |
| 756 | { |
| 757 | clib_warning ("cf removed"); |
| 758 | return; |
| 759 | } |
Florin Coras | 1f30a59 | 2019-05-08 19:57:24 -0700 | [diff] [blame] | 760 | |
| 761 | /* Wait for reply to be consumed before sending the fd */ |
| 762 | while (tries-- > 0) |
| 763 | { |
| 764 | int bytes; |
| 765 | rv = ioctl (cf->file_descriptor, TIOCOUTQ, &bytes); |
| 766 | if (rv < 0) |
| 767 | { |
| 768 | clib_unix_warning ("ioctl returned"); |
| 769 | break; |
| 770 | } |
| 771 | if (bytes == 0) |
| 772 | break; |
| 773 | usleep (1e3); |
| 774 | } |
| 775 | |
Florin Coras | 466f289 | 2018-08-03 02:50:43 -0700 | [diff] [blame] | 776 | vl_sock_api_send_fd_msg (cf->file_descriptor, &memfd->fd, 1); |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 777 | } |
| 778 | |
Filip Tehlar | 36217e3 | 2021-07-23 08:51:10 +0000 | [diff] [blame] | 779 | #define foreach_vlib_api_msg \ |
| 780 | _ (SOCKCLNT_CREATE, sockclnt_create, 0) \ |
| 781 | _ (SOCKCLNT_DELETE, sockclnt_delete, 0) \ |
| 782 | _ (SOCK_INIT_SHM, sock_init_shm, 0) |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 783 | |
| 784 | clib_error_t * |
Florin Coras | e86a8ed | 2018-01-05 03:20:25 -0800 | [diff] [blame] | 785 | vl_sock_api_init (vlib_main_t * vm) |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 786 | { |
Filip Tehlar | 36217e3 | 2021-07-23 08:51:10 +0000 | [diff] [blame] | 787 | api_main_t *am = vlibapi_get_main (); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 788 | clib_file_main_t *fm = &file_main; |
| 789 | clib_file_t template = { 0 }; |
| 790 | vl_api_registration_t *rp; |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 791 | socket_main_t *sm = &socket_main; |
| 792 | clib_socket_t *sock = &sm->socksvr_listen_socket; |
| 793 | clib_error_t *error; |
| 794 | |
| 795 | /* If not explicitly configured, do not bind/enable, etc. */ |
| 796 | if (sm->socket_name == 0) |
| 797 | return 0; |
| 798 | |
Filip Tehlar | 36217e3 | 2021-07-23 08:51:10 +0000 | [diff] [blame] | 799 | #define _(N, n, t) \ |
Klement Sekera | 9b7e8ac | 2021-11-22 21:26:20 +0100 | [diff] [blame] | 800 | vl_msg_api_set_handlers ( \ |
| 801 | VL_API_##N, #n, vl_api_##n##_t_handler, vl_noop_handler, \ |
| 802 | vl_api_##n##_t_endian, vl_api_##n##_t_print, sizeof (vl_api_##n##_t), t, \ |
| 803 | vl_api_##n##_t_print_json, vl_api_##n##_t_tojson, \ |
| 804 | vl_api_##n##_t_fromjson, vl_api_##n##_t_calc_size); \ |
Filip Tehlar | 36217e3 | 2021-07-23 08:51:10 +0000 | [diff] [blame] | 805 | am->api_trace_cfg[VL_API_##N].replay_enable = 0; |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 806 | foreach_vlib_api_msg; |
| 807 | #undef _ |
| 808 | |
| 809 | vec_resize (sm->input_buffer, 4096); |
| 810 | |
| 811 | sock->config = (char *) sm->socket_name; |
Ole Troan | 4ff09ae | 2019-04-15 11:27:22 +0200 | [diff] [blame] | 812 | sock->flags = CLIB_SOCKET_F_IS_SERVER | CLIB_SOCKET_F_ALLOW_GROUP_WRITE; |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 813 | error = clib_socket_init (sock); |
| 814 | if (error) |
| 815 | return error; |
| 816 | |
| 817 | pool_get (sm->registration_pool, rp); |
Dave Barach | b7b9299 | 2018-10-17 10:38:51 -0400 | [diff] [blame] | 818 | clib_memset (rp, 0, sizeof (*rp)); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 819 | |
| 820 | rp->registration_type = REGISTRATION_TYPE_SOCKET_LISTEN; |
| 821 | |
| 822 | template.read_function = socksvr_accept_ready; |
| 823 | template.write_function = socksvr_bogus_write; |
| 824 | template.file_descriptor = sock->fd; |
Paul Vinciguerra | 5481ad4 | 2020-01-28 14:47:17 -0500 | [diff] [blame] | 825 | template.description = format (0, "socksvr %s", sock->config); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 826 | template.private_data = rp - sm->registration_pool; |
| 827 | |
| 828 | rp->clib_file_index = clib_file_add (fm, &template); |
| 829 | return 0; |
| 830 | } |
| 831 | |
| 832 | static clib_error_t * |
| 833 | socket_exit (vlib_main_t * vm) |
| 834 | { |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 835 | socket_main_t *sm = &socket_main; |
| 836 | vl_api_registration_t *rp; |
| 837 | |
| 838 | /* Defensive driving in case something wipes out early */ |
| 839 | if (sm->registration_pool) |
| 840 | { |
| 841 | u32 index; |
| 842 | /* *INDENT-OFF* */ |
Damjan Marion | b2c31b6 | 2020-12-13 21:47:40 +0100 | [diff] [blame] | 843 | pool_foreach (rp, sm->registration_pool) { |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 844 | vl_api_registration_del_file (rp); |
| 845 | index = rp->vl_api_registration_pool_index; |
| 846 | vl_socket_free_registration_index (index); |
Damjan Marion | b2c31b6 | 2020-12-13 21:47:40 +0100 | [diff] [blame] | 847 | } |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 848 | /* *INDENT-ON* */ |
| 849 | } |
| 850 | |
| 851 | return 0; |
| 852 | } |
| 853 | |
| 854 | VLIB_MAIN_LOOP_EXIT_FUNCTION (socket_exit); |
| 855 | |
| 856 | static clib_error_t * |
| 857 | socksvr_config (vlib_main_t * vm, unformat_input_t * input) |
| 858 | { |
| 859 | socket_main_t *sm = &socket_main; |
| 860 | |
| 861 | while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) |
| 862 | { |
| 863 | if (unformat (input, "socket-name %s", &sm->socket_name)) |
| 864 | ; |
Ole Troan | 6595ff7 | 2019-08-07 13:41:39 +0200 | [diff] [blame] | 865 | /* DEPRECATE: default keyword is ignored */ |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 866 | else if (unformat (input, "default")) |
Ole Troan | 6595ff7 | 2019-08-07 13:41:39 +0200 | [diff] [blame] | 867 | ; |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 868 | else |
| 869 | { |
| 870 | return clib_error_return (0, "unknown input '%U'", |
| 871 | format_unformat_error, input); |
| 872 | } |
| 873 | } |
Ole Troan | 6595ff7 | 2019-08-07 13:41:39 +0200 | [diff] [blame] | 874 | |
| 875 | if (!vec_len (sm->socket_name)) |
| 876 | sm->socket_name = format (0, "%s/%s", vlib_unix_get_runtime_dir (), |
| 877 | API_SOCKET_FILENAME); |
| 878 | vec_terminate_c_string (sm->socket_name); |
| 879 | |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 880 | return 0; |
| 881 | } |
| 882 | |
| 883 | VLIB_CONFIG_FUNCTION (socksvr_config, "socksvr"); |
| 884 | |
Dave Barach | f8d5068 | 2019-05-14 18:01:44 -0400 | [diff] [blame] | 885 | void |
| 886 | vlibsocket_reference () |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 887 | { |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 888 | } |
| 889 | |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 890 | /* |
| 891 | * fd.io coding-style-patch-verification: ON |
| 892 | * |
| 893 | * Local Variables: |
| 894 | * eval: (c-set-style "gnu") |
| 895 | * End: |
| 896 | */ |