start to implement pymscp.c

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);
 
 
 

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']
+        )
+    ]
+)

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);
+}
+