GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
- by the Free Software Foundation; either version 2, or (at your
+ by the Free Software Foundation; either version 3, or (at your
option) any later version.
GNUnet is distributed in the hope that it will be useful, but
* GNUNET_NO to delete the item and continue (if supported)
*/
static int
-expired_processor (void *cls, const GNUNET_HashCode * key, uint32_t size,
+expired_processor (void *cls, const struct GNUNET_HashCode * key, uint32_t size,
const void *data, enum GNUNET_BLOCK_Type type,
uint32_t priority, uint32_t anonymity,
struct GNUNET_TIME_Absolute expiration, uint64_t uid)
return GNUNET_SYSERR;
}
now = GNUNET_TIME_absolute_get ();
- if (expiration.abs_value > now.abs_value)
+ if (expiration.abs_value_us > now.abs_value_us)
{
/* finished processing */
expired_kill_task =
&delete_expired, NULL);
return GNUNET_SYSERR;
}
-#if DEBUG_DATASTORE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Deleting content `%s' of type %u that expired %llu ms ago\n",
+ "Deleting content `%s' of type %u that expired %s ago\n",
GNUNET_h2s (key), type,
- (unsigned long long) (now.abs_value - expiration.abs_value));
-#endif
+ GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_difference (expiration,
+ now),
+ GNUNET_YES));
min_expiration = now;
GNUNET_STATISTICS_update (stats, gettext_noop ("# bytes expired"), size,
GNUNET_YES);
* GNUNET_NO to delete the item and continue (if supported)
*/
static int
-quota_processor (void *cls, const GNUNET_HashCode * key, uint32_t size,
+quota_processor (void *cls, const struct GNUNET_HashCode * key, uint32_t size,
const void *data, enum GNUNET_BLOCK_Type type,
uint32_t priority, uint32_t anonymity,
struct GNUNET_TIME_Absolute expiration, uint64_t uid)
if (NULL == key)
return GNUNET_SYSERR;
-#if DEBUG_DATASTORE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Deleting %llu bytes of low-priority (%u) content `%s' of type %u at %llu ms prior to expiration (still trying to free another %llu bytes)\n",
+ "Deleting %llu bytes of low-priority (%u) content `%s' of type %u at %s prior to expiration (still trying to free another %llu bytes)\n",
(unsigned long long) (size + GNUNET_DATASTORE_ENTRY_OVERHEAD),
(unsigned int) priority,
- GNUNET_h2s (key), type,
- (unsigned long long) GNUNET_TIME_absolute_get_remaining (expiration).rel_value,
+ GNUNET_h2s (key), type,
+ GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_remaining (expiration),
+ GNUNET_YES),
*need);
-#endif
if (size + GNUNET_DATASTORE_ENTRY_OVERHEAD > *need)
*need = 0;
else
{
unsigned long long last;
-#if DEBUG_DATASTORE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Asked to free up %llu bytes of cache space\n", need);
-#endif
last = 0;
while ((need > 0) && (last != need))
{
if (GNUNET_YES == cleaning_done)
{
-#if DEBUG_DATASTORE
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "Shutdown in progress, aborting transmission.\n");
-#endif
+ _("Shutdown in progress, aborting transmission.\n"));
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
GNUNET_free (msg);
return;
struct StatusMessage *sm;
size_t slen;
-#if DEBUG_DATASTORE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Transmitting `%s' message with value %d and message `%s'\n",
"STATUS", code, msg != NULL ? msg : "(none)");
-#endif
slen = (msg == NULL) ? 0 : strlen (msg) + 1;
sm = GNUNET_malloc (sizeof (struct StatusMessage) + slen);
sm->header.size = htons (sizeof (struct StatusMessage) + slen);
* GNUNET_NO to delete the item and continue (if supported)
*/
static int
-transmit_item (void *cls, const GNUNET_HashCode * key, uint32_t size,
+transmit_item (void *cls, const struct GNUNET_HashCode * key, uint32_t size,
const void *data, enum GNUNET_BLOCK_Type type, uint32_t priority,
uint32_t anonymity, struct GNUNET_TIME_Absolute expiration,
uint64_t uid)
if (key == NULL)
{
/* transmit 'DATA_END' */
-#if DEBUG_DATASTORE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Transmitting `%s' message\n",
"DATA_END");
-#endif
end = GNUNET_malloc (sizeof (struct GNUNET_MessageHeader));
end->size = htons (sizeof (struct GNUNET_MessageHeader));
end->type = htons (GNUNET_MESSAGE_TYPE_DATASTORE_DATA_END);
dm->uid = GNUNET_htonll (uid);
dm->key = *key;
memcpy (&dm[1], data, size);
-#if DEBUG_DATASTORE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Transmitting `%s' message for `%s' of type %u with expiration %llu (now: %llu)\n",
+ "Transmitting `%s' message for `%s' of type %u with expiration %s (in: %s)\n",
"DATA", GNUNET_h2s (key), type,
- (unsigned long long) expiration.abs_value,
- (unsigned long long) GNUNET_TIME_absolute_get ().abs_value);
-#endif
+ GNUNET_STRINGS_absolute_time_to_string (expiration),
+ GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_remaining (expiration),
+ GNUNET_YES));
GNUNET_STATISTICS_update (stats, gettext_noop ("# results found"), 1,
GNUNET_NO);
transmit (client, &dm->header);
uint64_t amount;
uint32_t entries;
-#if DEBUG_DATASTORE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Processing `%s' request\n", "RESERVE");
-#endif
amount = GNUNET_ntohll (msg->amount);
entries = ntohl (msg->entries);
used = payload + reserved;
int rid = ntohl (msg->rid);
unsigned long long rem;
-#if DEBUG_DATASTORE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Processing `%s' request\n",
"RELEASE_RESERVE");
-#endif
next = reservations;
prev = NULL;
while (NULL != (pos = next))
reserved -= rem;
GNUNET_STATISTICS_set (stats, gettext_noop ("# reserved"), reserved,
GNUNET_NO);
-#if DEBUG_DATASTORE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Returning %llu remaining reserved bytes to storage pool\n",
rem);
-#endif
GNUNET_free (pos);
transmit_status (client, GNUNET_OK, NULL);
return;
GNUNET_STATISTICS_update (stats, gettext_noop ("# bytes stored"), size,
GNUNET_YES);
GNUNET_CONTAINER_bloomfilter_add (filter, &dm->key);
-#if DEBUG_DATASTORE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Successfully stored %u bytes of type %u under key `%s'\n",
size, ntohl (dm->type), GNUNET_h2s (&dm->key));
-#endif
}
transmit_status (client, ret, msg);
GNUNET_free_non_null (msg);
* GNUNET_NO to delete the item
*/
static int
-check_present (void *cls, const GNUNET_HashCode * key, uint32_t size,
+check_present (void *cls, const struct GNUNET_HashCode * key, uint32_t size,
const void *data, enum GNUNET_BLOCK_Type type, uint32_t priority,
uint32_t anonymity, struct GNUNET_TIME_Absolute expiration,
uint64_t uid)
(0 ==
memcmp (&dm[1], data, size))))
{
-#if DEBUG_MYSQL
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Result already present in datastore\n");
-#endif
/* FIXME: change API to allow increasing 'replication' counter */
if ((ntohl (dm->priority) > 0) ||
- (GNUNET_TIME_absolute_ntoh (dm->expiration).abs_value >
- expiration.abs_value))
+ (GNUNET_TIME_absolute_ntoh (dm->expiration).abs_value_us >
+ expiration.abs_value_us))
plugin->api->update (plugin->api->cls, uid,
(int32_t) ntohl (dm->priority),
GNUNET_TIME_absolute_ntoh (dm->expiration), NULL);
int rid;
struct ReservationList *pos;
struct PutContext *pc;
- GNUNET_HashCode vhash;
+ struct GNUNET_HashCode vhash;
uint32_t size;
if ((dm == NULL) || (ntohl (dm->type) == 0))
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
return;
}
-#if DEBUG_DATASTORE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Processing `%s' request for `%s' of type %u\n", "PUT",
GNUNET_h2s (&dm->key), ntohl (dm->type));
-#endif
rid = ntohl (dm->rid);
size = ntohl (dm->size);
if (rid > 0)
size = ntohs (message->size);
if ((size != sizeof (struct GetMessage)) &&
- (size != sizeof (struct GetMessage) - sizeof (GNUNET_HashCode)))
+ (size != sizeof (struct GetMessage) - sizeof (struct GNUNET_HashCode)))
{
GNUNET_break (0);
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
return;
}
msg = (const struct GetMessage *) message;
-#if DEBUG_DATASTORE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Processing `%s' request for `%s' of type %u\n", "GET",
GNUNET_h2s (&msg->key), ntohl (msg->type));
-#endif
GNUNET_STATISTICS_update (stats, gettext_noop ("# GET requests received"), 1,
GNUNET_NO);
GNUNET_SERVER_client_keep (client);
(GNUNET_YES != GNUNET_CONTAINER_bloomfilter_test (filter, &msg->key)))
{
/* don't bother database... */
-#if DEBUG_DATASTORE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Empty result set for `%s' request for `%s' (bloomfilter).\n",
"GET", GNUNET_h2s (&msg->key));
-#endif
GNUNET_STATISTICS_update (stats,
gettext_noop
("# requests filtered by bloomfilter"), 1,
1, GNUNET_NO);
msg = (const struct UpdateMessage *) message;
emsg = NULL;
-#if DEBUG_DATASTORE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Processing `%s' request for %llu\n",
"UPDATE", (unsigned long long) GNUNET_ntohll (msg->uid));
-#endif
ret =
plugin->api->update (plugin->api->cls, GNUNET_ntohll (msg->uid),
(int32_t) ntohl (msg->priority),
handle_get_replication (void *cls, struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
-#if DEBUG_DATASTORE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Processing `%s' request\n",
"GET_REPLICATION");
-#endif
GNUNET_STATISTICS_update (stats,
gettext_noop
("# GET REPLICATION requests received"), 1,
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
return;
}
-#if DEBUG_DATASTORE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Processing `%s' request\n",
"GET_ZERO_ANONYMITY");
-#endif
GNUNET_STATISTICS_update (stats,
gettext_noop
("# GET ZERO ANONYMITY requests received"), 1,
* in to be deleted (by returning GNUNET_NO).
*/
static int
-remove_callback (void *cls, const GNUNET_HashCode * key, uint32_t size,
+remove_callback (void *cls, const struct GNUNET_HashCode * key, uint32_t size,
const void *data, enum GNUNET_BLOCK_Type type,
uint32_t priority, uint32_t anonymity,
struct GNUNET_TIME_Absolute expiration, uint64_t uid)
if (key == NULL)
{
-#if DEBUG_DATASTORE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"No further matches for `%s' request.\n", "REMOVE");
-#endif
transmit_status (client, GNUNET_NO, _("Content not found"));
GNUNET_SERVER_client_drop (client);
return GNUNET_OK; /* last item */
}
-#if DEBUG_DATASTORE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Item %llu matches `%s' request for key `%s' and type %u.\n",
(unsigned long long) uid, "REMOVE", GNUNET_h2s (key), type);
-#endif
GNUNET_STATISTICS_update (stats,
gettext_noop ("# bytes removed (explicit request)"),
size, GNUNET_YES);
const struct GNUNET_MessageHeader *message)
{
const struct DataMessage *dm = check_data (message);
- GNUNET_HashCode vhash;
+ struct GNUNET_HashCode vhash;
if (dm == NULL)
{
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
return;
}
-#if DEBUG_DATASTORE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Processing `%s' request for `%s' of type %u\n", "REMOVE",
GNUNET_h2s (&dm->key), ntohl (dm->type));
-#endif
GNUNET_STATISTICS_update (stats, gettext_noop ("# REMOVE requests received"),
1, GNUNET_NO);
GNUNET_SERVER_client_keep (client);
handle_drop (void *cls, struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
-#if DEBUG_DATASTORE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Processing `%s' request\n", "DROP");
-#endif
do_drop = GNUNET_YES;
GNUNET_SERVER_receive_done (client, GNUNET_OK);
}
GNUNET_assert (stats_worked == GNUNET_NO);
stats_worked = GNUNET_YES;
payload += value;
-#if DEBUG_SQLITE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Notification from statistics about existing payload (%llu), new payload is %llu\n",
- abs_value, payload);
-#endif
+ value, payload);
return GNUNET_OK;
}
static void
unload_plugin (struct DatastorePlugin *plug)
{
-#if DEBUG_DATASTORE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Datastore service is unloading plugin...\n");
-#endif
GNUNET_break (NULL == GNUNET_PLUGIN_unload (plug->lib_name, plug->api));
GNUNET_free (plug->lib_name);
GNUNET_free (plug->short_name);
*/
static void
add_key_to_bloomfilter (void *cls,
- const GNUNET_HashCode *key,
+ const struct GNUNET_HashCode *key,
unsigned int count)
{
struct GNUNET_CONTAINER_BloomFilter *bf = cls;
sizeof (struct GNUNET_MessageHeader)},
{NULL, NULL, 0, 0}
};
- char *fn;
+ char *fn;
char *pfn;
unsigned int bf_size;
int refresh_bf;
cache_size = quota / 8; /* Or should we make this an option? */
GNUNET_STATISTICS_set (stats, gettext_noop ("# cache size"), cache_size,
GNUNET_NO);
- if (quota / (32 * 1024LL) > (1 << 31))
+ if (quota / (32 * 1024LL) > (1 << 31))
bf_size = (1 << 31); /* absolute limit: ~2 GB, beyond that BF just won't help anyway */
else
bf_size = quota / (32 * 1024LL); /* 8 bit per entry, 1 bit per 32 kb in DB */
pfn);
GNUNET_free (pfn);
pfn = NULL;
- filter = GNUNET_CONTAINER_bloomfilter_load (NULL, bf_size, 5); /* approx. 3% false positives at max use */
+ filter = GNUNET_CONTAINER_bloomfilter_init (NULL, bf_size, 5); /* approx. 3% false positives at max use */
}
}
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
_("Rebuilding bloomfilter. Please be patient.\n"));
if (NULL != plugin->api->get_keys)
- plugin->api->get_keys (plugin->api->cls, &add_key_to_bloomfilter, filter);
+ plugin->api->get_keys (plugin->api->cls, &add_key_to_bloomfilter, filter);
else
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Plugin does not support get_keys function. Please fix!\n"));
projects / oweals / gnunet.git / blobdiff