/*
 * iSCSI Administration library
 *
 * Copyright (C) 2008-2009 Red Hat, Inc. All rights reserved.
 * Copyright (C) 2008-2009 Hans de Goede <hdegoede@redhat.com>
 * maintained by open-iscsi@googlegroups.com
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published
 * by the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 *
 * See the file COPYING included with this distribution for more details.
 */

#include <Python.h>
#include "libiscsi.h"

#if PY_MAJOR_VERSION >= 3
#define IS_PY3K
#define MODINITERROR return NULL
#define PYNUM_FROMLONG PyLong_FromLong
#define PYSTR_FROMSTRING PyUnicode_FromString
#else
#define MODINITERROR return
#define PYNUM_FROMLONG PyInt_FromLong
#define PYSTR_FROMSTRING PyString_FromString
#endif

#define RET_TRUE_ELSE_FALSE { Py_RETURN_TRUE; } else { Py_RETURN_FALSE; }
#define CMP_TO_RICHCMP(cmpfunc) \
	int comp_res = cmpfunc(self, other); \
	switch (op) { \
	    case Py_LT: \
		if (comp_res < 0) RET_TRUE_ELSE_FALSE \
	    case Py_LE: \
		if (comp_res <= 0) RET_TRUE_ELSE_FALSE \
	    case Py_EQ: \
		if (comp_res == 0) RET_TRUE_ELSE_FALSE \
	    case Py_NE: \
		if (comp_res != 0) RET_TRUE_ELSE_FALSE \
	    case Py_GT: \
		if (comp_res > 0) RET_TRUE_ELSE_FALSE \
	    default: \
		if (comp_res >= 0) RET_TRUE_ELSE_FALSE \
	}

static struct libiscsi_context *context = NULL;

/****************************** helpers ***********************************/
static int check_string(const char *string)
{
	if (strlen(string) >= LIBISCSI_VALUE_MAXLEN) {
		PyErr_SetString(PyExc_ValueError, "string too long");
		return -1;
	}
	return 0;
}

/********************** PyIscsiChapAuthInfo ***************************/

typedef struct {
	PyObject_HEAD

	struct libiscsi_auth_info info;
} PyIscsiChapAuthInfo;

static int PyIscsiChapAuthInfo_init(PyObject *self, PyObject *args,
				    PyObject *kwds)
{
	int i;
	PyIscsiChapAuthInfo *chap = (PyIscsiChapAuthInfo *)self;
	char *kwlist[] = {"username", "password", "reverse_username",
				"reverse_password", NULL};
	const char *string[4] = { NULL, NULL, NULL, NULL };

	if (!PyArg_ParseTupleAndKeywords(args, kwds,
					"zz|zz:chapAuthInfo.__init__",
					kwlist, &string[0], &string[1],
					&string[2], &string[3]))
		return -1;

	for (i = 0; i < 4; i++)
		if (string[i] && check_string(string[i]))
			return -1;

	memset (&chap->info, 0, sizeof(chap->info));
	chap->info.method = libiscsi_auth_chap;
	if (string[0])
		strcpy(chap->info.chap.username, string[0]);
	if (string[1])
		strcpy(chap->info.chap.password, string[1]);
	if (string[2])
		strcpy(chap->info.chap.reverse_username, string[2]);
	if (string[3])
		strcpy(chap->info.chap.reverse_password, string[3]);

	if (libiscsi_verify_auth_info(context, &chap->info)) {
		PyErr_SetString(PyExc_ValueError,
				libiscsi_get_error_string(context));
		return -1;
	}
	return 0;
}

static PyObject *PyIscsiChapAuthInfo_get(PyObject *self, void *data)
{
	PyIscsiChapAuthInfo *chap = (PyIscsiChapAuthInfo *)self;
	const char *attr = (const char *)data;

	if (!strcmp(attr, "username")) {
		return PYSTR_FROMSTRING(chap->info.chap.username);
	} else if (!strcmp(attr, "password")) {
		return PYSTR_FROMSTRING(chap->info.chap.password);
	} else if (!strcmp(attr, "reverse_username")) {
		return PYSTR_FROMSTRING(chap->info.chap.reverse_username);
	} else if (!strcmp(attr, "reverse_password")) {
		return PYSTR_FROMSTRING(chap->info.chap.reverse_password);
	}
	return NULL;
}

