#include "messenger_api_epoch_group.h"
#include "messenger_api_epoch.h"
#include "messenger_api_message.h"
#include "messenger_api_message_kind.h"
#include "messenger_api_room.h"

Include dependency graph for messenger_api_epoch_group.c:

Data Structures
struct	GNUNET_MESSENGER_CheckEpochGroup

struct	GNUNET_MESSENGER_CheckEpoch

struct	GNUNET_MESSENGER_CheckEpochAnnouncement

Functions
static void	random_epoch_group_identifier (uint32_t level, union GNUNET_MESSENGER_EpochIdentifier *identifier)

static enum GNUNET_GenericReturnValue	derive_epoch_group_key (const struct GNUNET_MESSENGER_EpochGroup group, const struct GNUNET_MESSENGER_EpochGroup previous, struct GNUNET_CRYPTO_SymmetricSessionKey *key)

struct GNUNET_MESSENGER_EpochGroup *	create_epoch_group (struct GNUNET_MESSENGER_Epoch epoch, const union GNUNET_MESSENGER_EpochIdentifier identifier, uint32_t level, enum GNUNET_GenericReturnValue valid)
	Creates and allocates a new epoch group for a given epoch using a specific group identifier or NULL and a specified level.

void	destroy_epoch_group (struct GNUNET_MESSENGER_EpochGroup *group)
	Destroys a given epoch group and frees its resources.

uint32_t	get_epoch_group_level (const struct GNUNET_MESSENGER_EpochGroup *group)
	Returns the group level of a given epoch group.

uint32_t	get_epoch_group_size (const struct GNUNET_MESSENGER_EpochGroup *group)
	Returns the size of a given epoch group in terms of members.

uint32_t	get_epoch_group_members_count (const struct GNUNET_MESSENGER_EpochGroup *group)
	Returns the current amount of members of a given epoch group.

enum GNUNET_GenericReturnValue	is_epoch_group_completed (const struct GNUNET_MESSENGER_EpochGroup *group)
	Returns whether a given epoch group is complete in terms of confirmed announcements from its members.

enum GNUNET_GenericReturnValue	is_epoch_group_announced (const struct GNUNET_MESSENGER_EpochGroup *group)
	Returns whether the client has announced being part of a given epoch group owning its secret key.

void	set_epoch_group_key (struct GNUNET_MESSENGER_EpochGroup group, const struct GNUNET_CRYPTO_SymmetricSessionKey shared_key, enum GNUNET_GenericReturnValue write_record)
	Sets the secret key of a given epoch group to a shared key.

const struct GNUNET_CRYPTO_SymmetricSessionKey *	get_epoch_group_key (const struct GNUNET_MESSENGER_EpochGroup *group)
	Returns the secret key of a given epoch group or NULL.

static enum GNUNET_GenericReturnValue	is_epoch_group_key_derived_from (const struct GNUNET_MESSENGER_EpochGroup group, const struct GNUNET_MESSENGER_EpochGroup previous)

enum GNUNET_GenericReturnValue	confirm_epoch_group_member (struct GNUNET_MESSENGER_EpochGroup group, const struct GNUNET_HashCode hash, const struct GNUNET_MESSENGER_Message message, struct GNUNET_MESSENGER_Contact contact, enum GNUNET_GenericReturnValue sent)
	Confirms an announcement message with its hash to a given epoch group as confirmation for a specific contact.

static uint32_t	get_epoch_group_member_position (const struct GNUNET_MESSENGER_EpochGroup *group)

enum GNUNET_GenericReturnValue	is_epoch_group_member (const struct GNUNET_MESSENGER_EpochGroup group, const struct GNUNET_MESSENGER_Contact contact)
	Returns whether a specific contact is confirmed member of a given epoch group.

enum GNUNET_GenericReturnValue	it_check_epoch_group_member (void cls, const struct GNUNET_MESSENGER_Contact member)

enum GNUNET_GenericReturnValue	is_epoch_group_subgroup_of (const struct GNUNET_MESSENGER_EpochGroup group, const struct GNUNET_MESSENGER_EpochGroup other)
	Returns whether a given epoch group is subgroup of a specific other group.

enum GNUNET_GenericReturnValue	get_epoch_group_member_hash (const struct GNUNET_MESSENGER_EpochGroup group, struct GNUNET_HashCode hash, enum GNUNET_GenericReturnValue other)
	Provides an announcement hash of a member from a given epoch group.

void	invalidate_epoch_group (struct GNUNET_MESSENGER_EpochGroup group, const struct GNUNET_MESSENGER_Contact contact)
	Invalidates a given epoch group by a specific contact.

enum GNUNET_GenericReturnValue	is_epoch_group_proposal (const struct GNUNET_MESSENGER_EpochGroup *group)
	Returns whether a given epoch group is the current proposal of the client.

enum GNUNET_GenericReturnValue	it_check_epoch_member (void cls, const struct GNUNET_MESSENGER_Contact member)

enum GNUNET_GenericReturnValue	is_epoch_group_compatible (const struct GNUNET_MESSENGER_EpochGroup group, const struct GNUNET_MESSENGER_Epoch epoch)
	Returns whether a given epoch group is compatible with a specific epoch with its members.

enum GNUNET_GenericReturnValue	it_check_epoch_announcement_member (void cls, const struct GNUNET_MESSENGER_Contact member)

enum GNUNET_GenericReturnValue	is_epoch_group_missing_announcement (const struct GNUNET_MESSENGER_EpochGroup group, const struct GNUNET_MESSENGER_EpochAnnouncement announcement)
	Returns whether any member of a given epoch group is missing in a provided epoch announcement.

double	get_epoch_group_position_factor (const struct GNUNET_MESSENGER_EpochGroup *group)
	Returns a relative member position of the client inside a given epoch group in relation to its list of members.

enum GNUNET_GenericReturnValue	send_epoch_group_announcement (struct GNUNET_MESSENGER_EpochGroup *group)
	Tries to send an announcement message by the client for a given epoch group using its secret key.

enum GNUNET_GenericReturnValue	send_epoch_group_access (struct GNUNET_MESSENGER_EpochGroup group, const struct GNUNET_HashCode event)
	Tries to send an access message by the client responding to a previous event in regards to a given epoch group using its secret key.

enum GNUNET_GenericReturnValue	send_epoch_group_revolution (struct GNUNET_MESSENGER_EpochGroup *group)
	Tries to send a revolution message by the client for a given epoch group using its secret key.

enum GNUNET_GenericReturnValue	send_epoch_group (struct GNUNET_MESSENGER_EpochGroup group, const struct GNUNET_HashCode initiator_event, const struct GNUNET_HashCode *partner_event, struct GNUNET_TIME_Relative timeout)
	Tries to send a group message by the client for a given epoch group to propose it forming a group out of the subgroups from two previous events and a timeout.

enum GNUNET_GenericReturnValue	send_epoch_group_authorization (struct GNUNET_MESSENGER_EpochGroup group, const struct GNUNET_HashCode event)
	Tries to send an authorization message by the client responding to a previous event in regards to a given epoch group using its secret key.

void	handle_epoch_group_announcement (struct GNUNET_MESSENGER_EpochGroup group, const struct GNUNET_MESSENGER_Message message, const struct GNUNET_HashCode hash, struct GNUNET_MESSENGER_Contact sender, enum GNUNET_GenericReturnValue sent)
	Handles an announcement message with hash from its sender inside a given epoch group as first stage.

void	handle_epoch_group_announcement_delay (struct GNUNET_MESSENGER_EpochGroup group, const struct GNUNET_MESSENGER_Message message, const struct GNUNET_HashCode hash, struct GNUNET_MESSENGER_Contact sender, enum GNUNET_GenericReturnValue sent)
	Handles an announcement message with hash from its sender inside a given epoch group as second stage after custom delay.

void	handle_epoch_group_access (struct GNUNET_MESSENGER_EpochGroup group, const struct GNUNET_MESSENGER_Message message, const struct GNUNET_HashCode *hash)
	Handles an access message with hash from its sender inside a given epoch group.

static void	cont_write_epoch_group_record (void *cls, enum GNUNET_ErrorCode ec)

void	write_epoch_group_record (struct GNUNET_MESSENGER_EpochGroup *group, enum GNUNET_GenericReturnValue deleted)
	Writes/Deletes the GNS record of a given epoch group depending on a provided flag that states whether an existing record should be deleted.

Function Documentation

◆ random_epoch_group_identifier()

static void random_epoch_group_identifier	(	uint32_t	level,
		union GNUNET_MESSENGER_EpochIdentifier *	identifier
	)

static

Definition at line 34 of file messenger_api_epoch_group.c.

{
  GNUNET_assert (identifier);
 
  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
                              identifier,
                              sizeof (*identifier));
 
  identifier->code.group_bit = 1;
  identifier->code.level_bits = 0x7F & level;
}

References GNUNET_MESSENGER_EpochIdentifier::code, GNUNET_assert, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_block(), GNUNET_MESSENGER_EpochIdentifierCode::group_bit, and GNUNET_MESSENGER_EpochIdentifierCode::level_bits.

Referenced by create_epoch_group().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ derive_epoch_group_key()

static enum GNUNET_GenericReturnValue derive_epoch_group_key	(	const struct GNUNET_MESSENGER_EpochGroup *	group,
		const struct GNUNET_MESSENGER_EpochGroup *	previous,
		struct GNUNET_CRYPTO_SymmetricSessionKey *	key
	)

static

Definition at line 50 of file messenger_api_epoch_group.c.

{
  const struct GNUNET_CRYPTO_SymmetricSessionKey *previous_key;
 
  GNUNET_assert ((group) && (previous) && (key));
 
  previous_key = get_epoch_group_key (previous);
 
  if (! previous_key)
    return GNUNET_SYSERR;
 
  if (GNUNET_YES != GNUNET_CRYPTO_hkdf_gnunet (
        key, sizeof (*key),
        GNUNET_MESSENGER_SALT_GROUP_KEY,
        sizeof (GNUNET_MESSENGER_SALT_GROUP_KEY),
        previous_key,
        sizeof (*previous_key),
        GNUNET_CRYPTO_kdf_arg_auto (&group->epoch->hash),
        GNUNET_CRYPTO_kdf_arg_auto (&group->identifier)))
    return GNUNET_SYSERR;
  else
    return GNUNET_OK;
}

References GNUNET_MESSENGER_EpochGroup::epoch, get_epoch_group_key(), GNUNET_assert, GNUNET_CRYPTO_hkdf_gnunet, GNUNET_CRYPTO_kdf_arg_auto, GNUNET_MESSENGER_SALT_GROUP_KEY, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, GNUNET_MESSENGER_Epoch::hash, GNUNET_MESSENGER_EpochGroup::identifier, and key.

Referenced by create_epoch_group(), and is_epoch_group_key_derived_from().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_epoch_group()

struct GNUNET_MESSENGER_EpochGroup * create_epoch_group	(	struct GNUNET_MESSENGER_Epoch *	epoch,
		const union GNUNET_MESSENGER_EpochIdentifier *	identifier,
		uint32_t	level,
		enum GNUNET_GenericReturnValue	valid
	)

Creates and allocates a new epoch group for a given epoch using a specific group identifier or NULL and a specified level.

Additionally a flag specifies whether that group needs to be valid to allow key derivation based on that property.

Parameters

[in,out]	epoch	Epoch
[in]	identifier	Group identifier
[in]	level	Group level
[in]	valid	Validity flag

Returns: New epoch group or NULL

Definition at line 78 of file messenger_api_epoch_group.c.

{
  struct GNUNET_MESSENGER_EpochGroup *group;
  const struct GNUNET_MESSENGER_EpochGroup *previous;
 
  GNUNET_assert (epoch);
 
  group = GNUNET_new (struct GNUNET_MESSENGER_EpochGroup);
 
  if (! group)
    return NULL;
 
  previous = get_epoch_previous_group (epoch, identifier);
 
  if ((GNUNET_YES == valid) && (previous) &&
      (GNUNET_YES != previous->valid))
    previous = NULL;
 
  if (identifier)
    GNUNET_memcpy (&(group->identifier), identifier,
                   sizeof (group->identifier));
  else
    random_epoch_group_identifier (level, &(group->identifier));
 
  GNUNET_assert (group->identifier.code.group_bit);
 
  group->announcement_expiration = GNUNET_TIME_absolute_get_zero_ ();
 
  group->epoch = epoch;
  group->membership = create_epoch_membership (get_epoch_group_size (group));
  group->shared_key = NULL;
  group->query = NULL;
 
  group->valid = GNUNET_YES;
  group->stored = GNUNET_NO;
 
  if (previous)
  {
    struct GNUNET_CRYPTO_SymmetricSessionKey key;
 
    if (GNUNET_OK == derive_epoch_group_key (group,
                                             previous,
                                             &key))
    {
      set_epoch_group_key (group, &key, GNUNET_YES);
      group->valid = previous->valid;
    }
  }
 
  return group;
}

Referenced by get_epoch_group(), and propose_epoch_group().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ destroy_epoch_group()

void destroy_epoch_group ( struct GNUNET_MESSENGER_EpochGroup * group )

Destroys a given epoch group and frees its resources.

Parameters

[in,out] group Epoch group

Definition at line 136 of file messenger_api_epoch_group.c.

{
  GNUNET_assert (group);
 
  if (group->membership)
    destroy_epoch_membership (group->membership);
 
  if (group->shared_key)
    GNUNET_free (group->shared_key);
 
  if (group->query)
    GNUNET_NAMESTORE_cancel (group->query);
 
  GNUNET_free (group);
}

References destroy_epoch_membership(), GNUNET_assert, GNUNET_free, GNUNET_NAMESTORE_cancel(), GNUNET_MESSENGER_EpochGroup::membership, GNUNET_MESSENGER_EpochGroup::query, and GNUNET_MESSENGER_EpochGroup::shared_key.

Referenced by get_epoch_group(), iterate_destroy_group(), and propose_epoch_group().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_epoch_group_level()

uint32_t get_epoch_group_level ( const struct GNUNET_MESSENGER_EpochGroup * group )

Returns the group level of a given epoch group.

Parameters

[in] group Epoch group

Returns: Group level

Definition at line 154 of file messenger_api_epoch_group.c.

{
  GNUNET_assert (group);
 
  return group->identifier.code.level_bits;
}

References GNUNET_MESSENGER_EpochIdentifier::code, GNUNET_assert, GNUNET_MESSENGER_EpochGroup::identifier, and GNUNET_MESSENGER_EpochIdentifierCode::level_bits.

Referenced by get_epoch_group_size(), handle_authorization_message(), handle_epoch_group_access(), handle_epoch_group_announcement(), is_epoch_group_subgroup_of(), is_epoch_subgroup_of_any_group(), propose_epoch_group(), and send_epoch_group_authorization().

Here is the caller graph for this function:

◆ get_epoch_group_size()

uint32_t get_epoch_group_size ( const struct GNUNET_MESSENGER_EpochGroup * group )

Returns the size of a given epoch group in terms of members.

Parameters

[in] group Epoch group

Returns: Maximum group size

Definition at line 163 of file messenger_api_epoch_group.c.

{
  GNUNET_assert (group);
 
  return 0x1 << get_epoch_group_level (group);
}

References get_epoch_group_level(), and GNUNET_assert.

Referenced by create_epoch_group().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_epoch_group_members_count()

uint32_t get_epoch_group_members_count ( const struct GNUNET_MESSENGER_EpochGroup * group )

Returns the current amount of members of a given epoch group.

Parameters

[in] group Epoch group

Returns: Amount of confirmed members of group

Definition at line 172 of file messenger_api_epoch_group.c.

{
  GNUNET_assert (group);
 
  return get_epoch_membership_count (group->membership);
}

References get_epoch_membership_count(), GNUNET_assert, and GNUNET_MESSENGER_EpochGroup::membership.

Referenced by get_epoch_group_position_factor(), and is_other_epoch_group_better().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_epoch_group_completed()

