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.5 by root, Fri Jul 3 09:26:19 2009 UTC vs.
Revision 1.9 by root, Sun Jan 30 02:03:35 2011 UTC

1#if defined(__linux) 1#if defined(__linux) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__CYGWIN__)
2# define ENABLE_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 3#else
4# define ENABLE_IPV6 0 4# define ENABLE_IPV6 0
5#endif 5#endif
6 6
… …
8#include "perl.h" 8#include "perl.h"
9#include "XSUB.h" 9#include "XSUB.h"
10 10
11#include <pthread.h> 11#include <pthread.h>
12 12
13#include <math.h>
14#include <stdio.h> 13#include <stdio.h>
15#include <stdlib.h> 14#include <stdlib.h>
16#include <string.h> 15#include <string.h>
17 16
18#include <time.h> 17#include <time.h>
… …
30#include <arpa/inet.h> 29#include <arpa/inet.h>
31 30
32#ifdef __linux 31#ifdef __linux
33# include <linux/icmp.h> 32# include <linux/icmp.h>
34#endif 33#endif
35#if ENABLE_IPV6 34#if ENABLE_IPV6 && !defined (__CYGWIN__)
36# include <netinet/icmp6.h> 35# include <netinet/icmp6.h>
37#endif 36#endif
38 37
39#define ICMP4_ECHO 8 38#define ICMP4_ECHO 8
40#define ICMP4_ECHO_REPLY 0 39#define ICMP4_ECHO_REPLY 0
41#define ICMP6_ECHO 128 40#define ICMP6_ECHO 128
42#define ICMP6_ECHO_REPLY 129 41#define ICMP6_ECHO_REPLY 129
43 42
44#define DRAIN_INTERVAL .000001 // how long to wait when sendto returns ENOBUFS, in seconds 43#define DRAIN_INTERVAL 1e-6 // how long to wait when sendto returns ENOBUFS, in seconds
45#define MIN_INTERVAL .000001 // minimum packet send interval, in seconds 44#define MIN_INTERVAL 1e-6 // minimum packet send interval, in seconds
46 45
47#define HDR_SIZE_IP4 20 46#define HDR_SIZE_IP4 20
48#define HDR_SIZE_IP6 48 47#define HDR_SIZE_IP6 48
49 48
50//TODO: xread/xwrite for atomicity? we currently rely on the fact that the pip buffersize divides exactly by pointer sizes 49//TODO: xread/xwrite for atomicity? we currently rely on the fact that the pip buffersize divides exactly by pointer sizes
51 50
52typedef uint8_t addr_t[16]; 51typedef uint8_t addr_tt[16];
52
53/*****************************************************************************/
53 54
54typedef double tstamp; 55typedef double tstamp;
55 56
56static tstamp 57static tstamp
57NOW (void) 58NOW (void)
58{ 59{
59 struct timeval tv; 60 struct timeval tv;
61
60 gettimeofday (&tv, 0); 62 gettimeofday (&tv, 0);
63
61 return tv.tv_sec + tv.tv_usec * 0.000001; 64 return tv.tv_sec + tv.tv_usec * 1e-6;
62} 65}
63 66
67static void
68ssleep (tstamp wait)
69{
70#if defined (__SVR4) && defined (__sun)
71 struct timeval tv;
72
73 tv.tv_sec = wait;
74 tv.tv_usec = (wait - tv.tv_sec) * 1e6;
75
76 select (0, 0, 0, 0, &tv);
77#elif defined(_WIN32)
78 Sleep ((unsigned long)(delay * 1e3));
79#else
80 struct timespec ts;
81
82 ts.tv_sec = wait;
83 ts.tv_nsec = (wait - ts.tv_sec) * 1e9;
84
85 nanosleep (&ts, 0);
86#endif
87}
88
89/*****************************************************************************/
90
64typedef struct { 91typedef struct
92{
65 int family; 93 int family;
66 addr_t lo, hi; 94 addr_tt lo, hi;
67 double interval; 95 double interval;
68 tstamp next; 96 tstamp next;
69} RANGE; 97} RANGE;
70 98
71typedef struct { 99typedef struct
100{
72 SV *id; 101 SV *id;
73 double interval; 102 double interval;
74 int nranges; 103 int nranges;
75 RANGE *ranges; 104 RANGE *ranges;
76 uint32_t payload; 105 uint32_t payload;
77} REQ; 106} REQ;
78 107
79typedef struct { 108typedef struct
109{
80 uint8_t version_ihl; 110 uint8_t version_ihl;
81 uint8_t tos; 111 uint8_t tos;
82 uint16_t tot_len; 112 uint16_t tot_len;
83 113
84 uint16_t id; 114 uint16_t id;
… …
90 120
91 uint32_t src; 121 uint32_t src;
92 uint32_t dst; 122 uint32_t dst;
93} IP4HDR; 123} IP4HDR;
94 124
95typedef struct { 125typedef struct
126{
96 uint8_t version; 127 uint8_t version;
97 uint8_t x1, x2, x3; 128 uint8_t x1, x2, x3;
98 129
99 uint16_t payload_len; 130 uint16_t payload_len;
100 uint8_t nxt_hdr; 131 uint8_t nxt_hdr;
… …
102 133
103 uint8_t src[16]; 134 uint8_t src[16];
104 uint8_t dst[16]; 135 uint8_t dst[16];
105} IP6HDR; 136} IP6HDR;
106 137
138/*****************************************************************************/
139
107#define MAGIC 0xca4c 140#define MAGIC 0xca4c
108 141
109static uint16_t magic; 142static uint16_t magic;
110 143
111typedef struct { 144typedef struct
145{
112 uint8_t type, code; 146 uint8_t type, code;
113 uint16_t cksum; 147 uint16_t cksum;
114 uint16_t id, seq; 148 uint16_t id, seq;
115 uint32_t payload; 149 uint32_t payload;
116 tstamp stamp; // be careful when accessing this 150 uint32_t stamp_hi;
151 uint32_t stamp_lo;
117} PKT; 152} PKT;
153
154static int
155pkt_is_valid (PKT *pkt)
156{
157 return pkt->id == (uint16_t) magic
158 && pkt->seq == (uint16_t)~magic;
159}
160
161static void
162ts_to_pkt (PKT *pkt, tstamp ts)
163{
164 /* move 12 bits of seconds into the 32 bit fractional part */
165 /* leaving 20 bits subsecond resolution and 44 bits of integers */
166 /* (of which 32 are typically usable) */
167 ts *= 1. / 4096.;
168
169 pkt->stamp_hi = ts;
170 pkt->stamp_lo = (ts - pkt->stamp_hi) * 4294967296.;
171}
172
173static tstamp
174pkt_to_ts (PKT *pkt)
175{
176 return pkt->stamp_hi * 4096.
177 + pkt->stamp_lo * (4096. / 4294967296.);
178}
179
180/*****************************************************************************/
118 181
119static pthread_t pthrid; 182static pthread_t pthrid;
120static int thr_send[2]; // send to worker 183static int thr_send[2]; // send to worker
121static int thr_recv[2]; // receive from worker 184static int thr_recv[2]; // receive from worker
122 185
… …
126 189
127static uint16_t 190static uint16_t
128icmp_cksum (void *data, unsigned int len) 191icmp_cksum (void *data, unsigned int len)
129{ 192{
130 register int sum = 0; 193 register int sum = 0;
131 uint16_t *wp; 194 uint32_t *wp;
132 195
133 assert (~len & 1);
134
135 for (wp = (uint16_t *)data; len; wp++, len -= 2) 196 for (wp = (uint32_t *)data; len; wp++, len -= 4)
136 sum += *wp; 197 sum += (*wp & 0xffff) + (*wp >> 16);
137 198
138 sum = (sum >> 16) + (sum & 0xffff); /* add high 16 to low 16 */ 199 sum = (sum >> 16) + (sum & 0xffff); /* add high 16 to low 16 */
139 sum += sum >> 16; /* add carry */ 200 sum += sum >> 16; /* add carry */
140 201
141 return ~sum; 202 return ~sum;
142} 203}
143 204
144static void 205static void
145inc_addr (addr_t *addr) 206inc_addr (addr_tt *addr)
146{ 207{
147 int len = sizeof (addr_t) - 1; 208 int len = sizeof (addr_tt) - 1;
148 209
149 do 210 do
150 { 211 {
151 if ((*addr)[len] != 0xff) 212 if ((*addr)[len] != 0xff)
152 { 213 {
… …
182 for (;;) 243 for (;;)
183 { 244 {
184 REQ *req; 245 REQ *req;
185 int len = read (thr_send [0], &req, sizeof (req)); 246 int len = read (thr_send [0], &req, sizeof (req));
186 247
248 tstamp now = NOW ();
249 tstamp next = now;
250
187 if (!len) 251 if (!len)
188 pthread_exit (0); 252 pthread_exit (0);
189 else if (len != sizeof (req)) 253 else if (len != sizeof (req))
190 { 254 {
191 perror ("AnyEvent::FastPing: short reead or read error"); 255 perror ("AnyEvent::FastPing: short read or read error");
192 pthread_exit ((void *)-1); 256 pthread_exit ((void *)-1);
193 } 257 }
194 258
195 //TODO: bind to source address 259 //TODO: bind to source address
196 260
197 pkt.code = 0; 261 pkt.code = 0;
198 pkt.id = (uint16_t)magic; 262 pkt.id = (uint16_t)magic;
199 pkt.seq = (uint16_t)~magic; 263 pkt.seq = (uint16_t)~magic;
200 pkt.payload = req->payload; 264 pkt.payload = req->payload;
201
202 tstamp now = NOW ();
203 tstamp next = now;
204 265
205 { 266 {
206 int r; 267 int r;
207 for (r = req->nranges; r--; ) 268 for (r = req->nranges; r--; )
208 inc_addr (&req->ranges [r].hi); 269 inc_addr (&req->ranges [r].hi);
209 } 270 }
210 271
211 while (req->nranges) 272 while (req->nranges)
212 { 273 {
213 RANGE *range = req->ranges; 274 RANGE *range = req->ranges;
275 int n, k;
214 276
215 if (!memcmp (&range->lo, &range->hi, sizeof (addr_t))) 277 if (!memcmp (&range->lo, &range->hi, sizeof (addr_tt)))
216 req->ranges [0] = req->ranges [--req->nranges]; 278 req->ranges [0] = req->ranges [--req->nranges];
217 else 279 else
218 { 280 {
219 // ranges [0] is always the next range to ping 281 // ranges [0] is always the next range to ping
220 tstamp wait = range->next - now; 282 tstamp wait = range->next - now;
… …
228 else if (range) 290 else if (range)
229 next = range->next; 291 next = range->next;
230 } 292 }
231 293
232 if (wait > 0.) 294 if (wait > 0.)
233 {
234 struct timespec ts;
235
236 ts.tv_sec = wait;
237 ts.tv_nsec = (wait - ts.tv_sec) * 1000000000.;
238
239 nanosleep (&ts, 0); 295 ssleep (wait);
240 }
241 296
242 now = NOW (); 297 now = NOW ();
243 298
244 pkt.stamp = now; 299 ts_to_pkt (&pkt, now);
245 pkt.cksum = 0; 300 pkt.cksum = 0;
246 301
247 if (range->family == AF_INET) 302 if (range->family == AF_INET)
248 { 303 {
249 pkt.type = ICMP4_ECHO; 304 pkt.type = ICMP4_ECHO;
250 pkt.cksum = icmp_cksum (&pkt, sizeof (pkt)); 305 pkt.cksum = icmp_cksum (&pkt, sizeof (pkt));
251 306
252 memcpy (&sa4.sin_addr, 307 memcpy (&sa4.sin_addr,
253 sizeof (addr_t) - sizeof (sa4.sin_addr) + (char *)&range->lo, 308 sizeof (addr_tt) - sizeof (sa4.sin_addr) + (char *)&range->lo,
254 sizeof (sa4.sin_addr)); 309 sizeof (sa4.sin_addr));
255 310
256 if (sendto (icmp4_fd, &pkt, sizeof (pkt), 0, (struct sockaddr *)&sa4, sizeof (sa4)) > 0) 311 if (sendto (icmp4_fd, &pkt, sizeof (pkt), 0, (struct sockaddr *)&sa4, sizeof (sa4)) > 0)
257 errno = 0; 312 errno = 0;
258 } 313 }
… …
260 { 315 {
261#if ENABLE_IPV6 316#if ENABLE_IPV6
262 pkt.type = ICMP6_ECHO; 317 pkt.type = ICMP6_ECHO;
263 318
264 memcpy (&sa6.sin6_addr, 319 memcpy (&sa6.sin6_addr,
265 sizeof (addr_t) - sizeof (sa6.sin6_addr) + (char *)&range->lo, 320 sizeof (addr_tt) - sizeof (sa6.sin6_addr) + (char *)&range->lo,
266 sizeof (sa6.sin6_addr)); 321 sizeof (sa6.sin6_addr));
267 322
268 if (sendto (icmp6_fd, &pkt, sizeof (pkt), 0, (struct sockaddr *)&sa6, sizeof (sa6)) > 0) 323 if (sendto (icmp6_fd, &pkt, sizeof (pkt), 0, (struct sockaddr *)&sa6, sizeof (sa6)) > 0)
269 errno = 0; 324 errno = 0;
270#endif 325#endif
271 } 326 }
272 327
273 if (errno == ENOBUFS) 328 if (errno == ENOBUFS)
274 { 329 ssleep (DRAIN_INTERVAL);
275 struct timespec ts;
276
277 ts.tv_sec = 0;
278 ts.tv_nsec = DRAIN_INTERVAL * 1000000000;
279
280 nanosleep (&ts, 0);
281 }
282 else 330 else
283 { 331 {
284 inc_addr (&range->lo); 332 inc_addr (&range->lo);
285 333
286 range->next = next; 334 range->next = next;
… …
289 337
290 next += req->interval; 338 next += req->interval;
291 } 339 }
292 340
293 // make a downheap operation 341 // make a downheap operation
294 int k = 0;
295 int n = 0;
296 for (;;) 342 for (n = k = 0; ; )
297 { 343 {
344 int j = k * 2 + 1;
345
298 ++n; 346 ++n;
299 int j = k * 2 + 1;
300 347
301 if (j >= req->nranges) 348 if (j >= req->nranges)
302 break; 349 break;
303 else if (j < req->nranges - 1) 350 else if (j < req->nranges - 1)
304 if (req->ranges [j].next > req->ranges [j + 1].next) 351 if (req->ranges [j].next > req->ranges [j + 1].next)
305 ++j; 352 ++j;
306 353
307 if (req->ranges [j].next >= req->ranges [k].next) 354 if (req->ranges [j].next >= req->ranges [k].next)
308 break; 355 break;
309 356
357 {
310 RANGE temp = req->ranges [k]; 358 RANGE temp = req->ranges [k];
311 req->ranges [k] = req->ranges [j]; 359 req->ranges [k] = req->ranges [j];
312 req->ranges [j] = temp; 360 req->ranges [j] = temp;
361 }
313 362
314 k = j; 363 k = j;
315 } 364 }
316 } 365 }
317 366
… …
322} 371}
323 372
324static void 373static void
325feed_reply (AV *res_av) 374feed_reply (AV *res_av)
326{ 375{
327 if (av_len (res_av) < 0)
328 return;
329
330 dSP; 376 dSP;
331 SV *res = sv_2mortal (newRV_inc ((SV *)res_av)); 377 SV *res = sv_2mortal (newRV_inc ((SV *)res_av));
332 int i; 378 int i;
379
380 if (av_len (res_av) < 0)
381 return;
333 382
334 ENTER; 383 ENTER;
335 SAVETMPS; 384 SAVETMPS;
336 385
337 for (i = av_len (cbs) + 1; i--; ) 386 for (i = av_len (cbs) + 1; i--; )
… …
412 HV *stash = gv_stashpv ("AnyEvent::FastPing", 1); 461 HV *stash = gv_stashpv ("AnyEvent::FastPing", 1);
413 462
414 cbs = get_av ("AnyEvent::FastPing::CB", 1); 463 cbs = get_av ("AnyEvent::FastPing::CB", 1);
415 magic = getpid () ^ MAGIC; 464 magic = getpid () ^ MAGIC;
416 465
466 if (sizeof (PKT) & 3)
467 croak ("size of PKT structure is not a multiple of 4");
468
417 boot (); 469 boot ();
418 470
419 newCONSTSUB (stash, "ipv4_supported", newSViv (icmp4_fd >= 0)); 471 newCONSTSUB (stash, "ipv4_supported", newSViv (icmp4_fd >= 0));
420 newCONSTSUB (stash, "ipv6_supported", newSViv (icmp6_fd >= 0)); 472 newCONSTSUB (stash, "ipv6_supported", newSViv (icmp6_fd >= 0));
421 473
… …
427 479
428SV * 480SV *
429_req_icmp_ping (SV *ranges, NV interval, U32 payload, SV *id) 481_req_icmp_ping (SV *ranges, NV interval, U32 payload, SV *id)
430 CODE: 482 CODE:
431{ 483{
484 AV *rav;
485 int nranges, i;
486 REQ *req;
487
432 if (!SvROK (ranges) || SvTYPE (SvRV (ranges)) != SVt_PVAV) 488 if (!SvROK (ranges) || SvTYPE (SvRV (ranges)) != SVt_PVAV)
433 croak ("address ranges must be given as arrayref with lo, hi pairs"); 489 croak ("address ranges must be given as arrayref with lo, hi pairs");
434 490
435 AV *rav = (AV *)SvRV (ranges); 491 rav = (AV *)SvRV (ranges);
436 int nranges = av_len (rav) + 1; 492 nranges = av_len (rav) + 1;
437 493
438 REQ *req = malloc (sizeof (REQ)); 494 req = malloc (sizeof (REQ));
439 int i;
440 495
441 if (interval < MIN_INTERVAL) 496 if (interval < MIN_INTERVAL)
442 interval = MIN_INTERVAL; 497 interval = MIN_INTERVAL;
443 498
444 req->id = newSVsv (id); 499 req->id = newSVsv (id);
… …
448 req->ranges = (RANGE *)malloc (nranges * sizeof (RANGE)); 503 req->ranges = (RANGE *)malloc (nranges * sizeof (RANGE));
449 504
450 while (nranges--) 505 while (nranges--)
451 { 506 {
452 SV *sv = *av_fetch (rav, nranges, 1); 507 SV *sv = *av_fetch (rav, nranges, 1);
508 SV *lo, *hi;
509 AV *av;
510 RANGE *r;
453 511
454 if (!SvROK (sv) || SvTYPE (SvRV (sv)) != SVt_PVAV) 512 if (!SvROK (sv) || SvTYPE (SvRV (sv)) != SVt_PVAV)
455 croak ("address range must be given as arrayref with lo, hi, interval arrayrefs"); 513 croak ("address range must be given as arrayref with lo, hi, interval arrayrefs");
456 514
457 AV *av = (AV *)SvRV (sv); 515 av = (AV *)SvRV (sv);
458 RANGE *r = req->ranges + nranges; 516 r = req->ranges + nranges;
459 517
460 SV *lo = *av_fetch (av, 0, 1); 518 lo = *av_fetch (av, 0, 1);
461 SV *hi = *av_fetch (av, 1, 1); 519 hi = *av_fetch (av, 1, 1);
462 520
463 sv_utf8_downgrade (lo, 0); 521 sv_utf8_downgrade (lo, 0);
464 sv_utf8_downgrade (hi, 0); 522 sv_utf8_downgrade (hi, 0);
465 523
466 memset (&r->lo, 0, sizeof (addr_t)); 524 memset (&r->lo, 0, sizeof (addr_tt));
467 memset (&r->hi, 0, sizeof (addr_t)); 525 memset (&r->hi, 0, sizeof (addr_tt));
468 526
469 if (SvPOKp (lo) && SvPOKp (hi)) 527 if (SvPOKp (lo) && SvPOKp (hi))
470 { 528 {
471 if (SvCUR (lo) != SvCUR (hi)) 529 if (SvCUR (lo) != SvCUR (hi))
472 croak ("all addresses in range must be of the same size (either 4 or 16 bytes)"); 530 croak ("all addresses in range must be of the same size (either 4 or 16 bytes)");
473 531
474 if (SvCUR (lo) == 4) 532 if (SvCUR (lo) == 4)
475 { 533 {
476 r->family = AF_INET; 534 r->family = AF_INET;
477 memcpy (sizeof (addr_t) - 4 + (char *)&r->lo, SvPVX (lo), 4); 535 memcpy (sizeof (addr_tt) - 4 + (char *)&r->lo, SvPVX (lo), 4);
478 memcpy (sizeof (addr_t) - 4 + (char *)&r->hi, SvPVX (hi), 4); 536 memcpy (sizeof (addr_tt) - 4 + (char *)&r->hi, SvPVX (hi), 4);
479 } 537 }
480 else if (SvCUR (lo) == 16) 538 else if (SvCUR (lo) == 16)
481 { 539 {
482#if ENABLE_IPV6 540#if ENABLE_IPV6
483 r->family = AF_INET6; 541 r->family = AF_INET6;
484 memcpy (&r->lo, SvPVX (lo), sizeof (addr_t)); 542 memcpy (&r->lo, SvPVX (lo), sizeof (addr_tt));
485 memcpy (&r->hi, SvPVX (hi), sizeof (addr_t)); 543 memcpy (&r->hi, SvPVX (hi), sizeof (addr_tt));
486#else 544#else
487 croak ("IPv6 not supported in this configuration"); 545 croak ("IPv6 not supported in this configuration");
488#endif 546#endif
489 } 547 }
490 else 548 else
491 croak ("addresses in range must be either 4 (IPv4) or 16 (IPv6) bytes in length"); 549 croak ("addresses in range must be either 4 (IPv4) or 16 (IPv6) bytes in length");
492 } 550 }
493 else if (SvIOK (lo) && SvIOK (hi)) 551 else if (SvIOK (lo) && SvIOK (hi))
494 { 552 {
553 uint32_t addr;
554
495 r->family = AF_INET; 555 r->family = AF_INET;
496 556
497 uint32_t addr;
498 addr = htonl (SvUV (lo)); memcpy (sizeof (addr_t) - 4 + (char *)&r->lo, &addr, 4); 557 addr = htonl (SvUV (lo)); memcpy (sizeof (addr_tt) - 4 + (char *)&r->lo, &addr, 4);
499 addr = htonl (SvUV (hi)); memcpy (sizeof (addr_t) - 4 + (char *)&r->hi, &addr, 4); 558 addr = htonl (SvUV (hi)); memcpy (sizeof (addr_tt) - 4 + (char *)&r->hi, &addr, 4);
500 } 559 }
501 else 560 else
502 croak ("addresses in range must be strings with either 4 (IPv4) or 16 (IPv6) octets"); 561 croak ("addresses in range must be strings with either 4 (IPv4) or 16 (IPv6) octets");
503 562
504 if (r->family == AF_INET) 563 if (r->family == AF_INET)
… …
549 struct sockaddr_in sa; 608 struct sockaddr_in sa;
550 socklen_t sl = sizeof (sa); 609 socklen_t sl = sizeof (sa);
551 AV *res_av = av_len (cbs) < 0 ? 0 : (AV *)sv_2mortal ((SV *)newAV ()); 610 AV *res_av = av_len (cbs) < 0 ? 0 : (AV *)sv_2mortal ((SV *)newAV ());
552 tstamp now = NOW (); 611 tstamp now = NOW ();
553 612
613 if (!res_av)
614 XSRETURN_UNDEF;
615
554 for (;;) 616 for (;;)
555 { 617 {
618 IP4HDR *iphdr = (IP4HDR *)buf;
556 int len = recvfrom (icmp4_fd, buf, sizeof (buf), MSG_TRUNC, (struct sockaddr *)&sa, &sl); 619 int len = recvfrom (icmp4_fd, buf, sizeof (buf), MSG_TRUNC, (struct sockaddr *)&sa, &sl);
620 int hdrlen, totlen;
621 PKT *pkt;
557 622
558 if (len <= HDR_SIZE_IP4) 623 if (len <= HDR_SIZE_IP4)
559 break; 624 break;
560 625
561 IP4HDR *iphdr = (IP4HDR *)buf;
562
563 int hdrlen = (iphdr->version_ihl & 15) * 4; 626 hdrlen = (iphdr->version_ihl & 15) * 4;
564 int totlen = ntohs (iphdr->tot_len); 627 totlen = ntohs (iphdr->tot_len);
565 628
566 // packet corrupt? 629 // packet corrupt?
567 if (!res_av
568 || totlen > len 630 if (totlen > len
569 || iphdr->protocol != IPPROTO_ICMP 631 || iphdr->protocol != IPPROTO_ICMP
570 || hdrlen < HDR_SIZE_IP4 || hdrlen + sizeof (PKT) != totlen) 632 || hdrlen < HDR_SIZE_IP4 || hdrlen + sizeof (PKT) != totlen)
571 continue; 633 continue;
572 634
573 PKT *pkt = (PKT *)(buf + hdrlen); 635 pkt = (PKT *)(buf + hdrlen);
574 636
575 if (pkt->type != ICMP4_ECHO_REPLY 637 if (pkt->type != ICMP4_ECHO_REPLY || !pkt_is_valid (pkt))
576 || pkt->id != (uint16_t) magic
577 || pkt->seq != (uint16_t)~magic
578 || !isnormal (pkt->stamp))
579 continue; 638 continue;
580 639
640 {
581 AV *av = newAV (); 641 AV *av = newAV ();
582 av_push (av, newSVpvn ((char *)&sa.sin_addr, 4)); 642 av_push (av, newSVpvn ((char *)&sa.sin_addr, 4));
583 av_push (av, newSVnv (now - pkt->stamp)); 643 av_push (av, newSVnv (now - pkt_to_ts (pkt)));
584 av_push (av, newSVuv (pkt->payload)); 644 av_push (av, newSVuv (pkt->payload));
585 645
586 av_push (res_av, newRV_noinc ((SV *)av)); 646 av_push (res_av, newRV_noinc ((SV *)av));
647 }
587 } 648 }
588 649
589 if (res_av)
590 feed_reply (res_av); 650 feed_reply (res_av);
591} 651}
592 652
593void 653void
594_recv_icmp6 (...) 654_recv_icmp6 (...)
595 CODE: 655 CODE:
… …
598 socklen_t sl = sizeof (sa); 658 socklen_t sl = sizeof (sa);
599 AV *res_av = av_len (cbs) < 0 ? 0 : (AV *)sv_2mortal ((SV *)newAV ()); 659 AV *res_av = av_len (cbs) < 0 ? 0 : (AV *)sv_2mortal ((SV *)newAV ());
600 PKT pkt; 660 PKT pkt;
601 tstamp now = NOW (); 661 tstamp now = NOW ();
602 662
663 if (!res_av)
664 XSRETURN_UNDEF;
665
603 for (;;) 666 for (;;)
604 { 667 {
605 int len = recvfrom (icmp6_fd, &pkt, sizeof (pkt), MSG_TRUNC, (struct sockaddr *)&sa, &sl); 668 int len = recvfrom (icmp6_fd, &pkt, sizeof (pkt), MSG_TRUNC, (struct sockaddr *)&sa, &sl);
606 669
607 if (len != sizeof (PKT)) 670 if (len != sizeof (PKT))
608 break; 671 break;
609 672
610 if (!res_av 673 if (pkt.type != ICMP6_ECHO_REPLY || !pkt_is_valid (&pkt))
611 || pkt.type != ICMP6_ECHO_REPLY
612 || pkt.id != (uint16_t) magic
613 || pkt.seq != (uint16_t)~magic
614 || !isnormal (pkt.stamp))
615 continue; 674 continue;
616 675
676 {
617 AV *av = newAV (); 677 AV *av = newAV ();
618 av_push (av, newSVpvn ((char *)&sa.sin6_addr, 16)); 678 av_push (av, newSVpvn ((char *)&sa.sin6_addr, 16));
619 av_push (av, newSVnv (now - pkt.stamp)); 679 av_push (av, newSVnv (now - pkt_to_ts (&pkt)));
620 av_push (av, newSVuv (pkt.payload)); 680 av_push (av, newSVuv (pkt.payload));
621 681
622 av_push (res_av, newRV_noinc ((SV *)av)); 682 av_push (res_av, newRV_noinc ((SV *)av));
683 }
623 } 684 }
624 685
625 if (res_av)
626 feed_reply (res_av); 686 feed_reply (res_av);
627} 687}
628 688

Diff Legend

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