messenger_api_message.h File Reference

#include "gnunet_util_lib.h"
#include "gnunet_messenger_service.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
#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)

Typedefs
typedef void(*	GNUNET_MESSENGER_SignFunction) (const void *cls, struct GNUNET_MESSENGER_Message *message, uint16_t length, char *buffer, const struct GNUNET_HashCode *hash)

Enumerations
enum	GNUNET_MESSENGER_PackMode { GNUNET_MESSENGER_PACK_MODE_ENVELOPE = 0x1 , 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	copy_message_header (struct GNUNET_MESSENGER_Message *message, const struct GNUNET_MESSENGER_MessageHeader *header)
	Copy message header details from another message to 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...
enum GNUNET_GenericReturnValue	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, enum GNUNET_GenericReturnValue 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, enum GNUNET_GenericReturnValue 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, enum GNUNET_GenericReturnValue include_header)
	Encodes a given message into a buffer of a maximal length in bytes. More...
enum GNUNET_GenericReturnValue	decode_message (struct GNUNET_MESSENGER_Message *message, uint16_t length, const char *buffer, enum GNUNET_GenericReturnValue 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_CRYPTO_PrivateKey *key)
	Signs the hash of a message with a given private key and writes the signature into the buffer as well. More...
void	sign_message_by_peer (struct GNUNET_MESSENGER_Message *message, uint16_t length, char *buffer, const struct GNUNET_HashCode *hash, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Signs the hash of a message with the peer identity of a given config and writes the signature into the buffer as well. More...
enum GNUNET_GenericReturnValue	verify_message (const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash, const struct GNUNET_CRYPTO_PublicKey *key)
	Verifies the signature of a given message and its hash with a specific public key. More...
enum GNUNET_GenericReturnValue	verify_message_by_peer (const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash, const struct GNUNET_PeerIdentity *identity)
	Verifies the signature of a given message and its hash with a specific peer's identity. More...
enum GNUNET_GenericReturnValue	encrypt_message (struct GNUNET_MESSENGER_Message *message, const struct GNUNET_CRYPTO_PublicKey *key)
	Encrypts a message using a given public key and replaces its body and kind with the now private encrypted message. More...
enum GNUNET_GenericReturnValue	decrypt_message (struct GNUNET_MESSENGER_Message *message, const struct GNUNET_CRYPTO_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_MESSENGER_Message *	transcribe_message (const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_CRYPTO_PublicKey *key)
	Transcribes a message as a new transcript message using a given public key from the recipient of the encrypted message content. More...
enum GNUNET_GenericReturnValue	read_transcript_message (struct GNUNET_MESSENGER_Message *message)
	Read the original message from a transcript message 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 GNUNET_MESSENGER_SignFunction sign, enum GNUNET_MESSENGER_PackMode mode, const void *cls)
	Encodes the message to pack it into a newly allocated envelope if mode is equal to GNUNET_MESSENGER_PACK_MODE_ENVELOPE. More...
enum GNUNET_GenericReturnValue	is_peer_message (const struct GNUNET_MESSENGER_Message *message)
	Returns whether a specific kind of message can be sent by the service without usage of a clients private key. More...
enum GNUNET_GenericReturnValue	is_service_message (const struct GNUNET_MESSENGER_Message *message)
	Returns whether a specific kind of message contains service critical information. More...
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. More...
const struct GNUNET_ShortHashCode *	get_message_discourse (const struct GNUNET_MESSENGER_Message *message)
	Returns the discourse hash of a message depending on its kind. More...

Macro Definition Documentation

GNUNET_MESSENGER_MAX_MESSAGE_SIZE

#define GNUNET_MESSENGER_MAX_MESSAGE_SIZE

Value:

                                           (GNUNET_MAX_MESSAGE_SIZE \
                                           - GNUNET_MIN_MESSAGE_SIZE)

Definition at line 33 of file messenger_api_message.h.

GNUNET_MESSENGER_PADDING_MIN

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

Definition at line 36 of file messenger_api_message.h.

GNUNET_MESSENGER_PADDING_LEVEL0

#define GNUNET_MESSENGER_PADDING_LEVEL0   (512)

Definition at line 37 of file messenger_api_message.h.

GNUNET_MESSENGER_PADDING_LEVEL1

#define GNUNET_MESSENGER_PADDING_LEVEL1   (4096)

Definition at line 38 of file messenger_api_message.h.

GNUNET_MESSENGER_PADDING_LEVEL2

#define GNUNET_MESSENGER_PADDING_LEVEL2   (32768)

Definition at line 39 of file messenger_api_message.h.

Typedef Documentation

GNUNET_MESSENGER_SignFunction

typedef void(* GNUNET_MESSENGER_SignFunction) (const void *cls, struct GNUNET_MESSENGER_Message *message, uint16_t length, char *buffer, const struct GNUNET_HashCode *hash)

Definition at line 281 of file messenger_api_message.h.

Enumeration Type Documentation

GNUNET_MESSENGER_PackMode

enum GNUNET_MESSENGER_PackMode

Enumerator
GNUNET_MESSENGER_PACK_MODE_ENVELOPE
GNUNET_MESSENGER_PACK_MODE_UNKNOWN

Definition at line 289 of file messenger_api_message.h.

{
  GNUNET_MESSENGER_PACK_MODE_ENVELOPE = 0x1,
  GNUNET_MESSENGER_PACK_MODE_UNKNOWN = 0x0,
};

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 48 of file messenger_api_message.c.

{
  struct GNUNET_MESSENGER_Message *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;
  case GNUNET_MESSENGER_KIND_TICKET:
    message->body.ticket.identifier = NULL;
    break;
  case GNUNET_MESSENGER_KIND_TRANSCRIPT:
    message->body.transcript.length = 0;
    message->body.transcript.data = NULL;
    break;
  case GNUNET_MESSENGER_KIND_TAG:
    message->body.tag.tag = NULL;
    break;
  case GNUNET_MESSENGER_KIND_TALK:
    message->body.talk.length = 0;
    message->body.talk.data = NULL;
    break;
  default:
    break;
  }
 
  return message;
}

References GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_MessagePrivate::data, GNUNET_MESSENGER_MessageTranscript::data, GNUNET_MESSENGER_MessageTalk::data, GNUNET_MESSENGER_MessageBody::file, GNUNET_MESSENGER_KIND_FILE, GNUNET_MESSENGER_KIND_NAME, GNUNET_MESSENGER_KIND_PRIVATE, GNUNET_MESSENGER_KIND_TAG, GNUNET_MESSENGER_KIND_TALK, GNUNET_MESSENGER_KIND_TEXT, GNUNET_MESSENGER_KIND_TICKET, GNUNET_MESSENGER_KIND_TRANSCRIPT, GNUNET_new, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageTicket::identifier, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_MessagePrivate::length, GNUNET_MESSENGER_MessageTranscript::length, GNUNET_MESSENGER_MessageTalk::length, GNUNET_MESSENGER_MessageName::name, GNUNET_MESSENGER_MessageBody::name, GNUNET_MESSENGER_MessageBody::privacy, GNUNET_MESSENGER_MessageTag::tag, GNUNET_MESSENGER_MessageBody::tag, GNUNET_MESSENGER_MessageBody::talk, GNUNET_MESSENGER_MessageText::text, GNUNET_MESSENGER_MessageBody::text, GNUNET_MESSENGER_MessageBody::ticket, GNUNET_MESSENGER_MessageBody::transcript, and GNUNET_MESSENGER_MessageFile::uri.

Referenced by create_message_connection(), create_message_delete(), create_message_id(), create_message_info(), 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_subscribe(), get_store_message(), and transcribe_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 93 of file messenger_api_message.c.

{
  struct GNUNET_MESSENGER_Message *copy;
 
  GNUNET_assert (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 = message->body.name.name? GNUNET_strdup (
      message->body.name.name) : NULL;
    break;
  case GNUNET_MESSENGER_KIND_TEXT:
    copy->body.text.text = message->body.text.text? GNUNET_strdup (
      message->body.text.text) : NULL;
    break;
  case GNUNET_MESSENGER_KIND_FILE:
    copy->body.file.uri = message->body.file.uri? GNUNET_strdup (
      message->body.file.uri) : NULL;
    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;
  case GNUNET_MESSENGER_KIND_TICKET:
    copy->body.ticket.identifier = message->body.ticket.identifier?
                                   GNUNET_strdup (
      message->body.ticket.identifier) : NULL;
    break;
  case GNUNET_MESSENGER_KIND_TRANSCRIPT:
    copy->body.transcript.data = copy->body.transcript.length ? GNUNET_malloc (
      copy->body.transcript.length) : NULL;
 
    if (copy->body.transcript.data)
      GNUNET_memcpy (copy->body.transcript.data, message->body.transcript.data,
                     copy->body.transcript.length);
 
    break;
  case GNUNET_MESSENGER_KIND_TAG:
    copy->body.tag.tag = message->body.tag.tag? GNUNET_strdup (
      message->body.tag.tag) : NULL;
    break;
  case GNUNET_MESSENGER_KIND_TALK:
    copy->body.talk.data = copy->body.talk.length ? GNUNET_malloc (
      copy->body.talk.length) : NULL;
 
    if (copy->body.talk.data)
      GNUNET_memcpy (copy->body.talk.data, message->body.talk.data,
                     copy->body.talk.length);
 
    break;
  default:
    break;
  }
 
  return copy;
}

References GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_MessagePrivate::data, GNUNET_MESSENGER_MessageTranscript::data, GNUNET_MESSENGER_MessageTalk::data, GNUNET_MESSENGER_MessageBody::file, GNUNET_assert, GNUNET_malloc, GNUNET_memcpy, GNUNET_MESSENGER_KIND_FILE, GNUNET_MESSENGER_KIND_NAME, GNUNET_MESSENGER_KIND_PRIVATE, GNUNET_MESSENGER_KIND_TAG, GNUNET_MESSENGER_KIND_TALK, GNUNET_MESSENGER_KIND_TEXT, GNUNET_MESSENGER_KIND_TICKET, GNUNET_MESSENGER_KIND_TRANSCRIPT, GNUNET_new, GNUNET_strdup, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageTicket::identifier, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_MessagePrivate::length, GNUNET_MESSENGER_MessageTranscript::length, GNUNET_MESSENGER_MessageTalk::length, GNUNET_MESSENGER_MessageName::name, GNUNET_MESSENGER_MessageBody::name, GNUNET_MESSENGER_MessageBody::privacy, GNUNET_MESSENGER_MessageTag::tag, GNUNET_MESSENGER_MessageBody::tag, GNUNET_MESSENGER_MessageBody::talk, GNUNET_MESSENGER_MessageText::text, GNUNET_MESSENGER_MessageBody::text, GNUNET_MESSENGER_MessageBody::ticket, GNUNET_MESSENGER_MessageBody::transcript, and GNUNET_MESSENGER_MessageFile::uri.

Referenced by enqueue_message_control(), forward_tunnel_message(), GNUNET_MESSENGER_send_message(), handle_private_message(), handle_room_message(), handle_transcript_message(), handle_tunnel_message(), and send_srv_handle_message().

Here is the caller graph for this function:

copy_message_header()

void copy_message_header	(	struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_MESSENGER_MessageHeader *	header
	)

Copy message header details from another message to a given message.

Parameters

[in,out]	message	Message
[in]	header	Message header

Definition at line 161 of file messenger_api_message.c.

{
  enum GNUNET_MESSENGER_MessageKind kind;
 
  GNUNET_assert ((message) && (header));
 
  kind = message->header.kind;
 
  GNUNET_memcpy (&(message->header), header,
                 sizeof(struct GNUNET_MESSENGER_MessageHeader));
 
  message->header.kind = kind;
}

References GNUNET_assert, GNUNET_memcpy, GNUNET_MESSENGER_Message::header, and GNUNET_MESSENGER_MessageHeader::kind.

Referenced by handle_room_message(), and handle_transcript_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 224 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 233 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 clear_queue_messages(), create_message_peer(), dequeue_from_messages(), dequeue_message_from_room(), destroy_message_control(), enqueue_to_messages(), forward_tunnel_message(), get_store_message(), handle_delete_message(), handle_discourse_subscription(), handle_private_message(), handle_transcript_message(), iterate_destroy_message(), iterate_destroy_messages(), iterate_destroy_subscription(), iterate_flag_for_cleanup_discourse_message(), keep_subscription_alive(), send_message_to_room_with_key(), send_tunnel_message(), task_message_control(), and update_room_message().

Here is the call graph for this function:

Here is the caller graph for this function:

is_message_session_bound()

enum GNUNET_GenericReturnValue 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 244 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 enqueue_message_to_room(), 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,
		enum GNUNET_GenericReturnValue	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 367 of file messenger_api_message.c.

{
  uint16_t length;
  
  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,
		enum GNUNET_GenericReturnValue	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 437 of file messenger_api_message.c.

{
  uint16_t length;
 
  GNUNET_assert (message);
  
  length = 0;
 
  if (GNUNET_YES == include_header)
    length += GNUNET_CRYPTO_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_CRYPTO_signature_get_length(), GNUNET_YES, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageHeader::kind, and GNUNET_MESSENGER_MessageHeader::signature.

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

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,
		enum GNUNET_GenericReturnValue	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 709 of file messenger_api_message.c.

{
  uint16_t offset;
  kind_t kind;
 
  GNUNET_assert ((message) && (buffer));
 
  offset = 0;
 
  if (GNUNET_YES == include_header)
    encode_step_signature (buffer, offset, &(message->header.signature),
                           length);
 
  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 iterate_save_messages(), notify_srv_handle_message(), pack_message(), and send_message_to_room().

Here is the call graph for this function:

Here is the caller graph for this function:

decode_message()

enum GNUNET_GenericReturnValue decode_message	(	struct GNUNET_MESSENGER_Message *	message,
		uint16_t	length,
		const char *	buffer,
		enum GNUNET_GenericReturnValue	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 970 of file messenger_api_message.c.

{
  uint16_t offset;
  uint16_t count;
  kind_t kind;
 
  GNUNET_assert (
    (message) &&
    (buffer) &&
    (length >= get_message_kind_size (GNUNET_MESSENGER_KIND_UNKNOWN,
                                      include_header))
    );
 
  offset = 0;
 
  if (GNUNET_YES == include_header)
  {
    ssize_t result;
 
    result = GNUNET_CRYPTO_read_signature_from_buffer (
      &(message->header.signature), buffer, length - offset);
 
    if (result < 0)
      return GNUNET_NO;
    else
      offset += result;
  }
 
  count = length - offset;
  if (count < get_message_kind_size (GNUNET_MESSENGER_KIND_UNKNOWN,
                                     include_header))
    return GNUNET_NO;
 
  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);
  kind = GNUNET_be32toh (kind);
 
  message->header.kind = (enum GNUNET_MESSENGER_MessageKind) kind;
 
  if (count < get_message_kind_size (message->header.kind, include_header))
    return GNUNET_NO;
 
  {
    uint16_t result;
    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_CRYPTO_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 1080 of file messenger_api_message.c.

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

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

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

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_CRYPTO_PrivateKey *	key
	)

Signs the hash of a message with a given private key 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]	key	Private key

Definition at line 1096 of file messenger_api_message.c.

{
  GNUNET_assert ((message) && (buffer) && (hash) && (key));
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sign message by member: %s\n",
              GNUNET_h2s (hash));
 
