+static void
+state_reset_result (void *cls,
+ int64_t result,
+ const char *err_msg,
+ uint16_t err_msg_size)
+{
+ op = NULL;
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "state_reset_result:\t%d\n",
+ (int) result);
+ GNUNET_assert (GNUNET_OK == result);
+
+ op = GNUNET_PSYCSTORE_state_reset (h, &channel_pub_key,
+ &state_reset_result, cls);
+ GNUNET_PSYCSTORE_operation_cancel (op);
+ op = NULL;
+ end ();
+}
+
+
+static int
+state_result (void *cls,
+ const char *name,
+ const void *value,
+ uint32_t value_size)
+{
+ struct StateClosure *scls = cls;
+ const char *nam = scls->name[scls->n];
+ const void *val = scls->value[scls->n];
+ size_t val_size = scls->value_size[scls->n++];
+
+ if (value_size == val_size
+ && 0 == memcmp (value, val, val_size)
+ && 0 == strcmp (name, nam))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ " variable %s matches\n",
+ name);
+ return GNUNET_YES;
+ }
+ else
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ " variable %s differs\nReceived: %.*s\nExpected: %.*s\n",
+ name, value_size, value, val_size, val);
+ GNUNET_assert (0);
+ return GNUNET_SYSERR;
+ }
+}
+
+
+static void
+state_get_prefix_result (void *cls, int64_t result,
+ const char *err_msg, uint16_t err_msg_size)
+{
+ struct StateClosure *scls = cls;
+ op = NULL;
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "state_get_prefix_result:\t%d\n", result);
+ GNUNET_assert (GNUNET_OK == result && 2 == scls->n);
+
+ op = GNUNET_PSYCSTORE_state_reset (h, &channel_pub_key,
+ &state_reset_result, cls);
+}
+
+
+static void
+state_get_result (void *cls, int64_t result,
+ const char *err_msg, uint16_t err_msg_size)
+{
+ op = NULL;
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "state_get_result:\t%d\n", result);
+ GNUNET_assert (GNUNET_OK == result);
+
+ scls.n = 0;
+
+ scls.name[0] = "_sync_bar";
+ scls.value[0] = "ten eleven twelve";
+ scls.value_size[0] = sizeof ("ten eleven twelve") - 1;
+
+ scls.name[1] = "_sync_foo";
+ scls.value[1] = "three two one";
+ scls.value_size[1] = sizeof ("three two one") - 1;
+
+ op = GNUNET_PSYCSTORE_state_get_prefix (h, &channel_pub_key, "_sync",
+ &state_result,
+ &state_get_prefix_result, &scls);
+}
+
+
+static void
+counters_result (void *cls, int status, uint64_t max_fragment_id,
+ uint64_t max_message_id, uint64_t max_group_generation,
+ uint64_t max_state_message_id)
+{
+ struct FragmentClosure *fcls = cls;
+ int result = 0;
+ op = NULL;
+
+ if (GNUNET_OK == status
+ && max_fragment_id == GNUNET_ntohll (fcls->msg[2]->fragment_id)
+ && max_message_id == GNUNET_ntohll (fcls->msg[2]->message_id)
+ && max_group_generation == GNUNET_ntohll (fcls->msg[2]->group_generation)
+ && max_state_message_id == GNUNET_ntohll (fcls->msg[0]->message_id))
+ result = 1;
+
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "counters_get:\t%d\n", result);
+ GNUNET_assert (result == 1);
+
+ scls.n = 0;
+ scls.name[0] = "_sync_bar";
+ scls.value[0] = "ten eleven twelve";
+ scls.value_size[0] = sizeof ("ten eleven twelve") - 1;
+
+ op = GNUNET_PSYCSTORE_state_get (h, &channel_pub_key, "_sync_bar_x_yy_zzz",
+ &state_result, &state_get_result, &scls);
+}
+
+
+static void
+state_modify_result (void *cls, int64_t result,
+ const char *err_msg, uint16_t err_msg_size)
+{
+ op = NULL;
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "state_modify_result:\t%d\n", result);
+ GNUNET_assert (GNUNET_OK == result);
+
+ op = GNUNET_PSYCSTORE_counters_get (h, &channel_pub_key,
+ &counters_result, cls);
+}
+
+
+static void
+state_sync_result (void *cls, int64_t result,
+ const char *err_msg, uint16_t err_msg_size)
+{
+ struct FragmentClosure *fcls = cls;
+ op = NULL;
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "state_sync_result:\t%d\n", result);
+ GNUNET_assert (GNUNET_OK == result);
+
+ op = GNUNET_PSYCSTORE_state_modify (h, &channel_pub_key,
+ GNUNET_ntohll (fcls->msg[0]->message_id),
+ 0, state_modify_result, fcls);
+}
+
+
+static int
+fragment_result (void *cls,
+ struct GNUNET_MULTICAST_MessageHeader *msg,
+ enum GNUNET_PSYCSTORE_MessageFlags flags)
+{
+ struct FragmentClosure *fcls = cls;
+ GNUNET_assert (fcls->n < fcls->n_expected);
+ struct GNUNET_MULTICAST_MessageHeader *msg0 = fcls->msg[fcls->n];
+ uint64_t flags0 = fcls->flags[fcls->n++];
+
+ if (flags == flags0 && msg->header.size == msg0->header.size
+ && 0 == memcmp (msg, msg0, ntohs (msg->header.size)))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, " fragment %" PRIu64 " matches\n",
+ GNUNET_ntohll (msg->fragment_id));
+ return GNUNET_YES;
+ }
+ else
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ " fragment differs: expected %" PRIu64 ", got %" PRIu64 "\n",
+ GNUNET_ntohll (msg0->fragment_id),
+ GNUNET_ntohll (msg->fragment_id));
+ GNUNET_assert (0);
+ return GNUNET_SYSERR;
+ }
+}
+
+
+static void
+message_get_latest_result (void *cls, int64_t result,
+ const char *err_msg, uint16_t err_msg_size)
+{
+ struct FragmentClosure *fcls = cls;
+ op = NULL;
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "message_get_latest:\t%d\n", result);
+ GNUNET_assert (0 < result && fcls->n == fcls->n_expected);
+
+ modifiers[0] = (struct GNUNET_PSYC_Modifier) {
+ .oper = '=',
+ .name = "_sync_foo",
+ .value = "three two one",
+ .value_size = sizeof ("three two one") - 1
+ };
+ modifiers[1] = (struct GNUNET_PSYC_Modifier) {
+ .oper = '=',
+ .name = "_sync_bar",
+ .value = "ten eleven twelve",
+ .value_size = sizeof ("ten eleven twelve") - 1
+ };
+
+ op = GNUNET_PSYCSTORE_state_sync (h, &channel_pub_key,
+ GNUNET_ntohll (fcls->msg[0]->message_id) + 1,
+ GNUNET_ntohll (fcls->msg[0]->message_id) + 2,
+ 2, modifiers, state_sync_result, fcls);
+}
+
+
+static void
+message_get_result (void *cls, int64_t result,
+ const char *err_msg, uint16_t err_msg_size)
+{
+ struct FragmentClosure *fcls = cls;
+ op = NULL;
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "message_get:\t%d\n", result);
+ GNUNET_assert (0 < result && fcls->n == fcls->n_expected);
+
+ fcls->n = 0;
+ fcls->n_expected = 3;
+ op = GNUNET_PSYCSTORE_message_get_latest (h, &channel_pub_key, &slave_pub_key,
+ 1, "", &fragment_result,
+ &message_get_latest_result, fcls);
+}
+
+
+static void
+message_get_fragment_result (void *cls, int64_t result,
+ const char *err_msg, uint16_t err_msg_size)
+{
+ struct FragmentClosure *fcls = cls;
+ op = NULL;
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "message_get_fragment:\t%d\n", result);
+ GNUNET_assert (0 < result && fcls->n == fcls->n_expected);
+
+ fcls->n = 0;
+ fcls->n_expected = 3;
+ uint64_t message_id = GNUNET_ntohll (fcls->msg[0]->message_id);
+ op = GNUNET_PSYCSTORE_message_get (h, &channel_pub_key, &slave_pub_key,
+ message_id, message_id, 0, "",
+ &fragment_result,
+ &message_get_result, fcls);
+}
+
+
+static void
+fragment_get_latest_result (void *cls, int64_t result,
+ const char *err_msg, uint16_t err_msg_size)
+{
+ struct FragmentClosure *fcls = cls;
+ op = NULL;
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "fragment_get_latest:\t%d\n", result);
+ GNUNET_assert (0 < result && fcls->n == fcls->n_expected);
+
+ fcls->n = 1;
+ fcls->n_expected = 2;
+ op = GNUNET_PSYCSTORE_message_get_fragment (h, &channel_pub_key, &slave_pub_key,
+ GNUNET_ntohll (fcls->msg[1]->message_id),
+ GNUNET_ntohll (fcls->msg[1]->fragment_offset),
+ &fragment_result,
+ &message_get_fragment_result, fcls);
+}
+
+
+static void
+fragment_get_result (void *cls, int64_t result,
+ const char *err_msg, uint16_t err_msg_size)
+{
+ struct FragmentClosure *fcls = cls;
+ op = NULL;
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "fragment_get:\t%d\n",
+ (int) result);
+ GNUNET_assert (0 < result && fcls->n == fcls->n_expected);
+
+ fcls->n = 0;
+ fcls->n_expected = 3;
+ op = GNUNET_PSYCSTORE_fragment_get_latest (h, &channel_pub_key,
+ &slave_pub_key, fcls->n_expected,
+ &fragment_result,
+ &fragment_get_latest_result, fcls);
+}
+
+
+static void
+fragment_store_result (void *cls, int64_t result,
+ const char *err_msg, uint16_t err_msg_size)
+{
+ op = NULL;
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "fragment_store:\t%d\n", result);
+ GNUNET_assert (GNUNET_OK == result);
+
+ if ((intptr_t) cls == GNUNET_YES)
+ { /* last fragment */
+ fcls.n = 0;
+ fcls.n_expected = 1;
+ uint64_t fragment_id = GNUNET_ntohll (fcls.msg[0]->fragment_id);
+ op = GNUNET_PSYCSTORE_fragment_get (h, &channel_pub_key, &slave_pub_key,
+ fragment_id, fragment_id,
+ &fragment_result,
+ &fragment_get_result, &fcls);
+ }
+}
+
+
+static void
+fragment_store ()
+{
+ struct GNUNET_MULTICAST_MessageHeader *msg;
+ fcls.flags[0] = GNUNET_PSYCSTORE_MESSAGE_STATE;
+ fcls.msg[0] = 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));
+
+ msg->hop_counter = htonl (9);
+ msg->fragment_id = GNUNET_htonll (INT64_MAX - 8);
+ msg->fragment_offset = GNUNET_htonll (0);
+ msg->message_id = GNUNET_htonll (INT64_MAX - 10);
+ msg->group_generation = GNUNET_htonll (INT64_MAX - 3);
+ 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));
+
+ op = GNUNET_PSYCSTORE_fragment_store (h, &channel_pub_key, msg, fcls.flags[0],
+ &fragment_store_result, GNUNET_NO);
+
+ fcls.flags[1] = GNUNET_PSYCSTORE_MESSAGE_STATE_APPLIED;
+ fcls.msg[1] = msg = GNUNET_malloc (sizeof (*msg) + sizeof (channel_pub_key));
+ GNUNET_memcpy (msg, fcls.msg[0], sizeof (*msg) + sizeof (channel_pub_key));
+ msg->fragment_id = GNUNET_htonll (INT64_MAX - 4);
+ msg->fragment_offset = GNUNET_htonll (1024);
+
+ op = GNUNET_PSYCSTORE_fragment_store (h, &channel_pub_key, msg, fcls.flags[1],
+ &fragment_store_result, GNUNET_NO);
+
+ fcls.flags[2] = GNUNET_PSYCSTORE_MESSAGE_STATE_HASH;
+ fcls.msg[2] = msg = GNUNET_malloc (sizeof (*msg) + sizeof (channel_pub_key));
+ GNUNET_memcpy (msg, fcls.msg[1], sizeof (*msg) + sizeof (channel_pub_key));
+ msg->fragment_id = GNUNET_htonll (INT64_MAX);
+ msg->fragment_offset = GNUNET_htonll (16384);
+
+ op = GNUNET_PSYCSTORE_fragment_store (h, &channel_pub_key, msg, fcls.flags[2],
+ &fragment_store_result, (void *) GNUNET_YES);
+}
+
+
+static void
+membership_test_result (void *cls, int64_t result,
+ const char *err_msg, uint16_t err_msg_size)
+{
+ op = NULL;
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "membership_test:\t%d\n", result);
+ GNUNET_assert (GNUNET_OK == result);
+
+ fragment_store ();
+}
+
+
+static void
+membership_store_result (void *cls, int64_t result,
+ const char *err_msg, uint16_t err_msg_size)
+{
+ op = NULL;
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "membership_store:\t%d\n", result);
+ GNUNET_assert (GNUNET_OK == result);
+
+ op = GNUNET_PSYCSTORE_membership_test (h, &channel_pub_key, &slave_pub_key,
+ INT64_MAX - 10, 2,
+ &membership_test_result, NULL);
+}
+
+