src/vnet/session/session_api.c

   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>
  19 #include <vnet/session/application_interface.h>
  20 #include <vnet/session/session_rules_table.h>
  21 #include <vnet/session/session_table.h>
  22
  23 #include <vnet/vnet_msg_enum.h>
  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)                 \
  43 _(APPLICATION_ATTACH, application_attach)                               \
  44 _(APPLICATION_DETACH, application_detach)                               \
  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)                             \
  52 _(BIND_SOCK, bind_sock)                                                 \
  53 _(UNBIND_SOCK, unbind_sock)                                             \
  54 _(CONNECT_SOCK, connect_sock)                                           \
  55 _(SESSION_ENABLE_DISABLE, session_enable_disable)                       \
  56 _(APP_NAMESPACE_ADD_DEL, app_namespace_add_del)                         \
  57 _(SESSION_RULE_ADD_DEL, session_rule_add_del)                           \
  58 _(SESSION_RULES_DUMP, session_rules_dump)                               \
  59
  60 static int
  61 session_send_memfd_fd (vl_api_registration_t * reg, const ssvm_private_t * sp)
  62 {
  63   clib_error_t *error;
  64   if (vl_api_registration_file_index (reg) == VL_API_INVALID_FI)
  65     {
  66       clib_warning ("can't send memfd fd");
  67       return -1;
  68     }
  69   error = vl_api_send_fd_msg (reg, sp->fd);
  70   if (error)
  71     {
  72       clib_error_report (error);
  73       return -1;
  74     }
  75   return 0;
  76 }
  77
  78 static int
  79 send_add_segment_callback (u32 api_client_index, const ssvm_private_t * sp)
  80 {
  81   vl_api_map_another_segment_t *mp;
  82   vl_api_registration_t *reg;
  83
  84   reg = vl_mem_api_client_index_to_registration (api_client_index);
  85   if (!reg)
  86     {
  87       clib_warning ("no registration: %u", api_client_index);
  88       return -1;
  89     }
  90
  91   if (ssvm_type (sp) == SSVM_SEGMENT_MEMFD
  92       && vl_api_registration_file_index (reg) == VL_API_INVALID_FI)
  93     {
  94       clib_warning ("can't send memfd fd");
  95       return -1;
  96     }
  97
  98   mp = vl_msg_api_alloc_as_if_client (sizeof (*mp));
  99   memset (mp, 0, sizeof (*mp));
 100   mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_MAP_ANOTHER_SEGMENT);
 101   mp->segment_size = sp->ssvm_size;
 102   strncpy ((char *) mp->segment_name, (char *) sp->name,
 103            sizeof (mp->segment_name) - 1);
 104
 105   vl_msg_api_send_shmem (reg->vl_input_queue, (u8 *) & mp);
 106
 107   if (ssvm_type (sp) == SSVM_SEGMENT_MEMFD)
 108     return session_send_memfd_fd (reg, sp);
 109
 110   return 0;
 111 }
 112
 113 static int
 114 send_session_accept_callback (stream_session_t * s)
 115 {
 116   application_t *server = application_get (s->app_index);
 117   transport_proto_vft_t *tp_vft;
 118   vl_api_accept_session_t *mp;
 119   vl_api_registration_t *reg;
 120   transport_connection_t *tc;
 121   stream_session_t *listener;
 122   svm_queue_t *vpp_queue;
 123
 124   vpp_queue = session_manager_get_vpp_event_queue (s->thread_index);
 125   reg = vl_mem_api_client_index_to_registration (server->api_client_index);
 126   if (!reg)
 127     {
 128       clib_warning ("no registration: %u", server->api_client_index);
 129       return -1;
 130     }
 131
 132   mp = vl_mem_api_alloc_as_if_client_w_reg (reg, sizeof (*mp));
 133   memset (mp, 0, sizeof (*mp));
 134
 135   mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_ACCEPT_SESSION);
 136   mp->context = server->index;
 137   listener = listen_session_get (s->session_type, s->listener_index);
 138   tp_vft = transport_protocol_get_vft (session_get_transport_proto (s));
 139   tc = tp_vft->get_connection (s->connection_index, s->thread_index);
 140   mp->listener_handle = listen_session_get_handle (listener);
 141
 142   if (application_is_proxy (server))
 143     {
 144       listener =
 145         application_first_listener (server,
 146                                     transport_connection_fib_proto (tc),
 147                                     tc->proto);
 148       if (listener)
 149         mp->listener_handle = listen_session_get_handle (listener);
 150     }
 151   mp->handle = session_handle (s);
 152   mp->server_rx_fifo = pointer_to_uword (s->server_rx_fifo);
 153   mp->server_tx_fifo = pointer_to_uword (s->server_tx_fifo);
 154   mp->vpp_event_queue_address = pointer_to_uword (vpp_queue);
 155   mp->port = tc->rmt_port;
 156   mp->is_ip4 = tc->is_ip4;
 157   clib_memcpy (&mp->ip, &tc->rmt_ip, sizeof (tc->rmt_ip));
 158   vl_msg_api_send_shmem (reg->vl_input_queue, (u8 *) & mp);
 159
 160   return 0;
 161 }
 162
 163 static void
 164 send_session_disconnect_callback (stream_session_t * s)
 165 {
 166   application_t *app = application_get (s->app_index);
 167   vl_api_disconnect_session_t *mp;
 168   vl_api_registration_t *reg;
 169
 170   reg = vl_mem_api_client_index_to_registration (app->api_client_index);
 171   if (!reg)
 172     {
 173       clib_warning ("no registration: %u", app->api_client_index);
 174       return;
 175     }
 176
 177   mp = vl_mem_api_alloc_as_if_client_w_reg (reg, sizeof (*mp));
 178   memset (mp, 0, sizeof (*mp));
 179   mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_DISCONNECT_SESSION);
 180   mp->handle = session_handle (s);
 181   vl_msg_api_send_shmem (reg->vl_input_queue, (u8 *) & mp);
 182 }
 183
 184 static void
 185 send_session_reset_callback (stream_session_t * s)
 186 {
 187   application_t *app = application_get (s->app_index);
 188   vl_api_registration_t *reg;
 189   vl_api_reset_session_t *mp;
 190
 191   reg = vl_mem_api_client_index_to_registration (app->api_client_index);
 192   if (!reg)
 193     {
 194       clib_warning ("no registration: %u", app->api_client_index);
 195       return;
 196     }
 197
 198   mp = vl_mem_api_alloc_as_if_client_w_reg (reg, sizeof (*mp));
 199   memset (mp, 0, sizeof (*mp));
 200   mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_RESET_SESSION);
 201   mp->handle = session_handle (s);
 202   vl_msg_api_send_shmem (reg->vl_input_queue, (u8 *) & mp);
 203 }
 204
 205 int
 206 send_session_connected_callback (u32 app_index, u32 api_context,
 207                                  stream_session_t * s, u8 is_fail)
 208 {
 209   vl_api_connect_session_reply_t *mp;
 210   transport_connection_t *tc;
 211   vl_api_registration_t *reg;
 212   svm_queue_t *vpp_queue;
 213   application_t *app;
 214
 215   app = application_get (app_index);
 216   reg = vl_mem_api_client_index_to_registration (app->api_client_index);
 217   if (!reg)
 218     {
 219       clib_warning ("no registration: %u", app->api_client_index);
 220       return -1;
 221     }
 222
 223   mp = vl_mem_api_alloc_as_if_client_w_reg (reg, sizeof (*mp));
 224   mp->_vl_msg_id = clib_host_to_net_u16 (VL_API_CONNECT_SESSION_REPLY);
 225   mp->context = api_context;
 226
 227   if (is_fail)
 228     goto done;
 229
 230   tc = session_get_transport (s);
 231   if (!tc)
 232     {
 233       is_fail = 1;
 234       goto done;
 235     }
 236
 237   vpp_queue = session_manager_get_vpp_event_queue (s->thread_index);
 238   mp->server_rx_fifo = pointer_to_uword (s->server_rx_fifo);
 239   mp->server_tx_fifo = pointer_to_uword (s->server_tx_fifo);
 240   mp->handle = session_handle (s);
 241   mp->vpp_event_queue_address = pointer_to_uword (vpp_queue);
 242   clib_memcpy (mp->lcl_ip, &tc->lcl_ip, sizeof (tc->lcl_ip));
 243   mp->is_ip4 = tc->is_ip4;
 244   mp->lcl_port = tc->lcl_port;
 245
 246 done:
 247   mp->retval = is_fail ?
 248     clib_host_to_net_u32 (VNET_API_ERROR_SESSION_CONNECT) : 0;
 249   vl_msg_api_send_shmem (reg->vl_input_queue, (u8 *) & mp);
 250   return 0;
 251 }
 252
 253 /**
 254  * Redirect a connect_uri message to the indicated server.
 255  * Only sent if the server has bound the related port with
 256  * URI_OPTIONS_FLAGS_USE_FIFO
 257  */
 258 static int
 259 redirect_connect_callback (u32 server_api_client_index, void *mp_arg)
 260 {
 261   vl_api_connect_sock_t *mp = mp_arg;
 262   svm_queue_t *server_q, *client_q;
 263   segment_manager_properties_t *props;
 264   vlib_main_t *vm = vlib_get_main ();
 265   f64 timeout = vlib_time_now (vm) + 0.5;
 266   application_t *app;
 267   int rv = 0;
 268
 269   server_q = vl_api_client_index_to_input_queue (server_api_client_index);
 270
 271   if (!server_q)
 272     {
 273       rv = VNET_API_ERROR_INVALID_VALUE;
 274       goto out;
 275     }
 276
 277   client_q = vl_api_client_index_to_input_queue (mp->client_index);
 278   if (!client_q)
 279     {
 280       rv = VNET_API_ERROR_INVALID_VALUE_2;
 281       goto out;
 282     }
 283
 284   /* Tell the server the client's API queue address, so it can reply */
 285   mp->client_queue_address = pointer_to_uword (client_q);
 286   app = application_lookup (mp->client_index);
 287   if (!app)
 288     {
 289       clib_warning ("no client application");
 290       return -1;
 291     }
 292
 293   props = segment_manager_properties_get (app->sm_properties);
 294   mp->options[APP_OPTIONS_RX_FIFO_SIZE] = props->rx_fifo_size;
 295   mp->options[APP_OPTIONS_TX_FIFO_SIZE] = props->tx_fifo_size;
 296
 297   /*
 298    * Bounce message handlers MUST NOT block the data-plane.
 299    * Spin waiting for the queue lock, but
 300    */
 301
 302   while (vlib_time_now (vm) < timeout)
 303     {
 304       rv = svm_queue_add (server_q, (u8 *) & mp, 1 /*nowait */ );
 305       switch (rv)
 306         {
 307           /* correctly enqueued */
 308         case 0:
 309           return VNET_API_ERROR_SESSION_REDIRECT;
 310
 311           /* continue spinning, wait for pthread_mutex_trylock to work */
 312         case -1:
 313           continue;
 314
 315           /* queue stuffed, drop the msg */
 316         case -2:
 317           rv = VNET_API_ERROR_QUEUE_FULL;
 318           goto out;
 319         }
 320     }
 321 out:
 322   /* Dispose of the message */
 323   vl_msg_api_free (mp);
 324   return rv;
 325 }
 326
 327 static session_cb_vft_t session_cb_vft = {
 328   .session_accept_callback = send_session_accept_callback,
 329   .session_disconnect_callback = send_session_disconnect_callback,
 330   .session_connected_callback = send_session_connected_callback,
 331   .session_reset_callback = send_session_reset_callback,
 332   .add_segment_callback = send_add_segment_callback,
 333   .redirect_connect_callback = redirect_connect_callback
 334 };
 335
 336 static void
 337 vl_api_session_enable_disable_t_handler (vl_api_session_enable_disable_t * mp)
 338 {
 339   vl_api_session_enable_disable_reply_t *rmp;
 340   vlib_main_t *vm = vlib_get_main ();
 341   int rv = 0;
 342
 343   vnet_session_enable_disable (vm, mp->is_enable);
 344   REPLY_MACRO (VL_API_SESSION_ENABLE_DISABLE_REPLY);
 345 }
 346
 347 static void
 348 vl_api_application_attach_t_handler (vl_api_application_attach_t * mp)
 349 {
 350   vl_api_application_attach_reply_t *rmp;
 351   ssvm_private_t *segp, *evt_q_segment;
 352   vnet_app_attach_args_t _a, *a = &_a;
 353   vl_api_registration_t *reg;
 354   clib_error_t *error = 0;
 355   int rv = 0;
 356
 357   reg = vl_api_client_index_to_registration (mp->client_index);
 358   if (!reg)
 359     return;
 360
 361   if (session_manager_is_enabled () == 0)
 362     {
 363       rv = VNET_API_ERROR_FEATURE_DISABLED;
 364       goto done;
 365     }
 366
 367   STATIC_ASSERT (sizeof (u64) * APP_OPTIONS_N_OPTIONS <=
 368                  sizeof (mp->options),
 369                  "Out of options, fix api message definition");
 370
 371   memset (a, 0, sizeof (*a));
 372   a->api_client_index = mp->client_index;
 373   a->options = mp->options;
 374   a->session_cb_vft = &session_cb_vft;
 375
 376   if (mp->namespace_id_len > 64)
 377     {
 378       rv = VNET_API_ERROR_INVALID_VALUE;
 379       goto done;
 380     }
 381
 382   if (mp->namespace_id_len)
 383     {
 384       vec_validate (a->namespace_id, mp->namespace_id_len - 1);
 385       clib_memcpy (a->namespace_id, mp->namespace_id, mp->namespace_id_len);
 386     }
 387
 388   if ((error = vnet_application_attach (a)))
 389     {
 390       rv = clib_error_get_code (error);
 391       clib_error_report (error);
 392     }
 393   vec_free (a->namespace_id);
 394
 395 done:
 396
 397   /* *INDENT-OFF* */
 398   REPLY_MACRO2 (VL_API_APPLICATION_ATTACH_REPLY, ({
 399     if (!rv)
 400       {
 401         segp = a->segment;
 402         rmp->segment_name_length = 0;
 403         rmp->segment_size = segp->ssvm_size;
 404         if (vec_len (segp->name))
 405           {
 406             memcpy (rmp->segment_name, segp->name, vec_len (segp->name));
 407             rmp->segment_name_length = vec_len (segp->name);
 408           }
 409         rmp->app_event_queue_address = a->app_event_queue_address;
 410       }
 411   }));
 412   /* *INDENT-ON* */
 413
 414   if (rv)
 415     return;
 416
 417   /* Send fifo segment fd if needed */
 418   if (ssvm_type (a->segment) == SSVM_SEGMENT_MEMFD)
 419     session_send_memfd_fd (reg, a->segment);
 420   /* Send event queues segment */
 421   if ((evt_q_segment = session_manager_get_evt_q_segment ()))
 422     session_send_memfd_fd (reg, evt_q_segment);
 423 }
 424
 425 static void
 426 vl_api_application_detach_t_handler (vl_api_application_detach_t * mp)
 427 {
 428   vl_api_application_detach_reply_t *rmp;
 429   int rv = VNET_API_ERROR_INVALID_VALUE_2;
 430   vnet_app_detach_args_t _a, *a = &_a;
 431   application_t *app;
 432
 433   if (session_manager_is_enabled () == 0)
 434     {
 435       rv = VNET_API_ERROR_FEATURE_DISABLED;
 436       goto done;
 437     }
 438
 439   app = application_lookup (mp->client_index);
 440   if (app)
 441     {
 442       a->app_index = app->index;
 443       rv = vnet_application_detach (a);
 444     }
 445
 446 done:
 447   REPLY_MACRO (VL_API_APPLICATION_DETACH_REPLY);
 448 }
 449
 450 static void
 451 vl_api_bind_uri_t_handler (vl_api_bind_uri_t * mp)
 452 {
 453   vl_api_bind_uri_reply_t *rmp;
 454   vnet_bind_args_t _a, *a = &_a;
 455   application_t *app;
 456   int rv;
 457
 458   if (session_manager_is_enabled () == 0)
 459     {
 460       rv = VNET_API_ERROR_FEATURE_DISABLED;
 461       goto done;
 462     }
 463
 464   app = application_lookup (mp->client_index);
 465   if (app)
 466     {
 467       memset (a, 0, sizeof (*a));
 468       a->uri = (char *) mp->uri;
 469       a->app_index = app->index;
 470       rv = vnet_bind_uri (a);
 471     }
 472   else
 473     {
 474       rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
 475     }
 476
 477 done:
 478   REPLY_MACRO (VL_API_BIND_URI_REPLY);
 479 }
 480
 481 static void
 482 vl_api_unbind_uri_t_handler (vl_api_unbind_uri_t * mp)
 483 {
 484   vl_api_unbind_uri_reply_t *rmp;
 485   application_t *app;
 486   vnet_unbind_args_t _a, *a = &_a;
 487   int rv;
 488
 489   if (session_manager_is_enabled () == 0)
 490     {
 491       rv = VNET_API_ERROR_FEATURE_DISABLED;
 492       goto done;
 493     }
 494
 495   app = application_lookup (mp->client_index);
 496   if (app)
 497     {
 498       a->uri = (char *) mp->uri;
 499       a->app_index = app->index;
 500       rv = vnet_unbind_uri (a);
 501     }
 502   else
 503     {
 504       rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
 505     }
 506
 507 done:
 508   REPLY_MACRO (VL_API_UNBIND_URI_REPLY);
 509 }
 510
 511 static void
 512 vl_api_connect_uri_t_handler (vl_api_connect_uri_t * mp)
 513 {
 514   vl_api_connect_session_reply_t *rmp;
 515   vnet_connect_args_t _a, *a = &_a;
 516   application_t *app;
 517   clib_error_t *error = 0;
 518   int rv = 0;
 519
 520   if (session_manager_is_enabled () == 0)
 521     {
 522       rv = VNET_API_ERROR_FEATURE_DISABLED;
 523       goto done;
 524     }
 525
 526   app = application_lookup (mp->client_index);
 527   if (app)
 528     {
 529       a->uri = (char *) mp->uri;
 530       a->api_context = mp->context;
 531       a->app_index = app->index;
 532       a->mp = mp;
 533       if ((error = vnet_connect_uri (a)))
 534         {
 535           rv = clib_error_get_code (error);
 536           if (rv != VNET_API_ERROR_SESSION_REDIRECT)
 537             clib_error_report (error);
 538         }
 539     }
 540   else
 541     {
 542       rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
 543     }
 544
 545   /*
 546    * Don't reply to stream (tcp) connects. The reply will come once
 547    * the connection is established. In case of the redirects, the reply
 548    * will come from the server app.
 549    */
 550   if (rv == 0 || rv == VNET_API_ERROR_SESSION_REDIRECT)
 551     return;
 552
 553 done:
 554   /* *INDENT-OFF* */
 555   REPLY_MACRO (VL_API_CONNECT_SESSION_REPLY);
 556   /* *INDENT-ON* */
 557 }
 558
 559 static void
 560 vl_api_disconnect_session_t_handler (vl_api_disconnect_session_t * mp)
 561 {
 562   vl_api_disconnect_session_reply_t *rmp;
 563   vnet_disconnect_args_t _a, *a = &_a;
 564   application_t *app;
 565   int rv = 0;
 566
 567   if (session_manager_is_enabled () == 0)
 568     {
 569       rv = VNET_API_ERROR_FEATURE_DISABLED;
 570       goto done;
 571     }
 572
 573   app = application_lookup (mp->client_index);
 574   if (app)
 575     {
 576       a->handle = mp->handle;
 577       a->app_index = app->index;
 578       rv = vnet_disconnect_session (a);
 579     }
 580   else
 581     {
 582       rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
 583     }
 584
 585 done:
 586   REPLY_MACRO2 (VL_API_DISCONNECT_SESSION_REPLY, rmp->handle = mp->handle);
 587 }
 588
 589 static void
 590 vl_api_disconnect_session_reply_t_handler (vl_api_disconnect_session_reply_t *
 591                                            mp)
 592 {
 593   vnet_disconnect_args_t _a, *a = &_a;
 594   application_t *app;
 595
 596   /* Client objected to disconnecting the session, log and continue */
 597   if (mp->retval)
 598     {
 599       clib_warning ("client retval %d", mp->retval);
 600       return;
 601     }
 602
 603   /* Disconnect has been confirmed. Confirm close to transport */
 604   app = application_lookup (mp->client_index);
 605   if (app)
 606     {
 607       a->handle = mp->handle;
 608       a->app_index = app->index;
 609       vnet_disconnect_session (a);
 610     }
 611 }
 612
 613 static void
 614 vl_api_reset_session_reply_t_handler (vl_api_reset_session_reply_t * mp)
 615 {
 616   application_t *app;
 617   stream_session_t *s;
 618   u32 index, thread_index;
 619
 620   app = application_lookup (mp->client_index);
 621   if (!app)
 622     return;
 623
 624   session_parse_handle (mp->handle, &index, &thread_index);
 625   s = session_get_if_valid (index, thread_index);
 626   if (s == 0 || app->index != s->app_index)
 627     {
 628       clib_warning ("Invalid session!");
 629       return;
 630     }
 631
 632   /* Client objected to resetting the session, log and continue */
 633   if (mp->retval)
 634     {
 635       clib_warning ("client retval %d", mp->retval);
 636       return;
 637     }
 638
 639   /* This comes as a response to a reset, transport only waiting for
 640    * confirmation to remove connection state, no need to disconnect */
 641   stream_session_cleanup (s);
 642 }
 643
 644 static void
 645 vl_api_accept_session_reply_t_handler (vl_api_accept_session_reply_t * mp)
 646 {
 647   stream_session_t *s;
 648   u32 session_index, thread_index;
 649   vnet_disconnect_args_t _a, *a = &_a;
 650
 651   /* Server isn't interested, kill the session */
 652   if (mp->retval)
 653     {
 654       a->app_index = mp->context;
 655       a->handle = mp->handle;
 656       vnet_disconnect_session (a);
 657     }
 658   else
 659     {
 660       session_parse_handle (mp->handle, &session_index, &thread_index);
 661       s = session_get_if_valid (session_index, thread_index);
 662       if (!s)
 663         {
 664           clib_warning ("session doesn't exist");
 665           return;
 666         }
 667       if (s->app_index != mp->context)
 668         {
 669           clib_warning ("app doesn't own session");
 670           return;
 671         }
 672       s->session_state = SESSION_STATE_READY;
 673     }
 674 }
 675
 676 static void
 677 vl_api_map_another_segment_reply_t_handler (vl_api_map_another_segment_reply_t
 678                                             * mp)
 679 {
 680   clib_warning ("not implemented");
 681 }
 682
 683 static void
 684 vl_api_bind_sock_t_handler (vl_api_bind_sock_t * mp)
 685 {
 686   vl_api_bind_sock_reply_t *rmp;
 687   vnet_bind_args_t _a, *a = &_a;
 688   int rv = 0;
 689   clib_error_t *error;
 690   application_t *app = 0;
 691   stream_session_t *s;
 692   transport_connection_t *tc = 0;
 693   ip46_address_t *ip46;
 694
 695   if (session_manager_is_enabled () == 0)
 696     {
 697       rv = VNET_API_ERROR_FEATURE_DISABLED;
 698       goto done;
 699     }
 700
 701   app = application_lookup (mp->client_index);
 702   if (!app)
 703     {
 704       rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
 705       goto done;
 706     }
 707
 708   ip46 = (ip46_address_t *) mp->ip;
 709   memset (a, 0, sizeof (*a));
 710   a->sep.is_ip4 = mp->is_ip4;
 711   a->sep.ip = *ip46;
 712   a->sep.port = mp->port;
 713   a->sep.fib_index = mp->vrf;
 714   a->sep.sw_if_index = ENDPOINT_INVALID_INDEX;
 715   a->sep.transport_proto = mp->proto;
 716   a->app_index = app->index;
 717
 718   if ((error = vnet_bind (a)))
 719     {
 720       rv = clib_error_get_code (error);
 721       clib_error_report (error);
 722     }
 723
 724 done:
 725   /* *INDENT-OFF* */
 726   REPLY_MACRO2 (VL_API_BIND_SOCK_REPLY,({
 727     if (!rv)
 728       {
 729         rmp->handle = a->handle;
 730         rmp->lcl_port = mp->port;
 731         if (app && application_has_global_scope (app))
 732           {
 733             s = listen_session_get_from_handle (a->handle);
 734             tc = listen_session_get_transport (s);
 735             rmp->lcl_is_ip4 = tc->is_ip4;
 736             clib_memcpy (rmp->lcl_ip, &tc->lcl_ip, sizeof (tc->lcl_ip));
 737           }
 738       }
 739   }));
 740   /* *INDENT-ON* */
 741 }
 742
 743 static void
 744 vl_api_unbind_sock_t_handler (vl_api_unbind_sock_t * mp)
 745 {
 746   vl_api_unbind_sock_reply_t *rmp;
 747   vnet_unbind_args_t _a, *a = &_a;
 748   application_t *app;
 749   clib_error_t *error;
 750   int rv = 0;
 751
 752   if (session_manager_is_enabled () == 0)
 753     {
 754       rv = VNET_API_ERROR_FEATURE_DISABLED;
 755       goto done;
 756     }
 757
 758   app = application_lookup (mp->client_index);
 759   if (app)
 760     {
 761       a->app_index = app->index;
 762       a->handle = mp->handle;
 763       if ((error = vnet_unbind (a)))
 764         {
 765           rv = clib_error_get_code (error);
 766           clib_error_report (error);
 767         }
 768     }
 769
 770 done:
 771   REPLY_MACRO (VL_API_UNBIND_SOCK_REPLY);
 772 }
 773
 774 static void
 775 vl_api_connect_sock_t_handler (vl_api_connect_sock_t * mp)
 776 {
 777   vl_api_connect_session_reply_t *rmp;
 778   vnet_connect_args_t _a, *a = &_a;
 779   application_t *app;
 780   clib_error_t *error = 0;
 781   int rv = 0;
 782
 783   if (session_manager_is_enabled () == 0)
 784     {
 785       rv = VNET_API_ERROR_FEATURE_DISABLED;
 786       goto done;
 787     }
 788
 789   app = application_lookup (mp->client_index);
 790   if (app)
 791     {
 792       svm_queue_t *client_q;
 793       ip46_address_t *ip46 = (ip46_address_t *) mp->ip;
 794
 795       client_q = vl_api_client_index_to_input_queue (mp->client_index);
 796       mp->client_queue_address = pointer_to_uword (client_q);
 797       a->sep.is_ip4 = mp->is_ip4;
 798       a->sep.ip = *ip46;
 799       a->sep.port = mp->port;
 800       a->sep.transport_proto = mp->proto;
 801       a->sep.fib_index = mp->vrf;
 802       a->sep.sw_if_index = ENDPOINT_INVALID_INDEX;
 803       a->api_context = mp->context;
 804       a->app_index = app->index;
 805       a->mp = mp;
 806       if ((error = vnet_connect (a)))
 807         {
 808           rv = clib_error_get_code (error);
 809           if (rv != VNET_API_ERROR_SESSION_REDIRECT)
 810             clib_error_report (error);
 811         }
 812     }
 813   else
 814     {
 815       rv = VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
 816     }
 817
 818   if (rv == 0 || rv == VNET_API_ERROR_SESSION_REDIRECT)
 819     return;
 820
 821   /* Got some error, relay it */
 822
 823 done:
 824   REPLY_MACRO (VL_API_CONNECT_SESSION_REPLY);
 825 }
 826
 827 static void
 828 vl_api_app_namespace_add_del_t_handler (vl_api_app_namespace_add_del_t * mp)
 829 {
 830   vl_api_app_namespace_add_del_reply_t *rmp;
 831   clib_error_t *error = 0;
 832   u32 appns_index = 0;
 833   u8 *ns_id = 0;
 834   int rv = 0;
 835   if (!session_manager_is_enabled ())
 836     {
 837       rv = VNET_API_ERROR_FEATURE_DISABLED;
 838       goto done;
 839     }
 840
 841   if (mp->namespace_id_len > ARRAY_LEN (mp->namespace_id))
 842     {
 843       rv = VNET_API_ERROR_INVALID_VALUE;
 844       goto done;
 845     }
 846
 847   vec_validate (ns_id, mp->namespace_id_len - 1);
 848   clib_memcpy (ns_id, mp->namespace_id, mp->namespace_id_len);
 849   vnet_app_namespace_add_del_args_t args = {
 850     .ns_id = ns_id,
 851     .secret = clib_net_to_host_u64 (mp->secret),
 852     .sw_if_index = clib_net_to_host_u32 (mp->sw_if_index),
 853     .ip4_fib_id = clib_net_to_host_u32 (mp->ip4_fib_id),
 854     .ip6_fib_id = clib_net_to_host_u32 (mp->ip6_fib_id),
 855     .is_add = 1
 856   };
 857   error = vnet_app_namespace_add_del (&args);
 858   if (error)
 859     {
 860       rv = clib_error_get_code (error);
 861       clib_error_report (error);
 862     }
 863   else
 864     {
 865       appns_index = app_namespace_index_from_id (ns_id);
 866       if (appns_index == APP_NAMESPACE_INVALID_INDEX)
 867         {
 868           clib_warning ("app ns lookup failed");
 869           rv = VNET_API_ERROR_UNSPECIFIED;
 870         }
 871     }
 872   vec_free (ns_id);
 873
 874   /* *INDENT-OFF* */
 875 done:
 876   REPLY_MACRO2 (VL_API_APP_NAMESPACE_ADD_DEL_REPLY, ({
 877     if (!rv)
 878       rmp->appns_index = clib_host_to_net_u32 (appns_index);
 879   }));
 880   /* *INDENT-ON* */
 881 }
 882
 883 static void
 884 vl_api_session_rule_add_del_t_handler (vl_api_session_rule_add_del_t * mp)
 885 {
 886   vl_api_session_rule_add_del_reply_t *rmp;
 887   session_rule_add_del_args_t args;
 888   session_rule_table_add_del_args_t *table_args = &args.table_args;
 889   clib_error_t *error;
 890   u8 fib_proto;
 891   int rv = 0;
 892
 893   memset (&args, 0, sizeof (args));
 894   fib_proto = mp->is_ip4 ? FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6;
 895
 896   table_args->lcl.fp_len = mp->lcl_plen;
 897   table_args->lcl.fp_proto = fib_proto;
 898   table_args->rmt.fp_len = mp->rmt_plen;
 899   table_args->rmt.fp_proto = fib_proto;
 900   table_args->lcl_port = mp->lcl_port;
 901   table_args->rmt_port = mp->rmt_port;
 902   table_args->action_index = clib_net_to_host_u32 (mp->action_index);
 903   table_args->is_add = mp->is_add;
 904   mp->tag[sizeof (mp->tag) - 1] = 0;
 905   table_args->tag = format (0, "%s", mp->tag);
 906   args.appns_index = clib_net_to_host_u32 (mp->appns_index);
 907   args.scope = mp->scope;
 908   args.transport_proto = mp->transport_proto;
 909
 910   memset (&table_args->lcl.fp_addr, 0, sizeof (table_args->lcl.fp_addr));
 911   memset (&table_args->rmt.fp_addr, 0, sizeof (table_args->rmt.fp_addr));
 912   ip_set (&table_args->lcl.fp_addr, mp->lcl_ip, mp->is_ip4);
 913   ip_set (&table_args->rmt.fp_addr, mp->rmt_ip, mp->is_ip4);
 914   error = vnet_session_rule_add_del (&args);
 915   if (error)
 916     {
 917       rv = clib_error_get_code (error);
 918       clib_error_report (error);
 919     }
 920   vec_free (table_args->tag);
 921   REPLY_MACRO (VL_API_SESSION_RULE_ADD_DEL_REPLY);
 922 }
 923
 924 static void
 925 send_session_rule_details4 (mma_rule_16_t * rule, u8 is_local,
 926                             u8 transport_proto, u32 appns_index, u8 * tag,
 927                             vl_api_registration_t * reg, u32 context)
 928 {
 929   vl_api_session_rules_details_t *rmp = 0;
 930   session_mask_or_match_4_t *match =
 931     (session_mask_or_match_4_t *) & rule->match;
 932   session_mask_or_match_4_t *mask =
 933     (session_mask_or_match_4_t *) & rule->mask;
 934
 935   rmp = vl_msg_api_alloc (sizeof (*rmp));
 936   memset (rmp, 0, sizeof (*rmp));
 937   rmp->_vl_msg_id = ntohs (VL_API_SESSION_RULES_DETAILS);
 938   rmp->context = context;
 939
 940   rmp->is_ip4 = 1;
 941   clib_memcpy (rmp->lcl_ip, &match->lcl_ip, sizeof (match->lcl_ip));
 942   clib_memcpy (rmp->rmt_ip, &match->rmt_ip, sizeof (match->rmt_ip));
 943   rmp->lcl_plen = ip4_mask_to_preflen (&mask->lcl_ip);
 944   rmp->rmt_plen = ip4_mask_to_preflen (&mask->rmt_ip);
 945   rmp->lcl_port = match->lcl_port;
 946   rmp->rmt_port = match->rmt_port;
 947   rmp->action_index = clib_host_to_net_u32 (rule->action_index);
 948   rmp->scope =
 949     is_local ? SESSION_RULE_SCOPE_LOCAL : SESSION_RULE_SCOPE_GLOBAL;
 950   rmp->transport_proto = transport_proto;
 951   rmp->appns_index = clib_host_to_net_u32 (appns_index);
 952   if (tag)
 953     {
 954       clib_memcpy (rmp->tag, tag, vec_len (tag));
 955       rmp->tag[vec_len (tag)] = 0;
 956     }
 957
 958   vl_api_send_msg (reg, (u8 *) rmp);
 959 }
 960
 961 static void
 962 send_session_rule_details6 (mma_rule_40_t * rule, u8 is_local,
 963                             u8 transport_proto, u32 appns_index, u8 * tag,
 964                             vl_api_registration_t * reg, u32 context)
 965 {
 966   vl_api_session_rules_details_t *rmp = 0;
 967   session_mask_or_match_6_t *match =
 968     (session_mask_or_match_6_t *) & rule->match;
 969   session_mask_or_match_6_t *mask =
 970     (session_mask_or_match_6_t *) & rule->mask;
 971
 972   rmp = vl_msg_api_alloc (sizeof (*rmp));
 973   memset (rmp, 0, sizeof (*rmp));
 974   rmp->_vl_msg_id = ntohs (VL_API_SESSION_RULES_DETAILS);
 975   rmp->context = context;
 976
 977   rmp->is_ip4 = 0;
 978   clib_memcpy (rmp->lcl_ip, &match->lcl_ip, sizeof (match->lcl_ip));
 979   clib_memcpy (rmp->rmt_ip, &match->rmt_ip, sizeof (match->rmt_ip));
 980   rmp->lcl_plen = ip6_mask_to_preflen (&mask->lcl_ip);
 981   rmp->rmt_plen = ip6_mask_to_preflen (&mask->rmt_ip);
 982   rmp->lcl_port = match->lcl_port;
 983   rmp->rmt_port = match->rmt_port;
 984   rmp->action_index = clib_host_to_net_u32 (rule->action_index);
 985   rmp->scope =
 986     is_local ? SESSION_RULE_SCOPE_LOCAL : SESSION_RULE_SCOPE_GLOBAL;
 987   rmp->transport_proto = transport_proto;
 988   rmp->appns_index = clib_host_to_net_u32 (appns_index);
 989   if (tag)
 990     {
 991       clib_memcpy (rmp->tag, tag, vec_len (tag));
 992       rmp->tag[vec_len (tag)] = 0;
 993     }
 994
 995   vl_api_send_msg (reg, (u8 *) rmp);
 996 }
 997
 998 static void
 999 send_session_rules_table_details (session_rules_table_t * srt, u8 fib_proto,
1000                                   u8 tp, u8 is_local, u32 appns_index,
1001                                   vl_api_registration_t * reg, u32 context)
1002 {
1003   mma_rule_16_t *rule16;
1004   mma_rule_40_t *rule40;
1005   mma_rules_table_16_t *srt16;
1006   mma_rules_table_40_t *srt40;
1007   u32 ri;
1008
1009   if (is_local || fib_proto == FIB_PROTOCOL_IP4)
1010     {
1011       u8 *tag = 0;
1012       /* *INDENT-OFF* */
1013       srt16 = &srt->session_rules_tables_16;
1014       pool_foreach (rule16, srt16->rules, ({
1015         ri = mma_rules_table_rule_index_16 (srt16, rule16);
1016         tag = session_rules_table_rule_tag (srt, ri, 1);
1017         send_session_rule_details4 (rule16, is_local, tp, appns_index, tag,
1018                                     reg, context);
1019       }));
1020       /* *INDENT-ON* */
1021     }
1022   if (is_local || fib_proto == FIB_PROTOCOL_IP6)
1023     {
1024       u8 *tag = 0;
1025       /* *INDENT-OFF* */
1026       srt40 = &srt->session_rules_tables_40;
1027       pool_foreach (rule40, srt40->rules, ({
1028         ri = mma_rules_table_rule_index_40 (srt40, rule40);
1029         tag = session_rules_table_rule_tag (srt, ri, 1);
1030         send_session_rule_details6 (rule40, is_local, tp, appns_index, tag,
1031                                     reg, context);
1032       }));
1033       /* *INDENT-ON* */
1034     }
1035 }
1036
1037 static void
1038 vl_api_session_rules_dump_t_handler (vl_api_one_map_server_dump_t * mp)
1039 {
1040   vl_api_registration_t *reg;
1041   session_table_t *st;
1042   u8 tp;
1043
1044   reg = vl_api_client_index_to_registration (mp->client_index);
1045   if (!reg)
1046     return;
1047
1048   /* *INDENT-OFF* */
1049   session_table_foreach (st, ({
1050     for (tp = 0; tp < TRANSPORT_N_PROTO; tp++)
1051       {
1052         send_session_rules_table_details (&st->session_rules[tp],
1053                                           st->active_fib_proto, tp,
1054                                           st->is_local, st->appns_index, reg,
1055                                           mp->context);
1056       }
1057   }));
1058   /* *INDENT-ON* */
1059 }
1060
1061 static clib_error_t *
1062 application_reaper_cb (u32 client_index)
1063 {
1064   application_t *app = application_lookup (client_index);
1065   vnet_app_detach_args_t _a, *a = &_a;
1066   if (app)
1067     {
1068       a->app_index = app->index;
1069       vnet_application_detach (a);
1070     }
1071   return 0;
1072 }
1073
1074 VL_MSG_API_REAPER_FUNCTION (application_reaper_cb);
1075
1076 #define vl_msg_name_crc_list
1077 #include <vnet/vnet_all_api_h.h>
1078 #undef vl_msg_name_crc_list
1079
1080 static void
1081 setup_message_id_table (api_main_t * am)
1082 {
1083 #define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id);
1084   foreach_vl_msg_name_crc_session;
1085 #undef _
1086 }
1087
1088 /*
1089  * session_api_hookup
1090  * Add uri's API message handlers to the table.
1091  * vlib has alread mapped shared memory and
1092  * added the client registration handlers.
1093  * See .../open-repo/vlib/memclnt_vlib.c:memclnt_process()
1094  */
1095 static clib_error_t *
1096 session_api_hookup (vlib_main_t * vm)
1097 {
1098   api_main_t *am = &api_main;
1099
1100 #define _(N,n)                                                  \
1101     vl_msg_api_set_handlers(VL_API_##N, #n,                     \
1102                            vl_api_##n##_t_handler,              \
1103                            vl_noop_handler,                     \
1104                            vl_api_##n##_t_endian,               \
1105                            vl_api_##n##_t_print,                \
1106                            sizeof(vl_api_##n##_t), 1);
1107   foreach_session_api_msg;
1108 #undef _
1109
1110   /*
1111    * Messages which bounce off the data-plane to
1112    * an API client. Simply tells the message handling infra not
1113    * to free the message.
1114    *
1115    * Bounced message handlers MUST NOT block the data plane
1116    */
1117   am->message_bounce[VL_API_CONNECT_URI] = 1;
1118   am->message_bounce[VL_API_CONNECT_SOCK] = 1;
1119
1120   /*
1121    * Set up the (msg_name, crc, message-id) table
1122    */
1123   setup_message_id_table (am);
1124
1125   return 0;
1126 }
1127
1128 VLIB_API_INIT_FUNCTION (session_api_hookup);
1129
1130 /*
1131  * fd.io coding-style-patch-verification: ON
1132  *
1133  * Local Variables:
1134  * eval: (c-set-style "gnu")
1135  * End:
1136  */