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

Comparing AnyEvent-FastPing/FastPing.xs (file contents):
Revision 1.1 by root, Sun Apr 27 15:43:51 2008 UTC vs.
Revision 1.6 by root, Sat Jul 18 00:53:42 2009 UTC

1#define _POSIX_C_SOURCE 199309 1#if defined(__linux)
2#define _GNU_SOURCE 1
3
4#define IPV6 1 // if you get compilation problems try to disable IPv6 2# define ENABLE_IPV6 1 // if you get compilation problems try to disable IPv6
3#else
4# define ENABLE_IPV6 0
5#endif
5 6
6#include "EXTERN.h" 7#include "EXTERN.h"
7#include "perl.h" 8#include "perl.h"
8#include "XSUB.h" 9#include "XSUB.h"
9 10
… …
29#include <arpa/inet.h> 30#include <arpa/inet.h>
30 31
31#ifdef __linux 32#ifdef __linux
32# include <linux/icmp.h> 33# include <linux/icmp.h>
33#endif 34#endif
34#if IPV6 35#if ENABLE_IPV6
35# include <netinet/icmp6.h> 36# include <netinet/icmp6.h>
36#endif 37#endif
37 38
38#define ICMP4_ECHO 8 39#define ICMP4_ECHO 8
39#define ICMP4_ECHO_REPLY 0 40#define ICMP4_ECHO_REPLY 0
… …
44#define MIN_INTERVAL .000001 // minimum packet send interval, in seconds 45#define MIN_INTERVAL .000001 // minimum packet send interval, in seconds
45 46
46#define HDR_SIZE_IP4 20 47#define HDR_SIZE_IP4 20
47#define HDR_SIZE_IP6 48 48#define HDR_SIZE_IP6 48
48 49
49//TODO: xread/xwrite for atomicity? we currently rely on the fact that the pip biffersize divides exactly by pointer sizes 50//TODO: xread/xwrite for atomicity? we currently rely on the fact that the pip buffersize divides exactly by pointer sizes
50 51
51typedef uint8_t addr_t[16]; 52typedef uint8_t addr_t[16];
52 53
53typedef double tstamp; 54typedef double tstamp;
54 55
55tstamp 56static tstamp
56NOW () 57NOW (void)
57{ 58{
58 struct timeval tv; 59 struct timeval tv;
59 gettimeofday (&tv, 0); 60 gettimeofday (&tv, 0);
60 return tv.tv_sec + tv.tv_usec * 0.000001; 61 return tv.tv_sec + tv.tv_usec * 0.000001;
61} 62}
… …
161static void * 162static void *
162ping_proc (void *unused) 163ping_proc (void *unused)
163{ 164{
164 PKT pkt; 165 PKT pkt;
165 struct sockaddr_in sa4; 166 struct sockaddr_in sa4;
166#if IPV6 167#if ENABLE_IPV6
167 struct sockaddr_in6 sa6; 168 struct sockaddr_in6 sa6;
168#endif 169#endif
169 170
170 memset (&pkt, 0, sizeof (pkt)); 171 memset (&pkt, 0, sizeof (pkt));
171 172
172 memset (&sa4, 0, sizeof (sa4)); 173 memset (&sa4, 0, sizeof (sa4));
173 sa4.sin_family = AF_INET; 174 sa4.sin_family = AF_INET;
174 sa4.sin_port = 0; 175 sa4.sin_port = 0;
175#if IPV6 176#if ENABLE_IPV6
176 memset (&sa6, 0, sizeof (sa6)); 177 memset (&sa6, 0, sizeof (sa6));
177 sa6.sin6_family = AF_INET6; 178 sa6.sin6_family = AF_INET6;
178 sa6.sin6_port = 0; 179 sa6.sin6_port = 0;
179#endif 180#endif
180 181
181 for (;;) 182 for (;;)
182 { 183 {
183 REQ *req; 184 REQ *req;
184 int len = read (thr_send [0], &req, sizeof (req)); 185 int len = read (thr_send [0], &req, sizeof (req));
186
187 tstamp now = NOW ();
188 tstamp next = now;
185 189
186 if (!len) 190 if (!len)
187 pthread_exit (0); 191 pthread_exit (0);
188 else if (len != sizeof (req)) 192 else if (len != sizeof (req))
189 { 193 {
… …
196 pkt.code = 0; 200 pkt.code = 0;
197 pkt.id = (uint16_t)magic; 201 pkt.id = (uint16_t)magic;
198 pkt.seq = (uint16_t)~magic; 202 pkt.seq = (uint16_t)~magic;
199 pkt.payload = req->payload; 203 pkt.payload = req->payload;
200 204
201 tstamp now = NOW ();
202 tstamp next = now;
203
204 { 205 {
205 int r; 206 int r;
206 for (r = req->nranges; r--; ) 207 for (r = req->nranges; r--; )
207 inc_addr (&req->ranges [r].hi); 208 inc_addr (&req->ranges [r].hi);
208 } 209 }
209 210
210 while (req->nranges) 211 while (req->nranges)
211 { 212 {
212 RANGE *range = req->ranges; 213 RANGE *range = req->ranges;
214 int n, k;
213 215
214 if (!memcmp (&range->lo, &range->hi, sizeof (addr_t))) 216 if (!memcmp (&range->lo, &range->hi, sizeof (addr_t)))
215 req->ranges [0] = req->ranges [--req->nranges]; 217 req->ranges [0] = req->ranges [--req->nranges];
216 else 218 else
217 { 219 {
… …
255 if (sendto (icmp4_fd, &pkt, sizeof (pkt), 0, (struct sockaddr *)&sa4, sizeof (sa4)) > 0) 257 if (sendto (icmp4_fd, &pkt, sizeof (pkt), 0, (struct sockaddr *)&sa4, sizeof (sa4)) > 0)
256 errno = 0; 258 errno = 0;
257 } 259 }
258 else 260 else
259 { 261 {
260#if IPV6 262#if ENABLE_IPV6
261 pkt.type = ICMP6_ECHO; 263 pkt.type = ICMP6_ECHO;
262 264
263 memcpy (&sa6.sin6_addr, 265 memcpy (&sa6.sin6_addr,
264 sizeof (addr_t) - sizeof (sa6.sin6_addr) + (char *)&range->lo, 266 sizeof (addr_t) - sizeof (sa6.sin6_addr) + (char *)&range->lo,
265 sizeof (sa6.sin6_addr)); 267 sizeof (sa6.sin6_addr));
… …
288 290
289 next += req->interval; 291 next += req->interval;
290 } 292 }
291 293
292 // make a downheap operation 294 // make a downheap operation
293 int k = 0;
294 int n = 0;
295 for (;;) 295 for (n = k = 0; ; )
296 { 296 {
297 int j = k * 2 + 1;
298
297 ++n; 299 ++n;
298 int j = k * 2 + 1;
299 300
300 if (j >= req->nranges) 301 if (j >= req->nranges)
301 break; 302 break;
302 else if (j < req->nranges - 1) 303 else if (j < req->nranges - 1)
303 if (req->ranges [j].next > req->ranges [j + 1].next) 304 if (req->ranges [j].next > req->ranges [j + 1].next)
304 ++j; 305 ++j;
305 306
306 if (req->ranges [j].next >= req->ranges [k].next) 307 if (req->ranges [j].next >= req->ranges [k].next)
307 break; 308 break;
308 309
310 {
309 RANGE temp = req->ranges [k]; 311 RANGE temp = req->ranges [k];
310 req->ranges [k] = req->ranges [j]; 312 req->ranges [k] = req->ranges [j];
311 req->ranges [j] = temp; 313 req->ranges [j] = temp;
314 }
312 315
313 k = j; 316 k = j;
314 } 317 }
315 } 318 }
316 319
… …
321} 324}
322 325
323static void 326static void
324feed_reply (AV *res_av) 327feed_reply (AV *res_av)
325{ 328{
326 if (av_len (res_av) < 0)
327 return;
328
329 dSP; 329 dSP;
330 SV *res = sv_2mortal (newRV_inc ((SV *)res_av)); 330 SV *res = sv_2mortal (newRV_inc ((SV *)res_av));
331 int i; 331 int i;
332
333 if (av_len (res_av) < 0)
334 return;
332 335
333 ENTER; 336 ENTER;
334 SAVETMPS; 337 SAVETMPS;
335 338
336 for (i = av_len (cbs) + 1; i--; ) 339 for (i = av_len (cbs) + 1; i--; )
… …
358 361
359 if (pipe (thr_recv) < 0) 362 if (pipe (thr_recv) < 0)
360 croak ("AnyEvent::FastPing: unable to create receive pipe"); 363 croak ("AnyEvent::FastPing: unable to create receive pipe");
361 364
362 icmp4_fd = socket (AF_INET, SOCK_RAW, IPPROTO_ICMP); 365 icmp4_fd = socket (AF_INET, SOCK_RAW, IPPROTO_ICMP);
366 fcntl (icmp4_fd, F_SETFL, O_NONBLOCK);
363#ifdef ICMP_FILTER 367#ifdef ICMP_FILTER
364 { 368 {
365 struct icmp_filter oval; 369 struct icmp_filter oval;
366 oval.data = 0xffffffff & ~(1 << ICMP4_ECHO_REPLY); 370 oval.data = 0xffffffff & ~(1 << ICMP4_ECHO_REPLY);
367 setsockopt (icmp4_fd, SOL_RAW, ICMP_FILTER, &oval, sizeof oval); 371 setsockopt (icmp4_fd, SOL_RAW, ICMP_FILTER, &oval, sizeof oval);
368 } 372 }
369#endif 373#endif
370 374
371#if IPV6 375#if ENABLE_IPV6
372 icmp6_fd = socket (AF_INET6, SOCK_RAW, IPPROTO_ICMPV6); 376 icmp6_fd = socket (AF_INET6, SOCK_RAW, IPPROTO_ICMPV6);
377 fcntl (icmp6_fd, F_SETFL, O_NONBLOCK);
373# ifdef ICMP6_FILTER 378# ifdef ICMP6_FILTER
374 { 379 {
375 struct icmp6_filter oval; 380 struct icmp6_filter oval;
376 ICMP6_FILTER_SETBLOCKALL (&oval); 381 ICMP6_FILTER_SETBLOCKALL (&oval);
377 ICMP6_FILTER_SETPASS (ICMP6_ECHO_REPLY, &oval); 382 ICMP6_FILTER_SETPASS (ICMP6_ECHO_REPLY, &oval);
… …
424 429
425SV * 430SV *
426_req_icmp_ping (SV *ranges, NV interval, U32 payload, SV *id) 431_req_icmp_ping (SV *ranges, NV interval, U32 payload, SV *id)
427 CODE: 432 CODE:
428{ 433{
434 AV *rav;
435 int nranges, i;
436 REQ *req;
437
429 if (!SvROK (ranges) || SvTYPE (SvRV (ranges)) != SVt_PVAV) 438 if (!SvROK (ranges) || SvTYPE (SvRV (ranges)) != SVt_PVAV)
430 croak ("address ranges must be given as arrayref with lo, hi pairs"); 439 croak ("address ranges must be given as arrayref with lo, hi pairs");
431 440
432 AV *rav = (AV *)SvRV (ranges); 441 rav = (AV *)SvRV (ranges);
433 int nranges = av_len (rav) + 1; 442 nranges = av_len (rav) + 1;
434 443
435 REQ *req = malloc (sizeof (REQ)); 444 req = malloc (sizeof (REQ));
436 int i;
437 445
438 if (interval < MIN_INTERVAL) 446 if (interval < MIN_INTERVAL)
439 interval = MIN_INTERVAL; 447 interval = MIN_INTERVAL;
440 448
441 req->id = newSVsv (id); 449 req->id = newSVsv (id);
… …
445 req->ranges = (RANGE *)malloc (nranges * sizeof (RANGE)); 453 req->ranges = (RANGE *)malloc (nranges * sizeof (RANGE));
446 454
447 while (nranges--) 455 while (nranges--)
448 { 456 {
449 SV *sv = *av_fetch (rav, nranges, 1); 457 SV *sv = *av_fetch (rav, nranges, 1);
458 SV *lo, *hi;
459 AV *av;
460 RANGE *r;
450 461
451 if (!SvROK (sv) || SvTYPE (SvRV (sv)) != SVt_PVAV) 462 if (!SvROK (sv) || SvTYPE (SvRV (sv)) != SVt_PVAV)
452 croak ("address range must be given as arrayref with lo, hi, interval arrayrefs"); 463 croak ("address range must be given as arrayref with lo, hi, interval arrayrefs");
453 464
454 AV *av = (AV *)SvRV (sv); 465 av = (AV *)SvRV (sv);
455 RANGE *r = req->ranges + nranges; 466 r = req->ranges + nranges;
456 467
457 SV *lo = *av_fetch (av, 0, 1); 468 lo = *av_fetch (av, 0, 1);
458 SV *hi = *av_fetch (av, 1, 1); 469 hi = *av_fetch (av, 1, 1);
459 470
460 sv_utf8_downgrade (lo, 0); 471 sv_utf8_downgrade (lo, 0);
461 sv_utf8_downgrade (hi, 0); 472 sv_utf8_downgrade (hi, 0);
462 473
463 memset (&r->lo, 0, sizeof (addr_t)); 474 memset (&r->lo, 0, sizeof (addr_t));
464 memset (&r->hi, 0, sizeof (addr_t)); 475 memset (&r->hi, 0, sizeof (addr_t));
465 476
466 if (SvPOKp (lo) && SvPOKp (hi)) 477 if (SvPOKp (lo) && SvPOKp (hi))
467 { 478 {
468 if (SvCUR (lo) != SvCUR (hi)) 479 if (SvCUR (lo) != SvCUR (hi))
469 croak ("addresses in range must be of the same size (either 4 or 16 bytes)"); 480 croak ("all addresses in range must be of the same size (either 4 or 16 bytes)");
470 481
471 if (SvCUR (lo) == 4) 482 if (SvCUR (lo) == 4)
472 { 483 {
473 r->family = AF_INET; 484 r->family = AF_INET;
474 memcpy (sizeof (addr_t) - 4 + (char *)&r->lo, SvPVX (lo), 4); 485 memcpy (sizeof (addr_t) - 4 + (char *)&r->lo, SvPVX (lo), 4);
475 memcpy (sizeof (addr_t) - 4 + (char *)&r->hi, SvPVX (hi), 4); 486 memcpy (sizeof (addr_t) - 4 + (char *)&r->hi, SvPVX (hi), 4);
476 } 487 }
477 else if (SvCUR (lo) == 16) 488 else if (SvCUR (lo) == 16)
478 { 489 {
479#if IPV6 490#if ENABLE_IPV6
480 r->family = AF_INET6; 491 r->family = AF_INET6;
481 memcpy (&r->lo, SvPVX (lo), sizeof (addr_t)); 492 memcpy (&r->lo, SvPVX (lo), sizeof (addr_t));
482 memcpy (&r->hi, SvPVX (hi), sizeof (addr_t)); 493 memcpy (&r->hi, SvPVX (hi), sizeof (addr_t));
483#else 494#else
484 croak ("IPv6 not supported in this configuration"); 495 croak ("IPv6 not supported in this configuration");
485#endif 496#endif
486 } 497 }
487 else 498 else
488 croak ("addresses in range must be either 4 (IPv4) or 16 (IPV6) bytes in length"); 499 croak ("addresses in range must be either 4 (IPv4) or 16 (IPv6) bytes in length");
489 } 500 }
490 else if (SvIOK (lo) && SvIOK (hi)) 501 else if (SvIOK (lo) && SvIOK (hi))
491 { 502 {
503 uint32_t addr;
504
492 r->family = AF_INET; 505 r->family = AF_INET;
493 506
494 uint32_t addr;
495 addr = htonl (SvUV (lo)); memcpy (sizeof (addr_t) - 4 + (char *)&r->lo, &addr, 4); 507 addr = htonl (SvUV (lo)); memcpy (sizeof (addr_t) - 4 + (char *)&r->lo, &addr, 4);
496 addr = htonl (SvUV (hi)); memcpy (sizeof (addr_t) - 4 + (char *)&r->hi, &addr, 4); 508 addr = htonl (SvUV (hi)); memcpy (sizeof (addr_t) - 4 + (char *)&r->hi, &addr, 4);
497 } 509 }
498 else 510 else
499 croak ("addresses in range must be strings with either 4 (IPv4) or 16 (IPv6) octets"); 511 croak ("addresses in range must be strings with either 4 (IPv4) or 16 (IPv6) octets");
… …
548 AV *res_av = av_len (cbs) < 0 ? 0 : (AV *)sv_2mortal ((SV *)newAV ()); 560 AV *res_av = av_len (cbs) < 0 ? 0 : (AV *)sv_2mortal ((SV *)newAV ());
549 tstamp now = NOW (); 561 tstamp now = NOW ();
550 562
551 for (;;) 563 for (;;)
552 { 564 {
565 IP4HDR *iphdr = (IP4HDR *)buf;
553 int len = recvfrom (icmp4_fd, buf, sizeof (buf), MSG_DONTWAIT | MSG_TRUNC, &sa, &sl); 566 int len = recvfrom (icmp4_fd, buf, sizeof (buf), MSG_TRUNC, (struct sockaddr *)&sa, &sl);
567 int hdrlen, totlen;
568 PKT *pkt;
554 569
555 if (len <= HDR_SIZE_IP4) 570 if (len <= HDR_SIZE_IP4)
556 break; 571 break;
557 572
558 IP4HDR *iphdr = (IP4HDR *)buf;
559
560 int hdrlen = (iphdr->version_ihl & 15) * 4; 573 hdrlen = (iphdr->version_ihl & 15) * 4;
561 int totlen = ntohs (iphdr->tot_len); 574 totlen = ntohs (iphdr->tot_len);
562 575
563 // packet corrupt? 576 // packet corrupt?
564 if (!res_av 577 if (!res_av
565 || totlen > len 578 || totlen > len
566 || iphdr->protocol != IPPROTO_ICMP 579 || iphdr->protocol != IPPROTO_ICMP
567 || hdrlen < HDR_SIZE_IP4 || hdrlen + sizeof (PKT) != totlen) 580 || hdrlen < HDR_SIZE_IP4 || hdrlen + sizeof (PKT) != totlen)
568 continue; 581 continue;
569 582
570 PKT *pkt = (PKT *)(buf + hdrlen); 583 pkt = (PKT *)(buf + hdrlen);
571 584
572 if (pkt->type != ICMP4_ECHO_REPLY 585 if (pkt->type != ICMP4_ECHO_REPLY
573 || pkt->id != (uint16_t) magic 586 || pkt->id != (uint16_t) magic
574 || pkt->seq != (uint16_t)~magic 587 || pkt->seq != (uint16_t)~magic
575 || !isnormal (pkt->stamp)) 588 || !isnormal (pkt->stamp))
576 continue; 589 continue;
577 590
591 {
578 AV *av = newAV (); 592 AV *av = newAV ();
579 av_push (av, newSVpvn ((char *)&sa.sin_addr, 4)); 593 av_push (av, newSVpvn ((char *)&sa.sin_addr, 4));
580 av_push (av, newSVnv (now - pkt->stamp)); 594 av_push (av, newSVnv (now - pkt->stamp));
581 av_push (av, newSVuv (pkt->payload)); 595 av_push (av, newSVuv (pkt->payload));
582 596
583 av_push (res_av, newRV_noinc ((SV *)av)); 597 av_push (res_av, newRV_noinc ((SV *)av));
598 }
584 } 599 }
585 600
586 if (res_av) 601 if (res_av)
587 feed_reply (res_av); 602 feed_reply (res_av);
588} 603}
… …
597 PKT pkt; 612 PKT pkt;
598 tstamp now = NOW (); 613 tstamp now = NOW ();
599 614
600 for (;;) 615 for (;;)
601 { 616 {
602 int len = recvfrom (icmp6_fd, &pkt, sizeof (pkt), MSG_DONTWAIT | MSG_TRUNC, &sa, &sl); 617 int len = recvfrom (icmp6_fd, &pkt, sizeof (pkt), MSG_TRUNC, (struct sockaddr *)&sa, &sl);
603 618
604 if (len != sizeof (PKT)) 619 if (len != sizeof (PKT))
605 break; 620 break;
606 621
607 if (!res_av 622 if (!res_av
… …
609 || pkt.id != (uint16_t) magic 624 || pkt.id != (uint16_t) magic
610 || pkt.seq != (uint16_t)~magic 625 || pkt.seq != (uint16_t)~magic
611 || !isnormal (pkt.stamp)) 626 || !isnormal (pkt.stamp))
612 continue; 627 continue;
613 628
629 {
614 AV *av = newAV (); 630 AV *av = newAV ();
615 av_push (av, newSVpvn ((char *)&sa.sin6_addr, 16)); 631 av_push (av, newSVpvn ((char *)&sa.sin6_addr, 16));
616 av_push (av, newSVnv (now - pkt.stamp)); 632 av_push (av, newSVnv (now - pkt.stamp));
617 av_push (av, newSVuv (pkt.payload)); 633 av_push (av, newSVuv (pkt.payload));
618 634
619 av_push (res_av, newRV_noinc ((SV *)av)); 635 av_push (res_av, newRV_noinc ((SV *)av));
636 }
620 } 637 }
621 638
622 if (res_av) 639 if (res_av)
623 feed_reply (res_av); 640 feed_reply (res_av);
624} 641}

Diff Legend

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