ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/gvpe/src/vpn_dns.C
(Generate patch)

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.2 by pcg, Tue Mar 1 04:38:21 2005 UTC vs.
Revision 1.4 by pcg, Wed Mar 2 05:49:31 2005 UTC

… …
39 39
40#include "netcompat.h" 40#include "netcompat.h"
41 41
42#include "vpn.h" 42#include "vpn.h"
43 43
44#if ENABLE_HTTP_PROXY
45# include "conf.h"
46#endif
47
48#define MIN_RETRY 1. 44#define MIN_RETRY 1.
49#define MAX_RETRY 60. 45#define MAX_RETRY 60.
50 46
51#define SERVER conf.dns_port 47#define MAX_OUTSTANDING 10 // max. outstanding requests
48#define MAX_WINDOW 100 // max. for MAX_OUTSTANDING
49#define MAX_RATE 1 // requests/s
50#define MAX_BACKLOG (10*1024) // size of protocol backlog
52 51
53/* 52/*
54 53
55protocol, in shorthand :) 54protocol, in shorthand :)
56 55
… …
79 static const char encode_chars[64 + 1]; 78 static const char encode_chars[64 + 1];
80 static s8 decode_chars[256]; 79 static s8 decode_chars[256];
81 80
82 static int encode_len (int bytes) { return (bytes * 8 + 5) / 6; } 81 static int encode_len (int bytes) { return (bytes * 8 + 5) / 6; }
83 static int decode_len (int bytes) { return (bytes * 6) / 8; } 82 static int decode_len (int bytes) { return (bytes * 6) / 8; }
84 static void encode (char *dst, u8 *src, int len); 83 static int encode (char *dst, u8 *src, int len);
85 static void decode (u8 *dst, char *src, int len); 84 static int decode (u8 *dst, char *src, int len);
86 85
87 dns64 (); 86 dns64 ();
88} dns64; 87} dns64;
89 88
90const char dns64::encode_chars[64 + 1] = "0123456789-abcdefghijklmnopqrstuvwxyz_ABCDEFGHIJKLMNOPQRSTUVWXYZ"; 89const char dns64::encode_chars[64 + 1] = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-";
91s8 dns64::decode_chars[256]; 90s8 dns64::decode_chars[256];
92 91
93dns64::dns64 () 92dns64::dns64 ()
94{ 93{
95 for (int i = 0; i < 64; i++) 94 for (int i = 0; i < 64; i++)
96 decode_chars [encode_chars [i]] = i + 1; 95 decode_chars [encode_chars [i]] = i + 1;
97} 96}
98 97
99void dns64::encode (char *dst, u8 *src, int len) 98int dns64::encode (char *dst, u8 *src, int len)
100{ 99{
101 // slow, but easy to debug 100 // slow, but easy to debug
101 char *beg = dst;
102 unsigned int accum, bits = 0; 102 unsigned int accum, bits = 0;
103 103
104 while (len--) 104 while (len--)
105 { 105 {
106 accum <<= 8; 106 accum <<= 8;
… …
114 } 114 }
115 } 115 }
116 116
117 if (bits) 117 if (bits)
118 *dst++ = encode_chars [(accum << (6 - bits)) & 63]; 118 *dst++ = encode_chars [(accum << (6 - bits)) & 63];
119}
120 119
120 return dst - beg;
121}
122
121void dns64::decode (u8 *dst, char *src, int len) 123int dns64::decode (u8 *dst, char *src, int len)
122{ 124{
123 // slow, but easy to debug 125 // slow, but easy to debug
126 u8 *beg = dst;
124 unsigned int accum, bits = 0; 127 unsigned int accum, bits = 0;
125 128
126 while (len--) 129 while (len--)
127 { 130 {
128 s8 chr = decode_chars [(u8)*src++]; 131 s8 chr = decode_chars [(u8)*src++];
129
130 132
131 if (!chr) 133 if (!chr)
132 break; 134 break;
133 135
134 accum <<= 6; 136 accum <<= 6;
… …
139 { 141 {
140 *dst++ = accum >> (bits - 8); 142 *dst++ = accum >> (bits - 8);
141 bits -= 8; 143 bits -= 8;
142 } 144 }
143 } 145 }
146
147 return dst - beg;
144} 148}
149
150/////////////////////////////////////////////////////////////////////////////
151
152struct byte_stream
153{
154 u8 *data;
155 int maxsize;
156 int fill;
157
158 byte_stream (int maxsize);
159 ~byte_stream ();
160
161 bool empty () { return !fill; }
162 int size () { return fill; }
163
164 bool put (vpn_packet *pkt);
165 vpn_packet *get ();
166
167 u8 *begin () { return data; }
168 void remove (int count);
169};
170
171byte_stream::byte_stream (int maxsize)
172: maxsize (maxsize), fill (0)
173{
174 data = new u8 [maxsize];
175}
176
177byte_stream::~byte_stream ()
178{
179 delete data;
180}
181
182void byte_stream::remove (int count)
183{
184 if (count > fill)
185 abort ();
186
187 memmove (data, data + count, fill -= count);
188}
189
190bool byte_stream::put (vpn_packet *pkt)
191{
192 if (maxsize - fill < pkt->len + 2)
193 return false;
194
195 data [fill++] = pkt->len >> 8;
196 data [fill++] = pkt->len;
197
198 memcpy (data + fill, &((*pkt)[0]), pkt->len); fill += pkt->len;
199
200 return true;
201}
202
203vpn_packet *byte_stream::get ()
204{
205 int len = (data [0] << 8) | data [1];
206
207 if (fill < len + 2)
208 return 0;
209
210 vpn_packet *pkt = new vpn_packet;
211 memcpy (&((*pkt)[0]), data + 2, len);
212 remove (len + 2);
213
214 return pkt;
215}
216
217/////////////////////////////////////////////////////////////////////////////
145 218
146#define FLAG_QUERY ( 0 << 15) 219#define FLAG_QUERY ( 0 << 15)
147#define FLAG_RESPONSE ( 1 << 15) 220#define FLAG_RESPONSE ( 1 << 15)
148#define FLAG_OP_MASK (15 << 14) 221#define FLAG_OP_MASK (15 << 14)
149#define FLAG_OP_QUERY ( 0 << 11) 222#define FLAG_OP_QUERY ( 0 << 11)
… …
204 } 277 }
205 278
206 return data - orig; 279 return data - orig;
207} 280}
208 281
282/////////////////////////////////////////////////////////////////////////////
283
284struct dns_req
285{
286 dns_packet *pkt;
287 tstamp next;
288 int retry;
289 connection *conn;
290
291 dns_req (connection *c, int seqno, byte_stream *stream);
292};
293
294struct dns_rep
295{
296};
297
298static u16 dns_id; // TODO: should be per-vpn
299
300dns_req::dns_req (connection *c, int seqno, byte_stream *stream)
301: conn (c)
302{
303 next = 0;
304 retry = 0;
305
306 pkt = new dns_packet;
307
308 pkt->id = dns_id++;
309 pkt->flags = DEFAULT_CLIENT_FLAGS;
310 pkt->qdcount = htons (1);
311 pkt->ancount = 0;
312 pkt->nscount = 0;
313 pkt->arcount = 0;
314
315 int offs = 6*2;
316 int dlen = 255 - strlen (THISNODE->domain) - 1; // here we always have room for the max. label length
317
318 u8 lbl[64]; //D
319 char enc[65];
320 int lbllen = 3;
321 lbl[0] = c->conf->id; //D
322 lbl[1] = seqno >> 8; //D
323 lbl[2] = seqno; //D
324
325 while (dlen > 0)
326 {
327 int sndlen = dlen;
328
329 if (sndlen + lbllen > dns64::decode_len (MAX_LBL_SIZE))
330 sndlen = dns64::decode_len (MAX_LBL_SIZE) - lbllen;
331
332 if (sndlen > stream->size ())
333 sndlen = stream->size ();
334
335 if (sndlen + lbllen == 0)
336 break;
337
338 memcpy (lbl + lbllen, stream->begin (), sndlen);
339 stream->remove (sndlen);
340 lbllen += sndlen;
341
342 dns64::encode (enc, lbl, lbllen);
343
344 int elen = dns64::encode_len (lbllen);
345 (*pkt)[offs++] = elen;
346 memcpy (&((*pkt)[offs]), enc, elen);
347 offs += elen;
348 dlen -= elen + 1;
349
350 lbllen = 0;
351 }
352
353 const char *suffix = THISNODE->domain;
354
355 // add tunnel domain
356 for (;;)
357 {
358 const char *end = strchr (suffix, '.');
359
360 if (!end)
361 end = suffix + strlen (suffix);
362
363 int len = end - suffix;
364
365 (*pkt)[offs++] = len;
366 memcpy (&((*pkt)[offs]), suffix, len);
367 offs += len;
368
369 if (!*end)
370 break;
371
372 suffix = end + 1;
373 }
374
375 (*pkt)[offs++] = 0;
376 (*pkt)[offs++] = RR_TYPE_ANY >> 8; (*pkt)[offs++] = RR_TYPE_ANY;
377 (*pkt)[offs++] = RR_CLASS_IN >> 8; (*pkt)[offs++] = RR_CLASS_IN;
378
379 pkt->len = offs;
380
381 c->vpn->dns_sndpq.push_back (this);
382}
383
384/////////////////////////////////////////////////////////////////////////////
385
209struct dns_cfg 386struct dns_cfg
210{ 387{
211 u8 id1, id2, id3; 388 u8 id1, id2, id3;
212 u8 def_ttl; 389 u8 def_ttl;
213 u8 unused1; 390 u8 unused1;
214 u16 max_size; 391 u16 max_size;
215 u8 flags1, flags2; 392 u8 flags1, flags2;
216}; 393};
217 394
218// reply to client-poll 395dns_packet *
219void dnsv4_poll (dns_packet *pkt, int &offs) 396vpn::dnsv4_server (dns_packet *pkt)
220{ 397{
221 int dlen = MAX_PKT_SIZE - offs - 2; 398 u16 flags = ntohs (pkt->flags);
222 399
223 (*pkt) [offs++] = 0; 400 //memcpy (&((*rep)[0]), &((*pkt)[0]), pkt->len);
224 (*pkt) [offs++] = 5; 401 int offs = 6 * 2; // skip header
225 memcpy (&((*pkt)[offs]), "\01H\02\xff\x00", 5);
226 offs += 5;
227 402
228 pkt->ancount = htons (1);
229 pkt->flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_OK); 403 pkt->flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_FORMERR);
230 404
405 if (!(flags & (FLAG_RESPONSE | FLAG_OP_MASK | FLAG_TC))
406 && pkt->qdcount == htons (1))
407 {
408 char qname[MAXSIZE];
409 int qlen = pkt->decode_label ((char *)qname, MAXSIZE - offs, offs);
410
411 printf ("rcvd packet len %d, id%04x flags%04x q%04x a%04x n%04x a%04x <%s>\n", pkt->len,
412 pkt->id, flags, pkt->qdcount, pkt->ancount, pkt->nscount, pkt->arcount, qname);//D
413
414 u16 qtype = (*pkt) [offs++] << 8; qtype |= (*pkt) [offs++];
415 u16 qclass = (*pkt) [offs++] << 8; qclass |= (*pkt) [offs++];
416
417 pkt->qdcount = htons (1);
418 pkt->ancount = 0;
419 pkt->nscount = 0; // should be self, as other nameservers reply like this
420 pkt->arcount = 0; // a record for self, as other nameservers reply like this
421
422 pkt->flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_NXDOMAIN);
423
424 int dlen = strlen (THISNODE->domain);
425
426 if (qclass == RR_CLASS_IN
427 && (qtype == RR_TYPE_ANY || qtype == RR_TYPE_TXT)
428 && qlen > dlen + 1
429 && !memcmp (qname + qlen - dlen - 1, THISNODE->domain, dlen))
430 {
431 // correct class, domain, parse
432 u8 data[MAXSIZE];
433 int datalen = dns64::decode (data, qname, qlen - dlen - 1);
434
435 for (int i = 0; i < datalen; i++)
436 printf ("%02x ", data[i]);
437 printf ("\n");
438
439
440
441
442#if 0
443 // now generate reply
444 rep->ancount = htons (1); // one answer RR
445 rep->flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_OK);
446
447 (*rep) [offs++] = 0xc0;
448 (*rep) [offs++] = 6 * 2; // same as in query section
449
450 (*rep) [offs++] = RR_TYPE_TXT >> 8; (*rep) [offs++] = RR_TYPE_TXT;
451 (*rep) [offs++] = RR_CLASS_IN >> 8; (*rep) [offs++] = RR_CLASS_IN;
452
453 (*rep) [offs++] = 0; (*rep) [offs++] = 0;
454 (*rep) [offs++] = 0; (*rep) [offs++] = 0; // TTL
455
456 int dlen = MAX_PKT_SIZE - offs - 2;
457
231 printf ("we have room for %d bytes\n", dlen); 458 printf ("we have room for %d bytes\n", dlen);
459
460 int rdlen_offs = offs += 2;
461
462 u8 txt[255];
463 txt[0] = 0;
464 txt[1] = 0;
465
466 int txtlen = 2;
467
468 while (dlen > 1)
469 {
470 int sndlen = --dlen;
471
472 if (sndlen + txtlen > 255)
473 sndlen = 255 - txtlen;
474
475 sndlen = 0;
476
477 (*rep)[offs++] = sndlen + txtlen;
478 memcpy (&((*rep)[offs]), txt, txtlen);
479 offs += txtlen;
480
481 //if (sndlen + txtlen > dns_snddq.
482 }
483
484 int rdlen = offs - rdlen_offs;
485
486 (*rep) [rdlen_offs - 2] = rdlen >> 8;
487 (*rep) [rdlen_offs - 1] = rdlen;
488#endif
489 }
490 }
491
492 pkt->len = offs;
493 return pkt;
494}
495
496void
497vpn::dnsv4_client (dns_packet *pkt)
498{
499 u16 flags = ntohs (pkt->flags);
500 int offs = 6 * 2; // skip header
501
502 pkt->qdcount = ntohs (pkt->qdcount);
503 pkt->ancount = ntohs (pkt->ancount);
504
505 for (vector<dns_req *>::iterator i = dns_sndpq.begin ();
506 i != dns_sndpq.end ();
507 ++i)
508 if ((*i)->pkt->id == pkt->id)
509 {
510 connection *c = (*i)->conn;
511 printf ("GOT RESPONSE id %x %p\n", pkt->id, c);//D
512 delete *i;
513 dns_sndpq.erase (i);
514
515 if (flags & (FLAG_RESPONSE | FLAG_OP_MASK | FLAG_TC))
516 {
517 char qname[MAXSIZE];
518
519 while (pkt->qdcount-- && offs < MAXSIZE - 4)
520 {
521 int qlen = pkt->decode_label ((char *)qname, MAXSIZE - offs, offs);
522 offs += 4; // skip qtype, qclass
523 }
524
525 while (pkt->ancount-- && offs < MAXSIZE - 10)
526 {
527 pkt->decode_label ((char *)qname, MAXSIZE - offs, offs);
528
529 u16 qtype = (*pkt) [offs++] << 8; qtype |= (*pkt) [offs++];
530 u16 qclass = (*pkt) [offs++] << 8; qclass |= (*pkt) [offs++];
531 u32 ttl = (*pkt) [offs++] << 24;
532 ttl |= (*pkt) [offs++] << 16;
533 ttl |= (*pkt) [offs++] << 8;
534 ttl |= (*pkt) [offs++];
535
536 u16 rdlen = (*pkt) [offs++] << 8; rdlen |= (*pkt) [offs++];
537
538 printf ("REPLY %d:%d TTL %d RD %d\n", qtype, qclass, ttl, rdlen);
539
540 offs += rdlen;
541
542 if (MAXSIZE - offs < rdlen)
543 {
544 // decode bytes, finally
545 }
546 }
547 }
548
549 break;
550 }
232} 551}
233 552
234void 553void
235vpn::dnsv4_ev (io_watcher &w, short revents) 554vpn::dnsv4_ev (io_watcher &w, short revents)
236{ 555{
… …
238 { 557 {
239 dns_packet *pkt = new dns_packet; 558 dns_packet *pkt = new dns_packet;
240 struct sockaddr_in sa; 559 struct sockaddr_in sa;
241 socklen_t sa_len = sizeof (sa); 560 socklen_t sa_len = sizeof (sa);
242 561
243 int len = recvfrom (w.fd, &((*pkt)[0]), MAXSIZE, 0, (sockaddr *)&sa, &sa_len); 562 pkt->len = recvfrom (w.fd, &((*pkt)[0]), MAXSIZE, 0, (sockaddr *)&sa, &sa_len);
244 pkt->len = len;
245 563
246 u16 flags = ntohs (pkt->flags); 564 if (pkt->len > 0)
247
248 if (THISNODE->dns_port) 565 if (THISNODE->dns_port)
566 {
567 pkt = dnsv4_server (pkt);
568 sendto (w.fd, &((*pkt)[0]), pkt->len, 0, (sockaddr *)&sa, sa_len);
569 }
570 else
571 dnsv4_client (pkt);
572 }
573}
574
575bool
576connection::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos)
577{
578 // never initialized
579 if (!dns_snddq && !dns_rcvdq)
580 {
581 dns_rcvdq = new byte_stream (MAX_BACKLOG * 2);
582 dns_snddq = new byte_stream (MAX_BACKLOG);
583
584 dns_rcvseq = dns_sndseq = 0;
585
586 dns_si.set (::conf.dns_forw_host, ::conf.dns_forw_port, PROT_DNSv4);
587 }
588
589 if (!dns_snddq->put (pkt))
590 return false;
591
592 // start timer if neccessary
593 if (!dnsv4_tw.active)
594 dnsv4_cb (dnsv4_tw);
595
596 return true;
597}
598
599void
600connection::dnsv4_cb (time_watcher &w)
601{
602 // check for timeouts and (re)transmit
603 tstamp next = NOW + 60;
604 dns_req *send = 0;
605
606 slog (L_NOISE, _("dnsv4, %d packets in send queue\n"), vpn->dns_sndpq.size ());
607
608 for (vector<dns_req *>::iterator i = vpn->dns_sndpq.begin ();
609 i != vpn->dns_sndpq.end ();
610 ++i)
611 {
612 dns_req *r = *i;
613
614 if (r->next <= NOW)
249 { 615 {
250 // server 616 if (!send)
251 pkt->flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_FORMERR);
252
253 int offs = 6 * 2; // skip header
254
255 if (!(flags & (FLAG_RESPONSE | FLAG_OP_MASK | FLAG_TC))
256 && pkt->qdcount == htons (1))
257 { 617 {
258 char qname[MAXSIZE]; 618 send = r;
259 int qlen = pkt->decode_label ((char *)qname, MAXSIZE, offs);
260 619
261 printf ("rcvd packet len %d, id%04x flags%04x q%04x a%04x n%04x a%04x <%s>\n", len, 620 slog (L_NOISE, _("dnsv4, send req %d\n"), r->pkt->id);
262 pkt->id, flags, pkt->qdcount, pkt->ancount, pkt->nscount, pkt->arcount, qname);//D 621 r->retry++;
263 622 r->next = NOW + r->retry;
264 u16 qtype = (*pkt) [offs++] << 8; qtype |= (*pkt) [offs++];
265 u16 qclass = (*pkt) [offs++] << 8; qclass |= (*pkt) [offs++];
266
267 pkt->qdcount = htons (1);
268 pkt->ancount = 0;
269 pkt->nscount = 0; // should be self, as other nameservers reply like this
270 pkt->arcount = 0; // a record for self, as other nameservers reply like this
271
272 pkt->flags = htons (DEFAULT_SERVER_FLAGS | FLAG_RCODE_NXDOMAIN);
273
274 int dlen = strlen (THISNODE->domain);
275
276 if (qclass == RR_CLASS_IN
277 && (qtype == RR_TYPE_ANY || qtype == RR_TYPE_TXT)
278 && qlen > dlen + 1
279 && !memcmp (qname + qlen - dlen - 1, THISNODE->domain, dlen))
280 {
281 // correct class, now generate reply
282 pkt->ancount = htons (1); // one answer RR
283
284 (*pkt) [offs++] = 0xc0;
285 (*pkt) [offs++] = 6 * 2; // same as in query section
286
287 (*pkt) [offs++] = RR_TYPE_TXT >> 8; (*pkt) [offs++] = RR_TYPE_TXT;
288 (*pkt) [offs++] = RR_CLASS_IN >> 8; (*pkt) [offs++] = RR_CLASS_IN;
289
290 (*pkt) [offs++] = 0; (*pkt) [offs++] = 0;
291 (*pkt) [offs++] = 0; (*pkt) [offs++] = 0; // TTL
292
293 dnsv4_poll (pkt, offs);
294 printf ("correct class\n");
295 }
296 } 623 }
297
298 sendto (w.fd, &((*pkt)[0]), offs, 0, (sockaddr *)&sa, sa_len);
299 } 624 }
300 else 625
301 { 626 if (r->next < next)
302 // client 627 next = r->next;
303 } 628 }
629
630 if (!send
631 && vpn->dns_sndpq.size () < MAX_OUTSTANDING)
632 send = new dns_req (this, dns_sndseq++, dns_snddq);
633
634 tstamp min_next = NOW + (1. / (tstamp)MAX_RATE);
635
636 if (send)
304 } 637 {
305} 638 dns_packet *pkt = send->pkt;
306 639
307bool 640 next = min_next;
308vpn::send_dnsv4_packet (vpn_packet *pkt, const sockinfo &si, int tos) 641
309{ 642 sendto (vpn->dnsv4_fd, &((*pkt)[0]), pkt->len, 0, dns_si.sav4 (), dns_si.salenv4 ());
310 //return i->send_packet (pkt, tos); 643 }
644 else if (next < min_next)
645 next = min_next;
646
647 w.start (next);
311} 648}
312 649
313#endif 650#endif
314 651

Diff Legend

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