gnunet-service-messenger_handle.c File Reference

GNUnet MESSENGER service. More...

#include "gnunet-service-messenger_handle.h"
#include "gnunet-service-messenger.h"
#include "gnunet-service-messenger_message_kind.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_MessageHandle

Functions
struct GNUNET_MESSENGER_SrvHandle *	create_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...
int	iterate_free_member_ids (void *cls, const struct GNUNET_HashCode *key, void *value)
void	destroy_handle (struct GNUNET_MESSENGER_SrvHandle *handle)
	Destroys a handle and frees its memory fully. More...
void	get_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 int	create_handle_member_id (const struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
const struct GNUNET_ShortHashCode *	get_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...
int	change_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...
static void	change_handle_name (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name)
static void	change_handle_ego (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_MESSENGER_Ego *ego)
static int	iterate_send_message (void *cls, const struct GNUNET_HashCode *key, void *value)
void	set_handle_ego (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_MESSENGER_Ego *ego)
	Sets the EGO used by a given handle. More...
const struct GNUNET_MESSENGER_Ego *	get_handle_ego (const struct GNUNET_MESSENGER_SrvHandle *handle)
	Returns the EGO used by a given handle. More...
static void	callback_setup_handle_name (void *cls, const char *name, const struct GNUNET_MESSENGER_Ego *ego)
void	setup_handle_name (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name)
	Tries to set the name and EGO key of a handle initially by looking up a specific name. More...
static void	callback_update_handle (void *cls, const char *name, const struct GNUNET_MESSENGER_Ego *ego)
void	update_handle (struct GNUNET_MESSENGER_SrvHandle *handle)
	Tries to change the key pair of an EGO of a handle under the same name and informs all rooms about the change automatically. More...
static void	callback_set_handle_name (void *cls, const char *name, const struct GNUNET_MESSENGER_Ego *ego)
void	set_handle_name (struct GNUNET_MESSENGER_SrvHandle *handle, const char *name)
	Tries to rename the handle which implies renaming the EGO its using and moving all related data into the directory fitting to the changed name. More...
int	open_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...
int	entry_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...
int	close_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...
int	send_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_contect (const struct GNUNET_MESSENGER_MemberSession *session)
void	notify_handle_message (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key, const struct GNUNET_MESSENGER_MemberSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
	Notifies the handle that a new message was received or sent. More...
static int	callback_scan_for_rooms (void *cls, const char *filename)
void	load_handle_configuration (struct GNUNET_MESSENGER_SrvHandle *handle)
	Loads member ids and other potential configuration from a given handle which depends on the given name the handle uses. More...
static int	iterate_save_rooms (void *cls, const struct GNUNET_HashCode *key, void *value)
void	save_handle_configuration (struct GNUNET_MESSENGER_SrvHandle *handle)
	Saves member ids and other potential configuration from a given handle which depends on the given name the handle uses. More...

Detailed Description

GNUnet MESSENGER service.

Author

Tobias Frisch

Definition in file gnunet-service-messenger_handle.c.

Function Documentation

create_handle()

struct GNUNET_MESSENGER_SrvHandle* create_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

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

References GNUNET_MESSENGER_SrvHandle::ego, GNUNET_assert, GNUNET_CONTAINER_multihashmap_create(), GNUNET_new, GNUNET_NO, handle, GNUNET_MESSENGER_SrvHandle::member_ids, mq, GNUNET_MESSENGER_SrvHandle::mq, GNUNET_MESSENGER_SrvHandle::name, GNUNET_MESSENGER_SrvHandle::service, and service.

Referenced by add_service_handle(), and GNUNET_MESSENGER_connect().

{
  GNUNET_assert((service) && (mq));

  struct GNUNET_MESSENGER_SrvHandle *handle = GNUNET_new(struct GNUNET_MESSENGER_SrvHandle);

  handle->service = service;
  handle->mq = mq;

  handle->name = NULL;
  handle->ego = NULL;

  handle->member_ids = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);

  return handle;
}

Here is the call graph for this function:

Here is the caller graph for this function:

iterate_free_member_ids()

int iterate_free_member_ids	(	void *	cls,
		const struct GNUNET_HashCode *	key,
		void *	value
	)

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

References GNUNET_free, and GNUNET_YES.

Referenced by destroy_handle().

{
  GNUNET_free(value);

  return GNUNET_YES;
}

Here is the caller graph for this function:

destroy_handle()

void destroy_handle

(

struct GNUNET_MESSENGER_SrvHandle *

handle

)

Destroys a handle and frees its memory fully.

Parameters

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

References GNUNET_MESSENGER_Service::dir, GNUNET_assert, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_free, iterate_free_member_ids(), GNUNET_MESSENGER_SrvHandle::member_ids, GNUNET_MESSENGER_SrvHandle::name, save_handle_configuration(), and GNUNET_MESSENGER_SrvHandle::service.

Referenced by clear_list_handles(), GNUNET_MESSENGER_connect(), GNUNET_MESSENGER_disconnect(), and remove_service_handle().

{
  GNUNET_assert(handle);

  if (handle->service->dir)
    save_handle_configuration (handle);

  if (handle->name)
    GNUNET_free(handle->name);

  GNUNET_CONTAINER_multihashmap_iterate (handle->member_ids, iterate_free_member_ids, NULL);
  GNUNET_CONTAINER_multihashmap_destroy (handle->member_ids);

  GNUNET_free(handle);
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_handle_data_subdir()

void get_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 77 of file gnunet-service-messenger_handle.c.

References GNUNET_MESSENGER_Service::dir, DIR_SEPARATOR, GNUNET_asprintf(), GNUNET_assert, and GNUNET_MESSENGER_SrvHandle::service.

Referenced by callback_set_handle_name(), iterate_save_rooms(), load_handle_configuration(), and save_handle_configuration().

{
  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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

create_handle_member_id()

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

static

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

References generate_free_member_id(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_sh2s(), GNUNET_YES, and GNUNET_MESSENGER_SrvHandle::member_ids.

Referenced by entry_handle_room(), and open_handle_room().

{
  GNUNET_assert((handle) && (key));

  struct GNUNET_ShortHashCode *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_INFO, "Created a new member id (%s) for room: %s\n", GNUNET_sh2s (random_id),
             GNUNET_h2s (key));

  return GNUNET_YES;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_handle_member_id()

const struct GNUNET_ShortHashCode* get_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 115 of file gnunet-service-messenger_handle.c.

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), and GNUNET_MESSENGER_SrvHandle::member_ids.

Referenced by close_handle_room(), close_service_room(), entry_handle_room(), find_list_handle_by_member(), handle_get_message(), handle_room_close(), handle_room_entry(), handle_room_open(), join_room_locally(), notify_handle_message(), open_handle_room(), open_room(), pack_room_message(), send_handle_message(), send_room_message(), and solve_room_member_collisions().

{
  GNUNET_assert((handle) && (key));

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

Here is the call graph for this function:

Here is the caller graph for this function:

change_handle_member_id()

int change_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

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

References env, 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_MESSAGE_TYPE_MESSENGER_CONNECTION_MEMBER_ID, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_new, GNUNET_OK, GNUNET_sh2s(), GNUNET_SYSERR, GNUNET_MESSENGER_MemberMessage::id, GNUNET_MESSENGER_MemberMessage::key, GNUNET_MESSENGER_SrvHandle::member_ids, GNUNET_MESSENGER_SrvHandle::mq, and msg.

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

{
  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))
    goto send_message_to_client;

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

  struct GNUNET_MESSENGER_MemberMessage *msg;
  struct GNUNET_MQ_Envelope *env;

send_message_to_client:

  env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_MEMBER_ID);

  GNUNET_memcpy(&(msg->key), key, sizeof(*key));
  GNUNET_memcpy(&(msg->id), member_id, sizeof(*member_id));

  GNUNET_MQ_send (handle->mq, env);
  return GNUNET_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

change_handle_name()

static void change_handle_name ( struct GNUNET_MESSENGER_SrvHandle *  handle, const char *  name  )

static

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

References env, GNUNET_assert, GNUNET_free, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_GET_NAME, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_strdup, GNUNET_MESSENGER_SrvHandle::mq, msg, and GNUNET_MESSENGER_SrvHandle::name.

Referenced by callback_set_handle_name(), callback_setup_handle_name(), and set_handle_name().

{
  GNUNET_assert(handle);

  if (handle->name)
    GNUNET_free(handle->name);

  handle->name = name ? GNUNET_strdup(name) : NULL;

  const uint16_t name_len = handle->name ? strlen (handle->name) : 0;

  struct GNUNET_MESSENGER_NameMessage *msg;
  struct GNUNET_MQ_Envelope *env;

  env = GNUNET_MQ_msg_extra(msg, name_len + 1, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_GET_NAME);

  char *extra = ((char*) msg) + sizeof(*msg);

  if (name_len)
    GNUNET_memcpy(extra, handle->name, name_len);

  extra[name_len] = '\0';

  GNUNET_MQ_send (handle->mq, env);
}

Here is the call graph for this function:

Here is the caller graph for this function:

change_handle_ego()

static void change_handle_ego ( struct GNUNET_MESSENGER_SrvHandle *  handle, const struct GNUNET_MESSENGER_Ego *  ego  )

static

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

References GNUNET_MESSENGER_SrvHandle::ego, env, get_handle_ego(), GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_IDENTITY_key_get_length(), GNUNET_IDENTITY_write_key_to_buffer(), GNUNET_log, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_GET_KEY, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_MESSENGER_SrvHandle::mq, msg, and GNUNET_MESSENGER_Ego::pub.

Referenced by callback_setup_handle_name(), callback_update_handle(), and set_handle_ego().

{
  GNUNET_assert(handle);

  handle->ego = ego;

  ego = get_handle_ego (handle);

  const uint16_t length = GNUNET_IDENTITY_key_get_length(&(ego->pub));

  struct GNUNET_MESSENGER_KeyMessage *msg;
  struct GNUNET_MQ_Envelope *env;

  env = GNUNET_MQ_msg_extra(msg, length, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_GET_KEY);

  char *extra = ((char*) msg) + sizeof(*msg);

  if (GNUNET_IDENTITY_write_key_to_buffer(&(ego->pub), extra, length) < 0)
    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Could not write key to buffer.\n");

  GNUNET_MQ_send (handle->mq, env);
}

Here is the call graph for this function:

Here is the caller graph for this function:

iterate_send_message()

static int iterate_send_message ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

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

References GNUNET_YES, GNUNET_MESSENGER_MessageHandle::handle, GNUNET_MESSENGER_MessageHandle::message, and send_handle_message().

Referenced by callback_set_handle_name(), and set_handle_ego().

{
  struct GNUNET_MESSENGER_MessageHandle *msg_handle = cls;

  send_handle_message (msg_handle->handle, key, msg_handle->message);

  return GNUNET_YES;
}

Here is the call graph for this function:

Here is the caller graph for this function:

set_handle_ego()

void set_handle_ego	(	struct GNUNET_MESSENGER_SrvHandle *	handle,
		const struct GNUNET_MESSENGER_Ego *	ego
	)

Sets the EGO used by a given handle.

Parameters

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

References change_handle_ego(), create_message_key(), destroy_message(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_MESSENGER_MessageHandle::handle, iterate_send_message(), GNUNET_MESSENGER_SrvHandle::member_ids, GNUNET_MESSENGER_MessageHandle::message, and GNUNET_MESSENGER_Ego::priv.

Referenced by callback_ego_create().

{
  GNUNET_assert((handle) && (ego));

  struct GNUNET_MESSENGER_MessageHandle msg_handle;

  msg_handle.handle = handle;
  msg_handle.message = create_message_key (&(ego->priv));

  GNUNET_CONTAINER_multihashmap_iterate (handle->member_ids, iterate_send_message, &msg_handle);

  destroy_message (msg_handle.message);

  change_handle_ego (handle, ego);
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_handle_ego()

const struct GNUNET_MESSENGER_Ego* get_handle_ego

(

const struct GNUNET_MESSENGER_SrvHandle *

handle

)

Returns the EGO used by a given handle.

Parameters

[in]

handle

Handle

Returns

EGO key pair

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

References GNUNET_MESSENGER_SrvHandle::ego, GNUNET_assert, GNUNET_IDENTITY_ego_get_anonymous(), GNUNET_IDENTITY_ego_get_private_key(), GNUNET_IDENTITY_ego_get_public_key(), GNUNET_memcpy, GNUNET_MESSENGER_Ego::priv, and GNUNET_MESSENGER_Ego::pub.

Referenced by change_handle_ego(), handle_get_message(), join_room(), join_room_locally(), notify_handle_message(), pack_room_message(), recv_message_info(), send_room_info(), and solve_room_member_collisions().

{
  GNUNET_assert(handle);

  static struct GNUNET_MESSENGER_Ego anonymous;
  static int read_keys = 0;

  if (handle->ego)
    return handle->ego;

  if (!read_keys)
  {
    struct GNUNET_IDENTITY_Ego *ego = GNUNET_IDENTITY_ego_get_anonymous ();
    GNUNET_memcpy(&(anonymous.priv), GNUNET_IDENTITY_ego_get_private_key (ego), sizeof(anonymous.priv));
    GNUNET_IDENTITY_ego_get_public_key (ego, &(anonymous.pub));
    read_keys = 1;
  }

  return &anonymous;
}

Here is the call graph for this function:

Here is the caller graph for this function:

callback_setup_handle_name()

static void callback_setup_handle_name ( void *  cls, const char *  name, const struct GNUNET_MESSENGER_Ego *  ego  )

static

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

References change_handle_ego(), change_handle_name(), GNUNET_MESSENGER_Service::dir, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSENGER_MessageHandle::handle, load_handle_configuration(), and GNUNET_MESSENGER_SrvHandle::service.

Referenced by setup_handle_name().

{
  struct GNUNET_MESSENGER_SrvHandle *handle = cls;

  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Setting up handle...\n");

  change_handle_name (handle, name);
  change_handle_ego (handle, ego);

  if (handle->service->dir)
    load_handle_configuration (handle);
}

Here is the call graph for this function:

Here is the caller graph for this function:

setup_handle_name()

void setup_handle_name	(	struct GNUNET_MESSENGER_SrvHandle *	handle,
		const char *	name
	)

Tries to set the name and EGO key of a handle initially by looking up a specific name.

Parameters

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

References callback_setup_handle_name(), get_service_ego_store(), GNUNET_assert, lookup_store_ego(), and GNUNET_MESSENGER_SrvHandle::service.

Referenced by handle_create().

{
  GNUNET_assert(handle);

  struct GNUNET_MESSENGER_EgoStore *store = get_service_ego_store(handle->service);

  lookup_store_ego (store, name, callback_setup_handle_name, handle);
}

Here is the call graph for this function:

Here is the caller graph for this function:

callback_update_handle()

static void callback_update_handle ( void *  cls, const char *  name, const struct GNUNET_MESSENGER_Ego *  ego  )

static

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

References change_handle_ego(), create_store_ego(), get_service_ego_store(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSENGER_MessageHandle::handle, GNUNET_MESSENGER_SrvHandle::name, and GNUNET_MESSENGER_SrvHandle::service.

Referenced by update_handle().

{
  struct GNUNET_MESSENGER_SrvHandle *handle = cls;

  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Updating handle...\n");

  struct GNUNET_MESSENGER_EgoStore *store = get_service_ego_store(handle->service);

  if (!ego)
    create_store_ego(store, handle->name, handle);
  else
    change_handle_ego (handle, ego);
}

Here is the call graph for this function:

Here is the caller graph for this function:

update_handle()

void update_handle

(

struct GNUNET_MESSENGER_SrvHandle *

handle

)

Tries to change the key pair of an EGO of a handle under the same name and informs all rooms about the change automatically.

Parameters

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

References callback_update_handle(), get_service_ego_store(), GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, lookup_store_ego(), GNUNET_MESSENGER_SrvHandle::name, and GNUNET_MESSENGER_SrvHandle::service.

Referenced by handle_update().

{
  GNUNET_assert(handle);

  if (!handle->name)
  {
    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Updating handle failed: Name is required!\n");
    return;
  }

  struct GNUNET_MESSENGER_EgoStore *store = get_service_ego_store(handle->service);

  lookup_store_ego (store, handle->name, callback_update_handle, handle);
}

Here is the call graph for this function:

Here is the caller graph for this function:

callback_set_handle_name()

static void callback_set_handle_name ( void *  cls, const char *  name, const struct GNUNET_MESSENGER_Ego *  ego  )

static

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

References change_handle_name(), create_message_name(), destroy_message(), GNUNET_MESSENGER_SrvHandle::ego, get_handle_data_subdir(), get_service_ego_store(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_DISK_directory_create_for_file(), GNUNET_DISK_directory_test(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_MessageHandle::handle, iterate_send_message(), GNUNET_MESSENGER_SrvHandle::member_ids, GNUNET_MESSENGER_MessageHandle::message, GNUNET_MESSENGER_SrvHandle::name, rename_store_ego(), result, and GNUNET_MESSENGER_SrvHandle::service.

Referenced by set_handle_name().

{
  struct GNUNET_MESSENGER_SrvHandle *handle = cls;

  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Renaming handle...\n");

  if (ego)
  {
    GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Renaming handle failed: Name is occupied! (%s)\n", name);
    return;
  }

  struct GNUNET_MESSENGER_EgoStore *store = get_service_ego_store(handle->service);

  int rename_ego_in_store = handle->ego? GNUNET_YES : GNUNET_NO;

  char *old_dir;
  get_handle_data_subdir (handle, handle->name, &old_dir);

  char *new_dir;
  get_handle_data_subdir (handle, name, &new_dir);

  int result = 0;

  if (GNUNET_YES == GNUNET_DISK_directory_test (old_dir, GNUNET_YES))
  {
    GNUNET_DISK_directory_create_for_file (new_dir);

    result = rename (old_dir, new_dir);
  }
  else if (GNUNET_YES == GNUNET_DISK_directory_test (new_dir, GNUNET_NO))
    result = -1;

  if (0 == result)
  {
    struct GNUNET_MESSENGER_MessageHandle msg_handle;

    msg_handle.handle = handle;
    msg_handle.message = create_message_name (name);

    GNUNET_CONTAINER_multihashmap_iterate (handle->member_ids, iterate_send_message, &msg_handle);

    destroy_message (msg_handle.message);

    change_handle_name (handle, name);
  }
  else
    rename_ego_in_store = GNUNET_NO;

  GNUNET_free(old_dir);
  GNUNET_free(new_dir);

  if (GNUNET_YES == rename_ego_in_store)
    rename_store_ego(store, handle->name, name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

set_handle_name()

void set_handle_name	(	struct GNUNET_MESSENGER_SrvHandle *	handle,
		const char *	name
	)

Tries to rename the handle which implies renaming the EGO its using and moving all related data into the directory fitting to the changed name.

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

Parameters

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

References callback_set_handle_name(), change_handle_name(), GNUNET_MESSENGER_SrvHandle::ego, get_service_ego_store(), GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, lookup_store_ego(), and GNUNET_MESSENGER_SrvHandle::service.

Referenced by handle_get_name(), and handle_set_name().

{
  GNUNET_assert(handle);

  if (!name)
  {
    if (handle->ego)
      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Renaming handle failed: Name is required!\n");
    else
      change_handle_name (handle, name);

    return;
  }

  struct GNUNET_MESSENGER_EgoStore *store = get_service_ego_store(handle->service);

  lookup_store_ego (store, name, callback_set_handle_name, handle);
}

Here is the call graph for this function:

Here is the caller graph for this function:

open_handle_room()

int open_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

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

References create_handle_member_id(), get_handle_member_id(), GNUNET_assert, GNUNET_NO, GNUNET_YES, open_service_room(), and GNUNET_MESSENGER_SrvHandle::service.

Referenced by handle_room_open().

{
  GNUNET_assert((handle) && (key));

  if ((!get_handle_member_id (handle, key)) && (GNUNET_YES != create_handle_member_id (handle, key)))
    return GNUNET_NO;

  return open_service_room (handle->service, handle, key);
}

Here is the call graph for this function:

Here is the caller graph for this function:

entry_handle_room()

int entry_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

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

References create_handle_member_id(), entry_service_room(), get_handle_member_id(), GNUNET_assert, GNUNET_NO, GNUNET_YES, and GNUNET_MESSENGER_SrvHandle::service.

Referenced by handle_room_entry().

{
  GNUNET_assert((handle) && (door) && (key));

  if ((!get_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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

close_handle_room()

int close_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

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

References close_service_room(), get_handle_member_id(), GNUNET_assert, GNUNET_NO, and GNUNET_MESSENGER_SrvHandle::service.

Referenced by handle_room_close().

{
  GNUNET_assert((handle) && (key));

  if (!get_handle_member_id (handle, key))
    return GNUNET_NO;

  return close_service_room (handle->service, handle, key);
}

Here is the call graph for this function:

Here is the caller graph for this function:

send_handle_message()

int send_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

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

References copy_message(), get_handle_member_id(), get_service_room(), GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_NO, GNUNET_MESSENGER_Message::header, msg, send_room_message(), GNUNET_MESSENGER_MessageHeader::sender_id, and GNUNET_MESSENGER_SrvHandle::service.

Referenced by handle_send_message(), and iterate_send_message().

{
  GNUNET_assert((handle) && (key) && (message));

  const struct GNUNET_ShortHashCode *id = get_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;
  }

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

  GNUNET_memcpy(&(msg->header.sender_id), id, sizeof(*id));

  return send_room_message (room, handle, msg);
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_next_member_session_contect()

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

static

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

References get_member_session_context(), and GNUNET_MESSENGER_MemberSession::next.

Referenced by notify_handle_message().

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

Here is the call graph for this function:

Here is the caller graph for this function:

notify_handle_message()

void notify_handle_message	(	struct GNUNET_MESSENGER_SrvHandle *	handle,
		const struct GNUNET_HashCode *	key,
		const struct GNUNET_MESSENGER_MemberSession *	session,
		const struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_HashCode *	hash
	)

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

Parameters

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

References GNUNET_MESSENGER_MemberSession::contact, context, GNUNET_MESSENGER_RecvMessage::context, copy_message(), decrypt_message(), destroy_message(), encode_message(), env, GNUNET_MESSENGER_RecvMessage::flags, get_contact_key(), get_handle_ego(), get_handle_member_id(), get_message_size(), get_next_member_session_contect(), 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_PRIVATE, GNUNET_MESSENGER_KIND_PRIVATE, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_YES, GNUNET_MESSENGER_RecvMessage::hash, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_RecvMessage::key, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_SrvHandle::mq, msg, pubkey, and GNUNET_MESSENGER_RecvMessage::sender.

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

{
  GNUNET_assert((handle) && (key) && (session) && (message) && (hash));

  if ((!handle->mq) || (!get_handle_member_id (handle, key)))
  {
    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Notifying client about message requires membership!\n");
    return;
  }

  const struct GNUNET_IDENTITY_PublicKey *pubkey = get_contact_key(session->contact);

  struct GNUNET_HashCode sender;
  GNUNET_CRYPTO_hash(pubkey, sizeof(*pubkey), &sender);

  const struct GNUNET_HashCode *context = get_next_member_session_contect (session);

  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Notifying client about message: %s\n", GNUNET_h2s (hash));

  struct GNUNET_MESSENGER_Message *private_message = NULL;

  if (GNUNET_MESSENGER_KIND_PRIVATE == message->header.kind)
  {
    private_message = copy_message(message);

    if (GNUNET_YES != decrypt_message(private_message, &(get_handle_ego(handle)->priv)))
    {
      destroy_message(private_message);
      private_message = NULL;
    }
    else
      message = private_message;
  }

  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) (
      private_message? GNUNET_MESSENGER_FLAG_PRIVATE : GNUNET_MESSENGER_FLAG_NONE
  );

  char *buffer = ((char*) msg) + sizeof(*msg);
  encode_message (message, length, buffer, GNUNET_YES);

  if (private_message)
    destroy_message(private_message);

  GNUNET_MQ_send (handle->mq, env);
}

Here is the call graph for this function:

Here is the caller graph for this function:

callback_scan_for_rooms()

static int callback_scan_for_rooms ( void *  cls, const char *  filename  )

static

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

References cfg, change_handle_member_id(), GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_destroy(), GNUNET_CONFIGURATION_get_data(), GNUNET_CONFIGURATION_parse(), GNUNET_DISK_file_test(), GNUNET_OK, GNUNET_YES, and GNUNET_MESSENGER_MessageHandle::handle.

Referenced by load_handle_configuration().

{
  struct GNUNET_MESSENGER_SrvHandle *handle = cls;

  struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create ();

  if ((GNUNET_YES == GNUNET_DISK_file_test (filename)) && (GNUNET_OK == GNUNET_CONFIGURATION_parse (cfg, filename)))
  {
    struct GNUNET_HashCode key;
    struct GNUNET_ShortHashCode member_id;

    if ((GNUNET_OK == GNUNET_CONFIGURATION_get_data (cfg, "room", "key", &key, sizeof(key))) &&
        (GNUNET_OK == GNUNET_CONFIGURATION_get_data (cfg, "room", "member_id", &member_id, sizeof(member_id))))
      change_handle_member_id (handle, &key, &member_id);
  }

  GNUNET_CONFIGURATION_destroy (cfg);
  return GNUNET_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

load_handle_configuration()

void load_handle_configuration

(

struct GNUNET_MESSENGER_SrvHandle *

handle

)

Loads member ids and other potential configuration from a given handle which depends on the given name the handle uses.

Parameters

[out]

handle

Handle

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

References callback_scan_for_rooms(), DIR_SEPARATOR, get_handle_data_subdir(), GNUNET_asprintf(), GNUNET_assert, GNUNET_DISK_directory_scan(), GNUNET_DISK_directory_test(), GNUNET_free, GNUNET_OK, GNUNET_YES, GNUNET_MESSENGER_SrvHandle::name, and find_typedefs::scan_dir().

Referenced by callback_setup_handle_name().

{
  GNUNET_assert(handle);

  char *id_dir;
  get_handle_data_subdir (handle, handle->name, &id_dir);

  if (GNUNET_YES == GNUNET_DISK_directory_test (id_dir, GNUNET_YES))
  {
    char *scan_dir;
    GNUNET_asprintf (&scan_dir, "%s%s%c", id_dir, "rooms", DIR_SEPARATOR);

    if (GNUNET_OK == GNUNET_DISK_directory_test (scan_dir, GNUNET_YES))
      GNUNET_DISK_directory_scan (scan_dir, callback_scan_for_rooms, handle);

    GNUNET_free(scan_dir);
  }

  GNUNET_free(id_dir);
}

Here is the call graph for this function:

Here is the caller graph for this function:

iterate_save_rooms()

static int iterate_save_rooms ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

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

References cfg, DIR_SEPARATOR, filename, get_handle_data_subdir(), GNUNET_asprintf(), GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_destroy(), GNUNET_CONFIGURATION_set_value_string(), GNUNET_CONFIGURATION_write(), GNUNET_free, GNUNET_h2s(), GNUNET_STRINGS_data_to_string_alloc(), GNUNET_YES, GNUNET_MESSENGER_MessageHandle::handle, GNUNET_MESSENGER_SrvHandle::name, and value.

Referenced by save_handle_configuration().

{
  struct GNUNET_MESSENGER_SrvHandle *handle = cls;
  struct GNUNET_ShortHashCode *member_id = value;

  char *id_dir;
  get_handle_data_subdir (handle, handle->name, &id_dir);

  char *filename;
  GNUNET_asprintf (&filename, "%s%s%c%s.cfg", id_dir, "rooms", DIR_SEPARATOR, GNUNET_h2s (key));

  GNUNET_free(id_dir);

  struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create ();

  char *key_data = GNUNET_STRINGS_data_to_string_alloc (key, sizeof(*key));

  if (key_data)
  {
    GNUNET_CONFIGURATION_set_value_string (cfg, "room", "key", key_data);

    GNUNET_free(key_data);
  }

  char *member_id_data = GNUNET_STRINGS_data_to_string_alloc (member_id, sizeof(*member_id));

  if (member_id_data)
  {
    GNUNET_CONFIGURATION_set_value_string (cfg, "room", "member_id", member_id_data);

    GNUNET_free(member_id_data);
  }

  GNUNET_CONFIGURATION_write (cfg, filename);
  GNUNET_CONFIGURATION_destroy (cfg);

  GNUNET_free(filename);

  return GNUNET_YES;
}

Here is the call graph for this function:

Here is the caller graph for this function:

save_handle_configuration()

void save_handle_configuration

(

struct GNUNET_MESSENGER_SrvHandle *

handle

)

Saves member ids and other potential configuration from a given handle which depends on the given name the handle uses.

Parameters

[in]

handle

Handle

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

References DIR_SEPARATOR, get_handle_data_subdir(), GNUNET_asprintf(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_DISK_directory_create(), GNUNET_DISK_directory_test(), GNUNET_free, GNUNET_NO, GNUNET_OK, GNUNET_YES, iterate_save_rooms(), GNUNET_MESSENGER_SrvHandle::member_ids, and GNUNET_MESSENGER_SrvHandle::name.

Referenced by destroy_handle().

{
  GNUNET_assert(handle);

  char *id_dir;
  get_handle_data_subdir (handle, handle->name, &id_dir);

  if ((GNUNET_YES == GNUNET_DISK_directory_test (id_dir, GNUNET_NO)) || (GNUNET_OK
      == GNUNET_DISK_directory_create (id_dir)))
  {
    char *save_dir;
    GNUNET_asprintf (&save_dir, "%s%s%c", id_dir, "rooms", DIR_SEPARATOR);

    if ((GNUNET_YES == GNUNET_DISK_directory_test (save_dir, GNUNET_NO)) ||
        (GNUNET_OK == GNUNET_DISK_directory_create (save_dir)))
      GNUNET_CONTAINER_multihashmap_iterate (handle->member_ids, iterate_save_rooms, handle);

    GNUNET_free(save_dir);
  }

  GNUNET_free(id_dir);
}

Here is the call graph for this function:

Here is the caller graph for this function: