python.c

The major functionality added in this release includes: - Rootless mode in X11 - Widget Templt

pysH_Sinfo (server_obj * self, PyObject * args)
{
	PyObject *map;

	CHECK_SERVER (self);
	if (!PyArg_ParseTuple (args, ""))
		return NULL;

	map = PyDict_New ();

#define F(x,y) PyDict_SetItemString (map, x, PyString_FromString(self->serv->y))
	F ("name", servername);
	F ("hostname", hostname);
	F ("password", password);
	F ("nick", nick);
#undef F
#define F(x, y) PyDict_SetItemString (map, x, PyInt_FromLong(self->serv->y))
	F ("port", port);
#undef F
	return map;
}

static PyObject *
pysH_Einfo (sess_obj * self, PyObject * args)
{
	PyObject *map;

	CHECK_SESS (self);
	if (!PyArg_ParseTuple (args, ""))
		return NULL;

	map = PyDict_New ();

#define F(x, y) PyDict_SetItemString (map, x, PyString_FromString(self->sess->y))
	F ("channel", channel);
	F ("waitchannel", waitchannel);
	F ("nick", server->nick);
	F ("willjoinchannel", willjoinchannel);
	F ("channelkey", channelkey);
#undef F
	/* Now for the numbers ... --AGL */
#define F(x, y) PyDict_SetItemString (map, x, PyInt_FromLong(self->sess->y))
	F ("limit", limit);
	F ("ops", ops);
	F ("total", total);
	F ("type", type);
	F ("is_shell", type == SESS_SHELL);
	F ("is_tab", is_tab);
	F ("is_dialog", type == SESS_DIALOG);
	F ("is_server", type == SESS_SERVER);
#undef F

	PyDict_SetItemString (map, "servername",
								 PyString_FromString (self->sess->server->hostname));
	PyDict_SetItemString (map, "serverport",
								 PyInt_FromLong (self->sess->server->port));
	PyDict_SetItemString (map, "servernick",
								 PyString_FromString (self->sess->server->nick));

	return map;
}

static PyObject *
pysH_Eget_users (sess_obj * self, PyObject * args)
{
	PyObject *map, *tuple;
	struct User *cur;
	GSList *list;

	g_assert (self);

	CHECK_SESS (self);
	if (!PyArg_ParseTuple (args, ""))
		return NULL;

	map = PyDict_New ();

	list = self->sess->userlist;
	while (list)
	{
		cur = (struct User *) list->data;
		tuple = PyTuple_New (3);
		if (cur->hostname)
			PyTuple_SetItem (tuple, 0, PyString_FromString (cur->hostname));
		else
			PyTuple_SetItem (tuple, 0, PyString_FromString ("FETCHING"));
		PyTuple_SetItem (tuple, 1, PyInt_FromLong (cur->op));
		PyTuple_SetItem (tuple, 2, PyInt_FromLong (cur->voice));
		PyDict_SetItemString (map, cur->nick, tuple);

		list = list->next;
	}

	return map;
}

static PyObject *
pysH_register (xchat_obj * self, PyObject * args)
{
	char *name;
	char *desc;

	if (!PyArg_ParseTuple (args, "ss", &name, &desc))
		return NULL;

	g_assert (name);
	g_assert (desc);
	self->name = g_strdup (name);
	self->desc = g_strdup (desc);

	Py_XINCREF (Py_None);
	return Py_None;
}

static int
python_timeout (timeout_hook* hook)
{

	PyObject *arglist, *retobj;
	arglist = Py_BuildValue ("()");

	PyThreadState_Swap (hook->xchat->state);
	retobj = PyEval_CallObject (hook->cback, arglist);
	if (PyErr_Occurred ())
		PyErr_Print ();

	Py_XDECREF (arglist);
	Py_XDECREF (retobj);

	Py_XDECREF (hook->cback);
	hook->xchat->timeout_hooks = g_slist_remove (hook->xchat->timeout_hooks, hook);
	g_free(hook);

	return 0;
}

static PyObject *
pysH_hook_timeout (xchat_obj * self, PyObject * args)
{
	PyObject *cback;
	long timeout;
	timeout_hook *hook;

	if (!PyArg_ParseTuple (args, "lO", &timeout, &cback))
		return NULL;

	if (!PyCallable_Check (cback))
	{
		PyErr_SetString (PyExc_TypeError, "parameter must be callable");
		return NULL;
	}

	Py_XINCREF (cback);

	hook = g_new0 (timeout_hook, 1);
	hook->xchat = self;
	hook->cback = cback;
	hook->iotag = fe_timeout_add(timeout, python_timeout, hook);
	self->timeout_hooks = g_slist_prepend (self->timeout_hooks, hook);

	Py_XINCREF (Py_None);
	return Py_None;
}

