-make it compile against new api, added parser utils borrowed from dnsparser

5 files changed, 360 insertions, 316 deletions

diff --git a/src/gns/gns.h b/src/gns/gns.h
index ae7a1c670..cb47c817a 100644
--- a/src/gns/gns.h
+++ b/src/gns/gns.h
@@ -29,19 +29,6 @@
 GNUNET_NETWORK_STRUCT_BEGIN
 
 /**
- * Equivalent to GNUNET_DNSPARSER_Record
- * FIXME typedef?
- */
-struct GNUNET_GNS_Record
-{
-  //struct GNUNET_DNSPARSER_Record record;
-
-  //enum GNUNET_NAMESTORE_RecordFlags flags;
-
-  const struct GNUNET_NAMESTORE_SignatureLocation *sig_loc;
-
-};
-/**
  * Message from client to GNS service to lookup records.
  */
 struct GNUNET_GNS_ClientLookupMessage
diff --git a/src/gns/gns_api.c b/src/gns/gns_api.c
index 50f616716..00e96a61b 100644
--- a/src/gns/gns_api.c
+++ b/src/gns/gns_api.c
@@ -430,7 +430,7 @@ process_reply (void *cls, const GNUNET_HashCode * key, void *value)
   const struct GNUNET_GNS_ClientResultMessage *gns_msg = cls;
   struct GNUNET_GNS_LookupHandle *lookup_handle = value;
   const char *name = (const char*) &lookup_handle[1];
-  const struct GNUNET_GNS_Record *records;
+  const GNUNET_GNS_Record *records;
   uint32_t num_records;
   size_t meta_length;
   size_t msize;
@@ -449,10 +449,10 @@ process_reply (void *cls, const GNUNET_HashCode * key, void *value)
   num_records = ntohl (gns_msg->num_records);
   meta_length =
     sizeof (struct GNUNET_GNS_ClientResultMessage) +
-    sizeof (struct GNUNET_GNS_Record) * (num_records);
+    sizeof (GNUNET_GNS_Record) * (num_records);
   if ((msize < meta_length) ||
       (num_records >
-       GNUNET_SERVER_MAX_MESSAGE_SIZE / sizeof (struct GNUNET_GNS_Record)))
+       GNUNET_SERVER_MAX_MESSAGE_SIZE / sizeof (GNUNET_GNS_Record)))
   {
     GNUNET_break (0);
     return GNUNET_NO;
@@ -461,7 +461,7 @@ process_reply (void *cls, const GNUNET_HashCode * key, void *value)
   LOG (GNUNET_ERROR_TYPE_DEBUG, "Giving %u byte reply for %s to application\n",
        (unsigned int) (msize - meta_length), GNUNET_h2s (key));
 #endif
-  records = (const struct GNUNET_GNS_Record *) &gns_msg[1];
+  records = (const GNUNET_GNS_Record *) &gns_msg[1];
   lookup_handle->iter (lookup_handle->iter_cls, name, records, num_records);
   return GNUNET_YES;
 }
diff --git a/src/gns/gns_util.c b/src/gns/gns_util.c
new file mode 100644
index 000000000..b2f5e1f38
--- /dev/null
+++ b/src/gns/gns_util.c
@@ -0,0 +1,196 @@
+#include "gns.h"
+
+/**
+ * Add a DNS name to the buffer at the given location.
+ *
+ * @param dst where to write the name
+ * @param dst_len number of bytes in dst
+ * @param off pointer to offset where to write the name (increment by bytes used)
+ *            must not be changed if there is an error
+ * @param name name to write
+ * @return GNUNET_SYSERR if 'name' is invalid
+ *         GNUNET_NO if 'name' did not fit
+ *         GNUNET_OK if 'name' was added to 'dst'
+ */
+static int
+add_name (char *dst,
+          size_t dst_len,
+          size_t *off,
+          const char *name)
+{
+  const char *dot;
+  size_t start;
+  size_t pos;
+  size_t len;
+
+  if (NULL == name)
+    return GNUNET_SYSERR;
+  start = *off;
+  if (start + strlen (name) + 2 > dst_len)
+    return GNUNET_NO;
+  pos = start;
+  do
+  {
+    dot = strchr (name, '.');
+    if (NULL == dot)
+      len = strlen (name);
+    else
+      len = dot - name;
+    if ( (len >= 64) || (len == 0) )
+      return GNUNET_NO; /* segment too long or empty */
+    dst[pos++] = (char) (uint8_t) len;
+    memcpy (&dst[pos], name, len);
+    pos += len;
+    name += len + 1; /* also skip dot */
+  }
+  while (NULL != dot);
+  dst[pos++] = '\0'; /* terminator */
+  *off = pos;
+  return GNUNET_OK;
+}
+
+/**
+ * Add an MX record to the buffer at the given location.
+ *
+ * @param dst where to write the mx record
+ * @param dst_len number of bytes in dst
+ * @param off pointer to offset where to write the mx information (increment by bytes used);
+ *            can also change if there was an error
+ * @param mx mx information to write
+ * @return GNUNET_SYSERR if 'mx' is invalid
+ *         GNUNET_NO if 'mx' did not fit
+ *         GNUNET_OK if 'mx' was added to 'dst'
+ */
+static int
+add_mx (char *dst,
+        size_t dst_len,
+        size_t *off,
+        const struct GNUNET_DNSPARSER_MxRecord *mx)
+{
+  uint16_t mxpref;
+
+  if (*off + sizeof (uint16_t) > dst_len)
+    return GNUNET_NO;
+  mxpref = htons (mx->preference);
+  memcpy (&dst[*off], &mxpref, sizeof (mxpref));
+  (*off) += sizeof (mxpref);
+  return add_name (dst, dst_len, off, mx->mxhost);
+}
+
+
+/**
+ * Add an SOA record to the buffer at the given location.
+ *
+ * @param dst where to write the SOA record
+ * @param dst_len number of bytes in dst
+ * @param off pointer to offset where to write the SOA information (increment by bytes used)
+ *            can also change if there was an error
+ * @param soa SOA information to write
+ * @return GNUNET_SYSERR if 'soa' is invalid
+ *         GNUNET_NO if 'soa' did not fit
+ *         GNUNET_OK if 'soa' was added to 'dst'
+ */
+static int
+add_soa (char *dst,
+         size_t dst_len,
+         size_t *off,
+         const struct GNUNET_DNSPARSER_SoaRecord *soa)
+{
+  struct soa_data sd;
+  int ret;
+
+  if ( (GNUNET_OK != (ret = add_name (dst,
+                                      dst_len,
+                                      off,
+                                      soa->mname))) ||
+       (GNUNET_OK != (ret = add_name (dst,
+                                      dst_len,
+                                      off,
+                                      soa->rname)) ) )
+    return ret;
+  if (*off + sizeof (struct soa_data) > dst_len)
+    return GNUNET_NO;
+  sd.serial = htonl (soa->serial);
+  sd.refresh = htonl (soa->refresh);
+  sd.retry = htonl (soa->retry);
+  sd.expire = htonl (soa->expire);
+  sd.minimum = htonl (soa->minimum_ttl);
+  memcpy (&dst[*off], &sd, sizeof (sd));
+  (*off) += sizeof (sd);
+  return GNUNET_OK;
+}
+
+/**
+ * Add a DNS record to the buffer at the given location.
+ *
+ * @param dst where to write the record
+ * @param dst_len number of bytes in dst
+ * @param off pointer to offset where to write the query (increment by bytes used)
+ *            must not be changed if there is an error
+ * @param record record to write
+ * @return GNUNET_SYSERR if 'record' is invalid
+ *         GNUNET_NO if 'record' did not fit
+ *         GNUNET_OK if 'record' was added to 'dst'
+ */
+static int
+parse_record (char *dst,
+            size_t dst_len,
+            size_t *off,
+            const struct GNUNET_GNS_Record *record)
+{
+  int ret;
+  size_t start;
+  size_t pos;
+  struct record_line rl;
+
+  start = *off;
+  ret = add_name (dst, dst_len - sizeof (struct record_line), off, record->name);
+  if (ret != GNUNET_OK)
+    return ret;
+  /* '*off' is now the position where we will need to write the record line */
+
+  pos = *off + sizeof (struct record_line);
+  switch (record->type)
+  { 
+  case GNUNET_DNSPARSER_TYPE_MX:
+    ret = add_mx (dst, dst_len, &pos, record->data.mx);    
+    break;
+  case GNUNET_DNSPARSER_TYPE_SOA:
+    ret = add_soa (dst, dst_len, &pos, record->data.soa);
+    break;
+  case GNUNET_DNSPARSER_TYPE_NS:
+  case GNUNET_DNSPARSER_TYPE_CNAME:
+  case GNUNET_DNSPARSER_TYPE_PTR:
+    ret = add_name (dst, dst_len, &pos, record->data.hostname);
+    break;
+  default:
+    if (pos + record->data.raw.data_len > dst_len)
+    {
+      ret = GNUNET_NO;
+      break;
+    }
+    memcpy (&dst[pos], record->data.raw.data, record->data.raw.data_len);
+    pos += record->data.raw.data_len;
+    ret = GNUNET_OK;
+    break;
+  }
+  if (ret != GNUNET_OK)
+  {
+    *off = start;
+    return GNUNET_NO;
+  }
+
+  if (pos - (*off + sizeof (struct record_line)) > UINT16_MAX)
+  {
+    /* record data too long */
+    *off = start;
+    return GNUNET_NO;
+  }
+  rl.type = htons (record->type);
+  rl.class = htons (record->class);
+  rl.ttl = htonl (GNUNET_TIME_absolute_get_remaining (record->expiration_time).rel_value / 1000); /* in seconds */
+  rl.data_len = htons ((uint16_t) (pos - (*off + sizeof (struct record_line))));
+  memcpy (&dst[*off], &rl, sizeof (struct record_line));
+  *off = pos;
+  return GNUNET_OK;  
+}
diff --git a/src/gns/gnunet-service-gns.c b/src/gns/gnunet-service-gns.c
index 198e4c33b..cb82439c4 100644
--- a/src/gns/gnunet-service-gns.c
+++ b/src/gns/gnunet-service-gns.c
@@ -52,7 +52,7 @@ struct GNUNET_GNS_QueryRecordList
   struct GNUNET_GNS_QueryRecordList * next;
   struct GNUNET_GNS_QueryRecordList * prev;
 
