GNUnet debian-0.24.3-23-g589b01d60
gnunet-service-messenger_room.c File Reference
Include dependency graph for gnunet-service-messenger_room.c:

Go to the source code of this file.

Data Structures

struct  GNUNET_MESSENGER_ClosureSendRoom
 
struct  GNUNET_MESSENGER_MemberSubscriptionIteration
 
struct  GNUNET_MESSENGER_MemberSessionCompletion
 
struct  GNUNET_MESSENGER_MemberUpdate
 

Functions

static void idle_request_room_messages (void *cls)
 
static void get_room_data_subdir (struct GNUNET_MESSENGER_SrvRoom *room, char **dir)
 
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...
 
static enum GNUNET_GenericReturnValue iterate_destroy_tunnels (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
 
static void close_srv_room (struct GNUNET_MESSENGER_SrvRoom *room)
 
static void handle_room_messages (struct GNUNET_MESSENGER_SrvRoom *room)
 
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...
 
static enum GNUNET_GenericReturnValue send_room_info (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_SrvTunnel *tunnel)
 
static void * callback_room_connect (void *cls, struct GNUNET_CADET_Channel *channel, const struct GNUNET_PeerIdentity *source)
 
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 enum GNUNET_GenericReturnValue join_room_locally (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle)
 
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...
 
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)
 
struct GNUNET_MQ_Envelopepack_srv_room_message (struct GNUNET_MESSENGER_SrvRoom *room, 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...
 
static enum GNUNET_GenericReturnValue iterate_send_room_message (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
 
enum GNUNET_GenericReturnValue update_room_message (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
 
void callback_room_handle_message (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
 
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...
 
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)
 
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...
 
static enum GNUNET_GenericReturnValue iterate_member_for_subscription (void *cls, const struct GNUNET_CRYPTO_PublicKey *public_key, struct GNUNET_MESSENGER_MemberSession *session)
 
void cleanup_srv_room_discourse_messages (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_ShortHashCode *discourse)
 Cleanup discourse messages outside of current subscriptions from a specific discourse of all the members in a given room. More...
 
static enum GNUNET_GenericReturnValue iterate_update_member_sessions (void *cls, const struct GNUNET_CRYPTO_PublicKey *public_key, struct GNUNET_MESSENGER_MemberSession *session)
 
static void remove_room_member_session (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_MemberSession *session)
 
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...
 

Function Documentation

◆ idle_request_room_messages()

static void idle_request_room_messages ( void *  cls)
static

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

999{
1000 struct GNUNET_MESSENGER_SrvRoom *room;
1001 struct GNUNET_MESSENGER_OperationStore *operation_store;
1002 const struct GNUNET_HashCode *hash;
1003
1004 GNUNET_assert (cls);
1005
1006 room = cls;
1007 room->idle = NULL;
1008
1009 operation_store = get_srv_room_operation_store (room);
1010 hash = get_message_state_merge_hash (&(room->state));
1011
1012 if ((hash) && (! GNUNET_is_zero (hash)) &&
1014 hash)))
1016 operation_store,
1017 hash,
1020
1025 cls);
1026}
const struct GNUNET_HashCode * get_message_state_merge_hash(const struct GNUNET_MESSENGER_MessageState *state)
enum GNUNET_MESSENGER_OperationType get_store_operation_type(const struct GNUNET_MESSENGER_OperationStore *store, const struct GNUNET_HashCode *hash)
Returns the type of the active operation under a given hash in a specific operation store.
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.
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.
#define GNUNET_MESSENGER_MERGE_DELAY
#define GNUNET_MESSENGER_IDLE_DELAY
#define GNUNET_is_zero(a)
Check that memory in a is all zeros.
@ GNUNET_SCHEDULER_PRIORITY_IDLE
Run when otherwise idle.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed_with_priority(struct GNUNET_TIME_Relative delay, enum GNUNET_SCHEDULER_Priority priority, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1207
A 512-bit hashcode.
struct GNUNET_SCHEDULER_Task * idle
struct GNUNET_MESSENGER_MessageState state

References get_message_state_merge_hash(), get_srv_room_operation_store(), get_store_operation_type(), GNUNET_assert, GNUNET_is_zero, GNUNET_MESSENGER_IDLE_DELAY, GNUNET_MESSENGER_MERGE_DELAY, GNUNET_MESSENGER_OP_MERGE, GNUNET_MESSENGER_OP_UNKNOWN, GNUNET_SCHEDULER_add_delayed_with_priority(), GNUNET_SCHEDULER_PRIORITY_IDLE, GNUNET_MESSENGER_SrvRoom::idle, idle_request_room_messages(), GNUNET_MESSENGER_SrvRoom::state, and use_store_operation().

Referenced by create_srv_room(), and idle_request_room_messages().

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

◆ get_room_data_subdir()

static void get_room_data_subdir ( struct GNUNET_MESSENGER_SrvRoom room,
char **  dir 
)
static

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

50{
51 GNUNET_assert ((room) && (dir));
52
53 if (room->service->dir)
54 GNUNET_asprintf (dir, "%s%s%c%s%c", room->service->dir, "rooms",
57 else
58 *dir = NULL;
59}
static char * dir
Set to the directory where runtime files are stored.
Definition: gnunet-arm.c:88
const struct GNUNET_HashCode * get_srv_room_key(const struct GNUNET_MESSENGER_SrvRoom *room)
Returns the shared secret you need to access a room.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define DIR_SEPARATOR
Definition: platform.h:166
struct GNUNET_MESSENGER_Service * service

References dir, GNUNET_MESSENGER_Service::dir, DIR_SEPARATOR, get_srv_room_key(), GNUNET_asprintf(), GNUNET_assert, GNUNET_h2s(), and GNUNET_MESSENGER_SrvRoom::service.

Referenced by create_srv_room(), load_srv_room(), remove_room_member_session(), remove_srv_room(), and save_srv_room().

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

◆ 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 63 of file gnunet-service-messenger_room.c.

65{
66 struct GNUNET_MESSENGER_SrvRoom *room;
67 char *room_dir;
68
69 GNUNET_assert ((handle) && (key));
70
71 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Create new room: %s\n",
72 GNUNET_h2s (key));
73
75
76 room->service = handle->service;
77 room->host = handle;
78 room->port = NULL;
79
80 GNUNET_memcpy (&(room->key), key, sizeof(struct GNUNET_HashCode));
81
83
84 get_room_data_subdir (room, &room_dir);
85
90
91 GNUNET_free (room_dir);
92
93 init_list_tunnels (&(room->basement));
94 init_message_state (&(room->state));
95
96 room->peer_message = NULL;
97
99 room->idle = NULL;
100
101 if (room->service->dir)
102 load_srv_room (room);
103
106
107 return room;
108}
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, const char *directory)
Initializes a message store as fully empty using a specific directory.
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.
static void get_room_data_subdir(struct GNUNET_MESSENGER_SrvRoom *room, char **dir)
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.
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_log(kind,...)
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_NO
@ GNUNET_ERROR_TYPE_DEBUG
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
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:1231
void init_list_tunnels(struct GNUNET_MESSENGER_ListTunnels *tunnels)
Initializes list of tunnels peer identities as empty list.
struct GNUNET_HashCode * peer_message
struct GNUNET_CONTAINER_MultiPeerMap * tunnels
struct GNUNET_CADET_Port * port
struct GNUNET_MESSENGER_ListTunnels basement
struct GNUNET_MESSENGER_ListMessages handling
struct GNUNET_MESSENGER_SrvHandle * host

References GNUNET_MESSENGER_SrvRoom::basement, GNUNET_MESSENGER_Service::dir, 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_assert, GNUNET_CONTAINER_multipeermap_create(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_log, 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:

◆ iterate_destroy_tunnels()

static enum GNUNET_GenericReturnValue iterate_destroy_tunnels ( void *  cls,
const struct GNUNET_PeerIdentity key,
void *  value 
)
static

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

115{
116 struct GNUNET_MESSENGER_SrvTunnel *tunnel;
117
119
120 tunnel = value;
121
122 destroy_tunnel (tunnel);
123 return GNUNET_YES;
124}
static char * value
Value of the record to add/remove.
static void destroy_tunnel(void *cls)
This tunnel is no longer used, destroy it.
@ GNUNET_YES

References destroy_tunnel(), GNUNET_assert, GNUNET_YES, and value.

Referenced by destroy_srv_room().

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

◆ close_srv_room()

static void close_srv_room ( struct GNUNET_MESSENGER_SrvRoom room)
static

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

443{
444 struct GNUNET_PeerIdentity peer;
445
446 GNUNET_assert (room);
447
448 if (! room->port)
449 return;
450
451 if ((room->peer_message) &&
452 (GNUNET_OK == get_service_peer_identity (room->service, &peer)))
453 {
454 struct GNUNET_MESSENGER_Message *message;
455
456 message = create_message_miss (&peer);
457
458 if (! message)
460 "Sending miss message about peer failed: %s\n",
461 GNUNET_h2s (&(room->key)));
462 else
463 send_srv_room_message (room, room->host, message);
464 }
465
467 room->port = NULL;
468}
struct GNUNET_MESSENGER_Message * create_message_miss(const struct GNUNET_PeerIdentity *peer)
Creates and allocates a new miss message containing the missing peer 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.
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.
void GNUNET_CADET_close_port(struct GNUNET_CADET_Port *p)
Close a port opened with GNUNET_CADET_open_port.
Definition: cadet_api.c:804
@ GNUNET_OK
@ GNUNET_ERROR_TYPE_ERROR
The identity of the host (wraps the signing key of the peer).

References create_message_miss(), get_service_peer_identity(), GNUNET_assert, GNUNET_CADET_close_port(), GNUNET_ERROR_TYPE_ERROR, GNUNET_h2s(), GNUNET_log, GNUNET_OK, GNUNET_MESSENGER_SrvRoom::host, GNUNET_MESSENGER_SrvRoom::key, GNUNET_MESSENGER_SrvRoom::peer_message, GNUNET_MESSENGER_SrvRoom::port, send_srv_room_message(), and GNUNET_MESSENGER_SrvRoom::service.

Referenced by destroy_srv_room(), open_srv_room(), and rebuild_srv_room_basement_structure().

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

◆ handle_room_messages()

static void handle_room_messages ( struct GNUNET_MESSENGER_SrvRoom room)
static

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

1184{
1185 struct GNUNET_MESSENGER_MessageStore *message_store;
1186 struct GNUNET_MESSENGER_MemberStore *member_store;
1187 struct GNUNET_MESSENGER_PeerStore *peer_store;
1188 const struct GNUNET_HashCode *key;
1189
1190 message_store = get_srv_room_message_store (room);
1191 member_store = get_srv_room_member_store (room);
1192 peer_store = get_srv_room_peer_store (room);
1193
1194 key = get_srv_room_key (room);
1195
1197 "Handling room messages: %s\n", GNUNET_h2s (key));
1198
1199 while (room->handling.head)
1200 {
1201 struct GNUNET_MESSENGER_ListMessage *element;
1202 struct GNUNET_MESSENGER_SenderSession session;
1203 const struct GNUNET_MESSENGER_Message *message;
1204 const struct GNUNET_HashCode *epoch;
1205
1206 element = room->handling.head;
1207 message = get_store_message (
1208 message_store, &(element->hash));
1209
1210 if (! message)
1211 goto finish_handling;
1212
1213 if (GNUNET_YES == is_peer_message (message))
1214 {
1215 session.peer = get_store_peer_of (peer_store, message, &(element->hash));
1216
1217 if (! session.peer)
1218 goto finish_handling;
1219 }
1220 else
1221 {
1222 struct GNUNET_MESSENGER_Member *member;
1223
1224 member = get_store_member_of (member_store, message);
1225
1226 if (! member)
1227 goto finish_handling;
1228
1229 session.member = get_member_session_of (member, message,
1230 &(element->hash));
1231
1232 if (! session.member)
1233 goto finish_handling;
1234 }
1235
1236 epoch = get_store_message_epoch (message_store, &(element->hash));
1237
1238 handle_service_message (room->service, room, &session, message,
1239 &(element->hash), epoch, GNUNET_YES);
1240
1241finish_handling:
1243 element);
1244 GNUNET_free (element);
1245 }
1246}
struct GNUNET_MESSENGER_MemberSession * get_member_session_of(struct GNUNET_MESSENGER_Member *member, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Returns the member session of a member using a public key which can verify the signature of a given m...
struct GNUNET_MESSENGER_Member * get_store_member_of(struct GNUNET_MESSENGER_MemberStore *store, const struct GNUNET_MESSENGER_Message *message)
Returns the member of a store using a sender id of a given message.
const struct GNUNET_HashCode * get_store_message_epoch(const struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash)
Returns the epoch hash of a message from a message store matching a given hash.
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.
struct GNUNET_PeerIdentity * get_store_peer_of(struct GNUNET_MESSENGER_PeerStore *store, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Returns the peer identity inside the store which verifies the signature of a given message as valid.
void handle_service_message(struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_MESSENGER_SenderSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash, const struct GNUNET_HashCode *epoch, enum GNUNET_GenericReturnValue recent)
Sends a received or sent message with a given hash to each handle of a service which is currently mem...
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
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_MESSENGER_ListMessage * head
struct GNUNET_MESSENGER_ListMessage * tail

References get_member_session_of(), get_srv_room_key(), get_srv_room_member_store(), get_srv_room_message_store(), get_srv_room_peer_store(), get_store_member_of(), get_store_message(), get_store_message_epoch(), get_store_peer_of(), GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_YES, handle_service_message(), GNUNET_MESSENGER_SrvRoom::handling, GNUNET_MESSENGER_ListMessage::hash, GNUNET_MESSENGER_ListMessages::head, is_peer_message(), key, GNUNET_MESSENGER_SenderSession::member, GNUNET_MESSENGER_SenderSession::peer, GNUNET_MESSENGER_SrvRoom::service, and GNUNET_MESSENGER_ListMessages::tail.

Referenced by callback_room_handle_message(), and destroy_srv_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 134 of file gnunet-service-messenger_room.c.

136{
137 GNUNET_assert (room);
138
139 if (room->idle)
140 {
142 room->idle = NULL;
143 }
144
145 close_srv_room (room);
146
148 NULL);
150
151 if (! (room->service->dir))
152 goto skip_saving;
153
154 if (GNUNET_YES == deletion)
155 remove_srv_room (room);
156 else
157 save_srv_room (room);
158
159skip_saving:
164
166 clear_list_tunnels (&(room->basement));
167 clear_message_state (&(room->state));
168
169 if (room->peer_message)
171
172 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Free room: %s\n",
173 GNUNET_h2s (&(room->key)));
174
175 GNUNET_free (room);
176}
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.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:980
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_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_SCHEDULER_cancel(), GNUNET_YES, handle_room_messages(), GNUNET_MESSENGER_SrvRoom::idle, iterate_destroy_tunnels(), GNUNET_MESSENGER_SrvRoom::key, 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 180 of file gnunet-service-messenger_room.c.

181{
182 GNUNET_assert (room);
183
184 return &(room->peer_store);
185}
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(), save_srv_room(), and traverse_epoch_session_message().

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 189 of file gnunet-service-messenger_room.c.

190{
191 GNUNET_assert (room);
192
193 return &(room->member_store);
194}
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(), cleanup_srv_room_discourse_messages(), 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(), notify_srv_handle_message(), open_srv_room(), recv_message_info(), recv_message_request(), save_srv_room(), send_message_join(), solve_srv_room_member_collisions(), and traverse_epoch_session_message().

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)

◆ 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 207 of file gnunet-service-messenger_room.c.

208{
209 GNUNET_assert (room);
210
211 return &(room->operation_store);
212}
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:

◆ send_room_info()

static enum GNUNET_GenericReturnValue send_room_info ( struct GNUNET_MESSENGER_SrvRoom room,
struct GNUNET_MESSENGER_SrvHandle handle,
struct GNUNET_MESSENGER_SrvTunnel tunnel 
)
static

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

219{
220 if ((! handle) || (! is_tunnel_connected (tunnel)))
221 return GNUNET_NO;
222
224 room->service));
225}
struct GNUNET_MESSENGER_Message * create_message_info(struct GNUNET_MESSENGER_Service *service)
Creates and allocates a new info message containing the hosts service peer identity and version.
enum GNUNET_GenericReturnValue is_tunnel_connected(const struct GNUNET_MESSENGER_SrvTunnel *tunnel)
Returns the status of a currently bound channel of a tunnel.
enum GNUNET_GenericReturnValue send_tunnel_message(struct GNUNET_MESSENGER_SrvTunnel *tunnel, void *handle, struct GNUNET_MESSENGER_Message *message)
Sends a message by packing it automatically into an envelope and passing it through the tunnel.

References create_message_info(), GNUNET_NO, handle, is_tunnel_connected(), GNUNET_MESSENGER_OperationStore::room, send_tunnel_message(), and GNUNET_MESSENGER_SrvRoom::service.

Referenced by callback_room_connect().

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

◆ callback_room_connect()

static void * callback_room_connect ( void *  cls,
struct GNUNET_CADET_Channel channel,
const struct GNUNET_PeerIdentity source 
)
static

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

232{
233 struct GNUNET_MESSENGER_SrvRoom *room;
234 struct GNUNET_MESSENGER_SrvTunnel *tunnel;
235
236 GNUNET_assert ((cls) && (channel) && (source));
237
238 room = cls;
239
241 "New incoming connection to room (%s) from peer: %s\n",
243
244 tunnel = create_tunnel (room, source);
245
246 if ((tunnel) &&
248 tunnel,
250 {
251 destroy_tunnel (tunnel);
252 tunnel = NULL;
253 }
254
255 if (! tunnel)
256 {
258 return NULL;
259 }
260
261 bind_tunnel (tunnel, channel);
262
264 "New tunnel in room (%s) established to peer: %s\n",
266
267 if (GNUNET_YES == send_room_info (room, room->host, tunnel))
268 return tunnel;
269
270 disconnect_tunnel (tunnel);
271
273 tunnel))
274 destroy_tunnel (tunnel);
275
276 return NULL;
277}
static GstElement * source
Appsrc instance into which we write data for the pipeline.
static enum GNUNET_GenericReturnValue send_room_info(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_SrvTunnel *tunnel)
void bind_tunnel(struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_CADET_Channel *channel)
Binds a CADET channel to a tunnel and replaces its channel the tunnel is currently bound to if necess...
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).
void disconnect_tunnel(struct GNUNET_MESSENGER_SrvTunnel *tunnel)
Disconnects and unbinds a channel from a tunnel.
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.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
void delayed_disconnect_channel(struct GNUNET_CADET_Channel *channel)
Starts an urgent task to close a CADET channel asynchronously.
struct GNUNET_CADET_Channel * channel
struct GNUNET_MESSENGER_SrvRoom * room

References bind_tunnel(), GNUNET_MESSENGER_SrvTunnel::channel, create_tunnel(), delayed_disconnect_channel(), destroy_tunnel(), disconnect_tunnel(), get_srv_room_key(), GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multipeermap_put(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_OK, GNUNET_YES, GNUNET_MESSENGER_SrvRoom::host, GNUNET_MESSENGER_SrvTunnel::room, send_room_info(), source, and GNUNET_MESSENGER_SrvRoom::tunnels.

Referenced by open_srv_room().

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

◆ join_room()

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

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

285{
286 const struct GNUNET_ShortHashCode *member_id;
287
288 GNUNET_assert ((room) && (handle) && (member));
289
290 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Joining room: %s (%s)\n", GNUNET_h2s (
291 get_srv_room_key (room)),
292 GNUNET_sh2s (get_member_id (member)));
293
294 member_id = get_member_id (member);
295
297 member_id))
298 return GNUNET_NO;
299
300 {
302 if ((! id) || (0 != GNUNET_memcmp (id, member_id)))
304 else
306
307 notify_srv_handle_member_id (handle, room, member_id, reset);
308 }
309
310 return GNUNET_YES;
311}
static int reset
Reset argument.
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...
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_ShortHashCode * get_member_id(const struct GNUNET_MESSENGER_Member *member)
Returns the current id of a given member.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
GNUNET_GenericReturnValue
Named constants for return values.
const char * GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).
A 256-bit hashcode.

References change_srv_handle_member_id(), get_member_id(), get_srv_room_key(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_memcmp, GNUNET_NO, GNUNET_OK, GNUNET_sh2s(), GNUNET_YES, handle, notify_srv_handle_member_id(), and reset.

Referenced by join_room_locally(), and open_srv_room().

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

◆ join_room_locally()

static enum GNUNET_GenericReturnValue join_room_locally ( struct GNUNET_MESSENGER_SrvRoom room,
struct GNUNET_MESSENGER_SrvHandle handle 
)
static

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

317{
318 struct GNUNET_MESSENGER_MemberStore *member_store;
319 const struct GNUNET_ShortHashCode *member_id;
320 struct GNUNET_MESSENGER_Member *member;
321
322 member_store = get_srv_room_member_store (room);
324 member = add_store_member (member_store, member_id);
325
326 if (GNUNET_NO == join_room (room, handle, member, member_id))
327 return GNUNET_NO;
328
329 return GNUNET_YES;
330}
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.
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)

References add_store_member(), get_srv_handle_member_id(), get_srv_room_key(), get_srv_room_member_store(), GNUNET_NO, GNUNET_YES, handle, and join_room().

Referenced by enter_srv_room_at(), and open_srv_room().

Here is the call graph for this function:
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 334 of file gnunet-service-messenger_room.c.

336{
337 GNUNET_assert (room);
338
339 if (handle)
340 room->host = handle;
341
342 if (room->port)
343 {
345 "Port of room (%s) was already open!\n",
347
348 if (! handle)
349 return GNUNET_YES;
350
351 return join_room_locally (room, handle);
352 }
353
354 {
357 struct GNUNET_HashCode port;
358
360 tunnel_message,
362 struct
364 ,
366
367 cadet = get_srv_room_cadet (room);
368
370 &(key.hash),
371 get_srv_room_key (room),
372 sizeof (key.hash));
373
374 if ((key.code.feed_bit) && (! key.code.group_bit))
375 {
377 "Opening port of personal room containing private feeds failed!");
378 return GNUNET_SYSERR;
379 }
380
382 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Trying to open CADET port: %s\n",
383 GNUNET_h2s (&port));
384
386 room, NULL, callback_tunnel_disconnect,
387 handlers);
388 }
389
390 if (room->port)
391 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Port of room (%s) was opened!\n",
393 else
395 "Port of room (%s) could not be opened!\n",
397
398 if (! handle)
399 goto complete_opening;
400
401 {
402 struct GNUNET_MESSENGER_MemberStore *member_store;
403 const struct GNUNET_ShortHashCode *member_id;
404 struct GNUNET_MESSENGER_Member *member;
405
406 member_store = get_srv_room_member_store (room);
408 member = add_store_member (member_store, member_id);
409
410 if ((GNUNET_NO == join_room (room, handle, member, member_id)) &&
411 (room->port))
412 {
414 "You could not join the room, therefore it keeps closed!\n");
415
416 close_srv_room (room);
417 return GNUNET_NO;
418 }
419 }
420
421complete_opening:
422 if (! room->port)
423 return GNUNET_NO;
424
425 {
426 struct GNUNET_MESSENGER_Message *message;
427 message = create_message_peer (room->service);
428
429 if (! message)
430 {
432 "Peer message could not be sent!\n");
433 return GNUNET_NO;
434 }
435
436 return send_srv_room_message (room, handle, message);
437 }
438}
struct GNUNET_MQ_MessageHandlers handlers[]
Definition: 003.c:1
static uint16_t port
Port number.
Definition: gnunet-bcd.c:146
static struct GNUNET_CADET_Handle * cadet
Handle for cadet.
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 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)
struct GNUNET_CADET_Handle * get_srv_room_cadet(struct GNUNET_MESSENGER_SrvRoom *room)
Returns the CADET handle from a rooms service.
void callback_tunnel_disconnect(void *cls, const struct GNUNET_CADET_Channel *channel)
Callback for a CADET channel disconnecting to manage this event as a proper tunnel provided as its cl...
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:966
@ GNUNET_SYSERR
@ GNUNET_ERROR_TYPE_WARNING
#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 union GNUNET_MESSENGER_RoomKey *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 room key unifies a room key code and its 512bit hash representation.

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_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_CADET_CLI, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_NO, GNUNET_SYSERR, GNUNET_YES, handle, handlers, GNUNET_MESSENGER_SrvRoom::host, join_room(), join_room_locally(), key, port, GNUNET_MESSENGER_SrvRoom::port, 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 472 of file gnunet-service-messenger_room.c.

475{
476 struct GNUNET_PeerIdentity peer;
477 struct GNUNET_MESSENGER_SrvTunnel *tunnel;
478
479 GNUNET_assert ((room) && (handle) && (door));
480
482 (0 == GNUNET_memcmp (&peer, door)))
483 return join_room_locally (room, handle);
484
486
487 if (! tunnel)
488 {
489 tunnel = create_tunnel (room, door);
490
492 tunnel,
494 {
496 "You could not connect to that door!\n");
497 destroy_tunnel (tunnel);
498 return GNUNET_NO;
499 }
500 }
501
502 if (GNUNET_SYSERR == connect_tunnel (tunnel))
503 {
505 "Connection failure during entrance!\n");
507 destroy_tunnel (tunnel);
508 return GNUNET_NO;
509 }
510
511 return join_room_locally (room, handle);
512}
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.

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::peer, GNUNET_MESSENGER_SrvTunnel::room, GNUNET_MESSENGER_SrvRoom::service, and GNUNET_MESSENGER_SrvRoom::tunnels.

Referenced by callback_tunnel_disconnect(), and entry_service_room().

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

◆ sign_srv_room_message_by_peer()

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

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

521{
522 const struct GNUNET_MESSENGER_Service *service;
523
524 GNUNET_assert ((cls) && (message) && (buffer) && (hash));
525
526 service = cls;
527
528 if (! service->config)
529 {
531 "Signing message by peer identity failed!\n");
532 return;
533 }
534
535 sign_message_by_peer (message, length, buffer, hash, service->config);
536}
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
void sign_message_by_peer(struct GNUNET_MESSENGER_Message *message, uint16_t length, char *buffer, const struct GNUNET_HashCode *hash, const struct GNUNET_CONFIGURATION_Handle *cfg)
Signs the hash of a message with the peer identity of a given config and writes the signature into th...

References GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, service, and sign_message_by_peer().

Referenced by pack_srv_room_message().

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 ( struct GNUNET_MESSENGER_SrvRoom room,
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 peers private key if necessary.

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,out]roomRoom
[in,out]messageMessage
[out]hashHash of message
[in]modePacking mode
Returns
New envelope or NULL

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

544{
545 struct GNUNET_PeerIdentity peer;
546
547 GNUNET_assert ((room) && (message) && (hash));
548
549 if (GNUNET_YES != is_peer_message (message))
550 return pack_message (message, hash, NULL, mode, NULL);
551
552 if (GNUNET_YES == is_epoch_message (message))
555 else
558
559 if (GNUNET_OK != get_service_peer_identity (room->service, &peer))
560 return NULL;
561
562 convert_peer_identity_to_id (&peer, &(message->header.sender_id));
563 get_message_state_chain_hash (&(room->state), &(message->header.previous));
564
566 {
567 const struct GNUNET_MESSENGER_MessageStore *store;
568 const struct GNUNET_HashCode *epoch;
569
570 store = get_srv_room_message_store (room);
571 epoch = get_store_message_epoch (store, &(message->header.previous));
572
573 if (epoch)
574 GNUNET_memcpy (&(message->body.merge.epochs[0]), epoch,
575 sizeof (struct GNUNET_HashCode));
576
577 epoch = get_store_message_epoch (store, &(message->body.merge.previous));
578
579 if (epoch)
580 GNUNET_memcpy (&(message->body.merge.epochs[1]), epoch,
581 sizeof (struct GNUNET_HashCode));
582 }
583
585 "Packing message with peer signature: %s\n",
586 GNUNET_sh2s (&(message->header.sender_id)));
587
589 return pack_message (message, hash, sign_srv_room_message_by_peer, mode,
590 room->service);
591}
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.
@ GNUNET_MESSENGER_KIND_MERGE
The merge kind.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get_zero_(void)
Return absolute time of 0ms.
Definition: time.c:142
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:640
enum GNUNET_GenericReturnValue is_epoch_message(const struct GNUNET_MESSENGER_Message *message)
Returns whether a certain kind of message from storage contains some specific details that might be r...
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_MESSENGER_MessageMerge merge
struct GNUNET_HashCode previous
The hash of the previous message from the senders perspective.
enum GNUNET_MESSENGER_MessageKind kind
The kind of the message.
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_HashCode previous
The hash of a second previous message.
struct GNUNET_HashCode epochs[2]
The previous epochs the message was sent from.
struct GNUNET_MESSENGER_MessageHeader header
Header.
struct GNUNET_MESSENGER_MessageBody body
Body.

References GNUNET_MESSENGER_Message::body, convert_peer_identity_to_id(), GNUNET_MESSENGER_MessageMerge::epochs, get_message_state_chain_hash(), get_service_peer_identity(), get_srv_room_message_store(), get_store_message_epoch(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcpy, GNUNET_MESSENGER_KIND_MERGE, GNUNET_OK, GNUNET_PUBLIC_KEY_TYPE_EDDSA, GNUNET_sh2s(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_zero_(), GNUNET_TIME_absolute_hton(), GNUNET_YES, GNUNET_MESSENGER_Message::header, is_epoch_message(), is_peer_message(), GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_MessageBody::merge, mode, pack_message(), GNUNET_MESSENGER_MessageHeader::previous, GNUNET_MESSENGER_MessageMerge::previous, GNUNET_MESSENGER_MessageHeader::sender_id, GNUNET_MESSENGER_SrvRoom::service, 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:

◆ iterate_send_room_message()

static enum GNUNET_GenericReturnValue iterate_send_room_message ( void *  cls,
const struct GNUNET_PeerIdentity key,
void *  value 
)
static

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

608{
609 struct GNUNET_MESSENGER_SrvTunnel *tunnel;
610 struct GNUNET_MESSENGER_ClosureSendRoom *closure;
611 struct GNUNET_MQ_Envelope *env;
612
613 GNUNET_assert ((cls) && (value));
614
615 tunnel = value;
616
617 if ((! is_tunnel_connected (tunnel)) ||
619 return GNUNET_YES;
620
621 closure = cls;
622
623 if (tunnel == closure->exclude)
624 return GNUNET_YES;
625
626 env = NULL;
627
628 if (closure->packed == GNUNET_NO)
629 {
630 env = pack_srv_room_message (closure->room,
631 closure->message,
632 closure->hash,
634
635 if (env)
636 closure->packed = GNUNET_YES;
637 }
638 else
639 env = pack_message (closure->message, NULL, NULL,
641
642 if (env)
643 send_tunnel_envelope (tunnel, env, closure->hash);
644
645 return GNUNET_YES;
646}
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
struct GNUNET_MQ_Envelope * pack_srv_room_message(struct GNUNET_MESSENGER_SrvRoom *room, 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 send_tunnel_envelope(struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MQ_Envelope *env, const struct GNUNET_HashCode *hash)
Sends an envelope containing a message with a given hash through a tunnel.
uint32_t get_tunnel_messenger_version(const struct GNUNET_MESSENGER_SrvTunnel *tunnel)
Returns the current messenger version the peer connected via a given tunnel has reported to be using ...
#define GNUNET_MESSENGER_VERSION
Version number of GNUnet Messenger API.
@ GNUNET_MESSENGER_PACK_MODE_ENVELOPE
struct GNUNET_MESSENGER_Message * message
struct GNUNET_MESSENGER_SrvTunnel * exclude
struct GNUNET_MESSENGER_SrvRoom * room

References env, GNUNET_MESSENGER_ClosureSendRoom::exclude, get_tunnel_messenger_version(), GNUNET_assert, GNUNET_MESSENGER_PACK_MODE_ENVELOPE, GNUNET_MESSENGER_VERSION, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_ClosureSendRoom::hash, is_tunnel_connected(), GNUNET_MESSENGER_ClosureSendRoom::message, pack_message(), pack_srv_room_message(), GNUNET_MESSENGER_ClosureSendRoom::packed, GNUNET_MESSENGER_ClosureSendRoom::room, send_tunnel_envelope(), and value.

Referenced by forward_srv_room_message(), and send_srv_room_message().

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

◆ update_room_message()

enum GNUNET_GenericReturnValue update_room_message ( struct GNUNET_MESSENGER_SrvRoom room,
struct GNUNET_MESSENGER_Message message,
const struct GNUNET_HashCode hash 
)

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

1253{
1254 struct GNUNET_MESSENGER_OperationStore *operation_store;
1255 struct GNUNET_MESSENGER_MessageStore *message_store;
1256 enum GNUNET_GenericReturnValue requested;
1257
1258 GNUNET_assert ((room) && (message) && (hash));
1259
1260 operation_store = get_srv_room_operation_store (room);
1261
1262 requested = (GNUNET_MESSENGER_OP_REQUEST ==
1263 get_store_operation_type (operation_store, hash)?
1265
1266 if (GNUNET_YES == requested)
1267 cancel_store_operation (operation_store, hash);
1268
1269 message_store = get_srv_room_message_store (room);
1270
1271 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Handle a message in room (%s).\n",
1272 GNUNET_h2s (get_srv_room_key (room)));
1273
1274 if (GNUNET_YES == contains_store_message (message_store, hash))
1275 {
1276 destroy_message (message);
1277
1278 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Duplicate message got dropped!\n");
1279 return GNUNET_NO;
1280 }
1281
1282 if (GNUNET_OK != put_store_message (message_store, hash, message))
1283 {
1284 destroy_message (message);
1285
1286 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Storing message failed!\n");
1287 return GNUNET_NO;
1288 }
1289
1290 update_message_state (&(room->state), requested, message, hash);
1291
1292 if ((GNUNET_YES == requested) ||
1293 (GNUNET_MESSENGER_KIND_INFO == message->header.kind) ||
1295 return GNUNET_YES;
1296
1297 if ((GNUNET_MESSENGER_KIND_MERGE == message->header.kind) &&
1299 &(message->body.
1300 merge.previous))
1301 ))
1302 cancel_store_operation (operation_store, &(message->body.merge.previous));
1303
1305 &(message->header.
1306 previous)))
1307 cancel_store_operation (operation_store, &(message->header.previous));
1308
1309 return GNUNET_YES;
1310}
void update_message_state(struct GNUNET_MESSENGER_MessageState *state, enum GNUNET_GenericReturnValue requested, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
enum GNUNET_GenericReturnValue contains_store_message(const struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash)
Checks if a message matching a given hash is stored in a message store.
enum GNUNET_GenericReturnValue put_store_message(struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash, struct GNUNET_MESSENGER_Message *message)
Stores a message into the message store.
void cancel_store_operation(struct GNUNET_MESSENGER_OperationStore *store, const struct GNUNET_HashCode *hash)
Stops any active operation under a given hash in a specific operation store.
@ GNUNET_MESSENGER_KIND_INFO
The info kind.
@ GNUNET_MESSENGER_KIND_REQUEST
The request kind.
void destroy_message(struct GNUNET_MESSENGER_Message *message)
Destroys a message and frees its memory fully.

References GNUNET_MESSENGER_Message::body, cancel_store_operation(), contains_store_message(), destroy_message(), get_srv_room_key(), get_srv_room_message_store(), get_srv_room_operation_store(), get_store_operation_type(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_MESSENGER_KIND_INFO, GNUNET_MESSENGER_KIND_MERGE, GNUNET_MESSENGER_KIND_REQUEST, GNUNET_MESSENGER_OP_MERGE, GNUNET_MESSENGER_OP_REQUEST, GNUNET_NO, GNUNET_OK, GNUNET_YES, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_MessageBody::merge, GNUNET_MESSENGER_MessageHeader::previous, GNUNET_MESSENGER_MessageMerge::previous, put_store_message(), GNUNET_MESSENGER_SrvRoom::state, and update_message_state().

Referenced by handle_tunnel_message(), it_handle_epoch_message_delayed(), and send_srv_room_message().

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

◆ callback_room_handle_message()

void callback_room_handle_message ( struct GNUNET_MESSENGER_SrvRoom room,
const struct GNUNET_MESSENGER_Message message,
const struct GNUNET_HashCode hash 
)

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

1427{
1428 struct GNUNET_MESSENGER_PeerStore *peer_store;
1429 struct GNUNET_MESSENGER_MemberStore *member_store;
1430 struct GNUNET_MESSENGER_SenderSession session;
1431 enum GNUNET_GenericReturnValue start_handle;
1432
1433 GNUNET_assert ((room) && (message) && (hash));
1434
1435 peer_store = get_srv_room_peer_store (room);
1436 member_store = get_srv_room_member_store (room);
1437
1438 if (GNUNET_YES == is_peer_message (message))
1439 {
1440 session.peer = get_store_peer_of (peer_store, message, hash);
1441
1442 if (! session.peer)
1443 {
1445 "Message handling dropped: Peer is missing!\n");
1446 return;
1447 }
1448 }
1449 else
1450 {
1451 struct GNUNET_MESSENGER_Member *member;
1452 member = get_store_member_of (member_store, message);
1453
1454 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Callback for message (%s)\n",
1455 GNUNET_h2s (hash));
1456
1457 if (! member)
1458 {
1460 "Message handling dropped: Member is missing!\n");
1461 return;
1462 }
1463
1464 session.member = get_member_session_of (member, message, hash);
1465
1466 if (! session.member)
1467 {
1469 "Message handling dropped: Session is missing!\n");
1470 return;
1471 }
1472 }
1473
1474 {
1475 struct GNUNET_MESSENGER_MemberUpdate update;
1476 update.message = message;
1477 update.hash = hash;
1478
1479 update.head = NULL;
1480 update.tail = NULL;
1481
1483 member_store,
1485 &update);
1486
1487 while (update.head)
1488 {
1489 struct GNUNET_MESSENGER_MemberSessionCompletion *element = update.head;
1490
1491 remove_room_member_session (room, element->session);
1492
1493 GNUNET_CONTAINER_DLL_remove (update.head, update.tail, element);
1495 "Remove member session completion from queue!\n");
1496
1497 GNUNET_free (element);
1498 }
1499 }
1500
1501 start_handle = room->handling.head ? GNUNET_NO : GNUNET_YES;
1502
1503 add_to_list_messages (&(room->handling), hash);
1504
1505 switch (message->header.kind)
1506 {
1508 handle_message_join (room, &session, message, hash);
1509 break;
1511 handle_message_leave (room, &session, message, hash);
1512 break;
1514 handle_message_key (room, &session, message, hash);
1515 break;
1517 handle_message_peer (room, &session, message, hash);
1518 break;
1520 handle_message_id (room, &session, message, hash);
1521 break;
1523 handle_message_miss (room, &session, message, hash);
1524 break;
1526 handle_message_delete (room, &session, message, hash);
1527 break;
1529 handle_message_connection (room, &session, message, hash);
1530 break;
1532 handle_message_subscribe (room, &session, message, hash);
1533 break;
1534 default:
1535 break;
1536 }
1537
1538 if (GNUNET_YES == start_handle)
1539 handle_room_messages (room);
1540}
void add_to_list_messages(struct GNUNET_MESSENGER_ListMessages *messages, const struct GNUNET_HashCode *hash)
Adds a specific hash from a message to the end of the list.
int iterate_store_members(struct GNUNET_MESSENGER_MemberStore *store, GNUNET_MESSENGER_MemberIteratorCallback it, void *cls)
Iterate through all member sessions currently connected to the members of the given member store and ...
void handle_message_id(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SenderSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a received or sent id message to change a members id.
void handle_message_delete(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SenderSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a received or sent delete message to delete a specific message from the store.
void handle_message_peer(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SenderSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a received or sent peer message to make changes of the basement in the room.
void handle_message_join(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SenderSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a received or sent join message to make changes of current member information.
void handle_message_key(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SenderSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a received or sent key message to change the key of a member and rearrange the contacts accor...
void handle_message_leave(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SenderSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a received or sent leave message to make changes of current member information.
void handle_message_subscribe(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SenderSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a received or sent subscribe message to subscribe a member to a discourse.
void handle_message_connection(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SenderSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a received or sent connection message to update connection information about a peer.
void handle_message_miss(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SenderSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a received or sent miss message to drop a peer from the basement in the room.
static void remove_room_member_session(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_MemberSession *session)
static enum GNUNET_GenericReturnValue iterate_update_member_sessions(void *cls, const struct GNUNET_CRYPTO_PublicKey *public_key, struct GNUNET_MESSENGER_MemberSession *session)
@ GNUNET_MESSENGER_KIND_MISS
The miss kind.
@ GNUNET_MESSENGER_KIND_LEAVE
The leave 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_SUBSCRIBTION
The subscribtion kind.
@ GNUNET_MESSENGER_KIND_DELETION
The deletion kind.
@ GNUNET_MESSENGER_KIND_CONNECTION
The connection kind.
@ GNUNET_MESSENGER_KIND_ID
The id kind.
struct GNUNET_MESSENGER_MemberSession * session
const struct GNUNET_MESSENGER_Message * message

References add_to_list_messages(), get_member_session_of(), get_srv_room_member_store(), get_srv_room_peer_store(), get_store_member_of(), get_store_peer_of(), GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_MESSENGER_KIND_CONNECTION, GNUNET_MESSENGER_KIND_DELETION, GNUNET_MESSENGER_KIND_ID, GNUNET_MESSENGER_KIND_JOIN, GNUNET_MESSENGER_KIND_KEY, GNUNET_MESSENGER_KIND_LEAVE, GNUNET_MESSENGER_KIND_MISS, GNUNET_MESSENGER_KIND_PEER, GNUNET_MESSENGER_KIND_SUBSCRIBTION, GNUNET_NO, GNUNET_YES, handle_message_connection(), handle_message_delete(), handle_message_id(), handle_message_join(), handle_message_key(), handle_message_leave(), handle_message_miss(), handle_message_peer(), handle_message_subscribe(), handle_room_messages(), GNUNET_MESSENGER_SrvRoom::handling, GNUNET_MESSENGER_MemberUpdate::hash, GNUNET_MESSENGER_ListMessages::head, GNUNET_MESSENGER_MemberUpdate::head, GNUNET_MESSENGER_Message::header, is_peer_message(), iterate_store_members(), iterate_update_member_sessions(), GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_SenderSession::member, GNUNET_MESSENGER_MemberUpdate::message, GNUNET_MESSENGER_SenderSession::peer, remove_room_member_session(), GNUNET_MESSENGER_MemberSessionCompletion::session, and GNUNET_MESSENGER_MemberUpdate::tail.

Referenced by handle_tunnel_message(), and send_srv_room_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 660 of file gnunet-service-messenger_room.c.

663{
664 struct GNUNET_HashCode hash;
665
666 GNUNET_assert ((room) && (handle));
667
668 if (! message)
669 return GNUNET_NO;
670
672 "Sending message from handle in room: %s (%s)\n",
673 GNUNET_h2s (&(room->key)),
675
676 {
678
679 closure.room = room;
680 closure.handle = handle;
681 closure.exclude = NULL;
682 closure.message = message;
683 closure.hash = &hash;
684 closure.packed = GNUNET_NO;
685
687 iterate_send_room_message, &closure);
688
689 if (GNUNET_NO == closure.packed)
692 }
693
694 {
695 enum GNUNET_GenericReturnValue new_message;
696 new_message = update_room_message (room, message, &hash);
697
698 if (GNUNET_YES != new_message)
699 {
701 "Sending duplicate message failed!\n");
702 return GNUNET_SYSERR;
703 }
704 }
705
706 switch (message->header.kind)
707 {
710 break;
713 break;
716 break;
719 break;
722 break;
723 default:
724 break;
725 }
726
728 return GNUNET_YES;
729}
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)
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)
const char * GNUNET_MESSENGER_name_of_kind(enum GNUNET_MESSENGER_MessageKind kind)
Get the name of a message kind.
Definition: messenger_api.c:46
@ GNUNET_MESSENGER_PACK_MODE_UNKNOWN

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_operation(), callback_tunnel_disconnect(), 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 733 of file gnunet-service-messenger_room.c.

737{
739 struct GNUNET_HashCode message_hash;
740
741 GNUNET_assert ((room) && (tunnel));
742
743 if (! message)
744 return;
745
746 GNUNET_memcpy (&message_hash, hash, sizeof(struct GNUNET_HashCode));
747
748 closure.room = room;
749 closure.handle = NULL;
750 closure.exclude = tunnel;
751 closure.message = message;
752 closure.hash = &message_hash;
753 closure.packed = GNUNET_YES;
754
756 iterate_send_room_message, &closure);
757}

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 761 of file gnunet-service-messenger_room.c.

763{
764 struct GNUNET_MESSENGER_MessageStore *message_store;
765 const struct GNUNET_MESSENGER_Message *message;
766
767 if (! room->peer_message)
768 return;
769
770 message_store = get_srv_room_message_store (room);
771 message = get_store_message (message_store, room->peer_message);
772
773 if (! message)
774 {
776 room->peer_message = NULL;
777 return;
778 }
779
780 if (tunnel)
781 forward_tunnel_message (tunnel, message, room->peer_message);
782}
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 786 of file gnunet-service-messenger_room.c.

788{
789 const struct GNUNET_HashCode *hash;
790
791 GNUNET_assert (room);
792
793 if (! handle)
794 return;
795
797 "Merging messages by handle in room: %s\n",
798 GNUNET_h2s (&(room->key)));
799
800 do
801 {
802 struct GNUNET_MESSENGER_Message *message;
803
804 hash = get_message_state_merge_hash (&(room->state));
805
806 if ((! hash) || (GNUNET_is_zero (hash)))
807 break;
808
809 message = create_message_merge (hash);
810
811 if (! message)
812 {
814 "Merging messages failed: %s\n",
815 GNUNET_h2s (&(room->key)));
816 }
817
818 send_srv_room_message (room, handle, message);
819 }
820 while (hash);
821}
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...

References create_message_merge(), get_message_state_merge_hash(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_h2s(), GNUNET_is_zero, 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 825 of file gnunet-service-messenger_room.c.

829{
830 const struct GNUNET_MESSENGER_Message *message;
831 struct GNUNET_TIME_Relative forever;
832
833 GNUNET_assert ((room) && (session) && (hash));
834
836
837 if (0 == GNUNET_memcmp (&forever, &delay))
838 {
840 "Deletion is delayed forever: operation is impossible!\n");
841 return GNUNET_SYSERR;
842 }
843
844 {
845 struct GNUNET_MESSENGER_MessageStore *message_store;
846
847 message_store = get_srv_room_message_store (room);
848 message = get_store_message (message_store, hash);
849 }
850
851 if (! message)
852 return GNUNET_YES;
853
854 if (GNUNET_YES != check_member_session_history (session, hash, GNUNET_YES))
855 {
857 "Unpermitted request for deletion by member (%s) of message (%s)!\n",
859 hash));
860
861 return GNUNET_NO;
862 }
863
864 {
865 struct GNUNET_MESSENGER_OperationStore *operation_store;
866
867 operation_store = get_srv_room_operation_store (room);
868
869 if (GNUNET_OK != use_store_operation (operation_store, hash,
871 {
873 "Deletion has failed: operation denied!\n");
874 return GNUNET_SYSERR;
875 }
876 }
877
878 return GNUNET_YES;
879}
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...
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_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 883 of file gnunet-service-messenger_room.c.

884{
885 GNUNET_assert (room);
886
887 return room->service->cadet;
888}
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 892 of file gnunet-service-messenger_room.c.

893{
894 GNUNET_assert (room);
895
896 return &(room->key);
897}

References GNUNET_assert, and GNUNET_MESSENGER_SrvRoom::key.

Referenced by callback_room_connect(), callback_tunnel_disconnect(), 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(), handle_room_messages(), handle_service_message(), 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 901 of file gnunet-service-messenger_room.c.

903{
904 GNUNET_assert ((room) && (peer));
905
906 return GNUNET_CONTAINER_multipeermap_get (room->tunnels, peer);
907}

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_room_message_step()

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 
)
static

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

916{
917 struct GNUNET_MESSENGER_MessageStore *message_store;
918 const struct GNUNET_MESSENGER_MessageLink *link;
919 const struct GNUNET_MESSENGER_Message *message;
920
921 GNUNET_assert ((room) && (hash) && (session));
922
923 message_store = get_srv_room_message_store (room);
924 link = get_store_message_link (message_store, hash, GNUNET_YES);
925
926 if (! link)
927 goto forward;
928
930 "Requesting link of message with hash: %s\n",
931 GNUNET_h2s (hash));
932
933 {
935 result = request_room_message_step (room, &(link->first), session,
936 callback, cls);
937
938 if ((GNUNET_YES == link->multiple) &&
939 (GNUNET_YES == request_room_message_step (room, &(link->second),
940 session, callback, cls)))
941 return GNUNET_YES;
942 else
943 return result;
944 }
945
946forward:
947 message = get_store_message (message_store, hash);
948
949 if (! message)
950 {
952 "Requested message is missing in local storage: %s\n",
953 GNUNET_h2s (hash));
954 return GNUNET_NO;
955 }
956
957 if (GNUNET_YES == is_epoch_message (message))
958 goto skip_member_session;
959
960 if (GNUNET_YES != check_member_session_history (session, hash, GNUNET_NO))
961 {
963 "Unpermitted request for access by member (%s) of message (%s)!\n",
965 GNUNET_h2s (hash));
966 return GNUNET_YES;
967 }
968
969skip_member_session:
970 if (callback)
971 callback (cls, room, message, hash);
972
973 return GNUNET_YES;
974}
static int forward
Search direction: forward.
Definition: gnunet-abd.c:163
static int result
Global testing status.
const struct GNUNET_MESSENGER_MessageLink * get_store_message_link(struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash, enum GNUNET_GenericReturnValue deleted_only)
Returns the message link from a message store matching a given hash.
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 check_member_session_history(), GNUNET_MESSENGER_MessageLink::first, forward, get_member_session_id(), get_srv_room_message_store(), get_store_message(), get_store_message_link(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_h2s(), GNUNET_log, GNUNET_NO, GNUNET_sh2s(), GNUNET_YES, is_epoch_message(), GNUNET_MESSENGER_MessageLink::multiple, request_room_message_step(), result, and GNUNET_MESSENGER_MessageLink::second.

Referenced by request_room_message_step(), and request_srv_room_message().

Here is the call graph for this function:
Here is the caller 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 978 of file gnunet-service-messenger_room.c.

983{
985
986 GNUNET_assert ((room) && (hash));
987
988 result = request_room_message_step (room, hash, session, callback, cls);
989
990 if ((GNUNET_NO == result) && (callback))
991 callback (cls, room, NULL, hash);
992
993 return result;
994}

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 1030 of file gnunet-service-messenger_room.c.

1035{
1036 struct GNUNET_MESSENGER_MemberStore *member_store;
1037 struct GNUNET_MESSENGER_Member *member;
1038 struct GNUNET_MESSENGER_ListHandles *handles;
1039 struct GNUNET_MESSENGER_ListHandle *element;
1040
1041 GNUNET_assert ((room) && (public_key) && (member_id));
1042
1043 member_store = get_srv_room_member_store (room);
1044 member = get_store_member (member_store, member_id);
1045
1046 if ((! member) || (1 >= GNUNET_CONTAINER_multihashmap_size (
1047 member->sessions)))
1048 return;
1049
1050 handles = &(room->service->handles);
1051
1052 for (element = handles->head; element; element = element->next)
1053 {
1054 const struct GNUNET_CRYPTO_PublicKey *pubkey;
1055 struct GNUNET_MESSENGER_MemberSession *session;
1056
1057 if (0 != GNUNET_memcmp (member_id, get_srv_handle_member_id (
1058 element->handle, get_srv_room_key (room))))
1059 continue;
1060
1061 pubkey = get_srv_handle_key (element->handle);
1062
1063 if (0 == GNUNET_memcmp (public_key, pubkey))
1064 continue;
1065
1066 session = get_member_session (member, pubkey);
1067
1068 if (! session)
1069 continue;
1070
1071 {
1073 start = get_member_session_start (session);
1074
1075 if (GNUNET_TIME_relative_get_zero_ ().rel_value_us !=
1077 continue;
1078 }
1079
1080 {
1081 struct GNUNET_ShortHashCode random_id;
1082 generate_free_member_id (&random_id, member_store->members);
1083
1085 element->handle,
1086 room,
1087 &random_id,
1088 GNUNET_NO);
1089 }
1090 }
1091}
static int start
Set if we are to start default services (including ARM).
Definition: gnunet-arm.c:38
static uint64_t timestamp(void)
Get current timestamp.
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_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:423
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_MemberSession::public_key, GNUNET_MESSENGER_SrvRoom::service, GNUNET_MESSENGER_Member::sessions, start, and timestamp().

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 1095 of file gnunet-service-messenger_room.c.

1096{
1097 struct GNUNET_MESSENGER_ListTunnel *element;
1098 struct GNUNET_PeerIdentity peer;
1099 size_t count;
1100 size_t src;
1101 size_t dst;
1102
1103 GNUNET_assert (room);
1104
1105 if (GNUNET_OK != get_service_peer_identity (room->service, &peer))
1106 return;
1107
1108 count = count_of_tunnels (&(room->basement));
1109
1110 if (! find_list_tunnels (&(room->basement), &peer, &src))
1111 return;
1112
1113 if ((count > room->service->min_routers) &&
1114 (GNUNET_NO == is_srv_handle_routing (room->host, &(room->key))) &&
1116 &peer,
1118 {
1119 close_srv_room (room);
1120 return;
1121 }
1122
1123 element = room->basement.head;
1124 dst = 0;
1125
1126 while (element)
1127 {
1128 struct GNUNET_MESSENGER_SrvTunnel *tunnel;
1129
1130 GNUNET_PEER_resolve (element->peer, &peer);
1131
1133
1134 if (! tunnel)
1135 {
1136 element = remove_from_list_tunnels (&(room->basement), element);
1137 continue;
1138 }
1139
1140 if (GNUNET_YES == required_connection_between (count, src, dst))
1141 {
1142 if (GNUNET_SYSERR == connect_tunnel (tunnel))
1143 {
1144 element = remove_from_list_tunnels (&(room->basement), element);
1145 continue;
1146 }
1147 }
1148 else
1149 disconnect_tunnel (tunnel);
1150
1151 element = element->next;
1152 dst++;
1153 }
1154}
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...
@ 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 1158 of file gnunet-service-messenger_room.c.

1159{
1160 GNUNET_assert (room);
1161
1163}
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 1167 of file gnunet-service-messenger_room.c.

1168{
1169 uint32_t flags;
1170
1171 GNUNET_assert (room);
1172
1174
1175 if (GNUNET_YES == room->service->auto_routing)
1177
1178 return flags;
1179}
@ 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:

◆ iterate_member_for_subscription()

static enum GNUNET_GenericReturnValue iterate_member_for_subscription ( void *  cls,
const struct GNUNET_CRYPTO_PublicKey public_key,
struct GNUNET_MESSENGER_MemberSession session 
)
static

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

1324{
1326 struct GNUNET_MESSENGER_Member *member;
1327 struct GNUNET_MESSENGER_Subscription *subscription;
1328
1329 GNUNET_assert ((cls) && (session));
1330
1331 it = cls;
1332 member = session->member;
1333
1334 subscription = get_member_subscription (member, it->discourse);
1335 if (! subscription)
1336 return GNUNET_YES;
1337
1338 if (GNUNET_TIME_absolute_cmp (subscription->start, <, it->start))
1339 it->start = subscription->start;
1340
1341 return GNUNET_YES;
1342}
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.
#define GNUNET_TIME_absolute_cmp(t1, op, t2)
Compare two absolute times.

References GNUNET_MESSENGER_MemberSubscriptionIteration::discourse, get_member_subscription(), GNUNET_assert, GNUNET_TIME_absolute_cmp, GNUNET_YES, GNUNET_MESSENGER_MemberSession::member, GNUNET_MESSENGER_Subscription::member, GNUNET_MESSENGER_MemberSubscriptionIteration::start, and GNUNET_MESSENGER_Subscription::start.

Referenced by cleanup_srv_room_discourse_messages().

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

◆ cleanup_srv_room_discourse_messages()

void cleanup_srv_room_discourse_messages ( struct GNUNET_MESSENGER_SrvRoom room,
const struct GNUNET_ShortHashCode discourse 
)

Cleanup discourse messages outside of current subscriptions from a specific discourse of all the members in a given room.

Parameters
[in,out]roomRoom
[in]discourseHash of discourse

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

1349{
1351 struct GNUNET_MESSENGER_MemberStore *member_store;
1352 struct GNUNET_MESSENGER_MessageStore *message_store;
1353
1354 GNUNET_assert ((room) && (discourse));
1355
1356 it.discourse = discourse;
1358
1359 member_store = get_srv_room_member_store (room);
1360
1362
1363 message_store = get_srv_room_message_store (room);
1364
1366 discourse,
1367 it.start);
1368}
void cleanup_store_discourse_messages_before(struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_ShortHashCode *discourse, const struct GNUNET_TIME_Absolute timestamp)
Cleans up and deletes all discourse messages existing in the message store memory before a certain ti...
static enum GNUNET_GenericReturnValue iterate_member_for_subscription(void *cls, const struct GNUNET_CRYPTO_PublicKey *public_key, struct GNUNET_MESSENGER_MemberSession *session)
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get_forever_(void)
Return "forever".
Definition: time.c:205

References cleanup_store_discourse_messages_before(), GNUNET_MESSENGER_MemberSubscriptionIteration::discourse, get_srv_room_member_store(), get_srv_room_message_store(), GNUNET_assert, GNUNET_TIME_absolute_get_forever_(), iterate_member_for_subscription(), iterate_store_members(), and GNUNET_MESSENGER_MemberSubscriptionIteration::start.

Referenced by handle_message_subscribe(), and task_subscription_exit().

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

◆ iterate_update_member_sessions()

static enum GNUNET_GenericReturnValue iterate_update_member_sessions ( void *  cls,
const struct GNUNET_CRYPTO_PublicKey public_key,
struct GNUNET_MESSENGER_MemberSession session 
)
static

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

1393{
1394 struct GNUNET_MESSENGER_MemberUpdate *update;
1395
1396 GNUNET_assert ((cls) && (session));
1397
1398 update = cls;
1399
1400 update_member_session_history (session, update->message, update->hash);
1401
1402 if (GNUNET_YES == is_member_session_completed (session))
1403 {
1405
1407 "Add member session completion to queue!\n");
1408
1410 element->session = session;
1411
1412 GNUNET_CONTAINER_DLL_insert_tail (update->head, update->tail, element);
1413 }
1414
1415 return GNUNET_YES;
1416}
void update_member_session_history(struct GNUNET_MESSENGER_MemberSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Adds a given message to the history of a session using the messages hash.
enum GNUNET_GenericReturnValue is_member_session_completed(const struct GNUNET_MESSENGER_MemberSession *session)
Returns if the given member session has been completed.
#define GNUNET_CONTAINER_DLL_insert_tail(head, tail, element)
Insert an element at the tail of a DLL.
struct GNUNET_MESSENGER_MemberSessionCompletion * head
struct GNUNET_MESSENGER_MemberSessionCompletion * tail

References GNUNET_assert, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, GNUNET_YES, GNUNET_MESSENGER_MemberUpdate::hash, GNUNET_MESSENGER_MemberUpdate::head, is_member_session_completed(), GNUNET_MESSENGER_MemberUpdate::message, GNUNET_MESSENGER_MemberSessionCompletion::session, GNUNET_MESSENGER_MemberUpdate::tail, and update_member_session_history().

Referenced by callback_room_handle_message().

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

◆ remove_room_member_session()

static void remove_room_member_session ( struct GNUNET_MESSENGER_SrvRoom room,
struct GNUNET_MESSENGER_MemberSession session 
)
static

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

1646{
1647 struct GNUNET_HashCode hash;
1648 char *session_dir;
1649 char *room_dir;
1650
1651 GNUNET_assert ((room) && (session));
1652
1654 "Remove member session from room: %s (%s)\n",
1656 GNUNET_h2s (get_srv_room_key (room)));
1657
1658 remove_member_session (session->member, session);
1659
1660 {
1661 const struct GNUNET_CRYPTO_PublicKey *public_key;
1662 public_key = get_member_session_public_key (session);
1663
1664 GNUNET_CRYPTO_hash (public_key, sizeof(*public_key), &hash);
1665 }
1666
1667
1668 get_room_data_subdir (room, &room_dir);
1669
1671 &session_dir, "%s%s%c%s%c%s%c%s%c", room_dir,
1672 "members", DIR_SEPARATOR,
1674 "sessions", DIR_SEPARATOR,
1675 GNUNET_h2s (&hash), DIR_SEPARATOR);
1676
1677 GNUNET_free (room_dir);
1678
1679 GNUNET_DISK_directory_remove (session_dir);
1680 GNUNET_free (session_dir);
1681
1682 destroy_member_session (session);
1683}
void remove_member_session(struct GNUNET_MESSENGER_Member *member, struct GNUNET_MESSENGER_MemberSession *session)
Removes a given member session from its member.
void destroy_member_session(struct GNUNET_MESSENGER_MemberSession *session)
Destroys a member session and frees its memory fully.
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.
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_remove(const char *filename)
Remove all files in a directory (rm -rf).
Definition: disk.c:1098
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

References destroy_member_session(), DIR_SEPARATOR, get_member_session_id(), get_member_session_public_key(), get_room_data_subdir(), get_srv_room_key(), GNUNET_asprintf(), GNUNET_assert, GNUNET_CRYPTO_hash(), GNUNET_DISK_directory_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_sh2s(), GNUNET_MESSENGER_MemberSession::member, and remove_member_session().

Referenced by callback_room_handle_message().

Here is the call graph for this function:
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 1544 of file gnunet-service-messenger_room.c.

1545{
1546 char *room_dir;
1547
1548 GNUNET_assert (room);
1549
1550 get_room_data_subdir (room, &room_dir);
1551
1552 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Load room from directory: %s\n",
1553 room_dir);
1554
1556 {
1557 char *peers_file;
1558 GNUNET_asprintf (&peers_file, "%s%s", room_dir, "peers.list");
1559
1560 load_peer_store (get_srv_room_peer_store (room), peers_file);
1561 GNUNET_free (peers_file);
1562
1567
1568 {
1569 char *basement_file;
1570 GNUNET_asprintf (&basement_file, "%s%s", room_dir, "basement.list");
1571
1572 load_list_tunnels (&(room->basement), basement_file);
1573 GNUNET_free (basement_file);
1574 }
1575
1576 load_message_state (&(room->state), room_dir);
1577 }
1578
1579 GNUNET_free (room_dir);
1580}
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)
Loads messages from its directory into a message store.
void move_message_store(struct GNUNET_MESSENGER_MessageStore *store, const char *directory)
Moves all storage from a message store from its current directory to a given directory.
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.
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_test(const char *fil, int is_readable)
Test if fil is a directory and listable.
Definition: disk.c:454
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(), move_message_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 1584 of file gnunet-service-messenger_room.c.

1585{
1586 char *room_dir;
1587
1588 GNUNET_assert (room);
1589
1590 get_room_data_subdir (room, &room_dir);
1591
1592 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Save room to directory: %s\n",
1593 room_dir);
1594
1595 if ((GNUNET_YES == GNUNET_DISK_directory_test (room_dir, GNUNET_NO)) ||
1597 {
1598 char *peers_file;
1599 GNUNET_asprintf (&peers_file, "%s%s", room_dir, "peers.list");
1600
1601 save_peer_store (get_srv_room_peer_store (room), peers_file);
1602 GNUNET_free (peers_file);
1603
1608
1609 {
1610 char *basement_file;
1611 GNUNET_asprintf (&basement_file, "%s%s", room_dir, "basement.list");
1612
1613 save_list_tunnels (&(room->basement), basement_file);
1614 GNUNET_free (basement_file);
1615 }
1616
1617 save_message_state (&(room->state), room_dir);
1618 }
1619
1620 GNUNET_free (room_dir);
1621}
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)
Saves messages from a message store into its 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:547
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, move_message_store(), 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 1625 of file gnunet-service-messenger_room.c.

1626{
1627 char *room_dir;
1628
1629 GNUNET_assert (room);
1630
1631 get_room_data_subdir (room, &room_dir);
1632
1633 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Remove room from directory: %s\n",
1634 room_dir);
1635
1638
1639 GNUNET_free (room_dir);
1640}

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: