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.2 by root, Sat May 17 21:47:29 2008 UTC vs.
Revision 1.7 by root, Sun Jan 16 17:05:32 2011 UTC

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

Diff Legend

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