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

Comparing AnyEvent-FastPing/FPing.xs (file contents):
Revision 1.1 by root, Fri May 4 07:02:19 2007 UTC vs.
Revision 1.7 by root, Fri May 4 16:17:25 2007 UTC

1#define _POSIX_C_SOURCE 199309 1#define _POSIX_C_SOURCE 199309
2#define _GNU_SOURCE 1 2#define _GNU_SOURCE 1
3 3
4#define IPV6 1 4#define IPV6 1 // if you get compilation problems try to disable IPv6
5 5
6#include "EXTERN.h" 6#include "EXTERN.h"
7#include "perl.h" 7#include "perl.h"
8#include "XSUB.h" 8#include "XSUB.h"
9 9
… …
26#include <sys/socket.h> 26#include <sys/socket.h>
27 27
28#include <netinet/in.h> 28#include <netinet/in.h>
29#include <arpa/inet.h> 29#include <arpa/inet.h>
30 30
31#ifdef __linux
32# include <linux/icmp.h>
33#endif
34#if IPV6
35# include <netinet/icmp6.h>
36#endif
37
31#define ICMP4_ECHO 8 38#define ICMP4_ECHO 8
39#define ICMP4_ECHO_REPLY 0
32#define ICMP6_ECHO 128 40#define ICMP6_ECHO 128
41#define ICMP6_ECHO_REPLY 129
33 42
34#define DRAIN_INTERVAL .000001 // how long to wait when sendto returns ENOBUFS, in seconds 43#define DRAIN_INTERVAL .000001 // how long to wait when sendto returns ENOBUFS, in seconds
35#define MIN_INTERVAL .000001 // minimum packet send interval, in seconds 44#define MIN_INTERVAL .000001 // minimum packet send interval, in seconds
36 45
37#define HDR_SIZE_IP4 20 46#define HDR_SIZE_IP4 20
… …
57 double interval; 66 double interval;
58 tstamp next; 67 tstamp next;
59} RANGE; 68} RANGE;
60 69
61typedef struct { 70typedef struct {
62 int send_fd;
63 SV *id; 71 SV *id;
64 double interval; 72 double interval;
65 int nranges; 73 int nranges;
66 RANGE *ranges; 74 RANGE *ranges;
67 uint32_t payload; 75 uint32_t payload;
… …
95 uint8_t dst[16]; 103 uint8_t dst[16];
96} IP6HDR; 104} IP6HDR;
97 105
98#define MAGIC 0xca4c 106#define MAGIC 0xca4c
99 107
108static uint16_t magic;
109
100typedef struct { 110typedef struct {
101 uint8_t type, code; 111 uint8_t type, code;
102 uint16_t cksum; 112 uint16_t cksum;
103 uint16_t id, seq; 113 uint16_t id, seq;
114 uint32_t payload;
104 tstamp stamp; // be careful when accessing this 115 tstamp stamp; // be careful when accessing this
105 uint32_t payload;
106} PKT; 116} PKT;
107 117
108pthread_t pthrid; 118static pthread_t pthrid;
109int thr_send[2]; // send to worker 119static int thr_send[2]; // send to worker
110int thr_recv[2]; // receive from worker 120static int thr_recv[2]; // receive from worker
111 121
112int icmp4_fd, icmp6_fd; 122static int icmp4_fd, icmp6_fd;
113 123
114uint16_t 124static AV *cbs;
125
126static uint16_t
115icmp_cksum (void *data, unsigned int len) 127icmp_cksum (void *data, unsigned int len)
116{ 128{
117 register int sum = 0; 129 register int sum = 0;
118 uint16_t *wp; 130 uint16_t *wp;
119 131
… …
157 169
158 memset (&pkt, 0, sizeof (pkt)); 170 memset (&pkt, 0, sizeof (pkt));
159 171
160 memset (&sa4, 0, sizeof (sa4)); 172 memset (&sa4, 0, sizeof (sa4));
161 sa4.sin_family = AF_INET; 173 sa4.sin_family = AF_INET;
162 sa4.sin_port = 0; // unused 174 sa4.sin_port = 0;
163#if IPV6 175#if IPV6
164 memset (&sa6, 0, sizeof (sa6)); 176 memset (&sa6, 0, sizeof (sa6));
165 sa6.sin6_family = AF_INET6; 177 sa6.sin6_family = AF_INET6;
166 sa6.sin6_port = 0; // unused 178 sa6.sin6_port = 0;
167#endif 179#endif
168 180
169 for (;;) 181 for (;;)
170 { 182 {
171 REQ *req; 183 REQ *req;
… …
180 } 192 }
181 193
182 //TODO: bind to source address 194 //TODO: bind to source address
183 195
184 pkt.code = 0; 196 pkt.code = 0;
185 pkt.id = (uint16_t)MAGIC; 197 pkt.id = (uint16_t)magic;
186 pkt.seq = (uint16_t)~MAGIC; 198 pkt.seq = (uint16_t)~magic;
187 pkt.payload = req->payload; 199 pkt.payload = req->payload;
188 200
189 tstamp next = NOW (); 201 tstamp now = NOW ();
202 tstamp next = now;
203
204 {
205 int r;
206 for (r = req->nranges; r--; )
207 inc_addr (&req->ranges [r].hi);
208 }
190 209
191 while (req->nranges) 210 while (req->nranges)
192 { 211 {
193 RANGE *range = req->ranges; 212 RANGE *range = req->ranges;
194 213
195 if (!memcmp (&range->lo, &range->hi, sizeof (addr_t))) 214 if (!memcmp (&range->lo, &range->hi, sizeof (addr_t)))
196 req->ranges [0] = req->ranges [--req->nranges]; 215 req->ranges [0] = req->ranges [--req->nranges];
197 else 216 else
198 { 217 {
199 tstamp now = NOW ();
200
201 // ranges [0] is always the next range to ping 218 // ranges [0] is always the next range to ping
202 tstamp wait = range->next - now; 219 tstamp wait = range->next - now;
203 220
204 // compare with the global frequency limit 221 // compare with the global frequency limit
205 { 222 {
… …
219 ts.tv_nsec = (wait - ts.tv_sec) * 1000000000.; 236 ts.tv_nsec = (wait - ts.tv_sec) * 1000000000.;
220 237
221 nanosleep (&ts, 0); 238 nanosleep (&ts, 0);
222 } 239 }
223 240
241 now = NOW ();
242
224 pkt.stamp = now; 243 pkt.stamp = now;
225 pkt.cksum = 0; 244 pkt.cksum = 0;
226 245
227 if (range->family == AF_INET) 246 if (range->family == AF_INET)
228 { 247 {
… …
231 250
232 memcpy (&sa4.sin_addr, 251 memcpy (&sa4.sin_addr,
233 sizeof (addr_t) - sizeof (sa4.sin_addr) + (char *)&range->lo, 252 sizeof (addr_t) - sizeof (sa4.sin_addr) + (char *)&range->lo,
234 sizeof (sa4.sin_addr)); 253 sizeof (sa4.sin_addr));
235 254
236 if (sendto (req->send_fd, &pkt, sizeof (pkt), 0, (struct sockaddr *)&sa4, sizeof (sa4)) > 0) 255 if (sendto (icmp4_fd, &pkt, sizeof (pkt), 0, (struct sockaddr *)&sa4, sizeof (sa4)) > 0)
237 errno = 0; 256 errno = 0;
238 } 257 }
239 else 258 else
240 { 259 {
241#if IPV6 260#if IPV6
… …
243 262
244 memcpy (&sa6.sin6_addr, 263 memcpy (&sa6.sin6_addr,
245 sizeof (addr_t) - sizeof (sa6.sin6_addr) + (char *)&range->lo, 264 sizeof (addr_t) - sizeof (sa6.sin6_addr) + (char *)&range->lo,
246 sizeof (sa6.sin6_addr)); 265 sizeof (sa6.sin6_addr));
247 266
248 if (sendto (req->send_fd, &pkt, sizeof (pkt), 0, (struct sockaddr *)&sa6, sizeof (sa6)) > 0) 267 if (sendto (icmp6_fd, &pkt, sizeof (pkt), 0, (struct sockaddr *)&sa6, sizeof (sa6)) > 0)
249 errno = 0; 268 errno = 0;
250#endif 269#endif
251 } 270 }
252 271
253 if (errno == ENOBUFS) 272 if (errno == ENOBUFS)
… …
300 319
301 return 0; 320 return 0;
302} 321}
303 322
304static void 323static void
324feed_reply (AV *res_av)
325{
326 if (av_len (res_av) < 0)
327 return;
328
329 dSP;
330 SV *res = sv_2mortal (newRV_inc ((SV *)res_av));
331 int i;
332
333 ENTER;
334 SAVETMPS;
335
336 for (i = av_len (cbs) + 1; i--; )
337 {
338 SV *cb = *av_fetch (cbs, i, 1);
339
340 PUSHMARK (SP);
341 XPUSHs (res);
342 PUTBACK;
343 call_sv (cb, G_DISCARD | G_VOID);
344 }
345
346 FREETMPS;
347 LEAVE;
348}
349
350static void
305boot () 351boot ()
306{ 352{
307 sigset_t fullsigset, oldsigset; 353 sigset_t fullsigset, oldsigset;
308 pthread_attr_t attr; 354 pthread_attr_t attr;
309 355
… …
312 358
313 if (pipe (thr_recv) < 0) 359 if (pipe (thr_recv) < 0)
314 croak ("Net::FPing: unable to create receive pipe"); 360 croak ("Net::FPing: unable to create receive pipe");
315 361
316 icmp4_fd = socket (AF_INET, SOCK_RAW, IPPROTO_ICMP); 362 icmp4_fd = socket (AF_INET, SOCK_RAW, IPPROTO_ICMP);
363#ifdef ICMP_FILTER
364 {
365 struct icmp_filter oval;
366 oval.data = 0xffffffff & ~(1 << ICMP4_ECHO_REPLY);
367 setsockopt (icmp4_fd, SOL_RAW, ICMP_FILTER, &oval, sizeof oval);
368 }
369#endif
370
317#if IPV6 371#if IPV6
318 icmp6_fd = socket (AF_INET6, SOCK_RAW, IPPROTO_ICMPV6); 372 icmp6_fd = socket (AF_INET6, SOCK_RAW, IPPROTO_ICMPV6);
373# ifdef ICMP6_FILTER
374 {
375 struct icmp6_filter oval;
376 ICMP6_FILTER_SETBLOCKALL (&oval);
377 ICMP6_FILTER_SETPASS (ICMP6_ECHO_REPLY, &oval);
378 setsockopt (icmp6_fd, IPPROTO_ICMPV6, ICMP6_FILTER, &oval, sizeof oval);
379 }
380# endif
319#endif 381#endif
320 382
321 pthread_attr_init (&attr); 383 pthread_attr_init (&attr);
322 pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED); 384 pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
323#ifdef PTHREAD_SCOPE_PROCESS 385#ifdef PTHREAD_SCOPE_PROCESS
… …
341} 403}
342 404
343MODULE = Net::FPing PACKAGE = Net::FPing 405MODULE = Net::FPing PACKAGE = Net::FPing
344 406
345BOOT: 407BOOT:
408{
409 HV *stash = gv_stashpv ("Net::FPing", 1);
410
411 cbs = get_av ("Net::FPing::CB", 1);
412 magic = getpid () ^ MAGIC;
413
346 boot (); 414 boot ();
347 415
416 newCONSTSUB (stash, "ipv4_supported", newSViv (icmp4_fd >= 0));
417 newCONSTSUB (stash, "ipv6_supported", newSViv (icmp6_fd >= 0));
418
419 newCONSTSUB (stash, "icmp4_pktsize", newSViv (HDR_SIZE_IP4 + sizeof (PKT)));
420 newCONSTSUB (stash, "icmp6_pktsize", newSViv (HDR_SIZE_IP6 + sizeof (PKT)));
421}
422
348PROTOTYPES: DISABLE 423PROTOTYPES: DISABLE
349 424
350SV * 425SV *
351_req_ranges4 (SV *ranges, NV interval, U32 payload, SV *id) 426_req_icmp_ping (SV *ranges, NV interval, U32 payload, SV *id)
352 CODE: 427 CODE:
353{ 428{
354 if (!SvROK (ranges) || SvTYPE (SvRV (ranges)) != SVt_PVAV) 429 if (!SvROK (ranges) || SvTYPE (SvRV (ranges)) != SVt_PVAV)
355 croak ("address ranges must be given as arrayref with lo, hi pairs"); 430 croak ("address ranges must be given as arrayref with lo, hi pairs");
356 431
… …
361 int i; 436 int i;
362 437
363 if (interval < MIN_INTERVAL) 438 if (interval < MIN_INTERVAL)
364 interval = MIN_INTERVAL; 439 interval = MIN_INTERVAL;
365 440
366 req->send_fd = icmp4_fd;
367 req->id = newSVsv (id); 441 req->id = newSVsv (id);
368 req->interval = interval; 442 req->interval = interval;
369 req->payload = payload; 443 req->payload = payload;
370 req->nranges = nranges; 444 req->nranges = nranges;
371 req->ranges = (RANGE *)malloc (nranges * sizeof (RANGE)); 445 req->ranges = (RANGE *)malloc (nranges * sizeof (RANGE));
… …
422 addr = htonl (SvUV (hi)); memcpy (sizeof (addr_t) - 4 + (char *)&r->hi, &addr, 4); 496 addr = htonl (SvUV (hi)); memcpy (sizeof (addr_t) - 4 + (char *)&r->hi, &addr, 4);
423 } 497 }
424 else 498 else
425 croak ("addresses in range must be strings with either 4 (IPv4) or 16 (IPv6) octets"); 499 croak ("addresses in range must be strings with either 4 (IPv4) or 16 (IPv6) octets");
426 500
427 if (r->family = AF_INET) 501 if (r->family == AF_INET)
428 { 502 {
429 if (icmp4_fd < 0) 503 if (icmp4_fd < 0)
430 croak ("Net::FPing: IPv4 ping support not available on this system"); 504 croak ("Net::FPing: IPv4 ping support not available on this system");
431 } 505 }
432 else 506 else
… …
469 CODE: 543 CODE:
470{ 544{
471 char buf [512]; 545 char buf [512];
472 struct sockaddr_in sa; 546 struct sockaddr_in sa;
473 socklen_t sl = sizeof (sa); 547 socklen_t sl = sizeof (sa);
474 AV *res_av = newAV (); 548 AV *res_av = av_len (cbs) < 0 ? 0 : (AV *)sv_2mortal ((SV *)newAV ());
475 SV *res_rv = sv_2mortal (newRV_noinc ((SV *)res_av)); 549 tstamp now = NOW ();
476 550
477 for (;;) 551 for (;;)
478 { 552 {
479 int len = recvfrom (icmp4_fd, buf, sizeof (buf), MSG_DONTWAIT | MSG_TRUNC, &sa, &sl); 553 int len = recvfrom (icmp4_fd, buf, sizeof (buf), MSG_DONTWAIT | MSG_TRUNC, &sa, &sl);
480 554
… …
485 559
486 int hdrlen = (iphdr->version_ihl & 15) * 4; 560 int hdrlen = (iphdr->version_ihl & 15) * 4;
487 int totlen = ntohs (iphdr->tot_len); 561 int totlen = ntohs (iphdr->tot_len);
488 562
489 // packet corrupt? 563 // packet corrupt?
564 if (!res_av
490 if (totlen > len 565 || totlen > len
491 || iphdr->protocol != IPPROTO_ICMP 566 || iphdr->protocol != IPPROTO_ICMP
492 || hdrlen < HDR_SIZE_IP4 || hdrlen + sizeof (PKT) != totlen) 567 || hdrlen < HDR_SIZE_IP4 || hdrlen + sizeof (PKT) != totlen)
493 continue; 568 continue;
494 569
495 PKT *pkt = (PKT *)(buf + hdrlen); 570 PKT *pkt = (PKT *)(buf + hdrlen);
496 571
497 if (pkt->id != (uint16_t)MAGIC 572 if (pkt->type != ICMP4_ECHO_REPLY
573 || pkt->id != (uint16_t) magic
498 || pkt->seq != (uint16_t)~MAGIC 574 || pkt->seq != (uint16_t)~magic
499 || pkt->type != ICMP4_ECHO
500 || !isnormal (pkt->stamp)) 575 || !isnormal (pkt->stamp))
501 continue; 576 continue;
502 577
503 // just drain for now 578 AV *av = newAV ();
504 //av_push 579 av_push (av, newSVpvn ((char *)&sa.sin_addr, 4));
580 av_push (av, newSVnv (now - pkt->stamp));
581 av_push (av, newSVuv (pkt->payload));
582
583 av_push (res_av, newRV_noinc ((SV *)av));
505 } 584 }
506 585
586 if (res_av)
507 // feed (res_av); 587 feed_reply (res_av);
508} 588}
509 589
510void 590void
511_recv_icmp6 (...) 591_recv_icmp6 (...)
512 CODE: 592 CODE:
513{ 593{
514 char buf [512];
515 struct sockaddr_in sa; 594 struct sockaddr_in6 sa;
516 socklen_t sl = sizeof (sa); 595 socklen_t sl = sizeof (sa);
517 AV *res_av = (AV *)sv_2mortal ((SV *)newAV ()); 596 AV *res_av = av_len (cbs) < 0 ? 0 : (AV *)sv_2mortal ((SV *)newAV ());
597 PKT pkt;
598 tstamp now = NOW ();
518 599
519 for (;;) 600 for (;;)
520 { 601 {
521 int len = recvfrom (icmp6_fd, buf, sizeof (buf), MSG_DONTWAIT | MSG_TRUNC, &sa, &sl); 602 int len = recvfrom (icmp6_fd, &pkt, sizeof (pkt), MSG_DONTWAIT | MSG_TRUNC, &sa, &sl);
522 603
523 if (len <= HDR_SIZE_IP6) 604 if (len != sizeof (PKT))
524 break; 605 break;
525 606
526 IP6HDR *iphdr = (IP6HDR *)buf; 607 if (!res_av
527 608 || pkt.type != ICMP6_ECHO_REPLY
528 int datalen = ntohs (iphdr->payload_len); 609 || pkt.id != (uint16_t) magic
529 610 || pkt.seq != (uint16_t)~magic
530 // packet corrupt? 611 || !isnormal (pkt.stamp))
531 if (HDR_SIZE_IP6 + datalen > len
532 || iphdr->nxt_hdr != IPPROTO_ICMPV6
533 || HDR_SIZE_IP6 + sizeof (PKT) != datalen)
534 continue; 612 continue;
535 613
536 PKT *pkt = (PKT *)(buf + HDR_SIZE_IP6); 614 AV *av = newAV ();
615 av_push (av, newSVpvn ((char *)&sa.sin6_addr, 16));
616 av_push (av, newSVnv (now - pkt.stamp));
617 av_push (av, newSVuv (pkt.payload));
537 618
538 if (pkt->id != (uint16_t)MAGIC 619 av_push (res_av, newRV_noinc ((SV *)av));
539 || pkt->seq != (uint16_t)~MAGIC
540 || pkt->type != ICMP6_ECHO
541 || !isnormal (pkt->stamp))
542 continue;
543
544 //fprintf (stderr, "ip6 echo received\n");
545 // just drain for now
546 //av_push
547 } 620 }
548 621
622 if (res_av)
549 // feed (res_av); 623 feed_reply (res_av);
550} 624}
551 625

Diff Legend

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