src/plugins/hs_apps/sapi/vpp_echo_sapi.c

   1 /*
   2  * Copyright (c) 2022 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 <hs_apps/sapi/vpp_echo_common.h>
  17
  18 int
  19 echo_api_connect_app_socket (echo_main_t *em)
  20 {
  21   clib_socket_t *cs = &em->app_api_sock;
  22   clib_error_t *err;
  23   int rv = 0;
  24
  25   cs->config = (char *) em->socket_name;
  26   cs->flags =
  27     CLIB_SOCKET_F_IS_CLIENT | CLIB_SOCKET_F_SEQPACKET | CLIB_SOCKET_F_BLOCKING;
  28
  29   if ((err = clib_socket_init (cs)))
  30     {
  31       clib_error_report (err);
  32       rv = -1;
  33     }
  34
  35   return rv;
  36 }
  37
  38 static inline u64
  39 echo_vpp_worker_segment_handle (u32 wrk_index)
  40 {
  41   return (ECHO_INVALID_SEGMENT_HANDLE - wrk_index - 1);
  42 }
  43
  44 static int
  45 echo_segment_discover_mqs (uword segment_handle, int *fds, u32 n_fds)
  46 {
  47   echo_main_t *em = &echo_main;
  48   fifo_segment_t *fs;
  49   u32 fs_index;
  50
  51   fs_index = echo_segment_lookup (segment_handle);
  52   if (fs_index == ECHO_INVALID_SEGMENT_INDEX)
  53     {
  54       ECHO_LOG (0, "ERROR: mq segment %lx for is not attached!",
  55                 segment_handle);
  56       return -1;
  57     }
  58
  59   clib_spinlock_lock (&em->segment_handles_lock);
  60
  61   fs = fifo_segment_get_segment (&em->segment_main, fs_index);
  62   fifo_segment_msg_qs_discover (fs, fds, n_fds);
  63
  64   clib_spinlock_unlock (&em->segment_handles_lock);
  65
  66   return 0;
  67 }
  68
  69 static int
  70 echo_api_attach_reply_handler (app_sapi_attach_reply_msg_t *mp, int *fds)
  71 {
  72   echo_main_t *em = &echo_main;
  73   int i, rv, n_fds_used = 0;
  74   u64 segment_handle;
  75   u8 *segment_name;
  76
  77   if (mp->retval)
  78     {
  79       ECHO_LOG (0, "attach failed: %U", format_session_error, mp->retval);
  80       goto failed;
  81     }
  82
  83   em->my_client_index = mp->api_client_handle;
  84   segment_handle = mp->segment_handle;
  85   if (segment_handle == ECHO_INVALID_SEGMENT_HANDLE)
  86     {
  87       ECHO_LOG (0, "invalid segment handle");
  88       goto failed;
  89     }
  90
  91   if (!mp->n_fds)
  92     goto failed;
  93
  94   if (mp->fd_flags & SESSION_FD_F_VPP_MQ_SEGMENT)
  95     if (echo_segment_attach (echo_vpp_worker_segment_handle (0), "vpp-mq-seg",
  96                              SSVM_SEGMENT_MEMFD, fds[n_fds_used++]))
  97       goto failed;
  98
  99   if (mp->fd_flags & SESSION_FD_F_MEMFD_SEGMENT)
 100     {
 101       segment_name = format (0, "memfd-%ld%c", segment_handle, 0);
 102       rv = echo_segment_attach (segment_handle, (char *) segment_name,
 103                                 SSVM_SEGMENT_MEMFD, fds[n_fds_used++]);
 104       vec_free (segment_name);
 105       if (rv != 0)
 106         goto failed;
 107     }
 108
 109   echo_segment_attach_mq (segment_handle, mp->app_mq, 0, &em->app_mq);
 110
 111   if (mp->fd_flags & SESSION_FD_F_MQ_EVENTFD)
 112     {
 113       ECHO_LOG (0, "SESSION_FD_F_MQ_EVENTFD unsupported!");
 114       goto failed;
 115     }
 116
 117   echo_segment_discover_mqs (echo_vpp_worker_segment_handle (0),
 118                              fds + n_fds_used, mp->n_fds - n_fds_used);
 119   echo_segment_attach_mq (echo_vpp_worker_segment_handle (0), mp->vpp_ctrl_mq,
 120                           mp->vpp_ctrl_mq_thread, &em->ctrl_mq);
 121
 122   em->state = STATE_ATTACHED_NO_CERT;
 123   return 0;
 124
 125 failed:
 126
 127   for (i = clib_max (n_fds_used - 1, 0); i < mp->n_fds; i++)
 128     close (fds[i]);
 129
 130   return -1;
 131 }
 132
 133 static int
 134 echo_api_send_attach (clib_socket_t *cs)
 135 {
 136   echo_main_t *em = &echo_main;
 137   app_sapi_msg_t msg = { 0 };
 138   app_sapi_attach_msg_t *mp = &msg.attach;
 139   clib_error_t *err;
 140
 141   clib_memcpy (&mp->name, em->app_name, vec_len (em->app_name));
 142   mp->options[APP_OPTIONS_FLAGS] =
 143     APP_OPTIONS_FLAGS_ACCEPT_REDIRECT | APP_OPTIONS_FLAGS_ADD_SEGMENT;
 144   mp->options[APP_OPTIONS_SEGMENT_SIZE] = 256 << 20;
 145   mp->options[APP_OPTIONS_ADD_SEGMENT_SIZE] = 128 << 20;
 146   mp->options[APP_OPTIONS_RX_FIFO_SIZE] = em->fifo_size;
 147   mp->options[APP_OPTIONS_TX_FIFO_SIZE] = em->fifo_size;
 148   mp->options[APP_OPTIONS_PREALLOC_FIFO_PAIRS] = em->prealloc_fifo_pairs;
 149   mp->options[APP_OPTIONS_EVT_QUEUE_SIZE] = em->evt_q_size;
 150
 151   msg.type = APP_SAPI_MSG_TYPE_ATTACH;
 152   err = clib_socket_sendmsg (cs, &msg, sizeof (msg), 0, 0);
 153   if (err)
 154     {
 155       clib_error_report (err);
 156       return -1;
 157     }
 158
 159   return 0;
 160 }
 161
 162 int
 163 echo_sapi_attach (echo_main_t *em)
 164 {
 165   app_sapi_msg_t _rmp, *rmp = &_rmp;
 166   clib_error_t *err;
 167   clib_socket_t *cs;
 168   int fds[32];
 169
 170   cs = &em->app_api_sock;
 171   if (echo_api_send_attach (cs))
 172     return -1;
 173
 174   /*
 175    * Wait for attach reply
 176    */
 177   err = clib_socket_recvmsg (cs, rmp, sizeof (*rmp), fds, ARRAY_LEN (fds));
 178   if (err)
 179     {
 180       clib_error_report (err);
 181       return -1;
 182     }
 183
 184   if (rmp->type != APP_SAPI_MSG_TYPE_ATTACH_REPLY)
 185     return -1;
 186
 187   return echo_api_attach_reply_handler (&rmp->attach_reply, fds);
 188 }
 189
 190 int
 191 echo_sapi_add_cert_key (echo_main_t *em)
 192 {
 193   u32 cert_len = test_srv_crt_rsa_len;
 194   u32 key_len = test_srv_key_rsa_len;
 195   u32 certkey_len = cert_len + key_len;
 196   app_sapi_msg_t _msg = { 0 }, *msg = &_msg;
 197   app_sapi_cert_key_add_del_msg_t *mp;
 198   app_sapi_msg_t _rmp, *rmp = &_rmp;
 199   clib_error_t *err;
 200   clib_socket_t *cs;
 201   u8 *certkey = 0;
 202   int rv = -1;
 203
 204   msg->type = APP_SAPI_MSG_TYPE_ADD_DEL_CERT_KEY;
 205   mp = &msg->cert_key_add_del;
 206   mp->context = ntohl (0xfeedface);
 207   mp->cert_len = cert_len;
 208   mp->certkey_len = certkey_len;
 209   mp->is_add = 1;
 210
 211   vec_validate (certkey, certkey_len - 1);
 212   clib_memcpy_fast (certkey, test_srv_crt_rsa, cert_len);
 213   clib_memcpy_fast (certkey + cert_len, test_srv_key_rsa, key_len);
 214
 215   cs = &em->app_api_sock;
 216   err = clib_socket_sendmsg (cs, msg, sizeof (*msg), 0, 0);
 217   if (err)
 218     {
 219       clib_error_report (err);
 220       goto done;
 221     }
 222
 223   err = clib_socket_sendmsg (cs, certkey, certkey_len, 0, 0);
 224   if (err)
 225     {
 226       clib_error_report (err);
 227       goto done;
 228     }
 229
 230   /*
 231    * Wait for reply and process it
 232    */
 233   err = clib_socket_recvmsg (cs, rmp, sizeof (*rmp), 0, 0);
 234   if (err)
 235     {
 236       clib_error_report (err);
 237       goto done;
 238     }
 239
 240   if (rmp->type != APP_SAPI_MSG_TYPE_ADD_DEL_CERT_KEY_REPLY)
 241     {
 242       ECHO_LOG (0, "unexpected reply type %u", rmp->type);
 243       goto done;
 244     }
 245
 246   if (!rmp->cert_key_add_del_reply.retval)
 247     rv = rmp->cert_key_add_del_reply.index;
 248
 249   em->state = STATE_ATTACHED;
 250   em->ckpair_index = rv;
 251
 252 done:
 253
 254   return rv;
 255 }
 256
 257 int
 258 echo_sapi_recv_fd (echo_main_t *em, int *fds, int n_fds)
 259 {
 260   app_sapi_msg_t _msg, *msg = &_msg;
 261   clib_error_t *err =
 262     clib_socket_recvmsg (&em->app_api_sock, msg, sizeof (*msg), fds, n_fds);
 263   if (err)
 264     {
 265       clib_error_report (err);
 266       return -1;
 267     }
 268   return 0;
 269 }
 270
 271 int
 272 echo_sapi_detach (echo_main_t *em)
 273 {
 274   clib_socket_t *cs = &em->app_api_sock;
 275   clib_socket_close (cs);
 276   em->state = STATE_DETACHED;
 277   return 0;
 278 }
 279
 280 int
 281 echo_sapi_del_cert_key (echo_main_t *em)
 282 {
 283   app_sapi_msg_t _msg = { 0 }, *msg = &_msg;
 284   app_sapi_cert_key_add_del_msg_t *mp;
 285   app_sapi_msg_t _rmp, *rmp = &_rmp;
 286   clib_error_t *err;
 287   clib_socket_t *cs;
 288
 289   msg->type = APP_SAPI_MSG_TYPE_ADD_DEL_CERT_KEY;
 290   mp = &msg->cert_key_add_del;
 291   mp->index = em->ckpair_index;
 292
 293   cs = &em->app_api_sock;
 294   err = clib_socket_sendmsg (cs, msg, sizeof (*msg), 0, 0);
 295   if (err)
 296     {
 297       clib_error_report (err);
 298       return -1;
 299     }
 300
 301   /*
 302    * Wait for reply and process it
 303    */
 304   err = clib_socket_recvmsg (cs, rmp, sizeof (*rmp), 0, 0);
 305   if (err)
 306     {
 307       clib_error_report (err);
 308       return -1;
 309     }
 310
 311   if (rmp->type != APP_SAPI_MSG_TYPE_ADD_DEL_CERT_KEY_REPLY)
 312     {
 313       ECHO_LOG (0, "unexpected reply type %u", rmp->type);
 314       return -1;
 315     }
 316
 317   if (rmp->cert_key_add_del_reply.retval)
 318     return -1;
 319
 320   em->state = STATE_CLEANED_CERT_KEY;
 321   return 0;
 322 }
 323
 324 /*
 325  * fd.io coding-style-patch-verification: ON
 326  *
 327  * Local Variables:
 328  * eval: (c-set-style "gnu")
 329  * End:
 330  */