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 | |
Florin Coras | e86a8ed | 2018-01-05 03:20:25 -0800 | [diff] [blame] | 48 | socket_main_t socket_main; |
| 49 | |
Florin Coras | 2881dec | 2018-10-02 18:29:25 -0700 | [diff] [blame] | 50 | #define SOCK_API_REG_HANDLE_BIT (1<<31) |
| 51 | |
| 52 | static u32 |
| 53 | sock_api_registration_handle (vl_api_registration_t * regp) |
| 54 | { |
| 55 | ASSERT (regp->vl_api_registration_pool_index < SOCK_API_REG_HANDLE_BIT); |
| 56 | return regp->vl_api_registration_pool_index | SOCK_API_REG_HANDLE_BIT; |
| 57 | } |
| 58 | |
| 59 | static u32 |
| 60 | socket_api_registration_handle_to_index (u32 reg_index) |
| 61 | { |
| 62 | return (reg_index & ~SOCK_API_REG_HANDLE_BIT); |
| 63 | } |
| 64 | |
| 65 | u8 |
| 66 | vl_socket_api_registration_handle_is_valid (u32 reg_handle) |
| 67 | { |
| 68 | return ((reg_handle & SOCK_API_REG_HANDLE_BIT) != 0); |
| 69 | } |
| 70 | |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 71 | void |
Florin Coras | e86a8ed | 2018-01-05 03:20:25 -0800 | [diff] [blame] | 72 | 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] | 73 | { |
| 74 | vl_api_registration_t *reg; |
| 75 | socket_main_t *sm = &socket_main; |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 76 | clib_file_t *f; |
| 77 | |
| 78 | /* |
| 79 | * Must have at least one active client, not counting the |
| 80 | * REGISTRATION_TYPE_SOCKET_LISTEN bind/accept socket |
| 81 | */ |
| 82 | if (pool_elts (sm->registration_pool) < 2) |
| 83 | return; |
| 84 | |
| 85 | vlib_cli_output (vm, "Socket clients"); |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 86 | vlib_cli_output (vm, "%20s %8s", "Name", "Fildesc"); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 87 | /* *INDENT-OFF* */ |
| 88 | pool_foreach (reg, sm->registration_pool, |
| 89 | ({ |
| 90 | if (reg->registration_type == REGISTRATION_TYPE_SOCKET_SERVER) { |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 91 | f = vl_api_registration_file (reg); |
| 92 | vlib_cli_output (vm, "%20s %8d", reg->name, f->file_descriptor); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 93 | } |
| 94 | })); |
| 95 | /* *INDENT-ON* */ |
| 96 | } |
| 97 | |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 98 | vl_api_registration_t * |
Florin Coras | 2881dec | 2018-10-02 18:29:25 -0700 | [diff] [blame] | 99 | vl_socket_api_client_handle_to_registration (u32 handle) |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 100 | { |
| 101 | socket_main_t *sm = &socket_main; |
Florin Coras | 2881dec | 2018-10-02 18:29:25 -0700 | [diff] [blame] | 102 | u32 index = socket_api_registration_handle_to_index (handle); |
| 103 | if (pool_is_free_index (sm->registration_pool, index)) |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 104 | { |
| 105 | #if DEBUG > 2 |
Florin Coras | 2881dec | 2018-10-02 18:29:25 -0700 | [diff] [blame] | 106 | clib_warning ("Invalid index %d\n", index); |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 107 | #endif |
| 108 | return 0; |
| 109 | } |
Florin Coras | 2881dec | 2018-10-02 18:29:25 -0700 | [diff] [blame] | 110 | return pool_elt_at_index (sm->registration_pool, index); |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 111 | } |
| 112 | |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 113 | void |
| 114 | vl_socket_api_send (vl_api_registration_t * rp, u8 * elem) |
| 115 | { |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 116 | #if CLIB_DEBUG > 1 |
| 117 | u32 output_length; |
| 118 | #endif |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 119 | socket_main_t *sm = &socket_main; |
| 120 | u16 msg_id = ntohs (*(u16 *) elem); |
| 121 | api_main_t *am = &api_main; |
| 122 | msgbuf_t *mb = (msgbuf_t *) (elem - offsetof (msgbuf_t, data)); |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 123 | vl_api_registration_t *sock_rp; |
Florin Coras | 8023ad4 | 2018-08-02 12:16:03 -0700 | [diff] [blame] | 124 | clib_file_main_t *fm = &file_main; |
| 125 | clib_error_t *error; |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 126 | clib_file_t *cf; |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 127 | |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 128 | cf = vl_api_registration_file (rp); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 129 | ASSERT (rp->registration_type > REGISTRATION_TYPE_SHMEM); |
| 130 | |
| 131 | if (msg_id >= vec_len (am->api_trace_cfg)) |
| 132 | { |
| 133 | clib_warning ("id out of range: %d", msg_id); |
| 134 | vl_msg_api_free ((void *) elem); |
| 135 | return; |
| 136 | } |
| 137 | |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 138 | sock_rp = pool_elt_at_index (sm->registration_pool, |
| 139 | rp->vl_api_registration_pool_index); |
| 140 | ASSERT (sock_rp); |
| 141 | |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 142 | /* Add the msgbuf_t to the output vector */ |
Florin Coras | 8023ad4 | 2018-08-02 12:16:03 -0700 | [diff] [blame] | 143 | vec_add (sock_rp->output_vector, (u8 *) mb, sizeof (*mb)); |
| 144 | |
| 145 | /* Try to send the message and save any error like |
| 146 | * we do in the input epoll loop */ |
| 147 | vec_add (sock_rp->output_vector, elem, ntohl (mb->data_len)); |
| 148 | error = clib_file_write (cf); |
| 149 | unix_save_error (&unix_main, error); |
| 150 | |
| 151 | /* If we didn't finish sending everything, wait for tx space */ |
| 152 | if (vec_len (sock_rp->output_vector) > 0 |
| 153 | && !(cf->flags & UNIX_FILE_DATA_AVAILABLE_TO_WRITE)) |
| 154 | { |
| 155 | cf->flags |= UNIX_FILE_DATA_AVAILABLE_TO_WRITE; |
| 156 | fm->file_update (cf, UNIX_FILE_UPDATE_MODIFY); |
| 157 | } |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 158 | |
| 159 | #if CLIB_DEBUG > 1 |
| 160 | output_length = sizeof (*mb) + ntohl (mb->data_len); |
| 161 | clib_warning ("wrote %u bytes to fd %d", output_length, |
| 162 | cf->file_descriptor); |
| 163 | #endif |
| 164 | |
| 165 | vl_msg_api_free ((void *) elem); |
| 166 | } |
| 167 | |
| 168 | void |
Florin Coras | e86a8ed | 2018-01-05 03:20:25 -0800 | [diff] [blame] | 169 | vl_socket_free_registration_index (u32 pool_index) |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 170 | { |
| 171 | int i; |
| 172 | vl_api_registration_t *rp; |
| 173 | if (pool_is_free_index (socket_main.registration_pool, pool_index)) |
| 174 | { |
| 175 | clib_warning ("main pool index %d already free", pool_index); |
| 176 | return; |
| 177 | } |
| 178 | rp = pool_elt_at_index (socket_main.registration_pool, pool_index); |
| 179 | |
| 180 | ASSERT (rp->registration_type != REGISTRATION_TYPE_FREE); |
| 181 | for (i = 0; i < vec_len (rp->additional_fds_to_close); i++) |
| 182 | if (close (rp->additional_fds_to_close[i]) < 0) |
| 183 | clib_unix_warning ("close"); |
| 184 | vec_free (rp->additional_fds_to_close); |
| 185 | vec_free (rp->name); |
| 186 | vec_free (rp->unprocessed_input); |
| 187 | vec_free (rp->output_vector); |
| 188 | rp->registration_type = REGISTRATION_TYPE_FREE; |
| 189 | pool_put (socket_main.registration_pool, rp); |
| 190 | } |
| 191 | |
| 192 | void |
Florin Coras | e86a8ed | 2018-01-05 03:20:25 -0800 | [diff] [blame] | 193 | vl_socket_process_api_msg (clib_file_t * uf, vl_api_registration_t * rp, |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 194 | i8 * input_v) |
| 195 | { |
| 196 | msgbuf_t *mbp = (msgbuf_t *) input_v; |
| 197 | |
| 198 | u8 *the_msg = (u8 *) (mbp->data); |
| 199 | socket_main.current_uf = uf; |
| 200 | socket_main.current_rp = rp; |
| 201 | vl_msg_api_socket_handler (the_msg); |
| 202 | socket_main.current_uf = 0; |
| 203 | socket_main.current_rp = 0; |
| 204 | } |
| 205 | |
| 206 | clib_error_t * |
| 207 | vl_socket_read_ready (clib_file_t * uf) |
| 208 | { |
| 209 | clib_file_main_t *fm = &file_main; |
| 210 | vlib_main_t *vm = vlib_get_main (); |
| 211 | vl_api_registration_t *rp; |
| 212 | int n; |
| 213 | i8 *msg_buffer = 0; |
| 214 | u8 *data_for_process; |
| 215 | u32 msg_len; |
| 216 | u32 save_input_buffer_length = vec_len (socket_main.input_buffer); |
| 217 | vl_socket_args_for_process_t *a; |
| 218 | msgbuf_t *mbp; |
| 219 | int mbp_set = 0; |
| 220 | |
| 221 | rp = pool_elt_at_index (socket_main.registration_pool, uf->private_data); |
| 222 | |
| 223 | n = read (uf->file_descriptor, socket_main.input_buffer, |
| 224 | vec_len (socket_main.input_buffer)); |
| 225 | |
| 226 | if (n <= 0 && errno != EAGAIN) |
| 227 | { |
| 228 | clib_file_del (fm, uf); |
| 229 | |
| 230 | if (!pool_is_free (socket_main.registration_pool, rp)) |
| 231 | { |
| 232 | u32 index = rp - socket_main.registration_pool; |
Florin Coras | e86a8ed | 2018-01-05 03:20:25 -0800 | [diff] [blame] | 233 | vl_socket_free_registration_index (index); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 234 | } |
| 235 | else |
| 236 | { |
| 237 | clib_warning ("client index %d already free?", |
| 238 | rp->vl_api_registration_pool_index); |
| 239 | } |
| 240 | return 0; |
| 241 | } |
| 242 | |
| 243 | _vec_len (socket_main.input_buffer) = n; |
| 244 | |
| 245 | /* |
| 246 | * Look for bugs here. This code is tricky because |
| 247 | * data read from a stream socket does not honor message |
| 248 | * boundaries. In the case of a long message (>4K bytes) |
| 249 | * we have to do (at least) 2 reads, etc. |
| 250 | */ |
| 251 | do |
| 252 | { |
| 253 | if (vec_len (rp->unprocessed_input)) |
| 254 | { |
| 255 | vec_append (rp->unprocessed_input, socket_main.input_buffer); |
| 256 | msg_buffer = rp->unprocessed_input; |
| 257 | } |
| 258 | else |
| 259 | { |
| 260 | msg_buffer = socket_main.input_buffer; |
| 261 | mbp_set = 0; |
| 262 | } |
| 263 | |
| 264 | if (mbp_set == 0) |
| 265 | { |
| 266 | /* Any chance that we have a complete message? */ |
| 267 | if (vec_len (msg_buffer) <= sizeof (msgbuf_t)) |
| 268 | goto save_and_split; |
| 269 | |
| 270 | mbp = (msgbuf_t *) msg_buffer; |
| 271 | msg_len = ntohl (mbp->data_len); |
| 272 | mbp_set = 1; |
| 273 | } |
| 274 | |
| 275 | /* We don't have the entire message yet. */ |
| 276 | if (mbp_set == 0 |
| 277 | || (msg_len + sizeof (msgbuf_t)) > vec_len (msg_buffer)) |
| 278 | { |
| 279 | save_and_split: |
| 280 | /* if we were using the input buffer save the fragment */ |
| 281 | if (msg_buffer == socket_main.input_buffer) |
| 282 | { |
| 283 | ASSERT (vec_len (rp->unprocessed_input) == 0); |
| 284 | vec_validate (rp->unprocessed_input, vec_len (msg_buffer) - 1); |
Dave Barach | 178cf49 | 2018-11-13 16:34:13 -0500 | [diff] [blame] | 285 | clib_memcpy_fast (rp->unprocessed_input, msg_buffer, |
| 286 | vec_len (msg_buffer)); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 287 | _vec_len (rp->unprocessed_input) = vec_len (msg_buffer); |
| 288 | } |
| 289 | _vec_len (socket_main.input_buffer) = save_input_buffer_length; |
| 290 | return 0; |
| 291 | } |
| 292 | |
| 293 | data_for_process = (u8 *) vec_dup (msg_buffer); |
| 294 | _vec_len (data_for_process) = (msg_len + sizeof (msgbuf_t)); |
| 295 | pool_get (socket_main.process_args, a); |
| 296 | a->clib_file = uf; |
| 297 | a->regp = rp; |
| 298 | a->data = data_for_process; |
| 299 | |
Florin Coras | e86a8ed | 2018-01-05 03:20:25 -0800 | [diff] [blame] | 300 | vlib_process_signal_event (vm, vl_api_clnt_node.index, |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 301 | SOCKET_READ_EVENT, |
| 302 | a - socket_main.process_args); |
| 303 | if (n > (msg_len + sizeof (*mbp))) |
| 304 | vec_delete (msg_buffer, msg_len + sizeof (*mbp), 0); |
| 305 | else |
| 306 | _vec_len (msg_buffer) = 0; |
| 307 | n -= msg_len + sizeof (msgbuf_t); |
| 308 | msg_len = 0; |
| 309 | mbp_set = 0; |
| 310 | } |
| 311 | while (n > 0); |
| 312 | |
| 313 | _vec_len (socket_main.input_buffer) = save_input_buffer_length; |
| 314 | |
| 315 | return 0; |
| 316 | } |
| 317 | |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 318 | clib_error_t * |
| 319 | vl_socket_write_ready (clib_file_t * uf) |
| 320 | { |
| 321 | clib_file_main_t *fm = &file_main; |
| 322 | vl_api_registration_t *rp; |
| 323 | int n; |
| 324 | |
| 325 | rp = pool_elt_at_index (socket_main.registration_pool, uf->private_data); |
| 326 | |
| 327 | /* Flush output vector. */ |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 328 | size_t total_bytes = vec_len (rp->output_vector); |
| 329 | size_t bytes_to_send, remaining_bytes = total_bytes; |
| 330 | void *p = rp->output_vector; |
| 331 | while (remaining_bytes > 0) |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 332 | { |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 333 | bytes_to_send = remaining_bytes > 4096 ? 4096 : remaining_bytes; |
| 334 | n = write (uf->file_descriptor, p, bytes_to_send); |
| 335 | if (n < 0) |
Florin Coras | 8023ad4 | 2018-08-02 12:16:03 -0700 | [diff] [blame] | 336 | { |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 337 | if (errno == EAGAIN) |
| 338 | { |
| 339 | break; |
| 340 | } |
| 341 | #if DEBUG > 2 |
| 342 | clib_warning ("write error, close the file...\n"); |
| 343 | #endif |
| 344 | clib_file_del (fm, uf); |
| 345 | vl_socket_free_registration_index (rp - |
| 346 | socket_main.registration_pool); |
| 347 | return 0; |
Florin Coras | 8023ad4 | 2018-08-02 12:16:03 -0700 | [diff] [blame] | 348 | } |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 349 | remaining_bytes -= bytes_to_send; |
| 350 | p += bytes_to_send; |
| 351 | } |
| 352 | |
| 353 | vec_delete (rp->output_vector, total_bytes - remaining_bytes, 0); |
| 354 | if (vec_len (rp->output_vector) <= 0 |
| 355 | && (uf->flags & UNIX_FILE_DATA_AVAILABLE_TO_WRITE)) |
| 356 | { |
| 357 | uf->flags &= ~UNIX_FILE_DATA_AVAILABLE_TO_WRITE; |
| 358 | fm->file_update (uf, UNIX_FILE_UPDATE_MODIFY); |
Florin Coras | 8023ad4 | 2018-08-02 12:16:03 -0700 | [diff] [blame] | 359 | } |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 360 | |
| 361 | return 0; |
| 362 | } |
| 363 | |
| 364 | clib_error_t * |
| 365 | vl_socket_error_ready (clib_file_t * uf) |
| 366 | { |
| 367 | vl_api_registration_t *rp; |
| 368 | clib_file_main_t *fm = &file_main; |
| 369 | |
| 370 | rp = pool_elt_at_index (socket_main.registration_pool, uf->private_data); |
| 371 | clib_file_del (fm, uf); |
Florin Coras | e86a8ed | 2018-01-05 03:20:25 -0800 | [diff] [blame] | 372 | vl_socket_free_registration_index (rp - socket_main.registration_pool); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 373 | |
| 374 | return 0; |
| 375 | } |
| 376 | |
| 377 | void |
| 378 | socksvr_file_add (clib_file_main_t * fm, int fd) |
| 379 | { |
| 380 | vl_api_registration_t *rp; |
| 381 | clib_file_t template = { 0 }; |
| 382 | |
| 383 | pool_get (socket_main.registration_pool, rp); |
Dave Barach | b7b9299 | 2018-10-17 10:38:51 -0400 | [diff] [blame] | 384 | clib_memset (rp, 0, sizeof (*rp)); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 385 | |
| 386 | template.read_function = vl_socket_read_ready; |
| 387 | template.write_function = vl_socket_write_ready; |
| 388 | template.error_function = vl_socket_error_ready; |
| 389 | template.file_descriptor = fd; |
| 390 | template.private_data = rp - socket_main.registration_pool; |
| 391 | |
| 392 | rp->registration_type = REGISTRATION_TYPE_SOCKET_SERVER; |
| 393 | rp->vl_api_registration_pool_index = rp - socket_main.registration_pool; |
| 394 | rp->clib_file_index = clib_file_add (fm, &template); |
| 395 | } |
| 396 | |
| 397 | static clib_error_t * |
| 398 | socksvr_accept_ready (clib_file_t * uf) |
| 399 | { |
| 400 | clib_file_main_t *fm = &file_main; |
| 401 | socket_main_t *sm = &socket_main; |
| 402 | clib_socket_t *sock = &sm->socksvr_listen_socket; |
| 403 | clib_socket_t client; |
| 404 | clib_error_t *error; |
| 405 | |
| 406 | error = clib_socket_accept (sock, &client); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 407 | if (error) |
| 408 | return error; |
| 409 | |
| 410 | socksvr_file_add (fm, client.fd); |
| 411 | return 0; |
| 412 | } |
| 413 | |
| 414 | static clib_error_t * |
| 415 | socksvr_bogus_write (clib_file_t * uf) |
| 416 | { |
| 417 | clib_warning ("why am I here?"); |
| 418 | return 0; |
| 419 | } |
| 420 | |
| 421 | /* |
| 422 | * vl_api_sockclnt_create_t_handler |
| 423 | */ |
| 424 | void |
| 425 | vl_api_sockclnt_create_t_handler (vl_api_sockclnt_create_t * mp) |
| 426 | { |
| 427 | vl_api_registration_t *regp; |
| 428 | vl_api_sockclnt_create_reply_t *rp; |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 429 | api_main_t *am = &api_main; |
| 430 | hash_pair_t *hp; |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 431 | int rv = 0; |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 432 | u32 nmsg = hash_elts (am->msg_index_by_name_and_crc); |
| 433 | u32 i = 0; |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 434 | |
| 435 | regp = socket_main.current_rp; |
| 436 | |
| 437 | ASSERT (regp->registration_type == REGISTRATION_TYPE_SOCKET_SERVER); |
| 438 | |
| 439 | regp->name = format (0, "%s%c", mp->name, 0); |
| 440 | |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 441 | u32 size = sizeof (*rp) + (nmsg * sizeof (vl_api_message_table_entry_t)); |
| 442 | rp = vl_msg_api_alloc (size); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 443 | rp->_vl_msg_id = htons (VL_API_SOCKCLNT_CREATE_REPLY); |
Florin Coras | 2881dec | 2018-10-02 18:29:25 -0700 | [diff] [blame] | 444 | rp->index = htonl (sock_api_registration_handle (regp)); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 445 | rp->context = mp->context; |
| 446 | rp->response = htonl (rv); |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 447 | rp->count = htons (nmsg); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 448 | |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 449 | /* *INDENT-OFF* */ |
| 450 | hash_foreach_pair (hp, am->msg_index_by_name_and_crc, |
| 451 | ({ |
| 452 | rp->message_table[i].index = htons(hp->value[0]); |
| 453 | strncpy((char *)rp->message_table[i].name, (char *)hp->key, 64-1); |
| 454 | i++; |
| 455 | })); |
| 456 | /* *INDENT-ON* */ |
Florin Coras | e86a8ed | 2018-01-05 03:20:25 -0800 | [diff] [blame] | 457 | vl_api_send_msg (regp, (u8 *) rp); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 458 | } |
| 459 | |
| 460 | /* |
| 461 | * vl_api_sockclnt_delete_t_handler |
| 462 | */ |
| 463 | void |
| 464 | vl_api_sockclnt_delete_t_handler (vl_api_sockclnt_delete_t * mp) |
| 465 | { |
| 466 | vl_api_registration_t *regp; |
| 467 | vl_api_sockclnt_delete_reply_t *rp; |
| 468 | |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 469 | regp = vl_api_client_index_to_registration (mp->client_index); |
| 470 | if (!regp) |
| 471 | return; |
| 472 | |
Ole Troan | 3c1cf2c | 2019-01-05 11:27:54 +0100 | [diff] [blame] | 473 | u32 reg_index = socket_api_registration_handle_to_index (ntohl (mp->index)); |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 474 | rp = vl_msg_api_alloc (sizeof (*rp)); |
| 475 | rp->_vl_msg_id = htons (VL_API_SOCKCLNT_DELETE_REPLY); |
| 476 | rp->context = mp->context; |
| 477 | |
| 478 | if (!pool_is_free_index (socket_main.registration_pool, reg_index)) |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 479 | { |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 480 | rp->response = htonl (1); |
Florin Coras | e86a8ed | 2018-01-05 03:20:25 -0800 | [diff] [blame] | 481 | vl_api_send_msg (regp, (u8 *) rp); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 482 | |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 483 | vl_api_registration_del_file (regp); |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 484 | vl_socket_free_registration_index (reg_index); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 485 | } |
| 486 | else |
| 487 | { |
Ole Troan | 94495f2 | 2018-08-02 11:58:12 +0200 | [diff] [blame] | 488 | clib_warning ("unknown client ID %d", reg_index); |
| 489 | rp->response = htonl (-1); |
| 490 | vl_api_send_msg (regp, (u8 *) rp); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 491 | } |
| 492 | } |
| 493 | |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 494 | clib_error_t * |
Florin Coras | 466f289 | 2018-08-03 02:50:43 -0700 | [diff] [blame] | 495 | 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] | 496 | { |
| 497 | struct msghdr mh = { 0 }; |
| 498 | struct iovec iov[1]; |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 499 | char ctl[CMSG_SPACE (sizeof (int) * n_fds)]; |
Florin Coras | 466f289 | 2018-08-03 02:50:43 -0700 | [diff] [blame] | 500 | struct cmsghdr *cmsg; |
| 501 | char *msg = "fdmsg"; |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 502 | int rv; |
| 503 | |
| 504 | iov[0].iov_base = msg; |
| 505 | iov[0].iov_len = strlen (msg); |
| 506 | mh.msg_iov = iov; |
| 507 | mh.msg_iovlen = 1; |
| 508 | |
Dave Barach | b7b9299 | 2018-10-17 10:38:51 -0400 | [diff] [blame] | 509 | clib_memset (&ctl, 0, sizeof (ctl)); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 510 | mh.msg_control = ctl; |
| 511 | mh.msg_controllen = sizeof (ctl); |
| 512 | cmsg = CMSG_FIRSTHDR (&mh); |
Florin Coras | 466f289 | 2018-08-03 02:50:43 -0700 | [diff] [blame] | 513 | cmsg->cmsg_len = CMSG_LEN (sizeof (int) * n_fds); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 514 | cmsg->cmsg_level = SOL_SOCKET; |
| 515 | cmsg->cmsg_type = SCM_RIGHTS; |
Dave Barach | 178cf49 | 2018-11-13 16:34:13 -0500 | [diff] [blame] | 516 | clib_memcpy_fast (CMSG_DATA (cmsg), fds, sizeof (int) * n_fds); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 517 | |
| 518 | rv = sendmsg (socket_fd, &mh, 0); |
| 519 | if (rv < 0) |
| 520 | return clib_error_return_unix (0, "sendmsg"); |
| 521 | return 0; |
| 522 | } |
| 523 | |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 524 | vl_api_shm_elem_config_t * |
| 525 | vl_api_make_shm_config (vl_api_sock_init_shm_t * mp) |
| 526 | { |
| 527 | vl_api_shm_elem_config_t *config = 0, *c; |
| 528 | u64 cfg; |
| 529 | int i; |
| 530 | |
| 531 | if (!mp->nitems) |
| 532 | { |
Dave Barach | 7895872 | 2018-05-10 16:44:27 -0400 | [diff] [blame] | 533 | vec_validate (config, 6); |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 534 | config[0].type = VL_API_VLIB_RING; |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 535 | config[0].size = 256; |
Dave Barach | 7895872 | 2018-05-10 16:44:27 -0400 | [diff] [blame] | 536 | config[0].count = 32; |
| 537 | |
| 538 | config[1].type = VL_API_VLIB_RING; |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 539 | config[1].size = 1024; |
Dave Barach | 7895872 | 2018-05-10 16:44:27 -0400 | [diff] [blame] | 540 | config[1].count = 16; |
| 541 | |
| 542 | config[2].type = VL_API_VLIB_RING; |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 543 | config[2].size = 4096; |
Dave Barach | 7895872 | 2018-05-10 16:44:27 -0400 | [diff] [blame] | 544 | config[2].count = 2; |
| 545 | |
| 546 | config[3].type = VL_API_CLIENT_RING; |
| 547 | config[3].size = 256; |
| 548 | config[3].count = 32; |
| 549 | |
| 550 | config[4].type = VL_API_CLIENT_RING; |
| 551 | config[4].size = 1024; |
| 552 | config[4].count = 16; |
| 553 | |
| 554 | config[5].type = VL_API_CLIENT_RING; |
| 555 | config[5].size = 4096; |
| 556 | config[5].count = 2; |
| 557 | |
| 558 | config[6].type = VL_API_QUEUE; |
| 559 | config[6].count = 128; |
| 560 | config[6].size = sizeof (uword); |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 561 | } |
| 562 | else |
| 563 | { |
| 564 | vec_validate (config, mp->nitems - 1); |
| 565 | for (i = 0; i < mp->nitems; i++) |
| 566 | { |
| 567 | cfg = mp->configs[i]; |
| 568 | /* Pretty much a hack but it avoids defining our own api type |
| 569 | * in memclnt.api */ |
| 570 | c = (vl_api_shm_elem_config_t *) & cfg; |
| 571 | config[i].type = c->type; |
| 572 | config[i].count = c->count; |
| 573 | config[i].size = c->size; |
| 574 | } |
| 575 | } |
| 576 | return config; |
| 577 | } |
| 578 | |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 579 | /* |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 580 | * Bootstrap shm api using the socket api |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 581 | */ |
| 582 | void |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 583 | 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] | 584 | { |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 585 | vl_api_sock_init_shm_reply_t *rmp; |
Florin Coras | 4d9b9d8 | 2018-01-14 12:25:50 -0800 | [diff] [blame] | 586 | ssvm_private_t _memfd_private, *memfd = &_memfd_private; |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 587 | svm_map_region_args_t _args, *a = &_args; |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 588 | vl_api_registration_t *regp; |
| 589 | api_main_t *am = &api_main; |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 590 | svm_region_t *vlib_rp; |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 591 | clib_file_t *cf; |
| 592 | vl_api_shm_elem_config_t *config = 0; |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 593 | vl_shmem_hdr_t *shmem_hdr; |
Florin Coras | 1f30a59 | 2019-05-08 19:57:24 -0700 | [diff] [blame] | 594 | int rv, tries = 1000; |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 595 | |
| 596 | regp = vl_api_client_index_to_registration (mp->client_index); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 597 | if (regp == 0) |
| 598 | { |
| 599 | clib_warning ("API client disconnected"); |
| 600 | return; |
| 601 | } |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 602 | if (regp->registration_type != REGISTRATION_TYPE_SOCKET_SERVER) |
| 603 | { |
| 604 | rv = -31; /* VNET_API_ERROR_INVALID_REGISTRATION */ |
| 605 | goto reply; |
| 606 | } |
| 607 | |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 608 | /* |
| 609 | * Set up a memfd segment of the requested size wherein the |
| 610 | * shmem data structures will be initialized |
| 611 | */ |
Dave Barach | b7b9299 | 2018-10-17 10:38:51 -0400 | [diff] [blame] | 612 | clib_memset (memfd, 0, sizeof (*memfd)); |
Florin Coras | 4d9b9d8 | 2018-01-14 12:25:50 -0800 | [diff] [blame] | 613 | memfd->ssvm_size = mp->requested_size; |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 614 | memfd->requested_va = 0ULL; |
| 615 | memfd->i_am_master = 1; |
| 616 | memfd->name = format (0, "%s%c", regp->name, 0); |
| 617 | |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 618 | if ((rv = ssvm_master_init_memfd (memfd))) |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 619 | goto reply; |
| 620 | |
| 621 | /* Remember to close this fd when the socket connection goes away */ |
| 622 | vec_add1 (regp->additional_fds_to_close, memfd->fd); |
| 623 | |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 624 | /* |
| 625 | * Create a plausible svm_region in the memfd backed segment |
| 626 | */ |
Dave Barach | b7b9299 | 2018-10-17 10:38:51 -0400 | [diff] [blame] | 627 | clib_memset (a, 0, sizeof (*a)); |
Florin Coras | 4d9b9d8 | 2018-01-14 12:25:50 -0800 | [diff] [blame] | 628 | a->baseva = memfd->sh->ssvm_va + MMAP_PAGESIZE; |
| 629 | a->size = memfd->ssvm_size - MMAP_PAGESIZE; |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 630 | /* $$$$ might want a different config parameter */ |
| 631 | a->pvt_heap_size = am->api_pvt_heap_size; |
| 632 | a->flags = SVM_FLAGS_MHEAP; |
| 633 | svm_region_init_mapped_region (a, (svm_region_t *) a->baseva); |
| 634 | |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 635 | /* |
| 636 | * Part deux, initialize the svm_region_t shared-memory header |
| 637 | * api allocation rings, and so on. |
| 638 | */ |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 639 | config = vl_api_make_shm_config (mp); |
| 640 | vlib_rp = (svm_region_t *) a->baseva; |
| 641 | vl_init_shmem (vlib_rp, config, 1 /* is_vlib (dont-care) */ , |
| 642 | 1 /* is_private */ ); |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 643 | |
| 644 | /* Remember who created this. Needs to be post vl_init_shmem */ |
| 645 | shmem_hdr = (vl_shmem_hdr_t *) vlib_rp->user_ctx; |
| 646 | shmem_hdr->clib_file_index = vl_api_registration_file_index (regp); |
| 647 | |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 648 | vec_add1 (am->vlib_private_rps, vlib_rp); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 649 | memfd->sh->ready = 1; |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 650 | vec_free (config); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 651 | |
| 652 | /* Recompute the set of input queues to poll in memclnt_process */ |
| 653 | vec_reset_length (vl_api_queue_cursizes); |
| 654 | |
| 655 | reply: |
| 656 | |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 657 | rmp = vl_msg_api_alloc (sizeof (*rmp)); |
| 658 | rmp->_vl_msg_id = htons (VL_API_SOCK_INIT_SHM_REPLY); |
| 659 | rmp->context = mp->context; |
| 660 | rmp->retval = htonl (rv); |
| 661 | |
Florin Coras | 8023ad4 | 2018-08-02 12:16:03 -0700 | [diff] [blame] | 662 | /* |
| 663 | * Note: The reply message needs to make it out the back door |
| 664 | * before we send the magic fd message. That's taken care of by |
| 665 | * the send function. |
| 666 | */ |
| 667 | vl_socket_api_send (regp, (u8 *) rmp); |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 668 | |
| 669 | if (rv != 0) |
| 670 | return; |
| 671 | |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 672 | /* Send the magic "here's your sign (aka fd)" socket message */ |
Florin Coras | 8023ad4 | 2018-08-02 12:16:03 -0700 | [diff] [blame] | 673 | cf = vl_api_registration_file (regp); |
Florin Coras | 1f30a59 | 2019-05-08 19:57:24 -0700 | [diff] [blame] | 674 | |
| 675 | /* Wait for reply to be consumed before sending the fd */ |
| 676 | while (tries-- > 0) |
| 677 | { |
| 678 | int bytes; |
| 679 | rv = ioctl (cf->file_descriptor, TIOCOUTQ, &bytes); |
| 680 | if (rv < 0) |
| 681 | { |
| 682 | clib_unix_warning ("ioctl returned"); |
| 683 | break; |
| 684 | } |
| 685 | if (bytes == 0) |
| 686 | break; |
| 687 | usleep (1e3); |
| 688 | } |
| 689 | |
Florin Coras | 466f289 | 2018-08-03 02:50:43 -0700 | [diff] [blame] | 690 | vl_sock_api_send_fd_msg (cf->file_descriptor, &memfd->fd, 1); |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 691 | } |
| 692 | |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 693 | #define foreach_vlib_api_msg \ |
| 694 | _(SOCKCLNT_CREATE, sockclnt_create) \ |
| 695 | _(SOCKCLNT_DELETE, sockclnt_delete) \ |
Dave Barach | 7895872 | 2018-05-10 16:44:27 -0400 | [diff] [blame] | 696 | _(SOCK_INIT_SHM, sock_init_shm) |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 697 | |
| 698 | clib_error_t * |
Florin Coras | e86a8ed | 2018-01-05 03:20:25 -0800 | [diff] [blame] | 699 | vl_sock_api_init (vlib_main_t * vm) |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 700 | { |
| 701 | clib_file_main_t *fm = &file_main; |
| 702 | clib_file_t template = { 0 }; |
| 703 | vl_api_registration_t *rp; |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 704 | socket_main_t *sm = &socket_main; |
| 705 | clib_socket_t *sock = &sm->socksvr_listen_socket; |
| 706 | clib_error_t *error; |
| 707 | |
| 708 | /* If not explicitly configured, do not bind/enable, etc. */ |
| 709 | if (sm->socket_name == 0) |
| 710 | return 0; |
| 711 | |
Florin Coras | 90a6398 | 2017-12-19 04:50:01 -0800 | [diff] [blame] | 712 | #define _(N,n) \ |
| 713 | vl_msg_api_set_handlers(VL_API_##N, #n, \ |
| 714 | vl_api_##n##_t_handler, \ |
| 715 | vl_noop_handler, \ |
| 716 | vl_api_##n##_t_endian, \ |
| 717 | vl_api_##n##_t_print, \ |
| 718 | sizeof(vl_api_##n##_t), 1); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 719 | foreach_vlib_api_msg; |
| 720 | #undef _ |
| 721 | |
| 722 | vec_resize (sm->input_buffer, 4096); |
| 723 | |
| 724 | sock->config = (char *) sm->socket_name; |
| 725 | |
| 726 | /* mkdir of file socket, only under /run */ |
| 727 | if (strncmp (sock->config, "/run", 4) == 0) |
| 728 | { |
| 729 | u8 *tmp = format (0, "%s", sock->config); |
| 730 | int i = vec_len (tmp); |
| 731 | while (i && tmp[--i] != '/') |
| 732 | ; |
| 733 | |
| 734 | tmp[i] = 0; |
| 735 | |
| 736 | if (i) |
| 737 | vlib_unix_recursive_mkdir ((char *) tmp); |
| 738 | vec_free (tmp); |
| 739 | } |
| 740 | |
Ole Troan | 4ff09ae | 2019-04-15 11:27:22 +0200 | [diff] [blame] | 741 | 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] | 742 | error = clib_socket_init (sock); |
| 743 | if (error) |
| 744 | return error; |
| 745 | |
| 746 | pool_get (sm->registration_pool, rp); |
Dave Barach | b7b9299 | 2018-10-17 10:38:51 -0400 | [diff] [blame] | 747 | clib_memset (rp, 0, sizeof (*rp)); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 748 | |
| 749 | rp->registration_type = REGISTRATION_TYPE_SOCKET_LISTEN; |
| 750 | |
| 751 | template.read_function = socksvr_accept_ready; |
| 752 | template.write_function = socksvr_bogus_write; |
| 753 | template.file_descriptor = sock->fd; |
| 754 | template.private_data = rp - sm->registration_pool; |
| 755 | |
| 756 | rp->clib_file_index = clib_file_add (fm, &template); |
| 757 | return 0; |
| 758 | } |
| 759 | |
| 760 | static clib_error_t * |
| 761 | socket_exit (vlib_main_t * vm) |
| 762 | { |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 763 | socket_main_t *sm = &socket_main; |
| 764 | vl_api_registration_t *rp; |
| 765 | |
| 766 | /* Defensive driving in case something wipes out early */ |
| 767 | if (sm->registration_pool) |
| 768 | { |
| 769 | u32 index; |
| 770 | /* *INDENT-OFF* */ |
| 771 | pool_foreach (rp, sm->registration_pool, ({ |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 772 | vl_api_registration_del_file (rp); |
| 773 | index = rp->vl_api_registration_pool_index; |
| 774 | vl_socket_free_registration_index (index); |
Dave Barach | 59b2565 | 2017-09-10 15:04:27 -0400 | [diff] [blame] | 775 | })); |
| 776 | /* *INDENT-ON* */ |
| 777 | } |
| 778 | |
| 779 | return 0; |
| 780 | } |
| 781 | |
| 782 | VLIB_MAIN_LOOP_EXIT_FUNCTION (socket_exit); |
| 783 | |
| 784 | static clib_error_t * |
| 785 | socksvr_config (vlib_main_t * vm, unformat_input_t * input) |
| 786 | { |
| 787 | socket_main_t *sm = &socket_main; |
| 788 | |
| 789 | while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) |
| 790 | { |
| 791 | if (unformat (input, "socket-name %s", &sm->socket_name)) |
| 792 | ; |
| 793 | else if (unformat (input, "default")) |
| 794 | { |
| 795 | sm->socket_name = format (0, "%s%c", API_SOCKET_FILE, 0); |
| 796 | } |
| 797 | else |
| 798 | { |
| 799 | return clib_error_return (0, "unknown input '%U'", |
| 800 | format_unformat_error, input); |
| 801 | } |
| 802 | } |
| 803 | return 0; |
| 804 | } |
| 805 | |
| 806 | VLIB_CONFIG_FUNCTION (socksvr_config, "socksvr"); |
| 807 | |
| 808 | clib_error_t * |
| 809 | vlibsocket_init (vlib_main_t * vm) |
| 810 | { |
| 811 | return 0; |
| 812 | } |
| 813 | |
| 814 | VLIB_INIT_FUNCTION (vlibsocket_init); |
| 815 | |
| 816 | /* |
| 817 | * fd.io coding-style-patch-verification: ON |
| 818 | * |
| 819 | * Local Variables: |
| 820 | * eval: (c-set-style "gnu") |
| 821 | * End: |
| 822 | */ |