1 files changed, 238 insertions, 233 deletions

diff --git a/src/gns/gnunet-service-gns.c b/src/gns/gnunet-service-gns.c
index 5bfaf4859..57ab393b0 100644
--- a/src/gns/gnunet-service-gns.c
+++ b/src/gns/gnunet-service-gns.c
@@ -46,7 +46,8 @@ struct GnsClient;
 /**
  * Handle to a lookup operation from client via API.
  */
-struct ClientLookupHandle {
+struct ClientLookupHandle
+{
   /**
    * We keep these in a DLL.
    */
@@ -77,7 +78,8 @@ struct ClientLookupHandle {
 /**
  * Information we track per connected client.
  */
-struct GnsClient {
+struct GnsClient
+{
   /**
    * The client
    */
@@ -104,7 +106,8 @@ struct GnsClient {
  * Representation of a TLD, mapping the respective TLD string
  * (i.e. ".gnu") to the respective public key of the zone.
  */
-struct GNS_TopLevelDomain {
+struct GNS_TopLevelDomain
+{
   /**
    * Kept in a DLL, as there are unlikely enough of these to
    * warrant a hash map.
@@ -173,25 +176,25 @@ static struct GNS_TopLevelDomain *tld_tail;
  * @return #GNUNET_YES if @a tld was found #GNUNET_NO if not
  */
 int
-GNS_find_tld(const char *tld_str,
-             struct GNUNET_CRYPTO_EcdsaPublicKey *pkey)
+GNS_find_tld (const char *tld_str,
+              struct GNUNET_CRYPTO_EcdsaPublicKey *pkey)
 {
   if ('\0' == *tld_str)
     return GNUNET_NO;
   for (struct GNS_TopLevelDomain *tld = tld_head;
        NULL != tld;
        tld = tld->next)
+  {
+    if (0 == strcasecmp (tld_str,
+                         tld->tld))
     {
-      if (0 == strcasecmp(tld_str,
-                          tld->tld))
-        {
-          *pkey = tld->pkey;
-          return GNUNET_YES;
-        }
+      *pkey = tld->pkey;
+      return GNUNET_YES;
     }
+  }
   if (GNUNET_OK ==
-      GNUNET_GNSRECORD_zkey_to_pkey(tld_str + 1,
-                                    pkey))
+      GNUNET_GNSRECORD_zkey_to_pkey (tld_str + 1,
+                                     pkey))
     return GNUNET_YES; /* TLD string *was* the public key */
   return GNUNET_NO;
 }
@@ -205,12 +208,12 @@ GNS_find_tld(const char *tld_str,
  *         or @a name if @a name does not contain a "."
  */
 const char *
-GNS_get_tld(const char *name)
+GNS_get_tld (const char *name)
 {
   const char *tld;
 
-  tld = strrchr(name,
-                (unsigned char)'.');
+  tld = strrchr (name,
+                 (unsigned char) '.');
   if (NULL == tld)
     tld = name;
   else
@@ -225,39 +228,39 @@ GNS_get_tld(const char *name)
  * @param cls unused, NULL
  */
 static void
-shutdown_task(void *cls)
+shutdown_task (void *cls)
 {
   struct GNS_TopLevelDomain *tld;
 
-  (void)cls;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Shutting down!\n");
-  GNS_interceptor_done();
-  GNS_resolver_done();
+  (void) cls;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Shutting down!\n");
+  GNS_interceptor_done ();
+  GNS_resolver_done ();
   if (NULL != statistics)
-    {
-      GNUNET_STATISTICS_destroy(statistics,
-                                GNUNET_NO);
-      statistics = NULL;
-    }
+  {
+    GNUNET_STATISTICS_destroy (statistics,
+                               GNUNET_NO);
+    statistics = NULL;
+  }
   if (NULL != namecache_handle)
-    {
-      GNUNET_NAMECACHE_disconnect(namecache_handle);
-      namecache_handle = NULL;
-    }
+  {
+    GNUNET_NAMECACHE_disconnect (namecache_handle);
+    namecache_handle = NULL;
+  }
   if (NULL != dht_handle)
-    {
-      GNUNET_DHT_disconnect(dht_handle);
-      dht_handle = NULL;
-    }
+  {
+    GNUNET_DHT_disconnect (dht_handle);
+    dht_handle = NULL;
+  }
   while (NULL != (tld = tld_head))
-    {
-      GNUNET_CONTAINER_DLL_remove(tld_head,
-                                  tld_tail,
-                                  tld);
-      GNUNET_free(tld->tld);
-      GNUNET_free(tld);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (tld_head,
+                                 tld_tail,
+                                 tld);
+    GNUNET_free (tld->tld);
+    GNUNET_free (tld);
+  }
 }
 
 
@@ -269,27 +272,27 @@ shutdown_task(void *cls)
  * @param app_ctx @a client
  */
 static void
-client_disconnect_cb(void *cls,
-                     struct GNUNET_SERVICE_Client *client,
-                     void *app_ctx)
+client_disconnect_cb (void *cls,
+                      struct GNUNET_SERVICE_Client *client,
+                      void *app_ctx)
 {
   struct ClientLookupHandle *clh;
   struct GnsClient *gc = app_ctx;
 
-  (void)cls;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Client %p disconnected\n",
-             client);
+  (void) cls;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Client %p disconnected\n",
+              client);
   while (NULL != (clh = gc->clh_head))
-    {
-      if (NULL != clh->lookup)
-        GNS_resolver_lookup_cancel(clh->lookup);
-      GNUNET_CONTAINER_DLL_remove(gc->clh_head,
-                                  gc->clh_tail,
-                                  clh);
-      GNUNET_free(clh);
-    }
-  GNUNET_free(gc);
+  {
+    if (NULL != clh->lookup)
+      GNS_resolver_lookup_cancel (clh->lookup);
+    GNUNET_CONTAINER_DLL_remove (gc->clh_head,
+                                 gc->clh_tail,
+                                 clh);
+    GNUNET_free (clh);
+  }
+  GNUNET_free (gc);
 }
 
 
@@ -302,17 +305,17 @@ client_disconnect_cb(void *cls,
  * @return internal namestore client structure for this client
  */
 static void *
-client_connect_cb(void *cls,
-                  struct GNUNET_SERVICE_Client *client,
-                  struct GNUNET_MQ_Handle *mq)
+client_connect_cb (void *cls,
+                   struct GNUNET_SERVICE_Client *client,
+                   struct GNUNET_MQ_Handle *mq)
 {
   struct GnsClient *gc;
 
-  (void)cls;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Client %p connected\n",
-             client);
-  gc = GNUNET_new(struct GnsClient);
+  (void) cls;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Client %p connected\n",
+              client);
+  gc = GNUNET_new (struct GnsClient);
   gc->client = client;
   gc->mq = mq;
   return gc;
@@ -327,9 +330,9 @@ client_connect_cb(void *cls,
  * @param rd the record data
  */
 static void
-send_lookup_response(void *cls,
-                     uint32_t rd_count,
-                     const struct GNUNET_GNSRECORD_Data *rd)
+send_lookup_response (void *cls,
+                      uint32_t rd_count,
+                      const struct GNUNET_GNSRECORD_Data *rd)
 {
   struct ClientLookupHandle *clh = cls;
   struct GnsClient *gc = clh->gc;
@@ -337,46 +340,46 @@ send_lookup_response(void *cls,
   struct LookupResultMessage *rmsg;
   ssize_t len;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Sending LOOKUP_RESULT message with %u results\n",
-             (unsigned int)rd_count);
-  len = GNUNET_GNSRECORD_records_get_size(rd_count,
-                                          rd);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending LOOKUP_RESULT message with %u results\n",
+              (unsigned int) rd_count);
+  len = GNUNET_GNSRECORD_records_get_size (rd_count,
+                                           rd);
   if (len < 0)
-    {
-      GNUNET_break(0);
-      GNUNET_SERVICE_client_drop(gc->client);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (gc->client);
+    return;
+  }
   if (len > UINT16_MAX - sizeof(*rmsg))
-    {
-      GNUNET_break(0);
-      GNUNET_SERVICE_client_drop(gc->client);
-      return;
-    }
-  env = GNUNET_MQ_msg_extra(rmsg,
-                            len,
-                            GNUNET_MESSAGE_TYPE_GNS_LOOKUP_RESULT);
+  {
+    GNUNET_break (0);
+    GNUNET_SERVICE_client_drop (gc->client);
+    return;
+  }
+  env = GNUNET_MQ_msg_extra (rmsg,
+                             len,
+                             GNUNET_MESSAGE_TYPE_GNS_LOOKUP_RESULT);
   rmsg->id = clh->request_id;
-  rmsg->rd_count = htonl(rd_count);
-  GNUNET_assert(len ==
-                GNUNET_GNSRECORD_records_serialize(rd_count,
-                                                   rd,
-                                                   len,
-                                                   (char*)&rmsg[1]));
-  GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(gc->client),
-                 env);
-  GNUNET_CONTAINER_DLL_remove(gc->clh_head,
-                              gc->clh_tail,
-                              clh);
-  GNUNET_free(clh);
-  GNUNET_STATISTICS_update(statistics,
-                           "Completed lookups", 1,
-                           GNUNET_NO);
-  GNUNET_STATISTICS_update(statistics,
-                           "Records resolved",
-                           rd_count,
-                           GNUNET_NO);
+  rmsg->rd_count = htonl (rd_count);
+  GNUNET_assert (len ==
+                 GNUNET_GNSRECORD_records_serialize (rd_count,
+                                                     rd,
+                                                     len,
+                                                     (char*) &rmsg[1]));
+  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (gc->client),
+                  env);
+  GNUNET_CONTAINER_DLL_remove (gc->clh_head,
+                               gc->clh_tail,
+                               clh);
+  GNUNET_free (clh);
+  GNUNET_STATISTICS_update (statistics,
+                            "Completed lookups", 1,
+                            GNUNET_NO);
+  GNUNET_STATISTICS_update (statistics,
+                            "Records resolved",
+                            rd_count,
+                            GNUNET_NO);
 }
 
 
@@ -388,19 +391,19 @@ send_lookup_response(void *cls,
  * @return #GNUNET_OK if @a l_msg is well-formed
  */
 static int
-check_lookup(void *cls,
-             const struct LookupMessage *l_msg)
+check_lookup (void *cls,
+              const struct LookupMessage *l_msg)
 {
   size_t nlen;
 
-  (void)cls;
-  GNUNET_MQ_check_zero_termination(l_msg);
-  nlen = ntohs(l_msg->header.size) - sizeof(struct LookupMessage);
+  (void) cls;
+  GNUNET_MQ_check_zero_termination (l_msg);
+  nlen = ntohs (l_msg->header.size) - sizeof(struct LookupMessage);
   if (nlen > GNUNET_DNSPARSER_MAX_NAME_LENGTH)
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -413,8 +416,8 @@ check_lookup(void *cls,
  * @param message the message
  */
 static void
-handle_lookup(void *cls,
-              const struct LookupMessage *sh_msg)
+handle_lookup (void *cls,
+               const struct LookupMessage *sh_msg)
 {
   struct GnsClient *gc = cls;
   char name[GNUNET_DNSPARSER_MAX_NAME_LENGTH + 1];
@@ -422,47 +425,48 @@ handle_lookup(void *cls,
   char *nameptr = name;
   const char *utf_in;
 
-  GNUNET_SERVICE_client_continue(gc->client);
-  utf_in = (const char *)&sh_msg[1];
-  GNUNET_STRINGS_utf8_tolower(utf_in,
-                              nameptr);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received LOOKUP `%s' message\n",
-             name);
-  clh = GNUNET_new(struct ClientLookupHandle);
-  GNUNET_CONTAINER_DLL_insert(gc->clh_head,
-                              gc->clh_tail,
-                              clh);
+  GNUNET_SERVICE_client_continue (gc->client);
+  utf_in = (const char *) &sh_msg[1];
+  GNUNET_STRINGS_utf8_tolower (utf_in,
+                               nameptr);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received LOOKUP `%s' message\n",
+              name);
+  clh = GNUNET_new (struct ClientLookupHandle);
+  GNUNET_CONTAINER_DLL_insert (gc->clh_head,
+                               gc->clh_tail,
+                               clh);
   clh->gc = gc;
   clh->request_id = sh_msg->id;
-  if ((GNUNET_DNSPARSER_TYPE_A == ntohl(sh_msg->type)) &&
+  if ((GNUNET_DNSPARSER_TYPE_A == ntohl (sh_msg->type)) &&
       (GNUNET_OK != v4_enabled))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "LOOKUP: Query for A record but AF_INET not supported!");
-      send_lookup_response(clh,
-                           0,
-                           NULL);
-      return;
-    }
-  if ((GNUNET_DNSPARSER_TYPE_AAAA == ntohl(sh_msg->type)) &&
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "LOOKUP: Query for A record but AF_INET not supported!");
+    send_lookup_response (clh,
+                          0,
+                          NULL);
+    return;
+  }
+  if ((GNUNET_DNSPARSER_TYPE_AAAA == ntohl (sh_msg->type)) &&
       (GNUNET_OK != v6_enabled))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "LOOKUP: Query for AAAA record but AF_INET6 not supported!");
-      send_lookup_response(clh,
-                           0,
-                           NULL);
-      return;
-    }
-  clh->lookup = GNS_resolver_lookup(&sh_msg->zone,
-                                    ntohl(sh_msg->type),
-                                    name,
-                                    (enum GNUNET_GNS_LocalOptions)ntohs(sh_msg->options),
-                                    &send_lookup_response, clh);
-  GNUNET_STATISTICS_update(statistics,
-                           "Lookup attempts",
-                           1, GNUNET_NO);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "LOOKUP: Query for AAAA record but AF_INET6 not supported!");
+    send_lookup_response (clh,
+                          0,
+                          NULL);
+    return;
+  }
+  clh->lookup = GNS_resolver_lookup (&sh_msg->zone,
+                                     ntohl (sh_msg->type),
+                                     name,
+                                     (enum GNUNET_GNS_LocalOptions) ntohs (
+                                       sh_msg->options),
+                                     &send_lookup_response, clh);
+  GNUNET_STATISTICS_update (statistics,
+                            "Lookup attempts",
+                            1, GNUNET_NO);
 }
 
 
@@ -475,36 +479,37 @@ handle_lookup(void *cls,
  * @param value value for the option, public key for TLDs
  */
 static void
-read_service_conf(void *cls,
-                  const char *section,
-                  const char *option,
-                  const char *value)
+read_service_conf (void *cls,
+                   const char *section,
+                   const char *option,
+                   const char *value)
 {
   struct GNUNET_CRYPTO_EcdsaPublicKey pk;
   struct GNS_TopLevelDomain *tld;
 
-  (void)cls;
-  (void)section;
+  (void) cls;
+  (void) section;
   if (option[0] != '.')
     return;
   if (GNUNET_OK !=
-      GNUNET_STRINGS_string_to_data(value,
-                                    strlen(value),
-                                    &pk,
-                                    sizeof(pk)))
-    {
-      GNUNET_log_config_invalid(GNUNET_ERROR_TYPE_ERROR,
-                                section,
-                                option,
-                                _("Properly base32-encoded public key required"));
-      return;
-    }
-  tld = GNUNET_new(struct GNS_TopLevelDomain);
-  tld->tld = GNUNET_strdup(&option[1]);
+      GNUNET_STRINGS_string_to_data (value,
+                                     strlen (value),
+                                     &pk,
+                                     sizeof(pk)))
+  {
+    GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
+                               section,
+                               option,
+                               _ (
+                                 "Properly base32-encoded public key required"));
+    return;
+  }
+  tld = GNUNET_new (struct GNS_TopLevelDomain);
+  tld->tld = GNUNET_strdup (&option[1]);
   tld->pkey = pk;
-  GNUNET_CONTAINER_DLL_insert(tld_head,
-                              tld_tail,
-                              tld);
+  GNUNET_CONTAINER_DLL_insert (tld_head,
+                               tld_tail,
+                               tld);
 }
 
 
@@ -516,66 +521,66 @@ read_service_conf(void *cls,
  * @param c configuration to use
  */
 static void
-run(void *cls,
-    const struct GNUNET_CONFIGURATION_Handle *c,
-    struct GNUNET_SERVICE_Handle *service)
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *c,
+     struct GNUNET_SERVICE_Handle *service)
 {
   unsigned long long max_parallel_bg_queries = 16;
 
-  GNUNET_CONFIGURATION_iterate_section_values(c,
-                                              "gns",
-                                              &read_service_conf,
-                                              NULL);
-  v6_enabled = GNUNET_NETWORK_test_pf(PF_INET6);
-  v4_enabled = GNUNET_NETWORK_test_pf(PF_INET);
-  namecache_handle = GNUNET_NAMECACHE_connect(c);
+  GNUNET_CONFIGURATION_iterate_section_values (c,
+                                               "gns",
+                                               &read_service_conf,
+                                               NULL);
+  v6_enabled = GNUNET_NETWORK_test_pf (PF_INET6);
+  v4_enabled = GNUNET_NETWORK_test_pf (PF_INET);
+  namecache_handle = GNUNET_NAMECACHE_connect (c);
   if (NULL == namecache_handle)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _("Failed to connect to the namecache!\n"));
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Failed to connect to the namecache!\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
   if (GNUNET_OK ==
-      GNUNET_CONFIGURATION_get_value_number(c,
-                                            "gns",
-                                            "MAX_PARALLEL_BACKGROUND_QUERIES",
-                                            &max_parallel_bg_queries))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Number of allowed parallel background queries: %llu\n",
-                 max_parallel_bg_queries);
-    }
-  dht_handle = GNUNET_DHT_connect(c,
-                                  (unsigned int)max_parallel_bg_queries);
+      GNUNET_CONFIGURATION_get_value_number (c,
+                                             "gns",
+                                             "MAX_PARALLEL_BACKGROUND_QUERIES",
+                                             &max_parallel_bg_queries))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Number of allowed parallel background queries: %llu\n",
+                max_parallel_bg_queries);
+  }
+  dht_handle = GNUNET_DHT_connect (c,
+                                   (unsigned int) max_parallel_bg_queries);
   if (NULL == dht_handle)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _("Could not connect to DHT!\n"));
-      GNUNET_SCHEDULER_add_now(&shutdown_task,
-                               NULL);
-      return;
-    }
-  GNS_resolver_init(namecache_handle,
-                    dht_handle,
-                    c,
-                    max_parallel_bg_queries);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Could not connect to DHT!\n"));
+    GNUNET_SCHEDULER_add_now (&shutdown_task,
+                              NULL);
+    return;
+  }
+  GNS_resolver_init (namecache_handle,
+                     dht_handle,
+                     c,
+                     max_parallel_bg_queries);
   if ((GNUNET_YES ==
-       GNUNET_CONFIGURATION_get_value_yesno(c,
-                                            "gns",
-                                            "INTERCEPT_DNS")) &&
+       GNUNET_CONFIGURATION_get_value_yesno (c,
+                                             "gns",
+                                             "INTERCEPT_DNS")) &&
       (GNUNET_SYSERR ==
-       GNS_interceptor_init(c)))
-    {
-      GNUNET_break(0);
-      GNUNET_SCHEDULER_add_now(&shutdown_task,
-                               NULL);
-      return;
-    }
-  statistics = GNUNET_STATISTICS_create("gns",
-                                        c);
-  GNUNET_SCHEDULER_add_shutdown(&shutdown_task,
-                                NULL);
+       GNS_interceptor_init (c)))
+  {
+    GNUNET_break (0);
+    GNUNET_SCHEDULER_add_now (&shutdown_task,
+                              NULL);
+    return;
+  }
+  statistics = GNUNET_STATISTICS_create ("gns",
+                                         c);
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
+                                 NULL);
 }
 
 
@@ -589,11 +594,11 @@ GNUNET_SERVICE_MAIN
   &client_connect_cb,
   &client_disconnect_cb,
   NULL,
-  GNUNET_MQ_hd_var_size(lookup,
-                        GNUNET_MESSAGE_TYPE_GNS_LOOKUP,
-                        struct LookupMessage,
-                        NULL),
-  GNUNET_MQ_handler_end());
+  GNUNET_MQ_hd_var_size (lookup,
+                         GNUNET_MESSAGE_TYPE_GNS_LOOKUP,
+                         struct LookupMessage,
+                         NULL),
+  GNUNET_MQ_handler_end ());
 
 
 /* end of gnunet-service-gns.c */