ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/EV/EV.xs
(Generate patch)

Comparing EV/EV.xs (file contents):
Revision 1.31 by root, Thu Nov 1 11:11:21 2007 UTC vs.
Revision 1.86 by root, Mon Dec 3 13:41:24 2007 UTC

… …
2#include "perl.h" 2#include "perl.h"
3#include "XSUB.h" 3#include "XSUB.h"
4 4
5/*#include <netinet/in.h>*/ 5/*#include <netinet/in.h>*/
6 6
7#define TIMEOUT_NONE HUGE_VAL
8#define EV_USE_EPOLL 1
9
10#define EV_PROTOTYPES 1 7#define EV_PROTOTYPES 1
11#include "EV/EVAPI.h" 8#include "EV/EVAPI.h"
12 9
10/* fix perl api breakage */
11#undef signal
12#undef sigaction
13
14#define EV_SELECT_IS_WINSOCKET 0
15#ifdef _WIN32
16# define EV_SELECT_USE_FD_SET 0
17# define NFDBITS PERL_NFDBITS
18# define fd_mask Perl_fd_mask
19#endif
20/* due to bugs in OS X we have to use libev/ explicitly here */
13#include "libev/ev.c" 21#include "libev/ev.c"
22#include "event.c"
23
24#ifndef _WIN32
25# include <pthread.h>
26#endif
27
28#define WFLAG_KEEPALIVE 1
29
30#define UNREF(w) \
31 if (!((w)->flags & WFLAG_KEEPALIVE) \
32 && !ev_is_active (w)) \
33 ev_unref ();
34
35#define REF(w) \
36 if (!((w)->flags & WFLAG_KEEPALIVE) \
37 && ev_is_active (w)) \
38 ev_ref ();
39
40#define START(type,w) \
41 do { \
42 UNREF (w); \
43 ev_ ## type ## _start (w); \
44 } while (0)
45
46#define STOP(type,w) \
47 do { \
48 REF (w); \
49 ev_ ## type ## _stop (w); \
50 } while (0)
51
52#define RESET(type,w,seta) \
53 do { \
54 int active = ev_is_active (w); \
55 if (active) STOP (type, w); \
56 ev_ ## type ## _set seta; \
57 if (active) START (type, w); \
58 } while (0)
14 59
15typedef int Signal; 60typedef int Signal;
16 61
17static struct EVAPI evapi; 62static struct EVAPI evapi;
18 63
… …
20 *stash_watcher, 65 *stash_watcher,
21 *stash_io, 66 *stash_io,
22 *stash_timer, 67 *stash_timer,
23 *stash_periodic, 68 *stash_periodic,
24 *stash_signal, 69 *stash_signal,
70 *stash_child,
71 *stash_stat,
25 *stash_idle, 72 *stash_idle,
26 *stash_prepare, 73 *stash_prepare,
27 *stash_check, 74 *stash_check,
28 *stash_child; 75 *stash_embed,
76 *stash_fork;
29 77
78#ifndef SIG_SIZE
79/* kudos to Slaven Rezic for the idea */
80static char sig_size [] = { SIG_NUM };
81# define SIG_SIZE (sizeof (sig_size) + 1)
82#endif
83
30static int 84static Signal
31sv_signum (SV *sig) 85sv_signum (SV *sig)
32{ 86{
33 int signum; 87 Signal signum;
34 88
35 SvGETMAGIC (sig); 89 SvGETMAGIC (sig);
36 90
37 for (signum = 1; signum < SIG_SIZE; ++signum) 91 for (signum = 1; signum < SIG_SIZE; ++signum)
38 if (strEQ (SvPV_nolen (sig), PL_sig_name [signum])) 92 if (strEQ (SvPV_nolen (sig), PL_sig_name [signum]))
39 return signum; 93 return signum;
40 94
41 if (SvIV (sig) > 0) 95 signum = SvIV (sig);
96
97 if (signum > 0 && signum < SIG_SIZE)
42 return SvIV (sig); 98 return signum;
43 99
44 return -1; 100 return -1;
45} 101}
46 102
47///////////////////////////////////////////////////////////////////////////// 103/////////////////////////////////////////////////////////////////////////////
48// Event 104// Event
49 105
50static void e_cb (struct ev_watcher *w, int revents); 106static void e_cb (ev_watcher *w, int revents);
51 107
52static int 108static int
53sv_fileno (SV *fh) 109sv_fileno (SV *fh)
54{ 110{
55 SvGETMAGIC (fh); 111 SvGETMAGIC (fh);
… …
58 fh = SvRV (fh); 114 fh = SvRV (fh);
59 115
60 if (SvTYPE (fh) == SVt_PVGV) 116 if (SvTYPE (fh) == SVt_PVGV)
61 return PerlIO_fileno (IoIFP (sv_2io (fh))); 117 return PerlIO_fileno (IoIFP (sv_2io (fh)));
62 118
63 if ((SvIV (fh) >= 0) && (SvIV (fh) < 0x7ffffff)) 119 if (SvOK (fh) && (SvIV (fh) >= 0) && (SvIV (fh) < 0x7fffffffL))
64 return SvIV (fh); 120 return SvIV (fh);
65 121
66 return -1; 122 return -1;
67} 123}
68 124
69static void * 125static void *
70e_new (int size, SV *cb_sv) 126e_new (int size, SV *cb_sv)
71{ 127{
72 struct ev_watcher *w; 128 ev_watcher *w;
73 SV *self = NEWSV (0, size); 129 SV *self = NEWSV (0, size);
74 SvPOK_only (self); 130 SvPOK_only (self);
75 SvCUR_set (self, size); 131 SvCUR_set (self, size);
76 132
77 w = (struct ev_watcher *)SvPVX (self); 133 w = (ev_watcher *)SvPVX (self);
78 134
79 ev_watcher_init (w, e_cb); 135 ev_init (w, e_cb);
80 136
137 w->flags = WFLAG_KEEPALIVE;
138 w->data = 0;
81 w->fh = 0; 139 w->fh = 0;
82 w->cb_sv = newSVsv (cb_sv); 140 w->cb_sv = newSVsv (cb_sv);
83 w->self = self; 141 w->self = self;
84 142
85 return (void *)w; 143 return (void *)w;
86} 144}
87 145
146static void
147e_destroy (void *w_)
148{
149 ev_watcher *w = (ev_watcher *)w_;
150
151 SvREFCNT_dec (w->fh ); w->fh = 0;
152 SvREFCNT_dec (w->cb_sv); w->cb_sv = 0;
153 SvREFCNT_dec (w->data ); w->data = 0;
154}
155
88static SV * 156static SV *
89e_bless (struct ev_watcher *w, HV *stash) 157e_bless (ev_watcher *w, HV *stash)
90{ 158{
91 SV *rv; 159 SV *rv;
92 160
93 if (SvOBJECT (w->self)) 161 if (SvOBJECT (w->self))
94 rv = newRV_inc (w->self); 162 rv = newRV_inc (w->self);
… …
100 } 168 }
101 169
102 return rv; 170 return rv;
103} 171}
104 172
173static SV *sv_events_cache;
174
105static void 175static void
106e_cb (struct ev_watcher *w, int revents) 176e_cb (ev_watcher *w, int revents)
107{ 177{
108 dSP; 178 dSP;
109 I32 mark = SP - PL_stack_base; 179 I32 mark = SP - PL_stack_base;
110 SV *sv_self, *sv_events, *sv_status = 0; 180 SV *sv_self, *sv_events;
111 static SV *sv_events_cache;
112
113 fprintf (stderr, "e_cb %p,%x\n", w, revents);//D
114 181
115 sv_self = newRV_inc (w->self); /* w->self MUST be blessed by now */ 182 sv_self = newRV_inc (w->self); /* w->self MUST be blessed by now */
116 183
117 if (sv_events_cache) 184 if (sv_events_cache)
118 { 185 {
… …
125 PUSHMARK (SP); 192 PUSHMARK (SP);
126 EXTEND (SP, 2); 193 EXTEND (SP, 2);
127 PUSHs (sv_self); 194 PUSHs (sv_self);
128 PUSHs (sv_events); 195 PUSHs (sv_events);
129 196
130 if (revents & EV_CHILD)
131 XPUSHs (sv_status = newSViv (((struct ev_child *)w)->status));
132
133 PUTBACK; 197 PUTBACK;
134 call_sv (w->cb_sv, G_DISCARD | G_VOID | G_EVAL); 198 call_sv (w->cb_sv, G_DISCARD | G_VOID | G_EVAL);
135 SP = PL_stack_base + mark; PUTBACK;
136 199
137 SvREFCNT_dec (sv_self); 200 SvREFCNT_dec (sv_self);
138 SvREFCNT_dec (sv_status);
139 201
140 if (sv_events_cache) 202 if (sv_events_cache)
141 SvREFCNT_dec (sv_events); 203 SvREFCNT_dec (sv_events);
142 else 204 else
143 sv_events_cache = sv_events; 205 sv_events_cache = sv_events;
206
207 if (SvTRUE (ERRSV))
208 {
209 SPAGAIN;
210 PUSHMARK (SP);
211 PUTBACK;
212 call_sv (get_sv ("EV::DIED", 1), G_DISCARD | G_VOID | G_EVAL | G_KEEPERR);
213 }
214
215 SP = PL_stack_base + mark;
216 PUTBACK;
217}
218
219static void
220e_once_cb (int revents, void *arg)
221{
222 dSP;
223 I32 mark = SP - PL_stack_base;
224 SV *sv_events;
225
226 if (sv_events_cache)
227 {
228 sv_events = sv_events_cache; sv_events_cache = 0;
229 SvIV_set (sv_events, revents);
230 }
231 else
232 sv_events = newSViv (revents);
233
234 PUSHMARK (SP);
235 XPUSHs (sv_events);
236
237 PUTBACK;
238 call_sv ((SV *)arg, G_DISCARD | G_VOID | G_EVAL);
239
240 SvREFCNT_dec ((SV *)arg);
241
242 if (sv_events_cache)
243 SvREFCNT_dec (sv_events);
244 else
245 sv_events_cache = sv_events;
246
247 if (SvTRUE (ERRSV))
248 {
249 SPAGAIN;
250 PUSHMARK (SP);
251 PUTBACK;
252 call_sv (get_sv ("EV::DIED", 1), G_DISCARD | G_VOID | G_EVAL | G_KEEPERR);
253 }
254
255 SP = PL_stack_base + mark;
256 PUTBACK;
257}
258
259static ev_tstamp
260e_periodic_cb (ev_periodic *w, ev_tstamp now)
261{
262 ev_tstamp retval;
263 int count;
264 dSP;
265
266 ENTER;
267 SAVETMPS;
268
269 PUSHMARK (SP);
270 EXTEND (SP, 2);
271 PUSHs (newRV_inc (w->self)); /* w->self MUST be blessed by now */
272 PUSHs (newSVnv (now));
273
274 PUTBACK;
275 count = call_sv (w->fh, G_SCALAR | G_EVAL);
276 SPAGAIN;
144 277
145 if (SvTRUE (ERRSV)) 278 if (SvTRUE (ERRSV))
146 { 279 {
147 PUSHMARK (SP); 280 PUSHMARK (SP);
148 PUTBACK; 281 PUTBACK;
149 call_sv (get_sv ("EV::DIED", 1), G_DISCARD | G_VOID | G_EVAL | G_KEEPERR); 282 call_sv (get_sv ("EV::DIED", 1), G_DISCARD | G_VOID | G_EVAL | G_KEEPERR);
150 SP = PL_stack_base + mark; PUTBACK; 283 SPAGAIN;
151 } 284 }
152}
153 285
154#if 0 286 if (count > 0)
155/////////////////////////////////////////////////////////////////////////////
156// DNS
157
158static void
159dns_cb (int result, char type, int count, int ttl, void *addresses, void *arg)
160{
161 dSP;
162 SV *cb = (SV *)arg;
163
164 ENTER;
165 SAVETMPS;
166 PUSHMARK (SP);
167 EXTEND (SP, count + 3);
168 PUSHs (sv_2mortal (newSViv (result)));
169
170 if (result == DNS_ERR_NONE && ttl >= 0)
171 { 287 {
172 int i; 288 retval = SvNV (TOPs);
173 289
174 PUSHs (sv_2mortal (newSViv (type))); 290 if (retval < now)
175 PUSHs (sv_2mortal (newSViv (ttl))); 291 retval = now;
176
177 for (i = 0; i < count; ++i)
178 switch (type)
179 {
180 case DNS_IPv6_AAAA:
181 PUSHs (sv_2mortal (newSVpvn (i * 16 + (char *)addresses, 16)));
182 break;
183 case DNS_IPv4_A:
184 PUSHs (sv_2mortal (newSVpvn (i * 4 + (char *)addresses, 4)));
185 break;
186 case DNS_PTR:
187 PUSHs (sv_2mortal (newSVpv (*(char **)addresses, 0)));
188 break;
189 }
190 } 292 }
191 293 else
192 PUTBACK; 294 retval = now;
193 call_sv (sv_2mortal (cb), G_DISCARD | G_VOID | G_EVAL);
194 295
195 FREETMPS; 296 FREETMPS;
196
197 if (SvTRUE (ERRSV))
198 {
199 PUSHMARK (SP);
200 PUTBACK;
201 call_sv (get_sv ("EV::DIED", 1), G_DISCARD | G_VOID | G_EVAL | G_KEEPERR);
202 }
203
204 LEAVE; 297 LEAVE;
298
299 return retval;
205} 300}
206#endif
207 301
208#define CHECK_REPEAT(repeat) if (repeat < 0.) \ 302#define CHECK_REPEAT(repeat) if (repeat < 0.) \
209 croak (# repeat " value must be >= 0"); 303 croak (# repeat " value must be >= 0");
210 304
211#define CHECK_FD(fh,fd) if ((fd) < 0) \ 305#define CHECK_FD(fh,fd) if ((fd) < 0) \
212 croak ("illegal file descriptor or filehandle (either no attached file descriptor or illegal value): %s", SvPV_nolen (fh)); 306 croak ("illegal file descriptor or filehandle (either no attached file descriptor or illegal value): %s", SvPV_nolen (fh));
213 307
308#define CHECK_SIG(sv,num) if ((num) < 0) \
309 croak ("illegal signal number or name: %s", SvPV_nolen (sv));
310
214///////////////////////////////////////////////////////////////////////////// 311/////////////////////////////////////////////////////////////////////////////
215// XS interface functions 312// XS interface functions
216 313
217MODULE = EV PACKAGE = EV PREFIX = ev_ 314MODULE = EV PACKAGE = EV PREFIX = ev_
218 315
219PROTOTYPES: ENABLE 316PROTOTYPES: ENABLE
220 317
221BOOT: 318BOOT:
222{ 319{
223 int i;
224 HV *stash = gv_stashpv ("EV", 1); 320 HV *stash = gv_stashpv ("EV", 1);
225 321
226 static const struct { 322 static const struct {
227 const char *name; 323 const char *name;
228 IV iv; 324 IV iv;
229 } *civ, const_iv[] = { 325 } *civ, const_iv[] = {
230# define const_iv(pfx, name) { # name, (IV) pfx ## name }, 326# define const_iv(pfx, name) { # name, (IV) pfx ## name },
327 const_iv (EV_, MINPRI)
328 const_iv (EV_, MAXPRI)
329
231 const_iv (EV_, UNDEF) 330 const_iv (EV_, UNDEF)
232 const_iv (EV_, NONE) 331 const_iv (EV_, NONE)
233 const_iv (EV_, TIMEOUT) 332 const_iv (EV_, TIMEOUT)
234 const_iv (EV_, READ) 333 const_iv (EV_, READ)
235 const_iv (EV_, WRITE) 334 const_iv (EV_, WRITE)
… …
238 const_iv (EV_, CHECK) 337 const_iv (EV_, CHECK)
239 const_iv (EV_, ERROR) 338 const_iv (EV_, ERROR)
240 339
241 const_iv (EV, LOOP_ONESHOT) 340 const_iv (EV, LOOP_ONESHOT)
242 const_iv (EV, LOOP_NONBLOCK) 341 const_iv (EV, LOOP_NONBLOCK)
243
244 const_iv (EV, METHOD_NONE) 342 const_iv (EV, UNLOOP_ONE)
343 const_iv (EV, UNLOOP_ALL)
344
245 const_iv (EV, METHOD_SELECT) 345 const_iv (EV, BACKEND_SELECT)
346 const_iv (EV, BACKEND_POLL)
246 const_iv (EV, METHOD_EPOLL) 347 const_iv (EV, BACKEND_EPOLL)
348 const_iv (EV, BACKEND_KQUEUE)
349 const_iv (EV, BACKEND_DEVPOLL)
350 const_iv (EV, BACKEND_PORT)
351 const_iv (EV, FLAG_AUTO)
352 const_iv (EV, FLAG_NOENV)
353 const_iv (EV, FLAG_FORKCHECK)
247 }; 354 };
248 355
249 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 356 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
250 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 357 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
251 358
252 stash_watcher = gv_stashpv ("EV::Watcher" , 1); 359 stash_watcher = gv_stashpv ("EV::Watcher" , 1);
253 stash_io = gv_stashpv ("EV::Io" , 1); 360 stash_io = gv_stashpv ("EV::IO" , 1);
254 stash_timer = gv_stashpv ("EV::Timer" , 1); 361 stash_timer = gv_stashpv ("EV::Timer" , 1);
255 stash_periodic = gv_stashpv ("EV::Periodic", 1); 362 stash_periodic = gv_stashpv ("EV::Periodic", 1);
256 stash_signal = gv_stashpv ("EV::Signal" , 1); 363 stash_signal = gv_stashpv ("EV::Signal" , 1);
257 stash_idle = gv_stashpv ("EV::Idle" , 1); 364 stash_idle = gv_stashpv ("EV::Idle" , 1);
258 stash_prepare = gv_stashpv ("EV::Prepare" , 1); 365 stash_prepare = gv_stashpv ("EV::Prepare" , 1);
259 stash_check = gv_stashpv ("EV::Check" , 1); 366 stash_check = gv_stashpv ("EV::Check" , 1);
260 stash_child = gv_stashpv ("EV::Child" , 1); 367 stash_child = gv_stashpv ("EV::Child" , 1);
368 stash_embed = gv_stashpv ("EV::Embed" , 1);
369 stash_stat = gv_stashpv ("EV::Stat" , 1);
261 370
262 { 371 {
263 SV *sv = perl_get_sv ("EV::API", TRUE); 372 SV *sv = perl_get_sv ("EV::API", TRUE);
264 perl_get_sv ("EV::API", TRUE); /* silence 5.10 warning */ 373 perl_get_sv ("EV::API", TRUE); /* silence 5.10 warning */
265 374
266 /* the poor man's shared library emulator */ 375 /* the poor man's shared library emulator */
267 evapi.ver = EV_API_VERSION; 376 evapi.ver = EV_API_VERSION;
268 evapi.rev = EV_API_REVISION; 377 evapi.rev = EV_API_REVISION;
269 evapi.sv_fileno = sv_fileno; 378 evapi.sv_fileno = sv_fileno;
270 evapi.sv_signum = sv_signum; 379 evapi.sv_signum = sv_signum;
271 evapi.now = &ev_now; 380 evapi.now = ev_now;
272 evapi.method = &ev_method; 381 evapi.backend = ev_backend;
273 evapi.loop_done = &ev_loop_done; 382 evapi.unloop = ev_unloop;
383 evapi.ref = ev_ref;
384 evapi.unref = ev_unref;
274 evapi.time = ev_time; 385 evapi.time = ev_time;
275 evapi.loop = ev_loop; 386 evapi.loop = ev_loop;
276 evapi.once = ev_once; 387 evapi.once = ev_once;
277 evapi.io_start = ev_io_start; 388 evapi.io_start = ev_io_start;
278 evapi.io_stop = ev_io_stop; 389 evapi.io_stop = ev_io_stop;
… …
289 evapi.prepare_stop = ev_prepare_stop; 400 evapi.prepare_stop = ev_prepare_stop;
290 evapi.check_start = ev_check_start; 401 evapi.check_start = ev_check_start;
291 evapi.check_stop = ev_check_stop; 402 evapi.check_stop = ev_check_stop;
292 evapi.child_start = ev_child_start; 403 evapi.child_start = ev_child_start;
293 evapi.child_stop = ev_child_stop; 404 evapi.child_stop = ev_child_stop;
405 evapi.stat_start = ev_stat_start;
406 evapi.stat_stop = ev_stat_stop;
407 evapi.stat_stat = ev_stat_stat;
294 408
295 sv_setiv (sv, (IV)&evapi); 409 sv_setiv (sv, (IV)&evapi);
296 SvREADONLY_on (sv); 410 SvREADONLY_on (sv);
297 } 411 }
412#ifndef _WIN32
413 pthread_atfork (0, 0, ev_default_fork);
414#endif
298} 415}
299 416
300NV ev_now () 417NV ev_now ()
301 CODE:
302 RETVAL = ev_now;
303 OUTPUT:
304 RETVAL
305 418
306int ev_method () 419unsigned int ev_backend ()
307 CODE:
308 RETVAL = ev_method;
309 OUTPUT:
310 RETVAL
311 420
312NV ev_time () 421NV ev_time ()
313 422
314void ev_init (int flags = 0) 423unsigned int ev_default_loop (unsigned int flags = ev_supported_backends ())
424
425unsigned int ev_loop_count ()
315 426
316void ev_loop (int flags = 0) 427void ev_loop (int flags = 0)
317 428
318void ev_loop_done (int value = 1) 429void ev_unloop (int how = 1)
319 CODE:
320 ev_loop_done = value;
321 430
322struct ev_io *io (SV *fh, int events, SV *cb) 431ev_io *io (SV *fh, int events, SV *cb)
323 ALIAS: 432 ALIAS:
324 io_ns = 1 433 io_ns = 1
325 CODE: 434 CODE:
326{ 435{
327 int fd = sv_fileno (fh); 436 int fd = sv_fileno (fh);
328 CHECK_FD (fh, fd); 437 CHECK_FD (fh, fd);
329 438
330 RETVAL = e_new (sizeof (struct ev_io), cb); 439 RETVAL = e_new (sizeof (ev_io), cb);
331 RETVAL->fh = newSVsv (fh); 440 RETVAL->fh = newSVsv (fh);
332 ev_io_set (RETVAL, fd, events); 441 ev_io_set (RETVAL, fd, events);
333 if (!ix) ev_io_start (RETVAL); 442 if (!ix) START (io, RETVAL);
334} 443}
335 OUTPUT: 444 OUTPUT:
336 RETVAL 445 RETVAL
337 446
338struct ev_timer *timer (NV after, NV repeat, SV *cb) 447ev_timer *timer (NV after, NV repeat, SV *cb)
339 ALIAS: 448 ALIAS:
340 timer_ns = 1 449 timer_ns = 1
341 INIT: 450 INIT:
342 CHECK_REPEAT (repeat); 451 CHECK_REPEAT (repeat);
343 CODE: 452 CODE:
344 RETVAL = e_new (sizeof (struct ev_timer), cb); 453 RETVAL = e_new (sizeof (ev_timer), cb);
345 ev_timer_set (RETVAL, after, repeat); 454 ev_timer_set (RETVAL, after, repeat);
346 if (!ix) ev_timer_start (RETVAL); 455 if (!ix) START (timer, RETVAL);
347 OUTPUT: 456 OUTPUT:
348 RETVAL 457 RETVAL
349 458
350struct ev_periodic *periodic (NV at, NV interval, SV *cb) 459SV *periodic (NV at, NV interval, SV *reschedule_cb, SV *cb)
351 ALIAS: 460 ALIAS:
352 periodic_ns = 1 461 periodic_ns = 1
353 INIT: 462 INIT:
354 CHECK_REPEAT (interval); 463 CHECK_REPEAT (interval);
355 CODE: 464 CODE:
465{
466 ev_periodic *w;
356 RETVAL = e_new (sizeof (struct ev_periodic), cb); 467 w = e_new (sizeof (ev_periodic), cb);
357 ev_periodic_set (RETVAL, at, interval); 468 w->fh = SvTRUE (reschedule_cb) ? newSVsv (reschedule_cb) : 0;
358 if (!ix) ev_periodic_start (RETVAL); 469 ev_periodic_set (w, at, interval, w->fh ? e_periodic_cb : 0);
470 RETVAL = e_bless ((ev_watcher *)w, stash_periodic);
471 if (!ix) START (periodic, w);
472}
359 OUTPUT: 473 OUTPUT:
360 RETVAL 474 RETVAL
361 475
362struct ev_signal *signal (Signal signum, SV *cb) 476ev_signal *signal (SV *signal, SV *cb)
363 ALIAS: 477 ALIAS:
364 signal_ns = 1 478 signal_ns = 1
365 CODE: 479 CODE:
480{
481 Signal signum = sv_signum (signal);
482 CHECK_SIG (signal, signum);
483
366 RETVAL = e_new (sizeof (struct ev_signal), cb); 484 RETVAL = e_new (sizeof (ev_signal), cb);
367 ev_signal_set (RETVAL, signum); 485 ev_signal_set (RETVAL, signum);
368 if (!ix) ev_signal_start (RETVAL); 486 if (!ix) START (signal, RETVAL);
487}
369 OUTPUT: 488 OUTPUT:
370 RETVAL 489 RETVAL
371 490
372struct ev_idle *idle (SV *cb) 491ev_idle *idle (SV *cb)
373 ALIAS: 492 ALIAS:
374 idle_ns = 1 493 idle_ns = 1
375 CODE: 494 CODE:
376 RETVAL = e_new (sizeof (struct ev_idle), cb); 495 RETVAL = e_new (sizeof (ev_idle), cb);
377 ev_idle_set (RETVAL); 496 ev_idle_set (RETVAL);
378 if (!ix) ev_idle_start (RETVAL); 497 if (!ix) START (idle, RETVAL);
379 OUTPUT: 498 OUTPUT:
380 RETVAL 499 RETVAL
381 500
382struct ev_prepare *prepare (SV *cb) 501ev_prepare *prepare (SV *cb)
383 ALIAS: 502 ALIAS:
384 prepare_ns = 1 503 prepare_ns = 1
385 CODE: 504 CODE:
386 RETVAL = e_new (sizeof (struct ev_prepare), cb); 505 RETVAL = e_new (sizeof (ev_prepare), cb);
387 ev_prepare_set (RETVAL); 506 ev_prepare_set (RETVAL);
388 if (!ix) ev_prepare_start (RETVAL); 507 if (!ix) START (prepare, RETVAL);
389 OUTPUT: 508 OUTPUT:
390 RETVAL 509 RETVAL
391 510
392struct ev_check *check (SV *cb) 511ev_check *check (SV *cb)
393 ALIAS: 512 ALIAS:
394 check_ns = 1 513 check_ns = 1
395 CODE: 514 CODE:
396 RETVAL = e_new (sizeof (struct ev_check), cb); 515 RETVAL = e_new (sizeof (ev_check), cb);
397 ev_check_set (RETVAL); 516 ev_check_set (RETVAL);
398 if (!ix) ev_check_start (RETVAL); 517 if (!ix) START (check, RETVAL);
399 OUTPUT: 518 OUTPUT:
400 RETVAL 519 RETVAL
401 520
402struct ev_child *child (int pid, SV *cb) 521ev_child *child (int pid, SV *cb)
403 ALIAS: 522 ALIAS:
404 check_ns = 1 523 child_ns = 1
405 CODE: 524 CODE:
406 RETVAL = e_new (sizeof (struct ev_check), cb); 525 RETVAL = e_new (sizeof (ev_child), cb);
407 ev_child_set (RETVAL, pid); 526 ev_child_set (RETVAL, pid);
408 if (!ix) ev_child_start (RETVAL); 527 if (!ix) START (child, RETVAL);
409 OUTPUT: 528 OUTPUT:
410 RETVAL 529 RETVAL
411 530
531ev_stat *stat (SV *path, NV interval, SV *cb)
532 ALIAS:
533 stat_ns = 1
534 CODE:
535 RETVAL = e_new (sizeof (ev_stat), cb);
536 RETVAL->fh = newSVsv (path);
537 ev_stat_set (RETVAL, SvPVbyte_nolen (RETVAL->fh), interval);
538 if (!ix) START (stat, RETVAL);
539 OUTPUT:
540 RETVAL
541
542void once (SV *fh, int events, SV *timeout, SV *cb)
543 CODE:
544 ev_once (
545 sv_fileno (fh), events,
546 SvOK (timeout) ? SvNV (timeout) : -1.,
547 e_once_cb,
548 newSVsv (cb)
549 );
412 550
413PROTOTYPES: DISABLE 551PROTOTYPES: DISABLE
414 552
415MODULE = EV PACKAGE = EV::Watcher PREFIX = ev_ 553MODULE = EV PACKAGE = EV::Watcher PREFIX = ev_
416 554
417int ev_is_active (struct ev_watcher *w) 555int ev_is_active (ev_watcher *w)
418 556
557int ev_is_pending (ev_watcher *w)
558
559int keepalive (ev_watcher *w, int new_value = 0)
560 CODE:
561{
562 RETVAL = w->flags & WFLAG_KEEPALIVE;
563 new_value = new_value ? WFLAG_KEEPALIVE : 0;
564
565 if (items > 1 && ((new_value ^ w->flags) & WFLAG_KEEPALIVE))
566 {
567 REF (w);
568 w->flags = (w->flags & ~WFLAG_KEEPALIVE) | new_value;
569 UNREF (w);
570 }
571}
572 OUTPUT:
573 RETVAL
574
419SV *cb (struct ev_watcher *w, SV *new_cb = 0) 575SV *cb (ev_watcher *w, SV *new_cb = 0)
420 CODE: 576 CODE:
421{ 577{
422 RETVAL = newSVsv (w->cb_sv); 578 RETVAL = newSVsv (w->cb_sv);
423 579
424 if (items > 1) 580 if (items > 1)
425 sv_setsv (w->cb_sv, new_cb); 581 sv_setsv (w->cb_sv, new_cb);
426} 582}
427 OUTPUT: 583 OUTPUT:
428 RETVAL 584 RETVAL
429 585
586SV *data (ev_watcher *w, SV *new_data = 0)
587 CODE:
588{
589 RETVAL = w->data ? newSVsv (w->data) : &PL_sv_undef;
590
591 if (items > 1)
592 {
593 SvREFCNT_dec (w->data);
594 w->data = newSVsv (new_data);
595 }
596}
597 OUTPUT:
598 RETVAL
599
430void trigger (struct ev_watcher *w, int revents = EV_NONE) 600void trigger (ev_watcher *w, int revents = EV_NONE)
431 CODE: 601 CODE:
432 w->cb (w, revents); 602 w->cb (w, revents);
433 603
604int priority (ev_watcher *w, int new_priority = 0)
605 CODE:
606{
607 RETVAL = w->priority;
608
609 if (items > 1)
610 {
611 int active = ev_is_active (w);
612
613 if (new_priority < EV_MINPRI || new_priority > EV_MAXPRI)
614 croak ("watcher priority out of range, value must be between %d and %d, inclusive", EV_MINPRI, EV_MAXPRI);
615
616 if (active)
617 {
618 /* grrr. */
619 PUSHMARK (SP);
620 XPUSHs (ST (0));
621 call_method ("stop", G_DISCARD | G_VOID);
622 }
623
624 ev_set_priority (w, new_priority);
625
626 if (active)
627 {
628 PUSHMARK (SP);
629 XPUSHs (ST (0));
630 call_method ("start", G_DISCARD | G_VOID);
631 }
632 }
633}
634 OUTPUT:
635 RETVAL
636
434MODULE = EV PACKAGE = EV::Io PREFIX = ev_io_ 637MODULE = EV PACKAGE = EV::IO PREFIX = ev_io_
435 638
436void ev_io_start (struct ev_io *w) 639void ev_io_start (ev_io *w)
640 CODE:
641 START (io, w);
437 642
438void ev_io_stop (struct ev_io *w) 643void ev_io_stop (ev_io *w)
644 CODE:
645 STOP (io, w);
439 646
440void DESTROY (struct ev_io *w) 647void DESTROY (ev_io *w)
441 CODE: 648 CODE:
649 STOP (io, w);
442 ev_io_stop (w); 650 e_destroy (w);
443 651
444void set (struct ev_io *w, SV *fh, int events) 652void set (ev_io *w, SV *fh, int events)
445 CODE: 653 CODE:
446{ 654{
447 int active = w->active;
448 int fd = sv_fileno (fh); 655 int fd = sv_fileno (fh);
449 CHECK_FD (fh, fd); 656 CHECK_FD (fh, fd);
450 657
451 if (active) ev_io_stop (w);
452
453 sv_setsv (w->fh, fh); 658 sv_setsv (w->fh, fh);
454 ev_io_set (w, fd, events); 659 RESET (io, w, (w, fd, events));
455
456 if (active) ev_io_start (w);
457} 660}
458 661
459SV *fh (struct ev_io *w, SV *new_fh = 0) 662SV *fh (ev_io *w, SV *new_fh = 0)
460 CODE: 663 CODE:
461{ 664{
462 RETVAL = newSVsv (w->fh);
463
464 if (items > 1) 665 if (items > 1)
465 { 666 {
466 int active = w->active; 667 int fd = sv_fileno (new_fh);
467 if (active) ev_io_stop (w); 668 CHECK_FD (new_fh, fd);
468 669
469 sv_setsv (w->fh, new_fh); 670 RETVAL = w->fh;
470 ev_io_set (w, sv_fileno (w->fh), w->events); 671 w->fh = newSVsv (new_fh);
471 672
472 if (active) ev_io_start (w); 673 RESET (io, w, (w, fd, w->events));
473 } 674 }
675 else
676 RETVAL = newSVsv (w->fh);
474} 677}
475 OUTPUT: 678 OUTPUT:
476 RETVAL 679 RETVAL
477 680
478short events (struct ev_io *w, short new_events = EV_UNDEF) 681int events (ev_io *w, int new_events = EV_UNDEF)
479 CODE: 682 CODE:
480{ 683{
481 RETVAL = w->events; 684 RETVAL = w->events;
685
686 if (items > 1)
687 RESET (io, w, (w, w->fd, new_events));
688}
689 OUTPUT:
690 RETVAL
691
692MODULE = EV PACKAGE = EV::Signal PREFIX = ev_signal_
693
694void ev_signal_start (ev_signal *w)
695 CODE:
696 START (signal, w);
697
698void ev_signal_stop (ev_signal *w)
699 CODE:
700 STOP (signal, w);
701
702void DESTROY (ev_signal *w)
703 CODE:
704 STOP (signal, w);
705 e_destroy (w);
706
707void set (ev_signal *w, SV *signal)
708 CODE:
709{
710 Signal signum = sv_signum (signal);
711 CHECK_SIG (signal, signum);
712
713 RESET (signal, w, (w, signum));
714}
715
716int signal (ev_signal *w, SV *new_signal = 0)
717 CODE:
718{
719 RETVAL = w->signum;
482 720
483 if (items > 1) 721 if (items > 1)
484 { 722 {
485 int active = w->active; 723 Signal signum = sv_signum (new_signal);
486 if (active) ev_io_stop (w); 724 CHECK_SIG (new_signal, signum);
487 725
488 ev_io_set (w, w->fd, new_events); 726 RESET (signal, w, (w, signum));
489
490 if (active) ev_io_start (w);
491 } 727 }
492} 728}
493 OUTPUT: 729 OUTPUT:
494 RETVAL 730 RETVAL
495 731
496MODULE = EV PACKAGE = EV::Signal PREFIX = ev_signal_
497
498void ev_signal_start (struct ev_signal *w)
499
500void ev_signal_stop (struct ev_signal *w)
501
502void DESTROY (struct ev_signal *w)
503 CODE:
504 ev_signal_stop (w);
505
506void set (struct ev_signal *w, SV *signal = 0)
507 CODE:
508{
509 Signal signum = sv_signum (signal); /* may croak here */
510 int active = w->active;
511
512 if (active) ev_signal_stop (w);
513 ev_signal_set (w, signum);
514 if (active) ev_signal_start (w);
515}
516
517MODULE = EV PACKAGE = EV::Time
518
519MODULE = EV PACKAGE = EV::Timer PREFIX = ev_timer_ 732MODULE = EV PACKAGE = EV::Timer PREFIX = ev_timer_
520 733
521void ev_timer_start (struct ev_timer *w) 734void ev_timer_start (ev_timer *w)
522 INIT: 735 INIT:
523 CHECK_REPEAT (w->repeat); 736 CHECK_REPEAT (w->repeat);
737 CODE:
738 START (timer, w);
524 739
525void ev_timer_stop (struct ev_timer *w) 740void ev_timer_stop (ev_timer *w)
741 CODE:
742 STOP (timer, w);
526 743
527void ev_timer_again (struct ev_timer *w) 744void ev_timer_again (ev_timer *w)
528 INIT: 745 INIT:
529 CHECK_REPEAT (w->repeat); 746 CHECK_REPEAT (w->repeat);
747 CODE:
748 REF (w);
749 ev_timer_again (w);
750 UNREF (w);
530 751
531void DESTROY (struct ev_timer *w) 752void DESTROY (ev_timer *w)
532 CODE: 753 CODE:
754 STOP (timer, w);
533 ev_timer_stop (w); 755 e_destroy (w);
534 756
535void set (struct ev_timer *w, NV after, NV repeat = 0.) 757void set (ev_timer *w, NV after, NV repeat = 0.)
536 INIT: 758 INIT:
537 CHECK_REPEAT (repeat); 759 CHECK_REPEAT (repeat);
538 CODE: 760 CODE:
539{
540 int active = w->active;
541 if (active) ev_timer_stop (w);
542 ev_timer_set (w, after, repeat); 761 RESET (timer, w, (w, after, repeat));
543 if (active) ev_timer_start (w);
544}
545 762
546MODULE = EV PACKAGE = EV::Periodic PREFIX = ev_periodic_ 763MODULE = EV PACKAGE = EV::Periodic PREFIX = ev_periodic_
547 764
548void ev_periodic_start (struct ev_periodic *w) 765void ev_periodic_start (ev_periodic *w)
549 INIT: 766 INIT:
550 CHECK_REPEAT (w->interval); 767 CHECK_REPEAT (w->interval);
768 CODE:
769 START (periodic, w);
551 770
552void ev_periodic_stop (struct ev_periodic *w) 771void ev_periodic_stop (ev_periodic *w)
772 CODE:
773 STOP (periodic, w);
553 774
775void ev_periodic_again (ev_periodic *w)
776 CODE:
777 REF (w);
778 ev_periodic_again (w);
779 UNREF (w);
780
554void DESTROY (struct ev_periodic *w) 781void DESTROY (ev_periodic *w)
555 CODE: 782 CODE:
556 ev_periodic_stop (w); 783 STOP (periodic, w);
784 e_destroy (w);
557 785
558void set (struct ev_periodic *w, NV at, NV interval = 0.) 786void set (ev_periodic *w, NV at, NV interval = 0., SV *reschedule_cb = &PL_sv_undef)
559 INIT: 787 INIT:
560 CHECK_REPEAT (interval); 788 CHECK_REPEAT (interval);
561 CODE: 789 CODE:
562{ 790{
563 int active = w->active; 791 SvREFCNT_dec (w->fh);
564 if (active) ev_periodic_stop (w); 792 w->fh = SvTRUE (reschedule_cb) ? newSVsv (reschedule_cb) : 0;
565 ev_periodic_set (w, at, interval); 793
566 if (active) ev_periodic_start (w); 794 RESET (periodic, w, (w, at, interval, w->fh ? e_periodic_cb : 0));
567} 795}
568 796
569MODULE = EV PACKAGE = EV::Idle PREFIX = ev_idle_ 797MODULE = EV PACKAGE = EV::Idle PREFIX = ev_idle_
570 798
571void ev_idle_start (struct ev_idle *w) 799void ev_idle_start (ev_idle *w)
800 CODE:
801 START (idle, w);
572 802
573void ev_idle_stop (struct ev_idle *w) 803void ev_idle_stop (ev_idle *w)
804 CODE:
805 STOP (idle, w);
574 806
575void DESTROY (struct ev_idle *w) 807void DESTROY (ev_idle *w)
576 CODE: 808 CODE:
809 STOP (idle, w);
577 ev_idle_stop (w); 810 e_destroy (w);
578 811
579MODULE = EV PACKAGE = EV::Prepare PREFIX = ev_check_ 812MODULE = EV PACKAGE = EV::Prepare PREFIX = ev_check_
580 813
581void ev_prepare_start (struct ev_prepare *w) 814void ev_prepare_start (ev_prepare *w)
815 CODE:
816 START (prepare, w);
582 817
583void ev_prepare_stop (struct ev_prepare *w) 818void ev_prepare_stop (ev_prepare *w)
819 CODE:
820 STOP (prepare, w);
584 821
585void DESTROY (struct ev_prepare *w) 822void DESTROY (ev_prepare *w)
586 CODE: 823 CODE:
587 ev_prepare_stop (w); 824 STOP (prepare, w);
825 e_destroy (w);
588 826
589MODULE = EV PACKAGE = EV::Check PREFIX = ev_check_ 827MODULE = EV PACKAGE = EV::Check PREFIX = ev_check_
590 828
591void ev_check_start (struct ev_check *w) 829void ev_check_start (ev_check *w)
830 CODE:
831 START (check, w);
592 832
593void ev_check_stop (struct ev_check *w) 833void ev_check_stop (ev_check *w)
834 CODE:
835 STOP (check, w);
594 836
595void DESTROY (struct ev_check *w) 837void DESTROY (ev_check *w)
596 CODE: 838 CODE:
839 STOP (check, w);
597 ev_check_stop (w); 840 e_destroy (w);
598 841
599MODULE = EV PACKAGE = EV::Child PREFIX = ev_child_ 842MODULE = EV PACKAGE = EV::Child PREFIX = ev_child_
600 843
601void ev_child_start (struct ev_child *w) 844void ev_child_start (ev_child *w)
845 CODE:
846 START (child, w);
602 847
603void ev_child_stop (struct ev_child *w) 848void ev_child_stop (ev_child *w)
849 CODE:
850 STOP (child, w);
604 851
605void DESTROY (struct ev_child *w) 852void DESTROY (ev_child *w)
606 CODE: 853 CODE:
854 STOP (child, w);
607 ev_child_stop (w); 855 e_destroy (w);
608 856
609void set (struct ev_child *w, int pid) 857void set (ev_child *w, int pid)
610 CODE: 858 CODE:
611{ 859 RESET (child, w, (w, pid));
612 int active = w->active;
613 if (active) ev_child_stop (w);
614 ev_child_set (w, pid);
615 if (active) ev_child_start (w);
616}
617 860
861int pid (ev_child *w, int new_pid = 0)
862 CODE:
863{
864 RETVAL = w->pid;
865
866 if (items > 1)
867 RESET (child, w, (w, new_pid));
868}
869 OUTPUT:
870 RETVAL
871
872
618int status (struct ev_child *w) 873int rstatus (ev_child *w)
874 ALIAS:
875 rpid = 1
876 CODE:
877 RETVAL = ix ? w->rpid : w->rstatus;
878 OUTPUT:
879 RETVAL
880
881MODULE = EV PACKAGE = EV::Stat PREFIX = ev_stat_
882
883void ev_stat_start (ev_stat *w)
884 CODE:
885 START (stat, w);
886
887void ev_stat_stop (ev_stat *w)
888 CODE:
889 STOP (stat, w);
890
891void DESTROY (ev_stat *w)
892 CODE:
893 STOP (stat, w);
894 e_destroy (w);
895
896void set (ev_stat *w, SV *path, NV interval)
897 CODE:
898{
899 sv_setsv (w->fh, path);
900 RESET (stat, w, (w, SvPVbyte_nolen (w->fh), interval));
901}
902
903SV *path (ev_stat *w, SV *new_path = 0)
904 CODE:
905{
906 RETVAL = SvREFCNT_inc (w->fh);
907
908 if (items > 1)
909 {
910 SvREFCNT_dec (w->fh);
911 w->fh = newSVsv (new_path);
912 RESET (stat, w, (w, SvPVbyte_nolen (w->fh), w->interval));
913 }
914}
915 OUTPUT:
916 RETVAL
917
918NV interval (ev_stat *w, NV new_interval = 0.)
919 CODE:
920{
921 RETVAL = w->interval;
922
923 if (items > 1)
924 RESET (stat, w, (w, SvPVbyte_nolen (w->fh), new_interval));
925}
926 OUTPUT:
927 RETVAL
928
929void prev (ev_stat *w)
930 ALIAS:
931 stat = 1
932 attr = 2
619 CODE: 933 PPCODE:
620 RETVAL = w->status; 934{
621 OUTPUT: 935 ev_statdata *s = ix ? &w->attr : &w->prev;
622 RETVAL 936
937 if (ix == 1)
938 ev_stat_stat (w);
939 else if (!s->st_nlink)
940 errno = ENOENT;
941
942 PL_statcache.st_dev = s->st_nlink;
943 PL_statcache.st_ino = s->st_ino;
944 PL_statcache.st_mode = s->st_mode;
945 PL_statcache.st_nlink = s->st_nlink;
946 PL_statcache.st_uid = s->st_uid;
947 PL_statcache.st_gid = s->st_gid;
948 PL_statcache.st_rdev = s->st_rdev;
949 PL_statcache.st_size = s->st_size;
950 PL_statcache.st_atime = s->st_atime;
951 PL_statcache.st_mtime = s->st_mtime;
952 PL_statcache.st_ctime = s->st_ctime;
953
954 if (GIMME_V == G_SCALAR)
955 XPUSHs (boolSV (s->st_nlink));
956 else if (GIMME_V == G_ARRAY && s->st_nlink)
957 {
958 EXTEND (SP, 13);
959 PUSHs (sv_2mortal (newSViv (s->st_dev)));
960 PUSHs (sv_2mortal (newSViv (s->st_ino)));
961 PUSHs (sv_2mortal (newSVuv (s->st_mode)));
962 PUSHs (sv_2mortal (newSVuv (s->st_nlink)));
963 PUSHs (sv_2mortal (newSViv (s->st_uid)));
964 PUSHs (sv_2mortal (newSViv (s->st_gid)));
965 PUSHs (sv_2mortal (newSViv (s->st_rdev)));
966 PUSHs (sv_2mortal (newSVnv ((NV)s->st_size)));
967 PUSHs (sv_2mortal (newSVnv (s->st_atime)));
968 PUSHs (sv_2mortal (newSVnv (s->st_mtime)));
969 PUSHs (sv_2mortal (newSVnv (s->st_ctime)));
970 PUSHs (sv_2mortal (newSVuv (4096)));
971 PUSHs (sv_2mortal (newSVnv ((NV)((s->st_size + 4095) / 4096))));
972 }
973}
623 974
624#if 0 975#if 0
625
626MODULE = EV PACKAGE = EV::DNS PREFIX = evdns_
627
628BOOT:
629{
630 HV *stash = gv_stashpv ("EV::DNS", 1);
631
632 static const struct {
633 const char *name;
634 IV iv;
635 } *civ, const_iv[] = {
636# define const_iv(pfx, name) { # name, (IV) pfx ## name },
637 const_iv (DNS_, ERR_NONE)
638 const_iv (DNS_, ERR_FORMAT)
639 const_iv (DNS_, ERR_SERVERFAILED)
640 const_iv (DNS_, ERR_NOTEXIST)
641 const_iv (DNS_, ERR_NOTIMPL)
642 const_iv (DNS_, ERR_REFUSED)
643 const_iv (DNS_, ERR_TRUNCATED)
644 const_iv (DNS_, ERR_UNKNOWN)
645 const_iv (DNS_, ERR_TIMEOUT)
646 const_iv (DNS_, ERR_SHUTDOWN)
647 const_iv (DNS_, IPv4_A)
648 const_iv (DNS_, PTR)
649 const_iv (DNS_, IPv6_AAAA)
650 const_iv (DNS_, QUERY_NO_SEARCH)
651 const_iv (DNS_, OPTION_SEARCH)
652 const_iv (DNS_, OPTION_NAMESERVERS)
653 const_iv (DNS_, OPTION_MISC)
654 const_iv (DNS_, OPTIONS_ALL)
655 const_iv (DNS_, NO_SEARCH)
656 };
657
658 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
659 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
660}
661
662int evdns_init ()
663
664void evdns_shutdown (int fail_requests = 1)
665
666const char *evdns_err_to_string (int err)
667
668int evdns_nameserver_add (U32 address)
669
670int evdns_count_nameservers ()
671
672int evdns_clear_nameservers_and_suspend ()
673
674int evdns_resume ()
675
676int evdns_nameserver_ip_add (char *ip_as_string)
677
678int evdns_resolve_ipv4 (const char *name, int flags, SV *cb)
679 C_ARGS: name, flags, dns_cb, (void *)SvREFCNT_inc (cb)
680
681int evdns_resolve_ipv6 (const char *name, int flags, SV *cb)
682 C_ARGS: name, flags, dns_cb, (void *)SvREFCNT_inc (cb)
683
684int evdns_resolve_reverse (SV *addr, int flags, SV *cb)
685 ALIAS:
686 evdns_resolve_reverse_ipv6 = 1
687 CODE:
688{
689 STRLEN len;
690 char *data = SvPVbyte (addr, len);
691 if (len != (ix ? 16 : 4))
692 croak ("ipv4/ipv6 address to be resolved must be given as 4/16 byte octet string");
693
694 RETVAL = ix
695 ? evdns_resolve_reverse_ipv6 ((struct in6_addr *)data, flags, dns_cb, (void *)SvREFCNT_inc (cb))
696 : evdns_resolve_reverse ((struct in_addr *)data, flags, dns_cb, (void *)SvREFCNT_inc (cb));
697}
698 OUTPUT:
699 RETVAL
700
701int evdns_set_option (char *option, char *val, int flags)
702
703int evdns_resolv_conf_parse (int flags, const char *filename)
704
705#ifdef MS_WINDOWS
706
707int evdns_config_windows_nameservers ()
708
709#endif
710
711void evdns_search_clear ()
712
713void evdns_search_add (char *domain)
714
715void evdns_search_ndots_set (int ndots)
716
717 976
718MODULE = EV PACKAGE = EV::HTTP PREFIX = evhttp_ 977MODULE = EV PACKAGE = EV::HTTP PREFIX = evhttp_
719 978
720BOOT: 979BOOT:
721{ 980{

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines