vpp-api/python/vpp_papi/pneum_wrap.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
  16 #include <Python.h>
  17 #include "../pneum/pneum.h"
  18 #include <vppinfra/hash.h>
  19
  20 static PyObject *pneum_callback = NULL;
  21
  22 static void
  23 wrap_pneum_callback (unsigned char * data, int len)
  24 {
  25   PyGILState_STATE gstate;
  26   PyObject *result;//, *arglist;
  27
  28   gstate = PyGILState_Ensure();
  29
  30   /* Time to call the callback */
  31 #if PY_VERSION_HEX >= 0x03000000
  32   result = PyObject_CallFunction(pneum_callback, "y#", data, len);
  33 #else
  34   result = PyObject_CallFunction(pneum_callback, "s#", data, len);
  35 #endif
  36   if (result)
  37     Py_DECREF(result);
  38   else
  39     PyErr_Print();
  40
  41   PyGILState_Release(gstate);
  42 }
  43
  44 static PyObject *
  45 wrap_connect (PyObject *self, PyObject *args)
  46 {
  47   char * name, * chroot_prefix = NULL;
  48   int rv;
  49   PyObject * temp = NULL;
  50   pneum_callback_t cb = NULL;
  51
  52   if (!PyArg_ParseTuple(args, "s|Os:wrap_connect",
  53                         &name, &temp, &chroot_prefix))
  54     return (NULL);
  55
  56   if (temp)
  57     {
  58       if (!PyCallable_Check(temp))
  59         {
  60           PyErr_SetString(PyExc_TypeError, "parameter must be callable");
  61           return NULL;
  62         }
  63
  64       Py_XINCREF(temp);         /* Add a reference to new callback */
  65       Py_XDECREF(pneum_callback);  /* Dispose of previous callback */
  66       pneum_callback = temp;       /* Remember new callback */
  67       cb = wrap_pneum_callback;
  68     }
  69   Py_BEGIN_ALLOW_THREADS
  70     rv = pneum_connect(name, chroot_prefix, cb);
  71   Py_END_ALLOW_THREADS
  72   return PyLong_FromLong(rv);
  73 }
  74
  75 static PyObject *
  76 wrap_disconnect (PyObject *self, PyObject *args)
  77 {
  78   int rv;
  79   Py_BEGIN_ALLOW_THREADS
  80   rv = pneum_disconnect();
  81   Py_END_ALLOW_THREADS
  82   return PyLong_FromLong(rv);
  83 }
  84 static PyObject *
  85 wrap_write (PyObject *self, PyObject *args)
  86 {
  87   char *data;
  88   int len, rv;
  89
  90   if (!PyArg_ParseTuple(args, "s#", &data, &len))
  91     return NULL;
  92   Py_BEGIN_ALLOW_THREADS
  93   rv = pneum_write(data, len);
  94   Py_END_ALLOW_THREADS
  95
  96   return PyLong_FromLong(rv);
  97 }
  98
  99 static PyObject *
 100 wrap_read (PyObject *self, PyObject *args)
 101 {
 102   char *data;
 103   int len, rv;
 104
 105   Py_BEGIN_ALLOW_THREADS
 106   rv = pneum_read(&data, &len);
 107   Py_END_ALLOW_THREADS
 108
 109   if (rv != 0) { Py_RETURN_NONE; }
 110 #if PY_VERSION_HEX >= 0x03000000
 111   PyObject *ret = Py_BuildValue("y#", data, len);
 112 #else
 113   PyObject *ret = Py_BuildValue("s#", data, len);
 114 #endif
 115   if (!ret) { Py_RETURN_NONE; }
 116
 117   pneum_free(data);
 118   return ret;
 119 }
 120
 121 static PyObject *
 122 wrap_msg_table (PyObject *self, PyObject *args)
 123 {
 124   int i = 0, rv = 0;
 125   hash_pair_t *hp;
 126   uword *h = pneum_msg_table_get_hash();
 127   PyObject *ret = PyList_New(pneum_msg_table_size());
 128   if (!ret) goto error;
 129   hash_foreach_pair (hp, h,
 130   ({
 131     PyObject *item = PyTuple_New(2);
 132     if (!item) goto error;
 133     rv = PyTuple_SetItem(item, 0, PyLong_FromLong((u32)hp->value[0]));
 134     if (rv) goto error;
 135     rv = PyTuple_SetItem(item, 1, PyString_FromString((char *)hp->key));
 136     if (rv) goto error;
 137     PyList_SetItem(ret, i, item);
 138     i++;
 139   }));
 140
 141   return ret;
 142
 143  error:
 144   /* TODO: Raise exception */
 145   printf("msg_table failed");
 146   Py_RETURN_NONE;
 147 }
 148
 149 static PyMethodDef vpp_api_Methods[] = {
 150   {"connect", wrap_connect, METH_VARARGS, "Connect to the VPP API."},
 151   {"disconnect", wrap_disconnect, METH_VARARGS, "Disconnect from the VPP API."},
 152   {"write", wrap_write, METH_VARARGS, "Write data to the VPP API."},
 153   {"read", wrap_read, METH_VARARGS, "Read data from the VPP API."},
 154   {"msg_table", wrap_msg_table, METH_VARARGS, "Get API dictionary."},
 155   {NULL, NULL, 0, NULL}        /* Sentinel */
 156 };
 157
 158 #if PY_VERSION_HEX >= 0x03000000
 159 PyMODINIT_FUNC
 160 PyInit_vpp_api (void)
 161 #else
 162 void
 163 initvpp_api (void)
 164 #endif
 165 {
 166 #if PY_VERSION_HEX >= 0x03000000
 167   static struct PyModuleDef vpp_api_module = {
 168 #if PY_VERSION_HEX >= 0x03020000
 169     PyModuleDef_HEAD_INIT,
 170 #else
 171     {
 172       PyObject_HEAD_INIT(NULL)
 173       NULL, /* m_init */
 174       0,    /* m_index */
 175       NULL, /* m_copy */
 176     },
 177 #endif
 178     (char *) "vpp_api",
 179     NULL,
 180     -1,
 181     vpp_api_Methods,
 182     NULL,
 183     NULL,
 184     NULL,
 185     NULL
 186   };
 187 #endif
 188
 189   /* Ensure threading is initialised */
 190   if (!PyEval_ThreadsInitialized()) {
 191     PyEval_InitThreads();
 192   }
 193
 194 #if PY_VERSION_HEX >= 0x03000000
 195   return PyModule_Create(&vpp_api_module);
 196 #else
 197   Py_InitModule((char *) "vpp_api", vpp_api_Methods);
 198   return;
 199 #endif
 200 }