GNUnet debian-0.24.3-26-g2202bbd4d
plugin_gnsrecord_messenger.c File Reference
Include dependency graph for plugin_gnsrecord_messenger.c:

Go to the source code of this file.

Functions

static char * messenger_value_to_string (void *cls, uint32_t type, const void *data, size_t data_size)
 Convert the 'value' of a record to a string. More...
 
static int messenger_string_to_value (void *cls, uint32_t type, const char *s, void **data, size_t *data_size)
 Convert human-readable version of a 'value' of a record to the binary representation. More...
 
static uint32_t messenger_typename_to_number (void *cls, const char *gns_typename)
 Convert a type name (e.g. More...
 
static const char * messenger_number_to_typename (void *cls, uint32_t type)
 Convert a type number to the corresponding type string (e.g. More...
 
void * libgnunet_plugin_gnsrecord_messenger_init (void *cls)
 Entry point for the plugin. More...
 
void * libgnunet_plugin_gnsrecord_messenger_done (void *cls)
 Exit point from the plugin. More...
 

Variables

struct {
   const char *   name
 
   uint32_t   number
 
name_map []
 Mapping of record type numbers to human-readable record type names. More...
 

Function Documentation

◆ messenger_value_to_string()

static char * messenger_value_to_string ( void *  cls,
uint32_t  type,
const void *  data,
size_t  data_size 
)
static

Convert the 'value' of a record to a string.

Parameters
clsclosure, unused
typetype of the record
datavalue in binary encoding
data_sizenumber of bytes in data
Returns
NULL on error, otherwise human-readable representation of the value

Definition at line 44 of file plugin_gnsrecord_messenger.c.

48{
49 (void) cls;
50 switch (type)
51 {
53 {
54 if (data_size != sizeof(struct GNUNET_MESSENGER_RoomEntryRecord))
55 {
57 return NULL;
58 }
59 {
61
63 &(record->door.public_key));
65 &(record->key), sizeof(struct GNUNET_HashCode));
66
67 char *ret;
68 GNUNET_asprintf (&ret, "%s-%s", key, door);
71 return ret;
72 }
73 }
75 {
77 {
79 return NULL;
80 }
81 {
83
84 char *name = GNUNET_strndup (record->name, 256);
86 &(record->flags), sizeof(uint32_t));
87
88 char *ret;
89 GNUNET_asprintf (&ret, "%s-%s", flags, name);
92 return ret;
93 }
94 }
96 {
98 {
100 return NULL;
101 }
102 {
104
106 &(record->key),
107 sizeof(struct GNUNET_HashCode));
109 &(record->hash),
110 sizeof(struct GNUNET_HashCode));
112 &(record->identifier),
113 sizeof(struct GNUNET_ShortHashCode));
115 &(record->shared_key),
116 sizeof(struct GNUNET_CRYPTO_SymmetricSessionKey));
118 &(record->flags),
119 sizeof(uint32_t));
120
121 char *ret;
123 &ret,
124 "%s-%s-%s-%s-%s",
125 flags,
128 hash,
129 key);
130
136 return ret;
137 }
138 }
139 default:
140 return NULL;
141 }
142}
#define GNUNET_GNSRECORD_TYPE_MESSENGER_ROOM_EPOCH_KEY
Record type to store epoch keys from a messenger room.
#define GNUNET_GNSRECORD_TYPE_MESSENGER_ROOM_ENTRY
Record type to share an entry of a messenger room.
#define GNUNET_GNSRECORD_TYPE_MESSENGER_ROOM_DETAILS
Record type to store details about a messenger room.
static int ret
Final status code.
Definition: gnunet-arm.c:93
static void record(void *cls, size_t data_size, const void *data)
Process recorded audio data.
static char * data
The data to insert into the dht.
struct GNUNET_HashCode key
The key used in the DHT.
static uint32_t type
Type string converted to DNS type value.
static size_t data_size
Number of bytes in data.
char * GNUNET_CRYPTO_eddsa_public_key_to_string(const struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Convert a public key to a string.
Definition: crypto_ecc.c:255
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_strndup(a, length)
Wrapper around GNUNET_xstrndup_.
#define GNUNET_free(ptr)
Wrapper around free.
char * GNUNET_STRINGS_data_to_string_alloc(const void *buf, size_t size)
Return the base32crockford encoding of the given buffer.
Definition: strings.c:807
const char * name
A 512-bit hashcode.
A room details record specifies a custom name for a given room and some additional space for flags.
uint32_t flags
The flags of the room.
A room entry record specifies which peer is hosting a given room and may also specify the key to ente...
struct GNUNET_PeerIdentity door
The peer identity of an open door to a room.
A room epoch key record specifies an epoch key for a given room that can be identified via a given ke...
uint32_t flags
The flags of the epoch or group key.
struct GNUNET_ShortHashCode identifier
The short hash identifying the epoch or group key.
struct GNUNET_CRYPTO_SymmetricSessionKey shared_key
The shared epoch or group key in the room.
struct GNUNET_HashCode hash
The hash identifying the epoch.
A 256-bit hashcode.

References data, data_size, GNUNET_MESSENGER_RoomEntryRecord::door, GNUNET_MESSENGER_RoomDetailsRecord::flags, GNUNET_MESSENGER_RoomEpochKeyRecord::flags, GNUNET_asprintf(), GNUNET_break_op, GNUNET_CRYPTO_eddsa_public_key_to_string(), GNUNET_free, GNUNET_GNSRECORD_TYPE_MESSENGER_ROOM_DETAILS, GNUNET_GNSRECORD_TYPE_MESSENGER_ROOM_ENTRY, GNUNET_GNSRECORD_TYPE_MESSENGER_ROOM_EPOCH_KEY, GNUNET_STRINGS_data_to_string_alloc(), GNUNET_strndup, GNUNET_MESSENGER_RoomEpochKeyRecord::hash, GNUNET_MESSENGER_RoomEpochKeyRecord::identifier, key, name, record(), ret, GNUNET_MESSENGER_RoomEpochKeyRecord::shared_key, and type.

Referenced by libgnunet_plugin_gnsrecord_messenger_init().

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

◆ messenger_string_to_value()

static int messenger_string_to_value ( void *  cls,
uint32_t  type,
const char *  s,
void **  data,
size_t *  data_size 
)
static

Convert human-readable version of a 'value' of a record to the binary representation.

Parameters
clsclosure, unused
typetype of the record
shuman-readable string
dataset to value in binary encoding (will be allocated)
data_sizeset to number of bytes in data
Returns
GNUNET_OK on success

Definition at line 157 of file plugin_gnsrecord_messenger.c.

162{
163 (void) cls;
164 if (NULL == s)
165 {
166 GNUNET_break (0);
167 return GNUNET_SYSERR;
168 }
169
170 switch (type)
171 {
173 {
174 char key[104];
175 const char *dash;
176 struct GNUNET_PeerIdentity door;
177
178 if ((NULL == (dash = strchr (s, '-'))) ||
179 (1 != sscanf (s, "%103s-", key)) ||
181 dash + 1, strlen (dash + 1), &(door.public_key))))
182 {
183 GNUNET_log (
185 _ ("Unable to parse MESSENGER_ROOM_ENTRY record `%s'\n"),
186 s);
187
188 return GNUNET_SYSERR;
189 }
190 {
193 );
194
196 key, strlen (key),
197 &(record->key), sizeof(struct GNUNET_HashCode)))
198 {
199 GNUNET_log (
201 _ ("Unable to parse MESSENGER_ROOM_ENTRY record `%s'\n"),
202 s);
203
205 return GNUNET_SYSERR;
206 }
207
208 record->door = door;
209 *data = record;
211 return GNUNET_OK;
212 }
213 }
215 {
216 char flags[8];
217 const char *dash;
218
219 if ((NULL == (dash = strchr (s, '-'))) ||
220 (1 != sscanf (s, "%7s-", flags)) ||
221 (strlen (dash + 1) > 256))
222 {
223 GNUNET_log (
225 _ ("Unable to parse MESSENGER_ROOM_DETAILS record `%s'\n"),
226 s);
227
228 return GNUNET_SYSERR;
229 }
230 {
233 );
234
236 flags, strlen (flags),
237 &(record->flags), sizeof(uint32_t)))
238 {
239 GNUNET_log (
241 _ ("Unable to parse MESSENGER_ROOM_DETAILS record `%s'\n"),
242 s);
243
245 return GNUNET_SYSERR;
246 }
247
248 GNUNET_memcpy (record->name, dash + 1, strlen (dash + 1));
249
250 *data = record;
252 return GNUNET_OK;
253 }
254 }
256 {
257 char key[104];
258 char hash[104];
259 char identifier[53];
260 char shared_key[104];
261 char flags[8];
262 const char *dash;
263 const char *s0;
264
265 s0 = s;
266 if ((NULL == (dash = strchr (s0, '-'))) ||
267 (1 != sscanf (s0, "%7s-", flags)) ||
268 (strlen (dash + 1) > 104))
269 {
270 GNUNET_log (
272 _ ("Unable to parse MESSENGER_ROOM_EPOCH_KEY record `%s'\n"),
273 s);
274
275 return GNUNET_SYSERR;
276 }
277
278 s0 = dash + 1;
279 if ((NULL == (dash = strchr (s0, '-'))) ||
280 (1 != sscanf (s0, "%103s-", shared_key)) ||
281 (strlen (dash + 1) > 53))
282 {
283 GNUNET_log (
285 _ ("Unable to parse MESSENGER_ROOM_EPOCH_KEY record `%s'\n"),
286 s);
287
288 return GNUNET_SYSERR;
289 }
290
291 s0 = dash + 1;
292 if ((NULL == (dash = strchr (s0, '-'))) ||
293 (1 != sscanf (s0, "%52s-", identifier)) ||
294 (strlen (dash + 1) > 104))
295 {
296 GNUNET_log (
298 _ ("Unable to parse MESSENGER_ROOM_EPOCH_KEY record `%s'\n"),
299 s);
300
301 return GNUNET_SYSERR;
302 }
303
304 s0 = dash + 1;
305 if ((NULL == (dash = strchr (s0, '-'))) ||
306 (1 != sscanf (s0, "%103s-", hash)) ||
307 (strlen (dash + 1) > 103))
308 {
309 GNUNET_log (
311 _ ("Unable to parse MESSENGER_ROOM_EPOCH_KEY record `%s'\n"),
312 s);
313
314 return GNUNET_SYSERR;
315 }
316
317 GNUNET_memcpy (key, dash + 1, strlen (dash + 1));
318
319 {
322 );
323
325 flags, strlen (flags),
326 &(record->flags), sizeof(uint32_t))) ||
328 shared_key, strlen (shared_key),
329 &(record->shared_key),
330 sizeof(struct GNUNET_CRYPTO_SymmetricSessionKey)))
331 ||
333 identifier, strlen (identifier),
334 &(record->identifier),
335 sizeof(struct GNUNET_ShortHashCode)))
336 ||
338 hash, strlen (hash),
339 &(record->hash),
340 sizeof(struct GNUNET_HashCode))) ||
342 key, strlen (key),
343 &(record->key),
344 sizeof(struct GNUNET_HashCode))))
345 {
346 GNUNET_log (
348 _ ("Unable to parse MESSENGER_ROOM_EPOCH_KEY record `%s'\n"),
349 s);
350
352 return GNUNET_SYSERR;
353 }
354
355 *data = record;
357 return GNUNET_OK;
358 }
359 }
360 default:
361 return GNUNET_SYSERR;
362 }
363}
#define GNUNET_log(kind,...)
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_eddsa_public_key_from_string(const char *enc, size_t enclen, struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Convert a string representing a public key to a public key.
Definition: crypto_ecc.c:361
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_OK
@ GNUNET_SYSERR
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ GNUNET_ERROR_TYPE_ERROR
#define GNUNET_new(type)
Allocate a struct or union of the given type.
enum GNUNET_GenericReturnValue GNUNET_STRINGS_string_to_data(const char *enc, size_t enclen, void *out, size_t out_size)
Convert CrockfordBase32 encoding back to data.
Definition: strings.c:832
#define _(String)
GNU gettext support macro.
Definition: platform.h:179
The identity of the host (wraps the signing key of the peer).

References _, data, data_size, GNUNET_MESSENGER_RoomEntryRecord::door, GNUNET_MESSENGER_RoomDetailsRecord::flags, GNUNET_MESSENGER_RoomEpochKeyRecord::flags, GNUNET_break, GNUNET_CRYPTO_eddsa_public_key_from_string(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_GNSRECORD_TYPE_MESSENGER_ROOM_DETAILS, GNUNET_GNSRECORD_TYPE_MESSENGER_ROOM_ENTRY, GNUNET_GNSRECORD_TYPE_MESSENGER_ROOM_EPOCH_KEY, GNUNET_log, GNUNET_memcpy, GNUNET_new, GNUNET_OK, GNUNET_STRINGS_string_to_data(), GNUNET_SYSERR, GNUNET_MESSENGER_RoomEpochKeyRecord::hash, GNUNET_MESSENGER_RoomEpochKeyRecord::identifier, key, GNUNET_PeerIdentity::public_key, record(), GNUNET_MESSENGER_RoomEpochKeyRecord::shared_key, and type.

Referenced by libgnunet_plugin_gnsrecord_messenger_init().

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

◆ messenger_typename_to_number()

static uint32_t messenger_typename_to_number ( void *  cls,
const char *  gns_typename 
)
static

Convert a type name (e.g.

"AAAA") to the corresponding number.

Parameters
clsclosure, unused
gns_typenamename to convert
Returns
corresponding number, UINT32_MAX on error

Definition at line 391 of file plugin_gnsrecord_messenger.c.

393{
394 unsigned int i;
395
396 (void) cls;
397 i = 0;
398 while ((name_map[i].name != NULL) &&
399 (0 != strcasecmp (gns_typename, name_map[i].name)))
400 i++;
401 return name_map[i].number;
402}
static struct @39 name_map[]
Mapping of record type numbers to human-readable record type names.

References name, and name_map.

Referenced by libgnunet_plugin_gnsrecord_messenger_init().

Here is the caller graph for this function:

◆ messenger_number_to_typename()

static const char * messenger_number_to_typename ( void *  cls,
uint32_t  type 
)
static

Convert a type number to the corresponding type string (e.g.

1 to "A")

Parameters
clsclosure, unused
typenumber of a type to convert
Returns
corresponding typestring, NULL on error

Definition at line 413 of file plugin_gnsrecord_messenger.c.

415{
416 unsigned int i;
417
418 (void) cls;
419 i = 0;
420 while ((name_map[i].name != NULL) &&
421 (type != name_map[i].number))
422 i++;
423 return name_map[i].name;
424}

References name, name_map, and type.

Referenced by libgnunet_plugin_gnsrecord_messenger_init().

Here is the caller graph for this function:

◆ libgnunet_plugin_gnsrecord_messenger_init()

void * libgnunet_plugin_gnsrecord_messenger_init ( void *  cls)

Entry point for the plugin.

Parameters
clsNULL
Returns
the exported block API

Definition at line 437 of file plugin_gnsrecord_messenger.c.

438{
440
441 (void) cls;
447 return api;
448}
static char * messenger_value_to_string(void *cls, uint32_t type, const void *data, size_t data_size)
Convert the 'value' of a record to a string.
static const char * messenger_number_to_typename(void *cls, uint32_t type)
Convert a type number to the corresponding type string (e.g.
static uint32_t messenger_typename_to_number(void *cls, const char *gns_typename)
Convert a type name (e.g.
static int messenger_string_to_value(void *cls, uint32_t type, const char *s, void **data, size_t *data_size)
Convert human-readable version of a 'value' of a record to the binary representation.
Each plugin is required to return a pointer to a struct of this type as the return value from its ent...
GNUNET_GNSRECORD_TypenameToNumberFunction typename_to_number
Typename to number.
GNUNET_GNSRECORD_NumberToTypenameFunction number_to_typename
Number to typename.
GNUNET_GNSRECORD_ValueToStringFunction value_to_string
Conversion to string.
void * cls
Closure for all of the callbacks.
GNUNET_GNSRECORD_StringToValueFunction string_to_value
Conversion to binary.

References GNUNET_GNSRECORD_PluginFunctions::cls, GNUNET_new, messenger_number_to_typename(), messenger_string_to_value(), messenger_typename_to_number(), messenger_value_to_string(), GNUNET_GNSRECORD_PluginFunctions::number_to_typename, GNUNET_GNSRECORD_PluginFunctions::string_to_value, GNUNET_GNSRECORD_PluginFunctions::typename_to_number, and GNUNET_GNSRECORD_PluginFunctions::value_to_string.

Here is the call graph for this function:

◆ libgnunet_plugin_gnsrecord_messenger_done()

void * libgnunet_plugin_gnsrecord_messenger_done ( void *  cls)

Exit point from the plugin.

Parameters
clsthe return value from libgnunet_plugin_block_test_init
Returns
NULL

Definition at line 461 of file plugin_gnsrecord_messenger.c.

462{
464
465 GNUNET_free (api);
466 return NULL;
467}

References GNUNET_GNSRECORD_PluginFunctions::cls, and GNUNET_free.

Variable Documentation

◆ name

◆ number

uint32_t number

Definition at line 373 of file plugin_gnsrecord_messenger.c.

◆ 

struct { ... } name_map[]
Initial value:
= {
{ "MESSENGER_ROOM_ENTRY", GNUNET_GNSRECORD_TYPE_MESSENGER_ROOM_ENTRY },
{ "MESSENGER_ROOM_DETAILS", GNUNET_GNSRECORD_TYPE_MESSENGER_ROOM_DETAILS },
{ "MESSENGER_ROOM_EPOCH_KEY", GNUNET_GNSRECORD_TYPE_MESSENGER_ROOM_EPOCH_KEY }
,
{ NULL, UINT32_MAX }
}

Mapping of record type numbers to human-readable record type names.

Referenced by messenger_number_to_typename(), and messenger_typename_to_number().