2 This file is part of GNUnet.
3 Copyright (C) 2009-2018 GNUnet e.V.
5 GNUnet is free software: you can redistribute it and/or modify it
6 under the terms of the GNU Affero General Public License as published
7 by the Free Software Foundation, either version 3 of the License,
8 or (at your option) any later version.
10 GNUnet is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Affero General Public License for more details.
15 You should have received a copy of the GNU Affero General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>.
18 SPDX-License-Identifier: AGPL3.0-or-later
22 * @file util/resolver_api.c
23 * @brief resolver for writing a tool
24 * @author Christian Grothoff
27 #include "gnunet_util_lib.h"
28 #include "gnunet_protocols.h"
29 #include "gnunet_resolver_service.h"
32 #define LOG(kind, ...) GNUNET_log_from (kind, "util-resolver-api", __VA_ARGS__)
34 #define LOG_STRERROR(kind, syscall) GNUNET_log_from_strerror (kind, \
35 "util-resolver-api", \
39 * Maximum supported length for a hostname
41 #define MAX_HOSTNAME 1024
45 * Possible hostnames for "loopback".
47 static const char *loopback[] = {
57 static const struct GNUNET_CONFIGURATION_Handle *resolver_cfg;
60 * Our connection to the resolver service, created on-demand, but then
61 * persists until error or shutdown.
63 static struct GNUNET_MQ_Handle *mq;
66 * Head of DLL of requests.
68 static struct GNUNET_RESOLVER_RequestHandle *req_head;
71 * Tail of DLL of requests.
73 static struct GNUNET_RESOLVER_RequestHandle *req_tail;
76 * ID of the last request we sent to the service
78 static uint32_t last_request_id;
81 * How long should we wait to reconnect?
83 static struct GNUNET_TIME_Relative backoff;
86 * Task for reconnecting.
88 static struct GNUNET_SCHEDULER_Task *r_task;
91 * Task ID of shutdown task; only present while we have a
92 * connection to the resolver service.
94 static struct GNUNET_SCHEDULER_Task *s_task;
98 * Handle to a request given to the resolver. Can be used to cancel
99 * the request prior to the timeout or successful execution. Also
100 * used to track our internal state for the request.
102 struct GNUNET_RESOLVER_RequestHandle
105 * Next entry in DLL of requests.
107 struct GNUNET_RESOLVER_RequestHandle *next;
110 * Previous entry in DLL of requests.
112 struct GNUNET_RESOLVER_RequestHandle *prev;
115 * Callback if this is an name resolution request,
118 GNUNET_RESOLVER_AddressCallback addr_callback;
121 * Callback if this is a reverse lookup request,
124 GNUNET_RESOLVER_HostnameCallback name_callback;
127 * Closure for the callbacks.
132 * When should this request time out?
134 struct GNUNET_TIME_Absolute timeout;
137 * Task handle for making reply callbacks in numeric lookups
138 * asynchronous, and for timeout handling.
140 struct GNUNET_SCHEDULER_Task *task;
143 * Desired address family.
148 * Identifies the request. The response will contain this id.
153 * Has this request been transmitted to the service?
154 * #GNUNET_YES if transmitted
155 * #GNUNET_YES if not transmitted
156 * #GNUNET_SYSERR when request was canceled
161 * Did we add this request to the queue?
166 * Desired direction (IP to name or name to IP)
171 * #GNUNET_YES if a response was received
173 int received_response;
176 * Length of the data that follows this struct.
183 * Check that the resolver service runs on localhost
186 * @return #GNUNET_OK if the resolver is properly configured,
187 * #GNUNET_SYSERR otherwise.
193 struct sockaddr_in v4;
194 struct sockaddr_in6 v6;
197 GNUNET_CONFIGURATION_have_value (resolver_cfg,
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);
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);
213 GNUNET_CONFIGURATION_get_value_string (resolver_cfg,
218 LOG (GNUNET_ERROR_TYPE_INFO,
220 "Missing `%s' for `%s' in configuration, DNS resolution will be unavailable.\n"),
223 return GNUNET_SYSERR;
225 if ((1 == inet_pton (AF_INET, hostname, &v4)) ||
226 (1 == inet_pton (AF_INET6, hostname, &v6)))
228 GNUNET_free (hostname);
231 for (unsigned int i = 0;
234 if (0 == strcasecmp (loopback[i],
237 GNUNET_free (hostname);
240 LOG (GNUNET_ERROR_TYPE_INFO,
242 "Missing `%s' or numeric IP address for `%s' of `%s' in configuration, DNS resolution will be unavailable.\n"),
246 GNUNET_free (hostname);
247 return GNUNET_SYSERR;
252 * Create the connection to the resolver service.
254 * @param cfg configuration to use
257 GNUNET_RESOLVER_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
259 GNUNET_assert (NULL != cfg);
260 backoff = GNUNET_TIME_UNIT_MILLISECONDS;
266 * Destroy the connection to the resolver service.
269 GNUNET_RESOLVER_disconnect ()
271 struct GNUNET_RESOLVER_RequestHandle *rh;
273 while (NULL != (rh = req_head))
275 GNUNET_assert (GNUNET_SYSERR == rh->was_transmitted);
276 GNUNET_CONTAINER_DLL_remove (req_head,
283 LOG (GNUNET_ERROR_TYPE_DEBUG,
284 "Disconnecting from DNS service\n");
285 GNUNET_MQ_destroy (mq);
290 GNUNET_SCHEDULER_cancel (r_task);
295 GNUNET_SCHEDULER_cancel (s_task);
302 * Task executed on system shutdown.
305 shutdown_task (void *cls)
309 GNUNET_RESOLVER_disconnect ();
310 backoff = GNUNET_TIME_UNIT_MILLISECONDS;
315 * Consider disconnecting if we have no further requests pending.
320 for (struct GNUNET_RESOLVER_RequestHandle *rh = req_head;
323 if (GNUNET_SYSERR != rh->was_transmitted)
327 GNUNET_SCHEDULER_cancel (r_task);
332 s_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
339 * Convert IP address to string without DNS resolution.
341 * @param af address family
342 * @param ip the address
343 * @param ip_len number of bytes in @a ip
344 * @return address as a string, NULL on error
351 char buf[INET6_ADDRSTRLEN];
356 if (ip_len != sizeof(struct in_addr))
364 LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
371 if (ip_len != sizeof(struct in6_addr))
379 LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
389 return GNUNET_strdup (buf);
394 * Adjust exponential back-off and reconnect to the service.
401 * Generic error handler, called with the appropriate error code and
402 * the same closure specified at the creation of the message queue.
403 * Not every message queue implementation supports an error handler.
406 * @param error error code
409 mq_error_handler (void *cls,
410 enum GNUNET_MQ_Error error)
413 GNUNET_MQ_destroy (mq);
415 LOG (GNUNET_ERROR_TYPE_DEBUG,
416 "MQ error %d, reconnecting\n",
423 * Process pending requests to the resolver.
428 struct GNUNET_RESOLVER_GetMessage *msg;
429 struct GNUNET_MQ_Envelope *env;
430 struct GNUNET_RESOLVER_RequestHandle *rh = req_head;
439 /* nothing to do, release socket really soon if there is nothing
440 * else happening... */
443 GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
448 if (GNUNET_NO != rh->was_transmitted)
449 return; /* waiting for reply */
450 env = GNUNET_MQ_msg_extra (msg,
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],
459 LOG (GNUNET_ERROR_TYPE_DEBUG,
460 "Transmitting DNS resolution request (ID %u) to DNS service\n",
464 rh->was_transmitted = GNUNET_YES;
469 * Check validity of response with a hostname for a DNS lookup.
472 * @param msg message with the hostname
475 check_response (void *cls,
476 const struct GNUNET_RESOLVER_ResponseMessage *msg)
481 /* implemented in #handle_response() for now */
487 * Check validity of response with a hostname for a DNS lookup.
488 * NOTE: right now rather messy, might want to use different
489 * message types for different response formats in the future.
492 * @param msg message with the response
495 handle_response (void *cls,
496 const struct GNUNET_RESOLVER_ResponseMessage *msg)
498 struct GNUNET_RESOLVER_RequestHandle *rh = req_head;
501 uint32_t client_request_id = msg->client_id;
503 for (; rh != NULL; rh = rh->next)
505 if (rh->id == client_request_id)
512 /* Resolver service sent extra replies to query (after terminator)? Bad! */
514 GNUNET_MQ_destroy (mq);
519 size = ntohs (msg->header.size);
520 if (size == sizeof(struct GNUNET_RESOLVER_ResponseMessage))
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)
528 /* no reverse lookup was successful, return IP as string */
529 if (NULL != rh->name_callback)
531 if (GNUNET_NO == rh->received_response)
533 nret = no_resolve (rh->af,
536 rh->name_callback (rh->cls, nret);
539 /* finally, make termination call */
540 if (GNUNET_SYSERR != rh->was_transmitted)
541 rh->name_callback (rh->cls,
544 if ((NULL != rh->addr_callback) &&
545 (GNUNET_SYSERR != rh->was_transmitted))
546 rh->addr_callback (rh->cls,
550 rh->was_transmitted = GNUNET_NO;
551 GNUNET_RESOLVER_request_cancel (rh);
555 /* return reverse lookup results to caller */
556 if (NULL != rh->name_callback)
558 const char *hostname;
560 hostname = (const char *) &msg[1];
561 if (hostname[size - sizeof(struct GNUNET_RESOLVER_ResponseMessage) - 1] !=
565 if (GNUNET_SYSERR != rh->was_transmitted)
566 rh->name_callback (rh->cls,
568 rh->was_transmitted = GNUNET_NO;
569 GNUNET_RESOLVER_request_cancel (rh);
570 GNUNET_MQ_destroy (mq);
575 LOG (GNUNET_ERROR_TYPE_DEBUG,
576 "Resolver returns `%s' for IP `%s'.\n",
578 GNUNET_a2s ((const void *) &rh[1],
580 if (rh->was_transmitted != GNUNET_SYSERR)
581 rh->name_callback (rh->cls,
583 rh->received_response = GNUNET_YES;
585 /* return lookup results to caller */
586 if (NULL != rh->addr_callback)
588 struct sockaddr_in v4;
589 struct sockaddr_in6 v6;
590 const struct sockaddr *sa;
596 ip_len = size - sizeof(struct GNUNET_RESOLVER_ResponseMessage);
597 if (ip_len == sizeof(struct in_addr))
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);
606 sa = (const struct sockaddr *) &v4;
608 else if (ip_len == sizeof(struct in6_addr))
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);
617 sa = (const struct sockaddr *) &v6;
622 if (GNUNET_SYSERR != rh->was_transmitted)
623 rh->addr_callback (rh->cls,
626 rh->was_transmitted = GNUNET_NO;
627 GNUNET_RESOLVER_request_cancel (rh);
628 GNUNET_MQ_destroy (mq);
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,
644 * We've been asked to lookup the address for a hostname and were
645 * given a valid numeric string. Perform the callbacks for the
648 * @param cls `struct GNUNET_RESOLVER_RequestHandle` for the request
651 numeric_resolution (void *cls)
653 struct GNUNET_RESOLVER_RequestHandle *rh = cls;
654 struct sockaddr_in v4;
655 struct sockaddr_in6 v6;
656 const char *hostname;
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);
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);
669 hostname = (const char *) &rh[1];
670 if (((rh->af == AF_UNSPEC) ||
671 (rh->af == AF_INET)) &&
672 (1 == inet_pton (AF_INET,
676 rh->addr_callback (rh->cls,
677 (const struct sockaddr *) &v4,
679 if ((rh->af == AF_UNSPEC) &&
680 (GNUNET_SYSERR != rh->was_transmitted) &&
681 (1 == inet_pton (AF_INET6,
685 /* this can happen on some systems IF "hostname" is "localhost" */
686 rh->addr_callback (rh->cls,
687 (const struct sockaddr *) &v6,
690 if (GNUNET_SYSERR != rh->was_transmitted)
691 rh->addr_callback (rh->cls,
697 if (((rh->af == AF_UNSPEC) ||
698 (rh->af == AF_INET6)) &&
699 (1 == inet_pton (AF_INET6,
703 rh->addr_callback (rh->cls,
704 (const struct sockaddr *) &v6,
706 if (GNUNET_SYSERR != rh->was_transmitted)
707 rh->addr_callback (rh->cls,
713 /* why are we here? this task should not have been scheduled! */
720 * We've been asked to lookup the address for a hostname and were
721 * given a variant of "loopback". Perform the callbacks for the
722 * respective loopback numeric addresses.
724 * @param cls `struct GNUNET_RESOLVER_RequestHandle` for the request
727 loopback_resolution (void *cls)
729 struct GNUNET_RESOLVER_RequestHandle *rh = cls;
730 struct sockaddr_in v4;
731 struct sockaddr_in6 v6;
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);
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);
745 v6.sin6_addr = in6addr_loopback;
749 rh->addr_callback (rh->cls,
750 (const struct sockaddr *) &v4,
755 rh->addr_callback (rh->cls,
756 (const struct sockaddr *) &v6,
761 rh->addr_callback (rh->cls,
762 (const struct sockaddr *) &v6,
764 rh->addr_callback (rh->cls,
765 (const struct sockaddr *) &v4,
774 if (GNUNET_SYSERR != rh->was_transmitted)
775 rh->addr_callback (rh->cls,
778 LOG (GNUNET_ERROR_TYPE_DEBUG,
779 "Finished resolving hostname `%s'.\n",
780 (const char *) &rh[1]);
786 * Now try to reconnect to the resolver service.
791 reconnect_task (void *cls)
793 struct GNUNET_MQ_MessageHandler handlers[] = {
794 GNUNET_MQ_hd_var_size (response,
795 GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE,
796 struct GNUNET_RESOLVER_ResponseMessage,
798 GNUNET_MQ_handler_end ()
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,
814 LOG (GNUNET_ERROR_TYPE_DEBUG,
815 "Failed to connect, will try again later\n");
824 * Adjust exponential back-off and reconnect to the service.
829 struct GNUNET_RESOLVER_RequestHandle *rh;
833 GNUNET_assert (NULL == mq);
834 if (NULL != (rh = req_head))
836 switch (rh->was_transmitted)
839 /* nothing more to do */
843 /* disconnected, transmit again! */
844 rh->was_transmitted = GNUNET_NO;
848 /* request was cancelled, remove entirely */
849 GNUNET_CONTAINER_DLL_remove (req_head,
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,
865 GNUNET_assert (NULL != resolver_cfg);
866 r_task = GNUNET_SCHEDULER_add_delayed (backoff,
869 backoff = GNUNET_TIME_STD_BACKOFF (backoff);
874 * A DNS resolution timed out. Notify the application.
876 * @param cls the `struct GNUNET_RESOLVER_RequestHandle *`
879 handle_lookup_timeout (void *cls)
881 struct GNUNET_RESOLVER_RequestHandle *rh = cls;
884 if (GNUNET_NO == rh->direction)
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,
896 #if ! defined(GNUNET_CULL_LOGGING)
897 char buf[INET6_ADDRSTRLEN];
899 LOG (GNUNET_ERROR_TYPE_INFO,
900 _ ("Timeout trying to resolve IP address `%s'.\n"),
902 (const void *) &rh[1],
906 if (GNUNET_NO == rh->received_response)
910 nret = no_resolve (rh->af,
913 if (NULL != rh->name_callback)
914 rh->name_callback (rh->cls, nret);
917 /* finally, make termination call */
918 if (NULL != rh->name_callback)
919 rh->name_callback (rh->cls,
922 rh->was_transmitted = GNUNET_NO;
923 GNUNET_RESOLVER_request_cancel (rh);
929 * Convert a string to one or more IP addresses.
931 * @param hostname the hostname to resolve
932 * @param af AF_INET or AF_INET6; use AF_UNSPEC for "any"
933 * @param callback function to call with addresses
934 * @param callback_cls closure for @a callback
935 * @param timeout how long to try resolving
936 * @return handle that can be used to cancel the request, NULL on error
938 struct GNUNET_RESOLVER_RequestHandle *
939 GNUNET_RESOLVER_ip_get (const char *hostname,
941 struct GNUNET_TIME_Relative timeout,
942 GNUNET_RESOLVER_AddressCallback callback,
945 struct GNUNET_RESOLVER_RequestHandle *rh;
950 slen = strlen (hostname) + 1;
951 if (slen + sizeof(struct GNUNET_RESOLVER_GetMessage) >=
952 GNUNET_MAX_MESSAGE_SIZE)
957 LOG (GNUNET_ERROR_TYPE_DEBUG,
958 "Trying to resolve hostname `%s'.\n",
960 rh = GNUNET_malloc (sizeof(struct GNUNET_RESOLVER_RequestHandle) + slen);
962 rh->id = ++last_request_id;
963 rh->addr_callback = callback;
964 rh->cls = callback_cls;
965 GNUNET_memcpy (&rh[1],
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,
976 (af == AF_UNSPEC))) ||
977 ((1 == inet_pton (AF_INET6,
983 rh->task = GNUNET_SCHEDULER_add_now (&numeric_resolution,
987 /* then, check if this is a loopback address */
988 for (unsigned int i = 0;
991 if (0 == strcasecmp (loopback[i],
994 rh->task = GNUNET_SCHEDULER_add_now (&loopback_resolution,
998 if (GNUNET_OK != check_config ())
1003 rh->task = GNUNET_SCHEDULER_add_delayed (timeout,
1004 &handle_lookup_timeout,
1006 GNUNET_CONTAINER_DLL_insert_tail (req_head,
1009 rh->was_queued = GNUNET_YES;
1012 GNUNET_SCHEDULER_cancel (s_task);
1015 process_requests ();
1021 * We've been asked to convert an address to a string without
1022 * a reverse lookup, either because the client asked for it
1023 * or because the DNS lookup hit a timeout. Do the numeric
1024 * conversion and invoke the callback.
1026 * @param cls `struct GNUNET_RESOLVER_RequestHandle` for the request
1029 numeric_reverse (void *cls)
1031 struct GNUNET_RESOLVER_RequestHandle *rh = cls;
1035 result = no_resolve (rh->af,
1038 LOG (GNUNET_ERROR_TYPE_DEBUG,
1039 "Resolver returns `%s'.\n",
1043 rh->name_callback (rh->cls,
1045 GNUNET_free (result);
1047 rh->name_callback (rh->cls,
1049 if (NULL != rh->task)
1051 GNUNET_SCHEDULER_cancel (rh->task);
1059 * Get an IP address as a string.
1061 * @param sa host address
1062 * @param salen length of host address in @a sa
1063 * @param do_resolve use #GNUNET_NO to return numeric hostname
1064 * @param timeout how long to try resolving
1065 * @param callback function to call with hostnames
1066 * last callback is NULL when finished
1067 * @param cls closure for @a callback
1068 * @return handle that can be used to cancel the request
1070 struct GNUNET_RESOLVER_RequestHandle *
1071 GNUNET_RESOLVER_hostname_get (const struct sockaddr *sa,
1074 struct GNUNET_TIME_Relative timeout,
1075 GNUNET_RESOLVER_HostnameCallback callback,
1078 struct GNUNET_RESOLVER_RequestHandle *rh;
1082 if (GNUNET_OK != check_config ())
1084 LOG (GNUNET_ERROR_TYPE_ERROR,
1085 _ ("Resolver not configured correctly.\n"));
1089 switch (sa->sa_family)
1092 GNUNET_assert (salen == sizeof(struct sockaddr_in));
1093 ip_len = sizeof(struct in_addr);
1094 ip = &((const struct sockaddr_in*) sa)->sin_addr;
1098 GNUNET_assert (salen == sizeof(struct sockaddr_in6));
1099 ip_len = sizeof(struct in6_addr);
1100 ip = &((const struct sockaddr_in6*) sa)->sin6_addr;
1107 rh = GNUNET_malloc (sizeof(struct GNUNET_RESOLVER_RequestHandle) + salen);
1108 rh->name_callback = callback;
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],
1116 rh->data_len = ip_len;
1117 rh->direction = GNUNET_YES;
1118 rh->received_response = GNUNET_NO;
1119 if (GNUNET_NO == do_resolve)
1121 rh->task = GNUNET_SCHEDULER_add_now (&numeric_reverse,
1125 rh->task = GNUNET_SCHEDULER_add_delayed (timeout,
1126 &handle_lookup_timeout,
1128 GNUNET_CONTAINER_DLL_insert_tail (req_head,
1131 rh->was_queued = GNUNET_YES;
1134 GNUNET_SCHEDULER_cancel (s_task);
1137 process_requests ();
1143 * Get local fully qualified af name
1148 GNUNET_RESOLVER_local_fqdn_get ()
1150 char hostname[GNUNET_OS_get_hostname_max_length () + 1];
1152 if (0 != gethostname (hostname,
1153 sizeof(hostname) - 1))
1155 LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
1159 LOG (GNUNET_ERROR_TYPE_DEBUG,
1160 "Resolving our FQDN `%s'\n",
1162 #if HAVE_GETADDRINFO
1164 struct addrinfo *ai;
1168 if (0 != (ret = getaddrinfo (hostname,
1173 LOG (GNUNET_ERROR_TYPE_ERROR,
1174 _ ("Could not resolve our FQDN: %s\n"),
1175 gai_strerror (ret));
1178 if (NULL != ai->ai_canonname)
1179 rval = GNUNET_strdup (ai->ai_canonname);
1181 rval = GNUNET_strdup (hostname);
1185 #elif HAVE_GETHOSTBYNAME2
1187 struct hostent *host;
1189 host = gethostbyname2 (hostname,
1192 host = gethostbyname2 (hostname,
1196 LOG (GNUNET_ERROR_TYPE_ERROR,
1197 _ ("Could not resolve our FQDN: %s\n"),
1198 hstrerror (h_errno));
1201 return GNUNET_strdup (host->h_name);
1203 #elif HAVE_GETHOSTBYNAME
1205 struct hostent *host;
1207 host = gethostbyname (hostname);
1210 LOG (GNUNET_ERROR_TYPE_ERROR,
1211 _ ("Could not resolve our FQDN: %s\n"),
1212 hstrerror (h_errno));
1215 return GNUNET_strdup (host->h_name);
1218 /* fallback: just hope name is already FQDN */
1219 return GNUNET_strdup (hostname);
1225 * Looking our own hostname.
1227 * @param af AF_INET or AF_INET6; use AF_UNSPEC for "any"
1228 * @param timeout how long to try resolving
1229 * @param callback function to call with addresses
1230 * @param cls closure for @a callback
1231 * @return handle that can be used to cancel the request, NULL on error
1233 struct GNUNET_RESOLVER_RequestHandle *
1234 GNUNET_RESOLVER_hostname_resolve (int af,
1235 struct GNUNET_TIME_Relative timeout,
1236 GNUNET_RESOLVER_AddressCallback callback,
1239 char hostname[GNUNET_OS_get_hostname_max_length () + 1];
1241 if (0 != gethostname (hostname, sizeof(hostname) - 1))
1243 LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
1247 LOG (GNUNET_ERROR_TYPE_DEBUG,
1248 "Resolving our hostname `%s'\n",
1250 return GNUNET_RESOLVER_ip_get (hostname,
1259 * Cancel a request that is still pending with the resolver.
1260 * Note that a client MUST NOT cancel a request that has
1261 * been completed (i.e, the callback has been called to
1262 * signal timeout or the final result).
1264 * @param rh handle of request to cancel
1267 GNUNET_RESOLVER_request_cancel (struct GNUNET_RESOLVER_RequestHandle *rh)
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)
1275 GNUNET_SCHEDULER_cancel (rh->task);
1278 if (GNUNET_NO == rh->was_transmitted)
1280 if (GNUNET_YES == rh->was_queued)
1281 GNUNET_CONTAINER_DLL_remove (req_head,
1285 check_disconnect ();
1288 GNUNET_assert (GNUNET_YES == rh->was_transmitted);
1289 rh->was_transmitted = GNUNET_SYSERR; /* mark as cancelled */
1290 check_disconnect ();
1294 /* end of resolver_api.c */