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 | |
Florin Coras | 371ca50 | 2018-02-21 12:07:41 -0800 | [diff] [blame] | 25 | /* |
| 26 | * TLS server cert and keys to be used for testing only |
| 27 | */ |
| 28 | const char test_srv_crt_rsa[] = |
| 29 | "-----BEGIN CERTIFICATE-----\r\n" |
Florin Coras | 8f89dd0 | 2018-03-05 16:53:07 -0800 | [diff] [blame] | 30 | "MIID5zCCAs+gAwIBAgIJALeMYCEHrTtJMA0GCSqGSIb3DQEBCwUAMIGJMQswCQYD\r\n" |
| 31 | "VQQGEwJVUzELMAkGA1UECAwCQ0ExETAPBgNVBAcMCFNhbiBKb3NlMQ4wDAYDVQQK\r\n" |
| 32 | "DAVDaXNjbzEOMAwGA1UECwwFZmQuaW8xFjAUBgNVBAMMDXRlc3R0bHMuZmQuaW8x\r\n" |
| 33 | "IjAgBgkqhkiG9w0BCQEWE3ZwcC1kZXZAbGlzdHMuZmQuaW8wHhcNMTgwMzA1MjEx\r\n" |
| 34 | "NTEyWhcNMjgwMzAyMjExNTEyWjCBiTELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNB\r\n" |
| 35 | "MREwDwYDVQQHDAhTYW4gSm9zZTEOMAwGA1UECgwFQ2lzY28xDjAMBgNVBAsMBWZk\r\n" |
| 36 | "LmlvMRYwFAYDVQQDDA10ZXN0dGxzLmZkLmlvMSIwIAYJKoZIhvcNAQkBFhN2cHAt\r\n" |
| 37 | "ZGV2QGxpc3RzLmZkLmlvMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA\r\n" |
| 38 | "4C1k8a1DuStgggqT4o09fP9sJ2dC54bxhS/Xk2VEfaIZ222WSo4X/syRVfVy9Yah\r\n" |
| 39 | "cpI1zJ/RDxaZSFhgA+nPZBrFMsrULkrdAOpOVj8eDEp9JuWdO2ODSoFnCvLxcYWB\r\n" |
| 40 | "Yc5kHryJpEaGJl1sFQSesnzMFty/59ta0stk0Fp8r5NhIjWvSovGzPo6Bhz+VS2c\r\n" |
| 41 | "ebIZh4x1t2hHaFcgm0qJoJ6DceReWCW8w+yOVovTolGGq+bpb2Hn7MnRSZ2K2NdL\r\n" |
| 42 | "+aLXpkZbS/AODP1FF2vTO1mYL290LO7/51vJmPXNKSDYMy5EvILr5/VqtjsFCwRL\r\n" |
| 43 | "Q4jcM/+GeHSAFWx4qIv0BwIDAQABo1AwTjAdBgNVHQ4EFgQUWa1SOB37xmT53tZQ\r\n" |
| 44 | "aXuLLhRI7U8wHwYDVR0jBBgwFoAUWa1SOB37xmT53tZQaXuLLhRI7U8wDAYDVR0T\r\n" |
| 45 | "BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEAoUht13W4ya27NVzQuCMvqPWL3VM4\r\n" |
| 46 | "3xbPFk02FaGz/WupPu276zGlzJAZrbuDcQowwwU1Ni1Yygxl96s1c2M5rHDTrOKG\r\n" |
| 47 | "rK0hbkSFBo+i6I8u4HiiQ4rYmG0Hv6+sXn3of0HsbtDPGgWZoipPWDljPYEURu3e\r\n" |
| 48 | "3HRe/Dtsj9CakBoSDzs8ndWaBR+f4sM9Tk1cjD46Gq2T/qpSPXqKxEUXlzhdCAn4\r\n" |
| 49 | "twub17Bq2kykHpppCwPg5M+v30tHG/R2Go15MeFWbEJthFk3TZMjKL7UFs7fH+x2\r\n" |
| 50 | "wSonXb++jY+KmCb93C+soABBizE57g/KmiR2IxQ/LMjDik01RSUIaM0lLA==\r\n" |
| 51 | "-----END CERTIFICATE-----\r\n"; |
Florin Coras | 371ca50 | 2018-02-21 12:07:41 -0800 | [diff] [blame] | 52 | const u32 test_srv_crt_rsa_len = sizeof (test_srv_crt_rsa); |
| 53 | |
| 54 | const char test_srv_key_rsa[] = |
Florin Coras | 8f89dd0 | 2018-03-05 16:53:07 -0800 | [diff] [blame] | 55 | "-----BEGIN PRIVATE KEY-----\r\n" |
| 56 | "MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDgLWTxrUO5K2CC\r\n" |
| 57 | "CpPijT18/2wnZ0LnhvGFL9eTZUR9ohnbbZZKjhf+zJFV9XL1hqFykjXMn9EPFplI\r\n" |
| 58 | "WGAD6c9kGsUyytQuSt0A6k5WPx4MSn0m5Z07Y4NKgWcK8vFxhYFhzmQevImkRoYm\r\n" |
| 59 | "XWwVBJ6yfMwW3L/n21rSy2TQWnyvk2EiNa9Ki8bM+joGHP5VLZx5shmHjHW3aEdo\r\n" |
| 60 | "VyCbSomgnoNx5F5YJbzD7I5Wi9OiUYar5ulvYefsydFJnYrY10v5otemRltL8A4M\r\n" |
| 61 | "/UUXa9M7WZgvb3Qs7v/nW8mY9c0pINgzLkS8guvn9Wq2OwULBEtDiNwz/4Z4dIAV\r\n" |
| 62 | "bHioi/QHAgMBAAECggEBAMzGipP8+oT166U+NlJXRFifFVN1DvdhG9PWnOxGL+c3\r\n" |
| 63 | "ILmBBC08WQzmHshPemBvR6DZkA1H23cV5JTiLWrFtC00CvhXsLRMrE5+uWotI6yE\r\n" |
| 64 | "iofybMroHvD6/X5R510UX9hQ6MHu5ShLR5VZ9zXHz5MpTmB/60jG5dLx+jgcwBK8\r\n" |
| 65 | "LuGv2YB/WCUwT9QJ3YU2eaingnXtz/MrFbkbltrqlnBdlD+kTtw6Yac9y1XuuQXc\r\n" |
| 66 | "BPeulLNDuPolJVWbUvDBZrpt2dXTgz8ws1sv+wCNE0xwQJsqW4Nx3QkpibUL9RUr\r\n" |
| 67 | "CVbKlNfa9lopT6nGKlgX69R/uH35yh9AOsfasro6w0ECgYEA82UJ8u/+ORah+0sF\r\n" |
| 68 | "Q0FfW5MTdi7OAUHOz16pUsGlaEv0ERrjZxmAkHA/VRwpvDBpx4alCv0Hc39PFLIk\r\n" |
| 69 | "nhSsM2BEuBkTAs6/GaoNAiBtQVE/hN7awNRWVmlieS0go3Y3dzaE9IUMyj8sPOFT\r\n" |
| 70 | "5JdJ6BM69PHKCkY3dKdnnfpFEuECgYEA68mRpteunF1mdZgXs+WrN+uLlRrQR20F\r\n" |
| 71 | "ZyMYiUCH2Dtn26EzA2moy7FipIIrQcX/j+KhYNGM3e7MU4LymIO29E18mn8JODnH\r\n" |
| 72 | "sQOXzBTsf8A4yIVMkcuQD3bfb0JiUGYUPOidTp2N7IJA7+6Yc3vQOyb74lnKnJoO\r\n" |
| 73 | "gougPT2wS+cCgYAn7muzb6xFsXDhyW0Tm6YJYBfRS9yAWEuVufINobeBZPSl2cN1\r\n" |
| 74 | "Jrnw+HlrfTNbrJWuJmjtZJXUXQ6cVp2rUbjutNyRV4vG6iRwEXYQ40EJdkr1gZpi\r\n" |
| 75 | "CHQhuShuuPih2MNAy7EEbM+sXrDjTBR3bFqzuHPzu7dp+BshCFX3lRfAAQKBgGQt\r\n" |
| 76 | "K5i7IhCFDjb/+3IPLgOAK7mZvsvZ4eXD33TQ2eZgtut1PXtBtNl17/b85uv293Fm\r\n" |
| 77 | "VDISVcsk3eLNS8zIiT6afUoWlxAwXEs0v5WRfjl4radkGvgGiJpJYvyeM67877RB\r\n" |
| 78 | "EDSKc/X8ESLfOB44iGvZUEMG6zJFscx9DgN25iQZAoGAbyd+JEWwdVH9/K3IH1t2\r\n" |
| 79 | "PBkZX17kNWv+iVM1WyFjbe++vfKZCrOJiyiqhDeEqgrP3AuNMlaaduC3VRC3G5oV\r\n" |
| 80 | "Mj1tlhDWQ/qhvKdCKNdIVQYDE75nw+FRWV8yYkHAnXYW3tNoweDIwixE0hkPR1bc\r\n" |
| 81 | "oEjPLVNtx8SOj/M4rhaPT3I=\r\n" "-----END PRIVATE KEY-----\r\n"; |
Florin Coras | 371ca50 | 2018-02-21 12:07:41 -0800 | [diff] [blame] | 82 | const u32 test_srv_key_rsa_len = sizeof (test_srv_key_rsa); |
| 83 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 84 | static u8 |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 85 | session_endpoint_is_local (session_endpoint_t * sep) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 86 | { |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 87 | return (ip_is_zero (&sep->ip, sep->is_ip4) |
| 88 | || ip_is_local_host (&sep->ip, sep->is_ip4)); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 89 | } |
| 90 | |
| 91 | static u8 |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 92 | session_endpoint_is_zero (session_endpoint_t * sep) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 93 | { |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 94 | return ip_is_zero (&sep->ip, sep->is_ip4); |
| 95 | } |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 96 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 97 | u8 |
| 98 | session_endpoint_in_ns (session_endpoint_t * sep) |
| 99 | { |
Florin Coras | e1b819e | 2018-03-15 07:45:27 -0700 | [diff] [blame] | 100 | u8 is_lep = session_endpoint_is_local (sep); |
| 101 | if (!is_lep && sep->sw_if_index != ENDPOINT_INVALID_INDEX |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 102 | && !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] | 103 | { |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 104 | clib_warning ("sw_if_index %u not configured with ip %U", |
| 105 | sep->sw_if_index, format_ip46_address, &sep->ip, |
| 106 | sep->is_ip4); |
| 107 | return 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 108 | } |
Florin Coras | e1b819e | 2018-03-15 07:45:27 -0700 | [diff] [blame] | 109 | return (is_lep || ip_is_local (sep->fib_index, &sep->ip, sep->is_ip4)); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 110 | } |
| 111 | |
| 112 | int |
| 113 | api_parse_session_handle (u64 handle, u32 * session_index, u32 * thread_index) |
| 114 | { |
| 115 | session_manager_main_t *smm = vnet_get_session_manager_main (); |
| 116 | stream_session_t *pool; |
| 117 | |
| 118 | *thread_index = handle & 0xFFFFFFFF; |
| 119 | *session_index = handle >> 32; |
| 120 | |
| 121 | if (*thread_index >= vec_len (smm->sessions)) |
| 122 | return VNET_API_ERROR_INVALID_VALUE; |
| 123 | |
| 124 | pool = smm->sessions[*thread_index]; |
| 125 | |
| 126 | if (pool_is_free_index (pool, *session_index)) |
| 127 | return VNET_API_ERROR_INVALID_VALUE_2; |
| 128 | |
| 129 | return 0; |
| 130 | } |
| 131 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 132 | static void |
| 133 | session_endpoint_update_for_app (session_endpoint_t * sep, |
| 134 | application_t * app) |
| 135 | { |
| 136 | app_namespace_t *app_ns; |
| 137 | app_ns = app_namespace_get (app->ns_index); |
| 138 | if (app_ns) |
| 139 | { |
| 140 | /* Ask transport and network to bind to/connect using local interface |
| 141 | * that "supports" app's namespace. This will fix our local connection |
| 142 | * endpoint. |
| 143 | */ |
| 144 | sep->sw_if_index = app_ns->sw_if_index; |
| 145 | sep->fib_index = |
| 146 | sep->is_ip4 ? app_ns->ip4_fib_index : app_ns->ip6_fib_index; |
| 147 | } |
| 148 | } |
| 149 | |
| 150 | static int |
| 151 | vnet_bind_i (u32 app_index, session_endpoint_t * sep, u64 * handle) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 152 | { |
Florin Coras | 5fda7a3 | 2018-02-14 08:04:31 -0800 | [diff] [blame] | 153 | u64 lh, ll_handle = SESSION_INVALID_HANDLE; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 154 | application_t *app; |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 155 | u32 table_index; |
Florin Coras | 5fda7a3 | 2018-02-14 08:04:31 -0800 | [diff] [blame] | 156 | int rv; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 157 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 158 | app = application_get_if_valid (app_index); |
| 159 | if (!app) |
| 160 | { |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 161 | SESSION_DBG ("app not attached"); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 162 | return VNET_API_ERROR_APPLICATION_NOT_ATTACHED; |
| 163 | } |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 164 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 165 | session_endpoint_update_for_app (sep, app); |
| 166 | if (!session_endpoint_in_ns (sep)) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 167 | return VNET_API_ERROR_INVALID_VALUE_2; |
| 168 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 169 | table_index = application_session_table (app, |
| 170 | session_endpoint_fib_proto (sep)); |
Florin Coras | 5fda7a3 | 2018-02-14 08:04:31 -0800 | [diff] [blame] | 171 | lh = session_lookup_endpoint_listener (table_index, sep, 1); |
| 172 | if (lh != SESSION_INVALID_HANDLE) |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 173 | return VNET_API_ERROR_ADDRESS_IN_USE; |
| 174 | |
| 175 | /* |
| 176 | * Add session endpoint to local session table. Only binds to "inaddr_any" |
| 177 | * (i.e., zero address) are added to local scope table. |
| 178 | */ |
Florin Coras | e1b819e | 2018-03-15 07:45:27 -0700 | [diff] [blame] | 179 | if (application_has_local_scope (app) && session_endpoint_is_local (sep)) |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 180 | { |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 181 | if ((rv = application_start_local_listen (app, sep, handle))) |
| 182 | return rv; |
Florin Coras | 5fda7a3 | 2018-02-14 08:04:31 -0800 | [diff] [blame] | 183 | ll_handle = *handle; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 184 | } |
| 185 | |
| 186 | if (!application_has_global_scope (app)) |
Florin Coras | 5fda7a3 | 2018-02-14 08:04:31 -0800 | [diff] [blame] | 187 | return (ll_handle == SESSION_INVALID_HANDLE ? -1 : 0); |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 188 | |
| 189 | /* |
| 190 | * Add session endpoint to global session table |
| 191 | */ |
| 192 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 193 | /* Setup listen path down to transport */ |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 194 | rv = application_start_listen (app, sep, handle); |
Florin Coras | 5fda7a3 | 2018-02-14 08:04:31 -0800 | [diff] [blame] | 195 | if (rv && ll_handle != SESSION_INVALID_HANDLE) |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 196 | session_lookup_del_session_endpoint (table_index, sep); |
Florin Coras | 5fda7a3 | 2018-02-14 08:04:31 -0800 | [diff] [blame] | 197 | |
| 198 | /* |
| 199 | * Store in local table listener the index of the transport layer |
| 200 | * listener. We'll need local listeners are hit and we need to |
| 201 | * return global handle |
| 202 | */ |
| 203 | if (ll_handle != SESSION_INVALID_HANDLE) |
| 204 | { |
| 205 | local_session_t *ll; |
| 206 | stream_session_t *tl; |
| 207 | ll = application_get_local_listener_w_handle (ll_handle); |
| 208 | tl = listen_session_get_from_handle (*handle); |
| 209 | ll->transport_listener_index = tl->session_index; |
| 210 | } |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 211 | return rv; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 212 | } |
| 213 | |
| 214 | int |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 215 | vnet_unbind_i (u32 app_index, session_handle_t handle) |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 216 | { |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 217 | application_t *app; |
| 218 | int rv; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 219 | |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 220 | if (!(app = application_get_if_valid (app_index))) |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 221 | { |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 222 | SESSION_DBG ("app (%d) not attached", app_index); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 223 | return VNET_API_ERROR_APPLICATION_NOT_ATTACHED; |
| 224 | } |
| 225 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 226 | if (application_has_local_scope (app)) |
| 227 | { |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 228 | if ((rv = application_stop_local_listen (app, handle))) |
| 229 | return rv; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 230 | } |
| 231 | |
| 232 | /* |
| 233 | * Clear the global scope table of the listener |
| 234 | */ |
| 235 | if (application_has_global_scope (app)) |
| 236 | return application_stop_listen (app, handle); |
| 237 | return 0; |
| 238 | } |
| 239 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 240 | int |
Florin Coras | 371ca50 | 2018-02-21 12:07:41 -0800 | [diff] [blame] | 241 | application_connect (u32 client_index, u32 api_context, |
| 242 | session_endpoint_t * sep) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 243 | { |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 244 | application_t *server, *client; |
| 245 | u32 table_index, server_index, li; |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 246 | stream_session_t *listener; |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 247 | local_session_t *ll; |
| 248 | u64 lh; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 249 | |
| 250 | if (session_endpoint_is_zero (sep)) |
| 251 | return VNET_API_ERROR_INVALID_VALUE; |
| 252 | |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 253 | client = application_get (client_index); |
| 254 | session_endpoint_update_for_app (sep, client); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 255 | |
| 256 | /* |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 257 | * First check the local scope for locally attached destinations. |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 258 | * If we have local scope, we pass *all* connects through it since we may |
| 259 | * have special policy rules even for non-local destinations, think proxy. |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 260 | */ |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 261 | if (application_has_local_scope (client)) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 262 | { |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 263 | table_index = application_local_session_table (client); |
| 264 | lh = session_lookup_local_endpoint (table_index, sep); |
| 265 | if (lh == SESSION_DROP_HANDLE) |
Florin Coras | a2ff7b8 | 2017-11-08 17:55:03 -0800 | [diff] [blame] | 266 | return VNET_API_ERROR_APP_CONNECT_FILTERED; |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 267 | |
Florin Coras | 5fda7a3 | 2018-02-14 08:04:31 -0800 | [diff] [blame] | 268 | if (lh == SESSION_INVALID_HANDLE) |
| 269 | goto global_scope; |
| 270 | |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 271 | local_session_parse_handle (lh, &server_index, &li); |
| 272 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 273 | /* |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 274 | * Break loop if rule in local table points to connecting app. This |
| 275 | * can happen if client is a generic proxy. Route connect through |
| 276 | * global table instead. |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 277 | */ |
Florin Coras | 5fda7a3 | 2018-02-14 08:04:31 -0800 | [diff] [blame] | 278 | if (server_index != client_index) |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 279 | { |
Florin Coras | 5fda7a3 | 2018-02-14 08:04:31 -0800 | [diff] [blame] | 280 | server = application_get (server_index); |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 281 | ll = application_get_local_listen_session (server, li); |
| 282 | return application_local_session_connect (table_index, client, |
| 283 | server, ll, api_context); |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 284 | } |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 285 | } |
| 286 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 287 | /* |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 288 | * If nothing found, check the global scope for locally attached |
| 289 | * destinations. Make sure first that we're allowed to. |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 290 | */ |
Florin Coras | 5fda7a3 | 2018-02-14 08:04:31 -0800 | [diff] [blame] | 291 | |
| 292 | global_scope: |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 293 | if (session_endpoint_is_local (sep)) |
| 294 | return VNET_API_ERROR_SESSION_CONNECT; |
| 295 | |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 296 | if (!application_has_global_scope (client)) |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 297 | return VNET_API_ERROR_APP_CONNECT_SCOPE; |
| 298 | |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 299 | table_index = application_session_table (client, |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 300 | session_endpoint_fib_proto (sep)); |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 301 | listener = session_lookup_listener (table_index, sep); |
| 302 | if (listener) |
| 303 | { |
| 304 | server = application_get (listener->app_index); |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 305 | if (server) |
| 306 | return application_local_session_connect (table_index, client, server, |
| 307 | (local_session_t *) |
| 308 | listener, api_context); |
Florin Coras | 3cbc04b | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 309 | } |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 310 | |
| 311 | /* |
| 312 | * Not connecting to a local server, propagate to transport |
| 313 | */ |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 314 | if (application_open_session (client, sep, api_context)) |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 315 | return VNET_API_ERROR_SESSION_CONNECT; |
| 316 | return 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 317 | } |
| 318 | |
| 319 | /** |
| 320 | * unformat a vnet URI |
| 321 | * |
Florin Coras | 8f89dd0 | 2018-03-05 16:53:07 -0800 | [diff] [blame] | 322 | * transport-proto://[hostname]ip46-addr:port |
| 323 | * eg. tcp://ip46-addr:port |
| 324 | * tls://[testtsl.fd.io]ip46-addr:port |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 325 | * |
| 326 | * u8 ip46_address[16]; |
| 327 | * u16 port_in_host_byte_order; |
| 328 | * stream_session_type_t sst; |
| 329 | * u8 *fifo_name; |
| 330 | * |
| 331 | * if (unformat (input, "%U", unformat_vnet_uri, &ip46_address, |
| 332 | * &sst, &port, &fifo_name)) |
| 333 | * etc... |
| 334 | * |
| 335 | */ |
| 336 | uword |
| 337 | unformat_vnet_uri (unformat_input_t * input, va_list * args) |
| 338 | { |
Florin Coras | 8f89dd0 | 2018-03-05 16:53:07 -0800 | [diff] [blame] | 339 | session_endpoint_extended_t *sep = va_arg (*args, |
| 340 | session_endpoint_extended_t *); |
Florin Coras | 371ca50 | 2018-02-21 12:07:41 -0800 | [diff] [blame] | 341 | u32 transport_proto = 0, port; |
| 342 | |
Florin Coras | 8f89dd0 | 2018-03-05 16:53:07 -0800 | [diff] [blame] | 343 | if (unformat (input, "%U://%U/%d", unformat_transport_proto, |
| 344 | &transport_proto, unformat_ip4_address, &sep->ip.ip4, &port)) |
| 345 | { |
| 346 | sep->transport_proto = transport_proto; |
| 347 | sep->port = clib_host_to_net_u16 (port); |
| 348 | sep->is_ip4 = 1; |
| 349 | return 1; |
| 350 | } |
| 351 | else if (unformat (input, "%U://[%s]%U/%d", unformat_transport_proto, |
| 352 | &transport_proto, &sep->hostname, unformat_ip4_address, |
| 353 | &sep->ip.ip4, &port)) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 354 | { |
Florin Coras | 4399c2e | 2018-01-25 06:34:42 -0800 | [diff] [blame] | 355 | sep->transport_proto = transport_proto; |
Florin Coras | 371ca50 | 2018-02-21 12:07:41 -0800 | [diff] [blame] | 356 | sep->port = clib_host_to_net_u16 (port); |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 357 | sep->is_ip4 = 1; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 358 | return 1; |
| 359 | } |
Florin Coras | 371ca50 | 2018-02-21 12:07:41 -0800 | [diff] [blame] | 360 | else if (unformat (input, "%U://%U/%d", unformat_transport_proto, |
| 361 | &transport_proto, unformat_ip6_address, &sep->ip.ip6, |
| 362 | &port)) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 363 | { |
Florin Coras | 4399c2e | 2018-01-25 06:34:42 -0800 | [diff] [blame] | 364 | sep->transport_proto = transport_proto; |
Florin Coras | 371ca50 | 2018-02-21 12:07:41 -0800 | [diff] [blame] | 365 | sep->port = clib_host_to_net_u16 (port); |
Marco Varlese | 191a594 | 2017-10-30 18:17:21 +0100 | [diff] [blame] | 366 | sep->is_ip4 = 0; |
| 367 | return 1; |
| 368 | } |
Florin Coras | 8f89dd0 | 2018-03-05 16:53:07 -0800 | [diff] [blame] | 369 | else if (unformat (input, "%U://[%s]%U/%d", unformat_transport_proto, |
| 370 | &transport_proto, &sep->hostname, unformat_ip6_address, |
| 371 | &sep->ip.ip6, &port)) |
| 372 | { |
| 373 | sep->transport_proto = transport_proto; |
| 374 | sep->port = clib_host_to_net_u16 (port); |
| 375 | sep->is_ip4 = 0; |
| 376 | return 1; |
| 377 | } |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 378 | return 0; |
| 379 | } |
| 380 | |
Dave Barach | b7f1faa | 2017-08-29 11:43:37 -0400 | [diff] [blame] | 381 | static u8 *cache_uri; |
Florin Coras | 8f89dd0 | 2018-03-05 16:53:07 -0800 | [diff] [blame] | 382 | static session_endpoint_extended_t *cache_sep; |
Dave Barach | b7f1faa | 2017-08-29 11:43:37 -0400 | [diff] [blame] | 383 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 384 | int |
Florin Coras | 8f89dd0 | 2018-03-05 16:53:07 -0800 | [diff] [blame] | 385 | parse_uri (char *uri, session_endpoint_extended_t * sep) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 386 | { |
| 387 | unformat_input_t _input, *input = &_input; |
| 388 | |
Dave Barach | b7f1faa | 2017-08-29 11:43:37 -0400 | [diff] [blame] | 389 | if (cache_uri && !strncmp (uri, (char *) cache_uri, vec_len (cache_uri))) |
| 390 | { |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 391 | *sep = *cache_sep; |
Dave Barach | b7f1faa | 2017-08-29 11:43:37 -0400 | [diff] [blame] | 392 | return 0; |
| 393 | } |
| 394 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 395 | /* Make sure */ |
| 396 | uri = (char *) format (0, "%s%c", uri, 0); |
| 397 | |
| 398 | /* Parse uri */ |
| 399 | unformat_init_string (input, uri, strlen (uri)); |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 400 | if (!unformat (input, "%U", unformat_vnet_uri, sep)) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 401 | { |
| 402 | unformat_free (input); |
| 403 | return VNET_API_ERROR_INVALID_VALUE; |
| 404 | } |
| 405 | unformat_free (input); |
| 406 | |
Dave Barach | b7f1faa | 2017-08-29 11:43:37 -0400 | [diff] [blame] | 407 | vec_free (cache_uri); |
| 408 | cache_uri = (u8 *) uri; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 409 | if (cache_sep) |
| 410 | clib_mem_free (cache_sep); |
| 411 | cache_sep = clib_mem_alloc (sizeof (*sep)); |
| 412 | *cache_sep = *sep; |
Dave Barach | b7f1faa | 2017-08-29 11:43:37 -0400 | [diff] [blame] | 413 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 414 | return 0; |
| 415 | } |
| 416 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 417 | static int |
| 418 | session_validate_namespace (u8 * namespace_id, u64 secret, u32 * app_ns_index) |
| 419 | { |
| 420 | app_namespace_t *app_ns; |
| 421 | if (vec_len (namespace_id) == 0) |
| 422 | { |
| 423 | /* Use default namespace */ |
| 424 | *app_ns_index = 0; |
| 425 | return 0; |
| 426 | } |
| 427 | |
| 428 | *app_ns_index = app_namespace_index_from_id (namespace_id); |
| 429 | if (*app_ns_index == APP_NAMESPACE_INVALID_INDEX) |
| 430 | return VNET_API_ERROR_APP_INVALID_NS; |
| 431 | app_ns = app_namespace_get (*app_ns_index); |
| 432 | if (!app_ns) |
| 433 | return VNET_API_ERROR_APP_INVALID_NS; |
| 434 | if (app_ns->ns_secret != secret) |
| 435 | return VNET_API_ERROR_APP_WRONG_NS_SECRET; |
| 436 | return 0; |
| 437 | } |
| 438 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 439 | /** |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 440 | * Attach application to vpp |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 441 | * |
| 442 | * Allocates a vpp app, i.e., a structure that keeps back pointers |
| 443 | * to external app and a segment manager for shared memory fifo based |
| 444 | * communication with the external app. |
| 445 | */ |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 446 | clib_error_t * |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 447 | vnet_application_attach (vnet_app_attach_args_t * a) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 448 | { |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 449 | svm_fifo_segment_private_t *fs; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 450 | application_t *app = 0; |
| 451 | segment_manager_t *sm; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 452 | u32 app_ns_index = 0; |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 453 | u64 secret; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 454 | int rv; |
| 455 | |
Florin Coras | 0bee9ce | 2018-03-22 21:24:31 -0700 | [diff] [blame] | 456 | if (a->api_client_index != APP_INVALID_INDEX) |
| 457 | app = application_lookup (a->api_client_index); |
| 458 | else if (a->name) |
| 459 | app = application_lookup_name (a->name); |
| 460 | else |
| 461 | return clib_error_return_code (0, VNET_API_ERROR_INVALID_VALUE, 0, |
| 462 | "api index or name must be provided"); |
| 463 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 464 | if (app) |
Florin Coras | 0bee9ce | 2018-03-22 21:24:31 -0700 | [diff] [blame] | 465 | return clib_error_return_code (0, VNET_API_ERROR_APP_ALREADY_ATTACHED, 0, |
| 466 | "app already attached"); |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 467 | |
| 468 | secret = a->options[APP_OPTIONS_NAMESPACE_SECRET]; |
| 469 | if ((rv = session_validate_namespace (a->namespace_id, secret, |
| 470 | &app_ns_index))) |
| 471 | return clib_error_return_code (0, rv, 0, "namespace validation: %d", rv); |
| 472 | a->options[APP_OPTIONS_NAMESPACE] = app_ns_index; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 473 | app = application_new (); |
Florin Coras | 0bee9ce | 2018-03-22 21:24:31 -0700 | [diff] [blame] | 474 | if ((rv = application_init (app, a->api_client_index, a->name, a->options, |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 475 | a->session_cb_vft))) |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 476 | return clib_error_return_code (0, rv, 0, "app init: %d", rv); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 477 | |
Damjan Marion | 7bee80c | 2017-04-26 15:32:12 +0200 | [diff] [blame] | 478 | a->app_event_queue_address = pointer_to_uword (app->event_queue); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 479 | sm = segment_manager_get (app->first_segment_manager); |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 480 | fs = segment_manager_get_segment_w_lock (sm, 0); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 481 | |
Florin Coras | 7999e83 | 2017-10-31 01:51:04 -0700 | [diff] [blame] | 482 | if (application_is_proxy (app)) |
| 483 | application_setup_proxy (app); |
| 484 | |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 485 | ASSERT (vec_len (fs->ssvm.name) <= 128); |
| 486 | a->segment = &fs->ssvm; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 487 | a->app_index = app->index; |
Florin Coras | b384b54 | 2018-01-15 01:08:33 -0800 | [diff] [blame] | 488 | |
Florin Coras | a332c46 | 2018-01-31 06:52:17 -0800 | [diff] [blame] | 489 | segment_manager_segment_reader_unlock (sm); |
| 490 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 491 | return 0; |
| 492 | } |
| 493 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 494 | /** |
| 495 | * Detach application from vpp |
| 496 | */ |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 497 | int |
| 498 | vnet_application_detach (vnet_app_detach_args_t * a) |
| 499 | { |
| 500 | application_t *app; |
| 501 | app = application_get_if_valid (a->app_index); |
| 502 | |
| 503 | if (!app) |
| 504 | { |
| 505 | clib_warning ("app not attached"); |
| 506 | return VNET_API_ERROR_APPLICATION_NOT_ATTACHED; |
| 507 | } |
| 508 | |
| 509 | application_del (app); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 510 | return 0; |
| 511 | } |
| 512 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 513 | int |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 514 | vnet_bind_uri (vnet_bind_args_t * a) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 515 | { |
Florin Coras | 8f89dd0 | 2018-03-05 16:53:07 -0800 | [diff] [blame] | 516 | session_endpoint_extended_t sep = SESSION_ENDPOINT_EXT_NULL; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 517 | int rv; |
| 518 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 519 | rv = parse_uri (a->uri, &sep); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 520 | if (rv) |
| 521 | return rv; |
| 522 | |
Florin Coras | 8f89dd0 | 2018-03-05 16:53:07 -0800 | [diff] [blame] | 523 | return vnet_bind_i (a->app_index, (session_endpoint_t *) & sep, &a->handle); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 524 | } |
| 525 | |
| 526 | int |
| 527 | vnet_unbind_uri (vnet_unbind_args_t * a) |
| 528 | { |
Florin Coras | 8f89dd0 | 2018-03-05 16:53:07 -0800 | [diff] [blame] | 529 | session_endpoint_extended_t sep = SESSION_ENDPOINT_EXT_NULL; |
Florin Coras | 371ca50 | 2018-02-21 12:07:41 -0800 | [diff] [blame] | 530 | stream_session_t *listener; |
Florin Coras | 36ec1f5 | 2018-05-29 21:15:38 -0700 | [diff] [blame] | 531 | u32 table_index; |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 532 | int rv; |
| 533 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 534 | rv = parse_uri (a->uri, &sep); |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 535 | if (rv) |
| 536 | return rv; |
| 537 | |
Florin Coras | 36ec1f5 | 2018-05-29 21:15:38 -0700 | [diff] [blame] | 538 | /* NOTE: only default fib tables supported for uri apis */ |
| 539 | table_index = session_lookup_get_index_for_fib (fib_ip_proto (!sep.is_ip4), |
| 540 | 0); |
| 541 | listener = session_lookup_listener (table_index, |
| 542 | (session_endpoint_t *) & sep); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 543 | if (!listener) |
| 544 | return VNET_API_ERROR_ADDRESS_NOT_IN_USE; |
| 545 | |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 546 | return vnet_unbind_i (a->app_index, listen_session_get_handle (listener)); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 547 | } |
| 548 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 549 | clib_error_t * |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 550 | vnet_connect_uri (vnet_connect_args_t * a) |
| 551 | { |
Florin Coras | 8f89dd0 | 2018-03-05 16:53:07 -0800 | [diff] [blame] | 552 | session_endpoint_extended_t sep = SESSION_ENDPOINT_EXT_NULL; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 553 | int rv; |
| 554 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 555 | /* Parse uri */ |
Florin Coras | 371ca50 | 2018-02-21 12:07:41 -0800 | [diff] [blame] | 556 | rv = parse_uri (a->uri, &sep); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 557 | if (rv) |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 558 | return clib_error_return_code (0, rv, 0, "app init: %d", rv); |
Florin Coras | 371ca50 | 2018-02-21 12:07:41 -0800 | [diff] [blame] | 559 | |
Florin Coras | 8f89dd0 | 2018-03-05 16:53:07 -0800 | [diff] [blame] | 560 | if ((rv = application_connect (a->app_index, a->api_context, |
| 561 | (session_endpoint_t *) & sep))) |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 562 | return clib_error_return_code (0, rv, 0, "connect failed"); |
| 563 | return 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 564 | } |
| 565 | |
| 566 | int |
Florin Coras | 6cf30ad | 2017-04-04 23:08:23 -0700 | [diff] [blame] | 567 | vnet_disconnect_session (vnet_disconnect_args_t * a) |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 568 | { |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 569 | if (session_handle_is_local (a->handle)) |
| 570 | { |
| 571 | local_session_t *ls; |
| 572 | ls = application_get_local_session_from_handle (a->handle); |
| 573 | if (ls->app_index != a->app_index && ls->client_index != a->app_index) |
| 574 | { |
| 575 | clib_warning ("app %u is neither client nor server for session %u", |
| 576 | a->app_index, a->app_index); |
| 577 | return VNET_API_ERROR_INVALID_VALUE; |
| 578 | } |
| 579 | return application_local_session_disconnect (a->app_index, ls); |
| 580 | } |
| 581 | else |
| 582 | { |
| 583 | stream_session_t *s; |
| 584 | s = session_get_from_handle_if_valid (a->handle); |
| 585 | if (!s || s->app_index != a->app_index) |
| 586 | return VNET_API_ERROR_INVALID_VALUE; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 587 | |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 588 | /* We're peeking into another's thread pool. Make sure */ |
| 589 | ASSERT (s->session_index == session_index_from_handle (a->handle)); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 590 | |
Florin Coras | f8f516a | 2018-02-08 15:10:09 -0800 | [diff] [blame] | 591 | stream_session_disconnect (s); |
| 592 | } |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 593 | return 0; |
| 594 | } |
| 595 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 596 | clib_error_t * |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 597 | vnet_bind (vnet_bind_args_t * a) |
| 598 | { |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 599 | int rv; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 600 | if ((rv = vnet_bind_i (a->app_index, &a->sep, &a->handle))) |
Florin Coras | 54693d2 | 2018-07-17 10:46:29 -0700 | [diff] [blame^] | 601 | return clib_error_return_code (0, rv, 0, "bind failed: %d", rv); |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 602 | return 0; |
| 603 | } |
| 604 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 605 | clib_error_t * |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 606 | vnet_unbind (vnet_unbind_args_t * a) |
| 607 | { |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 608 | int rv; |
| 609 | if ((rv = vnet_unbind_i (a->app_index, a->handle))) |
Florin Coras | 54693d2 | 2018-07-17 10:46:29 -0700 | [diff] [blame^] | 610 | return clib_error_return_code (0, rv, 0, "unbind failed: %d", rv); |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 611 | return 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 612 | } |
| 613 | |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 614 | clib_error_t * |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 615 | vnet_connect (vnet_connect_args_t * a) |
| 616 | { |
Florin Coras | 8f89dd0 | 2018-03-05 16:53:07 -0800 | [diff] [blame] | 617 | session_endpoint_t *sep = (session_endpoint_t *) & a->sep; |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 618 | int rv; |
Florin Coras | 371ca50 | 2018-02-21 12:07:41 -0800 | [diff] [blame] | 619 | |
| 620 | if ((rv = application_connect (a->app_index, a->api_context, sep))) |
Florin Coras | 54693d2 | 2018-07-17 10:46:29 -0700 | [diff] [blame^] | 621 | return clib_error_return_code (0, rv, 0, "connect failed: %d", rv); |
Florin Coras | cea194d | 2017-10-02 00:18:51 -0700 | [diff] [blame] | 622 | return 0; |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 623 | } |
| 624 | |
Dave Barach | 68b0fb0 | 2017-02-28 15:15:56 -0500 | [diff] [blame] | 625 | /* |
| 626 | * fd.io coding-style-patch-verification: ON |
| 627 | * |
| 628 | * Local Variables: |
| 629 | * eval: (c-set-style "gnu") |
| 630 | * End: |
| 631 | */ |