#include "gnunet-service-messenger_tunnel.h"
#include "gnunet-service-messenger_message_kind.h"
#include "gnunet-service-messenger_message_recv.h"
#include "gnunet-service-messenger_message_store.h"
#include "gnunet-service-messenger_operation_store.h"
#include "gnunet-service-messenger_operation.h"
#include "gnunet-service-messenger_room.h"
#include "gnunet_common.h"
#include "gnunet_messenger_service.h"
#include "gnunet_util_lib.h"
#include "messenger_api_message.h"
#include "messenger_api_util.h"

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

Data Structures
struct	GNUNET_MESSENGER_MessageSent

Functions
struct GNUNET_MESSENGER_SrvTunnel *	create_tunnel (struct GNUNET_MESSENGER_SrvRoom room, const struct GNUNET_PeerIdentity door)
	Creates and allocates a tunnel of a room to a specific peer identity (called door).

void	destroy_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel)
	Destroys a tunnel and frees its memory fully.

void	bind_tunnel (struct GNUNET_MESSENGER_SrvTunnel tunnel, struct GNUNET_CADET_Channel channel)
	Binds a CADET channel to a tunnel and replaces its channel the tunnel is currently bound to if necessary.

void	callback_tunnel_disconnect (void cls, const struct GNUNET_CADET_Channel channel)
	Callback for a CADET channel disconnecting to manage this event as a proper tunnel provided as its closure.

static enum GNUNET_GenericReturnValue	verify_tunnel_message (struct GNUNET_MESSENGER_SrvRoom room, struct GNUNET_MESSENGER_Message message, struct GNUNET_HashCode *hash)

enum GNUNET_GenericReturnValue	check_tunnel_message (void cls, const struct GNUNET_MessageHeader header)
	Callback for message verification via header in a tunnel that is provided as a closure from a CADET channel.

enum GNUNET_GenericReturnValue	update_room_message (struct GNUNET_MESSENGER_SrvRoom room, struct GNUNET_MESSENGER_Message message, const struct GNUNET_HashCode *hash)

void	callback_room_handle_message (struct GNUNET_MESSENGER_SrvRoom room, const struct GNUNET_MESSENGER_Message message, const struct GNUNET_HashCode *hash)

static void	update_tunnel_last_message (struct GNUNET_MESSENGER_SrvTunnel tunnel, const struct GNUNET_HashCode hash)

void	handle_tunnel_message (void cls, const struct GNUNET_MessageHeader header)
	Callback for message handling via header in a tunnel that is provided as a closure from a CADET channel.

enum GNUNET_GenericReturnValue	connect_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel)
	Tries to connect a tunnel by creating a new CADET channel and binding it.

void	disconnect_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel)
	Disconnects and unbinds a channel from a tunnel.

enum GNUNET_GenericReturnValue	is_tunnel_connected (const struct GNUNET_MESSENGER_SrvTunnel *tunnel)
	Returns the status of a currently bound channel of a tunnel.

static void	callback_tunnel_sent (void *cls)

void	send_tunnel_envelope (struct GNUNET_MESSENGER_SrvTunnel tunnel, struct GNUNET_MQ_Envelope env, const struct GNUNET_HashCode *hash)
	Sends an envelope containing a message with a given hash through a tunnel.

static void	callback_tunnel_message_signed (void cls, struct GNUNET_MESSENGER_SrvRoom room, struct GNUNET_MESSENGER_Message message, struct GNUNET_MQ_Envelope envelope, const struct GNUNET_HashCode *hash)

enum GNUNET_GenericReturnValue	send_tunnel_message (struct GNUNET_MESSENGER_SrvTunnel tunnel, void handle, struct GNUNET_MESSENGER_Message *message)
	Sends a message by packing it automatically into an envelope and passing it through the tunnel.

void	forward_tunnel_message (struct GNUNET_MESSENGER_SrvTunnel tunnel, const struct GNUNET_MESSENGER_Message message, const struct GNUNET_HashCode *hash)
	Forwards a given message with a known hash through a tunnel.

const struct GNUNET_HashCode *	get_tunnel_peer_message (const struct GNUNET_MESSENGER_SrvTunnel *tunnel)
	Returns the hash of the latest peer message published through a given tunnel and matching the tunnels peer identity.

void	get_tunnel_peer_identity (const struct GNUNET_MESSENGER_SrvTunnel tunnel, struct GNUNET_PeerIdentity peer)
	Writes the peer identity of the peer connected via tunnel to this peer into the peer parameter.

uint32_t	get_tunnel_messenger_version (const struct GNUNET_MESSENGER_SrvTunnel *tunnel)
	Returns the current messenger version the peer connected via a given tunnel has reported to be using if it was compatible during updating.

enum GNUNET_GenericReturnValue	update_tunnel_messenger_version (struct GNUNET_MESSENGER_SrvTunnel *tunnel, uint32_t version)
	Updates the messenger version of the tunnel to a given version if it is compatible to the running peer of the service.

Function Documentation

◆ create_tunnel()

struct GNUNET_MESSENGER_SrvTunnel * create_tunnel	(	struct GNUNET_MESSENGER_SrvRoom *	room,
		const struct GNUNET_PeerIdentity *	door
	)

Creates and allocates a tunnel of a room to a specific peer identity (called door).

Parameters

[in,out]	room	Room
[in]	door	Peer identity

Returns: New tunnel

Definition at line 42 of file gnunet-service-messenger_tunnel.c.

{
  struct GNUNET_MESSENGER_SrvTunnel *tunnel;
 
  GNUNET_assert ((room) && (door));
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Create new tunnel: %s\n",
              GNUNET_i2s (door));
 
  tunnel = GNUNET_new (struct GNUNET_MESSENGER_SrvTunnel);
 
  tunnel->room = room;
  tunnel->channel = NULL;
 
  tunnel->peer = GNUNET_PEER_intern (door);
 
  tunnel->messenger_version = 0;
 
  tunnel->peer_message = NULL;
 
  init_message_state (&(tunnel->state));
 
  return tunnel;
}

References GNUNET_MESSENGER_SrvTunnel::channel, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_log, GNUNET_new, GNUNET_PEER_intern(), init_message_state(), GNUNET_MESSENGER_SrvTunnel::messenger_version, GNUNET_MESSENGER_SrvTunnel::peer, GNUNET_MESSENGER_SrvTunnel::peer_message, GNUNET_MESSENGER_SrvTunnel::room, and GNUNET_MESSENGER_SrvTunnel::state.

Referenced by callback_room_connect(), and enter_srv_room_at().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ destroy_tunnel()

void destroy_tunnel ( struct GNUNET_MESSENGER_SrvTunnel * tunnel )

Destroys a tunnel and frees its memory fully.

Parameters

[in,out] tunnel

Definition at line 70 of file gnunet-service-messenger_tunnel.c.

{
  GNUNET_assert (tunnel);
 
  if (tunnel->channel)
    GNUNET_CADET_channel_destroy (tunnel->channel);
 
  GNUNET_PEER_change_rc (tunnel->peer, -1);
 
  if (tunnel->peer_message)
    GNUNET_free (tunnel->peer_message);
 
  clear_message_state (&(tunnel->state));
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Free tunnel!\n");
 
  GNUNET_free (tunnel);
}

References GNUNET_MESSENGER_SrvTunnel::channel, clear_message_state(), GNUNET_assert, GNUNET_CADET_channel_destroy(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_PEER_change_rc(), GNUNET_MESSENGER_SrvTunnel::peer, GNUNET_MESSENGER_SrvTunnel::peer_message, and GNUNET_MESSENGER_SrvTunnel::state.

Here is the call graph for this function:

◆ bind_tunnel()

void bind_tunnel	(	struct GNUNET_MESSENGER_SrvTunnel *	tunnel,
		struct GNUNET_CADET_Channel *	channel
	)

Binds a CADET channel to a tunnel and replaces its channel the tunnel is currently bound to if necessary.

Parameters

[in,out]	tunnel	Tunnel
[in,out]	channel	CADET channel

Definition at line 91 of file gnunet-service-messenger_tunnel.c.

{
  GNUNET_assert (tunnel);
 
  if (tunnel->channel)
    delayed_disconnect_channel (tunnel->channel);
 
  tunnel->channel = channel;
}

References GNUNET_MESSENGER_SrvTunnel::channel, delayed_disconnect_channel(), and GNUNET_assert.

Referenced by callback_room_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ callback_tunnel_disconnect()

void callback_tunnel_disconnect	(	void *	cls,
		const struct GNUNET_CADET_Channel *	channel
	)

Callback for a CADET channel disconnecting to manage this event as a proper tunnel provided as its closure.

Parameters

[in,out]	cls	Closure
[in]	channel	CADET channel

Definition at line 104 of file gnunet-service-messenger_tunnel.c.

{
  struct GNUNET_MESSENGER_SrvTunnel *tunnel;
  struct GNUNET_MESSENGER_SrvRoom *room;
  struct GNUNET_PeerIdentity identity;
 
  tunnel = cls;
 
  if (! tunnel)
    return;
 
  GNUNET_assert (tunnel->room);
 
  room = tunnel->room;
 
  get_tunnel_peer_identity (tunnel, &identity);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Connection dropped to room (%s) from peer: %s\n",
              GNUNET_h2s (get_srv_room_key (room)), GNUNET_i2s (&identity));
 
  tunnel->channel = NULL;
 
  if (! room->host)
    return;
 
  if ((GNUNET_YES != GNUNET_CONTAINER_multipeermap_remove (room->tunnels,
                                                           &identity,
                                                           tunnel)) ||
      (GNUNET_YES == GNUNET_CONTAINER_multipeermap_contains (room->tunnels,
                                                             &identity)))
    return;
 
  GNUNET_STATISTICS_update (room->service->statistics,
                            "# tunnels connected",
                            -1,
                            GNUNET_NO);
 
  if (GNUNET_YES == contains_list_tunnels (&(room->basement), &identity))
  {
    struct GNUNET_MESSENGER_Message *message;
 
    message = create_message_miss (&identity);
 
    if (! message)
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Sending miss message about tunnel failed: %s\n",
                  GNUNET_h2s (&(room->key)));
    else
      send_srv_room_message (room, room->host, message);
  }
 
  if ((0 < GNUNET_CONTAINER_multipeermap_size (room->tunnels)) ||
      (GNUNET_NO == room->service->auto_connecting))
    return;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Search for alternate tunnel for room: %s\n",
              GNUNET_h2s (get_srv_room_key (room)));
 
  {
    struct GNUNET_MESSENGER_ListTunnel *element;
    element = find_list_tunnels_alternate (&(room->basement), &identity);
 
    if (! element)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "No alternative tunnel was found!\n");
      return;
    }
 
    GNUNET_PEER_resolve (element->peer, &identity);
  }
 
  enter_srv_room_at (room, room->host, &identity);
}

References GNUNET_MESSENGER_Service::auto_connecting, GNUNET_MESSENGER_SrvRoom::basement, GNUNET_MESSENGER_SrvTunnel::channel, contains_list_tunnels(), create_message_miss(), enter_srv_room_at(), find_list_tunnels_alternate(), get_srv_room_key(), get_tunnel_peer_identity(), GNUNET_assert, GNUNET_CONTAINER_multipeermap_contains(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_NO, GNUNET_PEER_resolve(), GNUNET_STATISTICS_update(), GNUNET_YES, GNUNET_MESSENGER_SrvRoom::host, identity, GNUNET_MESSENGER_SrvRoom::key, GNUNET_MESSENGER_ListTunnel::peer, GNUNET_MESSENGER_SrvTunnel::room, send_srv_room_message(), GNUNET_MESSENGER_SrvRoom::service, GNUNET_MESSENGER_Service::statistics, and GNUNET_MESSENGER_SrvRoom::tunnels.

Referenced by connect_tunnel(), and open_srv_room().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ verify_tunnel_message()

static enum GNUNET_GenericReturnValue verify_tunnel_message	(	struct GNUNET_MESSENGER_SrvRoom *	room,
		struct GNUNET_MESSENGER_Message *	message,
		struct GNUNET_HashCode *	hash
	)

static

Definition at line 184 of file gnunet-service-messenger_tunnel.c.

{
  const struct GNUNET_MESSENGER_Message *previous;
 
  GNUNET_assert ((room) && (message));
 
  if (GNUNET_MESSENGER_KIND_UNKNOWN == message->header.kind)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Message error: Kind is unknown! (%d)\n", message->header.kind);
    return GNUNET_SYSERR;
  }
 
  {
    struct GNUNET_MESSENGER_MessageStore *message_store;
 
    message_store = get_srv_room_message_store (room);
 
    previous = get_store_message (
      message_store, &(message->header.previous));
  }
 
  if (! previous)
    goto skip_time_comparison;
 
  {
    struct GNUNET_TIME_Absolute timestamp;
    struct GNUNET_TIME_Absolute last;
 
    timestamp = GNUNET_TIME_absolute_ntoh (message->header.timestamp);
    last = GNUNET_TIME_absolute_ntoh (previous->header.timestamp);
 
    if (GNUNET_TIME_relative_get_zero_ ().rel_value_us !=
        GNUNET_TIME_absolute_get_difference (timestamp, last).rel_value_us)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Message warning: Timestamp does not check out!\n");
    }
  }
 
skip_time_comparison:
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Receiving message of kind: %s!\n",
              GNUNET_MESSENGER_name_of_kind (message->header.kind));
 
  return GNUNET_OK;
}

References get_srv_room_message_store(), get_store_message(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_MESSENGER_KIND_UNKNOWN, GNUNET_MESSENGER_name_of_kind(), GNUNET_OK, GNUNET_SYSERR, GNUNET_TIME_absolute_get_difference(), GNUNET_TIME_absolute_ntoh(), GNUNET_TIME_relative_get_zero_(), GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_MessageHeader::previous, GNUNET_MESSENGER_MessageHeader::timestamp, and timestamp().

Referenced by check_tunnel_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_tunnel_message()

enum GNUNET_GenericReturnValue check_tunnel_message	(	void *	cls,
		const struct GNUNET_MessageHeader *	header
	)

Callback for message verification via header in a tunnel that is provided as a closure from a CADET channel.

Parameters

[in,out]	cls	Closure
[in]	header	Message header

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

{
  struct GNUNET_MESSENGER_SrvTunnel *tunnel;
  struct GNUNET_MESSENGER_Message message;
  struct GNUNET_HashCode hash;
  uint16_t length;
  const char *buffer;
 
  GNUNET_assert (header);
 
  tunnel = cls;
 
  if (! tunnel)
    return GNUNET_SYSERR;
 
  length = ntohs (header->size) - sizeof(*header);
  buffer = (const char*) &header[1];
 
  if (length < get_message_kind_size (GNUNET_MESSENGER_KIND_UNKNOWN,
                                      GNUNET_YES))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Tunnel error: Message too short! (%d)\n", length);
    return GNUNET_SYSERR;
  }
 
  {
    uint16_t padding;
    padding = 0;
 
    if (GNUNET_YES != decode_message (&message, length, buffer, GNUNET_YES,
                                      &padding))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Tunnel error: Decoding failed!\n");
      return GNUNET_SYSERR;
    }
 
    hash_message (&message, length - padding, buffer, &hash);
  }
 
  return verify_tunnel_message (tunnel->room, &message, &hash);
}

References decode_message(), get_message_kind_size(), GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_MESSENGER_KIND_UNKNOWN, GNUNET_SYSERR, GNUNET_YES, hash_message(), GNUNET_MESSENGER_SrvTunnel::room, GNUNET_MessageHeader::size, and verify_tunnel_message().

Here is the call graph for this function:

◆ update_room_message()

enum GNUNET_GenericReturnValue update_room_message	(	struct GNUNET_MESSENGER_SrvRoom *	room,
		struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_HashCode *	hash
	)

extern

Definition at line 1433 of file gnunet-service-messenger_room.c.

{
  struct GNUNET_MESSENGER_OperationStore *operation_store;
  struct GNUNET_MESSENGER_MessageStore *message_store;
  enum GNUNET_GenericReturnValue requested;
 
  GNUNET_assert ((room) && (message) && (hash));
 
  operation_store = get_srv_room_operation_store (room);
 
  if (! operation_store)
  {
    destroy_message (message);
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Operation store invalid!\n");
    return GNUNET_NO;
  }
 
  requested = (GNUNET_MESSENGER_OP_REQUEST ==
               get_store_operation_type (operation_store, hash)?
               GNUNET_YES : GNUNET_NO);
 
  if (GNUNET_YES == requested)
    cancel_store_operation (operation_store, hash);
 
  message_store = get_srv_room_message_store (room);
 
  if (! message_store)
  {
    destroy_message (message);
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Message store invalid!\n");
    return GNUNET_NO;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Handle a message in room (%s).\n",
              GNUNET_h2s (get_srv_room_key (room)));
 
  if (GNUNET_YES == contains_store_message (message_store, hash))
  {
    destroy_message (message);
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Duplicate message got dropped!\n");
    return GNUNET_NO;
  }
 
  if (GNUNET_OK != put_store_message (message_store, hash, message))
  {
    destroy_message (message);
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Storing message failed!\n");
    return GNUNET_NO;
  }
 
  update_message_state (&(room->state), requested, message, hash);
 
  if ((GNUNET_YES == requested) ||
      (GNUNET_MESSENGER_KIND_INFO == message->header.kind) ||
      (GNUNET_MESSENGER_KIND_REQUEST == message->header.kind))
    return GNUNET_YES;
 
  if ((GNUNET_MESSENGER_KIND_MERGE == message->header.kind) &&
      (GNUNET_MESSENGER_OP_MERGE == get_store_operation_type (operation_store,
                                                              &(message->body.
                                                                merge.previous))
      ))
    cancel_store_operation (operation_store, &(message->body.merge.previous));
 
  if (GNUNET_MESSENGER_OP_MERGE == get_store_operation_type (operation_store,
                                                             &(message->header.
                                                               previous)))
    cancel_store_operation (operation_store, &(message->header.previous));
 
  if (! room->save_task)
    room->save_task = GNUNET_SCHEDULER_add_delayed_with_priority (
      GNUNET_MESSENGER_SAVE_DELAY,
      GNUNET_SCHEDULER_PRIORITY_IDLE,
      autosave_room_messages, room);
 
  return GNUNET_YES;
}

References autosave_room_messages(), GNUNET_MESSENGER_Message::body, cancel_store_operation(), contains_store_message(), destroy_message(), get_srv_room_key(), get_srv_room_message_store(), get_srv_room_operation_store(), get_store_operation_type(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_MESSENGER_KIND_INFO, GNUNET_MESSENGER_KIND_MERGE, GNUNET_MESSENGER_KIND_REQUEST, GNUNET_MESSENGER_OP_MERGE, GNUNET_MESSENGER_OP_REQUEST, GNUNET_MESSENGER_SAVE_DELAY, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_delayed_with_priority(), GNUNET_SCHEDULER_PRIORITY_IDLE, GNUNET_YES, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_MessageBody::merge, GNUNET_MESSENGER_MessageHeader::previous, GNUNET_MESSENGER_MessageMerge::previous, put_store_message(), GNUNET_MESSENGER_SrvRoom::save_task, GNUNET_MESSENGER_SrvRoom::state, and update_message_state().

Referenced by callback_srv_room_message_signed(), handle_tunnel_message(), and it_handle_epoch_message_delayed().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ callback_room_handle_message()

void callback_room_handle_message	(	struct GNUNET_MESSENGER_SrvRoom *	room,
		const struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_HashCode *	hash
	)

extern

Definition at line 1642 of file gnunet-service-messenger_room.c.

{
  struct GNUNET_MESSENGER_PeerStore *peer_store;
  struct GNUNET_MESSENGER_MemberStore *member_store;
  struct GNUNET_MESSENGER_SenderSession session;
  enum GNUNET_GenericReturnValue start_handle;
 
  GNUNET_assert ((room) && (message) && (hash));
 
  peer_store = get_srv_room_peer_store (room);
  member_store = get_srv_room_member_store (room);
 
  if (GNUNET_YES == is_peer_message (message))
  {
    session.peer = get_store_peer_of (peer_store, message, hash);
 
    if (! session.peer)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Message handling dropped: Peer is missing!\n");
      return;
    }
  }
  else
  {
    struct GNUNET_MESSENGER_Member *member;
    member = get_store_member_of (member_store, message);
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Callback for message (%s)\n",
                GNUNET_h2s (hash));
 
    if (! member)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Message handling dropped: Member is missing!\n");
      return;
    }
 
    session.member = get_member_session_of (member, message, hash);
 
    if (! session.member)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Message handling dropped: Session is missing!\n");
      return;
    }
  }
 
  {
    struct GNUNET_MESSENGER_MemberUpdate update;
    update.message = message;
    update.hash = hash;
 
    update.head = NULL;
    update.tail = NULL;
 
    iterate_store_members (
      member_store,
      iterate_update_member_sessions,
      &update);
 
    while (update.head)
    {
      struct GNUNET_MESSENGER_SrvMemberSessionCompletion *element = update.head;
 
      remove_room_member_session (room, element->session);
 
      GNUNET_CONTAINER_DLL_remove (update.head, update.tail, element);
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Remove member session completion from queue!\n");
 
      GNUNET_free (element);
    }
  }
 
  start_handle = room->handling.head ? GNUNET_NO : GNUNET_YES;
 
  add_to_list_messages (&(room->handling), hash);
 
  switch (message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_JOIN:
    handle_message_join (room, &session, message, hash);
    break;
  case GNUNET_MESSENGER_KIND_LEAVE:
    handle_message_leave (room, &session, message, hash);
    break;
  case GNUNET_MESSENGER_KIND_KEY:
    handle_message_key (room, &session, message, hash);
    break;
  case GNUNET_MESSENGER_KIND_PEER:
    handle_message_peer (room, &session, message, hash);
    break;
  case GNUNET_MESSENGER_KIND_ID:
    handle_message_id (room, &session, message, hash);
    break;
  case GNUNET_MESSENGER_KIND_MISS:
    handle_message_miss (room, &session, message, hash);
    break;
  case GNUNET_MESSENGER_KIND_DELETION:
    handle_message_delete (room, &session, message, hash);
    break;
  case GNUNET_MESSENGER_KIND_CONNECTION:
    handle_message_connection (room, &session, message, hash);
    break;
  case GNUNET_MESSENGER_KIND_SUBSCRIBTION:
    handle_message_subscribe (room, &session, message, hash);
    break;
  default:
    break;
  }
 
  if (GNUNET_YES == start_handle)
    handle_room_messages (room);
}

Referenced by callback_srv_room_message_signed(), and handle_tunnel_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_tunnel_last_message()

static void update_tunnel_last_message	(	struct GNUNET_MESSENGER_SrvTunnel *	tunnel,
		const struct GNUNET_HashCode *	hash
	)

static

Definition at line 292 of file gnunet-service-messenger_tunnel.c.

{
  struct GNUNET_MESSENGER_OperationStore *operation_store;
  enum GNUNET_GenericReturnValue requested;
 
  GNUNET_assert ((tunnel) && (hash));
 
  operation_store = get_srv_room_operation_store (tunnel->room);
 
  requested = (GNUNET_MESSENGER_OP_REQUEST ==
               get_store_operation_type (operation_store, hash)?
               GNUNET_YES : GNUNET_NO);
 
  {
    struct GNUNET_MESSENGER_MessageStore *message_store;
    const struct GNUNET_MESSENGER_Message *message;
 
    message_store = get_srv_room_message_store (tunnel->room);
    message = get_store_message (message_store, hash);
 
    if (! message)
      return;
 
    update_message_state (&(tunnel->state), requested, message, hash);
  }
}

References get_srv_room_message_store(), get_srv_room_operation_store(), get_store_message(), get_store_operation_type(), GNUNET_assert, GNUNET_MESSENGER_OP_REQUEST, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_SrvTunnel::room, GNUNET_MESSENGER_SrvTunnel::state, and update_message_state().

Referenced by callback_tunnel_sent(), and handle_tunnel_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_tunnel_message()

void handle_tunnel_message	(	void *	cls,
		const struct GNUNET_MessageHeader *	header
	)

Callback for message handling via header in a tunnel that is provided as a closure from a CADET channel.

Parameters

[in,out]	cls	Closure
[in]	header	Message header

Definition at line 322 of file gnunet-service-messenger_tunnel.c.

{
  struct GNUNET_MESSENGER_SrvTunnel *tunnel;
  struct GNUNET_MESSENGER_Message message;
  struct GNUNET_HashCode hash;
  uint16_t length;
  const char *buffer;
 
  GNUNET_assert (header);
 
  tunnel = cls;
 
  if (! tunnel)
    return;
 
  length = ntohs (header->size) - sizeof(*header);
  buffer = (const char*) &header[1];
 
  {
    uint16_t padding;
    padding = 0;
 
    decode_message (&message, length, buffer, GNUNET_YES, &padding);
    hash_message (&message, length - padding, buffer, &hash);
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got message of kind: %s!\n",
              GNUNET_MESSENGER_name_of_kind (message.header.kind));
 
  {
    enum GNUNET_GenericReturnValue new_message;
    new_message = update_room_message (tunnel->room,
                                       copy_message (&message),
                                       &hash);
 
    if (GNUNET_YES != new_message)
      goto receive_done;
  }
 
  update_tunnel_last_message (tunnel, &hash);
 
  {
    enum GNUNET_GenericReturnValue forward_message;
    forward_message = GNUNET_YES;
 
    switch (message.header.kind)
    {
    case GNUNET_MESSENGER_KIND_INFO:
      forward_message = recv_message_info (
        tunnel->room,
        tunnel,
        &message,
        &hash);
      break;
    case GNUNET_MESSENGER_KIND_PEER:
      forward_message = recv_message_peer (
        tunnel->room,
        tunnel,
        &message,
        &hash);
      break;
    case GNUNET_MESSENGER_KIND_MISS:
      forward_message = recv_message_miss (
        tunnel->room,
        tunnel,
        &message,
        &hash);
      break;
    case GNUNET_MESSENGER_KIND_REQUEST:
      forward_message = recv_message_request (
        tunnel->room,
        tunnel,
        &message,
        &hash);
      break;
    default:
      break;
    }
 
    if (GNUNET_YES == forward_message)
    {
      struct GNUNET_MQ_Envelope *envelope;
 
      envelope = pack_message (&message, NULL,
                               GNUNET_MESSENGER_PACK_MODE_ENVELOPE);
 
      if (! envelope)
      {
        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                    "Packing message into envelope failed: %s\n",
                    GNUNET_h2s (&hash));
        goto receive_done;
      }
 
      send_srv_room_envelope (tunnel->room, tunnel, envelope, &hash);
      callback_room_handle_message (tunnel->room, &message, &hash);
    }
  }
 
receive_done:
  cleanup_message (&message);
 
  GNUNET_STATISTICS_update (tunnel->room->service->statistics,
                            "# messages received",
                            1,
                            GNUNET_NO);
 
  GNUNET_CADET_receive_done (tunnel->channel);
}

References callback_room_handle_message(), GNUNET_MESSENGER_SrvTunnel::channel, cleanup_message(), copy_message(), decode_message(), GNUNET_assert, GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_h2s(), GNUNET_log, GNUNET_MESSENGER_KIND_INFO, GNUNET_MESSENGER_KIND_MISS, GNUNET_MESSENGER_KIND_PEER, GNUNET_MESSENGER_KIND_REQUEST, GNUNET_MESSENGER_name_of_kind(), GNUNET_MESSENGER_PACK_MODE_ENVELOPE, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_YES, hash_message(), GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageHeader::kind, pack_message(), recv_message_info(), recv_message_miss(), recv_message_peer(), recv_message_request(), GNUNET_MESSENGER_SrvTunnel::room, send_srv_room_envelope(), GNUNET_MESSENGER_SrvRoom::service, GNUNET_MessageHeader::size, GNUNET_MESSENGER_Service::statistics, update_room_message(), and update_tunnel_last_message().

Here is the call graph for this function:

◆ connect_tunnel()

enum GNUNET_GenericReturnValue connect_tunnel ( struct GNUNET_MESSENGER_SrvTunnel * tunnel )

Tries to connect a tunnel by creating a new CADET channel and binding it.

The function returns GNUNET_YES on success, otherwise GNUNET_NO.

Parameters

[in,out] tunnel Tunnel

Returns: GNUNET_YES on success, otherwise GNUNET_NO

Definition at line 434 of file gnunet-service-messenger_tunnel.c.

{
  const struct GNUNET_PeerIdentity *door;
  struct GNUNET_CADET_Handle *cadet;
  union GNUNET_MESSENGER_RoomKey key;
 
  GNUNET_assert (tunnel);
 
  if (tunnel->channel)
    return GNUNET_NO;
 
  door = GNUNET_PEER_resolve2 (tunnel->peer);
  cadet = get_srv_room_cadet (tunnel->room);
 
  GNUNET_memcpy (
    &(key.hash),
    get_srv_room_key (tunnel->room),
    sizeof (key.hash));
 
  if ((key.code.feed_bit) && (! key.code.group_bit))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Tunnel to personal room containing private feeds failed!");
    return GNUNET_NO;
  }
 
  {
    struct GNUNET_HashCode port;
    struct GNUNET_MQ_MessageHandler handlers[] = { GNUNET_MQ_hd_var_size (
                                                     tunnel_message,
                                                     GNUNET_MESSAGE_TYPE_CADET_CLI,
                                                     struct
                                                     GNUNET_MessageHeader, NULL)
                                                   ,
                                                   GNUNET_MQ_handler_end () };
 
    convert_messenger_key_to_port (&key, &port);
    tunnel->channel = GNUNET_CADET_channel_create (cadet, tunnel, door, &port,
                                                   NULL,
                                                   callback_tunnel_disconnect,
                                                   handlers);
  }
 
  if (! tunnel->channel)
    return GNUNET_SYSERR;
 
  GNUNET_STATISTICS_update (tunnel->room->service->statistics,
                            "# tunnels connected",
                            1,
                            GNUNET_NO);
 
  return GNUNET_YES;
}

References cadet, callback_tunnel_disconnect(), GNUNET_MESSENGER_SrvTunnel::channel, convert_messenger_key_to_port(), get_srv_room_cadet(), get_srv_room_key(), GNUNET_assert, GNUNET_CADET_channel_create(), GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_CADET_CLI, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_NO, GNUNET_PEER_resolve2(), GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_YES, handlers, key, GNUNET_MESSENGER_SrvTunnel::peer, port, GNUNET_MESSENGER_SrvTunnel::room, GNUNET_MESSENGER_SrvRoom::service, and GNUNET_MESSENGER_Service::statistics.

Referenced by enter_srv_room_at(), and rebuild_srv_room_basement_structure().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ disconnect_tunnel()

void disconnect_tunnel ( struct GNUNET_MESSENGER_SrvTunnel * tunnel )

Disconnects and unbinds a channel from a tunnel.

The actual disconnection will be asynchronous.

Parameters

[in,out] tunnel Tunnel

Definition at line 490 of file gnunet-service-messenger_tunnel.c.

{
  GNUNET_assert (tunnel);
 
  if (tunnel->channel)
  {
    delayed_disconnect_channel (tunnel->channel);
 
    tunnel->channel = NULL;
  }
}

References GNUNET_MESSENGER_SrvTunnel::channel, delayed_disconnect_channel(), and GNUNET_assert.

Referenced by callback_room_connect(), rebuild_srv_room_basement_structure(), and recv_message_info().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_tunnel_connected()

enum GNUNET_GenericReturnValue is_tunnel_connected ( const struct GNUNET_MESSENGER_SrvTunnel * tunnel )

Returns the status of a currently bound channel of a tunnel.

Parameters

[in] tunnel Tunnel

Returns: GNUNET_YES or GNUNET_NO

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

{
  GNUNET_assert (tunnel);
 
  return (tunnel->channel ? GNUNET_YES : GNUNET_NO);
}

References GNUNET_MESSENGER_SrvTunnel::channel, GNUNET_assert, GNUNET_NO, and GNUNET_YES.

Referenced by iterate_send_room_envelope(), and send_room_info().

Here is the caller graph for this function:

◆ callback_tunnel_sent()

static void callback_tunnel_sent ( void * cls )

static

Definition at line 519 of file gnunet-service-messenger_tunnel.c.

{
  struct GNUNET_MESSENGER_MessageSent *sent;
 
  GNUNET_assert (cls);
 
  sent = cls;
 
  if (sent->tunnel)
  {
    update_tunnel_last_message (sent->tunnel, &(sent->hash));
 
    GNUNET_STATISTICS_update (sent->tunnel->room->service->statistics,
                              "# messages sent",
                              1,
                              GNUNET_NO);
  }
 
  GNUNET_free (sent);
}

References GNUNET_assert, GNUNET_free, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_MESSENGER_MessageSent::hash, GNUNET_MESSENGER_SrvTunnel::room, GNUNET_MESSENGER_SrvRoom::service, GNUNET_MESSENGER_Service::statistics, GNUNET_MESSENGER_MessageSent::tunnel, and update_tunnel_last_message().

Referenced by send_tunnel_envelope().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_tunnel_envelope()

void send_tunnel_envelope	(	struct GNUNET_MESSENGER_SrvTunnel *	tunnel,
		struct GNUNET_MQ_Envelope *	env,
		const struct GNUNET_HashCode *	hash
	)

Sends an envelope containing a message with a given hash through a tunnel.

Parameters

[in,out]	tunnel	Tunnel
[in,out]	env	Envelope
[in]	hash	Hash of message

Definition at line 542 of file gnunet-service-messenger_tunnel.c.

{
  struct GNUNET_MQ_Handle *mq;
  struct GNUNET_MESSENGER_MessageSent *sent;
 
  GNUNET_assert ((tunnel) && (env) && (hash));
 
  mq = GNUNET_CADET_get_mq (tunnel->channel);
  sent = GNUNET_new (struct GNUNET_MESSENGER_MessageSent);
 
  GNUNET_memcpy (&(sent->hash), hash, sizeof(struct GNUNET_HashCode));
 
  sent->tunnel = tunnel;
 
  GNUNET_MQ_notify_sent (env, callback_tunnel_sent, sent);
  GNUNET_MQ_send (mq, env);
}

References callback_tunnel_sent(), GNUNET_MESSENGER_SrvTunnel::channel, env, GNUNET_assert, GNUNET_CADET_get_mq(), GNUNET_memcpy, GNUNET_MQ_notify_sent(), GNUNET_MQ_send(), GNUNET_new, GNUNET_MESSENGER_MessageSent::hash, mq, and GNUNET_MESSENGER_MessageSent::tunnel.

Referenced by callback_tunnel_message_signed(), forward_tunnel_message(), and iterate_send_room_envelope().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ callback_tunnel_message_signed()

static void callback_tunnel_message_signed	(	void *	cls,
		struct GNUNET_MESSENGER_SrvRoom *	room,
		struct GNUNET_MESSENGER_Message *	message,
		struct GNUNET_MQ_Envelope *	envelope,
		const struct GNUNET_HashCode *	hash
	)

static

Definition at line 564 of file gnunet-service-messenger_tunnel.c.

{
  struct GNUNET_MESSENGER_SrvTunnel *tunnel;
 
  GNUNET_assert ((cls) && (message) && (envelope) && (hash));
 
  tunnel = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending tunnel message: %s\n",
              GNUNET_h2s (hash));
 
  destroy_message (message);
  send_tunnel_envelope (tunnel, envelope, hash);
}

References destroy_message(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, and send_tunnel_envelope().

Referenced by send_tunnel_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_tunnel_message()

enum GNUNET_GenericReturnValue send_tunnel_message	(	struct GNUNET_MESSENGER_SrvTunnel *	tunnel,
		void *	handle,
		struct GNUNET_MESSENGER_Message *	message
	)

Sends a message by packing it automatically into an envelope and passing it through the tunnel.

The used handle will sign the message and the hash will be calculated and stored.

Parameters

[in,out]	tunnel	Tunnel
[in,out]	handle	Handle
[in,out]	message	Message

Returns: GNUNET_YES on success, GNUNET_NO otherwise

Definition at line 586 of file gnunet-service-messenger_tunnel.c.

{
  GNUNET_assert ((tunnel) && (tunnel->room));
 
  if (! message)
    return GNUNET_NO;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending message from tunnel in room: %s (%s)\n",
              GNUNET_h2s (&(tunnel->room->key)),
              GNUNET_MESSENGER_name_of_kind (message->header.kind));
 
  return sign_srv_room_message (tunnel->room, message,
                                &callback_tunnel_message_signed,
                                tunnel);
}

References callback_tunnel_message_signed(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_MESSENGER_name_of_kind(), GNUNET_NO, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_SrvRoom::key, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_SrvTunnel::room, and sign_srv_room_message().

Referenced by recv_message_info(), and send_room_info().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ forward_tunnel_message()

void forward_tunnel_message	(	struct GNUNET_MESSENGER_SrvTunnel *	tunnel,
		const struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_HashCode *	hash
	)

Forwards a given message with a known hash through a tunnel.

Parameters

[in,out]	tunnel	Tunnel
[in]	message	Message
[in]	hash	Hash of message

Definition at line 607 of file gnunet-service-messenger_tunnel.c.

{
  struct GNUNET_MESSENGER_Message *copy;
  struct GNUNET_MQ_Envelope *envelope;
 
  GNUNET_assert ((tunnel) && (message) && (hash));
 
  copy = copy_message (message);
  envelope = pack_message (copy, NULL,
                           GNUNET_MESSENGER_PACK_MODE_ENVELOPE);
 
  destroy_message (copy);
 
  if (! envelope)
    return;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Forwarding tunnel message: %s\n",
              GNUNET_h2s (hash));
 
  send_tunnel_envelope (tunnel, envelope, hash);
}

References copy_message(), destroy_message(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_MESSENGER_PACK_MODE_ENVELOPE, pack_message(), and send_tunnel_envelope().

Referenced by callback_found_message(), check_srv_room_peer_status(), forward_about_members(), and recv_message_info().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_tunnel_peer_message()

const struct GNUNET_HashCode * get_tunnel_peer_message ( const struct GNUNET_MESSENGER_SrvTunnel * tunnel )

Returns the hash of the latest peer message published through a given tunnel and matching the tunnels peer identity.

If no peer message has been linked to the tunnel yet, NULL gets returned.

Parameters

[in] tunnel Tunnel

Returns: Hash of peer message or NULL

Definition at line 633 of file gnunet-service-messenger_tunnel.c.

{
  GNUNET_assert (tunnel);
 
  return tunnel->peer_message;
}

References GNUNET_assert, and GNUNET_MESSENGER_SrvTunnel::peer_message.

◆ get_tunnel_peer_identity()

void get_tunnel_peer_identity	(	const struct GNUNET_MESSENGER_SrvTunnel *	tunnel,
		struct GNUNET_PeerIdentity *	peer
	)

Writes the peer identity of the peer connected via tunnel to this peer into the peer parameter.

Parameters

[in]	tunnel	Tunnel
[out]	peer	Peer identity

Definition at line 642 of file gnunet-service-messenger_tunnel.c.

{
  GNUNET_assert (tunnel);
 
  GNUNET_PEER_resolve (tunnel->peer, peer);
}

References GNUNET_assert, GNUNET_PEER_resolve(), and GNUNET_MESSENGER_SrvTunnel::peer.

Referenced by callback_tunnel_disconnect(), and recv_message_info().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_tunnel_messenger_version()

uint32_t get_tunnel_messenger_version ( const struct GNUNET_MESSENGER_SrvTunnel * tunnel )

Returns the current messenger version the peer connected via a given tunnel has reported to be using if it was compatible during updating.

See also: update_tunnel_messenger_version

Parameters

[in] tunnel Tunnel

Returns: Version of messenger

Definition at line 652 of file gnunet-service-messenger_tunnel.c.

{
  GNUNET_assert (tunnel);
 
  return tunnel->messenger_version;
}

References GNUNET_assert, and GNUNET_MESSENGER_SrvTunnel::messenger_version.

Referenced by iterate_send_room_envelope(), and recv_message_info().

Here is the caller graph for this function:

◆ update_tunnel_messenger_version()

enum GNUNET_GenericReturnValue update_tunnel_messenger_version	(	struct GNUNET_MESSENGER_SrvTunnel *	tunnel,
		uint32_t	version
	)

Updates the messenger version of the tunnel to a given version if it is compatible to the running peer of the service.

Depending on success it returns GNUNET_OK or GNUNET_SYSERR on failure.

Parameters

[in,out]	tunnel	Tunnel
[in]	version	Version of messenger

Returns: GNUNET_OK on success, otherwise GNUNET_SYSERR

Definition at line 661 of file gnunet-service-messenger_tunnel.c.

{
  GNUNET_assert (tunnel);
 
  if (version != GNUNET_MESSENGER_VERSION)
    return GNUNET_SYSERR;
 
  if (version > tunnel->messenger_version)
    tunnel->messenger_version = version;
 
  return GNUNET_OK;
}

References GNUNET_assert, GNUNET_MESSENGER_VERSION, GNUNET_OK, GNUNET_SYSERR, and GNUNET_MESSENGER_SrvTunnel::messenger_version.

Referenced by recv_message_info().

Here is the caller graph for this function:

Data Structures

Functions

Function Documentation

◆ create_tunnel()

◆ destroy_tunnel()

◆ bind_tunnel()

◆ callback_tunnel_disconnect()

◆ verify_tunnel_message()

◆ check_tunnel_message()

◆ update_room_message()

◆ callback_room_handle_message()

◆ update_tunnel_last_message()

◆ handle_tunnel_message()

◆ connect_tunnel()

◆ disconnect_tunnel()

◆ is_tunnel_connected()

◆ callback_tunnel_sent()

◆ send_tunnel_envelope()

◆ callback_tunnel_message_signed()

◆ send_tunnel_message()

◆ forward_tunnel_message()

◆ get_tunnel_peer_message()

◆ get_tunnel_peer_identity()

◆ get_tunnel_messenger_version()

◆ update_tunnel_messenger_version()