From d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb Mon Sep 17 00:00:00 2001 From: ng0 Date: Sun, 8 Sep 2019 12:33:09 +0000 Subject: uncrustify as demanded. --- src/gns/gnunet-dns2gns.c | 791 ++++++++++++++++++++++++----------------------- 1 file changed, 397 insertions(+), 394 deletions(-) (limited to 'src/gns/gnunet-dns2gns.c') diff --git a/src/gns/gnunet-dns2gns.c b/src/gns/gnunet-dns2gns.c index d2eabf02c..4058aba99 100644 --- a/src/gns/gnunet-dns2gns.c +++ b/src/gns/gnunet-dns2gns.c @@ -11,12 +11,12 @@ WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details. - + You should have received a copy of the GNU Affero General Public License along with this program. If not, see . SPDX-License-Identifier: AGPL3.0-or-later -*/ + */ /** * @file gnunet-dns2gns.c * @brief DNS server that translates DNS requests to GNS @@ -37,8 +37,7 @@ /** * Data kept per request. */ -struct Request -{ +struct Request { /** * Socket to use for sending the reply. */ @@ -156,39 +155,39 @@ static const struct GNUNET_CONFIGURATION_Handle *cfg; * @param cls unused */ static void -do_shutdown (void *cls) +do_shutdown(void *cls) { - (void) cls; + (void)cls; if (NULL != t4) - { - GNUNET_SCHEDULER_cancel (t4); - t4 = NULL; - } + { + GNUNET_SCHEDULER_cancel(t4); + t4 = NULL; + } if (NULL != t6) - { - GNUNET_SCHEDULER_cancel (t6); - t6 = NULL; - } + { + GNUNET_SCHEDULER_cancel(t6); + t6 = NULL; + } if (NULL != listen_socket4) - { - GNUNET_NETWORK_socket_close (listen_socket4); - listen_socket4 = NULL; - } + { + GNUNET_NETWORK_socket_close(listen_socket4); + listen_socket4 = NULL; + } if (NULL != listen_socket6) - { - GNUNET_NETWORK_socket_close (listen_socket6); - listen_socket6 = NULL; - } + { + GNUNET_NETWORK_socket_close(listen_socket6); + listen_socket6 = NULL; + } if (NULL != gns) - { - GNUNET_GNS_disconnect (gns); - gns = NULL; - } + { + GNUNET_GNS_disconnect(gns); + gns = NULL; + } if (NULL != dns_stub) - { - GNUNET_DNSSTUB_stop (dns_stub); - dns_stub = NULL; - } + { + GNUNET_DNSSTUB_stop(dns_stub); + dns_stub = NULL; + } } @@ -198,38 +197,38 @@ do_shutdown (void *cls) * @param request context for the request. */ static void -send_response (struct Request *request) +send_response(struct Request *request) { char *buf; size_t size; ssize_t sret; if (GNUNET_SYSERR == - GNUNET_DNSPARSER_pack (request->packet, - UINT16_MAX /* is this not too much? */, - &buf, - &size)) + GNUNET_DNSPARSER_pack(request->packet, + UINT16_MAX /* is this not too much? */, + &buf, + &size)) { - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, - _("Failed to pack DNS response into UDP packet!\n")); + GNUNET_log(GNUNET_ERROR_TYPE_WARNING, + _("Failed to pack DNS response into UDP packet!\n")); } else { - sret = GNUNET_NETWORK_socket_sendto (request->lsock, - buf, - size, - request->addr, - request->addr_len); - if ( (sret < 0) || - (size != (size_t) sret) ) - GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, - "sendto"); - GNUNET_free (buf); + sret = GNUNET_NETWORK_socket_sendto(request->lsock, + buf, + size, + request->addr, + request->addr_len); + if ((sret < 0) || + (size != (size_t)sret)) + GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, + "sendto"); + GNUNET_free(buf); } - GNUNET_SCHEDULER_cancel (request->timeout_task); - GNUNET_DNSPARSER_free_packet (request->packet); - GNUNET_free (request->udp_msg); - GNUNET_free (request); + GNUNET_SCHEDULER_cancel(request->timeout_task); + GNUNET_DNSPARSER_free_packet(request->packet); + GNUNET_free(request->udp_msg); + GNUNET_free(request); } @@ -239,18 +238,18 @@ send_response (struct Request *request) * @param cls `struct Request *` of the request to clean up */ static void -do_timeout (void *cls) +do_timeout(void *cls) { struct Request *request = cls; if (NULL != request->packet) - GNUNET_DNSPARSER_free_packet (request->packet); + GNUNET_DNSPARSER_free_packet(request->packet); if (NULL != request->lookup) - GNUNET_GNS_lookup_with_tld_cancel (request->lookup); + GNUNET_GNS_lookup_with_tld_cancel(request->lookup); if (NULL != request->dns_lookup) - GNUNET_DNSSTUB_resolve_cancel (request->dns_lookup); - GNUNET_free (request->udp_msg); - GNUNET_free (request); + GNUNET_DNSSTUB_resolve_cancel(request->dns_lookup); + GNUNET_free(request->udp_msg); + GNUNET_free(request); } @@ -262,28 +261,28 @@ do_timeout (void *cls) * @param r size of the DNS payload */ static void -dns_result_processor (void *cls, - const struct GNUNET_TUN_DnsHeader *dns, - size_t r) +dns_result_processor(void *cls, + const struct GNUNET_TUN_DnsHeader *dns, + size_t r) { struct Request *request = cls; if (NULL == dns) - { - /* DNSSTUB gave up, so we trigger timeout early */ - GNUNET_SCHEDULER_cancel (request->timeout_task); - do_timeout (request); - return; - } + { + /* DNSSTUB gave up, so we trigger timeout early */ + GNUNET_SCHEDULER_cancel(request->timeout_task); + do_timeout(request); + return; + } if (request->original_request_id != dns->id) - { - /* for a another query, ignore */ - return; - } - request->packet = GNUNET_DNSPARSER_parse ((char*)dns, - r); - GNUNET_DNSSTUB_resolve_cancel (request->dns_lookup); - send_response (request); + { + /* for a another query, ignore */ + return; + } + request->packet = GNUNET_DNSPARSER_parse((char*)dns, + r); + GNUNET_DNSSTUB_resolve_cancel(request->dns_lookup); + send_response(request); } @@ -296,10 +295,10 @@ dns_result_processor (void *cls, * @param rd the records in reply */ static void -result_processor (void *cls, - int was_gns, - uint32_t rd_count, - const struct GNUNET_GNSRECORD_Data *rd) +result_processor(void *cls, + int was_gns, + uint32_t rd_count, + const struct GNUNET_GNSRECORD_Data *rd) { struct Request *request = cls; struct GNUNET_DNSPARSER_Packet *packet; @@ -307,22 +306,22 @@ result_processor (void *cls, request->lookup = NULL; if (GNUNET_NO == was_gns) - { - /* TLD not configured for GNS, fall back to DNS */ - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Using DNS resolver IP `%s' to resolve `%s'\n", - dns_ip, - request->packet->queries[0].name); - request->original_request_id = request->packet->id; - GNUNET_DNSPARSER_free_packet (request->packet); - request->packet = NULL; - request->dns_lookup = GNUNET_DNSSTUB_resolve (dns_stub, - request->udp_msg, - request->udp_msg_size, - &dns_result_processor, - request); - return; - } + { + /* TLD not configured for GNS, fall back to DNS */ + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Using DNS resolver IP `%s' to resolve `%s'\n", + dns_ip, + request->packet->queries[0].name); + request->original_request_id = request->packet->id; + GNUNET_DNSPARSER_free_packet(request->packet); + request->packet = NULL; + request->dns_lookup = GNUNET_DNSSTUB_resolve(dns_stub, + request->udp_msg, + request->udp_msg_size, + &dns_result_processor, + request); + return; + } packet = request->packet; packet->flags.query_or_response = 1; packet->flags.return_code = GNUNET_TUN_DNS_RETURN_CODE_NO_ERROR; @@ -333,59 +332,62 @@ result_processor (void *cls, packet->flags.message_truncated = 0; packet->flags.authoritative_answer = 0; //packet->flags.opcode = GNUNET_TUN_DNS_OPCODE_STATUS; // ??? - for (uint32_t i=0;iqueries[0].name); - rec.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET; - rec.type = GNUNET_DNSPARSER_TYPE_A; - rec.data.raw.data = GNUNET_new (struct in_addr); - GNUNET_memcpy (rec.data.raw.data, - rd[i].data, - rd[i].data_size); - rec.data.raw.data_len = sizeof (struct in_addr); - GNUNET_array_append (packet->answers, - packet->num_answers, - rec); - break; - case GNUNET_DNSPARSER_TYPE_AAAA: - GNUNET_assert (sizeof (struct in6_addr) == rd[i].data_size); - rec.name = GNUNET_strdup (packet->queries[0].name); - rec.data.raw.data = GNUNET_new (struct in6_addr); - rec.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET; - rec.type = GNUNET_DNSPARSER_TYPE_AAAA; - GNUNET_memcpy (rec.data.raw.data, - rd[i].data, - rd[i].data_size); - rec.data.raw.data_len = sizeof (struct in6_addr); - GNUNET_array_append (packet->answers, - packet->num_answers, - rec); - break; - case GNUNET_DNSPARSER_TYPE_CNAME: - rec.name = GNUNET_strdup (packet->queries[0].name); - rec.data.hostname = GNUNET_strdup (rd[i].data); - rec.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET; - rec.type = GNUNET_DNSPARSER_TYPE_CNAME; - GNUNET_memcpy (rec.data.hostname, - rd[i].data, - rd[i].data_size); - GNUNET_array_append (packet->answers, - packet->num_answers, - rec); - break; - default: - /* skip */ - break; - } + { + case GNUNET_DNSPARSER_TYPE_A: + GNUNET_assert(sizeof(struct in_addr) == rd[i].data_size); + rec.name = GNUNET_strdup(packet->queries[0].name); + rec.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET; + rec.type = GNUNET_DNSPARSER_TYPE_A; + rec.data.raw.data = GNUNET_new(struct in_addr); + GNUNET_memcpy(rec.data.raw.data, + rd[i].data, + rd[i].data_size); + rec.data.raw.data_len = sizeof(struct in_addr); + GNUNET_array_append(packet->answers, + packet->num_answers, + rec); + break; + + case GNUNET_DNSPARSER_TYPE_AAAA: + GNUNET_assert(sizeof(struct in6_addr) == rd[i].data_size); + rec.name = GNUNET_strdup(packet->queries[0].name); + rec.data.raw.data = GNUNET_new(struct in6_addr); + rec.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET; + rec.type = GNUNET_DNSPARSER_TYPE_AAAA; + GNUNET_memcpy(rec.data.raw.data, + rd[i].data, + rd[i].data_size); + rec.data.raw.data_len = sizeof(struct in6_addr); + GNUNET_array_append(packet->answers, + packet->num_answers, + rec); + break; + + case GNUNET_DNSPARSER_TYPE_CNAME: + rec.name = GNUNET_strdup(packet->queries[0].name); + rec.data.hostname = GNUNET_strdup(rd[i].data); + rec.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET; + rec.type = GNUNET_DNSPARSER_TYPE_CNAME; + GNUNET_memcpy(rec.data.hostname, + rd[i].data, + rd[i].data_size); + GNUNET_array_append(packet->answers, + packet->num_answers, + rec); + break; + + default: + /* skip */ + break; + } } - send_response (request); + send_response(request); } @@ -399,73 +401,73 @@ result_processor (void *cls, * @param udp_msg_size number of bytes in @a udp_msg */ static void -handle_request (struct GNUNET_NETWORK_Handle *lsock, - const void *addr, - size_t addr_len, - const char *udp_msg, - size_t udp_msg_size) +handle_request(struct GNUNET_NETWORK_Handle *lsock, + const void *addr, + size_t addr_len, + const char *udp_msg, + size_t udp_msg_size) { struct Request *request; struct GNUNET_DNSPARSER_Packet *packet; - packet = GNUNET_DNSPARSER_parse (udp_msg, - udp_msg_size); + packet = GNUNET_DNSPARSER_parse(udp_msg, + udp_msg_size); if (NULL == packet) - { - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, - _("Cannot parse DNS request from %s\n"), - GNUNET_a2s (addr, addr_len)); - return; - } - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Received request for `%s' with flags %u, #answers %d, #auth %d, #additional %d\n", - packet->queries[0].name, - (unsigned int) packet->flags.query_or_response, - (int) packet->num_answers, - (int) packet->num_authority_records, - (int) packet->num_additional_records); - if ( (0 != packet->flags.query_or_response) || - (0 != packet->num_answers) || - (0 != packet->num_authority_records)) - { - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, - _("Received malformed DNS request from %s\n"), - GNUNET_a2s (addr, addr_len)); - GNUNET_DNSPARSER_free_packet (packet); - return; - } - if ( (1 != packet->num_queries) ) - { - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, - _("Received unsupported DNS request from %s\n"), - GNUNET_a2s (addr, - addr_len)); - GNUNET_DNSPARSER_free_packet (packet); - return; - } - request = GNUNET_malloc (sizeof (struct Request) + addr_len); + { + GNUNET_log(GNUNET_ERROR_TYPE_WARNING, + _("Cannot parse DNS request from %s\n"), + GNUNET_a2s(addr, addr_len)); + return; + } + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Received request for `%s' with flags %u, #answers %d, #auth %d, #additional %d\n", + packet->queries[0].name, + (unsigned int)packet->flags.query_or_response, + (int)packet->num_answers, + (int)packet->num_authority_records, + (int)packet->num_additional_records); + if ((0 != packet->flags.query_or_response) || + (0 != packet->num_answers) || + (0 != packet->num_authority_records)) + { + GNUNET_log(GNUNET_ERROR_TYPE_WARNING, + _("Received malformed DNS request from %s\n"), + GNUNET_a2s(addr, addr_len)); + GNUNET_DNSPARSER_free_packet(packet); + return; + } + if ((1 != packet->num_queries)) + { + GNUNET_log(GNUNET_ERROR_TYPE_WARNING, + _("Received unsupported DNS request from %s\n"), + GNUNET_a2s(addr, + addr_len)); + GNUNET_DNSPARSER_free_packet(packet); + return; + } + request = GNUNET_malloc(sizeof(struct Request) + addr_len); request->lsock = lsock; request->packet = packet; request->addr = &request[1]; request->addr_len = addr_len; - GNUNET_memcpy (&request[1], - addr, - addr_len); + GNUNET_memcpy(&request[1], + addr, + addr_len); request->udp_msg_size = udp_msg_size; - request->udp_msg = GNUNET_memdup (udp_msg, - udp_msg_size); - request->timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, - &do_timeout, - request); - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Calling GNS on `%s'\n", - packet->queries[0].name); - request->lookup = GNUNET_GNS_lookup_with_tld (gns, - packet->queries[0].name, - packet->queries[0].type, - GNUNET_NO, - &result_processor, - request); + request->udp_msg = GNUNET_memdup(udp_msg, + udp_msg_size); + request->timeout_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT, + &do_timeout, + request); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Calling GNS on `%s'\n", + packet->queries[0].name); + request->lookup = GNUNET_GNS_lookup_with_tld(gns, + packet->queries[0].name, + packet->queries[0].type, + GNUNET_NO, + &result_processor, + request); } @@ -475,49 +477,49 @@ handle_request (struct GNUNET_NETWORK_Handle *lsock, * @param cls the 'listen_socket4' */ static void -read_dns4 (void *cls) +read_dns4(void *cls) { struct sockaddr_in v4; socklen_t addrlen; ssize_t size; const struct GNUNET_SCHEDULER_TaskContext *tc; - GNUNET_assert (listen_socket4 == cls); - t4 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, - listen_socket4, - &read_dns4, - listen_socket4); - tc = GNUNET_SCHEDULER_get_task_context (); + GNUNET_assert(listen_socket4 == cls); + t4 = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, + listen_socket4, + &read_dns4, + listen_socket4); + tc = GNUNET_SCHEDULER_get_task_context(); if (0 == (GNUNET_SCHEDULER_REASON_READ_READY & tc->reason)) return; /* shutdown? */ - size = GNUNET_NETWORK_socket_recvfrom_amount (listen_socket4); + size = GNUNET_NETWORK_socket_recvfrom_amount(listen_socket4); if (0 > size) { - GNUNET_break (0); + GNUNET_break(0); return; /* read error!? */ } { char buf[size + 1]; ssize_t sret; - addrlen = sizeof (v4); - sret = GNUNET_NETWORK_socket_recvfrom (listen_socket4, - buf, - size + 1, - (struct sockaddr *) &v4, - &addrlen); + addrlen = sizeof(v4); + sret = GNUNET_NETWORK_socket_recvfrom(listen_socket4, + buf, + size + 1, + (struct sockaddr *)&v4, + &addrlen); if (0 > sret) - { - GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, - "recvfrom"); - return; - } - GNUNET_break (size == sret); - handle_request (listen_socket4, - &v4, - addrlen, - buf, - size); + { + GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, + "recvfrom"); + return; + } + GNUNET_break(size == sret); + handle_request(listen_socket4, + &v4, + addrlen, + buf, + size); } } @@ -528,49 +530,49 @@ read_dns4 (void *cls) * @param cls the 'listen_socket6' */ static void -read_dns6 (void *cls) +read_dns6(void *cls) { struct sockaddr_in6 v6; socklen_t addrlen; ssize_t size; const struct GNUNET_SCHEDULER_TaskContext *tc; - GNUNET_assert (listen_socket6 == cls); - t6 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, - listen_socket6, - &read_dns6, - listen_socket6); - tc = GNUNET_SCHEDULER_get_task_context (); + GNUNET_assert(listen_socket6 == cls); + t6 = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, + listen_socket6, + &read_dns6, + listen_socket6); + tc = GNUNET_SCHEDULER_get_task_context(); if (0 == (GNUNET_SCHEDULER_REASON_READ_READY & tc->reason)) return; /* shutdown? */ - size = GNUNET_NETWORK_socket_recvfrom_amount (listen_socket6); + size = GNUNET_NETWORK_socket_recvfrom_amount(listen_socket6); if (0 > size) { - GNUNET_break (0); + GNUNET_break(0); return; /* read error!? */ } { char buf[size]; ssize_t sret; - addrlen = sizeof (v6); - sret = GNUNET_NETWORK_socket_recvfrom (listen_socket6, - buf, - size, - (struct sockaddr *) &v6, - &addrlen); + addrlen = sizeof(v6); + sret = GNUNET_NETWORK_socket_recvfrom(listen_socket6, + buf, + size, + (struct sockaddr *)&v6, + &addrlen); if (0 > sret) - { - GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, - "recvfrom"); - return; - } - GNUNET_break (size == sret); - handle_request (listen_socket6, - &v6, - addrlen, - buf, - size); + { + GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, + "recvfrom"); + return; + } + GNUNET_break(size == sret); + handle_request(listen_socket6, + &v6, + addrlen, + buf, + size); } } @@ -584,149 +586,150 @@ read_dns6 (void *cls) * @param c configuration */ static void -run (void *cls, - char *const *args, - const char *cfgfile, - const struct GNUNET_CONFIGURATION_Handle *c) +run(void *cls, + char *const *args, + const char *cfgfile, + const struct GNUNET_CONFIGURATION_Handle *c) { char *addr_str; - (void) cls; - (void) args; - (void) cfgfile; + + (void)cls; + (void)args; + (void)cfgfile; cfg = c; if (NULL == dns_ip) - { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - _("No DNS server specified!\n")); - return; - } - GNUNET_SCHEDULER_add_shutdown (&do_shutdown, - NULL); - if (NULL == (gns = GNUNET_GNS_connect (cfg))) + { + GNUNET_log(GNUNET_ERROR_TYPE_ERROR, + _("No DNS server specified!\n")); + return; + } + GNUNET_SCHEDULER_add_shutdown(&do_shutdown, + NULL); + if (NULL == (gns = GNUNET_GNS_connect(cfg))) return; - GNUNET_assert (NULL != (dns_stub = GNUNET_DNSSTUB_start (128))); + GNUNET_assert(NULL != (dns_stub = GNUNET_DNSSTUB_start(128))); if (GNUNET_OK != - GNUNET_DNSSTUB_add_dns_ip (dns_stub, - dns_ip)) - { - GNUNET_DNSSTUB_stop (dns_stub); - GNUNET_GNS_disconnect (gns); - gns = NULL; - return; - } + GNUNET_DNSSTUB_add_dns_ip(dns_stub, + dns_ip)) + { + GNUNET_DNSSTUB_stop(dns_stub); + GNUNET_GNS_disconnect(gns); + gns = NULL; + return; + } /* Get address to bind to */ - if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (c, "dns2gns", - "BIND_TO", - &addr_str)) - { - //No address specified - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "Don't know what to bind to...\n"); - GNUNET_free (addr_str); - GNUNET_SCHEDULER_shutdown (); - return; - } - if (1 != inet_pton (AF_INET, addr_str, &address)) - { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "Unable to parse address %s\n", - addr_str); - GNUNET_free (addr_str); - GNUNET_SCHEDULER_shutdown (); - return; - } - GNUNET_free (addr_str); + if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(c, "dns2gns", + "BIND_TO", + &addr_str)) + { + //No address specified + GNUNET_log(GNUNET_ERROR_TYPE_ERROR, + "Don't know what to bind to...\n"); + GNUNET_free(addr_str); + GNUNET_SCHEDULER_shutdown(); + return; + } + if (1 != inet_pton(AF_INET, addr_str, &address)) + { + GNUNET_log(GNUNET_ERROR_TYPE_ERROR, + "Unable to parse address %s\n", + addr_str); + GNUNET_free(addr_str); + GNUNET_SCHEDULER_shutdown(); + return; + } + GNUNET_free(addr_str); /* Get address to bind to */ - if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (c, "dns2gns", - "BIND_TO6", - &addr_str)) - { - //No address specified - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "Don't know what to bind6 to...\n"); - GNUNET_free (addr_str); - GNUNET_SCHEDULER_shutdown (); - return; - } - if (1 != inet_pton (AF_INET6, addr_str, &address6)) - { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - "Unable to parse IPv6 address %s\n", - addr_str); - GNUNET_free (addr_str); - GNUNET_SCHEDULER_shutdown (); - return; - } - GNUNET_free (addr_str); + if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(c, "dns2gns", + "BIND_TO6", + &addr_str)) + { + //No address specified + GNUNET_log(GNUNET_ERROR_TYPE_ERROR, + "Don't know what to bind6 to...\n"); + GNUNET_free(addr_str); + GNUNET_SCHEDULER_shutdown(); + return; + } + if (1 != inet_pton(AF_INET6, addr_str, &address6)) + { + GNUNET_log(GNUNET_ERROR_TYPE_ERROR, + "Unable to parse IPv6 address %s\n", + addr_str); + GNUNET_free(addr_str); + GNUNET_SCHEDULER_shutdown(); + return; + } + GNUNET_free(addr_str); - listen_socket4 = GNUNET_NETWORK_socket_create (PF_INET, - SOCK_DGRAM, - IPPROTO_UDP); + listen_socket4 = GNUNET_NETWORK_socket_create(PF_INET, + SOCK_DGRAM, + IPPROTO_UDP); if (NULL != listen_socket4) - { - struct sockaddr_in v4; + { + struct sockaddr_in v4; - memset (&v4, 0, sizeof (v4)); - v4.sin_family = AF_INET; - v4.sin_addr.s_addr = address; + memset(&v4, 0, sizeof(v4)); + v4.sin_family = AF_INET; + v4.sin_addr.s_addr = address; #if HAVE_SOCKADDR_IN_SIN_LEN - v4.sin_len = sizeof (v4); + v4.sin_len = sizeof(v4); #endif - v4.sin_port = htons (listen_port); - if (GNUNET_OK != - GNUNET_NETWORK_socket_bind (listen_socket4, - (struct sockaddr *) &v4, - sizeof (v4))) - { - GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind"); - GNUNET_NETWORK_socket_close (listen_socket4); - listen_socket4 = NULL; + v4.sin_port = htons(listen_port); + if (GNUNET_OK != + GNUNET_NETWORK_socket_bind(listen_socket4, + (struct sockaddr *)&v4, + sizeof(v4))) + { + GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "bind"); + GNUNET_NETWORK_socket_close(listen_socket4); + listen_socket4 = NULL; + } } - } - listen_socket6 = GNUNET_NETWORK_socket_create (PF_INET6, - SOCK_DGRAM, - IPPROTO_UDP); + listen_socket6 = GNUNET_NETWORK_socket_create(PF_INET6, + SOCK_DGRAM, + IPPROTO_UDP); if (NULL != listen_socket6) - { - struct sockaddr_in6 v6; + { + struct sockaddr_in6 v6; - memset (&v6, 0, sizeof (v6)); - v6.sin6_family = AF_INET6; - v6.sin6_addr = address6; + memset(&v6, 0, sizeof(v6)); + v6.sin6_family = AF_INET6; + v6.sin6_addr = address6; #if HAVE_SOCKADDR_IN_SIN_LEN - v6.sin6_len = sizeof (v6); + v6.sin6_len = sizeof(v6); #endif - v6.sin6_port = htons (listen_port); - if (GNUNET_OK != - GNUNET_NETWORK_socket_bind (listen_socket6, - (struct sockaddr *) &v6, - sizeof (v6))) + v6.sin6_port = htons(listen_port); + if (GNUNET_OK != + GNUNET_NETWORK_socket_bind(listen_socket6, + (struct sockaddr *)&v6, + sizeof(v6))) + { + GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "bind"); + GNUNET_NETWORK_socket_close(listen_socket6); + listen_socket6 = NULL; + } + } + if ((NULL == listen_socket4) && + (NULL == listen_socket6)) { - GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind"); - GNUNET_NETWORK_socket_close (listen_socket6); - listen_socket6 = NULL; + GNUNET_GNS_disconnect(gns); + gns = NULL; + GNUNET_DNSSTUB_stop(dns_stub); + dns_stub = NULL; + return; } - } - if ( (NULL == listen_socket4) && - (NULL == listen_socket6) ) - { - GNUNET_GNS_disconnect (gns); - gns = NULL; - GNUNET_DNSSTUB_stop (dns_stub); - dns_stub = NULL; - return; - } if (NULL != listen_socket4) - t4 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, - listen_socket4, - &read_dns4, - listen_socket4); + t4 = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, + listen_socket4, + &read_dns4, + listen_socket4); if (NULL != listen_socket6) - t6 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, - listen_socket6, - &read_dns6, - listen_socket6); + t6 = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, + listen_socket6, + &read_dns6, + listen_socket6); } @@ -738,39 +741,39 @@ run (void *cls, * @return 0 ok, 1 on error */ int -main (int argc, - char *const *argv) +main(int argc, + char *const *argv) { struct GNUNET_GETOPT_CommandLineOption options[] = { - GNUNET_GETOPT_option_string ('d', - "dns", - "IP", - gettext_noop ("IP of recursive DNS resolver to use (required)"), - &dns_ip), - GNUNET_GETOPT_option_uint ('p', - "port", - "UDPPORT", - gettext_noop ("UDP port to listen on for inbound DNS requests; default: 2853"), - &listen_port), + GNUNET_GETOPT_option_string('d', + "dns", + "IP", + gettext_noop("IP of recursive DNS resolver to use (required)"), + &dns_ip), + GNUNET_GETOPT_option_uint('p', + "port", + "UDPPORT", + gettext_noop("UDP port to listen on for inbound DNS requests; default: 2853"), + &listen_port), GNUNET_GETOPT_OPTION_END }; int ret; if (GNUNET_OK != - GNUNET_STRINGS_get_utf8_args (argc, argv, - &argc, &argv)) + GNUNET_STRINGS_get_utf8_args(argc, argv, + &argc, &argv)) return 2; - GNUNET_log_setup ("gnunet-dns2gns", - "WARNING", - NULL); + GNUNET_log_setup("gnunet-dns2gns", + "WARNING", + NULL); ret = - (GNUNET_OK == - GNUNET_PROGRAM_run (argc, argv, - "gnunet-dns2gns", - _("GNUnet DNS-to-GNS proxy (a DNS server)"), - options, - &run, NULL)) ? 0 : 1; - GNUNET_free ((void*) argv); + (GNUNET_OK == + GNUNET_PROGRAM_run(argc, argv, + "gnunet-dns2gns", + _("GNUnet DNS-to-GNS proxy (a DNS server)"), + options, + &run, NULL)) ? 0 : 1; + GNUNET_free((void*)argv); return ret; } -- cgit v1.2.3