gnunet-service-messenger_handle.c File Reference

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

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

Go to the source code of this file.

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).
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.
void	set_srv_handle_key (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_CRYPTO_BlindablePublicKey *key)
	Sets the public key of a given handle.
const struct GNUNET_CRYPTO_BlindablePublicKey *	get_srv_handle_key (const struct GNUNET_MESSENGER_SrvHandle *handle)
	Returns the public key of a given handle.
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.
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.
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.
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.
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).
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.
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.
static enum GNUNET_GenericReturnValue	iterate_srv_handle_sync_finished (void *cls, const struct GNUNET_HashCode *key, void *value)
void	merge_srv_handle_room_to_sync (struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_SrvRoom *room)
	Merges the latest hash from a specific room by a given handle until the message graph of the room is fully synced.
void	sync_srv_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle, uint16_t response_type, const struct GNUNET_HashCode *key, const struct GNUNET_HashCode *previous, const struct GNUNET_HashCode *epoch, const struct GNUNET_PeerIdentity *door)
	Starts merging message hashes until the state from a room of a given handle using a specific key is fully synced to then send a response using a specified response_type to the handles client with the latest known hash and epoch of a message in that room.
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.
static const struct GNUNET_HashCode *	get_next_member_session_context (const struct GNUNET_MESSENGER_SrvMemberSession *session)
static const struct GNUNET_MESSENGER_SrvMemberSession *	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, const struct GNUNET_HashCode *epoch, enum GNUNET_GenericReturnValue recent)
	Notifies the handle that a new message was received or sent.
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.

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 45 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->syncing = GNUNET_CONTAINER_multihashmap_create (8, 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 69 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 85 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 97 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_iterate (handle->syncing,
                                         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_CONTAINER_multihashmap_destroy (handle->syncing);
 
  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_BlindablePublicKey *	key
	)

Sets the public key of a given handle.

Parameters

[out]	handle	Handle
[in]	key	Public key

Definition at line 124 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_BlindablePublicKey);
 
  if (key)
    memcpy (handle->key, key, sizeof(struct GNUNET_CRYPTO_BlindablePublicKey));
}

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_BlindablePublicKey * 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 143 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 152 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 168 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 200 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_service_message(), iterate_srv_handle_sync_finished(), 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_room().

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 210 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 251 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 271 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 286 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 319 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:

iterate_srv_handle_sync_finished()

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

static

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

{
  struct GNUNET_MESSENGER_SrvHandle *handle;
  struct GNUNET_MESSENGER_SrvHandleSync *sync;
  struct GNUNET_MESSENGER_SrvRoom *room;
  const struct GNUNET_ShortHashCode *member_id;
  struct GNUNET_MESSENGER_MessageStore *store;
 
  GNUNET_assert ((cls) && (key) && (value));
 
  handle = cls;
  sync = value;
 
  room = get_service_room (handle->service, key);
  member_id = get_srv_handle_member_id (handle, key);
 
  if ((! room) || (! member_id))
    goto sync_epoch;
 
  get_message_state_chain_hash (&(room->state), &(sync->hash));
 
sync_epoch:
  if (! room)
  {
    GNUNET_memcpy (&(sync->epoch), &(sync->hash),
                   sizeof(sync->epoch));
    goto send_response;
  }
 
  store = get_srv_room_message_store (room);
 
  if (! store)
    goto send_response;
 
  GNUNET_memcpy (&(sync->epoch),
                 get_store_message_epoch (store, &(sync->hash)),
                 sizeof(sync->epoch));
 
send_response:
  {
    struct GNUNET_MESSENGER_RoomMessage *response;
    struct GNUNET_MQ_Envelope *envelope;
 
    switch (sync->response_type)
    {
    case GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_OPEN:
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Opening room with member id: %s\n",
                  GNUNET_sh2s (member_id));
      break;
    case GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_ENTRY:
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Entering room with member id: %s\n",
                  GNUNET_sh2s (member_id));
      break;
    case GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_CLOSE:
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Closing room succeeded: %s\n",
                  GNUNET_h2s (key));
      break;
    case GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_SYNC:
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Synced room: %s\n",
                  GNUNET_h2s (key));
      break;
    default:
      break;
    }
 
    envelope = GNUNET_MQ_msg (response, sync->response_type);
 
    GNUNET_memcpy (&(response->door), &(sync->door), sizeof(response->door));
    GNUNET_memcpy (&(response->key), key, sizeof(response->key));
    GNUNET_memcpy (&(response->previous), &(sync->hash), sizeof(response->
                                                                previous));
    GNUNET_memcpy (&(response->epoch), &(sync->epoch), sizeof(response->epoch));
 
    GNUNET_MQ_send (handle->mq, envelope);
  }
 
  GNUNET_free (sync);
  return GNUNET_YES;
}

References GNUNET_MESSENGER_SrvHandleSync::door, GNUNET_MESSENGER_SrvHandleSync::epoch, get_message_state_chain_hash(), get_service_room(), get_srv_handle_member_id(), get_srv_room_message_store(), get_store_message_epoch(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_CLOSE, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_ENTRY, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_OPEN, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_SYNC, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_sh2s(), GNUNET_YES, handle, GNUNET_MESSENGER_SrvHandleSync::hash, key, GNUNET_VPN_Handle::mq, response, GNUNET_MESSENGER_SrvHandleSync::response_type, send_response(), GNUNET_MESSENGER_SrvRoom::state, and value.

Referenced by merge_srv_handle_room_to_sync(), and sync_srv_handle_room().

Here is the call graph for this function:

Here is the caller graph for this function:

merge_srv_handle_room_to_sync()

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

Merges the latest hash from a specific room by a given handle until the message graph of the room is fully synced.

The function will be called automatically in case the given handle is actively syncing.

Parameters

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

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

{
  enum GNUNET_GenericReturnValue result;
 
  GNUNET_assert ((handle) && (room));
 
  GNUNET_assert (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (handle->
                                                                       syncing,
                                                                       &(room->
                                                                         key)));
 
  result = merge_srv_room_last_messages (room, handle);
 
  if (GNUNET_NO == result)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Finish syncing room: %s\n",
                GNUNET_h2s (&(room->key)));
 
    GNUNET_CONTAINER_multihashmap_get_multiple (handle->syncing,
                                                &(room->key),
                                                &
                                                iterate_srv_handle_sync_finished,
                                                handle);
    GNUNET_CONTAINER_multihashmap_remove_all (handle->syncing, &(room->key));
    room->sync = NULL;
  }
  else if (GNUNET_YES != result)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Merging messages failed while syncing: %s\n",
                GNUNET_h2s (&(room->key)));
    room->sync = NULL;
  }
  else if (NULL == room->sync)
    room->sync = handle;
}

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CONTAINER_multihashmap_get_multiple(), GNUNET_CONTAINER_multihashmap_remove_all(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_h2s(), GNUNET_log, GNUNET_NO, GNUNET_YES, handle, iterate_srv_handle_sync_finished(), key, GNUNET_MESSENGER_SrvRoom::key, merge_srv_room_last_messages(), result, and GNUNET_MESSENGER_SrvRoom::sync.

Referenced by callback_srv_room_message_signed(), notify_srv_handle_message(), and sync_srv_handle_room().

Here is the call graph for this function:

Here is the caller graph for this function:

sync_srv_handle_room()

void sync_srv_handle_room	(	struct GNUNET_MESSENGER_SrvHandle *	handle,
		uint16_t	response_type,
		const struct GNUNET_HashCode *	key,
		const struct GNUNET_HashCode *	hash,
		const struct GNUNET_HashCode *	epoch,
		const struct GNUNET_PeerIdentity *	door
	)

Starts merging message hashes until the state from a room of a given handle using a specific key is fully synced to then send a response using a specified response_type to the handles client with the latest known hash and epoch of a message in that room.

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. Similar goes for the provided epoch and door identifier.

Parameters

[in,out]	handle	Handle
[in]	response_type	Type of response
[in]	key	Key of a room
[in]	prev	Known hash of a message
[in]	epoch	Known epoch in a room
[in]	door	Known door identity or NULL

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

{
  struct GNUNET_MESSENGER_SrvRoom *room;
  struct GNUNET_MESSENGER_SrvHandleSync *sync;
 
  GNUNET_assert ((handle) && (key) && (previous));
 
  room = get_service_room (handle->service, key);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "%s syncing room: %s\n",
              (room) && (room->sync)? "Continue" : "Start",
              GNUNET_h2s (key));
 
  sync = GNUNET_new (struct GNUNET_MESSENGER_SrvHandleSync);
 
  GNUNET_assert (sync);
  sync->response_type = response_type;
 
  if (door)
    GNUNET_memcpy (&(sync->door), door, sizeof(sync->door));
  else if (GNUNET_OK != get_service_peer_identity (handle->service, &(sync->door
                                                                      )))
    memset (&(sync->door), 0, sizeof(sync->door));
 
  GNUNET_memcpy (&(sync->hash), previous, sizeof(sync->hash));
  GNUNET_memcpy (&(sync->epoch), epoch, sizeof(sync->epoch));
 
  if ((! room) || (! get_srv_handle_member_id (handle, key)) ||
      (NULL == get_message_state_merge_hash (&(room->state))))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Finish syncing room quickly: %s\n",
                GNUNET_h2s (key));
 
    iterate_srv_handle_sync_finished (handle, key, sync);
    return;
  }
 
  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (handle->syncing,
                                                      key, sync,
                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Could not wait for syncing room: %s\n",
                GNUNET_h2s (key));
    GNUNET_free (sync);
  }
 
  if (NULL != room->sync)
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Wait for syncing: %s\n",
                GNUNET_h2s (&(room->key)));
  else
    merge_srv_handle_room_to_sync (handle, room);
}

References GNUNET_MESSENGER_SrvHandleSync::door, GNUNET_MESSENGER_SrvHandleSync::epoch, get_message_state_merge_hash(), get_service_peer_identity(), get_service_room(), get_srv_handle_member_id(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_new, GNUNET_OK, handle, GNUNET_MESSENGER_SrvHandleSync::hash, iterate_srv_handle_sync_finished(), key, GNUNET_MESSENGER_SrvRoom::key, merge_srv_handle_room_to_sync(), GNUNET_MESSENGER_SrvHandleSync::response_type, GNUNET_MESSENGER_SrvRoom::state, and GNUNET_MESSENGER_SrvRoom::sync.

Referenced by handle_room_close(), 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 518 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_SrvMemberSession *  session )

static

Definition at line 571 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_SrvMemberSession::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_SrvMemberSession * get_handle_member_session ( struct GNUNET_MESSENGER_SrvHandle *  handle, struct GNUNET_MESSENGER_SrvRoom *  room, const struct GNUNET_HashCode *  key  )

static

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

{
  const struct GNUNET_ShortHashCode *id;
  const struct GNUNET_CRYPTO_BlindablePublicKey *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,
		const struct GNUNET_HashCode *	epoch,
		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]	epoch	Hash of epoch
[in]	recent	Whether the message was recently received

Definition at line 626 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) && (
                   epoch));
 
  key = get_srv_room_key (room);
  id = get_srv_handle_member_id (handle, key);
 
  if (! handle->mq)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Notifying client is missing a message queue!\n");
    return;
  }
 
  if ((GNUNET_MESSENGER_KIND_MERGE == message->header.kind) &&
      (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (handle->syncing,
                                                             key)) &&
      (NULL == get_message_state_merge_hash (&(room->state))))
    merge_srv_handle_room_to_sync (handle, room);
 
  if (! 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)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Room does not offer a member store: %s\n",
                  GNUNET_h2s (key));
      return;
    }
 
    member = get_store_member (member_store, id);
 
    if (! member)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Could not find member in store with given id: %s (%s)\n",
                  GNUNET_sh2s (id),
                  GNUNET_h2s (key));
      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_BlindablePublicKey *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));
    GNUNET_memcpy (&(msg->epoch), epoch, sizeof(msg->epoch));
 
    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_message_state_merge_hash(), 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_CONTAINER_multihashmap_contains(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, 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_MERGE, GNUNET_MESSENGER_KIND_TALK, GNUNET_MESSENGER_name_of_kind(), GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_sh2s(), 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, merge_srv_handle_room_to_sync(), GNUNET_VPN_Handle::mq, msg, GNUNET_MESSENGER_SenderSession::peer, pubkey, GNUNET_MESSENGER_SrvRoom::state, GNUNET_MESSENGER_MessageBody::talk, GNUNET_MESSENGER_MessageHeader::timestamp, and timestamp().

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

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 771 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 807 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 823 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: