#include "platform.h"
#include "gnunet_messenger_service.h"
#include "gnunet-service-messenger.h"
#include "gnunet-service-messenger_handle.h"
#include "gnunet-service-messenger_room.h"
#include "messenger_api_util.h"

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

Data Structures
struct	GNUNET_MESSENGER_NextMemberId

Functions
struct GNUNET_MESSENGER_SrvHandle *	create_srv_handle (struct GNUNET_MESSENGER_Service service, struct GNUNET_MQ_Handle mq)
	Creates and allocates a new handle related to a service and using a given mq (message queue). More...

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

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

void	destroy_srv_handle (struct GNUNET_MESSENGER_SrvHandle *handle)
	Destroys a handle and frees its memory fully. More...

void	set_srv_handle_key (struct GNUNET_MESSENGER_SrvHandle handle, const struct GNUNET_CRYPTO_PublicKey key)
	Sets the public key of a given handle. More...

const struct GNUNET_CRYPTO_PublicKey *	get_srv_handle_key (const struct GNUNET_MESSENGER_SrvHandle *handle)
	Returns the public key of a given handle. More...

void	get_srv_handle_data_subdir (const struct GNUNET_MESSENGER_SrvHandle handle, const char name, char **dir)
	Writes the path of the directory for a given handle using a specific name to the parameter dir. More...

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

const struct GNUNET_ShortHashCode *	get_srv_handle_member_id (const struct GNUNET_MESSENGER_SrvHandle handle, const struct GNUNET_HashCode key)
	Returns the member id of a given handle in a specific room. More...

enum GNUNET_GenericReturnValue	change_srv_handle_member_id (struct GNUNET_MESSENGER_SrvHandle handle, const struct GNUNET_HashCode key, const struct GNUNET_ShortHashCode *unique_id)
	Changes the member id of a given handle in a specific room to match a unique_id and returns GNUNET_OK on success. More...

enum GNUNET_GenericReturnValue	open_srv_handle_room (struct GNUNET_MESSENGER_SrvHandle handle, const struct GNUNET_HashCode key)
	Makes a given handle a member of the room using a specific key and opens the room from the handles service. More...

enum GNUNET_GenericReturnValue	entry_srv_handle_room (struct GNUNET_MESSENGER_SrvHandle handle, const struct GNUNET_PeerIdentity door, const struct GNUNET_HashCode *key)
	Makes a given handle a member of the room using a specific key and enters the room through a tunnel to a peer identified by a given door (peer identity). More...

enum GNUNET_GenericReturnValue	close_srv_handle_room (struct GNUNET_MESSENGER_SrvHandle handle, const struct GNUNET_HashCode key)
	Removes the membership of the room using a specific key and closes it if no other handle from this service is still a member of it. More...

enum GNUNET_GenericReturnValue	is_srv_handle_routing (const struct GNUNET_MESSENGER_SrvHandle handle, const struct GNUNET_HashCode key)
	Returns whether a given handle has enabled routing for a room using a specific key by opening that room. More...

void	sync_srv_handle_messages (struct GNUNET_MESSENGER_SrvHandle handle, const struct GNUNET_HashCode key, const struct GNUNET_HashCode prev, struct GNUNET_HashCode hash)
	Returns the latest merged hash from a room of a given handle using a specific key and the handles own latest known hash of a message. More...

enum GNUNET_GenericReturnValue	send_srv_handle_message (struct GNUNET_MESSENGER_SrvHandle handle, const struct GNUNET_HashCode key, const struct GNUNET_MESSENGER_Message *message)
	Sends a message from a given handle to the room using a specific key. More...

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

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

void	notify_srv_handle_message (struct GNUNET_MESSENGER_SrvHandle handle, struct GNUNET_MESSENGER_SrvRoom room, const struct GNUNET_MESSENGER_SenderSession session, const struct GNUNET_MESSENGER_Message message, const struct GNUNET_HashCode *hash, enum GNUNET_GenericReturnValue recent)
	Notifies the handle that a new message was received or sent. More...

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

static void	task_notify_srv_handle_member_id (void *cls)

void	notify_srv_handle_member_id (struct GNUNET_MESSENGER_SrvHandle handle, struct GNUNET_MESSENGER_SrvRoom room, const struct GNUNET_ShortHashCode *member_id, enum GNUNET_GenericReturnValue reset)
	Notifies the handle that a new member id needs to be used. More...

Function Documentation

◆ create_srv_handle()

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

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

Parameters

[in,out]	service	MESSENGER Service
[in,out]	mq	Message queue

Returns: New handle

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

{
  struct GNUNET_MESSENGER_SrvHandle *handle;
 
  GNUNET_assert ((service) && (mq));
 
  handle = GNUNET_new (struct GNUNET_MESSENGER_SrvHandle);
 
  handle->service = service;
  handle->mq = mq;
 
  handle->member_ids = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
  handle->next_ids = GNUNET_CONTAINER_multihashmap_create (4, GNUNET_NO);
  handle->routing = GNUNET_CONTAINER_multihashmap_create (4, GNUNET_NO);
 
  handle->notify = NULL;
 
  return handle;
}

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

Referenced by add_service_handle().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ iterate_close_rooms()

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

static

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

{
  struct GNUNET_MESSENGER_SrvHandle *handle;
 
  GNUNET_assert ((cls) && (key));
 
  handle = cls;
 
  close_service_room (handle->service, handle, key, GNUNET_NO);
  return GNUNET_YES;
}

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

Referenced by destroy_srv_handle().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ iterate_free_values()

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

static

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

{
  GNUNET_assert (value);
 
  GNUNET_free (value);
  return GNUNET_YES;
}

References GNUNET_assert, GNUNET_free, GNUNET_YES, and value.

Referenced by close_srv_handle_room(), and destroy_srv_handle().

Here is the caller graph for this function:

◆ destroy_srv_handle()

void destroy_srv_handle ( struct GNUNET_MESSENGER_SrvHandle * handle )

Destroys a handle and frees its memory fully.

Parameters

[in,out] handle Handle

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

{
  GNUNET_assert (handle);
 
  GNUNET_CONTAINER_multihashmap_iterate (handle->routing,
                                         iterate_close_rooms, handle);
 
  if (handle->notify)
    GNUNET_SCHEDULER_cancel (handle->notify);
 
  GNUNET_CONTAINER_multihashmap_iterate (handle->next_ids,
                                         iterate_free_values, NULL);
  GNUNET_CONTAINER_multihashmap_iterate (handle->member_ids,
                                         iterate_free_values, NULL);
 
  GNUNET_CONTAINER_multihashmap_destroy (handle->next_ids);
  GNUNET_CONTAINER_multihashmap_destroy (handle->member_ids);
  GNUNET_CONTAINER_multihashmap_destroy (handle->routing);
 
  GNUNET_free (handle);
}

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

Referenced by clear_list_handles(), and remove_service_handle().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_srv_handle_key()

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

Sets the public key of a given handle.

Parameters

[out]	handle	Handle
[in]	key	Public key

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

{
  GNUNET_assert (handle);
 
  if ((handle->key) && (! key))
  {
    GNUNET_free (handle->key);
    handle->key = NULL;
  }
  else if (! handle->key)
    handle->key = GNUNET_new (struct GNUNET_CRYPTO_PublicKey);
 
  if (key)
    memcpy (handle->key, key, sizeof(struct GNUNET_CRYPTO_PublicKey));
}

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

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

Here is the caller graph for this function:

◆ get_srv_handle_key()

const struct GNUNET_CRYPTO_PublicKey * get_srv_handle_key ( const struct GNUNET_MESSENGER_SrvHandle * handle )

Returns the public key of a given handle.

Parameters

[in] handle Handle

Returns: Public key of handle

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

{
  GNUNET_assert (handle);
 
  return handle->key;
}

References GNUNET_assert, and handle.

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

Here is the caller graph for this function:

◆ get_srv_handle_data_subdir()

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

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

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

Parameters

[in]	handle	Handle
[in]	name	Potential name of the handle
[out]	dir	Path to store data

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

{
  GNUNET_assert ((handle) && (dir));
 
  if (name)
    GNUNET_asprintf (dir, "%s%s%c%s%c", handle->service->dir, "identities",
                     DIR_SEPARATOR, name, DIR_SEPARATOR);
  else
    GNUNET_asprintf (dir, "%s%s%c", handle->service->dir, "anonymous",
                     DIR_SEPARATOR);
}

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

Here is the call graph for this function:

◆ create_handle_member_id()

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

static

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

{
  struct GNUNET_ShortHashCode *random_id;
 
  GNUNET_assert ((handle) && (key));
 
  random_id = GNUNET_new (struct GNUNET_ShortHashCode);
 
  if (! random_id)
    return GNUNET_NO;
 
  generate_free_member_id (random_id, NULL);
 
  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (handle->member_ids, key,
                                                      random_id,
                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
  {
    GNUNET_free (random_id);
    return GNUNET_NO;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Created a new member id (%s) for room: %s\n", GNUNET_sh2s (
                random_id),
              GNUNET_h2s (key));
 
  return GNUNET_YES;
}

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

Referenced by entry_srv_handle_room(), and open_srv_handle_room().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_srv_handle_member_id()

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

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

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

Parameters

[in]	handle	Handle
[in]	key	Key of a room

Returns: Member id or NULL

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

{
  GNUNET_assert ((handle) && (key));
 
  return GNUNET_CONTAINER_multihashmap_get (handle->member_ids, key);
}

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ change_srv_handle_member_id()

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

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

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

Parameters

[in,out]	handle	Handle
[in]	key	Key of a room
[in]	unique_id	Unique member id

Returns: GNUNET_OK on success, otherwise GNUNET_SYSERR

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

{
  struct GNUNET_ShortHashCode *member_id;
 
  GNUNET_assert ((handle) && (key) && (unique_id));
 
  member_id = GNUNET_CONTAINER_multihashmap_get (handle->member_ids, key);
 
  if (! member_id)
  {
    member_id = GNUNET_new (struct GNUNET_ShortHashCode);
    GNUNET_memcpy (member_id, unique_id, sizeof(*member_id));
 
    if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (handle->member_ids, key,
                                                        member_id,
                                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
    {
      GNUNET_free (member_id);
      return GNUNET_SYSERR;
    }
  }
 
  if (0 == GNUNET_memcmp (unique_id, member_id))
    return GNUNET_OK;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Change a member id (%s) for room (%s).\n", GNUNET_sh2s (
                member_id),
              GNUNET_h2s (key));
 
  GNUNET_memcpy (member_id, unique_id, sizeof(*unique_id));
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Member id changed to (%s).\n",
              GNUNET_sh2s (unique_id));
  return GNUNET_OK;
}

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ open_srv_handle_room()

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

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

Parameters

[in,out]	handle	Handle
[in]	key	Key of a room

Returns: GNUNET_YES on success, otherwise GNUNET_NO

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

{
  GNUNET_assert ((handle) && (key));
 
  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (handle->routing,
                                                      key,
                                                      NULL,
                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE))
 
    return GNUNET_NO;
 
  if ((! get_srv_handle_member_id (handle, key)) &&
      (GNUNET_YES != create_handle_member_id (handle,
                                              key)))
    return GNUNET_NO;
 
  return open_service_room (handle->service, handle, key);
}

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

Referenced by handle_room_open().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entry_srv_handle_room()

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

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

Parameters

[in,out]	handle	Handle
[in]	door	Peer identity
[in]	key	Key of a room

Returns: GNUNET_YES on success, otherwise GNUNET_NO

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

{
  GNUNET_assert ((handle) && (door) && (key));
 
  if ((! get_srv_handle_member_id (handle, key)) && (GNUNET_YES !=
                                                     create_handle_member_id (
                                                       handle, key)))
    return GNUNET_NO;
 
  return entry_service_room (handle->service, handle, door, key);
}

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

Referenced by handle_room_entry().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ close_srv_handle_room()

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

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

Parameters

[in,out]	handle	Handle
[in]	key	Key of a room

Returns: GNUNET_YES on success, otherwise GNUNET_NO

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

{
  GNUNET_assert ((handle) && (key));
 
  GNUNET_CONTAINER_multihashmap_get_multiple (handle->next_ids, key,
                                              iterate_free_values, NULL);
  GNUNET_CONTAINER_multihashmap_remove_all (handle->next_ids, key);
 
  if ((handle->notify) && (0 == GNUNET_CONTAINER_multihashmap_size (
                             handle->next_ids)))
  {
    GNUNET_SCHEDULER_cancel (handle->notify);
    handle->notify = NULL;
  }
 
  if (! get_srv_handle_member_id (handle, key))
    return GNUNET_NO;
 
  {
    enum GNUNET_GenericReturnValue result;
    result = close_service_room (handle->service, handle, key, GNUNET_YES);
 
    if (GNUNET_YES != result)
      return result;
 
    GNUNET_CONTAINER_multihashmap_remove_all (handle->routing, key);
    return result;
  }
}

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

Referenced by handle_room_close().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_srv_handle_routing()

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

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

Parameters

[in]	handle	Handle
[in]	key	Key of a room

Returns: GNUNET_YES is routing is enabled, otherwise GNUNET_NO

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

{
  GNUNET_assert ((handle) && (key));
 
  return GNUNET_CONTAINER_multihashmap_contains (handle->routing, key);
}

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

Referenced by find_list_handle_by_member(), and rebuild_srv_room_basement_structure().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sync_srv_handle_messages()

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

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

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

Parameters

[in,out]	handle	Handle
[in]	key	Key of a room
[in]	prev	Known hash of a message
[out]	hash	Hash of the latest merged message in a room available to the handle

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

{
  struct GNUNET_MESSENGER_SrvRoom *room;
 
  GNUNET_assert ((handle) && (key) && (prev) && (hash));
 
  room = get_service_room (handle->service, key);
 
  if ((! room) || (! get_srv_handle_member_id (handle, key)))
  {
    GNUNET_memcpy (hash, prev, sizeof(*hash));
    return;
  }
 
  merge_srv_room_last_messages (room, handle);
  get_message_state_chain_hash (&(room->state), hash);
}

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_srv_handle_message()

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

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

Parameters

[in,out]	handle	Handle
[in]	key	Key of a room
[in]	message	Message

Returns: GNUNET_YES on success, GNUNET_NO or GNUNET_SYSERR otherwise.

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

{
  const struct GNUNET_ShortHashCode *id;
  struct GNUNET_MESSENGER_SrvRoom *room;
 
  GNUNET_assert ((handle) && (key) && (message));
 
  id = get_srv_handle_member_id (handle, key);
 
  if (! id)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "It is required to be a member of a room to send messages!\n");
    return GNUNET_NO;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending message with member id: %s\n",
              GNUNET_sh2s (id));
 
  if (0 != GNUNET_memcmp (id, &(message->header.sender_id)))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Member id does not match with handle!\n");
    return GNUNET_NO;
  }
 
  room = get_service_room (handle->service, key);
 
  if (! room)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "The room (%s) is unknown!\n",
                GNUNET_h2s (key));
    return GNUNET_NO;
  }
 
  {
    struct GNUNET_MESSENGER_Message *msg;
    msg = copy_message (message);
 
    if (! msg)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Copying message failed!\n");
      return GNUNET_NO;
    }
    
    return send_srv_room_message (room, handle, msg);
  }
}

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

Referenced by handle_send_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_next_member_session_context()

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

static

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

{
  GNUNET_assert (session);
 
  if (session->next)
    return get_next_member_session_context (session->next);
  else
    return get_member_session_context (session);
}

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

Referenced by get_next_member_session_context(), and notify_srv_handle_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_handle_member_session()

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

static

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

{
  const struct GNUNET_ShortHashCode *id;
  const struct GNUNET_CRYPTO_PublicKey *pubkey;
 
  GNUNET_assert ((handle) && (room) && (key) && (handle->service));
 
  id = get_srv_handle_member_id (handle, key);
 
  if (! id)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Handle is missing a member id for its member session! (%s)\n",
                GNUNET_h2s (key));
    return NULL;
  }
 
  pubkey = get_srv_handle_key (handle);
 
  if (! pubkey)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Handle is missing a public key for its member session! (%s)\n",
                GNUNET_h2s (key));
    return NULL;
  }
 
  {
    struct GNUNET_MESSENGER_MemberStore *store;
    struct GNUNET_MESSENGER_Member *member;
    
    store = get_srv_room_member_store (room);
    member = get_store_member (store, id);
 
    return get_member_session (member, pubkey);
  }
}

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

Referenced by notify_srv_handle_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ notify_srv_handle_message()

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

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

Parameters

[in,out]	handle	Handle
[in]	room	Room of the message
[in]	session	Sender session
[in]	message	Message
[in]	hash	Hash of message
[in]	recent	Whether the message was recently handled

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

{
  const struct GNUNET_HashCode *key;
  const struct GNUNET_ShortHashCode *id;
  const struct GNUNET_HashCode *context;
  struct GNUNET_TIME_Absolute timestamp;
  const struct GNUNET_ShortHashCode *discourse;
  struct GNUNET_MESSENGER_Subscription *subscription;
  struct GNUNET_HashCode sender;
 
  GNUNET_assert ((handle) && (room) && (session) && (message) && (hash));
 
  key = get_srv_room_key (room);
  id = get_srv_handle_member_id (handle, key);
 
  if ((! handle->mq) || (! id))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Notifying client about message requires membership!\n");
    return;
  }
 
  context = NULL;
 
  if (GNUNET_MESSENGER_KIND_TALK != message->header.kind)
    goto skip_message_filter;
 
  timestamp = GNUNET_TIME_absolute_ntoh(message->header.timestamp);
  discourse = &(message->body.talk.discourse);
 
  {
    struct GNUNET_MESSENGER_MemberStore *member_store;
    struct GNUNET_MESSENGER_Member *member;
 
    member_store = get_srv_room_member_store (room);
 
    if (! member_store)
      return;
 
    member = get_store_member (member_store, id);
 
    if (! member)
      return;
 
    subscription = get_member_subscription(member, discourse);
  }
  
  if ((! subscription) ||
      (GNUNET_YES != has_subscription_of_timestamp(subscription, timestamp)))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, 
                "Dropping message for client outside of subscription: %s\n",
                GNUNET_h2s (hash));
    return;
  }
  
skip_message_filter:
  if (GNUNET_YES == is_peer_message (message))
  {
    const struct GNUNET_PeerIdentity *identity = session->peer;
    GNUNET_CRYPTO_hash (identity, sizeof(*identity), &sender);
 
    context = &sender;
  }
  else
  {
    const struct GNUNET_CRYPTO_PublicKey *pubkey;
    pubkey = get_member_session_public_key (session->member);
    GNUNET_CRYPTO_hash (pubkey, sizeof(*pubkey), &sender);
 
    context = get_next_member_session_context (session->member);
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Notifying client about message: %s (%s)\n",
              GNUNET_h2s (hash), GNUNET_MESSENGER_name_of_kind (
                message->header.kind));
 
  {
    struct GNUNET_MESSENGER_RecvMessage *msg;
    struct GNUNET_MQ_Envelope *env;
    uint16_t length;
    char *buffer;
 
    length = get_message_size (message, GNUNET_YES);
 
    env = GNUNET_MQ_msg_extra (msg, length,
                              GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_RECV_MESSAGE);
 
    GNUNET_memcpy (&(msg->key), key, sizeof(msg->key));
    GNUNET_memcpy (&(msg->sender), &sender, sizeof(msg->sender));
    GNUNET_memcpy (&(msg->context), context, sizeof(msg->context));
    GNUNET_memcpy (&(msg->hash), hash, sizeof(msg->hash));
 
    msg->flags = (uint32_t) GNUNET_MESSENGER_FLAG_NONE;
 
    if (GNUNET_YES == is_peer_message (message))
      msg->flags |= (uint32_t) GNUNET_MESSENGER_FLAG_PEER;
    else if (get_handle_member_session (handle, room, key) == session->member)
      msg->flags |= (uint32_t) GNUNET_MESSENGER_FLAG_SENT;
 
    if (GNUNET_YES == recent)
      msg->flags |= (uint32_t) GNUNET_MESSENGER_FLAG_RECENT;
 
    buffer = ((char*) msg) + sizeof(*msg);
    encode_message (message, length, buffer, GNUNET_YES);
 
    GNUNET_MQ_send (handle->mq, env);
  }
}

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ iterate_next_member_ids()

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

static

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

{
  struct GNUNET_MESSENGER_SrvHandle *handle;
  struct GNUNET_MESSENGER_NextMemberId *next;
 
  GNUNET_assert ((cls) && (value));
 
  handle = cls;
  next = value;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Notifying client about next member id: %s (%s)\n",
              GNUNET_sh2s (&(next->id)), GNUNET_h2s (key));
 
  {
    struct GNUNET_MESSENGER_MemberMessage *msg;
    struct GNUNET_MQ_Envelope *env;
 
    env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_MEMBER_ID);
 
    GNUNET_memcpy (&(msg->key), key, sizeof(*key));
    GNUNET_memcpy (&(msg->id), &(next->id), sizeof(next->id));
    msg->reset = (uint32_t) next->reset;
 
    GNUNET_MQ_send (handle->mq, env);
  }
 
  GNUNET_free (next);
  return GNUNET_YES;
}

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

Referenced by task_notify_srv_handle_member_id().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ task_notify_srv_handle_member_id()

static void task_notify_srv_handle_member_id ( void * cls )

static

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

{
  struct GNUNET_MESSENGER_SrvHandle *handle;
 
  GNUNET_assert (cls);
 
  handle = cls;
  handle->notify = NULL;
 
  GNUNET_CONTAINER_multihashmap_iterate (handle->next_ids,
                                         iterate_next_member_ids, handle);
  GNUNET_CONTAINER_multihashmap_clear (handle->next_ids);
}

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

Referenced by notify_srv_handle_member_id().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ notify_srv_handle_member_id()

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

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

Parameters

[in,out]	handle	Handle
[in]	room	Room of the member
[in]	member_id	Member id
[in]	reset	Reset member session with join message

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

{
  struct GNUNET_MESSENGER_NextMemberId *next;
  struct GNUNET_MESSENGER_NextMemberId *prev;
  const struct GNUNET_HashCode *key;
 
  GNUNET_assert ((handle) && (room) && (member_id));
 
  next = GNUNET_new (struct GNUNET_MESSENGER_NextMemberId);
  key = get_srv_room_key (room);
  
  if (! next)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Allocation of next member id failed: %s (%s)\n",
                GNUNET_sh2s (member_id), GNUNET_h2s (key));
    return;
  }
 
  GNUNET_memcpy (&(next->id), member_id, sizeof(next->id));
  next->reset = reset;
 
  prev = GNUNET_CONTAINER_multihashmap_get (handle->next_ids, key);
 
  if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_put (handle->next_ids, key,
                                                       next,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Update of next member id failed: %s (%s)\n",
                GNUNET_sh2s (member_id), GNUNET_h2s (key));
    return;
  }
 
  if (prev)
    GNUNET_free (prev);
 
  if (! handle->notify)
    handle->notify = GNUNET_SCHEDULER_add_now (task_notify_srv_handle_member_id,
                                               handle);
}

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

Referenced by join_room(), and solve_srv_room_member_collisions().

Here is the call graph for this function:

Here is the caller graph for this function:

Data Structures

Functions

Function Documentation

◆ create_srv_handle()

◆ iterate_close_rooms()

◆ iterate_free_values()

◆ destroy_srv_handle()

◆ set_srv_handle_key()

◆ get_srv_handle_key()

◆ get_srv_handle_data_subdir()

◆ create_handle_member_id()

◆ get_srv_handle_member_id()

◆ change_srv_handle_member_id()

◆ open_srv_handle_room()

◆ entry_srv_handle_room()

◆ close_srv_handle_room()

◆ is_srv_handle_routing()

◆ sync_srv_handle_messages()

◆ send_srv_handle_message()

◆ get_next_member_session_context()

◆ get_handle_member_session()

◆ notify_srv_handle_message()

◆ iterate_next_member_ids()

◆ task_notify_srv_handle_member_id()

◆ notify_srv_handle_member_id()