[ViewVC] Diff of: cvs/gvpe/src/vpn

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.10 by pcg, Fri Mar 4 08:15:04 2005 UTC vs.
Revision 1.47 by pcg, Thu Aug 7 17:54:27 2008 UTC

…		…
1	/*	1	/*
2	vpn_dns.C -- handle the dns tunnel part of the protocol.	2	vpn_dns.C -- handle the dns tunnel part of the protocol.
3	Copyright (C) 2003-2005 Marc Lehmann <gvpe@schmorp.de>	3	Copyright (C) 2003-2008 Marc Lehmann <gvpe@schmorp.de>
4		4
5	This file is part of GVPE.	5	This file is part of GVPE.
6		6
7	GVPE is free software; you can redistribute it and/or modify	7	GVPE is free software; you can redistribute it and/or modify it
8	it under the terms of the GNU General Public License as published by	8	under the terms of the GNU General Public License as published by the
9	the Free Software Foundation; either version 2 of the License, or	9	Free Software Foundation; either version 3 of the License, or (at your
10	(at your option) any later version.	10	option) any later version.
11		11
12	This program is distributed in the hope that it will be useful,	12	This program is distributed in the hope that it will be useful, but
13	but WITHOUT ANY WARRANTY; without even the implied warranty of	13	WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
15	GNU General Public License for more details.	15	Public License for more details.
16		16
17	You should have received a copy of the GNU General Public License	17	You should have received a copy of the GNU General Public License along
18	along with gvpe; if not, write to the Free Software	18	with this program; if not, see <http://www.gnu.org/licenses/>.
19	Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	19
		20	Additional permission under GNU GPL version 3 section 7
		21
		22	If you modify this Program, or any covered work, by linking or
		23	combining it with the OpenSSL project's OpenSSL library (or a modified
		24	version of that library), containing parts covered by the terms of the
		25	OpenSSL or SSLeay licenses, the licensors of this Program grant you
		26	additional permission to convey the resulting work. Corresponding
		27	Source for a non-source form of such a combination shall include the
		28	source code for the parts of OpenSSL used as well as that of the
		29	covered work.
20	*/	30	*/
		31
		32	// TODO: EDNS0 option to increase dns mtu?
		33	// TODO: re-write dns packet parsing/creation using a safe mem-buffer
		34	// to ensure no buffer overflows or similar problems.
21		35
22	#include "config.h"	36	#include "config.h"
23		37
24	#if ENABLE_DNS	38	#if ENABLE_DNS
25		39
26	// dns processing is EXTREMELY ugly. For obvious(?) reasons.	40	// dns processing is EXTREMELY ugly. For obvious(?) reasons.
27	// it's a hack, use only in emergency situations please.	41	// it's a hack, use only in emergency situations please.
28		42
29	#include <cstring>	43	#include <cstring>
		44	#include <cassert>
30		45
31	#include <sys/types.h>	46	#include <sys/types.h>
32	#include <sys/socket.h>	47	#include <sys/socket.h>
33	#include <sys/wait.h>	48	#include <sys/wait.h>
34	#include <sys/uio.h>	49	#include <sys/uio.h>
37	#include <unistd.h>	52	#include <unistd.h>
38	#include <fcntl.h>	53	#include <fcntl.h>
39		54
40	#include <map>	55	#include <map>
41		56
		57	#include <cstdio> /* bug in libgmp: gmp.h relies on cstdio being included */
