gnunet-service-messenger_tunnel.c File Reference

GNUnet MESSENGER service. More...

#include "gnunet-service-messenger_tunnel.h"
#include "gnunet-service-messenger_handle.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 "messenger_api_util.h"

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

Go to the source code of this file.

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). More...
void	destroy_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel)
	Destroys a tunnel and frees its memory fully. More...
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. More...
void	callback_room_disconnect (struct GNUNET_MESSENGER_SrvRoom *room, void *cls)
void	callback_tunnel_disconnect (void *cls, const struct GNUNET_CADET_Channel *channel)
int	callback_verify_room_message (struct GNUNET_MESSENGER_SrvRoom *room, void *cls, struct GNUNET_MESSENGER_Message *message, struct GNUNET_HashCode *hash)
int	check_tunnel_message (void *cls, const struct GNUNET_MessageHeader *header)
int	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, struct GNUNET_MESSENGER_SrvHandle *handle, 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)
int	connect_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel)
	Tries to connect a tunnel by creating a new CADET channel and binding it. More...
void	disconnect_tunnel (struct GNUNET_MESSENGER_SrvTunnel *tunnel)
	Disconnects and unbinds a channel from a tunnel. More...
int	is_tunnel_connected (const struct GNUNET_MESSENGER_SrvTunnel *tunnel)
	Returns the status of a currently bound channel of a tunnel. More...
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. More...
int	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. More...
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. More...
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. More...
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. More...
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. More...
int	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. More...

Detailed Description

GNUnet MESSENGER service.

Author

Tobias Frisch

Definition in file gnunet-service-messenger_tunnel.c.

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

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

References GNUNET_MESSENGER_SrvTunnel::channel, GNUNET_assert, 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_room_at().

{
  GNUNET_assert((room) && (door));

  struct GNUNET_MESSENGER_SrvTunnel *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;
}

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

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

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

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

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

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

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

Referenced by callback_room_connect().

{
  GNUNET_assert(tunnel);

  if (tunnel->channel)
    delayed_disconnect_channel (tunnel->channel);

  tunnel->channel = channel;
}

Here is the call graph for this function:

Here is the caller graph for this function:

callback_room_disconnect()

void callback_room_disconnect	(	struct GNUNET_MESSENGER_SrvRoom *	room,
		void *	cls
	)

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

References GNUNET_MESSENGER_SrvRoom::basement, contains_list_tunnels(), create_message_miss(), get_tunnel_peer_identity(), GNUNET_CONTAINER_multipeermap_contains(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_YES, GNUNET_MESSENGER_SrvRoom::host, send_room_message(), and GNUNET_MESSENGER_SrvRoom::tunnels.

Referenced by bind_tunnel(), and callback_tunnel_disconnect().

{
  struct GNUNET_MESSENGER_SrvTunnel *tunnel = cls;

  if (!room->host)
    return;

  struct GNUNET_PeerIdentity identity;
  get_tunnel_peer_identity(tunnel, &identity);

  if ((GNUNET_YES != GNUNET_CONTAINER_multipeermap_remove (room->tunnels, &identity, tunnel)) ||
      (GNUNET_YES == GNUNET_CONTAINER_multipeermap_contains(room->tunnels, &identity)))
    return;

  if (GNUNET_YES == contains_list_tunnels (&(room->basement), &identity))
    send_room_message (room, room->host, create_message_miss (&identity));
}

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
	)

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

References callback_room_disconnect(), callback_verify_room_message(), GNUNET_MESSENGER_SrvTunnel::channel, and GNUNET_MESSENGER_SrvTunnel::room.

Referenced by connect_tunnel(), join_room_locally(), and open_room().

{
  struct GNUNET_MESSENGER_SrvTunnel *tunnel = cls;

  if (tunnel)
  {
    tunnel->channel = NULL;

    callback_room_disconnect (tunnel->room, cls);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

callback_verify_room_message()

int callback_verify_room_message	(	struct GNUNET_MESSENGER_SrvRoom *	room,
		void *	cls,
		struct GNUNET_MESSENGER_Message *	message,
		struct GNUNET_HashCode *	hash
	)

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

References get_room_message_store(), get_store_message(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, 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, and GNUNET_MESSENGER_MessageHeader::timestamp.

Referenced by callback_tunnel_disconnect(), and check_tunnel_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 = get_room_message_store(room);

  const struct GNUNET_MESSENGER_Message *previous = get_store_message(message_store, &(message->header.previous));

  if (!previous)
    goto skip_time_comparison;

  struct GNUNET_TIME_Absolute timestamp = GNUNET_TIME_absolute_ntoh(message->header.timestamp);
  struct GNUNET_TIME_Absolute 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_ERROR, "Message error: Timestamp does not check out!\n");
    return GNUNET_SYSERR;
  }

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

Here is the call graph for this function:

Here is the caller graph for this function:

check_tunnel_message()

int check_tunnel_message	(	void *	cls,
		const struct GNUNET_MessageHeader *	header
	)

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

References callback_room_handle_message(), callback_verify_room_message(), decode_message(), get_message_kind_size(), GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_MESSENGER_KIND_UNKNOWN, GNUNET_SYSERR, GNUNET_YES, handle, hash_message(), GNUNET_MESSENGER_SrvTunnel::room, GNUNET_MessageHeader::size, and update_room_message().

Referenced by join_room_locally().

{
  struct GNUNET_MESSENGER_SrvTunnel *tunnel = cls;

  if (!tunnel)
    return GNUNET_SYSERR;

  const uint16_t length = ntohs (header->size) - sizeof(*header);
  const char *buffer = (const char*) &header[1];

  struct GNUNET_MESSENGER_Message message;

  if (length < get_message_kind_size(GNUNET_MESSENGER_KIND_UNKNOWN))
  {
    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Tunnel error: Message too short! (%d)\n", length);
    return GNUNET_SYSERR;
  }

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

  struct GNUNET_HashCode hash;
  hash_message (&message, length - padding, buffer, &hash);

  return callback_verify_room_message (tunnel->room, cls, &message, &hash);
}

Here is the call graph for this function:

Here is the caller graph for this function:

update_room_message()

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

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

References GNUNET_MESSENGER_Message::body, cancel_store_operation(), destroy_message(), get_room_key(), get_room_message_store(), get_room_operation_store(), get_store_message(), 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_NO, GNUNET_OK, GNUNET_YES, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_MessageBody::merge, GNUNET_MESSENGER_MessageMerge::previous, GNUNET_MESSENGER_MessageHeader::previous, put_store_message(), GNUNET_MESSENGER_SrvRoom::state, and update_message_state().

Referenced by check_tunnel_message(), handle_tunnel_message(), iterate_send_room_message(), and send_room_message().

{
  GNUNET_assert((room) && (message) && (hash));

  struct GNUNET_MESSENGER_OperationStore *operation_store = get_room_operation_store(room);

  const int 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);

  struct GNUNET_MESSENGER_MessageStore *message_store = get_room_message_store(room);

  const struct GNUNET_MESSENGER_Message *old_message = get_store_message (message_store, hash);

  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Handle a message in room (%s).\n", GNUNET_h2s (get_room_key(room)));

  if ((old_message) || (GNUNET_OK != put_store_message (message_store, hash, message)))
  {
    if (old_message != message)
      destroy_message(message);

    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Duplicate message got dropped!\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));

  return GNUNET_YES;
}

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,
		struct GNUNET_MESSENGER_SrvHandle *	handle,
		const struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_HashCode *	hash
	)

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

References add_to_list_messages(), get_member_session_of(), get_room_member_store(), get_store_member_of(), GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_MESSENGER_KIND_DELETE, GNUNET_MESSENGER_KIND_ID, GNUNET_MESSENGER_KIND_JOIN, GNUNET_MESSENGER_KIND_KEY, GNUNET_MESSENGER_KIND_LEAVE, GNUNET_MESSENGER_KIND_MISS, GNUNET_MESSENGER_KIND_NAME, GNUNET_MESSENGER_KIND_PEER, GNUNET_NO, GNUNET_YES, handle_message_delete(), handle_message_id(), handle_message_join(), handle_message_key(), handle_message_leave(), handle_message_miss(), handle_message_name(), handle_message_peer(), handle_room_messages(), GNUNET_MESSENGER_SrvRoom::handling, GNUNET_MESSENGER_MemberUpdate::hash, GNUNET_MESSENGER_ListMessages::head, GNUNET_MESSENGER_MemberUpdate::head, GNUNET_MESSENGER_Message::header, iterate_store_members(), iterate_update_member_sessions(), GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_MemberUpdate::message, remove_room_member_session(), GNUNET_MESSENGER_MemberSessionCompletion::session, and GNUNET_MESSENGER_MemberUpdate::tail.

Referenced by check_tunnel_message(), handle_tunnel_message(), iterate_send_room_message(), and send_room_message().

{
  struct GNUNET_MESSENGER_MemberStore *member_store = get_room_member_store(room);
  struct GNUNET_MESSENGER_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;
  }

  struct GNUNET_MESSENGER_MemberSession *session = get_member_session_of(member, message, hash);

  if (!session)
  {
    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_MemberSessionCompletion *element = update.head;

    remove_room_member_session (room, element->session);

    GNUNET_CONTAINER_DLL_remove(update.head, update.tail, element);
    GNUNET_free (element);
  }

  const int 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_NAME:
    handle_message_name (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_DELETE:
    handle_message_delete (room, session, message, hash);
    break;
  default:
    break;
  }

  if (GNUNET_YES == start_handle)
    handle_room_messages (room);
}

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 147 of file gnunet-service-messenger_tunnel.c.

References get_room_message_store(), get_room_operation_store(), get_store_message(), get_store_operation_type(), 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().

{
  struct GNUNET_MESSENGER_OperationStore *operation_store = get_room_operation_store(tunnel->room);

  const int requested = (GNUNET_MESSENGER_OP_REQUEST == get_store_operation_type(operation_store, hash)?
      GNUNET_YES : GNUNET_NO
  );

  struct GNUNET_MESSENGER_MessageStore *message_store = get_room_message_store(tunnel->room);

  const struct GNUNET_MESSENGER_Message *message = get_store_message(message_store, hash);

  if (message)
    update_message_state(&(tunnel->state), requested, message, hash);
}

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
	)

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

References callback_room_handle_message(), GNUNET_MESSENGER_SrvTunnel::channel, copy_message(), decode_message(), forward_room_message(), GNUNET_CADET_receive_done(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSENGER_KIND_INFO, GNUNET_MESSENGER_KIND_PEER, GNUNET_MESSENGER_KIND_REQUEST, GNUNET_MESSENGER_name_of_kind(), GNUNET_YES, hash_message(), GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageHeader::kind, recv_message_info(), recv_message_peer(), recv_message_request(), GNUNET_MESSENGER_SrvTunnel::room, GNUNET_MessageHeader::size, update_room_message(), and update_tunnel_last_message().

Referenced by join_room_locally().

{
  struct GNUNET_MESSENGER_SrvTunnel *tunnel = cls;

  const uint16_t length = ntohs (header->size) - sizeof(*header);
  const char *buffer = (const char*) &header[1];

  struct GNUNET_MESSENGER_Message message;
  struct GNUNET_HashCode hash;

  uint16_t 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));

  if (!tunnel)
    return;

  const int 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);

  int 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_REQUEST:
    forward_message = recv_message_request (tunnel->room, tunnel, &message, &hash);
    break;
  default:
    break;
  }

  if (GNUNET_YES == forward_message)
  {
    forward_room_message (tunnel->room, tunnel, &message, &hash);
    callback_room_handle_message (tunnel->room, NULL, &message, &hash);
  }

receive_done:
  GNUNET_CADET_receive_done (tunnel->channel);
}

Here is the call graph for this function:

Here is the caller graph for this function:

connect_tunnel()

int 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

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

References cadet, callback_tunnel_disconnect(), GNUNET_MESSENGER_SrvTunnel::channel, convert_messenger_key_to_port(), get_room_cadet(), get_room_key(), GNUNET_assert, GNUNET_CADET_channel_create(), GNUNET_MESSAGE_TYPE_CADET_CLI, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, GNUNET_NO, GNUNET_PEER_resolve2(), GNUNET_YES, key, GNUNET_MESSENGER_SrvTunnel::peer, and GNUNET_MESSENGER_SrvTunnel::room.

Referenced by enter_room_at(), and rebuild_room_basement_structure().

{
  GNUNET_assert(tunnel);

  if (tunnel->channel)
    return GNUNET_NO;

  const struct GNUNET_PeerIdentity *door = GNUNET_PEER_resolve2 (tunnel->peer);

  struct GNUNET_CADET_Handle *cadet = get_room_cadet (tunnel->room);
  const struct GNUNET_HashCode *key = get_room_key (tunnel->room);

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

  struct GNUNET_HashCode port;
  convert_messenger_key_to_port(key, &port);
  tunnel->channel = GNUNET_CADET_channel_create (cadet, tunnel, door, &port, NULL, callback_tunnel_disconnect, handlers);

  return GNUNET_YES;
}

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

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

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

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

{
  GNUNET_assert(tunnel);

  if (tunnel->channel)
  {
    delayed_disconnect_channel (tunnel->channel);

    tunnel->channel = NULL;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

is_tunnel_connected()

int 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 259 of file gnunet-service-messenger_tunnel.c.

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

Referenced by iterate_send_room_message(), and send_room_info().

{
  GNUNET_assert(tunnel);

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

Here is the caller graph for this function:

callback_tunnel_sent()

static void callback_tunnel_sent ( void *  cls )

static

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

References GNUNET_free, GNUNET_MESSENGER_MessageSent::hash, GNUNET_MESSENGER_MessageSent::tunnel, and update_tunnel_last_message().

Referenced by send_tunnel_envelope().

{
  struct GNUNET_MESSENGER_MessageSent *sent = cls;

  if (sent->tunnel)
    update_tunnel_last_message (sent->tunnel, &(sent->hash));

  GNUNET_free(sent);
}

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

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

References callback_tunnel_sent(), GNUNET_MESSENGER_SrvTunnel::channel, 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 forward_tunnel_message(), iterate_send_room_message(), and send_tunnel_message().

{
  GNUNET_assert((tunnel) && (env) && (hash));

  struct GNUNET_MQ_Handle *mq = GNUNET_CADET_get_mq (tunnel->channel);

  struct GNUNET_MESSENGER_MessageSent *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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

send_tunnel_message()

int 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

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

References destroy_message(), env, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_MESSENGER_PACK_MODE_ENVELOPE, GNUNET_NO, GNUNET_YES, pack_room_message(), GNUNET_MESSENGER_SrvTunnel::room, and send_tunnel_envelope().

Referenced by recv_message_info(), and send_room_info().

{
  GNUNET_assert((tunnel) && (handle));

  if (!message)
    return GNUNET_NO;

  struct GNUNET_HashCode hash;
  struct GNUNET_MQ_Envelope *env = pack_room_message (
      tunnel->room, (struct GNUNET_MESSENGER_SrvHandle*) handle,
      message, &hash, GNUNET_MESSENGER_PACK_MODE_ENVELOPE
  );

  destroy_message(message);

  if (!env)
    return GNUNET_NO;

  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Sending tunnel message: %s\n",
             GNUNET_h2s(&hash));

  send_tunnel_envelope (tunnel, env, &hash);
  return GNUNET_YES;
}

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

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

References copy_message(), destroy_message(), env, 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_room_peer_status(), and forward_about_members().

{
  GNUNET_assert((tunnel) && (message) && (hash));

  struct GNUNET_MESSENGER_Message *copy = copy_message(message);
  struct GNUNET_MQ_Envelope *env = pack_message (copy, NULL, NULL, GNUNET_MESSENGER_PACK_MODE_ENVELOPE);

  destroy_message(copy);

  if (!env)
    return;

  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Forwarding tunnel message: %s\n",
             GNUNET_h2s(hash));

  send_tunnel_envelope (tunnel, env, hash);
}

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 348 of file gnunet-service-messenger_tunnel.c.

References GNUNET_assert, and GNUNET_MESSENGER_SrvTunnel::peer_message.

{
  GNUNET_assert(tunnel);

  return tunnel->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 356 of file gnunet-service-messenger_tunnel.c.

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

Referenced by callback_room_disconnect(), and recv_message_info().

{
  GNUNET_assert(tunnel);

  GNUNET_PEER_resolve(tunnel->peer, peer);
}

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 364 of file gnunet-service-messenger_tunnel.c.

References GNUNET_assert, and GNUNET_MESSENGER_SrvTunnel::messenger_version.

Referenced by iterate_send_room_message(), and recv_message_info().

{
  GNUNET_assert(tunnel);

  return tunnel->messenger_version;
}

Here is the caller graph for this function:

update_tunnel_messenger_version()

int 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

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

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

Referenced by recv_message_info().

{
  GNUNET_assert(tunnel);

  if (version != GNUNET_MESSENGER_VERSION)
    return GNUNET_SYSERR;

  if (version > tunnel->messenger_version)
    tunnel->messenger_version = version;

  return GNUNET_OK;
}

Here is the caller graph for this function: