messenger api: client and service implementation of GNUnet MESSENGER service More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_identity_service.h"
#include "gnunet_signatures.h"
#include "gnunet_messenger_service.h"
#include "messenger_api_ego.h"

Include dependency graph for messenger_api_message.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	GNUNET_MESSENGER_MAX_MESSAGE_SIZE (GNUNET_MAX_MESSAGE_SIZE - GNUNET_MIN_MESSAGE_SIZE)

#define	GNUNET_MESSENGER_PADDING_MIN (sizeof(uint16_t) + sizeof(char))

#define	GNUNET_MESSENGER_PADDING_LEVEL0 (512)

#define	GNUNET_MESSENGER_PADDING_LEVEL1 (4096)

#define	GNUNET_MESSENGER_PADDING_LEVEL2 (32768)

#define	GNUNET_MESSENGER_PACK_MODE_ENVELOPE 0x1

#define	GNUNET_MESSENGER_PACK_MODE_UNKNOWN 0x0

Functions
struct GNUNET_MESSENGER_Message *	create_message (enum GNUNET_MESSENGER_MessageKind kind)
	Creates and allocates a new message with a specific kind. More...

struct GNUNET_MESSENGER_Message *	copy_message (const struct GNUNET_MESSENGER_Message *message)
	Creates and allocates a copy of a given message. More...

void	cleanup_message (struct GNUNET_MESSENGER_Message *message)
	Frees the messages body memory. More...

void	destroy_message (struct GNUNET_MESSENGER_Message *message)
	Destroys a message and frees its memory fully. More...

int	is_message_session_bound (const struct GNUNET_MESSENGER_Message *message)
	Returns if the message should be bound to a member session. More...

uint16_t	get_message_kind_size (enum GNUNET_MESSENGER_MessageKind kind, int include_header)
	Returns the minimal size in bytes to encode a message of a specific kind. More...

uint16_t	get_message_size (const struct GNUNET_MESSENGER_Message *message, int include_header)
	Returns the exact size in bytes to encode a given message. More...

void	encode_message (const struct GNUNET_MESSENGER_Message message, uint16_t length, char buffer, int include_header)
	Encodes a given message into a buffer of a maximal length in bytes. More...

int	decode_message (struct GNUNET_MESSENGER_Message message, uint16_t length, const char buffer, int include_header, uint16_t *padding)
	Decodes a message from a given buffer of a maximal length in bytes. More...

void	hash_message (const struct GNUNET_MESSENGER_Message message, uint16_t length, const char buffer, struct GNUNET_HashCode *hash)
	Calculates a hash of a given buffer with a length in bytes from a message. More...

void	sign_message (struct GNUNET_MESSENGER_Message message, uint16_t length, char buffer, const struct GNUNET_HashCode hash, const struct GNUNET_MESSENGER_Ego ego)
	Signs the hash of a message with a given ego and writes the signature into the buffer as well. More...

int	verify_message (const struct GNUNET_MESSENGER_Message message, const struct GNUNET_HashCode hash, const struct GNUNET_IDENTITY_PublicKey *key)
	Verifies the signature of a given message and its hash with a specific public key. More...

int	encrypt_message (struct GNUNET_MESSENGER_Message message, const struct GNUNET_IDENTITY_PublicKey key)
	Encrypts a message using a given public key and replaces its body and kind with the now private encrypted message. More...

int	decrypt_message (struct GNUNET_MESSENGER_Message message, const struct GNUNET_IDENTITY_PrivateKey key)
	Decrypts a private message using a given private key and replaces its body and kind with the inner encrypted message. More...

struct GNUNET_MQ_Envelope *	pack_message (struct GNUNET_MESSENGER_Message message, struct GNUNET_HashCode hash, const struct GNUNET_MESSENGER_Ego *ego, int mode)
	Encodes the message to pack it into a newly allocated envelope if mode is equal to GNUNET_MESSENGER_PACK_MODE_ENVELOPE. More...

int	filter_message_sending (const struct GNUNET_MESSENGER_Message *message)
	Returns if a specific kind of message should be sent by a client. More...

Detailed Description

messenger api: client and service implementation of GNUnet MESSENGER service

