source: vendor/current/lib/tevent/pytevent.c

Last change on this file was 988, checked in by Silvan Scherrer, 9 years ago

Samba Server: update vendor to version 4.4.3
File size: 22.1 KB
Line 
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
40void init_tevent(void);
41
42typedef struct {
43 PyObject_HEAD
44 struct tevent_context *ev;
45} TeventContext_Object;
46
47typedef struct {
48 PyObject_HEAD
49 struct tevent_queue *queue;
50} TeventQueue_Object;
51
52typedef struct {
53 PyObject_HEAD
54 struct tevent_req *req;
55} TeventReq_Object;
56
57typedef struct {
58 PyObject_HEAD
59 struct tevent_signal *signal;
60} TeventSignal_Object;
61
62typedef struct {
63 PyObject_HEAD
64 struct tevent_timer *timer;
65 PyObject *callback;
66} TeventTimer_Object;
67
68typedef struct {
69 PyObject_HEAD
70 struct tevent_fd *fd;
71} TeventFd_Object;
72
73static PyTypeObject TeventContext_Type;
74static PyTypeObject TeventReq_Type;
75static PyTypeObject TeventQueue_Type;
76static PyTypeObject TeventSignal_Type;
77static PyTypeObject TeventTimer_Type;
78static PyTypeObject TeventFd_Type;
79
80static int py_context_init(struct tevent_context *ev)
81{
82 /* FIXME */
83 return 0;
84}
85
86static 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
98static void py_set_fd_close_fn(struct tevent_fd *fde,
99 tevent_fd_close_fn_t close_fn)
100{
101 /* FIXME */
102}
103
104static uint16_t py_get_fd_flags(struct tevent_fd *fde)
105{
106 /* FIXME */
107 return 0;
108}
109
110static void py_set_fd_flags(struct tevent_fd *fde, uint16_t flags)
111{
112 /* FIXME */
113}
114
115/* timed_event functions */
116static 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 */
129static 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 */
140static 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 */
153static int py_loop_once(struct tevent_context *ev, const char *location)
154{
155 /* FIXME */
156 return 0;
157}
158
159static int py_loop_wait(struct tevent_context *ev, const char *location)
160{
161 /* FIXME */
162 return 0;
163}
164
165const 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
178static 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
208static 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
218static PyObject *py_tevent_queue_stop(TeventQueue_Object *self)
219{
220 tevent_queue_stop(self->queue);
221 Py_RETURN_NONE;
222}
223
224static PyObject *py_tevent_queue_start(TeventQueue_Object *self)
225{
226 tevent_queue_start(self->queue);
227 Py_RETURN_NONE;
228}
229
230static 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
238static 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
264static 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
274static PyObject *py_tevent_context_wakeup_send(PyObject *self, PyObject *args)
275{
276 /* FIXME */
277
278 Py_RETURN_NONE;
279}
280
281static 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
290static 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
299static 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
312static void py_tevent_signal_dealloc(TeventSignal_Object *self)
313{
314 talloc_free(self->signal);
315 PyObject_Del(self);
316}
317
318static 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
325static 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
351static 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
367static 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
376static int py_tevent_timer_traverse(TeventTimer_Object *self, visitproc visit, void *arg)
377{
378 Py_VISIT(self->callback);
379 return 0;
380}
381
382static PyObject* py_tevent_timer_get_active(TeventTimer_Object *self) {
383 return PyBool_FromLong(self->timer != NULL);
384}
385
386struct 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
395static 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
404struct TeventTimer_Object_ref {
405 TeventTimer_Object *obj;
406};
407
408static 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
415static 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
477static 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
487static 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
502static 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
513static void py_tevent_fp_dealloc(TeventFd_Object *self)
514{
515 talloc_free(self->fd);
516 PyObject_Del(self);
517}
518
519static 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
526static 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
552static 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
572static PyObject *py_tevent_req_wakeup_recv(PyObject *self)
573{
574 /* FIXME */
575 Py_RETURN_NONE;
576}
577
578static PyObject *py_tevent_req_received(PyObject *self)
579{
580 /* FIXME */
581 Py_RETURN_NONE;
582}
583
584static PyObject *py_tevent_req_is_error(PyObject *self)
585{
586 /* FIXME */
587 Py_RETURN_NONE;
588}
589
590static PyObject *py_tevent_req_poll(PyObject *self)
591{
592 /* FIXME */
593 Py_RETURN_NONE;
594}
595
596static PyObject *py_tevent_req_is_in_progress(PyObject *self)
597{
598 /* FIXME */
599 Py_RETURN_NONE;
600}
601
602static 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
611static PyObject *py_tevent_req_post(PyObject *self, PyObject *args)
612{
613 /* FIXME */
614 Py_RETURN_NONE;
615}
616
617static PyObject *py_tevent_req_set_error(PyObject *self, PyObject *args)
618{
619 /* FIXME */
620 Py_RETURN_NONE;
621}
622
623static PyObject *py_tevent_req_done(PyObject *self)
624{
625 /* FIXME */
626 Py_RETURN_NONE;
627}
628
629static PyObject *py_tevent_req_notify_callback(PyObject *self)
630{
631 /* FIXME */
632 Py_RETURN_NONE;
633}
634
635static PyObject *py_tevent_req_set_endtime(PyObject *self, PyObject *args)
636{
637 /* FIXME */
638 Py_RETURN_NONE;
639}
640
641static 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
650static 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
674static void py_tevent_req_dealloc(TeventReq_Object *self)
675{
676 talloc_free(self->req);
677 PyObject_DEL(self);
678}
679
680static 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
689static PyObject *py_tevent_queue_get_length(TeventQueue_Object *self)
690{
691 return PyInt_FromLong(tevent_queue_length(self->queue));
692}
693
694static 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
703static void py_tevent_queue_dealloc(TeventQueue_Object *self)
704{
705 talloc_free(self->queue);
706 PyObject_Del(self);
707}
708
709static 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
718static 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
724static 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
733static void py_tevent_context_dealloc(TeventContext_Object *self)
734{
735 talloc_free(self->ev);
736 PyObject_Del(self);
737}
738
739static 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
771static 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
781static 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
792static 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
826err:
827 Py_XDECREF(ret);
828 Py_XDECREF(string);
829 talloc_free(backends);
830 return NULL;
831}
832
833static 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
846static 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
855PyObject * module_init(void);
856PyObject * 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
910PyMODINIT_FUNC PyInit__tevent(void);
911PyMODINIT_FUNC PyInit__tevent(void)
912{
913 return module_init();
914}
915#else
916void init_tevent(void);
917void init_tevent(void)
918{
919 module_init();
920}
921#endif
Note: See TracBrowser for help on using the repository browser.