enum GNUNET_GenericReturnValue is_epoch_group_completed ( const struct GNUNET_MESSENGER_EpochGroup * group )

Returns whether a given epoch group is complete in terms of confirmed announcements from its members.

Parameters

[in] group Epoch group

Returns: GNUNET_YES if complete, otherwise GNUNET_NO

Definition at line 182 of file messenger_api_epoch_group.c.

{
  GNUNET_assert (group);
 
  return is_epoch_membership_completed (group->membership);
}

References GNUNET_assert, is_epoch_membership_completed(), and GNUNET_MESSENGER_EpochGroup::membership.

Referenced by cancel_epoch_proposal_group(), get_epoch_group_position_factor(), handle_epoch_group_announcement(), handle_epoch_group_announcement_delay(), is_epoch_group_compatible(), is_epoch_group_subgroup_of(), propose_epoch_group(), and update_epoch_group().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_epoch_group_announced()

enum GNUNET_GenericReturnValue is_epoch_group_announced ( const struct GNUNET_MESSENGER_EpochGroup * group )

Returns whether the client has announced being part of a given epoch group owning its secret key.

Parameters

[in] group Epoch group

Returns: GNUNET_YES if client is active member of the group, otherwise GNUNET_NO

Definition at line 191 of file messenger_api_epoch_group.c.

{
  GNUNET_assert (group);
 
  return is_epoch_membership_member (group->membership, NULL);
}

References GNUNET_assert, is_epoch_membership_member(), and GNUNET_MESSENGER_EpochGroup::membership.

Referenced by handle_epoch_group_announcement(), and it_move_epoch_groups_from_previous_epoch().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_epoch_group_key()

void set_epoch_group_key	(	struct GNUNET_MESSENGER_EpochGroup *	group,
		const struct GNUNET_CRYPTO_SymmetricSessionKey *	shared_key,
		enum GNUNET_GenericReturnValue	write_record
	)

Sets the secret key of a given epoch group to a shared key.

An additional flag decides whether the shared key has been loaded from storage or whether it should write its record afterwards.

Parameters

[in,out]	group	Epoch group
[in]	shared_key	Shared key or NULL
[in]	write_record	GNUNET_YES if the record should be written, otherwise GNUNET_NO

Definition at line 200 of file messenger_api_epoch_group.c.

{
  GNUNET_assert (group);
 
  if ((GNUNET_NO == write_record) && (shared_key))
    group->stored = GNUNET_YES;
 
  if (group->shared_key)
    return;
 
  group->shared_key = GNUNET_new (struct GNUNET_CRYPTO_SymmetricSessionKey);
 
  if (! group->shared_key)
    return;
 
  if (shared_key)
    GNUNET_memcpy (group->shared_key, shared_key,
                   sizeof (struct GNUNET_CRYPTO_SymmetricSessionKey));
  else
    GNUNET_CRYPTO_symmetric_create_session_key (group->shared_key);
 
  update_epoch_group (group->epoch, group);
 
  if (GNUNET_YES != group->stored)
    write_epoch_group_record (group, GNUNET_NO);
}

References GNUNET_MESSENGER_EpochGroup::epoch, GNUNET_assert, GNUNET_CRYPTO_symmetric_create_session_key(), GNUNET_memcpy, GNUNET_new, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_EpochGroup::shared_key, GNUNET_MESSENGER_EpochGroup::stored, update_epoch_group(), and write_epoch_group_record().

Referenced by create_epoch_group(), handle_authorization_message(), handle_epoch_group_access(), handle_group_message(), and read_handle_epoch_key().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_epoch_group_key()

const struct GNUNET_CRYPTO_SymmetricSessionKey * get_epoch_group_key ( const struct GNUNET_MESSENGER_EpochGroup * group )

Returns the secret key of a given epoch group or NULL.

Parameters

[in] group Epoch group

Returns: Secret key or NULL

Definition at line 231 of file messenger_api_epoch_group.c.

{
  GNUNET_assert (group);
 
  return group->shared_key;
}

References GNUNET_assert, and GNUNET_MESSENGER_EpochGroup::shared_key.

Referenced by create_new_epoch(), derive_epoch_group_key(), handle_authorization_message(), handle_epoch_group_announcement(), handle_revolution_message(), is_epoch_group_key_derived_from(), it_find_valid_group_with_most_members(), it_move_epoch_groups_from_previous_epoch(), send_epoch_announcement_authorization(), send_epoch_group_access(), send_epoch_group_announcement(), send_epoch_group_authorization(), send_epoch_group_revolution(), and update_epoch_group().

Here is the caller graph for this function:

◆ is_epoch_group_key_derived_from()

static enum GNUNET_GenericReturnValue is_epoch_group_key_derived_from	(	const struct GNUNET_MESSENGER_EpochGroup *	group,
		const struct GNUNET_MESSENGER_EpochGroup *	previous
	)

static

Definition at line 240 of file messenger_api_epoch_group.c.

{
  const struct GNUNET_CRYPTO_SymmetricSessionKey *shared_key;
  struct GNUNET_CRYPTO_SymmetricSessionKey key;
 
  GNUNET_assert ((group) && (previous));
 
  shared_key = get_epoch_group_key (group);
 
  if (! shared_key)
    return GNUNET_SYSERR;
 
  if (GNUNET_OK != derive_epoch_group_key (group, previous, &key))
    return GNUNET_SYSERR;
 
  if (0 == GNUNET_memcmp (shared_key, &key))
    return GNUNET_YES;
  else
    return GNUNET_NO;
}

References derive_epoch_group_key(), get_epoch_group_key(), GNUNET_assert, GNUNET_memcmp, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, and key.

Referenced by invalidate_epoch_group().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ confirm_epoch_group_member()

enum GNUNET_GenericReturnValue confirm_epoch_group_member	(	struct GNUNET_MESSENGER_EpochGroup *	group,
		const struct GNUNET_HashCode *	hash,
		const struct GNUNET_MESSENGER_Message *	message,
		struct GNUNET_MESSENGER_Contact *	contact,
		enum GNUNET_GenericReturnValue	sent
	)

Confirms an announcement message with its hash to a given epoch group as confirmation for a specific contact.

An additional flag specifies whether the message has been sent by the client or not.

Parameters

[in,out]	group	Epoch group
[in]	hash	Hash of message
[in]	message	Message
[in,out]	contact	Contact
[in]	sent	Sent flag

Returns: GNUNET_YES on success, GNUNET_SYSERR on internal failure, otherwise GNUNET_NO

Definition at line 266 of file messenger_api_epoch_group.c.

{
  enum GNUNET_GenericReturnValue result;
 
  GNUNET_assert ((group) && (hash) && (message) && (contact));
 
  if (GNUNET_YES != is_epoch_member (group->epoch, contact))
    return GNUNET_SYSERR;
 
  result = confirm_epoch_membership_announcment (group->membership,
                                                 hash,
                                                 message,
                                                 contact,
                                                 sent);
 
  if (GNUNET_YES != result)
    return result;
 
  update_epoch_group (group->epoch, group);
  return GNUNET_YES;
}

References confirm_epoch_membership_announcment(), GNUNET_MESSENGER_EpochGroup::epoch, GNUNET_assert, GNUNET_SYSERR, GNUNET_YES, is_epoch_member(), GNUNET_MESSENGER_EpochGroup::membership, result, and update_epoch_group().

Referenced by handle_epoch_group_announcement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_epoch_group_member_position()

static uint32_t get_epoch_group_member_position ( const struct GNUNET_MESSENGER_EpochGroup * group )

static

Definition at line 294 of file messenger_api_epoch_group.c.

{
  GNUNET_assert (group);
 
  return get_epoch_membership_member_position (group->membership);
}

References get_epoch_membership_member_position(), GNUNET_assert, and GNUNET_MESSENGER_EpochGroup::membership.

Referenced by get_epoch_group_position_factor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_epoch_group_member()

enum GNUNET_GenericReturnValue is_epoch_group_member	(	const struct GNUNET_MESSENGER_EpochGroup *	group,
		const struct GNUNET_MESSENGER_Contact *	contact
	)

Returns whether a specific contact is confirmed member of a given epoch group.

Parameters

[in]	group	Epoch group
[in]	contact	Contact

Returns: GNUNET_YES if the contact is a member, otherwise GNUNET_NO

Definition at line 304 of file messenger_api_epoch_group.c.

{
  GNUNET_assert ((group) && (contact));
 
  return is_epoch_membership_member (group->membership, contact);
}

References GNUNET_assert, is_epoch_membership_member(), and GNUNET_MESSENGER_EpochGroup::membership.

Referenced by handle_epoch_group_announcement(), is_epoch_member_in_any_group(), and it_check_epoch_group_member().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ it_check_epoch_group_member()

enum GNUNET_GenericReturnValue it_check_epoch_group_member	(	void *	cls,
		const struct GNUNET_MESSENGER_Contact *	member
	)

Definition at line 320 of file messenger_api_epoch_group.c.

{
  struct GNUNET_MESSENGER_CheckEpochGroup *check;
 
  GNUNET_assert ((cls) && (member));
 
  check = cls;
 
  if (GNUNET_YES == is_epoch_group_member (check->group, member))
    return GNUNET_YES;
 
  check->result = GNUNET_NO;
  return GNUNET_NO;
}

References GNUNET_assert, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_CheckEpochGroup::group, is_epoch_group_member(), and GNUNET_MESSENGER_CheckEpochGroup::result.

Referenced by is_epoch_group_subgroup_of().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_epoch_group_subgroup_of()

enum GNUNET_GenericReturnValue is_epoch_group_subgroup_of	(	const struct GNUNET_MESSENGER_EpochGroup *	group,
		const struct GNUNET_MESSENGER_EpochGroup *	other
	)

Returns whether a given epoch group is subgroup of a specific other group.

Parameters

[in]	group	Epoch group
[in]	other	Other epoch group

Returns: GNUNET_YES if the group is a subgroup, otherwise GNUNET_NO

Definition at line 338 of file messenger_api_epoch_group.c.

{
  struct GNUNET_MESSENGER_CheckEpochGroup check;
 
  GNUNET_assert ((group) && (other));
 
  if (group == other)
    return GNUNET_YES;
 
  if (get_epoch_group_level (other) <= get_epoch_group_level (group))
    return GNUNET_NO;
 
  if (GNUNET_YES != is_epoch_group_completed (group))
    return GNUNET_NO;
 
  check.group = other;
  check.result = GNUNET_YES;
 
  iterate_epoch_membership_members (group->membership,
                                    it_check_epoch_group_member,
                                    &check);
 
  return check.result;
}

References get_epoch_group_level(), GNUNET_assert, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_CheckEpochGroup::group, is_epoch_group_completed(), it_check_epoch_group_member(), iterate_epoch_membership_members(), GNUNET_MESSENGER_EpochGroup::membership, and GNUNET_MESSENGER_CheckEpochGroup::result.

Referenced by is_epoch_subgroup_of_any_group().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_epoch_group_member_hash()

enum GNUNET_GenericReturnValue get_epoch_group_member_hash	(	const struct GNUNET_MESSENGER_EpochGroup *	group,
		struct GNUNET_HashCode *	hash,
		enum GNUNET_GenericReturnValue	other
	)

Provides an announcement hash of a member from a given epoch group.

Depending on a flag it provides some hash of another member or the clients own announcement.

Parameters

[in]	group	Epoch group
[out]	hash	Hash of announcement
[in]	other	Other flag

Returns: GNUNET_OK on success, otherwise GNUNET_SYSERR

Definition at line 366 of file messenger_api_epoch_group.c.

{
  GNUNET_assert ((group) && (hash));
 
  return get_epoch_membership_member_hash (group->membership, hash, other);
}

References get_epoch_membership_member_hash(), GNUNET_assert, GNUNET_MESSENGER_CheckEpochGroup::group, and GNUNET_MESSENGER_EpochGroup::membership.

Referenced by handle_access_message(), and propose_epoch_group().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ invalidate_epoch_group()

void invalidate_epoch_group	(	struct GNUNET_MESSENGER_EpochGroup *	group,
		const struct GNUNET_MESSENGER_Contact *	contact
	)

Invalidates a given epoch group by a specific contact.

Parameters

[in,out]	group	Epoch group
[in]	contact	Contact

Definition at line 377 of file messenger_api_epoch_group.c.

{
  const struct GNUNET_MESSENGER_Message *message;
  struct GNUNET_MESSENGER_EpochGroup *previous;
  struct GNUNET_MESSENGER_Epoch *epoch;
 
  GNUNET_assert (group);
 
  if (GNUNET_NO == group->valid)
    return;
 
  if ((contact) && (GNUNET_YES != is_epoch_member (group->epoch, contact)))
    return;
 
  group->valid = GNUNET_NO;
  write_epoch_group_record (group, GNUNET_NO);
 
  message = get_room_message (group->epoch->room, &(group->epoch->hash));
 
  if (! message)
    goto skip_traversal;
 
  switch (message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_JOIN:
    epoch = get_room_epoch (
      group->epoch->room, &(message->body.join.epoch), GNUNET_NO);
 
    if (epoch)
      previous = get_epoch_group (
        epoch, &(group->identifier), GNUNET_SYSERR);
    else
      previous = NULL;
    break;
  case GNUNET_MESSENGER_KIND_LEAVE:
    epoch = get_room_epoch (
      group->epoch->room, &(message->body.leave.epoch), GNUNET_NO);
 
    if (epoch)
      previous = get_epoch_group (
        epoch, &(group->identifier), GNUNET_SYSERR);
    else
      previous = NULL;
    break;
  case GNUNET_MESSENGER_KIND_MERGE:
    epoch = get_room_epoch (
      group->epoch->room, &(message->body.merge.epochs[0]), GNUNET_NO);
 
    if (epoch)
    {
      previous = get_epoch_group (
        epoch, &(group->identifier), GNUNET_SYSERR);
 
      if ((previous) &&
          (GNUNET_YES != is_epoch_group_key_derived_from (previous, group)))
        previous = NULL;
    }
    else
      previous = NULL;
 
    if (! previous)
    {
      epoch = get_room_epoch (
        group->epoch->room, &(message->body.merge.epochs[1]), GNUNET_NO);
 
      if (epoch)
        previous = get_epoch_group (
          epoch, &(group->identifier), GNUNET_SYSERR);
    }
    break;
  default:
    previous = NULL;
    break;
  }
 
  if ((previous) &&
      (GNUNET_YES != is_epoch_group_key_derived_from (previous, group)))
    previous = NULL;
 
  if (previous)
    invalidate_epoch_group (previous, contact);
 
skip_traversal:
  if (group->epoch->main_group != group)
    return;
 
  group->epoch->main_group = get_epoch_group (
    group->epoch, NULL, GNUNET_YES);
}

References GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_MessageJoin::epoch, GNUNET_MESSENGER_MessageLeave::epoch, GNUNET_MESSENGER_EpochGroup::epoch, GNUNET_MESSENGER_MessageMerge::epochs, get_epoch_group(), get_room_epoch(), get_room_message(), GNUNET_assert, GNUNET_MESSENGER_KIND_JOIN, GNUNET_MESSENGER_KIND_LEAVE, GNUNET_MESSENGER_KIND_MERGE, GNUNET_NO, GNUNET_SYSERR, GNUNET_YES, GNUNET_MESSENGER_Epoch::hash, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_EpochGroup::identifier, invalidate_epoch_group(), is_epoch_group_key_derived_from(), is_epoch_member(), GNUNET_MESSENGER_MessageBody::join, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_MessageBody::leave, GNUNET_MESSENGER_Epoch::main_group, GNUNET_MESSENGER_MessageBody::merge, GNUNET_MESSENGER_Epoch::room, GNUNET_MESSENGER_EpochGroup::valid, and write_epoch_group_record().

Referenced by handle_revolution_message(), invalidate_epoch_group(), and iterate_epoch_group_invalidation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_epoch_group_proposal()

enum GNUNET_GenericReturnValue is_epoch_group_proposal ( const struct GNUNET_MESSENGER_EpochGroup * group )

Returns whether a given epoch group is the current proposal of the client.

Parameters

[in] group Epoch group

Returns: GNUNET_YES if the group is being proposed, otherwise GNUNET_NO

Definition at line 470 of file messenger_api_epoch_group.c.

{
  GNUNET_assert (group);
 
  if (get_epoch_proposal_group (group->epoch) == group)
    return GNUNET_YES;
  else
    return GNUNET_NO;
}

References GNUNET_MESSENGER_EpochGroup::epoch, get_epoch_proposal_group(), GNUNET_assert, GNUNET_NO, and GNUNET_YES.

Referenced by handle_epoch_group_announcement(), and update_epoch_group().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ it_check_epoch_member()

enum GNUNET_GenericReturnValue it_check_epoch_member	(	void *	cls,
		const struct GNUNET_MESSENGER_Contact *	member
	)

Definition at line 488 of file messenger_api_epoch_group.c.

{
  struct GNUNET_MESSENGER_CheckEpoch *check;
  uint32_t i;
 
  GNUNET_assert ((cls) && (member));
 
  check = cls;
 
  for (i = 0; i < check->epoch->members_count; i++)
    if (member == check->epoch->members[i])
      return GNUNET_YES;
 
  check->result = GNUNET_NO;
  return GNUNET_NO;
}

References GNUNET_MESSENGER_CheckEpoch::epoch, GNUNET_assert, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_Epoch::members, GNUNET_MESSENGER_Epoch::members_count, and GNUNET_MESSENGER_CheckEpoch::result.

Referenced by is_epoch_group_compatible().

Here is the caller graph for this function:

◆ is_epoch_group_compatible()

enum GNUNET_GenericReturnValue is_epoch_group_compatible	(	const struct GNUNET_MESSENGER_EpochGroup *	group,
		const struct GNUNET_MESSENGER_Epoch *	epoch
	)

Returns whether a given epoch group is compatible with a specific epoch with its members.

Parameters

[in]	group	Epoch group
[in]	epoch	Epoch

Returns: GNUNET_YES if the group is compatible, otherwise GNUNET_NO

Definition at line 508 of file messenger_api_epoch_group.c.

{
  struct GNUNET_MESSENGER_CheckEpoch check;
 
  GNUNET_assert ((group) && (epoch));
 
  if (GNUNET_YES != is_epoch_group_completed (group))
    return GNUNET_NO;
 
  if (GNUNET_YES != group->valid)
    return GNUNET_NO;
 
  if (group->epoch == epoch)
    return GNUNET_YES;
 
  if (0 == epoch->members_count)
    return GNUNET_NO;
 
  check.epoch = epoch;
  check.result = GNUNET_YES;
 
  iterate_epoch_membership_members (group->membership,
                                    it_check_epoch_member,
                                    &check);
 
  return check.result;
}

References GNUNET_MESSENGER_CheckEpoch::epoch, GNUNET_MESSENGER_EpochGroup::epoch, GNUNET_assert, GNUNET_NO, GNUNET_YES, is_epoch_group_completed(), it_check_epoch_member(), iterate_epoch_membership_members(), GNUNET_MESSENGER_Epoch::members_count, GNUNET_MESSENGER_EpochGroup::membership, GNUNET_MESSENGER_CheckEpoch::result, and GNUNET_MESSENGER_EpochGroup::valid.

Referenced by create_new_epoch(), handle_epoch_announcement_access(), and it_move_epoch_groups_from_previous_epoch().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ it_check_epoch_announcement_member()

enum GNUNET_GenericReturnValue it_check_epoch_announcement_member	(	void *	cls,
		const struct GNUNET_MESSENGER_Contact *	member
	)

Definition at line 545 of file messenger_api_epoch_group.c.

{
  struct GNUNET_MESSENGER_CheckEpochAnnouncement *check;
 
  GNUNET_assert ((cls) && (member));
 
  check = cls;
 
  if (GNUNET_YES == is_epoch_announcement_member (check->announcement, member))
    return GNUNET_YES;
 
  check->result = GNUNET_YES;
  return GNUNET_NO;
}

References GNUNET_MESSENGER_CheckEpochAnnouncement::announcement, GNUNET_assert, GNUNET_NO, GNUNET_YES, is_epoch_announcement_member(), and GNUNET_MESSENGER_CheckEpochAnnouncement::result.

Referenced by is_epoch_group_missing_announcement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_epoch_group_missing_announcement()

enum GNUNET_GenericReturnValue is_epoch_group_missing_announcement	(	const struct GNUNET_MESSENGER_EpochGroup *	group,
		const struct GNUNET_MESSENGER_EpochAnnouncement *	announcement
	)

Returns whether any member of a given epoch group is missing in a provided epoch announcement.

Parameters

[in]	group	Epoch group
[in]	announcement	Epoch announcement

Returns: GNUNET_YES if any member is missing, GNUNET_NO otherwise

Definition at line 564 of file messenger_api_epoch_group.c.

{
  struct GNUNET_MESSENGER_CheckEpochAnnouncement check;
 
  GNUNET_assert ((group) && (announcement));
 
  if (0 == get_epoch_announcement_members_count (announcement))
    return GNUNET_YES;
 
  check.announcement = announcement;
  check.result = GNUNET_NO;
 
  iterate_epoch_membership_members (group->membership,
                                    it_check_epoch_announcement_member,
                                    &check);
 
  return check.result;
}

References announcement, GNUNET_MESSENGER_CheckEpochAnnouncement::announcement, get_epoch_announcement_members_count(), GNUNET_assert, GNUNET_NO, GNUNET_YES, it_check_epoch_announcement_member(), iterate_epoch_membership_members(), GNUNET_MESSENGER_EpochGroup::membership, and GNUNET_MESSENGER_CheckEpochAnnouncement::result.

Referenced by handle_epoch_announcement_access().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_epoch_group_position_factor()

double get_epoch_group_position_factor ( const struct GNUNET_MESSENGER_EpochGroup * group )

Returns a relative member position of the client inside a given epoch group in relation to its list of members.

Parameters

[in] group Epoch group

Returns: Member position as factor between 0.0 and 1.0

Definition at line 589 of file messenger_api_epoch_group.c.

{
  const struct GNUNET_MESSENGER_EpochGroup *target;
  uint32_t members_count;
  uint32_t announced;
  uint32_t position;
 
  GNUNET_assert (group);
 
  if (GNUNET_NO == is_epoch_group_completed (group))
    target = get_epoch_previous_group (group->epoch, &(group->identifier));
  else
    target = NULL;
 
  if (! target)
    target = group;
 
  members_count = get_epoch_group_members_count (target);
  announced = get_epoch_group_members_count (group);
 
  if (members_count <= announced)
    return 0.0;
 
  position = get_epoch_group_member_position (target);
 
  if (position > announced)
    position -= announced;
  else
    position = 0;
 
  return (0.0 + position) / (members_count - announced);
}

References GNUNET_MESSENGER_EpochGroup::epoch, get_epoch_group_member_position(), get_epoch_group_members_count(), get_epoch_previous_group(), GNUNET_assert, GNUNET_NO, GNUNET_MESSENGER_EpochGroup::identifier, and is_epoch_group_completed().

Referenced by handle_epoch_announcement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_epoch_group_announcement()

enum GNUNET_GenericReturnValue send_epoch_group_announcement ( struct GNUNET_MESSENGER_EpochGroup * group )

Tries to send an announcement message by the client for a given epoch group using its secret key.

Parameters

[in,out] group Epoch group

Returns: GNUNET_OK on success, otherwise GNUNET_SYSERR

Definition at line 625 of file messenger_api_epoch_group.c.

{
  const struct GNUNET_CRYPTO_SymmetricSessionKey *key;
  const struct GNUNET_CRYPTO_EcdhePrivateKey *private_key;
  struct GNUNET_TIME_Relative timeout;
  struct GNUNET_MESSENGER_Message *message;
 
  GNUNET_assert (group);
 
  key = get_epoch_group_key (group);
 
  if (! key)
    return GNUNET_SYSERR;
 
  timeout = GNUNET_TIME_absolute_get_remaining (
    group->announcement_expiration);
 
  if (GNUNET_YES != GNUNET_TIME_relative_is_zero (timeout))
    return GNUNET_NO;
 
  timeout = GNUNET_TIME_relative_multiply (
    GNUNET_TIME_relative_get_hour_ (), 24);
 
  private_key = get_epoch_private_key (group->epoch,
                                       timeout);
 
  if (! private_key)
    return GNUNET_SYSERR;
 
  timeout = get_epoch_private_key_timeout (group->epoch);
 
  message = create_message_announcement (&(group->identifier),
                                         private_key,
                                         key,
                                         timeout);
 
  if (! message)
    return GNUNET_SYSERR;
 
  send_epoch_message (group->epoch, message);
 
  group->announcement_expiration = GNUNET_TIME_absolute_add (
    GNUNET_TIME_absolute_get (), timeout);
 
  return GNUNET_OK;
}

References GNUNET_MESSENGER_EpochGroup::announcement_expiration, create_message_announcement(), GNUNET_MESSENGER_EpochGroup::epoch, get_epoch_group_key(), get_epoch_private_key(), get_epoch_private_key_timeout(), GNUNET_assert, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_TIME_absolute_add(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_relative_get_hour_(), GNUNET_TIME_relative_is_zero(), GNUNET_TIME_relative_multiply(), GNUNET_YES, GNUNET_MESSENGER_EpochGroup::identifier, key, send_epoch_message(), and timeout.

Referenced by create_new_epoch(), handle_authorization_message(), handle_epoch_group_access(), and handle_epoch_group_announcement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_epoch_group_access()

enum GNUNET_GenericReturnValue send_epoch_group_access	(	struct GNUNET_MESSENGER_EpochGroup *	group,
		const struct GNUNET_HashCode *	event
	)

Tries to send an access message by the client responding to a previous event in regards to a given epoch group using its secret key.

Parameters

[in,out]	group	Epoch group
[in]	event	Hash of event message

Returns: GNUNET_OK on success, otherwise GNUNET_SYSERR

Definition at line 674 of file messenger_api_epoch_group.c.

{
  struct GNUNET_MESSENGER_Room *room;
  const struct GNUNET_CRYPTO_SymmetricSessionKey *key;
  const struct GNUNET_MESSENGER_Message *group_message;
  const struct GNUNET_MESSENGER_Message *announcement_message;
  const struct GNUNET_CRYPTO_EcdhePublicKey *public_key;
  struct GNUNET_MESSENGER_Message *message;
 
  GNUNET_assert ((group) && (event));
 
  room = group->epoch->room;
  key = get_epoch_group_key (group);
 
  if (! key)
    return GNUNET_SYSERR;
 
  if (GNUNET_YES != is_room_message_sent (room, event))
    return GNUNET_SYSERR;
 
  group_message = get_room_message (room, event);
 
  if ((! group_message) ||
      (GNUNET_MESSENGER_KIND_GROUP != group_message->header.kind))
    return GNUNET_SYSERR;
 
  announcement_message = get_room_message (room, &(group_message->body.group.
                                                   partner));
 
  if ((! announcement_message) ||
      (GNUNET_MESSENGER_KIND_ANNOUNCEMENT != announcement_message->header.kind))
    return GNUNET_SYSERR;
 
  public_key = &(announcement_message->body.announcement.key);
  message = create_message_access (event,
                                   public_key,
                                   key);
 
  if (! message)
    return GNUNET_SYSERR;
 
  send_epoch_message (group->epoch, message);
  return GNUNET_OK;
}

References GNUNET_MESSENGER_MessageBody::announcement, GNUNET_MESSENGER_Message::body, create_message_access(), GNUNET_MESSENGER_EpochGroup::epoch, get_epoch_group_key(), get_room_message(), GNUNET_assert, GNUNET_MESSENGER_KIND_ANNOUNCEMENT, GNUNET_MESSENGER_KIND_GROUP, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, GNUNET_MESSENGER_MessageBody::group, GNUNET_MESSENGER_Message::header, is_room_message_sent(), key, GNUNET_MESSENGER_MessageAnnouncement::key, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_Epoch::room, and send_epoch_message().

Referenced by handle_group_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_epoch_group_revolution()

enum GNUNET_GenericReturnValue send_epoch_group_revolution ( struct GNUNET_MESSENGER_EpochGroup * group )

Tries to send a revolution message by the client for a given epoch group using its secret key.

Parameters

[in,out] group Epoch group

Returns: GNUNET_OK on success, otherwise GNUNET_SYSERR

Definition at line 722 of file messenger_api_epoch_group.c.

{
  const struct GNUNET_CRYPTO_SymmetricSessionKey *key;
  struct GNUNET_MESSENGER_Message *message;
 
  GNUNET_assert (group);
 
  key = get_epoch_group_key (group);
 
  if (! key)
    return GNUNET_SYSERR;
 
  message = create_message_revolution (&(group->identifier),
                                       key);
 
  if (! message)
    return GNUNET_SYSERR;
 
  send_epoch_message (group->epoch, message);
  return GNUNET_OK;
}

References create_message_revolution(), GNUNET_MESSENGER_EpochGroup::epoch, get_epoch_group_key(), GNUNET_assert, GNUNET_OK, GNUNET_SYSERR, GNUNET_MESSENGER_EpochGroup::identifier, key, and send_epoch_message().

Referenced by handle_epoch_group_announcement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_epoch_group()

enum GNUNET_GenericReturnValue send_epoch_group	(	struct GNUNET_MESSENGER_EpochGroup *	group,
		const struct GNUNET_HashCode *	initiator_event,
		const struct GNUNET_HashCode *	partner_event,
		struct GNUNET_TIME_Relative	timeout
	)

Tries to send a group message by the client for a given epoch group to propose it forming a group out of the subgroups from two previous events and a timeout.

Parameters

[in,out]	group	Epoch group
[in]	initiator_event	Hash of initiator event message
[in]	partner_event	Hash of partner event message
[in]	timeout	Timeout for group

Returns: GNUNET_OK on success, otherwise GNUNET_SYSERR

Definition at line 746 of file messenger_api_epoch_group.c.

{
  struct GNUNET_MESSENGER_Room *room;
  const struct GNUNET_MESSENGER_Message *announcement_message;
  const union GNUNET_MESSENGER_EpochIdentifier *initiator_identifier;
  const union GNUNET_MESSENGER_EpochIdentifier *partner_identifier;
  struct GNUNET_MESSENGER_Message *message;
 
  GNUNET_assert ((group) && (initiator_event) && (partner_event));
 
  if (0 == GNUNET_CRYPTO_hash_cmp (initiator_event, partner_event))
    return GNUNET_SYSERR;
 
  room = group->epoch->room;
 
  if (GNUNET_YES != is_room_message_sent (room, initiator_event))
    return GNUNET_SYSERR;
 
  announcement_message = get_room_message (room, initiator_event);
 
  if ((! announcement_message) ||
      (GNUNET_MESSENGER_KIND_ANNOUNCEMENT != announcement_message->header.kind))
    return GNUNET_SYSERR;
 
  initiator_identifier = &(announcement_message->body.announcement.identifier);
 
  if (group->identifier.code.level_bits != initiator_identifier->code.level_bits
      + 1)
    return GNUNET_SYSERR;
 
  announcement_message = get_room_message (room, partner_event);
 
  if ((! announcement_message) ||
      (GNUNET_MESSENGER_KIND_ANNOUNCEMENT != announcement_message->header.kind))
    return GNUNET_SYSERR;
 
  partner_identifier = &(announcement_message->body.announcement.identifier);
 
  if (initiator_identifier->code.level_bits != partner_identifier->code.
      level_bits)
    return GNUNET_SYSERR;
 
  if (((initiator_identifier->code.group_bit) || (partner_identifier->code.
                                                  group_bit)) &&
      (0 == GNUNET_memcmp (initiator_identifier->code.bits, partner_identifier->
                           code.bits)))
    return GNUNET_SYSERR;
 
  if (get_room_sender (room, initiator_event) == get_room_sender (room,
                                                                  partner_event)
      )
    return GNUNET_SYSERR;
 
  message = create_message_group (&(group->identifier),
                                  initiator_event,
                                  partner_event,
                                  timeout);
 
  if (! message)
    return GNUNET_SYSERR;
 
  send_epoch_message (group->epoch, message);
  return GNUNET_OK;
}

References GNUNET_MESSENGER_MessageBody::announcement, GNUNET_MESSENGER_EpochIdentifierCode::bits, GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_EpochIdentifier::code, create_message_group(), GNUNET_MESSENGER_EpochGroup::epoch, get_room_message(), get_room_sender(), GNUNET_assert, GNUNET_CRYPTO_hash_cmp(), GNUNET_memcmp, GNUNET_MESSENGER_KIND_ANNOUNCEMENT, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, GNUNET_MESSENGER_EpochIdentifierCode::group_bit, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageAnnouncement::identifier, GNUNET_MESSENGER_EpochGroup::identifier, is_room_message_sent(), GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_EpochIdentifierCode::level_bits, GNUNET_MESSENGER_Epoch::room, send_epoch_message(), and timeout.

Referenced by propose_epoch_group().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_epoch_group_authorization()

enum GNUNET_GenericReturnValue send_epoch_group_authorization	(	struct GNUNET_MESSENGER_EpochGroup *	group,
		const struct GNUNET_HashCode *	event
	)

Tries to send an authorization message by the client responding to a previous event in regards to a given epoch group using its secret key.

Parameters

[in,out]	group	Epoch group
[in]	event	Hash of event message

Returns: GNUNET_OK on success, otherwise GNUNET_SYSERR

Definition at line 816 of file messenger_api_epoch_group.c.

{
  struct GNUNET_MESSENGER_Room *room;
  const struct GNUNET_CRYPTO_SymmetricSessionKey *key;
  const struct GNUNET_MESSENGER_Message *group_message;
  const struct GNUNET_HashCode *announcement_event;
  const struct GNUNET_MESSENGER_Message *announcement_message;
  const union GNUNET_MESSENGER_EpochIdentifier *identifier;
  const struct GNUNET_MESSENGER_EpochGroup *target_group;
  const struct GNUNET_CRYPTO_SymmetricSessionKey *group_key;
  struct GNUNET_MESSENGER_Message *message;
 
  GNUNET_assert ((group) && (event));
 
  room = group->epoch->room;
  key = get_epoch_group_key (group);
 
  if (! key)
    return GNUNET_SYSERR;
 
  group_message = get_room_message (room, event);
 
  if ((! group_message) ||
      (GNUNET_MESSENGER_KIND_GROUP != group_message->header.kind))
    return GNUNET_SYSERR;
 
  if (0 != GNUNET_memcmp (&(group->identifier), &(group_message->body.group.
                                                  identifier)))
    return GNUNET_SYSERR;
 
  if (GNUNET_YES == is_room_message_sent (room, event))
    announcement_event = &(group_message->body.group.initiator);
  else
    announcement_event = &(group_message->body.group.partner);
 
  if (GNUNET_YES != is_room_message_sent (room, announcement_event))
    return GNUNET_SYSERR;
 
  announcement_message = get_room_message (room, announcement_event);
 
  if ((! announcement_message) ||
      (GNUNET_MESSENGER_KIND_ANNOUNCEMENT != announcement_message->header.kind))
    return GNUNET_SYSERR;
 
  identifier = &(announcement_message->body.announcement.identifier);
 
  if (! identifier->code.group_bit)
    return GNUNET_SYSERR;
 
  if (0 == GNUNET_memcmp (&(group->identifier), identifier))
    return GNUNET_SYSERR;
 
  target_group = get_epoch_group (group->epoch,
                                  identifier,
                                  GNUNET_YES);
 
  if (! target_group)
    return GNUNET_SYSERR;
 
  if (get_epoch_group_level (target_group) + 1 != get_epoch_group_level (group))
    return GNUNET_SYSERR;
 
  group_key = get_epoch_group_key (target_group);
 
  if (! group_key)
    return GNUNET_SYSERR;
 
  message = create_message_authorization (identifier,
                                          event,
                                          group_key,
                                          key);
 
  if (! message)
    return GNUNET_SYSERR;
 
  send_epoch_message (group->epoch, message);
  return GNUNET_OK;
}

Referenced by handle_epoch_group_access(), and handle_epoch_group_announcement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_epoch_group_announcement()

void handle_epoch_group_announcement	(	struct GNUNET_MESSENGER_EpochGroup *	group,
		const struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_HashCode *	hash,
		struct GNUNET_MESSENGER_Contact *	sender,
		enum GNUNET_GenericReturnValue	sent
	)

Handles an announcement message with hash from its sender inside a given epoch group as first stage.

Parameters

[in,out]	group	Epoch group
[in]	message	Message
[in]	hash	Hash of message
[in]	sender	Sender of message
[in]	sent	Sent flag

Definition at line 898 of file messenger_api_epoch_group.c.

{
  struct GNUNET_HashCode proposal_hash;
  const struct GNUNET_CRYPTO_SymmetricSessionKey *key;
  enum GNUNET_GenericReturnValue is_proposal;
  struct GNUNET_TIME_Relative timeout;
 
  GNUNET_assert ((group) && (message) && (hash) && (sender));
 
  if (GNUNET_YES == is_epoch_group_proposal (group))
  {
    GNUNET_memcpy (&(proposal_hash), &(group->epoch->proposal_hash), sizeof (
                     proposal_hash));
    memset (&(group->epoch->proposal_hash), 0, sizeof (group->epoch->
                                                       proposal_hash));
 
    is_proposal = GNUNET_YES;
 
    cancel_epoch_proposal_group (group->epoch);
  }
  else
    is_proposal = GNUNET_NO;
 
  key = get_epoch_group_key (group);
 
  if (key)
  {
    if (GNUNET_OK != verify_message_by_key (message, key))
      return;
 
    if ((GNUNET_YES == is_epoch_group_completed (group)) &&
        (GNUNET_YES != is_epoch_group_member (group, sender)))
    {
      send_epoch_group_revolution (group);
      return;
    }
  }
 
  if (GNUNET_YES != confirm_epoch_group_member (group, hash, message, sender,
                                                sent))
    return;
 
  {
    const struct GNUNET_MESSENGER_EpochGroup *proposal_group;
 
    proposal_group = get_epoch_proposal_group (group->epoch);
 
    if ((proposal_group) && (group->epoch->main_group) &&
        (get_epoch_group_level (proposal_group) <= get_epoch_group_level (
           group->epoch->main_group)))
      cancel_epoch_proposal_group (group->epoch);
  }
 
  if ((key) && (GNUNET_YES == is_proposal) &&
      (GNUNET_YES != is_epoch_group_announced (group)))
  {
    send_epoch_group_authorization (group, &proposal_hash);
    send_epoch_group_announcement (group);
  }
 
  timeout = GNUNET_TIME_relative_get_zero_ ();
 
  delay_room_action (group->epoch->room, hash, timeout);
}

References cancel_epoch_proposal_group(), confirm_epoch_group_member(), delay_room_action(), GNUNET_MESSENGER_EpochGroup::epoch, get_epoch_group_key(), get_epoch_group_level(), get_epoch_proposal_group(), GNUNET_assert, GNUNET_memcpy, GNUNET_NO, GNUNET_OK, GNUNET_TIME_relative_get_zero_(), GNUNET_YES, is_epoch_group_announced(), is_epoch_group_completed(), is_epoch_group_member(), is_epoch_group_proposal(), key, GNUNET_MESSENGER_Epoch::main_group, GNUNET_MESSENGER_Epoch::proposal_hash, GNUNET_MESSENGER_Epoch::room, send_epoch_group_announcement(), send_epoch_group_authorization(), send_epoch_group_revolution(), timeout, and verify_message_by_key().

Referenced by handle_announcement_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_epoch_group_announcement_delay()

void handle_epoch_group_announcement_delay	(	struct GNUNET_MESSENGER_EpochGroup *	group,
		const struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_HashCode *	hash,
		struct GNUNET_MESSENGER_Contact *	sender,
		enum GNUNET_GenericReturnValue	sent
	)

Handles an announcement message with hash from its sender inside a given epoch group as second stage after custom delay.

Parameters

[in,out]	group	Epoch group
[in]	message	Message
[in]	hash	Hash of message
[in]	sender	Sender of message
[in]	sent	Sent flag

Definition at line 969 of file messenger_api_epoch_group.c.

{
  GNUNET_assert ((group) && (message) && (hash) && (sender));
 
  if (GNUNET_YES == is_room_public (group->epoch->room))
    return;
 
  if ((GNUNET_YES == sent) && (GNUNET_YES == group->valid) &&
      (GNUNET_YES == is_epoch_group_completed (group)))
    propose_epoch_group (group->epoch, GNUNET_TIME_relative_get_hour_ ());
}

References GNUNET_MESSENGER_EpochGroup::epoch, GNUNET_assert, GNUNET_TIME_relative_get_hour_(), GNUNET_YES, is_epoch_group_completed(), is_room_public(), propose_epoch_group(), GNUNET_MESSENGER_Epoch::room, and GNUNET_MESSENGER_EpochGroup::valid.

Referenced by handle_room_delayed_announcement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_epoch_group_access()

void handle_epoch_group_access	(	struct GNUNET_MESSENGER_EpochGroup *	group,
		const struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_HashCode *	hash
	)

Handles an access message with hash from its sender inside a given epoch group.

Parameters

[in,out]	group	Epoch group
[in]	message	Message
[in]	hash	Hash of message
[in]	sender	Sender of message
[in]	sent	Sent flag

Definition at line 989 of file messenger_api_epoch_group.c.

{
  const struct GNUNET_CRYPTO_EcdhePrivateKey *private_key;
  struct GNUNET_CRYPTO_HpkePrivateKey private_hpke;
  struct GNUNET_CRYPTO_SymmetricSessionKey shared_key;
 
  GNUNET_assert ((group) && (message) && (hash));
 
  private_key = get_epoch_private_key (group->epoch,
                                       GNUNET_TIME_relative_get_hour_ ());
 
  if (! private_key)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Private key for decrypting shared key is missing!\n");
    return;
  }
 
  GNUNET_memcpy (&private_hpke.ecdhe_key,
                 private_key,
                 sizeof *private_key);
  if (GNUNET_NO == extract_access_message_key (message,
                                               &private_hpke,
                                               &shared_key
                                               ))
    return;
 
  set_epoch_group_key (group, &shared_key, GNUNET_YES);
 
  if ((group->epoch->main_group) && (group != group->epoch->main_group) &&
      (get_epoch_group_level (group) <= get_epoch_group_level (group->epoch->
                                                               main_group)))
    return;
 
  cancel_epoch_proposal_group (group->epoch);
 
  send_epoch_group_authorization (group, &(message->body.access.event));
  send_epoch_group_announcement (group);
}

References GNUNET_MESSENGER_MessageBody::access, GNUNET_MESSENGER_Message::body, cancel_epoch_proposal_group(), GNUNET_CRYPTO_HpkePrivateKey::ecdhe_key, GNUNET_MESSENGER_EpochGroup::epoch, GNUNET_MESSENGER_MessageAccess::event, extract_access_message_key(), get_epoch_group_level(), get_epoch_private_key(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcpy, GNUNET_NO, GNUNET_TIME_relative_get_hour_(), GNUNET_YES, GNUNET_MESSENGER_Epoch::main_group, send_epoch_group_announcement(), send_epoch_group_authorization(), and set_epoch_group_key().

Referenced by handle_access_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cont_write_epoch_group_record()

static void cont_write_epoch_group_record	(	void *	cls,
		enum GNUNET_ErrorCode	ec
	)

static

Definition at line 1033 of file messenger_api_epoch_group.c.

{
  struct GNUNET_MESSENGER_EpochGroup *group;
 
  GNUNET_assert (cls);
 
  group = cls;
 
  if (GNUNET_EC_NONE != ec)
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Error writing group key record: %d\n", (int) ec);
 
  group->query = NULL;
}

References GNUNET_assert, GNUNET_EC_NONE, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, and GNUNET_MESSENGER_EpochGroup::query.

Referenced by write_epoch_group_record().

Here is the caller graph for this function:

◆ write_epoch_group_record()

void write_epoch_group_record	(	struct GNUNET_MESSENGER_EpochGroup *	group,
		enum GNUNET_GenericReturnValue	deleted
	)

Writes/Deletes the GNS record of a given epoch group depending on a provided flag that states whether an existing record should be deleted.

Parameters

[in,out]	group	Epoch group
[in]	deleted	Deleted flag

Definition at line 1051 of file messenger_api_epoch_group.c.

{
  const struct GNUNET_MESSENGER_Handle *handle;
  const struct GNUNET_HashCode *hash;
  const struct GNUNET_ShortHashCode *identifier;
  const struct GNUNET_CRYPTO_SymmetricSessionKey *shared_key;
 
  GNUNET_assert ((group) && (group->epoch));
 
  handle = get_room_handle (group->epoch->room);
 
  if (! handle)
    return;
 
  hash = &(group->epoch->hash);
  identifier = &(group->identifier.hash);
 
  if (GNUNET_YES == deleted)
  {
    shared_key = NULL;
  }
  else
  {
    shared_key = group->shared_key;
 
    if (! shared_key)
      return;
  }
 
  store_handle_epoch_key (
    handle, group->epoch->room,
    hash, identifier, shared_key,
    GNUNET_YES == group->valid?
    GNUNET_MESSENGER_FLAG_EPOCH_VALID :
    GNUNET_MESSENGER_FLAG_EPOCH_NONE,
    &cont_write_epoch_group_record,
    group,
    &(group->query));
}

References cont_write_epoch_group_record(), GNUNET_MESSENGER_EpochGroup::epoch, get_room_handle(), GNUNET_assert, GNUNET_MESSENGER_FLAG_EPOCH_NONE, GNUNET_MESSENGER_FLAG_EPOCH_VALID, GNUNET_YES, handle, GNUNET_MESSENGER_EpochIdentifier::hash, GNUNET_MESSENGER_Epoch::hash, GNUNET_MESSENGER_EpochGroup::identifier, GNUNET_MESSENGER_EpochGroup::query, GNUNET_MESSENGER_Epoch::room, GNUNET_MESSENGER_EpochGroup::shared_key, store_handle_epoch_key(), and GNUNET_MESSENGER_EpochGroup::valid.

Referenced by invalidate_epoch_group(), it_group_store_key(), and set_epoch_group_key().

Here is the call graph for this function:

Here is the caller graph for this function:

Data Structures

Functions

Function Documentation

◆ random_epoch_group_identifier()

◆ derive_epoch_group_key()

◆ create_epoch_group()

◆ destroy_epoch_group()

◆ get_epoch_group_level()

◆ get_epoch_group_size()

◆ get_epoch_group_members_count()

◆ is_epoch_group_completed()

◆ is_epoch_group_announced()

◆ set_epoch_group_key()

◆ get_epoch_group_key()

◆ is_epoch_group_key_derived_from()

◆ confirm_epoch_group_member()

◆ get_epoch_group_member_position()

◆ is_epoch_group_member()

◆ it_check_epoch_group_member()

◆ is_epoch_group_subgroup_of()

◆ get_epoch_group_member_hash()

◆ invalidate_epoch_group()

◆ is_epoch_group_proposal()

◆ it_check_epoch_member()

◆ is_epoch_group_compatible()

◆ it_check_epoch_announcement_member()

◆ is_epoch_group_missing_announcement()

◆ get_epoch_group_position_factor()

◆ send_epoch_group_announcement()

◆ send_epoch_group_access()

◆ send_epoch_group_revolution()

◆ send_epoch_group()

◆ send_epoch_group_authorization()

◆ handle_epoch_group_announcement()

◆ handle_epoch_group_announcement_delay()

◆ handle_epoch_group_access()

◆ cont_write_epoch_group_record()

◆ write_epoch_group_record()