From 502af2167f7c218366666ca4944bd7cc54b5b19a Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Mon, 15 Aug 2011 21:46:35 +0000 Subject: indentation --- src/block/block.c | 132 ++++++------ src/block/plugin_block_dht.c | 83 ++++---- src/block/plugin_block_dns.c | 105 +++++----- src/block/plugin_block_fs.c | 408 ++++++++++++++++++-------------------- src/block/plugin_block_template.c | 35 ++-- src/block/plugin_block_test.c | 61 +++--- src/block/test_block.c | 34 +--- 7 files changed, 403 insertions(+), 455 deletions(-) (limited to 'src/block') diff --git a/src/block/block.c b/src/block/block.c index 24bde02ac..bdef55aa3 100644 --- a/src/block/block.c +++ b/src/block/block.c @@ -37,9 +37,9 @@ struct Plugin { /** * Name of the shared library. - */ + */ char *library_name; - + /** * Plugin API. */ @@ -59,7 +59,7 @@ struct GNUNET_BLOCK_Context /** * Our configuration. - */ + */ const struct GNUNET_CONFIGURATION_Handle *cfg; }; @@ -73,14 +73,11 @@ struct GNUNET_BLOCK_Context */ void GNUNET_BLOCK_mingle_hash (const GNUNET_HashCode * in, - uint32_t mingle_number, - GNUNET_HashCode * hc) + 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); } @@ -106,39 +103,33 @@ GNUNET_BLOCK_context_create (const struct GNUNET_CONFIGURATION_Handle *cfg) ctx->cfg = cfg; num_plugins = 0; if (GNUNET_OK == - GNUNET_CONFIGURATION_get_value_string (cfg, - "block", "PLUGINS", &plugs)) + 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_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_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_array_append (ctx->plugins, - num_plugins, - NULL); + GNUNET_free (plugs); + } + GNUNET_array_append (ctx->plugins, num_plugins, NULL); return ctx; } @@ -156,14 +147,13 @@ GNUNET_BLOCK_context_destroy (struct GNUNET_BLOCK_Context *ctx) 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++; - } + { + GNUNET_break (NULL == + GNUNET_PLUGIN_unload (plugin->library_name, plugin->api)); + GNUNET_free (plugin->library_name); + GNUNET_free (plugin); + i++; + } GNUNET_free (ctx->plugins); GNUNET_free (ctx); } @@ -177,8 +167,7 @@ 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; @@ -186,16 +175,16 @@ find_plugin (struct GNUNET_BLOCK_Context *ctx, i = 0; while (NULL != (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++; } + i++; + } return NULL; } @@ -220,22 +209,21 @@ 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); + type, query, bf, bf_mutator, + xquery, xquery_size, reply_block, reply_block_size); } @@ -252,17 +240,15 @@ 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); } diff --git a/src/block/plugin_block_dht.c b/src/block/plugin_block_dht.c index 0e499b821..1fe51e1a3 100644 --- a/src/block/plugin_block_dht.c +++ b/src/block/plugin_block_dht.c @@ -50,14 +50,13 @@ */ static enum GNUNET_BLOCK_EvaluationResult block_plugin_dht_evaluate (void *cls, - 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) { switch (type) { @@ -67,7 +66,7 @@ block_plugin_dht_evaluate (void *cls, if (reply_block_size == 0) return GNUNET_BLOCK_EVALUATION_REQUEST_VALID; GNUNET_break (NULL == *bf); - return GNUNET_BLOCK_EVALUATION_OK_LAST; + return GNUNET_BLOCK_EVALUATION_OK_LAST; default: return GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED; } @@ -87,10 +86,9 @@ block_plugin_dht_evaluate (void *cls, */ static int block_plugin_dht_get_key (void *cls, - 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) { const struct GNUNET_MessageHeader *msg; const struct GNUNET_HELLO_Message *hello; @@ -99,37 +97,34 @@ block_plugin_dht_get_key (void *cls, if (type != GNUNET_BLOCK_TYPE_DHT_HELLO) return GNUNET_SYSERR; if (block_size < sizeof (struct GNUNET_MessageHeader)) - { - GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, - "block-dht", - _("Block not of type %u\n"), - GNUNET_BLOCK_TYPE_DHT_HELLO); - return GNUNET_NO; - } + { + GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, + "block-dht", + _("Block not of type %u\n"), GNUNET_BLOCK_TYPE_DHT_HELLO); + return GNUNET_NO; + } msg = block; if (block_size != ntohs (msg->size)) - { - GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, - "block-dht", - _("Size mismatch for block\n"), - GNUNET_BLOCK_TYPE_DHT_HELLO); - return GNUNET_NO; - } + { + GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, + "block-dht", + _("Size mismatch for block\n"), + GNUNET_BLOCK_TYPE_DHT_HELLO); + return GNUNET_NO; + } hello = block; - pid = (struct GNUNET_PeerIdentity*) key; - if (GNUNET_OK != - GNUNET_HELLO_get_id (hello, - pid)) - { - GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, - "block-dht", - _("Block of type %u is malformed\n"), - GNUNET_BLOCK_TYPE_DHT_HELLO); - return GNUNET_NO; - } + pid = (struct GNUNET_PeerIdentity *) key; + if (GNUNET_OK != GNUNET_HELLO_get_id (hello, pid)) + { + GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, + "block-dht", + _("Block of type %u is malformed\n"), + GNUNET_BLOCK_TYPE_DHT_HELLO); + return GNUNET_NO; + } return GNUNET_OK; } - + /** * Entry point for the plugin. @@ -137,11 +132,11 @@ block_plugin_dht_get_key (void *cls, void * libgnunet_plugin_block_dht_init (void *cls) { - static enum GNUNET_BLOCK_Type types[] = - { - GNUNET_BLOCK_TYPE_DHT_HELLO, - GNUNET_BLOCK_TYPE_ANY /* end of list */ - }; + static enum GNUNET_BLOCK_Type types[] = + { + GNUNET_BLOCK_TYPE_DHT_HELLO, + GNUNET_BLOCK_TYPE_ANY /* end of list */ + }; struct GNUNET_BLOCK_PluginFunctions *api; api = GNUNET_malloc (sizeof (struct GNUNET_BLOCK_PluginFunctions)); diff --git a/src/block/plugin_block_dns.c b/src/block/plugin_block_dns.c index 681a659ae..0cf8c50e9 100644 --- a/src/block/plugin_block_dns.c +++ b/src/block/plugin_block_dns.c @@ -48,14 +48,13 @@ */ static enum GNUNET_BLOCK_EvaluationResult block_plugin_dns_evaluate (void *cls, - 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) { switch (type) { @@ -66,37 +65,43 @@ block_plugin_dns_evaluate (void *cls, if (reply_block_size == 0) return GNUNET_BLOCK_EVALUATION_REQUEST_VALID; - if (reply_block_size != sizeof(struct GNUNET_DNS_Record)) - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "DNS-Block is invalid: reply_block_size=%d != %d\n", reply_block_size, sizeof(struct GNUNET_DNS_Record)); - return GNUNET_BLOCK_EVALUATION_RESULT_INVALID; - } - - const struct GNUNET_DNS_Record* rec = reply_block; - - if (ntohl(rec->purpose.size) != sizeof(struct GNUNET_DNS_Record) - sizeof(struct GNUNET_CRYPTO_RsaSignature)) - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "DNS-Block is invalid: rec->purpose.size=%d != %d\n", - ntohl(rec->purpose.size), - sizeof(struct GNUNET_DNS_Record) - sizeof(struct GNUNET_CRYPTO_RsaSignature)); - return GNUNET_BLOCK_EVALUATION_RESULT_INVALID; - } - - if (GNUNET_TIME_relative_get_zero().rel_value == GNUNET_TIME_absolute_get_remaining(rec->expiration_time).rel_value) - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "DNS-Block is invalid: Timeout\n"); - return GNUNET_BLOCK_EVALUATION_RESULT_INVALID; - } - - if (GNUNET_OK != GNUNET_CRYPTO_rsa_verify (htonl(GNUNET_SIGNATURE_PURPOSE_DNS_RECORD), - &rec->purpose, - &rec->signature, - &rec->peer)) - { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "DNS-Block is invalid: invalid signature\n"); - return GNUNET_BLOCK_EVALUATION_RESULT_INVALID; - } + if (reply_block_size != sizeof (struct GNUNET_DNS_Record)) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "DNS-Block is invalid: reply_block_size=%d != %d\n", + reply_block_size, sizeof (struct GNUNET_DNS_Record)); + return GNUNET_BLOCK_EVALUATION_RESULT_INVALID; + } + + const struct GNUNET_DNS_Record *rec = reply_block; + + if (ntohl (rec->purpose.size) != + sizeof (struct GNUNET_DNS_Record) - + sizeof (struct GNUNET_CRYPTO_RsaSignature)) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "DNS-Block is invalid: rec->purpose.size=%d != %d\n", + ntohl (rec->purpose.size), + sizeof (struct GNUNET_DNS_Record) - + sizeof (struct GNUNET_CRYPTO_RsaSignature)); + return GNUNET_BLOCK_EVALUATION_RESULT_INVALID; + } + + if (GNUNET_TIME_relative_get_zero ().rel_value == + GNUNET_TIME_absolute_get_remaining (rec->expiration_time).rel_value) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "DNS-Block is invalid: Timeout\n"); + return GNUNET_BLOCK_EVALUATION_RESULT_INVALID; + } + + if (GNUNET_OK != + GNUNET_CRYPTO_rsa_verify (htonl (GNUNET_SIGNATURE_PURPOSE_DNS_RECORD), + &rec->purpose, &rec->signature, &rec->peer)) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "DNS-Block is invalid: invalid signature\n"); + return GNUNET_BLOCK_EVALUATION_RESULT_INVALID; + } /* How to decide whether there are no more? */ return GNUNET_BLOCK_EVALUATION_OK_MORE; @@ -119,15 +124,15 @@ block_plugin_dns_evaluate (void *cls, */ static int block_plugin_dns_get_key (void *cls, - 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) { if (type != GNUNET_BLOCK_TYPE_DNS) return GNUNET_SYSERR; - const struct GNUNET_DNS_Record* rec = block; - memcpy(key, &rec->service_descriptor, sizeof(GNUNET_HashCode)); + const struct GNUNET_DNS_Record *rec = block; + + memcpy (key, &rec->service_descriptor, sizeof (GNUNET_HashCode)); return GNUNET_OK; } @@ -137,11 +142,11 @@ block_plugin_dns_get_key (void *cls, void * libgnunet_plugin_block_dns_init (void *cls) { - static enum GNUNET_BLOCK_Type types[] = - { - GNUNET_BLOCK_TYPE_DNS, - GNUNET_BLOCK_TYPE_ANY /* end of list */ - }; + static enum GNUNET_BLOCK_Type types[] = + { + GNUNET_BLOCK_TYPE_DNS, + GNUNET_BLOCK_TYPE_ANY /* end of list */ + }; struct GNUNET_BLOCK_PluginFunctions *api; api = GNUNET_malloc (sizeof (struct GNUNET_BLOCK_PluginFunctions)); diff --git a/src/block/plugin_block_fs.c b/src/block/plugin_block_fs.c index caf009ddf..db8e59991 100644 --- a/src/block/plugin_block_fs.c +++ b/src/block/plugin_block_fs.c @@ -57,14 +57,13 @@ */ static enum GNUNET_BLOCK_EvaluationResult block_plugin_fs_evaluate (void *cls, - 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) { const struct SBlock *sb; GNUNET_HashCode chash; @@ -73,92 +72,81 @@ block_plugin_fs_evaluate (void *cls, GNUNET_HashCode sh; switch (type) + { + case GNUNET_BLOCK_TYPE_FS_DBLOCK: + case GNUNET_BLOCK_TYPE_FS_IBLOCK: + if (xquery_size != 0) { - case GNUNET_BLOCK_TYPE_FS_DBLOCK: - case GNUNET_BLOCK_TYPE_FS_IBLOCK: - if (xquery_size != 0) - { - GNUNET_break_op (0); - return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID; - } - if (reply_block == NULL) - return GNUNET_BLOCK_EVALUATION_REQUEST_VALID; - return GNUNET_BLOCK_EVALUATION_OK_LAST; - case GNUNET_BLOCK_TYPE_FS_KBLOCK: - case GNUNET_BLOCK_TYPE_FS_NBLOCK: - if (xquery_size != 0) - { - GNUNET_break_op (0); - return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID; - } - if (reply_block == NULL) - return GNUNET_BLOCK_EVALUATION_REQUEST_VALID; - GNUNET_CRYPTO_hash (reply_block, - reply_block_size, - &chash); - GNUNET_BLOCK_mingle_hash (&chash, bf_mutator, &mhash); - if (NULL != *bf) - { - if (GNUNET_YES == GNUNET_CONTAINER_bloomfilter_test (*bf, - &mhash)) - return GNUNET_BLOCK_EVALUATION_OK_DUPLICATE; - } - else - { - *bf = GNUNET_CONTAINER_bloomfilter_init (NULL, - 8, - BLOOMFILTER_K); - } - GNUNET_CONTAINER_bloomfilter_add (*bf, &mhash); - return GNUNET_BLOCK_EVALUATION_OK_MORE; - case GNUNET_BLOCK_TYPE_FS_SBLOCK: - if (xquery_size != sizeof (GNUNET_HashCode)) - { - GNUNET_break_op (0); - return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID; - } - if (reply_block == NULL) - return GNUNET_BLOCK_EVALUATION_REQUEST_VALID; - nsid = xquery; - if (reply_block_size < sizeof (struct SBlock)) - { - GNUNET_break_op (0); - return GNUNET_BLOCK_EVALUATION_RESULT_INVALID; - } - sb = reply_block; - GNUNET_CRYPTO_hash (&sb->subspace, - sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), - &sh); - if (0 != memcmp (nsid, - &sh, - sizeof (GNUNET_HashCode))) - { - GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING, - "block-fs", - _("Reply mismatched in terms of namespace. Discarded.\n")); - return GNUNET_BLOCK_EVALUATION_RESULT_INVALID; - } - GNUNET_CRYPTO_hash (reply_block, - reply_block_size, - &chash); - GNUNET_BLOCK_mingle_hash (&chash, bf_mutator, &mhash); - if (NULL != *bf) - { - if (GNUNET_YES == GNUNET_CONTAINER_bloomfilter_test (*bf, - &mhash)) - return GNUNET_BLOCK_EVALUATION_OK_DUPLICATE; - } - else - { - *bf = GNUNET_CONTAINER_bloomfilter_init (NULL, - 8, - BLOOMFILTER_K); - } - GNUNET_CONTAINER_bloomfilter_add (*bf, &mhash); - return GNUNET_BLOCK_EVALUATION_OK_MORE; - default: - return GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED; + GNUNET_break_op (0); + return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID; } + if (reply_block == NULL) + return GNUNET_BLOCK_EVALUATION_REQUEST_VALID; + return GNUNET_BLOCK_EVALUATION_OK_LAST; + case GNUNET_BLOCK_TYPE_FS_KBLOCK: + case GNUNET_BLOCK_TYPE_FS_NBLOCK: + if (xquery_size != 0) + { + GNUNET_break_op (0); + return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID; + } + if (reply_block == NULL) + return GNUNET_BLOCK_EVALUATION_REQUEST_VALID; + GNUNET_CRYPTO_hash (reply_block, reply_block_size, &chash); + GNUNET_BLOCK_mingle_hash (&chash, bf_mutator, &mhash); + if (NULL != *bf) + { + if (GNUNET_YES == GNUNET_CONTAINER_bloomfilter_test (*bf, &mhash)) + return GNUNET_BLOCK_EVALUATION_OK_DUPLICATE; + } + else + { + *bf = GNUNET_CONTAINER_bloomfilter_init (NULL, 8, BLOOMFILTER_K); + } + GNUNET_CONTAINER_bloomfilter_add (*bf, &mhash); + return GNUNET_BLOCK_EVALUATION_OK_MORE; + case GNUNET_BLOCK_TYPE_FS_SBLOCK: + if (xquery_size != sizeof (GNUNET_HashCode)) + { + GNUNET_break_op (0); + return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID; + } + if (reply_block == NULL) + return GNUNET_BLOCK_EVALUATION_REQUEST_VALID; + nsid = xquery; + if (reply_block_size < sizeof (struct SBlock)) + { + GNUNET_break_op (0); + return GNUNET_BLOCK_EVALUATION_RESULT_INVALID; + } + sb = reply_block; + GNUNET_CRYPTO_hash (&sb->subspace, + sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), + &sh); + if (0 != memcmp (nsid, &sh, sizeof (GNUNET_HashCode))) + { + GNUNET_log_from (GNUNET_ERROR_TYPE_WARNING, + "block-fs", + _ + ("Reply mismatched in terms of namespace. Discarded.\n")); + return GNUNET_BLOCK_EVALUATION_RESULT_INVALID; + } + GNUNET_CRYPTO_hash (reply_block, reply_block_size, &chash); + GNUNET_BLOCK_mingle_hash (&chash, bf_mutator, &mhash); + if (NULL != *bf) + { + if (GNUNET_YES == GNUNET_CONTAINER_bloomfilter_test (*bf, &mhash)) + return GNUNET_BLOCK_EVALUATION_OK_DUPLICATE; + } + else + { + *bf = GNUNET_CONTAINER_bloomfilter_init (NULL, 8, BLOOMFILTER_K); + } + GNUNET_CONTAINER_bloomfilter_add (*bf, &mhash); + return GNUNET_BLOCK_EVALUATION_OK_MORE; + default: + return GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED; + } } @@ -175,126 +163,122 @@ block_plugin_fs_evaluate (void *cls, */ static int block_plugin_fs_get_key (void *cls, - 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) { const struct KBlock *kb; const struct SBlock *sb; const struct NBlock *nb; switch (type) + { + case GNUNET_BLOCK_TYPE_FS_DBLOCK: + case GNUNET_BLOCK_TYPE_FS_IBLOCK: + GNUNET_CRYPTO_hash (block, block_size, key); + return GNUNET_OK; + case GNUNET_BLOCK_TYPE_FS_KBLOCK: + if (block_size < sizeof (struct KBlock)) + { + GNUNET_break_op (0); + return GNUNET_NO; + } + kb = block; + if (block_size - sizeof (struct KBlock) != + ntohl (kb->purpose.size) + - sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) + - sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)) + { + GNUNET_break_op (0); + return GNUNET_NO; + } + if (GNUNET_OK != + GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_FS_KBLOCK, + &kb->purpose, &kb->signature, &kb->keyspace)) + { + GNUNET_break_op (0); + return GNUNET_NO; + } + if (key != NULL) + GNUNET_CRYPTO_hash (&kb->keyspace, + sizeof (struct + GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), + key); + return GNUNET_OK; + case GNUNET_BLOCK_TYPE_FS_SBLOCK: + if (block_size < sizeof (struct SBlock)) + { + GNUNET_break_op (0); + return GNUNET_NO; + } + sb = block; + if (block_size != + ntohl (sb->purpose.size) + sizeof (struct GNUNET_CRYPTO_RsaSignature)) { - case GNUNET_BLOCK_TYPE_FS_DBLOCK: - case GNUNET_BLOCK_TYPE_FS_IBLOCK: - GNUNET_CRYPTO_hash (block, block_size, key); - return GNUNET_OK; - case GNUNET_BLOCK_TYPE_FS_KBLOCK: - if (block_size < sizeof (struct KBlock)) - { - GNUNET_break_op (0); - return GNUNET_NO; - } - kb = block; - if (block_size - sizeof (struct KBlock) != - ntohl (kb->purpose.size) - - sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) - - sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) ) - { - GNUNET_break_op (0); - return GNUNET_NO; - } - if (GNUNET_OK != - GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_FS_KBLOCK, - &kb->purpose, - &kb->signature, - &kb->keyspace)) - { - GNUNET_break_op (0); - return GNUNET_NO; - } - if (key != NULL) - GNUNET_CRYPTO_hash (&kb->keyspace, - sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), - key); - return GNUNET_OK; - case GNUNET_BLOCK_TYPE_FS_SBLOCK: - if (block_size < sizeof (struct SBlock)) - { - GNUNET_break_op (0); - return GNUNET_NO; - } - sb = block; - if (block_size != - ntohl (sb->purpose.size) + sizeof (struct GNUNET_CRYPTO_RsaSignature)) - { - GNUNET_break_op (0); - return GNUNET_NO; - } - if (GNUNET_OK != - GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_FS_SBLOCK, - &sb->purpose, - &sb->signature, - &sb->subspace)) - { - GNUNET_break_op (0); - return GNUNET_NO; - } - if (key != NULL) - *key = sb->identifier; - return GNUNET_OK; - case GNUNET_BLOCK_TYPE_FS_NBLOCK: - if (block_size < sizeof (struct NBlock)) - { - GNUNET_break_op (0); - return GNUNET_NO; - } - nb = block; - if (block_size - sizeof (struct NBlock) != - ntohl (nb->ns_purpose.size) - - sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) - - sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) ) - { - GNUNET_break_op (0); - return GNUNET_NO; - } - if (block_size != - ntohl (nb->ksk_purpose.size) + sizeof (struct GNUNET_CRYPTO_RsaSignature)) - { - GNUNET_break_op (0); - return GNUNET_NO; - } - if (GNUNET_OK != - GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_FS_NBLOCK_KSIG, - &nb->ksk_purpose, - &nb->ksk_signature, - &nb->keyspace)) - { - GNUNET_break_op (0); - return GNUNET_NO; - } - if (GNUNET_OK != - GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_FS_NBLOCK, - &nb->ns_purpose, - &nb->ns_signature, - &nb->subspace)) - { - GNUNET_break_op (0); - return GNUNET_NO; - } - /* FIXME: we used to xor ID with NSID, - why not here? */ - if (key != NULL) - GNUNET_CRYPTO_hash (&nb->keyspace, - sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), - key); - return GNUNET_OK; - default: - return GNUNET_SYSERR; + GNUNET_break_op (0); + return GNUNET_NO; } + if (GNUNET_OK != + GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_FS_SBLOCK, + &sb->purpose, &sb->signature, &sb->subspace)) + { + GNUNET_break_op (0); + return GNUNET_NO; + } + if (key != NULL) + *key = sb->identifier; + return GNUNET_OK; + case GNUNET_BLOCK_TYPE_FS_NBLOCK: + if (block_size < sizeof (struct NBlock)) + { + GNUNET_break_op (0); + return GNUNET_NO; + } + nb = block; + if (block_size - sizeof (struct NBlock) != + ntohl (nb->ns_purpose.size) + - sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) + - sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded)) + { + GNUNET_break_op (0); + return GNUNET_NO; + } + if (block_size != + ntohl (nb->ksk_purpose.size) + + sizeof (struct GNUNET_CRYPTO_RsaSignature)) + { + GNUNET_break_op (0); + return GNUNET_NO; + } + if (GNUNET_OK != + GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_FS_NBLOCK_KSIG, + &nb->ksk_purpose, + &nb->ksk_signature, &nb->keyspace)) + { + GNUNET_break_op (0); + return GNUNET_NO; + } + if (GNUNET_OK != + GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_FS_NBLOCK, + &nb->ns_purpose, + &nb->ns_signature, &nb->subspace)) + { + GNUNET_break_op (0); + return GNUNET_NO; + } + /* FIXME: we used to xor ID with NSID, + * why not here? */ + if (key != NULL) + GNUNET_CRYPTO_hash (&nb->keyspace, + sizeof (struct + GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), + key); + return GNUNET_OK; + default: + return GNUNET_SYSERR; + } } - + /** * Entry point for the plugin. @@ -302,15 +286,15 @@ block_plugin_fs_get_key (void *cls, void * libgnunet_plugin_block_fs_init (void *cls) { - static enum GNUNET_BLOCK_Type types[] = - { - GNUNET_BLOCK_TYPE_FS_DBLOCK, - GNUNET_BLOCK_TYPE_FS_IBLOCK, - GNUNET_BLOCK_TYPE_FS_KBLOCK, - GNUNET_BLOCK_TYPE_FS_SBLOCK, - GNUNET_BLOCK_TYPE_FS_NBLOCK, - GNUNET_BLOCK_TYPE_ANY /* end of list */ - }; + static enum GNUNET_BLOCK_Type types[] = + { + GNUNET_BLOCK_TYPE_FS_DBLOCK, + GNUNET_BLOCK_TYPE_FS_IBLOCK, + GNUNET_BLOCK_TYPE_FS_KBLOCK, + GNUNET_BLOCK_TYPE_FS_SBLOCK, + GNUNET_BLOCK_TYPE_FS_NBLOCK, + GNUNET_BLOCK_TYPE_ANY /* end of list */ + }; struct GNUNET_BLOCK_PluginFunctions *api; api = GNUNET_malloc (sizeof (struct GNUNET_BLOCK_PluginFunctions)); diff --git a/src/block/plugin_block_template.c b/src/block/plugin_block_template.c index 77e7c0ab9..9eb84ac4b 100644 --- a/src/block/plugin_block_template.c +++ b/src/block/plugin_block_template.c @@ -47,14 +47,14 @@ */ static enum GNUNET_BLOCK_EvaluationResult block_plugin_template_evaluate (void *cls, - 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) { return GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED; } @@ -73,14 +73,13 @@ block_plugin_template_evaluate (void *cls, */ static int block_plugin_template_get_key (void *cls, - 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) { return GNUNET_SYSERR; } - + /** * Entry point for the plugin. @@ -88,11 +87,11 @@ block_plugin_template_get_key (void *cls, void * libgnunet_plugin_block_template_init (void *cls) { - static enum GNUNET_BLOCK_Type types[] = - { - /* FIXME: insert supported block types here */ - GNUNET_BLOCK_TYPE_ANY /* end of list */ - }; + static enum GNUNET_BLOCK_Type types[] = + { + /* FIXME: insert supported block types here */ + GNUNET_BLOCK_TYPE_ANY /* end of list */ + }; struct GNUNET_BLOCK_PluginFunctions *api; api = GNUNET_malloc (sizeof (struct GNUNET_BLOCK_PluginFunctions)); diff --git a/src/block/plugin_block_test.c b/src/block/plugin_block_test.c index 639a5c46e..b5c03eea9 100644 --- a/src/block/plugin_block_test.c +++ b/src/block/plugin_block_test.c @@ -54,42 +54,36 @@ */ static enum GNUNET_BLOCK_EvaluationResult block_plugin_test_evaluate (void *cls, - 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) { GNUNET_HashCode chash; GNUNET_HashCode mhash; - if (type != GNUNET_BLOCK_TYPE_TEST) + if (type != GNUNET_BLOCK_TYPE_TEST) return GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED; if (xquery_size != 0) return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID; if (reply_block_size == 0) return GNUNET_BLOCK_EVALUATION_REQUEST_VALID; - GNUNET_CRYPTO_hash (reply_block, - reply_block_size, - &chash); + GNUNET_CRYPTO_hash (reply_block, reply_block_size, &chash); GNUNET_BLOCK_mingle_hash (&chash, bf_mutator, &mhash); if (NULL != *bf) - { - if (GNUNET_YES == GNUNET_CONTAINER_bloomfilter_test (*bf, - &mhash)) - return GNUNET_BLOCK_EVALUATION_OK_DUPLICATE; - } + { + if (GNUNET_YES == GNUNET_CONTAINER_bloomfilter_test (*bf, &mhash)) + return GNUNET_BLOCK_EVALUATION_OK_DUPLICATE; + } else - { - *bf = GNUNET_CONTAINER_bloomfilter_init (NULL, - 8, - BLOOMFILTER_K); - } - GNUNET_CONTAINER_bloomfilter_add (*bf, &mhash); + { + *bf = GNUNET_CONTAINER_bloomfilter_init (NULL, 8, BLOOMFILTER_K); + } + GNUNET_CONTAINER_bloomfilter_add (*bf, &mhash); return GNUNET_BLOCK_EVALUATION_OK_MORE; } @@ -107,16 +101,15 @@ block_plugin_test_evaluate (void *cls, */ static int block_plugin_test_get_key (void *cls, - 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) { /* always fails since there is no fixed relationship between - keys and values for test values */ + * keys and values for test values */ return GNUNET_SYSERR; } - + /** * Entry point for the plugin. @@ -124,11 +117,11 @@ block_plugin_test_get_key (void *cls, void * libgnunet_plugin_block_test_init (void *cls) { - static enum GNUNET_BLOCK_Type types[] = - { - GNUNET_BLOCK_TYPE_TEST, - GNUNET_BLOCK_TYPE_ANY /* end of list */ - }; + static enum GNUNET_BLOCK_Type types[] = + { + GNUNET_BLOCK_TYPE_TEST, + GNUNET_BLOCK_TYPE_ANY /* end of list */ + }; struct GNUNET_BLOCK_PluginFunctions *api; api = GNUNET_malloc (sizeof (struct GNUNET_BLOCK_PluginFunctions)); diff --git a/src/block/test_block.c b/src/block/test_block.c index bb9a1f01b..4bfd63ceb 100644 --- a/src/block/test_block.c +++ b/src/block/test_block.c @@ -38,35 +38,24 @@ test_fs (struct GNUNET_BLOCK_Context *ctx) memset (block, 1, sizeof (block)); if (GNUNET_OK != GNUNET_BLOCK_get_key (ctx, - GNUNET_BLOCK_TYPE_FS_DBLOCK, - block, - sizeof (block), - &key)) + GNUNET_BLOCK_TYPE_FS_DBLOCK, + block, sizeof (block), &key)) return 1; if (GNUNET_BLOCK_EVALUATION_OK_LAST != GNUNET_BLOCK_evaluate (ctx, - GNUNET_BLOCK_TYPE_FS_DBLOCK, - &key, - NULL, 0, - NULL, 0, - block, sizeof (block))) + GNUNET_BLOCK_TYPE_FS_DBLOCK, + &key, NULL, 0, NULL, 0, block, sizeof (block))) return 2; if (GNUNET_BLOCK_EVALUATION_REQUEST_VALID != GNUNET_BLOCK_evaluate (ctx, - GNUNET_BLOCK_TYPE_FS_DBLOCK, - &key, - NULL, 0, - NULL, 0, - NULL, 0)) + GNUNET_BLOCK_TYPE_FS_DBLOCK, + &key, NULL, 0, NULL, 0, NULL, 0)) return 4; GNUNET_log_skip (1, GNUNET_NO); - if (GNUNET_BLOCK_EVALUATION_REQUEST_INVALID != + if (GNUNET_BLOCK_EVALUATION_REQUEST_INVALID != GNUNET_BLOCK_evaluate (ctx, - GNUNET_BLOCK_TYPE_FS_DBLOCK, - &key, - NULL, 0, - "bogus", 5, - NULL, 0)) + GNUNET_BLOCK_TYPE_FS_DBLOCK, + &key, NULL, 0, "bogus", 5, NULL, 0)) return 8; GNUNET_log_skip (0, GNUNET_YES); return 0; @@ -81,10 +70,7 @@ main (int argc, char *argv[]) GNUNET_log_setup ("test-block", "WARNING", NULL); cfg = GNUNET_CONFIGURATION_create (); - GNUNET_CONFIGURATION_set_value_string (cfg, - "block", - "PLUGINS", - "fs"); + GNUNET_CONFIGURATION_set_value_string (cfg, "block", "PLUGINS", "fs"); ctx = GNUNET_BLOCK_context_create (cfg); ret = test_fs (ctx); GNUNET_BLOCK_context_destroy (ctx); -- cgit v1.2.3