This file is part of GNUnet.
Copyright (C) 2009, 2010, 2012, 2014, 2016 GNUnet e.V.
- GNUnet is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published
- by the Free Software Foundation; either version 3, or (at your
- option) any later version.
+ GNUnet is free software: you can redistribute it and/or modify it
+ under the terms of the GNU Affero General Public License as published
+ by the Free Software Foundation, either version 3 of the License,
+ or (at your option) any later version.
GNUnet is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- General Public License for more details.
+ Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
- You should have received a copy of the GNU General Public License
- along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA.
+ SPDX-License-Identifier: AGPL3.0-or-later
*/
/**
* #GNUNET_NO : last_value is n/a, #GNUNET_YES: last_value is valid
*/
int last_value_set;
-
};
* #GNUNET_NO: value is n/a, #GNUNET_YES: value is valid
*/
int set;
-
};
* the end of this struct, do not free().
*/
const char *service;
-
};
* Maximum watch ID used by this client so far.
*/
uint32_t max_wid;
-
};
size_t slen;
struct GNUNET_STATISTICS_SetMessage *msg;
- if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_filename (cfg,
- "STATISTICS",
- "DATABASE",
- &fn))
+ if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg,
+ "STATISTICS",
+ "DATABASE",
+ &fn))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
"STATISTICS",
total = 0;
while (NULL != (se = sub_head))
{
- GNUNET_CONTAINER_DLL_remove (sub_head,
- sub_tail,
- se);
+ GNUNET_CONTAINER_DLL_remove (sub_head, sub_tail, se);
slen = strlen (se->service) + 1;
while (NULL != (pos = se->stat_head))
{
- GNUNET_CONTAINER_DLL_remove (se->stat_head,
- se->stat_tail,
- pos);
- if ( (pos->persistent) &&
- (NULL != wh) )
+ GNUNET_CONTAINER_DLL_remove (se->stat_head, se->stat_tail, pos);
+ if ((pos->persistent) && (NULL != wh))
{
nlen = strlen (pos->name) + 1;
size = sizeof (struct GNUNET_STATISTICS_SetMessage) + nlen + slen;
2,
se->service,
pos->name));
- msg->flags = htonl (pos->persistent ? GNUNET_STATISTICS_SETFLAG_PERSISTENT : 0);
+ msg->flags =
+ htonl (pos->persistent ? GNUNET_STATISTICS_SETFLAG_PERSISTENT : 0);
msg->value = GNUNET_htonll (pos->value);
- if (GNUNET_OK != GNUNET_BIO_write (wh,
- msg,
- size))
+ if (GNUNET_OK != GNUNET_BIO_write (wh, msg, size))
{
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
- "write",
- fn);
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "write", fn);
if (GNUNET_OK != GNUNET_BIO_write_close (wh))
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
- "close",
- fn);
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "close", fn);
wh = NULL;
}
else
}
if (NULL != wh)
{
- if (GNUNET_OK !=
- GNUNET_BIO_write_close (wh))
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
- "close",
- fn);
+ if (GNUNET_OK != GNUNET_BIO_write_close (wh))
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "close", fn);
if (0 == total)
- GNUNET_break (0 ==
- UNLINK (fn));
+ GNUNET_break (0 == unlink (fn));
else
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Wrote %llu bytes of statistics to `%s'\n"),
+ _ ("Wrote %llu bytes of statistics to `%s'\n"),
total,
fn);
}
* @param e value to transmit
*/
static void
-transmit (struct ClientEntry *ce,
- const struct StatsEntry *e)
+transmit (struct ClientEntry *ce, const struct StatsEntry *e)
{
struct GNUNET_MQ_Envelope *env;
struct GNUNET_STATISTICS_ReplyMessage *m;
size_t size;
- size = strlen (e->subsystem->service) + 1 +
- strlen (e->name) + 1;
- GNUNET_assert (size < GNUNET_SERVER_MAX_MESSAGE_SIZE);
- env = GNUNET_MQ_msg_extra (m,
- size,
- GNUNET_MESSAGE_TYPE_STATISTICS_VALUE);
+ size = strlen (e->subsystem->service) + 1 + strlen (e->name) + 1;
+ GNUNET_assert (size < GNUNET_MAX_MESSAGE_SIZE);
+ env = GNUNET_MQ_msg_extra (m, size, GNUNET_MESSAGE_TYPE_STATISTICS_VALUE);
m->uid = htonl (e->uid);
if (e->persistent)
m->uid |= htonl (GNUNET_STATISTICS_PERSIST_BIT);
m->value = GNUNET_htonll (e->value);
- GNUNET_assert (size ==
- GNUNET_STRINGS_buffer_fill ((char *) &m[1],
- size,
- 2,
- e->subsystem->service,
- e->name));
+ GNUNET_assert (size == GNUNET_STRINGS_buffer_fill ((char *) &m[1],
+ size,
+ 2,
+ e->subsystem->service,
+ e->name));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Transmitting value for `%s:%s' (%d): %llu\n",
e->subsystem->service,
e->name,
e->persistent,
(unsigned long long) e->value);
- GNUNET_MQ_send (ce->mq,
- env);
+ GNUNET_MQ_send (ce->mq, env);
}
*/
static void *
client_connect_cb (void *cls,
- struct GNUNET_SERVICE_Client *c,
- struct GNUNET_MQ_Handle *mq)
+ struct GNUNET_SERVICE_Client *c,
+ struct GNUNET_MQ_Handle *mq)
{
struct ClientEntry *ce;
ce->client = c;
ce->mq = mq;
client_count++;
- GNUNET_notification_context_add (nc,
- mq);
+ GNUNET_notification_context_add (nc, mq);
return ce;
}
* @return #GNUNET_OK if @a message is well-formed
*/
static int
-check_get (void *cls,
- const struct GNUNET_MessageHeader *message)
+check_get (void *cls, const struct GNUNET_MessageHeader *message)
{
const char *service;
const char *name;
size_t size;
size = ntohs (message->size) - sizeof (struct GNUNET_MessageHeader);
- if (size !=
- GNUNET_STRINGS_buffer_tokenize ((const char *) &message[1],
- size,
- 2,
- &service,
- &name))
+ if (size != GNUNET_STRINGS_buffer_tokenize ((const char *) &message[1],
+ size,
+ 2,
+ &service,
+ &name))
{
GNUNET_break (0);
return GNUNET_SYSERR;
* @param message the actual message
*/
static void
-handle_get (void *cls,
- const struct GNUNET_MessageHeader *message)
+handle_get (void *cls, const struct GNUNET_MessageHeader *message)
{
struct ClientEntry *ce = cls;
struct GNUNET_MQ_Envelope *env;
size = ntohs (message->size) - sizeof (struct GNUNET_MessageHeader);
GNUNET_assert (size ==
- GNUNET_STRINGS_buffer_tokenize ((const char *) &message[1],
- size,
- 2,
- &service,
- &name));
+ GNUNET_STRINGS_buffer_tokenize ((const char *) &message[1],
+ size,
+ 2,
+ &service,
+ &name));
slen = strlen (service);
nlen = strlen (name);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
nlen ? name : "*");
for (se = sub_head; NULL != se; se = se->next)
{
- if (! ( (0 == slen) ||
- (0 == strcmp (service, se->service))) )
+ if (! ((0 == slen) || (0 == strcmp (service, se->service))))
continue;
for (pos = se->stat_head; NULL != pos; pos = pos->next)
{
- if (! ( (0 == nlen) ||
- (0 == strcmp (name,
- pos->name))) )
+ if (! ((0 == nlen) || (0 == strcmp (name, pos->name))))
continue;
- transmit (ce,
- pos);
+ transmit (ce, pos);
}
}
- env = GNUNET_MQ_msg (end,
- GNUNET_MESSAGE_TYPE_STATISTICS_END);
- GNUNET_MQ_send (ce->mq,
- env);
+ env = GNUNET_MQ_msg (end, GNUNET_MESSAGE_TYPE_STATISTICS_END);
+ GNUNET_MQ_send (ce->mq, env);
GNUNET_SERVICE_client_continue (ce->client);
}
{
pos->last_value_set = GNUNET_YES;
}
- env = GNUNET_MQ_msg (wvm,
- GNUNET_MESSAGE_TYPE_STATISTICS_WATCH_VALUE);
- wvm->flags = htonl (se->persistent ? GNUNET_STATISTICS_SETFLAG_PERSISTENT : 0);
+ env = GNUNET_MQ_msg (wvm, GNUNET_MESSAGE_TYPE_STATISTICS_WATCH_VALUE);
+ wvm->flags =
+ htonl (se->persistent ? GNUNET_STATISTICS_SETFLAG_PERSISTENT : 0);
wvm->wid = htonl (pos->wid);
wvm->reserved = htonl (0);
wvm->value = GNUNET_htonll (se->value);
- GNUNET_MQ_send (pos->ce->mq,
- env);
+ GNUNET_MQ_send (pos->ce->mq, env);
pos->last_value = se->value;
}
}
* @return subsystem entry, never NULL (subsystem entry is created if necessary)
*/
static struct SubsystemEntry *
-find_subsystem_entry (struct ClientEntry *ce,
- const char *service)
+find_subsystem_entry (struct ClientEntry *ce, const char *service)
{
size_t slen;
struct SubsystemEntry *se;
se = ce->subsystem;
else
se = NULL;
- if ( (NULL == se) ||
- (0 != strcmp (service,
- se->service)) )
+ if ((NULL == se) || (0 != strcmp (service, se->service)))
{
for (se = sub_head; NULL != se; se = se->next)
- if (0 == strcmp (service,
- se->service))
+ if (0 == strcmp (service, se->service))
break;
if (NULL != ce)
ce->subsystem = se;
"Allocating new subsystem entry `%s'\n",
service);
slen = strlen (service) + 1;
- se = GNUNET_malloc (sizeof (struct SubsystemEntry) +
- slen);
- GNUNET_memcpy (&se[1],
- service,
- slen);
+ se = GNUNET_malloc (sizeof (struct SubsystemEntry) + slen);
+ GNUNET_memcpy (&se[1], service, slen);
se->service = (const char *) &se[1];
- GNUNET_CONTAINER_DLL_insert (sub_head,
- sub_tail,
- se);
+ GNUNET_CONTAINER_DLL_insert (sub_head, sub_tail, se);
if (NULL != ce)
ce->subsystem = se;
return se;
* @return statistis entry, or NULL if not found
*/
static struct StatsEntry *
-find_stat_entry (struct SubsystemEntry *se,
- const char *name)
+find_stat_entry (struct SubsystemEntry *se, const char *name)
{
struct StatsEntry *pos;
for (pos = se->stat_head; NULL != pos; pos = pos->next)
- if (0 == strcmp (name, pos->name))
+ if (0 == strcmp (name, pos->name))
return pos;
return NULL;
}
* @return #GNUNET_OK if message is well-formed
*/
static int
-check_set (void *cls,
- const struct GNUNET_STATISTICS_SetMessage *msg)
+check_set (void *cls, const struct GNUNET_STATISTICS_SetMessage *msg)
{
const char *service;
const char *name;
size_t msize;
msize = ntohs (msg->header.size) - sizeof (*msg);
- if (msize !=
- GNUNET_STRINGS_buffer_tokenize ((const char *) &msg[1],
- msize,
- 2,
- &service,
- &name))
+ if (msize != GNUNET_STRINGS_buffer_tokenize ((const char *) &msg[1],
+ msize,
+ 2,
+ &service,
+ &name))
{
GNUNET_break (0);
return GNUNET_SYSERR;
* @param message the actual message
*/
static void
-handle_set (void *cls,
- const struct GNUNET_STATISTICS_SetMessage *msg)
+handle_set (void *cls, const struct GNUNET_STATISTICS_SetMessage *msg)
{
struct ClientEntry *ce = cls;
const char *service;
msize = ntohs (msg->header.size);
size = msize - sizeof (struct GNUNET_STATISTICS_SetMessage);
- GNUNET_assert (size ==
- GNUNET_STRINGS_buffer_tokenize ((const char *) &msg[1],
- size,
- 2,
- &service,
- &name));
- se = find_subsystem_entry (ce,
- service);
+ GNUNET_assert (size == GNUNET_STRINGS_buffer_tokenize ((const char *) &msg[1],
+ size,
+ 2,
+ &service,
+ &name));
+ se = find_subsystem_entry (ce, service);
flags = ntohl (msg->flags);
value = GNUNET_ntohll (msg->value);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
name,
(unsigned int) flags,
(unsigned long long) value);
- pos = find_stat_entry (se,
- name);
+ pos = find_stat_entry (se, name);
if (NULL != pos)
{
initial_set = 0;
else
{
changed = (0 != delta);
- GNUNET_break ( (delta <= 0) ||
- (pos->value + delta > pos->value) );
+ GNUNET_break ((delta <= 0) || (pos->value + delta > pos->value));
pos->value += delta;
}
}
if (pos != se->stat_head)
{
/* move to front for faster setting next time! */
- GNUNET_CONTAINER_DLL_remove (se->stat_head,
- se->stat_tail,
- pos);
- GNUNET_CONTAINER_DLL_insert (se->stat_head,
- se->stat_tail,
- pos);
+ GNUNET_CONTAINER_DLL_remove (se->stat_head, se->stat_tail, pos);
+ GNUNET_CONTAINER_DLL_insert (se->stat_head, se->stat_tail, pos);
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Statistic `%s:%s' updated to value %llu (%d).\n",
name,
(unsigned long long) pos->value,
pos->persistent);
- if ( (changed) ||
- (1 == initial_set) )
+ if ((changed) || (1 == initial_set))
notify_change (pos);
GNUNET_SERVICE_client_continue (ce->client);
return;
/* not found, create a new entry */
nlen = strlen (name) + 1;
pos = GNUNET_malloc (sizeof (struct StatsEntry) + nlen);
- GNUNET_memcpy (&pos[1],
- name,
- nlen);
+ GNUNET_memcpy (&pos[1], name, nlen);
pos->name = (const char *) &pos[1];
pos->subsystem = se;
- if ( (0 == (flags & GNUNET_STATISTICS_SETFLAG_RELATIVE)) ||
- (0 < (int64_t) GNUNET_ntohll (msg->value)) )
+ if ((0 == (flags & GNUNET_STATISTICS_SETFLAG_RELATIVE)) ||
+ (0 < (int64_t) GNUNET_ntohll (msg->value)))
{
pos->value = GNUNET_ntohll (msg->value);
pos->set = GNUNET_YES;
}
pos->uid = uidgen++;
pos->persistent = (0 != (flags & GNUNET_STATISTICS_SETFLAG_PERSISTENT));
- GNUNET_CONTAINER_DLL_insert (se->stat_head,
- se->stat_tail,
- pos);
+ GNUNET_CONTAINER_DLL_insert (se->stat_head, se->stat_tail, pos);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"New statistic on `%s:%s' with value %llu created.\n",
service,
* @return #GNUNET_OK if message is well-formed
*/
static int
-check_watch (void *cls,
- const struct GNUNET_MessageHeader *message)
+check_watch (void *cls, const struct GNUNET_MessageHeader *message)
{
size_t size;
const char *service;
const char *name;
size = ntohs (message->size) - sizeof (struct GNUNET_MessageHeader);
- if (size !=
- GNUNET_STRINGS_buffer_tokenize ((const char *) &message[1],
- size,
- 2,
- &service,
- &name))
+ if (size != GNUNET_STRINGS_buffer_tokenize ((const char *) &message[1],
+ size,
+ 2,
+ &service,
+ &name))
{
GNUNET_break (0);
return GNUNET_SYSERR;
* @param message the actual message
*/
static void
-handle_watch (void *cls,
- const struct GNUNET_MessageHeader *message)
+handle_watch (void *cls, const struct GNUNET_MessageHeader *message)
{
struct ClientEntry *ce = cls;
const char *service;
msize = ntohs (message->size);
size = msize - sizeof (struct GNUNET_MessageHeader);
GNUNET_assert (size ==
- GNUNET_STRINGS_buffer_tokenize ((const char *) &message[1],
- size,
- 2,
- &service,
- &name));
+ GNUNET_STRINGS_buffer_tokenize ((const char *) &message[1],
+ size,
+ 2,
+ &service,
+ &name));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Received request to watch statistic on `%s:%s'\n",
service,
name);
- se = find_subsystem_entry (ce,
- service);
- pos = find_stat_entry (se,
- name);
+ se = find_subsystem_entry (ce, service);
+ pos = find_stat_entry (se, name);
if (NULL == pos)
{
nlen = strlen (name) + 1;
- pos = GNUNET_malloc (sizeof (struct StatsEntry) +
- nlen);
- GNUNET_memcpy (&pos[1],
- name,
- nlen);
+ pos = GNUNET_malloc (sizeof (struct StatsEntry) + nlen);
+ GNUNET_memcpy (&pos[1], name, nlen);
pos->name = (const char *) &pos[1];
pos->subsystem = se;
- GNUNET_CONTAINER_DLL_insert (se->stat_head,
- se->stat_tail,
- pos);
+ GNUNET_CONTAINER_DLL_insert (se->stat_head, se->stat_tail, pos);
pos->uid = uidgen++;
pos->set = GNUNET_NO;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
we->ce = ce;
we->last_value_set = GNUNET_NO;
we->wid = ce->max_wid++;
- GNUNET_CONTAINER_DLL_insert (pos->we_head,
- pos->we_tail,
- we);
+ GNUNET_CONTAINER_DLL_insert (pos->we_head, pos->we_tail, we);
if (0 != pos->value)
notify_change (pos);
GNUNET_SERVICE_client_continue (ce->client);
* @param message the actual message
*/
static void
-handle_disconnect (void *cls,
- const struct GNUNET_MessageHeader *message)
+handle_disconnect (void *cls, const struct GNUNET_MessageHeader *message)
{
struct ClientEntry *ce = cls;
struct GNUNET_MQ_Envelope *env;
struct GNUNET_MessageHeader *msg;
- env = GNUNET_MQ_msg (msg,
- GNUNET_MESSAGE_TYPE_STATISTICS_DISCONNECT_CONFIRM);
- GNUNET_MQ_send (ce->mq,
- env);
+ env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_STATISTICS_DISCONNECT_CONFIRM);
+ GNUNET_MQ_send (ce->mq, env);
GNUNET_SERVICE_client_continue (ce->client);
}
GNUNET_assert (0 == client_count);
while (NULL != (se = sub_head))
{
- GNUNET_CONTAINER_DLL_remove (sub_head,
- sub_tail,
- se);
+ GNUNET_CONTAINER_DLL_remove (sub_head, sub_tail, se);
while (NULL != (pos = se->stat_head))
{
- GNUNET_CONTAINER_DLL_remove (se->stat_head,
- se->stat_tail,
- pos);
+ GNUNET_CONTAINER_DLL_remove (se->stat_head, se->stat_tail, pos);
while (NULL != (we = pos->we_head))
{
GNUNET_break (0);
- GNUNET_CONTAINER_DLL_remove (pos->we_head,
- pos->we_tail,
- we);
+ GNUNET_CONTAINER_DLL_remove (pos->we_head, pos->we_tail, we);
GNUNET_free (we);
}
GNUNET_free (pos);
*/
static void
client_disconnect_cb (void *cls,
- struct GNUNET_SERVICE_Client *client,
- void *app_cls)
+ struct GNUNET_SERVICE_Client *client,
+ void *app_cls)
{
struct ClientEntry *ce = app_cls;
struct WatchEntry *we;
wen = we->next;
if (we->ce != ce)
continue;
- GNUNET_CONTAINER_DLL_remove (pos->we_head,
- pos->we_tail,
- we);
+ GNUNET_CONTAINER_DLL_remove (pos->we_head, pos->we_tail, we);
GNUNET_free (we);
}
}
}
GNUNET_free (ce);
- if ( (0 == client_count) &&
- (GNUNET_YES == in_shutdown) )
+ if ((0 == client_count) && (GNUNET_YES == in_shutdown))
do_shutdown ();
}
*
* @param cls NULL
* @param message the message found on disk
- * @return #GNUNET_OK on success, #GNUNET_SYSERR to stop further processing
+ * @return #GNUNET_OK on success,
+ * #GNUNET_NO to stop further processing (no error)
+ * #GNUNET_SYSERR to stop further processing with error
*/
static int
-inject_message (void *cls,
- const struct GNUNET_MessageHeader *message)
+inject_message (void *cls, const struct GNUNET_MessageHeader *message)
{
uint16_t msize = ntohs (message->size);
const struct GNUNET_STATISTICS_SetMessage *sm;
sm = (const struct GNUNET_STATISTICS_SetMessage *) message;
- if ( (sizeof (struct GNUNET_STATISTICS_SetMessage) > msize) ||
- (GNUNET_OK !=
- check_set (NULL,
- sm)) )
+ if ((sizeof (struct GNUNET_STATISTICS_SetMessage) > msize) ||
+ (GNUNET_OK != check_set (NULL, sm)))
{
GNUNET_break (0);
return GNUNET_SYSERR;
}
- handle_set (NULL,
- sm);
+ handle_set (NULL, sm);
return GNUNET_OK;
}
char *buf;
struct GNUNET_MessageStreamTokenizer *mst;
- if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_filename (cfg,
- "STATISTICS",
- "DATABASE",
- &fn))
+ if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg,
+ "STATISTICS",
+ "DATABASE",
+ &fn))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
"STATISTICS",
"DATABASE");
return;
}
- if ( (GNUNET_OK !=
- GNUNET_DISK_file_size (fn,
- &fsize,
- GNUNET_NO,
- GNUNET_YES)) ||
- (0 == fsize) )
+ if ((GNUNET_OK !=
+ GNUNET_DISK_file_size (fn, &fsize, GNUNET_NO, GNUNET_YES)) ||
+ (0 == fsize))
{
GNUNET_free (fn);
return;
GNUNET_free (fn);
return;
}
- if (GNUNET_OK !=
- GNUNET_BIO_read (rh,
- fn,
- buf,
- fsize))
+ if (GNUNET_OK != GNUNET_BIO_read (rh, fn, buf, fsize))
{
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
- "read",
- fn);
- GNUNET_break (GNUNET_OK ==
- GNUNET_BIO_read_close (rh,
- NULL));
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "read", fn);
+ GNUNET_break (GNUNET_OK == GNUNET_BIO_read_close (rh, NULL));
GNUNET_free (buf);
GNUNET_free (fn);
return;
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
- _("Loading %llu bytes of statistics from `%s'\n"),
+ _ ("Loading %llu bytes of statistics from `%s'\n"),
(unsigned long long) fsize,
- fn);
- mst = GNUNET_MST_create (&inject_message,
- NULL);
- GNUNET_break (GNUNET_OK ==
- GNUNET_MST_from_buffer (mst,
- buf,
- (size_t) fsize,
- GNUNET_YES,
- GNUNET_NO));
+ fn);
+ mst = GNUNET_MST_create (&inject_message, NULL);
+ GNUNET_break (
+ GNUNET_OK ==
+ GNUNET_MST_from_buffer (mst, buf, (size_t) fsize, GNUNET_YES, GNUNET_NO));
GNUNET_MST_destroy (mst);
GNUNET_free (buf);
- GNUNET_break (GNUNET_OK ==
- GNUNET_BIO_read_close (rh,
- NULL));
+ GNUNET_break (GNUNET_OK == GNUNET_BIO_read_close (rh, NULL));
GNUNET_free (fn);
}
cfg = c;
nc = GNUNET_notification_context_create (16);
load ();
- GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
- NULL);
+ GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
}
/**
* Define "main" method using service macro.
*/
-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 ());
+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 ());
#if defined(LINUX) && defined(__GLIBC__)
/**
* MINIMIZE heap size (way below 128k) since this process doesn't need much.
*/
-void __attribute__ ((constructor))
-GNUNET_STATISTICS_memory_init ()
+void __attribute__ ((constructor)) GNUNET_STATISTICS_memory_init ()
{
mallopt (M_TRIM_THRESHOLD, 4 * 1024);
mallopt (M_TOP_PAD, 1 * 1024);
projects / oweals / gnunet.git / blobdiff