[ViewVC] Diff of: cvs/AnyEvent-FastPing/FastPing.xs

Comparing AnyEvent-FastPing/FastPing.xs (file contents):
Revision 1.9 by root, Sun Jan 30 02:03:35 2011 UTC vs.
Revision 1.10 by root, Mon Jan 31 05:35:48 2011 UTC

…		…
48		48
49	//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
50		50
51	typedef uint8_t addr_tt[16];	51	typedef uint8_t addr_tt[16];
52		52
		53	static int thr_res[2]; // receive from worker(s)
		54	static int icmp4_fd = -1, icmp6_fd = -1;
		55
53	/*****************************************************************************/	56	/*****************************************************************************/
54		57
55	typedef double tstamp;	58	typedef double tstamp;
56		59
57	static tstamp	60	static tstamp
…		…
88		91
89	/*****************************************************************************/	92	/*****************************************************************************/
90		93
91	typedef struct	94	typedef struct
92	{	95	{
93	int family;
94	addr_tt lo, hi;
95	double interval;
96	tstamp next;
97	} RANGE;
98
99	typedef struct
100	{
101	SV *id;
102	double interval;
103	int nranges;
104	RANGE *ranges;
105	uint32_t payload;
106	} REQ;
107
108	typedef struct
109	{
110	uint8_t version_ihl;	96	uint8_t version_ihl;
111	uint8_t tos;	97	uint8_t tos;
112	uint16_t tot_len;	98	uint16_t tot_len;
113		99
114	uint16_t id;	100	uint16_t id;
…		…
120		106
121	uint32_t src;	107	uint32_t src;
122	uint32_t dst;	108	uint32_t dst;
123	} IP4HDR;	109	} IP4HDR;
124		110
		111	#if 0
125	typedef struct	112	typedef struct
126	{	113	{
127	uint8_t version;	114	uint8_t version;
128	uint8_t x1, x2, x3;	115	uint8_t x1, x2, x3;
129		116
…		…
132	uint8_t hop_limit;	119	uint8_t hop_limit;
133		120
134	uint8_t src[16];	121	uint8_t src[16];
135	uint8_t dst[16];	122	uint8_t dst[16];
136	} IP6HDR;	123	} IP6HDR;
		124	#endif
137		125
138	/*****************************************************************************/	126	/*****************************************************************************/
139		127
140	#define MAGIC 0xca4c	128	typedef struct
		129	{
		130	tstamp next;
		131	double interval;
		132	int addrlen;
		133	addr_tt lo, hi;
		134	void *items;
		135	} RANGE;
141		136
		137	typedef struct
		138	{
		139	RANGE **ranges;
		140	int rangecnt, rangemax;
		141
		142	tstamp interval;
		143	tstamp maxrtt;
142	static uint16_t magic;	144	uint16_t magic1;
		145	uint16_t magic2;
		146	uint16_t magic3;
		147
		148	int id;
		149
		150	AV recvq; / receive queue */
		151	int nextrecv;
		152	SV *recvcb;
		153
		154	pthread_t thrid;
		155	int running;
		156	} PINGER;
		157
		158	static PINGER **pingers;
		159	static int pingerfree; / freelist next */
		160	static int pingercnt;
		161	static int pingermax;
		162	static int firstfree = -1;
		163	static int firstrecv = -1;
		164
		165	/*****************************************************************************/
143		166
144	typedef struct	167	typedef struct
145	{	168	{
146	uint8_t type, code;	169	uint8_t type, code;
147	uint16_t cksum;	170	uint16_t cksum;
148	uint16_t id, seq;	171	uint16_t id, seq;
149	uint32_t payload;	172	uint16_t pinger;
		173	uint16_t magic;
150	uint32_t stamp_hi;	174	uint32_t stamp_hi;
151	uint32_t stamp_lo;	175	uint32_t stamp_lo;
152	} PKT;	176	} PKT;
153		177
154	static int	178	static int
155	pkt_is_valid (PKT *pkt)	179	pkt_is_valid_for (PKT pkt, PINGER pinger)
156	{	180	{
157	return pkt->id == (uint16_t) magic	181	return pkt->id == pinger->magic1
158	&& pkt->seq == (uint16_t)~magic;	182	&& pkt->seq == pinger->magic2
		183	&& pkt->magic == pinger->magic3;
159	}	184	}
160		185
161	static void	186	static void
162	ts_to_pkt (PKT *pkt, tstamp ts)	187	ts_to_pkt (PKT *pkt, tstamp ts)
163	{	188	{
…		…
175	{	200	{
176	return pkt->stamp_hi * 4096.	201	return pkt->stamp_hi * 4096.
177	+ pkt->stamp_lo * (4096. / 4294967296.);	202	+ pkt->stamp_lo * (4096. / 4294967296.);
178	}	203	}
179		204
180	/*****************************************************************************/	205	static void
181		206	pkt_cksum (PKT *pkt)
182	static pthread_t pthrid;
183	static int thr_send[2]; // send to worker
184	static int thr_recv[2]; // receive from worker
185
186	static int icmp4_fd, icmp6_fd;
187
188	static AV *cbs;
189
190	static uint16_t
191	icmp_cksum (void *data, unsigned int len)
192	{	207	{
193	register int sum = 0;	208	uint_fast32_t sum = -pkt->cksum;
194	uint32_t *wp;	209	uint32_t wp = (uint32_t )pkt;
		210	int len = sizeof (*pkt) / 4;
195		211
196	for (wp = (uint32_t *)data; len; wp++, len -= 4)	212	do
		213	{
		214	uint_fast32_t w = (volatile uint32_t )wp++;
197	sum += (wp & 0xffff) + (wp >> 16);	215	sum += (w & 0xffff) + (w >> 16);
		216	}
		217	while (len--);
198		218
199	sum = (sum >> 16) + (sum & 0xffff); /* add high 16 to low 16 */	219	sum = (sum >> 16) + (sum & 0xffff); /* add high 16 to low 16 */
200	sum += sum >> 16; /* add carry */	220	sum += sum >> 16; /* add carry */
201		221
202	return ~sum;	222	pkt->cksum = ~sum;
		223	}
		224
		225	/*****************************************************************************/
		226
		227	static void
		228	range_free (RANGE *self)
		229	{
		230	free (self);
203	}	231	}
204		232
205	static void	233	static void
206	inc_addr (addr_tt *addr)	234	inc_addr (addr_tt *addr)
207	{	235	{
208	int len = sizeof (addr_tt) - 1;	236	int len = sizeof (addr_tt) - 1;
209		237
210	do	238	while (!++(*addr)[len])
		239	--len;
		240	}
		241
		242	/*****************************************************************************/
		243
		244	/* like sendto, but retries on failure */
		245	static void
		246	xsendto (int fd, void buf, size_t len, int flags, void sa, int salen)
		247	{
		248	tstamp wait = 0;
		249
		250	while (sendto (fd, buf, len, flags, sa, salen) < 0 && errno == ENOBUFS)
		251	ssleep (wait += DRAIN_INTERVAL);
		252	}
		253
		254	static void
		255	send_ping (PKT pkt, addr_tt addr, int addr_len)
		256	{
		257	pkt->cksum = 0;
		258
		259	if (addr_len == 4)
		260	{
		261	struct sockaddr_in sa;
		262
		263	pkt->type = ICMP4_ECHO;
		264	pkt_cksum (pkt);
		265
		266	sa.sin_family = AF_INET;
		267	sa.sin_port = 0;
		268
		269	memcpy (&sa.sin_addr,
		270	sizeof (addr_tt) - sizeof (sa.sin_addr) + (char *)addr,
		271	sizeof (sa.sin_addr));
		272
		273	xsendto (icmp4_fd, pkt, sizeof (*pkt), 0, &sa, sizeof (sa));
		274	}
		275	else
		276	{
		277	#if ENABLE_IPV6
		278	struct sockaddr_in6 sa;
		279
		280	pkt->type = ICMP6_ECHO;
		281
		282	sa.sin6_family = AF_INET6;
		283	sa.sin6_port = 0;
		284	sa.sin6_flowinfo = 0;
		285	sa.sin6_scope_id = 0;
		286
		287	memcpy (&sa.sin6_addr,
		288	sizeof (addr_tt) - sizeof (sa.sin6_addr) + (char *)addr,
		289	sizeof (sa.sin6_addr));
		290
		291	xsendto (icmp6_fd, &pkt, sizeof (pkt), 0, &sa, sizeof (sa));
		292	#endif
		293	}
		294	}
		295
		296	static void
		297	downheap (PINGER *self)
		298	{
		299	RANGE elem = self->ranges [0]; / always exists */
		300	int Nm1 = self->rangecnt - 1;
		301	int j;
		302	int k;
		303
		304	for (k = 0; ; )
		305	{
		306	int j = k * 2 + 1;
		307
		308	if (j > Nm1)
		309	break;
		310
		311	if (j < Nm1
		312	&& self->ranges [j]->next > self->ranges [j + 1]->next)
		313	++j;
		314
		315	if (self->ranges [j]->next >= elem->next)
		316	break;
		317
		318	self->ranges [k] = self->ranges [j];
		319
		320	k = j;
		321	}
		322
		323	self->ranges [k] = elem;
		324	}
		325
		326	static void
		327	upheap (PINGER *self, int k)
		328	{
		329	RANGE *elem = self->ranges [k];
		330
		331	while (k)
		332	{
		333	int j = (k - 1) >> 1;
		334
		335	if (self->ranges [j]->next <= elem->next)
		336	break;
		337
		338	self->ranges [k] = self->ranges [j];
		339
		340	k = j;
		341	}
		342
		343	self->ranges [k] = elem;
		344	}
		345
		346	static void *
		347	ping_proc (void *self_)
		348	{
		349	PINGER self = (PINGER )self_;
		350	PKT pkt;
		351
		352	memset (&pkt, 0, sizeof (pkt));
		353
		354	tstamp now = NOW ();
		355	tstamp next = now;
		356
		357	pkt.code = 0;
		358	pkt.id = self->magic1;
		359	pkt.seq = self->magic2;
		360	pkt.magic = self->magic3;
		361	pkt.pinger = self->id;
		362
		363	while (self->rangecnt)
		364	{
		365	RANGE *range = self->ranges [0];
		366	int n, k;
		367
		368	// ranges [0] is always the next range to ping
		369	tstamp wait = range->next - now;
		370
		371	// compare with the global frequency limit
211	{	372	{
212	if ((*addr)[len] != 0xff)	373	tstamp diff = next - now;
		374
		375	if (wait < diff)
		376	wait = diff;
		377	else if (range)
		378	next = range->next;
		379	}
		380
		381	if (wait > 0.)
		382	ssleep (wait);
		383
		384	now = NOW ();
		385
		386	ts_to_pkt (&pkt, now);
		387
		388	send_ping (&pkt, &range->lo, range->addrlen);
		389
		390	if (!memcmp (&range->lo, &range->hi, sizeof (addr_tt)))
213	{	391	{
214	++(*addr)[len];	392	self->ranges [0] = self->ranges [--self->rangecnt];
215	break;	393	range_free (range);
216	}	394	}
217		395	else
218	(*addr)[len] = 0;
219	}
220	while (len--);
221	}
222
223	static void *
224	ping_proc (void *unused)
225	{
226	PKT pkt;
227	struct sockaddr_in sa4;
228	#if ENABLE_IPV6
229	struct sockaddr_in6 sa6;
230	#endif
231
232	memset (&pkt, 0, sizeof (pkt));
233
234	memset (&sa4, 0, sizeof (sa4));
235	sa4.sin_family = AF_INET;
236	sa4.sin_port = 0;
237	#if ENABLE_IPV6
238	memset (&sa6, 0, sizeof (sa6));
239	sa6.sin6_family = AF_INET6;
240	sa6.sin6_port = 0;
241	#endif
242
243	for (;;)
244	{
245	REQ *req;
246	int len = read (thr_send [0], &req, sizeof (req));
247
248	tstamp now = NOW ();
249	tstamp next = now;
250
251	if (!len)
252	pthread_exit (0);
253	else if (len != sizeof (req))
254	{	396	{
255	perror ("AnyEvent::FastPing: short read or read error");	397	inc_addr (&range->lo);
256	pthread_exit ((void *)-1);	398
		399	range->next = next;
		400	range->next += range->interval;
		401
		402	downheap (self);
257	}	403	}
258		404
259	//TODO: bind to source address	405	next += self->interval;
260
261	pkt.code = 0;
262	pkt.id = (uint16_t)magic;
263	pkt.seq = (uint16_t)~magic;
264	pkt.payload = req->payload;
265
266	{
267	int r;
268	for (r = req->nranges; r--; )
269	inc_addr (&req->ranges [r].hi);
270	}	406	}
271		407
272	while (req->nranges)	408	ssleep (self->maxrtt);
		409
		410	{
		411	uint16_t id = self->id;
		412
		413	write (thr_res [1], &id, sizeof (id));
		414	}
		415
		416	return 0;
		417	}
		418
		419	/*****************************************************************************/
		420
		421	static void
		422	pinger_start (PINGER *self)
		423	{
		424	sigset_t fullsigset, oldsigset;
		425	pthread_attr_t attr;
		426
		427	if (self->running)
		428	return;
		429
		430	sigfillset (&fullsigset);
		431
		432	pthread_attr_init (&attr);
		433	pthread_attr_setstacksize (&attr, PTHREAD_STACK_MIN < sizeof (long) * 2048 ? sizeof (long) * 2048 : PTHREAD_STACK_MIN);
		434
		435	pthread_sigmask (SIG_SETMASK, &fullsigset, &oldsigset);
		436
		437	if (pthread_create (&self->thrid, &attr, ping_proc, (void *)self))
		438	croak ("AnyEvent::FastPing: unable to create pinger thread");
		439
		440	pthread_sigmask (SIG_SETMASK, &oldsigset, 0);
		441
		442	self->running = 1;
		443	}
		444
		445	static void
		446	pinger_stop (PINGER *self)
		447	{
		448	if (!self->running)
		449	return;
		450
		451	self->running = 0;
		452	pthread_cancel (self->thrid);
		453	pthread_join (self->thrid, 0);
		454	}
		455
		456	static void
		457	pinger_init (PINGER *self)
		458	{
		459	memset (self, 0, sizeof (PINGER));
		460
		461	if (firstfree >= 0)
		462	{
		463	self->id = firstfree;
		464	firstfree = pingerfree [firstfree];
		465	}
		466	else if (pingercnt == 0xffff)
		467	croak ("unable to create more than 65536 AnyEvent::FastPing objects");
		468	else
		469	{
		470	if (pingercnt == pingermax)
273	{	471	{
274	RANGE *range = req->ranges;	472	pingermax = pingermax * 2 + 16;
275	int n, k;	473	pingers = realloc (pingers , sizeof (pingers [0]) * pingermax);
276		474	pingerfree = realloc (pingerfree, sizeof (pingerfree [0]) * pingermax);
277	if (!memcmp (&range->lo, &range->hi, sizeof (addr_tt)))
278	req->ranges [0] = req->ranges [--req->nranges];
279	else
280	{
281	// ranges [0] is always the next range to ping
282	tstamp wait = range->next - now;
283
284	// compare with the global frequency limit
285	{
286	tstamp diff = next - now;
287
288	if (wait < diff)
289	wait = diff;
290	else if (range)
291	next = range->next;
292	}
293
294	if (wait > 0.)
295	ssleep (wait);
296
297	now = NOW ();
298
299	ts_to_pkt (&pkt, now);
300	pkt.cksum = 0;
301
302	if (range->family == AF_INET)
303	{
304	pkt.type = ICMP4_ECHO;
305	pkt.cksum = icmp_cksum (&pkt, sizeof (pkt));
306
307	memcpy (&sa4.sin_addr,
308	sizeof (addr_tt) - sizeof (sa4.sin_addr) + (char *)&range->lo,
309	sizeof (sa4.sin_addr));
310
311	if (sendto (icmp4_fd, &pkt, sizeof (pkt), 0, (struct sockaddr *)&sa4, sizeof (sa4)) > 0)
312	errno = 0;
313	}
314	else
315	{
316	#if ENABLE_IPV6
317	pkt.type = ICMP6_ECHO;
318
319	memcpy (&sa6.sin6_addr,
320	sizeof (addr_tt) - sizeof (sa6.sin6_addr) + (char *)&range->lo,
321	sizeof (sa6.sin6_addr));
322
323	if (sendto (icmp6_fd, &pkt, sizeof (pkt), 0, (struct sockaddr *)&sa6, sizeof (sa6)) > 0)
324	errno = 0;
325	#endif
326	}
327
328	if (errno == ENOBUFS)
329	ssleep (DRAIN_INTERVAL);
330	else
331	{
332	inc_addr (&range->lo);
333
334	range->next = next;
335	range->next += range->interval;
336	}
337
338	next += req->interval;
339	}
340
341	// make a downheap operation
342	for (n = k = 0; ; )
343	{
344	int j = k * 2 + 1;
345
346	++n;
347
348	if (j >= req->nranges)
349	break;
350	else if (j < req->nranges - 1)
351	if (req->ranges [j].next > req->ranges [j + 1].next)
352	++j;
353
354	if (req->ranges [j].next >= req->ranges [k].next)
355	break;
356
357	{
358	RANGE temp = req->ranges [k];
359	req->ranges [k] = req->ranges [j];
360	req->ranges [j] = temp;
361	}
362
363	k = j;
364	}
365	}	475	}
366		476
367	write (thr_recv [1], &req, sizeof (req));	477	self->id = pingercnt++;
		478	}
		479
		480	pingers [self->id] = self;
		481
		482	self->recvcb = &PL_sv_undef;
		483	self->interval = MIN_INTERVAL;
		484	self->maxrtt = 0.5;
		485	self->rangemax = 16;
		486	self->ranges = malloc (sizeof (self->ranges [0]) * self->rangemax);
		487	}
		488
		489	static void
		490	pinger_free (PINGER *self)
		491	{
		492	pinger_stop (self);
		493
		494	pingers [self->id] = 0;
		495
		496	SvREFCNT_dec (self->recvq);
		497	SvREFCNT_dec (self->recvcb);
		498
		499	pingerfree [self->id] = firstfree;
		500	firstfree = self->id;
		501
		502	while (self->rangecnt)
		503	range_free (self->ranges [--self->rangecnt]);
		504
		505	free (self->ranges);
		506	}
		507
		508	/*****************************************************************************/
		509
		510	static void
		511	recv_feed (PINGER self, void addr, int addrlen, tstamp rtt)
		512	{
		513	if (!self->recvq)
368	}	514	{
		515	/* first seen this round */
		516	if (!SvOK (self->recvcb))
		517	return;
369		518
		519	self->recvq = newAV ();
		520
		521	self->nextrecv = firstrecv;
		522	firstrecv = self->id;
		523	}
		524
		525	{
		526	AV *pkt = newAV ();
		527
		528	av_extend (pkt, 2-1);
		529
		530	AvARRAY (pkt)[0] = newSVpvn (addr, addrlen);
		531	AvARRAY (pkt)[1] = newSVnv (rtt);
		532	AvFILLp (pkt) = 2-1;
		533
		534	av_push (self->recvq, newRV_noinc ((SV *)pkt));
		535	}
		536	}
		537
		538	static void
		539	recv_flush (void)
		540	{
		541	if (firstrecv < 0)
370	return 0;	542	return;
371	}
372		543
		544	ENTER;
		545	SAVETMPS;
		546
		547	while (firstrecv >= 0)
		548	{
		549	dSP;
		550	PINGER *self = pingers [firstrecv];
		551	firstrecv = self->nextrecv;
		552
		553	self->nextrecv = -1;
		554
		555	PUSHMARK (SP);
		556	XPUSHs (sv_2mortal (newRV_noinc ((SV *)self->recvq)));
		557	self->recvq = 0;
		558	PUTBACK;
		559	call_sv (self->recvcb, G_DISCARD \| G_VOID);
		560	}
		561
		562	FREETMPS;
		563	LEAVE;
		564	}
		565
		566	/*****************************************************************************/
		567
		568	#if 0
373	static void	569	static void
374	feed_reply (AV *res_av)	570	feed_reply (AV *res_av)
375	{	571	{
376	dSP;	572	dSP;
377	SV res = sv_2mortal (newRV_inc ((SV )res_av));	573	SV res = sv_2mortal (newRV_inc ((SV )res_av));
…		…
394	}	590	}
395		591
396	FREETMPS;	592	FREETMPS;
397	LEAVE;	593	LEAVE;
398	}	594	}
		595	#endif
399		596
400	static void	597	static void
401	boot ()	598	boot ()
402	{	599	{
403	sigset_t fullsigset, oldsigset;
404	pthread_attr_t attr;
405
406	if (pipe (thr_send) < 0)
407	croak ("AnyEvent::FastPing: unable to create send pipe");
408
409	if (pipe (thr_recv) < 0)	600	if (pipe (thr_res) < 0)
410	croak ("AnyEvent::FastPing: unable to create receive pipe");	601	croak ("AnyEvent::FastPing: unable to create receive pipe");
		602
		603	sv_setiv (get_sv ("AnyEvent::FastPing::THR_RES_FD", 1), thr_res [0]);
411		604
412	icmp4_fd = socket (AF_INET, SOCK_RAW, IPPROTO_ICMP);	605	icmp4_fd = socket (AF_INET, SOCK_RAW, IPPROTO_ICMP);
413	fcntl (icmp4_fd, F_SETFL, O_NONBLOCK);	606	fcntl (icmp4_fd, F_SETFL, O_NONBLOCK);
414	#ifdef ICMP_FILTER	607	#ifdef ICMP_FILTER
415	{	608	{
…		…
430	setsockopt (icmp6_fd, IPPROTO_ICMPV6, ICMP6_FILTER, &oval, sizeof oval);	623	setsockopt (icmp6_fd, IPPROTO_ICMPV6, ICMP6_FILTER, &oval, sizeof oval);
431	}	624	}
432	# endif	625	# endif
433	#endif	626	#endif
434		627
435	pthread_attr_init (&attr);
436	pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
437	#ifdef PTHREAD_SCOPE_PROCESS
438	pthread_attr_setscope (&attr, PTHREAD_SCOPE_PROCESS);
439	#endif
440
441	sigfillset (&fullsigset);
442
443	pthread_sigmask (SIG_SETMASK, &fullsigset, &oldsigset);
444
445	if (pthread_create (&pthrid, &attr, ping_proc, 0))
446	croak ("AnyEvent::FastPing: unable to create pinger thread");
447
448	pthread_sigmask (SIG_SETMASK, &oldsigset, 0);
449
450	sv_setiv (get_sv ("AnyEvent::FastPing::THR_REQ_FD", 1), thr_send [1]);
451	sv_setiv (get_sv ("AnyEvent::FastPing::THR_RES_FD", 1), thr_recv [0]);
452
453	sv_setiv (get_sv ("AnyEvent::FastPing::ICMP4_FD", 1), icmp4_fd);	628	sv_setiv (get_sv ("AnyEvent::FastPing::ICMP4_FD", 1), icmp4_fd);
454	sv_setiv (get_sv ("AnyEvent::FastPing::ICMP6_FD", 1), icmp6_fd);	629	sv_setiv (get_sv ("AnyEvent::FastPing::ICMP6_FD", 1), icmp6_fd);
455	}	630	}
456		631
457	MODULE = AnyEvent::FastPing PACKAGE = AnyEvent::FastPing	632	MODULE = AnyEvent::FastPing PACKAGE = AnyEvent::FastPing PREFIX = pinger_
458		633
459	BOOT:	634	BOOT:
460	{	635	{
461	HV *stash = gv_stashpv ("AnyEvent::FastPing", 1);	636	HV *stash = gv_stashpv ("AnyEvent::FastPing", 1);
462
463	cbs = get_av ("AnyEvent::FastPing::CB", 1);
464	magic = getpid () ^ MAGIC;
465		637
466	if (sizeof (PKT) & 3)	638	if (sizeof (PKT) & 3)
467	croak ("size of PKT structure is not a multiple of 4");	639	croak ("size of PKT structure is not a multiple of 4");
468		640
469	boot ();	641	boot ();
…		…
475	newCONSTSUB (stash, "icmp6_pktsize", newSViv (HDR_SIZE_IP6 + sizeof (PKT)));	647	newCONSTSUB (stash, "icmp6_pktsize", newSViv (HDR_SIZE_IP6 + sizeof (PKT)));
476	}	648	}
477		649
478	PROTOTYPES: DISABLE	650	PROTOTYPES: DISABLE
479		651
480	SV *	652	void
481	_req_icmp_ping (SV ranges, NV interval, U32 payload, SV id)	653	_new (SV *klass, UV magic1, UV magic2, UV magic3)
		654	PPCODE:
		655	{
		656	SV *pv = NEWSV (0, sizeof (PINGER));
		657	PINGER self = (PINGER )SvPVX (pv);
		658	SvPOK_only (pv);
		659	XPUSHs (sv_2mortal (sv_bless (newRV_noinc (pv), gv_stashpv (SvPV_nolen (klass), 1))));
		660	pinger_init (self);
		661	self->magic1 = magic1;
		662	self->magic2 = magic2;
		663	self->magic3 = magic3;
		664	}
		665
		666	void
		667	_free (PINGER *self)
482	CODE:	668	CODE:
483	{	669	pinger_free (self);
484	AV *rav;
485	int nranges, i;
486	REQ *req;
487		670
488	if (!SvROK (ranges) \|\| SvTYPE (SvRV (ranges)) != SVt_PVAV)	671	IV
489	croak ("address ranges must be given as arrayref with lo, hi pairs");	672	id (PINGER *self, ...)
490		673	CODE:
491	rav = (AV *)SvRV (ranges);	674	RETVAL = self->id;
492	nranges = av_len (rav) + 1;
493
494	req = malloc (sizeof (REQ));
495
496	if (interval < MIN_INTERVAL)
497	interval = MIN_INTERVAL;
498
499	req->id = newSVsv (id);
500	req->interval = interval;
501	req->payload = payload;
502	req->nranges = nranges;
503	req->ranges = (RANGE )malloc (nranges sizeof (RANGE));
504
505	while (nranges--)
506	{
507	SV sv = av_fetch (rav, nranges, 1);
508	SV lo, hi;
509	AV *av;
510	RANGE *r;
511
512	if (!SvROK (sv) \|\| SvTYPE (SvRV (sv)) != SVt_PVAV)
513	croak ("address range must be given as arrayref with lo, hi, interval arrayrefs");
514
515	av = (AV *)SvRV (sv);
516	r = req->ranges + nranges;
517
518	lo = *av_fetch (av, 0, 1);
519	hi = *av_fetch (av, 1, 1);
520
521	sv_utf8_downgrade (lo, 0);
522	sv_utf8_downgrade (hi, 0);
523
524	memset (&r->lo, 0, sizeof (addr_tt));
525	memset (&r->hi, 0, sizeof (addr_tt));
526
527	if (SvPOKp (lo) && SvPOKp (hi))
528	{
529	if (SvCUR (lo) != SvCUR (hi))
530	croak ("all addresses in range must be of the same size (either 4 or 16 bytes)");
531
532	if (SvCUR (lo) == 4)
533	{
534	r->family = AF_INET;
535	memcpy (sizeof (addr_tt) - 4 + (char *)&r->lo, SvPVX (lo), 4);
536	memcpy (sizeof (addr_tt) - 4 + (char *)&r->hi, SvPVX (hi), 4);
537	}
538	else if (SvCUR (lo) == 16)
539	{
540	#if ENABLE_IPV6
541	r->family = AF_INET6;
542	memcpy (&r->lo, SvPVX (lo), sizeof (addr_tt));
543	memcpy (&r->hi, SvPVX (hi), sizeof (addr_tt));
544	#else
545	croak ("IPv6 not supported in this configuration");
546	#endif
547	}
548	else
549	croak ("addresses in range must be either 4 (IPv4) or 16 (IPv6) bytes in length");
550	}
551	else if (SvIOK (lo) && SvIOK (hi))
552	{
553	uint32_t addr;
554
555	r->family = AF_INET;
556
557	addr = htonl (SvUV (lo)); memcpy (sizeof (addr_tt) - 4 + (char *)&r->lo, &addr, 4);
558	addr = htonl (SvUV (hi)); memcpy (sizeof (addr_tt) - 4 + (char *)&r->hi, &addr, 4);
559	}
560	else
561	croak ("addresses in range must be strings with either 4 (IPv4) or 16 (IPv6) octets");
562
563	if (r->family == AF_INET)
564	{
565	if (icmp4_fd < 0)
566	croak ("AnyEvent::FastPing: IPv4 ping support not available on this system");
567	}
568	else
569	{
570	if (icmp6_fd < 0)
571	croak ("AnyEvent::FastPing: IPv6 ping support not available on this system");
572	}
573
574	r->interval = SvNV (*av_fetch (av, 2, 1));
575
576	if (r->interval < req->interval)
577	r->interval = req->interval;
578
579	r->next = 0.;
580	}
581
582	RETVAL = newSVpvn ((char *)&req, sizeof (req));
583	}
584	OUTPUT:	675	OUTPUT:
585	RETVAL	676	RETVAL
586		677
587	SV *	678	void pinger_start (PINGER *self)
588	_read_res ()	679
		680	void pinger_stop (PINGER *self)
		681
		682	void _stop_id (UV id)
589	CODE:	683	CODE:
		684	if (id < pingercnt && pingers [id])
		685	pinger_stop (pingers [id]);
		686
		687	void interval (PINGER *self, NV interval)
		688	CODE:
		689	self->interval = interval > MIN_INTERVAL ? interval : MIN_INTERVAL;
		690
		691	void add_range (PINGER self, SV lo_, SV *hi_, NV interval)
		692	CODE:
590	{	693	{
		694	STRLEN lo_len, hi_len;
		695	char *lo = SvPVbyte (lo_, lo_len);
		696	char *hi = SvPVbyte (hi_, hi_len);
591	REQ *req;	697	RANGE *range;
592		698
593	if (read (thr_recv [0], &req, sizeof (req)) != sizeof (req))	699	if (lo_len != hi_len \|\| (lo_len != 4 && lo_len != 16))
594	RETVAL = &PL_sv_undef;	700	croak ("AnyEvent::FastPing::add_range address range must be specified as two binary IPv4 or IPv6 addresses");
595		701
596	RETVAL = req->id;	702	if (lo_len == 4 && icmp4_fd < 0) croak ("IPv4 support unavailable");
597	free (req->ranges);	703	if (lo_len == 16 && icmp6_fd < 0) croak ("IPv6 support unavailable");
598	free (req);	704
		705	range = calloc (1, sizeof (RANGE));
		706
		707	range->next = 0;
		708	range->interval = interval > MIN_INTERVAL ? interval : MIN_INTERVAL;
		709	range->addrlen = lo_len;
		710
		711	memcpy (sizeof (addr_tt) - lo_len + (char *)&range->lo, lo, lo_len);
		712	memcpy (sizeof (addr_tt) - lo_len + (char *)&range->hi, hi, lo_len);
		713
		714	if (self->rangecnt == self->rangemax)
		715	self->ranges = realloc (self->ranges, sizeof (self->ranges [0]) * (self->rangemax <<= 1));
		716
		717	self->ranges [self->rangecnt] = range;
		718	upheap (self, self->rangecnt);
		719	++self->rangecnt;
599	}	720	}
600	OUTPUT:	721
601	RETVAL	722	void
		723	on_recv (PINGER self, SV cb)
		724	CODE:
		725	SvREFCNT_dec (self->recvcb);
		726	self->recvcb = newSVsv (cb);
		727
		728	void
		729	max_rtt (PINGER *self, NV maxrtt)
		730	CODE:
		731	self->maxrtt = maxrtt;
