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.4 by root, Sun Mar 29 20:07:03 2009 UTC vs.
Revision 1.8 by root, Sat Jan 29 23:36:49 2011 UTC

1#define _POSIX_C_SOURCE 200112 1#if defined(__linux) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__CYGWIN__)
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#ifdef __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 && !defined (__CYGWIN__)
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
… …
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 buffersize 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_tt[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}
67 63
68typedef struct { 64typedef struct
65{
69 int family; 66 int family;
70 addr_t lo, hi; 67 addr_tt lo, hi;
71 double interval; 68 double interval;
72 tstamp next; 69 tstamp next;
73} RANGE; 70} RANGE;
74 71
75typedef struct { 72typedef struct
73{
76 SV *id; 74 SV *id;
77 double interval; 75 double interval;
78 int nranges; 76 int nranges;
79 RANGE *ranges; 77 RANGE *ranges;
80 uint32_t payload; 78 uint32_t payload;
81} REQ; 79} REQ;
82 80
83typedef struct { 81typedef struct
82{
84 uint8_t version_ihl; 83 uint8_t version_ihl;
85 uint8_t tos; 84 uint8_t tos;
86 uint16_t tot_len; 85 uint16_t tot_len;
87 86
88 uint16_t id; 87 uint16_t id;
… …
94 93
95 uint32_t src; 94 uint32_t src;
96 uint32_t dst; 95 uint32_t dst;
97} IP4HDR; 96} IP4HDR;
98 97
99typedef struct { 98typedef struct
99{
100 uint8_t version; 100 uint8_t version;
101 uint8_t x1, x2, x3; 101 uint8_t x1, x2, x3;
102 102
103 uint16_t payload_len; 103 uint16_t payload_len;
104 uint8_t nxt_hdr; 104 uint8_t nxt_hdr;
… …
110 110
111#define MAGIC 0xca4c 111#define MAGIC 0xca4c
112 112
113static uint16_t magic; 113static uint16_t magic;
114 114
115typedef struct { 115typedef struct
116{
116 uint8_t type, code; 117 uint8_t type, code;
117 uint16_t cksum; 118 uint16_t cksum;
118 uint16_t id, seq; 119 uint16_t id, seq;
119 uint32_t payload; 120 uint32_t payload;
120 tstamp stamp; // be careful when accessing this 121 tstamp stamp; // be careful when accessing this
… …
144 145
145 return ~sum; 146 return ~sum;
146} 147}
147 148
148static void 149static void
149inc_addr (addr_t *addr) 150inc_addr (addr_tt *addr)
150{ 151{
151 int len = sizeof (addr_t) - 1; 152 int len = sizeof (addr_tt) - 1;
152 153
153 do 154 do
154 { 155 {
155 if ((*addr)[len] != 0xff) 156 if ((*addr)[len] != 0xff)
156 { 157 {
… …
166static void * 167static void *
167ping_proc (void *unused) 168ping_proc (void *unused)
168{ 169{
169 PKT pkt; 170 PKT pkt;
170 struct sockaddr_in sa4; 171 struct sockaddr_in sa4;
171#if IPV6 172#if ENABLE_IPV6
172 struct sockaddr_in6 sa6; 173 struct sockaddr_in6 sa6;
173#endif 174#endif
174 175
175 memset (&pkt, 0, sizeof (pkt)); 176 memset (&pkt, 0, sizeof (pkt));
176 177
177 memset (&sa4, 0, sizeof (sa4)); 178 memset (&sa4, 0, sizeof (sa4));
178 sa4.sin_family = AF_INET; 179 sa4.sin_family = AF_INET;
179 sa4.sin_port = 0; 180 sa4.sin_port = 0;
180#if IPV6 181#if ENABLE_IPV6
181 memset (&sa6, 0, sizeof (sa6)); 182 memset (&sa6, 0, sizeof (sa6));
182 sa6.sin6_family = AF_INET6; 183 sa6.sin6_family = AF_INET6;
183 sa6.sin6_port = 0; 184 sa6.sin6_port = 0;
184#endif 185#endif
185 186
186 for (;;) 187 for (;;)
187 { 188 {
188 REQ *req; 189 REQ *req;
189 int len = read (thr_send [0], &req, sizeof (req)); 190 int len = read (thr_send [0], &req, sizeof (req));
190 191
192 tstamp now = NOW ();
193 tstamp next = now;
194
191 if (!len) 195 if (!len)
192 pthread_exit (0); 196 pthread_exit (0);
193 else if (len != sizeof (req)) 197 else if (len != sizeof (req))
194 { 198 {
195 perror ("AnyEvent::FastPing: short reead or read error"); 199 perror ("AnyEvent::FastPing: short read or read error");
196 pthread_exit ((void *)-1); 200 pthread_exit ((void *)-1);
197 } 201 }
198 202
199 //TODO: bind to source address 203 //TODO: bind to source address
200 204
201 pkt.code = 0; 205 pkt.code = 0;
202 pkt.id = (uint16_t)magic; 206 pkt.id = (uint16_t)magic;
203 pkt.seq = (uint16_t)~magic; 207 pkt.seq = (uint16_t)~magic;
204 pkt.payload = req->payload; 208 pkt.payload = req->payload;
205
206 tstamp now = NOW ();
207 tstamp next = now;
208 209
209 { 210 {
210 int r; 211 int r;
211 for (r = req->nranges; r--; ) 212 for (r = req->nranges; r--; )
212 inc_addr (&req->ranges [r].hi); 213 inc_addr (&req->ranges [r].hi);
213 } 214 }
214 215
215 while (req->nranges) 216 while (req->nranges)
216 { 217 {
217 RANGE *range = req->ranges; 218 RANGE *range = req->ranges;
219 int n, k;
218 220
219 if (!memcmp (&range->lo, &range->hi, sizeof (addr_t))) 221 if (!memcmp (&range->lo, &range->hi, sizeof (addr_tt)))
220 req->ranges [0] = req->ranges [--req->nranges]; 222 req->ranges [0] = req->ranges [--req->nranges];
221 else 223 else
222 { 224 {
223 // ranges [0] is always the next range to ping 225 // ranges [0] is always the next range to ping
224 tstamp wait = range->next - now; 226 tstamp wait = range->next - now;
… …
252 { 254 {
253 pkt.type = ICMP4_ECHO; 255 pkt.type = ICMP4_ECHO;
254 pkt.cksum = icmp_cksum (&pkt, sizeof (pkt)); 256 pkt.cksum = icmp_cksum (&pkt, sizeof (pkt));
255 257
256 memcpy (&sa4.sin_addr, 258 memcpy (&sa4.sin_addr,
257 sizeof (addr_t) - sizeof (sa4.sin_addr) + (char *)&range->lo, 259 sizeof (addr_tt) - sizeof (sa4.sin_addr) + (char *)&range->lo,
258 sizeof (sa4.sin_addr)); 260 sizeof (sa4.sin_addr));
259 261
260 if (sendto (icmp4_fd, &pkt, sizeof (pkt), 0, (struct sockaddr *)&sa4, sizeof (sa4)) > 0) 262 if (sendto (icmp4_fd, &pkt, sizeof (pkt), 0, (struct sockaddr *)&sa4, sizeof (sa4)) > 0)
261 errno = 0; 263 errno = 0;
262 } 264 }
263 else 265 else
264 { 266 {
265#if IPV6 267#if ENABLE_IPV6
266 pkt.type = ICMP6_ECHO; 268 pkt.type = ICMP6_ECHO;
267 269
268 memcpy (&sa6.sin6_addr, 270 memcpy (&sa6.sin6_addr,
269 sizeof (addr_t) - sizeof (sa6.sin6_addr) + (char *)&range->lo, 271 sizeof (addr_tt) - sizeof (sa6.sin6_addr) + (char *)&range->lo,
270 sizeof (sa6.sin6_addr)); 272 sizeof (sa6.sin6_addr));
271 273
272 if (sendto (icmp6_fd, &pkt, sizeof (pkt), 0, (struct sockaddr *)&sa6, sizeof (sa6)) > 0) 274 if (sendto (icmp6_fd, &pkt, sizeof (pkt), 0, (struct sockaddr *)&sa6, sizeof (sa6)) > 0)
273 errno = 0; 275 errno = 0;
274#endif 276#endif
… …
293 295
294 next += req->interval; 296 next += req->interval;
295 } 297 }
296 298
297 // make a downheap operation 299 // make a downheap operation
298 int k = 0;
299 int n = 0;
300 for (;;) 300 for (n = k = 0; ; )
301 { 301 {
302 int j = k * 2 + 1;
303
302 ++n; 304 ++n;
303 int j = k * 2 + 1;
304 305
305 if (j >= req->nranges) 306 if (j >= req->nranges)
306 break; 307 break;
307 else if (j < req->nranges - 1) 308 else if (j < req->nranges - 1)
308 if (req->ranges [j].next > req->ranges [j + 1].next) 309 if (req->ranges [j].next > req->ranges [j + 1].next)
309 ++j; 310 ++j;
310 311
311 if (req->ranges [j].next >= req->ranges [k].next) 312 if (req->ranges [j].next >= req->ranges [k].next)
312 break; 313 break;
313 314
315 {
314 RANGE temp = req->ranges [k]; 316 RANGE temp = req->ranges [k];
315 req->ranges [k] = req->ranges [j]; 317 req->ranges [k] = req->ranges [j];
316 req->ranges [j] = temp; 318 req->ranges [j] = temp;
319 }
317 320
318 k = j; 321 k = j;
319 } 322 }
320 } 323 }
321 324
… …
326} 329}
327 330
328static void 331static void
329feed_reply (AV *res_av) 332feed_reply (AV *res_av)
330{ 333{
331 if (av_len (res_av) < 0)
332 return;
333
334 dSP; 334 dSP;
335 SV *res = sv_2mortal (newRV_inc ((SV *)res_av)); 335 SV *res = sv_2mortal (newRV_inc ((SV *)res_av));
336 int i; 336 int i;
337
338 if (av_len (res_av) < 0)
339 return;
337 340
338 ENTER; 341 ENTER;
339 SAVETMPS; 342 SAVETMPS;
340 343
341 for (i = av_len (cbs) + 1; i--; ) 344 for (i = av_len (cbs) + 1; i--; )
… …
372 oval.data = 0xffffffff & ~(1 << ICMP4_ECHO_REPLY); 375 oval.data = 0xffffffff & ~(1 << ICMP4_ECHO_REPLY);
373 setsockopt (icmp4_fd, SOL_RAW, ICMP_FILTER, &oval, sizeof oval); 376 setsockopt (icmp4_fd, SOL_RAW, ICMP_FILTER, &oval, sizeof oval);
374 } 377 }
375#endif 378#endif
376 379
377#if IPV6 380#if ENABLE_IPV6
378 icmp6_fd = socket (AF_INET6, SOCK_RAW, IPPROTO_ICMPV6); 381 icmp6_fd = socket (AF_INET6, SOCK_RAW, IPPROTO_ICMPV6);
379 fcntl (icmp6_fd, F_SETFL, O_NONBLOCK); 382 fcntl (icmp6_fd, F_SETFL, O_NONBLOCK);
380# ifdef ICMP6_FILTER 383# ifdef ICMP6_FILTER
381 { 384 {
382 struct icmp6_filter oval; 385 struct icmp6_filter oval;
… …
431 434
432SV * 435SV *
433_req_icmp_ping (SV *ranges, NV interval, U32 payload, SV *id) 436_req_icmp_ping (SV *ranges, NV interval, U32 payload, SV *id)
434 CODE: 437 CODE:
435{ 438{
439 AV *rav;
440 int nranges, i;
441 REQ *req;
442
436 if (!SvROK (ranges) || SvTYPE (SvRV (ranges)) != SVt_PVAV) 443 if (!SvROK (ranges) || SvTYPE (SvRV (ranges)) != SVt_PVAV)
437 croak ("address ranges must be given as arrayref with lo, hi pairs"); 444 croak ("address ranges must be given as arrayref with lo, hi pairs");
438 445
439 AV *rav = (AV *)SvRV (ranges); 446 rav = (AV *)SvRV (ranges);
440 int nranges = av_len (rav) + 1; 447 nranges = av_len (rav) + 1;
441 448
442 REQ *req = malloc (sizeof (REQ)); 449 req = malloc (sizeof (REQ));
443 int i;
444 450
445 if (interval < MIN_INTERVAL) 451 if (interval < MIN_INTERVAL)
446 interval = MIN_INTERVAL; 452 interval = MIN_INTERVAL;
447 453
448 req->id = newSVsv (id); 454 req->id = newSVsv (id);
… …
452 req->ranges = (RANGE *)malloc (nranges * sizeof (RANGE)); 458 req->ranges = (RANGE *)malloc (nranges * sizeof (RANGE));
453 459
454 while (nranges--) 460 while (nranges--)
455 { 461 {
456 SV *sv = *av_fetch (rav, nranges, 1); 462 SV *sv = *av_fetch (rav, nranges, 1);
463 SV *lo, *hi;
464 AV *av;
465 RANGE *r;
457 466
458 if (!SvROK (sv) || SvTYPE (SvRV (sv)) != SVt_PVAV) 467 if (!SvROK (sv) || SvTYPE (SvRV (sv)) != SVt_PVAV)
459 croak ("address range must be given as arrayref with lo, hi, interval arrayrefs"); 468 croak ("address range must be given as arrayref with lo, hi, interval arrayrefs");
460 469
461 AV *av = (AV *)SvRV (sv); 470 av = (AV *)SvRV (sv);
462 RANGE *r = req->ranges + nranges; 471 r = req->ranges + nranges;
463 472
464 SV *lo = *av_fetch (av, 0, 1); 473 lo = *av_fetch (av, 0, 1);
465 SV *hi = *av_fetch (av, 1, 1); 474 hi = *av_fetch (av, 1, 1);
466 475
467 sv_utf8_downgrade (lo, 0); 476 sv_utf8_downgrade (lo, 0);
468 sv_utf8_downgrade (hi, 0); 477 sv_utf8_downgrade (hi, 0);
469 478
470 memset (&r->lo, 0, sizeof (addr_t)); 479 memset (&r->lo, 0, sizeof (addr_tt));
471 memset (&r->hi, 0, sizeof (addr_t)); 480 memset (&r->hi, 0, sizeof (addr_tt));
472 481
473 if (SvPOKp (lo) && SvPOKp (hi)) 482 if (SvPOKp (lo) && SvPOKp (hi))
474 { 483 {
475 if (SvCUR (lo) != SvCUR (hi)) 484 if (SvCUR (lo) != SvCUR (hi))
476 croak ("addresses in range must be of the same size (either 4 or 16 bytes)"); 485 croak ("all addresses in range must be of the same size (either 4 or 16 bytes)");
477 486
478 if (SvCUR (lo) == 4) 487 if (SvCUR (lo) == 4)
479 { 488 {
480 r->family = AF_INET; 489 r->family = AF_INET;
481 memcpy (sizeof (addr_t) - 4 + (char *)&r->lo, SvPVX (lo), 4); 490 memcpy (sizeof (addr_tt) - 4 + (char *)&r->lo, SvPVX (lo), 4);
482 memcpy (sizeof (addr_t) - 4 + (char *)&r->hi, SvPVX (hi), 4); 491 memcpy (sizeof (addr_tt) - 4 + (char *)&r->hi, SvPVX (hi), 4);
483 } 492 }
484 else if (SvCUR (lo) == 16) 493 else if (SvCUR (lo) == 16)
485 { 494 {
486#if IPV6 495#if ENABLE_IPV6
487 r->family = AF_INET6; 496 r->family = AF_INET6;
488 memcpy (&r->lo, SvPVX (lo), sizeof (addr_t)); 497 memcpy (&r->lo, SvPVX (lo), sizeof (addr_tt));
489 memcpy (&r->hi, SvPVX (hi), sizeof (addr_t)); 498 memcpy (&r->hi, SvPVX (hi), sizeof (addr_tt));
490#else 499#else
491 croak ("IPv6 not supported in this configuration"); 500 croak ("IPv6 not supported in this configuration");
492#endif 501#endif
493 } 502 }
494 else 503 else
495 croak ("addresses in range must be either 4 (IPv4) or 16 (IPV6) bytes in length"); 504 croak ("addresses in range must be either 4 (IPv4) or 16 (IPv6) bytes in length");
496 } 505 }
497 else if (SvIOK (lo) && SvIOK (hi)) 506 else if (SvIOK (lo) && SvIOK (hi))
498 { 507 {
508 uint32_t addr;
509
499 r->family = AF_INET; 510 r->family = AF_INET;
500 511
501 uint32_t addr;
502 addr = htonl (SvUV (lo)); memcpy (sizeof (addr_t) - 4 + (char *)&r->lo, &addr, 4); 512 addr = htonl (SvUV (lo)); memcpy (sizeof (addr_tt) - 4 + (char *)&r->lo, &addr, 4);
503 addr = htonl (SvUV (hi)); memcpy (sizeof (addr_t) - 4 + (char *)&r->hi, &addr, 4); 513 addr = htonl (SvUV (hi)); memcpy (sizeof (addr_tt) - 4 + (char *)&r->hi, &addr, 4);
504 } 514 }
505 else 515 else
506 croak ("addresses in range must be strings with either 4 (IPv4) or 16 (IPv6) octets"); 516 croak ("addresses in range must be strings with either 4 (IPv4) or 16 (IPv6) octets");
507 517
508 if (r->family == AF_INET) 518 if (r->family == AF_INET)
… …
555 AV *res_av = av_len (cbs) < 0 ? 0 : (AV *)sv_2mortal ((SV *)newAV ()); 565 AV *res_av = av_len (cbs) < 0 ? 0 : (AV *)sv_2mortal ((SV *)newAV ());
556 tstamp now = NOW (); 566 tstamp now = NOW ();
557 567
558 for (;;) 568 for (;;)
559 { 569 {
570 IP4HDR *iphdr = (IP4HDR *)buf;
560 int len = recvfrom (icmp4_fd, buf, sizeof (buf), MSG_TRUNC, (struct sockaddr *)&sa, &sl); 571 int len = recvfrom (icmp4_fd, buf, sizeof (buf), MSG_TRUNC, (struct sockaddr *)&sa, &sl);
572 int hdrlen, totlen;
573 PKT *pkt;
561 574
562 if (len <= HDR_SIZE_IP4) 575 if (len <= HDR_SIZE_IP4)
563 break; 576 break;
564 577
565 IP4HDR *iphdr = (IP4HDR *)buf;
566
567 int hdrlen = (iphdr->version_ihl & 15) * 4; 578 hdrlen = (iphdr->version_ihl & 15) * 4;
568 int totlen = ntohs (iphdr->tot_len); 579 totlen = ntohs (iphdr->tot_len);
569 580
570 // packet corrupt? 581 // packet corrupt?
571 if (!res_av 582 if (!res_av
572 || totlen > len 583 || totlen > len
573 || iphdr->protocol != IPPROTO_ICMP 584 || iphdr->protocol != IPPROTO_ICMP
574 || hdrlen < HDR_SIZE_IP4 || hdrlen + sizeof (PKT) != totlen) 585 || hdrlen < HDR_SIZE_IP4 || hdrlen + sizeof (PKT) != totlen)
575 continue; 586 continue;
576 587
577 PKT *pkt = (PKT *)(buf + hdrlen); 588 pkt = (PKT *)(buf + hdrlen);
578 589
579 if (pkt->type != ICMP4_ECHO_REPLY 590 if (pkt->type != ICMP4_ECHO_REPLY
580 || pkt->id != (uint16_t) magic 591 || pkt->id != (uint16_t) magic
581 || pkt->seq != (uint16_t)~magic 592 || pkt->seq != (uint16_t)~magic
582 || !isnormal (pkt->stamp)) 593 || !isnormal (pkt->stamp))
583 continue; 594 continue;
584 595
596 {
585 AV *av = newAV (); 597 AV *av = newAV ();
586 av_push (av, newSVpvn ((char *)&sa.sin_addr, 4)); 598 av_push (av, newSVpvn ((char *)&sa.sin_addr, 4));
587 av_push (av, newSVnv (now - pkt->stamp)); 599 av_push (av, newSVnv (now - pkt->stamp));
588 av_push (av, newSVuv (pkt->payload)); 600 av_push (av, newSVuv (pkt->payload));
589 601
590 av_push (res_av, newRV_noinc ((SV *)av)); 602 av_push (res_av, newRV_noinc ((SV *)av));
603 }
591 } 604 }
592 605
593 if (res_av) 606 if (res_av)
594 feed_reply (res_av); 607 feed_reply (res_av);
595} 608}
… …
616 || pkt.id != (uint16_t) magic 629 || pkt.id != (uint16_t) magic
617 || pkt.seq != (uint16_t)~magic 630 || pkt.seq != (uint16_t)~magic
618 || !isnormal (pkt.stamp)) 631 || !isnormal (pkt.stamp))
619 continue; 632 continue;
620 633
634 {
621 AV *av = newAV (); 635 AV *av = newAV ();
622 av_push (av, newSVpvn ((char *)&sa.sin6_addr, 16)); 636 av_push (av, newSVpvn ((char *)&sa.sin6_addr, 16));
623 av_push (av, newSVnv (now - pkt.stamp)); 637 av_push (av, newSVnv (now - pkt.stamp));
624 av_push (av, newSVuv (pkt.payload)); 638 av_push (av, newSVuv (pkt.payload));
625 639
626 av_push (res_av, newRV_noinc ((SV *)av)); 640 av_push (res_av, newRV_noinc ((SV *)av));
641 }
627 } 642 }
628 643
629 if (res_av) 644 if (res_av)
630 feed_reply (res_av); 645 feed_reply (res_av);
631} 646}

Diff Legend

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