static int
test_nullstring_rw ()
{
char *msg;
char *readResultString = (char *) "not null";
struct GNUNET_BIO_WriteHandle *fileW;
struct GNUNET_BIO_ReadHandle *fileR;
char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
fileW = GNUNET_BIO_write_open (fileName);
GNUNET_assert (NULL != fileW);
GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, NULL));
GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
fileR = GNUNET_BIO_read_open (fileName);
GNUNET_assert (NULL != fileR);
GNUNET_assert (GNUNET_OK ==
GNUNET_BIO_read_string (fileR, "Read string error",
&readResultString, 200));
GNUNET_assert (NULL == readResultString);
GNUNET_BIO_read_close (fileR, &msg);
GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
GNUNET_free (fileName);
return 0;
}
static int
test_fakestring_rw ()
{
char *msg;
int32_t tmpInt = 2;
char *readResult;
struct GNUNET_BIO_WriteHandle *fileW;
struct GNUNET_BIO_ReadHandle *fileR;
char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
fileW = GNUNET_BIO_write_open (fileName);
GNUNET_assert (NULL != fileW);
GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
fileR = GNUNET_BIO_read_open (fileName);
GNUNET_assert (NULL != fileR);
GNUNET_assert (GNUNET_SYSERR ==
GNUNET_BIO_read_string (fileR, "Read string error",
&readResult, 200));
msg = NULL;
GNUNET_BIO_read_close (fileR, &msg);
GNUNET_free (msg);
GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
GNUNET_free (fileName);
return 0;
}
static int
test_fakebigmeta_rw ()
{
char *msg;
int32_t tmpInt = 1024 * 1024 * 10;
struct GNUNET_BIO_WriteHandle *fileW;
struct GNUNET_BIO_ReadHandle *fileR;
char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
struct GNUNET_CONTAINER_MetaData *metaDataR;
fileW = GNUNET_BIO_write_open (fileName);
GNUNET_assert (NULL != fileW);
GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt));
GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
fileR = GNUNET_BIO_read_open (fileName);
GNUNET_assert (NULL != fileR);
metaDataR = NULL;
GNUNET_assert (GNUNET_SYSERR ==
GNUNET_BIO_read_meta_data (fileR, "Read meta error",
&metaDataR));
msg = NULL;
GNUNET_BIO_read_close (fileR, &msg);
GNUNET_free (msg);
GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
GNUNET_assert (NULL == metaDataR);
GNUNET_free (fileName);
return 0;
}
static int
test_bigmeta_rw ()
{
char *msg;
static char meta[1024 * 1024 * 10];
struct GNUNET_BIO_WriteHandle *fileW;
struct GNUNET_BIO_ReadHandle *fileR;
char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
struct GNUNET_CONTAINER_MetaData *metaDataR;
memset (meta, 'b', sizeof (meta));
meta[sizeof (meta) - 1] = '\0';
fileW = GNUNET_BIO_write_open (fileName);
GNUNET_assert (NULL != fileW);
GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, sizeof (meta)));
GNUNET_assert (GNUNET_OK == GNUNET_BIO_write (fileW, meta, sizeof (meta)));
GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
fileR = GNUNET_BIO_read_open (fileName);
GNUNET_assert (NULL != fileR);
metaDataR = NULL;
GNUNET_assert (GNUNET_SYSERR ==
GNUNET_BIO_read_meta_data (fileR, "Read meta error",
&metaDataR));
msg = NULL;
GNUNET_BIO_read_close (fileR, &msg);
GNUNET_free (msg);
GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
GNUNET_assert (NULL == metaDataR);
GNUNET_free (fileName);
return 0;
}
static int
test_bigstring_rw ()
{
char *msg;
char *readResultString;
struct GNUNET_BIO_WriteHandle *fileW;
struct GNUNET_BIO_ReadHandle *fileR;
char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
fileW = GNUNET_BIO_write_open (fileName);
GNUNET_assert (NULL != fileW);
GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING));
GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
fileR = GNUNET_BIO_read_open (fileName);
GNUNET_assert (NULL != fileR);
readResultString = NULL;
GNUNET_assert (GNUNET_SYSERR ==
GNUNET_BIO_read_string (fileR, "Read string error",
&readResultString, 1));
GNUNET_assert (NULL == readResultString);
msg = NULL;
GNUNET_BIO_read_close (fileR, &msg);
GNUNET_free (msg);
GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
GNUNET_free (fileName);
return 0;
}
static int
init ()
{
#if LOG_BACKOFF
killLogFileName = GNUNET_DISK_mktemp ("exponential-backoff-waiting.log");
if (NULL == (killLogFilePtr = FOPEN (killLogFileName, "w")))
{
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "fopen",
killLogFileName);
GNUNET_free (killLogFileName);
return GNUNET_SYSERR;
}
#endif
return GNUNET_OK;
}
static void
run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *c,
struct GNUNET_TESTING_Peer *peer)
{
const char *keywords[] = {
"down_foo",
"down_bar",
};
char *buf;
struct GNUNET_CONTAINER_MetaData *meta;
struct GNUNET_FS_Uri *kuri;
struct GNUNET_FS_FileInformation *fi;
size_t i;
struct GNUNET_FS_BlockOptions bo;
cfg = c;
fn = GNUNET_DISK_mktemp ("gnunet-unindex-test-dst");
fs = GNUNET_FS_start (cfg, "test-fs-unindex-persistence", &progress_cb, NULL,
GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END);
GNUNET_assert (NULL != fs);
buf = GNUNET_malloc (FILESIZE);
for (i = 0; i < FILESIZE; i++)
buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
GNUNET_assert (FILESIZE ==
GNUNET_DISK_fn_write (fn, buf, FILESIZE,
GNUNET_DISK_PERM_USER_READ |
GNUNET_DISK_PERM_USER_WRITE));
GNUNET_free (buf);
meta = GNUNET_CONTAINER_meta_data_create ();
kuri = GNUNET_FS_uri_ksk_create_from_args (2, keywords);
bo.content_priority = 42;
bo.anonymity_level = 1;
bo.replication_level = 0;
bo.expiration_time = GNUNET_TIME_relative_to_absolute (LIFETIME);
fi = GNUNET_FS_file_information_create_from_file (fs, "publish-context", fn,
kuri, meta, GNUNET_YES,
&bo);
GNUNET_FS_uri_destroy (kuri);
GNUNET_CONTAINER_meta_data_destroy (meta);
GNUNET_assert (NULL != fi);
start = GNUNET_TIME_absolute_get ();
publish =
GNUNET_FS_publish_start (fs, fi, NULL, NULL, NULL,
GNUNET_FS_PUBLISH_OPTION_NONE);
GNUNET_assert (publish != NULL);
}
static int
test_normal_rw ()
{
char *msg;
int64_t testNum;
char *readResultString;
char *fileName = GNUNET_DISK_mktemp ("gnunet_bio");
struct GNUNET_BIO_WriteHandle *fileW;
struct GNUNET_BIO_ReadHandle *fileR;
struct GNUNET_CONTAINER_MetaData *metaDataW;
struct GNUNET_CONTAINER_MetaData *metaDataR;
metaDataW = GNUNET_CONTAINER_meta_data_create ();
metaDataR = NULL;
GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW);
fileW = GNUNET_BIO_write_open (fileName);
GNUNET_assert (NULL != fileW);
GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING));
GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW, metaDataW));
GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int64 (fileW, TESTNUMBER64));
GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW));
fileR = GNUNET_BIO_read_open (fileName);
GNUNET_assert (NULL != fileR);
readResultString = NULL;
GNUNET_assert (GNUNET_OK ==
GNUNET_BIO_read_string (fileR, "Read string error",
&readResultString, 200));
GNUNET_assert (NULL != readResultString);
GNUNET_assert (0 == strcmp (TESTSTRING, readResultString));
GNUNET_free (readResultString);
GNUNET_assert (GNUNET_OK ==
GNUNET_BIO_read_meta_data (fileR, "Read meta error",
&metaDataR));
GNUNET_assert (GNUNET_YES ==
GNUNET_CONTAINER_meta_data_test_equal (metaDataR, metaDataW));
GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_int64 (fileR, &testNum));
GNUNET_BIO_read_close (fileR, &msg);
GNUNET_CONTAINER_meta_data_destroy (metaDataW);
GNUNET_CONTAINER_meta_data_destroy (metaDataR);
GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName));
GNUNET_free (fileName);
return 0;
}
static int
init ()
{
struct GNUNET_CONFIGURATION_Handle *cfg;
char pwd[PATH_MAX];
char *binary;
cfg = GNUNET_CONFIGURATION_create ();
if (GNUNET_OK != GNUNET_CONFIGURATION_parse (cfg,
"test_arm_api_data.conf"))
return GNUNET_SYSERR;
if (NULL == getcwd (pwd, PATH_MAX))
return GNUNET_SYSERR;
GNUNET_assert (0 < GNUNET_asprintf (&binary,
"%s/%s",
pwd,
BINARY));
GNUNET_CONFIGURATION_set_value_string (cfg,
SERVICE,
"BINARY",
binary);
GNUNET_free (binary);
if (GNUNET_OK != GNUNET_CONFIGURATION_write (cfg,
CFGFILENAME))
{
GNUNET_CONFIGURATION_destroy (cfg);
return GNUNET_SYSERR;
}
GNUNET_CONFIGURATION_destroy (cfg);
#if LOG_BACKOFF
killLogFileName = GNUNET_DISK_mktemp ("exponential-backoff-waiting.log");
if (NULL == (killLogFilePtr = FOPEN (killLogFileName,
"w")))
{
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
"fopen",
killLogFileName);
GNUNET_free (killLogFileName);
return GNUNET_SYSERR;
}
#endif
return GNUNET_OK;
}
static void
run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TESTING_Peer *peer)
{
enum MHD_FLAG flags;
struct GNUNET_CRYPTO_EcdsaPrivateKey *host_key;
struct GNUNET_GNSRECORD_Data rd;
char *zone_keyfile;
namestore = GNUNET_NAMESTORE_connect (cfg);
GNUNET_assert (NULL != namestore);
flags = MHD_USE_DEBUG;
mhd = MHD_start_daemon (flags,
PORT,
NULL, NULL,
&mhd_ahc, NULL,
MHD_OPTION_END);
GNUNET_assert (NULL != mhd);
mhd_main ();
tmp_cfgfile = GNUNET_DISK_mktemp ("test_gns_proxy_tmp.conf");
if (NULL == tmp_cfgfile)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to create tmp cfg!\n");
do_shutdown ();
return;
}
if (GNUNET_OK != GNUNET_CONFIGURATION_write ((struct GNUNET_CONFIGURATION_Handle *)cfg,
tmp_cfgfile))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to write tmp cfg\n");
do_shutdown ();
return;
}
proxy_proc = GNUNET_OS_start_process (GNUNET_NO,
GNUNET_OS_INHERIT_STD_ALL,
NULL,
NULL,
NULL,
"gnunet-gns-proxy",
"gnunet-gns-proxy",
"-c", tmp_cfgfile, NULL);
if (NULL == proxy_proc)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Unable to start proxy\n");
do_shutdown ();
return;
}
if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns",
"ZONEKEY",
&zone_keyfile))
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to get key from cfg\n");
return;
}
host_key = GNUNET_CRYPTO_ecdsa_key_create_from_file (zone_keyfile);
rd.expiration_time = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
GNUNET_assert (GNUNET_OK == GNUNET_GNSRECORD_string_to_value (GNUNET_DNSPARSER_TYPE_A,
"127.0.0.1",
(void**)&rd.data,
&rd.data_size));
rd.record_type = GNUNET_DNSPARSER_TYPE_A;
GNUNET_NAMESTORE_record_create (namestore,
host_key,
"www",
&rd,
&commence_testing,
NULL);
GNUNET_free ((void**)rd.data);
GNUNET_free (zone_keyfile);
GNUNET_free (host_key);
}
static void
run (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *c)
{
const char *keywords[] = {
"down_foo",
"down_bar",
};
char *buf;
struct GNUNET_CONTAINER_MetaData *meta;
struct GNUNET_FS_Uri *kuri;
struct GNUNET_FS_FileInformation *fi1;
struct GNUNET_FS_FileInformation *fi2;
struct GNUNET_FS_FileInformation *fidir;
size_t i;
struct GNUNET_FS_BlockOptions bo;
cfg = c;
setup_peer (&p1, "test_fs_publish_data.conf");
fs = GNUNET_FS_start (cfg, "test-fs-publish-persistence", &progress_cb, NULL,
GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END);
GNUNET_assert (NULL != fs);
fn1 = GNUNET_DISK_mktemp ("gnunet-publish-test-dst");
buf = GNUNET_malloc (FILESIZE);
for (i = 0; i < FILESIZE; i++)
buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
GNUNET_assert (FILESIZE ==
GNUNET_DISK_fn_write (fn1, buf, FILESIZE,
GNUNET_DISK_PERM_USER_READ |
GNUNET_DISK_PERM_USER_WRITE));
GNUNET_free (buf);
fn2 = GNUNET_DISK_mktemp ("gnunet-publish-test-dst");
buf = GNUNET_malloc (FILESIZE);
for (i = 0; i < FILESIZE; i++)
buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
GNUNET_assert (FILESIZE ==
GNUNET_DISK_fn_write (fn2, buf, FILESIZE,
GNUNET_DISK_PERM_USER_READ |
GNUNET_DISK_PERM_USER_WRITE));
GNUNET_free (buf);
meta = GNUNET_CONTAINER_meta_data_create ();
kuri = GNUNET_FS_uri_ksk_create_from_args (2, keywords);
bo.content_priority = 42;
bo.anonymity_level = 1;
bo.replication_level = 0;
bo.expiration_time = GNUNET_TIME_relative_to_absolute (LIFETIME);
fi1 =
GNUNET_FS_file_information_create_from_file (fs, "publish-context1", fn1,
kuri, meta, GNUNET_YES, &bo);
GNUNET_assert (NULL != fi1);
bo.anonymity_level = 2;
fi2 =
GNUNET_FS_file_information_create_from_file (fs, "publish-context2", fn2,
kuri, meta, GNUNET_YES, &bo);
GNUNET_assert (NULL != fi2);
bo.anonymity_level = 3;
fidir =
GNUNET_FS_file_information_create_empty_directory (fs,
"publish-context-dir",
kuri, meta, &bo, NULL);
GNUNET_assert (GNUNET_OK == GNUNET_FS_file_information_add (fidir, fi1));
GNUNET_assert (GNUNET_OK == GNUNET_FS_file_information_add (fidir, fi2));
GNUNET_FS_uri_destroy (kuri);
GNUNET_CONTAINER_meta_data_destroy (meta);
GNUNET_assert (NULL != fidir);
start = GNUNET_TIME_absolute_get ();
GNUNET_FS_publish_start (fs, fidir, NULL, NULL, NULL,
GNUNET_FS_PUBLISH_OPTION_NONE);
GNUNET_assert (publish != NULL);
}
static void
run (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
const char *keywords[] = {
"down_foo",
"down_bar",
};
char *fn1;
char *fn2;
char *buf;
struct GNUNET_CONTAINER_MetaData *meta;
struct GNUNET_FS_Uri *kuri;
struct GNUNET_FS_FileInformation *fi1;
struct GNUNET_FS_FileInformation *fi2;
struct GNUNET_FS_FileInformation *fidir;
struct GNUNET_FS_Handle *fs;
size_t i;
struct GNUNET_FS_BlockOptions bo;
fs = GNUNET_FS_start (cfg, "test-fs-file-information", NULL, NULL,
GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
fn1 = GNUNET_DISK_mktemp ("gnunet-file_information-test-dst");
buf = GNUNET_malloc (FILESIZE);
for (i = 0; i < FILESIZE; i++)
buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
GNUNET_assert (FILESIZE ==
GNUNET_DISK_fn_write (fn1, buf, FILESIZE,
GNUNET_DISK_PERM_USER_READ |
GNUNET_DISK_PERM_USER_WRITE));
GNUNET_free (buf);
fn2 = GNUNET_DISK_mktemp ("gnunet-file_information-test-dst");
buf = GNUNET_malloc (FILESIZE);
for (i = 0; i < FILESIZE; i++)
buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
GNUNET_assert (FILESIZE ==
GNUNET_DISK_fn_write (fn2, buf, FILESIZE,
GNUNET_DISK_PERM_USER_READ |
GNUNET_DISK_PERM_USER_WRITE));
GNUNET_free (buf);
meta = GNUNET_CONTAINER_meta_data_create ();
kuri = GNUNET_FS_uri_ksk_create_from_args (2, keywords);
bo.content_priority = 42;
bo.anonymity_level = 1;
bo.replication_level = 0;
bo.expiration_time = GNUNET_TIME_relative_to_absolute (LIFETIME);
fi1 =
GNUNET_FS_file_information_create_from_file (fs,
"file_information-context1",
fn1, kuri, meta, GNUNET_YES,
&bo);
GNUNET_assert (fi1 != NULL);
fi2 =
GNUNET_FS_file_information_create_from_file (fs,
"file_information-context2",
fn2, kuri, meta, GNUNET_YES,
&bo);
GNUNET_assert (fi2 != NULL);
fidir =
GNUNET_FS_file_information_create_empty_directory (fs,
"file_information-context-dir",
kuri, meta, &bo, NULL);
GNUNET_assert (GNUNET_OK == GNUNET_FS_file_information_add (fidir, fi1));
GNUNET_assert (GNUNET_OK == GNUNET_FS_file_information_add (fidir, fi2));
GNUNET_FS_uri_destroy (kuri);
GNUNET_CONTAINER_meta_data_destroy (meta);
GNUNET_assert (NULL != fidir);
/* FIXME: test more of API! */
GNUNET_FS_file_information_destroy (fidir, &mycleaner, NULL);
GNUNET_DISK_directory_remove (fn1);
GNUNET_DISK_directory_remove (fn2);
GNUNET_free_non_null (fn1);
GNUNET_free_non_null (fn2);
GNUNET_FS_stop (fs);
}
/**
* Checking configuration diffs
*/
static int
checkDiffs (struct GNUNET_CONFIGURATION_Handle *cfgDefault, int option)
{
struct GNUNET_CONFIGURATION_Handle *cfg;
struct GNUNET_CONFIGURATION_Handle *cfgDiffs;
struct DiffsCBData cbData;
int ret;
char *diffsFileName;
initDiffsCBData (&cbData);
cfg = GNUNET_CONFIGURATION_create ();
/* load defaults */
GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (cfg, NULL));
/* Modify configuration and save it */
cfgDiffs = editConfiguration (cfg, option);
diffsFileName = GNUNET_DISK_mktemp ("gnunet-test-configurations-diffs.conf");
if (diffsFileName == NULL)
{
GNUNET_break (0);
GNUNET_CONFIGURATION_destroy (cfg);
GNUNET_CONFIGURATION_destroy (cfgDiffs);
return 1;
}
GNUNET_CONFIGURATION_write_diffs (cfgDefault, cfg, diffsFileName);
GNUNET_CONFIGURATION_destroy (cfg);
/* Compare the dumped configuration with modifications done */
cfg = GNUNET_CONFIGURATION_create ();
GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_parse (cfg, diffsFileName));
if (0 != remove (diffsFileName))
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "remove", diffsFileName);
cbData.callBackOption = COMPARE;
cbData.cfgDiffs = cfgDiffs;
GNUNET_CONFIGURATION_iterate (cfg, diffsCallBack, &cbData);
if (1 == (ret = cbData.status))
{
FPRINTF (stderr, "%s",
"Incorrect Configuration Diffs: Diffs may contain data not actually edited\n");
goto housekeeping;
}
cbData.cfgDiffs = cfg;
GNUNET_CONFIGURATION_iterate (cfgDiffs, diffsCallBack, &cbData);
if ((ret = cbData.status) == 1)
FPRINTF (stderr, "%s",
"Incorrect Configuration Diffs: Data may be missing in diffs\n");
housekeeping:
#if 0
cbData.section = NULL;
cbData.callBackOption = PRINT;
printf ("\nExpected Diffs:\n");
GNUNET_CONFIGURATION_iterate (cfgDiffs, diffsCallBack, &cbData);
cbData.section = NULL;
printf ("\nActual Diffs:\n");
GNUNET_CONFIGURATION_iterate (cfg, diffsCallBack, &cbData);
#endif
GNUNET_CONFIGURATION_destroy (cfg);
GNUNET_CONFIGURATION_destroy (cfgDiffs);
GNUNET_free (diffsFileName);
return ret;
}
/**
* Create a data cache.
*
* @param cfg configuration to use
* @param section section in the configuration that contains our options
* @return handle to use to access the service
*/
struct GNUNET_DATACACHE_Handle *
GNUNET_DATACACHE_create (const struct GNUNET_CONFIGURATION_Handle *cfg,
const char *section)
{
unsigned int bf_size;
unsigned long long quota;
struct GNUNET_DATACACHE_Handle *ret;
char *libname;
char *name;
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_size (cfg, section, "QUOTA", "a))
{
LOG (GNUNET_ERROR_TYPE_ERROR,
_("No `%s' specified for `%s' in configuration!\n"), "QUOTA", section);
return NULL;
}
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_string (cfg, section, "DATABASE", &name))
{
LOG (GNUNET_ERROR_TYPE_ERROR,
_("No `%s' specified for `%s' in configuration!\n"), "DATABASE",
section);
return NULL;
}
bf_size = quota / 32; /* 8 bit per entry, 1 bit per 32 kb in DB */
ret = GNUNET_malloc (sizeof (struct GNUNET_DATACACHE_Handle));
if (GNUNET_YES !=
GNUNET_CONFIGURATION_get_value_yesno (cfg, section, "DISABLE_BF"))
{
if (GNUNET_YES !=
GNUNET_CONFIGURATION_get_value_yesno (cfg, section, "DISABLE_BF_RC"))
{
ret->bloom_name = GNUNET_DISK_mktemp ("gnunet-datacachebloom");
}
if (NULL != ret->bloom_name)
{
ret->filter = GNUNET_CONTAINER_bloomfilter_load (ret->bloom_name, quota / 1024, /* 8 bit per entry in DB, expect 1k entries */
5);
}
if (NULL == ret->filter)
{
ret->filter = GNUNET_CONTAINER_bloomfilter_init (NULL, bf_size, 5); /* approx. 3% false positives at max use */
}
}
ret->stats = GNUNET_STATISTICS_create ("datacache", cfg);
ret->section = GNUNET_strdup (section);
ret->env.cfg = cfg;
ret->env.delete_notify = &env_delete_notify;
ret->env.section = ret->section;
ret->env.cls = ret;
ret->env.delete_notify = &env_delete_notify;
ret->env.quota = quota;
LOG (GNUNET_ERROR_TYPE_INFO, _("Loading `%s' datacache plugin\n"), name);
GNUNET_asprintf (&libname, "libgnunet_plugin_datacache_%s", name);
ret->short_name = name;
ret->lib_name = libname;
ret->api = GNUNET_PLUGIN_load (libname, &ret->env);
if (ret->api == NULL)
{
LOG (GNUNET_ERROR_TYPE_ERROR,
_("Failed to load datacache plugin for `%s'\n"), name);
GNUNET_DATACACHE_destroy (ret);
return NULL;
}
return ret;
}
