src/plugins/hs_apps/sapi/vpp_echo_bapi.c

   1 /*
   2  * Copyright (c) 2019 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 <stdio.h>
  17 #include <signal.h>
  18
  19 #include <hs_apps/sapi/vpp_echo_common.h>
  20
  21 /*
  22  *
  23  *  Binary API Messages
  24  *
  25  */
  26
  27 void
  28 echo_send_attach (echo_main_t * em)
  29 {
  30   vl_api_app_attach_t *bmp;
  31   bmp = vl_msg_api_alloc (sizeof (*bmp));
  32   clib_memset (bmp, 0, sizeof (*bmp));
  33
  34   bmp->_vl_msg_id = ntohs (VL_API_APP_ATTACH);
  35   bmp->client_index = em->my_client_index;
  36   bmp->context = ntohl (0xfeedface);
  37   bmp->options[APP_OPTIONS_FLAGS] = APP_OPTIONS_FLAGS_ACCEPT_REDIRECT;
  38   bmp->options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_ADD_SEGMENT;
  39   bmp->options[APP_OPTIONS_PREALLOC_FIFO_PAIRS] = em->prealloc_fifo_pairs;
  40   bmp->options[APP_OPTIONS_RX_FIFO_SIZE] = em->fifo_size;
  41   bmp->options[APP_OPTIONS_TX_FIFO_SIZE] = em->fifo_size;
  42   bmp->options[APP_OPTIONS_ADD_SEGMENT_SIZE] = 128 << 20;
  43   bmp->options[APP_OPTIONS_SEGMENT_SIZE] = 256 << 20;
  44   bmp->options[APP_OPTIONS_EVT_QUEUE_SIZE] = em->evt_q_size;
  45   if (em->appns_id)
  46     {
  47       bmp->namespace_id_len = vec_len (em->appns_id);
  48       clib_memcpy_fast (bmp->namespace_id, em->appns_id,
  49                         bmp->namespace_id_len);
  50       bmp->options[APP_OPTIONS_FLAGS] |= em->appns_flags;
  51       bmp->options[APP_OPTIONS_NAMESPACE_SECRET] = em->appns_secret;
  52     }
  53   vl_msg_api_send_shmem (em->vl_input_queue, (u8 *) & bmp);
  54 }
  55
  56 void
  57 echo_send_detach (echo_main_t * em)
  58 {
  59   vl_api_application_detach_t *bmp;
  60   bmp = vl_msg_api_alloc (sizeof (*bmp));
  61   clib_memset (bmp, 0, sizeof (*bmp));
  62
  63   bmp->_vl_msg_id = ntohs (VL_API_APPLICATION_DETACH);
  64   bmp->client_index = em->my_client_index;
  65   bmp->context = ntohl (0xfeedface);
  66
  67   vl_msg_api_send_shmem (em->vl_input_queue, (u8 *) & bmp);
  68 }
  69
  70 void
  71 echo_send_add_cert_key (echo_main_t * em)
  72 {
  73   u32 cert_len = test_srv_crt_rsa_len;
  74   u32 key_len = test_srv_key_rsa_len;
  75   vl_api_app_add_cert_key_pair_t *bmp;
  76
  77   bmp = vl_msg_api_alloc (sizeof (*bmp) + cert_len + key_len);
  78   clib_memset (bmp, 0, sizeof (*bmp) + cert_len + key_len);
  79
  80   bmp->_vl_msg_id = ntohs (VL_API_APP_ADD_CERT_KEY_PAIR);
  81   bmp->client_index = em->my_client_index;
  82   bmp->context = ntohl (0xfeedface);
  83   bmp->cert_len = clib_host_to_net_u16 (cert_len);
  84   bmp->certkey_len = clib_host_to_net_u16 (key_len + cert_len);
  85   clib_memcpy_fast (bmp->certkey, test_srv_crt_rsa, cert_len);
  86   clib_memcpy_fast (bmp->certkey + cert_len, test_srv_key_rsa, key_len);
  87
  88   vl_msg_api_send_shmem (em->vl_input_queue, (u8 *) & bmp);
  89 }
  90
  91 void
  92 echo_send_del_cert_key (echo_main_t * em)
  93 {
  94   vl_api_app_del_cert_key_pair_t *bmp;
  95   bmp = vl_msg_api_alloc (sizeof (*bmp));
  96   clib_memset (bmp, 0, sizeof (*bmp));
  97
  98   bmp->_vl_msg_id = ntohs (VL_API_APP_DEL_CERT_KEY_PAIR);
  99   bmp->client_index = em->my_client_index;
 100   bmp->context = ntohl (0xfeedface);
 101   bmp->index = clib_host_to_net_u32 (em->ckpair_index);
 102   vl_msg_api_send_shmem (em->vl_input_queue, (u8 *) & bmp);
 103 }
 104
 105 void
 106 echo_send_listen (echo_main_t * em, ip46_address_t * ip)
 107 {
 108   app_session_evt_t _app_evt, *app_evt = &_app_evt;
 109   session_listen_msg_t *mp;
 110   svm_msg_q_t *mq = em->ctrl_mq;
 111
 112   app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_LISTEN);
 113   mp = (session_listen_msg_t *) app_evt->evt->data;
 114   memset (mp, 0, sizeof (*mp));
 115   mp->client_index = em->my_client_index;
 116   mp->context = ntohl (0xfeedface);
 117   mp->wrk_index = 0;
 118   mp->is_ip4 = em->uri_elts.is_ip4;
 119   clib_memcpy_fast (&mp->ip, ip, sizeof (mp->ip));
 120   mp->port = em->uri_elts.port;
 121   mp->proto = em->uri_elts.transport_proto;
 122   mp->ckpair_index = em->ckpair_index;
 123   mp->crypto_engine = em->crypto_engine;
 124   app_send_ctrl_evt_to_vpp (mq, app_evt);
 125 }
 126
 127 void
 128 echo_send_unbind (echo_main_t * em, echo_session_t * s)
 129 {
 130   app_session_evt_t _app_evt, *app_evt = &_app_evt;
 131   session_unlisten_msg_t *mp;
 132   svm_msg_q_t *mq = em->ctrl_mq;
 133
 134   app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_UNLISTEN);
 135   mp = (session_unlisten_msg_t *) app_evt->evt->data;
 136   memset (mp, 0, sizeof (*mp));
 137   mp->client_index = em->my_client_index;
 138   mp->wrk_index = 0;
 139   mp->handle = s->vpp_session_handle;
 140   mp->context = 0;
 141   app_send_ctrl_evt_to_vpp (mq, app_evt);
 142 }
 143
 144 void
 145 echo_send_connect (echo_main_t * em, void *args)
 146 {
 147   app_session_evt_t _app_evt, *app_evt = &_app_evt;
 148   session_connect_msg_t *mp;
 149   echo_connect_args_t *a = (echo_connect_args_t *) args;
 150   svm_msg_q_t *mq = em->ctrl_mq;
 151
 152   clib_atomic_sub_fetch (&em->max_sim_connects, 1);
 153   while (em->max_sim_connects <= 0)
 154     ;
 155
 156   app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_CONNECT);
 157   mp = (session_connect_msg_t *) app_evt->evt->data;
 158   memset (mp, 0, sizeof (*mp));
 159   mp->client_index = em->my_client_index;
 160   mp->context = ntohl (a->context);
 161   mp->wrk_index = 0;
 162   mp->is_ip4 = em->uri_elts.is_ip4;
 163   clib_memcpy_fast (&mp->ip, &a->ip, sizeof (mp->ip));
 164   clib_memcpy_fast (&mp->lcl_ip, &a->lcl_ip, sizeof (mp->ip));
 165   mp->port = em->uri_elts.port;
 166   mp->proto = em->uri_elts.transport_proto;
 167   mp->parent_handle = a->parent_session_handle;
 168   mp->ckpair_index = em->ckpair_index;
 169   mp->crypto_engine = em->crypto_engine;
 170   app_send_ctrl_evt_to_vpp (mq, app_evt);
 171 }
 172
 173 void
 174 echo_send_disconnect_session (echo_main_t * em, void *args)
 175 {
 176   echo_session_t *s;
 177   app_session_evt_t _app_evt, *app_evt = &_app_evt;
 178   session_disconnect_msg_t *mp;
 179   svm_msg_q_t *mq = em->ctrl_mq;
 180   echo_disconnect_args_t *a = (echo_disconnect_args_t *) args;
 181
 182   app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_DISCONNECT);
 183   mp = (session_disconnect_msg_t *) app_evt->evt->data;
 184   memset (mp, 0, sizeof (*mp));
 185   mp->client_index = em->my_client_index;
 186   mp->handle = a->session_handle;
 187   app_send_ctrl_evt_to_vpp (mq, app_evt);
 188
 189   if (!(s = echo_get_session_from_handle (em, mp->handle)))
 190     return;
 191   em->proto_cb_vft->sent_disconnect_cb (s);
 192 }
 193
 194 /*
 195  *
 196  *  Helpers
 197  *
 198  */
 199
 200 static int
 201 ssvm_segment_attach (char *name, ssvm_segment_type_t type, int fd)
 202 {
 203   fifo_segment_create_args_t _a, *a = &_a;
 204   fifo_segment_main_t *sm = &echo_main.segment_main;
 205   int rv;
 206
 207   clib_memset (a, 0, sizeof (*a));
 208   a->segment_name = (char *) name;
 209   a->segment_type = type;
 210
 211   if (type == SSVM_SEGMENT_MEMFD)
 212     a->memfd_fd = fd;
 213
 214   if ((rv = fifo_segment_attach (sm, a)))
 215     return rv;
 216   vec_reset_length (a->new_segment_indices);
 217   return 0;
 218 }
 219
 220 static inline void
 221 echo_segment_handle_add_del (echo_main_t * em, u64 segment_handle, u8 add)
 222 {
 223   clib_spinlock_lock (&em->segment_handles_lock);
 224   if (add)
 225     hash_set (em->shared_segment_handles, segment_handle, 1);
 226   else
 227     hash_unset (em->shared_segment_handles, segment_handle);
 228   clib_spinlock_unlock (&em->segment_handles_lock);
 229 }
 230
 231 /*
 232  *
 233  *  Binary API callbacks
 234  *
 235  */
 236
 237 static void
 238   vl_api_app_add_cert_key_pair_reply_t_handler
 239   (vl_api_app_add_cert_key_pair_reply_t * mp)
 240 {
 241   echo_main_t *em = &echo_main;
 242   if (mp->retval)
 243     {
 244       ECHO_FAIL (ECHO_FAIL_VL_API_CERT_KEY_ADD_REPLY,
 245                  "Adding cert and key returned %d",
 246                  clib_net_to_host_u32 (mp->retval));
 247       return;
 248     }
 249   /* No concurrency here, only bapi thread writes */
 250   if (em->state != STATE_ATTACHED_NO_CERT)
 251     {
 252       ECHO_FAIL (ECHO_FAIL_VL_API_CERT_KEY_ADD_REPLY, "Wrong state");
 253       return;
 254     }
 255   em->ckpair_index = clib_net_to_host_u32 (mp->index);
 256   em->state = STATE_ATTACHED;
 257 }
 258
 259 static void
 260   vl_api_app_del_cert_key_pair_reply_t_handler
 261   (vl_api_app_del_cert_key_pair_reply_t * mp)
 262 {
 263   echo_main_t *em = &echo_main;
 264   if (mp->retval)
 265     {
 266       ECHO_FAIL (ECHO_FAIL_VL_API_CERT_KEY_DEL_REPLY,
 267                  "Delete cert and key returned %d",
 268                  clib_net_to_host_u32 (mp->retval));
 269       return;
 270     }
 271   em->state = STATE_CLEANED_CERT_KEY;
 272 }
 273
 274 static void
 275 vl_api_app_attach_reply_t_handler (vl_api_app_attach_reply_t * mp)
 276 {
 277   echo_main_t *em = &echo_main;
 278   int *fds = 0, i;
 279   u32 n_fds = 0;
 280   u64 segment_handle;
 281   segment_handle = clib_net_to_host_u64 (mp->segment_handle);
 282   ECHO_LOG (2, "Attached returned app %u", htons (mp->app_index));
 283
 284   if (mp->retval)
 285     {
 286       ECHO_FAIL (ECHO_FAIL_VL_API_APP_ATTACH, "attach failed: %U",
 287                  format_api_error, clib_net_to_host_u32 (mp->retval));
 288       return;
 289     }
 290
 291   if (mp->segment_name_length == 0)
 292     {
 293       ECHO_FAIL (ECHO_FAIL_VL_API_MISSING_SEGMENT_NAME,
 294                  "segment_name_length zero");
 295       return;
 296     }
 297
 298   if (!mp->app_mq)
 299     {
 300       ECHO_FAIL (ECHO_FAIL_VL_API_NULL_APP_MQ, "NULL app_mq");
 301       return;
 302     }
 303   em->app_mq = uword_to_pointer (mp->app_mq, svm_msg_q_t *);
 304   em->ctrl_mq = uword_to_pointer (mp->vpp_ctrl_mq, svm_msg_q_t *);
 305
 306   if (mp->n_fds)
 307     {
 308       vec_validate (fds, mp->n_fds);
 309       if (vl_socket_client_recv_fd_msg (fds, mp->n_fds, 5))
 310         {
 311           ECHO_FAIL (ECHO_FAIL_VL_API_RECV_FD_MSG,
 312                      "vl_socket_client_recv_fd_msg failed");
 313           goto failed;
 314         }
 315
 316       if (mp->fd_flags & SESSION_FD_F_VPP_MQ_SEGMENT)
 317         if (ssvm_segment_attach (0, SSVM_SEGMENT_MEMFD, fds[n_fds++]))
 318           {
 319             ECHO_FAIL (ECHO_FAIL_VL_API_SVM_FIFO_SEG_ATTACH,
 320                        "svm_fifo_segment_attach failed on SSVM_SEGMENT_MEMFD");
 321             goto failed;
 322           }
 323
 324       if (mp->fd_flags & SESSION_FD_F_MEMFD_SEGMENT)
 325         if (ssvm_segment_attach ((char *) mp->segment_name,
 326                                  SSVM_SEGMENT_MEMFD, fds[n_fds++]))
 327           {
 328             ECHO_FAIL (ECHO_FAIL_VL_API_SVM_FIFO_SEG_ATTACH,
 329                        "svm_fifo_segment_attach ('%s') "
 330                        "failed on SSVM_SEGMENT_MEMFD", mp->segment_name);
 331             goto failed;
 332           }
 333       if (mp->fd_flags & SESSION_FD_F_MQ_EVENTFD)
 334         svm_msg_q_set_consumer_eventfd (em->app_mq, fds[n_fds++]);
 335
 336       vec_free (fds);
 337     }
 338   else
 339     {
 340       if (ssvm_segment_attach ((char *) mp->segment_name, SSVM_SEGMENT_SHM,
 341                                -1))
 342         {
 343           ECHO_FAIL (ECHO_FAIL_VL_API_SVM_FIFO_SEG_ATTACH,
 344                      "svm_fifo_segment_attach ('%s') "
 345                      "failed on SSVM_SEGMENT_SHM", mp->segment_name);
 346           return;
 347         }
 348     }
 349   echo_segment_handle_add_del (em, segment_handle, 1 /* add */ );
 350   ECHO_LOG (2, "Mapped segment 0x%lx", segment_handle);
 351
 352   em->state = STATE_ATTACHED_NO_CERT;
 353   return;
 354 failed:
 355   for (i = clib_max (n_fds - 1, 0); i < vec_len (fds); i++)
 356     close (fds[i]);
 357   vec_free (fds);
 358 }
 359
 360 static void
 361 vl_api_application_detach_reply_t_handler (vl_api_application_detach_reply_t *
 362                                            mp)
 363 {
 364   if (mp->retval)
 365     {
 366       ECHO_FAIL (ECHO_FAIL_VL_API_DETACH_REPLY,
 367                  "app detach returned with err: %d", mp->retval);
 368       return;
 369     }
 370   echo_main.state = STATE_DETACHED;
 371 }
 372
 373 static void
 374 vl_api_unmap_segment_t_handler (vl_api_unmap_segment_t * mp)
 375 {
 376   echo_main_t *em = &echo_main;
 377   u64 segment_handle = clib_net_to_host_u64 (mp->segment_handle);
 378   echo_segment_handle_add_del (em, segment_handle, 0 /* add */ );
 379   ECHO_LOG (2, "Unmaped segment 0x%lx", segment_handle);
 380 }
 381
 382 static void
 383 vl_api_map_another_segment_t_handler (vl_api_map_another_segment_t * mp)
 384 {
 385   fifo_segment_main_t *sm = &echo_main.segment_main;
 386   fifo_segment_create_args_t _a, *a = &_a;
 387   echo_main_t *em = &echo_main;
 388   int *fds = 0, i;
 389   char *seg_name = (char *) mp->segment_name;
 390   u64 segment_handle = clib_net_to_host_u64 (mp->segment_handle);
 391
 392   if (mp->fd_flags & SESSION_FD_F_MEMFD_SEGMENT)
 393     {
 394       vec_validate (fds, 1);
 395       if (vl_socket_client_recv_fd_msg (fds, 1, 5))
 396         {
 397           ECHO_FAIL (ECHO_FAIL_VL_API_RECV_FD_MSG,
 398                      "vl_socket_client_recv_fd_msg failed");
 399           goto failed;
 400         }
 401
 402       if (ssvm_segment_attach (seg_name, SSVM_SEGMENT_MEMFD, fds[0]))
 403         {
 404           ECHO_FAIL (ECHO_FAIL_VL_API_SVM_FIFO_SEG_ATTACH,
 405                      "svm_fifo_segment_attach ('%s') "
 406                      "failed on SSVM_SEGMENT_MEMFD", seg_name);
 407           goto failed;
 408         }
 409       vec_free (fds);
 410     }
 411   else
 412     {
 413       clib_memset (a, 0, sizeof (*a));
 414       a->segment_name = seg_name;
 415       a->segment_size = mp->segment_size;
 416       /* Attach to the segment vpp created */
 417       if (fifo_segment_attach (sm, a))
 418         {
 419           ECHO_FAIL (ECHO_FAIL_VL_API_FIFO_SEG_ATTACH,
 420                      "fifo_segment_attach ('%s') failed", seg_name);
 421           goto failed;
 422         }
 423     }
 424   echo_segment_handle_add_del (em, segment_handle, 1 /* add */ );
 425   ECHO_LOG (2, "Mapped segment 0x%lx", segment_handle);
 426   return;
 427
 428 failed:
 429   for (i = 0; i < vec_len (fds); i++)
 430     close (fds[i]);
 431   vec_free (fds);
 432 }
 433
 434 #define foreach_quic_echo_msg                                    \
 435 _(APP_ATTACH_REPLY, app_attach_reply)                            \
 436 _(APPLICATION_DETACH_REPLY, application_detach_reply)            \
 437 _(MAP_ANOTHER_SEGMENT, map_another_segment)                      \
 438 _(APP_ADD_CERT_KEY_PAIR_REPLY, app_add_cert_key_pair_reply)      \
 439 _(APP_DEL_CERT_KEY_PAIR_REPLY, app_del_cert_key_pair_reply)      \
 440 _(UNMAP_SEGMENT, unmap_segment)
 441
 442 void
 443 echo_api_hookup (echo_main_t * em)
 444 {
 445 #define _(N,n)                                                  \
 446     vl_msg_api_set_handlers(VL_API_##N, #n,                     \
 447                            vl_api_##n##_t_handler,              \
 448                            vl_noop_handler,                     \
 449                            vl_api_##n##_t_endian,               \
 450                            vl_api_##n##_t_print,                \
 451                            sizeof(vl_api_##n##_t), 1);
 452   foreach_quic_echo_msg;
 453 #undef _
 454 }
 455
 456 /*
 457  * fd.io coding-style-patch-verification: ON
 458  *
 459  * Local Variables:
 460  * eval: (c-set-style "gnu")
 461  * End:
 462  */