1 files changed, 365 insertions, 86 deletions

diff --git a/src/include/gnunet_messenger_service.h b/src/include/gnunet_messenger_service.h
index 0576e239f..1bc68b87b 100644
--- a/src/include/gnunet_messenger_service.h
+++ b/src/include/gnunet_messenger_service.h
@@ -1,6 +1,6 @@
 /*
    This file is part of GNUnet.
-   Copyright (C) 2020 GNUnet e.V.
+   Copyright (C) 2020--2024 GNUnet e.V.
 
    GNUnet is free software: you can redistribute it and/or modify it
    under the terms of the GNU Affero General Public License as published
@@ -39,19 +39,21 @@ extern "C" {
 #endif
 #endif
 
-#include "platform.h"
+#include "gnunet_common.h"
 #include "gnunet_configuration_lib.h"
-#include "gnunet_crypto_lib.h"
 #include "gnunet_identity_service.h"
-#include "gnunet_mq_lib.h"
-#include "gnunet_protocols.h"
+#include "gnunet_reclaim_lib.h"
+#include "gnunet_reclaim_service.h"
 #include "gnunet_scheduler_lib.h"
 #include "gnunet_time_lib.h"
+#include "gnunet_util_lib.h"
 
 /**
  * Version number of GNUnet Messenger API.
+ *
+ * Current version of the Messenger: 0.3
  */
-#define GNUNET_MESSENGER_VERSION 0x00000001
+#define GNUNET_MESSENGER_VERSION 0x00000003
 
 /**
  * Identifier of GNUnet MESSENGER Service.
@@ -73,6 +75,48 @@ struct GNUNET_MESSENGER_Room;
  */
 struct GNUNET_MESSENGER_Contact;
 
+GNUNET_NETWORK_STRUCT_BEGIN
+
+/**
+ * A room entry record specifies which peer is hosting a given room and
+ * may also specify the key to enter it.
+ */
+struct GNUNET_MESSENGER_RoomEntryRecord
+{
+  /**
+   * The peer identity of an open door to a room.
+   */
+  struct GNUNET_PeerIdentity door;
+
+  /**
+   * The hash identifying the port of the room.
+   */
+  struct GNUNET_HashCode key;
+};
+
+GNUNET_NETWORK_STRUCT_END
+
+  GNUNET_NETWORK_STRUCT_BEGIN
+
+/**
+ * A room details record specifies a custom name for a given room and
+ * some additional space for flags.
+ */
+struct GNUNET_MESSENGER_RoomDetailsRecord
+{
+  /**
+   * The custom name for the room.
+   */
+  char name[256];
+
+  /**
+   * The flags of the room.
+   */
+  uint32_t flags;
+};
+
+GNUNET_NETWORK_STRUCT_END
+
 /**
  * Enum for the different supported kinds of messages
  */
@@ -154,6 +198,26 @@ enum GNUNET_MESSENGER_MessageKind
   GNUNET_MESSENGER_KIND_DELETE = 15,
 
   /**
+   * The connection kind. The message contains a #GNUNET_MESSENGER_MessageConnection body.
+   */
+  GNUNET_MESSENGER_KIND_CONNECTION = 16,
+
+  /**
+   * The ticket kind. The message contains a #GNUNET_MESSENGER_MessageTicket body.
+   */
+  GNUNET_MESSENGER_KIND_TICKET = 17,
+
+  /**
+   * The transcript kind. The message contains a #GNUNET_MESSENGER_MessageTranscript body.
+   */
+  GNUNET_MESSENGER_KIND_TRANSCRIPT = 18,
+
+  /**
+   * The tag kind. The message contains a #GNUNET_MESSENGER_MessageTag body.
+   */
+  GNUNET_MESSENGER_KIND_TAG = 19,
+
+  /**
    * The unknown kind. The message contains an unknown body.
    */
   GNUNET_MESSENGER_KIND_UNKNOWN = 0
@@ -181,7 +245,7 @@ struct GNUNET_MESSENGER_MessageHeader
   /**
    * The signature of the senders private key.
    */
-  struct GNUNET_IDENTITY_Signature signature;
+  struct GNUNET_CRYPTO_Signature signature;
 
   /**
    * The timestamp of the message.
@@ -213,12 +277,11 @@ struct GNUNET_MESSENGER_MessageHeader
 struct GNUNET_MESSENGER_MessageInfo
 {
   /**
-   * The senders key to verify its signatures.
-   */
-  struct GNUNET_IDENTITY_PublicKey host_key;
-
-  /**
    * The version of GNUnet Messenger API.
+   *
+   * The sixteen lower bits represent the lower version number while the sixteen higher bits
+   * represent the higher version number. A different higher version number implies incompatibility
+   * to lower versions while differences in the lower version can still be supported potentially.
    */
   uint32_t messenger_version;
 };
@@ -234,7 +297,7 @@ struct GNUNET_MESSENGER_MessageJoin
   /**
    * The senders public key to verify its signatures.
    */
-  struct GNUNET_IDENTITY_PublicKey key;
+  struct GNUNET_CRYPTO_PublicKey key;
 };
 
 /**
@@ -272,7 +335,7 @@ struct GNUNET_MESSENGER_MessageKey
   /**
    * The new public key which replaces the current senders public key.
    */
-  struct GNUNET_IDENTITY_PublicKey key;
+  struct GNUNET_CRYPTO_PublicKey key;
 };
 
 /**
@@ -451,6 +514,87 @@ struct GNUNET_MESSENGER_MessageDelete
 };
 
 /**
+ * A connection message body
+ * This allows to tell others about connection information about a peer.
+ *
+ * Message-body-size: 8 bytes
+ */
+struct GNUNET_MESSENGER_MessageConnection
+{
+  /**
+   * The amount of connections of a peer.
+   */
+  uint32_t amount;
+
+  /**
+   * The flags about the connections of a peer.
+   */
+  uint32_t flags;
+};
+
+/**
+ * A ticket message body
+ * This allows to exchange ticket identifiers with an audience.
+ *
+ * Message-body-size: 32 bytes
+ */
+struct GNUNET_MESSENGER_MessageTicket
+{
+  /**
+   * The identifier of a RECLAIM ticket.
+   */
+  struct GNUNET_RECLAIM_Identifier identifier;
+};
+
+/**
+ * A transcript message body
+ * This allows reading the content of a sent private message.
+ *
+ * Message-body-size: 68+
+ */
+struct GNUNET_MESSENGER_MessageTranscript
+{
+  /**
+   * The hash of the original message.
+   */
+  struct GNUNET_HashCode hash;
+
+  /**
+   * The key from the recipient of the original message.
+   */
+  struct GNUNET_CRYPTO_PublicKey key;
+
+  /**
+   * The length of the transcribed message.
+   */
+  uint16_t length;
+
+  /**
+   * The data of the transcribed message.
+   */
+  char *data;
+};
+
+/**
+ * A tag message body
+ * This allows tagging a message with a custom tag.
+ *
+ * Message-body-size: 32+
+ */
+struct GNUNET_MESSENGER_MessageTag
+{
+  /**
+   * The hash of the message to tag.
+   */
+  struct GNUNET_HashCode hash;
+
+  /**
+   * The custom tag.
+   */
+  char *tag;
+};
+
+/**
  * The unified body of a #GNUNET_MESSENGER_Message.
  */
 struct GNUNET_MESSENGER_MessageBody
@@ -470,8 +614,12 @@ struct GNUNET_MESSENGER_MessageBody
     struct GNUNET_MESSENGER_MessageInvite invite;
     struct GNUNET_MESSENGER_MessageText text;
     struct GNUNET_MESSENGER_MessageFile file;
-    struct GNUNET_MESSENGER_MessagePrivate private;
-    struct GNUNET_MESSENGER_MessageDelete delete;
+    struct GNUNET_MESSENGER_MessagePrivate privacy;
+    struct GNUNET_MESSENGER_MessageDelete deletion;
+    struct GNUNET_MESSENGER_MessageConnection connection;
+    struct GNUNET_MESSENGER_MessageTicket ticket;
+    struct GNUNET_MESSENGER_MessageTranscript transcript;
+    struct GNUNET_MESSENGER_MessageTag tag;
   };
 };
 
@@ -492,7 +640,8 @@ struct GNUNET_MESSENGER_Message
 };
 
 /**
- * Enum for the different supported flags used by message handling
+ * Enum for the different supported flags used by message handling.
+ * Compatible flags can be OR'ed together.
  */
 enum GNUNET_MESSENGER_MessageFlags
 {
@@ -502,38 +651,76 @@ enum GNUNET_MESSENGER_MessageFlags
   GNUNET_MESSENGER_FLAG_NONE = 0,
 
   /**
+   * The sent flag. The flag indicates that the message was sent by the client.
+   */
+  GNUNET_MESSENGER_FLAG_SENT = 1,
+
+  /**
    * The private flag. The flag indicates that the message was privately encrypted.
    */
-  GNUNET_MESSENGER_FLAG_PRIVATE = 1,
+  GNUNET_MESSENGER_FLAG_PRIVATE = 2,
+
+  /**
+   * The peer flag. The flag indicates that the message was sent by a peer and not a member.
+   */
+  GNUNET_MESSENGER_FLAG_PEER = 4,
+
+  /**
+   * The recent flag. The flag indicates that the message was recently handled by the service.
+   */
+  GNUNET_MESSENGER_FLAG_RECENT = 8,
+
+  /**
+   * The update flag. The flag indicates that the message was updated by the client.
+   */
+  GNUNET_MESSENGER_FLAG_UPDATE = 16,
+
+  /**
+   * The delete flag. The flag indicates that the message was deleted by the service.
+   */
+  GNUNET_MESSENGER_FLAG_DELETE = 32,
 };
 
 /**
- * Method called whenever the EGO of a <i>handle</i> changes or if the first connection fails
- * to load a valid EGO and the anonymous key pair will be used instead.
- *
- * @param[in/out] cls Closure from #GNUNET_MESSENGER_connect
- * @param[in/out] handle Messenger handle
+ * Enum for the different supported flags used to specify connection handling.
+ * Compatible flags can be OR'ed together.
  */
-typedef void
-(*GNUNET_MESSENGER_IdentityCallback) (void *cls, struct GNUNET_MESSENGER_Handle *handle);
+enum GNUNET_MESSENGER_ConnectionFlags
+{
+  /**
+   * The none flag. The flag indicates that the connection is not affected by any modifications.
+   */
+  GNUNET_MESSENGER_FLAG_CONNECTION_NONE = 0,/**< GNUNET_MESSENGER_FLAG_CONNECTION_NONE */
+
+  /**
+   * The auto flag. The flag indicates that a peer will automatically handle routing.
+   */
+  GNUNET_MESSENGER_FLAG_CONNECTION_AUTO = 1,/**< GNUNET_MESSENGER_FLAG_CONNECTION_AUTO */
+};
 
 /**
  * Method called whenever a message is sent or received from a <i>room</i>.
  *
- * The flag <i>private_message</i> will be #GNUNET_YES if a message was
- * received privately, otherwise #GNUNET_NO.
+ * The <i>flags</i> will indicate with a bitmask if a message was
+ * received privately or if the message was sent by the client.
  *
  * @param[in/out] cls Closure from #GNUNET_MESSENGER_connect
  * @param[in] room Room handle
  * @param[in] sender Sender of message
+ * @param[in] recipient Recipient of message
  * @param[in] message Newly received or sent message
  * @param[in] hash Hash identifying the message
  * @param[in] flags Flags of the message
  */
 typedef void
-(*GNUNET_MESSENGER_MessageCallback) (void *cls, struct GNUNET_MESSENGER_Room *room,
-                                     const struct GNUNET_MESSENGER_Contact *sender,
-                                     const struct GNUNET_MESSENGER_Message *message,
+(*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);
 
@@ -545,45 +732,34 @@ typedef void
  * @param[in] room Room handle
  * @param[in] contact Contact handle
  */
-typedef int
-(*GNUNET_MESSENGER_MemberCallback) (void* cls, struct GNUNET_MESSENGER_Room *room,
-                                    const struct GNUNET_MESSENGER_Contact *contact);
+typedef enum GNUNET_GenericReturnValue
+(*GNUNET_MESSENGER_MemberCallback) (void *cls,
+                                    struct GNUNET_MESSENGER_Room *room,
+                                    const struct
+                                    GNUNET_MESSENGER_Contact *contact);
 
 /**
- * Set up a handle for the messenger related functions and connects to all necessary services. It will look up the ego
- * key identified by its <i>name</i> and use it for signing all messages from the handle.
+ * 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.
  *
  * @param[in] cfg Configuration to use
- * @param[in] name Name to look up an ego or NULL to stay anonymous
- * @param[in] identity_callback Function called when the EGO of the handle changes
- * @param[in/out] identity_cls Closure for the <i>identity_callback</i> handler
+ * @param[in] name Name or NULL
+ * @param[in] key Private key or NULL to stay anonymous
  * @param[in] msg_callback Function called when a new message is sent or received
- * @param[in/out] msg_cls Closure for the <i>msg_callback</i> handler
+ * @param[in,out] msg_cls Closure for the <i>msg_callback</i> handler
  * @return Messenger handle to use, NULL on error
  */
 struct GNUNET_MESSENGER_Handle*
-GNUNET_MESSENGER_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *name,
-                          GNUNET_MESSENGER_IdentityCallback identity_callback, void *identity_cls,
-                          GNUNET_MESSENGER_MessageCallback msg_callback, void *msg_cls);
-
-/**
- * Update a handle of the messenger to use a different ego key and replace the old one with a newly generated one. All
- * participated rooms get informed about the key renewal. The handle requires a set name for this function to work and
- * it needs to be unused by other egos.
- *
- * Keep in mind that this will fully delete the old ego key (if any is used) even if any other service wants to use it
- * as default.
- *
- * @param[in/out] handle Messenger handle to use
- * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
- */
-int
-GNUNET_MESSENGER_update (struct GNUNET_MESSENGER_Handle *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);
 
 /**
  * Disconnect all of the messengers used services and clears up its used memory.
  *
- * @param[in/out] handle Messenger handle to use
+ * @param[in,out] handle Messenger handle to use
  */
 void
 GNUNET_MESSENGER_disconnect (struct GNUNET_MESSENGER_Handle *handle);
@@ -598,27 +774,40 @@ const char*
 GNUNET_MESSENGER_get_name (const struct GNUNET_MESSENGER_Handle *handle);
 
 /**
- * Set the name for the messenger. This will rename the currently used ego and move all stored files related to the current
- * name to its new directory. If anything fails during this process the function returns #GNUNET_NO and the name for
- * the messenger won't change as specified.
+ * Set the name for the messenger handle and sends messages renaming your contact in currently
+ * open rooms.
  *
- * @param[in/out] handle Messenger handle to use
+ * @param[in,out] handle Messenger handle to use
  * @param[in] name Name for the messenger to change to
  * @return #GNUNET_YES on success, #GNUNET_NO on failure and #GNUNET_SYSERR if <i>handle</i> is NULL
  */
-int
-GNUNET_MESSENGER_set_name (struct GNUNET_MESSENGER_Handle *handle, const char *name);
+enum GNUNET_GenericReturnValue
+GNUNET_MESSENGER_set_name (struct GNUNET_MESSENGER_Handle *handle,
+                           const char *name);
 
 /**
  * Get the public key used by the messenger or NULL if the anonymous key was used.
  *
  * @param[in] handle Messenger handle to use
- * @return Used ego's public key or NULL
+ * @return Used public key or NULL
  */
-const struct GNUNET_IDENTITY_PublicKey*
+const struct GNUNET_CRYPTO_PublicKey*
 GNUNET_MESSENGER_get_key (const struct GNUNET_MESSENGER_Handle *handle);
 
 /**
+ * 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.
+ *
+ * @param[in,out] handle Messenger handle to use
+ * @param[in] key Private key to change to or NULL
+ * @return #GNUNET_YES on success, #GNUNET_NO on failure and #GNUNET_SYSERR if <i>handle</i> is NULL
+ */
+enum GNUNET_GenericReturnValue
+GNUNET_MESSENGER_set_key (struct GNUNET_MESSENGER_Handle *handle,
+                          const struct GNUNET_CRYPTO_PrivateKey *key);
+
+/**
  * Open a room to send and receive messages. The room will use the specified <i>key</i> as port for the underlying cadet
  * service. Opening a room results in opening the port for incoming connections as possible <b>door</b>.
  *
@@ -630,12 +819,13 @@ GNUNET_MESSENGER_get_key (const struct GNUNET_MESSENGER_Handle *handle);
  *
  * ( All <b>doors</b> form a ring structured network to shorten the latency sending and receiving messages. )
  *
- * @param[in/out] handle Messenger handle to use
+ * @param[in,out] handle Messenger handle to use
  * @param[in] key Hash identifying the port
  * @return Room handle, NULL on error
  */
 struct GNUNET_MESSENGER_Room*
-GNUNET_MESSENGER_open_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *key);
+GNUNET_MESSENGER_open_room (struct GNUNET_MESSENGER_Handle *handle,
+                            const struct GNUNET_HashCode *key);
 
 /**
  * Enter a room to send and receive messages through a <b>door</b> opened using #GNUNET_MESSENGER_open_room.
@@ -650,28 +840,55 @@ GNUNET_MESSENGER_open_room (struct GNUNET_MESSENGER_Handle *handle, const struct
  *
  * ( All <b>doors</b> form a ring structured network to shorten the latency sending and receiving messages. )
  *
- * @param[in/out] handle Messenger handle to use
+ * @param[in,out] handle Messenger handle to use
  * @param[in] door Peer identity of an open <b>door</b>
  * @param[in] key Hash identifying the port
  * @return Room handle, NULL on error
  */
 struct GNUNET_MESSENGER_Room*
-GNUNET_MESSENGER_enter_room (struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_PeerIdentity *door,
+GNUNET_MESSENGER_enter_room (struct GNUNET_MESSENGER_Handle *handle,
+                             const struct GNUNET_PeerIdentity *door,
                              const struct GNUNET_HashCode *key);
 
 /**
- * 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.
+ * Close a <i>room</i> 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 <b>door</b>, all members entered through that specific <b>door</b> have to use another one
  * or open the room on their own. )
  *
- * @param[in/out] room Room handle
+ * @param[in,out] room Room handle
  */
 void
 GNUNET_MESSENGER_close_room (struct GNUNET_MESSENGER_Room *room);
 
 /**
+ * Searches for a specific <i>contact</i> in a given <i>room</i> and calls a selected <i>callback</i> 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.
+ *
+ * @param[in] handle Messenger handle to use
+ * @param[in] contact Contact handle
+ * @param[in] callback Function called for each room
+ * @param[in] cls Closure for the <i>callback</i> handler
+ * @return Amount of rooms iterated
+ */
+int
+GNUNET_MESSENGER_find_rooms (const struct GNUNET_MESSENGER_Handle *handle,
+                             const struct GNUNET_MESSENGER_Contact *contact,
+                             GNUNET_MESSENGER_MemberCallback callback,
+                             void *cls);
+
+/**
+ * Get the key of a given <i>room</i>.
+ *
+ * @param[in] room Room handle
+ * @return Hash identifying the port or NULL on failure
+ */
+const struct GNUNET_HashCode*
+GNUNET_MESSENGER_room_get_key (const struct GNUNET_MESSENGER_Room *room);
+
+/**
  * Get the contact of a member in a <i>room</i> which sent a specific message identified with a given <i>hash</i>.
  *
  * Notice that contacts are independent of rooms but will be removed if all rooms containing these contacts get closed.
@@ -680,8 +897,23 @@ GNUNET_MESSENGER_close_room (struct GNUNET_MESSENGER_Room *room);
  * @param[in] hash Hash identifying a message
  * @return Contact handle, NULL otherwise
  */
-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_sender (const struct GNUNET_MESSENGER_Room *room,
+                             const struct GNUNET_HashCode *hash);
+
+/**
+ * Get the contact of a member in a <i>room</i> which has been targeted as recipient of a specific message identified
+ * with a given <i>hash</i>.
+ *
+ * Notice that contacts are independent of rooms but will be removed if all rooms containing these contacts get closed.
+ *
+ * @param[in] room Room handle
+ * @param[in] hash Hash identifying a message
+ * @return Contact handle, NULL otherwise
+ */
+const struct GNUNET_MESSENGER_Contact*
+GNUNET_MESSENGER_get_recipient (const struct GNUNET_MESSENGER_Room *room,
+                                const struct GNUNET_HashCode *hash);
 
 /**
  * Get the name used by the <i>contact</i>.
@@ -690,19 +922,31 @@ GNUNET_MESSENGER_get_sender (const struct GNUNET_MESSENGER_Room *room, const str
  * @return Name of <i>contact</i> or NULL
  */
 const char*
-GNUNET_MESSENGER_contact_get_name (const struct GNUNET_MESSENGER_Contact *contact);
+GNUNET_MESSENGER_contact_get_name (const struct
+                                   GNUNET_MESSENGER_Contact *contact);
 
 /**
  * Get the public key used by the <i>contact</i> or NULL if the anonymous key was used.
  *
  * @param[in] contact Contact handle
- * @return Public key of the ego used by <i>contact</i> or NULL
+ * @return Public key used by <i>contact</i> or NULL
  */
-const struct GNUNET_IDENTITY_PublicKey*
-GNUNET_MESSENGER_contact_get_key (const struct GNUNET_MESSENGER_Contact *contact);
+const struct GNUNET_CRYPTO_PublicKey*
+GNUNET_MESSENGER_contact_get_key (const struct
+                                  GNUNET_MESSENGER_Contact *contact);
 
 /**
- * Send a <i>message</i> into a </i>room</i>. If you opened the <i>room</i> all entered members will receive the
+ * Get the locally unique id of the <i>contact</i>.
+ *
+ * @param[in] contact Contact handle
+ * @return Locally unique contact id or zero
+ */
+size_t
+GNUNET_MESSENGER_contact_get_id (const struct
+                                 GNUNET_MESSENGER_Contact *contact);
+
+/**
+ * Send a <i>message</i> into a <i>room</i>. If you opened the <i>room</i> all entered members will receive the
  * <i>message</i>. If you entered the <i>room</i> through a <b>door</b> all so entered <b>doors</b> will receive the
  * <i>message</i> as well. All members receiving the <i>message</i> will also propagate this <i>message</i> recursively
  * as long as the <i>message</i> is unknown to them.
@@ -715,13 +959,30 @@ GNUNET_MESSENGER_contact_get_key (const struct GNUNET_MESSENGER_Contact *contact
  *
  * Sending a message to all members in a given room can be done by providing NULL as contact.
  *
- * @param[in/out] room Room handle
- * @param[in] message New message to send
+ * @param[in,out] room Room handle
+ * @param[in,out] message New message to send
  * @param[in] contact Contact or NULL
  */
 void
-GNUNET_MESSENGER_send_message (struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Message *message,
-                               const struct GNUNET_MESSENGER_Contact* contact);
+GNUNET_MESSENGER_send_message (struct GNUNET_MESSENGER_Room *room,
+                               const struct GNUNET_MESSENGER_Message *message,
+                               const struct GNUNET_MESSENGER_Contact *contact);
+
+/**
+ * Delete a message identified by its <i>hash</i> from a <i>room</i>. 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.
+ *
+ * @param[in,out] room Room handle
+ * @param[in] message Message to delete
+ * @param[in] delay Delay to delete the message
+ */
+void
+GNUNET_MESSENGER_delete_message (struct GNUNET_MESSENGER_Room *room,
+                                 const struct GNUNET_HashCode *hash,
+                                 const struct GNUNET_TIME_Relative delay);
 
 /**
  * Get the message in a <i>room</i> identified by its <i>hash</i>.
@@ -731,7 +992,8 @@ GNUNET_MESSENGER_send_message (struct GNUNET_MESSENGER_Room *room, const struct
  * @return Message struct or NULL if no message with that hash is known
  */
 const struct GNUNET_MESSENGER_Message*
-GNUNET_MESSENGER_get_message (const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash);
+GNUNET_MESSENGER_get_message (const struct GNUNET_MESSENGER_Room *room,
+                              const struct GNUNET_HashCode *hash);
 
 /**
  * Iterates through all members of a given <i>room</i> and calls a selected <i>callback</i>
@@ -744,8 +1006,25 @@ GNUNET_MESSENGER_get_message (const struct GNUNET_MESSENGER_Room *room, const st
  * @return Amount of members iterated
  */
 int
-GNUNET_MESSENGER_iterate_members (struct GNUNET_MESSENGER_Room *room, GNUNET_MESSENGER_MemberCallback callback,
-                                  void* cls);
+GNUNET_MESSENGER_iterate_members (struct GNUNET_MESSENGER_Room *room,
+                                  GNUNET_MESSENGER_MemberCallback callback,
+                                  void *cls);
+
+/**
+ * Send a <i>ticket</i> into a <i>room</i>. The ticket will automatically be converted
+ * into a message to be sent only to its audience as a private message.
+ *
+ * A ticket can only be sent with this function if its issuer's public key is the one
+ * being used by the messenger. The audience's public key is not allowed to be the
+ * anonymous public key. The room needs to contain a member using the audience's public
+ * key.
+ *
+ * @param[in,out] room Room handle
+ * @param[in] ticket Ticket to send
+ */
+void
+GNUNET_MESSENGER_send_ticket (struct GNUNET_MESSENGER_Room *room,
+                              const struct GNUNET_RECLAIM_Ticket *ticket);
 
 #if 0 /* keep Emacsens' auto-indent happy */
 {