ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/EV/EV.xs
Revision: 1.16
Committed: Wed Oct 31 10:53:54 2007 UTC (16 years, 6 months ago) by root
Branch: MAIN
Changes since 1.15: +2 -0 lines
Log Message:
EV first rough cut

File Contents

# User Rev Content
1 root 1.1 #include "EXTERN.h"
2     #include "perl.h"
3     #include "XSUB.h"
4    
5     #include <math.h>
6     #include <netinet/in.h>
7    
8 root 1.15 #define TIMEOUT_NONE HUGE_VAL
9 root 1.1
10 root 1.15 #define EV_COMMON \
11     SV *self; /* contains this struct */ \
12     SV *cb_sv, *fh;
13 root 1.1
14 root 1.11 #include "EV/EVAPI.h"
15    
16 root 1.16 #include "libev/ev.c"
17    
18 root 1.10 typedef int Signal;
19 root 1.1
20 root 1.11 static struct EVAPI evapi;
21    
22 root 1.15 static HV
23     *stash_watcher,
24     *stash_io,
25     *stash_time,
26     *stash_timer,
27     *stash_periodic,
28     *stash_signal,
29     *stash_idle,
30     *stash_check;
31 root 1.1
32 root 1.10 static int
33     sv_signum (SV *sig)
34     {
35     int signum;
36    
37     if (SvIV (sig) > 0)
38     return SvIV (sig);
39    
40     for (signum = 1; signum < SIG_SIZE; ++signum)
41     if (strEQ (SvPV_nolen (sig), PL_sig_name [signum]))
42     return signum;
43    
44     return -1;
45     }
46    
47 root 1.11 static void
48     api_once (int fd, short events, double timeout, void (*cb)(int, short, void *), void *arg)
49     {
50 root 1.15 #if 0
51 root 1.12 if (timeout >= 0.)
52 root 1.11 {
53     struct timeval tv;
54     tv_set (&tv, timeout);
55     event_once (fd, events, cb, arg, &tv);
56     }
57     else
58     event_once (fd, events, cb, arg, 0);
59 root 1.15 #endif
60 root 1.11 }
61    
62 root 1.1 /////////////////////////////////////////////////////////////////////////////
63     // Event
64    
65 root 1.15 static void e_cb (struct ev_watcher *w, int revents);
66 root 1.1
67 root 1.15 static int
68     sv_fileno (SV *fh)
69 root 1.1 {
70 root 1.3 SvGETMAGIC (fh);
71 root 1.1
72 root 1.3 if (SvROK (fh))
73     fh = SvRV (fh);
74 root 1.1
75 root 1.3 if (SvTYPE (fh) == SVt_PVGV)
76     return PerlIO_fileno (IoIFP (sv_2io (fh)));
77 root 1.1
78 root 1.3 if (SvIOK (fh))
79     return SvIV (fh);
80 root 1.1
81     return -1;
82     }
83    
84 root 1.15 static void *
85     e_new (int size, SV *cb_sv)
86 root 1.1 {
87 root 1.15 struct ev_watcher *w;
88     SV *self = NEWSV (0, size);
89 root 1.1 SvPOK_only (self);
90 root 1.15 SvCUR_set (self, size);
91 root 1.1
92 root 1.15 w = (struct ev_watcher *)SvPVX (self);
93 root 1.1
94 root 1.15 evw_init (w, e_cb);
95 root 1.1
96 root 1.15 w->fh = 0;
97     w->cb_sv = newSVsv (cb_sv);
98     w->self = self;
99 root 1.1
100 root 1.15 return (void *)w;
101 root 1.1 }
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     SV *sv_self, *sv_events;
126     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.1 PUTBACK;
143 root 1.15 call_sv (w->cb_sv, G_DISCARD | G_VOID | G_EVAL);
144 root 1.14 SP = PL_stack_base + mark; PUTBACK;
145    
146     SvREFCNT_dec (sv_self);
147    
148     if (sv_events_cache)
149     SvREFCNT_dec (sv_events);
150     else
151     sv_events_cache = sv_events;
152 root 1.1
153 root 1.8 if (SvTRUE (ERRSV))
154     {
155     PUSHMARK (SP);
156     PUTBACK;
157     call_sv (get_sv ("EV::DIED", 1), G_DISCARD | G_VOID | G_EVAL | G_KEEPERR);
158 root 1.14 SP = PL_stack_base + mark; PUTBACK;
159 root 1.8 }
160 root 1.1 }
161    
162 root 1.15 #if 0
163 root 1.1 /////////////////////////////////////////////////////////////////////////////
164     // DNS
165    
166     static void
167     dns_cb (int result, char type, int count, int ttl, void *addresses, void *arg)
168     {
169     dSP;
170     SV *cb = (SV *)arg;
171    
172     ENTER;
173     SAVETMPS;
174     PUSHMARK (SP);
175     EXTEND (SP, count + 3);
176     PUSHs (sv_2mortal (newSViv (result)));
177    
178     if (result == DNS_ERR_NONE && ttl >= 0)
179     {
180     int i;
181    
182     PUSHs (sv_2mortal (newSViv (type)));
183     PUSHs (sv_2mortal (newSViv (ttl)));
184    
185     for (i = 0; i < count; ++i)
186     switch (type)
187     {
188     case DNS_IPv6_AAAA:
189     PUSHs (sv_2mortal (newSVpvn (i * 16 + (char *)addresses, 16)));
190     break;
191     case DNS_IPv4_A:
192     PUSHs (sv_2mortal (newSVpvn (i * 4 + (char *)addresses, 4)));
193     break;
194     case DNS_PTR:
195     PUSHs (sv_2mortal (newSVpv (*(char **)addresses, 0)));
196     break;
197     }
198     }
199    
200     PUTBACK;
201     call_sv (sv_2mortal (cb), G_DISCARD | G_VOID | G_EVAL);
202    
203     FREETMPS;
204 root 1.8
205     if (SvTRUE (ERRSV))
206     {
207     PUSHMARK (SP);
208     PUTBACK;
209     call_sv (get_sv ("EV::DIED", 1), G_DISCARD | G_VOID | G_EVAL | G_KEEPERR);
210     }
211    
212 root 1.1 LEAVE;
213     }
214 root 1.15 #endif
215 root 1.1
216     /////////////////////////////////////////////////////////////////////////////
217     // XS interface functions
218    
219 root 1.15 MODULE = EV PACKAGE = EV PREFIX = ev_
220 root 1.1
221     BOOT:
222     {
223 root 1.10 int i;
224 root 1.1 HV *stash = gv_stashpv ("EV", 1);
225    
226     static const struct {
227     const char *name;
228     IV iv;
229     } *civ, const_iv[] = {
230     # define const_iv(pfx, name) { # name, (IV) pfx ## name },
231     const_iv (EV_, NONE)
232     const_iv (EV_, TIMEOUT)
233     const_iv (EV_, READ)
234     const_iv (EV_, WRITE)
235     const_iv (EV_, SIGNAL)
236 root 1.15 const_iv (EV_, IDLE)
237     const_iv (EV_, CHECK)
238    
239     const_iv (EV, LOOP_ONESHOT)
240 root 1.1 const_iv (EV, LOOP_NONBLOCK)
241 root 1.15
242     const_iv (EV, METHOD_NONE)
243     const_iv (EV, METHOD_SELECT)
244     const_iv (EV, METHOD_EPOLL)
245 root 1.1 };
246    
247     for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
248     newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
249    
250 root 1.15 stash_watcher = gv_stashpv ("EV::Watcher" , 1);
251     stash_io = gv_stashpv ("EV::IO" , 1);
252     stash_time = gv_stashpv ("EV::Time" , 1);
253     stash_timer = gv_stashpv ("EV::Timer" , 1);
254     stash_periodic = gv_stashpv ("EV::Periodic", 1);
255     stash_signal = gv_stashpv ("EV::Signal" , 1);
256     stash_idle = gv_stashpv ("EV::Idle" , 1);
257     stash_check = gv_stashpv ("EV::Check" , 1);
258 root 1.11
259     {
260     SV *sv = perl_get_sv ("EV::API", TRUE);
261     perl_get_sv ("EV::API", TRUE); /* silence 5.10 warning */
262    
263 root 1.15 /* the poor man's shared library emulator */
264     evapi.ver = EV_API_VERSION;
265     evapi.rev = EV_API_REVISION;
266     evapi.once = api_once;
267     evapi.sv_fileno = sv_fileno;
268     evapi.sv_signum = sv_signum;
269     evapi.now = &ev_now;
270     evapi.method = &ev_method;
271     evapi.loop_done = &ev_loop_done;
272     evapi.time = ev_time;
273     evapi.loop = ev_loop;
274     evapi.io_start = evio_start;
275     evapi.io_stop = evio_stop;
276     evapi.timer_start = evtimer_start;
277     evapi.timer_stop = evtimer_stop;
278     evapi.periodic_start = evperiodic_start;
279     evapi.periodic_stop = evperiodic_stop;
280     evapi.signal_start = evsignal_start;
281     evapi.signal_stop = evsignal_stop;
282     evapi.idle_start = evidle_start;
283     evapi.idle_stop = evidle_stop;
284     evapi.check_start = evcheck_start;
285     evapi.check_stop = evcheck_stop;
286 root 1.11
287     sv_setiv (sv, (IV)&evapi);
288     SvREADONLY_on (sv);
289     }
290 root 1.1 }
291    
292 root 1.15 NV ev_now ()
293 root 1.1 CODE:
294 root 1.15 RETVAL = ev_now;
295 root 1.1 OUTPUT:
296     RETVAL
297    
298 root 1.15 int ev_method ()
299 root 1.1 CODE:
300 root 1.15 RETVAL = ev_method;
301 root 1.1 OUTPUT:
302     RETVAL
303    
304 root 1.15 NV ev_time ()
305 root 1.1
306 root 1.15 void ev_init (int flags = 0)
307 root 1.1
308 root 1.15 void ev_loop (int flags = 0)
309 root 1.1
310 root 1.15 void ev_loop_done (int value = 1)
311 root 1.1 CODE:
312 root 1.15 ev_loop_done = value;
313 root 1.1
314 root 1.15 struct ev_io *io (SV *fh, int events, SV *cb)
315     ALIAS:
316     io_ns = 1
317 root 1.1 CODE:
318 root 1.15 RETVAL = e_new (sizeof (struct ev_io), cb);
319     RETVAL->fh = newSVsv (fh);
320     evio_set (RETVAL, sv_fileno (RETVAL->fh), events);
321     if (!ix) evio_start (RETVAL);
322 root 1.1 OUTPUT:
323     RETVAL
324    
325 root 1.15 struct ev_timer *timer (NV after, NV repeat, SV *cb)
326 root 1.1 ALIAS:
327 root 1.15 timer_ns = 1
328 root 1.1 CODE:
329 root 1.15 RETVAL = e_new (sizeof (struct ev_timer), cb);
330     evtimer_set (RETVAL, after, repeat);
331     if (!ix) evtimer_start (RETVAL);
332 root 1.1 OUTPUT:
333     RETVAL
334    
335 root 1.15 struct ev_periodic *periodic (NV at, NV interval, SV *cb)
336 root 1.9 ALIAS:
337 root 1.15 periodic_ns = 1
338 root 1.9 CODE:
339 root 1.15 RETVAL = e_new (sizeof (struct ev_periodic), cb);
340     evperiodic_set (RETVAL, at, interval);
341     if (!ix) evperiodic_start (RETVAL);
342 root 1.9 OUTPUT:
343     RETVAL
344    
345 root 1.15 struct ev_signal *signal (Signal signum, SV *cb)
346 root 1.1 ALIAS:
347 root 1.15 signal_ns = 1
348 root 1.1 CODE:
349 root 1.15 RETVAL = e_new (sizeof (struct ev_signal), cb);
350     evsignal_set (RETVAL, signum);
351     if (!ix) evsignal_start (RETVAL);
352 root 1.1 OUTPUT:
353     RETVAL
354    
355 root 1.15 struct ev_idle *idle (SV *cb)
356 root 1.1 ALIAS:
357 root 1.15 idle_ns = 1
358 root 1.1 CODE:
359 root 1.15 RETVAL = e_new (sizeof (struct ev_idle), cb);
360     evidle_set (RETVAL);
361     if (!ix) evidle_start (RETVAL);
362 root 1.1 OUTPUT:
363     RETVAL
364    
365 root 1.15 struct ev_check *check (SV *cb)
366 root 1.1 ALIAS:
367 root 1.15 check_ns = 1
368 root 1.1 CODE:
369 root 1.15 RETVAL = e_new (sizeof (struct ev_check), cb);
370     evcheck_set (RETVAL);
371     if (!ix) evcheck_start (RETVAL);
372 root 1.1 OUTPUT:
373     RETVAL
374    
375 root 1.15
376 root 1.1 PROTOTYPES: DISABLE
377    
378 root 1.15 MODULE = EV PACKAGE = EV::Watcher PREFIX = ev_
379 root 1.1
380 root 1.15 int ev_is_active (struct ev_watcher *w)
381 root 1.1
382 root 1.15 SV *cb (struct ev_watcher *w, SV *new_cb = 0)
383 root 1.1 CODE:
384 root 1.15 {
385     RETVAL = newSVsv (w->cb_sv);
386    
387     if (items > 1)
388     sv_setsv (w->cb_sv, new_cb);
389     }
390 root 1.1 OUTPUT:
391     RETVAL
392    
393 root 1.15 MODULE = EV PACKAGE = EV::IO PREFIX = evio_
394 root 1.1
395 root 1.15 void evio_start (struct ev_io *w)
396 root 1.1
397 root 1.15 void evio_stop (struct ev_io *w)
398    
399     void set (struct ev_io *w, SV *fh, int events)
400 root 1.1 CODE:
401     {
402 root 1.15 int active = w->active;
403     if (active) evio_stop (w);
404 root 1.1
405 root 1.15 sv_setsv (w->fh, fh);
406     evio_set (w, sv_fileno (w->fh), events);
407 root 1.1
408 root 1.15 if (active) evio_start (w);
409     }
410 root 1.1
411 root 1.15 SV *fh (struct ev_io *w, SV *new_fh = 0)
412 root 1.1 CODE:
413 root 1.15 {
414     RETVAL = newSVsv (w->fh);
415 root 1.1
416 root 1.15 if (items > 1)
417     {
418     int active = w->active;
419     if (active) evio_stop (w);
420 root 1.1
421 root 1.15 sv_setsv (w->fh, new_fh);
422     evio_set (w, sv_fileno (w->fh), w->events);
423 root 1.1
424 root 1.15 if (active) evio_start (w);
425     }
426     }
427 root 1.1 OUTPUT:
428     RETVAL
429    
430 root 1.15 short events (struct ev_io *w, short new_events = EV_UNDEF)
431 root 1.1 CODE:
432 root 1.15 {
433     RETVAL = w->events;
434    
435     if (items > 1)
436     {
437     int active = w->active;
438     if (active) evio_stop (w);
439    
440     evio_set (w, w->fd, new_events);
441    
442     if (active) evio_start (w);
443     }
444     }
445 root 1.1 OUTPUT:
446     RETVAL
447    
448 root 1.15 MODULE = EV PACKAGE = EV::Signal PREFIX = evsignal_
449    
450     void evsignal_start (struct ev_signal *w)
451    
452     void evsignal_stop (struct ev_signal *w)
453    
454     void set (struct ev_signal *w, SV *signal = 0)
455 root 1.1 CODE:
456 root 1.15 {
457     Signal signum = sv_signum (signal); /* may croak here */
458     int active = w->active;
459    
460     if (active) evsignal_stop (w);
461     evsignal_set (w, signum);
462     if (active) evsignal_start (w);
463     }
464    
465     MODULE = EV PACKAGE = EV::Time
466    
467     MODULE = EV PACKAGE = EV::Timer PREFIX = evtimer_
468    
469     void evtimer_start (struct ev_timer *w)
470    
471     void evtimer_stop (struct ev_timer *w)
472 root 1.1
473 root 1.15 void set (struct ev_timer *w, NV after, NV repeat = 0.)
474 root 1.1 CODE:
475 root 1.15 {
476     int active = w->active;
477     if (active) evtimer_stop (w);
478     evtimer_set (w, after, repeat);
479     if (active) evtimer_start (w);
480     }
481 root 1.1
482 root 1.15 MODULE = EV PACKAGE = EV::Periodic PREFIX = evperiodic_
483    
484     void evperiodic_start (struct ev_periodic *w)
485 root 1.1
486 root 1.15 void evperiodic_stop (struct ev_periodic *w)
487 root 1.1
488 root 1.15 void set (struct ev_periodic *w, NV at, NV interval = 0.)
489 root 1.10 CODE:
490     {
491 root 1.15 int active = w->active;
492     if (active) evperiodic_stop (w);
493     evperiodic_set (w, at, interval);
494     if (active) evperiodic_start (w);
495     }
496 root 1.10
497 root 1.15 MODULE = EV PACKAGE = EV::Idle PREFIX = evidle_
498 root 1.10
499 root 1.15 void evidle_start (struct ev_idle *w)
500 root 1.10
501 root 1.15 void evidle_stop (struct ev_idle *w)
502 root 1.10
503 root 1.15 MODULE = EV PACKAGE = EV::Check PREFIX = evcheck_
504 root 1.1
505 root 1.15 void evcheck_start (struct ev_check *w)
506 root 1.1
507 root 1.15 void evcheck_stop (struct ev_check *w)
508 root 1.1
509 root 1.15 #if 0
510 root 1.1
511     MODULE = EV PACKAGE = EV::DNS PREFIX = evdns_
512    
513     BOOT:
514     {
515     HV *stash = gv_stashpv ("EV::DNS", 1);
516    
517     static const struct {
518     const char *name;
519     IV iv;
520     } *civ, const_iv[] = {
521     # define const_iv(pfx, name) { # name, (IV) pfx ## name },
522     const_iv (DNS_, ERR_NONE)
523     const_iv (DNS_, ERR_FORMAT)
524     const_iv (DNS_, ERR_SERVERFAILED)
525     const_iv (DNS_, ERR_NOTEXIST)
526     const_iv (DNS_, ERR_NOTIMPL)
527     const_iv (DNS_, ERR_REFUSED)
528     const_iv (DNS_, ERR_TRUNCATED)
529     const_iv (DNS_, ERR_UNKNOWN)
530     const_iv (DNS_, ERR_TIMEOUT)
531     const_iv (DNS_, ERR_SHUTDOWN)
532     const_iv (DNS_, IPv4_A)
533     const_iv (DNS_, PTR)
534     const_iv (DNS_, IPv6_AAAA)
535     const_iv (DNS_, QUERY_NO_SEARCH)
536     const_iv (DNS_, OPTION_SEARCH)
537     const_iv (DNS_, OPTION_NAMESERVERS)
538     const_iv (DNS_, OPTION_MISC)
539     const_iv (DNS_, OPTIONS_ALL)
540     const_iv (DNS_, NO_SEARCH)
541     };
542    
543     for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
544     newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
545     }
546    
547     int evdns_init ()
548    
549     void evdns_shutdown (int fail_requests = 1)
550    
551     const char *evdns_err_to_string (int err)
552    
553     int evdns_nameserver_add (U32 address)
554    
555     int evdns_count_nameservers ()
556    
557     int evdns_clear_nameservers_and_suspend ()
558    
559     int evdns_resume ()
560    
561     int evdns_nameserver_ip_add (char *ip_as_string)
562    
563     int evdns_resolve_ipv4 (const char *name, int flags, SV *cb)
564     C_ARGS: name, flags, dns_cb, (void *)SvREFCNT_inc (cb)
565    
566     int evdns_resolve_ipv6 (const char *name, int flags, SV *cb)
567     C_ARGS: name, flags, dns_cb, (void *)SvREFCNT_inc (cb)
568    
569     int evdns_resolve_reverse (SV *addr, int flags, SV *cb)
570     ALIAS:
571     evdns_resolve_reverse_ipv6 = 1
572     CODE:
573     {
574     STRLEN len;
575     char *data = SvPVbyte (addr, len);
576     if (len != (ix ? 16 : 4))
577 root 1.8 croak ("ipv4/ipv6 address to be resolved must be given as 4/16 byte octet string");
578 root 1.1
579     RETVAL = ix
580     ? evdns_resolve_reverse_ipv6 ((struct in6_addr *)data, flags, dns_cb, (void *)SvREFCNT_inc (cb))
581     : evdns_resolve_reverse ((struct in_addr *)data, flags, dns_cb, (void *)SvREFCNT_inc (cb));
582     }
583     OUTPUT:
584     RETVAL
585    
586     int evdns_set_option (char *option, char *val, int flags)
587    
588     int evdns_resolv_conf_parse (int flags, const char *filename)
589    
590     #ifdef MS_WINDOWS
591    
592     int evdns_config_windows_nameservers ()
593    
594     #endif
595    
596     void evdns_search_clear ()
597    
598     void evdns_search_add (char *domain)
599    
600     void evdns_search_ndots_set (int ndots)
601    
602 root 1.5
603     MODULE = EV PACKAGE = EV::HTTP PREFIX = evhttp_
604    
605     BOOT:
606     {
607     HV *stash = gv_stashpv ("EV::HTTP", 1);
608    
609     static const struct {
610     const char *name;
611     IV iv;
612     } *civ, const_iv[] = {
613     # define const_iv(pfx, name) { # name, (IV) pfx ## name },
614     const_iv (HTTP_, OK)
615     const_iv (HTTP_, NOCONTENT)
616     const_iv (HTTP_, MOVEPERM)
617     const_iv (HTTP_, MOVETEMP)
618     const_iv (HTTP_, NOTMODIFIED)
619     const_iv (HTTP_, BADREQUEST)
620     const_iv (HTTP_, NOTFOUND)
621     const_iv (HTTP_, SERVUNAVAIL)
622     const_iv (EVHTTP_, REQ_OWN_CONNECTION)
623     const_iv (EVHTTP_, PROXY_REQUEST)
624     const_iv (EVHTTP_, REQ_GET)
625     const_iv (EVHTTP_, REQ_POST)
626     const_iv (EVHTTP_, REQ_HEAD)
627     const_iv (EVHTTP_, REQUEST)
628     const_iv (EVHTTP_, RESPONSE)
629     };
630    
631     for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
632     newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
633     }
634    
635     MODULE = EV PACKAGE = EV::HTTP::Request PREFIX = evhttp_request_
636    
637     #HttpRequest new (SV *klass, SV *cb)
638    
639     #void DESTROY (struct evhttp_request *req);
640    
641 root 1.15 #endif
642    
643 root 1.5
644    
645    
646    
647    
648    
649