Instant messaging based on the CADET subsystem. More...

Data Structures
struct	GNUNET_MESSENGER_RoomEntryRecord
	A room entry record specifies which peer is hosting a given room and may also specify the key to enter it. More...

struct	GNUNET_MESSENGER_RoomDetailsRecord
	A room details record specifies a custom name for a given room and some additional space for flags. More...

struct	GNUNET_MESSENGER_MessageHeader
	The header of a GNUNET_MESSENGER_Message. More...

struct	GNUNET_MESSENGER_MessageInfo
	An info message body. More...

struct	GNUNET_MESSENGER_MessageJoin
	A join message body. More...

struct	GNUNET_MESSENGER_MessageLeave
	A leave message body. More...

struct	GNUNET_MESSENGER_MessageName
	A name message body. More...

struct	GNUNET_MESSENGER_MessageKey
	A key message body. More...

struct	GNUNET_MESSENGER_MessagePeer
	A peer message body. More...

struct	GNUNET_MESSENGER_MessageId
	An id message body. More...

struct	GNUNET_MESSENGER_MessageMiss
	A miss message body. More...

struct	GNUNET_MESSENGER_MessageMerge
	A merge message body. More...

struct	GNUNET_MESSENGER_MessageRequest
	A request message body. More...

struct	GNUNET_MESSENGER_MessageInvite
	An invite message body. More...

struct	GNUNET_MESSENGER_MessageText
	A text message body. More...

struct	GNUNET_MESSENGER_MessageFile
	A file message body. More...

struct	GNUNET_MESSENGER_MessagePrivate
	A private message body. More...

struct	GNUNET_MESSENGER_MessageDelete
	A delete message body This allows deletion of an own previous message with any custom automatic delay. More...

struct	GNUNET_MESSENGER_MessageConnection
	A connection message body This allows to tell others about connection information about a peer. More...

struct	GNUNET_MESSENGER_MessageTicket
	A ticket message body This allows to exchange ticket identifiers with an audience. More...

struct	GNUNET_MESSENGER_MessageTranscript
	A transcript message body This allows reading the content of a sent private message. More...

struct	GNUNET_MESSENGER_MessageTag
	A tag message body This allows tagging a message with a custom tag. More...

struct	GNUNET_MESSENGER_MessageBody
	The unified body of a GNUNET_MESSENGER_Message. More...

struct	GNUNET_MESSENGER_Message
	Struct to a message. More...

Macros
#define	GNUNET_MESSENGER_VERSION 0x00000003
	Version number of GNUnet Messenger API. More...

#define	GNUNET_MESSENGER_SERVICE_NAME "messenger"
	Identifier of GNUnet MESSENGER Service. More...

#define	GNUNET_MESSENGER_KIND_MAX (GNUNET_MESSENGER_KIND_DELETE)

Typedefs
typedef void(*	GNUNET_MESSENGER_MessageCallback) (void cls, struct GNUNET_MESSENGER_Room room, const struct GNUNET_MESSENGER_Contact sender, const struct GNUNET_MESSENGER_Contact recipient, const struct GNUNET_MESSENGER_Message message, const struct GNUNET_HashCode hash, enum GNUNET_MESSENGER_MessageFlags flags)
	Method called whenever a message is sent or received from a room. More...

typedef enum GNUNET_GenericReturnValue(*	GNUNET_MESSENGER_MemberCallback) (void cls, struct GNUNET_MESSENGER_Room room, const struct GNUNET_MESSENGER_Contact *contact)
	Method called for each member in a room during iteration. More...

Enumerations
enum	GNUNET_MESSENGER_MessageKind { GNUNET_MESSENGER_KIND_INFO = 1 , GNUNET_MESSENGER_KIND_JOIN = 2 , GNUNET_MESSENGER_KIND_LEAVE = 3 , GNUNET_MESSENGER_KIND_NAME = 4 , GNUNET_MESSENGER_KIND_KEY = 5 , GNUNET_MESSENGER_KIND_PEER = 6 , GNUNET_MESSENGER_KIND_ID = 7 , GNUNET_MESSENGER_KIND_MISS = 8 , GNUNET_MESSENGER_KIND_MERGE = 9 , GNUNET_MESSENGER_KIND_REQUEST = 10 , GNUNET_MESSENGER_KIND_INVITE = 11 , GNUNET_MESSENGER_KIND_TEXT = 12 , GNUNET_MESSENGER_KIND_FILE = 13 , GNUNET_MESSENGER_KIND_PRIVATE = 14 , GNUNET_MESSENGER_KIND_DELETE = 15 , GNUNET_MESSENGER_KIND_CONNECTION = 16 , GNUNET_MESSENGER_KIND_TICKET = 17 , GNUNET_MESSENGER_KIND_TRANSCRIPT = 18 , GNUNET_MESSENGER_KIND_TAG = 19 , GNUNET_MESSENGER_KIND_UNKNOWN = 0 }
	Enum for the different supported kinds of messages. More...

enum	GNUNET_MESSENGER_MessageFlags { GNUNET_MESSENGER_FLAG_NONE = 0 , GNUNET_MESSENGER_FLAG_SENT = 1 , GNUNET_MESSENGER_FLAG_PRIVATE = 2 , GNUNET_MESSENGER_FLAG_PEER = 4 , GNUNET_MESSENGER_FLAG_RECENT = 8 , GNUNET_MESSENGER_FLAG_UPDATE = 16 , GNUNET_MESSENGER_FLAG_DELETE = 32 }
	Enum for the different supported flags used by message handling. More...

enum	GNUNET_MESSENGER_ConnectionFlags { GNUNET_MESSENGER_FLAG_CONNECTION_NONE = 0 , GNUNET_MESSENGER_FLAG_CONNECTION_AUTO = 1 }
	Enum for the different supported flags used to specify connection handling. More...

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

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

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

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

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

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

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

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

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

Detailed Description

Instant messaging based on the CADET subsystem.

Macro Definition Documentation

◆ GNUNET_MESSENGER_VERSION

#define GNUNET_MESSENGER_VERSION 0x00000003

Version number of GNUnet Messenger API.

Current version of the Messenger: 0.3

Definition at line 56 of file gnunet_messenger_service.h.

◆ GNUNET_MESSENGER_SERVICE_NAME

#define GNUNET_MESSENGER_SERVICE_NAME "messenger"

Identifier of GNUnet MESSENGER Service.

Definition at line 61 of file gnunet_messenger_service.h.

◆ GNUNET_MESSENGER_KIND_MAX

#define GNUNET_MESSENGER_KIND_MAX (GNUNET_MESSENGER_KIND_DELETE)

Definition at line 226 of file gnunet_messenger_service.h.

Typedef Documentation

◆ GNUNET_MESSENGER_MessageCallback

typedef void(* GNUNET_MESSENGER_MessageCallback) (void *cls, struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Contact *sender, const struct GNUNET_MESSENGER_Contact *recipient, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash, enum GNUNET_MESSENGER_MessageFlags flags)

Method called whenever a message is sent or received from a room.

The flags will indicate with a bitmask if a message was received privately or if the message was sent by the client.

Parameters

	[in/out]	cls Closure from GNUNET_MESSENGER_connect
[in]	room	Room handle
[in]	sender	Sender of message
[in]	recipient	Recipient of message
[in]	message	Newly received or sent message
[in]	hash	Hash identifying the message
[in]	flags	Flags of the message

Definition at line 715 of file gnunet_messenger_service.h.

◆ GNUNET_MESSENGER_MemberCallback

typedef enum GNUNET_GenericReturnValue(* GNUNET_MESSENGER_MemberCallback) (void *cls, struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Contact *contact)

Method called for each member in a room during iteration.

If the method returns GNUNET_YES the iteration continues, otherwise it will quit the iteration.

Parameters

	[in/out]	cls Closure from GNUNET_MESSENGER_iterate_members
[in]	room	Room handle
[in]	contact	Contact handle

Definition at line 715 of file gnunet_messenger_service.h.

Enumeration Type Documentation

◆ GNUNET_MESSENGER_MessageKind

enum GNUNET_MESSENGER_MessageKind

Enum for the different supported kinds of messages.

Enumerator
GNUNET_MESSENGER_KIND_INFO	The info kind. The message contains a GNUNET_MESSENGER_MessageInfo body.
GNUNET_MESSENGER_KIND_JOIN	The join kind. The message contains a GNUNET_MESSENGER_MessageJoin body.
GNUNET_MESSENGER_KIND_LEAVE	The leave kind. The message contains a GNUNET_MESSENGER_MessageLeave body.
GNUNET_MESSENGER_KIND_NAME	The name kind. The message contains a GNUNET_MESSENGER_MessageName body.
GNUNET_MESSENGER_KIND_KEY	The key kind. The message contains a GNUNET_MESSENGER_MessageKey body.
GNUNET_MESSENGER_KIND_PEER	The peer kind. The message contains a GNUNET_MESSENGER_MessagePeer body.
GNUNET_MESSENGER_KIND_ID	The id kind. The message contains a GNUNET_MESSENGER_MessageId body.
GNUNET_MESSENGER_KIND_MISS	The miss kind. The message contains a GNUNET_MESSENGER_MessageMiss body.
GNUNET_MESSENGER_KIND_MERGE	The merge kind. The message contains a GNUNET_MESSENGER_MessageMerge body.
GNUNET_MESSENGER_KIND_REQUEST	The request kind. The message contains a GNUNET_MESSENGER_MessageRequest body.
GNUNET_MESSENGER_KIND_INVITE	The invite kind. The message contains a GNUNET_MESSENGER_MessageInvite body.
GNUNET_MESSENGER_KIND_TEXT	The text kind. The message contains a GNUNET_MESSENGER_MessageText body.
GNUNET_MESSENGER_KIND_FILE	The file kind. The message contains a GNUNET_MESSENGER_MessageFile body.
GNUNET_MESSENGER_KIND_PRIVATE	The private kind. The message contains a GNUNET_MESSENGER_MessagePrivate body.
GNUNET_MESSENGER_KIND_DELETE	The delete kind. The message contains a GNUNET_MESSENGER_MessageDelete body.
GNUNET_MESSENGER_KIND_CONNECTION	The connection kind. The message contains a GNUNET_MESSENGER_MessageConnection body.
GNUNET_MESSENGER_KIND_TICKET	The ticket kind. The message contains a GNUNET_MESSENGER_MessageTicket body.
GNUNET_MESSENGER_KIND_TRANSCRIPT	The transcript kind. The message contains a GNUNET_MESSENGER_MessageTranscript body.
GNUNET_MESSENGER_KIND_TAG	The tag kind. The message contains a GNUNET_MESSENGER_MessageTag body.
GNUNET_MESSENGER_KIND_UNKNOWN	The unknown kind. The message contains an unknown body.

Definition at line 123 of file gnunet_messenger_service.h.

{
  GNUNET_MESSENGER_KIND_INFO = 1,
 
  GNUNET_MESSENGER_KIND_JOIN = 2,
 
  GNUNET_MESSENGER_KIND_LEAVE = 3,
 
  GNUNET_MESSENGER_KIND_NAME = 4,
 
  GNUNET_MESSENGER_KIND_KEY = 5,
 
  GNUNET_MESSENGER_KIND_PEER = 6,
 
  GNUNET_MESSENGER_KIND_ID = 7,
 
  GNUNET_MESSENGER_KIND_MISS = 8,
 
  GNUNET_MESSENGER_KIND_MERGE = 9,
 
  GNUNET_MESSENGER_KIND_REQUEST = 10,
 
  GNUNET_MESSENGER_KIND_INVITE = 11,
 
  GNUNET_MESSENGER_KIND_TEXT = 12,
 
  GNUNET_MESSENGER_KIND_FILE = 13,
 
  GNUNET_MESSENGER_KIND_PRIVATE = 14,
 
  GNUNET_MESSENGER_KIND_DELETE = 15,
 
  GNUNET_MESSENGER_KIND_CONNECTION = 16,
 
  GNUNET_MESSENGER_KIND_TICKET = 17,
 
  GNUNET_MESSENGER_KIND_TRANSCRIPT = 18,
 
  GNUNET_MESSENGER_KIND_TAG = 19,
 
  GNUNET_MESSENGER_KIND_UNKNOWN = 0
};

◆ GNUNET_MESSENGER_MessageFlags

enum GNUNET_MESSENGER_MessageFlags

Enum for the different supported flags used by message handling.

Compatible flags can be OR'ed together.

Enumerator
GNUNET_MESSENGER_FLAG_NONE	The none flag. The flag indicates that the message is not affected by any special context.
GNUNET_MESSENGER_FLAG_SENT	The sent flag. The flag indicates that the message was sent by the client.
GNUNET_MESSENGER_FLAG_PRIVATE	The private flag. The flag indicates that the message was privately encrypted.
GNUNET_MESSENGER_FLAG_PEER	The peer flag. The flag indicates that the message was sent by a peer and not a member.
GNUNET_MESSENGER_FLAG_RECENT	The recent flag. The flag indicates that the message was recently handled by the service.
GNUNET_MESSENGER_FLAG_UPDATE	The update flag. The flag indicates that the message was updated by the client.
GNUNET_MESSENGER_FLAG_DELETE	The delete flag. The flag indicates that the message was deleted by the service.

Definition at line 646 of file gnunet_messenger_service.h.

{
  GNUNET_MESSENGER_FLAG_NONE = 0,
 
  GNUNET_MESSENGER_FLAG_SENT = 1,
 
  GNUNET_MESSENGER_FLAG_PRIVATE = 2,
 
  GNUNET_MESSENGER_FLAG_PEER = 4,
 
  GNUNET_MESSENGER_FLAG_RECENT = 8,
 
  GNUNET_MESSENGER_FLAG_UPDATE = 16,
 
  GNUNET_MESSENGER_FLAG_DELETE = 32,
};

◆ GNUNET_MESSENGER_ConnectionFlags

enum GNUNET_MESSENGER_ConnectionFlags

Enum for the different supported flags used to specify connection handling.

Compatible flags can be OR'ed together.

Enumerator

GNUNET_MESSENGER_FLAG_CONNECTION_NONE

The none flag.

The flag indicates that the connection is not affected by any modifications. GNUNET_MESSENGER_FLAG_CONNECTION_NONE

GNUNET_MESSENGER_FLAG_CONNECTION_AUTO

The auto flag.

The flag indicates that a peer will automatically handle routing. GNUNET_MESSENGER_FLAG_CONNECTION_AUTO

Definition at line 688 of file gnunet_messenger_service.h.

{
  GNUNET_MESSENGER_FLAG_CONNECTION_NONE = 0,
  GNUNET_MESSENGER_FLAG_CONNECTION_AUTO = 1,
};

Function Documentation

◆ GNUNET_MESSENGER_name_of_kind()

const char * GNUNET_MESSENGER_name_of_kind ( enum GNUNET_MESSENGER_MessageKind kind )

Get the name of a message kind.

Parameters

kind	Kind of a message

Returns: Name of that kind

Definition at line 43 of file messenger_api.c.

{
  switch (kind)
  {
  case GNUNET_MESSENGER_KIND_INFO:
    return "INFO";
  case GNUNET_MESSENGER_KIND_JOIN:
    return "JOIN";
  case GNUNET_MESSENGER_KIND_LEAVE:
    return "LEAVE";
  case GNUNET_MESSENGER_KIND_NAME:
    return "NAME";
  case GNUNET_MESSENGER_KIND_KEY:
    return "KEY";
  case GNUNET_MESSENGER_KIND_PEER:
    return "PEER";
  case GNUNET_MESSENGER_KIND_ID:
    return "ID";
  case GNUNET_MESSENGER_KIND_MISS:
    return "MISS";
  case GNUNET_MESSENGER_KIND_MERGE:
    return "MERGE";
  case GNUNET_MESSENGER_KIND_REQUEST:
    return "REQUEST";
  case GNUNET_MESSENGER_KIND_INVITE:
    return "INVITE";
  case GNUNET_MESSENGER_KIND_TEXT:
    return "TEXT";
  case GNUNET_MESSENGER_KIND_FILE:
    return "FILE";
  case GNUNET_MESSENGER_KIND_PRIVATE:
    return "PRIVATE";
  case GNUNET_MESSENGER_KIND_DELETE:
    return "DELETE";
  case GNUNET_MESSENGER_KIND_CONNECTION:
    return "CONNECTION";
  case GNUNET_MESSENGER_KIND_TICKET:
    return "TICKET";
  case GNUNET_MESSENGER_KIND_TRANSCRIPT:
    return "TRANSCRIPT";
  case GNUNET_MESSENGER_KIND_TAG:
    return "TAG";
  default:
    return "UNKNOWN";
  }
}

Referenced by callback_verify_room_message(), handle_recv_message(), handle_send_message(), handle_tunnel_message(), notify_srv_handle_message(), on_message(), and send_srv_room_message().

Here is the caller graph for this function:

◆ GNUNET_MESSENGER_connect()

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.

It will use the a custom name in combination of a private key provided for signing all messages from the handle.

Parameters

[in]	cfg	Configuration to use
[in]	name	Name or NULL
[in]	key	Private key or NULL to stay anonymous
[in]	msg_callback	Function called when a new message is sent or received
[in,out]	msg_cls	Closure for the msg_callback handler

Returns: Messenger handle to use, NULL on error

Definition at line 587 of file messenger_api.c.

{
  struct GNUNET_MESSENGER_Handle *handle = create_handle (cfg, msg_callback,
                                                          msg_cls);
 
  reconnect (handle);
 
  if (handle->mq)
  {
    set_handle_name (handle, name);
 
    if ((! key) || (0 < GNUNET_CRYPTO_private_key_get_length (key)))
      set_handle_key (handle, key);
 
    struct GNUNET_MESSENGER_CreateMessage *msg;
    struct GNUNET_MQ_Envelope *env;
 
    env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_CREATE);
    GNUNET_MQ_send (handle->mq, env);
    return handle;
  }
  else
  {
    destroy_handle (handle);
    return NULL;
  }
}

References cfg, create_handle(), destroy_handle(), env, GNUNET_CRYPTO_private_key_get_length(), GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_CREATE, GNUNET_MQ_msg, GNUNET_MQ_send(), handle, key, GNUNET_VPN_Handle::mq, msg, GNUNET_MESSENGER_Handle::msg_callback, GNUNET_MESSENGER_Handle::msg_cls, name, reconnect(), set_handle_key(), and set_handle_name().

Referenced by on_ego_lookup(), run(), and start_service_run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_MESSENGER_disconnect()

void GNUNET_MESSENGER_disconnect ( struct GNUNET_MESSENGER_Handle * handle )

Disconnect all of the messengers used services and clears up its used memory.

Parameters

[in,out] handle Messenger handle to use

Definition at line 621 of file messenger_api.c.

{
  if (! handle)
    return;
 
  struct GNUNET_MESSENGER_DestroyMessage *msg;
  struct GNUNET_MQ_Envelope *env;
 
  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_DESTROY);
  GNUNET_MQ_send (handle->mq, env);
 
  destroy_handle (handle);
}

References destroy_handle(), env, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_DESTROY, GNUNET_MQ_msg, GNUNET_MQ_send(), handle, GNUNET_VPN_Handle::mq, and msg.

Referenced by shutdown_hook(), and stop_service_run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_MESSENGER_get_name()

const char * GNUNET_MESSENGER_get_name ( const struct GNUNET_MESSENGER_Handle * handle )

Get the name (if specified, otherwise NULL) used by the messenger.

Parameters

[in] handle Messenger handle to use

Returns: Name used by the messenger or NULL

Definition at line 764 of file messenger_api.c.

{
  if (! handle)
    return NULL;
 
  return get_handle_name (handle);
}

References get_handle_name(), and handle.

Referenced by on_identity(), and on_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_MESSENGER_set_name()

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.

Parameters

[in,out]	handle	Messenger handle to use
[in]	name	Name for the messenger to change to

Returns: GNUNET_YES on success, GNUNET_NO on failure and GNUNET_SYSERR if handle is NULL

Definition at line 799 of file messenger_api.c.

{
  if (! handle)
    return GNUNET_SYSERR;
 
  set_handle_name (handle, strlen (name) > 0 ? name : NULL);
  GNUNET_MESSENGER_find_rooms (handle, NULL, iterate_send_name_to_room, handle);
  return GNUNET_YES;
}

References GNUNET_MESSENGER_find_rooms(), GNUNET_SYSERR, GNUNET_YES, handle, iterate_send_name_to_room(), name, and set_handle_name().

Here is the call graph for this function:

◆ GNUNET_MESSENGER_get_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.

Parameters

[in] handle Messenger handle to use

Returns: Used public key or NULL

Definition at line 822 of file messenger_api.c.

{
  if (! handle)
    return NULL;
 
  return get_non_anonymous_key (get_handle_pubkey (handle));
}

References get_handle_pubkey(), get_non_anonymous_key(), and handle.

Here is the call graph for this function:

◆ GNUNET_MESSENGER_set_key()

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.

The currently used key will be replaced and the change will get signed accordingly to be verified by all contacts.

Parameters

[in,out]	handle	Messenger handle to use
[in]	key	Private key to change to or NULL

Returns: GNUNET_YES on success, GNUNET_NO on failure and GNUNET_SYSERR if handle is NULL

Definition at line 849 of file messenger_api.c.

{
  if (! handle)
    return GNUNET_SYSERR;
 
  if (! key)
  {
    GNUNET_MESSENGER_find_rooms (handle, NULL, iterate_send_key_to_room, NULL);
    set_handle_key (handle, NULL);
    return GNUNET_YES;
  }
 
  if (0 >= GNUNET_CRYPTO_private_key_get_length (key))
    return GNUNET_SYSERR;
 
  struct GNUNET_CRYPTO_PrivateKey priv;
  GNUNET_memcpy (&priv, key, sizeof (priv));
 
  GNUNET_MESSENGER_find_rooms (handle, NULL, iterate_send_key_to_room, &priv);
  set_handle_key (handle, &priv);
  return GNUNET_YES;
}

References GNUNET_CRYPTO_private_key_get_length(), GNUNET_memcpy, GNUNET_MESSENGER_find_rooms(), GNUNET_SYSERR, GNUNET_YES, handle, iterate_send_key_to_room(), key, and set_handle_key().

Here is the call graph for this function:

◆ GNUNET_MESSENGER_open_room()

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.

The room will use the specified key as port for the underlying cadet service. Opening a room results in opening the port for incoming connections as possible door.

Notice that there can only be one room related to a specific key. So trying to open two rooms with the same key will result in opening the room once but returning the handle both times because the room stays open.

You can also open a room after entering it through a door using GNUNET_MESSENGER_enter_room. This will notify all entered doors to list you as new door.

( All doors form a ring structured network to shorten the latency sending and receiving messages. )

Parameters

[in,out]	handle	Messenger handle to use
[in]	key	Hash identifying the port

Returns: Room handle, NULL on error

Definition at line 875 of file messenger_api.c.

{
  if ((! handle) || (! key))
    return NULL;
 
  struct GNUNET_MESSENGER_Room *room = GNUNET_CONTAINER_multihashmap_get (
    handle->rooms, key);
 
  if (! room)
  {
    room = create_room (handle, key);
 
    if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (handle->rooms, key,
                                                        room,
                                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
    {
      destroy_room (room);
      return NULL;
    }
  }
 
  send_open_room (handle, room);
  return room;
}

References create_room(), destroy_room(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_OK, handle, key, and send_open_room().

Referenced by join_room_run(), and on_identity().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_MESSENGER_enter_room()

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.

Notice that there can only be one room related to a specific key. So trying to enter two rooms with the same key will result in entering the room once but returning the handle both times because the room stays entered. You can however enter a room through multiple doors in parallel which results in connecting both ends. But entering the room through the same door won't have any effect after the first time.

You can also enter a room through a door after opening it using GNUNET_MESSENGER_open_room. But the door may not be your own peer identity.

( All doors form a ring structured network to shorten the latency sending and receiving messages. )

Parameters

[in,out]	handle	Messenger handle to use
[in]	door	Peer identity of an open door
[in]	key	Hash identifying the port

Returns: Room handle, NULL on error

Definition at line 903 of file messenger_api.c.

{
  if ((! handle) || (! door) || (! key))
    return NULL;
 
  struct GNUNET_MESSENGER_Room *room = GNUNET_CONTAINER_multihashmap_get (
    handle->rooms, key);
 
  if (! room)
  {
    room = create_room (handle, key);
 
    if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (handle->rooms, key,
                                                        room,
                                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
    {
      destroy_room (room);
      return NULL;
    }
  }
 
  send_enter_room (handle, room, door);
  return room;
}

References create_room(), destroy_room(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_OK, handle, key, and send_enter_room().

Referenced by join_room_run(), and on_identity().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_MESSENGER_close_room()

void GNUNET_MESSENGER_close_room ( struct GNUNET_MESSENGER_Room * room )

Close a room which was entered, opened or both in various order and variety.

Closing a room will destroy all connections from your peer to another and the other way around.

( After a member closes a door, all members entered through that specific door have to use another one or open the room on their own. )

Parameters

[in,out] room Room handle

Definition at line 932 of file messenger_api.c.

{
  if (! room)
    return;
 
  struct GNUNET_MESSENGER_Message *message = create_message_leave ();
 
  if (message)
    enqueue_message_to_room (room, message, NULL);
}

References create_message_leave(), and enqueue_message_to_room().

Referenced by shutdown_hook().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_MESSENGER_find_rooms()

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.

The callback will receive a room matching the condition and the given contact. The function returns the amount of rooms iterated with the given callback.

Parameters

[in]	handle	Messenger handle to use
[in]	contact	Contact handle
[in]	callback	Function called for each room
[in]	cls	Closure for the callback handler

Returns: Amount of rooms iterated

Definition at line 978 of file messenger_api.c.

{
  if (! handle)
    return GNUNET_SYSERR;
 
  struct GNUNET_MESSENGER_RoomFind find;
 
  find.contact = contact;
  find.callback = callback;
  find.counter = (contact? contact->rc : SIZE_MAX);
  find.cls = cls;
 
  return GNUNET_CONTAINER_multihashmap_iterate (handle->rooms,
                                                iterate_find_room, &find);
}

References GNUNET_MESSENGER_RoomFind::callback, GNUNET_MESSENGER_RoomFind::cls, GNUNET_MESSENGER_RoomFind::contact, GNUNET_MESSENGER_RoomFind::counter, GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_SYSERR, handle, iterate_find_room(), GNUNET_MESSENGER_Contact::rc, and SIZE_MAX.

Referenced by GNUNET_MESSENGER_set_key(), and GNUNET_MESSENGER_set_name().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_MESSENGER_room_get_key()

const struct GNUNET_HashCode * GNUNET_MESSENGER_room_get_key ( const struct GNUNET_MESSENGER_Room * room )

Get the key of a given room.

Parameters

[in] room Room handle

Returns: Hash identifying the port or NULL on failure

Definition at line 999 of file messenger_api.c.

{
  if (! room)
    return NULL;
 
  return &(room->key);
}

References GNUNET_MESSENGER_Room::key.

Referenced by on_message_cb().

Here is the caller graph for this function:

◆ GNUNET_MESSENGER_get_sender()

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.

Notice that contacts are independent of rooms but will be removed if all rooms containing these contacts get closed.

Parameters

[in]	room	Room handle
[in]	hash	Hash identifying a message

Returns: Contact handle, NULL otherwise

Definition at line 1009 of file messenger_api.c.

{
  if ((! room) || (! hash))
    return NULL;
 
  return get_room_sender (room, hash);
}

References get_room_sender().

Here is the call graph for this function:

◆ GNUNET_MESSENGER_get_recipient()

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.

Notice that contacts are independent of rooms but will be removed if all rooms containing these contacts get closed.

Parameters

[in]	room	Room handle
[in]	hash	Hash identifying a message

Returns: Contact handle, NULL otherwise

Definition at line 1020 of file messenger_api.c.

{
  if ((! room) || (! hash))
    return NULL;
 
  return get_room_recipient (room, hash);
}

References get_room_recipient().

Here is the call graph for this function:

◆ GNUNET_MESSENGER_contact_get_name()

const char * GNUNET_MESSENGER_contact_get_name ( const struct GNUNET_MESSENGER_Contact * contact )

Get the name used by the contact.

Parameters

[in] contact Contact handle

Returns: Name of contact or NULL

Definition at line 1031 of file messenger_api.c.

{
  if (! contact)
    return NULL;
 
  return get_contact_name (contact);
}

References get_contact_name().

Referenced by on_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_MESSENGER_contact_get_key()

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.

Parameters

[in] contact Contact handle

Returns: Public key used by contact or NULL

Definition at line 1042 of file messenger_api.c.

{
  if (! contact)
    return NULL;
 
  return get_non_anonymous_key (get_contact_key (contact));
}

References get_contact_key(), and get_non_anonymous_key().

Referenced by iterate_send_private_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_MESSENGER_contact_get_id()

size_t GNUNET_MESSENGER_contact_get_id ( const struct GNUNET_MESSENGER_Contact * contact )

Get the locally unique id of the contact.

Parameters

[in] contact Contact handle

Returns: Locally unique contact id or zero

Definition at line 1053 of file messenger_api.c.

{
  if (! contact)
    return 0;
 
  return get_contact_id (contact);
}

References get_contact_id().

Here is the call graph for this function:

◆ GNUNET_MESSENGER_send_message()

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.

If you opened the room all entered members will receive the message. If you entered the room through a door all so entered doors will receive the message as well. All members receiving the message will also propagate this message recursively as long as the message is unknown to them.

Notice that all messages sent and received are also stored and can be propagated to new members entering the room.

If you provide a specific contact as receiver of the given message, the message will automatically be encrypted and sent as a private message (see GNUNET_MESSENGER_MessagePrivate). Therefore the selected contact will be the only member receiving the actual message.

Sending a message to all members in a given room can be done by providing NULL as contact.

Parameters

[in,out]	room	Room handle
[in,out]	message	New message to send
[in]	contact	Contact or NULL

Definition at line 1119 of file messenger_api.c.

{
  if ((! room) || (! message))
    return;
 
  switch (filter_message_sending (message))
  {
  case GNUNET_SYSERR:
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Sending message aborted: This kind of message is reserved for the service!\n");
    return;
  case GNUNET_NO:
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Sending message aborted: This kind of message could cause issues!\n");
    return;
  default:
    break;
  }
 
  const struct GNUNET_CRYPTO_PublicKey *public_key;
 
  if (contact)
  {
    public_key = get_non_anonymous_key (
      get_contact_key (contact)
      );
 
    if (! public_key)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Sending message aborted: Invalid key!\n");
      return;
    }
  }
  else
    public_key = NULL;
 
  send_message_to_room_with_key (room, copy_message (message), public_key);
}

References copy_message(), filter_message_sending(), get_contact_key(), get_non_anonymous_key(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_NO, GNUNET_SYSERR, and send_message_to_room_with_key().

Referenced by iterate_send_private_message(), on_message(), and read_stdio().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_MESSENGER_delete_message()

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.

A deletion will be propagated to all members of the room as with any other sent message. Notice that a deletion will only request other members of the room to delete the selected message. If you are not permitted to delete the message, the deletion will be ignored.

Depending on the implementation other clients may also ignore your deletion request in other circumstances.

Parameters

[in,out]	room	Room handle
[in]	message	Message to delete
[in]	delay	Delay to delete the message

Definition at line 1182 of file messenger_api.c.

{
  if ((! room) || (! hash))
    return;
 
  delete_message_in_room (room, hash, delay);
}

References delete_message_in_room().

Here is the call graph for this function:

◆ GNUNET_MESSENGER_get_message()

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.

Parameters

[in]	room	Room handle
[in]	hash	Hash identifying a message

Returns: Message struct or NULL if no message with that hash is known

Definition at line 1194 of file messenger_api.c.

{
  if ((! room) || (! hash))
    return NULL;
 
  const struct GNUNET_MESSENGER_Message *message = get_room_message (room,
                                                                     hash);
 
  if (! message)
  {
    struct GNUNET_MESSENGER_GetMessage *msg;
    struct GNUNET_MQ_Envelope *env;
 
    env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_GET_MESSAGE);
    GNUNET_memcpy (&(msg->key), &(room->key), sizeof(msg->key));
    GNUNET_memcpy (&(msg->hash), hash, sizeof(*hash));
    GNUNET_MQ_send (room->handle->mq, env);
  }
 
  return message;
}

References env, get_room_message(), GNUNET_memcpy, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_GET_MESSAGE, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_MESSENGER_Room::handle, GNUNET_MESSENGER_Room::key, GNUNET_MESSENGER_Handle::mq, and msg.

Here is the call graph for this function:

◆ GNUNET_MESSENGER_iterate_members()

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.

The callback will receive the contact of each member. The function returns the amount of members iterated with the given callback.

Parameters

[in]	room	Room handle
[in]	callback	Function called for each member
[in]	cls	Closure for the callback handler

Returns: Amount of members iterated

Definition at line 1219 of file messenger_api.c.

{
  if (! room)
    return GNUNET_SYSERR;
 
  return iterate_room_members (room, callback, cls);
}

References GNUNET_SYSERR, and iterate_room_members().

Referenced by read_stdio().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GNUNET_MESSENGER_send_ticket()

void GNUNET_MESSENGER_send_ticket	(	struct GNUNET_MESSENGER_Room *	room,
		const struct GNUNET_RECLAIM_Ticket *	ticket
	)

Send a ticket into a room.

The ticket will automatically be converted into a message to be sent only to its audience as a private message.

A ticket can only be sent with this function if its issuer's public key is the one being used by the messenger. The audience's public key is not allowed to be the anonymous public key. The room needs to contain a member using the audience's public key.

Parameters

[in,out]	room	Room handle
[in]	ticket	Ticket to send

Definition at line 1258 of file messenger_api.c.

{
  if ((! room) || (! ticket))
    return;
 
  const struct GNUNET_CRYPTO_PublicKey *pubkey;
  pubkey = get_handle_pubkey (room->handle);
 
  if (0 != GNUNET_memcmp (pubkey, &(ticket->identity)))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Sending ticket aborted: Invalid identity!\n");
    return;
  }
 
  struct GNUNET_MESSENGER_CheckTicket check;
  check.audience = &(ticket->audience);
  check.result = GNUNET_NO;
 
  const int members = iterate_room_members (
    room,
    check_ticket_audience,
    &check);
 
  if ((! members) || (GNUNET_YES != check.result))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Sending ticket aborted: Audience not found!\n");
    return;
  }
 
  struct GNUNET_MESSENGER_Message *message = create_message_ticket (
    &(ticket->rnd)
    );
 
  if (! message)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Sending ticket aborted: Message creation failed!\n");
    return;
  }
 
  send_message_to_room_with_key (room, message, &(ticket->audience));
}

References GNUNET_RECLAIM_Ticket::audience, GNUNET_MESSENGER_CheckTicket::audience, check_ticket_audience(), create_message_ticket(), get_handle_pubkey(), GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_memcmp, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_Room::handle, GNUNET_RECLAIM_Ticket::identity, iterate_room_members(), pubkey, GNUNET_MESSENGER_CheckTicket::result, GNUNET_RECLAIM_Ticket::rnd, send_message_to_room_with_key(), and ticket.

Here is the call graph for this function:

Data Structures

Macros

Typedefs

Enumerations

Functions

Detailed Description

Macro Definition Documentation

◆ GNUNET_MESSENGER_VERSION

◆ GNUNET_MESSENGER_SERVICE_NAME

◆ GNUNET_MESSENGER_KIND_MAX

Typedef Documentation

◆ GNUNET_MESSENGER_MessageCallback

◆ GNUNET_MESSENGER_MemberCallback

Enumeration Type Documentation

◆ GNUNET_MESSENGER_MessageKind

◆ GNUNET_MESSENGER_MessageFlags

◆ GNUNET_MESSENGER_ConnectionFlags

Function Documentation

◆ GNUNET_MESSENGER_name_of_kind()

◆ GNUNET_MESSENGER_connect()

◆ GNUNET_MESSENGER_disconnect()

◆ GNUNET_MESSENGER_get_name()

◆ GNUNET_MESSENGER_set_name()

◆ GNUNET_MESSENGER_get_key()

◆ GNUNET_MESSENGER_set_key()

◆ GNUNET_MESSENGER_open_room()

◆ GNUNET_MESSENGER_enter_room()

◆ GNUNET_MESSENGER_close_room()

◆ GNUNET_MESSENGER_find_rooms()

◆ GNUNET_MESSENGER_room_get_key()

◆ GNUNET_MESSENGER_get_sender()

◆ GNUNET_MESSENGER_get_recipient()

◆ GNUNET_MESSENGER_contact_get_name()

◆ GNUNET_MESSENGER_contact_get_key()

◆ GNUNET_MESSENGER_contact_get_id()

◆ GNUNET_MESSENGER_send_message()

◆ GNUNET_MESSENGER_delete_message()

◆ GNUNET_MESSENGER_get_message()

◆ GNUNET_MESSENGER_iterate_members()

◆ GNUNET_MESSENGER_send_ticket()