1 files changed, 273 insertions, 273 deletions

diff --git a/src/util/dnsstub.c b/src/util/dnsstub.c
index aa0c2191a..ab7a08318 100644
--- a/src/util/dnsstub.c
+++ b/src/util/dnsstub.c
@@ -11,12 +11,12 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 /**
  * @file dns/dnsstub.c
  * @brief DNS stub resolver which sends DNS requests to an actual resolver
@@ -29,7 +29,7 @@
  * Timeout for retrying DNS queries.
  */
 #define DNS_RETRANSMIT_DELAY \
-  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 250)
+  GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 250)
 
 
 /**
@@ -41,9 +41,7 @@ struct DnsServer;
 /**
  * UDP socket we are using for sending DNS requests to the Internet.
  */
-struct GNUNET_DNSSTUB_RequestSocket
-{
-
+struct GNUNET_DNSSTUB_RequestSocket {
   /**
    * UDP socket we use for this request for IPv4
    */
@@ -99,9 +97,7 @@ struct GNUNET_DNSSTUB_RequestSocket
 /**
  * DNS Server used for resolution.
  */
-struct DnsServer
-{
-
+struct DnsServer {
   /**
    * Kept in a DLL.
    */
@@ -122,9 +118,7 @@ struct DnsServer
 /**
  * Handle to the stub resolver.
  */
-struct GNUNET_DNSSTUB_Context
-{
-
+struct GNUNET_DNSSTUB_Context {
   /**
    * Array of all open sockets for DNS requests.
    */
@@ -158,33 +152,33 @@ struct GNUNET_DNSSTUB_Context
  * @param rs request socket to clean up
  */
 static void
-cleanup_rs (struct GNUNET_DNSSTUB_RequestSocket *rs)
+cleanup_rs(struct GNUNET_DNSSTUB_RequestSocket *rs)
 {
   if (NULL != rs->dnsout4)
-  {
-    GNUNET_NETWORK_socket_close (rs->dnsout4);
-    rs->dnsout4 = NULL;
-  }
+    {
+      GNUNET_NETWORK_socket_close(rs->dnsout4);
+      rs->dnsout4 = NULL;
+    }
   if (NULL != rs->dnsout6)
-  {
-    GNUNET_NETWORK_socket_close (rs->dnsout6);
-    rs->dnsout6 = NULL;
-  }
+    {
+      GNUNET_NETWORK_socket_close(rs->dnsout6);
+      rs->dnsout6 = NULL;
+    }
   if (NULL != rs->read_task)
-  {
-    GNUNET_SCHEDULER_cancel (rs->read_task);
-    rs->read_task = NULL;
-  }
+    {
+      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;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(rs->retry_task);
+      rs->retry_task = NULL;
+    }
   if (NULL != rs->request)
-  {
-    GNUNET_free (rs->request);
-    rs->request = NULL;
-  }
+    {
+      GNUNET_free(rs->request);
+      rs->request = NULL;
+    }
 }
 
 
@@ -195,7 +189,7 @@ cleanup_rs (struct GNUNET_DNSSTUB_RequestSocket *rs)
  * @return #GNUNET_OK on success
  */
 static struct GNUNET_NETWORK_Handle *
-open_socket (int af)
+open_socket(int af)
 {
   struct sockaddr_in a4;
   struct sockaddr_in6 a6;
@@ -203,33 +197,35 @@ open_socket (int af)
   socklen_t alen;
   struct GNUNET_NETWORK_Handle *ret;
 
-  ret = GNUNET_NETWORK_socket_create (af, SOCK_DGRAM, 0);
+  ret = GNUNET_NETWORK_socket_create(af, SOCK_DGRAM, 0);
   if (NULL == ret)
     return NULL;
   switch (af)
-  {
-  case AF_INET:
-    memset (&a4, 0, alen = sizeof (struct sockaddr_in));
-    sa = (struct sockaddr *) &a4;
-    break;
-  case AF_INET6:
-    memset (&a6, 0, alen = sizeof (struct sockaddr_in6));
-    sa = (struct sockaddr *) &a6;
-    break;
-  default:
-    GNUNET_break (0);
-    GNUNET_NETWORK_socket_close (ret);
-    return NULL;
-  }
+    {
+    case AF_INET:
+      memset(&a4, 0, alen = sizeof(struct sockaddr_in));
+      sa = (struct sockaddr *)&a4;
+      break;
+
+    case AF_INET6:
+      memset(&a6, 0, alen = sizeof(struct sockaddr_in6));
+      sa = (struct sockaddr *)&a6;
+      break;
+
+    default:
+      GNUNET_break(0);
+      GNUNET_NETWORK_socket_close(ret);
+      return NULL;
+    }
   sa->sa_family = af;
-  if (GNUNET_OK != GNUNET_NETWORK_socket_bind (ret, sa, alen))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _ ("Could not bind to any port: %s\n"),
-                strerror (errno));
-    GNUNET_NETWORK_socket_close (ret);
-    return NULL;
-  }
+  if (GNUNET_OK != GNUNET_NETWORK_socket_bind(ret, sa, alen))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 _("Could not bind to any port: %s\n"),
+                 strerror(errno));
+      GNUNET_NETWORK_socket_close(ret);
+      return NULL;
+    }
   return ret;
 }
 
@@ -242,38 +238,38 @@ open_socket (int af)
  * @return NULL on error
  */
 static struct GNUNET_DNSSTUB_RequestSocket *
-get_request_socket (struct GNUNET_DNSSTUB_Context *ctx)
+get_request_socket(struct GNUNET_DNSSTUB_Context *ctx)
 {
   struct GNUNET_DNSSTUB_RequestSocket *rs;
 
   for (unsigned int i = 0; i < 256; i++)
-  {
-    rs = &ctx->sockets[GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
-                                                 ctx->num_sockets)];
-    if (NULL == rs->rc)
-      break;
-  }
+    {
+      rs = &ctx->sockets[GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_NONCE,
+                                                  ctx->num_sockets)];
+      if (NULL == rs->rc)
+        break;
+    }
   if (NULL != rs->rc)
-  {
-    /* signal "failure" */
-    rs->rc (rs->rc_cls, NULL, 0);
-    rs->rc = NULL;
-  }
+    {
+      /* signal "failure" */
+      rs->rc(rs->rc_cls, NULL, 0);
+      rs->rc = NULL;
+    }
   if (NULL != rs->read_task)
-  {
-    GNUNET_SCHEDULER_cancel (rs->read_task);
-    rs->read_task = NULL;
-  }
+    {
+      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;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(rs->retry_task);
+      rs->retry_task = NULL;
+    }
   if (NULL != rs->request)
-  {
-    GNUNET_free (rs->request);
-    rs->request = NULL;
-  }
+    {
+      GNUNET_free(rs->request);
+      rs->request = NULL;
+    }
   rs->ctx = ctx;
   return rs;
 }
