vpp-api/python/pneum/pneum.c

   1 /*
   2  * Copyright (c) 2016 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 #include <stdio.h>
  16 #include <stdlib.h>
  17 #include <stddef.h>
  18 #include <sys/types.h>
  19 #include <sys/socket.h>
  20 #include <sys/mman.h>
  21 #include <sys/stat.h>
  22 #include <netinet/in.h>
  23 #include <netdb.h>
  24 #include <signal.h>
  25 #include <setjmp.h>
  26 #include <stdbool.h>
  27
  28 #include <vnet/vnet.h>
  29 #include <vlib/vlib.h>
  30 #include <vlib/unix/unix.h>
  31 #include <vlibapi/api.h>
  32 #include <vlibmemory/api.h>
  33
  34 #include <api/vpe_msg_enum.h>
  35
  36 #include "pneum.h"
  37
  38 #define vl_typedefs             /* define message structures */
  39 #include <api/vpe_all_api_h.h>
  40 #undef vl_typedefs
  41
  42 #define vl_endianfun             /* define message structures */
  43 #include <api/vpe_all_api_h.h>
  44 #undef vl_endianfun
  45
  46 typedef struct {
  47   u8 rx_thread_jmpbuf_valid;
  48   u8 connected_to_vlib;
  49   jmp_buf rx_thread_jmpbuf;
  50   pthread_t rx_thread_handle;
  51 } pneum_main_t;
  52
  53 pneum_main_t pneum_main;
  54
  55 extern int wrap_pneum_callback(char *data, int len);
  56
  57 /*
  58  * Satisfy external references when -lvlib is not available.
  59  */
  60 void vlib_cli_output (struct vlib_main_t * vm, char * fmt, ...)
  61 {
  62   clib_warning ("vlib_cli_output callled...");
  63 }
  64
  65 #define vl_api_version(n,v) static u32 vpe_api_version = v;
  66 #include <api/vpe.api.h>
  67 #undef vl_api_version
  68 void
  69 vl_client_add_api_signatures (vl_api_memclnt_create_t *mp)
  70 {
  71   /*
  72    * Send the main API signature in slot 0. This bit of code must
  73    * match the checks in ../vpe/api/api.c: vl_msg_api_version_check().
  74    */
  75   mp->api_versions[0] = clib_host_to_net_u32 (vpe_api_version);
  76 }
  77
  78 static void
  79 pneum_api_handler (void *msg)
  80 {
  81   u16 id = ntohs(*((u16 *)msg));
  82
  83   if (id == VL_API_RX_THREAD_EXIT) {
  84     pneum_main_t *pm = &pneum_main;
  85     vl_msg_api_free(msg);
  86     longjmp(pm->rx_thread_jmpbuf, 1);
  87   }
  88   msgbuf_t *msgbuf = (msgbuf_t *)(((u8 *)msg) - offsetof(msgbuf_t, data));
  89   int l = ntohl(msgbuf->data_len);
  90   if (l == 0)
  91     clib_warning("Message ID %d has wrong length: %d\n", id, l);
  92
  93   /* Call Python callback */
  94   (void)wrap_pneum_callback(msg, l);
  95   vl_msg_api_free(msg);
  96 }
  97
  98 static void *
  99 pneum_rx_thread_fn (void *arg)
 100 {
 101   unix_shared_memory_queue_t *q;
 102   pneum_main_t *pm = &pneum_main;
 103   api_main_t *am = &api_main;
 104   uword msg;
 105
 106   q = am->vl_input_queue;
 107
 108   /* So we can make the rx thread terminate cleanly */
 109   if (setjmp(pm->rx_thread_jmpbuf) == 0) {
 110     pm->rx_thread_jmpbuf_valid = 1;
 111     while (1)
 112       while (!unix_shared_memory_queue_sub(q, (u8 *)&msg, 0))
 113         pneum_api_handler((void *)msg);
 114   }
 115   pthread_exit(0);
 116 }
 117
 118 int
 119 pneum_connect (char *name)
 120 {
 121   int rv = 0;
 122   pneum_main_t *pm = &pneum_main;
 123
 124   /*
 125    * Bail out now if we're not running as root
 126    */
 127   if (geteuid() != 0)
 128     return (-1);
 129
 130   if ((rv = vl_client_api_map("/vpe-api"))) {
 131     clib_warning ("vl_client_api map rv %d", rv);
 132     return rv;
 133   }
 134
 135   if (vl_client_connect(name, 0, 32) < 0) {
 136     vl_client_api_unmap();
 137     return (-1);
 138   }
 139
 140   /* Start the rx queue thread */
 141   rv = pthread_create(&pm->rx_thread_handle, NULL, pneum_rx_thread_fn, 0);
 142   if (rv) {
 143     clib_warning("pthread_create returned %d", rv);
 144     vl_client_api_unmap();
 145     return (-1);
 146   }
 147
 148   pm->connected_to_vlib = 1;
 149
 150   return (0);
 151 }
 152
 153 int
 154 pneum_disconnect (void)
 155 {
 156   api_main_t *am = &api_main;
 157   pneum_main_t *pm = &pneum_main;
 158
 159   fformat (stdout,"disconnecting from vpe \n");
 160
 161   if (pm->rx_thread_jmpbuf_valid) {
 162     vl_api_rx_thread_exit_t *ep;
 163     uword junk;
 164     ep = vl_msg_api_alloc (sizeof (*ep));
 165     ep->_vl_msg_id = ntohs(VL_API_RX_THREAD_EXIT);
 166     vl_msg_api_send_shmem(am->vl_input_queue, (u8 *)&ep);
 167     pthread_join(pm->rx_thread_handle, (void **) &junk);
 168   }
 169   if (pm->connected_to_vlib) {
 170     vl_client_disconnect();
 171     vl_client_api_unmap();
 172   }
 173   memset (pm, 0, sizeof (*pm));
 174
 175   return (0);
 176 }
 177
 178 int
 179 pneum_read (char **p, int *l)
 180 {
 181   unix_shared_memory_queue_t *q;
 182   api_main_t *am = &api_main;
 183   uword msg;
 184
 185   *l = 0;
 186
 187   if (am->our_pid == 0) return (-1);
 188
 189   q = am->vl_input_queue;
 190   int rv = unix_shared_memory_queue_sub(q, (u8 *)&msg, 0);
 191   if (rv == 0) {
 192     u16 msg_id = ntohs(*((u16 *)msg));
 193     msgbuf_t *msgbuf = (msgbuf_t *)(((u8 *)msg) - offsetof(msgbuf_t, data));
 194     *l = ntohl(msgbuf->data_len);
 195     if (*l == 0) {
 196       printf("Unregistered API message: %d\n", msg_id);
 197       return (-1);
 198     }
 199     *p = (char *)msg;
 200   } else {
 201     printf("Read failed with %d\n", rv);
 202   }
 203   return (rv);
 204 }
 205
 206 /*
 207  * XXX: Makes the assumption that client_index is the first member
 208  */
 209 typedef VL_API_PACKED(struct _vl_api_header {
 210   u16 _vl_msg_id;
 211   u32 client_index;
 212 }) vl_api_header_t;
 213
 214 static unsigned int
 215 pneum_client_index (void)
 216 {
 217   return (api_main.my_client_index);
 218 }
 219
 220 int
 221 pneum_write (char *p, int l)
 222 {
 223   int rv = -1;
 224   api_main_t *am = &api_main;
 225   vl_api_header_t *mp = vl_msg_api_alloc(l);
 226   unix_shared_memory_queue_t *q;
 227
 228   if (!mp) return (-1);
 229   memcpy(mp, p, l);
 230   mp->client_index = pneum_client_index();
 231   q = am->shmem_hdr->vl_input_queue;
 232   rv = unix_shared_memory_queue_add(q, (u8 *)&mp, 0);
 233   if (rv != 0) {
 234     printf("vpe_api_write fails: %d\n", rv);
 235     /* Clear message */
 236     vl_msg_api_free(mp);
 237   }
 238   return (rv);
 239 }