Clarified the dscp-tos documentation a bit.
[doldaconnect.git] / lib / python / dolmod.c
1 /*
2  *  Dolda Connect - Modular multiuser Direct Connect-style client
3  *  Copyright (C) 2004 Fredrik Tolf <fredrik@dolda2000.com>
4  *  
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.
9  *  
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.
14  *  
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
18 */
19 #include <Python.h>
20 #include <sys/poll.h>
21 #include <doldaconnect/uilib.h>
22 #include <doldaconnect/uimisc.h>
23 #include <doldaconnect/utils.h>
24 #include <wchar.h>
25
26 struct respobj {
27     PyObject_HEAD
28     struct dc_response *resp;
29 };
30
31 static int fd = -1;
32
33 static void resptype_del(struct respobj *self)
34 {
35     dc_freeresp(self->resp);
36     self->ob_type->tp_free((PyObject *)self);
37 }
38
39 static PyObject *resp_getcode(struct respobj *self)
40 {
41     return(Py_BuildValue("i", self->resp->code));
42 }
43
44 static PyObject *resp_gettag(struct respobj *self)
45 {
46     return(Py_BuildValue("i", self->resp->tag));
47 }
48
49 static PyObject *resp_getcmd(struct respobj *self)
50 {
51     return(PyUnicode_FromWideChar(self->resp->cmdname, wcslen(self->resp->cmdname)));
52 }
53
54 static PyObject *resp_extract(struct respobj *self)
55 {
56     int i, o;
57     PyObject *ret, *sl;
58     wchar_t *c;
59     
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)));
66         }
67         PyList_SetItem(ret, i, sl);
68     }
69     return(ret);
70 }
71
72 static PyObject *resp_intresp(struct respobj *self)
73 {
74     int i;
75     PyObject *ret, *sl;
76     struct dc_intresp *ires;
77     
78     ret = PyList_New(0);
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) {
84             case 1:
85                 PyList_SetItem(sl, i, PyUnicode_FromWideChar(ires->argv[i].val.str, wcslen(ires->argv[i].val.str)));
86                 break;
87             case 2:
88                 PyList_SetItem(sl, i, PyInt_FromLong(ires->argv[i].val.num));
89                 break;
90             case 3:
91                 PyList_SetItem(sl, i, PyFloat_FromDouble(ires->argv[i].val.flnum));
92                 break;
93             case 4:
94                 PyList_SetItem(sl, i, PyLong_FromLongLong(ires->argv[i].val.lnum));
95                 break;
96             }
97         }
98         dc_freeires(ires);
99         PyList_Append(ret, sl);
100     }
101     return(ret);
102 }
103
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}
116 };
117
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,
126 };
127
128 static struct respobj *makeresp(struct dc_response *resp)
129 {
130     struct respobj *new;
131     
132     new = (struct respobj *)resptype.tp_alloc(&resptype, 0);
133     new->resp = resp;
134     return(new);
135 }
136
137 static PyObject *mod_connect(PyObject *self, PyObject *args)
138 {
139     char *host;
140     
141     host = NULL;
142     if(!PyArg_ParseTuple(args, "|s", &host))
143         return(NULL);
144     if(fd >= 0)
145         dc_disconnect();
146     if((fd = dc_connect(host)) < 0) {
147         PyErr_SetFromErrno(PyExc_OSError);
148         return(NULL);
149     }
150     return(Py_BuildValue("i", fd));
151 }
152
153 static PyObject *mod_disconnect(PyObject *self, PyObject *args)
154 {
155     if(fd != -1) {
156         dc_disconnect();
157         fd = -1;
158     }
159     Py_RETURN_NONE;
160 }
161
162 static PyObject *mod_connected(PyObject *self, PyObject *args)
163 {
164     if(fd == -1)
165         Py_RETURN_FALSE;
166     else
167         Py_RETURN_TRUE;
168 }
169
170 static PyObject *mod_select(PyObject *self, PyObject *args)
171 {
172     struct pollfd pfd;
173     int timeout, ret;
174     
175     timeout = -1;
176     if(!PyArg_ParseTuple(args, "|i", &timeout))
177         return(NULL);
178     if(fd < 0) {
179         PyErr_SetString(PyExc_RuntimeError, "Not connected");
180         return(NULL);
181     }
182     pfd.fd = fd;
183     pfd.events = POLLIN;
184     if(dc_wantwrite())
185         pfd.events |= POLLOUT;
186     if((ret = poll(&pfd, 1, timeout)) < 0) {
187         if(errno == EINTR)
188             Py_RETURN_FALSE;
189         dc_disconnect();
190         fd = -1;
191         PyErr_SetFromErrno(PyExc_OSError);
192         return(NULL);
193     }
194     if(((pfd.revents & POLLIN) && dc_handleread()) || ((pfd.revents & POLLOUT) && dc_handlewrite())) {
195         fd = -1;
196         if(errno == 0)
197             Py_RETURN_FALSE;
198         PyErr_SetFromErrno(PyExc_OSError);
199         return(NULL);
200     }
201     if(ret > 0)
202         Py_RETURN_TRUE;
203     Py_RETURN_FALSE;
204 }
205
206 static PyObject *mod_getresp(PyObject *self, PyObject *args)
207 {
208     int tag;
209     struct dc_response *resp;
210     
211     tag = -1;
212     if(!PyArg_ParseTuple(args, "|i", &tag))
213         return(NULL);
214     if(tag == -1)
215         resp = dc_getresp();
216     else
217         resp = dc_gettaggedresp(tag);
218     if(resp == NULL)
219         Py_RETURN_NONE;
220     return((PyObject *)makeresp(resp));
221 }
222
223 static int qcmd_cb(struct dc_response *resp)
224 {
225     PyObject *pycb, *args, *ret;
226     
227     pycb = resp->data;
228     args = Py_BuildValue("(N)", makeresp(resp));
229     ret = PyObject_Call(pycb, args, NULL);
230     Py_DECREF(args);
231     Py_DECREF(ret);
232     Py_DECREF(pycb);
233     return(2);
234 }
235
236 static PyObject *mod_qcmd(PyObject *self, PyObject *args, PyObject *kwargs)
237 {
238     int i;
239     wchar_t **toks, *tok, *cmd;
240     size_t tokssize, toksdata, toksize;
241     PyObject *c, *n, *cb, *ret;
242     
243     toks = NULL;
244     tokssize = toksdata = 0;
245     cmd = NULL;
246     ret = NULL;
247     for(i = 0; i < PySequence_Size(args); i++) {
248         if((c = PySequence_GetItem(args, i)) == NULL)
249             goto out;
250         if(!PyUnicode_Check(c)) {
251             n = PyUnicode_FromObject(c);
252             Py_DECREF(c);
253             if((c = n) == NULL)
254                 goto out;
255         }
256         tok = smalloc((toksize = (PyUnicode_GetSize(c) + 1)) * sizeof(*tok));
257         tok[PyUnicode_AsWideChar((PyUnicodeObject *)c, tok, toksize)] = L'\0';
258         Py_DECREF(c);
259         if(cmd == NULL)
260             cmd = tok;
261         else
262             addtobuf(toks, tok);
263     }
264     if(cmd == NULL) {
265         PyErr_SetString(PyExc_TypeError, "qcmd needs at least 1 argument");
266         goto out;
267     }
268     addtobuf(toks, NULL);
269     ret = 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));
274         } else {
275             PyErr_SetString(PyExc_TypeError, "Callback must be callable");
276             Py_DECREF(cb);
277         }
278     } else {
279         ret = PyInt_FromLong(dc_queuecmd(NULL, NULL, cmd, L"%a", toks, NULL));
280     }
281
282 out:
283     dc_freewcsarr(toks);
284     if(cmd != NULL)
285         free(cmd);
286     return(ret);
287 }
288
289 static void login_cb(int err, wchar_t *reason, PyObject *cb)
290 {
291     char *errstr;
292     PyObject *args, *pyerr, *pyreason, *ret;
293     
294     switch(err) {
295     case DC_LOGIN_ERR_SUCCESS:
296         errstr = "success";
297         break;
298     case DC_LOGIN_ERR_NOLOGIN:
299         errstr = "nologin";
300         break;
301     case DC_LOGIN_ERR_SERVER:
302         errstr = "server";
303         break;
304     case DC_LOGIN_ERR_USER:
305         errstr = "user";
306         break;
307     case DC_LOGIN_ERR_CONV:
308         errstr = "conv";
309         break;
310     case DC_LOGIN_ERR_AUTHFAIL:
311         errstr = "authfail";
312         break;
313     default:
314         errstr = "unknown";
315         break;
316     }
317     pyerr = PyString_FromString(errstr);
318     if(reason == NULL)
319         Py_INCREF(pyreason = Py_None);
320     else
321         pyreason = PyUnicode_FromWideChar(reason, wcslen(reason));
322     args = PyTuple_Pack(2, pyerr, pyreason);
323     Py_DECREF(pyerr); Py_DECREF(pyreason);
324     ret = PyObject_Call(cb, args, NULL);
325     Py_DECREF(cb);
326     Py_DECREF(args);
327     Py_DECREF(ret);
328 }
329
330 static PyObject *mod_loginasync(PyObject *self, PyObject *args, PyObject *kwargs)
331 {
332     int useauthless;
333     char *username;
334     PyObject *o, *cb, *conv;
335     
336     username = NULL;
337     conv = NULL;
338     useauthless = 1;
339     if(!PyArg_ParseTuple(args, "O|i", &cb, &useauthless))
340         return(NULL);
341     if(!PyCallable_Check(cb)) {
342         PyErr_SetString(PyExc_TypeError, "Callback must be callable");
343         return(NULL);
344     }
345     if(PyMapping_HasKeyString(kwargs, "username")) {
346         o = PyMapping_GetItemString(kwargs, "username");
347         username = PyString_AsString(o);
348         Py_DECREF(o);
349         if(username == NULL)
350             return(NULL);
351     }
352     if(PyMapping_HasKeyString(kwargs, "conv")) {
353         conv = PyMapping_GetItemString(kwargs, "conv");
354         if(!PyCallable_Check(conv)) {
355             PyErr_SetString(PyExc_TypeError, "Conv callback must be callable");
356             return(NULL);
357         }
358         PyErr_SetString(PyExc_NotImplementedError, "Custom conv functions are not yet supported by the Python interface");
359         return(NULL);
360     }
361     Py_INCREF(cb);
362     dc_loginasync(username, useauthless, NULL, (void (*)(int, wchar_t *, void *))login_cb, cb);
363     Py_RETURN_NONE;
364 }
365
366 static PyObject *mod_lexsexpr(PyObject *self, PyObject *args)
367 {
368     PyObject *arg, *se, *ret;
369     wchar_t **arr, **ap, *buf;
370     size_t bufsize;
371     
372     if(!PyArg_ParseTuple(args, "O", &arg))
373         return(NULL);
374     if((se = PyUnicode_FromObject(arg)) == NULL)
375         return(NULL);
376     buf = smalloc((bufsize = (PyUnicode_GetSize(se) + 1)) * sizeof(*buf));
377     buf[PyUnicode_AsWideChar((PyUnicodeObject *)se, buf, bufsize)] = L'\0';
378     arr = dc_lexsexpr(buf);
379     free(buf);
380     Py_DECREF(se);
381     ret = PyList_New(0);
382     if(arr != NULL) {
383         for(ap = arr; *ap; ap++)
384             PyList_Append(ret, PyUnicode_FromWideChar(*ap, wcslen(*ap)));
385         dc_freewcsarr(arr);
386     }
387     return(ret);
388 }
389
390 static PyObject *mod_wantwrite(PyObject *self)
391 {
392     if(dc_wantwrite())
393         Py_RETURN_TRUE;
394     else
395         Py_RETURN_FALSE;
396 }
397
398 static PyObject *mod_checkproto(PyObject *self, PyObject *args)
399 {
400     PyObject *tmp;
401     struct respobj *resp;
402     int version;
403     
404     version = DC_LATEST;
405     if(!PyArg_ParseTuple(args, "O|i", &tmp, &version))
406         return(NULL);
407     if(!PyObject_TypeCheck(tmp, &resptype)) {
408         PyErr_SetString(PyExc_TypeError, "first argument must be a response object");
409         return(NULL);
410     }
411     resp = (struct respobj *)tmp;
412     if(dc_checkprotocol(resp->resp, version))
413         Py_RETURN_FALSE;
414     else
415         Py_RETURN_TRUE;
416 }
417
418 static PyMethodDef methods[] = {
419     {"connect", mod_connect, METH_VARARGS,
420      "Connect to a Dolda Connect server"},
421     {"disconnect", mod_disconnect, METH_VARARGS,
422      "Disconnect from the server"},
423     {"connected", mod_connected, METH_VARARGS,
424      "Return a boolean indicated whether there currently is a connection to a server"},
425     {"select", mod_select, METH_VARARGS,
426      "Handle data from the server connection, optionally blocking until something happens"},
427     {"getresp", mod_getresp, METH_VARARGS,
428      "Get a queued response object"},
429     {"qcmd", (PyCFunction)mod_qcmd, METH_VARARGS | METH_KEYWORDS,
430      "Queue a command to be sent to the server"},
431     {"loginasync", (PyCFunction)mod_loginasync, METH_VARARGS | METH_KEYWORDS,
432      "Perform an asynchronous login procedure"},
433     {"lexsexpr", mod_lexsexpr, METH_VARARGS,
434      "Use a standard algorithm to lex a search expression"},
435     {"wantwrite", (PyCFunction)mod_wantwrite, METH_NOARGS,
436      "Return a boolean indicating whether there is output to be fed to the server"},
437     {"checkproto", (PyCFunction)mod_checkproto, METH_VARARGS,
438      "Check so that the connect stanza returned by the server indicates support for the correct revision of the protocol"},
439     {NULL, NULL, 0, NULL}
440 };
441
442 PyMODINIT_FUNC initdolmod(void)
443 {
444     PyObject *m;
445     
446     if(PyType_Ready(&resptype) < 0)
447         return;
448     m = Py_InitModule("dolmod", methods);
449     Py_INCREF(&resptype);
450     PyModule_AddObject(m, "Response", (PyObject *)&resptype);
451     PyModule_AddObject(m, "latest", Py_BuildValue("i", DC_LATEST));
452     dc_init();
453 }