42	#include <gmp.h>	58	#include <gmp.h>
43		59
44	#include "netcompat.h"	60	#include "netcompat.h"
45		61
46	#include "vpn.h"	62	#include "vpn.h"
47		63
48	#define MIN_POLL_INTERVAL .2 // how often to poll minimally when the server is having data
49	#define MAX_POLL_INTERVAL 6. // how often to poll minimally when the server has no data	64	#define MAX_POLL_INTERVAL 5. // how often to poll minimally when the server has no data
50	#define ACTIVITY_INTERVAL 5.	65	#define ACTIVITY_INTERVAL 5.
51		66
52	#define INITIAL_TIMEOUT 1.	67	#define INITIAL_TIMEOUT 0.1 // retry timeouts
53	#define INITIAL_SYN_TIMEOUT 2.	68	#define INITIAL_SYN_TIMEOUT 2. // retry timeout for initial syn
54		69
55	#define MIN_SEND_INTERVAL (1./1000.)
56	#define MAX_SEND_INTERVAL 0.5 // optimistic?	70	#define MAX_SEND_INTERVAL 2. // optimistic?
57		71
58	#define MAX_OUTSTANDING 400 // max. outstanding requests
59	#define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING	72	#define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING, and backlog
60	#define MAX_RATE 100 // requests/s
61	#define MAX_BACKLOG (100*1024) // size of protocol backlog, must be > MAXSIZE	73	#define MAX_BACKLOG (64*1024) // size of gvpe protocol backlog (bytes), must be > MAXSIZE
62		74
63	#define MAX_DOMAIN_SIZE 220 // 255 is legal limit, but bind doesn't compress well	75	#define MAX_DOMAIN_SIZE 240 // 255 is legal limit, but bind doesn't compress well
64	// 240 leaves about 4 bytes of server reply data	76	// 240 leaves about 4 bytes of server reply data
65	// every two request byte sless give room for one reply byte	77	// every request byte less give room for two reply bytes
66		78
67	#define SEQNO_MASK 0xffff	79	#define SEQNO_MASK 0x3fff
68	#define SEQNO_EQ(a,b) ( 0 == ( ((a) ^ (b)) & SEQNO_MASK) )	80	#define SEQNO_EQ(a,b) ( 0 == ( ((a) ^ (b)) & SEQNO_MASK) )
69		81
70	#define MAX_LBL_SIZE 63	82	#define MAX_LBL_SIZE 63
71	#define MAX_PKT_SIZE 512	83	#define MAX_PKT_SIZE 512
72		84
…		…
265	static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyO");	277	static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyO");
266		278
267	/////////////////////////////////////////////////////////////////////////////	279	/////////////////////////////////////////////////////////////////////////////
268		280
269	#define HDRSIZE 6	281	#define HDRSIZE 6
270		282
271	inline void encode_header (char *data, int clientid, int seqno)	283	inline void encode_header (char *data, int clientid, int seqno, int retry = 0)
272	{	284	{
273	u8 hdr[3] = { clientid, seqno >> 8, seqno };	285	seqno &= SEQNO_MASK;
		286
		287	u8 hdr[3] = {
		288	clientid,
		289	(seqno >> 8) \| (retry << 6),
		290	seqno,
		291	};
274		292
275	assert (clientid < 256);	293	assert (clientid < 256);
276		294
277	cdc26.encode (data, hdr, 3);	295	cdc26.encode (data, hdr, 3);
278	}	296	}
…		…
282	u8 hdr[3];	300	u8 hdr[3];
283		301
284	cdc26.decode (hdr, data, HDRSIZE);	302	cdc26.decode (hdr, data, HDRSIZE);
285		303
286	clientid = hdr[0];	304	clientid = hdr[0];
287	seqno = (hdr[1] << 8) \| hdr[2];	305	seqno = ((hdr[1] << 8) \| hdr[2]) & SEQNO_MASK;
288	}	306	}
289		307
290	/////////////////////////////////////////////////////////////////////////////	308	/////////////////////////////////////////////////////////////////////////////
291		309
292	struct byte_stream	310	struct byte_stream
…		…
321	}	339	}
322		340
323	void byte_stream::remove (int count)	341	void byte_stream::remove (int count)
324	{	342	{
325	if (count > fill)	343	if (count > fill)
326	abort ();	344	assert (count <= fill);
327		345
328	memmove (data, data + count, fill -= count);	346	memmove (data, data + count, fill -= count);
329	}	347	}
330		348
331	bool byte_stream::put (u8 *data, unsigned int datalen)	349	bool byte_stream::put (u8 *data, unsigned int datalen)
…		…
351	return true;	369	return true;
352	}	370	}
353		371
354	vpn_packet *byte_stream::get ()	372	vpn_packet *byte_stream::get ()
355	{	373	{
		374	unsigned int len;
		375
		376	for (;;)
		377	{
356	int len = (data [0] << 8) \| data [1];	378	len = (data [0] << 8) \| data [1];
357		379
358	if (len > MAXSIZE && fill >= 2)	380	if (len <= MAXSIZE \|\| fill < 2)
359	abort (); // TODO handle this gracefully, connection reset	381	break;
360		382
		383	// TODO: handle this better than skipping, e.g. by reset
		384	slog (L_DEBUG, _("DNS: corrupted packet stream skipping a byte..."));
		385	remove (1);
		386	}
		387
361	if (fill < len + 2)	388	if (fill < len + 2)
362	return 0;	389	return 0;
363		390
364	vpn_packet *pkt = new vpn_packet;	391	vpn_packet *pkt = new vpn_packet;
365		392
…		…
394	struct dns_cfg	421	struct dns_cfg
395	{	422	{
396	static int next_uid;	423	static int next_uid;
397		424
398	u8 id1, id2, id3, id4;	425	u8 id1, id2, id3, id4;
		426
399	u8 version;	427	u8 version;
		428	u8 flags;
400	u8 rrtype;	429	u8 rrtype;
401	u8 flags;
402	u8 def_ttl;	430	u8 def_ttl;
403	u8 rcv_cdc;	431
404	u8 snd_cdc;
405	u16 max_size;
406	u16 client;	432	u16 client;
407	u16 uid; // to make request unique	433	u16 uid; // to make request unique
408		434
409	u8 reserved[8];	435	u16 max_size;
		436	u8 seq_cdc;
		437	u8 req_cdc;
		438
		439	u8 rep_cdc;
		440	u8 delay; // time in 0.01s units that the server may delay replying packets
		441	u8 r3, r4;
		442
		443	u8 r5, r6, r7, r8;
410		444
411	void reset (int clientid);	445	void reset (int clientid);
412	bool valid ();	446	bool valid ();
413	};	447	};
414		448
…		…
424	version = 1;	458	version = 1;
425		459
426	rrtype = RR_TYPE_TXT;	460	rrtype = RR_TYPE_TXT;
427	flags = 0;	461	flags = 0;
428	def_ttl = 0;	462	def_ttl = 0;
		463	seq_cdc = 26;
		464	req_cdc = 62;
429	rcv_cdc = 0;	465	rep_cdc = 0;
430	snd_cdc = 62;
431	max_size = ntohs (MAX_PKT_SIZE);	466	max_size = htons (MAX_PKT_SIZE);
432	client = ntohs (clientid);	467	client = htons (clientid);
433	uid = next_uid++;	468	uid = next_uid++;
		469	delay = 0;
434		470
435	memset (reserved, 0, 8);	471	r3 = r4 = 0;
		472	r4 = r5 = r6 = r7 = 0;
436	}	473	}
437		474
438	bool dns_cfg::valid ()	475	bool dns_cfg::valid ()
439	{	476	{
		477	// although the protocol itself allows for some configurability,
		478	// only the following encoding/decoding settings are implemented.
440	return id1 == 'G'	479	return id1 == 'G'
441	&& id2 == 'V'	480	&& id2 == 'V'
442	&& id3 == 'P'	481	&& id3 == 'P'
443	&& id4 == 'E'	482	&& id4 == 'E'
		483	&& seq_cdc == 26
		484	&& req_cdc == 62
		485	&& rep_cdc == 0
444	&& version == 1	486	&& version == 1;
445	&& flags == 0
446	&& rcv_cdc == 0
447	&& snd_cdc == 62
448	&& max_size == ntohs (MAX_PKT_SIZE);
449	}	487	}
450		488
451	struct dns_packet : net_packet	489	struct dns_packet : net_packet
452	{	490	{
453	u16 id;	491	u16 id;
454	u16 flags; // QR:1 Opcode:4 AA:1 TC:1 RD:1 RA:1 Z:3 RCODE:4	492	u16 flags; // QR:1 Opcode:4 AA:1 TC:1 RD:1 RA:1 Z:3 RCODE:4
455	u16 qdcount, ancount, nscount, arcount;	493	u16 qdcount, ancount, nscount, arcount;
456		494
457	u8 data[MAXSIZE - 6 * 2];	495	u8 data [MAXSIZE - 6 * 2];
458		496
459	int decode_label (char *data, int size, int &offs);	497	int decode_label (char *data, int size, int &offs);
460	};	498	};
461		499
462	int dns_packet::decode_label (char *data, int size, int &offs)	500	int dns_packet::decode_label (char *data, int size, int &offs)
…		…
493	return data - orig;	531	return data - orig;
494	}	532	}
495		533
496	/////////////////////////////////////////////////////////////////////////////	534	/////////////////////////////////////////////////////////////////////////////
497		535
498	struct dns_snd
499	{
500	dns_packet *pkt;
501	tstamp timeout, sent;
502	int retry;
503	struct dns_connection *dns;
504	int seqno;
505
506	dns_snd (dns_connection *dns);
507	void gen_stream_req (int seqno, byte_stream &stream);
508	void gen_syn_req (const dns_cfg &cfg);
509	};
510
511	static u16 dns_id = 12098; // TODO: should be per-vpn	536	static u16 dns_id = 0; // TODO: should be per-vpn
512		537
513	static u16 next_id ()	538	static u16 next_id ()
514	{	539	{
		540	if (!dns_id)
		541	dns_id = time (0);
		542
515	// the simplest lsfr with periodicity 65535 i could find	543	// the simplest lsfr with periodicity 65535 i could find
516	dns_id = (dns_id << 1)	544	dns_id = (dns_id << 1)
517	\| (((dns_id >> 1)	545	\| (((dns_id >> 1)
518	^ (dns_id >> 2)	546	^ (dns_id >> 2)
519	^ (dns_id >> 4)	547	^ (dns_id >> 4)
520	^ (dns_id >> 15)) & 1);	548	^ (dns_id >> 15)) & 1);
521		549
522	return dns_id;	550	return dns_id;
523	}	551	}
524		552
		553	struct dns_rcv;
		554	struct dns_snd;
		555
		556	struct dns_connection
		557	{
		558	connection *c;
		559	struct vpn *vpn;
		560
		561	dns_cfg cfg;
		562
		563	bool established;
		564
		565	tstamp last_received;
		566	tstamp last_sent;
		567	double min_latency;
		568	double poll_interval, send_interval;
		569
		570	vector<dns_rcv *> rcvpq;
		571
		572	byte_stream rcvdq; int rcvseq; int repseq;
		573	byte_stream snddq; int sndseq;
		574
		575	inline void time_cb (ev::timer &w, int revents); ev::timer tw;
		576	void receive_rep (dns_rcv *r);
		577
		578	dns_connection (connection *c);
		579	~dns_connection ();
		580	};
		581
		582	struct dns_snd
		583	{
		584	dns_packet *pkt;
		585	tstamp timeout, sent;
		586	int retry;
		587	struct dns_connection *dns;
		588	int seqno;
		589	bool stdhdr;
		590
		591	void gen_stream_req (int seqno, byte_stream &stream);
		592	void gen_syn_req ();
		593
		594	dns_snd (dns_connection *dns);
		595	~dns_snd ();
		596	};
		597
525	dns_snd::dns_snd (dns_connection *dns)	598	dns_snd::dns_snd (dns_connection *dns)
526	: dns (dns)	599	: dns (dns)
527	{	600	{
528	timeout = 0;	601	timeout = 0;
529	retry = 0;	602	retry = 0;
530	seqno = 0;	603	seqno = 0;
		604	sent = ev_now ();
		605	stdhdr = false;
531		606
532	pkt = new dns_packet;	607	pkt = new dns_packet;
533		608
534	pkt->id = next_id ();	609	pkt->id = next_id ();
		610	}
		611
		612	dns_snd::~dns_snd ()
		613	{
		614	delete pkt;
535	}	615	}
536		616
537	static void append_domain (dns_packet &pkt, int &offs, const char *domain)	617	static void append_domain (dns_packet &pkt, int &offs, const char *domain)
538	{	618	{
539	// add tunnel domain	619	// add tunnel domain
…		…
557	}	637	}
558	}	638	}
559		639
560	void dns_snd::gen_stream_req (int seqno, byte_stream &stream)	640	void dns_snd::gen_stream_req (int seqno, byte_stream &stream)
561	{	641	{
		642	stdhdr = true;
562	this->seqno = seqno;	643	this->seqno = seqno;
563		644
564	timeout = NOW + INITIAL_TIMEOUT;	645	timeout = ev_now () + INITIAL_TIMEOUT;
565		646
566	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);	647	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
567	pkt->qdcount = htons (1);	648	pkt->qdcount = htons (1);
568		649
569	int offs = 6*2;	650	int offs = 6*2;
570	int dlen = MAX_DOMAIN_SIZE - (strlen (THISNODE->domain) + 2);	651	int dlen = MAX_DOMAIN_SIZE - (strlen (dns->c->conf->domain) + 2);
571	// MAX_DOMAIN_SIZE is technically 255, but bind doesn't compress responses well,	652	// MAX_DOMAIN_SIZE is technically 255, but bind doesn't compress responses well,
572	// so we need to have space for 2*MAX_DOMAIN_SIZE + header + extra	653	// so we need to have space for 2*MAX_DOMAIN_SIZE + header + extra
573		654
574	char enc[256], *encp = enc;	655	char enc[256], *encp = enc;
575	encode_header (enc, THISNODE->id, seqno);	656	encode_header (enc, THISNODE->id, seqno);
…		…
593	encp += lbllen;	674	encp += lbllen;
594		675
595	enclen -= lbllen;	676	enclen -= lbllen;
596	}	677	}
597		678
598	append_domain (*pkt, offs, THISNODE->domain);	679	append_domain (*pkt, offs, dns->c->conf->domain);
599		680
600	(*pkt)[offs++] = 0;	681	(*pkt)[offs++] = 0;
601	(pkt)[offs++] = RR_TYPE_ANY >> 8; (pkt)[offs++] = RR_TYPE_ANY;	682	(pkt)[offs++] = RR_TYPE_ANY >> 8; (pkt)[offs++] = RR_TYPE_ANY;
602	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;	683	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;
603		684
604	pkt->len = offs;	685	pkt->len = offs;
605	}	686	}
606		687
607	void dns_snd::gen_syn_req (const dns_cfg &cfg)	688	void dns_snd::gen_syn_req ()
608	{	689	{
609	timeout = NOW + INITIAL_SYN_TIMEOUT;	690	timeout = ev_now () + INITIAL_SYN_TIMEOUT;
610		691
611	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);	692	pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
612	pkt->qdcount = htons (1);	693	pkt->qdcount = htons (1);
613		694
614	int offs = 6*2;	695	int offs = 6 * 2;
615		696
616	int elen = cdc26.encode ((char )pkt->at (offs + 1), (u8 )&cfg, sizeof (dns_cfg));	697	int elen = cdc26.encode ((char )pkt->at (offs + 1), (u8 )&dns->cfg, sizeof (dns_cfg));
617		698
618	assert (elen <= MAX_LBL_SIZE);	699	assert (elen <= MAX_LBL_SIZE);
619		700
620	(*pkt)[offs] = elen;	701	(*pkt)[offs] = elen;
621	offs += elen + 1;	702	offs += elen + 1;
622	append_domain (*pkt, offs, THISNODE->domain);	703	append_domain (*pkt, offs, dns->c->conf->domain);
623		704
624	(*pkt)[offs++] = 0;	705	(*pkt)[offs++] = 0;
625	(pkt)[offs++] = RR_TYPE_A >> 8; (pkt)[offs++] = RR_TYPE_A;	706	(pkt)[offs++] = RR_TYPE_A >> 8; (pkt)[offs++] = RR_TYPE_A;
626	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;	707	(pkt)[offs++] = RR_CLASS_IN >> 8; (pkt)[offs++] = RR_CLASS_IN;
627		708
…		…
650	delete pkt;	731	delete pkt;
651	}	732	}
652		733
653	/////////////////////////////////////////////////////////////////////////////	734	/////////////////////////////////////////////////////////////////////////////
654		735
655	struct dns_connection
656	{
657	connection *c;
658	struct vpn *vpn;
659
660	dns_cfg cfg;
661
662	bool established;
663
664	tstamp last_received;
665	tstamp last_sent;
666	double poll_interval, send_interval;
667
668	vector<dns_rcv *> rcvpq;
669
670	byte_stream rcvdq; int rcvseq;
671	byte_stream snddq; int sndseq;
672
673	void time_cb (time_watcher &w); time_watcher tw;
674	void receive_rep (dns_rcv *r);
675
676	dns_connection (connection *c);
677	~dns_connection ();
678	};
679
680	dns_connection::dns_connection (connection *c)	736	dns_connection::dns_connection (connection *c)
681	: c (c)	737	: c (c)
682	, rcvdq (MAX_BACKLOG * 2)	738	, rcvdq (MAX_BACKLOG * 2)
683	, snddq (MAX_BACKLOG * 2)	739	, snddq (MAX_BACKLOG)
684	, tw (this, &dns_connection::time_cb)
685	{	740	{
		741	tw.set<dns_connection, &dns_connection::time_cb> (this);
		742
686	vpn = c->vpn;	743	vpn = c->vpn;
687		744
688	established = false;	745	established = false;
689		746
690	rcvseq = sndseq = 0;	747	rcvseq = repseq = sndseq = 0;
691		748
692	last_sent = last_received = 0;	749	last_sent = last_received = 0;
693	poll_interval = MIN_POLL_INTERVAL;	750	poll_interval = 0.5; // starting here
694	send_interval = 0.2; // starting rate	751	send_interval = 0.5; // starting rate
		752	min_latency = INITIAL_TIMEOUT;
695	}	753	}
696		754
697	dns_connection::~dns_connection ()	755	dns_connection::~dns_connection ()
698	{	756	{
699	for (vector<dns_rcv *>::iterator i = rcvpq.begin ();	757	for (vector<dns_rcv *>::iterator i = rcvpq.begin ();
…		…
704		762
705	void dns_connection::receive_rep (dns_rcv *r)	763	void dns_connection::receive_rep (dns_rcv *r)
706	{	764	{
707	if (r->datalen)	765	if (r->datalen)
708	{	766	{
709	last_received = NOW;	767	last_received = ev_now ();
710	tw.trigger ();	768	tw ();
711		769
712	poll_interval *= 0.99;	770	poll_interval = send_interval;
713	if (poll_interval > MIN_POLL_INTERVAL)
714	poll_interval = MIN_POLL_INTERVAL;
715	}	771	}
716	else	772	else
717	{	773	{
718	poll_interval *= 1.1;	774	poll_interval *= 1.5;
		775
719	if (poll_interval > MAX_POLL_INTERVAL)	776	if (poll_interval > MAX_POLL_INTERVAL)
720	poll_interval = MAX_POLL_INTERVAL;	777	poll_interval = MAX_POLL_INTERVAL;
721	}	778	}
722		779
723	rcvpq.push_back (r);	780	rcvpq.push_back (r);
…		…
726		783
727	// find next packet	784	// find next packet
728	for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )	785	for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )
729	if (SEQNO_EQ (rcvseq, (*i)->seqno))	786	if (SEQNO_EQ (rcvseq, (*i)->seqno))
730	{	787	{
		788	//printf ("seqno eq %x %x\n", rcvseq, (*i)->seqno);//D
731	// enter the packet into our input stream	789	// enter the packet into our input stream
732	r = *i;	790	r = *i;
733		791
734	// remove the oldest packet, look forward, as it's oldest first	792	// remove the oldest packet, look forward, as it's oldest first
735	for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)	793	for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)
736	if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))	794	if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))
737	{	795	{
		796	//printf ("seqno RR %x %x\n", (*j)->seqno, rcvseq - MAX_WINDOW);//D
738	delete *j;	797	delete *j;
739	rcvpq.erase (j);	798	rcvpq.erase (j);
740	break;	799	break;
741	}	800	}
742		801
743	rcvseq = (rcvseq + 1) & SEQNO_MASK;	802	rcvseq = (rcvseq + 1) & SEQNO_MASK;
744		803
745	if (!rcvdq.put (r->data, r->datalen))	804	if (!rcvdq.put (r->data, r->datalen))
		805	{
		806	slog (L_ERR, "DNS: !rcvdq.put (r->data, r->datalen)");
746	abort (); // MUST never overflow, can be caused by data corruption, TODO	807	abort (); // MUST never overflow, can be caused by data corruption, TODO
		808	}
747		809
748	while (vpn_packet *pkt = rcvdq.get ())	810	while (vpn_packet *pkt = rcvdq.get ())
749	{	811	{
750	sockinfo si;	812	sockinfo si;
751	si.host = 0; si.port = 0; si.prot = PROT_DNSv4;	813	si.host = htonl (c->conf->id); si.port = 0; si.prot = PROT_DNSv4;
752		814
753	vpn->recv_vpn_packet (pkt, si);	815	vpn->recv_vpn_packet (pkt, si);
		816
		817	delete pkt;
754	}	818	}
755		819
756	// check for further packets	820	// check for further packets
757	goto redo;	821	goto redo;
758	}	822	}
…		…
768	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);	832	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);
769		833
770	if (0 == (flags & (FLAG_RESPONSE \| FLAG_OP_MASK))	834	if (0 == (flags & (FLAG_RESPONSE \| FLAG_OP_MASK))
771	&& pkt.qdcount == htons (1))	835	&& pkt.qdcount == htons (1))
772	{	836	{
773	char qname[MAXSIZE];	837	char qname [MAXSIZE];
774	int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);	838	int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);
775		839
776	u16 qtype = pkt [offs++] << 8; qtype \|= pkt [offs++];	840	u16 qtype = pkt [offs++] << 8; qtype \|= pkt [offs++];
777	u16 qclass = pkt [offs++] << 8; qclass \|= pkt [offs++];	841	u16 qclass = pkt [offs++] << 8; qclass \|= pkt [offs++];
778		842
779	pkt.qdcount = htons (1);	843	pkt.qdcount = htons (1);
780	pkt.ancount = 0;	844	pkt.ancount = 0;
781	pkt.nscount = 0; // should be self, as other nameservers reply like this	845	pkt.nscount = 0; // should be self, as other nameservers reply like this
782	pkt.arcount = 0; // a record for self, as other nameservers reply like this	846	pkt.arcount = 0; // a record for self, as other nameservers reply like this
783		847
784	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_NXDOMAIN);	848	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_SERVFAIL);
785		849
786	int dlen = strlen (THISNODE->domain);	850	int dlen = strlen (THISNODE->domain);
787		851
788	if (qclass == RR_CLASS_IN	852	if (qclass == RR_CLASS_IN
789	&& qlen > dlen + 1	853	&& qlen > dlen + 1
790	&& !memcmp (qname + qlen - dlen - 1, THISNODE->domain, dlen))	854	&& !memcmp (qname + qlen - (dlen + 1), THISNODE->domain, dlen))
791	{	855	{
792	// now generate reply	856	// now generate reply
793	pkt.ancount = htons (1); // one answer RR	857	pkt.ancount = htons (1); // one answer RR
794	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_OK);	858	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_OK);
795		859
…		…
817	if (SEQNO_EQ ((*i)->seqno, seqno))	881	if (SEQNO_EQ ((*i)->seqno, seqno))
818	{	882	{
819	// already seen that request: simply reply with the cached reply	883	// already seen that request: simply reply with the cached reply
820	dns_rcv r = i;	884	dns_rcv r = i;
821		885
822	printf ("DUPLICATE %d\n", htons (r->pkt->id));//D	886	slog (L_DEBUG, "DNS: duplicate packet received ID %d, SEQ %d", htons (r->pkt->id), seqno);
		887
		888	// refresh header & id, as the retry count could have changed
		889	memcpy (r->pkt->at (6 * 2 + 1), pkt.at (6 * 2 + 1), HDRSIZE);
		890	r->pkt->id = pkt.id;
823		891
824	memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len);	892	memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len);
825	pkt.id = r->pkt->id;	893
826	goto duplicate_request;	894	goto duplicate_request;
827	}	895	}
828		896
829	// new packet, queue	897	// new packet, queue
830	rcv = new dns_rcv (seqno, data, datalen);	898	rcv = new dns_rcv (seqno, data, datalen);
831	dns->receive_rep (rcv);	899	dns->receive_rep (rcv);
832	}	900	}
833		901
		902	{
834	pkt [offs++] = 0xc0; pkt [offs++] = 6 * 2; // refer to name in query section	903	pkt [offs++] = 0xc0; pkt [offs++] = 6 * 2; // refer to name in query section
835		904
836	// type
837	int rtype = dns ? dns->cfg.rrtype : RR_TYPE_A;	905	int rtype = dns ? dns->cfg.rrtype : RR_TYPE_A;
838	pkt [offs++] = rtype >> 8; pkt [offs++] = rtype;	906	pkt [offs++] = rtype >> 8; pkt [offs++] = rtype; // type
839
840	// class
841	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN;	907	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
842
843	// TTL
844	pkt [offs++] = 0; pkt [offs++] = 0;	908	pkt [offs++] = 0; pkt [offs++] = 0;
845	pkt [offs++] = 0; pkt [offs++] = dns ? dns->cfg.def_ttl : 0;	909	pkt [offs++] = 0; pkt [offs++] = dns ? dns->cfg.def_ttl : 0; // TTL
846		910
847	int rdlen_offs = offs += 2;	911	int rdlen_offs = offs += 2;
848		912
		913	if (dns)
		914	{
849	int dlen = (dns ? ntohs (dns->cfg.max_size) : MAX_PKT_SIZE) - offs;	915	int dlen = ntohs (dns->cfg.max_size) - offs;
		916
850	// bind doesn't compress well, so reduce further by one label length	917	// bind doesn't compress well, so reduce further by one label length
851	dlen -= qlen;	918	dlen -= qlen;
852		919
853	if (dns)	920	// only put data into in-order sequence packets, if
854	{	921	// we receive out-of-order packets we generate empty
855	while (dlen > 1 && !dns->snddq.empty ())	922	// replies
		923	//printf ("%d - %d & %x (=%d) < %d\n", seqno, dns->repseq, SEQNO_MASK, (seqno - dns->repseq) & SEQNO_MASK, MAX_WINDOW);//D
		924	if (((seqno - dns->repseq) & SEQNO_MASK) <= MAX_WINDOW)
856	{	925	{
		926	dns->repseq = seqno;
		927
		928	while (dlen > 1 && !dns->snddq.empty ())
		929	{
857	int txtlen = dlen <= 255 ? dlen - 1 : 255;	930	int txtlen = dlen <= 255 ? dlen - 1 : 255;
858		931
859	if (txtlen > dns->snddq.size ())	932	if (txtlen > dns->snddq.size ())
860	txtlen = dns->snddq.size ();	933	txtlen = dns->snddq.size ();
861		934
862	pkt[offs++] = txtlen;	935	pkt[offs++] = txtlen;
863	memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);	936	memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);
864	offs += txtlen;	937	offs += txtlen;
865	dns->snddq.remove (txtlen);	938	dns->snddq.remove (txtlen);
866		939
867	dlen -= txtlen + 1;	940	dlen -= txtlen + 1;
		941	}
868	}	942	}
869		943
870	// avoid empty TXT rdata	944	// avoid completely empty TXT rdata
871	if (offs == rdlen_offs)	945	if (offs == rdlen_offs)
872	pkt[offs++] = 0;	946	pkt[offs++] = 0;
		947
		948	slog (L_NOISE, "DNS: snddq %d", dns->snddq.size ());
873	}	949	}
874	else	950	else
875	{	951	{
876	// send RST	952	// send RST
877	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;	953	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
878	pkt [offs++] = CMD_IP_RST;	954	pkt [offs++] = CMD_IP_RST;
879	}	955	}
880		956
881	int rdlen = offs - rdlen_offs;	957	int rdlen = offs - rdlen_offs;
882		958
883	pkt [rdlen_offs - 2] = rdlen >> 8;	959	pkt [rdlen_offs - 2] = rdlen >> 8;
884	pkt [rdlen_offs - 1] = rdlen;	960	pkt [rdlen_offs - 1] = rdlen;
885		961
886	if (dns)	962	if (dns)
887	{	963	{
888	// now update dns_rcv copy	964	// now update dns_rcv copy
889	rcv->pkt->len = offs;	965	rcv->pkt->len = offs;
890	memcpy (rcv->pkt->at (0), pkt.at (0), offs);	966	memcpy (rcv->pkt->at (0), pkt.at (0), offs);
891	}	967	}
		968	}
892		969
893	duplicate_request: ;	970	duplicate_request: ;
894	}	971	}
895	else	972	else
896	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);	973	pkt.flags = htons (DEFAULT_SERVER_FLAGS \| FLAG_RCODE_FORMERR);
…		…
908	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class	985	pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
909	pkt [offs++] = 0; pkt [offs++] = 0;	986	pkt [offs++] = 0; pkt [offs++] = 0;
910	pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL	987	pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL
911	pkt [offs++] = 0; pkt [offs++] = 4; // rdlength	988	pkt [offs++] = 0; pkt [offs++] = 4; // rdlength
912		989
913	slog (L_INFO, _("DNS tunnel: client %d tries to connect"), client);	990	slog (L_INFO, _("DNS: client %d connects"), client);
914		991
915	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;	992	pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
916	pkt [offs++] = CMD_IP_REJ;	993	pkt [offs++] = CMD_IP_REJ;
917		994
918	if (0 < client && client <= conns.size ())	995	if (0 < client && client <= conns.size ())
…		…
949	i != dns_sndpq.end ();	1026	i != dns_sndpq.end ();
950	++i)	1027	++i)
951	if ((*i)->pkt->id == pkt.id)	1028	if ((*i)->pkt->id == pkt.id)
952	{	1029	{
953	dns_connection dns = (i)->dns;	1030	dns_connection dns = (i)->dns;
		1031	connection *c = dns->c;
954	int seqno = (*i)->seqno;	1032	int seqno = (*i)->seqno;
955	u8 data[MAXSIZE], *datap = data;	1033	u8 data[MAXSIZE], *datap = data;
		1034	//printf ("rcv pkt %x\n", seqno);//D
956		1035
957	if ((*i)->retry)	1036	if ((*i)->retry)
958	{	1037	{
959	dns->send_interval *= 1.01;	1038	dns->send_interval *= 1.01;
960	if (dns->send_interval < MAX_SEND_INTERVAL)	1039	if (dns->send_interval > MAX_SEND_INTERVAL)
961	dns->send_interval = MAX_SEND_INTERVAL;	1040	dns->send_interval = MAX_SEND_INTERVAL;
962	}	1041	}
963	else	1042	else
964	{	1043	{
		1044	#if 0
965	dns->send_interval *= 0.99;	1045	dns->send_interval *= 0.999;
966	if (dns->send_interval < MIN_SEND_INTERVAL)	1046	#endif
967	dns->send_interval = MIN_SEND_INTERVAL;
968
969	// the latency surely puts an upper bound on	1047	// the latency surely puts an upper bound on
970	// the minimum send interval	1048	// the minimum send interval
971	if (dns->send_interval > NOW - (*i)->sent)	1049	double latency = ev_now () - (*i)->sent;
972	dns->send_interval = NOW - (*i)->sent;	1050
		1051	if (latency < dns->min_latency)
		1052	dns->min_latency = latency;
		1053
		1054	if (dns->send_interval > dns->min_latency * conf.dns_overlap_factor)
		1055	dns->send_interval = dns->min_latency * conf.dns_overlap_factor;
		1056
		1057	if (dns->send_interval < conf.dns_send_interval)
		1058	dns->send_interval = conf.dns_send_interval;
973	}	1059	}
974		1060
975	delete *i;	1061	delete *i;
976	dns_sndpq.erase (i);	1062	dns_sndpq.erase (i);
977		1063
…		…
1027		1113
1028	if (ip [0] == CMD_IP_1	1114	if (ip [0] == CMD_IP_1
1029	&& ip [1] == CMD_IP_2	1115	&& ip [1] == CMD_IP_2
1030	&& ip [2] == CMD_IP_3)	1116	&& ip [2] == CMD_IP_3)
1031	{	1117	{
1032	slog (L_TRACE, _("got tunnel meta command %02x"), ip [3]);	1118	slog (L_TRACE, _("DNS: got tunnel meta command %02x"), ip [3]);
1033		1119
1034	if (ip [3] == CMD_IP_RST)	1120	if (ip [3] == CMD_IP_RST)
1035	{	1121	{
1036	slog (L_DEBUG, _("got tunnel RST request"));	1122	slog (L_DEBUG, _("DNS: got tunnel RST request"));
1037		1123
1038	connection *c = dns->c;
1039	delete c->dns; c->dns = 0;	1124	delete dns; c->dns = 0;
1040		1125
1041	return;	1126	return;
1042	}	1127	}
1043	else if (ip [3] == CMD_IP_SYN)	1128	else if (ip [3] == CMD_IP_SYN)
		1129	{
		1130	slog (L_DEBUG, _("DNS: got tunnel SYN reply, server likes us."));
1044	dns->established = true;	1131	dns->established = true;
		1132	}
		1133	else if (ip [3] == CMD_IP_REJ)
		1134	{
		1135	slog (L_DEBUG, _("DNS: got tunnel REJ reply, server does not like us, aborting."));
		1136	abort ();
		1137	}
1045	else	1138	else
1046	slog (L_INFO, _("got unknown meta command %02x"), ip [3]);	1139	slog (L_INFO, _("DNS: got unknown meta command %02x"), ip [3]);
1047	}	1140	}
1048	else	1141	else
1049	slog (L_INFO, _("got spurious a record %d.%d.%d.%d"),	1142	slog (L_INFO, _("DNS: got spurious a record %d.%d.%d.%d"),
1050	ip [0], ip [1], ip [2], ip [3]);	1143	ip [0], ip [1], ip [2], ip [3]);
1051		1144
1052	return;	1145	return;
1053	}	1146	}
1054		1147
1055	int client, rseqno;	1148	int client, rseqno;
1056	decode_header (qname, client, rseqno);	1149	decode_header (qname, client, rseqno);
1057		1150
1058	if (client != THISNODE->id)	1151	if (client != THISNODE->id)
1059	{	1152	{
1060	slog (L_INFO, _("got dns tunnel response with wrong clientid, ignoring"));	1153	slog (L_INFO, _("DNS: got dns tunnel response with wrong clientid, ignoring"));
1061	datap = 0;	1154	datap = 0;
1062	}	1155	}
1063	else if (rseqno != seqno)	1156	else if (rseqno != seqno)
1064	{	1157	{
1065	slog (L_DEBUG, _("got dns tunnel response with wrong seqno, badly caching nameserver?"));	1158	slog (L_DEBUG, _("DNS: got dns tunnel response with wrong seqno, badly caching nameserver?"));
1066	datap = 0;	1159	datap = 0;
1067	}	1160	}
1068	}	1161	}
1069	}	1162	}
1070		1163
…		…
1075	break;	1168	break;
1076	}	1169	}
1077	}	1170	}
1078		1171
1079	void	1172	void
1080	vpn::dnsv4_ev (io_watcher &w, short revents)	1173	vpn::dnsv4_ev (ev::io &w, int revents)
1081	{	1174	{
1082	if (revents & EVENT_READ)	1175	if (revents & EV_READ)
1083	{	1176	{
1084	dns_packet *pkt = new dns_packet;	1177	dns_packet *pkt = new dns_packet;
1085	struct sockaddr_in sa;	1178	struct sockaddr_in sa;
1086	socklen_t sa_len = sizeof (sa);	1179	socklen_t sa_len = sizeof (sa);
1087		1180
1088	pkt->len = recvfrom (w.fd, pkt->at (0), MAXSIZE, 0, (sockaddr *)&sa, &sa_len);	1181	pkt->len = recvfrom (w.fd, pkt->at (0), MAXSIZE, 0, (sockaddr *)&sa, &sa_len);
1089		1182
1090	if (pkt->len > 0)	1183	if (pkt->len > 0)
1091	{	1184	{
1092	if (THISNODE->dns_port)	1185	if (ntohs (pkt->flags) & FLAG_RESPONSE)
		1186	dnsv4_client (*pkt);
		1187	else
1093	{	1188	{
1094	dnsv4_server (*pkt);	1189	dnsv4_server (*pkt);
1095	sendto (w.fd, pkt->at (0), pkt->len, 0, (sockaddr *)&sa, sa_len);	1190	sendto (w.fd, pkt->at (0), pkt->len, 0, (sockaddr *)&sa, sa_len);
1096	}	1191	}
1097	else
1098	dnsv4_client (*pkt);
1099		1192
1100	delete pkt;	1193	delete pkt;
1101	}	1194	}
1102	}	1195	}
1103	}	1196	}
1104		1197
1105	bool	1198	bool
1106	connection::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)	1199	vpn::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)
1107	{	1200	{
		1201	int client = ntohl (si.host);
		1202
		1203	assert (0 < client && client <= conns.size ());
		1204
		1205	connection *c = conns [client - 1];
		1206
1108	if (!dns)	1207	if (!c->dns)
1109	dns = new dns_connection (this);	1208	c->dns = new dns_connection (c);
1110		1209
1111	if (!dns->snddq.put (pkt))	1210	if (c->dns->snddq.put (pkt))
1112	return false;	1211	c->dns->tw ();
1113		1212
1114	dns->tw.trigger ();	1213	// always return true even if the buffer overflows
1115
1116	return true;	1214	return true;
1117	}	1215	}
1118		1216
		1217	void
		1218	connection::dnsv4_reset_connection ()
		1219	{
		1220	//delete dns; dns = 0; //TODO
		1221	}
		1222
1119	#define NEXT(w) do { if (next > (w)) next = w; } while (0)	1223	#define NEXT(w) do { if (next > (w)) next = w; } while (0)
1120		1224
1121	void	1225	void
1122	dns_connection::time_cb (time_watcher &w)	1226	dns_connection::time_cb (ev::timer &w, int revents)
1123	{	1227	{
1124	// servers have to be polled	1228	// servers have to be polled
1125	if (THISNODE->dns_port)	1229	if (THISNODE->dns_port)
1126	return;	1230	return;
1127		1231
1128	// check for timeouts and (re)transmit	1232	// check for timeouts and (re)transmit
1129	tstamp next = NOW + poll_interval;	1233	tstamp next = ev::now () + poll_interval;
1130	dns_snd *send = 0;	1234	dns_snd *send = 0;
1131		1235
1132	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();	1236	for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();
1133	i != vpn->dns_sndpq.end ();	1237	i != vpn->dns_sndpq.end ();
1134	++i)	1238	++i)
1135	{	1239	{
1136	dns_snd r = i;	1240	dns_snd r = i;
1137		1241
1138	if (r->timeout <= NOW)	1242	if (r->timeout <= ev_now ())
1139	{	1243	{
1140	if (!send)	1244	if (!send)
1141	{	1245	{
1142	send = r;	1246	send = r;
1143		1247
1144	r->retry++;	1248	r->retry++;
1145	r->timeout = NOW + r->retry;	1249	r->timeout = ev_now () + (r->retry * min_latency * conf.dns_timeout_factor);
		1250	//printf ("RETRY %x (%d, %f)\n", r->seqno, r->retry, r->timeout - ev_now ());//D
		1251
		1252	// the following code changes the query section a bit, forcing
		1253	// the forwarder to generate a new request
		1254	if (r->stdhdr)
		1255	encode_header ((char )r->pkt->at (6 2 + 1), THISNODE->id, r->seqno, r->retry);
1146	}	1256	}
1147	}	1257	}
1148	else if (r->timeout < next)	1258	else
1149	NEXT (r->timeout);	1259	NEXT (r->timeout);
1150	}	1260	}
1151		1261
1152	if (last_sent + send_interval <= NOW)
1153	{
1154	if (!send)	1262	if (!send)
		1263	{
		1264	// generate a new packet, if wise
		1265
		1266	if (!established)
1155	{	1267	{
1156	// generate a new packet, if wise
1157
1158	if (!established)
1159	{
1160	if (vpn->dns_sndpq.empty ())	1268	if (vpn->dns_sndpq.empty ())
1161	{
1162	send = new dns_snd (this);
1163
1164	cfg.reset (THISNODE->id);
1165	send->gen_syn_req (cfg);
1166	}
1167	}
1168	else if (vpn->dns_sndpq.size () < MAX_OUTSTANDING)
1169	{	1269	{
1170	send = new dns_snd (this);	1270	send = new dns_snd (this);
		1271
		1272	cfg.reset (THISNODE->id);
		1273	send->gen_syn_req ();
		1274	}
		1275	}
		1276	else if (vpn->dns_sndpq.size () < conf.dns_max_outstanding
		1277	&& !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))
		1278	{
		1279	if (last_sent + send_interval <= ev_now ())
		1280	{
		1281	//printf ("sending data request etc.\n"); //D
		1282	if (!snddq.empty () \|\| last_received + 1. > ev_now ())
		1283	{
		1284	poll_interval = send_interval;
		1285	NEXT (ev_now () + send_interval);
		1286	}
		1287
		1288	send = new dns_snd (this);
1171	send->gen_stream_req (sndseq, snddq);	1289	send->gen_stream_req (sndseq, snddq);
		1290	send->timeout = ev_now () + min_latency * conf.dns_timeout_factor;
		1291	//printf ("SEND %x (%f)\n", send->seqno, send->timeout - ev_now (), min_latency, conf.dns_timeout_factor);//D
1172		1292
1173	sndseq = (sndseq + 1) & SEQNO_MASK;	1293	sndseq = (sndseq + 1) & SEQNO_MASK;
1174	}	1294	}
1175		1295	else
1176	if (send)	1296	NEXT (last_sent + send_interval);
1177	vpn->dns_sndpq.push_back (send);
1178	}	1297	}
1179		1298
1180	if (send)	1299	if (send)
1181	{	1300	vpn->dns_sndpq.push_back (send);
1182	printf ("send pkt\n");	1301	}
1183	last_sent = NOW;
1184		1302
1185	if (!send->retry)	1303	if (send)
1186	send->sent = NOW;	1304	{
1187		1305	last_sent = ev_now ();
1188	sendto (vpn->dnsv4_fd,	1306	sendto (vpn->dnsv4_fd,
1189	send->pkt->at (0), send->pkt->len, 0,	1307	send->pkt->at (0), send->pkt->len, 0,
1190	vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());	1308	vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());
1191	}
1192	}	1309	}
1193	else
1194	NEXT (last_sent + send_interval);
1195		1310
1196	printf ("pi %f si %f N %f (%d:%d)\n", poll_interval, send_interval, next - NOW, vpn->dns_sndpq.size (), snddq.size ());	1311	slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)",
		1312	poll_interval, send_interval, next - ev_now (),
		1313	vpn->dns_sndpq.size (), snddq.size (),
		1314	rcvpq.size ());
1197		1315
1198	w.start (next);	1316	// TODO: no idea when this happens, but when next < ev_now (), we have a problem
		1317	// doesn't seem to happen anymore
		1318	if (next < ev_now () + 0.001)
		1319	next = ev_now () + 0.1;
		1320
		1321	w.start (next - ev_now ());
1199	}	1322	}
1200		1323
1201	#endif	1324	#endif
1202		1325

Diff Legend

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

Comparing gvpe/src/vpn_dns.C (file contents): Revision 1.10 by pcg, Fri Mar 4 08:15:04 2005 UTC vs. Revision 1.47 by pcg, Thu Aug 7 17:54:27 2008 UTC

Diff Legend

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.10 by pcg, Fri Mar 4 08:15:04 2005 UTC vs.
Revision 1.47 by pcg, Thu Aug 7 17:54:27 2008 UTC