-fix leaks

[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 e2caea8a575428e732d09f24abe2f94dd76c2bb2..076add1eb62eb423f422a0ad94a9f5d10348cac3 100644 (file)
--- a/src/namestore/namestore_api_monitor.c
+++ b/src/namestore/namestore_api_monitor.c
@@ -56,9 +56,14 @@ struct GNUNET_NAMESTORE_ZoneMonitor
   GNUNET_NAMESTORE_RecordMonitor monitor;
 
   /**
-   * Closure for 'monitor'.
+   * Function called when we've synchronized.
    */
-  void *monitor_cls;
+  GNUNET_NAMESTORE_RecordsSynchronizedCallback sync_cb;
+
+  /**
+   * Closure for 'monitor' and 'sync_cb'.
+   */
+  void *cls;
 
   /**
    * Transmission handle to client.
@@ -68,12 +73,8 @@ struct GNUNET_NAMESTORE_ZoneMonitor
   /**
    * Monitored zone.
    */
-  struct GNUNET_CRYPTO_ShortHashCode zone;
+  struct GNUNET_CRYPTO_EcdsaPrivateKey zone;
 
-  /**
-   * GNUNET_YES if we monitor all zones, GNUNET_NO if we only monitor 'zone'.
-   */
-  int all_zones;
 };
 
 