static int PyIscsiChapAuthInfo_set(PyObject *self, PyObject *value, void *data)
{
	PyIscsiChapAuthInfo *chap = (PyIscsiChapAuthInfo *)self;
	const char *attr = (const char *)data;
	const char *str;

	if (!PyArg_Parse(value, "s", &str) || check_string(str))
		return -1;

	if (!strcmp(attr, "username")) {
		strcpy(chap->info.chap.username, str);
	} else if (!strcmp(attr, "password")) {
		strcpy(chap->info.chap.password, str);
	} else if (!strcmp(attr, "reverse_username")) {
		strcpy(chap->info.chap.reverse_username, str);
	} else if (!strcmp(attr, "reverse_password")) {
		strcpy(chap->info.chap.reverse_password, str);
	}

	return 0;
}

static int PyIscsiChapAuthInfo_compare(PyIscsiChapAuthInfo *self,
				       PyIscsiChapAuthInfo *other)
{
	int r;

	r = strcmp(self->info.chap.username, other->info.chap.username);
	if (r)
		return r;

	r = strcmp(self->info.chap.password, other->info.chap.password);
	if (r)
		return r;

	r = strcmp(self->info.chap.reverse_username,
		   other->info.chap.reverse_username);
	if (r)
		return r;

	r = strcmp(self->info.chap.reverse_password,
		   other->info.chap.reverse_password);
	return r;
}

PyObject *PyIscsiChapAuthInfo_richcompare(PyIscsiChapAuthInfo *self,
	                                  PyIscsiChapAuthInfo *other,
					  int op)
{
	CMP_TO_RICHCMP(PyIscsiChapAuthInfo_compare)
}

static PyObject *PyIscsiChapAuthInfo_str(PyObject *self)
{
	PyIscsiChapAuthInfo *chap = (PyIscsiChapAuthInfo *)self;
	char s[1024], reverse[512] = "";

	if (chap->info.chap.reverse_username[0])
		snprintf(reverse, sizeof(reverse), ", %s:%s",
			 chap->info.chap.reverse_username,
			 chap->info.chap.reverse_password);

	snprintf(s, sizeof(s), "%s:%s%s", chap->info.chap.username,
		 chap->info.chap.password, reverse);

	return PYSTR_FROMSTRING(s);
}

static struct PyGetSetDef PyIscsiChapAuthInfo_getseters[] = {
	{"username", (getter)PyIscsiChapAuthInfo_get,
		(setter)PyIscsiChapAuthInfo_set,
		"username", "username"},
	{"password", (getter)PyIscsiChapAuthInfo_get,
		(setter)PyIscsiChapAuthInfo_set,
		"password", "password"},
	{"reverse_username", (getter)PyIscsiChapAuthInfo_get,
		(setter)PyIscsiChapAuthInfo_set,
		"reverse_username", "reverse_username"},
	{"reverse_password", (getter)PyIscsiChapAuthInfo_get,
		(setter)PyIscsiChapAuthInfo_set,
		"reverse_password", "reverse_password"},
	{NULL}
};

PyTypeObject PyIscsiChapAuthInfo_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "libiscsi.chapAuthInfo",
	.tp_basicsize = sizeof (PyIscsiChapAuthInfo),
	.tp_getset = PyIscsiChapAuthInfo_getseters,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE
#ifndef IS_PY3K
	// Py_TPFLAGS_CHECKTYPES is only needed on Python 2
	|  Py_TPFLAGS_CHECKTYPES
#endif
	,
	.tp_richcompare = (richcmpfunc)PyIscsiChapAuthInfo_compare,
	.tp_init = PyIscsiChapAuthInfo_init,
	.tp_str = PyIscsiChapAuthInfo_str,
	.tp_new = PyType_GenericNew,
	.tp_doc = "iscsi chap authentication information.",
};

/***************************** PyIscsiNode  ********************************/

typedef struct {
	PyObject_HEAD

	struct libiscsi_node node;
} PyIscsiNode;

static int PyIscsiNode_init(PyObject *self, PyObject *args, PyObject *kwds)
{
	PyIscsiNode *node = (PyIscsiNode *)self;
	char *kwlist[] = {"name", "tpgt", "address", "port", "iface", NULL};
	const char *name = NULL, *address = NULL, *iface = NULL;
	int tpgt = -1, port = 3260;

	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s|isis:node.__init__",
					 kwlist, &name, &tpgt, &address,
					 &port, &iface))
		return -1;
	if (address == NULL) {
		PyErr_SetString(PyExc_ValueError, "address not set");
		return -1;
	}
	if (check_string(name) || check_string(address) || check_string(iface))
		return -1;

	strcpy(node->node.name, name);
	node->node.tpgt = tpgt;
	strcpy(node->node.address, address);
	node->node.port = port;
	strcpy(node->node.iface, iface);

	return 0;
}

static PyObject *PyIscsiNode_get(PyObject *self, void *data)
{
	PyIscsiNode *node = (PyIscsiNode *)self;
	const char *attr = (const char *)data;

	if (!strcmp(attr, "name")) {
		return PYSTR_FROMSTRING(node->node.name);
	} else if (!strcmp(attr, "tpgt")) {
		return PYNUM_FROMLONG(node->node.tpgt);
	} else if (!strcmp(attr, "address")) {
		return PYSTR_FROMSTRING(node->node.address);
	} else if (!strcmp(attr, "port")) {
		return PYNUM_FROMLONG(node->node.port);
	} else if (!strcmp(attr, "iface")) {
		return PYSTR_FROMSTRING(node->node.iface);
	}
	return NULL;
}

static int PyIscsiNode_set(PyObject *self, PyObject *value, void *data)
{
	PyIscsiNode *node = (PyIscsiNode *)self;
	const char *attr = (const char *)data;
	const char *str;
	int i;

	if (!strcmp(attr, "name")) {
		if (!PyArg_Parse(value, "s", &str) || check_string(str))
			return -1;
		strcpy(node->node.name, str);
	} else if (!strcmp(attr, "tpgt")) {
		if (!PyArg_Parse(value, "i", &i))
			return -1;
		node->node.tpgt = i;
	} else if (!strcmp(attr, "address")) {
		if (!PyArg_Parse(value, "s", &str) || check_string(str))
			return -1;
		strcpy(node->node.address, str);
	} else if (!strcmp(attr, "port")) {
		if (!PyArg_Parse(value, "i", &i))
			return -1;
		node->node.port = i;
	} else if (!strcmp(attr, "iface")) {
		if (!PyArg_Parse(value, "s", &str) || check_string(str))
			return -1;
		strcpy(node->node.iface, str);
	}

	return 0;
}

static int PyIscsiNode_compare(PyIscsiNode *self, PyIscsiNode *other)
{
	int res;

	res = strcmp(self->node.name, other->node.name);
	if (res)
		return res;

	if (self->node.tpgt < other->node.tpgt)
		return -1;
	if (self->node.tpgt > other->node.tpgt)
		return -1;

	res = strcmp(self->node.address, other->node.address);
	if (res)
		return res;

	if (self->node.port < other->node.port)
		return -1;
	if (self->node.port > other->node.port)
		return -1;

	res = strcmp(self->node.iface, other->node.iface);
	if (res)
		return res;

	return 0;
}

PyObject *PyIscsiNode_richcompare(PyIscsiNode *self, PyIscsiNode *other, int op)
{
    CMP_TO_RICHCMP(PyIscsiNode_compare)
}

static PyObject *PyIscsiNode_str(PyObject *self)
{
	PyIscsiNode *node = (PyIscsiNode *)self;
	char s[1024], tpgt[16] = "";

	if (node->node.tpgt != -1)
		sprintf(tpgt, ",%d", node->node.tpgt);

	snprintf(s, sizeof(s), "%s:%d%s %s", node->node.address,
		 node->node.port, tpgt, node->node.name);

	return PYSTR_FROMSTRING(s);
}

