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

Comparing AnyEvent-FastPing/FastPing.xs (file contents):
Revision 1.7 by root, Sun Jan 16 17:05:32 2011 UTC vs.
Revision 1.15 by root, Sat Nov 12 01:20:46 2016 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>
19	#include <poll.h>	18	#include <poll.h>
20	#include <unistd.h>	19	#include <unistd.h>
21	#include <inttypes.h>	20	#include <inttypes.h>
22	#include <fcntl.h>	21	#include <fcntl.h>
23	#include <errno.h>	22	#include <errno.h>
		23	#include <limits.h>
24		24
25	#include <sys/types.h>	25	#include <sys/types.h>
26	#include <sys/time.h>	26	#include <sys/time.h>
27	#include <sys/socket.h>	27	#include <sys/socket.h>
28		28
…		…
30	#include <arpa/inet.h>	30	#include <arpa/inet.h>
31		31
32	#ifdef __linux	32	#ifdef __linux
33	# include <linux/icmp.h>	33	# include <linux/icmp.h>
34	#endif	34	#endif
35	#if ENABLE_IPV6	35	#if ENABLE_IPV6 && !defined (__CYGWIN__)
36	# include <netinet/icmp6.h>	36	# include <netinet/icmp6.h>
37	#endif	37	#endif
38		38
39	#define ICMP4_ECHO 8	39	#define ICMP4_ECHO 8
40	#define ICMP4_ECHO_REPLY 0	40	#define ICMP4_ECHO_REPLY 0
41	#define ICMP6_ECHO 128	41	#define ICMP6_ECHO 128
42	#define ICMP6_ECHO_REPLY 129	42	#define ICMP6_ECHO_REPLY 129
43		43
44	#define DRAIN_INTERVAL .000001 // how long to wait when sendto returns ENOBUFS, in seconds	44	#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	45	#define MIN_INTERVAL 1e-6 // minimum packet send interval, in seconds
46		46
47	#define HDR_SIZE_IP4 20	47	#define HDR_SIZE_IP4 20
48	#define HDR_SIZE_IP6 48	48	#define HDR_SIZE_IP6 48
49		49
50	//TODO: xread/xwrite for atomicity? we currently rely on the fact that the pip buffersize divides exactly by pointer sizes	50	static int thr_res[2]; // worker thread finished status
		51	static int icmp4_fd = -1;
		52	static int icmp6_fd = -1;
51		53
52	typedef uint8_t addr_t[16];	54	/*****************************************************************************/
53		55
54	typedef double tstamp;	56	typedef double tstamp;
55		57
56	static tstamp	58	static tstamp
57	NOW (void)	59	NOW (void)
58	{	60	{
59	struct timeval tv;	61	struct timeval tv;
		62
60	gettimeofday (&tv, 0);	63	gettimeofday (&tv, 0);
		64
61	return tv.tv_sec + tv.tv_usec * 0.000001;	65	return tv.tv_sec + tv.tv_usec * 1e-6;
62	}	66	}
63		67
		68	static void
		69	ssleep (tstamp wait)
		70	{
		71	#if defined (__SVR4) && defined (__sun)
		72	struct timeval tv;
		73
		74	tv.tv_sec = wait;
		75	tv.tv_usec = (wait - tv.tv_sec) * 1e6;
		76
		77	select (0, 0, 0, 0, &tv);
		78	#elif defined(_WIN32)
		79	Sleep ((unsigned long)(delay * 1e3));
		80	#else
		81	struct timespec ts;
		82
		83	ts.tv_sec = wait;
		84	ts.tv_nsec = (wait - ts.tv_sec) * 1e9;
		85
		86	nanosleep (&ts, 0);
		87	#endif
		88	}
		89
		90	/*****************************************************************************/
		91
64	typedef struct {	92	typedef struct
65	int family;	93	{
66	addr_t lo, hi;
67	double interval;
68	tstamp next;
69	} RANGE;
70
71	typedef struct {
72	SV *id;
73	double interval;
74	int nranges;
75	RANGE *ranges;
76	uint32_t payload;
77	} REQ;
78
79	typedef struct {
80	uint8_t version_ihl;	94	uint8_t version_ihl;
81	uint8_t tos;	95	uint8_t tos;
82	uint16_t tot_len;	96	uint16_t tot_len;
83		97
84	uint16_t id;	98	uint16_t id;
…		…
90		104
91	uint32_t src;	105	uint32_t src;
92	uint32_t dst;	106	uint32_t dst;
93	} IP4HDR;	107	} IP4HDR;
94		108
		109	/*****************************************************************************/
		110
		111	typedef uint8_t addr_tt[16];
		112
