#include "platform.h"
#include <gnunet_util_lib.h>
#include <gnunet_dnsstub_lib.h>
#include <gnunet_dnsparser_lib.h>

Include dependency graph for gnunet-zonewalk.c:

Data Structures
struct	Request
	Request we should make. More...

Macros
#define	THRESH 20
	Maximum number of queries pending at the same time. More...

#define	TIME_THRESH 10
	TIME_THRESH is in usecs. More...

#define	MAX_RETRIES 5
	How often do we retry a query before giving up for good? More...

Functions
static void	process_record (struct Request req, struct GNUNET_DNSPARSER_Record rec)
	We received rec for req. More...

static void	process_result (void cls, const struct GNUNET_TUN_DnsHeader dns, size_t dns_len)
	Function called with the result of a DNS resolution. More...

static int	submit_req (struct Request *req)
	Submit a request to DNS unless we need to slow down because we are at the rate limit. More...

static void	process_queue (void *cls)
	Process as many requests as possible from the queue. More...

static void	do_shutdown (void *cls)
	Clean up and terminate the process. More...

static void	run (void *cls)
	Process requests from the queue, then if the queue is not empty, try again. More...

static void	queue (const char *hostname)
	Add hostname to the list of requests to be made. More...

int	main (int argc, char **argv)
	Call with IP address of resolver to query. More...

Variables
static struct GNUNET_DNSSTUB_Context *	ctx
	Context for DNS resolution. More...

static unsigned int	pending
	The number of queries that are outstanding. More...

static unsigned int	lookups
	Number of lookups we performed overall. More...

static unsigned int	failures
	Number of lookups that failed. More...

static unsigned int	records
	Number of records we found. More...

static struct Request *	req_head
	Head of DLL of all requests to perform. More...

static struct Request *	req_tail
	Tail of DLL of all requests to perform. More...

static struct GNUNET_SCHEDULER_Task *	t
	Main task. More...

Macro Definition Documentation

◆ THRESH

#define THRESH 20

Maximum number of queries pending at the same time.

Definition at line 126 of file gnunet-zonewalk.c.

Referenced by submit_req().

◆ TIME_THRESH

#define TIME_THRESH 10

TIME_THRESH is in usecs.

How quickly do we submit fresh queries. Used as an additional throttle.

Definition at line 132 of file gnunet-zonewalk.c.

Referenced by submit_req().

◆ MAX_RETRIES

#define MAX_RETRIES 5

How often do we retry a query before giving up for good?

Definition at line 137 of file gnunet-zonewalk.c.

Referenced by process_result().

Function Documentation

◆ process_record()

static void process_record	(	struct Request *	req,
		struct GNUNET_DNSPARSER_Record *	rec
	)

static

We received rec for req.

Remember the answer.

Parameters

req	request
rec	response

Definition at line 147 of file gnunet-zonewalk.c.

Referenced by process_result().

 {
   char buf[INET6_ADDRSTRLEN];
 
   records++;
   switch (rec->type)
   {
   case GNUNET_DNSPARSER_TYPE_A:
     fprintf (stdout,
              "%s A %s\n",
              req->hostname,
              inet_ntop (AF_INET,
                         rec->data.raw.data,
                         buf,
                         sizeof(buf)));
     break;
 
   case GNUNET_DNSPARSER_TYPE_AAAA:
     fprintf (stdout,
              "%s AAAA %s\n",
              req->hostname,
              inet_ntop (AF_INET6,
                         rec->data.raw.data,
                         buf,
                         sizeof(buf)));
     break;
 
   case GNUNET_DNSPARSER_TYPE_NS:
     fprintf (stdout,
              "%s NS %s\n",
              req->hostname,
              rec->data.hostname);
     break;
 
   case GNUNET_DNSPARSER_TYPE_CNAME:
     fprintf (stdout,
              "%s CNAME %s\n",
              req->hostname,
              rec->data.hostname);
     break;
 
   case GNUNET_DNSPARSER_TYPE_MX:
     fprintf (stdout,
              "%s MX %u %s\n",
              req->hostname,
              (unsigned int) rec->data.mx->preference,
              rec->data.mx->mxhost);
     break;
 
   case GNUNET_DNSPARSER_TYPE_SOA:
     fprintf (stdout,
              "%s SOA %s %s %u %u %u %u %u\n",
              req->hostname,
              rec->data.soa->mname,
              rec->data.soa->rname,
              (unsigned int) rec->data.soa->serial,
              (unsigned int) rec->data.soa->refresh,
              (unsigned int) rec->data.soa->retry,
              (unsigned int) rec->data.soa->expire,
              (unsigned int) rec->data.soa->minimum_ttl);
     break;
 
   case GNUNET_DNSPARSER_TYPE_SRV:
     fprintf (stdout,
              "%s SRV %s %u %u %u\n",
              req->hostname,
              rec->data.srv->target,
              rec->data.srv->priority,
              rec->data.srv->weight,
              rec->data.srv->port);
     break;
 
   case GNUNET_DNSPARSER_TYPE_PTR:
     fprintf (stdout,
              "%s PTR %s\n",
              req->hostname,
              rec->data.hostname);
     break;
 
   case GNUNET_DNSPARSER_TYPE_TXT:
     fprintf (stdout,
              "%s TXT %.*s\n",
              req->hostname,
              (int) rec->data.raw.data_len,
              (char *) rec->data.raw.data);
     break;
 
   case GNUNET_DNSPARSER_TYPE_DNAME:
     fprintf (stdout,
              "%s DNAME %s\n",
              req->hostname,
              rec->data.hostname);
     break;
 
   /* obscure records */
   case GNUNET_DNSPARSER_TYPE_AFSDB:
   case GNUNET_DNSPARSER_TYPE_NAPTR:
   case GNUNET_DNSPARSER_TYPE_APL:
   case GNUNET_DNSPARSER_TYPE_DHCID:
   case GNUNET_DNSPARSER_TYPE_HIP:
   case GNUNET_DNSPARSER_TYPE_LOC:
   case GNUNET_DNSPARSER_TYPE_RP:
   case GNUNET_DNSPARSER_TYPE_TKEY:
   case GNUNET_DNSPARSER_TYPE_TSIG:
   case GNUNET_DNSPARSER_TYPE_URI:
   case GNUNET_DNSPARSER_TYPE_TA:
 
   /* DNSSEC */
   case GNUNET_DNSPARSER_TYPE_DS:
   case GNUNET_DNSPARSER_TYPE_RRSIG:
   case GNUNET_DNSPARSER_TYPE_NSEC:
   case GNUNET_DNSPARSER_TYPE_DNSKEY:
   case GNUNET_DNSPARSER_TYPE_NSEC3:
   case GNUNET_DNSPARSER_TYPE_NSEC3PARAM:
   case GNUNET_DNSPARSER_TYPE_CDS:
   case GNUNET_DNSPARSER_TYPE_CDNSKEY:
 
   /* DNSSEC payload */
   case GNUNET_DNSPARSER_TYPE_CERT:
   case GNUNET_DNSPARSER_TYPE_SSHFP:
   case GNUNET_DNSPARSER_TYPE_IPSECKEY:
   case GNUNET_DNSPARSER_TYPE_TLSA:
   case GNUNET_DNSPARSER_TYPE_OPENPGPKEY:
 
   /* obsolete records */
   case GNUNET_DNSPARSER_TYPE_SIG:
   case GNUNET_DNSPARSER_TYPE_KEY:
   case GNUNET_DNSPARSER_TYPE_KX:
     {
       char *base32;
 
       base32 = GNUNET_STRINGS_data_to_string_alloc (rec->data.raw.data,
                                                     rec->data.raw.data_len);
       fprintf (stdout,
                "%s (%u) %s\n",
                req->hostname,
                rec->type,
                base32);
       GNUNET_free (base32);
     }
     break;
 
   default:
     fprintf (stderr,
              "Unsupported type %u\n",
              (unsigned int) rec->type);
     break;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_result()

static void process_result	(	void *	cls,
		const struct GNUNET_TUN_DnsHeader *	dns,
		size_t	dns_len
	)

static

Function called with the result of a DNS resolution.

Parameters

cls	closure with the `struct Request`
dns	dns response, never NULL
dns_len	number of bytes in dns

Definition at line 307 of file gnunet-zonewalk.c.

References GNUNET_DNSPARSER_Packet::additional_records, GNUNET_DNSPARSER_Packet::answers, GNUNET_DNSPARSER_Packet::authority_records, failures, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_DNSPARSER_free_packet(), GNUNET_DNSPARSER_parse(), GNUNET_DNSSTUB_resolve_cancel(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, Request::hostname, Request::id, GNUNET_TUN_DnsHeader::id, Request::issue_num, MAX_RETRIES, GNUNET_DNSPARSER_Packet::num_additional_records, GNUNET_DNSPARSER_Packet::num_answers, GNUNET_DNSPARSER_Packet::num_authority_records, p, pending, process_record(), Request::raw, and Request::rs.

Referenced by submit_req().

 {
   struct Request *req = cls;
   struct GNUNET_DNSPARSER_Packet *p;
 
   if (NULL == dns)
   {
     /* stub gave up */
     pending--;
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Stub gave up on DNS reply for `%s'\n",
                 req->hostname);
     GNUNET_CONTAINER_DLL_remove (req_head,
                                  req_tail,
                                  req);
     if (req->issue_num > MAX_RETRIES)
     {
       failures++;
       GNUNET_free (req->hostname);
       GNUNET_free (req->raw);
       GNUNET_free (req);
       return;
     }
     GNUNET_CONTAINER_DLL_insert_tail (req_head,
                                       req_tail,
                                       req);
     req->rs = NULL;
     return;
   }
   if (req->id != dns->id)
     return;
   pending--;
   GNUNET_DNSSTUB_resolve_cancel (req->rs);
   req->rs = NULL;
   GNUNET_CONTAINER_DLL_remove (req_head,
                                req_tail,
                                req);
   p = GNUNET_DNSPARSER_parse ((const char *) dns,
                               dns_len);
   if (NULL == p)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Failed to parse DNS reply for `%s'\n",
                 req->hostname);
     if (req->issue_num > MAX_RETRIES)
     {
       failures++;
       GNUNET_free (req->hostname);
       GNUNET_free (req->raw);
       GNUNET_free (req);
       return;
     }
     GNUNET_CONTAINER_DLL_insert_tail (req_head,
                                       req_tail,
                                       req);
     return;
   }
   for (unsigned int i = 0; i < p->num_answers; i++)
   {
     struct GNUNET_DNSPARSER_Record *rs = &p->answers[i];
 
     process_record (req,
                     rs);
   }
   for (unsigned int i = 0; i < p->num_authority_records; i++)
   {
     struct GNUNET_DNSPARSER_Record *rs = &p->authority_records[i];
 
     process_record (req,
                     rs);
   }
   for (unsigned int i = 0; i < p->num_additional_records; i++)
   {
     struct GNUNET_DNSPARSER_Record *rs = &p->additional_records[i];
 
     process_record (req,
                     rs);
   }
   GNUNET_DNSPARSER_free_packet (p);
   GNUNET_free (req->hostname);
   GNUNET_free (req->raw);
   GNUNET_free (req);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ submit_req()

static int submit_req ( struct Request * req )

static

Submit a request to DNS unless we need to slow down because we are at the rate limit.

Parameters

req	request to submit

Returns: GNUNET_OK if request was submitted GNUNET_NO if request was already submitted GNUNET_SYSERR if we are at the rate limit

Definition at line 404 of file gnunet-zonewalk.c.

References GNUNET_assert, GNUNET_DNSSTUB_resolve(), GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, Request::issue_num, lookups, pending, process_result(), Request::raw, Request::raw_len, Request::rs, THRESH, Request::time, and TIME_THRESH.

Referenced by process_queue().

 {
   static struct timeval last_request;
   struct timeval now;
 
   if (NULL != req->rs)
     return GNUNET_NO; /* already submitted */
   gettimeofday (&now,
                 NULL);
   if ((((now.tv_sec - last_request.tv_sec) == 0) &&
        ((now.tv_usec - last_request.tv_usec) < TIME_THRESH)) ||
       (pending >= THRESH))
     return GNUNET_SYSERR;
   GNUNET_assert (NULL == req->rs);
   req->rs = GNUNET_DNSSTUB_resolve (ctx,
                                     req->raw,
                                     req->raw_len,
                                     &process_result,
                                     req);
   GNUNET_assert (NULL != req->rs);
   req->issue_num++;
   last_request = now;
   lookups++;
   pending++;
   req->time = time (NULL);
   return GNUNET_OK;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_queue()

static void process_queue ( void * cls )

static

Process as many requests as possible from the queue.

Parameters

cls NULL

Definition at line 439 of file gnunet-zonewalk.c.

References GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_shutdown(), GNUNET_SYSERR, GNUNET_TIME_UNIT_MILLISECONDS, Request::next, and submit_req().

Referenced by run().

 {
   (void) cls;
   t = NULL;
   for (struct Request *req = req_head;
        NULL != req;
        req = req->next)
   {
     if (GNUNET_SYSERR == submit_req (req))
       break;
   }
   if (NULL != req_head)
     t = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
                                       &process_queue,
                                       NULL);
   else
     GNUNET_SCHEDULER_shutdown ();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ do_shutdown()

static void do_shutdown ( void * cls )

static

Clean up and terminate the process.

Parameters

cls NULL

Definition at line 465 of file gnunet-zonewalk.c.

References GNUNET_DNSSTUB_stop(), and GNUNET_SCHEDULER_cancel().

Referenced by run().

 {
   (void) cls;
   if (NULL != t)
   {
     GNUNET_SCHEDULER_cancel (t);
     t = NULL;
   }
   GNUNET_DNSSTUB_stop (ctx);
   ctx = NULL;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ run()

static void run ( void * cls )

static

Process requests from the queue, then if the queue is not empty, try again.

Parameters

cls NULL

Definition at line 485 of file gnunet-zonewalk.c.

References do_shutdown(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_shutdown(), and process_queue().

Referenced by main().

 {
   (void) cls;
 
   GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
                                  NULL);
   t = GNUNET_SCHEDULER_add_now (&process_queue,
                                 NULL);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ queue()

static void queue ( const char * hostname )

static

Add hostname to the list of requests to be made.

Parameters

hostname name to resolve

Definition at line 502 of file gnunet-zonewalk.c.

References GNUNET_DNSPARSER_Query::dns_traffic_class, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CRYPTO_QUALITY_NONCE, GNUNET_CRYPTO_random_u32(), GNUNET_DNSPARSER_check_name(), GNUNET_DNSPARSER_pack(), GNUNET_DNSPARSER_TYPE_NS, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_TUN_DNS_CLASS_INTERNET, Request::hostname, Request::id, GNUNET_DNSPARSER_Packet::id, GNUNET_DNSPARSER_Query::name, GNUNET_DNSPARSER_Packet::num_queries, q, GNUNET_DNSPARSER_Packet::queries, Request::raw, Request::raw_len, ret, and GNUNET_DNSPARSER_Query::type.

Referenced by check_vl_transmission(), core_read_finished_cb(), free_pending_acknowledgement(), get_audiobin(), get_queue_delete_it(), handle_add_queue_message(), handle_del_queue_message(), handle_send_message_ack(), lookup_queue_it(), main(), mq_cancel(), mq_destroy(), mq_error(), mq_init(), mq_send(), prepare_pending_acknowledgement(), proto_read_kx(), queue_read(), queue_read_kx(), queue_send_msg(), queue_timeout(), queue_write(), select_read_cb(), select_write_cb(), setup_queue(), and transmit_on_queue().

 {
   struct GNUNET_DNSPARSER_Packet p;
   struct GNUNET_DNSPARSER_Query q;
   struct Request *req;
   char *raw;
   size_t raw_size;
   int ret;
 
   if (GNUNET_OK !=
       GNUNET_DNSPARSER_check_name (hostname))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Refusing invalid hostname `%s'\n",
                 hostname);
     return;
   }
   q.name = (char *) hostname;
   q.type = GNUNET_DNSPARSER_TYPE_NS;
   q.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET;
 
   memset (&p,
           0,
           sizeof(p));
   p.num_queries = 1;
   p.queries = &q;
   p.id = (uint16_t) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
                                               UINT16_MAX);
   ret = GNUNET_DNSPARSER_pack (&p,
                                UINT16_MAX,
                                &raw,
                                &raw_size);
   if (GNUNET_OK != ret)
   {
     if (GNUNET_NO == ret)
       GNUNET_free (raw);
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Failed to pack query for hostname `%s'\n",
                 hostname);
     return;
   }
 
   req = GNUNET_new (struct Request);
   req->hostname = strdup (hostname);
   req->raw = raw;
   req->raw_len = raw_size;
   req->id = p.id;
   GNUNET_CONTAINER_DLL_insert_tail (req_head,
                                     req_tail,
                                     req);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ main()

int main	(	int	argc,
		char **	argv
	)

Call with IP address of resolver to query.

Parameters

argc	should be 2
argv[1]	should contain IP address

Returns: 0 on success

Definition at line 563 of file gnunet-zonewalk.c.

References failures, GNUNET_DNSSTUB_add_dns_ip(), GNUNET_DNSSTUB_start(), GNUNET_OK, GNUNET_SCHEDULER_run(), Request::hn, lookups, pending, queue(), records, and run().

 {
   char hn[256];
 
   if (2 != argc)
   {
     fprintf (stderr,
              "Missing required configuration argument\n");
     return -1;
   }
   ctx = GNUNET_DNSSTUB_start (256);
   if (NULL == ctx)
   {
     fprintf (stderr,
              "Failed to initialize GNUnet DNS STUB\n");
     return 1;
   }
   if (GNUNET_OK !=
       GNUNET_DNSSTUB_add_dns_ip (ctx,
                                  argv[1]))
   {
     fprintf (stderr,
              "Failed to use `%s' for DNS resolver\n",
              argv[1]);
     return 1;
   }
 
   while (NULL !=
          fgets (hn,
                 sizeof(hn),
                 stdin))
   {
     if (strlen (hn) > 0)
       hn[strlen (hn) - 1] = '\0';  /* eat newline */
     queue (hn);
   }
   GNUNET_SCHEDULER_run (&run,
                         NULL);
   fprintf (stderr,
            "Did %u lookups, found %u records, %u lookups failed, %u pending on shutdown\n",
            lookups,
            records,
            failures,
            pending);
   return 0;
 }

Here is the call graph for this function:

Variable Documentation

◆ ctx

struct GNUNET_DNSSTUB_Context* ctx

static

Context for DNS resolution.

Definition at line 86 of file gnunet-zonewalk.c.

Referenced by add_address_to_hello(), add_address_to_uri(), add_plugin(), cadet_connect_adapter(), cadet_connect_cb(), cadet_test_run(), cancel_get(), check_connection_quality(), check_edge(), core_env_sent_cb(), create_peer_ctx(), curl_download_cb(), datacache_get_iterator(), debugctx(), delayed_put(), derive_aes_key(), derive_auth_key(), derive_iv(), derive_pong_iv(), dfa_add_multi_strides_helper(), dht_connect_cb(), dht_connected(), dht_get_string_accept_handler(), dht_get_string_handler(), dht_test_run(), find_best_address_it(), get_iter(), get_peer_ctx(), GNUNET_BLOCK_context_create(), GNUNET_CADET_TEST_ruN(), GNUNET_CRYPTO_ecdsa_private_key_derive(), GNUNET_CRYPTO_ecdsa_public_key_derive(), GNUNET_CRYPTO_hkdf_v(), GNUNET_DHT_TEST_run(), GNUNET_SET_element_hash(), GNUNET_SIGNAL_raise(), handle_raw_message(), iterate_channels_cb(), new_regex_ctx(), op_get_element_iterator(), regex_edge_iterator(), REGEX_INTERNAL_search(), regex_result_iterator(), REGEX_TEST_automaton_save_graph_step(), REGEX_TEST_combine(), remove_by_unique_id(), run(), service_started(), start_profiling(), t_ax_decrypt_and_validate(), t_ax_encrypt(), t_ax_hmac_hash(), t_hmac(), t_hmac_derive_key(), tcp_send(), tmain(), and try_send_tcp().

◆ pending

unsigned int pending

static

The number of queries that are outstanding.

Definition at line 91 of file gnunet-zonewalk.c.

Referenced by end(), GNUNET_NETWORK_socket_recvfrom_amount(), main(), process_result(), and submit_req().

◆ lookups

unsigned int lookups

static

Number of lookups we performed overall.

Definition at line 96 of file gnunet-zonewalk.c.

Referenced by main(), and submit_req().

◆ failures

unsigned int failures

static

Number of lookups that failed.

Definition at line 101 of file gnunet-zonewalk.c.

Referenced by main(), and process_result().

◆ records

unsigned int records

static

Number of records we found.

Definition at line 106 of file gnunet-zonewalk.c.

Referenced by GNUNET_JSON_from_gnsrecord(), main(), and process_record().

◆ req_head

struct Request* req_head

static

Head of DLL of all requests to perform.

Definition at line 111 of file gnunet-zonewalk.c.

◆ req_tail

struct Request* req_tail

static

Tail of DLL of all requests to perform.

Definition at line 116 of file gnunet-zonewalk.c.

◆ t

struct GNUNET_SCHEDULER_Task* t

static

Main task.

Definition at line 121 of file gnunet-zonewalk.c.

Referenced by add(), add_address_to_uri(), add_without_sets(), automaton_create_proofs(), automaton_destroy_state(), automaton_merge_states(), automaton_state_traverse(), compute_scalar_product(), consider_path_cb(), construct_task_graph(), destroy_tunnels_now(), dfa_add_multi_strides_helper(), dfa_compress_paths(), dfa_compress_paths_helper(), dfa_move(), dfa_remove_dead_states(), extract_abs_time(), find_peer_context(), GCCH_channel_incoming_new(), GCT_add_inbound_connection(), GCT_create_tunnel(), GCT_handle_kx(), GCT_handle_kx_auth(), GCT_send(), get_all_tunnels_iterator(), get_next_free_ctn(), GNUNET_CRYPTO_hkdf_v(), GNUNET_DISK_file_seek(), GNUNET_log_setup(), GNUNET_SCHEDULER_add_at_with_priority(), GNUNET_SCHEDULER_add_now_with_lifeness(), GNUNET_SCHEDULER_add_select(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_add_with_reason_and_priority(), GNUNET_SERVICE_client_drop(), GNUNET_STRINGS_fancy_time_to_absolute(), GNUNET_TIME_get_current_year(), GNUNET_TIME_time_to_year(), GNUNET_TRANSPORT_TESTING_done(), GNUNET_TRANSPORT_TESTING_get_test_plugin_name(), GNUNET_TWEETNACL_sign_detached_verify(), handle_p2p_estimate(), helper_read(), helper_write(), iterate_initial_edge(), M(), mark_connection_unready(), pack25519(), parse_definitions(), parse_pattern(), progress_cb(), put_task(), REGEX_INTERNAL_dfa_add_multi_strides(), restore_fair(), retry_kx(), rsa_gcd_validate(), scc_tarjan_strongconnect(), sel25519(), shutdown_if_no_lifeness(), state_add_transition(), state_get_edges(), and unpackneg().

Data Structures

Macros

Functions

Variables

Macro Definition Documentation

◆ THRESH

◆ TIME_THRESH

◆ MAX_RETRIES

Function Documentation

◆ process_record()

◆ process_result()

◆ submit_req()

◆ process_queue()

◆ do_shutdown()

◆ run()

◆ queue()

◆ main()

Variable Documentation

◆ ctx

◆ pending

◆ lookups

◆ failures

◆ records

◆ req_head

◆ req_tail

◆ t