#include "gnunet_common.h"
#include "gnunet_messenger_service.h"
#include "gnunet_pils_service.h"
#include "gnunet_util_lib.h"
#include "messenger_api_message.h"
#include "platform.h"
#include "gnunet-service-messenger_room.h"
#include "gnunet-service-messenger_basement.h"
#include "gnunet-service-messenger_member.h"
#include "gnunet-service-messenger_member_session.h"
#include "gnunet-service-messenger_sender_session.h"
#include "gnunet-service-messenger_message_kind.h"
#include "gnunet-service-messenger_message_handle.h"
#include "gnunet-service-messenger_message_send.h"
#include "gnunet-service-messenger_operation.h"
#include "gnunet-service-messenger_service.h"
#include "gnunet-service-messenger_tunnel.h"
#include "messenger_api_util.h"
#include <stdint.h>
#include <string.h>

Include dependency graph for gnunet-service-messenger_room.c:

Data Structures
struct	GNUNET_MESSENGER_ClosureSendRoom

struct	GNUNET_MESSENGER_MemberSubscriptionIteration

struct	GNUNET_MESSENGER_SrvMemberSessionCompletion

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_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.

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

static enum GNUNET_GenericReturnValue	iterate_cancel_signature (void cls, const struct GNUNET_HashCode 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.

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.

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_OperationStore *	get_srv_room_operation_store (struct GNUNET_MESSENGER_SrvRoom *room)
	Returns the used operation store of a given room.

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.

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.

static void	callback_srv_room_sign_result (void cls, const struct GNUNET_PeerIdentity identity, const struct GNUNET_CRYPTO_EddsaSignature *peer_signature)

enum GNUNET_GenericReturnValue	sign_srv_room_message (struct GNUNET_MESSENGER_SrvRoom room, struct GNUNET_MESSENGER_Message message, GNUNET_MESSENGER_SignedCallback callback, void *closure)
	Packs a message depending on its kind into a newly allocated envelope.

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 void	callback_srv_room_message_signed (void cls, struct GNUNET_MESSENGER_SrvRoom room, struct GNUNET_MESSENGER_Message message, struct GNUNET_MQ_Envelope envelope, 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.

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

void	send_srv_room_envelope (struct GNUNET_MESSENGER_SrvRoom room, struct GNUNET_MESSENGER_SrvTunnel tunnel, struct GNUNET_MQ_Envelope envelope, const struct GNUNET_HashCode hash)
	Sends an envelope from a message with a given hash excluding a specific tunnel inside of a room.

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.

enum GNUNET_GenericReturnValue	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.

enum GNUNET_GenericReturnValue	delete_srv_room_message (struct GNUNET_MESSENGER_SrvRoom room, struct GNUNET_MESSENGER_SrvMemberSession 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.

struct GNUNET_CADET_Handle *	get_srv_room_cadet (struct GNUNET_MESSENGER_SrvRoom *room)
	Returns the CADET handle from a rooms service.

const struct GNUNET_HashCode *	get_srv_room_key (const struct GNUNET_MESSENGER_SrvRoom *room)
	Returns the shared secret you need to access a room.

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.

static enum GNUNET_GenericReturnValue	request_room_message_step (struct GNUNET_MESSENGER_SrvRoom room, const struct GNUNET_HashCode hash, const struct GNUNET_MESSENGER_SrvMemberSession 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_SrvMemberSession session, GNUNET_MESSENGER_MessageRequestCallback callback, void cls)
	Requests a message from a room identified by a given hash.

void	solve_srv_room_member_collisions (struct GNUNET_MESSENGER_SrvRoom room, const struct GNUNET_CRYPTO_BlindablePublicKey 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).

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.

uint32_t	get_srv_room_amount_of_tunnels (const struct GNUNET_MESSENGER_SrvRoom *room)
	Returns the amount of active tunnels of a given room.

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.

static enum GNUNET_GenericReturnValue	iterate_member_for_subscription (void cls, const struct GNUNET_CRYPTO_BlindablePublicKey public_key, struct GNUNET_MESSENGER_SrvMemberSession *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.

static enum GNUNET_GenericReturnValue	iterate_update_member_sessions (void cls, const struct GNUNET_CRYPTO_BlindablePublicKey public_key, struct GNUNET_MESSENGER_SrvMemberSession *session)

static void	remove_room_member_session (struct GNUNET_MESSENGER_SrvRoom room, struct GNUNET_MESSENGER_SrvMemberSession 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.

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.

void	remove_srv_room (struct GNUNET_MESSENGER_SrvRoom *room)
	Removes the configuration for a given room of a service.

Function Documentation

◆ idle_request_room_messages()

static void idle_request_room_messages ( void * cls )

static

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

{
  struct GNUNET_MESSENGER_SrvRoom *room;
  struct GNUNET_MESSENGER_OperationStore *operation_store;
  const struct GNUNET_HashCode *hash;
 
  GNUNET_assert (cls);
 
  room = cls;
  room->idle = NULL;
 
  operation_store = get_srv_room_operation_store (room);
  hash = get_message_state_merge_hash (&(room->state));
 
  if ((hash) && (! GNUNET_is_zero (hash)) &&
      (GNUNET_MESSENGER_OP_UNKNOWN == get_store_operation_type (operation_store,
                                                                hash)))
    use_store_operation (
      operation_store,
      hash,
      GNUNET_MESSENGER_OP_MERGE,
      GNUNET_MESSENGER_MERGE_DELAY);
 
  room->idle = GNUNET_SCHEDULER_add_delayed_with_priority (
    GNUNET_MESSENGER_IDLE_DELAY,
    GNUNET_SCHEDULER_PRIORITY_IDLE,
    idle_request_room_messages,
    cls);
}

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

{
  GNUNET_assert ((room) && (dir));
 
  if (room->service->dir)
    GNUNET_asprintf (dir, "%s%s%c%s%c", room->service->dir, "rooms",
                     DIR_SEPARATOR, GNUNET_h2s (get_srv_room_key (room)),
                     DIR_SEPARATOR);
  else
    *dir = NULL;
}

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]	handle	Handle
[in]	key	Key of room

Returns: New room

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

{
  struct GNUNET_MESSENGER_SrvRoom *room;
  char *room_dir;
 
  GNUNET_assert ((handle) && (key));
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Create new room: %s\n",
              GNUNET_h2s (key));
 
  room = GNUNET_new (struct GNUNET_MESSENGER_SrvRoom);
 
  room->service = handle->service;
  room->host = handle;
  room->sync = NULL;
  room->port = NULL;
 
  GNUNET_memcpy (&(room->key), key, sizeof(struct GNUNET_HashCode));
 
  room->tunnels = GNUNET_CONTAINER_multipeermap_create (8, GNUNET_NO);
 
  get_room_data_subdir (room, &room_dir);
 
  room->signatures = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_YES);
 
  init_peer_store (get_srv_room_peer_store (room), room->service);
  init_member_store (get_srv_room_member_store (room), room);
  init_message_store (get_srv_room_message_store (room), room_dir);
  init_operation_store (get_srv_room_operation_store (room), room);
 
  GNUNET_free (room_dir);
 
  init_list_tunnels (&(room->basement));
  init_message_state (&(room->state));
 
  room->peer_message = NULL;
 
  init_list_messages (&(room->handling));
  room->idle = NULL;
 
  if (room->service->dir)
    load_srv_room (room);
 
  room->idle = GNUNET_SCHEDULER_add_with_priority (
    GNUNET_SCHEDULER_PRIORITY_IDLE, idle_request_room_messages, room);
 
  return room;
}

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

{
  struct GNUNET_MESSENGER_SrvTunnel *tunnel;
 
  GNUNET_assert (value);
 
  tunnel = value;
 
  destroy_tunnel (tunnel);
  return 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:

◆ iterate_cancel_signature()

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

static

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

{
  struct GNUNET_MESSENGER_SrvRoomSignature *signature;
 
  GNUNET_assert (value);
 
  signature = value;
 
  if (signature->operation)
    GNUNET_PILS_cancel (signature->operation);
 
  if (signature->message)
    destroy_message (signature->message);
 
  if (signature->envelope)
    GNUNET_free (signature->envelope);
 
  GNUNET_free (signature);
  return GNUNET_YES;
}

References destroy_message(), GNUNET_MESSENGER_SrvRoomSignature::envelope, GNUNET_assert, GNUNET_free, GNUNET_PILS_cancel(), GNUNET_YES, GNUNET_MESSENGER_SrvRoomSignature::message, GNUNET_MESSENGER_SrvRoomSignature::operation, and value.

Referenced by destroy_srv_room(), and sign_srv_room_message().

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

{
  struct GNUNET_PeerIdentity peer;
 
  GNUNET_assert (room);
 
  if (! room->port)
    return;
 
  if ((room->peer_message) &&
      (GNUNET_OK == get_service_peer_identity (room->service, &peer)))
  {
    struct GNUNET_MESSENGER_Message *message;
 
    message = create_message_miss (&peer);
 
    if (! message)
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Sending miss message about peer failed: %s\n",
                  GNUNET_h2s (&(room->key)));
    else
      send_srv_room_message (room, room->host, message);
  }
 
  GNUNET_CADET_close_port (room->port);
  room->port = NULL;
}

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

{
  struct GNUNET_MESSENGER_MessageStore *message_store;
  struct GNUNET_MESSENGER_MemberStore *member_store;
  struct GNUNET_MESSENGER_PeerStore *peer_store;
  const struct GNUNET_HashCode *key;
 
  message_store = get_srv_room_message_store (room);
  member_store = get_srv_room_member_store (room);
  peer_store = get_srv_room_peer_store (room);
 
  key = get_srv_room_key (room);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Handling room messages: %s\n", GNUNET_h2s (key));
 
  while (room->handling.head)
  {
    struct GNUNET_MESSENGER_ListMessage *element;
    struct GNUNET_MESSENGER_SenderSession session;
    const struct GNUNET_MESSENGER_Message *message;
    const struct GNUNET_HashCode *epoch;
 
    element = room->handling.head;
    message = get_store_message (
      message_store, &(element->hash));
 
    if (! message)
      goto finish_handling;
 
    if (GNUNET_YES == is_peer_message (message))
    {
      session.peer = get_store_peer_of (peer_store, message, &(element->hash));
 
      if (! session.peer)
        goto finish_handling;
    }
    else
    {
      struct GNUNET_MESSENGER_Member *member;
 
      member = get_store_member_of (member_store, message);
 
      if (! member)
        goto finish_handling;
 
      session.member = get_member_session_of (member, message,
                                              &(element->hash));
 
      if (! session.member)
        goto finish_handling;
    }
 
    epoch = get_store_message_epoch (message_store, &(element->hash));
 
    handle_service_message (room->service, room, &session, message,
                            &(element->hash), epoch, GNUNET_YES);
 
finish_handling:
    GNUNET_CONTAINER_DLL_remove (room->handling.head, room->handling.tail,
                                 element);
    GNUNET_free (element);
  }
}

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]	room	Room
[in]	deletion	Flag to indicate context of destruction

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

{
  GNUNET_assert (room);
 
  if (room->idle)
  {
    GNUNET_SCHEDULER_cancel (room->idle);
    room->idle = NULL;
  }
 
  close_srv_room (room);
 
  GNUNET_CONTAINER_multipeermap_iterate (room->tunnels, iterate_destroy_tunnels,
                                         NULL);
  handle_room_messages (room);
 
  if (! (room->service->dir))
    goto skip_saving;
 
  if (GNUNET_YES == deletion)
    remove_srv_room (room);
  else
    save_srv_room (room);
 
skip_saving:
  clear_peer_store (get_srv_room_peer_store (room));
  clear_member_store (get_srv_room_member_store (room));
  clear_message_store (get_srv_room_message_store (room));
  clear_operation_store (get_srv_room_operation_store (room));
 
  GNUNET_CONTAINER_multihashmap_iterate (room->signatures,
                                         &iterate_cancel_signature,
                                         room);
  GNUNET_CONTAINER_multihashmap_destroy (room->signatures);
 
  GNUNET_CONTAINER_multipeermap_destroy (room->tunnels);
  clear_list_tunnels (&(room->basement));
  clear_message_state (&(room->state));
 
  if (room->peer_message)
    GNUNET_free (room->peer_message);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Free room: %s\n",
              GNUNET_h2s (&(room->key)));
 
  GNUNET_free (room);
}

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] room Room

Returns: Peer store

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

{
  GNUNET_assert (room);
 
  return &(room->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] room Room

Returns: Member store

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

{
  GNUNET_assert (room);
 
  return &(room->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 )

Returns the used message store of a given room.

Parameters

[in,out] room Room

Returns: Message store

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

{
  GNUNET_assert (room);
 
  return &(room->message_store);
}

References GNUNET_assert, and GNUNET_MESSENGER_SrvRoom::message_store.

Referenced by callback_found_message(), callback_operation(), check_member_session_completion(), check_srv_room_peer_status(), cleanup_srv_room_discourse_messages(), create_srv_room(), delete_srv_room_message(), destroy_srv_room(), forward_about_members(), handle_room_messages(), iterate_epoch_session_members(), iterate_srv_handle_sync_finished(), load_srv_room(), notify_about_members(), recv_message_info(), request_room_message_step(), save_srv_room(), sign_srv_room_message(), traverse_epoch_message(), update_room_message(), update_tunnel_last_message(), and verify_tunnel_message().

Here is the caller graph for this function:

◆ get_srv_room_operation_store()

struct GNUNET_MESSENGER_OperationStore * get_srv_room_operation_store ( struct GNUNET_MESSENGER_SrvRoom * room )

Returns the used operation store of a given room.

Parameters

[in,out] room Room

Returns: Operation store

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

{
  GNUNET_assert (room);
 
  return &(room->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 254 of file gnunet-service-messenger_room.c.

{
  if ((! handle) || (! is_tunnel_connected (tunnel)))
    return GNUNET_NO;
 
  return send_tunnel_message (tunnel, handle, create_message_info (
                                room->service));
}

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

{
  struct GNUNET_MESSENGER_SrvRoom *room;
  struct GNUNET_MESSENGER_SrvTunnel *tunnel;
 
  GNUNET_assert ((cls) && (channel) && (source));
 
  room = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "New incoming connection to room (%s) from peer: %s\n",
              GNUNET_h2s (get_srv_room_key (room)), GNUNET_i2s (source));
 
  tunnel = create_tunnel (room, source);
 
  if ((tunnel) &&
      (GNUNET_OK != GNUNET_CONTAINER_multipeermap_put (room->tunnels, source,
                                                       tunnel,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE)))
  {
    destroy_tunnel (tunnel);
    tunnel = NULL;
  }
 
  if (! tunnel)
  {
    delayed_disconnect_channel (channel);
    return NULL;
  }
 
  bind_tunnel (tunnel, channel);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "New tunnel in room (%s) established to peer: %s\n",
              GNUNET_h2s (get_srv_room_key (room)), GNUNET_i2s (source));
 
  if (GNUNET_YES == send_room_info (room, room->host, tunnel))
    return tunnel;
 
  disconnect_tunnel (tunnel);
 
  if (GNUNET_YES == GNUNET_CONTAINER_multipeermap_remove (room->tunnels, source,
                                                          tunnel))
    destroy_tunnel (tunnel);
 
  return NULL;
}

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

{
  const struct GNUNET_ShortHashCode *member_id;
 
  GNUNET_assert ((room) && (handle) && (member));
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Joining room: %s (%s)\n", GNUNET_h2s (
                get_srv_room_key (room)),
              GNUNET_sh2s (get_member_id (member)));
 
  member_id = get_member_id (member);
 
  if (GNUNET_OK != change_srv_handle_member_id (handle, get_srv_room_key (room),
                                                member_id))
    return GNUNET_NO;
 
  {
    enum GNUNET_GenericReturnValue reset;
    if ((! id) || (0 != GNUNET_memcmp (id, member_id)))
      reset = GNUNET_YES;
    else
      reset = GNUNET_NO;
 
    notify_srv_handle_member_id (handle, room, member_id, reset);
  }
 
  return GNUNET_YES;
}

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

{
  struct GNUNET_MESSENGER_MemberStore *member_store;
  const struct GNUNET_ShortHashCode *member_id;
  struct GNUNET_MESSENGER_Member *member;
 
  member_store = get_srv_room_member_store (room);
  member_id = get_srv_handle_member_id (handle, get_srv_room_key (room));
  member = add_store_member (member_store, member_id);
 
  if (GNUNET_NO == join_room (room, handle, member, member_id))
    return GNUNET_NO;
 
  return GNUNET_YES;
}

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]	room	Room
[in,out]	handle	Handle

Returns: GNUNET_YES on success, GNUNET_NO on failure.

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

{
  GNUNET_assert (room);
 
  if (handle)
    room->host = handle;
 
  if (room->port)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Port of room (%s) was already open!\n",
                GNUNET_h2s (get_srv_room_key (room)));
 
    if (! handle)
      return GNUNET_YES;
 
    return join_room_locally (room, handle);
  }
 
  {
    struct GNUNET_CADET_Handle *cadet;
    union GNUNET_MESSENGER_RoomKey key;
    struct GNUNET_HashCode port;
 
    struct GNUNET_MQ_MessageHandler handlers[] = { GNUNET_MQ_hd_var_size (
                                                     tunnel_message,
                                                     GNUNET_MESSAGE_TYPE_CADET_CLI,
                                                     struct
                                                     GNUNET_MessageHeader, NULL)
                                                   ,
                                                   GNUNET_MQ_handler_end () };
 
    cadet = get_srv_room_cadet (room);
 
    GNUNET_memcpy (
      &(key.hash),
      get_srv_room_key (room),
      sizeof (key.hash));
 
    if ((key.code.feed_bit) && (! key.code.group_bit))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Opening port of personal room containing private feeds failed!");
      return GNUNET_SYSERR;
    }
 
    convert_messenger_key_to_port (&key, &port);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Trying to open CADET port: %s\n",
                GNUNET_h2s (&port));
 
    room->port = GNUNET_CADET_open_port (cadet, &port, callback_room_connect,
                                         room, NULL, callback_tunnel_disconnect,
                                         handlers);
  }
 
  if (room->port)
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Port of room (%s) was opened!\n",
                GNUNET_h2s (get_srv_room_key (room)));
  else
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Port of room (%s) could not be opened!\n",
                GNUNET_h2s (get_srv_room_key (room)));
 
  if (! handle)
    goto complete_opening;
 
  {
    struct GNUNET_MESSENGER_MemberStore *member_store;
    const struct GNUNET_ShortHashCode *member_id;
    struct GNUNET_MESSENGER_Member *member;
 
    member_store = get_srv_room_member_store (room);
    member_id = get_srv_handle_member_id (handle, get_srv_room_key (room));
    member = add_store_member (member_store, member_id);
 
    if ((GNUNET_NO == join_room (room, handle, member, member_id)) &&
        (room->port))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "You could not join the room, therefore it keeps closed!\n");
 
      close_srv_room (room);
      return GNUNET_NO;
    }
  }
 
complete_opening:
  if (! room->port)
    return GNUNET_NO;
 
  {
    struct GNUNET_MESSENGER_Message *message;
    message = create_message_peer (room->service);
 
    if (! message)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Peer message could not be sent!\n");
      return GNUNET_NO;
    }
 
    return send_srv_room_message (room, handle, message);
  }
}

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]	room	Room
[in,out]	handle	Handle
[in]	door	Peer identity

Returns: GNUNET_YES on success, GNUNET_NO on failure.

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

{
  struct GNUNET_PeerIdentity peer;
  struct GNUNET_MESSENGER_SrvTunnel *tunnel;
 
  GNUNET_assert ((room) && (handle) && (door));
 
  if ((GNUNET_OK == get_service_peer_identity (room->service, &peer)) &&
      (0 == GNUNET_memcmp (&peer, door)))
    return join_room_locally (room, handle);
 
  tunnel = GNUNET_CONTAINER_multipeermap_get (room->tunnels, door);
 
  if (! tunnel)
  {
    tunnel = create_tunnel (room, door);
 
    if (GNUNET_OK != GNUNET_CONTAINER_multipeermap_put (room->tunnels, door,
                                                        tunnel,
                                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "You could not connect to that door!\n");
      destroy_tunnel (tunnel);
      return GNUNET_NO;
    }
  }
 
  if (GNUNET_SYSERR == connect_tunnel (tunnel))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Connection failure during entrance!\n");
    GNUNET_CONTAINER_multipeermap_remove (room->tunnels, door, tunnel);
    destroy_tunnel (tunnel);
    return GNUNET_NO;
  }
 
  return join_room_locally (room, handle);
}

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:

◆ callback_srv_room_sign_result()

static void callback_srv_room_sign_result	(	void *	cls,
		const struct GNUNET_PeerIdentity *	identity,
		const struct GNUNET_CRYPTO_EddsaSignature *	peer_signature
	)

static

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

{
  struct GNUNET_MESSENGER_SrvRoomSignature *signature;
  struct GNUNET_MessageHeader *header;
  uint16_t padded_length;
  char *buffer;
 
  GNUNET_assert ((cls) && (peer_signature));
 
  signature = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Signature operation with peer identity (%s) completed: %s\n",
              GNUNET_i2s (identity),
              GNUNET_h2s (&(signature->hash)));
 
  GNUNET_assert (signature->operation);
  signature->operation = NULL;
 
  GNUNET_assert ((signature->room) && (signature->message) && (signature->
                                                               envelope));
 
  GNUNET_memcpy (&(signature->message->header.signature.eddsa_signature),
                 peer_signature, sizeof (*peer_signature));
 
  header = (struct GNUNET_MessageHeader *) GNUNET_MQ_env_get_msg (signature->
                                                                  envelope);
  padded_length = header->size - sizeof (*header);
  buffer = (char *) &(header[1]);
 
  encode_message_signature (signature->message, padded_length, buffer);
 
  GNUNET_assert (signature->callback);
  signature->callback (signature->closure,
                       signature->room,
                       signature->message,
                       signature->envelope,
                       &(signature->hash));
 
  if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove (signature->room->
                                                          signatures,
                                                          &(signature->hash),
                                                          signature))
  {
    signature->message = NULL;
    signature->envelope = NULL;
 
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Signature operation could not be removed: %s\n",
                GNUNET_h2s (&(signature->hash)));
    return;
  }
 
  GNUNET_free (signature);
}

References GNUNET_MESSENGER_SrvRoomSignature::callback, GNUNET_MESSENGER_SrvRoomSignature::closure, GNUNET_CRYPTO_BlindableKeySignature::eddsa_signature, encode_message_signature(), GNUNET_MESSENGER_SrvRoomSignature::envelope, GNUNET_assert, GNUNET_CONTAINER_multihashmap_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_memcpy, GNUNET_MQ_env_get_msg(), GNUNET_YES, GNUNET_MESSENGER_SrvRoomSignature::hash, GNUNET_MESSENGER_Message::header, identity, GNUNET_MESSENGER_SrvRoomSignature::message, GNUNET_MESSENGER_SrvRoomSignature::operation, GNUNET_MESSENGER_SrvRoomSignature::room, GNUNET_MESSENGER_MessageHeader::signature, and GNUNET_MessageHeader::size.

Referenced by sign_srv_room_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sign_srv_room_message()

enum GNUNET_GenericReturnValue sign_srv_room_message	(	struct GNUNET_MESSENGER_SrvRoom *	room,
		struct GNUNET_MESSENGER_Message *	message,
		GNUNET_MESSENGER_SignedCallback	callback,
		void *	closure
	)

Packs a message depending on its kind 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.

When the message has been signed, the message and the packed envelope are passed into the provided callback which is required.

Parameters

[in,out]	room	Room
[in,out]	message	Message
[in]	callback	Callback of signature
[in,out]	closure	Closure

Returns: GNUNET_YES on success, GNUNET_SYSERR on failure and GNUNET_NO otherwise.

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

{
  struct GNUNET_MESSENGER_SrvRoomSignature *signature;
  struct GNUNET_PeerIdentity identity;
 
  GNUNET_assert ((room) && (message) && (callback));
 
  if (GNUNET_YES != is_peer_message (message))
  {
    struct GNUNET_MQ_Envelope *envelope;
    struct GNUNET_HashCode hash;
 
    envelope = pack_message (message, &hash,
                             GNUNET_MESSENGER_PACK_MODE_ENVELOPE);
 
    if (! envelope)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Packing message into envelope failed: %s\n",
                  GNUNET_MESSENGER_name_of_kind (message->header.kind));
      return GNUNET_SYSERR;
    }
 
    callback (closure, room, message, envelope, &hash);
    return GNUNET_YES;
  }
 
  if (GNUNET_YES == is_epoch_message (message))
    message->header.timestamp = GNUNET_TIME_absolute_hton (
      GNUNET_TIME_absolute_get_zero_ ());
  else
    message->header.timestamp = GNUNET_TIME_absolute_hton (
      GNUNET_TIME_absolute_get ());
 
  if (GNUNET_OK != get_service_peer_identity (room->service, &identity))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Peer identity is missing!\n");
    return GNUNET_SYSERR;
  }
 
  convert_peer_identity_to_id (&identity, &(message->header.sender_id));
  get_message_state_chain_hash (&(room->state), &(message->header.previous));
 
  if (GNUNET_MESSENGER_KIND_MERGE == message->header.kind)
  {
    const struct GNUNET_MESSENGER_MessageStore *store;
    const struct GNUNET_HashCode *epoch;
 
    store = get_srv_room_message_store (room);
    epoch = get_store_message_epoch (store, &(message->header.previous));
 
    if (epoch)
      GNUNET_memcpy (&(message->body.merge.epochs[0]), epoch,
                     sizeof (struct GNUNET_HashCode));
 
    epoch = get_store_message_epoch (store, &(message->body.merge.previous));
 
    if (epoch)
      GNUNET_memcpy (&(message->body.merge.epochs[1]), epoch,
                     sizeof (struct GNUNET_HashCode));
  }
 
  signature = GNUNET_new (struct GNUNET_MESSENGER_SrvRoomSignature);
  GNUNET_assert (signature);
 
  signature->room = room;
  signature->message = message;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Packing message with peer signature: %s\n",
              GNUNET_sh2s (&(signature->message->header.sender_id)));
 
  message->header.signature.type = htonl (GNUNET_PUBLIC_KEY_TYPE_EDDSA);
  signature->envelope = pack_message (signature->message, &(signature->hash),
                                      GNUNET_MESSENGER_PACK_MODE_ENVELOPE);
 
  if (! signature->envelope)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Packing message into envelope failed: %s\n",
                GNUNET_MESSENGER_name_of_kind (signature->message->header.kind))
    ;
    destroy_message (signature->message);
    GNUNET_free (signature);
    return GNUNET_SYSERR;
  }
 
  signature->callback = callback;
  signature->closure = closure;
 
  signature->operation = sign_message_by_peer (signature->message,
                                               &(signature->hash),
                                               room->service->pils,
                                               &callback_srv_room_sign_result,
                                               signature);
 
  if (! signature->operation)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Signing message by peer identity (%s) failed: %s\n",
                GNUNET_i2s (&identity),
                GNUNET_h2s (&(signature->hash)));
 
    destroy_message (signature->message);
    GNUNET_free (signature->envelope);
    GNUNET_free (signature);
    return GNUNET_SYSERR;
  }
 
  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (room->signatures,
                                                      &(signature->hash),
                                                      signature,
                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Signature operation could not be stored: %s\n",
                GNUNET_h2s (&(signature->hash)));
 
    iterate_cancel_signature (NULL, &(signature->hash),
                              signature);
    return GNUNET_SYSERR;
  }
 
  return GNUNET_YES;
}

Referenced by send_srv_room_message(), and send_tunnel_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 1387 of file gnunet-service-messenger_room.c.

{
  struct GNUNET_MESSENGER_OperationStore *operation_store;
  struct GNUNET_MESSENGER_MessageStore *message_store;
  enum GNUNET_GenericReturnValue requested;
 
  GNUNET_assert ((room) && (message) && (hash));
 
  operation_store = get_srv_room_operation_store (room);
 
  requested = (GNUNET_MESSENGER_OP_REQUEST ==
               get_store_operation_type (operation_store, hash)?
               GNUNET_YES : GNUNET_NO);
 
  if (GNUNET_YES == requested)
    cancel_store_operation (operation_store, hash);
 
  message_store = get_srv_room_message_store (room);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Handle a message in room (%s).\n",
              GNUNET_h2s (get_srv_room_key (room)));
 
  if (GNUNET_YES == contains_store_message (message_store, hash))
  {
    destroy_message (message);
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Duplicate message got dropped!\n");
    return GNUNET_NO;
  }
 
  if (GNUNET_OK != put_store_message (message_store, hash, message))
  {
    destroy_message (message);
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Storing message failed!\n");
    return GNUNET_NO;
  }
 
  update_message_state (&(room->state), requested, message, hash);
 
  if ((GNUNET_YES == requested) ||
      (GNUNET_MESSENGER_KIND_INFO == message->header.kind) ||
      (GNUNET_MESSENGER_KIND_REQUEST == message->header.kind))
    return GNUNET_YES;
 
  if ((GNUNET_MESSENGER_KIND_MERGE == message->header.kind) &&
      (GNUNET_MESSENGER_OP_MERGE == get_store_operation_type (operation_store,
                                                              &(message->body.
                                                                merge.previous))
      ))
    cancel_store_operation (operation_store, &(message->body.merge.previous));
 
  if (GNUNET_MESSENGER_OP_MERGE == get_store_operation_type (operation_store,
                                                             &(message->header.
                                                               previous)))
    cancel_store_operation (operation_store, &(message->header.previous));
 
  return GNUNET_YES;
}

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 callback_srv_room_message_signed(), handle_tunnel_message(), and it_handle_epoch_message_delayed().

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

{
  struct GNUNET_MESSENGER_PeerStore *peer_store;
  struct GNUNET_MESSENGER_MemberStore *member_store;
  struct GNUNET_MESSENGER_SenderSession session;
  enum GNUNET_GenericReturnValue start_handle;
 
  GNUNET_assert ((room) && (message) && (hash));
 
  peer_store = get_srv_room_peer_store (room);
  member_store = get_srv_room_member_store (room);
 
  if (GNUNET_YES == is_peer_message (message))
  {
    session.peer = get_store_peer_of (peer_store, message, hash);
 
    if (! session.peer)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Message handling dropped: Peer is missing!\n");
      return;
    }
  }
  else
  {
    struct GNUNET_MESSENGER_Member *member;
    member = get_store_member_of (member_store, message);
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Callback for message (%s)\n",
                GNUNET_h2s (hash));
 
    if (! member)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Message handling dropped: Member is missing!\n");
      return;
    }
 
    session.member = get_member_session_of (member, message, hash);
 
    if (! session.member)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Message handling dropped: Session is missing!\n");
      return;
    }
  }
 
  {
    struct GNUNET_MESSENGER_MemberUpdate update;
    update.message = message;
    update.hash = hash;
 
    update.head = NULL;
    update.tail = NULL;
 
    iterate_store_members (
      member_store,
      iterate_update_member_sessions,
      &update);
 
    while (update.head)
    {
      struct GNUNET_MESSENGER_SrvMemberSessionCompletion *element = update.head;
 
      remove_room_member_session (room, element->session);
 
      GNUNET_CONTAINER_DLL_remove (update.head, update.tail, element);
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Remove member session completion from queue!\n");
 
      GNUNET_free (element);
    }
  }
 
  start_handle = room->handling.head ? GNUNET_NO : GNUNET_YES;
 
  add_to_list_messages (&(room->handling), hash);
 
  switch (message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_JOIN:
    handle_message_join (room, &session, message, hash);
    break;
  case GNUNET_MESSENGER_KIND_LEAVE:
    handle_message_leave (room, &session, message, hash);
    break;
  case GNUNET_MESSENGER_KIND_KEY:
    handle_message_key (room, &session, message, hash);
    break;
  case GNUNET_MESSENGER_KIND_PEER:
    handle_message_peer (room, &session, message, hash);
    break;
  case GNUNET_MESSENGER_KIND_ID:
    handle_message_id (room, &session, message, hash);
    break;
  case GNUNET_MESSENGER_KIND_MISS:
    handle_message_miss (room, &session, message, hash);
    break;
  case GNUNET_MESSENGER_KIND_DELETION:
    handle_message_delete (room, &session, message, hash);
    break;
  case GNUNET_MESSENGER_KIND_CONNECTION:
    handle_message_connection (room, &session, message, hash);
    break;
  case GNUNET_MESSENGER_KIND_SUBSCRIBTION:
    handle_message_subscribe (room, &session, message, hash);
    break;
  default:
    break;
  }
 
  if (GNUNET_YES == start_handle)
    handle_room_messages (room);
}

Referenced by callback_srv_room_message_signed(), and handle_tunnel_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ callback_srv_room_message_signed()

static void callback_srv_room_message_signed	(	void *	cls,
		struct GNUNET_MESSENGER_SrvRoom *	room,
		struct GNUNET_MESSENGER_Message *	message,
		struct GNUNET_MQ_Envelope *	envelope,
		const struct GNUNET_HashCode *	hash
	)

static

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

{
  struct GNUNET_MESSENGER_SrvHandle *handle;
  enum GNUNET_GenericReturnValue new_message;
 
  GNUNET_assert ((cls) && (room) && (message) && (envelope) && (hash));
 
  handle = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending room message: %s\n",
              GNUNET_h2s (hash));
 
  send_srv_room_envelope (room, NULL, envelope, hash);
  new_message = update_room_message (room, message, hash);
 
  if (GNUNET_YES != new_message)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Sending duplicate message failed: %s\n",
                GNUNET_h2s (hash));
    return;
  }
 
  switch (message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_JOIN:
    send_message_join (room, handle, message, hash);
    break;
  case GNUNET_MESSENGER_KIND_KEY:
    send_message_key (room, handle, message, hash);
    break;
  case GNUNET_MESSENGER_KIND_PEER:
    send_message_peer (room, handle, message, hash);
    break;
  case GNUNET_MESSENGER_KIND_ID:
    send_message_id (room, handle, message, hash);
    break;
  case GNUNET_MESSENGER_KIND_REQUEST:
    send_message_request (room, handle, message, hash);
    break;
  default:
    break;
  }
 
  callback_room_handle_message (room, message, hash);
 
  if ((GNUNET_MESSENGER_KIND_MERGE == message->header.kind) &&
      (room->sync == handle) &&
      (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (handle->syncing, &(
                                                               room->key))))
    merge_srv_handle_room_to_sync (handle, room);
}

References callback_room_handle_message(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_contains(), 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_MERGE, GNUNET_MESSENGER_KIND_PEER, GNUNET_MESSENGER_KIND_REQUEST, GNUNET_YES, handle, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_SrvRoom::key, GNUNET_MESSENGER_MessageHeader::kind, merge_srv_handle_room_to_sync(), send_message_id(), send_message_join(), send_message_key(), send_message_peer(), send_message_request(), send_srv_room_envelope(), GNUNET_MESSENGER_SrvRoom::sync, and update_room_message().

Referenced by 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]	room	Room
[in,out]	handle	Handle
[in,out]	message	Message

Returns: GNUNET_YES on success, GNUNET_NO or GNUNET_SYSERR otherwise.

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

{
  GNUNET_assert ((room) && (handle));
 
  if (! message)
    return GNUNET_NO;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending message from handle in room: %s (%s)\n",
              GNUNET_h2s (&(room->key)),
              GNUNET_MESSENGER_name_of_kind (message->header.kind));
 
  return sign_srv_room_message (room, message,
                                &callback_srv_room_message_signed,
                                handle);
}

References callback_srv_room_message_signed(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_MESSENGER_name_of_kind(), GNUNET_NO, handle, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_SrvRoom::key, GNUNET_MESSENGER_MessageHeader::kind, and sign_srv_room_message().

Referenced by callback_operation(), callback_tunnel_disconnect(), close_service_room(), close_srv_room(), iterate_service_miss_rooms(), iterate_service_update_rooms(), 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:

◆ iterate_send_room_envelope()

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

static

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

{
  struct GNUNET_MESSENGER_SrvTunnel *tunnel;
  struct GNUNET_MESSENGER_ClosureSendRoom *closure;
  struct GNUNET_MQ_Envelope *envelope;
 
  GNUNET_assert ((cls) && (value));
 
  closure = cls;
  tunnel = value;
 
  GNUNET_assert ((closure->envelope) && (closure->hash));
 
  if ((! is_tunnel_connected (tunnel)) ||
      (get_tunnel_messenger_version (tunnel) < GNUNET_MESSENGER_VERSION))
    return GNUNET_YES;
 
  if (tunnel == closure->exclude)
    return GNUNET_YES;
 
  envelope = GNUNET_MQ_env_copy (closure->envelope);
 
  if (envelope)
    send_tunnel_envelope (tunnel, envelope, closure->hash);
 
  return GNUNET_YES;
}

References GNUNET_MESSENGER_ClosureSendRoom::envelope, GNUNET_MESSENGER_ClosureSendRoom::exclude, get_tunnel_messenger_version(), GNUNET_assert, GNUNET_MESSENGER_VERSION, GNUNET_MQ_env_copy(), GNUNET_YES, GNUNET_MESSENGER_ClosureSendRoom::hash, is_tunnel_connected(), send_tunnel_envelope(), and value.

Referenced by send_srv_room_envelope().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_srv_room_envelope()

void send_srv_room_envelope	(	struct GNUNET_MESSENGER_SrvRoom *	room,
		struct GNUNET_MESSENGER_SrvTunnel *	tunnel,
		struct GNUNET_MQ_Envelope *	envelope,
		const struct GNUNET_HashCode *	hash
	)

Sends an envelope from a message with a given hash excluding a specific tunnel inside of a room.

The function will send copies from the given envelope and frees the original afterwards.

Parameters

[in,out]	room	Room
[in,out]	tunnel	Tunnel
[in,out]	message	Message
[in]	hash	Hash of message

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

{
  struct GNUNET_MESSENGER_ClosureSendRoom closure;
 
  GNUNET_assert ((room) && (envelope));
 
  closure.exclude = tunnel;
  closure.envelope = envelope;
  closure.hash = hash;
 
  GNUNET_CONTAINER_multipeermap_iterate (room->tunnels,
                                         &iterate_send_room_envelope,
                                         &closure);
 
  GNUNET_free (envelope);
}

References GNUNET_MESSENGER_ClosureSendRoom::envelope, GNUNET_MESSENGER_ClosureSendRoom::exclude, GNUNET_assert, GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_free, GNUNET_MESSENGER_ClosureSendRoom::hash, iterate_send_room_envelope(), and GNUNET_MESSENGER_SrvRoom::tunnels.

Referenced by callback_srv_room_message_signed(), and 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]	room	Room
[in,out]	tunnel	Tunnel

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

{
  struct GNUNET_MESSENGER_MessageStore *message_store;
  const struct GNUNET_MESSENGER_Message *message;
 
  if (! room->peer_message)
    return;
 
  message_store = get_srv_room_message_store (room);
  message = get_store_message (message_store, room->peer_message);
 
  if (! message)
  {
    GNUNET_free (room->peer_message);
    room->peer_message = NULL;
    return;
  }
 
  if (tunnel)
    forward_tunnel_message (tunnel, message, room->peer_message);
}

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

enum GNUNET_GenericReturnValue 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.

The function will only try to merge one existing fork of the message graph and continue automatically if any active handle inside the room is syncing. Should there be no existing fork in the message graph it returns GNUNET_NO.

Parameters

[in,out]	room	Room
[in,out]	handle	Handle

Returns: GNUNET_YES on success, GNUNET_SYSERR on failure, otherwise GNUNET_NO

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

{
  const struct GNUNET_HashCode *hash;
  struct GNUNET_MESSENGER_Message *message;
 
  GNUNET_assert (room);
 
  if (! handle)
    return GNUNET_SYSERR;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Merging messages by handle in room: %s\n",
              GNUNET_h2s (&(room->key)));
 
  hash = get_message_state_merge_hash (&(room->state));
 
  if ((! hash) || (GNUNET_is_zero (hash)))
    return GNUNET_NO;
 
  message = create_message_merge (hash);
 
  if (! message)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Merging messages failed: %s\n",
                GNUNET_h2s (&(room->key)));
    return GNUNET_SYSERR;
  }
 
  return send_srv_room_message (room, handle, message);
}

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, GNUNET_NO, GNUNET_SYSERR, handle, GNUNET_MESSENGER_SrvRoom::key, send_srv_room_message(), and GNUNET_MESSENGER_SrvRoom::state.

Referenced by merge_srv_handle_room_to_sync().

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_SrvMemberSession *	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]	room	Room
[in,out]	session	Member session
[in]	hash	Hash of message
[in]	delay	Delay of deletion

Returns: GNUNET_YES on success, GNUNET_NO if permission gets denied, GNUNET_SYSERR on operation failure

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

{
  const struct GNUNET_MESSENGER_Message *message;
  struct GNUNET_TIME_Relative forever;
 
  GNUNET_assert ((room) && (session) && (hash));
 
  forever = GNUNET_TIME_relative_get_forever_ ();
 
  if (0 == GNUNET_memcmp (&forever, &delay))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Deletion is delayed forever: operation is impossible!\n");
    return GNUNET_SYSERR;
  }
 
  {
    struct GNUNET_MESSENGER_MessageStore *message_store;
 
    message_store = get_srv_room_message_store (room);
    message = get_store_message (message_store, hash);
  }
 
  if (! message)
    return GNUNET_YES;
 
  if (GNUNET_YES != check_member_session_history (session, hash, GNUNET_YES))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Unpermitted request for deletion by member (%s) of message (%s)!\n",
                GNUNET_sh2s (get_member_session_id (session)), GNUNET_h2s (
                  hash));
 
    return GNUNET_NO;
  }
 
  {
    struct GNUNET_MESSENGER_OperationStore *operation_store;
 
    operation_store = get_srv_room_operation_store (room);
 
    if (GNUNET_OK != use_store_operation (operation_store, hash,
                                          GNUNET_MESSENGER_OP_DELETE, delay))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Deletion has failed: operation denied!\n");
      return GNUNET_SYSERR;
    }
  }
 
  return GNUNET_YES;
}

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] room Room

Returns: CADET handle

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

{
  GNUNET_assert (room);
 
  return room->service->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] room Room

Returns: Shared secret

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

{
  GNUNET_assert (room);
 
  return &(room->key);
}

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]	room	Room
[in]	peer	Peer identity

Returns: Tunnel or NULL

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

{
  GNUNET_assert ((room) && (peer));
 
  return GNUNET_CONTAINER_multipeermap_get (room->tunnels, peer);
}

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_SrvMemberSession *	session,
		GNUNET_MESSENGER_MessageRequestCallback	callback,
		void *	cls
	)

static

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

{
  struct GNUNET_MESSENGER_MessageStore *message_store;
  const struct GNUNET_MESSENGER_MessageLink *link;
  const struct GNUNET_MESSENGER_Message *message;
 
  GNUNET_assert ((room) && (hash) && (session));
 
  message_store = get_srv_room_message_store (room);
  link = get_store_message_link (message_store, hash, GNUNET_YES);
 
  if (! link)
    goto forward;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Requesting link of message with hash: %s\n",
              GNUNET_h2s (hash));
 
  {
    enum GNUNET_GenericReturnValue result;
    result = request_room_message_step (room, &(link->first), session,
                                        callback, cls);
 
    if ((GNUNET_YES == link->multiple) &&
        (GNUNET_YES == request_room_message_step (room, &(link->second),
                                                  session, callback, cls)))
      return GNUNET_YES;
    else
      return result;
  }
 
forward:
  message = get_store_message (message_store, hash);
 
  if (! message)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Requested message is missing in local storage: %s\n",
                GNUNET_h2s (hash));
    return GNUNET_NO;
  }
 
  if (GNUNET_YES == is_epoch_message (message))
    goto skip_member_session;
 
  if (GNUNET_YES != check_member_session_history (session, hash, GNUNET_NO))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Unpermitted request for access by member (%s) of message (%s)!\n",
                GNUNET_sh2s (get_member_session_id (session)),
                GNUNET_h2s (hash));
    return GNUNET_YES;
  }
 
skip_member_session:
  if (callback)
    callback (cls, room, message, hash);
 
  return GNUNET_YES;
}

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_SrvMemberSession *	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]	room	Room
[in]	hash	Hash of message
[in]	callback	Callback to process result
[in]	cls	Closure for the callback

Returns: GNUNET_YES if the request could be processed, otherwise GNUNET_NO

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

{
  enum GNUNET_GenericReturnValue result;
 
  GNUNET_assert ((room) && (hash));
 
  result = request_room_message_step (room, hash, session, callback, cls);
 
  if ((GNUNET_NO == result) && (callback))
    callback (cls, room, NULL, hash);
 
  return result;
}

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_BlindablePublicKey *	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]	room	Room
[in]	public_key	Public key
[in]	member_id	Member ID
[in]	timestamp	Timestamp

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

{
  struct GNUNET_MESSENGER_MemberStore *member_store;
  struct GNUNET_MESSENGER_Member *member;
  struct GNUNET_MESSENGER_ListHandles *handles;
  struct GNUNET_MESSENGER_ListHandle *element;
 
  GNUNET_assert ((room) && (public_key) && (member_id));
 
  member_store = get_srv_room_member_store (room);
  member = get_store_member (member_store, member_id);
 
  if ((! member) || (1 >= GNUNET_CONTAINER_multihashmap_size (
                       member->sessions)))
    return;
 
  handles = &(room->service->handles);
 
  for (element = handles->head; element; element = element->next)
  {
    const struct GNUNET_CRYPTO_BlindablePublicKey *pubkey;
    struct GNUNET_MESSENGER_SrvMemberSession *session;
 
    if (0 != GNUNET_memcmp (member_id, get_srv_handle_member_id (
                              element->handle, get_srv_room_key (room))))
      continue;
 
    pubkey = get_srv_handle_key (element->handle);
 
    if (0 == GNUNET_memcmp (public_key, pubkey))
      continue;
 
    session = get_member_session (member, pubkey);
 
    if (! session)
      continue;
 
    {
      struct GNUNET_TIME_Absolute start;
      start = get_member_session_start (session);
 
      if (GNUNET_TIME_relative_get_zero_ ().rel_value_us !=
          GNUNET_TIME_absolute_get_difference (start, timestamp).rel_value_us)
        continue;
    }
 
    {
      struct GNUNET_ShortHashCode random_id;
      generate_free_member_id (&random_id, member_store->members);
 
      notify_srv_handle_member_id (
        element->handle,
        room,
        &random_id,
        GNUNET_NO);
    }
  }
}

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_SrvMemberSession::member, GNUNET_MESSENGER_MemberStore::members, GNUNET_MESSENGER_ListHandle::next, notify_srv_handle_member_id(), pubkey, GNUNET_MESSENGER_SrvMemberSession::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] room Room

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

{
  struct GNUNET_MESSENGER_ListTunnel *element;
  struct GNUNET_PeerIdentity peer;
  size_t count;
  size_t src;
  size_t dst;
 
  GNUNET_assert (room);
 
  if (GNUNET_OK != get_service_peer_identity (room->service, &peer))
    return;
 
  count = count_of_tunnels (&(room->basement));
 
  if (! find_list_tunnels (&(room->basement), &peer, &src))
    return;
 
  if ((count > room->service->min_routers) &&
      (GNUNET_NO == is_srv_handle_routing (room->host, &(room->key))) &&
      (GNUNET_OK == verify_list_tunnels_flag_token (&(room->basement),
                                                    &peer,
                                                    GNUNET_MESSENGER_FLAG_CONNECTION_AUTO)))
  {
    close_srv_room (room);
    return;
  }
 
  element = room->basement.head;
  dst = 0;
 
  while (element)
  {
    struct GNUNET_MESSENGER_SrvTunnel *tunnel;
 
    GNUNET_PEER_resolve (element->peer, &peer);
 
    tunnel = GNUNET_CONTAINER_multipeermap_get (room->tunnels, &peer);
 
    if (! tunnel)
    {
      element = remove_from_list_tunnels (&(room->basement), element);
      continue;
    }
 
    if (GNUNET_YES == required_connection_between (count, src, dst))
    {
      if (GNUNET_SYSERR == connect_tunnel (tunnel))
      {
        element = remove_from_list_tunnels (&(room->basement), element);
        continue;
      }
    }
    else
      disconnect_tunnel (tunnel);
 
    element = element->next;
    dst++;
  }
}

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] room Room

Returns: Amount of tunnels

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

{
  GNUNET_assert (room);
 
  return GNUNET_CONTAINER_multipeermap_size (room->tunnels);
}

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] room Room

Returns: Connection flags

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

{
  uint32_t flags;
 
  GNUNET_assert (room);
 
  flags = GNUNET_MESSENGER_FLAG_CONNECTION_NONE;
 
  if (GNUNET_YES == room->service->auto_routing)
    flags |= GNUNET_MESSENGER_FLAG_CONNECTION_AUTO;
 
  return flags;
}

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_BlindablePublicKey *	public_key,
		struct GNUNET_MESSENGER_SrvMemberSession *	session
	)

static

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

{
  struct GNUNET_MESSENGER_MemberSubscriptionIteration *it;
  struct GNUNET_MESSENGER_Member *member;
  struct GNUNET_MESSENGER_Subscription *subscription;
 
  GNUNET_assert ((cls) && (session));
 
  it = cls;
  member = session->member;
 
  subscription = get_member_subscription (member, it->discourse);
  if (! subscription)
    return GNUNET_YES;
 
  if (GNUNET_TIME_absolute_cmp (subscription->start, <, it->start))
    it->start = subscription->start;
 
  return GNUNET_YES;
}

References GNUNET_MESSENGER_MemberSubscriptionIteration::discourse, get_member_subscription(), GNUNET_assert, GNUNET_TIME_absolute_cmp, GNUNET_YES, GNUNET_MESSENGER_SrvMemberSession::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]	room	Room
[in]	discourse	Hash of discourse

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

{
  struct GNUNET_MESSENGER_MemberSubscriptionIteration it;
  struct GNUNET_MESSENGER_MemberStore *member_store;
  struct GNUNET_MESSENGER_MessageStore *message_store;
 
  GNUNET_assert ((room) && (discourse));
 
  it.discourse = discourse;
  it.start = GNUNET_TIME_absolute_get_forever_ ();
 
  member_store = get_srv_room_member_store (room);
 
  iterate_store_members (member_store, iterate_member_for_subscription, &it);
 
  message_store = get_srv_room_message_store (room);
 
  cleanup_store_discourse_messages_before (message_store,
                                           discourse,
                                           it.start);
}

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_BlindablePublicKey *	public_key,
		struct GNUNET_MESSENGER_SrvMemberSession *	session
	)

static

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

{
  struct GNUNET_MESSENGER_MemberUpdate *update;
 
  GNUNET_assert ((cls) && (session));
 
  update = cls;
 
  update_member_session_history (session, update->message, update->hash);
 
  if (GNUNET_YES == is_member_session_completed (session))
  {
    struct GNUNET_MESSENGER_SrvMemberSessionCompletion *element;
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Add member session completion to queue!\n");
 
    element = GNUNET_new (struct GNUNET_MESSENGER_SrvMemberSessionCompletion);
    element->session = session;
 
    GNUNET_CONTAINER_DLL_insert_tail (update->head, update->tail, element);
  }
 
  return GNUNET_YES;
}

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_SrvMemberSessionCompletion::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_SrvMemberSession *	session
	)

static

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

{
  struct GNUNET_HashCode hash;
  char *session_dir;
  char *room_dir;
 
  GNUNET_assert ((room) && (session));
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Remove member session from room: %s (%s)\n",
              GNUNET_sh2s (get_member_session_id (session)),
              GNUNET_h2s (get_srv_room_key (room)));
 
  remove_member_session (session->member, session);
 
  {
    const struct GNUNET_CRYPTO_BlindablePublicKey *public_key;
    public_key = get_member_session_public_key (session);
 
    GNUNET_CRYPTO_hash (public_key, sizeof(*public_key), &hash);
  }
 
 
  get_room_data_subdir (room, &room_dir);
 
  GNUNET_asprintf (
    &session_dir, "%s%s%c%s%c%s%c%s%c", room_dir,
    "members", DIR_SEPARATOR,
    GNUNET_sh2s (get_member_session_id (session)), DIR_SEPARATOR,
    "sessions", DIR_SEPARATOR,
    GNUNET_h2s (&hash), DIR_SEPARATOR);
 
  GNUNET_free (room_dir);
 
  GNUNET_DISK_directory_remove (session_dir);
  GNUNET_free (session_dir);
 
  destroy_member_session (session);
}

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_SrvMemberSession::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] room Room

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

{
  char *room_dir;
 
  GNUNET_assert (room);
 
  get_room_data_subdir (room, &room_dir);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Load room from directory: %s\n",
              room_dir);
 
  if (GNUNET_YES == GNUNET_DISK_directory_test (room_dir, GNUNET_YES))
  {
    char *peers_file;
    GNUNET_asprintf (&peers_file, "%s%s", room_dir, "peers.list");
 
    load_peer_store (get_srv_room_peer_store (room), peers_file);
    GNUNET_free (peers_file);
 
    load_member_store (get_srv_room_member_store (room), room_dir);
    move_message_store (get_srv_room_message_store (room), room_dir);
    load_message_store (get_srv_room_message_store (room));
    load_operation_store (get_srv_room_operation_store (room), room_dir);
 
    {
      char *basement_file;
      GNUNET_asprintf (&basement_file, "%s%s", room_dir, "basement.list");
 
      load_list_tunnels (&(room->basement), basement_file);
      GNUNET_free (basement_file);
    }
 
    load_message_state (&(room->state), room_dir);
  }
 
  GNUNET_free (room_dir);
}

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] room Room

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

{
  char *room_dir;
 
  GNUNET_assert (room);
 
  get_room_data_subdir (room, &room_dir);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Save room to directory: %s\n",
              room_dir);
 
  if ((GNUNET_YES == GNUNET_DISK_directory_test (room_dir, GNUNET_NO)) ||
      (GNUNET_OK == GNUNET_DISK_directory_create (room_dir)))
  {
    char *peers_file;
    GNUNET_asprintf (&peers_file, "%s%s", room_dir, "peers.list");
 
    save_peer_store (get_srv_room_peer_store (room), peers_file);
    GNUNET_free (peers_file);
 
    save_member_store (get_srv_room_member_store (room), room_dir);
    move_message_store (get_srv_room_message_store (room), room_dir);
    save_message_store (get_srv_room_message_store (room));
    save_operation_store (get_srv_room_operation_store (room), room_dir);
 
    {
      char *basement_file;
      GNUNET_asprintf (&basement_file, "%s%s", room_dir, "basement.list");
 
      save_list_tunnels (&(room->basement), basement_file);
      GNUNET_free (basement_file);
    }
 
    save_message_state (&(room->state), room_dir);
  }
 
  GNUNET_free (room_dir);
}

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] room Room

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

{
  char *room_dir;
 
  GNUNET_assert (room);
 
  get_room_data_subdir (room, &room_dir);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Remove room from directory: %s\n",
              room_dir);
 
  if (GNUNET_YES == GNUNET_DISK_directory_test (room_dir, GNUNET_YES))
    GNUNET_DISK_directory_remove (room_dir);
 
  GNUNET_free (room_dir);
}

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:

Data Structures

Functions

Function Documentation

◆ idle_request_room_messages()

◆ get_room_data_subdir()

◆ create_srv_room()

◆ iterate_destroy_tunnels()

◆ iterate_cancel_signature()

◆ close_srv_room()

◆ handle_room_messages()

◆ destroy_srv_room()

◆ get_srv_room_peer_store()

◆ get_srv_room_member_store()

◆ get_srv_room_message_store()

◆ get_srv_room_operation_store()

◆ send_room_info()

◆ callback_room_connect()

◆ join_room()

◆ join_room_locally()

◆ open_srv_room()

◆ enter_srv_room_at()

◆ callback_srv_room_sign_result()

◆ sign_srv_room_message()

◆ update_room_message()

◆ callback_room_handle_message()

◆ callback_srv_room_message_signed()

◆ send_srv_room_message()

◆ iterate_send_room_envelope()

◆ send_srv_room_envelope()

◆ check_srv_room_peer_status()

◆ merge_srv_room_last_messages()

◆ delete_srv_room_message()

◆ get_srv_room_cadet()

◆ get_srv_room_key()

◆ get_srv_room_tunnel()

◆ request_room_message_step()

◆ request_srv_room_message()

◆ solve_srv_room_member_collisions()

◆ rebuild_srv_room_basement_structure()

◆ get_srv_room_amount_of_tunnels()

◆ get_srv_room_connection_flags()

◆ iterate_member_for_subscription()

◆ cleanup_srv_room_discourse_messages()

◆ iterate_update_member_sessions()

◆ remove_room_member_session()

◆ load_srv_room()

◆ save_srv_room()

◆ remove_srv_room()