#include "gnunet-service-messenger_service.h"
#include "gnunet-service-messenger_message_kind.h"
#include "gnunet-service-messenger_room.h"
#include "gnunet_common.h"
#include "messenger_api_util.h"

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

Data Structures
struct	HandleInitializationClosure

Functions
static void	callback_shutdown_service (void *cls)

struct GNUNET_MESSENGER_Service *	create_service (const struct GNUNET_CONFIGURATION_Handle config, struct GNUNET_SERVICE_Handle service_handle)
	Creates and allocates a new service using a given config and a GNUnet service handle. More...

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

void	destroy_service (struct GNUNET_MESSENGER_Service *service)
	Destroys a service and frees its memory fully. More...

struct GNUNET_MESSENGER_ContactStore *	get_service_contact_store (struct GNUNET_MESSENGER_Service *service)
	Returns the used contact store of a given service. More...

struct GNUNET_MESSENGER_SrvHandle *	add_service_handle (struct GNUNET_MESSENGER_Service service, struct GNUNET_MQ_Handle mq)
	Creates and adds a new handle to a service using a given message queue. More...

void	remove_service_handle (struct GNUNET_MESSENGER_Service service, struct GNUNET_MESSENGER_SrvHandle handle)
	Removes a handle from a service and destroys it. More...

enum GNUNET_GenericReturnValue	get_service_peer_identity (struct GNUNET_MESSENGER_Service service, struct GNUNET_PeerIdentity peer)
	Tries to write the peer identity of the peer running a service on to the peer parameter. More...

struct GNUNET_MESSENGER_SrvRoom *	get_service_room (const struct GNUNET_MESSENGER_Service service, const struct GNUNET_HashCode key)
	Returns the room identified by a given key for a service. More...

static enum GNUNET_GenericReturnValue	find_member_session_in_room (void cls, const struct GNUNET_CRYPTO_PublicKey public_key, struct GNUNET_MESSENGER_MemberSession *session)

static void	initialize_service_handle (struct GNUNET_MESSENGER_SrvHandle handle, struct GNUNET_MESSENGER_SrvRoom room)

enum GNUNET_GenericReturnValue	open_service_room (struct GNUNET_MESSENGER_Service service, struct GNUNET_MESSENGER_SrvHandle handle, const struct GNUNET_HashCode *key)
	Tries to open a room using a given key for a service by a specific handle. More...

enum GNUNET_GenericReturnValue	entry_service_room (struct GNUNET_MESSENGER_Service service, struct GNUNET_MESSENGER_SrvHandle handle, const struct GNUNET_PeerIdentity door, const struct GNUNET_HashCode key)
	Tries to enter a room using a given key for a service by a specific handle. More...

enum GNUNET_GenericReturnValue	close_service_room (struct GNUNET_MESSENGER_Service service, struct GNUNET_MESSENGER_SrvHandle handle, const struct GNUNET_HashCode *key, enum GNUNET_GenericReturnValue deletion)
	Tries to close a room using a given key for a service by a specific handle. More...

void	handle_service_message (struct GNUNET_MESSENGER_Service service, struct GNUNET_MESSENGER_SrvRoom room, const struct GNUNET_MESSENGER_SenderSession session, const struct GNUNET_MESSENGER_Message message, const struct GNUNET_HashCode *hash)
	Sends a received or sent message with a given hash to each handle of a service which is currently member of a specific room for handling it in the client API. More...

Function Documentation

◆ callback_shutdown_service()

static void callback_shutdown_service ( void * cls )

static

Definition at line 35 of file gnunet-service-messenger_service.c.

{
  struct GNUNET_MESSENGER_Service *service;
 
  service = cls;
 
  if (service)
  {
    service->shutdown = NULL;
 
    destroy_service (service);
  }
}

References destroy_service(), and service.

Referenced by create_service().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_service()

struct GNUNET_MESSENGER_Service * create_service	(	const struct GNUNET_CONFIGURATION_Handle *	config,
		struct GNUNET_SERVICE_Handle *	service_handle
	)

Creates and allocates a new service using a given config and a GNUnet service handle.

Parameters

[in]	config	Configuration
[in,out]	service_handle	GNUnet service handle

Returns: New service

Definition at line 51 of file gnunet-service-messenger_service.c.

{
  struct GNUNET_MESSENGER_Service *service;
 
  GNUNET_assert ((config) && (service_handle));
 
  service = GNUNET_new (struct GNUNET_MESSENGER_Service);
 
  service->config = config;
  service->service = service_handle;
 
  service->shutdown = GNUNET_SCHEDULER_add_shutdown (&callback_shutdown_service,
                                                     service);
 
  service->peer = NULL;
  service->dir = NULL;
 
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (service->config,
                                                            GNUNET_MESSENGER_SERVICE_NAME,
                                                            "MESSENGER_DIR",
                                                            &(service->dir)))
  {
    if (service->dir)
      GNUNET_free (service->dir);
 
    service->dir = NULL;
  }
  else
  {
    if ((GNUNET_YES != GNUNET_DISK_directory_test (service->dir, GNUNET_YES)) &&
        (GNUNET_OK
         !=
         GNUNET_DISK_directory_create (service->dir)))
    {
      GNUNET_free (service->dir);
 
      service->dir = NULL;
    }
  }
 
  service->auto_connecting = GNUNET_CONFIGURATION_get_value_yesno (
    service->config,
    GNUNET_MESSENGER_SERVICE_NAME,
    "MESSENGER_AUTO_CONNECTING");
 
  service->auto_routing = GNUNET_CONFIGURATION_get_value_yesno (service->config,
                                                                GNUNET_MESSENGER_SERVICE_NAME,
                                                                "MESSENGER_AUTO_ROUTING");
 
  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (service->config,
                                                          GNUNET_MESSENGER_SERVICE_NAME,
                                                          "MESSENGER_MIN_ROUTERS",
                                                          &(service->min_routers
                                                            )))
    service->min_routers = 0;
 
  service->cadet = GNUNET_CADET_connect (service->config);
  service->statistics = GNUNET_STATISTICS_create (GNUNET_MESSENGER_SERVICE_NAME,
                                                  service->config);
 
  init_list_handles (&(service->handles));
 
  service->rooms = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
 
  init_contact_store (get_service_contact_store (service));
 
  return service;
}

References callback_shutdown_service(), config, get_service_contact_store(), GNUNET_assert, GNUNET_CADET_connect(), GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CONTAINER_multihashmap_create(), GNUNET_DISK_directory_create(), GNUNET_DISK_directory_test(), GNUNET_free, GNUNET_MESSENGER_SERVICE_NAME, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_shutdown(), GNUNET_STATISTICS_create(), GNUNET_YES, init_contact_store(), init_list_handles(), and service.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ iterate_destroy_rooms()

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

static

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

{
  struct GNUNET_MESSENGER_SrvRoom *room;
 
  GNUNET_assert (value);
 
  room = value;
 
  destroy_srv_room (room, GNUNET_NO);
  return GNUNET_YES;
}

References destroy_srv_room(), GNUNET_assert, GNUNET_NO, GNUNET_YES, and value.

Referenced by destroy_service().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ destroy_service()

void destroy_service ( struct GNUNET_MESSENGER_Service * service )

Destroys a service and frees its memory fully.

Parameters

[in,out] service Service

Definition at line 139 of file gnunet-service-messenger_service.c.

{
  GNUNET_assert (service);
 
  if (service->shutdown)
  {
    GNUNET_SCHEDULER_cancel (service->shutdown);
    service->shutdown = NULL;
  }
 
  clear_list_handles (&(service->handles));
 
  GNUNET_CONTAINER_multihashmap_iterate (service->rooms, iterate_destroy_rooms,
                                         NULL);
  GNUNET_CONTAINER_multihashmap_destroy (service->rooms);
 
  clear_contact_store (get_service_contact_store (service));
 
  if (service->cadet)
  {
    GNUNET_CADET_disconnect (service->cadet);
    service->cadet = NULL;
  }
 
  if (service->statistics)
  {
    GNUNET_STATISTICS_destroy (service->statistics,
                               GNUNET_YES);
    service->statistics = NULL;
  }
 
  if (service->dir)
  {
    GNUNET_free (service->dir);
    service->dir = NULL;
  }
 
  if (service->peer)
  {
    GNUNET_free (service->peer);
    service->peer = NULL;
  }
 
  GNUNET_SERVICE_shutdown (service->service);
  GNUNET_free (service);
}

References clear_contact_store(), clear_list_handles(), get_service_contact_store(), GNUNET_assert, GNUNET_CADET_disconnect(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_free, GNUNET_SCHEDULER_cancel(), GNUNET_SERVICE_shutdown(), GNUNET_STATISTICS_destroy(), GNUNET_YES, iterate_destroy_rooms(), and service.

Referenced by callback_shutdown_service().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_service_contact_store()

struct GNUNET_MESSENGER_ContactStore * get_service_contact_store ( struct GNUNET_MESSENGER_Service * service )

Returns the used contact store of a given service.

Parameters

[in,out] service Service

Returns: Contact store

Definition at line 188 of file gnunet-service-messenger_service.c.

{
  GNUNET_assert (service);
 
  return &(service->contact_store);
}

References GNUNET_assert, and service.

Referenced by create_service(), destroy_service(), and get_member_contact_store().

Here is the caller graph for this function:

◆ add_service_handle()

struct GNUNET_MESSENGER_SrvHandle * add_service_handle	(	struct GNUNET_MESSENGER_Service *	service,
		struct GNUNET_MQ_Handle *	mq
	)

Creates and adds a new handle to a service using a given message queue.

Parameters

[in,out]	service	Service
[in,out]	mq	Message queue

Returns: New handle

Definition at line 197 of file gnunet-service-messenger_service.c.

{
  struct GNUNET_MESSENGER_SrvHandle *handle;
 
  GNUNET_assert ((service) && (mq));
 
  handle = create_srv_handle (service, mq);
 
  if (handle)
  {
    add_list_handle (&(service->handles), handle);
    GNUNET_STATISTICS_update (service->statistics,
                              "# handles connected",
                              1,
                              GNUNET_NO);
  }
 
  return handle;
}

References add_list_handle(), create_srv_handle(), GNUNET_assert, GNUNET_NO, GNUNET_STATISTICS_update(), handle, mq, and service.

Referenced by callback_client_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ remove_service_handle()

void remove_service_handle	(	struct GNUNET_MESSENGER_Service *	service,
		struct GNUNET_MESSENGER_SrvHandle *	handle
	)

Removes a handle from a service and destroys it.

Parameters

[in,out]	service	Service
[in,out]	handle	Handle

Definition at line 220 of file gnunet-service-messenger_service.c.

{
  GNUNET_assert ((service) && (handle));
 
  if (! handle)
    return;
 
  if (GNUNET_YES == remove_list_handle (&(service->handles), handle))
  {
    destroy_srv_handle (handle);
    GNUNET_STATISTICS_update (service->statistics,
                              "# handles connected",
                              -1,
                              GNUNET_NO);
  }
}

References destroy_srv_handle(), GNUNET_assert, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_YES, handle, remove_list_handle(), and service.

Referenced by callback_client_disconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_service_peer_identity()

enum GNUNET_GenericReturnValue get_service_peer_identity	(	struct GNUNET_MESSENGER_Service *	service,
		struct GNUNET_PeerIdentity *	peer
	)

Tries to write the peer identity of the peer running a service on to the peer parameter.

The functions returns GNUNET_OK on success, otherwise GNUNET_SYSERR.

Parameters

[in,out]	service	Service
[out]	peer	Peer identity

Returns: GNUNET_OK on success, otherwise GNUNET_SYSERR

Definition at line 240 of file gnunet-service-messenger_service.c.

{
  enum GNUNET_GenericReturnValue result;
 
  GNUNET_assert ((service) && (peer));
 
  if (service->peer)
  {
    GNUNET_memcpy (peer, service->peer, sizeof(struct GNUNET_PeerIdentity));
    return GNUNET_OK;
  }
 
  result = GNUNET_CRYPTO_get_peer_identity (service->config, peer);
 
  if (GNUNET_OK != result)
    return result;
 
  if (! service->peer)
    service->peer = GNUNET_new (struct GNUNET_PeerIdentity);
 
  GNUNET_memcpy (service->peer, peer, sizeof(struct GNUNET_PeerIdentity));
  return result;
}

References GNUNET_assert, GNUNET_CRYPTO_get_peer_identity(), GNUNET_memcpy, GNUNET_new, GNUNET_OK, result, and service.

Referenced by close_srv_room(), create_message_peer(), enter_srv_room_at(), get_store_service_peer_identity(), pack_srv_room_message(), and rebuild_srv_room_basement_structure().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_service_room()

struct GNUNET_MESSENGER_SrvRoom * get_service_room	(	const struct GNUNET_MESSENGER_Service *	service,
		const struct GNUNET_HashCode *	key
	)

Returns the room identified by a given key for a service.

If the service doesn't know any room using the given key, NULL gets returned.

Parameters

[in]	service	Service
[in]	key	Key of room

Returns: Room or NULL

Definition at line 267 of file gnunet-service-messenger_service.c.

{
  GNUNET_assert ((service) && (key));
 
  return GNUNET_CONTAINER_multihashmap_get (service->rooms, key);
}

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), key, and service.

Referenced by close_service_room(), entry_service_room(), handle_get_message(), open_service_room(), send_srv_handle_message(), and sync_srv_handle_messages().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ find_member_session_in_room()

static enum GNUNET_GenericReturnValue find_member_session_in_room	(	void *	cls,
		const struct GNUNET_CRYPTO_PublicKey *	public_key,
		struct GNUNET_MESSENGER_MemberSession *	session
	)

static

Definition at line 284 of file gnunet-service-messenger_service.c.

{
  struct HandleInitializationClosure *init;
  const struct GNUNET_ShortHashCode *id;
 
  GNUNET_assert ((cls) && (session));
 
  init = cls;
 
  if (! public_key)
    return GNUNET_YES;
 
  {
    const struct GNUNET_CRYPTO_PublicKey *pubkey;
    pubkey = get_srv_handle_key (init->handle);
 
    if (0 != GNUNET_memcmp (pubkey, public_key))
      return GNUNET_YES;
  }
 
  id = get_member_session_id (session);
 
  if (! id)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Initialitation: Missing member id!");
    return GNUNET_NO;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Initialitation: Matching member found (%s)!\n",
              GNUNET_sh2s (id));
 
  change_srv_handle_member_id (init->handle, get_srv_room_key (init->room), id);
  return GNUNET_NO;
}

References change_srv_handle_member_id(), get_member_session_id(), get_srv_handle_key(), get_srv_room_key(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcmp, GNUNET_NO, GNUNET_sh2s(), GNUNET_YES, id, init, and pubkey.

Referenced by initialize_service_handle().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ initialize_service_handle()

static void initialize_service_handle	(	struct GNUNET_MESSENGER_SrvHandle *	handle,
		struct GNUNET_MESSENGER_SrvRoom *	room
	)

static

Definition at line 324 of file gnunet-service-messenger_service.c.

{
  struct GNUNET_MESSENGER_MemberStore *store;
  const struct GNUNET_CRYPTO_PublicKey *pubkey;
 
  GNUNET_assert ((handle) && (room));
 
  store = get_srv_room_member_store (room);
  if (! store)
    return;
 
  pubkey = get_srv_handle_key (handle);
  if ((! pubkey) || (0 == GNUNET_memcmp (pubkey, get_anonymous_public_key ())))
    return;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Initialize member id of handle via matching member in room!\n");
 
  {
    struct HandleInitializationClosure init;
    init.handle = handle;
    init.room = room;
    init.pubkey = pubkey;
 
    iterate_store_members (store, find_member_session_in_room, &init);
  }
}

References find_member_session_in_room(), get_anonymous_public_key(), get_srv_handle_key(), get_srv_room_member_store(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcmp, handle, init, iterate_store_members(), pubkey, and HandleInitializationClosure::room.

Referenced by entry_service_room(), and open_service_room().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ open_service_room()

enum GNUNET_GenericReturnValue open_service_room	(	struct GNUNET_MESSENGER_Service *	service,
		struct GNUNET_MESSENGER_SrvHandle *	handle,
		const struct GNUNET_HashCode *	key
	)

Tries to open a room using a given key for a service by a specific handle.

The room will be created if necessary. If the function is successful, it returns GNUNET_YES, otherwise GNUNET_NO.

Parameters

[in,out]	service	Service
[in,out]	handle	Handle
[in]	key	Key of room

Returns: GNUNET_YES on success, otherwise GNUNET_NO

Definition at line 355 of file gnunet-service-messenger_service.c.

{
  struct GNUNET_MESSENGER_SrvRoom *room;
  enum GNUNET_GenericReturnValue result;
 
  GNUNET_assert ((service) && (handle) && (key));
 
  room = get_service_room (service, key);
 
  if (room)
  {
    initialize_service_handle (handle, room);
    result = open_srv_room (room, handle);
 
    if (GNUNET_YES == result)
      GNUNET_STATISTICS_update (service->statistics,
                                "# room openings",
                                1,
                                GNUNET_NO);
    return result;
  }
 
  room = create_srv_room (handle, key);
  initialize_service_handle (handle, room);
 
  if ((GNUNET_YES == open_srv_room (room, handle)) &&
      (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (service->rooms,
                                                       key, room,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)))
  {
    GNUNET_STATISTICS_update (service->statistics,
                              "# room openings",
                              1,
                              GNUNET_NO);
    GNUNET_STATISTICS_set (service->statistics,
                           "# rooms active",
                           GNUNET_CONTAINER_multihashmap_size (service->rooms),
                           GNUNET_NO);
    return GNUNET_YES;
  }
 
  destroy_srv_room (room, GNUNET_YES);
  return GNUNET_NO;
}

References create_srv_room(), destroy_srv_room(), get_service_room(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_set(), GNUNET_STATISTICS_update(), GNUNET_YES, handle, initialize_service_handle(), key, open_srv_room(), result, and service.

Referenced by open_srv_handle_room().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ entry_service_room()

enum GNUNET_GenericReturnValue entry_service_room	(	struct GNUNET_MESSENGER_Service *	service,
		struct GNUNET_MESSENGER_SrvHandle *	handle,
		const struct GNUNET_PeerIdentity *	door,
		const struct GNUNET_HashCode *	key
	)

Tries to enter a room using a given key for a service by a specific handle.

The room will be created if necessary. If the function is successful, it returns GNUNET_YES, otherwise GNUNET_NO.

The room will be entered through the peer identitied by the peer identity provided as door parameter and a new connection will be made.

Parameters

[in,out]	service	Service
[in,out]	handle	Handle
[in]	door	Peer identity
[in]	key	Key of room

Returns: GNUNET_YES on success, otherwise GNUNET_NO

Definition at line 404 of file gnunet-service-messenger_service.c.

{
  struct GNUNET_MESSENGER_SrvRoom *room;
 
  GNUNET_assert ((service) && (handle) && (door) && (key));
 
  room = get_service_room (service, key);
 
  if (room)
  {
    initialize_service_handle (handle, room);
 
    if (GNUNET_YES == enter_srv_room_at (room, handle, door))
    {
      GNUNET_STATISTICS_update (service->statistics,
                                "# room entries",
                                1,
                                GNUNET_NO);
      return GNUNET_YES;
    }
    else
      return GNUNET_NO;
  }
 
  room = create_srv_room (handle, key);
  initialize_service_handle (handle, room);
 
  if ((GNUNET_YES == enter_srv_room_at (room, handle, door)) &&
      (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (service->rooms,
                                                       key, room,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST)))
  {
    GNUNET_STATISTICS_update (service->statistics,
                              "# room entries",
                              1,
                              GNUNET_NO);
    GNUNET_STATISTICS_set (service->statistics,
                           "# rooms active",
                           GNUNET_CONTAINER_multihashmap_size (service->rooms),
                           GNUNET_NO);
    return GNUNET_YES;
  }
  else
  {
    destroy_srv_room (room, GNUNET_YES);
    return GNUNET_NO;
  }
 
}

References create_srv_room(), destroy_srv_room(), enter_srv_room_at(), get_service_room(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_set(), GNUNET_STATISTICS_update(), GNUNET_YES, handle, initialize_service_handle(), key, and service.

Referenced by entry_srv_handle_room().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ close_service_room()

enum GNUNET_GenericReturnValue close_service_room	(	struct GNUNET_MESSENGER_Service *	service,
		struct GNUNET_MESSENGER_SrvHandle *	handle,
		const struct GNUNET_HashCode *	key,
		enum GNUNET_GenericReturnValue	deletion
	)

Tries to close a room using a given key for a service by a specific handle.

The room will be created if necessary. If the function is successful, it returns GNUNET_YES, otherwise GNUNET_NO.

If the specific handle is currently the host of the room for this service, a new handle which is a member will take its place. Otherwise the room will be destroyed for this service.

Parameters

[in,out]	service	Service
[in,out]	handle	Handle
[in]	key	Key of room
[in]	deletion	Flag to indicate context of closing

Returns: GNUNET_YES on success, otherwise GNUNET_NO

Definition at line 459 of file gnunet-service-messenger_service.c.

{
  struct GNUNET_MESSENGER_SrvRoom *room;
  struct GNUNET_MESSENGER_SrvHandle *member_handle;
 
  GNUNET_assert ((service) && (handle) && (key));
 
  room = get_service_room (service, key);
 
  if (! room)
    return GNUNET_NO;
 
  {
    struct GNUNET_ShortHashCode *id;
    id = (struct GNUNET_ShortHashCode*) (
      GNUNET_CONTAINER_multihashmap_get (handle->member_ids, key));
 
    GNUNET_assert (id);
 
    if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove (handle->member_ids,
                                                            key, id))
      return GNUNET_NO;
 
    GNUNET_free (id);
  }
 
  member_handle = (struct GNUNET_MESSENGER_SrvHandle*) (
    find_list_handle_by_member (&(service->handles), key));
 
  if (! member_handle)
  {
    if (GNUNET_OK == GNUNET_CONTAINER_multihashmap_remove (service->rooms, key,
                                                           room))
    {
      destroy_srv_room (room, deletion);
      GNUNET_STATISTICS_update (service->statistics,
                                "# room closings",
                                1,
                                GNUNET_NO);
      GNUNET_STATISTICS_set (service->statistics,
                             "# rooms active",
                             GNUNET_CONTAINER_multihashmap_size (service->rooms)
                             ,
                             GNUNET_NO);
      return GNUNET_YES;
    }
    else
      return GNUNET_NO;
  }
 
  if (room->host == handle)
  {
    room->host = member_handle;
 
    if (room->peer_message)
      send_srv_room_message (room, room->host, create_message_connection (
                               room));
  }
 
  GNUNET_STATISTICS_update (service->statistics,
                            "# room closings",
                            1,
                            GNUNET_NO);
 
  return GNUNET_YES;
}

References create_message_connection(), destroy_srv_room(), find_list_handle_by_member(), get_service_room(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_free, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_set(), GNUNET_STATISTICS_update(), GNUNET_YES, handle, GNUNET_MESSENGER_SrvRoom::host, id, key, GNUNET_MESSENGER_SrvRoom::peer_message, send_srv_room_message(), and service.

Referenced by close_srv_handle_room(), and iterate_close_rooms().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_service_message()

void handle_service_message	(	struct GNUNET_MESSENGER_Service *	service,
		struct GNUNET_MESSENGER_SrvRoom *	room,
		const struct GNUNET_MESSENGER_SenderSession *	session,
		const struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_HashCode *	hash
	)

Sends a received or sent message with a given hash to each handle of a service which is currently member of a specific room for handling it in the client API.

Parameters

[in,out]	service	Service
[in,out]	room	Room
[in]	session	Sender session
[in]	message	Message
[in]	hash	Hash of message

Definition at line 531 of file gnunet-service-messenger_service.c.

{
  struct GNUNET_MESSENGER_ListHandle *element;
 
  GNUNET_assert ((service) && (room) && (session) && (message) && (hash));
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Notify active clients about message: %s (%s)\n",
              GNUNET_h2s (hash), GNUNET_MESSENGER_name_of_kind (
                message->header.kind));
 
  element = service->handles.head;
 
  while (element)
  {
    notify_srv_handle_message (element->handle, room, session, message, hash,
                               GNUNET_YES);
    element = element->next;
  }
 
  GNUNET_STATISTICS_update (service->statistics,
                            "# message notifications",
                            1,
                            GNUNET_NO);
}

References GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_MESSENGER_name_of_kind(), GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_YES, GNUNET_MESSENGER_ListHandle::handle, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_ListHandle::next, notify_srv_handle_message(), and service.

Referenced by handle_room_messages().

Here is the call graph for this function:

Here is the caller graph for this function:

Data Structures

Functions

Function Documentation

◆ callback_shutdown_service()

◆ create_service()

◆ iterate_destroy_rooms()

◆ destroy_service()

◆ get_service_contact_store()

◆ add_service_handle()

◆ remove_service_handle()

◆ get_service_peer_identity()

◆ get_service_room()

◆ find_member_session_in_room()

◆ initialize_service_handle()

◆ open_service_room()

◆ entry_service_room()

◆ close_service_room()

◆ handle_service_message()