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

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.39 by pcg, Tue Apr 26 00:55:56 2005 UTC vs.
Revision 1.42 by pcg, Sat Nov 10 05:14:22 2007 UTC

   r4 = r5 = r6 = r7 = 0;
 }
 bool dns_cfg::valid ()
 {
+  // although the protocol itself allows for some configurability,
+  // only the following encoding/decoding settings are implemented.
   return id1 == 'G'
       && id2 == 'V'
       && id3 == 'P'
       && id4 == 'E'
       && seq_cdc == 26
   vector<dns_rcv *> rcvpq;
   byte_stream rcvdq; int rcvseq; int repseq;
   byte_stream snddq; int sndseq;
-  void time_cb (time_watcher &w); time_watcher tw;
+  void time_cb (ev::timer &w, int revents); ev::timer tw;
   void receive_rep (dns_rcv *r);
   dns_connection (connection *c);
   ~dns_connection ();
 };
 : dns (dns)
 {
   timeout = 0;
   retry = 0;
   seqno = 0;
-  sent = NOW;
+  sent = ev::ev_now ();
   stdhdr = false;
   pkt = new dns_packet;
   pkt->id = next_id ();
 void dns_snd::gen_stream_req (int seqno, byte_stream &stream)
 {
   stdhdr = true;
   this->seqno = seqno;
-  timeout = NOW + INITIAL_TIMEOUT;
+  timeout = ev::ev_now () + INITIAL_TIMEOUT;
   pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
   pkt->qdcount = htons (1);
   int offs = 6*2;
   pkt->len = offs;
 }
 void dns_snd::gen_syn_req ()
 {
-  timeout = NOW + INITIAL_SYN_TIMEOUT;
+  timeout = ev::ev_now () + INITIAL_SYN_TIMEOUT;
   pkt->flags = htons (DEFAULT_CLIENT_FLAGS);
   pkt->qdcount = htons (1);
   int offs = 6 * 2;
 void dns_connection::receive_rep (dns_rcv *r)
 {
   if (r->datalen)
     {
-      last_received = NOW;
+      last_received = ev::ev_now ();
-      tw.trigger ();
+      tw ();
       poll_interval = send_interval;
     }
   else
     {
   // find next packet
   for (vector<dns_rcv *>::iterator i = rcvpq.end (); i-- != rcvpq.begin (); )
     if (SEQNO_EQ (rcvseq, (*i)->seqno))
       {
+        //printf ("seqno eq %x %x\n", rcvseq, (*i)->seqno);//D
         // enter the packet into our input stream
         r = *i;
         // remove the oldest packet, look forward, as it's oldest first
         for (vector<dns_rcv *>::iterator j = rcvpq.begin (); j != rcvpq.end (); ++j)
           if (SEQNO_EQ ((*j)->seqno, rcvseq - MAX_WINDOW))
             {
+              //printf ("seqno RR %x %x\n", (*j)->seqno, rcvseq - MAX_WINDOW);//D
               delete *j;
               rcvpq.erase (j);
               break;
             }
       {
         dns_connection *dns = (*i)->dns;
         connection *c = dns->c;
         int seqno = (*i)->seqno;
         u8 data[MAXSIZE], *datap = data;
+        //printf ("rcv pkt %x\n", seqno);//D
         if ((*i)->retry)
           {
             dns->send_interval *= 1.01;
             if (dns->send_interval > MAX_SEND_INTERVAL)
 #if 0
             dns->send_interval *= 0.999;
 #endif
             // the latency surely puts an upper bound on
             // the minimum send interval
-            double latency = NOW - (*i)->sent;
+            double latency = ev::ev_now () - (*i)->sent;
             if (latency < dns->min_latency)
               dns->min_latency = latency;
             if (dns->send_interval > dns->min_latency * conf.dns_overlap_factor)
         break;
       }
 }
 void
-vpn::dnsv4_ev (io_watcher &w, short revents)
+vpn::dnsv4_ev (ev::io &w, int revents)
 {
-  if (revents & EVENT_READ)
+  if (revents & EV_READ)
     {
       dns_packet *pkt = new dns_packet;
       struct sockaddr_in sa;
       socklen_t sa_len = sizeof (sa);
   if (!c->dns)
     c->dns = new dns_connection (c);
   if (c->dns->snddq.put (pkt))
-    c->dns->tw.trigger ();
+    c->dns->tw ();
   // always return true even if the buffer overflows
   return true;
 }
 }
 #define NEXT(w) do { if (next > (w)) next = w; } while (0)
 void
-dns_connection::time_cb (time_watcher &w)
+dns_connection::time_cb (ev::timer &w, int revents)
 {
   // servers have to be polled
   if (THISNODE->dns_port)
     return;
   // check for timeouts and (re)transmit
-  tstamp next = NOW + poll_interval;
+  tstamp next = ev::now () + poll_interval;
   dns_snd *send = 0;
   for (vector<dns_snd *>::iterator i = vpn->dns_sndpq.begin ();
        i != vpn->dns_sndpq.end ();
        ++i)
     {
       dns_snd *r = *i;
-      if (r->timeout <= NOW)
+      if (r->timeout <= ev::ev_now ())
         {
           if (!send)
             {
               send = r;
               r->retry++;
-              r->timeout = NOW + (r->retry * min_latency * conf.dns_timeout_factor);
+              r->timeout = ev::ev_now () + (r->retry * min_latency * conf.dns_timeout_factor);
+              //printf ("RETRY %x (%d, %f)\n", r->seqno, r->retry, r->timeout - ev::ev_now ());//D
               // the following code changes the query section a bit, forcing
               // the forwarder to generate a new request
               if (r->stdhdr)
-                {
-                  //printf ("reencoded header for ID %d retry %d:%d:%d (%p)\n", htons (r->pkt->id), THISNODE->id, r->seqno, r->retry);
-                  //encode_header ((char *)r->pkt->at (6 * 2 + 1), THISNODE->id, r->seqno, r->retry);
+                encode_header ((char *)r->pkt->at (6 * 2 + 1), THISNODE->id, r->seqno, r->retry);
-                }
             }
         }
       else
         NEXT (r->timeout);
     }
             }
         }
       else if (vpn->dns_sndpq.size () < conf.dns_max_outstanding
                && !SEQNO_EQ (rcvseq, sndseq - (MAX_WINDOW - 1)))
         {
-          if (last_sent + send_interval <= NOW)
+          if (last_sent + send_interval <= ev::ev_now ())
             {
               //printf ("sending data request etc.\n"); //D
-              if (!snddq.empty () || last_received + 1. > NOW)
+              if (!snddq.empty () || last_received + 1. > ev::ev_now ())
                 {
                   poll_interval = send_interval;
-                  NEXT (NOW + send_interval);
+                  NEXT (ev::ev_now () + send_interval);
                 }
               send = new dns_snd (this);
               send->gen_stream_req (sndseq, snddq);
-              send->timeout = NOW + min_latency * conf.dns_timeout_factor;
+              send->timeout = ev::ev_now () + min_latency * conf.dns_timeout_factor;
+              //printf ("SEND %x (%f)\n", send->seqno, send->timeout - ev::ev_now (), min_latency, conf.dns_timeout_factor);//D
               sndseq = (sndseq + 1) & SEQNO_MASK;
             }
           else
             NEXT (last_sent + send_interval);
         vpn->dns_sndpq.push_back (send);
     }
   if (send)
     {
-      last_sent = NOW;
+      last_sent = ev::ev_now ();
       sendto (vpn->dnsv4_fd,
               send->pkt->at (0), send->pkt->len, 0,
               vpn->dns_forwarder.sav4 (), vpn->dns_forwarder.salenv4 ());
     }
   slog (L_NOISE, "DNS: pi %f si %f N %f (%d:%d %d)",
-        poll_interval, send_interval, next - NOW,
+        poll_interval, send_interval, next - ev::ev_now (),
         vpn->dns_sndpq.size (), snddq.size (),
         rcvpq.size ());
-  // TODO: no idea when this happens, but when next < NOW, we have a problem
+  // TODO: no idea when this happens, but when next < ev::ev_now (), we have a problem
   // doesn't seem to happen anymore
-  if (next < NOW + 0.001)
+  if (next < ev::ev_now () + 0.001)
-    next = NOW + 0.1;
+    next = ev::ev_now () + 0.1;
-  w.start (next);
+  w.start (next - ev::ev_now ());
 }
 #endif

Diff Legend

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

Comparing gvpe/src/vpn_dns.C (file contents): Revision 1.39 by pcg, Tue Apr 26 00:55:56 2005 UTC vs. Revision 1.42 by pcg, Sat Nov 10 05:14:22 2007 UTC

Diff Legend

Comparing gvpe/src/vpn_dns.C (file contents):
Revision 1.39 by pcg, Tue Apr 26 00:55:56 2005 UTC vs.
Revision 1.42 by pcg, Sat Nov 10 05:14:22 2007 UTC