messenger_api_message_kind.c File Reference

#include "messenger_api_message_kind.h"
#include "messenger_api_message.h"
#include <string.h>

Include dependency graph for messenger_api_message_kind.c:

Go to the source code of this file.

Functions
struct GNUNET_MESSENGER_Message *	create_message_join (const struct GNUNET_CRYPTO_PrivateKey *key)
	Creates and allocates a new join message containing the clients public key. More...
struct GNUNET_MESSENGER_Message *	create_message_leave (void)
	Creates and allocates a new leave message. More...
struct GNUNET_MESSENGER_Message *	create_message_name (const char *name)
	Creates and allocates a new name message containing the name to change to. More...
struct GNUNET_MESSENGER_Message *	create_message_key (const struct GNUNET_CRYPTO_PrivateKey *key)
	Creates and allocates a new key message containing the public key to change to derived from its private counterpart. More...
struct GNUNET_MESSENGER_Message *	create_message_id (const struct GNUNET_ShortHashCode *unique_id)
	Creates and allocates a new id message containing the unique member id to change to. More...
struct GNUNET_MESSENGER_Message *	create_message_request (const struct GNUNET_HashCode *hash)
	Creates and allocates a new request message containing the hash of a missing message. More...
struct GNUNET_MESSENGER_Message *	create_message_deletion (const struct GNUNET_HashCode *hash, const struct GNUNET_TIME_Relative delay)
	Creates and allocates a new deletion message containing the hash of a message to delete after a specific delay. More...
struct GNUNET_MESSENGER_Message *	create_message_subscribtion (const struct GNUNET_ShortHashCode *discourse, const struct GNUNET_TIME_Relative time, uint32_t flags)
	Creates and allocates a new subscribe message for a subscription of a given discourse with a specific time window and flags. More...
struct GNUNET_MESSENGER_Message *	create_message_announcement (const union GNUNET_MESSENGER_EpochIdentifier *identifier, const struct GNUNET_CRYPTO_EcdhePrivateKey *private_key, const struct GNUNET_CRYPTO_SymmetricSessionKey *shared_key, const struct GNUNET_TIME_Relative timeout)
	Creates and allocates a new announcement message for an announcement of a given epoch or group under an identifier using a specific private_key and shared_key until a given timeout. More...
struct GNUNET_MESSENGER_Message *	create_message_appeal (const struct GNUNET_HashCode *event, const struct GNUNET_CRYPTO_EcdhePrivateKey *private_key, const struct GNUNET_TIME_Relative timeout)
	Creates and allocates a new appeal message for an epoch announcement using a specific private_key to receive access before a given timeout. More...
struct GNUNET_MESSENGER_Message *	create_message_access (const struct GNUNET_HashCode *event, const struct GNUNET_CRYPTO_EcdhePublicKey *public_key, const struct GNUNET_CRYPTO_SymmetricSessionKey *shared_key)
	Creates and allocates a new access message to grant access to the shared_key of an announced epoch or group depending on target event encrypting the shared key for a specific public_key. More...
struct GNUNET_MESSENGER_Message *	create_message_revolution (const union GNUNET_MESSENGER_EpochIdentifier *identifier, const struct GNUNET_CRYPTO_SymmetricSessionKey *shared_key)
	Creates and allocates a new revolution message for an announced epoch or group selected by its identifier which is using a specific shared_key. More...
struct GNUNET_MESSENGER_Message *	create_message_group (const union GNUNET_MESSENGER_EpochIdentifier *identifier, const struct GNUNET_HashCode *initiator, const struct GNUNET_HashCode *partner, const struct GNUNET_TIME_Relative timeout)
	Creates and allocates a new group message to propose a group formation between an initiator subgroup and another partner subgroup until a given timeout to improve further epoch key exchange. More...
struct GNUNET_MESSENGER_Message *	create_message_authorization (const union GNUNET_MESSENGER_EpochIdentifier *identifier, const struct GNUNET_HashCode *event, const struct GNUNET_CRYPTO_SymmetricSessionKey *group_key, const struct GNUNET_CRYPTO_SymmetricSessionKey *shared_key)
	Creates and allocates a new authorization message to grant access to the shared_key of a specific group selected via its identifier following an announcement or a group formation event encrypting the shared key for a specific established group_key of selected group. More...

Function Documentation

create_message_join()

struct GNUNET_MESSENGER_Message * create_message_join

(

const struct GNUNET_CRYPTO_PrivateKey *

key

)

Creates and allocates a new join message containing the clients public key.

(all values are stored as copy)

Parameters

[in]

key

Private key

Returns

New message

Definition at line 32 of file messenger_api_message_kind.c.

{
  struct GNUNET_MESSENGER_Message *message;
 
  if (! key)
    return NULL;
 
  message = create_message (GNUNET_MESSENGER_KIND_JOIN);
 
  if (! message)
    return NULL;
 
  memset (&(message->body.leave.epoch), 0,
          sizeof (struct GNUNET_HashCode));
 
  GNUNET_CRYPTO_key_get_public (key, &(message->body.join.key));
  return message;
}

References GNUNET_MESSENGER_Message::body, create_message(), GNUNET_MESSENGER_MessageLeave::epoch, GNUNET_CRYPTO_key_get_public(), GNUNET_MESSENGER_KIND_JOIN, GNUNET_MESSENGER_MessageBody::join, key, GNUNET_MESSENGER_MessageJoin::key, and GNUNET_MESSENGER_MessageBody::leave.

Referenced by handle_member_id().

Here is the call graph for this function:

Here is the caller graph for this function:

create_message_leave()

struct GNUNET_MESSENGER_Message * create_message_leave

(

void

)

Creates and allocates a new leave message.

Returns

New message

Definition at line 53 of file messenger_api_message_kind.c.

{
  struct GNUNET_MESSENGER_Message *message;
 
  message = create_message (GNUNET_MESSENGER_KIND_LEAVE);
 
  if (! message)
    return NULL;
 
  memset (&(message->body.leave.epoch), 0,
          sizeof (struct GNUNET_HashCode));
 
  return message;
}

References GNUNET_MESSENGER_Message::body, create_message(), GNUNET_MESSENGER_MessageLeave::epoch, GNUNET_MESSENGER_KIND_LEAVE, and GNUNET_MESSENGER_MessageBody::leave.

Referenced by GNUNET_MESSENGER_close_room().

Here is the call graph for this function:

Here is the caller graph for this function:

create_message_name()

struct GNUNET_MESSENGER_Message * create_message_name

(

const char *

name

)

Creates and allocates a new name message containing the name to change to.

(all values are stored as copy)

Parameters

[in]

name

New name

Returns

New message

Definition at line 70 of file messenger_api_message_kind.c.

{
  struct GNUNET_MESSENGER_Message *message;
 
  if (! name)
    return NULL;
 
  message = create_message (GNUNET_MESSENGER_KIND_NAME);
 
  if (! message)
    return NULL;
 
  message->body.name.name = GNUNET_strdup (name);
  return message;
}

References GNUNET_MESSENGER_Message::body, create_message(), GNUNET_MESSENGER_KIND_NAME, GNUNET_strdup, name, GNUNET_MESSENGER_MessageName::name, and GNUNET_MESSENGER_MessageBody::name.

Referenced by iterate_send_name_to_room().

Here is the call graph for this function:

Here is the caller graph for this function:

create_message_key()

struct GNUNET_MESSENGER_Message * create_message_key

(

const struct GNUNET_CRYPTO_PrivateKey *

key

)

Creates and allocates a new key message containing the public key to change to derived from its private counterpart.

(all values are stored as copy)

Parameters

[in]

key

Private key

Returns

New message

Definition at line 88 of file messenger_api_message_kind.c.

