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   mp->flags = em->connect_flag;
 171   app_send_ctrl_evt_to_vpp (mq, app_evt);
 172 }
 173
 174 void
 175 echo_send_disconnect_session (echo_main_t * em, void *args)
 176 {
 177   echo_session_t *s;
 178   app_session_evt_t _app_evt, *app_evt = &_app_evt;
 179   session_disconnect_msg_t *mp;
 180   svm_msg_q_t *mq = em->ctrl_mq;
 181   echo_disconnect_args_t *a = (echo_disconnect_args_t *) args;
 182
 183   app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_DISCONNECT);
 184   mp = (session_disconnect_msg_t *) app_evt->evt->data;
 185   memset (mp, 0, sizeof (*mp));
 186   mp->client_index = em->my_client_index;
 187   mp->handle = a->session_handle;
 188   app_send_ctrl_evt_to_vpp (mq, app_evt);
 189
 190   if (!(s = echo_get_session_from_handle (em, mp->handle)))
 191     return;
 192   em->proto_cb_vft->sent_disconnect_cb (s);
 193 }
 194
 195 /*
 196  *
 197  *  Helpers
 198  *
 199  */
 200
 201 static int
 202 ssvm_segment_attach (char *name, ssvm_segment_type_t type, int fd)
 203 {
 204   fifo_segment_create_args_t _a, *a = &_a;
 205   fifo_segment_main_t *sm = &echo_main.segment_main;
 206   int rv;
 207
 208   clib_memset (a, 0, sizeof (*a));
 209   a->segment_name = (char *) name;
 210   a->segment_type = type;
 211
 212   if (type == SSVM_SEGMENT_MEMFD)
 213     a->memfd_fd = fd;
 214
 215   if ((rv = fifo_segment_attach (sm, a)))
 216     return rv;
 217   vec_reset_length (a->new_segment_indices);
 218   return 0;
 219 }
 220
 221 static inline void
 222 echo_segment_handle_add_del (echo_main_t * em, u64 segment_handle, u8 add)
 223 {
 224   clib_spinlock_lock (&em->segment_handles_lock);
 225   if (add)
 226     hash_set (em->shared_segment_handles, segment_handle, 1);
 227   else
 228     hash_unset (em->shared_segment_handles, segment_handle);
 229   clib_spinlock_unlock (&em->segment_handles_lock);
 230 }
 231
 232 /*
 233  *
 234  *  Binary API callbacks
 235  *
 236  */
 237
 238 static void
 239   vl_api_app_add_cert_key_pair_reply_t_handler
 240   (vl_api_app_add_cert_key_pair_reply_t * mp)
 241 {
 242   echo_main_t *em = &echo_main;
 243   if (mp->retval)
 244     {
 245       ECHO_FAIL (ECHO_FAIL_VL_API_CERT_KEY_ADD_REPLY,
 246                  "Adding cert and key returned %d",
 247                  clib_net_to_host_u32 (mp->retval));
 248       return;
 249     }
 250   /* No concurrency here, only bapi thread writes */
 251   if (em->state != STATE_ATTACHED_NO_CERT)
 252     {
 253       ECHO_FAIL (ECHO_FAIL_VL_API_CERT_KEY_ADD_REPLY, "Wrong state");
 254       return;
 255     }
 256   em->ckpair_index = clib_net_to_host_u32 (mp->index);
 257   em->state = STATE_ATTACHED;
 258 }
 259
 260 static void
 261   vl_api_app_del_cert_key_pair_reply_t_handler
 262   (vl_api_app_del_cert_key_pair_reply_t * mp)
 263 {
 264   echo_main_t *em = &echo_main;
 265   if (mp->retval)
 266     {
 267       ECHO_FAIL (ECHO_FAIL_VL_API_CERT_KEY_DEL_REPLY,
 268                  "Delete cert and key returned %d",
 269                  clib_net_to_host_u32 (mp->retval));
 270       return;
 271     }
 272   em->state = STATE_CLEANED_CERT_KEY;
 273 }
 274
 275 static void
 276 vl_api_app_attach_reply_t_handler (vl_api_app_attach_reply_t * mp)
 277 {
 278   echo_main_t *em = &echo_main;
 279   int *fds = 0, i;
 280   u32 n_fds = 0;
 281   u64 segment_handle;
 282   segment_handle = clib_net_to_host_u64 (mp->segment_handle);
 283   ECHO_LOG (2, "Attached returned app %u", htons (mp->app_index));
 284
 285   if (mp->retval)
 286     {
 287       ECHO_FAIL (ECHO_FAIL_VL_API_APP_ATTACH, "attach failed: %U",
 288                  format_api_error, clib_net_to_host_u32 (mp->retval));
 289       return;
 290     }
 291
 292   if (mp->segment_name_length == 0)
 293     {
 294       ECHO_FAIL (ECHO_FAIL_VL_API_MISSING_SEGMENT_NAME,
 295                  "segment_name_length zero");
 296       return;
 297     }
 298
 299   if (!mp->app_mq)
 300     {
 301       ECHO_FAIL (ECHO_FAIL_VL_API_NULL_APP_MQ, "NULL app_mq");
 302       return;
 303     }
 304   em->app_mq = uword_to_pointer (mp->app_mq, svm_msg_q_t *);
 305   em->ctrl_mq = uword_to_pointer (mp->vpp_ctrl_mq, svm_msg_q_t *);
 306
 307   if (mp->n_fds)
 308     {
 309       vec_validate (fds, mp->n_fds);
 310       if (vl_socket_client_recv_fd_msg (fds, mp->n_fds, 5))
 311         {
 312           ECHO_FAIL (ECHO_FAIL_VL_API_RECV_FD_MSG,
 313                      "vl_socket_client_recv_fd_msg failed");
 314           goto failed;
 315         }
 316
 317       if (mp->fd_flags & SESSION_FD_F_VPP_MQ_SEGMENT)
 318         if (ssvm_segment_attach (0, SSVM_SEGMENT_MEMFD, fds[n_fds++]))
 319           {
 320             ECHO_FAIL (ECHO_FAIL_VL_API_SVM_FIFO_SEG_ATTACH,
 321                        "svm_fifo_segment_attach failed on SSVM_SEGMENT_MEMFD");
 322             goto failed;
 323           }
 324
 325       if (mp->fd_flags & SESSION_FD_F_MEMFD_SEGMENT)
 326         if (ssvm_segment_attach ((char *) mp->segment_name,
 327                                  SSVM_SEGMENT_MEMFD, fds[n_fds++]))
 328           {
 329             ECHO_FAIL (ECHO_FAIL_VL_API_SVM_FIFO_SEG_ATTACH,
 330                        "svm_fifo_segment_attach ('%s') "
 331                        "failed on SSVM_SEGMENT_MEMFD", mp->segment_name);
 332             goto failed;
 333           }
 334       if (mp->fd_flags & SESSION_FD_F_MQ_EVENTFD)
 335         svm_msg_q_set_consumer_eventfd (em->app_mq, fds[n_fds++]);
 336
 337       vec_free (fds);
 338     }
 339   else
 340     {
 341       if (ssvm_segment_attach ((char *) mp->segment_name, SSVM_SEGMENT_SHM,
 342                                -1))
 343         {
 344           ECHO_FAIL (ECHO_FAIL_VL_API_SVM_FIFO_SEG_ATTACH,
 345                      "svm_fifo_segment_attach ('%s') "
 346                      "failed on SSVM_SEGMENT_SHM", mp->segment_name);
 347           return;
 348         }
 349     }
 350   echo_segment_handle_add_del (em, segment_handle, 1 /* add */ );
 351   ECHO_LOG (2, "Mapped segment 0x%lx", segment_handle);
 352
 353   em->state = STATE_ATTACHED_NO_CERT;
 354   return;
 355 failed:
 356   for (i = clib_max (n_fds - 1, 0); i < vec_len (fds); i++)
 357     close (fds[i]);
 358   vec_free (fds);
 359 }
 360
 361 static void
 362 vl_api_application_detach_reply_t_handler (vl_api_application_detach_reply_t *
 363                                            mp)
 364 {
 365   if (mp->retval)
 366     {
 367       ECHO_FAIL (ECHO_FAIL_VL_API_DETACH_REPLY,
 368                  "app detach returned with err: %d", mp->retval);
 369       return;
 370     }
 371   echo_main.state = STATE_DETACHED;
 372 }
 373
 374 static void
 375 vl_api_unmap_segment_t_handler (vl_api_unmap_segment_t * mp)
 376 {
 377   echo_main_t *em = &echo_main;
 378   u64 segment_handle = clib_net_to_host_u64 (mp->segment_handle);
 379   echo_segment_handle_add_del (em, segment_handle, 0 /* add */ );
 380   ECHO_LOG (2, "Unmaped segment 0x%lx", segment_handle);
 381 }
 382
 383 static void
 384 vl_api_map_another_segment_t_handler (vl_api_map_another_segment_t * mp)
 385 {
 386   fifo_segment_main_t *sm = &echo_main.segment_main;
 387   fifo_segment_create_args_t _a, *a = &_a;
 388   echo_main_t *em = &echo_main;
 389   int *fds = 0, i;
 390   char *seg_name = (char *) mp->segment_name;
 391   u64 segment_handle = clib_net_to_host_u64 (mp->segment_handle);
 392
 393   if (mp->fd_flags & SESSION_FD_F_MEMFD_SEGMENT)
 394     {
 395       vec_validate (fds, 1);
 396       if (vl_socket_client_recv_fd_msg (fds, 1, 5))
 397         {
 398           ECHO_FAIL (ECHO_FAIL_VL_API_RECV_FD_MSG,
 399                      "vl_socket_client_recv_fd_msg failed");
 400           goto failed;
 401         }
 402
 403       if (ssvm_segment_attach (seg_name, SSVM_SEGMENT_MEMFD, fds[0]))
 404         {
 405           ECHO_FAIL (ECHO_FAIL_VL_API_SVM_FIFO_SEG_ATTACH,
 406                      "svm_fifo_segment_attach ('%s') "
 407                      "failed on SSVM_SEGMENT_MEMFD", seg_name);
 408           goto failed;
 409         }
 410       vec_free (fds);
 411     }
 412   else
 413     {
 414       clib_memset (a, 0, sizeof (*a));
 415       a->segment_name = seg_name;
 416       a->segment_size = mp->segment_size;
 417       /* Attach to the segment vpp created */
 418       if (fifo_segment_attach (sm, a))
 419         {
 420           ECHO_FAIL (ECHO_FAIL_VL_API_FIFO_SEG_ATTACH,
 421                      "fifo_segment_attach ('%s') failed", seg_name);
 422           goto failed;
 423         }
 424     }
 425   echo_segment_handle_add_del (em, segment_handle, 1 /* add */ );
 426   ECHO_LOG (2, "Mapped segment 0x%lx", segment_handle);
 427   return;
 428
 429 failed:
 430   for (i = 0; i < vec_len (fds); i++)
 431     close (fds[i]);
 432   vec_free (fds);
 433 }
 434
 435 #define foreach_quic_echo_msg                                    \
 436 _(APP_ATTACH_REPLY, app_attach_reply)                            \
 437 _(APPLICATION_DETACH_REPLY, application_detach_reply)            \
 438 _(MAP_ANOTHER_SEGMENT, map_another_segment)                      \
 439 _(APP_ADD_CERT_KEY_PAIR_REPLY, app_add_cert_key_pair_reply)      \
 440 _(APP_DEL_CERT_KEY_PAIR_REPLY, app_del_cert_key_pair_reply)      \
 441 _(UNMAP_SEGMENT, unmap_segment)
 442
 443 void
 444 echo_api_hookup (echo_main_t * em)
 445 {
 446 #define _(N,n)                                                  \
 447     vl_msg_api_set_handlers(VL_API_##N, #n,                     \
 448                            vl_api_##n##_t_handler,              \
 449                            vl_noop_handler,                     \
 450                            vl_api_##n##_t_endian,               \
 451                            vl_api_##n##_t_print,                \
 452                            sizeof(vl_api_##n##_t), 1);
 453   foreach_quic_echo_msg;
 454 #undef _
 455 }
 456
 457 /*
 458  * fd.io coding-style-patch-verification: ON
 459  *
 460  * Local Variables:
 461  * eval: (c-set-style "gnu")
 462  * End:
 463  */