Change regex combination, allow hex
[oweals/gnunet.git] / src / regex / regex_internal_lib.h
index 1c8946449a08d5850a440dc4447998a3602bc8e6..1156e33f3cf4ca2a773d9f0c48a0b51b16d2f316 100644 (file)
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet
-     (C) 2012, 2013 Christian Grothoff (and other contributing authors)
+     Copyright (C) 2012, 2013 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
@@ -14,8 +14,8 @@
 
      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 regex/regex_internal_lib.h
@@ -61,11 +61,12 @@ struct REGEX_INTERNAL_Automaton;
  * @param max_path_len limit the path compression length to the
  *        given value. If set to 1, no path compression is applied. Set to 0 for
  *        maximal possible path compression (generally not desireable).
- * @return DFA, needs to be freed using REGEX_INTERNAL_automaton_destroy.
+ * @return DFA, needs to be freed using #REGEX_INTERNAL_automaton_destroy().
  */
 struct REGEX_INTERNAL_Automaton *
-REGEX_INTERNAL_construct_dfa (const char *regex, const size_t len,
-                            unsigned int max_path_len);
+REGEX_INTERNAL_construct_dfa (const char *regex,
+                              const size_t len,
+                              unsigned int max_path_len);
 
 
 /**
@@ -88,36 +89,23 @@ REGEX_INTERNAL_automaton_destroy (struct REGEX_INTERNAL_Automaton *a);
  */
 int
 REGEX_INTERNAL_eval (struct REGEX_INTERNAL_Automaton *a,
-                   const char *string);
+                     const char *string);
 
 
 /**
- * Get the first key for the given 'input_string'. This hashes
- * the first x bits of the 'input_string'.
+ * Get the first key for the given @a input_string. This hashes
+ * the first x bits of the @a input_string.
  *
  * @param input_string string.
- * @param string_len length of the 'input_string'.
+ * @param string_len length of the @a input_string.
  * @param key pointer to where to write the hash code.
- *
- * @return number of bits of 'input_string' that have been consumed
+ * @return number of bits of @a input_string that have been consumed
  *         to construct the key
  */
 size_t
-REGEX_INTERNAL_get_first_key (const char *input_string, size_t string_len,
-                            struct GNUNET_HashCode * key);
-
-
-/**
- * Check if the given 'proof' matches the given 'key'.
- *
- * @param proof partial regex of a state.
- * @param key hash of a state.
- *
- * @return GNUNET_OK if the proof is valid for the given key.
- */
-int
-REGEX_INTERNAL_check_proof (const char *proof,
-                          const struct GNUNET_HashCode *key);
+REGEX_INTERNAL_get_first_key (const char *input_string,
+                              size_t string_len,
+                              struct GNUNET_HashCode * key);
 
 
 /**
@@ -125,17 +113,18 @@ REGEX_INTERNAL_check_proof (const char *proof,
  *
  * @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 proof proof for current state
+ * @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.
  */
-typedef void (*REGEX_INTERNAL_KeyIterator)(void *cls,
-                                         const struct GNUNET_HashCode *key,
-                                         const char *proof,
-                                         int accepting,
-                                         unsigned int num_edges,
-                                         const struct REGEX_BLOCK_Edge *edges);
+typedef void
+(*REGEX_INTERNAL_KeyIterator)(void *cls,
+                              const struct GNUNET_HashCode *key,
+                              const char *proof,
+                              int accepting,
+                              unsigned int num_edges,
+                              const struct REGEX_BLOCK_Edge *edges);
 
 
 /**
@@ -148,8 +137,24 @@ typedef void (*REGEX_INTERNAL_KeyIterator)(void *cls,
  */
 void
 REGEX_INTERNAL_iterate_all_edges (struct REGEX_INTERNAL_Automaton *a,
-                                REGEX_INTERNAL_KeyIterator iterator,
-                                void *iterator_cls);
+                                  REGEX_INTERNAL_KeyIterator iterator,
+                                  void *iterator_cls);
+
+
+/**
+ * Iterate over all edges of automaton 'a' that are reachable from a state with
+ * a proof of at least #GNUNET_REGEX_INITIAL_BYTES characters.
+ *
+ * Call the iterator for each such edge.
+ *
+ * @param a automaton.
+ * @param iterator iterator called for each reachable edge.
+ * @param iterator_cls closure.
+ */
+void
+REGEX_INTERNAL_iterate_reachable_edges (struct REGEX_INTERNAL_Automaton *a,
+                                        REGEX_INTERNAL_KeyIterator iterator,
+                                        void *iterator_cls);
 
 
 
@@ -163,31 +168,32 @@ struct REGEX_INTERNAL_Announcement;
  */
 struct REGEX_INTERNAL_Search;
 
+
 /**
  * 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 id ID to announce as provider of regex. Own ID in most cases.
+ * @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_PeerIdentity *id,
-                       const char *regex,
-                       uint16_t compression,
-                       struct GNUNET_STATISTICS_Handle *stats);
+                        const struct GNUNET_CRYPTO_EddsaPrivateKey *priv,
+                        const char *regex,
+                        uint16_t compression,
+                        struct GNUNET_STATISTICS_Handle *stats);
+
 
 /**
  * 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);
@@ -196,8 +202,8 @@ REGEX_INTERNAL_reannounce (struct REGEX_INTERNAL_Announcement *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);
@@ -206,24 +212,25 @@ REGEX_INTERNAL_announce_cancel (struct REGEX_INTERNAL_Announcement *h);
 /**
  * Search callback function.
  *
- * @param cls Closure provided in REGEX_INTERNAL_search.
+ * @param cls Closure provided in #REGEX_INTERNAL_search().
  * @param id Peer providing a regex that matches the string.
  * @param get_path Path of the get request.
- * @param get_path_length Lenght of get_path.
+ * @param get_path_length Length of @a get_path.
  * @param put_path Path of the put request.
- * @param put_path_length Length of the put_path.
+ * @param put_path_length Length of the @a put_path.
  */
-typedef void (*REGEX_INTERNAL_Found)(void *cls,
-                                   const struct GNUNET_PeerIdentity *id,
-                                   const struct GNUNET_PeerIdentity *get_path,
-                                   unsigned int get_path_length,
-                                   const struct GNUNET_PeerIdentity *put_path,
-                                   unsigned int put_path_length);
+typedef void
+(*REGEX_INTERNAL_Found)(void *cls,
+                        const struct GNUNET_PeerIdentity *id,
+                        const struct GNUNET_PeerIdentity *get_path,
+                        unsigned int get_path_length,
+                        const struct GNUNET_PeerIdentity *put_path,
+                        unsigned int put_path_length);
 
 
 /**
  * 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.
@@ -231,22 +238,21 @@ typedef void (*REGEX_INTERNAL_Found)(void *cls,
  * @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);
 
 /**
- * Stop search and free all data used by a REGEX_INTERNAL_search call.
+ * Stop search and free all data used by a #REGEX_INTERNAL_search() call.
  * Does not close DHT connection.
- * 
- * @param h Handle returned by a previous REGEX_INTERNAL_search call.
+ *
+ * @param h Handle returned by a previous #REGEX_INTERNAL_search() call.
  */
 void
 REGEX_INTERNAL_search_cancel (struct REGEX_INTERNAL_Search *h);