static PyObject *PyIscsiNode_login(PyObject *self)
{
	PyIscsiNode *node = (PyIscsiNode *)self;
	int ret;

	Py_BEGIN_ALLOW_THREADS
	ret = libiscsi_node_login(context, &node->node);
	Py_END_ALLOW_THREADS

	if (ret) {
		PyErr_SetString(PyExc_IOError,
				libiscsi_get_error_string(context));
		return NULL;
	}
	Py_RETURN_NONE;
}

static PyObject *PyIscsiNode_logout(PyObject *self)
{
	PyIscsiNode *node = (PyIscsiNode *)self;

	if (libiscsi_node_logout(context, &node->node)) {
		PyErr_SetString(PyExc_IOError,
				libiscsi_get_error_string(context));
		return NULL;
	}
	Py_RETURN_NONE;
}

static PyObject *PyIscsiNode_setAuth(PyObject *self, PyObject *args,
				     PyObject *kwds)
{
	char *kwlist[] = {"authinfo", NULL};
	PyIscsiNode *node = (PyIscsiNode *)self;
	PyObject *arg;
	const struct libiscsi_auth_info *authinfo = NULL;

	if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", kwlist, &arg))
		return NULL;

	if (arg == Py_None) {
		authinfo = NULL;
	} else if (PyObject_IsInstance(arg, (PyObject *)
				       &PyIscsiChapAuthInfo_Type)) {
		PyIscsiChapAuthInfo *pyauthinfo = (PyIscsiChapAuthInfo *)arg;
		authinfo = &pyauthinfo->info;
	} else {
		PyErr_SetString(PyExc_ValueError, "invalid authinfo type");
		return NULL;
	}

	if (libiscsi_node_set_auth(context, &node->node, authinfo)) {
		PyErr_SetString(PyExc_IOError,
				libiscsi_get_error_string(context));
		return NULL;
	}
	Py_RETURN_NONE;
}

static PyObject *PyIscsiNode_getAuth(PyObject *self)
{
	PyIscsiNode *node = (PyIscsiNode *)self;
	PyIscsiChapAuthInfo *pyauthinfo;
	struct libiscsi_auth_info authinfo;

	if (libiscsi_node_get_auth(context, &node->node, &authinfo)) {
		PyErr_SetString(PyExc_IOError,
				libiscsi_get_error_string(context));
		return NULL;
	}

	switch (authinfo.method) {
	case libiscsi_auth_chap:
		pyauthinfo = PyObject_New(PyIscsiChapAuthInfo,
					  &PyIscsiChapAuthInfo_Type);
		if (!pyauthinfo)
			return NULL;

		pyauthinfo->info = authinfo;

		return (PyObject *)pyauthinfo;

	case libiscsi_auth_none:
	default:
		Py_RETURN_NONE;
	}
}

static PyObject *PyIscsiNode_setParameter(PyObject *self, PyObject *args,
					  PyObject *kwds)
{
	char *kwlist[] = {"parameter", "value", NULL};
	PyIscsiNode *node = (PyIscsiNode *)self;
	const char *parameter, *value;

	if (!PyArg_ParseTupleAndKeywords(args, kwds, "ss", kwlist,
					 &parameter, &value))
		return NULL;
	if (check_string(parameter) || check_string(value))
		return NULL;

	if (libiscsi_node_set_parameter(context, &node->node, parameter,
				        value)) {
		PyErr_SetString(PyExc_IOError,
				libiscsi_get_error_string(context));
		return NULL;
	}
	Py_RETURN_NONE;
}

static PyObject *PyIscsiNode_getParameter(PyObject *self, PyObject *args,
					  PyObject *kwds)
{
	char *kwlist[] = {"parameter", NULL};
	PyIscsiNode *node = (PyIscsiNode *)self;
	const char *parameter;
	char value[LIBISCSI_VALUE_MAXLEN];

	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &parameter))
		return NULL;
	if (check_string(parameter))
		return NULL;

	if (libiscsi_node_get_parameter(context, &node->node, parameter,
					value)) {
		PyErr_SetString(PyExc_IOError,
				libiscsi_get_error_string(context));
		return NULL;
	}
	return Py_BuildValue("s", value);
}

