GNUnet  0.19.3

Asynchronous standard DNS lookups. More...

Collaboration diagram for Resolver service:

Typedefs

typedef void(* GNUNET_RESOLVER_AddressCallback) (void *cls, const struct sockaddr *addr, socklen_t addrlen)
 Function called by the resolver for each address obtained from DNS. More...
 
typedef void(* GNUNET_RESOLVER_HostnameCallback) (void *cls, const char *hostname)
 Function called by the resolver for each hostname obtained from DNS. More...
 

Functions

void GNUNET_RESOLVER_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
 Create the connection to the resolver service. More...
 
void GNUNET_RESOLVER_disconnect (void)
 Destroy the connection to the resolver service. More...
 
struct GNUNET_RESOLVER_RequestHandleGNUNET_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. More...
 
struct GNUNET_RESOLVER_RequestHandleGNUNET_RESOLVER_hostname_resolve (int af, struct GNUNET_TIME_Relative timeout, GNUNET_RESOLVER_AddressCallback callback, void *cls)
 Resolve our hostname to an IP address. More...
 
char * GNUNET_RESOLVER_local_fqdn_get (void)
 Get local fully qualified domain name. More...
 
struct GNUNET_RESOLVER_RequestHandleGNUNET_RESOLVER_hostname_get (const struct sockaddr *sa, socklen_t salen, int do_resolve, struct GNUNET_TIME_Relative timeout, GNUNET_RESOLVER_HostnameCallback callback, void *cls)
 Perform a reverse DNS lookup. More...
 
void GNUNET_RESOLVER_request_cancel (struct GNUNET_RESOLVER_RequestHandle *rh)
 Cancel a request that is still pending with the resolver. More...
 

Detailed Description

Asynchronous standard DNS lookups.

Typedef Documentation

◆ GNUNET_RESOLVER_AddressCallback

typedef void(* GNUNET_RESOLVER_AddressCallback) (void *cls, const struct sockaddr *addr, socklen_t addrlen)

Function called by the resolver for each address obtained from DNS.

Parameters
clsclosure
addrone of the addresses of the host, NULL for the last address
addrlenlength of addr

Definition at line 59 of file gnunet_resolver_service.h.

◆ GNUNET_RESOLVER_HostnameCallback

typedef void(* GNUNET_RESOLVER_HostnameCallback) (void *cls, const char *hostname)

Function called by the resolver for each hostname obtained from DNS.

Parameters
clsclosure
hostnameone of the names for the host, NULL on the last call to the callback

Definition at line 128 of file gnunet_resolver_service.h.

Function Documentation

◆ GNUNET_RESOLVER_connect()

void GNUNET_RESOLVER_connect ( const struct GNUNET_CONFIGURATION_Handle cfg)

Create the connection to the resolver service.

Parameters
cfgconfiguration to use

Definition at line 258 of file resolver_api.c.

259 {
260  GNUNET_assert (NULL != cfg);
262  resolver_cfg = cfg;
263 }
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_TIME_UNIT_MILLISECONDS
One millisecond.
static struct GNUNET_TIME_Relative backoff
How long should we wait to reconnect?
Definition: resolver_api.c:84
static const struct GNUNET_CONFIGURATION_Handle * resolver_cfg
Configuration.
Definition: resolver_api.c:58

References backoff, cfg, GNUNET_assert, GNUNET_TIME_UNIT_MILLISECONDS, and resolver_cfg.

Referenced by GNUNET_SERVICE_run_(), program_main(), reversal_test(), and service_task().

Here is the caller graph for this function:

◆ GNUNET_RESOLVER_disconnect()

void GNUNET_RESOLVER_disconnect ( void  )

Destroy the connection to the resolver service.

Definition at line 270 of file resolver_api.c.