  {
    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(signature.hash));
    GNUNET_CRYPTO_sign (key, &signature, &(message->header.signature));
  }
 
  message->header.signature.type = key->type;
 
  {
    uint16_t offset = 0;
    encode_step_signature (buffer, offset, &(message->header.signature), length);
  }
}

References encode_step_signature, GNUNET_assert, GNUNET_CRYPTO_sign, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE, 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_CRYPTO_Signature::type.

Referenced by send_message_to_room().

Here is the call graph for this function:

Here is the caller graph for this function:

sign_message_by_peer()

void sign_message_by_peer	(	struct GNUNET_MESSENGER_Message *	message,
		uint16_t	length,
		char *	buffer,
		const struct GNUNET_HashCode *	hash,
		const struct GNUNET_CONFIGURATION_Handle *	cfg
	)

Signs the hash of a message with the peer identity of a given config 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]	cfg	Peer configuration

Definition at line 1127 of file messenger_api_message.c.

{
  GNUNET_assert ((message) && (buffer) && (hash) && (cfg));
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sign message by peer: %s\n",
              GNUNET_h2s (hash));
 
  {
    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(signature.hash));
    GNUNET_CRYPTO_sign_by_peer_identity (cfg, &(signature.purpose),
                                        &(message->header.signature.
                                          eddsa_signature));
  }
 
  message->header.signature.type = htonl (GNUNET_PUBLIC_KEY_TYPE_EDDSA);
 
  {
    uint16_t offset = 0;
    encode_step_signature (buffer, offset, &(message->header.signature), length);
  }
}