static PyObject *
pysH_hook_signal (xchat_obj * self, PyObject * args)
{
	char *name;
	PyObject *cback;
	int signum;
	sig_hook *sh;

	if (!PyArg_ParseTuple (args, "sO", &name, &cback))
		return NULL;

	if (!PyCallable_Check (cback))
	{
		PyErr_SetString (PyExc_TypeError, "parameter must be callable");
		return NULL;
	}

	signum = find_signal_from_name (name);
	if (signum == -1)
	{
		PyErr_SetString (PyExc_LookupError, "unknown signal name");
		return NULL;
	}

	Py_XINCREF (cback);

	sh = g_new0 (sig_hook, 1);
	sh->xchat = self;
	sh->cback = cback;
	sh->sig = g_new0 (struct xp_signal, 1);
	sh->sig->signal = signum;
	sh->sig->data = sh;
	sh->sig->callback = pys_stock_signal_handler;
	hook_signal (sh->sig);
	self->sig_hooks = g_slist_prepend (self->sig_hooks, sh);

	Py_XINCREF (Py_None);
	return Py_None;
}

static PyObject *
pysH_Dget_string (data_obj * self, PyObject * args)
{
	if (!PyArg_ParseTuple (args, ""))
		return NULL;

	return PyString_FromString ((char *) self->data);
}

static PyObject *
pysH_Dget_session (data_obj * self, PyObject * args)
{
	PyObject *sess;

	if (!PyArg_ParseTuple (args, ""))
		return NULL;

	sess = _sess_new ();
	((sess_obj *) sess)->sess = self->data;

	return sess;
}

static PyObject *
pysH_Dget_server (data_obj * self, PyObject * args)
{
	PyObject *serv;

	if (!PyArg_ParseTuple (args, ""))
		return NULL;

	serv = _server_new ();
	((server_obj *) serv)->serv = self->data;

	return serv;
}

static PyObject *
pysH_Dget_number (data_obj * self, PyObject * args)
{
	int num;

	g_assert (sizeof (int) == sizeof (void *));

	if (!PyArg_ParseTuple (args, ""))
		return NULL;

	memcpy (&num, &self->data, sizeof (int));
	return PyInt_FromLong (num);
}

PyObject *
pysH_Eset (sess_obj * self, PyObject * args)
{
	char *host, *chan, *nick;
	int port;
	GSList *cur;
	struct session *sess;

	if (!PyArg_ParseTuple (args, "siss", &host, &port, &nick, &chan))
		return NULL;

	cur = sess_list;
	while (cur)
	{
		sess = cur->data;
		if (sess->server->port == port &&
			 strcasecmp (sess->server->hostname, host) == 0 &&
			 strcasecmp (sess->server->nick, nick) == 0 &&
			 strcasecmp (sess->channel, chan) == 0)
		{
			self->sess = sess;
			break;
		}
		cur = cur->next;
	}

	if (!cur)
	{
		PyErr_SetString (PyExc_LookupError, "unknown session");
		return NULL;
	}

	Py_XINCREF (Py_None);
	return Py_None;
}

static PyObject *
pysH_Sset (server_obj * self, PyObject * args)
{
	char *host, *nick;
	int port;
	GSList *cur;
	struct server *serv;

	if (!PyArg_ParseTuple (args, "sis", &host, &port, &nick))
		return NULL;

	cur = serv_list;
	while (cur)
	{
		serv = cur->data;

		if (serv->port == port &&
			 strcasecmp (serv->hostname, host) == 0 &&
			 strcasecmp (serv->nick, nick) == 0)
		{
			self->serv = serv;
			break;
		}

		cur = cur->next;
	}
	if (!cur)
	{
		PyErr_SetString (PyExc_LookupError, "unknown server");
		return NULL;
	}

	Py_XINCREF (Py_None);
	return Py_None;
}

static PyObject *
pysH_Eget_server (sess_obj * self, PyObject * args)
{
	PyObject *serv;

	CHECK_SESS (self);
	if (!PyArg_ParseTuple (args, ""))
		return NULL;

	serv = _server_new ();
	((server_obj *) serv)->serv = self->sess->server;

	return serv;
}

static PyObject *
pysH_info (xchat_obj * self, PyObject * args)
{
	PyObject *map;

	if (!PyArg_ParseTuple (args, ""))
		return NULL;

	map = PyDict_New ();

#define F(x,y) PyDict_SetItemString (map, x, PyString_FromString(y))
	F ("version", VERSION);
#undef F

#ifdef USE_GDKPIXBUF
	PyDict_SetItemString (map, "Gdk-Pixbuf", PyString_FromString ("yes"));
#else
	PyDict_SetItemString (map, "Gdk-Pixbuf", PyString_FromString ("no"));
#endif

#ifdef USE_GNOME
	PyDict_SetItemString (map, "GNOME", PyString_FromString ("yes"));
#else
	PyDict_SetItemString (map, "GNOME", PyString_FromString ("no"));
#endif

#ifdef USE_PERL
	PyDict_SetItemString (map, "Perl", PyString_FromString ("yes"));
#else
	PyDict_SetItemString (map, "Perl", PyString_FromString ("no"));
#endif

#ifdef USE_PLUGIN
	PyDict_SetItemString (map, "Plugin", PyString_FromString ("yes"));
#else
	PyDict_SetItemString (map, "Plugin", PyString_FromString ("no"));
#endif

#ifdef ENABLE_NLS
	PyDict_SetItemString (map, "NLS", PyString_FromString ("yes"));
#else
	PyDict_SetItemString (map, "NLS", PyString_FromString ("no"));
#endif

#ifdef SOCKS
	PyDict_SetItemString (map, "Socks", PyString_FromString ("yes"));
#else
	PyDict_SetItemString (map, "Socks", PyString_FromString ("no"));
#endif

	return map;
}

static PyMethodDef _xchat_methods[] = {
	{"get_servers", (PyCFunction) pysH_get_servers, METH_VARARGS},
	{"get_sessions", (PyCFunction) pysH_get_sessions, METH_VARARGS},
	
		{"get_current_session", (PyCFunction) pysH_get_current_session,
	 METH_VARARGS},
	{"hook_command", (PyCFunction) pysH_hook_command, METH_VARARGS},
	{"register", (PyCFunction) pysH_register, METH_VARARGS},
	{"hook_signal", (PyCFunction) pysH_hook_signal, METH_VARARGS},
	{"hook_timeout", (PyCFunction) pysH_hook_timeout, METH_VARARGS},
	{"info", (PyCFunction) pysH_info, METH_VARARGS},
	{NULL, NULL}
};

static PyMethodDef _server_methods[] = {
	{"send", (PyCFunction) pysH_Ssend, METH_VARARGS},
	{"info", (PyCFunction) pysH_Sinfo, METH_VARARGS},
	{"set", (PyCFunction) pysH_Sset, METH_VARARGS},
	{NULL, NULL}
};

static PyMethodDef _sess_methods[] = {
	{"print_text", (PyCFunction) pysH_Eprint_text, METH_VARARGS},
	{"handle_cmd", (PyCFunction) pysH_Ehandle_cmd, METH_VARARGS},
	{"get_users", (PyCFunction) pysH_Eget_users, METH_VARARGS},
	{"info", (PyCFunction) pysH_Einfo, METH_VARARGS},
	{"set", (PyCFunction) pysH_Eset, METH_VARARGS},
	{"get_server", (PyCFunction) pysH_Eget_server, METH_VARARGS},
	{NULL, NULL}
};

static PyMethodDef _data_methods[] = {
	{"get_string", (PyCFunction) pysH_Dget_string, METH_VARARGS},
	{"get_server", (PyCFunction) pysH_Dget_server, METH_VARARGS},
	{"get_session", (PyCFunction) pysH_Dget_session, METH_VARARGS},
	{"get_number", (PyCFunction) pysH_Dget_number, METH_VARARGS},
	{NULL, NULL}
};

static PyObject *
_server_getaddr (server_obj * self, char *name)
{
	return Py_FindMethod (_server_methods, (PyObject *) self, name);
}

static PyObject *
_xchat_getaddr (xchat_obj * self, char *name)
{
	return Py_FindMethod (_xchat_methods, (PyObject *) self, name);
}

static PyObject *
_sess_getaddr (sess_obj * self, char *name)
{
	return Py_FindMethod (_sess_methods, (PyObject *) self, name);
}

static PyObject *
_data_getaddr (sess_obj * self, char *name)
{
	return Py_FindMethod (_data_methods, (PyObject *) self, name);
}

static PyMethodDef _classes[] = {
	{"XChat", _xchat_obj_op, 0},
	{"Server", _server_obj_op, 0},
	{"Session", _sess_obj_op, 0},
	{"Data", _data_obj_op, 0},
	{NULL, NULL}
};

static void
pys_autoloadfile (char *file)
{
	char *words[3] = {"", "", file};
	pys_load(NULL, NULL, words, NULL);
}

