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/gnunet-service-dns.c
* Generic logging shorthand
*/
#define LOG(kind, ...) \
- GNUNET_log_from (kind, "dns", __VA_ARGS__);
+ GNUNET_log_from(kind, "dns", __VA_ARGS__);
/**
* Phases each request goes through.
*/
-enum RequestPhase
-{
+enum RequestPhase {
/**
* Request has just been received.
*/
/**
* Entry we keep for each client.
*/
-struct ClientRecord
-{
+struct ClientRecord {
/**
* Kept in doubly-linked list.
*/
struct ClientRecord *next;
- /**
+ /**
* Kept in doubly-linked list.
- */
+ */
struct ClientRecord *prev;
/**
* Flags for the client.
*/
enum GNUNET_DNS_Flags flags;
-
};
/**
* Entry we keep for each active request.
*/
-struct RequestRecord
-{
-
+struct RequestRecord {
/**
* List of clients that still need to see this request (each entry
* is set to NULL when the client is done).
* In which phase this this request?
*/
enum RequestPhase phase;
-
};
* @param rr request to clean up
*/
static void
-cleanup_rr (struct RequestRecord *rr)
+cleanup_rr(struct RequestRecord *rr)
{
- GNUNET_free_non_null (rr->payload);
+ GNUNET_free_non_null(rr->payload);
rr->payload = NULL;
rr->payload_length = 0;
- GNUNET_array_grow (rr->client_wait_list,
- rr->client_wait_list_length,
- 0);
+ GNUNET_array_grow(rr->client_wait_list,
+ rr->client_wait_list_length,
+ 0);
}
* @param cls unused
*/
static void
-cleanup_task (void *cls GNUNET_UNUSED)
+cleanup_task(void *cls GNUNET_UNUSED)
{
if (NULL != hijacker)
- {
- GNUNET_HELPER_stop (hijacker, GNUNET_NO);
- hijacker = NULL;
- }
- for (unsigned int i=0;i<8;i++)
- GNUNET_free_non_null (helper_argv[i]);
- for (unsigned int i=0;i<=UINT16_MAX;i++)
- cleanup_rr (&requests[i]);
+ {
+ GNUNET_HELPER_stop(hijacker, GNUNET_NO);
+ hijacker = NULL;
+ }
+ for (unsigned int i = 0; i < 8; i++)
+ GNUNET_free_non_null(helper_argv[i]);
+ for (unsigned int i = 0; i <= UINT16_MAX; i++)
+ cleanup_rr(&requests[i]);
if (NULL != stats)
- {
- GNUNET_STATISTICS_destroy (stats,
- GNUNET_NO);
- stats = NULL;
- }
+ {
+ GNUNET_STATISTICS_destroy(stats,
+ GNUNET_NO);
+ stats = NULL;
+ }
if (NULL != dnsstub)
- {
- GNUNET_DNSSTUB_stop (dnsstub);
- dnsstub = NULL;
- }
+ {
+ GNUNET_DNSSTUB_stop(dnsstub);
+ dnsstub = NULL;
+ }
}
* @param rr request send to the network or just clean up.
*/
static void
-request_done (struct RequestRecord *rr)
+request_done(struct RequestRecord *rr)
{
struct GNUNET_MessageHeader *hdr;
size_t reply_len;
uint16_t source_port;
uint16_t destination_port;
- GNUNET_array_grow (rr->client_wait_list,
- rr->client_wait_list_length,
- 0);
+ GNUNET_array_grow(rr->client_wait_list,
+ rr->client_wait_list_length,
+ 0);
if (RP_RESPONSE_MONITOR != rr->phase)
- {
- /* no response, drop */
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Got no response for request %llu, dropping\n",
- (unsigned long long) rr->request_id);
- cleanup_rr (rr);
- return;
- }
+ {
+ /* no response, drop */
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "Got no response for request %llu, dropping\n",
+ (unsigned long long)rr->request_id);
+ cleanup_rr(rr);
+ return;
+ }
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Transmitting response for request %llu\n",
- (unsigned long long) rr->request_id);
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "Transmitting response for request %llu\n",
+ (unsigned long long)rr->request_id);
/* send response via hijacker */
- reply_len = sizeof (struct GNUNET_MessageHeader);
- reply_len += sizeof (struct GNUNET_TUN_Layer2PacketHeader);
+ reply_len = sizeof(struct GNUNET_MessageHeader);
+ reply_len += sizeof(struct GNUNET_TUN_Layer2PacketHeader);
switch (rr->src_addr.ss_family)
- {
- case AF_INET:
- reply_len += sizeof (struct GNUNET_TUN_IPv4Header);
- break;
- case AF_INET6:
- reply_len += sizeof (struct GNUNET_TUN_IPv6Header);
- break;
- default:
- GNUNET_break (0);
- cleanup_rr (rr);
- return;
- }
- reply_len += sizeof (struct GNUNET_TUN_UdpHeader);
+ {
+ case AF_INET:
+ reply_len += sizeof(struct GNUNET_TUN_IPv4Header);
+ break;
+
+ case AF_INET6:
+ reply_len += sizeof(struct GNUNET_TUN_IPv6Header);
+ break;
+
+ default:
+ GNUNET_break(0);
+ cleanup_rr(rr);
+ return;
+ }
+ reply_len += sizeof(struct GNUNET_TUN_UdpHeader);
reply_len += rr->payload_length;
if (reply_len >= GNUNET_MAX_MESSAGE_SIZE)
- {
- /* response too big, drop */
- GNUNET_break (0); /* how can this be? */
- cleanup_rr(rr);
- return;
- }
+ {
+ /* response too big, drop */
+ GNUNET_break(0); /* how can this be? */
+ cleanup_rr(rr);
+ return;
+ }
{
char buf[reply_len] GNUNET_ALIGN;
size_t off;
struct GNUNET_TUN_IPv6Header ip6;
/* first, GNUnet message header */
- hdr = (struct GNUNET_MessageHeader*) buf;
- hdr->type = htons (GNUNET_MESSAGE_TYPE_DNS_HELPER);
- hdr->size = htons ((uint16_t) reply_len);
- off = sizeof (struct GNUNET_MessageHeader);
+ hdr = (struct GNUNET_MessageHeader*)buf;
+ hdr->type = htons(GNUNET_MESSAGE_TYPE_DNS_HELPER);
+ hdr->size = htons((uint16_t)reply_len);
+ off = sizeof(struct GNUNET_MessageHeader);
/* first, TUN header */
{
struct GNUNET_TUN_Layer2PacketHeader tun;
- tun.flags = htons (0);
+ tun.flags = htons(0);
if (rr->src_addr.ss_family == AF_INET)
- tun.proto = htons (ETH_P_IPV4);
+ tun.proto = htons(ETH_P_IPV4);
else
- tun.proto = htons (ETH_P_IPV6);
- GNUNET_memcpy (&buf[off],
- &tun,
- sizeof (struct GNUNET_TUN_Layer2PacketHeader));
- off += sizeof (struct GNUNET_TUN_Layer2PacketHeader);
+ tun.proto = htons(ETH_P_IPV6);
+ GNUNET_memcpy(&buf[off],
+ &tun,
+ sizeof(struct GNUNET_TUN_Layer2PacketHeader));
+ off += sizeof(struct GNUNET_TUN_Layer2PacketHeader);
}
/* now IP header */
switch (rr->src_addr.ss_family)
- {
- case AF_INET:
{
- struct sockaddr_in *src = (struct sockaddr_in *) &rr->src_addr;
- struct sockaddr_in *dst = (struct sockaddr_in *) &rr->dst_addr;
-
- source_port = dst->sin_port;
- destination_port = src->sin_port;
- GNUNET_TUN_initialize_ipv4_header (&ip4,
- IPPROTO_UDP,
- reply_len - off - sizeof (struct GNUNET_TUN_IPv4Header),
- &dst->sin_addr,
- &src->sin_addr);
- GNUNET_memcpy (&buf[off],
- &ip4,
- sizeof (ip4));
- off += sizeof (ip4);
+ case AF_INET:
+ {
+ struct sockaddr_in *src = (struct sockaddr_in *)&rr->src_addr;
+ struct sockaddr_in *dst = (struct sockaddr_in *)&rr->dst_addr;
+
+ source_port = dst->sin_port;
+ destination_port = src->sin_port;
+ GNUNET_TUN_initialize_ipv4_header(&ip4,
+ IPPROTO_UDP,
+ reply_len - off - sizeof(struct GNUNET_TUN_IPv4Header),
+ &dst->sin_addr,
+ &src->sin_addr);
+ GNUNET_memcpy(&buf[off],
+ &ip4,
+ sizeof(ip4));
+ off += sizeof(ip4);
}
break;
- case AF_INET6:
+
+ case AF_INET6:
{
- struct sockaddr_in6 *src = (struct sockaddr_in6 *) &rr->src_addr;
- struct sockaddr_in6 *dst = (struct sockaddr_in6 *) &rr->dst_addr;
-
- source_port = dst->sin6_port;
- destination_port = src->sin6_port;
- GNUNET_TUN_initialize_ipv6_header (&ip6,
- IPPROTO_UDP,
- reply_len - off - sizeof (struct GNUNET_TUN_IPv6Header),
- &dst->sin6_addr,
- &src->sin6_addr);
- GNUNET_memcpy (&buf[off],
- &ip6,
- sizeof (ip6));
- off += sizeof (ip6);
+ struct sockaddr_in6 *src = (struct sockaddr_in6 *)&rr->src_addr;
+ struct sockaddr_in6 *dst = (struct sockaddr_in6 *)&rr->dst_addr;
+
+ source_port = dst->sin6_port;
+ destination_port = src->sin6_port;
+ GNUNET_TUN_initialize_ipv6_header(&ip6,
+ IPPROTO_UDP,
+ reply_len - off - sizeof(struct GNUNET_TUN_IPv6Header),
+ &dst->sin6_addr,
+ &src->sin6_addr);
+ GNUNET_memcpy(&buf[off],
+ &ip6,
+ sizeof(ip6));
+ off += sizeof(ip6);
}
break;
- default:
- GNUNET_assert (0);
- }
+
+ default:
+ GNUNET_assert(0);
+ }
/* now UDP header */
{
udp.source_port = source_port;
udp.destination_port = destination_port;
- udp.len = htons (reply_len - off);
+ udp.len = htons(reply_len - off);
if (AF_INET == rr->src_addr.ss_family)
- GNUNET_TUN_calculate_udp4_checksum (&ip4,
- &udp,
- rr->payload,
- rr->payload_length);
+ GNUNET_TUN_calculate_udp4_checksum(&ip4,
+ &udp,
+ rr->payload,
+ rr->payload_length);
else
- GNUNET_TUN_calculate_udp6_checksum (&ip6,
- &udp,
- rr->payload,
- rr->payload_length);
- GNUNET_memcpy (&buf[off],
- &udp,
- sizeof (udp));
- off += sizeof (udp);
+ GNUNET_TUN_calculate_udp6_checksum(&ip6,
+ &udp,
+ rr->payload,
+ rr->payload_length);
+ GNUNET_memcpy(&buf[off],
+ &udp,
+ sizeof(udp));
+ off += sizeof(udp);
}
/* now DNS payload */
{
- GNUNET_memcpy (&buf[off], rr->payload, rr->payload_length);
+ GNUNET_memcpy(&buf[off], rr->payload, rr->payload_length);
off += rr->payload_length;
}
/* final checks & sending */
- GNUNET_assert (off == reply_len);
- (void) GNUNET_HELPER_send (hijacker,
- hdr,
- GNUNET_YES,
- NULL, NULL);
- GNUNET_STATISTICS_update (stats,
- gettext_noop ("# DNS requests answered via TUN interface"),
- 1, GNUNET_NO);
+ GNUNET_assert(off == reply_len);
+ (void)GNUNET_HELPER_send(hijacker,
+ hdr,
+ GNUNET_YES,
+ NULL, NULL);
+ GNUNET_STATISTICS_update(stats,
+ gettext_noop("# DNS requests answered via TUN interface"),
+ 1, GNUNET_NO);
}
/* clean up, we're done */
- cleanup_rr (rr);
+ cleanup_rr(rr);
}
* @param cr client to send the response to
*/
static void
-send_request_to_client (struct RequestRecord *rr,
- struct ClientRecord *cr)
+send_request_to_client(struct RequestRecord *rr,
+ struct ClientRecord *cr)
{
struct GNUNET_MQ_Envelope *env;
struct GNUNET_DNS_Request *req;
- if (sizeof (struct GNUNET_DNS_Request) + rr->payload_length >= GNUNET_MAX_MESSAGE_SIZE)
- {
- GNUNET_break (0);
- cleanup_rr (rr);
- return;
- }
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Sending information about request %llu to local client\n",
- (unsigned long long) rr->request_id);
- env = GNUNET_MQ_msg_extra (req,
- rr->payload_length,
- GNUNET_MESSAGE_TYPE_DNS_CLIENT_REQUEST);
- req->reserved = htonl (0);
+ if (sizeof(struct GNUNET_DNS_Request) + rr->payload_length >= GNUNET_MAX_MESSAGE_SIZE)
+ {
+ GNUNET_break(0);
+ cleanup_rr(rr);
+ return;
+ }
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "Sending information about request %llu to local client\n",
+ (unsigned long long)rr->request_id);
+ env = GNUNET_MQ_msg_extra(req,
+ rr->payload_length,
+ GNUNET_MESSAGE_TYPE_DNS_CLIENT_REQUEST);
+ req->reserved = htonl(0);
req->request_id = rr->request_id;
- GNUNET_memcpy (&req[1],
- rr->payload,
- rr->payload_length);
- GNUNET_MQ_send (cr->mq,
- env);
+ GNUNET_memcpy(&req[1],
+ rr->payload,
+ rr->payload_length);
+ GNUNET_MQ_send(cr->mq,
+ env);
}
* @param r number of bytes in dns
*/
static void
-process_dns_result (void *cls,
- const struct GNUNET_TUN_DnsHeader *dns,
- size_t r);
+process_dns_result(void *cls,
+ const struct GNUNET_TUN_DnsHeader *dns,
+ size_t r);
/**
* @param rr request to process further
*/
static void
-next_phase (struct RequestRecord *rr)
+next_phase(struct RequestRecord *rr)
{
struct ClientRecord *cr;
int nz;
if (rr->phase == RP_DROP)
- {
- cleanup_rr (rr);
- return;
- }
+ {
+ cleanup_rr(rr);
+ return;
+ }
nz = -1;
- for (unsigned int j=0;j<rr->client_wait_list_length;j++)
- {
- if (NULL != rr->client_wait_list[j])
+ for (unsigned int j = 0; j < rr->client_wait_list_length; j++)
{
- nz = (int) j;
- break;
+ if (NULL != rr->client_wait_list[j])
+ {
+ nz = (int)j;
+ break;
+ }
}
- }
if (-1 != nz)
- {
- send_request_to_client (rr,
- rr->client_wait_list[nz]);
- return;
- }
- /* done with current phase, advance! */
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Request %llu now in phase %d\n",
- rr->request_id,
- rr->phase);
- switch (rr->phase)
- {
- case RP_INIT:
- rr->phase = RP_REQUEST_MONITOR;
- for (cr = clients_head; NULL != cr; cr = cr->next)
{
- if (0 != (cr->flags & GNUNET_DNS_FLAG_REQUEST_MONITOR))
- GNUNET_array_append (rr->client_wait_list,
- rr->client_wait_list_length,
- cr);
+ send_request_to_client(rr,
+ rr->client_wait_list[nz]);
+ return;
}
- next_phase (rr);
- return;
- case RP_REQUEST_MONITOR:
- rr->phase = RP_QUERY;
- for (cr = clients_head; NULL != cr; cr = cr->next)
+ /* done with current phase, advance! */
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "Request %llu now in phase %d\n",
+ rr->request_id,
+ rr->phase);
+ switch (rr->phase)
{
- if (0 != (cr->flags & GNUNET_DNS_FLAG_PRE_RESOLUTION))
- GNUNET_array_append (rr->client_wait_list,
- rr->client_wait_list_length,
- cr);
- }
- next_phase (rr);
- return;
- case RP_QUERY:
+ case RP_INIT:
+ rr->phase = RP_REQUEST_MONITOR;
+ for (cr = clients_head; NULL != cr; cr = cr->next)
+ {
+ if (0 != (cr->flags & GNUNET_DNS_FLAG_REQUEST_MONITOR))
+ GNUNET_array_append(rr->client_wait_list,
+ rr->client_wait_list_length,
+ cr);
+ }
+ next_phase(rr);
+ return;
+
+ case RP_REQUEST_MONITOR:
+ rr->phase = RP_QUERY;
+ for (cr = clients_head; NULL != cr; cr = cr->next)
+ {
+ if (0 != (cr->flags & GNUNET_DNS_FLAG_PRE_RESOLUTION))
+ GNUNET_array_append(rr->client_wait_list,
+ rr->client_wait_list_length,
+ cr);
+ }
+ next_phase(rr);
+ return;
+
+ case RP_QUERY:
#if 0
- /* TODO: optionally, use this to forward DNS requests to the
- *original* DNS server instead of the one we have configured...
- (but then we need to create a fresh dnsstub for each request
- *and* manage the timeout) */
- switch (rr->dst_addr.ss_family)
- {
- case AF_INET:
- salen = sizeof (struct sockaddr_in);
- sa = (const struct sockaddr *) &rr->dst_addr;
+ /* TODO: optionally, use this to forward DNS requests to the
+ * original* DNS server instead of the one we have configured...
+ (but then we need to create a fresh dnsstub for each request
+ * and* manage the timeout) */
+ switch (rr->dst_addr.ss_family)
+ {
+ case AF_INET:
+ salen = sizeof(struct sockaddr_in);
+ sa = (const struct sockaddr *)&rr->dst_addr;
+ break;
+
+ case AF_INET6:
+ salen = sizeof(struct sockaddr_in6);
+ sa = (const struct sockaddr *)&rr->dst_addr;
+ break;
+
+ default:
+ GNUNET_assert(0);
+ }
+#endif
+ rr->phase = RP_INTERNET_DNS;
+ rr->rs = GNUNET_DNSSTUB_resolve(dnsstub,
+ rr->payload,
+ rr->payload_length,
+ &process_dns_result,
+ NULL);
+ if (NULL == rr->rs)
+ {
+ GNUNET_STATISTICS_update(stats,
+ gettext_noop("# DNS exit failed (failed to open socket)"),
+ 1,
+ GNUNET_NO);
+ cleanup_rr(rr);
+ return;
+ }
+ return;
+
+ case RP_INTERNET_DNS:
+ rr->phase = RP_MODIFY;
+ for (cr = clients_head; NULL != cr; cr = cr->next)
+ {
+ if (0 != (cr->flags & GNUNET_DNS_FLAG_POST_RESOLUTION))
+ GNUNET_array_append(rr->client_wait_list,
+ rr->client_wait_list_length,
+ cr);
+ }
+ next_phase(rr);
+ return;
+
+ case RP_MODIFY:
+ rr->phase = RP_RESPONSE_MONITOR;
+ for (cr = clients_head; NULL != cr; cr = cr->next)
+ {
+ if (0 != (cr->flags & GNUNET_DNS_FLAG_RESPONSE_MONITOR))
+ GNUNET_array_append(rr->client_wait_list,
+ rr->client_wait_list_length,
+ cr);
+ }
+ next_phase(rr);
+ return;
+
+ case RP_RESPONSE_MONITOR:
+ request_done(rr);
break;
- case AF_INET6:
- salen = sizeof (struct sockaddr_in6);
- sa = (const struct sockaddr *) &rr->dst_addr;
+
+ case RP_DROP:
+ cleanup_rr(rr);
break;
+
default:
- GNUNET_assert (0);
- }
-#endif
- rr->phase = RP_INTERNET_DNS;
- rr->rs = GNUNET_DNSSTUB_resolve (dnsstub,
- rr->payload,
- rr->payload_length,
- &process_dns_result,
- NULL);
- if (NULL == rr->rs)
- {
- GNUNET_STATISTICS_update (stats,
- gettext_noop ("# DNS exit failed (failed to open socket)"),
- 1,
- GNUNET_NO);
- cleanup_rr (rr);
- return;
- }
- return;
- case RP_INTERNET_DNS:
- rr->phase = RP_MODIFY;
- for (cr = clients_head; NULL != cr; cr = cr->next)
- {
- if (0 != (cr->flags & GNUNET_DNS_FLAG_POST_RESOLUTION))
- GNUNET_array_append (rr->client_wait_list,
- rr->client_wait_list_length,
- cr);
- }
- next_phase (rr);
- return;
- case RP_MODIFY:
- rr->phase = RP_RESPONSE_MONITOR;
- for (cr = clients_head; NULL != cr; cr = cr->next)
- {
- if (0 != (cr->flags & GNUNET_DNS_FLAG_RESPONSE_MONITOR))
- GNUNET_array_append (rr->client_wait_list,
- rr->client_wait_list_length,
- cr);
+ GNUNET_break(0);
+ cleanup_rr(rr);
+ break;
}
- next_phase (rr);
- return;
- case RP_RESPONSE_MONITOR:
- request_done (rr);
- break;
- case RP_DROP:
- cleanup_rr (rr);
- break;
- default:
- GNUNET_break (0);
- cleanup_rr (rr);
- break;
- }
}
* @return our `struct ClientRecord`
*/
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 ClientRecord *cr = cls;
- cr = GNUNET_new (struct ClientRecord);
+ cr = GNUNET_new(struct ClientRecord);
cr->client = client;
cr->mq = mq;
- GNUNET_CONTAINER_DLL_insert (clients_head,
- clients_tail,
- cr);
+ GNUNET_CONTAINER_DLL_insert(clients_head,
+ clients_tail,
+ cr);
return cr;
}
* @param app_ctx our `struct ClientRecord`
*/
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 ClientRecord *cr = app_ctx;
struct RequestRecord *rr;
- GNUNET_CONTAINER_DLL_remove (clients_head,
- clients_tail,
- cr);
- for (unsigned int i=0;i<UINT16_MAX;i++)
- {
- rr = &requests[i];
- if (0 == rr->client_wait_list_length)
- continue; /* not in use */
- for (unsigned int j=0;j<rr->client_wait_list_length;j++)
+ GNUNET_CONTAINER_DLL_remove(clients_head,
+ clients_tail,
+ cr);
+ for (unsigned int i = 0; i < UINT16_MAX; i++)
{
- if (rr->client_wait_list[j] == cr)
- {
- rr->client_wait_list[j] = NULL;
- next_phase (rr);
- }
+ rr = &requests[i];
+ if (0 == rr->client_wait_list_length)
+ continue; /* not in use */
+ for (unsigned int j = 0; j < rr->client_wait_list_length; j++)
+ {
+ if (rr->client_wait_list[j] == cr)
+ {
+ rr->client_wait_list[j] = NULL;
+ next_phase(rr);
+ }
+ }
}
- }
- GNUNET_free (cr);
+ GNUNET_free(cr);
}
* @param r number of bytes in dns
*/
static void
-process_dns_result (void *cls,
- const struct GNUNET_TUN_DnsHeader *dns,
- size_t r)
+process_dns_result(void *cls,
+ const struct GNUNET_TUN_DnsHeader *dns,
+ size_t r)
{
struct RequestRecord *rr;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Processing DNS result from stub resolver\n");
- GNUNET_assert (NULL == cls);
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "Processing DNS result from stub resolver\n");
+ GNUNET_assert(NULL == cls);
if (NULL == dns)
return; /* ignore */
rr = &requests[dns->id];
if (rr->phase != RP_INTERNET_DNS)
- {
- /* unexpected / bogus reply */
- GNUNET_STATISTICS_update (stats,
- gettext_noop ("# External DNS response discarded (no matching request)"),
- 1, GNUNET_NO);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Received DNS reply that does not match any pending request. Dropping.\n");
- return;
- }
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Got a response from the stub resolver for DNS request %llu intercepted locally!\n",
- (unsigned long long) rr->request_id);
- GNUNET_free_non_null (rr->payload);
- rr->payload = GNUNET_malloc (r);
- GNUNET_memcpy (rr->payload,
- dns,
- r);
+ {
+ /* unexpected / bogus reply */
+ GNUNET_STATISTICS_update(stats,
+ gettext_noop("# External DNS response discarded (no matching request)"),
+ 1, GNUNET_NO);
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "Received DNS reply that does not match any pending request. Dropping.\n");
+ return;
+ }
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "Got a response from the stub resolver for DNS request %llu intercepted locally!\n",
+ (unsigned long long)rr->request_id);
+ GNUNET_free_non_null(rr->payload);
+ rr->payload = GNUNET_malloc(r);
+ GNUNET_memcpy(rr->payload,
+ dns,
+ r);
rr->payload_length = r;
- next_phase (rr);
+ next_phase(rr);
}
* @param reg the init message
*/
static void
-handle_client_init (void *cls,
- const struct GNUNET_DNS_Register *reg)
+handle_client_init(void *cls,
+ const struct GNUNET_DNS_Register *reg)
{
struct ClientRecord *cr = cls;
- cr->flags = (enum GNUNET_DNS_Flags) ntohl (reg->flags);
- GNUNET_SERVICE_client_continue (cr->client);
+ cr->flags = (enum GNUNET_DNS_Flags)ntohl(reg->flags);
+ GNUNET_SERVICE_client_continue(cr->client);
}
* @return #GNUNET_OK (always fine)
*/
static int
-check_client_response (void *cls,
- const struct GNUNET_DNS_Response *resp)
+check_client_response(void *cls,
+ const struct GNUNET_DNS_Response *resp)
{
return GNUNET_OK; /* any payload is acceptable */
}
* @param resp the response
*/
static void
-handle_client_response (void *cls,
- const struct GNUNET_DNS_Response *resp)
+handle_client_response(void *cls,
+ const struct GNUNET_DNS_Response *resp)
{
struct ClientRecord *cr = cls;
struct RequestRecord *rr;
uint16_t msize;
uint16_t off;
- msize = ntohs (resp->header.size);
- off = (uint16_t) resp->request_id;
+ msize = ntohs(resp->header.size);
+ off = (uint16_t)resp->request_id;
rr = &requests[off];
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Received DNS response with ID %llu from local client!\n",
- (unsigned long long) resp->request_id);
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "Received DNS response with ID %llu from local client!\n",
+ (unsigned long long)resp->request_id);
if (rr->request_id != resp->request_id)
- {
- GNUNET_STATISTICS_update (stats,
- gettext_noop ("# Client response discarded (no matching request)"),
- 1,
- GNUNET_NO);
- GNUNET_SERVICE_client_continue (cr->client);
- return;
- }
- for (unsigned int i=0;i<rr->client_wait_list_length;i++)
- {
- if (NULL == rr->client_wait_list[i])
- continue;
- if (rr->client_wait_list[i] != cr)
- continue;
- rr->client_wait_list[i] = NULL;
- switch (ntohl (resp->drop_flag))
{
- case 0: /* drop */
- rr->phase = RP_DROP;
- break;
- case 1: /* no change */
- break;
- case 2: /* update */
- msize -= sizeof (struct GNUNET_DNS_Response);
- if ( (sizeof (struct GNUNET_TUN_DnsHeader) > msize) ||
- (RP_REQUEST_MONITOR == rr->phase) ||
- (RP_RESPONSE_MONITOR == rr->phase) )
- {
- GNUNET_break (0);
- GNUNET_SERVICE_client_drop (cr->client);
- next_phase (rr);
- return;
- }
- GNUNET_free_non_null (rr->payload);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Changing DNS reply according to client specifications\n");
- rr->payload = GNUNET_malloc (msize);
- rr->payload_length = msize;
- GNUNET_memcpy (rr->payload, &resp[1], msize);
- if (rr->phase == RP_QUERY)
- {
- /* clear wait list, we're moving to MODIFY phase next */
- GNUNET_array_grow (rr->client_wait_list,
- rr->client_wait_list_length,
- 0);
- }
- /* if query changed to answer, move past DNS resolution phase... */
- if ( (RP_QUERY == rr->phase) &&
- (rr->payload_length > sizeof (struct GNUNET_TUN_DnsHeader)) &&
- ((struct GNUNET_TUN_DnsFlags*)&(((struct GNUNET_TUN_DnsHeader*) rr->payload)->flags))->query_or_response == 1)
- {
- rr->phase = RP_INTERNET_DNS;
- GNUNET_array_grow (rr->client_wait_list,
- rr->client_wait_list_length,
- 0);
- }
- break;
+ GNUNET_STATISTICS_update(stats,
+ gettext_noop("# Client response discarded (no matching request)"),
+ 1,
+ GNUNET_NO);
+ GNUNET_SERVICE_client_continue(cr->client);
+ return;
+ }
+ for (unsigned int i = 0; i < rr->client_wait_list_length; i++)
+ {
+ if (NULL == rr->client_wait_list[i])
+ continue;
+ if (rr->client_wait_list[i] != cr)
+ continue;
+ rr->client_wait_list[i] = NULL;
+ switch (ntohl(resp->drop_flag))
+ {
+ case 0: /* drop */
+ rr->phase = RP_DROP;
+ break;
+
+ case 1: /* no change */
+ break;
+
+ case 2: /* update */
+ msize -= sizeof(struct GNUNET_DNS_Response);
+ if ((sizeof(struct GNUNET_TUN_DnsHeader) > msize) ||
+ (RP_REQUEST_MONITOR == rr->phase) ||
+ (RP_RESPONSE_MONITOR == rr->phase))
+ {
+ GNUNET_break(0);
+ GNUNET_SERVICE_client_drop(cr->client);
+ next_phase(rr);
+ return;
+ }
+ GNUNET_free_non_null(rr->payload);
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "Changing DNS reply according to client specifications\n");
+ rr->payload = GNUNET_malloc(msize);
+ rr->payload_length = msize;
+ GNUNET_memcpy(rr->payload, &resp[1], msize);
+ if (rr->phase == RP_QUERY)
+ {
+ /* clear wait list, we're moving to MODIFY phase next */
+ GNUNET_array_grow(rr->client_wait_list,
+ rr->client_wait_list_length,
+ 0);
+ }
+ /* if query changed to answer, move past DNS resolution phase... */
+ if ((RP_QUERY == rr->phase) &&
+ (rr->payload_length > sizeof(struct GNUNET_TUN_DnsHeader)) &&
+ ((struct GNUNET_TUN_DnsFlags*)&(((struct GNUNET_TUN_DnsHeader*)rr->payload)->flags))->query_or_response == 1)
+ {
+ rr->phase = RP_INTERNET_DNS;
+ GNUNET_array_grow(rr->client_wait_list,
+ rr->client_wait_list_length,
+ 0);
+ }
+ break;
+ }
+ next_phase(rr);
+ GNUNET_SERVICE_client_continue(cr->client);
+ return;
}
- next_phase (rr);
- GNUNET_SERVICE_client_continue (cr->client);
- return;
- }
/* odd, client was not on our list for the request, that ought
to be an error */
- GNUNET_break (0);
- GNUNET_SERVICE_client_drop (cr->client);
+ GNUNET_break(0);
+ GNUNET_SERVICE_client_drop(cr->client);
}
* @param message the actual message, a DNS request we should handle
*/
static int
-process_helper_messages (void *cls,
- const struct GNUNET_MessageHeader *message)
+process_helper_messages(void *cls,
+ const struct GNUNET_MessageHeader *message)
{
uint16_t msize;
const struct GNUNET_TUN_Layer2PacketHeader *tun;
struct sockaddr_in *dsta4;
struct sockaddr_in6 *dsta6;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Intercepted message via DNS hijacker\n");
- msize = ntohs (message->size);
- if (msize < sizeof (struct GNUNET_MessageHeader) + sizeof (struct GNUNET_TUN_Layer2PacketHeader) + sizeof (struct GNUNET_TUN_IPv4Header))
- {
- /* non-IP packet received on TUN!? */
- GNUNET_break (0);
- return GNUNET_OK;
- }
- msize -= sizeof (struct GNUNET_MessageHeader);
- tun = (const struct GNUNET_TUN_Layer2PacketHeader *) &message[1];
- msize -= sizeof (struct GNUNET_TUN_Layer2PacketHeader);
- switch (ntohs (tun->proto))
- {
- case ETH_P_IPV4:
- ip4 = (const struct GNUNET_TUN_IPv4Header *) &tun[1];
- ip6 = NULL; /* make compiler happy */
- if ( (msize < sizeof (struct GNUNET_TUN_IPv4Header)) ||
- (ip4->version != 4) ||
- (ip4->header_length != sizeof (struct GNUNET_TUN_IPv4Header) / 4) ||
- (ntohs(ip4->total_length) != msize) ||
- (ip4->protocol != IPPROTO_UDP) )
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "Intercepted message via DNS hijacker\n");
+ msize = ntohs(message->size);
+ if (msize < sizeof(struct GNUNET_MessageHeader) + sizeof(struct GNUNET_TUN_Layer2PacketHeader) + sizeof(struct GNUNET_TUN_IPv4Header))
{
- /* non-IP/UDP packet received on TUN (or with options) */
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Received malformed IPv4-UDP packet on TUN interface.\n"));
+ /* non-IP packet received on TUN!? */
+ GNUNET_break(0);
return GNUNET_OK;
}
- udp = (const struct GNUNET_TUN_UdpHeader*) &ip4[1];
- msize -= sizeof (struct GNUNET_TUN_IPv4Header);
- break;
- case ETH_P_IPV6:
- ip4 = NULL; /* make compiler happy */
- ip6 = (const struct GNUNET_TUN_IPv6Header *) &tun[1];
- if ( (msize < sizeof (struct GNUNET_TUN_IPv6Header)) ||
- (ip6->version != 6) ||
- (ntohs (ip6->payload_length) != msize - sizeof (struct GNUNET_TUN_IPv6Header)) ||
- (ip6->next_header != IPPROTO_UDP) )
+ msize -= sizeof(struct GNUNET_MessageHeader);
+ tun = (const struct GNUNET_TUN_Layer2PacketHeader *)&message[1];
+ msize -= sizeof(struct GNUNET_TUN_Layer2PacketHeader);
+ switch (ntohs(tun->proto))
{
- /* non-IP/UDP packet received on TUN (or with extensions) */
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Received malformed IPv6-UDP packet on TUN interface.\n"));
+ case ETH_P_IPV4:
+ ip4 = (const struct GNUNET_TUN_IPv4Header *)&tun[1];
+ ip6 = NULL; /* make compiler happy */
+ if ((msize < sizeof(struct GNUNET_TUN_IPv4Header)) ||
+ (ip4->version != 4) ||
+ (ip4->header_length != sizeof(struct GNUNET_TUN_IPv4Header) / 4) ||
+ (ntohs(ip4->total_length) != msize) ||
+ (ip4->protocol != IPPROTO_UDP))
+ {
+ /* non-IP/UDP packet received on TUN (or with options) */
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+ _("Received malformed IPv4-UDP packet on TUN interface.\n"));
+ return GNUNET_OK;
+ }
+ udp = (const struct GNUNET_TUN_UdpHeader*)&ip4[1];
+ msize -= sizeof(struct GNUNET_TUN_IPv4Header);
+ break;
+
+ case ETH_P_IPV6:
+ ip4 = NULL; /* make compiler happy */
+ ip6 = (const struct GNUNET_TUN_IPv6Header *)&tun[1];
+ if ((msize < sizeof(struct GNUNET_TUN_IPv6Header)) ||
+ (ip6->version != 6) ||
+ (ntohs(ip6->payload_length) != msize - sizeof(struct GNUNET_TUN_IPv6Header)) ||
+ (ip6->next_header != IPPROTO_UDP))
+ {
+ /* non-IP/UDP packet received on TUN (or with extensions) */
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+ _("Received malformed IPv6-UDP packet on TUN interface.\n"));
+ return GNUNET_OK;
+ }
+ udp = (const struct GNUNET_TUN_UdpHeader *)&ip6[1];
+ msize -= sizeof(struct GNUNET_TUN_IPv6Header);
+ break;
+
+ default:
+ /* non-IP packet received on TUN!? */
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+ _("Got non-IP packet with %u bytes and protocol %u from TUN\n"),
+ (unsigned int)msize,
+ ntohs(tun->proto));
return GNUNET_OK;
}
- udp = (const struct GNUNET_TUN_UdpHeader *) &ip6[1];
- msize -= sizeof (struct GNUNET_TUN_IPv6Header);
- break;
- default:
- /* non-IP packet received on TUN!? */
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Got non-IP packet with %u bytes and protocol %u from TUN\n"),
- (unsigned int) msize,
- ntohs (tun->proto));
- return GNUNET_OK;
- }
- if ( (msize <= sizeof (struct GNUNET_TUN_UdpHeader) + sizeof (struct GNUNET_TUN_DnsHeader)) ||
- (DNS_PORT != ntohs (udp->destination_port)) )
- {
- /* non-DNS packet received on TUN, ignore */
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- _("DNS interceptor got non-DNS packet (dropped)\n"));
- GNUNET_STATISTICS_update (stats,
- gettext_noop ("# Non-DNS UDP packet received via TUN interface"),
- 1, GNUNET_NO);
- return GNUNET_OK;
- }
- msize -= sizeof (struct GNUNET_TUN_UdpHeader);
- dns = (const struct GNUNET_TUN_DnsHeader*) &udp[1];
+ if ((msize <= sizeof(struct GNUNET_TUN_UdpHeader) + sizeof(struct GNUNET_TUN_DnsHeader)) ||
+ (DNS_PORT != ntohs(udp->destination_port)))
+ {
+ /* non-DNS packet received on TUN, ignore */
+ GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+ _("DNS interceptor got non-DNS packet (dropped)\n"));
+ GNUNET_STATISTICS_update(stats,
+ gettext_noop("# Non-DNS UDP packet received via TUN interface"),
+ 1, GNUNET_NO);
+ return GNUNET_OK;
+ }
+ msize -= sizeof(struct GNUNET_TUN_UdpHeader);
+ dns = (const struct GNUNET_TUN_DnsHeader*)&udp[1];
rr = &requests[dns->id];
/* clean up from previous request */
- GNUNET_free_non_null (rr->payload);
+ GNUNET_free_non_null(rr->payload);
rr->payload = NULL;
- GNUNET_array_grow (rr->client_wait_list,
- rr->client_wait_list_length,
- 0);
+ GNUNET_array_grow(rr->client_wait_list,
+ rr->client_wait_list_length,
+ 0);
/* setup new request */
rr->phase = RP_INIT;
- switch (ntohs (tun->proto))
- {
- case ETH_P_IPV4:
+ switch (ntohs(tun->proto))
{
- srca4 = (struct sockaddr_in*) &rr->src_addr;
- dsta4 = (struct sockaddr_in*) &rr->dst_addr;
- memset (srca4, 0, sizeof (struct sockaddr_in));
- memset (dsta4, 0, sizeof (struct sockaddr_in));
+ case ETH_P_IPV4:
+ {
+ srca4 = (struct sockaddr_in*)&rr->src_addr;
+ dsta4 = (struct sockaddr_in*)&rr->dst_addr;
+ memset(srca4, 0, sizeof(struct sockaddr_in));
+ memset(dsta4, 0, sizeof(struct sockaddr_in));
srca4->sin_family = AF_INET;
dsta4->sin_family = AF_INET;
srca4->sin_addr = ip4->source_address;
srca4->sin_port = udp->source_port;
dsta4->sin_port = udp->destination_port;
#if HAVE_SOCKADDR_IN_SIN_LEN
- srca4->sin_len = sizeof (struct sockaddr_in);
- dsta4->sin_len = sizeof (struct sockaddr_in);
+ srca4->sin_len = sizeof(struct sockaddr_in);
+ dsta4->sin_len = sizeof(struct sockaddr_in);
#endif
}
break;
- case ETH_P_IPV6:
+
+ case ETH_P_IPV6:
{
- srca6 = (struct sockaddr_in6*) &rr->src_addr;
- dsta6 = (struct sockaddr_in6*) &rr->dst_addr;
- memset (srca6, 0, sizeof (struct sockaddr_in6));
- memset (dsta6, 0, sizeof (struct sockaddr_in6));
+ srca6 = (struct sockaddr_in6*)&rr->src_addr;
+ dsta6 = (struct sockaddr_in6*)&rr->dst_addr;
+ memset(srca6, 0, sizeof(struct sockaddr_in6));
+ memset(dsta6, 0, sizeof(struct sockaddr_in6));
srca6->sin6_family = AF_INET6;
dsta6->sin6_family = AF_INET6;
srca6->sin6_addr = ip6->source_address;
srca6->sin6_port = udp->source_port;
dsta6->sin6_port = udp->destination_port;
#if HAVE_SOCKADDR_IN_SIN_LEN
- srca6->sin6_len = sizeof (struct sockaddr_in6);
- dsta6->sin6_len = sizeof (struct sockaddr_in6);
+ srca6->sin6_len = sizeof(struct sockaddr_in6);
+ dsta6->sin6_len = sizeof(struct sockaddr_in6);
#endif
}
- break;
- default:
- GNUNET_assert (0);
- }
- rr->payload = GNUNET_malloc (msize);
+ break;
+
+ default:
+ GNUNET_assert(0);
+ }
+ rr->payload = GNUNET_malloc(msize);
rr->payload_length = msize;
- GNUNET_memcpy (rr->payload, dns, msize);
+ GNUNET_memcpy(rr->payload, dns, msize);
rr->request_id = dns->id | (request_id_gen << 16);
request_id_gen++;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Creating new DNS request %llu\n",
- (unsigned long long) rr->request_id);
- GNUNET_STATISTICS_update (stats,
- gettext_noop ("# DNS requests received via TUN interface"),
- 1, GNUNET_NO);
+ LOG(GNUNET_ERROR_TYPE_DEBUG,
+ "Creating new DNS request %llu\n",
+ (unsigned long long)rr->request_id);
+ GNUNET_STATISTICS_update(stats,
+ gettext_noop("# DNS requests received via TUN interface"),
+ 1, GNUNET_NO);
/* start request processing state machine */
- next_phase (rr);
+ next_phase(rr);
return GNUNET_OK;
}
* @param service the initialized service
*/
static void
-run (void *cls,
- const struct GNUNET_CONFIGURATION_Handle *cfg_,
- struct GNUNET_SERVICE_Handle *service)
+run(void *cls,
+ const struct GNUNET_CONFIGURATION_Handle *cfg_,
+ struct GNUNET_SERVICE_Handle *service)
{
char *ifc_name;
char *ipv4addr;
int nortsetup;
cfg = cfg_;
- stats = GNUNET_STATISTICS_create ("dns", cfg);
- GNUNET_SCHEDULER_add_shutdown (&cleanup_task,
- cls);
- dnsstub = GNUNET_DNSSTUB_start (128);
+ stats = GNUNET_STATISTICS_create("dns", cfg);
+ GNUNET_SCHEDULER_add_shutdown(&cleanup_task,
+ cls);
+ dnsstub = GNUNET_DNSSTUB_start(128);
/* TODO: support multiple DNS_EXIT servers being configured */
/* TODO: see above TODO on using DNS server from original packet.
Not sure which is best... */
dns_exit = NULL;
- if ( (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_string (cfg,
- "dns",
- "DNS_EXIT",
- &dns_exit)) ||
- (GNUNET_OK !=
- GNUNET_DNSSTUB_add_dns_ip (dnsstub,
- dns_exit)) )
- {
- GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
- "dns",
- "DNS_EXIT",
- _("need a valid IPv4 or IPv6 address\n"));
- GNUNET_free_non_null (dns_exit);
- }
- binary = GNUNET_OS_get_suid_binary_path (cfg, "gnunet-helper-dns");
+ if ((GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_string(cfg,
+ "dns",
+ "DNS_EXIT",
+ &dns_exit)) ||
+ (GNUNET_OK !=
+ GNUNET_DNSSTUB_add_dns_ip(dnsstub,
+ dns_exit)))
+ {
+ GNUNET_log_config_invalid(GNUNET_ERROR_TYPE_ERROR,
+ "dns",
+ "DNS_EXIT",
+ _("need a valid IPv4 or IPv6 address\n"));
+ GNUNET_free_non_null(dns_exit);
+ }
+ binary = GNUNET_OS_get_suid_binary_path(cfg, "gnunet-helper-dns");
if (GNUNET_YES !=
- GNUNET_OS_check_helper_binary (binary,
- GNUNET_YES,
- NULL)) // TODO: once we have a windows-testcase, add test parameters here
- {
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- _("`%s' is not SUID or the path is invalid, "
- "will not run DNS interceptor\n"),
- binary);
- global_ret = 1;
- GNUNET_free (binary);
- return;
- }
- GNUNET_free (binary);
+ GNUNET_OS_check_helper_binary(binary,
+ GNUNET_YES,
+ NULL)) // TODO: once we have a windows-testcase, add test parameters here
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
+ _("`%s' is not SUID or the path is invalid, "
+ "will not run DNS interceptor\n"),
+ binary);
+ global_ret = 1;
+ GNUNET_free(binary);
+ return;
+ }
+ GNUNET_free(binary);
- helper_argv[0] = GNUNET_strdup ("gnunet-dns");
+ helper_argv[0] = GNUNET_strdup("gnunet-dns");
if (GNUNET_SYSERR ==
- GNUNET_CONFIGURATION_get_value_string (cfg,
- "dns",
- "IFNAME",
- &ifc_name))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "No entry 'IFNAME' in configuration!\n");
- GNUNET_free (binary);
- GNUNET_SCHEDULER_shutdown ();
- return;
- }
+ GNUNET_CONFIGURATION_get_value_string(cfg,
+ "dns",
+ "IFNAME",
+ &ifc_name))
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ "No entry 'IFNAME' in configuration!\n");
+ GNUNET_free(binary);
+ GNUNET_SCHEDULER_shutdown();
+ return;
+ }
helper_argv[1] = ifc_name;
- if ( (GNUNET_SYSERR ==
- GNUNET_CONFIGURATION_get_value_string (cfg,
- "dns",
- "IPV6ADDR",
- &ipv6addr)) )
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "No entry 'IPV6ADDR' in configuration!\n");
- GNUNET_free (binary);
- GNUNET_SCHEDULER_shutdown ();
- return;
- }
+ if ((GNUNET_SYSERR ==
+ GNUNET_CONFIGURATION_get_value_string(cfg,
+ "dns",
+ "IPV6ADDR",
+ &ipv6addr)))
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ "No entry 'IPV6ADDR' in configuration!\n");
+ GNUNET_free(binary);
+ GNUNET_SCHEDULER_shutdown();
+ return;
+ }
helper_argv[2] = ipv6addr;
if (GNUNET_SYSERR ==
- GNUNET_CONFIGURATION_get_value_string (cfg,
- "dns",
- "IPV6PREFIX",
- &ipv6prefix))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "No entry 'IPV6PREFIX' in configuration!\n");
- GNUNET_free (binary);
- GNUNET_SCHEDULER_shutdown ();
- return;
- }
+ GNUNET_CONFIGURATION_get_value_string(cfg,
+ "dns",
+ "IPV6PREFIX",
+ &ipv6prefix))
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ "No entry 'IPV6PREFIX' in configuration!\n");
+ GNUNET_free(binary);
+ GNUNET_SCHEDULER_shutdown();
+ return;
+ }
helper_argv[3] = ipv6prefix;
if (GNUNET_SYSERR ==
- GNUNET_CONFIGURATION_get_value_string (cfg,
- "dns",
- "IPV4ADDR",
- &ipv4addr))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "No entry 'IPV4ADDR' in configuration!\n");
- GNUNET_free (binary);
- GNUNET_SCHEDULER_shutdown ();
- return;
- }
+ GNUNET_CONFIGURATION_get_value_string(cfg,
+ "dns",
+ "IPV4ADDR",
+ &ipv4addr))
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ "No entry 'IPV4ADDR' in configuration!\n");
+ GNUNET_free(binary);
+ GNUNET_SCHEDULER_shutdown();
+ return;
+ }
helper_argv[4] = ipv4addr;
if (GNUNET_SYSERR ==
- GNUNET_CONFIGURATION_get_value_string (cfg, "dns", "IPV4MASK",
- &ipv4mask))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "No entry 'IPV4MASK' in configuration!\n");
- GNUNET_free (binary);
- GNUNET_SCHEDULER_shutdown ();
- return;
- }
+ GNUNET_CONFIGURATION_get_value_string(cfg, "dns", "IPV4MASK",
+ &ipv4mask))
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ "No entry 'IPV4MASK' in configuration!\n");
+ GNUNET_free(binary);
+ GNUNET_SCHEDULER_shutdown();
+ return;
+ }
helper_argv[5] = ipv4mask;
- nortsetup = GNUNET_CONFIGURATION_get_value_yesno (cfg, "dns",
- "SKIP_ROUTING_SETUP");
+ nortsetup = GNUNET_CONFIGURATION_get_value_yesno(cfg, "dns",
+ "SKIP_ROUTING_SETUP");
if (GNUNET_YES == nortsetup)
helper_argv[6] = GNUNET_strdup("1");
else
helper_argv[6] = GNUNET_strdup("0");
helper_argv[7] = NULL;
- hijacker = GNUNET_HELPER_start (GNUNET_NO,
- binary,
- helper_argv,
- &process_helper_messages,
- NULL, NULL);
- GNUNET_free (binary);
+ hijacker = GNUNET_HELPER_start(GNUNET_NO,
+ binary,
+ helper_argv,
+ &process_helper_messages,
+ NULL, NULL);
+ GNUNET_free(binary);
}
* Define "main" method using service macro.
*/
GNUNET_SERVICE_MAIN
-("dns",
- GNUNET_SERVICE_OPTION_NONE,
- &run,
- &client_connect_cb,
- &client_disconnect_cb,
- NULL,
- GNUNET_MQ_hd_fixed_size (client_init,
- GNUNET_MESSAGE_TYPE_DNS_CLIENT_INIT,
- struct GNUNET_DNS_Register,
- NULL),
- GNUNET_MQ_hd_var_size (client_response,
+ ("dns",
+ GNUNET_SERVICE_OPTION_NONE,
+ &run,
+ &client_connect_cb,
+ &client_disconnect_cb,
+ NULL,
+ GNUNET_MQ_hd_fixed_size(client_init,
+ GNUNET_MESSAGE_TYPE_DNS_CLIENT_INIT,
+ struct GNUNET_DNS_Register,
+ NULL),
+ GNUNET_MQ_hd_var_size(client_response,
GNUNET_MESSAGE_TYPE_DNS_CLIENT_RESPONSE,
struct GNUNET_DNS_Response,
NULL),
- GNUNET_MQ_handler_end ());
+ GNUNET_MQ_handler_end());
/* FIXME: this might need a port on systems without 'getresgid' */
* Enable use of SGID capabilities on POSIX
*/
void __attribute__ ((constructor))
-GNUNET_DNS_init ()
+GNUNET_DNS_init()
{
gid_t rgid;
gid_t egid;
gid_t sgid;
- if (-1 == getresgid (&rgid,
- &egid,
- &sgid))
- {
- fprintf (stderr,
- "getresgid failed: %s\n",
- strerror (errno));
- }
+ if (-1 == getresgid(&rgid,
+ &egid,
+ &sgid))
+ {
+ fprintf(stderr,
+ "getresgid failed: %s\n",
+ strerror(errno));
+ }
else if (sgid != rgid)
- {
- if (-1 == setregid (sgid,
- sgid))
- fprintf (stderr,
- "setregid failed: %s\n",
- strerror (errno));
- }
+ {
+ if (-1 == setregid(sgid,
+ sgid))
+ fprintf(stderr,
+ "setregid failed: %s\n",
+ strerror(errno));
+ }
}
#endif
projects / oweals / gnunet.git / blobdiff