GNUnet 0.21.1
gnunet-service-statistics.c
Go to the documentation of this file.
1/*
2 This file is part of GNUnet.
3 Copyright (C) 2009, 2010, 2012, 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
26#include "platform.h"
27#include "gnunet_util_lib.h"
28#include "gnunet_protocols.h"
30#include "gnunet_time_lib.h"
31#include "statistics.h"
32
37{
42
47
51 struct ClientEntry *ce;
52
56 uint64_t last_value;
57
61 uint32_t wid;
62
68};
69
70
75struct SubsystemEntry;
76
77
82{
87
92
97
102 const char *name;
103
108
113
117 uint64_t value;
118
122 uint32_t uid;
123
128
133 int set;
134};
135
136
142{
147
152
157
162
167 const char *service;
168};
169
170
174struct ClientEntry
175{
180
184 struct GNUNET_MQ_Handle *mq;
185
190
194 uint32_t max_wid;
195};
196
197
201static const struct GNUNET_CONFIGURATION_Handle *cfg;
202
207
212
216static unsigned int client_count;
217
222
226static uint32_t uidgen;
227
231static int in_shutdown;
232
233
237static void
239{
240 struct SubsystemEntry *se;
241 struct StatsEntry *pos;
242 char *fn;
243 struct GNUNET_BIO_WriteHandle *wh;
244 uint16_t size;
245 unsigned long long total;
246 size_t nlen;
247 size_t slen;
249
251 "STATISTICS",
252 "DATABASE",
253 &fn))
254 {
256 "STATISTICS",
257 "DATABASE");
258 return;
259 }
262 total = 0;
263 while (NULL != (se = sub_head))
264 {
266 slen = strlen (se->service) + 1;
267 while (NULL != (pos = se->stat_head))
268 {
270 if ((pos->persistent) && (NULL != wh))
271 {
272 nlen = strlen (pos->name) + 1;
273 size = sizeof(struct GNUNET_STATISTICS_SetMessage) + nlen + slen;
274 GNUNET_assert (size < UINT16_MAX);
276
277 msg->header.size = htons ((uint16_t) size);
279 GNUNET_assert (nlen + slen ==
280 GNUNET_STRINGS_buffer_fill ((char *) &msg[1],
281 nlen + slen,
282 2,
283 se->service,
284 pos->name));
285 msg->flags =
287 msg->value = GNUNET_htonll (pos->value);
288 if (GNUNET_OK != GNUNET_BIO_write (wh, "statistics-save-msg", msg,
289 size))
290 {
292 if (GNUNET_OK != GNUNET_BIO_write_close (wh, NULL))
294 wh = NULL;
295 }
296 else
297 {
298 total += size;
299 }
301 }
302 GNUNET_free (pos);
303 }
304 GNUNET_free (se);
305 }
306 if (NULL != wh)
307 {
308 if (GNUNET_OK != GNUNET_BIO_write_close (wh, NULL))
310 if (0 == total)
311 GNUNET_break (0 == unlink (fn));
312 else
314 _ ("Wrote %llu bytes of statistics to `%s'\n"),
315 total,
316 fn);
317 }
318 GNUNET_free (fn);
319}
320
321
328static void
329transmit (struct ClientEntry *ce, const struct StatsEntry *e)
330{
331 struct GNUNET_MQ_Envelope *env;
333 size_t size;
334
335 size = strlen (e->subsystem->service) + 1 + strlen (e->name) + 1;
338 m->uid = htonl (e->uid);
339 if (e->persistent)
340 m->uid |= htonl (GNUNET_STATISTICS_PERSIST_BIT);
341 m->value = GNUNET_htonll (e->value);
343 size,
344 2,
345 e->subsystem->service,
346 e->name));
348 "Transmitting value for `%s:%s' (%d): %llu\n",
349 e->subsystem->service,
350 e->name,
351 e->persistent,
352 (unsigned long long) e->value);
353 GNUNET_MQ_send (ce->mq, env);
354}
355
356
365static void *
367 struct GNUNET_SERVICE_Client *c,
368 struct GNUNET_MQ_Handle *mq)
369{
370 struct ClientEntry *ce;
371
372 ce = GNUNET_new (struct ClientEntry);
373 ce->client = c;
374 ce->mq = mq;
375 client_count++;
377 return ce;
378}
379
380
388static int
389check_get (void *cls, const struct GNUNET_MessageHeader *message)
390{
391 const char *service;
392 const char *name;
393 size_t size;
394
395 size = ntohs (message->size) - sizeof(struct GNUNET_MessageHeader);
396 if (size != GNUNET_STRINGS_buffer_tokenize ((const char *) &message[1],
397 size,
398 2,
399 &service,
400 &name))
401 {
402 GNUNET_break (0);
403 return GNUNET_SYSERR;
404 }
405 return GNUNET_OK;
406}
407
408
415static void
416handle_get (void *cls, const struct GNUNET_MessageHeader *message)
417{
418 struct ClientEntry *ce = cls;
419 struct GNUNET_MQ_Envelope *env;
421 const char *service;
422 const char *name;
423 size_t slen;
424 size_t nlen;
425 struct SubsystemEntry *se;
426 struct StatsEntry *pos;
427 size_t size;
428
429 size = ntohs (message->size) - sizeof(struct GNUNET_MessageHeader);
431 GNUNET_STRINGS_buffer_tokenize ((const char *) &message[1],
432 size,
433 2,
434 &service,
435 &name));
436 slen = strlen (service);
437 nlen = strlen (name);
439 "Received request for statistics on `%s:%s'\n",
440 slen ? service : "*",
441 nlen ? name : "*");
442 for (se = sub_head; NULL != se; se = se->next)
443 {
444 if (! ((0 == slen) || (0 == strcmp (service, se->service))))
445 continue;
446 for (pos = se->stat_head; NULL != pos; pos = pos->next)
447 {
448 if (! ((0 == nlen) || (0 == strcmp (name, pos->name))))
449 continue;
450 transmit (ce, pos);
451 }
452 }
454 GNUNET_MQ_send (ce->mq, env);
456}
457
458
464static void
466{
467 struct GNUNET_MQ_Envelope *env;
469 struct WatchEntry *pos;
470
471 for (pos = se->we_head; NULL != pos; pos = pos->next)
472 {
473 if (GNUNET_YES == pos->last_value_set)
474 {
475 if (pos->last_value == se->value)
476 continue;
477 }
478 else
479 {
481 }
483 wvm->flags =
485 wvm->wid = htonl (pos->wid);
486 wvm->reserved = htonl (0);
487 wvm->value = GNUNET_htonll (se->value);
488 GNUNET_MQ_send (pos->ce->mq, env);
489 pos->last_value = se->value;
490 }
491}
492
493
502static struct SubsystemEntry *
503find_subsystem_entry (struct ClientEntry *ce, const char *service)
504{
505 size_t slen;
506 struct SubsystemEntry *se;
507
508 if (NULL != ce)
509 se = ce->subsystem;
510 else
511 se = NULL;
512 if ((NULL == se) || (0 != strcmp (service, se->service)))
513 {
514 for (se = sub_head; NULL != se; se = se->next)
515 if (0 == strcmp (service, se->service))
516 break;
517 if (NULL != ce)
518 ce->subsystem = se;
519 }
520 if (NULL != se)
521 return se;
523 "Allocating new subsystem entry `%s'\n",
524 service);
525 slen = strlen (service) + 1;
526 se = GNUNET_malloc (sizeof(struct SubsystemEntry) + slen);
527 GNUNET_memcpy (&se[1], service, slen);
528 se->service = (const char *) &se[1];
530 if (NULL != ce)
531 ce->subsystem = se;
532 return se;
533}
534
535
543static struct StatsEntry *
544find_stat_entry (struct SubsystemEntry *se, const char *name)
545{
546 struct StatsEntry *pos;
547
548 for (pos = se->stat_head; NULL != pos; pos = pos->next)
549 if (0 == strcmp (name, pos->name))
550 return pos;
551 return NULL;
552}
553
554
562static int
564{
565 const char *service;
566 const char *name;
567 size_t msize;
568
569 msize = ntohs (msg->header.size) - sizeof(*msg);
570 if (msize != GNUNET_STRINGS_buffer_tokenize ((const char *) &msg[1],
571 msize,
572 2,
573 &service,
574 &name))
575 {
576 GNUNET_break (0);
577 return GNUNET_SYSERR;
578 }
579 return GNUNET_OK;
580}
581
582
589static void
591{
592 struct ClientEntry *ce = cls;
593 const char *service;
594 const char *name;
595 size_t nlen;
596 uint16_t msize;
597 uint16_t size;
598 struct SubsystemEntry *se;
599 struct StatsEntry *pos;
600 uint32_t flags;
601 uint64_t value;
602 int64_t delta;
603 int changed;
604 int initial_set;
605
606 msize = ntohs (msg->header.size);
607 size = msize - sizeof(struct GNUNET_STATISTICS_SetMessage);
609 size,
610 2,
611 &service,
612 &name));
613 se = find_subsystem_entry (ce, service);
614 flags = ntohl (msg->flags);
615 value = GNUNET_ntohll (msg->value);
617 "Received request to update statistic on `%s:%s' (%u) to/by %llu\n",
618 service,
619 name,
620 (unsigned int) flags,
621 (unsigned long long) value);
622 pos = find_stat_entry (se, name);
623 if (NULL != pos)
624 {
625 initial_set = 0;
627 {
628 changed = (pos->value != value);
629 pos->value = value;
630 }
631 else
632 {
633 delta = (int64_t) value;
634 if ((delta < 0) && (pos->value < -delta))
635 {
636 changed = (0 != pos->value);
637 pos->value = 0;
638 }
639 else
640 {
641 changed = (0 != delta);
642 GNUNET_break ((delta <= 0) || (pos->value + delta > pos->value));
643 pos->value += delta;
644 }
645 }
646 if (GNUNET_NO == pos->set)
647 {
648 pos->set = GNUNET_YES;
649 initial_set = 1;
650 }
652 if (pos != se->stat_head)
653 {
654 /* move to front for faster setting next time! */
657 }
659 "Statistic `%s:%s' updated to value %llu (%d).\n",
660 service,
661 name,
662 (unsigned long long) pos->value,
663 pos->persistent);
664 if ((changed) || (1 == initial_set))
665 notify_change (pos);
667 return;
668 }
669 /* not found, create a new entry */
670 nlen = strlen (name) + 1;
671 pos = GNUNET_malloc (sizeof(struct StatsEntry) + nlen);
672 GNUNET_memcpy (&pos[1], name, nlen);
673 pos->name = (const char *) &pos[1];
674 pos->subsystem = se;
676 (0 < (int64_t) GNUNET_ntohll (msg->value)))
677 {
678 pos->value = GNUNET_ntohll (msg->value);
679 pos->set = GNUNET_YES;
680 }
681 else
682 {
683 pos->set = GNUNET_NO;
684 }
685 pos->uid = uidgen++;
689 "New statistic on `%s:%s' with value %llu created.\n",
690 service,
691 name,
692 (unsigned long long) pos->value);
693 if (NULL != ce)
695}
696
697
705static int
706check_watch (void *cls, const struct GNUNET_MessageHeader *message)
707{
708 size_t size;
709 const char *service;
710 const char *name;
711
712 size = ntohs (message->size) - sizeof(struct GNUNET_MessageHeader);
713 if (size != GNUNET_STRINGS_buffer_tokenize ((const char *) &message[1],
714 size,
715 2,
716 &service,
717 &name))
718 {
719 GNUNET_break (0);
720 return GNUNET_SYSERR;
721 }
722 return GNUNET_OK;
723}
724
725
732static void
733handle_watch (void *cls, const struct GNUNET_MessageHeader *message)
734{
735 struct ClientEntry *ce = cls;
736 const char *service;
737 const char *name;
738 uint16_t msize;
739 uint16_t size;
740 struct SubsystemEntry *se;
741 struct StatsEntry *pos;
742 struct WatchEntry *we;
743 size_t nlen;
744
745 if (NULL == nc)
746 {
748 return;
749 }
751 msize = ntohs (message->size);
752 size = msize - sizeof(struct GNUNET_MessageHeader);
754 GNUNET_STRINGS_buffer_tokenize ((const char *) &message[1],
755 size,
756 2,
757 &service,
758 &name));
760 "Received request to watch statistic on `%s:%s'\n",
761 service,
762 name);
763 se = find_subsystem_entry (ce, service);
764 pos = find_stat_entry (se, name);
765 if (NULL == pos)
766 {
767 nlen = strlen (name) + 1;
768 pos = GNUNET_malloc (sizeof(struct StatsEntry) + nlen);
769 GNUNET_memcpy (&pos[1], name, nlen);
770 pos->name = (const char *) &pos[1];
771 pos->subsystem = se;
773 pos->uid = uidgen++;
774 pos->set = GNUNET_NO;
776 "New statistic on `%s:%s' with value %llu created.\n",
777 service,
778 name,
779 (unsigned long long) pos->value);
780 }
781 we = GNUNET_new (struct WatchEntry);
782 we->ce = ce;
784 we->wid = ce->max_wid++;
786 if (0 != pos->value)
787 notify_change (pos);
789}
790
791
800static void
801handle_disconnect (void *cls, const struct GNUNET_MessageHeader *message)
802{
803 struct ClientEntry *ce = cls;
804 struct GNUNET_MQ_Envelope *env;
806
808 GNUNET_MQ_send (ce->mq, env);
810}
811
812
816static void
818{
819 struct WatchEntry *we;
820 struct StatsEntry *pos;
821 struct SubsystemEntry *se;
822
823 if (NULL == nc)
824 return;
825 save ();
827 nc = NULL;
829 while (NULL != (se = sub_head))
830 {
832 while (NULL != (pos = se->stat_head))
833 {
835 while (NULL != (we = pos->we_head))
836 {
837 GNUNET_break (0);
839 GNUNET_free (we);
840 }
841 GNUNET_free (pos);
842 }
843 GNUNET_free (se);
844 }
845}
846
847
853static void
854shutdown_task (void *cls)
855{
857 if (0 != client_count)
858 return;
859 do_shutdown ();
860}
861
862
870static void
872 struct GNUNET_SERVICE_Client *client,
873 void *app_cls)
874{
875 struct ClientEntry *ce = app_cls;
876 struct WatchEntry *we;
877 struct WatchEntry *wen;
878 struct StatsEntry *pos;
879 struct SubsystemEntry *se;
880
881 client_count--;
882 for (se = sub_head; NULL != se; se = se->next)
883 {
884 for (pos = se->stat_head; NULL != pos; pos = pos->next)
885 {
886 wen = pos->we_head;
887 while (NULL != (we = wen))
888 {
889 wen = we->next;
890 if (we->ce != ce)
891 continue;
893 GNUNET_free (we);
894 }
895 }
896 }
897 GNUNET_free (ce);
898 if ((0 == client_count) && (GNUNET_YES == in_shutdown))
899 do_shutdown ();
900}
901
902
914static int
915inject_message (void *cls, const struct GNUNET_MessageHeader *message)
916{
917 uint16_t msize = ntohs (message->size);
918 const struct GNUNET_STATISTICS_SetMessage *sm;
919
920 sm = (const struct GNUNET_STATISTICS_SetMessage *) message;
921 if ((sizeof(struct GNUNET_STATISTICS_SetMessage) > msize) ||
922 (GNUNET_OK != check_set (NULL, sm)))
923 {
924 GNUNET_break (0);
925 return GNUNET_SYSERR;
926 }
927 handle_set (NULL, sm);
928 return GNUNET_OK;
929}
930
931
936static void
938{
939 char *fn;
940 struct GNUNET_BIO_ReadHandle *rh;
941 uint64_t fsize;
942 char *buf;
944
946 "STATISTICS",
947 "DATABASE",
948 &fn))
949 {
951 "STATISTICS",
952 "DATABASE");
953 return;
954 }
955 if ((GNUNET_OK !=
957 (0 == fsize))
958 {
959 GNUNET_free (fn);
960 return;
961 }
962 buf = GNUNET_malloc (fsize);
964 if (! rh)
965 {
966 GNUNET_free (buf);
967 GNUNET_free (fn);
968 return;
969 }
970 if (GNUNET_OK != GNUNET_BIO_read (rh, fn, buf, fsize))
971 {
974 GNUNET_free (buf);
975 GNUNET_free (fn);
976 return;
977 }
979 _ ("Loading %llu bytes of statistics from `%s'\n"),
980 (unsigned long long) fsize,
981 fn);
982 mst = GNUNET_MST_create (&inject_message, NULL);
984 GNUNET_OK ==
985 GNUNET_MST_from_buffer (mst, buf, (size_t) fsize, GNUNET_YES, GNUNET_NO));
986 GNUNET_MST_destroy (mst);
987 GNUNET_free (buf);
989 GNUNET_free (fn);
990}
991
992
1000static void
1001run (void *cls,
1002 const struct GNUNET_CONFIGURATION_Handle *c,
1004{
1005 cfg = c;
1007 load ();
1009}
1010
1011
1016 "statistics",
1018 &run,
1021 NULL,
1025 NULL),
1028 struct GNUNET_MessageHeader,
1029 NULL),
1032 struct GNUNET_MessageHeader,
1033 NULL),
1036 struct GNUNET_MessageHeader,
1037 NULL),
1039
1040
1041#if defined(__linux__) && defined(__GLIBC__)
1042#include <malloc.h>
1043
1047void __attribute__ ((constructor))
1048GNUNET_STATISTICS_memory_init ()
1049{
1050 mallopt (M_TRIM_THRESHOLD, 4 * 1024);
1051 mallopt (M_TOP_PAD, 1 * 1024);
1052 malloc_trim (0);
1053}
1054
1055
1056#endif
1057
1058
1059/* end of gnunet-service-statistics.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
static struct GNUNET_ARM_MonitorHandle * m
Monitor connection with ARM.
Definition: gnunet-arm.c:104
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:34
static int get
Get DID Documement for DID Flag.
Definition: gnunet-did.c:63
static char * name
Name (label) of the records to list.
static char * value
Value of the record to add/remove.
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
static void transmit(struct ClientEntry *ce, const struct StatsEntry *e)
Transmit the given stats value.
static void handle_set(void *cls, const struct GNUNET_STATISTICS_SetMessage *msg)
Handle SET-message.
static int check_watch(void *cls, const struct GNUNET_MessageHeader *message)
Check integrity of WATCH-message.
static void handle_watch(void *cls, const struct GNUNET_MessageHeader *message)
Handle WATCH-message.
static struct SubsystemEntry * find_subsystem_entry(struct ClientEntry *ce, const char *service)
Find the subsystem entry of the given name for the specified client.
static void handle_disconnect(void *cls, const struct GNUNET_MessageHeader *message)
Handle DISCONNECT-message.
static int inject_message(void *cls, const struct GNUNET_MessageHeader *message)
We've read a struct GNUNET_STATISTICS_SetMessage * from disk.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
static unsigned int client_count
Number of connected clients.
static struct GNUNET_NotificationContext * nc
Our notification context.
static void client_disconnect_cb(void *cls, struct GNUNET_SERVICE_Client *client, void *app_cls)
A client disconnected.
static int in_shutdown
Set to GNUNET_YES if we are shutting down as soon as possible.
static void shutdown_task(void *cls)
Task run during shutdown.
static void handle_get(void *cls, const struct GNUNET_MessageHeader *message)
Handle GET-message.
static void save()
Write persistent statistics to disk.
static void notify_change(struct StatsEntry *se)
Notify all clients listening about a change to a value.
static void load()
Load persistent values from disk.
GNUNET_SERVICE_MAIN("statistics", GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_var_size(set, GNUNET_MESSAGE_TYPE_STATISTICS_SET, struct GNUNET_STATISTICS_SetMessage, NULL), GNUNET_MQ_hd_var_size(get, GNUNET_MESSAGE_TYPE_STATISTICS_GET, struct GNUNET_MessageHeader, NULL), GNUNET_MQ_hd_var_size(watch, GNUNET_MESSAGE_TYPE_STATISTICS_WATCH, struct GNUNET_MessageHeader, NULL), GNUNET_MQ_hd_fixed_size(disconnect, GNUNET_MESSAGE_TYPE_STATISTICS_DISCONNECT, struct GNUNET_MessageHeader, NULL), GNUNET_MQ_handler_end())
Define "main" method using service macro.
static struct SubsystemEntry * sub_tail
Tail of linked list of subsystems with active statistics.
static void run(void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
Process statistics requests.
static void do_shutdown()
Actually perform the shutdown.
static void * client_connect_cb(void *cls, struct GNUNET_SERVICE_Client *c, struct GNUNET_MQ_Handle *mq)
Callback called when a client connects to the service.
static struct SubsystemEntry * sub_head
Head of linked list of subsystems with active statistics.
static struct StatsEntry * find_stat_entry(struct SubsystemEntry *se, const char *name)
Find the statistics entry of the given subsystem.
static int check_set(void *cls, const struct GNUNET_STATISTICS_SetMessage *msg)
Check format of SET-message.
static uint32_t uidgen
Counter used to generate unique values.
static int check_get(void *cls, const struct GNUNET_MessageHeader *message)
Check integrity of GET-message.
static int watch
Watch value continuously.
struct GNUNET_PQ_ResultSpec __attribute__
Constants for network protocols.
API to create, modify and access statistics.
Functions related to time.
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message,...
enum GNUNET_GenericReturnValue GNUNET_BIO_read(struct GNUNET_BIO_ReadHandle *h, const char *what, void *result, size_t len)
Read some contents into a buffer.
Definition: bio.c:291
enum GNUNET_GenericReturnValue GNUNET_BIO_write_close(struct GNUNET_BIO_WriteHandle *h, char **emsg)
Close an IO handle.
Definition: bio.c:556
struct GNUNET_BIO_WriteHandle * GNUNET_BIO_write_open_file(const char *fn)
Open a file for writing.
Definition: bio.c:508
enum GNUNET_GenericReturnValue GNUNET_BIO_write(struct GNUNET_BIO_WriteHandle *h, const char *what, const void *buffer, size_t n)
Write a buffer to a handle.
Definition: bio.c:752
enum GNUNET_GenericReturnValue GNUNET_BIO_read_close(struct GNUNET_BIO_ReadHandle *h, char **emsg)
Close an open handle.
Definition: bio.c:162
struct GNUNET_BIO_ReadHandle * GNUNET_BIO_read_open_file(const char *fn)
Open a file for reading.
Definition: bio.c:114
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_DISK_file_size(const char *filename, uint64_t *size, int include_symbolic_links, int single_file_mode)
Get the size of the file (or directory) of the given file (in bytes).
Definition: disk.c:221
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_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
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.
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.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
@ 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.
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
@ GNUNET_ERROR_TYPE_INFO
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_notification_context_destroy(struct GNUNET_NotificationContext *nc)
Destroy the context, force disconnect for all subscribers.
Definition: nc.c:138
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
struct GNUNET_NotificationContext * GNUNET_notification_context_create(unsigned int queue_length)
Create a new notification context.
Definition: nc.c:122
#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_notification_context_add(struct GNUNET_NotificationContext *nc, struct GNUNET_MQ_Handle *mq)
Add a subscriber to the notification context.
Definition: nc.c:161
#define GNUNET_MESSAGE_TYPE_STATISTICS_END
Response to a STATISTICS_GET message (end of value stream).
#define GNUNET_MESSAGE_TYPE_STATISTICS_GET
Get a statistical value(s).
#define GNUNET_MESSAGE_TYPE_STATISTICS_VALUE
Response to a STATISTICS_GET message (with value).
#define GNUNET_MESSAGE_TYPE_STATISTICS_WATCH_VALUE
Changes to a watched value.
#define GNUNET_MESSAGE_TYPE_STATISTICS_SET
Set a statistical value.
#define GNUNET_MESSAGE_TYPE_STATISTICS_DISCONNECT_CONFIRM
Service confirms disconnect and that it is done processing all requests from the client.
#define GNUNET_MESSAGE_TYPE_STATISTICS_WATCH
Watch changes to a statistical value.
#define GNUNET_MESSAGE_TYPE_STATISTICS_DISCONNECT
Client is done sending service requests and will now disconnect.
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:1340
enum GNUNET_GenericReturnValue GNUNET_MST_from_buffer(struct GNUNET_MessageStreamTokenizer *mst, const char *buf, size_t size, int purge, int one_shot)
Add incoming data to the receive buffer and call the callback for all complete messages.
Definition: mst.c:101
struct GNUNET_MessageStreamTokenizer * GNUNET_MST_create(GNUNET_MessageTokenizerCallback cb, void *cb_cls)
Create a message stream tokenizer.
Definition: mst.c:86
void GNUNET_MST_destroy(struct GNUNET_MessageStreamTokenizer *mst)
Destroys a tokenizer.
Definition: mst.c:404
void GNUNET_SERVICE_client_mark_monitor(struct GNUNET_SERVICE_Client *c)
Set the 'monitor' flag on this client.
Definition: service.c:2549
void GNUNET_SERVICE_client_drop(struct GNUNET_SERVICE_Client *c)
Ask the server to disconnect from the given client.
Definition: service.c:2484
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2455
@ GNUNET_SERVICE_OPTION_SOFT_SHUTDOWN
Trigger a SOFT server shutdown on signals, allowing active non-monitor clients to complete their tran...
unsigned int GNUNET_STRINGS_buffer_tokenize(const char *buffer, size_t size, unsigned int count,...)
Given a buffer of a given size, find "count" 0-terminated strings in the buffer and assign the count ...
Definition: strings.c:72
size_t GNUNET_STRINGS_buffer_fill(char *buffer, size_t size, unsigned int count,...)
Fill a buffer of the given size with count 0-terminated strings (given as varargs).
Definition: strings.c:44
static unsigned int size
Size of the "table".
Definition: peer.c:68
static void disconnect(struct GNUNET_PEERSTORE_Handle *h)
Disconnect from the peerstore service.
#define _(String)
GNU gettext support macro.
Definition: platform.h:178
static struct GNUNET_TIME_Relative delta
Definition: speedup.c:36
#define GNUNET_STATISTICS_PERSIST_BIT
Flag for the struct GNUNET_STATISTICS_ReplyMessage UID only.
Definition: statistics.h:65
#define GNUNET_STATISTICS_SETFLAG_PERSISTENT
The value being set is to be persistent (note that this bit can be combined with GNUNET_STATISTICS_SE...
Definition: statistics.h:83
#define GNUNET_STATISTICS_SETFLAG_RELATIVE
The value being set is a relative change.
Definition: statistics.h:75
Information about one of our clients.
struct GNUNET_SERVICE_Client * client
Handle identifying the client.
struct SubsystemEntry * subsystem
Which subsystem is this client writing to (SET/UPDATE)?
uint32_t max_wid
Maximum watch ID used by this client so far.
struct GNUNET_MQ_Handle * mq
Queue for transmissions to client.
Handle for buffered reading.
Definition: bio.c:69
Handle for buffered writing.
Definition: bio.c:466
Handle to a message queue.
Definition: mq.c:87
Header for all communications.
Handle to a message stream tokenizer.
Definition: mst.c:45
The notification context is the key datastructure for a convenience API used for transmission of noti...
Definition: nc.c:77
Handle to a client that is connected to a service.
Definition: service.c:246
Handle to a service.
Definition: service.c:117
Statistics message.
Definition: statistics.h:41
Message to set a statistic.
Definition: statistics.h:92
uint32_t flags
0 for absolute value, 1 for relative value; 2 to make persistent (see GNUNET_STATISTICS_SETFLAG_*).
Definition: statistics.h:102
Message transmitted if a watched value changes.
Definition: statistics.h:116
uint32_t reserved
Reserved (always 0).
Definition: statistics.h:139
uint32_t flags
0 for absolute value, 1 for relative value; 2 to make persistent (see GNUNET_STATISTICS_SETFLAG_*).
Definition: statistics.h:126
uint32_t wid
Unique watch identification number (watch requests are enumerated in the order they are received,...
Definition: statistics.h:134
Entry in the statistics list.
uint64_t value
Our value.
struct StatsEntry * prev
This is a linked list.
struct StatsEntry * next
This is a linked list.
struct SubsystemEntry * subsystem
Subsystem this entry belongs to.
struct WatchEntry * we_tail
Watch context for changes to this value, or NULL for none.
uint32_t uid
Unique ID.
struct WatchEntry * we_head
Watch context for changes to this value, or NULL for none.
int persistent
Is this value persistent?
const char * name
Name for the value stored by this entry, allocated at the end of this struct.
int set
Is this value set? GNUNET_NO: value is n/a, GNUNET_YES: value is valid.
We keep the statistics organized by subsystem for faster lookup during SET operations.
struct SubsystemEntry * prev
Subsystems are kept in a DLL.
struct SubsystemEntry * next
Subsystems are kept in a DLL.
struct StatsEntry * stat_head
Head of list of values kept for this subsystem.
struct StatsEntry * stat_tail
Tail of list of values kept for this subsystem.
const char * service
Name of the subsystem this entry is for, allocated at the end of this struct, do not free().
struct WatchEntry * next
Watch entries are kept in a linked list.
uint64_t last_value
Last value we communicated to the client for this watch entry.
struct WatchEntry * prev
Watch entries are kept in a linked list.
int last_value_set
Is last_value valid GNUNET_NO : last_value is n/a, GNUNET_YES: last_value is valid.
uint32_t wid
Unique watch number for this client and this watched value.
struct ClientEntry * ce
For which client is this watch entry?