GNUnet debian-0.24.3-28-g4f2a77692
 
Loading...
Searching...
No Matches
Data Structures | Macros | Functions
dnsstub.c File Reference
#include "platform.h"
#include "gnunet_util_lib.h"
Include dependency graph for dnsstub.c:

Go to the source code of this file.

Data Structures

struct  GNUNET_DNSSTUB_RequestSocket
 UDP socket we are using for sending DNS requests to the Internet. More...
 
struct  DnsServer
 DNS Server used for resolution. More...
 
struct  GNUNET_DNSSTUB_Context
 Handle to the stub resolver. More...
 

Macros

#define DNS_RETRANSMIT_DELAY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 250)
 Timeout for retrying DNS queries.
 

Functions

static void cleanup_rs (struct GNUNET_DNSSTUB_RequestSocket *rs)
 We're done with a struct GNUNET_DNSSTUB_RequestSocket, close it for now.
 
static struct GNUNET_NETWORK_Handle * open_socket (int af)
 Open source port for sending DNS requests.
 
static struct GNUNET_DNSSTUB_RequestSocket * get_request_socket (struct GNUNET_DNSSTUB_Context *ctx)
 Get a socket of the specified address family to send out a UDP DNS request to the Internet.
 
static int do_dns_read (struct GNUNET_DNSSTUB_RequestSocket *rs, struct GNUNET_NETWORK_Handle *dnsout)
 Actually do the reading of a DNS packet from our UDP socket and see if we have a valid, matching, pending request.
 
static void read_response (void *cls)
 Read a DNS response from the (unhindered) UDP-Socket.
 
static void schedule_read (struct GNUNET_DNSSTUB_RequestSocket *rs)
 Schedule read_response() task for rs.
 
static void transmit_query (void *cls)
 Task to (re)transmit the DNS query, possibly repeatedly until we succeed.
 
struct GNUNET_DNSSTUB_RequestSocket * GNUNET_DNSSTUB_resolve (struct GNUNET_DNSSTUB_Context *ctx, const void *request, size_t request_len, GNUNET_DNSSTUB_ResultCallback rc, void *rc_cls)
 Perform DNS resolution using our default IP from init.
 
void GNUNET_DNSSTUB_resolve_cancel (struct GNUNET_DNSSTUB_RequestSocket *rs)
 Cancel DNS resolution.
 
struct GNUNET_DNSSTUB_Context * GNUNET_DNSSTUB_start (unsigned int num_sockets)
 Start a DNS stub resolver.
 
int GNUNET_DNSSTUB_add_dns_ip (struct GNUNET_DNSSTUB_Context *ctx, const char *dns_ip)
 Add nameserver for use by the DNSSTUB.
 
int GNUNET_DNSSTUB_add_dns_sa (struct GNUNET_DNSSTUB_Context *ctx, const struct sockaddr *sa)
 Add nameserver for use by the DNSSTUB.
 
void GNUNET_DNSSTUB_set_retry (struct GNUNET_DNSSTUB_Context *ctx, struct GNUNET_TIME_Relative retry_freq)
 How long should we try requests before timing out? Only effective for requests issued after this call.
 
void GNUNET_DNSSTUB_stop (struct GNUNET_DNSSTUB_Context *ctx)
 Cleanup DNSSTUB resolver.
 

Macro Definition Documentation

◆ DNS_RETRANSMIT_DELAY

#define DNS_RETRANSMIT_DELAY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 250)

Timeout for retrying DNS queries.

Definition at line 32 of file dnsstub.c.

