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:
7 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 #include "../pneum/pneum.h"
18 #include <vppinfra/hash.h>
20 static PyObject *pneum_callback = NULL;
23 wrap_pneum_callback (unsigned char * data, int len)
25 PyGILState_STATE gstate;
26 PyObject *result;//, *arglist;
28 gstate = PyGILState_Ensure();
30 /* Time to call the callback */
31 #if PY_VERSION_HEX >= 0x03000000
32 result = PyObject_CallFunction(pneum_callback, "y#", data, len);
34 result = PyObject_CallFunction(pneum_callback, "s#", data, len);
41 PyGILState_Release(gstate);
45 wrap_connect (PyObject *self, PyObject *args, PyObject *kw)
47 char * name, * chroot_prefix = NULL;
48 int rx_qlen = 32; /* default rx queue length */
50 PyObject * temp = NULL;
51 pneum_callback_t cb = NULL;
53 if (!PyArg_ParseTuple(args, "sOzi:wrap_connect",
54 &name, &temp, &chroot_prefix, &rx_qlen))
59 if (!PyCallable_Check(temp))
61 PyErr_SetString(PyExc_TypeError, "parameter must be callable");
65 Py_XINCREF(temp); /* Add a reference to new callback */
66 Py_XDECREF(pneum_callback); /* Dispose of previous callback */
67 pneum_callback = temp; /* Remember new callback */
68 cb = wrap_pneum_callback;
70 Py_BEGIN_ALLOW_THREADS
71 rv = pneum_connect(name, chroot_prefix, cb, rx_qlen);
73 return PyLong_FromLong(rv);
77 wrap_disconnect (PyObject *self, PyObject *args)
80 Py_BEGIN_ALLOW_THREADS
81 rv = pneum_disconnect();
83 return PyLong_FromLong(rv);
87 wrap_write (PyObject *self, PyObject *args)
92 if (!PyArg_ParseTuple(args, "s#", &data, &len))
95 Py_BEGIN_ALLOW_THREADS
96 rv = pneum_write(data, len);
99 return PyLong_FromLong(rv);
103 wrap_read (PyObject *self, PyObject *args)
107 unsigned short timeout;
109 if (!PyArg_ParseTuple(args, "H", &timeout))
111 Py_BEGIN_ALLOW_THREADS
112 rv = pneum_read(&data, &len, timeout);
115 if (rv != 0) { Py_RETURN_NONE; }
116 #if PY_VERSION_HEX >= 0x03000000
117 PyObject *ret = Py_BuildValue("y#", data, len);
119 PyObject *ret = Py_BuildValue("s#", data, len);
122 if (!ret) { Py_RETURN_NONE; }
128 wrap_msg_table (PyObject *self, PyObject *args)
132 uword *h = pneum_msg_table_get_hash();
133 PyObject *ret = PyList_New(pneum_msg_table_size());
134 if (!ret) goto error;
135 hash_foreach_pair (hp, h,
137 PyObject *item = PyTuple_New(2);
138 if (!item) goto error;
139 rv = PyTuple_SetItem(item, 0, PyLong_FromLong((u32)hp->value[0]));
141 rv = PyTuple_SetItem(item, 1, PyString_FromString((char *)hp->key));
143 PyList_SetItem(ret, i, item);
150 /* TODO: Raise exception */
151 printf("msg_table failed");
156 wrap_suspend (PyObject *self, PyObject *args)
158 Py_BEGIN_ALLOW_THREADS
165 wrap_resume (PyObject *self, PyObject *args)
167 Py_BEGIN_ALLOW_THREADS
173 static PyMethodDef vpp_api_Methods[] = {
174 {"connect", wrap_connect, METH_VARARGS, "Connect to the VPP API."},
175 {"disconnect", wrap_disconnect, METH_VARARGS, "Disconnect from the VPP API."},
176 {"write", wrap_write, METH_VARARGS, "Write data to the VPP API."},
177 {"read", wrap_read, METH_VARARGS, "Read data from the VPP API."},
178 {"msg_table", wrap_msg_table, METH_VARARGS, "Get API dictionary."},
179 {"suspend", wrap_suspend, METH_VARARGS, "Suspend RX thread."},
180 {"resume", wrap_resume, METH_VARARGS, "Resume RX thread."},
181 {NULL, NULL, 0, NULL} /* Sentinel */
184 #if PY_VERSION_HEX >= 0x03000000
186 PyInit_vpp_api (void)
192 #if PY_VERSION_HEX >= 0x03000000
193 static struct PyModuleDef vpp_api_module = {
194 #if PY_VERSION_HEX >= 0x03020000
195 PyModuleDef_HEAD_INIT,
198 PyObject_HEAD_INIT(NULL)
215 /* Ensure threading is initialised */
216 if (!PyEval_ThreadsInitialized()) {
217 PyEval_InitThreads();
220 #if PY_VERSION_HEX >= 0x03000000
221 return PyModule_Create(&vpp_api_module);
223 Py_InitModule((char *) "vpp_api", vpp_api_Methods);