-removing unnecessary key from regex blocks, compacting some of the other fields

7 files changed, 232 insertions, 151 deletions

diff --git a/src/include/block_regex.h b/src/include/block_regex.h
index 282c626a2..73d7b70a5 100644
--- a/src/include/block_regex.h
+++ b/src/include/block_regex.h
@@ -39,77 +39,75 @@ extern "C"
 #include <stdint.h>
 
 
+GNUNET_NETWORK_STRUCT_BEGIN
+
+
 /**
  * @brief A RegexBlock contains one or more of this struct in the payload.
  */
 struct RegexEdge
 {
-      /**
-       * Destination of this edge.
-       */
-    struct GNUNET_HashCode key;
-
-      /**
-       * Length of the token towards the new state.
-       */
-    unsigned int n_token;
-
-    /* char token[n_token] */
+  /**
+   * Destination of this edge.
+   */
+  struct GNUNET_HashCode key;
+  
+  /**
+   * Length of the token towards the new state.
+   */
+  uint32_t n_token GNUNET_PACKED;
+
+  /* char token[n_token] */
 };
 
+
 /**
  * @brief Block to announce a regex state.
  */
 struct RegexBlock
 {
-      /**
-       * The key of the state.
-       */
-    struct GNUNET_HashCode key;
-
-      /**
-       * Length of the proof regex string.
-       */
-    unsigned int n_proof;
-
-      /**
-       * Numer of edges parting from this state.
-       */
-    unsigned int n_edges;
-
-      /**
-       * Is this state an accepting state?
-       */
-    int accepting;
-
-    /* char proof[n_proof] */
-    /* struct RegexEdge edges[n_edges] */
+
+  /**
+   * Length of the proof regex string.
+   */
+  uint16_t proof_len GNUNET_PACKED;
+
+  /**
+   * Is this state an accepting state?
+   */
+  int16_t is_accepting GNUNET_PACKED;
+
+  /**
+   * Numer of edges parting from this state.
+   */
+  uint32_t n_edges GNUNET_PACKED;
+
+  /* char proof[n_proof] */
+  /* struct RegexEdge edges[n_edges] */
 };
 
+
 /**
  * @brief Block to announce a peer accepting a state.
  */
 struct RegexAccept
 {
-      /**
-       * The key of the state.
-       */
-    struct GNUNET_HashCode key;
-
-      /**
-       * Length of the proof regex string.
-       * FIXME necessary???
-       * already present in the leading MeshRegexBlock
-       */
-    // unsigned int n_proof;
-
-      /**
-       * The identity of the peer accepting the state
-       */
-    struct GNUNET_PeerIdentity id;
+  /**
+   * The key of the state.
+   */
+  struct GNUNET_HashCode key;
+  
+  /**
+   * The identity of the peer accepting the state
+   */
+  struct GNUNET_PeerIdentity id;
 
 };
 
+
+GNUNET_NETWORK_STRUCT_END
+
+
 #if 0                           /* keep Emacsens' auto-indent happy */
 {
 #endif
@@ -117,4 +115,4 @@ struct RegexAccept
 }
 #endif
 
-#endif
\ No newline at end of file
+#endif
diff --git a/src/include/gnunet_namestore_service.h b/src/include/gnunet_namestore_service.h
index 38083ed9c..418813734 100644
--- a/src/include/gnunet_namestore_service.h
+++ b/src/include/gnunet_namestore_service.h
@@ -1,10 +1,10 @@
 /*
      This file is part of GNUnet
-     (C) 2012 Christian Grothoff (and other contributing authors)
+     (C) 2012, 2013 Christian Grothoff (and other contributing authors)
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
-     by the Free Software Foundation; either version 2, or (at your
+     by the Free Software Foundation; either version 3, or (at your
      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but
@@ -225,9 +225,8 @@ struct GNUNET_NAMESTORE_RecordData
 
 /**
  * Store an item in the namestore.  If the item is already present,
- * the expiration time is updated to the max of the existing time and
- * the new time.  This API is used when we cache signatures from other
- * authorities.
+ * it is replaced with the new record.  Use an empty array to
+ * remove all records under the given name.
  *
  * @param h handle to the namestore
  * @param zone_key public key of the zone
@@ -276,49 +275,26 @@ GNUNET_NAMESTORE_verify_signature (const struct GNUNET_CRYPTO_EccPublicKeyBinary
 
 /**
  * Store an item in the namestore.  If the item is already present,
- * the expiration time is updated to the max of the existing time and
- * the new time.  This API is used by the authority of a zone.
- * FIXME: consider allowing to pass multiple records in one call!
+ * it is replaced with the new record.  Use an empty array to
+ * remove all records under the given name.
  *
  * @param h handle to the namestore
  * @param pkey private key of the zone
  * @param name name that is being mapped (at most 255 characters long)
- * @param rd record data to store
- * @param cont continuation to call when done
- * @param cont_cls closure for cont
- * @return handle to abort the request
- */
-struct GNUNET_NAMESTORE_QueueEntry *
-GNUNET_NAMESTORE_record_create (struct GNUNET_NAMESTORE_Handle *h,
-                                const struct GNUNET_CRYPTO_EccPrivateKey *pkey,
-                                const char *name,
-                                const struct GNUNET_NAMESTORE_RecordData *rd,
-                                GNUNET_NAMESTORE_ContinuationWithStatus cont,
-                                void *cont_cls);
-
-
-/**
- * Explicitly remove some content from the database.  The
- * "cont"inuation will be called with status "GNUNET_OK" if content
- * was removed, "GNUNET_NO" if no matching entry was found and
- * "GNUNET_SYSERR" on all other types of errors.
- * This API is used by the authority of a zone.
- *
- * @param h handle to the namestore
- * @param pkey private key of the zone
- * @param name name that is being mapped (at most 255 characters long)
- * @param rd record data, remove specific record,  NULL to remove the name and all records
+ * @param rd_count number of records in the 'rd' array
+ * @param rd array of records with data to store
  * @param cont continuation to call when done
- * @param cont_cls closure for cont
+ * @param cont_cls closure for 'cont'
  * @return handle to abort the request
  */
 struct GNUNET_NAMESTORE_QueueEntry *
-GNUNET_NAMESTORE_record_remove (struct GNUNET_NAMESTORE_Handle *h,
-                                const struct GNUNET_CRYPTO_EccPrivateKey *pkey,
-                                const char *name,
-                                const struct GNUNET_NAMESTORE_RecordData *rd,
-                                GNUNET_NAMESTORE_ContinuationWithStatus cont,
-                                void *cont_cls);
+GNUNET_NAMESTORE_record_put_by_authority (struct GNUNET_NAMESTORE_Handle *h,
+                                          const struct GNUNET_CRYPTO_EccPrivateKey *pkey,
+                                          const char *name,
+                                          unsigned int rd_count,
+                                          const struct GNUNET_NAMESTORE_RecordData *rd,
+                                          GNUNET_NAMESTORE_ContinuationWithStatus cont,
+                                          void *cont_cls);
 
 
 /**
@@ -341,7 +317,7 @@ typedef void (*GNUNET_NAMESTORE_RecordProcessor) (void *cls,
                                                   const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
                                                   struct GNUNET_TIME_Absolute freshness,                            
                                                   const char *name,
-                                                  unsigned int rd_len,
+                                                  unsigned int rd_count,
                                                   const struct GNUNET_NAMESTORE_RecordData *rd,
                                                   const struct GNUNET_CRYPTO_EccSignature *signature);
 
@@ -462,6 +438,64 @@ GNUNET_NAMESTORE_zone_iteration_stop (struct GNUNET_NAMESTORE_ZoneIterator *it);
 
 
 /**
+ * Handle for a monitoring activity.
+ */
+struct GNUNET_NAMESTORE_ZoneMonitor;
+
+
+/**
+ * Function called whenever the records for a given name changed.
+ *
+ * @param cls closure
+ * @param was_removed GNUNET_NO if the record was added, GNUNET_YES if it was removed
+ * @param freshness when does the corresponding block in the DHT expire (until
+ *               when should we never do a DHT lookup for the same name again)?; 
+ *               GNUNET_TIME_UNIT_ZERO_ABS if there are no records of any type in the namestore,
+ *               or the expiration time of the block in the namestore (even if there are zero
+ *               records matching the desired record type)
+ * @param name name that is being mapped (at most 255 characters long)
+ * @param rd_count number of entries in 'rd' array
+ * @param rd array of records with data to store
+ * @param signature signature of the record block
+ */
+typedef void (*GNUNET_NAMESTORE_RecordMonitor)(void *cls,
+                                               int was_removed,
+                                               const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
+                                               struct GNUNET_TIME_Absolute freshness,                       
+                                               const char *name,
+                                               unsigned int rd_len,
+                                               const struct GNUNET_NAMESTORE_RecordData *rd,
+                                               const struct GNUNET_CRYPTO_EccSignature *signature);
+
+
+/**
+ * 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 monitor function to call on zone changes
+ * @param monitor_cls closure for 'monitor'
+ * @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,
+                                     GNUNET_NAMESTORE_RecordMonitor monitor,
+                                     void *monitor_cls);
+
+
+/**
+ * Stop monitoring a zone for changes.
+ *
+ * @param zm handle to the monitor activity to stop
+ */
+void
+GNUNET_NAMESTORE_zone_monitor_stop (struct GNUNET_NAMESTORE_ZoneMonitor *zm);
+
+
+/**
  * Cancel a namestore operation.  The final callback from the
  * operation must not have been done yet.  Must be called on any
  * namestore operation that has not yet completed prior to calling
@@ -473,7 +507,6 @@ void
 GNUNET_NAMESTORE_cancel (struct GNUNET_NAMESTORE_QueueEntry *qe);
 
 
-
 /* convenience APIs for serializing / deserializing GNS records */
 
 /**
@@ -579,6 +612,7 @@ GNUNET_NAMESTORE_number_to_typename (uint32_t type);
 /**
  * Test if a given record is expired.
  * 
+ * @param rd record to test
  * @return GNUNET_YES if the record is expired,
  *         GNUNET_NO if not
  */
diff --git a/src/regex/plugin_block_regex.c b/src/regex/plugin_block_regex.c
index e17b34d33..9eeb13190 100644
--- a/src/regex/plugin_block_regex.c
+++ b/src/regex/plugin_block_regex.c
@@ -80,7 +80,7 @@ rdebug (void *cls,
  */
 static enum GNUNET_BLOCK_EvaluationResult
 evaluate_block_regex (void *cls, enum GNUNET_BLOCK_Type type,
-                      const struct GNUNET_HashCode * query,
+                      const struct GNUNET_HashCode *query,
                       struct GNUNET_CONTAINER_BloomFilter **bf,
                       int32_t bf_mutator, const void *xquery,
                       size_t xquery_size, const void *reply_block,
@@ -106,15 +106,16 @@ evaluate_block_regex (void *cls, enum GNUNET_BLOCK_Type type,
 
     GNUNET_break_op (0);
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
-                "Block with no xquery, key: %s, %u edges\n",
-                GNUNET_h2s (&rblock->key), 
+                "Block with no xquery, query: %s, %u edges\n",
+                GNUNET_h2s (query), 
                 ntohl (rblock->n_edges));
     REGEX_BLOCK_iterate (rblock, reply_block_size, &rdebug, NULL);
     return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
   }
   switch (REGEX_BLOCK_check (reply_block,
-                                      reply_block_size,
-                                      xquery))
+                             reply_block_size,
+                             query,
+                             xquery))
   {
     case GNUNET_SYSERR:
       GNUNET_break_op(0);
@@ -276,12 +277,15 @@ block_plugin_regex_get_key (void *cls, enum GNUNET_BLOCK_Type type,
                             const void *block, size_t block_size,
                             struct GNUNET_HashCode * key)
 {
+  int ret;
+
   switch (type)
   {
     case GNUNET_BLOCK_TYPE_REGEX:
-      GNUNET_assert (sizeof (struct RegexBlock) <= block_size);
-      *key = ((struct RegexBlock *) block)->key;
-      return GNUNET_OK;
+      ret = REGEX_BLOCK_get_key (block, block_size,
+                                 key);
+      GNUNET_break_op (GNUNET_OK == ret);
+      return ret;
     case GNUNET_BLOCK_TYPE_REGEX_ACCEPT:
       GNUNET_assert (sizeof (struct RegexAccept) <= block_size);
       *key = ((struct RegexAccept *) block)->key;
diff --git a/src/regex/regex_block_lib.c b/src/regex/regex_block_lib.c
index bd3ec9679..01c591caa 100644
--- a/src/regex/regex_block_lib.c
+++ b/src/regex/regex_block_lib.c
@@ -40,8 +40,8 @@
  */
 int
 REGEX_BLOCK_check_proof (const char *proof,
-                            size_t proof_len,
-                            const struct GNUNET_HashCode *key)
+                         size_t proof_len,
+                         const struct GNUNET_HashCode *key)
 {
   struct GNUNET_HashCode key_check;
 
@@ -50,7 +50,6 @@ REGEX_BLOCK_check_proof (const char *proof,
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Proof check failed, was NULL.\n");
     return GNUNET_NO;
   }
-
   GNUNET_CRYPTO_hash (proof, proof_len, &key_check);
   return (0 ==
           GNUNET_CRYPTO_hash_cmp (key, &key_check)) ? GNUNET_OK : GNUNET_NO;
@@ -72,10 +71,6 @@ struct CheckEdgeContext
    */
   int found;
 
-  /**
-   * Key of the block we are iterating (for debug purposes).
-   */
-  char *key;
 };
 
 
@@ -99,7 +94,7 @@ check_edge (void *cls,
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
               "edge %.*s [%u]: %s->%s\n",
-              (int) len, token, len, ctx->key, GNUNET_h2s(key));
+              (int) len, token, len, GNUNET_h2s(key));
   if (NULL == ctx->xquery)
     return GNUNET_YES;
   if (strlen (ctx->xquery) < len)
@@ -115,6 +110,7 @@ check_edge (void *cls,
  *
  * @param block The start of the block.
  * @param size The size of the block.
+ * @param query the query for the block
  * @param xquery String describing the edge we are looking for.
  *               Can be NULL in case this is a put block.
  *
@@ -125,34 +121,33 @@ check_edge (void *cls,
 int
 REGEX_BLOCK_check (const struct RegexBlock *block,
                    size_t size,
+                   const struct GNUNET_HashCode *query,
                    const char *xquery)
 {
   struct CheckEdgeContext ctx;
   int res;
-  uint32_t len;
+  uint16_t len;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Checking block with xquery `%s'\n",
               NULL != xquery ? xquery : "NULL");
-  len = ntohl (block->n_proof);
+  len = ntohs (block->proof_len);
   if (size < sizeof (struct RegexBlock) + len)
   {
     GNUNET_break_op (0);
     return GNUNET_SYSERR;
   }
-  if (GNUNET_OK != REGEX_BLOCK_check_proof ((const char *) &block[1], len, &block->key))
+  if (GNUNET_OK != REGEX_BLOCK_check_proof ((const char *) &block[1], len, query))
   {
     GNUNET_break_op (0);
     return GNUNET_SYSERR;
   }
-  if ( (GNUNET_YES == ntohl (block->accepting)) &&
+  if ( (GNUNET_YES == ntohs (block->is_accepting)) &&
        ( (NULL == xquery) || ('\0' == xquery[0]) ) )
     return GNUNET_OK;
   ctx.xquery = xquery;
   ctx.found = GNUNET_NO;
-  ctx.key = GNUNET_strdup (GNUNET_h2s (&block->key));
   res = REGEX_BLOCK_iterate (block, size, &check_edge, &ctx);
-  GNUNET_free (ctx.key);
   if (GNUNET_SYSERR == res)
     return GNUNET_SYSERR;
   if (NULL == xquery)
@@ -162,6 +157,32 @@ REGEX_BLOCK_check (const struct RegexBlock *block,
 
 
 /**
+ * Obtain the key that a particular block is to be stored under.
+ *
+ * @param block block to get the key from
+ * @param block_len number of bytes in block
+ * @param query where to store the key
+ * @return GNUNET_OK on success, GNUNET_SYSERR if the block is malformed
+ */
+int
+REGEX_BLOCK_get_key (const struct RegexBlock *block,
+                     size_t block_len,
+                     struct GNUNET_HashCode *key)
+{
+  uint16_t len;
+
+  len = ntohs (block->proof_len);
+  if (block_len < sizeof (struct RegexBlock) + len)
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_CRYPTO_hash (&block[1], len, key);
+  return GNUNET_OK;
+}
+
+
+/**
  * Iterate over all edges of a block of a regex state.
  *
  * @param block Block to iterate over.
@@ -179,9 +200,9 @@ REGEX_BLOCK_check (const struct RegexBlock *block,
  */
 int
 REGEX_BLOCK_iterate (const struct RegexBlock *block,
-                            size_t size,
-                            REGEX_INTERNAL_EgdeIterator iterator,
-                            void *iter_cls)
+                     size_t size,
+                     REGEX_INTERNAL_EgdeIterator iterator,
+                     void *iter_cls)
 {
   struct RegexEdge *edge;
   unsigned int n;
@@ -196,7 +217,7 @@ REGEX_BLOCK_iterate (const struct RegexBlock *block,
     GNUNET_break_op (0);
     return GNUNET_SYSERR;
   }
-  n = ntohl (block->n_proof);
+  n = ntohs (block->proof_len);
   offset += n;
   if (offset >= size) /* Is it safe to access the regex proof? */
   {
@@ -208,7 +229,7 @@ REGEX_BLOCK_iterate (const struct RegexBlock *block,
   n = ntohl (block->n_edges);
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Start iterating block of size %u, proof %u, off %u edges %u\n",
-       size, ntohl (block->n_proof), offset, n);
+       size, ntohs (block->proof_len), offset, n);
   /* aux always points at the end of the previous block */
   for (i = 0; i < n; i++)
   {
@@ -257,15 +278,16 @@ REGEX_BLOCK_iterate (const struct RegexBlock *block,
  * @param proof proof string for the block
  * @param num_edges number of edges in the block
  * @param edges the edges of the block
- * @return the regex block
+ * @param accepting is this an accepting state
+ * @param rsize set to the size of the returned block (OUT-only)
+ * @return the regex block, NULL on error
  */
 struct RegexBlock *
-REGEX_BLOCK_create (const struct GNUNET_HashCode *key,
-                             const char *proof,
-                             unsigned int num_edges,
-                             const struct REGEX_BLOCK_Edge *edges,
-                             int accepting,
-                             size_t *rsize)
+REGEX_BLOCK_create (const char *proof,
+                    unsigned int num_edges,
+                    const struct REGEX_BLOCK_Edge *edges,
+                    int accepting,
+                    size_t *rsize)
 {
   struct RegexBlock *block;
   struct RegexEdge *block_edge;
@@ -275,13 +297,17 @@ REGEX_BLOCK_create (const struct GNUNET_HashCode *key,
   unsigned int offset;
   char *aux;
 
-  len = strlen(proof);
+  len = strlen (proof);
+  if (len > UINT16_MAX)
+    {
+      GNUNET_break (0);
+      return NULL;
+    }
   size = sizeof (struct RegexBlock) + len;
   block = GNUNET_malloc (size);
-  block->key = *key;
-  block->n_proof = htonl (len);
+  block->proof_len = htons (len);
   block->n_edges = htonl (num_edges);
-  block->accepting = htonl (accepting);
+  block->is_accepting = htons (accepting);
 
   /* Store the proof at the end of the block. */
   aux = (char *) &block[1];
diff --git a/src/regex/regex_block_lib.h b/src/regex/regex_block_lib.h
index 985296b4f..dec025205 100644
--- a/src/regex/regex_block_lib.h
+++ b/src/regex/regex_block_lib.h
@@ -68,8 +68,8 @@ struct REGEX_BLOCK_Edge
  */
 int
 REGEX_BLOCK_check_proof (const char *proof,
-                            size_t proof_len,
-                            const struct GNUNET_HashCode *key);
+                         size_t proof_len,
+                         const struct GNUNET_HashCode *key);
 
 
 /**
@@ -77,6 +77,7 @@ REGEX_BLOCK_check_proof (const char *proof,
  *
  * @param block The start of the block.
  * @param size The size of the block.
+ * @param query the query for the block
  * @param xquery String describing the edge we are looking for.
  *               Can be NULL in case this is a put block.
  *
@@ -87,6 +88,7 @@ REGEX_BLOCK_check_proof (const char *proof,
 int
 REGEX_BLOCK_check (const struct RegexBlock *block,
                    size_t size,
+                   const struct GNUNET_HashCode *query,
                    const char *xquery);
 
 
@@ -130,6 +132,20 @@ REGEX_BLOCK_iterate (const struct RegexBlock *block,
                             REGEX_INTERNAL_EgdeIterator iterator,
                             void *iter_cls);
 
+/**
+ * Obtain the key that a particular block is to be stored under.
+ *
+ * @param block block to get the key from
+ * @param block_len number of bytes in block
+ * @param query where to store the key
+ * @return GNUNET_OK on success, GNUNET_SYSERR if the block is malformed
+ */
+int
+REGEX_BLOCK_get_key (const struct RegexBlock *block,
+                     size_t block_len,
+                     struct GNUNET_HashCode *key);
+
+
 
 /**
  * Construct a regex block to be stored in the DHT.
@@ -137,15 +153,16 @@ REGEX_BLOCK_iterate (const struct RegexBlock *block,
  * @param proof proof string for the block
  * @param num_edges number of edges in the block
  * @param edges the edges of the block
- * @return the regex block
+ * @param accepting is this an accepting state
+ * @param rsize set to the size of the returned block (OUT-only)
+ * @return the regex block, NULL on error
  */
 struct RegexBlock *
-REGEX_BLOCK_create (const struct GNUNET_HashCode *key,
-                             const char *proof,
-                             unsigned int num_edges,
-                             const struct REGEX_BLOCK_Edge *edges,
-                             int accepting,
-                             size_t *rsize);
+REGEX_BLOCK_create (const char *proof,
+                    unsigned int num_edges,
+                    const struct REGEX_BLOCK_Edge *edges,
+                    int accepting,
+                    size_t *rsize);
 
 
 #if 0                           /* keep Emacsens' auto-indent happy */
diff --git a/src/regex/regex_internal_dht.c b/src/regex/regex_internal_dht.c
index af775ef95..e7259edcc 100644
--- a/src/regex/regex_internal_dht.c
+++ b/src/regex/regex_internal_dht.c
@@ -123,10 +123,10 @@ regex_iterator (void *cls,
                     DHT_TTL,
                     NULL, NULL);
   }
-  block = REGEX_BLOCK_create (key, proof,
-                                       num_edges, edges,
-                                       accepting,
-                                       &size);
+  block = REGEX_BLOCK_create (proof,
+                              num_edges, edges,
+                              accepting,
+                              &size);
   (void)
   GNUNET_DHT_put (h->dht, key,
                   DHT_REPLICATION,
@@ -420,20 +420,20 @@ dht_get_string_handler (void *cls, struct GNUNET_TIME_Absolute exp,
   GNUNET_break (
     GNUNET_OK ==
     GNUNET_CONTAINER_multihashmap_put (info->dht_get_results,
-                                       &((struct RegexBlock *)copy)->key, copy,
+                                       key, copy,
                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)
                );
   len = strlen (info->description);
   if (len == ctx->position) // String processed
   {
-    if (GNUNET_YES == ntohl (block->accepting))
+    if (GNUNET_YES == ntohs (block->is_accepting))
     {
       regex_find_path (key, ctx);
     }
     else
     {
-      LOG (GNUNET_ERROR_TYPE_INFO, "  block not accepting!\n");
-      // FIXME REGEX this block not successful, wait for more? start timeout?
+      LOG (GNUNET_ERROR_TYPE_INFO, "block not accepting!\n");
+      /* FIXME REGEX this block not successful, wait for more? start timeout? */
     }
     return;
   }
@@ -457,7 +457,7 @@ regex_result_iterator (void *cls,
   struct RegexBlock *block = value;
   struct RegexSearchContext *ctx = cls;
 
-  if (GNUNET_YES == ntohl(block->accepting) &&
+  if (GNUNET_YES == ntohs (block->is_accepting) &&
       ctx->position == strlen (ctx->info->description))
   {
     LOG (GNUNET_ERROR_TYPE_INFO, " * Found accepting known block\n");
@@ -466,7 +466,7 @@ regex_result_iterator (void *cls,
   }
   LOG (GNUNET_ERROR_TYPE_DEBUG, "* %u, %u, [%u]\n",
        ctx->position, strlen(ctx->info->description),
-       ntohl(block->accepting));
+       ntohs (block->is_accepting));
 
   regex_next_edge (block, SIZE_MAX, ctx);
 
@@ -646,7 +646,7 @@ REGEX_INTERNAL_search (struct GNUNET_DHT_Handle *dht,
   h->callback_cls = callback_cls;
   h->stats = stats;
   h->dht_get_handles = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_NO);
-  h->dht_get_results = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_YES);
+  h->dht_get_results = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_NO);
 
   /* Initialize context */
   len = strlen (string);
diff --git a/src/set/gnunet-service-set.h b/src/set/gnunet-service-set.h
index 86dd0cfc0..26b1d361e 100644
--- a/src/set/gnunet-service-set.h
+++ b/src/set/gnunet-service-set.h
@@ -196,7 +196,8 @@ struct Incoming;
 /**
  * Different types a tunnel can be.
  */
-enum TunnelContextType {
+enum TunnelContextType 
+{
   /**
    * Tunnel is waiting for a set request from the tunnel,
    * or for the ack/nack of the client for a received request.
@@ -237,6 +238,7 @@ union TunnelContextData
   struct IntersectionEvaluateOperation *intersection_op;
 };
 
+
 /**
  * Information about a tunnel we are connected to.
  * Used as tunnel context with mesh.