{
  struct GNUNET_MESSENGER_Message *message;
 
  if (! key)
    return NULL;
 
  message = create_message (GNUNET_MESSENGER_KIND_KEY);
 
  if (! message)
    return NULL;
 
  GNUNET_CRYPTO_key_get_public (key, &(message->body.key.key));
  return message;
}

References GNUNET_MESSENGER_Message::body, create_message(), GNUNET_CRYPTO_key_get_public(), GNUNET_MESSENGER_KIND_KEY, key, GNUNET_MESSENGER_MessageKey::key, and GNUNET_MESSENGER_MessageBody::key.

Referenced by iterate_send_key_to_room().

Here is the call graph for this function:

Here is the caller graph for this function:

create_message_id()

struct GNUNET_MESSENGER_Message * create_message_id

(

const struct GNUNET_ShortHashCode *

unique_id

)

Creates and allocates a new id message containing the unique member id to change to.

(all values are stored as copy)

Parameters

[in]

unique_id

Unique member id

Returns

New message

Definition at line 106 of file messenger_api_message_kind.c.

{
  struct GNUNET_MESSENGER_Message *message;
 
  if (! unique_id)
    return NULL;
 
  message = create_message (GNUNET_MESSENGER_KIND_ID);
 
  if (! message)
    return NULL;
 
  GNUNET_memcpy (&(message->body.id.id), unique_id,
                 sizeof(struct GNUNET_ShortHashCode));
 
  return message;
}

References GNUNET_MESSENGER_Message::body, create_message(), GNUNET_memcpy, GNUNET_MESSENGER_KIND_ID, GNUNET_MESSENGER_MessageId::id, and GNUNET_MESSENGER_MessageBody::id.

Referenced by handle_member_id().

Here is the call graph for this function:

Here is the caller graph for this function:

create_message_request()

struct GNUNET_MESSENGER_Message * create_message_request

(

const struct GNUNET_HashCode *

hash

)

Creates and allocates a new request message containing the hash of a missing message.

(all values are stored as copy)

Parameters

[in]

hash

Hash of message

Returns

New message

Definition at line 126 of file messenger_api_message_kind.c.

{
  struct GNUNET_MESSENGER_Message *message;
 
  if (! hash)
    return NULL;
 
  {
    struct GNUNET_HashCode zero;
    memset (&zero, 0, sizeof(zero));
 
    if (0 == GNUNET_CRYPTO_hash_cmp (hash, &zero))
      return NULL;
  }
 
  message = create_message (GNUNET_MESSENGER_KIND_REQUEST);
 
  if (! message)
    return NULL;
 
  GNUNET_memcpy (&(message->body.request.hash), hash, sizeof(struct
                                                             GNUNET_HashCode));
 
  return message;
}

References GNUNET_MESSENGER_Message::body, create_message(), GNUNET_CRYPTO_hash_cmp(), GNUNET_memcpy, GNUNET_MESSENGER_KIND_REQUEST, GNUNET_MESSENGER_MessageRequest::hash, GNUNET_MESSENGER_MessageBody::request, and zero.

Referenced by handle_miss_message().

Here is the call graph for this function:

Here is the caller graph for this function:

create_message_deletion()

struct GNUNET_MESSENGER_Message * create_message_deletion	(	const struct GNUNET_HashCode *	hash,
		const struct GNUNET_TIME_Relative	delay
	)

Creates and allocates a new deletion message containing the hash of a message to delete after a specific delay.

(all values are stored as copy)

Parameters

[in]	hash	Hash of message
[in]	delay	Delay of deletion

Returns

New message

Definition at line 154 of file messenger_api_message_kind.c.

{
  struct GNUNET_MESSENGER_Message *message;
 
  if (! hash)
    return NULL;
 
  message = create_message (GNUNET_MESSENGER_KIND_DELETION);
 
  if (! message)
    return NULL;
 
  GNUNET_memcpy (&(message->body.deletion.hash), hash, sizeof(struct
                                                              GNUNET_HashCode));
  message->body.deletion.delay = GNUNET_TIME_relative_hton (delay);
 
  return message;
}

References GNUNET_MESSENGER_Message::body, create_message(), GNUNET_MESSENGER_MessageDeletion::delay, GNUNET_MESSENGER_MessageBody::deletion, GNUNET_memcpy, GNUNET_MESSENGER_KIND_DELETION, GNUNET_TIME_relative_hton(), and GNUNET_MESSENGER_MessageDeletion::hash.

Referenced by delete_room_message().

Here is the call graph for this function:

Here is the caller graph for this function:

create_message_subscribtion()

struct GNUNET_MESSENGER_Message * create_message_subscribtion	(	const struct GNUNET_ShortHashCode *	discourse,
		const struct GNUNET_TIME_Relative	time,
		uint32_t	flags
	)

Creates and allocates a new subscribe message for a subscription of a given discourse with a specific time window and flags.

(all values are stored as copy)

Parameters

[in]	discourse	Discourse
[in]	time	Time of subscription
[in]	flags	Subscription flags

Returns

New message

Definition at line 176 of file messenger_api_message_kind.c.

{
  struct GNUNET_MESSENGER_Message *message;
 
  if (! discourse)
    return NULL;
 
  message = create_message (GNUNET_MESSENGER_KIND_SUBSCRIBTION);
 
  if (! message)
    return NULL;
 
  GNUNET_memcpy (&(message->body.subscribtion.discourse), discourse,
                 sizeof (struct GNUNET_ShortHashCode));
 
  message->body.subscribtion.time = GNUNET_TIME_relative_hton (time);
  message->body.subscribtion.flags = flags;
 
  return message;
}

References GNUNET_MESSENGER_Message::body, create_message(), GNUNET_MESSENGER_MessageSubscribtion::discourse, GNUNET_MESSENGER_MessageSubscribtion::flags, GNUNET_memcpy, GNUNET_MESSENGER_KIND_SUBSCRIBTION, GNUNET_TIME_relative_hton(), GNUNET_MESSENGER_MessageBody::subscribtion, and GNUNET_MESSENGER_MessageSubscribtion::time.

Referenced by handle_discourse_subscription().

Here is the call graph for this function:

Here is the caller graph for this function:

create_message_announcement()

struct GNUNET_MESSENGER_Message * create_message_announcement	(	const union GNUNET_MESSENGER_EpochIdentifier *	identifier,
		const struct GNUNET_CRYPTO_EcdhePrivateKey *	private_key,
		const struct GNUNET_CRYPTO_SymmetricSessionKey *	shared_key,
		const struct GNUNET_TIME_Relative	timeout
	)

Creates and allocates a new announcement message for an announcement of a given epoch or group under an identifier using a specific private_key and shared_key until a given timeout.

Parameters

[in]	identifier	Epoch identifier
[in]	private_key	Private key
[in]	shared_key	Shared key
[in]	timeout	Timeout

Returns

New message

Definition at line 201 of file messenger_api_message_kind.c.

{
  struct GNUNET_MESSENGER_Message *message;
 
  if ((! identifier) || (! private_key) || (! shared_key))
    return NULL;
 
  message = create_message (GNUNET_MESSENGER_KIND_ANNOUNCEMENT);
 
  if (! message)
    return NULL;
 
  GNUNET_memcpy (&(message->body.announcement.identifier), identifier,
                 sizeof (message->body.announcement.identifier));
 
  GNUNET_CRYPTO_ecdhe_key_get_public (
    private_key, &(message->body.announcement.key));
 
  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_NONCE,
                              message->body.announcement.nonce.data.nonce,
                              GNUNET_MESSENGER_EPOCH_NONCE_BYTES);
 
  message->body.announcement.timeout = GNUNET_TIME_relative_hton (timeout);
 
  sign_message_by_key (message, shared_key);
 
  return message;
}

References GNUNET_MESSENGER_MessageBody::announcement, GNUNET_MESSENGER_Message::body, create_message(), GNUNET_MESSENGER_EpochNonce::data, GNUNET_CRYPTO_ecdhe_key_get_public(), GNUNET_CRYPTO_QUALITY_NONCE, GNUNET_CRYPTO_random_block(), GNUNET_memcpy, GNUNET_MESSENGER_EPOCH_NONCE_BYTES, GNUNET_MESSENGER_KIND_ANNOUNCEMENT, GNUNET_TIME_relative_hton(), GNUNET_MESSENGER_MessageAnnouncement::identifier, GNUNET_MESSENGER_MessageAnnouncement::key, GNUNET_MESSENGER_EpochNonceData::nonce, GNUNET_MESSENGER_MessageAnnouncement::nonce, sign_message_by_key(), timeout, and GNUNET_MESSENGER_MessageAnnouncement::timeout.

Referenced by send_epoch_announcement(), and send_epoch_group_announcement().

Here is the call graph for this function:

Here is the caller graph for this function:

create_message_appeal()

struct GNUNET_MESSENGER_Message * create_message_appeal	(	const struct GNUNET_HashCode *	event,
		const struct GNUNET_CRYPTO_EcdhePrivateKey *	private_key,
		const struct GNUNET_TIME_Relative	timeout
	)

Creates and allocates a new appeal message for an epoch announcement using a specific private_key to receive access before a given timeout.

Parameters

[in]	event	Hash of announcement event
[in]	private_key	Private key
[in]	timeout	Timeout

Returns

New message

Definition at line 238 of file messenger_api_message_kind.c.

{
  struct GNUNET_MESSENGER_Message *message;
 
  if ((! event) || (! private_key))
    return NULL;
 
  message = create_message (GNUNET_MESSENGER_KIND_APPEAL);
 
  if (! message)
    return NULL;
 
  GNUNET_memcpy (&(message->body.appeal.event), event,
                 sizeof (message->body.appeal.event));
 
  GNUNET_CRYPTO_ecdhe_key_get_public (
    private_key, &(message->body.appeal.key));
 
  message->body.appeal.timeout = GNUNET_TIME_relative_hton (timeout);
 
  return message;
}

References GNUNET_MESSENGER_MessageBody::appeal, GNUNET_MESSENGER_Message::body, create_message(), GNUNET_MESSENGER_MessageAppeal::event, GNUNET_CRYPTO_ecdhe_key_get_public(), GNUNET_memcpy, GNUNET_MESSENGER_KIND_APPEAL, GNUNET_TIME_relative_hton(), GNUNET_MESSENGER_MessageAppeal::key, timeout, and GNUNET_MESSENGER_MessageAppeal::timeout.

Referenced by send_epoch_announcement_appeal().

Here is the call graph for this function:

Here is the caller graph for this function:

create_message_access()

struct GNUNET_MESSENGER_Message * create_message_access	(	const struct GNUNET_HashCode *	event,
		const struct GNUNET_CRYPTO_EcdhePublicKey *	public_key,
		const struct GNUNET_CRYPTO_SymmetricSessionKey *	shared_key
	)

Creates and allocates a new access message to grant access to the shared_key of an announced epoch or group depending on target event encrypting the shared key for a specific public_key.

Parameters

[in]	event	Hash of appeal or group formation event
[in]	public_key	Public key
[in]	shared_key	Shared key

Returns

New message

Definition at line 265 of file messenger_api_message_kind.c.

{
  struct GNUNET_MESSENGER_Message *message;
 
  if ((! event) || (! public_key) || (! shared_key))
    return NULL;
 
  message = create_message (GNUNET_MESSENGER_KIND_ACCESS);
 
  if (! message)
    return NULL;
 
  if (GNUNET_OK != GNUNET_CRYPTO_hpke_seal_oneshot (public_key,
                                                    (const uint8_t*)
                                                    "messenger",
                                                    strlen ("messenger"),
                                                    NULL,
                                                    0,
                                                    (const uint8_t*) shared_key,
                                                    sizeof (*shared_key),
                                                    message->body.access.key,
                                                    NULL))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Encrypting key failed!\n");
 
    destroy_message (message);
    return NULL;
  }
 
  GNUNET_memcpy (&(message->body.access.event), event,
                 sizeof (message->body.access.event));
 
  sign_message_by_key (message, shared_key);
 
  return message;
}

References GNUNET_MESSENGER_MessageBody::access, GNUNET_MESSENGER_Message::body, create_message(), destroy_message(), GNUNET_MESSENGER_MessageAccess::event, GNUNET_CRYPTO_hpke_seal_oneshot(), GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_memcpy, GNUNET_MESSENGER_KIND_ACCESS, GNUNET_OK, GNUNET_MESSENGER_MessageAccess::key, and sign_message_by_key().

Referenced by send_epoch_announcement_access(), and send_epoch_group_access().

Here is the call graph for this function:

Here is the caller graph for this function:

create_message_revolution()

struct GNUNET_MESSENGER_Message * create_message_revolution	(	const union GNUNET_MESSENGER_EpochIdentifier *	identifier,
		const struct GNUNET_CRYPTO_SymmetricSessionKey *	shared_key
	)

Creates and allocates a new revolution message for an announced epoch or group selected by its identifier which is using a specific shared_key.

Parameters

[in]	identifier	Epoch identifier
[in]	shared_key	Shared key

Returns

New message

Definition at line 307 of file messenger_api_message_kind.c.

{
  struct GNUNET_MESSENGER_Message *message;
 
  if ((! identifier) || (! shared_key))
    return NULL;
 
  message = create_message (GNUNET_MESSENGER_KIND_REVOLUTION);
 
  if (! message)
    return NULL;
 
  GNUNET_memcpy (&(message->body.revolution.identifier), identifier,
                 sizeof (message->body.revolution.identifier));
 
  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_NONCE,
                              message->body.revolution.nonce.data.nonce,
                              GNUNET_MESSENGER_EPOCH_NONCE_BYTES);
 
  sign_message_by_key (message, shared_key);
 
  return message;
}

References GNUNET_MESSENGER_Message::body, create_message(), GNUNET_MESSENGER_EpochNonce::data, GNUNET_CRYPTO_QUALITY_NONCE, GNUNET_CRYPTO_random_block(), GNUNET_memcpy, GNUNET_MESSENGER_EPOCH_NONCE_BYTES, GNUNET_MESSENGER_KIND_REVOLUTION, GNUNET_MESSENGER_MessageRevolution::identifier, GNUNET_MESSENGER_EpochNonceData::nonce, GNUNET_MESSENGER_MessageRevolution::nonce, GNUNET_MESSENGER_MessageBody::revolution, and sign_message_by_key().

Referenced by send_epoch_announcement_revolution(), and send_epoch_group_revolution().

Here is the call graph for this function:

Here is the caller graph for this function:

create_message_group()

struct GNUNET_MESSENGER_Message * create_message_group	(	const union GNUNET_MESSENGER_EpochIdentifier *	identifier,
		const struct GNUNET_HashCode *	initiator,
		const struct GNUNET_HashCode *	partner,
		const struct GNUNET_TIME_Relative	timeout
	)

Creates and allocates a new group message to propose a group formation between an initiator subgroup and another partner subgroup until a given timeout to improve further epoch key exchange.

Parameters

[in]	identifier	Group identifier
[in]	initiator	Initiator group identifier
[in]	partner	Partner group identifier
[in]	timeout	Timeout

Returns

New message

Definition at line 336 of file messenger_api_message_kind.c.

