MESSENGER service

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_MessageBody
	The unified body of a GNUNET_MESSENGER_Message. More...
struct	GNUNET_MESSENGER_Message
	Struct to a message. More...

Macros
#define	GNUNET_MESSENGER_VERSION   0x00000001
	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_IdentityCallback) (void *cls, struct GNUNET_MESSENGER_Handle *handle)
	Method called whenever the EGO of a handle changes or if the first connection fails to load a valid EGO and the anonymous key pair will be used instead. More...
typedef void(*	GNUNET_MESSENGER_MessageCallback) (void *cls, struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Contact *sender, 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 int(*	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_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 }
	Enum for the different supported flags used by message handling Compatible flags can be OR'ed together. 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, GNUNET_MESSENGER_IdentityCallback identity_callback, void *identity_cls, GNUNET_MESSENGER_MessageCallback msg_callback, void *msg_cls)
	Set up a handle for the messenger related functions and connects to all necessary services. More...
int	GNUNET_MESSENGER_update (struct GNUNET_MESSENGER_Handle *handle)
	Update a handle of the messenger to use a different ego key and replace the old one with a newly generated one. 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...
int	GNUNET_MESSENGER_set_name (struct GNUNET_MESSENGER_Handle *handle, const char *name)
	Set the name for the messenger. More...
const struct GNUNET_IDENTITY_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...
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 char *	GNUNET_MESSENGER_contact_get_name (const struct GNUNET_MESSENGER_Contact *contact)
	Get the name used by the contact. More...
const struct GNUNET_IDENTITY_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...
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...
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...

Detailed Description

Instant messaging based on the CADET subsystem.

Macro Definition Documentation

GNUNET_MESSENGER_VERSION

#define GNUNET_MESSENGER_VERSION   0x00000001

Version number of GNUnet Messenger API.

Current version of the Messenger: 0.1

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 206 of file gnunet_messenger_service.h.

Typedef Documentation

GNUNET_MESSENGER_IdentityCallback

typedef void(* GNUNET_MESSENGER_IdentityCallback) (void *cls, struct GNUNET_MESSENGER_Handle *handle)

Method called whenever the EGO of a handle changes or if the first connection fails to load a valid EGO and the anonymous key pair will be used instead.

Parameters

[in/out]	cls Closure from GNUNET_MESSENGER_connect
[in/out]	handle Messenger handle

Definition at line 571 of file gnunet_messenger_service.h.

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_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]	message	Newly received or sent message
[in]	hash	Hash identifying the message
[in]	flags	Flags of the message

Definition at line 588 of file gnunet_messenger_service.h.

GNUNET_MESSENGER_MemberCallback

typedef int(* 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 604 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_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_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.

Definition at line 546 of file gnunet_messenger_service.h.

{
  GNUNET_MESSENGER_FLAG_NONE = 0,
 
  GNUNET_MESSENGER_FLAG_SENT = 1,
 
  GNUNET_MESSENGER_FLAG_PRIVATE = 2,
};

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 35 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";
  default:
    return "UNKNOWN";
  }
}

References GNUNET_MESSENGER_KIND_DELETE, GNUNET_MESSENGER_KIND_FILE, GNUNET_MESSENGER_KIND_ID, GNUNET_MESSENGER_KIND_INFO, GNUNET_MESSENGER_KIND_INVITE, GNUNET_MESSENGER_KIND_JOIN, GNUNET_MESSENGER_KIND_KEY, GNUNET_MESSENGER_KIND_LEAVE, GNUNET_MESSENGER_KIND_MERGE, GNUNET_MESSENGER_KIND_MISS, GNUNET_MESSENGER_KIND_NAME, GNUNET_MESSENGER_KIND_PEER, GNUNET_MESSENGER_KIND_PRIVATE, GNUNET_MESSENGER_KIND_REQUEST, and GNUNET_MESSENGER_KIND_TEXT.

Referenced by callback_verify_room_message(), handle_recv_message(), handle_send_message(), handle_tunnel_message(), and on_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,
		GNUNET_MESSENGER_IdentityCallback	identity_callback,
		void *	identity_cls,
		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 look up the ego key identified by its name and use it for signing all messages from the handle.

Parameters

[in]	cfg	Configuration to use
[in]	name	Name to look up an ego or NULL to stay anonymous
[in]	identity_callback	Function called when the EGO of the handle changes
[in,out]	identity_cls	Closure for the identity_callback handler
[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 436 of file messenger_api.c.

{
  struct GNUNET_MESSENGER_Handle *handle = create_handle (cfg, identity_callback, identity_cls, msg_callback, msg_cls);
 
  reconnect (handle);
 
  if (handle->mq)
  {
    const uint16_t name_len = name ? strlen (name) : 0;
 
    struct GNUNET_MESSENGER_CreateMessage *msg;
    struct GNUNET_MQ_Envelope *env;
 
    env = GNUNET_MQ_msg_extra(msg, name_len + 1, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_CREATE);
 
    char *extra = ((char*) msg) + sizeof(*msg);
 
    if (name_len)
      GNUNET_memcpy(extra, name, name_len);
 
    extra[name_len] = '\0';
 
    GNUNET_MQ_send (handle->mq, env);
    return handle;
  }
  else
  {
    destroy_handle (handle);
    return NULL;
  }
}

References cfg, create_handle(), destroy_handle(), env, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_CREATE, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), handle, GNUNET_MESSENGER_Handle::identity_callback, GNUNET_MESSENGER_Handle::identity_cls, GNUNET_DNS_Handle::mq, msg, GNUNET_MESSENGER_Handle::msg_callback, GNUNET_MESSENGER_Handle::msg_cls, name, and reconnect().

Referenced by on_peer(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_MESSENGER_update()

int GNUNET_MESSENGER_update

(

struct GNUNET_MESSENGER_Handle *

handle

)

Update a handle of the messenger to use a different ego key and replace the old one with a newly generated one.

All participated rooms get informed about the key renewal. The handle requires a set name for this function to work and it needs to be unused by other egos.

Keep in mind that this will fully delete the old ego key (if any is used) even if any other service wants to use it as default.

Parameters

[in,out]

handle

Messenger handle to use

Returns

GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 474 of file messenger_api.c.

{
  if ((!handle) || (!get_handle_name (handle)))
    return GNUNET_SYSERR;
 
  struct GNUNET_MESSENGER_UpdateMessage *msg;
  struct GNUNET_MQ_Envelope *env;
 
  env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_UPDATE);
  GNUNET_MQ_send (handle->mq, env);
  return GNUNET_OK;
}

References env, get_handle_name(), GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_UPDATE, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_OK, GNUNET_SYSERR, handle, GNUNET_DNS_Handle::mq, and msg.

Here is the call 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 488 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_DNS_Handle::mq, and msg.

Referenced by shutdown_cb(), and shutdown_hook().

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 503 of file messenger_api.c.

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

References get_handle_name(), and handle.

Referenced by on_identity().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_MESSENGER_set_name()

int GNUNET_MESSENGER_set_name	(	struct GNUNET_MESSENGER_Handle *	handle,
		const char *	name
	)

Set the name for the messenger.

This will rename the currently used ego and move all stored files related to the current name to its new directory. If anything fails during this process the function returns GNUNET_NO and the name for the messenger won't change as specified.

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 512 of file messenger_api.c.

{
  if (!handle)
    return GNUNET_SYSERR;
 
  const uint16_t name_len = name ? strlen (name) : 0;
 
  struct GNUNET_MESSENGER_NameMessage *msg;
  struct GNUNET_MQ_Envelope *env;
 
  env = GNUNET_MQ_msg_extra(msg, name_len + 1, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_SET_NAME);
 
  char *extra = ((char*) msg) + sizeof(*msg);
 
  if (name_len)
    GNUNET_memcpy(extra, name, name_len);
 
  extra[name_len] = '\0';
 
  GNUNET_MQ_send (handle->mq, env);
  return GNUNET_YES;
}

References env, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_SET_NAME, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_SYSERR, GNUNET_YES, handle, GNUNET_DNS_Handle::mq, msg, and name.

Here is the call graph for this function:

GNUNET_MESSENGER_get_key()

const struct GNUNET_IDENTITY_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 ego's public key or NULL

Definition at line 546 of file messenger_api.c.

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

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

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 555 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 on_identity(), on_peer(), and second_stage().

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 580 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 barrier_wait_cb(), on_identity(), and second_stage().

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 606 of file messenger_api.c.

{
  if (!room)
    return;
 
  send_close_room (room->handle, room);
}

References GNUNET_MESSENGER_Room::handle, and send_close_room().

Referenced by shutdown_cb(), and 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 644 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.

Here is the call 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 663 of file messenger_api.c.

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

References GNUNET_MESSENGER_Room::key.

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 672 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_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 682 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_IDENTITY_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 of the ego used by contact or NULL

Definition at line 691 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_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]	message	New message to send
[in]	contact	Contact or NULL

Definition at line 700 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;
  }
 
  ssize_t key_length = 0;
 
  if (contact)
  {
    const struct GNUNET_IDENTITY_PublicKey *public_key = get_non_anonymous_key (
        get_contact_key(contact)
    );
 
    if (public_key)
      key_length = GNUNET_IDENTITY_public_key_get_length(public_key);
    else
      key_length = -1;
  }
 
  if (key_length < 0)
  {
    GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Sending message aborted: Invalid key!\n");
    return;
  }
 
  const uint16_t msg_length = get_message_size (message, GNUNET_NO);
 
  struct GNUNET_MESSENGER_SendMessage *msg;
  struct GNUNET_MQ_Envelope *env;
 
  const uint16_t length = (uint16_t) key_length + msg_length;
 
  env = GNUNET_MQ_msg_extra(
      msg, length,
      GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_SEND_MESSAGE
  );
 
  GNUNET_memcpy(&(msg->key), &(room->key), sizeof(msg->key));
 
  msg->flags = (uint32_t) (
      contact? GNUNET_MESSENGER_FLAG_PRIVATE : GNUNET_MESSENGER_FLAG_NONE
  );
 
  char *buffer = ((char*) msg) + sizeof(*msg);
  char *msg_buffer = buffer + key_length;
 
  if (key_length > 0)
    GNUNET_IDENTITY_write_public_key_to_buffer(get_contact_key(contact), buffer, key_length);
 
  encode_message (message, msg_length, msg_buffer, GNUNET_NO);
 
  GNUNET_MQ_send (room->handle->mq, env);
}

References encode_message(), env, filter_message_sending(), get_contact_key(), get_message_size(), get_non_anonymous_key(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_IDENTITY_public_key_get_length(), GNUNET_IDENTITY_write_public_key_to_buffer(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_SEND_MESSAGE, GNUNET_MESSENGER_FLAG_NONE, GNUNET_MESSENGER_FLAG_PRIVATE, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_SYSERR, GNUNET_MESSENGER_Room::handle, GNUNET_MESSENGER_Room::key, GNUNET_MESSENGER_Handle::mq, and msg.

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

Here is the call graph for this function:

Here is the caller 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 769 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 792 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 end_cb(), and read_stdio().

Here is the call graph for this function:

Here is the caller graph for this function: