GNUnet 0.21.0
gnunet-service-datastore.c
Go to the documentation of this file.
1/*
2 This file is part of GNUnet
3 Copyright (C) 2004-2014, 2016 GNUnet e.V.
4
5 GNUnet is free software: you can redistribute it and/or modify it
6 under the terms of the GNU Affero General Public License as published
7 by the Free Software Foundation, either version 3 of the License,
8 or (at your option) any later version.
9
10 GNUnet is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Affero General Public License for more details.
14
15 You should have received a copy of the GNU Affero General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>.
17
18 SPDX-License-Identifier: AGPL3.0-or-later
19 */
20
27#include "platform.h"
28#include "gnunet_util_lib.h"
29#include "gnunet_protocols.h"
32#include "datastore.h"
33
37#define MAX_PENDING 1024
38
42#define MAX_BF_SIZE ((uint32_t) (1LL << 31))
43
48#define MAX_EXPIRE_DELAY \
49 GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
50
55#define MIN_EXPIRE_DELAY \
56 GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 1)
57
61static char *quota_stat_name;
62
67
72#define MAX_STAT_SYNC_LAG 50
73
74
79{
85
90
94 char *lib_name;
95
101};
102
103
108{
113
118
122 uint64_t amount;
123
127 uint64_t entries;
128
132 int32_t rid;
133};
134
135
139static struct DatastorePlugin *plugin;
140
145
150
154static char *plugin_name;
155
159static const struct GNUNET_CONFIGURATION_Handle *cfg;
160
165
172static unsigned long long cache_size;
173
177static unsigned long long reserved;
178
183static unsigned long long payload;
184
190
198
202static unsigned long long quota;
203
207static int do_drop;
208
212static int refresh_bf;
213
219static unsigned int last_sync;
220
224static int stats_worked;
225
226
231static void
233{
236 "# utilization by current datastore",
237 payload,
238 GNUNET_NO);
239 last_sync = 0;
240}
241
242
247static int cleaning_done;
248
253
258
267static void
268delete_expired (void *cls);
269
270
292static int
294 const struct GNUNET_HashCode *key,
295 uint32_t size,
296 const void *data,
298 uint32_t priority,
299 uint32_t anonymity,
300 uint32_t replication,
302 uint64_t uid)
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}
346
347
356static void
357delete_expired (void *cls)
358{
359 expired_kill_task = NULL;
361}
362
363
383static int
385 const struct GNUNET_HashCode *key,
386 uint32_t size,
387 const void *data,
389 uint32_t priority,
390 uint32_t anonymity,
391 uint32_t replication,
393 uint64_t uid)
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}
425
426
439static void
440manage_space (unsigned long long need)
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}
454
455
463static void
465 int code,
466 const char *msg)
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}
484
485
504static int
505transmit_item (void *cls,
506 const struct GNUNET_HashCode *key,
507 uint32_t size,
508 const void *data,
510 uint32_t priority,
511 uint32_t anonymity,
512 uint32_t replication,
514 uint64_t uid)
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}
557
558
565static void
566handle_reserve (void *cls, const struct ReserveMessage *msg)
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}
641
642
649static void
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}
696
697
704static int
705check_data (const struct DataMessage *dm)
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}
719
720
731static void
733 const struct GNUNET_HashCode *key,
734 uint32_t size,
735 int status,
736 const char *msg)
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}
765
766
774static int
775check_put (void *cls, const struct DataMessage *dm)
776{
777 if (GNUNET_OK != check_data (dm))
778 {
779 GNUNET_break (0);
780 return GNUNET_SYSERR;
781 }
782 return GNUNET_OK;
783}
784
785
792static void
793handle_put (void *cls, const struct DataMessage *dm)
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 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);
840}
841
842
849static void
850handle_get (void *cls, const struct GetMessage *msg)
851{
852 struct GNUNET_SERVICE_Client *client = cls;
853
855 "Processing GET request of type %u\n",
856 (uint32_t) ntohl (msg->type));
858 gettext_noop ("# GET requests received"),
859 1,
860 GNUNET_NO);
862 GNUNET_ntohll (msg->next_uid),
863 msg->random,
864 NULL,
865 ntohl (msg->type),
867 client);
869}
870
871
878static void
879handle_get_key (void *cls, const struct GetKeyMessage *msg)
880{
881 struct GNUNET_SERVICE_Client *client = cls;
882
884 "Processing GET request for `%s' of type %u\n",
885 GNUNET_h2s (&msg->key),
886 (uint32_t) ntohl (msg->type));
888 gettext_noop ("# GET KEY requests received"),
889 1,
890 GNUNET_NO);
892 {
893 /* don't bother database... */
895 "Empty result set for GET request for `%s' (bloomfilter).\n",
896 GNUNET_h2s (&msg->key));
899 "# requests filtered by bloomfilter"),
900 1,
901 GNUNET_NO);
902 transmit_item (client,
903 NULL,
904 0,
905 NULL,
906 0,
907 0,
908 0,
909 0,
911 0);
913 return;
914 }
916 GNUNET_ntohll (msg->next_uid),
917 msg->random,
918 &msg->key,
919 ntohl (msg->type),
921 client);
923}
924
925
932static void
933handle_get_replication (void *cls, const struct GNUNET_MessageHeader *message)
934{
935 struct GNUNET_SERVICE_Client *client = cls;
936
937 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Processing GET_REPLICATION request\n");
940 "# GET REPLICATION requests received"),
941 1,
942 GNUNET_NO);
945}
946
947
954static void
956{
957 struct GNUNET_SERVICE_Client *client = cls;
959
960 type = (enum GNUNET_BLOCK_Type) ntohl (msg->type);
962 {
963 GNUNET_break (0);
965 return;
966 }
968 "Processing GET_ZERO_ANONYMITY request\n");
971 "# GET ZERO ANONYMITY requests received"),
972 1,
973 GNUNET_NO);
975 GNUNET_ntohll (msg->next_uid),
976 type,
978 client);
980}
981
982
993static void
995 const struct GNUNET_HashCode *key,
996 uint32_t size,
997 int status,
998 const char *msg)
999{
1000 struct GNUNET_SERVICE_Client *client = cls;
1001
1002 if (GNUNET_SYSERR == status)
1003 {
1004 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "REMOVE request failed: %s.\n", msg);
1005 transmit_status (client, GNUNET_NO, msg);
1006 return;
1007 }
1008 if (GNUNET_NO == status)
1009 {
1011 "Content not found for REMOVE request.\n");
1012 transmit_status (client, GNUNET_NO, _ ("Content not found"));
1013 return;
1014 }
1016 "Item matches REMOVE request for key `%s'.\n",
1017 GNUNET_h2s (key));
1019 gettext_noop ("# bytes removed (explicit request)"),
1020 size,
1021 GNUNET_YES);
1023 transmit_status (client, GNUNET_OK, NULL);
1024}
1025
1026
1034static int
1035check_remove (void *cls, const struct DataMessage *dm)
1036{
1037 if (GNUNET_OK != check_data (dm))
1038 {
1039 GNUNET_break (0);
1040 return GNUNET_SYSERR;
1041 }
1042 return GNUNET_OK;
1043}
1044
1045
1052static void
1053handle_remove (void *cls, const struct DataMessage *dm)
1054{
1055 struct GNUNET_SERVICE_Client *client = cls;
1056
1058 gettext_noop ("# REMOVE requests received"),
1059 1,
1060 GNUNET_NO);
1062 "Processing REMOVE request for `%s'\n",
1063 GNUNET_h2s (&dm->key));
1065 &dm->key,
1066 ntohl (dm->size),
1067 &dm[1],
1069 client);
1071}
1072
1073
1080static void
1081handle_drop (void *cls,
1082 const struct GNUNET_MessageHeader *message)
1083{
1084 struct GNUNET_SERVICE_Client *client = cls;
1085
1087 "Processing DROP request\n");
1090}
1091
1092
1101static void
1103{
1104 if ((delta < 0) && (payload < -delta))
1105 {
1106 GNUNET_log (
1108 _ (
1109 "Datastore payload must have been inaccurate (%lld < %lld). Recomputing it.\n"),
1110 (long long) payload,
1111 (long long) -delta);
1114 _ ("New payload: %lld\n"),
1115 (long long) payload);
1116 sync_stats ();
1117 return;
1118 }
1119 payload += delta;
1120 last_sync++;
1122 sync_stats ();
1123}
1124
1125
1136static int
1138 const char *subsystem,
1139 const char *name,
1140 uint64_t value,
1141 int is_persistent)
1142{
1145 payload += value;
1146 GNUNET_log (
1148 "Notification from statistics about existing payload (%llu), new payload is %llu\n",
1149 (unsigned long long) value,
1150 (unsigned long long) payload);
1151 return GNUNET_OK;
1152}
1153
1154
1158static struct DatastorePlugin *
1160{
1161 struct DatastorePlugin *ret;
1162 char *libname;
1163
1164 ret = GNUNET_new (struct DatastorePlugin);
1165 ret->env.cfg = cfg;
1166 ret->env.duc = &disk_utilization_change_cb;
1167 ret->env.cls = NULL;
1169 _ ("Loading `%s' datastore plugin\n"),
1170 plugin_name);
1171 GNUNET_asprintf (&libname, "libgnunet_plugin_datastore_%s", plugin_name);
1172 ret->short_name = GNUNET_strdup (plugin_name);
1173 ret->lib_name = libname;
1174 ret->api = GNUNET_PLUGIN_load (libname, &ret->env);
1175 if (NULL == ret->api)
1176 {
1178 _ ("Failed to load datastore plugin for `%s'\n"),
1179 plugin_name);
1180 GNUNET_free (ret->short_name);
1181 GNUNET_free (libname);
1182 GNUNET_free (ret);
1183 return NULL;
1184 }
1185 return ret;
1186}
1187
1188
1195static void
1197{
1199 "Datastore service is unloading plugin...\n");
1200 GNUNET_break (NULL == GNUNET_PLUGIN_unload (plug->lib_name, plug->api));
1201 GNUNET_free (plug->lib_name);
1202 GNUNET_free (plug->short_name);
1203 GNUNET_free (plug);
1204}
1205
1206
1210static void
1212{
1217 NULL);
1218}
1219
1220
1228static void
1230 const struct GNUNET_HashCode *key,
1231 unsigned int count)
1232{
1233 struct GNUNET_CONTAINER_BloomFilter *bf = cls;
1234
1235 if (NULL == key)
1236 {
1238 _ ("Bloomfilter construction complete.\n"));
1239 begin_service ();
1240 return;
1241 }
1242
1243 while (0 < count--)
1245}
1246
1247
1255static void
1256process_stat_done (void *cls, int success)
1257{
1258 stat_get = NULL;
1259 if (NULL != stat_timeout_task)
1260 {
1262 stat_timeout_task = NULL;
1263 }
1264 plugin = load_plugin ();
1265 if (NULL == plugin)
1266 {
1268 filter = NULL;
1269 if (NULL != stats)
1270 {
1272 stats = NULL;
1273 }
1274 return;
1275 }
1276
1277 if (GNUNET_NO == stats_worked)
1278 {
1280 "Failed to obtain value from statistics service, recomputing it\n");
1283 _ ("New payload: %lld\n"),
1284 (long long) payload);
1285 }
1286
1287 if (GNUNET_YES == refresh_bf)
1288 {
1290 _ ("Rebuilding bloomfilter. Please be patient.\n"));
1291 if (NULL != plugin->api->get_keys)
1292 {
1294 return;
1295 }
1296 else
1297 {
1299 _ (
1300 "Plugin does not support get_keys function. Please fix!\n"));
1301 }
1302 }
1303 begin_service ();
1304}
1305
1306
1312static void
1313stat_timeout (void *cls)
1314{
1315 stat_timeout_task = NULL;
1318}
1319
1320
1324static void
1325cleaning_task (void *cls)
1326{
1328 if (NULL != expired_kill_task)
1329 {
1331 expired_kill_task = NULL;
1332 }
1333 if (GNUNET_YES == do_drop)
1334 {
1336 "Dropping database!\n");
1337 plugin->api->drop (plugin->api->cls);
1338 payload = 0;
1339 last_sync++;
1340 }
1341 if (NULL != plugin)
1342 {
1344 plugin = NULL;
1345 }
1346 if (NULL != filter)
1347 {
1349 filter = NULL;
1350 }
1351 if (NULL != stat_get)
1352 {
1354 stat_get = NULL;
1355 }
1356 if (NULL != stat_timeout_task)
1357 {
1359 stat_timeout_task = NULL;
1360 }
1362 plugin_name = NULL;
1363 if (last_sync > 0)
1364 sync_stats ();
1365 if (NULL != stats)
1366 {
1368 stats = NULL;
1369 }
1371 quota_stat_name = NULL;
1372}
1373
1374
1383static void *
1385 struct GNUNET_SERVICE_Client *client,
1386 struct GNUNET_MQ_Handle *mq)
1387{
1388 return client;
1389}
1390
1391
1400static void
1402 struct GNUNET_SERVICE_Client *client,
1403 void *app_ctx)
1404{
1405 struct ReservationList *pos;
1406 struct ReservationList *prev;
1407 struct ReservationList *next;
1408
1409 GNUNET_assert (app_ctx == client);
1410 prev = NULL;
1411 pos = reservations;
1412 while (NULL != pos)
1413 {
1414 next = pos->next;
1415 if (pos->client == client)
1416 {
1417 if (NULL == prev)
1419 else
1420 prev->next = next;
1422 GNUNET_free (pos);
1423 }
1424 else
1425 {
1426 prev = pos;
1427 }
1428 pos = next;
1429 }
1431 gettext_noop ("# reserved"),
1432 reserved,
1433 GNUNET_NO);
1434}
1435
1436
1444static void
1445run (void *cls,
1446 const struct GNUNET_CONFIGURATION_Handle *c,
1447 struct GNUNET_SERVICE_Handle *serv)
1448{
1449 char *fn;
1450 char *pfn;
1451 unsigned int bf_size;
1452
1453 service = serv;
1454 cfg = c;
1456 "DATASTORE",
1457 "DATABASE",
1458 &plugin_name))
1459 {
1461 "DATABASE",
1462 "DATASTORE");
1463 return;
1464 }
1466 _ ("# bytes used in file-sharing datastore `%s'"),
1467 plugin_name);
1468 if (GNUNET_OK !=
1469 GNUNET_CONFIGURATION_get_value_size (cfg, "DATASTORE", "QUOTA", &quota))
1470 {
1471 GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "QUOTA", "DATASTORE");
1472 return;
1473 }
1474 stats = GNUNET_STATISTICS_create ("datastore", cfg);
1476 cache_size = quota / 8; /* Or should we make this an option? */
1478 gettext_noop ("# cache size"),
1479 cache_size,
1480 GNUNET_NO);
1481 if (quota / (32 * 1024LL) > MAX_BF_SIZE)
1482 bf_size = MAX_BF_SIZE;
1483 else
1484 bf_size =
1485 quota / (32 * 1024LL); /* 8 bit per entry, 1 bit per 32 kb in DB */
1486 fn = NULL;
1488 "DATASTORE",
1489 "BLOOMFILTER",
1490 &fn)) ||
1492 {
1494 _ ("Could not use specified filename `%s' for bloomfilter.\n"),
1495 NULL != fn ? fn : "");
1496 GNUNET_free (fn);
1497 fn = NULL;
1498 }
1499 if (NULL != fn)
1500 {
1501 GNUNET_asprintf (&pfn, "%s.%s", fn, plugin_name);
1502 if (GNUNET_YES == GNUNET_DISK_file_test (pfn))
1503 {
1504 filter =
1506 bf_size,
1507 5); /* approx. 3% false positives at max use */
1508 if (NULL == filter)
1509 {
1510 /* file exists but not valid, remove and try again, but refresh */
1511 if (0 != unlink (pfn))
1512 {
1513 /* failed to remove, run without file */
1515 _ ("Failed to remove bogus bloomfilter file `%s'\n"),
1516 pfn);
1517 GNUNET_free (pfn);
1518 pfn = NULL;
1520 NULL,
1521 bf_size,
1522 5); /* approx. 3% false positives at max use */
1524 }
1525 else
1526 {
1527 /* try again after remove */
1529 pfn,
1530 bf_size,
1531 5); /* approx. 3% false positives at max use */
1533 if (NULL == filter)
1534 {
1535 /* failed yet again, give up on using file */
1537 _ ("Failed to remove bogus bloomfilter file `%s'\n"),
1538 pfn);
1539 GNUNET_free (pfn);
1540 pfn = NULL;
1542 NULL,
1543 bf_size,
1544 5); /* approx. 3% false positives at max use */
1545 }
1546 }
1547 }
1548 else
1549 {
1550 /* normal case: have an existing valid bf file, no need to refresh */
1552 }
1553 }
1554 else
1555 {
1556 filter =
1558 bf_size,
1559 5); /* approx. 3% false positives at max use */
1561 }
1562 GNUNET_free (pfn);
1563 }
1564 else
1565 {
1566 filter =
1568 bf_size,
1569 5); /* approx. 3% false positives at max use */
1571 }
1572 GNUNET_free (fn);
1573 if (NULL == filter)
1574 {
1576 _ ("Failed to initialize bloomfilter.\n"));
1577 if (NULL != stats)
1578 {
1580 stats = NULL;
1581 }
1582 return;
1583 }
1586 "datastore",
1590 NULL);
1591 if (NULL == stat_get)
1593 else
1595 &stat_timeout,
1596 NULL);
1598}
1599
1600
1605 "datastore",
1607 &run,
1610 NULL,
1611 GNUNET_MQ_hd_fixed_size (reserve,
1613 struct ReserveMessage,
1614 NULL),
1615 GNUNET_MQ_hd_fixed_size (release_reserve,
1617 struct ReleaseReserveMessage,
1618 NULL),
1621 struct DataMessage,
1622 NULL),
1625 struct GetMessage,
1626 NULL),
1629 struct GetKeyMessage,
1630 NULL),
1631 GNUNET_MQ_hd_fixed_size (get_replication,
1633 struct GNUNET_MessageHeader,
1634 NULL),
1635 GNUNET_MQ_hd_fixed_size (get_zero_anonymity,
1638 NULL),
1639 GNUNET_MQ_hd_var_size (remove,
1641 struct DataMessage,
1642 NULL),
1645 struct GNUNET_MessageHeader,
1646 NULL),
1648
1649
1650/* end of gnunet-service-datastore.c */
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
structs for communication between datastore service and API
#define gettext_noop(String)
Definition: gettext.h:70
static int ret
Final status code.
Definition: gnunet-arm.c:94
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:34
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 int get
Get DID Documement for DID Flag.
Definition: gnunet-did.c:63
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:38
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.
GNUNET_SERVICE_MAIN("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.
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).
API for the database backend plugins.
Constants for network protocols.
API to create, modify and access statistics.
#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:482
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_create_for_file(const char *filename)
Create the directory structure for storing a file.
Definition: disk.c:582
#define GNUNET_log(kind,...)
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:54
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:37
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ 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:304
#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.
Definition: gnunet_mq_lib.h:63
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:78
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
void * GNUNET_PLUGIN_load(const char *library_name, void *arg)
Setup plugin (runs the "init" callback and returns whatever "init" returned).
Definition: plugin.c:198
void * GNUNET_PLUGIN_unload(const char *library_name, void *arg)
Unload plugin (runs the "done" callback and returns whatever "done" returned).
Definition: plugin.c:242
#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:1334
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:975
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:1272
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:1202
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:1226
void GNUNET_SERVICE_suspend(struct GNUNET_SERVICE_Handle *sh)
Suspend accepting connections from the listen socket temporarily.
Definition: service.c:2347
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2489
struct GNUNET_MQ_Handle * GNUNET_SERVICE_client_get_mq(struct GNUNET_SERVICE_Client *c)
Obtain the message queue of c.
Definition: service.c:2602
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2408
void GNUNET_SERVICE_resume(struct GNUNET_SERVICE_Handle *sh)
Resume accepting connections from the listen socket.
Definition: service.c:2359
@ 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:405
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:570
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:737
#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:421
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:638
const char * GNUNET_STRINGS_absolute_time_to_string(struct GNUNET_TIME_Absolute t)
Like asctime, except for GNUnet time.
Definition: strings.c:617
#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:178
static struct GNUNET_TIME_Relative delta
Definition: speedup.c:36
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.
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.
struct GNUNET_DATASTORE_PluginEnvironment env
Environment this transport service is using for this plugin.
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.
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
Entry in list of pending tasks.
Definition: scheduler.c:136
Handle to a client that is connected to a service.
Definition: service.c:252
Handle to a service.
Definition: service.c:118
Linked list of things we still need to do.
Handle for the service.
Time for absolute times used by GNUnet, in microseconds.
uint64_t abs_value_us
The actual value.
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
static char * get_key(const char *line)
Every line in the topology configuration starts with a string indicating which kind of information wi...
Definition: testing.c:1761