talloc: use the system pytalloc-util for python3 as well
[sfrench/samba-autobuild/.git] / lib / tevent / pytevent.c
1 /*
2    Unix SMB/CIFS implementation.
3    Python bindings for tevent
4
5    Copyright (C) Jelmer Vernooij 2010
6
7      ** NOTE! The following LGPL license applies to the tevent
8      ** library. This does NOT imply that all of Samba is released
9      ** under the LGPL
10
11    This library is free software; you can redistribute it and/or
12    modify it under the terms of the GNU Lesser General Public
13    License as published by the Free Software Foundation; either
14    version 3 of the License, or (at your option) any later version.
15
16    This library is distributed in the hope that it will be useful,
17    but WITHOUT ANY WARRANTY; without even the implied warranty of
18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19    Lesser General Public License for more details.
20
21    You should have received a copy of the GNU Lesser General Public
22    License along with this library; if not, see <http://www.gnu.org/licenses/>.
23 */
24
25 #include <Python.h>
26 #include "replace.h"
27 #include <tevent.h>
28
29 #if PY_MAJOR_VERSION >= 3
30 #define PyStr_Check PyUnicode_Check
31 #define PyStr_FromString PyUnicode_FromString
32 #define PyStr_AsUTF8 PyUnicode_AsUTF8
33 #define PyInt_FromLong PyLong_FromLong
34 #else
35 #define PyStr_Check PyString_Check
36 #define PyStr_FromString PyString_FromString
37 #define PyStr_AsUTF8 PyString_AsString
38 #endif
39
40 void init_tevent(void);
41
42 typedef struct {
43         PyObject_HEAD
44         struct tevent_context *ev;
45 } TeventContext_Object;
46
47 typedef struct {
48         PyObject_HEAD
49         struct tevent_queue *queue;
50 } TeventQueue_Object;
51
52 typedef struct {
53         PyObject_HEAD
54         struct tevent_req *req;
55 } TeventReq_Object;
56
57 typedef struct {
58         PyObject_HEAD
59         struct tevent_signal *signal;
60 } TeventSignal_Object;
61
62 typedef struct {
63         PyObject_HEAD
64         struct tevent_timer *timer;
65         PyObject *callback;
66 } TeventTimer_Object;
67
68 typedef struct {
69         PyObject_HEAD
70         struct tevent_fd *fd;
71 } TeventFd_Object;
72
73 static PyTypeObject TeventContext_Type;
74 static PyTypeObject TeventReq_Type;
75 static PyTypeObject TeventQueue_Type;
76 static PyTypeObject TeventSignal_Type;
77 static PyTypeObject TeventTimer_Type;
78 static PyTypeObject TeventFd_Type;
79
80 static int py_context_init(struct tevent_context *ev)
81 {
82         /* FIXME */
83         return 0;
84 }
85
86 static struct tevent_fd *py_add_fd(struct tevent_context *ev,
87                                     TALLOC_CTX *mem_ctx,
88                                     int fd, uint16_t flags,
89                                     tevent_fd_handler_t handler,
90                                     void *private_data,
91                                     const char *handler_name,
92                                     const char *location)
93 {
94         /* FIXME */
95         return NULL;
96 }
97
98 static void py_set_fd_close_fn(struct tevent_fd *fde,
99                                 tevent_fd_close_fn_t close_fn)
100 {
101         /* FIXME */
102 }
103
104 static uint16_t py_get_fd_flags(struct tevent_fd *fde)
105 {
106         /* FIXME */
107         return 0;
108 }
109
110 static void py_set_fd_flags(struct tevent_fd *fde, uint16_t flags)
111 {
112         /* FIXME */
113 }
114
115 /* timed_event functions */
116 static struct tevent_timer *py_add_timer(struct tevent_context *ev,
117                                           TALLOC_CTX *mem_ctx,
118                                           struct timeval next_event,
119                                           tevent_timer_handler_t handler,
120                                           void *private_data,
121                                           const char *handler_name,
122                                           const char *location)
123 {
124         /* FIXME */
125         return NULL;
126 }
127
128 /* immediate event functions */
129 static void py_schedule_immediate(struct tevent_immediate *im,
130                                    struct tevent_context *ev,
131                                    tevent_immediate_handler_t handler,
132                                    void *private_data,
133                                    const char *handler_name,
134                                    const char *location)
135 {
136         /* FIXME */
137 }
138
139 /* signal functions */
140 static struct tevent_signal *py_add_signal(struct tevent_context *ev,
141                                             TALLOC_CTX *mem_ctx,
142                                             int signum, int sa_flags,
143                                             tevent_signal_handler_t handler,
144                                             void *private_data,
145                                             const char *handler_name,
146                                             const char *location)
147 {
148         /* FIXME */
149         return NULL;
150 }
151
152 /* loop functions */
153 static int py_loop_once(struct tevent_context *ev, const char *location)
154 {
155         /* FIXME */
156         return 0;
157 }
158
159 static int py_loop_wait(struct tevent_context *ev, const char *location)
160 {
161         /* FIXME */
162         return 0;
163 }
164
165 const static struct tevent_ops py_tevent_ops = {
166         .context_init = py_context_init,
167         .add_fd = py_add_fd,
168         .set_fd_close_fn = py_set_fd_close_fn,
169         .get_fd_flags = py_get_fd_flags,
170         .set_fd_flags = py_set_fd_flags,
171         .add_timer = py_add_timer,
172         .schedule_immediate = py_schedule_immediate,
173         .add_signal = py_add_signal,
174         .loop_wait = py_loop_wait,
175         .loop_once = py_loop_once,
176 };
177
178 static PyObject *py_register_backend(PyObject *self, PyObject *args)
179 {
180         PyObject *name, *py_backend;
181
182         if (!PyArg_ParseTuple(args, "O", &py_backend))
183                 return NULL;
184
185         name = PyObject_GetAttrString(py_backend, "name");
186         if (name == NULL) {
187                 PyErr_SetNone(PyExc_AttributeError);
188                 return NULL;
189         }
190
191         if (!PyStr_Check(name)) {
192                 PyErr_SetNone(PyExc_TypeError);
193                 Py_DECREF(name);
194                 return NULL;
195         }
196
197         if (!tevent_register_backend(PyStr_AsUTF8(name), &py_tevent_ops)) { /* FIXME: What to do with backend */
198                 PyErr_SetNone(PyExc_RuntimeError);
199                 Py_DECREF(name);
200                 return NULL;
201         }
202
203         Py_DECREF(name);
204
205         Py_RETURN_NONE;
206 }
207
208 static PyObject *py_tevent_context_reinitialise(TeventContext_Object *self)
209 {
210         int ret = tevent_re_initialise(self->ev);
211         if (ret != 0) {
212                 PyErr_SetNone(PyExc_RuntimeError);
213                 return NULL;
214         }
215         Py_RETURN_NONE;
216 }
217
218 static PyObject *py_tevent_queue_stop(TeventQueue_Object *self)
219 {
220         tevent_queue_stop(self->queue);
221         Py_RETURN_NONE;
222 }
223
224 static PyObject *py_tevent_queue_start(TeventQueue_Object *self)
225 {
226         tevent_queue_start(self->queue);
227         Py_RETURN_NONE;
228 }
229
230 static void py_queue_trigger(struct tevent_req *req, void *private_data)
231 {
232         PyObject *callback = private_data, *ret;
233
234         ret = PyObject_CallFunction(callback, discard_const_p(char, ""));
235         Py_XDECREF(ret);
236 }
237
238 static PyObject *py_tevent_queue_add(TeventQueue_Object *self, PyObject *args)
239 {
240         TeventContext_Object *py_ev;
241         TeventReq_Object *py_req;
242         PyObject *trigger;
243         bool ret;
244
245         if (!PyArg_ParseTuple(args, "O!O!O", 
246                                                   &TeventContext_Type, &py_ev,
247                                                   &TeventReq_Type, &py_req,
248                                                   &trigger))
249                 return NULL;
250
251         Py_INCREF(trigger);
252
253         ret = tevent_queue_add(self->queue, py_ev->ev, py_req->req,
254                                                    py_queue_trigger, trigger);
255         if (!ret) {
256                 PyErr_SetString(PyExc_RuntimeError, "queue add failed");
257                 Py_DECREF(trigger);
258                 return NULL;
259         }
260
261         Py_RETURN_NONE;
262 }
263
264 static PyMethodDef py_tevent_queue_methods[] = {
265         { "stop", (PyCFunction)py_tevent_queue_stop, METH_NOARGS,
266                 "S.stop()" },
267         { "start", (PyCFunction)py_tevent_queue_start, METH_NOARGS,
268                 "S.start()" },
269         { "add", (PyCFunction)py_tevent_queue_add, METH_VARARGS,
270                 "S.add(ctx, req, trigger, baton)" },
271         { NULL },
272 };
273
274 static PyObject *py_tevent_context_wakeup_send(PyObject *self, PyObject *args)
275 {
276         /* FIXME */
277
278         Py_RETURN_NONE;
279 }
280
281 static PyObject *py_tevent_context_loop_wait(TeventContext_Object *self)
282 {
283         if (tevent_loop_wait(self->ev) != 0) {
284                 PyErr_SetNone(PyExc_RuntimeError);
285                 return NULL;
286         }
287         Py_RETURN_NONE;
288 }
289
290 static PyObject *py_tevent_context_loop_once(TeventContext_Object *self)
291 {
292         if (tevent_loop_once(self->ev) != 0) {
293                 PyErr_SetNone(PyExc_RuntimeError);
294                 return NULL;
295         }
296         Py_RETURN_NONE;
297 }
298
299 static void py_tevent_signal_handler(struct tevent_context *ev,
300                                         struct tevent_signal *se,
301                                         int signum,
302                                         int count,
303                                         void *siginfo,
304                                         void *private_data)
305 {
306         PyObject *callback = (PyObject *)private_data, *ret;
307
308         ret = PyObject_CallFunction(callback, discard_const_p(char, "ii"), signum, count);
309         Py_XDECREF(ret);
310 }
311
312 static void py_tevent_signal_dealloc(TeventSignal_Object *self)
313 {
314         talloc_free(self->signal);
315         PyObject_Del(self);
316 }
317
318 static PyTypeObject TeventSignal_Type = {
319         .tp_name = "tevent.Signal",
320         .tp_basicsize = sizeof(TeventSignal_Object),
321         .tp_dealloc = (destructor)py_tevent_signal_dealloc,
322         .tp_flags = Py_TPFLAGS_DEFAULT,
323 };
324
325 static PyObject *py_tevent_context_add_signal(TeventContext_Object *self, PyObject *args)
326 {
327         int signum, sa_flags;
328         PyObject *handler;
329         struct tevent_signal *sig;
330         TeventSignal_Object *ret;
331
332         if (!PyArg_ParseTuple(args, "iiO", &signum, &sa_flags, &handler))
333                 return NULL;
334
335         Py_INCREF(handler);
336         sig = tevent_add_signal(self->ev, NULL, signum, sa_flags,
337                                                         py_tevent_signal_handler, handler);
338
339         ret = PyObject_New(TeventSignal_Object, &TeventSignal_Type);
340         if (ret == NULL) {
341                 PyErr_NoMemory();
342                 talloc_free(sig);
343                 return NULL;
344         }
345
346         ret->signal = sig;
347
348         return (PyObject *)ret;
349 }
350
351 static void py_timer_handler(struct tevent_context *ev,
352                                        struct tevent_timer *te,
353                                        struct timeval current_time,
354                                        void *private_data)
355 {
356         TeventTimer_Object *self = private_data;
357         PyObject *ret;
358
359         ret = PyObject_CallFunction(self->callback, discard_const_p(char, "l"), te);
360         if (ret == NULL) {
361                 /* No Python stack to propagate exception to; just print traceback */
362                 PyErr_PrintEx(0);
363         }
364         Py_XDECREF(ret);
365 }
366
367 static void py_tevent_timer_dealloc(TeventTimer_Object *self)
368 {
369         if (self->timer) {
370                 talloc_free(self->timer);
371         }
372         Py_DECREF(self->callback);
373         PyObject_Del(self);
374 }
375
376 static int py_tevent_timer_traverse(TeventTimer_Object *self, visitproc visit, void *arg)
377 {
378         Py_VISIT(self->callback);
379         return 0;
380 }
381
382 static PyObject* py_tevent_timer_get_active(TeventTimer_Object *self) {
383         return PyBool_FromLong(self->timer != NULL);
384 }
385
386 struct PyGetSetDef py_tevent_timer_getset[] = {
387         {
388                 .name = discard_const_p(char, "active"),
389                 .get = (getter)py_tevent_timer_get_active,
390                 .doc = discard_const_p(char, "true if the timer is scheduled to run"),
391         },
392         {NULL},
393 };
394
395 static PyTypeObject TeventTimer_Type = {
396         .tp_name = "tevent.Timer",
397         .tp_basicsize = sizeof(TeventTimer_Object),
398         .tp_dealloc = (destructor)py_tevent_timer_dealloc,
399         .tp_traverse = (traverseproc)py_tevent_timer_traverse,
400         .tp_getset = py_tevent_timer_getset,
401         .tp_flags = Py_TPFLAGS_DEFAULT,
402 };
403
404 struct TeventTimer_Object_ref {
405         TeventTimer_Object *obj;
406 };
407
408 static int TeventTimer_Object_ref_destructor(struct TeventTimer_Object_ref *ref)
409 {
410         ref->obj->timer = NULL;
411         Py_DECREF(ref->obj);
412         return 0;
413 }
414
415 static PyObject *py_tevent_context_add_timer_internal(TeventContext_Object *self,
416                                                       struct timeval next_event,
417                                                       PyObject *callback)
418 {
419         /* Ownership notes:
420          *
421          * There are 5 pieces in play; two tevent contexts and 3 Python objects:
422          * - The tevent timer
423          * - The tevent context
424          * - The Python context -- "self"
425          * - The Python timer (TeventTimer_Object) -- "ret"
426          * - The Python callback function -- "callback"
427          *
428          * We only use the Python context for getting the tevent context,
429          * afterwards it can be destroyed.
430          *
431          * The tevent context owns the tevent timer.
432          *
433          * The tevent timer holds a reference to the Python timer, so the Python
434          * timer must always outlive the tevent timer.
435          * The Python timer has a pointer to the tevent timer; a destructor is
436          * used to set this to NULL when the tevent timer is deallocated.
437          *
438          * The tevent timer can be deallocated in these cases:
439          *  1) when the context is destroyed
440          *  2) after the event fires
441          *  Posssibly, API might be added to cancel (free the tevent timer).
442          *
443          * The Python timer holds a reference to the callback.
444          */
445         TeventTimer_Object *ret;
446         struct TeventTimer_Object_ref *ref;
447
448         ret = PyObject_New(TeventTimer_Object, &TeventTimer_Type);
449         if (ret == NULL) {
450                 PyErr_NoMemory();
451                 return NULL;
452         }
453         Py_INCREF(callback);
454         ret->callback = callback;
455         ret->timer = tevent_add_timer(self->ev, NULL, next_event, py_timer_handler,
456                                       ret);
457         if (ret->timer == NULL) {
458                 Py_DECREF(ret);
459                 PyErr_SetString(PyExc_RuntimeError, "Could not initialize timer");
460                 return NULL;
461         }
462         ref = talloc(ret->timer, struct TeventTimer_Object_ref);
463         if (ref == NULL) {
464                 talloc_free(ret->timer);
465                 Py_DECREF(ret);
466                 PyErr_SetString(PyExc_RuntimeError, "Could not initialize timer");
467                 return NULL;
468         }
469         Py_INCREF(ret);
470         ref->obj = ret;
471
472         talloc_set_destructor(ref, TeventTimer_Object_ref_destructor);
473
474         return (PyObject *)ret;
475 }
476
477 static PyObject *py_tevent_context_add_timer(TeventContext_Object *self, PyObject *args)
478 {
479         struct timeval next_event;
480         PyObject *callback;
481         if (!PyArg_ParseTuple(args, "lO", &next_event, &callback))
482                 return NULL;
483
484         return py_tevent_context_add_timer_internal(self, next_event, callback);
485 }
486
487 static PyObject *py_tevent_context_add_timer_offset(TeventContext_Object *self, PyObject *args)
488 {
489         struct timeval next_event;
490         double offset;
491         int seconds;
492         PyObject *callback;
493         if (!PyArg_ParseTuple(args, "dO", &offset, &callback))
494                 return NULL;
495
496         seconds = offset;
497         offset -= seconds;
498         next_event = tevent_timeval_current_ofs(seconds, (int)(offset*1000000));
499         return py_tevent_context_add_timer_internal(self, next_event, callback);
500 }
501
502 static void py_fd_handler(struct tevent_context *ev,
503                                     struct tevent_fd *fde,
504                                     uint16_t flags,
505                                     void *private_data)
506 {
507         PyObject *callback = private_data, *ret;
508
509         ret = PyObject_CallFunction(callback, discard_const_p(char, "i"), flags);
510         Py_XDECREF(ret);
511 }
512
513 static void py_tevent_fp_dealloc(TeventFd_Object *self)
514 {
515         talloc_free(self->fd);
516         PyObject_Del(self);
517 }
518
519 static PyTypeObject TeventFd_Type = {
520         .tp_name = "tevent.Fd",
521         .tp_basicsize = sizeof(TeventFd_Object),
522         .tp_dealloc = (destructor)py_tevent_fp_dealloc,
523         .tp_flags = Py_TPFLAGS_DEFAULT,
524 };
525
526 static PyObject *py_tevent_context_add_fd(TeventContext_Object *self, PyObject *args)
527 {
528         int fd, flags;
529         PyObject *handler;
530         struct tevent_fd *tfd;
531         TeventFd_Object *ret;
532
533         if (!PyArg_ParseTuple(args, "iiO", &fd, &flags, &handler))
534                 return NULL;
535
536         tfd = tevent_add_fd(self->ev, NULL, fd, flags, py_fd_handler, handler);
537         if (tfd == NULL) {
538                 PyErr_SetNone(PyExc_RuntimeError);
539                 return NULL;
540         }
541
542         ret = PyObject_New(TeventFd_Object, &TeventFd_Type);
543         if (ret == NULL) {
544                 talloc_free(tfd);
545                 return NULL;
546         }
547         ret->fd = tfd;
548
549         return (PyObject *)ret;
550 }
551
552 static PyMethodDef py_tevent_context_methods[] = {
553         { "reinitialise", (PyCFunction)py_tevent_context_reinitialise, METH_NOARGS,
554                 "S.reinitialise()" },
555         { "wakeup_send", (PyCFunction)py_tevent_context_wakeup_send, 
556                 METH_VARARGS, "S.wakeup_send(wakeup_time) -> req" },
557         { "loop_wait", (PyCFunction)py_tevent_context_loop_wait,
558                 METH_NOARGS, "S.loop_wait()" },
559         { "loop_once", (PyCFunction)py_tevent_context_loop_once,
560                 METH_NOARGS, "S.loop_once()" },
561         { "add_signal", (PyCFunction)py_tevent_context_add_signal,
562                 METH_VARARGS, "S.add_signal(signum, sa_flags, handler) -> signal" },
563         { "add_timer", (PyCFunction)py_tevent_context_add_timer,
564                 METH_VARARGS, "S.add_timer(next_event, handler) -> timer" },
565         { "add_timer_offset", (PyCFunction)py_tevent_context_add_timer_offset,
566                 METH_VARARGS, "S.add_timer(offset_seconds, handler) -> timer" },
567         { "add_fd", (PyCFunction)py_tevent_context_add_fd, 
568                 METH_VARARGS, "S.add_fd(fd, flags, handler) -> fd" },
569         { NULL },
570 };
571
572 static PyObject *py_tevent_req_wakeup_recv(PyObject *self)
573 {
574         /* FIXME */
575         Py_RETURN_NONE;
576 }
577
578 static PyObject *py_tevent_req_received(PyObject *self)
579 {
580         /* FIXME */
581         Py_RETURN_NONE;
582 }
583
584 static PyObject *py_tevent_req_is_error(PyObject *self)
585 {
586         /* FIXME */
587         Py_RETURN_NONE;
588 }
589
590 static PyObject *py_tevent_req_poll(PyObject *self)
591 {
592         /* FIXME */
593         Py_RETURN_NONE;
594 }
595
596 static PyObject *py_tevent_req_is_in_progress(PyObject *self)
597 {
598         /* FIXME */
599         Py_RETURN_NONE;
600 }
601
602 static PyGetSetDef py_tevent_req_getsetters[] = {
603         {
604                 .name = discard_const_p(char, "in_progress"),
605                 .get = (getter)py_tevent_req_is_in_progress,
606                 .doc = discard_const_p(char, "Whether the request is in progress"),
607         },
608         { NULL }
609 };
610
611 static PyObject *py_tevent_req_post(PyObject *self, PyObject *args)
612 {
613         /* FIXME */
614         Py_RETURN_NONE;
615 }
616
617 static PyObject *py_tevent_req_set_error(PyObject *self, PyObject *args)
618 {
619         /* FIXME */
620         Py_RETURN_NONE;
621 }
622
623 static PyObject *py_tevent_req_done(PyObject *self)
624 {
625         /* FIXME */
626         Py_RETURN_NONE;
627 }
628
629 static PyObject *py_tevent_req_notify_callback(PyObject *self)
630 {
631         /* FIXME */
632         Py_RETURN_NONE;
633 }
634
635 static PyObject *py_tevent_req_set_endtime(PyObject *self, PyObject *args)
636 {
637         /* FIXME */
638         Py_RETURN_NONE;
639 }
640
641 static PyObject *py_tevent_req_cancel(TeventReq_Object *self)
642 {
643         if (!tevent_req_cancel(self->req)) {
644                 PyErr_SetNone(PyExc_RuntimeError);
645                 return NULL;
646         }
647         Py_RETURN_NONE;
648 }
649
650 static PyMethodDef py_tevent_req_methods[] = {
651         { "wakeup_recv", (PyCFunction)py_tevent_req_wakeup_recv, METH_NOARGS,
652                 "Wakeup received" },
653         { "received", (PyCFunction)py_tevent_req_received, METH_NOARGS,
654                 "Receive finished" },
655         { "is_error", (PyCFunction)py_tevent_req_is_error, METH_NOARGS,
656                 "is_error() -> (error, state)" },
657         { "poll", (PyCFunction)py_tevent_req_poll, METH_VARARGS,
658                 "poll(ctx)" },
659         { "post", (PyCFunction)py_tevent_req_post, METH_VARARGS,
660                 "post(ctx) -> req" },
661         { "set_error", (PyCFunction)py_tevent_req_set_error, METH_VARARGS,
662                 "set_error(error)" },
663         { "done", (PyCFunction)py_tevent_req_done, METH_NOARGS,
664                 "done()" },
665         { "notify_callback", (PyCFunction)py_tevent_req_notify_callback,
666                 METH_NOARGS, "notify_callback()" },
667         { "set_endtime", (PyCFunction)py_tevent_req_set_endtime,
668                 METH_VARARGS, "set_endtime(ctx, endtime)" },
669         { "cancel", (PyCFunction)py_tevent_req_cancel,
670                 METH_NOARGS, "cancel()" },
671         { NULL }
672 };
673
674 static void py_tevent_req_dealloc(TeventReq_Object *self)
675 {
676         talloc_free(self->req);
677         PyObject_DEL(self);
678 }
679
680 static PyTypeObject TeventReq_Type = {
681         .tp_name = "tevent.Request",
682         .tp_basicsize = sizeof(TeventReq_Object),
683         .tp_methods = py_tevent_req_methods,
684         .tp_dealloc = (destructor)py_tevent_req_dealloc,
685         .tp_getset = py_tevent_req_getsetters,
686         /* FIXME: .tp_new = py_tevent_req_new, */
687 };
688
689 static PyObject *py_tevent_queue_get_length(TeventQueue_Object *self)
690 {
691         return PyInt_FromLong(tevent_queue_length(self->queue));
692 }
693
694 static PyGetSetDef py_tevent_queue_getsetters[] = {
695         {
696                 .name = discard_const_p(char, "length"),
697                 .get = (getter)py_tevent_queue_get_length,
698                 .doc = discard_const_p(char, "The number of elements in the queue."),
699         },
700         { NULL },
701 };
702
703 static void py_tevent_queue_dealloc(TeventQueue_Object *self)
704 {
705         talloc_free(self->queue);
706         PyObject_Del(self);
707 }
708
709 static PyTypeObject TeventQueue_Type = {
710         .tp_name = "tevent.Queue",
711         .tp_basicsize = sizeof(TeventQueue_Object),
712         .tp_dealloc = (destructor)py_tevent_queue_dealloc,
713         .tp_flags = Py_TPFLAGS_DEFAULT,
714         .tp_getset = py_tevent_queue_getsetters,
715         .tp_methods = py_tevent_queue_methods,
716 };
717
718 static PyObject *py_tevent_context_signal_support(PyObject *_self)
719 {
720         TeventContext_Object *self = (TeventContext_Object *)_self;
721         return PyBool_FromLong(tevent_signal_support(self->ev));
722 }
723
724 static PyGetSetDef py_tevent_context_getsetters[] = {
725         {
726                 .name = discard_const_p(char, "signal_support"),
727                 .get = (getter)py_tevent_context_signal_support,
728                 .doc = discard_const_p(char, "if this platform and tevent context support signal handling"),
729         },
730         { NULL }
731 };
732
733 static void py_tevent_context_dealloc(TeventContext_Object *self)
734 {
735         talloc_free(self->ev);
736         PyObject_Del(self);
737 }
738
739 static PyObject *py_tevent_context_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
740 {
741         const char * const kwnames[] = { "name", NULL };
742         char *name = NULL;
743         struct tevent_context *ev;
744         TeventContext_Object *ret;
745
746         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|s", discard_const_p(char *, kwnames), &name))
747                 return NULL;
748
749         if (name == NULL) {
750                 ev = tevent_context_init(NULL);
751         } else {
752                 ev = tevent_context_init_byname(NULL, name);
753         }
754
755         if (ev == NULL) {
756                 PyErr_SetNone(PyExc_RuntimeError);
757                 return NULL;
758         }
759
760         ret = PyObject_New(TeventContext_Object, type);
761         if (ret == NULL) {
762                 PyErr_NoMemory();
763                 talloc_free(ev);
764                 return NULL;
765         }
766
767         ret->ev = ev;
768         return (PyObject *)ret;
769 }
770
771 static PyTypeObject TeventContext_Type = {
772         .tp_name = "tevent.Context",
773         .tp_new = py_tevent_context_new,
774         .tp_basicsize = sizeof(TeventContext_Object),
775         .tp_dealloc = (destructor)py_tevent_context_dealloc,
776         .tp_methods = py_tevent_context_methods,
777         .tp_getset = py_tevent_context_getsetters,
778         .tp_flags = Py_TPFLAGS_DEFAULT,
779 };
780
781 static PyObject *py_set_default_backend(PyObject *self, PyObject *args)
782 {
783         char *backend_name;
784         if (!PyArg_ParseTuple(args, "s", &backend_name))
785                 return NULL;
786
787         tevent_set_default_backend(backend_name);
788
789         Py_RETURN_NONE;
790 }
791
792 static PyObject *py_backend_list(PyObject *self)
793 {
794         PyObject *ret = NULL;
795         PyObject *string = NULL;
796         int i, result;
797         const char **backends = NULL;
798
799         ret = PyList_New(0);
800         if (ret == NULL) {
801                 return NULL;
802         }
803
804         backends = tevent_backend_list(NULL);
805         if (backends == NULL) {
806                 PyErr_SetNone(PyExc_RuntimeError);
807                 goto err;
808         }
809         for (i = 0; backends[i]; i++) {
810                 string = PyStr_FromString(backends[i]);
811                 if (!string) {
812                         goto err;
813                 }
814                 result = PyList_Append(ret, string);
815                 if (result) {
816                         goto err;
817                 }
818                 Py_DECREF(string);
819                 string = NULL;
820         }
821
822         talloc_free(backends);
823
824         return ret;
825
826 err:
827         Py_XDECREF(ret);
828         Py_XDECREF(string);
829         talloc_free(backends);
830         return NULL;
831 }
832
833 static PyMethodDef tevent_methods[] = {
834         { "register_backend", (PyCFunction)py_register_backend, METH_VARARGS,
835                 "register_backend(backend)" },
836         { "set_default_backend", (PyCFunction)py_set_default_backend, 
837                 METH_VARARGS, "set_default_backend(backend)" },
838         { "backend_list", (PyCFunction)py_backend_list, 
839                 METH_NOARGS, "backend_list() -> list" },
840         { NULL },
841 };
842
843 #define MODULE_DOC PyDoc_STR("Python wrapping of talloc-maintained objects.")
844
845 #if PY_MAJOR_VERSION >= 3
846 static struct PyModuleDef moduledef = {
847         PyModuleDef_HEAD_INIT,
848         .m_name = "_tevent",
849         .m_doc = MODULE_DOC,
850         .m_size = -1,
851         .m_methods = tevent_methods,
852 };
853 #endif
854
855 PyObject * module_init(void);
856 PyObject * module_init(void)
857 {
858         PyObject *m;
859
860         if (PyType_Ready(&TeventContext_Type) < 0)
861                 return NULL;
862
863         if (PyType_Ready(&TeventQueue_Type) < 0)
864                 return NULL;
865
866         if (PyType_Ready(&TeventReq_Type) < 0)
867                 return NULL;
868
869         if (PyType_Ready(&TeventSignal_Type) < 0)
870                 return NULL;
871
872         if (PyType_Ready(&TeventTimer_Type) < 0)
873                 return NULL;
874
875         if (PyType_Ready(&TeventFd_Type) < 0)
876                 return NULL;
877
878 #if PY_MAJOR_VERSION >= 3
879         m = PyModule_Create(&moduledef);
880 #else
881         m = Py_InitModule3("_tevent", tevent_methods, MODULE_DOC);
882 #endif
883         if (m == NULL)
884                 return NULL;
885
886         Py_INCREF(&TeventContext_Type);
887         PyModule_AddObject(m, "Context", (PyObject *)&TeventContext_Type);
888
889         Py_INCREF(&TeventQueue_Type);
890         PyModule_AddObject(m, "Queue", (PyObject *)&TeventQueue_Type);
891
892         Py_INCREF(&TeventReq_Type);
893         PyModule_AddObject(m, "Request", (PyObject *)&TeventReq_Type);
894
895         Py_INCREF(&TeventSignal_Type);
896         PyModule_AddObject(m, "Signal", (PyObject *)&TeventSignal_Type);
897
898         Py_INCREF(&TeventTimer_Type);
899         PyModule_AddObject(m, "Timer", (PyObject *)&TeventTimer_Type);
900
901         Py_INCREF(&TeventFd_Type);
902         PyModule_AddObject(m, "Fd", (PyObject *)&TeventFd_Type);
903
904         PyModule_AddStringConstant(m, "__version__", PACKAGE_VERSION);
905
906         return m;
907 }
908
909 #if PY_MAJOR_VERSION >= 3
910 PyMODINIT_FUNC PyInit__tevent(void);
911 PyMODINIT_FUNC PyInit__tevent(void)
912 {
913         return module_init();
914 }
915 #else
916 void init_tevent(void);
917 void init_tevent(void)
918 {
919         module_init();
920 }
921 #endif