Author: Tobias Frisch

Definition in file messenger_api_message.h.

Macro Definition Documentation

◆ GNUNET_MESSENGER_MAX_MESSAGE_SIZE

#define GNUNET_MESSENGER_MAX_MESSAGE_SIZE (GNUNET_MAX_MESSAGE_SIZE - GNUNET_MIN_MESSAGE_SIZE)

Definition at line 38 of file messenger_api_message.h.

◆ GNUNET_MESSENGER_PADDING_MIN

#define GNUNET_MESSENGER_PADDING_MIN (sizeof(uint16_t) + sizeof(char))

Definition at line 40 of file messenger_api_message.h.

◆ GNUNET_MESSENGER_PADDING_LEVEL0

#define GNUNET_MESSENGER_PADDING_LEVEL0 (512)

Definition at line 41 of file messenger_api_message.h.

◆ GNUNET_MESSENGER_PADDING_LEVEL1

#define GNUNET_MESSENGER_PADDING_LEVEL1 (4096)

Definition at line 42 of file messenger_api_message.h.

◆ GNUNET_MESSENGER_PADDING_LEVEL2

#define GNUNET_MESSENGER_PADDING_LEVEL2 (32768)

Definition at line 43 of file messenger_api_message.h.

◆ GNUNET_MESSENGER_PACK_MODE_ENVELOPE

#define GNUNET_MESSENGER_PACK_MODE_ENVELOPE 0x1

Definition at line 219 of file messenger_api_message.h.

◆ GNUNET_MESSENGER_PACK_MODE_UNKNOWN

#define GNUNET_MESSENGER_PACK_MODE_UNKNOWN 0x0

Definition at line 220 of file messenger_api_message.h.

Function Documentation

◆ create_message()

struct GNUNET_MESSENGER_Message* create_message ( enum GNUNET_MESSENGER_MessageKind kind )

Creates and allocates a new message with a specific kind.

Parameters

[in] kind Kind of message

Returns: New message

Definition at line 42 of file messenger_api_message.c.

 {
   struct GNUNET_MESSENGER_Message *message = GNUNET_new (struct
                                                          GNUNET_MESSENGER_Message);
  
   message->header.kind = kind;
  
   switch (message->header.kind)
   {
   case GNUNET_MESSENGER_KIND_NAME:
     message->body.name.name = NULL;
     break;
   case GNUNET_MESSENGER_KIND_TEXT:
     message->body.text.text = NULL;
     break;
   case GNUNET_MESSENGER_KIND_FILE:
     message->body.file.uri = NULL;
     break;
   case GNUNET_MESSENGER_KIND_PRIVATE:
     message->body.privacy.length = 0;
     message->body.privacy.data = NULL;
     break;
   default:
     break;
   }
  
   return message;
 }

Referenced by create_message_delete(), create_message_id(), create_message_info(), create_message_invite(), create_message_join(), create_message_key(), create_message_leave(), create_message_merge(), create_message_miss(), create_message_name(), create_message_peer(), create_message_request(), create_message_text(), and get_store_message().

Here is the caller graph for this function:

◆ copy_message()

struct GNUNET_MESSENGER_Message* copy_message ( const struct GNUNET_MESSENGER_Message * message )

Creates and allocates a copy of a given message.

Parameters

[in] message Message

Returns: New message

Definition at line 73 of file messenger_api_message.c.

 {
   GNUNET_assert (message);
  
   struct GNUNET_MESSENGER_Message *copy = GNUNET_new (struct
                                                       GNUNET_MESSENGER_Message);
  
   GNUNET_memcpy (copy, message, sizeof(struct GNUNET_MESSENGER_Message));
  
   switch (message->header.kind)
   {
   case GNUNET_MESSENGER_KIND_NAME:
     copy->body.name.name = GNUNET_strdup (message->body.name.name);
     break;
   case GNUNET_MESSENGER_KIND_TEXT:
     copy->body.text.text = GNUNET_strdup (message->body.text.text);
     break;
   case GNUNET_MESSENGER_KIND_FILE:
     copy->body.file.uri = GNUNET_strdup (message->body.file.uri);
     break;
   case GNUNET_MESSENGER_KIND_PRIVATE:
     copy->body.privacy.data = copy->body.privacy.length ? GNUNET_malloc (
       copy->body.privacy.length) : NULL;
  
     if (copy->body.privacy.data)
     {
       GNUNET_memcpy (copy->body.privacy.data, message->body.privacy.data,
                      copy->body.privacy.length);
     }
  
     break;
   default:
     break;
   }
  
   return copy;
 }

Referenced by forward_tunnel_message(), handle_room_message(), handle_tunnel_message(), notify_srv_handle_message(), and send_srv_handle_message().

Here is the caller graph for this function:

◆ cleanup_message()

void cleanup_message ( struct GNUNET_MESSENGER_Message * message )

Frees the messages body memory.

Parameters

[in,out] message Message

Definition at line 137 of file messenger_api_message.c.

 {
   GNUNET_assert (message);
  
   destroy_message_body (message->header.kind, &(message->body));
 }

References GNUNET_MESSENGER_Message::body, destroy_message_body(), GNUNET_assert, GNUNET_MESSENGER_Message::header, and GNUNET_MESSENGER_MessageHeader::kind.

Referenced by check_recv_message(), check_send_message(), handle_recv_message(), handle_send_message(), and handle_tunnel_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ destroy_message()

void destroy_message ( struct GNUNET_MESSENGER_Message * message )

Destroys a message and frees its memory fully.

Parameters

[in,out] message Message

Definition at line 146 of file messenger_api_message.c.

 {
   GNUNET_assert (message);
  
   destroy_message_body (message->header.kind, &(message->body));
  
   GNUNET_free (message);
 }

References GNUNET_MESSENGER_Message::body, destroy_message_body(), GNUNET_assert, GNUNET_free, GNUNET_MESSENGER_Message::header, and GNUNET_MESSENGER_MessageHeader::kind.

Referenced by callback_set_handle_name(), create_message_peer(), forward_tunnel_message(), get_store_message(), handle_delete_message(), handle_room_message(), iterate_destroy_message(), iterate_destroy_messages(), notify_srv_handle_message(), send_tunnel_message(), set_srv_handle_ego(), and update_room_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_message_session_bound()

int is_message_session_bound ( const struct GNUNET_MESSENGER_Message * message )

Returns if the message should be bound to a member session.

Parameters

[in] message Message

Returns: GNUNET_YES or GNUNET_NO

Definition at line 157 of file messenger_api_message.c.

 {
   GNUNET_assert (message);
  
   if ((GNUNET_MESSENGER_KIND_JOIN == message->header.kind) ||
       (GNUNET_MESSENGER_KIND_LEAVE == message->header.kind) ||
       (GNUNET_MESSENGER_KIND_NAME == message->header.kind) ||
       (GNUNET_MESSENGER_KIND_KEY == message->header.kind) ||
       (GNUNET_MESSENGER_KIND_ID == message->header.kind))
     return GNUNET_YES;
   else
     return GNUNET_NO;
 }

References GNUNET_assert, GNUNET_MESSENGER_KIND_ID, GNUNET_MESSENGER_KIND_JOIN, GNUNET_MESSENGER_KIND_KEY, GNUNET_MESSENGER_KIND_LEAVE, GNUNET_MESSENGER_KIND_NAME, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_Message::header, and GNUNET_MESSENGER_MessageHeader::kind.

Referenced by send_srv_room_message(), and update_member_session_history().

Here is the caller graph for this function:

◆ get_message_kind_size()

uint16_t get_message_kind_size	(	enum GNUNET_MESSENGER_MessageKind	kind,
		int	include_header
	)

Returns the minimal size in bytes to encode a message of a specific kind.

Parameters

[in]	kind	Kind of message
[in]	include_header	Flag to include header

Returns: Minimal size to encode

Definition at line 252 of file messenger_api_message.c.

 {
   uint16_t length = 0;
  
   if (GNUNET_YES == include_header)
   {
     length += member_size (struct GNUNET_MESSENGER_Message, header.timestamp);
     length += member_size (struct GNUNET_MESSENGER_Message, header.sender_id);
     length += member_size (struct GNUNET_MESSENGER_Message, header.previous);
   }
  
   length += sizeof(kind_t);
  
   return length + get_message_body_kind_size (kind);
 }

References get_message_body_kind_size(), GNUNET_YES, GNUNET_MESSENGER_Message::header, member_size, GNUNET_MESSENGER_MessageHeader::previous, GNUNET_MESSENGER_MessageHeader::sender_id, and GNUNET_MESSENGER_MessageHeader::timestamp.

Referenced by calc_usual_padding(), check_recv_message(), check_send_message(), check_tunnel_message(), decode_message(), get_message_size(), and get_store_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_message_size()

uint16_t get_message_size	(	const struct GNUNET_MESSENGER_Message *	message,
		int	include_header
	)

Returns the exact size in bytes to encode a given message.

Parameters

[in]	message	Message
[in]	include_header	Flag to include header

Returns: Size to encode

Definition at line 308 of file messenger_api_message.c.

 {
   GNUNET_assert (message);
  
   uint16_t length = 0;
  
   if (GNUNET_YES == include_header)
     length += GNUNET_IDENTITY_signature_get_length (
       &(message->header.signature));
  
   length += get_message_kind_size (message->header.kind, include_header);
   length += get_message_body_size (message->header.kind, &(message->body));
  
   return length;
 }

References GNUNET_MESSENGER_Message::body, get_message_body_size(), get_message_kind_size(), GNUNET_assert, GNUNET_IDENTITY_signature_get_length(), GNUNET_YES, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageHeader::kind, and GNUNET_MESSENGER_MessageHeader::signature.

Referenced by GNUNET_MESSENGER_send_message(), iterate_save_messages(), notify_srv_handle_message(), and pack_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ encode_message()

void encode_message	(	const struct GNUNET_MESSENGER_Message *	message,
		uint16_t	length,
		char *	buffer,
		int	include_header
	)

Encodes a given message into a buffer of a maximal length in bytes.

Parameters

[in]	message	Message
[in]	length	Maximal length to encode
[out]	buffer	Buffer
[in]	include_header	Flag to include header

Definition at line 513 of file messenger_api_message.c.

 {
   GNUNET_assert ((message) && (buffer));
  
   uint16_t offset = 0;
  
   if (GNUNET_YES == include_header)
     encode_step_signature (buffer, offset, &(message->header.signature),
                            length);
  
   const kind_t kind = GNUNET_htobe32 ((kind_t) message->header.kind);
  
   if (GNUNET_YES == include_header)
   {
     encode_step (buffer, offset, &(message->header.timestamp));
     encode_step (buffer, offset, &(message->header.sender_id));
     encode_step (buffer, offset, &(message->header.previous));
   }
  
   encode_step (buffer, offset, &kind);
  
   encode_message_body (message->header.kind, &(message->body), length, buffer,
                        offset);
 }

References GNUNET_MESSENGER_Message::body, encode_message_body(), encode_step, encode_step_signature, GNUNET_assert, GNUNET_htobe32, GNUNET_YES, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_MessageHeader::previous, GNUNET_MESSENGER_MessageHeader::sender_id, GNUNET_MESSENGER_MessageHeader::signature, and GNUNET_MESSENGER_MessageHeader::timestamp.

Referenced by GNUNET_MESSENGER_send_message(), iterate_save_messages(), notify_srv_handle_message(), and pack_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ decode_message()

int decode_message	(	struct GNUNET_MESSENGER_Message *	message,
		uint16_t	length,
		const char *	buffer,
		int	include_header,
		uint16_t *	padding
	)

Decodes a message from a given buffer of a maximal length in bytes.

If the buffer is too small for a message of its decoded kind the function fails with resulting GNUNET_NO after decoding only the messages header.

On success the function returns GNUNET_YES.

Parameters

[out]	message	Message
[in]	length	Maximal length to decode
[in]	buffer	Buffer
[in]	include_header	Flag to include header
[out]	padding	Padding

Returns: GNUNET_YES on success, otherwise GNUNET_NO

Definition at line 681 of file messenger_api_message.c.

 {
   GNUNET_assert (
     (message) &&
     (buffer) &&
     (length >= get_message_kind_size (GNUNET_MESSENGER_KIND_UNKNOWN,
                                       include_header))
     );
  
   uint16_t offset = 0;
  
   if (GNUNET_YES == include_header)
   {
     ssize_t result = GNUNET_IDENTITY_read_signature_from_buffer (
       &(message->header.signature), buffer, length - offset
       );
  
     if (result < 0)
       return GNUNET_NO;
     else
       offset += result;
   }
  
   const uint16_t count = length - offset;
  
   if (count < get_message_kind_size (GNUNET_MESSENGER_KIND_UNKNOWN,
                                      include_header))
     return GNUNET_NO;
  
   kind_t kind;
  
   if (GNUNET_YES == include_header)
   {
     decode_step (buffer, offset, &(message->header.timestamp));
     decode_step (buffer, offset, &(message->header.sender_id));
     decode_step (buffer, offset, &(message->header.previous));
   }
  
   decode_step (buffer, offset, &kind);
  
   message->header.kind = (enum GNUNET_MESSENGER_MessageKind) GNUNET_be32toh (
     kind);
  
   if (count < get_message_kind_size (message->header.kind, include_header))
     return GNUNET_NO;
  
   const uint16_t result = decode_message_body (&(message->header.kind),
                                                &(message->body), length, buffer,
                                                offset);
  
   if (padding)
     *padding = result;
  
   return GNUNET_YES;
 }

References GNUNET_MESSENGER_Message::body, decode_message_body(), decode_step, get_message_kind_size(), GNUNET_assert, GNUNET_be32toh, GNUNET_IDENTITY_read_signature_from_buffer(), GNUNET_MESSENGER_KIND_UNKNOWN, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_MessageHeader::previous, result, GNUNET_MESSENGER_MessageHeader::sender_id, GNUNET_MESSENGER_MessageHeader::signature, and GNUNET_MESSENGER_MessageHeader::timestamp.

Referenced by check_recv_message(), check_send_message(), check_tunnel_message(), get_store_message(), handle_recv_message(), handle_send_message(), and handle_tunnel_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ hash_message()

void hash_message	(	const struct GNUNET_MESSENGER_Message *	message,
		uint16_t	length,
		const char *	buffer,
		struct GNUNET_HashCode *	hash
	)

Calculates a hash of a given buffer with a length in bytes from a message.

Parameters

[in]	message	Message
[in]	length	Length of buffer
[in]	buffer	Buffer
[out]	hash	Hash

Definition at line 784 of file messenger_api_message.c.

 {
   GNUNET_assert ((message) && (buffer) && (hash));
  
   const ssize_t offset = GNUNET_IDENTITY_signature_get_length (
     &(message->header.signature)
     );
  
   GNUNET_CRYPTO_hash (buffer + offset, length - offset, hash);
 }

References GNUNET_assert, GNUNET_CRYPTO_hash(), GNUNET_IDENTITY_signature_get_length(), GNUNET_MESSENGER_Message::header, and GNUNET_MESSENGER_MessageHeader::signature.

Referenced by check_tunnel_message(), get_store_message(), handle_tunnel_message(), and pack_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sign_message()

void sign_message	(	struct GNUNET_MESSENGER_Message *	message,
		uint16_t	length,
		char *	buffer,
		const struct GNUNET_HashCode *	hash,
		const struct GNUNET_MESSENGER_Ego *	ego
	)

Signs the hash of a message with a given ego and writes the signature into the buffer as well.

Parameters

[in,out]	message	Message
[in]	length	Length of buffer
[out]	buffer	Buffer
[in]	hash	Hash of message
[in]	ego	EGO

Definition at line 800 of file messenger_api_message.c.

 {
   GNUNET_assert ((message) && (buffer) && (hash) && (ego));
  
   struct GNUNET_MESSENGER_MessageSignature signature;
  
   signature.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE);
   signature.purpose.size = htonl (sizeof(signature));
  
   GNUNET_memcpy (&(signature.hash), hash, sizeof(struct GNUNET_HashCode));
   GNUNET_IDENTITY_sign (&(ego->priv), &signature, &(message->header.signature));
  
   uint16_t offset = 0;
   encode_step_signature (buffer, offset, &(message->header.signature), length);
 }

References encode_step_signature, GNUNET_assert, GNUNET_IDENTITY_sign, GNUNET_memcpy, GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE, GNUNET_MESSENGER_MessageSignature::hash, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_Ego::priv, GNUNET_CRYPTO_EccSignaturePurpose::purpose, GNUNET_MESSENGER_MessageSignature::purpose, GNUNET_MESSENGER_MessageHeader::signature, and GNUNET_CRYPTO_EccSignaturePurpose::size.

Referenced by pack_message().

Here is the caller graph for this function:

◆ verify_message()

int verify_message	(	const struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_HashCode *	hash,
		const struct GNUNET_IDENTITY_PublicKey *	key
	)

Verifies the signature of a given message and its hash with a specific public key.

The function returns GNUNET_OK if the signature was valid, otherwise GNUNET_SYSERR.

Parameters

[in]	message	Message
[in]	hash	Hash of message
[in]	key	Public key of EGO

Returns: GNUNET_OK on success, otherwise GNUNET_SYSERR

Definition at line 822 of file messenger_api_message.c.

 {
   GNUNET_assert ((message) && (hash) && (key));
  
   if (ntohl (key->type) != ntohl (message->header.signature.type))
     return GNUNET_SYSERR;
  
   struct GNUNET_MESSENGER_MessageSignature signature;
  
   signature.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE);
   signature.purpose.size = htonl (sizeof(signature));
  
   GNUNET_memcpy (&(signature.hash), hash, sizeof(struct GNUNET_HashCode));
  
   return GNUNET_IDENTITY_signature_verify (
     GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE, &signature,
     &(message->header.signature), key);
 }

References GNUNET_assert, GNUNET_IDENTITY_signature_verify, GNUNET_memcpy, GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE, GNUNET_SYSERR, GNUNET_MESSENGER_MessageSignature::hash, GNUNET_MESSENGER_Message::header, key, GNUNET_CRYPTO_EccSignaturePurpose::purpose, GNUNET_MESSENGER_MessageSignature::purpose, GNUNET_MESSENGER_MessageHeader::signature, GNUNET_CRYPTO_EccSignaturePurpose::size, and GNUNET_IDENTITY_Signature::type.

Referenced by verify_member_session_as_sender().

Here is the caller graph for this function:

◆ encrypt_message()

int encrypt_message	(	struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_IDENTITY_PublicKey *	key
	)

Encrypts a message using a given public key and replaces its body and kind with the now private encrypted message.

The function returns GNUNET_YES if the operation succeeded, otherwise GNUNET_NO.

Parameters

[in,out]	message	Message
[in]	key	Public key of EGO

Returns: GNUNET_YES on success, otherwise GNUNET_NO

Definition at line 845 of file messenger_api_message.c.

 {
   GNUNET_assert ((message) && (key));
  
   struct GNUNET_MESSENGER_ShortMessage shortened;
  
   fold_short_message (message, &shortened);
  
   const uint16_t length = get_short_message_size (&shortened, GNUNET_YES);
   const uint16_t padded_length = calc_padded_length (
     length + GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES
     );
  
   message->header.kind = GNUNET_MESSENGER_KIND_PRIVATE;
   message->body.privacy.data = GNUNET_malloc (padded_length);
   message->body.privacy.length = padded_length;
  
   const uint16_t encoded_length = (
     padded_length - GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES
     );
  
   encode_short_message (&shortened, encoded_length, message->body.privacy.data);
  
   if (GNUNET_OK != GNUNET_IDENTITY_encrypt (message->body.privacy.data,
                                             encoded_length,
                                             key,
                                             message->body.privacy.data,
                                             padded_length))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Encrypting message failed!\n");
  
     unfold_short_message (&shortened, message);
     return GNUNET_NO;
   }
  
   destroy_message_body (shortened.kind, &(shortened.body));
   return GNUNET_YES;
 }

References GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_ShortMessage::body, calc_padded_length(), GNUNET_MESSENGER_MessagePrivate::data, destroy_message_body(), encode_short_message(), fold_short_message(), get_short_message_size(), GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_IDENTITY_encrypt(), GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES, GNUNET_log, GNUNET_malloc, GNUNET_MESSENGER_KIND_PRIVATE, GNUNET_NO, GNUNET_OK, GNUNET_YES, GNUNET_MESSENGER_Message::header, key, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_ShortMessage::kind, GNUNET_MESSENGER_MessagePrivate::length, GNUNET_MESSENGER_MessageBody::privacy, and unfold_short_message().

Referenced by handle_send_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ decrypt_message()

int decrypt_message	(	struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_IDENTITY_PrivateKey *	key
	)

Decrypts a private message using a given private key and replaces its body and kind with the inner encrypted message.

The function returns GNUNET_YES if the operation succeeded, otherwise GNUNET_NO.

Parameters

[in,out]	message	Message
[in]	key	Private key of EGO

Returns: GNUNET_YES on success, otherwise GNUNET_NO

Definition at line 887 of file messenger_api_message.c.

 {
   GNUNET_assert ((message) && (key));
  
   const uint16_t padded_length = message->body.privacy.length;
  
   if (padded_length < GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                 "Message length too short to decrypt!\n");
  
     return GNUNET_NO;
   }
  
   const uint16_t encoded_length = (
     padded_length - GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES
     );
  
   if (GNUNET_OK != GNUNET_IDENTITY_decrypt (message->body.privacy.data,
                                             padded_length,
                                             key,
                                             message->body.privacy.data,
                                             encoded_length))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Decrypting message failed!\n");
  
     return GNUNET_NO;
   }
  
   struct GNUNET_MESSENGER_ShortMessage shortened;
  
   if (GNUNET_YES != decode_short_message (&shortened,
                                           encoded_length,
                                           message->body.privacy.data))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                 "Decoding decrypted message failed!\n");
  
     return GNUNET_NO;
   }
  
   unfold_short_message (&shortened, message);
   return GNUNET_YES;
 }

References GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_MessagePrivate::data, decode_short_message(), GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_IDENTITY_decrypt(), GNUNET_IDENTITY_ENCRYPT_OVERHEAD_BYTES, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_YES, key, GNUNET_MESSENGER_MessagePrivate::length, GNUNET_MESSENGER_MessageBody::privacy, and unfold_short_message().

Referenced by notify_srv_handle_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pack_message()

struct GNUNET_MQ_Envelope* pack_message	(	struct GNUNET_MESSENGER_Message *	message,
		struct GNUNET_HashCode *	hash,
		const struct GNUNET_MESSENGER_Ego *	ego,
		int	mode
	)

Encodes the message to pack it into a newly allocated envelope if mode is equal to GNUNET_MESSENGER_PACK_MODE_ENVELOPE.

Independent of the mode the message will be hashed if hash is not NULL and it will be signed if the ego is not NULL.

Parameters

[out]	message	Message
[out]	hash	Hash of message
[in]	ego	EGO to sign
[in]	mode	Mode of packing

Returns: Envelope or NULL

Definition at line 935 of file messenger_api_message.c.

 {
   GNUNET_assert (message);
  
   if (ego)
     message->header.signature.type = ego->priv.type;
  
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Packing message kind=%u and sender: %s\n",
               message->header.kind, GNUNET_sh2s (&(message->header.sender_id)));
  
   struct GNUNET_MessageHeader *header;
  
   const uint16_t length = get_message_size (message, GNUNET_YES);
   const uint16_t padded_length = calc_padded_length (length);
  
   struct GNUNET_MQ_Envelope *env;
   char *buffer;
  
   if (GNUNET_MESSENGER_PACK_MODE_ENVELOPE == mode)
   {
     env = GNUNET_MQ_msg_extra (header, padded_length,
                                GNUNET_MESSAGE_TYPE_CADET_CLI);
  
     buffer = (char*) &(header[1]);
   }
   else
   {
     env = NULL;
  
     buffer = GNUNET_malloc (padded_length);
   }
  
   encode_message (message, padded_length, buffer, GNUNET_YES);
  
   if (hash)
   {
     hash_message (message, length, buffer, hash);
  
     if (ego)
       sign_message (message, length, buffer, hash, ego);
   }
  
   if (GNUNET_MESSENGER_PACK_MODE_ENVELOPE != mode)
     GNUNET_free (buffer);
  
   return env;
 }

References calc_padded_length(), encode_message(), env, get_message_size(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_malloc, GNUNET_MESSAGE_TYPE_CADET_CLI, GNUNET_MESSENGER_PACK_MODE_ENVELOPE, GNUNET_MQ_msg_extra, GNUNET_sh2s(), GNUNET_YES, hash_message(), GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageHeader::kind, mode, GNUNET_MESSENGER_Ego::priv, GNUNET_MESSENGER_MessageHeader::sender_id, sign_message(), GNUNET_MESSENGER_MessageHeader::signature, GNUNET_IDENTITY_PrivateKey::type, and GNUNET_IDENTITY_Signature::type.

Referenced by forward_tunnel_message(), iterate_send_room_message(), and pack_srv_room_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ filter_message_sending()

int filter_message_sending ( const struct GNUNET_MESSENGER_Message * message )

Returns if a specific kind of message should be sent by a client.

The function returns GNUNET_YES or GNUNET_NO for recommendations and GNUNET_SYSERR for specific kinds of messages which should not be sent manually at all.

Parameters

[in] message Message

Definition at line 989 of file messenger_api_message.c.

 {
   switch (message->header.kind)
   {
   case GNUNET_MESSENGER_KIND_INFO:
     return GNUNET_SYSERR; // Reserved for connection handling only!
   case GNUNET_MESSENGER_KIND_JOIN:
     return GNUNET_NO; // Use #GNUNET_MESSENGER_enter_room(...) instead!
   case GNUNET_MESSENGER_KIND_LEAVE:
     return GNUNET_NO; // Use #GNUNET_MESSENGER_close_room(...) instead!
   case GNUNET_MESSENGER_KIND_NAME:
     return GNUNET_YES;
   case GNUNET_MESSENGER_KIND_KEY:
     return GNUNET_NO; // Use #GNUNET_MESSENGER_update(...) instead!
   case GNUNET_MESSENGER_KIND_PEER:
     return GNUNET_NO; // Use #GNUNET_MESSENGER_open_room(...) instead!
   case GNUNET_MESSENGER_KIND_ID:
     return GNUNET_SYSERR; // Reserved for member id handling only!
   case GNUNET_MESSENGER_KIND_MISS:
     return GNUNET_SYSERR; // Reserved for connection handling only!
   case GNUNET_MESSENGER_KIND_MERGE:
     return GNUNET_YES;
   case GNUNET_MESSENGER_KIND_REQUEST:
     return GNUNET_YES;
   case GNUNET_MESSENGER_KIND_INVITE:
     return GNUNET_YES;
   case GNUNET_MESSENGER_KIND_TEXT:
     return GNUNET_YES;
   case GNUNET_MESSENGER_KIND_FILE:
     return GNUNET_YES;
   case GNUNET_MESSENGER_KIND_PRIVATE:
     return GNUNET_NO; // Use #GNUNET_MESSENGER_send_message(...) with a contact instead!
   case GNUNET_MESSENGER_KIND_DELETE:
     return GNUNET_YES;
   default:
     return GNUNET_SYSERR;
   }
 }

Referenced by check_send_message(), and GNUNET_MESSENGER_send_message().

Here is the caller graph for this function:

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ GNUNET_MESSENGER_MAX_MESSAGE_SIZE

◆ GNUNET_MESSENGER_PADDING_MIN

◆ GNUNET_MESSENGER_PADDING_LEVEL0

◆ GNUNET_MESSENGER_PADDING_LEVEL1

◆ GNUNET_MESSENGER_PADDING_LEVEL2

◆ GNUNET_MESSENGER_PACK_MODE_ENVELOPE

◆ GNUNET_MESSENGER_PACK_MODE_UNKNOWN

Function Documentation

◆ create_message()

◆ copy_message()

◆ cleanup_message()

◆ destroy_message()

◆ is_message_session_bound()

◆ get_message_kind_size()

◆ get_message_size()

◆ encode_message()

◆ decode_message()

◆ hash_message()

◆ sign_message()

◆ verify_message()

◆ encrypt_message()

◆ decrypt_message()

◆ pack_message()

◆ filter_message_sending()