src/sensor/sensor_util_lib.c

   1 /*
   2      This file is part of GNUnet.
   3      (C)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file sensor/sensor_util_lib.c
  23  * @brief senor utilities
  24  * @author Omar Tarabai
  25  */
  26 #include <inttypes.h>
  27 #include "platform.h"
  28 #include "gnunet_util_lib.h"
  29 #include "gnunet_sensor_util_lib.h"
  30 #include "gnunet_statistics_service.h"
  31
  32 #define LOG(kind,...) GNUNET_log_from (kind, "sensor-util",__VA_ARGS__)
  33
  34 /**
  35  * Minimum sensor execution interval (in seconds)
  36  */
  37 #define MIN_INTERVAL 30
  38
  39 /**
  40  * Supported sources of sensor information
  41  */
  42 static const char *sources[] = { "gnunet-statistics", "process", NULL };
  43
  44 /**
  45  * Supported datatypes of sensor information
  46  */
  47 static const char *datatypes[] = { "numeric", "string", NULL };
  48
  49 /**
  50  * Parses a version number string into major and minor
  51  *
  52  * @param version full version string
  53  * @param major pointer to parsed major value
  54  * @param minor pointer to parsed minor value
  55  * @return #GNUNET_OK if parsing went ok, #GNUNET_SYSERROR in case of error
  56  */
  57 static int
  58 version_parse(char *version, uint16_t *major, uint16_t *minor)
  59 {
  60   int majorval = 0;
  61   int minorval = 0;
  62
  63   for(; isdigit(*version); version++)
  64   {
  65     majorval *= 10;
  66     majorval += *version - '0';
  67   }
  68   if(*version != '.')
  69     return GNUNET_SYSERR;
  70   version++;
  71   for(; isdigit(*version); version++)
  72   {
  73     minorval *= 10;
  74     minorval += *version - '0';
  75   }
  76   if(*version != 0)
  77     return GNUNET_SYSERR;
  78   *major = majorval;
  79   *minor = minorval;
  80
  81   return GNUNET_OK;
  82 }
  83
  84 /**
  85  * Load sensor definition from configuration
  86  *
  87  * @param cfg configuration handle
  88  * @param sectionname configuration section containing definition
  89  */
  90 static struct SensorInfo *
  91 load_sensor_from_cfg(struct GNUNET_CONFIGURATION_Handle *cfg, const char *sectionname)
  92 {
  93   struct SensorInfo *sensor;
  94   char *version_str;
  95   char *starttime_str;
  96   char *endtime_str;
  97   unsigned long long time_sec;
  98   char *dummy;
  99   struct GNUNET_CRYPTO_EddsaPublicKey public_key;
 100
 101   sensor = GNUNET_new(struct SensorInfo);
 102   //name
 103   sensor->name = GNUNET_strdup(sectionname);
 104   //version
 105   if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, sectionname, "VERSION", &version_str))
 106   {
 107     LOG (GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor version\n"));
 108     GNUNET_free(sensor);
 109     return NULL;
 110   }
 111   if(GNUNET_OK != version_parse(version_str, &(sensor->version_major), &(sensor->version_minor)))
 112   {
 113     LOG (GNUNET_ERROR_TYPE_ERROR, _("Invalid sensor version number, format should be major.minor\n"));
 114     GNUNET_free(sensor);
 115     GNUNET_free(version_str);
 116     return NULL;
 117   }
 118   GNUNET_free(version_str);
 119   //description
 120   GNUNET_CONFIGURATION_get_value_string(cfg, sectionname, "DESCRIPTION", &sensor->description);
 121   //category
 122   if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, sectionname, "CATEGORY", &sensor->category) ||
 123         NULL == sensor->category)
 124   {
 125     LOG (GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor category\n"));
 126     GNUNET_free(sensor);
 127     return NULL;
 128   }
 129   //enabled
 130   if(GNUNET_NO == GNUNET_CONFIGURATION_get_value_yesno(cfg, sectionname, "ENABLED"))
 131     sensor->enabled = GNUNET_NO;
 132   else
 133     sensor->enabled = GNUNET_YES;
 134   //start time
 135   sensor->start_time = NULL;
 136   if(GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, sectionname, "START_TIME", &starttime_str))
 137   {
 138     GNUNET_STRINGS_fancy_time_to_absolute(starttime_str, sensor->start_time);
 139     LOG (GNUNET_ERROR_TYPE_DEBUG, "Start time loaded: `%s'. Parsed: %d\n", starttime_str, (NULL != sensor->start_time));
 140     GNUNET_free(starttime_str);
 141   }
 142   //end time
 143   sensor->end_time = NULL;
 144   if(GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, sectionname, "END_TIME", &endtime_str))
 145   {
 146     GNUNET_STRINGS_fancy_time_to_absolute(endtime_str, sensor->end_time);
 147     LOG (GNUNET_ERROR_TYPE_DEBUG, "End time loaded: `%s'. Parsed: %d\n", endtime_str, (NULL != sensor->end_time));
 148     GNUNET_free(endtime_str);
 149   }
 150   //interval
 151   if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg, sectionname, "INTERVAL", &time_sec))
 152   {
 153     LOG (GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor run interval\n"));
 154     GNUNET_free(sensor);
 155     return NULL;
 156   }
 157   if(time_sec < MIN_INTERVAL)
 158   {
 159     LOG (GNUNET_ERROR_TYPE_ERROR, _("Sensor run interval too low (%" PRIu64 " < %d)\n"),
 160         time_sec, MIN_INTERVAL);
 161     GNUNET_free(sensor);
 162     return NULL;
 163   }
 164   sensor->interval = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, time_sec);
 165   //lifetime
 166   if(GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, sectionname, "LIFETIME", &time_sec))
 167   {
 168     sensor->lifetime = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, time_sec);
 169     if (sensor->lifetime.rel_value_us < sensor->interval.rel_value_us)
 170       LOG  (GNUNET_ERROR_TYPE_WARNING,
 171           "Lifetime of sensor data is preferred to be higher than interval for sensor `%s'.\n",
 172           sensor->name);
 173   }
 174   else
 175     sensor->lifetime = sensor->interval;
 176   //capabilities TODO
 177   //source
 178   if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_choice(cfg, sectionname, "SOURCE", sources, (const char **)&sensor->source))
 179   {
 180     LOG (GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor source\n"));
 181     GNUNET_free(sensor);
 182     return NULL;
 183   }
 184   if(sources[0] == sensor->source) //gnunet-statistics
 185   {
 186     if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, sectionname, "GNUNET_STAT_SERVICE", &sensor->gnunet_stat_service) ||
 187         GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, sectionname, "GNUNET_STAT_NAME", &sensor->gnunet_stat_name))
 188     {
 189       LOG (GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor gnunet-statistics source information\n"));
 190       GNUNET_free(sensor);
 191       return NULL;
 192     }
 193     sensor->gnunet_stat_get_handle = NULL;
 194   }
 195   else if(sources[1] == sensor->source) //process
 196   {
 197     if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, sectionname, "EXT_PROCESS", &sensor->ext_process))
 198     {
 199       LOG (GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor process name\n"));
 200       GNUNET_free(sensor);
 201       return NULL;
 202     }
 203     GNUNET_CONFIGURATION_get_value_string(cfg, sectionname, "EXT_ARGS", &sensor->ext_args);
 204   }
 205   //expected datatype
 206   if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_choice(cfg, sectionname, "EXPECTED_DATATYPE", datatypes, (const char **)&sensor->expected_datatype))
 207   {
 208     LOG (GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor expected datatype\n"));
 209     GNUNET_free(sensor);
 210     return NULL;
 211   }
 212   if(sources[0] == sensor->source && datatypes[0] != sensor->expected_datatype)
 213   {
 214     LOG (GNUNET_ERROR_TYPE_ERROR, _("Invalid expected datatype, gnunet-statistics returns uint64 values\n"));
 215     GNUNET_free(sensor);
 216     return NULL;
 217   }
 218   //reporting mechanism
 219   sensor->collection_point = NULL;
 220   if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, sectionname, "COLLECTION_POINT", &dummy))
 221   {
 222     if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg, sectionname, "COLLECTION_INTERVAL", &time_sec))
 223     {
 224       LOG (GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor collection interval\n"));
 225     }
 226     else
 227     {
 228       sensor->collection_interval = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, time_sec);
 229       if (GNUNET_OK == GNUNET_CRYPTO_eddsa_public_key_from_string(dummy, strlen(dummy), &public_key))
 230       {
 231         sensor->collection_point = GNUNET_new(struct GNUNET_PeerIdentity);
 232         sensor->collection_point->public_key = public_key;
 233       }
 234     }
 235     GNUNET_free (dummy);
 236   }
 237   sensor->p2p_report = GNUNET_NO;
 238   if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno(cfg, sectionname, "P2P_REPORT"))
 239   {
 240     if(GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg, sectionname, "P2P_INTERVAL", &time_sec))
 241     {
 242       LOG (GNUNET_ERROR_TYPE_ERROR, _("Error reading sensor p2p reporting interval\n"));
 243     }
 244     else
 245     {
 246       sensor->p2p_interval = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, time_sec);
 247       sensor->p2p_report = GNUNET_YES;
 248     }
 249   }
 250   //execution task
 251   sensor->execution_task = GNUNET_SCHEDULER_NO_TASK;
 252   //running
 253   sensor->running = GNUNET_NO;
 254
 255   return sensor;
 256 }
 257
 258 /**
 259  * Load sensor definition from file
 260  *
 261  * @param filename full path to file containing sensor definition
 262  */
 263 static struct SensorInfo *
 264 load_sensor_from_file(const char *filename)
 265 {
 266   struct GNUNET_CONFIGURATION_Handle *sensorcfg;
 267   const char *filebasename;
 268   struct SensorInfo *sensor;
 269
 270   //test file
 271   if(GNUNET_YES != GNUNET_DISK_file_test(filename))
 272   {
 273     LOG (GNUNET_ERROR_TYPE_ERROR, _("Failed to access sensor file: %s\n"), filename);
 274     return NULL;
 275   }
 276   //load file as configuration
 277   sensorcfg = GNUNET_CONFIGURATION_create();
 278   if(GNUNET_SYSERR == GNUNET_CONFIGURATION_parse(sensorcfg, filename))
 279   {
 280     GNUNET_CONFIGURATION_destroy(sensorcfg);
 281     LOG (GNUNET_ERROR_TYPE_ERROR, _("Failed to load sensor definition: %s\n"), filename);
 282     return NULL;
 283   }
 284   //configuration section should be the same as filename
 285   filebasename = GNUNET_STRINGS_get_short_name(filename);
 286   sensor = load_sensor_from_cfg(sensorcfg, filebasename);
 287   if(NULL == sensor)
 288   {
 289     GNUNET_CONFIGURATION_destroy(sensorcfg);
 290     return NULL;
 291   }
 292   sensor->def_file = GNUNET_strdup(filename);
 293   sensor->cfg = sensorcfg;
 294
 295   return sensor;
 296 }
 297
 298 /**
 299  * Compares version numbers of two sensors
 300  *
 301  * @param s1 first sensor
 302  * @param s2 second sensor
 303  * @return 1: s1 > s2, 0: s1 == s2, -1: s1 < s2
 304  */
 305 static int
 306 sensor_version_compare(struct SensorInfo *s1, struct SensorInfo *s2)
 307 {
 308   if(s1->version_major == s2->version_major)
 309     return (s1->version_minor < s2->version_minor) ? -1 : (s1->version_minor > s2->version_minor);
 310   else
 311     return (s1->version_major < s2->version_major) ? -1 : (s1->version_major > s2->version_major);
 312 }
 313
 314 /**
 315  * Adds a new sensor to given hashmap.
 316  * If the same name exist, compares versions and update if old.
 317  *
 318  * @param sensor Sensor structure to add
 319  * @param map Hashmap to add to
 320  * @return #GNUNET_YES if added, #GNUNET_NO if not added which is not necessarily an error
 321  */
 322 static int
 323 add_sensor_to_hashmap(struct SensorInfo *sensor, struct GNUNET_CONTAINER_MultiHashMap *map)
 324 {
 325   struct GNUNET_HashCode key;
 326   struct SensorInfo *existing;
 327
 328   GNUNET_CRYPTO_hash(sensor->name, strlen(sensor->name) + 1, &key);
 329   existing = GNUNET_CONTAINER_multihashmap_get(map, &key);
 330   if(NULL != existing) //sensor with same name already exists
 331   {
 332     if(sensor_version_compare(existing, sensor) >= 0) //same or newer version already exist
 333     {
 334       LOG (GNUNET_ERROR_TYPE_INFO, _("Sensor `%s' already exists with same or newer version\n"), sensor->name);
 335       return GNUNET_NO;
 336     }
 337     else
 338     {
 339       GNUNET_CONTAINER_multihashmap_remove(map, &key, existing); //remove the old version
 340       GNUNET_free(existing);
 341       LOG (GNUNET_ERROR_TYPE_INFO, "Upgrading sensor `%s' to a newer version\n", sensor->name);
 342     }
 343   }
 344   if(GNUNET_SYSERR == GNUNET_CONTAINER_multihashmap_put(map, &key, sensor, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
 345   {
 346     LOG (GNUNET_ERROR_TYPE_ERROR, _("Error adding new sensor `%s' to global hashmap, this should not happen\n"), sensor->name);
 347     return GNUNET_NO;
 348   }
 349
 350   return GNUNET_YES;
 351 }
 352
 353 /**
 354  * Iterating over files in sensors directory
 355  *
 356  * @param cls closure
 357  * @param filename complete filename (absolute path)
 358  * @return #GNUNET_OK to continue to iterate
 359  */
 360 static int
 361 reload_sensors_dir_cb(void *cls, const char *filename)
 362 {
 363   struct GNUNET_CONTAINER_MultiHashMap *sensors = cls;
 364   struct SensorInfo *sensor;
 365
 366   if(GNUNET_YES != GNUNET_DISK_file_test(filename))
 367     return GNUNET_OK;
 368   sensor = load_sensor_from_file(filename);
 369   if(NULL == sensor)
 370   {
 371     LOG (GNUNET_ERROR_TYPE_ERROR,
 372         _("Error loading sensor from file: %s\n"), filename);
 373     return GNUNET_OK;
 374   }
 375   if(GNUNET_YES != add_sensor_to_hashmap(sensor, sensors))
 376     LOG (GNUNET_ERROR_TYPE_WARNING,
 377         "Could not add sensor `%s' to global hashmap\n", sensor->name);
 378
 379   return GNUNET_OK;
 380 }
 381
 382 /*
 383  * Get path to the directory containing the sensor definition files
 384  *
 385  * @return sensor files directory
 386  */
 387 char *
 388 GNUNET_SENSOR_get_sensor_dir ()
 389 {
 390   char* datadir;
 391   char* sensordir;
 392
 393   datadir = GNUNET_OS_installation_get_path(GNUNET_OS_IPK_DATADIR);
 394   GNUNET_asprintf(&sensordir, "%ssensors%s",
 395       datadir, DIR_SEPARATOR_STR);
 396   GNUNET_free(datadir);
 397
 398   return sensordir;
 399 }
 400
 401 /**
 402  * Reads sensor definitions from local data files
 403  *
 404  * @return a multihashmap of loaded sensors
 405  */
 406 struct GNUNET_CONTAINER_MultiHashMap *
 407 GNUNET_SENSOR_load_all_sensors ()
 408 {
 409   char* sensordir;
 410   struct GNUNET_CONTAINER_MultiHashMap *sensors;
 411
 412   sensors = GNUNET_CONTAINER_multihashmap_create(10, GNUNET_NO);
 413   sensordir = GNUNET_SENSOR_get_sensor_dir ();
 414   LOG (GNUNET_ERROR_TYPE_INFO,
 415       "Loading sensor definitions from directory `%s'\n", sensordir);
 416   GNUNET_assert(GNUNET_YES == GNUNET_DISK_directory_test(sensordir, GNUNET_YES));
 417
 418   //read all files in sensors directory
 419   GNUNET_DISK_directory_scan(sensordir, &reload_sensors_dir_cb, sensors);
 420   LOG (GNUNET_ERROR_TYPE_INFO, "Loaded %d sensors from directory `%s'\n",
 421       GNUNET_CONTAINER_multihashmap_size(sensors), sensordir);
 422   GNUNET_free(sensordir);
 423   return sensors;
 424 }
 425
 426 /**
 427  * Parses a sensor reading message struct
 428  *
 429  * @param msg message header received
 430  * @param sensors multihashmap of loaded sensors
 431  * @return sensor reading struct or NULL if error
 432  */
 433 struct GNUNET_SENSOR_Reading *
 434 GNUNET_SENSOR_parse_reading_message (const struct GNUNET_MessageHeader *msg,
 435     struct GNUNET_CONTAINER_MultiHashMap *sensors)
 436 {
 437   uint16_t msg_size;
 438   struct GNUNET_SENSOR_ReadingMessage *rm;
 439   uint16_t sensorname_size;
 440   uint16_t value_size;
 441   void *dummy;
 442   char *sensorname;
 443   struct GNUNET_HashCode key;
 444   struct SensorInfo *sensor;
 445   struct GNUNET_SENSOR_Reading *reading;
 446
 447   msg_size = ntohs (msg->size);
 448   if (msg_size < sizeof (struct GNUNET_SENSOR_ReadingMessage))
 449   {
 450     LOG (GNUNET_ERROR_TYPE_WARNING, "Invalid reading message size.\n");
 451     return NULL;
 452   }
 453   rm = (struct GNUNET_SENSOR_ReadingMessage *)msg;
 454   sensorname_size = ntohs (rm->sensorname_size);
 455   value_size = ntohs (rm->value_size);
 456   if ((sizeof (struct GNUNET_SENSOR_ReadingMessage)
 457       + sensorname_size + value_size) != msg_size)
 458   {
 459     LOG (GNUNET_ERROR_TYPE_WARNING, "Invalid reading message size.\n");
 460     return NULL;
 461   }
 462   dummy = &rm[1];
 463   sensorname = GNUNET_malloc (sensorname_size);
 464   memcpy (sensorname, dummy, sensorname_size);
 465   GNUNET_CRYPTO_hash(sensorname, sensorname_size, &key);
 466   GNUNET_free (sensorname);
 467   sensor = GNUNET_CONTAINER_multihashmap_get (sensors, &key);
 468   if (NULL == sensor)
 469   {
 470     LOG (GNUNET_ERROR_TYPE_WARNING,
 471         "Unknown sensor name in reading message.\n");
 472     return NULL;
 473   }
 474   if ((sensor->version_minor != ntohs (rm->sensorversion_minor)) ||
 475       (sensor->version_major != ntohs (rm->sensorversion_major)))
 476   {
 477     LOG (GNUNET_ERROR_TYPE_WARNING,
 478         "Sensor version mismatch in reading message.\n");
 479     return NULL;
 480   }
 481   if (0 == strcmp (sensor->expected_datatype, "numeric") &&
 482       sizeof (double) != value_size)
 483   {
 484     LOG (GNUNET_ERROR_TYPE_WARNING,
 485         "Invalid value size for a numerical sensor.\n");
 486     return NULL;
 487   }
 488   reading = GNUNET_new (struct GNUNET_SENSOR_Reading);
 489   reading->sensor = sensor;
 490   reading->timestamp = GNUNET_be64toh (rm->timestamp);
 491   reading->value_size = value_size;
 492   reading->value = GNUNET_malloc (value_size);
 493   dummy += sensorname_size;
 494   memcpy (reading->value, dummy, value_size);
 495   return reading;
 496 }
 497
 498 /**
 499  * Remove sensor execution from scheduler
 500  *
 501  * @param cls unused
 502  * @param key hash of sensor name, key to hashmap
 503  * @param value a 'struct SensorInfo *'
 504  * @return #GNUNET_YES if we should continue to
 505  *         iterate,
 506  *         #GNUNET_NO if not.
 507  */
 508 static int destroy_sensor(void *cls,
 509     const struct GNUNET_HashCode *key, void *value)
 510 {
 511   struct SensorInfo *sensorinfo = value;
 512
 513   if(GNUNET_SCHEDULER_NO_TASK != sensorinfo->execution_task)
 514   {
 515     GNUNET_SCHEDULER_cancel(sensorinfo->execution_task);
 516     sensorinfo->execution_task = GNUNET_SCHEDULER_NO_TASK;
 517   }
 518   if(NULL != sensorinfo->gnunet_stat_get_handle)
 519   {
 520     GNUNET_STATISTICS_get_cancel(sensorinfo->gnunet_stat_get_handle);
 521     sensorinfo->gnunet_stat_get_handle = NULL;
 522   }
 523   if(NULL != sensorinfo->ext_cmd)
 524   {
 525     GNUNET_OS_command_stop(sensorinfo->ext_cmd);
 526     sensorinfo->ext_cmd = NULL;
 527   }
 528   if(NULL != sensorinfo->cfg)
 529     GNUNET_CONFIGURATION_destroy(sensorinfo->cfg);
 530   if(NULL != sensorinfo->name)
 531     GNUNET_free(sensorinfo->name);
 532   if(NULL != sensorinfo->def_file)
 533     GNUNET_free(sensorinfo->def_file);
 534   if(NULL != sensorinfo->description)
 535     GNUNET_free(sensorinfo->description);
 536   if(NULL != sensorinfo->category)
 537     GNUNET_free(sensorinfo->category);
 538   if(NULL != sensorinfo->capabilities)
 539     GNUNET_free(sensorinfo->capabilities);
 540   if(NULL != sensorinfo->gnunet_stat_service)
 541     GNUNET_free(sensorinfo->gnunet_stat_service);
 542   if(NULL != sensorinfo->gnunet_stat_name)
 543     GNUNET_free(sensorinfo->gnunet_stat_name);
 544   if(NULL != sensorinfo->ext_process)
 545     GNUNET_free(sensorinfo->ext_process);
 546   if(NULL != sensorinfo->ext_args)
 547     GNUNET_free(sensorinfo->ext_args);
 548   if (NULL != sensorinfo->collection_point)
 549     GNUNET_free (sensorinfo->collection_point);
 550   GNUNET_free(sensorinfo);
 551   return GNUNET_YES;
 552 }
 553
 554 /**
 555  * Destroys a group of sensors in a hashmap and the hashmap itself
 556  *
 557  * @param sensors hashmap containing the sensors
 558  */
 559 void
 560 GNUNET_SENSOR_destroy_sensors (struct GNUNET_CONTAINER_MultiHashMap *sensors)
 561 {
 562   LOG (GNUNET_ERROR_TYPE_DEBUG, "Destroying sensor list.\n");
 563   GNUNET_CONTAINER_multihashmap_iterate(sensors, &destroy_sensor, NULL);
 564   GNUNET_CONTAINER_multihashmap_destroy(sensors);
 565 }
 566