@@ -288,24 +284,24 @@ get_request_socket (struct GNUNET_DNSSTUB_Context *ctx)
  * @return #GNUNET_OK on success, #GNUNET_NO on drop, #GNUNET_SYSERR on IO-errors (closed socket)
  */
 static int
-do_dns_read (struct GNUNET_DNSSTUB_RequestSocket *rs,
-             struct GNUNET_NETWORK_Handle *dnsout)
+do_dns_read(struct GNUNET_DNSSTUB_RequestSocket *rs,
+            struct GNUNET_NETWORK_Handle *dnsout)
 {
   struct GNUNET_DNSSTUB_Context *ctx = rs->ctx;
   ssize_t r;
   int len;
 
 #ifndef MINGW
-  if (0 != ioctl (GNUNET_NETWORK_get_fd (dnsout), FIONREAD, &len))
-  {
-    /* conservative choice: */
-    len = UINT16_MAX;
-  }
+  if (0 != ioctl(GNUNET_NETWORK_get_fd(dnsout), FIONREAD, &len))
+    {
+      /* conservative choice: */
+      len = UINT16_MAX;
+    }
 #else
   /* port the code above? */
   len = UINT16_MAX;
 #endif
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Receiving %d byte DNS reply\n", len);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Receiving %d byte DNS reply\n", len);
   {
     unsigned char buf[len] GNUNET_ALIGN;
     int found;
@@ -313,51 +309,51 @@ do_dns_read (struct GNUNET_DNSSTUB_RequestSocket *rs,
     socklen_t addrlen;
     struct GNUNET_TUN_DnsHeader *dns;
 
-    addrlen = sizeof (addr);
-    memset (&addr, 0, sizeof (addr));
-    r = GNUNET_NETWORK_socket_recvfrom (dnsout,
-                                        buf,
-                                        sizeof (buf),
-                                        (struct sockaddr *) &addr,
-                                        &addrlen);
+    addrlen = sizeof(addr);
+    memset(&addr, 0, sizeof(addr));
+    r = GNUNET_NETWORK_socket_recvfrom(dnsout,
+                                       buf,
+                                       sizeof(buf),
+                                       (struct sockaddr *)&addr,
+                                       &addrlen);
     if (-1 == r)
-    {
-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "recvfrom");
-      GNUNET_NETWORK_socket_close (dnsout);
-      return GNUNET_SYSERR;
-    }
+      {
+        GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "recvfrom");
+        GNUNET_NETWORK_socket_close(dnsout);
+        return GNUNET_SYSERR;
+      }
     found = GNUNET_NO;
     for (struct DnsServer *ds = ctx->dns_head; NULL != ds; ds = ds->next)
-    {
-      if (0 == memcmp (&addr,
-                       &ds->ss,
-                       GNUNET_MIN (sizeof (struct sockaddr_storage), addrlen)))
       {
-        found = GNUNET_YES;
-        break;
+        if (0 == memcmp(&addr,
+                        &ds->ss,
+                        GNUNET_MIN(sizeof(struct sockaddr_storage), addrlen)))
+          {
+            found = GNUNET_YES;
+            break;
+          }
       }
-    }
     if (GNUNET_NO == found)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Received DNS response from server we never asked (ignored)");
-      return GNUNET_NO;
-    }
-    if (sizeof (struct GNUNET_TUN_DnsHeader) > (size_t) r)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _ ("Received DNS response that is too small (%u bytes)"),
-                  (unsigned int) r);
-      return GNUNET_NO;
-    }
-    dns = (struct GNUNET_TUN_DnsHeader *) buf;
+      {
+        GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                   "Received DNS response from server we never asked (ignored)");
+        return GNUNET_NO;
+      }
+    if (sizeof(struct GNUNET_TUN_DnsHeader) > (size_t)r)
+      {
+        GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                   _("Received DNS response that is too small (%u bytes)"),
+                   (unsigned int)r);
+        return GNUNET_NO;
+      }
+    dns = (struct GNUNET_TUN_DnsHeader *)buf;
     if (NULL == rs->rc)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Request timeout or cancelled; ignoring reply\n");
-      return GNUNET_NO;
-    }
-    rs->rc (rs->rc_cls, dns, r);
+      {
+        GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                   "Request timeout or cancelled; ignoring reply\n");
+        return GNUNET_NO;
+      }
+    rs->rc(rs->rc_cls, dns, r);
   }
   return GNUNET_OK;
 }
@@ -369,7 +365,7 @@ do_dns_read (struct GNUNET_DNSSTUB_RequestSocket *rs,
  * @param cls socket to read from
  */
 static void
-read_response (void *cls);
+read_response(void *cls);
 
 
 /**
@@ -378,25 +374,25 @@ read_response (void *cls);
  * @param rs request to schedule read operation for
  */
 static void
-schedule_read (struct GNUNET_DNSSTUB_RequestSocket *rs)
+schedule_read(struct GNUNET_DNSSTUB_RequestSocket *rs)
 {
   struct GNUNET_NETWORK_FDSet *rset;
 
   if (NULL != rs->read_task)
-    GNUNET_SCHEDULER_cancel (rs->read_task);
-  rset = GNUNET_NETWORK_fdset_create ();
+    GNUNET_SCHEDULER_cancel(rs->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_UNIT_FOREVER_REL,
-                                 rset,
-                                 NULL,
-                                 &read_response,
-                                 rs);
-  GNUNET_NETWORK_fdset_destroy (rset);
+    GNUNET_SCHEDULER_add_select(GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                GNUNET_TIME_UNIT_FOREVER_REL,
+                                rset,
+                                NULL,
+                                &read_response,
+                                rs);
+  GNUNET_NETWORK_fdset_destroy(rset);
 }
 
 
@@ -406,24 +402,24 @@ schedule_read (struct GNUNET_DNSSTUB_RequestSocket *rs)
  * @param cls `struct GNUNET_DNSSTUB_RequestSocket` to read from
  */
 static void
-read_response (void *cls)
+read_response(void *cls)
 {
   struct GNUNET_DNSSTUB_RequestSocket *rs = cls;
   const struct GNUNET_SCHEDULER_TaskContext *tc;
 
   rs->read_task = NULL;
-  tc = GNUNET_SCHEDULER_get_task_context ();
+  tc = GNUNET_SCHEDULER_get_task_context();
   /* 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 */
-  schedule_read (rs);
+  schedule_read(rs);
 }
 
 
@@ -434,7 +430,7 @@ read_response (void *cls)
  * @param cls our `struct GNUNET_DNSSTUB_RequestSocket *`
  */
 static void
-transmit_query (void *cls)
+transmit_query(void *cls)
 {
   struct GNUNET_DNSSTUB_RequestSocket *rs = cls;
   struct GNUNET_DNSSTUB_Context *ctx = rs->ctx;
@@ -444,52 +440,54 @@ transmit_query (void *cls)
   struct GNUNET_NETWORK_Handle *dnsout;
 
   rs->retry_task =
-    GNUNET_SCHEDULER_add_delayed (ctx->retry_freq, &transmit_query, rs);
+    GNUNET_SCHEDULER_add_delayed(ctx->retry_freq, &transmit_query, rs);
   ds = rs->ds_pos;
   rs->ds_pos = ds->next;
   if (NULL == rs->ds_pos)
     rs->ds_pos = ctx->dns_head;
-  GNUNET_assert (NULL != ds);
+  GNUNET_assert(NULL != ds);
   dnsout = NULL;
   switch (ds->ss.ss_family)
-  {
-  case AF_INET:
-    if (NULL == rs->dnsout4)
-      rs->dnsout4 = open_socket (AF_INET);
-    dnsout = rs->dnsout4;
-    sa = (const struct sockaddr *) &ds->ss;
-    salen = sizeof (struct sockaddr_in);
-    break;
-  case AF_INET6:
-    if (NULL == rs->dnsout6)
-      rs->dnsout6 = open_socket (AF_INET6);
-    dnsout = rs->dnsout6;
-    sa = (const struct sockaddr *) &ds->ss;
-    salen = sizeof (struct sockaddr_in6);
-    break;
-  default:
-    return;
-  }
+    {
+    case AF_INET:
+      if (NULL == rs->dnsout4)
+        rs->dnsout4 = open_socket(AF_INET);
+      dnsout = rs->dnsout4;
+      sa = (const struct sockaddr *)&ds->ss;
+      salen = sizeof(struct sockaddr_in);
+      break;
+
+    case AF_INET6:
+      if (NULL == rs->dnsout6)
+        rs->dnsout6 = open_socket(AF_INET6);
+      dnsout = rs->dnsout6;
+      sa = (const struct sockaddr *)&ds->ss;
+      salen = sizeof(struct sockaddr_in6);
+      break;
+
+    default:
+      return;
+    }
   if (NULL == dnsout)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Unable to use configure DNS server, skipping\n");
-    return;
-  }
-  if (GNUNET_SYSERR == GNUNET_NETWORK_socket_sendto (dnsout,
-                                                     rs->request,
-                                                     rs->request_len,
-                                                     sa,
-                                                     salen))
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _ ("Failed to send DNS request to %s: %s\n"),
-                GNUNET_a2s (sa, salen),
-                strerror (errno));
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "Unable to use configure DNS server, skipping\n");
+      return;
+    }
+  if (GNUNET_SYSERR == GNUNET_NETWORK_socket_sendto(dnsout,
+                                                    rs->request,
+                                                    rs->request_len,
+                                                    sa,
+                                                    salen))
+    GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+               _("Failed to send DNS request to %s: %s\n"),
+               GNUNET_a2s(sa, salen),
+               strerror(errno));
   else
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                _ ("Sent DNS request to %s\n"),
-                GNUNET_a2s (sa, salen));
-  schedule_read (rs);
+    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+               _("Sent DNS request to %s\n"),
+               GNUNET_a2s(sa, salen));
+  schedule_read(rs);
 }
 
 
@@ -504,32 +502,32 @@ transmit_query (void *cls)
  * @return socket used for the request, NULL on error
  */
 struct GNUNET_DNSSTUB_RequestSocket *
-GNUNET_DNSSTUB_resolve (struct GNUNET_DNSSTUB_Context *ctx,
-                        const void *request,
-                        size_t request_len,
-                        GNUNET_DNSSTUB_ResultCallback rc,
-                        void *rc_cls)
+GNUNET_DNSSTUB_resolve(struct GNUNET_DNSSTUB_Context *ctx,
+                       const void *request,
+                       size_t request_len,
+                       GNUNET_DNSSTUB_ResultCallback rc,
+                       void *rc_cls)
 {
   struct GNUNET_DNSSTUB_RequestSocket *rs;
 
   if (NULL == ctx->dns_head)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "No DNS server configured for resolution\n");
-    return NULL;
-  }
-  if (NULL == (rs = get_request_socket (ctx)))
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "No request socket available for DNS resolution\n");
-    return NULL;
-  }
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "No DNS server configured for resolution\n");
+      return NULL;
+    }
+  if (NULL == (rs = get_request_socket(ctx)))
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+                 "No request socket available for DNS resolution\n");
+      return NULL;
+    }
   rs->ds_pos = ctx->dns_head;
   rs->rc = rc;
   rs->rc_cls = rc_cls;
-  rs->request = GNUNET_memdup (request, request_len);
+  rs->request = GNUNET_memdup(request, request_len);
   rs->request_len = request_len;
-  rs->retry_task = GNUNET_SCHEDULER_add_now (&transmit_query, rs);
+  rs->retry_task = GNUNET_SCHEDULER_add_now(&transmit_query, rs);
   return rs;
 }
 
@@ -540,19 +538,19 @@ GNUNET_DNSSTUB_resolve (struct GNUNET_DNSSTUB_Context *ctx,
  * @param rs resolution to cancel
  */
 void
-GNUNET_DNSSTUB_resolve_cancel (struct GNUNET_DNSSTUB_RequestSocket *rs)
+GNUNET_DNSSTUB_resolve_cancel(struct GNUNET_DNSSTUB_RequestSocket *rs)
 {
   rs->rc = NULL;
   if (NULL != rs->retry_task)
-  {
-    GNUNET_SCHEDULER_cancel (rs->retry_task);
-    rs->retry_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(rs->retry_task);
+      rs->retry_task = NULL;
+    }
   if (NULL != rs->read_task)
-  {
-    GNUNET_SCHEDULER_cancel (rs->read_task);
-    rs->read_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(rs->read_task);
+      rs->read_task = NULL;
+    }
 }
 
 
@@ -564,19 +562,19 @@ GNUNET_DNSSTUB_resolve_cancel (struct GNUNET_DNSSTUB_RequestSocket *rs)
  * @return NULL on error
  */
 struct GNUNET_DNSSTUB_Context *
-GNUNET_DNSSTUB_start (unsigned int num_sockets)
+GNUNET_DNSSTUB_start(unsigned int num_sockets)
 {
   struct GNUNET_DNSSTUB_Context *ctx;
 
   if (0 == num_sockets)
-  {
-    GNUNET_break (0);
-    return NULL;
-  }
-  ctx = GNUNET_new (struct GNUNET_DNSSTUB_Context);
+    {
+      GNUNET_break(0);
+      return NULL;
+    }
+  ctx = GNUNET_new(struct GNUNET_DNSSTUB_Context);
   ctx->num_sockets = num_sockets;
   ctx->sockets =
-    GNUNET_new_array (num_sockets, struct GNUNET_DNSSTUB_RequestSocket);
+    GNUNET_new_array(num_sockets, struct GNUNET_DNSSTUB_RequestSocket);
   ctx->retry_freq = DNS_RETRANSMIT_DELAY;
   return ctx;
 }
@@ -591,45 +589,45 @@ GNUNET_DNSSTUB_start (unsigned int num_sockets)
  * @return #GNUNET_OK on success
  */
 int
-GNUNET_DNSSTUB_add_dns_ip (struct GNUNET_DNSSTUB_Context *ctx,
-                           const char *dns_ip)
+GNUNET_DNSSTUB_add_dns_ip(struct GNUNET_DNSSTUB_Context *ctx,
+                          const char *dns_ip)
 {
   struct DnsServer *ds;
   struct in_addr i4;
   struct in6_addr i6;
 
-  ds = GNUNET_new (struct DnsServer);
-  if (1 == inet_pton (AF_INET, dns_ip, &i4))
-  {
-    struct sockaddr_in *s4 = (struct sockaddr_in *) &ds->ss;
+  ds = GNUNET_new(struct DnsServer);
+  if (1 == inet_pton(AF_INET, dns_ip, &i4))
+    {
+      struct sockaddr_in *s4 = (struct sockaddr_in *)&ds->ss;
 
-    s4->sin_family = AF_INET;
-    s4->sin_port = htons (53);
-    s4->sin_addr = i4;
+      s4->sin_family = AF_INET;
+      s4->sin_port = htons(53);
+      s4->sin_addr = i4;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-    s4->sin_len = (u_char) sizeof (struct sockaddr_in);
+      s4->sin_len = (u_char)sizeof(struct sockaddr_in);
 #endif
-  }
-  else if (1 == inet_pton (AF_INET6, dns_ip, &i6))
-  {
-    struct sockaddr_in6 *s6 = (struct sockaddr_in6 *) &ds->ss;
+    }
+  else if (1 == inet_pton(AF_INET6, dns_ip, &i6))
+    {
+      struct sockaddr_in6 *s6 = (struct sockaddr_in6 *)&ds->ss;
 
-    s6->sin6_family = AF_INET6;
-    s6->sin6_port = htons (53);
-    s6->sin6_addr = i6;
+      s6->sin6_family = AF_INET6;
+      s6->sin6_port = htons(53);
+      s6->sin6_addr = i6;
 #if HAVE_SOCKADDR_IN_SIN_LEN
-    s6->sin6_len = (u_char) sizeof (struct sockaddr_in6);
+      s6->sin6_len = (u_char)sizeof(struct sockaddr_in6);
 #endif
-  }
+    }
   else
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Malformed IP address `%s' for DNS server\n",
-                dns_ip);
-    GNUNET_free (ds);
-    return GNUNET_SYSERR;
-  }
-  GNUNET_CONTAINER_DLL_insert (ctx->dns_head, ctx->dns_tail, ds);
+    {
+      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+                 "Malformed IP address `%s' for DNS server\n",
+                 dns_ip);
+      GNUNET_free(ds);
+      return GNUNET_SYSERR;
+    }
+  GNUNET_CONTAINER_DLL_insert(ctx->dns_head, ctx->dns_tail, ds);
   return GNUNET_OK;
 }
 
@@ -643,26 +641,28 @@ GNUNET_DNSSTUB_add_dns_ip (struct GNUNET_DNSSTUB_Context *ctx,
  * @return #GNUNET_OK on success
  */
 int
-GNUNET_DNSSTUB_add_dns_sa (struct GNUNET_DNSSTUB_Context *ctx,
-                           const struct sockaddr *sa)
+GNUNET_DNSSTUB_add_dns_sa(struct GNUNET_DNSSTUB_Context *ctx,
+                          const struct sockaddr *sa)
 {
   struct DnsServer *ds;
 
-  ds = GNUNET_new (struct DnsServer);
+  ds = GNUNET_new(struct DnsServer);
   switch (sa->sa_family)
-  {
-  case AF_INET:
-    GNUNET_memcpy (&ds->ss, sa, sizeof (struct sockaddr_in));
-    break;
-  case AF_INET6:
-    GNUNET_memcpy (&ds->ss, sa, sizeof (struct sockaddr_in6));
-    break;
-  default:
-    GNUNET_break (0);
-    GNUNET_free (ds);
-    return GNUNET_SYSERR;
-  }
-  GNUNET_CONTAINER_DLL_insert (ctx->dns_head, ctx->dns_tail, ds);
+    {
+    case AF_INET:
+      GNUNET_memcpy(&ds->ss, sa, sizeof(struct sockaddr_in));
+      break;
+
+    case AF_INET6:
+      GNUNET_memcpy(&ds->ss, sa, sizeof(struct sockaddr_in6));
+      break;
+
+    default:
+      GNUNET_break(0);
+      GNUNET_free(ds);
+      return GNUNET_SYSERR;
+    }
+  GNUNET_CONTAINER_DLL_insert(ctx->dns_head, ctx->dns_tail, ds);
   return GNUNET_OK;
 }
 
@@ -675,8 +675,8 @@ GNUNET_DNSSTUB_add_dns_sa (struct GNUNET_DNSSTUB_Context *ctx,
  * @param retry_freq how long to wait between retries
  */
 void
-GNUNET_DNSSTUB_set_retry (struct GNUNET_DNSSTUB_Context *ctx,
-                          struct GNUNET_TIME_Relative retry_freq)
+GNUNET_DNSSTUB_set_retry(struct GNUNET_DNSSTUB_Context *ctx,
+                         struct GNUNET_TIME_Relative retry_freq)
 {
   ctx->retry_freq = retry_freq;
 }
@@ -688,19 +688,19 @@ GNUNET_DNSSTUB_set_retry (struct GNUNET_DNSSTUB_Context *ctx,
  * @param ctx stub resolver to clean up
  */
 void
-GNUNET_DNSSTUB_stop (struct GNUNET_DNSSTUB_Context *ctx)
+GNUNET_DNSSTUB_stop(struct GNUNET_DNSSTUB_Context *ctx)
 {
   struct DnsServer *ds;
 
   while (NULL != (ds = ctx->dns_head))
-  {
-    GNUNET_CONTAINER_DLL_remove (ctx->dns_head, ctx->dns_tail, ds);
-    GNUNET_free (ds);
-  }
+    {
+      GNUNET_CONTAINER_DLL_remove(ctx->dns_head, ctx->dns_tail, ds);
+      GNUNET_free(ds);
+    }
   for (unsigned int i = 0; i < ctx->num_sockets; i++)
-    cleanup_rs (&ctx->sockets[i]);
-  GNUNET_free (ctx->sockets);
-  GNUNET_free (ctx);
+    cleanup_rs(&ctx->sockets[i]);
+  GNUNET_free(ctx->sockets);
+  GNUNET_free(ctx);
 }