-  struct GNUNET_DNSPARSER_Record * record;
+  GNUNET_GNS_Record * record;
 };
 
 /**
@@ -103,8 +103,6 @@ struct GNUNET_DNS_Handle *dns_handle;
  */
 struct GNUNET_DHT_Handle *dht_handle;
 
-struct GNUNET_TIME_Relative dht_update_interval;
-
 /**
  * Our zone's private key
  */
@@ -115,6 +113,8 @@ struct GNUNET_CRYPTO_RsaPrivateKey *zone_key;
  */
 struct GNUNET_NAMESTORE_Handle *namestore_handle;
 
+struct GNUNET_NAMESTORE_ZoneIterator *namestore_iter;
+
 /**
  * The configuration the GNS service is running with
  */
@@ -136,6 +136,12 @@ GNUNET_HashCode zone_hash;
 const char* gnunet_tld = ".gnunet";
 
 /**
+ * Useful for zone update for DHT put
+ */
+static int num_public_records =  3600;
+struct GNUNET_TIME_Relative dht_update_interval;
+
+/**
  * Task run during shutdown.
  *
  * @param cls unused
@@ -313,20 +319,24 @@ resolve_name(struct GNUNET_GNS_PendingQuery *query, GNUNET_HashCode *zone);
  * @param data the record data
  */
 void
-process_authority_lookup(void* cls, const GNUNET_HashCode *zone,
-                   const char *name, uint32_t record_type,
+process_authority_lookup(void* cls,
+                   const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
                    struct GNUNET_TIME_Absolute expiration,
-                   enum GNUNET_NAMESTORE_RecordFlags flags,
-                   size_t size, const void *data)
+                   const char *name,
+                   unsigned int rd_count,
+                   const struct GNUNET_NAMESTORE_RecordData *rd,
+                   const struct GNUNET_CRYPTO_RsaSignature *signature)
 {
   struct GNUNET_GNS_PendingQuery *query;
+  GNUNET_HashCode zone;
 
   query = (struct GNUNET_GNS_PendingQuery *)cls;
+  GNUNET_CRYPTO_hash(key, GNUNET_CRYPTO_RSA_KEY_LENGTH, &zone);
   
   /**
    * No authority found in namestore.
    */
-  if (NULL == data)
+  if (rd_count == 0)
   {
     if (query->authority_found)
     {
@@ -337,11 +347,10 @@ process_authority_lookup(void* cls, const GNUNET_HashCode *zone,
 
     /**
      * We did not find an authority in the namestore
-     * _IF_ the current authoritative zone is us.
-     * we cannot resolve
-     * _ELSE_ we cannot still check the dht
+     * _IF_ the current authoritative zone is us we cannot resolve
+     * _ELSE_ we can still check the dht
      */
-    if (GNUNET_CRYPTO_hash_cmp(zone, &zone_hash))
+    if (GNUNET_CRYPTO_hash_cmp(&zone, &zone_hash))
     {
       GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Authority unknown\n");
       //FIXME return NX answer
@@ -351,14 +360,23 @@ process_authority_lookup(void* cls, const GNUNET_HashCode *zone,
     resolve_authority_dht(query, name);
     return;
   }
-  
+
+  //Note only 1 pkey should have been returned.. anything else would be strange
   /**
    * We found an authority that may be able to help us
    * move on with query
    */
-  query->authority_found = 1;
-  GNUNET_HashCode *key = (GNUNET_HashCode*) data; //FIXME i assume this works
-  query->authority = key;
+  GNUNET_GNS_Record *record 
+    = GNUNET_malloc(sizeof(GNUNET_GNS_Record));
+  
+  
+  //FIXME todo
+  //parse_record(rd[0]->data, rd[0]->data_size, 0, record);
+  //FIXME this cast will not work we have to define how a PKEY record looks like
+  //In reality this also returns a pubkey not a hash
+  GNUNET_HashCode *k = (GNUNET_HashCode*)record->data.raw.data;
+  query->authority = k;
+  resolve_name(query, query->authority);
   
 }
 
@@ -449,40 +467,38 @@ reply_to_dns(struct GNUNET_GNS_PendingQuery *answer)
  * @param data the record data
  */
 static void
-process_authoritative_result(void* cls, const GNUNET_HashCode *zone,
-                  const char *name, uint32_t record_type,
+process_authoritative_result(void* cls,
+                  const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
                   struct GNUNET_TIME_Absolute expiration,
-                  enum GNUNET_NAMESTORE_RecordFlags flags,
-                  size_t size, const void *data)
+                  const char *name, unsigned int rd_count,
+                  const struct GNUNET_NAMESTORE_RecordData *rd,
+                  const struct GNUNET_CRYPTO_RsaSignature *signature)
 {
   struct GNUNET_GNS_PendingQuery *query;
   struct GNUNET_GNS_QueryRecordList *qrecord;
   struct GNUNET_DNSPARSER_Record *record;
+  GNUNET_HashCode zone;
   query = (struct GNUNET_GNS_PendingQuery *) cls;
+  GNUNET_CRYPTO_hash(key, GNUNET_CRYPTO_RSA_KEY_LENGTH, &zone);
 
+  //FIXME Handle results in rd
 
-  if (NULL == data)
+  if (rd_count == 0)
   {
     /**
      * FIXME
-     * Lookup terminated
-     * Do we have what we need to answer?
-     * If not -> DHT Phase
+     * Lookup terminated and no results
+     * -> DHT Phase unless data is recent
      * if full_name == next_name and not anwered we cannot resolve
      */
     GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-               "Namestore lookup terminated. (answered=%d)", query->answered);
-    if (query->answered)
-    {
-      reply_to_dns(query);
-      return;
-    }
-
+               "Namestore lookup terminated. without results\n");
+    
     /**
      * if this is not our zone we cannot rely on the namestore to be
      * complete. -> Query DHT
      */
-    if (!GNUNET_CRYPTO_hash_cmp(zone, &zone_hash))
+    if (!GNUNET_CRYPTO_hash_cmp(&zone, &zone_hash))
     {
       //FIXME todo
       resolve_name_dht(query, name);
@@ -500,54 +516,36 @@ process_authoritative_result(void* cls, const GNUNET_HashCode *zone,
   {
     /**
      * Record found
+     *
+     * FIXME Check record expiration and dht expiration
+     * consult dht if necessary
      */
     GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                "Processing additional result for %s from namestore\n", name);
-
-    qrecord = GNUNET_malloc(sizeof(struct GNUNET_GNS_QueryRecordList));
-    record = GNUNET_malloc(sizeof(struct GNUNET_DNSPARSER_Record));
-    qrecord->record = record;
-
-    record->name = (char*)query->original_name;
-
-    /**
-     * FIXME for gns records this requires the dnsparser to be modified!
-     * or use RAW. But RAW data need serialization!
-     * maybe store record data appropriately in namestore to avoid a
-     * huge switch statement?
-     */
-    if (record_type == GNUNET_DNSPARSER_TYPE_A)
-    {
-      record->data.raw.data = (char*)data;
-      record->data.raw.data_len = size;
-    }
-    record->expiration_time = expiration;
-    record->type = record_type;
-    record->class = GNUNET_DNSPARSER_CLASS_INTERNET; /* srsly? */
-    
-    //FIXME authoritative answer if we find a result in namestore
-    if (flags == GNUNET_NAMESTORE_RF_AUTHORITY)
+    int i;
+    for (i=0; i<rd_count;i++)
     {
-      //query->num_authority_records++;
+      // A time will come when this has to be freed
+      qrecord = GNUNET_malloc(sizeof(struct GNUNET_GNS_QueryRecordList));
+      record = GNUNET_malloc(sizeof(struct GNUNET_DNSPARSER_Record));
+      qrecord->record = record;
+      
+      //fixme into gns_util
+      //parse_record(rd[i]->data, rd[i]->data_size, 0, record);
+      GNUNET_CONTAINER_DLL_insert(query->records_head,
+                                  query->records_tail,
+                                  qrecord);
+      query->num_records++;
+
+      //TODO really?
+      //we need to resolve to the original name in the end though...
+      //record->name = (char*)query->original_name;
     }
-    
-    /**
-     * This seems to take into account that the result could
-     * be different in name and or record type...
-     * but to me this does not make sense
-     */
+
     GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Found answer to query!\n");
     query->answered = 1;
 
-    query->num_records++;
-
-    /**
-     * FIXME watch for leaks
-     * properly free pendingquery when the time comes
-     */
-    GNUNET_CONTAINER_DLL_insert(query->records_head,
-                                query->records_tail,
-                                qrecord);
+    reply_to_dns(query);
   }
 }
 
@@ -749,40 +747,41 @@ put_some_records(void)
   /* put a few records into namestore */
   char* ipA = "1.2.3.4";
   char* ipB = "5.6.7.8";
-  struct in_addr *alice = GNUNET_malloc(sizeof(struct in_addr));
-  struct in_addr *bob = GNUNET_malloc(sizeof(struct in_addr));
-  GNUNET_assert(1 == inet_pton (AF_INET, ipA, alice));
-  GNUNET_assert(1 == inet_pton (AF_INET, ipB, bob));
-  GNUNET_NAMESTORE_record_put (namestore_handle,
-                               &zone_hash,
+  GNUNET_GNS_Record *alice = GNUNET_malloc(sizeof(GNUNET_GNS_Record));
+  GNUNET_GNS_Record *bob = GNUNET_malloc(sizeof(GNUNET_GNS_Record));
+  struct GNUNET_NAMESTORE_RecordData *rda = NULL;
+  struct GNUNET_NAMESTORE_RecordData *rdb = NULL;
+  rda = GNUNET_malloc(sizeof(struct GNUNET_NAMESTORE_RecordData));
+  
+  //FIXME here we would have to parse the gns record and put it into
+  //the rd struct
+
+  //FIXME this is not enough! but too mucht atm
+  GNUNET_assert(1 == inet_pton (AF_INET, ipA, alice->data.raw.data));
+  GNUNET_assert(1 == inet_pton (AF_INET, ipB, bob->data.raw.data));
+
+  GNUNET_NAMESTORE_record_create (namestore_handle,
+                               zone_key,
                                "alice",
-                               GNUNET_GNS_RECORD_TYPE_A,
-                               GNUNET_TIME_absolute_get_forever(),
-                               GNUNET_NAMESTORE_RF_AUTHORITY,
-                               sizeof(struct in_addr),
-                               alice,
+                               rda,
                                NULL,
                                NULL);
-  GNUNET_NAMESTORE_record_put (namestore_handle,
-                               &zone_hash,
+  GNUNET_NAMESTORE_record_create (namestore_handle,
+                               zone_key,
                                "bob",
-                               GNUNET_GNS_RECORD_TYPE_A,
-                               GNUNET_TIME_absolute_get_forever(),
-                               GNUNET_NAMESTORE_RF_AUTHORITY,
-                               sizeof(struct in_addr),
-                               bob,
+                               rdb,
                                NULL,
                                NULL);
 }
 
-//Prototype... needed in put function
-static void
-update_zone_dht(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
+void
+update_zone_dht_next(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  GNUNET_NAMESTORE_zone_iterator_next(namestore_iter);
+}
 
 /**
  * Function used to put all records successively into the DHT.
- * FIXME also serializes records. maybe do this somewhere else...
- * FIXME don't store private records (maybe zone transfer does this)
  *
  * @param cls the closure (NULL)
  * @param zone our root zone hash
@@ -795,77 +794,37 @@ update_zone_dht(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
  * @param record_data the record data
  */
 void
-put_gns_record(void *cls, const GNUNET_HashCode *zone, const char *name,
-               uint32_t record_type, struct GNUNET_TIME_Absolute expiration,
-               enum GNUNET_NAMESTORE_RecordFlags flags,
-               size_t size, const void *record_data)
+put_gns_record(void *cls,
+                const const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
+                struct GNUNET_TIME_Absolute expiration,
+                const char *name,
+                unsigned int rd_count,
+                const struct GNUNET_NAMESTORE_RecordData *rd,
+                const struct GNUNET_CRYPTO_RsaSignature *signature)
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Putting a record into the DHT\n");
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Putting records into the DHT\n");
   struct GNUNET_TIME_Relative timeout;
-
-  char* data;
-  char* data_ptr;
-  struct GNUNET_TIME_AbsoluteNBO exp_nbo;
-  exp_nbo = GNUNET_TIME_absolute_hton (expiration);
-  uint32_t namelen = htonl(strlen(name));
-  uint16_t flags_nbo = htons(flags);
   GNUNET_HashCode name_hash;
   GNUNET_HashCode xor_hash;
 
-  /**
-   * I guess this can be done prettier
-   * FIXME extract into function, maybe even into different file
-   */
-  size_t record_len = sizeof(size_t) + sizeof(uint32_t) +
-    sizeof(uint16_t) +
-    sizeof(uint32_t) + strlen(name) + size;
-  
-  record_type = htonl(record_type);
-
-  data = GNUNET_malloc(record_len);
-  
-  /* -_- */
-  data_ptr = data;
-  memcpy(data_ptr, &namelen, sizeof(size_t));
-  data_ptr += sizeof(size_t);
-
-  memcpy(data_ptr, name, namelen);
-  data_ptr += namelen;
-  
-  memcpy(data_ptr, &record_type, sizeof(uint32_t));
-  data_ptr += sizeof(uint32_t);
-
-  memcpy(data_ptr, &exp_nbo, sizeof(struct GNUNET_TIME_AbsoluteNBO));
-  data_ptr += sizeof(struct GNUNET_TIME_AbsoluteNBO);
-
-  memcpy(data_ptr, &flags_nbo, sizeof(uint16_t));
-  data_ptr += sizeof(uint16_t);
-
-  memcpy(data_ptr, &size, sizeof(uint32_t));
-  data_ptr += sizeof(uint32_t);
-
-  /**
-   * FIXME note that this only works with raw data in nbo
-   * write helper function that converts properly and returns buffer
-   */
-  memcpy(data_ptr, record_data, size);
-  data_ptr += size;
-  /*Doing this made me sad...*/
-
+  if (NULL == name) //We're done
+  {
+    GNUNET_NAMESTORE_zone_iteration_stop (namestore_iter);
+    return;
+  }
   /**
    * FIXME magic number 20 move to config file
    */
   timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 20);
-
   GNUNET_CRYPTO_hash(name, strlen(name), &name_hash);
   GNUNET_CRYPTO_hash_xor(&zone_hash, &name_hash, &xor_hash);
   GNUNET_DHT_put (dht_handle, &xor_hash,
                   5, //replication level
                   GNUNET_DHT_RO_NONE,
                   GNUNET_BLOCK_TYPE_TEST, //FIXME todo block plugin
-                  (data_ptr-data),
-                  data,
-                  expiration, //FIXME from record makes sense? is absolute?
+                  rd->data_size,
+                  rd->data,
+                  expiration,
                   timeout,
                   NULL, //FIXME continuation needed? success check? yes ofc
                   NULL); //cls for cont
@@ -874,7 +833,7 @@ put_gns_record(void *cls, const GNUNET_HashCode *zone, const char *name,
    * Reschedule periodic put
    */
   GNUNET_SCHEDULER_add_delayed (dht_update_interval,
-                                &update_zone_dht,
+                                &update_zone_dht_next,
                                 NULL);
 
 }
@@ -886,12 +845,17 @@ put_gns_record(void *cls, const GNUNET_HashCode *zone, const char *name,
  * @param tc task context
  */
 static void
-update_zone_dht(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+update_zone_dht_start(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Update zone!\n");
-  GNUNET_NAMESTORE_zone_transfer (namestore_handle, &zone_hash,
-                                  &put_gns_record,
-                                  NULL);
+  dht_update_interval = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS,
+                                                     (3600/num_public_records));
+  namestore_iter = GNUNET_NAMESTORE_zone_iteration_start (namestore_handle,
+                                                          &zone_hash,
+                                                          GNUNET_NAMESTORE_RF_AUTHORITY,
+                                                          GNUNET_NAMESTORE_RF_PRIVATE,
+                                                          &put_gns_record,
+                                                          NULL);
 }
 
 /**
@@ -960,11 +924,12 @@ run (void *cls, struct GNUNET_SERVER_Handle *server,
   /**
    * Schedule periodic put
    * for our records
+   * We have roughly an hour for all records;
    */
   dht_update_interval = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS,
                                                       60); //FIXME from cfg
   GNUNET_SCHEDULER_add_delayed (dht_update_interval,
-                                &update_zone_dht,
+                                &update_zone_dht_start,
                                 NULL);
   GNUNET_log(GNUNET_ERROR_TYPE_INFO, "GNS Init done!\n");
 
diff --git a/src/gns/namestore_stub_api.c b/src/gns/namestore_stub_api.c
index 29a785a8a..d08de04cb 100644
--- a/src/gns/namestore_stub_api.c
+++ b/src/gns/namestore_stub_api.c
@@ -146,56 +146,40 @@ struct GNUNET_NAMESTORE_QueueEntry *
 GNUNET_NAMESTORE_record_put (struct GNUNET_NAMESTORE_Handle *h,
                              const GNUNET_HashCode *zone,
                              const char *name,
-                             uint32_t record_type,
                              struct GNUNET_TIME_Absolute expiration,
-                             enum GNUNET_NAMESTORE_RecordFlags flags,
-                             size_t data_size,
-                             const void *data, 
-                             GNUNET_NAMESTORE_ContinuationWithStatus cont,
+                             unsigned int rd_count,
+           const struct GNUNET_NAMESTORE_RecordData *rd,
+           const struct GNUNET_CRYPTO_RsaSignature *signature,
+           GNUNET_NAMESTORE_ContinuationWithStatus cont,
                              void *cont_cls)
 {
   struct GNUNET_NAMESTORE_QueueEntry *qe;
   qe = GNUNET_malloc(sizeof (struct GNUNET_NAMESTORE_QueueEntry));
-
-  struct GNUNET_NAMESTORE_SimpleRecord *sr;
-  sr = GNUNET_malloc(sizeof(struct GNUNET_NAMESTORE_SimpleRecord));
-  sr->name = name;
-  sr->record_type = record_type;
-  sr->expiration = expiration;
-  sr->flags = flags;
-  sr->data_size = data_size;
-  sr->data = data;
-  GNUNET_CONTAINER_DLL_insert(h->records_head, h->records_tail, sr);
+  //FIXME
   return qe;
 }
 
-/**
- * Store a signature in the namestore. 
- *
- * @param h handle to the namestore
- * @param zone hash of the public key of the zone
- * @param name name that is being mapped (at most 255 characters long)
- * @param record_type type of the record (A, AAAA, PKEY, etc.)
- * @param expiration expiration time for the content
- * @param flags flags for the content
- * @param data_size number of bytes in data
- * @param data value, semantics depend on 'record_type' (see RFCs for DNS and 
- *             GNS specification for GNS extensions)
- * @param cont continuation to call when done
- * @param cont_cls closure for cont
- * @return handle to abort the request
- */
+int
+GNUNET_NAMESTORE_verify_signature (const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *public_key,
+                                   const char *name,
+                                   unsigned int rd_count,
+                                   const struct GNUNET_NAMESTORE_RecordData *rd,
+                                   const struct GNUNET_CRYPTO_RsaSignature *signature)
+{
+  return GNUNET_OK;
+}
+
 struct GNUNET_NAMESTORE_QueueEntry *
-GNUNET_NAMESTORE_signature_put (struct GNUNET_NAMESTORE_Handle *h,
-                             const GNUNET_HashCode *zone,
+GNUNET_NAMESTORE_record_create (struct GNUNET_NAMESTORE_Handle *h,
+                             const struct GNUNET_CRYPTO_RsaPrivateKey *pkey,
                              const char *name,
-           struct GNUNET_CRYPTO_RsaSignature sig,
-                             GNUNET_NAMESTORE_ContinuationWithStatus cont,
+           const struct GNUNET_NAMESTORE_RecordData *rd,
+           GNUNET_NAMESTORE_ContinuationWithStatus cont,
                              void *cont_cls)
 {
   struct GNUNET_NAMESTORE_QueueEntry *qe;
   qe = GNUNET_malloc(sizeof (struct GNUNET_NAMESTORE_QueueEntry));
-
+  //FIXME
   return qe;
 }
 
@@ -217,30 +201,16 @@ GNUNET_NAMESTORE_signature_put (struct GNUNET_NAMESTORE_Handle *h,
  */
 struct GNUNET_NAMESTORE_QueueEntry *
 GNUNET_NAMESTORE_record_remove (struct GNUNET_NAMESTORE_Handle *h,
-                                const GNUNET_HashCode *zone, 
+                                const struct GNUNET_CRYPTO_RsaPrivateKey *pkey,
                                 const char *name,
-                                uint32_t record_type,
-                                size_t size,
-                                const void *data, 
-                                GNUNET_NAMESTORE_ContinuationWithStatus cont,
+                                const struct GNUNET_NAMESTORE_RecordData *rd,
+        GNUNET_NAMESTORE_ContinuationWithStatus cont,
                                 void *cont_cls)
 {
   struct GNUNET_NAMESTORE_QueueEntry *qe;
   qe = GNUNET_malloc(sizeof (struct GNUNET_NAMESTORE_QueueEntry));
   
-  struct GNUNET_NAMESTORE_SimpleRecord *iter;
-  for (iter=h->records_head; iter != NULL; iter=iter->next)
-  {
-    if (strcmp ( iter->name, name ) &&
-        iter->record_type == record_type &&
-        GNUNET_CRYPTO_hash_cmp (iter->zone, zone))
-      break;
-  }
-  if (iter)
-    GNUNET_CONTAINER_DLL_remove(h->records_head,
-                                h->records_tail,
-                                iter);
-  
+  //FIXME
   return qe;
 }
 
@@ -268,107 +238,33 @@ GNUNET_NAMESTORE_lookup_record (struct GNUNET_NAMESTORE_Handle *h,
   struct GNUNET_NAMESTORE_QueueEntry *qe;
   qe = GNUNET_malloc(sizeof (struct GNUNET_NAMESTORE_QueueEntry));
 
-  struct GNUNET_NAMESTORE_SimpleRecord *iter;
-  for (iter=h->records_head; iter != NULL; iter=iter->next)
-  {
-    if (strcmp(iter->name, name))
-      continue;
-
-    if (iter->record_type != record_type)
-      continue;
-
-    proc(proc_cls, iter->zone, iter->name, iter->record_type,
-       iter->expiration,
-       iter->flags,
-       iter->data_size /*size*/,
-       iter->data /* data */);
-  }
-  proc(proc_cls, zone, name, record_type,
-       GNUNET_TIME_absolute_get_forever(), 0, 0, NULL); /*TERMINATE*/
-
+  //FIXME
   return qe;
 }
 
-struct GNUNET_NAMESTORE_QueueEntry *
-GNUNET_NAMESTORE_lookup_signature (struct GNUNET_NAMESTORE_Handle *h,
-                                   const GNUNET_HashCode *zone,
-                                   const char* name,
-                                   GNUNET_NAMESTORE_SignatureProcessor proc,
-                                   void *proc_cls)
+struct GNUNET_NAMESTORE_ZoneIterator *
+GNUNET_NAMESTORE_zone_iteration_start(struct GNUNET_NAMESTORE_Handle *h,
+                                      const GNUNET_HashCode *zone,
+                                      enum GNUNET_NAMESTORE_RecordFlags must_have_flags,
+                                      enum GNUNET_NAMESTORE_RecordFlags must_not_have_flags,
+                                      GNUNET_NAMESTORE_RecordProcessor proc,
+                                      void *proc_cls)
 {
-  return NULL;
+  struct GNUNET_NAMESTORE_ZoneIterator *it;
+  it = GNUNET_malloc(sizeof(struct GNUNET_NAMESTORE_ZoneIterator));
+  return it;
 }
 
-
-/**
- * Get the hash of a record (what will be signed in the Stree for
- * the record).
- *
- * @param zone hash of the public key of the zone
- * @param name name that is being mapped (at most 255 characters long)
- * @param record_type type of the record (A, AAAA, PKEY, etc.)
- * @param expiration expiration time for the content
- * @param flags flags for the content
- * @param data_size number of bytes in data
- * @param data value, semantics depend on 'record_type' (see RFCs for DNS and.
- *             GNS specification for GNS extensions)
- * @param record_hash hash of the record (set)
- */
 void
-GNUNET_NAMESTORE_record_hash (struct GNUNET_NAMESTORE_Handle *h,
-                              const GNUNET_HashCode *zone,
-                              const char *name,
-                              uint32_t record_type,
-                              struct GNUNET_TIME_Absolute expiration,
-                              enum GNUNET_NAMESTORE_RecordFlags flags,
-                              size_t data_size,
-                              const void *data,
-                              GNUNET_HashCode *record_hash)
+GNUNET_NAMESTORE_zone_iterator_next(struct GNUNET_NAMESTORE_ZoneIterator *it)
 {
-  char* teststring = "namestore-stub";
-  GNUNET_CRYPTO_hash(teststring, strlen(teststring), record_hash);
 }
 
-
-/**
- * Get all records of a zone.
- *
- * @param h handle to the namestore
- * @param zone zone to access
- * @param proc function to call on a random value; it
- *        will be called repeatedly with a value (if available)
- *        and always once at the end with a zone and name of NULL.
- * @param proc_cls closure for proc
- * @return a handle that can be used to
- *         cancel
- */
-struct GNUNET_NAMESTORE_QueueEntry *
-GNUNET_NAMESTORE_zone_transfer (struct GNUNET_NAMESTORE_Handle *h,
-                                const GNUNET_HashCode *zone,
-                                GNUNET_NAMESTORE_RecordProcessor proc,
-                                void *proc_cls)
+void
+GNUNET_NAMESTORE_zone_iteration_stop(struct GNUNET_NAMESTORE_ZoneIterator *it)
 {
-  struct GNUNET_NAMESTORE_QueueEntry *qe;
-  qe = GNUNET_malloc(sizeof (struct GNUNET_NAMESTORE_QueueEntry));
-  return qe;
 }
 
-struct GNUNET_NAMESTORE_ZoneIterator *
-GNUNET_NAMESTORE_zone_iteration_start(struct GNUNET_NAMESTORE_Handle *h,
-                                      const GNUNET_HashCode *zone,
-                                      GNUNET_NAMESTORE_RecordProcessor proc,
-                                      void *proc_cls);
-
-int
-GNUNET_NAMESTORE_zone_iterator_next(struct GNUNET_NAMESTORE_ZoneIterator *it);
-
-void
-GNUNET_NAMESTORE_zone_iteration_stop(struct GNUNET_NAMESTORE_ZoneIterator *it);
-
-void
-GNUNET_NAMESTORE_cancel (struct GNUNET_NAMESTORE_QueueEntry *qe);
-
-
 /**
  * Cancel a namestore operation.  The final callback from the
  * operation must not have been done yet.