static int
test_ecdh()
{
struct GNUNET_CRYPTO_EddsaPrivateKey *priv_dsa;
struct GNUNET_CRYPTO_EcdhePrivateKey *priv_ecdh;
struct GNUNET_CRYPTO_EddsaPublicKey id1;
struct GNUNET_CRYPTO_EcdhePublicKey id2;
struct GNUNET_HashCode dh[3];
/* Generate keys */
priv_dsa = GNUNET_CRYPTO_eddsa_key_create ();
priv_ecdh = GNUNET_CRYPTO_ecdhe_key_create ();
/* Extract public keys */
GNUNET_CRYPTO_eddsa_key_get_public (priv_dsa,
&id1);
GNUNET_CRYPTO_ecdhe_key_get_public (priv_ecdh,
&id2);
/* Do ECDH */
GNUNET_assert (GNUNET_OK ==
GNUNET_CRYPTO_eddsa_ecdh (priv_dsa,
&id2,
&dh[0]));
GNUNET_assert (GNUNET_OK ==
GNUNET_CRYPTO_ecdh_eddsa (priv_ecdh,
&id1,
&dh[1]));
/* Check that both DH results are equal. */
GNUNET_assert (0 == memcmp (&dh[0], &dh[1],
sizeof (struct GNUNET_HashCode)));
GNUNET_free (priv_dsa);
GNUNET_free (priv_ecdh);
return 0;
}
/**
* Process cadet requests.
*
* @param cls closure
* @param server the initialized server
* @param c configuration to use
*/
static void
run (void *cls, struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *c)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "starting to run\n");
stats = GNUNET_STATISTICS_create ("cadet", c);
/* Scheduled the task to clean up when shutdown is called */
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
NULL);
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "reading key\n");
my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration (c);
GNUNET_assert (NULL != my_private_key);
GNUNET_CRYPTO_eddsa_key_get_public (my_private_key, &my_full_id.public_key);
myid = GNUNET_PEER_intern (&my_full_id);
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"STARTING SERVICE (cadet) for peer [%s]\n",
GNUNET_i2s (&my_full_id));
GML_init (server); /* Local clients */
GCH_init (c); /* Hellos */
GCC_init (c); /* Connections */
GCP_init (c); /* Peers */
GCD_init (c); /* DHT */
GCT_init (c, my_private_key); /* Tunnels */
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cadet service running\n");
}
static int
get_identity (unsigned int offset, struct GNUNET_PeerIdentity *id)
{
struct GNUNET_CRYPTO_EddsaPrivateKey private_key;
if (offset >= num_hostkeys)
return GNUNET_SYSERR;
(void) 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;
}
/**
* Function run when service multicast has started and is providing us
* with a configuration file.
*/
static void *
service_conf_peer0 (void *cls,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
group_key = GNUNET_CRYPTO_eddsa_key_create ();
GNUNET_CRYPTO_eddsa_key_get_public (group_key, &group_pub_key);
return GNUNET_MULTICAST_origin_start (cfg, group_key, 0,
origin_recv_join_request,
origin_recv_replay_frag,
origin_recv_replay_msg,
origin_recv_request,
origin_recv_message,
NULL);
}
/**
* Retrieve the identity of the host's peer.
*
* @param cfg configuration to use
* @param dst pointer to where to write the peer identity
* @return #GNUNET_OK on success, #GNUNET_SYSERR if the identity
* could not be retrieved
*/
int
GNUNET_CRYPTO_get_peer_identity (const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_PeerIdentity *dst)
{
struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
if (NULL == (priv = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg)))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Could not load peer's private key\n"));
return GNUNET_SYSERR;
}
GNUNET_CRYPTO_eddsa_key_get_public (priv, &dst->public_key);
GNUNET_free (priv);
return GNUNET_OK;
}
/**
* Callback to be called when the requested peer information is available
*
* @param cb_cls the closure from GNUNET_TETSBED_peer_get_information()
* @param op the operation this callback corresponds to
* @param pinfo the result; will be NULL if the operation has failed
* @param emsg error message if the operation has failed; will be NULL if the
* operation is successfull
*/
static void
peer_info_cb (void *cb_cls, struct GNUNET_TESTBED_Operation *op,
const struct GNUNET_TESTBED_PeerInformation *pinfo,
const char *emsg)
{
/* generate random data block */
GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK, msg, MSG_SIZE);
/* get private and public keys */
private_key =
GNUNET_CRYPTO_eddsa_key_create_from_configuration (pinfo->result.cfg);
GNUNET_assert (NULL != private_key);
public_key = GNUNET_new (struct GNUNET_CRYPTO_EddsaPublicKey);
GNUNET_CRYPTO_eddsa_key_get_public (private_key, public_key);
current_matching_bits = MATCHING_BITS_START;
performed_iterations = 0;
total_duration = GNUNET_TIME_UNIT_ZERO;
GNUNET_TESTBED_operation_done (op);
GNUNET_SCHEDULER_add_now (&pow_start, NULL);
}
/**
* Main function that will be run by the scheduler.
*
* @param cls closure
* @param args remaining command-line arguments
* @param cfgfile name of the configuration file used (for saving, can be NULL!)
* @param cfg configuration
*/
static void
run (void *cls,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *config)
{
struct GNUNET_CRYPTO_EddsaPrivateKey *pk;
char *pids;
cfg = config;
/* load proof of work */
if (NULL == pwfn)
{
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (cfg, "NSE",
"PROOFFILE",
&pwfn))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
"NSE", "PROOFFILE");
GNUNET_SCHEDULER_shutdown ();
return;
}
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Proof of Work file: %s\n",
pwfn);
if ( (GNUNET_YES != GNUNET_DISK_file_test (pwfn)) ||
(sizeof (proof) !=
GNUNET_DISK_fn_read (pwfn, &proof, sizeof (proof))))
proof = 0;
/* load private key */
if (NULL == pkfn)
{
if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "PEER",
"PRIVATE_KEY",
&pkfn))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
"PEER", "PRIVATE_KEY");
return;
}
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Private Key file: %s\n", pkfn);
if (NULL == (pk = GNUNET_CRYPTO_eddsa_key_create_from_file (pkfn)))
{
FPRINTF (stderr, _("Loading hostkey from `%s' failed.\n"), pkfn);
GNUNET_free (pkfn);
return;
}
GNUNET_free (pkfn);
GNUNET_CRYPTO_eddsa_key_get_public (pk, &pub);
GNUNET_free (pk);
pids = GNUNET_CRYPTO_eddsa_public_key_to_string (&pub);
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Peer ID: %s\n",
pids);
GNUNET_free (pids);
/* get target bit amount */
if (0 == nse_work_required)
{
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_number (cfg, "NSE", "WORKBITS",
&nse_work_required))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "WORKBITS");
GNUNET_SCHEDULER_shutdown ();
return;
}
if (nse_work_required >= sizeof (struct GNUNET_HashCode) * 8)
{
GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR, "NSE", "WORKBITS",
_("Value is too large.\n"));
GNUNET_SCHEDULER_shutdown ();
return;
} else if (0 == nse_work_required)
{
write_proof ();
GNUNET_SCHEDULER_shutdown ();
return;
}
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Bits: %llu\n",
nse_work_required);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Delay between tries: %s\n",
GNUNET_STRINGS_relative_time_to_string (proof_find_delay, 1));
GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
&find_proof, NULL);
}
int
main (int argc, char *argv[])
{
int i;
struct GNUNET_CRYPTO_EcdhePrivateKey *ecdhe[l];
struct GNUNET_CRYPTO_EcdhePublicKey dhpub[l];
struct GNUNET_CRYPTO_EddsaPrivateKey *eddsa[l];
struct GNUNET_CRYPTO_EddsaPublicKey dspub[l];
struct TestSig sig[l];
start = GNUNET_TIME_absolute_get();
for (i = 0; i < l; i++)
{
sig[i].purp.purpose = 0;
sig[i].purp.size = htonl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose)
+ sizeof (struct GNUNET_HashCode));
GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
&sig[i].h,
sizeof (sig[i].h));
}
log_duration ("", "Init");
start = GNUNET_TIME_absolute_get();
for (i = 0; i < l; i++)
eddsa[i] = GNUNET_CRYPTO_eddsa_key_create();
log_duration ("EdDSA", "create key");
start = GNUNET_TIME_absolute_get();
for (i = 0; i < l; i++)
GNUNET_CRYPTO_eddsa_key_get_public (eddsa[i], &dspub[i]);
log_duration ("EdDSA", "get pubilc");
start = GNUNET_TIME_absolute_get();
for (i = 0; i < l; i++)
GNUNET_assert (GNUNET_OK ==
GNUNET_CRYPTO_eddsa_sign (eddsa[i],
&sig[i].purp,
&sig[i].sig));
log_duration ("EdDSA", "sign HashCode");
start = GNUNET_TIME_absolute_get();
for (i = 0; i < l; i++)
GNUNET_assert (GNUNET_OK ==
GNUNET_CRYPTO_eddsa_verify (0,
&sig[i].purp,
&sig[i].sig,
&dspub[i]));
log_duration ("EdDSA", "verify HashCode");
start = GNUNET_TIME_absolute_get();
for (i = 0; i < l; i++)
ecdhe[i] = GNUNET_CRYPTO_ecdhe_key_create();
log_duration ("ECDH", "create key");
start = GNUNET_TIME_absolute_get();
for (i = 0; i < l; i++)
GNUNET_CRYPTO_ecdhe_key_get_public (ecdhe[i], &dhpub[i]);
log_duration ("ECDH", "get public");
start = GNUNET_TIME_absolute_get();
for (i = 0; i < l - 1; i+=2)
{
GNUNET_CRYPTO_ecc_ecdh (ecdhe[i], &dhpub[i+1], &sig[i].h);
GNUNET_CRYPTO_ecc_ecdh (ecdhe[i+1], &dhpub[i], &sig[i+1].h);
}
log_duration ("ECDH", "do DH");
return 0;
}
/**
* Initiate transport service.
*
* @param cls closure
* @param server the initialized server
* @param c configuration to use
*/
static void
run (void *cls,
struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *c)
{
char *keyfile;
struct GNUNET_CRYPTO_EddsaPrivateKey *pk;
long long unsigned int max_fd_cfg;
int max_fd_rlimit;
int max_fd;
int friend_only;
/* setup globals */
GST_cfg = c;
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (c,
"PEER",
"PRIVATE_KEY",
&keyfile))
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
_("Transport service is lacking key configuration settings. Exiting.\n"));
GNUNET_SCHEDULER_shutdown ();
return;
}
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_time (c,
"transport",
"HELLO_EXPIRATION",
&hello_expiration))
{
hello_expiration = GNUNET_CONSTANTS_HELLO_ADDRESS_EXPIRATION;
}
GST_server = server;
pk = GNUNET_CRYPTO_eddsa_key_create_from_file (keyfile);
GNUNET_free (keyfile);
GNUNET_assert (NULL != pk);
GST_my_private_key = pk;
GST_stats = GNUNET_STATISTICS_create ("transport", GST_cfg);
GST_peerinfo = GNUNET_PEERINFO_connect (GST_cfg);
GNUNET_CRYPTO_eddsa_key_get_public (GST_my_private_key,
&GST_my_identity.public_key);
GNUNET_assert(NULL != GST_my_private_key);
GNUNET_log(GNUNET_ERROR_TYPE_INFO,
"My identity is `%4s'\n",
GNUNET_i2s_full (&GST_my_identity));
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&shutdown_task,
NULL);
if (NULL == GST_peerinfo)
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
_("Could not access PEERINFO service. Exiting.\n"));
GNUNET_SCHEDULER_shutdown ();
return;
}
max_fd_rlimit = 0;
max_fd_cfg = 0;
#if HAVE_GETRLIMIT
struct rlimit r_file;
if (0 == getrlimit (RLIMIT_NOFILE, &r_file))
{
max_fd_rlimit = r_file.rlim_cur;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Maximum number of open files was: %u/%u\n",
r_file.rlim_cur,
r_file.rlim_max);
}
max_fd_rlimit = (9 * max_fd_rlimit) / 10; /* Keep 10% for rest of transport */
#endif
GNUNET_CONFIGURATION_get_value_number (GST_cfg,
"transport",
"MAX_FD",
&max_fd_cfg);
if (max_fd_cfg > max_fd_rlimit)
max_fd = max_fd_cfg;
else
max_fd = max_fd_rlimit;
if (max_fd < DEFAULT_MAX_FDS)
max_fd = DEFAULT_MAX_FDS;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Limiting number of sockets to %u: validation %u, neighbors: %u\n",
max_fd, (max_fd / 3), (max_fd / 3) * 2);
friend_only = GNUNET_CONFIGURATION_get_value_yesno (GST_cfg,
"topology",
"FRIENDS-ONLY");
if (GNUNET_SYSERR == friend_only)
friend_only = GNUNET_NO; /* According to topology defaults */
/* start subsystems */
GST_blacklist_start (GST_server,
GST_cfg,
&GST_my_identity);
GST_is = GNUNET_ATS_scanner_init ();
GST_ats_connect = GNUNET_ATS_connectivity_init (GST_cfg);
GST_ats = GNUNET_ATS_scheduling_init (GST_cfg,
&ats_request_address_change,
NULL);
GST_ats_init ();
GST_manipulation_init ();
GST_plugins_load (&GST_manipulation_recv,
&plugin_env_address_change_notification,
&plugin_env_session_start,
&plugin_env_session_end);
GST_hello_start (friend_only,
&process_hello_update,
NULL);
GST_neighbours_start ((max_fd / 3) * 2);
GST_clients_start (GST_server);
GST_validation_start ((max_fd / 3));
}
/**
* Regex callback iterator to store own service description in the DHT.
*
* @param cls closure.
* @param key hash for current state.
* @param proof proof for current state.
* @param accepting #GNUNET_YES if this is an accepting state, #GNUNET_NO if not.
* @param num_edges number of edges leaving current state.
* @param edges edges leaving current state.
*/
static void
regex_iterator (void *cls,
const struct GNUNET_HashCode *key,
const char *proof,
int accepting,
unsigned int num_edges,
const struct REGEX_BLOCK_Edge *edges)
{
struct REGEX_INTERNAL_Announcement *h = cls;
struct RegexBlock *block;
size_t size;
unsigned int i;
LOG (GNUNET_ERROR_TYPE_INFO,
"DHT PUT for state %s with proof `%s' and %u edges:\n",
GNUNET_h2s (key),
proof,
num_edges);
for (i = 0; i < num_edges; i++)
{
LOG (GNUNET_ERROR_TYPE_INFO,
"Edge %u `%s' towards %s\n",
i,
edges[i].label,
GNUNET_h2s (&edges[i].destination));
}
if (GNUNET_YES == accepting)
{
struct RegexAcceptBlock ab;
LOG (GNUNET_ERROR_TYPE_INFO,
"State %s is accepting, putting own id\n",
GNUNET_h2s (key));
size = sizeof (struct RegexAcceptBlock);
ab.purpose.size = ntohl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
sizeof (struct GNUNET_TIME_AbsoluteNBO) +
sizeof (struct GNUNET_HashCode));
ab.purpose.purpose = ntohl (GNUNET_SIGNATURE_PURPOSE_REGEX_ACCEPT);
ab.expiration_time = GNUNET_TIME_absolute_hton (GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_DHT_MAX_EXPIRATION));
ab.key = *key;
GNUNET_CRYPTO_eddsa_key_get_public (h->priv,
&ab.peer.public_key);
GNUNET_assert (GNUNET_OK ==
GNUNET_CRYPTO_eddsa_sign (h->priv,
&ab.purpose,
&ab.signature));
GNUNET_STATISTICS_update (h->stats, "# regex accepting blocks stored",
1, GNUNET_NO);
GNUNET_STATISTICS_update (h->stats, "# regex accepting block bytes stored",
sizeof (struct RegexAcceptBlock), GNUNET_NO);
(void)
GNUNET_DHT_put (h->dht, key,
DHT_REPLICATION,
DHT_OPT | GNUNET_DHT_RO_RECORD_ROUTE,
GNUNET_BLOCK_TYPE_REGEX_ACCEPT,
size,
&ab,
GNUNET_TIME_relative_to_absolute (DHT_TTL),
NULL, NULL);
}
block = REGEX_BLOCK_create (proof,
num_edges, edges,
accepting,
&size);
(void)
GNUNET_DHT_put (h->dht, key,
DHT_REPLICATION,
DHT_OPT,
GNUNET_BLOCK_TYPE_REGEX,
size, block,
GNUNET_TIME_relative_to_absolute (DHT_TTL),
NULL, NULL);
GNUNET_STATISTICS_update (h->stats,
"# regex blocks stored",
1, GNUNET_NO);
GNUNET_STATISTICS_update (h->stats,
"# regex block bytes stored",
size, GNUNET_NO);
GNUNET_free (block);
}
/**
* Handle network size estimate clients.
*
* @param cls closure
* @param c configuration to use
* @param service the initialized service
*/
static void
run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *c,
struct GNUNET_SERVICE_Handle *service)
{
struct GNUNET_MQ_MessageHandler core_handlers[] = {
GNUNET_MQ_hd_fixed_size (p2p_estimate,
GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD,
struct GNUNET_NSE_FloodMessage,
NULL),
GNUNET_MQ_handler_end ()
};
char *proof;
struct GNUNET_CRYPTO_EddsaPrivateKey *pk;
cfg = c;
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_time (cfg,
"NSE",
"INTERVAL",
&gnunet_nse_interval))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
"NSE",
"INTERVAL");
GNUNET_SCHEDULER_shutdown ();
return;
}
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_time (cfg,
"NSE",
"WORKDELAY",
&proof_find_delay))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
"NSE",
"WORKDELAY");
GNUNET_SCHEDULER_shutdown ();
return;
}
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_number (cfg,
"NSE",
"WORKBITS",
&nse_work_required))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
"NSE",
"WORKBITS");
GNUNET_SCHEDULER_shutdown ();
return;
}
if (nse_work_required >= sizeof (struct GNUNET_HashCode) * 8)
{
GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
"NSE",
"WORKBITS",
_("Value is too large.\n"));
GNUNET_SCHEDULER_shutdown ();
return;
}
#if ENABLE_NSE_HISTOGRAM
{
char *histogram_dir;
char *histogram_fn;
if (GNUNET_OK ==
GNUNET_CONFIGURATION_get_value_filename (cfg,
"NSE",
"HISTOGRAM_DIR",
&histogram_dir))
{
GNUNET_assert (0 < GNUNET_asprintf (&histogram_fn,
"%s/timestamps",
histogram_dir));
GNUNET_free (histogram_dir);
histogram = GNUNET_BIO_write_open (histogram_fn);
if (NULL == histogram)
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Unable to open histogram file `%s'\n",
histogram_fn);
GNUNET_free (histogram_fn);
}
logger_test =
GNUNET_CLIENT_service_test ("testbed-logger",
cfg,
GNUNET_TIME_UNIT_SECONDS,
&status_cb,
NULL);
}
#endif
GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
NULL);
pk = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg);
GNUNET_assert (NULL != pk);
my_private_key = pk;
GNUNET_CRYPTO_eddsa_key_get_public (my_private_key,
&my_identity.public_key);
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (cfg,
"NSE",
"PROOFFILE",
&proof))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
"NSE",
"PROOFFILE");
GNUNET_free (my_private_key);
my_private_key = NULL;
GNUNET_SCHEDULER_shutdown ();
return;
}
if ((GNUNET_YES != GNUNET_DISK_file_test (proof)) ||
(sizeof (my_proof) !=
GNUNET_DISK_fn_read (proof,
&my_proof,
sizeof (my_proof))))
my_proof = 0;
GNUNET_free (proof);
proof_task =
GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
&find_proof,
NULL);
peers = GNUNET_CONTAINER_multipeermap_create (128,
GNUNET_YES);
nc = GNUNET_notification_context_create (1);
/* Connect to core service and register core handlers */
core_api = GNUNET_CORE_connect (cfg, /* Main configuration */
NULL, /* Closure passed to functions */
&core_init, /* Call core_init once connected */
&handle_core_connect, /* Handle connects */
&handle_core_disconnect, /* Handle disconnects */
core_handlers); /* Register these handlers */
if (NULL == core_api)
{
GNUNET_SCHEDULER_shutdown ();
return;
}
stats = GNUNET_STATISTICS_create ("nse",
cfg);
}
static void
run (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
struct GNUNET_PSYCSTORE_PluginFunctions *db;
ok = 1;
db = load_plugin (cfg);
if (NULL == db)
{
FPRINTF (stderr,
"%s",
"Failed to initialize PSYCstore. "
"Database likely not setup, skipping test.\n");
ok = 77;
return;
}
/* Store & test membership */
LOG (GNUNET_ERROR_TYPE_INFO, "MEMBERSHIP\n");
channel_key = GNUNET_CRYPTO_eddsa_key_create ();
slave_key = GNUNET_CRYPTO_ecdsa_key_create ();
GNUNET_CRYPTO_eddsa_key_get_public (channel_key,
&channel_pub_key);
GNUNET_CRYPTO_ecdsa_key_get_public (slave_key, &slave_pub_key);
LOG (GNUNET_ERROR_TYPE_INFO, "membership_store()\n");
GNUNET_assert (GNUNET_OK == db->membership_store (db->cls, &channel_pub_key,
&slave_pub_key, GNUNET_YES,
4, 2, 1));
LOG (GNUNET_ERROR_TYPE_INFO, "membership_test()\n");
GNUNET_assert (GNUNET_YES == db->membership_test (db->cls, &channel_pub_key,
&slave_pub_key, 4));
GNUNET_assert (GNUNET_YES == db->membership_test (db->cls, &channel_pub_key,
&slave_pub_key, 2));
GNUNET_assert (GNUNET_NO == db->membership_test (db->cls, &channel_pub_key,
&slave_pub_key, 1));
/* Store & get messages */
LOG (GNUNET_ERROR_TYPE_INFO, "MESSAGES\n");
struct GNUNET_MULTICAST_MessageHeader *msg
= GNUNET_malloc (sizeof (*msg) + sizeof (channel_pub_key));
GNUNET_assert (msg != NULL);
msg->header.type = htons (GNUNET_MESSAGE_TYPE_MULTICAST_MESSAGE);
msg->header.size = htons (sizeof (*msg) + sizeof (channel_pub_key));
uint64_t fragment_id = INT64_MAX - 1;
msg->fragment_id = GNUNET_htonll (fragment_id);
uint64_t message_id = INT64_MAX - 10;
msg->message_id = GNUNET_htonll (message_id);
uint64_t group_generation = INT64_MAX - 3;
msg->group_generation = GNUNET_htonll (group_generation);
msg->hop_counter = htonl (9);
msg->fragment_offset = GNUNET_htonll (0);
msg->flags = htonl (GNUNET_MULTICAST_MESSAGE_LAST_FRAGMENT);
GNUNET_memcpy (&msg[1], &channel_pub_key, sizeof (channel_pub_key));
msg->purpose.size = htonl (ntohs (msg->header.size)
- sizeof (msg->header)
- sizeof (msg->hop_counter)
- sizeof (msg->signature));
msg->purpose.purpose = htonl (234);
GNUNET_assert (GNUNET_OK ==
GNUNET_CRYPTO_eddsa_sign (channel_key, &msg->purpose, &msg->signature));
LOG (GNUNET_ERROR_TYPE_INFO, "fragment_store()\n");
struct FragmentClosure fcls = { 0 };
fcls.n = 0;
fcls.msg[0] = msg;
fcls.flags[0] = GNUNET_PSYCSTORE_MESSAGE_STATE;
GNUNET_assert (
GNUNET_OK == db->fragment_store (db->cls, &channel_pub_key, msg,
fcls.flags[0]));
LOG (GNUNET_ERROR_TYPE_INFO, "fragment_get(%" PRIu64 ")\n", fragment_id);
uint64_t ret_frags = 0;
GNUNET_assert (
GNUNET_OK == db->fragment_get (db->cls, &channel_pub_key,
fragment_id, fragment_id,
&ret_frags, fragment_cb, &fcls));
GNUNET_assert (fcls.n == 1);
LOG (GNUNET_ERROR_TYPE_INFO, "message_get_fragment()\n");
fcls.n = 0;
GNUNET_assert (
GNUNET_OK == db->message_get_fragment (db->cls, &channel_pub_key,
GNUNET_ntohll (msg->message_id),
GNUNET_ntohll (msg->fragment_offset),
fragment_cb, &fcls));
GNUNET_assert (fcls.n == 1);
LOG (GNUNET_ERROR_TYPE_INFO, "message_add_flags()\n");
GNUNET_assert (
GNUNET_OK == db->message_add_flags (db->cls, &channel_pub_key,
GNUNET_ntohll (msg->message_id),
GNUNET_PSYCSTORE_MESSAGE_STATE_APPLIED));
LOG (GNUNET_ERROR_TYPE_INFO, "fragment_get(%" PRIu64 ")\n", fragment_id);
fcls.n = 0;
fcls.flags[0] |= GNUNET_PSYCSTORE_MESSAGE_STATE_APPLIED;
GNUNET_assert (
GNUNET_OK == db->fragment_get (db->cls, &channel_pub_key,
fragment_id, fragment_id,
&ret_frags, fragment_cb, &fcls));
GNUNET_assert (fcls.n == 1);
LOG (GNUNET_ERROR_TYPE_INFO, "fragment_store()\n");
struct GNUNET_MULTICAST_MessageHeader *msg1
= GNUNET_malloc (sizeof (*msg1) + sizeof (channel_pub_key));
GNUNET_memcpy (msg1, msg, sizeof (*msg1) + sizeof (channel_pub_key));
msg1->fragment_id = GNUNET_htonll (INT64_MAX);
msg1->fragment_offset = GNUNET_htonll (32768);
fcls.n = 0;
fcls.msg[1] = msg1;
fcls.flags[1] = GNUNET_PSYCSTORE_MESSAGE_STATE_HASH;
GNUNET_assert (GNUNET_OK == db->fragment_store (db->cls, &channel_pub_key, msg1,
fcls.flags[1]));
LOG (GNUNET_ERROR_TYPE_INFO, "message_get()\n");
GNUNET_assert (
GNUNET_OK == db->message_get (db->cls, &channel_pub_key,
message_id, message_id, 0,
&ret_frags, fragment_cb, &fcls));
GNUNET_assert (fcls.n == 2 && ret_frags == 2);
/* Message counters */
LOG (GNUNET_ERROR_TYPE_INFO, "counters_message_get()\n");
fragment_id = 0;
message_id = 0;
group_generation = 0;
GNUNET_assert (
GNUNET_OK == db->counters_message_get (db->cls, &channel_pub_key,
&fragment_id, &message_id,
&group_generation)
&& fragment_id == GNUNET_ntohll (msg1->fragment_id)
&& message_id == GNUNET_ntohll (msg1->message_id)
&& group_generation == GNUNET_ntohll (msg1->group_generation));
/* Modify state */
LOG (GNUNET_ERROR_TYPE_INFO, "STATE\n");
LOG (GNUNET_ERROR_TYPE_INFO, "state_modify_*()\n");
message_id = GNUNET_ntohll (fcls.msg[0]->message_id) + 1;
GNUNET_assert (GNUNET_OK == db->state_modify_begin (db->cls, &channel_pub_key,
message_id, 0));
GNUNET_assert (GNUNET_OK == db->state_modify_op (db->cls, &channel_pub_key,
GNUNET_PSYC_OP_ASSIGN,
"_foo",
C2ARG("one two three")));
GNUNET_assert (GNUNET_OK == db->state_modify_op (db->cls, &channel_pub_key,
GNUNET_PSYC_OP_ASSIGN,
"_foo_bar", slave_key,
sizeof (*slave_key)));
GNUNET_assert (GNUNET_OK == db->state_modify_end (db->cls, &channel_pub_key,
message_id));
LOG (GNUNET_ERROR_TYPE_INFO, "state_get()\n");
struct StateClosure scls = { 0 };
scls.n = 0;
scls.value[0] = "one two three";
scls.value_size[0] = strlen ("one two three");
GNUNET_assert (GNUNET_OK == db->state_get (db->cls, &channel_pub_key, "_foo",
state_cb, &scls));
GNUNET_assert (scls.n == 1);
LOG (GNUNET_ERROR_TYPE_INFO, "state_get_prefix()\n");
scls.n = 0;
scls.value[1] = slave_key;
scls.value_size[1] = sizeof (*slave_key);
GNUNET_assert (GNUNET_OK == db->state_get_prefix (db->cls, &channel_pub_key,
"_foo", state_cb, &scls));
GNUNET_assert (scls.n == 2);
LOG (GNUNET_ERROR_TYPE_INFO, "state_get_signed()\n");
scls.n = 0;
GNUNET_assert (GNUNET_NO == db->state_get_signed (db->cls, &channel_pub_key,
state_cb, &scls));
GNUNET_assert (scls.n == 0);
LOG (GNUNET_ERROR_TYPE_INFO, "state_update_signed()\n");
GNUNET_assert (GNUNET_OK == db->state_update_signed (db->cls,
&channel_pub_key));
LOG (GNUNET_ERROR_TYPE_INFO, "state_get_signed()\n");
scls.n = 0;
GNUNET_assert (GNUNET_YES == db->state_get_signed (db->cls, &channel_pub_key,
state_cb, &scls));
GNUNET_assert (scls.n == 2);
/* State counters */
LOG (GNUNET_ERROR_TYPE_INFO, "counters_state_get()\n");
uint64_t max_state_msg_id = 0;
GNUNET_assert (GNUNET_OK == db->counters_state_get (db->cls, &channel_pub_key,
&max_state_msg_id)
&& max_state_msg_id == message_id);
/* State sync */
LOG (GNUNET_ERROR_TYPE_INFO, "state_sync_*()\n");
scls.n = 0;
scls.value[0] = channel_key;
scls.value_size[0] = sizeof (*channel_key);
scls.value[1] = "three two one";
scls.value_size[1] = strlen ("three two one");
GNUNET_assert (GNUNET_OK == db->state_sync_begin (db->cls, &channel_pub_key));
GNUNET_assert (GNUNET_OK == db->state_sync_assign (db->cls, &channel_pub_key,
"_sync_bar", scls.value[0],
scls.value_size[0]));
GNUNET_assert (GNUNET_OK == db->state_sync_assign (db->cls, &channel_pub_key,
"_sync_foo", scls.value[1],
scls.value_size[1]));
GNUNET_assert (GNUNET_OK == db->state_sync_end (db->cls, &channel_pub_key,
max_state_msg_id,
INT64_MAX - 5));
GNUNET_assert (GNUNET_NO == db->state_get_prefix (db->cls, &channel_pub_key,
"_foo", state_cb, &scls));
GNUNET_assert (scls.n == 0);
GNUNET_assert (GNUNET_OK == db->state_get_prefix (db->cls, &channel_pub_key,
"_sync", state_cb, &scls));
GNUNET_assert (scls.n == 2);
scls.n = 0;
GNUNET_assert (GNUNET_OK == db->state_get_signed (db->cls, &channel_pub_key,
state_cb, &scls));
GNUNET_assert (scls.n == 2);
/* Modify state after sync */
LOG (GNUNET_ERROR_TYPE_INFO, "state_modify_*()\n");
message_id = GNUNET_ntohll (fcls.msg[0]->message_id) + 6;
GNUNET_assert (GNUNET_OK == db->state_modify_begin (db->cls, &channel_pub_key,
message_id,
message_id - max_state_msg_id));
GNUNET_assert (GNUNET_OK == db->state_modify_op (db->cls, &channel_pub_key,
GNUNET_PSYC_OP_ASSIGN,
"_sync_foo",
C2ARG("five six seven")));
GNUNET_assert (GNUNET_OK == db->state_modify_end (db->cls, &channel_pub_key,
message_id));
/* Reset state */
LOG (GNUNET_ERROR_TYPE_INFO, "state_reset()\n");
scls.n = 0;
GNUNET_assert (GNUNET_OK == db->state_reset (db->cls, &channel_pub_key));
GNUNET_assert (scls.n == 0);
ok = 0;
if (NULL != channel_key)
{
GNUNET_free (channel_key);
channel_key = NULL;
}
if (NULL != slave_key)
{
GNUNET_free (slave_key);
slave_key = NULL;
}
unload_plugin (db);
}
/**
* Setup CADET internals.
*
* @param cls closure
* @param server the initialized server
* @param c configuration to use
*/
static void
run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *c,
struct GNUNET_SERVICE_Handle *service)
{
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_number (c,
"CADET",
"RATCHET_MESSAGES",
&ratchet_messages))
{
GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING,
"CADET",
"RATCHET_MESSAGES",
"needs to be a number");
ratchet_messages = 64;
}
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_time (c,
"CADET",
"RATCHET_TIME",
&ratchet_time))
{
GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING,
"CADET",
"RATCHET_TIME",
"need delay value");
ratchet_time = GNUNET_TIME_UNIT_HOURS;
}
my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration (c);
if (NULL == my_private_key)
{
GNUNET_break (0);
GNUNET_SCHEDULER_shutdown ();
return;
}
GNUNET_CRYPTO_eddsa_key_get_public (my_private_key,
&my_full_id.public_key);
stats = GNUNET_STATISTICS_create ("cadet",
c);
GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
NULL);
ats_ch = GNUNET_ATS_connectivity_init (c);
/* FIXME: optimize code to allow GNUNET_YES here! */
open_ports = GNUNET_CONTAINER_multihashmap_create (16,
GNUNET_NO);
loose_channels = GNUNET_CONTAINER_multihashmap_create (16,
GNUNET_NO);
peers = GNUNET_CONTAINER_multipeermap_create (16,
GNUNET_YES);
connections = GNUNET_CONTAINER_multishortmap_create (256,
GNUNET_YES);
GCH_init (c);
GCD_init (c);
GCO_init (c);
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"CADET starting at peer %s\n",
GNUNET_i2s (&my_full_id));
}
