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;
}
/**
* 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);
}
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;
}
static int
testLocation ()
{
struct GNUNET_FS_Uri *uri;
char *uric;
struct GNUNET_FS_Uri *uri2;
struct GNUNET_FS_Uri *baseURI;
char *emsg;
struct GNUNET_CRYPTO_EddsaPrivateKey *pk;
baseURI =
GNUNET_FS_uri_parse
("gnunet://fs/chk/4QZP479A9SKGFNMQ2ZBCYE71YV2QMTVGWTVPB6A10ASVCKXDHB05DKPSC7ZF6E9P9W1VE47394EQY7NXA47Q6R35M7P1MJPGP59D1Z8.D54QD1K5XCG5878T6YZ19AM60MQ6FC0YNVK7QY08KK0KM0FJJ3KQWYG112FN5T07KN7J0X35DF6WVBT9B8ZMZ3X2BXJ22X3KFQ6MV2G.15999",
&emsg);
GNUNET_assert (baseURI != NULL);
GNUNET_assert (emsg == NULL);
pk = GNUNET_CRYPTO_eddsa_key_create ();
uri = GNUNET_FS_uri_loc_create (baseURI,
pk,
GNUNET_TIME_absolute_get ());
GNUNET_free (pk);
if (NULL == uri)
{
GNUNET_break (0);
GNUNET_FS_uri_destroy (baseURI);
return 1;
}
if (! GNUNET_FS_uri_test_loc (uri))
{
GNUNET_break (0);
GNUNET_FS_uri_destroy (uri);
GNUNET_FS_uri_destroy (baseURI);
return 1;
}
uri2 = GNUNET_FS_uri_loc_get_uri (uri);
if (! GNUNET_FS_uri_test_equal (baseURI, uri2))
{
GNUNET_break (0);
GNUNET_FS_uri_destroy (uri);
GNUNET_FS_uri_destroy (uri2);
GNUNET_FS_uri_destroy (baseURI);
return 1;
}
GNUNET_FS_uri_destroy (uri2);
GNUNET_FS_uri_destroy (baseURI);
uric = GNUNET_FS_uri_to_string (uri);
#if 0
/* not for the faint of heart: */
printf ("URI: `%s'\n", uric);
#endif
uri2 = GNUNET_FS_uri_parse (uric, &emsg);
GNUNET_free (uric);
if (uri2 == NULL)
{
fprintf (stderr, "URI parsing failed: %s\n", emsg);
GNUNET_break (0);
GNUNET_FS_uri_destroy (uri);
GNUNET_free (emsg);
return 1;
}
GNUNET_assert (NULL == emsg);
if (GNUNET_YES != GNUNET_FS_uri_test_equal (uri, uri2))
{
GNUNET_break (0);
GNUNET_FS_uri_destroy (uri);
GNUNET_FS_uri_destroy (uri2);
return 1;
}
GNUNET_FS_uri_destroy (uri2);
GNUNET_FS_uri_destroy (uri);
return 0;
}
/**
* Create a new private key by reading it from a file. If the
* files does not exist, create a new key and write it to the
* file. Caller must free return value. Note that this function
* can not guarantee that another process might not be trying
* the same operation on the same file at the same time.
* If the contents of the file
* are invalid the old file is deleted and a fresh key is
* created.
*
* @param filename name of file to use to store the key
* @return new private key, NULL on error (for example,
* permission denied)
*/
struct GNUNET_CRYPTO_EddsaPrivateKey *
GNUNET_CRYPTO_eddsa_key_create_from_file (const char *filename)
{
struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
struct GNUNET_DISK_FileHandle *fd;
unsigned int cnt;
int ec;
uint64_t fs;
if (GNUNET_SYSERR == GNUNET_DISK_directory_create_for_file (filename))
return NULL;
while (GNUNET_YES != GNUNET_DISK_file_test (filename))
{
fd = GNUNET_DISK_file_open (filename,
GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE
| GNUNET_DISK_OPEN_FAILIFEXISTS,
GNUNET_DISK_PERM_USER_READ |
GNUNET_DISK_PERM_USER_WRITE);
if (NULL == fd)
{
if (EEXIST == errno)
{
if (GNUNET_YES != GNUNET_DISK_file_test (filename))
{
/* must exist but not be accessible, fail for good! */
if (0 != ACCESS (filename, R_OK))
LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "access", filename);
else
GNUNET_break (0); /* what is going on!? */
return NULL;
}
continue;
}
LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "open", filename);
return NULL;
}
cnt = 0;
while (GNUNET_YES !=
GNUNET_DISK_file_lock (fd, 0,
sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey),
GNUNET_YES))
{
short_wait ();
if (0 == ++cnt % 10)
{
ec = errno;
LOG (GNUNET_ERROR_TYPE_ERROR,
_("Could not acquire lock on file `%s': %s...\n"), filename,
STRERROR (ec));
}
}
LOG (GNUNET_ERROR_TYPE_INFO,
_("Creating a new private key. This may take a while.\n"));
priv = GNUNET_CRYPTO_eddsa_key_create ();
GNUNET_assert (NULL != priv);
GNUNET_assert (sizeof (*priv) ==
GNUNET_DISK_file_write (fd, priv, sizeof (*priv)));
GNUNET_DISK_file_sync (fd);
if (GNUNET_YES !=
GNUNET_DISK_file_unlock (fd, 0,
sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey)))
LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
GNUNET_assert (GNUNET_YES == GNUNET_DISK_file_close (fd));
return priv;
}
/* key file exists already, read it! */
fd = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_READ,
GNUNET_DISK_PERM_NONE);
if (NULL == fd)
{
LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "open", filename);
return NULL;
}
cnt = 0;
while (1)
{
if (GNUNET_YES !=
GNUNET_DISK_file_lock (fd, 0,
sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey),
GNUNET_NO))
{
if (0 == ++cnt % 60)
{
ec = errno;
LOG (GNUNET_ERROR_TYPE_ERROR,
_("Could not acquire lock on file `%s': %s...\n"), filename,
STRERROR (ec));
LOG (GNUNET_ERROR_TYPE_ERROR,
_
("This may be ok if someone is currently generating a private key.\n"));
}
short_wait ();
continue;
}
if (GNUNET_YES != GNUNET_DISK_file_test (filename))
{
/* eh, what!? File we opened is now gone!? */
LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "stat", filename);
if (GNUNET_YES !=
GNUNET_DISK_file_unlock (fd, 0,
sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey)))
LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fd));
return NULL;
}
if (GNUNET_OK != GNUNET_DISK_file_size (filename, &fs, GNUNET_YES, GNUNET_YES))
fs = 0;
if (fs < sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey))
{
/* maybe we got the read lock before the key generating
* process had a chance to get the write lock; give it up! */
if (GNUNET_YES !=
GNUNET_DISK_file_unlock (fd, 0,
sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey)))
LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
if (0 == ++cnt % 10)
{
LOG (GNUNET_ERROR_TYPE_ERROR,
_("When trying to read key file `%s' I found %u bytes but I need at least %u.\n"),
filename, (unsigned int) fs,
(unsigned int) sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey));
LOG (GNUNET_ERROR_TYPE_ERROR,
_("This may be ok if someone is currently generating a key.\n"));
}
short_wait (); /* wait a bit longer! */
continue;
}
break;
}
fs = sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey);
priv = GNUNET_malloc (fs);
GNUNET_assert (fs == GNUNET_DISK_file_read (fd, priv, fs));
if (GNUNET_YES !=
GNUNET_DISK_file_unlock (fd, 0,
sizeof (struct GNUNET_CRYPTO_EddsaPrivateKey)))
LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fcntl", filename);
GNUNET_assert (GNUNET_YES == GNUNET_DISK_file_close (fd));
return priv;
}
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);
}
