#include "gnunet_server_lib.h"
#include "resolver.h"
+#define LOG(kind,...) GNUNET_log_from (kind, "resolver-api", __VA_ARGS__)
+
+#define LOG_STRERROR(kind,syscall) GNUNET_log_from_strerror (kind, "resolver-api", syscall)
+
/**
* Maximum supported length for a hostname
*/
/**
* Configuration.
*/
-static const struct GNUNET_CONFIGURATION_Handle *cfg;
+static const struct GNUNET_CONFIGURATION_Handle *resolver_cfg;
/**
* Our connection to the resolver service, created on-demand, but then
* (or equivalent).
*/
static void
-check_config (const struct GNUNET_CONFIGURATION_Handle *cfg)
+check_config ()
{
char *hostname;
unsigned int i;
v6.sin6_len = sizeof (v6);
#endif
if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_string (cfg,
- "resolver", "HOSTNAME", &hostname))
+ GNUNET_CONFIGURATION_get_value_string (resolver_cfg, "resolver",
+ "HOSTNAME", &hostname))
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Must specify `%s' for `%s' in configuration!\n"),
- "HOSTNAME", "resolver");
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ _("Must specify `%s' for `%s' in configuration!\n"), "HOSTNAME",
+ "resolver");
GNUNET_assert (0);
}
- if ((1 != inet_pton (AF_INET,
- hostname,
- &v4)) || (1 != inet_pton (AF_INET6, hostname, &v6)))
+ if ((1 != inet_pton (AF_INET, hostname, &v4)) ||
+ (1 != inet_pton (AF_INET6, hostname, &v6)))
{
GNUNET_free (hostname);
return;
GNUNET_free (hostname);
return;
}
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _
- ("Must specify `%s' or numeric IP address for `%s' of `%s' in configuration!\n"),
- "localhost", "HOSTNAME", "resolver");
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ _
+ ("Must specify `%s' or numeric IP address for `%s' of `%s' in configuration!\n"),
+ "localhost", "HOSTNAME", "resolver");
GNUNET_free (hostname);
GNUNET_assert (0);
}
/**
* Create the connection to the resolver service.
*
- * @param c configuration to use
+ * @param cfg configuration to use
*/
void
-GNUNET_RESOLVER_connect (const struct GNUNET_CONFIGURATION_Handle *c)
+GNUNET_RESOLVER_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
{
- GNUNET_assert (NULL != c);
- check_config (c);
+ GNUNET_assert (NULL != cfg);
backoff = GNUNET_TIME_UNIT_MILLISECONDS;
- cfg = c;
+ resolver_cfg = cfg;
+ check_config ();
}
if (NULL != client)
{
#if DEBUG_RESOLVER
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from DNS service\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from DNS service\n");
#endif
GNUNET_CLIENT_disconnect (client, GNUNET_NO);
client = NULL;
/**
* Convert IP address to string without DNS resolution.
*
- * @param sa the address
+ * @param sa the address
* @param salen number of bytes in sa
* @return address as a string, NULL on error
*/
if (salen != sizeof (struct sockaddr_in))
return NULL;
if (NULL ==
- inet_ntop (AF_INET,
- &((struct sockaddr_in *) sa)->sin_addr,
- inet4, INET_ADDRSTRLEN))
+ inet_ntop (AF_INET, &((struct sockaddr_in *) sa)->sin_addr, inet4,
+ INET_ADDRSTRLEN))
{
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "inet_ntop");
+ LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "inet_ntop");
return NULL;
}
ret = GNUNET_strdup (inet4);
if (salen != sizeof (struct sockaddr_in6))
return NULL;
if (NULL ==
- inet_ntop (AF_INET6,
- &((struct sockaddr_in6 *) sa)->sin6_addr,
- inet6, INET6_ADDRSTRLEN))
+ inet_ntop (AF_INET6, &((struct sockaddr_in6 *) sa)->sin6_addr, inet6,
+ INET6_ADDRSTRLEN))
{
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "inet_ntop");
+ LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "inet_ntop");
return NULL;
}
ret = GNUNET_strdup (inet6);
/**
* Adjust exponential back-off and reconnect to the service.
*/
-static void reconnect ();
+static void
+reconnect ();
/**
* Process pending requests to the resolver.
- *
- * @param h handle to the resolver
*/
-static void process_requests ();
+static void
+process_requests ();
/**
socklen_t salen;
#if DEBUG_RESOLVER
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Receiving response from DNS service\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Receiving response from DNS service\n");
#endif
if (msg == NULL)
{
if (NULL != rh->name_callback)
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Timeout trying to resolve IP address `%s'.\n"),
- GNUNET_a2s ((const void *) &rh[1], rh->data_len));
+ LOG (GNUNET_ERROR_TYPE_INFO,
+ _("Timeout trying to resolve IP address `%s'.\n"),
+ GNUNET_a2s ((const void *) &rh[1], rh->data_len));
else
- GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Timeout trying to resolve hostname `%s'.\n"),
- (const char *) &rh[1]);
+ LOG (GNUNET_ERROR_TYPE_INFO,
+ _("Timeout trying to resolve hostname `%s'.\n"),
+ (const char *) &rh[1]);
/* check if request was canceled */
if (rh->was_transmitted != GNUNET_SYSERR)
{
return;
}
#if DEBUG_RESOLVER
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- _("Resolver returns `%s' for IP `%s'.\n"),
- hostname, GNUNET_a2s ((const void *) &rh[1], rh->data_len));
+ LOG (GNUNET_ERROR_TYPE_DEBUG, _("Resolver returns `%s' for IP `%s'.\n"),
+ hostname, GNUNET_a2s ((const void *) &rh[1], rh->data_len));
#endif
if (rh->was_transmitted != GNUNET_SYSERR)
rh->name_callback (rh->cls, hostname);
rh->received_response = GNUNET_YES;
- GNUNET_CLIENT_receive (client,
- &handle_response,
- rh,
+ GNUNET_CLIENT_receive (client, &handle_response, rh,
GNUNET_TIME_absolute_get_remaining (rh->timeout));
}
/* return lookup results to caller */
{
char *ips = no_resolve (sa, salen);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Resolver returns `%s' for `%s'.\n",
- ips, (const char *) &rh[1]);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Resolver returns `%s' for `%s'.\n", ips,
+ (const char *) &rh[1]);
GNUNET_free (ips);
}
#endif
rh->addr_callback (rh->cls, sa, salen);
- GNUNET_CLIENT_receive (client,
- &handle_response,
- rh,
+ GNUNET_CLIENT_receive (client, &handle_response, rh,
GNUNET_TIME_absolute_get_remaining (rh->timeout));
}
}
/**
- * We've been asked to lookup the address for a hostname and were
+ * 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.
*
/**
- * We've been asked to lookup the address for a hostname and were
+ * 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.
*
/**
* Process pending requests to the resolver.
- *
- * @param h handle to the resolver
*/
static void
process_requests ()
{
/* nothing to do, release socket really soon if there is nothing
* else happening... */
- s_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
- &shutdown_task, NULL);
+ s_task =
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
+ &shutdown_task, NULL);
return;
}
if (GNUNET_YES == rh->was_transmitted)
msg->domain = htonl (rh->domain);
memcpy (&msg[1], &rh[1], rh->data_len);
#if DEBUG_RESOLVER
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Transmitting DNS resolution request to DNS service\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Transmitting DNS resolution request to DNS service\n");
#endif
if (GNUNET_OK !=
- GNUNET_CLIENT_transmit_and_get_response (client,
- &msg->header,
+ GNUNET_CLIENT_transmit_and_get_response (client, &msg->header,
GNUNET_TIME_absolute_get_remaining
(rh->timeout), GNUNET_YES,
&handle_response, rh))
if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
return;
#if DEBUG_RESOLVER
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Trying to connect to DNS service\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Trying to connect to DNS service\n");
#endif
- client = GNUNET_CLIENT_connect ("resolver", cfg);
+ client = GNUNET_CLIENT_connect ("resolver", resolver_cfg);
if (NULL == client)
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Failed to connect, will try again later\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Failed to connect, will try again later\n");
reconnect ();
return;
}
}
}
#if DEBUG_RESOLVER
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Will try to connect to DNS service in %llu ms\n",
- (unsigned long long) backoff.rel_value);
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Will try to connect to DNS service in %llu ms\n",
+ (unsigned long long) backoff.rel_value);
#endif
- GNUNET_assert (NULL != cfg);
+ GNUNET_assert (NULL != resolver_cfg);
r_task = GNUNET_SCHEDULER_add_delayed (backoff, &reconnect_task, NULL);
backoff = GNUNET_TIME_relative_multiply (backoff, 2);
}
* @return handle that can be used to cancel the request, NULL on error
*/
struct GNUNET_RESOLVER_RequestHandle *
-GNUNET_RESOLVER_ip_get (const char *hostname,
- int domain,
+GNUNET_RESOLVER_ip_get (const char *hostname, int domain,
struct GNUNET_TIME_Relative timeout,
GNUNET_RESOLVER_AddressCallback callback,
void *callback_cls)
rh->timeout = GNUNET_TIME_relative_to_absolute (timeout);
rh->direction = GNUNET_NO;
/* first, check if this is a numeric address */
- if (((1 == inet_pton (AF_INET,
- hostname,
- &v4)) &&
+ if (((1 == inet_pton (AF_INET, hostname, &v4)) &&
((domain == AF_INET) || (domain == AF_UNSPEC))) ||
- ((1 == inet_pton (AF_INET6,
- hostname,
- &v6)) &&
+ ((1 == inet_pton (AF_INET6, hostname, &v6)) &&
((domain == AF_INET6) || (domain == AF_UNSPEC))))
{
rh->task = GNUNET_SCHEDULER_add_now (&numeric_resolution, rh);
result = no_resolve ((const struct sockaddr *) &rh[1], rh->data_len);
#if DEBUG_RESOLVER
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Resolver returns `%s'.\n"), result);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, _("Resolver returns `%s'.\n"), result);
#endif
if (result != NULL)
{
* @return handle that can be used to cancel the request
*/
struct GNUNET_RESOLVER_RequestHandle *
-GNUNET_RESOLVER_hostname_get (const struct sockaddr *sa,
- socklen_t salen,
+GNUNET_RESOLVER_hostname_get (const struct sockaddr *sa, socklen_t salen,
int do_resolve,
struct GNUNET_TIME_Relative timeout,
GNUNET_RESOLVER_HostnameCallback callback,
{
struct GNUNET_RESOLVER_RequestHandle *rh;
- check_config (cfg);
+ check_config ();
rh = GNUNET_malloc (sizeof (struct GNUNET_RESOLVER_RequestHandle) + salen);
rh->name_callback = callback;
rh->cls = cls;
if (0 != gethostname (hostname, sizeof (hostname) - 1))
{
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR |
- GNUNET_ERROR_TYPE_BULK, "gethostname");
+ LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+ "gethostname");
return NULL;
}
#if DEBUG_RESOLVER
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- _("Resolving our FQDN `%s'\n"), hostname);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, _("Resolving our FQDN `%s'\n"), hostname);
#endif
host = gethostbyname (hostname);
if (NULL == host)
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Could not resolve our FQDN : %s\n"), hstrerror (h_errno));
+ LOG (GNUNET_ERROR_TYPE_ERROR, _("Could not resolve our FQDN : %s\n"),
+ hstrerror (h_errno));
return NULL;
}
return GNUNET_strdup (host->h_name);
if (0 != gethostname (hostname, sizeof (hostname) - 1))
{
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR |
- GNUNET_ERROR_TYPE_BULK, "gethostname");
+ LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+ "gethostname");
return NULL;
}
#if DEBUG_RESOLVER
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- _("Resolving our hostname `%s'\n"), hostname);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, _("Resolving our hostname `%s'\n"), hostname);
#endif
return GNUNET_RESOLVER_ip_get (hostname, domain, timeout, callback, cls);
}