X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fblock%2Fblock.c;h=51dab783d6dd5997527a796751634dacb4308543;hb=5a943624e2634d632ee2bf3a78c25b0aeae3813e;hp=24bde02acb2d3bd0438987d81fb585c599eddcba;hpb=38d121662a466fd857e2da150833522d36130c52;p=oweals%2Fgnunet.git diff --git a/src/block/block.c b/src/block/block.c index 24bde02ac..51dab783d 100644 --- a/src/block/block.c +++ b/src/block/block.c @@ -25,6 +25,7 @@ */ #include "platform.h" #include "gnunet_util_lib.h" +#include "gnunet_constants.h" #include "gnunet_signatures.h" #include "gnunet_block_lib.h" #include "gnunet_block_plugin.h" @@ -37,9 +38,9 @@ struct Plugin { /** * Name of the shared library. - */ + */ char *library_name; - + /** * Plugin API. */ @@ -53,38 +54,64 @@ struct Plugin struct GNUNET_BLOCK_Context { /** - * NULL-terminated array of our plugins. + * Array of our plugins. */ struct Plugin **plugins; + /** + * Size of the 'plugins' array. + */ + unsigned int num_plugins; + /** * Our configuration. - */ + */ const struct GNUNET_CONFIGURATION_Handle *cfg; }; /** * Mingle hash with the mingle_number to produce different bits. - * + * * @param in original hash code * @param mingle_number number for hash permutation * @param hc where to store the result. */ void -GNUNET_BLOCK_mingle_hash (const GNUNET_HashCode * in, - uint32_t mingle_number, - GNUNET_HashCode * hc) +GNUNET_BLOCK_mingle_hash (const GNUNET_HashCode * in, uint32_t mingle_number, + GNUNET_HashCode * hc) { GNUNET_HashCode m; - GNUNET_CRYPTO_hash (&mingle_number, - sizeof (uint32_t), - &m); + GNUNET_CRYPTO_hash (&mingle_number, sizeof (uint32_t), &m); GNUNET_CRYPTO_hash_xor (&m, in, hc); } +/** + * Add a plugin to the list managed by the block library. + * + * @param cls the block context + * @param library_name name of the plugin + * @param lib_ret the plugin API + */ +static void +add_plugin (void *cls, const char *library_name, void *lib_ret) +{ + struct GNUNET_BLOCK_Context *ctx = cls; + struct GNUNET_BLOCK_PluginFunctions *api = lib_ret; + struct Plugin *plugin; + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Loading block plugin `%s'\n"), + library_name); + plugin = GNUNET_malloc (sizeof (struct Plugin)); + plugin->api = api; + plugin->library_name = GNUNET_strdup (library_name); + GNUNET_array_append (ctx->plugins, ctx->num_plugins, plugin); +} + + + /** * Create a block context. Loads the block plugins. * @@ -95,50 +122,10 @@ struct GNUNET_BLOCK_Context * GNUNET_BLOCK_context_create (const struct GNUNET_CONFIGURATION_Handle *cfg) { struct GNUNET_BLOCK_Context *ctx; - struct GNUNET_BLOCK_PluginFunctions *api; - struct Plugin *plugin; - unsigned int num_plugins; - char *plugs; - char *pos; - char *libname; ctx = GNUNET_malloc (sizeof (struct GNUNET_BLOCK_Context)); ctx->cfg = cfg; - num_plugins = 0; - if (GNUNET_OK == - GNUNET_CONFIGURATION_get_value_string (cfg, - "block", "PLUGINS", &plugs)) - { - GNUNET_log (GNUNET_ERROR_TYPE_INFO, - _("Loading block plugins `%s'\n"), plugs); - pos = strtok (plugs, " "); - while (pos != NULL) - { - GNUNET_asprintf (&libname, "libgnunet_plugin_block_%s", pos); - api = GNUNET_PLUGIN_load (libname, NULL); - if (api == NULL) - { - GNUNET_log (GNUNET_ERROR_TYPE_ERROR, - _("Failed to load block plugin `%s'\n"), - pos); - GNUNET_free (libname); - } - else - { - plugin = GNUNET_malloc (sizeof (struct Plugin)); - plugin->api = api; - plugin->library_name = libname; - GNUNET_array_append (ctx->plugins, - num_plugins, - plugin); - } - pos = strtok (NULL, " "); - } - GNUNET_free (plugs); - } - GNUNET_array_append (ctx->plugins, - num_plugins, - NULL); + GNUNET_PLUGIN_load_all ("libgnunet_plugin_block_", NULL, &add_plugin, ctx); return ctx; } @@ -154,16 +141,14 @@ GNUNET_BLOCK_context_destroy (struct GNUNET_BLOCK_Context *ctx) unsigned int i; struct Plugin *plugin; - i = 0; - while (NULL != (plugin = ctx->plugins[i])) - { - GNUNET_break (NULL == - GNUNET_PLUGIN_unload (plugin->library_name, - plugin->api)); - GNUNET_free (plugin->library_name); - GNUNET_free (plugin); - i++; - } + for (i = 0; i < ctx->num_plugins; i++) + { + plugin = ctx->plugins[i]; + GNUNET_break (NULL == + GNUNET_PLUGIN_unload (plugin->library_name, plugin->api)); + GNUNET_free (plugin->library_name); + GNUNET_free (plugin); + } GNUNET_free (ctx->plugins); GNUNET_free (ctx); } @@ -177,25 +162,23 @@ GNUNET_BLOCK_context_destroy (struct GNUNET_BLOCK_Context *ctx) * @return NULL if no matching plugin exists */ static struct GNUNET_BLOCK_PluginFunctions * -find_plugin (struct GNUNET_BLOCK_Context *ctx, - enum GNUNET_BLOCK_Type type) +find_plugin (struct GNUNET_BLOCK_Context *ctx, enum GNUNET_BLOCK_Type type) { struct Plugin *plugin; unsigned int i; unsigned int j; - i = 0; - while (NULL != (plugin = ctx->plugins[i])) + for (i = 0; i < ctx->num_plugins; i++) + { + plugin = ctx->plugins[i]; + j = 0; + while (0 != (plugin->api->types[j])) { - j = 0; - while (0 != (plugin->api->types[j])) - { - if (type == plugin->api->types[j]) - return plugin->api; - j++; - } - i++; + if (type == plugin->api->types[j]) + return plugin->api; + j++; } + } return NULL; } @@ -203,7 +186,7 @@ find_plugin (struct GNUNET_BLOCK_Context *ctx, /** * Function called to validate a reply or a request. For * request evaluation, simply pass "NULL" for the reply_block. - * Note that it is assumed that the reply has already been + * Note that it is assumed that the reply has already been * matched to the key (and signatures checked) as it would * be done with the "get_key" function. * @@ -220,22 +203,19 @@ find_plugin (struct GNUNET_BLOCK_Context *ctx, */ enum GNUNET_BLOCK_EvaluationResult GNUNET_BLOCK_evaluate (struct GNUNET_BLOCK_Context *ctx, - enum GNUNET_BLOCK_Type type, - const GNUNET_HashCode *query, - struct GNUNET_CONTAINER_BloomFilter **bf, - int32_t bf_mutator, - const void *xquery, - size_t xquery_size, - const void *reply_block, - size_t reply_block_size) + enum GNUNET_BLOCK_Type type, + const GNUNET_HashCode * query, + struct GNUNET_CONTAINER_BloomFilter **bf, + int32_t bf_mutator, const void *xquery, + size_t xquery_size, const void *reply_block, + size_t reply_block_size) { struct GNUNET_BLOCK_PluginFunctions *plugin = find_plugin (ctx, type); if (plugin == NULL) return GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED; - return plugin->evaluate (plugin->cls, - type, query, bf, bf_mutator, - xquery, xquery_size, reply_block, reply_block_size); + return plugin->evaluate (plugin->cls, type, query, bf, bf_mutator, xquery, + xquery_size, reply_block, reply_block_size); } @@ -252,17 +232,76 @@ GNUNET_BLOCK_evaluate (struct GNUNET_BLOCK_Context *ctx, */ int GNUNET_BLOCK_get_key (struct GNUNET_BLOCK_Context *ctx, - enum GNUNET_BLOCK_Type type, - const void *block, - size_t block_size, - GNUNET_HashCode *key) + enum GNUNET_BLOCK_Type type, const void *block, + size_t block_size, GNUNET_HashCode * key) { struct GNUNET_BLOCK_PluginFunctions *plugin = find_plugin (ctx, type); if (plugin == NULL) return GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED; - return plugin->get_key (plugin->cls, - type, block, block_size, key); + return plugin->get_key (plugin->cls, type, block, block_size, key); +} + + +/** + * How many bytes should a bloomfilter be if we have already seen + * entry_count responses? Note that GNUNET_CONSTANTS_BLOOMFILTER_K gives us the number + * of bits set per entry. Furthermore, we should not re-size the + * filter too often (to keep it cheap). + * + * Since other peers will also add entries but not resize the filter, + * we should generally pick a slightly larger size than what the + * strict math would suggest. + * + * @return must be a power of two and smaller or equal to 2^15. + */ +static size_t +compute_bloomfilter_size (unsigned int entry_count) +{ + size_t size; + unsigned int ideal = (entry_count * GNUNET_CONSTANTS_BLOOMFILTER_K) / 4; + uint16_t max = 1 << 15; + + if (entry_count > max) + return max; + size = 8; + while ((size < max) && (size < ideal)) + size *= 2; + if (size > max) + return max; + return size; +} + + +/** + * Construct a bloom filter that would filter out the given + * results. + * + * @param bf_mutator mutation value to use + * @param seen_results results already seen + * @param seen_results_count number of entries in 'seen_results' + * @return NULL if seen_results_count is 0, otherwise a BF + * that would match the given results. + */ +struct GNUNET_CONTAINER_BloomFilter * +GNUNET_BLOCK_construct_bloomfilter (int32_t bf_mutator, + const GNUNET_HashCode * seen_results, + unsigned int seen_results_count) +{ + struct GNUNET_CONTAINER_BloomFilter *bf; + GNUNET_HashCode mhash; + unsigned int i; + size_t nsize; + + nsize = compute_bloomfilter_size (seen_results_count); + bf = GNUNET_CONTAINER_bloomfilter_init (NULL, nsize, + GNUNET_CONSTANTS_BLOOMFILTER_K); + for (i = 0; i < seen_results_count; i++) + { + GNUNET_BLOCK_mingle_hash (&seen_results[i], bf_mutator, &mhash); + GNUNET_CONTAINER_bloomfilter_add (bf, &mhash); + } + return bf; }