45{
49 struct GNUNET_NETWORK_Handle *dnsout4;
50
54 struct GNUNET_NETWORK_Handle *dnsout6;
55
59 GNUNET_DNSSTUB_ResultCallback rc;
60
64 void *rc_cls;
65
69 struct GNUNET_SCHEDULER_Task *read_task;
70
74 struct GNUNET_SCHEDULER_Task *retry_task;
75
79 struct DnsServer *ds_pos;
80
84 struct GNUNET_DNSSTUB_Context *ctx;
85
89 void *request;
90
94 size_t request_len;
95};
96
97
101struct DnsServer
102{
106 struct DnsServer *next;
107
111 struct DnsServer *prev;
112
116 struct sockaddr_storage ss;
117};
118
119
123struct GNUNET_DNSSTUB_Context
124{
128 struct GNUNET_DNSSTUB_RequestSocket *sockets;
129
133 struct DnsServer *dns_head;
134
138 struct DnsServer *dns_tail;
139
143 struct GNUNET_TIME_Relative retry_freq;
144
148 unsigned int num_sockets;
149};
150
151
157static void
158cleanup_rs (struct GNUNET_DNSSTUB_RequestSocket *rs)
159{
160 if (NULL != rs->dnsout4)
161 {
162 GNUNET_NETWORK_socket_close (rs->dnsout4);
163 rs->dnsout4 = NULL;
164 }
165 if (NULL != rs->dnsout6)
166 {
167 GNUNET_NETWORK_socket_close (rs->dnsout6);
168 rs->dnsout6 = NULL;
169 }
170 if (NULL != rs->read_task)
171 {
172 GNUNET_SCHEDULER_cancel (rs->read_task);
173 rs->read_task = NULL;
174 }
175 if (NULL != rs->retry_task)
176 {
177 GNUNET_SCHEDULER_cancel (rs->retry_task);
178 rs->retry_task = NULL;
179 }
180 if (NULL != rs->request)
181 {
182 GNUNET_free (rs->request);
183 rs->request = NULL;
184 }
185}
186
187
194static struct GNUNET_NETWORK_Handle *
195open_socket (int af)
196{
197 struct sockaddr_in a4;
198 struct sockaddr_in6 a6;
199 struct sockaddr *sa;
200 socklen_t alen;
201 struct GNUNET_NETWORK_Handle *ret;
202
203 ret = GNUNET_NETWORK_socket_create (af, SOCK_DGRAM, 0);
204 if (NULL == ret)
205 return NULL;
206 switch (af)
207 {
208 case AF_INET:
209 memset (&a4, 0, alen = sizeof(struct sockaddr_in));
210 sa = (struct sockaddr *) &a4;
211 break;
212
213 case AF_INET6:
214 memset (&a6, 0, alen = sizeof(struct sockaddr_in6));
215 sa = (struct sockaddr *) &a6;
216 break;
217
218 default:
219 GNUNET_break (0);
220 GNUNET_NETWORK_socket_close (ret);
221 return NULL;
222 }
223 sa->sa_family = af;
224 if (GNUNET_OK != GNUNET_NETWORK_socket_bind (ret, sa, alen))
225 {
226 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
227 _ ("Could not bind to any port: %s\n"),
228 strerror (errno));
229 GNUNET_NETWORK_socket_close (ret);
230 return NULL;
231 }
232 return ret;
233}
234
235
243static struct GNUNET_DNSSTUB_RequestSocket *
244get_request_socket (struct GNUNET_DNSSTUB_Context *ctx)
245{
246 struct GNUNET_DNSSTUB_RequestSocket *rs;
247
248 for (unsigned int i = 0; i < 256; i++)
249 {
250 rs = &ctx->sockets[GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
251 ctx->num_sockets)];
252 if (NULL == rs->rc)
253 break;
254 }
255 if (NULL != rs->rc)
256 {
257 /* signal "failure" */
258 rs->rc (rs->rc_cls, NULL, 0);
259 rs->rc = NULL;
260 }
261 if (NULL != rs->read_task)
262 {
263 GNUNET_SCHEDULER_cancel (rs->read_task);
264 rs->read_task = NULL;
265 }
266 if (NULL != rs->retry_task)
267 {
268 GNUNET_SCHEDULER_cancel (rs->retry_task);
269 rs->retry_task = NULL;
270 }
271 if (NULL != rs->request)
272 {
273 GNUNET_free (rs->request);
274 rs->request = NULL;
275 }
276 rs->ctx = ctx;
277 return rs;
278}
279
280
289static int
290do_dns_read (struct GNUNET_DNSSTUB_RequestSocket *rs,
291 struct GNUNET_NETWORK_Handle *dnsout)
292{
293 struct GNUNET_DNSSTUB_Context *ctx = rs->ctx;
294 ssize_t r;
295 int len;
296
297 if (0 != ioctl (GNUNET_NETWORK_get_fd (dnsout), FIONREAD, &len))
298 {
299 /* conservative choice: */
300 len = UINT16_MAX;
301 }
302
303 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Receiving %d byte DNS reply\n", len);
304 {
305 unsigned char buf[len] GNUNET_ALIGN;
306 int found;
307 struct sockaddr_storage addr;
308 socklen_t addrlen;
309 struct GNUNET_TUN_DnsHeader *dns;
310
311 addrlen = sizeof(addr);
312 memset (&addr, 0, sizeof(addr));
313 r = GNUNET_NETWORK_socket_recvfrom (dnsout,
314 buf,
315 sizeof(buf),
316 (struct sockaddr *) &addr,
317 &addrlen);
318 if (-1 == r)
319 {
320 GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "recvfrom");
321 GNUNET_NETWORK_socket_close (dnsout);
322 return GNUNET_SYSERR;
323 }
324 found = GNUNET_NO;
325 for (struct DnsServer *ds = ctx->dns_head; NULL != ds; ds = ds->next)
326 {
327 if (ds->ss.ss_family != addr.ss_family)
328 continue;
329 if (addr.ss_family == AF_INET)
330 {
331 struct sockaddr_in *v4 = (struct sockaddr_in *) &addr;
332 struct sockaddr_in *ds_v4 = (struct sockaddr_in *) &ds->ss;
333
334
335 if ((0 == memcmp (&v4->sin_addr,
336 &ds_v4->sin_addr,
337 sizeof(struct sockaddr_in))) &&
338 (v4->sin_port == ds_v4->sin_port))
339 {
340 found = GNUNET_YES;
341 break;
342 }
343 }
344 else
345 {
346 struct sockaddr_in6 *v6 = (struct sockaddr_in6 *) &addr;
347 struct sockaddr_in6 *ds_v6 = (struct sockaddr_in6 *) &ds->ss;
348
349 if (0 == memcmp (&v6->sin6_addr,
350 &ds_v6->sin6_addr,
351 sizeof (v6->sin6_addr)) &&
352 (v6->sin6_port == ds_v6->sin6_port))
353 {
354 found = GNUNET_YES;
355 break;
356 }
357
358 }
359 }
360 if (GNUNET_NO == found)
361 {
362 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
363 "Received DNS response from server we never asked (ignored)\n");
364
365 return GNUNET_NO;
366 }
367 if (sizeof(struct GNUNET_TUN_DnsHeader) > (size_t) r)
368 {
369 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
370 _ ("Received DNS response that is too small (%u bytes)\n"),
371 (unsigned int) r);
372 return GNUNET_NO;
373 }
374 dns = (struct GNUNET_TUN_DnsHeader *) buf;
375 if (NULL == rs->rc)
376 {
377 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
378 "Request timeout or cancelled; ignoring reply\n");
379 return GNUNET_NO;
380 }
381 rs->rc (rs->rc_cls, dns, r);
382 }
383 return GNUNET_OK;
384}
385
386
392static void
393read_response (void *cls);
394
395
401static void
402schedule_read (struct GNUNET_DNSSTUB_RequestSocket *rs)
403{
404 struct GNUNET_NETWORK_FDSet *rset;
405
406 if (NULL != rs->read_task)
407 GNUNET_SCHEDULER_cancel (rs->read_task);
408 rset = GNUNET_NETWORK_fdset_create ();
409 if (NULL != rs->dnsout4)
410 GNUNET_NETWORK_fdset_set (rset, rs->dnsout4);
411 if (NULL != rs->dnsout6)
412 GNUNET_NETWORK_fdset_set (rset, rs->dnsout6);
413 rs->read_task =
414 GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
415 GNUNET_TIME_UNIT_FOREVER_REL,
416 rset,
417 NULL,
418 &read_response,
419 rs);
420 GNUNET_NETWORK_fdset_destroy (rset);
421}
422
423
424static void
425read_response (void *cls)
426{
427 struct GNUNET_DNSSTUB_RequestSocket *rs = cls;
428 const struct GNUNET_SCHEDULER_TaskContext *tc;
429
430 rs->read_task = NULL;
431 tc = GNUNET_SCHEDULER_get_task_context ();
432 /* read and process ready sockets */
433 if ((NULL != rs->dnsout4) &&
434 (GNUNET_NETWORK_fdset_isset (tc->read_ready, rs->dnsout4)) &&
435 (GNUNET_SYSERR == do_dns_read (rs, rs->dnsout4)))
436 rs->dnsout4 = NULL;
437 if ((NULL != rs->dnsout6) &&
438 (GNUNET_NETWORK_fdset_isset (tc->read_ready, rs->dnsout6)) &&
439 (GNUNET_SYSERR == do_dns_read (rs, rs->dnsout6)))
440 rs->dnsout6 = NULL;
441 /* re-schedule read task */
442 schedule_read (rs);
443}
444
445
452static void
453transmit_query (void *cls)
454{
455 struct GNUNET_DNSSTUB_RequestSocket *rs = cls;
456 struct GNUNET_DNSSTUB_Context *ctx = rs->ctx;
457 const struct sockaddr *sa;
458 socklen_t salen;
459 struct DnsServer *ds;
460 struct GNUNET_NETWORK_Handle *dnsout;
461
462 rs->retry_task =
463 GNUNET_SCHEDULER_add_delayed (ctx->retry_freq, &transmit_query, rs);
464 ds = rs->ds_pos;
465 rs->ds_pos = ds->next;
466 if (NULL == rs->ds_pos)
467 rs->ds_pos = ctx->dns_head;
468 GNUNET_assert (NULL != ds);
469 dnsout = NULL;
470 switch (ds->ss.ss_family)
471 {
472 case AF_INET:
473 if (NULL == rs->dnsout4)
474 rs->dnsout4 = open_socket (AF_INET);
475 dnsout = rs->dnsout4;
476 sa = (const struct sockaddr *) &ds->ss;
477 salen = sizeof(struct sockaddr_in);
478 break;
479
480 case AF_INET6:
481 if (NULL == rs->dnsout6)
482 rs->dnsout6 = open_socket (AF_INET6);
483 dnsout = rs->dnsout6;
484 sa = (const struct sockaddr *) &ds->ss;
485 salen = sizeof(struct sockaddr_in6);
486 break;
487
488 default:
489 return;
490 }
491 if (NULL == dnsout)
492 {
493 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
494 "Unable to use configure DNS server, skipping\n");
495 return;
496 }
497 if (GNUNET_SYSERR == GNUNET_NETWORK_socket_sendto (dnsout,
498 rs->request,
499 rs->request_len,
500 sa,
501 salen))
502 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
503 _ ("Failed to send DNS request to %s: %s\n"),
504 GNUNET_a2s (sa, salen),
505 strerror (errno));
506 else
507 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
508 _ ("Sent DNS request to %s\n"),
509 GNUNET_a2s (sa, salen));
510 schedule_read (rs);
511}
512
513
524struct GNUNET_DNSSTUB_RequestSocket *
525GNUNET_DNSSTUB_resolve (struct GNUNET_DNSSTUB_Context *ctx,
526 const void *request,
527 size_t request_len,
528 GNUNET_DNSSTUB_ResultCallback rc,
529 void *rc_cls)
530{
531 struct GNUNET_DNSSTUB_RequestSocket *rs;
532
533 if (NULL == ctx->dns_head)
534 {
535 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
536 "No DNS server configured for resolution\n");
537 return NULL;
538 }
539 if (NULL == (rs = get_request_socket (ctx)))
540 {
541 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
542 "No request socket available for DNS resolution\n");
543 return NULL;
544 }
545 rs->ds_pos = ctx->dns_head;
546 rs->rc = rc;
547 rs->rc_cls = rc_cls;
548 rs->request = GNUNET_memdup (request, request_len);
549 rs->request_len = request_len;
550 rs->retry_task = GNUNET_SCHEDULER_add_now (&transmit_query, rs);
551 return rs;
552}
553
554
560void
561GNUNET_DNSSTUB_resolve_cancel (struct GNUNET_DNSSTUB_RequestSocket *rs)
562{
563 rs->rc = NULL;
564 if (NULL != rs->retry_task)
565 {
566 GNUNET_SCHEDULER_cancel (rs->retry_task);
567 rs->retry_task = NULL;
568 }
569 if (NULL != rs->read_task)
570 {
571 GNUNET_SCHEDULER_cancel (rs->read_task);
572 rs->read_task = NULL;
573 }
574}
575
576
584struct GNUNET_DNSSTUB_Context *
585GNUNET_DNSSTUB_start (unsigned int num_sockets)
586{
587 struct GNUNET_DNSSTUB_Context *ctx;
588
589 if (0 == num_sockets)
590 {
591 GNUNET_break (0);
592 return NULL;
593 }
594 ctx = GNUNET_new (struct GNUNET_DNSSTUB_Context);
595 ctx->num_sockets = num_sockets;
596 ctx->sockets =
597 GNUNET_new_array (num_sockets, struct GNUNET_DNSSTUB_RequestSocket);
598 ctx->retry_freq = DNS_RETRANSMIT_DELAY;
599 return ctx;
600}
601
602
611int
612GNUNET_DNSSTUB_add_dns_ip (struct GNUNET_DNSSTUB_Context *ctx,
613 const char *dns_ip)
614{
615 struct DnsServer *ds;
616 struct in_addr i4;
617 struct in6_addr i6;
618
619 ds = GNUNET_new (struct DnsServer);
620 if (1 == inet_pton (AF_INET, dns_ip, &i4))
621 {
622 struct sockaddr_in *s4 = (struct sockaddr_in *) &ds->ss;
623
624 s4->sin_family = AF_INET;
625 s4->sin_port = htons (53);
626 s4->sin_addr = i4;
627#if HAVE_SOCKADDR_IN_SIN_LEN
628 s4->sin_len = (u_char) sizeof(struct sockaddr_in);
629#endif
630 }
631 else if (1 == inet_pton (AF_INET6, dns_ip, &i6))
632 {
633 struct sockaddr_in6 *s6 = (struct sockaddr_in6 *) &ds->ss;
634
635 s6->sin6_family = AF_INET6;
636 s6->sin6_port = htons (53);
637 s6->sin6_addr = i6;
638#if HAVE_SOCKADDR_IN_SIN_LEN
639 s6->sin6_len = (u_char) sizeof(struct sockaddr_in6);
640#endif
641 }
642 else
643 {
644 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
645 "Malformed IP address `%s' for DNS server\n",
646 dns_ip);
647 GNUNET_free (ds);
648 return GNUNET_SYSERR;
649 }
650 GNUNET_CONTAINER_DLL_insert (ctx->dns_head, ctx->dns_tail, ds);
651 return GNUNET_OK;
652}
653
654
663int
664GNUNET_DNSSTUB_add_dns_sa (struct GNUNET_DNSSTUB_Context *ctx,
665 const struct sockaddr *sa)
666{
667 struct DnsServer *ds;
668
669 ds = GNUNET_new (struct DnsServer);
670 switch (sa->sa_family)
671 {
672 case AF_INET :
673 GNUNET_memcpy (&ds->ss, sa, sizeof(struct sockaddr_in));
674 break;
675
676 case AF_INET6:
677 GNUNET_memcpy (&ds->ss, sa, sizeof(struct sockaddr_in6));
678 break;
679
680 default:
681 GNUNET_break (0);
682 GNUNET_free (ds);
683 return GNUNET_SYSERR;
684 }
685 GNUNET_CONTAINER_DLL_insert (ctx->dns_head, ctx->dns_tail, ds);
686 return GNUNET_OK;
687}
688
689
690void
691GNUNET_DNSSTUB_set_retry (struct GNUNET_DNSSTUB_Context *ctx,
692 struct GNUNET_TIME_Relative retry_freq)
693{
694 ctx->retry_freq = retry_freq;
695}
696
697
703void
704GNUNET_DNSSTUB_stop (struct GNUNET_DNSSTUB_Context *ctx)
705{
706 struct DnsServer *ds;
707
708 while (NULL != (ds = ctx->dns_head))
709 {
710 GNUNET_CONTAINER_DLL_remove (ctx->dns_head, ctx->dns_tail, ds);
711 GNUNET_free (ds);
712 }
713 for (unsigned int i = 0; i < ctx->num_sockets; i++)
714 cleanup_rs (&ctx->sockets[i]);
715 GNUNET_free (ctx->sockets);
716 GNUNET_free (ctx);
717}
718
719
720/* end of dnsstub.c */
transmit_query
static void transmit_query(void *cls)
Task to (re)transmit the DNS query, possibly repeatedly until we succeed.
Definition dnsstub.c:454
get_request_socket
static struct GNUNET_DNSSTUB_RequestSocket * get_request_socket(struct GNUNET_DNSSTUB_Context *ctx)
Get a socket of the specified address family to send out a UDP DNS request to the Internet.
Definition dnsstub.c:245
read_response
static void read_response(void *cls)
Read a DNS response from the (unhindered) UDP-Socket.
Definition dnsstub.c:426
do_dns_read
static int do_dns_read(struct GNUNET_DNSSTUB_RequestSocket *rs, struct GNUNET_NETWORK_Handle *dnsout)
Actually do the reading of a DNS packet from our UDP socket and see if we have a valid,...
Definition dnsstub.c:291
schedule_read
static void schedule_read(struct GNUNET_DNSSTUB_RequestSocket *rs)
Schedule read_response() task for rs.
Definition dnsstub.c:403
open_socket
static struct GNUNET_NETWORK_Handle * open_socket(int af)
Open source port for sending DNS requests.
Definition dnsstub.c:196
cleanup_rs
static void cleanup_rs(struct GNUNET_DNSSTUB_RequestSocket *rs)
We're done with a struct GNUNET_DNSSTUB_RequestSocket, close it for now.
Definition dnsstub.c:159
DNS_RETRANSMIT_DELAY
#define DNS_RETRANSMIT_DELAY
Timeout for retrying DNS queries.
Definition dnsstub.c:32
ret
static int ret
Final status code.
Definition gnunet-arm.c:93
dns_ip
static char * dns_ip
IP of DNS server.
Definition gnunet-dns2gns.c:188
ctx
static struct GNUNET_FS_Handle * ctx
Definition gnunet-download.c:40
read_task
struct GNUNET_SCHEDULER_Task * read_task
Definition gnunet-messenger.c:38
ds
static struct GNUNET_FS_DirScanner * ds
Handle to the directory scanner (for recursive insertions).
Definition gnunet-publish.c:131
retry_task
static struct GNUNET_SCHEDULER_Task * retry_task
Task that re-transmits requests (using retry_heap).
Definition gnunet-service-dht_clients.c:262
request
static struct GNUNET_VPN_RedirectionRequest * request
Opaque redirection request handle.
Definition gnunet-vpn.c:40
GNUNET_CRYPTO_random_u32
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
Definition crypto_random.c:178
GNUNET_CRYPTO_QUALITY_NONCE
@ GNUNET_CRYPTO_QUALITY_NONCE
Randomness for IVs etc.
Definition gnunet_crypto_lib.h:103
GNUNET_CONTAINER_DLL_remove
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
Definition gnunet_container_lib.h:1920
GNUNET_CONTAINER_DLL_insert
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
Definition gnunet_container_lib.h:1797
GNUNET_DNSSTUB_start
struct GNUNET_DNSSTUB_Context * GNUNET_DNSSTUB_start(unsigned int num_sockets)
Start a DNS stub resolver.
Definition dnsstub.c:586
GNUNET_DNSSTUB_add_dns_ip
int GNUNET_DNSSTUB_add_dns_ip(struct GNUNET_DNSSTUB_Context *ctx, const char *dns_ip)
Add nameserver for use by the DNSSTUB.
Definition dnsstub.c:613
GNUNET_DNSSTUB_ResultCallback
void(* GNUNET_DNSSTUB_ResultCallback)(void *cls, const struct GNUNET_TUN_DnsHeader *dns, size_t dns_len)
Function called with the result of a DNS resolution.
Definition gnunet_dnsstub_lib.h:123
GNUNET_DNSSTUB_stop
void GNUNET_DNSSTUB_stop(struct GNUNET_DNSSTUB_Context *ctx)
Cleanup DNSSTUB resolver.
Definition dnsstub.c:705
GNUNET_DNSSTUB_set_retry
void GNUNET_DNSSTUB_set_retry(struct GNUNET_DNSSTUB_Context *ctx, struct GNUNET_TIME_Relative retry_freq)
How long should we try requests before timing out? Only effective for requests issued after this call...
Definition dnsstub.c:692
GNUNET_DNSSTUB_resolve
struct GNUNET_DNSSTUB_RequestSocket * GNUNET_DNSSTUB_resolve(struct GNUNET_DNSSTUB_Context *ctx, const void *request, size_t request_len, GNUNET_DNSSTUB_ResultCallback rc, void *rc_cls)
Perform DNS resolution using our default IP from init.
Definition dnsstub.c:526
GNUNET_DNSSTUB_resolve_cancel
void GNUNET_DNSSTUB_resolve_cancel(struct GNUNET_DNSSTUB_RequestSocket *rs)
Cancel DNS resolution.
Definition dnsstub.c:562
GNUNET_DNSSTUB_add_dns_sa
int GNUNET_DNSSTUB_add_dns_sa(struct GNUNET_DNSSTUB_Context *ctx, const struct sockaddr *sa)
Add nameserver for use by the DNSSTUB.
Definition dnsstub.c:665
GNUNET_log
#define GNUNET_log(kind,...)
Definition gnunet_common.h:548
GNUNET_ALIGN
#define GNUNET_ALIGN
gcc-ism to force alignment; we use this to align char-arrays that may then be cast to 'struct's.
Definition gnunet_common.h:253
GNUNET_memcpy
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
Definition gnunet_common.h:1317
GNUNET_SCHEDULER_PRIORITY_DEFAULT
@ GNUNET_SCHEDULER_PRIORITY_DEFAULT
Run with the default priority (normal P2P operations).
Definition gnunet_common.h:1796
GNUNET_OK
@ GNUNET_OK
Definition gnunet_common.h:111
GNUNET_YES
@ GNUNET_YES
Definition gnunet_common.h:113
GNUNET_NO
@ GNUNET_NO
Definition gnunet_common.h:110
GNUNET_SYSERR
@ GNUNET_SYSERR
Definition gnunet_common.h:109
GNUNET_assert
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Definition gnunet_common.h:957
GNUNET_break
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
Definition gnunet_common.h:1042
GNUNET_a2s
const char * GNUNET_a2s(const struct sockaddr *addr, socklen_t addrlen)
Convert a "struct sockaddr*" (IPv4 or IPv6 address) to a string (for printing debug messages).
Definition common_logging.c:1386
GNUNET_log_strerror
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
Definition gnunet_common.h:1084
GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_WARNING
Definition gnunet_common.h:415
GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_ERROR
Definition gnunet_common.h:414
GNUNET_ERROR_TYPE_DEBUG
@ GNUNET_ERROR_TYPE_DEBUG
Definition gnunet_common.h:421
GNUNET_new
#define GNUNET_new(type)
Allocate a struct or union of the given type.
Definition gnunet_common.h:1237
GNUNET_new_array
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
Definition gnunet_common.h:1337
GNUNET_free
#define GNUNET_free(ptr)
Wrapper around free.
Definition gnunet_common.h:1412
GNUNET_memdup
#define GNUNET_memdup(buf, size)
Allocate and initialize a block of memory.
Definition gnunet_common.h:1362
GNUNET_NETWORK_socket_close
enum GNUNET_GenericReturnValue GNUNET_NETWORK_socket_close(struct GNUNET_NETWORK_Handle *desc)
Close a socket.
Definition network.c:508
GNUNET_NETWORK_fdset_destroy
void GNUNET_NETWORK_fdset_destroy(struct GNUNET_NETWORK_FDSet *fds)
Releases the associated memory of an fd set.
Definition network.c:1185
GNUNET_NETWORK_get_fd
int GNUNET_NETWORK_get_fd(const struct GNUNET_NETWORK_Handle *desc)
Return file descriptor for this network handle.
Definition network.c:1001
GNUNET_NETWORK_socket_recvfrom
ssize_t GNUNET_NETWORK_socket_recvfrom(const struct GNUNET_NETWORK_Handle *desc, void *buffer, size_t length, struct sockaddr *src_addr, socklen_t *addrlen)
Read data from a socket (always non-blocking).
Definition network.c:688
GNUNET_NETWORK_fdset_create
struct GNUNET_NETWORK_FDSet * GNUNET_NETWORK_fdset_create(void)
Creates an fd set.
Definition network.c:1169
GNUNET_NETWORK_socket_create
struct GNUNET_NETWORK_Handle * GNUNET_NETWORK_socket_create(int domain, int type, int protocol)
Create a new socket.
Definition network.c:833
GNUNET_NETWORK_fdset_set
void GNUNET_NETWORK_fdset_set(struct GNUNET_NETWORK_FDSet *fds, const struct GNUNET_NETWORK_Handle *desc)
Add a socket to the FD set.
Definition network.c:932
GNUNET_NETWORK_socket_bind
enum GNUNET_GenericReturnValue GNUNET_NETWORK_socket_bind(struct GNUNET_NETWORK_Handle *desc, const struct sockaddr *address, socklen_t address_len)
Bind a socket to a particular address.
Definition network.c:439
GNUNET_NETWORK_socket_sendto
ssize_t GNUNET_NETWORK_socket_sendto(const struct GNUNET_NETWORK_Handle *desc, const void *message, size_t length, const struct sockaddr *dest_addr, socklen_t dest_len)
Send data to a particular destination (always non-blocking).
Definition network.c:772
GNUNET_NETWORK_fdset_isset
int GNUNET_NETWORK_fdset_isset(const struct GNUNET_NETWORK_FDSet *fds, const struct GNUNET_NETWORK_Handle *desc)
Check whether a socket is part of the fd set.
Definition network.c:950
GNUNET_SCHEDULER_add_select
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_select(enum GNUNET_SCHEDULER_Priority prio, struct GNUNET_TIME_Relative delay, const struct GNUNET_NETWORK_FDSet *rs, const struct GNUNET_NETWORK_FDSet *ws, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when any of the specified file descriptor set...
Definition scheduler.c:1835
GNUNET_SCHEDULER_get_task_context
const struct GNUNET_SCHEDULER_TaskContext * GNUNET_SCHEDULER_get_task_context(void)
Obtain the reasoning why the current task was started.
Definition scheduler.c:758
GNUNET_SCHEDULER_cancel
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition scheduler.c:980
GNUNET_SCHEDULER_add_now
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition scheduler.c:1304
GNUNET_SCHEDULER_add_delayed
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition scheduler.c:1277
GNUNET_TIME_UNIT_FOREVER_REL
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
Definition gnunet_time_lib.h:196
_
#define _(String)
GNU gettext support macro.
Definition platform.h:179
tc
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition scheduler.c:431
DnsServer
DNS Server used for resolution.
Definition dnsstub.c:103
DnsServer::next
struct DnsServer * next
Kept in a DLL.
Definition dnsstub.c:107
DnsServer::prev
struct DnsServer * prev
Kept in a DLL.
Definition dnsstub.c:112
DnsServer::ss
struct sockaddr_storage ss
IP address of the DNS resolver.
Definition dnsstub.c:117
GNUNET_DNSSTUB_Context
Handle to the stub resolver.
Definition dnsstub.c:125
GNUNET_DNSSTUB_Context::dns_tail
struct DnsServer * dns_tail
DLL of DNS resolvers we use.
Definition dnsstub.c:139
GNUNET_DNSSTUB_Context::num_sockets
unsigned int num_sockets
Length of sockets array.
Definition dnsstub.c:149
GNUNET_DNSSTUB_Context::sockets
struct GNUNET_DNSSTUB_RequestSocket * sockets
Array of all open sockets for DNS requests.
Definition dnsstub.c:129
GNUNET_DNSSTUB_Context::dns_head
struct DnsServer * dns_head
DLL of DNS resolvers we use.
Definition dnsstub.c:134
GNUNET_DNSSTUB_Context::retry_freq
struct GNUNET_TIME_Relative retry_freq
How frequently do we retry requests?
Definition dnsstub.c:144
GNUNET_DNSSTUB_RequestSocket
UDP socket we are using for sending DNS requests to the Internet.
Definition dnsstub.c:46
GNUNET_DNSSTUB_RequestSocket::request
void * request
Query we sent to addr.
Definition dnsstub.c:90
GNUNET_DNSSTUB_RequestSocket::ctx
struct GNUNET_DNSSTUB_Context * ctx
Context this request executes in.
Definition dnsstub.c:85
GNUNET_DNSSTUB_RequestSocket::dnsout4
struct GNUNET_NETWORK_Handle * dnsout4
UDP socket we use for this request for IPv4.
Definition dnsstub.c:50
GNUNET_DNSSTUB_RequestSocket::read_task
struct GNUNET_SCHEDULER_Task * read_task
Task for reading from dnsout4 and dnsout6.
Definition dnsstub.c:70
GNUNET_DNSSTUB_RequestSocket::rc
GNUNET_DNSSTUB_ResultCallback rc
Function to call with result.
Definition dnsstub.c:60
GNUNET_DNSSTUB_RequestSocket::retry_task
struct GNUNET_SCHEDULER_Task * retry_task
Task for retrying transmission of the query.
Definition dnsstub.c:75
GNUNET_DNSSTUB_RequestSocket::dnsout6
struct GNUNET_NETWORK_Handle * dnsout6
UDP socket we use for this request for IPv6.
Definition dnsstub.c:55
GNUNET_DNSSTUB_RequestSocket::request_len
size_t request_len
Number of bytes in request.
Definition dnsstub.c:95
GNUNET_DNSSTUB_RequestSocket::rc_cls
void * rc_cls
Closure for rc.
Definition dnsstub.c:65
GNUNET_DNSSTUB_RequestSocket::ds_pos
struct DnsServer * ds_pos
Next address we sent the DNS request to.
Definition dnsstub.c:80
GNUNET_NETWORK_FDSet
collection of IO descriptors
Definition gnunet_network_lib.h:76
GNUNET_NETWORK_Handle
handle to a socket
Definition network.c:53
GNUNET_NETWORK_Handle::af
int af
Address family / domain.
Definition network.c:59
GNUNET_SCHEDULER_TaskContext
Context information passed to each scheduler task.
Definition gnunet_scheduler_lib.h:182
GNUNET_SCHEDULER_TaskContext::read_ready
const struct GNUNET_NETWORK_FDSet * read_ready
Set of file descriptors ready for reading; note that additional bits may be set that were not in the ...
Definition gnunet_scheduler_lib.h:206
GNUNET_SCHEDULER_Task
Entry in list of pending tasks.
Definition scheduler.c:136
GNUNET_TIME_Relative
Time for relative time used by GNUnet, in microseconds.
Definition gnunet_time_lib.h:79
GNUNET_TUN_DnsHeader
DNS header.
Definition gnunet_tun_lib.h:456

Function Documentation

◆ cleanup_rs()

static void cleanup_rs ( struct GNUNET_DNSSTUB_RequestSocket *  rs)
static

We're done with a struct GNUNET_DNSSTUB_RequestSocket, close it for now.

Parameters
rsrequest socket to clean up

Definition at line 159 of file dnsstub.c.

160{
161 if (NULL != rs->dnsout4)
162 {
163 GNUNET_NETWORK_socket_close (rs->dnsout4);
164 rs->dnsout4 = NULL;
165 }
166 if (NULL != rs->dnsout6)
167 {
168 GNUNET_NETWORK_socket_close (rs->dnsout6);
169 rs->dnsout6 = NULL;
170 }
171 if (NULL != rs->read_task)
172 {
173 GNUNET_SCHEDULER_cancel (rs->read_task);
174 rs->read_task = NULL;
175 }
176 if (NULL != rs->retry_task)
177 {
178 GNUNET_SCHEDULER_cancel (rs->retry_task);
179 rs->retry_task = NULL;
180 }
181 if (NULL != rs->request)
182 {
183 GNUNET_free (rs->request);
184 rs->request = NULL;
185 }
186}

References GNUNET_DNSSTUB_RequestSocket::dnsout4, GNUNET_DNSSTUB_RequestSocket::dnsout6, GNUNET_free, GNUNET_NETWORK_socket_close(), GNUNET_SCHEDULER_cancel(), GNUNET_DNSSTUB_RequestSocket::read_task, GNUNET_DNSSTUB_RequestSocket::request, and GNUNET_DNSSTUB_RequestSocket::retry_task.

Referenced by GNUNET_DNSSTUB_stop().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ open_socket()

static struct GNUNET_NETWORK_Handle * open_socket ( int  af)
static

Open source port for sending DNS requests.

Parameters
afAF_INET or AF_INET6
Returns
GNUNET_OK on success

Definition at line 196 of file dnsstub.c.

197{
198 struct sockaddr_in a4;
199 struct sockaddr_in6 a6;
200 struct sockaddr *sa;
201 socklen_t alen;
202 struct GNUNET_NETWORK_Handle *ret;
203
204 ret = GNUNET_NETWORK_socket_create (af, SOCK_DGRAM, 0);
205 if (NULL == ret)
206 return NULL;
207 switch (af)
208 {
209 case AF_INET:
210 memset (&a4, 0, alen = sizeof(struct sockaddr_in));
211 sa = (struct sockaddr *) &a4;
212 break;
213
214 case AF_INET6:
215 memset (&a6, 0, alen = sizeof(struct sockaddr_in6));
216 sa = (struct sockaddr *) &a6;
217 break;
218
219 default:
220 GNUNET_break (0);
221 GNUNET_NETWORK_socket_close (ret);
222 return NULL;
223 }
224 sa->sa_family = af;
225 if (GNUNET_OK != GNUNET_NETWORK_socket_bind (ret, sa, alen))
226 {
227 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
228 _ ("Could not bind to any port: %s\n"),
229 strerror (errno));
230 GNUNET_NETWORK_socket_close (ret);
231 return NULL;
232 }
233 return ret;
234}

References _, GNUNET_NETWORK_Handle::af, GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_NETWORK_socket_bind(), GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_create(), GNUNET_OK, and ret.

Referenced by transmit_query().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ get_request_socket()

static struct GNUNET_DNSSTUB_RequestSocket * get_request_socket ( struct GNUNET_DNSSTUB_Context *  ctx)
static

Get a socket of the specified address family to send out a UDP DNS request to the Internet.

Parameters
ctxthe DNSSTUB context
Returns
NULL on error

Definition at line 245 of file dnsstub.c.

246{
247 struct GNUNET_DNSSTUB_RequestSocket *rs;
248
249 for (unsigned int i = 0; i < 256; i++)
250 {
251 rs = &ctx->sockets[GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
252 ctx->num_sockets)];
253 if (NULL == rs->rc)
254 break;
255 }
256 if (NULL != rs->rc)
257 {
258 /* signal "failure" */
259 rs->rc (rs->rc_cls, NULL, 0);
260 rs->rc = NULL;
261 }
262 if (NULL != rs->read_task)
263 {
264 GNUNET_SCHEDULER_cancel (rs->read_task);
265 rs->read_task = NULL;
266 }
267 if (NULL != rs->retry_task)
268 {
269 GNUNET_SCHEDULER_cancel (rs->retry_task);
270 rs->retry_task = NULL;
271 }
272 if (NULL != rs->request)
273 {
274 GNUNET_free (rs->request);
275 rs->request = NULL;
276 }
277 rs->ctx = ctx;
278 return rs;
279}

References ctx, GNUNET_DNSSTUB_RequestSocket::ctx, GNUNET_CRYPTO_QUALITY_NONCE, GNUNET_CRYPTO_random_u32(), GNUNET_free, GNUNET_SCHEDULER_cancel(), GNUNET_DNSSTUB_RequestSocket::rc, GNUNET_DNSSTUB_RequestSocket::rc_cls, GNUNET_DNSSTUB_RequestSocket::read_task, GNUNET_DNSSTUB_RequestSocket::request, and GNUNET_DNSSTUB_RequestSocket::retry_task.

Referenced by GNUNET_DNSSTUB_resolve().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ do_dns_read()

static int do_dns_read ( struct GNUNET_DNSSTUB_RequestSocket *  rs,
struct GNUNET_NETWORK_Handle *  dnsout 
)
static

Actually do the reading of a DNS packet from our UDP socket and see if we have a valid, matching, pending request.

Parameters
rsrequest socket with callback details
dnsoutsocket to read from
Returns
GNUNET_OK on success, GNUNET_NO on drop, GNUNET_SYSERR on IO-errors (closed socket)

Definition at line 291 of file dnsstub.c.

293{
294 struct GNUNET_DNSSTUB_Context *ctx = rs->ctx;
295 ssize_t r;
296 int len;
297
298 if (0 != ioctl (GNUNET_NETWORK_get_fd (dnsout), FIONREAD, &len))
299 {
300 /* conservative choice: */
301 len = UINT16_MAX;
302 }
303
304 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Receiving %d byte DNS reply\n", len);
305 {
306 unsigned char buf[len] GNUNET_ALIGN;
307 int found;
308 struct sockaddr_storage addr;
309 socklen_t addrlen;
310 struct GNUNET_TUN_DnsHeader *dns;
311
312 addrlen = sizeof(addr);
313 memset (&addr, 0, sizeof(addr));
314 r = GNUNET_NETWORK_socket_recvfrom (dnsout,
315 buf,
316 sizeof(buf),
317 (struct sockaddr *) &addr,
318 &addrlen);
319 if (-1 == r)
320 {
321 GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "recvfrom");
322 GNUNET_NETWORK_socket_close (dnsout);
323 return GNUNET_SYSERR;
324 }
325 found = GNUNET_NO;
326 for (struct DnsServer *ds = ctx->dns_head; NULL != ds; ds = ds->next)
327 {
328 if (ds->ss.ss_family != addr.ss_family)
329 continue;
330 if (addr.ss_family == AF_INET)
331 {
332 struct sockaddr_in *v4 = (struct sockaddr_in *) &addr;
333 struct sockaddr_in *ds_v4 = (struct sockaddr_in *) &ds->ss;
334
335
336 if ((0 == memcmp (&v4->sin_addr,
337 &ds_v4->sin_addr,
338 sizeof(struct sockaddr_in))) &&
339 (v4->sin_port == ds_v4->sin_port))
340 {
341 found = GNUNET_YES;
342 break;
343 }
344 }
345 else
346 {
347 struct sockaddr_in6 *v6 = (struct sockaddr_in6 *) &addr;
348 struct sockaddr_in6 *ds_v6 = (struct sockaddr_in6 *) &ds->ss;
349
350 if (0 == memcmp (&v6->sin6_addr,
351 &ds_v6->sin6_addr,
352 sizeof (v6->sin6_addr)) &&
353 (v6->sin6_port == ds_v6->sin6_port))
354 {
355 found = GNUNET_YES;
356 break;
357 }
358
359 }
360 }
361 if (GNUNET_NO == found)
362 {
363 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
364 "Received DNS response from server we never asked (ignored)\n");
365
366 return GNUNET_NO;
367 }
368 if (sizeof(struct GNUNET_TUN_DnsHeader) > (size_t) r)
369 {
370 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
371 _ ("Received DNS response that is too small (%u bytes)\n"),
372 (unsigned int) r);
373 return GNUNET_NO;
374 }
375 dns = (struct GNUNET_TUN_DnsHeader *) buf;
376 if (NULL == rs->rc)
377 {
378 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
379 "Request timeout or cancelled; ignoring reply\n");
380 return GNUNET_NO;
381 }
382 rs->rc (rs->rc_cls, dns, r);
383 }
384 return GNUNET_OK;
385}

