Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2015-2016 Cisco and/or its affiliates. |
| 3 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 4 | * you may not use this file except in compliance with the License. |
| 5 | * You may obtain a copy of the License at: |
| 6 | * |
| 7 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 8 | * |
| 9 | * Unless required by applicable law or agreed to in writing, software |
| 10 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 11 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 12 | * See the License for the specific language governing permissions and |
| 13 | * limitations under the License. |
| 14 | */ |
| 15 | |
| 16 | #include <vnet/vnet.h> |
| 17 | #include <vlibmemory/api.h> |
| 18 | #include <vnet/session/application.h> |
Florin Coras | 1c71045 | 2017-10-17 00:03:13 -0700 | [diff] [blame] | 19 | #include <vnet/session/application_interface.h> |
| 20 | #include <vnet/session/session_rules_table.h> |
Florin Coras | 6c36f53 | 2017-11-03 18:32:34 -0700 | [diff] [blame] | 21 | #include <vnet/session/session_table.h> |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 22 | |
| 23 | #include <vnet/vnet_msg_enum.h> |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 24 | |
| 25 | #define vl_typedefs /* define message structures */ |
| 26 | #include <vnet/vnet_all_api_h.h> |
| 27 | #undef vl_typedefs |
| 28 | |
| 29 | #define vl_endianfun /* define message structures */ |
| 30 | #include <vnet/vnet_all_api_h.h> |
| 31 | #undef vl_endianfun |
| 32 | |
| 33 | /* instantiate all the print functions we know about */ |
| 34 | #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__) |
| 35 | #define vl_printfun |
| 36 | #include <vnet/vnet_all_api_h.h> |
| 37 | #undef vl_printfun |
| 38 | |
| 39 | #include <vlibapi/api_helper_macros.h> |
| 40 | |
| 41 | #define foreach_session_api_msg \ |
| 42 | _(MAP_ANOTHER_SEGMENT_REPLY, map_another_segment_reply) \ |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 43 | _(APPLICATION_ATTACH, application_attach) \ |
| 44 | _(APPLICATION_DETACH, application_detach) \ |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 45 | _(BIND_URI, bind_uri) \ |
| 46 | _(UNBIND_URI, unbind_uri) \ |
| 47 | _(CONNECT_URI, connect_uri) \ |
| 48 | _(DISCONNECT_SESSION, disconnect_session) \ |
| 49 | _(DISCONNECT_SESSION_REPLY, disconnect_session_reply) \ |
| 50 | _(ACCEPT_SESSION_REPLY, accept_session_reply) \ |
| 51 | _(RESET_SESSION_REPLY, reset_session_reply) \ |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 52 | _(BIND_SOCK, bind_sock) \ |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 53 | _(UNBIND_SOCK, unbind_sock) \ |
| 54 | _(CONNECT_SOCK, connect_sock) \ |
Florin Coras | e04c299 | 2017-03-01 08:17:34 -0800 | [diff] [blame] | 55 | _(SESSION_ENABLE_DISABLE, session_enable_disable) \ |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 56 | _(APP_NAMESPACE_ADD_DEL, app_namespace_add_del) \ |
Florin Coras | 1c71045 | 2017-10-17 00:03:13 -0700 | [diff] [blame] | 57 | _(SESSION_RULE_ADD_DEL, session_rule_add_del) \ |
Florin Coras | 6c36f53 | 2017-11-03 18:32:34 -0700 | [diff] [blame] | 58 | _(SESSION_RULES_DUMP, session_rules_dump) \ |
Florin Coras | 371ca50 | 2018-02-21 12:07:41 -0800 | [diff] [blame] | 59 | _(APPLICATION_TLS_CERT_ADD, application_tls_cert_add) \ |
| 60 | _(APPLICATION_TLS_KEY_ADD, application_tls_key_add) \ |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 61 | _(APP_WORKER_ADD_DEL, app_worker_add_del) \ |
Florin Coras | e04c299 | 2017-03-01 08:17:34 -0800 | [diff] [blame] | 62 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 63 | static int |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 64 | session_send_fds (vl_api_registration_t * reg, int fds[], int n_fds) |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 65 | { |
| 66 | clib_error_t *error; |
| 67 | if (vl_api_registration_file_index (reg) == VL_API_INVALID_FI) |
| 68 | { |
| 69 | clib_warning ("can't send memfd fd"); |
| 70 | return -1; |
| 71 | } |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 72 | error = vl_api_send_fd_msg (reg, fds, n_fds); |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 73 | if (error) |
| 74 | { |
| 75 | clib_error_report (error); |
| 76 | return -1; |
| 77 | } |
| 78 | return 0; |
| 79 | } |
| 80 | |
| 81 | static int |
| 82 | send_add_segment_callback (u32 api_client_index, const ssvm_private_t * sp) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 83 | { |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 84 | int fds[SESSION_N_FD_TYPE], n_fds = 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 85 | vl_api_map_another_segment_t *mp; |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 86 | vl_api_registration_t *reg; |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 87 | u8 fd_flags = 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 88 | |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 89 | reg = vl_mem_api_client_index_to_registration (api_client_index); |
| 90 | if (!reg) |
| 91 | { |
| 92 | clib_warning ("no registration: %u", api_client_index); |
| 93 | return -1; |
| 94 | } |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 95 | |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 96 | if (ssvm_type (sp) == SSVM_SEGMENT_MEMFD) |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 97 | { |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 98 | if (vl_api_registration_file_index (reg) == VL_API_INVALID_FI) |
| 99 | { |
| 100 | clib_warning ("can't send memfd fd"); |
| 101 | return -1; |
| 102 | } |
| 103 | |
| 104 | fd_flags |= SESSION_FD_F_MEMFD_SEGMENT; |
| 105 | fds[n_fds] = sp->fd; |
| 106 | n_fds += 1; |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 107 | } |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 108 | |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 109 | mp = vl_mem_api_alloc_as_if_client_w_reg (reg, sizeof (*mp)); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 110 | memset (mp, 0, sizeof (*mp)); |
| 111 | mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_MAP_ANOTHER_SEGMENT); |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 112 | mp->segment_size = sp->ssvm_size; |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 113 | mp->fd_flags = fd_flags; |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 114 | strncpy ((char *) mp->segment_name, (char *) sp->name, |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 115 | sizeof (mp->segment_name) - 1); |
| 116 | |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 117 | vl_msg_api_send_shmem (reg->vl_input_queue, (u8 *) & mp); |
| 118 | |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 119 | if (n_fds) |
| 120 | return session_send_fds (reg, fds, n_fds); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 121 | |
| 122 | return 0; |
| 123 | } |
| 124 | |
| 125 | static int |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 126 | send_del_segment_callback (u32 api_client_index, const ssvm_private_t * fs) |
| 127 | { |
| 128 | vl_api_unmap_segment_t *mp; |
| 129 | vl_api_registration_t *reg; |
| 130 | |
| 131 | reg = vl_mem_api_client_index_to_registration (api_client_index); |
| 132 | if (!reg) |
| 133 | { |
| 134 | clib_warning ("no registration: %u", api_client_index); |
| 135 | return -1; |
| 136 | } |
| 137 | |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 138 | mp = vl_mem_api_alloc_as_if_client_w_reg (reg, sizeof (*mp)); |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 139 | memset (mp, 0, sizeof (*mp)); |
| 140 | mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_UNMAP_SEGMENT); |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 141 | strncpy ((char *) mp->segment_name, (char *) fs->name, |
| 142 | sizeof (mp->segment_name) - 1); |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 143 | |
| 144 | vl_msg_api_send_shmem (reg->vl_input_queue, (u8 *) & mp); |
| 145 | |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 146 | return 0; |
| 147 | } |
| 148 | |
| 149 | static int |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 150 | send_app_cut_through_registration_add (u32 api_client_index, |
| 151 | u32 wrk_map_index, u64 mq_addr, |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 152 | u64 peer_mq_addr) |
| 153 | { |
| 154 | vl_api_app_cut_through_registration_add_t *mp; |
| 155 | vl_api_registration_t *reg; |
| 156 | svm_msg_q_t *mq, *peer_mq; |
| 157 | int fds[2]; |
| 158 | |
| 159 | reg = vl_mem_api_client_index_to_registration (api_client_index); |
| 160 | if (!reg) |
| 161 | { |
| 162 | clib_warning ("no registration: %u", api_client_index); |
| 163 | return -1; |
| 164 | } |
| 165 | |
| 166 | mp = vl_mem_api_alloc_as_if_client_w_reg (reg, sizeof (*mp)); |
| 167 | memset (mp, 0, sizeof (*mp)); |
| 168 | mp->_vl_msg_id = |
| 169 | clib_host_to_net_u16 (VL_API_APP_CUT_THROUGH_REGISTRATION_ADD); |
| 170 | |
| 171 | mp->evt_q_address = mq_addr; |
| 172 | mp->peer_evt_q_address = peer_mq_addr; |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 173 | mp->wrk_index = wrk_map_index; |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 174 | |
| 175 | mq = uword_to_pointer (mq_addr, svm_msg_q_t *); |
| 176 | peer_mq = uword_to_pointer (peer_mq_addr, svm_msg_q_t *); |
| 177 | |
| 178 | if (svm_msg_q_get_producer_eventfd (mq) != -1) |
| 179 | { |
| 180 | mp->fd_flags |= SESSION_FD_F_MQ_EVENTFD; |
| 181 | mp->n_fds = 2; |
| 182 | /* app will overwrite exactly the fds we pass here. So |
| 183 | * when we swap mq with peer_mq (accept vs connect) the |
| 184 | * fds will still be valid */ |
| 185 | fds[0] = svm_msg_q_get_consumer_eventfd (mq); |
| 186 | fds[1] = svm_msg_q_get_producer_eventfd (peer_mq); |
| 187 | } |
| 188 | |
| 189 | vl_msg_api_send_shmem (reg->vl_input_queue, (u8 *) & mp); |
| 190 | |
| 191 | if (mp->n_fds != 0) |
| 192 | session_send_fds (reg, fds, mp->n_fds); |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 193 | |
| 194 | return 0; |
| 195 | } |
| 196 | |
| 197 | static int |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 198 | send_session_accept_callback (stream_session_t * s) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 199 | { |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 200 | app_worker_t *server_wrk = app_worker_get (s->app_wrk_index); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 201 | transport_proto_vft_t *tp_vft; |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 202 | vl_api_accept_session_t *mp; |
| 203 | vl_api_registration_t *reg; |
| 204 | transport_connection_t *tc; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 205 | stream_session_t *listener; |
Florin Coras | 3c2fed5 | 2018-07-04 04:15:05 -0700 | [diff] [blame] | 206 | svm_msg_q_t *vpp_queue; |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 207 | application_t *server; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 208 | |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 209 | server = application_get (server_wrk->app_index); |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 210 | reg = vl_mem_api_client_index_to_registration (server->api_client_index); |
| 211 | if (!reg) |
| 212 | { |
| 213 | clib_warning ("no registration: %u", server->api_client_index); |
| 214 | return -1; |
| 215 | } |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 216 | |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 217 | mp = vl_mem_api_alloc_as_if_client_w_reg (reg, sizeof (*mp)); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 218 | memset (mp, 0, sizeof (*mp)); |
| 219 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 220 | mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_ACCEPT_SESSION); |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 221 | mp->context = server_wrk->wrk_index; |
Damjan Marion | 7bee80c | 2017-04-26 15:32:12 +0200 | [diff] [blame] | 222 | mp->server_rx_fifo = pointer_to_uword (s->server_rx_fifo); |
| 223 | mp->server_tx_fifo = pointer_to_uword (s->server_tx_fifo); |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 224 | |
| 225 | if (session_has_transport (s)) |
| 226 | { |
Florin Coras | 5c9083d | 2018-04-13 06:39:07 -0700 | [diff] [blame] | 227 | listener = listen_session_get (s->listener_index); |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 228 | mp->listener_handle = listen_session_get_handle (listener); |
| 229 | if (application_is_proxy (server)) |
| 230 | { |
| 231 | listener = |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 232 | app_worker_first_listener (server_wrk, session_get_fib_proto (s), |
| 233 | session_get_transport_proto (s)); |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 234 | if (listener) |
| 235 | mp->listener_handle = listen_session_get_handle (listener); |
| 236 | } |
| 237 | vpp_queue = session_manager_get_vpp_event_queue (s->thread_index); |
| 238 | mp->vpp_event_queue_address = pointer_to_uword (vpp_queue); |
| 239 | mp->handle = session_handle (s); |
| 240 | tp_vft = transport_protocol_get_vft (session_get_transport_proto (s)); |
| 241 | tc = tp_vft->get_connection (s->connection_index, s->thread_index); |
| 242 | mp->port = tc->rmt_port; |
| 243 | mp->is_ip4 = tc->is_ip4; |
| 244 | clib_memcpy (&mp->ip, &tc->rmt_ip, sizeof (tc->rmt_ip)); |
| 245 | } |
| 246 | else |
| 247 | { |
| 248 | local_session_t *ls = (local_session_t *) s; |
| 249 | local_session_t *ll; |
| 250 | if (application_local_session_listener_has_transport (ls)) |
| 251 | { |
Florin Coras | 5c9083d | 2018-04-13 06:39:07 -0700 | [diff] [blame] | 252 | listener = listen_session_get (ls->listener_index); |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 253 | mp->listener_handle = listen_session_get_handle (listener); |
Florin Coras | 5fda7a3 | 2018-02-14 08:04:31 -0800 | [diff] [blame] | 254 | mp->is_ip4 = session_type_is_ip4 (listener->session_type); |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 255 | } |
| 256 | else |
| 257 | { |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 258 | ll = application_get_local_listen_session (server_wrk, |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 259 | ls->listener_index); |
Florin Coras | 5fda7a3 | 2018-02-14 08:04:31 -0800 | [diff] [blame] | 260 | if (ll->transport_listener_index != ~0) |
| 261 | { |
Florin Coras | 5c9083d | 2018-04-13 06:39:07 -0700 | [diff] [blame] | 262 | listener = listen_session_get (ll->transport_listener_index); |
Florin Coras | 5fda7a3 | 2018-02-14 08:04:31 -0800 | [diff] [blame] | 263 | mp->listener_handle = listen_session_get_handle (listener); |
| 264 | } |
| 265 | else |
| 266 | { |
| 267 | mp->listener_handle = application_local_session_handle (ll); |
| 268 | } |
| 269 | mp->is_ip4 = session_type_is_ip4 (ll->listener_session_type); |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 270 | } |
| 271 | mp->handle = application_local_session_handle (ls); |
| 272 | mp->port = ls->port; |
| 273 | mp->vpp_event_queue_address = ls->client_evt_q; |
| 274 | mp->server_event_queue_address = ls->server_evt_q; |
| 275 | } |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 276 | vl_msg_api_send_shmem (reg->vl_input_queue, (u8 *) & mp); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 277 | |
| 278 | return 0; |
| 279 | } |
| 280 | |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 281 | void |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 282 | mq_send_local_session_disconnected_cb (u32 app_wrk_index, |
| 283 | local_session_t * ls) |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 284 | { |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 285 | app_worker_t *app_wrk = app_worker_get (app_wrk_index); |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 286 | svm_msg_q_msg_t _msg, *msg = &_msg; |
| 287 | session_disconnected_msg_t *mp; |
| 288 | svm_msg_q_t *app_mq; |
| 289 | session_event_t *evt; |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 290 | application_t *app; |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 291 | |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 292 | app = application_get (app_wrk->app_index); |
| 293 | app_mq = app_wrk->event_queue; |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 294 | svm_msg_q_lock_and_alloc_msg_w_ring (app_mq, SESSION_MQ_CTRL_EVT_RING, |
| 295 | SVM_Q_WAIT, msg); |
| 296 | svm_msg_q_unlock (app_mq); |
| 297 | evt = svm_msg_q_msg_data (app_mq, msg); |
| 298 | memset (evt, 0, sizeof (*evt)); |
| 299 | evt->event_type = SESSION_CTRL_EVT_DISCONNECTED; |
| 300 | mp = (session_disconnected_msg_t *) evt->data; |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 301 | mp->handle = application_local_session_handle (ls); |
| 302 | mp->context = app->api_client_index; |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 303 | svm_msg_q_add (app_mq, msg, SVM_Q_WAIT); |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 304 | } |
| 305 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 306 | static void |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 307 | send_session_disconnect_callback (stream_session_t * s) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 308 | { |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 309 | app_worker_t *app_wrk = app_worker_get (s->app_wrk_index); |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 310 | vl_api_disconnect_session_t *mp; |
| 311 | vl_api_registration_t *reg; |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 312 | application_t *app; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 313 | |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 314 | app = application_get (app_wrk->app_index); |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 315 | reg = vl_mem_api_client_index_to_registration (app->api_client_index); |
| 316 | if (!reg) |
| 317 | { |
| 318 | clib_warning ("no registration: %u", app->api_client_index); |
| 319 | return; |
| 320 | } |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 321 | |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 322 | mp = vl_mem_api_alloc_as_if_client_w_reg (reg, sizeof (*mp)); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 323 | memset (mp, 0, sizeof (*mp)); |
| 324 | mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_DISCONNECT_SESSION); |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 325 | mp->handle = session_handle (s); |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 326 | mp->context = app->api_client_index; |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 327 | vl_msg_api_send_shmem (reg->vl_input_queue, (u8 *) & mp); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 328 | } |
| 329 | |
Florin Coras | d79b41e | 2017-03-04 05:37:52 -0800 | [diff] [blame] | 330 | static void |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 331 | send_session_reset_callback (stream_session_t * s) |
Florin Coras | d79b41e | 2017-03-04 05:37:52 -0800 | [diff] [blame] | 332 | { |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 333 | app_worker_t *app_wrk = app_worker_get (s->app_wrk_index); |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 334 | vl_api_registration_t *reg; |
| 335 | vl_api_reset_session_t *mp; |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 336 | application_t *app; |
Florin Coras | d79b41e | 2017-03-04 05:37:52 -0800 | [diff] [blame] | 337 | |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 338 | app = application_get (app_wrk->app_index); |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 339 | reg = vl_mem_api_client_index_to_registration (app->api_client_index); |
| 340 | if (!reg) |
| 341 | { |
| 342 | clib_warning ("no registration: %u", app->api_client_index); |
| 343 | return; |
| 344 | } |
Florin Coras | d79b41e | 2017-03-04 05:37:52 -0800 | [diff] [blame] | 345 | |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 346 | mp = vl_mem_api_alloc_as_if_client_w_reg (reg, sizeof (*mp)); |
Florin Coras | d79b41e | 2017-03-04 05:37:52 -0800 | [diff] [blame] | 347 | memset (mp, 0, sizeof (*mp)); |
| 348 | mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_RESET_SESSION); |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 349 | mp->handle = session_handle (s); |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 350 | vl_msg_api_send_shmem (reg->vl_input_queue, (u8 *) & mp); |
Florin Coras | d79b41e | 2017-03-04 05:37:52 -0800 | [diff] [blame] | 351 | } |
| 352 | |
Dave Barach | 0194f1a | 2017-05-15 10:11:39 -0400 | [diff] [blame] | 353 | int |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 354 | send_session_connected_callback (u32 app_wrk_index, u32 api_context, |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 355 | stream_session_t * s, u8 is_fail) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 356 | { |
Dave Wallace | 33e002b | 2017-09-06 01:20:02 -0400 | [diff] [blame] | 357 | vl_api_connect_session_reply_t *mp; |
Florin Coras | ade70e4 | 2017-10-14 18:56:41 -0700 | [diff] [blame] | 358 | transport_connection_t *tc; |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 359 | vl_api_registration_t *reg; |
Florin Coras | 3c2fed5 | 2018-07-04 04:15:05 -0700 | [diff] [blame] | 360 | svm_msg_q_t *vpp_queue; |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 361 | app_worker_t *app_wrk; |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 362 | application_t *app; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 363 | |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 364 | app_wrk = app_worker_get (app_wrk_index); |
| 365 | app = application_get (app_wrk->app_index); |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 366 | reg = vl_mem_api_client_index_to_registration (app->api_client_index); |
| 367 | if (!reg) |
| 368 | { |
| 369 | clib_warning ("no registration: %u", app->api_client_index); |
| 370 | return -1; |
| 371 | } |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 372 | |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 373 | mp = vl_mem_api_alloc_as_if_client_w_reg (reg, sizeof (*mp)); |
Dave Wallace | 33e002b | 2017-09-06 01:20:02 -0400 | [diff] [blame] | 374 | mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_CONNECT_SESSION_REPLY); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 375 | mp->context = api_context; |
Dave Wallace | 965fec9 | 2017-10-17 16:19:41 -0400 | [diff] [blame] | 376 | |
| 377 | if (is_fail) |
| 378 | goto done; |
| 379 | |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 380 | if (session_has_transport (s)) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 381 | { |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 382 | tc = session_get_transport (s); |
| 383 | if (!tc) |
| 384 | { |
| 385 | is_fail = 1; |
| 386 | goto done; |
| 387 | } |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 388 | |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 389 | vpp_queue = session_manager_get_vpp_event_queue (s->thread_index); |
| 390 | mp->handle = session_handle (s); |
| 391 | mp->vpp_event_queue_address = pointer_to_uword (vpp_queue); |
| 392 | clib_memcpy (mp->lcl_ip, &tc->lcl_ip, sizeof (tc->lcl_ip)); |
| 393 | mp->is_ip4 = tc->is_ip4; |
| 394 | mp->lcl_port = tc->lcl_port; |
| 395 | mp->server_rx_fifo = pointer_to_uword (s->server_rx_fifo); |
| 396 | mp->server_tx_fifo = pointer_to_uword (s->server_tx_fifo); |
| 397 | } |
| 398 | else |
| 399 | { |
| 400 | local_session_t *ls = (local_session_t *) s; |
| 401 | mp->handle = application_local_session_handle (ls); |
| 402 | mp->lcl_port = ls->port; |
| 403 | mp->vpp_event_queue_address = ls->server_evt_q; |
| 404 | mp->client_event_queue_address = ls->client_evt_q; |
| 405 | mp->server_rx_fifo = pointer_to_uword (s->server_tx_fifo); |
| 406 | mp->server_tx_fifo = pointer_to_uword (s->server_rx_fifo); |
| 407 | } |
Dave Wallace | 965fec9 | 2017-10-17 16:19:41 -0400 | [diff] [blame] | 408 | |
| 409 | done: |
| 410 | mp->retval = is_fail ? |
| 411 | clib_host_to_net_u32 (VNET_API_ERROR_SESSION_CONNECT) : 0; |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 412 | vl_msg_api_send_shmem (reg->vl_input_queue, (u8 *) & mp); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 413 | return 0; |
| 414 | } |
| 415 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 416 | static session_cb_vft_t session_cb_vft = { |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 417 | .session_accept_callback = send_session_accept_callback, |
| 418 | .session_disconnect_callback = send_session_disconnect_callback, |
| 419 | .session_connected_callback = send_session_connected_callback, |
Florin Coras | d79b41e | 2017-03-04 05:37:52 -0800 | [diff] [blame] | 420 | .session_reset_callback = send_session_reset_callback, |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 421 | .add_segment_callback = send_add_segment_callback, |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 422 | .del_segment_callback = send_del_segment_callback, |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 423 | }; |
| 424 | |
Florin Coras | 52207f1 | 2018-07-12 14:48:06 -0700 | [diff] [blame] | 425 | static int |
| 426 | mq_send_session_accepted_cb (stream_session_t * s) |
| 427 | { |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 428 | app_worker_t *app_wrk = app_worker_get (s->app_wrk_index); |
Florin Coras | 52207f1 | 2018-07-12 14:48:06 -0700 | [diff] [blame] | 429 | svm_msg_q_msg_t _msg, *msg = &_msg; |
| 430 | svm_msg_q_t *vpp_queue, *app_mq; |
| 431 | transport_proto_vft_t *tp_vft; |
| 432 | transport_connection_t *tc; |
| 433 | stream_session_t *listener; |
| 434 | session_accepted_msg_t *mp; |
| 435 | session_event_t *evt; |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 436 | application_t *app; |
Florin Coras | 52207f1 | 2018-07-12 14:48:06 -0700 | [diff] [blame] | 437 | |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 438 | app = application_get (app_wrk->app_index); |
| 439 | app_mq = app_wrk->event_queue; |
Florin Coras | 52207f1 | 2018-07-12 14:48:06 -0700 | [diff] [blame] | 440 | svm_msg_q_lock_and_alloc_msg_w_ring (app_mq, SESSION_MQ_CTRL_EVT_RING, |
| 441 | SVM_Q_WAIT, msg); |
| 442 | svm_msg_q_unlock (app_mq); |
| 443 | |
| 444 | evt = svm_msg_q_msg_data (app_mq, msg); |
| 445 | memset (evt, 0, sizeof (*evt)); |
| 446 | evt->event_type = SESSION_CTRL_EVT_ACCEPTED; |
| 447 | mp = (session_accepted_msg_t *) evt->data; |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 448 | mp->context = app_wrk->wrk_index; |
Florin Coras | 52207f1 | 2018-07-12 14:48:06 -0700 | [diff] [blame] | 449 | mp->server_rx_fifo = pointer_to_uword (s->server_rx_fifo); |
| 450 | mp->server_tx_fifo = pointer_to_uword (s->server_tx_fifo); |
| 451 | |
| 452 | if (session_has_transport (s)) |
| 453 | { |
| 454 | listener = listen_session_get (s->listener_index); |
| 455 | mp->listener_handle = listen_session_get_handle (listener); |
| 456 | if (application_is_proxy (app)) |
| 457 | { |
| 458 | listener = |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 459 | app_worker_first_listener (app_wrk, session_get_fib_proto (s), |
| 460 | session_get_transport_proto (s)); |
Florin Coras | 52207f1 | 2018-07-12 14:48:06 -0700 | [diff] [blame] | 461 | if (listener) |
| 462 | mp->listener_handle = listen_session_get_handle (listener); |
| 463 | } |
| 464 | vpp_queue = session_manager_get_vpp_event_queue (s->thread_index); |
| 465 | mp->vpp_event_queue_address = pointer_to_uword (vpp_queue); |
| 466 | mp->handle = session_handle (s); |
| 467 | tp_vft = transport_protocol_get_vft (session_get_transport_proto (s)); |
| 468 | tc = tp_vft->get_connection (s->connection_index, s->thread_index); |
| 469 | mp->port = tc->rmt_port; |
| 470 | mp->is_ip4 = tc->is_ip4; |
| 471 | clib_memcpy (&mp->ip, &tc->rmt_ip, sizeof (tc->rmt_ip)); |
| 472 | } |
| 473 | else |
| 474 | { |
| 475 | local_session_t *ls = (local_session_t *) s; |
| 476 | local_session_t *ll; |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 477 | u8 main_thread = vlib_num_workers ()? 1 : 0; |
| 478 | |
| 479 | send_app_cut_through_registration_add (app->api_client_index, |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 480 | app_wrk->wrk_map_index, |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 481 | ls->server_evt_q, |
| 482 | ls->client_evt_q); |
| 483 | |
Florin Coras | 52207f1 | 2018-07-12 14:48:06 -0700 | [diff] [blame] | 484 | if (application_local_session_listener_has_transport (ls)) |
| 485 | { |
| 486 | listener = listen_session_get (ls->listener_index); |
| 487 | mp->listener_handle = listen_session_get_handle (listener); |
| 488 | mp->is_ip4 = session_type_is_ip4 (listener->session_type); |
| 489 | } |
| 490 | else |
| 491 | { |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 492 | ll = |
| 493 | application_get_local_listen_session (app_wrk, |
| 494 | ls->listener_index); |
Florin Coras | 52207f1 | 2018-07-12 14:48:06 -0700 | [diff] [blame] | 495 | if (ll->transport_listener_index != ~0) |
| 496 | { |
| 497 | listener = listen_session_get (ll->transport_listener_index); |
| 498 | mp->listener_handle = listen_session_get_handle (listener); |
| 499 | } |
| 500 | else |
| 501 | { |
| 502 | mp->listener_handle = application_local_session_handle (ll); |
| 503 | } |
| 504 | mp->is_ip4 = session_type_is_ip4 (ll->listener_session_type); |
| 505 | } |
| 506 | mp->handle = application_local_session_handle (ls); |
| 507 | mp->port = ls->port; |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 508 | vpp_queue = session_manager_get_vpp_event_queue (main_thread); |
Florin Coras | 54693d2 | 2018-07-17 10:46:29 -0700 | [diff] [blame] | 509 | mp->vpp_event_queue_address = pointer_to_uword (vpp_queue); |
| 510 | mp->client_event_queue_address = ls->client_evt_q; |
Florin Coras | 52207f1 | 2018-07-12 14:48:06 -0700 | [diff] [blame] | 511 | mp->server_event_queue_address = ls->server_evt_q; |
| 512 | } |
| 513 | svm_msg_q_add (app_mq, msg, SVM_Q_WAIT); |
| 514 | |
| 515 | return 0; |
| 516 | } |
| 517 | |
| 518 | static void |
| 519 | mq_send_session_disconnected_cb (stream_session_t * s) |
| 520 | { |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 521 | app_worker_t *app_wrk = app_worker_get (s->app_wrk_index); |
Florin Coras | 52207f1 | 2018-07-12 14:48:06 -0700 | [diff] [blame] | 522 | svm_msg_q_msg_t _msg, *msg = &_msg; |
| 523 | session_disconnected_msg_t *mp; |
| 524 | svm_msg_q_t *app_mq; |
| 525 | session_event_t *evt; |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 526 | application_t *app; |
Florin Coras | 52207f1 | 2018-07-12 14:48:06 -0700 | [diff] [blame] | 527 | |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 528 | app = application_get (app_wrk->app_index); |
| 529 | app_mq = app_wrk->event_queue; |
Florin Coras | 52207f1 | 2018-07-12 14:48:06 -0700 | [diff] [blame] | 530 | svm_msg_q_lock_and_alloc_msg_w_ring (app_mq, SESSION_MQ_CTRL_EVT_RING, |
| 531 | SVM_Q_WAIT, msg); |
| 532 | svm_msg_q_unlock (app_mq); |
| 533 | evt = svm_msg_q_msg_data (app_mq, msg); |
| 534 | memset (evt, 0, sizeof (*evt)); |
| 535 | evt->event_type = SESSION_CTRL_EVT_DISCONNECTED; |
| 536 | mp = (session_disconnected_msg_t *) evt->data; |
| 537 | mp->handle = session_handle (s); |
| 538 | mp->context = app->api_client_index; |
| 539 | svm_msg_q_add (app_mq, msg, SVM_Q_WAIT); |
| 540 | } |
| 541 | |
| 542 | static void |
| 543 | mq_send_session_reset_cb (stream_session_t * s) |
| 544 | { |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 545 | app_worker_t *app = app_worker_get (s->app_wrk_index); |
Florin Coras | 52207f1 | 2018-07-12 14:48:06 -0700 | [diff] [blame] | 546 | svm_msg_q_msg_t _msg, *msg = &_msg; |
| 547 | session_reset_msg_t *mp; |
| 548 | svm_msg_q_t *app_mq; |
| 549 | session_event_t *evt; |
| 550 | |
| 551 | app_mq = app->event_queue; |
| 552 | svm_msg_q_lock_and_alloc_msg_w_ring (app_mq, SESSION_MQ_CTRL_EVT_RING, |
| 553 | SVM_Q_WAIT, msg); |
| 554 | svm_msg_q_unlock (app_mq); |
| 555 | evt = svm_msg_q_msg_data (app_mq, msg); |
| 556 | memset (evt, 0, sizeof (*evt)); |
| 557 | evt->event_type = SESSION_CTRL_EVT_RESET; |
| 558 | mp = (session_reset_msg_t *) evt->data; |
| 559 | mp->handle = session_handle (s); |
| 560 | svm_msg_q_add (app_mq, msg, SVM_Q_WAIT); |
| 561 | } |
| 562 | |
| 563 | static int |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 564 | mq_send_session_connected_cb (u32 app_wrk_index, u32 api_context, |
Florin Coras | 52207f1 | 2018-07-12 14:48:06 -0700 | [diff] [blame] | 565 | stream_session_t * s, u8 is_fail) |
| 566 | { |
| 567 | svm_msg_q_msg_t _msg, *msg = &_msg; |
| 568 | session_connected_msg_t *mp; |
| 569 | svm_msg_q_t *vpp_mq, *app_mq; |
| 570 | transport_connection_t *tc; |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 571 | app_worker_t *app_wrk; |
Florin Coras | 52207f1 | 2018-07-12 14:48:06 -0700 | [diff] [blame] | 572 | session_event_t *evt; |
| 573 | application_t *app; |
| 574 | |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 575 | app_wrk = app_worker_get (app_wrk_index); |
| 576 | app = application_get (app_wrk->app_index); |
| 577 | app_mq = app_wrk->event_queue; |
Florin Coras | 52207f1 | 2018-07-12 14:48:06 -0700 | [diff] [blame] | 578 | if (!app_mq) |
| 579 | { |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 580 | clib_warning ("app %u with api index: %u not attached", app->app_index, |
Florin Coras | 52207f1 | 2018-07-12 14:48:06 -0700 | [diff] [blame] | 581 | app->api_client_index); |
| 582 | return -1; |
| 583 | } |
| 584 | |
| 585 | svm_msg_q_lock_and_alloc_msg_w_ring (app_mq, SESSION_MQ_CTRL_EVT_RING, |
| 586 | SVM_Q_WAIT, msg); |
| 587 | svm_msg_q_unlock (app_mq); |
| 588 | evt = svm_msg_q_msg_data (app_mq, msg); |
| 589 | memset (evt, 0, sizeof (*evt)); |
| 590 | evt->event_type = SESSION_CTRL_EVT_CONNECTED; |
| 591 | mp = (session_connected_msg_t *) evt->data; |
| 592 | mp->context = api_context; |
| 593 | |
| 594 | if (is_fail) |
| 595 | goto done; |
| 596 | |
| 597 | if (session_has_transport (s)) |
| 598 | { |
| 599 | tc = session_get_transport (s); |
| 600 | if (!tc) |
| 601 | { |
| 602 | is_fail = 1; |
| 603 | goto done; |
| 604 | } |
| 605 | |
| 606 | vpp_mq = session_manager_get_vpp_event_queue (s->thread_index); |
| 607 | mp->handle = session_handle (s); |
| 608 | mp->vpp_event_queue_address = pointer_to_uword (vpp_mq); |
| 609 | clib_memcpy (mp->lcl_ip, &tc->lcl_ip, sizeof (tc->lcl_ip)); |
| 610 | mp->is_ip4 = tc->is_ip4; |
| 611 | mp->lcl_port = tc->lcl_port; |
| 612 | mp->server_rx_fifo = pointer_to_uword (s->server_rx_fifo); |
| 613 | mp->server_tx_fifo = pointer_to_uword (s->server_tx_fifo); |
| 614 | } |
| 615 | else |
| 616 | { |
| 617 | local_session_t *ls = (local_session_t *) s; |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 618 | u8 main_thread = vlib_num_workers ()? 1 : 0; |
| 619 | |
| 620 | send_app_cut_through_registration_add (app->api_client_index, |
Florin Coras | 134a996 | 2018-08-28 11:32:04 -0700 | [diff] [blame] | 621 | app_wrk->wrk_map_index, |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 622 | ls->client_evt_q, |
| 623 | ls->server_evt_q); |
| 624 | |
Florin Coras | 52207f1 | 2018-07-12 14:48:06 -0700 | [diff] [blame] | 625 | mp->handle = application_local_session_handle (ls); |
| 626 | mp->lcl_port = ls->port; |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 627 | vpp_mq = session_manager_get_vpp_event_queue (main_thread); |
Florin Coras | 54693d2 | 2018-07-17 10:46:29 -0700 | [diff] [blame] | 628 | mp->vpp_event_queue_address = pointer_to_uword (vpp_mq); |
Florin Coras | 52207f1 | 2018-07-12 14:48:06 -0700 | [diff] [blame] | 629 | mp->client_event_queue_address = ls->client_evt_q; |
Florin Coras | 54693d2 | 2018-07-17 10:46:29 -0700 | [diff] [blame] | 630 | mp->server_event_queue_address = ls->server_evt_q; |
Florin Coras | 52207f1 | 2018-07-12 14:48:06 -0700 | [diff] [blame] | 631 | mp->server_rx_fifo = pointer_to_uword (s->server_tx_fifo); |
| 632 | mp->server_tx_fifo = pointer_to_uword (s->server_rx_fifo); |
| 633 | } |
| 634 | |
| 635 | done: |
| 636 | mp->retval = is_fail ? |
| 637 | clib_host_to_net_u32 (VNET_API_ERROR_SESSION_CONNECT) : 0; |
| 638 | |
| 639 | svm_msg_q_add (app_mq, msg, SVM_Q_WAIT); |
| 640 | return 0; |
| 641 | } |
| 642 | |
Florin Coras | 6011699 | 2018-08-27 09:52:18 -0700 | [diff] [blame] | 643 | static int |
| 644 | mq_send_session_bound_cb (u32 app_wrk_index, u32 api_context, |
| 645 | session_handle_t handle, int rv) |
| 646 | { |
| 647 | svm_msg_q_msg_t _msg, *msg = &_msg; |
| 648 | svm_msg_q_t *app_mq, *vpp_evt_q; |
| 649 | transport_connection_t *tc; |
| 650 | stream_session_t *ls = 0; |
| 651 | session_bound_msg_t *mp; |
| 652 | app_worker_t *app_wrk; |
| 653 | session_event_t *evt; |
| 654 | application_t *app; |
| 655 | |
| 656 | app_wrk = app_worker_get (app_wrk_index); |
| 657 | app = application_get (app_wrk->app_index); |
| 658 | app_mq = app_wrk->event_queue; |
| 659 | if (!app_mq) |
| 660 | { |
| 661 | clib_warning ("app %u with api index: %u not attached", app->app_index, |
| 662 | app->api_client_index); |
| 663 | return -1; |
| 664 | } |
| 665 | |
| 666 | svm_msg_q_lock_and_alloc_msg_w_ring (app_mq, SESSION_MQ_CTRL_EVT_RING, |
| 667 | SVM_Q_WAIT, msg); |
| 668 | svm_msg_q_unlock (app_mq); |
| 669 | evt = svm_msg_q_msg_data (app_mq, msg); |
| 670 | memset (evt, 0, sizeof (*evt)); |
| 671 | evt->event_type = SESSION_CTRL_EVT_BOUND; |
| 672 | mp = (session_bound_msg_t *) evt->data; |
| 673 | mp->context = api_context; |
| 674 | |
| 675 | if (rv) |
| 676 | goto done; |
| 677 | |
| 678 | mp->handle = handle; |
| 679 | if (application_has_global_scope (app)) |
| 680 | { |
| 681 | ls = listen_session_get_from_handle (handle); |
| 682 | tc = listen_session_get_transport (ls); |
| 683 | mp->lcl_port = tc->lcl_port; |
| 684 | mp->lcl_is_ip4 = tc->is_ip4; |
| 685 | clib_memcpy (mp->lcl_ip, &tc->lcl_ip, sizeof (tc->lcl_ip)); |
| 686 | } |
| 687 | else |
| 688 | { |
| 689 | local_session_t *local; |
| 690 | local = application_get_local_listen_session_from_handle (handle); |
| 691 | mp->lcl_port = local->port; |
| 692 | mp->lcl_is_ip4 = session_type_is_ip4 (local->session_type); |
| 693 | } |
| 694 | |
| 695 | if (ls && session_transport_service_type (ls) == TRANSPORT_SERVICE_CL) |
| 696 | { |
| 697 | mp->rx_fifo = pointer_to_uword (ls->server_rx_fifo); |
| 698 | mp->tx_fifo = pointer_to_uword (ls->server_tx_fifo); |
| 699 | vpp_evt_q = session_manager_get_vpp_event_queue (0); |
| 700 | mp->vpp_evt_q = pointer_to_uword (vpp_evt_q); |
| 701 | } |
| 702 | |
| 703 | done: |
| 704 | mp->retval = rv; |
| 705 | svm_msg_q_add (app_mq, msg, SVM_Q_WAIT); |
| 706 | return 0; |
| 707 | } |
| 708 | |
Florin Coras | 52207f1 | 2018-07-12 14:48:06 -0700 | [diff] [blame] | 709 | static session_cb_vft_t session_mq_cb_vft = { |
| 710 | .session_accept_callback = mq_send_session_accepted_cb, |
| 711 | .session_disconnect_callback = mq_send_session_disconnected_cb, |
| 712 | .session_connected_callback = mq_send_session_connected_cb, |
| 713 | .session_reset_callback = mq_send_session_reset_cb, |
| 714 | .add_segment_callback = send_add_segment_callback, |
| 715 | .del_segment_callback = send_del_segment_callback, |
| 716 | }; |
| 717 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 718 | static void |
Florin Coras | e04c299 | 2017-03-01 08:17:34 -0800 | [diff] [blame] | 719 | vl_api_session_enable_disable_t_handler (vl_api_session_enable_disable_t * mp) |
| 720 | { |
| 721 | vl_api_session_enable_disable_reply_t *rmp; |
| 722 | vlib_main_t *vm = vlib_get_main (); |
| 723 | int rv = 0; |
| 724 | |
| 725 | vnet_session_enable_disable (vm, mp->is_enable); |
| 726 | REPLY_MACRO (VL_API_SESSION_ENABLE_DISABLE_REPLY); |
| 727 | } |
| 728 | |
| 729 | static void |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 730 | vl_api_application_attach_t_handler (vl_api_application_attach_t * mp) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 731 | { |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 732 | int rv = 0, fds[SESSION_N_FD_TYPE], n_fds = 0; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 733 | vl_api_application_attach_reply_t *rmp; |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 734 | ssvm_private_t *segp, *evt_q_segment; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 735 | vnet_app_attach_args_t _a, *a = &_a; |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 736 | vl_api_registration_t *reg; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 737 | clib_error_t *error = 0; |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 738 | u8 fd_flags = 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 739 | |
Florin Coras | fc804d9 | 2018-01-26 01:27:01 -0800 | [diff] [blame] | 740 | reg = vl_api_client_index_to_registration (mp->client_index); |
| 741 | if (!reg) |
| 742 | return; |
| 743 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 744 | if (session_manager_is_enabled () == 0) |
| 745 | { |
| 746 | rv = VNET_API_ERROR_FEATURE_DISABLED; |
| 747 | goto done; |
| 748 | } |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 749 | |
Florin Coras | ff6e769 | 2017-12-11 04:59:01 -0800 | [diff] [blame] | 750 | STATIC_ASSERT (sizeof (u64) * APP_OPTIONS_N_OPTIONS <= |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 751 | sizeof (mp->options), |
| 752 | "Out of options, fix api message definition"); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 753 | |
| 754 | memset (a, 0, sizeof (*a)); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 755 | a->api_client_index = mp->client_index; |
| 756 | a->options = mp->options; |
Florin Coras | 52207f1 | 2018-07-12 14:48:06 -0700 | [diff] [blame] | 757 | |
| 758 | if (a->options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_USE_MQ_FOR_CTRL_MSGS) |
| 759 | a->session_cb_vft = &session_mq_cb_vft; |
| 760 | else |
| 761 | a->session_cb_vft = &session_cb_vft; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 762 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 763 | if (mp->namespace_id_len > 64) |
| 764 | { |
| 765 | rv = VNET_API_ERROR_INVALID_VALUE; |
| 766 | goto done; |
| 767 | } |
| 768 | |
| 769 | if (mp->namespace_id_len) |
| 770 | { |
Dave Wallace | 8af2054 | 2017-10-26 03:29:30 -0400 | [diff] [blame] | 771 | vec_validate (a->namespace_id, mp->namespace_id_len - 1); |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 772 | clib_memcpy (a->namespace_id, mp->namespace_id, mp->namespace_id_len); |
| 773 | } |
| 774 | |
| 775 | if ((error = vnet_application_attach (a))) |
| 776 | { |
| 777 | rv = clib_error_get_code (error); |
| 778 | clib_error_report (error); |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 779 | vec_free (a->namespace_id); |
| 780 | goto done; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 781 | } |
| 782 | vec_free (a->namespace_id); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 783 | |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 784 | /* Send event queues segment */ |
| 785 | if ((evt_q_segment = session_manager_get_evt_q_segment ())) |
| 786 | { |
| 787 | fd_flags |= SESSION_FD_F_VPP_MQ_SEGMENT; |
| 788 | fds[n_fds] = evt_q_segment->fd; |
| 789 | n_fds += 1; |
| 790 | } |
| 791 | /* Send fifo segment fd if needed */ |
| 792 | if (ssvm_type (a->segment) == SSVM_SEGMENT_MEMFD) |
| 793 | { |
| 794 | fd_flags |= SESSION_FD_F_MEMFD_SEGMENT; |
| 795 | fds[n_fds] = a->segment->fd; |
| 796 | n_fds += 1; |
| 797 | } |
| 798 | if (a->options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_EVT_MQ_USE_EVENTFD) |
| 799 | { |
| 800 | fd_flags |= SESSION_FD_F_MQ_EVENTFD; |
| 801 | fds[n_fds] = svm_msg_q_get_producer_eventfd (a->app_evt_q); |
| 802 | n_fds += 1; |
| 803 | } |
| 804 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 805 | done: |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 806 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 807 | /* *INDENT-OFF* */ |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 808 | REPLY_MACRO2 (VL_API_APPLICATION_ATTACH_REPLY, ({ |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 809 | if (!rv) |
| 810 | { |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 811 | segp = a->segment; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 812 | rmp->segment_name_length = 0; |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 813 | rmp->segment_size = segp->ssvm_size; |
| 814 | if (vec_len (segp->name)) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 815 | { |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 816 | memcpy (rmp->segment_name, segp->name, vec_len (segp->name)); |
| 817 | rmp->segment_name_length = vec_len (segp->name); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 818 | } |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 819 | rmp->app_event_queue_address = pointer_to_uword (a->app_evt_q); |
| 820 | rmp->n_fds = n_fds; |
| 821 | rmp->fd_flags = fd_flags; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 822 | } |
| 823 | })); |
| 824 | /* *INDENT-ON* */ |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 825 | |
Florin Coras | 9936831 | 2018-08-02 10:45:44 -0700 | [diff] [blame] | 826 | if (n_fds) |
| 827 | session_send_fds (reg, fds, n_fds); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 828 | } |
| 829 | |
| 830 | static void |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 831 | vl_api_application_detach_t_handler (vl_api_application_detach_t * mp) |
| 832 | { |
| 833 | vl_api_application_detach_reply_t *rmp; |
| 834 | int rv = VNET_API_ERROR_INVALID_VALUE_2; |
| 835 | vnet_app_detach_args_t _a, *a = &_a; |
| 836 | application_t *app; |
| 837 | |
| 838 | if (session_manager_is_enabled () == 0) |
| 839 | { |
| 840 | rv = VNET_API_ERROR_FEATURE_DISABLED; |
| 841 | goto done; |
| 842 | } |
| 843 | |
| 844 | app = application_lookup (mp->client_index); |
| 845 | if (app) |
| 846 | { |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 847 | a->app_index = app->app_index; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 848 | rv = vnet_application_detach (a); |
| 849 | } |
| 850 | |
| 851 | done: |
| 852 | REPLY_MACRO (VL_API_APPLICATION_DETACH_REPLY); |
| 853 | } |
| 854 | |
| 855 | static void |
| 856 | vl_api_bind_uri_t_handler (vl_api_bind_uri_t * mp) |
| 857 | { |
Florin Coras | 7fb0fe1 | 2018-04-09 09:24:52 -0700 | [diff] [blame] | 858 | transport_connection_t *tc = 0; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 859 | vnet_bind_args_t _a, *a = &_a; |
Florin Coras | 7fb0fe1 | 2018-04-09 09:24:52 -0700 | [diff] [blame] | 860 | vl_api_bind_uri_reply_t *rmp; |
| 861 | stream_session_t *s; |
| 862 | application_t *app = 0; |
Florin Coras | 3c2fed5 | 2018-07-04 04:15:05 -0700 | [diff] [blame] | 863 | svm_msg_q_t *vpp_evt_q; |
Florin Coras | 6011699 | 2018-08-27 09:52:18 -0700 | [diff] [blame] | 864 | app_worker_t *app_wrk; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 865 | int rv; |
| 866 | |
| 867 | if (session_manager_is_enabled () == 0) |
| 868 | { |
| 869 | rv = VNET_API_ERROR_FEATURE_DISABLED; |
| 870 | goto done; |
| 871 | } |
| 872 | |
| 873 | app = application_lookup (mp->client_index); |
| 874 | if (app) |
| 875 | { |
| 876 | memset (a, 0, sizeof (*a)); |
| 877 | a->uri = (char *) mp->uri; |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 878 | a->app_index = app->app_index; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 879 | rv = vnet_bind_uri (a); |
| 880 | } |
| 881 | else |
| 882 | { |
| 883 | rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED; |
| 884 | } |
| 885 | |
| 886 | done: |
Florin Coras | 7fb0fe1 | 2018-04-09 09:24:52 -0700 | [diff] [blame] | 887 | |
| 888 | /* *INDENT-OFF* */ |
| 889 | REPLY_MACRO2 (VL_API_BIND_URI_REPLY, ({ |
| 890 | if (!rv) |
| 891 | { |
| 892 | rmp->handle = a->handle; |
Florin Coras | 7fb0fe1 | 2018-04-09 09:24:52 -0700 | [diff] [blame] | 893 | if (app && application_has_global_scope (app)) |
| 894 | { |
| 895 | s = listen_session_get_from_handle (a->handle); |
| 896 | tc = listen_session_get_transport (s); |
Florin Coras | 6c35494 | 2018-04-18 00:05:21 -0700 | [diff] [blame] | 897 | rmp->lcl_is_ip4 = tc->is_ip4; |
| 898 | rmp->lcl_port = tc->lcl_port; |
Florin Coras | 7fb0fe1 | 2018-04-09 09:24:52 -0700 | [diff] [blame] | 899 | clib_memcpy (rmp->lcl_ip, &tc->lcl_ip, sizeof(tc->lcl_ip)); |
| 900 | if (session_transport_service_type (s) == TRANSPORT_SERVICE_CL) |
| 901 | { |
| 902 | rmp->rx_fifo = pointer_to_uword (s->server_rx_fifo); |
| 903 | rmp->tx_fifo = pointer_to_uword (s->server_tx_fifo); |
| 904 | vpp_evt_q = session_manager_get_vpp_event_queue (0); |
| 905 | rmp->vpp_evt_q = pointer_to_uword (vpp_evt_q); |
| 906 | } |
| 907 | } |
| 908 | } |
| 909 | })); |
| 910 | /* *INDENT-ON* */ |
Florin Coras | 6011699 | 2018-08-27 09:52:18 -0700 | [diff] [blame] | 911 | |
| 912 | /* If app uses mq for control messages, send an mq message as well */ |
| 913 | if (app && application_use_mq_for_ctrl (app)) |
| 914 | { |
| 915 | app_wrk = application_get_worker (app, 0); |
| 916 | mq_send_session_bound_cb (app_wrk->wrk_index, mp->context, a->handle, |
| 917 | rv); |
| 918 | } |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 919 | } |
| 920 | |
| 921 | static void |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 922 | vl_api_unbind_uri_t_handler (vl_api_unbind_uri_t * mp) |
| 923 | { |
| 924 | vl_api_unbind_uri_reply_t *rmp; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 925 | application_t *app; |
| 926 | vnet_unbind_args_t _a, *a = &_a; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 927 | int rv; |
| 928 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 929 | if (session_manager_is_enabled () == 0) |
| 930 | { |
| 931 | rv = VNET_API_ERROR_FEATURE_DISABLED; |
| 932 | goto done; |
| 933 | } |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 934 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 935 | app = application_lookup (mp->client_index); |
| 936 | if (app) |
| 937 | { |
| 938 | a->uri = (char *) mp->uri; |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 939 | a->app_index = app->app_index; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 940 | rv = vnet_unbind_uri (a); |
| 941 | } |
| 942 | else |
| 943 | { |
| 944 | rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED; |
| 945 | } |
| 946 | |
| 947 | done: |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 948 | REPLY_MACRO (VL_API_UNBIND_URI_REPLY); |
| 949 | } |
| 950 | |
Florin Coras | f03a59a | 2017-06-09 21:07:32 -0700 | [diff] [blame] | 951 | static void |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 952 | vl_api_connect_uri_t_handler (vl_api_connect_uri_t * mp) |
| 953 | { |
Dave Wallace | 33e002b | 2017-09-06 01:20:02 -0400 | [diff] [blame] | 954 | vl_api_connect_session_reply_t *rmp; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 955 | vnet_connect_args_t _a, *a = &_a; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 956 | application_t *app; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 957 | clib_error_t *error = 0; |
| 958 | int rv = 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 959 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 960 | if (session_manager_is_enabled () == 0) |
| 961 | { |
| 962 | rv = VNET_API_ERROR_FEATURE_DISABLED; |
| 963 | goto done; |
| 964 | } |
Florin Coras | e04c299 | 2017-03-01 08:17:34 -0800 | [diff] [blame] | 965 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 966 | app = application_lookup (mp->client_index); |
| 967 | if (app) |
| 968 | { |
| 969 | a->uri = (char *) mp->uri; |
| 970 | a->api_context = mp->context; |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 971 | a->app_index = app->app_index; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 972 | if ((error = vnet_connect_uri (a))) |
| 973 | { |
| 974 | rv = clib_error_get_code (error); |
Florin Coras | 8f89dd0 | 2018-03-05 16:53:07 -0800 | [diff] [blame] | 975 | clib_error_report (error); |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 976 | } |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 977 | } |
| 978 | else |
| 979 | { |
| 980 | rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED; |
| 981 | } |
Florin Coras | e04c299 | 2017-03-01 08:17:34 -0800 | [diff] [blame] | 982 | |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 983 | /* |
| 984 | * Don't reply to stream (tcp) connects. The reply will come once |
| 985 | * the connection is established. In case of the redirects, the reply |
| 986 | * will come from the server app. |
| 987 | */ |
Florin Coras | 8f89dd0 | 2018-03-05 16:53:07 -0800 | [diff] [blame] | 988 | if (rv == 0) |
Florin Coras | e04c299 | 2017-03-01 08:17:34 -0800 | [diff] [blame] | 989 | return; |
| 990 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 991 | done: |
Florin Coras | e04c299 | 2017-03-01 08:17:34 -0800 | [diff] [blame] | 992 | /* *INDENT-OFF* */ |
Dave Wallace | 33e002b | 2017-09-06 01:20:02 -0400 | [diff] [blame] | 993 | REPLY_MACRO (VL_API_CONNECT_SESSION_REPLY); |
Florin Coras | e04c299 | 2017-03-01 08:17:34 -0800 | [diff] [blame] | 994 | /* *INDENT-ON* */ |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 995 | } |
| 996 | |
| 997 | static void |
| 998 | vl_api_disconnect_session_t_handler (vl_api_disconnect_session_t * mp) |
| 999 | { |
| 1000 | vl_api_disconnect_session_reply_t *rmp; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1001 | vnet_disconnect_args_t _a, *a = &_a; |
| 1002 | application_t *app; |
| 1003 | int rv = 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1004 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1005 | if (session_manager_is_enabled () == 0) |
| 1006 | { |
| 1007 | rv = VNET_API_ERROR_FEATURE_DISABLED; |
| 1008 | goto done; |
| 1009 | } |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1010 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1011 | app = application_lookup (mp->client_index); |
| 1012 | if (app) |
| 1013 | { |
| 1014 | a->handle = mp->handle; |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 1015 | a->app_index = app->app_index; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1016 | rv = vnet_disconnect_session (a); |
| 1017 | } |
| 1018 | else |
| 1019 | { |
| 1020 | rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED; |
| 1021 | } |
| 1022 | |
| 1023 | done: |
Dave Wallace | de5fec9 | 2017-11-11 22:41:34 -0500 | [diff] [blame] | 1024 | REPLY_MACRO2 (VL_API_DISCONNECT_SESSION_REPLY, rmp->handle = mp->handle); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1025 | } |
| 1026 | |
| 1027 | static void |
| 1028 | vl_api_disconnect_session_reply_t_handler (vl_api_disconnect_session_reply_t * |
| 1029 | mp) |
| 1030 | { |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1031 | vnet_disconnect_args_t _a, *a = &_a; |
| 1032 | application_t *app; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1033 | |
| 1034 | /* Client objected to disconnecting the session, log and continue */ |
| 1035 | if (mp->retval) |
| 1036 | { |
| 1037 | clib_warning ("client retval %d", mp->retval); |
| 1038 | return; |
| 1039 | } |
| 1040 | |
| 1041 | /* Disconnect has been confirmed. Confirm close to transport */ |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 1042 | app = application_lookup (mp->context); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1043 | if (app) |
| 1044 | { |
| 1045 | a->handle = mp->handle; |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 1046 | a->app_index = app->app_index; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1047 | vnet_disconnect_session (a); |
| 1048 | } |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1049 | } |
| 1050 | |
| 1051 | static void |
| 1052 | vl_api_reset_session_reply_t_handler (vl_api_reset_session_reply_t * mp) |
| 1053 | { |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 1054 | app_worker_t *app_wrk; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1055 | application_t *app; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1056 | stream_session_t *s; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1057 | u32 index, thread_index; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1058 | |
Ondrej Fabry | 6bd197e | 2018-08-15 08:46:46 +0200 | [diff] [blame] | 1059 | app = application_lookup (mp->context); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1060 | if (!app) |
| 1061 | return; |
| 1062 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 1063 | session_parse_handle (mp->handle, &index, &thread_index); |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 1064 | s = session_get_if_valid (index, thread_index); |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 1065 | if (!s) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1066 | { |
| 1067 | clib_warning ("Invalid session!"); |
| 1068 | return; |
| 1069 | } |
| 1070 | |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 1071 | app_wrk = app_worker_get (s->app_wrk_index); |
| 1072 | if (app_wrk->app_index != app->app_index) |
| 1073 | { |
| 1074 | clib_warning ("app %u does not own handle 0x%lx", app->app_index, |
| 1075 | mp->handle); |
| 1076 | return; |
| 1077 | } |
| 1078 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1079 | /* Client objected to resetting the session, log and continue */ |
| 1080 | if (mp->retval) |
| 1081 | { |
| 1082 | clib_warning ("client retval %d", mp->retval); |
| 1083 | return; |
| 1084 | } |
| 1085 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1086 | /* This comes as a response to a reset, transport only waiting for |
| 1087 | * confirmation to remove connection state, no need to disconnect */ |
| 1088 | stream_session_cleanup (s); |
| 1089 | } |
| 1090 | |
| 1091 | static void |
| 1092 | vl_api_accept_session_reply_t_handler (vl_api_accept_session_reply_t * mp) |
| 1093 | { |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 1094 | vnet_disconnect_args_t _a = { 0 }, *a = &_a; |
| 1095 | local_session_t *ls; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1096 | stream_session_t *s; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1097 | |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 1098 | /* Server isn't interested, kill the session */ |
| 1099 | if (mp->retval) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1100 | { |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 1101 | a->app_index = mp->context; |
| 1102 | a->handle = mp->handle; |
| 1103 | vnet_disconnect_session (a); |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 1104 | return; |
| 1105 | } |
| 1106 | |
| 1107 | if (session_handle_is_local (mp->handle)) |
| 1108 | { |
| 1109 | ls = application_get_local_session_from_handle (mp->handle); |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 1110 | if (!ls || ls->app_wrk_index != mp->context) |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 1111 | { |
| 1112 | clib_warning ("server %u doesn't own local handle %llu", |
| 1113 | mp->context, mp->handle); |
| 1114 | return; |
| 1115 | } |
| 1116 | if (application_local_session_connect_notify (ls)) |
| 1117 | return; |
| 1118 | ls->session_state = SESSION_STATE_READY; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1119 | } |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 1120 | else |
| 1121 | { |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 1122 | s = session_get_from_handle_if_valid (mp->handle); |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 1123 | if (!s) |
| 1124 | { |
| 1125 | clib_warning ("session doesn't exist"); |
| 1126 | return; |
| 1127 | } |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 1128 | if (s->app_wrk_index != mp->context) |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 1129 | { |
| 1130 | clib_warning ("app doesn't own session"); |
| 1131 | return; |
| 1132 | } |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 1133 | s->session_state = SESSION_STATE_READY; |
| 1134 | } |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1135 | } |
| 1136 | |
| 1137 | static void |
| 1138 | vl_api_map_another_segment_reply_t_handler (vl_api_map_another_segment_reply_t |
| 1139 | * mp) |
| 1140 | { |
| 1141 | clib_warning ("not implemented"); |
| 1142 | } |
| 1143 | |
| 1144 | static void |
| 1145 | vl_api_bind_sock_t_handler (vl_api_bind_sock_t * mp) |
| 1146 | { |
| 1147 | vl_api_bind_sock_reply_t *rmp; |
| 1148 | vnet_bind_args_t _a, *a = &_a; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 1149 | int rv = 0; |
| 1150 | clib_error_t *error; |
Florin Coras | eb2945c | 2017-11-22 10:39:09 -0800 | [diff] [blame] | 1151 | application_t *app = 0; |
Florin Coras | 6011699 | 2018-08-27 09:52:18 -0700 | [diff] [blame] | 1152 | app_worker_t *app_wrk; |
Florin Coras | dcf55ce | 2017-11-16 15:32:50 -0800 | [diff] [blame] | 1153 | stream_session_t *s; |
| 1154 | transport_connection_t *tc = 0; |
| 1155 | ip46_address_t *ip46; |
Florin Coras | 3c2fed5 | 2018-07-04 04:15:05 -0700 | [diff] [blame] | 1156 | svm_msg_q_t *vpp_evt_q; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1157 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1158 | if (session_manager_is_enabled () == 0) |
| 1159 | { |
| 1160 | rv = VNET_API_ERROR_FEATURE_DISABLED; |
| 1161 | goto done; |
| 1162 | } |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1163 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1164 | app = application_lookup (mp->client_index); |
Florin Coras | dcf55ce | 2017-11-16 15:32:50 -0800 | [diff] [blame] | 1165 | if (!app) |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1166 | { |
Florin Coras | dcf55ce | 2017-11-16 15:32:50 -0800 | [diff] [blame] | 1167 | rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED; |
| 1168 | goto done; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1169 | } |
Florin Coras | dcf55ce | 2017-11-16 15:32:50 -0800 | [diff] [blame] | 1170 | |
| 1171 | ip46 = (ip46_address_t *) mp->ip; |
| 1172 | memset (a, 0, sizeof (*a)); |
| 1173 | a->sep.is_ip4 = mp->is_ip4; |
| 1174 | a->sep.ip = *ip46; |
| 1175 | a->sep.port = mp->port; |
| 1176 | a->sep.fib_index = mp->vrf; |
| 1177 | a->sep.sw_if_index = ENDPOINT_INVALID_INDEX; |
| 1178 | a->sep.transport_proto = mp->proto; |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 1179 | a->app_index = app->app_index; |
| 1180 | a->wrk_map_index = mp->wrk_index; |
Florin Coras | dcf55ce | 2017-11-16 15:32:50 -0800 | [diff] [blame] | 1181 | |
| 1182 | if ((error = vnet_bind (a))) |
| 1183 | { |
| 1184 | rv = clib_error_get_code (error); |
| 1185 | clib_error_report (error); |
| 1186 | } |
Florin Coras | dcf55ce | 2017-11-16 15:32:50 -0800 | [diff] [blame] | 1187 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1188 | done: |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 1189 | /* *INDENT-OFF* */ |
| 1190 | REPLY_MACRO2 (VL_API_BIND_SOCK_REPLY,({ |
| 1191 | if (!rv) |
Florin Coras | dcf55ce | 2017-11-16 15:32:50 -0800 | [diff] [blame] | 1192 | { |
| 1193 | rmp->handle = a->handle; |
Florin Coras | eb2945c | 2017-11-22 10:39:09 -0800 | [diff] [blame] | 1194 | rmp->lcl_port = mp->port; |
Keith Burns (alagalah) | 60ae80f | 2018-03-15 10:04:20 -0700 | [diff] [blame] | 1195 | rmp->lcl_is_ip4 = mp->is_ip4; |
Dave Wallace | 97b1a27 | 2017-12-18 13:51:59 -0500 | [diff] [blame] | 1196 | if (app && application_has_global_scope (app)) |
Florin Coras | eb2945c | 2017-11-22 10:39:09 -0800 | [diff] [blame] | 1197 | { |
| 1198 | s = listen_session_get_from_handle (a->handle); |
| 1199 | tc = listen_session_get_transport (s); |
Florin Coras | eb2945c | 2017-11-22 10:39:09 -0800 | [diff] [blame] | 1200 | clib_memcpy (rmp->lcl_ip, &tc->lcl_ip, sizeof (tc->lcl_ip)); |
Florin Coras | 7fb0fe1 | 2018-04-09 09:24:52 -0700 | [diff] [blame] | 1201 | if (session_transport_service_type (s) == TRANSPORT_SERVICE_CL) |
| 1202 | { |
| 1203 | rmp->rx_fifo = pointer_to_uword (s->server_rx_fifo); |
| 1204 | rmp->tx_fifo = pointer_to_uword (s->server_tx_fifo); |
| 1205 | vpp_evt_q = session_manager_get_vpp_event_queue (0); |
| 1206 | rmp->vpp_evt_q = pointer_to_uword (vpp_evt_q); |
| 1207 | } |
Florin Coras | eb2945c | 2017-11-22 10:39:09 -0800 | [diff] [blame] | 1208 | } |
Florin Coras | dcf55ce | 2017-11-16 15:32:50 -0800 | [diff] [blame] | 1209 | } |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 1210 | })); |
| 1211 | /* *INDENT-ON* */ |
Florin Coras | 6011699 | 2018-08-27 09:52:18 -0700 | [diff] [blame] | 1212 | |
| 1213 | /* If app uses mq for control messages, send an mq message as well */ |
| 1214 | if (app && application_use_mq_for_ctrl (app)) |
| 1215 | { |
| 1216 | app_wrk = application_get_worker (app, mp->wrk_index); |
| 1217 | mq_send_session_bound_cb (app_wrk->wrk_index, mp->context, a->handle, |
| 1218 | rv); |
| 1219 | } |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1220 | } |
| 1221 | |
| 1222 | static void |
| 1223 | vl_api_unbind_sock_t_handler (vl_api_unbind_sock_t * mp) |
| 1224 | { |
| 1225 | vl_api_unbind_sock_reply_t *rmp; |
| 1226 | vnet_unbind_args_t _a, *a = &_a; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1227 | application_t *app; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 1228 | clib_error_t *error; |
| 1229 | int rv = 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1230 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1231 | if (session_manager_is_enabled () == 0) |
| 1232 | { |
| 1233 | rv = VNET_API_ERROR_FEATURE_DISABLED; |
| 1234 | goto done; |
| 1235 | } |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1236 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1237 | app = application_lookup (mp->client_index); |
| 1238 | if (app) |
| 1239 | { |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 1240 | a->app_index = app->app_index; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1241 | a->handle = mp->handle; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 1242 | if ((error = vnet_unbind (a))) |
| 1243 | { |
| 1244 | rv = clib_error_get_code (error); |
| 1245 | clib_error_report (error); |
| 1246 | } |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1247 | } |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1248 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1249 | done: |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1250 | REPLY_MACRO (VL_API_UNBIND_SOCK_REPLY); |
| 1251 | } |
| 1252 | |
| 1253 | static void |
| 1254 | vl_api_connect_sock_t_handler (vl_api_connect_sock_t * mp) |
| 1255 | { |
Dave Wallace | 33e002b | 2017-09-06 01:20:02 -0400 | [diff] [blame] | 1256 | vl_api_connect_session_reply_t *rmp; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1257 | vnet_connect_args_t _a, *a = &_a; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1258 | application_t *app; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 1259 | clib_error_t *error = 0; |
| 1260 | int rv = 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1261 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1262 | if (session_manager_is_enabled () == 0) |
| 1263 | { |
| 1264 | rv = VNET_API_ERROR_FEATURE_DISABLED; |
| 1265 | goto done; |
| 1266 | } |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1267 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1268 | app = application_lookup (mp->client_index); |
| 1269 | if (app) |
| 1270 | { |
Florin Coras | e86a8ed | 2018-01-05 03:20:25 -0800 | [diff] [blame] | 1271 | svm_queue_t *client_q; |
Dave Wallace | 33e002b | 2017-09-06 01:20:02 -0400 | [diff] [blame] | 1272 | ip46_address_t *ip46 = (ip46_address_t *) mp->ip; |
Dave Wallace | b2d5ff3 | 2017-06-14 12:38:28 -0400 | [diff] [blame] | 1273 | |
Florin Coras | 8f89dd0 | 2018-03-05 16:53:07 -0800 | [diff] [blame] | 1274 | memset (a, 0, sizeof (*a)); |
Dave Wallace | b2d5ff3 | 2017-06-14 12:38:28 -0400 | [diff] [blame] | 1275 | client_q = vl_api_client_index_to_input_queue (mp->client_index); |
| 1276 | mp->client_queue_address = pointer_to_uword (client_q); |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 1277 | a->sep.is_ip4 = mp->is_ip4; |
| 1278 | a->sep.ip = *ip46; |
| 1279 | a->sep.port = mp->port; |
| 1280 | a->sep.transport_proto = mp->proto; |
| 1281 | a->sep.fib_index = mp->vrf; |
| 1282 | a->sep.sw_if_index = ENDPOINT_INVALID_INDEX; |
Florin Coras | 8f89dd0 | 2018-03-05 16:53:07 -0800 | [diff] [blame] | 1283 | if (mp->hostname_len) |
| 1284 | { |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 1285 | vec_validate (a->sep_ext.hostname, mp->hostname_len - 1); |
| 1286 | clib_memcpy (a->sep_ext.hostname, mp->hostname, mp->hostname_len); |
Florin Coras | 8f89dd0 | 2018-03-05 16:53:07 -0800 | [diff] [blame] | 1287 | } |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1288 | a->api_context = mp->context; |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 1289 | a->app_index = app->app_index; |
| 1290 | a->wrk_map_index = mp->wrk_index; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 1291 | if ((error = vnet_connect (a))) |
| 1292 | { |
| 1293 | rv = clib_error_get_code (error); |
Florin Coras | 8f89dd0 | 2018-03-05 16:53:07 -0800 | [diff] [blame] | 1294 | clib_error_report (error); |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 1295 | } |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 1296 | vec_free (a->sep_ext.hostname); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1297 | } |
| 1298 | else |
| 1299 | { |
| 1300 | rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED; |
| 1301 | } |
Florin Coras | e04c299 | 2017-03-01 08:17:34 -0800 | [diff] [blame] | 1302 | |
Florin Coras | 8f89dd0 | 2018-03-05 16:53:07 -0800 | [diff] [blame] | 1303 | if (rv == 0) |
Florin Coras | e04c299 | 2017-03-01 08:17:34 -0800 | [diff] [blame] | 1304 | return; |
| 1305 | |
| 1306 | /* Got some error, relay it */ |
| 1307 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1308 | done: |
Dave Wallace | 33e002b | 2017-09-06 01:20:02 -0400 | [diff] [blame] | 1309 | REPLY_MACRO (VL_API_CONNECT_SESSION_REPLY); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1310 | } |
| 1311 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 1312 | static void |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 1313 | vl_api_app_worker_add_del_t_handler (vl_api_app_worker_add_del_t * mp) |
| 1314 | { |
| 1315 | int rv = 0, fds[SESSION_N_FD_TYPE], n_fds = 0; |
| 1316 | vl_api_app_worker_add_del_reply_t *rmp; |
| 1317 | vl_api_registration_t *reg; |
| 1318 | clib_error_t *error = 0; |
| 1319 | application_t *app; |
| 1320 | u8 fd_flags = 0; |
| 1321 | |
| 1322 | if (!session_manager_is_enabled ()) |
| 1323 | { |
| 1324 | rv = VNET_API_ERROR_FEATURE_DISABLED; |
| 1325 | goto done; |
| 1326 | } |
| 1327 | |
| 1328 | reg = vl_api_client_index_to_registration (mp->client_index); |
| 1329 | if (!reg) |
| 1330 | return; |
| 1331 | |
| 1332 | app = application_lookup (mp->app_api_index); |
| 1333 | if (!app) |
| 1334 | { |
| 1335 | rv = VNET_API_ERROR_INVALID_VALUE; |
| 1336 | goto done; |
| 1337 | } |
| 1338 | |
| 1339 | vnet_app_worker_add_del_args_t args = { |
| 1340 | .app_index = app->app_index, |
| 1341 | .wrk_index = clib_net_to_host_u32 (mp->wrk_index), |
| 1342 | .is_add = mp->is_add |
| 1343 | }; |
| 1344 | error = vnet_app_worker_add_del (&args); |
| 1345 | if (error) |
| 1346 | { |
| 1347 | rv = clib_error_get_code (error); |
| 1348 | clib_error_report (error); |
| 1349 | goto done; |
| 1350 | } |
| 1351 | |
Florin Coras | c3638fe | 2018-08-24 13:58:49 -0700 | [diff] [blame] | 1352 | /* Make coverity happy */ |
| 1353 | ASSERT (args.evt_q && args.segment); |
| 1354 | |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 1355 | /* Send fifo segment fd if needed */ |
| 1356 | if (ssvm_type (args.segment) == SSVM_SEGMENT_MEMFD) |
| 1357 | { |
| 1358 | fd_flags |= SESSION_FD_F_MEMFD_SEGMENT; |
| 1359 | fds[n_fds] = args.segment->fd; |
| 1360 | n_fds += 1; |
| 1361 | } |
| 1362 | if (application_segment_manager_properties (app)->use_mq_eventfd) |
| 1363 | { |
| 1364 | fd_flags |= SESSION_FD_F_MQ_EVENTFD; |
| 1365 | fds[n_fds] = svm_msg_q_get_producer_eventfd (args.evt_q); |
| 1366 | n_fds += 1; |
| 1367 | } |
| 1368 | |
| 1369 | /* *INDENT-OFF* */ |
| 1370 | done: |
| 1371 | REPLY_MACRO2 (VL_API_APP_WORKER_ADD_DEL_REPLY, ({ |
| 1372 | rmp->is_add = mp->is_add; |
| 1373 | if (!rv) |
| 1374 | { |
| 1375 | rmp->wrk_index = clib_host_to_net_u32 (args.wrk_index); |
| 1376 | if (vec_len (args.segment->name)) |
| 1377 | { |
| 1378 | memcpy (rmp->segment_name, args.segment->name, |
| 1379 | vec_len (args.segment->name)); |
| 1380 | rmp->segment_name_length = vec_len (args.segment->name); |
| 1381 | } |
| 1382 | rmp->app_event_queue_address = pointer_to_uword (args.evt_q); |
| 1383 | rmp->n_fds = n_fds; |
| 1384 | rmp->fd_flags = fd_flags; |
| 1385 | } |
| 1386 | })); |
| 1387 | /* *INDENT-ON* */ |
| 1388 | |
| 1389 | if (n_fds) |
| 1390 | session_send_fds (reg, fds, n_fds); |
| 1391 | } |
| 1392 | |
| 1393 | static void |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 1394 | vl_api_app_namespace_add_del_t_handler (vl_api_app_namespace_add_del_t * mp) |
| 1395 | { |
| 1396 | vl_api_app_namespace_add_del_reply_t *rmp; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 1397 | clib_error_t *error = 0; |
Florin Coras | 6e8c667 | 2017-11-10 09:03:54 -0800 | [diff] [blame] | 1398 | u32 appns_index = 0; |
| 1399 | u8 *ns_id = 0; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 1400 | int rv = 0; |
| 1401 | if (!session_manager_is_enabled ()) |
| 1402 | { |
| 1403 | rv = VNET_API_ERROR_FEATURE_DISABLED; |
| 1404 | goto done; |
| 1405 | } |
| 1406 | |
| 1407 | if (mp->namespace_id_len > ARRAY_LEN (mp->namespace_id)) |
| 1408 | { |
| 1409 | rv = VNET_API_ERROR_INVALID_VALUE; |
| 1410 | goto done; |
| 1411 | } |
| 1412 | |
| 1413 | vec_validate (ns_id, mp->namespace_id_len - 1); |
| 1414 | clib_memcpy (ns_id, mp->namespace_id, mp->namespace_id_len); |
| 1415 | vnet_app_namespace_add_del_args_t args = { |
| 1416 | .ns_id = ns_id, |
Florin Coras | 9a9adb2 | 2017-10-26 08:16:59 -0700 | [diff] [blame] | 1417 | .secret = clib_net_to_host_u64 (mp->secret), |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 1418 | .sw_if_index = clib_net_to_host_u32 (mp->sw_if_index), |
| 1419 | .ip4_fib_id = clib_net_to_host_u32 (mp->ip4_fib_id), |
| 1420 | .ip6_fib_id = clib_net_to_host_u32 (mp->ip6_fib_id), |
| 1421 | .is_add = 1 |
| 1422 | }; |
| 1423 | error = vnet_app_namespace_add_del (&args); |
| 1424 | if (error) |
| 1425 | { |
| 1426 | rv = clib_error_get_code (error); |
| 1427 | clib_error_report (error); |
| 1428 | } |
Florin Coras | 6e8c667 | 2017-11-10 09:03:54 -0800 | [diff] [blame] | 1429 | else |
| 1430 | { |
| 1431 | appns_index = app_namespace_index_from_id (ns_id); |
| 1432 | if (appns_index == APP_NAMESPACE_INVALID_INDEX) |
| 1433 | { |
| 1434 | clib_warning ("app ns lookup failed"); |
| 1435 | rv = VNET_API_ERROR_UNSPECIFIED; |
| 1436 | } |
| 1437 | } |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 1438 | vec_free (ns_id); |
Florin Coras | 6e8c667 | 2017-11-10 09:03:54 -0800 | [diff] [blame] | 1439 | |
| 1440 | /* *INDENT-OFF* */ |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 1441 | done: |
Florin Coras | 6e8c667 | 2017-11-10 09:03:54 -0800 | [diff] [blame] | 1442 | REPLY_MACRO2 (VL_API_APP_NAMESPACE_ADD_DEL_REPLY, ({ |
| 1443 | if (!rv) |
| 1444 | rmp->appns_index = clib_host_to_net_u32 (appns_index); |
| 1445 | })); |
| 1446 | /* *INDENT-ON* */ |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 1447 | } |
| 1448 | |
Florin Coras | 1c71045 | 2017-10-17 00:03:13 -0700 | [diff] [blame] | 1449 | static void |
| 1450 | vl_api_session_rule_add_del_t_handler (vl_api_session_rule_add_del_t * mp) |
| 1451 | { |
| 1452 | vl_api_session_rule_add_del_reply_t *rmp; |
| 1453 | session_rule_add_del_args_t args; |
| 1454 | session_rule_table_add_del_args_t *table_args = &args.table_args; |
| 1455 | clib_error_t *error; |
| 1456 | u8 fib_proto; |
| 1457 | int rv = 0; |
| 1458 | |
Florin Coras | c97a739 | 2017-11-05 23:07:07 -0800 | [diff] [blame] | 1459 | memset (&args, 0, sizeof (args)); |
Florin Coras | 1c71045 | 2017-10-17 00:03:13 -0700 | [diff] [blame] | 1460 | fib_proto = mp->is_ip4 ? FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6; |
| 1461 | |
| 1462 | table_args->lcl.fp_len = mp->lcl_plen; |
| 1463 | table_args->lcl.fp_proto = fib_proto; |
| 1464 | table_args->rmt.fp_len = mp->rmt_plen; |
| 1465 | table_args->rmt.fp_proto = fib_proto; |
Milan Lenco | 8b9a5d1 | 2017-11-24 17:12:33 +0100 | [diff] [blame] | 1466 | table_args->lcl_port = mp->lcl_port; |
| 1467 | table_args->rmt_port = mp->rmt_port; |
Florin Coras | 1c71045 | 2017-10-17 00:03:13 -0700 | [diff] [blame] | 1468 | table_args->action_index = clib_net_to_host_u32 (mp->action_index); |
| 1469 | table_args->is_add = mp->is_add; |
Florin Coras | c97a739 | 2017-11-05 23:07:07 -0800 | [diff] [blame] | 1470 | mp->tag[sizeof (mp->tag) - 1] = 0; |
| 1471 | table_args->tag = format (0, "%s", mp->tag); |
Florin Coras | 1c71045 | 2017-10-17 00:03:13 -0700 | [diff] [blame] | 1472 | args.appns_index = clib_net_to_host_u32 (mp->appns_index); |
| 1473 | args.scope = mp->scope; |
Florin Coras | 42324ad | 2017-11-18 18:45:20 -0800 | [diff] [blame] | 1474 | args.transport_proto = mp->transport_proto; |
Florin Coras | 1c71045 | 2017-10-17 00:03:13 -0700 | [diff] [blame] | 1475 | |
| 1476 | memset (&table_args->lcl.fp_addr, 0, sizeof (table_args->lcl.fp_addr)); |
| 1477 | memset (&table_args->rmt.fp_addr, 0, sizeof (table_args->rmt.fp_addr)); |
| 1478 | ip_set (&table_args->lcl.fp_addr, mp->lcl_ip, mp->is_ip4); |
| 1479 | ip_set (&table_args->rmt.fp_addr, mp->rmt_ip, mp->is_ip4); |
| 1480 | error = vnet_session_rule_add_del (&args); |
| 1481 | if (error) |
| 1482 | { |
| 1483 | rv = clib_error_get_code (error); |
| 1484 | clib_error_report (error); |
| 1485 | } |
Florin Coras | c97a739 | 2017-11-05 23:07:07 -0800 | [diff] [blame] | 1486 | vec_free (table_args->tag); |
Florin Coras | 1c71045 | 2017-10-17 00:03:13 -0700 | [diff] [blame] | 1487 | REPLY_MACRO (VL_API_SESSION_RULE_ADD_DEL_REPLY); |
| 1488 | } |
| 1489 | |
Florin Coras | 6c36f53 | 2017-11-03 18:32:34 -0700 | [diff] [blame] | 1490 | static void |
| 1491 | send_session_rule_details4 (mma_rule_16_t * rule, u8 is_local, |
Florin Coras | c97a739 | 2017-11-05 23:07:07 -0800 | [diff] [blame] | 1492 | u8 transport_proto, u32 appns_index, u8 * tag, |
Florin Coras | 6c4dae2 | 2018-01-09 06:39:23 -0800 | [diff] [blame] | 1493 | vl_api_registration_t * reg, u32 context) |
Florin Coras | 6c36f53 | 2017-11-03 18:32:34 -0700 | [diff] [blame] | 1494 | { |
| 1495 | vl_api_session_rules_details_t *rmp = 0; |
| 1496 | session_mask_or_match_4_t *match = |
| 1497 | (session_mask_or_match_4_t *) & rule->match; |
| 1498 | session_mask_or_match_4_t *mask = |
| 1499 | (session_mask_or_match_4_t *) & rule->mask; |
| 1500 | |
| 1501 | rmp = vl_msg_api_alloc (sizeof (*rmp)); |
| 1502 | memset (rmp, 0, sizeof (*rmp)); |
| 1503 | rmp->_vl_msg_id = ntohs (VL_API_SESSION_RULES_DETAILS); |
| 1504 | rmp->context = context; |
| 1505 | |
| 1506 | rmp->is_ip4 = 1; |
| 1507 | clib_memcpy (rmp->lcl_ip, &match->lcl_ip, sizeof (match->lcl_ip)); |
| 1508 | clib_memcpy (rmp->rmt_ip, &match->rmt_ip, sizeof (match->rmt_ip)); |
| 1509 | rmp->lcl_plen = ip4_mask_to_preflen (&mask->lcl_ip); |
| 1510 | rmp->rmt_plen = ip4_mask_to_preflen (&mask->rmt_ip); |
Milan Lenco | 8b9a5d1 | 2017-11-24 17:12:33 +0100 | [diff] [blame] | 1511 | rmp->lcl_port = match->lcl_port; |
| 1512 | rmp->rmt_port = match->rmt_port; |
Florin Coras | 6c36f53 | 2017-11-03 18:32:34 -0700 | [diff] [blame] | 1513 | rmp->action_index = clib_host_to_net_u32 (rule->action_index); |
| 1514 | rmp->scope = |
| 1515 | is_local ? SESSION_RULE_SCOPE_LOCAL : SESSION_RULE_SCOPE_GLOBAL; |
| 1516 | rmp->transport_proto = transport_proto; |
| 1517 | rmp->appns_index = clib_host_to_net_u32 (appns_index); |
Florin Coras | c97a739 | 2017-11-05 23:07:07 -0800 | [diff] [blame] | 1518 | if (tag) |
| 1519 | { |
| 1520 | clib_memcpy (rmp->tag, tag, vec_len (tag)); |
| 1521 | rmp->tag[vec_len (tag)] = 0; |
| 1522 | } |
Florin Coras | 6c36f53 | 2017-11-03 18:32:34 -0700 | [diff] [blame] | 1523 | |
Florin Coras | 6c4dae2 | 2018-01-09 06:39:23 -0800 | [diff] [blame] | 1524 | vl_api_send_msg (reg, (u8 *) rmp); |
Florin Coras | 6c36f53 | 2017-11-03 18:32:34 -0700 | [diff] [blame] | 1525 | } |
| 1526 | |
| 1527 | static void |
Florin Coras | c97a739 | 2017-11-05 23:07:07 -0800 | [diff] [blame] | 1528 | send_session_rule_details6 (mma_rule_40_t * rule, u8 is_local, |
| 1529 | u8 transport_proto, u32 appns_index, u8 * tag, |
Florin Coras | 6c4dae2 | 2018-01-09 06:39:23 -0800 | [diff] [blame] | 1530 | vl_api_registration_t * reg, u32 context) |
Florin Coras | 6c36f53 | 2017-11-03 18:32:34 -0700 | [diff] [blame] | 1531 | { |
| 1532 | vl_api_session_rules_details_t *rmp = 0; |
| 1533 | session_mask_or_match_6_t *match = |
| 1534 | (session_mask_or_match_6_t *) & rule->match; |
| 1535 | session_mask_or_match_6_t *mask = |
| 1536 | (session_mask_or_match_6_t *) & rule->mask; |
| 1537 | |
| 1538 | rmp = vl_msg_api_alloc (sizeof (*rmp)); |
| 1539 | memset (rmp, 0, sizeof (*rmp)); |
| 1540 | rmp->_vl_msg_id = ntohs (VL_API_SESSION_RULES_DETAILS); |
| 1541 | rmp->context = context; |
| 1542 | |
| 1543 | rmp->is_ip4 = 0; |
| 1544 | clib_memcpy (rmp->lcl_ip, &match->lcl_ip, sizeof (match->lcl_ip)); |
| 1545 | clib_memcpy (rmp->rmt_ip, &match->rmt_ip, sizeof (match->rmt_ip)); |
| 1546 | rmp->lcl_plen = ip6_mask_to_preflen (&mask->lcl_ip); |
| 1547 | rmp->rmt_plen = ip6_mask_to_preflen (&mask->rmt_ip); |
Milan Lenco | 8b9a5d1 | 2017-11-24 17:12:33 +0100 | [diff] [blame] | 1548 | rmp->lcl_port = match->lcl_port; |
| 1549 | rmp->rmt_port = match->rmt_port; |
Florin Coras | 6c36f53 | 2017-11-03 18:32:34 -0700 | [diff] [blame] | 1550 | rmp->action_index = clib_host_to_net_u32 (rule->action_index); |
Florin Coras | c97a739 | 2017-11-05 23:07:07 -0800 | [diff] [blame] | 1551 | rmp->scope = |
| 1552 | is_local ? SESSION_RULE_SCOPE_LOCAL : SESSION_RULE_SCOPE_GLOBAL; |
Florin Coras | 6c36f53 | 2017-11-03 18:32:34 -0700 | [diff] [blame] | 1553 | rmp->transport_proto = transport_proto; |
| 1554 | rmp->appns_index = clib_host_to_net_u32 (appns_index); |
Florin Coras | c97a739 | 2017-11-05 23:07:07 -0800 | [diff] [blame] | 1555 | if (tag) |
| 1556 | { |
| 1557 | clib_memcpy (rmp->tag, tag, vec_len (tag)); |
| 1558 | rmp->tag[vec_len (tag)] = 0; |
| 1559 | } |
Florin Coras | 6c36f53 | 2017-11-03 18:32:34 -0700 | [diff] [blame] | 1560 | |
Florin Coras | 6c4dae2 | 2018-01-09 06:39:23 -0800 | [diff] [blame] | 1561 | vl_api_send_msg (reg, (u8 *) rmp); |
Florin Coras | 6c36f53 | 2017-11-03 18:32:34 -0700 | [diff] [blame] | 1562 | } |
| 1563 | |
| 1564 | static void |
| 1565 | send_session_rules_table_details (session_rules_table_t * srt, u8 fib_proto, |
Florin Coras | c97a739 | 2017-11-05 23:07:07 -0800 | [diff] [blame] | 1566 | u8 tp, u8 is_local, u32 appns_index, |
Florin Coras | 6c4dae2 | 2018-01-09 06:39:23 -0800 | [diff] [blame] | 1567 | vl_api_registration_t * reg, u32 context) |
Florin Coras | 6c36f53 | 2017-11-03 18:32:34 -0700 | [diff] [blame] | 1568 | { |
| 1569 | mma_rule_16_t *rule16; |
| 1570 | mma_rule_40_t *rule40; |
| 1571 | mma_rules_table_16_t *srt16; |
| 1572 | mma_rules_table_40_t *srt40; |
Florin Coras | c97a739 | 2017-11-05 23:07:07 -0800 | [diff] [blame] | 1573 | u32 ri; |
Florin Coras | 6c36f53 | 2017-11-03 18:32:34 -0700 | [diff] [blame] | 1574 | |
Florin Coras | c97a739 | 2017-11-05 23:07:07 -0800 | [diff] [blame] | 1575 | if (is_local || fib_proto == FIB_PROTOCOL_IP4) |
Florin Coras | 6c36f53 | 2017-11-03 18:32:34 -0700 | [diff] [blame] | 1576 | { |
Florin Coras | c97a739 | 2017-11-05 23:07:07 -0800 | [diff] [blame] | 1577 | u8 *tag = 0; |
| 1578 | /* *INDENT-OFF* */ |
| 1579 | srt16 = &srt->session_rules_tables_16; |
| 1580 | pool_foreach (rule16, srt16->rules, ({ |
| 1581 | ri = mma_rules_table_rule_index_16 (srt16, rule16); |
| 1582 | tag = session_rules_table_rule_tag (srt, ri, 1); |
| 1583 | send_session_rule_details4 (rule16, is_local, tp, appns_index, tag, |
Florin Coras | 6c4dae2 | 2018-01-09 06:39:23 -0800 | [diff] [blame] | 1584 | reg, context); |
Florin Coras | c97a739 | 2017-11-05 23:07:07 -0800 | [diff] [blame] | 1585 | })); |
| 1586 | /* *INDENT-ON* */ |
| 1587 | } |
| 1588 | if (is_local || fib_proto == FIB_PROTOCOL_IP6) |
| 1589 | { |
| 1590 | u8 *tag = 0; |
| 1591 | /* *INDENT-OFF* */ |
| 1592 | srt40 = &srt->session_rules_tables_40; |
| 1593 | pool_foreach (rule40, srt40->rules, ({ |
| 1594 | ri = mma_rules_table_rule_index_40 (srt40, rule40); |
| 1595 | tag = session_rules_table_rule_tag (srt, ri, 1); |
| 1596 | send_session_rule_details6 (rule40, is_local, tp, appns_index, tag, |
Florin Coras | 6c4dae2 | 2018-01-09 06:39:23 -0800 | [diff] [blame] | 1597 | reg, context); |
Florin Coras | c97a739 | 2017-11-05 23:07:07 -0800 | [diff] [blame] | 1598 | })); |
| 1599 | /* *INDENT-ON* */ |
Florin Coras | 6c36f53 | 2017-11-03 18:32:34 -0700 | [diff] [blame] | 1600 | } |
| 1601 | } |
| 1602 | |
| 1603 | static void |
| 1604 | vl_api_session_rules_dump_t_handler (vl_api_one_map_server_dump_t * mp) |
| 1605 | { |
Florin Coras | 6c4dae2 | 2018-01-09 06:39:23 -0800 | [diff] [blame] | 1606 | vl_api_registration_t *reg; |
Florin Coras | 6c36f53 | 2017-11-03 18:32:34 -0700 | [diff] [blame] | 1607 | session_table_t *st; |
Florin Coras | c97a739 | 2017-11-05 23:07:07 -0800 | [diff] [blame] | 1608 | u8 tp; |
Florin Coras | 6c36f53 | 2017-11-03 18:32:34 -0700 | [diff] [blame] | 1609 | |
Florin Coras | 6c4dae2 | 2018-01-09 06:39:23 -0800 | [diff] [blame] | 1610 | reg = vl_api_client_index_to_registration (mp->client_index); |
| 1611 | if (!reg) |
Florin Coras | 6c36f53 | 2017-11-03 18:32:34 -0700 | [diff] [blame] | 1612 | return; |
| 1613 | |
| 1614 | /* *INDENT-OFF* */ |
| 1615 | session_table_foreach (st, ({ |
Florin Coras | c97a739 | 2017-11-05 23:07:07 -0800 | [diff] [blame] | 1616 | for (tp = 0; tp < TRANSPORT_N_PROTO; tp++) |
| 1617 | { |
| 1618 | send_session_rules_table_details (&st->session_rules[tp], |
| 1619 | st->active_fib_proto, tp, |
Florin Coras | 6c4dae2 | 2018-01-09 06:39:23 -0800 | [diff] [blame] | 1620 | st->is_local, st->appns_index, reg, |
Florin Coras | c97a739 | 2017-11-05 23:07:07 -0800 | [diff] [blame] | 1621 | mp->context); |
| 1622 | } |
Florin Coras | 6c36f53 | 2017-11-03 18:32:34 -0700 | [diff] [blame] | 1623 | })); |
| 1624 | /* *INDENT-ON* */ |
| 1625 | } |
| 1626 | |
Florin Coras | 371ca50 | 2018-02-21 12:07:41 -0800 | [diff] [blame] | 1627 | static void |
| 1628 | vl_api_application_tls_cert_add_t_handler (vl_api_application_tls_cert_add_t * |
| 1629 | mp) |
| 1630 | { |
| 1631 | vl_api_app_namespace_add_del_reply_t *rmp; |
| 1632 | vnet_app_add_tls_cert_args_t _a, *a = &_a; |
| 1633 | clib_error_t *error; |
Florin Coras | e3e2f07 | 2018-03-04 07:24:30 -0800 | [diff] [blame] | 1634 | application_t *app; |
Florin Coras | 371ca50 | 2018-02-21 12:07:41 -0800 | [diff] [blame] | 1635 | u32 cert_len; |
| 1636 | int rv = 0; |
| 1637 | if (!session_manager_is_enabled ()) |
| 1638 | { |
| 1639 | rv = VNET_API_ERROR_FEATURE_DISABLED; |
| 1640 | goto done; |
| 1641 | } |
Florin Coras | e3e2f07 | 2018-03-04 07:24:30 -0800 | [diff] [blame] | 1642 | if (!(app = application_lookup (mp->client_index))) |
| 1643 | { |
| 1644 | rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED; |
| 1645 | goto done; |
| 1646 | } |
Florin Coras | 371ca50 | 2018-02-21 12:07:41 -0800 | [diff] [blame] | 1647 | memset (a, 0, sizeof (*a)); |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 1648 | a->app_index = app->app_index; |
Florin Coras | 371ca50 | 2018-02-21 12:07:41 -0800 | [diff] [blame] | 1649 | cert_len = clib_net_to_host_u16 (mp->cert_len); |
Florin Coras | 5090c57 | 2018-03-18 08:22:17 -0700 | [diff] [blame] | 1650 | if (cert_len > 10000) |
| 1651 | { |
| 1652 | rv = VNET_API_ERROR_INVALID_VALUE; |
| 1653 | goto done; |
| 1654 | } |
Florin Coras | 371ca50 | 2018-02-21 12:07:41 -0800 | [diff] [blame] | 1655 | vec_validate (a->cert, cert_len); |
| 1656 | clib_memcpy (a->cert, mp->cert, cert_len); |
| 1657 | if ((error = vnet_app_add_tls_cert (a))) |
| 1658 | { |
| 1659 | rv = clib_error_get_code (error); |
| 1660 | clib_error_report (error); |
| 1661 | } |
| 1662 | vec_free (a->cert); |
| 1663 | done: |
| 1664 | REPLY_MACRO (VL_API_APPLICATION_TLS_CERT_ADD_REPLY); |
| 1665 | } |
| 1666 | |
| 1667 | static void |
| 1668 | vl_api_application_tls_key_add_t_handler (vl_api_application_tls_key_add_t * |
| 1669 | mp) |
| 1670 | { |
| 1671 | vl_api_app_namespace_add_del_reply_t *rmp; |
| 1672 | vnet_app_add_tls_key_args_t _a, *a = &_a; |
| 1673 | clib_error_t *error; |
Florin Coras | e3e2f07 | 2018-03-04 07:24:30 -0800 | [diff] [blame] | 1674 | application_t *app; |
Florin Coras | 371ca50 | 2018-02-21 12:07:41 -0800 | [diff] [blame] | 1675 | u32 key_len; |
| 1676 | int rv = 0; |
| 1677 | if (!session_manager_is_enabled ()) |
| 1678 | { |
| 1679 | rv = VNET_API_ERROR_FEATURE_DISABLED; |
| 1680 | goto done; |
| 1681 | } |
Florin Coras | e3e2f07 | 2018-03-04 07:24:30 -0800 | [diff] [blame] | 1682 | if (!(app = application_lookup (mp->client_index))) |
| 1683 | { |
| 1684 | rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED; |
| 1685 | goto done; |
| 1686 | } |
Florin Coras | 371ca50 | 2018-02-21 12:07:41 -0800 | [diff] [blame] | 1687 | memset (a, 0, sizeof (*a)); |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 1688 | a->app_index = app->app_index; |
Florin Coras | 371ca50 | 2018-02-21 12:07:41 -0800 | [diff] [blame] | 1689 | key_len = clib_net_to_host_u16 (mp->key_len); |
Florin Coras | 5090c57 | 2018-03-18 08:22:17 -0700 | [diff] [blame] | 1690 | if (key_len > 10000) |
| 1691 | { |
| 1692 | rv = VNET_API_ERROR_INVALID_VALUE; |
| 1693 | goto done; |
| 1694 | } |
Florin Coras | 371ca50 | 2018-02-21 12:07:41 -0800 | [diff] [blame] | 1695 | vec_validate (a->key, key_len); |
| 1696 | clib_memcpy (a->key, mp->key, key_len); |
| 1697 | if ((error = vnet_app_add_tls_key (a))) |
| 1698 | { |
| 1699 | rv = clib_error_get_code (error); |
| 1700 | clib_error_report (error); |
| 1701 | } |
| 1702 | vec_free (a->key); |
| 1703 | done: |
| 1704 | REPLY_MACRO (VL_API_APPLICATION_TLS_KEY_ADD_REPLY); |
| 1705 | } |
| 1706 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1707 | static clib_error_t * |
| 1708 | application_reaper_cb (u32 client_index) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1709 | { |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1710 | application_t *app = application_lookup (client_index); |
| 1711 | vnet_app_detach_args_t _a, *a = &_a; |
| 1712 | if (app) |
| 1713 | { |
Florin Coras | 1553197 | 2018-08-12 23:50:53 -0700 | [diff] [blame] | 1714 | a->app_index = app->app_index; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1715 | vnet_application_detach (a); |
| 1716 | } |
| 1717 | return 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1718 | } |
| 1719 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1720 | VL_MSG_API_REAPER_FUNCTION (application_reaper_cb); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1721 | |
| 1722 | #define vl_msg_name_crc_list |
| 1723 | #include <vnet/vnet_all_api_h.h> |
| 1724 | #undef vl_msg_name_crc_list |
| 1725 | |
| 1726 | static void |
| 1727 | setup_message_id_table (api_main_t * am) |
| 1728 | { |
| 1729 | #define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id); |
| 1730 | foreach_vl_msg_name_crc_session; |
| 1731 | #undef _ |
| 1732 | } |
| 1733 | |
| 1734 | /* |
| 1735 | * session_api_hookup |
| 1736 | * Add uri's API message handlers to the table. |
| 1737 | * vlib has alread mapped shared memory and |
| 1738 | * added the client registration handlers. |
| 1739 | * See .../open-repo/vlib/memclnt_vlib.c:memclnt_process() |
| 1740 | */ |
| 1741 | static clib_error_t * |
| 1742 | session_api_hookup (vlib_main_t * vm) |
| 1743 | { |
| 1744 | api_main_t *am = &api_main; |
| 1745 | |
| 1746 | #define _(N,n) \ |
| 1747 | vl_msg_api_set_handlers(VL_API_##N, #n, \ |
| 1748 | vl_api_##n##_t_handler, \ |
| 1749 | vl_noop_handler, \ |
| 1750 | vl_api_##n##_t_endian, \ |
| 1751 | vl_api_##n##_t_print, \ |
| 1752 | sizeof(vl_api_##n##_t), 1); |
| 1753 | foreach_session_api_msg; |
| 1754 | #undef _ |
| 1755 | |
| 1756 | /* |
| 1757 | * Messages which bounce off the data-plane to |
| 1758 | * an API client. Simply tells the message handling infra not |
| 1759 | * to free the message. |
| 1760 | * |
| 1761 | * Bounced message handlers MUST NOT block the data plane |
| 1762 | */ |
| 1763 | am->message_bounce[VL_API_CONNECT_URI] = 1; |
| 1764 | am->message_bounce[VL_API_CONNECT_SOCK] = 1; |
| 1765 | |
| 1766 | /* |
| 1767 | * Set up the (msg_name, crc, message-id) table |
| 1768 | */ |
| 1769 | setup_message_id_table (am); |
| 1770 | |
| 1771 | return 0; |
| 1772 | } |
| 1773 | |
| 1774 | VLIB_API_INIT_FUNCTION (session_api_hookup); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 1775 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1776 | /* |
| 1777 | * fd.io coding-style-patch-verification: ON |
| 1778 | * |
| 1779 | * Local Variables: |
| 1780 | * eval: (c-set-style "gnu") |
| 1781 | * End: |
| 1782 | */ |