602		732
603	void	733	void
604	_recv_icmp4 (...)	734	_recv_icmp4 (...)
605	CODE:	735	CODE:
606	{	736	{
607	char buf [512];	737	char buf [512];
608	struct sockaddr_in sa;	738	struct sockaddr_in sa;
609	socklen_t sl = sizeof (sa);
610	AV res_av = av_len (cbs) < 0 ? 0 : (AV )sv_2mortal ((SV *)newAV ());
611	tstamp now = NOW ();
612
613	if (!res_av)
614	XSRETURN_UNDEF;
615		739
616	for (;;)	740	for (;;)
617	{	741	{
		742	PINGER *pinger;
618	IP4HDR iphdr = (IP4HDR )buf;	743	IP4HDR iphdr = (IP4HDR )buf;
		744	socklen_t sl = sizeof (sa);
619	int len = recvfrom (icmp4_fd, buf, sizeof (buf), MSG_TRUNC, (struct sockaddr *)&sa, &sl);	745	int len = recvfrom (icmp4_fd, buf, sizeof (buf), MSG_TRUNC, (struct sockaddr *)&sa, &sl);
620	int hdrlen, totlen;	746	int hdrlen, totlen;
621	PKT *pkt;	747	PKT *pkt;
622		748
623	if (len <= HDR_SIZE_IP4)	749	if (len <= HDR_SIZE_IP4)
…		…
632	\|\| hdrlen < HDR_SIZE_IP4 \|\| hdrlen + sizeof (PKT) != totlen)	758	\|\| hdrlen < HDR_SIZE_IP4 \|\| hdrlen + sizeof (PKT) != totlen)
633	continue;	759	continue;
634		760
635	pkt = (PKT *)(buf + hdrlen);	761	pkt = (PKT *)(buf + hdrlen);
636		762
637	if (pkt->type != ICMP4_ECHO_REPLY \|\| !pkt_is_valid (pkt))	763	if (pkt->type != ICMP4_ECHO_REPLY
		764	\|\| pkt->pinger >= pingercnt
		765	\|\| !pingers [pkt->pinger])
638	continue;	766	continue;
639		767
640	{	768	pinger = pingers [pkt->pinger];
641	AV *av = newAV ();
642	av_push (av, newSVpvn ((char *)&sa.sin_addr, 4));
643	av_push (av, newSVnv (now - pkt_to_ts (pkt)));
644	av_push (av, newSVuv (pkt->payload));
645		769
646	av_push (res_av, newRV_noinc ((SV *)av));	770	if (!pkt_is_valid_for (pkt, pinger))
647	}	771	continue;
		772
		773	recv_feed (pinger, &sa.sin_addr, 4, NOW () - pkt_to_ts (pkt));
648	}	774	}
649		775
650	feed_reply (res_av);	776	recv_flush ();
651	}	777	}
652		778
653	void	779	void
654	_recv_icmp6 (...)	780	_recv_icmp6 (...)
655	CODE:	781	CODE:
656	{	782	{
657	struct sockaddr_in6 sa;	783	struct sockaddr_in6 sa;
658	socklen_t sl = sizeof (sa);
659	AV res_av = av_len (cbs) < 0 ? 0 : (AV )sv_2mortal ((SV *)newAV ());
660	PKT pkt;	784	PKT pkt;
661	tstamp now = NOW ();
662
663	if (!res_av)
664	XSRETURN_UNDEF;
665		785
666	for (;;)	786	for (;;)
667	{	787	{
		788	PINGER *pinger;
		789	socklen_t sl = sizeof (sa);
668	int len = recvfrom (icmp6_fd, &pkt, sizeof (pkt), MSG_TRUNC, (struct sockaddr *)&sa, &sl);	790	int len = recvfrom (icmp6_fd, &pkt, sizeof (pkt), MSG_TRUNC, (struct sockaddr *)&sa, &sl);
669		791
670	if (len != sizeof (PKT))	792	if (len != sizeof (PKT))
671	break;	793	break;
672		794
673	if (pkt.type != ICMP6_ECHO_REPLY \|\| !pkt_is_valid (&pkt))	795	if (pkt.type != ICMP6_ECHO_REPLY
		796	\|\| pkt.pinger >= pingercnt
		797	\|\| !pingers [pkt.pinger])
674	continue;	798	continue;
675		799
676	{	800	pinger = pingers [pkt.pinger];
677	AV *av = newAV ();
678	av_push (av, newSVpvn ((char *)&sa.sin6_addr, 16));
679	av_push (av, newSVnv (now - pkt_to_ts (&pkt)));
680	av_push (av, newSVuv (pkt.payload));
681		801
682	av_push (res_av, newRV_noinc ((SV *)av));	802	if (!pkt_is_valid_for (&pkt, pinger))
683	}	803	continue;
		804
		805	recv_feed (pinger, &sa.sin6_addr, 16, NOW () - pkt_to_ts (&pkt));
684	}	806	}
685		807
686	feed_reply (res_av);	808	recv_flush ();
687	}	809	}
688		810

Diff Legend

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

Comparing AnyEvent-FastPing/FastPing.xs (file contents): Revision 1.9 by root, Sun Jan 30 02:03:35 2011 UTC vs. Revision 1.10 by root, Mon Jan 31 05:35:48 2011 UTC

Diff Legend

Comparing AnyEvent-FastPing/FastPing.xs (file contents):
Revision 1.9 by root, Sun Jan 30 02:03:35 2011 UTC vs.
Revision 1.10 by root, Mon Jan 31 05:35:48 2011 UTC