GNUnet 0.25.0
 
Loading...
Searching...
No Matches
Data Structures | Macros | Functions | Variables
resolver_api.c File Reference

resolver for writing a tool More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_resolver_service.h"
#include "resolver.h"
Include dependency graph for resolver_api.c:

Go to the source code of this file.

Data Structures

struct  GNUNET_RESOLVER_RequestHandle
 Handle to a request given to the resolver. More...
 

Macros

#define LOG(kind, ...)   GNUNET_log_from (kind, "util-resolver-api", __VA_ARGS__)
 
#define LOG_STRERROR(kind, syscall)
 
#define MAX_HOSTNAME   1024
 Maximum supported length for a hostname.
 

Functions

static int check_config ()
 Check that the resolver service runs on localhost (or equivalent).
 
void GNUNET_RESOLVER_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
 Create the connection to the resolver service.
 
void GNUNET_RESOLVER_disconnect ()
 Destroy the connection to the resolver service.
 
static void shutdown_task (void *cls)
 Task executed on system shutdown.
 
static void check_disconnect ()
 Consider disconnecting if we have no further requests pending.
 
static char * no_resolve (int af, const void *ip, socklen_t ip_len)
 Convert IP address to string without DNS resolution.
 
static void reconnect (void)
 Adjust exponential back-off and reconnect to the service.
 
static void mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
 Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue.
 
static void process_requests ()
 Process pending requests to the resolver.
 
static int check_response (void *cls, const struct GNUNET_RESOLVER_ResponseMessage *msg)
 Check validity of response with a hostname for a DNS lookup.
 
static void handle_response (void *cls, const struct GNUNET_RESOLVER_ResponseMessage *msg)
 Check validity of response with a hostname for a DNS lookup.
 
static void numeric_resolution (void *cls)
 We've been asked to lookup the address for a hostname and were given a valid numeric string.
 
static void loopback_resolution (void *cls)
 We've been asked to lookup the address for a hostname and were given a variant of "loopback".
 
static void reconnect_task (void *cls)
 Now try to reconnect to the resolver service.
 
static void handle_lookup_timeout (void *cls)
 A DNS resolution timed out.
 
struct GNUNET_RESOLVER_RequestHandle * GNUNET_RESOLVER_ip_get (const char *hostname, int af, struct GNUNET_TIME_Relative timeout, GNUNET_RESOLVER_AddressCallback callback, void *callback_cls)
 Convert a string to one or more IP addresses.
 
static void numeric_reverse (void *cls)
 We've been asked to convert an address to a string without a reverse lookup, either because the client asked for it or because the DNS lookup hit a timeout.
 
struct GNUNET_RESOLVER_RequestHandle * GNUNET_RESOLVER_hostname_get (const struct sockaddr *sa, socklen_t salen, int do_resolve, struct GNUNET_TIME_Relative timeout, GNUNET_RESOLVER_HostnameCallback callback, void *cls)
 Get an IP address as a string.
 
char * GNUNET_RESOLVER_local_fqdn_get ()
 Get local fully qualified af name.
 
struct GNUNET_RESOLVER_RequestHandle * GNUNET_RESOLVER_hostname_resolve (int af, struct GNUNET_TIME_Relative timeout, GNUNET_RESOLVER_AddressCallback callback, void *cls)
 Looking our own hostname.
 
void GNUNET_RESOLVER_request_cancel (struct GNUNET_RESOLVER_RequestHandle *rh)
 Cancel a request that is still pending with the resolver.
 

Variables

static const char * loopback []
 Possible hostnames for "loopback".
 
static const struct GNUNET_CONFIGURATION_Handle * resolver_cfg
 Configuration.
 
static struct GNUNET_MQ_Handle * mq
 Our connection to the resolver service, created on-demand, but then persists until error or shutdown.
 
static struct GNUNET_RESOLVER_RequestHandle * req_head
 Head of DLL of requests.
 
static struct GNUNET_RESOLVER_RequestHandle * req_tail
 Tail of DLL of requests.
 
static uint32_t last_request_id
 ID of the last request we sent to the service.
 
static struct GNUNET_TIME_Relative backoff
 How long should we wait to reconnect?
 
static struct GNUNET_SCHEDULER_Task * r_task
 Task for reconnecting.
 
static struct GNUNET_SCHEDULER_Task * s_task
 Task ID of shutdown task; only present while we have a connection to the resolver service.
 

Detailed Description

resolver for writing a tool

Author
Christian Grothoff

Definition in file resolver_api.c.

Macro Definition Documentation

◆ LOG

#define LOG (   kind,
  ... 
)    GNUNET_log_from (kind, "util-resolver-api", __VA_ARGS__)

Definition at line 33 of file resolver_api.c.

◆ LOG_STRERROR

#define LOG_STRERROR (   kind,
  syscall 
)
Value:
GNUNET_log_from_strerror (kind, \
"util-resolver-api", \
syscall)
GNUNET_log_from_strerror
#define GNUNET_log_from_strerror(level, component, cmd)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
Definition gnunet_common.h:1106

Definition at line 35 of file resolver_api.c.

47 {
48 "localhost",
49 "ip6-localnet",
50 NULL
51};
52
53
57static const struct GNUNET_CONFIGURATION_Handle *resolver_cfg;
58
63static struct GNUNET_MQ_Handle *mq;
64
68static struct GNUNET_RESOLVER_RequestHandle *req_head;
69
73static struct GNUNET_RESOLVER_RequestHandle *req_tail;
74
78static uint32_t last_request_id;
79
83static struct GNUNET_TIME_Relative backoff;
84
88static struct GNUNET_SCHEDULER_Task *r_task;
89
94static struct GNUNET_SCHEDULER_Task *s_task;
95
96
102struct GNUNET_RESOLVER_RequestHandle
103{
107 struct GNUNET_RESOLVER_RequestHandle *next;
108
112 struct GNUNET_RESOLVER_RequestHandle *prev;
113
118 GNUNET_RESOLVER_AddressCallback addr_callback;
119
124 GNUNET_RESOLVER_HostnameCallback name_callback;
125
129 void *cls;
130
134 struct GNUNET_TIME_Absolute timeout;
135
140 struct GNUNET_SCHEDULER_Task *task;
141
145 int af;
146
150 uint32_t id;
151
158 int was_transmitted;
159
163 int was_queued;
164
168 int direction;
169
173 int received_response;
174
178 size_t data_len;
179};
180
181
189static int
190check_config ()
191{
192 char *hostname;
193 struct sockaddr_in v4;
194 struct sockaddr_in6 v6;
195
196 if (GNUNET_OK ==
197 GNUNET_CONFIGURATION_have_value (resolver_cfg,
198 "resolver",
199 "UNIXPATH"))
200 return GNUNET_OK;
201 memset (&v4, 0, sizeof(v4));
202 v4.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
203 v4.sin_family = AF_INET;
204#if HAVE_SOCKADDR_IN_SIN_LEN
205 v4.sin_len = sizeof(v4);
206#endif
207 memset (&v6, 0, sizeof(v6));
208 v6.sin6_family = AF_INET6;
209#if HAVE_SOCKADDR_IN_SIN_LEN
210 v6.sin6_len = sizeof(v6);
211#endif
212 if (GNUNET_OK !=
213 GNUNET_CONFIGURATION_get_value_string (resolver_cfg,
214 "resolver",
215 "HOSTNAME",
216 &hostname))
217 {
218 LOG (GNUNET_ERROR_TYPE_INFO,
219 _ (
220 "Missing `%s' for `%s' in configuration, DNS resolution will be unavailable.\n"),
221 "HOSTNAME",
222 "resolver");
223 return GNUNET_SYSERR;
224 }
225 if ((1 == inet_pton (AF_INET, hostname, &v4)) ||
226 (1 == inet_pton (AF_INET6, hostname, &v6)))
227 {
228 GNUNET_free (hostname);
229 return GNUNET_OK;
230 }
231 for (unsigned int i = 0;
232 NULL != loopback[i];
233 i++)
234 if (0 == strcasecmp (loopback[i],
235 hostname))
236 {
237 GNUNET_free (hostname);
238 return GNUNET_OK;
239 }
240 LOG (GNUNET_ERROR_TYPE_INFO,
241 _ (
242 "Missing `%s' or numeric IP address for `%s' of `%s' in configuration, DNS resolution will be unavailable.\n"),
243 "localhost",
244 "HOSTNAME",
245 "resolver");
246 GNUNET_free (hostname);
247 return GNUNET_SYSERR;
248}
249
250
256void
257GNUNET_RESOLVER_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
258{
259 GNUNET_assert (NULL != cfg);
260 backoff = GNUNET_TIME_UNIT_MILLISECONDS;
261 resolver_cfg = cfg;
262}
263
264
268void
269GNUNET_RESOLVER_disconnect ()
270{
271 struct GNUNET_RESOLVER_RequestHandle *rh;
272
273 while (NULL != (rh = req_head))
274 {
275 GNUNET_assert (GNUNET_SYSERR == rh->was_transmitted);
276 GNUNET_CONTAINER_DLL_remove (req_head,
277 req_tail,
278 rh);
279 GNUNET_free (rh);
280 }
281 if (NULL != mq)
282 {
283 LOG (GNUNET_ERROR_TYPE_DEBUG,
284 "Disconnecting from DNS service\n");
285 GNUNET_MQ_destroy (mq);
286 mq = NULL;
287 }
288 if (NULL != r_task)
289 {
290 GNUNET_SCHEDULER_cancel (r_task);
291 r_task = NULL;
292 }
293 if (NULL != s_task)
294 {
295 GNUNET_SCHEDULER_cancel (s_task);
296 s_task = NULL;
297 }
298}
299
300
304static void
305shutdown_task (void *cls)
306{
307 (void) cls;
308 s_task = NULL;
309 GNUNET_RESOLVER_disconnect ();
310 backoff = GNUNET_TIME_UNIT_MILLISECONDS;
311}
312
313
317static void
318check_disconnect ()
319{
320 for (struct GNUNET_RESOLVER_RequestHandle *rh = req_head;
321 NULL != rh;
322 rh = rh->next)
323 if (GNUNET_SYSERR != rh->was_transmitted)
324 return;
325 if (NULL != r_task)
326 {
327 GNUNET_SCHEDULER_cancel (r_task);
328 r_task = NULL;
329 }
330 if (NULL != s_task)
331 return;
332 s_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
333 &shutdown_task,
334 NULL);
335}
336
337
346static char *
347no_resolve (int af,
348 const void *ip,
349 socklen_t ip_len)
350{
351 char buf[INET6_ADDRSTRLEN];
352
353 switch (af)
354 {
355 case AF_INET:
356 if (ip_len != sizeof(struct in_addr))
357 return NULL;
358 if (NULL ==
359 inet_ntop (AF_INET,
360 ip,
361 buf,
362 sizeof(buf)))
363 {
364 LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
365 "inet_ntop");
366 return NULL;
367 }
368 break;
369
370 case AF_INET6:
371 if (ip_len != sizeof(struct in6_addr))
372 return NULL;
373 if (NULL ==
374 inet_ntop (AF_INET6,
375 ip,
376 buf,
377 sizeof(buf)))
378 {
379 LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
380 "inet_ntop");
381 return NULL;
382 }
383 break;
384
385 default:
386 GNUNET_break (0);
387 return NULL;
388 }
389 return GNUNET_strdup (buf);
390}
391
392
396static void
397reconnect (void);
398
399
408static void
409mq_error_handler (void *cls,
410 enum GNUNET_MQ_Error error)
411{
412 (void) cls;
413 GNUNET_MQ_destroy (mq);
414 mq = NULL;
415 LOG (GNUNET_ERROR_TYPE_DEBUG,
416 "MQ error %d, reconnecting\n",
417 error);
418 reconnect ();
419}
420
421
425static void
426process_requests ()
427{
428 struct GNUNET_RESOLVER_GetMessage *msg;
429 struct GNUNET_MQ_Envelope *env;
430 struct GNUNET_RESOLVER_RequestHandle *rh = req_head;
431
432 if (NULL == mq)
433 {
434 reconnect ();
435 return;
436 }
437 if (NULL == rh)
438 {
439 /* nothing to do, release socket really soon if there is nothing
440 * else happening... */
441 if (NULL == s_task)
442 s_task =
443 GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
444 &shutdown_task,
445 NULL);
446 return;
447 }
448 if (GNUNET_NO != rh->was_transmitted)
449 return; /* waiting for reply */
450 env = GNUNET_MQ_msg_extra (msg,
451 rh->data_len,
452 GNUNET_MESSAGE_TYPE_RESOLVER_REQUEST);
453 msg->direction = htonl (rh->direction);
454 msg->af = htonl (rh->af);
455 msg->client_id = rh->id;
456 GNUNET_memcpy (&msg[1],
457 &rh[1],
458 rh->data_len);
459 LOG (GNUNET_ERROR_TYPE_DEBUG,
460 "Transmitting DNS resolution request (ID %u) to DNS service\n",
461 rh->id);
462 GNUNET_MQ_send (mq,
463 env);
464 rh->was_transmitted = GNUNET_YES;
465}
466
467
474static int
475check_response (void *cls,
476 const struct GNUNET_RESOLVER_ResponseMessage *msg)
477{
478 (void) cls;
479 (void) msg;
480
481 /* implemented in #handle_response() for now */
482 return GNUNET_OK;
483}
484
485
494static void
495handle_response (void *cls,
496 const struct GNUNET_RESOLVER_ResponseMessage *msg)
497{
498 struct GNUNET_RESOLVER_RequestHandle *rh = req_head;
499 uint16_t size;
500 char *nret;
501 uint32_t client_request_id = msg->client_id;
502
503 for (; rh != NULL; rh = rh->next)
504 {
505 if (rh->id == client_request_id)
506 break;
507 }
508
509 (void) cls;
510 if (NULL == rh)
511 {
512 /* Resolver service sent extra replies to query (after terminator)? Bad! */
513 GNUNET_break (0);
514 GNUNET_MQ_destroy (mq);
515 mq = NULL;
516 reconnect ();
517 return;
518 }
519 size = ntohs (msg->header.size);
520 if (size == sizeof(struct GNUNET_RESOLVER_ResponseMessage))
521 {
522 LOG (GNUNET_ERROR_TYPE_DEBUG,
523 "Received empty response from DNS service\n");
524 /* message contains not data, just header; end of replies */
525 /* check if request was canceled */
526 if (GNUNET_SYSERR != rh->was_transmitted)
527 {
528 /* no reverse lookup was successful, return IP as string */
529 if (NULL != rh->name_callback)
530 {
531 if (GNUNET_NO == rh->received_response)
532 {
533 nret = no_resolve (rh->af,
534 &rh[1],
535 rh->data_len);
536 rh->name_callback (rh->cls, nret);
537 GNUNET_free (nret);
538 }
539 /* finally, make termination call */
540 if (GNUNET_SYSERR != rh->was_transmitted)
541 rh->name_callback (rh->cls,
542 NULL);
543 }
544 if ((NULL != rh->addr_callback) &&
545 (GNUNET_SYSERR != rh->was_transmitted))
546 rh->addr_callback (rh->cls,
547 NULL,
548 0);
549 }
550 rh->was_transmitted = GNUNET_NO;
551 GNUNET_RESOLVER_request_cancel (rh);
552 process_requests ();
553 return;
554 }
555 /* return reverse lookup results to caller */
556 if (NULL != rh->name_callback)
557 {
558 const char *hostname;
559
560 hostname = (const char *) &msg[1];
561 if (hostname[size - sizeof(struct GNUNET_RESOLVER_ResponseMessage) - 1] !=
562 '\0')
563 {
564 GNUNET_break (0);
565 if (GNUNET_SYSERR != rh->was_transmitted)
566 rh->name_callback (rh->cls,
567 NULL);
568 rh->was_transmitted = GNUNET_NO;
569 GNUNET_RESOLVER_request_cancel (rh);
570 GNUNET_MQ_destroy (mq);
571 mq = NULL;
572 reconnect ();
573 return;
574 }
575 LOG (GNUNET_ERROR_TYPE_DEBUG,
576 "Resolver returns `%s' for IP `%s'.\n",
577 hostname,
578 GNUNET_a2s ((const void *) &rh[1],
579 rh->data_len));
580 if (rh->was_transmitted != GNUNET_SYSERR)
581 rh->name_callback (rh->cls,
582 hostname);
583 rh->received_response = GNUNET_YES;
584 }
585 /* return lookup results to caller */
586 if (NULL != rh->addr_callback)
587 {
588 struct sockaddr_in v4;
589 struct sockaddr_in6 v6;
590 const struct sockaddr *sa;
591 socklen_t salen;
592 const void *ip;
593 size_t ip_len;
594
595 ip = &msg[1];
596 ip_len = size - sizeof(struct GNUNET_RESOLVER_ResponseMessage);
597 if (ip_len == sizeof(struct in_addr))
598 {
599 memset (&v4, 0, sizeof(v4));
600 v4.sin_family = AF_INET;
601 v4.sin_addr = *(struct in_addr*) ip;
602#if HAVE_SOCKADDR_IN_SIN_LEN
603 v4.sin_len = sizeof(v4);
604#endif
605 salen = sizeof(v4);
606 sa = (const struct sockaddr *) &v4;
607 }
608 else if (ip_len == sizeof(struct in6_addr))
609 {
610 memset (&v6, 0, sizeof(v6));
611 v6.sin6_family = AF_INET6;
612 v6.sin6_addr = *(struct in6_addr*) ip;
613#if HAVE_SOCKADDR_IN_SIN_LEN
614 v6.sin6_len = sizeof(v6);
615#endif
616 salen = sizeof(v6);
617 sa = (const struct sockaddr *) &v6;
618 }
619 else
620 {
621 GNUNET_break (0);
622 if (GNUNET_SYSERR != rh->was_transmitted)
623 rh->addr_callback (rh->cls,
624 NULL,
625 0);
626 rh->was_transmitted = GNUNET_NO;
627 GNUNET_RESOLVER_request_cancel (rh);
628 GNUNET_MQ_destroy (mq);
629 mq = NULL;
630 reconnect ();
631 return;
632 }
633 LOG (GNUNET_ERROR_TYPE_DEBUG,
634 "Received IP from DNS service\n");
635 if (GNUNET_SYSERR != rh->was_transmitted)
636 rh->addr_callback (rh->cls,
637 sa,
638 salen);
639 }
640}
641
642
650static void
651numeric_resolution (void *cls)
652{
653 struct GNUNET_RESOLVER_RequestHandle *rh = cls;
654 struct sockaddr_in v4;
655 struct sockaddr_in6 v6;
656 const char *hostname;
657
658 rh->task = NULL;
659 memset (&v4, 0, sizeof(v4));
660 v4.sin_family = AF_INET;
661#if HAVE_SOCKADDR_IN_SIN_LEN
662 v4.sin_len = sizeof(v4);
663#endif
664 memset (&v6, 0, sizeof(v6));
665 v6.sin6_family = AF_INET6;
666#if HAVE_SOCKADDR_IN_SIN_LEN
667 v6.sin6_len = sizeof(v6);
668#endif
669 hostname = (const char *) &rh[1];
670 if (((rh->af == AF_UNSPEC) ||
671 (rh->af == AF_INET)) &&
672 (1 == inet_pton (AF_INET,
673 hostname,
674 &v4.sin_addr)))
675 {
676 rh->addr_callback (rh->cls,
677 (const struct sockaddr *) &v4,
678 sizeof(v4));
679 if ((rh->af == AF_UNSPEC) &&
680 (GNUNET_SYSERR != rh->was_transmitted) &&
681 (1 == inet_pton (AF_INET6,
682 hostname,
683 &v6.sin6_addr)))
684 {
685 /* this can happen on some systems IF "hostname" is "localhost" */
686 rh->addr_callback (rh->cls,
687 (const struct sockaddr *) &v6,
688 sizeof(v6));
689 }
690 if (GNUNET_SYSERR != rh->was_transmitted)
691 rh->addr_callback (rh->cls,
692 NULL,
693 0);
694 GNUNET_free (rh);
695 return;
696 }
697 if (((rh->af == AF_UNSPEC) ||
698 (rh->af == AF_INET6)) &&
699 (1 == inet_pton (AF_INET6,
700 hostname,
701 &v6.sin6_addr)))
702 {
703 rh->addr_callback (rh->cls,
704 (const struct sockaddr *) &v6,
705 sizeof(v6));
706 if (GNUNET_SYSERR != rh->was_transmitted)
707 rh->addr_callback (rh->cls,
708 NULL,
709 0);
710 GNUNET_free (rh);
711 return;
712 }
713 /* why are we here? this task should not have been scheduled! */
714 GNUNET_assert (0);
715 GNUNET_free (rh);
716}
717
718
726static void
727loopback_resolution (void *cls)
728{
729 struct GNUNET_RESOLVER_RequestHandle *rh = cls;
730 struct sockaddr_in v4;
731 struct sockaddr_in6 v6;
732
733 rh->task = NULL;
734 memset (&v4, 0, sizeof(v4));
735 v4.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
736 v4.sin_family = AF_INET;
737#if HAVE_SOCKADDR_IN_SIN_LEN
738 v4.sin_len = sizeof(v4);
739#endif
740 memset (&v6, 0, sizeof(v6));
741 v6.sin6_family = AF_INET6;
742#if HAVE_SOCKADDR_IN_SIN_LEN
743 v6.sin6_len = sizeof(v6);
744#endif
745 v6.sin6_addr = in6addr_loopback;
746 switch (rh->af)
747 {
748 case AF_INET:
749 rh->addr_callback (rh->cls,
750 (const struct sockaddr *) &v4,
751 sizeof(v4));
752 break;
753
754 case AF_INET6:
755 rh->addr_callback (rh->cls,
756 (const struct sockaddr *) &v6,
757 sizeof(v6));
758 break;
759
760 case AF_UNSPEC:
761 rh->addr_callback (rh->cls,
762 (const struct sockaddr *) &v6,
763 sizeof(v6));
764 rh->addr_callback (rh->cls,
765 (const struct sockaddr *) &v4,
766 sizeof(v4));
767
768 break;
769
770 default:
771 GNUNET_break (0);
772 break;
773 }
774 if (GNUNET_SYSERR != rh->was_transmitted)
775 rh->addr_callback (rh->cls,
776 NULL,
777 0);
778 LOG (GNUNET_ERROR_TYPE_DEBUG,
779 "Finished resolving hostname `%s'.\n",
780 (const char *) &rh[1]);
781 GNUNET_free (rh);
782}
783
784
790static void
791reconnect_task (void *cls)
792{
793 struct GNUNET_MQ_MessageHandler handlers[] = {
794 GNUNET_MQ_hd_var_size (response,
795 GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE,
796 struct GNUNET_RESOLVER_ResponseMessage,
797 NULL),
798 GNUNET_MQ_handler_end ()
799 };
800
801 (void) cls;
802 r_task = NULL;
803 if (NULL == req_head)
804 return; /* no work pending */
805 LOG (GNUNET_ERROR_TYPE_DEBUG,
806 "Trying to connect to DNS service\n");
807 mq = GNUNET_CLIENT_connect (resolver_cfg,
808 "resolver",
809 handlers,
810 &mq_error_handler,
811 NULL);
812 if (NULL == mq)
813 {
814 LOG (GNUNET_ERROR_TYPE_DEBUG,
815 "Failed to connect, will try again later\n");
816 reconnect ();
817 return;
818 }
819 process_requests ();
820}
821
822
826static void
827reconnect ()
828{
829 struct GNUNET_RESOLVER_RequestHandle *rh;
830
831 if (NULL != r_task)
832 return;
833 GNUNET_assert (NULL == mq);
834 if (NULL != (rh = req_head))
835 {
836 switch (rh->was_transmitted)
837 {
838 case GNUNET_NO:
839 /* nothing more to do */
840 break;
841
842 case GNUNET_YES:
843 /* disconnected, transmit again! */
844 rh->was_transmitted = GNUNET_NO;
845 break;
846
847 case GNUNET_SYSERR:
848 /* request was cancelled, remove entirely */
849 GNUNET_CONTAINER_DLL_remove (req_head,
850 req_tail,
851 rh);
852 GNUNET_free (rh);
853 check_disconnect ();
854 break;
855
856 default:
857 GNUNET_assert (0);
858 break;
859 }
860 }
861 LOG (GNUNET_ERROR_TYPE_DEBUG,
862 "Will try to connect to DNS service in %s\n",
863 GNUNET_STRINGS_relative_time_to_string (backoff,
864 GNUNET_YES));
865 GNUNET_assert (NULL != resolver_cfg);
866 r_task = GNUNET_SCHEDULER_add_delayed (backoff,
867 &reconnect_task,
868 NULL);
869 backoff = GNUNET_TIME_STD_BACKOFF (backoff);
870}
871
872
878static void
879handle_lookup_timeout (void *cls)
880{
881 struct GNUNET_RESOLVER_RequestHandle *rh = cls;
882
883 rh->task = NULL;
884 if (GNUNET_NO == rh->direction)
885 {
886 LOG (GNUNET_ERROR_TYPE_INFO,
887 _ ("Timeout trying to resolve hostname `%s'.\n"),
888 (const char *) &rh[1]);
889 if (NULL != rh->addr_callback)
890 rh->addr_callback (rh->cls,
891 NULL,
892 0);
893 }
894 else
895 {
896#if ! defined(GNUNET_CULL_LOGGING)
897 char buf[INET6_ADDRSTRLEN];
898
899 LOG (GNUNET_ERROR_TYPE_INFO,
900 _ ("Timeout trying to resolve IP address `%s'.\n"),
901 inet_ntop (rh->af,
902 (const void *) &rh[1],
903 buf,
904 sizeof(buf)));
905#endif
906 if (GNUNET_NO == rh->received_response)
907 {
908 char *nret;
909
910 nret = no_resolve (rh->af,
911 &rh[1],
912 rh->data_len);
913 if (NULL != rh->name_callback)
914 rh->name_callback (rh->cls, nret);
915 GNUNET_free (nret);
916 }
917 /* finally, make termination call */
918 if (NULL != rh->name_callback)
919 rh->name_callback (rh->cls,
920 NULL);
921 }
922 rh->was_transmitted = GNUNET_NO;
923 GNUNET_RESOLVER_request_cancel (rh);
924 process_requests ();
925}
926
927
938struct GNUNET_RESOLVER_RequestHandle *
939GNUNET_RESOLVER_ip_get (const char *hostname,
940 int af,
941 struct GNUNET_TIME_Relative timeout,
942 GNUNET_RESOLVER_AddressCallback callback,
943 void *callback_cls)
944{
945 struct GNUNET_RESOLVER_RequestHandle *rh;
946 size_t slen;
947 struct in_addr v4;
948 struct in6_addr v6;
949
950 slen = strlen (hostname) + 1;
951 if (slen + sizeof(struct GNUNET_RESOLVER_GetMessage) >=
952 GNUNET_MAX_MESSAGE_SIZE)
953 {
954 GNUNET_break (0);
955 return NULL;
956 }
957 LOG (GNUNET_ERROR_TYPE_DEBUG,
958 "Trying to resolve hostname `%s'.\n",
959 hostname);
960 rh = GNUNET_malloc (sizeof(struct GNUNET_RESOLVER_RequestHandle) + slen);
961 rh->af = af;
962 rh->id = ++last_request_id;
963 rh->addr_callback = callback;
964 rh->cls = callback_cls;
965 GNUNET_memcpy (&rh[1],
966 hostname,
967 slen);
968 rh->data_len = slen;
969 rh->timeout = GNUNET_TIME_relative_to_absolute (timeout);
970 rh->direction = GNUNET_NO;
971 /* first, check if this is a numeric address */
972 if (((1 == inet_pton (AF_INET,
973 hostname,
974 &v4)) &&
975 ((af == AF_INET) ||
976 (af == AF_UNSPEC))) ||
977 ((1 == inet_pton (AF_INET6,
978 hostname,
979 &v6)) &&
980 ((af == AF_INET6) ||
981 (af == AF_UNSPEC))))
982 {
983 rh->task = GNUNET_SCHEDULER_add_now (&numeric_resolution,
984 rh);
985 return rh;
986 }
987 /* then, check if this is a loopback address */
988 for (unsigned int i = 0;
989 NULL != loopback[i];
990 i++)
991 if (0 == strcasecmp (loopback[i],
992 hostname))
993 {
994 rh->task = GNUNET_SCHEDULER_add_now (&loopback_resolution,
995 rh);
996 return rh;
997 }
998 if (GNUNET_OK != check_config ())
999 {
1000 GNUNET_free (rh);
1001 return NULL;
1002 }
1003 rh->task = GNUNET_SCHEDULER_add_delayed (timeout,
1004 &handle_lookup_timeout,
1005 rh);
1006 GNUNET_CONTAINER_DLL_insert_tail (req_head,
1007 req_tail,
1008 rh);
1009 rh->was_queued = GNUNET_YES;
1010 if (NULL != s_task)
1011 {
1012 GNUNET_SCHEDULER_cancel (s_task);
1013 s_task = NULL;
1014 }
1015 process_requests ();
1016 return rh;
1017}
1018
1019
1028static void
1029numeric_reverse (void *cls)
1030{
1031 struct GNUNET_RESOLVER_RequestHandle *rh = cls;
1032 char *result;
1033
1034 rh->task = NULL;
1035 result = no_resolve (rh->af,
1036 &rh[1],
1037 rh->data_len);
1038 LOG (GNUNET_ERROR_TYPE_DEBUG,
1039 "Resolver returns `%s'.\n",
1040 result);
1041 if (NULL != result)
1042 {
1043 rh->name_callback (rh->cls,
1044 result);
1045 GNUNET_free (result);
1046 }
1047 rh->name_callback (rh->cls,
1048 NULL);
1049 if (NULL != rh->task)
1050 {
1051 GNUNET_SCHEDULER_cancel (rh->task);
1052 rh->task = NULL;
1053 }
1054 GNUNET_free (rh);
1055}
1056
1057
1070struct GNUNET_RESOLVER_RequestHandle *
1071GNUNET_RESOLVER_hostname_get (const struct sockaddr *sa,
1072 socklen_t salen,
1073 int do_resolve,
1074 struct GNUNET_TIME_Relative timeout,
1075 GNUNET_RESOLVER_HostnameCallback callback,
1076 void *cls)
1077{
1078 struct GNUNET_RESOLVER_RequestHandle *rh;
1079 size_t ip_len;
1080 const void *ip;
1081
1082 if (GNUNET_OK != check_config ())
1083 {
1084 LOG (GNUNET_ERROR_TYPE_ERROR,
1085 _ ("Resolver not configured correctly.\n"));
1086 return NULL;
1087 }
1088
1089 switch (sa->sa_family)
1090 {
1091 case AF_INET:
1092 GNUNET_assert (salen == sizeof(struct sockaddr_in));
1093 ip_len = sizeof(struct in_addr);
1094 ip = &((const struct sockaddr_in*) sa)->sin_addr;
1095 break;
1096
1097 case AF_INET6:
1098 GNUNET_assert (salen == sizeof(struct sockaddr_in6));
1099 ip_len = sizeof(struct in6_addr);
1100 ip = &((const struct sockaddr_in6*) sa)->sin6_addr;
1101 break;
1102
1103 default:
1104 GNUNET_break (0);
1105 return NULL;
1106 }
1107 rh = GNUNET_malloc (sizeof(struct GNUNET_RESOLVER_RequestHandle) + salen);
1108 rh->name_callback = callback;
1109 rh->cls = cls;
1110 rh->af = sa->sa_family;
1111 rh->id = ++last_request_id;
1112 rh->timeout = GNUNET_TIME_relative_to_absolute (timeout);
1113 GNUNET_memcpy (&rh[1],
1114 ip,
1115 ip_len);
1116 rh->data_len = ip_len;
1117 rh->direction = GNUNET_YES;
1118 rh->received_response = GNUNET_NO;
1119 if (GNUNET_NO == do_resolve)
1120 {
1121 rh->task = GNUNET_SCHEDULER_add_now (&numeric_reverse,
1122 rh);
1123 return rh;
1124 }
1125 rh->task = GNUNET_SCHEDULER_add_delayed (timeout,
1126 &handle_lookup_timeout,
1127 rh);
1128 GNUNET_CONTAINER_DLL_insert_tail (req_head,
1129 req_tail,
1130 rh);
1131 rh->was_queued = GNUNET_YES;
1132 if (NULL != s_task)
1133 {
1134 GNUNET_SCHEDULER_cancel (s_task);
1135 s_task = NULL;
1136 }
1137 process_requests ();
1138 return rh;
1139}
1140
1141
1147char *
1148GNUNET_RESOLVER_local_fqdn_get ()
1149{
1150 char hostname[GNUNET_OS_get_hostname_max_length () + 1];
1151
1152 if (0 != gethostname (hostname,
1153 sizeof(hostname) - 1))
1154 {
1155 LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
1156 "gethostname");
1157 return NULL;
1158 }
1159 LOG (GNUNET_ERROR_TYPE_DEBUG,
1160 "Resolving our FQDN `%s'\n",
1161 hostname);
1162#if HAVE_GETADDRINFO
1163 {
1164 struct addrinfo *ai;
1165 int ret;
1166 char *rval;
1167
1168 if (0 != (ret = getaddrinfo (hostname,
1169 NULL,
1170 NULL,
1171 &ai)))
1172 {
1173 LOG (GNUNET_ERROR_TYPE_ERROR,
1174 _ ("Could not resolve our FQDN: %s\n"),
1175 gai_strerror (ret));
1176 return NULL;
1177 }
1178 if (NULL != ai->ai_canonname)
1179 rval = GNUNET_strdup (ai->ai_canonname);
1180 else
1181 rval = GNUNET_strdup (hostname);
1182 freeaddrinfo (ai);
1183 return rval;
1184 }
1185#elif HAVE_GETHOSTBYNAME2
1186 {
1187 struct hostent *host;
1188
1189 host = gethostbyname2 (hostname,
1190 AF_INET);
1191 if (NULL == host)
1192 host = gethostbyname2 (hostname,
1193 AF_INET6);
1194 if (NULL == host)
1195 {
1196 LOG (GNUNET_ERROR_TYPE_ERROR,
1197 _ ("Could not resolve our FQDN: %s\n"),
1198 hstrerror (h_errno));
1199 return NULL;
1200 }
1201 return GNUNET_strdup (host->h_name);
1202 }
1203#elif HAVE_GETHOSTBYNAME
1204 {
1205 struct hostent *host;
1206
1207 host = gethostbyname (hostname);
1208 if (NULL == host)
1209 {
1210 LOG (GNUNET_ERROR_TYPE_ERROR,
1211 _ ("Could not resolve our FQDN: %s\n"),
1212 hstrerror (h_errno));
1213 return NULL;
1214 }
1215 return GNUNET_strdup (host->h_name);
1216 }
1217#else
1218 /* fallback: just hope name is already FQDN */
1219 return GNUNET_strdup (hostname);
1220#endif
1221}
1222
1223
1233struct GNUNET_RESOLVER_RequestHandle *
1234GNUNET_RESOLVER_hostname_resolve (int af,
1235 struct GNUNET_TIME_Relative timeout,
1236 GNUNET_RESOLVER_AddressCallback callback,
1237 void *cls)
1238{
1239 char hostname[GNUNET_OS_get_hostname_max_length () + 1];
1240
1241 if (0 != gethostname (hostname, sizeof(hostname) - 1))
1242 {
1243 LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
1244 "gethostname");
1245 return NULL;
1246 }
1247 LOG (GNUNET_ERROR_TYPE_DEBUG,
1248 "Resolving our hostname `%s'\n",
1249 hostname);
1250 return GNUNET_RESOLVER_ip_get (hostname,
1251 af,
1252 timeout,
1253 callback,
1254 cls);
1255}
1256
1257
1266void
1267GNUNET_RESOLVER_request_cancel (struct GNUNET_RESOLVER_RequestHandle *rh)
1268{
1269 if (GNUNET_NO == rh->direction)
1270 LOG (GNUNET_ERROR_TYPE_DEBUG,
1271 "Asked to cancel request to resolve hostname `%s'.\n",
1272 (const char *) &rh[1]);
1273 if (NULL != rh->task)
1274 {
1275 GNUNET_SCHEDULER_cancel (rh->task);
1276 rh->task = NULL;
1277 }
1278 if (GNUNET_NO == rh->was_transmitted)
1279 {
1280 if (GNUNET_YES == rh->was_queued)
1281 GNUNET_CONTAINER_DLL_remove (req_head,
1282 req_tail,
1283 rh);
1284 GNUNET_free (rh);
1285 check_disconnect ();
1286 return;
1287 }
1288 GNUNET_assert (GNUNET_YES == rh->was_transmitted);
1289 rh->was_transmitted = GNUNET_SYSERR; /* mark as cancelled */
1290 check_disconnect ();
1291}
1292
1293
1294/* end of resolver_api.c */
handlers
struct GNUNET_MQ_MessageHandlers handlers[]
Definition 003.c:1
msg
struct GNUNET_MessageHeader * msg
Definition 005.c:2
env
struct GNUNET_MQ_Envelope * env
Definition 005.c:1
ret
static int ret
Final status code.
Definition gnunet-arm.c:93
cfg
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition gnunet-arm.c:108
timeout
static struct GNUNET_TIME_Relative timeout
User defined timestamp for completing operations.
Definition gnunet-arm.c:118
ai
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
Definition gnunet-communicator-unix.c:205
response
static struct MHD_Response * response
Our canonical response.
Definition gnunet-daemon-hostlist_server.c:102
shutdown_task
struct GNUNET_SCHEDULER_Task * shutdown_task
Definition gnunet-messenger.c:568
result
static int result
Global testing status.
Definition gnunet-regex-profiler.c:240
GNUNET_MAX_MESSAGE_SIZE
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message,...
Definition gnunet_util_lib.h:52
GNUNET_CLIENT_connect
struct GNUNET_MQ_Handle * GNUNET_CLIENT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *service_name, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *error_handler_cls)
Create a message queue to connect to a GNUnet service.
Definition client.c:1060
GNUNET_CONFIGURATION_get_value_string
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be a string.
Definition configuration.c:1921
GNUNET_CONFIGURATION_have_value
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_have_value(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option)
Test if we have a value for a particular option.
Definition configuration.c:2014
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_tail
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
Definition gnunet_container_lib.h:1822
GNUNET_MQ_MessageHandler::cls
void * cls
Closure for mv and cb.
Definition gnunet_mq_lib.h:511
GNUNET_memcpy
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
Definition gnunet_common.h:1320
GNUNET_MessageHeader::size
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
Definition gnunet_common.h:328
GNUNET_OK
@ GNUNET_OK
Definition gnunet_common.h:114
GNUNET_YES
@ GNUNET_YES
Definition gnunet_common.h:116
GNUNET_NO
@ GNUNET_NO
Definition gnunet_common.h:113
GNUNET_SYSERR
@ GNUNET_SYSERR
Definition gnunet_common.h:112
GNUNET_assert
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
Definition gnunet_common.h:960
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:1045
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_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_WARNING
Definition gnunet_common.h:418
GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_ERROR
Definition gnunet_common.h:417
GNUNET_ERROR_TYPE_BULK
@ GNUNET_ERROR_TYPE_BULK
Definition gnunet_common.h:426
GNUNET_ERROR_TYPE_DEBUG
@ GNUNET_ERROR_TYPE_DEBUG
Definition gnunet_common.h:424
GNUNET_ERROR_TYPE_INFO
@ GNUNET_ERROR_TYPE_INFO
Definition gnunet_common.h:423
GNUNET_strdup
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
Definition gnunet_common.h:1429
GNUNET_malloc
#define GNUNET_malloc(size)
Wrapper around malloc.
Definition gnunet_common.h:1355
GNUNET_free
#define GNUNET_free(ptr)
Wrapper around free.
Definition gnunet_common.h:1415
GNUNET_MQ_Error
GNUNET_MQ_Error
Error codes for the queue.
Definition gnunet_mq_lib.h:202
GNUNET_MQ_send
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition mq.c:305
GNUNET_MQ_handler_end
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
Definition gnunet_mq_lib.h:531
GNUNET_MQ_msg_extra
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition gnunet_mq_lib.h:61
GNUNET_MQ_hd_var_size
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
Definition gnunet_mq_lib.h:617
GNUNET_MQ_destroy
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition mq.c:700
GNUNET_OS_get_hostname_max_length
#define GNUNET_OS_get_hostname_max_length()
Get maximum string length returned by gethostname()
Definition gnunet_os_lib.h:422
GNUNET_MESSAGE_TYPE_RESOLVER_REQUEST
#define GNUNET_MESSAGE_TYPE_RESOLVER_REQUEST
Request DNS resolution.
Definition gnunet_protocols.h:89
GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE
#define GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE
Response to a DNS resolution request.
Definition gnunet_protocols.h:94
GNUNET_RESOLVER_local_fqdn_get
char * GNUNET_RESOLVER_local_fqdn_get()
Get local fully qualified af name.
Definition resolver_api.c:1149
GNUNET_RESOLVER_ip_get
struct GNUNET_RESOLVER_RequestHandle * GNUNET_RESOLVER_ip_get(const char *hostname, int af, struct GNUNET_TIME_Relative timeout, GNUNET_RESOLVER_AddressCallback callback, void *callback_cls)
Convert a string to one or more IP addresses.
Definition resolver_api.c:940
GNUNET_RESOLVER_disconnect
void GNUNET_RESOLVER_disconnect()
Destroy the connection to the resolver service.
Definition resolver_api.c:270
GNUNET_RESOLVER_connect
void GNUNET_RESOLVER_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Create the connection to the resolver service.
Definition resolver_api.c:258
GNUNET_RESOLVER_hostname_resolve
struct GNUNET_RESOLVER_RequestHandle * GNUNET_RESOLVER_hostname_resolve(int af, struct GNUNET_TIME_Relative timeout, GNUNET_RESOLVER_AddressCallback callback, void *cls)
Looking our own hostname.
Definition resolver_api.c:1235
GNUNET_RESOLVER_AddressCallback
void(* GNUNET_RESOLVER_AddressCallback)(void *cls, const struct sockaddr *addr, socklen_t addrlen)
Function called by the resolver for each address obtained from DNS.
Definition gnunet_resolver_service.h:60
GNUNET_RESOLVER_hostname_get
struct GNUNET_RESOLVER_RequestHandle * GNUNET_RESOLVER_hostname_get(const struct sockaddr *sa, socklen_t salen, int do_resolve, struct GNUNET_TIME_Relative timeout, GNUNET_RESOLVER_HostnameCallback callback, void *cls)
Get an IP address as a string.
Definition resolver_api.c:1072
GNUNET_RESOLVER_request_cancel
void GNUNET_RESOLVER_request_cancel(struct GNUNET_RESOLVER_RequestHandle *rh)
Cancel a request that is still pending with the resolver.
Definition resolver_api.c:1268
GNUNET_RESOLVER_HostnameCallback
void(* GNUNET_RESOLVER_HostnameCallback)(void *cls, const char *hostname)
Function called by the resolver for each hostname obtained from DNS.
Definition gnunet_resolver_service.h:129
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_STRINGS_relative_time_to_string
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition strings.c:599
GNUNET_TIME_UNIT_MILLISECONDS
#define GNUNET_TIME_UNIT_MILLISECONDS
One millisecond.
Definition gnunet_time_lib.h:151
GNUNET_TIME_relative_to_absolute
struct GNUNET_TIME_Absolute GNUNET_TIME_relative_to_absolute(struct GNUNET_TIME_Relative rel)
Convert relative time to an absolute time in the future.
Definition time.c:316
GNUNET_TIME_STD_BACKOFF
#define GNUNET_TIME_STD_BACKOFF(r)
Perform our standard exponential back-off calculation, starting at 1 ms and then going by a factor of...
Definition gnunet_time_lib.h:229
size
static unsigned int size
Size of the "table".
Definition peer.c:68
_
#define _(String)
GNU gettext support macro.
Definition platform.h:179
reconnect
static void reconnect(void)
Adjust exponential back-off and reconnect to the service.
Definition resolver_api.c:828
numeric_resolution
static void numeric_resolution(void *cls)
We've been asked to lookup the address for a hostname and were given a valid numeric string.
Definition resolver_api.c:652
req_tail
static struct GNUNET_RESOLVER_RequestHandle * req_tail
Tail of DLL of requests.
Definition resolver_api.c:74
no_resolve
static char * no_resolve(int af, const void *ip, socklen_t ip_len)
Convert IP address to string without DNS resolution.
Definition resolver_api.c:348
check_disconnect
static void check_disconnect()
Consider disconnecting if we have no further requests pending.
Definition resolver_api.c:319
mq
static struct GNUNET_MQ_Handle * mq
Our connection to the resolver service, created on-demand, but then persists until error or shutdown.
Definition resolver_api.c:64
check_config
static int check_config()
Check that the resolver service runs on localhost (or equivalent).
Definition resolver_api.c:191
loopback
static const char * loopback[]
Possible hostnames for "loopback".
Definition resolver_api.c:48
loopback_resolution
static void loopback_resolution(void *cls)
We've been asked to lookup the address for a hostname and were given a variant of "loopback".
Definition resolver_api.c:728
mq_error_handler
static void mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
Generic error handler, called with the appropriate error code and the same closure specified at the c...
Definition resolver_api.c:410
s_task
static struct GNUNET_SCHEDULER_Task * s_task
Task ID of shutdown task; only present while we have a connection to the resolver service.
Definition resolver_api.c:95
last_request_id
static uint32_t last_request_id
ID of the last request we sent to the service.
Definition resolver_api.c:79
backoff
static struct GNUNET_TIME_Relative backoff
How long should we wait to reconnect?
Definition resolver_api.c:84
handle_response
static void handle_response(void *cls, const struct GNUNET_RESOLVER_ResponseMessage *msg)
Check validity of response with a hostname for a DNS lookup.
Definition resolver_api.c:496
numeric_reverse
static void numeric_reverse(void *cls)
We've been asked to convert an address to a string without a reverse lookup, either because the clien...
Definition resolver_api.c:1030
process_requests
static void process_requests()
Process pending requests to the resolver.
Definition resolver_api.c:427
resolver_cfg
static const struct GNUNET_CONFIGURATION_Handle * resolver_cfg
Configuration.
Definition resolver_api.c:58
req_head
static struct GNUNET_RESOLVER_RequestHandle * req_head
Head of DLL of requests.
Definition resolver_api.c:69
r_task
static struct GNUNET_SCHEDULER_Task * r_task
Task for reconnecting.
Definition resolver_api.c:89
handle_lookup_timeout
static void handle_lookup_timeout(void *cls)
A DNS resolution timed out.
Definition resolver_api.c:880
check_response
static int check_response(void *cls, const struct GNUNET_RESOLVER_ResponseMessage *msg)
Check validity of response with a hostname for a DNS lookup.
Definition resolver_api.c:476
LOG
#define LOG(kind,...)
Definition resolver_api.c:33
LOG_STRERROR
#define LOG_STRERROR(kind, syscall)
Definition resolver_api.c:35
reconnect_task
static void reconnect_task(void *cls)
Now try to reconnect to the resolver service.
Definition resolver_api.c:792
GNUNET_CONFIGURATION_Handle
configuration data
Definition configuration.c:149
GNUNET_MQ_Envelope
Definition mq.c:34
GNUNET_MQ_Handle
Handle to a message queue.
Definition mq.c:87
GNUNET_MQ_MessageHandler
Message handler for a specific message type.
Definition gnunet_mq_lib.h:491
GNUNET_RESOLVER_GetMessage
Request for the resolver.
Definition resolver.h:44
GNUNET_RESOLVER_RequestHandle
Handle to a request given to the resolver.
Definition resolver_api.c:104
GNUNET_RESOLVER_RequestHandle::task
struct GNUNET_SCHEDULER_Task * task
Task handle for making reply callbacks in numeric lookups asynchronous, and for timeout handling.
Definition resolver_api.c:141
GNUNET_RESOLVER_RequestHandle::name_callback
GNUNET_RESOLVER_HostnameCallback name_callback
Callback if this is a reverse lookup request, otherwise NULL.
Definition resolver_api.c:125
GNUNET_RESOLVER_RequestHandle::was_queued
int was_queued
Did we add this request to the queue?
Definition resolver_api.c:164
GNUNET_RESOLVER_RequestHandle::next
struct GNUNET_RESOLVER_RequestHandle * next
Next entry in DLL of requests.
Definition resolver_api.c:108
GNUNET_RESOLVER_RequestHandle::cls
void * cls
Closure for the callbacks.
Definition resolver_api.c:130
GNUNET_RESOLVER_RequestHandle::was_transmitted
int was_transmitted
Has this request been transmitted to the service? GNUNET_YES if transmitted GNUNET_NO if not transmit...
Definition resolver_api.c:159
GNUNET_RESOLVER_RequestHandle::data_len
size_t data_len
Length of the data that follows this struct.
Definition resolver_api.c:179
GNUNET_RESOLVER_RequestHandle::addr_callback
GNUNET_RESOLVER_AddressCallback addr_callback
Callback if this is an name resolution request, otherwise NULL.
Definition resolver_api.c:119
GNUNET_RESOLVER_RequestHandle::af
int af
Desired address family.
Definition resolver_api.c:146
GNUNET_RESOLVER_RequestHandle::id
uint32_t id
Identifies the request.
Definition resolver_api.c:151
GNUNET_RESOLVER_RequestHandle::timeout
struct GNUNET_TIME_Absolute timeout
When should this request time out?
Definition resolver_api.c:135
GNUNET_RESOLVER_RequestHandle::prev
struct GNUNET_RESOLVER_RequestHandle * prev
Previous entry in DLL of requests.
Definition resolver_api.c:113
GNUNET_RESOLVER_RequestHandle::received_response
int received_response
GNUNET_YES if a response was received
Definition resolver_api.c:174
GNUNET_RESOLVER_RequestHandle::direction
int direction
Desired direction (IP to name or name to IP)
Definition resolver_api.c:169
GNUNET_RESOLVER_ResponseMessage
Definition resolver.h:73
GNUNET_SCHEDULER_Task
Entry in list of pending tasks.
Definition scheduler.c:136
GNUNET_TIME_Absolute
Time for absolute times used by GNUnet, in microseconds.
Definition gnunet_time_lib.h:54
GNUNET_TIME_Relative
Time for relative time used by GNUnet, in microseconds.
Definition gnunet_time_lib.h:79

◆ MAX_HOSTNAME

#define MAX_HOSTNAME   1024

Maximum supported length for a hostname.

Definition at line 42 of file resolver_api.c.

Function Documentation

◆ check_config()

static int check_config ( )
static

Check that the resolver service runs on localhost (or equivalent).

Returns
GNUNET_OK if the resolver is properly configured, GNUNET_SYSERR otherwise.

Definition at line 191 of file resolver_api.c.

192{
193 char *hostname;
194 struct sockaddr_in v4;
195 struct sockaddr_in6 v6;
196
197 if (GNUNET_OK ==
198 GNUNET_CONFIGURATION_have_value (resolver_cfg,
199 "resolver",
200 "UNIXPATH"))
201 return GNUNET_OK;
202 memset (&v4, 0, sizeof(v4));
203 v4.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
204 v4.sin_family = AF_INET;
205#if HAVE_SOCKADDR_IN_SIN_LEN
206 v4.sin_len = sizeof(v4);
207#endif
208 memset (&v6, 0, sizeof(v6));
209 v6.sin6_family = AF_INET6;
210#if HAVE_SOCKADDR_IN_SIN_LEN
211 v6.sin6_len = sizeof(v6);
212#endif
213 if (GNUNET_OK !=
214 GNUNET_CONFIGURATION_get_value_string (resolver_cfg,
215 "resolver",
216 "HOSTNAME",
217 &hostname))
218 {
219 LOG (GNUNET_ERROR_TYPE_INFO,
220 _ (
221 "Missing `%s' for `%s' in configuration, DNS resolution will be unavailable.\n"),
222 "HOSTNAME",
223 "resolver");
224 return GNUNET_SYSERR;
225 }
226 if ((1 == inet_pton (AF_INET, hostname, &v4)) ||
227 (1 == inet_pton (AF_INET6, hostname, &v6)))
228 {
229 GNUNET_free (hostname);
230 return GNUNET_OK;
231 }
232 for (unsigned int i = 0;
233 NULL != loopback[i];
234 i++)
235 if (0 == strcasecmp (loopback[i],
236 hostname))
237 {
238 GNUNET_free (hostname);
239 return GNUNET_OK;
240 }
241 LOG (GNUNET_ERROR_TYPE_INFO,
242 _ (
243 "Missing `%s' or numeric IP address for `%s' of `%s' in configuration, DNS resolution will be unavailable.\n"),
244 "localhost",
245 "HOSTNAME",
246 "resolver");
247 GNUNET_free (hostname);
248 return GNUNET_SYSERR;
249}

References _, GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_have_value(), GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_OK, GNUNET_SYSERR, LOG, loopback, and resolver_cfg.

Referenced by GNUNET_RESOLVER_hostname_get(), and GNUNET_RESOLVER_ip_get().

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

◆ shutdown_task()

static void shutdown_task ( void *  cls)
static

Task executed on system shutdown.

Definition at line 306 of file resolver_api.c.

307{
308 (void) cls;
309 s_task = NULL;
310 GNUNET_RESOLVER_disconnect ();
311 backoff = GNUNET_TIME_UNIT_MILLISECONDS;
312}

References backoff, GNUNET_RESOLVER_RequestHandle::cls, GNUNET_RESOLVER_disconnect(), GNUNET_TIME_UNIT_MILLISECONDS, and s_task.

Here is the call graph for this function:

◆ check_disconnect()

static void check_disconnect ( )
static

Consider disconnecting if we have no further requests pending.

Definition at line 319 of file resolver_api.c.

320{
321 for (struct GNUNET_RESOLVER_RequestHandle *rh = req_head;
322 NULL != rh;
323 rh = rh->next)
324 if (GNUNET_SYSERR != rh->was_transmitted)
325 return;
326 if (NULL != r_task)
327 {
328 GNUNET_SCHEDULER_cancel (r_task);
329 r_task = NULL;
330 }
331 if (NULL != s_task)
332 return;
333 s_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
334 &shutdown_task,
335 NULL);
336}

References GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_SYSERR, GNUNET_TIME_UNIT_MILLISECONDS, GNUNET_RESOLVER_RequestHandle::next, r_task, req_head, s_task, and shutdown_task.

Referenced by GNUNET_RESOLVER_request_cancel(), and reconnect().

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

◆ no_resolve()

static char * no_resolve ( int  af,
const void *  ip,
socklen_t  ip_len 
)
static

Convert IP address to string without DNS resolution.

Parameters
afaddress family
ipthe address
ip_lennumber of bytes in ip
Returns
address as a string, NULL on error

Definition at line 348 of file resolver_api.c.

351{
352 char buf[INET6_ADDRSTRLEN];
353
354 switch (af)
355 {
356 case AF_INET:
357 if (ip_len != sizeof(struct in_addr))
358 return NULL;
359 if (NULL ==
360 inet_ntop (AF_INET,
361 ip,
362 buf,
363 sizeof(buf)))
364 {
365 LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
366 "inet_ntop");
367 return NULL;
368 }
369 break;
370
371 case AF_INET6:
372 if (ip_len != sizeof(struct in6_addr))
373 return NULL;
374 if (NULL ==
375 inet_ntop (AF_INET6,
376 ip,
377 buf,
378 sizeof(buf)))
379 {
380 LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
381 "inet_ntop");
382 return NULL;
383 }
384 break;
385
386 default:
387 GNUNET_break (0);
388 return NULL;
389 }
390 return GNUNET_strdup (buf);
391}

References GNUNET_RESOLVER_RequestHandle::af, GNUNET_break, GNUNET_ERROR_TYPE_WARNING, GNUNET_strdup, and LOG_STRERROR.

Referenced by handle_lookup_timeout(), handle_response(), and numeric_reverse().

Here is the caller graph for this function:

◆ reconnect()

static void reconnect ( void  )
static

Adjust exponential back-off and reconnect to the service.

Definition at line 828 of file resolver_api.c.

829{
830 struct GNUNET_RESOLVER_RequestHandle *rh;
831
832 if (NULL != r_task)
833 return;
834 GNUNET_assert (NULL == mq);
835 if (NULL != (rh = req_head))
836 {
837 switch (rh->was_transmitted)
838 {
839 case GNUNET_NO:
840 /* nothing more to do */
841 break;
842
843 case GNUNET_YES:
844 /* disconnected, transmit again! */
845 rh->was_transmitted = GNUNET_NO;
846 break;
847
848 case GNUNET_SYSERR:
849 /* request was cancelled, remove entirely */
850 GNUNET_CONTAINER_DLL_remove (req_head,
851 req_tail,
852 rh);
853 GNUNET_free (rh);
854 check_disconnect ();
855 break;
856
857 default:
858 GNUNET_assert (0);
859 break;
860 }
861 }
862 LOG (GNUNET_ERROR_TYPE_DEBUG,
863 "Will try to connect to DNS service in %s\n",
864 GNUNET_STRINGS_relative_time_to_string (backoff,
865 GNUNET_YES));
866 GNUNET_assert (NULL != resolver_cfg);
867 r_task = GNUNET_SCHEDULER_add_delayed (backoff,
868 &reconnect_task,
869 NULL);
870 backoff = GNUNET_TIME_STD_BACKOFF (backoff);
871}

References backoff, check_disconnect(), GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_SYSERR, GNUNET_TIME_STD_BACKOFF, GNUNET_YES, LOG, mq, r_task, reconnect_task(), req_head, req_tail, resolver_cfg, and GNUNET_RESOLVER_RequestHandle::was_transmitted.

Referenced by callback_reconnect(), disconnect_and_schedule_reconnect(), disconnect_and_schedule_reconnect(), do_connect(), error_handler(), error_handler(), error_handler(), error_handler(), error_handler(), error_handler(), force_reconnect(), GNUNET_ABD_connect(), GNUNET_CADET_connect(), GNUNET_CADET_get_channel(), GNUNET_CADET_get_path(), GNUNET_CADET_list_peers(), GNUNET_CADET_list_tunnels(), GNUNET_CORE_connect(), GNUNET_CORE_monitor_start(), GNUNET_DNS_connect(), GNUNET_GNS_connect(), GNUNET_IDENTITY_connect(), GNUNET_MESSENGER_connect(), GNUNET_NAMECACHE_connect(), GNUNET_NAMESTORE_connect(), GNUNET_NAMESTORE_zone_monitor_start(), GNUNET_NAMESTORE_zone_monitor_start2(), GNUNET_NSE_connect(), GNUNET_PEERSTORE_connect(), GNUNET_PEERSTORE_monitor_start(), GNUNET_PILS_connect(), GNUNET_RECLAIM_connect(), GNUNET_RECLAIM_ticket_consume(), GNUNET_RPS_connect(), GNUNET_TRANSPORT_application_init(), GNUNET_TRANSPORT_communicator_connect(), GNUNET_TRANSPORT_monitor(), handle_address_change_notification(), handle_incoming_ack(), handle_monitor_end(), handle_mq_error(), handle_response(), mq_error_handler(), mq_error_handler(), mq_error_handler(), mq_error_handler(), mq_error_handler(), mq_error_handler(), mq_error_handler(), mq_error_handler(), process_requests(), reconnect(), reconnect(), reconnect_cbk(), reconnect_task(), reconnect_task(), reconnect_task(), reconnect_task(), reconnect_task(), reconnect_task(), reconnect_task(), reconnect_task(), and reschedule_connect().

Here is the call graph for this function:

◆ mq_error_handler()

static void mq_error_handler ( void *  cls,
enum GNUNET_MQ_Error  error 
)
static

Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue.

Not every message queue implementation supports an error handler.

Parameters
clsNULL
errorerror code

Definition at line 410 of file resolver_api.c.

412{
413 (void) cls;
414 GNUNET_MQ_destroy (mq);
415 mq = NULL;
416 LOG (GNUNET_ERROR_TYPE_DEBUG,
417 "MQ error %d, reconnecting\n",
418 error);
419 reconnect ();
420}

References GNUNET_RESOLVER_RequestHandle::cls, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MQ_destroy(), LOG, mq, and reconnect().

Referenced by reconnect_task().

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

◆ process_requests()

static void process_requests ( )
static

Process pending requests to the resolver.

Definition at line 427 of file resolver_api.c.

428{
429 struct GNUNET_RESOLVER_GetMessage *msg;
430 struct GNUNET_MQ_Envelope *env;
431 struct GNUNET_RESOLVER_RequestHandle *rh = req_head;
432
433 if (NULL == mq)
434 {
435 reconnect ();
436 return;
437 }
438 if (NULL == rh)
439 {
440 /* nothing to do, release socket really soon if there is nothing
441 * else happening... */
442 if (NULL == s_task)
443 s_task =
444 GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
445 &shutdown_task,
446 NULL);
447 return;
448 }
449 if (GNUNET_NO != rh->was_transmitted)
450 return; /* waiting for reply */
451 env = GNUNET_MQ_msg_extra (msg,
452 rh->data_len,
453 GNUNET_MESSAGE_TYPE_RESOLVER_REQUEST);
454 msg->direction = htonl (rh->direction);
455 msg->af = htonl (rh->af);
456 msg->client_id = rh->id;
457 GNUNET_memcpy (&msg[1],
458 &rh[1],
459 rh->data_len);
460 LOG (GNUNET_ERROR_TYPE_DEBUG,
461 "Transmitting DNS resolution request (ID %u) to DNS service\n",
462 rh->id);
463 GNUNET_MQ_send (mq,
464 env);
465 rh->was_transmitted = GNUNET_YES;
466}

References GNUNET_RESOLVER_RequestHandle::af, GNUNET_RESOLVER_RequestHandle::data_len, GNUNET_RESOLVER_RequestHandle::direction, env, GNUNET_ERROR_TYPE_DEBUG, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_RESOLVER_REQUEST, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_UNIT_MILLISECONDS, GNUNET_YES, GNUNET_RESOLVER_RequestHandle::id, LOG, mq, msg, reconnect(), req_head, s_task, shutdown_task, and GNUNET_RESOLVER_RequestHandle::was_transmitted.

Referenced by GNUNET_RESOLVER_hostname_get(), GNUNET_RESOLVER_ip_get(), handle_lookup_timeout(), handle_response(), and reconnect_task().

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

◆ check_response()

static int check_response ( void *  cls,
const struct GNUNET_RESOLVER_ResponseMessage *  msg 
)
static

Check validity of response with a hostname for a DNS lookup.

Parameters
clsNULL
msgmessage with the hostname

Definition at line 476 of file resolver_api.c.

478{
479 (void) cls;
480 (void) msg;
481
482 /* implemented in #handle_response() for now */
483 return GNUNET_OK;
484}

References GNUNET_RESOLVER_RequestHandle::cls, GNUNET_OK, and msg.

◆ handle_response()

static void handle_response ( void *  cls,
const struct GNUNET_RESOLVER_ResponseMessage *  msg 
)
static

Check validity of response with a hostname for a DNS lookup.

NOTE: right now rather messy, might want to use different message types for different response formats in the future.

Parameters
clsNULL
msgmessage with the response

Definition at line 496 of file resolver_api.c.

498{
499 struct GNUNET_RESOLVER_RequestHandle *rh = req_head;
500 uint16_t size;
501 char *nret;
502 uint32_t client_request_id = msg->client_id;
503
504 for (; rh != NULL; rh = rh->next)
505 {
506 if (rh->id == client_request_id)
507 break;
508 }
509
510 (void) cls;
511 if (NULL == rh)
512 {
513 /* Resolver service sent extra replies to query (after terminator)? Bad! */
514 GNUNET_break (0);
515 GNUNET_MQ_destroy (mq);
516 mq = NULL;
517 reconnect ();
518 return;
519 }
520 size = ntohs (msg->header.size);
521 if (size == sizeof(struct GNUNET_RESOLVER_ResponseMessage))
522 {
523 LOG (GNUNET_ERROR_TYPE_DEBUG,
524 "Received empty response from DNS service\n");
525 /* message contains not data, just header; end of replies */
526 /* check if request was canceled */
527 if (GNUNET_SYSERR != rh->was_transmitted)
528 {
529 /* no reverse lookup was successful, return IP as string */
530 if (NULL != rh->name_callback)
531 {
532 if (GNUNET_NO == rh->received_response)
533 {
534 nret = no_resolve (rh->af,
535 &rh[1],
536 rh->data_len);
537 rh->name_callback (rh->cls, nret);
538 GNUNET_free (nret);
539 }
540 /* finally, make termination call */
541 if (GNUNET_SYSERR != rh->was_transmitted)
542 rh->name_callback (rh->cls,
543 NULL);
544 }
545 if ((NULL != rh->addr_callback) &&
546 (GNUNET_SYSERR != rh->was_transmitted))
547 rh->addr_callback (rh->cls,
548 NULL,
549 0);
550 }
551 rh->was_transmitted = GNUNET_NO;
552 GNUNET_RESOLVER_request_cancel (rh);
553 process_requests ();
554 return;
555 }
556 /* return reverse lookup results to caller */
557 if (NULL != rh->name_callback)
558 {
559 const char *hostname;
560
561 hostname = (const char *) &msg[1];
562 if (hostname[size - sizeof(struct GNUNET_RESOLVER_ResponseMessage) - 1] !=
563 '\0')
564 {
565 GNUNET_break (0);
566 if (GNUNET_SYSERR != rh->was_transmitted)
567 rh->name_callback (rh->cls,
568 NULL);
569 rh->was_transmitted = GNUNET_NO;
570 GNUNET_RESOLVER_request_cancel (rh);
571 GNUNET_MQ_destroy (mq);
572 mq = NULL;
573 reconnect ();
574 return;
575 }
576 LOG (GNUNET_ERROR_TYPE_DEBUG,
577 "Resolver returns `%s' for IP `%s'.\n",
578 hostname,
579 GNUNET_a2s ((const void *) &rh[1],
580 rh->data_len));
581 if (rh->was_transmitted != GNUNET_SYSERR)
582 rh->name_callback (rh->cls,
583 hostname);
584 rh->received_response = GNUNET_YES;
585 }
586 /* return lookup results to caller */
587 if (NULL != rh->addr_callback)
588 {
589 struct sockaddr_in v4;
590 struct sockaddr_in6 v6;
591 const struct sockaddr *sa;
592 socklen_t salen;
593 const void *ip;
594 size_t ip_len;
595
596 ip = &msg[1];
597 ip_len = size - sizeof(struct GNUNET_RESOLVER_ResponseMessage);
598 if (ip_len == sizeof(struct in_addr))
599 {
600 memset (&v4, 0, sizeof(v4));
601 v4.sin_family = AF_INET;
602 v4.sin_addr = *(struct in_addr*) ip;
603#if HAVE_SOCKADDR_IN_SIN_LEN
604 v4.sin_len = sizeof(v4);
605#endif
606 salen = sizeof(v4);
607 sa = (const struct sockaddr *) &v4;
608 }
609 else if (ip_len == sizeof(struct in6_addr))
610 {
611 memset (&v6, 0, sizeof(v6));
612 v6.sin6_family = AF_INET6;
613 v6.sin6_addr = *(struct in6_addr*) ip;
614#if HAVE_SOCKADDR_IN_SIN_LEN
615 v6.sin6_len = sizeof(v6);
616#endif
617 salen = sizeof(v6);
618 sa = (const struct sockaddr *) &v6;
619 }
620 else
621 {
622 GNUNET_break (0);
623 if (GNUNET_SYSERR != rh->was_transmitted)
624 rh->addr_callback (rh->cls,
625 NULL,
626 0);
627 rh->was_transmitted = GNUNET_NO;
628 GNUNET_RESOLVER_request_cancel (rh);
629 GNUNET_MQ_destroy (mq);
630 mq = NULL;
631 reconnect ();
632 return;
633 }
634 LOG (GNUNET_ERROR_TYPE_DEBUG,
635 "Received IP from DNS service\n");
636 if (GNUNET_SYSERR != rh->was_transmitted)
637 rh->addr_callback (rh->cls,
638 sa,
639 salen);
640 }
641}

References GNUNET_RESOLVER_RequestHandle::addr_callback, GNUNET_RESOLVER_RequestHandle::af, GNUNET_RESOLVER_RequestHandle::cls, GNUNET_RESOLVER_RequestHandle::data_len, GNUNET_a2s(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_MQ_destroy(), GNUNET_NO, GNUNET_RESOLVER_request_cancel(), GNUNET_SYSERR, GNUNET_YES, GNUNET_RESOLVER_RequestHandle::id, LOG, mq, msg, GNUNET_RESOLVER_RequestHandle::name_callback, GNUNET_RESOLVER_RequestHandle::next, no_resolve(), process_requests(), GNUNET_RESOLVER_RequestHandle::received_response, reconnect(), req_head, GNUNET_MessageHeader::size, size, and GNUNET_RESOLVER_RequestHandle::was_transmitted.

Here is the call graph for this function:

◆ numeric_resolution()

static void numeric_resolution ( void *  cls)
static

We've been asked to lookup the address for a hostname and were given a valid numeric string.

Perform the callbacks for the numeric addresses.

Parameters
clsstruct GNUNET_RESOLVER_RequestHandle for the request

Definition at line 652 of file resolver_api.c.

653{
654 struct GNUNET_RESOLVER_RequestHandle *rh = cls;
655 struct sockaddr_in v4;
656 struct sockaddr_in6 v6;
657 const char *hostname;
658
659 rh->task = NULL;
660 memset (&v4, 0, sizeof(v4));
661 v4.sin_family = AF_INET;
662#if HAVE_SOCKADDR_IN_SIN_LEN
663 v4.sin_len = sizeof(v4);
664#endif
665 memset (&v6, 0, sizeof(v6));
666 v6.sin6_family = AF_INET6;
667#if HAVE_SOCKADDR_IN_SIN_LEN
668 v6.sin6_len = sizeof(v6);
669#endif
670 hostname = (const char *) &rh[1];
671 if (((rh->af == AF_UNSPEC) ||
672 (rh->af == AF_INET)) &&
673 (1 == inet_pton (AF_INET,
674 hostname,
675 &v4.sin_addr)))
676 {
677 rh->addr_callback (rh->cls,
678 (const struct sockaddr *) &v4,
679 sizeof(v4));
680 if ((rh->af == AF_UNSPEC) &&
681 (GNUNET_SYSERR != rh->was_transmitted) &&
682 (1 == inet_pton (AF_INET6,
683 hostname,
684 &v6.sin6_addr)))
685 {
686 /* this can happen on some systems IF "hostname" is "localhost" */
687 rh->addr_callback (rh->cls,
688 (const struct sockaddr *) &v6,
689 sizeof(v6));
690 }
691 if (GNUNET_SYSERR != rh->was_transmitted)
692 rh->addr_callback (rh->cls,
693 NULL,
694 0);
695 GNUNET_free (rh);
696 return;
697 }
698 if (((rh->af == AF_UNSPEC) ||
699 (rh->af == AF_INET6)) &&
700 (1 == inet_pton (AF_INET6,
701 hostname,
702 &v6.sin6_addr)))
703 {
704 rh->addr_callback (rh->cls,
705 (const struct sockaddr *) &v6,
706 sizeof(v6));
707 if (GNUNET_SYSERR != rh->was_transmitted)
708 rh->addr_callback (rh->cls,
709 NULL,
710 0);
711 GNUNET_free (rh);
712 return;
713 }
714 /* why are we here? this task should not have been scheduled! */
715 GNUNET_assert (0);
716 GNUNET_free (rh);
717}

References GNUNET_RESOLVER_RequestHandle::addr_callback, GNUNET_RESOLVER_RequestHandle::af, GNUNET_RESOLVER_RequestHandle::cls, GNUNET_assert, GNUNET_free, GNUNET_SYSERR, GNUNET_RESOLVER_RequestHandle::task, and GNUNET_RESOLVER_RequestHandle::was_transmitted.

Referenced by GNUNET_RESOLVER_ip_get().

Here is the caller graph for this function:

◆ loopback_resolution()

static void loopback_resolution ( void *  cls)
static

We've been asked to lookup the address for a hostname and were given a variant of "loopback".

Perform the callbacks for the respective loopback numeric addresses.

Parameters
clsstruct GNUNET_RESOLVER_RequestHandle for the request

Definition at line 728 of file resolver_api.c.

729{
730 struct GNUNET_RESOLVER_RequestHandle *rh = cls;
731 struct sockaddr_in v4;
732 struct sockaddr_in6 v6;
733
734 rh->task = NULL;
735 memset (&v4, 0, sizeof(v4));
736 v4.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
737 v4.sin_family = AF_INET;
738#if HAVE_SOCKADDR_IN_SIN_LEN
739 v4.sin_len = sizeof(v4);
740#endif
741 memset (&v6, 0, sizeof(v6));
742 v6.sin6_family = AF_INET6;
743#if HAVE_SOCKADDR_IN_SIN_LEN
744 v6.sin6_len = sizeof(v6);
745#endif
746 v6.sin6_addr = in6addr_loopback;
747 switch (rh->af)
748 {
749 case AF_INET:
750 rh->addr_callback (rh->cls,
751 (const struct sockaddr *) &v4,
752 sizeof(v4));
753 break;
754
755 case AF_INET6:
756 rh->addr_callback (rh->cls,
757 (const struct sockaddr *) &v6,
758 sizeof(v6));
759 break;
760
761 case AF_UNSPEC:
762 rh->addr_callback (rh->cls,
763 (const struct sockaddr *) &v6,
764 sizeof(v6));
765 rh->addr_callback (rh->cls,
766 (const struct sockaddr *) &v4,
767 sizeof(v4));
768
769 break;
770
771 default:
772 GNUNET_break (0);
773 break;
774 }
775 if (GNUNET_SYSERR != rh->was_transmitted)
776 rh->addr_callback (rh->cls,
777 NULL,
778 0);
779 LOG (GNUNET_ERROR_TYPE_DEBUG,
780 "Finished resolving hostname `%s'.\n",
781 (const char *) &rh[1]);
782 GNUNET_free (rh);
783}

References GNUNET_RESOLVER_RequestHandle::addr_callback, GNUNET_RESOLVER_RequestHandle::af, GNUNET_RESOLVER_RequestHandle::cls, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_SYSERR, LOG, GNUNET_RESOLVER_RequestHandle::task, and GNUNET_RESOLVER_RequestHandle::was_transmitted.

Referenced by GNUNET_RESOLVER_ip_get().

Here is the caller graph for this function:

◆ reconnect_task()

static void reconnect_task ( void *  cls)
static

Now try to reconnect to the resolver service.

Parameters
clsNULL

Definition at line 792 of file resolver_api.c.

793{
794 struct GNUNET_MQ_MessageHandler handlers[] = {
795 GNUNET_MQ_hd_var_size (response,
796 GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE,
797 struct GNUNET_RESOLVER_ResponseMessage,
798 NULL),
799 GNUNET_MQ_handler_end ()
800 };
801
802 (void) cls;
803 r_task = NULL;
804 if (NULL == req_head)
805 return; /* no work pending */
806 LOG (GNUNET_ERROR_TYPE_DEBUG,
807 "Trying to connect to DNS service\n");
808 mq = GNUNET_CLIENT_connect (resolver_cfg,
809 "resolver",
810 handlers,
811 &mq_error_handler,
812 NULL);
813 if (NULL == mq)
814 {
815 LOG (GNUNET_ERROR_TYPE_DEBUG,
816 "Failed to connect, will try again later\n");
817 reconnect ();
818 return;
819 }
820 process_requests ();
821}

References GNUNET_MQ_MessageHandler::cls, GNUNET_CLIENT_connect(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, handlers, LOG, mq, mq_error_handler(), process_requests(), r_task, reconnect(), req_head, resolver_cfg, and response.

Referenced by reconnect().

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

◆ handle_lookup_timeout()

static void handle_lookup_timeout ( void *  cls)
static

A DNS resolution timed out.

Notify the application.

Parameters
clsthe struct GNUNET_RESOLVER_RequestHandle *

Definition at line 880 of file resolver_api.c.

881{
882 struct GNUNET_RESOLVER_RequestHandle *rh = cls;
883
884 rh->task = NULL;
885 if (GNUNET_NO == rh->direction)
886 {
887 LOG (GNUNET_ERROR_TYPE_INFO,
888 _ ("Timeout trying to resolve hostname `%s'.\n"),
889 (const char *) &rh[1]);
890 if (NULL != rh->addr_callback)
891 rh->addr_callback (rh->cls,
892 NULL,
893 0);
894 }
895 else
896 {
897#if ! defined(GNUNET_CULL_LOGGING)
898 char buf[INET6_ADDRSTRLEN];
899
900 LOG (GNUNET_ERROR_TYPE_INFO,
901 _ ("Timeout trying to resolve IP address `%s'.\n"),
902 inet_ntop (rh->af,
903 (const void *) &rh[1],
904 buf,
905 sizeof(buf)));
906#endif
907 if (GNUNET_NO == rh->received_response)
908 {
909 char *nret;
910
911 nret = no_resolve (rh->af,
912 &rh[1],
913 rh->data_len);
914 if (NULL != rh->name_callback)
915 rh->name_callback (rh->cls, nret);
916 GNUNET_free (nret);
917 }
918 /* finally, make termination call */
919 if (NULL != rh->name_callback)
920 rh->name_callback (rh->cls,
921 NULL);
922 }
923 rh->was_transmitted = GNUNET_NO;
924 GNUNET_RESOLVER_request_cancel (rh);
925 process_requests ();
926}

References _, GNUNET_RESOLVER_RequestHandle::af, GNUNET_RESOLVER_RequestHandle::cls, GNUNET_RESOLVER_RequestHandle::direction, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_NO, GNUNET_RESOLVER_request_cancel(), LOG, no_resolve(), process_requests(), GNUNET_RESOLVER_RequestHandle::task, and GNUNET_RESOLVER_RequestHandle::was_transmitted.

Referenced by GNUNET_RESOLVER_hostname_get(), and GNUNET_RESOLVER_ip_get().

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

◆ numeric_reverse()

static void numeric_reverse ( void *  cls)
static

We've been asked to convert an address to a string without a reverse lookup, either because the client asked for it or because the DNS lookup hit a timeout.

Do the numeric conversion and invoke the callback.

Parameters
clsstruct GNUNET_RESOLVER_RequestHandle for the request

Definition at line 1030 of file resolver_api.c.

1031{
1032 struct GNUNET_RESOLVER_RequestHandle *rh = cls;
1033 char *result;
1034
1035 rh->task = NULL;
1036 result = no_resolve (rh->af,
1037 &rh[1],
1038 rh->data_len);
1039 LOG (GNUNET_ERROR_TYPE_DEBUG,
1040 "Resolver returns `%s'.\n",
1041 result);
1042 if (NULL != result)
1043 {
1044 rh->name_callback (rh->cls,
1045 result);
1046 GNUNET_free (result);
1047 }
1048 rh->name_callback (rh->cls,
1049 NULL);
1050 if (NULL != rh->task)
1051 {
1052 GNUNET_SCHEDULER_cancel (rh->task);
1053 rh->task = NULL;
1054 }
1055 GNUNET_free (rh);
1056}

References GNUNET_RESOLVER_RequestHandle::af, GNUNET_RESOLVER_RequestHandle::cls, GNUNET_RESOLVER_RequestHandle::data_len, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_SCHEDULER_cancel(), LOG, GNUNET_RESOLVER_RequestHandle::name_callback, no_resolve(), result, and GNUNET_RESOLVER_RequestHandle::task.

Referenced by GNUNET_RESOLVER_hostname_get().

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

Variable Documentation

◆ loopback

const char* loopback[]
static
Initial value:
= {
"localhost",
"ip6-localnet",
NULL
}

Possible hostnames for "loopback".

Definition at line 48 of file resolver_api.c.

48 {
49 "localhost",
50 "ip6-localnet",
51 NULL
52};

Referenced by check_config(), and GNUNET_RESOLVER_ip_get().

◆ resolver_cfg

const struct GNUNET_CONFIGURATION_Handle* resolver_cfg
static

Configuration.

Definition at line 58 of file resolver_api.c.

Referenced by check_config(), GNUNET_RESOLVER_connect(), reconnect(), and reconnect_task().

◆ mq

struct GNUNET_MQ_Handle* mq
static

Our connection to the resolver service, created on-demand, but then persists until error or shutdown.

Definition at line 64 of file resolver_api.c.

Referenced by add_service_handle(), adv_transmit(), cadet_mq_cancel_impl(), cadet_mq_destroy_impl(), cadet_mq_send_impl(), callback_client_connect(), check_peer_online(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), connect_cb(), connect_cb(), connect_cb(), connect_handler(), connect_handler(), connect_notify(), connection_client_cancel_impl(), connection_client_destroy_impl(), connection_client_send_impl(), connects(), continue_writing(), core_connect_cb(), core_connect_cb(), core_connects(), core_mq_cancel_impl(), core_mq_destroy_impl(), core_mq_send_impl(), create_srv_handle(), do_send(), GCP_set_mq(), GNUNET_CADET_drop_message(), GNUNET_FS_indexing_send_list(), GNUNET_MQ_assoc_add(), GNUNET_MQ_assoc_get(), GNUNET_MQ_assoc_remove(), GNUNET_MQ_destroy(), GNUNET_MQ_destroy_notify(), GNUNET_MQ_destroy_notify_cancel(), GNUNET_MQ_env_get_options(), GNUNET_MQ_get_current_envelope(), GNUNET_MQ_get_last_envelope(), GNUNET_MQ_get_length(), GNUNET_MQ_impl_current(), GNUNET_MQ_impl_send_continue(), GNUNET_MQ_impl_send_in_flight(), GNUNET_MQ_impl_state(), GNUNET_MQ_inject_error(), GNUNET_MQ_inject_message(), GNUNET_MQ_queue_for_callbacks(), GNUNET_MQ_send(), GNUNET_MQ_send_cancel(), GNUNET_MQ_send_copy(), GNUNET_MQ_set_handlers_closure(), GNUNET_MQ_set_options(), GNUNET_MQ_unsent_head(), GNUNET_notification_context_add(), GNUNET_RESOLVER_disconnect(), GNUNET_TRANSPORT_communicator_mq_add(), GSC_KX_handle_client_monitor_peers(), GSF_peer_connect_handler(), handle_core_connect(), handle_core_connect(), handle_response(), handle_start(), handle_transport_notify_connect(), impl_send_continue(), mq_destroy(), mq_destroy(), mq_destroy(), mq_destroy_d(), mq_destroy_d(), mq_destroy_d(), mq_destroy_impl(), mq_destroy_kx(), mq_error_handler(), mq_send(), mq_send(), mq_send(), mq_send_d(), mq_send_d(), mq_send_d(), mq_send_impl(), mq_send_kx(), notify_connect(), notify_connect(), notify_connect(), path_info_iterator(), process_requests(), queue_destroy(), reconnect(), reconnect_task(), return_agpl(), return_agpl(), send_message(), send_msg_with_kx(), send_simple_cb(), send_simple_cb(), send_simple_cb(), send_to_channel(), send_tunnel_envelope(), service_mq_cancel(), service_mq_send(), set_mq(), and transmit_pending().

◆ req_head

struct GNUNET_RESOLVER_RequestHandle* req_head
static

Head of DLL of requests.

Definition at line 69 of file resolver_api.c.

Referenced by check_disconnect(), GNUNET_RESOLVER_disconnect(), GNUNET_RESOLVER_hostname_get(), GNUNET_RESOLVER_ip_get(), GNUNET_RESOLVER_request_cancel(), handle_response(), process_requests(), reconnect(), and reconnect_task().

◆ req_tail

struct GNUNET_RESOLVER_RequestHandle* req_tail
static

Tail of DLL of requests.

Definition at line 74 of file resolver_api.c.

Referenced by GNUNET_RESOLVER_disconnect(), GNUNET_RESOLVER_hostname_get(), GNUNET_RESOLVER_ip_get(), GNUNET_RESOLVER_request_cancel(), and reconnect().

◆ last_request_id

uint32_t last_request_id
static

ID of the last request we sent to the service.

Definition at line 79 of file resolver_api.c.

Referenced by GNUNET_RESOLVER_hostname_get(), and GNUNET_RESOLVER_ip_get().

◆ backoff

struct GNUNET_TIME_Relative backoff
static

How long should we wait to reconnect?

Definition at line 84 of file resolver_api.c.

Referenced by GNUNET_RESOLVER_connect(), reconnect(), and shutdown_task().

◆ r_task

struct GNUNET_SCHEDULER_Task* r_task
static

Task for reconnecting.

Definition at line 89 of file resolver_api.c.

Referenced by check_disconnect(), GNUNET_RESOLVER_disconnect(), reconnect(), and reconnect_task().

◆ s_task

struct GNUNET_SCHEDULER_Task* s_task
static

Task ID of shutdown task; only present while we have a connection to the resolver service.

Definition at line 95 of file resolver_api.c.

Referenced by check_disconnect(), GNUNET_RESOLVER_disconnect(), GNUNET_RESOLVER_hostname_get(), GNUNET_RESOLVER_ip_get(), process_requests(), and shutdown_task().