#include "gnunet_util_lib.h"
#include "gnunet-service-messenger_service.h"
#include "gnunet-service-messenger_sender_session.h"

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

This graph shows which files directly or indirectly include this file:

Data Structures
struct	GNUNET_MESSENGER_SrvHandle

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

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

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

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

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.

{
  GNUNET_assert ((service) && (mq));
 
  struct GNUNET_MESSENGER_SrvHandle *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:

◆ 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 85 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 109 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 128 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 137 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:

◆ 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 184 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 194 of file gnunet-service-messenger_handle.c.

{
  GNUNET_assert ((handle) && (key) && (unique_id));
 
  struct GNUNET_ShortHashCode *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_INFO,
              "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_INFO, "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_INFO, 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 234 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 255 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 271 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 302 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 312 of file gnunet-service-messenger_handle.c.

{
  GNUNET_assert ((handle) && (key) && (prev) && (hash));
 
  struct GNUNET_MESSENGER_SrvRoom *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 334 of file gnunet-service-messenger_handle.c.

{
  GNUNET_assert ((handle) && (key) && (message));
 
  const struct GNUNET_ShortHashCode *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;
  }
 
  struct GNUNET_MESSENGER_SrvRoom *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 = copy_message (message);
  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_WARNING, GNUNET_h2s(), GNUNET_log, GNUNET_memcmp, GNUNET_NO, GNUNET_sh2s(), handle, GNUNET_MESSENGER_Message::header, 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:

◆ 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 422 of file gnunet-service-messenger_handle.c.

{
  GNUNET_assert ((handle) && (room) && (session) && (message) && (hash));
 
  const struct GNUNET_HashCode *key = get_srv_room_key (room);
 
  if ((! handle->mq) || (! get_srv_handle_member_id (handle, key)))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Notifying client about message requires membership!\n");
    return;
  }
 
  struct GNUNET_HashCode sender;
  const struct GNUNET_HashCode *context = NULL;
 
  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 = get_contact_key (
      session->member->contact);
    GNUNET_CRYPTO_hash (pubkey, sizeof(*pubkey), &sender);
 
    context = get_next_member_session_context (session->member);
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "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 = 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;
 
  char *buffer = ((char*) msg) + sizeof(*msg);
  encode_message (message, length, buffer, GNUNET_YES);
 
  GNUNET_MQ_send (handle->mq, env);
}

References GNUNET_MESSENGER_MemberSession::contact, context, encode_message(), env, get_contact_key(), get_handle_member_session(), get_message_size(), get_next_member_session_context(), get_srv_handle_member_id(), get_srv_room_key(), GNUNET_assert, GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_INFO, 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_name_of_kind(), GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_YES, handle, GNUNET_MESSENGER_Message::header, identity, is_peer_message(), key, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_SenderSession::member, GNUNET_VPN_Handle::mq, msg, GNUNET_MESSENGER_SenderSession::peer, and pubkey.

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:

◆ 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 531 of file gnunet-service-messenger_handle.c.

{
  GNUNET_assert ((handle) && (room) && (member_id));
 
  struct GNUNET_MESSENGER_NextMemberId *next = GNUNET_new (struct
                                                           GNUNET_MESSENGER_NextMemberId);
  if (! next)
  {
    return;
  }
 
  GNUNET_memcpy (&(next->id), member_id, sizeof(next->id));
  next->reset = reset;
 
  const struct GNUNET_HashCode *key = get_srv_room_key (room);
 
  struct GNUNET_MESSENGER_NextMemberId *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))
  {
    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_free, GNUNET_memcpy, GNUNET_new, GNUNET_SCHEDULER_add_now(), 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()

◆ destroy_srv_handle()

◆ set_srv_handle_key()

◆ get_srv_handle_key()

◆ get_srv_handle_data_subdir()

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

◆ notify_srv_handle_message()

◆ notify_srv_handle_member_id()