aboutsummaryrefslogtreecommitdiff
path: root/src/gns/gnunet-dns2gns.c
diff options
context:
space:
mode:
authorng0 <ng0@n0.is>2019-09-08 12:33:09 +0000
committerng0 <ng0@n0.is>2019-09-08 12:33:09 +0000
commitd41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb (patch)
tree9efd18ea7d425652085ed0bd5e8e45604bc5f6b9 /src/gns/gnunet-dns2gns.c
parenta0fce305c565c0937d917a92712f15e9c5736260 (diff)
downloadgnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.tar.gz
gnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.zip
uncrustify as demanded.
Diffstat (limited to 'src/gns/gnunet-dns2gns.c')
-rw-r--r--src/gns/gnunet-dns2gns.c791
1 files changed, 397 insertions, 394 deletions
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 @@
11 WITHOUT ANY WARRANTY; without even the implied warranty of 11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Affero General Public License for more details. 13 Affero General Public License for more details.
14 14
15 You should have received a copy of the GNU Affero General Public License 15 You should have received a copy of the GNU Affero General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>. 16 along with this program. If not, see <http://www.gnu.org/licenses/>.
17 17
18 SPDX-License-Identifier: AGPL3.0-or-later 18 SPDX-License-Identifier: AGPL3.0-or-later
19*/ 19 */
20/** 20/**
21 * @file gnunet-dns2gns.c 21 * @file gnunet-dns2gns.c
22 * @brief DNS server that translates DNS requests to GNS 22 * @brief DNS server that translates DNS requests to GNS
@@ -37,8 +37,7 @@
37/** 37/**
38 * Data kept per request. 38 * Data kept per request.
39 */ 39 */
40struct Request 40struct Request {
41{
42 /** 41 /**
43 * Socket to use for sending the reply. 42 * Socket to use for sending the reply.
44 */ 43 */
@@ -156,39 +155,39 @@ static const struct GNUNET_CONFIGURATION_Handle *cfg;
156 * @param cls unused 155 * @param cls unused
157 */ 156 */
158static void 157static void
159do_shutdown (void *cls) 158do_shutdown(void *cls)
160{ 159{
161 (void) cls; 160 (void)cls;
162 if (NULL != t4) 161 if (NULL != t4)
163 { 162 {
164 GNUNET_SCHEDULER_cancel (t4); 163 GNUNET_SCHEDULER_cancel(t4);
165 t4 = NULL; 164 t4 = NULL;
166 } 165 }
167 if (NULL != t6) 166 if (NULL != t6)
168 { 167 {
169 GNUNET_SCHEDULER_cancel (t6); 168 GNUNET_SCHEDULER_cancel(t6);
170 t6 = NULL; 169 t6 = NULL;
171 } 170 }
172 if (NULL != listen_socket4) 171 if (NULL != listen_socket4)
173 { 172 {
174 GNUNET_NETWORK_socket_close (listen_socket4); 173 GNUNET_NETWORK_socket_close(listen_socket4);
175 listen_socket4 = NULL; 174 listen_socket4 = NULL;
176 } 175 }
177 if (NULL != listen_socket6) 176 if (NULL != listen_socket6)
178 { 177 {
179 GNUNET_NETWORK_socket_close (listen_socket6); 178 GNUNET_NETWORK_socket_close(listen_socket6);
180 listen_socket6 = NULL; 179 listen_socket6 = NULL;
181 } 180 }
182 if (NULL != gns) 181 if (NULL != gns)
183 { 182 {
184 GNUNET_GNS_disconnect (gns); 183 GNUNET_GNS_disconnect(gns);
185 gns = NULL; 184 gns = NULL;
186 } 185 }
187 if (NULL != dns_stub) 186 if (NULL != dns_stub)
188 { 187 {
189 GNUNET_DNSSTUB_stop (dns_stub); 188 GNUNET_DNSSTUB_stop(dns_stub);
190 dns_stub = NULL; 189 dns_stub = NULL;
191 } 190 }
192} 191}
193 192
194 193
@@ -198,38 +197,38 @@ do_shutdown (void *cls)
198 * @param request context for the request. 197 * @param request context for the request.
199 */ 198 */
200static void 199static void
201send_response (struct Request *request) 200send_response(struct Request *request)
202{ 201{
203 char *buf; 202 char *buf;
204 size_t size; 203 size_t size;
205 ssize_t sret; 204 ssize_t sret;
206 205
207 if (GNUNET_SYSERR == 206 if (GNUNET_SYSERR ==
208 GNUNET_DNSPARSER_pack (request->packet, 207 GNUNET_DNSPARSER_pack(request->packet,
209 UINT16_MAX /* is this not too much? */, 208 UINT16_MAX /* is this not too much? */,
210 &buf, 209 &buf,
211 &size)) 210 &size))
212 { 211 {
213 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, 212 GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
214 _("Failed to pack DNS response into UDP packet!\n")); 213 _("Failed to pack DNS response into UDP packet!\n"));
215 } 214 }
216 else 215 else
217 { 216 {
218 sret = GNUNET_NETWORK_socket_sendto (request->lsock, 217 sret = GNUNET_NETWORK_socket_sendto(request->lsock,
219 buf, 218 buf,
220 size, 219 size,
221 request->addr, 220 request->addr,
222 request->addr_len); 221 request->addr_len);
223 if ( (sret < 0) || 222 if ((sret < 0) ||
224 (size != (size_t) sret) ) 223 (size != (size_t)sret))
225 GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, 224 GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING,
226 "sendto"); 225 "sendto");
227 GNUNET_free (buf); 226 GNUNET_free(buf);
228 } 227 }
229 GNUNET_SCHEDULER_cancel (request->timeout_task); 228 GNUNET_SCHEDULER_cancel(request->timeout_task);
230 GNUNET_DNSPARSER_free_packet (request->packet); 229 GNUNET_DNSPARSER_free_packet(request->packet);
231 GNUNET_free (request->udp_msg); 230 GNUNET_free(request->udp_msg);
232 GNUNET_free (request); 231 GNUNET_free(request);
233} 232}
234 233
235 234
@@ -239,18 +238,18 @@ send_response (struct Request *request)
239 * @param cls `struct Request *` of the request to clean up 238 * @param cls `struct Request *` of the request to clean up
240 */ 239 */
241static void 240static void
242do_timeout (void *cls) 241do_timeout(void *cls)
243{ 242{
244 struct Request *request = cls; 243 struct Request *request = cls;
245 244
246 if (NULL != request->packet) 245 if (NULL != request->packet)
247 GNUNET_DNSPARSER_free_packet (request->packet); 246 GNUNET_DNSPARSER_free_packet(request->packet);
248 if (NULL != request->lookup) 247 if (NULL != request->lookup)
249 GNUNET_GNS_lookup_with_tld_cancel (request->lookup); 248 GNUNET_GNS_lookup_with_tld_cancel(request->lookup);
250 if (NULL != request->dns_lookup) 249 if (NULL != request->dns_lookup)
251 GNUNET_DNSSTUB_resolve_cancel (request->dns_lookup); 250 GNUNET_DNSSTUB_resolve_cancel(request->dns_lookup);
252 GNUNET_free (request->udp_msg); 251 GNUNET_free(request->udp_msg);
253 GNUNET_free (request); 252 GNUNET_free(request);
254} 253}
255 254
256 255
@@ -262,28 +261,28 @@ do_timeout (void *cls)
262 * @param r size of the DNS payload 261 * @param r size of the DNS payload
263 */ 262 */
264static void 263static void
265dns_result_processor (void *cls, 264dns_result_processor(void *cls,
266 const struct GNUNET_TUN_DnsHeader *dns, 265 const struct GNUNET_TUN_DnsHeader *dns,
267 size_t r) 266 size_t r)
268{ 267{
269 struct Request *request = cls; 268 struct Request *request = cls;
270 269
271 if (NULL == dns) 270 if (NULL == dns)
272 { 271 {
273 /* DNSSTUB gave up, so we trigger timeout early */ 272 /* DNSSTUB gave up, so we trigger timeout early */
274 GNUNET_SCHEDULER_cancel (request->timeout_task); 273 GNUNET_SCHEDULER_cancel(request->timeout_task);
275 do_timeout (request); 274 do_timeout(request);
276 return; 275 return;
277 } 276 }
278 if (request->original_request_id != dns->id) 277 if (request->original_request_id != dns->id)
279 { 278 {
280 /* for a another query, ignore */ 279 /* for a another query, ignore */
281 return; 280 return;
282 } 281 }
283 request->packet = GNUNET_DNSPARSER_parse ((char*)dns, 282 request->packet = GNUNET_DNSPARSER_parse((char*)dns,
284 r); 283 r);
285 GNUNET_DNSSTUB_resolve_cancel (request->dns_lookup); 284 GNUNET_DNSSTUB_resolve_cancel(request->dns_lookup);
286 send_response (request); 285 send_response(request);
287} 286}
288 287
289 288
@@ -296,10 +295,10 @@ dns_result_processor (void *cls,
296 * @param rd the records in reply 295 * @param rd the records in reply
297 */ 296 */
298static void 297static void
299result_processor (void *cls, 298result_processor(void *cls,
300 int was_gns, 299 int was_gns,
301 uint32_t rd_count, 300 uint32_t rd_count,
302 const struct GNUNET_GNSRECORD_Data *rd) 301 const struct GNUNET_GNSRECORD_Data *rd)
303{ 302{
304 struct Request *request = cls; 303 struct Request *request = cls;
305 struct GNUNET_DNSPARSER_Packet *packet; 304 struct GNUNET_DNSPARSER_Packet *packet;
@@ -307,22 +306,22 @@ result_processor (void *cls,
307 306
308 request->lookup = NULL; 307 request->lookup = NULL;
309 if (GNUNET_NO == was_gns) 308 if (GNUNET_NO == was_gns)
310 { 309 {
311 /* TLD not configured for GNS, fall back to DNS */ 310 /* TLD not configured for GNS, fall back to DNS */
312 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 311 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
313 "Using DNS resolver IP `%s' to resolve `%s'\n", 312 "Using DNS resolver IP `%s' to resolve `%s'\n",
314 dns_ip, 313 dns_ip,
315 request->packet->queries[0].name); 314 request->packet->queries[0].name);
316 request->original_request_id = request->packet->id; 315 request->original_request_id = request->packet->id;
317 GNUNET_DNSPARSER_free_packet (request->packet); 316 GNUNET_DNSPARSER_free_packet(request->packet);
318 request->packet = NULL; 317 request->packet = NULL;
319 request->dns_lookup = GNUNET_DNSSTUB_resolve (dns_stub, 318 request->dns_lookup = GNUNET_DNSSTUB_resolve(dns_stub,
320 request->udp_msg, 319 request->udp_msg,
321 request->udp_msg_size, 320 request->udp_msg_size,
322 &dns_result_processor, 321 &dns_result_processor,
323 request); 322 request);
324 return; 323 return;
325 } 324 }
326 packet = request->packet; 325 packet = request->packet;
327 packet->flags.query_or_response = 1; 326 packet->flags.query_or_response = 1;
328 packet->flags.return_code = GNUNET_TUN_DNS_RETURN_CODE_NO_ERROR; 327 packet->flags.return_code = GNUNET_TUN_DNS_RETURN_CODE_NO_ERROR;
@@ -333,59 +332,62 @@ result_processor (void *cls,
333 packet->flags.message_truncated = 0; 332 packet->flags.message_truncated = 0;
334 packet->flags.authoritative_answer = 0; 333 packet->flags.authoritative_answer = 0;
335 //packet->flags.opcode = GNUNET_TUN_DNS_OPCODE_STATUS; // ??? 334 //packet->flags.opcode = GNUNET_TUN_DNS_OPCODE_STATUS; // ???
336 for (uint32_t i=0;i<rd_count;i++) 335 for (uint32_t i = 0; i < rd_count; i++)
337 { 336 {
338 // FIXME: do we need to hanlde #GNUNET_GNSRECORD_RF_SHADOW_RECORD 337 // FIXME: do we need to hanlde #GNUNET_GNSRECORD_RF_SHADOW_RECORD
339 // here? Or should we do this in libgnunetgns? 338 // here? Or should we do this in libgnunetgns?
340 rec.expiration_time.abs_value_us = rd[i].expiration_time; 339 rec.expiration_time.abs_value_us = rd[i].expiration_time;
341 switch (rd[i].record_type) 340 switch (rd[i].record_type)
342 { 341 {
343 case GNUNET_DNSPARSER_TYPE_A: 342 case GNUNET_DNSPARSER_TYPE_A:
344 GNUNET_assert (sizeof (struct in_addr) == rd[i].data_size); 343 GNUNET_assert(sizeof(struct in_addr) == rd[i].data_size);
345 rec.name = GNUNET_strdup (packet->queries[0].name); 344 rec.name = GNUNET_strdup(packet->queries[0].name);
346 rec.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET; 345 rec.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET;
347 rec.type = GNUNET_DNSPARSER_TYPE_A; 346 rec.type = GNUNET_DNSPARSER_TYPE_A;
348 rec.data.raw.data = GNUNET_new (struct in_addr); 347 rec.data.raw.data = GNUNET_new(struct in_addr);
349 GNUNET_memcpy (rec.data.raw.data, 348 GNUNET_memcpy(rec.data.raw.data,
350 rd[i].data, 349 rd[i].data,
351 rd[i].data_size); 350 rd[i].data_size);
352 rec.data.raw.data_len = sizeof (struct in_addr); 351 rec.data.raw.data_len = sizeof(struct in_addr);
353 GNUNET_array_append (packet->answers, 352 GNUNET_array_append(packet->answers,
354 packet->num_answers, 353 packet->num_answers,
355 rec); 354 rec);
356 break; 355 break;
357 case GNUNET_DNSPARSER_TYPE_AAAA: 356
358 GNUNET_assert (sizeof (struct in6_addr) == rd[i].data_size); 357 case GNUNET_DNSPARSER_TYPE_AAAA:
359 rec.name = GNUNET_strdup (packet->queries[0].name); 358 GNUNET_assert(sizeof(struct in6_addr) == rd[i].data_size);
360 rec.data.raw.data = GNUNET_new (struct in6_addr); 359 rec.name = GNUNET_strdup(packet->queries[0].name);
361 rec.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET; 360 rec.data.raw.data = GNUNET_new(struct in6_addr);
362 rec.type = GNUNET_DNSPARSER_TYPE_AAAA; 361 rec.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET;
363 GNUNET_memcpy (rec.data.raw.data, 362 rec.type = GNUNET_DNSPARSER_TYPE_AAAA;
364 rd[i].data, 363 GNUNET_memcpy(rec.data.raw.data,
365 rd[i].data_size); 364 rd[i].data,
366 rec.data.raw.data_len = sizeof (struct in6_addr); 365 rd[i].data_size);
367 GNUNET_array_append (packet->answers, 366 rec.data.raw.data_len = sizeof(struct in6_addr);
368 packet->num_answers, 367 GNUNET_array_append(packet->answers,
369 rec); 368 packet->num_answers,
370 break; 369 rec);
371 case GNUNET_DNSPARSER_TYPE_CNAME: 370 break;
372 rec.name = GNUNET_strdup (packet->queries[0].name); 371
373 rec.data.hostname = GNUNET_strdup (rd[i].data); 372 case GNUNET_DNSPARSER_TYPE_CNAME:
374 rec.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET; 373 rec.name = GNUNET_strdup(packet->queries[0].name);
375 rec.type = GNUNET_DNSPARSER_TYPE_CNAME; 374 rec.data.hostname = GNUNET_strdup(rd[i].data);
376 GNUNET_memcpy (rec.data.hostname, 375 rec.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET;
377 rd[i].data, 376 rec.type = GNUNET_DNSPARSER_TYPE_CNAME;
378 rd[i].data_size); 377 GNUNET_memcpy(rec.data.hostname,
379 GNUNET_array_append (packet->answers, 378 rd[i].data,
380 packet->num_answers, 379 rd[i].data_size);
381 rec); 380 GNUNET_array_append(packet->answers,
382 break; 381 packet->num_answers,
383 default: 382 rec);
384 /* skip */ 383 break;
385 break; 384
386 } 385 default:
386 /* skip */
387 break;
388 }
387 } 389 }
388 send_response (request); 390 send_response(request);
389} 391}
390 392
391 393
@@ -399,73 +401,73 @@ result_processor (void *cls,
399 * @param udp_msg_size number of bytes in @a udp_msg 401 * @param udp_msg_size number of bytes in @a udp_msg
400 */ 402 */
401static void 403static void
402handle_request (struct GNUNET_NETWORK_Handle *lsock, 404handle_request(struct GNUNET_NETWORK_Handle *lsock,
403 const void *addr, 405 const void *addr,
404 size_t addr_len, 406 size_t addr_len,
405 const char *udp_msg, 407 const char *udp_msg,
406 size_t udp_msg_size) 408 size_t udp_msg_size)
407{ 409{
408 struct Request *request; 410 struct Request *request;
409 struct GNUNET_DNSPARSER_Packet *packet; 411 struct GNUNET_DNSPARSER_Packet *packet;
410 412
411 packet = GNUNET_DNSPARSER_parse (udp_msg, 413 packet = GNUNET_DNSPARSER_parse(udp_msg,
412 udp_msg_size); 414 udp_msg_size);
413 if (NULL == packet) 415 if (NULL == packet)
414 { 416 {
415 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, 417 GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
416 _("Cannot parse DNS request from %s\n"), 418 _("Cannot parse DNS request from %s\n"),
417 GNUNET_a2s (addr, addr_len)); 419 GNUNET_a2s(addr, addr_len));
418 return; 420 return;
419 } 421 }
420 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 422 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
421 "Received request for `%s' with flags %u, #answers %d, #auth %d, #additional %d\n", 423 "Received request for `%s' with flags %u, #answers %d, #auth %d, #additional %d\n",
422 packet->queries[0].name, 424 packet->queries[0].name,
423 (unsigned int) packet->flags.query_or_response, 425 (unsigned int)packet->flags.query_or_response,
424 (int) packet->num_answers, 426 (int)packet->num_answers,
425 (int) packet->num_authority_records, 427 (int)packet->num_authority_records,
426 (int) packet->num_additional_records); 428 (int)packet->num_additional_records);
427 if ( (0 != packet->flags.query_or_response) || 429 if ((0 != packet->flags.query_or_response) ||
428 (0 != packet->num_answers) || 430 (0 != packet->num_answers) ||
429 (0 != packet->num_authority_records)) 431 (0 != packet->num_authority_records))
430 { 432 {
431 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, 433 GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
432 _("Received malformed DNS request from %s\n"), 434 _("Received malformed DNS request from %s\n"),
433 GNUNET_a2s (addr, addr_len)); 435 GNUNET_a2s(addr, addr_len));
434 GNUNET_DNSPARSER_free_packet (packet); 436 GNUNET_DNSPARSER_free_packet(packet);
435 return; 437 return;
436 } 438 }
437 if ( (1 != packet->num_queries) ) 439 if ((1 != packet->num_queries))
438 { 440 {
439 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, 441 GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
440 _("Received unsupported DNS request from %s\n"), 442 _("Received unsupported DNS request from %s\n"),
441 GNUNET_a2s (addr, 443 GNUNET_a2s(addr,
442 addr_len)); 444 addr_len));
443 GNUNET_DNSPARSER_free_packet (packet); 445 GNUNET_DNSPARSER_free_packet(packet);
444 return; 446 return;
445 } 447 }
446 request = GNUNET_malloc (sizeof (struct Request) + addr_len); 448 request = GNUNET_malloc(sizeof(struct Request) + addr_len);
447 request->lsock = lsock; 449 request->lsock = lsock;
448 request->packet = packet; 450 request->packet = packet;
449 request->addr = &request[1]; 451 request->addr = &request[1];
450 request->addr_len = addr_len; 452 request->addr_len = addr_len;
451 GNUNET_memcpy (&request[1], 453 GNUNET_memcpy(&request[1],
452 addr, 454 addr,
453 addr_len); 455 addr_len);
454 request->udp_msg_size = udp_msg_size; 456 request->udp_msg_size = udp_msg_size;
455 request->udp_msg = GNUNET_memdup (udp_msg, 457 request->udp_msg = GNUNET_memdup(udp_msg,
456 udp_msg_size); 458 udp_msg_size);
457 request->timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, 459 request->timeout_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT,
458 &do_timeout, 460 &do_timeout,
459 request); 461 request);
460 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 462 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
461 "Calling GNS on `%s'\n", 463 "Calling GNS on `%s'\n",
462 packet->queries[0].name); 464 packet->queries[0].name);
463 request->lookup = GNUNET_GNS_lookup_with_tld (gns, 465 request->lookup = GNUNET_GNS_lookup_with_tld(gns,
464 packet->queries[0].name, 466 packet->queries[0].name,
465 packet->queries[0].type, 467 packet->queries[0].type,
466 GNUNET_NO, 468 GNUNET_NO,
467 &result_processor, 469 &result_processor,
468 request); 470 request);
469} 471}
470 472
471 473
@@ -475,49 +477,49 @@ handle_request (struct GNUNET_NETWORK_Handle *lsock,
475 * @param cls the 'listen_socket4' 477 * @param cls the 'listen_socket4'
476 */ 478 */
477static void 479static void
478read_dns4 (void *cls) 480read_dns4(void *cls)
479{ 481{
480 struct sockaddr_in v4; 482 struct sockaddr_in v4;
481 socklen_t addrlen; 483 socklen_t addrlen;
482 ssize_t size; 484 ssize_t size;
483 const struct GNUNET_SCHEDULER_TaskContext *tc; 485 const struct GNUNET_SCHEDULER_TaskContext *tc;
484 486
485 GNUNET_assert (listen_socket4 == cls); 487 GNUNET_assert(listen_socket4 == cls);
486 t4 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, 488 t4 = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
487 listen_socket4, 489 listen_socket4,
488 &read_dns4, 490 &read_dns4,
489 listen_socket4); 491 listen_socket4);
490 tc = GNUNET_SCHEDULER_get_task_context (); 492 tc = GNUNET_SCHEDULER_get_task_context();
491 if (0 == (GNUNET_SCHEDULER_REASON_READ_READY & tc->reason)) 493 if (0 == (GNUNET_SCHEDULER_REASON_READ_READY & tc->reason))
492 return; /* shutdown? */ 494 return; /* shutdown? */
493 size = GNUNET_NETWORK_socket_recvfrom_amount (listen_socket4); 495 size = GNUNET_NETWORK_socket_recvfrom_amount(listen_socket4);
494 if (0 > size) 496 if (0 > size)
495 { 497 {
496 GNUNET_break (0); 498 GNUNET_break(0);
497 return; /* read error!? */ 499 return; /* read error!? */
498 } 500 }
499 { 501 {
500 char buf[size + 1]; 502 char buf[size + 1];
501 ssize_t sret; 503 ssize_t sret;
502 504
503 addrlen = sizeof (v4); 505 addrlen = sizeof(v4);
504 sret = GNUNET_NETWORK_socket_recvfrom (listen_socket4, 506 sret = GNUNET_NETWORK_socket_recvfrom(listen_socket4,
505 buf, 507 buf,
506 size + 1, 508 size + 1,
507 (struct sockaddr *) &v4, 509 (struct sockaddr *)&v4,
508 &addrlen); 510 &addrlen);
509 if (0 > sret) 511 if (0 > sret)
510 { 512 {
511 GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, 513 GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING,
512 "recvfrom"); 514 "recvfrom");
513 return; 515 return;
514 } 516 }
515 GNUNET_break (size == sret); 517 GNUNET_break(size == sret);
516 handle_request (listen_socket4, 518 handle_request(listen_socket4,
517 &v4, 519 &v4,
518 addrlen, 520 addrlen,
519 buf, 521 buf,
520 size); 522 size);
521 } 523 }
522} 524}
523 525
@@ -528,49 +530,49 @@ read_dns4 (void *cls)
528 * @param cls the 'listen_socket6' 530 * @param cls the 'listen_socket6'
529 */ 531 */
530static void 532static void
531read_dns6 (void *cls) 533read_dns6(void *cls)
532{ 534{
533 struct sockaddr_in6 v6; 535 struct sockaddr_in6 v6;
534 socklen_t addrlen; 536 socklen_t addrlen;
535 ssize_t size; 537 ssize_t size;
536 const struct GNUNET_SCHEDULER_TaskContext *tc; 538 const struct GNUNET_SCHEDULER_TaskContext *tc;
537 539
538 GNUNET_assert (listen_socket6 == cls); 540 GNUNET_assert(listen_socket6 == cls);
539 t6 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, 541 t6 = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
540 listen_socket6, 542 listen_socket6,
541 &read_dns6, 543 &read_dns6,
542 listen_socket6); 544 listen_socket6);
543 tc = GNUNET_SCHEDULER_get_task_context (); 545 tc = GNUNET_SCHEDULER_get_task_context();
544 if (0 == (GNUNET_SCHEDULER_REASON_READ_READY & tc->reason)) 546 if (0 == (GNUNET_SCHEDULER_REASON_READ_READY & tc->reason))
545 return; /* shutdown? */ 547 return; /* shutdown? */
546 size = GNUNET_NETWORK_socket_recvfrom_amount (listen_socket6); 548 size = GNUNET_NETWORK_socket_recvfrom_amount(listen_socket6);
547 if (0 > size) 549 if (0 > size)
548 { 550 {
549 GNUNET_break (0); 551 GNUNET_break(0);
550 return; /* read error!? */ 552 return; /* read error!? */
551 } 553 }
552 { 554 {
553 char buf[size]; 555 char buf[size];
554 ssize_t sret; 556 ssize_t sret;
555 557
556 addrlen = sizeof (v6); 558 addrlen = sizeof(v6);
557 sret = GNUNET_NETWORK_socket_recvfrom (listen_socket6, 559 sret = GNUNET_NETWORK_socket_recvfrom(listen_socket6,
558 buf, 560 buf,
559 size, 561 size,
560 (struct sockaddr *) &v6, 562 (struct sockaddr *)&v6,
561 &addrlen); 563 &addrlen);
562 if (0 > sret) 564 if (0 > sret)
563 { 565 {
564 GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, 566 GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING,
565 "recvfrom"); 567 "recvfrom");
566 return; 568 return;
567 } 569 }
568 GNUNET_break (size == sret); 570 GNUNET_break(size == sret);
569 handle_request (listen_socket6, 571 handle_request(listen_socket6,
570 &v6, 572 &v6,
571 addrlen, 573 addrlen,
572 buf, 574 buf,
573 size); 575 size);
574 } 576 }
575} 577}
576 578
@@ -584,149 +586,150 @@ read_dns6 (void *cls)
584 * @param c configuration 586 * @param c configuration
585 */ 587 */
586static void 588static void
587run (void *cls, 589run(void *cls,
588 char *const *args, 590 char *const *args,
589 const char *cfgfile, 591 const char *cfgfile,
590 const struct GNUNET_CONFIGURATION_Handle *c) 592 const struct GNUNET_CONFIGURATION_Handle *c)
591{ 593{
592 char *addr_str; 594 char *addr_str;
593 (void) cls; 595
594 (void) args; 596 (void)cls;
595 (void) cfgfile; 597 (void)args;
598 (void)cfgfile;
596 cfg = c; 599 cfg = c;
597 if (NULL == dns_ip) 600 if (NULL == dns_ip)
598 { 601 {
599 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 602 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
600 _("No DNS server specified!\n")); 603 _("No DNS server specified!\n"));
601 return; 604 return;
602 } 605 }
603 GNUNET_SCHEDULER_add_shutdown (&do_shutdown, 606 GNUNET_SCHEDULER_add_shutdown(&do_shutdown,
604 NULL); 607 NULL);
605 if (NULL == (gns = GNUNET_GNS_connect (cfg))) 608 if (NULL == (gns = GNUNET_GNS_connect(cfg)))
606 return; 609 return;
607 GNUNET_assert (NULL != (dns_stub = GNUNET_DNSSTUB_start (128))); 610 GNUNET_assert(NULL != (dns_stub = GNUNET_DNSSTUB_start(128)));
608 if (GNUNET_OK != 611 if (GNUNET_OK !=
609 GNUNET_DNSSTUB_add_dns_ip (dns_stub, 612 GNUNET_DNSSTUB_add_dns_ip(dns_stub,
610 dns_ip)) 613 dns_ip))
611 { 614 {
612 GNUNET_DNSSTUB_stop (dns_stub); 615 GNUNET_DNSSTUB_stop(dns_stub);
613 GNUNET_GNS_disconnect (gns); 616 GNUNET_GNS_disconnect(gns);
614 gns = NULL; 617 gns = NULL;
615 return; 618 return;
616 } 619 }
617 620
618 /* Get address to bind to */ 621 /* Get address to bind to */
619 if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (c, "dns2gns", 622 if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(c, "dns2gns",
620 "BIND_TO", 623 "BIND_TO",
621 &addr_str)) 624 &addr_str))
622 { 625 {
623 //No address specified 626 //No address specified
624 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 627 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
625 "Don't know what to bind to...\n"); 628 "Don't know what to bind to...\n");
626 GNUNET_free (addr_str); 629 GNUNET_free(addr_str);
627 GNUNET_SCHEDULER_shutdown (); 630 GNUNET_SCHEDULER_shutdown();
628 return; 631 return;
629 } 632 }
630 if (1 != inet_pton (AF_INET, addr_str, &address)) 633 if (1 != inet_pton(AF_INET, addr_str, &address))
631 { 634 {
632 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 635 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
633 "Unable to parse address %s\n", 636 "Unable to parse address %s\n",
634 addr_str); 637 addr_str);
635 GNUNET_free (addr_str); 638 GNUNET_free(addr_str);
636 GNUNET_SCHEDULER_shutdown (); 639 GNUNET_SCHEDULER_shutdown();
637 return; 640 return;
638 } 641 }
639 GNUNET_free (addr_str); 642 GNUNET_free(addr_str);
640 /* Get address to bind to */ 643 /* Get address to bind to */
641 if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (c, "dns2gns", 644 if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(c, "dns2gns",
642 "BIND_TO6", 645 "BIND_TO6",
643 &addr_str)) 646 &addr_str))
644 { 647 {
645 //No address specified 648 //No address specified
646 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 649 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
647 "Don't know what to bind6 to...\n"); 650 "Don't know what to bind6 to...\n");
648 GNUNET_free (addr_str); 651 GNUNET_free(addr_str);
649 GNUNET_SCHEDULER_shutdown (); 652 GNUNET_SCHEDULER_shutdown();
650 return; 653 return;
651 } 654 }
652 if (1 != inet_pton (AF_INET6, addr_str, &address6)) 655 if (1 != inet_pton(AF_INET6, addr_str, &address6))
653 { 656 {
654 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, 657 GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
655 "Unable to parse IPv6 address %s\n", 658 "Unable to parse IPv6 address %s\n",
656 addr_str); 659 addr_str);
657 GNUNET_free (addr_str); 660 GNUNET_free(addr_str);
658 GNUNET_SCHEDULER_shutdown (); 661 GNUNET_SCHEDULER_shutdown();
659 return; 662 return;
660 } 663 }
661 GNUNET_free (addr_str); 664 GNUNET_free(addr_str);
662 665
663 listen_socket4 = GNUNET_NETWORK_socket_create (PF_INET, 666 listen_socket4 = GNUNET_NETWORK_socket_create(PF_INET,
664 SOCK_DGRAM, 667 SOCK_DGRAM,
665 IPPROTO_UDP); 668 IPPROTO_UDP);
666 if (NULL != listen_socket4) 669 if (NULL != listen_socket4)
667 { 670 {
668 struct sockaddr_in v4; 671 struct sockaddr_in v4;
669 672
670 memset (&v4, 0, sizeof (v4)); 673 memset(&v4, 0, sizeof(v4));
671 v4.sin_family = AF_INET; 674 v4.sin_family = AF_INET;
672 v4.sin_addr.s_addr = address; 675 v4.sin_addr.s_addr = address;
673#if HAVE_SOCKADDR_IN_SIN_LEN 676#if HAVE_SOCKADDR_IN_SIN_LEN
674 v4.sin_len = sizeof (v4); 677 v4.sin_len = sizeof(v4);
675#endif 678#endif
676 v4.sin_port = htons (listen_port); 679 v4.sin_port = htons(listen_port);
677 if (GNUNET_OK != 680 if (GNUNET_OK !=
678 GNUNET_NETWORK_socket_bind (listen_socket4, 681 GNUNET_NETWORK_socket_bind(listen_socket4,
679 (struct sockaddr *) &v4, 682 (struct sockaddr *)&v4,
680 sizeof (v4))) 683 sizeof(v4)))
681 { 684 {
682 GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind"); 685 GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "bind");
683 GNUNET_NETWORK_socket_close (listen_socket4); 686 GNUNET_NETWORK_socket_close(listen_socket4);
684 listen_socket4 = NULL; 687 listen_socket4 = NULL;
688 }
685 } 689 }
686 } 690 listen_socket6 = GNUNET_NETWORK_socket_create(PF_INET6,
687 listen_socket6 = GNUNET_NETWORK_socket_create (PF_INET6, 691 SOCK_DGRAM,
688 SOCK_DGRAM, 692 IPPROTO_UDP);
689 IPPROTO_UDP);
690 if (NULL != listen_socket6) 693 if (NULL != listen_socket6)
691 { 694 {
692 struct sockaddr_in6 v6; 695 struct sockaddr_in6 v6;
693 696
694 memset (&v6, 0, sizeof (v6)); 697 memset(&v6, 0, sizeof(v6));
695 v6.sin6_family = AF_INET6; 698 v6.sin6_family = AF_INET6;
696 v6.sin6_addr = address6; 699 v6.sin6_addr = address6;
697#if HAVE_SOCKADDR_IN_SIN_LEN 700#if HAVE_SOCKADDR_IN_SIN_LEN
698 v6.sin6_len = sizeof (v6); 701 v6.sin6_len = sizeof(v6);
699#endif 702#endif
700 v6.sin6_port = htons (listen_port); 703 v6.sin6_port = htons(listen_port);
701 if (GNUNET_OK != 704 if (GNUNET_OK !=
702 GNUNET_NETWORK_socket_bind (listen_socket6, 705 GNUNET_NETWORK_socket_bind(listen_socket6,
703 (struct sockaddr *) &v6, 706 (struct sockaddr *)&v6,
704 sizeof (v6))) 707 sizeof(v6)))
708 {
709 GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "bind");
710 GNUNET_NETWORK_socket_close(listen_socket6);
711 listen_socket6 = NULL;
712 }
713 }
714 if ((NULL == listen_socket4) &&
715 (NULL == listen_socket6))
705 { 716 {
706 GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "bind"); 717 GNUNET_GNS_disconnect(gns);
707 GNUNET_NETWORK_socket_close (listen_socket6); 718 gns = NULL;
708 listen_socket6 = NULL; 719 GNUNET_DNSSTUB_stop(dns_stub);
720 dns_stub = NULL;
721 return;
709 } 722 }
710 }
711 if ( (NULL == listen_socket4) &&
712 (NULL == listen_socket6) )
713 {
714 GNUNET_GNS_disconnect (gns);
715 gns = NULL;
716 GNUNET_DNSSTUB_stop (dns_stub);
717 dns_stub = NULL;
718 return;
719 }
720 if (NULL != listen_socket4) 723 if (NULL != listen_socket4)
721 t4 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, 724 t4 = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
722 listen_socket4, 725 listen_socket4,
723 &read_dns4, 726 &read_dns4,
724 listen_socket4); 727 listen_socket4);
725 if (NULL != listen_socket6) 728 if (NULL != listen_socket6)
726 t6 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, 729 t6 = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
727 listen_socket6, 730 listen_socket6,
728 &read_dns6, 731 &read_dns6,
729 listen_socket6); 732 listen_socket6);
730} 733}
731 734
732 735
@@ -738,39 +741,39 @@ run (void *cls,
738 * @return 0 ok, 1 on error 741 * @return 0 ok, 1 on error
739 */ 742 */
740int 743int
741main (int argc, 744main(int argc,
742 char *const *argv) 745 char *const *argv)
743{ 746{
744 struct GNUNET_GETOPT_CommandLineOption options[] = { 747 struct GNUNET_GETOPT_CommandLineOption options[] = {
745 GNUNET_GETOPT_option_string ('d', 748 GNUNET_GETOPT_option_string('d',
746 "dns", 749 "dns",
747 "IP", 750 "IP",
748 gettext_noop ("IP of recursive DNS resolver to use (required)"), 751 gettext_noop("IP of recursive DNS resolver to use (required)"),
749 &dns_ip), 752 &dns_ip),
750 GNUNET_GETOPT_option_uint ('p', 753 GNUNET_GETOPT_option_uint('p',
751 "port", 754 "port",
752 "UDPPORT", 755 "UDPPORT",
753 gettext_noop ("UDP port to listen on for inbound DNS requests; default: 2853"), 756 gettext_noop("UDP port to listen on for inbound DNS requests; default: 2853"),
754 &listen_port), 757 &listen_port),
755 GNUNET_GETOPT_OPTION_END 758 GNUNET_GETOPT_OPTION_END
756 }; 759 };
757 int ret; 760 int ret;
758 761
759 if (GNUNET_OK != 762 if (GNUNET_OK !=
760 GNUNET_STRINGS_get_utf8_args (argc, argv, 763 GNUNET_STRINGS_get_utf8_args(argc, argv,
761 &argc, &argv)) 764 &argc, &argv))
762 return 2; 765 return 2;
763 GNUNET_log_setup ("gnunet-dns2gns", 766 GNUNET_log_setup("gnunet-dns2gns",
764 "WARNING", 767 "WARNING",
765 NULL); 768 NULL);
766 ret = 769 ret =
767 (GNUNET_OK == 770 (GNUNET_OK ==
768 GNUNET_PROGRAM_run (argc, argv, 771 GNUNET_PROGRAM_run(argc, argv,
769 "gnunet-dns2gns", 772 "gnunet-dns2gns",
770 _("GNUnet DNS-to-GNS proxy (a DNS server)"), 773 _("GNUnet DNS-to-GNS proxy (a DNS server)"),
771 options, 774 options,
772 &run, NULL)) ? 0 : 1; 775 &run, NULL)) ? 0 : 1;
773 GNUNET_free ((void*) argv); 776 GNUNET_free((void*)argv);
774 return ret; 777 return ret;
775} 778}
776 779