2 This file is part of GNUnet.
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.
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.
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.
22 * @file sensor/gnunet-service-sensor_reporting.c
23 * @brief sensor service reporting functionality
24 * @author Omar Tarabai
27 #include "gnunet_util_lib.h"
29 #include "gnunet_peerstore_service.h"
30 #include "gnunet_core_service.h"
31 #include "gnunet_cadet_service.h"
32 #include "gnunet_applications.h"
34 #define LOG(kind,...) GNUNET_log_from (kind, "sensor-reporting",__VA_ARGS__)
43 struct AnomalyInfo *prev;
48 struct AnomalyInfo *next;
53 struct GNUNET_SENSOR_SensorInfo *sensor;
56 * Current anomalous status of sensor
61 * List of peers that reported an anomaly for this sensor
63 struct GNUNET_CONTAINER_MultiPeerMap *anomalous_neighbors;
73 struct ValueInfo *prev;
78 struct ValueInfo *next;
83 struct GNUNET_SENSOR_SensorInfo *sensor;
86 * Last value read from sensor
91 * Size of @e last_value
93 size_t last_value_size;
96 * Timestamp of last value reading
98 struct GNUNET_TIME_Absolute last_value_timestamp;
101 * Has the last value seen already been reported to collection point?
103 int last_value_reported;
106 * Watcher of sensor values
108 struct GNUNET_PEERSTORE_WatchContext *wc;
111 * Collection point reporting task (or #GNUNET_SCHEDULER_NO_TASK)
113 GNUNET_SCHEDULER_TaskIdentifier reporting_task;
118 * Information about a connected CORE peer.
119 * Note that we only know about a connected peer if it is running the same
120 * application (sensor anomaly reporting) as us.
128 struct CorePeer *prev;
133 struct CorePeer *next;
136 * Peer identity of connected peer
138 struct GNUNET_PeerIdentity *peer_id;
141 * Message queue for messages to be sent to this peer
143 struct GNUNET_MQ_Handle *mq;
148 * Information about a connected CADET peer (collection point).
156 struct CadetPeer *prev;
161 struct CadetPeer *next;
166 struct GNUNET_PeerIdentity peer_id;
169 * CADET channel handle
171 struct GNUNET_CADET_Channel *channel;
174 * Message queue for messages to be sent to this peer
176 struct GNUNET_MQ_Handle *mq;
179 * Are we currently destroying the channel and its context?
189 static const struct GNUNET_CONFIGURATION_Handle *cfg;
192 * Multihashmap of loaded sensors
194 static struct GNUNET_CONTAINER_MultiHashMap *sensors;
197 * Handle to peerstore service
199 static struct GNUNET_PEERSTORE_Handle *peerstore;
202 * Handle to core service
204 static struct GNUNET_CORE_Handle *core;
207 * Handle to CADET service
209 static struct GNUNET_CADET_Handle *cadet;
214 static struct GNUNET_PeerIdentity mypeerid;
217 * Head of DLL of anomaly info structs
219 static struct AnomalyInfo *ai_head;
222 * Tail of DLL of anomaly info structs
224 static struct AnomalyInfo *ai_tail;
227 * Head of DLL of value info structs
229 static struct ValueInfo *vi_head;
232 * Tail of DLL of value info structs
234 static struct ValueInfo *vi_tail;
237 * Head of DLL of CORE peers
239 static struct CorePeer *corep_head;
242 * Tail of DLL of CORE peers
244 static struct CorePeer *corep_tail;
247 * Head of DLL of CADET peers
249 static struct CadetPeer *cadetp_head;
252 * Tail of DLL of CADET peers
254 static struct CadetPeer *cadetp_tail;
257 * Is the module started?
259 static int module_running = GNUNET_NO;
262 * Number of known neighborhood peers
264 static int neighborhood;
268 /******************************************************************************/
269 /****************************** CLEANUP ******************************/
270 /******************************************************************************/
273 * Destroy anomaly info struct
275 * @param ai struct to destroy
278 destroy_anomaly_info (struct AnomalyInfo *ai)
280 if (NULL != ai->anomalous_neighbors)
281 GNUNET_CONTAINER_multipeermap_destroy (ai->anomalous_neighbors);
287 * Destroy value info struct
289 * @param vi struct to destroy
292 destroy_value_info (struct ValueInfo *vi)
296 GNUNET_PEERSTORE_watch_cancel (vi->wc);
299 if (GNUNET_SCHEDULER_NO_TASK != vi->reporting_task)
301 GNUNET_SCHEDULER_cancel (vi->reporting_task);
302 vi->reporting_task = GNUNET_SCHEDULER_NO_TASK;
304 if (NULL != vi->last_value)
306 GNUNET_free (vi->last_value);
307 vi->last_value = NULL;
314 * Destroy core peer struct
316 * @param corep struct to destroy
319 destroy_core_peer (struct CorePeer *corep)
321 struct AnomalyInfo *ai;
323 if (NULL != corep->mq)
325 GNUNET_MQ_destroy (corep->mq);
331 GNUNET_assert (NULL != ai->anomalous_neighbors);
332 GNUNET_CONTAINER_multipeermap_remove_all (ai->anomalous_neighbors,
341 * Destroy cadet peer struct
343 * @param cadetp struct to destroy
346 destroy_cadet_peer (struct CadetPeer *cadetp)
348 cadetp->destroying = GNUNET_YES;
349 if (NULL != cadetp->mq)
351 GNUNET_MQ_destroy (cadetp->mq);
354 if (NULL != cadetp->channel)
356 GNUNET_CADET_channel_destroy (cadetp->channel);
357 cadetp->channel = NULL;
359 GNUNET_free (cadetp);
364 * Stop sensor reporting module
367 SENSOR_reporting_stop ()
369 struct ValueInfo *vi;
370 struct CorePeer *corep;
371 struct AnomalyInfo *ai;
372 struct CadetPeer *cadetp;
374 LOG (GNUNET_ERROR_TYPE_DEBUG, "Stopping sensor anomaly reporting module.\n");
375 module_running = GNUNET_NO;
377 /* Destroy value info's */
381 GNUNET_CONTAINER_DLL_remove (vi_head, vi_tail, vi);
382 destroy_value_info (vi);
385 /* Destroy core peers */
387 while (NULL != corep)
389 GNUNET_CONTAINER_DLL_remove (corep_head, corep_tail, corep);
390 destroy_core_peer (corep);
393 /* Destroy anomaly info's */
397 GNUNET_CONTAINER_DLL_remove (ai_head, ai_tail, ai);
398 destroy_anomaly_info (ai);
401 /* Destroy cadet peers */
402 cadetp = cadetp_head;
403 while (NULL != cadetp)
405 GNUNET_CONTAINER_DLL_remove (cadetp_head, cadetp_tail, cadetp);
406 destroy_cadet_peer (cadetp);
407 cadetp = cadetp_head;
409 /* Disconnect from other services */
412 GNUNET_CORE_disconnect (core);
415 if (NULL != peerstore)
417 GNUNET_PEERSTORE_disconnect (peerstore, GNUNET_NO);
422 GNUNET_CADET_disconnect (cadet);
428 /******************************************************************************/
429 /****************************** HELPERS ******************************/
430 /******************************************************************************/
434 * Gets the anomaly info struct related to the given sensor
436 * @param sensor Sensor to search by
438 static struct AnomalyInfo *
439 get_anomaly_info_by_sensor (struct GNUNET_SENSOR_SensorInfo *sensor)
441 struct AnomalyInfo *ai;
446 if (ai->sensor == sensor)
457 * Returns context of a connected CADET peer.
458 * Creates it first if didn't exist before.
460 * @param pid Peer Identity
461 * @return Context of connected CADET peer
463 static struct CadetPeer *
464 get_cadet_peer (struct GNUNET_PeerIdentity pid)
466 struct CadetPeer *cadetp;
468 cadetp = cadetp_head;
469 while (NULL != cadetp)
471 if (0 == GNUNET_CRYPTO_cmp_peer_identity (&pid, &cadetp->peer_id))
473 cadetp = cadetp->next;
475 LOG (GNUNET_ERROR_TYPE_DEBUG, "Creating a CADET connection to peer `%s'.\n",
477 /* Not found, create struct and channel */
478 cadetp = GNUNET_new (struct CadetPeer);
479 cadetp->peer_id = pid;
481 GNUNET_CADET_channel_create (cadet, cadetp, &pid,
482 GNUNET_APPLICATION_TYPE_SENSORDASHBOARD,
483 GNUNET_CADET_OPTION_RELIABLE);
484 cadetp->mq = GNUNET_CADET_mq_create (cadetp->channel);
485 GNUNET_CONTAINER_DLL_insert (cadetp_head, cadetp_tail, cadetp);
491 * Create an anomaly report message from a given anomaly info struct inside a
494 * @param ai Anomaly info struct to use
495 * @param type Message type
496 * @return Envelope with message
498 static struct GNUNET_MQ_Envelope *
499 create_anomaly_report_message (struct AnomalyInfo *ai, int type)
501 struct GNUNET_SENSOR_AnomalyReportMessage *arm;
502 struct GNUNET_MQ_Envelope *ev;
504 ev = GNUNET_MQ_msg (arm, type);
505 GNUNET_CRYPTO_hash (ai->sensor->name, strlen (ai->sensor->name) + 1,
506 &arm->sensorname_hash);
507 arm->sensorversion_major = htons (ai->sensor->version_major);
508 arm->sensorversion_minor = htons (ai->sensor->version_minor);
509 arm->anomalous = htons (ai->anomalous);
510 arm->anomalous_neighbors =
512 neighborhood) ? 0 : ((float)
513 GNUNET_CONTAINER_multipeermap_size
514 (ai->anomalous_neighbors)) / neighborhood;
520 * Create a sensor value message from a given value info struct inside a MQ
523 * @param vi Value info struct to use
524 * @return Envelope with message
526 static struct GNUNET_MQ_Envelope *
527 create_value_message (struct ValueInfo *vi)
529 struct GNUNET_SENSOR_ValueMessage *vm;
530 struct GNUNET_MQ_Envelope *ev;
532 ev = GNUNET_MQ_msg_extra (vm, vi->last_value_size,
533 GNUNET_MESSAGE_TYPE_SENSOR_READING);
534 GNUNET_CRYPTO_hash (vi->sensor->name, strlen (vi->sensor->name) + 1,
535 &vm->sensorname_hash);
536 vm->sensorversion_major = htons (vi->sensor->version_major);
537 vm->sensorversion_minor = htons (vi->sensor->version_minor);
538 vm->timestamp = vi->last_value_timestamp;
539 vm->value_size = htons (vi->last_value_size);
540 memcpy (&vm[1], vi->last_value, vi->last_value_size);
546 * Send given anomaly info report by putting it in the given message queue.
548 * @param mq Message queue to put the message in
549 * @param ai Anomaly info to report
550 * @param p2p Is the report sent to a neighboring peer
553 send_anomaly_report (struct GNUNET_MQ_Handle *mq, struct AnomalyInfo *ai,
556 struct GNUNET_MQ_Envelope *ev;
561 p2p) ? GNUNET_MESSAGE_TYPE_SENSOR_ANOMALY_REPORT_P2P :
562 GNUNET_MESSAGE_TYPE_SENSOR_ANOMALY_REPORT;
563 ev = create_anomaly_report_message (ai, type);
564 GNUNET_MQ_send (mq, ev);
568 /******************************************************************************/
569 /*************************** CORE Handlers ***************************/
570 /******************************************************************************/
574 * An inbound anomaly report is received from a peer through CORE.
576 * @param cls closure (unused)
577 * @param peer the other peer involved
578 * @param message the actual message
579 * @return #GNUNET_OK to keep the connection open,
580 * #GNUNET_SYSERR to close connection to the peer (signal serious error)
583 handle_anomaly_report (void *cls, const struct GNUNET_PeerIdentity *other,
584 const struct GNUNET_MessageHeader *message)
586 struct GNUNET_SENSOR_AnomalyReportMessage *arm;
587 struct GNUNET_SENSOR_SensorInfo *sensor;
588 struct AnomalyInfo *my_anomaly_info;
589 struct CadetPeer *cadetp;
591 int peer_in_anomalous_list;
593 arm = (struct GNUNET_SENSOR_AnomalyReportMessage *) message;
594 sensor = GNUNET_CONTAINER_multihashmap_get (sensors, &arm->sensorname_hash);
595 if (NULL == sensor ||
596 sensor->version_major != ntohs (arm->sensorversion_major) ||
597 sensor->version_minor != ntohs (arm->sensorversion_minor))
599 LOG (GNUNET_ERROR_TYPE_WARNING,
600 "I don't have the sensor reported by the peer `%s'.\n",
604 my_anomaly_info = get_anomaly_info_by_sensor (sensor);
605 GNUNET_assert (NULL != my_anomaly_info);
606 peer_in_anomalous_list =
607 GNUNET_CONTAINER_multipeermap_contains
608 (my_anomaly_info->anomalous_neighbors, other);
609 peer_anomalous = ntohs (arm->anomalous);
610 LOG (GNUNET_ERROR_TYPE_DEBUG,
611 "Received an anomaly update from neighbour `%s' (%d).\n",
612 GNUNET_i2s (other), peer_anomalous);
613 if (GNUNET_YES == peer_anomalous)
615 if (GNUNET_YES == peer_in_anomalous_list) /* repeated positive report */
618 GNUNET_CONTAINER_multipeermap_put (my_anomaly_info->anomalous_neighbors,
620 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
624 if (GNUNET_NO == peer_in_anomalous_list) /* repeated negative report */
627 GNUNET_CONTAINER_multipeermap_remove_all
628 (my_anomaly_info->anomalous_neighbors, other);
630 /* Send anomaly update to collection point only if I have the same anomaly */
631 if (GNUNET_YES == my_anomaly_info->anomalous &&
632 NULL != sensor->collection_point &&
633 GNUNET_YES == sensor->report_anomalies)
635 LOG (GNUNET_ERROR_TYPE_DEBUG,
636 "Neighbor update triggered sending anomaly report to collection point `%s'.\n",
637 GNUNET_i2s (sensor->collection_point));
638 cadetp = get_cadet_peer (*sensor->collection_point);
639 send_anomaly_report (cadetp->mq, my_anomaly_info, GNUNET_NO);
645 /******************************************************************************/
646 /************************ PEERSTORE callbacks ************************/
647 /******************************************************************************/
651 * Sensor value watch callback
653 * @param cls Closure, ValueInfo struct related to the sensor we are watching
654 * @param record PEERSTORE new record, NULL if error
655 * @param emsg Error message, NULL if no error
656 * @return GNUNET_YES to continue watching
659 value_watch_cb (void *cls, struct GNUNET_PEERSTORE_Record *record, char *emsg)
661 struct ValueInfo *vi = cls;
665 LOG (GNUNET_ERROR_TYPE_ERROR, _("PEERSTORE error: %s.\n"), emsg);
668 if (NULL != vi->last_value)
670 GNUNET_free (vi->last_value);
671 vi->last_value_size = 0;
673 vi->last_value = GNUNET_memdup (record->value, record->value_size);
674 vi->last_value_size = record->value_size;
675 vi->last_value_timestamp = GNUNET_TIME_absolute_get ();
676 vi->last_value_reported = GNUNET_NO;
681 /******************************************************************************/
682 /************************** CORE callbacks ***************************/
683 /******************************************************************************/
687 * Method called whenever a CORE peer disconnects.
689 * @param cls closure (unused)
690 * @param peer peer identity this notification is about
693 core_disconnect_cb (void *cls, const struct GNUNET_PeerIdentity *peer)
695 struct CorePeer *corep;
697 if (0 == GNUNET_CRYPTO_cmp_peer_identity (&mypeerid, peer))
699 LOG (GNUNET_ERROR_TYPE_DEBUG, "Core peer `%s' disconnected.\n",
703 while (NULL != corep)
705 if (0 == GNUNET_CRYPTO_cmp_peer_identity (peer, corep->peer_id))
707 GNUNET_CONTAINER_DLL_remove (corep_head, corep_tail, corep);
708 destroy_core_peer (corep);
717 * Method called whenever a given peer connects through CORE.
719 * @param cls closure (unused)
720 * @param peer peer identity this notification is about
723 core_connect_cb (void *cls, const struct GNUNET_PeerIdentity *peer)
725 struct CorePeer *corep;
726 struct AnomalyInfo *ai;
728 if (0 == GNUNET_CRYPTO_cmp_peer_identity (&mypeerid, peer))
730 LOG (GNUNET_ERROR_TYPE_DEBUG, "Connected to core peer `%s'.\n",
733 corep = GNUNET_new (struct CorePeer);
734 corep->peer_id = (struct GNUNET_PeerIdentity *) peer;
735 corep->mq = GNUNET_CORE_mq_create (core, peer);
736 GNUNET_CONTAINER_DLL_insert (corep_head, corep_tail, corep);
737 /* Send any locally anomalous sensors to the new peer */
741 if (GNUNET_YES == ai->anomalous)
743 LOG (GNUNET_ERROR_TYPE_DEBUG,
744 "Updating newly connected neighbor `%s' with anomalous sensor.\n",
746 send_anomaly_report (corep->mq, ai, GNUNET_YES);
754 * Function called after #GNUNET_CORE_connect has succeeded (or failed
755 * for good). Note that the private key of the peer is intentionally
756 * not exposed here; if you need it, your process should try to read
757 * the private key file directly (which should work if you are
758 * authorized...). Implementations of this function must not call
759 * #GNUNET_CORE_disconnect (other than by scheduling a new task to
762 * @param cls closure (unused)
763 * @param my_identity ID of this peer, NULL if we failed
766 core_startup_cb (void *cls, const struct GNUNET_PeerIdentity *my_identity)
768 if (NULL == my_identity)
770 LOG (GNUNET_ERROR_TYPE_ERROR, _("Failed to connect to CORE service.\n"));
771 SENSOR_reporting_stop ();
774 if (0 != GNUNET_CRYPTO_cmp_peer_identity (&mypeerid, my_identity))
776 LOG (GNUNET_ERROR_TYPE_ERROR,
777 _("Peer identity received from CORE init doesn't match ours.\n"));
778 SENSOR_reporting_stop ();
784 /******************************************************************************/
785 /************************* CADET callbacks ***************************/
786 /******************************************************************************/
789 * Function called whenever a channel is destroyed. Should clean up
790 * any associated state.
792 * It must NOT call #GNUNET_CADET_channel_destroy on the channel.
794 * @param cls closure (set from #GNUNET_CADET_connect)
795 * @param channel connection to the other end (henceforth invalid)
796 * @param channel_ctx place where local state associated
797 * with the channel is stored
800 cadet_channel_destroyed (void *cls, const struct GNUNET_CADET_Channel *channel,
803 struct CadetPeer *cadetp = channel_ctx;
805 if (GNUNET_YES == cadetp->destroying)
807 LOG (GNUNET_ERROR_TYPE_DEBUG,
808 "CADET channel was destroyed by remote peer `%s' or failed to start.\n",
809 GNUNET_i2s (&cadetp->peer_id));
810 GNUNET_CONTAINER_DLL_remove (cadetp_head, cadetp_tail, cadetp);
811 cadetp->channel = NULL;
812 destroy_cadet_peer (cadetp);
816 /******************************************************************************/
817 /********************** Local anomaly receiver ***********************/
818 /******************************************************************************/
822 * Used by the analysis module to tell the reporting module about a change in
823 * the anomaly status of a sensor.
825 * @param sensor Related sensor
826 * @param anomalous The new sensor anomalous status
829 SENSOR_reporting_anomaly_update (struct GNUNET_SENSOR_SensorInfo *sensor,
832 struct AnomalyInfo *ai;
833 struct CorePeer *corep;
834 struct CadetPeer *cadetp;
836 if (GNUNET_NO == module_running)
838 LOG (GNUNET_ERROR_TYPE_DEBUG, "Received an external anomaly update.\n");
839 ai = get_anomaly_info_by_sensor (sensor);
840 GNUNET_assert (NULL != ai);
841 ai->anomalous = anomalous;
842 /* Report change to all neighbors */
844 while (NULL != corep)
846 LOG (GNUNET_ERROR_TYPE_DEBUG,
847 "Sending an anomaly report to neighbor `%s'.\n",
848 GNUNET_i2s (corep->peer_id));
849 send_anomaly_report (corep->mq, ai, GNUNET_YES);
852 /* Report change to collection point if need */
853 if (NULL != ai->sensor->collection_point &&
854 GNUNET_YES == ai->sensor->report_anomalies)
856 LOG (GNUNET_ERROR_TYPE_DEBUG,
857 "Local anomaly update triggered sending anomaly report to collection point `%s'.\n",
858 GNUNET_i2s (ai->sensor->collection_point));
859 cadetp = get_cadet_peer (*ai->sensor->collection_point);
860 send_anomaly_report (cadetp->mq, ai, GNUNET_NO);
865 /******************************************************************************/
866 /******************* Reporting values (periodic) *********************/
867 /******************************************************************************/
871 * Task scheduled to send values to collection point
873 * @param cls closure, a `struct ValueReportingContext *`
877 report_value (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
879 struct ValueInfo *vi = cls;
880 struct GNUNET_SENSOR_SensorInfo *sensor = vi->sensor;
881 struct CadetPeer *cadetp;
882 struct GNUNET_MQ_Envelope *ev;
885 GNUNET_SCHEDULER_add_delayed (sensor->value_reporting_interval,
887 if (0 == vi->last_value_size || GNUNET_YES == vi->last_value_reported)
889 LOG (GNUNET_ERROR_TYPE_WARNING,
890 "Did not receive a fresh value from `%s' to report.\n", sensor->name);
893 LOG (GNUNET_ERROR_TYPE_DEBUG,
894 "Now trying to report last seen value of `%s' to collection point.\n",
896 cadetp = get_cadet_peer (*sensor->collection_point);
897 ev = create_value_message (vi);
898 GNUNET_MQ_send (cadetp->mq, ev);
899 vi->last_value_reported = GNUNET_YES;
903 /******************************************************************************/
904 /******************************** INIT *******************************/
905 /******************************************************************************/
909 * Iterator for defined sensors and creates anomaly info context
913 * @param value a `struct GNUNET_SENSOR_SensorInfo *` with sensor information
914 * @return #GNUNET_YES to continue iterations
917 init_sensor_reporting (void *cls, const struct GNUNET_HashCode *key,
920 struct GNUNET_SENSOR_SensorInfo *sensor = value;
921 struct AnomalyInfo *ai;
922 struct ValueInfo *vi;
924 /* Create sensor anomaly info context */
925 ai = GNUNET_new (struct AnomalyInfo);
928 ai->anomalous = GNUNET_NO;
929 ai->anomalous_neighbors =
930 GNUNET_CONTAINER_multipeermap_create (10, GNUNET_NO);
931 GNUNET_CONTAINER_DLL_insert (ai_head, ai_tail, ai);
932 /* Create sensor value info context (if needed to be reported) */
933 if (NULL == sensor->collection_point || GNUNET_NO == sensor->report_values)
935 LOG (GNUNET_ERROR_TYPE_INFO,
936 "Reporting sensor `%s' values to collection point `%s' every %s.\n",
937 sensor->name, GNUNET_i2s_full (sensor->collection_point),
938 GNUNET_STRINGS_relative_time_to_string (sensor->value_reporting_interval,
940 vi = GNUNET_new (struct ValueInfo);
942 vi->last_value = NULL;
943 vi->last_value_size = 0;
944 vi->last_value_reported = GNUNET_NO;
946 GNUNET_PEERSTORE_watch (peerstore, "sensor", &mypeerid, sensor->name,
947 &value_watch_cb, vi);
949 GNUNET_SCHEDULER_add_delayed (sensor->value_reporting_interval,
951 GNUNET_CONTAINER_DLL_insert (vi_head, vi_tail, vi);
957 * Start the sensor anomaly reporting module
959 * @param c our service configuration
960 * @param s multihashmap of loaded sensors
961 * @return #GNUNET_OK if started successfully, #GNUNET_SYSERR otherwise
964 SENSOR_reporting_start (const struct GNUNET_CONFIGURATION_Handle *c,
965 struct GNUNET_CONTAINER_MultiHashMap *s)
967 static struct GNUNET_CORE_MessageHandler core_handlers[] = {
968 {&handle_anomaly_report, GNUNET_MESSAGE_TYPE_SENSOR_ANOMALY_REPORT_P2P,
969 sizeof (struct GNUNET_SENSOR_AnomalyReportMessage)},
972 static struct GNUNET_CADET_MessageHandler cadet_handlers[] = {
976 LOG (GNUNET_ERROR_TYPE_DEBUG, "Starting sensor reporting module.\n");
977 GNUNET_assert (NULL != s);
980 /* Connect to PEERSTORE */
981 peerstore = GNUNET_PEERSTORE_connect (cfg);
982 if (NULL == peerstore)
984 LOG (GNUNET_ERROR_TYPE_ERROR,
985 _("Failed to connect to peerstore service.\n"));
986 SENSOR_reporting_stop ();
987 return GNUNET_SYSERR;
989 /* Connect to CORE */
991 GNUNET_CORE_connect (cfg, NULL, &core_startup_cb, core_connect_cb,
992 &core_disconnect_cb, NULL, GNUNET_YES, NULL,
993 GNUNET_YES, core_handlers);
996 LOG (GNUNET_ERROR_TYPE_ERROR, _("Failed to connect to CORE service.\n"));
997 SENSOR_reporting_stop ();
998 return GNUNET_SYSERR;
1000 /* Connect to CADET */
1002 GNUNET_CADET_connect (cfg, NULL, NULL, &cadet_channel_destroyed,
1003 cadet_handlers, NULL);
1006 LOG (GNUNET_ERROR_TYPE_ERROR, _("Failed to connect to CADET service.\n"));
1007 SENSOR_reporting_stop ();
1008 return GNUNET_SYSERR;
1010 GNUNET_CRYPTO_get_peer_identity (cfg, &mypeerid);
1011 GNUNET_CONTAINER_multihashmap_iterate (sensors, &init_sensor_reporting, NULL);
1013 module_running = GNUNET_YES;
1017 /* end of gnunet-service-sensor_reporting.c */