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.
/**
* 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'.
+ * Do we first iterate over all existing records?
*/
- int all_zones;
+ int iterate_first;
+
};
{
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),
const struct GNUNET_MessageHeader *msg)
{
struct GNUNET_NAMESTORE_ZoneMonitor *zm = cls;
- const struct LookupNameResponseMessage *lrm;
+ const struct RecordResultMessage *lrm;
size_t lrm_len;
size_t exp_lrm_len;
size_t name_len;
unsigned rd_count;
const char *name_tmp;
const char *rd_ser_tmp;
- struct GNUNET_TIME_Absolute expire;
if (NULL == msg)
{
reconnect (zm);
return;
}
- if ( (ntohs (msg->size) < sizeof (struct LookupNameResponseMessage)) ||
- (GNUNET_MESSAGE_TYPE_NAMESTORE_LOOKUP_NAME_RESPONSE != ntohs (msg->type) ) )
+ 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 LookupNameResponseMessage *) msg;
+ 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);
- expire = GNUNET_TIME_absolute_ntoh (lrm->expire);
- exp_lrm_len = sizeof (struct LookupNameResponseMessage) + name_len + rd_len;
+ exp_lrm_len = sizeof (struct RecordResultMessage) + name_len + rd_len;
if (lrm_len != exp_lrm_len)
{
GNUNET_break (0);
}
rd_ser_tmp = (const char *) &name_tmp[name_len];
{
- struct GNUNET_NAMESTORE_RecordData rd[rd_count];
+ struct GNUNET_GNSRECORD_Data rd[rd_count];
- if (GNUNET_OK != GNUNET_NAMESTORE_records_deserialize (rd_len, rd_ser_tmp, rd_count, rd))
+ 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->monitor_cls,
- &lrm->public_key, expire,
- name_tmp,
- rd_count, rd, &lrm->signature);
+ zm->monitor (zm->cls,
+ &lrm->private_key,
+ name_tmp,
+ rd_count, rd);
}
}
struct GNUNET_NAMESTORE_ZoneMonitor *zm = cls;
struct ZoneMonitorStartMessage sm;
+ zm->th = NULL;
if (size < sizeof (struct ZoneMonitorStartMessage))
- {
+ {
reconnect (zm);
return 0;
}
-
+ sm.header.type = htons (GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_START);
+ sm.header.size = htons (sizeof (struct ZoneMonitorStartMessage));
+ sm.iterate_first = htonl (zm->iterate_first);
sm.zone = zm->zone;
- sm.all_zones = htonl (zm->all_zones);
memcpy (buf, &sm, sizeof (sm));
GNUNET_CLIENT_receive (zm->h,
&handle_updates,
/**
- * Begin monitoring a zone for changes. Will first call the 'monitor' function
- * on all existing records in the selected zone(s) and then call it whenever
- * a record changes.
+ * Begin monitoring a zone for changes. If @a iterate_first is set,
+ * we Will first call the @a monitor function on all existing records
+ * in the selected zone(s). In any case, we will call @a sync and
+ * afterwards call @a monitor whenever 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 iterate_first #GNUNET_YES to first iterate over all existing records,
+ * #GNUNET_NO to only return changes that happen from now on
* @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 @a monitor and @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_ShortHashCode *zone,
+ const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone,
+ int iterate_first,
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 == (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
+ if (NULL != zone)
zm->zone = *zone;
+ zm->iterate_first = iterate_first;
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,
projects / oweals / gnunet.git / blobdiff