src/regex/plugin_block_regex.c

   1 /*
   2      This file is part of GNUnet
   3      (C) 2013 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file regex/plugin_block_regex.c
  23  * @brief blocks used for regex storage and search
  24  * @author Bartlomiej Polot
  25  */
  26
  27 #include "platform.h"
  28 #include "gnunet_block_plugin.h"
  29 #include "block_regex.h"
  30 #include "regex_block_lib.h"
  31
  32 /**
  33  * Number of bits we set per entry in the bloomfilter.
  34  * Do not change!
  35  */
  36 #define BLOOMFILTER_K 16
  37
  38
  39 /**
  40  * Function called to validate a reply or a request.  For
  41  * request evaluation, simply pass "NULL" for the reply_block.
  42  * Note that it is assumed that the reply has already been
  43  * matched to the key (and signatures checked) as it would
  44  * be done with the "get_key" function.
  45  *
  46  * @param cls closure
  47  * @param type block type
  48  * @param query original query (hash)
  49  * @param bf pointer to bloom filter associated with query; possibly updated (!)
  50  * @param bf_mutator mutation value for bf
  51  * @param xquery extrended query data (can be NULL, depending on type)
  52  * @param xquery_size number of bytes in xquery
  53  * @param reply_block response to validate
  54  * @param reply_block_size number of bytes in reply block
  55  * @return characterization of result
  56  */
  57 static enum GNUNET_BLOCK_EvaluationResult
  58 block_plugin_regex_evaluate (void *cls, enum GNUNET_BLOCK_Type type,
  59                              const struct GNUNET_HashCode * query,
  60                              struct GNUNET_CONTAINER_BloomFilter **bf,
  61                              int32_t bf_mutator, const void *xquery,
  62                              size_t xquery_size, const void *reply_block,
  63                              size_t reply_block_size)
  64 {
  65   struct GNUNET_HashCode chash;
  66   struct GNUNET_HashCode mhash;
  67
  68   switch (type)
  69   {
  70     case GNUNET_BLOCK_TYPE_REGEX:
  71       if (NULL == reply_block)
  72         return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;
  73       if (0 != xquery_size)
  74       {
  75         const char *query;
  76
  77         query = (const char *) xquery;
  78         if ('\0' != query[xquery_size - 1]) /* must be valid string */
  79         {
  80           GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
  81                       "Block xquery not a valid string\n");
  82           return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
  83         }
  84       }
  85       else
  86       {
  87         GNUNET_break_op (0);
  88         return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
  89       }
  90       switch (GNUNET_REGEX_block_check (reply_block,
  91                                         reply_block_size,
  92                                         xquery))
  93       {
  94         case GNUNET_SYSERR:
  95           GNUNET_break_op(0);
  96           return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
  97         case GNUNET_NO:
  98           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
  99                       "BLOCK XQUERY %s not accepted\n", xquery);
 100           return GNUNET_BLOCK_EVALUATION_RESULT_IRRELEVANT;
 101         default:
 102           GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 103                       "BLOCK XQUERY %s accepted\n", xquery);
 104           break;
 105       }
 106       if (NULL != bf)
 107       {
 108         GNUNET_CRYPTO_hash (reply_block, reply_block_size, &chash);
 109         GNUNET_BLOCK_mingle_hash (&chash, bf_mutator, &mhash);
 110         if (NULL != *bf)
 111         {
 112           if (GNUNET_YES == GNUNET_CONTAINER_bloomfilter_test (*bf, &mhash))
 113             return GNUNET_BLOCK_EVALUATION_OK_DUPLICATE;
 114         }
 115         else
 116         {
 117           *bf = GNUNET_CONTAINER_bloomfilter_init (NULL, 8, BLOOMFILTER_K);
 118         }
 119         GNUNET_CONTAINER_bloomfilter_add (*bf, &mhash);
 120       }
 121       return GNUNET_BLOCK_EVALUATION_OK_MORE;
 122
 123
 124     case GNUNET_BLOCK_TYPE_REGEX_ACCEPT:
 125       if (0 != xquery_size)
 126       {
 127         GNUNET_break_op (0);
 128         return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID;
 129       }
 130       if (NULL == reply_block)
 131         return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;
 132       if (sizeof (struct RegexAccept) != reply_block_size)
 133       {
 134         GNUNET_break_op(0);
 135         return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
 136       }
 137       if (NULL != bf)
 138       {
 139         GNUNET_CRYPTO_hash (reply_block, reply_block_size, &chash);
 140         GNUNET_BLOCK_mingle_hash (&chash, bf_mutator, &mhash);
 141         if (NULL != *bf)
 142         {
 143           if (GNUNET_YES == GNUNET_CONTAINER_bloomfilter_test (*bf, &mhash))
 144             return GNUNET_BLOCK_EVALUATION_OK_DUPLICATE;
 145         }
 146         else
 147         {
 148           *bf = GNUNET_CONTAINER_bloomfilter_init (NULL, 8, BLOOMFILTER_K);
 149         }
 150         GNUNET_CONTAINER_bloomfilter_add (*bf, &mhash);
 151       }
 152       return GNUNET_BLOCK_EVALUATION_OK_MORE;
 153
 154
 155     default:
 156       return GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED;
 157   }
 158 }
 159
 160
 161 /**
 162  * Function called to obtain the key for a block.
 163  *
 164  * @param cls closure
 165  * @param type block type
 166  * @param block block to get the key for
 167  * @param block_size number of bytes in block
 168  * @param key set to the key (query) for the given block
 169  * @return GNUNET_OK on success, GNUNET_SYSERR if type not supported
 170  *         (or if extracting a key from a block of this type does not work)
 171  */
 172 static int
 173 block_plugin_regex_get_key (void *cls, enum GNUNET_BLOCK_Type type,
 174                             const void *block, size_t block_size,
 175                             struct GNUNET_HashCode * key)
 176 {
 177   switch (type)
 178   {
 179     case GNUNET_BLOCK_TYPE_REGEX:
 180       GNUNET_assert (sizeof (struct RegexBlock) <= block_size);
 181       *key = ((struct RegexBlock *) block)->key;
 182       return GNUNET_OK;
 183     case GNUNET_BLOCK_TYPE_REGEX_ACCEPT:
 184       GNUNET_assert (sizeof (struct RegexAccept) <= block_size);
 185       *key = ((struct RegexAccept *) block)->key;
 186       return GNUNET_OK;
 187     default:
 188       GNUNET_break (0);
 189       return GNUNET_SYSERR;
 190   }
 191 }
 192
 193
 194 /**
 195  * Entry point for the plugin.
 196  */
 197 void *
 198 libgnunet_plugin_block_regex_init (void *cls)
 199 {
 200   static enum GNUNET_BLOCK_Type types[] =
 201   {
 202     GNUNET_BLOCK_TYPE_REGEX,
 203     GNUNET_BLOCK_TYPE_REGEX_ACCEPT,
 204     GNUNET_BLOCK_TYPE_ANY       /* end of list */
 205   };
 206   struct GNUNET_BLOCK_PluginFunctions *api;
 207
 208   api = GNUNET_malloc (sizeof (struct GNUNET_BLOCK_PluginFunctions));
 209   api->evaluate = &block_plugin_regex_evaluate;
 210   api->get_key = &block_plugin_regex_get_key;
 211   api->types = types;
 212   return api;
 213 }
 214
 215
 216 /**
 217  * Exit point from the plugin.
 218  */
 219 void *
 220 libgnunet_plugin_block_regex_done (void *cls)
 221 {
 222   struct GNUNET_TRANSPORT_PluginFunctions *api = cls;
 223
 224   GNUNET_free (api);
 225   return NULL;
 226 }
 227
 228 /* end of plugin_block_regex.c */