#include "gnunet_util_lib.h"
#include "gnunet_pils_service.h"
#include "gnunet_statistics_service.h"
#include "gnunet-service-messenger_list_handles.h"
#include "gnunet-service-messenger_sender_session.h"
#include "messenger_api_contact_store.h"

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

This graph shows which files directly or indirectly include this file:

Data Structures
struct	GNUNET_MESSENGER_Service

Functions
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.

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

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

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.

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

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.

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.

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.

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.

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.

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, const struct GNUNET_HashCode epoch, enum GNUNET_GenericReturnValue recent)
	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.

Function Documentation

◆ 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 159 of file gnunet-service-messenger_service.c.

{
  struct GNUNET_MESSENGER_Service *service;
 
  GNUNET_assert ((config) && (service_handle));
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Create new service!\n");
 
  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->identity = 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");
 
  service->group_keys = GNUNET_CONFIGURATION_get_value_yesno (
    service->config,
    GNUNET_MESSENGER_SERVICE_NAME,
    "MESSENGER_GROUP_KEYS");
 
  service->local_request = GNUNET_CONFIGURATION_get_value_yesno (
    service->config,
    GNUNET_MESSENGER_SERVICE_NAME,
    "MESSENGER_LOCAL_REQUEST");
 
  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->pils = GNUNET_PILS_connect (service->config,
                                       &callback_peer_id_changed,
                                       service);
  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_peer_id_changed(), 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_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_MESSENGER_SERVICE_NAME, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_PILS_connect(), 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:

◆ 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 263 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->pils)
  {
    GNUNET_PILS_disconnect (service->pils);
    service->pils = 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->identity)
  {
    GNUNET_free (service->identity);
    service->identity = NULL;
  }
 
  GNUNET_SERVICE_shutdown (service->service);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Free service!\n");
 
  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_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_PILS_disconnect(), 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 320 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 329 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 352 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 372 of file gnunet-service-messenger_service.c.

{
  GNUNET_assert ((service) && (peer));
 
  if (NULL == service->identity)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Service does not know its peer's identity!\n");
    return GNUNET_SYSERR;
  }
 
  GNUNET_memcpy (peer, service->identity, sizeof(*peer));
  return GNUNET_OK;
}

References GNUNET_assert, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_memcpy, GNUNET_OK, GNUNET_SYSERR, and service.

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

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 390 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(), iterate_srv_handle_sync_finished(), open_service_room(), send_srv_handle_message(), and sync_srv_handle_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 479 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 528 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 583 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->sync == handle)
    room->sync = NULL;
 
  if (room->host == handle)
  {
    struct GNUNET_MESSENGER_Message *message;
 
    room->host = member_handle;
 
    if (! room->peer_message)
      goto skip_connection_message;
 
    message = create_message_connection (room);
 
    if (! message)
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Sending connection message failed: %s\n",
                  GNUNET_h2s (&(room->key)));
    else
      send_srv_room_message (room, room->host, message);
  }
 
skip_connection_message:
  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_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_set(), GNUNET_STATISTICS_update(), GNUNET_YES, handle, GNUNET_MESSENGER_SrvRoom::host, id, key, GNUNET_MESSENGER_SrvRoom::key, GNUNET_MESSENGER_SrvRoom::peer_message, send_srv_room_message(), service, and GNUNET_MESSENGER_SrvRoom::sync.

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,
		const struct GNUNET_HashCode *	epoch,
		enum GNUNET_GenericReturnValue	recent
	)

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
[in]	epoch	Hash of epoch
[in]	recent	Whether the message was recently received

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

{
  struct GNUNET_MESSENGER_ListHandle *element;
 
  GNUNET_assert ((service) && (room) && (session) && (message) && (hash) && (
                   epoch));
 
  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));
 
  for (element = service->handles.head; element; element = element->next)
  {
    if (! get_srv_handle_member_id (element->handle,
                                    get_srv_room_key (room)))
      continue;
 
    notify_srv_handle_message (element->handle, room, session, message, hash,
                               epoch, recent);
  }
 
  GNUNET_STATISTICS_update (service->statistics,
                            "# message notifications",
                            1,
                            GNUNET_NO);
}

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

Referenced by callback_found_message(), and handle_room_messages().

Here is the call graph for this function:

Here is the caller graph for this function:

Data Structures

Functions

Function Documentation

◆ create_service()

◆ destroy_service()

◆ get_service_contact_store()

◆ add_service_handle()

◆ remove_service_handle()

◆ get_service_peer_identity()

◆ get_service_room()

◆ open_service_room()

◆ entry_service_room()

◆ close_service_room()

◆ handle_service_message()