#include "gnunet_common.h"
#include "gnunet_time_lib.h"
#include "gnunet_util_lib.h"
#include "messenger_api_epoch_announcement.h"
#include "messenger_api_epoch_group.h"

Include dependency graph for messenger_api_epoch.h:

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

Data Structures
struct	GNUNET_MESSENGER_Epoch

Functions
struct GNUNET_MESSENGER_Epoch *	create_epoch (struct GNUNET_MESSENGER_Room room, const struct GNUNET_HashCode hash)
	Creates and allocates an epoch in a given room which can be identified by a specific hash. More...

struct GNUNET_MESSENGER_Epoch *	create_new_epoch (struct GNUNET_MESSENGER_Room room, const struct GNUNET_HashCode hash)
	Creates and allocates a new epoch in a given room which can be identified by a specific hash. More...

void	destroy_epoch (struct GNUNET_MESSENGER_Epoch *epoch)
	Destroys an epoch and frees its memory fully from the client API. More...

uint32_t	get_epoch_size (const struct GNUNET_MESSENGER_Epoch *epoch)
	Returns the amount of members by a given epoch or zero as long as it's not fully initialized yet. More...

void	reset_epoch_size (struct GNUNET_MESSENGER_Epoch *epoch)
	Resets the amount of members by a given epoch to recalculate the exact amount. More...

enum GNUNET_GenericReturnValue	delay_epoch_message_for_its_members (struct GNUNET_MESSENGER_Epoch epoch, const struct GNUNET_HashCode hash)
	Adds a message with a given hash to a list that can be delayed in processing for the members of a specific epoch until the list of members is complete. More...

const struct GNUNET_CRYPTO_EcdhePrivateKey *	get_epoch_private_key (struct GNUNET_MESSENGER_Epoch *epoch, const struct GNUNET_TIME_Relative timeout)
	Returns the asymmetric private key (ECDHE) from a handle for a given epoch that can be used for HPKE key exchange until a specific timeout. More...

const struct GNUNET_TIME_Relative	get_epoch_private_key_timeout (const struct GNUNET_MESSENGER_Epoch *epoch)
	Returns the current relative timeout for the private key (ECDHE) of a given epoch that limits the usage for its key in terms of HPKE. More...

struct GNUNET_MESSENGER_EpochAnnouncement *	get_epoch_announcement (struct GNUNET_MESSENGER_Epoch epoch, const union GNUNET_MESSENGER_EpochIdentifier identifier, enum GNUNET_GenericReturnValue valid)
	Returns the epoch announcement of a given epoch using a specific unique identifier or NULL. More...

struct GNUNET_MESSENGER_EpochGroup *	get_epoch_group (struct GNUNET_MESSENGER_Epoch epoch, const union GNUNET_MESSENGER_EpochIdentifier identifier, enum GNUNET_GenericReturnValue valid)
	Returns the epoch group of a given epoch using a specific unique identifier or NULL. More...

enum GNUNET_GenericReturnValue	is_epoch_previous_of_other (const struct GNUNET_MESSENGER_Epoch epoch, const struct GNUNET_MESSENGER_Epoch other)
	Returns whether a given epoch is the epoch before some other epoch. More...

const struct GNUNET_MESSENGER_EpochAnnouncement *	get_epoch_previous_announcement (struct GNUNET_MESSENGER_Epoch epoch, const union GNUNET_MESSENGER_EpochIdentifier identifier)
	Returns the epoch announcement of a previous epoch from a given epoch using a specific announcement identifier. More...

const struct GNUNET_MESSENGER_EpochGroup *	get_epoch_previous_group (struct GNUNET_MESSENGER_Epoch epoch, const union GNUNET_MESSENGER_EpochIdentifier identifier)
	Returns the epoch group of a previous epoch from a given epoch using a specific group identifier. More...

uint32_t	get_epoch_member_position (const struct GNUNET_MESSENGER_Epoch epoch, const struct GNUNET_MESSENGER_Contact contact)
	Returns the index position of a specific contact inside a given epoch in relation to its list of members. More...

enum GNUNET_GenericReturnValue	is_epoch_member (const struct GNUNET_MESSENGER_Epoch epoch, const struct GNUNET_MESSENGER_Contact contact)
	Returns whether a specific contact is member of a given epoch. More...

double	get_epoch_position_factor (const struct GNUNET_MESSENGER_Epoch epoch, const struct GNUNET_MESSENGER_Contact contact, const struct GNUNET_MESSENGER_EpochMembership *membership)
	Returns a relative member positon of a specific contact inside a given epoch in relation to its list of members. More...

void	send_epoch_message (const struct GNUNET_MESSENGER_Epoch epoch, struct GNUNET_MESSENGER_Message message)
	Sends a created and allocated message in a room of a given epoch enforcing the message gets interpreted as part of that exact epoch. More...

void	update_epoch_announcement (struct GNUNET_MESSENGER_Epoch epoch, struct GNUNET_MESSENGER_EpochAnnouncement announcement)
	Updates the main announcement of a given epoch, looking into replacing the current main announcement with a specific epoch announcement that's provided. More...

void	update_epoch_group (struct GNUNET_MESSENGER_Epoch epoch, struct GNUNET_MESSENGER_EpochGroup group)
	Updates the main group of a given epoch, looking into replacing the current main group with a specific epoch group that's provided. More...

void	propose_epoch_group (struct GNUNET_MESSENGER_Epoch *epoch, const struct GNUNET_TIME_Relative timeout)
	Tries to propose a new group inside a given epoch that will automatically be formed by using the clients own main group and another group on the same level. More...

void	set_epoch_proposal_group (struct GNUNET_MESSENGER_Epoch epoch, const struct GNUNET_HashCode hash)
	Sets the current group of proposal for a given epoch to the group specified by a message identified by its hash. More...

const struct GNUNET_MESSENGER_EpochGroup *	get_epoch_proposal_group (struct GNUNET_MESSENGER_Epoch *epoch)
	Returns the current group of proposal for a given epoch. More...

void	cancel_epoch_proposal_group (struct GNUNET_MESSENGER_Epoch *epoch)
	Cancels the current proposal of a new group from a given epoch. More...

void	invalidate_epoch_keys_by_member (struct GNUNET_MESSENGER_Epoch epoch, const struct GNUNET_MESSENGER_Contact contact)
	Invalidates all announced epoch and group keys by a specific contact inside a given epoch. More...

Function Documentation

◆ create_epoch()

struct GNUNET_MESSENGER_Epoch * create_epoch	(	struct GNUNET_MESSENGER_Room *	room,
		const struct GNUNET_HashCode *	hash
	)

Creates and allocates an epoch in a given room which can be identified by a specific hash.

Parameters

[in,out]	room	Room
[in]	hash	Hash of epoch

Returns: Epoch

Definition at line 369 of file messenger_api_epoch.c.

{
  struct GNUNET_MESSENGER_Epoch *epoch;
 
  GNUNET_assert ((room) && (hash));
 
  if (GNUNET_is_zero (hash))
    return NULL;
 
  epoch = GNUNET_new (struct GNUNET_MESSENGER_Epoch);
 
  if (! epoch)
    return NULL;
 
  require_message_from_room (room, hash);
 
  GNUNET_memcpy (&(epoch->hash), hash, sizeof (epoch->hash));
  epoch->private_key_expiration = GNUNET_TIME_absolute_get_zero_ ();
  epoch->proposal_expiration = GNUNET_TIME_absolute_get_zero_ ();
 
  epoch->room = room;
  epoch->private_key = NULL;
 
  epoch->waiting = GNUNET_CONTAINER_multihashmap_create (
    8, GNUNET_NO);
 
  epoch->announcements = GNUNET_CONTAINER_multishortmap_create (
    1, GNUNET_NO);
 
  epoch->groups = GNUNET_CONTAINER_multishortmap_create (
    1, GNUNET_NO);
 
  epoch->nonces = GNUNET_CONTAINER_multishortmap_create (
    1, GNUNET_NO);
 
  epoch->members_count = 0;
  epoch->members = NULL;
 
  epoch->main_announcement = NULL;
  epoch->main_group = NULL;
 
  memset (&(epoch->proposal_hash), 0, sizeof (epoch->proposal_hash));
  epoch->proposal_timeout = NULL;
 
  epoch->following_count = 0;
  epoch->following = NULL;
 
  reset_epoch_size (epoch);
 
  return epoch;
}

Referenced by create_new_epoch(), and get_room_epoch().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_new_epoch()

struct GNUNET_MESSENGER_Epoch * create_new_epoch	(	struct GNUNET_MESSENGER_Room *	room,
		const struct GNUNET_HashCode *	hash
	)

Creates and allocates a new epoch in a given room which can be identified by a specific hash.

Parameters

[in,out]	room	Room
[in]	hash	Hash of epoch

Returns: New epoch

Definition at line 508 of file messenger_api_epoch.c.

{
  const struct GNUNET_MESSENGER_Contact **members;
  struct GNUNET_MESSENGER_Epoch *epoch;
  uint32_t members_count;
 
  GNUNET_assert ((room) && (hash));
 
  members = get_members_of_new_epoch (room, hash, &members_count);
 
  if (! members)
    return NULL;
 
  epoch = create_epoch (room, hash);
 
  if (! epoch)
  {
    if (members)
      GNUNET_free (members);
 
    return NULL;
  }
 
  epoch->members_count = members_count;
  epoch->members = members;
 
  {
    const struct GNUNET_MESSENGER_EpochGroup *previous;
 
    previous = get_epoch_previous_group (epoch, NULL);
 
    if ((! previous) || (GNUNET_YES != previous->valid) ||
        (! get_epoch_group_key (previous)) ||
        (GNUNET_YES != is_epoch_group_compatible (previous, epoch)))
      return epoch;
 
    GNUNET_CONTAINER_multishortmap_iterate (previous->epoch->groups,
                                            it_move_epoch_groups_from_previous_epoch,
                                            epoch);
 
    epoch->main_group = get_epoch_group (epoch, &(previous->identifier),
                                         GNUNET_SYSERR);
 
    if (epoch->main_group)
      send_epoch_group_announcement (epoch->main_group);
  }
 
  return epoch;
}

Referenced by get_room_epoch().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ destroy_epoch()

void destroy_epoch ( struct GNUNET_MESSENGER_Epoch * epoch )

Destroys an epoch and frees its memory fully from the client API.

Parameters

[in,out] epoch Epoch

Definition at line 593 of file messenger_api_epoch.c.

{
  GNUNET_assert (epoch);
 
  if (epoch->proposal_timeout)
  {
    GNUNET_SCHEDULER_cancel (epoch->proposal_timeout);
    epoch->proposal_timeout = NULL;
  }
 
  memset (&(epoch->proposal_hash), 0, sizeof (epoch->proposal_hash));
 
  epoch->main_group = NULL;
  epoch->main_announcement = NULL;
 
  if (epoch->nonces)
    GNUNET_CONTAINER_multishortmap_destroy (epoch->nonces);
 
  if (epoch->groups)
  {
    GNUNET_CONTAINER_multishortmap_iterate (epoch->groups,
                                            iterate_destroy_group,
                                            NULL);
 
    GNUNET_CONTAINER_multishortmap_destroy (epoch->groups);
  }
 
  if (epoch->announcements)
  {
    GNUNET_CONTAINER_multishortmap_iterate (epoch->announcements,
                                            iterate_destroy_announcement,
                                            NULL);
 
    GNUNET_CONTAINER_multishortmap_destroy (epoch->announcements);
  }
 
  if (epoch->waiting)
    GNUNET_CONTAINER_multihashmap_destroy (epoch->waiting);
 
  if (epoch->following)
    GNUNET_free (epoch->following);
 
  if (epoch->members)
    GNUNET_free (epoch->members);
 
  if (epoch->private_key)
    GNUNET_free (epoch->private_key);
 
  GNUNET_free (epoch);
}

Referenced by get_room_epoch(), and iterate_destroy_epoch().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_epoch_size()

uint32_t get_epoch_size ( const struct GNUNET_MESSENGER_Epoch * epoch )

Returns the amount of members by a given epoch or zero as long as it's not fully initialized yet.

Parameters

[in] epoch Epoch

Returns: Amount of members

Definition at line 646 of file messenger_api_epoch.c.

{
  GNUNET_assert (epoch);
 
  return epoch->members_count;
}

References GNUNET_MESSENGER_EpochAnnouncement::epoch, GNUNET_assert, and GNUNET_MESSENGER_Epoch::members_count.

Referenced by get_epoch_announcement_size(), get_epoch_position_factor(), and handle_message().

Here is the caller graph for this function:

◆ reset_epoch_size()

void reset_epoch_size ( struct GNUNET_MESSENGER_Epoch * epoch )

Resets the amount of members by a given epoch to recalculate the exact amount.

Parameters

[in,out] epoch Epoch

Definition at line 671 of file messenger_api_epoch.c.

{
  const struct GNUNET_MESSENGER_Contact **members;
  uint32_t members_count;
  uint32_t i;
 
  GNUNET_assert (epoch);
 
  setup_following_epochs_of_previous (epoch);
 
  members = get_members_of_epoch (
    epoch->room, &(epoch->hash), &members_count);
 
  if (! members)
    return;
 
  if (epoch->members)
    GNUNET_free (epoch->members);
 
  epoch->members_count = members_count;
  epoch->members = members;
 
  GNUNET_CONTAINER_multihashmap_iterate (
    epoch->waiting, it_handle_epoch_message_delayed, epoch);
  GNUNET_CONTAINER_multihashmap_clear (epoch->waiting);
 
  for (i = 0; i < epoch->following_count; i++)
    reset_epoch_size (epoch->following[i]);
}

References GNUNET_MESSENGER_Epoch::following, GNUNET_MESSENGER_Epoch::following_count, get_members_of_epoch(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_clear(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_free, GNUNET_MESSENGER_Epoch::hash, it_handle_epoch_message_delayed(), GNUNET_MESSENGER_Epoch::members, GNUNET_MESSENGER_Epoch::members_count, reset_epoch_size(), GNUNET_MESSENGER_Epoch::room, setup_following_epochs_of_previous(), and GNUNET_MESSENGER_Epoch::waiting.

Referenced by create_epoch(), handle_message(), and reset_epoch_size().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ delay_epoch_message_for_its_members()

enum GNUNET_GenericReturnValue delay_epoch_message_for_its_members	(	struct GNUNET_MESSENGER_Epoch *	epoch,
		const struct GNUNET_HashCode *	hash
	)

Adds a message with a given hash to a list that can be delayed in processing for the members of a specific epoch until the list of members is complete.

Parameters

[in,out]	epoch	Epoch
[in]	hash	Hash of message

Returns: GNUNET_YES if the message gets delayed, GNUNET_SYSERR on failure, otherwise GNUNET_NO

Definition at line 703 of file messenger_api_epoch.c.

{
  GNUNET_assert ((epoch) && (hash));
 
  if (epoch->members)
    return GNUNET_NO;
 
  if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (
        epoch->waiting, hash))
    return GNUNET_YES;
 
  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (
        epoch->waiting, hash, NULL,
        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
    return GNUNET_SYSERR;
  else
    return GNUNET_YES;
}

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, GNUNET_MESSENGER_Epoch::members, and GNUNET_MESSENGER_Epoch::waiting.

Referenced by get_room_availble_epoch_entry().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_epoch_private_key()

const struct GNUNET_CRYPTO_EcdhePrivateKey * get_epoch_private_key	(	struct GNUNET_MESSENGER_Epoch *	epoch,
		const struct GNUNET_TIME_Relative	timeout
	)

Returns the asymmetric private key (ECDHE) from a handle for a given epoch that can be used for HPKE key exchange until a specific timeout.

Parameters

[in,out]	epoch	Epoch
[in]	timeout	Timeout for the key

Returns: Private key

Definition at line 725 of file messenger_api_epoch.c.

{
  GNUNET_assert (epoch);
 
  if (epoch->private_key)
    return epoch->private_key;
 
  epoch->private_key = GNUNET_new (struct GNUNET_CRYPTO_EcdhePrivateKey);
 
  if (! epoch->private_key)
    return NULL;
 
  GNUNET_CRYPTO_ecdhe_key_create (epoch->private_key);
 
  epoch->private_key_expiration = GNUNET_TIME_absolute_add (
    GNUNET_TIME_absolute_get (), timeout);
 
  return epoch->private_key;
}

References GNUNET_assert, GNUNET_CRYPTO_ecdhe_key_create(), GNUNET_new, GNUNET_TIME_absolute_add(), GNUNET_TIME_absolute_get(), GNUNET_MESSENGER_Epoch::private_key, GNUNET_MESSENGER_Epoch::private_key_expiration, and timeout.

Referenced by handle_epoch_announcement_access(), handle_epoch_group_access(), send_epoch_announcement(), send_epoch_announcement_appeal(), and send_epoch_group_announcement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_epoch_private_key_timeout()

const struct GNUNET_TIME_Relative get_epoch_private_key_timeout ( const struct GNUNET_MESSENGER_Epoch * epoch )

Returns the current relative timeout for the private key (ECDHE) of a given epoch that limits the usage for its key in terms of HPKE.

Parameters

[in] epoch Epoch

Returns: Timeout of private key

Definition at line 748 of file messenger_api_epoch.c.

{
  GNUNET_assert (epoch);
 
  if (! epoch->private_key)
    return GNUNET_TIME_relative_get_zero_ ();
 
  return GNUNET_TIME_absolute_get_remaining (epoch->private_key_expiration);
}

References GNUNET_assert, GNUNET_TIME_absolute_get_remaining(), and GNUNET_TIME_relative_get_zero_().

Referenced by send_epoch_announcement(), send_epoch_announcement_appeal(), and send_epoch_group_announcement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_epoch_announcement()

struct GNUNET_MESSENGER_EpochAnnouncement * get_epoch_announcement	(	struct GNUNET_MESSENGER_Epoch *	epoch,
		const union GNUNET_MESSENGER_EpochIdentifier *	identifier,
		enum GNUNET_GenericReturnValue	valid
	)

Returns the epoch announcement of a given epoch using a specific unique identifier or NULL.

An optional flag states whether it is important to find a valid epoch announcement for sending encrypted messages. If the identifier is NULL, the announcement with most members gets returned. If the validity flag is set to GNUNET_SYSERR, no new epoch announcement gets created automatically.

Parameters

[in,out]	epoch	Epoch
[in]	identifier	Announcement identifier or NULL
[in]	valid	Validity flag

Returns: Epoch announcement or NULL

Definition at line 830 of file messenger_api_epoch.c.

{
  struct GNUNET_MESSENGER_EpochAnnouncement *announcement;
  GNUNET_CONTAINER_ShortmapIterator iterator;
 
  GNUNET_assert (epoch);
 
  announcement = NULL;
 
  if (GNUNET_YES == valid)
    iterator = it_find_valid_announcement_with_most_members;
  else
    iterator = it_find_announcement_with_most_members;
 
  if (identifier)
  {
    GNUNET_CONTAINER_multishortmap_get_multiple (epoch->announcements,
                                                 &(identifier->hash),
                                                 iterator,
                                                 &announcement);
 
    if ((announcement) || (GNUNET_SYSERR == valid))
      return announcement;
 
    announcement = create_epoch_announcement (epoch, identifier, valid);
 
    if (! announcement)
      return NULL;
 
    if (GNUNET_OK != GNUNET_CONTAINER_multishortmap_put (epoch->announcements,
                                                         &(identifier->hash),
                                                         announcement,
                                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
    {
      destroy_epoch_announcement (announcement);
      return NULL;
    }
 
    if ((GNUNET_YES == valid) && (GNUNET_YES != announcement->valid))
      return NULL;
  }
  else
    GNUNET_CONTAINER_multishortmap_iterate (epoch->announcements,
                                            iterator,
                                            &announcement);
 
  return announcement;
}

References GNUNET_MESSENGER_Epoch::announcements, create_epoch_announcement(), destroy_epoch_announcement(), GNUNET_MESSENGER_EpochAnnouncement::epoch, GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_CONTAINER_multishortmap_get_multiple(), GNUNET_CONTAINER_multishortmap_iterate(), GNUNET_CONTAINER_multishortmap_put(), GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, GNUNET_MESSENGER_EpochIdentifier::hash, GNUNET_MESSENGER_EpochAnnouncement::identifier, it_find_announcement_with_most_members(), it_find_valid_announcement_with_most_members(), and GNUNET_MESSENGER_EpochAnnouncement::valid.

Referenced by cb_key_monitor(), get_epoch_previous_announcement(), handle_access_message(), handle_announcement_message(), handle_appeal_message(), handle_authorization_message(), handle_revolution_message(), handle_room_delayed_announcement(), handle_room_delayed_appeal(), handle_room_delayed_deletion(), handle_secret_message(), invalidate_epoch_announcement(), and send_message_to_room().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_epoch_group()

struct GNUNET_MESSENGER_EpochGroup * get_epoch_group	(	struct GNUNET_MESSENGER_Epoch *	epoch,
		const union GNUNET_MESSENGER_EpochIdentifier *	identifier,
		enum GNUNET_GenericReturnValue	valid
	)

Returns the epoch group of a given epoch using a specific unique identifier or NULL.

An optional flag states whether it is important to find a valid epoch group for sending encrypted messages. If the identifier is NULL, the group with most members gets returned. If the validity flag is set to GNUNET_SYSERR, no new epoch group gets created automatically.

Parameters

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

Returns: Epoch group or NULL

Definition at line 950 of file messenger_api_epoch.c.

{
  struct GNUNET_MESSENGER_EpochGroup *group;
  GNUNET_CONTAINER_ShortmapIterator iterator;
 
  GNUNET_assert (epoch);
 
  group = NULL;
 
  if (GNUNET_YES == valid)
    iterator = it_find_valid_group_with_most_members;
  else
    iterator = it_find_group_with_most_members;
 
  if (identifier)
  {
    GNUNET_CONTAINER_multishortmap_get_multiple (epoch->groups,
                                                 &(identifier->hash),
                                                 iterator,
                                                 &group);
 
    if ((group) || (GNUNET_SYSERR == valid))
      return group;
 
    group = create_epoch_group (epoch, identifier,
                                identifier->code.level_bits,
                                valid);
 
    if (! group)
      return NULL;
 
    if (GNUNET_OK != GNUNET_CONTAINER_multishortmap_put (epoch->groups,
                                                         &(identifier->hash),
                                                         group,
                                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
    {
      destroy_epoch_group (group);
      return NULL;
    }
  }
  else
    GNUNET_CONTAINER_multishortmap_iterate (epoch->groups,
                                            iterator,
                                            &group);
 
  return group;
}

References GNUNET_MESSENGER_EpochIdentifier::code, create_epoch_group(), destroy_epoch_group(), GNUNET_MESSENGER_EpochGroup::epoch, GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_CONTAINER_multishortmap_get_multiple(), GNUNET_CONTAINER_multishortmap_iterate(), GNUNET_CONTAINER_multishortmap_put(), GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, GNUNET_MESSENGER_Epoch::groups, GNUNET_MESSENGER_EpochIdentifier::hash, GNUNET_MESSENGER_EpochGroup::identifier, it_find_group_with_most_members(), it_find_valid_group_with_most_members(), GNUNET_MESSENGER_EpochIdentifierCode::level_bits, and GNUNET_MESSENGER_EpochGroup::valid.

Referenced by cb_key_monitor(), create_new_epoch(), get_epoch_previous_group(), get_epoch_proposal_group(), handle_access_message(), handle_announcement_message(), handle_authorization_message(), handle_group_message(), handle_revolution_message(), handle_room_delayed_announcement(), invalidate_epoch_group(), it_move_epoch_groups_from_previous_epoch(), and send_epoch_group_authorization().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_epoch_previous_of_other()

enum GNUNET_GenericReturnValue is_epoch_previous_of_other	(	const struct GNUNET_MESSENGER_Epoch *	epoch,
		const struct GNUNET_MESSENGER_Epoch *	other
	)

Returns whether a given epoch is the epoch before some other epoch.

Parameters

[in]	epoch	Epoch
[in]	other	Other epoch

Returns: GNUNET_YES if epoch is the previous epoch, GNUNET_SYSERR on internal failure, otherwise GNUNET_NO

Definition at line 1002 of file messenger_api_epoch.c.

{
  const struct GNUNET_MESSENGER_Message *message;
 
  GNUNET_assert ((epoch) && (other));
 
  if (epoch->room != other->room)
    return GNUNET_NO;
 
  message = get_room_message (other->room, &(other->hash));
 
  if (! message)
    return GNUNET_SYSERR;
 
  switch (message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_JOIN:
    return 0 == GNUNET_CRYPTO_hash_cmp (&(epoch->hash), &(message->body.join.
                                                          epoch))?
           GNUNET_YES : GNUNET_NO;
  case GNUNET_MESSENGER_KIND_LEAVE:
    return 0 == GNUNET_CRYPTO_hash_cmp (&(epoch->hash), &(message->body.leave.
                                                          epoch))?
           GNUNET_YES : GNUNET_NO;
  case GNUNET_MESSENGER_KIND_MERGE:
    if (0 == GNUNET_CRYPTO_hash_cmp (&(epoch->hash), &(message->body.merge.
                                                       epochs[0])))
      return GNUNET_YES;
 
    if (0 == GNUNET_CRYPTO_hash_cmp (&(epoch->hash), &(message->body.merge.
                                                       epochs[1])))
      return GNUNET_YES;
 
    return GNUNET_NO;
  default:
    return GNUNET_SYSERR;
  }
}

References GNUNET_MESSENGER_Message::body, epochs, get_room_message(), GNUNET_assert, GNUNET_CRYPTO_hash_cmp(), 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_MessageBody::join, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_MessageBody::leave, GNUNET_MESSENGER_MessageBody::merge, and GNUNET_MESSENGER_Epoch::room.

Here is the call graph for this function:

◆ get_epoch_previous_announcement()

const struct GNUNET_MESSENGER_EpochAnnouncement * get_epoch_previous_announcement	(	struct GNUNET_MESSENGER_Epoch *	epoch,
		const union GNUNET_MESSENGER_EpochIdentifier *	identifier
	)

Returns the epoch announcement of a previous epoch from a given epoch using a specific announcement identifier.

This is utilized for potential key derivation.

Parameters

[in,out]	epoch	Epoch
[in]	identifier	Announcement identifier or NULL

Returns: Epoch announcement or NULL

Definition at line 1044 of file messenger_api_epoch.c.

{
  const struct GNUNET_MESSENGER_Message *message;
  struct GNUNET_MESSENGER_Epoch *previous;
  const struct GNUNET_MESSENGER_EpochAnnouncement *announcement;
 
  GNUNET_assert (epoch);
 
  message = get_room_message (epoch->room, &(epoch->hash));
 
  if ((! message) || (GNUNET_MESSENGER_KIND_LEAVE == message->header.kind))
    return NULL;
 
  previous = get_room_message_epoch (epoch->room,
                                     &(message->header.previous));
 
  if (epoch == previous)
    return NULL;
 
  if (previous)
    announcement = get_epoch_announcement (previous, identifier,
                                           GNUNET_SYSERR);
  else
    announcement = NULL;
 
  if ((! announcement) ||
      (announcement->epoch == epoch) ||
      (0 == GNUNET_CRYPTO_hash_cmp (&(announcement->epoch->hash),
                                    &(epoch->hash))))
    return NULL;
 
  return announcement;
}

References GNUNET_MESSENGER_EpochAnnouncement::epoch, get_epoch_announcement(), get_room_message(), get_room_message_epoch(), GNUNET_assert, GNUNET_CRYPTO_hash_cmp(), GNUNET_MESSENGER_KIND_LEAVE, GNUNET_SYSERR, GNUNET_MESSENGER_Epoch::hash, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_EpochAnnouncement::identifier, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_MessageHeader::previous, and GNUNET_MESSENGER_Epoch::room.

Referenced by create_epoch_announcement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_epoch_previous_group()

const struct GNUNET_MESSENGER_EpochGroup * get_epoch_previous_group	(	struct GNUNET_MESSENGER_Epoch *	epoch,
		const union GNUNET_MESSENGER_EpochIdentifier *	identifier
	)

Returns the epoch group of a previous epoch from a given epoch using a specific group identifier.

This is utilized for potential key derivation and taking over groups from one previous epoch into the current.

Parameters

[in,out]	epoch	Epoch
[in]	identifier	Group identifier or NULL

Returns: Epoch group or NULL

Definition at line 1082 of file messenger_api_epoch.c.

{
  const struct GNUNET_MESSENGER_Message *message;
  struct GNUNET_MESSENGER_Epoch *previous;
  const struct GNUNET_MESSENGER_EpochGroup *group;
 
  GNUNET_assert (epoch);
 
  message = get_room_message (epoch->room, &(epoch->hash));
 
  if (! message)
    return NULL;
 
  previous = get_room_message_epoch (epoch->room, &(message->header.previous));
 
  if (epoch == previous)
    return NULL;
 
  if (previous)
    group = get_epoch_group (previous,
                             identifier,
                             identifier?
                             GNUNET_SYSERR : GNUNET_YES);
  else
    group = NULL;
 
  if (GNUNET_MESSENGER_KIND_MERGE == message->header.kind)
  {
    struct GNUNET_MESSENGER_Epoch *other;
    const struct GNUNET_MESSENGER_EpochGroup *other_group;
 
    other = get_room_message_epoch (
      epoch->room,
      &(message->body.merge.previous));
 
    if (previous == other)
      goto skip_merge;
 
    if (other)
      other_group = get_epoch_group (other, identifier, GNUNET_SYSERR);
    else
      other_group = NULL;
 
    if (GNUNET_YES == is_other_epoch_group_better (group, other_group))
      group = other_group;
  }
 
skip_merge:
  if ((group) && ((group->epoch == epoch) ||
                  (0 == GNUNET_CRYPTO_hash_cmp (&(group->epoch->hash),
                                                &(epoch->hash)))))
    return NULL;
 
  return group;
}

References GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_EpochGroup::epoch, get_epoch_group(), get_room_message(), get_room_message_epoch(), GNUNET_assert, GNUNET_CRYPTO_hash_cmp(), GNUNET_MESSENGER_KIND_MERGE, GNUNET_SYSERR, GNUNET_YES, GNUNET_MESSENGER_Epoch::hash, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_EpochGroup::identifier, is_other_epoch_group_better(), GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_MessageBody::merge, GNUNET_MESSENGER_MessageHeader::previous, GNUNET_MESSENGER_MessageMerge::previous, and GNUNET_MESSENGER_Epoch::room.

Referenced by create_epoch_group(), create_new_epoch(), and get_epoch_group_position_factor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_epoch_member_position()

uint32_t get_epoch_member_position	(	const struct GNUNET_MESSENGER_Epoch *	epoch,
		const struct GNUNET_MESSENGER_Contact *	contact
	)

Returns the index position of a specific contact inside a given epoch in relation to its list of members.

Every member of an epoch gets a unique position.

Parameters

[in]	epoch	Epoch
[in]	contact	Contact

Returns: Member position

Definition at line 1162 of file messenger_api_epoch.c.

{
  const struct GNUNET_CRYPTO_PublicKey *key;
  char *key_string;
  uint32_t position;
  uint32_t i;
  int result;
 
  GNUNET_assert ((epoch) && (contact));
 
  key = get_contact_key (contact);
  key_string = GNUNET_CRYPTO_public_key_to_string (key);
 
  if (! key_string)
    return epoch->members_count;
 
  position = 0;
 
  for (i = 0; i < epoch->members_count; i++)
  {
    result = compare_member_public_keys (
      key_string, get_contact_key (epoch->members[i]));
 
    if ((0 < result) ||
        ((0 == result) && (contact->id < epoch->members[i]->id)))
      position++;
  }
 
  GNUNET_free (key_string);
  return position;
}

References compare_member_public_keys(), get_contact_key(), GNUNET_assert, GNUNET_CRYPTO_public_key_to_string(), GNUNET_free, GNUNET_MESSENGER_Contact::id, key, GNUNET_MESSENGER_Epoch::members, GNUNET_MESSENGER_Epoch::members_count, and result.

Referenced by get_epoch_position_factor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_epoch_member()

enum GNUNET_GenericReturnValue is_epoch_member	(	const struct GNUNET_MESSENGER_Epoch *	epoch,
		const struct GNUNET_MESSENGER_Contact *	contact
	)

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

Parameters

[in]	epoch	Epoch
[in]	contact	Contact

Returns: GNUNET_YES if contact is a member, GNUNET_SYSERR on internal failure, otherwise GNUNET_NO

Definition at line 1304 of file messenger_api_epoch.c.

{
  uint32_t i;
 
  GNUNET_assert ((epoch) && (contact));
 
  for (i = 0; i < epoch->members_count; i++)
    if (contact == epoch->members[i])
      return GNUNET_YES;
 
  return is_epoch_member_in_room (epoch->room, &(epoch->hash), contact);
}

References GNUNET_assert, GNUNET_YES, GNUNET_MESSENGER_Epoch::hash, is_epoch_member_in_room(), GNUNET_MESSENGER_Epoch::members, GNUNET_MESSENGER_Epoch::members_count, and GNUNET_MESSENGER_Epoch::room.

Referenced by confirm_epoch_announcement_member(), confirm_epoch_group_member(), get_room_availble_epoch_entry(), handle_appeal_message(), handle_room_delayed_appeal(), invalidate_epoch_announcement(), and invalidate_epoch_group().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_epoch_position_factor()

double get_epoch_position_factor	(	const struct GNUNET_MESSENGER_Epoch *	epoch,
		const struct GNUNET_MESSENGER_Contact *	contact,
		const struct GNUNET_MESSENGER_EpochMembership *	membership
	)

Returns a relative member positon of a specific contact inside a given epoch in relation to its list of members.

The position gets reduced depending on an optional active membership from a subgroup.

Parameters

[in]	epoch	Epoch
[in]	contact	Contact
[in]	membership	Membership or NULL

Returns: Member position as factor between 0.0 and 1.0

Definition at line 1320 of file messenger_api_epoch.c.

{
  uint32_t members_count;
  uint32_t announced;
  uint32_t position;
 
  GNUNET_assert ((epoch) && (contact));
 
  members_count = get_epoch_size (epoch);
  announced = membership?
              get_epoch_membership_count (membership) : 0;
 
  if (members_count <= announced)
    return 0.0;
 
  position = get_epoch_member_position (epoch, contact);
 
  if (position > announced)
    position -= announced;
  else
    position = 0;
 
  return (0.0 + position) / (members_count - announced);
}

References get_epoch_member_position(), get_epoch_membership_count(), get_epoch_size(), and GNUNET_assert.

Referenced by handle_appeal_message(), and handle_epoch_announcement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ send_epoch_message()

void send_epoch_message	(	const struct GNUNET_MESSENGER_Epoch *	epoch,
		struct GNUNET_MESSENGER_Message *	message
	)

Sends a created and allocated message in a room of a given epoch enforcing the message gets interpreted as part of that exact epoch.

Parameters

[in]	epoch	Epoch
[in,out]	message	Message

Definition at line 1350 of file messenger_api_epoch.c.

{
  GNUNET_assert ((epoch) && (message));
 
  enqueue_message_to_room (epoch->room,
                           &(epoch->hash),
                           message,
                           NULL,
                           GNUNET_YES);
}

References enqueue_message_to_room(), GNUNET_assert, GNUNET_YES, GNUNET_MESSENGER_Epoch::hash, and GNUNET_MESSENGER_Epoch::room.

Referenced by send_epoch_announcement(), send_epoch_announcement_access(), send_epoch_announcement_appeal(), send_epoch_announcement_authorization(), send_epoch_announcement_revolution(), send_epoch_group(), send_epoch_group_access(), send_epoch_group_announcement(), send_epoch_group_authorization(), and send_epoch_group_revolution().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_epoch_announcement()

void update_epoch_announcement	(	struct GNUNET_MESSENGER_Epoch *	epoch,
		struct GNUNET_MESSENGER_EpochAnnouncement *	announcement
	)

Updates the main announcement of a given epoch, looking into replacing the current main announcement with a specific epoch announcement that's provided.

The main announcement will be used for encrypting own messages in that epoch.

Parameters

[in,out]	epoch	Epoch
[in,out]	announcement	Epoch announcement

Definition at line 1364 of file messenger_api_epoch.c.

{
  GNUNET_assert ((epoch) && (announcement));
 
  if (! get_epoch_announcement_key (announcement))
    return;
 
  if (GNUNET_YES != announcement->valid)
    return;
 
  if ((! epoch->main_announcement) ||
      (GNUNET_YES == is_other_epoch_announcement_better (
         epoch->main_announcement, announcement)))
    epoch->main_announcement = announcement;
}

References get_epoch_announcement_key(), GNUNET_assert, GNUNET_YES, is_other_epoch_announcement_better(), GNUNET_MESSENGER_Epoch::main_announcement, and GNUNET_MESSENGER_EpochAnnouncement::valid.

Referenced by confirm_epoch_announcement_member(), and set_epoch_announcement_key().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ update_epoch_group()

void update_epoch_group	(	struct GNUNET_MESSENGER_Epoch *	epoch,
		struct GNUNET_MESSENGER_EpochGroup *	group
	)

Updates the main group of a given epoch, looking into replacing the current main group with a specific epoch group that's provided.

The main group will be used for encrypted key exchange.

Parameters

[in,out]	epoch	Epoch
[in,out]	group	Epoch group

Definition at line 1413 of file messenger_api_epoch.c.

{
  GNUNET_assert ((epoch) && (group));
 
  if (! get_epoch_group_key (group))
    return;
 
  if (GNUNET_YES != group->valid)
    return;
 
  if (GNUNET_YES != is_epoch_group_completed (group))
    return;
 
  if (GNUNET_YES == is_epoch_group_proposal (group))
  {
    if (epoch->proposal_timeout)
      GNUNET_SCHEDULER_cancel (epoch->proposal_timeout);
 
    epoch->proposal_timeout = NULL;
 
    memset (&(epoch->proposal_hash), 0, sizeof (epoch->proposal_hash));
    set_epoch_proposing (epoch, GNUNET_TIME_relative_get_zero_ ());
  }
 
  if ((! epoch->main_group) ||
      (GNUNET_YES == is_other_epoch_group_better (epoch->main_group,
                                                  group)))
    epoch->main_group = group;
}

References get_epoch_group_key(), GNUNET_assert, GNUNET_SCHEDULER_cancel(), GNUNET_TIME_relative_get_zero_(), GNUNET_YES, is_epoch_group_completed(), is_epoch_group_proposal(), is_other_epoch_group_better(), GNUNET_MESSENGER_Epoch::main_group, GNUNET_MESSENGER_Epoch::proposal_hash, GNUNET_MESSENGER_Epoch::proposal_timeout, set_epoch_proposing(), and GNUNET_MESSENGER_EpochGroup::valid.

Referenced by confirm_epoch_group_member(), and set_epoch_group_key().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ propose_epoch_group()

void propose_epoch_group	(	struct GNUNET_MESSENGER_Epoch *	epoch,
		const struct GNUNET_TIME_Relative	timeout
	)

Tries to propose a new group inside a given epoch that will automatically be formed by using the clients own main group and another group on the same level.

The proposal is active until a specified timeout. Multiple groups can not be proposed in parallel by the same client.

Parameters

[in,out]	epoch	Epoch
[in]	timeout	Timeout for proposal

Definition at line 1536 of file messenger_api_epoch.c.

{
  uint32_t level;
  struct GNUNET_MESSENGER_EpochGroup *group;
  struct GNUNET_HashCode initiator;
  struct GNUNET_HashCode partner;
 
  GNUNET_assert (epoch);
 
  if (GNUNET_YES != epoch->room->handle->group_keys)
    return;
 
  if ((epoch->proposal_timeout) ||
      (GNUNET_YES == is_epoch_proposing (epoch)))
    return;
 
  if (epoch->main_group)
  {
    struct GNUNET_CONTAINER_MultiShortmapIterator *iter;
 
    if (GNUNET_YES != is_epoch_group_completed (epoch->main_group))
      return;
 
    if (GNUNET_OK != get_epoch_group_member_hash (epoch->main_group, &(initiator
                                                                       ),
                                                  GNUNET_NO))
      return;
 
    level = get_epoch_group_level (epoch->main_group);
    iter = GNUNET_CONTAINER_multishortmap_iterator_create (epoch->groups);
 
    if (! iter)
      return;
 
    group = NULL;
 
    while (GNUNET_YES == GNUNET_CONTAINER_multishortmap_iterator_next (iter,
                                                                       NULL,
                                                                       (const
                                                                        void**)
                                                                       &group))
    {
      if ((epoch->main_group != group) &&
          (level == get_epoch_group_level (group)) &&
          (GNUNET_YES == is_epoch_group_completed (group)) &&
          (GNUNET_YES != is_epoch_subgroup_of_any_group (epoch, group)))
        break;
 
      group = NULL;
    }
 
    GNUNET_CONTAINER_multishortmap_iterator_destroy (iter);
 
    if (! group)
      return;
 
    if (GNUNET_OK != get_epoch_group_member_hash (group, &partner, GNUNET_YES))
      return;
  }
  else if (epoch->main_announcement)
  {
    struct GNUNET_CONTAINER_MultiHashMapIterator *iter;
    struct GNUNET_HashCode hash;
    const struct GNUNET_MESSENGER_Contact *contact;
 
    if (GNUNET_YES != is_epoch_announcement_announced (epoch->main_announcement)
        )
      return;
 
    if (GNUNET_OK != get_epoch_announcement_member_hash (epoch->
                                                         main_announcement, &(
                                                           initiator), GNUNET_NO
                                                         ))
      return;
 
    level = 0;
    iter = GNUNET_CONTAINER_multihashmap_iterator_create (epoch->
                                                          main_announcement->
                                                          membership->members);
 
    if (! iter)
      return;
 
    contact = NULL;
 
    while (GNUNET_YES == GNUNET_CONTAINER_multihashmap_iterator_next (iter, &
                                                                      hash,
                                                                      (const
                                                                       void**) &
                                                                      contact))
    {
      if ((0 != GNUNET_CRYPTO_hash_cmp (&initiator, &hash)) &&
          (GNUNET_NO == is_epoch_member_in_any_group (epoch, contact)))
        break;
 
      contact = NULL;
    }
 
    GNUNET_CONTAINER_multihashmap_iterator_destroy (iter);
 
    if (! contact)
      return;
 
    GNUNET_memcpy (&partner, &hash, sizeof (partner));
  }
  else
    return;
 
  level++;
  if (level >= 0x80)
    return;
 
  group = create_epoch_group (epoch, NULL, level, GNUNET_YES);
 
  if (! group)
    return;
 
  if (GNUNET_OK != GNUNET_CONTAINER_multishortmap_put (epoch->groups,
                                                       &(group->identifier.hash)
                                                       ,
                                                       group,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
  {
    destroy_epoch_group (group);
    return;
  }
 
  if (GNUNET_OK != send_epoch_group (group, &initiator, &partner, timeout))
  {
    GNUNET_CONTAINER_multishortmap_remove (epoch->groups, &(group->identifier.
                                                            hash), group);
    destroy_epoch_group (group);
    return;
  }
 
  set_epoch_proposing (epoch, timeout);
}

References create_epoch_group(), destroy_epoch_group(), get_epoch_announcement_member_hash(), get_epoch_group_level(), get_epoch_group_member_hash(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_iterator_create(), GNUNET_CONTAINER_multihashmap_iterator_destroy(), GNUNET_CONTAINER_multihashmap_iterator_next(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_CONTAINER_multishortmap_iterator_create(), GNUNET_CONTAINER_multishortmap_iterator_destroy(), GNUNET_CONTAINER_multishortmap_iterator_next(), GNUNET_CONTAINER_multishortmap_put(), GNUNET_CONTAINER_multishortmap_remove(), GNUNET_CRYPTO_hash_cmp(), GNUNET_memcpy, GNUNET_NO, GNUNET_OK, GNUNET_YES, GNUNET_MESSENGER_Handle::group_keys, GNUNET_MESSENGER_Epoch::groups, GNUNET_MESSENGER_Room::handle, GNUNET_MESSENGER_EpochIdentifier::hash, GNUNET_MESSENGER_EpochGroup::identifier, is_epoch_announcement_announced(), is_epoch_group_completed(), is_epoch_member_in_any_group(), is_epoch_proposing(), is_epoch_subgroup_of_any_group(), GNUNET_MESSENGER_Epoch::main_announcement, GNUNET_MESSENGER_Epoch::main_group, GNUNET_MESSENGER_Epoch::members, GNUNET_MESSENGER_Epoch::proposal_timeout, GNUNET_MESSENGER_Epoch::room, send_epoch_group(), set_epoch_proposing(), and timeout.

Referenced by handle_epoch_announcement_delay(), and handle_epoch_group_announcement_delay().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_epoch_proposal_group()

void set_epoch_proposal_group	(	struct GNUNET_MESSENGER_Epoch *	epoch,
		const struct GNUNET_HashCode *	hash
	)

Sets the current group of proposal for a given epoch to the group specified by a message identified by its hash.

Timeout for the proposal and other properties will be derived from that message accordingly.

Parameters

[in,out]	epoch	Epoch
[in]	hash	Hash of message

Definition at line 1677 of file messenger_api_epoch.c.

{
  const struct GNUNET_MESSENGER_Message *group_message;
  struct GNUNET_TIME_Relative timeout;
 
  GNUNET_assert ((epoch) && (hash));
 
  if (epoch->proposal_timeout)
    return;
 
  group_message = get_room_message (epoch->room, hash);
 
  if (! group_message)
    return;
 
  if (GNUNET_MESSENGER_KIND_GROUP != group_message->header.kind)
    return;
 
  if (! group_message->body.group.identifier.code.group_bit)
    return;
 
  timeout = get_message_timeout (group_message);
 
  if (GNUNET_TIME_relative_is_zero (timeout))
    return;
 
  GNUNET_memcpy (&(epoch->proposal_hash), hash, sizeof (epoch->proposal_hash));
  set_epoch_proposing (epoch, timeout);
 
  epoch->proposal_timeout = GNUNET_SCHEDULER_add_delayed_with_priority (
    timeout,
    GNUNET_SCHEDULER_PRIORITY_HIGH,
    on_epoch_proposal_timeout,
    epoch);
}

References GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_EpochIdentifier::code, get_message_timeout(), get_room_message(), GNUNET_assert, GNUNET_memcpy, GNUNET_MESSENGER_KIND_GROUP, GNUNET_SCHEDULER_add_delayed_with_priority(), GNUNET_SCHEDULER_PRIORITY_HIGH, GNUNET_TIME_relative_is_zero(), GNUNET_MESSENGER_MessageBody::group, GNUNET_MESSENGER_EpochIdentifierCode::group_bit, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageGroup::identifier, GNUNET_MESSENGER_MessageHeader::kind, on_epoch_proposal_timeout(), GNUNET_MESSENGER_Epoch::proposal_hash, GNUNET_MESSENGER_Epoch::proposal_timeout, GNUNET_MESSENGER_Epoch::room, set_epoch_proposing(), and timeout.

Referenced by handle_group_message().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_epoch_proposal_group()

const struct GNUNET_MESSENGER_EpochGroup * get_epoch_proposal_group ( struct GNUNET_MESSENGER_Epoch * epoch )

Returns the current group of proposal for a given epoch.

Parameters

[in,out] epoch Epoch

Returns: Proposal group or NULL

Definition at line 1716 of file messenger_api_epoch.c.

{
  const struct GNUNET_MESSENGER_Message *group_message;
 
  GNUNET_assert (epoch);
 
  group_message = get_room_message (epoch->room, &(epoch->proposal_hash));
 
  if (! group_message)
    return NULL;
 
  if (GNUNET_MESSENGER_KIND_GROUP != group_message->header.kind)
    return NULL;
 
  if (! group_message->body.group.identifier.code.group_bit)
    return NULL;
 
  return get_epoch_group (epoch, &(group_message->body.group.identifier),
                          GNUNET_NO);
}

References GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_EpochIdentifier::code, get_epoch_group(), get_room_message(), GNUNET_assert, GNUNET_MESSENGER_KIND_GROUP, GNUNET_NO, GNUNET_MESSENGER_MessageBody::group, GNUNET_MESSENGER_EpochIdentifierCode::group_bit, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageGroup::identifier, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_Epoch::proposal_hash, and GNUNET_MESSENGER_Epoch::room.

Referenced by cancel_epoch_proposal_group(), handle_epoch_group_announcement(), and is_epoch_group_proposal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ cancel_epoch_proposal_group()

void cancel_epoch_proposal_group ( struct GNUNET_MESSENGER_Epoch * epoch )

Cancels the current proposal of a new group from a given epoch.

Parameters

[in,out] epoch Epoch

Definition at line 1739 of file messenger_api_epoch.c.

{
  const struct GNUNET_MESSENGER_EpochGroup *proposal_group;
 
  GNUNET_assert (epoch);
 
  if (epoch->proposal_timeout)
  {
    GNUNET_SCHEDULER_cancel (epoch->proposal_timeout);
    epoch->proposal_timeout = NULL;
  }
 
  proposal_group = get_epoch_proposal_group (epoch);
 
  memset (&(epoch->proposal_hash), 0, sizeof (epoch->proposal_hash));
 
  if (! proposal_group)
    return;
 
  if (GNUNET_YES != is_epoch_group_completed (proposal_group))
    GNUNET_CONTAINER_multishortmap_remove (epoch->groups,
                                           &(proposal_group->identifier.hash),
                                           proposal_group);
}

References GNUNET_MESSENGER_EpochGroup::epoch, get_epoch_proposal_group(), GNUNET_assert, GNUNET_CONTAINER_multishortmap_remove(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, GNUNET_MESSENGER_Epoch::groups, GNUNET_MESSENGER_EpochIdentifier::hash, GNUNET_MESSENGER_EpochGroup::identifier, is_epoch_group_completed(), GNUNET_MESSENGER_Epoch::proposal_hash, and GNUNET_MESSENGER_Epoch::proposal_timeout.

Referenced by handle_epoch_group_access(), handle_epoch_group_announcement(), and on_epoch_proposal_timeout().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ invalidate_epoch_keys_by_member()

void invalidate_epoch_keys_by_member	(	struct GNUNET_MESSENGER_Epoch *	epoch,
		const struct GNUNET_MESSENGER_Contact *	contact
	)

Invalidates all announced epoch and group keys by a specific contact inside a given epoch.

Parameters

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

Definition at line 1802 of file messenger_api_epoch.c.

{
  GNUNET_assert ((epoch) && (contact));
 
  GNUNET_CONTAINER_multishortmap_iterate (epoch->announcements,
                                          iterate_epoch_announcement_invalidation,
                                          &contact);
 
  GNUNET_CONTAINER_multishortmap_iterate (epoch->groups,
                                          iterate_epoch_group_invalidation,
                                          &contact);
}

References GNUNET_MESSENGER_Epoch::announcements, GNUNET_MESSENGER_EpochGroup::epoch, GNUNET_assert, GNUNET_CONTAINER_multishortmap_iterate(), GNUNET_MESSENGER_Epoch::groups, iterate_epoch_announcement_invalidation(), and iterate_epoch_group_invalidation().

Referenced by iterate_room_epoch_member_invalidation().

Here is the call graph for this function:

Here is the caller graph for this function:

Data Structures

Functions

Function Documentation

◆ create_epoch()

◆ create_new_epoch()

◆ destroy_epoch()

◆ get_epoch_size()

◆ reset_epoch_size()

◆ delay_epoch_message_for_its_members()

◆ get_epoch_private_key()

◆ get_epoch_private_key_timeout()

◆ get_epoch_announcement()

◆ get_epoch_group()

◆ is_epoch_previous_of_other()

◆ get_epoch_previous_announcement()

◆ get_epoch_previous_group()

◆ get_epoch_member_position()

◆ is_epoch_member()

◆ get_epoch_position_factor()

◆ send_epoch_message()

◆ update_epoch_announcement()

◆ update_epoch_group()

◆ propose_epoch_group()

◆ set_epoch_proposal_group()

◆ get_epoch_proposal_group()

◆ cancel_epoch_proposal_group()

◆ invalidate_epoch_keys_by_member()