#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_transport_service.h"
#include "gnunet_transport_manipulation_service.h"
#include "gnunet_ats_service.h"
#include "gnunet_testing_lib.h"
#include <sqlite3.h>

Include dependency graph for gnunet-daemon-testbed-underlay.c:

Data Structures
struct	WhiteListRow
	Whilelist entry. More...

Macros
#define	LOG(type, ...) GNUNET_log (type, __VA_ARGS__)
	Logging shorthand. More...

#define	DEBUG(...) LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
	Debug logging shorthand. More...

#define	LOG_SQLITE(db, msg, level, cmd)
	Log an error message at log-level 'level' that indicates a failure of the command 'cmd' on file 'filename' with the message given by strerror(errno). More...

Functions
static int	iterator (void cls, const struct GNUNET_PeerIdentity key, void *value)
	Iterator over hash map entries. More...

static void	cleanup_map ()
	Cleaup and destroy the map. More...

static int	check_access (void cls, const struct GNUNET_PeerIdentity pid)
	Function that decides if a connection is acceptable or not. More...

static int	get_identity (unsigned int offset, struct GNUNET_PeerIdentity *id)

static int	load_keys (const struct GNUNET_CONFIGURATION_Handle *c)
	Function to load keys. More...

static void	unload_keys ()
	Function to unload keys. More...

static void	do_shutdown (void *cls)
	Shutdown task to cleanup our resources and exit. More...

static int	db_read_whitelist (struct sqlite3 db, int pid, struct WhiteListRow *wl_rows)
	Function to read whitelist rows from the database. More...

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

int	main (int argc, char const argv)
	The main function. More...

Variables
static struct GNUNET_CONTAINER_MultiPeerMap *	map
	The map to store the peer identities to allow/deny. More...

static struct sqlite3 *	db
	The database connection. More...

static struct GNUNET_TRANSPORT_Blacklist *	bh
	The blacklist handle we obtain from transport when we register ourselves for access control. More...

struct GNUNET_DISK_FileHandle *	hostkeys_fd
	The hostkeys file. More...

static struct GNUNET_DISK_MapHandle *	hostkeys_map
	The hostkeys map. More...

static void *	hostkeys_data
	The hostkeys data. More...

static struct GNUNET_TRANSPORT_ManipulationHandle *	transport
	Handle to the transport service. More...

static unsigned int	num_hostkeys
	The number of hostkeys in the hostkeys array. More...

Macro Definition Documentation

◆ LOG

#define LOG	(	type,
		...
	)	GNUNET_log (type, __VA_ARGS__)

Logging shorthand.

Definition at line 40 of file gnunet-daemon-testbed-underlay.c.

◆ DEBUG

#define DEBUG ( ... ) LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)

Debug logging shorthand.

Definition at line 46 of file gnunet-daemon-testbed-underlay.c.

◆ LOG_SQLITE

#define LOG_SQLITE	(	db,
		msg,
		level,
		cmd
	)

Value:

  do {                                                                  \
    GNUNET_log_from (level, "sqlite", _ ( \
                       "`%s' failed at %s:%d with error: %s\n"), \
                     cmd, __FILE__, __LINE__, sqlite3_errmsg (db));  \
    if (msg != NULL)                                                    \
    GNUNET_asprintf (msg, _ ("`%s' failed at %s:%u with error: %s"), cmd, \
                     __FILE__, __LINE__, sqlite3_errmsg (db));     \
  } while (0)

Log an error message at log-level 'level' that indicates a failure of the command 'cmd' on file 'filename' with the message given by strerror(errno).

Definition at line 54 of file gnunet-daemon-testbed-underlay.c.

Function Documentation

◆ cleanup_map()

static void cleanup_map ( )

static

Cleaup and destroy the map.

Definition at line 131 of file gnunet-daemon-testbed-underlay.c.

 {
   if (NULL != map)
   {
     GNUNET_assert (GNUNET_SYSERR != GNUNET_CONTAINER_multipeermap_iterate (map,
                                                                            &
                                                                            iterator,
                                                                            NULL));
     GNUNET_CONTAINER_multipeermap_destroy (map);
     map = NULL;
   }
 }

References GNUNET_assert, GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_SYSERR, iterator(), and map.

Referenced by do_shutdown().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_access()

static int check_access	(	void *	cls,
		const struct GNUNET_PeerIdentity *	pid
	)

static

Function that decides if a connection is acceptable or not.

Parameters

cls	closure
pid	peer to approve or disapproave

Returns: GNUNET_OK if the connection is allowed, GNUNET_SYSERR if not

Definition at line 153 of file gnunet-daemon-testbed-underlay.c.

 {
   int contains;
  
   GNUNET_assert (NULL != map);
   contains = GNUNET_CONTAINER_multipeermap_contains (map, pid);
   if (GNUNET_YES == contains)
   {
     DEBUG ("Permitting `%s'\n", GNUNET_i2s (pid));
     return GNUNET_OK;
   }
   DEBUG ("Not permitting `%s'\n", GNUNET_i2s (pid));
   return GNUNET_SYSERR;
 }

References DEBUG, GNUNET_assert, GNUNET_CONTAINER_multipeermap_contains(), GNUNET_i2s(), GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, map, and pid.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_identity()

static int get_identity	(	unsigned int	offset,
		struct GNUNET_PeerIdentity *	id
	)

static

Definition at line 170 of file gnunet-daemon-testbed-underlay.c.

 {
   struct GNUNET_CRYPTO_EddsaPrivateKey private_key;
  
   if (offset >= num_hostkeys)
     return GNUNET_SYSERR;
   GNUNET_memcpy (&private_key,
                  hostkeys_data + (offset * GNUNET_TESTING_HOSTKEYFILESIZE),
                  GNUNET_TESTING_HOSTKEYFILESIZE);
   GNUNET_CRYPTO_eddsa_key_get_public (&private_key,
                                       &id->public_key);
   return GNUNET_OK;
 }

References GNUNET_CRYPTO_eddsa_key_get_public(), GNUNET_memcpy, GNUNET_OK, GNUNET_SYSERR, GNUNET_TESTING_HOSTKEYFILESIZE, hostkeys_data, id, and num_hostkeys.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ load_keys()

static int load_keys ( const struct GNUNET_CONFIGURATION_Handle * c )

static

Function to load keys.

Definition at line 212 of file gnunet-daemon-testbed-underlay.c.

 {
   char *data_dir;
   char *idfile;
   uint64_t fsize;
  
   data_dir = NULL;
   idfile = NULL;
   fsize = 0;
   data_dir = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_DATADIR);
   GNUNET_asprintf (&idfile, "%s/testing_hostkeys.ecc", data_dir);
   GNUNET_free (data_dir);
   data_dir = NULL;
   if (GNUNET_OK !=
       GNUNET_DISK_file_size (idfile, &fsize, GNUNET_YES, GNUNET_YES))
   {
     GNUNET_free (idfile);
     return GNUNET_SYSERR;
   }
   if (0 != (fsize % GNUNET_TESTING_HOSTKEYFILESIZE))
   {
     LOG (GNUNET_ERROR_TYPE_ERROR,
          _ ("Incorrect hostkey file format: %s\n"), idfile);
     GNUNET_free (idfile);
     return GNUNET_SYSERR;
   }
   hostkeys_fd = GNUNET_DISK_file_open (idfile, GNUNET_DISK_OPEN_READ,
                                        GNUNET_DISK_PERM_NONE);
   if (NULL == hostkeys_fd)
   {
     GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", idfile);
     GNUNET_free (idfile);
     return GNUNET_SYSERR;
   }
   GNUNET_free (idfile);
   idfile = NULL;
   hostkeys_data = GNUNET_DISK_file_map (hostkeys_fd,
                                         &hostkeys_map,
                                         GNUNET_DISK_MAP_TYPE_READ,
                                         fsize);
   if (NULL == hostkeys_data)
   {
     GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "mmap");
     return GNUNET_SYSERR;
   }
   num_hostkeys = fsize / GNUNET_TESTING_HOSTKEYFILESIZE;
   return GNUNET_OK;
 }

References _, GNUNET_asprintf(), GNUNET_DISK_file_map(), GNUNET_DISK_file_open(), GNUNET_DISK_file_size(), GNUNET_DISK_MAP_TYPE_READ, GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_NONE, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log_strerror, GNUNET_log_strerror_file, GNUNET_OK, GNUNET_OS_installation_get_path(), GNUNET_OS_IPK_DATADIR, GNUNET_SYSERR, GNUNET_TESTING_HOSTKEYFILESIZE, GNUNET_YES, hostkeys_data, hostkeys_fd, hostkeys_map, LOG, and num_hostkeys.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ unload_keys()

static void unload_keys ( )

static

Function to unload keys.

Definition at line 266 of file gnunet-daemon-testbed-underlay.c.

 {
   if (NULL != hostkeys_map)
   {
     GNUNET_assert (NULL != hostkeys_data);
     GNUNET_DISK_file_unmap (hostkeys_map);
     hostkeys_map = NULL;
     hostkeys_data = NULL;
   }
   if (NULL != hostkeys_fd)
   {
     GNUNET_DISK_file_close (hostkeys_fd);
     hostkeys_fd = NULL;
   }
 }

References GNUNET_assert, GNUNET_DISK_file_close(), GNUNET_DISK_file_unmap(), hostkeys_data, hostkeys_fd, and hostkeys_map.

Referenced by do_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

Shutdown task to cleanup our resources and exit.

Parameters

cls NULL

Definition at line 289 of file gnunet-daemon-testbed-underlay.c.

 {
   if (NULL != transport)
   {
     GNUNET_TRANSPORT_manipulation_disconnect (transport);
     transport = NULL;
   }
   cleanup_map ();
   unload_keys ();
   if (NULL != bh)
     GNUNET_TRANSPORT_blacklist_cancel (bh);
 }

References bh, cleanup_map(), GNUNET_TRANSPORT_blacklist_cancel(), GNUNET_TRANSPORT_manipulation_disconnect(), transport, and unload_keys().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ db_read_whitelist()

static int db_read_whitelist	(	struct sqlite3 *	db,
		int	pid,
		struct WhiteListRow **	wl_rows
	)

static

Function to read whitelist rows from the database.

Parameters

db	the database connection
pid	the identity of this peer
wl_rows	where to store the retrieved whitelist rows

Returns: GNUNET_SYSERR upon error OR the number of rows retrieved

Definition at line 312 of file gnunet-daemon-testbed-underlay.c.

 {
   static const char *query_wl =
     "SELECT oid, latency FROM whitelist WHERE (id == ?);";
   struct sqlite3_stmt *stmt_wl;
   struct WhiteListRow *lr;
   int nrows;
   int ret;
  
   if (SQLITE_OK != (ret = sqlite3_prepare_v2 (db, query_wl, -1, &stmt_wl,
                                               NULL)))
   {
     LOG_SQLITE (db, NULL, GNUNET_ERROR_TYPE_ERROR, "sqlite3_prepare_v2");
     return GNUNET_SYSERR;
   }
   if (SQLITE_OK != (ret = sqlite3_bind_int (stmt_wl, 1, pid)))
   {
     LOG_SQLITE (db, NULL, GNUNET_ERROR_TYPE_ERROR, "sqlite3_bind_int");
     sqlite3_finalize (stmt_wl);
     return GNUNET_SYSERR;
   }
   nrows = 0;
   do
   {
     ret = sqlite3_step (stmt_wl);
     if (SQLITE_ROW != ret)
       break;
     nrows++;
     lr = GNUNET_new (struct WhiteListRow);
     lr->id = sqlite3_column_int (stmt_wl, 0);
     lr->latency = sqlite3_column_int (stmt_wl, 1);
     lr->next = *wl_rows;
     *wl_rows = lr;
   }
   while (1);
   sqlite3_finalize (stmt_wl);
   return nrows;
 }

References db, GNUNET_ERROR_TYPE_ERROR, GNUNET_new, GNUNET_SYSERR, LOG_SQLITE, lr, pid, and ret.

Referenced by run().

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

Definition at line 361 of file gnunet-daemon-testbed-underlay.c.

 {
   char *dbfile;
   struct WhiteListRow *wl_head;
   struct WhiteListRow *wl_entry;
   struct GNUNET_PeerIdentity identity;
   struct GNUNET_ATS_Properties prop;
   struct GNUNET_TIME_Relative delay;
   unsigned long long pid;
   unsigned int nrows;
   int ret;
  
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_number (c, "TESTBED",
                                              "PEERID", &pid))
   {
     GNUNET_break (0);
     return;
   }
   if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (c,
                                                             "TESTBED-UNDERLAY",
                                                             "DBFILE",
                                                             &dbfile))
   {
     GNUNET_break (0);
     return;
   }
   if (SQLITE_OK != (ret = sqlite3_open_v2 (dbfile, &db, SQLITE_OPEN_READONLY,
                                            NULL)))
   {
     if (NULL != db)
     {
       LOG_SQLITE (db, NULL, GNUNET_ERROR_TYPE_ERROR, "sqlite_open_v2");
       GNUNET_break (SQLITE_OK == sqlite3_close (db));
     }
     else
       LOG (GNUNET_ERROR_TYPE_ERROR, "Cannot open sqlite file %s\n", dbfile);
     GNUNET_free (dbfile);
     return;
   }
   DEBUG ("Opened database %s\n", dbfile);
   GNUNET_free (dbfile);
   dbfile = NULL;
   wl_head = NULL;
   if (GNUNET_OK != load_keys (c))
     goto close_db;
  
   transport = GNUNET_TRANSPORT_manipulation_connect (c);
   if (NULL == transport)
   {
     GNUNET_break (0);
     return;
   }
   /* read and process whitelist */
   nrows = 0;
   wl_head = NULL;
   nrows = db_read_whitelist (db, pid, &wl_head);
   if ((GNUNET_SYSERR == nrows) || (0 == nrows))
   {
     GNUNET_TRANSPORT_manipulation_disconnect (transport);
     goto close_db;
   }
   map = GNUNET_CONTAINER_multipeermap_create (nrows, GNUNET_NO);
   while (NULL != (wl_entry = wl_head))
   {
     wl_head = wl_entry->next;
     delay.rel_value_us = wl_entry->latency;
     memset (&prop, 0, sizeof(prop));
     GNUNET_assert (GNUNET_OK == get_identity (wl_entry->id, &identity));
     GNUNET_break (GNUNET_OK ==
                   GNUNET_CONTAINER_multipeermap_put (map, &identity, &identity,
                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
     DEBUG ("Setting %u ms latency to peer `%s'\n",
            wl_entry->latency,
            GNUNET_i2s (&identity));
     GNUNET_TRANSPORT_manipulation_set (transport,
                                        &identity,
                                        &prop,
                                        delay,
                                        delay);
     GNUNET_free (wl_entry);
   }
   bh = GNUNET_TRANSPORT_blacklist (c, &check_access, NULL);
   GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
  
 close_db:
   GNUNET_break (SQLITE_OK == sqlite3_close (db));
 }

References bh, check_access(), db, db_read_whitelist(), DEBUG, delay, do_shutdown(), get_identity(), GNUNET_assert, GNUNET_break, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_CONTAINER_multipeermap_create(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_i2s(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_shutdown(), GNUNET_SYSERR, GNUNET_TRANSPORT_blacklist(), GNUNET_TRANSPORT_manipulation_connect(), GNUNET_TRANSPORT_manipulation_disconnect(), GNUNET_TRANSPORT_manipulation_set(), WhiteListRow::id, identity, WhiteListRow::latency, load_keys(), LOG, LOG_SQLITE, map, WhiteListRow::next, pid, GNUNET_TIME_Relative::rel_value_us, ret, and transport.

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.

Parameters

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

Returns: 0 ok, 1 on error

Definition at line 460 of file gnunet-daemon-testbed-underlay.c.

 {
   static const struct GNUNET_GETOPT_CommandLineOption options[] = {
     GNUNET_GETOPT_OPTION_END
   };
   int ret;
  
   if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
     return 2;
 #ifdef SQLITE_CONFIG_MMAP_SIZE
   (void) sqlite3_config (SQLITE_CONFIG_MMAP_SIZE, 512000, 256000000);
 #endif
   ret =
     (GNUNET_OK ==
      GNUNET_PROGRAM_run (argc, argv, "testbed-underlay",
                          _
                          (
                            "Daemon to restrict underlay network in testbed deployments"),
                          options, &run, NULL)) ? 0 : 1;
   GNUNET_free_nz ((void *) argv);
   return ret;
 }