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)
static const struct GNUNET_MESSENGER_MemberSession *	get_handle_member_session (struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_HashCode *key)
void	notify_handle_message (struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_SrvRoom *room, 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

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

Returns

New handle

Definition at line 34 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->name = NULL;
  handle->ego = NULL;
 
  handle->member_ids = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
 
  return handle;
}

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

Referenced by add_service_handle(), and GNUNET_MESSENGER_connect().

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

{
  GNUNET_free(value);
 
  return GNUNET_YES;
}

References GNUNET_free, GNUNET_YES, and value.

Referenced by destroy_handle().

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

[in/out]

handle Handle

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

{
  GNUNET_assert(handle);
 
  if (handle->service->dir)
    save_handle_configuration (handle);
 
  if (handle->name)
  {
    struct GNUNET_MESSENGER_EgoStore *store = get_service_ego_store(handle->service);
 
    unbind_store_ego(store, handle->name, handle);
 
    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);
}

References get_service_ego_store(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_free, handle, iterate_free_member_ids(), save_handle_configuration(), and unbind_store_ego().

Referenced by clear_list_handles(), GNUNET_MESSENGER_connect(), GNUNET_MESSENGER_disconnect(), and remove_service_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 86 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.

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

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

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

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, handle, and key.

Referenced by entry_handle_room(), and open_handle_room().

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 127 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_handle_room(), close_service_room(), entry_handle_room(), find_list_handle_by_member(), get_handle_member_session(), handle_get_message(), 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().

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

	[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 136 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))
    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;
}

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, handle, key, GNUNET_DNS_Handle::mq, and msg.

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

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

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

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

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

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

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

References 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(), handle, GNUNET_DNS_Handle::mq, msg, and GNUNET_MESSENGER_Ego::pub.

Referenced by callback_setup_handle_name(), and set_handle_ego().

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

{
  struct GNUNET_MESSENGER_MessageHandle *msg_handle = cls;
 
  send_handle_message (msg_handle->handle, key, msg_handle->message);
 
  return GNUNET_YES;
}

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

Referenced by callback_set_handle_name(), and set_handle_ego().

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

	[in/out]	handle Handle
[in]	ego	EGO key pair

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

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

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

Referenced by iterate_create_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 271 of file gnunet-service-messenger_handle.c.

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

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

Referenced by change_handle_ego(), get_handle_member_session(), 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().

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

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

References change_handle_ego(), change_handle_name(), GNUNET_MESSENGER_SrvHandle::ego, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, handle, load_handle_configuration(), and name.

Referenced by setup_handle_name().

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

	[in/out]	handle Handle
[in]	name	Name (optionally: valid EGO name)

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

{
  GNUNET_assert(handle);
 
  struct GNUNET_MESSENGER_EgoStore *store = get_service_ego_store(handle->service);
 
  lookup_store_ego (store, name, callback_setup_handle_name, handle);
}

References callback_setup_handle_name(), get_service_ego_store(), GNUNET_assert, handle, lookup_store_ego(), and name.

Referenced by handle_create().

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

{
  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);
 
  bind_store_ego(store, handle->name, handle);
 
  if (!ego)
    create_store_ego (store, handle->name);
  else
    renew_store_ego (store, handle->name);
}

References bind_store_ego(), create_store_ego(), get_service_ego_store(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, handle, and renew_store_ego().

Referenced by update_handle().

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

[in/out]

handle Handle

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

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

References callback_update_handle(), get_service_ego_store(), GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, handle, and lookup_store_ego().

Referenced by handle_update().

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

{
  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);
 
  char *old_dir;
  get_handle_data_subdir (handle, handle->name, &old_dir);
 
  char *new_dir;
  get_handle_data_subdir (handle, name, &new_dir);
 
  if ((GNUNET_YES == GNUNET_DISK_directory_test (new_dir, GNUNET_NO)) &&
      (GNUNET_OK != GNUNET_DISK_directory_remove(new_dir)))
    goto free_dirs;
 
  if (GNUNET_YES == GNUNET_DISK_directory_test (old_dir, GNUNET_YES))
  {
    GNUNET_DISK_directory_create_for_file (new_dir);
 
    if (0 != rename (old_dir, new_dir))
      goto free_dirs;
  }
 
  if (handle->ego)
    rename_store_ego(store, handle->name, name);
 
  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);
 
free_dirs:
  GNUNET_free(old_dir);
  GNUNET_free(new_dir);
}

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_remove(), GNUNET_DISK_directory_test(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_YES, handle, GNUNET_MESSENGER_MessageHandle::handle, iterate_send_message(), GNUNET_MESSENGER_MessageHandle::message, name, and rename_store_ego().

Referenced by set_handle_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

	[in/out]	handle Handle
[in]	name	New name

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

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

References callback_set_handle_name(), change_handle_name(), get_service_ego_store(), GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, handle, lookup_store_ego(), and name.

Referenced by handle_get_name(), and handle_set_name().

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

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

Returns

GNUNET_YES on success, otherwise GNUNET_NO

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

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

References create_handle_member_id(), get_handle_member_id(), GNUNET_assert, GNUNET_NO, 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_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

	[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 439 of file gnunet-service-messenger_handle.c.

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

References create_handle_member_id(), entry_service_room(), get_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_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

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

Returns

GNUNET_YES on success, otherwise GNUNET_NO

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

{
  GNUNET_assert((handle) && (key));
 
  if (!get_handle_member_id (handle, key))
    return GNUNET_NO;
 
  return close_service_room (handle->service, handle, key);
}

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

Referenced by handle_room_close().

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

	[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 464 of file gnunet-service-messenger_handle.c.

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

References copy_message(), get_handle_member_id(), get_service_room(), GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_NO, handle, key, msg, and send_room_message().

Referenced by handle_send_message(), and iterate_send_message().

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

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

References get_member_session_context(), and GNUNET_MESSENGER_MemberSession::next.

Referenced by notify_handle_message().

Here is the call graph for this function:

Here is the caller graph for this function:

get_handle_member_session()

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

static

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

{
  GNUNET_assert((handle) && (room) && (key) && (handle->service));
 
  const struct GNUNET_ShortHashCode *id = get_handle_member_id(handle, key);
 
  if (!id)
    return NULL;
 
  struct GNUNET_MESSENGER_MemberStore *store = get_room_member_store(room);
  struct GNUNET_MESSENGER_Member *member = get_store_member(store, id);
 
  const struct GNUNET_MESSENGER_Ego *ego = get_handle_ego(handle);
 
  if (!ego)
    return NULL;
 
  return get_member_session(member, &(ego->pub));
}

References get_handle_ego(), get_handle_member_id(), get_member_session(), get_room_member_store(), get_store_member(), GNUNET_assert, handle, key, GNUNET_MESSENGER_Ego::pub, GNUNET_MESSENGER_MemberStore::room, and GNUNET_MESSENGER_Member::store.

Referenced by notify_handle_message().

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,
		struct GNUNET_MESSENGER_SrvRoom *	room,
		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

	[in/out]	handle Handle
[in]	room	Room of the message
[in]	session	Member session
[in]	message	Message
[in]	hash	Hash of message

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

{
  GNUNET_assert((handle) && (room) && (session) && (message) && (hash));
 
  const struct GNUNET_HashCode *key = get_room_key(room);
 
  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) GNUNET_MESSENGER_FLAG_NONE;
 
  if (get_handle_member_session(handle, room, key) == session)
    msg->flags |= (uint32_t) GNUNET_MESSENGER_FLAG_SENT;
 
  if (private_message)
    msg->flags |= (uint32_t) GNUNET_MESSENGER_FLAG_PRIVATE;
 
  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);
}

References GNUNET_MESSENGER_MemberSession::contact, context, copy_message(), decrypt_message(), destroy_message(), encode_message(), env, get_contact_key(), get_handle_ego(), get_handle_member_id(), get_handle_member_session(), get_message_size(), get_next_member_session_contect(), get_room_key(), 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_FLAG_SENT, GNUNET_MESSENGER_KIND_PRIVATE, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_YES, handle, GNUNET_MESSENGER_Message::header, key, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_DNS_Handle::mq, msg, 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:

callback_scan_for_rooms()

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

static

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

{
  struct GNUNET_MESSENGER_SrvHandle *handle = cls;
 
  if ((strlen(filename) <= 4) || (0 != strcmp(filename + strlen(filename) - 4, ".cfg")))
    return GNUNET_OK;
 
  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Load room configuration of handle: %s\n", filename);
 
  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;
}

References cfg, change_handle_member_id(), filename, GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_destroy(), GNUNET_CONFIGURATION_get_data(), GNUNET_CONFIGURATION_parse(), GNUNET_DISK_file_test(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_OK, GNUNET_YES, handle, and key.

Referenced by load_handle_configuration().

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

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

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, handle, and find_typedefs::scan_dir().

Referenced by callback_setup_handle_name().

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

{
  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);
 
  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Save room configuration of handle: %s\n", filename);
 
  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;
}

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_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_STRINGS_data_to_string_alloc(), GNUNET_YES, handle, key, and value.

Referenced by save_handle_configuration().

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

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

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, handle, and iterate_save_rooms().

Referenced by destroy_handle().

Here is the call graph for this function:

Here is the caller graph for this function: