2 * Dolda Connect - Modular multiuser Direct Connect-style client
3 * Copyright (C) 2004 Fredrik Tolf <fredrik@dolda2000.com>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 #include <doldaconnect/uilib.h>
22 #include <doldaconnect/uimisc.h>
23 #include <doldaconnect/utils.h>
28 struct dc_response *resp;
33 static void resptype_del(struct respobj *self)
35 dc_freeresp(self->resp);
36 self->ob_type->tp_free((PyObject *)self);
39 static PyObject *resp_getcode(struct respobj *self)
41 return(Py_BuildValue("i", self->resp->code));
44 static PyObject *resp_gettag(struct respobj *self)
46 return(Py_BuildValue("i", self->resp->tag));
49 static PyObject *resp_getcmd(struct respobj *self)
51 return(PyUnicode_FromWideChar(self->resp->cmdname, wcslen(self->resp->cmdname)));
54 static PyObject *resp_extract(struct respobj *self)
60 ret = PyList_New(self->resp->numlines);
61 for(i = 0; i < self->resp->numlines; i++) {
62 sl = PyList_New(self->resp->rlines[i].argc);
63 for(o = 0; o < self->resp->rlines[i].argc; o++) {
64 c = self->resp->rlines[i].argv[o];
65 PyList_SetItem(sl, o, PyUnicode_FromWideChar(c, wcslen(c)));
67 PyList_SetItem(ret, i, sl);
72 static PyObject *resp_intresp(struct respobj *self)
76 struct dc_intresp *ires;
79 self->resp->curline = 0;
80 while((ires = dc_interpret(self->resp)) != NULL) {
81 sl = PyList_New(ires->argc);
82 for(i = 0; i < ires->argc; i++) {
83 switch(ires->argv[i].type) {
85 PyList_SetItem(sl, i, PyUnicode_FromWideChar(ires->argv[i].val.str, wcslen(ires->argv[i].val.str)));
88 PyList_SetItem(sl, i, PyInt_FromLong(ires->argv[i].val.num));
91 PyList_SetItem(sl, i, PyFloat_FromDouble(ires->argv[i].val.flnum));
94 PyList_SetItem(sl, i, PyLong_FromLongLong(ires->argv[i].val.lnum));
99 PyList_Append(ret, sl);
104 static PyMethodDef respmethods[] = {
105 {"getcode", (PyCFunction)resp_getcode, METH_NOARGS,
106 "Get the numerical code from the response"},
107 {"gettag", (PyCFunction)resp_gettag, METH_NOARGS,
108 "Get the tag from the response"},
109 {"getcmd", (PyCFunction)resp_getcmd, METH_NOARGS,
110 "Get the command name from the response"},
111 {"extract", (PyCFunction)resp_extract, METH_NOARGS,
112 "Extract the lines and columns from the response"},
113 {"intresp", (PyCFunction)resp_intresp, METH_NOARGS,
114 "Interpret all the lines from the response with native datatypes"},
115 {NULL, NULL, 0, NULL}
118 static PyTypeObject resptype = {
119 PyObject_HEAD_INIT(NULL)
120 .tp_name = "dolcon.Response",
121 .tp_basicsize = sizeof(struct respobj),
122 .tp_flags = Py_TPFLAGS_DEFAULT,
123 .tp_doc = "Dolda Connect response objects",
124 .tp_dealloc = (destructor)resptype_del,
125 .tp_methods = respmethods,
128 static struct respobj *makeresp(struct dc_response *resp)
132 new = (struct respobj *)resptype.tp_alloc(&resptype, 0);
137 static PyObject *mod_connect(PyObject *self, PyObject *args)
142 if(!PyArg_ParseTuple(args, "|s", &host))
146 if((fd = dc_connect(host)) < 0) {
147 PyErr_SetFromErrno(PyExc_OSError);
150 return(Py_BuildValue("i", fd));
153 static PyObject *mod_disconnect(PyObject *self, PyObject *args)
162 static PyObject *mod_connected(PyObject *self, PyObject *args)
170 static PyObject *mod_select(PyObject *self, PyObject *args)
176 if(!PyArg_ParseTuple(args, "|i", &timeout))
179 PyErr_SetString(PyExc_RuntimeError, "Not connected");
185 pfd.events |= POLLOUT;
186 if((ret = poll(&pfd, 1, timeout)) < 0) {
191 PyErr_SetFromErrno(PyExc_OSError);
194 if(((pfd.revents & POLLIN) && dc_handleread()) || ((pfd.revents & POLLOUT) && dc_handlewrite())) {
198 PyErr_SetFromErrno(PyExc_OSError);
206 static PyObject *mod_getresp(PyObject *self, PyObject *args)
209 struct dc_response *resp;
212 if(!PyArg_ParseTuple(args, "|i", &tag))
217 resp = dc_gettaggedresp(tag);
220 return((PyObject *)makeresp(resp));
223 static int qcmd_cb(struct dc_response *resp)
225 PyObject *pycb, *args, *ret;
228 args = Py_BuildValue("(N)", makeresp(resp));
229 ret = PyObject_Call(pycb, args, NULL);
236 static PyObject *mod_qcmd(PyObject *self, PyObject *args, PyObject *kwargs)
239 wchar_t **toks, *tok, *cmd;
240 size_t tokssize, toksdata, toksize;
241 PyObject *c, *n, *cb, *ret;
244 tokssize = toksdata = 0;
247 for(i = 0; i < PySequence_Size(args); i++) {
248 if((c = PySequence_GetItem(args, i)) == NULL)
250 if(!PyUnicode_Check(c)) {
251 n = PyUnicode_FromObject(c);
256 tok = smalloc((toksize = (PyUnicode_GetSize(c) + 1)) * sizeof(*tok));
257 tok[PyUnicode_AsWideChar((PyUnicodeObject *)c, tok, toksize)] = L'\0';
265 PyErr_SetString(PyExc_TypeError, "qcmd needs at least 1 argument");
268 addtobuf(toks, NULL);
270 if(PyMapping_HasKeyString(kwargs, "cb")) {
271 cb = PyMapping_GetItemString(kwargs, "cb");
272 if(PyCallable_Check(cb)) {
273 ret = PyInt_FromLong(dc_queuecmd(qcmd_cb, cb, cmd, L"%a", toks, NULL));
275 PyErr_SetString(PyExc_TypeError, "Callback must be callable");
279 ret = PyInt_FromLong(dc_queuecmd(NULL, NULL, cmd, L"%a", toks, NULL));
289 static void login_cb(int err, wchar_t *reason, PyObject *cb)
292 PyObject *args, *pyerr, *pyreason, *ret;
295 case DC_LOGIN_ERR_SUCCESS:
298 case DC_LOGIN_ERR_NOLOGIN:
301 case DC_LOGIN_ERR_SERVER:
304 case DC_LOGIN_ERR_USER:
307 case DC_LOGIN_ERR_CONV:
310 case DC_LOGIN_ERR_AUTHFAIL:
314 pyerr = PyString_FromString(errstr);
316 Py_INCREF(pyreason = Py_None);
318 pyreason = PyUnicode_FromWideChar(reason, wcslen(reason));
319 args = PyTuple_Pack(2, pyerr, pyreason);
320 Py_DECREF(pyerr); Py_DECREF(pyreason);
321 ret = PyObject_Call(cb, args, NULL);
327 static PyObject *mod_loginasync(PyObject *self, PyObject *args, PyObject *kwargs)
331 PyObject *o, *cb, *conv;
336 if(!PyArg_ParseTuple(args, "O|i", &cb, &useauthless))
338 if(!PyCallable_Check(cb)) {
339 PyErr_SetString(PyExc_TypeError, "Callback must be callable");
342 if(PyMapping_HasKeyString(kwargs, "username")) {
343 o = PyMapping_GetItemString(kwargs, "username");
344 username = PyString_AsString(o);
349 if(PyMapping_HasKeyString(kwargs, "conv")) {
350 conv = PyMapping_GetItemString(kwargs, "conv");
351 if(!PyCallable_Check(conv)) {
352 PyErr_SetString(PyExc_TypeError, "Conv callback must be callable");
355 PyErr_SetString(PyExc_NotImplementedError, "Custom conv functions are not yet supported by the Python interface");
359 dc_loginasync(username, useauthless, NULL, (void (*)(int, wchar_t *, void *))login_cb, cb);
363 static PyObject *mod_lexsexpr(PyObject *self, PyObject *args)
365 PyObject *arg, *se, *ret;
366 wchar_t **arr, **ap, *buf;
369 if(!PyArg_ParseTuple(args, "O", &arg))
371 if((se = PyUnicode_FromObject(arg)) == NULL)
373 buf = smalloc((bufsize = (PyUnicode_GetSize(se) + 1)) * sizeof(*buf));
374 buf[PyUnicode_AsWideChar((PyUnicodeObject *)se, buf, bufsize)] = L'\0';
375 arr = dc_lexsexpr(buf);
380 for(ap = arr; *ap; ap++)
381 PyList_Append(ret, PyUnicode_FromWideChar(*ap, wcslen(*ap)));
387 static PyObject *mod_wantwrite(PyObject *self)
395 static PyObject *mod_checkproto(PyObject *self, PyObject *args)
398 struct respobj *resp;
402 if(!PyArg_ParseTuple(args, "O|i", &tmp, &version))
404 if(!PyObject_TypeCheck(tmp, &resptype)) {
405 PyErr_SetString(PyExc_TypeError, "first argument must be a response object");
408 resp = (struct respobj *)tmp;
409 if(dc_checkprotocol(resp->resp, version))
415 static PyMethodDef methods[] = {
416 {"connect", mod_connect, METH_VARARGS,
417 "Connect to a Dolda Connect server"},
418 {"disconnect", mod_disconnect, METH_VARARGS,
419 "Disconnect from the server"},
420 {"connected", mod_connected, METH_VARARGS,
421 "Return a boolean indicated whether there currently is a connection to a server"},
422 {"select", mod_select, METH_VARARGS,
423 "Handle data from the server connection, optionally blocking until something happens"},
424 {"getresp", mod_getresp, METH_VARARGS,
425 "Get a queued response object"},
426 {"qcmd", (PyCFunction)mod_qcmd, METH_VARARGS | METH_KEYWORDS,
427 "Queue a command to be sent to the server"},
428 {"loginasync", (PyCFunction)mod_loginasync, METH_VARARGS | METH_KEYWORDS,
429 "Perform an asynchronous login procedure"},
430 {"lexsexpr", mod_lexsexpr, METH_VARARGS,
431 "Use a standard algorithm to lex a search expression"},
432 {"wantwrite", (PyCFunction)mod_wantwrite, METH_NOARGS,
433 "Return a boolean indicating whether there is output to be fed to the server"},
434 {"checkproto", (PyCFunction)mod_checkproto, METH_VARARGS,
435 "Check so that the connect stanza returned by the server indicates support for the correct revision of the protocol"},
436 {NULL, NULL, 0, NULL}
439 PyMODINIT_FUNC initdolmod(void)
443 if(PyType_Ready(&resptype) < 0)
445 m = Py_InitModule("dolmod", methods);
446 Py_INCREF(&resptype);
447 PyModule_AddObject(m, "Response", (PyObject *)&resptype);
448 PyModule_AddObject(m, "latest", Py_BuildValue("i", DC_LATEST));