271 {
273 
274  while (NULL != (rh = req_head))
275  {
278  req_tail,
279  rh);
280  GNUNET_free (rh);
281  }
282  if (NULL != mq)
283  {
285  "Disconnecting from DNS service\n");
287  mq = NULL;
288  }
289  if (NULL != r_task)
290  {
292  r_task = NULL;
293  }
294  if (NULL != s_task)
295  {
297  s_task = NULL;
298  }
299 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
@ GNUNET_SYSERR
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:683
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:975
static struct GNUNET_RESOLVER_RequestHandle * req_tail
Tail of DLL of requests.
Definition: resolver_api.c:74
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
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
static struct GNUNET_RESOLVER_RequestHandle * req_head
Head of DLL of requests.
Definition: resolver_api.c:69
static struct GNUNET_SCHEDULER_Task * r_task
Task for reconnecting.
Definition: resolver_api.c:89
#define LOG(kind,...)
Definition: resolver_api.c:33
Handle to a request given to the resolver.
Definition: resolver_api.c:104
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

References GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_cancel(), GNUNET_SYSERR, LOG, mq, r_task, req_head, req_tail, s_task, and GNUNET_RESOLVER_RequestHandle::was_transmitted.

Referenced by shutdown_task().

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

◆ 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.

Parameters
hostnamethe hostname to resolve
afAF_INET or AF_INET6; use AF_UNSPEC for "any"
callbackfunction to call with addresses
callback_clsclosure for callback
timeouthow long to try resolving
Returns
handle that can be used to cancel the request, NULL on error

Definition at line 940 of file resolver_api.c.

945 {
947  size_t slen;
948  struct in_addr v4;
949  struct in6_addr v6;
950 
951  slen = strlen (hostname) + 1;
952  if (slen + sizeof(struct GNUNET_RESOLVER_GetMessage) >=
954  {
955  GNUNET_break (0);
956  return NULL;
957  }
959  "Trying to resolve hostname `%s'.\n",
960  hostname);
961  rh = GNUNET_malloc (sizeof(struct GNUNET_RESOLVER_RequestHandle) + slen);
962  rh->af = af;
963  rh->id = ++last_request_id;
964  rh->addr_callback = callback;
965  rh->cls = callback_cls;
966  GNUNET_memcpy (&rh[1],
967  hostname,
968  slen);
969  rh->data_len = slen;
971  rh->direction = GNUNET_NO;
972  /* first, check if this is a numeric address */
973  if (((1 == inet_pton (AF_INET,
974  hostname,
975  &v4)) &&
976  ((af == AF_INET) ||
977  (af == AF_UNSPEC))) ||
978  ((1 == inet_pton (AF_INET6,
979  hostname,
980  &v6)) &&
981  ((af == AF_INET6) ||
982  (af == AF_UNSPEC))))
983  {
985  rh);
986  return rh;
987  }
988  /* then, check if this is a loopback address */
989  for (unsigned int i = 0;
990  NULL != loopback[i];
991  i++)
992  if (0 == strcasecmp (loopback[i],
993  hostname))
994  {
996  rh);
997  return rh;
998  }
999  if (GNUNET_OK != check_config ())
1000  {
1001  GNUNET_free (rh);
1002  return NULL;
1003  }
1006  rh);
1008  req_tail,
1009  rh);
1010  rh->was_queued = GNUNET_YES;
1011  if (NULL != s_task)
1012  {
1014  s_task = NULL;
1015  }
1016  process_requests ();
1017  return rh;
1018 }
static struct GNUNET_TIME_Relative timeout
Desired timeout for the lookup (default is no timeout).
Definition: gnunet-abd.c:61
static char * hostname
Our hostname; we give this to all the peers we start.
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message,...
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
#define GNUNET_malloc(size)
Wrapper around malloc.
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:1299
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:1272
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
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
static int check_config()
Check that the resolver service runs on localhost (or equivalent).
Definition: resolver_api.c:191
static const char * loopback[]
Possible hostnames for "loopback".
Definition: resolver_api.c:48
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
static uint32_t last_request_id
ID of the last request we sent to the service.
Definition: resolver_api.c:79
static void process_requests()
Process pending requests to the resolver.
Definition: resolver_api.c:427
static void handle_lookup_timeout(void *cls)
A DNS resolution timed out.
Definition: resolver_api.c:880
Request for the resolver.
Definition: resolver.h:44
struct GNUNET_SCHEDULER_Task * task
Task handle for making reply callbacks in numeric lookups asynchronous, and for timeout handling.
Definition: resolver_api.c:141
int was_queued
Did we add this request to the queue?
Definition: resolver_api.c:164
void * cls
Closure for the callbacks.
Definition: resolver_api.c:130
size_t data_len
Length of the data that follows this struct.
Definition: resolver_api.c:179
GNUNET_RESOLVER_AddressCallback addr_callback
Callback if this is an name resolution request, otherwise NULL.
Definition: resolver_api.c:119
int af
Desired address family.
Definition: resolver_api.c:146
uint32_t id
Identifies the request.
Definition: resolver_api.c:151
struct GNUNET_TIME_Absolute timeout
When should this request time out?
Definition: resolver_api.c:135
int direction
Desired direction (IP to name or name to IP)
Definition: resolver_api.c:169

