X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fdns%2Fdnsstub.c;h=f9dc7a6966c13dc773fb8f7ee406190551748df6;hb=081f818a024f52aca9de82fc2c8c1cc181603455;hp=68cd55275085ed85a70f8824e7f88b4d6af79798;hpb=64732cdb0d95320d9274b26fcac6e617d6473248;p=oweals%2Fgnunet.git

diff --git a/src/dns/dnsstub.c b/src/dns/dnsstub.c
index 68cd55275..f9dc7a696 100644
--- a/src/dns/dnsstub.c
+++ b/src/dns/dnsstub.c
@@ -32,6 +32,11 @@
  */
 #define REQUEST_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5)
 
+/**
+ * Timeout for retrying DNS queries.
+ */
+#define DNS_RETRANSMIT_DELAY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 250)
+
 /**
  * How many DNS sockets do we open at most at the same time?
  * (technical socket maximum is this number x2 for IPv4+IPv6)
@@ -68,7 +73,12 @@ struct GNUNET_DNSSTUB_RequestSocket
   /**
    * Task for reading from dnsout4 and dnsout6.
    */
-  struct GNUNET_SCHEDULER_Task * read_task;
+  struct GNUNET_SCHEDULER_Task *read_task;
+
+  /**
+   * Task for retrying transmission of the query.
+   */
+  struct GNUNET_SCHEDULER_Task *retry_task;
 
   /**
    * When should this request time out?
@@ -85,6 +95,16 @@ struct GNUNET_DNSSTUB_RequestSocket
    */
   socklen_t addrlen;
 
+  /**
+   * Query we sent to @e addr.
+   */
+  void *request;
+
+  /**
+   * Number of bytes in @a request.
+   */
+  size_t request_len;
+
 };
 
 
@@ -107,7 +127,6 @@ struct GNUNET_DNSSTUB_Context
 };
 
 
-
 /**
  * We're done with a `struct GNUNET_DNSSTUB_RequestSocket`, close it for now.
  *
@@ -131,6 +150,16 @@ cleanup_rs (struct GNUNET_DNSSTUB_RequestSocket *rs)
     GNUNET_SCHEDULER_cancel (rs->read_task);
     rs->read_task = NULL;
   }
+  if (NULL != rs->retry_task)
+  {
+    GNUNET_SCHEDULER_cancel (rs->retry_task);
+    rs->retry_task = NULL;
+  }
+  if (NULL != rs->request)
+  {
+    GNUNET_free (rs->request);
+    rs->request = NULL;
+  }
 }
 
 
@@ -206,8 +235,22 @@ get_request_socket (struct GNUNET_DNSSTUB_Context *ctx,
   struct GNUNET_DNSSTUB_RequestSocket *rs;
   struct GNUNET_NETWORK_FDSet *rset;
 
-  rs = &ctx->sockets[GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
-					       DNS_SOCKET_MAX)];
+  for (unsigned int i=0;i<256;i++)
+  {
+    rs = &ctx->sockets[GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
+                                                 DNS_SOCKET_MAX)];
+    if (NULL == rs->rc)
+      break;
+  }
+  if (NULL != rs->rc)
+  {
+    /* signal "failure" */
+    rs->rc (rs->rc_cls,
+            rs,
+            NULL,
+            0);
+    rs->rc = NULL;
+  }
   rs->timeout = GNUNET_TIME_relative_to_absolute (REQUEST_TIMEOUT);
   switch (af)
   {
@@ -227,34 +270,83 @@ get_request_socket (struct GNUNET_DNSSTUB_Context *ctx,
     GNUNET_SCHEDULER_cancel (rs->read_task);
     rs->read_task = NULL;
   }
+  if (NULL != rs->retry_task)
+  {
+    GNUNET_SCHEDULER_cancel (rs->retry_task);
+    rs->retry_task = NULL;
+  }
+  if (NULL != rs->request)
+  {
+    GNUNET_free (rs->request);
+    rs->request = NULL;
+  }
   if ( (NULL == rs->dnsout4) &&
        (NULL == rs->dnsout6) )
     return NULL;
   rset = GNUNET_NETWORK_fdset_create ();
   if (NULL != rs->dnsout4)
-    GNUNET_NETWORK_fdset_set (rset, rs->dnsout4);
+    GNUNET_NETWORK_fdset_set (rset,
+                              rs->dnsout4);
   if (NULL != rs->dnsout6)
-    GNUNET_NETWORK_fdset_set (rset, rs->dnsout6);
+    GNUNET_NETWORK_fdset_set (rset,
+                              rs->dnsout6);
   rs->read_task = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
 					       REQUEST_TIMEOUT,
 					       rset,
 					       NULL,
-					       &read_response, rs);
+					       &read_response,
+                                               rs);
   GNUNET_NETWORK_fdset_destroy (rset);
   return rs;
 }
 
 
+/**
+ * Task to (re)transmit the DNS query, possibly repeatedly until
+ * we succeed.
+ *
+ * @param cls our `struct GNUNET_DNSSTUB_RequestSocket *`
+ */
+static void
+transmit_query (void *cls)
+{
+  struct GNUNET_DNSSTUB_RequestSocket *rs = cls;
+  struct GNUNET_NETWORK_Handle *ret;
+
+  rs->retry_task = NULL;
+  ret = (NULL != rs->dnsout4) ? rs->dnsout4 : rs->dnsout6;
+  GNUNET_assert (NULL != ret);
+  if (GNUNET_SYSERR ==
+      GNUNET_NETWORK_socket_sendto (ret,
+				    rs->request,
+				    rs->request_len,
+				    (struct sockaddr *) &rs->addr,
+				    rs->addrlen))
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+		_("Failed to send DNS request to %s\n"),
+		GNUNET_a2s ((struct sockaddr *) &rs->addr,
+                            rs->addrlen));
+  else
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+		_("Sent DNS request to %s\n"),
+		GNUNET_a2s ((struct sockaddr *) &rs->addr,
+                            rs->addrlen));
+  rs->retry_task = GNUNET_SCHEDULER_add_delayed (DNS_RETRANSMIT_DELAY,
+                                                 &transmit_query,
+                                                 rs);
+}
+
+
 /**
  * Perform DNS resolution.
  *
  * @param ctx stub resolver to use
  * @param sa the socket address
- * @param sa_len the socket length
+ * @param sa_len the length of @a sa
  * @param request DNS request to transmit
- * @param request_len number of bytes in msg
+ * @param request_len number of bytes in @a request
  * @param rc function to call with result
- * @param rc_cls closure for 'rc'
+ * @param rc_cls closure for @a rc
  * @return socket used for the request, NULL on error
  */
 struct GNUNET_DNSSTUB_RequestSocket *
@@ -267,36 +359,22 @@ GNUNET_DNSSTUB_resolve (struct GNUNET_DNSSTUB_Context *ctx,
 			void *rc_cls)
 {
   struct GNUNET_DNSSTUB_RequestSocket *rs;
-  struct GNUNET_NETWORK_Handle *ret;
-  int af;
 
-  af = sa->sa_family;
-  if (NULL == (rs = get_request_socket (ctx, af)))
+  if (NULL == (rs = get_request_socket (ctx,
+                                        sa->sa_family)))
     return NULL;
-  if (NULL != rs->dnsout4)
-    ret = rs->dnsout4;
-  else
-    ret = rs->dnsout6;
-  GNUNET_assert (NULL != ret);
+  GNUNET_assert (NULL == rs->rc);
   GNUNET_memcpy (&rs->addr,
-	  sa,
-	  sa_len);
+                 sa,
+                 sa_len);
   rs->addrlen = sa_len;
   rs->rc = rc;
   rs->rc_cls = rc_cls;
-  if (GNUNET_SYSERR ==
-      GNUNET_NETWORK_socket_sendto (ret,
-				    request,
-				    request_len,
-				    sa,
-				    sa_len))
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-		_("Failed to send DNS request to %s\n"),
-		GNUNET_a2s (sa, sa_len));
-  else
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-		_("Sent DNS request to %s\n"),
-		GNUNET_a2s (sa, sa_len));
+  rs->request = GNUNET_memdup (request,
+                               request_len);
+  rs->request_len = request_len;
+  rs->retry_task = GNUNET_SCHEDULER_add_now (&transmit_query,
+                                             rs);
   return rs;
 }
 
@@ -328,7 +406,9 @@ GNUNET_DNSSTUB_resolve2 (struct GNUNET_DNSSTUB_Context *ctx,
 
   memset (&v4, 0, sizeof (v4));
   memset (&v6, 0, sizeof (v6));
-  if (1 == inet_pton (AF_INET, ctx->dns_exit, &v4.sin_addr))
+  if (1 == inet_pton (AF_INET,
+                      ctx->dns_exit,
+                      &v4.sin_addr))
   {
     salen = sizeof (v4);
     v4.sin_family = AF_INET;
@@ -339,7 +419,9 @@ GNUNET_DNSSTUB_resolve2 (struct GNUNET_DNSSTUB_Context *ctx,
     sa = (struct sockaddr *) &v4;
     af = AF_INET;
   }
-  else if (1 == inet_pton (AF_INET6, ctx->dns_exit, &v6.sin6_addr))
+  else if (1 == inet_pton (AF_INET6,
+                           ctx->dns_exit,
+                           &v6.sin6_addr))
   {
     salen = sizeof (v6);
     v6.sin6_family = AF_INET6;
@@ -355,8 +437,10 @@ GNUNET_DNSSTUB_resolve2 (struct GNUNET_DNSSTUB_Context *ctx,
     GNUNET_break (0);
     return NULL;
   }
-  if (NULL == (rs = get_request_socket (ctx, af)))
+  if (NULL == (rs = get_request_socket (ctx,
+                                        af)))
     return NULL;
+  GNUNET_assert (NULL == rs->rc);
   if (NULL != rs->dnsout4)
     dnsout = rs->dnsout4;
   else
@@ -369,15 +453,17 @@ GNUNET_DNSSTUB_resolve2 (struct GNUNET_DNSSTUB_Context *ctx,
     return NULL;
   }
   GNUNET_memcpy (&rs->addr,
-	  sa,
-	  salen);
+                 sa,
+                 salen);
   rs->addrlen = salen;
   rs->rc = rc;
   rs->rc_cls = rc_cls;
   if (GNUNET_SYSERR ==
       GNUNET_NETWORK_socket_sendto (dnsout,
 				    request,
-				    request_len, sa, salen))
+				    request_len,
+                                    sa,
+                                    salen))
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 		_("Failed to send DNS request to %s\n"),
 		GNUNET_a2s (sa, salen));
@@ -405,7 +491,9 @@ do_dns_read (struct GNUNET_DNSSTUB_RequestSocket *rs,
   int len;
 
 #ifndef MINGW
-  if (0 != ioctl (GNUNET_NETWORK_get_fd (dnsout), FIONREAD, &len))
+  if (0 != ioctl (GNUNET_NETWORK_get_fd (dnsout),
+                  FIONREAD,
+                  &len))
   {
     /* conservative choice: */
     len = UINT16_MAX;
@@ -423,11 +511,14 @@ do_dns_read (struct GNUNET_DNSSTUB_RequestSocket *rs,
     addrlen = sizeof (addr);
     memset (&addr, 0, sizeof (addr));
     r = GNUNET_NETWORK_socket_recvfrom (dnsout,
-					buf, sizeof (buf),
-					(struct sockaddr*) &addr, &addrlen);
+					buf,
+                                        sizeof (buf),
+					(struct sockaddr*) &addr,
+                                        &addrlen);
     if (-1 == r)
     {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "recvfrom");
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
+                           "recvfrom");
       GNUNET_NETWORK_socket_close (dnsout);
       return GNUNET_SYSERR;
     }
@@ -476,31 +567,47 @@ read_response (void *cls)
   tc = GNUNET_SCHEDULER_get_task_context ();
   if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY))
   {
+    /* signal "failure" (from timeout) */
+    if (NULL != rs->rc)
+    {
+      rs->rc (rs->rc_cls,
+              rs,
+              NULL,
+              0);
+      rs->rc = NULL;
+    }
     /* timeout */
     cleanup_rs (rs);
     return;
   }
   /* read and process ready sockets */
   if ((NULL != rs->dnsout4) &&
-      (GNUNET_NETWORK_fdset_isset (tc->read_ready, rs->dnsout4)) &&
-      (GNUNET_SYSERR == do_dns_read (rs, rs->dnsout4)))
+      (GNUNET_NETWORK_fdset_isset (tc->read_ready,
+                                   rs->dnsout4)) &&
+      (GNUNET_SYSERR == do_dns_read (rs,
+                                     rs->dnsout4)))
     rs->dnsout4 = NULL;
   if ((NULL != rs->dnsout6) &&
-      (GNUNET_NETWORK_fdset_isset (tc->read_ready, rs->dnsout6)) &&
-      (GNUNET_SYSERR == do_dns_read (rs, rs->dnsout6)))
+      (GNUNET_NETWORK_fdset_isset (tc->read_ready,
+                                   rs->dnsout6)) &&
+      (GNUNET_SYSERR == do_dns_read (rs,
+                                     rs->dnsout6)))
     rs->dnsout6 = NULL;
 
   /* re-schedule read task */
   rset = GNUNET_NETWORK_fdset_create ();
   if (NULL != rs->dnsout4)
-    GNUNET_NETWORK_fdset_set (rset, rs->dnsout4);
+    GNUNET_NETWORK_fdset_set (rset,
+                              rs->dnsout4);
   if (NULL != rs->dnsout6)
-    GNUNET_NETWORK_fdset_set (rset, rs->dnsout6);
+    GNUNET_NETWORK_fdset_set (rset,
+                              rs->dnsout6);
   rs->read_task = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
 					       GNUNET_TIME_absolute_get_remaining (rs->timeout),
 					       rset,
 					       NULL,
-					       &read_response, rs);
+					       &read_response,
+                                               rs);
   GNUNET_NETWORK_fdset_destroy (rset);
 }