diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000000000000000000000000000000000000..85477867ff7703065631f66e97a51ff62f794855
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,9 @@
+[submodule "libdap-server-core"]
+ path = libdap-server-core
+ url = https://gitlab.demlabs.net/cellframe/libdap-server-core.git
+[submodule "libdap"]
+ path = libdap
+ url = https://gitlab.demlabs.net/cellframe/libdap.git
+[submodule "libdap-crypto"]
+ path = libdap-crypto
+ url = https://gitlab.demlabs.net/cellframe/libdap-crypto.git
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..31c5bfe7166bf42669cf4f0dd706ff3c2107afe1
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,49 @@
+project(DapServerCore C)
+cmake_minimum_required(VERSION 2.8)
+
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_COLOR_MAKEFILE ON)
+set(CMAKE_C_STANDARD 11)
+set(SUBMODULES_NO_BUILD ON)
+
+add_subdirectory(libdap)
+add_subdirectory(libdap-crypto)
+add_subdirectory(libdap-server-core)
+
+file(GLOB SERVER_CORE_PYTHON_SRCS src/*.c)
+file(GLOB SERVER_CORE_PYTHON_HEADERS include/*.h)
+
+set(Python_ADDITIONAL_VERSIONS 3.7)
+find_package (PythonLibs REQUIRED)
+#find_package(PkgConfig)
+#pkg_check_modules(PC_JSON-C REQUIRED json-c)
+include_directories(${PYTHON_INCLUDE_DIR} include/)
+
+add_library(${PROJECT_NAME} SHARED ${SERVER_CORE_PYTHON_SRCS} ${SERVER_CORE_PYTHON_HEADERS})
+
+target_link_libraries(${PROJECT_NAME})
+
+target_compile_options(
+ dap_server_core PRIVATE
+ "-fpic"
+)
+
+target_compile_options(
+ dap_core PRIVATE
+ "-fpic"
+)
+target_compile_options(
+ dap_crypto PRIVATE
+ "-fpic"
+)
+
+
+#target_link_libraries(${PROJECT_NAME} dap_core dap_crypto)
+#targat_link_libraries(${PROJECT_NAME} dap_server_core)
+target_link_libraries(${PROJECT_NAME} dap_core dap_crypto dap_server_core)
+
+#if(BUILD_DAP_PYTHON_TESTS)
+# add_subdirectory(test)
+# enable_testing()
+#endif()
+
diff --git a/include/dap_events_python.h b/include/dap_events_python.h
new file mode 100644
index 0000000000000000000000000000000000000000..7f652fcc26dd894e78ee945ffc0faa56653cc327
--- /dev/null
+++ b/include/dap_events_python.h
@@ -0,0 +1,83 @@
+#pragma once
+
+#include "Python.h"
+#include "dap_events.h"
+#include "dap_events_socket_python.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct PyDapEvents{
+ PyObject_HEAD
+ dap_events_t *t_events;
+}PyDapEventsObject;
+
+void PyDapEventsObject_dealloc(PyDapEventsObject *eventsObject);
+
+PyObject *PyDapEventsObject_new(PyTypeObject *type_object, PyObject *args, PyObject *kwds);
+
+//PyObject *dap_events_new_py();
+//PyObject *dap_events_delete_py(PyObject *self, PyObject *args); //dap_events_t * sh );
+//void dap_events_socket_remove_and_delete( dap_events_socket_t* a_es );
+PyObject *dap_events_socket_remove_and_delete_py(PyDapEventsObject *self, PyObject *args); //dap_events_socket_t* a_es, bool preserve_inheritor );
+
+PyObject *dap_events_kill_socket_py(PyDapEventsObject *self, PyObject *args); //dap_events_socket_t *a_es );
+
+PyObject *dap_events_start_py(PyDapEventsObject *self); //dap_events_t *sh );
+PyObject *dap_events_wait_py(PyDapEventsObject *self); //dap_events_t *sh );
+
+static PyMethodDef PyDapEventsObject_methods[] = {
+ {"start", (PyCFunction)dap_events_start_py, METH_NOARGS, ""},
+ {"wait", (PyCFunction)dap_events_wait_py, METH_NOARGS, ""},
+ {"killSocket", (PyCFunction)dap_events_kill_socket_py, METH_VARARGS, ""},
+ {"removeAndDeleteSocket", (PyCFunction)dap_events_socket_remove_and_delete_py, METH_VARARGS, ""},
+ {NULL, NULL, 0, NULL} /* Sentinel */
+};
+
+static PyTypeObject dapEvents_dapEventsType = {
+ PyVarObject_HEAD_INIT(NULL, 0)
+ "libDapServerCore.DapEvents", /* tp_name */
+ sizeof(PyDapEventsObject), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ (destructor)PyDapEventsObject_dealloc,//(destructor)Noddy_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ 0, /* tp_reserved */
+ 0, /* tp_repr */
+ 0, /* tp_as_number */
+ 0, /* tp_as_sequence */
+ 0, /* tp_as_mapping */
+ 0, /* tp_hash */
+ 0, /* tp_call */
+ 0, /* tp_str */
+ 0, /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT |
+ Py_TPFLAGS_BASETYPE, /* tp_flags */
+ "DapEvents objects", /* tp_doc */
+ 0, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
+ PyDapEventsObject_methods,//Noddy_methods, /* tp_methods */
+ 0,//Noddy_members, /* tp_members */
+ 0,//Noddy_getseters, /* tp_getset */
+ 0, /* tp_base */
+ 0, /* tp_dict */
+ 0, /* tp_descr_get */
+ 0, /* tp_descr_set */
+ 0, /* tp_dictoffset */
+ 0,//(initproc)PyDapEventsObject_init,//(initproc)Noddy_init, /* tp_init */
+ 0, /* tp_alloc */
+ PyDapEventsObject_new,//Noddy_new, /* tp_new */
+};
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/include/dap_events_socket_python.h b/include/dap_events_socket_python.h
new file mode 100644
index 0000000000000000000000000000000000000000..9795e7e3ecfc91ada1213b1004df6cd09ca9574d
--- /dev/null
+++ b/include/dap_events_socket_python.h
@@ -0,0 +1,96 @@
+#pragma once
+
+#include "Python.h"
+#include "dap_events_socket.h"
+#include "dap_events_python.h"
+#include "dap_common.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct PyDapEventsSocket{
+ PyObject_HEAD
+ dap_events_socket_t *t_events_socket;
+}PyDapEventsSocketObject;
+
+PyObject *dap_events_socket_create_after_py(PyDapEventsSocketObject *self);//dap_events_socket_t * a_es);
+
+//PyObject *dap_events_socket_wrap_no_add_py(PyObject *self, PyObject *args);//struct dap_events * a_events,
+ // int s, dap_events_socket_callbacks_t * a_callbacks); // Create new client and add it to the list
+
+
+PyObject *dap_events_socket_find_py(PyDapEventsSocketObject *self, PyObject *args);//int sock, struct dap_events * sh); // Find client by socket
+//PyObject *dap_events_socket_is_ready_to_read_py(PyDapEventsSocketObject *self);//dap_events_socket_t * sc);
+//PyObject *dap_events_socket_is_ready_to_write_py(PyDapEventsSocketObject *self);//dap_events_socket_t * sc);
+PyObject *dap_events_socket_set_readable_py(PyDapEventsSocketObject *self, PyObject *args);//dap_events_socket_t * sc,bool is_ready);
+PyObject *dap_events_socket_set_writable_py(PyDapEventsSocketObject *self, PyObject *args);//dap_events_socket_t * sc,bool is_ready);
+
+PyObject *dap_events_socket_write_py(PyDapEventsSocketObject *self, PyObject *args);//dap_events_socket_t *sc, const void * data, size_t data_size);
+PyObject *dap_events_socket_write_f_py(PyDapEventsSocketObject *self, PyObject *args);//dap_events_socket_t *sc, const char * format,...);
+PyObject *dap_events_socket_read_py(PyDapEventsSocketObject *self, PyObject *args);//dap_events_socket_t *sc, void * data, size_t data_size);
+
+PyObject *dap_events_socket_delete_py(PyDapEventsSocketObject *self, PyObject *args);//dap_events_socket_t *sc,bool preserve_inheritor); // Removes the client from the list
+
+PyObject *dap_events_socket_shrink_buf_in_py(PyDapEventsSocketObject *self, PyObject *args);//dap_events_socket_t * cl, size_t shrink_size);
+
+static PyMethodDef PyDapEventsObjectSocket_methods[] = {
+ {"createAfter", (PyCFunction)dap_events_socket_create_after_py, METH_NOARGS, ""},
+ {"find", (PyCFunction)dap_events_socket_find_py, METH_VARARGS, ""},
+// {"isReadyToRead", (PyCFunction)dap_events_socket_is_ready_to_read_py, METH_NOARGS, ""},
+// {"isReadyToWrite", (PyCFunction)dap_events_socket_is_ready_to_write_py, METH_NOARGS, ""},
+ {"setReadable", (PyCFunction)dap_events_socket_set_readable_py, METH_VARARGS, ""},
+ {"setWritable", (PyCFunction)dap_events_socket_set_writable_py, METH_VARARGS, ""},
+ {"write", (PyCFunction)dap_events_socket_write_py, METH_VARARGS, ""},
+ {"writeF", (PyCFunction)dap_events_socket_write_f_py, METH_VARARGS, ""},
+ {"read", (PyCFunction)dap_events_socket_read_py, METH_VARARGS, ""},
+ {"delete", (PyCFunction)dap_events_socket_delete_py, METH_VARARGS, ""},
+ {"shringBufIn", (PyCFunction)dap_events_socket_shrink_buf_in_py, METH_VARARGS, ""},
+ {NULL, NULL, 0, NULL} /* Sentinel */
+};
+
+static PyTypeObject dapEventsSocket_dapEventsSocketType = {
+ PyVarObject_HEAD_INIT(NULL, 0)
+ "libDapServerCore.DapEventsSocket", /* tp_name */
+ sizeof(PyDapEventsSocketObject), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ 0,//(destructor)Noddy_dealloc, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ 0, /* tp_reserved */
+ 0, /* tp_repr */
+ 0, /* tp_as_number */
+ 0, /* tp_as_sequence */
+ 0, /* tp_as_mapping */
+ 0, /* tp_hash */
+ 0, /* tp_call */
+ 0, /* tp_str */
+ 0, /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT |
+ Py_TPFLAGS_BASETYPE, /* tp_flags */
+ "DapEventsSocket objects", /* tp_doc */
+ 0, /* tp_traverse */
+ 0, /* tp_clear */
+ 0, /* tp_richcompare */
+ 0, /* tp_weaklistoffset */
+ 0, /* tp_iter */
+ 0, /* tp_iternext */
+ PyDapEventsObjectSocket_methods, /* tp_methods */
+ 0, /* tp_members */
+ 0, /* tp_getset */
+ 0, /* tp_base */
+ 0, /* tp_dict */
+ 0, /* tp_descr_get */
+ 0, /* tp_descr_set */
+ 0, /* tp_dictoffset */
+ 0,//(initproc)PyDapEventsObject_init,//(initproc)Noddy_init, /* tp_init */
+ 0, /* tp_alloc */
+ PyType_GenericNew,//PyDapEventsObject_new,//Noddy_new, /* tp_new */
+};
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/include/libdap-server-core-python.h b/include/libdap-server-core-python.h
new file mode 100644
index 0000000000000000000000000000000000000000..047549eaf13d1d165ae58b497a8b6c7eedaf4b64
--- /dev/null
+++ b/include/libdap-server-core-python.h
@@ -0,0 +1,73 @@
+#define PY_SSIZE_T_CLEAN
+#include "Python.h"
+#include "dap_server.h"
+#include "dap_client_remote.h"
+#include "dap_events.h"
+#include "dap_common.h"
+#include "dap_events_python.h"
+#include "dap_events_socket_python.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct PyDapServer {
+ PyObject_HEAD
+ dap_server_t *t_server;
+}PyDapServerObject;
+
+PyTypeObject dapServer_dapServerType = {
+ PyVarObject_HEAD_INIT(NULL, 0)
+ "libDapServerCore.DapServer", /* tp_name */
+ sizeof(PyDapServerObject), /* tp_basicsize */
+ 0, /* tp_itemsize */
+ 0, /* tp_dealloc */
+ 0, /* tp_print */
+ 0, /* tp_getattr */
+ 0, /* tp_setattr */
+ 0, /* tp_compare */
+ 0, /* tp_repr */
+ 0, /* tp_as_number */
+ 0, /* tp_as_sequence */
+ 0, /* tp_as_mapping */
+ 0, /* tp_hash */
+ 0, /* tp_call */
+ 0, /* tp_str */
+ 0, /* tp_getattro */
+ 0, /* tp_setattro */
+ 0, /* tp_as_buffer */
+ Py_TPFLAGS_DEFAULT, /* tp_flags */
+ "DapServer objects", /* tp_doc */
+};
+
+#define LOG_TAG "libdap-server-core-python"
+
+static PyObject *dap_server_core_init(PyObject *self, PyObject *args);
+static PyObject *dap_server_core_deinit();
+
+static PyObject *dap_server_core_loop(PyObject *self, PyObject *args);
+static PyObject *dap_server_core_listen(PyObject *self, PyObject *args);
+
+static PyMethodDef DapServerCorePythonMethods[] = {
+ {"init", dap_server_core_init, METH_VARARGS, "Initialization of the DAP (Deus Applicaions Prototypes) server core library"},
+ {"deinit", dap_server_core_deinit, METH_NOARGS, "Deinitialization of the DAP (Deus Applicaions Prototypes) server core library"},
+ {"loop", dap_server_core_loop, METH_VARARGS, ""},
+ {"listen", dap_server_core_listen, METH_VARARGS, ""},
+ {NULL, NULL, 0, NULL}
+};
+
+static struct PyModuleDef dapservercorepythonmodule = {
+ PyModuleDef_HEAD_INIT,
+ "libDapServerCore", /* name of module */
+ NULL, /* module documentation, may be NULL */
+ -1, /* size of per-interpreter state of the module,
+ or -1 if the module keeps state in global variables. */
+ DapServerCorePythonMethods
+};
+
+PyMODINIT_FUNC PyInit_libDapServerCore(void);
+
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/libdap b/libdap
new file mode 160000
index 0000000000000000000000000000000000000000..67993d1f4cec44de464acee32a4d4f71d51c7e7d
--- /dev/null
+++ b/libdap
@@ -0,0 +1 @@
+Subproject commit 67993d1f4cec44de464acee32a4d4f71d51c7e7d
diff --git a/libdap-crypto b/libdap-crypto
new file mode 160000
index 0000000000000000000000000000000000000000..6249887fdd5c9ed88eb26c1e10f853ea9f7001b6
--- /dev/null
+++ b/libdap-crypto
@@ -0,0 +1 @@
+Subproject commit 6249887fdd5c9ed88eb26c1e10f853ea9f7001b6
diff --git a/libdap-server-core b/libdap-server-core
new file mode 160000
index 0000000000000000000000000000000000000000..6778521f9f646e2985994e63f470067b3e2c1e48
--- /dev/null
+++ b/libdap-server-core
@@ -0,0 +1 @@
+Subproject commit 6778521f9f646e2985994e63f470067b3e2c1e48
diff --git a/src/dap_events_python.c b/src/dap_events_python.c
new file mode 100644
index 0000000000000000000000000000000000000000..aee762b3eb4dc65439aa4878106610c9331e0d4d
--- /dev/null
+++ b/src/dap_events_python.c
@@ -0,0 +1,44 @@
+#include "dap_events_python.h"
+
+PyObject *PyDapEventsObject_new(PyTypeObject *type_object, PyObject *args, PyObject *kwds){
+ PyDapEventsObject *new_EO = (PyDapEventsObject*)PyType_GenericNew(type_object, args, kwds);
+ new_EO->t_events = dap_events_new();
+ return (PyObject *)new_EO;
+}
+
+void PyDapEventsObject_dealloc(PyDapEventsObject *eventsObject){
+ dap_events_delete(eventsObject->t_events);
+ Py_TYPE(eventsObject)->tp_free((PyObject*)eventsObject);
+}
+
+//void dap_events_socket_remove_and_delete( dap_events_socket_t* a_es );
+PyObject *dap_events_socket_remove_and_delete_py(PyDapEventsObject *self, PyObject *args){
+ PyObject *in_obj;
+ PyObject *in_bool;
+ if (!PyArg_ParseTuple(args, "O|O", &in_obj, &in_bool)){
+ return NULL;
+ }
+ bool preserve_inheritor = true;
+ if (in_bool == Py_False)
+ preserve_inheritor = false;
+ dap_events_socket_remove_and_delete(((PyDapEventsSocketObject*)in_obj)->t_events_socket, preserve_inheritor);
+ return PyLong_FromLong(0);
+}
+
+PyObject *dap_events_kill_socket_py(PyDapEventsObject *self, PyObject *args){
+ PyObject *in_obj;
+ if (!PyArg_ParseTuple(args, "O", &in_obj)){
+ return NULL;
+ }
+ dap_events_kill_socket(((PyDapEventsSocketObject*)in_obj)->t_events_socket);
+ return PyLong_FromLong(0);
+}
+
+PyObject *dap_events_start_py(PyDapEventsObject *self){
+ int32_t result = dap_events_start(self->t_events);
+ return PyLong_FromLong(result);
+}
+PyObject *dap_events_wait_py(PyDapEventsObject *self){
+ int32_t result = dap_events_wait(self->t_events);
+ return PyLong_FromLong(result);
+}
diff --git a/src/dap_events_socket_python.c b/src/dap_events_socket_python.c
new file mode 100644
index 0000000000000000000000000000000000000000..f44de06fa7743ef046dcefc29373117d277f7f4b
--- /dev/null
+++ b/src/dap_events_socket_python.c
@@ -0,0 +1,142 @@
+#include "dap_events_socket_python.h"
+
+PyObject *dap_events_socket_create_after_py(PyDapEventsSocketObject *self){
+ if (self->t_events_socket == NULL){
+ return NULL;
+ }
+ dap_events_socket_create_after(self->t_events_socket);
+ return PyLong_FromLong(0);
+}
+
+//PyObject *dap_events_socket_wrap_no_add_py(PyObject *self, PyObject *args){
+// return PyLong_FromLong(0);
+//}
+
+
+PyObject *dap_events_socket_find_py(PyDapEventsSocketObject *self, PyObject *args){
+ if (self->t_events_socket != NULL){
+ return NULL;
+ }
+ int socket;
+ PyObject *in_object;
+ if (!PyArg_ParseTuple(args, "i|O", &socket, &in_object)){
+ return NULL;
+ }
+ self->t_events_socket = dap_events_socket_find(socket, ((PyDapEventsObject*)in_object)->t_events);
+ return PyLong_FromLong(0);
+}
+
+//PyObject *dap_events_socket_is_ready_to_read_py(PyDapEventsSocketObject *self){
+// bool result = dap_events_socket_is_ready_to_read(self->t_events_socket);
+// if (result)
+// return Py_BuildValue("O", Py_True);
+// else
+// return Py_BuildValue("O", Py_False);
+//}
+//PyObject *dap_events_socket_is_ready_to_write_py(PyDapEventsSocketObject *self){
+// bool result = dap_events_socket_is_ready_to_write(self->t_events_socket);
+// if (result)
+// return Py_BuildValue("O", Py_True);
+// else
+// return Py_BuildValue("O", Py_False);
+//}
+PyObject *dap_events_socket_set_readable_py(PyDapEventsSocketObject *self, PyObject *args){
+ if (self->t_events_socket == NULL){
+ return NULL;
+ }
+ PyObject *l_is_ready;
+ if (!PyArg_ParseTuple(args, "O", &l_is_ready)){
+ return NULL;
+ }
+ bool is_ready = true;
+ if (l_is_ready == Py_False)
+ is_ready = false;
+ dap_events_socket_set_readable(self->t_events_socket, is_ready);
+ return PyLong_FromLong(0);
+}
+PyObject *dap_events_socket_set_writable_py(PyDapEventsSocketObject *self, PyObject *args){
+ if (self->t_events_socket == NULL){
+ return NULL;
+ }
+ PyObject *l_is_ready;
+ if (!PyArg_ParseTuple(args, "O", &l_is_ready)){
+ return NULL;
+ }
+ bool is_ready = true;
+ if (l_is_ready == Py_False)
+ is_ready = false;
+ dap_events_socket_set_writable(self->t_events_socket, is_ready);
+ return PyLong_FromLong(0);
+}
+
+PyObject *dap_events_socket_write_py(PyDapEventsSocketObject *self, PyObject *args){
+ if (self->t_events_socket == NULL){
+ return NULL;
+ }
+ PyBytesObject *in_bytes;
+ size_t in_size;
+ if (!PyArg_ParseTuple(args, "S|n", &in_bytes, &in_size)){
+ return NULL;
+ }
+ char *in_v_bytes = PyBytes_AsString((PyObject*)in_bytes);
+ size_t res_size = dap_events_socket_write(self->t_events_socket,
+ in_v_bytes, in_size);
+ return Py_BuildValue("n", res_size);
+}
+PyObject *dap_events_socket_write_f_py(PyDapEventsSocketObject *self, PyObject *args){
+ if (self->t_events_socket == NULL){
+ return NULL;
+ }
+ const char *format;
+ PyTupleObject *pto;
+ if (!PyArg_ParseTuple(args, "s|O", &format, &pto)){
+ return NULL;
+ }
+ va_list ap;
+ if (!PyArg_VaParse(args, format, ap)){
+ return NULL;
+ }
+ size_t res_size = dap_events_socket_write_f(self->t_events_socket, format, ap);
+ return Py_BuildValue("n", res_size);
+}
+PyObject *dap_events_socket_read_py(PyDapEventsSocketObject *self, PyObject *args){
+ if (self->t_events_socket == NULL){
+ return NULL;
+ }
+ size_t in_size;
+ if (!PyArg_ParseTuple(args, "n", &in_size)){
+ return NULL;
+ }
+ void *res = DAP_NEW_SIZE(void*, in_size);
+ size_t res_size = dap_events_socket_read(self->t_events_socket, res, in_size);
+ PyBytesObject *res_obj = (PyBytesObject*)PyBytes_FromString(res);
+ return Py_BuildValue("nS", res_size, res_obj);
+}
+
+PyObject *dap_events_socket_delete_py(PyDapEventsSocketObject *self, PyObject *args){
+ if (self->t_events_socket == NULL){
+ return NULL;
+ }
+ PyObject *in_bool;
+ if (!PyArg_ParseTuple(args, "O", &in_bool)){
+ return NULL;
+ }
+ bool boolean = true;
+ if (in_bool == Py_False)
+ boolean = false;
+ dap_events_socket_delete(self->t_events_socket, boolean);
+ return PyLong_FromLong(0);
+}
+
+PyObject *dap_events_socket_shrink_buf_in_py(PyDapEventsSocketObject *self, PyObject *args){
+ if (self->t_events_socket == NULL){
+ return NULL;
+ }
+ size_t in_size;
+ if(!PyArg_ParseTuple(args, "n", &in_size)){
+ return NULL;
+ }
+ dap_events_socket_shrink_buf_in(self->t_events_socket, in_size);
+ return PyLong_FromLong(0);
+}
+
diff --git a/src/libdap-server-core-python.c b/src/libdap-server-core-python.c
new file mode 100644
index 0000000000000000000000000000000000000000..ab2bf51bc7a2fce231cd213f8208a5d5fca63c86
--- /dev/null
+++ b/src/libdap-server-core-python.c
@@ -0,0 +1,89 @@
+#include "libdap-server-core-python.h"
+
+
+static PyObject *dap_server_core_init(PyObject *self, PyObject *args){
+ uint32_t l_thread_cnt;
+ size_t conn_t;
+ dap_common_init("CVNT", "CVNT.log");
+ if (!PyArg_ParseTuple(args, "I|n", &l_thread_cnt, &conn_t)){
+ return NULL;
+ }
+ int32_t result = dap_server_init(l_thread_cnt);
+ if ( result != 0 ) {
+ log_it( L_CRITICAL, "Can't init socket server module" );
+ }
+ dap_events_init(l_thread_cnt, conn_t);
+ dap_client_remote_init();
+ return PyLong_FromLong(result);
+}
+static PyObject *dap_server_core_deinit(){
+ dap_client_remote_deinit();
+ dap_server_deinit();
+ dap_events_deinit();
+ return PyLong_FromLong(0);
+}
+
+static PyObject *dap_server_core_loop(PyObject *self, PyObject *args){
+ PyObject *obj_server;
+ if (!PyArg_ParseTuple(args, "O", &obj_server)){
+ return NULL;
+ }
+ int32_t result = dap_server_loop(((PyDapServerObject*)obj_server)->t_server);
+ log_it( result ? L_CRITICAL : L_NOTICE, "Server loop stopped with return code %d", ((PyDapServerObject*)obj_server)->t_server );
+ return PyLong_FromLong(result);
+}
+
+static PyObject *dap_server_core_listen(PyObject *self, PyObject *args){
+ const char *addr;
+ uint16_t port;
+ uint16_t type;
+ if (!PyArg_ParseTuple(args, "s|H|H", &addr, &port, &type)){
+ return NULL;
+ }
+ if (type > 1)
+ return NULL;
+ PyObject *obj = _PyObject_New(&dapServer_dapServerType);
+ ((PyDapServerObject*)obj)->t_server = dap_server_listen(addr, port, type);
+ return Py_BuildValue("O", obj);
+}
+
+PyMODINIT_FUNC PyInit_libDapServerCore(void){
+ dapServer_dapServerType.tp_new = PyType_GenericNew;
+ //dapEvents_dapEventsType.tp_new = PyType_GenericNew;
+ dapEventsSocket_dapEventsSocketType.tp_new = PyType_GenericNew;
+ if (PyType_Ready(&dapServer_dapServerType) < 0 || PyType_Ready(&dapEvents_dapEventsType) < 0
+ || PyType_Ready(&dapEventsSocket_dapEventsSocketType) < 0)
+ return NULL;
+
+ PyObject *module = PyModule_Create(&dapservercorepythonmodule);
+
+ PyModule_AddObject(module, "DapEvents", (PyObject*)&dapEvents_dapEventsType);
+ PyModule_AddObject(module, "DapEventsSocket", (PyObject*)&dapEventsSocket_dapEventsSocketType);
+
+ return module;
+}
+
+int main(int argc, char **argv) {
+ wchar_t *program = Py_DecodeLocale(argv[0], NULL);
+ if (program == NULL) {
+ fprintf(stderr, "Fatal error: cannot decode argv[0]\n");
+ exit(1);
+ }
+
+ /* Add a built-in module, before Py_Initialize */
+ PyImport_AppendInittab("libDapServerCore", PyInit_libDapServerCore);
+
+ /* Pass argv[0] to the Python interpreter */
+ Py_SetProgramName(program);
+
+ /* Initialize the Python interpreter. Required. */
+ Py_Initialize();
+
+ /* Optionally import the module; alternatively,
+ import can be deferred until the embedded script
+ imports it. */
+ PyImport_ImportModule("libDapServerCore");
+
+ PyMem_RawFree(program);
+ return 0;
+}
diff --git a/test/test.py b/test/test.py
new file mode 100644
index 0000000000000000000000000000000000000000..2780abb163e6d8cdd65d2ec4dc757b4af707f65c
--- /dev/null
+++ b/test/test.py
@@ -0,0 +1,6 @@
+import libDapServerCore as server
+
+print ("Start wrapping libdap server core python module")
+res_i = server.init(1, 0)
+rc = server.listen("0.0.0.0", 3307, 0)
+server.deinit()