References GNUNET_RESOLVER_RequestHandle::addr_callback, GNUNET_RESOLVER_RequestHandle::af, check_config(), GNUNET_RESOLVER_RequestHandle::cls, GNUNET_RESOLVER_RequestHandle::data_len, GNUNET_RESOLVER_RequestHandle::direction, GNUNET_break, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_malloc, GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_TIME_relative_to_absolute(), GNUNET_YES, handle_lookup_timeout(), hostname, GNUNET_RESOLVER_RequestHandle::id, last_request_id, LOG, loopback, loopback_resolution(), numeric_resolution(), process_requests(), req_head, req_tail, s_task, GNUNET_RESOLVER_RequestHandle::task, timeout, GNUNET_RESOLVER_RequestHandle::timeout, and GNUNET_RESOLVER_RequestHandle::was_queued.

Referenced by dns_result_parser(), dyndns_lookup(), GNUNET_CONNECTION_create_from_connect(), GNUNET_NAT_stun_make_request(), GNUNET_RESOLVER_hostname_resolve(), handle_gns_cname_result(), handle_gns_redirect_result(), http_common_dns_ip_lookup(), recursive_gns2dns_resolution(), run(), and start_connect().

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

◆ 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 
)

Resolve our hostname to an IP address.

Parameters
afAF_INET or AF_INET6; use AF_UNSPEC for "any"
callbackfunction to call with addresses
clsclosure for callback
timeouthow long to try resolving
Returns
handle that can be used to cancel the request, NULL on error

Resolve our hostname to an IP address.

Parameters
afAF_INET or AF_INET6; use AF_UNSPEC for "any"
timeouthow long to try resolving
callbackfunction to call with addresses
clsclosure for callback
Returns
handle that can be used to cancel the request, NULL on error

Definition at line 1235 of file resolver_api.c.

1239 {
1241 
1242  if (0 != gethostname (hostname, sizeof(hostname) - 1))
1243  {
1245  "gethostname");
1246  return NULL;
1247  }
1249  "Resolving our hostname `%s'\n",
1250  hostname);
1252  af,
1253  timeout,
1254  callback,
1255  cls);
1256 }
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_BULK
#define GNUNET_OS_get_hostname_max_length()
Get maximum string length returned by gethostname()
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
#define LOG_STRERROR(kind, syscall)
Definition: resolver_api.c:35

References GNUNET_RESOLVER_RequestHandle::af, GNUNET_RESOLVER_RequestHandle::cls, GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_OS_get_hostname_max_length, GNUNET_RESOLVER_ip_get(), hostname, LOG, LOG_STRERROR, and timeout.

Here is the call graph for this function:

◆ GNUNET_RESOLVER_local_fqdn_get()

char* GNUNET_RESOLVER_local_fqdn_get ( void  )

Get local fully qualified domain name.

Returns
local hostname, caller must free

Get local fully qualified domain name.

Returns
fqdn

Definition at line 1149 of file resolver_api.c.

1150 {
1152 
1153  if (0 != gethostname (hostname,
1154  sizeof(hostname) - 1))
1155  {
1157  "gethostname");
1158  return NULL;
1159  }
1161  "Resolving our FQDN `%s'\n",
1162  hostname);
1163 #if HAVE_GETADDRINFO
1164  {
1165  struct addrinfo *ai;
1166  int ret;
1167  char *rval;
1168 
1169  if (0 != (ret = getaddrinfo (hostname,
1170  NULL,
1171  NULL,
1172  &ai)))
1173  {
1175  _ ("Could not resolve our FQDN: %s\n"),
1176  gai_strerror (ret));
1177  return NULL;
1178  }
1179  if (NULL != ai->ai_canonname)
1180  rval = GNUNET_strdup (ai->ai_canonname);
1181  else
1182  rval = GNUNET_strdup (hostname);
1183  freeaddrinfo (ai);
1184  return rval;
1185  }
1186 #elif HAVE_GETHOSTBYNAME2
1187  {
1188  struct hostent *host;
1189 
1190  host = gethostbyname2 (hostname,
1191  AF_INET);
1192  if (NULL == host)
1193  host = gethostbyname2 (hostname,
1194  AF_INET6);
1195  if (NULL == host)
1196  {
1198  _ ("Could not resolve our FQDN: %s\n"),
1199  hstrerror (h_errno));
1200  return NULL;
1201  }
1202  return GNUNET_strdup (host->h_name);
1203  }
1204 #elif HAVE_GETHOSTBYNAME
1205  {
1206  struct hostent *host;
1207 
1208  host = gethostbyname (hostname);
1209  if (NULL == host)
1210  {
1212  _ ("Could not resolve our FQDN: %s\n"),
1213  hstrerror (h_errno));
1214  return NULL;
1215  }
1216  return GNUNET_strdup (host->h_name);
1217  }
1218 #else
1219  /* fallback: just hope name is already FQDN */
1220  return GNUNET_strdup (hostname);
1221 #endif
1222 }
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define _(String)
GNU gettext support macro.
Definition: platform.h:177

References _, ai, GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_OS_get_hostname_max_length, GNUNET_strdup, hostname, LOG, LOG_STRERROR, and ret.

Referenced by GNUNET_HOSTLIST_server_start().

Here is the caller graph for this function:

◆ 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 
)

Perform a reverse DNS lookup.

Parameters
sahost address
salenlength of sa
do_resolveuse GNUNET_NO to return numeric hostname
timeouthow long to try resolving
callbackfunction to call with hostnames
clsclosure for callback
Returns
handle that can be used to cancel the request, NULL on error

Perform a reverse DNS lookup.

Parameters
sahost address
salenlength of host address in sa
do_resolveuse GNUNET_NO to return numeric hostname
timeouthow long to try resolving
callbackfunction to call with hostnames last callback is NULL when finished
clsclosure for callback
Returns
handle that can be used to cancel the request

Definition at line 1072 of file resolver_api.c.

1078 {
1079  struct GNUNET_RESOLVER_RequestHandle *rh;
1080  size_t ip_len;
1081  const void *ip;
1082 
1083  if (GNUNET_OK != check_config ())
1084  {
1086  _ ("Resolver not configured correctly.\n"));
1087  return NULL;
1088  }
1089 
1090  switch (sa->sa_family)
1091  {
1092  case AF_INET:
1093  GNUNET_assert (salen == sizeof(struct sockaddr_in));
1094  ip_len = sizeof(struct in_addr);
1095  ip = &((const struct sockaddr_in*) sa)->sin_addr;
1096  break;
1097 
1098  case AF_INET6:
1099  GNUNET_assert (salen == sizeof(struct sockaddr_in6));
1100  ip_len = sizeof(struct in6_addr);
1101  ip = &((const struct sockaddr_in6*) sa)->sin6_addr;
1102  break;
1103 
1104  default:
1105  GNUNET_break (0);
1106  return NULL;
1107  }
1108  rh = GNUNET_malloc (sizeof(struct GNUNET_RESOLVER_RequestHandle) + salen);
1109  rh->name_callback = callback;
1110  rh->cls = cls;
1111  rh->af = sa->sa_family;
1112  rh->id = ++last_request_id;
1114  GNUNET_memcpy (&rh[1],
1115  ip,
1116  ip_len);
1117  rh->data_len = ip_len;
1118  rh->direction = GNUNET_YES;
1120  if (GNUNET_NO == do_resolve)
1121  {
1123  rh);
1124  return rh;
1125  }
1128  rh);
1130  req_tail,
1131  rh);
1132  rh->was_queued = GNUNET_YES;
1133  if (NULL != s_task)
1134  {
1136  s_task = NULL;
1137  }
1138  process_requests ();
1139  return rh;
1140 }
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...
GNUNET_RESOLVER_HostnameCallback name_callback
Callback if this is a reverse lookup request, otherwise NULL.
Definition: resolver_api.c:125
int received_response
GNUNET_YES if a response was received
Definition: resolver_api.c:174

References _, GNUNET_RESOLVER_RequestHandle::af, check_config(), GNUNET_RESOLVER_RequestHandle::cls, GNUNET_RESOLVER_RequestHandle::data_len, GNUNET_RESOLVER_RequestHandle::direction, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_ERROR, GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_TIME_relative_to_absolute(), GNUNET_YES, handle_lookup_timeout(), GNUNET_RESOLVER_RequestHandle::id, last_request_id, LOG, GNUNET_RESOLVER_RequestHandle::name_callback, numeric_reverse(), process_requests(), GNUNET_RESOLVER_RequestHandle::received_response, req_head, req_tail, s_task, GNUNET_RESOLVER_RequestHandle::task, timeout, GNUNET_RESOLVER_RequestHandle::timeout, and GNUNET_RESOLVER_RequestHandle::was_queued.

Referenced by http_common_dns_reverse_lookup(), run(), tcp_plugin_address_pretty_printer(), and udp_plugin_address_pretty_printer().

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

◆ GNUNET_RESOLVER_request_cancel()

void GNUNET_RESOLVER_request_cancel ( struct GNUNET_RESOLVER_RequestHandle rh)

Cancel a request that is still pending with the resolver.

Note that a client MUST NOT cancel a request that has been completed (i.e, the callback has been called to signal timeout or the final result).

Parameters
rhhandle of request to cancel

Definition at line 1268 of file resolver_api.c.

1269 {
1270  if (GNUNET_NO == rh->direction)
1272  "Asked to cancel request to resolve hostname `%s'.\n",
1273  (const char *) &rh[1]);
1274  if (NULL != rh->task)
1275  {
1277  rh->task = NULL;
1278  }
1279  if (GNUNET_NO == rh->was_transmitted)
1280  {
1281  if (GNUNET_YES == rh->was_queued)
1283  req_tail,
1284  rh);
1285  GNUNET_free (rh);
1286  check_disconnect ();
1287  return;
1288  }
1290  rh->was_transmitted = GNUNET_SYSERR; /* mark as cancelled */
1291  check_disconnect ();
1292 }
static void check_disconnect()
Consider disconnecting if we have no further requests pending.
Definition: resolver_api.c:319

References check_disconnect(), GNUNET_RESOLVER_RequestHandle::direction, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_SYSERR, GNUNET_YES, LOG, req_head, req_tail, GNUNET_RESOLVER_RequestHandle::task, GNUNET_RESOLVER_RequestHandle::was_queued, and GNUNET_RESOLVER_RequestHandle::was_transmitted.

Referenced by client_disconnect_cb(), connection_client_destroy_impl(), dns_result_parser(), do_shutdown(), GNS_resolver_lookup_cancel(), GNUNET_CONNECTION_destroy(), GNUNET_NAT_stun_make_request_cancel(), handle_gns_redirect_result(), handle_lookup_timeout(), handle_response(), init_socket(), libgnunet_plugin_transport_tcp_done(), and nat_register().

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