#include "namestore.h"
-
/**
* Handle for a monitoring activity.
*/
struct GNUNET_NAMESTORE_ZoneMonitor
{
+ /**
+ * Configuration (to reconnect).
+ */
+ const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+ /**
+ * Handle to namestore service.
+ */
+ struct GNUNET_CLIENT_Connection *h;
+
+ /**
+ * Function to call on events.
+ */
+ GNUNET_NAMESTORE_RecordMonitor monitor;
+
+ /**
+ * Function called when we've synchronized.
+ */
+ GNUNET_NAMESTORE_RecordsSynchronizedCallback sync_cb;
+
+ /**
+ * Closure for 'monitor' and 'sync_cb'.
+ */
+ void *cls;
+
+ /**
+ * Transmission handle to client.
+ */
+ struct GNUNET_CLIENT_TransmitHandle *th;
+
+ /**
+ * Monitored zone.
+ */
+ struct GNUNET_CRYPTO_EcdsaPrivateKey zone;
+
};
+/**
+ * Send our request to start monitoring to the service.
+ *
+ * @param cls the monitor handle
+ * @param size number of bytes available in buf
+ * @param buf where to copy the message to the service
+ * @return number of bytes copied to buf
+ */
+static size_t
+transmit_monitor_message (void *cls,
+ size_t size,
+ void *buf);
+
+
+/**
+ * Reconnect to the namestore service.
+ *
+ * @param zm monitor to reconnect
+ */
+static void
+reconnect (struct GNUNET_NAMESTORE_ZoneMonitor *zm)
+{
+ if (NULL != zm->h)
+ GNUNET_CLIENT_disconnect (zm->h);
+ zm->monitor (zm->cls,
+ 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),
+ GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_YES,
+ &transmit_monitor_message,
+ zm);
+}
+
+
+/**
+ * We've received a notification about a change to our zone.
+ * Forward to monitor callback.
+ *
+ * @param cls the zone monitor handle
+ * @param msg the message from the service.
+ */
+static void
+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;
+ }
+ 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];
+
+ 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);
+ }
+}
+
+
+/**
+ * Send our request to start monitoring to the service.
+ *
+ * @param cls the monitor handle
+ * @param size number of bytes available in buf
+ * @param buf where to copy the message to the service
+ * @return number of bytes copied to buf
+ */
+static size_t
+transmit_monitor_message (void *cls,
+ size_t size,
+ void *buf)
+{
+ 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;
+ memcpy (buf, &sm, sizeof (sm));
+ GNUNET_CLIENT_receive (zm->h,
+ &handle_updates,
+ zm,
+ GNUNET_TIME_UNIT_FOREVER_REL);
+ return sizeof (sm);
+}
+
+
/**
* 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.
*
* @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)
{
- GNUNET_break (0);
- return NULL;
+ 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;
+
+
+ zm = GNUNET_new (struct GNUNET_NAMESTORE_ZoneMonitor);
+ zm->cfg = cfg;
+ zm->h = client;
+ zm->zone = *zone;
+ zm->monitor = monitor;
+ 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,
+ GNUNET_YES,
+ &transmit_monitor_message,
+ zm);
+ return zm;
}
void
GNUNET_NAMESTORE_zone_monitor_stop (struct GNUNET_NAMESTORE_ZoneMonitor *zm)
{
+ if (NULL != zm->th)
+ {
+ GNUNET_CLIENT_notify_transmit_ready_cancel (zm->th);
+ zm->th = NULL;
+ }
+ GNUNET_CLIENT_disconnect (zm->h);
+ GNUNET_free (zm);
}
/* end of namestore_api_monitor.c */
projects / oweals / gnunet.git / blobdiff