MESSENGER service

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

Data Structures
struct	GNUNET_MESSENGER_RoomKeyCode
	A room key code specifies an identifier of a room and its individual properties. More...
union	GNUNET_MESSENGER_RoomKey
	A room key unifies a room key code and its 512bit hash representation. More...
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_EpochIdentifierCode
	An epoch identifier code specifies an epoch or group key inside a room and it provides the information about its group size. More...
union	GNUNET_MESSENGER_EpochIdentifier
	An epoch identifier unifies an epoch identifier code and its 256bit hash representation. More...
struct	GNUNET_MESSENGER_RoomEpochKeyRecord
	A room epoch key record specifies an epoch key for a given room that can be identified via a given key to enter it and an epoch identifier. More...
struct	GNUNET_MESSENGER_EpochNonceData
	Struct to store a unique epoch nonce for message data encryption. More...
union	GNUNET_MESSENGER_EpochNonce
	An epoch nonce unifies the epoch nonce data and its 256bit hash representation. More...
struct	GNUNET_MESSENGER_EncryptionKeyRecord
	An encryption key record specifies an encryption key for a given room that can be identified via a given key to enter it. 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_MessageDeletion
	A deletion 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_MessageSubscribtion
	A subscription message body This allows subscribing to a discourse. More...
struct	GNUNET_MESSENGER_MessageTalk
	A talk message body This allows talking in a discourse. More...
struct	GNUNET_MESSENGER_MessageAnnouncement
	An announcement message body This allows announcing group and epoch keys. More...
struct	GNUNET_MESSENGER_MessageSecret
	A secret message body This allows exchanging encrypted messages. More...
struct	GNUNET_MESSENGER_MessageAppeal
	An appeal message body This allows appealing to receive an epoch key. More...
struct	GNUNET_MESSENGER_MessageAccess
	An access message body This allows providing access to a group or an epoch key using a public key. More...
struct	GNUNET_MESSENGER_MessageRevolution
	A revolution message body This allows revolutionizing a group or epoch. More...
struct	GNUNET_MESSENGER_MessageGroup
	A group message body This allows forming an epoch group. More...
struct	GNUNET_MESSENGER_MessageAuthorization
	An authorization message body This allows providing access to a group or an epoch key using an established shared key. 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   0x00000007
	Version number of GNUnet Messenger API.
#define	GNUNET_MESSENGER_SERVICE_NAME   "messenger"
	Identifier of GNUnet MESSENGER Service.
#define	GNUNET_MESSENGER_EPOCH_NONCE_BYTES    sizeof (struct GNUNET_ShortHashCode)
#define	GNUNET_MESSENGER_ENCRYPTION_KEY_NONCE_BYTES    (sizeof (struct GNUNET_ShortHashCode))
#define	GNUNET_MESSENGER_ENCRYPTION_KEY_DATA_BYTES    (sizeof (uint32_t) + 4096 / 8)
#define	GNUNET_MESSENGER_KIND_MAX   (GNUNET_MESSENGER_KIND_TALK)
#define	GNUNET_MESSENGER_SECRET_IV_BYTES    sizeof (struct GNUNET_CRYPTO_SymmetricInitializationVector)
#define	GNUNET_MESSENGER_ACCESS_KEY_BYTES
#define	GNUNET_MESSENGER_AUTHORIZATION_KEY_BYTES    sizeof (struct GNUNET_CRYPTO_SymmetricSessionKey)

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

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_DELETION = 15 , GNUNET_MESSENGER_KIND_CONNECTION = 16 ,   GNUNET_MESSENGER_KIND_TICKET = 17 , GNUNET_MESSENGER_KIND_TRANSCRIPT = 18 , GNUNET_MESSENGER_KIND_TAG = 19 , GNUNET_MESSENGER_KIND_SUBSCRIBTION = 20 ,   GNUNET_MESSENGER_KIND_TALK = 21 , GNUNET_MESSENGER_KIND_ANNOUNCEMENT = 22 , GNUNET_MESSENGER_KIND_SECRET = 23 , GNUNET_MESSENGER_KIND_APPEAL = 24 ,   GNUNET_MESSENGER_KIND_ACCESS = 25 , GNUNET_MESSENGER_KIND_REVOLUTION = 26 , GNUNET_MESSENGER_KIND_GROUP = 27 , GNUNET_MESSENGER_KIND_AUTHORIZATION = 28 ,   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 , GNUNET_MESSENGER_FLAG_SECRET = 64 ,   GNUNET_MESSENGER_FLAG_MEMBER = 128 }
	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...
enum	GNUNET_MESSENGER_SubscriptionFlags { GNUNET_MESSENGER_FLAG_SUBSCRIPTION_NONE = 0 , GNUNET_MESSENGER_FLAG_SUBSCRIPTION_UNSUBSCRIBE = 1 , GNUNET_MESSENGER_FLAG_SUBSCRIPTION_KEEP_ALIVE = 2 }
	Enum for the different supported flags used to specify subscription handling. More...
enum	GNUNET_MESSENGER_EpochFlags { GNUNET_MESSENGER_FLAG_EPOCH_NONE = 0 , GNUNET_MESSENGER_FLAG_EPOCH_VALID = 1 }

Functions
const char *	GNUNET_MESSENGER_name_of_kind (enum GNUNET_MESSENGER_MessageKind kind)
	Get the name of a message kind.
void	GNUNET_MESSENGER_create_room_key (union GNUNET_MESSENGER_RoomKey *key, const char *input, enum GNUNET_GenericReturnValue is_public, enum GNUNET_GenericReturnValue is_group, enum GNUNET_GenericReturnValue is_feed)
	Creates a room key from given optional input string using certain properties for this targeted room.
struct GNUNET_MESSENGER_Handle *	GNUNET_MESSENGER_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *name, const struct GNUNET_CRYPTO_BlindablePrivateKey *key, const struct GNUNET_HashCode *secret, GNUNET_MESSENGER_MessageCallback msg_callback, void *msg_cls)
	Set up a handle for the messenger related functions and connects to all necessary services.
void	GNUNET_MESSENGER_disconnect (struct GNUNET_MESSENGER_Handle *handle)
	Disconnect all of the messengers used services and clears up its used memory.
const char *	GNUNET_MESSENGER_get_name (const struct GNUNET_MESSENGER_Handle *handle)
	Get the name (if specified, otherwise NULL) used by the messenger.
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.
const struct GNUNET_CRYPTO_BlindablePublicKey *	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.
enum GNUNET_GenericReturnValue	GNUNET_MESSENGER_set_key (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_CRYPTO_BlindablePrivateKey *key)
	Set the private key used by the messenger or NULL if the anonymous key should be used instead.
struct GNUNET_MESSENGER_Room *	GNUNET_MESSENGER_open_room (struct GNUNET_MESSENGER_Handle *handle, const union GNUNET_MESSENGER_RoomKey *key)
	Open a room to send and receive messages.
struct GNUNET_MESSENGER_Room *	GNUNET_MESSENGER_enter_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_PeerIdentity *door, const union GNUNET_MESSENGER_RoomKey *key)
	Enter a room to send and receive messages through a door opened using GNUNET_MESSENGER_open_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.
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.
const struct GNUNET_HashCode *	GNUNET_MESSENGER_room_get_key (const struct GNUNET_MESSENGER_Room *room)
	Get the key of a given room.
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.
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.
const char *	GNUNET_MESSENGER_contact_get_name (const struct GNUNET_MESSENGER_Contact *contact)
	Get the name used by the contact.
const struct GNUNET_CRYPTO_BlindablePublicKey *	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.
size_t	GNUNET_MESSENGER_contact_get_id (const struct GNUNET_MESSENGER_Contact *contact)
	Get the locally unique id of the contact.
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.
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.
const struct GNUNET_MESSENGER_Message *	GNUNET_MESSENGER_get_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash)
	Get the message in a room identified by its hash and requests it if necessary.
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.

Detailed Description

Instant messaging based on the CADET subsystem.

Macro Definition Documentation

GNUNET_MESSENGER_VERSION

#define GNUNET_MESSENGER_VERSION   0x00000007

Version number of GNUnet Messenger API.

Current version of the Messenger: 0.7

Definition at line 49 of file gnunet_messenger_service.h.

GNUNET_MESSENGER_SERVICE_NAME

#define GNUNET_MESSENGER_SERVICE_NAME   "messenger"

Identifier of GNUnet MESSENGER Service.

Definition at line 54 of file gnunet_messenger_service.h.

GNUNET_MESSENGER_EPOCH_NONCE_BYTES

#define GNUNET_MESSENGER_EPOCH_NONCE_BYTES    sizeof (struct GNUNET_ShortHashCode)

Definition at line 203 of file gnunet_messenger_service.h.

{
  uint8_t nonce[GNUNET_MESSENGER_EPOCH_NONCE_BYTES];
};
 
union GNUNET_MESSENGER_EpochNonce
{
  struct GNUNET_ShortHashCode hash;
  struct GNUNET_MESSENGER_EpochNonceData data;
};
 
#define GNUNET_MESSENGER_ENCRYPTION_KEY_NONCE_BYTES \
        (sizeof (struct GNUNET_ShortHashCode))
#define GNUNET_MESSENGER_ENCRYPTION_KEY_DATA_BYTES \
        (sizeof (uint32_t) + 4096 / 8)
 
struct GNUNET_MESSENGER_EncryptionKeyRecord
{
  struct GNUNET_HashCode key GNUNET_PACKED;
 
  uint8_t nonce_data[GNUNET_MESSENGER_ENCRYPTION_KEY_NONCE_BYTES];
 
  uint32_t encrypted_key_length;
 
  int32_t encrypted_key_checksum;
 
  uint8_t encrypted_key_data[GNUNET_MESSENGER_ENCRYPTION_KEY_DATA_BYTES];
};
 
GNUNET_NETWORK_STRUCT_END
 
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_DELETION = 15,
 
  GNUNET_MESSENGER_KIND_CONNECTION = 16,
 
  GNUNET_MESSENGER_KIND_TICKET = 17,
 
  GNUNET_MESSENGER_KIND_TRANSCRIPT = 18,
 
  GNUNET_MESSENGER_KIND_TAG = 19,
 
  GNUNET_MESSENGER_KIND_SUBSCRIBTION = 20,
 
  GNUNET_MESSENGER_KIND_TALK = 21,
 
  GNUNET_MESSENGER_KIND_ANNOUNCEMENT = 22,
 
  GNUNET_MESSENGER_KIND_SECRET = 23,
 
  GNUNET_MESSENGER_KIND_APPEAL = 24,
 
  GNUNET_MESSENGER_KIND_ACCESS = 25,
 
  GNUNET_MESSENGER_KIND_REVOLUTION = 26,
 
  GNUNET_MESSENGER_KIND_GROUP = 27,
 
  GNUNET_MESSENGER_KIND_AUTHORIZATION = 28,
 
  GNUNET_MESSENGER_KIND_UNKNOWN = 0
};
 
#define GNUNET_MESSENGER_KIND_MAX (GNUNET_MESSENGER_KIND_TALK)
 
const char*
GNUNET_MESSENGER_name_of_kind (enum GNUNET_MESSENGER_MessageKind kind);
 
void
GNUNET_MESSENGER_create_room_key (union GNUNET_MESSENGER_RoomKey *key,
                                  const char *input,
                                  enum GNUNET_GenericReturnValue is_public,
                                  enum GNUNET_GenericReturnValue is_group,
                                  enum GNUNET_GenericReturnValue is_feed);
 
struct GNUNET_MESSENGER_MessageHeader
{
  struct GNUNET_CRYPTO_BlindableKeySignature signature;
 
  struct GNUNET_TIME_AbsoluteNBO timestamp;
 
  struct GNUNET_ShortHashCode sender_id;
 
  struct GNUNET_HashCode previous;
 
  enum GNUNET_MESSENGER_MessageKind kind;
};
 
struct GNUNET_MESSENGER_MessageInfo
{
  uint32_t messenger_version;
};
 
struct GNUNET_MESSENGER_MessageJoin
{
  struct GNUNET_HashCode epoch;
 
  struct GNUNET_CRYPTO_BlindablePublicKey key;
 
  struct GNUNET_CRYPTO_HpkePublicKey hpke_key;
};
 
struct GNUNET_MESSENGER_MessageLeave
{
  struct GNUNET_HashCode epoch;
};
 
struct GNUNET_MESSENGER_MessageName
{
  char *name;
};
 
struct GNUNET_MESSENGER_MessageKey
{
  struct GNUNET_CRYPTO_BlindablePublicKey key;
 
  struct GNUNET_CRYPTO_HpkePublicKey hpke_key;
};
 
struct GNUNET_MESSENGER_MessagePeer
{
  struct GNUNET_PeerIdentity peer;
};
 
struct GNUNET_MESSENGER_MessageId
{
  struct GNUNET_ShortHashCode id;
};
 
struct GNUNET_MESSENGER_MessageMiss
{
  struct GNUNET_PeerIdentity peer;
};
 
struct GNUNET_MESSENGER_MessageMerge
{
  struct GNUNET_HashCode epochs[2];
 
  struct GNUNET_HashCode previous;
};
 
struct GNUNET_MESSENGER_MessageRequest
{
  struct GNUNET_HashCode hash;
};
 
struct GNUNET_MESSENGER_MessageInvite
{
  struct GNUNET_PeerIdentity door;
 
  union GNUNET_MESSENGER_RoomKey key;
};
 
struct GNUNET_MESSENGER_MessageText
{
  char *text;
};
 
struct GNUNET_MESSENGER_MessageFile
{
  struct GNUNET_CRYPTO_SymmetricSessionKey key;
 
  struct GNUNET_HashCode hash;
 
  char name[NAME_MAX];
 
  char *uri;
};
 
struct GNUNET_MESSENGER_MessagePrivate
{
  uint16_t length;
 
  char *data;
};
 
struct GNUNET_MESSENGER_MessageDeletion
{
  struct GNUNET_HashCode hash;
 
  struct GNUNET_TIME_RelativeNBO delay;
};
 
struct GNUNET_MESSENGER_MessageConnection
{
  uint32_t amount;
 
  uint32_t flags;
};
 
struct GNUNET_MESSENGER_MessageTicket
{
  char *identifier;
};
 
struct GNUNET_MESSENGER_MessageTranscript
{
  struct GNUNET_HashCode hash;
 
  struct GNUNET_CRYPTO_BlindablePublicKey key;
 
  uint16_t length;
 
  char *data;
};
 
struct GNUNET_MESSENGER_MessageTag
{
  struct GNUNET_HashCode hash;
 
  char *tag;
};
 
struct GNUNET_MESSENGER_MessageSubscribtion
{
  struct GNUNET_ShortHashCode discourse;
 
  struct GNUNET_TIME_RelativeNBO time;
 
  uint32_t flags;
};
 
struct GNUNET_MESSENGER_MessageTalk
{
  struct GNUNET_ShortHashCode discourse;
 
  uint16_t length;
 
  char *data;
};
 
struct GNUNET_MESSENGER_MessageAnnouncement
{
  union GNUNET_MESSENGER_EpochIdentifier identifier;
 
  struct GNUNET_CRYPTO_EcdhePublicKey key;
 
  union GNUNET_MESSENGER_EpochNonce nonce;
 
  struct GNUNET_TIME_RelativeNBO timeout;
 
  struct GNUNET_HashCode hmac;
};
 
#define GNUNET_MESSENGER_SECRET_IV_BYTES \
        sizeof (struct GNUNET_CRYPTO_SymmetricInitializationVector)
 
struct GNUNET_MESSENGER_MessageSecret
{
  union GNUNET_MESSENGER_EpochIdentifier identifier;
 
  uint8_t iv[GNUNET_MESSENGER_SECRET_IV_BYTES];
 
  struct GNUNET_HashCode hmac;
 
  uint16_t length;
 
  char *data;
};
 
struct GNUNET_MESSENGER_MessageAppeal
{
  struct GNUNET_HashCode event;
 
  struct GNUNET_CRYPTO_EcdhePublicKey key;
 
  struct GNUNET_TIME_RelativeNBO timeout;
};
 
#define GNUNET_MESSENGER_ACCESS_KEY_BYTES \
        sizeof (struct GNUNET_CRYPTO_SymmetricSessionKey) + \
        GNUNET_CRYPTO_HPKE_SEAL_ONESHOT_OVERHEAD_BYTES
 
struct GNUNET_MESSENGER_MessageAccess
{
  struct GNUNET_HashCode event;
 
  uint8_t key[GNUNET_MESSENGER_ACCESS_KEY_BYTES];
 
  struct GNUNET_HashCode hmac;
};
 
struct GNUNET_MESSENGER_MessageRevolution
{
  union GNUNET_MESSENGER_EpochIdentifier identifier;
 
  union GNUNET_MESSENGER_EpochNonce nonce;
 
  struct GNUNET_HashCode hmac;
};
 
struct GNUNET_MESSENGER_MessageGroup
{
  union GNUNET_MESSENGER_EpochIdentifier identifier;
 
  struct GNUNET_HashCode initiator;
 
  struct GNUNET_HashCode partner;
 
  struct GNUNET_TIME_RelativeNBO timeout;
};
 
#define GNUNET_MESSENGER_AUTHORIZATION_KEY_BYTES \
        sizeof (struct GNUNET_CRYPTO_SymmetricSessionKey)
 
struct GNUNET_MESSENGER_MessageAuthorization
{
  union GNUNET_MESSENGER_EpochIdentifier identifier;
 
  struct GNUNET_HashCode event;
 
  uint8_t key[GNUNET_MESSENGER_AUTHORIZATION_KEY_BYTES];
 
  struct GNUNET_HashCode hmac;
};
 
struct GNUNET_MESSENGER_MessageBody
{
  union
  {
    struct GNUNET_MESSENGER_MessageInfo info;
    struct GNUNET_MESSENGER_MessageJoin join;
    struct GNUNET_MESSENGER_MessageLeave leave;
    struct GNUNET_MESSENGER_MessageName name;
    struct GNUNET_MESSENGER_MessageKey key;
    struct GNUNET_MESSENGER_MessagePeer peer;
    struct GNUNET_MESSENGER_MessageId id;
    struct GNUNET_MESSENGER_MessageMiss miss;
    struct GNUNET_MESSENGER_MessageMerge merge;
    struct GNUNET_MESSENGER_MessageRequest request;
    struct GNUNET_MESSENGER_MessageInvite invite;
    struct GNUNET_MESSENGER_MessageText text;
    struct GNUNET_MESSENGER_MessageFile file;
    struct GNUNET_MESSENGER_MessagePrivate privacy;
    struct GNUNET_MESSENGER_MessageDeletion deletion;
    struct GNUNET_MESSENGER_MessageConnection connection;
    struct GNUNET_MESSENGER_MessageTicket ticket;
    struct GNUNET_MESSENGER_MessageTranscript transcript;
    struct GNUNET_MESSENGER_MessageTag tag;
    struct GNUNET_MESSENGER_MessageSubscribtion subscription;
    struct GNUNET_MESSENGER_MessageTalk talk;
    struct GNUNET_MESSENGER_MessageAnnouncement announcement;
    struct GNUNET_MESSENGER_MessageSecret secret;
    struct GNUNET_MESSENGER_MessageAppeal appeal;
    struct GNUNET_MESSENGER_MessageAccess access;
    struct GNUNET_MESSENGER_MessageRevolution revolution;
    struct GNUNET_MESSENGER_MessageGroup group;
    struct GNUNET_MESSENGER_MessageAuthorization authorization;
  };
};
 
struct GNUNET_MESSENGER_Message
{
  struct GNUNET_MESSENGER_MessageHeader header;
 
  struct GNUNET_MESSENGER_MessageBody body;
};
 
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,
 
  GNUNET_MESSENGER_FLAG_SECRET = 64,
 
  GNUNET_MESSENGER_FLAG_MEMBER = 128,
};
 
enum GNUNET_MESSENGER_ConnectionFlags
{
  GNUNET_MESSENGER_FLAG_CONNECTION_NONE = 0,
  GNUNET_MESSENGER_FLAG_CONNECTION_AUTO = 1,
};
 
enum GNUNET_MESSENGER_SubscriptionFlags
{
  GNUNET_MESSENGER_FLAG_SUBSCRIPTION_NONE = 0,
 
  GNUNET_MESSENGER_FLAG_SUBSCRIPTION_UNSUBSCRIBE = 1,
 
  GNUNET_MESSENGER_FLAG_SUBSCRIPTION_KEEP_ALIVE = 2,
};
 
enum GNUNET_MESSENGER_EpochFlags
{
  GNUNET_MESSENGER_FLAG_EPOCH_NONE = 0,
 
  GNUNET_MESSENGER_FLAG_EPOCH_VALID = 1,
};
 
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);
 
typedef enum GNUNET_GenericReturnValue
(*GNUNET_MESSENGER_MemberCallback) (void *cls,
                                    struct GNUNET_MESSENGER_Room *room,
                                    const struct
                                    GNUNET_MESSENGER_Contact *contact);
 
struct GNUNET_MESSENGER_Handle*
GNUNET_MESSENGER_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
                          const char *name,
                          const struct GNUNET_CRYPTO_BlindablePrivateKey *key,
                          const struct GNUNET_HashCode *secret,
                          GNUNET_MESSENGER_MessageCallback msg_callback,
                          void *msg_cls);
 
void
GNUNET_MESSENGER_disconnect (struct GNUNET_MESSENGER_Handle *handle);
 
const char*
GNUNET_MESSENGER_get_name (const struct GNUNET_MESSENGER_Handle *handle);
 
enum GNUNET_GenericReturnValue
GNUNET_MESSENGER_set_name (struct GNUNET_MESSENGER_Handle *handle,
                           const char *name);
 
const struct GNUNET_CRYPTO_BlindablePublicKey*
GNUNET_MESSENGER_get_key (const struct GNUNET_MESSENGER_Handle *handle);
 
enum GNUNET_GenericReturnValue
GNUNET_MESSENGER_set_key (struct GNUNET_MESSENGER_Handle *handle,
                          const struct GNUNET_CRYPTO_BlindablePrivateKey *key);
 
struct GNUNET_MESSENGER_Room*
GNUNET_MESSENGER_open_room (struct GNUNET_MESSENGER_Handle *handle,
                            const union GNUNET_MESSENGER_RoomKey *key);
 
struct GNUNET_MESSENGER_Room*
GNUNET_MESSENGER_enter_room (struct GNUNET_MESSENGER_Handle *handle,
                             const struct GNUNET_PeerIdentity *door,
                             const union GNUNET_MESSENGER_RoomKey *key);
 
void
GNUNET_MESSENGER_close_room (struct GNUNET_MESSENGER_Room *room);
 
int
GNUNET_MESSENGER_find_rooms (const struct GNUNET_MESSENGER_Handle *handle,
                             const struct GNUNET_MESSENGER_Contact *contact,
                             GNUNET_MESSENGER_MemberCallback callback,
                             void *cls);
 
const struct GNUNET_HashCode*
GNUNET_MESSENGER_room_get_key (const struct GNUNET_MESSENGER_Room *room);
 
const struct GNUNET_MESSENGER_Contact*
GNUNET_MESSENGER_get_sender (const struct GNUNET_MESSENGER_Room *room,
                             const struct GNUNET_HashCode *hash);
 
const struct GNUNET_MESSENGER_Contact*
GNUNET_MESSENGER_get_recipient (const struct GNUNET_MESSENGER_Room *room,
                                const struct GNUNET_HashCode *hash);
 
const char*
GNUNET_MESSENGER_contact_get_name (const struct
                                   GNUNET_MESSENGER_Contact *contact);
 
const struct GNUNET_CRYPTO_BlindablePublicKey*
GNUNET_MESSENGER_contact_get_key (const struct
                                  GNUNET_MESSENGER_Contact *contact);
 
size_t
GNUNET_MESSENGER_contact_get_id (const struct
                                 GNUNET_MESSENGER_Contact *contact);
 
void
GNUNET_MESSENGER_send_message (struct GNUNET_MESSENGER_Room *room,
                               const struct GNUNET_MESSENGER_Message *message,
                               const struct GNUNET_MESSENGER_Contact *contact);
 
void
GNUNET_MESSENGER_delete_message (struct GNUNET_MESSENGER_Room *room,
                                 const struct GNUNET_HashCode *hash,
                                 const struct GNUNET_TIME_Relative delay);
 
const struct GNUNET_MESSENGER_Message*
GNUNET_MESSENGER_get_message (struct GNUNET_MESSENGER_Room *room,
                              const struct GNUNET_HashCode *hash);
 
int
GNUNET_MESSENGER_iterate_members (struct GNUNET_MESSENGER_Room *room,
                                  GNUNET_MESSENGER_MemberCallback callback,
                                  void *cls);
 
#if 0 /* keep Emacsens' auto-indent happy */
{
#endif
#ifdef __cplusplus
}
#endif
 
#endif // GNUNET_MESSENGER_SERVICE_H
 

GNUNET_MESSENGER_ENCRYPTION_KEY_NONCE_BYTES

#define GNUNET_MESSENGER_ENCRYPTION_KEY_NONCE_BYTES    (sizeof (struct GNUNET_ShortHashCode))

Definition at line 228 of file gnunet_messenger_service.h.

GNUNET_MESSENGER_ENCRYPTION_KEY_DATA_BYTES

#define GNUNET_MESSENGER_ENCRYPTION_KEY_DATA_BYTES    (sizeof (uint32_t) + 4096 / 8)

Definition at line 230 of file gnunet_messenger_service.h.

GNUNET_MESSENGER_KIND_MAX

#define GNUNET_MESSENGER_KIND_MAX   (GNUNET_MESSENGER_KIND_TALK)

Definition at line 421 of file gnunet_messenger_service.h.

GNUNET_MESSENGER_SECRET_IV_BYTES

#define GNUNET_MESSENGER_SECRET_IV_BYTES    sizeof (struct GNUNET_CRYPTO_SymmetricInitializationVector)

Definition at line 910 of file gnunet_messenger_service.h.

GNUNET_MESSENGER_ACCESS_KEY_BYTES

#define GNUNET_MESSENGER_ACCESS_KEY_BYTES

Value:

        sizeof (struct GNUNET_CRYPTO_SymmetricSessionKey) + \
        GNUNET_CRYPTO_HPKE_SEAL_ONESHOT_OVERHEAD_BYTES

Definition at line 971 of file gnunet_messenger_service.h.

GNUNET_MESSENGER_AUTHORIZATION_KEY_BYTES

#define GNUNET_MESSENGER_AUTHORIZATION_KEY_BYTES    sizeof (struct GNUNET_CRYPTO_SymmetricSessionKey)

Definition at line 1052 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 1257 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 1257 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_DELETION	The deletion kind. The message contains a GNUNET_MESSENGER_MessageDeletion 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_SUBSCRIBTION	The subscription kind. The message contains a GNUNET_MESSENGER_MessageSubscribtion body.
GNUNET_MESSENGER_KIND_TALK	The talk kind. The message contains a GNUNET_MESSENGER_MessageTalk body.
GNUNET_MESSENGER_KIND_ANNOUNCEMENT	The announcement kind. The message contains a GNUNET_MESSENGER_MessageAnnouncement body.
GNUNET_MESSENGER_KIND_SECRET	The secret kind. The message contains a GNUNET_MESSENGER_MessageSecret body.
GNUNET_MESSENGER_KIND_APPEAL	The appeal kind. The message contains a GNUNET_MESSENGER_MessageAppeal body.
GNUNET_MESSENGER_KIND_ACCESS	The access kind. The message contains a GNUNET_MESSENGER_MessageAccess body.
GNUNET_MESSENGER_KIND_REVOLUTION	The revolution kind. The message contains a GNUNET_MESSENGER_MessageRevolution body.
GNUNET_MESSENGER_KIND_GROUP	The group kind. The message contains a GNUNET_MESSENGER_MessageGroup body.
GNUNET_MESSENGER_KIND_AUTHORIZATION	The authorization kind. The message contains a GNUNET_MESSENGER_MessageAuthorization body.
GNUNET_MESSENGER_KIND_UNKNOWN	The unknown kind. The message contains an unknown body.

Definition at line 273 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_DELETION = 15,
 
  GNUNET_MESSENGER_KIND_CONNECTION = 16,
 
  GNUNET_MESSENGER_KIND_TICKET = 17,
 
  GNUNET_MESSENGER_KIND_TRANSCRIPT = 18,
 
  GNUNET_MESSENGER_KIND_TAG = 19,
 
  GNUNET_MESSENGER_KIND_SUBSCRIBTION = 20,
 
  GNUNET_MESSENGER_KIND_TALK = 21,
 
  GNUNET_MESSENGER_KIND_ANNOUNCEMENT = 22,
 
  GNUNET_MESSENGER_KIND_SECRET = 23,
 
  GNUNET_MESSENGER_KIND_APPEAL = 24,
 
  GNUNET_MESSENGER_KIND_ACCESS = 25,
 
  GNUNET_MESSENGER_KIND_REVOLUTION = 26,
 
  GNUNET_MESSENGER_KIND_GROUP = 27,
 
  GNUNET_MESSENGER_KIND_AUTHORIZATION = 28,
 
  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.
GNUNET_MESSENGER_FLAG_SECRET	The secret flag. The flag indicates that the message was encrypted as epoch secret.
GNUNET_MESSENGER_FLAG_MEMBER	The member flag. The flag indicates that the message introduces a new member to the client.

Definition at line 1142 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_FLAG_SECRET = 64,
 
  GNUNET_MESSENGER_FLAG_MEMBER = 128,
};

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

{
  GNUNET_MESSENGER_FLAG_CONNECTION_NONE = 0,
  GNUNET_MESSENGER_FLAG_CONNECTION_AUTO = 1,
};

GNUNET_MESSENGER_SubscriptionFlags

enum GNUNET_MESSENGER_SubscriptionFlags

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

Compatible flags can be OR'ed together.

Enumerator
GNUNET_MESSENGER_FLAG_SUBSCRIPTION_NONE	The none flag. The flag indicates that the subscription is not affected by any modifications.
GNUNET_MESSENGER_FLAG_SUBSCRIPTION_UNSUBSCRIBE	The unsubscribe flag. The flag indicates that a member will unsubscribe a discourse.
GNUNET_MESSENGER_FLAG_SUBSCRIPTION_KEEP_ALIVE	The keep alive flag. The flag indicates that a member keeps a subscription alive implicitly.

Definition at line 1211 of file gnunet_messenger_service.h.

{
  GNUNET_MESSENGER_FLAG_SUBSCRIPTION_NONE = 0,
 
  GNUNET_MESSENGER_FLAG_SUBSCRIPTION_UNSUBSCRIBE = 1,
 
  GNUNET_MESSENGER_FLAG_SUBSCRIPTION_KEEP_ALIVE = 2,
};

GNUNET_MESSENGER_EpochFlags

enum GNUNET_MESSENGER_EpochFlags

Enumerator
GNUNET_MESSENGER_FLAG_EPOCH_NONE	The none flag. This flag indicates that the epoch or group key is not affected by any modifications.
GNUNET_MESSENGER_FLAG_EPOCH_VALID	The valid flag. This flag indicates whether an epoch or group key is still valid.

Definition at line 1229 of file gnunet_messenger_service.h.

{
  GNUNET_MESSENGER_FLAG_EPOCH_NONE = 0,
 
  GNUNET_MESSENGER_FLAG_EPOCH_VALID = 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

[in]

kind

Kind of a message

Returns

Name of that kind

Definition at line 46 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_DELETION:
    return "DELETION";
  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";
  case GNUNET_MESSENGER_KIND_SUBSCRIBTION:
    return "SUBSCRIPTION";
  case GNUNET_MESSENGER_KIND_TALK:
    return "TALK";
  case GNUNET_MESSENGER_KIND_ANNOUNCEMENT:
    return "ANNOUNCEMENT";
  case GNUNET_MESSENGER_KIND_SECRET:
    return "SECRET";
  case GNUNET_MESSENGER_KIND_APPEAL:
    return "APPEAL";
  case GNUNET_MESSENGER_KIND_ACCESS:
    return "ACCESS";
  case GNUNET_MESSENGER_KIND_REVOLUTION:
    return "REVOLUTION";
  case GNUNET_MESSENGER_KIND_GROUP:
    return "GROUP";
  case GNUNET_MESSENGER_KIND_AUTHORIZATION:
    return "AUTHORIZATION";
  default:
    return "UNKNOWN";
  }
}

References GNUNET_MESSENGER_KIND_ACCESS, GNUNET_MESSENGER_KIND_ANNOUNCEMENT, GNUNET_MESSENGER_KIND_APPEAL, GNUNET_MESSENGER_KIND_AUTHORIZATION, GNUNET_MESSENGER_KIND_CONNECTION, GNUNET_MESSENGER_KIND_DELETION, GNUNET_MESSENGER_KIND_FILE, GNUNET_MESSENGER_KIND_GROUP, 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, GNUNET_MESSENGER_KIND_REVOLUTION, GNUNET_MESSENGER_KIND_SECRET, GNUNET_MESSENGER_KIND_SUBSCRIBTION, GNUNET_MESSENGER_KIND_TAG, GNUNET_MESSENGER_KIND_TALK, GNUNET_MESSENGER_KIND_TEXT, GNUNET_MESSENGER_KIND_TICKET, and GNUNET_MESSENGER_KIND_TRANSCRIPT.

Referenced by check_send_message(), handle_recv_message(), handle_send_message(), handle_service_message(), handle_tunnel_message(), notify_srv_handle_message(), on_message(), send_srv_room_message(), and verify_tunnel_message().

Here is the caller graph for this function:

GNUNET_MESSENGER_create_room_key()

void GNUNET_MESSENGER_create_room_key	(	union GNUNET_MESSENGER_RoomKey *	key,
		const char *	input,
		enum GNUNET_GenericReturnValue	is_public,
		enum GNUNET_GenericReturnValue	is_group,
		enum GNUNET_GenericReturnValue	is_feed
	)

Creates a room key from given optional input string using certain properties for this targeted room.

Parameters

[out]	key	Room key
[in]	input	Input string or NULL
[in]	is_public	Public property
[in]	is_group	Group property
[in]	is_feed	Feed property

Definition at line 113 of file messenger_api.c.

{
  GNUNET_assert (key);
 
  if (input)
    GNUNET_CRYPTO_hash (
      input, strlen (input), &(key->hash));
  else
    GNUNET_CRYPTO_random_block (
      GNUNET_CRYPTO_QUALITY_STRONG,
      &(key->hash), sizeof (key->hash));
 
  key->code.public_bit = GNUNET_YES == is_public? 1 : 0;
  key->code.group_bit = GNUNET_YES == is_group? 1 : 0;
  key->code.feed_bit = GNUNET_YES == is_feed? 1 : 0;
  key->code.unused_bits = 0;
}

References GNUNET_assert, GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_QUALITY_STRONG, GNUNET_CRYPTO_random_block(), GNUNET_YES, is_public, and key.

Referenced by on_identity().

Here is the call graph for this function:

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_BlindablePrivateKey *	key,
		const struct GNUNET_HashCode *	secret,
		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 and a secret that is used to encrypt/decrypt locally stored keys.

Parameters

[in]	cfg	Configuration to use
[in]	name	Name or NULL
[in]	key	Private key or NULL to stay anonymous
[in]	secret	Private secret for local key storage or NULL
[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 763 of file messenger_api.c.

{
  struct GNUNET_MESSENGER_Handle *handle;
 
  GNUNET_assert (cfg);
 
  handle = create_handle (cfg, secret, msg_callback, msg_cls);
 
  reconnect (handle);
 
  if (handle->mq)
  {
    struct GNUNET_MESSENGER_CreateMessage *msg;
    struct GNUNET_MQ_Envelope *env;
 
    set_handle_name (handle, name);
 
    if ((! key) || (0 < GNUNET_CRYPTO_blindable_sk_get_length (key)))
      set_handle_key (handle, key);
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connect handle!\n");
 
    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_assert, GNUNET_CRYPTO_blindable_sk_get_length(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, 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(), GNUNET_MESSENGER_Handle::secret, 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 803 of file messenger_api.c.

{
  struct GNUNET_MESSENGER_DestroyMessage *msg;
  struct GNUNET_MQ_Envelope *env;
 
  if (! handle)
    return;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnect handle!\n");
 
  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_ERROR_TYPE_DEBUG, GNUNET_log, 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 1233 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 1272 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_BlindablePublicKey * 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 1296 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_BlindablePrivateKey *	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 1329 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_blindable_sk_get_length (key))
    return GNUNET_SYSERR;
 
  {
    struct GNUNET_CRYPTO_BlindablePrivateKey priv;
    GNUNET_memcpy (&priv, key, sizeof (priv));
 
    GNUNET_MESSENGER_find_rooms (handle, NULL, iterate_send_key_to_room, &priv);
    GNUNET_CRYPTO_private_key_clear (&priv);
  }
 
  set_handle_key (handle, key);
  return GNUNET_YES;
}

References GNUNET_CRYPTO_blindable_sk_get_length(), GNUNET_CRYPTO_private_key_clear(), 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 union GNUNET_MESSENGER_RoomKey *	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 1359 of file messenger_api.c.

{
  struct GNUNET_MESSENGER_Room *room;
 
  if ((! handle) || (! key))
    return NULL;
 
  if ((key->code.feed_bit) && (! key->code.group_bit))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Personal rooms containing private feeds should not be opened!")
    ;
    return NULL;
  }
 
  room = get_handle_room (handle, &(key->hash), GNUNET_YES);
 
  if (! room)
    return NULL;
 
  send_open_room (handle, room);
  return room;
}

References get_handle_room(), GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_YES, 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 union GNUNET_MESSENGER_RoomKey *	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 1386 of file messenger_api.c.

{
  struct GNUNET_MESSENGER_Room *room;
 
  if ((! handle) || (! door) || (! key))
    return NULL;
 
  room = get_handle_room (handle, &(key->hash), GNUNET_YES);
 
  if (! room)
    return NULL;
 
  send_enter_room (handle, room, door);
  return room;
}

References get_handle_room(), GNUNET_YES, 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 1406 of file messenger_api.c.

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

References create_message_leave(), enqueue_message_to_room(), and GNUNET_YES.

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

{
  struct GNUNET_MESSENGER_RoomFind find;
 
  if (! handle)
    return GNUNET_SYSERR;
 
  find.contact = contact;
  find.callback = callback;
  find.counter = (contact? contact->rc : SIZE_MAX);
  find.cls = cls;
 
  if (find.counter <= 0)
    return 0;
 
  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 1484 of file messenger_api.c.

{
  if (! room)
    return NULL;
 
  return get_room_key (room);
}

References get_room_key().

Referenced by on_message_cb().

Here is the call graph for this function:

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 1494 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 1505 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 1516 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_BlindablePublicKey * 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 1527 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 1538 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 1612 of file messenger_api.c.

{
  const struct GNUNET_CRYPTO_BlindablePublicKey *public_key;
  const struct GNUNET_CRYPTO_HpkePublicKey *encryption_key;
 
  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;
  }
 
  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;
    }
 
    encryption_key = get_contact_encryption_key (
      contact, get_room_key (room));
 
    if (! encryption_key)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Sending message aborted: Missing encryption key!\n");
      return;
    }
  }
  else
  {
    public_key = NULL;
    encryption_key = NULL;
  }
 
  send_message_to_room_with_key (
    room, copy_message (message), public_key, encryption_key);
}

References copy_message(), filter_message_sending(), get_contact_encryption_key(), get_contact_key(), get_non_anonymous_key(), get_room_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 1670 of file messenger_api.c.

{
  const struct GNUNET_MESSENGER_Message *message;
 
  if ((! room) || (! hash))
    return;
 
  message = get_room_message (room, hash);
 
  if ((message) && (GNUNET_YES == is_epoch_message (message)))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Deletion of message is not allowed!\n");
    return;
  }
 
  delete_room_message (room, hash, delay);
}

References delete_room_message(), get_room_message(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_YES, and is_epoch_message().

Here is the call graph for this function:

GNUNET_MESSENGER_get_message()

const struct GNUNET_MESSENGER_Message * GNUNET_MESSENGER_get_message	(	struct GNUNET_MESSENGER_Room *	room,
		const struct GNUNET_HashCode *	hash
	)

Get the message in a room identified by its hash and requests it if necessary.

Parameters

[in,out]	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 1715 of file messenger_api.c.

{
  const struct GNUNET_MESSENGER_Message *message;
 
  if ((! room) || (! hash) || (GNUNET_is_zero (hash)))
    return NULL;
 
  message = get_room_message (room, hash);
 
  if (! message)
  {
    if ((GNUNET_YES == room->joined) && (get_room_sender_id (room)))
      request_message_from_room (room, hash);
    else
      require_message_from_room (room, hash);
  }
 
  return message;
}

References get_room_message(), get_room_sender_id(), GNUNET_is_zero, GNUNET_YES, GNUNET_MESSENGER_Room::joined, request_message_from_room(), and require_message_from_room().

Referenced by on_message().

Here is the call graph for this function:

Here is the caller 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 1738 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: