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

# Content
1 #include "EXTERN.h"
2 #include "perl.h"
3 #include "XSUB.h"
4
5 #include <math.h>
6 #include <netinet/in.h>
7
8 #define TIMEOUT_NONE HUGE_VAL
9
10 #define EV_COMMON \
11 SV *self; /* contains this struct */ \
12 SV *cb_sv, *fh;
13
14 #include "EV/EVAPI.h"
15
16 #include "libev/ev.c"
17
18 typedef int Signal;
19
20 static struct EVAPI evapi;
21
22 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
32 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 static void
48 api_once (int fd, short events, double timeout, void (*cb)(int, short, void *), void *arg)
49 {
50 #if 0
51 if (timeout >= 0.)
52 {
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 #endif
60 }
61
62 /////////////////////////////////////////////////////////////////////////////
63 // Event
64
65 static void e_cb (struct ev_watcher *w, int revents);
66
67 static int
68 sv_fileno (SV *fh)
69 {
70 SvGETMAGIC (fh);
71
72 if (SvROK (fh))
73 fh = SvRV (fh);
74
75 if (SvTYPE (fh) == SVt_PVGV)
76 return PerlIO_fileno (IoIFP (sv_2io (fh)));
77
78 if (SvIOK (fh))
79 return SvIV (fh);
80
81 return -1;
82 }
83
84 static void *
85 e_new (int size, SV *cb_sv)
86 {
87 struct ev_watcher *w;
88 SV *self = NEWSV (0, size);
89 SvPOK_only (self);
90 SvCUR_set (self, size);
91
92 w = (struct ev_watcher *)SvPVX (self);
93
94 evw_init (w, e_cb);
95
96 w->fh = 0;
97 w->cb_sv = newSVsv (cb_sv);
98 w->self = self;
99
100 return (void *)w;
101 }
102
103 static SV *
104 e_bless (struct ev_watcher *w, HV *stash)
105 {
106 SV *rv;
107
108 if (SvOBJECT (w->self))
109 rv = newRV_inc (w->self);
110 else
111 {
112 rv = newRV_noinc (w->self);
113 sv_bless (rv, stash);
114 SvREADONLY_on (w->self);
115 }
116
117 return rv;
118 }
119
120 static void
121 e_cb (struct ev_watcher *w, int revents)
122 {
123 dSP;
124 I32 mark = SP - PL_stack_base;
125 SV *sv_self, *sv_events;
126 static SV *sv_events_cache;
127
128 sv_self = newRV_inc (w->self); /* w->self MUST be blessed by now */
129
130 if (sv_events_cache)
131 {
132 sv_events = sv_events_cache; sv_events_cache = 0;
133 SvIV_set (sv_events, revents);
134 }
135 else
136 sv_events = newSViv (revents);
137
138 PUSHMARK (SP);
139 EXTEND (SP, 2);
140 PUSHs (sv_self);
141 PUSHs (sv_events);
142 PUTBACK;
143 call_sv (w->cb_sv, G_DISCARD | G_VOID | G_EVAL);
144 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
153 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 SP = PL_stack_base + mark; PUTBACK;
159 }
160 }
161
162 #if 0
163 /////////////////////////////////////////////////////////////////////////////
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
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 LEAVE;
213 }
214 #endif
215
216 /////////////////////////////////////////////////////////////////////////////
217 // XS interface functions
218
219 MODULE = EV PACKAGE = EV PREFIX = ev_
220
221 BOOT:
222 {
223 int i;
224 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 const_iv (EV_, IDLE)
237 const_iv (EV_, CHECK)
238
239 const_iv (EV, LOOP_ONESHOT)
240 const_iv (EV, LOOP_NONBLOCK)
241
242 const_iv (EV, METHOD_NONE)
243 const_iv (EV, METHOD_SELECT)
244 const_iv (EV, METHOD_EPOLL)
245 };
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 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
259 {
260 SV *sv = perl_get_sv ("EV::API", TRUE);
261 perl_get_sv ("EV::API", TRUE); /* silence 5.10 warning */
262
263 /* 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
287 sv_setiv (sv, (IV)&evapi);
288 SvREADONLY_on (sv);
289 }
290 }
291
292 NV ev_now ()
293 CODE:
294 RETVAL = ev_now;
295 OUTPUT:
296 RETVAL
297
298 int ev_method ()
299 CODE:
300 RETVAL = ev_method;
301 OUTPUT:
302 RETVAL
303
304 NV ev_time ()
305
306 void ev_init (int flags = 0)
307
308 void ev_loop (int flags = 0)
309
310 void ev_loop_done (int value = 1)
311 CODE:
312 ev_loop_done = value;
313
314 struct ev_io *io (SV *fh, int events, SV *cb)
315 ALIAS:
316 io_ns = 1
317 CODE:
318 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 OUTPUT:
323 RETVAL
324
325 struct ev_timer *timer (NV after, NV repeat, SV *cb)
326 ALIAS:
327 timer_ns = 1
328 CODE:
329 RETVAL = e_new (sizeof (struct ev_timer), cb);
330 evtimer_set (RETVAL, after, repeat);
331 if (!ix) evtimer_start (RETVAL);
332 OUTPUT:
333 RETVAL
334
335 struct ev_periodic *periodic (NV at, NV interval, SV *cb)
336 ALIAS:
337 periodic_ns = 1
338 CODE:
339 RETVAL = e_new (sizeof (struct ev_periodic), cb);
340 evperiodic_set (RETVAL, at, interval);
341 if (!ix) evperiodic_start (RETVAL);
342 OUTPUT:
343 RETVAL
344
345 struct ev_signal *signal (Signal signum, SV *cb)
346 ALIAS:
347 signal_ns = 1
348 CODE:
349 RETVAL = e_new (sizeof (struct ev_signal), cb);
350 evsignal_set (RETVAL, signum);
351 if (!ix) evsignal_start (RETVAL);
352 OUTPUT:
353 RETVAL
354
355 struct ev_idle *idle (SV *cb)
356 ALIAS:
357 idle_ns = 1
358 CODE:
359 RETVAL = e_new (sizeof (struct ev_idle), cb);
360 evidle_set (RETVAL);
361 if (!ix) evidle_start (RETVAL);
362 OUTPUT:
363 RETVAL
364
365 struct ev_check *check (SV *cb)
366 ALIAS:
367 check_ns = 1
368 CODE:
369 RETVAL = e_new (sizeof (struct ev_check), cb);
370 evcheck_set (RETVAL);
371 if (!ix) evcheck_start (RETVAL);
372 OUTPUT:
373 RETVAL
374
375
376 PROTOTYPES: DISABLE
377
378 MODULE = EV PACKAGE = EV::Watcher PREFIX = ev_
379
380 int ev_is_active (struct ev_watcher *w)
381
382 SV *cb (struct ev_watcher *w, SV *new_cb = 0)
383 CODE:
384 {
385 RETVAL = newSVsv (w->cb_sv);
386
387 if (items > 1)
388 sv_setsv (w->cb_sv, new_cb);
389 }
390 OUTPUT:
391 RETVAL
392
393 MODULE = EV PACKAGE = EV::IO PREFIX = evio_
394
395 void evio_start (struct ev_io *w)
396
397 void evio_stop (struct ev_io *w)
398
399 void set (struct ev_io *w, SV *fh, int events)
400 CODE:
401 {
402 int active = w->active;
403 if (active) evio_stop (w);
404
405 sv_setsv (w->fh, fh);
406 evio_set (w, sv_fileno (w->fh), events);
407
408 if (active) evio_start (w);
409 }
410
411 SV *fh (struct ev_io *w, SV *new_fh = 0)
412 CODE:
413 {
414 RETVAL = newSVsv (w->fh);
415
416 if (items > 1)
417 {
418 int active = w->active;
419 if (active) evio_stop (w);
420
421 sv_setsv (w->fh, new_fh);
422 evio_set (w, sv_fileno (w->fh), w->events);
423
424 if (active) evio_start (w);
425 }
426 }
427 OUTPUT:
428 RETVAL
429
430 short events (struct ev_io *w, short new_events = EV_UNDEF)
431 CODE:
432 {
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 OUTPUT:
446 RETVAL
447
448 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 CODE:
456 {
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
473 void set (struct ev_timer *w, NV after, NV repeat = 0.)
474 CODE:
475 {
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
482 MODULE = EV PACKAGE = EV::Periodic PREFIX = evperiodic_
483
484 void evperiodic_start (struct ev_periodic *w)
485
486 void evperiodic_stop (struct ev_periodic *w)
487
488 void set (struct ev_periodic *w, NV at, NV interval = 0.)
489 CODE:
490 {
491 int active = w->active;
492 if (active) evperiodic_stop (w);
493 evperiodic_set (w, at, interval);
494 if (active) evperiodic_start (w);
495 }
496
497 MODULE = EV PACKAGE = EV::Idle PREFIX = evidle_
498
499 void evidle_start (struct ev_idle *w)
500
501 void evidle_stop (struct ev_idle *w)
502
503 MODULE = EV PACKAGE = EV::Check PREFIX = evcheck_
504
505 void evcheck_start (struct ev_check *w)
506
507 void evcheck_stop (struct ev_check *w)
508
509 #if 0
510
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 croak ("ipv4/ipv6 address to be resolved must be given as 4/16 byte octet string");
578
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
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 #endif
642
643
644
645
646
647
648
649