GNUnet 0.21.1
gnunet-service-core_typemap.c File Reference

management of map that specifies which message types this peer supports More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet-service-core.h"
#include "gnunet-service-core_sessions.h"
#include "gnunet-service-core_typemap.h"
#include <zlib.h>
Include dependency graph for gnunet-service-core_typemap.c:

Go to the source code of this file.

Data Structures

struct  GSC_TypeMap
 A type map describing which messages a given neighbour is able to process. More...
 

Functions

static void rehash_typemap ()
 Our type map changed, recompute its hash. More...
 
void GSC_TYPEMAP_hash (const struct GSC_TypeMap *tm, struct GNUNET_HashCode *hc)
 Hash the contents of a type map. More...
 
int GSC_TYPEMAP_check_hash (const struct GNUNET_HashCode *hc)
 Check if the given hash matches our current type map. More...
 
struct GNUNET_MessageHeaderGSC_TYPEMAP_compute_type_map_message ()
 Compute a type map message for this peer. More...
 
struct GSC_TypeMapGSC_TYPEMAP_get_from_message (const struct GNUNET_MessageHeader *msg)
 Extract a type map from a TYPE_MAP message. More...
 
static void broadcast_my_type_map ()
 Send my type map to all connected peers (it got changed). More...
 
void GSC_TYPEMAP_add (const uint16_t *types, unsigned int tlen)
 Add a set of types to our type map. More...
 
void GSC_TYPEMAP_remove (const uint16_t *types, unsigned int tlen)
 Remove a set of message types from our type map. More...
 
int GSC_TYPEMAP_test_match (const struct GSC_TypeMap *tmap, const uint16_t *types, unsigned int tcnt)
 Test if any of the types from the types array is in the given type map. More...
 
struct GSC_TypeMapGSC_TYPEMAP_extend (const struct GSC_TypeMap *tmap, const uint16_t *types, unsigned int tcnt)
 Add additional types to a given typemap. More...
 
struct GSC_TypeMapGSC_TYPEMAP_create ()
 Create an empty type map. More...
 
void GSC_TYPEMAP_destroy (struct GSC_TypeMap *tmap)
 Free the given type map. More...
 
void GSC_TYPEMAP_init ()
 Initialize typemap subsystem. More...
 
void GSC_TYPEMAP_done ()
 Shutdown typemap subsystem. More...
 

Variables

static struct GSC_TypeMap my_type_map
 Bitmap of message types this peer is able to handle. More...
 
static uint8_t map_counters [UINT16_MAX+1]
 Counters for message types this peer is able to handle. More...
 
static struct GNUNET_HashCode my_tm_hash
 Current hash of our (uncompressed) type map. More...
 
static int hash_current
 Is my_tm_hash() current with respect to our type map? More...
 

Detailed Description

management of map that specifies which message types this peer supports

Author
Christian Grothoff

Definition in file gnunet-service-core_typemap.c.

Function Documentation

◆ rehash_typemap()

static void rehash_typemap ( )
static

Our type map changed, recompute its hash.

Definition at line 69 of file gnunet-service-core_typemap.c.

70{
72}
static int hash_current
Is my_tm_hash() current with respect to our type map?
@ GNUNET_NO

References GNUNET_NO, and hash_current.

Referenced by GSC_TYPEMAP_add(), and GSC_TYPEMAP_remove().

Here is the caller graph for this function:

◆ GSC_TYPEMAP_hash()

void GSC_TYPEMAP_hash ( const struct GSC_TypeMap tm,
struct GNUNET_HashCode hc 
)

Hash the contents of a type map.

Parameters
tmmap to hash
hcwhere to store the hash code

Definition at line 82 of file gnunet-service-core_typemap.c.

83{
84 GNUNET_CRYPTO_hash (tm, sizeof(struct GSC_TypeMap), hc);
85}
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
A type map describing which messages a given neighbour is able to process.

References GNUNET_CRYPTO_hash().

Referenced by GSC_SESSIONS_set_typemap(), and GSC_TYPEMAP_check_hash().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GSC_TYPEMAP_check_hash()

int GSC_TYPEMAP_check_hash ( const struct GNUNET_HashCode hc)

Check if the given hash matches our current type map.

Parameters
hchash code to check if it matches our type map
Returns
GNUNET_YES if the hash matches, GNUNET_NO if not

Definition at line 95 of file gnunet-service-core_typemap.c.

96{
98 {
101 }
102 return (0 == memcmp (hc, &my_tm_hash, sizeof(struct GNUNET_HashCode)))
103 ? GNUNET_YES
104 : GNUNET_NO;
105}
static struct GNUNET_HashCode my_tm_hash
Current hash of our (uncompressed) type map.
static struct GSC_TypeMap my_type_map
Bitmap of message types this peer is able to handle.
void GSC_TYPEMAP_hash(const struct GSC_TypeMap *tm, struct GNUNET_HashCode *hc)
Hash the contents of a type map.
@ GNUNET_YES
A 512-bit hashcode.

References GNUNET_NO, GNUNET_YES, GSC_TYPEMAP_hash(), hash_current, my_tm_hash, and my_type_map.

Referenced by GSC_SESSIONS_confirm_typemap().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GSC_TYPEMAP_compute_type_map_message()

struct GNUNET_MessageHeader * GSC_TYPEMAP_compute_type_map_message ( void  )

Compute a type map message for this peer.

Returns
this peers current type map message.

Definition at line 114 of file gnunet-service-core_typemap.c.

115{
116 char *tmp;
117 uLongf dlen;
118 struct GNUNET_MessageHeader *hdr;
119
120#ifdef compressBound
121 dlen = compressBound (sizeof(my_type_map));
122#else
123 dlen = sizeof(my_type_map) + (sizeof(my_type_map) / 100) + 20;
124 /* documentation says 100.1% oldSize + 12 bytes, but we
125 * should be able to overshoot by more to be safe */
126#endif
127 hdr = GNUNET_malloc (dlen + sizeof(struct GNUNET_MessageHeader));
128 tmp = (char *) &hdr[1];
129 if ((Z_OK != compress2 ((Bytef *) tmp,
130 &dlen,
131 (const Bytef *) &my_type_map,
132 sizeof(my_type_map),
133 9)) ||
134 (dlen >= sizeof(my_type_map)))
135 {
136 /* compression failed, use uncompressed map */
137 dlen = sizeof(my_type_map);
138 GNUNET_memcpy (tmp, &my_type_map, sizeof(my_type_map));
140 }
141 else
142 {
143 /* compression worked, use compressed map */
145 }
146 hdr->size = htons ((uint16_t) dlen + sizeof(struct GNUNET_MessageHeader));
147 return hdr;
148}
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_MESSAGE_TYPE_CORE_BINARY_TYPE_MAP
uncompressed type map of the sender
#define GNUNET_MESSAGE_TYPE_CORE_COMPRESSED_TYPE_MAP
gzip-compressed type map of the sender
Header for all communications.

References GNUNET_malloc, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_CORE_BINARY_TYPE_MAP, GNUNET_MESSAGE_TYPE_CORE_COMPRESSED_TYPE_MAP, my_type_map, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by broadcast_my_type_map(), and transmit_typemap_task().

Here is the caller graph for this function:

◆ GSC_TYPEMAP_get_from_message()

struct GSC_TypeMap * GSC_TYPEMAP_get_from_message ( const struct GNUNET_MessageHeader msg)

Extract a type map from a TYPE_MAP message.

Extract a type map from a #GNUNET_MESSAGE_TYPE_CORE_COMRESSED_TYPE_MAP or GNUNET_MESSAGE_TYPE_CORE_BINARY_TYPE_MAP message.

Parameters
msga type map message
Returns
NULL on error

Definition at line 158 of file gnunet-service-core_typemap.c.

159{
160 struct GSC_TypeMap *ret;
161 uint16_t size;
162 uLongf dlen;
163
164 size = ntohs (msg->size);
165 switch (ntohs (msg->type))
166 {
169 gettext_noop ("# type maps received"),
170 1,
171 GNUNET_NO);
172 if (size != sizeof(struct GSC_TypeMap))
173 {
174 GNUNET_break_op (0);
175 return NULL;
176 }
177 ret = GNUNET_new (struct GSC_TypeMap);
178 GNUNET_memcpy (ret, &msg[1], sizeof(struct GSC_TypeMap));
179 return ret;
180
183 gettext_noop ("# type maps received"),
184 1,
185 GNUNET_NO);
186 ret = GNUNET_new (struct GSC_TypeMap);
187 dlen = sizeof(struct GSC_TypeMap);
188 if ((Z_OK != uncompress ((Bytef *) ret,
189 &dlen,
190 (const Bytef *) &msg[1],
191 (uLong) size)) ||
192 (dlen != sizeof(struct GSC_TypeMap)))
193 {
194 GNUNET_break_op (0);
196 return NULL;
197 }
198 return ret;
199
200 default:
201 GNUNET_break (0);
202 return NULL;
203 }
204}
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
#define gettext_noop(String)
Definition: gettext.h:70
static int ret
Final status code.
Definition: gnunet-arm.c:94
struct GNUNET_STATISTICS_Handle * GSC_stats
For creating statistics.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
static unsigned int size
Size of the "table".
Definition: peer.c:68

References gettext_noop, GNUNET_break, GNUNET_break_op, GNUNET_free, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_CORE_BINARY_TYPE_MAP, GNUNET_MESSAGE_TYPE_CORE_COMPRESSED_TYPE_MAP, GNUNET_new, GNUNET_NO, GNUNET_STATISTICS_update(), GSC_stats, msg, ret, GNUNET_MessageHeader::size, size, and GNUNET_MessageHeader::type.

Referenced by GSC_SESSIONS_set_typemap().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ broadcast_my_type_map()

static void broadcast_my_type_map ( )
static

Send my type map to all connected peers (it got changed).

Definition at line 211 of file gnunet-service-core_typemap.c.

212{
213 struct GNUNET_MessageHeader *hdr;
214
217 gettext_noop ("# updates to my type map"),
218 1,
219 GNUNET_NO);
221 GNUNET_free (hdr);
222}
void GSC_SESSIONS_broadcast_typemap(const struct GNUNET_MessageHeader *msg)
Broadcast an updated typemap message to all neighbours.
struct GNUNET_MessageHeader * GSC_TYPEMAP_compute_type_map_message()
Compute a type map message for this peer.

References gettext_noop, GNUNET_free, GNUNET_NO, GNUNET_STATISTICS_update(), GSC_SESSIONS_broadcast_typemap(), GSC_stats, and GSC_TYPEMAP_compute_type_map_message().

Referenced by GSC_TYPEMAP_add(), and GSC_TYPEMAP_remove().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GSC_TYPEMAP_add()

void GSC_TYPEMAP_add ( const uint16_t *  types,
unsigned int  tlen 
)

Add a set of types to our type map.

Parameters
typesarray of message types supported by this peer
tlennumber of entries in types

Definition at line 232 of file gnunet-service-core_typemap.c.

233{
234 unsigned int i;
235 int changed;
236
237 changed = GNUNET_NO;
238 for (i = 0; i < tlen; i++)
239 {
240 if (0 == map_counters[types[i]]++)
241 {
242 my_type_map.bits[types[i] / 32] |= (1 << (types[i] % 32));
243 changed = GNUNET_YES;
244 }
245 }
246 if (GNUNET_YES == changed)
247 {
248 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Typemap changed, broadcasting!\n");
251 }
252}
static void rehash_typemap()
Our type map changed, recompute its hash.
static uint8_t map_counters[UINT16_MAX+1]
Counters for message types this peer is able to handle.
static void broadcast_my_type_map()
Send my type map to all connected peers (it got changed).
#define GNUNET_log(kind,...)
@ GNUNET_ERROR_TYPE_DEBUG
uint32_t bits[(UINT16_MAX+1)/32]

References GSC_TypeMap::bits, broadcast_my_type_map(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_YES, map_counters, my_type_map, and rehash_typemap().

Referenced by handle_client_init().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GSC_TYPEMAP_remove()

void GSC_TYPEMAP_remove ( const uint16_t *  types,
unsigned int  tlen 
)

Remove a set of message types from our type map.

Parameters
typesarray of message types no longer supported by this peer
tlennumber of entries in types

Definition at line 256 of file gnunet-service-core_typemap.c.

257{
258 int changed;
259
260 changed = GNUNET_NO;
261 for (unsigned int i = 0; i < tlen; i++)
262 {
263 if (0 == --map_counters[types[i]])
264 {
265 my_type_map.bits[types[i] / 32] &= ~(1 << (types[i] % 32));
266 changed = GNUNET_YES;
267 }
268 }
269 if (GNUNET_YES == changed)
270 {
273 }
274}

References GSC_TypeMap::bits, broadcast_my_type_map(), GNUNET_NO, GNUNET_YES, map_counters, my_type_map, and rehash_typemap().

Referenced by client_disconnect_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GSC_TYPEMAP_test_match()

int GSC_TYPEMAP_test_match ( const struct GSC_TypeMap tmap,
const uint16_t *  types,
unsigned int  tcnt 
)

Test if any of the types from the types array is in the given type map.

Parameters
tmapmap to test
typesarray of types
tcntnumber of entries in types
Returns
GNUNET_YES if a type is in the map, GNUNET_NO if not

Definition at line 287 of file gnunet-service-core_typemap.c.

290{
291 if (NULL == tmap)
292 return GNUNET_NO;
293 if (0 == tcnt)
294 return GNUNET_YES; /* matches all */
295 for (unsigned int i = 0; i < tcnt; i++)
296 if (0 != (tmap->bits[types[i] / 32] & (1 << (types[i] % 32))))
297 return GNUNET_YES;
298 return GNUNET_NO;
299}

References GSC_TypeMap::bits, GNUNET_NO, and GNUNET_YES.

Referenced by GSC_CLIENTS_notify_client_about_neighbour(), and GSC_SESSIONS_add_to_typemap().

Here is the caller graph for this function:

◆ GSC_TYPEMAP_extend()

struct GSC_TypeMap * GSC_TYPEMAP_extend ( const struct GSC_TypeMap tmap,
const uint16_t *  types,
unsigned int  tcnt 
)

Add additional types to a given typemap.

Parameters
tmapmap to extend (not changed)
typesarray of types to add
tcntnumber of entries in types
Returns
updated type map (fresh copy)

Definition at line 311 of file gnunet-service-core_typemap.c.

314{
315 struct GSC_TypeMap *ret;
316
317 ret = GNUNET_new (struct GSC_TypeMap);
318 if (NULL != tmap)
319 GNUNET_memcpy (ret, tmap, sizeof(struct GSC_TypeMap));
320 for (unsigned int i = 0; i < tcnt; i++)
321 ret->bits[types[i] / 32] |= (1 << (types[i] % 32));
322 return ret;
323}

References GNUNET_memcpy, GNUNET_new, and ret.

Referenced by GSC_SESSIONS_add_to_typemap().

Here is the caller graph for this function:

◆ GSC_TYPEMAP_create()

struct GSC_TypeMap * GSC_TYPEMAP_create ( void  )

Create an empty type map.

Returns
an empty type map

Definition at line 332 of file gnunet-service-core_typemap.c.

333{
334 return GNUNET_new (struct GSC_TypeMap);
335}

References GNUNET_new.

Referenced by GSC_SESSIONS_create().

Here is the caller graph for this function:

◆ GSC_TYPEMAP_destroy()

void GSC_TYPEMAP_destroy ( struct GSC_TypeMap tmap)

Free the given type map.

Parameters
tmapa type map

Definition at line 344 of file gnunet-service-core_typemap.c.

345{
346 GNUNET_free (tmap);
347}

References GNUNET_free.

Referenced by GSC_SESSIONS_add_to_typemap(), GSC_SESSIONS_end(), and GSC_SESSIONS_set_typemap().

Here is the caller graph for this function:

◆ GSC_TYPEMAP_init()

void GSC_TYPEMAP_init ( void  )

Initialize typemap subsystem.

Definition at line 354 of file gnunet-service-core_typemap.c.

355{
356 /* nothing to do */
357}

Referenced by run().

Here is the caller graph for this function:

◆ GSC_TYPEMAP_done()

void GSC_TYPEMAP_done ( void  )

Shutdown typemap subsystem.

Definition at line 364 of file gnunet-service-core_typemap.c.

365{
366 /* nothing to do */
367}

Referenced by shutdown_task().

Here is the caller graph for this function:

Variable Documentation

◆ my_type_map

struct GSC_TypeMap my_type_map
static

Bitmap of message types this peer is able to handle.

Definition at line 46 of file gnunet-service-core_typemap.c.

Referenced by GSC_TYPEMAP_add(), GSC_TYPEMAP_check_hash(), GSC_TYPEMAP_compute_type_map_message(), and GSC_TYPEMAP_remove().

◆ map_counters

uint8_t map_counters[UINT16_MAX+1]
static

Counters for message types this peer is able to handle.

Definition at line 51 of file gnunet-service-core_typemap.c.

Referenced by GSC_TYPEMAP_add(), and GSC_TYPEMAP_remove().

◆ my_tm_hash

struct GNUNET_HashCode my_tm_hash
static

Current hash of our (uncompressed) type map.

Lazily computed when needed.

Definition at line 57 of file gnunet-service-core_typemap.c.

Referenced by GSC_TYPEMAP_check_hash().

◆ hash_current

int hash_current
static

Is my_tm_hash() current with respect to our type map?

Definition at line 62 of file gnunet-service-core_typemap.c.

Referenced by GSC_TYPEMAP_check_hash(), and rehash_typemap().