gnunet-service-messenger_room.c File Reference

GNUnet MESSENGER service. More...

#include "platform.h"
#include "gnunet-service-messenger_room.h"
#include "gnunet-service-messenger_member.h"
#include "gnunet-service-messenger_member_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.h"
#include "gnunet-service-messenger_service.h"
#include "gnunet-service-messenger_tunnel.h"
#include "messenger_api_util.h"

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

Go to the source code of this file.

Data Structures
struct	GNUNET_MESSENGER_MemberNotify
struct	GNUNET_MESSENGER_ClosureSendRoom
struct	GNUNET_MESSENGER_MemberSessionCompletion
struct	GNUNET_MESSENGER_MemberUpdate

Functions
static void	idle_request_room_messages (void *cls)
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. More...
static int	iterate_destroy_tunnels (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
static void	handle_room_messages (struct GNUNET_MESSENGER_SrvRoom *room)
void	destroy_srv_room (struct GNUNET_MESSENGER_SrvRoom *room, int deletion)
	Destroys a room and frees its memory fully. More...
struct GNUNET_MESSENGER_MemberStore *	get_srv_room_member_store (struct GNUNET_MESSENGER_SrvRoom *room)
	Returns the used member store of a given room. More...
struct GNUNET_MESSENGER_MessageStore *	get_srv_room_message_store (struct GNUNET_MESSENGER_SrvRoom *room)
	Returns the used message store of a given room. More...
struct GNUNET_MESSENGER_OperationStore *	get_srv_room_operation_store (struct GNUNET_MESSENGER_SrvRoom *room)
	Returns the used operation store of a given room. More...
static int	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 int	join_room (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_Member *member)
static void	notify_about_members (struct GNUNET_MESSENGER_MemberNotify *notify, struct GNUNET_MESSENGER_MemberSession *session, struct GNUNET_CONTAINER_MultiHashMap *map, int check_permission)
static int	iterate_notify_about_members (void *cls, const struct GNUNET_IDENTITY_PublicKey *public_key, struct GNUNET_MESSENGER_MemberSession *session)
static int	join_room_locally (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle)
int	check_tunnel_message (void *cls, const struct GNUNET_MessageHeader *header)
void	handle_tunnel_message (void *cls, const struct GNUNET_MessageHeader *header)
void	callback_tunnel_disconnect (void *cls, const struct GNUNET_CADET_Channel *channel)
int	open_srv_room (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle)
	Tries to open a room for a given handle. More...
int	enter_srv_room_at (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_PeerIdentity *door)
	Connects a tunnel to a hosting peer of a room through a so called door which is represented by a peer identity of a hosting peer. More...
struct GNUNET_MQ_Envelope *	pack_srv_room_message (const struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *hash, int mode)
	Packs a message depending on the selected mode into a newly allocated envelope. More...
static int	iterate_send_room_message (void *cls, const struct GNUNET_PeerIdentity *key, void *value)
int	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, struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
int	send_srv_room_message (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_Message *message)
	Sends a message from a given handle into a room. More...
void	forward_srv_room_message (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel, struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
	Forwards a message with a given hash to a specific tunnel inside of a room. More...
void	check_srv_room_peer_status (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvTunnel *tunnel)
	Checks the current state of opening a given room from this peer and re-publishes it if necessary to a selected tunnel or to all connected tunnels if necessary or if the selected tunnel is NULL. More...
void	merge_srv_room_last_messages (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle)
	Reduces all current forks inside of the message history of a room to one remaining last message by merging them down. More...
void	callback_room_deletion (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_HashCode *hash)
void	callback_room_merge (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_HashCode *hash)
int	delete_srv_room_message (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_MemberSession *session, const struct GNUNET_HashCode *hash, const struct GNUNET_TIME_Relative delay)
	Deletes a message from the room with a given hash in a specific delay if the provided member by its session is permitted to do so. More...
struct GNUNET_CADET_Handle *	get_srv_room_cadet (struct GNUNET_MESSENGER_SrvRoom *room)
	Returns the CADET handle from a rooms service. More...
const struct GNUNET_HashCode *	get_srv_room_key (const struct GNUNET_MESSENGER_SrvRoom *room)
	Returns the shared secret you need to access a room. More...
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. More...
static int	request_room_message_step (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_HashCode *hash, const struct GNUNET_MESSENGER_MemberSession *session, GNUNET_MESSENGER_MessageRequestCallback callback, void *cls)
int	request_srv_room_message (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_HashCode *hash, const struct GNUNET_MESSENGER_MemberSession *session, GNUNET_MESSENGER_MessageRequestCallback callback, void *cls)
	Requests a message from a room identified by a given hash. More...
void	callback_room_disconnect (struct GNUNET_MESSENGER_SrvRoom *room, void *cls)
int	callback_verify_room_message (struct GNUNET_MESSENGER_SrvRoom *room, void *cls, struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *hash)
void	solve_srv_room_member_collisions (struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_IDENTITY_PublicKey *public_key, const struct GNUNET_ShortHashCode *member_id, struct GNUNET_TIME_Absolute timestamp)
	Checks for potential collisions with member ids and solves them changing active handles ids if they use an already used member id (comparing public key and timestamp). More...
void	rebuild_srv_room_basement_structure (struct GNUNET_MESSENGER_SrvRoom *room)
	Rebuilds the decentralized structure for a room by ensuring all required connections are made depending on the amount of peers and this peers index in the list of them. More...
static int	iterate_update_member_sessions (void *cls, const struct GNUNET_IDENTITY_PublicKey *public_key, struct GNUNET_MESSENGER_MemberSession *session)
static void	remove_room_member_session (struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_MemberSession *session)
static void	get_room_data_subdir (struct GNUNET_MESSENGER_SrvRoom *room, char **dir)
void	load_srv_room (struct GNUNET_MESSENGER_SrvRoom *room)
	Loads the local configuration for a given room of a service which contains the last messages hash and the ruleset for general access of new members. More...
void	save_srv_room (struct GNUNET_MESSENGER_SrvRoom *room)
	Saves the configuration for a given room of a service which contains the last messages hash and the ruleset for general access of new members locally. More...
void	remove_srv_room (struct GNUNET_MESSENGER_SrvRoom *room)
	Removes the configuration for a given room of a service. More...

Detailed Description

GNUnet MESSENGER service.

Author

Tobias Frisch

Definition in file gnunet-service-messenger_room.c.

Function Documentation

idle_request_room_messages()

static void idle_request_room_messages ( void *  cls )

static

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

{
  struct GNUNET_MESSENGER_SrvRoom *room = cls;
 
  room->idle = NULL;
 
  struct GNUNET_MESSENGER_OperationStore *operation_store = get_srv_room_operation_store(room);
  const struct GNUNET_HashCode *hash = get_message_state_merge_hash(&(room->state));
 
  if ((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_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, GNUNET_MESSENGER_OperationStore::room, GNUNET_MESSENGER_SrvRoom::state, and use_store_operation().

Referenced by create_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 47 of file gnunet-service-messenger_room.c.

{
  GNUNET_assert((handle) && (key));
 
  struct GNUNET_MESSENGER_SrvRoom *room = GNUNET_new(struct GNUNET_MESSENGER_SrvRoom);
 
  room->service = handle->service;
  room->host = handle;
  room->port = NULL;
 
  GNUNET_memcpy(&(room->key), key, sizeof(struct GNUNET_HashCode));
 
  room->tunnels = GNUNET_CONTAINER_multipeermap_create (8, GNUNET_NO);
 
  init_member_store(get_srv_room_member_store(room), room);
  init_message_store (get_srv_room_message_store(room));
  init_operation_store(get_srv_room_operation_store(room), room);
 
  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;
}

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

Referenced by entry_service_room(), and open_service_room().

Here is the call graph for this function:

Here is the caller graph for this function:

iterate_destroy_tunnels()

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

static

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

{
  struct GNUNET_MESSENGER_SrvTunnel *tunnel = value;
  destroy_tunnel (tunnel);
  return GNUNET_YES;
}

References destroy_tunnel(), 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:

handle_room_messages()

static void handle_room_messages ( struct GNUNET_MESSENGER_SrvRoom *  room )

static

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

{
  struct GNUNET_MESSENGER_MessageStore *message_store = get_srv_room_message_store(room);
  struct GNUNET_MESSENGER_MemberStore *member_store = get_srv_room_member_store(room);
 
  while (room->handling.head)
  {
    struct GNUNET_MESSENGER_ListMessage *element = room->handling.head;
 
    const struct GNUNET_MESSENGER_Message *message = get_store_message (message_store, &(element->hash));
 
    if (!message)
      goto finish_handling;
 
    struct GNUNET_MESSENGER_Member *member = get_store_member_of(member_store, message);
 
    if (!member)
      goto finish_handling;
 
    struct GNUNET_MESSENGER_MemberSession *session = get_member_session_of(member, message, &(element->hash));
 
    if (session)
      handle_service_message (room->service, room, session, message, &(element->hash));
 
finish_handling:
    GNUNET_CONTAINER_DLL_remove(room->handling.head, room->handling.tail, element);
    GNUNET_free(element);
  }
}

References get_member_session_of(), get_srv_room_member_store(), get_srv_room_message_store(), get_store_member_of(), get_store_message(), GNUNET_CONTAINER_DLL_remove, GNUNET_free, handle_service_message(), GNUNET_MESSENGER_SrvRoom::handling, GNUNET_MESSENGER_ListMessage::hash, GNUNET_MESSENGER_ListMessages::head, GNUNET_MESSENGER_MemberSession::member, GNUNET_MESSENGER_MemberStore::room, 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,
		int	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 96 of file gnunet-service-messenger_room.c.

{
  GNUNET_assert(room);
 
  if (room->idle)
  {
    GNUNET_SCHEDULER_cancel (room->idle);
    room->idle = NULL;
  }
 
  if (room->port)
    GNUNET_CADET_close_port (room->port);
 
  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_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_multipeermap_destroy (room->tunnels);
  clear_list_tunnels (&(room->basement));
  clear_message_state(&(room->state));
 
  if (room->peer_message)
    GNUNET_free(room->peer_message);
 
  GNUNET_free(room);
}

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

get_srv_room_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 137 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(), check_srv_room_peer_status(), create_srv_room(), destroy_srv_room(), get_handle_member_session(), handle_get_message(), handle_room_messages(), join_room_locally(), load_srv_room(), open_srv_room(), recv_message_info(), recv_message_request(), save_srv_room(), and solve_srv_room_member_collisions().

Here is the caller graph for this function:

get_srv_room_message_store()

struct GNUNET_MESSENGER_MessageStore* get_srv_room_message_store

(

struct GNUNET_MESSENGER_SrvRoom *

room

)

Returns the used message store of a given room.

Parameters

[in,out]

room

Room

Returns

Message store

Definition at line 145 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_room_deletion(), callback_verify_room_message(), check_member_session_completion(), check_srv_room_peer_status(), create_srv_room(), delete_srv_room_message(), destroy_srv_room(), forward_about_members(), handle_room_messages(), load_srv_room(), notify_about_members(), request_room_message_step(), save_srv_room(), update_room_message(), and update_tunnel_last_message().

Here is the caller graph for this function:

get_srv_room_operation_store()

struct GNUNET_MESSENGER_OperationStore* get_srv_room_operation_store

(

struct GNUNET_MESSENGER_SrvRoom *

room

)

Returns the used operation store of a given room.

Parameters

[in,out]

room

Room

Returns

Operation store

Definition at line 153 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 int send_room_info ( struct GNUNET_MESSENGER_SrvRoom *  room, struct GNUNET_MESSENGER_SrvHandle *  handle, struct GNUNET_MESSENGER_SrvTunnel *  tunnel  )

static

Definition at line 161 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 (get_srv_handle_ego (handle)));
}

References create_message_info(), get_srv_handle_ego(), GNUNET_NO, handle, is_tunnel_connected(), and send_tunnel_message().

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

{
  struct GNUNET_MESSENGER_SrvRoom *room = cls;
 
  struct GNUNET_MESSENGER_SrvTunnel *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_INFO, "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_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multipeermap_put(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_ERROR_TYPE_INFO, 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 int join_room ( struct GNUNET_MESSENGER_SrvRoom *  room, struct GNUNET_MESSENGER_SrvHandle *  handle, struct GNUNET_MESSENGER_Member *  member  )

static

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

{
  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)));
 
  const struct GNUNET_ShortHashCode *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;
 
  struct GNUNET_MESSENGER_Message *message = create_message_join (get_srv_handle_ego (handle));
 
  if (!message)
  {
    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Your join message could not be created!\n");
 
    return GNUNET_NO;
  }
 
  GNUNET_memcpy(&(message->header.sender_id), member_id, sizeof(*member_id));
  return send_srv_room_message (room, handle, message);
}

References change_srv_handle_member_id(), create_message_join(), get_member_id(), get_srv_handle_ego(), get_srv_room_key(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_NO, GNUNET_OK, GNUNET_sh2s(), handle, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_SrvTunnel::room, send_srv_room_message(), and GNUNET_MESSENGER_MessageHeader::sender_id.

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:

notify_about_members()

static void notify_about_members ( struct GNUNET_MESSENGER_MemberNotify *  notify, struct GNUNET_MESSENGER_MemberSession *  session, struct GNUNET_CONTAINER_MultiHashMap *  map, int  check_permission  )

static

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

{
  if (session->prev)
    notify_about_members (notify, session->prev, map, GNUNET_YES);
 
  struct GNUNET_MESSENGER_MessageStore *message_store = get_srv_room_message_store(notify->room);
  struct GNUNET_MESSENGER_ListMessage *element;
 
  for (element = session->messages.head; element; element = element->next)
  {
    if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains(map, &(element->hash)))
      continue;
 
    if ((GNUNET_YES == check_permission) &&
        (GNUNET_YES != check_member_session_history(notify->session, &(element->hash), GNUNET_NO)))
      continue;
 
    if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put(map, &(element->hash), NULL,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
      GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Notification of session message could be duplicated!\n");
 
    const struct GNUNET_MESSENGER_Message *message = get_store_message(message_store, &(element->hash));
 
    if (message)
      notify_srv_handle_message (notify->handle, notify->room, session, message, &(element->hash));
  }
}

References check_member_session_history(), get_srv_room_message_store(), get_store_message(), GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_YES, GNUNET_MESSENGER_ListMessage::hash, GNUNET_MESSENGER_ListMessages::head, map, GNUNET_MESSENGER_MemberSession::messages, GNUNET_MESSENGER_ListMessage::next, notify, notify_srv_handle_message(), and GNUNET_MESSENGER_MemberSession::prev.

Referenced by iterate_notify_about_members().

Here is the call graph for this function:

Here is the caller graph for this function:

iterate_notify_about_members()

static int iterate_notify_about_members ( void *  cls, const struct GNUNET_IDENTITY_PublicKey *  public_key, struct GNUNET_MESSENGER_MemberSession *  session  )

static

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

{
  struct GNUNET_MESSENGER_MemberNotify *notify = cls;
 
  if ((notify->session == session) || (GNUNET_YES == is_member_session_completed(session)))
    return GNUNET_YES;
 
  struct GNUNET_CONTAINER_MultiHashMap *map = GNUNET_CONTAINER_multihashmap_create(4, GNUNET_NO);
 
  notify_about_members (notify, session, map, GNUNET_NO);
 
  GNUNET_CONTAINER_multihashmap_destroy(map);
  return GNUNET_YES;
}

References GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_NO, GNUNET_YES, is_member_session_completed(), map, notify, notify_about_members(), and GNUNET_MESSENGER_MemberNotify::session.

Referenced by join_room_locally().

Here is the call graph for this function:

Here is the caller graph for this function:

join_room_locally()

static int join_room_locally ( struct GNUNET_MESSENGER_SrvRoom *  room, struct GNUNET_MESSENGER_SrvHandle *  handle  )

static

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

{
  const struct GNUNET_ShortHashCode *member_id = get_srv_handle_member_id (handle, get_srv_room_key(room));
 
  struct GNUNET_MESSENGER_MemberStore *member_store = get_srv_room_member_store(room);
  struct GNUNET_MESSENGER_Member *member = add_store_member(member_store, member_id);
 
  if (GNUNET_NO == join_room (room, handle, member))
    return GNUNET_NO;
 
  const struct GNUNET_MESSENGER_Ego *ego = get_srv_handle_ego(handle);
  struct GNUNET_MESSENGER_MemberSession *session = get_member_session (member, &(ego->pub));
 
  if (!session)
  {
    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "A valid session is required to join a room!\n");
    return GNUNET_NO;
  }
 
  struct GNUNET_MESSENGER_MemberNotify notify;
 
  notify.room = room;
  notify.handle = handle;
  notify.session = session;
 
  iterate_store_members(get_srv_room_member_store(room), iterate_notify_about_members, &notify);
 
  return GNUNET_YES;
}

References add_store_member(), get_member_session(), get_srv_handle_ego(), get_srv_handle_member_id(), get_srv_room_key(), get_srv_room_member_store(), GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_NO, GNUNET_YES, handle, iterate_notify_about_members(), iterate_store_members(), join_room(), GNUNET_MESSENGER_MemberSession::member, notify, GNUNET_MESSENGER_Ego::pub, GNUNET_MESSENGER_MemberStore::room, GNUNET_MESSENGER_MemberNotify::room, and GNUNET_MESSENGER_MemberNotify::session.

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:

check_tunnel_message()

int check_tunnel_message	(	void *	cls,
		const struct GNUNET_MessageHeader *	header
	)

Definition at line 113 of file gnunet-service-messenger_tunnel.c.

{
  struct GNUNET_MESSENGER_SrvTunnel *tunnel = cls;
 
  if (!tunnel)
    return GNUNET_SYSERR;
 
  const uint16_t length = ntohs (header->size) - sizeof(*header);
  const char *buffer = (const char*) &header[1];
 
  struct GNUNET_MESSENGER_Message message;
 
  if (length < get_message_kind_size(GNUNET_MESSENGER_KIND_UNKNOWN, GNUNET_YES))
  {
    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Tunnel error: Message too short! (%d)\n", length);
    return GNUNET_SYSERR;
  }
 
  uint16_t padding = 0;
 
  if (GNUNET_YES != decode_message (&message, length, buffer, GNUNET_YES, &padding))
  {
    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Tunnel error: Decoding failed!\n");
    return GNUNET_SYSERR;
  }
 
  struct GNUNET_HashCode hash;
  hash_message (&message, length - padding, buffer, &hash);
 
  return callback_verify_room_message (tunnel->room, cls, &message, &hash);
}

References callback_verify_room_message(), decode_message(), get_message_kind_size(), GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_MESSENGER_KIND_UNKNOWN, GNUNET_SYSERR, GNUNET_YES, hash_message(), GNUNET_MESSENGER_SrvTunnel::room, and GNUNET_MessageHeader::size.

Here is the call graph for this function:

handle_tunnel_message()

void handle_tunnel_message	(	void *	cls,
		const struct GNUNET_MessageHeader *	header
	)

Definition at line 176 of file gnunet-service-messenger_tunnel.c.

{
  struct GNUNET_MESSENGER_SrvTunnel *tunnel = cls;
 
  if (!tunnel)
    return;
 
  const uint16_t length = ntohs (header->size) - sizeof(*header);
  const char *buffer = (const char*) &header[1];
 
  struct GNUNET_MESSENGER_Message message;
  struct GNUNET_HashCode hash;
 
  uint16_t padding = 0;
 
  decode_message (&message, length, buffer, GNUNET_YES, &padding);
  hash_message (&message, length - padding, buffer, &hash);
 
  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Got message of kind: %s!\n",
             GNUNET_MESSENGER_name_of_kind(message.header.kind));
 
  const int new_message = update_room_message (
      tunnel->room, copy_message (&message), &hash
  );
 
  if (GNUNET_YES != new_message)
    goto receive_done;
 
  update_tunnel_last_message (tunnel, &hash);
 
  int forward_message = GNUNET_YES;
 
  switch (message.header.kind)
  {
  case GNUNET_MESSENGER_KIND_INFO:
    forward_message = recv_message_info (tunnel->room, tunnel, &message, &hash);
    break;
  case GNUNET_MESSENGER_KIND_PEER:
    forward_message = recv_message_peer (tunnel->room, tunnel, &message, &hash);
    break;
  case GNUNET_MESSENGER_KIND_REQUEST:
    forward_message = recv_message_request (tunnel->room, tunnel, &message, &hash);
    break;
  default:
    break;
  }
 
  if (GNUNET_YES == forward_message)
  {
    forward_srv_room_message (tunnel->room, tunnel, &message, &hash);
    callback_room_handle_message (tunnel->room, NULL, &message, &hash);
  }
 
receive_done:
  cleanup_message(&message);
 
  GNUNET_CADET_receive_done (tunnel->channel);
}

References callback_room_handle_message(), GNUNET_MESSENGER_SrvTunnel::channel, cleanup_message(), copy_message(), decode_message(), forward_srv_room_message(), GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSENGER_KIND_INFO, GNUNET_MESSENGER_KIND_PEER, GNUNET_MESSENGER_KIND_REQUEST, GNUNET_MESSENGER_name_of_kind(), GNUNET_YES, hash_message(), GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageHeader::kind, recv_message_info(), recv_message_peer(), recv_message_request(), GNUNET_MESSENGER_SrvTunnel::room, GNUNET_MessageHeader::size, update_room_message(), and update_tunnel_last_message().

Here is the call graph for this function:

callback_tunnel_disconnect()

void callback_tunnel_disconnect	(	void *	cls,
		const struct GNUNET_CADET_Channel *	channel
	)

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

{
  struct GNUNET_MESSENGER_SrvTunnel *tunnel = cls;
 
  if (tunnel)
  {
    tunnel->channel = NULL;
 
    callback_room_disconnect (tunnel->room, cls);
  }
}

References callback_room_disconnect(), GNUNET_MESSENGER_SrvTunnel::channel, and GNUNET_MESSENGER_SrvTunnel::room.

Referenced by connect_tunnel(), and open_srv_room().

Here is the call graph for this function:

Here is the caller graph for this function:

open_srv_room()

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

{
  GNUNET_assert((room) && (handle));
 
  if (room->port)
    return join_room_locally (room, handle);
 
  struct GNUNET_CADET_Handle *cadet = get_srv_room_cadet (room);
  const struct GNUNET_HashCode *key = get_srv_room_key (room);
 
  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() };
 
  struct GNUNET_HashCode port;
  convert_messenger_key_to_port(key, &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_INFO, "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)));
 
  const struct GNUNET_ShortHashCode *member_id = get_srv_handle_member_id (handle, get_srv_room_key(room));
 
  struct GNUNET_MESSENGER_MemberStore *member_store = get_srv_room_member_store(room);
  struct GNUNET_MESSENGER_Member *member = add_store_member(member_store, member_id);
 
  if ((GNUNET_NO == join_room (room, handle, member)) && (room->port))
  {
    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "You could not join the room, therefore it keeps closed!\n");
 
    GNUNET_CADET_close_port (room->port);
    room->port = NULL;
 
    return GNUNET_NO;
  }
 
  struct GNUNET_MESSENGER_Message *peer_msg = create_message_peer (room->service);
  GNUNET_memcpy(&(peer_msg->header.sender_id), member_id, sizeof(*member_id));
  return (room->port ? send_srv_room_message (room, handle, peer_msg) : GNUNET_NO);
}

References add_store_member(), cadet, callback_room_connect(), callback_tunnel_disconnect(), 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_close_port(), GNUNET_CADET_open_port(), GNUNET_ERROR_TYPE_INFO, 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, handle, handlers, GNUNET_MESSENGER_Message::header, join_room(), join_room_locally(), key, port, GNUNET_MESSENGER_SrvRoom::port, GNUNET_MESSENGER_MemberStore::room, GNUNET_MESSENGER_MemberNotify::room, send_srv_room_message(), GNUNET_MESSENGER_MessageHeader::sender_id, and GNUNET_MESSENGER_SrvRoom::service.

Referenced by open_service_room().

Here is the call graph for this function:

Here is the caller graph for this function:

enter_srv_room_at()

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

{
  GNUNET_assert((room) && (handle) && (door));
 
  struct GNUNET_PeerIdentity peer;
 
  if ((GNUNET_OK == get_service_peer_identity (room->service, &peer)) &&
      (0 == GNUNET_memcmp(&peer, door)))
    return join_room_locally (room, handle);
 
  struct GNUNET_MESSENGER_SrvTunnel *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(), peer, GNUNET_MESSENGER_SrvTunnel::room, GNUNET_MESSENGER_SrvRoom::service, and GNUNET_MESSENGER_SrvRoom::tunnels.

Referenced by entry_service_room().

Here is the call graph for this function:

Here is the caller graph for this function:

pack_srv_room_message()

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

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

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

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

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

Parameters

[in]	room	Room
[in]	handle	Handle
[in,out]	message	Message
[out]	hash	Hash of message
[in]	mode	Packing mode

Returns

New envelope or NULL

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

{
  GNUNET_assert((room) && (handle) && (message) && (hash));
 
  message->header.timestamp = GNUNET_TIME_absolute_hton (GNUNET_TIME_absolute_get ());
 
  const struct GNUNET_ShortHashCode *id = get_srv_handle_member_id (handle, get_srv_room_key(room));
 
  GNUNET_assert(id);
 
  GNUNET_memcpy(&(message->header.sender_id), id, sizeof(struct GNUNET_ShortHashCode));
  get_message_state_chain_hash (&(room->state), &(message->header.previous));
 
  return pack_message (message, hash, get_srv_handle_ego (handle), mode);
}

References get_message_state_chain_hash(), get_srv_handle_ego(), get_srv_handle_member_id(), get_srv_room_key(), GNUNET_assert, GNUNET_memcpy, GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_hton(), handle, GNUNET_MESSENGER_Message::header, mode, pack_message(), GNUNET_MESSENGER_MessageHeader::previous, GNUNET_MESSENGER_MessageHeader::sender_id, GNUNET_MESSENGER_SrvRoom::state, and GNUNET_MESSENGER_MessageHeader::timestamp.

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

Here is the call graph for this function:

Here is the caller graph for this function:

iterate_send_room_message()

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

static

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

{
  struct GNUNET_MESSENGER_SrvTunnel *tunnel = value;
 
  if ((!is_tunnel_connected (tunnel)) ||
      (get_tunnel_messenger_version(tunnel) < GNUNET_MESSENGER_VERSION))
    return GNUNET_YES;
 
  struct GNUNET_MESSENGER_ClosureSendRoom *closure = cls;
 
  if (tunnel == closure->exclude)
    return GNUNET_YES;
 
  struct GNUNET_MQ_Envelope *env = NULL;
 
  if (closure->packed == GNUNET_NO)
  {
    env = pack_srv_room_message (closure->room, closure->handle, closure->message, closure->hash,
    GNUNET_MESSENGER_PACK_MODE_ENVELOPE);
 
    if (env)
      closure->packed = GNUNET_YES;
  }
  else
    env = pack_message (closure->message, NULL, NULL, GNUNET_MESSENGER_PACK_MODE_ENVELOPE);
 
  if (env)
    send_tunnel_envelope (tunnel, env, closure->hash);
 
  return GNUNET_YES;
}

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

Referenced by forward_srv_room_message(), and send_srv_room_message().

Here is the call graph for this function:

Here is the caller graph for this function:

update_room_message()

int update_room_message	(	struct GNUNET_MESSENGER_SrvRoom *	room,
		struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_HashCode *	hash
	)

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

{
  GNUNET_assert((room) && (message) && (hash));
 
  struct GNUNET_MESSENGER_OperationStore *operation_store = get_srv_room_operation_store(room);
 
  const int 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);
 
  struct GNUNET_MESSENGER_MessageStore *message_store = get_srv_room_message_store(room);
 
  const struct GNUNET_MESSENGER_Message *old_message = get_store_message (message_store, hash);
 
  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Handle a message in room (%s).\n", GNUNET_h2s (get_srv_room_key(room)));
 
  if ((old_message) || (GNUNET_OK != put_store_message (message_store, hash, message)))
  {
    if (old_message != message)
      destroy_message(message);
 
    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Duplicate message got dropped!\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(), destroy_message(), get_srv_room_key(), get_srv_room_message_store(), get_srv_room_operation_store(), get_store_message(), 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_OperationStore::room, GNUNET_MESSENGER_SrvRoom::state, and update_message_state().

Referenced by handle_tunnel_message(), and send_srv_room_message().

Here is the call graph for this function:

Here is the caller graph for this function:

callback_room_handle_message()

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

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

{
  struct GNUNET_MESSENGER_MemberStore *member_store = get_srv_room_member_store(room);
  struct GNUNET_MESSENGER_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;
  }
 
  struct GNUNET_MESSENGER_MemberSession *session = get_member_session_of(member, message, hash);
 
  if (!session)
  {
    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_MemberSessionCompletion *element = update.head;
 
    remove_room_member_session (room, element->session);
 
    GNUNET_CONTAINER_DLL_remove(update.head, update.tail, element);
    GNUNET_free (element);
  }
 
  const int 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_NAME:
    handle_message_name (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_DELETE:
    handle_message_delete (room, session, message, hash);
    break;
  default:
    break;
  }
 
  if (GNUNET_YES == start_handle)
    handle_room_messages (room);
}

References add_to_list_messages(), get_member_session_of(), get_srv_room_member_store(), get_store_member_of(), GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_MESSENGER_KIND_DELETE, GNUNET_MESSENGER_KIND_ID, GNUNET_MESSENGER_KIND_JOIN, GNUNET_MESSENGER_KIND_KEY, GNUNET_MESSENGER_KIND_LEAVE, GNUNET_MESSENGER_KIND_MISS, GNUNET_MESSENGER_KIND_NAME, GNUNET_MESSENGER_KIND_PEER, GNUNET_NO, GNUNET_YES, handle_message_delete(), handle_message_id(), handle_message_join(), handle_message_key(), handle_message_leave(), handle_message_miss(), handle_message_name(), handle_message_peer(), handle_room_messages(), GNUNET_MESSENGER_SrvRoom::handling, GNUNET_MESSENGER_MemberUpdate::hash, GNUNET_MESSENGER_ListMessages::head, GNUNET_MESSENGER_MemberUpdate::head, GNUNET_MESSENGER_Message::header, iterate_store_members(), iterate_update_member_sessions(), GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_MemberSession::member, GNUNET_MESSENGER_MemberUpdate::message, remove_room_member_session(), GNUNET_MESSENGER_MemberStore::room, GNUNET_MESSENGER_MemberSessionCompletion::session, and GNUNET_MESSENGER_MemberUpdate::tail.

Referenced by handle_tunnel_message(), and send_srv_room_message().

Here is the call graph for this function:

Here is the caller graph for this function:

send_srv_room_message()

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

{
  GNUNET_assert((room) && (handle));
 
  if (!message)
    return GNUNET_NO;
 
  if (GNUNET_YES == is_message_session_bound(message))
    merge_srv_room_last_messages(room, handle);
 
  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Sending message from handle with member id: %s\n",
             GNUNET_sh2s(get_srv_handle_member_id(handle, get_srv_room_key(room))));
 
  struct GNUNET_HashCode hash;
  struct GNUNET_MESSENGER_ClosureSendRoom closure;
 
  closure.room = room;
  closure.handle = handle;
  closure.exclude = NULL;
  closure.message = message;
  closure.hash = &hash;
  closure.packed = GNUNET_NO;
 
  GNUNET_CONTAINER_multipeermap_iterate (room->tunnels, iterate_send_room_message, &closure);
 
  if (GNUNET_NO == closure.packed)
    pack_srv_room_message (room, handle, message, &hash, GNUNET_MESSENGER_PACK_MODE_UNKNOWN);
 
  const int new_message = update_room_message (room, message, &hash);
 
  if (GNUNET_YES != new_message)
    return GNUNET_SYSERR;
 
  switch (message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_JOIN:
    send_message_join (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, handle, message, &hash);
  return GNUNET_YES;
}

References callback_room_handle_message(), GNUNET_MESSENGER_ClosureSendRoom::exclude, get_srv_handle_member_id(), get_srv_room_key(), GNUNET_assert, GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_MESSENGER_KIND_ID, GNUNET_MESSENGER_KIND_JOIN, GNUNET_MESSENGER_KIND_PEER, GNUNET_MESSENGER_KIND_REQUEST, GNUNET_MESSENGER_PACK_MODE_UNKNOWN, GNUNET_NO, GNUNET_sh2s(), GNUNET_SYSERR, GNUNET_YES, handle, GNUNET_MESSENGER_ClosureSendRoom::handle, GNUNET_MESSENGER_ClosureSendRoom::hash, GNUNET_MESSENGER_Message::header, is_message_session_bound(), iterate_send_room_message(), GNUNET_MESSENGER_MessageHeader::kind, merge_srv_room_last_messages(), GNUNET_MESSENGER_ClosureSendRoom::message, pack_srv_room_message(), GNUNET_MESSENGER_ClosureSendRoom::packed, GNUNET_MESSENGER_ClosureSendRoom::room, send_message_id(), send_message_join(), send_message_peer(), send_message_request(), GNUNET_MESSENGER_SrvRoom::tunnels, and update_room_message().

Referenced by callback_found_message(), callback_room_disconnect(), callback_room_merge(), check_srv_room_peer_status(), close_service_room(), join_room(), merge_srv_room_last_messages(), open_srv_room(), send_srv_handle_message(), and solve_srv_room_member_collisions().

Here is the call graph for this function:

Here is the caller graph for this function:

forward_srv_room_message()

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

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

Parameters

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

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

{
  GNUNET_assert((room) && (tunnel));
 
  if (!message)
    return;
 
  struct GNUNET_MESSENGER_ClosureSendRoom closure;
  struct GNUNET_HashCode message_hash;
 
  GNUNET_memcpy(&message_hash, hash, sizeof(struct GNUNET_HashCode));
 
  closure.room = room;
  closure.handle = NULL;
  closure.exclude = tunnel;
  closure.message = message;
  closure.hash = &message_hash;
  closure.packed = GNUNET_YES;
 
  GNUNET_CONTAINER_multipeermap_iterate (room->tunnels, iterate_send_room_message, &closure);
}

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

Referenced by handle_tunnel_message().

Here is the call graph for this function:

Here is the caller graph for this function:

check_srv_room_peer_status()

void check_srv_room_peer_status	(	struct GNUNET_MESSENGER_SrvRoom *	room,
		struct GNUNET_MESSENGER_SrvTunnel *	tunnel
	)

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

Parameters

[in,out]	room	Room
[in,out]	tunnel	Tunnel

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

{
  if (!room->peer_message)
    return;
 
  struct GNUNET_MESSENGER_MessageStore *message_store = get_srv_room_message_store(room);
 
  const struct GNUNET_MESSENGER_Message *message = get_store_message(message_store, room->peer_message);
 
  if (!message)
  {
    GNUNET_free(room->peer_message);
    room->peer_message = NULL;
    return;
  }
 
  struct GNUNET_MESSENGER_MemberStore *member_store = get_srv_room_member_store(room);
  struct GNUNET_MESSENGER_Member *member = get_store_member_of(member_store, message);
 
  if (!member)
    goto resend_peer_message;
 
  struct GNUNET_MESSENGER_MemberSession *session = get_member_session_of(member, message, room->peer_message);
 
  if (GNUNET_YES == is_member_session_closed(session))
    goto resend_peer_message;
 
  if (tunnel)
    forward_tunnel_message(tunnel, message, room->peer_message);
 
  return;
 
resend_peer_message:
  if (room->host)
    send_srv_room_message (room, room->host, create_message_peer (room->service));
}

References create_message_peer(), forward_tunnel_message(), get_member_session_of(), get_srv_room_member_store(), get_srv_room_message_store(), get_store_member_of(), get_store_message(), GNUNET_free, GNUNET_YES, GNUNET_MESSENGER_SrvRoom::host, is_member_session_closed(), GNUNET_MESSENGER_MemberSession::member, GNUNET_MESSENGER_SrvRoom::peer_message, GNUNET_MESSENGER_MemberStore::room, send_srv_room_message(), and GNUNET_MESSENGER_SrvRoom::service.

Referenced by recv_message_info(), and send_message_join().

Here is the call graph for this function:

Here is the caller graph for this function:

merge_srv_room_last_messages()

void merge_srv_room_last_messages	(	struct GNUNET_MESSENGER_SrvRoom *	room,
		struct GNUNET_MESSENGER_SrvHandle *	handle
	)

Reduces all current forks inside of the message history of a room to one remaining last message by merging them down.

All merge messages will be sent from a given handle.

Parameters

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

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

{
  GNUNET_assert(room);
 
  if (!handle)
    return;
 
  const struct GNUNET_HashCode *hash;
 
merge_next:
  hash = get_message_state_merge_hash (&(room->state));
 
  if (!hash)
    return;
 
  send_srv_room_message (room, handle, create_message_merge (hash));
  goto merge_next;
}

References create_message_merge(), get_message_state_merge_hash(), GNUNET_assert, handle, send_srv_room_message(), and GNUNET_MESSENGER_SrvRoom::state.

Referenced by send_srv_room_message().

Here is the call graph for this function:

Here is the caller graph for this function:

callback_room_deletion()

void callback_room_deletion	(	struct GNUNET_MESSENGER_SrvRoom *	room,
		const struct GNUNET_HashCode *	hash
	)

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

{
  if (GNUNET_OK != delete_store_message (get_srv_room_message_store(room), hash))
  {
    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Deletion of message failed! (%s)\n", GNUNET_h2s(hash));
    return;
  }
}

References delete_store_message(), get_srv_room_message_store(), GNUNET_ERROR_TYPE_WARNING, GNUNET_h2s(), GNUNET_log, and GNUNET_OK.

Referenced by callback_store_operation().

Here is the call graph for this function:

Here is the caller graph for this function:

callback_room_merge()

void callback_room_merge	(	struct GNUNET_MESSENGER_SrvRoom *	room,
		const struct GNUNET_HashCode *	hash
	)

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

{
  if (!room->host)
    return;
 
  send_srv_room_message (room, room->host, create_message_merge (hash));
}

References create_message_merge(), GNUNET_MESSENGER_SrvRoom::host, and send_srv_room_message().

Referenced by callback_store_operation().

Here is the call graph for this function:

Here is the caller graph for this function:

delete_srv_room_message()

int delete_srv_room_message	(	struct GNUNET_MESSENGER_SrvRoom *	room,
		struct GNUNET_MESSENGER_MemberSession *	session,
		const struct GNUNET_HashCode *	hash,
		const struct GNUNET_TIME_Relative	delay
	)

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

Parameters

[in,out]	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 669 of file gnunet-service-messenger_room.c.

{
  GNUNET_assert((room) && (session) && (hash));
 
  const struct GNUNET_TIME_Relative forever = GNUNET_TIME_relative_get_forever_ ();
 
  if (0 == GNUNET_memcmp(&forever, &delay))
  {
    GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Deletion is delayed forever: operation is impossible!\n");
    return GNUNET_SYSERR;
  }
 
  struct GNUNET_MESSENGER_MessageStore *message_store = get_srv_room_message_store(room);
 
  const struct GNUNET_MESSENGER_Message *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 = 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(), delay, get_member_session_id(), get_srv_room_message_store(), get_srv_room_operation_store(), get_store_message(), GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_h2s(), GNUNET_log, GNUNET_memcmp, GNUNET_MESSENGER_OP_DELETE, GNUNET_NO, GNUNET_OK, GNUNET_sh2s(), GNUNET_SYSERR, GNUNET_TIME_relative_get_forever_(), GNUNET_YES, GNUNET_MESSENGER_OperationStore::room, and use_store_operation().

Referenced by handle_message_delete().

Here is the call graph for this function:

Here is the caller graph for this function:

get_srv_room_cadet()

struct GNUNET_CADET_Handle* get_srv_room_cadet

(

struct GNUNET_MESSENGER_SrvRoom *

room

)

Returns the CADET handle from a rooms service.

Parameters

[in,out]

room

Room

Returns

CADET handle

Definition at line 711 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 719 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(), connect_tunnel(), get_member_store_key(), get_room_data_subdir(), handle_message_join(), handle_message_leave(), join_room(), join_room_locally(), notify_srv_handle_message(), open_srv_room(), pack_srv_room_message(), send_message_id(), send_srv_room_message(), 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 727 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(), peer, GNUNET_MESSENGER_SrvTunnel::room, and GNUNET_MESSENGER_SrvRoom::tunnels.

Here is the call graph for this function:

request_room_message_step()

static int request_room_message_step ( struct GNUNET_MESSENGER_SrvRoom *  room, const struct GNUNET_HashCode *  hash, const struct GNUNET_MESSENGER_MemberSession *  session, GNUNET_MESSENGER_MessageRequestCallback  callback, void *  cls  )

static

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

{
  struct GNUNET_MESSENGER_MessageStore *message_store = get_srv_room_message_store(room);
 
  const struct GNUNET_MESSENGER_MessageLink *link = get_store_message_link(
      message_store, hash, GNUNET_YES
  );
 
  if (!link)
    goto forward;
 
  int 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:
  if (GNUNET_YES != check_member_session_history(session, hash, GNUNET_NO))
    return GNUNET_YES;
 
  const struct GNUNET_MESSENGER_Message *message = get_store_message(message_store, hash);
 
  if (!message)
    return GNUNET_NO;
 
  if (callback)
    callback (cls, room, message, hash);
 
  return GNUNET_YES;
}

References check_member_session_history(), GNUNET_MESSENGER_MessageLink::first, forward, get_srv_room_message_store(), get_store_message(), get_store_message_link(), GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_MessageLink::multiple, result, and GNUNET_MESSENGER_MessageLink::second.

Referenced by request_srv_room_message().

Here is the call graph for this function:

Here is the caller graph for this function:

request_srv_room_message()

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

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

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

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

Parameters

[in,out]	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 775 of file gnunet-service-messenger_room.c.

{
  GNUNET_assert((room) && (hash));
 
  int 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:

callback_room_disconnect()

void callback_room_disconnect	(	struct GNUNET_MESSENGER_SrvRoom *	room,
		void *	cls
	)

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

{
  struct GNUNET_MESSENGER_SrvTunnel *tunnel = cls;
 
  if (!room->host)
    return;
 
  struct GNUNET_PeerIdentity identity;
  get_tunnel_peer_identity(tunnel, &identity);
 
  if ((GNUNET_YES != GNUNET_CONTAINER_multipeermap_remove (room->tunnels, &identity, tunnel)) ||
      (GNUNET_YES == GNUNET_CONTAINER_multipeermap_contains(room->tunnels, &identity)))
    return;
 
  if (GNUNET_YES == contains_list_tunnels (&(room->basement), &identity))
    send_srv_room_message (room, room->host, create_message_miss (&identity));
}

References GNUNET_MESSENGER_SrvRoom::basement, contains_list_tunnels(), create_message_miss(), get_tunnel_peer_identity(), GNUNET_CONTAINER_multipeermap_contains(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_YES, GNUNET_MESSENGER_SrvRoom::host, identity, GNUNET_MESSENGER_SrvTunnel::room, send_srv_room_message(), and GNUNET_MESSENGER_SrvRoom::tunnels.

Referenced by callback_tunnel_disconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

callback_verify_room_message()

int callback_verify_room_message	(	struct GNUNET_MESSENGER_SrvRoom *	room,
		void *	cls,
		struct GNUNET_MESSENGER_Message *	message,
		struct GNUNET_HashCode *	hash
	)

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

{
  if (GNUNET_MESSENGER_KIND_UNKNOWN == message->header.kind)
  {
    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Message error: Kind is unknown! (%d)\n", message->header.kind);
    return GNUNET_SYSERR;
  }
 
  struct GNUNET_MESSENGER_MessageStore *message_store = get_srv_room_message_store(room);
 
  const struct GNUNET_MESSENGER_Message *previous = get_store_message(message_store, &(message->header.previous));
 
  if (!previous)
    goto skip_time_comparison;
 
  struct GNUNET_TIME_Absolute timestamp = GNUNET_TIME_absolute_ntoh(message->header.timestamp);
  struct GNUNET_TIME_Absolute last = GNUNET_TIME_absolute_ntoh(previous->header.timestamp);
 
  if (GNUNET_TIME_relative_get_zero_().rel_value_us != GNUNET_TIME_absolute_get_difference(timestamp, last).rel_value_us)
  {
    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Message error: Timestamp does not check out!\n");
    return GNUNET_SYSERR;
  }
 
skip_time_comparison:
  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Receiving message of kind: %s!\n",
             GNUNET_MESSENGER_name_of_kind(message->header.kind));
 
  return GNUNET_OK;
}

References get_srv_room_message_store(), get_store_message(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_MESSENGER_KIND_UNKNOWN, GNUNET_MESSENGER_name_of_kind(), GNUNET_OK, GNUNET_SYSERR, GNUNET_TIME_absolute_get_difference(), GNUNET_TIME_absolute_ntoh(), GNUNET_TIME_relative_get_zero_(), GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_MessageHeader::previous, and GNUNET_MESSENGER_MessageHeader::timestamp.

Referenced by check_tunnel_message().

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_IDENTITY_PublicKey *	public_key,
		const struct GNUNET_ShortHashCode *	member_id,
		struct GNUNET_TIME_Absolute	timestamp
	)

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

Parameters

[in,out]	room	Room
[in]	public_key	Public key of EGO
[in]	member_id	Member ID
[in]	timestamp	Timestamp

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

{
  GNUNET_assert ((room) && (public_key) && (member_id));
 
  struct GNUNET_MESSENGER_MemberStore *member_store = get_srv_room_member_store(room);
  struct GNUNET_MESSENGER_Member *member = get_store_member(member_store, member_id);
 
  if ((!member) || (1 >= GNUNET_CONTAINER_multihashmap_size(member->sessions)))
    return;
 
  struct GNUNET_MESSENGER_ListHandles *handles = &(room->service->handles);
  struct GNUNET_MESSENGER_ListHandle* element;
 
  for (element = handles->head; element; element = element->next)
  {
    if (0 != GNUNET_memcmp(member_id, get_srv_handle_member_id(element->handle, get_srv_room_key(room))))
      continue;
 
    if (0 == GNUNET_memcmp(public_key, &(get_srv_handle_ego(element->handle)->pub)))
      continue;
 
    struct GNUNET_MESSENGER_MemberSession *session = get_member_session(member, &(get_srv_handle_ego(element->handle)->pub));
 
    if (!session)
      continue;
 
    struct GNUNET_TIME_Absolute 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);
 
    send_srv_room_message(room, element->handle, create_message_id(&random_id));
  }
}

References create_message_id(), generate_free_member_id(), get_member_session(), get_member_session_start(), get_srv_handle_ego(), 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_TIME_absolute_get_difference(), GNUNET_TIME_relative_get_zero_(), GNUNET_MESSENGER_ListHandle::handle, GNUNET_MESSENGER_Service::handles, GNUNET_MESSENGER_ListHandles::head, GNUNET_MESSENGER_MemberSession::member, GNUNET_MESSENGER_MemberStore::members, GNUNET_MESSENGER_ListHandle::next, GNUNET_MESSENGER_Ego::pub, GNUNET_MESSENGER_MemberStore::room, send_srv_room_message(), GNUNET_MESSENGER_SrvRoom::service, GNUNET_MESSENGER_Member::sessions, and start.

Referenced by handle_message_id(), and handle_message_join().

Here is the call graph for this function:

Here is the caller graph for this function:

rebuild_srv_room_basement_structure()

void rebuild_srv_room_basement_structure

(

struct GNUNET_MESSENGER_SrvRoom *

room

)

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

Parameters

[in,out]

room

Room

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

{
  GNUNET_assert(room);
 
  struct GNUNET_PeerIdentity peer;
  size_t src;
 
  if ((GNUNET_OK != get_service_peer_identity (room->service, &peer)) ||
      (!find_list_tunnels (&(room->basement), &peer, &src)))
    return;
 
  size_t count = count_of_tunnels (&(room->basement));
 
  struct GNUNET_MESSENGER_ListTunnel *element = room->basement.head;
  struct GNUNET_MESSENGER_SrvTunnel *tunnel;
 
  size_t dst = 0;
 
  while (element)
  {
    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, connect_tunnel(), count_of_tunnels(), disconnect_tunnel(), find_list_tunnels(), get_service_peer_identity(), GNUNET_assert, GNUNET_CONTAINER_multipeermap_get(), GNUNET_OK, GNUNET_PEER_resolve(), GNUNET_SYSERR, GNUNET_YES, GNUNET_MESSENGER_ListTunnels::head, GNUNET_MESSENGER_ListTunnel::next, GNUNET_MESSENGER_ListTunnel::peer, peer, remove_from_list_tunnels(), required_connection_between(), GNUNET_MESSENGER_SrvTunnel::room, GNUNET_MESSENGER_SrvRoom::service, and GNUNET_MESSENGER_SrvRoom::tunnels.

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:

iterate_update_member_sessions()

static int iterate_update_member_sessions ( void *  cls, const struct GNUNET_IDENTITY_PublicKey *  public_key, struct GNUNET_MESSENGER_MemberSession *  session  )

static

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

{
  struct GNUNET_MESSENGER_MemberUpdate *update = cls;
 
  update_member_session_history(session, update->message, update->hash);
 
  if (GNUNET_YES == is_member_session_completed(session))
  {
    struct GNUNET_MESSENGER_MemberSessionCompletion *element = GNUNET_new(
        struct GNUNET_MESSENGER_MemberSessionCompletion
    );
 
    element->session = session;
 
    GNUNET_CONTAINER_DLL_insert_tail(update->head, update->tail, element);
  }
 
  return GNUNET_YES;
}

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

Referenced by callback_room_handle_message().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_room_member_session()

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

static

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

{
  GNUNET_assert ((room) && (session));
 
  remove_member_session (session->member, session);
 
  const struct GNUNET_IDENTITY_PublicKey *public_key = get_member_session_public_key(session);
 
  struct GNUNET_HashCode hash;
  GNUNET_CRYPTO_hash(public_key, sizeof(*public_key), &hash);
 
  char *room_dir;
  get_room_data_subdir (room, &room_dir);
 
  char* session_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(), GNUNET_asprintf(), GNUNET_assert, GNUNET_CRYPTO_hash(), GNUNET_DISK_directory_remove(), GNUNET_free, GNUNET_h2s(), GNUNET_sh2s(), GNUNET_MESSENGER_MemberSession::member, remove_member_session(), and GNUNET_MESSENGER_MemberSessionCompletion::session.

Referenced by callback_room_handle_message().

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

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

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 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:

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

{
  GNUNET_assert(room);
 
  char *room_dir;
  get_room_data_subdir (room, &room_dir);
 
  if (GNUNET_YES == GNUNET_DISK_directory_test (room_dir, GNUNET_YES))
  {
    load_member_store (get_srv_room_member_store(room), room_dir);
    load_message_store (get_srv_room_message_store(room), room_dir);
    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(), GNUNET_asprintf(), GNUNET_assert, GNUNET_DISK_directory_test(), GNUNET_free, GNUNET_YES, load_list_tunnels(), load_member_store(), load_message_state(), load_message_store(), load_operation_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 1203 of file gnunet-service-messenger_room.c.

{
  GNUNET_assert(room);
 
  char *room_dir;
  get_room_data_subdir (room, &room_dir);
 
  if ((GNUNET_YES == GNUNET_DISK_directory_test (room_dir, GNUNET_NO)) ||
      (GNUNET_OK == GNUNET_DISK_directory_create (room_dir)))
  {
    save_member_store(get_srv_room_member_store(room), room_dir);
    save_message_store (get_srv_room_message_store(room), room_dir);
    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(), GNUNET_asprintf(), GNUNET_assert, GNUNET_DISK_directory_create(), GNUNET_DISK_directory_test(), GNUNET_free, GNUNET_NO, GNUNET_OK, GNUNET_YES, save_list_tunnels(), save_member_store(), save_message_state(), save_message_store(), save_operation_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 1230 of file gnunet-service-messenger_room.c.

{
  GNUNET_assert(room);
 
  char *room_dir;
  get_room_data_subdir (room, &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_free, and GNUNET_YES.

Referenced by destroy_srv_room().

Here is the call graph for this function:

Here is the caller graph for this function: