gnunet-gns.c File Reference

command line tool to access distributed GNS More...

#include "platform.h"
#include <gnunet_util_lib.h>
#include <gnunet_gnsrecord_lib.h>
#include <gnunet_namestore_service.h>
#include <gnunet_gns_service.h>

Include dependency graph for gnunet-gns.c:

Go to the source code of this file.

Functions
static void	spin (void *cls)
static void	do_shutdown (void *cls)
	Task run on shutdown.
static void	do_timeout (void *cls)
	Task to run on timeout.
static void	process_lookup_result (void *cls, int was_gns, uint32_t rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	Function called with the result of a GNS lookup.
static void	run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
	Main function that will be run.
int	main (int argc, char *const *argv)
	The main function for gnunet-gns.

Variables
static const struct GNUNET_CONFIGURATION_Handle *	cfg
	Configuration we are using.
static struct GNUNET_GNS_Handle *	gns
	Handle to GNS service.
static char *	lookup_name
	GNS name to lookup.
char *	idna_name
	DNS IDNA name to lookup.
static int	dns_compat
	DNS compatibility (name is given as DNS name, possible IDNA).
static char *	lookup_type
	record type to look up (-t option)
static int	raw
	raw output
static uint32_t	rtype
	Desired record type.
static struct GNUNET_TIME_Relative	timeout
	Timeout for lookup.
static struct GNUNET_SCHEDULER_Task *	to_task
	Timeout task.
static struct GNUNET_GNS_LookupWithTldRequest *	lr
	Handle to lookup request.
static int	global_ret
	Global return value.
static const char	spinner [] = {'|', '/', '-', '\\'}
	Spinner.
static struct GNUNET_SCHEDULER_Task *	t_spinner
	Spinner task.
struct GNUNET_TIME_Absolute	res_start
	Resolution start.

Detailed Description

command line tool to access distributed GNS

Author

Christian Grothoff

Definition in file gnunet-gns.c.

Function Documentation

spin()

static void spin ( void *  cls )

static

Definition at line 125 of file gnunet-gns.c.

{
  static int i = 0;
  printf ("%c\rResolving... ", spinner[i++ % sizeof spinner]);
  fflush (stdout);
  t_spinner = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (
                                              GNUNET_TIME_UNIT_MILLISECONDS, 100
                                              ),
                                            &spin,
                                            NULL);
}

References GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_relative_multiply(), GNUNET_TIME_UNIT_MILLISECONDS, spin(), spinner, and t_spinner.

Referenced by run(), and spin().

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

Task run on shutdown.

Cleans up everything.

Parameters

cls

unused

Definition at line 144 of file gnunet-gns.c.

{
  (void) cls;
  if (NULL != t_spinner)
  {
    printf ("\nResolution cancelled after %s\n",
            GNUNET_STRINGS_relative_time_to_string (
              GNUNET_TIME_absolute_get_duration (res_start),
              GNUNET_YES));
    GNUNET_SCHEDULER_cancel (t_spinner);
    t_spinner = NULL;
  }
  if (NULL != to_task)
  {
    GNUNET_SCHEDULER_cancel (to_task);
    to_task = NULL;
  }
  if (NULL != lr)
  {
    GNUNET_GNS_lookup_with_tld_cancel (lr);
    lr = NULL;
  }
  if (NULL != gns)
  {
    GNUNET_GNS_disconnect (gns);
    gns = NULL;
  }
  if (NULL != idna_name)
  {
    GNUNET_free (idna_name);
    idna_name = NULL;
  }
}

