static void
run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TESTING_Peer *peer)
{
struct CpsRunContext *crc;
static struct GNUNET_HashCode zkey;
datastore = GNUNET_DATASTORE_connect (cfg);
start_time = GNUNET_TIME_absolute_get ();
crc = GNUNET_malloc (sizeof (struct CpsRunContext));
crc->cfg = cfg;
crc->phase = RP_PUT;
if (NULL ==
GNUNET_DATASTORE_put (datastore, 0, &zkey, 4, "TEST",
GNUNET_BLOCK_TYPE_TEST, 0, 0, 0,
GNUNET_TIME_relative_to_absolute
(GNUNET_TIME_UNIT_SECONDS), 0, 1,
GNUNET_TIME_UNIT_MINUTES, &run_tests, crc))
{
FPRINTF (stderr, "%s", "Test 'put' operation failed.\n");
ok = 1;
GNUNET_free (crc);
}
}
/**
* If necessary, connect to the datastore and remove the KBlocks.
*
* @param uc context for the unindex operation.
*/
void
GNUNET_FS_unindex_do_remove_kblocks_ (struct GNUNET_FS_UnindexContext *uc)
{
const char *keyword;
const struct GNUNET_CRYPTO_EcdsaPrivateKey *anon;
struct GNUNET_CRYPTO_EcdsaPublicKey anon_pub;
struct GNUNET_CRYPTO_EcdsaPublicKey dpub;
if (NULL == uc->dsh)
uc->dsh = GNUNET_DATASTORE_connect (uc->h->cfg);
if (NULL == uc->dsh)
{
uc->state = UNINDEX_STATE_ERROR;
uc->emsg = GNUNET_strdup (_("Failed to connect to `datastore' service."));
GNUNET_FS_unindex_sync_ (uc);
signal_unindex_error (uc);
return;
}
if ( (NULL == uc->ksk_uri) ||
(uc->ksk_offset >= uc->ksk_uri->data.ksk.keywordCount) )
{
unindex_finish (uc);
return;
}
anon = GNUNET_CRYPTO_ecdsa_key_get_anonymous ();
GNUNET_CRYPTO_ecdsa_key_get_public (anon,
&anon_pub);
keyword = &uc->ksk_uri->data.ksk.keywords[uc->ksk_offset][1];
GNUNET_CRYPTO_ecdsa_public_key_derive (&anon_pub,
keyword,
"fs-ublock",
&dpub);
GNUNET_CRYPTO_hash (&dpub,
sizeof (dpub),
&uc->uquery);
uc->dqe = GNUNET_DATASTORE_get_key (uc->dsh,
uc->roff++,
&uc->uquery,
GNUNET_BLOCK_TYPE_FS_UBLOCK,
0 /* priority */,
1 /* queue size */,
GNUNET_TIME_UNIT_FOREVER_REL,
&process_kblock_for_unindex,
uc);
}
/**
* Connect to the datastore and remove the blocks.
*
* @param uc context for the unindex operation.
*/
void
GNUNET_FS_unindex_do_remove_ (struct GNUNET_FS_UnindexContext *uc)
{
if (NULL == uc->dsh)
uc->dsh = GNUNET_DATASTORE_connect (uc->h->cfg);
if (NULL == uc->dsh)
{
uc->state = UNINDEX_STATE_ERROR;
uc->emsg = GNUNET_strdup (_("Failed to connect to `datastore' service."));
GNUNET_FS_unindex_sync_ (uc);
signal_unindex_error (uc);
return;
}
uc->fh =
GNUNET_DISK_file_open (uc->filename, GNUNET_DISK_OPEN_READ,
GNUNET_DISK_PERM_NONE);
if (NULL == uc->fh)
{
GNUNET_DATASTORE_disconnect (uc->dsh, GNUNET_NO);
uc->dsh = NULL;
uc->state = UNINDEX_STATE_ERROR;
uc->emsg = GNUNET_strdup (_("Failed to open file for unindexing."));
GNUNET_FS_unindex_sync_ (uc);
signal_unindex_error (uc);
return;
}
uc->tc =
GNUNET_FS_tree_encoder_create (uc->h,
uc->file_size,
uc,
&unindex_reader,
&unindex_process,
&unindex_progress,
&unindex_extract_keywords);
GNUNET_FS_tree_encoder_next (uc->tc);
}
/**
* Publish a CHK under various keywords on GNUnet.
*
* @param h handle to the file sharing subsystem
* @param ksk_uri keywords to use
* @param meta metadata to use
* @param uri URI to refer to in the KBlock
* @param bo per-block options
* @param options publication options
* @param cont continuation
* @param cont_cls closure for cont
* @return NULL on error ('cont' will still be called)
*/
struct GNUNET_FS_PublishKskContext *
GNUNET_FS_publish_ksk (struct GNUNET_FS_Handle *h,
const struct GNUNET_FS_Uri *ksk_uri,
const struct GNUNET_CONTAINER_MetaData *meta,
const struct GNUNET_FS_Uri *uri,
const struct GNUNET_FS_BlockOptions *bo,
enum GNUNET_FS_PublishOptions options,
GNUNET_FS_PublishContinuation cont, void *cont_cls)
{
struct GNUNET_FS_PublishKskContext *pkc;
char *uris;
size_t size;
char *kbe;
char *sptr;
GNUNET_assert (NULL != uri);
pkc = GNUNET_malloc (sizeof (struct GNUNET_FS_PublishKskContext));
pkc->h = h;
pkc->bo = *bo;
pkc->cont = cont;
pkc->cont_cls = cont_cls;
if (0 == (options & GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY))
{
pkc->dsh = GNUNET_DATASTORE_connect (h->cfg);
if (NULL == pkc->dsh)
{
cont (cont_cls, NULL, _("Could not connect to datastore."));
GNUNET_free (pkc);
return NULL;
}
}
if (meta == NULL)
pkc->mdsize = 0;
else
pkc->mdsize = GNUNET_CONTAINER_meta_data_get_serialized_size (meta);
GNUNET_assert (pkc->mdsize >= 0);
uris = GNUNET_FS_uri_to_string (uri);
pkc->slen = strlen (uris) + 1;
size = pkc->mdsize + sizeof (struct KBlock) + pkc->slen;
if (size > MAX_KBLOCK_SIZE)
{
size = MAX_KBLOCK_SIZE;
pkc->mdsize = size - sizeof (struct KBlock) - pkc->slen;
}
pkc->kb = GNUNET_malloc (size);
kbe = (char *) &pkc->kb[1];
memcpy (kbe, uris, pkc->slen);
GNUNET_free (uris);
sptr = &kbe[pkc->slen];
if (meta != NULL)
pkc->mdsize =
GNUNET_CONTAINER_meta_data_serialize (meta, &sptr, pkc->mdsize,
GNUNET_CONTAINER_META_DATA_SERIALIZE_PART);
if (-1 == pkc->mdsize)
{
GNUNET_break (0);
GNUNET_free (pkc->kb);
if (pkc->dsh != NULL)
{
GNUNET_DATASTORE_disconnect (pkc->dsh, GNUNET_NO);
pkc->dsh = NULL;
}
GNUNET_free (pkc);
cont (cont_cls, NULL, _("Internal error."));
return NULL;
}
size = sizeof (struct KBlock) + pkc->slen + pkc->mdsize;
pkc->cpy = GNUNET_malloc (size);
pkc->cpy->purpose.size =
htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) +
pkc->mdsize + pkc->slen);
pkc->cpy->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_FS_KBLOCK);
pkc->ksk_uri = GNUNET_FS_uri_dup (ksk_uri);
pkc->ksk_task = GNUNET_SCHEDULER_add_now (&publish_ksk_cont, pkc);
return pkc;
}