static struct PyGetSetDef PyIscsiNode_getseters[] = {
	{"name", (getter)PyIscsiNode_get, (setter)PyIscsiNode_set,
		"name", "name"},
	{"tpgt", (getter)PyIscsiNode_get, (setter)PyIscsiNode_set,
		"tpgt", "tpgt"},
	{"address", (getter)PyIscsiNode_get, (setter)PyIscsiNode_set,
		"address", "address"},
	{"port", (getter)PyIscsiNode_get, (setter)PyIscsiNode_set,
		"port", "port"},
	{"iface", (getter)PyIscsiNode_get, (setter)PyIscsiNode_set,
		"iface", "iface"},
	{NULL}
};

static struct PyMethodDef  PyIscsiNode_methods[] = {
	{"login", (PyCFunction) PyIscsiNode_login, METH_NOARGS,
		"Log in to the node"},
	{"logout", (PyCFunction) PyIscsiNode_logout, METH_NOARGS,
		"Log out of the node"},
	{"setAuth", (PyCFunction) PyIscsiNode_setAuth,
		METH_VARARGS|METH_KEYWORDS,
		"Set authentication information"},
	{"getAuth", (PyCFunction) PyIscsiNode_getAuth, METH_NOARGS,
		"Get authentication information"},
	{"setParameter", (PyCFunction) PyIscsiNode_setParameter,
		METH_VARARGS|METH_KEYWORDS,
		"Set an iscsi node parameter"},
	{"getParameter", (PyCFunction) PyIscsiNode_getParameter,
		METH_VARARGS|METH_KEYWORDS,
		"Get an iscsi node parameter"},
	{NULL}
};

PyTypeObject PyIscsiNode_Type = {
	PyVarObject_HEAD_INIT(NULL, 0)
	.tp_name = "libiscsi.node",
	.tp_basicsize = sizeof (PyIscsiNode),
	.tp_getset = PyIscsiNode_getseters,
	.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE
#ifndef IS_PY3K
	| Py_TPFLAGS_CHECKTYPES
#endif
	,
	.tp_methods = PyIscsiNode_methods,
	.tp_richcompare = (richcmpfunc)PyIscsiNode_richcompare,
	.tp_init = PyIscsiNode_init,
	.tp_str = PyIscsiNode_str,
	.tp_new = PyType_GenericNew,
	.tp_doc = "The iscsi node contains iscsi node information.",
};

/***************************************************************************/

static PyObject *pylibiscsi_discover_sendtargets(PyObject *self,
						PyObject *args, PyObject *kwds)
{
	char *kwlist[] = {"address", "port", "authinfo", NULL};
	const char *address = NULL;
	int i, nr_found, port = 3260;
	PyObject *authinfo_arg = NULL;
	const struct libiscsi_auth_info *authinfo = NULL;
	struct libiscsi_node *found_nodes;
	PyObject* found_node_list;
	int ret;

	if (!PyArg_ParseTupleAndKeywords(args, kwds, "s|iO",
					kwlist, &address, &port,
					&authinfo_arg))
		return NULL;

	if (authinfo_arg) {
		if (PyObject_IsInstance(authinfo_arg, (PyObject *)
					       &PyIscsiChapAuthInfo_Type)) {
			PyIscsiChapAuthInfo *pyauthinfo =
				(PyIscsiChapAuthInfo *)authinfo_arg;
			authinfo = &pyauthinfo->info;
		} else if (authinfo_arg != Py_None) {
			PyErr_SetString(PyExc_ValueError,
				"invalid authinfo type");
			return NULL;
		}
	}

	Py_BEGIN_ALLOW_THREADS
	ret = libiscsi_discover_sendtargets(context, address, port, authinfo,
					    &nr_found, &found_nodes);
	Py_END_ALLOW_THREADS

	if (ret) {
		PyErr_SetString(PyExc_IOError,
				libiscsi_get_error_string(context));
		return NULL;
	}

	if (nr_found == 0)
		Py_RETURN_NONE;

	found_node_list = PyList_New(nr_found);
	if (!found_node_list)
		return NULL;

	for(i = 0; i < nr_found; i++) {
		PyIscsiNode *pynode;
		
		pynode = PyObject_New(PyIscsiNode, &PyIscsiNode_Type);
		if (!pynode) {
			/* This will deref already added nodes for us */
			Py_DECREF(found_node_list);
			return NULL;
		}
		pynode->node = found_nodes[i];
		PyList_SET_ITEM(found_node_list, i, (PyObject *)pynode);
	}

	return found_node_list;	
}