{
  struct GNUNET_MESSENGER_Message *message;
 
  if ((! identifier) || (! initiator) || (! partner) ||
      (! identifier->code.group_bit))
    return NULL;
 
  message = create_message (GNUNET_MESSENGER_KIND_GROUP);
 
  if (! message)
    return NULL;
 
  GNUNET_memcpy (&(message->body.group.identifier), identifier,
                 sizeof (message->body.group.identifier));
  GNUNET_memcpy (&(message->body.group.initiator), initiator,
                 sizeof (message->body.group.initiator));
  GNUNET_memcpy (&(message->body.group.partner), partner,
                 sizeof (message->body.group.partner));
 
  message->body.group.timeout = GNUNET_TIME_relative_hton (timeout);
 
  return message;
}

References GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_EpochIdentifier::code, create_message(), GNUNET_memcpy, GNUNET_MESSENGER_KIND_GROUP, GNUNET_TIME_relative_hton(), GNUNET_MESSENGER_MessageBody::group, GNUNET_MESSENGER_EpochIdentifierCode::group_bit, GNUNET_MESSENGER_MessageGroup::identifier, GNUNET_MESSENGER_MessageGroup::initiator, GNUNET_MESSENGER_MessageGroup::partner, timeout, and GNUNET_MESSENGER_MessageGroup::timeout.

Referenced by send_epoch_group().

Here is the call graph for this function:

Here is the caller graph for this function:

create_message_authorization()

struct GNUNET_MESSENGER_Message * create_message_authorization	(	const union GNUNET_MESSENGER_EpochIdentifier *	identifier,
		const struct GNUNET_HashCode *	event,
		const struct GNUNET_CRYPTO_SymmetricSessionKey *	group_key,
		const struct GNUNET_CRYPTO_SymmetricSessionKey *	shared_key
	)

Creates and allocates a new authorization message to grant access to the shared_key of a specific group selected via its identifier following an announcement or a group formation event encrypting the shared key for a specific established group_key of selected group.

Parameters

[in]	identifier	Group identifier
[in]	event	Hash of announcement or group formation event
[in]	group_key	Established group key
[in]	shared_key	Shared key

Returns

New message

Definition at line 366 of file messenger_api_message_kind.c.

{
  struct GNUNET_MESSENGER_Message *message;
  struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
 
  if ((! identifier) || (! event) || (! group_key) || (! shared_key))
    return NULL;
 
  message = create_message (GNUNET_MESSENGER_KIND_AUTHORIZATION);
 
  if (! message)
    return NULL;
 
  GNUNET_CRYPTO_symmetric_derive_iv (&iv, group_key,
                                     event, sizeof (*event),
                                     identifier, sizeof (*identifier),
                                     NULL);
 
  if (-1 == GNUNET_CRYPTO_symmetric_encrypt (shared_key,
                                             GNUNET_MESSENGER_AUTHORIZATION_KEY_BYTES,
                                             group_key,
                                             &iv,
                                             message->body.authorization.key))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Encrypting key failed!\n");
 
    destroy_message (message);
    return NULL;
  }
 
  GNUNET_memcpy (&(message->body.authorization.identifier), identifier,
                 sizeof (message->body.authorization.identifier));
  GNUNET_memcpy (&(message->body.authorization.event), event,
                 sizeof (message->body.authorization.event));
 
  sign_message_by_key (message, shared_key);
 
  return message;
}

References GNUNET_MESSENGER_MessageBody::authorization, GNUNET_MESSENGER_Message::body, create_message(), destroy_message(), GNUNET_MESSENGER_MessageAuthorization::event, GNUNET_CRYPTO_symmetric_derive_iv(), GNUNET_CRYPTO_symmetric_encrypt(), GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_memcpy, GNUNET_MESSENGER_AUTHORIZATION_KEY_BYTES, GNUNET_MESSENGER_KIND_AUTHORIZATION, GNUNET_MESSENGER_MessageAuthorization::identifier, GNUNET_MESSENGER_MessageAuthorization::key, and sign_message_by_key().

Referenced by send_epoch_announcement_authorization(), and send_epoch_group_authorization().

Here is the call graph for this function:

Here is the caller graph for this function: