gnunet-service-messenger_handle.c File Reference

GNUnet MESSENGER service. More...

#include "platform.h"
#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_srv_handle (struct GNUNET_MESSENGER_Service *service, struct GNUNET_MQ_Handle *mq)
	Creates and allocates a new handle related to a service and using a given mq (message queue). More...
int	iterate_free_member_ids (void *cls, const struct GNUNET_HashCode *key, void *value)
void	destroy_srv_handle (struct GNUNET_MESSENGER_SrvHandle *handle)
	Destroys a handle and frees its memory fully. More...
void	get_srv_handle_data_subdir (const struct GNUNET_MESSENGER_SrvHandle *handle, const char *name, char **dir)
	Writes the path of the directory for a given handle using a specific name to the parameter dir. More...
static int	create_handle_member_id (const struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
const struct GNUNET_ShortHashCode *	get_srv_handle_member_id (const struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
	Returns the member id of a given handle in a specific room. More...
int	change_srv_handle_member_id (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key, const struct GNUNET_ShortHashCode *unique_id)
	Changes the member id of a given handle in a specific room to match a unique_id and returns GNUNET_OK on success. More...
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_srv_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_srv_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_srv_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_srv_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_srv_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_srv_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
	Makes a given handle a member of the room using a specific key and opens the room from the handles service. More...
int	entry_srv_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_PeerIdentity *door, const struct GNUNET_HashCode *key)
	Makes a given handle a member of the room using a specific key and enters the room through a tunnel to a peer identified by a given door (peer identity). More...
int	close_srv_handle_room (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
	Removes the membership of the room using a specific key and closes it if no other handle from this service is still a member of it. More...
int	send_srv_handle_message (struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key, const struct GNUNET_MESSENGER_Message *message)
	Sends a message from a given handle to the room using a specific key. More...
static const struct GNUNET_HashCode *	get_next_member_session_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_srv_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_srv_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_srv_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_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 35 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().

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

{
  GNUNET_free(value);
 
  return GNUNET_YES;
}

References GNUNET_free, GNUNET_YES, and value.

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

{
  GNUNET_assert(handle);
 
  if (handle->service->dir)
    save_srv_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_srv_handle_configuration(), and unbind_store_ego().

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:

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 87 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_srv_handle_configuration(), and save_srv_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 102 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_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 128 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_service_room(), close_srv_handle_room(), entry_srv_handle_room(), find_list_handle_by_member(), get_handle_member_session(), handle_get_message(), handle_room_entry(), handle_room_open(), join_room_locally(), notify_srv_handle_message(), open_srv_handle_room(), open_srv_room(), pack_srv_room_message(), send_srv_handle_message(), send_srv_room_message(), and solve_srv_room_member_collisions().

Here is the call graph for this function:

Here is the caller graph for this function:

change_srv_handle_member_id()

int 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 137 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 183 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_srv_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 211 of file gnunet-service-messenger_handle.c.

{
  GNUNET_assert(handle);
 
  handle->ego = ego;
 
  ego = get_srv_handle_ego (handle);
 
  const uint16_t length = GNUNET_IDENTITY_public_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_public_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_srv_handle_ego(), GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_IDENTITY_public_key_get_length(), GNUNET_IDENTITY_write_public_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_srv_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 242 of file gnunet-service-messenger_handle.c.

{
  struct GNUNET_MESSENGER_MessageHandle *msg_handle = cls;
 
  send_srv_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_srv_handle_message().

Referenced by callback_set_handle_name(), and set_srv_handle_ego().

Here is the call graph for this function:

Here is the caller graph for this function:

set_srv_handle_ego()

void set_srv_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 254 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_srv_handle_ego()

const struct GNUNET_MESSENGER_Ego* get_srv_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 272 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_srv_handle_message(), pack_srv_room_message(), recv_message_info(), send_room_info(), and solve_srv_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 294 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_srv_handle_configuration (handle);
}

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

Referenced by setup_srv_handle_name().

Here is the call graph for this function:

Here is the caller graph for this function:

setup_srv_handle_name()

void setup_srv_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 310 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 321 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_srv_handle().

Here is the call graph for this function:

Here is the caller graph for this function:

update_srv_handle()

void update_srv_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 340 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 356 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_srv_handle_data_subdir (handle, handle->name, &old_dir);
 
  char *new_dir;
  get_srv_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_service_ego_store(), get_srv_handle_data_subdir(), 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_srv_handle_name().

Here is the call graph for this function:

Here is the caller graph for this function:

set_srv_handle_name()

void set_srv_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 407 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_set_name().

Here is the call graph for this function:

Here is the caller graph for this function:

open_srv_handle_room()

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

{
  GNUNET_assert((handle) && (key));
 
  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_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_srv_handle_room()

int 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 440 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()

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

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

References close_service_room(), get_srv_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_srv_handle_message()

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

{
  GNUNET_assert((handle) && (key) && (message));
 
  const struct GNUNET_ShortHashCode *id = get_srv_handle_member_id (handle, key);
 
  if (!id)
  {
    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "It is required to be a member of a room to send messages!\n");
    return GNUNET_NO;
  }
 
  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_srv_room_message (room, handle, msg);
}

References copy_message(), get_service_room(), get_srv_handle_member_id(), GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_NO, handle, key, msg, and send_srv_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 495 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_srv_handle_message().

Here is the call graph for this function:

Here is the caller graph for this function:

get_handle_member_session()

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

static

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

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

References get_member_session(), get_srv_handle_ego(), get_srv_handle_member_id(), get_srv_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_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_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 527 of file gnunet-service-messenger_handle.c.

{
  GNUNET_assert((handle) && (room) && (session) && (message) && (hash));
 
  const struct GNUNET_HashCode *key = get_srv_room_key(room);
 
  if ((!handle->mq) || (!get_srv_handle_member_id (handle, key)))
  {
    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Notifying client about message requires membership!\n");
    return;
  }
 
  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_srv_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_member_session(), get_message_size(), get_next_member_session_contect(), get_srv_handle_ego(), get_srv_handle_member_id(), get_srv_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 597 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_srv_handle_member_id (handle, &key, &member_id);
  }
 
  GNUNET_CONFIGURATION_destroy (cfg);
  return GNUNET_OK;
}

References cfg, change_srv_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_srv_handle_configuration().

Here is the call graph for this function:

Here is the caller graph for this function:

load_srv_handle_configuration()

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

{
  GNUNET_assert(handle);
 
  char *id_dir;
  get_srv_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_srv_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 646 of file gnunet-service-messenger_handle.c.

{
  struct GNUNET_MESSENGER_SrvHandle *handle = cls;
  struct GNUNET_ShortHashCode *member_id = value;
 
  char *id_dir;
  get_srv_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_srv_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_srv_handle_configuration().

Here is the call graph for this function:

Here is the caller graph for this function:

save_srv_handle_configuration()

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

{
  GNUNET_assert(handle);
 
  char *id_dir;
  get_srv_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_srv_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_srv_handle().

Here is the call graph for this function:

Here is the caller graph for this function: