Line data    Source code

       1             : /*
       2             :  * Copyright (c) 2020 Cisco and/or its affiliates.
       3             :  * Licensed under the Apache License, Version 2.0 (the "License");
       4             :  * you may not use this
       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 <vcl/vcl_private.h>
      17             : 
      18             : static int
      19           8 : vcl_api_connect_app_socket (vcl_worker_t * wrk)
      20             : {
      21           8 :   clib_socket_t *cs = &wrk->app_api_sock;
      22             :   clib_error_t *err;
      23           8 :   int rv = 0;
      24             : 
      25           8 :   cs->config = (char *) vcm->cfg.vpp_app_socket_api;
      26           8 :   cs->flags =
      27           8 :     CLIB_SOCKET_F_IS_CLIENT | CLIB_SOCKET_F_SEQPACKET | CLIB_SOCKET_F_BLOCKING;
      28             : 
      29           8 :   wrk->vcl_needs_real_epoll = 1;
      30             : 
      31           8 :   if ((err = clib_socket_init (cs)))
      32             :     {
      33             :       /* don't report the error to avoid flood of error messages during
      34             :        * reconnect */
      35           0 :       clib_error_free (err);
      36           0 :       rv = -1;
      37           0 :       goto done;
      38             :     }
      39             : 
      40           8 : done:
      41             : 
      42           8 :   wrk->vcl_needs_real_epoll = 0;
      43             : 
      44           8 :   return rv;
      45             : }
      46             : 
      47             : static int
      48           8 : vcl_api_attach_reply_handler (app_sapi_attach_reply_msg_t * mp, int *fds)
      49             : {
      50           8 :   vcl_worker_t *wrk = vcl_worker_get_current ();
      51           8 :   int i, rv, n_fds_used = 0;
      52             :   u64 segment_handle;
      53             :   u8 *segment_name;
      54             : 
      55           8 :   if (mp->retval)
      56             :     {
      57           0 :       VERR ("attach failed: %U", format_session_error, mp->retval);
      58           0 :       goto failed;
      59             :     }
      60             : 
      61           8 :   wrk->api_client_handle = mp->api_client_handle;
      62             :   /* reattaching via `vcl_api_retry_attach` wants wrk->vpp_wrk_index to be 0 */
      63           8 :   wrk->vpp_wrk_index = 0;
      64           8 :   segment_handle = mp->segment_handle;
      65           8 :   if (segment_handle == VCL_INVALID_SEGMENT_HANDLE)
      66             :     {
      67           0 :       VERR ("invalid segment handle");
      68           0 :       goto failed;
      69             :     }
      70             : 
      71           8 :   if (!mp->n_fds)
      72           0 :     goto failed;
      73             : 
      74           8 :   if (mp->fd_flags & SESSION_FD_F_VPP_MQ_SEGMENT)
      75           8 :     if (vcl_segment_attach (vcl_vpp_worker_segment_handle (0), "vpp-mq-seg",
      76           8 :                             SSVM_SEGMENT_MEMFD, fds[n_fds_used++]))
      77           0 :       goto failed;
      78             : 
      79           8 :   if (mp->fd_flags & SESSION_FD_F_MEMFD_SEGMENT)
      80             :     {
      81           8 :       segment_name = format (0, "memfd-%ld%c", segment_handle, 0);
      82           8 :       rv = vcl_segment_attach (segment_handle, (char *) segment_name,
      83           8 :                                SSVM_SEGMENT_MEMFD, fds[n_fds_used++]);
      84           8 :       vec_free (segment_name);
      85           8 :       if (rv != 0)
      86           0 :         goto failed;
      87             :     }
      88             : 
      89           8 :   vcl_segment_attach_mq (segment_handle, mp->app_mq, 0, &wrk->app_event_queue);
      90             : 
      91           8 :   if (mp->fd_flags & SESSION_FD_F_MQ_EVENTFD)
      92             :     {
      93           0 :       svm_msg_q_set_eventfd (wrk->app_event_queue, fds[n_fds_used++]);
      94           0 :       vcl_mq_epoll_add_evfd (wrk, wrk->app_event_queue);
      95             :     }
      96             : 
      97           8 :   vcl_segment_discover_mqs (vcl_vpp_worker_segment_handle (0),
      98           8 :                             fds + n_fds_used, mp->n_fds - n_fds_used);
      99           8 :   vcl_segment_attach_mq (vcl_vpp_worker_segment_handle (0), mp->vpp_ctrl_mq,
     100           8 :                          mp->vpp_ctrl_mq_thread, &wrk->ctrl_mq);
     101           8 :   vcm->ctrl_mq = wrk->ctrl_mq;
     102           8 :   vcm->app_index = mp->app_index;
     103             : 
     104           8 :   return 0;
     105             : 
     106           0 : failed:
     107             : 
     108           0 :   for (i = clib_max (n_fds_used - 1, 0); i < mp->n_fds; i++)
     109           0 :     close (fds[i]);
     110             : 
     111           0 :   return -1;
     112             : }
     113             : 
     114             : static int
     115           8 : vcl_api_send_attach (clib_socket_t * cs)
     116             : {
     117           8 :   app_sapi_msg_t msg = { 0 };
     118           8 :   app_sapi_attach_msg_t *mp = &msg.attach;
     119             :   u8 app_is_proxy, tls_engine;
     120             :   clib_error_t *err;
     121             : 
     122          16 :   app_is_proxy = (vcm->cfg.app_proxy_transport_tcp ||
     123           8 :                   vcm->cfg.app_proxy_transport_udp);
     124           8 :   tls_engine = CRYPTO_ENGINE_OPENSSL;
     125             : 
     126           8 :   clib_memcpy (&mp->name, vcm->app_name, vec_len (vcm->app_name));
     127           8 :   mp->options[APP_OPTIONS_FLAGS] =
     128           8 :     APP_OPTIONS_FLAGS_ACCEPT_REDIRECT | APP_OPTIONS_FLAGS_ADD_SEGMENT |
     129           8 :     (vcm->cfg.app_scope_local ? APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE : 0) |
     130           8 :     (vcm->cfg.app_scope_global ? APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE : 0) |
     131           8 :     (app_is_proxy ? APP_OPTIONS_FLAGS_IS_PROXY : 0) |
     132           8 :     (vcm->cfg.use_mq_eventfd ? APP_OPTIONS_FLAGS_EVT_MQ_USE_EVENTFD : 0) |
     133           8 :     (vcm->cfg.huge_page ? APP_OPTIONS_FLAGS_USE_HUGE_PAGE : 0) |
     134           8 :     (vcm->cfg.app_original_dst ? APP_OPTIONS_FLAGS_GET_ORIGINAL_DST : 0);
     135           8 :   mp->options[APP_OPTIONS_PROXY_TRANSPORT] =
     136          16 :     (u64) ((vcm->cfg.app_proxy_transport_tcp ? 1 << TRANSPORT_PROTO_TCP : 0) |
     137           8 :            (vcm->cfg.app_proxy_transport_udp ? 1 << TRANSPORT_PROTO_UDP : 0));
     138           8 :   mp->options[APP_OPTIONS_SEGMENT_SIZE] = vcm->cfg.segment_size;
     139           8 :   mp->options[APP_OPTIONS_ADD_SEGMENT_SIZE] = vcm->cfg.add_segment_size;
     140           8 :   mp->options[APP_OPTIONS_RX_FIFO_SIZE] = vcm->cfg.rx_fifo_size;
     141           8 :   mp->options[APP_OPTIONS_TX_FIFO_SIZE] = vcm->cfg.tx_fifo_size;
     142           8 :   mp->options[APP_OPTIONS_PREALLOC_FIFO_PAIRS] =
     143           8 :     vcm->cfg.preallocated_fifo_pairs;
     144           8 :   mp->options[APP_OPTIONS_EVT_QUEUE_SIZE] = vcm->cfg.event_queue_size;
     145           8 :   mp->options[APP_OPTIONS_TLS_ENGINE] = tls_engine;
     146             : 
     147           8 :   msg.type = APP_SAPI_MSG_TYPE_ATTACH;
     148           8 :   err = clib_socket_sendmsg (cs, &msg, sizeof (msg), 0, 0);
     149           8 :   if (err)
     150             :     {
     151           0 :       clib_error_report (err);
     152           0 :       return -1;
     153             :     }
     154             : 
     155           8 :   return 0;
     156             : }
     157             : 
     158             : int
     159           8 : vcl_sapi_attach (void)
     160             : {
     161           8 :   vcl_worker_t *wrk = vcl_worker_get_current ();
     162           8 :   app_sapi_msg_t _rmp, *rmp = &_rmp;
     163             :   clib_error_t *err;
     164             :   clib_socket_t *cs;
     165             :   int fds[32];
     166             : 
     167             :   /*
     168             :    * Init client socket and send attach
     169             :    */
     170           8 :   if (vcl_api_connect_app_socket (wrk))
     171           0 :     return -1;
     172             : 
     173           8 :   cs = &wrk->app_api_sock;
     174           8 :   if (vcl_api_send_attach (cs))
     175           0 :     return -1;
     176             : 
     177             :   /*
     178             :    * Wait for attach reply
     179             :    */
     180           8 :   err = clib_socket_recvmsg (cs, rmp, sizeof (*rmp), fds, ARRAY_LEN (fds));
     181           8 :   if (err)
     182             :     {
     183           0 :       clib_error_report (err);
     184           0 :       return -1;
     185             :     }
     186             : 
     187           8 :   if (rmp->type != APP_SAPI_MSG_TYPE_ATTACH_REPLY)
     188           0 :     return -1;
     189             : 
     190           8 :   return vcl_api_attach_reply_handler (&rmp->attach_reply, fds);
     191             : }
     192             : 
     193             : static int
     194           0 : vcl_api_add_del_worker_reply_handler (app_sapi_worker_add_del_reply_msg_t *
     195             :                                       mp, int *fds)
     196             : {
     197           0 :   int n_fds = 0, i, rv;
     198             :   u64 segment_handle;
     199             :   vcl_worker_t *wrk;
     200             : 
     201           0 :   if (mp->retval)
     202             :     {
     203           0 :       VDBG (0, "add/del worker failed: %U", format_session_error, mp->retval);
     204           0 :       goto failed;
     205             :     }
     206             : 
     207           0 :   if (!mp->is_add)
     208           0 :     goto failed;
     209             : 
     210           0 :   wrk = vcl_worker_get_current ();
     211           0 :   wrk->api_client_handle = mp->api_client_handle;
     212           0 :   wrk->vpp_wrk_index = mp->wrk_index;
     213           0 :   wrk->ctrl_mq = vcm->ctrl_mq;
     214             : 
     215           0 :   segment_handle = mp->segment_handle;
     216           0 :   if (segment_handle == VCL_INVALID_SEGMENT_HANDLE)
     217             :     {
     218           0 :       clib_warning ("invalid segment handle");
     219           0 :       goto failed;
     220             :     }
     221             : 
     222           0 :   if (!mp->n_fds)
     223           0 :     goto failed;
     224             : 
     225           0 :   if (mp->fd_flags & SESSION_FD_F_VPP_MQ_SEGMENT)
     226           0 :     if (vcl_segment_attach (vcl_vpp_worker_segment_handle (wrk->wrk_index),
     227             :                             "vpp-worker-seg", SSVM_SEGMENT_MEMFD,
     228           0 :                             fds[n_fds++]))
     229           0 :       goto failed;
     230             : 
     231           0 :   if (mp->fd_flags & SESSION_FD_F_MEMFD_SEGMENT)
     232             :     {
     233           0 :       u8 *segment_name = format (0, "memfd-%ld%c", segment_handle, 0);
     234           0 :       rv = vcl_segment_attach (segment_handle, (char *) segment_name,
     235           0 :                                SSVM_SEGMENT_MEMFD, fds[n_fds++]);
     236           0 :       vec_free (segment_name);
     237           0 :       if (rv != 0)
     238           0 :         goto failed;
     239             :     }
     240             : 
     241           0 :   vcl_segment_attach_mq (segment_handle, mp->app_event_queue_address, 0,
     242             :                          &wrk->app_event_queue);
     243             : 
     244           0 :   if (mp->fd_flags & SESSION_FD_F_MQ_EVENTFD)
     245             :     {
     246           0 :       svm_msg_q_set_eventfd (wrk->app_event_queue, fds[n_fds]);
     247           0 :       vcl_mq_epoll_add_evfd (wrk, wrk->app_event_queue);
     248           0 :       n_fds++;
     249             :     }
     250             : 
     251           0 :   VDBG (0, "worker %u vpp-worker %u added", wrk->wrk_index,
     252             :         wrk->vpp_wrk_index);
     253             : 
     254           0 :   return 0;
     255             : 
     256           0 : failed:
     257           0 :   for (i = clib_max (n_fds - 1, 0); i < mp->n_fds; i++)
     258           0 :     close (fds[i]);
     259             : 
     260           0 :   return -1;
     261             : }
     262             : 
     263             : int
     264           0 : vcl_sapi_app_worker_add (void)
     265             : {
     266           0 :   vcl_worker_t *wrk = vcl_worker_get_current ();
     267             :   app_sapi_worker_add_del_msg_t *mp;
     268           0 :   app_sapi_msg_t _rmp, *rmp = &_rmp;
     269           0 :   app_sapi_msg_t msg = { 0 };
     270             :   int fds[SESSION_N_FD_TYPE];
     271             :   clib_error_t *err;
     272             :   clib_socket_t *cs;
     273             : 
     274             :   /* Connect to socket api */
     275           0 :   if (vcl_api_connect_app_socket (wrk))
     276           0 :     return -1;
     277             : 
     278             :   /*
     279             :    * Send add worker
     280             :    */
     281           0 :   cs = &wrk->app_api_sock;
     282             : 
     283           0 :   msg.type = APP_SAPI_MSG_TYPE_ADD_DEL_WORKER;
     284           0 :   mp = &msg.worker_add_del;
     285           0 :   mp->app_index = vcm->app_index;
     286           0 :   mp->is_add = 1;
     287             : 
     288           0 :   err = clib_socket_sendmsg (cs, &msg, sizeof (msg), 0, 0);
     289           0 :   if (err)
     290             :     {
     291           0 :       clib_error_report (err);
     292           0 :       return -1;
     293             :     }
     294             : 
     295             :   /*
     296             :    * Wait for reply and process it
     297             :    */
     298           0 :   err = clib_socket_recvmsg (cs, rmp, sizeof (*rmp), fds, ARRAY_LEN (fds));
     299           0 :   if (err)
     300             :     {
     301           0 :       clib_error_report (err);
     302           0 :       return -1;
     303             :     }
     304             : 
     305           0 :   if (rmp->type != APP_SAPI_MSG_TYPE_ADD_DEL_WORKER_REPLY)
     306             :     {
     307           0 :       clib_warning ("unexpected reply type %u", rmp->type);
     308           0 :       return -1;
     309             :     }
     310             : 
     311           0 :   return vcl_api_add_del_worker_reply_handler (&rmp->worker_add_del_reply,
     312             :                                                fds);
     313             : }
     314             : 
     315             : void
     316           2 : vcl_sapi_app_worker_del (vcl_worker_t * wrk)
     317             : {
     318             :   app_sapi_worker_add_del_msg_t *mp;
     319           2 :   app_sapi_msg_t msg = { 0 };
     320             :   clib_error_t *err;
     321             :   clib_socket_t *cs;
     322             : 
     323           2 :   cs = &wrk->app_api_sock;
     324             : 
     325           2 :   msg.type = APP_SAPI_MSG_TYPE_ADD_DEL_WORKER;
     326           2 :   mp = &msg.worker_add_del;
     327           2 :   mp->app_index = vcm->app_index;
     328           2 :   mp->wrk_index = wrk->vpp_wrk_index;
     329           2 :   mp->is_add = 0;
     330             : 
     331           2 :   err = clib_socket_sendmsg (cs, &msg, sizeof (msg), 0, 0);
     332           2 :   if (err)
     333           0 :     clib_error_report (err);
     334           2 :   clib_socket_close (cs);
     335           2 : }
     336             : 
     337             : void
     338           6 : vcl_sapi_detach (vcl_worker_t * wrk)
     339             : {
     340           6 :   clib_socket_t *cs = &wrk->app_api_sock;
     341           6 :   clib_socket_close (cs);
     342           6 : }
     343             : 
     344             : int
     345           7 : vcl_sapi_recv_fds (vcl_worker_t * wrk, int *fds, int n_fds)
     346             : {
     347           7 :   app_sapi_msg_t _msg, *msg = &_msg;
     348             :   clib_socket_t *cs;
     349             :   clib_error_t *err;
     350             : 
     351           7 :   cs = &wrk->app_api_sock;
     352             : 
     353           7 :   err = clib_socket_recvmsg (cs, msg, sizeof (*msg), fds, n_fds);
     354           7 :   if (err)
     355             :     {
     356           0 :       clib_error_report (err);
     357           0 :       return -1;
     358             :     }
     359           7 :   if (msg->type != APP_SAPI_MSG_TYPE_SEND_FDS)
     360           0 :     return -1;
     361             : 
     362           7 :   return 0;
     363             : }
     364             : 
     365             : int
     366           4 : vcl_sapi_add_cert_key_pair (vppcom_cert_key_pair_t *ckpair)
     367             : {
     368           4 :   u32 cert_len = ckpair->cert_len, key_len = ckpair->key_len, certkey_len;
     369           4 :   vcl_worker_t *wrk = vcl_worker_get_current ();
     370           4 :   app_sapi_msg_t _msg = { 0 }, *msg = &_msg;
     371             :   app_sapi_cert_key_add_del_msg_t *mp;
     372           4 :   app_sapi_msg_t _rmp, *rmp = &_rmp;
     373             :   clib_error_t *err;
     374             :   clib_socket_t *cs;
     375           4 :   u8 *certkey = 0;
     376           4 :   int rv = -1;
     377             : 
     378           4 :   msg->type = APP_SAPI_MSG_TYPE_ADD_DEL_CERT_KEY;
     379           4 :   mp = &msg->cert_key_add_del;
     380           4 :   mp->context = wrk->wrk_index;
     381           4 :   mp->cert_len = cert_len;
     382           4 :   mp->certkey_len = cert_len + key_len;
     383           4 :   mp->is_add = 1;
     384             : 
     385           4 :   certkey_len = cert_len + key_len;
     386           4 :   vec_validate (certkey, certkey_len - 1);
     387           4 :   clib_memcpy_fast (certkey, ckpair->cert, cert_len);
     388           4 :   clib_memcpy_fast (certkey + cert_len, ckpair->key, key_len);
     389             : 
     390           4 :   cs = &wrk->app_api_sock;
     391           4 :   err = clib_socket_sendmsg (cs, msg, sizeof (*msg), 0, 0);
     392           4 :   if (err)
     393             :     {
     394           0 :       clib_error_report (err);
     395           0 :       goto done;
     396             :     }
     397             : 
     398           4 :   err = clib_socket_sendmsg (cs, certkey, certkey_len, 0, 0);
     399           4 :   if (err)
     400             :     {
     401           0 :       clib_error_report (err);
     402           0 :       goto done;
     403             :     }
     404             : 
     405             :   /*
     406             :    * Wait for reply and process it
     407             :    */
     408           4 :   err = clib_socket_recvmsg (cs, rmp, sizeof (*rmp), 0, 0);
     409           4 :   if (err)
     410             :     {
     411           0 :       clib_error_report (err);
     412           0 :       goto done;
     413             :     }
     414             : 
     415           4 :   if (rmp->type != APP_SAPI_MSG_TYPE_ADD_DEL_CERT_KEY_REPLY)
     416             :     {
     417           0 :       clib_warning ("unexpected reply type %u", rmp->type);
     418           0 :       goto done;
     419             :     }
     420             : 
     421           4 :   if (!rmp->cert_key_add_del_reply.retval)
     422           4 :     rv = rmp->cert_key_add_del_reply.index;
     423             : 
     424           0 : done:
     425             : 
     426           4 :   return rv;
     427             : }
     428             : 
     429             : int
     430           0 : vcl_sapi_del_cert_key_pair (u32 ckpair_index)
     431             : {
     432           0 :   vcl_worker_t *wrk = vcl_worker_get_current ();
     433           0 :   app_sapi_msg_t _msg = { 0 }, *msg = &_msg;
     434             :   app_sapi_cert_key_add_del_msg_t *mp;
     435           0 :   app_sapi_msg_t _rmp, *rmp = &_rmp;
     436             :   clib_error_t *err;
     437             :   clib_socket_t *cs;
     438             : 
     439           0 :   msg->type = APP_SAPI_MSG_TYPE_ADD_DEL_CERT_KEY;
     440           0 :   mp = &msg->cert_key_add_del;
     441           0 :   mp->context = wrk->wrk_index;
     442           0 :   mp->index = ckpair_index;
     443             : 
     444           0 :   cs = &wrk->app_api_sock;
     445           0 :   err = clib_socket_sendmsg (cs, msg, sizeof (*msg), 0, 0);
     446           0 :   if (err)
     447             :     {
     448           0 :       clib_error_report (err);
     449           0 :       return -1;
     450             :     }
     451             : 
     452             :   /*
     453             :    * Wait for reply and process it
     454             :    */
     455           0 :   err = clib_socket_recvmsg (cs, rmp, sizeof (*rmp), 0, 0);
     456           0 :   if (err)
     457             :     {
     458           0 :       clib_error_report (err);
     459           0 :       return -1;
     460             :     }
     461             : 
     462           0 :   if (rmp->type != APP_SAPI_MSG_TYPE_ADD_DEL_CERT_KEY_REPLY)
     463             :     {
     464           0 :       clib_warning ("unexpected reply type %u", rmp->type);
     465           0 :       return -1;
     466             :     }
     467             : 
     468           0 :   if (rmp->cert_key_add_del_reply.retval)
     469           0 :     return -1;
     470             : 
     471           0 :   return 0;
     472             : }
     473             : 
     474             : /*
     475             :  * fd.io coding-style-patch-verification: ON
     476             :  *
     477             :  * Local Variables:
     478             :  * eval: (c-set-style "gnu")
     479             :  * End:
     480             :  */