References cfg, encode_step_signature, GNUNET_assert, GNUNET_CRYPTO_sign_by_peer_identity(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_PUBLIC_KEY_TYPE_EDDSA, GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE, GNUNET_MESSENGER_MessageSignature::hash, GNUNET_MESSENGER_Message::header, GNUNET_CRYPTO_EccSignaturePurpose::purpose, GNUNET_MESSENGER_MessageSignature::purpose, GNUNET_MESSENGER_MessageHeader::signature, GNUNET_CRYPTO_EccSignaturePurpose::size, and GNUNET_CRYPTO_Signature::type.

Referenced by sign_srv_room_message_by_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

verify_message()

enum GNUNET_GenericReturnValue verify_message	(	const struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_HashCode *	hash,
		const struct GNUNET_CRYPTO_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

Returns

GNUNET_OK on success, otherwise GNUNET_SYSERR

Definition at line 1159 of file messenger_api_message.c.

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

References GNUNET_assert, GNUNET_CRYPTO_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_CRYPTO_Signature::type.

Referenced by verify_member_session_as_sender().

Here is the caller graph for this function:

verify_message_by_peer()

enum GNUNET_GenericReturnValue verify_message_by_peer	(	const struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_HashCode *	hash,
		const struct GNUNET_PeerIdentity *	identity
	)

Verifies the signature of a given message and its hash with a specific peer's identity.

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

Parameters

[in]	message	Message
[in]	hash	Hash of message
[in]	identity	Peer identity

Returns

GNUNET_OK on success, otherwise GNUNET_SYSERR

Definition at line 1182 of file messenger_api_message.c.

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

References GNUNET_assert, GNUNET_CRYPTO_verify_peer_identity(), GNUNET_memcpy, GNUNET_PUBLIC_KEY_TYPE_EDDSA, GNUNET_SIGNATURE_PURPOSE_CHAT_MESSAGE, GNUNET_SYSERR, GNUNET_MESSENGER_MessageSignature::hash, GNUNET_MESSENGER_Message::header, identity, GNUNET_CRYPTO_EccSignaturePurpose::purpose, GNUNET_MESSENGER_MessageSignature::purpose, GNUNET_MESSENGER_MessageHeader::signature, GNUNET_CRYPTO_EccSignaturePurpose::size, and GNUNET_CRYPTO_Signature::type.

Referenced by get_store_peer_of(), and verify_store_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

encrypt_message()

enum GNUNET_GenericReturnValue encrypt_message	(	struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_CRYPTO_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

Returns

GNUNET_YES on success, otherwise GNUNET_NO

Definition at line 1206 of file messenger_api_message.c.

{
  struct GNUNET_CRYPTO_EcdhePublicKey hpke_key;
  enum GNUNET_GenericReturnValue result;
  struct GNUNET_MESSENGER_ShortMessage shortened;
  uint16_t length, padded_length, encoded_length;
  uint8_t *data;
 
  GNUNET_assert ((message) && (key));
 
  if (GNUNET_YES == is_service_message (message))
    return GNUNET_NO;
 
  fold_short_message (message, &shortened);
 
  length = get_short_message_size (&shortened, GNUNET_YES);
  padded_length = calc_padded_length (length + encryption_overhead);
 
  GNUNET_assert (padded_length >= length + encryption_overhead);
 
  message->header.kind = GNUNET_MESSENGER_KIND_PRIVATE;
  message->body.privacy.data = GNUNET_malloc (padded_length);
  message->body.privacy.length = padded_length;
 
  GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_hpke_pk_to_x25519 (key, &hpke_key));
  encoded_length = (padded_length - encryption_overhead);
 
  GNUNET_assert (padded_length == encoded_length + encryption_overhead);
 
  result = GNUNET_NO;
  data = GNUNET_malloc (encoded_length);
 
  encode_short_message (&shortened, encoded_length, (char *) data);
 
  if (GNUNET_OK != GNUNET_CRYPTO_hpke_seal_oneshot (&hpke_key,
                                                    (uint8_t*) "messenger",
                                                    strlen ("messenger"),
                                                    NULL, 0,
                                                    (uint8_t*) data,
                                                    encoded_length,
                                                    (uint8_t*) message->body.
                                                    privacy.data,
                                                    NULL))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Encrypting message failed!\n");
 
    unfold_short_message (&shortened, message);
    goto cleanup;
  }
 
  destroy_message_body (shortened.kind, &(shortened.body));
  result = GNUNET_YES;
 
cleanup:
  GNUNET_free (data);
  return result;
}

References GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_ShortMessage::body, calc_padded_length(), cleanup(), data, GNUNET_MESSENGER_MessagePrivate::data, destroy_message_body(), encode_short_message(), encryption_overhead, fold_short_message(), get_short_message_size(), GNUNET_assert, GNUNET_CRYPTO_hpke_pk_to_x25519(), GNUNET_CRYPTO_hpke_seal_oneshot(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_malloc, GNUNET_MESSENGER_KIND_PRIVATE, GNUNET_NO, GNUNET_OK, GNUNET_YES, GNUNET_MESSENGER_Message::header, is_service_message(), key, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_ShortMessage::kind, GNUNET_MESSENGER_MessagePrivate::length, GNUNET_MESSENGER_MessageBody::privacy, result, and unfold_short_message().

Referenced by dequeue_message_from_room(), and send_message_to_room_with_key().

Here is the call graph for this function:

Here is the caller graph for this function:

decrypt_message()

enum GNUNET_GenericReturnValue decrypt_message	(	struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_CRYPTO_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

Returns

GNUNET_YES on success, otherwise GNUNET_NO

Definition at line 1267 of file messenger_api_message.c.

{
  struct GNUNET_CRYPTO_EcdhePrivateKey hpke_key;
  enum GNUNET_GenericReturnValue result;
  uint16_t padded_length, encoded_length;
  uint8_t *data;
 
  GNUNET_assert ((message) && (key));
 
  padded_length = message->body.privacy.length;
 
  if (padded_length < encryption_overhead)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Message length too short to decrypt!\n");
 
    return GNUNET_NO;
  }
 
  GNUNET_assert (GNUNET_OK == GNUNET_CRYPTO_hpke_sk_to_x25519 (key, &hpke_key));
  encoded_length = (padded_length - encryption_overhead);
 
  GNUNET_assert (padded_length == encoded_length + encryption_overhead);
 
  result = GNUNET_NO;
  data = GNUNET_malloc (encoded_length);
 
  if (GNUNET_OK !=
      GNUNET_CRYPTO_hpke_open_oneshot (&hpke_key,
                                       (uint8_t*) "messenger",
                                       strlen ("messenger"),
                                       NULL, 0,
                                       (uint8_t*) message->body.privacy.data,
                                       padded_length,
                                       (uint8_t*) data,
                                       NULL))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Decrypting message failed!\n");
 
    goto cleanup;
  }
 
  {
    struct GNUNET_MESSENGER_ShortMessage shortened;
    if (GNUNET_YES != decode_short_message (&shortened,
                                            encoded_length,
                                            (char*) data))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Decoding decrypted message failed!\n");
 
      goto cleanup;
    }
 
    unfold_short_message (&shortened, message);
    result = GNUNET_YES;
  }
 
cleanup:
  GNUNET_free (data);
  return result;
}

References GNUNET_MESSENGER_Message::body, cleanup(), data, GNUNET_MESSENGER_MessagePrivate::data, decode_short_message(), encryption_overhead, GNUNET_assert, GNUNET_CRYPTO_hpke_open_oneshot(), GNUNET_CRYPTO_hpke_sk_to_x25519(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_malloc, GNUNET_NO, GNUNET_OK, GNUNET_YES, key, GNUNET_MESSENGER_MessagePrivate::length, GNUNET_MESSENGER_MessageBody::privacy, result, and unfold_short_message().

Referenced by handle_private_message().

Here is the call graph for this function:

Here is the caller graph for this function:

transcribe_message()

struct GNUNET_MESSENGER_Message * transcribe_message	(	const struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_CRYPTO_PublicKey *	key
	)

Transcribes a message as a new transcript message using a given public key from the recipient of the encrypted message content.

Parameters

[in]	message	Message
[in]	key	Public key

Returns

Message transcript

Definition at line 1333 of file messenger_api_message.c.

{
  struct GNUNET_MESSENGER_Message *transcript;
 
  GNUNET_assert ((message) && (key));
 
  if (GNUNET_YES == is_service_message (message))
    return NULL;
 
  transcript = create_message (GNUNET_MESSENGER_KIND_TRANSCRIPT);
 
  if (! transcript)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Transcribing message failed!\n");
    return NULL;
  }
 
  GNUNET_memcpy (&(transcript->body.transcript.key), key,
                 sizeof(transcript->body.transcript.key));
 
  {
    struct GNUNET_MESSENGER_ShortMessage shortened;
    uint16_t data_length;
 
    fold_short_message (message, &shortened);
 
    data_length = get_short_message_size (&shortened, GNUNET_YES);
 
    transcript->body.transcript.data = GNUNET_malloc (data_length);
    transcript->body.transcript.length = data_length;
 
    encode_short_message (&shortened, data_length,
                          transcript->body.transcript.data);
  }
 
  return transcript;
}

References GNUNET_MESSENGER_Message::body, create_message(), GNUNET_MESSENGER_MessageTranscript::data, encode_short_message(), fold_short_message(), get_short_message_size(), GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_MESSENGER_KIND_TRANSCRIPT, GNUNET_YES, is_service_message(), key, GNUNET_MESSENGER_MessageTranscript::key, GNUNET_MESSENGER_MessageTranscript::length, and GNUNET_MESSENGER_MessageBody::transcript.

Referenced by send_message_to_room_with_key().

Here is the call graph for this function:

Here is the caller graph for this function:

read_transcript_message()

enum GNUNET_GenericReturnValue read_transcript_message

(

struct GNUNET_MESSENGER_Message *

message

)

Read the original message from a transcript message 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]

transcript

Message transcript

Returns

GNUNET_YES on success, otherwise GNUNET_NO

Definition at line 1374 of file messenger_api_message.c.

{
  uint16_t data_length;
  struct GNUNET_MESSENGER_ShortMessage shortened;
 
  GNUNET_assert (message);
 
  if (GNUNET_MESSENGER_KIND_TRANSCRIPT != message->header.kind)
    return GNUNET_NO;
 
  data_length = message->body.transcript.length;
 
  if (GNUNET_YES != decode_short_message (&shortened,
                                          data_length,
                                          message->body.transcript.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_MessageTranscript::data, decode_short_message(), GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_MESSENGER_KIND_TRANSCRIPT, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_MessageTranscript::length, GNUNET_MESSENGER_MessageBody::transcript, and unfold_short_message().

Referenced by handle_transcript_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 GNUNET_MESSENGER_SignFunction	sign,
		enum GNUNET_MESSENGER_PackMode	mode,
		const void *	cls
	)

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 sign function is not NULL.

Parameters

[out]	message	Message
[out]	hash	Hash of message
[in]	sign	Function to sign
[in]	mode	Mode of packing
[in,out]	cls	Closure for signing

Returns

Envelope or NULL

Definition at line 1402 of file messenger_api_message.c.

{
  struct GNUNET_MessageHeader *header;
  uint16_t length, padded_length;
  struct GNUNET_MQ_Envelope *env;
  char *buffer;
 
  GNUNET_assert (message);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Packing message kind=%u and sender: %s\n",
              message->header.kind, GNUNET_sh2s (&(message->header.sender_id)));
 
  length = get_message_size (message, GNUNET_YES);
  padded_length = calc_padded_length (length);
 
  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 (sign)
      sign (cls, message, length, buffer, hash);
  }
 
  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, and GNUNET_MESSENGER_MessageHeader::sender_id.

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:

is_peer_message()

enum GNUNET_GenericReturnValue is_peer_message

(

const struct GNUNET_MESSENGER_Message *

message

)

Returns whether a specific kind of message can be sent by the service without usage of a clients private key.

The function returns GNUNET_YES if the kind of message can be signed via a peer's identity, otherwise GNUNET_NO.

Parameters

[in]

message

Message

Returns

GNUNET_YES if sending is allowed, GNUNET_NO otherwise

Definition at line 1452 of file messenger_api_message.c.

{
  GNUNET_assert (message);
 
  switch (message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_INFO:
  case GNUNET_MESSENGER_KIND_PEER:
  case GNUNET_MESSENGER_KIND_MISS:
  case GNUNET_MESSENGER_KIND_MERGE:
  case GNUNET_MESSENGER_KIND_CONNECTION:
    return GNUNET_YES;
  default:
    return GNUNET_NO;
  }
}

References GNUNET_assert, GNUNET_MESSENGER_KIND_CONNECTION, GNUNET_MESSENGER_KIND_INFO, GNUNET_MESSENGER_KIND_MERGE, GNUNET_MESSENGER_KIND_MISS, GNUNET_MESSENGER_KIND_PEER, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_Message::header, and GNUNET_MESSENGER_MessageHeader::kind.

Referenced by callback_found_message(), callback_room_handle_message(), enqueue_message_control(), filter_message_sending(), get_store_member_of(), get_store_peer_of(), handle_room_messages(), is_service_message(), notify_about_members(), notify_srv_handle_message(), pack_srv_room_message(), process_message_control(), and task_message_control().

Here is the caller graph for this function:

is_service_message()

enum GNUNET_GenericReturnValue is_service_message

(

const struct GNUNET_MESSENGER_Message *

message

)

Returns whether a specific kind of message contains service critical information.

That kind of information should not be encrypted via private messages for example to guarantee the service to work properly. The function returns GNUNET_YES if the kind of message needs to be transferred accessible to all peers and their running service. It returns GNUNET_NO if the message can be encrypted to specific subgroups of members without issues. If the kind of message is unknown it returns GNUNET_SYSERR.

Parameters

[in]

message

Message

Returns

GNUNET_YES if encrypting is disallowed, GNUNET_NO or GNUNET_SYSERR otherwise

Definition at line 1471 of file messenger_api_message.c.

{
  GNUNET_assert (message);
 
  if (GNUNET_YES == is_peer_message (message))
    return GNUNET_YES;
 
  switch (message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_INFO:
    return GNUNET_YES; // Reserved for connection handling only!
  case GNUNET_MESSENGER_KIND_JOIN:
    return GNUNET_YES; // Reserved for member handling only!
  case GNUNET_MESSENGER_KIND_LEAVE:
    return GNUNET_YES; // Reserved for member handling only!
  case GNUNET_MESSENGER_KIND_NAME:
    return GNUNET_YES; // Reserved for member name handling only!
  case GNUNET_MESSENGER_KIND_KEY:
    return GNUNET_YES; // Reserved for member key handling only!
  case GNUNET_MESSENGER_KIND_PEER:
    return GNUNET_YES; // Reserved for connection handling only!
  case GNUNET_MESSENGER_KIND_ID:
    return GNUNET_YES; // Reserved for member id handling only!
  case GNUNET_MESSENGER_KIND_MISS:
    return GNUNET_YES; // Reserved for connection handling only!
  case GNUNET_MESSENGER_KIND_MERGE:
    return GNUNET_YES; // Reserved for peers only!
  case GNUNET_MESSENGER_KIND_REQUEST:
    return GNUNET_YES; // Requests should not apply individually! (inefficiently)
  case GNUNET_MESSENGER_KIND_INVITE:
    return GNUNET_NO;
  case GNUNET_MESSENGER_KIND_TEXT:
    return GNUNET_NO;
  case GNUNET_MESSENGER_KIND_FILE:
    return GNUNET_NO;
  case GNUNET_MESSENGER_KIND_PRIVATE:
    return GNUNET_YES; // Prevent duplicate encryption breaking all access!
  case GNUNET_MESSENGER_KIND_DELETE:
    return GNUNET_YES; // Deletion should not apply individually! (inefficiently)
  case GNUNET_MESSENGER_KIND_CONNECTION:
    return GNUNET_YES; // Reserved for connection handling only!
  case GNUNET_MESSENGER_KIND_TICKET:
    return GNUNET_NO;
  case GNUNET_MESSENGER_KIND_TRANSCRIPT:
    return GNUNET_NO;
  case GNUNET_MESSENGER_KIND_TAG:
    return GNUNET_NO;
  case GNUNET_MESSENGER_KIND_SUBSCRIBE:
    return GNUNET_YES; // Reserved for subscription handling only!
  case GNUNET_MESSENGER_KIND_TALK:
    return GNUNET_NO;
  default:
    return GNUNET_SYSERR;
  }
}

References GNUNET_assert, GNUNET_MESSENGER_KIND_CONNECTION, GNUNET_MESSENGER_KIND_DELETE, GNUNET_MESSENGER_KIND_FILE, GNUNET_MESSENGER_KIND_ID, GNUNET_MESSENGER_KIND_INFO, GNUNET_MESSENGER_KIND_INVITE, GNUNET_MESSENGER_KIND_JOIN, GNUNET_MESSENGER_KIND_KEY, GNUNET_MESSENGER_KIND_LEAVE, GNUNET_MESSENGER_KIND_MERGE, GNUNET_MESSENGER_KIND_MISS, GNUNET_MESSENGER_KIND_NAME, GNUNET_MESSENGER_KIND_PEER, GNUNET_MESSENGER_KIND_PRIVATE, GNUNET_MESSENGER_KIND_REQUEST, GNUNET_MESSENGER_KIND_SUBSCRIBE, GNUNET_MESSENGER_KIND_TAG, GNUNET_MESSENGER_KIND_TALK, GNUNET_MESSENGER_KIND_TEXT, GNUNET_MESSENGER_KIND_TICKET, GNUNET_MESSENGER_KIND_TRANSCRIPT, GNUNET_NO, GNUNET_SYSERR, GNUNET_YES, GNUNET_MESSENGER_Message::header, is_peer_message(), and GNUNET_MESSENGER_MessageHeader::kind.

Referenced by encrypt_message(), and transcribe_message().

Here is the call graph for this function:

Here is the caller graph for this function:

filter_message_sending()

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.

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

Returns

GNUNET_YES if sending is allowed, GNUNET_NO or GNUNET_SYSERR otherwise

Definition at line 1529 of file messenger_api_message.c.

{
  GNUNET_assert (message);
 
  if (GNUNET_YES == is_peer_message (message))
    return GNUNET_SYSERR; // Requires signature of peer rather than member!
 
  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_set_key(...) instead!
  case GNUNET_MESSENGER_KIND_PEER:
    return GNUNET_SYSERR; // Use #GNUNET_MESSENGER_open_room(...) instead!
  case GNUNET_MESSENGER_KIND_ID:
    return GNUNET_NO; // 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_SYSERR; // Reserved for peers only!
  case GNUNET_MESSENGER_KIND_REQUEST:
    return GNUNET_NO; // Use #GNUNET_MESSENGER_get_message(...) instead!
  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_NO; // Use #GNUNET_MESSENGER_delete_message(...) instead!
  case GNUNET_MESSENGER_KIND_CONNECTION:
    return GNUNET_SYSERR; // Reserved for connection handling only!
  case GNUNET_MESSENGER_KIND_TICKET:
    return GNUNET_YES;
  case GNUNET_MESSENGER_KIND_TRANSCRIPT:
    return GNUNET_NO; // Use #GNUNET_MESSENGER_send_message(...) with a contact instead!
  case GNUNET_MESSENGER_KIND_TAG:
    return GNUNET_YES;
  case GNUNET_MESSENGER_KIND_SUBSCRIBE:
    return GNUNET_YES;
  case GNUNET_MESSENGER_KIND_TALK:
    return GNUNET_YES;
  default:
    return GNUNET_SYSERR;
  }
}

