GNUnet 0.22.0
gnunet-service-messenger_handle.c File Reference
Include dependency graph for gnunet-service-messenger_handle.c:

Go to the source code of this file.

Data Structures

struct  GNUNET_MESSENGER_NextMemberId
 

Functions

struct GNUNET_MESSENGER_SrvHandlecreate_srv_handle (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MQ_Handle *mq)
 Creates and allocates a new handle related to a service and using a given mq (message queue). More...
 
static enum GNUNET_GenericReturnValue iterate_close_rooms (void *cls, const struct GNUNET_HashCode *key, void *value)
 
static enum GNUNET_GenericReturnValue iterate_free_values (void *cls, const struct GNUNET_HashCode *key, void *value)
 
void destroy_srv_handle (struct GNUNET_MESSENGER_SrvHandle *handle)
 Destroys a handle and frees its memory fully. More...
 
void set_srv_handle_key (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_CRYPTO_PublicKey *key)
 Sets the public key of a given handle. More...
 
const struct GNUNET_CRYPTO_PublicKeyget_srv_handle_key (const struct GNUNET_MESSENGER_SrvHandle *handle)
 Returns the public key of a given handle. More...
 
void get_srv_handle_data_subdir (const struct GNUNET_MESSENGER_SrvHandle *handle, const char *name, char **dir)
 Writes the path of the directory for a given handle using a specific name to the parameter dir. More...
 
static enum GNUNET_GenericReturnValue create_handle_member_id (const struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
 
const struct GNUNET_ShortHashCodeget_srv_handle_member_id (const struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
 Returns the member id of a given handle in a specific room. More...
 
enum GNUNET_GenericReturnValue change_srv_handle_member_id (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key, const struct GNUNET_ShortHashCode *unique_id)
 Changes the member id of a given handle in a specific room to match a unique_id and returns GNUNET_OK on success. More...
 
enum GNUNET_GenericReturnValue open_srv_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
 Makes a given handle a member of the room using a specific key and opens the room from the handles service. More...
 
enum GNUNET_GenericReturnValue entry_srv_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_PeerIdentity *door, const struct GNUNET_HashCode *key)
 Makes a given handle a member of the room using a specific key and enters the room through a tunnel to a peer identified by a given door (peer identity). More...
 
enum GNUNET_GenericReturnValue close_srv_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
 Removes the membership of the room using a specific key and closes it if no other handle from this service is still a member of it. More...
 
enum GNUNET_GenericReturnValue is_srv_handle_routing (const struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
 Returns whether a given handle has enabled routing for a room using a specific key by opening that room. More...
 
void sync_srv_handle_messages (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key, const struct GNUNET_HashCode *prev, struct GNUNET_HashCode *hash)
 Returns the latest merged hash from a room of a given handle using a specific key and the handles own latest known hash of a message. More...
 
enum GNUNET_GenericReturnValue send_srv_handle_message (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key, const struct GNUNET_MESSENGER_Message *message)
 Sends a message from a given handle to the room using a specific key. More...
 
static const struct GNUNET_HashCodeget_next_member_session_context (const struct GNUNET_MESSENGER_MemberSession *session)
 
static const struct GNUNET_MESSENGER_MemberSessionget_handle_member_session (struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_HashCode *key)
 
void notify_srv_handle_message (struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_MESSENGER_SenderSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash, enum GNUNET_GenericReturnValue recent)
 Notifies the handle that a new message was received or sent. More...
 
static enum GNUNET_GenericReturnValue iterate_next_member_ids (void *cls, const struct GNUNET_HashCode *key, void *value)
 
static void task_notify_srv_handle_member_id (void *cls)
 
void notify_srv_handle_member_id (struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_ShortHashCode *member_id, enum GNUNET_GenericReturnValue reset)
 Notifies the handle that a new member id needs to be used. More...
 

Function Documentation

◆ create_srv_handle()

struct GNUNET_MESSENGER_SrvHandle * create_srv_handle ( struct GNUNET_MESSENGER_Service service,
struct GNUNET_MQ_Handle mq 
)

Creates and allocates a new handle related to a service and using a given mq (message queue).

Parameters
[in,out]serviceMESSENGER Service
[in,out]mqMessage queue
Returns
New handle

Definition at line 42 of file gnunet-service-messenger_handle.c.

44{
46
47 GNUNET_assert ((service) && (mq));
48
50
51 handle->service = service;
52 handle->mq = mq;
53
57
58 handle->notify = NULL;
59
60 return handle;
61}
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
static struct GNUNET_VPN_Handle * handle
Handle to vpn service.
Definition: gnunet-vpn.c:35
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
@ GNUNET_NO
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_MQ_Handle * mq
Connection to VPN service.
Definition: vpn_api.c:44

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_create(), GNUNET_new, GNUNET_NO, handle, mq, GNUNET_VPN_Handle::mq, and service.

Referenced by add_service_handle().

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

◆ iterate_close_rooms()

static enum GNUNET_GenericReturnValue iterate_close_rooms ( void *  cls,
const struct GNUNET_HashCode key,
void *  value 
)
static

Definition at line 65 of file gnunet-service-messenger_handle.c.

68{
70
71 GNUNET_assert ((cls) && (key));
72
73 handle = cls;
74
76 return GNUNET_YES;
77}
struct GNUNET_HashCode key
The key used in the DHT.
enum GNUNET_GenericReturnValue close_service_room(struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key, enum GNUNET_GenericReturnValue deletion)
Tries to close a room using a given key for a service by a specific handle.
@ GNUNET_YES

References close_service_room(), GNUNET_assert, GNUNET_NO, GNUNET_YES, handle, and key.

Referenced by destroy_srv_handle().

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

◆ iterate_free_values()

static enum GNUNET_GenericReturnValue iterate_free_values ( void *  cls,
const struct GNUNET_HashCode key,
void *  value 
)
static

Definition at line 81 of file gnunet-service-messenger_handle.c.

84{
86
88 return GNUNET_YES;
89}
static char * value
Value of the record to add/remove.
#define GNUNET_free(ptr)
Wrapper around free.

References GNUNET_assert, GNUNET_free, GNUNET_YES, and value.

Referenced by close_srv_handle_room(), and destroy_srv_handle().

Here is the caller graph for this function:

◆ destroy_srv_handle()

void destroy_srv_handle ( struct GNUNET_MESSENGER_SrvHandle handle)

Destroys a handle and frees its memory fully.

Parameters
[in,out]handleHandle

Definition at line 93 of file gnunet-service-messenger_handle.c.

94{
96
99
100 if (handle->notify)
102
104 iterate_free_values, NULL);
106 iterate_free_values, NULL);
107
111
113}
static enum GNUNET_GenericReturnValue iterate_free_values(void *cls, const struct GNUNET_HashCode *key, void *value)
static enum GNUNET_GenericReturnValue iterate_close_rooms(void *cls, const struct GNUNET_HashCode *key, void *value)
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MultiHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:979

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_free, GNUNET_SCHEDULER_cancel(), handle, iterate_close_rooms(), and iterate_free_values().

Referenced by clear_list_handles(), and remove_service_handle().

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

◆ set_srv_handle_key()

void set_srv_handle_key ( struct GNUNET_MESSENGER_SrvHandle handle,
const struct GNUNET_CRYPTO_PublicKey key 
)

Sets the public key of a given handle.

Parameters
[out]handleHandle
[in]keyPublic key

Definition at line 117 of file gnunet-service-messenger_handle.c.

119{
121
122 if ((handle->key) && (! key))
123 {
124 GNUNET_free (handle->key);
125 handle->key = NULL;
126 }
127 else if (! handle->key)
129
130 if (key)
131 memcpy (handle->key, key, sizeof(struct GNUNET_CRYPTO_PublicKey));
132}
An identity key as per LSD0001.

References GNUNET_assert, GNUNET_free, GNUNET_new, handle, and key.

Referenced by initialize_handle_via_key(), send_message_join(), and send_message_key().

Here is the caller graph for this function:

◆ get_srv_handle_key()

const struct GNUNET_CRYPTO_PublicKey * get_srv_handle_key ( const struct GNUNET_MESSENGER_SrvHandle handle)

Returns the public key of a given handle.

Parameters
[in]handleHandle
Returns
Public key of handle

Definition at line 136 of file gnunet-service-messenger_handle.c.

137{
139
140 return handle->key;
141}

References GNUNET_assert, and handle.

Referenced by find_member_session_in_room(), get_handle_member_session(), handle_get_message(), initialize_service_handle(), and solve_srv_room_member_collisions().

Here is the caller graph for this function:

◆ get_srv_handle_data_subdir()

void get_srv_handle_data_subdir ( const struct GNUNET_MESSENGER_SrvHandle handle,
const char *  name,
char **  dir 
)

Writes the path of the directory for a given handle using a specific name to the parameter dir.

This directory will be used to store data regarding the handle and its messages.

Parameters
[in]handleHandle
[in]namePotential name of the handle
[out]dirPath to store data

Definition at line 145 of file gnunet-service-messenger_handle.c.

148{
149 GNUNET_assert ((handle) && (dir));
150
151 if (name)
152 GNUNET_asprintf (dir, "%s%s%c%s%c", handle->service->dir, "identities",
154 else
155 GNUNET_asprintf (dir, "%s%s%c", handle->service->dir, "anonymous",
157}
static char * dir
Set to the directory where runtime files are stored.
Definition: gnunet-arm.c:88
static char * name
Name (label) of the records to list.
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define DIR_SEPARATOR
Definition: platform.h:165

References dir, DIR_SEPARATOR, GNUNET_asprintf(), GNUNET_assert, handle, and name.

Here is the call graph for this function:

◆ create_handle_member_id()

static enum GNUNET_GenericReturnValue create_handle_member_id ( const struct GNUNET_MESSENGER_SrvHandle handle,
const struct GNUNET_HashCode key 
)
static

Definition at line 161 of file gnunet-service-messenger_handle.c.

163{
164 struct GNUNET_ShortHashCode *random_id;
165
166 GNUNET_assert ((handle) && (key));
167
168 random_id = GNUNET_new (struct GNUNET_ShortHashCode);
169
170 if (! random_id)
171 return GNUNET_NO;
172
173 generate_free_member_id (random_id, NULL);
174
176 random_id,
178 {
179 GNUNET_free (random_id);
180 return GNUNET_NO;
181 }
182
184 "Created a new member id (%s) for room: %s\n", GNUNET_sh2s (
185 random_id),
186 GNUNET_h2s (key));
187
188 return GNUNET_YES;
189}
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST
, ' bother checking if a value already exists (faster than GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE...
#define GNUNET_log(kind,...)
@ GNUNET_OK
const char * GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_DEBUG
enum GNUNET_GenericReturnValue generate_free_member_id(struct GNUNET_ShortHashCode *id, const struct GNUNET_CONTAINER_MultiShortmap *members)
Tries to generate an unused member id and store it into the id parameter.
A 256-bit hashcode.

References generate_free_member_id(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_sh2s(), GNUNET_YES, handle, and key.

Referenced by entry_srv_handle_room(), and open_srv_handle_room().

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

◆ get_srv_handle_member_id()

const struct GNUNET_ShortHashCode * get_srv_handle_member_id ( const struct GNUNET_MESSENGER_SrvHandle handle,
const struct GNUNET_HashCode key 
)

Returns the member id of a given handle in a specific room.

If the handle is not a member of the specific room, NULL gets returned.

Parameters
[in]handleHandle
[in]keyKey of a room
Returns
Member id or NULL

Definition at line 193 of file gnunet-service-messenger_handle.c.

195{
196 GNUNET_assert ((handle) && (key));
197
198 return GNUNET_CONTAINER_multihashmap_get (handle->member_ids, key);
199}
void * GNUNET_CONTAINER_multihashmap_get(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Given a key find a value in the map matching the key.

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), handle, and key.

Referenced by close_srv_handle_room(), entry_srv_handle_room(), find_list_handle_by_member(), get_handle_member_session(), handle_get_message(), handle_room_entry(), handle_room_open(), join_room_locally(), notify_srv_handle_message(), open_srv_handle_room(), open_srv_room(), send_srv_handle_message(), solve_srv_room_member_collisions(), and sync_srv_handle_messages().

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

◆ change_srv_handle_member_id()

enum GNUNET_GenericReturnValue change_srv_handle_member_id ( struct GNUNET_MESSENGER_SrvHandle handle,
const struct GNUNET_HashCode key,
const struct GNUNET_ShortHashCode unique_id 
)

Changes the member id of a given handle in a specific room to match a unique_id and returns GNUNET_OK on success.

The client connected to the handle will be informed afterwards automatically.

Parameters
[in,out]handleHandle
[in]keyKey of a room
[in]unique_idUnique member id
Returns
GNUNET_OK on success, otherwise GNUNET_SYSERR

Definition at line 203 of file gnunet-service-messenger_handle.c.

206{
207 struct GNUNET_ShortHashCode *member_id;
208
209 GNUNET_assert ((handle) && (key) && (unique_id));
210
211 member_id = GNUNET_CONTAINER_multihashmap_get (handle->member_ids, key);
212
213 if (! member_id)
214 {
215 member_id = GNUNET_new (struct GNUNET_ShortHashCode);
216 GNUNET_memcpy (member_id, unique_id, sizeof(*member_id));
217
219 member_id,
221 {
222 GNUNET_free (member_id);
223 return GNUNET_SYSERR;
224 }
225 }
226
227 if (0 == GNUNET_memcmp (unique_id, member_id))
228 return GNUNET_OK;
229
231 "Change a member id (%s) for room (%s).\n", GNUNET_sh2s (
232 member_id),
233 GNUNET_h2s (key));
234
235 GNUNET_memcpy (member_id, unique_id, sizeof(*unique_id));
236
237 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Member id changed to (%s).\n",
238 GNUNET_sh2s (unique_id));
239 return GNUNET_OK;
240}
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_SYSERR

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_memcmp, GNUNET_memcpy, GNUNET_new, GNUNET_OK, GNUNET_sh2s(), GNUNET_SYSERR, handle, and key.

Referenced by find_member_session_in_room(), join_room(), and send_message_id().

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

◆ open_srv_handle_room()

enum GNUNET_GenericReturnValue open_srv_handle_room ( struct GNUNET_MESSENGER_SrvHandle handle,
const struct GNUNET_HashCode key 
)

Makes a given handle a member of the room using a specific key and opens the room from the handles service.

Parameters
[in,out]handleHandle
[in]keyKey of a room
Returns
GNUNET_YES on success, otherwise GNUNET_NO

Definition at line 244 of file gnunet-service-messenger_handle.c.

246{
247 GNUNET_assert ((handle) && (key));
248
250 key,
251 NULL,
253
254 return GNUNET_NO;
255
258 key)))
259 return GNUNET_NO;
260
261 return open_service_room (handle->service, handle, key);
262}
const struct GNUNET_ShortHashCode * get_srv_handle_member_id(const struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
Returns the member id of a given handle in a specific room.
static enum GNUNET_GenericReturnValue create_handle_member_id(const struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
enum GNUNET_GenericReturnValue open_service_room(struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
Tries to open a room using a given key for a service by a specific handle.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE
If a value with the given key exists, replace it.

References create_handle_member_id(), get_srv_handle_member_id(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE, GNUNET_NO, GNUNET_OK, GNUNET_YES, handle, key, and open_service_room().

Referenced by handle_room_open().

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

◆ entry_srv_handle_room()

enum GNUNET_GenericReturnValue entry_srv_handle_room ( struct GNUNET_MESSENGER_SrvHandle handle,
const struct GNUNET_PeerIdentity door,
const struct GNUNET_HashCode key 
)

Makes a given handle a member of the room using a specific key and enters the room through a tunnel to a peer identified by a given door (peer identity).

Parameters
[in,out]handleHandle
[in]doorPeer identity
[in]keyKey of a room
Returns
GNUNET_YES on success, otherwise GNUNET_NO

Definition at line 266 of file gnunet-service-messenger_handle.c.

269{
270 GNUNET_assert ((handle) && (door) && (key));
271
274 handle, key)))
275 return GNUNET_NO;
276
277 return entry_service_room (handle->service, handle, door, key);
278}
enum GNUNET_GenericReturnValue entry_service_room(struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_PeerIdentity *door, const struct GNUNET_HashCode *key)
Tries to enter a room using a given key for a service by a specific handle.

References create_handle_member_id(), entry_service_room(), get_srv_handle_member_id(), GNUNET_assert, GNUNET_NO, GNUNET_YES, handle, and key.

Referenced by handle_room_entry().

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

◆ close_srv_handle_room()

enum GNUNET_GenericReturnValue close_srv_handle_room ( struct GNUNET_MESSENGER_SrvHandle handle,
const struct GNUNET_HashCode key 
)

Removes the membership of the room using a specific key and closes it if no other handle from this service is still a member of it.

Parameters
[in,out]handleHandle
[in]keyKey of a room
Returns
GNUNET_YES on success, otherwise GNUNET_NO

Definition at line 282 of file gnunet-service-messenger_handle.c.

284{
285 GNUNET_assert ((handle) && (key));
286
288 iterate_free_values, NULL);
290
291 if ((handle->notify) && (0 == GNUNET_CONTAINER_multihashmap_size (
292 handle->next_ids)))
293 {
295 handle->notify = NULL;
296 }
297
299 return GNUNET_NO;
300
301 {
304
305 if (GNUNET_YES != result)
306 return result;
307
309 return result;
310 }
311}
static int result
Global testing status.
int GNUNET_CONTAINER_multihashmap_remove_all(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Remove all entries for the given key from the map.
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_get_multiple(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, GNUNET_CONTAINER_MultiHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map that match a particular key.
GNUNET_GenericReturnValue
Named constants for return values.

References close_service_room(), get_srv_handle_member_id(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_get_multiple(), GNUNET_CONTAINER_multihashmap_remove_all(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_YES, handle, iterate_free_values(), key, and result.

Referenced by handle_room_close().

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

◆ is_srv_handle_routing()

enum GNUNET_GenericReturnValue is_srv_handle_routing ( const struct GNUNET_MESSENGER_SrvHandle handle,
const struct GNUNET_HashCode key 
)

Returns whether a given handle has enabled routing for a room using a specific key by opening that room.

Parameters
[in]handleHandle
[in]keyKey of a room
Returns
GNUNET_YES is routing is enabled, otherwise GNUNET_NO

Definition at line 315 of file gnunet-service-messenger_handle.c.

317{
318 GNUNET_assert ((handle) && (key));
319
321}
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_contains(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Check if the map contains any value under the given key (including values that are NULL).

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_contains(), handle, and key.

Referenced by find_list_handle_by_member(), and rebuild_srv_room_basement_structure().

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

◆ sync_srv_handle_messages()

void sync_srv_handle_messages ( struct GNUNET_MESSENGER_SrvHandle handle,
const struct GNUNET_HashCode key,
const struct GNUNET_HashCode prev,
struct GNUNET_HashCode hash 
)

Returns the latest merged hash from a room of a given handle using a specific key and the handles own latest known hash of a message.

If the room does not contain other messages being accessible to the handle and older than the provided hash, the function returns the originally provided hash as fallback.

Parameters
[in,out]handleHandle
[in]keyKey of a room
[in]prevKnown hash of a message
[out]hashHash of the latest merged message in a room available to the handle

Definition at line 325 of file gnunet-service-messenger_handle.c.

329{
330 struct GNUNET_MESSENGER_SrvRoom *room;
331
332 GNUNET_assert ((handle) && (key) && (prev) && (hash));
333
334 room = get_service_room (handle->service, key);
335
336 if ((! room) || (! get_srv_handle_member_id (handle, key)))
337 {
338 GNUNET_memcpy (hash, prev, sizeof(*hash));
339 return;
340 }
341
343 get_message_state_chain_hash (&(room->state), hash);
344}
void get_message_state_chain_hash(const struct GNUNET_MESSENGER_MessageState *state, struct GNUNET_HashCode *hash)
void merge_srv_room_last_messages(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle)
Reduces all current forks inside of the message history of a room to one remaining last message by me...
struct GNUNET_MESSENGER_SrvRoom * get_service_room(const struct GNUNET_MESSENGER_Service *service, const struct GNUNET_HashCode *key)
Returns the room identified by a given key for a service.
struct GNUNET_MESSENGER_MessageState state

References get_message_state_chain_hash(), get_service_room(), get_srv_handle_member_id(), GNUNET_assert, GNUNET_memcpy, handle, key, merge_srv_room_last_messages(), and GNUNET_MESSENGER_SrvRoom::state.

Referenced by handle_room_entry(), handle_room_open(), and handle_room_sync().

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

◆ send_srv_handle_message()

enum GNUNET_GenericReturnValue send_srv_handle_message ( struct GNUNET_MESSENGER_SrvHandle handle,
const struct GNUNET_HashCode key,
const struct GNUNET_MESSENGER_Message message 
)

Sends a message from a given handle to the room using a specific key.

Parameters
[in,out]handleHandle
[in]keyKey of a room
[in]messageMessage
Returns
GNUNET_YES on success, GNUNET_NO or GNUNET_SYSERR otherwise.

Definition at line 348 of file gnunet-service-messenger_handle.c.

351{
352 const struct GNUNET_ShortHashCode *id;
353 struct GNUNET_MESSENGER_SrvRoom *room;
354
355 GNUNET_assert ((handle) && (key) && (message));
356
358
359 if (! id)
360 {
362 "It is required to be a member of a room to send messages!\n");
363 return GNUNET_NO;
364 }
365
366 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending message with member id: %s\n",
367 GNUNET_sh2s (id));
368
369 if (0 != GNUNET_memcmp (id, &(message->header.sender_id)))
370 {
372 "Member id does not match with handle!\n");
373 return GNUNET_NO;
374 }
375
376 room = get_service_room (handle->service, key);
377
378 if (! room)
379 {
380 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "The room (%s) is unknown!\n",
381 GNUNET_h2s (key));
382 return GNUNET_NO;
383 }
384
385 {
387 msg = copy_message (message);
388
389 if (! msg)
390 {
391 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Copying message failed!\n");
392 return GNUNET_NO;
393 }
394
395 return send_srv_room_message (room, handle, msg);
396 }
397}
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
static struct GNUNET_IDENTITY_Handle * id
Handle to IDENTITY.
enum GNUNET_GenericReturnValue send_srv_room_message(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_Message *message)
Sends a message from a given handle into a room.
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_ERROR
struct GNUNET_MESSENGER_Message * copy_message(const struct GNUNET_MESSENGER_Message *message)
Creates and allocates a copy of a given message.
struct GNUNET_ShortHashCode sender_id
The senders id inside of the room the message was sent in.
struct GNUNET_MESSENGER_MessageHeader header
Header.

References copy_message(), get_service_room(), get_srv_handle_member_id(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_h2s(), GNUNET_log, GNUNET_memcmp, GNUNET_NO, GNUNET_sh2s(), handle, GNUNET_MESSENGER_Message::header, id, key, msg, send_srv_room_message(), and GNUNET_MESSENGER_MessageHeader::sender_id.

Referenced by handle_send_message().

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

◆ get_next_member_session_context()

static const struct GNUNET_HashCode * get_next_member_session_context ( const struct GNUNET_MESSENGER_MemberSession session)
static

Definition at line 401 of file gnunet-service-messenger_handle.c.

403{
404 GNUNET_assert (session);
405
406 if (session->next)
407 return get_next_member_session_context (session->next);
408 else
409 return get_member_session_context (session);
410}
static const struct GNUNET_HashCode * get_next_member_session_context(const struct GNUNET_MESSENGER_MemberSession *session)
const struct GNUNET_HashCode * get_member_session_context(const struct GNUNET_MESSENGER_MemberSession *session)
Returns the member context of a given member session.
struct GNUNET_MESSENGER_MemberSession * next

References get_member_session_context(), get_next_member_session_context(), GNUNET_assert, and GNUNET_MESSENGER_MemberSession::next.

Referenced by get_next_member_session_context(), and notify_srv_handle_message().

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

◆ get_handle_member_session()

static const struct GNUNET_MESSENGER_MemberSession * get_handle_member_session ( struct GNUNET_MESSENGER_SrvHandle handle,
struct GNUNET_MESSENGER_SrvRoom room,
const struct GNUNET_HashCode key 
)
static

Definition at line 414 of file gnunet-service-messenger_handle.c.

417{
418 const struct GNUNET_ShortHashCode *id;
419 const struct GNUNET_CRYPTO_PublicKey *pubkey;
420
421 GNUNET_assert ((handle) && (room) && (key) && (handle->service));
422
424
425 if (! id)
426 {
428 "Handle is missing a member id for its member session! (%s)\n",
429 GNUNET_h2s (key));
430 return NULL;
431 }
432
434
435 if (! pubkey)
436 {
438 "Handle is missing a public key for its member session! (%s)\n",
439 GNUNET_h2s (key));
440 return NULL;
441 }
442
443 {
444 struct GNUNET_MESSENGER_MemberStore *store;
445 struct GNUNET_MESSENGER_Member *member;
446
448 member = get_store_member (store, id);
449
450 return get_member_session (member, pubkey);
451 }
452}
static struct GNUNET_CRYPTO_PublicKey pubkey
Public key of the zone to look in.
const struct GNUNET_CRYPTO_PublicKey * get_srv_handle_key(const struct GNUNET_MESSENGER_SrvHandle *handle)
Returns the public key of a given handle.
struct GNUNET_MESSENGER_MemberSession * get_member_session(const struct GNUNET_MESSENGER_Member *member, const struct GNUNET_CRYPTO_PublicKey *public_key)
Returns the member session of a member identified by a given public key.
struct GNUNET_MESSENGER_Member * get_store_member(const struct GNUNET_MESSENGER_MemberStore *store, const struct GNUNET_ShortHashCode *id)
Returns the member in a store identified by a given id.
struct GNUNET_MESSENGER_MemberStore * get_srv_room_member_store(struct GNUNET_MESSENGER_SrvRoom *room)
Returns the used member store of a given room.
struct GNUNET_MESSENGER_MemberStore * store

References get_member_session(), get_srv_handle_key(), get_srv_handle_member_id(), get_srv_room_member_store(), get_store_member(), GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_h2s(), GNUNET_log, handle, id, key, pubkey, and GNUNET_MESSENGER_Member::store.

Referenced by notify_srv_handle_message().

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

◆ notify_srv_handle_message()

void notify_srv_handle_message ( struct GNUNET_MESSENGER_SrvHandle handle,
struct GNUNET_MESSENGER_SrvRoom room,
const struct GNUNET_MESSENGER_SenderSession session,
const struct GNUNET_MESSENGER_Message message,
const struct GNUNET_HashCode hash,
enum GNUNET_GenericReturnValue  recent 
)

Notifies the handle that a new message was received or sent.

Parameters
[in,out]handleHandle
[in]roomRoom of the message
[in]sessionSender session
[in]messageMessage
[in]hashHash of message
[in]recentWhether the message was recently handled

Definition at line 456 of file gnunet-service-messenger_handle.c.

462{
463 const struct GNUNET_HashCode *key;
464 const struct GNUNET_ShortHashCode *id;
465 const struct GNUNET_HashCode *context;
467 const struct GNUNET_ShortHashCode *discourse;
468 struct GNUNET_MESSENGER_Subscription *subscription;
469 struct GNUNET_HashCode sender;
470
471 GNUNET_assert ((handle) && (room) && (session) && (message) && (hash));
472
473 key = get_srv_room_key (room);
475
476 if ((! handle->mq) || (! id))
477 {
479 "Notifying client about message requires membership!\n");
480 return;
481 }
482
483 context = NULL;
484
485 if (GNUNET_MESSENGER_KIND_TALK != message->header.kind)
486 goto skip_message_filter;
487
489 discourse = &(message->body.talk.discourse);
490
491 {
492 struct GNUNET_MESSENGER_MemberStore *member_store;
493 struct GNUNET_MESSENGER_Member *member;
494
495 member_store = get_srv_room_member_store (room);
496
497 if (! member_store)
498 return;
499
500 member = get_store_member (member_store, id);
501
502 if (! member)
503 return;
504
505 subscription = get_member_subscription(member, discourse);
506 }
507
508 if ((! subscription) ||
510 {
512 "Dropping message for client outside of subscription: %s\n",
513 GNUNET_h2s (hash));
514 return;
515 }
516
517skip_message_filter:
518 if (GNUNET_YES == is_peer_message (message))
519 {
520 const struct GNUNET_PeerIdentity *identity = session->peer;
521 GNUNET_CRYPTO_hash (identity, sizeof(*identity), &sender);
522
523 context = &sender;
524 }
525 else
526 {
527 const struct GNUNET_CRYPTO_PublicKey *pubkey;
529 GNUNET_CRYPTO_hash (pubkey, sizeof(*pubkey), &sender);
530
532 }
533
535 "Notifying client about message: %s (%s)\n",
537 message->header.kind));
538
539 {
541 struct GNUNET_MQ_Envelope *env;
542 uint16_t length;
543 char *buffer;
544
545 length = get_message_size (message, GNUNET_YES);
546
547 env = GNUNET_MQ_msg_extra (msg, length,
549
550 GNUNET_memcpy (&(msg->key), key, sizeof(msg->key));
551 GNUNET_memcpy (&(msg->sender), &sender, sizeof(msg->sender));
552 GNUNET_memcpy (&(msg->context), context, sizeof(msg->context));
553 GNUNET_memcpy (&(msg->hash), hash, sizeof(msg->hash));
554
555 msg->flags = (uint32_t) GNUNET_MESSENGER_FLAG_NONE;
556
557 if (GNUNET_YES == is_peer_message (message))
558 msg->flags |= (uint32_t) GNUNET_MESSENGER_FLAG_PEER;
559 else if (get_handle_member_session (handle, room, key) == session->member)
560 msg->flags |= (uint32_t) GNUNET_MESSENGER_FLAG_SENT;
561
562 if (GNUNET_YES == recent)
563 msg->flags |= (uint32_t) GNUNET_MESSENGER_FLAG_RECENT;
564
565 buffer = ((char*) msg) + sizeof(*msg);
566 encode_message (message, length, buffer, GNUNET_YES);
567
569 }
570}
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static uint64_t timestamp(void)
Get current timestamp.
static pa_context * context
Pulseaudio context.
static struct GNUNET_IDENTITY_Handle * identity
Which namespace do we publish to? NULL if we do not publish to a namespace.
static const struct GNUNET_MESSENGER_MemberSession * get_handle_member_session(struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_HashCode *key)
struct GNUNET_MESSENGER_Subscription * get_member_subscription(struct GNUNET_MESSENGER_Member *member, const struct GNUNET_ShortHashCode *discourse)
Returns the active subscription of a given member to a selected discourse.
const struct GNUNET_CRYPTO_PublicKey * get_member_session_public_key(const struct GNUNET_MESSENGER_MemberSession *session)
Returns the public key of a given member session.
const struct GNUNET_HashCode * get_srv_room_key(const struct GNUNET_MESSENGER_SrvRoom *room)
Returns the shared secret you need to access a room.
enum GNUNET_GenericReturnValue has_subscription_of_timestamp(const struct GNUNET_MESSENGER_Subscription *subscribtion, struct GNUNET_TIME_Absolute timestamp)
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
const char * GNUNET_MESSENGER_name_of_kind(enum GNUNET_MESSENGER_MessageKind kind)
Get the name of a message kind.
Definition: messenger_api.c:44
@ GNUNET_MESSENGER_KIND_TALK
The talk kind.
@ GNUNET_MESSENGER_FLAG_SENT
The sent flag.
@ GNUNET_MESSENGER_FLAG_NONE
The none flag.
@ GNUNET_MESSENGER_FLAG_PEER
The peer flag.
@ GNUNET_MESSENGER_FLAG_RECENT
The recent flag.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:305
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition: gnunet_mq_lib.h:63
#define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_RECV_MESSAGE
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:739
void encode_message(const struct GNUNET_MESSENGER_Message *message, uint16_t length, char *buffer, enum GNUNET_GenericReturnValue include_header)
Encodes a given message into a buffer of a maximal length in bytes.
enum GNUNET_GenericReturnValue is_peer_message(const struct GNUNET_MESSENGER_Message *message)
Returns whether a specific kind of message can be sent by the service without usage of a clients priv...
uint16_t get_message_size(const struct GNUNET_MESSENGER_Message *message, enum GNUNET_GenericReturnValue include_header)
Returns the exact size in bytes to encode a given message.
A 512-bit hashcode.
struct GNUNET_MESSENGER_MessageTalk talk
enum GNUNET_MESSENGER_MessageKind kind
The kind of the message.
struct GNUNET_TIME_AbsoluteNBO timestamp
The timestamp of the message.
struct GNUNET_ShortHashCode discourse
The hash of the discourse to talk.
struct GNUNET_MESSENGER_MessageBody body
Body.
Message to receive something from a room.
struct GNUNET_MESSENGER_MemberSession * member
The identity of the host (wraps the signing key of the peer).
Time for absolute times used by GNUnet, in microseconds.

References GNUNET_MESSENGER_Message::body, context, GNUNET_MESSENGER_MessageTalk::discourse, encode_message(), env, get_handle_member_session(), get_member_session_public_key(), get_member_subscription(), get_message_size(), get_next_member_session_context(), get_srv_handle_member_id(), get_srv_room_key(), get_srv_room_member_store(), get_store_member(), GNUNET_assert, GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_RECV_MESSAGE, GNUNET_MESSENGER_FLAG_NONE, GNUNET_MESSENGER_FLAG_PEER, GNUNET_MESSENGER_FLAG_RECENT, GNUNET_MESSENGER_FLAG_SENT, GNUNET_MESSENGER_KIND_TALK, GNUNET_MESSENGER_name_of_kind(), GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_TIME_absolute_ntoh(), GNUNET_YES, handle, has_subscription_of_timestamp(), GNUNET_MESSENGER_Message::header, id, identity, is_peer_message(), key, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_SenderSession::member, GNUNET_VPN_Handle::mq, msg, GNUNET_MESSENGER_SenderSession::peer, pubkey, GNUNET_MESSENGER_MessageBody::talk, GNUNET_MESSENGER_MessageHeader::timestamp, and timestamp().

Referenced by callback_found_message(), handle_service_message(), and notify_about_members().

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

◆ iterate_next_member_ids()

static enum GNUNET_GenericReturnValue iterate_next_member_ids ( void *  cls,
const struct GNUNET_HashCode key,
void *  value 
)
static

Definition at line 574 of file gnunet-service-messenger_handle.c.

577{
580
581 GNUNET_assert ((cls) && (value));
582
583 handle = cls;
584 next = value;
585
587 "Notifying client about next member id: %s (%s)\n",
588 GNUNET_sh2s (&(next->id)), GNUNET_h2s (key));
589
590 {
592 struct GNUNET_MQ_Envelope *env;
593
595
596 GNUNET_memcpy (&(msg->key), key, sizeof(*key));
597 GNUNET_memcpy (&(msg->id), &(next->id), sizeof(next->id));
598 msg->reset = (uint32_t) next->reset;
599
601 }
602
604 return GNUNET_YES;
605}
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:78
#define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_MEMBER_ID
Message to receive the current member id of a handle in room.
struct GNUNET_MQ_Envelope * next
Messages are stored in a linked list.
Definition: mq.c:39

References env, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_MEMBER_ID, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_sh2s(), GNUNET_YES, handle, GNUNET_MESSENGER_NextMemberId::id, key, GNUNET_VPN_Handle::mq, msg, GNUNET_MQ_Envelope::next, and value.

Referenced by task_notify_srv_handle_member_id().

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

◆ task_notify_srv_handle_member_id()

static void task_notify_srv_handle_member_id ( void *  cls)
static

Definition at line 609 of file gnunet-service-messenger_handle.c.

610{
612
613 GNUNET_assert (cls);
614
615 handle = cls;
616 handle->notify = NULL;
617
621}
static enum GNUNET_GenericReturnValue iterate_next_member_ids(void *cls, const struct GNUNET_HashCode *key, void *value)
unsigned int GNUNET_CONTAINER_multihashmap_clear(struct GNUNET_CONTAINER_MultiHashMap *map)
Remove all entries from the map.

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_clear(), GNUNET_CONTAINER_multihashmap_iterate(), handle, and iterate_next_member_ids().

Referenced by notify_srv_handle_member_id().

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

◆ notify_srv_handle_member_id()

void notify_srv_handle_member_id ( struct GNUNET_MESSENGER_SrvHandle handle,
struct GNUNET_MESSENGER_SrvRoom room,
const struct GNUNET_ShortHashCode member_id,
enum GNUNET_GenericReturnValue  reset 
)

Notifies the handle that a new member id needs to be used.

Parameters
[in,out]handleHandle
[in]roomRoom of the member
[in]member_idMember id
[in]resetReset member session with join message

Definition at line 625 of file gnunet-service-messenger_handle.c.

629{
632 const struct GNUNET_HashCode *key;
633
634 GNUNET_assert ((handle) && (room) && (member_id));
635
637 key = get_srv_room_key (room);
638
639 if (! next)
640 {
642 "Allocation of next member id failed: %s (%s)\n",
643 GNUNET_sh2s (member_id), GNUNET_h2s (key));
644 return;
645 }
646
647 GNUNET_memcpy (&(next->id), member_id, sizeof(next->id));
648 next->reset = reset;
649
650 prev = GNUNET_CONTAINER_multihashmap_get (handle->next_ids, key);
651
653 next,
655 {
657 "Update of next member id failed: %s (%s)\n",
658 GNUNET_sh2s (member_id), GNUNET_h2s (key));
659 return;
660 }
661
662 if (prev)
663 GNUNET_free (prev);
664
665 if (! handle->notify)
667 handle);
668}
static int reset
Reset argument.
static void task_notify_srv_handle_member_id(void *cls)
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1303
enum GNUNET_GenericReturnValue reset

References get_srv_room_key(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_new, GNUNET_SCHEDULER_add_now(), GNUNET_sh2s(), GNUNET_YES, handle, GNUNET_MESSENGER_NextMemberId::id, key, reset, GNUNET_MESSENGER_NextMemberId::reset, and task_notify_srv_handle_member_id().

Referenced by join_room(), and solve_srv_room_member_collisions().

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