/*
This file is part of GNUnet.
- (C) 2011 Christian Grothoff (and other contributing authors)
+ (C) 2011-2014 Christian Grothoff (and other contributing authors)
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
* A type map describing which messages a given neighbour is able
* to process.
*/
-struct GSC_TypeMap
+struct GSC_TypeMap
{
uint32_t bits[(UINT16_MAX + 1) / 32];
};
*/
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.
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));
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));
switch (ntohs (msg->type))
{
case GNUNET_MESSAGE_TYPE_CORE_BINARY_TYPE_MAP:
+ GNUNET_STATISTICS_update (GSC_stats, gettext_noop ("# type maps received"),
+ 1, GNUNET_NO);
if (size != sizeof (struct GSC_TypeMap))
{
GNUNET_break_op (0);
return NULL;
}
- ret = GNUNET_malloc (sizeof (struct GSC_TypeMap));
+ ret = GNUNET_new (struct GSC_TypeMap);
memcpy (ret, &msg[1], sizeof (struct GSC_TypeMap));
return ret;
case GNUNET_MESSAGE_TYPE_CORE_COMPRESSED_TYPE_MAP:
- 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], (uLong) size)) ||
- (dlen != sizeof (struct GSC_TypeMap) ) )
+ if ((Z_OK !=
+ uncompress ((Bytef *) ret, &dlen, (const Bytef *) &msg[1],
+ (uLong) size)) || (dlen != sizeof (struct GSC_TypeMap)))
{
GNUNET_break_op (0);
GNUNET_free (ret);
struct GNUNET_MessageHeader *hdr;
hdr = GSC_TYPEMAP_compute_type_map_message ();
- GSC_SESSIONS_broadcast (hdr);
+ GNUNET_STATISTICS_update (GSC_stats,
+ gettext_noop ("# updates to my type map"), 1,
+ GNUNET_NO);
+ 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)
+ unsigned int tlen)
{
unsigned int i;
int changed;
changed = GNUNET_NO;
- for (i=0;i<tlen;i++)
+ for (i = 0; i < tlen; i++)
{
if (0 == map_counters[types[i]]++)
{
}
}
if (GNUNET_YES == changed)
+ {
+ 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)
+ unsigned int tlen)
{
unsigned int i;
int changed;
changed = GNUNET_NO;
- for (i=0;i<tlen;i++)
+ for (i = 0; i < tlen; i++)
{
if (0 == --map_counters[types[i]])
{
}
}
if (GNUNET_YES == changed)
+ {
+ rehash_typemap ();
broadcast_my_type_map ();
+ }
}
* 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,
- unsigned int tcnt)
-{
+ const uint16_t *types,
+ unsigned int tcnt)
+{
unsigned int i;
- for (i=0;i<tcnt;i++)
+ if (NULL == tmap)
+ return GNUNET_NO;
+ if (0 == tcnt)
+ return GNUNET_YES; /* matches all */
+ for (i = 0; i < tcnt; i++)
if (0 != (tmap->bits[types[i] / 32] & (1 << (types[i] % 32))))
return GNUNET_YES;
return GNUNET_NO;
/**
* 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,
- unsigned int tcnt)
+ 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++)
+ for (i = 0; i < tcnt; i++)
ret->bits[types[i] / 32] |= (1 << (types[i] % 32));
return ret;
}
+/**
+ * Create an empty type map.
+ *
+ * @return an empty type map
+ */
+struct GSC_TypeMap *
+GSC_TYPEMAP_create ()
+{
+ 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)