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