GNUnet debian-0.24.3-23-g589b01d60
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_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 subscribtion 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   0x00000006
 Version number of GNUnet Messenger API. More...
 
#define GNUNET_MESSENGER_SERVICE_NAME   "messenger"
 Identifier of GNUnet MESSENGER Service. More...
 
#define GNUNET_MESSENGER_EPOCH_NONCE_BYTES    sizeof (struct GNUNET_ShortHashCode)
 
#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. More...
 
typedef enum GNUNET_GenericReturnValue(* GNUNET_MESSENGER_MemberCallback) (void *cls, struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Contact *contact)
 Method called for each member in a room during iteration. More...
 

Enumerations

enum  GNUNET_MESSENGER_MessageKind {
  GNUNET_MESSENGER_KIND_INFO = 1 , GNUNET_MESSENGER_KIND_JOIN = 2 , GNUNET_MESSENGER_KIND_LEAVE = 3 , GNUNET_MESSENGER_KIND_NAME = 4 ,
  GNUNET_MESSENGER_KIND_KEY = 5 , GNUNET_MESSENGER_KIND_PEER = 6 , GNUNET_MESSENGER_KIND_ID = 7 , GNUNET_MESSENGER_KIND_MISS = 8 ,
  GNUNET_MESSENGER_KIND_MERGE = 9 , GNUNET_MESSENGER_KIND_REQUEST = 10 , GNUNET_MESSENGER_KIND_INVITE = 11 , GNUNET_MESSENGER_KIND_TEXT = 12 ,
  GNUNET_MESSENGER_KIND_FILE = 13 , GNUNET_MESSENGER_KIND_PRIVATE = 14 , GNUNET_MESSENGER_KIND_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. More...
 
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. More...
 
struct GNUNET_MESSENGER_HandleGNUNET_MESSENGER_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *name, const struct GNUNET_CRYPTO_PrivateKey *key, GNUNET_MESSENGER_MessageCallback msg_callback, void *msg_cls)
 Set up a handle for the messenger related functions and connects to all necessary services. More...
 
void GNUNET_MESSENGER_disconnect (struct GNUNET_MESSENGER_Handle *handle)
 Disconnect all of the messengers used services and clears up its used memory. More...
 
const char * GNUNET_MESSENGER_get_name (const struct GNUNET_MESSENGER_Handle *handle)
 Get the name (if specified, otherwise NULL) used by the messenger. More...
 
enum GNUNET_GenericReturnValue GNUNET_MESSENGER_set_name (struct GNUNET_MESSENGER_Handle *handle, const char *name)
 Set the name for the messenger handle and sends messages renaming your contact in currently open rooms. More...
 
const struct GNUNET_CRYPTO_PublicKeyGNUNET_MESSENGER_get_key (const struct GNUNET_MESSENGER_Handle *handle)
 Get the public key used by the messenger or NULL if the anonymous key was used. More...
 
enum GNUNET_GenericReturnValue GNUNET_MESSENGER_set_key (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_CRYPTO_PrivateKey *key)
 Set the private key used by the messenger or NULL if the anonymous key should be used instead. More...
 
struct GNUNET_MESSENGER_RoomGNUNET_MESSENGER_open_room (struct GNUNET_MESSENGER_Handle *handle, const union GNUNET_MESSENGER_RoomKey *key)
 Open a room to send and receive messages. More...
 
struct GNUNET_MESSENGER_RoomGNUNET_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. 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_HashCodeGNUNET_MESSENGER_room_get_key (const struct GNUNET_MESSENGER_Room *room)
 Get the key of a given room. More...
 
const struct GNUNET_MESSENGER_ContactGNUNET_MESSENGER_get_sender (const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash)
 Get the contact of a member in a room which sent a specific message identified with a given hash. More...
 
const struct GNUNET_MESSENGER_ContactGNUNET_MESSENGER_get_recipient (const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash)
 Get the contact of a member in a room which has been targeted as recipient of a specific message identified with a given hash. More...
 
const char * GNUNET_MESSENGER_contact_get_name (const struct GNUNET_MESSENGER_Contact *contact)
 Get the name used by the contact. More...
 
const struct GNUNET_CRYPTO_PublicKeyGNUNET_MESSENGER_contact_get_key (const struct GNUNET_MESSENGER_Contact *contact)
 Get the public key used by the contact or NULL if the anonymous key was used. More...
 
size_t GNUNET_MESSENGER_contact_get_id (const struct GNUNET_MESSENGER_Contact *contact)
 Get the locally unique id of the contact. More...
 
void GNUNET_MESSENGER_send_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_MESSENGER_Contact *contact)
 Send a message into a room. More...
 
void GNUNET_MESSENGER_delete_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash, const struct GNUNET_TIME_Relative delay)
 Delete a message identified by its hash from a room. More...
 
const struct GNUNET_MESSENGER_MessageGNUNET_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. 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   0x00000006

Version number of GNUnet Messenger API.

Current version of the Messenger: 0.6

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

◆ GNUNET_MESSENGER_KIND_MAX

#define GNUNET_MESSENGER_KIND_MAX   (GNUNET_MESSENGER_KIND_TALK)

Definition at line 376 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 855 of file gnunet_messenger_service.h.

◆ GNUNET_MESSENGER_ACCESS_KEY_BYTES

#define GNUNET_MESSENGER_ACCESS_KEY_BYTES
Value:

Definition at line 916 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 997 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]roomRoom handle
[in]senderSender of message
[in]recipientRecipient of message
[in]messageNewly received or sent message
[in]hashHash identifying the message
[in]flagsFlags of the message

Definition at line 1202 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]roomRoom handle
[in]contactContact handle

Definition at line 1202 of file gnunet_messenger_service.h.

Enumeration Type Documentation

◆ 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 subscribtion 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 228 of file gnunet_messenger_service.h.

229{
234
239
244
249
254
259
264
269
274
279
284
289
294
299
304
309
314
319
324
329
334
339
344
349
354
359
364
369
374};
@ GNUNET_MESSENGER_KIND_INFO
The info kind.
@ GNUNET_MESSENGER_KIND_MISS
The miss kind.
@ GNUNET_MESSENGER_KIND_INVITE
The invite kind.
@ GNUNET_MESSENGER_KIND_AUTHORIZATION
The authorization kind.
@ GNUNET_MESSENGER_KIND_ANNOUNCEMENT
The announcement kind.
@ GNUNET_MESSENGER_KIND_PRIVATE
The private kind.
@ GNUNET_MESSENGER_KIND_TAG
The tag kind.
@ GNUNET_MESSENGER_KIND_FILE
The file kind.
@ GNUNET_MESSENGER_KIND_APPEAL
The appeal kind.
@ GNUNET_MESSENGER_KIND_REQUEST
The request kind.
@ GNUNET_MESSENGER_KIND_NAME
The name kind.
@ GNUNET_MESSENGER_KIND_ACCESS
The access kind.
@ GNUNET_MESSENGER_KIND_LEAVE
The leave kind.
@ GNUNET_MESSENGER_KIND_TALK
The talk kind.
@ GNUNET_MESSENGER_KIND_REVOLUTION
The revolution kind.
@ GNUNET_MESSENGER_KIND_PEER
The peer kind.
@ GNUNET_MESSENGER_KIND_UNKNOWN
The unknown kind.
@ GNUNET_MESSENGER_KIND_TRANSCRIPT
The transcript kind.
@ GNUNET_MESSENGER_KIND_KEY
The key kind.
@ GNUNET_MESSENGER_KIND_TEXT
The text kind.
@ GNUNET_MESSENGER_KIND_SECRET
The secret kind.
@ GNUNET_MESSENGER_KIND_JOIN
The join kind.
@ GNUNET_MESSENGER_KIND_SUBSCRIBTION
The subscribtion kind.
@ GNUNET_MESSENGER_KIND_DELETION
The deletion kind.
@ GNUNET_MESSENGER_KIND_CONNECTION
The connection kind.
@ GNUNET_MESSENGER_KIND_TICKET
The ticket kind.
@ GNUNET_MESSENGER_KIND_MERGE
The merge kind.
@ GNUNET_MESSENGER_KIND_GROUP
The group kind.
@ GNUNET_MESSENGER_KIND_ID
The id kind.

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

1088{
1093
1098
1103
1108
1113
1118
1123
1128
1133};
@ GNUNET_MESSENGER_FLAG_SECRET
The secret flag.
@ GNUNET_MESSENGER_FLAG_PRIVATE
The private flag.
@ GNUNET_MESSENGER_FLAG_SENT
The sent flag.
@ GNUNET_MESSENGER_FLAG_UPDATE
The update flag.
@ GNUNET_MESSENGER_FLAG_NONE
The none flag.
@ GNUNET_MESSENGER_FLAG_MEMBER
The member flag.
@ GNUNET_MESSENGER_FLAG_DELETE
The delete flag.
@ GNUNET_MESSENGER_FLAG_PEER
The peer flag.
@ GNUNET_MESSENGER_FLAG_RECENT
The recent flag.

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

1140{
1150};
@ GNUNET_MESSENGER_FLAG_CONNECTION_AUTO
The auto flag.
@ GNUNET_MESSENGER_FLAG_CONNECTION_NONE
The none flag.

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

1157{
1162
1167
1172};
@ GNUNET_MESSENGER_FLAG_SUBSCRIPTION_KEEP_ALIVE
The keep alive flag.
@ GNUNET_MESSENGER_FLAG_SUBSCRIPTION_UNSUBSCRIBE
The unsubscribe flag.
@ GNUNET_MESSENGER_FLAG_SUBSCRIPTION_NONE
The none flag.

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

1175{
1181
1186};
@ GNUNET_MESSENGER_FLAG_EPOCH_NONE
The none flag.
@ GNUNET_MESSENGER_FLAG_EPOCH_VALID
The valid flag.

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]kindKind of a message
Returns
Name of that kind

Definition at line 46 of file messenger_api.c.

47{
48 switch (kind)
49 {
51 return "INFO";
53 return "JOIN";
55 return "LEAVE";
57 return "NAME";
59 return "KEY";
61 return "PEER";
63 return "ID";
65 return "MISS";
67 return "MERGE";
69 return "REQUEST";
71 return "INVITE";
73 return "TEXT";
75 return "FILE";
77 return "PRIVATE";
79 return "DELETION";
81 return "CONNECTION";
83 return "TICKET";
85 return "TRANSCRIPT";
87 return "TAG";
89 return "SUBSCRIBTION";
91 return "TALK";
93 return "ANNOUNCEMENT";
95 return "SECRET";
97 return "APPEAL";
99 return "ACCESS";
101 return "REVOLUTION";
103 return "GROUP";
105 return "AUTHORIZATION";
106 default:
107 return "UNKNOWN";
108 }
109}

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]keyRoom key
[in]inputInput string or NULL
[in]is_publicPublic property
[in]is_groupGroup property
[in]is_feedFeed property

Definition at line 113 of file messenger_api.c.

118{
120
121 if (input)
123 input, strlen (input), &(key->hash));
124 else
127 &(key->hash), sizeof (key->hash));
128
129 key->code.public_bit = GNUNET_YES == is_public? 1 : 0;
130 key->code.group_bit = GNUNET_YES == is_group? 1 : 0;
131 key->code.feed_bit = GNUNET_YES == is_feed? 1 : 0;
132 key->code.unused_bits = 0;
133}
struct GNUNET_HashCode key
The key used in the DHT.
static int is_public
Is record public (opposite of GNUNET_GNSRECORD_RF_PRIVATE)
void GNUNET_CRYPTO_random_block(enum GNUNET_CRYPTO_Quality mode, void *buffer, size_t length)
Fill block with a random values.
@ GNUNET_CRYPTO_QUALITY_STRONG
High-quality operations are desired.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
@ GNUNET_YES
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.

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_PrivateKey key,
GNUNET_MESSENGER_MessageCallback  msg_callback,
void *  msg_cls 
)

Set up a handle for the messenger related functions and connects to all necessary services.

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

Parameters
[in]cfgConfiguration to use
[in]nameName or NULL
[in]keyPrivate key or NULL to stay anonymous
[in]msg_callbackFunction called when a new message is sent or received
[in,out]msg_clsClosure for the msg_callback handler
Returns
Messenger handle to use, NULL on error

Definition at line 728 of file messenger_api.c.

733{
735
737
739
741
742 if (handle->mq)
743 {
745 struct GNUNET_MQ_Envelope *env;
746
748
751
752 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connect handle!\n");
753
756 return handle;
757 }
758 else
759 {
761 return NULL;
762 }
763}
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:108
static char * name
Name (label) of the records to list.
static struct GNUNET_VPN_Handle * handle
Handle to vpn service.
Definition: gnunet-vpn.c:35
#define GNUNET_log(kind,...)
ssize_t GNUNET_CRYPTO_private_key_get_length(const struct GNUNET_CRYPTO_PrivateKey *key)
Get the compacted length of a GNUNET_CRYPTO_PrivateKey.
Definition: crypto_pkey.c:64
@ GNUNET_ERROR_TYPE_DEBUG
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:305
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:76
#define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_CREATE
static void reconnect(struct GNUNET_MESSENGER_Handle *handle)
struct GNUNET_MESSENGER_Handle * create_handle(const struct GNUNET_CONFIGURATION_Handle *config, GNUNET_MESSENGER_MessageCallback msg_callback, void *msg_cls)
Creates and allocates a new handle using a given configuration and a custom message callback with a g...
void destroy_handle(struct GNUNET_MESSENGER_Handle *handle)
Destroys a handle and frees its memory fully from the client API.
void set_handle_key(struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_CRYPTO_PrivateKey *key)
Sets the keypair of a given handle to the keypair of a specific private key.
void set_handle_name(struct GNUNET_MESSENGER_Handle *handle, const char *name)
Sets the name of a handle to a specific name.
Message to create a handle for a client.
GNUNET_MESSENGER_MessageCallback msg_callback
struct GNUNET_MQ_Handle * mq
Connection to VPN service.
Definition: vpn_api.c:44

References cfg, create_handle(), destroy_handle(), env, GNUNET_assert, GNUNET_CRYPTO_private_key_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(), 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]handleMessenger handle to use

Definition at line 767 of file messenger_api.c.

768{
770 struct GNUNET_MQ_Envelope *env;
771
772 if (! handle)
773 return;
774
775 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnect handle!\n");
776
779
781}
#define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_DESTROY
Message to destroy the handle for a client.

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]handleMessenger handle to use
Returns
Name used by the messenger or NULL

Definition at line 1194 of file messenger_api.c.

1195{
1196 if (! handle)
1197 return NULL;
1198
1199 return get_handle_name (handle);
1200}
const char * get_handle_name(const struct GNUNET_MESSENGER_Handle *handle)
Returns the current name of a given handle or NULL if no valid name was assigned yet.

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]handleMessenger handle to use
[in]nameName 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 1233 of file messenger_api.c.

1235{
1236 if (! handle)
1237 return GNUNET_SYSERR;
1238
1239 set_handle_name (handle, strlen (name) > 0 ? name : NULL);
1241 return GNUNET_YES;
1242}
@ GNUNET_SYSERR
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 fo...
static enum GNUNET_GenericReturnValue iterate_send_name_to_room(void *cls, struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Contact *contact)

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

Here is the call graph for this function:

◆ GNUNET_MESSENGER_get_key()

const struct GNUNET_CRYPTO_PublicKey * GNUNET_MESSENGER_get_key ( const struct GNUNET_MESSENGER_Handle handle)

Get the public key used by the messenger or NULL if the anonymous key was used.

Parameters
[in]handleMessenger handle to use
Returns
Used public key or NULL

Definition at line 1256 of file messenger_api.c.

1257{
1258 if (! handle)
1259 return NULL;
1260
1262}
static const struct GNUNET_CRYPTO_PublicKey * get_non_anonymous_key(const struct GNUNET_CRYPTO_PublicKey *public_key)
const struct GNUNET_CRYPTO_PublicKey * get_handle_pubkey(const struct GNUNET_MESSENGER_Handle *handle)
Returns the public key of a given handle.

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

Here is the call graph for this function:

◆ GNUNET_MESSENGER_set_key()

enum GNUNET_GenericReturnValue GNUNET_MESSENGER_set_key ( struct GNUNET_MESSENGER_Handle handle,
const struct GNUNET_CRYPTO_PrivateKey key 
)

Set the private key used by the messenger or NULL if the anonymous key should be used instead.

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

Parameters
[in,out]handleMessenger handle to use
[in]keyPrivate 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 1287 of file messenger_api.c.

1289{
1290 if (! handle)
1291 return GNUNET_SYSERR;
1292
1293 if (! key)
1294 {
1296 set_handle_key (handle, NULL);
1297 return GNUNET_YES;
1298 }
1299
1301 return GNUNET_SYSERR;
1302
1303 {
1304 struct GNUNET_CRYPTO_PrivateKey priv;
1305 GNUNET_memcpy (&priv, key, sizeof (priv));
1306
1309 }
1310
1312 return GNUNET_YES;
1313}
void GNUNET_CRYPTO_private_key_clear(struct GNUNET_CRYPTO_PrivateKey *pk)
Clear memory that was used to store a private key.
Definition: crypto_pkey.c:47
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
static enum GNUNET_GenericReturnValue iterate_send_key_to_room(void *cls, struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Contact *contact)
A private key for an identity as per LSD0001.

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

Here is the call graph for this function:

◆ GNUNET_MESSENGER_open_room()

struct GNUNET_MESSENGER_Room * GNUNET_MESSENGER_open_room ( struct GNUNET_MESSENGER_Handle handle,
const 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]handleMessenger handle to use
[in]keyHash identifying the port
Returns
Room handle, NULL on error

Definition at line 1317 of file messenger_api.c.

1319{
1320 struct GNUNET_MESSENGER_Room *room;
1321
1322 if ((! handle) || (! key))
1323 return NULL;
1324
1325 if ((key->code.feed_bit) && (! key->code.group_bit))
1326 {
1328 "Personal rooms containing private feeds should not be opened!")
1329 ;
1330 return NULL;
1331 }
1332
1333 room = GNUNET_CONTAINER_multihashmap_get (handle->rooms, &(key->hash));
1334 if (! room)
1335 {
1336 room = create_room (handle, key);
1337
1339 handle->rooms, &(key->hash), room,
1341 {
1342 destroy_room (room);
1343 return NULL;
1344 }
1345 }
1346
1347 send_open_room (handle, room);
1348 return room;
1349}
void * GNUNET_CONTAINER_multihashmap_get(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Given a key find a value in the map matching the key.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST
, ' bother checking if a value already exists (faster than GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE...
@ GNUNET_OK
@ GNUNET_ERROR_TYPE_WARNING
static void send_open_room(struct GNUNET_MESSENGER_Handle *handle, struct GNUNET_MESSENGER_Room *room)
struct GNUNET_MESSENGER_Room * create_room(struct GNUNET_MESSENGER_Handle *handle, const union GNUNET_MESSENGER_RoomKey *key)
Creates and allocates a new room for a handle with a given key for the client API.
void destroy_room(struct GNUNET_MESSENGER_Room *room)
Destroys a room and frees its memory fully from the client API.

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

Referenced by join_room_run(), and on_identity().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_MESSENGER_enter_room()

struct GNUNET_MESSENGER_Room * GNUNET_MESSENGER_enter_room ( struct GNUNET_MESSENGER_Handle handle,
const struct GNUNET_PeerIdentity door,
const 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]handleMessenger handle to use
[in]doorPeer identity of an open door
[in]keyHash identifying the port
Returns
Room handle, NULL on error

Definition at line 1353 of file messenger_api.c.

1356{
1357 struct GNUNET_MESSENGER_Room *room;
1358
1359 if ((! handle) || (! door) || (! key))
1360 return NULL;
1361
1362 room = GNUNET_CONTAINER_multihashmap_get (handle->rooms, &(key->hash));
1363 if (! room)
1364 {
1365 room = create_room (handle, key);
1366
1368 handle->rooms, &(key->hash), room,
1370 {
1371 destroy_room (room);
1372 return NULL;
1373 }
1374 }
1375
1376 send_enter_room (handle, room, door);
1377 return room;
1378}
static void send_enter_room(struct GNUNET_MESSENGER_Handle *handle, struct GNUNET_MESSENGER_Room *room, const struct GNUNET_PeerIdentity *door)

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

Referenced by join_room_run(), and on_identity().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_MESSENGER_close_room()

void GNUNET_MESSENGER_close_room ( struct GNUNET_MESSENGER_Room room)

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

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

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

Parameters
[in,out]roomRoom handle

Definition at line 1382 of file messenger_api.c.

1383{
1384 struct GNUNET_MESSENGER_Message *message;
1385
1386 if (! room)
1387 return;
1388
1389 message = create_message_leave ();
1390
1391 if (! message)
1392 return;
1393
1394 enqueue_message_to_room (room, NULL, message, NULL, GNUNET_YES);
1395}
void enqueue_message_to_room(struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *epoch, struct GNUNET_MESSENGER_Message *message, struct GNUNET_MESSENGER_Message *transcript, enum GNUNET_GenericReturnValue sync)
Enqueus a message and its optional transcript for sending it to a given room and epoch.
struct GNUNET_MESSENGER_Message * create_message_leave(void)
Creates and allocates a new leave message.

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]handleMessenger handle to use
[in]contactContact handle
[in]callbackFunction called for each room
[in]clsClosure for the callback handler
Returns
Amount of rooms iterated

Definition at line 1436 of file messenger_api.c.

1440{
1441 struct GNUNET_MESSENGER_RoomFind find;
1442
1443 if (! handle)
1444 return GNUNET_SYSERR;
1445
1446 find.contact = contact;
1447 find.callback = callback;
1448 find.counter = (contact? contact->rc : SIZE_MAX);
1449 find.cls = cls;
1450
1451 if (find.counter <= 0)
1452 return 0;
1453
1455 iterate_find_room, &find);
1456}
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MultiHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
static enum GNUNET_GenericReturnValue iterate_find_room(void *cls, const struct GNUNET_HashCode *key, void *value)
#define SIZE_MAX
Definition: platform.h:209
GNUNET_MESSENGER_MemberCallback callback
const struct GNUNET_MESSENGER_Contact * contact

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]roomRoom handle
Returns
Hash identifying the port or NULL on failure

Definition at line 1460 of file messenger_api.c.

1461{
1462 if (! room)
1463 return NULL;
1464
1465 return get_room_key (room);
1466}
const struct GNUNET_HashCode * get_room_key(const struct GNUNET_MESSENGER_Room *room)
Return a the hash representation of a given 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]roomRoom handle
[in]hashHash identifying a message
Returns
Contact handle, NULL otherwise

Definition at line 1470 of file messenger_api.c.

1472{
1473 if ((! room) || (! hash))
1474 return NULL;
1475
1476 return get_room_sender (room, hash);
1477}
struct GNUNET_MESSENGER_Contact * get_room_sender(const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash)
Returns a messages sender locally stored from a map for a given hash in a room.

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]roomRoom handle
[in]hashHash identifying a message
Returns
Contact handle, NULL otherwise

Definition at line 1481 of file messenger_api.c.

1483{
1484 if ((! room) || (! hash))
1485 return NULL;
1486
1487 return get_room_recipient (room, hash);
1488}
struct GNUNET_MESSENGER_Contact * get_room_recipient(const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash)
Returns a messages recipient locally stored from a map for a given hash in a room.

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]contactContact handle
Returns
Name of contact or NULL

Definition at line 1492 of file messenger_api.c.

1494{
1495 if (! contact)
1496 return NULL;
1497
1498 return get_contact_name (contact);
1499}
const char * get_contact_name(const struct GNUNET_MESSENGER_Contact *contact)
Returns the current name of a given contact or NULL if no valid name was assigned yet.

References get_contact_name().

Referenced by on_message().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_MESSENGER_contact_get_key()

const struct GNUNET_CRYPTO_PublicKey * GNUNET_MESSENGER_contact_get_key ( const struct GNUNET_MESSENGER_Contact contact)

Get the public key used by the contact or NULL if the anonymous key was used.

Parameters
[in]contactContact handle
Returns
Public key used by contact or NULL

Definition at line 1503 of file messenger_api.c.

1505{
1506 if (! contact)
1507 return NULL;
1508
1509 return get_non_anonymous_key (get_contact_key (contact));
1510}
const struct GNUNET_CRYPTO_PublicKey * get_contact_key(const struct GNUNET_MESSENGER_Contact *contact)
Returns the public key of a given 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]contactContact handle
Returns
Locally unique contact id or zero

Definition at line 1514 of file messenger_api.c.

1516{
1517 if (! contact)
1518 return 0;
1519
1520 return get_contact_id (contact);
1521}
size_t get_contact_id(const struct GNUNET_MESSENGER_Contact *contact)
Returns the locally unique identifier of a given 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]roomRoom handle
[in,out]messageNew message to send
[in]contactContact or NULL

Definition at line 1582 of file messenger_api.c.

1585{
1586 const struct GNUNET_CRYPTO_PublicKey *public_key;
1587
1588 if ((! room) || (! message))
1589 return;
1590
1591 switch (filter_message_sending (message))
1592 {
1593 case GNUNET_SYSERR:
1595 "Sending message aborted: This kind of message is reserved for the service!\n");
1596 return;
1597 case GNUNET_NO:
1599 "Sending message aborted: This kind of message could cause issues!\n");
1600 return;
1601 default:
1602 break;
1603 }
1604
1605 if (contact)
1606 {
1607 public_key = get_non_anonymous_key (
1608 get_contact_key (contact));
1609
1610 if (! public_key)
1611 {
1613 "Sending message aborted: Invalid key!\n");
1614 return;
1615 }
1616 }
1617 else
1618 public_key = NULL;
1619
1620 send_message_to_room_with_key (room, copy_message (message), public_key);
1621}
@ GNUNET_NO
@ GNUNET_ERROR_TYPE_ERROR
static void send_message_to_room_with_key(struct GNUNET_MESSENGER_Room *room, struct GNUNET_MESSENGER_Message *message, const struct GNUNET_CRYPTO_PublicKey *public_key)
struct GNUNET_MESSENGER_Message * copy_message(const struct GNUNET_MESSENGER_Message *message)
Creates and allocates a copy of a given message.
enum GNUNET_GenericReturnValue filter_message_sending(const struct GNUNET_MESSENGER_Message *message)
Returns whether a specific kind of message should be sent by a client.
An identity key as per LSD0001.

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

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

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_MESSENGER_delete_message()

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

Delete a message identified by its hash from a room.

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

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

Parameters
[in,out]roomRoom handle
[in]messageMessage to delete
[in]delayDelay to delete the message

Definition at line 1625 of file messenger_api.c.

1628{
1629 const struct GNUNET_MESSENGER_Message *message;
1630
1631 if ((! room) || (! hash))
1632 return;
1633
1634 message = get_room_message (room, hash);
1635
1636 if ((message) && (GNUNET_YES == is_epoch_message (message)))
1637 {
1639 "Deletion of message is not allowed!\n");
1640 return;
1641 }
1642
1643 delete_room_message (room, hash, delay);
1644}
enum GNUNET_GenericReturnValue is_epoch_message(const struct GNUNET_MESSENGER_Message *message)
Returns whether a certain kind of message from storage contains some specific details that might be r...
const struct GNUNET_MESSENGER_Message * get_room_message(const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash)
Returns a message locally stored from a map for a given hash in a room.
void delete_room_message(struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash, const struct GNUNET_TIME_Relative delay)
Deletes a message with a given hash inside a room under a specific 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]roomRoom handle
[in]hashHash identifying a message
Returns
Message struct or NULL if no message with that hash is known

Definition at line 1670 of file messenger_api.c.

1672{
1673 const struct GNUNET_MESSENGER_Message *message;
1674
1675 if ((! room) || (! hash) || (GNUNET_is_zero (hash)))
1676 return NULL;
1677
1678 message = get_room_message (room, hash);
1679
1680 if (! message)
1681 {
1682 if ((GNUNET_YES == room->joined) && (get_room_sender_id (room)))
1683 request_message_from_room (room, hash);
1684 else
1685 require_message_from_room (room, hash);
1686 }
1687
1688 return message;
1689}
#define GNUNET_is_zero(a)
Check that memory in a is all zeros.
void request_message_from_room(const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash)
Requests a specific message from a given room which can be identified by its hash.
void require_message_from_room(struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash)
Requires a specific message in a given room which can be identified by its hash.
const struct GNUNET_ShortHashCode * get_room_sender_id(const struct GNUNET_MESSENGER_Room *room)
Returns the member id of the room's sender.
enum GNUNET_GenericReturnValue joined

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]roomRoom handle
[in]callbackFunction called for each member
[in]clsClosure for the callback handler
Returns
Amount of members iterated

Definition at line 1693 of file messenger_api.c.

1696{
1697 if (! room)
1698 return GNUNET_SYSERR;
1699
1700 return iterate_room_members (room, callback, cls);
1701}
int iterate_room_members(struct GNUNET_MESSENGER_Room *room, GNUNET_MESSENGER_MemberCallback callback, void *cls)
Iterates through all members of a given room to forward each of them to a selected callback with a cu...

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: