GNUnet 0.21.0
gnunet-service-messenger_room.h File Reference
Include dependency graph for gnunet-service-messenger_room.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  GNUNET_MESSENGER_SrvRoom
 

Macros

#define GNUNET_MESSENGER_IDLE_DELAY
 
#define GNUNET_MESSENGER_REQUEST_DELAY
 
#define GNUNET_MESSENGER_MERGE_DELAY
 

Typedefs

typedef void() GNUNET_MESSENGER_MessageRequestCallback(void *cls, struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
 Method called whenever a message is found during a request in a room. More...
 

Functions

struct GNUNET_MESSENGER_SrvRoomcreate_srv_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
 Creates and allocates a new room for a handle with a given key. More...
 
void destroy_srv_room (struct GNUNET_MESSENGER_SrvRoom *room, enum GNUNET_GenericReturnValue deletion)
 Destroys a room and frees its memory fully. More...
 
struct GNUNET_MESSENGER_PeerStoreget_srv_room_peer_store (struct GNUNET_MESSENGER_SrvRoom *room)
 Returns the used peer store of a given room. More...
 
struct GNUNET_MESSENGER_MemberStoreget_srv_room_member_store (struct GNUNET_MESSENGER_SrvRoom *room)
 Returns the used member store of a given room. More...
 
struct GNUNET_MESSENGER_MessageStoreget_srv_room_message_store (struct GNUNET_MESSENGER_SrvRoom *room)
 Returns the used message store of a given room. More...
 
struct GNUNET_MESSENGER_OperationStoreget_srv_room_operation_store (struct GNUNET_MESSENGER_SrvRoom *room)
 Returns the used operation store of a given room. More...
 
enum GNUNET_GenericReturnValue open_srv_room (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle)
 Tries to open a room for a given handle. More...
 
enum GNUNET_GenericReturnValue enter_srv_room_at (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_PeerIdentity *door)
 Connects a tunnel to a hosting peer of a room through a so called door which is represented by a peer identity of a hosting peer. More...
 
struct GNUNET_MQ_Envelopepack_srv_room_message (const struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *hash, enum GNUNET_MESSENGER_PackMode mode)
 Packs a message depending on the selected mode into a newly allocated envelope. More...
 
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. More...
 
void forward_srv_room_message (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
 Forwards a message with a given hash to a specific tunnel inside of a room. More...
 
void check_srv_room_peer_status (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel)
 Checks the current state of opening a given room from this peer and re-publishes it if necessary to a selected tunnel or to all connected tunnels if necessary or if the selected tunnel is NULL. More...
 
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 merging them down. More...
 
enum GNUNET_GenericReturnValue delete_srv_room_message (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_MemberSession *session, const struct GNUNET_HashCode *hash, const struct GNUNET_TIME_Relative delay)
 Deletes a message from the room with a given hash in a specific delay if the provided member by its session is permitted to do so. More...
 
struct GNUNET_CADET_Handleget_srv_room_cadet (struct GNUNET_MESSENGER_SrvRoom *room)
 Returns the CADET handle from a rooms service. More...
 
const struct GNUNET_HashCodeget_srv_room_key (const struct GNUNET_MESSENGER_SrvRoom *room)
 Returns the shared secret you need to access a room. More...
 
const struct GNUNET_MESSENGER_SrvTunnelget_srv_room_tunnel (const struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_PeerIdentity *peer)
 Returns a tunnel inside of a room leading towards a given peer if such a tunnel exists, otherwise NULL. More...
 
enum GNUNET_GenericReturnValue request_srv_room_message (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_HashCode *hash, const struct GNUNET_MESSENGER_MemberSession *session, GNUNET_MESSENGER_MessageRequestCallback callback, void *cls)
 Requests a message from a room identified by a given hash. More...
 
void solve_srv_room_member_collisions (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_CRYPTO_PublicKey *public_key, const struct GNUNET_ShortHashCode *member_id, struct GNUNET_TIME_Absolute timestamp)
 Checks for potential collisions with member ids and solves them changing active handles ids if they use an already used member id (comparing public key and timestamp). More...
 
void rebuild_srv_room_basement_structure (struct GNUNET_MESSENGER_SrvRoom *room)
 Rebuilds the decentralized structure for a room by ensuring all required connections are made depending on the amount of peers and this peers index in the list of them. More...
 
uint32_t get_srv_room_amount_of_tunnels (const struct GNUNET_MESSENGER_SrvRoom *room)
 Returns the amount of active tunnels of a given room. More...
 
uint32_t get_srv_room_connection_flags (const struct GNUNET_MESSENGER_SrvRoom *room)
 Returns connection flags about connection information of a given room and the service managing it. More...
 
void load_srv_room (struct GNUNET_MESSENGER_SrvRoom *room)
 Loads the local configuration for a given room of a service which contains the last messages hash and the ruleset for general access of new members. More...
 
void save_srv_room (struct GNUNET_MESSENGER_SrvRoom *room)
 Saves the configuration for a given room of a service which contains the last messages hash and the ruleset for general access of new members locally. More...
 
void remove_srv_room (struct GNUNET_MESSENGER_SrvRoom *room)
 Removes the configuration for a given room of a service. More...
 

Macro Definition Documentation

◆ GNUNET_MESSENGER_IDLE_DELAY

#define GNUNET_MESSENGER_IDLE_DELAY
Value:
struct GNUNET_TIME_Relative GNUNET_TIME_relative_get_second_(void)
Return relative time of 1s.
Definition: time.c:169
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:484

Definition at line 44 of file gnunet-service-messenger_room.h.

◆ GNUNET_MESSENGER_REQUEST_DELAY

#define GNUNET_MESSENGER_REQUEST_DELAY
Value:
struct GNUNET_TIME_Relative GNUNET_TIME_relative_get_minute_(void)
Return relative time of 1 minute.
Definition: time.c:178

Definition at line 47 of file gnunet-service-messenger_room.h.

◆ GNUNET_MESSENGER_MERGE_DELAY

#define GNUNET_MESSENGER_MERGE_DELAY

Typedef Documentation

◆ GNUNET_MESSENGER_MessageRequestCallback

typedef void() GNUNET_MESSENGER_MessageRequestCallback(void *cls, struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)

Method called whenever a message is found during a request in a room.

Parameters
[in,out]clsClosure from #request_room_message
[in,out]roomRoom
[in]messageMessage or NULL
[in]hashHash of message

Definition at line 306 of file gnunet-service-messenger_room.h.

Function Documentation

◆ create_srv_room()

struct GNUNET_MESSENGER_SrvRoom * create_srv_room ( struct GNUNET_MESSENGER_SrvHandle handle,
const struct GNUNET_HashCode key 
)

Creates and allocates a new room for a handle with a given key.

Parameters
[in,out]handleHandle
[in]keyKey of room
Returns
New room

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

48{
49 GNUNET_assert ((handle) && (key));
50
51 struct GNUNET_MESSENGER_SrvRoom *room = GNUNET_new (struct
53
54 room->service = handle->service;
55 room->host = handle;
56 room->port = NULL;
57
58 GNUNET_memcpy (&(room->key), key, sizeof(struct GNUNET_HashCode));
59
61
66
67 init_list_tunnels (&(room->basement));
68 init_message_state (&(room->state));
69
70 room->peer_message = NULL;
71
73 room->idle = NULL;
74
75 if (room->service->dir)
76 load_srv_room (room);
77
80
81 return room;
82}
struct GNUNET_HashCode key
The key used in the DHT.
void init_list_messages(struct GNUNET_MESSENGER_ListMessages *messages)
Initializes list of message hashes as empty list.
void init_member_store(struct GNUNET_MESSENGER_MemberStore *store, struct GNUNET_MESSENGER_SrvRoom *room)
Initializes a member store as fully empty connected to a room.
void init_message_state(struct GNUNET_MESSENGER_MessageState *state)
void init_message_store(struct GNUNET_MESSENGER_MessageStore *store)
Initializes a message store as fully empty.
void init_operation_store(struct GNUNET_MESSENGER_OperationStore *store, struct GNUNET_MESSENGER_SrvRoom *room)
Initializes an operation store as fully empty with a given room.
void init_peer_store(struct GNUNET_MESSENGER_PeerStore *store, struct GNUNET_MESSENGER_Service *service)
Initializes a peer store as fully empty.
struct GNUNET_MESSENGER_MessageStore * get_srv_room_message_store(struct GNUNET_MESSENGER_SrvRoom *room)
Returns the used message store of a given room.
struct GNUNET_MESSENGER_PeerStore * get_srv_room_peer_store(struct GNUNET_MESSENGER_SrvRoom *room)
Returns the used peer store of a given room.
static void idle_request_room_messages(void *cls)
struct GNUNET_MESSENGER_OperationStore * get_srv_room_operation_store(struct GNUNET_MESSENGER_SrvRoom *room)
Returns the used operation store of a given room.
struct GNUNET_MESSENGER_MemberStore * get_srv_room_member_store(struct GNUNET_MESSENGER_SrvRoom *room)
Returns the used member store of a given room.
void load_srv_room(struct GNUNET_MESSENGER_SrvRoom *room)
Loads the local configuration for a given room of a service which contains the last messages hash and...
static struct GNUNET_VPN_Handle * handle
Handle to vpn service.
Definition: gnunet-vpn.c:35
struct GNUNET_CONTAINER_MultiPeerMap * GNUNET_CONTAINER_multipeermap_create(unsigned int len, int do_not_copy_keys)
Create a multi peer map (hash map for public keys of peers).
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_SCHEDULER_PRIORITY_IDLE
Run when otherwise idle.
@ 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_SCHEDULER_Task * GNUNET_SCHEDULER_add_with_priority(enum GNUNET_SCHEDULER_Priority prio, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified priority.
Definition: scheduler.c:1226
void init_list_tunnels(struct GNUNET_MESSENGER_ListTunnels *tunnels)
Initializes list of tunnels peer identities as empty list.
A 512-bit hashcode.
struct GNUNET_HashCode * peer_message
struct GNUNET_CONTAINER_MultiPeerMap * tunnels
struct GNUNET_MESSENGER_Service * service
struct GNUNET_CADET_Port * port
struct GNUNET_MESSENGER_ListTunnels basement
struct GNUNET_SCHEDULER_Task * idle
struct GNUNET_MESSENGER_MessageState state
struct GNUNET_MESSENGER_ListMessages handling
struct GNUNET_MESSENGER_SrvHandle * host

References GNUNET_MESSENGER_SrvRoom::basement, GNUNET_MESSENGER_Service::dir, get_srv_room_member_store(), get_srv_room_message_store(), get_srv_room_operation_store(), get_srv_room_peer_store(), GNUNET_assert, GNUNET_CONTAINER_multipeermap_create(), GNUNET_memcpy, GNUNET_new, GNUNET_NO, GNUNET_SCHEDULER_add_with_priority(), GNUNET_SCHEDULER_PRIORITY_IDLE, handle, GNUNET_MESSENGER_SrvRoom::handling, GNUNET_MESSENGER_SrvRoom::host, GNUNET_MESSENGER_SrvRoom::idle, idle_request_room_messages(), init_list_messages(), init_list_tunnels(), init_member_store(), init_message_state(), init_message_store(), init_operation_store(), init_peer_store(), key, GNUNET_MESSENGER_SrvRoom::key, load_srv_room(), GNUNET_MESSENGER_SrvRoom::peer_message, GNUNET_MESSENGER_SrvRoom::port, GNUNET_MESSENGER_SrvRoom::service, GNUNET_MESSENGER_SrvRoom::state, and GNUNET_MESSENGER_SrvRoom::tunnels.

Referenced by entry_service_room(), and open_service_room().

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

◆ destroy_srv_room()

void destroy_srv_room ( struct GNUNET_MESSENGER_SrvRoom room,
enum GNUNET_GenericReturnValue  deletion 
)

Destroys a room and frees its memory fully.

The deletion flag should only be set to GNUNET_YES if the room gets dropped by the service, otherwise GNUNET_NO.

Parameters
[in,out]roomRoom
[in]deletionFlag to indicate context of destruction

Definition at line 103 of file gnunet-service-messenger_room.c.

105{
106 GNUNET_assert (room);
107
108 if (room->idle)
109 {
111 room->idle = NULL;
112 }
113
114 close_srv_room (room);
115
117 NULL);
119
120 if (! (room->service->dir))
121 goto skip_saving;
122
123 if (GNUNET_YES == deletion)
124 remove_srv_room (room);
125 else
126 save_srv_room (room);
127
128skip_saving:
133
135 clear_list_tunnels (&(room->basement));
136 clear_message_state (&(room->state));
137
138 if (room->peer_message)
140
141 GNUNET_free (room);
142}
void clear_member_store(struct GNUNET_MESSENGER_MemberStore *store)
Clears a member store, wipes its content and deallocates its memory.
void clear_message_state(struct GNUNET_MESSENGER_MessageState *state)
void clear_message_store(struct GNUNET_MESSENGER_MessageStore *store)
Clears a message store, wipes its content and deallocates its memory.
void clear_operation_store(struct GNUNET_MESSENGER_OperationStore *store)
Clears an operation store, stops all operations and deallocates its memory.
void clear_peer_store(struct GNUNET_MESSENGER_PeerStore *store)
Clears a peer store, wipes its content and deallocates its memory.
static enum GNUNET_GenericReturnValue iterate_destroy_tunnels(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
void save_srv_room(struct GNUNET_MESSENGER_SrvRoom *room)
Saves the configuration for a given room of a service which contains the last messages hash and the r...
void remove_srv_room(struct GNUNET_MESSENGER_SrvRoom *room)
Removes the configuration for a given room of a service.
static void handle_room_messages(struct GNUNET_MESSENGER_SrvRoom *room)
static void close_srv_room(struct GNUNET_MESSENGER_SrvRoom *room)
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
@ GNUNET_YES
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:975
void clear_list_tunnels(struct GNUNET_MESSENGER_ListTunnels *tunnels)
Clears the list of tunnels peer identities.

References GNUNET_MESSENGER_SrvRoom::basement, clear_list_tunnels(), clear_member_store(), clear_message_state(), clear_message_store(), clear_operation_store(), clear_peer_store(), close_srv_room(), GNUNET_MESSENGER_Service::dir, get_srv_room_member_store(), get_srv_room_message_store(), get_srv_room_operation_store(), get_srv_room_peer_store(), GNUNET_assert, GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_free, GNUNET_SCHEDULER_cancel(), GNUNET_YES, handle_room_messages(), GNUNET_MESSENGER_SrvRoom::idle, iterate_destroy_tunnels(), GNUNET_MESSENGER_SrvRoom::peer_message, remove_srv_room(), GNUNET_MESSENGER_SrvTunnel::room, save_srv_room(), GNUNET_MESSENGER_SrvRoom::service, GNUNET_MESSENGER_SrvRoom::state, and GNUNET_MESSENGER_SrvRoom::tunnels.

Referenced by close_service_room(), entry_service_room(), iterate_destroy_rooms(), and open_service_room().

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

◆ get_srv_room_peer_store()

struct GNUNET_MESSENGER_PeerStore * get_srv_room_peer_store ( struct GNUNET_MESSENGER_SrvRoom room)

Returns the used peer store of a given room.

Parameters
[in,out]roomRoom
Returns
Peer store

Definition at line 146 of file gnunet-service-messenger_room.c.

147{
148 GNUNET_assert (room);
149
150 return &(room->peer_store);
151}
struct GNUNET_MESSENGER_PeerStore peer_store

References GNUNET_assert, and GNUNET_MESSENGER_SrvRoom::peer_store.

Referenced by callback_found_message(), callback_room_handle_message(), create_srv_room(), destroy_srv_room(), handle_message_miss(), handle_message_peer(), handle_room_messages(), load_srv_room(), and save_srv_room().

Here is the caller graph for this function:

◆ get_srv_room_member_store()

struct GNUNET_MESSENGER_MemberStore * get_srv_room_member_store ( struct GNUNET_MESSENGER_SrvRoom room)

Returns the used member store of a given room.

Parameters
[in,out]roomRoom
Returns
Member store

Definition at line 155 of file gnunet-service-messenger_room.c.

156{
157 GNUNET_assert (room);
158
159 return &(room->member_store);
160}
struct GNUNET_MESSENGER_MemberStore member_store

References GNUNET_assert, GNUNET_MESSENGER_SrvRoom::member_store, and GNUNET_MESSENGER_MemberStore::room.

Referenced by callback_found_message(), callback_room_handle_message(), create_srv_room(), destroy_srv_room(), get_handle_member_session(), handle_get_message(), handle_room_messages(), initialize_service_handle(), join_room_locally(), load_srv_room(), open_srv_room(), recv_message_info(), recv_message_request(), save_srv_room(), send_message_join(), and solve_srv_room_member_collisions().

Here is the caller graph for this function:

◆ get_srv_room_message_store()

struct GNUNET_MESSENGER_MessageStore * get_srv_room_message_store ( struct GNUNET_MESSENGER_SrvRoom room)

Returns the used message store of a given room.

Parameters
[in,out]roomRoom
Returns
Message store

Definition at line 164 of file gnunet-service-messenger_room.c.

165{
166 GNUNET_assert (room);
167
168 return &(room->message_store);
169}
struct GNUNET_MESSENGER_MessageStore message_store

References GNUNET_assert, and GNUNET_MESSENGER_SrvRoom::message_store.

Referenced by callback_room_deletion(), callback_verify_room_message(), check_member_session_completion(), check_srv_room_peer_status(), create_srv_room(), delete_srv_room_message(), destroy_srv_room(), forward_about_members(), handle_room_messages(), load_srv_room(), notify_about_members(), recv_message_info(), request_room_message_step(), save_srv_room(), update_room_message(), and update_tunnel_last_message().

Here is the caller graph for this function:

◆ get_srv_room_operation_store()

struct GNUNET_MESSENGER_OperationStore * get_srv_room_operation_store ( struct GNUNET_MESSENGER_SrvRoom room)

Returns the used operation store of a given room.

Parameters
[in,out]roomRoom
Returns
Operation store

Definition at line 173 of file gnunet-service-messenger_room.c.

174{
175 GNUNET_assert (room);
176
177 return &(room->operation_store);
178}
struct GNUNET_MESSENGER_OperationStore operation_store

References GNUNET_assert, GNUNET_MESSENGER_SrvRoom::operation_store, and GNUNET_MESSENGER_OperationStore::room.

Referenced by callback_found_message(), create_srv_room(), delete_srv_room_message(), destroy_srv_room(), idle_request_room_messages(), load_srv_room(), save_srv_room(), send_message_request(), update_room_message(), and update_tunnel_last_message().

Here is the caller graph for this function:

◆ open_srv_room()

enum GNUNET_GenericReturnValue open_srv_room ( struct GNUNET_MESSENGER_SrvRoom room,
struct GNUNET_MESSENGER_SrvHandle handle 
)

Tries to open a room for a given handle.

If the room has already been opened, the handle will locally join the room.

Calling this method should result in joining a room and sending a peer message as well for this peer.

If the function returns GNUNET_YES the port for this room is guaranteed to be open for incoming connections.

Parameters
[in,out]roomRoom
[in,out]handleHandle
Returns
GNUNET_YES on success, GNUNET_NO on failure.

Definition at line 299 of file gnunet-service-messenger_room.c.

301{
302 GNUNET_assert (room);
303
304 if (handle)
305 room->host = handle;
306
307 if (room->port)
308 {
309 if (! handle)
310 return GNUNET_YES;
311
312 return join_room_locally (room, handle);
313 }
314
316 const struct GNUNET_HashCode *key = get_srv_room_key (room);
317
319 tunnel_message,
321 struct
324
325 struct GNUNET_HashCode port;
328 room, NULL, callback_tunnel_disconnect,
329 handlers);
330
331 if (room->port)
332 GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Port of room (%s) was opened!\n",
334 else
336 "Port of room (%s) could not be opened!\n",
338
339 if (! handle)
340 goto complete_opening;
341
342 const struct GNUNET_ShortHashCode *member_id = get_srv_handle_member_id (
343 handle, get_srv_room_key (room));
344
345 struct GNUNET_MESSENGER_MemberStore *member_store =
347 struct GNUNET_MESSENGER_Member *member = add_store_member (member_store,
348 member_id);
349
350 if ((GNUNET_NO == join_room (room, handle, member, member_id)) &&
351 (room->port))
352 {
354 "You could not join the room, therefore it keeps closed!\n");
355
356 close_srv_room (room);
357 return GNUNET_NO;
358 }
359
360complete_opening:
361 if (! room->port)
362 return GNUNET_NO;
363
365 room->service));
366}
struct GNUNET_MQ_MessageHandlers handlers[]
Definition: 003.c:1
static uint16_t port
Port number.
Definition: gnunet-bcd.c:147
static struct GNUNET_CADET_Handle * cadet
Handle for cadet.
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.
struct GNUNET_MESSENGER_Member * add_store_member(struct GNUNET_MESSENGER_MemberStore *store, const struct GNUNET_ShortHashCode *id)
Adds a member to a store under a specific id and returns it on success.
struct GNUNET_MESSENGER_Message * create_message_peer(struct GNUNET_MESSENGER_Service *service)
Creates and allocates a new peer message containing a services peer identity.
static enum GNUNET_GenericReturnValue join_room(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_Member *member, const struct GNUNET_ShortHashCode *id)
static void * callback_room_connect(void *cls, struct GNUNET_CADET_Channel *channel, const struct GNUNET_PeerIdentity *source)
static enum GNUNET_GenericReturnValue join_room_locally(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle)
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.
void callback_tunnel_disconnect(void *cls, const struct GNUNET_CADET_Channel *channel)
struct GNUNET_CADET_Handle * get_srv_room_cadet(struct GNUNET_MESSENGER_SrvRoom *room)
Returns the CADET handle from a rooms service.
const struct GNUNET_HashCode * get_srv_room_key(const struct GNUNET_MESSENGER_SrvRoom *room)
Returns the shared secret you need to access a room.
struct GNUNET_CADET_Port * GNUNET_CADET_open_port(struct GNUNET_CADET_Handle *h, const struct GNUNET_HashCode *port, GNUNET_CADET_ConnectEventHandler connects, void *connects_cls, GNUNET_CADET_WindowSizeEventHandler window_changes, GNUNET_CADET_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Open a port to receive incoming MQ-based channels.
Definition: cadet_api.c:954
#define GNUNET_log(kind,...)
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_INFO
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_MESSAGE_TYPE_CADET_CLI
Traffic (net-cat style) used by the Command Line Interface.
void convert_messenger_key_to_port(const struct GNUNET_HashCode *key, struct GNUNET_HashCode *port)
Converts a Messenger service key of a room to the specific port which gets used for the CADET channel...
Opaque handle to the service.
Definition: cadet_api.c:39
Message handler for a specific message type.
Header for all communications.
A 256-bit hashcode.

References add_store_member(), cadet, callback_room_connect(), callback_tunnel_disconnect(), close_srv_room(), convert_messenger_key_to_port(), create_message_peer(), get_srv_handle_member_id(), get_srv_room_cadet(), get_srv_room_key(), get_srv_room_member_store(), GNUNET_assert, GNUNET_CADET_open_port(), GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_h2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_CADET_CLI, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_NO, GNUNET_YES, handle, handlers, GNUNET_MESSENGER_SrvRoom::host, join_room(), join_room_locally(), key, port, GNUNET_MESSENGER_SrvRoom::port, GNUNET_MESSENGER_MemberStore::room, send_srv_room_message(), and GNUNET_MESSENGER_SrvRoom::service.

Referenced by open_service_room(), and recv_message_miss().

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

◆ enter_srv_room_at()

enum GNUNET_GenericReturnValue enter_srv_room_at ( struct GNUNET_MESSENGER_SrvRoom room,
struct GNUNET_MESSENGER_SrvHandle handle,
const struct GNUNET_PeerIdentity door 
)

Connects a tunnel to a hosting peer of a room through a so called door which is represented by a peer identity of a hosting peer.

During the connection the handle will join the room as a member, waiting for an info message from the selected host.

Parameters
[in,out]roomRoom
[in,out]handleHandle
[in]doorPeer identity
Returns
GNUNET_YES on success, GNUNET_NO on failure.

Definition at line 388 of file gnunet-service-messenger_room.c.

391{
392 GNUNET_assert ((room) && (handle) && (door));
393
394 struct GNUNET_PeerIdentity peer;
395
396 if ((GNUNET_OK == get_service_peer_identity (room->service, &peer)) &&
397 (0 == GNUNET_memcmp (&peer, door)))
398 return join_room_locally (room, handle);
399
400 struct GNUNET_MESSENGER_SrvTunnel *tunnel =
402
403 if (! tunnel)
404 {
405 tunnel = create_tunnel (room, door);
406
408 tunnel,
410 {
412 "You could not connect to that door!\n");
413 destroy_tunnel (tunnel);
414 return GNUNET_NO;
415 }
416 }
417
418 if (GNUNET_SYSERR == connect_tunnel (tunnel))
419 {
421 "Connection failure during entrance!\n");
423 destroy_tunnel (tunnel);
424 return GNUNET_NO;
425 }
426
427 return join_room_locally (room, handle);
428}
static void destroy_tunnel(void *cls)
This tunnel is no longer used, destroy it.
enum GNUNET_GenericReturnValue get_service_peer_identity(struct GNUNET_MESSENGER_Service *service, struct GNUNET_PeerIdentity *peer)
Tries to write the peer identity of the peer running a service on to the peer parameter.
struct GNUNET_MESSENGER_SrvTunnel * create_tunnel(struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_PeerIdentity *door)
Creates and allocates a tunnel of a room to a specific peer identity (called door).
enum GNUNET_GenericReturnValue connect_tunnel(struct GNUNET_MESSENGER_SrvTunnel *tunnel)
Tries to connect a tunnel by creating a new CADET channel and binding it.
void * GNUNET_CONTAINER_multipeermap_get(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Given a key find a value in the map matching the key.
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multipeermap_remove(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Remove the given key-value pair from the map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE
Allow multiple values with the same key.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
@ GNUNET_OK
@ GNUNET_SYSERR
@ GNUNET_ERROR_TYPE_ERROR
struct GNUNET_MESSENGER_SrvRoom * room
The identity of the host (wraps the signing key of the peer).

References connect_tunnel(), create_tunnel(), destroy_tunnel(), get_service_peer_identity(), GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multipeermap_get(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_memcmp, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, handle, join_room_locally(), GNUNET_MESSENGER_SrvTunnel::room, GNUNET_MESSENGER_SrvRoom::service, and GNUNET_MESSENGER_SrvRoom::tunnels.

Referenced by callback_room_disconnect(), and entry_service_room().

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

◆ pack_srv_room_message()

struct GNUNET_MQ_Envelope * pack_srv_room_message ( const struct GNUNET_MESSENGER_SrvRoom room,
const struct GNUNET_MESSENGER_SrvHandle handle,
struct GNUNET_MESSENGER_Message message,
struct GNUNET_HashCode hash,
enum GNUNET_MESSENGER_PackMode  mode 
)

Packs a message depending on the selected mode into a newly allocated envelope.

It will set the timestamp of the message, the sender id and the previous messages hash automatically before packing. The message will be signed by the handles private key.

If the optional hash parameter is a valid pointer, its value will be overridden by the signed messages hash.

If mode is set to GNUNET_MESSENGER_PACK_MODE_ENVELOPE, the function returns a valid envelope to send through a message queue, otherwise NULL.

Parameters
[in]roomRoom
[in]handleHandle
[in,out]messageMessage
[out]hashHash of message
[in]modePacking mode
Returns
New envelope or NULL

Definition at line 447 of file gnunet-service-messenger_room.c.

452{
453 GNUNET_assert ((room) && (handle) && (message) && (hash));
454
455 if (GNUNET_YES != is_peer_message (message))
456 return pack_message (message, hash, NULL, mode, NULL);
457
460
461 struct GNUNET_PeerIdentity peer;
462 if (GNUNET_OK != get_service_peer_identity (handle->service, &peer))
463 return NULL;
464
465 convert_peer_identity_to_id (&peer, &(message->header.sender_id));
466 get_message_state_chain_hash (&(room->state), &(message->header.previous));
467
469 "Packing message with peer signature: %s\n",
470 GNUNET_sh2s (&(message->header.sender_id)));
471
473 return pack_message (message, hash, sign_srv_room_message_by_peer, mode,
474 handle);
475}
void get_message_state_chain_hash(const struct GNUNET_MESSENGER_MessageState *state, struct GNUNET_HashCode *hash)
static void sign_srv_room_message_by_peer(const void *cls, struct GNUNET_MESSENGER_Message *message, uint16_t length, char *buffer, const struct GNUNET_HashCode *hash)
static enum @44 mode
Should we do a PUT (mode = 0) or GET (mode = 1);.
@ GNUNET_PUBLIC_KEY_TYPE_EDDSA
EDDSA identity.
const char * GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_DEBUG
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:111
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:638
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...
struct GNUNET_MQ_Envelope * pack_message(struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *hash, const GNUNET_MESSENGER_SignFunction sign, enum GNUNET_MESSENGER_PackMode mode, const void *cls)
Encodes the message to pack it into a newly allocated envelope if mode is equal to GNUNET_MESSENGER_P...
void convert_peer_identity_to_id(const struct GNUNET_PeerIdentity *identity, struct GNUNET_ShortHashCode *id)
Converts a peers identity to a short hash code which can be used as id to refer to a peer via sender ...
uint32_t type
Type of signature.
struct GNUNET_HashCode previous
The hash of the previous message from the senders perspective.
struct GNUNET_CRYPTO_Signature signature
The signature of the senders private key.
struct GNUNET_TIME_AbsoluteNBO timestamp
The timestamp of the 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 convert_peer_identity_to_id(), get_message_state_chain_hash(), get_service_peer_identity(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_OK, GNUNET_PUBLIC_KEY_TYPE_EDDSA, GNUNET_sh2s(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_hton(), GNUNET_YES, handle, GNUNET_MESSENGER_Message::header, is_peer_message(), mode, pack_message(), GNUNET_MESSENGER_MessageHeader::previous, GNUNET_MESSENGER_MessageHeader::sender_id, sign_srv_room_message_by_peer(), GNUNET_MESSENGER_MessageHeader::signature, GNUNET_MESSENGER_SrvRoom::state, GNUNET_MESSENGER_MessageHeader::timestamp, and GNUNET_CRYPTO_Signature::type.

Referenced by iterate_send_room_message(), send_srv_room_message(), and send_tunnel_message().

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

◆ send_srv_room_message()

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.

The hash parameter will be updated with the hash-value resulting from the sent message.

The function handles packing the message automatically and will call linked message-events locally even if the message won't be sent to another peer.

The function returns GNUNET_YES on success, GNUNET_NO if message is null and GNUNET_SYSERR if the message was known already.

Parameters
[in,out]roomRoom
[in,out]handleHandle
[in,out]messageMessage
Returns
GNUNET_YES on success, GNUNET_NO or GNUNET_SYSERR otherwise.

Definition at line 537 of file gnunet-service-messenger_room.c.

540{
541 GNUNET_assert ((room) && (handle));
542
543 if (! message)
544 return GNUNET_NO;
545
547 "Sending message from handle in room: %s (%s)\n",
548 GNUNET_h2s (&(room->key)),
550
551 struct GNUNET_HashCode hash;
553
554 closure.room = room;
555 closure.handle = handle;
556 closure.exclude = NULL;
557 closure.message = message;
558 closure.hash = &hash;
559 closure.packed = GNUNET_NO;
560
562 iterate_send_room_message, &closure);
563
564 if (GNUNET_NO == closure.packed)
567
568 enum GNUNET_GenericReturnValue new_message;
569 new_message = update_room_message (room, message, &hash);
570
571 if (GNUNET_YES != new_message)
572 {
573 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Sending duplicate message failed!\n");
574 return GNUNET_SYSERR;
575 }
576
577 switch (message->header.kind)
578 {
581 break;
584 break;
587 break;
590 break;
593 break;
594 default:
595 break;
596 }
597
599 return GNUNET_YES;
600}
void send_message_id(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a sent id message to update the handles member id in the room.
void send_message_request(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a sent request message to trigger the request operation for this service.
void send_message_join(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a sent join message to ensure growth of the decentralized room structure.
void send_message_key(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a sent key message to ensure changes to the public key of the sending handle.
void send_message_peer(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a sent peer message to update the rooms peer message of this service.
enum GNUNET_GenericReturnValue update_room_message(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
struct GNUNET_MQ_Envelope * pack_srv_room_message(const struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *hash, enum GNUNET_MESSENGER_PackMode mode)
Packs a message depending on the selected mode into a newly allocated envelope.
void callback_room_handle_message(struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
static enum GNUNET_GenericReturnValue iterate_send_room_message(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
GNUNET_GenericReturnValue
Named constants for return values.
const char * GNUNET_MESSENGER_name_of_kind(enum GNUNET_MESSENGER_MessageKind kind)
Get the name of a message kind.
Definition: messenger_api.c:42
@ GNUNET_MESSENGER_KIND_REQUEST
The request kind.
@ GNUNET_MESSENGER_KIND_PEER
The peer kind.
@ GNUNET_MESSENGER_KIND_KEY
The key kind.
@ GNUNET_MESSENGER_KIND_JOIN
The join kind.
@ GNUNET_MESSENGER_KIND_ID
The id kind.
@ GNUNET_MESSENGER_PACK_MODE_UNKNOWN
struct GNUNET_MESSENGER_Message * message
struct GNUNET_MESSENGER_SrvRoom * room
enum GNUNET_MESSENGER_MessageKind kind
The kind of the message.

References callback_room_handle_message(), GNUNET_MESSENGER_ClosureSendRoom::exclude, GNUNET_assert, GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_h2s(), GNUNET_log, GNUNET_MESSENGER_KIND_ID, GNUNET_MESSENGER_KIND_JOIN, GNUNET_MESSENGER_KIND_KEY, GNUNET_MESSENGER_KIND_PEER, GNUNET_MESSENGER_KIND_REQUEST, GNUNET_MESSENGER_name_of_kind(), GNUNET_MESSENGER_PACK_MODE_UNKNOWN, GNUNET_NO, GNUNET_SYSERR, GNUNET_YES, handle, GNUNET_MESSENGER_ClosureSendRoom::handle, GNUNET_MESSENGER_ClosureSendRoom::hash, GNUNET_MESSENGER_Message::header, iterate_send_room_message(), GNUNET_MESSENGER_SrvRoom::key, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_ClosureSendRoom::message, pack_srv_room_message(), GNUNET_MESSENGER_ClosureSendRoom::packed, GNUNET_MESSENGER_ClosureSendRoom::room, send_message_id(), send_message_join(), send_message_key(), send_message_peer(), send_message_request(), GNUNET_MESSENGER_SrvRoom::tunnels, and update_room_message().

Referenced by callback_room_disconnect(), callback_room_merge(), close_service_room(), close_srv_room(), merge_srv_room_last_messages(), open_srv_room(), send_message_peer(), and send_srv_handle_message().

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

◆ forward_srv_room_message()

void forward_srv_room_message ( struct GNUNET_MESSENGER_SrvRoom room,
struct GNUNET_MESSENGER_SrvTunnel tunnel,
struct GNUNET_MESSENGER_Message message,
const struct GNUNET_HashCode hash 
)

Forwards a message with a given hash to a specific tunnel inside of a room.

Parameters
[in,out]roomRoom
[in,out]tunnelTunnel
[in,out]messageMessage
[in]hashHash of message

Definition at line 604 of file gnunet-service-messenger_room.c.

608{
609 GNUNET_assert ((room) && (tunnel));
610
611 if (! message)
612 return;
613
615 struct GNUNET_HashCode message_hash;
616
617 GNUNET_memcpy (&message_hash, hash, sizeof(struct GNUNET_HashCode));
618
619 closure.room = room;
620 closure.handle = NULL;
621 closure.exclude = tunnel;
622 closure.message = message;
623 closure.hash = &message_hash;
624 closure.packed = GNUNET_YES;
625
627 iterate_send_room_message, &closure);
628}

References GNUNET_MESSENGER_ClosureSendRoom::exclude, GNUNET_assert, GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_memcpy, GNUNET_YES, GNUNET_MESSENGER_ClosureSendRoom::handle, GNUNET_MESSENGER_ClosureSendRoom::hash, iterate_send_room_message(), GNUNET_MESSENGER_ClosureSendRoom::message, GNUNET_MESSENGER_ClosureSendRoom::packed, GNUNET_MESSENGER_ClosureSendRoom::room, and GNUNET_MESSENGER_SrvRoom::tunnels.

Referenced by handle_tunnel_message().

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

◆ check_srv_room_peer_status()

void check_srv_room_peer_status ( struct GNUNET_MESSENGER_SrvRoom room,
struct GNUNET_MESSENGER_SrvTunnel tunnel 
)

Checks the current state of opening a given room from this peer and re-publishes it if necessary to a selected tunnel or to all connected tunnels if necessary or if the selected tunnel is NULL.

Parameters
[in,out]roomRoom
[in,out]tunnelTunnel

Definition at line 632 of file gnunet-service-messenger_room.c.

634{
635 if (! room->peer_message)
636 return;
637
638 struct GNUNET_MESSENGER_MessageStore *message_store =
640
641 const struct GNUNET_MESSENGER_Message *message = get_store_message (
642 message_store, room->peer_message);
643
644 if (! message)
645 {
647 room->peer_message = NULL;
648 return;
649 }
650
651 if (tunnel)
652 forward_tunnel_message (tunnel, message, room->peer_message);
653}
const struct GNUNET_MESSENGER_Message * get_store_message(struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash)
Returns the message from a message store matching a given hash.
void forward_tunnel_message(struct GNUNET_MESSENGER_SrvTunnel *tunnel, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Forwards a given message with a known hash through a tunnel.

References forward_tunnel_message(), get_srv_room_message_store(), get_store_message(), GNUNET_free, and GNUNET_MESSENGER_SrvRoom::peer_message.

Referenced by recv_message_info(), and send_message_join().

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

◆ merge_srv_room_last_messages()

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 merging them down.

All merge messages will be sent from a given handle.

Parameters
[in,out]roomRoom
[in,out]handleHandle

Definition at line 657 of file gnunet-service-messenger_room.c.

659{
660 GNUNET_assert (room);
661
662 if (! handle)
663 return;
664
666 "Merging messages by handle in room: %s\n",
667 GNUNET_h2s (&(room->key)));
668
669 const struct GNUNET_HashCode *hash;
670
671merge_next:
672 hash = get_message_state_merge_hash (&(room->state));
673
674 if (! hash)
675 return;
676
678 goto merge_next;
679}
struct GNUNET_MESSENGER_Message * create_message_merge(const struct GNUNET_HashCode *previous)
Creates and allocates a new merge message containing the hash of a second previous message besides th...
const struct GNUNET_HashCode * get_message_state_merge_hash(const struct GNUNET_MESSENGER_MessageState *state)

References create_message_merge(), get_message_state_merge_hash(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, handle, GNUNET_MESSENGER_SrvRoom::key, send_srv_room_message(), and GNUNET_MESSENGER_SrvRoom::state.

Referenced by sync_srv_handle_messages().

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

◆ delete_srv_room_message()

enum GNUNET_GenericReturnValue delete_srv_room_message ( struct GNUNET_MESSENGER_SrvRoom room,
struct GNUNET_MESSENGER_MemberSession session,
const struct GNUNET_HashCode hash,
const struct GNUNET_TIME_Relative  delay 
)

Deletes a message from the room with a given hash in a specific delay if the provided member by its session is permitted to do so.

Parameters
[in,out]roomRoom
[in,out]sessionMember session
[in]hashHash of message
[in]delayDelay of deletion
Returns
GNUNET_YES on success, GNUNET_NO if permission gets denied, GNUNET_SYSERR on operation failure

Definition at line 708 of file gnunet-service-messenger_room.c.

712{
713 GNUNET_assert ((room) && (session) && (hash));
714
715 const struct GNUNET_TIME_Relative forever =
717
718 if (0 == GNUNET_memcmp (&forever, &delay))
719 {
721 "Deletion is delayed forever: operation is impossible!\n");
722 return GNUNET_SYSERR;
723 }
724
725 struct GNUNET_MESSENGER_MessageStore *message_store =
727
728 const struct GNUNET_MESSENGER_Message *message = get_store_message (
729 message_store, hash);
730
731 if (! message)
732 return GNUNET_YES;
733
734 if (GNUNET_YES != check_member_session_history (session, hash, GNUNET_YES))
735 {
737 "Unpermitted request for deletion by member (%s) of message (%s)!\n",
739 hash));
740
741 return GNUNET_NO;
742 }
743
744 struct GNUNET_MESSENGER_OperationStore *operation_store =
746
747 if (GNUNET_OK != use_store_operation (operation_store, hash,
749 {
751 "Deletion has failed: operation denied!\n");
752 return GNUNET_SYSERR;
753 }
754
755 return GNUNET_YES;
756}
const struct GNUNET_ShortHashCode * get_member_session_id(const struct GNUNET_MESSENGER_MemberSession *session)
Returns the member id of a given member session.
enum GNUNET_GenericReturnValue check_member_session_history(const struct GNUNET_MESSENGER_MemberSession *session, const struct GNUNET_HashCode *hash, enum GNUNET_GenericReturnValue ownership)
Checks the history of a session for a specific message which is identified by its hash and if the own...
enum GNUNET_GenericReturnValue use_store_operation(struct GNUNET_MESSENGER_OperationStore *store, const struct GNUNET_HashCode *hash, enum GNUNET_MESSENGER_OperationType type, struct GNUNET_TIME_Relative delay)
Tries to use an operation under a given hash in a specific operation store.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_get_forever_(void)
Return "forever".
Definition: time.c:196
Time for relative time used by GNUnet, in microseconds.

References check_member_session_history(), get_member_session_id(), get_srv_room_message_store(), get_srv_room_operation_store(), get_store_message(), GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_h2s(), GNUNET_log, GNUNET_memcmp, GNUNET_MESSENGER_OP_DELETE, GNUNET_NO, GNUNET_OK, GNUNET_sh2s(), GNUNET_SYSERR, GNUNET_TIME_relative_get_forever_(), GNUNET_YES, GNUNET_MESSENGER_OperationStore::room, and use_store_operation().

Referenced by handle_message_delete().

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

◆ get_srv_room_cadet()

struct GNUNET_CADET_Handle * get_srv_room_cadet ( struct GNUNET_MESSENGER_SrvRoom room)

Returns the CADET handle from a rooms service.

Parameters
[in,out]roomRoom
Returns
CADET handle

Definition at line 760 of file gnunet-service-messenger_room.c.

761{
762 GNUNET_assert (room);
763
764 return room->service->cadet;
765}
struct GNUNET_CADET_Handle * cadet

References GNUNET_MESSENGER_Service::cadet, GNUNET_assert, and GNUNET_MESSENGER_SrvRoom::service.

Referenced by connect_tunnel(), and open_srv_room().

Here is the caller graph for this function:

◆ get_srv_room_key()

const struct GNUNET_HashCode * get_srv_room_key ( const struct GNUNET_MESSENGER_SrvRoom room)

Returns the shared secret you need to access a room.

Parameters
[in]roomRoom
Returns
Shared secret

Definition at line 769 of file gnunet-service-messenger_room.c.

770{
771 GNUNET_assert (room);
772
773 return &(room->key);
774}

References GNUNET_assert, and GNUNET_MESSENGER_SrvRoom::key.

Referenced by callback_room_connect(), clear_member_store(), clear_operation_store(), connect_tunnel(), find_member_session_in_room(), get_member_store_key(), get_room_data_subdir(), handle_message_join(), handle_message_leave(), join_room(), join_room_locally(), notify_srv_handle_member_id(), notify_srv_handle_message(), open_srv_room(), remove_room_member_session(), send_message_id(), solve_srv_room_member_collisions(), and update_room_message().

Here is the caller graph for this function:

◆ get_srv_room_tunnel()

const struct GNUNET_MESSENGER_SrvTunnel * get_srv_room_tunnel ( const struct GNUNET_MESSENGER_SrvRoom room,
const struct GNUNET_PeerIdentity peer 
)

Returns a tunnel inside of a room leading towards a given peer if such a tunnel exists, otherwise NULL.

Parameters
[in]roomRoom
[in]peerPeer identity
Returns
Tunnel or NULL

Definition at line 778 of file gnunet-service-messenger_room.c.

780{
781 GNUNET_assert ((room) && (peer));
782
783 return GNUNET_CONTAINER_multipeermap_get (room->tunnels, peer);
784}

References GNUNET_assert, GNUNET_CONTAINER_multipeermap_get(), GNUNET_MESSENGER_SrvTunnel::peer, GNUNET_MESSENGER_SrvTunnel::room, and GNUNET_MESSENGER_SrvRoom::tunnels.

Here is the call graph for this function:

◆ request_srv_room_message()

enum GNUNET_GenericReturnValue request_srv_room_message ( struct GNUNET_MESSENGER_SrvRoom room,
const struct GNUNET_HashCode hash,
const struct GNUNET_MESSENGER_MemberSession session,
GNUNET_MESSENGER_MessageRequestCallback  callback,
void *  cls 
)

Requests a message from a room identified by a given hash.

If the message is found, the selected callback will be called with it and the provided closure. If no matching message is found but it wasn't deleted the selected callback will be called with #NULL as message instead. In case of deletion the next available previous message will be used to call the callback.

It is also possible that the given callback will not be called if the requesting session is not permitted!

Parameters
[in,out]roomRoom
[in]hashHash of message
[in]callbackCallback to process result
[in]clsClosure for the callback
Returns
GNUNET_YES if the request could be processed, otherwise GNUNET_NO

Definition at line 845 of file gnunet-service-messenger_room.c.

850{
851 GNUNET_assert ((room) && (hash));
852
854 result = request_room_message_step (room, hash, session, callback, cls);
855
856 if ((GNUNET_NO == result) && (callback))
857 callback (cls, room, NULL, hash);
858
859 return result;
860}
static int result
Global testing status.
static enum GNUNET_GenericReturnValue request_room_message_step(struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_HashCode *hash, const struct GNUNET_MESSENGER_MemberSession *session, GNUNET_MESSENGER_MessageRequestCallback callback, void *cls)

References GNUNET_assert, GNUNET_NO, request_room_message_step(), and result.

Referenced by handle_get_message(), and recv_message_request().

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

◆ solve_srv_room_member_collisions()

void solve_srv_room_member_collisions ( struct GNUNET_MESSENGER_SrvRoom room,
const struct GNUNET_CRYPTO_PublicKey public_key,
const struct GNUNET_ShortHashCode member_id,
struct GNUNET_TIME_Absolute  timestamp 
)

Checks for potential collisions with member ids and solves them changing active handles ids if they use an already used member id (comparing public key and timestamp).

Parameters
[in,out]roomRoom
[in]public_keyPublic key
[in]member_idMember ID
[in]timestampTimestamp

Definition at line 974 of file gnunet-service-messenger_room.c.

979{
980 GNUNET_assert ((room) && (public_key) && (member_id));
981
982 struct GNUNET_MESSENGER_MemberStore *member_store =
984 struct GNUNET_MESSENGER_Member *member = get_store_member (member_store,
985 member_id);
986
987 if ((! member) || (1 >= GNUNET_CONTAINER_multihashmap_size (
988 member->sessions)))
989 return;
990
991 struct GNUNET_MESSENGER_ListHandles *handles = &(room->service->handles);
992 struct GNUNET_MESSENGER_ListHandle *element;
993
994 const struct GNUNET_CRYPTO_PublicKey *pubkey;
995
996 for (element = handles->head; element; element = element->next)
997 {
998 if (0 != GNUNET_memcmp (member_id, get_srv_handle_member_id (
999 element->handle, get_srv_room_key (room))))
1000 continue;
1001
1002 pubkey = get_srv_handle_key (element->handle);
1003
1004 if (0 == GNUNET_memcmp (public_key, pubkey))
1005 continue;
1006
1008 pubkey);
1009
1010 if (! session)
1011 continue;
1012
1014
1015 if (GNUNET_TIME_relative_get_zero_ ().rel_value_us !=
1016 GNUNET_TIME_absolute_get_difference (start, timestamp).rel_value_us)
1017 continue;
1018
1019 struct GNUNET_ShortHashCode random_id;
1020 generate_free_member_id (&random_id, member_store->members);
1021
1022 notify_srv_handle_member_id (element->handle, room, &random_id, GNUNET_NO);
1023 }
1024}
static int start
Set if we are to start default services (including ARM).
Definition: gnunet-arm.c:39
static struct GNUNET_CRYPTO_PublicKey pubkey
Public key of the zone to look in.
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.
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_TIME_Absolute get_member_session_start(const struct GNUNET_MESSENGER_MemberSession *session)
Returns the timestamp of the member session's start.
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.
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_get_zero_(void)
Return relative time of 0ms.
Definition: time.c:133
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_difference(struct GNUNET_TIME_Absolute start, struct GNUNET_TIME_Absolute end)
Compute the time difference between the given start and end times.
Definition: time.c:421
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.
An identity key as per LSD0001.
struct GNUNET_MESSENGER_ListHandle * next
struct GNUNET_MESSENGER_SrvHandle * handle
struct GNUNET_MESSENGER_ListHandle * head
struct GNUNET_CONTAINER_MultiShortmap * members
struct GNUNET_CONTAINER_MultiHashMap * sessions
struct GNUNET_MESSENGER_ListHandles handles
Time for absolute times used by GNUnet, in microseconds.

References generate_free_member_id(), get_member_session(), get_member_session_start(), get_srv_handle_key(), get_srv_handle_member_id(), get_srv_room_key(), get_srv_room_member_store(), get_store_member(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_size(), GNUNET_memcmp, GNUNET_NO, GNUNET_TIME_absolute_get_difference(), GNUNET_TIME_relative_get_zero_(), GNUNET_MESSENGER_ListHandle::handle, GNUNET_MESSENGER_Service::handles, GNUNET_MESSENGER_ListHandles::head, GNUNET_MESSENGER_MemberSession::member, GNUNET_MESSENGER_MemberStore::members, GNUNET_MESSENGER_ListHandle::next, notify_srv_handle_member_id(), pubkey, GNUNET_MESSENGER_MemberStore::room, GNUNET_MESSENGER_SrvRoom::service, GNUNET_MESSENGER_Member::sessions, and start.

Referenced by handle_message_id(), and handle_message_join().

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

◆ rebuild_srv_room_basement_structure()

void rebuild_srv_room_basement_structure ( struct GNUNET_MESSENGER_SrvRoom room)

Rebuilds the decentralized structure for a room by ensuring all required connections are made depending on the amount of peers and this peers index in the list of them.

Parameters
[in,out]roomRoom

Definition at line 1028 of file gnunet-service-messenger_room.c.

1029{
1030 GNUNET_assert (room);
1031
1032 struct GNUNET_PeerIdentity peer;
1033 size_t src;
1034
1035 if (GNUNET_OK != get_service_peer_identity (room->service, &peer))
1036 return;
1037
1038 size_t count = count_of_tunnels (&(room->basement));
1039
1040 if (! find_list_tunnels (&(room->basement), &peer, &src))
1041 return;
1042
1043 if ((count > room->service->min_routers) &&
1044 (GNUNET_NO == is_srv_handle_routing (room->host, &(room->key))) &&
1046 &peer,
1048 {
1049 close_srv_room (room);
1050 return;
1051 }
1052
1053 struct GNUNET_MESSENGER_ListTunnel *element = room->basement.head;
1054 struct GNUNET_MESSENGER_SrvTunnel *tunnel;
1055
1056 size_t dst = 0;
1057
1058 while (element)
1059 {
1060 GNUNET_PEER_resolve (element->peer, &peer);
1061
1063
1064 if (! tunnel)
1065 {
1066 element = remove_from_list_tunnels (&(room->basement), element);
1067 continue;
1068 }
1069
1070 if (GNUNET_YES == required_connection_between (count, src, dst))
1071 {
1072 if (GNUNET_SYSERR == connect_tunnel (tunnel))
1073 {
1074 element = remove_from_list_tunnels (&(room->basement), element);
1075 continue;
1076 }
1077 }
1078 else
1079 disconnect_tunnel (tunnel);
1080
1081 element = element->next;
1082 dst++;
1083 }
1084}
enum GNUNET_GenericReturnValue required_connection_between(size_t count, size_t src, size_t dst)
Returns GNUNET_YES or GNUNET_NO to determine if the peers of index src and index dst should be connec...
size_t count_of_tunnels(const struct GNUNET_MESSENGER_ListTunnels *tunnels)
Returns the count of peers in a list (typically from the basement of a room).
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 ro...
void disconnect_tunnel(struct GNUNET_MESSENGER_SrvTunnel *tunnel)
Disconnects and unbinds a channel from a tunnel.
@ GNUNET_MESSENGER_FLAG_CONNECTION_AUTO
The auto flag.
void GNUNET_PEER_resolve(GNUNET_PEER_Id id, struct GNUNET_PeerIdentity *pid)
Convert an interned PID to a normal peer identity.
Definition: peer.c:220
enum GNUNET_GenericReturnValue verify_list_tunnels_flag_token(const struct GNUNET_MESSENGER_ListTunnels *tunnels, const struct GNUNET_PeerIdentity *peer, enum GNUNET_MESSENGER_ConnectionFlags flag)
Verifies that a specific tunnel selected by its peer identity in a list of tunnels is the first in or...
struct GNUNET_MESSENGER_ListTunnel * find_list_tunnels(struct GNUNET_MESSENGER_ListTunnels *tunnels, const struct GNUNET_PeerIdentity *peer, size_t *index)
Searches linearly through the list of tunnels peer identities for matching a specific peer identity a...
struct GNUNET_MESSENGER_ListTunnel * remove_from_list_tunnels(struct GNUNET_MESSENGER_ListTunnels *tunnels, struct GNUNET_MESSENGER_ListTunnel *element)
Removes a specific element from the list of tunnels peer identities and returns the next element in t...
struct GNUNET_MESSENGER_ListTunnel * next
struct GNUNET_MESSENGER_ListTunnel * head

References GNUNET_MESSENGER_SrvRoom::basement, close_srv_room(), connect_tunnel(), count_of_tunnels(), disconnect_tunnel(), find_list_tunnels(), get_service_peer_identity(), GNUNET_assert, GNUNET_CONTAINER_multipeermap_get(), GNUNET_MESSENGER_FLAG_CONNECTION_AUTO, GNUNET_NO, GNUNET_OK, GNUNET_PEER_resolve(), GNUNET_SYSERR, GNUNET_YES, GNUNET_MESSENGER_ListTunnels::head, GNUNET_MESSENGER_SrvRoom::host, is_srv_handle_routing(), GNUNET_MESSENGER_SrvRoom::key, GNUNET_MESSENGER_Service::min_routers, GNUNET_MESSENGER_ListTunnel::next, GNUNET_MESSENGER_SrvTunnel::peer, GNUNET_MESSENGER_ListTunnel::peer, remove_from_list_tunnels(), required_connection_between(), GNUNET_MESSENGER_SrvTunnel::room, GNUNET_MESSENGER_SrvRoom::service, GNUNET_MESSENGER_SrvRoom::tunnels, and verify_list_tunnels_flag_token().

Referenced by handle_message_miss(), and handle_message_peer().

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

◆ get_srv_room_amount_of_tunnels()

uint32_t get_srv_room_amount_of_tunnels ( const struct GNUNET_MESSENGER_SrvRoom room)

Returns the amount of active tunnels of a given room.

Parameters
[in]roomRoom
Returns
Amount of tunnels

Definition at line 1088 of file gnunet-service-messenger_room.c.

1089{
1090 GNUNET_assert (room);
1091
1093}
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.

References GNUNET_assert, GNUNET_CONTAINER_multipeermap_size(), GNUNET_MESSENGER_SrvTunnel::room, and GNUNET_MESSENGER_SrvRoom::tunnels.

Referenced by create_message_connection().

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

◆ get_srv_room_connection_flags()

uint32_t get_srv_room_connection_flags ( const struct GNUNET_MESSENGER_SrvRoom room)

Returns connection flags about connection information of a given room and the service managing it.

Parameters
[in]roomRoom
Returns
Connection flags

Definition at line 1097 of file gnunet-service-messenger_room.c.

1098{
1099 GNUNET_assert (room);
1100
1102
1103 if (GNUNET_YES == room->service->auto_routing)
1105
1106 return flags;
1107}
@ GNUNET_MESSENGER_FLAG_CONNECTION_NONE
The none flag.
enum GNUNET_GenericReturnValue auto_routing

References GNUNET_MESSENGER_Service::auto_routing, GNUNET_assert, GNUNET_MESSENGER_FLAG_CONNECTION_AUTO, GNUNET_MESSENGER_FLAG_CONNECTION_NONE, GNUNET_YES, GNUNET_MESSENGER_SrvTunnel::room, and GNUNET_MESSENGER_SrvRoom::service.

Referenced by create_message_connection().

Here is the caller graph for this function:

◆ load_srv_room()

void load_srv_room ( struct GNUNET_MESSENGER_SrvRoom room)

Loads the local configuration for a given room of a service which contains the last messages hash and the ruleset for general access of new members.

Parameters
[out]roomRoom

Definition at line 1392 of file gnunet-service-messenger_room.c.

1393{
1394 GNUNET_assert (room);
1395
1396 char *room_dir;
1397 get_room_data_subdir (room, &room_dir);
1398
1399 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Load room from directory: %s\n",
1400 room_dir);
1401
1403 {
1404 char *peers_file;
1405 GNUNET_asprintf (&peers_file, "%s%s", room_dir, "peers.list");
1406
1407 load_peer_store (get_srv_room_peer_store (room), peers_file);
1408 GNUNET_free (peers_file);
1409
1413
1414 char *basement_file;
1415 GNUNET_asprintf (&basement_file, "%s%s", room_dir, "basement.list");
1416
1417 load_list_tunnels (&(room->basement), basement_file);
1418 GNUNET_free (basement_file);
1419
1420 load_message_state (&(room->state), room_dir);
1421 }
1422
1423 GNUNET_free (room_dir);
1424}
void load_member_store(struct GNUNET_MESSENGER_MemberStore *store, const char *directory)
Loads members from a directory into a member store.
void load_message_state(struct GNUNET_MESSENGER_MessageState *state, const char *path)
void load_message_store(struct GNUNET_MESSENGER_MessageStore *store, const char *directory)
Loads messages from a directory into a message store.
void load_operation_store(struct GNUNET_MESSENGER_OperationStore *store, const char *directory)
Loads operations from a directory into an operation store.
void load_peer_store(struct GNUNET_MESSENGER_PeerStore *store, const char *path)
Loads peer identities from a file into a peer store.
static void get_room_data_subdir(struct GNUNET_MESSENGER_SrvRoom *room, char **dir)
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_test(const char *fil, int is_readable)
Test if fil is a directory and listable.
Definition: disk.c:403
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
void load_list_tunnels(struct GNUNET_MESSENGER_ListTunnels *tunnels, const char *path)
Loads the list of tunnels peer identities from a file under a given path.

References GNUNET_MESSENGER_SrvRoom::basement, get_room_data_subdir(), get_srv_room_member_store(), get_srv_room_message_store(), get_srv_room_operation_store(), get_srv_room_peer_store(), GNUNET_asprintf(), GNUNET_assert, GNUNET_DISK_directory_test(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_YES, load_list_tunnels(), load_member_store(), load_message_state(), load_message_store(), load_operation_store(), load_peer_store(), and GNUNET_MESSENGER_SrvRoom::state.

Referenced by create_srv_room().

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

◆ save_srv_room()

void save_srv_room ( struct GNUNET_MESSENGER_SrvRoom room)

Saves the configuration for a given room of a service which contains the last messages hash and the ruleset for general access of new members locally.

Parameters
[in]roomRoom

Definition at line 1428 of file gnunet-service-messenger_room.c.

1429{
1430 GNUNET_assert (room);
1431
1432 char *room_dir;
1433 get_room_data_subdir (room, &room_dir);
1434
1435 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Save room to directory: %s\n",
1436 room_dir);
1437
1438 if ((GNUNET_YES == GNUNET_DISK_directory_test (room_dir, GNUNET_NO)) ||
1440 {
1441 char *peers_file;
1442 GNUNET_asprintf (&peers_file, "%s%s", room_dir, "peers.list");
1443
1444 save_peer_store (get_srv_room_peer_store (room), peers_file);
1445 GNUNET_free (peers_file);
1446
1450
1451 char *basement_file;
1452 GNUNET_asprintf (&basement_file, "%s%s", room_dir, "basement.list");
1453
1454 save_list_tunnels (&(room->basement), basement_file);
1455 GNUNET_free (basement_file);
1456
1457 save_message_state (&(room->state), room_dir);
1458 }
1459
1460 GNUNET_free (room_dir);
1461}
void save_member_store(struct GNUNET_MESSENGER_MemberStore *store, const char *directory)
Saves members from a member store into a directory.
void save_message_state(const struct GNUNET_MESSENGER_MessageState *state, const char *path)
void save_message_store(struct GNUNET_MESSENGER_MessageStore *store, const char *directory)
Saves messages from a message store into a directory.
void save_operation_store(const struct GNUNET_MESSENGER_OperationStore *store, const char *directory)
Saves operations from an operation store into a directory.
void save_peer_store(const struct GNUNET_MESSENGER_PeerStore *store, const char *path)
Saves peer identities from a peer store into a file.
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_create(const char *dir)
Implementation of "mkdir -p".
Definition: disk.c:496
void save_list_tunnels(struct GNUNET_MESSENGER_ListTunnels *tunnels, const char *path)
Saves the list of tunnels peer identities to a file under a given path.

References GNUNET_MESSENGER_SrvRoom::basement, get_room_data_subdir(), get_srv_room_member_store(), get_srv_room_message_store(), get_srv_room_operation_store(), get_srv_room_peer_store(), GNUNET_asprintf(), GNUNET_assert, GNUNET_DISK_directory_create(), GNUNET_DISK_directory_test(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_YES, save_list_tunnels(), save_member_store(), save_message_state(), save_message_store(), save_operation_store(), save_peer_store(), and GNUNET_MESSENGER_SrvRoom::state.

Referenced by destroy_srv_room().

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

◆ remove_srv_room()

void remove_srv_room ( struct GNUNET_MESSENGER_SrvRoom room)

Removes the configuration for a given room of a service.

Parameters
[in]roomRoom

Definition at line 1465 of file gnunet-service-messenger_room.c.

1466{
1467 GNUNET_assert (room);
1468
1469 char *room_dir;
1470 get_room_data_subdir (room, &room_dir);
1471
1472 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Remove room from directory: %s\n",
1473 room_dir);
1474
1477
1478 GNUNET_free (room_dir);
1479}
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_remove(const char *filename)
Remove all files in a directory (rm -rf).
Definition: disk.c:1087

References get_room_data_subdir(), GNUNET_assert, GNUNET_DISK_directory_remove(), GNUNET_DISK_directory_test(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, and GNUNET_YES.

Referenced by destroy_srv_room().

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