Program to generate a database file containing given underlay topology. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_testbed_service.h"
#include "testbed_api_topology.h"
#include "sqlite3.h"

Include dependency graph for generate-underlay-topology.c:

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

#define	LOG_ERROR(...) LOG (GNUNET_ERROR_TYPE_ERROR, __VA_ARGS__)

#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	link_processor (void *cls, unsigned int A, unsigned int B, unsigned int bandwidth, unsigned int latency, unsigned int loss)
	Functions of this type are called to process underlay link. More...

static int	setup_db (const char *dbfile)
	Open the database file, creating a new database if not existing and setup the whitelist table. More...

static void	run (void cls, char const args, const char cfgfile, const struct GNUNET_CONFIGURATION_Handle *config)
	Main run function. More...

int	main (int argc, char *const argv[])
	Main. More...

Variables
static struct sqlite3 *	db
	Handle to the sqlite3 database. More...

struct sqlite3_stmt *	stmt_insert
	Prepared statement for inserting link values into db. More...

enum GNUNET_TESTBED_TopologyOption	topology
	The topology to generate. More...

static unsigned int	num_peers
	The number of peers to include in the topology. More...

static int	exit_result
	program result More...

Detailed Description

Program to generate a database file containing given underlay topology.

Author: Sree Harsha Totakura sreeh.nosp@m.arsh.nosp@m.a@tot.nosp@m.akur.nosp@m.a.in

Definition in file generate-underlay-topology.c.

Macro Definition Documentation

◆ LOG

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

Definition at line 33 of file generate-underlay-topology.c.

◆ LOG_ERROR

#define LOG_ERROR ( ... ) LOG (GNUNET_ERROR_TYPE_ERROR, __VA_ARGS__)

Definition at line 36 of file generate-underlay-topology.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 43 of file generate-underlay-topology.c.

Function Documentation

◆ link_processor()

static int link_processor	(	void *	cls,
		unsigned int	A,
		unsigned int	B,
		unsigned int	bandwidth,
		unsigned int	latency,
		unsigned int	loss
	)

static

Functions of this type are called to process underlay link.

Parameters

cls	closure
A	offset of first peer
B	offset of second peer
bandwidth	the bandwidth of the link in bytes per second
latency	the latency of link in milliseconds
loss	the percentage of messages dropped on the link

Returns: GNUNET_OK to continue processing; GNUNET_SYSERR to abort

Definition at line 101 of file generate-underlay-topology.c.

 {
   if ((SQLITE_OK != sqlite3_bind_int (stmt_insert, 1, A)) ||
       (SQLITE_OK != sqlite3_bind_int (stmt_insert, 2, B)) ||
       (SQLITE_OK != sqlite3_bind_int (stmt_insert, 3, bandwidth)) ||
       (SQLITE_OK != sqlite3_bind_int (stmt_insert, 4, latency)) ||
       (SQLITE_OK != sqlite3_bind_int (stmt_insert, 5, loss)))
   {
     LOG_SQLITE (db, NULL, GNUNET_ERROR_TYPE_ERROR, "sqlite3_bind_int");
     return GNUNET_SYSERR;
   }
   if (SQLITE_DONE != sqlite3_step (stmt_insert))
   {
     LOG_SQLITE (db, NULL, GNUNET_ERROR_TYPE_ERROR, "sqlite3_step");
     return GNUNET_SYSERR;
   }
   fprintf (stdout, "%u -> %u\n", A, B);
   GNUNET_break (SQLITE_OK == sqlite3_reset (stmt_insert));
   // GNUNET_break (SQLITE_OK == sqlite3_clear_bindings (stmt_insert));
   if ((SQLITE_OK != sqlite3_bind_int (stmt_insert, 1, B)) ||
       (SQLITE_OK != sqlite3_bind_int (stmt_insert, 2, A)))
   {
     LOG_SQLITE (db, NULL, GNUNET_ERROR_TYPE_ERROR, "sqlite3_bind_int");
     return GNUNET_SYSERR;
   }
   if (SQLITE_DONE != sqlite3_step (stmt_insert))
   {
     LOG_SQLITE (db, NULL, GNUNET_ERROR_TYPE_ERROR, "sqlite3_step");
     return GNUNET_SYSERR;
   }
   fprintf (stdout, "%u -> %u\n", B, A);
   GNUNET_break (SQLITE_OK == sqlite3_reset (stmt_insert));
   return GNUNET_OK;
 }

References db, GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_OK, GNUNET_SYSERR, LOG_SQLITE, and stmt_insert.

Referenced by run().

Here is the caller graph for this function:

◆ setup_db()

static int setup_db ( const char * dbfile )

static

Open the database file, creating a new database if not existing and setup the whitelist table.

Parameters

dbfile the database filename

Returns: GNUNET_OK upon success; GNUNET_SYSERR upon failure (error message has to be printed)

Definition at line 151 of file generate-underlay-topology.c.

 {
   const char *query_create = "CREATE TABLE whitelist ("
                              "id INTEGER,"
                              "oid INTEGER,"
                              "bandwidth INTEGER DEFAULT NULL,"
                              "latency INTEGER DEFAULT NULL,"
                              "loss INTEGER DEFAULT NULL,"
                              " UNIQUE ("
                              "  id,"
                              "  oid"
                              " ) ON CONFLICT IGNORE"
                              ");";
   const char *query_insert = "INSERT INTO whitelist("
                              " id,"
                              " oid,"
                              " bandwidth,"
                              " latency,"
                              " loss"
                              ") VALUES ("
                              " ?1,"
                              " ?2,"
                              " ?3,"
                              " ?4,"
                              " ?5);";
   int ret;
  
   ret = GNUNET_SYSERR;
   if (SQLITE_OK != sqlite3_open (dbfile, &db))
   {
     LOG_SQLITE (db, NULL, GNUNET_ERROR_TYPE_ERROR, "sqlite3_open");
     goto err_ret;
   }
   if (0 != sqlite3_exec (db, query_create, NULL, NULL, NULL))
   {
     LOG_SQLITE (db, NULL, GNUNET_ERROR_TYPE_ERROR, "sqlite3_exec");
     fprintf (stderr,
              "Error: %d.  Perhaps the database `%s' already exits.\n",
              sqlite3_errcode (db),
              dbfile);
     goto err_ret;
   }
   GNUNET_break (0 ==
                 sqlite3_exec (db, "PRAGMA synchronous = 0;", NULL, NULL, NULL));
   if (SQLITE_OK !=
       sqlite3_prepare_v2 (db, query_insert, -1, &stmt_insert, NULL))
   {
     LOG_SQLITE (db, NULL, GNUNET_ERROR_TYPE_ERROR, "sqlite3_prepare_v2");
     goto err_ret;
   }
   ret = GNUNET_OK;
  
 err_ret:
   return ret;
 }

References db, GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_OK, GNUNET_SYSERR, LOG_SQLITE, ret, and stmt_insert.

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

static

Main run function.

Parameters

cls	NULL
args	arguments passed to GNUNET_PROGRAM_run
cfgfile	the path to configuration file
cfg	the configuration file handle

Definition at line 217 of file generate-underlay-topology.c.

 {
   const char *dbfile;
   const char *topology_string;
   unsigned int arg_uint1;
   unsigned int arg_uint2;
   const char *arg_str1;
   const char *value;
   unsigned int argc;
  
   argc = 0;
   arg_uint1 = 0; /* make compilers happy */
   arg_uint2 = 0; /* make compilers happy */
   if (NULL == args)
   {
     LOG_ERROR (_ ("Need at least 2 arguments\n"));
     return;
   }
   if (NULL == (dbfile = args[argc++]))
   {
     LOG_ERROR (_ ("Database filename missing\n"));
     return;
   }
   if (GNUNET_OK != setup_db (dbfile))
     return;
   if (NULL == (topology_string = args[argc++]))
   {
     LOG_ERROR (_ ("Topology string missing\n"));
     return;
   }
   if (GNUNET_YES != GNUNET_TESTBED_topology_get_ (&topology, topology_string))
   {
     LOG_ERROR (_ ("Invalid topology: %s\n"), topology_string);
     return;
   }
   arg_str1 = NULL;
   /* parse for first TOPOOPT.  This can either be arg_uint1 or arg_str1 */
   switch (topology)
   {
   case GNUNET_TESTBED_TOPOLOGY_ERDOS_RENYI:
   case GNUNET_TESTBED_TOPOLOGY_SMALL_WORLD_RING:
   case GNUNET_TESTBED_TOPOLOGY_SMALL_WORLD:
   case GNUNET_TESTBED_TOPOLOGY_SCALE_FREE:
     if (NULL == (value = args[argc++]))
     {
       LOG_ERROR (_ ("An argument is missing for given topology `%s'\n"),
                  topology_string);
       return;
     }
     if (-1 == sscanf (value, "%u", &arg_uint1))
     {
       LOG_ERROR (_ ("Invalid argument `%s' given as topology argument\n"),
                  value);
       return;
     }
     break;
  
   case GNUNET_TESTBED_TOPOLOGY_FROM_FILE:
     if (NULL == (arg_str1 = args[argc++]))
     {
       LOG_ERROR (_ ("Filename argument missing for topology `%s'\n"),
                  topology_string);
       return;
     }
     break;
  
   default:
     break;
   }
   /* parse for second TOPOOPT.  Only required for SCALE_FREE topology */
   switch (topology)
   {
   case GNUNET_TESTBED_TOPOLOGY_SCALE_FREE:
     if (NULL == (value = args[argc++]))
     {
       LOG_ERROR (_ ("Second argument for topology `%s' is missing\n"),
                  topology_string);
       return;
     }
     if (-1 == sscanf (value, "%u", &arg_uint2))
     {
       LOG_ERROR (_ ("Invalid argument `%s'; expecting unsigned int\n"), value);
       return;
     }
     break;
  
   default:
     break;
   }
   /* construct topologies */
   switch (topology)
   {
   case GNUNET_TESTBED_TOPOLOGY_LINE:
   case GNUNET_TESTBED_TOPOLOGY_RING:
   case GNUNET_TESTBED_TOPOLOGY_STAR:
   case GNUNET_TESTBED_TOPOLOGY_CLIQUE:
   case GNUNET_TESTBED_TOPOLOGY_2D_TORUS:
     GNUNET_TESTBED_underlay_construct_ (num_peers,
                                         link_processor,
                                         NULL,
                                         topology);
     break;
  
   case GNUNET_TESTBED_TOPOLOGY_ERDOS_RENYI:
   case GNUNET_TESTBED_TOPOLOGY_SMALL_WORLD_RING:
   case GNUNET_TESTBED_TOPOLOGY_SMALL_WORLD:
     GNUNET_TESTBED_underlay_construct_ (num_peers,
                                         link_processor,
                                         NULL,
                                         topology,
                                         arg_uint1);
     break;
  
   case GNUNET_TESTBED_TOPOLOGY_FROM_FILE:
     GNUNET_TESTBED_underlay_construct_ (num_peers,
                                         link_processor,
                                         NULL,
                                         topology,
                                         arg_str1);
     break;
  
   case GNUNET_TESTBED_TOPOLOGY_SCALE_FREE:
     GNUNET_TESTBED_underlay_construct_ (num_peers,
                                         link_processor,
                                         NULL,
                                         topology,
                                         arg_uint1,
                                         arg_uint2);
     break;
  
   default:
     GNUNET_assert (0);
   }
 }

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[]
	)

Main.

Definition at line 360 of file generate-underlay-topology.c.

 {
   struct GNUNET_GETOPT_CommandLineOption option[] = {
     GNUNET_GETOPT_option_uint ('p',
                                "num-peers",
                                "COUNT",
                                gettext_noop ("create COUNT number of peers"),
                                &num_peers),
     GNUNET_GETOPT_OPTION_END
   };
  
   int ret;
  
   exit_result = GNUNET_SYSERR;
   ret = GNUNET_PROGRAM_run (
     argc,
     argv,
     "gnunet-underlay-topology",
     _ (
       "Generates SQLite3 database representing a given underlay topology.\n"
       "Usage: gnunet-underlay-topology [OPTIONS] db-filename TOPO [TOPOOPTS]\n"
       "The following options are available for TOPO followed by TOPOOPTS if applicable:\n"
       "\t LINE\n"
       "\t RING\n"
       "\t RANDOM <num_rnd_links>\n"
       "\t SMALL_WORLD <num_rnd_links>\n"
       "\t SMALL_WORLD_RING <num_rnd_links>\n"
       "\t CLIQUE\n"
       "\t 2D_TORUS\n"
       "\t SCALE_FREE <cap> <m>\n"
       "\t FROM_FILE <filename>\n"
       "TOPOOPTS:\n"
       "\t num_rnd_links: The number of random links\n"
       "\t cap: the maximum number of links a node can have\n"
       "\t m: the number of links a node should have while joining the network\n"
       "\t filename: the path of the file which contains topology information\n"
       "NOTE: the format of the above file is described here: https://www.gnunet.org/content/topology-file-format\n"),
     option,
     &run,
     NULL);
   if (NULL != stmt_insert)
     sqlite3_finalize (stmt_insert);
   if (NULL != db)
     GNUNET_break (SQLITE_OK == sqlite3_close (db));
   if ((GNUNET_OK != ret) || (GNUNET_OK != exit_result))
     return 1;
   return 0;
 }