References _, ctx, GNUNET_DNSSTUB_RequestSocket::ctx, ds, GNUNET_ALIGN, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_log_strerror, GNUNET_NETWORK_get_fd(), GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_recvfrom(), GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, GNUNET_DNSSTUB_RequestSocket::rc, and GNUNET_DNSSTUB_RequestSocket::rc_cls.

Referenced by read_response().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ read_response()

static void read_response ( void *  cls)
static

Read a DNS response from the (unhindered) UDP-Socket.

Parameters
clsstruct GNUNET_DNSSTUB_RequestSocket to read from

Definition at line 426 of file dnsstub.c.

427{
428 struct GNUNET_DNSSTUB_RequestSocket *rs = cls;
429 const struct GNUNET_SCHEDULER_TaskContext *tc;
430
431 rs->read_task = NULL;
432 tc = GNUNET_SCHEDULER_get_task_context ();
433 /* read and process ready sockets */
434 if ((NULL != rs->dnsout4) &&
435 (GNUNET_NETWORK_fdset_isset (tc->read_ready, rs->dnsout4)) &&
436 (GNUNET_SYSERR == do_dns_read (rs, rs->dnsout4)))
437 rs->dnsout4 = NULL;
438 if ((NULL != rs->dnsout6) &&
439 (GNUNET_NETWORK_fdset_isset (tc->read_ready, rs->dnsout6)) &&
440 (GNUNET_SYSERR == do_dns_read (rs, rs->dnsout6)))
441 rs->dnsout6 = NULL;
442 /* re-schedule read task */
443 schedule_read (rs);
444}

References GNUNET_DNSSTUB_RequestSocket::dnsout4, GNUNET_DNSSTUB_RequestSocket::dnsout6, do_dns_read(), GNUNET_NETWORK_fdset_isset(), GNUNET_SCHEDULER_get_task_context(), GNUNET_SYSERR, GNUNET_SCHEDULER_TaskContext::read_ready, GNUNET_DNSSTUB_RequestSocket::read_task, schedule_read(), and tc.

Referenced by schedule_read().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ schedule_read()

static void schedule_read ( struct GNUNET_DNSSTUB_RequestSocket *  rs)
static

Schedule read_response() task for rs.

Parameters
rsrequest to schedule read operation for

Definition at line 403 of file dnsstub.c.

404{
405 struct GNUNET_NETWORK_FDSet *rset;
406
407 if (NULL != rs->read_task)
408 GNUNET_SCHEDULER_cancel (rs->read_task);
409 rset = GNUNET_NETWORK_fdset_create ();
410 if (NULL != rs->dnsout4)
411 GNUNET_NETWORK_fdset_set (rset, rs->dnsout4);
412 if (NULL != rs->dnsout6)
413 GNUNET_NETWORK_fdset_set (rset, rs->dnsout6);
414 rs->read_task =
415 GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
416 GNUNET_TIME_UNIT_FOREVER_REL,
417 rset,
418 NULL,
419 &read_response,
420 rs);
421 GNUNET_NETWORK_fdset_destroy (rset);
422}