95	typedef struct {	113	typedef struct
96	uint8_t version;	114	{
97	uint8_t x1, x2, x3;	115	tstamp next;
		116	tstamp interval;
		117	int addrlen;
98		118
99	uint16_t payload_len;	119	addr_tt lo, hi; /* only if !addrcnt */
100	uint8_t nxt_hdr;
101	uint8_t hop_limit;
102		120
103	uint8_t src[16];	121	int addrcnt;
104	uint8_t dst[16];	122	/* addrcnt addresses follow */
105	} IP6HDR;	123	} RANGE;
106		124
107	#define MAGIC 0xca4c
108
109	static uint16_t magic;
110
111	typedef struct {	125	typedef struct
		126	{
		127	RANGE **ranges;
		128	int rangecnt, rangemax;
		129
		130	tstamp next;
		131	tstamp interval;
		132
		133	tstamp maxrtt;
		134
		135	uint16_t magic1;
		136	uint16_t magic2;
		137	uint16_t magic3;
		138
		139	int id;
		140
		141	AV recvq; / receive queue */
		142	int nextrecv;
		143	SV *recvcb;
		144
		145	pthread_t thrid;
		146	int running;
		147	} PINGER;
		148
		149	static PINGER **pingers;
		150	static int pingerfree; / freelist next */
		151	static int pingercnt;
		152	static int pingermax;
		153	static int firstfree = -1;
		154	static int firstrecv = -1;
		155
		156	/*****************************************************************************/
		157
		158	typedef struct
		159	{
112	uint8_t type, code;	160	uint8_t type, code;
113	uint16_t cksum;	161	uint16_t cksum;
		162
114	uint16_t id, seq;	163	uint16_t id, seq;
		164
		165	uint16_t pinger;
		166	uint16_t magic;
		167
		168	uint32_t stamp_hi;
115	uint32_t payload;	169	uint32_t stamp_lo;
116	tstamp stamp; // be careful when accessing this
117	} PKT;	170	} PKT;
118		171
119	static pthread_t pthrid;
120	static int thr_send[2]; // send to worker
121	static int thr_recv[2]; // receive from worker
122
123	static int icmp4_fd, icmp6_fd;
124
125	static AV *cbs;
126
127	static uint16_t	172	static int
128	icmp_cksum (void *data, unsigned int len)	173	pkt_is_valid_for (PKT pkt, PINGER pinger)
129	{	174	{
130	register int sum = 0;	175	return pkt->id == pinger->magic1
131	uint16_t *wp;	176	&& pkt->seq == pinger->magic2
		177	&& pkt->magic == pinger->magic3;
		178	}
132		179
133	assert (~len & 1);	180	static void
		181	ts_to_pkt (PKT *pkt, tstamp ts)
		182	{
		183	/* move 12 bits of seconds into the 32 bit fractional part */
		184	/* leaving 20 bits subsecond resolution and 44 bits of integers */
		185	/* (of which 32 are typically usable) */
		186	ts *= 1. / 4096.;
134		187
135	for (wp = (uint16_t *)data; len; wp++, len -= 2)	188	pkt->stamp_hi = ts;
136	sum += *wp;	189	pkt->stamp_lo = (ts - pkt->stamp_hi) * 4294967296.;
		190	}
		191
		192	static tstamp
		193	pkt_to_ts (PKT *pkt)
		194	{
		195	return pkt->stamp_hi * 4096.
		196	+ pkt->stamp_lo * (4096. / 4294967296.);
		197	}
		198
		199	static void
		200	pkt_cksum (PKT *pkt)
		201	{
		202	uint_fast32_t sum = 0;
		203	uint32_t wp = (uint32_t )pkt;
		204	int len = sizeof (*pkt) / 4;
		205
		206	do
		207	{
		208	uint_fast32_t w = (volatile uint32_t )wp++;
		209	sum += (w & 0xffff) + (w >> 16);
		210	}
		211	while (--len);
137		212
138	sum = (sum >> 16) + (sum & 0xffff); /* add high 16 to low 16 */	213	sum = (sum >> 16) + (sum & 0xffff); /* add high 16 to low 16 */
139	sum += sum >> 16; /* add carry */	214	sum += sum >> 16; /* add carry */
140		215
		216	pkt->cksum = ~sum;
		217	}
		218
		219	/*****************************************************************************/
		220
		221	static void
		222	range_free (RANGE *self)
		223	{
		224	free (self);
		225	}
		226
		227	/* like sendto, but retries on failure */
		228	static void
		229	xsendto (int fd, void buf, size_t len, int flags, void sa, int salen)
		230	{
		231	tstamp wait = DRAIN_INTERVAL / 2.;
		232
		233	while (sendto (fd, buf, len, flags, sa, salen) < 0 && errno == ENOBUFS)
		234	ssleep (wait *= 2.);
		235	}
		236
		237	// ping current address, return true and increment if more to ping
		238	static int
		239	range_send_ping (RANGE self, PKT pkt)
		240	{
		241	// send ping
		242	uint8_t *addr;
		243	int addrlen;
		244
		245	if (self->addrcnt)
		246	addr = (self->addrcnt - 1) * self->addrlen + (uint8_t *)(self + 1);
		247	else
		248	addr = sizeof (addr_tt) - self->addrlen + self->lo;
		249
		250	addrlen = self->addrlen;
		251
		252	/* convert ipv4 mapped addresses - this only works for host lists */
		253	/* this tries to match 0000:0000:0000:0000:0000:ffff:a.b.c.d */
		254	/* efficiently but also with few insns */
		255	if (addrlen == 16 && !addr [0] && icmp4_fd >= 0
		256	&& !( addr [ 1]
		257	\| addr [ 2] \| addr [ 3]
		258	\| addr [ 4] \| addr [ 5]
		259	\| addr [ 6] \| addr [ 7]
		260	\| addr [ 8] \| addr [ 9]
		261	\| (255-addr [10]) \| (255-addr [11])))
		262	{
		263	addr += 12;
		264	addrlen -= 12;
		265	}
		266
		267	pkt->cksum = 0;
		268
		269	if (addrlen == 4)
		270	{
		271	struct sockaddr_in sa;
		272
		273	pkt->type = ICMP4_ECHO;
		274	pkt_cksum (pkt);
		275
		276	sa.sin_family = AF_INET;
		277	sa.sin_port = 0;
		278
		279	memcpy (&sa.sin_addr, addr, sizeof (sa.sin_addr));
		280
		281	xsendto (icmp4_fd, pkt, sizeof (*pkt), 0, &sa, sizeof (sa));
		282	}
		283	else
		284	{
		285	#if ENABLE_IPV6
		286	struct sockaddr_in6 sa;
		287
		288	pkt->type = ICMP6_ECHO;
		289
		290	sa.sin6_family = AF_INET6;
		291	sa.sin6_port = 0;
		292	sa.sin6_flowinfo = 0;
		293	sa.sin6_scope_id = 0;
		294
		295	memcpy (&sa.sin6_addr, addr, sizeof (sa.sin6_addr));
		296
		297	xsendto (icmp6_fd, pkt, sizeof (*pkt), 0, &sa, sizeof (sa));
		298	#endif
		299	}
		300
		301	// see if we have any more addresses
		302	if (self->addrcnt)
		303	{
		304	if (!--self->addrcnt)
		305	return 0;
		306	}
		307	else
		308	{
		309	if (!memcmp (&self->lo, &self->hi, sizeof (addr_tt)))
		310	return 0;
		311
		312	// increment self->lo
		313	{
		314	int len = sizeof (addr_tt) - 1;
		315
		316	while (!++self->lo [len])
		317	--len;
		318	}
		319	}
		320
141	return ~sum;	321	return 1;
142	}	322	}
143		323
		324	/*****************************************************************************/
		325
		326	static void
		327	downheap (PINGER *self)
		328	{
		329	RANGE elem = self->ranges [0]; / always exists */
		330	int Nm1 = self->rangecnt - 1;
		331	int j;
		332	int k;
		333
		334	for (k = 0; ; )
		335	{
		336	int j = k * 2 + 1;
		337
		338	if (j > Nm1)
		339	break;
		340
		341	if (j < Nm1
		342	&& self->ranges [j]->next > self->ranges [j + 1]->next)
		343	++j;
		344
		345	if (self->ranges [j]->next >= elem->next)
		346	break;
		347
		348	self->ranges [k] = self->ranges [j];
		349
		350	k = j;
		351	}
		352
		353	self->ranges [k] = elem;
		354	}
		355
		356	static void
		357	upheap (PINGER *self, int k)
		358	{
		359	RANGE *elem = self->ranges [k];
		360
		361	while (k)
		362	{
		363	int j = (k - 1) >> 1;
		364
		365	if (self->ranges [j]->next <= elem->next)
		366	break;
		367
		368	self->ranges [k] = self->ranges [j];
		369
		370	k = j;
		371	}
		372
		373	self->ranges [k] = elem;
		374	}
		375
