code for bootstrapping via hostlist servers More...

#include "platform.h"
#include "gnunet-daemon-hostlist_client.h"
#include "gnunet_core_service.h"
#include "gnunet_util_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_statistics_service.h"
#include "gnunet-daemon-hostlist_server.h"

Include dependency graph for gnunet-daemon-hostlist.c:

Data Structures
struct	GNUNET_HOSTLIST_ADV_Message
	A HOSTLIST_ADV message is used to exchange information about hostlist advertisements. More...

Functions
static void	core_init (void cls, const struct GNUNET_PeerIdentity my_identity)
	Callback invoked once our connection to CORE service is up.

static int	check_advertisement (void cls, const struct GNUNET_MessageHeader message)
	Core handler for p2p hostlist advertisements.

static void	handle_advertisement (void cls, const struct GNUNET_MessageHeader message)
	Core handler for p2p hostlist advertisements.

static void *	connect_handler (void cls, const struct GNUNET_PeerIdentity peer, struct GNUNET_MQ_Handle *mq, enum GNUNET_CORE_PeerClass class)
	Method called whenever a given peer connects.

static void	disconnect_handler (void cls, const struct GNUNET_PeerIdentity peer, void *internal_cls)
	Method called whenever a given peer disconnects.

static void	cleaning_task (void *cls)
	Last task run during shutdown.

static void	run (void cls, char const args, const char cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Main function that will be run.

int	main (int argc, char const argv)
	The main function for the hostlist daemon.

Variables
static int	advertising
	Set if we are allowed to advertise our hostlist to others.

static int	provide_hostlist
	Set if the user wants us to run a hostlist server.

static GNUNET_CORE_ConnectEventHandler	server_ch
	Handle to hostlist server's connect handler.

static int	bootstrapping
	Set if we are allowed to learn about peers by accessing hostlist servers.

static int	learning
	Set if the user allows us to learn about new hostlists from the network.

static struct GNUNET_STATISTICS_Handle *	stats
	Statistics handle.

static struct GNUNET_CORE_Handle *	core
	Handle to the core service (NULL until we've connected to it).

static GNUNET_HOSTLIST_UriHandler	client_adv_handler
	Handle to the hostlist client's advertisement handler.

static GNUNET_CORE_ConnectEventHandler	client_ch
	Handle to hostlist client's connect handler.

static GNUNET_CORE_DisconnectEventHandler	client_dh
	Handle to hostlist client's disconnect handler.

static GNUNET_NETWORK_STRUCT_END struct GNUNET_PeerIdentity	me
	Our own peer identity.

Detailed Description

code for bootstrapping via hostlist servers

Author: Christian Grothoff

Definition in file gnunet-daemon-hostlist.c.

Function Documentation

◆ core_init()

static void core_init	(	void *	cls,
		const struct GNUNET_PeerIdentity *	my_identity
	)

static

Callback invoked once our connection to CORE service is up.

Parameters

cls	NULL
my_identity	our peer's identity

Definition at line 129 of file gnunet-daemon-hostlist.c.

{
  me = *my_identity;
}

References me, and my_identity.

Referenced by run().

Here is the caller graph for this function:

◆ check_advertisement()

static int check_advertisement	(	void *	cls,
		const struct GNUNET_MessageHeader *	message
	)

static

Core handler for p2p hostlist advertisements.

Parameters

cls	closure
message	advertisement message we got

Returns: GNUNET_OK if message is well-formed

Definition at line 144 of file gnunet-daemon-hostlist.c.

{
  size_t size;
  size_t uri_size;
  const char *uri;
 
  size = ntohs (message->size);
  if (size <= sizeof(struct GNUNET_MessageHeader))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  uri = (const char *) &message[1];
  uri_size = size - sizeof(struct GNUNET_MessageHeader);
  if (uri[uri_size - 1] != '\0')
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, GNUNET_MessageHeader::size, size, and uri.

◆ handle_advertisement()

static void handle_advertisement	(	void *	cls,
		const struct GNUNET_MessageHeader *	message
	)

static

Core handler for p2p hostlist advertisements.

Parameters

cls	closure
message	advertisement message we got

Returns: GNUNET_OK on success

Definition at line 176 of file gnunet-daemon-hostlist.c.

{
  const char *uri = (const char *) &message[1];
 
  GNUNET_assert (NULL != client_adv_handler);
  (void) (*client_adv_handler)(uri);
}

References client_adv_handler, GNUNET_assert, and uri.

◆ connect_handler()

static void * connect_handler	(	void *	cls,
		const struct GNUNET_PeerIdentity *	peer,
		struct GNUNET_MQ_Handle *	mq,
		enum GNUNET_CORE_PeerClass	class
	)

static

Method called whenever a given peer connects.

Wrapper to call both client's and server's functions

Parameters

cls	closure
peer	peer identity this notification is about
mq	queue for sending messages to peer
class	class of the connecting peer

Returns: peer

Definition at line 197 of file gnunet-daemon-hostlist.c.

{
  if (0 == GNUNET_memcmp (&me,
                          peer))
    return NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "A new peer connected, notifying client and server\n");
  if (NULL != client_ch)
    GNUNET_assert (NULL ==
                   (*client_ch)(cls,
                                peer,
                                mq,
                                class));
  if (NULL != server_ch)
    GNUNET_assert (NULL ==
                   (*server_ch)(cls,
                                peer,
                                mq,
                                class));
  return (void *) peer;
}

References client_ch, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcmp, me, mq, and server_ch.

Referenced by run().

Here is the caller graph for this function:

◆ disconnect_handler()

static void disconnect_handler	(	void *	cls,
		const struct GNUNET_PeerIdentity *	peer,
		void *	internal_cls
	)

static

Method called whenever a given peer disconnects.

Wrapper to call both client's and server's functions

Parameters

cls	closure
peer	peer identity this notification is about

Definition at line 231 of file gnunet-daemon-hostlist.c.

{
  if (0 == GNUNET_memcmp (&me,
                          peer))
    return;
  /* call hostlist client disconnect handler */
  if (NULL != client_dh)
    (*client_dh)(cls,
                 peer,
                 NULL);
}

References client_dh, GNUNET_memcmp, and me.

Referenced by run().

Here is the caller graph for this function:

◆ cleaning_task()

static void cleaning_task ( void * cls )

static

Last task run during shutdown.

Disconnects us from the other services.

Parameters

cls NULL

Definition at line 253 of file gnunet-daemon-hostlist.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Hostlist daemon is shutting down\n");
  if (NULL != core)
  {
    GNUNET_CORE_disconnect (core);
    core = NULL;
  }
  if (bootstrapping)
  {
    GNUNET_HOSTLIST_client_stop ();
  }
  if (provide_hostlist)
  {
    GNUNET_HOSTLIST_server_stop ();
  }
  if (NULL != stats)
  {
    GNUNET_STATISTICS_destroy (stats,
                               GNUNET_NO);
    stats = NULL;
  }
}

References bootstrapping, core, GNUNET_CORE_disconnect(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_HOSTLIST_client_stop(), GNUNET_HOSTLIST_server_stop(), GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_destroy(), provide_hostlist, and stats.

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 *	cfg
	)

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!)
cfg	configuration

Definition at line 288 of file gnunet-daemon-hostlist.c.

{
  struct GNUNET_MQ_MessageHandler learn_handlers[] = {
    GNUNET_MQ_hd_var_size (advertisement,
                           GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT,
                           struct GNUNET_MessageHeader,
                           NULL),
    GNUNET_MQ_handler_end ()
  };
  struct GNUNET_MQ_MessageHandler no_learn_handlers[] = {
    GNUNET_MQ_handler_end ()
  };
  const struct GNUNET_CORE_ServiceInfo service_info =
  {
    .service = GNUNET_CORE_SERVICE_HOSTLIST,
    .version = { 1, 0 },
    .version_max = { 1, 0 },
    .version_min = { 1, 0 },
  };
 
  if ((! bootstrapping) && (! learning)
      && (! provide_hostlist)
      )
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ (
                  "None of the functions for the hostlist daemon were enabled.  I have no reason to run!\n"));
    return;
  }
  stats = GNUNET_STATISTICS_create ("hostlist", cfg);
  if (NULL == stats)
  {
    GNUNET_break (0);
    return;
  }
  if (bootstrapping)
    GNUNET_HOSTLIST_client_start (cfg,
                                  stats,
                                  &client_ch,
                                  &client_dh,
                                  &client_adv_handler,
                                  learning);
  core =
    GNUNET_CORE_connect (cfg,
                         NULL,
                         &core_init,
                         &connect_handler,
                         &disconnect_handler,
                         learning ? learn_handlers : no_learn_handlers,
                         &service_info);
 
 
  if (provide_hostlist)
    GNUNET_HOSTLIST_server_start (cfg,
                                  stats,
                                  core,
                                  &server_ch,
                                  advertising);
  GNUNET_SCHEDULER_add_shutdown (&cleaning_task,
                                 NULL);
 
  if (NULL == core)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to connect to `%s' service.\n"), "core");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
}

References _, advertising, bootstrapping, cfg, cleaning_task(), client_adv_handler, client_ch, client_dh, connect_handler(), core, core_init(), disconnect_handler(), GNUNET_break, GNUNET_CORE_connect(), GNUNET_CORE_SERVICE_HOSTLIST, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_HOSTLIST_client_start(), GNUNET_HOSTLIST_server_start(), GNUNET_log, GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_STATISTICS_create(), learning, provide_hostlist, server_ch, GNUNET_CORE_ServiceInfo::service, and stats.

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 the hostlist daemon.

Parameters

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

Returns: 0 ok, 1 on error

Definition at line 370 of file gnunet-daemon-hostlist.c.

{
  struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_option_flag ('a',
                               "advertise",
                               gettext_noop (
                                 "advertise our hostlist to other peers"),
                               &advertising),
    GNUNET_GETOPT_option_flag ('b',
                               "bootstrap",
                               gettext_noop (
                                 "bootstrap using hostlists (it is highly recommended that you always use this option)"),
                               &bootstrapping),
    GNUNET_GETOPT_option_flag ('e',
                               "enable-learning",
                               gettext_noop (
                                 "enable learning about hostlist servers from other peers"),
                               &learning),
    GNUNET_GETOPT_option_flag ('p',
                               "provide-hostlist",
                               gettext_noop ("provide a hostlist server"),
                               &provide_hostlist),
    GNUNET_GETOPT_OPTION_END
  };
 
  int ret;
 
  GNUNET_log_setup ("hostlist", "WARNING", NULL);
  ret =
    (GNUNET_OK ==
     GNUNET_PROGRAM_run (GNUNET_OS_project_data_gnunet (),
                         argc, argv,
                         "hostlist",
                         _ ("GNUnet hostlist server and client"),
                         options,
                         &run, NULL)) ? 0 : 1;
  return ret;
}