static PyObject *pylibiscsi_discover_firmware(PyObject *self)
{
	int i, nr_found;
	struct libiscsi_node *found_nodes;
	PyObject* found_node_list;

	if (libiscsi_discover_firmware(context, &nr_found, &found_nodes)) {
		PyErr_SetString(PyExc_IOError,
				libiscsi_get_error_string(context));
		return NULL;
	}

	if (nr_found == 0)
		Py_RETURN_NONE;

	found_node_list = PyList_New(nr_found);
	if (!found_node_list)
		return NULL;

	for(i = 0; i < nr_found; i++) {
		PyIscsiNode *pynode;
		
		pynode = PyObject_New(PyIscsiNode, &PyIscsiNode_Type);
		if (!pynode) {
			/* This will deref already added nodes for us */
			Py_DECREF(found_node_list);
			return NULL;
		}
		pynode->node = found_nodes[i];
		PyList_SET_ITEM(found_node_list, i, (PyObject *)pynode);
	}

	return found_node_list;	
}

static PyObject *pylibiscsi_get_firmware_initiator_name(PyObject *self)
{
	char initiatorname[LIBISCSI_VALUE_MAXLEN];

	if (libiscsi_get_firmware_initiator_name(initiatorname)) {
		PyErr_SetString(PyExc_IOError,
				libiscsi_get_error_string(context));
		return NULL;
	}

	return PYSTR_FROMSTRING(initiatorname);
}

static PyMethodDef pylibiscsi_functions[] = {
	{	"discover_sendtargets",
		(PyCFunction)pylibiscsi_discover_sendtargets,
		METH_VARARGS|METH_KEYWORDS,
		"Do sendtargets discovery and return a list of found nodes)"},
	{	"discover_firmware",
		(PyCFunction)pylibiscsi_discover_firmware, METH_NOARGS,
		"Do firmware discovery and return a list of found nodes)"},
	{	"get_firmware_initiator_name",
		(PyCFunction)pylibiscsi_get_firmware_initiator_name,
		METH_NOARGS,
		"Get initator name (iqn) from firmware"},
	{NULL, NULL}
};

#ifdef IS_PY3K
static struct PyModuleDef libiscsi_def = {
	PyModuleDef_HEAD_INIT,
	"libiscsi",
	NULL,
	-1,
	pylibiscsi_functions,
	NULL,
	NULL,
	NULL,
	NULL
};

PyMODINIT_FUNC PyInit_libiscsi(void)
#else
PyMODINIT_FUNC initlibiscsi(void)
#endif
{
	PyObject *m;

	if (!context) /* We may be called more then once */
		context = libiscsi_init();
	if (!context)
		MODINITERROR;

	if (PyType_Ready(&PyIscsiChapAuthInfo_Type) < 0)
		MODINITERROR;

	if (PyType_Ready(&PyIscsiNode_Type) < 0)
		MODINITERROR;

#ifdef IS_PY3K
	m = PyModule_Create(&libiscsi_def);
#else
	m = Py_InitModule("libiscsi", pylibiscsi_functions);
#endif
	Py_INCREF(&PyIscsiChapAuthInfo_Type);
	PyModule_AddObject(m, "chapAuthInfo", (PyObject *) &PyIscsiChapAuthInfo_Type);
	Py_INCREF(&PyIscsiNode_Type);
	PyModule_AddObject(m, "node", (PyObject *) &PyIscsiNode_Type);
#ifdef IS_PY3K
	return m;
#endif
}