GNUnet debian-0.24.3-29-g453fda2cf
 
Loading...
Searching...
No Matches
gnunet-service-datastore.c File Reference

Management for the datastore for files stored on a GNUnet node. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_statistics_service.h"
#include "gnunet_datastore_plugin.h"
#include "datastore.h"
Include dependency graph for gnunet-service-datastore.c:

Go to the source code of this file.

Data Structures

struct  DatastorePlugin
 Our datastore plugin. More...
 
struct  ReservationList
 Linked list of active reservations. More...
 

Macros

#define MAX_PENDING   1024
 How many messages do we queue at most per client?
 
#define MAX_BF_SIZE   ((uint32_t) (1LL << 31))
 Limit size of bloom filter to 2 GB.
 
#define MAX_EXPIRE_DELAY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
 How long are we at most keeping "expired" content past the expiration date in the database?
 
#define MIN_EXPIRE_DELAY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
 How fast are we allowed to query the database for deleting expired content? (1 item per second).
 
#define MAX_STAT_SYNC_LAG   50
 After how many payload-changing operations do we sync our statistics?
 

Functions

static void sync_stats ()
 Synchronize our utilization statistics with the statistics service.
 
static void delete_expired (void *cls)
 Task that is used to remove expired entries from the datastore.
 
static int 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, uint32_t replication, struct GNUNET_TIME_Absolute expiration, uint64_t uid)
 Iterate over the expired items stored in the datastore.
 
static int 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, uint32_t replication, struct GNUNET_TIME_Absolute expiration, uint64_t uid)
 An iterator over a set of items stored in the datastore that deletes until we're happy with respect to our quota.
 
static void manage_space (unsigned long long need)
 Manage available disk space by running tasks that will discard content if necessary.
 
static void transmit_status (struct GNUNET_SERVICE_Client *client, int code, const char *msg)
 Transmit a status code to the client.
 
static int 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, uint32_t replication, struct GNUNET_TIME_Absolute expiration, uint64_t uid)
 Function that will transmit the given datastore entry to the client.
 
static void handle_reserve (void *cls, const struct ReserveMessage *msg)
 Handle RESERVE-message.
 
static void handle_release_reserve (void *cls, const struct ReleaseReserveMessage *msg)
 Handle RELEASE_RESERVE-message.
 
static int check_data (const struct DataMessage *dm)
 Check that the given message is a valid data message.
 
static void put_continuation (void *cls, const struct GNUNET_HashCode *key, uint32_t size, int status, const char *msg)
 Put continuation.
 
static int check_put (void *cls, const struct DataMessage *dm)
 Verify PUT-message.
 
static void handle_put (void *cls, const struct DataMessage *dm)
 Handle PUT-message.
 
static void handle_get (void *cls, const struct GetMessage *msg)
 Handle GNUNET_MESSAGE_TYPE_DATASTORE_GET-message.
 
static void handle_get_key (void *cls, const struct GetKeyMessage *msg)
 Handle GNUNET_MESSAGE_TYPE_DATASTORE_GET_KEY-message.
 
static void handle_get_replication (void *cls, const struct GNUNET_MessageHeader *message)
 Handle GET_REPLICATION-message.
 
static void handle_get_zero_anonymity (void *cls, const struct GetZeroAnonymityMessage *msg)
 Handle GET_ZERO_ANONYMITY-message.
 
static void remove_continuation (void *cls, const struct GNUNET_HashCode *key, uint32_t size, int status, const char *msg)
 Remove continuation.
 
static int check_remove (void *cls, const struct DataMessage *dm)
 Verify REMOVE-message.
 
static void handle_remove (void *cls, const struct DataMessage *dm)
 Handle REMOVE-message.
 
static void handle_drop (void *cls, const struct GNUNET_MessageHeader *message)
 Handle DROP-message.
 
static void disk_utilization_change_cb (void *cls, int delta)
 Function called by plugins to notify us about a change in their disk utilization.
 
static int process_stat_in (void *cls, const char *subsystem, const char *name, uint64_t value, int is_persistent)
 Callback function to process statistic values.
 
static struct DatastorePluginload_plugin ()
 Load the datastore plugin.
 
static void unload_plugin (struct DatastorePlugin *plug)
 Function called when the service shuts down.
 
static void begin_service ()
 Initialization complete, start operating the service.
 
static void add_key_to_bloomfilter (void *cls, const struct GNUNET_HashCode *key, unsigned int count)
 Adds a given key to the bloomfilter in cls count times.
 
static void process_stat_done (void *cls, int success)
 We finished receiving the statistic.
 
static void stat_timeout (void *cls)
 Fetching stats took to long, run without.
 
static void cleaning_task (void *cls)
 Task run during shutdown.
 
static void * client_connect_cb (void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
 Add a client to our list of active clients.
 
static void client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *client, void *app_ctx)
 Called whenever a client is disconnected.
 
static void run (void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *serv)
 Process datastore requests.
 
 GNUNET_SERVICE_MAIN (GNUNET_OS_project_data_gnunet(), "datastore", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_fixed_size(reserve, GNUNET_MESSAGE_TYPE_DATASTORE_RESERVE, struct ReserveMessage, NULL), GNUNET_MQ_hd_fixed_size(release_reserve, GNUNET_MESSAGE_TYPE_DATASTORE_RELEASE_RESERVE, struct ReleaseReserveMessage, NULL), GNUNET_MQ_hd_var_size(put, GNUNET_MESSAGE_TYPE_DATASTORE_PUT, struct DataMessage, NULL), GNUNET_MQ_hd_fixed_size(get, GNUNET_MESSAGE_TYPE_DATASTORE_GET, struct GetMessage, NULL), GNUNET_MQ_hd_fixed_size(get_key, GNUNET_MESSAGE_TYPE_DATASTORE_GET_KEY, struct GetKeyMessage, NULL), GNUNET_MQ_hd_fixed_size(get_replication, GNUNET_MESSAGE_TYPE_DATASTORE_GET_REPLICATION, struct GNUNET_MessageHeader, NULL), GNUNET_MQ_hd_fixed_size(get_zero_anonymity, GNUNET_MESSAGE_TYPE_DATASTORE_GET_ZERO_ANONYMITY, struct GetZeroAnonymityMessage, NULL), GNUNET_MQ_hd_var_size(remove, GNUNET_MESSAGE_TYPE_DATASTORE_REMOVE, struct DataMessage, NULL), GNUNET_MQ_hd_fixed_size(drop, GNUNET_MESSAGE_TYPE_DATASTORE_DROP, struct GNUNET_MessageHeader, NULL), GNUNET_MQ_handler_end())
 Define "main" method using service macro.
 

Variables

static char * quota_stat_name
 Name under which we store current space consumption.
 
static struct GNUNET_SCHEDULER_Taskstat_timeout_task
 Task to timeout stat GET.
 
static struct DatastorePluginplugin
 Our datastore plugin (NULL if not available).
 
static struct ReservationListreservations
 Linked list of space reservations made by clients.
 
static struct GNUNET_CONTAINER_BloomFilterfilter
 Bloomfilter to quickly tell if we don't have the content.
 
static char * plugin_name
 Name of our plugin.
 
static const struct GNUNET_CONFIGURATION_Handlecfg
 Our configuration.
 
static struct GNUNET_STATISTICS_Handlestats
 Handle for reporting statistics.
 
static unsigned long long cache_size
 How much space are we using for the cache? (space available for insertions that will be instantly reclaimed by discarding less important content — or possibly whatever we just inserted into the "cache").
 
static unsigned long long reserved
 How much space have we currently reserved?
 
static unsigned long long payload
 How much data are we currently storing in the database?
 
static struct GNUNET_SCHEDULER_Taskexpired_kill_task
 Identity of the task that is used to delete expired content.
 