References gns, GNUNET_free, GNUNET_GNS_disconnect(), GNUNET_GNS_lookup_with_tld_cancel(), GNUNET_SCHEDULER_cancel(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_duration(), GNUNET_YES, idna_name, lr, res_start, t_spinner, and to_task.

Here is the call graph for this function:

do_timeout()

static void do_timeout ( void *  cls )

static

Task to run on timeout.

Parameters

cls

unused

Definition at line 185 of file gnunet-gns.c.

{
  to_task = NULL;
  global_ret = 3; // Timeout
  GNUNET_SCHEDULER_shutdown ();
}

References global_ret, GNUNET_SCHEDULER_shutdown(), and to_task.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

process_lookup_result()

static void process_lookup_result ( void *  cls, int  was_gns, uint32_t  rd_count, const struct GNUNET_GNSRECORD_Data *  rd  )

static

Function called with the result of a GNS lookup.

Parameters

cls	the 'const char *' name that was resolved
was_gns	GNUNET_NO if TLD did not indicate use of GNS
rd_count	number of records returned
rd	array of rd_count records with the results

Definition at line 202 of file gnunet-gns.c.

{
  struct GNUNET_TIME_Relative block_exp;
  const char *typename;
  char *string_val;
 
  lr = NULL;
  GNUNET_SCHEDULER_cancel (t_spinner);
  t_spinner = NULL;
  if (GNUNET_NO == was_gns)
  {
    global_ret = 4; /* not for GNS */
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  block_exp = GNUNET_TIME_absolute_get_remaining (
    GNUNET_GNSRECORD_record_get_expiration_time (
      rd_count,
      rd,
      GNUNET_TIME_UNIT_ZERO_ABS));
  if (! raw)
  {
    printf ("\r<<< %u record(s) found:\n\n", rd_count);
  }
  for (uint32_t i = 0; i < rd_count; i++)
  {
    typename = GNUNET_GNSRECORD_number_to_typename (rd[i].
                                                    record_type);
    string_val = GNUNET_GNSRECORD_value_to_string (rd[i].record_type
                                                   ,
                                                   rd[i].data,
                                                   rd[i].data_size);
    if (NULL == string_val)
    {
      fprintf (stderr,
               "Record %u of type %d malformed, skipping\n",
               (unsigned int) i,
               (int) rd[i].record_type);
      continue;
    }
    if (raw)
      printf ("%s\n", string_val);
    else
      printf ("%s: `%s' %s\n",
              typename,
              string_val,
              (0 != (rd[i].flags
                     &
                     GNUNET_GNSRECORD_RF_SUPPLEMENTAL)
              ) ?
              "(supplemental)" : "");
    GNUNET_free (string_val);
  }
  if (! raw)
  {
    printf ("\nResolution finished after %s\n",
            GNUNET_STRINGS_relative_time_to_string (
              GNUNET_TIME_absolute_get_duration (res_start),
              GNUNET_YES));
    if (0 != rd_count)
      printf ("Record set expires in %s.\n",
              GNUNET_STRINGS_relative_time_to_string (
                block_exp, GNUNET_YES));
  }
  GNUNET_SCHEDULER_shutdown ();
}

References data, data_size, global_ret, GNUNET_free, GNUNET_GNSRECORD_number_to_typename(), GNUNET_GNSRECORD_record_get_expiration_time(), GNUNET_GNSRECORD_RF_SUPPLEMENTAL, GNUNET_GNSRECORD_value_to_string(), GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_shutdown(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_YES, lr, raw, rd, rd_count, res_start, and t_spinner.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

run()

static void run ( void *  cls, char *const *  args, const char *  cfgfile, const struct GNUNET_CONFIGURATION_Handle *  c  )

static

Main function that will be run.

Parameters

cls	closure
args	remaining command-line arguments
cfgfile	name of the configuration file used (for saving, can be NULL!)
c	configuration

If DNS compatibility is requested, we first verify that the lookup_name is in a DNS format. If yes, we convert it to UTF-8.

Definition at line 282 of file gnunet-gns.c.

{
  const char *effective_lookup_type;
  (void) cls;
  (void) args;
  (void) cfgfile;
 
  cfg = c;
  to_task = NULL;
  {
    char *colon;
 
    if (NULL != (colon = strchr (lookup_name, ':')))
      *colon = '\0';
  }
 
  if (GNUNET_YES == dns_compat)
  {
    Idna_rc rc;
 
    if (GNUNET_OK != GNUNET_DNSPARSER_check_name (lookup_name))
    {
      fprintf (stderr,
               _ ("`%s' is not a valid DNS domain name\n"),
               lookup_name);
      global_ret = 3;
      return;
    }
    if (IDNA_SUCCESS !=
        (rc = idna_to_unicode_8z8z (lookup_name, &idna_name,
                                    IDNA_ALLOW_UNASSIGNED)))
    {
      fprintf (stderr,
               _ (
                 "Failed to convert DNS IDNA name `%s' to UTF-8: %s\n"),
               lookup_name,
               idna_strerror (rc));
      global_ret = 4;
      return;
    }
    lookup_name = idna_name;
  }
 
  if (GNUNET_YES !=
      GNUNET_CLIENT_test (cfg,
                          "arm"))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ (
                  "Cannot resolve using GNS: GNUnet peer not running\n"));
    global_ret = 5;
    return;
  }
  to_task = GNUNET_SCHEDULER_add_delayed (timeout,
                                          &do_timeout,
                                          NULL);
  gns = GNUNET_GNS_connect (cfg);
  if (NULL == gns)
  {
    fprintf (stderr,
             _ ("Failed to connect to GNS\n"));
    global_ret = 2;
    return;
  }
  GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
                                 NULL);
  if (NULL != lookup_type)
  {
    effective_lookup_type = lookup_type;
    rtype = GNUNET_GNSRECORD_typename_to_number (lookup_type);
  }
  else
  {
    effective_lookup_type = "A";
    rtype = GNUNET_DNSPARSER_TYPE_A;
  }
  if (UINT32_MAX == rtype)
  {
    fprintf (stderr,
             _ ("Invalid typename specified, assuming `ANY'\n"));
    rtype = GNUNET_GNSRECORD_TYPE_ANY;
  }
  if (! raw)
  {
    printf (">>> Looking for `%s' records under `%s'\n",
            effective_lookup_type, lookup_name);
  }
  t_spinner = GNUNET_SCHEDULER_add_now (&spin, NULL);
  res_start = GNUNET_TIME_absolute_get ();
  lr = GNUNET_GNS_lookup_with_tld (gns,
                                   lookup_name,
                                   rtype,
                                   GNUNET_GNS_LO_DEFAULT,
                                   &process_lookup_result,
                                   lookup_name);
  if (NULL == lr)
  {
    global_ret = 2;
    GNUNET_SCHEDULER_cancel (t_spinner);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
}

References _, cfg, dns_compat, do_shutdown, do_timeout(), global_ret, gns, GNUNET_CLIENT_test(), GNUNET_DNSPARSER_check_name(), GNUNET_DNSPARSER_TYPE_A, GNUNET_ERROR_TYPE_WARNING, GNUNET_GNS_connect(), GNUNET_GNS_LO_DEFAULT, GNUNET_GNS_lookup_with_tld(), GNUNET_GNSRECORD_TYPE_ANY, GNUNET_GNSRECORD_typename_to_number(), GNUNET_log, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_shutdown(), GNUNET_TIME_absolute_get(), GNUNET_YES, idna_name, lookup_name, lookup_type, lr, process_lookup_result(), raw, res_start, rtype, spin(), t_spinner, timeout, and to_task.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char *const *	argv
	)

The main function for gnunet-gns.

Parameters

argc	number of arguments from the command line
argv	command line arguments

Returns

0 ok, 1 on error

Definition at line 402 of file gnunet-gns.c.

{
  struct GNUNET_GETOPT_CommandLineOption options[] =
  { GNUNET_GETOPT_option_mandatory (
      GNUNET_GETOPT_option_string ('u',
                                   "lookup",
                                   "NAME",
                                   gettext_noop (
                                     "Lookup a record for the given name"),
                                   &lookup_name)),
    GNUNET_GETOPT_option_string ('t',
                                 "type",
                                 "TYPE",
                                 gettext_noop (
                                   "Specify the type of the record to lookup"),
                                 &lookup_type),
    GNUNET_GETOPT_option_relative_time ('T',
                                        "timeout",
                                        "TIMEOUT",
                                        gettext_noop (
                                          "Specify a timeout for the lookup"),
                                        &timeout),
    GNUNET_GETOPT_option_flag ('r',
                               "raw",
                               gettext_noop ("No unneeded output"),
                               &raw),
    GNUNET_GETOPT_option_flag ('d',
                               "dns",
                               gettext_noop (
                                 "DNS Compatibility: Name is passed in IDNA instead of UTF-8"),
                               &dns_compat),
    GNUNET_GETOPT_OPTION_END };
  int ret;
  timeout = GNUNET_TIME_UNIT_FOREVER_REL;
 
  GNUNET_log_setup ("gnunet-gns", "WARNING", NULL);
  ret = GNUNET_PROGRAM_run (GNUNET_OS_project_data_gnunet (),
                            argc,
                            argv,
                            "gnunet-gns",
                            _ ("GNUnet GNS resolver tool"),
                            options,
                            &run,
                            NULL);
  if (GNUNET_OK != ret)
    return 1;
  return global_ret;
}

References _, dns_compat, gettext_noop, global_ret, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_flag(), GNUNET_GETOPT_option_mandatory(), GNUNET_GETOPT_option_relative_time(), GNUNET_GETOPT_option_string(), GNUNET_log_setup(), GNUNET_OK, GNUNET_OS_project_data_gnunet(), GNUNET_PROGRAM_run(), GNUNET_TIME_UNIT_FOREVER_REL, lookup_name, lookup_type, options, raw, ret, run(), and timeout.

Here is the call graph for this function:

Variable Documentation

cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

static

Configuration we are using.

Definition at line 48 of file gnunet-gns.c.

Referenced by run().

gns

struct GNUNET_GNS_Handle* gns

static

Handle to GNS service.

Definition at line 53 of file gnunet-gns.c.

Referenced by do_shutdown(), and run().

lookup_name

char* lookup_name

static

GNS name to lookup.

(-u option)

Definition at line 58 of file gnunet-gns.c.

Referenced by main(), and run().

idna_name

char* idna_name

DNS IDNA name to lookup.

(set if -d option is set)

Definition at line 63 of file gnunet-gns.c.

Referenced by do_shutdown(), GNUNET_DNSPARSER_builder_add_name(), and run().

dns_compat

int dns_compat

static

DNS compatibility (name is given as DNS name, possible IDNA).

Definition at line 68 of file gnunet-gns.c.

Referenced by main(), and run().

lookup_type

char* lookup_type

static

record type to look up (-t option)

Definition at line 73 of file gnunet-gns.c.

Referenced by main(), and run().

raw

int raw

static

raw output

Definition at line 78 of file gnunet-gns.c.

Referenced by bf_group_serialize_cb(), build_dns_query(), main(), process_lookup_result(), process_queue(), queue(), and run().

rtype

uint32_t rtype

static

Desired record type.

Definition at line 83 of file gnunet-gns.c.

Referenced by run().

timeout

struct GNUNET_TIME_Relative timeout

static

Timeout for lookup.

Definition at line 88 of file gnunet-gns.c.

Referenced by main(), and run().

to_task

struct GNUNET_SCHEDULER_Task* to_task

static

Timeout task.

Definition at line 93 of file gnunet-gns.c.

Referenced by do_shutdown(), do_timeout(), and run().

lr

struct GNUNET_GNS_LookupWithTldRequest* lr

static

Handle to lookup request.

Definition at line 98 of file gnunet-gns.c.

Referenced by do_shutdown(), GNUNET_ABD_request_cancel(), GNUNET_GNS_lookup_cancel(), GNUNET_GNS_lookup_limited(), handle_link_list_request(), handle_result(), process_lookup_result(), and run().

global_ret

int global_ret

static

Global return value.

0 on success (default), 1 on internal failures 2 on launch failure, 4 if the name is not a GNS-supported TLD,

Definition at line 107 of file gnunet-gns.c.

Referenced by do_timeout(), main(), process_lookup_result(), and run().

spinner

const char spinner[] = {'|', '/', '-', '\\'}

static

Spinner.

Definition at line 112 of file gnunet-gns.c.

{'|', '/', '-', '\\'};

Referenced by spin().

t_spinner

struct GNUNET_SCHEDULER_Task* t_spinner

static

Spinner task.

Definition at line 117 of file gnunet-gns.c.

Referenced by do_shutdown(), process_lookup_result(), run(), and spin().

res_start

struct GNUNET_TIME_Absolute res_start

Resolution start.

Definition at line 122 of file gnunet-gns.c.

Referenced by do_shutdown(), process_lookup_result(), and run().