/*
This file is part of GNUnet
- (C) 2012 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2012, 2015 GNUnet e.V.
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
You should have received a copy of the GNU General Public License
along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
+ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
*/
/**
* @file src/regex/regex_internal_dht.c
#define LOG(kind,...) GNUNET_log_from (kind,"regex-dht",__VA_ARGS__)
+/**
+ * DHT replication level to use.
+ */
#define DHT_REPLICATION 5
+
+/**
+ * DHT record lifetime to use.
+ */
#define DHT_TTL GNUNET_TIME_UNIT_HOURS
+
+/**
+ * DHT options to set.
+ */
#define DHT_OPT GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE
/**
* Automaton representation of the regex (expensive to build).
*/
- struct REGEX_INTERNAL_Automaton* dfa;
+ struct REGEX_INTERNAL_Automaton *dfa;
/**
* Our private key.
*/
- const struct GNUNET_CRYPTO_EccPrivateKey *priv;
+ const struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
/**
* Optional statistics handle to report usage. Can be NULL.
* @param cls closure.
* @param key hash for current state.
* @param proof proof for current state.
- * @param accepting GNUNET_YES if this is an accepting state, GNUNET_NO if not.
+ * @param accepting #GNUNET_YES if this is an accepting state, #GNUNET_NO if not.
* @param num_edges number of edges leaving current state.
* @param edges edges leaving current state.
*/
struct REGEX_INTERNAL_Announcement *h = cls;
struct RegexBlock *block;
size_t size;
+ unsigned int i;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "DHT PUT for state %s with proof `%s' and %u edges\n",
+ LOG (GNUNET_ERROR_TYPE_INFO,
+ "DHT PUT for state %s with proof `%s' and %u edges:\n",
GNUNET_h2s (key),
proof,
num_edges);
+ for (i = 0; i < num_edges; i++)
+ {
+ LOG (GNUNET_ERROR_TYPE_INFO,
+ "Edge %u `%s' towards %s\n",
+ i,
+ edges[i].label,
+ GNUNET_h2s (&edges[i].destination));
+ }
if (GNUNET_YES == accepting)
{
struct RegexAcceptBlock ab;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
+ LOG (GNUNET_ERROR_TYPE_INFO,
"State %s is accepting, putting own id\n",
- GNUNET_h2s(key));
+ GNUNET_h2s (key));
size = sizeof (struct RegexAcceptBlock);
ab.purpose.size = ntohl (sizeof (struct GNUNET_CRYPTO_EccSignaturePurpose) +
- sizeof (struct GNUNET_TIME_AbsoluteNBO) +
- sizeof (struct GNUNET_HashCode));
+ sizeof (struct GNUNET_TIME_AbsoluteNBO) +
+ sizeof (struct GNUNET_HashCode));
ab.purpose.purpose = ntohl (GNUNET_SIGNATURE_PURPOSE_REGEX_ACCEPT);
ab.expiration_time = GNUNET_TIME_absolute_hton (GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_DHT_MAX_EXPIRATION));
ab.key = *key;
- GNUNET_CRYPTO_ecc_key_get_public_for_signature (h->priv,
- &ab.public_key);
+ GNUNET_CRYPTO_eddsa_key_get_public (h->priv,
+ &ab.peer.public_key);
GNUNET_assert (GNUNET_OK ==
- GNUNET_CRYPTO_ecc_sign (h->priv,
- &ab.purpose,
- &ab.signature));
+ GNUNET_CRYPTO_eddsa_sign (h->priv,
+ &ab.purpose,
+ &ab.signature));
GNUNET_STATISTICS_update (h->stats, "# regex accepting blocks stored",
1, GNUNET_NO);
NULL, NULL);
}
block = REGEX_BLOCK_create (proof,
- num_edges, edges,
- accepting,
- &size);
+ num_edges, edges,
+ accepting,
+ &size);
(void)
GNUNET_DHT_put (h->dht, key,
DHT_REPLICATION,
DHT_OPT,
- GNUNET_BLOCK_TYPE_REGEX,
- size, block,
+ GNUNET_BLOCK_TYPE_REGEX,
+ size, block,
GNUNET_TIME_relative_to_absolute (DHT_TTL),
DHT_TTL,
NULL, NULL);
- GNUNET_STATISTICS_update (h->stats, "# regex blocks stored",
+ GNUNET_STATISTICS_update (h->stats,
+ "# regex blocks stored",
1, GNUNET_NO);
- GNUNET_STATISTICS_update (h->stats, "# regex block bytes stored",
+ GNUNET_STATISTICS_update (h->stats,
+ "# regex block bytes stored",
size, GNUNET_NO);
GNUNET_free (block);
}
/**
* Announce a regular expression: put all states of the automaton in the DHT.
- * Does not free resources, must call REGEX_INTERNAL_announce_cancel for that.
- *
+ * Does not free resources, must call #REGEX_INTERNAL_announce_cancel() for that.
+ *
* @param dht An existing and valid DHT service handle. CANNOT be NULL.
* @param priv our private key, must remain valid until the announcement is cancelled
* @param regex Regular expression to announce.
* @param compression How many characters per edge can we squeeze?
* @param stats Optional statistics handle to report usage. Can be NULL.
- *
* @return Handle to reuse o free cached resources.
- * Must be freed by calling REGEX_INTERNAL_announce_cancel.
+ * Must be freed by calling #REGEX_INTERNAL_announce_cancel().
*/
struct REGEX_INTERNAL_Announcement *
REGEX_INTERNAL_announce (struct GNUNET_DHT_Handle *dht,
- const struct GNUNET_CRYPTO_EccPrivateKey *priv,
+ const struct GNUNET_CRYPTO_EddsaPrivateKey *priv,
const char *regex,
uint16_t compression,
struct GNUNET_STATISTICS_Handle *stats)
struct REGEX_INTERNAL_Announcement *h;
GNUNET_assert (NULL != dht);
- h = GNUNET_malloc (sizeof (struct REGEX_INTERNAL_Announcement));
+ h = GNUNET_new (struct REGEX_INTERNAL_Announcement);
h->regex = regex;
h->dht = dht;
h->stats = stats;
h->priv = priv;
- h->dfa = REGEX_INTERNAL_construct_dfa (regex,
- strlen (regex),
- compression);
+ h->dfa = REGEX_INTERNAL_construct_dfa (regex, strlen (regex), compression);
REGEX_INTERNAL_reannounce (h);
return h;
}
/**
* Announce again a regular expression previously announced.
* Does use caching to speed up process.
- *
- * @param h Handle returned by a previous REGEX_INTERNAL_announce call.
+ *
+ * @param h Handle returned by a previous #REGEX_INTERNAL_announce call().
*/
void
REGEX_INTERNAL_reannounce (struct REGEX_INTERNAL_Announcement *h)
{
GNUNET_assert (NULL != h->dfa); /* make sure to call announce first */
- LOG (GNUNET_ERROR_TYPE_INFO,
+ LOG (GNUNET_ERROR_TYPE_INFO,
"REGEX_INTERNAL_reannounce: %s\n",
h->regex);
- REGEX_INTERNAL_iterate_all_edges (h->dfa,
- ®ex_iterator, h);
+ REGEX_INTERNAL_iterate_reachable_edges (h->dfa,
+ ®ex_iterator,
+ h);
}
/**
* Clear all cached data used by a regex announce.
* Does not close DHT connection.
- *
- * @param h Handle returned by a previous REGEX_INTERNAL_announce call.
+ *
+ * @param h Handle returned by a previous #REGEX_INTERNAL_announce() call.
*/
void
REGEX_INTERNAL_announce_cancel (struct REGEX_INTERNAL_Announcement *h)
/**
- * Type of values in 'dht_get_results'.
- */
+ * Type of values in `dht_get_results`.
+ */
struct Result
{
/**
struct GNUNET_CONTAINER_MultiHashMap *dht_get_handles;
/**
- * Results from running DHT GETs, values are of type
+ * Results from running DHT GETs, values are of type
* 'struct Result'.
*/
struct GNUNET_CONTAINER_MultiHashMap *dht_get_results;
* Number of contexts (branches/steps in search).
*/
unsigned int n_contexts;
-
+
/**
* @param callback Callback for found peers.
*/
const struct RegexAcceptBlock *block = data;
struct RegexSearchContext *ctx = cls;
struct REGEX_INTERNAL_Search *info = ctx->info;
- struct GNUNET_PeerIdentity pid;
- LOG (GNUNET_ERROR_TYPE_DEBUG,
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
"Regex result accept for %s (key %s)\n",
info->description, GNUNET_h2s(key));
- GNUNET_STATISTICS_update (info->stats,
+ GNUNET_STATISTICS_update (info->stats,
"# regex accepting blocks found",
1, GNUNET_NO);
- GNUNET_STATISTICS_update (info->stats,
+ GNUNET_STATISTICS_update (info->stats,
"# regex accepting block bytes found",
size, GNUNET_NO);
- GNUNET_CRYPTO_hash (&block->public_key,
- sizeof (struct GNUNET_CRYPTO_EccPublicSignKey),
- &pid.hashPubKey);
info->callback (info->callback_cls,
- &pid,
+ &block->peer,
get_path, get_path_length,
put_path, put_path_length);
}
/**
- * Find a path to a peer that offers a regex servcie compatible
+ * Find a path to a peer that offers a regex service compatible
* with a given string.
- *
+ *
* @param key The key of the accepting state.
* @param ctx Context containing info about the string, tunnel, etc.
*/
struct GNUNET_DHT_GetHandle *get_h;
LOG (GNUNET_ERROR_TYPE_DEBUG,
- "regex finds path for %s\n",
- GNUNET_h2s (key));
+ "Accept state found, now searching for paths to %s\n",
+ GNUNET_h2s (key),
+ (unsigned int) ctx->position);
get_h = GNUNET_DHT_get_start (ctx->info->dht, /* handle */
GNUNET_BLOCK_TYPE_REGEX_ACCEPT, /* type */
key, /* key to search */
* @param exp when will this value expire
* @param key key of the result
* @param get_path path of the get request (not used)
- * @param get_path_length lenght of get_path (not used)
+ * @param get_path_length length of @a get_path (not used)
* @param put_path path of the put request (not used)
- * @param put_path_length length of the put_path (not used)
+ * @param put_path_length length of the @a put_path (not used)
* @param type type of the result
* @param size number of bytes in data
* @param data pointer to the result data
size_t len;
struct Result *copy;
- LOG (GNUNET_ERROR_TYPE_INFO,
+ LOG (GNUNET_ERROR_TYPE_INFO,
"DHT GET result for %s (%s)\n",
GNUNET_h2s (key), ctx->info->description);
copy = GNUNET_malloc (sizeof (struct Result) + size);
/**
- * Iterator over found existing mesh regex blocks that match an ongoing search.
+ * Iterator over found existing cadet regex blocks that match an ongoing search.
*
* @param cls Closure (current context)-
* @param key Current key code (key for cached block).
* @param value Value in the hash map (cached RegexBlock).
- * @return GNUNET_YES: we should always continue to iterate.
+ * @return #GNUNET_YES: we should always continue to iterate.
*/
static int
regex_result_iterator (void *cls,
const struct RegexBlock *block = result->data;
struct RegexSearchContext *ctx = cls;
- if ( (GNUNET_YES ==
+ if ( (GNUNET_YES ==
GNUNET_BLOCK_is_accepting (block, result->size)) &&
(ctx->position == strlen (ctx->info->description)) )
{
- LOG (GNUNET_ERROR_TYPE_INFO,
+ LOG (GNUNET_ERROR_TYPE_INFO,
"Found accepting known block\n");
regex_find_path (key, ctx);
return GNUNET_YES; // We found an accept state!
}
- LOG (GNUNET_ERROR_TYPE_DEBUG,
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
"* %u, %u, [%u]\n",
- ctx->position,
+ ctx->position,
strlen (ctx->info->description),
GNUNET_BLOCK_is_accepting (block, result->size));
regex_next_edge (block, result->size, ctx);
- GNUNET_STATISTICS_update (ctx->info->stats, "# regex mesh blocks iterated",
+ GNUNET_STATISTICS_update (ctx->info->stats, "# regex cadet blocks iterated",
1, GNUNET_NO);
return GNUNET_YES;
* @param token Token that follows to next state.
* @param len Lenght of token.
* @param key Hash of next state.
- *
- * @return GNUNET_YES if should keep iterating, GNUNET_NO otherwise.
+ * @return #GNUNET_YES if should keep iterating, #GNUNET_NO otherwise.
*/
static int
regex_edge_iterator (void *cls,
if (len > current_len)
{
LOG (GNUNET_ERROR_TYPE_DEBUG, "Token too long, END\n");
- return GNUNET_YES;
+ return GNUNET_YES;
}
if (0 != strncmp (current, token, len))
{
LOG (GNUNET_ERROR_TYPE_DEBUG, "Token doesn't match, END\n");
- return GNUNET_YES;
+ return GNUNET_YES;
}
if (len > ctx->longest_match)
int result;
LOG (GNUNET_ERROR_TYPE_DEBUG, "Next edge\n");
- /* Find the longest match for the current string position,
+ /* Find the longest match for the current string position,
* among tokens in the given block */
ctx->longest_match = 0;
result = REGEX_BLOCK_iterate (block, size,
/* Did anything match? */
if (0 == ctx->longest_match)
{
- LOG (GNUNET_ERROR_TYPE_DEBUG,
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
"no match in block\n");
return;
}
hash = &ctx->hash;
- new_ctx = GNUNET_malloc (sizeof (struct RegexSearchContext));
+ new_ctx = GNUNET_new (struct RegexSearchContext);
new_ctx->info = info;
new_ctx->position = ctx->position + ctx->longest_match;
GNUNET_array_append (info->contexts, info->n_contexts, new_ctx);
if (GNUNET_YES ==
GNUNET_CONTAINER_multihashmap_contains (info->dht_get_handles, hash))
{
- LOG (GNUNET_ERROR_TYPE_DEBUG,
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
"GET for %s running, END\n",
GNUNET_h2s (hash));
GNUNET_CONTAINER_multihashmap_get_multiple (info->dht_get_results,
GNUNET_STATISTICS_update (info->stats, "# regex nodes traversed",
1, GNUNET_NO);
- LOG (GNUNET_ERROR_TYPE_INFO,
- "looking for %s\n",
- GNUNET_h2s (hash));
+ LOG (GNUNET_ERROR_TYPE_DEBUG,
+ "Following edges at %s for offset %u in `%s'\n",
+ GNUNET_h2s (hash),
+ (unsigned int) ctx->position,
+ info->description);
rest = &new_ctx->info->description[new_ctx->position];
- get_h =
+ get_h =
GNUNET_DHT_get_start (info->dht, /* handle */
GNUNET_BLOCK_TYPE_REGEX, /* type */
hash, /* key to search */
/**
* Search for a peer offering a regex matching certain string in the DHT.
- * The search runs until REGEX_INTERNAL_search_cancel is called, even if results
+ * The search runs until #REGEX_INTERNAL_search_cancel() is called, even if results
* are returned.
*
* @param dht An existing and valid DHT service handle.
* @param callback Callback for found peers.
* @param callback_cls Closure for @c callback.
* @param stats Optional statistics handle to report usage. Can be NULL.
- *
* @return Handle to stop search and free resources.
- * Must be freed by calling REGEX_INTERNAL_search_cancel.
+ * Must be freed by calling #REGEX_INTERNAL_search_cancel().
*/
struct REGEX_INTERNAL_Search *
REGEX_INTERNAL_search (struct GNUNET_DHT_Handle *dht,
- const char *string,
- REGEX_INTERNAL_Found callback,
- void *callback_cls,
- struct GNUNET_STATISTICS_Handle *stats)
+ const char *string,
+ REGEX_INTERNAL_Found callback,
+ void *callback_cls,
+ struct GNUNET_STATISTICS_Handle *stats)
{
struct REGEX_INTERNAL_Search *h;
struct GNUNET_DHT_GetHandle *get_h;
size_t len;
/* Initialize handle */
- LOG (GNUNET_ERROR_TYPE_INFO, "REGEX_INTERNAL_search: %s\n", string);
GNUNET_assert (NULL != dht);
GNUNET_assert (NULL != callback);
- h = GNUNET_malloc (sizeof (struct REGEX_INTERNAL_Search));
+ h = GNUNET_new (struct REGEX_INTERNAL_Search);
h->dht = dht;
h->description = GNUNET_strdup (string);
h->callback = callback;
/* Initialize context */
len = strlen (string);
size = REGEX_INTERNAL_get_first_key (string, len, &key);
- ctx = GNUNET_malloc (sizeof (struct RegexSearchContext));
+ LOG (GNUNET_ERROR_TYPE_INFO,
+ "Initial key for `%s' is %s (based on `%.*s')\n",
+ string,
+ GNUNET_h2s (&key),
+ size,
+ string);
+ ctx = GNUNET_new (struct RegexSearchContext);
ctx->position = size;
ctx->info = h;
- GNUNET_array_append (h->contexts, h->n_contexts, ctx);
- LOG (GNUNET_ERROR_TYPE_DEBUG,
- "consumed %u bits out of %u, now looking for %s\n",
- size, len,
- GNUNET_h2s (&key));
-
+ GNUNET_array_append (h->contexts,
+ h->n_contexts,
+ ctx);
/* Start search in DHT */
get_h = GNUNET_DHT_get_start (h->dht, /* handle */
GNUNET_BLOCK_TYPE_REGEX, /* type */
* @param cls Closure (unused).
* @param key Current key code (unused).
* @param value Value in the hash map (get handle).
- * @return GNUNET_YES if we should continue to iterate,
- * GNUNET_NO if not.
+ * @return #GNUNET_YES if we should continue to iterate,
+ * #GNUNET_NO if not.
*/
static int
regex_cancel_dht_get (void *cls,
/**
- * Iterator over hash map entries to free MeshRegexBlocks stored during the
+ * Iterator over hash map entries to free CadetRegexBlocks stored during the
* search for connect_by_string.
*
* @param cls Closure (unused).
* @param key Current key code (unused).
- * @param value MeshRegexBlock in the hash map.
- * @return GNUNET_YES if we should continue to iterate,
- * GNUNET_NO if not.
+ * @param value CadetRegexBlock in the hash map.
+ * @return #GNUNET_YES if we should continue to iterate,
+ * #GNUNET_NO if not.
*/
static int
regex_free_result (void *cls,