static void
testNamespace ()
{
struct GNUNET_CRYPTO_EcdsaPrivateKey *ns;
struct GNUNET_FS_BlockOptions bo;
struct GNUNET_CONTAINER_MetaData *meta;
struct GNUNET_FS_Uri *ksk_uri;
struct GNUNET_FS_Uri *sks_uri;
ns = GNUNET_CRYPTO_ecdsa_key_create ();
meta = GNUNET_CONTAINER_meta_data_create ();
ksk_uri = GNUNET_FS_uri_parse ("gnunet://fs/ksk/testnsa", NULL);
bo.content_priority = 1;
bo.anonymity_level = 1;
bo.replication_level = 0;
bo.expiration_time =
GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
sks_uri = GNUNET_FS_uri_sks_create (&nsid, "root");
GNUNET_FS_publish_ksk (fs,
ksk_uri, meta, sks_uri,
&bo, GNUNET_FS_PUBLISH_OPTION_NONE,
&adv_cont, NULL);
GNUNET_FS_uri_destroy (sks_uri);
kill_task =
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, &do_timeout,
NULL);
GNUNET_FS_uri_destroy (ksk_uri);
GNUNET_CONTAINER_meta_data_destroy (meta);
GNUNET_free (ns);
}
static void
sks_cont (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
{
struct GNUNET_CONTAINER_MetaData *meta;
struct GNUNET_FS_Uri *ksk_uri;
char *msg;
struct GNUNET_FS_BlockOptions bo;
if (NULL == uri)
{
fprintf (stderr, "Error publishing: %s\n", emsg);
err = 1;
GNUNET_FS_stop (fs);
return;
}
meta = GNUNET_CONTAINER_meta_data_create ();
msg = NULL;
ksk_uri = GNUNET_FS_uri_parse ("gnunet://fs/ksk/ns-search", &msg);
GNUNET_assert (NULL == msg);
ksk_expect_uri = GNUNET_FS_uri_dup (uri);
bo.content_priority = 1;
bo.anonymity_level = 1;
bo.replication_level = 0;
bo.expiration_time =
GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
GNUNET_FS_publish_ksk (fs, ksk_uri, meta, uri, &bo,
GNUNET_FS_PUBLISH_OPTION_NONE, &publish_cont, NULL);
GNUNET_FS_uri_destroy (ksk_uri);
GNUNET_CONTAINER_meta_data_destroy (meta);
}
static int
testKeyword ()
{
char *uri;
struct GNUNET_FS_Uri *ret;
char *emsg;
if (NULL != (ret = GNUNET_FS_uri_parse ("gnunet://fs/ksk/++", &emsg)))
{
GNUNET_FS_uri_destroy (ret);
GNUNET_assert (0);
}
GNUNET_free (emsg);
ret = GNUNET_FS_uri_parse ("gnunet://fs/ksk/foo+bar", &emsg);
if (NULL == ret)
{
GNUNET_free (emsg);
GNUNET_assert (0);
}
if (! GNUNET_FS_uri_test_ksk (ret))
{
GNUNET_FS_uri_destroy (ret);
GNUNET_assert (0);
}
if ((2 != ret->data.ksk.keywordCount) ||
(0 != strcmp (" foo", ret->data.ksk.keywords[0])) ||
(0 != strcmp (" bar", ret->data.ksk.keywords[1])))
{
GNUNET_FS_uri_destroy (ret);
GNUNET_assert (0);
}
uri = GNUNET_FS_uri_to_string (ret);
if (0 != strcmp (uri, "gnunet://fs/ksk/foo+bar"))
{
GNUNET_free (uri);
GNUNET_FS_uri_destroy (ret);
GNUNET_assert (0);
}
GNUNET_free (uri);
GNUNET_FS_uri_destroy (ret);
return 0;
}
static void
testNamespace ()
{
ns = GNUNET_CRYPTO_ecdsa_key_create ();
GNUNET_assert (NULL != ns);
bo.content_priority = 1;
bo.anonymity_level = 1;
bo.replication_level = 0;
bo.expiration_time =
GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
meta = GNUNET_CONTAINER_meta_data_create ();
uri_this =
GNUNET_FS_uri_parse
("gnunet://fs/chk/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820.RNVVVVOOLCLK065B5D04HTNVNSIB2AI022RG8200HSLK1CO1000ATQ98824DMA2032LIMG50CG0K057NVUVG200000H000004400000.42",
NULL);
uri_next =
GNUNET_FS_uri_parse
("gnunet://fs/chk/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820.RNVVVVOOLCLK065B5D04HTNVNSIB2AI022RG8200HSLK1CO1000ATQ98824DMA2032LIMG50CG0K057NVUVG200000H000004400000.43",
NULL);
GNUNET_FS_publish_sks (fs, ns, "this", "next", meta, uri_this, &bo,
GNUNET_FS_PUBLISH_OPTION_NONE, &sks_cont_this, NULL);
}
static void
publish_cont (void *cls, const struct GNUNET_FS_Uri *ksk_uri, const char *emsg)
{
char *msg;
struct GNUNET_FS_Uri *sks_uri;
char sbuf[1024];
char buf[1024];
char *ret;
if (NULL != emsg)
{
FPRINTF (stderr, "Error publishing: %s\n", emsg);
err = 1;
GNUNET_FS_stop (fs);
return;
}
ret = GNUNET_STRINGS_data_to_string (&nsid, sizeof (nsid), buf, sizeof (buf));
GNUNET_assert (NULL != ret);
ret[0] = '\0';
GNUNET_snprintf (sbuf, sizeof (sbuf), "gnunet://fs/sks/%s/this", buf);
sks_uri = GNUNET_FS_uri_parse (sbuf, &msg);
if (NULL == sks_uri)
{
FPRINTF (stderr, "failed to parse URI `%s': %s\n", sbuf, msg);
err = 1;
GNUNET_FS_stop (fs);
GNUNET_free_non_null (msg);
return;
}
ksk_search =
GNUNET_FS_search_start (fs, ksk_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE,
"ksk_search");
sks_search =
GNUNET_FS_search_start (fs, sks_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE,
"sks_search");
GNUNET_FS_uri_destroy (sks_uri);
}
/**
* Iterate over all entries in a directory. Note that directories
* are structured such that it is possible to iterate over the
* individual blocks as well as over the entire directory. Thus
* a client can call this function on the buffer in the
* GNUNET_FS_ProgressCallback. Also, directories can optionally
* include the contents of (small) files embedded in the directory
* itself; for those files, the processor may be given the
* contents of the file directly by this function.
* <p>
*
* Note that this function maybe called on parts of directories. Thus
* parser errors should not be reported _at all_ (with GNUNET_break).
* Still, if some entries can be recovered despite these parsing
* errors, the function should try to do this.
*
* @param size number of bytes in data
* @param data pointer to the beginning of the directory
* @param offset offset of data in the directory
* @param dep function to call on each entry
* @param dep_cls closure for dep
* @return GNUNET_OK if this could be a block in a directory,
* GNUNET_NO if this could be part of a directory (but not 100% OK)
* GNUNET_SYSERR if 'data' does not represent a directory
*/
int
GNUNET_FS_directory_list_contents (size_t size, const void *data,
uint64_t offset,
GNUNET_FS_DirectoryEntryProcessor dep,
void *dep_cls)
{
struct GetFullDataClosure full_data;
const char *cdata = data;
char *emsg;
uint64_t pos;
uint64_t align;
uint32_t mdSize;
uint64_t epos;
struct GNUNET_FS_Uri *uri;
struct GNUNET_CONTAINER_MetaData *md;
char *filename;
if ((offset == 0) &&
((size < 8 + sizeof (uint32_t)) ||
(0 != memcmp (cdata, GNUNET_FS_DIRECTORY_MAGIC, 8))))
return GNUNET_SYSERR;
pos = offset;
if (offset == 0)
{
GNUNET_memcpy (&mdSize, &cdata[8], sizeof (uint32_t));
mdSize = ntohl (mdSize);
if (mdSize > size - 8 - sizeof (uint32_t))
{
/* invalid size */
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
_("MAGIC mismatch. This is not a GNUnet directory.\n"));
return GNUNET_SYSERR;
}
md = GNUNET_CONTAINER_meta_data_deserialize (&cdata[8 + sizeof (uint32_t)],
mdSize);
if (md == NULL)
{
GNUNET_break (0);
return GNUNET_SYSERR; /* malformed ! */
}
dep (dep_cls, NULL, NULL, md, 0, NULL);
GNUNET_CONTAINER_meta_data_destroy (md);
pos = 8 + sizeof (uint32_t) + mdSize;
}
while (pos < size)
{
/* find end of URI */
if (cdata[pos] == '\0')
{
/* URI is never empty, must be end of block,
* skip to next alignment */
align = ((pos / DBLOCK_SIZE) + 1) * DBLOCK_SIZE;
if (align == pos)
{
/* if we were already aligned, still skip a block! */
align += DBLOCK_SIZE;
}
pos = align;
if (pos >= size)
{
/* malformed - or partial download... */
break;
}
}
epos = pos;
while ((epos < size) && (cdata[epos] != '\0'))
epos++;
if (epos >= size)
return GNUNET_NO; /* malformed - or partial download */
uri = GNUNET_FS_uri_parse (&cdata[pos], &emsg);
pos = epos + 1;
if (uri == NULL)
{
GNUNET_free (emsg);
pos--; /* go back to '\0' to force going to next alignment */
continue;
}
if (GNUNET_FS_uri_test_ksk (uri))
{
GNUNET_FS_uri_destroy (uri);
GNUNET_break (0);
return GNUNET_NO; /* illegal in directory! */
}
GNUNET_memcpy (&mdSize, &cdata[pos], sizeof (uint32_t));
mdSize = ntohl (mdSize);
pos += sizeof (uint32_t);
if (pos + mdSize > size)
{
GNUNET_FS_uri_destroy (uri);
return GNUNET_NO; /* malformed - or partial download */
}
md = GNUNET_CONTAINER_meta_data_deserialize (&cdata[pos], mdSize);
if (md == NULL)
{
GNUNET_FS_uri_destroy (uri);
GNUNET_break (0);
return GNUNET_NO; /* malformed ! */
}
pos += mdSize;
filename =
GNUNET_CONTAINER_meta_data_get_by_type (md,
EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
full_data.size = 0;
full_data.data = NULL;
GNUNET_CONTAINER_meta_data_iterate (md, &find_full_data, &full_data);
if (dep != NULL)
{
dep (dep_cls, filename, uri, md, full_data.size, full_data.data);
}
GNUNET_free_non_null (full_data.data);
GNUNET_free_non_null (filename);
GNUNET_CONTAINER_meta_data_destroy (md);
GNUNET_FS_uri_destroy (uri);
}
return GNUNET_OK;
}
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;
}
static int
testFile (int i)
{
char *uri;
struct GNUNET_FS_Uri *ret;
char *emsg;
if (NULL !=
(ret =
GNUNET_FS_uri_parse
("gnunet://fs/chk/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820.RNVVVVOOLCLK065B5D04HTNVNSIB2AI022RG8200HSLK1CO1000ATQ98824DMA2032LIMG50CG0K057NVUVG200000H00000440000.42",
&emsg)))
{
GNUNET_FS_uri_destroy (ret);
GNUNET_assert (0);
}
GNUNET_free (emsg);
if (NULL !=
(ret =
GNUNET_FS_uri_parse
("gnunet://fs/chk/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820.RNVVVVOOLCLK065B5D04HTNVNSIB2AI022RG8200HSLK1CO1000ATQ98824DMA2032LIMG50CG0K057NVUVG200000H000004400000",
&emsg)))
{
GNUNET_FS_uri_destroy (ret);
GNUNET_assert (0);
}
GNUNET_free (emsg);
if (NULL !=
(ret =
GNUNET_FS_uri_parse
("gnunet://fs/chk/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820.RNVVVVOOLCLK065B5D04HTNVNSIB2AI022RG8200HSLK1CO1000ATQ98824DMA2032LIMG50CG0K057NVUVG200000H000004400000.FGH",
&emsg)))
{
GNUNET_FS_uri_destroy (ret);
GNUNET_assert (0);
}
GNUNET_free (emsg);
ret =
GNUNET_FS_uri_parse
("gnunet://fs/chk/4QZP479A9SKGFNMQ2ZBCYE71YV2QMTVGWTVPB6A10ASVCKXDHB05DKPSC7ZF6E9P9W1VE47394EQY7NXA47Q6R35M7P1MJPGP59D1Z8.D54QD1K5XCG5878T6YZ19AM60MQ6FC0YNVK7QY08KK0KM0FJJ3KQWYG112FN5T07KN7J0X35DF6WVBT9B8ZMZ3X2BXJ22X3KFQ6MV2G.42",
&emsg);
if (ret == NULL)
{
GNUNET_free (emsg);
GNUNET_assert (0);
}
if (GNUNET_FS_uri_test_ksk (ret))
{
GNUNET_FS_uri_destroy (ret);
GNUNET_assert (0);
}
if (GNUNET_FS_uri_test_sks (ret))
{
GNUNET_FS_uri_destroy (ret);
GNUNET_assert (0);
}
if (GNUNET_ntohll (ret->data.chk.file_length) != 42)
{
GNUNET_FS_uri_destroy (ret);
GNUNET_assert (0);
}
uri = GNUNET_FS_uri_to_string (ret);
if (0 !=
strcmp (uri,
"gnunet://fs/chk/4QZP479A9SKGFNMQ2ZBCYE71YV2QMTVGWTVPB6A10ASVCKXDHB05DKPSC7ZF6E9P9W1VE47394EQY7NXA47Q6R35M7P1MJPGP59D1Z8.D54QD1K5XCG5878T6YZ19AM60MQ6FC0YNVK7QY08KK0KM0FJJ3KQWYG112FN5T07KN7J0X35DF6WVBT9B8ZMZ3X2BXJ22X3KFQ6MV2G.42"))
{
GNUNET_free (uri);
GNUNET_FS_uri_destroy (ret);
GNUNET_assert (0);
}
GNUNET_free (uri);
GNUNET_FS_uri_destroy (ret);
return 0;
}
static int
testNamespace (int i)
{
char *uri;
struct GNUNET_FS_Uri *ret;
char *emsg;
struct GNUNET_CRYPTO_EcdsaPrivateKey *ph;
struct GNUNET_CRYPTO_EcdsaPublicKey id;
char buf[1024];
char ubuf[1024];
char *sret;
if (NULL !=
(ret =
GNUNET_FS_uri_parse ("gnunet://fs/sks/D1KJS9H2A82Q65VKQ0ML3RFU6U1D3VUK",
&emsg)))
{
GNUNET_FS_uri_destroy (ret);
GNUNET_assert (0);
}
GNUNET_free (emsg);
if (NULL !=
(ret =
GNUNET_FS_uri_parse
("gnunet://fs/sks/XQHH4R288W26EBV369F6RCE0PJVJTX2Y74Q2FJPMPGA31HJX2JG/this", &emsg)))
{
GNUNET_FS_uri_destroy (ret);
GNUNET_assert (0);
}
GNUNET_free (emsg);
if (NULL != (ret = GNUNET_FS_uri_parse ("gnunet://fs/sks/test", &emsg)))
{
GNUNET_FS_uri_destroy (ret);
GNUNET_assert (0);
}
GNUNET_free (emsg);
ph = GNUNET_CRYPTO_ecdsa_key_create ();
GNUNET_CRYPTO_ecdsa_key_get_public (ph, &id);
sret = GNUNET_STRINGS_data_to_string (&id, sizeof (id),
ubuf, sizeof (ubuf) - 1);
GNUNET_assert (NULL != sret);
sret[0] = '\0';
GNUNET_snprintf (buf, sizeof (buf),
"gnunet://fs/sks/%s/test",
ubuf);
ret = GNUNET_FS_uri_parse (buf, &emsg);
if (NULL == ret)
{
GNUNET_free (emsg);
GNUNET_assert (0);
}
if (GNUNET_FS_uri_test_ksk (ret))
{
GNUNET_FS_uri_destroy (ret);
GNUNET_assert (0);
}
if (!GNUNET_FS_uri_test_sks (ret))
{
GNUNET_FS_uri_destroy (ret);
GNUNET_assert (0);
}
uri = GNUNET_FS_uri_to_string (ret);
if (0 !=
strcmp (uri,
buf))
{
GNUNET_FS_uri_destroy (ret);
GNUNET_free (uri);
GNUNET_assert (0);
}
GNUNET_free (uri);
GNUNET_FS_uri_destroy (ret);
return 0;
}
static int
testDirectory (unsigned int i)
{
struct GNUNET_FS_DirectoryBuilder *db;
char *data;
size_t dlen;
struct GNUNET_FS_Uri **uris;
struct GNUNET_CONTAINER_MetaData **mds;
struct GNUNET_CONTAINER_MetaData *meta;
struct PCLS cls;
char *emsg;
int p;
int q;
char uri[512];
char txt[128];
int ret = 0;
struct GNUNET_TIME_Absolute start;
const char *s;
cls.max = i;
uris = GNUNET_malloc (sizeof (struct GNUNET_FS_Uri *) * i);
mds = GNUNET_malloc (sizeof (struct GNUNET_CONTAINER_MetaData *) * i);
meta = GNUNET_CONTAINER_meta_data_create ();
GNUNET_CONTAINER_meta_data_insert (meta, "<test>", EXTRACTOR_METATYPE_TITLE,
EXTRACTOR_METAFORMAT_UTF8, "text/plain",
"A title", strlen ("A title") + 1);
GNUNET_CONTAINER_meta_data_insert (meta, "<test>",
EXTRACTOR_METATYPE_AUTHOR_NAME,
EXTRACTOR_METAFORMAT_UTF8, "text/plain",
"An author", strlen ("An author") + 1);
for (p = 0; p < i; p++)
{
mds[p] = GNUNET_CONTAINER_meta_data_create ();
for (q = 0; q <= p; q++)
{
GNUNET_snprintf (txt, sizeof (txt), "%u -- %u\n", p, q);
GNUNET_CONTAINER_meta_data_insert (mds[p], "<test>",
#if HAVE_EXTRACTOR_H
q % EXTRACTOR_metatype_get_max (),
#else
q % 128,
#endif
EXTRACTOR_METAFORMAT_UTF8,
"text/plain", txt, strlen (txt) + 1);
}
GNUNET_snprintf (uri, sizeof (uri),
"gnunet://fs/chk/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820.RNVVVVOOLCLK065B5D04HTNVNSIB2AI022RG8200HSLK1CO1000ATQ98824DMA2032LIMG50CG0K057NVUVG200000H000004400000.%u",
p);
emsg = NULL;
uris[p] = GNUNET_FS_uri_parse (uri, &emsg);
if (uris[p] == NULL)
{
GNUNET_CONTAINER_meta_data_destroy (mds[p]);
while (--p > 0)
{
GNUNET_CONTAINER_meta_data_destroy (mds[p]);
GNUNET_FS_uri_destroy (uris[p]);
}
GNUNET_free (mds);
GNUNET_free (uris);
GNUNET_free (emsg);
GNUNET_CONTAINER_meta_data_destroy (meta);
ABORT (); /* error in testcase */
}
GNUNET_assert (emsg == NULL);
}
start = GNUNET_TIME_absolute_get ();
db = GNUNET_FS_directory_builder_create (meta);
for (p = 0; p < i; p++)
GNUNET_FS_directory_builder_add (db, uris[p], mds[p], NULL);
GNUNET_FS_directory_builder_finish (db, &dlen, (void **) &data);
s = GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration
(start),
GNUNET_YES);
FPRINTF (stdout,
"Creating directory with %u entires and total size %llu took %s\n",
i, (unsigned long long) dlen, s);
if (i < 100)
{
cls.pos = 0;
cls.uri = uris;
cls.md = mds;
GNUNET_FS_directory_list_contents (dlen, data, 0, &processor, &cls);
GNUNET_assert (cls.pos == i);
}
GNUNET_free (data);
GNUNET_CONTAINER_meta_data_destroy (meta);
for (p = 0; p < i; p++)
{
GNUNET_CONTAINER_meta_data_destroy (mds[p]);
GNUNET_FS_uri_destroy (uris[p]);
}
GNUNET_free (uris);
GNUNET_free (mds);
return ret;
}
/**
* Function called from datastore with result from us looking for
* a UBlock. There are four cases:
* 1) no result, means we move on to the next keyword
* 2) UID is the same as the first UID, means we move on to next keyword
* 3) UBlock for a different CHK, means we keep looking for more
* 4) UBlock is for our CHK, means we remove the block and then move
* on to the next keyword
*
* @param cls the 'struct GNUNET_FS_UnindexContext *'
* @param key key for the content
* @param size number of bytes in data
* @param data content stored
* @param type type of the content
* @param priority priority of the content
* @param anonymity anonymity-level for the content
* @param expiration expiration time for the content
* @param uid unique identifier for the datum;
* maybe 0 if no unique identifier is available
*/
static void
process_kblock_for_unindex (void *cls,
const struct GNUNET_HashCode *key,
size_t size,
const void *data,
enum GNUNET_BLOCK_Type type,
uint32_t priority,
uint32_t anonymity,
struct GNUNET_TIME_Absolute expiration,
uint64_t uid)
{
struct GNUNET_FS_UnindexContext *uc = cls;
const struct UBlock *ub;
struct GNUNET_FS_Uri *chk_uri;
struct GNUNET_HashCode query;
struct GNUNET_HashCode dh;
uc->dqe = NULL;
if (NULL == data)
{
/* no result */
GNUNET_CONTAINER_multihashmap_clear (uc->seen_dh);
uc->ksk_offset++;
GNUNET_FS_unindex_do_remove_kblocks_ (uc);
return;
}
GNUNET_CRYPTO_hash (data,
size,
&dh);
if (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_contains (uc->seen_dh,
&dh))
{
GNUNET_CONTAINER_multihashmap_clear (uc->seen_dh);
uc->ksk_offset++;
GNUNET_FS_unindex_do_remove_kblocks_ (uc);
return;
}
GNUNET_assert (GNUNET_OK ==
GNUNET_CONTAINER_multihashmap_put (uc->seen_dh,
&dh,
uc,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
GNUNET_assert (GNUNET_BLOCK_TYPE_FS_UBLOCK == type);
if (size < sizeof (struct UBlock))
{
GNUNET_break (0);
goto get_next;
}
ub = data;
GNUNET_CRYPTO_hash (&ub->verification_key,
sizeof (ub->verification_key),
&query);
if (0 != memcmp (&query,
key,
sizeof (struct GNUNET_HashCode)))
{
/* result does not match our keyword, skip */
goto get_next;
}
{
char pt[size - sizeof (struct UBlock)];
struct GNUNET_CRYPTO_EcdsaPublicKey anon_pub;
const char *keyword;
GNUNET_CRYPTO_ecdsa_key_get_public (GNUNET_CRYPTO_ecdsa_key_get_anonymous (),
&anon_pub);
keyword = &uc->ksk_uri->data.ksk.keywords[uc->ksk_offset][1];
GNUNET_FS_ublock_decrypt_ (&ub[1], size - sizeof (struct UBlock),
&anon_pub,
keyword,
pt);
if (NULL == memchr (&pt[1], 0, sizeof (pt) - 1))
{
GNUNET_break_op (0); /* malformed UBlock */
goto get_next;
}
chk_uri = GNUNET_FS_uri_parse (&pt[1], NULL);
if (NULL == chk_uri)
{
GNUNET_break_op (0); /* malformed UBlock */
goto get_next;
}
}
if (0 != memcmp (&uc->chk,
&chk_uri->data.chk.chk,
sizeof (struct ContentHashKey)))
{
/* different CHK, ignore */
GNUNET_FS_uri_destroy (chk_uri);
goto get_next;
}
GNUNET_FS_uri_destroy (chk_uri);
/* matches! */
uc->dqe = GNUNET_DATASTORE_remove (uc->dsh,
key,
size,
data,
0 /* priority */,
1 /* queue size */,
GNUNET_TIME_UNIT_FOREVER_REL,
&continue_after_remove,
uc);
return;
get_next:
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);
}
/**
* 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 c configuration
*/
static void
run (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *c)
{
struct GNUNET_FS_Uri *uri;
char *emsg;
enum GNUNET_FS_DownloadOptions options;
if (NULL == args[0])
{
FPRINTF (stderr, "%s", _("You need to specify a URI argument.\n"));
return;
}
uri = GNUNET_FS_uri_parse (args[0], &emsg);
if (NULL == uri)
{
FPRINTF (stderr, _("Failed to parse URI: %s\n"), emsg);
GNUNET_free (emsg);
ret = 1;
return;
}
if ((!GNUNET_FS_uri_test_chk (uri)) && (!GNUNET_FS_uri_test_loc (uri)))
{
FPRINTF (stderr, "%s", _("Only CHK or LOC URIs supported.\n"));
ret = 1;
GNUNET_FS_uri_destroy (uri);
return;
}
if (NULL == filename)
{
FPRINTF (stderr, "%s", _("Target filename must be specified.\n"));
ret = 1;
GNUNET_FS_uri_destroy (uri);
return;
}
cfg = c;
ctx =
GNUNET_FS_start (cfg, "gnunet-download", &progress_cb, NULL,
GNUNET_FS_FLAGS_NONE,
GNUNET_FS_OPTIONS_DOWNLOAD_PARALLELISM, parallelism,
GNUNET_FS_OPTIONS_REQUEST_PARALLELISM,
request_parallelism, GNUNET_FS_OPTIONS_END);
if (NULL == ctx)
{
FPRINTF (stderr, _("Could not initialize `%s' subsystem.\n"), "FS");
GNUNET_FS_uri_destroy (uri);
ret = 1;
return;
}
options = GNUNET_FS_DOWNLOAD_OPTION_NONE;
if (do_recursive)
options |= GNUNET_FS_DOWNLOAD_OPTION_RECURSIVE;
if (local_only)
options |= GNUNET_FS_DOWNLOAD_OPTION_LOOPBACK_ONLY;
dc = GNUNET_FS_download_start (ctx, uri, NULL, filename, NULL, 0,
GNUNET_FS_uri_chk_get_file_size (uri),
anonymity, options, NULL, NULL);
GNUNET_FS_uri_destroy (uri);
if (dc == NULL)
{
GNUNET_FS_stop (ctx);
ctx = NULL;
return;
}
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
NULL);
}
