--- gvpe/src/vpn_dns.C	2005/03/06 21:52:15	1.23
+++ gvpe/src/vpn_dns.C	2005/03/07 22:24:24	1.25
@@ -56,11 +56,12 @@
 #define MIN_SEND_INTERVAL 0.01 // wait at least this time between sending requests
 #define MAX_SEND_INTERVAL 0.5 // optimistic?
 
-#define MAX_OUTSTANDING 10 // max. outstanding requests
+#define LATENCY_FACTOR   0.5 // RTT * LATENCY_FACTOR == sending rate
+#define MAX_OUTSTANDING   20 // max. outstanding requests
 #define MAX_WINDOW      1000 // max. for MAX_OUTSTANDING, and backlog
 #define MAX_BACKLOG     (100*1024) // size of gvpe protocol backlog (bytes), must be > MAXSIZE
 
-#define MAX_DOMAIN_SIZE 220 // 255 is legal limit, but bind doesn't compress well
+#define MAX_DOMAIN_SIZE 200 // 255 is legal limit, but bind doesn't compress well
 // 240 leaves about 4 bytes of server reply data
 // every two request bytes less give room for one reply byte
 
@@ -267,7 +268,7 @@
 /////////////////////////////////////////////////////////////////////////////
 
 #define HDRSIZE 6
-
+ 
 inline void encode_header (char *data, int clientid, int seqno, int retry = 0)
 {
   seqno &= SEQNO_MASK;
@@ -411,17 +412,23 @@
   static int next_uid;
 
   u8 id1, id2, id3, id4;
+
   u8 version;
-  u8 rrtype;
   u8 flags;
+  u8 rrtype;
   u8 def_ttl;
-  u8 rcv_cdc;
-  u8 snd_cdc;
-  u16 max_size;
+
   u16 client;
   u16 uid; // to make request unique
 
-  u8 reserved[8];
+  u16 max_size;
+  u8 seq_cdc;
+  u8 req_cdc;
+
+  u8 rep_cdc;
+  u8 r2, r3, r4;
+
+  u8 r5, r6, r7, r8;
 
   void reset (int clientid);
   bool valid ();
@@ -440,14 +447,16 @@
 
   rrtype   = RR_TYPE_TXT;
   flags    = 0;
-  def_ttl  = 1;
-  rcv_cdc  = 0;
-  snd_cdc  = 62;
+  def_ttl  = 0;
+  seq_cdc  = 26;
+  req_cdc  = 62;
+  rep_cdc  = 0;
   max_size = ntohs (MAX_PKT_SIZE);
   client   = ntohs (clientid);
   uid      = next_uid++;
 
-  memset (reserved, 0, 8);
+  r2 = r3 = r4 = 0;
+  r4 = r5 = r6 = r7 = 0;
 }
 
 bool dns_cfg::valid ()
@@ -456,10 +465,10 @@
       && id2 == 'V'
       && id3 == 'P'
       && id4 == 'E'
+      && seq_cdc == 26
+      && req_cdc == 62
+      && rep_cdc == 0
       && version == 1
-      && flags == 0
-      && rcv_cdc == 0
-      && snd_cdc == 62
       && max_size == ntohs (MAX_PKT_SIZE);
 }
 
@@ -469,7 +478,7 @@
   u16 flags; // QR:1 Opcode:4 AA:1 TC:1 RD:1 RA:1 Z:3 RCODE:4
   u16 qdcount, ancount, nscount, arcount;
 
-  u8 data[MAXSIZE - 6 * 2];
+  u8 data [MAXSIZE - 6 * 2];
 
   int decode_label (char *data, int size, int &offs);
 };
@@ -541,7 +550,7 @@
 
   tstamp last_received;
   tstamp last_sent;
-  double last_latency;
+  double min_latency;
   double poll_interval, send_interval;
 
   vector<dns_rcv *> rcvpq;
@@ -725,7 +734,7 @@
   last_sent = last_received = 0;
   poll_interval = MIN_POLL_INTERVAL;
   send_interval = 0.5; // starting rate
-  last_latency = INITIAL_TIMEOUT;
+  min_latency = INITIAL_TIMEOUT;
 }
 
 dns_connection::~dns_connection ()
@@ -748,6 +757,7 @@
   else
     {
       poll_interval *= 1.5;
+
       if (poll_interval > MAX_POLL_INTERVAL)
         poll_interval = MAX_POLL_INTERVAL;
     }
@@ -807,7 +817,7 @@
   if (0 == (flags & (FLAG_RESPONSE | FLAG_OP_MASK))
       && pkt.qdcount == htons (1))
     {
-      char qname[MAXSIZE];
+      char qname [MAXSIZE];
       int qlen = pkt.decode_label ((char *)qname, MAXSIZE - offs, offs);
 
       u16 qtype  = pkt [offs++] << 8; qtype  |= pkt [offs++];
@@ -824,7 +834,7 @@
 
       if (qclass == RR_CLASS_IN
           && qlen > dlen + 1
-          && !memcmp (qname + qlen - dlen - 1, THISNODE->domain, dlen))
+          && !memcmp (qname + qlen - (dlen + 1), THISNODE->domain, dlen))
         {
           // now generate reply
           pkt.ancount = htons (1); // one answer RR
@@ -956,7 +966,7 @@
               pkt [offs++] = 0; pkt [offs++] = cfg.def_ttl; // TTL
               pkt [offs++] = 0; pkt [offs++] = 4; // rdlength
 
-              slog (L_INFO, _("DNS: client %d tries to connect"), client);
+              slog (L_INFO, _("DNS: client %d connects"), client);
 
               pkt [offs++] = CMD_IP_1; pkt [offs++] = CMD_IP_2; pkt [offs++] = CMD_IP_3;
               pkt [offs++] = CMD_IP_REJ;
@@ -1018,10 +1028,12 @@
             // the latency surely puts an upper bound on
             // the minimum send interval
             double latency = NOW - (*i)->sent;
-            dns->last_latency = latency;
 
-            if (dns->send_interval > latency)
-              dns->send_interval = latency;
+            if (latency < dns->min_latency)
+              dns->min_latency = latency;
+
+            if (dns->send_interval > dns->min_latency * LATENCY_FACTOR)
+              dns->send_interval = dns->min_latency * LATENCY_FACTOR;
           }
 
         delete *i;
@@ -1148,13 +1160,13 @@
 
       if (pkt->len > 0)
         {
-          if (THISNODE->dns_port)
+          if (ntohs (pkt->flags) & FLAG_RESPONSE)
+            dnsv4_client (*pkt);
+          else
             {
               dnsv4_server (*pkt);
               sendto (w.fd, pkt->at (0), pkt->len, 0, (sockaddr *)&sa, sa_len);
             }
-          else
-            dnsv4_client (*pkt);
 
           delete pkt;
         }
@@ -1213,7 +1225,7 @@
               send = r;
 
               r->retry++;
-              r->timeout = NOW + (r->retry * last_latency * 8.);
+              r->timeout = NOW + (r->retry * min_latency * 8.);
 
               // the following code changes the query section a bit, forcing
               // the forwarder to generate a new request
@@ -1248,7 +1260,7 @@
                    && !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))
             {
               //printf ("sending data request etc.\n"); //D
-              if (!snddq.empty ())
+              if (!snddq.empty () || last_received + 1. > NOW)
                 {
                   poll_interval = send_interval;
                   NEXT (NOW + send_interval);
@@ -1256,7 +1268,7 @@
 
               send = new dns_snd (this);
               send->gen_stream_req (sndseq, snddq);
-              send->timeout = NOW + last_latency * 8.;
+              send->timeout = NOW + min_latency * 8.;
 
               sndseq = (sndseq + 1) & SEQNO_MASK;
             }