void
pys_init ()
{
	pys_list = NULL;

	Py_SetProgramName ("xchat");
	Py_Initialize ();

	XChat_Type.ob_type = &PyType_Type;
	Server_Type.ob_type = &PyType_Type;

	Py_InitModule ("XChat", _classes);
	if (PyErr_Occurred ())
		g_assert_not_reached ();

	pys_master = Py_NewInterpreter ();
	Py_InitModule ("XChat", _classes);

	for_files (get_xdir (), "*.py", pys_autoloadfile);
}

int
pys_pkill (struct session *sess, char *tbuf, char **word, char **word_eol)
{
	GSList *cur;
	xchat_obj *obj;

	if (!word[2] || word[2][0] == 0)
		return FALSE;

	cur = pys_list;
	while (cur)
	{
		obj = cur->data;
		if (obj->name)
		{
			if (strcmp (obj->name, word[2]) == 0)
				break;
		}
		cur = cur->next;
	}
	if (!cur)
	{
		PrintText (sess, "No such python script\n");
		return FALSE;
	}

	PyThreadState_Swap (obj->state);
	Py_EndInterpreter (obj->state);
	PyThreadState_Swap (pys_master);

	return TRUE;
}

int
pys_plist (struct session *sess, char *tbuf, char **word, char **word_eol)
{
	GSList *cur;
	xchat_obj *obj;
	gchar *buf;

	cur = pys_list;
	while (cur)
	{
		obj = cur->data;
		buf = g_strdup_printf ("%s: %s\n", obj->name, obj->desc);
		PrintText (sess, buf);
		g_free (buf);

		cur = cur->next;
	}

	return TRUE;
}

int
pys_cmd_handle (char *cmd, struct session *sess, char **word)
{
	GSList *cur;
	xchat_obj *xo;
	cmd_hook *hook = NULL;
	sess_obj *sess_o;
	PyObject *tuple, *arglist, *retobj;
	int c, x, y;

	cur = pys_list;
	while (cur)
	{
		xo = cur->data;
		hook = find_hook (xo->cmd_hooks, cmd);
		if (hook)
			break;
		cur = cur->next;
	}
	if (!hook)
		return 0;

	sess_o = (sess_obj *) _sess_new ();
	sess_o->sess = sess;

	/* Count the number of args */
	c = 1;
	while (word[c] && word[c][0] != 0)
		c++;
	c--;

	tuple = PyTuple_New (c);
	c++;
	for (x = 1, y = 0; x < c; x++, y++)
		PyTuple_SetItem (tuple, y, PyString_FromString (word[x]));

	arglist = Py_BuildValue ("(s,O,O)", cmd, sess_o, tuple);

	PyThreadState_Swap(hook->xchat->state);
	retobj = PyEval_CallObject (hook->cback, arglist);
	if (PyErr_Occurred ())
		PyErr_Print ();

	Py_XDECREF (arglist);
	Py_XDECREF (sess_o);
	Py_XDECREF (tuple);
	Py_XDECREF (retobj);

	return TRUE;
}

/* Note: this is also called from pys_autoloadfile() with funky
   arguments, be careful */
int
pys_load (struct session *sess, char *tbuf, char **word, char **word_eol)
{
	FILE *in;
	PyThreadState *tstate;

	if (!word[2] || word[2][0] == 0)
		return FALSE;
	if (strcmp (word[2], "DEBUG") == 0)
	{
		printf ("*** Python code - running interactive loop...\n");
		in = fopen ("test.py", "r");
		g_assert (in);
		PyRun_InteractiveLoop (in, "test.py");
		return TRUE;
	}

	in = fopen (word[2], "r");
	if (!in)
	{
		PrintText (current_tab,
					  "\017Python script file not found or could not be opened\n");
		return FALSE;
	}
	if ((tstate = Py_NewInterpreter ()) == NULL)
	{
		PrintText (current_tab, "\017Python interpreter could not be created\n");
		fclose(in);
		return TRUE;
	}
	Py_InitModule ("XChat", _classes);
	if (PyErr_Occurred ())
	{
		PrintText (current_tab,
					  "\017Python interpreter failed to import XChat\n");
		fclose(in);
		return TRUE;
	}
	PyRun_SimpleFile (in, word[2]);
	if (PyErr_Occurred ())
	{
		PrintText (current_tab,
					  "\017Python interpreter failed to load script\n");
		Py_EndInterpreter (tstate);
		fclose(in);
		return TRUE;
	}

	fclose(in);
	return TRUE;
}

void
pys_kill ()
{
	PyThreadState_Swap (pys_master);
	Py_Finalize ();
}