ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/EV/EV.xs
Revision: 1.43
Committed: Fri Nov 2 22:18:49 2007 UTC (16 years, 6 months ago) by root
Branch: MAIN
Changes since 1.42: +6 -0 lines
Log Message:
*** empty log message ***

File Contents

# User Rev Content
1 root 1.1 #include "EXTERN.h"
2     #include "perl.h"
3     #include "XSUB.h"
4    
5 root 1.20 /*#include <netinet/in.h>*/
6 root 1.1
7 root 1.20 #define EV_PROTOTYPES 1
8 root 1.11 #include "EV/EVAPI.h"
9    
10 root 1.16 #include "libev/ev.c"
11 root 1.36 #include "libev/event.h"
12     #include "libev/event.c"
13     #include "libev/evdns.c"
14 root 1.16
15 root 1.10 typedef int Signal;
16 root 1.1
17 root 1.11 static struct EVAPI evapi;
18    
19 root 1.15 static HV
20     *stash_watcher,
21     *stash_io,
22     *stash_timer,
23     *stash_periodic,
24     *stash_signal,
25     *stash_idle,
26 root 1.22 *stash_prepare,
27 root 1.23 *stash_check,
28     *stash_child;
29 root 1.1
30 root 1.43 #ifndef SIG_SIZE
31     /* kudos to Slaven Rezic for the idea */
32     static char sig_size [] = { SIG_NUM };
33     # define SIG_SIZE (sizeof (sig_size) + 1)
34     #endif
35    
36 root 1.10 static int
37     sv_signum (SV *sig)
38     {
39     int signum;
40    
41 root 1.31 SvGETMAGIC (sig);
42 root 1.10
43     for (signum = 1; signum < SIG_SIZE; ++signum)
44     if (strEQ (SvPV_nolen (sig), PL_sig_name [signum]))
45     return signum;
46    
47 root 1.31 if (SvIV (sig) > 0)
48     return SvIV (sig);
49    
50 root 1.10 return -1;
51     }
52    
53 root 1.1 /////////////////////////////////////////////////////////////////////////////
54     // Event
55    
56 root 1.15 static void e_cb (struct ev_watcher *w, int revents);
57 root 1.1
58 root 1.15 static int
59     sv_fileno (SV *fh)
60 root 1.1 {
61 root 1.3 SvGETMAGIC (fh);
62 root 1.1
63 root 1.3 if (SvROK (fh))
64     fh = SvRV (fh);
65 root 1.1
66 root 1.3 if (SvTYPE (fh) == SVt_PVGV)
67     return PerlIO_fileno (IoIFP (sv_2io (fh)));
68 root 1.1
69 root 1.31 if ((SvIV (fh) >= 0) && (SvIV (fh) < 0x7ffffff))
70 root 1.3 return SvIV (fh);
71 root 1.1
72     return -1;
73     }
74    
75 root 1.15 static void *
76     e_new (int size, SV *cb_sv)
77 root 1.1 {
78 root 1.15 struct ev_watcher *w;
79     SV *self = NEWSV (0, size);
80 root 1.1 SvPOK_only (self);
81 root 1.15 SvCUR_set (self, size);
82 root 1.1
83 root 1.15 w = (struct ev_watcher *)SvPVX (self);
84 root 1.1
85 root 1.29 ev_watcher_init (w, e_cb);
86 root 1.1
87 root 1.15 w->fh = 0;
88     w->cb_sv = newSVsv (cb_sv);
89     w->self = self;
90 root 1.1
91 root 1.15 return (void *)w;
92 root 1.1 }
93    
94 root 1.34 static void *
95     e_destroy (void *w_)
96     {
97     struct ev_watcher *w = w_;
98    
99     SvREFCNT_dec (w->fh ); w->fh = 0;
100     SvREFCNT_dec (w->cb_sv); w->cb_sv = 0;
101     }
102    
103 root 1.15 static SV *
104     e_bless (struct ev_watcher *w, HV *stash)
105 root 1.1 {
106     SV *rv;
107    
108 root 1.15 if (SvOBJECT (w->self))
109     rv = newRV_inc (w->self);
110 root 1.1 else
111     {
112 root 1.15 rv = newRV_noinc (w->self);
113     sv_bless (rv, stash);
114     SvREADONLY_on (w->self);
115 root 1.1 }
116    
117     return rv;
118     }
119    
120     static void
121 root 1.15 e_cb (struct ev_watcher *w, int revents)
122 root 1.1 {
123     dSP;
124 root 1.14 I32 mark = SP - PL_stack_base;
125 root 1.24 SV *sv_self, *sv_events, *sv_status = 0;
126 root 1.14 static SV *sv_events_cache;
127 root 1.1
128 root 1.15 sv_self = newRV_inc (w->self); /* w->self MUST be blessed by now */
129 root 1.14
130     if (sv_events_cache)
131     {
132     sv_events = sv_events_cache; sv_events_cache = 0;
133 root 1.15 SvIV_set (sv_events, revents);
134 root 1.14 }
135     else
136 root 1.15 sv_events = newSViv (revents);
137 root 1.14
138 root 1.1 PUSHMARK (SP);
139     EXTEND (SP, 2);
140 root 1.14 PUSHs (sv_self);
141     PUSHs (sv_events);
142 root 1.24
143     if (revents & EV_CHILD)
144     XPUSHs (sv_status = newSViv (((struct ev_child *)w)->status));
145    
146 root 1.1 PUTBACK;
147 root 1.15 call_sv (w->cb_sv, G_DISCARD | G_VOID | G_EVAL);
148 root 1.14 SP = PL_stack_base + mark; PUTBACK;
149    
150     SvREFCNT_dec (sv_self);
151 root 1.24 SvREFCNT_dec (sv_status);
152 root 1.14
153     if (sv_events_cache)
154     SvREFCNT_dec (sv_events);
155     else
156     sv_events_cache = sv_events;
157 root 1.1
158 root 1.8 if (SvTRUE (ERRSV))
159     {
160     PUSHMARK (SP);
161     PUTBACK;
162     call_sv (get_sv ("EV::DIED", 1), G_DISCARD | G_VOID | G_EVAL | G_KEEPERR);
163 root 1.14 SP = PL_stack_base + mark; PUTBACK;
164 root 1.8 }
165 root 1.1 }
166    
167     /////////////////////////////////////////////////////////////////////////////
168     // DNS
169    
170     static void
171     dns_cb (int result, char type, int count, int ttl, void *addresses, void *arg)
172     {
173     dSP;
174     SV *cb = (SV *)arg;
175    
176     ENTER;
177     SAVETMPS;
178     PUSHMARK (SP);
179     EXTEND (SP, count + 3);
180     PUSHs (sv_2mortal (newSViv (result)));
181    
182     if (result == DNS_ERR_NONE && ttl >= 0)
183     {
184     int i;
185    
186     PUSHs (sv_2mortal (newSViv (type)));
187     PUSHs (sv_2mortal (newSViv (ttl)));
188    
189     for (i = 0; i < count; ++i)
190     switch (type)
191     {
192     case DNS_IPv6_AAAA:
193     PUSHs (sv_2mortal (newSVpvn (i * 16 + (char *)addresses, 16)));
194     break;
195     case DNS_IPv4_A:
196     PUSHs (sv_2mortal (newSVpvn (i * 4 + (char *)addresses, 4)));
197     break;
198     case DNS_PTR:
199     PUSHs (sv_2mortal (newSVpv (*(char **)addresses, 0)));
200     break;
201     }
202     }
203    
204     PUTBACK;
205     call_sv (sv_2mortal (cb), G_DISCARD | G_VOID | G_EVAL);
206    
207     FREETMPS;
208 root 1.8
209     if (SvTRUE (ERRSV))
210     {
211     PUSHMARK (SP);
212     PUTBACK;
213     call_sv (get_sv ("EV::DIED", 1), G_DISCARD | G_VOID | G_EVAL | G_KEEPERR);
214     }
215    
216 root 1.1 LEAVE;
217     }
218    
219 root 1.18 #define CHECK_REPEAT(repeat) if (repeat < 0.) \
220     croak (# repeat " value must be >= 0");
221    
222 root 1.31 #define CHECK_FD(fh,fd) if ((fd) < 0) \
223     croak ("illegal file descriptor or filehandle (either no attached file descriptor or illegal value): %s", SvPV_nolen (fh));
224    
225 root 1.1 /////////////////////////////////////////////////////////////////////////////
226     // XS interface functions
227    
228 root 1.15 MODULE = EV PACKAGE = EV PREFIX = ev_
229 root 1.1
230 root 1.21 PROTOTYPES: ENABLE
231    
232 root 1.1 BOOT:
233     {
234 root 1.10 int i;
235 root 1.1 HV *stash = gv_stashpv ("EV", 1);
236    
237     static const struct {
238     const char *name;
239     IV iv;
240     } *civ, const_iv[] = {
241     # define const_iv(pfx, name) { # name, (IV) pfx ## name },
242 root 1.41 const_iv (EV_, MINPRI)
243     const_iv (EV_, MAXPRI)
244    
245 root 1.20 const_iv (EV_, UNDEF)
246 root 1.1 const_iv (EV_, NONE)
247     const_iv (EV_, TIMEOUT)
248     const_iv (EV_, READ)
249     const_iv (EV_, WRITE)
250     const_iv (EV_, SIGNAL)
251 root 1.15 const_iv (EV_, IDLE)
252     const_iv (EV_, CHECK)
253 root 1.20 const_iv (EV_, ERROR)
254 root 1.15
255     const_iv (EV, LOOP_ONESHOT)
256 root 1.1 const_iv (EV, LOOP_NONBLOCK)
257 root 1.15
258 root 1.41 const_iv (EV, METHOD_AUTO)
259 root 1.15 const_iv (EV, METHOD_SELECT)
260 root 1.41 const_iv (EV, METHOD_POLL)
261 root 1.15 const_iv (EV, METHOD_EPOLL)
262 root 1.42 const_iv (EV, METHOD_KQUEUE)
263     const_iv (EV, METHOD_DEVPOLL)
264     const_iv (EV, METHOD_PORT)
265 root 1.41 const_iv (EV, METHOD_ANY)
266 root 1.1 };
267    
268     for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
269     newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
270    
271 root 1.15 stash_watcher = gv_stashpv ("EV::Watcher" , 1);
272 root 1.28 stash_io = gv_stashpv ("EV::Io" , 1);
273 root 1.15 stash_timer = gv_stashpv ("EV::Timer" , 1);
274     stash_periodic = gv_stashpv ("EV::Periodic", 1);
275     stash_signal = gv_stashpv ("EV::Signal" , 1);
276     stash_idle = gv_stashpv ("EV::Idle" , 1);
277 root 1.22 stash_prepare = gv_stashpv ("EV::Prepare" , 1);
278 root 1.15 stash_check = gv_stashpv ("EV::Check" , 1);
279 root 1.23 stash_child = gv_stashpv ("EV::Child" , 1);
280 root 1.11
281     {
282     SV *sv = perl_get_sv ("EV::API", TRUE);
283     perl_get_sv ("EV::API", TRUE); /* silence 5.10 warning */
284    
285 root 1.15 /* the poor man's shared library emulator */
286     evapi.ver = EV_API_VERSION;
287     evapi.rev = EV_API_REVISION;
288     evapi.sv_fileno = sv_fileno;
289     evapi.sv_signum = sv_signum;
290     evapi.now = &ev_now;
291     evapi.method = &ev_method;
292     evapi.loop_done = &ev_loop_done;
293     evapi.time = ev_time;
294     evapi.loop = ev_loop;
295 root 1.20 evapi.once = ev_once;
296 root 1.29 evapi.io_start = ev_io_start;
297     evapi.io_stop = ev_io_stop;
298     evapi.timer_start = ev_timer_start;
299     evapi.timer_stop = ev_timer_stop;
300     evapi.timer_again = ev_timer_again;
301     evapi.periodic_start = ev_periodic_start;
302     evapi.periodic_stop = ev_periodic_stop;
303     evapi.signal_start = ev_signal_start;
304     evapi.signal_stop = ev_signal_stop;
305     evapi.idle_start = ev_idle_start;
306     evapi.idle_stop = ev_idle_stop;
307     evapi.prepare_start = ev_prepare_start;
308     evapi.prepare_stop = ev_prepare_stop;
309     evapi.check_start = ev_check_start;
310     evapi.check_stop = ev_check_stop;
311     evapi.child_start = ev_child_start;
312     evapi.child_stop = ev_child_stop;
313 root 1.11
314     sv_setiv (sv, (IV)&evapi);
315     SvREADONLY_on (sv);
316     }
317 root 1.33
318     pthread_atfork (ev_fork_prepare, ev_fork_parent, ev_fork_child);
319 root 1.1 }
320    
321 root 1.15 NV ev_now ()
322 root 1.1 CODE:
323 root 1.15 RETVAL = ev_now;
324 root 1.1 OUTPUT:
325     RETVAL
326    
327 root 1.15 int ev_method ()
328 root 1.1 CODE:
329 root 1.15 RETVAL = ev_method;
330 root 1.1 OUTPUT:
331     RETVAL
332    
333 root 1.15 NV ev_time ()
334 root 1.1
335 root 1.41 void ev_init (int methods = EVMETHOD_AUTO)
336 root 1.1
337 root 1.15 void ev_loop (int flags = 0)
338 root 1.1
339 root 1.15 void ev_loop_done (int value = 1)
340 root 1.1 CODE:
341 root 1.15 ev_loop_done = value;
342 root 1.1
343 root 1.15 struct ev_io *io (SV *fh, int events, SV *cb)
344     ALIAS:
345     io_ns = 1
346 root 1.1 CODE:
347 root 1.31 {
348     int fd = sv_fileno (fh);
349     CHECK_FD (fh, fd);
350    
351 root 1.15 RETVAL = e_new (sizeof (struct ev_io), cb);
352     RETVAL->fh = newSVsv (fh);
353 root 1.31 ev_io_set (RETVAL, fd, events);
354 root 1.29 if (!ix) ev_io_start (RETVAL);
355 root 1.31 }
356 root 1.1 OUTPUT:
357     RETVAL
358    
359 root 1.15 struct ev_timer *timer (NV after, NV repeat, SV *cb)
360 root 1.1 ALIAS:
361 root 1.15 timer_ns = 1
362 root 1.18 INIT:
363     CHECK_REPEAT (repeat);
364 root 1.1 CODE:
365 root 1.15 RETVAL = e_new (sizeof (struct ev_timer), cb);
366 root 1.29 ev_timer_set (RETVAL, after, repeat);
367     if (!ix) ev_timer_start (RETVAL);
368 root 1.1 OUTPUT:
369     RETVAL
370    
371 root 1.15 struct ev_periodic *periodic (NV at, NV interval, SV *cb)
372 root 1.9 ALIAS:
373 root 1.15 periodic_ns = 1
374 root 1.18 INIT:
375     CHECK_REPEAT (interval);
376 root 1.9 CODE:
377 root 1.15 RETVAL = e_new (sizeof (struct ev_periodic), cb);
378 root 1.29 ev_periodic_set (RETVAL, at, interval);
379     if (!ix) ev_periodic_start (RETVAL);
380 root 1.9 OUTPUT:
381     RETVAL
382    
383 root 1.15 struct ev_signal *signal (Signal signum, SV *cb)
384 root 1.1 ALIAS:
385 root 1.15 signal_ns = 1
386 root 1.1 CODE:
387 root 1.15 RETVAL = e_new (sizeof (struct ev_signal), cb);
388 root 1.29 ev_signal_set (RETVAL, signum);
389     if (!ix) ev_signal_start (RETVAL);
390 root 1.1 OUTPUT:
391     RETVAL
392    
393 root 1.15 struct ev_idle *idle (SV *cb)
394 root 1.1 ALIAS:
395 root 1.15 idle_ns = 1
396 root 1.1 CODE:
397 root 1.15 RETVAL = e_new (sizeof (struct ev_idle), cb);
398 root 1.29 ev_idle_set (RETVAL);
399     if (!ix) ev_idle_start (RETVAL);
400 root 1.1 OUTPUT:
401     RETVAL
402    
403 root 1.22 struct ev_prepare *prepare (SV *cb)
404     ALIAS:
405     prepare_ns = 1
406     CODE:
407     RETVAL = e_new (sizeof (struct ev_prepare), cb);
408 root 1.29 ev_prepare_set (RETVAL);
409     if (!ix) ev_prepare_start (RETVAL);
410 root 1.22 OUTPUT:
411     RETVAL
412    
413 root 1.15 struct ev_check *check (SV *cb)
414 root 1.1 ALIAS:
415 root 1.15 check_ns = 1
416 root 1.1 CODE:
417 root 1.15 RETVAL = e_new (sizeof (struct ev_check), cb);
418 root 1.29 ev_check_set (RETVAL);
419     if (!ix) ev_check_start (RETVAL);
420 root 1.1 OUTPUT:
421     RETVAL
422    
423 root 1.25 struct ev_child *child (int pid, SV *cb)
424 root 1.23 ALIAS:
425     check_ns = 1
426     CODE:
427     RETVAL = e_new (sizeof (struct ev_check), cb);
428 root 1.29 ev_child_set (RETVAL, pid);
429     if (!ix) ev_child_start (RETVAL);
430 root 1.23 OUTPUT:
431     RETVAL
432    
433 root 1.15
434 root 1.1 PROTOTYPES: DISABLE
435    
436 root 1.15 MODULE = EV PACKAGE = EV::Watcher PREFIX = ev_
437 root 1.1
438 root 1.15 int ev_is_active (struct ev_watcher *w)
439 root 1.1
440 root 1.15 SV *cb (struct ev_watcher *w, SV *new_cb = 0)
441 root 1.1 CODE:
442 root 1.15 {
443     RETVAL = newSVsv (w->cb_sv);
444    
445     if (items > 1)
446     sv_setsv (w->cb_sv, new_cb);
447     }
448 root 1.1 OUTPUT:
449     RETVAL
450    
451 root 1.28 void trigger (struct ev_watcher *w, int revents = EV_NONE)
452     CODE:
453     w->cb (w, revents);
454    
455 root 1.41 int priority (struct ev_watcher *w, int new_priority = 0)
456     CODE:
457     {
458     RETVAL = w->priority;
459    
460     if (items > 1)
461     {
462     int active = ev_is_active (w);
463    
464     if (new_priority < EV_MINPRI || new_priority > EV_MAXPRI)
465     croak ("watcher priority out of range, value must be between %d and %d, inclusive", EV_MINPRI, EV_MAXPRI);
466    
467     if (active)
468     {
469     /* grrr. */
470     PUSHMARK (SP);
471     XPUSHs (ST (0));
472     call_method ("stop", G_DISCARD | G_VOID);
473     }
474    
475     ev_set_priority (w, new_priority);
476    
477     if (active)
478     {
479     PUSHMARK (SP);
480     XPUSHs (ST (0));
481     call_method ("start", G_DISCARD | G_VOID);
482     }
483     }
484     }
485     OUTPUT:
486     RETVAL
487    
488 root 1.29 MODULE = EV PACKAGE = EV::Io PREFIX = ev_io_
489 root 1.1
490 root 1.29 void ev_io_start (struct ev_io *w)
491 root 1.1
492 root 1.29 void ev_io_stop (struct ev_io *w)
493 root 1.15
494 root 1.26 void DESTROY (struct ev_io *w)
495     CODE:
496 root 1.29 ev_io_stop (w);
497 root 1.34 e_destroy (w);
498 root 1.26
499 root 1.15 void set (struct ev_io *w, SV *fh, int events)
500 root 1.1 CODE:
501     {
502 root 1.41 int active = ev_is_active (w);
503 root 1.31 int fd = sv_fileno (fh);
504     CHECK_FD (fh, fd);
505    
506 root 1.29 if (active) ev_io_stop (w);
507 root 1.1
508 root 1.15 sv_setsv (w->fh, fh);
509 root 1.31 ev_io_set (w, fd, events);
510 root 1.1
511 root 1.29 if (active) ev_io_start (w);
512 root 1.15 }
513 root 1.1
514 root 1.15 SV *fh (struct ev_io *w, SV *new_fh = 0)
515 root 1.1 CODE:
516 root 1.15 {
517     RETVAL = newSVsv (w->fh);
518 root 1.1
519 root 1.15 if (items > 1)
520     {
521 root 1.41 int active = ev_is_active (w);
522 root 1.29 if (active) ev_io_stop (w);
523 root 1.1
524 root 1.15 sv_setsv (w->fh, new_fh);
525 root 1.29 ev_io_set (w, sv_fileno (w->fh), w->events);
526 root 1.1
527 root 1.29 if (active) ev_io_start (w);
528 root 1.15 }
529     }
530 root 1.1 OUTPUT:
531     RETVAL
532    
533 root 1.37 int events (struct ev_io *w, int new_events = EV_UNDEF)
534 root 1.1 CODE:
535 root 1.15 {
536     RETVAL = w->events;
537    
538     if (items > 1)
539     {
540 root 1.41 int active = ev_is_active (w);
541 root 1.29 if (active) ev_io_stop (w);
542 root 1.15
543 root 1.29 ev_io_set (w, w->fd, new_events);
544 root 1.15
545 root 1.29 if (active) ev_io_start (w);
546 root 1.15 }
547     }
548 root 1.1 OUTPUT:
549     RETVAL
550    
551 root 1.29 MODULE = EV PACKAGE = EV::Signal PREFIX = ev_signal_
552 root 1.15
553 root 1.29 void ev_signal_start (struct ev_signal *w)
554 root 1.15
555 root 1.29 void ev_signal_stop (struct ev_signal *w)
556 root 1.15
557 root 1.26 void DESTROY (struct ev_signal *w)
558     CODE:
559 root 1.29 ev_signal_stop (w);
560 root 1.34 e_destroy (w);
561 root 1.26
562 root 1.40 void set (struct ev_signal *w, SV *signal)
563 root 1.1 CODE:
564 root 1.15 {
565     Signal signum = sv_signum (signal); /* may croak here */
566 root 1.41 int active = ev_is_active (w);
567 root 1.15
568 root 1.29 if (active) ev_signal_stop (w);
569 root 1.39
570 root 1.29 ev_signal_set (w, signum);
571 root 1.39
572 root 1.29 if (active) ev_signal_start (w);
573 root 1.15 }
574    
575 root 1.39 int signal (struct ev_signal *w, SV *new_signal = 0)
576     CODE:
577     {
578     RETVAL = w->signum;
579    
580     if (items > 1)
581     {
582 root 1.40 Signal signum = sv_signum (new_signal); /* may croak here */
583 root 1.41 int active = ev_is_active (w);
584 root 1.39 if (active) ev_signal_stop (w);
585    
586     ev_signal_set (w, signum);
587    
588     if (active) ev_signal_start (w);
589     }
590     }
591     OUTPUT:
592     RETVAL
593    
594 root 1.15 MODULE = EV PACKAGE = EV::Time
595    
596 root 1.29 MODULE = EV PACKAGE = EV::Timer PREFIX = ev_timer_
597 root 1.15
598 root 1.29 void ev_timer_start (struct ev_timer *w)
599 root 1.18 INIT:
600     CHECK_REPEAT (w->repeat);
601 root 1.15
602 root 1.29 void ev_timer_stop (struct ev_timer *w)
603 root 1.1
604 root 1.29 void ev_timer_again (struct ev_timer *w)
605 root 1.18 INIT:
606     CHECK_REPEAT (w->repeat);
607 root 1.17
608 root 1.26 void DESTROY (struct ev_timer *w)
609     CODE:
610 root 1.29 ev_timer_stop (w);
611 root 1.34 e_destroy (w);
612 root 1.26
613 root 1.15 void set (struct ev_timer *w, NV after, NV repeat = 0.)
614 root 1.18 INIT:
615     CHECK_REPEAT (repeat);
616 root 1.1 CODE:
617 root 1.15 {
618 root 1.41 int active = ev_is_active (w);
619 root 1.29 if (active) ev_timer_stop (w);
620     ev_timer_set (w, after, repeat);
621     if (active) ev_timer_start (w);
622 root 1.15 }
623 root 1.1
624 root 1.29 MODULE = EV PACKAGE = EV::Periodic PREFIX = ev_periodic_
625 root 1.15
626 root 1.29 void ev_periodic_start (struct ev_periodic *w)
627 root 1.18 INIT:
628     CHECK_REPEAT (w->interval);
629 root 1.1
630 root 1.29 void ev_periodic_stop (struct ev_periodic *w)
631 root 1.1
632 root 1.26 void DESTROY (struct ev_periodic *w)
633     CODE:
634 root 1.29 ev_periodic_stop (w);
635 root 1.34 e_destroy (w);
636 root 1.26
637 root 1.15 void set (struct ev_periodic *w, NV at, NV interval = 0.)
638 root 1.18 INIT:
639     CHECK_REPEAT (interval);
640 root 1.10 CODE:
641     {
642 root 1.41 int active = ev_is_active (w);
643 root 1.29 if (active) ev_periodic_stop (w);
644 root 1.39
645 root 1.29 ev_periodic_set (w, at, interval);
646 root 1.39
647 root 1.29 if (active) ev_periodic_start (w);
648 root 1.15 }
649 root 1.10
650 root 1.29 MODULE = EV PACKAGE = EV::Idle PREFIX = ev_idle_
651 root 1.10
652 root 1.29 void ev_idle_start (struct ev_idle *w)
653 root 1.10
654 root 1.29 void ev_idle_stop (struct ev_idle *w)
655 root 1.10
656 root 1.26 void DESTROY (struct ev_idle *w)
657     CODE:
658 root 1.29 ev_idle_stop (w);
659 root 1.34 e_destroy (w);
660 root 1.26
661 root 1.29 MODULE = EV PACKAGE = EV::Prepare PREFIX = ev_check_
662 root 1.22
663 root 1.29 void ev_prepare_start (struct ev_prepare *w)
664 root 1.22
665 root 1.29 void ev_prepare_stop (struct ev_prepare *w)
666 root 1.22
667 root 1.26 void DESTROY (struct ev_prepare *w)
668     CODE:
669 root 1.29 ev_prepare_stop (w);
670 root 1.34 e_destroy (w);
671 root 1.26
672 root 1.29 MODULE = EV PACKAGE = EV::Check PREFIX = ev_check_
673 root 1.1
674 root 1.29 void ev_check_start (struct ev_check *w)
675 root 1.1
676 root 1.29 void ev_check_stop (struct ev_check *w)
677 root 1.1
678 root 1.26 void DESTROY (struct ev_check *w)
679     CODE:
680 root 1.29 ev_check_stop (w);
681 root 1.34 e_destroy (w);
682 root 1.26
683 root 1.29 MODULE = EV PACKAGE = EV::Child PREFIX = ev_child_
684 root 1.23
685 root 1.29 void ev_child_start (struct ev_child *w)
686 root 1.23
687 root 1.29 void ev_child_stop (struct ev_child *w)
688 root 1.23
689 root 1.26 void DESTROY (struct ev_child *w)
690     CODE:
691 root 1.29 ev_child_stop (w);
692 root 1.34 e_destroy (w);
693 root 1.26
694 root 1.23 void set (struct ev_child *w, int pid)
695     CODE:
696     {
697 root 1.41 int active = ev_is_active (w);
698 root 1.29 if (active) ev_child_stop (w);
699 root 1.39
700 root 1.29 ev_child_set (w, pid);
701 root 1.39
702 root 1.29 if (active) ev_child_start (w);
703 root 1.23 }
704    
705 root 1.39 int pid (struct ev_child *w, int new_pid = 0)
706     CODE:
707     {
708 root 1.40 RETVAL = w->pid;
709 root 1.39
710     if (items > 1)
711     {
712 root 1.41 int active = ev_is_active (w);
713 root 1.39 if (active) ev_child_stop (w);
714    
715     ev_child_set (w, new_pid);
716    
717     if (active) ev_child_start (w);
718     }
719     }
720     OUTPUT:
721     RETVAL
722    
723    
724 root 1.24 int status (struct ev_child *w)
725     CODE:
726     RETVAL = w->status;
727     OUTPUT:
728     RETVAL
729    
730 root 1.1 MODULE = EV PACKAGE = EV::DNS PREFIX = evdns_
731    
732     BOOT:
733     {
734     HV *stash = gv_stashpv ("EV::DNS", 1);
735    
736     static const struct {
737     const char *name;
738     IV iv;
739     } *civ, const_iv[] = {
740     # define const_iv(pfx, name) { # name, (IV) pfx ## name },
741     const_iv (DNS_, ERR_NONE)
742     const_iv (DNS_, ERR_FORMAT)
743     const_iv (DNS_, ERR_SERVERFAILED)
744     const_iv (DNS_, ERR_NOTEXIST)
745     const_iv (DNS_, ERR_NOTIMPL)
746     const_iv (DNS_, ERR_REFUSED)
747     const_iv (DNS_, ERR_TRUNCATED)
748     const_iv (DNS_, ERR_UNKNOWN)
749     const_iv (DNS_, ERR_TIMEOUT)
750     const_iv (DNS_, ERR_SHUTDOWN)
751     const_iv (DNS_, IPv4_A)
752     const_iv (DNS_, PTR)
753     const_iv (DNS_, IPv6_AAAA)
754     const_iv (DNS_, QUERY_NO_SEARCH)
755     const_iv (DNS_, OPTION_SEARCH)
756     const_iv (DNS_, OPTION_NAMESERVERS)
757     const_iv (DNS_, OPTION_MISC)
758     const_iv (DNS_, OPTIONS_ALL)
759     const_iv (DNS_, NO_SEARCH)
760     };
761    
762     for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
763     newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
764     }
765    
766     int evdns_init ()
767    
768     void evdns_shutdown (int fail_requests = 1)
769    
770     const char *evdns_err_to_string (int err)
771    
772     int evdns_nameserver_add (U32 address)
773    
774     int evdns_count_nameservers ()
775    
776     int evdns_clear_nameservers_and_suspend ()
777    
778     int evdns_resume ()
779    
780     int evdns_nameserver_ip_add (char *ip_as_string)
781    
782     int evdns_resolve_ipv4 (const char *name, int flags, SV *cb)
783     C_ARGS: name, flags, dns_cb, (void *)SvREFCNT_inc (cb)
784    
785     int evdns_resolve_ipv6 (const char *name, int flags, SV *cb)
786     C_ARGS: name, flags, dns_cb, (void *)SvREFCNT_inc (cb)
787    
788     int evdns_resolve_reverse (SV *addr, int flags, SV *cb)
789     ALIAS:
790     evdns_resolve_reverse_ipv6 = 1
791     CODE:
792     {
793     STRLEN len;
794     char *data = SvPVbyte (addr, len);
795     if (len != (ix ? 16 : 4))
796 root 1.8 croak ("ipv4/ipv6 address to be resolved must be given as 4/16 byte octet string");
797 root 1.1
798     RETVAL = ix
799     ? evdns_resolve_reverse_ipv6 ((struct in6_addr *)data, flags, dns_cb, (void *)SvREFCNT_inc (cb))
800     : evdns_resolve_reverse ((struct in_addr *)data, flags, dns_cb, (void *)SvREFCNT_inc (cb));
801     }
802     OUTPUT:
803     RETVAL
804    
805     int evdns_set_option (char *option, char *val, int flags)
806    
807     int evdns_resolv_conf_parse (int flags, const char *filename)
808    
809     #ifdef MS_WINDOWS
810    
811     int evdns_config_windows_nameservers ()
812    
813     #endif
814    
815     void evdns_search_clear ()
816    
817     void evdns_search_add (char *domain)
818    
819     void evdns_search_ndots_set (int ndots)
820    
821 root 1.36 #if 0
822 root 1.5
823     MODULE = EV PACKAGE = EV::HTTP PREFIX = evhttp_
824    
825     BOOT:
826     {
827     HV *stash = gv_stashpv ("EV::HTTP", 1);
828    
829     static const struct {
830     const char *name;
831     IV iv;
832     } *civ, const_iv[] = {
833     # define const_iv(pfx, name) { # name, (IV) pfx ## name },
834     const_iv (HTTP_, OK)
835     const_iv (HTTP_, NOCONTENT)
836     const_iv (HTTP_, MOVEPERM)
837     const_iv (HTTP_, MOVETEMP)
838     const_iv (HTTP_, NOTMODIFIED)
839     const_iv (HTTP_, BADREQUEST)
840     const_iv (HTTP_, NOTFOUND)
841     const_iv (HTTP_, SERVUNAVAIL)
842     const_iv (EVHTTP_, REQ_OWN_CONNECTION)
843     const_iv (EVHTTP_, PROXY_REQUEST)
844     const_iv (EVHTTP_, REQ_GET)
845     const_iv (EVHTTP_, REQ_POST)
846     const_iv (EVHTTP_, REQ_HEAD)
847     const_iv (EVHTTP_, REQUEST)
848     const_iv (EVHTTP_, RESPONSE)
849     };
850    
851     for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
852     newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
853     }
854    
855     MODULE = EV PACKAGE = EV::HTTP::Request PREFIX = evhttp_request_
856    
857     #HttpRequest new (SV *klass, SV *cb)
858    
859     #void DESTROY (struct evhttp_request *req);
860    
861 root 1.15 #endif
862    
863 root 1.5
864    
865    
866    
867    
868    
869