References GNUNET_DNSSTUB_RequestSocket::dnsout4, GNUNET_DNSSTUB_RequestSocket::dnsout6, GNUNET_NETWORK_fdset_create(), GNUNET_NETWORK_fdset_destroy(), GNUNET_NETWORK_fdset_set(), GNUNET_SCHEDULER_add_select(), GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_PRIORITY_DEFAULT, GNUNET_TIME_UNIT_FOREVER_REL, read_response(), and GNUNET_DNSSTUB_RequestSocket::read_task.

Referenced by read_response(), and transmit_query().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ transmit_query()

static void transmit_query ( void *  cls)
static

Task to (re)transmit the DNS query, possibly repeatedly until we succeed.

Parameters
clsour struct GNUNET_DNSSTUB_RequestSocket *

Definition at line 454 of file dnsstub.c.

455{
456 struct GNUNET_DNSSTUB_RequestSocket *rs = cls;
457 struct GNUNET_DNSSTUB_Context *ctx = rs->ctx;
458 const struct sockaddr *sa;
459 socklen_t salen;
460 struct DnsServer *ds;
461 struct GNUNET_NETWORK_Handle *dnsout;
462
463 rs->retry_task =
464 GNUNET_SCHEDULER_add_delayed (ctx->retry_freq, &transmit_query, rs);
465 ds = rs->ds_pos;
466 rs->ds_pos = ds->next;
467 if (NULL == rs->ds_pos)
468 rs->ds_pos = ctx->dns_head;
469 GNUNET_assert (NULL != ds);
470 dnsout = NULL;
471 switch (ds->ss.ss_family)
472 {
473 case AF_INET:
474 if (NULL == rs->dnsout4)
475 rs->dnsout4 = open_socket (AF_INET);
476 dnsout = rs->dnsout4;
477 sa = (const struct sockaddr *) &ds->ss;
478 salen = sizeof(struct sockaddr_in);
479 break;
480
481 case AF_INET6:
482 if (NULL == rs->dnsout6)
483 rs->dnsout6 = open_socket (AF_INET6);
484 dnsout = rs->dnsout6;
485 sa = (const struct sockaddr *) &ds->ss;
486 salen = sizeof(struct sockaddr_in6);
487 break;
488
489 default:
490 return;
491 }
492 if (NULL == dnsout)
493 {
494 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
495 "Unable to use configure DNS server, skipping\n");
496 return;
497 }
498 if (GNUNET_SYSERR == GNUNET_NETWORK_socket_sendto (dnsout,
499 rs->request,
500 rs->request_len,
501 sa,
502 salen))
503 GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
504 _ ("Failed to send DNS request to %s: %s\n"),
505 GNUNET_a2s (sa, salen),
506 strerror (errno));
507 else
508 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
509 _ ("Sent DNS request to %s\n"),
510 GNUNET_a2s (sa, salen));
511 schedule_read (rs);
512}

References _, ctx, GNUNET_DNSSTUB_RequestSocket::ctx, GNUNET_DNSSTUB_RequestSocket::dnsout4, GNUNET_DNSSTUB_RequestSocket::dnsout6, ds, GNUNET_DNSSTUB_RequestSocket::ds_pos, GNUNET_a2s(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_NETWORK_socket_sendto(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SYSERR, open_socket(), GNUNET_DNSSTUB_RequestSocket::request, GNUNET_DNSSTUB_RequestSocket::request_len, GNUNET_DNSSTUB_RequestSocket::retry_task, schedule_read(), and transmit_query().

Referenced by GNUNET_DNSSTUB_resolve(), and transmit_query().

Here is the call graph for this function:
Here is the caller graph for this function: