diff options
| -rw-r--r-- | include/mscp.h | 2 | ||||
| -rw-r--r-- | setup.py | 14 | ||||
| -rw-r--r-- | src/pymscp.c | 331 |
3 files changed, 346 insertions, 1 deletions
diff --git a/include/mscp.h b/include/mscp.h index 0015548..3bdf7ed 100644 --- a/include/mscp.h +++ b/include/mscp.h @@ -257,7 +257,7 @@ void mscp_set_msg_fd(struct mscp *m, int fd); * * @return pointer to the message. */ -const char *mscp_get_error(); +const char *mscp_get_error(void); diff --git a/setup.py b/setup.py new file mode 100644 index 0000000..dae605b --- /dev/null +++ b/setup.py @@ -0,0 +1,14 @@ +from distutils.core import setup, Extension + +setup( + name='pymscp', + ext_modules = [ + Extension( + 'pymscp', + ['src/pymscp.c'], + library_dirs = ['build'], + libraries = ['mscp'], + include_dirs = ['include'] + ) + ] +) diff --git a/src/pymscp.c b/src/pymscp.c new file mode 100644 index 0000000..201ce87 --- /dev/null +++ b/src/pymscp.c @@ -0,0 +1,331 @@ +#define PY_SSIZE_T_CLEAN +#include <Python.h> +#include <mscp.h> + +static PyObject *wrap_mscp_init(PyObject *sef, PyObject *args, PyObject *kw) +{ + /* + * Initialize struct mscp with options. wrap_mscp_init + * receives all the arguments with keywords. + */ + + char *remote; + char *keywords[] = { + /* mscp_opts */ + "direction", /* int, MSCP_DIRECTION_L2R or MSCP_DIRECTION_R2L */ + "nr_threads", /* int */ + "nr_ahead", /* int */ + "min_chunk_sz", /* unsigned long */ + "max_chunk_sz", /* unsigned long */ + "buf_sz", /* unsigned long */ + "coremask", /* const char * */ + "severity", /* int, MSCP_SERVERITY_* */ + "msg_fd", /* int */ + + /* mscp_ssh_opts */ + "login_name", /* const char * */ + "port", /* const char * */ + "identity", /* const char * */ + "cipher", /* const char * */ + "hmac", /* const char * */ + "compress", /* const char * */ + "password", /* const char * */ + "passphrase", /* const char * */ + "debug_level", /* int */ + "no_hostkey_check", /* bool */ + "enable_nagle", /* bool */ + NULL, + }; + const char *fmt = "siiikkkzii" "zzzzzzzzipp"; + char *coremask; + char *login_name, *port, *identity, *cipher, *hmac, *compress; + char *password, *passphrase; + + struct mscp_opts mo; + struct mscp_ssh_opts so; + struct mscp *m; + int ret; + + memset(&mo, 0, sizeof(mo)); + memset(&so, 0, sizeof(so)); + + ret = PyArg_ParseTupleAndKeywords(args, kw, fmt, keywords, + &remote, + &mo.direction, + &mo.nr_threads, + &mo.nr_ahead, + &mo.min_chunk_sz, + &mo.max_chunk_sz, + &mo.buf_sz, + &coremask, + &mo.severity, + &mo.msg_fd, + &login_name, + &port, + &identity, + &cipher, + &hmac, + &compress, + &password, + &passphrase, + &so.no_hostkey_check, + &so.enable_nagle); + + if (!ret) + return NULL; + + if (coremask) + strncpy(mo.coremask, coremask, MSCP_MAX_COREMASK_STR); + if (login_name) + strncpy(so.login_name, login_name, MSCP_SSH_MAX_LOGIN_NAME); + if (port) + strncpy(so.port, port, MSCP_SSH_MAX_PORT_STR); + if (identity) + strncpy(so.identity, identity, MSCP_SSH_MAX_IDENTITY_PATH); + if (cipher) + strncpy(so.cipher, cipher, MSCP_SSH_MAX_CIPHER_STR); + if (hmac) + strncpy(so.hmac, hmac, MSCP_SSH_MAX_HMAC_STR); + if (compress) + strncpy(so.compress, compress, MSCP_SSH_MAX_COMP_STR); + if (password) + strncpy(so.password, password, MSCP_SSH_MAX_PASSWORD); + if (passphrase) + strncpy(so.passphrase, passphrase, MSCP_SSH_MAX_PASSPHRASE); + + + m = mscp_init(remote, &mo, &so); + if (!m) + return NULL; + + return Py_BuildValue("K", (unsigned long long)m); +} + +static PyObject *wrap_mscp_connect(PyObject *self, PyObject *args, PyObject *kw) +{ + char *keywords[] = { "m", NULL }; + unsigned long long maddr; + struct mscp *m; + + if (!PyArg_ParseTupleAndKeywords(args, kw, "K", keywords, &maddr)) + return NULL; + + m = (void *)maddr; + if (mscp_connect(m) < 0) { + PyErr_Format(PyExc_RuntimeError, mscp_get_error()); + return NULL; + } + + return Py_BuildValue(""); +} + +static PyObject *wrap_mscp_add_src_path(PyObject *self, PyObject *args, PyObject *kw) +{ + char *keywords[] = { "m", "src_path", NULL }; + unsigned long long maddr; + char *src_path; + struct mscp *m; + + if (!PyArg_ParseTupleAndKeywords(args, kw, "Ks", keywords, &maddr, &src_path)) + return NULL; + + m = (void *)maddr; + if (mscp_add_src_path(m, src_path) < 0) { + PyErr_Format(PyExc_RuntimeError, mscp_get_error()); + return NULL; + } + + return Py_BuildValue(""); +} + +static PyObject *wrap_mscp_set_dst_path(PyObject *self, PyObject *args, PyObject *kw) +{ + char *keywords[] = { "m", "dst_path", NULL }; + unsigned long long maddr; + char *dst_path; + struct mscp *m; + + if (!PyArg_ParseTupleAndKeywords(args, kw, "Ks", keywords, &maddr, &dst_path)) + return NULL; + + m = (void *)maddr; + if (mscp_set_dst_path(m, dst_path) < 0) { + PyErr_Format(PyExc_RuntimeError, mscp_get_error()); + return NULL; + } + + return Py_BuildValue(""); +} + +static PyObject *wrap_mscp_prepare(PyObject *self, PyObject *args, PyObject *kw) +{ + char *keywords[] = { "m", NULL }; + unsigned long long maddr; + struct mscp *m; + + if (!PyArg_ParseTupleAndKeywords(args, kw, "K", keywords, &maddr)) + return NULL; + + m = (void *)maddr; + if (mscp_prepare(m) < 0) { + PyErr_Format(PyExc_RuntimeError, mscp_get_error()); + return NULL; + } + + return Py_BuildValue(""); +} + +static PyObject *wrap_mscp_start(PyObject *self, PyObject *args, PyObject *kw) +{ + char *keywords[] = { "m", NULL }; + unsigned long long maddr; + struct mscp *m; + + if (!PyArg_ParseTupleAndKeywords(args, kw, "K", keywords, &maddr)) + return NULL; + + m = (void *)maddr; + if (mscp_start(m) < 0) { + PyErr_Format(PyExc_RuntimeError, mscp_get_error()); + return NULL; + } + + return Py_BuildValue(""); +} + +static PyObject *wrap_mscp_stop(PyObject *self, PyObject *args, PyObject *kw) +{ + char *keywords[] = { "m", NULL }; + unsigned long long maddr; + struct mscp *m; + + if (!PyArg_ParseTupleAndKeywords(args, kw, "K", keywords, &maddr)) + return NULL; + + m = (void *)maddr; + mscp_stop(m); + + return Py_BuildValue(""); +} + +static PyObject *wrap_mscp_join(PyObject *self, PyObject *args, PyObject *kw) +{ + char *keywords[] = { "m", NULL }; + unsigned long long maddr; + struct mscp *m; + + if (!PyArg_ParseTupleAndKeywords(args, kw, "K", keywords, &maddr)) + return NULL; + + m = (void *)maddr; + if (mscp_join(m) < 0) { + PyErr_Format(PyExc_RuntimeError, mscp_get_error()); + return NULL; + } + + return Py_BuildValue(""); +} + +static PyObject *wrap_mscp_get_stats(PyObject *self, PyObject *args, PyObject *kw) +{ + char *keywords[] = { "m", NULL }; + unsigned long long maddr; + struct mscp_stats s; + struct mscp *m; + + if (!PyArg_ParseTupleAndKeywords(args, kw, "K", keywords, &maddr)) + return NULL; + + m = (void *)maddr; + mscp_get_stats(m, &s); + + return Py_BuildValue("KKd", s.total, s.done, s.finished); +} + +static PyObject *wrap_mscp_cleanup(PyObject *self, PyObject *args, PyObject *kw) +{ + char *keywords[] = { "m", NULL }; + unsigned long long maddr; + struct mscp *m; + + if (!PyArg_ParseTupleAndKeywords(args, kw, "K", keywords, &maddr)) + return NULL; + + m = (void *)maddr; + mscp_cleanup(m); + + return Py_BuildValue(""); +} + +static PyObject *wrap_mscp_free(PyObject *self, PyObject *args, PyObject *kw) +{ + char *keywords[] = { "m", NULL }; + unsigned long long maddr; + struct mscp *m; + + if (!PyArg_ParseTupleAndKeywords(args, kw, "K", keywords, &maddr)) + return NULL; + + m = (void *)maddr; + mscp_free(m); + + return Py_BuildValue(""); +} + +static PyMethodDef PyMscpMethods[] = { + { + "mscp_init", (PyCFunction)wrap_mscp_init, + METH_VARARGS | METH_KEYWORDS, NULL + }, + { + "mscp_connect", (PyCFunction)wrap_mscp_connect, + METH_VARARGS | METH_KEYWORDS, NULL + }, + { + "mscp_add_src_path", (PyCFunction)wrap_mscp_add_src_path, + METH_VARARGS | METH_KEYWORDS, NULL + }, + { + "mscp_set_dst_path", (PyCFunction)wrap_mscp_set_dst_path, + METH_VARARGS | METH_KEYWORDS, NULL + }, + { + "mscp_prepare", (PyCFunction)wrap_mscp_prepare, + METH_VARARGS | METH_KEYWORDS, NULL + }, + { + "mscp_start", (PyCFunction)wrap_mscp_start, + METH_VARARGS | METH_KEYWORDS, NULL + }, + { + "mscp_stop", (PyCFunction)wrap_mscp_stop, + METH_VARARGS | METH_KEYWORDS, NULL + }, + { + "mscp_join", (PyCFunction)wrap_mscp_join, + METH_VARARGS | METH_KEYWORDS, NULL + }, + { + "mscp_get_stats", (PyCFunction)wrap_mscp_get_stats, + METH_VARARGS | METH_KEYWORDS, NULL + }, + { + "mscp_cleanup", (PyCFunction)wrap_mscp_cleanup, + METH_VARARGS | METH_KEYWORDS, NULL + }, + { + "mscp_free", (PyCFunction)wrap_mscp_free, + METH_VARARGS | METH_KEYWORDS, NULL + }, + + { NULL, NULL, 0, NULL }, +}; + +static PyModuleDef PyMscpModule = { + PyModuleDef_HEAD_INIT, "PyMscp", NULL, -1, PyMscpMethods, +}; + +PyMODINIT_FUNC PyInit_PyMscp(void) { + return PyModule_Create(&PyMscpModule); +} + |