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

Comparing cvsroot/EV-ADNS/ADNS.xs (file contents):
Revision 1.6 by root, Sat Dec 1 20:52:30 2007 UTC vs.
Revision 1.12 by root, Fri Dec 7 23:54:13 2007 UTC

… …
4 4
5#include <poll.h> 5#include <poll.h>
6#include <adns.h> 6#include <adns.h>
7 7
8#include "EVAPI.h" 8#include "EVAPI.h"
9
10static HV *stash;
11static adns_state ads;
12 9
13struct ctx 10struct ctx
14{ 11{
15 SV *self; 12 SV *self;
16 adns_query query; 13 adns_query query;
… …
26 23
27 return newRV_noinc ((SV *)av); 24 return newRV_noinc ((SV *)av);
28} 25}
29 26
30static void 27static void
31process () 28process (adns_state ads)
32{ 29{
33 dSP; 30 dSP;
34 31
35 for (;;) 32 for (;;)
36 { 33 {
… …
48 c = (struct ctx *)ctx; 45 c = (struct ctx *)ctx;
49 cb = c->cb; 46 cb = c->cb;
50 c->cb = 0; 47 c->cb = 0;
51 ev_unref (); 48 ev_unref ();
52 SvREFCNT_dec (c->self); 49 SvREFCNT_dec (c->self);
53 printf ("refrefclr\n");
54 50
55 PUSHMARK (SP); 51 PUSHMARK (SP);
56 52
57 EXTEND (SP, a->nrrs + 2); 53 EXTEND (SP, a->nrrs + 2);
58 PUSHs (sv_2mortal (newSViv (a->status))); 54 PUSHs (sv_2mortal (newSViv (a->status)));
… …
70 case adns_r_ptr_raw: 66 case adns_r_ptr_raw:
71 sv = newSVpv (a->rrs.str [i], 0); 67 sv = newSVpv (a->rrs.str [i], 0);
72 break; 68 break;
73 69
74 case adns_r_txt: 70 case adns_r_txt:
75 sv = newSVpvn (a->rrs.manyistr [i]->str, a->rrs.manyistr [i]->i); 71 {
72 AV *av = newAV ();
73 adns_rr_intstr *rr = a->rrs.manyistr [i];
74
75 while (rr->str)
76 {
77 av_push (av, newSVpvn (rr->str, rr->i));
78 ++rr;
79 }
80
81 sv = newRV_noinc ((SV *)av);
82 }
76 break; 83 break;
77 84
78 case adns_r_a: 85 case adns_r_a:
79 sv = newSVpv (inet_ntoa (a->rrs.inaddr [i]), 0); 86 sv = newSVpv (inet_ntoa (a->rrs.inaddr [i]), 0);
80 break; 87 break;
… …
85 92
86 case adns_r_hinfo: 93 case adns_r_hinfo:
87 { 94 {
88 /* untested */ 95 /* untested */
89 AV *av = newAV (); 96 AV *av = newAV ();
90 sv = newRV_noinc ((SV *)av);
91 adns_rr_intstrpair *rr = a->rrs.intstrpair + i; 97 adns_rr_intstrpair *rr = a->rrs.intstrpair + i;
92 98
93 av_push (av, newSVpvn (rr->array [0].str, rr->array [0].i)); 99 av_push (av, newSVpvn (rr->array [0].str, rr->array [0].i));
94 av_push (av, newSVpvn (rr->array [1].str, rr->array [1].i)); 100 av_push (av, newSVpvn (rr->array [1].str, rr->array [1].i));
101
102 sv = newRV_noinc ((SV *)av);
95 } 103 }
96 break; 104 break;
97 105
98 case adns_r_rp: 106 case adns_r_rp:
99 case adns_r_rp_raw: 107 case adns_r_rp_raw:
100 { 108 {
101 /* untested */ 109 /* untested */
102 AV *av = newAV (); 110 AV *av = newAV ();
103 sv = newRV_noinc ((SV *)av);
104 adns_rr_strpair *rr = a->rrs.strpair + i; 111 adns_rr_strpair *rr = a->rrs.strpair + i;
105 112
106 av_push (av, newSVpv (rr->array [0], 0)); 113 av_push (av, newSVpv (rr->array [0], 0));
107 av_push (av, newSVpv (rr->array [1], 0)); 114 av_push (av, newSVpv (rr->array [1], 0));
115
116 sv = newRV_noinc ((SV *)av);
108 } 117 }
109 break; 118 break;
110 119
111 case adns_r_mx: 120 case adns_r_mx:
112 { 121 {
113 AV *av = newAV (); 122 AV *av = newAV ();
114 sv = newRV_noinc ((SV *)av);
115 adns_rr_inthostaddr *rr = a->rrs.inthostaddr + i; 123 adns_rr_inthostaddr *rr = a->rrs.inthostaddr + i;
116 124
117 av_push (av, newSViv (rr->i)); 125 av_push (av, newSViv (rr->i));
118 av_push (av, ha2sv (&rr->ha)); 126 av_push (av, ha2sv (&rr->ha));
127
128 sv = newRV_noinc ((SV *)av);
119 } 129 }
120 break; 130 break;
121 131
122 case adns_r_mx_raw: 132 case adns_r_mx_raw:
123 { 133 {
124 AV *av = newAV (); 134 AV *av = newAV ();
125 sv = newRV_noinc ((SV *)av);
126 adns_rr_intstr *rr = a->rrs.intstr + i; 135 adns_rr_intstr *rr = a->rrs.intstr + i;
127 136
128 av_push (av, newSViv (rr->i)); 137 av_push (av, newSViv (rr->i));
129 av_push (av, newSVpv (rr->str, 0)); 138 av_push (av, newSVpv (rr->str, 0));
139
140 sv = newRV_noinc ((SV *)av);
130 } 141 }
131 break; 142 break;
132 143
133 case adns_r_soa: 144 case adns_r_soa:
134 case adns_r_soa_raw: 145 case adns_r_soa_raw:
135 { 146 {
136 AV *av = newAV (); 147 AV *av = newAV ();
137 sv = newRV_noinc ((SV *)av);
138 adns_rr_soa *rr = a->rrs.soa + i; 148 adns_rr_soa *rr = a->rrs.soa + i;
139 149
140 av_push (av, newSVpv (rr->mname, 0)); 150 av_push (av, newSVpv (rr->mname, 0));
141 av_push (av, newSVpv (rr->rname, 0)); 151 av_push (av, newSVpv (rr->rname, 0));
142 av_push (av, newSVuv (rr->serial)); 152 av_push (av, newSVuv (rr->serial));
143 av_push (av, newSVuv (rr->refresh)); 153 av_push (av, newSVuv (rr->refresh));
144 av_push (av, newSVuv (rr->retry)); 154 av_push (av, newSVuv (rr->retry));
145 av_push (av, newSVuv (rr->expire)); 155 av_push (av, newSVuv (rr->expire));
146 av_push (av, newSVuv (rr->minimum)); 156 av_push (av, newSVuv (rr->minimum));
157
158 sv = newRV_noinc ((SV *)av);
147 } 159 }
148 break; 160 break;
149 161
150 case adns_r_srv_raw: 162 case adns_r_srv_raw:
151 { 163 {
152 AV *av = newAV (); 164 AV *av = newAV ();
153 sv = newRV_noinc ((SV *)av);
154 adns_rr_srvraw *rr = a->rrs.srvraw + i; 165 adns_rr_srvraw *rr = a->rrs.srvraw + i;
155 166
156 av_push (av, newSViv (rr->priority)); 167 av_push (av, newSViv (rr->priority));
157 av_push (av, newSViv (rr->weight)); 168 av_push (av, newSViv (rr->weight));
158 av_push (av, newSViv (rr->port)); 169 av_push (av, newSViv (rr->port));
159 av_push (av, newSVpv (rr->host, 0)); 170 av_push (av, newSVpv (rr->host, 0));
171
172 sv = newRV_noinc ((SV *)av);
160 } 173 }
161 break; 174 break;
162 175
163 case adns_r_srv: 176 case adns_r_srv:
164 { 177 {
165 AV *av = newAV (); 178 AV *av = newAV ();
166 sv = newRV_noinc ((SV *)av);
167 adns_rr_srvha *rr = a->rrs.srvha + i; 179 adns_rr_srvha *rr = a->rrs.srvha + i;
168 180
169 av_push (av, newSViv (rr->priority)); 181 av_push (av, newSViv (rr->priority));
170 av_push (av, newSViv (rr->weight)); 182 av_push (av, newSViv (rr->weight));
171 av_push (av, newSViv (rr->port)); 183 av_push (av, newSViv (rr->port));
172 av_push (av, ha2sv (&rr->ha)); 184 av_push (av, ha2sv (&rr->ha));
185
186 sv = newRV_noinc ((SV *)av);
173 } 187 }
174 break; 188 break;
175 189
176 case adns_r_unknown: 190 case adns_r_unknown:
177 sv = newSVpvn (a->rrs.byteblock [i].data, a->rrs.byteblock [i].len); 191 sv = newSVpvn (a->rrs.byteblock [i].data, a->rrs.byteblock [i].len);
… …
198 212
199static struct pollfd *fds; 213static struct pollfd *fds;
200static int nfd, mfd; 214static int nfd, mfd;
201static ev_io *iow; 215static ev_io *iow;
202static ev_timer tw; 216static ev_timer tw;
217static ev_idle iw;
203static ev_prepare prepare_ev; 218static ev_prepare pw;
204static struct timeval tv_now; 219static struct timeval tv_now;
205 220
206static void 221static void
207update_now (EV_P) 222update_now (EV_P)
208{ 223{
209 ev_tstamp t = ev_now (); 224 ev_tstamp t = ev_now ();
210 225
211 tv_now.tv_sec = (long)t; 226 tv_now.tv_sec = (long)t;
212 tv_now.tv_usec = (long)((t - (ev_tstamp)tv_now.tv_sec) * 1e-6); 227 tv_now.tv_usec = (long)((t - (ev_tstamp)tv_now.tv_sec) * 1e6);
228}
229
230static void
231idle_cb (EV_P_ ev_idle *w, int revents)
232{
233 ev_idle_stop (EV_A_ w);
213} 234}
214 235
215static void 236static void
216timer_cb (EV_P_ ev_timer *w, int revents) 237timer_cb (EV_P_ ev_timer *w, int revents)
217{ 238{
239 adns_state ads = (adns_state)w->data;
240 update_now ();
241
242 adns_processtimeouts (ads, &tv_now);
218} 243}
219 244
220static void 245static void
221io_cb (EV_P_ ev_io *w, int revents) 246io_cb (EV_P_ ev_io *w, int revents)
222{ 247{
248 adns_state ads = (adns_state)w->data;
223 update_now (EV_A); 249 update_now (EV_A);
224 250
225 if (revents & EV_READ ) adns_processreadable (ads, w->fd, &tv_now); 251 if (revents & EV_READ ) adns_processreadable (ads, w->fd, &tv_now);
226 if (revents & EV_WRITE) adns_processwriteable (ads, w->fd, &tv_now); 252 if (revents & EV_WRITE) adns_processwriteable (ads, w->fd, &tv_now);
227} 253}
… …
230static void 256static void
231prepare_cb (EV_P_ ev_prepare *w, int revents) 257prepare_cb (EV_P_ ev_prepare *w, int revents)
232{ 258{
233 int i; 259 int i;
234 int timeout = 3600000; 260 int timeout = 3600000;
261 adns_state ads = (adns_state)w->data;
235 262
236 if (ev_is_active (&tw)) 263 if (ev_is_active (&tw))
237 { 264 {
238 ev_ref (); 265 ev_ref ();
239 ev_timer_stop (EV_A_ &tw); 266 ev_timer_stop (EV_A_ &tw);
240 } 267 }
241 268
269 if (ev_is_active (&iw))
270 ev_idle_stop (EV_A_ &iw);
271
242 for (i = 0; i < nfd; ++i) 272 for (i = 0; i < nfd; ++i)
243 { 273 {
244 ev_ref (); 274 ev_ref ();
245 ev_io_stop (EV_A_ iow + i); 275 ev_io_stop (EV_A_ iow + i);
246 } 276 }
247 277
248 process (); 278 process (ads);
249
250 update_now (EV_A); 279 update_now (EV_A);
251 280
252 nfd = mfd; 281 nfd = mfd;
253 282
254 while (adns_beforepoll (ads, fds, &nfd, &timeout, &tv_now)) 283 while (adns_beforepoll (ads, fds, &nfd, &timeout, &tv_now))
255 { 284 {
256 mfd = nfd; 285 mfd = nfd;
257 286
287 free (iow); iow = malloc (mfd * sizeof (ev_io));
258 free (iow); iow = malloc (mfd * sizeof (struct pollfd)); 288 free (fds); fds = malloc (mfd * sizeof (struct pollfd));
259 free (fds); fds = malloc (mfd * sizeof (ev_io));
260 } 289 }
261 290
262 ev_timer_set (&tw, timeout * 1e-3, 0.); 291 ev_timer_set (&tw, timeout * 1e-3, 0.);
263 ev_timer_start (EV_A_ &tw); 292 ev_timer_start (EV_A_ &tw);
264 ev_unref (); 293 ev_unref ();
… …
272 301
273 ev_io_start (EV_A_ iow + i); 302 ev_io_start (EV_A_ iow + i);
274 ev_unref (); 303 ev_unref ();
275 } 304 }
276} 305}
306
307static HV *stash;
308static adns_state ads;
277 309
278MODULE = EV::ADNS PACKAGE = EV::ADNS 310MODULE = EV::ADNS PACKAGE = EV::ADNS
279 311
280PROTOTYPES: ENABLE 312PROTOTYPES: ENABLE
281 313
… …
369 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; ) 401 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
370 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 402 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
371 403
372 I_EV_API ("EV::ADNS"); 404 I_EV_API ("EV::ADNS");
373 405
374 ev_prepare_init (&prepare_ev, prepare_cb); ev_prepare_start (EV_DEFAULT_ &prepare_ev); 406 adns_init (&ads, adns_if_noenv | adns_if_noerrprint | adns_if_noserverwarn | adns_if_noautosys, 0);
407
408 ev_prepare_init (&pw, prepare_cb);
409 pw.data = (void *)ads;
410 ev_prepare_start (EV_DEFAULT_ &pw);
375 ev_unref (); 411 ev_unref ();
376 412
413 ev_init (&iw, idle_cb); ev_set_priority (&iw, EV_MINPRI);
414 iw.data = (void *)ads;
377 ev_init (&tw, timer_cb); 415 ev_init (&tw, timer_cb);
378 416 tw.data = (void *)ads;
379 adns_init (&ads, adns_if_noenv | adns_if_noerrprint | adns_if_noserverwarn | adns_if_noautosys, 0);
380} 417}
381 418
382void submit (char *owner, int type, int flags, SV *cb) 419void submit (char *owner, int type, int flags, SV *cb)
383 PPCODE: 420 PPCODE:
384{ 421{
… …
399 SvCUR_set (csv, sizeof (struct ctx)); 436 SvCUR_set (csv, sizeof (struct ctx));
400 437
401 c->self = csv; 438 c->self = csv;
402 c->cb = newSVsv (cb); 439 c->cb = newSVsv (cb);
403 440
441 if (!ev_is_active (&iw))
442 ev_idle_start (EV_A_ &iw);
443
404 if (GIMME_V != G_VOID) 444 if (GIMME_V != G_VOID)
405 { 445 {
406 csv = sv_2mortal (newRV_inc (csv)); 446 csv = sv_2mortal (newRV_inc (csv));
407 sv_bless (csv, stash); 447 sv_bless (csv, stash);
408 XPUSHs (csv); 448 XPUSHs (csv);
… …
415 cancel = 1 455 cancel = 1
416 CODE: 456 CODE:
417{ 457{
418 struct ctx *c; 458 struct ctx *c;
419 459
420 printf ("destroy\n");
421 if (!(SvROK (req) && SvOBJECT (SvRV (req)) 460 if (!(SvROK (req) && SvOBJECT (SvRV (req))
422 && (SvSTASH (SvRV (req)) == stash))) 461 && (SvSTASH (SvRV (req)) == stash)))
423 croak ("object is not of type EV::ADNS"); 462 croak ("object is not of type EV::ADNS");
424 463
425 c = (struct ctx *)SvPVX (SvRV (req)); 464 c = (struct ctx *)SvPVX (SvRV (req));
… …
429 ev_unref (); 468 ev_unref ();
430 SvREFCNT_dec (c->cb); 469 SvREFCNT_dec (c->cb);
431 c->cb = 0; 470 c->cb = 0;
432 adns_cancel (c->query); 471 adns_cancel (c->query);
433 SvREFCNT_dec (c->self); 472 SvREFCNT_dec (c->self);
434 printf ("refrefcl2\n");
435 } 473 }
436} 474}
437 475
438 476
439 477

Diff Legend

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