@@ -101,10 +102,9 @@ reconnect (struct GNUNET_NAMESTORE_ZoneMonitor *zm)
 {
   if (NULL != zm->h)
     GNUNET_CLIENT_disconnect (zm->h);
-  zm->monitor (zm->monitor_cls,
+  zm->monitor (zm->cls,
               NULL,
-              GNUNET_TIME_UNIT_ZERO_ABS,
-              NULL, 0, NULL, NULL);
+              NULL, 0, NULL);
   GNUNET_assert (NULL != (zm->h = GNUNET_CLIENT_connect ("namestore", zm->cfg)));
   zm->th = GNUNET_CLIENT_notify_transmit_ready (zm->h,
                                                sizeof (struct ZoneMonitorStartMessage),
@@ -127,20 +127,82 @@ handle_updates (void *cls,
                const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_NAMESTORE_ZoneMonitor *zm = cls;
+  const struct RecordResultMessage *lrm;
+  size_t lrm_len;
+  size_t exp_lrm_len;
+  size_t name_len;
+  size_t rd_len;
+  unsigned rd_count;
+  const char *name_tmp;
+  const char *rd_ser_tmp;
 
   if (NULL == msg)
   {
     reconnect (zm);
     return;
   }
-  // FIXME: parse, validate
+  if ( (ntohs (msg->size) == sizeof (struct GNUNET_MessageHeader)) &&
+       (GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_SYNC == ntohs (msg->type) ) )
+  {
+    GNUNET_CLIENT_receive (zm->h,
+                          &handle_updates,
+                          zm,
+                          GNUNET_TIME_UNIT_FOREVER_REL);
+    if (NULL != zm->sync_cb)
+      zm->sync_cb (zm->cls);
+    return;
+  }
+  if ( (ntohs (msg->size) < sizeof (struct RecordResultMessage)) ||
+       (GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT != ntohs (msg->type) ) )
+  {
+    GNUNET_break (0);
+    reconnect (zm);
+    return;
+  }
+  lrm = (const struct RecordResultMessage *) msg;
+  lrm_len = ntohs (lrm->gns_header.header.size);
+  rd_len = ntohs (lrm->rd_len);
+  rd_count = ntohs (lrm->rd_count);
+  name_len = ntohs (lrm->name_len);
+  exp_lrm_len = sizeof (struct RecordResultMessage) + name_len + rd_len;
+  if (lrm_len != exp_lrm_len)
+  {
+    GNUNET_break (0);
+    reconnect (zm);
+    return;
+  }
+  if (0 == name_len)
+  {
+    GNUNET_break (0);
+    reconnect (zm);
+    return;
+  }
+  name_tmp = (const char *) &lrm[1];
+  if ((name_tmp[name_len -1] != '\0') || (name_len > MAX_NAME_LEN))
+  {
+    GNUNET_break (0);
+    reconnect (zm);
+    return;
+  }
+  rd_ser_tmp = (const char *) &name_tmp[name_len];
+  {
+    struct GNUNET_GNSRECORD_Data rd[rd_count];
 
-  GNUNET_CLIENT_receive (zm->h,
-                        &handle_updates,
-                        zm,
-                        GNUNET_TIME_UNIT_FOREVER_REL);
-  // FIXME: call 'monitor'.
-  // zm->monitor (zm->monitor_cls, ...);
+    if (GNUNET_OK != GNUNET_GNSRECORD_records_deserialize (rd_len, rd_ser_tmp, rd_count, rd))
+    {
+      GNUNET_break (0);
+      reconnect (zm);
+      return;
+    }
+    GNUNET_CLIENT_receive (zm->h,
+                          &handle_updates,
+                          zm,
+                          GNUNET_TIME_UNIT_FOREVER_REL);
+    zm->monitor (zm->cls,
+                &lrm->private_key,
+                name_tmp,
+                rd_count, rd);
+  }
 }
 
 
@@ -160,14 +222,16 @@ transmit_monitor_message (void *cls,
   struct GNUNET_NAMESTORE_ZoneMonitor *zm = cls;
   struct ZoneMonitorStartMessage sm;
 
+  zm->th = NULL;
   if (size < sizeof (struct ZoneMonitorStartMessage))
-  {    
+  {
     reconnect (zm);
     return 0;
   }
- 
+  sm.gns_header.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_START);
+  sm.gns_header.header.size = htons (sizeof (struct ZoneMonitorStartMessage));
+  sm.gns_header.r_id = htonl (0);
   sm.zone = zm->zone;
-  sm.all_zones = htonl (zm->all_zones);
   memcpy (buf, &sm, sizeof (sm));
   GNUNET_CLIENT_receive (zm->h,
                         &handle_updates,
@@ -183,31 +247,35 @@ transmit_monitor_message (void *cls,
  * a record changes.
  *
  * @param cfg configuration to use to connect to namestore
- * @param zone zone to monitor, NULL for all zones
+ * @param zone zone to monitor
  * @param monitor function to call on zone changes
- * @param monitor_cls closure for 'monitor'
+ * @param sync_cb function called when we're in sync with the namestore
+ * @param cls closure for 'monitor' and '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_ShortHashCode *zone,
+                                    const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
                                     GNUNET_NAMESTORE_RecordMonitor monitor,
-                                    void *monitor_cls)
+                                    GNUNET_NAMESTORE_RecordsSynchronizedCallback sync_cb,
+                                    void *cls)
 {
   struct GNUNET_NAMESTORE_ZoneMonitor *zm;
   struct GNUNET_CLIENT_Connection *client;
 
+  if (NULL == zone)
+       return NULL;
   if (NULL == (client = GNUNET_CLIENT_connect ("namestore", cfg)))
-    return NULL; 
+    return NULL;
+
+
   zm = GNUNET_new (struct GNUNET_NAMESTORE_ZoneMonitor);
   zm->cfg = cfg;
   zm->h = client;
-  if (NULL == zone)
-    zm->all_zones = GNUNET_YES;
-  else
-    zm->zone = *zone;
+  zm->zone = *zone;
   zm->monitor = monitor;
-  zm->monitor_cls = monitor_cls;
+  zm->sync_cb = sync_cb;
+  zm->cls = cls;
   zm->th = GNUNET_CLIENT_notify_transmit_ready (zm->h,
                                                sizeof (struct ZoneMonitorStartMessage),
                                                GNUNET_TIME_UNIT_FOREVER_REL,