[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[GNUnet-SVN] r34075 - in gnunet/src: include sensor sensordashboard
|
From: |
gnunet |
|
Subject: |
[GNUnet-SVN] r34075 - in gnunet/src: include sensor sensordashboard |
|
Date: |
Tue, 29 Jul 2014 16:01:37 +0200 |
Author: otarabai
Date: 2014-07-29 16:01:37 +0200 (Tue, 29 Jul 2014)
New Revision: 34075
Modified:
gnunet/src/include/gnunet_sensor_service.h
gnunet/src/include/gnunet_sensor_util_lib.h
gnunet/src/sensor/gnunet-sensor.c
gnunet/src/sensor/gnunet-service-sensor-analysis.c
gnunet/src/sensor/gnunet-service-sensor-reporting.c
gnunet/src/sensor/gnunet-service-sensor-update.c
gnunet/src/sensor/gnunet-service-sensor.c
gnunet/src/sensor/gnunet_sensor_model_plugin.h
gnunet/src/sensor/plugin_sensor_model_gaussian.c
gnunet/src/sensor/sensor.h
gnunet/src/sensor/sensor_api.c
gnunet/src/sensor/sensor_util_lib.c
gnunet/src/sensor/test_sensor_api.c
gnunet/src/sensordashboard/gnunet-sensordashboard.c
gnunet/src/sensordashboard/gnunet-service-sensordashboard.c
gnunet/src/sensordashboard/sensordashboard.h
Log:
sensor, sensordashboard: doxygen fixes + indentation
Modified: gnunet/src/include/gnunet_sensor_service.h
===================================================================
--- gnunet/src/include/gnunet_sensor_service.h 2014-07-29 13:06:05 UTC (rev
34074)
+++ gnunet/src/include/gnunet_sensor_service.h 2014-07-29 14:01:37 UTC (rev
34075)
@@ -79,18 +79,19 @@
* @param error message
*/
typedef void (*GNUNET_SENSOR_SensorIteratorCB) (void *cls,
- const struct SensorInfoShort
*sensor,
- const char *err_msg);
+ const struct SensorInfoShort *
+ sensor, const char *err_msg);
+
/**
* Continuation called with a status result.
*
* @param cls closure
* @param emsg error message, NULL on success
*/
-typedef void (*GNUNET_SENSOR_Continuation)(void *cls,
- const char *emsg);
+typedef void (*GNUNET_SENSOR_Continuation) (void *cls, const char *emsg);
+
/**
* Connect to the sensor service.
*
@@ -99,14 +100,16 @@
struct GNUNET_SENSOR_Handle *
GNUNET_SENSOR_connect (const struct GNUNET_CONFIGURATION_Handle *cfg);
+
/**
* Disconnect from the sensor service
*
* @param h handle to disconnect
*/
void
-GNUNET_SENSOR_disconnect(struct GNUNET_SENSOR_Handle *h);
+GNUNET_SENSOR_disconnect (struct GNUNET_SENSOR_Handle *h);
+
/**
* Client asking to iterate all available sensors
*
@@ -120,9 +123,10 @@
*/
struct GNUNET_SENSOR_SensorIteratorContext *
GNUNET_SENSOR_iterate_sensors (struct GNUNET_SENSOR_Handle *h,
- struct GNUNET_TIME_Relative timeout,
- const char* sensorname, size_t sensorname_len,
- GNUNET_SENSOR_SensorIteratorCB callback, void *callback_cls);
+ struct GNUNET_TIME_Relative timeout,
+ const char *sensorname, size_t sensorname_len,
+ GNUNET_SENSOR_SensorIteratorCB callback,
+ void *callback_cls);
#if 0 /* keep Emacsens' auto-indent happy */
{
Modified: gnunet/src/include/gnunet_sensor_util_lib.h
===================================================================
--- gnunet/src/include/gnunet_sensor_util_lib.h 2014-07-29 13:06:05 UTC (rev
34074)
+++ gnunet/src/include/gnunet_sensor_util_lib.h 2014-07-29 14:01:37 UTC (rev
34075)
@@ -188,12 +188,11 @@
};
GNUNET_NETWORK_STRUCT_BEGIN
-
/**
* Used to communicate sensor readings to
* collection points (SENSORDASHBAORD service)
*/
-struct GNUNET_SENSOR_ReadingMessage
+ struct GNUNET_SENSOR_ReadingMessage
{
/**
@@ -297,8 +296,6 @@
};
GNUNET_NETWORK_STRUCT_END
-
-
/**
* Given two version numbers as major and minor, compare them.
*
@@ -307,7 +304,7 @@
* @param v2_major First part of second version number
* @param v2_minor Second part of second version number
*/
-int
+ int
GNUNET_SENSOR_version_compare (uint16_t v1_major, uint16_t v1_minor,
uint16_t v2_major, uint16_t v2_minor);
Modified: gnunet/src/sensor/gnunet-sensor.c
===================================================================
--- gnunet/src/sensor/gnunet-sensor.c 2014-07-29 13:06:05 UTC (rev 34074)
+++ gnunet/src/sensor/gnunet-sensor.c 2014-07-29 14:01:37 UTC (rev 34075)
@@ -51,16 +51,16 @@
* @param tc scheduler context
*/
static void
-shutdown_task (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
- if(NULL != sensor_handle)
+ if (NULL != sensor_handle)
{
- GNUNET_SENSOR_disconnect(sensor_handle);
+ GNUNET_SENSOR_disconnect (sensor_handle);
sensor_handle = NULL;
}
}
+
/**
* Callback for getting sensor info from service
*
@@ -68,27 +68,26 @@
* @param sensor brief information about sensor (NULL means end of
transmission)
* @param err_msg contains error string if any
*/
-void print_sensor_info(void *cls,
- const struct SensorInfoShort *sensor,
- const char *err_msg)
+void
+print_sensor_info (void *cls, const struct SensorInfoShort *sensor,
+ const char *err_msg)
{
- if(NULL != err_msg)
+ if (NULL != err_msg)
{
- printf("Error: %s\n", err_msg);
- GNUNET_SCHEDULER_shutdown();
+ printf ("Error: %s\n", err_msg);
+ GNUNET_SCHEDULER_shutdown ();
return;
}
- if(NULL == sensor) /* no more sensors from service */
+ if (NULL == sensor) /* no more sensors from service */
return;
- printf("Name: %s\nVersion: %d.%d\n",
- sensor->name,
- sensor->version_major,
- sensor->version_minor);
- if(NULL != sensor->description)
- printf("Description: %s\n", sensor->description);
- printf("\n");
+ printf ("Name: %s\nVersion: %d.%d\n", sensor->name, sensor->version_major,
+ sensor->version_minor);
+ if (NULL != sensor->description)
+ printf ("Description: %s\n", sensor->description);
+ printf ("\n");
}
+
/**
* Main function that will be run by the scheduler.
*
@@ -98,41 +97,31 @@
* @param cfg configuration
*/
static void
-run (void *cls,
- char *const *args,
- const char *cfgfile,
+run (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
-
sensor_handle = NULL;
- GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
- &shutdown_task,
- NULL);
- sensor_handle = GNUNET_SENSOR_connect(cfg);
- GNUNET_assert(NULL != sensor_handle);
- if(GNUNET_YES == get_all)
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
+ NULL);
+ sensor_handle = GNUNET_SENSOR_connect (cfg);
+ GNUNET_assert (NULL != sensor_handle);
+ if (GNUNET_YES == get_all)
{
- GNUNET_SENSOR_iterate_sensors(sensor_handle,
- GNUNET_TIME_UNIT_FOREVER_REL,
- NULL,
- 0,
- &print_sensor_info,
- NULL);
+ GNUNET_SENSOR_iterate_sensors (sensor_handle, GNUNET_TIME_UNIT_FOREVER_REL,
+ NULL, 0, &print_sensor_info, NULL);
}
- else if(NULL != get_sensor)
+ else if (NULL != get_sensor)
{
- GNUNET_SENSOR_iterate_sensors(sensor_handle,
- GNUNET_TIME_UNIT_FOREVER_REL,
- get_sensor,
- strlen(get_sensor),
- &print_sensor_info,
- NULL);
+ GNUNET_SENSOR_iterate_sensors (sensor_handle, GNUNET_TIME_UNIT_FOREVER_REL,
+ get_sensor, strlen (get_sensor),
+ &print_sensor_info, NULL);
}
- GNUNET_SCHEDULER_shutdown();
+ GNUNET_SCHEDULER_shutdown ();
ret = 0;
}
+
/**
* The main function to sensor.
*
@@ -144,21 +133,19 @@
main (int argc, char *const *argv)
{
static const struct GNUNET_GETOPT_CommandLineOption options[] = {
- {'a', "all", NULL,
- gettext_noop("Retrieve information about all defined sensors"),
- 0, &GNUNET_GETOPT_set_one, &get_all},
- {'g', "get-sensor", NULL,
- gettext_noop("Retrieve information about a single sensor"),
- 1, &GNUNET_GETOPT_set_string, &get_sensor},
+ {'a', "all", NULL,
+ gettext_noop ("Retrieve information about all defined sensors"),
+ 0, &GNUNET_GETOPT_set_one, &get_all},
+ {'g', "get-sensor", NULL,
+ gettext_noop ("Retrieve information about a single sensor"),
+ 1, &GNUNET_GETOPT_set_string, &get_sensor},
GNUNET_GETOPT_OPTION_END
};
+
return (GNUNET_OK ==
- GNUNET_PROGRAM_run (argc,
- argv,
- "gnunet-sensor [options [value]]",
- gettext_noop
- ("sensor"),
- options, &run, NULL)) ? ret : 1;
+ GNUNET_PROGRAM_run (argc, argv, "gnunet-sensor [options [value]]",
+ gettext_noop ("sensor"), options, &run,
+ NULL)) ? ret : 1;
}
/* end of gnunet-sensor.c */
Modified: gnunet/src/sensor/gnunet-service-sensor-analysis.c
===================================================================
--- gnunet/src/sensor/gnunet-service-sensor-analysis.c 2014-07-29 13:06:05 UTC
(rev 34074)
+++ gnunet/src/sensor/gnunet-service-sensor-analysis.c 2014-07-29 14:01:37 UTC
(rev 34075)
@@ -100,19 +100,18 @@
*/
struct GNUNET_PeerIdentity peerid;
-/*
+/**
* Destroy a created model
*/
static void
destroy_sensor_model (struct SensorModel *sensor_model)
{
GNUNET_assert (NULL != sensor_model);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Destroying sensor model for `%s'.\n",
- sensor_model->sensor->name);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Destroying sensor model for `%s'.\n",
+ sensor_model->sensor->name);
if (NULL != sensor_model->wc)
{
- GNUNET_PEERSTORE_watch_cancel(sensor_model->wc);
+ GNUNET_PEERSTORE_watch_cancel (sensor_model->wc);
sensor_model->wc = NULL;
}
if (NULL != sensor_model->cls)
@@ -120,14 +119,16 @@
model_api->destroy_model (sensor_model->cls);
sensor_model->cls = NULL;
}
- GNUNET_free(sensor_model);
+ GNUNET_free (sensor_model);
sensor_model = NULL;
}
-/*
+
+/**
* Stop the sensor analysis module
*/
-void SENSOR_analysis_stop()
+void
+SENSOR_analysis_stop ()
{
struct SensorModel *sm;
@@ -135,12 +136,12 @@
while (NULL != models_head)
{
sm = models_head;
- GNUNET_CONTAINER_DLL_remove(models_head, models_tail, sm);
- destroy_sensor_model(sm);
+ GNUNET_CONTAINER_DLL_remove (models_head, models_tail, sm);
+ destroy_sensor_model (sm);
}
if (NULL != peerstore)
{
- GNUNET_PEERSTORE_disconnect(peerstore, GNUNET_YES);
+ GNUNET_PEERSTORE_disconnect (peerstore, GNUNET_YES);
peerstore = NULL;
}
if (NULL != model_api)
@@ -151,40 +152,39 @@
}
}
-/*
+
+/**
* Sensor value watch callback
*/
static int
-sensor_watcher (void *cls,
- struct GNUNET_PEERSTORE_Record *record,
- char *emsg)
+sensor_watcher (void *cls, struct GNUNET_PEERSTORE_Record *record, char *emsg)
{
struct SensorModel *sensor_model = cls;
double *val;
int anomalous;
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Received a sensor value, will feed to sensor model.\n");
- if (sizeof(double) != record->value_size)
+ "Received a sensor value, will feed to sensor model.\n");
+ if (sizeof (double) != record->value_size)
{
- LOG (GNUNET_ERROR_TYPE_ERROR,
- _("Received an invalid sensor value."));
+ LOG (GNUNET_ERROR_TYPE_ERROR, _("Received an invalid sensor value."));
return GNUNET_YES;
}
- val = (double *)(record->value);
+ val = (double *) (record->value);
anomalous = model_api->feed_model (sensor_model->cls, *val);
if (GNUNET_YES == anomalous)
{
LOG (GNUNET_ERROR_TYPE_WARNING,
- "Anomaly detected in sensor `%s', value: %f.\n",
- sensor_model->sensor->name, *val);
+ "Anomaly detected in sensor `%s', value: %f.\n",
+ sensor_model->sensor->name, *val);
}
else
LOG (GNUNET_ERROR_TYPE_DEBUG, "Value non-anomalous.\n");
return GNUNET_YES;
}
-/*
+
+/**
* Iterator for defined sensors
* Creates sensor model for numeric sensors
*
@@ -194,28 +194,27 @@
* @return #GNUNET_YES to continue iterations
*/
static int
-init_sensor_model (void *cls,
- const struct GNUNET_HashCode *key,
- void *value)
+init_sensor_model (void *cls, const struct GNUNET_HashCode *key, void *value)
{
struct GNUNET_SENSOR_SensorInfo *sensor = value;
struct SensorModel *sensor_model;
- if (0 != strcmp("numeric", sensor->expected_datatype))
+ if (0 != strcmp ("numeric", sensor->expected_datatype))
return GNUNET_YES;
- sensor_model = GNUNET_new(struct SensorModel);
+ sensor_model = GNUNET_new (struct SensorModel);
sensor_model->sensor = sensor;
- sensor_model->wc = GNUNET_PEERSTORE_watch(peerstore,
- "sensor", &peerid, sensor->name,
- &sensor_watcher, sensor_model);
- sensor_model->cls = model_api->create_model(model_api->cls);
- GNUNET_CONTAINER_DLL_insert(models_head, models_tail, sensor_model);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Created sensor model for `%s'.\n", sensor->name);
+ sensor_model->wc =
+ GNUNET_PEERSTORE_watch (peerstore, "sensor", &peerid, sensor->name,
+ &sensor_watcher, sensor_model);
+ sensor_model->cls = model_api->create_model (model_api->cls);
+ GNUNET_CONTAINER_DLL_insert (models_head, models_tail, sensor_model);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Created sensor model for `%s'.\n",
+ sensor->name);
return GNUNET_YES;
}
-/*
+
+/**
* Start the sensor analysis module
*
* @param c our service configuration
@@ -223,38 +222,41 @@
* @return #GNUNET_OK if started successfully, #GNUNET_SYSERR otherwise
*/
int
-SENSOR_analysis_start(const struct GNUNET_CONFIGURATION_Handle *c,
- struct GNUNET_CONTAINER_MultiHashMap *sensors)
+SENSOR_analysis_start (const struct GNUNET_CONFIGURATION_Handle *c,
+ struct GNUNET_CONTAINER_MultiHashMap *sensors)
{
char *model_name;
- GNUNET_assert(NULL != sensors);
+ GNUNET_assert (NULL != sensors);
cfg = c;
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_string (cfg, "sensor-analysis", "MODEL",
- &model_name))
+ &model_name))
{
- LOG (GNUNET_ERROR_TYPE_ERROR, _("Analysis model not defined in
configuration.\n"));
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ _("Analysis model not defined in configuration.\n"));
return GNUNET_SYSERR;
}
- GNUNET_asprintf (&model_lib_name, "libgnunet_plugin_sensor_model_%s",
model_name);
- model_api = GNUNET_PLUGIN_load(model_lib_name, (void *) cfg);
- GNUNET_free(model_name);
- if(NULL == model_api)
+ GNUNET_asprintf (&model_lib_name, "libgnunet_plugin_sensor_model_%s",
+ model_name);
+ model_api = GNUNET_PLUGIN_load (model_lib_name, (void *) cfg);
+ GNUNET_free (model_name);
+ if (NULL == model_api)
{
- LOG (GNUNET_ERROR_TYPE_ERROR, _("Could not load analysis model `%s'.\n"),
model_lib_name);
+ LOG (GNUNET_ERROR_TYPE_ERROR, _("Could not load analysis model `%s'.\n"),
+ model_lib_name);
return GNUNET_SYSERR;
}
- peerstore = GNUNET_PEERSTORE_connect(cfg);
+ peerstore = GNUNET_PEERSTORE_connect (cfg);
if (NULL == peerstore)
{
- LOG (GNUNET_ERROR_TYPE_ERROR, _("Could not connect to peerstore
service.\n"));
- SENSOR_analysis_stop();
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ _("Could not connect to peerstore service.\n"));
+ SENSOR_analysis_stop ();
return GNUNET_SYSERR;
}
- GNUNET_CRYPTO_get_peer_identity(cfg, &peerid);
- GNUNET_CONTAINER_multihashmap_iterate(sensors, &init_sensor_model, NULL);
-
+ GNUNET_CRYPTO_get_peer_identity (cfg, &peerid);
+ GNUNET_CONTAINER_multihashmap_iterate (sensors, &init_sensor_model, NULL);
return GNUNET_OK;
}
Modified: gnunet/src/sensor/gnunet-service-sensor-reporting.c
===================================================================
--- gnunet/src/sensor/gnunet-service-sensor-reporting.c 2014-07-29 13:06:05 UTC
(rev 34074)
+++ gnunet/src/sensor/gnunet-service-sensor-reporting.c 2014-07-29 14:01:37 UTC
(rev 34075)
@@ -182,7 +182,6 @@
*/
struct CadetChannelContext *cc_tail;
-
/**
* Destroy a reporting context structure
*/
@@ -196,7 +195,7 @@
}
if (GNUNET_SCHEDULER_NO_TASK != rc->cp_task)
{
- GNUNET_SCHEDULER_cancel(rc->cp_task);
+ GNUNET_SCHEDULER_cancel (rc->cp_task);
rc->cp_task = GNUNET_SCHEDULER_NO_TASK;
}
if (NULL != rc->last_value)
@@ -204,9 +203,10 @@
GNUNET_free (rc->last_value);
rc->last_value_size = 0;
}
- GNUNET_free(rc);
+ GNUNET_free (rc);
}
+
/**
* Destroy a CADET channel context struct
*/
@@ -242,8 +242,7 @@
struct ReportingContext *rc;
struct CadetChannelContext *cc;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Stopping sensor reporting module.\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Stopping sensor reporting module.\n");
while (NULL != cc_head)
{
cc = cc_head;
@@ -289,11 +288,10 @@
cc = cc->next;
}
cc = GNUNET_new (struct CadetChannelContext);
- cc->c = GNUNET_CADET_channel_create(cadet,
- cc,
- &pid,
- GNUNET_APPLICATION_TYPE_SENSORDASHBOARD,
- GNUNET_CADET_OPTION_DEFAULT);
+ cc->c =
+ GNUNET_CADET_channel_create (cadet, cc, &pid,
+ GNUNET_APPLICATION_TYPE_SENSORDASHBOARD,
+ GNUNET_CADET_OPTION_DEFAULT);
cc->pid = pid;
cc->sending = GNUNET_NO;
cc->destroying = GNUNET_NO;
@@ -319,8 +317,8 @@
void *dummy;
sensorname_size = strlen (rc->sensor->name) + 1;
- total_size = sizeof(struct GNUNET_SENSOR_ReadingMessage) +
- sensorname_size +
+ total_size =
+ sizeof (struct GNUNET_SENSOR_ReadingMessage) + sensorname_size +
rc->last_value_size;
ret = GNUNET_malloc (total_size);
ret->header.size = htons (total_size);
@@ -357,18 +355,17 @@
cc->th = NULL;
cc->sending = GNUNET_NO;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Copying to CADET transmit buffer.\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Copying to CADET transmit buffer.\n");
if (NULL == buf)
{
LOG (GNUNET_ERROR_TYPE_WARNING,
- "CADET failed to transmit message (NULL buf), discarding.\n");
+ "CADET failed to transmit message (NULL buf), discarding.\n");
}
else if (size < cc->pending_msg_size)
{
LOG (GNUNET_ERROR_TYPE_WARNING,
- "CADET failed to transmit message (small size, expected: %u, got: %u)"
- ", discarding.\n", cc->pending_msg_size, size);
+ "CADET failed to transmit message (small size, expected: %u, got: %u)"
+ ", discarding.\n", cc->pending_msg_size, size);
}
else
{
@@ -390,7 +387,7 @@
*/
static void
report_collection_point (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext* tc)
+ const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct ReportingContext *rc = cls;
struct GNUNET_SENSOR_SensorInfo *sensor = rc->sensor;
@@ -404,13 +401,13 @@
LOG (GNUNET_ERROR_TYPE_WARNING,
"Did not receive a value from `%s' to report yet.\n",
rc->sensor->name);
- rc->cp_task = GNUNET_SCHEDULER_add_delayed (sensor->collection_interval,
- &report_collection_point, rc);
+ rc->cp_task =
+ GNUNET_SCHEDULER_add_delayed (sensor->collection_interval,
+ &report_collection_point, rc);
return;
}
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Now trying to report last seen value of `%s' "
- "to collection point.\n",
+ "Now trying to report last seen value of `%s' " "to collection
point.\n",
rc->sensor->name);
GNUNET_assert (NULL != sensor->collection_point);
cc = get_cadet_channel (*sensor->collection_point);
@@ -418,26 +415,26 @@
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Cadet channel to collection point busy, "
- "trying again for sensor `%s' after %d seconds.\n",
- rc->sensor->name,
+ "trying again for sensor `%s' after %d seconds.\n", rc->sensor->name,
COLLECTION_RETRY);
- rc->cp_task = GNUNET_SCHEDULER_add_delayed (
- GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS,
COLLECTION_RETRY),
- &report_collection_point, rc);
+ rc->cp_task =
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+ (GNUNET_TIME_UNIT_SECONDS,
+ COLLECTION_RETRY),
+ &report_collection_point, rc);
return;
}
msg_size = construct_reading_message (rc, &msg);
cc->sending = GNUNET_YES;
cc->pending_msg = msg;
cc->pending_msg_size = msg_size;
- cc->th = GNUNET_CADET_notify_transmit_ready (cc->c,
- GNUNET_YES,
- sensor->collection_interval,
- msg_size,
- &do_report_collection_point,
- cc);
- rc->cp_task = GNUNET_SCHEDULER_add_delayed (sensor->collection_interval,
- &report_collection_point, rc);
+ cc->th =
+ GNUNET_CADET_notify_transmit_ready (cc->c, GNUNET_YES,
+ sensor->collection_interval,
msg_size,
+ &do_report_collection_point, cc);
+ rc->cp_task =
+ GNUNET_SCHEDULER_add_delayed (sensor->collection_interval,
+ &report_collection_point, rc);
}
@@ -445,9 +442,7 @@
* Sensor value watch callback
*/
static int
-sensor_watch_cb (void *cls,
- struct GNUNET_PEERSTORE_Record *record,
- char *emsg)
+sensor_watch_cb (void *cls, struct GNUNET_PEERSTORE_Record *record, char *emsg)
{
struct ReportingContext *rc = cls;
@@ -458,14 +453,13 @@
GNUNET_free (rc->last_value);
rc->last_value_size = 0;
}
- rc->last_value = GNUNET_malloc(record->value_size);
+ rc->last_value = GNUNET_malloc (record->value_size);
memcpy (rc->last_value, record->value, record->value_size);
rc->last_value_size = record->value_size;
- rc->timestamp = GNUNET_TIME_absolute_get().abs_value_us;
+ rc->timestamp = GNUNET_TIME_absolute_get ().abs_value_us;
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Received a sensor `%s' watch value at "
- "timestamp %" PRIu64 ", updating notification last_value.\n",
- rc->sensor->name,
+ "Received a sensor `%s' watch value at " "timestamp %" PRIu64
+ ", updating notification last_value.\n", rc->sensor->name,
rc->timestamp);
return GNUNET_YES;
}
@@ -481,46 +475,40 @@
* @return #GNUNET_YES to continue iterations
*/
static int
-init_sensor_reporting (void *cls,
- const struct GNUNET_HashCode *key,
+init_sensor_reporting (void *cls, const struct GNUNET_HashCode *key,
void *value)
{
struct GNUNET_SENSOR_SensorInfo *sensor = value;
struct ReportingContext *rc;
- if (NULL == sensor->collection_point &&
- GNUNET_NO == sensor->p2p_report)
+ if (NULL == sensor->collection_point && GNUNET_NO == sensor->p2p_report)
return GNUNET_YES;
rc = GNUNET_new (struct ReportingContext);
rc->sensor = sensor;
rc->last_value = NULL;
rc->last_value_size = 0;
- rc->wc = GNUNET_PEERSTORE_watch(peerstore,
- "sensor",
- &mypeerid,
- sensor->name,
- &sensor_watch_cb,
- rc);
+ rc->wc =
+ GNUNET_PEERSTORE_watch (peerstore, "sensor", &mypeerid, sensor->name,
+ &sensor_watch_cb, rc);
if (NULL != sensor->collection_point)
{
LOG (GNUNET_ERROR_TYPE_INFO,
- "Will start reporting sensor `%s' values to "
- "collection point `%s' every %s.\n",
- sensor->name, GNUNET_i2s_full(sensor->collection_point),
- GNUNET_STRINGS_relative_time_to_string(sensor->collection_interval,
- GNUNET_YES));
+ "Will start reporting sensor `%s' values to "
+ "collection point `%s' every %s.\n", sensor->name,
+ GNUNET_i2s_full (sensor->collection_point),
+ GNUNET_STRINGS_relative_time_to_string (sensor->collection_interval,
+ GNUNET_YES));
rc->cp_task =
GNUNET_SCHEDULER_add_delayed (sensor->collection_interval,
- &report_collection_point,
- rc);
+ &report_collection_point, rc);
}
if (GNUNET_YES == sensor->p2p_report)
{
LOG (GNUNET_ERROR_TYPE_INFO,
- "Will start reporting sensor `%s' values to p2p network every %s.\n",
- sensor->name,
- GNUNET_STRINGS_relative_time_to_string(sensor->p2p_interval,
- GNUNET_YES));
+ "Will start reporting sensor `%s' values to p2p network every %s.\n",
+ sensor->name,
+ GNUNET_STRINGS_relative_time_to_string (sensor->p2p_interval,
+ GNUNET_YES));
}
GNUNET_CONTAINER_DLL_insert (rc_head, rc_tail, rc);
return GNUNET_YES;
@@ -539,8 +527,7 @@
* with the channel is stored
*/
static void
-cadet_channel_destroyed (void *cls,
- const struct GNUNET_CADET_Channel *channel,
+cadet_channel_destroyed (void *cls, const struct GNUNET_CADET_Channel *channel,
void *channel_ctx)
{
struct CadetChannelContext *cc = channel_ctx;
@@ -567,38 +554,31 @@
struct GNUNET_CONTAINER_MultiHashMap *sensors)
{
static struct GNUNET_CADET_MessageHandler cadet_handlers[] = {
- {NULL, 0, 0}
+ {NULL, 0, 0}
};
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Starting sensor reporting module.\n");
- GNUNET_assert(NULL != sensors);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Starting sensor reporting module.\n");
+ GNUNET_assert (NULL != sensors);
cfg = c;
- peerstore = GNUNET_PEERSTORE_connect(cfg);
+ peerstore = GNUNET_PEERSTORE_connect (cfg);
if (NULL == peerstore)
{
LOG (GNUNET_ERROR_TYPE_ERROR,
- _("Failed to connect to peerstore service.\n"));
+ _("Failed to connect to peerstore service.\n"));
SENSOR_reporting_stop ();
return GNUNET_SYSERR;
}
- cadet = GNUNET_CADET_connect(cfg,
- NULL,
- NULL,
- &cadet_channel_destroyed,
- cadet_handlers,
- NULL);
+ cadet =
+ GNUNET_CADET_connect (cfg, NULL, NULL, &cadet_channel_destroyed,
+ cadet_handlers, NULL);
if (NULL == cadet)
{
- LOG (GNUNET_ERROR_TYPE_ERROR,
- _("Failed to connect to CADET service.\n"));
+ LOG (GNUNET_ERROR_TYPE_ERROR, _("Failed to connect to CADET service.\n"));
SENSOR_reporting_stop ();
return GNUNET_SYSERR;
}
- GNUNET_CRYPTO_get_peer_identity (cfg,
- &mypeerid);
- GNUNET_CONTAINER_multihashmap_iterate(sensors,
- &init_sensor_reporting, NULL);
+ GNUNET_CRYPTO_get_peer_identity (cfg, &mypeerid);
+ GNUNET_CONTAINER_multihashmap_iterate (sensors, &init_sensor_reporting,
NULL);
return GNUNET_OK;
}
Modified: gnunet/src/sensor/gnunet-service-sensor-update.c
===================================================================
--- gnunet/src/sensor/gnunet-service-sensor-update.c 2014-07-29 13:06:05 UTC
(rev 34074)
+++ gnunet/src/sensor/gnunet-service-sensor-update.c 2014-07-29 14:01:37 UTC
(rev 34075)
@@ -168,7 +168,7 @@
/**
* Pointer to service reset function called when we have new sensor updates.
*/
-void (*reset_cb)();
+void (*reset_cb) ();
/**
@@ -178,9 +178,9 @@
* @param tc GNUnet scheduler task context
*/
static void
-check_for_updates (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc);
+check_for_updates (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
+
/**
* Trigger sending next pending message to the default update point if any.
*
@@ -249,8 +249,7 @@
GNUNET_CADET_disconnect (cadet);
cadet = NULL;
}
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Sensor update module stopped.\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Sensor update module stopped.\n");
}
@@ -277,8 +276,9 @@
up->failed = GNUNET_NO;
up = up->next;
}
- update_task = GNUNET_SCHEDULER_add_delayed (SENSOR_UPDATE_CHECK_INTERVAL,
- &check_for_updates, NULL);
+ update_task =
+ GNUNET_SCHEDULER_add_delayed (SENSOR_UPDATE_CHECK_INTERVAL,
+ &check_for_updates, NULL);
return;
}
LOG (GNUNET_ERROR_TYPE_WARNING,
@@ -342,11 +342,9 @@
return;
pm = up_default->pm_head;
up_default->th =
- GNUNET_CADET_notify_transmit_ready (up_default->ch,
- GNUNET_YES,
+ GNUNET_CADET_notify_transmit_ready (up_default->ch, GNUNET_YES,
GNUNET_TIME_UNIT_FOREVER_REL,
- ntohs (pm->msg->size),
- &do_send_msg,
+ ntohs (pm->msg->size), &do_send_msg,
NULL);
}
@@ -362,9 +360,9 @@
struct PendingMessage *pm;
pm = GNUNET_new (struct PendingMessage);
+
pm->msg = msg;
- GNUNET_CONTAINER_DLL_insert_tail (up_default->pm_head,
- up_default->pm_tail,
+ GNUNET_CONTAINER_DLL_insert_tail (up_default->pm_head, up_default->pm_tail,
pm);
trigger_send_next_msg ();
}
@@ -377,8 +375,7 @@
* @param tc GNUnet scheduler task context
*/
static void
-check_for_updates (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+check_for_updates (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GNUNET_MessageHeader *msg;
size_t msg_size;
@@ -393,18 +390,16 @@
"Retrying in %s.\n",
GNUNET_STRINGS_relative_time_to_string (SENSOR_UPDATE_CHECK_RETRY,
GNUNET_NO));
- update_task = GNUNET_SCHEDULER_add_delayed (SENSOR_UPDATE_CHECK_RETRY,
- &check_for_updates, NULL);
+ update_task =
+ GNUNET_SCHEDULER_add_delayed (SENSOR_UPDATE_CHECK_RETRY,
+ &check_for_updates, NULL);
return;
}
updating = GNUNET_YES;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Checking for sensor updates.\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Checking for sensor updates.\n");
GNUNET_assert (NULL != up_default);
up_default->ch =
- GNUNET_CADET_channel_create (cadet,
- up_default,
- &up_default->peer_id,
+ GNUNET_CADET_channel_create (cadet, up_default, &up_default->peer_id,
GNUNET_APPLICATION_TYPE_SENSORUPDATE,
GNUNET_CADET_OPTION_DEFAULT);
if (NULL == up_default->ch)
@@ -422,8 +417,9 @@
msg->size = htons (msg_size);
msg->type = htons (GNUNET_MESSAGE_TYPE_SENSOR_LIST_REQ);
queue_msg (msg);
- update_task = GNUNET_SCHEDULER_add_delayed (SENSOR_UPDATE_CHECK_INTERVAL,
- &check_for_updates, NULL);
+ update_task =
+ GNUNET_SCHEDULER_add_delayed (SENSOR_UPDATE_CHECK_INTERVAL,
+ &check_for_updates, NULL);
}
@@ -444,18 +440,16 @@
struct GNUNET_CRYPTO_EddsaPublicKey public_key;
struct UpdatePoint *up;
- if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg,
- "sensor",
- "UPDATE_POINTS",
- &points_list))
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_string (cfg, "sensor", "UPDATE_POINTS",
+ &points_list))
{
- GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
- "sensor",
+ GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "sensor",
"UPDATE_POINTS");
return GNUNET_SYSERR;
}
points_list_len = strlen (points_list) + 1;
- for (i = 0; i < points_list_len; i ++)
+ for (i = 0; i < points_list_len; i++)
{
if (' ' == points_list[i])
continue;
@@ -463,20 +457,20 @@
len = 0;
while (' ' != points_list[i] && '\0' != points_list[i])
{
- len ++;
- i ++;
+ len++;
+ i++;
}
if (GNUNET_OK !=
- GNUNET_CRYPTO_eddsa_public_key_from_string (points_list + start,
- len,
+ GNUNET_CRYPTO_eddsa_public_key_from_string (points_list + start, len,
&public_key))
{
LOG (GNUNET_ERROR_TYPE_ERROR,
- "Invalid EDDSA public key `%.*s' for update point.\n",
- len, points_list + len);
+ "Invalid EDDSA public key `%.*s' for update point.\n", len,
+ points_list + len);
continue;
}
up = GNUNET_new (struct UpdatePoint);
+
up->peer_id.public_key = public_key;
up->ch = NULL;
up->th = NULL;
@@ -484,8 +478,7 @@
up->expected_sensor_updates = 0;
up->failed = GNUNET_NO;
GNUNET_CONTAINER_DLL_insert (up_head, up_tail, up);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Loaded update point `%s'.\n",
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Loaded update point `%s'.\n",
GNUNET_i2s_full (&up->peer_id));
}
GNUNET_free (points_list);
@@ -505,8 +498,7 @@
* #GNUNET_NO if we have it
*/
static int
-update_required (char *sensorname,
- uint16_t sensorversion_major,
+update_required (char *sensorname, uint16_t sensorversion_major,
uint16_t sensorversion_minor)
{
struct GNUNET_HashCode key;
@@ -516,10 +508,9 @@
local_sensor = GNUNET_CONTAINER_multihashmap_get (sensors, &key);
if (NULL == local_sensor)
return GNUNET_YES;
- if (GNUNET_SENSOR_version_compare (local_sensor->version_major,
- local_sensor->version_minor,
- sensorversion_major,
- sensorversion_minor) < 0)
+ if (GNUNET_SENSOR_version_compare
+ (local_sensor->version_major, local_sensor->version_minor,
+ sensorversion_major, sensorversion_minor) < 0)
return GNUNET_YES;
return GNUNET_NO;
}
@@ -536,8 +527,7 @@
* #GNUNET_SYSERR to close it (signal serious error).
*/
static int
-handle_sensor_brief (void *cls,
- struct GNUNET_CADET_Channel *channel,
+handle_sensor_brief (void *cls, struct GNUNET_CADET_Channel *channel,
void **channel_ctx,
const struct GNUNET_MessageHeader *message)
{
@@ -569,16 +559,15 @@
}
else
{
- sbm = (struct GNUNET_SENSOR_SensorBriefMessage *)message;
+ sbm = (struct GNUNET_SENSOR_SensorBriefMessage *) message;
version_major = ntohs (sbm->version_major);
version_minor = ntohs (sbm->version_minor);
- if (GNUNET_YES == update_required ((char *)&sbm[1],
- version_major,
- version_minor))
+ if (GNUNET_YES ==
+ update_required ((char *) &sbm[1], version_major, version_minor))
{
LOG (GNUNET_ERROR_TYPE_INFO,
- "Requesting sensor %s %d.%d from update point.\n",
- &sbm[1], version_major, version_minor);
+ "Requesting sensor %s %d.%d from update point.\n", &sbm[1],
+ version_major, version_minor);
/* We duplicate the same msg received but change the type and send it
* back to update point to ask for full sensor information. */
msg_size = ntohs (message->size);
@@ -586,7 +575,7 @@
memcpy (pull_req, message, msg_size);
pull_req->type = htons (GNUNET_MESSAGE_TYPE_SENSOR_FULL_REQ);
queue_msg (pull_req);
- up_default->expected_sensor_updates ++;
+ up_default->expected_sensor_updates++;
}
}
GNUNET_CADET_receive_done (channel);
@@ -606,39 +595,28 @@
* @return #GNUNET_OK on success, #GNUNET_SYSERR on error
*/
static int
-update_sensor (char *sensorname,
- void *sensorfile, uint16_t sensorfile_size,
- char *scriptname,
- void *scriptfile, uint16_t scriptfile_size)
+update_sensor (char *sensorname, void *sensorfile, uint16_t sensorfile_size,
+ char *scriptname, void *scriptfile, uint16_t scriptfile_size)
{
char *sensors_dir;
char *sensor_path;
char *script_path;
LOG (GNUNET_ERROR_TYPE_INFO,
- "Received new sensor information:\n"
- "Name: %s\n"
- "Sensor file size: %d\n"
- "Script name: %s\n"
- "Script file size: %d.\n",
- sensorname,
- sensorfile_size,
- (NULL == scriptname) ? "None" : scriptname,
+ "Received new sensor information:\n" "Name: %s\n"
+ "Sensor file size: %d\n" "Script name: %s\n" "Script file size: %d.\n",
+ sensorname, sensorfile_size, (NULL == scriptname) ? "None" : scriptname,
scriptfile_size);
sensors_dir = GNUNET_SENSOR_get_sensor_dir ();
GNUNET_asprintf (&sensor_path, "%s%s", sensors_dir, sensorname);
GNUNET_DISK_fn_write (sensor_path, sensorfile, sensorfile_size,
- GNUNET_DISK_PERM_USER_READ |
- GNUNET_DISK_PERM_GROUP_READ |
- GNUNET_DISK_PERM_OTHER_READ |
+ GNUNET_DISK_PERM_USER_READ |
GNUNET_DISK_PERM_GROUP_READ
+ | GNUNET_DISK_PERM_OTHER_READ |
GNUNET_DISK_PERM_USER_WRITE);
if (NULL != scriptname)
{
- GNUNET_asprintf (&script_path,
- "%s-files%s%s",
- sensor_path,
- DIR_SEPARATOR_STR,
- scriptname);
+ GNUNET_asprintf (&script_path, "%s-files%s%s", sensor_path,
+ DIR_SEPARATOR_STR, scriptname);
GNUNET_DISK_fn_write (script_path, scriptfile, scriptfile_size,
GNUNET_DISK_PERM_USER_READ |
GNUNET_DISK_PERM_GROUP_READ |
@@ -661,7 +639,8 @@
* @param cls unused
* @param tc unused
*/
-void reset (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+void
+reset (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
reset_cb ();
}
@@ -678,10 +657,9 @@
* #GNUNET_SYSERR to close it (signal serious error).
*/
static int
-handle_sensor_full (void *cls,
- struct GNUNET_CADET_Channel *channel,
- void **channel_ctx,
- const struct GNUNET_MessageHeader *message)
+handle_sensor_full (void *cls, struct GNUNET_CADET_Channel *channel,
+ void **channel_ctx,
+ const struct GNUNET_MessageHeader *message)
{
struct GNUNET_SENSOR_SensorFullMessage *sfm;
uint16_t msg_size;
@@ -703,8 +681,8 @@
return GNUNET_OK;
}
/* parse received msg */
- sfm = (struct GNUNET_SENSOR_SensorFullMessage *)message;
- sensorname_ptr = (char *)&sfm[1];
+ sfm = (struct GNUNET_SENSOR_SensorFullMessage *) message;
+ sensorname_ptr = (char *) &sfm[1];
sensorfile_ptr = sensorname_ptr + ntohs (sfm->sensorname_size);
sensorfile_size = ntohs (sfm->sensorfile_size);
scriptfile_size = ntohs (sfm->scriptfile_size);
@@ -718,13 +696,9 @@
scriptname_ptr = NULL;
scriptfile_ptr = NULL;
}
- update_sensor ((char *)&sfm[1],
- sensorfile_ptr,
- sensorfile_size,
- scriptname_ptr,
- scriptfile_ptr,
- scriptfile_size);
- up_default->expected_sensor_updates --;
+ update_sensor ((char *) &sfm[1], sensorfile_ptr, sensorfile_size,
+ scriptname_ptr, scriptfile_ptr, scriptfile_size);
+ up_default->expected_sensor_updates--;
if (0 == up_default->expected_sensor_updates)
{
updating = GNUNET_NO;
@@ -749,8 +723,7 @@
* with the channel is stored
*/
static void
-cadet_channel_destroyed (void *cls,
- const struct GNUNET_CADET_Channel *channel,
+cadet_channel_destroyed (void *cls, const struct GNUNET_CADET_Channel *channel,
void *channel_ctx)
{
struct UpdatePoint *up = channel_ctx;
@@ -769,52 +742,46 @@
* Start the sensor update module
*
* @param c our service configuration
- * @param sensors multihashmap of loaded sensors
+ * @param s multihashmap of loaded sensors
* @param cb callback to reset service components when we have new updates
* @return #GNUNET_OK if started successfully, #GNUNET_SYSERR otherwise
*/
int
SENSOR_update_start (const struct GNUNET_CONFIGURATION_Handle *c,
- struct GNUNET_CONTAINER_MultiHashMap *s,
- void (*cb)())
+ struct GNUNET_CONTAINER_MultiHashMap *s, void (*cb) ())
{
static struct GNUNET_CADET_MessageHandler cadet_handlers[] = {
- {&handle_sensor_brief, GNUNET_MESSAGE_TYPE_SENSOR_BRIEF, 0},
- {&handle_sensor_brief, GNUNET_MESSAGE_TYPE_SENSOR_END, 0},
- {&handle_sensor_full, GNUNET_MESSAGE_TYPE_SENSOR_FULL, 0},
- {NULL, 0, 0}
+ {&handle_sensor_brief, GNUNET_MESSAGE_TYPE_SENSOR_BRIEF, 0},
+ {&handle_sensor_brief, GNUNET_MESSAGE_TYPE_SENSOR_END, 0},
+ {&handle_sensor_full, GNUNET_MESSAGE_TYPE_SENSOR_FULL, 0},
+ {NULL, 0, 0}
};
- GNUNET_assert(NULL != s);
+ GNUNET_assert (NULL != s);
cfg = c;
sensors = s;
reset_cb = cb;
- cadet = GNUNET_CADET_connect(cfg,
- NULL,
- NULL,
- &cadet_channel_destroyed,
- cadet_handlers,
- NULL);
+ cadet =
+ GNUNET_CADET_connect (cfg, NULL, NULL, &cadet_channel_destroyed,
+ cadet_handlers, NULL);
if (NULL == cadet)
{
- LOG (GNUNET_ERROR_TYPE_ERROR,
- _("Failed to connect to CADET service.\n"));
+ LOG (GNUNET_ERROR_TYPE_ERROR, _("Failed to connect to CADET service.\n"));
SENSOR_update_stop ();
return GNUNET_SYSERR;
}
if (GNUNET_OK != load_update_points ())
{
- LOG (GNUNET_ERROR_TYPE_ERROR,
- "Failed to load update points.\n");
+ LOG (GNUNET_ERROR_TYPE_ERROR, "Failed to load update points.\n");
SENSOR_update_stop ();
return GNUNET_SYSERR;
}
up_default = up_head;
updating = GNUNET_NO;
- update_task = GNUNET_SCHEDULER_add_delayed (SENSOR_UPDATE_CHECK_INTERVAL,
- &check_for_updates, NULL);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "Sensor update module started.\n");
+ update_task =
+ GNUNET_SCHEDULER_add_delayed (SENSOR_UPDATE_CHECK_INTERVAL,
+ &check_for_updates, NULL);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Sensor update module started.\n");
return GNUNET_OK;
}
Modified: gnunet/src/sensor/gnunet-service-sensor.c
===================================================================
--- gnunet/src/sensor/gnunet-service-sensor.c 2014-07-29 13:06:05 UTC (rev
34074)
+++ gnunet/src/sensor/gnunet-service-sensor.c 2014-07-29 14:01:37 UTC (rev
34075)
@@ -1,6 +1,6 @@
/*
This file is part of GNUnet.
- (C)
+ (C)
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
@@ -79,14 +79,11 @@
static void
set_sensor_enabled (struct GNUNET_SENSOR_SensorInfo *sensor, int state)
{
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "Sensor `%s': Setting enabled to %d.\n",
- sensor->name, state);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sensor `%s': Setting enabled to %d.\n",
+ sensor->name, state);
sensor->enabled = GNUNET_NO;
GNUNET_assert (NULL != sensor->cfg);
- GNUNET_CONFIGURATION_set_value_string (sensor->cfg,
- sensor->name,
- "ENABLED",
+ GNUNET_CONFIGURATION_set_value_string (sensor->cfg, sensor->name, "ENABLED",
(GNUNET_YES == state) ? "YES" : "NO");
GNUNET_CONFIGURATION_write (sensor->cfg, sensor->def_file);
}
@@ -112,8 +109,7 @@
* @param tc unused
*/
static void
-shutdown_task (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
stop ();
if (NULL != statistics)
@@ -137,11 +133,11 @@
* @param client identification of the client
*/
static void
-handle_client_disconnect (void *cls,
- struct GNUNET_SERVER_Client *client)
+handle_client_disconnect (void *cls, struct GNUNET_SERVER_Client *client)
{
}
+
/**
* Creates a structure with basic sensor info to be sent to a client.
*
@@ -157,34 +153,35 @@
size_t desc_len;
char *str_ptr;
- name_len = strlen(sensor->name);
- if(NULL == sensor->description)
+ name_len = strlen (sensor->name);
+ if (NULL == sensor->description)
desc_len = 0;
else
- desc_len = strlen(sensor->description) + 1;
+ desc_len = strlen (sensor->description) + 1;
len = 0;
- len += sizeof(struct SensorInfoMessage);
+ len += sizeof (struct SensorInfoMessage);
len += name_len;
len += desc_len;
- msg = GNUNET_malloc(len);
- msg->header.size = htons(len);
- msg->header.type = htons(GNUNET_MESSAGE_TYPE_SENSOR_INFO);
- msg->name_len = htons(name_len);
- msg->description_len = htons(desc_len);
- msg->version_major = htons(sensor->version_major);
- msg->version_minor = htons(sensor->version_minor);
- str_ptr = (char*) &msg[1];
- memcpy(str_ptr, sensor->name, name_len);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sending sensor name (%d): %.*s\n",
- name_len, name_len, str_ptr);
+ msg = GNUNET_malloc (len);
+ msg->header.size = htons (len);
+ msg->header.type = htons (GNUNET_MESSAGE_TYPE_SENSOR_INFO);
+ msg->name_len = htons (name_len);
+ msg->description_len = htons (desc_len);
+ msg->version_major = htons (sensor->version_major);
+ msg->version_minor = htons (sensor->version_minor);
+ str_ptr = (char *) &msg[1];
+ memcpy (str_ptr, sensor->name, name_len);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending sensor name (%d): %.*s\n",
+ name_len, name_len, str_ptr);
str_ptr += name_len;
- memcpy(str_ptr, sensor->description, desc_len);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sending sensor description (%d):
%.*s\n",
- desc_len, desc_len, str_ptr);
-
+ memcpy (str_ptr, sensor->description, desc_len);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Sending sensor description (%d): %.*s\n", desc_len, desc_len,
+ str_ptr);
return msg;
}
+
/**
* Handle GET SENSOR message.
*
@@ -193,8 +190,7 @@
* @param message the actual message
*/
static void
-handle_get_sensor (void *cls,
- struct GNUNET_SERVER_Client *client,
+handle_get_sensor (void *cls, struct GNUNET_SERVER_Client *client,
const struct GNUNET_MessageHeader *message)
{
struct GNUNET_SERVER_TransmitContext *tc;
@@ -204,27 +200,36 @@
struct GNUNET_SENSOR_SensorInfo *sensorinfo;
struct SensorInfoMessage *msg;
- sensorname = (char *)&message[1];
- sensorname_len = ntohs(message->size) - sizeof(struct GNUNET_MessageHeader);
- GNUNET_log (GNUNET_ERROR_TYPE_INFO, "`%s' message received for sensor (%d)
`%.*s'\n",
- "GET SENSOR", sensorname_len, sensorname_len, sensorname);
+ sensorname = (char *) &message[1];
+ sensorname_len = ntohs (message->size) - sizeof (struct
GNUNET_MessageHeader);
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "`%s' message received for sensor (%d) `%.*s'\n", "GET SENSOR",
+ sensorname_len, sensorname_len, sensorname);
tc = GNUNET_SERVER_transmit_context_create (client);
- GNUNET_CRYPTO_hash(sensorname, sensorname_len, &key);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Created key hash for requested
sensor\n");
- sensorinfo = (struct GNUNET_SENSOR_SensorInfo
*)GNUNET_CONTAINER_multihashmap_get(sensors, &key);
- if(NULL != sensorinfo)
+ GNUNET_CRYPTO_hash (sensorname, sensorname_len, &key);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Created key hash for requested sensor\n");
+ sensorinfo =
+ (struct GNUNET_SENSOR_SensorInfo *)
+ GNUNET_CONTAINER_multihashmap_get (sensors, &key);
+ if (NULL != sensorinfo)
{
- msg = create_sensor_info_msg(sensorinfo);
- GNUNET_SERVER_transmit_context_append_message(tc, (struct
GNUNET_MessageHeader *)msg);
- GNUNET_free(msg);
+ msg = create_sensor_info_msg (sensorinfo);
+ GNUNET_SERVER_transmit_context_append_message (tc,
+ (struct GNUNET_MessageHeader
+ *) msg);
+ GNUNET_free (msg);
}
else
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Requested sensor `%.*s' was not
found\n",
- sensorname_len, sensorname);
- GNUNET_SERVER_transmit_context_append_data(tc, NULL, 0,
GNUNET_MESSAGE_TYPE_SENSOR_END);
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Requested sensor `%.*s' was not found\n", sensorname_len,
+ sensorname);
+ GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0,
+ GNUNET_MESSAGE_TYPE_SENSOR_END);
GNUNET_SERVER_transmit_context_run (tc, GNUNET_TIME_UNIT_FOREVER_REL);
}
+
/**
* Iterator for sensors and adds them to transmit context
*
@@ -233,22 +238,22 @@
* @param value a `struct GNUNET_SENSOR_SensorInfo *`
*/
static int
-add_sensor_to_tc (void *cls,
- const struct GNUNET_HashCode *key,
- void *value)
+add_sensor_to_tc (void *cls, const struct GNUNET_HashCode *key, void *value)
{
struct GNUNET_SERVER_TransmitContext *tc = cls;
struct GNUNET_SENSOR_SensorInfo *sensorinfo = value;
struct SensorInfoMessage *msg;
- msg = create_sensor_info_msg(sensorinfo);
- GNUNET_SERVER_transmit_context_append_message(tc, (struct
GNUNET_MessageHeader *)msg);
+ msg = create_sensor_info_msg (sensorinfo);
+ GNUNET_SERVER_transmit_context_append_message (tc,
+ (struct GNUNET_MessageHeader
*)
+ msg);
- GNUNET_free(msg);
-
+ GNUNET_free (msg);
return GNUNET_YES;
}
+
/**
* Handle GET ALL SENSORS message.
*
@@ -258,86 +263,86 @@
*/
static void
handle_get_all_sensors (void *cls, struct GNUNET_SERVER_Client *client,
- const struct GNUNET_MessageHeader *message)
+ const struct GNUNET_MessageHeader *message)
{
struct GNUNET_SERVER_TransmitContext *tc;
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "`%s' message received.\n",
- "GET ALL SENSOR");
+ "GET ALL SENSOR");
tc = GNUNET_SERVER_transmit_context_create (client);
- GNUNET_CONTAINER_multihashmap_iterate(sensors, &add_sensor_to_tc, tc);
- GNUNET_SERVER_transmit_context_append_data(tc, NULL, 0,
GNUNET_MESSAGE_TYPE_SENSOR_END);
+ GNUNET_CONTAINER_multihashmap_iterate (sensors, &add_sensor_to_tc, tc);
+ GNUNET_SERVER_transmit_context_append_data (tc, NULL, 0,
+ GNUNET_MESSAGE_TYPE_SENSOR_END);
GNUNET_SERVER_transmit_context_run (tc, GNUNET_TIME_UNIT_FOREVER_REL);
}
+
/**
* Do a series of checks to determine if sensor should execute
*
* @return #GNUNET_YES / #GNUNET_NO
*/
static int
-should_run_sensor(struct GNUNET_SENSOR_SensorInfo *sensorinfo)
+should_run_sensor (struct GNUNET_SENSOR_SensorInfo *sensorinfo)
{
struct GNUNET_TIME_Absolute now;
- if(GNUNET_NO == sensorinfo->enabled)
+ if (GNUNET_NO == sensorinfo->enabled)
{
- GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Sensor `%s' is disabled, will not
run\n", sensorinfo->name);
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "Sensor `%s' is disabled, will not run\n", sensorinfo->name);
return GNUNET_NO;
}
- now = GNUNET_TIME_absolute_get();
- if(NULL != sensorinfo->start_time
- && now.abs_value_us < sensorinfo->start_time->abs_value_us)
+ now = GNUNET_TIME_absolute_get ();
+ if (NULL != sensorinfo->start_time &&
+ now.abs_value_us < sensorinfo->start_time->abs_value_us)
{
- GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Start time for sensor `%s' not reached
yet, will not run\n", sensorinfo->name);
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "Start time for sensor `%s' not reached yet, will not run\n",
+ sensorinfo->name);
return GNUNET_NO;
}
- if(NULL != sensorinfo->end_time
- && now.abs_value_us >= sensorinfo->end_time->abs_value_us)
+ if (NULL != sensorinfo->end_time &&
+ now.abs_value_us >= sensorinfo->end_time->abs_value_us)
{
- GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Sensor `%s' expired, disabling.\n",
sensorinfo->name);
- set_sensor_enabled(sensorinfo, GNUNET_NO);
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Sensor `%s' expired, disabling.\n",
+ sensorinfo->name);
+ set_sensor_enabled (sensorinfo, GNUNET_NO);
return GNUNET_NO;
}
return GNUNET_YES;
}
+
/**
* Callback function to process statistic values
*
* @param cls `struct GNUNET_SENSOR_SensorInfo *`
- * @param subsystem name of subsystem that created the statistic
+ * @param ss name of subsystem that created the statistic
* @param name the name of the datum
* @param value the current value
* @param is_persistent #GNUNET_YES if the value is persistent, #GNUNET_NO if
not
* @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration
*/
static int
-sensor_statistics_iterator (void *cls,
- const char *ss,
- const char *name,
- uint64_t value,
- int is_persistent)
+sensor_statistics_iterator (void *cls, const char *ss, const char *name,
+ uint64_t value, int is_persistent)
{
struct GNUNET_SENSOR_SensorInfo *sensorinfo = cls;
- double dvalue = (double)value;
+ double dvalue = (double) value;
struct GNUNET_TIME_Absolute expiry;
- GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Received a value for sensor `%s': %"
PRIu64 "\n", sensorinfo->name, value);
- expiry = GNUNET_TIME_relative_to_absolute(sensorinfo->lifetime);
- GNUNET_PEERSTORE_store(peerstore,
- subsystem,
- &peerid,
- sensorinfo->name,
- &dvalue,
- sizeof(dvalue),
- expiry,
- GNUNET_PEERSTORE_STOREOPTION_MULTIPLE,
- NULL,
- NULL);
- return GNUNET_SYSERR; /* We only want one value */
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "Received a value for sensor `%s': %" PRIu64 "\n",
+ sensorinfo->name, value);
+ expiry = GNUNET_TIME_relative_to_absolute (sensorinfo->lifetime);
+ GNUNET_PEERSTORE_store (peerstore, subsystem, &peerid, sensorinfo->name,
+ &dvalue, sizeof (dvalue), expiry,
+ GNUNET_PEERSTORE_STOREOPTION_MULTIPLE, NULL, NULL);
+ return GNUNET_SYSERR; /* We only want one value */
}
+
/**
* Continuation called after sensor gets all gnunet statistics values
*
@@ -354,6 +359,7 @@
sensorinfo->running = GNUNET_NO;
}
+
/**
* Tries to parse a received sensor value to its
* expected datatype
@@ -364,8 +370,7 @@
* @return size of new parsed value, 0 for error
*/
static size_t
-parse_sensor_value (const char *value,
- struct GNUNET_SENSOR_SensorInfo *sensor,
+parse_sensor_value (const char *value, struct GNUNET_SENSOR_SensorInfo *sensor,
void **ret)
{
double *dval;
@@ -374,25 +379,28 @@
*ret = NULL;
if ('\0' == *value)
return 0;
- if(0 == strcmp("numeric", sensor->expected_datatype))
+ if (0 == strcmp ("numeric", sensor->expected_datatype))
{
- dval = GNUNET_new(double);
- *dval = strtod(value, &endptr);
- if(value == endptr)
+ dval = GNUNET_new (double);
+
+ *dval = strtod (value, &endptr);
+ if (value == endptr)
return 0;
- *ret = dval;
- return sizeof(double);
+ *ret = dval;
+ return sizeof (double);
}
- if(0 == strcmp("string", sensor->expected_datatype))
+ if (0 == strcmp ("string", sensor->expected_datatype))
{
- *ret = GNUNET_strdup(value);
- return strlen(value) + 1;
+ *ret = GNUNET_strdup (value);
+ return strlen (value) + 1;
}
- GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
- _("Unknown value type expected by sensor, this should not happen.\n"));
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ _
+ ("Unknown value type expected by sensor, this should not
happen.\n"));
return 0;
}
+
/**
* Callback for output of executed sensor process
*
@@ -407,62 +415,58 @@
size_t valsize;
struct GNUNET_TIME_Absolute expiry;
- if(NULL == line)
+ if (NULL == line)
{
- GNUNET_OS_command_stop(sensorinfo->ext_cmd);
+ GNUNET_OS_command_stop (sensorinfo->ext_cmd);
sensorinfo->ext_cmd = NULL;
sensorinfo->running = GNUNET_NO;
sensorinfo->ext_cmd_value_received = GNUNET_NO;
return;
}
- if(GNUNET_YES == sensorinfo->ext_cmd_value_received)
- return; /* We only want one *valid* value */
- GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Received a value for sensor `%s': %s\n",
sensorinfo->name, line);
- valsize = parse_sensor_value(line, sensorinfo, &value);
- if (valsize == 0) /* invalid value, FIXME: should we disable the sensor now?
*/
+ if (GNUNET_YES == sensorinfo->ext_cmd_value_received)
+ return; /* We only want one *valid* value */
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Received a value for sensor `%s': %s\n",
+ sensorinfo->name, line);
+ valsize = parse_sensor_value (line, sensorinfo, &value);
+ if (valsize == 0) /* invalid value, FIXME: should we disable the
sensor now? */
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _("Received an invalid value for sensor `%s': %s\n"),
- sensorinfo->name, line);
+ _("Received an invalid value for sensor `%s': %s\n"),
+ sensorinfo->name, line);
}
else
{
sensorinfo->ext_cmd_value_received = GNUNET_YES;
- expiry = GNUNET_TIME_relative_to_absolute(sensorinfo->lifetime);
- GNUNET_PEERSTORE_store(peerstore,
- subsystem,
- &peerid,
- sensorinfo->name,
- value,
- valsize,
- expiry,
- GNUNET_PEERSTORE_STOREOPTION_MULTIPLE,
- NULL,
- NULL);
+ expiry = GNUNET_TIME_relative_to_absolute (sensorinfo->lifetime);
+ GNUNET_PEERSTORE_store (peerstore, subsystem, &peerid, sensorinfo->name,
+ value, valsize, expiry,
+ GNUNET_PEERSTORE_STOREOPTION_MULTIPLE, NULL, NULL);
GNUNET_free (value);
}
}
+
/**
* Checks if the given file is a path
*
* @return #GNUNET_YES / #GNUNET_NO
*/
static int
-is_path(char *filename)
+is_path (char *filename)
{
size_t filename_len;
int i;
- filename_len = strlen(filename);
- for(i = 0; i < filename_len; i++)
+ filename_len = strlen (filename);
+ for (i = 0; i < filename_len; i++)
{
- if(DIR_SEPARATOR == filename[i])
+ if (DIR_SEPARATOR == filename[i])
return GNUNET_YES;
}
return GNUNET_NO;
}
+
/**
* Actual execution of a sensor
*
@@ -470,92 +474,91 @@
* @param tc unsed
*/
static void
-sensor_run (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext * tc)
+sensor_run (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GNUNET_SENSOR_SensorInfo *sensorinfo = cls;
int check_result;
char *sensors_dir;
char *process_path;
- sensorinfo->execution_task =
GNUNET_SCHEDULER_add_delayed(sensorinfo->interval, &sensor_run, sensorinfo);
- if(GNUNET_YES == sensorinfo->running) //FIXME: should we try to kill?
+ sensorinfo->execution_task =
+ GNUNET_SCHEDULER_add_delayed (sensorinfo->interval, &sensor_run,
+ sensorinfo);
+ if (GNUNET_YES == sensorinfo->running) //FIXME: should we try to kill?
{
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Sensor `%s' running for too long,
will try again next interval\n", sensorinfo->name);
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Sensor `%s' running for too long, will try again next
interval\n",
+ sensorinfo->name);
return;
}
- if(GNUNET_NO == should_run_sensor(sensorinfo))
+ if (GNUNET_NO == should_run_sensor (sensorinfo))
return;
sensorinfo->running = GNUNET_YES;
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Starting the execution of sensor
`%s'\n", sensorinfo->name);
- if(0 == strcmp ("gnunet-statistics", sensorinfo->source))
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Starting the execution of sensor `%s'\n", sensorinfo->name);
+ if (0 == strcmp ("gnunet-statistics", sensorinfo->source))
{
- sensorinfo->gnunet_stat_get_handle = GNUNET_STATISTICS_get(statistics,
- sensorinfo->gnunet_stat_service,
- sensorinfo->gnunet_stat_name,
- sensorinfo->interval, //try to get values only for the interval of the
sensor
- &end_sensor_run_stat,
- &sensor_statistics_iterator,
- sensorinfo);
+ sensorinfo->gnunet_stat_get_handle = GNUNET_STATISTICS_get (statistics,
sensorinfo->gnunet_stat_service, sensorinfo->gnunet_stat_name,
sensorinfo->interval, //try to get values only for the interval of the
sensor
+
&end_sensor_run_stat,
+
&sensor_statistics_iterator,
+ sensorinfo);
}
- else if(0 == strcmp ("process", sensorinfo->source))
+ else if (0 == strcmp ("process", sensorinfo->source))
{
- if(GNUNET_YES == is_path(sensorinfo->ext_process))
+ if (GNUNET_YES == is_path (sensorinfo->ext_process))
{
- GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
- _("Sensor `%s': External process should not be a path, disabling
sensor.\n"),
- sensorinfo->name);
- set_sensor_enabled(sensorinfo, GNUNET_NO);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ _
+ ("Sensor `%s': External process should not be a path,
disabling sensor.\n"),
+ sensorinfo->name);
+ set_sensor_enabled (sensorinfo, GNUNET_NO);
return;
}
//check if the process exists in $PATH
- process_path = GNUNET_strdup(sensorinfo->ext_process);
+ process_path = GNUNET_strdup (sensorinfo->ext_process);
check_result =
- GNUNET_OS_check_helper_binary(process_path, GNUNET_NO, NULL);
- if(GNUNET_SYSERR == check_result)
+ GNUNET_OS_check_helper_binary (process_path, GNUNET_NO, NULL);
+ if (GNUNET_SYSERR == check_result)
{
//search in sensor directory
sensors_dir = GNUNET_SENSOR_get_sensor_dir ();
- GNUNET_free(process_path);
- GNUNET_asprintf(&process_path,
- "%s%s-files%s%s",
- sensors_dir,
- sensorinfo->name,
- DIR_SEPARATOR_STR,
- sensorinfo->ext_process);
- GNUNET_free(sensors_dir);
+ GNUNET_free (process_path);
+ GNUNET_asprintf (&process_path, "%s%s-files%s%s", sensors_dir,
+ sensorinfo->name, DIR_SEPARATOR_STR,
+ sensorinfo->ext_process);
+ GNUNET_free (sensors_dir);
check_result =
- GNUNET_OS_check_helper_binary(process_path, GNUNET_NO, NULL);
+ GNUNET_OS_check_helper_binary (process_path, GNUNET_NO, NULL);
}
- if(GNUNET_SYSERR == check_result)
+ if (GNUNET_SYSERR == check_result)
{
- GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
- _("Sensor `%s' process `%s' problem: binary doesn't exist or not
executable\n"),
- sensorinfo->name,
- sensorinfo->ext_process);
- set_sensor_enabled(sensorinfo, GNUNET_NO);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ _
+ ("Sensor `%s' process `%s' problem: binary doesn't exist or
not executable\n"),
+ sensorinfo->name, sensorinfo->ext_process);
+ set_sensor_enabled (sensorinfo, GNUNET_NO);
sensorinfo->running = GNUNET_NO;
- GNUNET_free(process_path);
+ GNUNET_free (process_path);
return;
}
sensorinfo->ext_cmd_value_received = GNUNET_NO;
- sensorinfo->ext_cmd = GNUNET_OS_command_run(&sensor_process_callback,
- sensorinfo,
- GNUNET_TIME_UNIT_FOREVER_REL,
- process_path,
- sensorinfo->ext_process,
- sensorinfo->ext_args,
- NULL);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Process started for sensor `%s'\n",
sensorinfo->name);
- GNUNET_free(process_path);
+ sensorinfo->ext_cmd =
+ GNUNET_OS_command_run (&sensor_process_callback, sensorinfo,
+ GNUNET_TIME_UNIT_FOREVER_REL, process_path,
+ sensorinfo->ext_process, sensorinfo->ext_args,
+ NULL);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Process started for sensor `%s'\n",
+ sensorinfo->name);
+ GNUNET_free (process_path);
}
else
{
sensorinfo->running = GNUNET_NO;
- GNUNET_break(0); //shouldn't happen
+ GNUNET_break (0); //shouldn't happen
}
}
+
/**
* Starts the execution of a sensor
*
@@ -571,28 +574,34 @@
{
struct GNUNET_SENSOR_SensorInfo *sensorinfo = value;
- if(GNUNET_NO == should_run_sensor(sensorinfo))
+ if (GNUNET_NO == should_run_sensor (sensorinfo))
return GNUNET_YES;
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Scheduling sensor `%s' to run after %"
PRIu64 " microseconds\n",
- sensorinfo->name, sensorinfo->interval.rel_value_us);
- if(GNUNET_SCHEDULER_NO_TASK != sensorinfo->execution_task)
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Scheduling sensor `%s' to run after %" PRIu64 " microseconds\n",
+ sensorinfo->name, sensorinfo->interval.rel_value_us);
+ if (GNUNET_SCHEDULER_NO_TASK != sensorinfo->execution_task)
{
- GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
- _("Sensor `%s' execution task already set, this should not happen\n"),
sensorinfo->name);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ _
+ ("Sensor `%s' execution task already set, this should not
happen\n"),
+ sensorinfo->name);
return GNUNET_NO;
}
- sensorinfo->execution_task =
GNUNET_SCHEDULER_add_delayed(sensorinfo->interval, &sensor_run, sensorinfo);
+ sensorinfo->execution_task =
+ GNUNET_SCHEDULER_add_delayed (sensorinfo->interval, &sensor_run,
+ sensorinfo);
return GNUNET_YES;
}
+
/**
* Starts the execution of all enabled sensors
*
*/
static void
-schedule_all_sensors()
+schedule_all_sensors ()
{
- GNUNET_CONTAINER_multihashmap_iterate(sensors, &schedule_sensor, NULL);
+ GNUNET_CONTAINER_multihashmap_iterate (sensors, &schedule_sensor, NULL);
}
@@ -603,9 +612,9 @@
start ()
{
sensors = GNUNET_SENSOR_load_all_sensors ();
- schedule_all_sensors();
- SENSOR_analysis_start(cfg, sensors);
- SENSOR_reporting_start(cfg, sensors);
+ schedule_all_sensors ();
+ SENSOR_analysis_start (cfg, sensors);
+ SENSOR_reporting_start (cfg, sensors);
SENSOR_update_start (cfg, sensors, &reset);
}
@@ -618,8 +627,7 @@
* @param c configuration to use
*/
static void
-run (void *cls,
- struct GNUNET_SERVER_Handle *server,
+run (void *cls, struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *c)
{
static const struct GNUNET_SERVER_MessageHandler handlers[] = {
@@ -631,16 +639,13 @@
};
cfg = c;
- statistics = GNUNET_STATISTICS_create("sensor", cfg);
- GNUNET_CRYPTO_get_peer_identity(cfg, &peerid);
- peerstore = GNUNET_PEERSTORE_connect(cfg);
+ statistics = GNUNET_STATISTICS_create ("sensor", cfg);
+ GNUNET_CRYPTO_get_peer_identity (cfg, &peerid);
+ peerstore = GNUNET_PEERSTORE_connect (cfg);
GNUNET_SERVER_add_handlers (server, handlers);
- GNUNET_SERVER_disconnect_notify (server,
- &handle_client_disconnect,
- NULL);
- GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
- &shutdown_task,
- NULL);
+ GNUNET_SERVER_disconnect_notify (server, &handle_client_disconnect, NULL);
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
+ NULL);
start ();
}
@@ -668,11 +673,8 @@
main (int argc, char *const *argv)
{
return (GNUNET_OK ==
- GNUNET_SERVICE_run (argc,
- argv,
- "sensor",
- GNUNET_SERVICE_OPTION_NONE,
- &run, NULL)) ? 0 : 1;
+ GNUNET_SERVICE_run (argc, argv, "sensor", GNUNET_SERVICE_OPTION_NONE,
+ &run, NULL)) ? 0 : 1;
}
/* end of gnunet-service-sensor.c */
Modified: gnunet/src/sensor/gnunet_sensor_model_plugin.h
===================================================================
--- gnunet/src/sensor/gnunet_sensor_model_plugin.h 2014-07-29 13:06:05 UTC
(rev 34074)
+++ gnunet/src/sensor/gnunet_sensor_model_plugin.h 2014-07-29 14:01:37 UTC
(rev 34075)
@@ -54,16 +54,14 @@
* @param cls closure (plugin state)
* @return model state to be used for later calls
*/
- void *
- (*create_model) (void *cls);
+ void *(*create_model) (void *cls);
/*
* Destroy a model instance
*
* @param cls closure (model state)
*/
- void
- (*destroy_model) (void *cls);
+ void (*destroy_model) (void *cls);
/*
* Feed a new value to a model
@@ -72,8 +70,7 @@
* @param val value to be fed to the model
* @return #GNUNET_YES in case of a detected outlier, #GNUNET_NO otherwise
*/
- int
- (*feed_model) (void *cls, double val);
+ int (*feed_model) (void *cls, double val);
};
Modified: gnunet/src/sensor/plugin_sensor_model_gaussian.c
===================================================================
--- gnunet/src/sensor/plugin_sensor_model_gaussian.c 2014-07-29 13:06:05 UTC
(rev 34074)
+++ gnunet/src/sensor/plugin_sensor_model_gaussian.c 2014-07-29 14:01:37 UTC
(rev 34075)
@@ -82,15 +82,22 @@
};
+/**
+ * Update local sums of model with a new value.
+ *
+ * @param model Targe model
+ * @param val New value
+ */
static void
update_sums (struct Model *model, double val)
{
model->sum += val;
model->sumsq += val * val;
- model->n ++;
+ model->n++;
}
-/*
+
+/**
* Feed a new value to a model
*
* @param cls closure (model state)
@@ -108,23 +115,21 @@
if (model->n < plugin->training_window)
{
- update_sums(model, val);
+ update_sums (model, val);
return GNUNET_NO;
}
mean = model->sum / model->n;
- stddev = sqrt(
- (model->sumsq - 2 * mean * model->sum + model->n * mean * mean)
- /
- (model->n - 1)
- );
+ stddev =
+ sqrt ((model->sumsq - 2 * mean * model->sum +
+ model->n * mean * mean) / (model->n - 1));
allowed_variance = (plugin->confidence_interval * stddev);
- if ((val < (mean - allowed_variance)) ||
- (val > (mean + allowed_variance)))
+ if ((val < (mean - allowed_variance)) || (val > (mean + allowed_variance)))
return GNUNET_YES;
return GNUNET_NO;
}
-/*
+
+/**
* Destroy a model instance
*
* @param cls closure (model state)
@@ -134,10 +139,11 @@
{
struct Model *model = cls;
- GNUNET_free(model);
+ GNUNET_free (model);
}
-/*
+
+/**
* Create a model instance
*
* @param cls closure (plugin state)
@@ -149,12 +155,14 @@
struct Plugin *plugin = cls;
struct Model *model;
- model = GNUNET_new(struct Model);
+ model = GNUNET_new (struct Model);
+
model->plugin = plugin;
return model;
}
-/*
+
+/**
* Entry point for the plugin.
*
* @param cls The struct GNUNET_CONFIGURATION_Handle.
@@ -172,32 +180,36 @@
return NULL; /* can only initialize once! */
memset (&plugin, 0, sizeof (struct Plugin));
plugin.cfg = cfg;
- if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg,
- "sensor-model-gaussian", "TRAINING_WINDOW", &num))
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_number (cfg, "sensor-model-gaussian",
+ "TRAINING_WINDOW", &num))
{
LOG (GNUNET_ERROR_TYPE_ERROR,
- _("Missing `TRAINING_WINDOW' value in configuration.\n"));
+ _("Missing `TRAINING_WINDOW' value in configuration.\n"));
return NULL;
}
plugin.training_window = (int) num;
- if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg,
- "sensor-model-gaussian", "CONFIDENCE_INTERVAL", &num))
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_number (cfg, "sensor-model-gaussian",
+ "CONFIDENCE_INTERVAL", &num))
{
LOG (GNUNET_ERROR_TYPE_ERROR,
- _("Missing `CONFIDENCE_INTERVAL' value in configuration.\n"));
+ _("Missing `CONFIDENCE_INTERVAL' value in configuration.\n"));
return NULL;
}
plugin.confidence_interval = (int) num;
api = GNUNET_new (struct GNUNET_SENSOR_ModelFunctions);
+
api->cls = &plugin;
api->create_model = &sensor_gaussian_model_create_model;
api->destroy_model = &sensor_gaussian_model_destroy_model;
api->feed_model = &sensor_gaussian_model_feed;
- LOG(GNUNET_ERROR_TYPE_DEBUG, "Gaussian model plugin is running.\n");
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Gaussian model plugin is running.\n");
return api;
}
-/*
+
+/**
* Exit point from the plugin.
*
* @param cls The plugin context (as returned by "init")
Modified: gnunet/src/sensor/sensor.h
===================================================================
--- gnunet/src/sensor/sensor.h 2014-07-29 13:06:05 UTC (rev 34074)
+++ gnunet/src/sensor/sensor.h 2014-07-29 14:01:37 UTC (rev 34075)
@@ -28,12 +28,11 @@
GNUNET_NETWORK_STRUCT_BEGIN
-
/**
* Carries a summary of a sensor
*
*/
-struct SensorInfoMessage
+ struct SensorInfoMessage
{
/**
* Message header
@@ -63,27 +62,32 @@
GNUNET_NETWORK_STRUCT_END
-/*
+/**
* Stop the sensor analysis module
*/
-void SENSOR_analysis_stop();
+ void
+SENSOR_analysis_stop ();
-/*
+
+/**
* Start the sensor analysis module
*
* @param c our service configuration
- * @param sensors_mhm multihashmap of loaded sensors
+ * @param sensors multihashmap of loaded sensors
* @return #GNUNET_OK if started successfully, #GNUNET_SYSERR otherwise
*/
int
-SENSOR_analysis_start(const struct GNUNET_CONFIGURATION_Handle *c,
- struct GNUNET_CONTAINER_MultiHashMap *sensors_mhm);
+SENSOR_analysis_start (const struct GNUNET_CONFIGURATION_Handle *c,
+ struct GNUNET_CONTAINER_MultiHashMap *sensors);
+
/**
* Stop sensor reporting module
*/
-void SENSOR_reporting_stop();
+void
+SENSOR_reporting_stop ();
+
/**
* Start the sensor reporting module
*
@@ -92,25 +96,26 @@
* @return #GNUNET_OK if started successfully, #GNUNET_SYSERR otherwise
*/
int
-SENSOR_reporting_start(const struct GNUNET_CONFIGURATION_Handle *c,
- struct GNUNET_CONTAINER_MultiHashMap *sensors);
+SENSOR_reporting_start (const struct GNUNET_CONFIGURATION_Handle *c,
+ struct GNUNET_CONTAINER_MultiHashMap *sensors);
+
/**
* Stop the sensor update module
*/
void
SENSOR_update_stop ();
+
/**
* Start the sensor update module
*
* @param c our service configuration
- * @param sensors multihashmap of loaded sensors
- * @param reset_cb callback to reset service components when we have new
updates
+ * @param s multihashmap of loaded sensors
+ * @param cb callback to reset service components when we have new updates
* @return #GNUNET_OK if started successfully, #GNUNET_SYSERR otherwise
*/
int
SENSOR_update_start (const struct GNUNET_CONFIGURATION_Handle *c,
struct GNUNET_CONTAINER_MultiHashMap *s,
- void (*reset_cb)());
-
+ void (*cb) ());
Modified: gnunet/src/sensor/sensor_api.c
===================================================================
--- gnunet/src/sensor/sensor_api.c 2014-07-29 13:06:05 UTC (rev 34074)
+++ gnunet/src/sensor/sensor_api.c 2014-07-29 14:01:37 UTC (rev 34075)
@@ -1,6 +1,6 @@
/*
This file is part of GNUnet.
- (C)
+ (C)
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
@@ -42,7 +42,7 @@
/**
* Our configuration.
*/
- const struct GNUNET_CONFIGURATION_Handle *cfg;
+ const struct GNUNET_CONFIGURATION_Handle *cfg;
/**
* Connection to the service.
@@ -190,6 +190,7 @@
static void
reconnect (struct GNUNET_SENSOR_Handle *h);
+
/**
* Check if we have a request pending in the transmission queue and are
* able to transmit it right now. If so, schedule transmission.
@@ -215,7 +216,7 @@
struct GNUNET_SENSOR_Handle *h;
client = GNUNET_CLIENT_connect ("sensor", cfg);
- if(NULL == client)
+ if (NULL == client)
return NULL;
h = GNUNET_new (struct GNUNET_SENSOR_Handle);
h->client = client;
@@ -223,13 +224,14 @@
return h;
}
+
/**
* Disconnect from the sensor service
*
* @param h handle to disconnect
*/
void
-GNUNET_SENSOR_disconnect(struct GNUNET_SENSOR_Handle *h)
+GNUNET_SENSOR_disconnect (struct GNUNET_SENSOR_Handle *h)
{
if (NULL != h->client)
{
@@ -239,6 +241,7 @@
GNUNET_free (h);
}
+
/**
* Task scheduled to re-try connecting to the sensor service.
*
@@ -254,6 +257,7 @@
reconnect (h);
}
+
/**
* Close the existing connection to SENSOR and reconnect.
*
@@ -299,7 +303,8 @@
* @param ic context of the iterator to cancel
*/
void
-GNUNET_SENSOR_iterate_sensor_cancel (struct
GNUNET_SENSOR_SensorIteratorContext *ic)
+GNUNET_SENSOR_iterate_sensor_cancel (struct GNUNET_SENSOR_SensorIteratorContext
+ *ic)
{
struct GNUNET_SENSOR_Handle *h;
@@ -312,9 +317,7 @@
ic->callback = NULL;
if (GNUNET_YES == ic->request_transmitted)
return; /* need to finish processing */
- GNUNET_CONTAINER_DLL_remove (h->ic_head,
- h->ic_tail,
- ic);
+ GNUNET_CONTAINER_DLL_remove (h->ic_head, h->ic_tail, ic);
if (NULL != ic->rc)
{
GNUNET_CONTAINER_DLL_remove (h->rc_head, h->rc_tail, ic->rc);
@@ -323,6 +326,7 @@
GNUNET_free (ic);
}
+
/**
* Iteration request has timed out.
*
@@ -330,7 +334,8 @@
* @param tc scheduler context
*/
static void
-signal_sensor_iteration_timeout (void *cls, const struct
GNUNET_SCHEDULER_TaskContext *tc)
+signal_sensor_iteration_timeout (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GNUNET_SENSOR_SensorIteratorContext *ic = cls;
GNUNET_SENSOR_SensorIteratorCB cb;
@@ -342,9 +347,10 @@
GNUNET_SENSOR_iterate_sensor_cancel (ic);
if (NULL != cb)
cb (cb_cls, NULL,
- _("Timeout transmitting iteration request to `SENSOR' service."));
+ _("Timeout transmitting iteration request to `SENSOR' service."));
}
+
/**
* Type of a function to call when we receive a message from the
* service. Call the iterator with the result and (if applicable)
@@ -355,7 +361,7 @@
* @param msg message received, NULL on timeout or fatal error
*/
static void
-sensor_handler(void *cls, const struct GNUNET_MessageHeader *msg)
+sensor_handler (void *cls, const struct GNUNET_MessageHeader *msg)
{
struct GNUNET_SENSOR_Handle *h = cls;
struct GNUNET_SENSOR_SensorIteratorContext *ic = h->ic_head;
@@ -376,7 +382,7 @@
{
cb = ic->callback;
cb_cls = ic->callback_cls;
- GNUNET_SENSOR_iterate_sensor_cancel(ic);
+ GNUNET_SENSOR_iterate_sensor_cancel (ic);
}
else
{
@@ -384,8 +390,7 @@
}
reconnect (h);
if (NULL != cb)
- cb (cb_cls, NULL,
- _("Failed to receive response from `SENSOR' service."));
+ cb (cb_cls, NULL, _("Failed to receive response from `SENSOR'
service."));
return;
}
if (NULL == ic)
@@ -402,14 +407,14 @@
/* normal end of list of sensors, signal end, process next pending request
*/
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Received end of list of sensors from `%s' service\n", "SENSOR");
- GNUNET_SENSOR_iterate_sensor_cancel(ic);
+ GNUNET_SENSOR_iterate_sensor_cancel (ic);
trigger_transmit (h);
- if ( (GNUNET_NO == h->in_receive) &&
- (NULL != h->ic_head) )
+ if ((GNUNET_NO == h->in_receive) && (NULL != h->ic_head))
{
h->in_receive = GNUNET_YES;
GNUNET_CLIENT_receive (h->client, &sensor_handler, h,
- GNUNET_TIME_absolute_get_remaining (h->ic_head->timeout));
+ GNUNET_TIME_absolute_get_remaining (h->
+
ic_head->timeout));
}
if (NULL != cb)
cb (cb_cls, NULL, NULL);
@@ -417,34 +422,33 @@
}
ms = ntohs (msg->size);
im = (const struct SensorInfoMessage *) msg;
- name_len = ntohs(im->name_len);
- desc_len = ntohs(im->description_len);
+ name_len = ntohs (im->name_len);
+ desc_len = ntohs (im->description_len);
if ((ms != sizeof (struct SensorInfoMessage) + name_len + desc_len) ||
(ntohs (msg->type) != GNUNET_MESSAGE_TYPE_SENSOR_INFO))
{
/* malformed message */
GNUNET_break (0);
- GNUNET_SENSOR_iterate_sensor_cancel(ic);
+ GNUNET_SENSOR_iterate_sensor_cancel (ic);
reconnect (h);
if (NULL != cb)
- cb (cb_cls, NULL,
- _("Received invalid message from `SENSOR' service."));
+ cb (cb_cls, NULL, _("Received invalid message from `SENSOR' service."));
return;
}
- sensor = GNUNET_new(struct SensorInfoShort);
- str_ptr = (char *)&im[1];
- sensor->name = GNUNET_strndup(str_ptr, name_len);
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Received sensor name (%d): %.*s\n",
- name_len, name_len, str_ptr);
+ sensor = GNUNET_new (struct SensorInfoShort);
+ str_ptr = (char *) &im[1];
+ sensor->name = GNUNET_strndup (str_ptr, name_len);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Received sensor name (%d): %.*s\n", name_len,
+ name_len, str_ptr);
str_ptr += name_len;
- if(desc_len > 0)
+ if (desc_len > 0)
{
LOG (GNUNET_ERROR_TYPE_DEBUG, "Received sensor description (%d): %.*s\n",
- desc_len, desc_len, str_ptr);
- sensor->description = GNUNET_strndup(str_ptr, desc_len);
+ desc_len, desc_len, str_ptr);
+ sensor->description = GNUNET_strndup (str_ptr, desc_len);
}
- sensor->version_major = ntohs(im->version_major);
- sensor->version_minor = ntohs(im->version_minor);
+ sensor->version_major = ntohs (im->version_major);
+ sensor->version_minor = ntohs (im->version_minor);
h->in_receive = GNUNET_YES;
GNUNET_CLIENT_receive (h->client, &sensor_handler, h,
GNUNET_TIME_absolute_get_remaining (ic->timeout));
@@ -452,6 +456,7 @@
cb (cb_cls, sensor, NULL);
}
+
/**
* We've transmitted the iteration request. Now get ready to process
* the results (or handle transmission error).
@@ -485,10 +490,11 @@
{
h->in_receive = GNUNET_YES;
GNUNET_CLIENT_receive (h->client, &sensor_handler, h,
- GNUNET_TIME_absolute_get_remaining (ic->timeout));
+ GNUNET_TIME_absolute_get_remaining (ic->timeout));
}
}
+
/**
* Transmit the request at the head of the transmission queue
* and trigger continuation (if any).
@@ -507,7 +513,7 @@
h->th = NULL;
if (NULL == rc)
- return 0; /* request was cancelled in the meantime */
+ return 0; /* request was cancelled in the meantime */
if (NULL == buf)
{
/* sensor service died */
@@ -538,6 +544,7 @@
return ret;
}
+
/**
* Check if we have a request pending in the transmission queue and are
* able to transmit it right now. If so, schedule transmission.
@@ -550,9 +557,9 @@
struct GNUNET_SENSOR_RequestContext *rc;
if (NULL == (rc = h->rc_head))
- return; /* no requests queued */
+ return; /* no requests queued */
if (NULL != h->th)
- return; /* request already pending */
+ return; /* request already pending */
if (NULL == h->client)
{
/* disconnected, try to reconnect */
@@ -560,12 +567,12 @@
return;
}
h->th =
- GNUNET_CLIENT_notify_transmit_ready (h->client, rc->size,
- GNUNET_TIME_UNIT_FOREVER_REL,
- GNUNET_YES,
- &do_transmit, h);
+ GNUNET_CLIENT_notify_transmit_ready (h->client, rc->size,
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_YES, &do_transmit, h);
}
+
/**
* Client asking to iterate all available sensors
*
@@ -579,41 +586,40 @@
*/
struct GNUNET_SENSOR_SensorIteratorContext *
GNUNET_SENSOR_iterate_sensors (struct GNUNET_SENSOR_Handle *h,
- struct GNUNET_TIME_Relative timeout,
- const char* sensorname, size_t sensorname_len,
- GNUNET_SENSOR_SensorIteratorCB callback, void *callback_cls)
+ struct GNUNET_TIME_Relative timeout,
+ const char *sensorname, size_t sensorname_len,
+ GNUNET_SENSOR_SensorIteratorCB callback,
+ void *callback_cls)
{
struct GNUNET_SENSOR_SensorIteratorContext *ic;
struct GNUNET_SENSOR_RequestContext *rc;
struct GNUNET_MessageHeader *mh;
ic = GNUNET_new (struct GNUNET_SENSOR_SensorIteratorContext);
+
if (NULL == sensorname)
{
LOG (GNUNET_ERROR_TYPE_INFO,
"Requesting list of sensors from SENSOR service\n");
- rc =
- GNUNET_malloc (sizeof (struct GNUNET_SENSOR_RequestContext) +
- sizeof (struct GNUNET_MessageHeader));
+ rc = GNUNET_malloc (sizeof (struct GNUNET_SENSOR_RequestContext) +
+ sizeof (struct GNUNET_MessageHeader));
rc->size = sizeof (struct GNUNET_MessageHeader);
mh = (struct GNUNET_MessageHeader *) &rc[1];
- mh->size = htons(sizeof (struct GNUNET_MessageHeader));
- mh->type = htons(GNUNET_MESSAGE_TYPE_SENSOR_GETALL);
+ mh->size = htons (sizeof (struct GNUNET_MessageHeader));
+ mh->type = htons (GNUNET_MESSAGE_TYPE_SENSOR_GETALL);
}
else
{
LOG (GNUNET_ERROR_TYPE_INFO,
"Requesting information on sensor `%s' from SENSOR service\n",
sensorname);
- rc =
- GNUNET_malloc (sizeof (struct GNUNET_SENSOR_RequestContext) +
- sizeof (struct GNUNET_MessageHeader) +
- sensorname_len);
+ rc = GNUNET_malloc (sizeof (struct GNUNET_SENSOR_RequestContext) +
+ sizeof (struct GNUNET_MessageHeader) + sensorname_len);
rc->size = sizeof (struct GNUNET_MessageHeader) + sensorname_len;
mh = (struct GNUNET_MessageHeader *) &rc[1];
- mh->size = htons(rc->size);
- mh->type = htons(GNUNET_MESSAGE_TYPE_SENSOR_GET);
- memcpy(&mh[1], sensorname, sensorname_len);
+ mh->size = htons (rc->size);
+ mh->type = htons (GNUNET_MESSAGE_TYPE_SENSOR_GET);
+ memcpy (&mh[1], sensorname, sensorname_len);
}
ic->h = h;
ic->rc = rc;
@@ -621,13 +627,12 @@
ic->callback_cls = callback_cls;
ic->timeout = GNUNET_TIME_relative_to_absolute (timeout);
ic->timeout_task =
- GNUNET_SCHEDULER_add_delayed (timeout, &signal_sensor_iteration_timeout,
ic);
+ GNUNET_SCHEDULER_add_delayed (timeout, &signal_sensor_iteration_timeout,
+ ic);
rc->cont = &sensor_iterator_start_receive;
rc->cont_cls = ic;
GNUNET_CONTAINER_DLL_insert_tail (h->rc_head, h->rc_tail, rc);
- GNUNET_CONTAINER_DLL_insert_tail (h->ic_head,
- h->ic_tail,
- ic);
+ GNUNET_CONTAINER_DLL_insert_tail (h->ic_head, h->ic_tail, ic);
trigger_transmit (h);
return ic;
}
Modified: gnunet/src/sensor/sensor_util_lib.c
===================================================================
--- gnunet/src/sensor/sensor_util_lib.c 2014-07-29 13:06:05 UTC (rev 34074)
+++ gnunet/src/sensor/sensor_util_lib.c 2014-07-29 14:01:37 UTC (rev 34075)
@@ -52,28 +52,28 @@
* @param version full version string
* @param major pointer to parsed major value
* @param minor pointer to parsed minor value
- * @return #GNUNET_OK if parsing went ok, #GNUNET_SYSERROR in case of error
+ * @return #GNUNET_OK if parsing went ok, #GNUNET_SYSERR in case of error
*/
static int
-version_parse(char *version, uint16_t *major, uint16_t *minor)
+version_parse (char *version, uint16_t * major, uint16_t * minor)
{
int majorval = 0;
int minorval = 0;
- for(; isdigit(*version); version++)
+ for (; isdigit (*version); version++)
{
majorval *= 10;
majorval += *version - '0';
}
- if(*version != '.')
+ if (*version != '.')
return GNUNET_SYSERR;
version++;
- for(; isdigit(*version); version++)
+ for (; isdigit (*version); version++)
{
minorval *= 10;
minorval += *version - '0';
}
- if(*version != 0)
+ if (*version != 0)
return GNUNET_SYSERR;
*major = majorval;
*minor = minorval;
@@ -81,6 +81,7 @@
return GNUNET_OK;
}
+
/**
* Load sensor definition from configuration
*
@@ -88,7 +89,8 @@
* @param sectionname configuration section containing definition
*/
static struct GNUNET_SENSOR_SensorInfo *
-load_sensor_from_cfg(struct GNUNET_CONFIGURATION_Handle *cfg, const char
*sectionname)
+load_sensor_from_cfg (struct GNUNET_CONFIGURATION_Handle *cfg,
+ const char *sectionname)
{
struct GNUNET_SENSOR_SensorInfo *sensor;
char *version_str;
@@ -98,152 +100,209 @@
char *dummy;
struct GNUNET_CRYPTO_EddsaPublicKey public_key;
- sensor = GNUNET_new(struct GNUNET_SENSOR_SensorInfo);
+ sensor = GNUNET_new (struct GNUNET_SENSOR_SensorInfo);
+
//name
- sensor->name = GNUNET_strdup(sectionname);
+ sensor->name = GNUNET_strdup (sectionname);
//version
- if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, sectionname,
"VERSION", &version_str))
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_string (cfg, sectionname, "VERSION",
+ &version_str))
{
LOG (GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor version\n"));
- GNUNET_free(sensor);
+ GNUNET_free (sensor);
return NULL;
}
- if(GNUNET_OK != version_parse(version_str, &(sensor->version_major),
&(sensor->version_minor)))
+ if (GNUNET_OK !=
+ version_parse (version_str, &(sensor->version_major),
+ &(sensor->version_minor)))
{
- LOG (GNUNET_ERROR_TYPE_ERROR, _("Invalid sensor version number, format
should be major.minor\n"));
- GNUNET_free(sensor);
- GNUNET_free(version_str);
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ _("Invalid sensor version number, format should be major.minor\n"));
+ GNUNET_free (sensor);
+ GNUNET_free (version_str);
return NULL;
}
- GNUNET_free(version_str);
+ GNUNET_free (version_str);
//description
- GNUNET_CONFIGURATION_get_value_string(cfg, sectionname, "DESCRIPTION",
&sensor->description);
+ GNUNET_CONFIGURATION_get_value_string (cfg, sectionname, "DESCRIPTION",
+ &sensor->description);
//category
- if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, sectionname,
"CATEGORY", &sensor->category) ||
- NULL == sensor->category)
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_string (cfg, sectionname, "CATEGORY",
+ &sensor->category) ||
+ NULL == sensor->category)
{
LOG (GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor category\n"));
- GNUNET_free(sensor);
+ GNUNET_free (sensor);
return NULL;
}
//enabled
- if(GNUNET_NO == GNUNET_CONFIGURATION_get_value_yesno(cfg, sectionname,
"ENABLED"))
+ if (GNUNET_NO ==
+ GNUNET_CONFIGURATION_get_value_yesno (cfg, sectionname, "ENABLED"))
sensor->enabled = GNUNET_NO;
else
sensor->enabled = GNUNET_YES;
//start time
sensor->start_time = NULL;
- if(GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, sectionname,
"START_TIME", &starttime_str))
+ if (GNUNET_OK ==
+ GNUNET_CONFIGURATION_get_value_string (cfg, sectionname, "START_TIME",
+ &starttime_str))
{
- GNUNET_STRINGS_fancy_time_to_absolute(starttime_str, sensor->start_time);
- LOG (GNUNET_ERROR_TYPE_DEBUG, "Start time loaded: `%s'. Parsed: %d\n",
starttime_str, (NULL != sensor->start_time));
- GNUNET_free(starttime_str);
+ GNUNET_STRINGS_fancy_time_to_absolute (starttime_str, sensor->start_time);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "Start time loaded: `%s'. Parsed: %d\n",
+ starttime_str, (NULL != sensor->start_time));
+ GNUNET_free (starttime_str);
}
//end time
sensor->end_time = NULL;
- if(GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, sectionname,
"END_TIME", &endtime_str))
+ if (GNUNET_OK ==
+ GNUNET_CONFIGURATION_get_value_string (cfg, sectionname, "END_TIME",
+ &endtime_str))
{
- GNUNET_STRINGS_fancy_time_to_absolute(endtime_str, sensor->end_time);
- LOG (GNUNET_ERROR_TYPE_DEBUG, "End time loaded: `%s'. Parsed: %d\n",
endtime_str, (NULL != sensor->end_time));
- GNUNET_free(endtime_str);
+ GNUNET_STRINGS_fancy_time_to_absolute (endtime_str, sensor->end_time);
+ LOG (GNUNET_ERROR_TYPE_DEBUG, "End time loaded: `%s'. Parsed: %d\n",
+ endtime_str, (NULL != sensor->end_time));
+ GNUNET_free (endtime_str);
}
//interval
- if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg, sectionname,
"INTERVAL", &time_sec))
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_number (cfg, sectionname, "INTERVAL",
+ &time_sec))
{
LOG (GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor run interval\n"));
- GNUNET_free(sensor);
+ GNUNET_free (sensor);
return NULL;
}
- if(time_sec < MIN_INTERVAL)
+ if (time_sec < MIN_INTERVAL)
{
- LOG (GNUNET_ERROR_TYPE_ERROR, _("Sensor run interval too low (%" PRIu64 "
< %d)\n"),
- time_sec, MIN_INTERVAL);
- GNUNET_free(sensor);
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ _("Sensor run interval too low (%" PRIu64 " < %d)\n"), time_sec,
+ MIN_INTERVAL);
+ GNUNET_free (sensor);
return NULL;
}
- sensor->interval = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS,
time_sec);
+ sensor->interval =
+ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, time_sec);
//lifetime
- if(GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, sectionname,
"LIFETIME", &time_sec))
+ if (GNUNET_OK ==
+ GNUNET_CONFIGURATION_get_value_number (cfg, sectionname, "LIFETIME",
+ &time_sec))
{
- sensor->lifetime = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS,
time_sec);
+ sensor->lifetime =
+ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, time_sec);
if (sensor->lifetime.rel_value_us < sensor->interval.rel_value_us)
- LOG (GNUNET_ERROR_TYPE_WARNING,
- "Lifetime of sensor data is preferred to be higher than interval for
sensor `%s'.\n",
- sensor->name);
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ "Lifetime of sensor data is preferred to be higher than interval
for sensor `%s'.\n",
+ sensor->name);
}
else
sensor->lifetime = GNUNET_TIME_UNIT_FOREVER_REL;
//capabilities TODO
//source
- if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_choice(cfg, sectionname,
"SOURCE", sources, (const char **)&sensor->source))
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_choice (cfg, sectionname, "SOURCE",
+ sources,
+ (const char **) &sensor->source))
{
LOG (GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor source\n"));
- GNUNET_free(sensor);
+ GNUNET_free (sensor);
return NULL;
}
- if(sources[0] == sensor->source) //gnunet-statistics
+ if (sources[0] == sensor->source) //gnunet-statistics
{
- if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, sectionname,
"GNUNET_STAT_SERVICE", &sensor->gnunet_stat_service) ||
- GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, sectionname,
"GNUNET_STAT_NAME", &sensor->gnunet_stat_name))
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_string (cfg, sectionname,
+ "GNUNET_STAT_SERVICE",
+ &sensor->gnunet_stat_service) ||
+ GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, sectionname,
+ "GNUNET_STAT_NAME",
+
&sensor->gnunet_stat_name))
{
- LOG (GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor gnunet-statistics
source information\n"));
- GNUNET_free(sensor);
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ _("Error reading sensor gnunet-statistics source information\n"));
+ GNUNET_free (sensor);
return NULL;
}
sensor->gnunet_stat_get_handle = NULL;
}
- else if(sources[1] == sensor->source) //process
+ else if (sources[1] == sensor->source) //process
{
- if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, sectionname,
"EXT_PROCESS", &sensor->ext_process))
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_string (cfg, sectionname, "EXT_PROCESS",
+ &sensor->ext_process))
{
LOG (GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor process name\n"));
- GNUNET_free(sensor);
+ GNUNET_free (sensor);
return NULL;
}
- GNUNET_CONFIGURATION_get_value_string(cfg, sectionname, "EXT_ARGS",
&sensor->ext_args);
+ GNUNET_CONFIGURATION_get_value_string (cfg, sectionname, "EXT_ARGS",
+ &sensor->ext_args);
}
//expected datatype
- if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_choice(cfg, sectionname,
"EXPECTED_DATATYPE", datatypes, (const char **)&sensor->expected_datatype))
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_choice (cfg, sectionname,
+ "EXPECTED_DATATYPE", datatypes,
+ (const char **)
+ &sensor->expected_datatype))
{
- LOG (GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor expected
datatype\n"));
- GNUNET_free(sensor);
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ _("Error reading sensor expected datatype\n"));
+ GNUNET_free (sensor);
return NULL;
}
- if(sources[0] == sensor->source && datatypes[0] != sensor->expected_datatype)
+ if (sources[0] == sensor->source && datatypes[0] !=
sensor->expected_datatype)
{
- LOG (GNUNET_ERROR_TYPE_ERROR, _("Invalid expected datatype,
gnunet-statistics returns uint64 values\n"));
- GNUNET_free(sensor);
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ _
+ ("Invalid expected datatype, gnunet-statistics returns uint64
values\n"));
+ GNUNET_free (sensor);
return NULL;
}
//reporting mechanism
sensor->collection_point = NULL;
- if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, sectionname,
"COLLECTION_POINT", &dummy))
+ if (GNUNET_OK ==
+ GNUNET_CONFIGURATION_get_value_string (cfg, sectionname,
+ "COLLECTION_POINT", &dummy))
{
- if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg, sectionname,
"COLLECTION_INTERVAL", &time_sec))
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_number (cfg, sectionname,
+ "COLLECTION_INTERVAL",
+ &time_sec))
{
- LOG (GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor collection
interval\n"));
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ _("Error reading sensor collection interval\n"));
}
else
{
- sensor->collection_interval =
GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, time_sec);
- if (GNUNET_OK == GNUNET_CRYPTO_eddsa_public_key_from_string(dummy,
strlen(dummy), &public_key))
+ sensor->collection_interval =
+ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, time_sec);
+ if (GNUNET_OK ==
+ GNUNET_CRYPTO_eddsa_public_key_from_string (dummy, strlen (dummy),
+ &public_key))
{
- sensor->collection_point = GNUNET_new(struct GNUNET_PeerIdentity);
+ sensor->collection_point = GNUNET_new (struct GNUNET_PeerIdentity);
+
sensor->collection_point->public_key = public_key;
}
}
GNUNET_free (dummy);
}
sensor->p2p_report = GNUNET_NO;
- if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno(cfg, sectionname,
"P2P_REPORT"))
+ if (GNUNET_YES ==
+ GNUNET_CONFIGURATION_get_value_yesno (cfg, sectionname, "P2P_REPORT"))
{
- if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg, sectionname,
"P2P_INTERVAL", &time_sec))
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_number (cfg, sectionname,
"P2P_INTERVAL",
+ &time_sec))
{
- LOG (GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor p2p reporting
interval\n"));
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ _("Error reading sensor p2p reporting interval\n"));
}
else
{
- sensor->p2p_interval =
GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, time_sec);
+ sensor->p2p_interval =
+ GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, time_sec);
sensor->p2p_report = GNUNET_YES;
}
}
@@ -255,43 +314,45 @@
return sensor;
}
+
/**
* Load sensor definition from file
*
* @param filename full path to file containing sensor definition
*/
static struct GNUNET_SENSOR_SensorInfo *
-load_sensor_from_file(const char *filename)
+load_sensor_from_file (const char *filename)
{
struct GNUNET_CONFIGURATION_Handle *sensorcfg;
const char *filebasename;
struct GNUNET_SENSOR_SensorInfo *sensor;
//test file
- if(GNUNET_YES != GNUNET_DISK_file_test(filename))
+ if (GNUNET_YES != GNUNET_DISK_file_test (filename))
{
- LOG (GNUNET_ERROR_TYPE_ERROR, _("Failed to access sensor file: %s\n"),
filename);
+ LOG (GNUNET_ERROR_TYPE_ERROR, _("Failed to access sensor file: %s\n"),
+ filename);
return NULL;
}
//load file as configuration
- sensorcfg = GNUNET_CONFIGURATION_create();
- if(GNUNET_SYSERR == GNUNET_CONFIGURATION_parse(sensorcfg, filename))
+ sensorcfg = GNUNET_CONFIGURATION_create ();
+ if (GNUNET_SYSERR == GNUNET_CONFIGURATION_parse (sensorcfg, filename))
{
- GNUNET_CONFIGURATION_destroy(sensorcfg);
- LOG (GNUNET_ERROR_TYPE_ERROR, _("Failed to load sensor definition: %s\n"),
filename);
+ GNUNET_CONFIGURATION_destroy (sensorcfg);
+ LOG (GNUNET_ERROR_TYPE_ERROR, _("Failed to load sensor definition: %s\n"),
+ filename);
return NULL;
}
//configuration section should be the same as filename
- filebasename = GNUNET_STRINGS_get_short_name(filename);
- sensor = load_sensor_from_cfg(sensorcfg, filebasename);
- if(NULL == sensor)
+ filebasename = GNUNET_STRINGS_get_short_name (filename);
+ sensor = load_sensor_from_cfg (sensorcfg, filebasename);
+ if (NULL == sensor)
{
- GNUNET_CONFIGURATION_destroy(sensorcfg);
+ GNUNET_CONFIGURATION_destroy (sensorcfg);
return NULL;
}
- sensor->def_file = GNUNET_strdup(filename);
+ sensor->def_file = GNUNET_strdup (filename);
sensor->cfg = sensorcfg;
-
return sensor;
}
@@ -331,14 +392,13 @@
struct GNUNET_HashCode key;
struct GNUNET_SENSOR_SensorInfo *existing;
- GNUNET_CRYPTO_hash(sensor->name, strlen(sensor->name) + 1, &key);
- existing = GNUNET_CONTAINER_multihashmap_get(map, &key);
- if(NULL != existing) //sensor with same name already exists
+ GNUNET_CRYPTO_hash (sensor->name, strlen (sensor->name) + 1, &key);
+ existing = GNUNET_CONTAINER_multihashmap_get (map, &key);
+ if (NULL != existing) //sensor with same name already exists
{
- if(GNUNET_SENSOR_version_compare (existing->version_major,
- existing->version_minor,
- sensor->version_major,
- sensor->version_minor) >= 0)
+ if (GNUNET_SENSOR_version_compare
+ (existing->version_major, existing->version_minor,
+ sensor->version_major, sensor->version_minor) >= 0)
{
LOG (GNUNET_ERROR_TYPE_INFO,
_("Sensor `%s' already exists with same or newer version\n"),
@@ -347,24 +407,24 @@
}
else
{
- GNUNET_CONTAINER_multihashmap_remove(map, &key, existing); //remove the
old version
- GNUNET_free(existing);
- LOG (GNUNET_ERROR_TYPE_INFO,
- "Upgrading sensor `%s' to a newer version\n",
+ GNUNET_CONTAINER_multihashmap_remove (map, &key, existing);
//remove the old version
+ GNUNET_free (existing);
+ LOG (GNUNET_ERROR_TYPE_INFO, "Upgrading sensor `%s' to a newer
version\n",
sensor->name);
}
}
- if(GNUNET_SYSERR == GNUNET_CONTAINER_multihashmap_put(map, &key, sensor,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
+ if (GNUNET_SYSERR ==
+ GNUNET_CONTAINER_multihashmap_put (map, &key, sensor,
+
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
{
LOG (GNUNET_ERROR_TYPE_ERROR,
- _("Error adding new sensor `%s' to global hashmap.\n"),
- sensor->name);
+ _("Error adding new sensor `%s' to global hashmap.\n"), sensor->name);
return GNUNET_NO;
}
-
return GNUNET_YES;
}
+
/**
* Iterating over files in sensors directory
*
@@ -373,27 +433,27 @@
* @return #GNUNET_OK to continue to iterate
*/
static int
-reload_sensors_dir_cb(void *cls, const char *filename)
+reload_sensors_dir_cb (void *cls, const char *filename)
{
struct GNUNET_CONTAINER_MultiHashMap *sensors = cls;
struct GNUNET_SENSOR_SensorInfo *sensor;
- if(GNUNET_YES != GNUNET_DISK_file_test(filename))
+ if (GNUNET_YES != GNUNET_DISK_file_test (filename))
return GNUNET_OK;
- sensor = load_sensor_from_file(filename);
- if(NULL == sensor)
+ sensor = load_sensor_from_file (filename);
+ if (NULL == sensor)
{
- LOG (GNUNET_ERROR_TYPE_ERROR,
- _("Error loading sensor from file: %s\n"), filename);
+ LOG (GNUNET_ERROR_TYPE_ERROR, _("Error loading sensor from file: %s\n"),
+ filename);
return GNUNET_OK;
}
- if(GNUNET_YES != add_sensor_to_hashmap(sensor, sensors))
+ if (GNUNET_YES != add_sensor_to_hashmap (sensor, sensors))
LOG (GNUNET_ERROR_TYPE_WARNING,
- "Could not add sensor `%s' to global hashmap\n", sensor->name);
-
+ "Could not add sensor `%s' to global hashmap\n", sensor->name);
return GNUNET_OK;
}
+
/*
* Get path to the directory containing the sensor definition files with a
* trailing directory separator.
@@ -403,19 +463,16 @@
char *
GNUNET_SENSOR_get_sensor_dir ()
{
- char* datadir;
- char* sensordir;
+ char *datadir;
+ char *sensordir;
- datadir = GNUNET_OS_installation_get_path(GNUNET_OS_IPK_DATADIR);
- GNUNET_asprintf (&sensordir,
- "%ssensors%s",
- datadir,
- DIR_SEPARATOR_STR);
- GNUNET_free(datadir);
-
+ datadir = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_DATADIR);
+ GNUNET_asprintf (&sensordir, "%ssensors%s", datadir, DIR_SEPARATOR_STR);
+ GNUNET_free (datadir);
return sensordir;
}
+
/**
* Reads sensor definitions from local data files
*
@@ -424,20 +481,21 @@
struct GNUNET_CONTAINER_MultiHashMap *
GNUNET_SENSOR_load_all_sensors ()
{
- char* sensordir;
+ char *sensordir;
struct GNUNET_CONTAINER_MultiHashMap *sensors;
- sensors = GNUNET_CONTAINER_multihashmap_create(10, GNUNET_NO);
+ sensors = GNUNET_CONTAINER_multihashmap_create (10, GNUNET_NO);
sensordir = GNUNET_SENSOR_get_sensor_dir ();
LOG (GNUNET_ERROR_TYPE_INFO,
- "Loading sensor definitions from directory `%s'\n", sensordir);
- GNUNET_assert(GNUNET_YES == GNUNET_DISK_directory_test(sensordir,
GNUNET_YES));
+ "Loading sensor definitions from directory `%s'\n", sensordir);
+ GNUNET_assert (GNUNET_YES ==
+ GNUNET_DISK_directory_test (sensordir, GNUNET_YES));
//read all files in sensors directory
- GNUNET_DISK_directory_scan(sensordir, &reload_sensors_dir_cb, sensors);
+ GNUNET_DISK_directory_scan (sensordir, &reload_sensors_dir_cb, sensors);
LOG (GNUNET_ERROR_TYPE_INFO, "Loaded %d sensors from directory `%s'\n",
- GNUNET_CONTAINER_multihashmap_size(sensors), sensordir);
- GNUNET_free(sensordir);
+ GNUNET_CONTAINER_multihashmap_size (sensors), sensordir);
+ GNUNET_free (sensordir);
return sensors;
}
@@ -452,46 +510,45 @@
* iterate,
* #GNUNET_NO if not.
*/
-static int destroy_sensor(void *cls,
- const struct GNUNET_HashCode *key,
- void *value)
+static int
+destroy_sensor (void *cls, const struct GNUNET_HashCode *key, void *value)
{
struct GNUNET_SENSOR_SensorInfo *sensor = value;
- if(GNUNET_SCHEDULER_NO_TASK != sensor->execution_task)
+ if (GNUNET_SCHEDULER_NO_TASK != sensor->execution_task)
{
- GNUNET_SCHEDULER_cancel(sensor->execution_task);
+ GNUNET_SCHEDULER_cancel (sensor->execution_task);
sensor->execution_task = GNUNET_SCHEDULER_NO_TASK;
}
- if(NULL != sensor->gnunet_stat_get_handle)
+ if (NULL != sensor->gnunet_stat_get_handle)
{
- GNUNET_STATISTICS_get_cancel(sensor->gnunet_stat_get_handle);
+ GNUNET_STATISTICS_get_cancel (sensor->gnunet_stat_get_handle);
sensor->gnunet_stat_get_handle = NULL;
}
- if(NULL != sensor->ext_cmd)
+ if (NULL != sensor->ext_cmd)
{
- GNUNET_OS_command_stop(sensor->ext_cmd);
+ GNUNET_OS_command_stop (sensor->ext_cmd);
sensor->ext_cmd = NULL;
}
- if(NULL != sensor->cfg)
- GNUNET_CONFIGURATION_destroy(sensor->cfg);
- if(NULL != sensor->name)
+ if (NULL != sensor->cfg)
+ GNUNET_CONFIGURATION_destroy (sensor->cfg);
+ if (NULL != sensor->name)
GNUNET_free (sensor->name);
- if(NULL != sensor->def_file)
+ if (NULL != sensor->def_file)
GNUNET_free (sensor->def_file);
- if(NULL != sensor->description)
+ if (NULL != sensor->description)
GNUNET_free (sensor->description);
- if(NULL != sensor->category)
+ if (NULL != sensor->category)
GNUNET_free (sensor->category);
- if(NULL != sensor->capabilities)
+ if (NULL != sensor->capabilities)
GNUNET_free (sensor->capabilities);
- if(NULL != sensor->gnunet_stat_service)
+ if (NULL != sensor->gnunet_stat_service)
GNUNET_free (sensor->gnunet_stat_service);
- if(NULL != sensor->gnunet_stat_name)
+ if (NULL != sensor->gnunet_stat_name)
GNUNET_free (sensor->gnunet_stat_name);
- if(NULL != sensor->ext_process)
+ if (NULL != sensor->ext_process)
GNUNET_free (sensor->ext_process);
- if(NULL != sensor->ext_args)
+ if (NULL != sensor->ext_args)
GNUNET_free (sensor->ext_args);
if (NULL != sensor->collection_point)
GNUNET_free (sensor->collection_point);
@@ -499,6 +556,7 @@
return GNUNET_YES;
}
+
/**
* Destroys a group of sensors in a hashmap and the hashmap itself
*
@@ -508,7 +566,6 @@
GNUNET_SENSOR_destroy_sensors (struct GNUNET_CONTAINER_MultiHashMap *sensors)
{
LOG (GNUNET_ERROR_TYPE_DEBUG, "Destroying sensor list.\n");
- GNUNET_CONTAINER_multihashmap_iterate(sensors, &destroy_sensor, NULL);
- GNUNET_CONTAINER_multihashmap_destroy(sensors);
+ GNUNET_CONTAINER_multihashmap_iterate (sensors, &destroy_sensor, NULL);
+ GNUNET_CONTAINER_multihashmap_destroy (sensors);
}
-
Modified: gnunet/src/sensor/test_sensor_api.c
===================================================================
--- gnunet/src/sensor/test_sensor_api.c 2014-07-29 13:06:05 UTC (rev 34074)
+++ gnunet/src/sensor/test_sensor_api.c 2014-07-29 14:01:37 UTC (rev 34075)
@@ -30,9 +30,7 @@
static void
-run (void *cls,
- char *const *args,
- const char *cfgfile,
+run (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
ok = 0;
@@ -47,25 +45,27 @@
GNUNET_GETOPT_OPTION_END
};
struct GNUNET_OS_Process *proc;
- char *path = GNUNET_OS_get_libexec_binary_path ( "gnunet-service-sensor");
+ char *path = GNUNET_OS_get_libexec_binary_path ("gnunet-service-sensor");
+
if (NULL == path)
{
- fprintf (stderr, "Service executable not found `%s'\n",
"gnunet-service-sensor");
- return -1;
+ fprintf (stderr, "Service executable not found `%s'\n",
+ "gnunet-service-sensor");
+ return -1;
}
- proc = GNUNET_OS_start_process (GNUNET_NO, GNUNET_OS_INHERIT_STD_ALL, NULL,
- NULL, NULL, path, "gnunet-service-sensor", NULL);
+ proc =
+ GNUNET_OS_start_process (GNUNET_NO, GNUNET_OS_INHERIT_STD_ALL, NULL,
NULL,
+ NULL, path, "gnunet-service-sensor", NULL);
GNUNET_free (path);
GNUNET_assert (NULL != proc);
- GNUNET_PROGRAM_run (1, argv, "test-sensor-api", "nohelp",
- options, &run, &ok);
+ GNUNET_PROGRAM_run (1, argv, "test-sensor-api", "nohelp", options, &run,
&ok);
if (0 != GNUNET_OS_process_kill (proc, SIGTERM))
- {
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
- ok = 1;
- }
+ {
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+ ok = 1;
+ }
GNUNET_OS_process_wait (proc);
GNUNET_OS_process_destroy (proc);
return ok;
@@ -75,9 +75,7 @@
int
main (int argc, char *argv[])
{
- GNUNET_log_setup ("test_statistics_api",
- "WARNING",
- NULL);
+ GNUNET_log_setup ("test_statistics_api", "WARNING", NULL);
return check ();
}
Modified: gnunet/src/sensordashboard/gnunet-sensordashboard.c
===================================================================
--- gnunet/src/sensordashboard/gnunet-sensordashboard.c 2014-07-29 13:06:05 UTC
(rev 34074)
+++ gnunet/src/sensordashboard/gnunet-sensordashboard.c 2014-07-29 14:01:37 UTC
(rev 34075)
@@ -64,11 +64,12 @@
if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
return 2;
- ret = (GNUNET_OK ==
- GNUNET_PROGRAM_run (argc, argv, "gnunet-sensordashboard",
- gettext_noop ("help text"), options, &run,
- NULL)) ? ret : 1;
- GNUNET_free ((void*) argv);
+ ret =
+ (GNUNET_OK ==
+ GNUNET_PROGRAM_run (argc, argv, "gnunet-sensordashboard",
+ gettext_noop ("help text"), options, &run,
+ NULL)) ? ret : 1;
+ GNUNET_free ((void *) argv);
return ret;
}
Modified: gnunet/src/sensordashboard/gnunet-service-sensordashboard.c
===================================================================
--- gnunet/src/sensordashboard/gnunet-service-sensordashboard.c 2014-07-29
13:06:05 UTC (rev 34074)
+++ gnunet/src/sensordashboard/gnunet-service-sensordashboard.c 2014-07-29
14:01:37 UTC (rev 34075)
@@ -251,8 +251,7 @@
* with the channel is stored
*/
static void
-cadet_channel_destroyed (void *cls,
- const struct GNUNET_CADET_Channel *channel,
+cadet_channel_destroyed (void *cls, const struct GNUNET_CADET_Channel *channel,
void *channel_ctx)
{
struct ClientPeerContext *cp = channel_ctx;
@@ -284,8 +283,7 @@
* (can be NULL -- that's not an error)
*/
static void *
-cadet_channel_created (void *cls,
- struct GNUNET_CADET_Channel *channel,
+cadet_channel_created (void *cls, struct GNUNET_CADET_Channel *channel,
const struct GNUNET_PeerIdentity *initiator,
uint32_t port, enum GNUNET_CADET_ChannelOption options)
{
@@ -295,6 +293,7 @@
"Received a channel connection from peer `%s'.\n",
GNUNET_i2s (initiator));
cp = GNUNET_new (struct ClientPeerContext);
+
cp->peerid = *initiator;
cp->ch = channel;
cp->destroying = GNUNET_NO;
@@ -356,12 +355,11 @@
if (NULL != cp->th)
return;
pm = cp->pm_head;
- cp->th = GNUNET_CADET_notify_transmit_ready (cp->ch,
- GNUNET_YES,
- GNUNET_TIME_UNIT_FOREVER_REL,
- ntohs (pm->msg->size),
- &do_send_msg,
- cp);
+ cp->th =
+ GNUNET_CADET_notify_transmit_ready (cp->ch, GNUNET_YES,
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ ntohs (pm->msg->size), &do_send_msg,
+ cp);
}
@@ -377,6 +375,7 @@
struct PendingMessage *pm;
pm = GNUNET_new (struct PendingMessage);
+
pm->msg = msg;
GNUNET_CONTAINER_DLL_insert_tail (cp->pm_head, cp->pm_tail, pm);
trigger_send_next_msg (cp);
@@ -393,9 +392,7 @@
* @return #GNUNET_YES to continue iteration
*/
static int
-send_sensor_brief (void *cls,
- const struct GNUNET_HashCode *key,
- void *value)
+send_sensor_brief (void *cls, const struct GNUNET_HashCode *key, void *value)
{
struct ClientPeerContext *cp = cls;
struct GNUNET_SENSOR_SensorInfo *sensor = value;
@@ -405,8 +402,8 @@
/* Create message struct */
sensorname_size = strlen (sensor->name) + 1;
- total_size = sizeof (struct GNUNET_SENSOR_SensorBriefMessage) +
- sensorname_size;
+ total_size =
+ sizeof (struct GNUNET_SENSOR_SensorBriefMessage) + sensorname_size;
msg = GNUNET_malloc (total_size);
msg->header.size = htons (total_size);
msg->header.type = htons (GNUNET_MESSAGE_TYPE_SENSOR_BRIEF);
@@ -415,7 +412,7 @@
msg->version_minor = htons (sensor->version_minor);
memcpy (&msg[1], sensor->name, sensorname_size);
/* Queue the msg */
- queue_msg ((struct GNUNET_MessageHeader *)msg, cp);
+ queue_msg ((struct GNUNET_MessageHeader *) msg, cp);
return GNUNET_YES;
}
@@ -435,8 +432,7 @@
* #GNUNET_SYSERR to close it (signal serious error).
*/
static int
-handle_sensor_list_req (void *cls,
- struct GNUNET_CADET_Channel *channel,
+handle_sensor_list_req (void *cls, struct GNUNET_CADET_Channel *channel,
void **channel_ctx,
const struct GNUNET_MessageHeader *message)
{
@@ -446,10 +442,9 @@
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Received a sensor list request from peer `%s'.\n",
GNUNET_i2s (&cp->peerid));
- GNUNET_CONTAINER_multihashmap_iterate (sensors,
- &send_sensor_brief,
- cp);
+ GNUNET_CONTAINER_multihashmap_iterate (sensors, &send_sensor_brief, cp);
end_msg = GNUNET_new (struct GNUNET_MessageHeader);
+
end_msg->size = htons (sizeof (struct GNUNET_MessageHeader));
end_msg->type = htons (GNUNET_MESSAGE_TYPE_SENSOR_END);
queue_msg (end_msg, cp);
@@ -485,11 +480,11 @@
GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Invalid reading message size.\n");
return NULL;
}
- rm = (struct GNUNET_SENSOR_ReadingMessage *)msg;
+ rm = (struct GNUNET_SENSOR_ReadingMessage *) msg;
sensorname_size = ntohs (rm->sensorname_size);
value_size = ntohs (rm->value_size);
- if ((sizeof (struct GNUNET_SENSOR_ReadingMessage)
- + sensorname_size + value_size) != msg_size)
+ if ((sizeof (struct GNUNET_SENSOR_ReadingMessage) + sensorname_size +
+ value_size) != msg_size)
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Invalid reading message size.\n");
return NULL;
@@ -497,13 +492,13 @@
dummy = &rm[1];
sensorname = GNUNET_malloc (sensorname_size);
memcpy (sensorname, dummy, sensorname_size);
- GNUNET_CRYPTO_hash(sensorname, sensorname_size, &key);
+ GNUNET_CRYPTO_hash (sensorname, sensorname_size, &key);
GNUNET_free (sensorname);
sensor = GNUNET_CONTAINER_multihashmap_get (sensors, &key);
if (NULL == sensor)
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "Unknown sensor name in reading message.\n");
+ "Unknown sensor name in reading message.\n");
return NULL;
}
if ((sensor->version_minor != ntohs (rm->sensorversion_minor)) ||
@@ -546,8 +541,7 @@
* #GNUNET_SYSERR to close it (signal serious error).
*/
static int
-handle_sensor_reading (void *cls,
- struct GNUNET_CADET_Channel *channel,
+handle_sensor_reading (void *cls, struct GNUNET_CADET_Channel *channel,
void **channel_ctx,
const struct GNUNET_MessageHeader *message)
{
@@ -564,13 +558,9 @@
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Received a sensor reading from peer `%s':\n"
- "# Sensor name: `%s'\n"
- "# Timestamp: %" PRIu64 "\n"
- "# Value size: %" PRIu64 ".\n",
- GNUNET_i2s (&cp->peerid),
- reading->sensor->name,
- reading->timestamp,
- reading->value_size);
+ "# Sensor name: `%s'\n" "# Timestamp: %" PRIu64 "\n"
+ "# Value size: %" PRIu64 ".\n", GNUNET_i2s (&cp->peerid),
+ reading->sensor->name, reading->timestamp, reading->value_size);
GNUNET_PEERSTORE_store (peerstore, subsystem, &cp->peerid,
reading->sensor->name, reading->value,
reading->value_size, GNUNET_TIME_UNIT_FOREVER_ABS,
@@ -609,12 +599,10 @@
if (NULL == sensor)
return NULL;
sensor_dir = GNUNET_SENSOR_get_sensor_dir ();
- GNUNET_asprintf (&sensor_path, "%s%s",
- sensor_dir, sensorname);
- if (GNUNET_OK != GNUNET_DISK_file_size (sensor_path,
- &sensorfile_size,
- GNUNET_NO,
- GNUNET_YES))
+ GNUNET_asprintf (&sensor_path, "%s%s", sensor_dir, sensorname);
+ if (GNUNET_OK !=
+ GNUNET_DISK_file_size (sensor_path, &sensorfile_size, GNUNET_NO,
+ GNUNET_YES))
{
GNUNET_free (sensor_dir);
GNUNET_free (sensor_path);
@@ -626,25 +614,19 @@
/* Test if there is an associated script */
if (NULL != sensor->ext_process)
{
- GNUNET_asprintf (&sensorscript_path, "%s%s-files%s%s",
- sensor_dir,
- sensor->name,
- DIR_SEPARATOR_STR,
- sensor->ext_process);
- if (GNUNET_OK == GNUNET_DISK_file_size (sensorscript_path,
- &sensorscript_size,
- GNUNET_NO,
- GNUNET_YES))
+ GNUNET_asprintf (&sensorscript_path, "%s%s-files%s%s", sensor_dir,
+ sensor->name, DIR_SEPARATOR_STR, sensor->ext_process);
+ if (GNUNET_OK ==
+ GNUNET_DISK_file_size (sensorscript_path, &sensorscript_size,
GNUNET_NO,
+ GNUNET_YES))
{
sensorscriptname_size = strlen (sensor->ext_process) + 1;
}
}
/* Construct the msg */
- total_size = sizeof (struct GNUNET_SENSOR_SensorFullMessage) +
- sensorname_size +
- sensorfile_size +
- sensorscriptname_size +
- sensorscript_size;
+ total_size =
+ sizeof (struct GNUNET_SENSOR_SensorFullMessage) + sensorname_size +
+ sensorfile_size + sensorscriptname_size + sensorscript_size;
msg = GNUNET_malloc (total_size);
msg->header.size = htons (total_size);
msg->header.type = htons (GNUNET_MESSAGE_TYPE_SENSOR_FULL);
@@ -685,8 +667,7 @@
* #GNUNET_SYSERR to close it (signal serious error).
*/
static int
-handle_sensor_full_req (void *cls,
- struct GNUNET_CADET_Channel *channel,
+handle_sensor_full_req (void *cls, struct GNUNET_CADET_Channel *channel,
void **channel_ctx,
const struct GNUNET_MessageHeader *message)
{
@@ -700,10 +681,10 @@
/* parse & error check */
if (msg_size > sizeof (struct GNUNET_SENSOR_SensorBriefMessage))
{
- sbm = (struct GNUNET_SENSOR_SensorBriefMessage *)message;
+ sbm = (struct GNUNET_SENSOR_SensorBriefMessage *) message;
sensorname_size = ntohs (sbm->name_size);
- if (msg_size != sizeof (struct GNUNET_SENSOR_SensorBriefMessage) +
- sensorname_size)
+ if (msg_size !=
+ sizeof (struct GNUNET_SENSOR_SensorBriefMessage) + sensorname_size)
sbm = NULL;
}
if (NULL == sbm)
@@ -714,15 +695,15 @@
return GNUNET_SYSERR;
}
/* Create and send msg with full sensor info */
- sfm = create_full_sensor_msg ((char *)&sbm[1]);
+ sfm = create_full_sensor_msg ((char *) &sbm[1]);
if (NULL == sfm)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Error creating full sensor info msg for sensor `%s'.\n",
- (char *)&sbm[1]);
+ (char *) &sbm[1]);
return GNUNET_SYSERR;
}
- queue_msg ((struct GNUNET_MessageHeader *)sfm, cp);
+ queue_msg ((struct GNUNET_MessageHeader *) sfm, cp);
GNUNET_CADET_receive_done (channel);
return GNUNET_OK;
}
@@ -740,32 +721,30 @@
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
static const struct GNUNET_SERVER_MessageHandler handlers[] = {
- {NULL, NULL, 0, 0}
+ {NULL, NULL, 0, 0}
};
static struct GNUNET_CADET_MessageHandler cadet_handlers[] = {
- {&handle_sensor_reading,
- GNUNET_MESSAGE_TYPE_SENSOR_READING, 0},
- {&handle_sensor_list_req,
- GNUNET_MESSAGE_TYPE_SENSOR_LIST_REQ,
- sizeof (struct GNUNET_MessageHeader)},
- {&handle_sensor_full_req,
- GNUNET_MESSAGE_TYPE_SENSOR_FULL_REQ,
- sizeof (struct GNUNET_MessageHeader)},
- {NULL, 0, 0}
+ {&handle_sensor_reading,
+ GNUNET_MESSAGE_TYPE_SENSOR_READING, 0},
+ {&handle_sensor_list_req,
+ GNUNET_MESSAGE_TYPE_SENSOR_LIST_REQ,
+ sizeof (struct GNUNET_MessageHeader)},
+ {&handle_sensor_full_req,
+ GNUNET_MESSAGE_TYPE_SENSOR_FULL_REQ,
+ sizeof (struct GNUNET_MessageHeader)},
+ {NULL, 0, 0}
};
static uint32_t cadet_ports[] = {
- GNUNET_APPLICATION_TYPE_SENSORDASHBOARD,
- GNUNET_APPLICATION_TYPE_SENSORUPDATE,
- GNUNET_APPLICATION_TYPE_END
+ GNUNET_APPLICATION_TYPE_SENSORDASHBOARD,
+ GNUNET_APPLICATION_TYPE_SENSORUPDATE,
+ GNUNET_APPLICATION_TYPE_END
};
sensors = GNUNET_SENSOR_load_all_sensors ();
GNUNET_assert (NULL != sensors);
- cadet = GNUNET_CADET_connect(cfg,
- NULL,
- &cadet_channel_created,
- &cadet_channel_destroyed,
- cadet_handlers,
- cadet_ports);
+ cadet =
+ GNUNET_CADET_connect (cfg, NULL, &cadet_channel_created,
+ &cadet_channel_destroyed, cadet_handlers,
+ cadet_ports);
if (NULL == cadet)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
Modified: gnunet/src/sensordashboard/sensordashboard.h
===================================================================
--- gnunet/src/sensordashboard/sensordashboard.h 2014-07-29 13:06:05 UTC
(rev 34074)
+++ gnunet/src/sensordashboard/sensordashboard.h 2014-07-29 14:01:37 UTC
(rev 34075)
@@ -25,6 +25,4 @@
#include "gnunet_sensordashboard_service.h"
-GNUNET_NETWORK_STRUCT_BEGIN
-
-GNUNET_NETWORK_STRUCT_END
+GNUNET_NETWORK_STRUCT_BEGIN GNUNET_NETWORK_STRUCT_END
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [GNUnet-SVN] r34075 - in gnunet/src: include sensor sensordashboard,
gnunet <=