References GNUNET_assert, GNUNET_MESSENGER_KIND_CONNECTION, GNUNET_MESSENGER_KIND_DELETE, GNUNET_MESSENGER_KIND_FILE, GNUNET_MESSENGER_KIND_ID, GNUNET_MESSENGER_KIND_INFO, GNUNET_MESSENGER_KIND_INVITE, GNUNET_MESSENGER_KIND_JOIN, GNUNET_MESSENGER_KIND_KEY, GNUNET_MESSENGER_KIND_LEAVE, GNUNET_MESSENGER_KIND_MERGE, GNUNET_MESSENGER_KIND_MISS, GNUNET_MESSENGER_KIND_NAME, GNUNET_MESSENGER_KIND_PEER, GNUNET_MESSENGER_KIND_PRIVATE, GNUNET_MESSENGER_KIND_REQUEST, GNUNET_MESSENGER_KIND_SUBSCRIBE, GNUNET_MESSENGER_KIND_TAG, GNUNET_MESSENGER_KIND_TALK, GNUNET_MESSENGER_KIND_TEXT, GNUNET_MESSENGER_KIND_TICKET, GNUNET_MESSENGER_KIND_TRANSCRIPT, GNUNET_NO, GNUNET_SYSERR, GNUNET_YES, GNUNET_MESSENGER_Message::header, is_peer_message(), and GNUNET_MESSENGER_MessageHeader::kind.

Referenced by check_send_message(), and GNUNET_MESSENGER_send_message().

Here is the call graph for this function:

Here is the caller graph for this function:

get_message_discourse()

const struct GNUNET_ShortHashCode * get_message_discourse

(

const struct GNUNET_MESSENGER_Message *

message

)

Returns the discourse hash of a message depending on its kind.

If a message contains a discourse hash it will not be stored locally on peers.

Parameters

[in]

message

Message

Returns

Discourse hash of message or NULL

Definition at line 1587 of file messenger_api_message.c.

{
  GNUNET_assert (message);
 
  switch (message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_SUBSCRIBE:
    return &(message->body.subscribe.discourse);
  case GNUNET_MESSENGER_KIND_TALK:
    return &(message->body.talk.discourse);
  default:
    return NULL;
  }
}

References GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_MessageSubscribe::discourse, GNUNET_MESSENGER_MessageTalk::discourse, GNUNET_assert, GNUNET_MESSENGER_KIND_SUBSCRIBE, GNUNET_MESSENGER_KIND_TALK, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_MessageBody::subscribe, and GNUNET_MESSENGER_MessageBody::talk.

Referenced by handle_message_control(), iterate_flag_for_cleanup_discourse_message(), put_store_message(), send_message_to_room(), and update_message_state().

Here is the caller graph for this function: