src/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 <vpp/api/vpe_msg_enum.h>
  35
  36 #include "pneum.h"
  37
  38 #define vl_typedefs             /* define message structures */
  39 #include <vpp/api/vpe_all_api_h.h>
  40 #undef vl_typedefs
  41
  42 #define vl_endianfun             /* define message structures */
  43 #include <vpp/api/vpe_all_api_h.h>
  44 #undef vl_endianfun
  45
  46 vlib_main_t vlib_global_main;
  47 vlib_main_t **vlib_mains;
  48
  49 typedef struct {
  50   u8 rx_thread_jmpbuf_valid;
  51   u8 connected_to_vlib;
  52   jmp_buf rx_thread_jmpbuf;
  53   pthread_t rx_thread_handle;
  54 } pneum_main_t;
  55
  56 pneum_main_t pneum_main;
  57
  58 pneum_callback_t pneum_callback;
  59
  60 /*
  61  * Satisfy external references when -lvlib is not available.
  62  */
  63 void vlib_cli_output (struct vlib_main_t * vm, char * fmt, ...)
  64 {
  65   clib_warning ("vlib_cli_output called...");
  66 }
  67
  68 void
  69 pneum_free (void * msg)
  70 {
  71   vl_msg_api_free (msg);
  72 }
  73
  74 static void
  75 pneum_api_handler (void *msg)
  76 {
  77   u16 id = ntohs(*((u16 *)msg));
  78   if (id == VL_API_RX_THREAD_EXIT) {
  79     pneum_main_t *pm = &pneum_main;
  80     vl_msg_api_free(msg);
  81     longjmp(pm->rx_thread_jmpbuf, 1);
  82   }
  83   msgbuf_t *msgbuf = (msgbuf_t *)(((u8 *)msg) - offsetof(msgbuf_t, data));
  84   int l = ntohl(msgbuf->data_len);
  85   if (l == 0)
  86     clib_warning("Message ID %d has wrong length: %d\n", id, l);
  87
  88   /* Call Python callback */
  89   ASSERT(pneum_callback);
  90   (pneum_callback)(msg, l);
  91   pneum_free(msg);
  92 }
  93
  94 static void *
  95 pneum_rx_thread_fn (void *arg)
  96 {
  97   unix_shared_memory_queue_t *q;
  98   pneum_main_t *pm = &pneum_main;
  99   api_main_t *am = &api_main;
 100   uword msg;
 101
 102   q = am->vl_input_queue;
 103
 104   /* So we can make the rx thread terminate cleanly */
 105   if (setjmp(pm->rx_thread_jmpbuf) == 0) {
 106     pm->rx_thread_jmpbuf_valid = 1;
 107     while (1)
 108       while (!unix_shared_memory_queue_sub(q, (u8 *)&msg, 0))
 109         pneum_api_handler((void *)msg);
 110   }
 111   pthread_exit(0);
 112 }
 113
 114 uword *
 115 pneum_msg_table_get_hash (void)
 116 {
 117   api_main_t *am = &api_main;
 118   return (am->msg_index_by_name_and_crc);
 119 }
 120
 121 int
 122 pneum_msg_table_size(void)
 123 {
 124   api_main_t *am = &api_main;
 125   return hash_elts(am->msg_index_by_name_and_crc);
 126 }
 127
 128 int
 129 pneum_connect (char * name, char * chroot_prefix, pneum_callback_t cb,
 130                int rx_qlen)
 131 {
 132   int rv = 0;
 133   pneum_main_t *pm = &pneum_main;
 134
 135   if (chroot_prefix != NULL)
 136     vl_set_memory_root_path (chroot_prefix);
 137
 138   if ((rv = vl_client_api_map("/vpe-api"))) {
 139     clib_warning ("vl_client_api map rv %d", rv);
 140     return rv;
 141   }
 142
 143   if (vl_client_connect(name, 0, rx_qlen) < 0) {
 144     vl_client_api_unmap();
 145     return (-1);
 146   }
 147
 148   if (cb) {
 149     /* Start the rx queue thread */
 150     rv = pthread_create(&pm->rx_thread_handle, NULL, pneum_rx_thread_fn, 0);
 151     if (rv) {
 152       clib_warning("pthread_create returned %d", rv);
 153       vl_client_api_unmap();
 154       return (-1);
 155     }
 156     pneum_callback = cb;
 157   }
 158
 159   pm->connected_to_vlib = 1;
 160
 161   return (0);
 162 }
 163
 164 int
 165 pneum_disconnect (void)
 166 {
 167   api_main_t *am = &api_main;
 168   pneum_main_t *pm = &pneum_main;
 169
 170   if (pm->rx_thread_jmpbuf_valid) {
 171     vl_api_rx_thread_exit_t *ep;
 172     uword junk;
 173     ep = vl_msg_api_alloc (sizeof (*ep));
 174     ep->_vl_msg_id = ntohs(VL_API_RX_THREAD_EXIT);
 175     vl_msg_api_send_shmem(am->vl_input_queue, (u8 *)&ep);
 176     pthread_join(pm->rx_thread_handle, (void **) &junk);
 177   }
 178   if (pm->connected_to_vlib) {
 179     vl_client_disconnect();
 180     vl_client_api_unmap();
 181     pneum_callback = 0;
 182   }
 183   memset (pm, 0, sizeof (*pm));
 184
 185   return (0);
 186 }
 187
 188 int
 189 pneum_read (char **p, int *l)
 190 {
 191   unix_shared_memory_queue_t *q;
 192   api_main_t *am = &api_main;
 193   pneum_main_t *pm = &pneum_main;
 194   uword msg;
 195
 196   if (!pm->connected_to_vlib) return -1;
 197
 198   *l = 0;
 199
 200   if (am->our_pid == 0) return (-1);
 201
 202   q = am->vl_input_queue;
 203   int rv = unix_shared_memory_queue_sub(q, (u8 *)&msg, 0);
 204   if (rv == 0) {
 205     u16 msg_id = ntohs(*((u16 *)msg));
 206     msgbuf_t *msgbuf = (msgbuf_t *)(((u8 *)msg) - offsetof(msgbuf_t, data));
 207     *l = ntohl(msgbuf->data_len);
 208     if (*l == 0) {
 209       printf("Unregistered API message: %d\n", msg_id);
 210       return (-1);
 211     }
 212     *p = (char *)msg;
 213   } else {
 214     printf("Read failed with %d\n", rv);
 215   }
 216   return (rv);
 217 }
 218
 219 /*
 220  * XXX: Makes the assumption that client_index is the first member
 221  */
 222 typedef VL_API_PACKED(struct _vl_api_header {
 223   u16 _vl_msg_id;
 224   u32 client_index;
 225 }) vl_api_header_t;
 226
 227 static unsigned int
 228 pneum_client_index (void)
 229 {
 230   return (api_main.my_client_index);
 231 }
 232
 233 int
 234 pneum_write (char *p, int l)
 235 {
 236   int rv = -1;
 237   api_main_t *am = &api_main;
 238   vl_api_header_t *mp = vl_msg_api_alloc(l);
 239   unix_shared_memory_queue_t *q;
 240   pneum_main_t *pm = &pneum_main;
 241
 242   if (!pm->connected_to_vlib) return -1;
 243   if (!mp) return (-1);
 244   memcpy(mp, p, l);
 245   mp->client_index = pneum_client_index();
 246   q = am->shmem_hdr->vl_input_queue;
 247   rv = unix_shared_memory_queue_add(q, (u8 *)&mp, 0);
 248   if (rv != 0) {
 249     printf("vpe_api_write fails: %d\n", rv);
 250     /* Clear message */
 251     pneum_free(mp);
 252   }
 253   return (rv);
 254 }
 255
 256 uint32_t
 257 pneum_get_msg_index (unsigned char * name)
 258 {
 259   return vl_api_get_msg_index (name);
 260 }