Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 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 | #include <vnet/session/application_interface.h> |
| 16 | |
| 17 | #include <vnet/session/session.h> |
| 18 | #include <vlibmemory/api.h> |
| 19 | #include <vnet/dpo/load_balance.h> |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 20 | |
| 21 | /** @file |
| 22 | VPP's application/session API bind/unbind/connect/disconnect calls |
| 23 | */ |
| 24 | |
| 25 | static u8 |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 26 | session_endpoint_is_local (session_endpoint_t * sep) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 27 | { |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 28 | return (ip_is_zero (&sep->ip, sep->is_ip4) |
| 29 | || ip_is_local_host (&sep->ip, sep->is_ip4)); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 30 | } |
| 31 | |
| 32 | static u8 |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 33 | session_endpoint_is_zero (session_endpoint_t * sep) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 34 | { |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 35 | return ip_is_zero (&sep->ip, sep->is_ip4); |
| 36 | } |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 37 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 38 | u8 |
| 39 | session_endpoint_in_ns (session_endpoint_t * sep) |
| 40 | { |
| 41 | u8 is_zero = ip_is_zero (&sep->ip, sep->is_ip4); |
| 42 | if (!is_zero && sep->sw_if_index != ENDPOINT_INVALID_INDEX |
| 43 | && !ip_interface_has_address (sep->sw_if_index, &sep->ip, sep->is_ip4)) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 44 | { |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 45 | clib_warning ("sw_if_index %u not configured with ip %U", |
| 46 | sep->sw_if_index, format_ip46_address, &sep->ip, |
| 47 | sep->is_ip4); |
| 48 | return 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 49 | } |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 50 | return (is_zero || ip_is_local (sep->fib_index, &sep->ip, sep->is_ip4)); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 51 | } |
| 52 | |
| 53 | int |
| 54 | api_parse_session_handle (u64 handle, u32 * session_index, u32 * thread_index) |
| 55 | { |
| 56 | session_manager_main_t *smm = vnet_get_session_manager_main (); |
| 57 | stream_session_t *pool; |
| 58 | |
| 59 | *thread_index = handle & 0xFFFFFFFF; |
| 60 | *session_index = handle >> 32; |
| 61 | |
| 62 | if (*thread_index >= vec_len (smm->sessions)) |
| 63 | return VNET_API_ERROR_INVALID_VALUE; |
| 64 | |
| 65 | pool = smm->sessions[*thread_index]; |
| 66 | |
| 67 | if (pool_is_free_index (pool, *session_index)) |
| 68 | return VNET_API_ERROR_INVALID_VALUE_2; |
| 69 | |
| 70 | return 0; |
| 71 | } |
| 72 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 73 | static void |
| 74 | session_endpoint_update_for_app (session_endpoint_t * sep, |
| 75 | application_t * app) |
| 76 | { |
| 77 | app_namespace_t *app_ns; |
| 78 | app_ns = app_namespace_get (app->ns_index); |
| 79 | if (app_ns) |
| 80 | { |
| 81 | /* Ask transport and network to bind to/connect using local interface |
| 82 | * that "supports" app's namespace. This will fix our local connection |
| 83 | * endpoint. |
| 84 | */ |
| 85 | sep->sw_if_index = app_ns->sw_if_index; |
| 86 | sep->fib_index = |
| 87 | sep->is_ip4 ? app_ns->ip4_fib_index : app_ns->ip6_fib_index; |
| 88 | } |
| 89 | } |
| 90 | |
| 91 | static int |
| 92 | vnet_bind_i (u32 app_index, session_endpoint_t * sep, u64 * handle) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 93 | { |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 94 | application_t *app; |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 95 | u32 table_index; |
| 96 | u64 listener; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 97 | int rv, have_local = 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 98 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 99 | app = application_get_if_valid (app_index); |
| 100 | if (!app) |
| 101 | { |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 102 | SESSION_DBG ("app not attached"); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 103 | return VNET_API_ERROR_APPLICATION_NOT_ATTACHED; |
| 104 | } |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 105 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 106 | session_endpoint_update_for_app (sep, app); |
| 107 | if (!session_endpoint_in_ns (sep)) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 108 | return VNET_API_ERROR_INVALID_VALUE_2; |
| 109 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 110 | table_index = application_session_table (app, |
| 111 | session_endpoint_fib_proto (sep)); |
Florin Coras | a2ff7b8 | 2017-11-08 17:55:03 -0800 | [diff] [blame] | 112 | listener = session_lookup_endpoint_listener (table_index, sep, 1); |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 113 | if (listener != SESSION_INVALID_HANDLE) |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 114 | return VNET_API_ERROR_ADDRESS_IN_USE; |
| 115 | |
| 116 | /* |
| 117 | * Add session endpoint to local session table. Only binds to "inaddr_any" |
| 118 | * (i.e., zero address) are added to local scope table. |
| 119 | */ |
| 120 | if (application_has_local_scope (app) && session_endpoint_is_zero (sep)) |
| 121 | { |
| 122 | table_index = application_local_session_table (app); |
Florin Coras | a2ff7b8 | 2017-11-08 17:55:03 -0800 | [diff] [blame] | 123 | listener = session_lookup_endpoint_listener (table_index, sep, 1); |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 124 | if (listener != SESSION_INVALID_HANDLE) |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 125 | return VNET_API_ERROR_ADDRESS_IN_USE; |
| 126 | session_lookup_add_session_endpoint (table_index, sep, app->index); |
| 127 | *handle = session_lookup_local_listener_make_handle (sep); |
| 128 | have_local = 1; |
| 129 | } |
| 130 | |
| 131 | if (!application_has_global_scope (app)) |
| 132 | return (have_local - 1); |
| 133 | |
| 134 | /* |
| 135 | * Add session endpoint to global session table |
| 136 | */ |
| 137 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 138 | /* Setup listen path down to transport */ |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 139 | rv = application_start_listen (app, sep, handle); |
| 140 | if (rv && have_local) |
| 141 | session_lookup_del_session_endpoint (table_index, sep); |
| 142 | return rv; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 143 | } |
| 144 | |
| 145 | int |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 146 | vnet_unbind_i (u32 app_index, u64 handle) |
| 147 | { |
| 148 | application_t *app = application_get_if_valid (app_index); |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 149 | stream_session_t *listener = 0; |
| 150 | u32 table_index; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 151 | |
| 152 | if (!app) |
| 153 | { |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 154 | SESSION_DBG ("app (%d) not attached", app_index); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 155 | return VNET_API_ERROR_APPLICATION_NOT_ATTACHED; |
| 156 | } |
| 157 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 158 | /* |
| 159 | * Clean up local session table. If we have a listener session use it to |
| 160 | * find the port and proto. If not, the handle must be a local table handle |
| 161 | * so parse it. |
| 162 | */ |
| 163 | |
| 164 | if (application_has_local_scope (app)) |
| 165 | { |
| 166 | session_endpoint_t sep = SESSION_ENDPOINT_NULL; |
| 167 | if (!session_lookup_local_is_handle (handle)) |
| 168 | listener = listen_session_get_from_handle (handle); |
| 169 | if (listener) |
| 170 | { |
| 171 | if (listen_session_get_local_session_endpoint (listener, &sep)) |
| 172 | { |
| 173 | clib_warning ("broken listener"); |
| 174 | return -1; |
| 175 | } |
| 176 | } |
| 177 | else |
| 178 | { |
| 179 | if (session_lookup_local_listener_parse_handle (handle, &sep)) |
| 180 | { |
| 181 | clib_warning ("can't parse handle"); |
| 182 | return -1; |
| 183 | } |
| 184 | } |
| 185 | table_index = application_local_session_table (app); |
| 186 | session_lookup_del_session_endpoint (table_index, &sep); |
| 187 | } |
| 188 | |
| 189 | /* |
| 190 | * Clear the global scope table of the listener |
| 191 | */ |
| 192 | if (application_has_global_scope (app)) |
| 193 | return application_stop_listen (app, handle); |
| 194 | return 0; |
| 195 | } |
| 196 | |
| 197 | static int |
| 198 | app_connect_redirect (application_t * server, void *mp) |
| 199 | { |
| 200 | return server->cb_fns.redirect_connect_callback (server->api_client_index, |
| 201 | mp); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 202 | } |
| 203 | |
| 204 | int |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 205 | vnet_connect_i (u32 app_index, u32 api_context, session_endpoint_t * sep, |
| 206 | void *mp) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 207 | { |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 208 | application_t *server, *app; |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 209 | u32 table_index, server_index; |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 210 | stream_session_t *listener; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 211 | |
| 212 | if (session_endpoint_is_zero (sep)) |
| 213 | return VNET_API_ERROR_INVALID_VALUE; |
| 214 | |
| 215 | app = application_get (app_index); |
| 216 | session_endpoint_update_for_app (sep, app); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 217 | |
| 218 | /* |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 219 | * First check the the local scope for locally attached destinations. |
| 220 | * If we have local scope, we pass *all* connects through it since we may |
| 221 | * have special policy rules even for non-local destinations, think proxy. |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 222 | */ |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 223 | if (application_has_local_scope (app)) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 224 | { |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 225 | table_index = application_local_session_table (app); |
Florin Coras | a2ff7b8 | 2017-11-08 17:55:03 -0800 | [diff] [blame] | 226 | server_index = session_lookup_local_endpoint (table_index, sep); |
| 227 | if (server_index == APP_DROP_INDEX) |
| 228 | return VNET_API_ERROR_APP_CONNECT_FILTERED; |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 229 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 230 | /* |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 231 | * Break loop if rule in local table points to connecting app. This |
| 232 | * can happen if client is a generic proxy. Route connect through |
| 233 | * global table instead. |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 234 | */ |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 235 | if (server_index != app_index) |
| 236 | { |
| 237 | server = application_get (server_index); |
| 238 | /* |
| 239 | * Server is willing to have a direct fifo connection created |
| 240 | * instead of going through the state machine, etc. |
| 241 | */ |
| 242 | if (server && (server->flags & APP_OPTIONS_FLAGS_ACCEPT_REDIRECT)) |
| 243 | return app_connect_redirect (server, mp); |
| 244 | } |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 245 | } |
| 246 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 247 | /* |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 248 | * If nothing found, check the global scope for locally attached |
| 249 | * destinations. Make sure first that we're allowed to. |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 250 | */ |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 251 | if (session_endpoint_is_local (sep)) |
| 252 | return VNET_API_ERROR_SESSION_CONNECT; |
| 253 | |
| 254 | if (!application_has_global_scope (app)) |
| 255 | return VNET_API_ERROR_APP_CONNECT_SCOPE; |
| 256 | |
| 257 | table_index = application_session_table (app, |
| 258 | session_endpoint_fib_proto (sep)); |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 259 | listener = session_lookup_listener (table_index, sep); |
| 260 | if (listener) |
| 261 | { |
| 262 | server = application_get (listener->app_index); |
| 263 | if (server && (server->flags & APP_OPTIONS_FLAGS_ACCEPT_REDIRECT)) |
| 264 | return app_connect_redirect (server, mp); |
| 265 | } |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 266 | |
| 267 | /* |
| 268 | * Not connecting to a local server, propagate to transport |
| 269 | */ |
| 270 | if (application_open_session (app, sep, api_context)) |
| 271 | return VNET_API_ERROR_SESSION_CONNECT; |
| 272 | return 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 273 | } |
| 274 | |
| 275 | /** |
| 276 | * unformat a vnet URI |
| 277 | * |
Florin Coras | 4399c2e | 2018-01-25 06:34:42 -0800 | [diff] [blame] | 278 | * transport-proto://ip46-addr:port |
| 279 | * eg. tcp://ip46-addr:port |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 280 | * |
| 281 | * u8 ip46_address[16]; |
| 282 | * u16 port_in_host_byte_order; |
| 283 | * stream_session_type_t sst; |
| 284 | * u8 *fifo_name; |
| 285 | * |
| 286 | * if (unformat (input, "%U", unformat_vnet_uri, &ip46_address, |
| 287 | * &sst, &port, &fifo_name)) |
| 288 | * etc... |
| 289 | * |
| 290 | */ |
| 291 | uword |
| 292 | unformat_vnet_uri (unformat_input_t * input, va_list * args) |
| 293 | { |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 294 | session_endpoint_t *sep = va_arg (*args, session_endpoint_t *); |
Florin Coras | 4399c2e | 2018-01-25 06:34:42 -0800 | [diff] [blame] | 295 | u32 transport_proto = 0; |
| 296 | if (unformat (input, "%U://%U/%d", unformat_transport_proto, |
| 297 | &transport_proto, unformat_ip4_address, &sep->ip.ip4, |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 298 | &sep->port)) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 299 | { |
Florin Coras | 4399c2e | 2018-01-25 06:34:42 -0800 | [diff] [blame] | 300 | sep->transport_proto = transport_proto; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 301 | sep->port = clib_host_to_net_u16 (sep->port); |
| 302 | sep->is_ip4 = 1; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 303 | return 1; |
| 304 | } |
Florin Coras | 4399c2e | 2018-01-25 06:34:42 -0800 | [diff] [blame] | 305 | if (unformat (input, "%U://%U/%d", unformat_transport_proto, |
| 306 | &transport_proto, unformat_ip6_address, &sep->ip.ip6, |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 307 | &sep->port)) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 308 | { |
Florin Coras | 4399c2e | 2018-01-25 06:34:42 -0800 | [diff] [blame] | 309 | sep->transport_proto = transport_proto; |
Marco Varlese | 191a594 | 2017-10-30 18:17:21 +0100 | [diff] [blame] | 310 | sep->port = clib_host_to_net_u16 (sep->port); |
| 311 | sep->is_ip4 = 0; |
| 312 | return 1; |
| 313 | } |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 314 | return 0; |
| 315 | } |
| 316 | |
Dave Barach | b7f1faa | 2017-08-29 11:43:37 -0400 | [diff] [blame] | 317 | static u8 *cache_uri; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 318 | static session_endpoint_t *cache_sep; |
Dave Barach | b7f1faa | 2017-08-29 11:43:37 -0400 | [diff] [blame] | 319 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 320 | int |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 321 | parse_uri (char *uri, session_endpoint_t * sep) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 322 | { |
| 323 | unformat_input_t _input, *input = &_input; |
| 324 | |
Dave Barach | b7f1faa | 2017-08-29 11:43:37 -0400 | [diff] [blame] | 325 | if (cache_uri && !strncmp (uri, (char *) cache_uri, vec_len (cache_uri))) |
| 326 | { |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 327 | *sep = *cache_sep; |
Dave Barach | b7f1faa | 2017-08-29 11:43:37 -0400 | [diff] [blame] | 328 | return 0; |
| 329 | } |
| 330 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 331 | /* Make sure */ |
| 332 | uri = (char *) format (0, "%s%c", uri, 0); |
| 333 | |
| 334 | /* Parse uri */ |
| 335 | unformat_init_string (input, uri, strlen (uri)); |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 336 | if (!unformat (input, "%U", unformat_vnet_uri, sep)) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 337 | { |
| 338 | unformat_free (input); |
| 339 | return VNET_API_ERROR_INVALID_VALUE; |
| 340 | } |
| 341 | unformat_free (input); |
| 342 | |
Dave Barach | b7f1faa | 2017-08-29 11:43:37 -0400 | [diff] [blame] | 343 | vec_free (cache_uri); |
| 344 | cache_uri = (u8 *) uri; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 345 | if (cache_sep) |
| 346 | clib_mem_free (cache_sep); |
| 347 | cache_sep = clib_mem_alloc (sizeof (*sep)); |
| 348 | *cache_sep = *sep; |
Dave Barach | b7f1faa | 2017-08-29 11:43:37 -0400 | [diff] [blame] | 349 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 350 | return 0; |
| 351 | } |
| 352 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 353 | static int |
| 354 | session_validate_namespace (u8 * namespace_id, u64 secret, u32 * app_ns_index) |
| 355 | { |
| 356 | app_namespace_t *app_ns; |
| 357 | if (vec_len (namespace_id) == 0) |
| 358 | { |
| 359 | /* Use default namespace */ |
| 360 | *app_ns_index = 0; |
| 361 | return 0; |
| 362 | } |
| 363 | |
| 364 | *app_ns_index = app_namespace_index_from_id (namespace_id); |
| 365 | if (*app_ns_index == APP_NAMESPACE_INVALID_INDEX) |
| 366 | return VNET_API_ERROR_APP_INVALID_NS; |
| 367 | app_ns = app_namespace_get (*app_ns_index); |
| 368 | if (!app_ns) |
| 369 | return VNET_API_ERROR_APP_INVALID_NS; |
| 370 | if (app_ns->ns_secret != secret) |
| 371 | return VNET_API_ERROR_APP_WRONG_NS_SECRET; |
| 372 | return 0; |
| 373 | } |
| 374 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 375 | /** |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 376 | * Attach application to vpp |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 377 | * |
| 378 | * Allocates a vpp app, i.e., a structure that keeps back pointers |
| 379 | * to external app and a segment manager for shared memory fifo based |
| 380 | * communication with the external app. |
| 381 | */ |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 382 | clib_error_t * |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 383 | vnet_application_attach (vnet_app_attach_args_t * a) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 384 | { |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 385 | svm_fifo_segment_private_t *fs; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 386 | application_t *app = 0; |
| 387 | segment_manager_t *sm; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 388 | u32 app_ns_index = 0; |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 389 | u64 secret; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 390 | int rv; |
| 391 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 392 | app = application_lookup (a->api_client_index); |
| 393 | if (app) |
| 394 | return clib_error_return_code (0, VNET_API_ERROR_APP_ALREADY_ATTACHED, |
| 395 | 0, "app already attached"); |
| 396 | |
| 397 | secret = a->options[APP_OPTIONS_NAMESPACE_SECRET]; |
| 398 | if ((rv = session_validate_namespace (a->namespace_id, secret, |
| 399 | &app_ns_index))) |
| 400 | return clib_error_return_code (0, rv, 0, "namespace validation: %d", rv); |
| 401 | a->options[APP_OPTIONS_NAMESPACE] = app_ns_index; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 402 | app = application_new (); |
| 403 | if ((rv = application_init (app, a->api_client_index, a->options, |
| 404 | a->session_cb_vft))) |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 405 | return clib_error_return_code (0, rv, 0, "app init: %d", rv); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 406 | |
Damjan Marion | 7bee80c | 2017-04-26 15:32:12 +0200 | [diff] [blame] | 407 | a->app_event_queue_address = pointer_to_uword (app->event_queue); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 408 | sm = segment_manager_get (app->first_segment_manager); |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 409 | fs = segment_manager_get_segment (sm->segment_indices[0]); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 410 | |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 411 | if (application_is_proxy (app)) |
| 412 | application_setup_proxy (app); |
| 413 | |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 414 | ASSERT (vec_len (fs->ssvm.name) <= 128); |
| 415 | a->segment = &fs->ssvm; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 416 | a->app_index = app->index; |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 417 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 418 | return 0; |
| 419 | } |
| 420 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 421 | /** |
| 422 | * Detach application from vpp |
| 423 | */ |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 424 | int |
| 425 | vnet_application_detach (vnet_app_detach_args_t * a) |
| 426 | { |
| 427 | application_t *app; |
| 428 | app = application_get_if_valid (a->app_index); |
| 429 | |
| 430 | if (!app) |
| 431 | { |
| 432 | clib_warning ("app not attached"); |
| 433 | return VNET_API_ERROR_APPLICATION_NOT_ATTACHED; |
| 434 | } |
| 435 | |
| 436 | application_del (app); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 437 | return 0; |
| 438 | } |
| 439 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 440 | int |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 441 | vnet_bind_uri (vnet_bind_args_t * a) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 442 | { |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 443 | session_endpoint_t sep = SESSION_ENDPOINT_NULL; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 444 | int rv; |
| 445 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 446 | rv = parse_uri (a->uri, &sep); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 447 | if (rv) |
| 448 | return rv; |
| 449 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 450 | return vnet_bind_i (a->app_index, &sep, &a->handle); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 451 | } |
| 452 | |
| 453 | int |
| 454 | vnet_unbind_uri (vnet_unbind_args_t * a) |
| 455 | { |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 456 | stream_session_t *listener; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 457 | session_endpoint_t sep = SESSION_ENDPOINT_NULL; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 458 | int rv; |
| 459 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 460 | rv = parse_uri (a->uri, &sep); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 461 | if (rv) |
| 462 | return rv; |
| 463 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 464 | /* NOTE: only default table supported for uri */ |
| 465 | listener = session_lookup_listener (0, &sep); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 466 | if (!listener) |
| 467 | return VNET_API_ERROR_ADDRESS_NOT_IN_USE; |
| 468 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 469 | return vnet_unbind_i (a->app_index, listen_session_get_handle (listener)); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 470 | } |
| 471 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 472 | clib_error_t * |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 473 | vnet_connect_uri (vnet_connect_args_t * a) |
| 474 | { |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 475 | session_endpoint_t sep_null = SESSION_ENDPOINT_NULL; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 476 | int rv; |
| 477 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 478 | /* Parse uri */ |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 479 | a->sep = sep_null; |
| 480 | rv = parse_uri (a->uri, &a->sep); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 481 | if (rv) |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 482 | return clib_error_return_code (0, rv, 0, "app init: %d", rv); |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 483 | if ((rv = vnet_connect_i (a->app_index, a->api_context, &a->sep, a->mp))) |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 484 | return clib_error_return_code (0, rv, 0, "connect failed"); |
| 485 | return 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 486 | } |
| 487 | |
| 488 | int |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 489 | vnet_disconnect_session (vnet_disconnect_args_t * a) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 490 | { |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 491 | u32 index, thread_index; |
| 492 | stream_session_t *s; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 493 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 494 | session_parse_handle (a->handle, &index, &thread_index); |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 495 | s = session_get_if_valid (index, thread_index); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 496 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 497 | if (!s || s->app_index != a->app_index) |
| 498 | return VNET_API_ERROR_INVALID_VALUE; |
| 499 | |
Florin Coras | a546481 | 2017-04-19 13:00:05 -0700 | [diff] [blame] | 500 | /* We're peeking into another's thread pool. Make sure */ |
| 501 | ASSERT (s->session_index == index); |
| 502 | |
Florin Coras | 2f8d8fa | 2018-01-26 06:36:04 -0800 | [diff] [blame^] | 503 | stream_session_disconnect (s); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 504 | return 0; |
| 505 | } |
| 506 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 507 | clib_error_t * |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 508 | vnet_bind (vnet_bind_args_t * a) |
| 509 | { |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 510 | int rv; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 511 | if ((rv = vnet_bind_i (a->app_index, &a->sep, &a->handle))) |
| 512 | return clib_error_return_code (0, rv, 0, "bind failed"); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 513 | return 0; |
| 514 | } |
| 515 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 516 | clib_error_t * |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 517 | vnet_unbind (vnet_unbind_args_t * a) |
| 518 | { |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 519 | int rv; |
| 520 | if ((rv = vnet_unbind_i (a->app_index, a->handle))) |
| 521 | return clib_error_return_code (0, rv, 0, "unbind failed"); |
| 522 | return 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 523 | } |
| 524 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 525 | clib_error_t * |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 526 | vnet_connect (vnet_connect_args_t * a) |
| 527 | { |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 528 | int rv; |
| 529 | if ((rv = vnet_connect_i (a->app_index, a->api_context, &a->sep, a->mp))) |
| 530 | return clib_error_return_code (0, rv, 0, "connect failed"); |
| 531 | return 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 532 | } |
| 533 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 534 | /* |
| 535 | * fd.io coding-style-patch-verification: ON |
| 536 | * |
| 537 | * Local Variables: |
| 538 | * eval: (c-set-style "gnu") |
| 539 | * End: |
| 540 | */ |