indentation

author: Christian Grothoff <christian@grothoff.org> 2011-08-15 21:46:35 +0000
committer: Christian Grothoff <christian@grothoff.org> 2011-08-15 21:46:35 +0000
commit: 502af2167f7c218366666ca4944bd7cc54b5b19a (patch)
tree: a91fec5cc9769d260640bd91c6633cb9cf395524 /src/vpn/gnunet-daemon-vpn-dns.c
parent: 03af5a603b7cc53432249d5854cd412aa90dde0d (diff)
download: gnunet-502af2167f7c218366666ca4944bd7cc54b5b19a.tar.gz
gnunet-502af2167f7c218366666ca4944bd7cc54b5b19a.zip
1 files changed, 119 insertions, 103 deletions
diff --git a/src/vpn/gnunet-daemon-vpn-dns.c b/src/vpn/gnunet-daemon-vpn-dns.c
index 6ccef5869..d6f842e34 100644
--- a/src/vpn/gnunet-daemon-vpn-dns.c
+++ b/src/vpn/gnunet-daemon-vpn-dns.c
@@ -52,56 +52,67 @@ struct answer_packet_list *answer_proc_tail;
 * {{{
 */
 size_t
-send_query(void* cls __attribute__((unused)), size_t size, void* buf) {
+send_query (void *cls __attribute__ ((unused)), size_t size, void *buf)
-    size_t len;
+{
+  size_t len;
+  /*
+   * Send the rehijack-message
+   */
+  if (restart_hijack == 1)
+  {
+    restart_hijack = 0;
    /*
-     * Send the rehijack-message
+     * The message is just a header
     */
-    if (restart_hijack == 1)
+    GNUNET_assert (sizeof (struct GNUNET_MessageHeader) <= size);
-      {
+    struct GNUNET_MessageHeader *hdr = buf;
-        restart_hijack = 0;
-        /*
+    len = sizeof (struct GNUNET_MessageHeader);
-         * The message is just a header
+    hdr->size = htons (len);
-         */
+    hdr->type = htons (GNUNET_MESSAGE_TYPE_REHIJACK);
-        GNUNET_assert(sizeof(struct GNUNET_MessageHeader) <= size);
+  }
-        struct GNUNET_MessageHeader* hdr = buf;
+  else if (head != NULL)
-        len = sizeof(struct GNUNET_MessageHeader);
+  {
-        hdr->size = htons(len);
+    struct query_packet_list *query = head;
-        hdr->type = htons(GNUNET_MESSAGE_TYPE_REHIJACK);
-      }
+    len = ntohs (query->pkt.hdr.size);
-    else if (head != NULL)
-      {
+    GNUNET_assert (len <= size);
-        struct query_packet_list* query = head;
-        len = ntohs(query->pkt.hdr.size);
+    memcpy (buf, &query->pkt.hdr, len);
-        GNUNET_assert(len <= size);
+    GNUNET_CONTAINER_DLL_remove (head, tail, query);
-        memcpy(buf, &query->pkt.hdr, len);
+    GNUNET_free (query);
+  }
-        GNUNET_CONTAINER_DLL_remove (head, tail, query);
+  else
+  {
-        GNUNET_free(query);
+    GNUNET_break (0);
-      }
+    len = 0;
-    else
+  }
-      {
-        GNUNET_break(0);
+  /*
-        len = 0;
+   * Check whether more data is to be sent
-      }
+   */
+  if (head != NULL)
-    /*
+  {
-     * Check whether more data is to be sent
+    GNUNET_CLIENT_notify_transmit_ready (dns_connection,
-     */
+                                         ntohs (head->pkt.hdr.size),
-    if (head != NULL)
+                                         GNUNET_TIME_UNIT_FOREVER_REL,
-      {
+                                         GNUNET_YES, &send_query, NULL);
-        GNUNET_CLIENT_notify_transmit_ready(dns_connection, ntohs(head->pkt.hdr.size), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, &send_query, NULL);
+  }
-      }
+  else if (restart_hijack == 1)
-    else if (restart_hijack == 1)
+  {
-      {
+    GNUNET_CLIENT_notify_transmit_ready (dns_connection,
-        GNUNET_CLIENT_notify_transmit_ready(dns_connection, sizeof(struct GNUNET_MessageHeader), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, &send_query, NULL);
+                                         sizeof (struct GNUNET_MessageHeader),
-      }
+                                         GNUNET_TIME_UNIT_FOREVER_REL,
+                                         GNUNET_YES, &send_query, NULL);
-    return len;
+  }
+  return len;
 }
 /* }}} */
@@ -109,33 +120,37 @@ send_query(void* cls __attribute__((unused)), size_t size, void* buf) {
 * Connect to the service-dns
 */
 void
-connect_to_service_dns (void *cls __attribute__((unused)),
+connect_to_service_dns (void *cls __attribute__ ((unused)),
-                        const struct GNUNET_SCHEDULER_TaskContext *tc) {
+                        const struct GNUNET_SCHEDULER_TaskContext *tc)
-    conn_task = GNUNET_SCHEDULER_NO_TASK;
+{
-    if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
+  conn_task = GNUNET_SCHEDULER_NO_TASK;
-      return;
+  if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Connecting to service-dns\n");
+    return;
-    GNUNET_assert (dns_connection == NULL);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting to service-dns\n");
-    dns_connection = GNUNET_CLIENT_connect ("dns", cfg);
+  GNUNET_assert (dns_connection == NULL);
-    /* This would most likely be a misconfiguration */
+  dns_connection = GNUNET_CLIENT_connect ("dns", cfg);
-    GNUNET_assert(NULL != dns_connection);
+  /* This would most likely be a misconfiguration */
-    GNUNET_CLIENT_receive(dns_connection, &dns_answer_handler, NULL, GNUNET_TIME_UNIT_FOREVER_REL);
+  GNUNET_assert (NULL != dns_connection);
+  GNUNET_CLIENT_receive (dns_connection, &dns_answer_handler, NULL,
-    /* We might not yet be connected. Yay, mps. */
+                         GNUNET_TIME_UNIT_FOREVER_REL);
-    if (NULL == dns_connection) return;
+  /* We might not yet be connected. Yay, mps. */
-    /* If a packet is already in the list, schedule to send it */
+  if (NULL == dns_connection)
-    if (head != NULL)
+    return;
-      GNUNET_CLIENT_notify_transmit_ready(dns_connection,
-                                          ntohs(head->pkt.hdr.size),
+  /* If a packet is already in the list, schedule to send it */
-                                          GNUNET_TIME_UNIT_FOREVER_REL,
+  if (head != NULL)
-                                          GNUNET_YES,
+    GNUNET_CLIENT_notify_transmit_ready (dns_connection,
-                                          &send_query,
+                                         ntohs (head->pkt.hdr.size),
-                                          NULL);
+                                         GNUNET_TIME_UNIT_FOREVER_REL,
-    else if (restart_hijack == 1)
+                                         GNUNET_YES, &send_query, NULL);
-      {
+  else if (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_CLIENT_notify_transmit_ready (dns_connection,
+                                         sizeof (struct GNUNET_MessageHeader),
+                                         GNUNET_TIME_UNIT_FOREVER_REL,
+                                         GNUNET_YES, &send_query, NULL);
+  }
 }
 /**
@@ -143,33 +158,34 @@ connect_to_service_dns (void *cls __attribute__((unused)),
 * handle it
 */
 void
-dns_answer_handler(void* cls __attribute__((unused)), const struct GNUNET_MessageHeader *msg) {
+dns_answer_handler (void *cls
-    /* the service disconnected, reconnect after short wait */
+                    __attribute__ ((unused)),
-    if (msg == NULL)
+                    const struct GNUNET_MessageHeader *msg)
-      {
+{
-        GNUNET_CLIENT_disconnect(dns_connection, GNUNET_NO);
+  /* the service disconnected, reconnect after short wait */
-        dns_connection = NULL;
+  if (msg == NULL)
-        conn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+  {
-                                                  &connect_to_service_dns,
+    GNUNET_CLIENT_disconnect (dns_connection, GNUNET_NO);
-                                                  NULL);
+    dns_connection = NULL;
-        return;
+    conn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
-      }
+                                              &connect_to_service_dns, NULL);
+    return;
-    /* the service did something strange, reconnect immediately */
+  }
-    if (msg->type != htons(GNUNET_MESSAGE_TYPE_VPN_DNS_LOCAL_RESPONSE_DNS))
-      {
+  /* the service did something strange, reconnect immediately */
-        GNUNET_break (0);
+  if (msg->type != htons (GNUNET_MESSAGE_TYPE_VPN_DNS_LOCAL_RESPONSE_DNS))
-        GNUNET_CLIENT_disconnect(dns_connection, GNUNET_NO);
+  {
-        dns_connection = NULL;
+    GNUNET_break (0);
-        conn_task = GNUNET_SCHEDULER_add_now (&connect_to_service_dns,
+    GNUNET_CLIENT_disconnect (dns_connection, GNUNET_NO);
-                                              NULL);
+    dns_connection = NULL;
-        return;
+    conn_task = GNUNET_SCHEDULER_add_now (&connect_to_service_dns, NULL);
-      }
+    return;
-    void *pkt = GNUNET_malloc(ntohs(msg->size));
+  }
+  void *pkt = GNUNET_malloc (ntohs (msg->size));
-    memcpy(pkt, msg, ntohs(msg->size));
+  memcpy (pkt, msg, ntohs (msg->size));
-    GNUNET_SCHEDULER_add_now(process_answer, pkt);
-    GNUNET_CLIENT_receive(dns_connection, &dns_answer_handler, NULL, GNUNET_TIME_UNIT_FOREVER_REL);
+  GNUNET_SCHEDULER_add_now (process_answer, pkt);
+  GNUNET_CLIENT_receive (dns_connection, &dns_answer_handler, NULL,
+                         GNUNET_TIME_UNIT_FOREVER_REL);
 }
author	Christian Grothoff <christian@grothoff.org>	2011-08-15 21:46:35 +0000
committer	Christian Grothoff <christian@grothoff.org>	2011-08-15 21:46:35 +0000
commit	502af2167f7c218366666ca4944bd7cc54b5b19a (patch)
tree	a91fec5cc9769d260640bd91c6633cb9cf395524 /src/vpn/gnunet-daemon-vpn-dns.c
parent	03af5a603b7cc53432249d5854cd412aa90dde0d (diff)
download	gnunet-502af2167f7c218366666ca4944bd7cc54b5b19a.tar.gz gnunet-502af2167f7c218366666ca4944bd7cc54b5b19a.zip

diff --git a/src/vpn/gnunet-daemon-vpn-dns.c b/src/vpn/gnunet-daemon-vpn-dns.c index 6ccef5869..d6f842e34 100644 --- a/src/vpn/gnunet-daemon-vpn-dns.c +++ b/src/vpn/gnunet-daemon-vpn-dns.c
@@ -52,56 +52,67 @@ struct answer_packet_list *answer_proc_tail;
52	* {{{	52	* {{{
53	*/	53	*/
54	size_t	54	size_t
55	send_query(void* cls __attribute__((unused)), size_t size, void* buf) {	55	send_query (void cls __attribute__ ((unused)), size_t size, void buf)
56	size_t len;	56	{
		57	size_t len;
		58
		59	/*
		60	* Send the rehijack-message
		61	*/
		62	if (restart_hijack == 1)
		63	{
		64	restart_hijack = 0;
57	/*	65	/*
58	* Send the rehijack-message	66	* The message is just a header
59	*/	67	*/
60	if (restart_hijack == 1)	68	GNUNET_assert (sizeof (struct GNUNET_MessageHeader) <= size);
61	{	69	struct GNUNET_MessageHeader *hdr = buf;
62	restart_hijack = 0;	70
63	/*	71	len = sizeof (struct GNUNET_MessageHeader);
64	* The message is just a header	72	hdr->size = htons (len);
65	*/	73	hdr->type = htons (GNUNET_MESSAGE_TYPE_REHIJACK);
66	GNUNET_assert(sizeof(struct GNUNET_MessageHeader) <= size);	74	}
67	struct GNUNET_MessageHeader* hdr = buf;	75	else if (head != NULL)
68	len = sizeof(struct GNUNET_MessageHeader);	76	{
69	hdr->size = htons(len);	77	struct query_packet_list *query = head;
70	hdr->type = htons(GNUNET_MESSAGE_TYPE_REHIJACK);	78
71	}	79	len = ntohs (query->pkt.hdr.size);
72	else if (head != NULL)	80
73	{	81	GNUNET_assert (len <= size);
74	struct query_packet_list* query = head;	82
75	len = ntohs(query->pkt.hdr.size);	83	memcpy (buf, &query->pkt.hdr, len);
76		84
77	GNUNET_assert(len <= size);	85	GNUNET_CONTAINER_DLL_remove (head, tail, query);
78		86
79	memcpy(buf, &query->pkt.hdr, len);	87	GNUNET_free (query);
80		88	}
81	GNUNET_CONTAINER_DLL_remove (head, tail, query);	89	else
82		90	{
83	GNUNET_free(query);	91	GNUNET_break (0);
84	}	92	len = 0;
85	else	93	}
86	{	94
87	GNUNET_break(0);	95	/*
88	len = 0;	96	* Check whether more data is to be sent
89	}	97	*/
90		98	if (head != NULL)
91	/*	99	{
92	* Check whether more data is to be sent	100	GNUNET_CLIENT_notify_transmit_ready (dns_connection,
93	*/	101	ntohs (head->pkt.hdr.size),
94	if (head != NULL)	102	GNUNET_TIME_UNIT_FOREVER_REL,
95	{	103	GNUNET_YES, &send_query, NULL);
96	GNUNET_CLIENT_notify_transmit_ready(dns_connection, ntohs(head->pkt.hdr.size), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, &send_query, NULL);	104	}
97	}	105	else if (restart_hijack == 1)
98	else if (restart_hijack == 1)	106	{
99	{	107	GNUNET_CLIENT_notify_transmit_ready (dns_connection,
100	GNUNET_CLIENT_notify_transmit_ready(dns_connection, sizeof(struct GNUNET_MessageHeader), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, &send_query, NULL);	108	sizeof (struct GNUNET_MessageHeader),
101	}	109	GNUNET_TIME_UNIT_FOREVER_REL,
102		110	GNUNET_YES, &send_query, NULL);
103	return len;	111	}
		112
		113	return len;
104	}	114	}
		115
105	/* }}} */	116	/* }}} */
106		117
107		118
@@ -109,33 +120,37 @@ send_query(void* cls __attribute__((unused)), size_t size, void* buf) {
109	* Connect to the service-dns	120	* Connect to the service-dns
110	*/	121	*/
111	void	122	void
112	connect_to_service_dns (void *cls __attribute__((unused)),	123	connect_to_service_dns (void *cls __attribute__ ((unused)),
113	const struct GNUNET_SCHEDULER_TaskContext *tc) {	124	const struct GNUNET_SCHEDULER_TaskContext *tc)
114	conn_task = GNUNET_SCHEDULER_NO_TASK;	125	{
115	if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))	126	conn_task = GNUNET_SCHEDULER_NO_TASK;
116	return;	127	if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
117	GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Connecting to service-dns\n");	128	return;
118	GNUNET_assert (dns_connection == NULL);	129	GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting to service-dns\n");
119	dns_connection = GNUNET_CLIENT_connect ("dns", cfg);	130	GNUNET_assert (dns_connection == NULL);
120	/* This would most likely be a misconfiguration */	131	dns_connection = GNUNET_CLIENT_connect ("dns", cfg);
121	GNUNET_assert(NULL != dns_connection);	132	/* This would most likely be a misconfiguration */
122	GNUNET_CLIENT_receive(dns_connection, &dns_answer_handler, NULL, GNUNET_TIME_UNIT_FOREVER_REL);	133	GNUNET_assert (NULL != dns_connection);
123		134	GNUNET_CLIENT_receive (dns_connection, &dns_answer_handler, NULL,
124	/* We might not yet be connected. Yay, mps. */	135	GNUNET_TIME_UNIT_FOREVER_REL);
125	if (NULL == dns_connection) return;	136
126		137	/* We might not yet be connected. Yay, mps. */
127	/* If a packet is already in the list, schedule to send it */	138	if (NULL == dns_connection)
128	if (head != NULL)	139	return;
129	GNUNET_CLIENT_notify_transmit_ready(dns_connection,	140
130	ntohs(head->pkt.hdr.size),	141	/* If a packet is already in the list, schedule to send it */
131	GNUNET_TIME_UNIT_FOREVER_REL,	142	if (head != NULL)
132	GNUNET_YES,	143	GNUNET_CLIENT_notify_transmit_ready (dns_connection,
133	&send_query,	144	ntohs (head->pkt.hdr.size),
134	NULL);	145	GNUNET_TIME_UNIT_FOREVER_REL,
135	else if (restart_hijack == 1)	146	GNUNET_YES, &send_query, NULL);
136	{	147	else if (restart_hijack == 1)
137	GNUNET_CLIENT_notify_transmit_ready(dns_connection, sizeof(struct GNUNET_MessageHeader), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, &send_query, NULL);	148	{
138	}	149	GNUNET_CLIENT_notify_transmit_ready (dns_connection,
		150	sizeof (struct GNUNET_MessageHeader),
		151	GNUNET_TIME_UNIT_FOREVER_REL,
		152	GNUNET_YES, &send_query, NULL);
		153	}
139	}	154	}
140		155
141	/**	156	/**
@@ -143,33 +158,34 @@ connect_to_service_dns (void *cls __attribute__((unused)),
143	* handle it	158	* handle it
144	*/	159	*/
145	void	160	void
146	dns_answer_handler(void* cls __attribute__((unused)), const struct GNUNET_MessageHeader *msg) {	161	dns_answer_handler (void *cls
147	/* the service disconnected, reconnect after short wait */	162	__attribute__ ((unused)),
148	if (msg == NULL)	163	const struct GNUNET_MessageHeader *msg)
149	{	164	{
150	GNUNET_CLIENT_disconnect(dns_connection, GNUNET_NO);	165	/* the service disconnected, reconnect after short wait */
151	dns_connection = NULL;	166	if (msg == NULL)
152	conn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,	167	{
153	&connect_to_service_dns,	168	GNUNET_CLIENT_disconnect (dns_connection, GNUNET_NO);
154	NULL);	169	dns_connection = NULL;
155	return;	170	conn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
156	}	171	&connect_to_service_dns, NULL);
157		172	return;
158	/* the service did something strange, reconnect immediately */	173	}
159	if (msg->type != htons(GNUNET_MESSAGE_TYPE_VPN_DNS_LOCAL_RESPONSE_DNS))	174
160	{	175	/* the service did something strange, reconnect immediately */
161	GNUNET_break (0);	176	if (msg->type != htons (GNUNET_MESSAGE_TYPE_VPN_DNS_LOCAL_RESPONSE_DNS))
162	GNUNET_CLIENT_disconnect(dns_connection, GNUNET_NO);	177	{
163	dns_connection = NULL;	178	GNUNET_break (0);
164	conn_task = GNUNET_SCHEDULER_add_now (&connect_to_service_dns,	179	GNUNET_CLIENT_disconnect (dns_connection, GNUNET_NO);
165	NULL);	180	dns_connection = NULL;
166	return;	181	conn_task = GNUNET_SCHEDULER_add_now (&connect_to_service_dns, NULL);
167	}	182	return;
168	void *pkt = GNUNET_malloc(ntohs(msg->size));	183	}
169		184	void *pkt = GNUNET_malloc (ntohs (msg->size));
170	memcpy(pkt, msg, ntohs(msg->size));	185
171		186	memcpy (pkt, msg, ntohs (msg->size));
172	GNUNET_SCHEDULER_add_now(process_answer, pkt);	187
173	GNUNET_CLIENT_receive(dns_connection, &dns_answer_handler, NULL, GNUNET_TIME_UNIT_FOREVER_REL);	188	GNUNET_SCHEDULER_add_now (process_answer, pkt);
		189	GNUNET_CLIENT_receive (dns_connection, &dns_answer_handler, NULL,
		190	GNUNET_TIME_UNIT_FOREVER_REL);
174	}	191	}
175