144	static void	376	static void *
145	inc_addr (addr_t *addr)	377	ping_proc (void *self_)
146	{	378	{
147	int len = sizeof (addr_t) - 1;	379	PINGER self = (PINGER )self_;
		380	PKT pkt;
		381
		382	memset (&pkt, 0, sizeof (pkt));
		383
		384	tstamp now = NOW ();
		385
		386	pkt.code = 0;
		387	pkt.id = self->magic1;
		388	pkt.seq = self->magic2;
		389	pkt.magic = self->magic3;
		390	pkt.pinger = self->id;
		391
		392	if (self->next < now)
		393	self->next = now;
		394
		395	while (self->rangecnt)
		396	{
		397	RANGE *range = self->ranges [0];
		398
		399	// ranges [0] is always the next range to ping
		400	tstamp wait = range->next - now;
		401
		402	// compare with the global frequency limit
		403	{
		404	tstamp diff = self->next - now;
		405
		406	if (wait < diff)
		407	wait = diff; // global rate limit overrides
		408	else
		409	self->next = range->next; // fast forward
		410	}
		411
		412	if (wait > 0.)
		413	ssleep (wait);
		414
		415	now = NOW ();
		416
		417	ts_to_pkt (&pkt, now);
		418
		419	if (!range_send_ping (range, &pkt))
		420	{
		421	self->ranges [0] = self->ranges [--self->rangecnt];
		422	range_free (range);
		423	}
		424	else
		425	range->next = self->next + range->interval;
		426
		427	downheap (self);
		428
		429	self->next += self->interval;
		430	now = NOW ();
		431	}
		432
		433	ssleep (self->maxrtt);
		434
		435	{
		436	uint16_t id = self->id;
		437
		438	write (thr_res [1], &id, sizeof (id));
		439	}
		440
		441	return 0;
		442	}
		443
		444	/*****************************************************************************/
		445
		446	/* NetBSD, Solaris... */
		447	#ifndef PTHREAD_STACK_MIN
		448	# define PTHREAD_STACK_MIN 0
		449	#endif
		450
		451	static void
		452	pinger_start (PINGER *self)
		453	{
		454	sigset_t fullsigset, oldsigset;
		455	pthread_attr_t attr;
		456
		457	if (self->running)
		458	return;
		459
		460	sigfillset (&fullsigset);
		461
		462	pthread_attr_init (&attr);
		463	pthread_attr_setstacksize (&attr, PTHREAD_STACK_MIN < sizeof (long) * 2048 ? sizeof (long) * 2048 : PTHREAD_STACK_MIN);
		464
		465	pthread_sigmask (SIG_SETMASK, &fullsigset, &oldsigset);
		466
		467	if (pthread_create (&self->thrid, &attr, ping_proc, (void *)self))
		468	croak ("AnyEvent::FastPing: unable to create pinger thread");
		469
		470	pthread_sigmask (SIG_SETMASK, &oldsigset, 0);
		471
		472	self->running = 1;
		473	}
		474
		475	static void
		476	pinger_stop (PINGER *self)
		477	{
		478	if (!self->running)
		479	return;
		480
		481	self->running = 0;
		482	pthread_cancel (self->thrid);
		483	pthread_join (self->thrid, 0);
		484	}
		485
		486	static void
		487	pinger_init (PINGER *self)
		488	{
		489	memset (self, 0, sizeof (PINGER));
		490
		491	if (firstfree >= 0)
		492	{
		493	self->id = firstfree;
		494	firstfree = pingerfree [firstfree];
		495	}
		496	else if (pingercnt == 0xffff)
		497	croak ("unable to create more than 65536 AnyEvent::FastPing objects");
		498	else
		499	{
		500	if (pingercnt == pingermax)
		501	{
		502	pingermax = pingermax * 2 + 16;
		503	pingers = realloc (pingers , sizeof (pingers [0]) * pingermax);
		504	pingerfree = realloc (pingerfree, sizeof (pingerfree [0]) * pingermax);
		505	}
		506
		507	self->id = pingercnt++;
		508	}
		509
		510	pingers [self->id] = self;
		511
		512	self->recvcb = &PL_sv_undef;
		513	self->next = 0.;
		514	self->interval = MIN_INTERVAL;
		515	self->maxrtt = 0.5;
		516	self->rangemax = 16;
		517	self->ranges = malloc (sizeof (self->ranges [0]) * self->rangemax);
		518	}
		519
		520	static void
		521	pinger_free (PINGER *self)
		522	{
		523	pinger_stop (self);
		524
		525	pingers [self->id] = 0;
		526
		527	SvREFCNT_dec (self->recvq);
		528	SvREFCNT_dec (self->recvcb);
		529
		530	pingerfree [self->id] = firstfree;
		531	firstfree = self->id;
		532
		533	while (self->rangecnt)
		534	range_free (self->ranges [--self->rangecnt]);
		535
		536	free (self->ranges);
		537	}
		538
		539	static void
		540	pinger_add_range (PINGER self, RANGE range)
		541	{
		542	if (self->rangecnt == self->rangemax)
		543	self->ranges = realloc (self->ranges, sizeof (self->ranges [0]) * (self->rangemax <<= 1));
		544
		545	self->ranges [self->rangecnt] = range;
		546	upheap (self, self->rangecnt);
		547	++self->rangecnt;
		548	}
		549
		550	/*****************************************************************************/
		551
		552	static void
		553	recv_feed (PINGER self, void addr, int addrlen, tstamp rtt)
		554	{
		555	if (!self->recvq)
		556	{
		557	/* first seen this round */
		558	if (!SvOK (self->recvcb))
		559	return;
		560
		561	self->recvq = newAV ();
		562
		563	self->nextrecv = firstrecv;
		564	firstrecv = self->id;
		565	}
		566
		567	{
		568	AV *pkt = newAV ();
		569
		570	av_extend (pkt, 2-1);
		571
		572	AvARRAY (pkt)[0] = newSVpvn (addr, addrlen);
		573	AvARRAY (pkt)[1] = newSVnv (rtt);
		574	AvFILLp (pkt) = 2-1;
		575
		576	av_push (self->recvq, newRV_noinc ((SV *)pkt));
		577	}
		578	}
		579
		580	static void
		581	recv_flush (void)
		582	{
		583	if (firstrecv < 0)
		584	return;
		585
		586	ENTER;
		587	SAVETMPS;
148		588
149	do	589	do
150	{	590	{
151	if ((*addr)[len] != 0xff)	591	dSP;
152	{	592	PINGER *self = pingers [firstrecv];
153	++(*addr)[len];	593	firstrecv = self->nextrecv;
154	break;
155	}
156		594
157	(*addr)[len] = 0;	595	self->nextrecv = -1;
158	}
159	while (len--);
160	}
161		596
162	static void *	597	PUSHMARK (SP);
163	ping_proc (void *unused)	598	XPUSHs (sv_2mortal (newRV_noinc ((SV *)self->recvq)));
164	{	599	self->recvq = 0;
165	PKT pkt;	600	PUTBACK;
166	struct sockaddr_in sa4;	601	call_sv (self->recvcb, G_DISCARD \| G_VOID);
167	#if ENABLE_IPV6
168	struct sockaddr_in6 sa6;
169	#endif
170
171	memset (&pkt, 0, sizeof (pkt));
172
173	memset (&sa4, 0, sizeof (sa4));
174	sa4.sin_family = AF_INET;
175	sa4.sin_port = 0;
176	#if ENABLE_IPV6
177	memset (&sa6, 0, sizeof (sa6));
178	sa6.sin6_family = AF_INET6;
179	sa6.sin6_port = 0;
180	#endif
181
182	for (;;)
183	{
184	REQ *req;
185	int len = read (thr_send [0], &req, sizeof (req));
186
187	tstamp now = NOW ();
188	tstamp next = now;
189
190	if (!len)
191	pthread_exit (0);
192	else if (len != sizeof (req))
193	{
194	perror ("AnyEvent::FastPing: short read or read error");
195	pthread_exit ((void *)-1);
196	}
197
198	//TODO: bind to source address
199
200	pkt.code = 0;
201	pkt.id = (uint16_t)magic;
202	pkt.seq = (uint16_t)~magic;
203	pkt.payload = req->payload;
204
205	{
206	int r;
207	for (r = req->nranges; r--; )
208	inc_addr (&req->ranges [r].hi);
209	}	602	}
		603	while (firstrecv >= 0);
210		604
211	while (req->nranges)	605	FREETMPS;
212	{	606	LEAVE;
213	RANGE *range = req->ranges;
214	int n, k;
215
216	if (!memcmp (&range->lo, &range->hi, sizeof (addr_t)))
217	req->ranges [0] = req->ranges [--req->nranges];
218	else
219	{
220	// ranges [0] is always the next range to ping
221	tstamp wait = range->next - now;
222
223	// compare with the global frequency limit
224	{
225	tstamp diff = next - now;
226
227	if (wait < diff)
228	wait = diff;
229	else if (range)
230	next = range->next;
231	}
232
233	if (wait > 0.)
234	{
235	struct timespec ts;
236
237	ts.tv_sec = wait;
238	ts.tv_nsec = (wait - ts.tv_sec) * 1000000000.;
239
240	nanosleep (&ts, 0);
241	}
242
243	now = NOW ();
244
245	pkt.stamp = now;
246	pkt.cksum = 0;
247
248	if (range->family == AF_INET)
249	{
250	pkt.type = ICMP4_ECHO;
251	pkt.cksum = icmp_cksum (&pkt, sizeof (pkt));
252
253	memcpy (&sa4.sin_addr,
254	sizeof (addr_t) - sizeof (sa4.sin_addr) + (char *)&range->lo,
255	sizeof (sa4.sin_addr));
256
257	if (sendto (icmp4_fd, &pkt, sizeof (pkt), 0, (struct sockaddr *)&sa4, sizeof (sa4)) > 0)
258	errno = 0;
259	}
260	else
261	{
262	#if ENABLE_IPV6
263	pkt.type = ICMP6_ECHO;
264
265	memcpy (&sa6.sin6_addr,
266	sizeof (addr_t) - sizeof (sa6.sin6_addr) + (char *)&range->lo,
267	sizeof (sa6.sin6_addr));
268
269	if (sendto (icmp6_fd, &pkt, sizeof (pkt), 0, (struct sockaddr *)&sa6, sizeof (sa6)) > 0)
270	errno = 0;
271	#endif
272	}
273
274	if (errno == ENOBUFS)
275	{
276	struct timespec ts;
277
278	ts.tv_sec = 0;
279	ts.tv_nsec = DRAIN_INTERVAL * 1000000000;
280
281	nanosleep (&ts, 0);
282	}
283	else
284	{
285	inc_addr (&range->lo);
286
287	range->next = next;
288	range->next += range->interval;
289	}
290
291	next += req->interval;
292	}
293
294	// make a downheap operation
295	for (n = k = 0; ; )
296	{
297	int j = k * 2 + 1;
298
299	++n;
300
301	if (j >= req->nranges)
302	break;
303	else if (j < req->nranges - 1)
304	if (req->ranges [j].next > req->ranges [j + 1].next)
305	++j;
306
307	if (req->ranges [j].next >= req->ranges [k].next)
308	break;
309
310	{
311	RANGE temp = req->ranges [k];
312	req->ranges [k] = req->ranges [j];
313	req->ranges [j] = temp;
314	}
315
316	k = j;
317	}
318	}
319
320	write (thr_recv [1], &req, sizeof (req));
321	}
322
323	return 0;
324	}	607	}
325		608
		609	/*****************************************************************************/
		610
		611	#if 0
326	static void	612	static void
327	feed_reply (AV *res_av)	613	feed_reply (AV *res_av)
328	{	614	{
329	dSP;	615	dSP;
330	SV res = sv_2mortal (newRV_inc ((SV )res_av));	616	SV res = sv_2mortal (newRV_inc ((SV )res_av));
…		…
347	}	633	}
348		634
349	FREETMPS;	635	FREETMPS;
350	LEAVE;	636	LEAVE;
351	}	637	}
		638	#endif
352		639
353	static void	640	static void
354	boot ()	641	boot_protocols (void)
355	{	642	{
356	sigset_t fullsigset, oldsigset;
357	pthread_attr_t attr;
358
359	if (pipe (thr_send) < 0)
360	croak ("AnyEvent::FastPing: unable to create send pipe");
361
362	if (pipe (thr_recv) < 0)
363	croak ("AnyEvent::FastPing: unable to create receive pipe");
364
365	icmp4_fd = socket (AF_INET, SOCK_RAW, IPPROTO_ICMP);	643	icmp4_fd = socket (AF_INET, SOCK_RAW, IPPROTO_ICMP);
366	fcntl (icmp4_fd, F_SETFL, O_NONBLOCK);	644	fcntl (icmp4_fd, F_SETFL, O_NONBLOCK);
367	#ifdef ICMP_FILTER	645	#ifdef ICMP_FILTER
368	{	646	{
369	struct icmp_filter oval;	647	struct icmp_filter oval;
…		…
382	ICMP6_FILTER_SETPASS (ICMP6_ECHO_REPLY, &oval);	660	ICMP6_FILTER_SETPASS (ICMP6_ECHO_REPLY, &oval);
383	setsockopt (icmp6_fd, IPPROTO_ICMPV6, ICMP6_FILTER, &oval, sizeof oval);	661	setsockopt (icmp6_fd, IPPROTO_ICMPV6, ICMP6_FILTER, &oval, sizeof oval);
384	}	662	}
385	# endif	663	# endif
386	#endif	664	#endif
		665	}
387		666
388	pthread_attr_init (&attr);	667	static void
389	pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);	668	boot (void)
390	#ifdef PTHREAD_SCOPE_PROCESS	669	{
391	pthread_attr_setscope (&attr, PTHREAD_SCOPE_PROCESS);	670	if (pipe (thr_res) < 0)
392	#endif
393
394	sigfillset (&fullsigset);
395
396	pthread_sigmask (SIG_SETMASK, &fullsigset, &oldsigset);
397
398	if (pthread_create (&pthrid, &attr, ping_proc, 0))
399	croak ("AnyEvent::FastPing: unable to create pinger thread");	671	croak ("AnyEvent::FastPing: unable to create receive pipe");
400		672
401	pthread_sigmask (SIG_SETMASK, &oldsigset, 0);
402
403	sv_setiv (get_sv ("AnyEvent::FastPing::THR_REQ_FD", 1), thr_send [1]);
404	sv_setiv (get_sv ("AnyEvent::FastPing::THR_RES_FD", 1), thr_recv [0]);	673	sv_setiv (get_sv ("AnyEvent::FastPing::THR_RES_FD", 1), thr_res [0]);
		674
		675	boot_protocols ();
405		676
406	sv_setiv (get_sv ("AnyEvent::FastPing::ICMP4_FD", 1), icmp4_fd);	677	sv_setiv (get_sv ("AnyEvent::FastPing::ICMP4_FD", 1), icmp4_fd);
407	sv_setiv (get_sv ("AnyEvent::FastPing::ICMP6_FD", 1), icmp6_fd);	678	sv_setiv (get_sv ("AnyEvent::FastPing::ICMP6_FD", 1), icmp6_fd);
408	}	679	}
409		680
		681	#define NOT_RUNNING \
		682	if (self->running) \
		683	croak ("AnyEvent::FastPing object has been started - you have to stop it first before calling this method, caught");
		684
410	MODULE = AnyEvent::FastPing PACKAGE = AnyEvent::FastPing	685	MODULE = AnyEvent::FastPing PACKAGE = AnyEvent::FastPing PREFIX = pinger_
		686
		687	PROTOTYPES: DISABLE
411		688
412	BOOT:	689	BOOT:
413	{	690	{
414	HV *stash = gv_stashpv ("AnyEvent::FastPing", 1);	691	HV *stash = gv_stashpv ("AnyEvent::FastPing", 1);
		692
		693	if (sizeof (PKT) & 3)
		694	croak ("size of PKT structure is not a multiple of 4");
415		695
416	cbs = get_av ("AnyEvent::FastPing::CB", 1);
417	magic = getpid () ^ MAGIC;
418
419	boot ();
420
421	newCONSTSUB (stash, "ipv4_supported", newSViv (icmp4_fd >= 0));
422	newCONSTSUB (stash, "ipv6_supported", newSViv (icmp6_fd >= 0));
423
424	newCONSTSUB (stash, "icmp4_pktsize", newSViv (HDR_SIZE_IP4 + sizeof (PKT)));	696	newCONSTSUB (stash, "icmp4_pktsize", newSViv (HDR_SIZE_IP4 + sizeof (PKT)));
425	newCONSTSUB (stash, "icmp6_pktsize", newSViv (HDR_SIZE_IP6 + sizeof (PKT)));	697	newCONSTSUB (stash, "icmp6_pktsize", newSViv (HDR_SIZE_IP6 + sizeof (PKT)));
426	}
427		698
428	PROTOTYPES: DISABLE	699	boot_protocols ();
429		700
430	SV *	701	newCONSTSUB (stash, "ipv4_supported", newSViv (icmp4_fd >= 0));
431	_req_icmp_ping (SV ranges, NV interval, U32 payload, SV id)	702	newCONSTSUB (stash, "ipv6_supported", newSViv (icmp6_fd >= 0));
432	CODE:	703
433	{	704	close (icmp4_fd);
434	AV *rav;	705	close (icmp6_fd);
435	int nranges, i;
436	REQ *req;
437
438	if (!SvROK (ranges) \|\| SvTYPE (SvRV (ranges)) != SVt_PVAV)
439	croak ("address ranges must be given as arrayref with lo, hi pairs");
440
441	rav = (AV *)SvRV (ranges);
442	nranges = av_len (rav) + 1;
443
444	req = malloc (sizeof (REQ));
445
446	if (interval < MIN_INTERVAL)
447	interval = MIN_INTERVAL;
448
449	req->id = newSVsv (id);
450	req->interval = interval;
451	req->payload = payload;
452	req->nranges = nranges;
453	req->ranges = (RANGE )malloc (nranges sizeof (RANGE));
454
455	while (nranges--)
456	{
457	SV sv = av_fetch (rav, nranges, 1);
458	SV lo, hi;
459	AV *av;
460	RANGE *r;
461
462	if (!SvROK (sv) \|\| SvTYPE (SvRV (sv)) != SVt_PVAV)
463	croak ("address range must be given as arrayref with lo, hi, interval arrayrefs");
464
465	av = (AV *)SvRV (sv);
466	r = req->ranges + nranges;
467
468	lo = *av_fetch (av, 0, 1);
469	hi = *av_fetch (av, 1, 1);
470
471	sv_utf8_downgrade (lo, 0);
472	sv_utf8_downgrade (hi, 0);
473
474	memset (&r->lo, 0, sizeof (addr_t));
475	memset (&r->hi, 0, sizeof (addr_t));
476
477	if (SvPOKp (lo) && SvPOKp (hi))
478	{
479	if (SvCUR (lo) != SvCUR (hi))
480	croak ("all addresses in range must be of the same size (either 4 or 16 bytes)");
481
482	if (SvCUR (lo) == 4)
483	{
484	r->family = AF_INET;
485	memcpy (sizeof (addr_t) - 4 + (char *)&r->lo, SvPVX (lo), 4);
486	memcpy (sizeof (addr_t) - 4 + (char *)&r->hi, SvPVX (hi), 4);
487	}
488	else if (SvCUR (lo) == 16)
489	{
490	#if ENABLE_IPV6
491	r->family = AF_INET6;
492	memcpy (&r->lo, SvPVX (lo), sizeof (addr_t));
493	memcpy (&r->hi, SvPVX (hi), sizeof (addr_t));
494	#else
495	croak ("IPv6 not supported in this configuration");
496	#endif
497	}
498	else
499	croak ("addresses in range must be either 4 (IPv4) or 16 (IPv6) bytes in length");
500	}
501	else if (SvIOK (lo) && SvIOK (hi))
502	{
503	uint32_t addr;
504
505	r->family = AF_INET;
506
507	addr = htonl (SvUV (lo)); memcpy (sizeof (addr_t) - 4 + (char *)&r->lo, &addr, 4);
508	addr = htonl (SvUV (hi)); memcpy (sizeof (addr_t) - 4 + (char *)&r->hi, &addr, 4);
509	}
510	else
511	croak ("addresses in range must be strings with either 4 (IPv4) or 16 (IPv6) octets");
512
513	if (r->family == AF_INET)
514	{
515	if (icmp4_fd < 0)
516	croak ("AnyEvent::FastPing: IPv4 ping support not available on this system");
517	}
518	else
519	{
520	if (icmp6_fd < 0)
521	croak ("AnyEvent::FastPing: IPv6 ping support not available on this system");
522	}
523
524	r->interval = SvNV (*av_fetch (av, 2, 1));
525
526	if (r->interval < req->interval)
527	r->interval = req->interval;
528
529	r->next = 0.;
530	}
531
532	RETVAL = newSVpvn ((char *)&req, sizeof (req));
533	}	706	}
534	OUTPUT:
535	RETVAL
536		707
537	SV *	708	void
538	_read_res ()	709	_boot ()
539	CODE:	710	CODE:
540	{	711	boot ();
541	REQ *req;
542
543	if (read (thr_recv [0], &req, sizeof (req)) != sizeof (req))
544	RETVAL = &PL_sv_undef;
545
546	RETVAL = req->id;
547	free (req->ranges);
548	free (req);
549	}
550	OUTPUT:
551	RETVAL
552		712
553	void	713	void
554	_recv_icmp4 (...)	714	_recv_icmp4 (...)
555	CODE:	715	CODE:
556	{	716	{
557	char buf [512];	717	char buf [512];
558	struct sockaddr_in sa;	718	struct sockaddr_in sa;
559	socklen_t sl = sizeof (sa);	719	int maxrecv;
560	AV res_av = av_len (cbs) < 0 ? 0 : (AV )sv_2mortal ((SV *)newAV ());
561	tstamp now = NOW ();
562		720
563	for (;;)	721	for (maxrecv = 256+1; --maxrecv; )
564	{	722	{
		723	PINGER *pinger;
565	IP4HDR iphdr = (IP4HDR )buf;	724	IP4HDR iphdr = (IP4HDR )buf;
		725	socklen_t sl = sizeof (sa);
566	int len = recvfrom (icmp4_fd, buf, sizeof (buf), MSG_TRUNC, (struct sockaddr *)&sa, &sl);	726	int len = recvfrom (icmp4_fd, buf, sizeof (buf), MSG_TRUNC, (struct sockaddr *)&sa, &sl);
567	int hdrlen, totlen;	727	int hdrlen, totlen;
568	PKT *pkt;	728	PKT *pkt;
569		729
570	if (len <= HDR_SIZE_IP4)	730	if (len <= HDR_SIZE_IP4)
571	break;	731	break;
572		732
573	hdrlen = (iphdr->version_ihl & 15) * 4;	733	hdrlen = (iphdr->version_ihl & 15) * 4;
574	totlen = ntohs (iphdr->tot_len);	734	totlen = ntohs (iphdr->tot_len);
575		735
576	// packet corrupt?
577	if (!res_av
578	\|\| totlen > len	736	if (totlen > len
579	\|\| iphdr->protocol != IPPROTO_ICMP	737	\|\| iphdr->protocol != IPPROTO_ICMP
580	\|\| hdrlen < HDR_SIZE_IP4 \|\| hdrlen + sizeof (PKT) != totlen)	738	\|\| hdrlen < HDR_SIZE_IP4 \|\| hdrlen + sizeof (PKT) != totlen)
581	continue;	739	continue;
582		740
583	pkt = (PKT *)(buf + hdrlen);	741	pkt = (PKT *)(buf + hdrlen);
584		742
585	if (pkt->type != ICMP4_ECHO_REPLY	743	if (pkt->type != ICMP4_ECHO_REPLY
586	\|\| pkt->id != (uint16_t) magic	744	\|\| pkt->pinger >= pingercnt
587	\|\| pkt->seq != (uint16_t)~magic	745	\|\| !pingers [pkt->pinger])
588	\|\| !isnormal (pkt->stamp))
589	continue;	746	continue;
590		747
591	{	748	pinger = pingers [pkt->pinger];
592	AV *av = newAV ();
593	av_push (av, newSVpvn ((char *)&sa.sin_addr, 4));
594	av_push (av, newSVnv (now - pkt->stamp));
595	av_push (av, newSVuv (pkt->payload));
596		749
597	av_push (res_av, newRV_noinc ((SV *)av));	750	if (!pkt_is_valid_for (pkt, pinger))
598	}	751	continue;
		752
		753	recv_feed (pinger, &sa.sin_addr, 4, NOW () - pkt_to_ts (pkt));
599	}	754	}
600		755
601	if (res_av)	756	recv_flush ();
602	feed_reply (res_av);
603	}	757	}
604		758
605	void	759	void
606	_recv_icmp6 (...)	760	_recv_icmp6 (...)
607	CODE:	761	CODE:
608	{	762	{
609	struct sockaddr_in6 sa;	763	struct sockaddr_in6 sa;
610	socklen_t sl = sizeof (sa);
611	AV res_av = av_len (cbs) < 0 ? 0 : (AV )sv_2mortal ((SV *)newAV ());
612	PKT pkt;	764	PKT pkt;
613	tstamp now = NOW ();	765	int maxrecv;
614		766
615	for (;;)	767	for (maxrecv = 256+1; --maxrecv; )
616	{	768	{
		769	PINGER *pinger;
		770	socklen_t sl = sizeof (sa);
617	int len = recvfrom (icmp6_fd, &pkt, sizeof (pkt), MSG_TRUNC, (struct sockaddr *)&sa, &sl);	771	int len = recvfrom (icmp6_fd, &pkt, sizeof (pkt), MSG_TRUNC, (struct sockaddr *)&sa, &sl);
618		772
619	if (len != sizeof (PKT))	773	if (len != sizeof (PKT))
620	break;	774	break;
621		775
622	if (!res_av
623	\|\| pkt.type != ICMP6_ECHO_REPLY	776	if (pkt.type != ICMP6_ECHO_REPLY
624	\|\| pkt.id != (uint16_t) magic	777	\|\| pkt.pinger >= pingercnt
625	\|\| pkt.seq != (uint16_t)~magic	778	\|\| !pingers [pkt.pinger])
626	\|\| !isnormal (pkt.stamp))
627	continue;	779	continue;
628		780
		781	pinger = pingers [pkt.pinger];
		782
		783	if (!pkt_is_valid_for (&pkt, pinger))
		784	continue;
		785
		786	recv_feed (pinger, &sa.sin6_addr, 16, NOW () - pkt_to_ts (&pkt));
		787	}
		788
		789	recv_flush ();
		790	}
		791
		792	void
		793	_new (SV *klass, UV magic1, UV magic2, UV magic3)
		794	PPCODE:
		795	{
		796	SV *pv = NEWSV (0, sizeof (PINGER));
		797	PINGER self = (PINGER )SvPVX (pv);
		798
		799	SvPOK_only (pv);
		800	XPUSHs (sv_2mortal (sv_bless (newRV_noinc (pv), gv_stashpv (SvPVutf8_nolen (klass), 1))));
		801	pinger_init (self);
		802	self->magic1 = magic1;
		803	self->magic2 = magic2;
		804	self->magic3 = magic3;
		805	}
		806
		807	void
		808	_free (PINGER *self)
		809	CODE:
		810	pinger_free (self);
		811
		812	IV
		813	id (PINGER *self, ...)
		814	CODE:
		815	RETVAL = self->id;
		816	OUTPUT:
		817	RETVAL
		818
		819	void pinger_start (PINGER *self)
		820
		821	void pinger_stop (PINGER *self)
		822
		823	void
		824	_stop_id (UV id)
		825	CODE:
		826	if (id < pingercnt && pingers [id])
		827	pinger_stop (pingers [id]);
		828
		829	void
		830	interval (PINGER *self, NV interval)
		831	CODE:
		832	NOT_RUNNING;
		833	self->interval = interval > MIN_INTERVAL ? interval : MIN_INTERVAL;
		834
		835	void
		836	max_rtt (PINGER *self, NV maxrtt)
		837	CODE:
		838	NOT_RUNNING;
		839	self->maxrtt = maxrtt;
		840
		841	void
		842	on_recv (PINGER self, SV cb)
		843	CODE:
		844	SvREFCNT_dec (self->recvcb);
		845	self->recvcb = newSVsv (cb);
		846
		847	void
		848	add_range (PINGER self, SV lo_, SV *hi_, NV interval = 0)
		849	CODE:
		850	{
		851	STRLEN lo_len, hi_len;
		852	char *lo = SvPVbyte (lo_, lo_len);
		853	char *hi = SvPVbyte (hi_, hi_len);
		854	RANGE *range;
		855	NOT_RUNNING;
		856
		857	if (lo_len != hi_len \|\| (lo_len != 4 && lo_len != 16))
		858	croak ("AnyEvent::FastPing::add_range address range must be specified as two binary IPv4 or IPv6 addresses");
		859
		860	if (lo_len == 4 && icmp4_fd < 0) croak ("IPv4 support unavailable");
		861	if (lo_len == 16 && icmp6_fd < 0) croak ("IPv6 support unavailable");
		862
		863	if (memcmp (lo, hi, lo_len) > 0)
		864	croak ("AnyEvent::FastPing::add_range called with lo > hi");
		865
		866	range = calloc (1, sizeof (RANGE));
		867
		868	range->next = 0;
		869	range->interval = interval > MIN_INTERVAL ? interval : MIN_INTERVAL;
		870	range->addrlen = lo_len;
		871
		872	memcpy (sizeof (addr_tt) - lo_len + (char *)&range->lo, lo, lo_len);
		873	memcpy (sizeof (addr_tt) - lo_len + (char *)&range->hi, hi, lo_len);
		874
		875	pinger_add_range (self, range);
		876	}
		877
		878	void
		879	add_hosts (PINGER self, SV addrs, NV interval = 0, UV interleave = 1)
		880	CODE:
		881	{
		882	AV *av;
		883	int i, j, k;
		884	int cnt;
		885	int addrlen = 0;
		886	RANGE *range;
		887	NOT_RUNNING;
		888
		889	if (!SvROK (addrs) \|\| SvTYPE (SvRV (addrs)) != SVt_PVAV)
		890	croak ("AnyEvent::FastPing::add_hosts expects an arrayref with binary IPv4 or IPv6 addresses");
		891
		892	av = (AV *)SvRV (addrs);
		893	cnt = av_len (av) + 1;
		894
		895	for (i = 0; i < cnt; ++i)
		896	{
		897	SV sv = av_fetch (av, i, 1);
		898	sv_utf8_downgrade (sv, 0);
		899
		900	j = SvCUR (sv);
		901
		902	if (j != 4 && j != 16)
		903	croak ("AnyEvent::FastPing::add_hosts addresses must be specified as binary IPv4 or IPv6 addresses");
		904
		905	if (j > addrlen)
		906	addrlen = j;
		907	}
		908
		909	if (!cnt)
		910	XSRETURN_EMPTY;
		911
		912	range = calloc (1, sizeof (RANGE) + cnt * addrlen);
		913
		914	range->next = 0;
		915	range->interval = interval > MIN_INTERVAL ? interval : MIN_INTERVAL;
		916	range->addrlen = addrlen;
		917	range->addrcnt = cnt;
		918
		919	if (interleave == 0)
		920	interleave = cnt <= 256 * 256 ? 256 : (int)sqrtf (cnt);
		921
		922	k = cnt;
		923	for (j = 0; j < interleave; ++j)
		924	for (i = j; i < cnt; i += interleave)
629	{	925	{
630	AV *av = newAV ();	926	uint8_t dst = (uint8_t )(range + 1) + --k * addrlen;
631	av_push (av, newSVpvn ((char *)&sa.sin6_addr, 16));	927	char *pv;
632	av_push (av, newSVnv (now - pkt.stamp));	928	STRLEN pvlen;
633	av_push (av, newSVuv (pkt.payload));	929	SV sv = av_fetch (av, i, 1);
		930	sv_utf8_downgrade (sv, 0);
634		931
635	av_push (res_av, newRV_noinc ((SV *)av));	932	pv = SvPVbyte (sv, pvlen);
		933
		934	if (pvlen != addrlen)
		935	{
		936	dst [ 0] = 0x00; dst [ 1] = 0x00; dst [ 2] = 0x00; dst [ 3] = 0x00;
		937	dst [ 4] = 0x00; dst [ 5] = 0x00; dst [ 6] = 0x00; dst [ 7] = 0x00;
		938	dst [ 8] = 0x00; dst [ 9] = 0x00; dst [10] = 0xff; dst [11] = 0xff;
		939	dst [12] = pv [0]; dst [13] = pv [1]; dst [14] = pv [2]; dst [15] = pv [3];
		940	}
		941	else
		942	memcpy (dst, pv, addrlen);
636	}	943	}
637	}
638		944
639	if (res_av)	945	pinger_add_range (self, range);
640	feed_reply (res_av);
641	}	946	}
642		947

Diff Legend

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

Comparing AnyEvent-FastPing/FastPing.xs (file contents): Revision 1.7 by root, Sun Jan 16 17:05:32 2011 UTC vs. Revision 1.15 by root, Sat Nov 12 01:20:46 2016 UTC

Diff Legend

Comparing AnyEvent-FastPing/FastPing.xs (file contents):
Revision 1.7 by root, Sun Jan 16 17:05:32 2011 UTC vs.
Revision 1.15 by root, Sat Nov 12 01:20:46 2016 UTC