static struct GNUNET_TIME_Absolute min_expiration
 Minimum time that content should have to not be discarded instantly (time stamp of any content that we've been discarding recently to stay below the quota).
 
static unsigned long long quota
 How much space are we allowed to use?
 
static int do_drop
 Should the database be dropped on exit?
 
static int refresh_bf
 Should we refresh the BF when the DB is loaded?
 
static unsigned int last_sync
 Number of updates that were made to the payload value since we last synchronized it with the statistics service.
 
static int stats_worked
 Did we get an answer from statistics?
 
static int cleaning_done
 Have we already cleaned up the TCCs and are hence no longer willing (or able) to transmit anything to anyone?
 
static struct GNUNET_STATISTICS_GetHandlestat_get
 Handle for pending get request.
 
static struct GNUNET_SERVICE_Handleservice
 Handle to our server.
 

Detailed Description

Management for the datastore for files stored on a GNUnet node.

Author
Christian Grothoff

Definition in file gnunet-service-datastore.c.

Macro Definition Documentation

◆ MAX_PENDING

#define MAX_PENDING   1024

How many messages do we queue at most per client?

Definition at line 37 of file gnunet-service-datastore.c.

◆ MAX_BF_SIZE

#define MAX_BF_SIZE   ((uint32_t) (1LL << 31))

Limit size of bloom filter to 2 GB.

Definition at line 42 of file gnunet-service-datastore.c.

◆ MAX_EXPIRE_DELAY

#define MAX_EXPIRE_DELAY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)

How long are we at most keeping "expired" content past the expiration date in the database?

Definition at line 48 of file gnunet-service-datastore.c.

78{
84
88 char *short_name;
89
93 char *lib_name;
94
100};
101
102
106struct ReservationList
107{
111 struct ReservationList *next;
112
117
121 uint64_t amount;
122
126 uint64_t entries;
127
131 int32_t rid;
132};
133
134
138static struct DatastorePlugin *plugin;
139
143static struct ReservationList *reservations;
144
149
153static char *plugin_name;
154
158static const struct GNUNET_CONFIGURATION_Handle *cfg;
159
163static struct GNUNET_STATISTICS_Handle *stats;
164
171static unsigned long long cache_size;
172
176static unsigned long long reserved;
177
182static unsigned long long payload;
183
189
197
201static unsigned long long quota;
202
206static int do_drop;
207
211static int refresh_bf;
212
218static unsigned int last_sync;
219
223static int stats_worked;
224
225
230static void
231sync_stats ()
232{
235 "# utilization by current datastore",
236 payload,
237 GNUNET_NO);
238 last_sync = 0;
239}
240
241
246static int cleaning_done;
247
252
256static struct GNUNET_SERVICE_Handle *service;
257
266static void
267delete_expired (void *cls);
268
269
291static int
292expired_processor (void *cls,
293 const struct GNUNET_HashCode *key,
294 uint32_t size,
295 const void *data,
297 uint32_t priority,
298 uint32_t anonymity,
299 uint32_t replication,
301 uint64_t uid)
302{
303 struct GNUNET_TIME_Absolute now;
304
305 if (NULL == key)
306 {
311 NULL);
312 return GNUNET_SYSERR;
313 }
315 if (expiration.abs_value_us > now.abs_value_us)
316 {
317 /* finished processing */
322 NULL);
323 return GNUNET_SYSERR;
324 }
326 "Deleting content `%s' of type %u that expired %s ago\n",
327 GNUNET_h2s (key),
328 type,
331 GNUNET_YES));
332 min_expiration = now;
334 gettext_noop ("# bytes expired"),
335 size,
336 GNUNET_YES);
342 NULL);
343 return GNUNET_NO;
344}
345
346
355static void
356delete_expired (void *cls)
357{
358 expired_kill_task = NULL;
360}
361
362
382static int
383quota_processor (void *cls,
384 const struct GNUNET_HashCode *key,
385 uint32_t size,
386 const void *data,
388 uint32_t priority,
389 uint32_t anonymity,
390 uint32_t replication,
392 uint64_t uid)
393{
394 unsigned long long *need = cls;
395
396 if (NULL == key)
397 return GNUNET_SYSERR;
398 GNUNET_log (
400 "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",
401 (unsigned long long) (size + GNUNET_DATASTORE_ENTRY_OVERHEAD),
402 (unsigned int) priority,
403 GNUNET_h2s (key),
404 type,
406 expiration),
407 GNUNET_YES),
408 *need);
410 *need = 0;
411 else
413 if (priority > 0)
415 else
418 gettext_noop ("# bytes purged (low-priority)"),
419 size,
420 GNUNET_YES);
422 return GNUNET_NO;
423}
424
425
438static void
439manage_space (unsigned long long need)
440{
441 unsigned long long last;
442
444 "Asked to free up %llu bytes of cache space\n",
445 need);
446 last = 0;
447 while ((need > 0) && (last != need))
448 {
449 last = need;
451 }
452}
453
454
462static void
464 int code,
465 const char *msg)
466{
467 struct GNUNET_MQ_Envelope *env;
468 struct StatusMessage *sm;
469 size_t slen;
470
472 "Transmitting `%s' message with value %d and message `%s'\n",
473 "STATUS",
474 code,
475 msg != NULL ? msg : "(none)");
476 slen = (msg == NULL) ? 0 : strlen (msg) + 1;
478 sm->status = htonl (code);
480 GNUNET_memcpy (&sm[1], msg, slen);
482}
483
484
503static int
504transmit_item (void *cls,
505 const struct GNUNET_HashCode *key,
506 uint32_t size,
507 const void *data,
509 uint32_t priority,
510 uint32_t anonymity,
511 uint32_t replication,
513 uint64_t uid)
514{
515 struct GNUNET_SERVICE_Client *client = cls;
516 struct GNUNET_MQ_Envelope *env;
518 struct DataMessage *dm;
519
520 if (NULL == key)
521 {
522 /* transmit 'DATA_END' */
523 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Transmitting DATA_END message\n");
526 return GNUNET_OK;
527 }
530 dm->rid = htonl (0);
531 dm->size = htonl (size);
532 dm->type = htonl (type);
533 dm->priority = htonl (priority);
534 dm->anonymity = htonl (anonymity);
535 dm->replication = htonl (replication);
537 dm->uid = GNUNET_htonll (uid);
538 dm->key = *key;
539 GNUNET_memcpy (&dm[1], data, size);
540 GNUNET_log (
542 "Transmitting DATA message for `%s' of type %u with expiration %s (in: %s)\n",
543 GNUNET_h2s (key),
544 type,
547 expiration),
548 GNUNET_YES));
550 gettext_noop ("# results found"),
551 1,
552 GNUNET_NO);
554 return GNUNET_OK;
555}
556
557
564static void
565handle_reserve (void *cls, const struct ReserveMessage *msg)
566{
570 static int reservation_gen;
571 struct GNUNET_SERVICE_Client *client = cls;
572 struct ReservationList *e;
573 unsigned long long used;
574 unsigned long long req;
575 uint64_t amount;
576 uint32_t entries;
577
578 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Processing RESERVE request\n");
579 amount = GNUNET_ntohll (msg->amount);
580 entries = ntohl (msg->entries);
581 used = payload + reserved;
582 req =
583 amount + ((unsigned long long) GNUNET_DATASTORE_ENTRY_OVERHEAD) * entries;
584 if (used + req > quota)
585 {
586 if (quota < used)
587 used =
588 quota; /* cheat a bit for error message (to avoid negative numbers) */
589 GNUNET_log (
591 _ (
592 "Insufficient space (%llu bytes are available) to satisfy RESERVE request for %llu bytes\n"),
593 quota - used,
594 req);
595 if (cache_size < req)
596 {
597 /* TODO: document this in the FAQ; essentially, if this
598 * message happens, the insertion request could be blocked
599 * by less-important content from migration because it is
600 * larger than 1/8th of the overall available space, and
601 * we only reserve 1/8th for "fresh" insertions */
602 GNUNET_log (
604 _ (
605 "The requested amount (%llu bytes) is larger than the cache size (%llu bytes)\n"),
606 req,
607 cache_size);
609 0,
611 "Insufficient space to satisfy request and "
612 "requested amount is larger than cache size"));
613 }
614 else
615 {
617 0,
618 gettext_noop ("Insufficient space to satisfy request"));
619 }
621 return;
622 }
623 reserved += req;
625 gettext_noop ("# reserved"),
626 reserved,
627 GNUNET_NO);
628 e = GNUNET_new (struct ReservationList);
629 e->next = reservations;
630 reservations = e;
631 e->client = client;
632 e->amount = amount;
633 e->entries = entries;
634 e->rid = ++reservation_gen;
635 if (reservation_gen < 0)
636 reservation_gen = 0; /* wrap around */
637 transmit_status (client, e->rid, NULL);
639}
640
641
648static void
649handle_release_reserve (void *cls, const struct ReleaseReserveMessage *msg)
650{
651 struct GNUNET_SERVICE_Client *client = cls;
652 struct ReservationList *pos;
653 struct ReservationList *prev;
654 struct ReservationList *next;
655 int rid = ntohl (msg->rid);
656 unsigned long long rem;
657
658 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Processing RELEASE_RESERVE request\n");
660 prev = NULL;
661 while (NULL != (pos = next))
662 {
663 next = pos->next;
664 if (rid == pos->rid)
665 {
666 if (prev == NULL)
668 else
669 prev->next = next;
670 rem =
671 pos->amount
672 + ((unsigned long long) GNUNET_DATASTORE_ENTRY_OVERHEAD) * pos->entries;
673 GNUNET_assert (reserved >= rem);
674 reserved -= rem;
676 gettext_noop ("# reserved"),
677 reserved,
678 GNUNET_NO);
680 "Returning %llu remaining reserved bytes to storage pool\n",
681 rem);
682 GNUNET_free (pos);
685 return;
686 }
687 prev = pos;
688 }
689 GNUNET_break (0);
692 gettext_noop ("Could not find matching reservation"));
694}
695
696
703static int
704check_data (const struct DataMessage *dm)
705{
706 uint16_t size;
707 uint32_t dsize;
708
709 size = ntohs (dm->header.size);
710 dsize = ntohl (dm->size);
711 if (size != dsize + sizeof(struct DataMessage))
712 {
713 GNUNET_break (0);
714 return GNUNET_SYSERR;
715 }
716 return GNUNET_OK;
717}
718
719
730static void
731put_continuation (void *cls,
732 const struct GNUNET_HashCode *key,
733 uint32_t size,
734 int status,
735 const char *msg)
736{
737 struct GNUNET_SERVICE_Client *client = cls;
738
739 if (GNUNET_OK == status)
740 {
742 gettext_noop ("# bytes stored"),
743 size,
744 GNUNET_YES);
747 "Successfully stored %u bytes under key `%s'\n",
748 size,
749 GNUNET_h2s (key));
750 }
751 transmit_status (client,
753 msg);
755 {
757 _ ("Need %llu bytes more space (%llu allowed, using %llu)\n"),
758 (unsigned long long) size + GNUNET_DATASTORE_ENTRY_OVERHEAD,
759 (unsigned long long) (quota - reserved - cache_size),
760 (unsigned long long) payload);
762 }
763}
764
765
773static int
774check_put (void *cls, const struct DataMessage *dm)
775{
776 if (GNUNET_OK != check_data (dm))
777 {
778 GNUNET_break (0);
779 return GNUNET_SYSERR;
780 }
781 return GNUNET_OK;
782}
783
784
791static void
792handle_put (void *cls, const struct DataMessage *dm)
793{
794 struct GNUNET_SERVICE_Client *client = cls;
795 int rid;
796 struct ReservationList *pos;
797 uint32_t size;
798
800 "Processing PUT request for `%s' of type %u\n",
801 GNUNET_h2s (&dm->key),
802 (uint32_t) ntohl (dm->type));
803 rid = ntohl (dm->rid);
804 size = ntohl (dm->size);
805 if (rid > 0)
806 {
807 pos = reservations;
808 while ((NULL != pos) && (rid != pos->rid))
809 pos = pos->next;
810 GNUNET_break (pos != NULL);
811 if (NULL != pos)
812 {
813 GNUNET_break (pos->entries > 0);
814 GNUNET_break (pos->amount >= size);
815 pos->entries--;
816 pos->amount -= size;
819 gettext_noop ("# reserved"),
820 reserved,
821 GNUNET_NO);
822 }
823 }
824 {
825 bool absent =
827 plugin->api->put (plugin->api->cls,
828 &dm->key,
829 absent,
830 ntohl (dm->size),
831 &dm[1],
832 ntohl (dm->type),
833 ntohl (dm->priority),
834 ntohl (dm->anonymity),
835 ntohl (dm->replication),
838 client);
839 }
841}
842
843
850static void
851handle_get (void *cls, const struct GetMessage *msg)
852{
853 struct GNUNET_SERVICE_Client *client = cls;
854
856 "Processing GET request of type %u\n",
857 (uint32_t) ntohl (msg->type));
859 gettext_noop ("# GET requests received"),
860 1,
861 GNUNET_NO);
863 GNUNET_ntohll (msg->next_uid),
864 msg->random,
865 NULL,
866 ntohl (msg->type),
868 client);
870}
871
872
879static void
880handle_get_key (void *cls, const struct GetKeyMessage *msg)
881{
882 struct GNUNET_SERVICE_Client *client = cls;
883
885 "Processing GET request for `%s' of type %u\n",
886 GNUNET_h2s (&msg->key),
887 (uint32_t) ntohl (msg->type));
889 gettext_noop ("# GET KEY requests received"),
890 1,
891 GNUNET_NO);
893 {
894 /* don't bother database... */
896 "Empty result set for GET request for `%s' (bloomfilter).\n",
897 GNUNET_h2s (&msg->key));
900 "# requests filtered by bloomfilter"),
901 1,
902 GNUNET_NO);
903 transmit_item (client,
904 NULL,
905 0,
906 NULL,
907 0,
908 0,
909 0,
910 0,
912 0);
914 return;
915 }
917 GNUNET_ntohll (msg->next_uid),
918 msg->random,
919 &msg->key,
920 ntohl (msg->type),
922 client);
924}
925
926
933static void
934handle_get_replication (void *cls, const struct GNUNET_MessageHeader *message)
935{
936 struct GNUNET_SERVICE_Client *client = cls;
937
938 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Processing GET_REPLICATION request\n");
941 "# GET REPLICATION requests received"),
942 1,
943 GNUNET_NO);
946}
947
948
955static void
957{
958 struct GNUNET_SERVICE_Client *client = cls;
960
961 type = ntohl (msg->type);
963 {
964 GNUNET_break (0);
966 return;
967 }
969 "Processing GET_ZERO_ANONYMITY request\n");
972 "# GET ZERO ANONYMITY requests received"),
973 1,
974 GNUNET_NO);
976 GNUNET_ntohll (msg->next_uid),
977 type,
979 client);
981}
982
983
994static void
995remove_continuation (void *cls,
996 const struct GNUNET_HashCode *key,
997 uint32_t size,
998 int status,
999 const char *msg)
1000{
1001 struct GNUNET_SERVICE_Client *client = cls;
1002
1003 if (GNUNET_SYSERR == status)
1004 {
1005 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "REMOVE request failed: %s.\n", msg);
1006 transmit_status (client, GNUNET_NO, msg);
1007 return;
1008 }
1009 if (GNUNET_NO == status)
1010 {
1012 "Content not found for REMOVE request.\n");
1013 transmit_status (client, GNUNET_NO, _ ("Content not found"));
1014 return;
1015 }
1017 "Item matches REMOVE request for key `%s'.\n",
1018 GNUNET_h2s (key));
1020 gettext_noop ("# bytes removed (explicit request)"),
1021 size,
1022 GNUNET_YES);
1024 transmit_status (client, GNUNET_OK, NULL);
1025}
1026
1027
1035static int
1036check_remove (void *cls, const struct DataMessage *dm)
1037{
1038 if (GNUNET_OK != check_data (dm))
1039 {
1040 GNUNET_break (0);
1041 return GNUNET_SYSERR;
1042 }
1043 return GNUNET_OK;
1044}
1045
1046
1053static void
1054handle_remove (void *cls, const struct DataMessage *dm)
1055{
1056 struct GNUNET_SERVICE_Client *client = cls;
1057
1059 gettext_noop ("# REMOVE requests received"),
1060 1,
1061 GNUNET_NO);
1063 "Processing REMOVE request for `%s'\n",
1064 GNUNET_h2s (&dm->key));
1066 &dm->key,
1067 ntohl (dm->size),
1068 &dm[1],
1070 client);
1072}
1073
1074
1081static void
1082handle_drop (void *cls,
1083 const struct GNUNET_MessageHeader *message)
1084{
1085 struct GNUNET_SERVICE_Client *client = cls;
1086
1088 "Processing DROP request\n");
1091}
1092
1093
1102static void
1103disk_utilization_change_cb (void *cls, int delta)
1104{
1105 if ((delta < 0) && (payload < -delta))
1106 {
1107 GNUNET_log (
1109 _ (
1110 "Datastore payload must have been inaccurate (%lld < %lld). Recomputing it.\n"),
1111 (long long) payload,
1112 (long long) -delta);
1115 _ ("New payload: %lld\n"),
1116 (long long) payload);
1117 sync_stats ();
1118 return;
1119 }
1120 payload += delta;
1121 last_sync++;
1123 sync_stats ();
1124}
1125
1126
1137static int
1138process_stat_in (void *cls,
1139 const char *subsystem,
1140 const char *name,
1141 uint64_t value,
1142 int is_persistent)
1143{
1146 payload += value;
1147 GNUNET_log (
1149 "Notification from statistics about existing payload (%llu), new payload is %llu\n",
1150 (unsigned long long) value,
1151 (unsigned long long) payload);
1152 return GNUNET_OK;
1153}
1154
1155
1159static struct DatastorePlugin *
1160load_plugin ()
1161{
1162 struct DatastorePlugin *ret;
1163 char *libname;
1164
1165 ret = GNUNET_new (struct DatastorePlugin);
1166 ret->env.cfg = cfg;
1167 ret->env.duc = &disk_utilization_change_cb;
1168 ret->env.cls = NULL;
1170 _ ("Loading `%s' datastore plugin\n"),
1171 plugin_name);
1172 GNUNET_asprintf (&libname,
1173 "libgnunet_plugin_datastore_%s",
1174 plugin_name);
1175 ret->short_name = GNUNET_strdup (plugin_name);
1176 ret->lib_name = libname;
1178 libname,
1179 &ret->env);
1180 if (NULL == ret->api)
1181 {
1183 _ ("Failed to load datastore plugin for `%s'\n"),
1184 plugin_name);
1185 GNUNET_free (ret->short_name);
1186 GNUNET_free (libname);
1187 GNUNET_free (ret);
1188 return NULL;
1189 }
1190 return ret;
1191}
1192
1193
1200static void
1201unload_plugin (struct DatastorePlugin *plug)
1202{
1204 "Datastore service is unloading plugin...\n");
1205 GNUNET_break (NULL == GNUNET_PLUGIN_unload (plug->lib_name, plug->api));
1206 GNUNET_free (plug->lib_name);
1207 GNUNET_free (plug->short_name);
1208 GNUNET_free (plug);
1209}
1210
1211
1215static void
1217{
1222 NULL);
1223}
1224
1225
1233static void
1234add_key_to_bloomfilter (void *cls,
1235 const struct GNUNET_HashCode *key,
1236 unsigned int count)
1237{
1238 struct GNUNET_CONTAINER_BloomFilter *bf = cls;
1239
1240 if (NULL == key)
1241 {
1243 _ ("Bloomfilter construction complete.\n"));
1244 begin_service ();
1245 return;
1246 }
1247
1248 while (0 < count--)
1250}
1251
1252
1260static void
1261process_stat_done (void *cls, int success)
1262{
1263 stat_get = NULL;
1264 if (NULL != stat_timeout_task)
1265 {
1267 stat_timeout_task = NULL;
1268 }
1269 plugin = load_plugin ();
1270 if (NULL == plugin)
1271 {
1273 filter = NULL;
1274 if (NULL != stats)
1275 {
1277 stats = NULL;
1278 }
1279 return;
1280 }
1281
1282 if (GNUNET_NO == stats_worked)
1283 {
1285 "Failed to obtain value from statistics service, recomputing it\n");
1288 _ ("New payload: %lld\n"),
1289 (long long) payload);
1290 }
1291
1292 if (GNUNET_YES == refresh_bf)
1293 {
1295 _ ("Rebuilding bloomfilter. Please be patient.\n"));
1296 if (NULL != plugin->api->get_keys)
1297 {
1299 return;
1300 }
1301 else
1302 {
1304 _ (
1305 "Plugin does not support get_keys function. Please fix!\n"))
1306 ;
1307 }
1308 }
1309 begin_service ();
1310}
1311
1312
1318static void
1319stat_timeout (void *cls)
1320{
1321 stat_timeout_task = NULL;
1324}
1325
1326
1330static void
1331cleaning_task (void *cls)
1332{
1334 if (NULL != expired_kill_task)
1335 {
1337 expired_kill_task = NULL;
1338 }
1339 if (GNUNET_YES == do_drop)
1340 {
1342 "Dropping database!\n");
1343 plugin->api->drop (plugin->api->cls);
1344 payload = 0;
1345 last_sync++;
1346 }
1347 if (NULL != plugin)
1348 {
1350 plugin = NULL;
1351 }
1352 if (NULL != filter)
1353 {
1355 filter = NULL;
1356 }
1357 if (NULL != stat_get)
1358 {
1360 stat_get = NULL;
1361 }
1362 if (NULL != stat_timeout_task)
1363 {
1365 stat_timeout_task = NULL;
1366 }
1368 plugin_name = NULL;
1369 if (last_sync > 0)
1370 sync_stats ();
1371 if (NULL != stats)
1372 {
1374 stats = NULL;
1375 }
1377 quota_stat_name = NULL;
1378}
1379
1380
1389static void *
1390client_connect_cb (void *cls,
1391 struct GNUNET_SERVICE_Client *client,
1392 struct GNUNET_MQ_Handle *mq)
1393{
1394 return client;
1395}
1396
1397
1406static void
1407client_disconnect_cb (void *cls,
1408 struct GNUNET_SERVICE_Client *client,
1409 void *app_ctx)
1410{
1411 struct ReservationList *pos;
1412 struct ReservationList *prev;
1413 struct ReservationList *next;
1414
1415 GNUNET_assert (app_ctx == client);
1416 prev = NULL;
1417 pos = reservations;
1418 while (NULL != pos)
1419 {
1420 next = pos->next;
1421 if (pos->client == client)
1422 {
1423 if (NULL == prev)
1425 else
1426 prev->next = next;
1428 GNUNET_free (pos);
1429 }
1430 else
1431 {
1432 prev = pos;
1433 }
1434 pos = next;
1435 }
1437 gettext_noop ("# reserved"),
1438 reserved,
1439 GNUNET_NO);
1440}
1441
1442
1450static void
1451run (void *cls,
1452 const struct GNUNET_CONFIGURATION_Handle *c,
1453 struct GNUNET_SERVICE_Handle *serv)
1454{
1455 char *fn;
1456 char *pfn;
1457 unsigned int bf_size;
1458
1459 service = serv;
1460 cfg = c;
1462 "DATASTORE",
1463 "DATABASE",
1464 &plugin_name))
1465 {
1467 "DATABASE",
1468 "DATASTORE");
1469 return;
1470 }
1472 _ ("# bytes used in file-sharing datastore `%s'"),
1473 plugin_name);
1474 if (GNUNET_OK !=
1475 GNUNET_CONFIGURATION_get_value_size (cfg, "DATASTORE", "QUOTA", &quota))
1476 {
1477 GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "QUOTA", "DATASTORE");
1478 return;
1479 }
1480 stats = GNUNET_STATISTICS_create ("datastore", cfg);
1482 cache_size = quota / 8; /* Or should we make this an option? */
1484 gettext_noop ("# cache size"),
1485 cache_size,
1486 GNUNET_NO);
1487 if (quota / (32 * 1024LL) > MAX_BF_SIZE)
1488 bf_size = MAX_BF_SIZE;
1489 else
1490 bf_size =
1491 quota / (32 * 1024LL); /* 8 bit per entry, 1 bit per 32 kb in DB */
1492 fn = NULL;
1494 "DATASTORE",
1495 "BLOOMFILTER",
1496 &fn)) ||
1498 {
1500 _ ("Could not use specified filename `%s' for bloomfilter.\n"),
1501 NULL != fn ? fn : "");
1502 GNUNET_free (fn);
1503 fn = NULL;
1504 }
1505 if (NULL != fn)
1506 {
1507 GNUNET_asprintf (&pfn, "%s.%s", fn, plugin_name);
1508 if (GNUNET_YES == GNUNET_DISK_file_test (pfn))
1509 {
1510 filter =
1512 bf_size,
1513 5); /* approx. 3% false positives at max use */
1514 if (NULL == filter)
1515 {
1516 /* file exists but not valid, remove and try again, but refresh */
1517 if (0 != unlink (pfn))
1518 {
1519 /* failed to remove, run without file */
1521 _ ("Failed to remove bogus bloomfilter file `%s'\n"),
1522 pfn);
1523 GNUNET_free (pfn);
1524 pfn = NULL;
1526 NULL,
1527 bf_size,
1528 5); /* approx. 3% false positives at max use */
1530 }
1531 else
1532 {
1533 /* try again after remove */
1535 pfn,
1536 bf_size,
1537 5); /* approx. 3% false positives at max use */
1539 if (NULL == filter)
1540 {
1541 /* failed yet again, give up on using file */
1543 _ ("Failed to remove bogus bloomfilter file `%s'\n"),
1544 pfn);
1545 GNUNET_free (pfn);
1546 pfn = NULL;
1548 NULL,
1549 bf_size,
1550 5); /* approx. 3% false positives at max use */
1551 }
1552 }
1553 }
1554 else
1555 {
1556 /* normal case: have an existing valid bf file, no need to refresh */
1558 }
1559 }
1560 else
1561 {
1562 filter =
1564 bf_size,
1565 5); /* approx. 3% false positives at max use */
1567 }
1568 GNUNET_free (pfn);
1569 }
1570 else
1571 {
1572 filter =
1574 bf_size,
1575 5); /* approx. 3% false positives at max use */
1577 }
1578 GNUNET_free (fn);
1579 if (NULL == filter)
1580 {
1582 _ ("Failed to initialize bloomfilter.\n"));
1583 if (NULL != stats)
1584 {
1586 stats = NULL;
1587 }
1588 return;
1589 }
1592 "datastore",
1596 NULL);
1597 if (NULL == stat_get)
1599 else
1601 &stat_timeout,
1602 NULL);
1604}
1605
1606
1612 "datastore",
1614 &run,
1617 NULL,
1618 GNUNET_MQ_hd_fixed_size (reserve,
1620 struct ReserveMessage,
1621 NULL),
1622 GNUNET_MQ_hd_fixed_size (release_reserve,
1624 struct ReleaseReserveMessage,
1625 NULL),
1628 struct DataMessage,
1629 NULL),
1632 struct GetMessage,
1633 NULL),
1634 GNUNET_MQ_hd_fixed_size (get_key,
1636 struct GetKeyMessage,
1637 NULL),
1638 GNUNET_MQ_hd_fixed_size (get_replication,
1640 struct GNUNET_MessageHeader,
1641 NULL),
1642 GNUNET_MQ_hd_fixed_size (get_zero_anonymity,
1645 NULL),
1646 GNUNET_MQ_hd_var_size (remove,
1648 struct DataMessage,
1649 NULL),
1652 struct GNUNET_MessageHeader,
1653 NULL),
1655
1656
1657/* end of gnunet-service-datastore.c */
struct GNUNET_MessageHeader * msg
Definition 005.c:2
struct GNUNET_MQ_Envelope * env
Definition 005.c:1
#define gettext_noop(String)
Definition gettext.h:74
static int ret
Final status code.
Definition gnunet-arm.c:93
static int end
Set if we are to shutdown all services (including ARM).
Definition gnunet-arm.c:33
static unsigned int replication
Desired replication level.
static char * data
The data to insert into the dht.
struct GNUNET_HashCode key
The key used in the DHT.
static struct GNUNET_TIME_Relative expiration
User supplied expiration value.
static unsigned int anonymity
static char * name
Name (label) of the records to list.
static char * value
Value of the record to add/remove.
static uint32_t type
Type string converted to DNS type value.
static int status
The program status; 0 for success.
Definition gnunet-nse.c:39
static int check_put(void *cls, const struct DataMessage *dm)
Verify PUT-message.
static struct GNUNET_STATISTICS_GetHandle * stat_get
Handle for pending get request.
static void run(void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *serv)
Process datastore requests.
static void stat_timeout(void *cls)
Fetching stats took to long, run without.
static void handle_drop(void *cls, const struct GNUNET_MessageHeader *message)
Handle DROP-message.
static void cleaning_task(void *cls)
Task run during shutdown.
static int 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, uint32_t replication, struct GNUNET_TIME_Absolute expiration, uint64_t uid)
Iterate over the expired items stored in the datastore.
static char * plugin_name
Name of our plugin.
static void add_key_to_bloomfilter(void *cls, const struct GNUNET_HashCode *key, unsigned int count)
Adds a given key to the bloomfilter in cls count times.
static struct DatastorePlugin * plugin
Our datastore plugin (NULL if not available).
static int stats_worked
Did we get an answer from statistics?
static struct GNUNET_STATISTICS_Handle * stats
Handle for reporting statistics.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
static struct GNUNET_SCHEDULER_Task * stat_timeout_task
Task to timeout stat GET.
static struct GNUNET_CONTAINER_BloomFilter * filter
Bloomfilter to quickly tell if we don't have the content.
static void delete_expired(void *cls)
Task that is used to remove expired entries from the datastore.
static struct GNUNET_TIME_Absolute min_expiration
Minimum time that content should have to not be discarded instantly (time stamp of any content that w...
static void handle_remove(void *cls, const struct DataMessage *dm)
Handle REMOVE-message.
static unsigned long long payload
How much data are we currently storing in the database?
static int check_remove(void *cls, const struct DataMessage *dm)
Verify REMOVE-message.
static void handle_reserve(void *cls, const struct ReserveMessage *msg)
Handle RESERVE-message.
#define MAX_BF_SIZE
Limit size of bloom filter to 2 GB.
static void put_continuation(void *cls, const struct GNUNET_HashCode *key, uint32_t size, int status, const char *msg)
Put continuation.
static char * quota_stat_name
Name under which we store current space consumption.
static void handle_get_key(void *cls, const struct GetKeyMessage *msg)
Handle GNUNET_MESSAGE_TYPE_DATASTORE_GET_KEY-message.
static int 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, uint32_t replication, struct GNUNET_TIME_Absolute expiration, uint64_t uid)
An iterator over a set of items stored in the datastore that deletes until we're happy with respect t...
static void process_stat_done(void *cls, int success)
We finished receiving the statistic.
static void remove_continuation(void *cls, const struct GNUNET_HashCode *key, uint32_t size, int status, const char *msg)
Remove continuation.
#define MIN_EXPIRE_DELAY
How fast are we allowed to query the database for deleting expired content? (1 item per second).
static void * client_connect_cb(void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
Add a client to our list of active clients.
static void transmit_status(struct GNUNET_SERVICE_Client *client, int code, const char *msg)
Transmit a status code to the client.
static int check_data(const struct DataMessage *dm)
Check that the given message is a valid data message.
static int process_stat_in(void *cls, const char *subsystem, const char *name, uint64_t value, int is_persistent)
Callback function to process statistic values.
static int do_drop
Should the database be dropped on exit?
static int cleaning_done
Have we already cleaned up the TCCs and are hence no longer willing (or able) to transmit anything to...
static void handle_release_reserve(void *cls, const struct ReleaseReserveMessage *msg)
Handle RELEASE_RESERVE-message.
#define MAX_STAT_SYNC_LAG
After how many payload-changing operations do we sync our statistics?
static void manage_space(unsigned long long need)
Manage available disk space by running tasks that will discard content if necessary.
static struct GNUNET_SCHEDULER_Task * expired_kill_task
Identity of the task that is used to delete expired content.
static void begin_service()
Initialization complete, start operating the service.
static unsigned long long quota
How much space are we allowed to use?
static struct ReservationList * reservations
Linked list of space reservations made by clients.
static unsigned int last_sync
Number of updates that were made to the payload value since we last synchronized it with the statisti...
static void handle_get_replication(void *cls, const struct GNUNET_MessageHeader *message)
Handle GET_REPLICATION-message.
static void handle_get(void *cls, const struct GetMessage *msg)
Handle GNUNET_MESSAGE_TYPE_DATASTORE_GET-message.
static unsigned long long reserved
How much space have we currently reserved?
static void sync_stats()
Synchronize our utilization statistics with the statistics service.
static int 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, uint32_t replication, struct GNUNET_TIME_Absolute expiration, uint64_t uid)
Function that will transmit the given datastore entry to the client.
static void handle_put(void *cls, const struct DataMessage *dm)
Handle PUT-message.
static void unload_plugin(struct DatastorePlugin *plug)
Function called when the service shuts down.
#define MAX_EXPIRE_DELAY
How long are we at most keeping "expired" content past the expiration date in the database?
static void disk_utilization_change_cb(void *cls, int delta)
Function called by plugins to notify us about a change in their disk utilization.
static void client_disconnect_cb(void *cls, struct GNUNET_SERVICE_Client *client, void *app_ctx)
Called whenever a client is disconnected.
static struct GNUNET_SERVICE_Handle * service
Handle to our server.
static int refresh_bf
Should we refresh the BF when the DB is loaded?
static struct DatastorePlugin * load_plugin()
Load the datastore plugin.
static unsigned long long cache_size
How much space are we using for the cache? (space available for insertions that will be instantly rec...
static void handle_get_zero_anonymity(void *cls, const struct GetZeroAnonymityMessage *msg)
Handle GET_ZERO_ANONYMITY-message.
static char * subsystem
Set to subsystem that we're going to get stats for (or NULL for all).
GNUNET_BLOCK_Type
WARNING: This header is generated! In order to add DHT block types, you must register them in GANA,...
@ GNUNET_BLOCK_TYPE_ANY
Identifier for any block.
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message,...
struct GNUNET_CONTAINER_BloomFilter * GNUNET_CONTAINER_bloomfilter_init(const char *data, size_t size, unsigned int k)
Create a Bloom filter from raw bits.
void GNUNET_CONTAINER_bloomfilter_add(struct GNUNET_CONTAINER_BloomFilter *bf, const struct GNUNET_HashCode *e)
Add an element to the filter.
bool GNUNET_CONTAINER_bloomfilter_test(const struct GNUNET_CONTAINER_BloomFilter *bf, const struct GNUNET_HashCode *e)
Test if an element is in the filter.
struct GNUNET_CONTAINER_BloomFilter * GNUNET_CONTAINER_bloomfilter_load(const char *filename, size_t size, unsigned int k)
Load a Bloom filter from a file.
void GNUNET_CONTAINER_bloomfilter_remove(struct GNUNET_CONTAINER_BloomFilter *bf, const struct GNUNET_HashCode *e)
Remove an element from the filter.
void GNUNET_CONTAINER_bloomfilter_free(struct GNUNET_CONTAINER_BloomFilter *bf)
Free the space associated with a filter in memory, flush to drive if needed (do not free the space on...
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_filename(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be the name of a file or directory.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_size(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *size)
Get a configuration value that should be a size in bytes.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be a string.
#define GNUNET_DATASTORE_ENTRY_OVERHEAD
How many bytes of overhead will we assume per entry in any DB (for reservations)?
enum GNUNET_GenericReturnValue GNUNET_DISK_file_test(const char *fil)
Check that fil corresponds to a filename (of a file that exists and that is not a directory).
Definition disk.c:533
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_create_for_file(const char *filename)
Create the directory structure for storing a file.
Definition disk.c:633
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
#define GNUNET_log(kind,...)
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
@ GNUNET_SCHEDULER_PRIORITY_IDLE
Run when otherwise idle.
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
@ GNUNET_SYSERR
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
@ GNUNET_ERROR_TYPE_INFO
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition mq.c:305
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
const struct GNUNET_OS_ProjectData * GNUNET_OS_project_data_gnunet(void)
Return default project data used by 'libgnunetutil' for GNUnet.
void * GNUNET_PLUGIN_load(const struct GNUNET_OS_ProjectData *pd, const char *library_name, void *arg)
Setup plugin (runs the "init" callback and returns whatever "init" returned).
Definition plugin.c:221
void * GNUNET_PLUGIN_unload(const char *library_name, void *arg)
Unload plugin (runs the "done" callback and returns whatever "done" returned).
Definition plugin.c:277
#define GNUNET_MESSAGE_TYPE_DATASTORE_DROP
Message sent by datastore client to drop the database.
#define GNUNET_MESSAGE_TYPE_DATASTORE_RELEASE_RESERVE
Message sent by datastore client on join.
#define GNUNET_MESSAGE_TYPE_DATASTORE_DATA_END
Message sent by datastore to client signaling end of matching data.
#define GNUNET_MESSAGE_TYPE_DATASTORE_GET_KEY
Message sent by datastore client to get data by key.
#define GNUNET_MESSAGE_TYPE_DATASTORE_RESERVE
Message sent by datastore client on join.
#define GNUNET_MESSAGE_TYPE_DATASTORE_REMOVE
Message sent by datastore client to remove data.
#define GNUNET_MESSAGE_TYPE_DATASTORE_GET
Message sent by datastore client to get data.
#define GNUNET_MESSAGE_TYPE_DATASTORE_DATA
Message sent by datastore to client providing requested data (in response to GET or GET_RANDOM reques...
#define GNUNET_MESSAGE_TYPE_DATASTORE_PUT
Message sent by datastore client to store data.
#define GNUNET_MESSAGE_TYPE_DATASTORE_GET_REPLICATION
Message sent by datastore client to get random data.
#define GNUNET_MESSAGE_TYPE_DATASTORE_STATUS
Message sent by datastore to client informing about status processing a request (in response to RESER...
#define GNUNET_MESSAGE_TYPE_DATASTORE_GET_ZERO_ANONYMITY
Message sent by datastore client to get random data.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received,...
Definition scheduler.c:1339
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition scheduler.c:980
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition scheduler.c:1277
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed_with_priority(struct GNUNET_TIME_Relative delay, enum GNUNET_SCHEDULER_Priority priority, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition scheduler.c:1207
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_with_priority(enum GNUNET_SCHEDULER_Priority prio, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified priority.
Definition scheduler.c:1231
#define GNUNET_SERVICE_MAIN(pd, service_name, service_options, init_cb, connect_cb, disconnect_cb, cls,...)
Creates the "main" function for a GNUnet service.
void GNUNET_SERVICE_suspend(struct GNUNET_SERVICE_Handle *sh)
Suspend accepting connections from the listen socket temporarily.
Definition service.c:2380
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition service.c:2462
struct GNUNET_MQ_Handle * GNUNET_SERVICE_client_get_mq(struct GNUNET_SERVICE_Client *c)
Obtain the message queue of c.
Definition service.c:2544
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition service.c:2433
void GNUNET_SERVICE_resume(struct GNUNET_SERVICE_Handle *sh)
Resume accepting connections from the listen socket.
Definition service.c:2388
@ GNUNET_SERVICE_OPTION_NONE
Use defaults.
struct GNUNET_STATISTICS_Handle * GNUNET_STATISTICS_create(const char *subsystem, const struct GNUNET_CONFIGURATION_Handle *cfg)
Get handle for the statistics service.
void GNUNET_STATISTICS_get_cancel(struct GNUNET_STATISTICS_GetHandle *gh)
Cancel a GNUNET_STATISTICS_get request.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
struct GNUNET_STATISTICS_GetHandle * GNUNET_STATISTICS_get(struct GNUNET_STATISTICS_Handle *handle, const char *subsystem, const char *name, GNUNET_STATISTICS_Callback cont, GNUNET_STATISTICS_Iterator proc, void *cls)
Get statistic from the peer.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).
#define GNUNET_TIME_UNIT_SECONDS
One second.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_remaining(struct GNUNET_TIME_Absolute future)
Given a timestamp in the future, how much time remains until then?
Definition time.c:406
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition strings.c:599
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition time.c:111
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition time.c:741
#define GNUNET_TIME_UNIT_ZERO_ABS
Absolute time zero.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_difference(struct GNUNET_TIME_Absolute start, struct GNUNET_TIME_Absolute end)
Compute the time difference between the given start and end times.
Definition time.c:423
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition time.c:640
const char * GNUNET_STRINGS_absolute_time_to_string(struct GNUNET_TIME_Absolute t)
Like asctime, except for GNUnet time.
Definition strings.c:660
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
static unsigned int size
Size of the "table".
Definition peer.c:68
#define _(String)
GNU gettext support macro.
Definition platform.h:179
static struct GNUNET_MQ_Handle * mq
Our connection to the resolver service, created on-demand, but then persists until error or shutdown.
static struct GNUNET_TIME_Relative delta
Definition speedup.c:36
Message transmitting content from or to the datastore service.
Definition datastore.h:192
uint32_t priority
Priority of the item (NBO), zero for remove.
Definition datastore.h:219
struct GNUNET_HashCode key
Key under which the item can be found.
Definition datastore.h:252
uint64_t uid
Unique ID for the content (can be used for UPDATE); can be zero for remove (which indicates that the ...
Definition datastore.h:242
struct GNUNET_TIME_AbsoluteNBO expiration
Expiration time (NBO); zero for remove.
Definition datastore.h:247
struct GNUNET_MessageHeader header
Type is either GNUNET_MESSAGE_TYPE_DATASTORE_PUT, GNUNET_MESSAGE_TYPE_DATASTORE_REMOVE or GNUNET_MESS...
Definition datastore.h:199
uint32_t type
Type of the item (NBO), zero for remove, (actually an enum GNUNET_BLOCK_Type)
Definition datastore.h:214
uint32_t size
Number of bytes in the item (NBO).
Definition datastore.h:209
uint32_t replication
Desired replication level.
Definition datastore.h:229
uint32_t anonymity
Desired anonymity level (NBO), zero for remove.
Definition datastore.h:224
uint32_t rid
Reservation ID to use; use zero for none.
Definition datastore.h:204
Our datastore plugin.
char * lib_name
Name of the library (e.g.
struct GNUNET_DATASTORE_PluginFunctions * api
API of the transport as returned by the plugin's initialization function.
char * short_name
Short name for the plugin (e.g.
The datastore service will pass a pointer to a struct of this type as the first and only argument to ...
Each plugin is required to return a pointer to a struct of this type as the return value from its ent...
PluginGetKey get_key
Get a particular datum matching a given hash from the datastore.
PluginGetRandom get_expiration
Function to get a random expired item or, if none are expired, either the oldest entry or one with a ...
PluginEstimateSize estimate_size
Calculate the current on-disk size of the SQ store.
PluginGetKeys get_keys
Iterate over all keys in the database.
PluginGetRandom get_replication
Function to get a random item with high replication score from the database, lowering the item's repl...
PluginPut put
Function to store an item in the datastore.
void * cls
Closure to use for all of the following callbacks (except "next_request").
PluginGetType get_zero_anonymity
Get datum (of the specified type) with anonymity level zero.
PluginDrop drop
Delete the database.
PluginRemoveKey remove_key
Function to remove an item from the database.
A 512-bit hashcode.
Handle to a message queue.
Definition mq.c:87
Header for all communications.
Entry in list of pending tasks.
Definition scheduler.c:136
Handle to a client that is connected to a service.
Definition service.c:249
Handle to a service.
Definition service.c:116
Linked list of things we still need to do.
Handle for the service.
Time for absolute times used by GNUnet, in microseconds.
Message to the datastore service asking about specific content.
Definition datastore.h:108
Message to the datastore service asking about specific content.
Definition datastore.h:141
Message to the datastore service asking about zero anonymity content.
Definition datastore.h:169
Message from datastore client informing service that the remainder of the reserved bytes can now be r...
Definition datastore.h:90
Linked list of active reservations.
uint64_t amount
Number of bytes (still) reserved.
struct GNUNET_SERVICE_Client * client
Client that made the reservation.
int32_t rid
Reservation identifier.
uint64_t entries
Number of items (still) reserved.
struct ReservationList * next
This is a linked list.
Message from datastore service informing client about the current size of the datastore.
Definition datastore.h:40
Message from datastore service informing client about the success or failure of a requested operation...
Definition datastore.h:65
struct GNUNET_TIME_AbsoluteNBO min_expiration
Minimum expiration time required for content to be stored by the datacache at this time,...
Definition datastore.h:80
int32_t status
Status code, -1 for errors.
Definition datastore.h:74

◆ MIN_EXPIRE_DELAY

#define MIN_EXPIRE_DELAY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)

How fast are we allowed to query the database for deleting expired content? (1 item per second).

Definition at line 55 of file gnunet-service-datastore.c.

◆ MAX_STAT_SYNC_LAG

#define MAX_STAT_SYNC_LAG   50

After how many payload-changing operations do we sync our statistics?

Definition at line 72 of file gnunet-service-datastore.c.

Function Documentation

◆ sync_stats()

static void sync_stats ( )
static

Synchronize our utilization statistics with the statistics service.

Definition at line 232 of file gnunet-service-datastore.c.

233{
236 "# utilization by current datastore",
237 payload,
238 GNUNET_NO);
239 last_sync = 0;
240}

References GNUNET_NO, GNUNET_STATISTICS_set(), GNUNET_YES, last_sync, payload, quota_stat_name, and stats.

Referenced by cleaning_task(), and disk_utilization_change_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ delete_expired()

static void delete_expired ( void *  cls)
static

Task that is used to remove expired entries from the datastore.

This task will schedule itself again automatically to always delete all expired content quickly.

Parameters
clsnot used

Definition at line 357 of file gnunet-service-datastore.c.

358{
359 expired_kill_task = NULL;
361}

References DatastorePlugin::api, GNUNET_DATASTORE_PluginFunctions::cls, expired_kill_task, expired_processor(), GNUNET_DATASTORE_PluginFunctions::get_expiration, and plugin.

Referenced by begin_service(), and expired_processor().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ expired_processor()

static int 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,
uint32_t  replication,
struct GNUNET_TIME_Absolute  expiration,
uint64_t  uid 
)
static

Iterate over the expired items stored in the datastore.

Delete all expired items; once we have processed all expired items, re-schedule the "delete_expired" task.

Parameters
clsnot used
keykey for the content
sizenumber of bytes in data
datacontent stored
typetype of the content
prioritypriority of the content
anonymityanonymity-level for the content
replicationreplication-level for the content
expirationexpiration time for the content
uidunique identifier for the datum; maybe 0 if no unique identifier is available
Returns
GNUNET_SYSERR to abort the iteration, GNUNET_OK to continue (continue on call to "next", of course), GNUNET_NO to delete the item and continue (if supported)

Definition at line 293 of file gnunet-service-datastore.c.

303{
304 struct GNUNET_TIME_Absolute now;
305
306 if (NULL == key)
307 {
312 NULL);
313 return GNUNET_SYSERR;
314 }
316 if (expiration.abs_value_us > now.abs_value_us)
317 {
318 /* finished processing */
323 NULL);
324 return GNUNET_SYSERR;
325 }
327 "Deleting content `%s' of type %u that expired %s ago\n",
328 GNUNET_h2s (key),
329 type,
332 GNUNET_YES));
333 min_expiration = now;
335 gettext_noop ("# bytes expired"),
336 size,
337 GNUNET_YES);
343 NULL);
344 return GNUNET_NO;
345}

References GNUNET_TIME_Absolute::abs_value_us, delete_expired(), expiration, expired_kill_task, filter, gettext_noop, GNUNET_CONTAINER_bloomfilter_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_delayed_with_priority(), GNUNET_SCHEDULER_PRIORITY_IDLE, GNUNET_STATISTICS_update(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_SYSERR, GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_difference(), GNUNET_YES, key, MAX_EXPIRE_DELAY, min_expiration, MIN_EXPIRE_DELAY, size, stats, and type.

Referenced by delete_expired().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ quota_processor()

static int 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,
uint32_t  replication,
struct GNUNET_TIME_Absolute  expiration,
uint64_t  uid 
)
static

An iterator over a set of items stored in the datastore that deletes until we're happy with respect to our quota.

Parameters
clsclosure
keykey for the content
sizenumber of bytes in data
datacontent stored
typetype of the content
prioritypriority of the content
anonymityanonymity-level for the content
replicationreplication-level for the content
expirationexpiration time for the content
uidunique identifier for the datum; maybe 0 if no unique identifier is available
Returns
GNUNET_SYSERR to abort the iteration, GNUNET_OK to continue (continue on call to "next", of course), GNUNET_NO to delete the item and continue (if supported)

Definition at line 384 of file gnunet-service-datastore.c.

394{
395 unsigned long long *need = cls;
396
397 if (NULL == key)
398 return GNUNET_SYSERR;
399 GNUNET_log (
401 "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",
402 (unsigned long long) (size + GNUNET_DATASTORE_ENTRY_OVERHEAD),
403 (unsigned int) priority,
404 GNUNET_h2s (key),
405 type,
407 expiration),
408 GNUNET_YES),
409 *need);
411 *need = 0;
412 else
414 if (priority > 0)
416 else
419 gettext_noop ("# bytes purged (low-priority)"),
420 size,
421 GNUNET_YES);
423 return GNUNET_NO;
424}

References expiration, filter, gettext_noop, GNUNET_CONTAINER_bloomfilter_remove(), GNUNET_DATASTORE_ENTRY_OVERHEAD, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_SYSERR, GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_YES, key, min_expiration, size, stats, and type.

Referenced by manage_space().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ manage_space()

static void manage_space ( unsigned long long  need)
static

Manage available disk space by running tasks that will discard content if necessary.

This function will be run whenever a request for "need" bytes of storage could only be satisfied by eating into the "cache" (and we want our cache space back).

Parameters
neednumber of bytes of content that were placed into the "cache" (and hence the number of bytes that should be removed).

Definition at line 440 of file gnunet-service-datastore.c.

441{
442 unsigned long long last;
443
445 "Asked to free up %llu bytes of cache space\n",
446 need);
447 last = 0;
448 while ((need > 0) && (last != need))
449 {
450 last = need;
452 }
453}

References DatastorePlugin::api, GNUNET_DATASTORE_PluginFunctions::cls, GNUNET_DATASTORE_PluginFunctions::get_expiration, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, plugin, and quota_processor().

Referenced by put_continuation().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ transmit_status()

static void transmit_status ( struct GNUNET_SERVICE_Client client,
int  code,
const char *  msg 
)
static

Transmit a status code to the client.

Parameters
clientreceiver of the response
codestatus code
msgoptional error message (can be NULL)

Definition at line 464 of file gnunet-service-datastore.c.

467{
468 struct GNUNET_MQ_Envelope *env;
469 struct StatusMessage *sm;
470 size_t slen;
471
473 "Transmitting `%s' message with value %d and message `%s'\n",
474 "STATUS",
475 code,
476 msg != NULL ? msg : "(none)");
477 slen = (msg == NULL) ? 0 : strlen (msg) + 1;
479 sm->status = htonl (code);
481 GNUNET_memcpy (&sm[1], msg, slen);
483}

References env, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_DATASTORE_STATUS, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_SERVICE_client_get_mq(), GNUNET_TIME_absolute_hton(), StatusMessage::min_expiration, min_expiration, msg, and StatusMessage::status.

Referenced by handle_release_reserve(), handle_reserve(), put_continuation(), and remove_continuation().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ transmit_item()

static int 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,
uint32_t  replication,
struct GNUNET_TIME_Absolute  expiration,
uint64_t  uid 
)
static

Function that will transmit the given datastore entry to the client.

Parameters
clsclosure, pointer to the client (of type struct GNUNET_SERVICE_Client).
keykey for the content
sizenumber of bytes in data
datacontent stored
typetype of the content
prioritypriority of the content
anonymityanonymity-level for the content
replicationreplication-level for the content
expirationexpiration time for the content
uidunique identifier for the datum; maybe 0 if no unique identifier is available
Returns
GNUNET_SYSERR to abort the iteration, GNUNET_OK to continue, GNUNET_NO to delete the item and continue (if supported)

Definition at line 505 of file gnunet-service-datastore.c.

515{
516 struct GNUNET_SERVICE_Client *client = cls;
517 struct GNUNET_MQ_Envelope *env;
519 struct DataMessage *dm;
520
521 if (NULL == key)
522 {
523 /* transmit 'DATA_END' */
524 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Transmitting DATA_END message\n");
527 return GNUNET_OK;
528 }
531 dm->rid = htonl (0);
532 dm->size = htonl (size);
533 dm->type = htonl (type);
534 dm->priority = htonl (priority);
535 dm->anonymity = htonl (anonymity);
536 dm->replication = htonl (replication);
538 dm->uid = GNUNET_htonll (uid);
539 dm->key = *key;
540 GNUNET_memcpy (&dm[1], data, size);
541 GNUNET_log (
543 "Transmitting DATA message for `%s' of type %u with expiration %s (in: %s)\n",
544 GNUNET_h2s (key),
545 type,
548 expiration),
549 GNUNET_YES));
551 gettext_noop ("# results found"),
552 1,
553 GNUNET_NO);
555 return GNUNET_OK;
556}

References anonymity, DataMessage::anonymity, data, end, env, expiration, DataMessage::expiration, gettext_noop, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_htonll(), GNUNET_log, GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_DATASTORE_DATA, GNUNET_MESSAGE_TYPE_DATASTORE_DATA_END, GNUNET_MQ_msg, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_OK, GNUNET_SERVICE_client_get_mq(), GNUNET_STATISTICS_update(), GNUNET_STRINGS_absolute_time_to_string(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_absolute_hton(), GNUNET_YES, key, DataMessage::key, DataMessage::priority, replication, DataMessage::replication, DataMessage::rid, size, DataMessage::size, stats, type, DataMessage::type, and DataMessage::uid.

Referenced by handle_get(), handle_get_key(), handle_get_replication(), and handle_get_zero_anonymity().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ handle_reserve()

static void handle_reserve ( void *  cls,
const struct ReserveMessage msg 
)
static

Handle RESERVE-message.

Parameters
clsidentification of the client
msgthe actual message

Static counter to produce reservation identifiers.

Definition at line 566 of file gnunet-service-datastore.c.

567{
571 static int reservation_gen;
572 struct GNUNET_SERVICE_Client *client = cls;
573 struct ReservationList *e;
574 unsigned long long used;
575 unsigned long long req;
576 uint64_t amount;
577 uint32_t entries;
578
579 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Processing RESERVE request\n");
580 amount = GNUNET_ntohll (msg->amount);
581 entries = ntohl (msg->entries);
582 used = payload + reserved;
583 req =
584 amount + ((unsigned long long) GNUNET_DATASTORE_ENTRY_OVERHEAD) * entries;
585 if (used + req > quota)
586 {
587 if (quota < used)
588 used =
589 quota; /* cheat a bit for error message (to avoid negative numbers) */
590 GNUNET_log (
592 _ (
593 "Insufficient space (%llu bytes are available) to satisfy RESERVE request for %llu bytes\n"),
594 quota - used,
595 req);
596 if (cache_size < req)
597 {
598 /* TODO: document this in the FAQ; essentially, if this
599 * message happens, the insertion request could be blocked
600 * by less-important content from migration because it is
601 * larger than 1/8th of the overall available space, and
602 * we only reserve 1/8th for "fresh" insertions */
603 GNUNET_log (
605 _ (
606 "The requested amount (%llu bytes) is larger than the cache size (%llu bytes)\n"),
607 req,
608 cache_size);
610 0,
612 "Insufficient space to satisfy request and "
613 "requested amount is larger than cache size"));
614 }
615 else
616 {
618 0,
619 gettext_noop ("Insufficient space to satisfy request"));
620 }
622 return;
623 }
624 reserved += req;
626 gettext_noop ("# reserved"),
627 reserved,
628 GNUNET_NO);
629 e = GNUNET_new (struct ReservationList);
630 e->next = reservations;
631 reservations = e;
632 e->client = client;
633 e->amount = amount;
634 e->entries = entries;
635 e->rid = ++reservation_gen;
636 if (reservation_gen < 0)
637 reservation_gen = 0; /* wrap around */
638 transmit_status (client, e->rid, NULL);
640}

References _, ReservationList::amount, cache_size, ReservationList::client, ReservationList::entries, gettext_noop, GNUNET_DATASTORE_ENTRY_OVERHEAD, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_ntohll(), GNUNET_SERVICE_client_continue(), GNUNET_STATISTICS_set(), msg, ReservationList::next, payload, quota, reservations, reserved, ReservationList::rid, stats, and transmit_status().

Here is the call graph for this function:

◆ handle_release_reserve()

static void handle_release_reserve ( void *  cls,
const struct ReleaseReserveMessage msg 
)
static

Handle RELEASE_RESERVE-message.

Parameters
clsidentification of the client
msgthe actual message

Definition at line 650 of file gnunet-service-datastore.c.

651{
652 struct GNUNET_SERVICE_Client *client = cls;
653 struct ReservationList *pos;
654 struct ReservationList *prev;
655 struct ReservationList *next;
656 int rid = ntohl (msg->rid);
657 unsigned long long rem;
658
659 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Processing RELEASE_RESERVE request\n");
661 prev = NULL;
662 while (NULL != (pos = next))
663 {
664 next = pos->next;
665 if (rid == pos->rid)
666 {
667 if (prev == NULL)
669 else
670 prev->next = next;
671 rem =
672 pos->amount
673 + ((unsigned long long) GNUNET_DATASTORE_ENTRY_OVERHEAD) * pos->entries;
674 GNUNET_assert (reserved >= rem);
675 reserved -= rem;
677 gettext_noop ("# reserved"),
678 reserved,
679 GNUNET_NO);
681 "Returning %llu remaining reserved bytes to storage pool\n",
682 rem);
683 GNUNET_free (pos);
686 return;
687 }
688 prev = pos;
689 }
690 GNUNET_break (0);
693 gettext_noop ("Could not find matching reservation"));
695}

References ReservationList::amount, ReservationList::client, ReservationList::entries, gettext_noop, GNUNET_assert, GNUNET_break, GNUNET_DATASTORE_ENTRY_OVERHEAD, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_SERVICE_client_continue(), GNUNET_STATISTICS_set(), GNUNET_SYSERR, msg, ReservationList::next, reservations, reserved, ReservationList::rid, stats, and transmit_status().

Here is the call graph for this function:

◆ check_data()

static int check_data ( const struct DataMessage dm)
static

Check that the given message is a valid data message.

Parameters
dmmessage to check
Returns
GNUNET_SYSERR is not well-formed, otherwise GNUNET_OK

Definition at line 705 of file gnunet-service-datastore.c.

706{
707 uint16_t size;
708 uint32_t dsize;
709
710 size = ntohs (dm->header.size);
711 dsize = ntohl (dm->size);
712 if (size != dsize + sizeof(struct DataMessage))
713 {
714 GNUNET_break (0);
715 return GNUNET_SYSERR;
716 }
717 return GNUNET_OK;
718}

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, DataMessage::header, GNUNET_MessageHeader::size, size, and DataMessage::size.

Referenced by check_put(), and check_remove().

Here is the caller graph for this function:

◆ put_continuation()

static void put_continuation ( void *  cls,
const struct GNUNET_HashCode key,
uint32_t  size,
int  status,
const char *  msg 
)
static

Put continuation.

Parameters
clsclosure
keykey for the item stored
sizesize of the item stored
statusGNUNET_OK if inserted, GNUNET_NO if updated, or #GNUNET_SYSERROR if error
msgerror message on error

Definition at line 732 of file gnunet-service-datastore.c.

737{
738 struct GNUNET_SERVICE_Client *client = cls;
739
740 if (GNUNET_OK == status)
741 {
743 gettext_noop ("# bytes stored"),
744 size,
745 GNUNET_YES);
748 "Successfully stored %u bytes under key `%s'\n",
749 size,
750 GNUNET_h2s (key));
751 }
752 transmit_status (client,
754 msg);
756 {
758 _ ("Need %llu bytes more space (%llu allowed, using %llu)\n"),
759 (unsigned long long) size + GNUNET_DATASTORE_ENTRY_OVERHEAD,
760 (unsigned long long) (quota - reserved - cache_size),
761 (unsigned long long) payload);
763 }
764}

References _, cache_size, filter, gettext_noop, GNUNET_CONTAINER_bloomfilter_add(), GNUNET_DATASTORE_ENTRY_OVERHEAD, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_h2s(), GNUNET_log, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_YES, key, manage_space(), msg, payload, quota, reserved, size, stats, status, and transmit_status().

Referenced by handle_put().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ check_put()

static int check_put ( void *  cls,
const struct DataMessage dm 
)
static

Verify PUT-message.

Parameters
clsidentification of the client
dmthe actual message
Returns
GNUNET_OK if dm is well-formed

Definition at line 775 of file gnunet-service-datastore.c.

776{
777 if (GNUNET_OK != check_data (dm))
778 {
779 GNUNET_break (0);
780 return GNUNET_SYSERR;
781 }
782 return GNUNET_OK;
783}

References check_data(), GNUNET_break, GNUNET_OK, and GNUNET_SYSERR.

Here is the call graph for this function:

◆ handle_put()

static void handle_put ( void *  cls,
const struct DataMessage dm 
)
static

Handle PUT-message.

Parameters
clsidentification of the client
dmthe actual message

Definition at line 793 of file gnunet-service-datastore.c.

794{
795 struct GNUNET_SERVICE_Client *client = cls;
796 int rid;
797 struct ReservationList *pos;
798 uint32_t size;
799
801 "Processing PUT request for `%s' of type %u\n",
802 GNUNET_h2s (&dm->key),
803 (uint32_t) ntohl (dm->type));
804 rid = ntohl (dm->rid);
805 size = ntohl (dm->size);
806 if (rid > 0)
807 {
808 pos = reservations;
809 while ((NULL != pos) && (rid != pos->rid))
810 pos = pos->next;
811 GNUNET_break (pos != NULL);
812 if (NULL != pos)
813 {
814 GNUNET_break (pos->entries > 0);
815 GNUNET_break (pos->amount >= size);
816 pos->entries--;
817 pos->amount -= size;
820 gettext_noop ("# reserved"),
821 reserved,
822 GNUNET_NO);
823 }
824 }
825 {
826 bool absent =
828 plugin->api->put (plugin->api->cls,
829 &dm->key,
830 absent,
831 ntohl (dm->size),
832 &dm[1],
833 ntohl (dm->type),
834 ntohl (dm->priority),
835 ntohl (dm->anonymity),
836 ntohl (dm->replication),
839 client);
840 }
842}

References ReservationList::amount, DataMessage::anonymity, DatastorePlugin::api, ReservationList::client, GNUNET_DATASTORE_PluginFunctions::cls, ReservationList::entries, DataMessage::expiration, filter, gettext_noop, GNUNET_break, GNUNET_CONTAINER_bloomfilter_test(), GNUNET_DATASTORE_ENTRY_OVERHEAD, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_NO, GNUNET_SERVICE_client_continue(), GNUNET_STATISTICS_set(), GNUNET_TIME_absolute_ntoh(), DataMessage::key, ReservationList::next, plugin, DataMessage::priority, GNUNET_DATASTORE_PluginFunctions::put, put_continuation(), DataMessage::replication, reservations, reserved, DataMessage::rid, ReservationList::rid, size, DataMessage::size, stats, and DataMessage::type.

Here is the call graph for this function:

◆ handle_get()

static void handle_get ( void *  cls,
const struct GetMessage msg 
)
static

Handle GNUNET_MESSAGE_TYPE_DATASTORE_GET-message.

Parameters
clsidentification of the client
msgthe actual message

Definition at line 852 of file gnunet-service-datastore.c.

853{
854 struct GNUNET_SERVICE_Client *client = cls;
855
857 "Processing GET request of type %u\n",
858 (uint32_t) ntohl (msg->type));
860 gettext_noop ("# GET requests received"),
861 1,
862 GNUNET_NO);
864 GNUNET_ntohll (msg->next_uid),
865 msg->random,
866 NULL,
867 ntohl (msg->type),
869 client);
871}

References DatastorePlugin::api, GNUNET_DATASTORE_PluginFunctions::cls, GNUNET_DATASTORE_PluginFunctions::get_key, gettext_noop, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_ntohll(), GNUNET_SERVICE_client_continue(), GNUNET_STATISTICS_update(), msg, plugin, stats, transmit_item(), and GNUNET_MessageHeader::type.

Here is the call graph for this function:

◆ handle_get_key()

static void handle_get_key ( void *  cls,
const struct GetKeyMessage msg 
)
static

Handle GNUNET_MESSAGE_TYPE_DATASTORE_GET_KEY-message.

Parameters
clsclosure
msgthe actual message

Definition at line 881 of file gnunet-service-datastore.c.

882{
883 struct GNUNET_SERVICE_Client *client = cls;
884
886 "Processing GET request for `%s' of type %u\n",
887 GNUNET_h2s (&msg->key),
888 (uint32_t) ntohl (msg->type));
890 gettext_noop ("# GET KEY requests received"),
891 1,
892 GNUNET_NO);
894 {
895 /* don't bother database... */
897 "Empty result set for GET request for `%s' (bloomfilter).\n",
898 GNUNET_h2s (&msg->key));
901 "# requests filtered by bloomfilter"),
902 1,
903 GNUNET_NO);
904 transmit_item (client,
905 NULL,
906 0,
907 NULL,
908 0,
909 0,
910 0,
911 0,
913 0);
915 return;
916 }
918 GNUNET_ntohll (msg->next_uid),
919 msg->random,
920 &msg->key,
921 ntohl (msg->type),
923 client);
925}

References DatastorePlugin::api, GNUNET_DATASTORE_PluginFunctions::cls, filter, GNUNET_DATASTORE_PluginFunctions::get_key, gettext_noop, GNUNET_CONTAINER_bloomfilter_test(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_NO, GNUNET_ntohll(), GNUNET_SERVICE_client_continue(), GNUNET_STATISTICS_update(), GNUNET_TIME_UNIT_ZERO_ABS, GNUNET_YES, msg, plugin, stats, transmit_item(), and GNUNET_MessageHeader::type.

Here is the call graph for this function:

◆ handle_get_replication()

static void handle_get_replication ( void *  cls,
const struct GNUNET_MessageHeader message 
)
static

Handle GET_REPLICATION-message.

Parameters
clsidentification of the client
messagethe actual message

Definition at line 935 of file gnunet-service-datastore.c.

936{
937 struct GNUNET_SERVICE_Client *client = cls;
938
939 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Processing GET_REPLICATION request\n");
942 "# GET REPLICATION requests received"),
943 1,
944 GNUNET_NO);
947}

References DatastorePlugin::api, GNUNET_DATASTORE_PluginFunctions::cls, GNUNET_DATASTORE_PluginFunctions::get_replication, gettext_noop, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_SERVICE_client_continue(), GNUNET_STATISTICS_update(), plugin, stats, and transmit_item().

Here is the call graph for this function:

◆ handle_get_zero_anonymity()

static void handle_get_zero_anonymity ( void *  cls,
const struct GetZeroAnonymityMessage msg 
)
static

Handle GET_ZERO_ANONYMITY-message.

Parameters
clsclient identification of the client
msgthe actual message

Definition at line 957 of file gnunet-service-datastore.c.

958{
959 struct GNUNET_SERVICE_Client *client = cls;
961
962 type = ntohl (msg->type);
964 {
965 GNUNET_break (0);
967 return;
968 }
970 "Processing GET_ZERO_ANONYMITY request\n");
973 "# GET ZERO ANONYMITY requests received"),
974 1,
975 GNUNET_NO);
977 GNUNET_ntohll (msg->next_uid),
978 type,
980 client);
982}

References DatastorePlugin::api, GNUNET_DATASTORE_PluginFunctions::cls, GNUNET_DATASTORE_PluginFunctions::get_zero_anonymity, gettext_noop, GNUNET_BLOCK_TYPE_ANY, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_ntohll(), GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), GNUNET_STATISTICS_update(), msg, plugin, stats, transmit_item(), type, and GNUNET_MessageHeader::type.

Here is the call graph for this function:

◆ remove_continuation()

static void remove_continuation ( void *  cls,
const struct GNUNET_HashCode key,
uint32_t  size,
int  status,
const char *  msg 
)
static

Remove continuation.

Parameters
clsclosure
keykey for the content
sizenumber of bytes in data
statusGNUNET_OK if removed, GNUNET_NO if not found, or #GNUNET_SYSERROR if error
msgerror message on error

Definition at line 996 of file gnunet-service-datastore.c.

1001{
1002 struct GNUNET_SERVICE_Client *client = cls;
1003
1004 if (GNUNET_SYSERR == status)
1005 {
1006 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "REMOVE request failed: %s.\n", msg);
1007 transmit_status (client, GNUNET_NO, msg);
1008 return;
1009 }
1010 if (GNUNET_NO == status)
1011 {
1013 "Content not found for REMOVE request.\n");
1014 transmit_status (client, GNUNET_NO, _ ("Content not found"));
1015 return;
1016 }
1018 "Item matches REMOVE request for key `%s'.\n",
1019 GNUNET_h2s (key));
1021 gettext_noop ("# bytes removed (explicit request)"),
1022 size,
1023 GNUNET_YES);
1025 transmit_status (client, GNUNET_OK, NULL);
1026}

References _, filter, gettext_noop, GNUNET_CONTAINER_bloomfilter_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_h2s(), GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_YES, key, msg, size, stats, status, and transmit_status().

Referenced by handle_remove().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ check_remove()

static int check_remove ( void *  cls,
const struct DataMessage dm 
)
static

Verify REMOVE-message.

Parameters
clsidentification of the client
dmthe actual message
Returns
GNUNET_OK if dm is well-formed

Definition at line 1037 of file gnunet-service-datastore.c.

1038{
1039 if (GNUNET_OK != check_data (dm))
1040 {
1041 GNUNET_break (0);
1042 return GNUNET_SYSERR;
1043 }
1044 return GNUNET_OK;
1045}

References check_data(), GNUNET_break, GNUNET_OK, and GNUNET_SYSERR.

Here is the call graph for this function:

◆ handle_remove()

static void handle_remove ( void *  cls,
const struct DataMessage dm 
)
static

Handle REMOVE-message.

Parameters
clsclosure
dmthe actual message

Definition at line 1055 of file gnunet-service-datastore.c.

1056{
1057 struct GNUNET_SERVICE_Client *client = cls;
1058
1060 gettext_noop ("# REMOVE requests received"),
1061 1,
1062 GNUNET_NO);
1064 "Processing REMOVE request for `%s'\n",
1065 GNUNET_h2s (&dm->key));
1067 &dm->key,
1068 ntohl (dm->size),
1069 &dm[1],
1071 client);
1073}

References DatastorePlugin::api, GNUNET_DATASTORE_PluginFunctions::cls, gettext_noop, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_NO, GNUNET_SERVICE_client_continue(), GNUNET_STATISTICS_update(), DataMessage::key, plugin, remove_continuation(), GNUNET_DATASTORE_PluginFunctions::remove_key, DataMessage::size, and stats.

Here is the call graph for this function:

◆ handle_drop()

static void handle_drop ( void *  cls,
const struct GNUNET_MessageHeader message 
)
static

Handle DROP-message.

Parameters
clsidentification of the client
messagethe actual message

Definition at line 1083 of file gnunet-service-datastore.c.

1085{
1086 struct GNUNET_SERVICE_Client *client = cls;
1087
1089 "Processing DROP request\n");
1092}

References do_drop, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_SERVICE_client_continue(), and GNUNET_YES.

Here is the call graph for this function:

◆ disk_utilization_change_cb()

static void disk_utilization_change_cb ( void *  cls,
int  delta 
)
static

Function called by plugins to notify us about a change in their disk utilization.

Parameters
clsclosure (NULL)
deltachange in disk utilization, 0 for "reset to empty"

Definition at line 1104 of file gnunet-service-datastore.c.

1105{
1106 if ((delta < 0) && (payload < -delta))
1107 {
1108 GNUNET_log (
1110 _ (
1111 "Datastore payload must have been inaccurate (%lld < %lld). Recomputing it.\n"),
1112 (long long) payload,
1113 (long long) -delta);
1116 _ ("New payload: %lld\n"),
1117 (long long) payload);
1118 sync_stats ();
1119 return;
1120 }
1121 payload += delta;
1122 last_sync++;
1124 sync_stats ();
1125}

References _, DatastorePlugin::api, GNUNET_DATASTORE_PluginFunctions::cls, delta, GNUNET_DATASTORE_PluginFunctions::estimate_size, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, last_sync, MAX_STAT_SYNC_LAG, payload, plugin, and sync_stats().

Referenced by load_plugin().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ process_stat_in()

static int process_stat_in ( void *  cls,
const char *  subsystem,
const char *  name,
uint64_t  value,
int  is_persistent 
)
static

Callback function to process statistic values.

Parameters
clsclosure (struct Plugin*)
subsystemname of subsystem that created the statistic
namethe name of the datum
valuethe current value
is_persistentGNUNET_YES if the value is persistent, GNUNET_NO if not
Returns
GNUNET_OK to continue, GNUNET_SYSERR to abort iteration

Definition at line 1139 of file gnunet-service-datastore.c.

1144{
1147 payload += value;
1148 GNUNET_log (
1150 "Notification from statistics about existing payload (%llu), new payload is %llu\n",
1151 (unsigned long long) value,
1152 (unsigned long long) payload);
1153 return GNUNET_OK;
1154}

References GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_YES, payload, stats_worked, and value.

Referenced by run().

Here is the caller graph for this function:

◆ load_plugin()

static struct DatastorePlugin * load_plugin ( )
static

Load the datastore plugin.

Definition at line 1161 of file gnunet-service-datastore.c.

1162{
1163 struct DatastorePlugin *ret;
1164 char *libname;
1165
1166 ret = GNUNET_new (struct DatastorePlugin);
1167 ret->env.cfg = cfg;
1168 ret->env.duc = &disk_utilization_change_cb;
1169 ret->env.cls = NULL;
1171 _ ("Loading `%s' datastore plugin\n"),
1172 plugin_name);
1173 GNUNET_asprintf (&libname,
1174 "libgnunet_plugin_datastore_%s",
1175 plugin_name);
1176 ret->short_name = GNUNET_strdup (plugin_name);
1177 ret->lib_name = libname;
1179 libname,
1180 &ret->env);
1181 if (NULL == ret->api)
1182 {
1184 _ ("Failed to load datastore plugin for `%s'\n"),
1185 plugin_name);
1186 GNUNET_free (ret->short_name);
1187 GNUNET_free (libname);
1188 GNUNET_free (ret);
1189 return NULL;
1190 }
1191 return ret;
1192}

References _, cfg, disk_utilization_change_cb(), GNUNET_asprintf(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_new, GNUNET_OS_project_data_gnunet(), GNUNET_PLUGIN_load(), GNUNET_strdup, plugin_name, and ret.

Referenced by process_stat_done().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ unload_plugin()

static void unload_plugin ( struct DatastorePlugin plug)
static

Function called when the service shuts down.

Unloads our datastore plugin.

Parameters
plugplugin to unload

Definition at line 1202 of file gnunet-service-datastore.c.

1203{
1205 "Datastore service is unloading plugin...\n");
1206 GNUNET_break (NULL == GNUNET_PLUGIN_unload (plug->lib_name, plug->api));
1207 GNUNET_free (plug->lib_name);
1208 GNUNET_free (plug->short_name);
1209 GNUNET_free (plug);
1210}

References DatastorePlugin::api, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_PLUGIN_unload(), DatastorePlugin::lib_name, and DatastorePlugin::short_name.

Referenced by cleaning_task().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ begin_service()

static void begin_service ( )
static

Initialization complete, start operating the service.

Definition at line 1217 of file gnunet-service-datastore.c.

References delete_expired(), expired_kill_task, GNUNET_SCHEDULER_add_with_priority(), GNUNET_SCHEDULER_PRIORITY_IDLE, GNUNET_SERVICE_resume(), and service.

Referenced by add_key_to_bloomfilter(), and process_stat_done().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ add_key_to_bloomfilter()

static void add_key_to_bloomfilter ( void *  cls,
const struct GNUNET_HashCode key,
unsigned int  count 
)
static

Adds a given key to the bloomfilter in cls count times.

Parameters
clsthe bloomfilter
keykey to add
countnumber of times to add key

Definition at line 1235 of file gnunet-service-datastore.c.

1238{
1239 struct GNUNET_CONTAINER_BloomFilter *bf = cls;
1240
1241 if (NULL == key)
1242 {
1244 _ ("Bloomfilter construction complete.\n"));
1245 begin_service ();
1246 return;
1247 }
1248
1249 while (0 < count--)
1251}

References _, begin_service(), GNUNET_CONTAINER_bloomfilter_add(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, and key.

Referenced by process_stat_done().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ process_stat_done()

static void process_stat_done ( void *  cls,
int  success 
)
static

We finished receiving the statistic.

Initialize the plugin; if loading the statistic failed, run the estimator.

Parameters
clsNULL
successGNUNET_NO if we failed to read the stat

Definition at line 1262 of file gnunet-service-datastore.c.

1263{
1264 stat_get = NULL;
1265 if (NULL != stat_timeout_task)
1266 {
1268 stat_timeout_task = NULL;
1269 }
1270 plugin = load_plugin ();
1271 if (NULL == plugin)
1272 {
1274 filter = NULL;
1275 if (NULL != stats)
1276 {
1278 stats = NULL;
1279 }
1280 return;
1281 }
1282
1283 if (GNUNET_NO == stats_worked)
1284 {
1286 "Failed to obtain value from statistics service, recomputing it\n");
1289 _ ("New payload: %lld\n"),
1290 (long long) payload);
1291 }
1292
1293 if (GNUNET_YES == refresh_bf)
1294 {
1296 _ ("Rebuilding bloomfilter. Please be patient.\n"));
1297 if (NULL != plugin->api->get_keys)
1298 {
1300 return;
1301 }
1302 else
1303 {
1305 _ (
1306 "Plugin does not support get_keys function. Please fix!\n"))
1307 ;
1308 }
1309 }
1310 begin_service ();
1311}

References _, add_key_to_bloomfilter(), DatastorePlugin::api, begin_service(), GNUNET_DATASTORE_PluginFunctions::cls, GNUNET_DATASTORE_PluginFunctions::estimate_size, filter, GNUNET_DATASTORE_PluginFunctions::get_keys, GNUNET_CONTAINER_bloomfilter_free(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_destroy(), GNUNET_YES, load_plugin(), payload, plugin, refresh_bf, stat_get, stat_timeout_task, stats, and stats_worked.

Referenced by run(), and stat_timeout().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ stat_timeout()

static void stat_timeout ( void *  cls)
static

Fetching stats took to long, run without.

Parameters
clsNULL

Definition at line 1320 of file gnunet-service-datastore.c.

1321{
1322 stat_timeout_task = NULL;
1325}

References GNUNET_NO, GNUNET_STATISTICS_get_cancel(), process_stat_done(), stat_get, and stat_timeout_task.

Referenced by run().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ cleaning_task()

static void cleaning_task ( void *  cls)
static

Task run during shutdown.

Definition at line 1332 of file gnunet-service-datastore.c.

1333{
1335 if (NULL != expired_kill_task)
1336 {
1338 expired_kill_task = NULL;
1339 }
1340 if (GNUNET_YES == do_drop)
1341 {
1343 "Dropping database!\n");
1344 plugin->api->drop (plugin->api->cls);
1345 payload = 0;
1346 last_sync++;
1347 }
1348 if (NULL != plugin)
1349 {
1351 plugin = NULL;
1352 }
1353 if (NULL != filter)
1354 {
1356 filter = NULL;
1357 }
1358 if (NULL != stat_get)
1359 {
1361 stat_get = NULL;
1362 }
1363 if (NULL != stat_timeout_task)
1364 {
1366 stat_timeout_task = NULL;
1367 }
1369 plugin_name = NULL;
1370 if (last_sync > 0)
1371 sync_stats ();
1372 if (NULL != stats)
1373 {
1375 stats = NULL;
1376 }
1378 quota_stat_name = NULL;
1379}

References DatastorePlugin::api, cleaning_done, GNUNET_DATASTORE_PluginFunctions::cls, do_drop, GNUNET_DATASTORE_PluginFunctions::drop, expired_kill_task, filter, GNUNET_CONTAINER_bloomfilter_free(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_destroy(), GNUNET_STATISTICS_get_cancel(), GNUNET_YES, last_sync, payload, plugin, plugin_name, quota_stat_name, stat_get, stat_timeout_task, stats, sync_stats(), and unload_plugin().

Referenced by run().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ client_connect_cb()

static void * client_connect_cb ( void *  cls,
struct GNUNET_SERVICE_Client client,
struct GNUNET_MQ_Handle mq 
)
static

Add a client to our list of active clients.

Parameters
clsNULL
clientclient to add
mqmessage queue for client
Returns
client

Definition at line 1391 of file gnunet-service-datastore.c.

1394{
1395 return client;
1396}

◆ client_disconnect_cb()

static void client_disconnect_cb ( void *  cls,
struct GNUNET_SERVICE_Client client,
void *  app_ctx 
)
static

Called whenever a client is disconnected.

Frees our resources associated with that client.

Parameters
clsclosure
clientidentification of the client
app_ctxmust match client

Definition at line 1408 of file gnunet-service-datastore.c.

1411{
1412 struct ReservationList *pos;
1413 struct ReservationList *prev;
1414 struct ReservationList *next;
1415
1416 GNUNET_assert (app_ctx == client);
1417 prev = NULL;
1418 pos = reservations;
1419 while (NULL != pos)
1420 {
1421 next = pos->next;
1422 if (pos->client == client)
1423 {
1424 if (NULL == prev)
1426 else
1427 prev->next = next;
1429 GNUNET_free (pos);
1430 }
1431 else
1432 {
1433 prev = pos;
1434 }
1435 pos = next;
1436 }
1438 gettext_noop ("# reserved"),
1439 reserved,
1440 GNUNET_NO);
1441}

References ReservationList::amount, ReservationList::client, ReservationList::entries, gettext_noop, GNUNET_assert, GNUNET_DATASTORE_ENTRY_OVERHEAD, GNUNET_free, GNUNET_NO, GNUNET_STATISTICS_set(), ReservationList::next, reservations, reserved, and stats.

Here is the call graph for this function:

◆ run()

static void run ( void *  cls,
const struct GNUNET_CONFIGURATION_Handle c,
struct GNUNET_SERVICE_Handle serv 
)
static

Process datastore requests.

Parameters
clsclosure
servthe initialized service
cconfiguration to use

Definition at line 1452 of file gnunet-service-datastore.c.

1455{
1456 char *fn;
1457 char *pfn;
1458 unsigned int bf_size;
1459
1460 service = serv;
1461 cfg = c;
1463 "DATASTORE",
1464 "DATABASE",
1465 &plugin_name))
1466 {
1468 "DATABASE",
1469 "DATASTORE");
1470 return;
1471 }
1473 _ ("# bytes used in file-sharing datastore `%s'"),
1474 plugin_name);
1475 if (GNUNET_OK !=
1476 GNUNET_CONFIGURATION_get_value_size (cfg, "DATASTORE", "QUOTA", &quota))
1477 {
1478 GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "QUOTA", "DATASTORE");
1479 return;
1480 }
1481 stats = GNUNET_STATISTICS_create ("datastore", cfg);
1483 cache_size = quota / 8; /* Or should we make this an option? */
1485 gettext_noop ("# cache size"),
1486 cache_size,
1487 GNUNET_NO);
1488 if (quota / (32 * 1024LL) > MAX_BF_SIZE)
1489 bf_size = MAX_BF_SIZE;
1490 else
1491 bf_size =
1492 quota / (32 * 1024LL); /* 8 bit per entry, 1 bit per 32 kb in DB */
1493 fn = NULL;
1495 "DATASTORE",
1496 "BLOOMFILTER",
1497 &fn)) ||
1499 {
1501 _ ("Could not use specified filename `%s' for bloomfilter.\n"),
1502 NULL != fn ? fn : "");
1503 GNUNET_free (fn);
1504 fn = NULL;
1505 }
1506 if (NULL != fn)
1507 {
1508 GNUNET_asprintf (&pfn, "%s.%s", fn, plugin_name);
1509 if (GNUNET_YES == GNUNET_DISK_file_test (pfn))
1510 {
1511 filter =
1513 bf_size,
1514 5); /* approx. 3% false positives at max use */
1515 if (NULL == filter)
1516 {
1517 /* file exists but not valid, remove and try again, but refresh */
1518 if (0 != unlink (pfn))
1519 {
1520 /* failed to remove, run without file */
1522 _ ("Failed to remove bogus bloomfilter file `%s'\n"),
1523 pfn);
1524 GNUNET_free (pfn);
1525 pfn = NULL;
1527 NULL,
1528 bf_size,
1529 5); /* approx. 3% false positives at max use */
1531 }
1532 else
1533 {
1534 /* try again after remove */
1536 pfn,
1537 bf_size,
1538 5); /* approx. 3% false positives at max use */
1540 if (NULL == filter)
1541 {
1542 /* failed yet again, give up on using file */
1544 _ ("Failed to remove bogus bloomfilter file `%s'\n"),
1545 pfn);
1546 GNUNET_free (pfn);
1547 pfn = NULL;
1549 NULL,
1550 bf_size,
1551 5); /* approx. 3% false positives at max use */
1552 }
1553 }
1554 }
1555 else
1556 {
1557 /* normal case: have an existing valid bf file, no need to refresh */
1559 }
1560 }
1561 else
1562 {
1563 filter =
1565 bf_size,
1566 5); /* approx. 3% false positives at max use */
1568 }
1569 GNUNET_free (pfn);
1570 }
1571 else
1572 {
1573 filter =
1575 bf_size,
1576 5); /* approx. 3% false positives at max use */
1578 }
1579 GNUNET_free (fn);
1580 if (NULL == filter)
1581 {
1583 _ ("Failed to initialize bloomfilter.\n"));
1584 if (NULL != stats)
1585 {
1587 stats = NULL;
1588 }
1589 return;
1590 }
1593 "datastore",
1597 NULL);
1598 if (NULL == stat_get)
1600 else
1602 &stat_timeout,
1603 NULL);
1605}

References _, cache_size, cfg, cleaning_task(), filter, gettext_noop, GNUNET_asprintf(), GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_size(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONTAINER_bloomfilter_init(), GNUNET_CONTAINER_bloomfilter_load(), GNUNET_DISK_directory_create_for_file(), GNUNET_DISK_file_test(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_log_config_missing(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SERVICE_suspend(), GNUNET_STATISTICS_create(), GNUNET_STATISTICS_destroy(), GNUNET_STATISTICS_get(), GNUNET_STATISTICS_set(), GNUNET_SYSERR, GNUNET_TIME_UNIT_SECONDS, GNUNET_YES, MAX_BF_SIZE, plugin_name, process_stat_done(), process_stat_in(), quota, quota_stat_name, refresh_bf, service, stat_get, stat_timeout(), stat_timeout_task, and stats.

Here is the call graph for this function:

◆ GNUNET_SERVICE_MAIN()

Variable Documentation

◆ quota_stat_name

char* quota_stat_name
static

Name under which we store current space consumption.

Definition at line 61 of file gnunet-service-datastore.c.

Referenced by cleaning_task(), run(), and sync_stats().

◆ stat_timeout_task

struct GNUNET_SCHEDULER_Task* stat_timeout_task
static

Task to timeout stat GET.

Definition at line 66 of file gnunet-service-datastore.c.

Referenced by cleaning_task(), GNUNET_HOSTLIST_client_start(), process_stat_done(), run(), and stat_timeout().

◆ plugin

◆ reservations

struct ReservationList* reservations
static

Linked list of space reservations made by clients.

Definition at line 144 of file gnunet-service-datastore.c.

Referenced by client_disconnect_cb(), handle_put(), handle_release_reserve(), and handle_reserve().

◆ filter

◆ plugin_name

char* plugin_name
static

Name of our plugin.

Definition at line 154 of file gnunet-service-datastore.c.

Referenced by cleaning_task(), load_plugin(), and run().

◆ cfg

const struct GNUNET_CONFIGURATION_Handle* cfg
static

Our configuration.

Definition at line 159 of file gnunet-service-datastore.c.

Referenced by load_plugin(), and run().

◆ stats

◆ cache_size

unsigned long long cache_size
static

How much space are we using for the cache? (space available for insertions that will be instantly reclaimed by discarding less important content — or possibly whatever we just inserted into the "cache").

Definition at line 172 of file gnunet-service-datastore.c.

Referenced by handle_reserve(), put_continuation(), and run().

◆ reserved

unsigned long long reserved
static

How much space have we currently reserved?

Definition at line 177 of file gnunet-service-datastore.c.

Referenced by client_disconnect_cb(), handle_put(), handle_release_reserve(), handle_reserve(), and put_continuation().

◆ payload

◆ expired_kill_task

struct GNUNET_SCHEDULER_Task* expired_kill_task
static

Identity of the task that is used to delete expired content.

Definition at line 189 of file gnunet-service-datastore.c.

Referenced by begin_service(), cleaning_task(), delete_expired(), and expired_processor().

◆ min_expiration

struct GNUNET_TIME_Absolute min_expiration
static

Minimum time that content should have to not be discarded instantly (time stamp of any content that we've been discarding recently to stay below the quota).

FOREVER if we had to expire content with non-zero priority.

Definition at line 197 of file gnunet-service-datastore.c.

Referenced by expired_processor(), put_migration_continuation(), quota_processor(), and transmit_status().

◆ quota

unsigned long long quota
static

How much space are we allowed to use?

Definition at line 202 of file gnunet-service-datastore.c.

Referenced by GNUNET_DATACACHE_create(), handle_reserve(), put_continuation(), and run().

◆ do_drop

int do_drop
static

Should the database be dropped on exit?

Definition at line 207 of file gnunet-service-datastore.c.

Referenced by cleaning_task(), and handle_drop().

◆ refresh_bf

int refresh_bf
static

Should we refresh the BF when the DB is loaded?

Definition at line 212 of file gnunet-service-datastore.c.

Referenced by process_stat_done(), and run().

◆ last_sync

unsigned int last_sync
static

Number of updates that were made to the payload value since we last synchronized it with the statistics service.

Definition at line 219 of file gnunet-service-datastore.c.

Referenced by cleaning_task(), disk_utilization_change_cb(), and sync_stats().

◆ stats_worked

int stats_worked
static

Did we get an answer from statistics?

Definition at line 224 of file gnunet-service-datastore.c.

Referenced by process_stat_done(), and process_stat_in().

◆ cleaning_done

int cleaning_done
static

Have we already cleaned up the TCCs and are hence no longer willing (or able) to transmit anything to anyone?

Definition at line 247 of file gnunet-service-datastore.c.

Referenced by cleaning_task().

◆ stat_get

struct GNUNET_STATISTICS_GetHandle* stat_get
static

Handle for pending get request.

Definition at line 252 of file gnunet-service-datastore.c.

Referenced by cleaning_task(), process_stat_done(), run(), and stat_timeout().

◆ service

struct GNUNET_SERVICE_Handle* service
static

Handle to our server.

Definition at line 257 of file gnunet-service-datastore.c.

Referenced by begin_service(), and run().