X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fcore%2Fgnunet-service-core_typemap.c;h=0600f59ef937af81afb905438ae8d222961a5767;hb=17f5db6f7c8d60930367738b3d872fbf891486ee;hp=d3214ea67ce478ca2494eb85c82faab85d9ae4a6;hpb=83b19539f4d322b43683f5838b72e9ec2c8e6073;p=oweals%2Fgnunet.git diff --git a/src/core/gnunet-service-core_typemap.c b/src/core/gnunet-service-core_typemap.c index d3214ea67..0600f59ef 100644 --- a/src/core/gnunet-service-core_typemap.c +++ b/src/core/gnunet-service-core_typemap.c @@ -1,6 +1,6 @@ /* This file is part of GNUnet. - (C) 2011 Christian Grothoff (and other contributing authors) + Copyright (C) 2011-2014 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. */ /** @@ -51,6 +51,63 @@ static struct GSC_TypeMap my_type_map; */ static uint8_t map_counters[UINT16_MAX + 1]; +/** + * Current hash of our (uncompressed) type map. + * Lazily computed when needed. + */ +static struct GNUNET_HashCode my_tm_hash; + +/** + * Is #my_tm_hash() current with respect to our type map? + */ +static int hash_current; + + +/** + * Our type map changed, recompute its hash. + */ +static void +rehash_typemap () +{ + hash_current = GNUNET_NO; +} + + +/** + * Hash the contents of a type map. + * + * @param tm map to hash + * @param hc where to store the hash code + */ +void +GSC_TYPEMAP_hash (const struct GSC_TypeMap *tm, + struct GNUNET_HashCode *hc) +{ + GNUNET_CRYPTO_hash (tm, + sizeof (struct GSC_TypeMap), + hc); +} + + +/** + * Check if the given hash matches our current type map. + * + * @param hc hash code to check if it matches our type map + * @return #GNUNET_YES if the hash matches, #GNUNET_NO if not + */ +int +GSC_TYPEMAP_check_hash (const struct GNUNET_HashCode *hc) +{ + if (GNUNET_NO == hash_current) + { + GSC_TYPEMAP_hash (&my_type_map, + &my_tm_hash); + hash_current = GNUNET_YES; + } + return (0 == memcmp (hc, &my_tm_hash, sizeof (struct GNUNET_HashCode))) + ? GNUNET_YES : GNUNET_NO; +} + /** * Compute a type map message for this peer. @@ -77,12 +134,14 @@ GSC_TYPEMAP_compute_type_map_message () compress2 ((Bytef *) tmp, &dlen, (const Bytef *) &my_type_map, sizeof (my_type_map), 9)) || (dlen >= sizeof (my_type_map))) { + /* compression failed, use uncompressed map */ dlen = sizeof (my_type_map); - memcpy (tmp, &my_type_map, sizeof (my_type_map)); + GNUNET_memcpy (tmp, &my_type_map, sizeof (my_type_map)); hdr->type = htons (GNUNET_MESSAGE_TYPE_CORE_BINARY_TYPE_MAP); } else { + /* compression worked, use compressed map */ hdr->type = htons (GNUNET_MESSAGE_TYPE_CORE_COMPRESSED_TYPE_MAP); } hdr->size = htons ((uint16_t) dlen + sizeof (struct GNUNET_MessageHeader)); @@ -114,13 +173,15 @@ GSC_TYPEMAP_get_from_message (const struct GNUNET_MessageHeader *msg) GNUNET_break_op (0); return NULL; } - ret = GNUNET_malloc (sizeof (struct GSC_TypeMap)); - memcpy (ret, &msg[1], sizeof (struct GSC_TypeMap)); + ret = GNUNET_new (struct GSC_TypeMap); + GNUNET_memcpy (ret, &msg[1], sizeof (struct GSC_TypeMap)); return ret; case GNUNET_MESSAGE_TYPE_CORE_COMPRESSED_TYPE_MAP: - GNUNET_STATISTICS_update (GSC_stats, gettext_noop ("# type maps received"), - 1, GNUNET_NO); - ret = GNUNET_malloc (sizeof (struct GSC_TypeMap)); + GNUNET_STATISTICS_update (GSC_stats, + gettext_noop ("# type maps received"), + 1, + GNUNET_NO); + ret = GNUNET_new (struct GSC_TypeMap); dlen = sizeof (struct GSC_TypeMap); if ((Z_OK != uncompress ((Bytef *) ret, &dlen, (const Bytef *) &msg[1], @@ -148,18 +209,23 @@ broadcast_my_type_map () hdr = GSC_TYPEMAP_compute_type_map_message (); GNUNET_STATISTICS_update (GSC_stats, - gettext_noop ("# updates to my type map"), 1, + gettext_noop ("# updates to my type map"), + 1, GNUNET_NO); - GSC_SESSIONS_broadcast (hdr); + GSC_SESSIONS_broadcast_typemap (hdr); GNUNET_free (hdr); } /** * Add a set of types to our type map. + * + * @param types array of message types supported by this peer + * @param tlen number of entries in @a types */ void -GSC_TYPEMAP_add (const uint16_t * types, unsigned int tlen) +GSC_TYPEMAP_add (const uint16_t *types, + unsigned int tlen) { unsigned int i; int changed; @@ -174,21 +240,29 @@ GSC_TYPEMAP_add (const uint16_t * types, unsigned int tlen) } } if (GNUNET_YES == changed) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Typemap changed, broadcasting!\n"); + rehash_typemap (); broadcast_my_type_map (); + } } /** * Remove a set of types from our type map. + * + * @param types array of types to remove + * @param tlen length of the @a types array */ void -GSC_TYPEMAP_remove (const uint16_t * types, unsigned int tlen) +GSC_TYPEMAP_remove (const uint16_t *types, + unsigned int tlen) { - unsigned int i; int changed; changed = GNUNET_NO; - for (i = 0; i < tlen; i++) + for (unsigned int i = 0; i < tlen; i++) { if (0 == --map_counters[types[i]]) { @@ -197,7 +271,10 @@ GSC_TYPEMAP_remove (const uint16_t * types, unsigned int tlen) } } if (GNUNET_YES == changed) + { + rehash_typemap (); broadcast_my_type_map (); + } } @@ -205,22 +282,21 @@ GSC_TYPEMAP_remove (const uint16_t * types, unsigned int tlen) * Test if any of the types from the types array is in the * given type map. * - * @param map map to test + * @param tmap map to test * @param types array of types - * @param tcnt number of entries in types - * @return GNUNET_YES if a type is in the map, GNUNET_NO if not + * @param tcnt number of entries in @a types + * @return #GNUNET_YES if a type is in the map, #GNUNET_NO if not */ int -GSC_TYPEMAP_test_match (const struct GSC_TypeMap *tmap, const uint16_t * types, +GSC_TYPEMAP_test_match (const struct GSC_TypeMap *tmap, + const uint16_t *types, unsigned int tcnt) { - unsigned int i; - if (NULL == tmap) return GNUNET_NO; if (0 == tcnt) return GNUNET_YES; /* matches all */ - for (i = 0; i < tcnt; i++) + for (unsigned int i = 0; i < tcnt; i++) if (0 != (tmap->bits[types[i] / 32] & (1 << (types[i] % 32)))) return GNUNET_YES; return GNUNET_NO; @@ -230,22 +306,22 @@ GSC_TYPEMAP_test_match (const struct GSC_TypeMap *tmap, const uint16_t * types, /** * Add additional types to a given typemap. * - * @param map map to extend (not changed) + * @param tmap map to extend (not changed) * @param types array of types to add - * @param tcnt number of entries in types + * @param tcnt number of entries in @a types * @return updated type map (fresh copy) */ struct GSC_TypeMap * -GSC_TYPEMAP_extend (const struct GSC_TypeMap *tmap, const uint16_t * types, +GSC_TYPEMAP_extend (const struct GSC_TypeMap *tmap, + const uint16_t *types, unsigned int tcnt) { struct GSC_TypeMap *ret; - unsigned int i; - ret = GNUNET_malloc (sizeof (struct GSC_TypeMap)); + ret = GNUNET_new (struct GSC_TypeMap); if (NULL != tmap) - memcpy (ret, tmap, sizeof (struct GSC_TypeMap)); - for (i = 0; i < tcnt; i++) + GNUNET_memcpy (ret, tmap, sizeof (struct GSC_TypeMap)); + for (unsigned int i = 0; i < tcnt; i++) ret->bits[types[i] / 32] |= (1 << (types[i] % 32)); return ret; } @@ -254,19 +330,19 @@ GSC_TYPEMAP_extend (const struct GSC_TypeMap *tmap, const uint16_t * types, /** * Create an empty type map. * - * @param map a type map + * @return an empty type map */ struct GSC_TypeMap * GSC_TYPEMAP_create () { - return GNUNET_malloc (sizeof (struct GSC_TypeMap)); + return GNUNET_new (struct GSC_TypeMap); } /** * Free the given type map. * - * @param map a type map + * @param tmap a type map */ void GSC_TYPEMAP_destroy (struct GSC_TypeMap *tmap)