#include "gnunet_common.h"
#include "gnunet_messenger_service.h"
#include "gnunet-service-messenger.h"
#include "gnunet_reclaim_service.h"
#include "gnunet_time_lib.h"
#include "messenger_api_contact.h"
#include "messenger_api_contact_store.h"
#include "messenger_api_handle.h"
#include "messenger_api_message.h"
#include "messenger_api_message_control.h"
#include "messenger_api_message_kind.h"
#include "messenger_api_room.h"
#include "messenger_api_util.h"

Include dependency graph for messenger_api.c:

Data Structures
struct	GNUNET_MESSENGER_RoomFind

struct	GNUNET_MESSENGER_CheckTicket

Functions
const char *	GNUNET_MESSENGER_name_of_kind (enum GNUNET_MESSENGER_MessageKind kind)
	Get the name of a message kind. More...

static enum GNUNET_GenericReturnValue	dequeue_messages_from_room (struct GNUNET_MESSENGER_Room *room)

static void	handle_room_open (void cls, const struct GNUNET_MESSENGER_RoomMessage msg)

static void	handle_room_entry (void cls, const struct GNUNET_MESSENGER_RoomMessage msg)

static void	handle_room_close (void cls, const struct GNUNET_MESSENGER_RoomMessage msg)

static void	handle_room_sync (void cls, const struct GNUNET_MESSENGER_RoomMessage msg)

static void	enqueue_message_to_room (struct GNUNET_MESSENGER_Room room, struct GNUNET_MESSENGER_Message message, struct GNUNET_MESSENGER_Message *transcript)

static void	handle_member_id (void cls, const struct GNUNET_MESSENGER_MemberMessage msg)

static enum GNUNET_GenericReturnValue	check_recv_message (void cls, const struct GNUNET_MESSENGER_RecvMessage msg)

static void	handle_recv_message (void cls, const struct GNUNET_MESSENGER_RecvMessage msg)

static void	handle_miss_message (void cls, const struct GNUNET_MESSENGER_GetMessage msg)

static void	reconnect (struct GNUNET_MESSENGER_Handle *handle)

static void	send_open_room (struct GNUNET_MESSENGER_Handle handle, struct GNUNET_MESSENGER_Room room)

static void	send_enter_room (struct GNUNET_MESSENGER_Handle handle, struct GNUNET_MESSENGER_Room room, const struct GNUNET_PeerIdentity *door)

static void	send_close_room (struct GNUNET_MESSENGER_Handle handle, struct GNUNET_MESSENGER_Room room)

static void	send_sync_room (struct GNUNET_MESSENGER_Handle handle, struct GNUNET_MESSENGER_Room room)

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

static void	callback_reconnect (void *cls)

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

static void	callback_mq_error (void *cls, enum GNUNET_MQ_Error error)

struct GNUNET_MESSENGER_Handle *	GNUNET_MESSENGER_connect (const struct GNUNET_CONFIGURATION_Handle cfg, const char name, const struct GNUNET_CRYPTO_PrivateKey key, GNUNET_MESSENGER_MessageCallback msg_callback, void msg_cls)
	Set up a handle for the messenger related functions and connects to all necessary services. More...

void	GNUNET_MESSENGER_disconnect (struct GNUNET_MESSENGER_Handle *handle)
	Disconnect all of the messengers used services and clears up its used memory. More...

static void	send_message_to_room (struct GNUNET_MESSENGER_Room room, struct GNUNET_MESSENGER_Message message, const struct GNUNET_CRYPTO_PrivateKey key, struct GNUNET_HashCode hash)

const char *	GNUNET_MESSENGER_get_name (const struct GNUNET_MESSENGER_Handle *handle)
	Get the name (if specified, otherwise NULL) used by the messenger. More...

static enum GNUNET_GenericReturnValue	iterate_send_name_to_room (void cls, struct GNUNET_MESSENGER_Room room, const struct GNUNET_MESSENGER_Contact *contact)

enum GNUNET_GenericReturnValue	GNUNET_MESSENGER_set_name (struct GNUNET_MESSENGER_Handle handle, const char name)
	Set the name for the messenger handle and sends messages renaming your contact in currently open rooms. More...

static const struct GNUNET_CRYPTO_PublicKey *	get_non_anonymous_key (const struct GNUNET_CRYPTO_PublicKey *public_key)

const struct GNUNET_CRYPTO_PublicKey *	GNUNET_MESSENGER_get_key (const struct GNUNET_MESSENGER_Handle *handle)
	Get the public key used by the messenger or NULL if the anonymous key was used. More...

static enum GNUNET_GenericReturnValue	iterate_send_key_to_room (void cls, struct GNUNET_MESSENGER_Room room, const struct GNUNET_MESSENGER_Contact *contact)

enum GNUNET_GenericReturnValue	GNUNET_MESSENGER_set_key (struct GNUNET_MESSENGER_Handle handle, const struct GNUNET_CRYPTO_PrivateKey key)
	Set the private key used by the messenger or NULL if the anonymous key should be used instead. More...

struct GNUNET_MESSENGER_Room *	GNUNET_MESSENGER_open_room (struct GNUNET_MESSENGER_Handle handle, const struct GNUNET_HashCode key)
	Open a room to send and receive messages. More...

struct GNUNET_MESSENGER_Room *	GNUNET_MESSENGER_enter_room (struct GNUNET_MESSENGER_Handle handle, const struct GNUNET_PeerIdentity door, const struct GNUNET_HashCode *key)
	Enter a room to send and receive messages through a door opened using GNUNET_MESSENGER_open_room. More...

void	GNUNET_MESSENGER_close_room (struct GNUNET_MESSENGER_Room *room)
	Close a room which was entered, opened or both in various order and variety. More...

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

int	GNUNET_MESSENGER_find_rooms (const struct GNUNET_MESSENGER_Handle handle, const struct GNUNET_MESSENGER_Contact contact, GNUNET_MESSENGER_MemberCallback callback, void *cls)
	Searches for a specific contact in a given room and calls a selected callback with a given closure for each of them containing the contact as a member. More...

const struct GNUNET_HashCode *	GNUNET_MESSENGER_room_get_key (const struct GNUNET_MESSENGER_Room *room)
	Get the key of a given room. More...

const struct GNUNET_MESSENGER_Contact *	GNUNET_MESSENGER_get_sender (const struct GNUNET_MESSENGER_Room room, const struct GNUNET_HashCode hash)
	Get the contact of a member in a room which sent a specific message identified with a given hash. More...

const struct GNUNET_MESSENGER_Contact *	GNUNET_MESSENGER_get_recipient (const struct GNUNET_MESSENGER_Room room, const struct GNUNET_HashCode hash)
	Get the contact of a member in a room which has been targeted as recipient of a specific message identified with a given hash. More...

const char *	GNUNET_MESSENGER_contact_get_name (const struct GNUNET_MESSENGER_Contact *contact)
	Get the name used by the contact. More...

const struct GNUNET_CRYPTO_PublicKey *	GNUNET_MESSENGER_contact_get_key (const struct GNUNET_MESSENGER_Contact *contact)
	Get the public key used by the contact or NULL if the anonymous key was used. More...

size_t	GNUNET_MESSENGER_contact_get_id (const struct GNUNET_MESSENGER_Contact *contact)
	Get the locally unique id of the contact. More...

static void	send_message_to_room_with_key (struct GNUNET_MESSENGER_Room room, struct GNUNET_MESSENGER_Message message, const struct GNUNET_CRYPTO_PublicKey *public_key)

void	GNUNET_MESSENGER_send_message (struct GNUNET_MESSENGER_Room room, const struct GNUNET_MESSENGER_Message message, const struct GNUNET_MESSENGER_Contact *contact)
	Send a message into a room. More...

void	delete_message_in_room (struct GNUNET_MESSENGER_Room room, const struct GNUNET_HashCode hash, const struct GNUNET_TIME_Relative delay)

void	GNUNET_MESSENGER_delete_message (struct GNUNET_MESSENGER_Room room, const struct GNUNET_HashCode hash, const struct GNUNET_TIME_Relative delay)
	Delete a message identified by its hash from a room. More...

const struct GNUNET_MESSENGER_Message *	GNUNET_MESSENGER_get_message (const struct GNUNET_MESSENGER_Room room, const struct GNUNET_HashCode hash)
	Get the message in a room identified by its hash. More...

int	GNUNET_MESSENGER_iterate_members (struct GNUNET_MESSENGER_Room room, GNUNET_MESSENGER_MemberCallback callback, void cls)
	Iterates through all members of a given room and calls a selected callback for each of them with a provided closure. More...

static enum GNUNET_GenericReturnValue	check_ticket_audience (void cls, struct GNUNET_MESSENGER_Room room, const struct GNUNET_MESSENGER_Contact *contact)

void	GNUNET_MESSENGER_send_ticket (struct GNUNET_MESSENGER_Room room, const struct GNUNET_RECLAIM_Ticket ticket)
	Send a ticket into a room. More...

Function Documentation

◆ dequeue_messages_from_room()

static enum GNUNET_GenericReturnValue dequeue_messages_from_room ( struct GNUNET_MESSENGER_Room * room )

static

Definition at line 714 of file messenger_api.c.

{
  if (GNUNET_YES != is_room_available (room))
    return room->queue.head ? GNUNET_NO : GNUNET_YES;
 
  struct GNUNET_MESSENGER_Message *message = NULL;
  struct GNUNET_MESSENGER_Message *transcript = NULL;
  struct GNUNET_CRYPTO_PublicKey pubkey;
  struct GNUNET_CRYPTO_PrivateKey key;
  struct GNUNET_HashCode hash, other;
 
  do {
    if (message)
      destroy_message (message);
 
    message = dequeue_from_messages (&(room->queue), &key, &transcript);
 
    if (! message)
    {
      message = transcript;
      continue;
    }
 
    send_message_to_room (room, message, &key, &hash);
 
    if (! transcript)
      continue;
 
    GNUNET_memcpy (&(transcript->body.transcript.hash), &hash, sizeof(hash));
    GNUNET_CRYPTO_key_get_public (&key, &pubkey);
 
    if (GNUNET_YES == encrypt_message (transcript, &pubkey))
    {
      send_message_to_room (room, transcript, &key, &other);
 
      link_room_message (room, &hash, &other);
      link_room_message (room, &other, &hash);
    }
    else
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Sending transcript aborted: Encryption failed!\n");
    
    destroy_message (transcript);
  } while (message);
 
  return GNUNET_YES;
}

References GNUNET_MESSENGER_Message::body, dequeue_from_messages(), destroy_message(), encrypt_message(), GNUNET_CRYPTO_key_get_public(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_memcpy, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_MessageTranscript::hash, GNUNET_MESSENGER_QueueMessages::head, is_room_available(), key, link_room_message(), pubkey, GNUNET_MESSENGER_Room::queue, send_message_to_room(), and GNUNET_MESSENGER_MessageBody::transcript.

Referenced by enqueue_message_to_room(), handle_room_entry(), handle_room_open(), and handle_room_sync().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_room_open()

static void handle_room_open	(	void *	cls,
		const struct GNUNET_MESSENGER_RoomMessage *	msg
	)

static

Definition at line 95 of file messenger_api.c.

{
  struct GNUNET_MESSENGER_Handle *handle = cls;
 
  const struct GNUNET_HashCode *key = &(msg->key);
  const struct GNUNET_HashCode *prev = &(msg->previous);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Opened room: %s\n", GNUNET_h2s (key));
 
  open_handle_room (handle, key);
 
  struct GNUNET_MESSENGER_Room *room = get_handle_room (handle, key);
 
  if (! room)
    return;
 
  update_room_last_message (room, prev);
 
  dequeue_messages_from_room (room);
}

References dequeue_messages_from_room(), get_handle_room(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, handle, key, msg, open_handle_room(), and update_room_last_message().

Here is the call graph for this function:

◆ handle_room_entry()

static void handle_room_entry	(	void *	cls,
		const struct GNUNET_MESSENGER_RoomMessage *	msg
	)

static

Definition at line 119 of file messenger_api.c.

{
  struct GNUNET_MESSENGER_Handle *handle = cls;
 
  const struct GNUNET_PeerIdentity *door = &(msg->door);
  const struct GNUNET_HashCode *key = &(msg->key);
  const struct GNUNET_HashCode *prev = &(msg->previous);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Entered room: %s\n", GNUNET_h2s (key));
 
  entry_handle_room_at (handle, door, key);
 
  struct GNUNET_MESSENGER_Room *room = get_handle_room (handle, key);
 
  if (! room)
    return;
 
  update_room_last_message (room, prev);
 
  dequeue_messages_from_room (room);
}

References dequeue_messages_from_room(), entry_handle_room_at(), get_handle_room(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, handle, key, msg, and update_room_last_message().

Here is the call graph for this function:

◆ handle_room_close()

static void handle_room_close	(	void *	cls,
		const struct GNUNET_MESSENGER_RoomMessage *	msg
	)

static

Definition at line 144 of file messenger_api.c.

{
  struct GNUNET_MESSENGER_Handle *handle = cls;
 
  const struct GNUNET_HashCode *key = &(msg->key);
  const struct GNUNET_HashCode *prev = &(msg->previous);
 
  struct GNUNET_MESSENGER_Room *room = get_handle_room (handle, key);
 
  if (room)
    update_room_last_message (room, prev);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Closed room: %s\n", GNUNET_h2s (key));
 
  close_handle_room (handle, key);
}

References close_handle_room(), get_handle_room(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, handle, key, msg, and update_room_last_message().

Here is the call graph for this function:

◆ handle_room_sync()

static void handle_room_sync	(	void *	cls,
		const struct GNUNET_MESSENGER_RoomMessage *	msg
	)

static

Definition at line 164 of file messenger_api.c.

{
  struct GNUNET_MESSENGER_Handle *handle = cls;
 
  const struct GNUNET_HashCode *key = &(msg->key);
  const struct GNUNET_HashCode *prev = &(msg->previous);
 
  struct GNUNET_MESSENGER_Room *room = get_handle_room (handle, key);
 
  if (! room)
    return;
 
  update_room_last_message (room, prev);
 
  room->wait_for_sync = GNUNET_NO;
 
  dequeue_messages_from_room (room);
}

References dequeue_messages_from_room(), get_handle_room(), GNUNET_NO, handle, key, msg, update_room_last_message(), and GNUNET_MESSENGER_Room::wait_for_sync.

Here is the call graph for this function:

◆ enqueue_message_to_room()

static void enqueue_message_to_room	(	struct GNUNET_MESSENGER_Room *	room,
		struct GNUNET_MESSENGER_Message *	message,
		struct GNUNET_MESSENGER_Message *	transcript
	)

static

Definition at line 682 of file messenger_api.c.

{
  GNUNET_assert ((room) && (message));
 
  const struct GNUNET_CRYPTO_PrivateKey *key = get_handle_key (room->handle);
  enum GNUNET_GenericReturnValue priority;
 
  switch (message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_JOIN:
    priority = GNUNET_YES;
    break;
  default:
    priority = GNUNET_NO;
    break;
  }
 
  enqueue_to_messages (&(room->queue), key, message, transcript, priority);
 
  if (GNUNET_YES != is_room_available (room))
    return;
 
  if (GNUNET_YES == is_message_session_bound (message))
    send_sync_room (room->handle, room);
  else if (GNUNET_YES != room->wait_for_sync)
    dequeue_messages_from_room (room);
}

References dequeue_messages_from_room(), enqueue_to_messages(), get_handle_key(), GNUNET_assert, GNUNET_MESSENGER_KIND_JOIN, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_Room::handle, GNUNET_MESSENGER_Message::header, is_message_session_bound(), is_room_available(), key, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_Room::queue, send_sync_room(), and GNUNET_MESSENGER_Room::wait_for_sync.

Referenced by GNUNET_MESSENGER_close_room(), handle_member_id(), handle_miss_message(), iterate_send_key_to_room(), iterate_send_name_to_room(), and send_message_to_room_with_key().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_member_id()

static void handle_member_id	(	void *	cls,
		const struct GNUNET_MESSENGER_MemberMessage *	msg
	)

static

Definition at line 191 of file messenger_api.c.

{
  struct GNUNET_MESSENGER_Handle *handle = cls;
 
  const struct GNUNET_HashCode *key = &(msg->key);
  const struct GNUNET_ShortHashCode *id = &(msg->id);
  const uint32_t reset = msg->reset;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Changed member id in room: %s\n",
              GNUNET_h2s (key));
 
  struct GNUNET_MESSENGER_Room *room = get_handle_room (handle, key);
 
  if (! room)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Room is unknown to handle: %s\n",
                GNUNET_h2s (key));
    return;
  }
 
  struct GNUNET_MESSENGER_Message *message;
  if ((! get_room_sender_id (room)) || (GNUNET_YES == reset))
  {
    set_room_sender_id (room, id);
    message = create_message_join (get_handle_key (handle));
  }
  else
    message = create_message_id (id);
 
  if (! message)
    return;
 
  enqueue_message_to_room (room, message, NULL);
}

References create_message_id(), create_message_join(), enqueue_message_to_room(), get_handle_key(), get_handle_room(), get_room_sender_id(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_h2s(), GNUNET_log, GNUNET_YES, handle, key, msg, reset, and set_room_sender_id().

Here is the call graph for this function:

◆ check_recv_message()

static enum GNUNET_GenericReturnValue check_recv_message	(	void *	cls,
		const struct GNUNET_MESSENGER_RecvMessage *	msg
	)

static

Definition at line 229 of file messenger_api.c.

{
  const uint16_t full_length = ntohs (msg->header.size);
 
  if (full_length < sizeof(*msg))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Receiving failed: Message invalid!\n");
    return GNUNET_NO;
  }
 
  const uint16_t length = full_length - sizeof(*msg);
  const char *buffer = ((const char*) msg) + sizeof(*msg);
 
  struct GNUNET_MESSENGER_Message message;
 
  if (length < get_message_kind_size (GNUNET_MESSENGER_KIND_UNKNOWN,
                                      GNUNET_YES))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Receiving failed: Message too short!\n");
    return GNUNET_NO;
  }
 
  if (GNUNET_YES != decode_message (&message, length, buffer, GNUNET_YES, NULL))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Receiving failed: Message decoding failed!\n");
    return GNUNET_NO;
  }
 
  cleanup_message (&message);
  return GNUNET_OK;
}

References cleanup_message(), decode_message(), get_message_kind_size(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_MESSENGER_KIND_UNKNOWN, GNUNET_NO, GNUNET_OK, GNUNET_YES, msg, and GNUNET_MessageHeader::size.

Here is the call graph for this function:

◆ handle_recv_message()

static void handle_recv_message	(	void *	cls,
		const struct GNUNET_MESSENGER_RecvMessage *	msg
	)

static

Definition at line 267 of file messenger_api.c.

{
  struct GNUNET_MESSENGER_Handle *handle = cls;
 
  const struct GNUNET_HashCode *key = &(msg->key);
  const struct GNUNET_HashCode *sender = &(msg->sender);
  const struct GNUNET_HashCode *context = &(msg->context);
  const struct GNUNET_HashCode *hash = &(msg->hash);
 
  enum GNUNET_MESSENGER_MessageFlags flags = (
    (enum GNUNET_MESSENGER_MessageFlags) (msg->flags));
 
  const uint16_t length = ntohs (msg->header.size) - sizeof(*msg);
  const char *buffer = ((const char*) msg) + sizeof(*msg);
 
  struct GNUNET_MESSENGER_Message message;
  decode_message (&message, length, buffer, GNUNET_YES, NULL);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Receiving message: %s\n",
              GNUNET_MESSENGER_name_of_kind (message.header.kind));
 
  struct GNUNET_MESSENGER_Room *room = get_handle_room (handle, key);
 
  if (! room)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Unknown room for this client: %s\n",
                GNUNET_h2s (key));
 
    goto skip_message;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Raw contact from sender and context: (%s : %s)\n",
              GNUNET_h2s (sender), GNUNET_h2s_full (context));
 
  process_message_control (room->control,
                           sender,
                           context,
                           hash,
                           &message,
                           flags);
 
skip_message:
  cleanup_message (&message);
}

References cleanup_message(), context, GNUNET_MESSENGER_Room::control, decode_message(), get_handle_room(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_h2s_full(), GNUNET_log, GNUNET_MESSENGER_name_of_kind(), GNUNET_YES, handle, GNUNET_MESSENGER_Message::header, key, GNUNET_MESSENGER_MessageHeader::kind, msg, process_message_control(), and GNUNET_MessageHeader::size.

Here is the call graph for this function:

◆ handle_miss_message()

static void handle_miss_message	(	void *	cls,
		const struct GNUNET_MESSENGER_GetMessage *	msg
	)

static

Definition at line 316 of file messenger_api.c.

{
  struct GNUNET_MESSENGER_Handle *handle = cls;
 
  const struct GNUNET_HashCode *key = &(msg->key);
  const struct GNUNET_HashCode *hash = &(msg->hash);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Missing message in room: %s\n",
              GNUNET_h2s (hash));
 
  struct GNUNET_MESSENGER_Room *room = get_handle_room (handle, key);
 
  if (! room)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Miss in unknown room for this client: %s\n", GNUNET_h2s (key));
    return;
  }
 
  if (! get_room_sender_id (room))
    return;
 
  struct GNUNET_MESSENGER_Message *message = create_message_request (hash);
  if (! message)
    return;
 
  enqueue_message_to_room (room, message, NULL);
}

References create_message_request(), enqueue_message_to_room(), get_handle_room(), get_room_sender_id(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, handle, key, and msg.

Here is the call graph for this function:

◆ reconnect()

static void reconnect ( struct GNUNET_MESSENGER_Handle * handle )

static

Definition at line 539 of file messenger_api.c.

{
  const struct GNUNET_MQ_MessageHandler handlers[] = {
    GNUNET_MQ_hd_fixed_size (
      member_id,
      GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_MEMBER_ID,
      struct GNUNET_MESSENGER_MemberMessage, handle
      ),
    GNUNET_MQ_hd_fixed_size (
      room_open,
      GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_OPEN,
      struct GNUNET_MESSENGER_RoomMessage, handle
      ),
    GNUNET_MQ_hd_fixed_size (
      room_entry,
      GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_ENTRY,
      struct GNUNET_MESSENGER_RoomMessage, handle
      ),
    GNUNET_MQ_hd_fixed_size (
      room_close,
      GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_CLOSE,
      struct GNUNET_MESSENGER_RoomMessage, handle
      ),
    GNUNET_MQ_hd_var_size (
      recv_message,
      GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_RECV_MESSAGE,
      struct GNUNET_MESSENGER_RecvMessage, handle
      ),
    GNUNET_MQ_hd_fixed_size (
      miss_message,
      GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_GET_MESSAGE,
      struct GNUNET_MESSENGER_GetMessage, handle
      ),
    GNUNET_MQ_hd_fixed_size (
      room_sync,
      GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_SYNC,
      struct GNUNET_MESSENGER_RoomMessage, handle
      ),
    GNUNET_MQ_handler_end ()
  };
 
  handle->mq = GNUNET_CLIENT_connect (handle->cfg,
                                      GNUNET_MESSENGER_SERVICE_NAME, handlers,
                                      &callback_mq_error, handle);
}

References callback_mq_error(), GNUNET_VPN_Handle::cfg, GNUNET_CLIENT_connect(), GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_MEMBER_ID, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_CLOSE, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_ENTRY, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_GET_MESSAGE, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_OPEN, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_RECV_MESSAGE, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_SYNC, GNUNET_MESSENGER_SERVICE_NAME, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, handle, handlers, GNUNET_VPN_Handle::mq, and recv_message().

Referenced by callback_reconnect(), and GNUNET_MESSENGER_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_open_room()

static void send_open_room	(	struct GNUNET_MESSENGER_Handle *	handle,
		struct GNUNET_MESSENGER_Room *	room
	)

static

Definition at line 351 of file messenger_api.c.

{
  const struct GNUNET_CRYPTO_PublicKey *key = get_handle_pubkey (handle);
 
  struct GNUNET_MESSENGER_RoomMessage *msg;
  struct GNUNET_MQ_Envelope *env;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Open room (%s) by member using key: %s\n",
              GNUNET_h2s (&(room->key)),
              GNUNET_CRYPTO_public_key_to_string (key));
 
  const ssize_t len = GNUNET_CRYPTO_public_key_get_length (key);
 
  env = GNUNET_MQ_msg_extra (msg, len > 0 ? len : 0,
                             GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_OPEN);
  GNUNET_memcpy (&(msg->key), &(room->key), sizeof(msg->key));
  GNUNET_memcpy (&(msg->previous), &(room->last_message),
                 sizeof(msg->previous));
 
  char *msg_buffer = ((char*) msg) + sizeof(*msg);
 
  if (len > 0)
    GNUNET_CRYPTO_write_public_key_to_buffer (key, msg_buffer, len);
 
  GNUNET_MQ_send (handle->mq, env);
}

References env, get_handle_pubkey(), GNUNET_CRYPTO_public_key_get_length(), GNUNET_CRYPTO_public_key_to_string(), GNUNET_CRYPTO_write_public_key_to_buffer(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_OPEN, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), handle, key, GNUNET_MESSENGER_Room::key, GNUNET_MESSENGER_Room::last_message, GNUNET_VPN_Handle::mq, and msg.

Referenced by GNUNET_MESSENGER_open_room(), and iterate_reset_room().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_enter_room()

static void send_enter_room	(	struct GNUNET_MESSENGER_Handle *	handle,
		struct GNUNET_MESSENGER_Room *	room,
		const struct GNUNET_PeerIdentity *	door
	)

static

Definition at line 382 of file messenger_api.c.

{
  const struct GNUNET_CRYPTO_PublicKey *key = get_handle_pubkey (handle);
 
  struct GNUNET_MESSENGER_RoomMessage *msg;
  struct GNUNET_MQ_Envelope *env;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Enter room (%s) via door: %s (%s)\n",
              GNUNET_h2s (&(room->key)),
              GNUNET_i2s (door),
              GNUNET_CRYPTO_public_key_to_string (key));
 
  const ssize_t len = GNUNET_CRYPTO_public_key_get_length (key);
 
  env = GNUNET_MQ_msg_extra (msg, len > 0 ? len : 0,
                             GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_ENTRY);
  GNUNET_memcpy (&(msg->door), door, sizeof(*door));
  GNUNET_memcpy (&(msg->key), &(room->key), sizeof(msg->key));
  GNUNET_memcpy (&(msg->previous), &(room->last_message),
                 sizeof(msg->previous));
 
  char *msg_buffer = ((char*) msg) + sizeof(*msg);
 
  if (len > 0)
    GNUNET_CRYPTO_write_public_key_to_buffer (key, msg_buffer, len);
 
  GNUNET_MQ_send (handle->mq, env);
}

References env, get_handle_pubkey(), GNUNET_CRYPTO_public_key_get_length(), GNUNET_CRYPTO_public_key_to_string(), GNUNET_CRYPTO_write_public_key_to_buffer(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_i2s(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_ENTRY, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), handle, key, GNUNET_MESSENGER_Room::key, GNUNET_MESSENGER_Room::last_message, GNUNET_VPN_Handle::mq, and msg.

Referenced by GNUNET_MESSENGER_enter_room(), and iterate_reset_room().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_close_room()

static void send_close_room	(	struct GNUNET_MESSENGER_Handle *	handle,
		struct GNUNET_MESSENGER_Room *	room
	)

static

Definition at line 415 of file messenger_api.c.

{
  struct GNUNET_MESSENGER_RoomMessage *msg;
  struct GNUNET_MQ_Envelope *env;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Close room (%s)!\n",
              GNUNET_h2s (&(room->key)));
 
  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_CLOSE);
 
  GNUNET_memcpy (&(msg->key), &(room->key), sizeof(msg->key));
  GNUNET_memcpy (&(msg->previous), &(room->last_message),
                 sizeof(msg->previous));
 
  GNUNET_MQ_send (handle->mq, env);
}

References env, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_CLOSE, GNUNET_MQ_msg, GNUNET_MQ_send(), handle, GNUNET_MESSENGER_Room::key, GNUNET_MESSENGER_Room::last_message, GNUNET_VPN_Handle::mq, and msg.

Referenced by iterate_close_room(), and send_message_to_room().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_sync_room()

static void send_sync_room	(	struct GNUNET_MESSENGER_Handle *	handle,
		struct GNUNET_MESSENGER_Room *	room
	)

static

Definition at line 435 of file messenger_api.c.

{
  struct GNUNET_MESSENGER_RoomMessage *msg;
  struct GNUNET_MQ_Envelope *env;
 
  room->wait_for_sync = GNUNET_YES;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sync room (%s)!\n",
              GNUNET_h2s (&(room->key)));
 
  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_SYNC);
 
  GNUNET_memcpy (&(msg->key), &(room->key), sizeof(msg->key));
  GNUNET_memcpy (&(msg->previous), &(room->last_message),
                 sizeof(msg->previous));
 
  GNUNET_MQ_send (handle->mq, env);
}

References env, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_SYNC, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_YES, handle, GNUNET_MESSENGER_Room::key, GNUNET_MESSENGER_Room::last_message, GNUNET_VPN_Handle::mq, msg, and GNUNET_MESSENGER_Room::wait_for_sync.

Referenced by enqueue_message_to_room().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ iterate_reset_room()

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

static

Definition at line 457 of file messenger_api.c.

{
  struct GNUNET_MESSENGER_Handle *handle = cls;
  struct GNUNET_MESSENGER_Room *room = value;
 
  if (GNUNET_YES == room->opened)
    send_open_room (handle, room);
 
  struct GNUNET_MESSENGER_ListTunnel *entry = room->entries.head;
 
  struct GNUNET_PeerIdentity door;
 
  while (entry)
  {
    GNUNET_PEER_resolve (entry->peer, &door);
 
    send_enter_room (handle, room, &door);
 
    entry = entry->next;
  }
 
  return GNUNET_YES;
}

References GNUNET_MESSENGER_Room::entries, GNUNET_PEER_resolve(), GNUNET_YES, handle, GNUNET_MESSENGER_ListTunnels::head, GNUNET_MESSENGER_ListTunnel::next, GNUNET_MESSENGER_Room::opened, GNUNET_MESSENGER_ListTunnel::peer, send_enter_room(), send_open_room(), and value.

Referenced by callback_reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ callback_reconnect()

static void callback_reconnect ( void * cls )

static

Definition at line 485 of file messenger_api.c.

{
  struct GNUNET_MESSENGER_Handle *handle = cls;
 
  handle->reconnect_task = NULL;
  handle->reconnect_time = GNUNET_TIME_STD_BACKOFF (handle->reconnect_time);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Reconnect messenger!\n");
 
  reconnect (handle);
 
  GNUNET_CONTAINER_multihashmap_iterate (handle->rooms, iterate_reset_room,
                                         handle);
}

References GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_TIME_STD_BACKOFF, handle, iterate_reset_room(), and reconnect().

Referenced by callback_mq_error().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ iterate_close_room()

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

static

Definition at line 502 of file messenger_api.c.

{
  struct GNUNET_MESSENGER_Handle *handle = cls;
  struct GNUNET_MESSENGER_Room *room = value;
 
  send_close_room (handle, room);
 
  return GNUNET_YES;
}

References GNUNET_YES, handle, send_close_room(), and value.

Referenced by callback_mq_error().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ callback_mq_error()

static void callback_mq_error	(	void *	cls,
		enum GNUNET_MQ_Error	error
	)

static

Definition at line 516 of file messenger_api.c.

{
  struct GNUNET_MESSENGER_Handle *handle = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "MQ_Error: %u\n", error);
 
  GNUNET_CONTAINER_multihashmap_iterate (handle->rooms, iterate_close_room,
                                         handle);
 
  if (handle->mq)
  {
    GNUNET_MQ_destroy (handle->mq);
    handle->mq = NULL;
  }
 
  handle->reconnect_task = GNUNET_SCHEDULER_add_delayed (handle->reconnect_time,
                                                         &callback_reconnect,
                                                         handle);
}

References callback_reconnect(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_add_delayed(), handle, iterate_close_room(), and GNUNET_VPN_Handle::mq.

Referenced by reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_message_to_room()

static void send_message_to_room	(	struct GNUNET_MESSENGER_Room *	room,
		struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_CRYPTO_PrivateKey *	key,
		struct GNUNET_HashCode *	hash
	)

static

Definition at line 637 of file messenger_api.c.

{
  const struct GNUNET_ShortHashCode *sender_id = get_room_sender_id (room);
 
  message->header.timestamp = GNUNET_TIME_absolute_hton (
    GNUNET_TIME_absolute_get ());
 
  GNUNET_memcpy (&(message->header.sender_id), sender_id,
                 sizeof(message->header.sender_id));
  GNUNET_memcpy (&(message->header.previous), &(room->last_message),
                 sizeof(message->header.previous));
 
  message->header.signature.type = key->type;
 
  const uint16_t msg_length = get_message_size (message, GNUNET_YES);
 
  struct GNUNET_MESSENGER_SendMessage *msg;
  struct GNUNET_MQ_Envelope *env;
 
  env = GNUNET_MQ_msg_extra (
    msg, msg_length,
    GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_SEND_MESSAGE
    );
 
  GNUNET_memcpy (&(msg->key), &(room->key), sizeof(msg->key));
 
  char *msg_buffer = ((char*) msg) + sizeof(*msg);
  encode_message (message, msg_length, msg_buffer, GNUNET_YES);
 
  hash_message (message, msg_length, msg_buffer, hash);
  sign_message (message, msg_length, msg_buffer, hash, key);
 
  update_room_last_message (room, hash);
 
  GNUNET_MQ_send (room->handle->mq, env);
 
  if (GNUNET_MESSENGER_KIND_LEAVE == message->header.kind)
    send_close_room (room->handle, room);
}

References encode_message(), env, get_message_size(), get_room_sender_id(), GNUNET_memcpy, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_SEND_MESSAGE, GNUNET_MESSENGER_KIND_LEAVE, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_hton(), GNUNET_YES, GNUNET_MESSENGER_Room::handle, hash_message(), GNUNET_MESSENGER_Message::header, key, GNUNET_MESSENGER_Room::key, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_Room::last_message, GNUNET_MESSENGER_Handle::mq, msg, GNUNET_MESSENGER_MessageHeader::previous, send_close_room(), GNUNET_MESSENGER_MessageHeader::sender_id, sign_message(), GNUNET_MESSENGER_MessageHeader::signature, GNUNET_MESSENGER_MessageHeader::timestamp, GNUNET_CRYPTO_Signature::type, and update_room_last_message().

Referenced by dequeue_messages_from_room().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ iterate_send_name_to_room()

static enum GNUNET_GenericReturnValue iterate_send_name_to_room	(	void *	cls,
		struct GNUNET_MESSENGER_Room *	room,
		const struct GNUNET_MESSENGER_Contact *	contact
	)

static

Definition at line 774 of file messenger_api.c.

{
  const struct GNUNET_MESSENGER_Handle *handle = cls;
 
  if (GNUNET_YES != room->use_handle_name)
    return GNUNET_YES;
 
  const char *name = get_handle_name (handle);
 
  if (! name)
    return GNUNET_YES;
 
  struct GNUNET_MESSENGER_Message *message = create_message_name (name);
 
  if (! message)
    return GNUNET_NO;
 
  enqueue_message_to_room (room, message, NULL);
  return GNUNET_YES;
}

References create_message_name(), enqueue_message_to_room(), get_handle_name(), GNUNET_NO, GNUNET_YES, handle, name, and GNUNET_MESSENGER_Room::use_handle_name.

Referenced by GNUNET_MESSENGER_set_name().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_non_anonymous_key()

static const struct GNUNET_CRYPTO_PublicKey * get_non_anonymous_key ( const struct GNUNET_CRYPTO_PublicKey * public_key )

static

Definition at line 812 of file messenger_api.c.

{
  if (0 == GNUNET_memcmp (public_key, get_anonymous_public_key ()))
    return NULL;
 
  return public_key;
}

References get_anonymous_public_key(), and GNUNET_memcmp.

Referenced by check_ticket_audience(), GNUNET_MESSENGER_contact_get_key(), GNUNET_MESSENGER_get_key(), and GNUNET_MESSENGER_send_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ iterate_send_key_to_room()

static enum GNUNET_GenericReturnValue iterate_send_key_to_room	(	void *	cls,
		struct GNUNET_MESSENGER_Room *	room,
		const struct GNUNET_MESSENGER_Contact *	contact
	)

static

Definition at line 832 of file messenger_api.c.

{
  const struct GNUNET_CRYPTO_PrivateKey *key = cls;
 
  struct GNUNET_MESSENGER_Message *message = create_message_key (key);
 
  if (! message)
    return GNUNET_NO;
 
  enqueue_message_to_room (room, message, NULL);
  return GNUNET_YES;
}

References create_message_key(), enqueue_message_to_room(), GNUNET_NO, GNUNET_YES, and key.

Referenced by GNUNET_MESSENGER_set_key().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ iterate_find_room()

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

static

Definition at line 953 of file messenger_api.c.

{
  struct GNUNET_MESSENGER_RoomFind *find = cls;
  struct GNUNET_MESSENGER_Room *room = value;
 
  if ((find->counter > 0) && ((! find->contact) || (GNUNET_YES ==
                                                    find_room_member (room,
                                                                      find->
                                                                      contact))))
  {
    find->counter--;
 
    if (! find->callback)
      return GNUNET_YES;
 
    return find->callback (find->cls, room, find->contact);
  }
  else
    return GNUNET_NO;
}

References GNUNET_MESSENGER_RoomFind::callback, GNUNET_MESSENGER_RoomFind::cls, GNUNET_MESSENGER_RoomFind::contact, GNUNET_MESSENGER_RoomFind::counter, find_room_member(), GNUNET_NO, GNUNET_YES, and value.

Referenced by GNUNET_MESSENGER_find_rooms().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_message_to_room_with_key()

static void send_message_to_room_with_key	(	struct GNUNET_MESSENGER_Room *	room,
		struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_CRYPTO_PublicKey *	public_key
	)

static

Definition at line 1064 of file messenger_api.c.

{
  struct GNUNET_MESSENGER_Message *transcript = NULL;
  const struct GNUNET_CRYPTO_PublicKey *pubkey;
 
  char *original_name;
 
  if (GNUNET_MESSENGER_KIND_NAME != message->header.kind)
    goto skip_naming;
 
  original_name = message->body.name.name;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Apply rule for using handle name in room: %s\n", GNUNET_h2s (
                &(room->key)));
 
  const char *handle_name = get_handle_name (room->handle);
 
  if ((handle_name) && (GNUNET_YES == room->use_handle_name) &&
      ((! original_name) || (0 == strlen (original_name))))
  {
    if (original_name)
      GNUNET_free (original_name);
 
    message->body.name.name = GNUNET_strdup (handle_name);
  }
 
skip_naming:
  if (! public_key)
    goto skip_encryption;
 
  pubkey = get_handle_pubkey (room->handle);
 
  if (0 != GNUNET_memcmp (pubkey, public_key))
    transcript = transcribe_message (message, public_key);
 
  if (GNUNET_YES != encrypt_message (message, public_key))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Sending message aborted: Encryption failed!\n");
 
    if (transcript)
      destroy_message (transcript);
 
    destroy_message (message);
    return;
  }
 
skip_encryption:
  enqueue_message_to_room (room, message, transcript);
}

References GNUNET_MESSENGER_Message::body, destroy_message(), encrypt_message(), enqueue_message_to_room(), get_handle_name(), get_handle_pubkey(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_memcmp, GNUNET_MESSENGER_KIND_NAME, GNUNET_strdup, GNUNET_YES, GNUNET_MESSENGER_Room::handle, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_Room::key, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_MessageName::name, GNUNET_MESSENGER_MessageBody::name, pubkey, transcribe_message(), and GNUNET_MESSENGER_Room::use_handle_name.

Referenced by delete_message_in_room(), GNUNET_MESSENGER_send_message(), and GNUNET_MESSENGER_send_ticket().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ delete_message_in_room()

void delete_message_in_room	(	struct GNUNET_MESSENGER_Room *	room,
		const struct GNUNET_HashCode *	hash,
		const struct GNUNET_TIME_Relative	delay
	)

Definition at line 1163 of file messenger_api.c.

{
  struct GNUNET_MESSENGER_Message *message = create_message_delete (hash,
                                                                    delay);
 
  if (! message)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Sending deletion aborted: Message creation failed!\n");
    return;
  }
 
  send_message_to_room_with_key (room, message, NULL);
}

References create_message_delete(), GNUNET_ERROR_TYPE_WARNING, GNUNET_log, and send_message_to_room_with_key().

Referenced by GNUNET_MESSENGER_delete_message(), and handle_delete_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_ticket_audience()

static enum GNUNET_GenericReturnValue check_ticket_audience	(	void *	cls,
		struct GNUNET_MESSENGER_Room *	room,
		const struct GNUNET_MESSENGER_Contact *	contact
	)

static

Definition at line 1238 of file messenger_api.c.

{
  struct GNUNET_MESSENGER_CheckTicket *check = cls;
 
  const struct GNUNET_CRYPTO_PublicKey *key;
  key = get_non_anonymous_key (get_contact_key (contact));
 
  if ((key) && (0 == GNUNET_memcmp (key, check->audience)))
  {
    check->result = GNUNET_YES;
    return GNUNET_NO;
  }
 
  return GNUNET_YES;
}

References GNUNET_MESSENGER_CheckTicket::audience, get_contact_key(), get_non_anonymous_key(), GNUNET_memcmp, GNUNET_NO, GNUNET_YES, key, and GNUNET_MESSENGER_CheckTicket::result.

Referenced by GNUNET_MESSENGER_send_ticket().

Here is the call graph for this function:

Here is the caller graph for this function:

Data Structures

Functions

Function Documentation

◆ dequeue_messages_from_room()

◆ handle_room_open()

◆ handle_room_entry()

◆ handle_room_close()

◆ handle_room_sync()

◆ enqueue_message_to_room()

◆ handle_member_id()

◆ check_recv_message()

◆ handle_recv_message()

◆ handle_miss_message()

◆ reconnect()

◆ send_open_room()

◆ send_enter_room()

◆ send_close_room()

◆ send_sync_room()

◆ iterate_reset_room()

◆ callback_reconnect()

◆ iterate_close_room()

◆ callback_mq_error()

◆ send_message_to_room()

◆ iterate_send_name_to_room()

◆ get_non_anonymous_key()

◆ iterate_send_key_to_room()

◆ iterate_find_room()

◆ send_message_to_room_with_key()

◆ delete_message_in_room()

◆ check_ticket_audience()