get rid of the unneeded "closure"-struct

2 files changed, 165 insertions, 118 deletions

diff --git a/src/vpn/gnunet-daemon-vpn.c b/src/vpn/gnunet-daemon-vpn.c
index cc2474f32..e84600e4a 100644
--- a/src/vpn/gnunet-daemon-vpn.c
+++ b/src/vpn/gnunet-daemon-vpn.c
@@ -43,42 +43,92 @@
  */
 static int ret;
 
-struct vpn_cls {
-        struct GNUNET_DISK_PipeHandle* helper_in; // From the helper
-        struct GNUNET_DISK_PipeHandle* helper_out; // To the helper
-        const struct GNUNET_DISK_FileHandle* fh_from_helper;
-        const struct GNUNET_DISK_FileHandle* fh_to_helper;
+/**
+ * The scheduler to use throughout the daemon
+ */
+static struct GNUNET_SCHEDULER_Handle *sched;
 
-        struct GNUNET_SERVER_MessageStreamTokenizer* mst;
+/**
+ * The configuration to use
+ */
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
 
-        struct GNUNET_SCHEDULER_Handle *sched;
+/**
+ * PipeHandle to receive data from the helper
+ */
+static struct GNUNET_DISK_PipeHandle* helper_in;
 
-        struct GNUNET_CLIENT_Connection *dns_connection;
-        unsigned char restart_hijack;
+/**
+ * PipeHandle to send data to the helper
+ */
+static struct GNUNET_DISK_PipeHandle* helper_out;
 
-        pid_t helper_pid;
+/**
+ * FileHandle to receive data from the helper
+ */
+static const struct GNUNET_DISK_FileHandle* fh_from_helper;
 
-        const struct GNUNET_CONFIGURATION_Handle *cfg;
+/**
+ * FileHandle to send data to the helper
+ */
+static const struct GNUNET_DISK_FileHandle* fh_to_helper;
 
-        struct query_packet_list *head;
-        struct query_packet_list *tail;
+/**
+ * The Message-Tokenizer that tokenizes the messages comming from the helper
+ */
+static struct GNUNET_SERVER_MessageStreamTokenizer* mst;
 
-        struct answer_packet_list *answer_proc_head;
-        struct answer_packet_list *answer_proc_tail;
-};
+/**
+ * The connection to the service-dns
+ */
+static struct GNUNET_CLIENT_Connection *dns_connection;
 
-static struct vpn_cls mycls;
+/**
+ * A flag to show that the service-dns has to rehijack the outbound dns-packets
+ *
+ * This gets set when the helper restarts as the routing-tables are flushed when
+ * the interface vanishes.
+ */
+static unsigned char restart_hijack;
+
+/**
+ * The process id of the helper
+ */
+static pid_t helper_pid;
+
+/**
+ * a list of outgoing dns-query-packets
+ */
+static struct query_packet_list *head;
+
+/**
+ * The last element of the list of outgoing dns-query-packets
+ */
+static struct query_packet_list *tail;
+
+/**
+ * A list of processed dns-responses.
+ *
+ * "processed" means that the packet is complete and can be sent out via udp
+ * directly
+ */
+static struct answer_packet_list *answer_proc_head;
+
+/**
+ * The last element of the list of processed dns-responses.
+ */
+static struct answer_packet_list *answer_proc_tail;
 
 size_t send_query(void* cls, size_t size, void* buf);
 
 static void cleanup(void* cls, const struct GNUNET_SCHEDULER_TaskContext* tskctx) {
   GNUNET_assert (0 != (tskctx->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN));
-  PLIBC_KILL(mycls.helper_pid, SIGTERM);
-  GNUNET_OS_process_wait(mycls.helper_pid);
-  if (mycls.dns_connection != NULL)
+  PLIBC_KILL(helper_pid, SIGTERM);
+  GNUNET_OS_process_wait(helper_pid);
+  if (dns_connection != NULL)
     {
-      GNUNET_CLIENT_disconnect (mycls.dns_connection, GNUNET_NO);
-      mycls.dns_connection = NULL;
+      GNUNET_CLIENT_disconnect (dns_connection, GNUNET_NO);
+      dns_connection = NULL;
     }
 }
 
@@ -90,39 +140,39 @@ static void start_helper_and_schedule(void *cls,
         if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
           return;
 
-        mycls.helper_in = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_NO);
-        mycls.helper_out = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_NO, GNUNET_YES);
+        helper_in = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_NO);
+        helper_out = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_NO, GNUNET_YES);
 
-        if (mycls.helper_in == NULL || mycls.helper_out == NULL) return;
+        if (helper_in == NULL || helper_out == NULL) return;
 
-        mycls.helper_pid = GNUNET_OS_start_process(mycls.helper_in, mycls.helper_out, "gnunet-helper-vpn", "gnunet-helper-vpn", NULL);
+        helper_pid = GNUNET_OS_start_process(helper_in, helper_out, "gnunet-helper-vpn", "gnunet-helper-vpn", NULL);
 
-        mycls.fh_from_helper = GNUNET_DISK_pipe_handle (mycls.helper_out, GNUNET_DISK_PIPE_END_READ);
-        mycls.fh_to_helper = GNUNET_DISK_pipe_handle (mycls.helper_in, GNUNET_DISK_PIPE_END_WRITE);
+        fh_from_helper = GNUNET_DISK_pipe_handle (helper_out, GNUNET_DISK_PIPE_END_READ);
+        fh_to_helper = GNUNET_DISK_pipe_handle (helper_in, GNUNET_DISK_PIPE_END_WRITE);
 
-        GNUNET_DISK_pipe_close_end(mycls.helper_out, GNUNET_DISK_PIPE_END_WRITE);
-        GNUNET_DISK_pipe_close_end(mycls.helper_in, GNUNET_DISK_PIPE_END_READ);
+        GNUNET_DISK_pipe_close_end(helper_out, GNUNET_DISK_PIPE_END_WRITE);
+        GNUNET_DISK_pipe_close_end(helper_in, GNUNET_DISK_PIPE_END_READ);
 
-        GNUNET_SCHEDULER_add_read_file (mycls.sched, GNUNET_TIME_UNIT_FOREVER_REL, mycls.fh_from_helper, &helper_read, NULL);
+        GNUNET_SCHEDULER_add_read_file (sched, GNUNET_TIME_UNIT_FOREVER_REL, fh_from_helper, &helper_read, NULL);
 }
 
 
 static void restart_helper(void* cls, const struct GNUNET_SCHEDULER_TaskContext* tskctx) {
         // Kill the helper
-        PLIBC_KILL(mycls.helper_pid, SIGKILL);
-        GNUNET_OS_process_wait(mycls.helper_pid);
+        PLIBC_KILL(helper_pid, SIGKILL);
+        GNUNET_OS_process_wait(helper_pid);
 
         /* Tell the dns-service to rehijack the dns-port
          * The routing-table gets flushed if an interface disappears.
          */
-        mycls.restart_hijack = 1;
-        GNUNET_CLIENT_notify_transmit_ready(mycls.dns_connection, sizeof(struct GNUNET_MessageHeader), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, &send_query, NULL);
+        restart_hijack = 1;
+        GNUNET_CLIENT_notify_transmit_ready(dns_connection, sizeof(struct GNUNET_MessageHeader), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, &send_query, NULL);
 
-        GNUNET_DISK_pipe_close(mycls.helper_in);
-        GNUNET_DISK_pipe_close(mycls.helper_out);
+        GNUNET_DISK_pipe_close(helper_in);
+        GNUNET_DISK_pipe_close(helper_out);
 
         // Restart the helper
-        GNUNET_SCHEDULER_add_delayed (mycls.sched, GNUNET_TIME_UNIT_SECONDS, start_helper_and_schedule, NULL);
+        GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_UNIT_SECONDS, start_helper_and_schedule, NULL);
 
 }
 
@@ -132,16 +182,16 @@ static void helper_read(void* cls, const struct GNUNET_SCHEDULER_TaskContext* ts
         if (tsdkctx->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)
                 return;
 
-        int t = GNUNET_DISK_file_read(mycls.fh_from_helper, &buf, 65535);
+        int t = GNUNET_DISK_file_read(fh_from_helper, &buf, 65535);
         if (t<=0) {
                 GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Read error for header from vpn-helper: %m\n");
-                GNUNET_SCHEDULER_add_now(mycls.sched, restart_helper, cls);
+                GNUNET_SCHEDULER_add_now(sched, restart_helper, cls);
                 return;
         }
 
-        /* FIXME */ GNUNET_SERVER_mst_receive(mycls.mst, NULL, buf, t, 0, 0);
+        /* FIXME */ GNUNET_SERVER_mst_receive(mst, NULL, buf, t, 0, 0);
 
-        GNUNET_SCHEDULER_add_read_file (mycls.sched, GNUNET_TIME_UNIT_FOREVER_REL, mycls.fh_from_helper, &helper_read, NULL);
+        GNUNET_SCHEDULER_add_read_file (sched, GNUNET_TIME_UNIT_FOREVER_REL, fh_from_helper, &helper_read, NULL);
 }
 
 static uint16_t calculate_ip_checksum(uint16_t* hdr, short len) {
@@ -159,7 +209,7 @@ static uint16_t calculate_ip_checksum(uint16_t* hdr, short len) {
 static void helper_write(void* cls, const struct GNUNET_SCHEDULER_TaskContext* tsdkctx) {
         if (tsdkctx->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)
                 return;
-        struct answer_packet_list* ans = mycls.answer_proc_head;
+        struct answer_packet_list* ans = answer_proc_head;
         size_t len = ntohs(ans->pkt.hdr.size);
 
         GNUNET_assert(ans->pkt.subtype == GNUNET_DNS_ANSWER_TYPE_IP);
@@ -199,21 +249,21 @@ static void helper_write(void* cls, const struct GNUNET_SCHEDULER_TaskContext* t
 
         memcpy(&pkt->udp_dns.data, ans->pkt.data, data_len);
         
-        GNUNET_CONTAINER_DLL_remove (mycls.answer_proc_head, mycls.answer_proc_tail, ans);
+        GNUNET_CONTAINER_DLL_remove (answer_proc_head, answer_proc_tail, ans);
         GNUNET_free(ans);
 
-        /* FIXME */ GNUNET_DISK_file_write(mycls.fh_to_helper, pkt, pkt_len);
+        /* FIXME */ GNUNET_DISK_file_write(fh_to_helper, pkt, pkt_len);
 
-        if (mycls.answer_proc_head != NULL)
-                GNUNET_SCHEDULER_add_write_file (mycls.sched, GNUNET_TIME_UNIT_FOREVER_REL, mycls.fh_to_helper, &helper_write, NULL);
+        if (answer_proc_head != NULL)
+                GNUNET_SCHEDULER_add_write_file (sched, GNUNET_TIME_UNIT_FOREVER_REL, fh_to_helper, &helper_write, NULL);
 }
 
 size_t send_query(void* cls, size_t size, void* buf)
 {
   size_t len;
-  if (mycls.restart_hijack == 1)
+  if (restart_hijack == 1)
     {
-      mycls.restart_hijack = 0;
+      restart_hijack = 0;
       GNUNET_assert(sizeof(struct GNUNET_MessageHeader) >= size);
       struct GNUNET_MessageHeader* hdr = buf;
       len = sizeof(struct GNUNET_MessageHeader);
@@ -222,20 +272,20 @@ size_t send_query(void* cls, size_t size, void* buf)
     }
   else
     {
-        struct query_packet_list* query = mycls.head;
+        struct query_packet_list* query = head;
         len = ntohs(query->pkt.hdr.size);
 
         GNUNET_assert(len <= size);
 
         memcpy(buf, &query->pkt.hdr, len);
 
-        GNUNET_CONTAINER_DLL_remove (mycls.head, mycls.tail, query);
+        GNUNET_CONTAINER_DLL_remove (head, tail, query);
 
         GNUNET_free(query);
     }
 
-        if (mycls.head != NULL || mycls.restart_hijack == 1) {
-                GNUNET_CLIENT_notify_transmit_ready(mycls.dns_connection, ntohs(mycls.head->pkt.hdr.size), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, &send_query, NULL);
+        if (head != NULL || restart_hijack == 1) {
+                GNUNET_CLIENT_notify_transmit_ready(dns_connection, ntohs(head->pkt.hdr.size), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, &send_query, NULL);
         }
 
         return len;
@@ -279,10 +329,10 @@ static void message_token(void *cls, void *client, const struct GNUNET_MessageHe
                         query->pkt.src_port = udp->udp_hdr.spt;
                         memcpy(query->pkt.data, udp->data, ntohs(udp->udp_hdr.len) - 8);
 
-                        GNUNET_CONTAINER_DLL_insert_after(mycls.head, mycls.tail, mycls.tail, query);
+                        GNUNET_CONTAINER_DLL_insert_after(head, tail, tail, query);
 
-                        if (mycls.dns_connection != NULL)
-                          /* struct GNUNET_CLIENT_TransmitHandle* th = */ GNUNET_CLIENT_notify_transmit_ready(mycls.dns_connection, len, GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, &send_query, NULL);
+                        if (dns_connection != NULL)
+                          /* struct GNUNET_CLIENT_TransmitHandle* th = */ GNUNET_CLIENT_notify_transmit_ready(dns_connection, len, GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, &send_query, NULL);
                 }
         }
 
@@ -297,11 +347,11 @@ reconnect_to_service_dns (void *cls,
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;
   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Connecting\n");
-  GNUNET_assert (mycls.dns_connection == NULL);
-  mycls.dns_connection = GNUNET_CLIENT_connect (mycls.sched, "dns", mycls.cfg); 
-  GNUNET_CLIENT_receive(mycls.dns_connection, &dns_answer_handler, NULL, GNUNET_TIME_UNIT_FOREVER_REL);
-  if (mycls.head != NULL)
-    /* struct GNUNET_CLIENT_TransmitHandle* th = */ GNUNET_CLIENT_notify_transmit_ready(mycls.dns_connection, ntohs(mycls.head->pkt.hdr.size), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, &send_query, NULL);
+  GNUNET_assert (dns_connection == NULL);
+  dns_connection = GNUNET_CLIENT_connect (sched, "dns", cfg);
+  GNUNET_CLIENT_receive(dns_connection, &dns_answer_handler, NULL, GNUNET_TIME_UNIT_FOREVER_REL);
+  if (head != NULL)
+    /* struct GNUNET_CLIENT_TransmitHandle* th = */ GNUNET_CLIENT_notify_transmit_ready(dns_connection, ntohs(head->pkt.hdr.size), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, &send_query, NULL);
 }
 
 static void
@@ -332,9 +382,9 @@ process_answer(void* cls, const struct GNUNET_SCHEDULER_TaskContext* tc) {
 
         memcpy(&list->pkt, pkt, htons(pkt->hdr.size));
 
-        GNUNET_CONTAINER_DLL_insert_after(mycls.answer_proc_head, mycls.answer_proc_tail, mycls.answer_proc_tail, list);
+        GNUNET_CONTAINER_DLL_insert_after(answer_proc_head, answer_proc_tail, answer_proc_tail, list);
 
-        GNUNET_SCHEDULER_add_write_file (mycls.sched, GNUNET_TIME_UNIT_FOREVER_REL, mycls.fh_to_helper, &helper_write, NULL);
+        GNUNET_SCHEDULER_add_write_file (sched, GNUNET_TIME_UNIT_FOREVER_REL, fh_to_helper, &helper_write, NULL);
 
         return;
 }
@@ -344,9 +394,9 @@ dns_answer_handler(void* cls, const struct GNUNET_MessageHeader *msg)
 {
   if (msg == NULL)
     {
-      GNUNET_CLIENT_disconnect(mycls.dns_connection, GNUNET_NO);
-      mycls.dns_connection = NULL;
-      GNUNET_SCHEDULER_add_delayed (mycls.sched,
+      GNUNET_CLIENT_disconnect(dns_connection, GNUNET_NO);
+      dns_connection = NULL;
+      GNUNET_SCHEDULER_add_delayed (sched,
                                     GNUNET_TIME_UNIT_SECONDS,
                                     &reconnect_to_service_dns,
                                     NULL);
@@ -356,9 +406,9 @@ dns_answer_handler(void* cls, const struct GNUNET_MessageHeader *msg)
   if (msg->type != htons(GNUNET_MESSAGE_TYPE_LOCAL_RESPONSE_DNS)) 
     {
       GNUNET_break (0);
-      GNUNET_CLIENT_disconnect(mycls.dns_connection, GNUNET_NO);
-      mycls.dns_connection = NULL;
-      GNUNET_SCHEDULER_add_now (mycls.sched,
+      GNUNET_CLIENT_disconnect(dns_connection, GNUNET_NO);
+      dns_connection = NULL;
+      GNUNET_SCHEDULER_add_now (sched,
                                 &reconnect_to_service_dns,
                                 NULL);
       return;
@@ -367,8 +417,8 @@ dns_answer_handler(void* cls, const struct GNUNET_MessageHeader *msg)
 
   memcpy(pkt, msg, ntohs(msg->size));
 
-  GNUNET_SCHEDULER_add_now(mycls.sched, process_answer, pkt);
-  GNUNET_CLIENT_receive(mycls.dns_connection, &dns_answer_handler, NULL, GNUNET_TIME_UNIT_FOREVER_REL);
+  GNUNET_SCHEDULER_add_now(sched, process_answer, pkt);
+  GNUNET_CLIENT_receive(dns_connection, &dns_answer_handler, NULL, GNUNET_TIME_UNIT_FOREVER_REL);
 }
 
 /**
@@ -382,15 +432,15 @@ dns_answer_handler(void* cls, const struct GNUNET_MessageHeader *msg)
  */
 static void
 run (void *cls,
-     struct GNUNET_SCHEDULER_Handle *sched,
+     struct GNUNET_SCHEDULER_Handle *sched_,
      char *const *args,
      const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *cfg) 
+     const struct GNUNET_CONFIGURATION_Handle *cfg_)
 {
-  mycls.sched = sched;
-  mycls.mst = GNUNET_SERVER_mst_create(&message_token, NULL);
-  mycls.cfg = cfg;
-  mycls.restart_hijack = 0;
+  sched = sched_;
+  mst = GNUNET_SERVER_mst_create(&message_token, NULL);
+  cfg = cfg_;
+  restart_hijack = 0;
   GNUNET_SCHEDULER_add_now (sched, &reconnect_to_service_dns, NULL);
   GNUNET_SCHEDULER_add_delayed(sched, GNUNET_TIME_UNIT_FOREVER_REL, &cleanup, cls); 
   GNUNET_SCHEDULER_add_now (sched, start_helper_and_schedule, NULL);
diff --git a/src/vpn/gnunet-service-dns.c b/src/vpn/gnunet-service-dns.c
index 9732f90c4..c3d136406 100644
--- a/src/vpn/gnunet-service-dns.c
+++ b/src/vpn/gnunet-service-dns.c
@@ -39,21 +39,18 @@
 #include "gnunet_crypto_lib.h"
 #include "gnunet_signatures.h"
 
-struct dns_cls {
-        struct GNUNET_SCHEDULER_Handle *sched;
+static struct GNUNET_SCHEDULER_Handle *sched;
 
-        struct GNUNET_NETWORK_Handle *dnsout;
+static struct GNUNET_NETWORK_Handle *dnsout;
 
-        struct GNUNET_DHT_Handle *dht;
+static struct GNUNET_DHT_Handle *dht;
 
-        unsigned short dnsoutport;
+static unsigned short dnsoutport;
 
-        const struct GNUNET_CONFIGURATION_Handle *cfg;
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
 
-        struct answer_packet_list *head;
-        struct answer_packet_list *tail;
-};
-static struct dns_cls mycls;
+static struct answer_packet_list *head;
+static struct answer_packet_list *tail;
 
 struct dns_query_id_state {
         unsigned valid:1;
@@ -163,7 +160,7 @@ void receive_dht(void *cls,
 
   answer->pkt.addroffset = htons((unsigned short)((unsigned long)(&drec_data->data)-(unsigned long)(&answer->pkt)));
 
-  GNUNET_CONTAINER_DLL_insert_after(mycls.head, mycls.tail, mycls.tail, answer);
+  GNUNET_CONTAINER_DLL_insert_after(head, tail, tail, answer);
 
   GNUNET_SERVER_notify_transmit_ready(query_states[id].client,
                                       len,
@@ -178,8 +175,8 @@ void receive_dht(void *cls,
  * This receives a GNUNET_MESSAGE_TYPE_REHIJACK and rehijacks the DNS
  */
 void rehijack(void *cls, struct GNUNET_SERVER_Client *client, const struct GNUNET_MessageHeader *message) {
-    unhijack(mycls.dnsoutport);
-    hijack(mycls.dnsoutport);
+    unhijack(dnsoutport);
+    hijack(dnsoutport);
 }
 
 /**
@@ -212,7 +209,7 @@ void receive_query(void *cls, struct GNUNET_SERVER_Client *client, const struct
             struct receive_dht_cls* cls = GNUNET_malloc(sizeof(struct receive_dht_cls));
             cls->id = dns->s.id;
 
-            cls->handle = GNUNET_DHT_get_start(mycls.dht,
+            cls->handle = GNUNET_DHT_get_start(dht,
                                  GNUNET_TIME_UNIT_MINUTES,
                                  GNUNET_BLOCK_TYPE_DNS,
                                  &key,
@@ -235,26 +232,26 @@ void receive_query(void *cls, struct GNUNET_SERVER_Client *client, const struct
         dest.sin_port = htons(53);
         dest.sin_addr.s_addr = pkt->orig_to;
 
-        /* int r = */ GNUNET_NETWORK_socket_sendto(mycls.dnsout, dns, ntohs(pkt->hdr.size) - sizeof(struct query_packet) + 1, (struct sockaddr*) &dest, sizeof dest);
+        /* int r = */ GNUNET_NETWORK_socket_sendto(dnsout, dns, ntohs(pkt->hdr.size) - sizeof(struct query_packet) + 1, (struct sockaddr*) &dest, sizeof dest);
 
 out:
         GNUNET_SERVER_receive_done(client, GNUNET_OK);
 }
 
 size_t send_answer(void* cls, size_t size, void* buf) {
-        struct answer_packet_list* query = mycls.head;
+        struct answer_packet_list* query = head;
         size_t len = ntohs(query->pkt.hdr.size);
 
         GNUNET_assert(len <= size);
 
         memcpy(buf, &query->pkt.hdr, len);
 
-        GNUNET_CONTAINER_DLL_remove (mycls.head, mycls.tail, query);
+        GNUNET_CONTAINER_DLL_remove (head, tail, query);
 
         GNUNET_free(query);
 
-        if (mycls.head != NULL) {
-                GNUNET_SERVER_notify_transmit_ready(cls, ntohs(mycls.head->pkt.hdr.size), GNUNET_TIME_UNIT_FOREVER_REL, &send_answer, cls);
+        if (head != NULL) {
+                GNUNET_SERVER_notify_transmit_ready(cls, ntohs(head->pkt.hdr.size), GNUNET_TIME_UNIT_FOREVER_REL, &send_answer, cls);
         }
 
         return len;
@@ -272,7 +269,7 @@ static void read_response (void *cls, const struct GNUNET_SCHEDULER_TaskContext
         unsigned int addrlen = sizeof addr;
 
         int r;
-        r = GNUNET_NETWORK_socket_recvfrom(mycls.dnsout, buf, 65536, (struct sockaddr*)&addr, &addrlen);
+        r = GNUNET_NETWORK_socket_recvfrom(dnsout, buf, 65536, (struct sockaddr*)&addr, &addrlen);
 
         /* if (r < 0) TODO */
 
@@ -289,12 +286,12 @@ static void read_response (void *cls, const struct GNUNET_SCHEDULER_TaskContext
                 answer->pkt.dst_port = query_states[dns->s.id].local_port;
                 memcpy(answer->pkt.data, buf, r);
 
-                GNUNET_CONTAINER_DLL_insert_after(mycls.head, mycls.tail, mycls.tail, answer);
+                GNUNET_CONTAINER_DLL_insert_after(head, tail, tail, answer);
 
                 /* struct GNUNET_CONNECTION_TransmitHandle* th = */ GNUNET_SERVER_notify_transmit_ready(query_states[dns->s.id].client, len, GNUNET_TIME_UNIT_FOREVER_REL, &send_answer, query_states[dns->s.id].client);
         }
 
-        GNUNET_SCHEDULER_add_read_net(mycls.sched, GNUNET_TIME_UNIT_FOREVER_REL, mycls.dnsout, &read_response, NULL);
+        GNUNET_SCHEDULER_add_read_net(sched, GNUNET_TIME_UNIT_FOREVER_REL, dnsout, &read_response, NULL);
 }
 
 
@@ -308,8 +305,8 @@ static void
 cleanup_task (void *cls,
               const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-        unhijack(mycls.dnsoutport);
-        GNUNET_DHT_disconnect(mycls.dht);
+        unhijack(dnsoutport);
+        GNUNET_DHT_disconnect(dht);
 }
 
 static void
@@ -330,7 +327,7 @@ publish_name (void *cls,
   GNUNET_CRYPTO_hash(name, strlen(name)+1, &data.service_descriptor);
 
   char* keyfile;
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename(mycls.cfg, "GNUNETD",
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename(cfg, "GNUNETD",
                                                            "HOSTKEY", &keyfile))
     {
       GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "could not read keyfile-value\n");
@@ -359,7 +356,7 @@ publish_name (void *cls,
 
   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Putting with key %08x\n", *((unsigned int*)&data.service_descriptor));
 
-  GNUNET_DHT_put(mycls.dht,
+  GNUNET_DHT_put(dht,
                  &data.service_descriptor,
                  GNUNET_DHT_RO_NONE,
                  GNUNET_BLOCK_TYPE_DNS,
@@ -370,7 +367,7 @@ publish_name (void *cls,
                  NULL,
                  NULL);
 
-  GNUNET_SCHEDULER_add_delayed (mycls.sched, GNUNET_TIME_UNIT_HOURS, publish_name, NULL);
+  GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_UNIT_HOURS, publish_name, NULL);
 }
 
 /**
@@ -381,9 +378,9 @@ publish_name (void *cls,
  */
 static void
 run (void *cls,
-     struct GNUNET_SCHEDULER_Handle *sched,
+     struct GNUNET_SCHEDULER_Handle *sched_,
      struct GNUNET_SERVER_Handle *server,
-     const struct GNUNET_CONFIGURATION_Handle *cfg)
+     const struct GNUNET_CONFIGURATION_Handle *cfg_)
 {
   static const struct GNUNET_SERVER_MessageHandler handlers[] = {
           /* callback, cls, type, size */
@@ -392,7 +389,8 @@ run (void *cls,
     {NULL, NULL, 0, 0}
   };
 
-  mycls.cfg = cfg;
+  cfg = cfg_;
+  sched = sched_;
 
   {
   int i;
@@ -401,18 +399,17 @@ run (void *cls,
   }
   }
 
-  mycls.dht = GNUNET_DHT_connect(sched, cfg, 1024);
+  dht = GNUNET_DHT_connect(sched, cfg, 1024);
 
   struct sockaddr_in addr;
 
-  mycls.sched = sched;
-  mycls.dnsout = GNUNET_NETWORK_socket_create (AF_INET, SOCK_DGRAM, 0);
-  if (mycls.dnsout == NULL) 
+  dnsout = GNUNET_NETWORK_socket_create (AF_INET, SOCK_DGRAM, 0);
+  if (dnsout == NULL)
     return;
   memset(&addr, 0, sizeof(struct sockaddr_in));
 
-  int err = GNUNET_NETWORK_socket_bind (mycls.dnsout,
-                                        (struct sockaddr*)&addr, 
+  int err = GNUNET_NETWORK_socket_bind (dnsout,
+                                        (struct sockaddr*)&addr,
                                         sizeof(struct sockaddr_in));
 
   if (err != GNUNET_YES) {
@@ -420,17 +417,17 @@ run (void *cls,
         return;
   }
   socklen_t addrlen = sizeof(struct sockaddr_in);
-  err = getsockname(GNUNET_NETWORK_get_fd(mycls.dnsout),
-                    (struct sockaddr*) &addr, 
+  err = getsockname(GNUNET_NETWORK_get_fd(dnsout),
+                    (struct sockaddr*) &addr,
                     &addrlen);
 
-  mycls.dnsoutport = htons(addr.sin_port);
+  dnsoutport = htons(addr.sin_port);
 
   hijack(htons(addr.sin_port));
 
-  GNUNET_SCHEDULER_add_now (mycls.sched, publish_name, NULL);
+  GNUNET_SCHEDULER_add_now (sched, publish_name, NULL);
 
-        GNUNET_SCHEDULER_add_read_net(sched, GNUNET_TIME_UNIT_FOREVER_REL, mycls.dnsout, &read_response, NULL);
+  GNUNET_SCHEDULER_add_read_net(sched, GNUNET_TIME_UNIT_FOREVER_REL, dnsout, &read_response, NULL);
 
   GNUNET_SERVER_add_handlers (server, handlers);
   GNUNET_SCHEDULER_add_delayed (sched,