ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/gvpe/src/vpn_dns.C
Revision: 1.27
Committed: Sat Mar 12 18:10:40 2005 UTC (19 years, 2 months ago) by pcg
Content type: text/plain
Branch: MAIN
Changes since 1.26: +19 -18 lines
Log Message:
*** empty log message ***

File Contents

# User Rev Content
1 pcg 1.1 /*
2     vpn_dns.C -- handle the dns tunnel part of the protocol.
3 pcg 1.7 Copyright (C) 2003-2005 Marc Lehmann <gvpe@schmorp.de>
4 pcg 1.1
5 pcg 1.7 This file is part of GVPE.
6    
7     GVPE is free software; you can redistribute it and/or modify
8 pcg 1.1 it under the terms of the GNU General Public License as published by
9     the Free Software Foundation; either version 2 of the License, or
10     (at your option) any later version.
11    
12     This program is distributed in the hope that it will be useful,
13     but WITHOUT ANY WARRANTY; without even the implied warranty of
14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15     GNU General Public License for more details.
16    
17     You should have received a copy of the GNU General Public License
18 pcg 1.7 along with gvpe; if not, write to the Free Software
19 pcg 1.1 Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20     */
21    
22     #include "config.h"
23    
24     #if ENABLE_DNS
25    
26     // dns processing is EXTREMELY ugly. For obvious(?) reasons.
27     // it's a hack, use only in emergency situations please.
28    
29     #include <cstring>
30 pcg 1.20 #include <cassert>
31 pcg 1.1
32     #include <sys/types.h>
33     #include <sys/socket.h>
34     #include <sys/wait.h>
35     #include <sys/uio.h>
36     #include <errno.h>
37     #include <time.h>
38     #include <unistd.h>
39     #include <fcntl.h>
40    
41     #include <map>
42    
43 pcg 1.8 #include <gmp.h>
44    
45 pcg 1.1 #include "netcompat.h"
46    
47     #include "vpn.h"
48    
49 pcg 1.15 #define MIN_POLL_INTERVAL .02 // how often to poll minimally when the server has data
50 pcg 1.10 #define MAX_POLL_INTERVAL 6. // how often to poll minimally when the server has no data
51     #define ACTIVITY_INTERVAL 5.
52    
53 pcg 1.17 #define INITIAL_TIMEOUT 0.1 // retry timeouts
54     #define INITIAL_SYN_TIMEOUT 10. // retry timeout for initial syn
55 pcg 1.10
56 pcg 1.15 #define MIN_SEND_INTERVAL 0.01 // wait at least this time between sending requests
57 pcg 1.27 #define MAX_SEND_INTERVAL 2. // optimistic?
58 pcg 1.1
59 pcg 1.25 #define LATENCY_FACTOR 0.5 // RTT * LATENCY_FACTOR == sending rate
60 pcg 1.27 #define MAX_OUTSTANDING 40 // max. outstanding requests
61 pcg 1.17 #define MAX_WINDOW 1000 // max. for MAX_OUTSTANDING, and backlog
62 pcg 1.15 #define MAX_BACKLOG (100*1024) // size of gvpe protocol backlog (bytes), must be > MAXSIZE
63 pcg 1.5
64 pcg 1.25 #define MAX_DOMAIN_SIZE 200 // 255 is legal limit, but bind doesn't compress well
65 pcg 1.5 // 240 leaves about 4 bytes of server reply data
66 pcg 1.15 // every two request bytes less give room for one reply byte
67 pcg 1.5
68 pcg 1.17 #define SEQNO_MASK 0x3fff
69 pcg 1.8 #define SEQNO_EQ(a,b) ( 0 == ( ((a) ^ (b)) & SEQNO_MASK) )
70 pcg 1.1
71 pcg 1.8 #define MAX_LBL_SIZE 63
72     #define MAX_PKT_SIZE 512
73 pcg 1.1
74 pcg 1.10 #define RR_TYPE_A 1
75     #define RR_TYPE_NULL 10
76     #define RR_TYPE_TXT 16
77 pcg 1.8 #define RR_TYPE_ANY 255
78 pcg 1.10
79     #define RR_CLASS_IN 1
80    
81     #define CMD_IP_1 207
82     #define CMD_IP_2 46
83     #define CMD_IP_3 236
84     #define CMD_IP_RST 29
85     #define CMD_IP_SYN 113
86     #define CMD_IP_REJ 32
87 pcg 1.1
88 pcg 1.8 // works for cmaps up to 255 (not 256!)
89     struct charmap
90     {
91     enum { INVALID = (u8)255 };
92 pcg 1.1
93 pcg 1.8 char encode [256]; // index => char
94     u8 decode [256]; // char => index
95     unsigned int size;
96 pcg 1.2
97 pcg 1.8 charmap (const char *cmap);
98     };
99    
100     charmap::charmap (const char *cmap)
101     {
102     char *enc = encode;
103     u8 *dec = decode;
104 pcg 1.2
105 pcg 1.8 memset (enc, (char) 0, 256);
106     memset (dec, (char)INVALID, 256);
107 pcg 1.1
108 pcg 1.8 for (size = 0; cmap [size]; size++)
109     {
110     enc [size] = cmap [size];
111     dec [(u8)enc [size]] = size;
112     }
113 pcg 1.1
114 pcg 1.8 assert (size < 256);
115     }
116 pcg 1.2
117 pcg 1.8 #define MAX_DEC_LEN 500
118     #define MAX_ENC_LEN (MAX_DEC_LEN * 2)
119     #define MAX_LIMBS ((MAX_DEC_LEN * 8 + GMP_NUMB_BITS - 1) / GMP_NUMB_BITS)
120 pcg 1.2
121 pcg 1.8 // ugly. minimum base is 16(!)
122     struct basecoder
123 pcg 1.2 {
124 pcg 1.8 charmap cmap;
125     unsigned int enc_len [MAX_DEC_LEN];
126     unsigned int dec_len [MAX_ENC_LEN];
127 pcg 1.2
128 pcg 1.8 unsigned int encode_len (unsigned int len);
129     unsigned int decode_len (unsigned int len);
130    
131     unsigned int encode (char *dst, u8 *src, unsigned int len);
132     unsigned int decode (u8 *dst, char *src, unsigned int len);
133    
134     basecoder (const char *cmap);
135     };
136    
137     basecoder::basecoder (const char *cmap)
138     : cmap (cmap)
139     {
140     for (unsigned int len = 0; len < MAX_DEC_LEN; ++len)
141     {
142     u8 src [MAX_DEC_LEN];
143     u8 dst [MAX_ENC_LEN];
144 pcg 1.2
145 pcg 1.8 memset (src, 255, len);
146 pcg 1.2
147 pcg 1.8 mp_limb_t m [MAX_LIMBS];
148     mp_size_t n;
149    
150     n = mpn_set_str (m, src, len, 256);
151     n = mpn_get_str (dst, this->cmap.size, m, n);
152    
153     for (int i = 0; !dst [i]; ++i)
154     n--;
155    
156     enc_len [len] = n;
157     dec_len [n] = len;
158     }
159     }
160    
161     unsigned int basecoder::encode_len (unsigned int len)
162     {
163     return enc_len [len];
164     }
165 pcg 1.2
166 pcg 1.8 unsigned int basecoder::decode_len (unsigned int len)
167 pcg 1.2 {
168 pcg 1.8 while (len && !dec_len [len])
169     --len;
170    
171     return dec_len [len];
172 pcg 1.2 }
173    
174 pcg 1.8 unsigned int basecoder::encode (char *dst, u8 *src, unsigned int len)
175 pcg 1.2 {
176 pcg 1.10 if (!len || len > MAX_DEC_LEN)
177 pcg 1.8 return 0;
178    
179     int elen = encode_len (len);
180    
181     mp_limb_t m [MAX_LIMBS];
182     mp_size_t n;
183    
184     u8 dst_ [MAX_ENC_LEN];
185    
186     n = mpn_set_str (m, src, len, 256);
187     n = mpn_get_str (dst_, cmap.size, m, n);
188    
189     int plen = elen; // for padding
190 pcg 1.2
191 pcg 1.8 while (n < plen)
192 pcg 1.2 {
193 pcg 1.8 *dst++ = cmap.encode [0];
194     plen--;
195 pcg 1.2 }
196    
197 pcg 1.8 for (unsigned int i = n - plen; i < n; ++i)
198     *dst++ = cmap.encode [dst_ [i]];
199 pcg 1.4
200 pcg 1.8 return elen;
201 pcg 1.2 }
202    
203 pcg 1.8 unsigned int basecoder::decode (u8 *dst, char *src, unsigned int len)
204 pcg 1.2 {
205 pcg 1.10 if (!len || len > MAX_ENC_LEN)
206 pcg 1.8 return 0;
207    
208     u8 src_ [MAX_ENC_LEN];
209     unsigned int elen = 0;
210 pcg 1.2
211     while (len--)
212     {
213 pcg 1.8 u8 val = cmap.decode [(u8)*src++];
214 pcg 1.2
215 pcg 1.8 if (val != charmap::INVALID)
216     src_ [elen++] = val;
217     }
218    
219     int dlen = decode_len (elen);
220    
221     mp_limb_t m [MAX_LIMBS];
222     mp_size_t n;
223    
224     u8 dst_ [MAX_DEC_LEN];
225 pcg 1.2
226 pcg 1.8 n = mpn_set_str (m, src_, elen, cmap.size);
227     n = mpn_get_str (dst_, 256, m, n);
228 pcg 1.2
229 pcg 1.8 if (n < dlen)
230     {
231     memset (dst, 0, dlen - n);
232     memcpy (dst + dlen - n, dst_, n);
233 pcg 1.2 }
234 pcg 1.8 else
235     memcpy (dst, dst_ + n - dlen, dlen);
236 pcg 1.4
237 pcg 1.8 return dlen;
238     }
239    
240     #if 0
241     struct test { test (); } test;
242    
243     test::test ()
244     {
245     basecoder cdc ("0123456789abcdefghijklmnopqrstuvwxyz");
246    
247     u8 in[] = "0123456789abcdefghijklmnopqrstuvwxyz";
248     static char enc[200];
249     static u8 dec[200];
250    
251     for (int i = 1; i < 20; i++)
252     {
253     int elen = cdc.encode (enc, in, i);
254     int dlen = cdc.decode (dec, enc, elen);
255    
256     printf ("%d>%d>%d (%s>%s)\n", i, elen, dlen, enc, dec);
257     }
258     abort ();
259     }
260     #endif
261    
262 pcg 1.10 //static basecoder cdc64 ("_dDpPhHzZrR06QqMmjJkKBb34TtSsvVlL81xXaAeEFf92WwGgYyoO57UucCNniI-");
263 pcg 1.8 //static basecoder cdc63 ("_dDpPhHzZrR06QqMmjJkKBb34TtSsvVlL81xXaAeEFf92WwGgYyoO57UucCNniI");
264     static basecoder cdc62 ("dDpPhHzZrR06QqMmjJkKBb34TtSsvVlL81xXaAeEFf92WwGgYyoO57UucCNniI");
265     //static basecoder cdc36 ("dphzr06qmjkb34tsvl81xaef92wgyo57ucni"); // unused as of yet
266     static basecoder cdc26 ("dPhZrQmJkBtSvLxAeFwGyO");
267    
268     /////////////////////////////////////////////////////////////////////////////
269    
270     #define HDRSIZE 6
271 pcg 1.24
272 pcg 1.17 inline void encode_header (char *data, int clientid, int seqno, int retry = 0)
273 pcg 1.8 {
274 pcg 1.17 seqno &= SEQNO_MASK;
275    
276     u8 hdr[3] = {
277     clientid,
278     (seqno >> 8) | (retry << 6),
279     seqno,
280     };
281 pcg 1.8
282     assert (clientid < 256);
283    
284     cdc26.encode (data, hdr, 3);
285     }
286    
287     inline void decode_header (char *data, int &clientid, int &seqno)
288     {
289     u8 hdr[3];
290    
291     cdc26.decode (hdr, data, HDRSIZE);
292    
293     clientid = hdr[0];
294 pcg 1.17 seqno = ((hdr[1] << 8) | hdr[2]) & SEQNO_MASK;
295 pcg 1.4 }
296    
297     /////////////////////////////////////////////////////////////////////////////
298    
299     struct byte_stream
300     {
301     u8 *data;
302     int maxsize;
303     int fill;
304    
305     byte_stream (int maxsize);
306     ~byte_stream ();
307    
308     bool empty () { return !fill; }
309     int size () { return fill; }
310    
311 pcg 1.5 bool put (u8 *data, unsigned int datalen);
312 pcg 1.4 bool put (vpn_packet *pkt);
313     vpn_packet *get ();
314    
315     u8 *begin () { return data; }
316     void remove (int count);
317     };
318    
319     byte_stream::byte_stream (int maxsize)
320     : maxsize (maxsize), fill (0)
321     {
322     data = new u8 [maxsize];
323     }
324    
325     byte_stream::~byte_stream ()
326     {
327     delete data;
328     }
329    
330     void byte_stream::remove (int count)
331     {
332     if (count > fill)
333 pcg 1.17 assert (count <= fill);
334 pcg 1.4
335     memmove (data, data + count, fill -= count);
336     }
337    
338 pcg 1.5 bool byte_stream::put (u8 *data, unsigned int datalen)
339     {
340     if (maxsize - fill < datalen)
341     return false;
342    
343     memcpy (this->data + fill, data, datalen); fill += datalen;
344    
345     return true;
346     }
347    
348 pcg 1.4 bool byte_stream::put (vpn_packet *pkt)
349     {
350     if (maxsize - fill < pkt->len + 2)
351     return false;
352    
353     data [fill++] = pkt->len >> 8;
354     data [fill++] = pkt->len;
355    
356 pcg 1.10 memcpy (data + fill, pkt->at (0), pkt->len); fill += pkt->len;
357 pcg 1.4
358     return true;
359     }
360    
361     vpn_packet *byte_stream::get ()
362     {
363 pcg 1.18 unsigned int len;
364    
365     for (;;)
366     {
367     len = (data [0] << 8) | data [1];
368 pcg 1.4
369 pcg 1.18 if (len <= MAXSIZE || fill < 2)
370     break;
371 pcg 1.5
372 pcg 1.18 // TODO: handle this better than skipping, e.g. by reset
373     slog (L_DEBUG, _("DNS: corrupted packet stream skipping a byte..."));
374     remove (1);
375     }
376    
377 pcg 1.4 if (fill < len + 2)
378     return 0;
379    
380     vpn_packet *pkt = new vpn_packet;
381 pcg 1.5
382     pkt->len = len;
383 pcg 1.10 memcpy (pkt->at (0), data + 2, len);
384 pcg 1.4 remove (len + 2);
385    
386     return pkt;
387 pcg 1.2 }
388    
389 pcg 1.3 /////////////////////////////////////////////////////////////////////////////
390    
391 pcg 1.2 #define FLAG_QUERY ( 0 << 15)
392     #define FLAG_RESPONSE ( 1 << 15)
393 pcg 1.9 #define FLAG_OP_MASK (15 << 11)
394 pcg 1.2 #define FLAG_OP_QUERY ( 0 << 11)
395     #define FLAG_AA ( 1 << 10)
396     #define FLAG_TC ( 1 << 9)
397     #define FLAG_RD ( 1 << 8)
398     #define FLAG_RA ( 1 << 7)
399 pcg 1.5 #define FLAG_AUTH ( 1 << 5)
400 pcg 1.2 #define FLAG_RCODE_MASK (15 << 0)
401     #define FLAG_RCODE_OK ( 0 << 0)
402     #define FLAG_RCODE_FORMERR ( 1 << 0)
403     #define FLAG_RCODE_SERVFAIL ( 2 << 0)
404     #define FLAG_RCODE_NXDOMAIN ( 3 << 0)
405     #define FLAG_RCODE_REFUSED ( 5 << 0)
406    
407     #define DEFAULT_CLIENT_FLAGS (FLAG_QUERY | FLAG_OP_QUERY | FLAG_RD)
408 pcg 1.5 #define DEFAULT_SERVER_FLAGS (FLAG_RESPONSE | FLAG_OP_QUERY | FLAG_AA | FLAG_RD | FLAG_RA)
409 pcg 1.2
410 pcg 1.10 struct dns_cfg
411     {
412     static int next_uid;
413    
414     u8 id1, id2, id3, id4;
415 pcg 1.24
416 pcg 1.10 u8 version;
417 pcg 1.24 u8 flags;
418 pcg 1.10 u8 rrtype;
419     u8 def_ttl;
420 pcg 1.24
421 pcg 1.10 u16 client;
422     u16 uid; // to make request unique
423    
424 pcg 1.24 u16 max_size;
425     u8 seq_cdc;
426     u8 req_cdc;
427    
428     u8 rep_cdc;
429     u8 r2, r3, r4;
430    
431     u8 r5, r6, r7, r8;
432 pcg 1.10
433     void reset (int clientid);
434     bool valid ();
435     };
436    
437     int dns_cfg::next_uid;
438    
439     void dns_cfg::reset (int clientid)
440     {
441     id1 = 'G';
442     id2 = 'V';
443     id3 = 'P';
444     id4 = 'E';
445    
446     version = 1;
447    
448     rrtype = RR_TYPE_TXT;
449     flags = 0;
450 pcg 1.24 def_ttl = 0;
451     seq_cdc = 26;
452     req_cdc = 62;
453     rep_cdc = 0;
454 pcg 1.27 max_size = htons (MAX_PKT_SIZE);
455     client = htons (clientid);
456 pcg 1.10 uid = next_uid++;
457    
458 pcg 1.24 r2 = r3 = r4 = 0;
459     r4 = r5 = r6 = r7 = 0;
460 pcg 1.10 }
461    
462     bool dns_cfg::valid ()
463     {
464     return id1 == 'G'
465     && id2 == 'V'
466     && id3 == 'P'
467     && id4 == 'E'
468 pcg 1.24 && seq_cdc == 26
469     && req_cdc == 62
470     && rep_cdc == 0
471 pcg 1.27 && version == 1;
472 pcg 1.10 }
473    
474 pcg 1.2 struct dns_packet : net_packet
475     {
476     u16 id;
477     u16 flags; // QR:1 Opcode:4 AA:1 TC:1 RD:1 RA:1 Z:3 RCODE:4
478     u16 qdcount, ancount, nscount, arcount;
479    
480 pcg 1.24 u8 data [MAXSIZE - 6 * 2];
481 pcg 1.2
482     int decode_label (char *data, int size, int &offs);
483     };
484    
485     int dns_packet::decode_label (char *data, int size, int &offs)
486     {
487     char *orig = data;
488    
489     memset (data, 0, size);
490    
491     while (offs < size - 1)
492     {
493     u8 len = (*this)[offs++];
494    
495     if (!len)
496     break;
497     else if (len < 64)
498     {
499     if (size < len + 1 || offs + len >= MAXSIZE - 1)
500     break;
501    
502     memcpy (data, &((*this)[offs]), len);
503    
504     data += len; size -= len; offs += len;
505     *data++ = '.'; size--;
506     }
507     else
508     {
509     int offs2 = ((len & 63) << 8) + (*this)[offs++];
510    
511     data += decode_label (data, size, offs2);
512     break;
513     }
514     }
515    
516     return data - orig;
517     }
518    
519 pcg 1.3 /////////////////////////////////////////////////////////////////////////////
520    
521 pcg 1.18 static u16 dns_id = 0; // TODO: should be per-vpn
522    
523     static u16 next_id ()
524     {
525     if (!dns_id)
526     dns_id = time (0);
527    
528     // the simplest lsfr with periodicity 65535 i could find
529     dns_id = (dns_id << 1)
530     | (((dns_id >> 1)
531     ^ (dns_id >> 2)
532     ^ (dns_id >> 4)
533     ^ (dns_id >> 15)) & 1);
534    
535     return dns_id;
536     }
537    
538     struct dns_rcv;
539     struct dns_snd;
540    
541     struct dns_connection
542     {
543     connection *c;
544     struct vpn *vpn;
545    
546     dns_cfg cfg;
547    
548     bool established;
549    
550     tstamp last_received;
551     tstamp last_sent;
552 pcg 1.25 double min_latency;
553 pcg 1.18 double poll_interval, send_interval;
554    
555     vector<dns_rcv *> rcvpq;
556    
557     byte_stream rcvdq; int rcvseq;
558     byte_stream snddq; int sndseq;
559    
560     void time_cb (time_watcher &w); time_watcher tw;
561     void receive_rep (dns_rcv *r);
562    
563     dns_connection (connection *c);
564     ~dns_connection ();
565     };
566    
567 pcg 1.10 struct dns_snd
568 pcg 1.3 {
569     dns_packet *pkt;
570 pcg 1.10 tstamp timeout, sent;
571 pcg 1.3 int retry;
572 pcg 1.9 struct dns_connection *dns;
573 pcg 1.5 int seqno;
574 pcg 1.17 bool stdhdr;
575 pcg 1.3
576 pcg 1.9 void gen_stream_req (int seqno, byte_stream &stream);
577 pcg 1.18 void gen_syn_req ();
578 pcg 1.11
579     dns_snd (dns_connection *dns);
580     ~dns_snd ();
581 pcg 1.3 };
582    
583 pcg 1.10 dns_snd::dns_snd (dns_connection *dns)
584 pcg 1.9 : dns (dns)
585 pcg 1.3 {
586 pcg 1.10 timeout = 0;
587 pcg 1.3 retry = 0;
588 pcg 1.10 seqno = 0;
589 pcg 1.11 sent = NOW;
590 pcg 1.17 stdhdr = false;
591 pcg 1.3
592     pkt = new dns_packet;
593    
594 pcg 1.5 pkt->id = next_id ();
595     }
596    
597 pcg 1.11 dns_snd::~dns_snd ()
598     {
599     delete pkt;
600     }
601    
602 pcg 1.10 static void append_domain (dns_packet &pkt, int &offs, const char *domain)
603     {
604     // add tunnel domain
605     for (;;)
606     {
607     const char *end = strchr (domain, '.');
608    
609     if (!end)
610     end = domain + strlen (domain);
611    
612     int len = end - domain;
613    
614     pkt [offs++] = len;
615     memcpy (pkt.at (offs), domain, len);
616     offs += len;
617    
618     if (!*end)
619     break;
620    
621     domain = end + 1;
622     }
623     }
624    
625     void dns_snd::gen_stream_req (int seqno, byte_stream &stream)
626 pcg 1.5 {
627 pcg 1.17 stdhdr = true;
628 pcg 1.5 this->seqno = seqno;
629    
630 pcg 1.10 timeout = NOW + INITIAL_TIMEOUT;
631    
632 pcg 1.5 pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
633 pcg 1.4 pkt->qdcount = htons (1);
634 pcg 1.3
635 pcg 1.4 int offs = 6*2;
636 pcg 1.19 int dlen = MAX_DOMAIN_SIZE - (strlen (dns->c->conf->domain) + 2);
637 pcg 1.5 // MAX_DOMAIN_SIZE is technically 255, but bind doesn't compress responses well,
638     // so we need to have space for 2*MAX_DOMAIN_SIZE + header + extra
639    
640 pcg 1.8 char enc[256], *encp = enc;
641     encode_header (enc, THISNODE->id, seqno);
642 pcg 1.4
643 pcg 1.8 int datalen = cdc62.decode_len (dlen - (dlen + MAX_LBL_SIZE - 1) / MAX_LBL_SIZE - HDRSIZE);
644 pcg 1.4
645 pcg 1.9 if (datalen > stream.size ())
646     datalen = stream.size ();
647 pcg 1.8
648 pcg 1.9 int enclen = cdc62.encode (enc + HDRSIZE, stream.begin (), datalen) + HDRSIZE;
649     stream.remove (datalen);
650 pcg 1.4
651 pcg 1.5 while (enclen)
652     {
653     int lbllen = enclen < MAX_LBL_SIZE ? enclen : MAX_LBL_SIZE;
654    
655     (*pkt)[offs++] = lbllen;
656     memcpy (pkt->at (offs), encp, lbllen);
657 pcg 1.4
658 pcg 1.5 offs += lbllen;
659     encp += lbllen;
660 pcg 1.4
661 pcg 1.5 enclen -= lbllen;
662 pcg 1.4 }
663    
664 pcg 1.19 append_domain (*pkt, offs, dns->c->conf->domain);
665 pcg 1.3
666 pcg 1.10 (*pkt)[offs++] = 0;
667     (*pkt)[offs++] = RR_TYPE_ANY >> 8; (*pkt)[offs++] = RR_TYPE_ANY;
668     (*pkt)[offs++] = RR_CLASS_IN >> 8; (*pkt)[offs++] = RR_CLASS_IN;
669    
670     pkt->len = offs;
671     }
672    
673 pcg 1.18 void dns_snd::gen_syn_req ()
674 pcg 1.10 {
675     timeout = NOW + INITIAL_SYN_TIMEOUT;
676 pcg 1.4
677 pcg 1.10 pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
678     pkt->qdcount = htons (1);
679 pcg 1.4
680 pcg 1.18 int offs = 6 * 2;
681 pcg 1.4
682 pcg 1.18 int elen = cdc26.encode ((char *)pkt->at (offs + 1), (u8 *)&dns->cfg, sizeof (dns_cfg));
683 pcg 1.4
684 pcg 1.10 assert (elen <= MAX_LBL_SIZE);
685 pcg 1.4
686 pcg 1.10 (*pkt)[offs] = elen;
687     offs += elen + 1;
688 pcg 1.19 append_domain (*pkt, offs, dns->c->conf->domain);
689 pcg 1.4
690     (*pkt)[offs++] = 0;
691 pcg 1.10 (*pkt)[offs++] = RR_TYPE_A >> 8; (*pkt)[offs++] = RR_TYPE_A;
692 pcg 1.4 (*pkt)[offs++] = RR_CLASS_IN >> 8; (*pkt)[offs++] = RR_CLASS_IN;
693    
694     pkt->len = offs;
695 pcg 1.5 }
696    
697     struct dns_rcv
698     {
699     int seqno;
700     dns_packet *pkt; // reply packet
701     u8 data [MAXSIZE]; // actually part of the reply packet...
702     int datalen;
703    
704 pcg 1.6 dns_rcv (int seqno, u8 *data, int datalen);
705 pcg 1.5 ~dns_rcv ();
706     };
707    
708 pcg 1.6 dns_rcv::dns_rcv (int seqno, u8 *data, int datalen)
709 pcg 1.5 : seqno (seqno), pkt (new dns_packet), datalen (datalen)
710     {
711     memcpy (this->data, data, datalen);
712     }
713 pcg 1.4
714 pcg 1.5 dns_rcv::~dns_rcv ()
715     {
716     delete pkt;
717 pcg 1.3 }
718    
719     /////////////////////////////////////////////////////////////////////////////
720 pcg 1.9
721     dns_connection::dns_connection (connection *c)
722     : c (c)
723     , rcvdq (MAX_BACKLOG * 2)
724     , snddq (MAX_BACKLOG * 2)
725     , tw (this, &dns_connection::time_cb)
726     {
727     vpn = c->vpn;
728    
729 pcg 1.10 established = false;
730    
731 pcg 1.9 rcvseq = sndseq = 0;
732 pcg 1.10
733     last_sent = last_received = 0;
734     poll_interval = MIN_POLL_INTERVAL;
735 pcg 1.17 send_interval = 0.5; // starting rate
736 pcg 1.25 min_latency = INITIAL_TIMEOUT;
737 pcg 1.9 }
738    
739     dns_connection::~dns_connection ()
740     {
741     for (vector<dns_rcv *>::iterator i = rcvpq.begin ();
742     i != rcvpq.end ();
743     ++i)
744     delete *i;
745     }
746 pcg 1.3
747 pcg 1.10 void dns_connection::receive_rep (dns_rcv *r)
748 pcg 1.2 {
749 pcg 1.10 if (r->datalen)
750     {
751     last_received = NOW;
752     tw.trigger ();
753    
754 pcg 1.12 poll_interval = send_interval;
755 pcg 1.10 }
756     else
757     {
758 pcg 1.17 poll_interval *= 1.5;
759 pcg 1.25
760 pcg 1.10 if (poll_interval > MAX_POLL_INTERVAL)
761     poll_interval = MAX_POLL_INTERVAL;
762     }
763 pcg 1.2
764 pcg 1.9 rcvpq.push_back (r);
765 pcg 1.5
766     redo:
767    
768 pcg 1.8 // find next packet
769 pcg 1.9 for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )
770     if (SEQNO_EQ (rcvseq, (*i)->seqno))
771 pcg 1.5 {
772 pcg 1.8 // enter the packet into our input stream
773     r = *i;
774    
775     // remove the oldest packet, look forward, as it's oldest first
776 pcg 1.9 for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)
777     if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))
778 pcg 1.8 {
779     delete *j;
780 pcg 1.9 rcvpq.erase (j);
781 pcg 1.8 break;
782     }
783 pcg 1.5
784 pcg 1.9 rcvseq = (rcvseq + 1) & SEQNO_MASK;
785 pcg 1.5
786 pcg 1.9 if (!rcvdq.put (r->data, r->datalen))
787 pcg 1.17 {
788     slog (L_ERR, "DNS: !rcvdq.put (r->data, r->datalen)");
789     abort (); // MUST never overflow, can be caused by data corruption, TODO
790     }
791 pcg 1.5
792 pcg 1.9 while (vpn_packet *pkt = rcvdq.get ())
793 pcg 1.5 {
794     sockinfo si;
795 pcg 1.18 si.host = 0x01010101; si.port = htons (c->conf->id); si.prot = PROT_DNSv4;
796 pcg 1.5
797     vpn->recv_vpn_packet (pkt, si);
798 pcg 1.11
799     delete pkt;
800 pcg 1.5 }
801 pcg 1.8
802     // check for further packets
803 pcg 1.5 goto redo;
804     }
805     }
806    
807 pcg 1.10 void
808     vpn::dnsv4_server (dns_packet &pkt)
809 pcg 1.2 {
810 pcg 1.10 u16 flags = ntohs (pkt.flags);
811 pcg 1.2
812 pcg 1.4 int offs = 6 * 2; // skip header
813 pcg 1.2
814 pcg 1.10 pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_FORMERR);
815 pcg 1.2
816 pcg 1.10 if (0 == (flags & (FLAG_RESPONSE | FLAG_OP_MASK))
817     && pkt.qdcount == htons (1))
818 pcg 1.4 {
819 pcg 1.24 char qname [MAXSIZE];
820 pcg 1.10 int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);
821 pcg 1.4
822 pcg 1.10 u16 qtype = pkt [offs++] << 8; qtype |= pkt [offs++];
823     u16 qclass = pkt [offs++] << 8; qclass |= pkt [offs++];
824 pcg 1.2
825 pcg 1.10 pkt.qdcount = htons (1);
826     pkt.ancount = 0;
827     pkt.nscount = 0; // should be self, as other nameservers reply like this
828     pkt.arcount = 0; // a record for self, as other nameservers reply like this
829 pcg 1.2
830 pcg 1.16 pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_SERVFAIL);
831 pcg 1.2
832 pcg 1.4 int dlen = strlen (THISNODE->domain);
833 pcg 1.2
834 pcg 1.4 if (qclass == RR_CLASS_IN
835 pcg 1.10 && qlen > dlen + 1
836 pcg 1.24 && !memcmp (qname + qlen - (dlen + 1), THISNODE->domain, dlen))
837 pcg 1.2 {
838 pcg 1.10 // now generate reply
839     pkt.ancount = htons (1); // one answer RR
840     pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_OK);
841    
842     if ((qtype == RR_TYPE_ANY
843     || qtype == RR_TYPE_TXT
844     || qtype == RR_TYPE_NULL)
845     && qlen > dlen + 1 + HDRSIZE)
846 pcg 1.5 {
847 pcg 1.10 // correct class, domain: parse
848     int client, seqno;
849     decode_header (qname, client, seqno);
850 pcg 1.5
851 pcg 1.10 u8 data[MAXSIZE];
852     int datalen = cdc62.decode (data, qname + HDRSIZE, qlen - (dlen + 1 + HDRSIZE));
853 pcg 1.9
854 pcg 1.10 if (0 < client && client <= conns.size ())
855     {
856     connection *c = conns [client - 1];
857     dns_connection *dns = c->dns;
858     dns_rcv *rcv;
859 pcg 1.17 bool in_seq;
860 pcg 1.10
861     if (dns)
862     {
863     for (vector<dns_rcv *>::iterator i = dns->rcvpq.end (); i-- != dns->rcvpq.begin (); )
864     if (SEQNO_EQ ((*i)->seqno, seqno))
865     {
866     // already seen that request: simply reply with the cached reply
867     dns_rcv *r = *i;
868    
869 pcg 1.17 slog (L_DEBUG, "DNS: duplicate packet received ID %d, SEQ %d", htons (r->pkt->id), seqno);
870    
871     // refresh header & id, as the retry count could have changed
872     memcpy (r->pkt->at (6 * 2 + 1), pkt.at (6 * 2 + 1), HDRSIZE);
873     r->pkt->id = pkt.id;
874 pcg 1.10
875     memcpy (pkt.at (0), r->pkt->at (0), offs = r->pkt->len);
876 pcg 1.17
877 pcg 1.10 goto duplicate_request;
878     }
879    
880 pcg 1.17 in_seq = dns->rcvseq == seqno;
881    
882 pcg 1.10 // new packet, queue
883     rcv = new dns_rcv (seqno, data, datalen);
884     dns->receive_rep (rcv);
885     }
886    
887 pcg 1.21 {
888     pkt [offs++] = 0xc0; pkt [offs++] = 6 * 2; // refer to name in query section
889    
890     int rtype = dns ? dns->cfg.rrtype : RR_TYPE_A;
891     pkt [offs++] = rtype >> 8; pkt [offs++] = rtype; // type
892     pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
893     pkt [offs++] = 0; pkt [offs++] = 0;
894     pkt [offs++] = 0; pkt [offs++] = dns ? dns->cfg.def_ttl : 0; // TTL
895    
896     int rdlen_offs = offs += 2;
897 pcg 1.10
898 pcg 1.21 if (dns)
899     {
900 pcg 1.27 int dlen = ntohs (dns->cfg.max_size) - offs;
901    
902     // bind doesn't compress well, so reduce further by one label length
903     dlen -= qlen;
904    
905 pcg 1.21 // only put data into in-order sequence packets, if
906     // we receive out-of-order packets we generate empty
907     // replies
908     while (dlen > 1 && !dns->snddq.empty () && in_seq)
909     {
910     int txtlen = dlen <= 255 ? dlen - 1 : 255;
911 pcg 1.10
912 pcg 1.21 if (txtlen > dns->snddq.size ())
913     txtlen = dns->snddq.size ();
914 pcg 1.10
915 pcg 1.21 pkt[offs++] = txtlen;
916     memcpy (pkt.at (offs), dns->snddq.begin (), txtlen);
917     offs += txtlen;
918     dns->snddq.remove (txtlen);
919 pcg 1.10
920 pcg 1.21 dlen -= txtlen + 1;
921     }
922    
923     // avoid empty TXT rdata
924     if (offs == rdlen_offs)
925     pkt[offs++] = 0;
926 pcg 1.15
927 pcg 1.21 slog (L_NOISE, "DNS: snddq %d", dns->snddq.size ());
928     }
929     else
930     {
931     // send RST
932     pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
933     pkt [offs++] = CMD_IP_RST;
934     }
935 pcg 1.10
936 pcg 1.21 int rdlen = offs - rdlen_offs;
937 pcg 1.10
938 pcg 1.21 pkt [rdlen_offs - 2] = rdlen >> 8;
939     pkt [rdlen_offs - 1] = rdlen;
940 pcg 1.10
941 pcg 1.21 if (dns)
942     {
943     // now update dns_rcv copy
944     rcv->pkt->len = offs;
945     memcpy (rcv->pkt->at (0), pkt.at (0), offs);
946     }
947     }
948 pcg 1.9
949 pcg 1.10 duplicate_request: ;
950     }
951     else
952     pkt.flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_FORMERR);
953     }
954     else if (qtype == RR_TYPE_A
955     && qlen > dlen + 1 + cdc26.encode_len (sizeof (dns_cfg)))
956     {
957     dns_cfg cfg;
958     cdc26.decode ((u8 *)&cfg, qname, cdc26.encode_len (sizeof (dns_cfg)));
959     int client = ntohs (cfg.client);
960 pcg 1.4
961 pcg 1.10 pkt [offs++] = 0xc0; pkt [offs++] = 6 * 2; // refer to name in query section
962 pcg 1.2
963 pcg 1.10 pkt [offs++] = RR_TYPE_A >> 8; pkt [offs++] = RR_TYPE_A; // type
964     pkt [offs++] = RR_CLASS_IN >> 8; pkt [offs++] = RR_CLASS_IN; // class
965     pkt [offs++] = 0; pkt [offs++] = 0;
966     pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL
967     pkt [offs++] = 0; pkt [offs++] = 4; // rdlength
968 pcg 1.2
969 pcg 1.24 slog (L_INFO, _("DNS: client %d connects"), client);
970 pcg 1.2
971 pcg 1.10 pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
972     pkt [offs++] = CMD_IP_REJ;
973 pcg 1.2
974 pcg 1.10 if (0 < client && client <= conns.size ())
975 pcg 1.5 {
976 pcg 1.10 connection *c = conns [client - 1];
977 pcg 1.2
978 pcg 1.10 if (cfg.valid ())
979     {
980     pkt [offs - 1] = CMD_IP_SYN;
981    
982     delete c->dns;
983     c->dns = new dns_connection (c);
984     c->dns->cfg = cfg;
985     }
986 pcg 1.5 }
987     }
988 pcg 1.2 }
989 pcg 1.6
990 pcg 1.10 pkt.len = offs;
991 pcg 1.4 }
992     }
993    
994     void
995 pcg 1.10 vpn::dnsv4_client (dns_packet &pkt)
996 pcg 1.4 {
997 pcg 1.10 u16 flags = ntohs (pkt.flags);
998 pcg 1.4 int offs = 6 * 2; // skip header
999    
1000 pcg 1.10 pkt.qdcount = ntohs (pkt.qdcount);
1001     pkt.ancount = ntohs (pkt.ancount);
1002 pcg 1.4
1003 pcg 1.5 // go through our request list and find the corresponding request
1004 pcg 1.10 for (vector<dns_snd *>::iterator i = dns_sndpq.begin ();
1005 pcg 1.4 i != dns_sndpq.end ();
1006     ++i)
1007 pcg 1.10 if ((*i)->pkt->id == pkt.id)
1008 pcg 1.4 {
1009 pcg 1.9 dns_connection *dns = (*i)->dns;
1010 pcg 1.12 connection *c = dns->c;
1011 pcg 1.5 int seqno = (*i)->seqno;
1012     u8 data[MAXSIZE], *datap = data;
1013    
1014 pcg 1.10 if ((*i)->retry)
1015     {
1016 pcg 1.17 dns->send_interval *= 1.01;
1017 pcg 1.12 if (dns->send_interval > MAX_SEND_INTERVAL)
1018 pcg 1.10 dns->send_interval = MAX_SEND_INTERVAL;
1019     }
1020     else
1021     {
1022 pcg 1.26 #if 0
1023 pcg 1.17 dns->send_interval *= 0.999;
1024 pcg 1.12 #endif
1025 pcg 1.10 // the latency surely puts an upper bound on
1026     // the minimum send interval
1027 pcg 1.12 double latency = NOW - (*i)->sent;
1028    
1029 pcg 1.25 if (latency < dns->min_latency)
1030     dns->min_latency = latency;
1031    
1032     if (dns->send_interval > dns->min_latency * LATENCY_FACTOR)
1033     dns->send_interval = dns->min_latency * LATENCY_FACTOR;
1034 pcg 1.27
1035     if (dns->send_interval < MIN_SEND_INTERVAL)
1036     dns->send_interval = MIN_SEND_INTERVAL;
1037 pcg 1.10 }
1038    
1039 pcg 1.4 delete *i;
1040     dns_sndpq.erase (i);
1041    
1042 pcg 1.10 if (flags & FLAG_RESPONSE && !(flags & FLAG_OP_MASK))
1043 pcg 1.4 {
1044     char qname[MAXSIZE];
1045    
1046 pcg 1.10 while (pkt.qdcount-- && offs < MAXSIZE - 4)
1047 pcg 1.4 {
1048 pcg 1.10 int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);
1049 pcg 1.4 offs += 4; // skip qtype, qclass
1050     }
1051    
1052 pcg 1.10 while (pkt.ancount-- && offs < MAXSIZE - 10 && datap)
1053 pcg 1.4 {
1054 pcg 1.10 int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);
1055    
1056     u16 qtype = pkt [offs++] << 8; qtype |= pkt [offs++];
1057     u16 qclass = pkt [offs++] << 8; qclass |= pkt [offs++];
1058     u32 ttl = pkt [offs++] << 24;
1059     ttl |= pkt [offs++] << 16;
1060     ttl |= pkt [offs++] << 8;
1061     ttl |= pkt [offs++];
1062     u16 rdlen = pkt [offs++] << 8; rdlen |= pkt [offs++];
1063 pcg 1.8
1064 pcg 1.10 if (qtype == RR_TYPE_NULL || qtype == RR_TYPE_TXT)
1065     {
1066     if (rdlen <= MAXSIZE - offs)
1067     {
1068     // decode bytes, finally
1069    
1070     while (rdlen)
1071     {
1072     int txtlen = pkt [offs++];
1073 pcg 1.4
1074 pcg 1.10 assert (txtlen + offs < MAXSIZE - 1);
1075 pcg 1.4
1076 pcg 1.10 memcpy (datap, pkt.at (offs), txtlen);
1077     datap += txtlen; offs += txtlen;
1078    
1079     rdlen -= txtlen + 1;
1080     }
1081     }
1082     }
1083     else if (qtype == RR_TYPE_A)
1084 pcg 1.5 {
1085 pcg 1.10 u8 ip [4];
1086 pcg 1.5
1087 pcg 1.10 ip [0] = pkt [offs++];
1088     ip [1] = pkt [offs++];
1089     ip [2] = pkt [offs++];
1090     ip [3] = pkt [offs++];
1091    
1092     if (ip [0] == CMD_IP_1
1093     && ip [1] == CMD_IP_2
1094     && ip [2] == CMD_IP_3)
1095 pcg 1.5 {
1096 pcg 1.17 slog (L_TRACE, _("DNS: got tunnel meta command %02x"), ip [3]);
1097 pcg 1.5
1098 pcg 1.10 if (ip [3] == CMD_IP_RST)
1099     {
1100 pcg 1.17 slog (L_DEBUG, _("DNS: got tunnel RST request"));
1101 pcg 1.10
1102 pcg 1.12 delete dns; c->dns = 0;
1103 pcg 1.10
1104     return;
1105     }
1106     else if (ip [3] == CMD_IP_SYN)
1107 pcg 1.12 {
1108 pcg 1.17 slog (L_DEBUG, _("DNS: got tunnel SYN reply, server likes us."));
1109 pcg 1.12 dns->established = true;
1110     }
1111     else if (ip [3] == CMD_IP_REJ)
1112     {
1113 pcg 1.17 slog (L_DEBUG, _("DNS: got tunnel REJ reply, server does not like us, aborting."));
1114 pcg 1.12 abort ();
1115     }
1116 pcg 1.10 else
1117 pcg 1.17 slog (L_INFO, _("DNS: got unknown meta command %02x"), ip [3]);
1118 pcg 1.10 }
1119     else
1120 pcg 1.17 slog (L_INFO, _("DNS: got spurious a record %d.%d.%d.%d"),
1121 pcg 1.10 ip [0], ip [1], ip [2], ip [3]);
1122 pcg 1.5
1123 pcg 1.10 return;
1124 pcg 1.9 }
1125 pcg 1.4
1126 pcg 1.9 int client, rseqno;
1127     decode_header (qname, client, rseqno);
1128    
1129     if (client != THISNODE->id)
1130     {
1131 pcg 1.17 slog (L_INFO, _("DNS: got dns tunnel response with wrong clientid, ignoring"));
1132 pcg 1.9 datap = 0;
1133     }
1134     else if (rseqno != seqno)
1135     {
1136 pcg 1.17 slog (L_DEBUG, _("DNS: got dns tunnel response with wrong seqno, badly caching nameserver?"));
1137 pcg 1.9 datap = 0;
1138 pcg 1.4 }
1139     }
1140     }
1141    
1142 pcg 1.6 // todo: pkt now used
1143 pcg 1.9 if (datap)
1144     dns->receive_rep (new dns_rcv (seqno, data, datap - data));
1145 pcg 1.5
1146 pcg 1.4 break;
1147     }
1148     }
1149    
1150     void
1151     vpn::dnsv4_ev (io_watcher &w, short revents)
1152     {
1153     if (revents & EVENT_READ)
1154     {
1155     dns_packet *pkt = new dns_packet;
1156     struct sockaddr_in sa;
1157     socklen_t sa_len = sizeof (sa);
1158    
1159 pcg 1.10 pkt->len = recvfrom (w.fd, pkt->at (0), MAXSIZE, 0, (sockaddr *)&sa, &sa_len);
1160 pcg 1.4
1161     if (pkt->len > 0)
1162 pcg 1.5 {
1163 pcg 1.24 if (ntohs (pkt->flags) & FLAG_RESPONSE)
1164     dnsv4_client (*pkt);
1165     else
1166 pcg 1.5 {
1167 pcg 1.10 dnsv4_server (*pkt);
1168     sendto (w.fd, pkt->at (0), pkt->len, 0, (sockaddr *)&sa, sa_len);
1169 pcg 1.5 }
1170 pcg 1.10
1171     delete pkt;
1172 pcg 1.5 }
1173 pcg 1.1 }
1174     }
1175    
1176     bool
1177 pcg 1.18 vpn::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)
1178 pcg 1.3 {
1179 pcg 1.18 int client = ntohs (si.port);
1180    
1181     assert (0 < client && client <= conns.size ());
1182    
1183     connection *c = conns [client - 1];
1184    
1185     if (!c->dns)
1186     c->dns = new dns_connection (c);
1187 pcg 1.4
1188 pcg 1.18 if (!c->dns->snddq.put (pkt))
1189 pcg 1.3 return false;
1190    
1191 pcg 1.18 c->dns->tw.trigger ();
1192 pcg 1.3
1193     return true;
1194     }
1195    
1196 pcg 1.12 void
1197     connection::dnsv4_reset_connection ()
1198     {
1199     //delete dns; dns = 0; //TODO
1200     }
1201    
1202 pcg 1.10 #define NEXT(w) do { if (next > (w)) next = w; } while (0)
1203    
1204 pcg 1.3 void
1205 pcg 1.9 dns_connection::time_cb (time_watcher &w)
1206 pcg 1.1 {
1207 pcg 1.10 // servers have to be polled
1208     if (THISNODE->dns_port)
1209     return;
1210    
1211 pcg 1.3 // check for timeouts and (re)transmit
1212 pcg 1.10 tstamp next = NOW + poll_interval;
1213     dns_snd *send = 0;
1214 pcg 1.3
1215 pcg 1.10 for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();
1216 pcg 1.4 i != vpn->dns_sndpq.end ();
1217 pcg 1.3 ++i)
1218     {
1219 pcg 1.10 dns_snd *r = *i;
1220 pcg 1.3
1221 pcg 1.10 if (r->timeout <= NOW)
1222 pcg 1.3 {
1223 pcg 1.4 if (!send)
1224     {
1225     send = r;
1226    
1227     r->retry++;
1228 pcg 1.25 r->timeout = NOW + (r->retry * min_latency * 8.);
1229 pcg 1.17
1230     // the following code changes the query section a bit, forcing
1231     // the forwarder to generate a new request
1232     if (r->stdhdr)
1233     {
1234 pcg 1.27 //printf ("reencoded header for ID %d retry %d:%d:%d (%p)\n", htons (r->pkt->id), THISNODE->id, r->seqno, r->retry);
1235 pcg 1.17 //encode_header ((char *)r->pkt->at (6 * 2 + 1), THISNODE->id, r->seqno, r->retry);
1236     }
1237 pcg 1.4 }
1238 pcg 1.3 }
1239 pcg 1.11 else
1240 pcg 1.10 NEXT (r->timeout);
1241 pcg 1.3 }
1242    
1243 pcg 1.27 if (send || (last_sent + send_interval <= NOW))
1244 pcg 1.5 {
1245 pcg 1.10 if (!send)
1246     {
1247     // generate a new packet, if wise
1248    
1249     if (!established)
1250     {
1251     if (vpn->dns_sndpq.empty ())
1252     {
1253     send = new dns_snd (this);
1254    
1255     cfg.reset (THISNODE->id);
1256 pcg 1.18 send->gen_syn_req ();
1257 pcg 1.10 }
1258     }
1259 pcg 1.17 else if (vpn->dns_sndpq.size () < MAX_OUTSTANDING
1260     && !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))
1261 pcg 1.10 {
1262 pcg 1.18 //printf ("sending data request etc.\n"); //D
1263 pcg 1.25 if (!snddq.empty () || last_received + 1. > NOW)
1264 pcg 1.17 {
1265     poll_interval = send_interval;
1266     NEXT (NOW + send_interval);
1267     }
1268    
1269 pcg 1.10 send = new dns_snd (this);
1270     send->gen_stream_req (sndseq, snddq);
1271 pcg 1.25 send->timeout = NOW + min_latency * 8.;
1272 pcg 1.5
1273 pcg 1.10 sndseq = (sndseq + 1) & SEQNO_MASK;
1274     }
1275 pcg 1.4
1276 pcg 1.27 if (send && !send->retry)
1277 pcg 1.10 vpn->dns_sndpq.push_back (send);
1278     }
1279 pcg 1.4
1280 pcg 1.10 if (send)
1281     {
1282     last_sent = NOW;
1283     sendto (vpn->dnsv4_fd,
1284     send->pkt->at (0), send->pkt->len, 0,
1285     vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());
1286     }
1287 pcg 1.4 }
1288 pcg 1.10 else
1289     NEXT (last_sent + send_interval);
1290    
1291 pcg 1.27 slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)",
1292 pcg 1.12 poll_interval, send_interval, next - NOW,
1293 pcg 1.27 vpn->dns_sndpq.size (), snddq.size (),
1294     rcvpq.size ());
1295 pcg 1.11
1296     // TODO: no idea when this happens, but when next < NOW, we have a problem
1297     if (next < NOW + 0.0001)
1298     next = NOW + 0.1;
1299 pcg 1.4
1300 pcg 1.3 w.start (next);
1301 pcg 1.1 }
1302    
1303     #endif
1304