clean up zone iteration logic

[oweals/gnunet.git] / src / namestore / namestore_api_monitor.c

diff --git a/src/namestore/namestore_api_monitor.c b/src/namestore/namestore_api_monitor.c
index 85131f9ccb547e7e468fa5e9e476b711af10858f..8e6d39ad7e2612bd242b6e31af6331f56fa3d029 100644 (file)
--- a/src/namestore/namestore_api_monitor.c
+++ b/src/namestore/namestore_api_monitor.c
@@ -50,20 +50,35 @@ struct GNUNET_NAMESTORE_ZoneMonitor
    */
   struct GNUNET_MQ_Handle *mq;
 
+  /**
+   * Function to call on errors.
+   */
+  GNUNET_SCHEDULER_TaskCallback error_cb;
+
+  /**
+   * Closure for @e error_cb.
+   */
+  void *error_cb_cls;
+
   /**
    * Function to call on events.
    */
   GNUNET_NAMESTORE_RecordMonitor monitor;
 
+  /**
+   * Closure for @e monitor.
+   */
+  void *monitor_cls;
+
   /**
    * Function called when we've synchronized.
    */
-  GNUNET_NAMESTORE_RecordsSynchronizedCallback sync_cb;
+  GNUNET_SCHEDULER_TaskCallback sync_cb;
 
   /**
-   * Closure for @e monitor and @e sync_cb.
+   * Closure for @e sync_cb.
    */
-  void *cls;
+  void *sync_cb_cls;
 
   /**
    * Monitored zone.
@@ -99,8 +114,10 @@ handle_sync (void *cls,
 {
   struct GNUNET_NAMESTORE_ZoneMonitor *zm = cls;
 
+  (void) cls;
+  (void) msg;
   if (NULL != zm->sync_cb)
-    zm->sync_cb (zm->cls);
+    zm->sync_cb (zm->sync_cb_cls);
 }
 
 
@@ -123,6 +140,7 @@ check_result (void *cls,
   const char *name_tmp;
   const char *rd_ser_tmp;
 
+  (void) cls;
   lrm_len = ntohs (lrm->gns_header.header.size);
   rd_len = ntohs (lrm->rd_len);
   rd_count = ntohs (lrm->rd_count);
@@ -193,7 +211,7 @@ handle_result (void *cls,
                                                          rd_ser_tmp,
                                                          rd_count,
                                                          rd));
-    zm->monitor (zm->cls,
+    zm->monitor (zm->monitor_cls,
                 &lrm->private_key,
                 name_tmp,
                 rd_count,
@@ -216,6 +234,7 @@ mq_error_handler (void *cls,
 {
   struct GNUNET_NAMESTORE_ZoneMonitor *zm = cls;
 
+  (void) error;
   reconnect (zm);
 }
 
@@ -228,15 +247,15 @@ mq_error_handler (void *cls,
 static void
 reconnect (struct GNUNET_NAMESTORE_ZoneMonitor *zm)
 {
-  GNUNET_MQ_hd_fixed_size (sync,
-                           GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_SYNC,
-                           struct GNUNET_MessageHeader);
-  GNUNET_MQ_hd_var_size (result,
-                         GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT,
-                         struct RecordResultMessage);
   struct GNUNET_MQ_MessageHandler handlers[] = {
-    make_sync_handler (zm),
-    make_result_handler (zm),
+    GNUNET_MQ_hd_fixed_size (sync,
+                             GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_SYNC,
+                             struct GNUNET_MessageHeader,
+                             zm),
+    GNUNET_MQ_hd_var_size (result,
+                           GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT,
+                           struct RecordResultMessage,
+                           zm),
     GNUNET_MQ_handler_end ()
   };
   struct GNUNET_MQ_Envelope *env;
@@ -245,13 +264,9 @@ reconnect (struct GNUNET_NAMESTORE_ZoneMonitor *zm)
   if (NULL != zm->mq)
   {
     GNUNET_MQ_destroy (zm->mq);
-    zm->monitor (zm->cls,
-                 NULL,
-                 NULL,
-                 0,
-                 NULL);
+    zm->error_cb (zm->error_cb_cls);
   }
-  zm->mq = GNUNET_CLIENT_connecT (zm->cfg,
+  zm->mq = GNUNET_CLIENT_connect (zm->cfg,
                                   "namestore",
                                   handlers,
                                   &mq_error_handler,
@@ -278,18 +293,28 @@ reconnect (struct GNUNET_NAMESTORE_ZoneMonitor *zm)
  * @param zone zone to monitor
  * @param iterate_first #GNUNET_YES to first iterate over all existing records,
  *                      #GNUNET_NO to only return changes that happen from now on
+ * @param error_cb function to call on error (i.e. disconnect); note that
+ *         unlike the other error callbacks in this API, a call to this
+ *         function does NOT destroy the monitor handle, it merely signals
+ *         that monitoring is down. You need to still explicitly call
+ *         #GNUNET_NAMESTORE_zone_monitor_stop().
+ * @param error_cb_cls closure for @a error_cb
  * @param monitor function to call on zone changes
+ * @param monitor_cls closure for @a monitor
  * @param sync_cb function called when we're in sync with the namestore
- * @param cls closure for @a monitor and @a sync_cb
+ * @param cls closure for @a sync_cb
  * @return handle to stop monitoring
  */
 struct GNUNET_NAMESTORE_ZoneMonitor *
 GNUNET_NAMESTORE_zone_monitor_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
                                     const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
                                      int iterate_first,
+                                     GNUNET_SCHEDULER_TaskCallback error_cb,
+                                     void *error_cb_cls,
                                     GNUNET_NAMESTORE_RecordMonitor monitor,
-                                    GNUNET_NAMESTORE_RecordsSynchronizedCallback sync_cb,
-                                    void *cls)
+                                     void *monitor_cls,
+                                    GNUNET_SCHEDULER_TaskCallback sync_cb,
+                                    void *sync_cb_cls)
 {
   struct GNUNET_NAMESTORE_ZoneMonitor *zm;
 
@@ -297,9 +322,12 @@ GNUNET_NAMESTORE_zone_monitor_start (const struct GNUNET_CONFIGURATION_Handle *c
   if (NULL != zone)
     zm->zone = *zone;
   zm->iterate_first = iterate_first;
+  zm->error_cb = error_cb;
+  zm->error_cb_cls = error_cb_cls;
   zm->monitor = monitor;
+  zm->monitor_cls = monitor_cls;
   zm->sync_cb = sync_cb;
-  zm->cls = cls;
+  zm->sync_cb_cls = sync_cb_cls;
   zm->cfg = cfg;
   reconnect (zm);
   if (NULL == zm->mq)