#include "messenger_api_epoch.h"
#include "gnunet_common.h"
#include "gnunet_messenger_service.h"
#include "gnunet_util_lib.h"
#include "messenger_api.h"
#include "messenger_api_contact.h"
#include "messenger_api_epoch_announcement.h"
#include "messenger_api_epoch_group.h"
#include "messenger_api_message.h"
#include "messenger_api_room.h"
#include <stdint.h>

Include dependency graph for messenger_api_epoch.c:

Functions
static const struct GNUNET_MESSENGER_Contact **	get_members_of_epoch (struct GNUNET_MESSENGER_Room room, const struct GNUNET_HashCode epoch, uint32_t *members_count)

static void	add_following_epoch (struct GNUNET_MESSENGER_Epoch epoch, struct GNUNET_MESSENGER_Epoch follow)

static void	setup_following_epochs_of_previous (struct GNUNET_MESSENGER_Epoch *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. More...

static enum GNUNET_GenericReturnValue	is_epoch_member_in_room (const struct GNUNET_MESSENGER_Room room, const struct GNUNET_HashCode epoch, const struct GNUNET_MESSENGER_Contact *contact)

static const struct GNUNET_MESSENGER_Contact **	get_members_of_new_epoch (struct GNUNET_MESSENGER_Room room, const struct GNUNET_HashCode epoch, uint32_t *members_count)

static enum GNUNET_GenericReturnValue	it_move_epoch_groups_from_previous_epoch (void cls, const struct GNUNET_ShortHashCode key, void *value)

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...

static enum GNUNET_GenericReturnValue	iterate_destroy_group (void cls, const struct GNUNET_ShortHashCode key, void *value)

static enum GNUNET_GenericReturnValue	iterate_destroy_announcement (void cls, const struct GNUNET_ShortHashCode key, void *value)

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...

static enum GNUNET_GenericReturnValue	it_handle_epoch_message_delayed (void cls, const struct GNUNET_HashCode key, void *value)

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...

static enum GNUNET_GenericReturnValue	is_other_epoch_announcement_better (const struct GNUNET_MESSENGER_EpochAnnouncement announcement, const struct GNUNET_MESSENGER_EpochAnnouncement other)

static enum GNUNET_GenericReturnValue	it_find_announcement_with_most_members (void cls, const struct GNUNET_ShortHashCode key, void *value)

static enum GNUNET_GenericReturnValue	it_find_valid_announcement_with_most_members (void cls, const struct GNUNET_ShortHashCode key, void *value)

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...

static enum GNUNET_GenericReturnValue	is_other_epoch_group_better (const struct GNUNET_MESSENGER_EpochGroup group, const struct GNUNET_MESSENGER_EpochGroup other)

static enum GNUNET_GenericReturnValue	it_find_group_with_most_members (void cls, const struct GNUNET_ShortHashCode key, void *value)

static enum GNUNET_GenericReturnValue	it_find_valid_group_with_most_members (void cls, const struct GNUNET_ShortHashCode key, void *value)

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...

static int	compare_member_public_keys (const char key_string, const struct GNUNET_CRYPTO_PublicKey key)

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...

static enum GNUNET_GenericReturnValue	is_epoch_sender_in_room (const struct GNUNET_MESSENGER_Room room, const struct GNUNET_HashCode epoch, const struct GNUNET_MESSENGER_Contact *contact)

static enum GNUNET_GenericReturnValue	is_epoch_member_in_room_graph (const struct GNUNET_MESSENGER_Room room, const struct GNUNET_HashCode epoch, const struct GNUNET_MESSENGER_Contact contact, struct GNUNET_CONTAINER_MultiHashMap map)

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...

static void	set_epoch_proposing (struct GNUNET_MESSENGER_Epoch *epoch, struct GNUNET_TIME_Relative timeout)

static enum GNUNET_GenericReturnValue	is_epoch_proposing (const struct GNUNET_MESSENGER_Epoch *epoch)

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...

static void	on_epoch_proposal_timeout (void *cls)

static enum GNUNET_GenericReturnValue	is_epoch_subgroup_of_any_group (struct GNUNET_MESSENGER_Epoch epoch, const struct GNUNET_MESSENGER_EpochGroup subgroup)

enum GNUNET_GenericReturnValue	is_epoch_member_in_any_group (struct GNUNET_MESSENGER_Epoch epoch, const struct GNUNET_MESSENGER_Contact contact)

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...

static enum GNUNET_GenericReturnValue	iterate_epoch_announcement_invalidation (void cls, const struct GNUNET_ShortHashCode key, void *value)

static enum GNUNET_GenericReturnValue	iterate_epoch_group_invalidation (void cls, const struct GNUNET_ShortHashCode key, void *value)

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

◆ get_members_of_epoch()

static const struct GNUNET_MESSENGER_Contact ** get_members_of_epoch	(	struct GNUNET_MESSENGER_Room *	room,
		const struct GNUNET_HashCode *	epoch,
		uint32_t *	members_count
	)

static

Definition at line 40 of file messenger_api_epoch.c.

{
  const struct GNUNET_MESSENGER_Message *message;
  const struct GNUNET_MESSENGER_Contact **members;
  uint32_t allocation_count;
  uint32_t count;
 
  GNUNET_assert ((room) && (epoch) && (members_count));
 
  message = get_room_message (room, epoch);
 
  if (! message)
    return NULL;
 
  switch (message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_JOIN:
    {
      struct GNUNET_MESSENGER_Epoch *previous;
      const struct GNUNET_MESSENGER_Contact *contact;
 
      contact = get_room_sender (room, epoch);
 
      if (! contact)
        return NULL;
 
      if (GNUNET_is_zero (&(message->body.join.epoch)))
      {
        allocation_count = 1;
        count = 0;
 
        members = GNUNET_malloc (
          allocation_count * sizeof (const struct GNUNET_MESSENGER_Contact*));
 
        if (! members)
          return NULL;
 
        members[count++] = contact;
 
        *members_count = count;
        return members;
      }
 
      previous = get_room_epoch (
        room, &(message->body.join.epoch), GNUNET_NO);
 
      if ((previous) && (previous->members))
      {
        allocation_count = previous->members_count + 1;
 
        for (count = 0; count < previous->members_count; count++)
        {
          if (previous->members[count] == contact)
          {
            allocation_count = previous->members_count;
            break;
          }
        }
 
        members = GNUNET_malloc (
          allocation_count * sizeof (const struct GNUNET_MESSENGER_Contact*));
 
        if (! members)
          return NULL;
 
        for (count = 0; count < previous->members_count; count++)
          members[count] = previous->members[count];
 
        if (count < allocation_count)
          members[count++] = contact;
 
        *members_count = count;
        return members;
      }
 
      break;
    }
  case GNUNET_MESSENGER_KIND_LEAVE:
    {
      struct GNUNET_MESSENGER_Epoch *previous;
      const struct GNUNET_MESSENGER_Contact *contact;
 
      previous = get_room_epoch (
        room, &(message->body.leave.epoch), GNUNET_NO);
      contact = get_room_sender (room, epoch);
 
      if ((previous) && (previous->members) && (contact))
      {
        uint32_t index;
 
        allocation_count = previous->members_count > 1?
                           previous->members_count - 1 : 1;
        count = 0;
 
        members = GNUNET_malloc (
          allocation_count * sizeof (const struct GNUNET_MESSENGER_Contact*));
 
        if (! members)
          return NULL;
 
        for (index = 0; index < previous->members_count; index++)
          if (previous->members[index] != contact)
            members[count++] = previous->members[index];
 
        *members_count = count;
        return members;
      }
    }
  case GNUNET_MESSENGER_KIND_MERGE:
    {
      struct GNUNET_MESSENGER_Epoch *prev0;
      struct GNUNET_MESSENGER_Epoch *prev1;
 
      prev0 = get_room_epoch (room, &(message->body.merge.epochs[0]),
                              GNUNET_NO);
      prev1 = get_room_epoch (room, &(message->body.merge.epochs[1]),
                              GNUNET_NO);
 
      if ((prev0) && (prev1) && (prev0->members) && (prev1->members))
      {
        enum GNUNET_GenericReturnValue drop;
        uint32_t duplicates;
        uint32_t index;
 
        allocation_count = prev0->members_count + prev1->members_count;
        duplicates = 0;
 
        for (index = 0; index < prev0->members_count; index++)
        {
          for (count = 0; count < prev1->members_count; count++)
          {
            if (prev1->members[count] == prev0->members[index])
            {
              duplicates++;
              break;
            }
          }
        }
 
        if (! allocation_count)
          return NULL;
 
        if (allocation_count > duplicates)
          allocation_count -= duplicates;
        else
          allocation_count = 1;
 
        members = GNUNET_malloc (
          allocation_count * sizeof (const struct GNUNET_MESSENGER_Contact*));
 
        if (! members)
          return NULL;
 
        count = 0;
 
        for (index = 0; index < prev0->members_count; index++)
          members[count++] = prev0->members[index];
 
        for (index = 0; index < prev1->members_count; index++)
        {
          drop = GNUNET_NO;
 
          for (duplicates = 0; duplicates < prev0->members_count; duplicates++
               )
          {
            if (prev0->members[duplicates] == prev1->members[index])
            {
              drop = GNUNET_YES;
              break;
            }
          }
 
          if (GNUNET_YES == drop)
            continue;
 
          members[count++] = prev1->members[index];
        }
 
        *members_count = count;
        return members;
      }
      else if ((prev0) && (! prev1) && (prev0->members))
      {
        uint32_t index;
 
        allocation_count = prev0->members_count;
 
        members = GNUNET_malloc (
          allocation_count * sizeof (const struct GNUNET_MESSENGER_Contact*));
 
        if (! members)
          return NULL;
 
        count = 0;
 
        for (index = 0; index < prev0->members_count; index++)
          members[count++] = prev0->members[index];
 
        *members_count = count;
        return members;
      }
      else if ((! prev0) && (prev1) && (prev1->members))
      {
        uint32_t index;
 
        allocation_count = prev1->members_count;
 
        members = GNUNET_malloc (
          allocation_count * sizeof (const struct GNUNET_MESSENGER_Contact*));
 
        if (! members)
          return NULL;
 
        count = 0;
 
        for (index = 0; index < prev1->members_count; index++)
          members[count++] = prev1->members[index];
 
        *members_count = count;
        return members;
      }
    }
  default:
    break;
  }
 
  return NULL;
}

Referenced by get_members_of_new_epoch(), and reset_epoch_size().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ add_following_epoch()

static void add_following_epoch	(	struct GNUNET_MESSENGER_Epoch *	epoch,
		struct GNUNET_MESSENGER_Epoch *	follow
	)

static

Definition at line 273 of file messenger_api_epoch.c.

{
  struct GNUNET_MESSENGER_Epoch **follows;
  uint32_t count;
  uint32_t i;
 
  GNUNET_assert ((epoch) && (follow));
 
  if (epoch == follow)
    return;
 
  for (i = 0; i < epoch->following_count; i++)
  {
    if (epoch->following[i] == follow)
      return;
  }
 
  count = epoch->following_count + 1;
  follows = GNUNET_malloc (sizeof (struct GNUNET_MESSENGER_Epoch*) * count);
 
  if (! follows)
    return;
 
  for (i = 0; i < epoch->following_count; i++)
    follows[i] = epoch->following[i];
 
  follows[epoch->following_count] = follow;
 
  if (epoch->following)
    GNUNET_free (epoch->following);
 
  epoch->following_count = count;
  epoch->following = follows;
}

References GNUNET_MESSENGER_Epoch::following, GNUNET_MESSENGER_Epoch::following_count, GNUNET_assert, GNUNET_free, and GNUNET_malloc.

Referenced by setup_following_epochs_of_previous().

Here is the caller graph for this function:

◆ setup_following_epochs_of_previous()

static void setup_following_epochs_of_previous ( struct GNUNET_MESSENGER_Epoch * epoch )

static

Definition at line 311 of file messenger_api_epoch.c.

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

Referenced by reset_epoch_size().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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:

◆ is_epoch_member_in_room()

static enum GNUNET_GenericReturnValue is_epoch_member_in_room	(	const struct GNUNET_MESSENGER_Room *	room,
		const struct GNUNET_HashCode *	epoch,
		const struct GNUNET_MESSENGER_Contact *	contact
	)

static

Definition at line 1279 of file messenger_api_epoch.c.

{
  struct GNUNET_CONTAINER_MultiHashMap *map;
  enum GNUNET_GenericReturnValue result;
 
  GNUNET_assert ((room) && (epoch) && (contact));
 
  if (GNUNET_is_zero (epoch))
    return GNUNET_NO;
 
  map = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
 
  if (! map)
    return GNUNET_NO;
 
  result = is_epoch_member_in_room_graph (room, epoch, contact, map);
 
  GNUNET_CONTAINER_multihashmap_destroy (map);
  return result;
}

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_is_zero, GNUNET_NO, is_epoch_member_in_room_graph(), map, and result.

Referenced by get_members_of_new_epoch(), and is_epoch_member().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_members_of_new_epoch()

static const struct GNUNET_MESSENGER_Contact ** get_members_of_new_epoch	(	struct GNUNET_MESSENGER_Room *	room,
		const struct GNUNET_HashCode *	epoch,
		uint32_t *	members_count
	)

static

Definition at line 429 of file messenger_api_epoch.c.

{
  struct GNUNET_CONTAINER_MultiShortmapIterator *it;
  const struct GNUNET_MESSENGER_Contact **members;
  uint32_t allocation_count;
  uint32_t count;
 
  GNUNET_assert ((room) && (epoch) && (members_count));
 
  members = get_members_of_epoch (room, epoch, members_count);
 
  if (members)
    return members;
 
  allocation_count = GNUNET_CONTAINER_multishortmap_size (room->members);
  count = 0;
 
  it = GNUNET_CONTAINER_multishortmap_iterator_create (room->members);
 
  if (it)
  {
    struct GNUNET_ShortHashCode member_id;
    const struct GNUNET_MESSENGER_Contact *member;
 
    members = GNUNET_malloc (
      allocation_count * sizeof (const struct GNUNET_MESSENGER_Contact*));
 
    if (! members)
      goto skip_iterator;
 
    while (GNUNET_YES == GNUNET_CONTAINER_multishortmap_iterator_next (it, &
                                                                       member_id,
                                                                       (const
                                                                        void**)
                                                                       &member))
    {
      if (GNUNET_YES == is_epoch_member_in_room (room, epoch, member))
        members[count++] = member;
    }
 
skip_iterator:
    GNUNET_CONTAINER_multishortmap_iterator_destroy (it);
  }
 
  GNUNET_assert (allocation_count >= count);
 
  *members_count = count;
  return members;
}

References get_members_of_epoch(), GNUNET_assert, GNUNET_CONTAINER_multishortmap_iterator_create(), GNUNET_CONTAINER_multishortmap_iterator_destroy(), GNUNET_CONTAINER_multishortmap_iterator_next(), GNUNET_CONTAINER_multishortmap_size(), GNUNET_malloc, GNUNET_YES, is_epoch_member_in_room(), and GNUNET_MESSENGER_Room::members.

Referenced by create_new_epoch().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ it_move_epoch_groups_from_previous_epoch()

static enum GNUNET_GenericReturnValue it_move_epoch_groups_from_previous_epoch	(	void *	cls,
		const struct GNUNET_ShortHashCode *	key,
		void *	value
	)

static

Definition at line 483 of file messenger_api_epoch.c.

{
  struct GNUNET_MESSENGER_Epoch *epoch;
  struct GNUNET_MESSENGER_EpochGroup *group;
 
  GNUNET_assert ((cls) && (value));
 
  epoch = cls;
  group = value;
 
  if ((GNUNET_YES != group->valid) ||
      (! get_epoch_group_key (group)) ||
      (GNUNET_YES != is_epoch_group_announced (group)) ||
      (GNUNET_YES != is_epoch_group_compatible (group, epoch)))
    return GNUNET_YES;
 
  get_epoch_group (epoch, &(group->identifier), GNUNET_YES);
  return GNUNET_YES;
}

References GNUNET_MESSENGER_EpochGroup::epoch, get_epoch_group(), get_epoch_group_key(), GNUNET_assert, GNUNET_YES, GNUNET_MESSENGER_EpochGroup::identifier, is_epoch_group_announced(), is_epoch_group_compatible(), GNUNET_MESSENGER_EpochGroup::valid, and value.

Referenced by create_new_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:

◆ iterate_destroy_group()

static enum GNUNET_GenericReturnValue iterate_destroy_group	(	void *	cls,
		const struct GNUNET_ShortHashCode *	key,
		void *	value
	)

static

Definition at line 561 of file messenger_api_epoch.c.

{
  struct GNUNET_MESSENGER_EpochGroup *group;
 
  GNUNET_assert (value);
 
  group = value;
 
  destroy_epoch_group (group);
  return GNUNET_YES;
}

References destroy_epoch_group(), GNUNET_assert, GNUNET_YES, and value.

Referenced by destroy_epoch().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ iterate_destroy_announcement()

static enum GNUNET_GenericReturnValue iterate_destroy_announcement	(	void *	cls,
		const struct GNUNET_ShortHashCode *	key,
		void *	value
	)

static

Definition at line 577 of file messenger_api_epoch.c.

{
  struct GNUNET_MESSENGER_EpochAnnouncement *announcement;
 
  GNUNET_assert (value);
 
  announcement = value;
 
  destroy_epoch_announcement (announcement);
  return GNUNET_YES;
}

References destroy_epoch_announcement(), GNUNET_assert, GNUNET_YES, and value.

Referenced by destroy_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:

◆ it_handle_epoch_message_delayed()

static enum GNUNET_GenericReturnValue it_handle_epoch_message_delayed	(	void *	cls,
		const struct GNUNET_HashCode *	key,
		void *	value
	)

static

Definition at line 655 of file messenger_api_epoch.c.

{
  struct GNUNET_MESSENGER_Epoch *epoch;
 
  GNUNET_assert ((cls) && (key));
 
  epoch = cls;
 
  update_room_message (epoch->room, key);
  return GNUNET_YES;
}

References GNUNET_assert, GNUNET_YES, key, GNUNET_MESSENGER_Epoch::room, and update_room_message().

Referenced by reset_epoch_size().

Here is the call graph for this function:

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:

◆ is_other_epoch_announcement_better()

static enum GNUNET_GenericReturnValue is_other_epoch_announcement_better	(	const struct GNUNET_MESSENGER_EpochAnnouncement *	announcement,
		const struct GNUNET_MESSENGER_EpochAnnouncement *	other
	)

static

Definition at line 760 of file messenger_api_epoch.c.

{
  uint32_t count;
  uint32_t max;
 
  if (! other)
    return GNUNET_NO;
  if (! announcement)
    return GNUNET_YES;
 
  count = get_epoch_announcement_members_count (other);
  max = get_epoch_announcement_members_count (announcement);
 
  if (count > max)
    return GNUNET_YES;
  else if (count < max)
    return GNUNET_NO;
 
  if (0 < GNUNET_memcmp (&(other->identifier), &(announcement->identifier)))
    return GNUNET_YES;
  else
    return GNUNET_NO;
}

References get_epoch_announcement_members_count(), GNUNET_memcmp, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_EpochAnnouncement::identifier, and max.

Referenced by it_find_announcement_with_most_members(), and update_epoch_announcement().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ it_find_announcement_with_most_members()

static enum GNUNET_GenericReturnValue it_find_announcement_with_most_members	(	void *	cls,
		const struct GNUNET_ShortHashCode *	key,
		void *	value
	)

static

Definition at line 790 of file messenger_api_epoch.c.

{
  struct GNUNET_MESSENGER_EpochAnnouncement **result;
  struct GNUNET_MESSENGER_EpochAnnouncement *announcement;
 
  GNUNET_assert ((cls) && (key) && (value));
 
  result = cls;
  announcement = value;
 
  if (GNUNET_YES == is_other_epoch_announcement_better (*result, announcement))
    *result = announcement;
 
  return GNUNET_YES;
}

References GNUNET_assert, GNUNET_YES, is_other_epoch_announcement_better(), key, result, and value.

Referenced by get_epoch_announcement(), and it_find_valid_announcement_with_most_members().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ it_find_valid_announcement_with_most_members()

static enum GNUNET_GenericReturnValue it_find_valid_announcement_with_most_members	(	void *	cls,
		const struct GNUNET_ShortHashCode *	key,
		void *	value
	)

static

Definition at line 810 of file messenger_api_epoch.c.

{
  struct GNUNET_MESSENGER_EpochAnnouncement *announcement;
 
  GNUNET_assert ((cls) && (key) && (value));
 
  announcement = value;
 
  if ((GNUNET_YES != announcement->valid) ||
      (! get_epoch_announcement_key (announcement)))
    return GNUNET_YES;
 
  return it_find_announcement_with_most_members (cls, key, value);
}

References get_epoch_announcement_key(), GNUNET_assert, GNUNET_YES, it_find_announcement_with_most_members(), key, GNUNET_MESSENGER_EpochAnnouncement::valid, and value.

Referenced by get_epoch_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:

◆ is_other_epoch_group_better()

static enum GNUNET_GenericReturnValue is_other_epoch_group_better	(	const struct GNUNET_MESSENGER_EpochGroup *	group,
		const struct GNUNET_MESSENGER_EpochGroup *	other
	)

static

Definition at line 884 of file messenger_api_epoch.c.

{
  uint32_t count;
  uint32_t max;
 
  if (! other)
    return GNUNET_NO;
  if (! group)
    return GNUNET_YES;
 
  count = get_epoch_group_members_count (other);
  max = get_epoch_group_members_count (group);
 
  if (count > max)
    return GNUNET_YES;
  else if (count < max)
    return GNUNET_NO;
 
  if (0 < GNUNET_memcmp (&(other->identifier), &(group->identifier)))
    return GNUNET_YES;
  else
    return GNUNET_NO;
}

References get_epoch_group_members_count(), GNUNET_memcmp, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_EpochGroup::identifier, and max.

Referenced by get_epoch_previous_group(), it_find_group_with_most_members(), and update_epoch_group().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ it_find_group_with_most_members()

static enum GNUNET_GenericReturnValue it_find_group_with_most_members	(	void *	cls,
		const struct GNUNET_ShortHashCode *	key,
		void *	value
	)

static

Definition at line 911 of file messenger_api_epoch.c.

{
  struct GNUNET_MESSENGER_EpochGroup **result;
  struct GNUNET_MESSENGER_EpochGroup *group;
 
  GNUNET_assert ((cls) && (key) && (value));
 
  result = cls;
  group = value;
 
  if (GNUNET_YES == is_other_epoch_group_better (*result, group))
    *result = group;
 
  return GNUNET_YES;
}

References GNUNET_assert, GNUNET_YES, is_other_epoch_group_better(), key, result, and value.

Referenced by get_epoch_group(), and it_find_valid_group_with_most_members().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ it_find_valid_group_with_most_members()

static enum GNUNET_GenericReturnValue it_find_valid_group_with_most_members	(	void *	cls,
		const struct GNUNET_ShortHashCode *	key,
		void *	value
	)

static

Definition at line 931 of file messenger_api_epoch.c.

{
  struct GNUNET_MESSENGER_EpochGroup *group;
 
  GNUNET_assert ((cls) && (key) && (value));
 
  group = value;
 
  if ((GNUNET_YES != group->valid) ||
      (! get_epoch_group_key (group)))
    return GNUNET_YES;
 
  return it_find_group_with_most_members (cls, key, value);
}

References get_epoch_group_key(), GNUNET_assert, GNUNET_YES, it_find_group_with_most_members(), key, GNUNET_MESSENGER_EpochGroup::valid, and value.

Referenced by get_epoch_group().

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:

◆ compare_member_public_keys()

static int compare_member_public_keys	(	const char *	key_string,
		const struct GNUNET_CRYPTO_PublicKey *	key
	)

static

Definition at line 1142 of file messenger_api_epoch.c.

{
  char *str;
  int result;
 
  GNUNET_assert ((key_string) && (key));
 
  str = GNUNET_CRYPTO_public_key_to_string (key);
  if (! str)
    return 0;
 
  result = strcmp (key_string, str);
 
  GNUNET_free (str);
  return result;
}

References GNUNET_assert, GNUNET_CRYPTO_public_key_to_string(), GNUNET_free, key, and result.

Referenced by get_epoch_member_position().

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_sender_in_room()

static enum GNUNET_GenericReturnValue is_epoch_sender_in_room	(	const struct GNUNET_MESSENGER_Room *	room,
		const struct GNUNET_HashCode *	epoch,
		const struct GNUNET_MESSENGER_Contact *	contact
	)

static

Definition at line 1197 of file messenger_api_epoch.c.

{
  struct GNUNET_MESSENGER_RoomMessageEntry *entry;
 
  GNUNET_assert ((room) && (epoch) && (contact));
 
  entry = GNUNET_CONTAINER_multihashmap_get (room->messages, epoch);
 
  if (! entry)
    return GNUNET_SYSERR;
 
  if (contact == entry->sender)
    return GNUNET_YES;
 
  if (! entry->sender)
    return GNUNET_NO;
 
  return GNUNET_NO;
}

References GNUNET_MESSENGER_RoomMessageEntry::epoch, GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), GNUNET_NO, GNUNET_SYSERR, GNUNET_YES, GNUNET_MESSENGER_Room::messages, and GNUNET_MESSENGER_RoomMessageEntry::sender.

Referenced by is_epoch_member_in_room_graph().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_epoch_member_in_room_graph()

static enum GNUNET_GenericReturnValue is_epoch_member_in_room_graph	(	const struct GNUNET_MESSENGER_Room *	room,
		const struct GNUNET_HashCode *	epoch,
		const struct GNUNET_MESSENGER_Contact *	contact,
		struct GNUNET_CONTAINER_MultiHashMap *	map
	)

static

Definition at line 1221 of file messenger_api_epoch.c.

{
  const struct GNUNET_MESSENGER_Message *message;
  const struct GNUNET_HashCode *previous;
 
  GNUNET_assert ((room) && (epoch) && (contact) && (map));
 
  if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (map, epoch))
    return GNUNET_NO;
 
  message = get_room_message (room, epoch);
 
  if (! message)
    return GNUNET_NO;
 
  GNUNET_CONTAINER_multihashmap_put (map, epoch, NULL,
                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
 
  switch (message->header.kind)
  {
  case GNUNET_MESSENGER_KIND_JOIN:
    if (GNUNET_YES == is_epoch_sender_in_room (room, epoch, contact))
      return GNUNET_YES;
 
    previous = &(message->body.join.epoch);
    break;
  case GNUNET_MESSENGER_KIND_LEAVE:
    if (GNUNET_YES == is_epoch_sender_in_room (room, epoch, contact))
      return GNUNET_NO;
 
    previous = &(message->body.leave.epoch);
    break;
  case GNUNET_MESSENGER_KIND_MERGE:
    previous = &(message->body.merge.epochs[0]);
 
    if ((previous) &&
        (GNUNET_YES == is_epoch_member_in_room_graph (room, previous, contact,
                                                      map)))
      return GNUNET_YES;
 
    previous = &(message->body.merge.epochs[1]);
    break;
  default:
    previous = NULL;
    break;
  }
 
  if (! previous)
    return GNUNET_NO;
 
  return is_epoch_member_in_room_graph (room, previous, contact, map);
}

Referenced by is_epoch_member_in_room(), and is_epoch_member_in_room_graph().

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:

◆ set_epoch_proposing()

static void set_epoch_proposing	(	struct GNUNET_MESSENGER_Epoch *	epoch,
		struct GNUNET_TIME_Relative	timeout
	)

static

Definition at line 1384 of file messenger_api_epoch.c.

{
  GNUNET_assert (epoch);
 
  epoch->proposal_expiration = GNUNET_TIME_absolute_add (
    GNUNET_TIME_absolute_get (),
    timeout);
}

References GNUNET_assert, GNUNET_TIME_absolute_add(), GNUNET_TIME_absolute_get(), GNUNET_MESSENGER_Epoch::proposal_expiration, and timeout.

Referenced by propose_epoch_group(), set_epoch_proposal_group(), and update_epoch_group().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_epoch_proposing()

static enum GNUNET_GenericReturnValue is_epoch_proposing ( const struct GNUNET_MESSENGER_Epoch * epoch )

static

Definition at line 1396 of file messenger_api_epoch.c.

{
  struct GNUNET_TIME_Relative timeout;
 
  GNUNET_assert (epoch);
 
  timeout = GNUNET_TIME_absolute_get_remaining (
    epoch->proposal_expiration);
 
  if (GNUNET_YES == GNUNET_TIME_relative_is_zero (timeout))
    return GNUNET_NO;
  else
    return GNUNET_YES;
}

References GNUNET_assert, GNUNET_NO, GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_relative_is_zero(), GNUNET_YES, GNUNET_MESSENGER_Epoch::proposal_expiration, and timeout.

Referenced by propose_epoch_group().

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:

◆ on_epoch_proposal_timeout()

static void on_epoch_proposal_timeout ( void * cls )

static

Definition at line 1446 of file messenger_api_epoch.c.

{
  struct GNUNET_MESSENGER_Epoch *epoch;
 
  GNUNET_assert (cls);
 
  epoch = cls;
  epoch->proposal_timeout = NULL;
 
  cancel_epoch_proposal_group (epoch);
}

References cancel_epoch_proposal_group(), GNUNET_assert, and GNUNET_MESSENGER_Epoch::proposal_timeout.

Referenced by set_epoch_proposal_group().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_epoch_subgroup_of_any_group()

static enum GNUNET_GenericReturnValue is_epoch_subgroup_of_any_group	(	struct GNUNET_MESSENGER_Epoch *	epoch,
		const struct GNUNET_MESSENGER_EpochGroup *	subgroup
	)

static

Definition at line 1460 of file messenger_api_epoch.c.

{
  struct GNUNET_CONTAINER_MultiShortmapIterator *iter;
  enum GNUNET_GenericReturnValue result;
  const struct GNUNET_MESSENGER_EpochGroup *group;
 
  GNUNET_assert ((epoch) && (subgroup));
 
  iter = GNUNET_CONTAINER_multishortmap_iterator_create (epoch->groups);
 
  if (! iter)
    return GNUNET_NO;
 
  result = GNUNET_NO;
 
  while (GNUNET_YES == GNUNET_CONTAINER_multishortmap_iterator_next (iter, NULL,
                                                                     (const
                                                                      void**) &
                                                                     group))
  {
    if (group == subgroup)
      continue;
 
    if (get_epoch_group_level (subgroup) >= get_epoch_group_level (group))
      continue;
 
    if (GNUNET_YES == is_epoch_group_subgroup_of (subgroup, group))
    {
      result = GNUNET_YES;
      break;
    }
  }
 
  GNUNET_CONTAINER_multishortmap_iterator_destroy (iter);
  return result;
}

References GNUNET_MESSENGER_EpochGroup::epoch, get_epoch_group_level(), GNUNET_assert, GNUNET_CONTAINER_multishortmap_iterator_create(), GNUNET_CONTAINER_multishortmap_iterator_destroy(), GNUNET_CONTAINER_multishortmap_iterator_next(), GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_Epoch::groups, is_epoch_group_subgroup_of(), and result.

Referenced by propose_epoch_group().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_epoch_member_in_any_group()

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

Definition at line 1501 of file messenger_api_epoch.c.

{
  struct GNUNET_CONTAINER_MultiShortmapIterator *iter;
  enum GNUNET_GenericReturnValue result;
  struct GNUNET_ShortHashCode key;
  const struct GNUNET_MESSENGER_EpochGroup *group;
 
  GNUNET_assert ((epoch) && (contact));
 
  iter = GNUNET_CONTAINER_multishortmap_iterator_create (epoch->groups);
 
  if (! iter)
    return GNUNET_NO;
 
  result = GNUNET_NO;
 
  while (GNUNET_YES == GNUNET_CONTAINER_multishortmap_iterator_next (iter, &key,
                                                                     (const
                                                                      void**) &
                                                                     group))
  {
    if (GNUNET_YES == is_epoch_group_member (group, contact))
    {
      result = GNUNET_YES;
      break;
    }
  }
 
  GNUNET_CONTAINER_multishortmap_iterator_destroy (iter);
  return result;
}

References GNUNET_MESSENGER_EpochGroup::epoch, GNUNET_assert, GNUNET_CONTAINER_multishortmap_iterator_create(), GNUNET_CONTAINER_multishortmap_iterator_destroy(), GNUNET_CONTAINER_multishortmap_iterator_next(), GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_Epoch::groups, is_epoch_group_member(), key, and result.

Referenced by propose_epoch_group().

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:

◆ iterate_epoch_announcement_invalidation()

static enum GNUNET_GenericReturnValue iterate_epoch_announcement_invalidation	(	void *	cls,
		const struct GNUNET_ShortHashCode *	key,
		void *	value
	)

static

Definition at line 1766 of file messenger_api_epoch.c.

{
  const struct GNUNET_MESSENGER_Contact **contact;
  struct GNUNET_MESSENGER_EpochAnnouncement *announcement;
 
  GNUNET_assert ((cls) && (value));
 
  contact = cls;
  announcement = value;
 
  invalidate_epoch_announcement (announcement, *contact);
  return GNUNET_YES;
}

References GNUNET_assert, GNUNET_YES, invalidate_epoch_announcement(), and value.

Referenced by invalidate_epoch_keys_by_member().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ iterate_epoch_group_invalidation()

static enum GNUNET_GenericReturnValue iterate_epoch_group_invalidation	(	void *	cls,
		const struct GNUNET_ShortHashCode *	key,
		void *	value
	)

static

Definition at line 1784 of file messenger_api_epoch.c.

{
  const struct GNUNET_MESSENGER_Contact **contact;
  struct GNUNET_MESSENGER_EpochGroup *group;
 
  GNUNET_assert ((cls) && (value));
 
  contact = cls;
  group = value;
 
  invalidate_epoch_group (group, *contact);
  return GNUNET_YES;
}

References GNUNET_assert, GNUNET_YES, invalidate_epoch_group(), and value.

Referenced by invalidate_epoch_keys_by_member().

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:

Functions

Function Documentation

◆ get_members_of_epoch()

◆ add_following_epoch()

◆ setup_following_epochs_of_previous()

◆ create_epoch()

◆ is_epoch_member_in_room()

◆ get_members_of_new_epoch()

◆ it_move_epoch_groups_from_previous_epoch()

◆ create_new_epoch()

◆ iterate_destroy_group()

◆ iterate_destroy_announcement()

◆ destroy_epoch()

◆ get_epoch_size()

◆ it_handle_epoch_message_delayed()

◆ reset_epoch_size()

◆ delay_epoch_message_for_its_members()

◆ get_epoch_private_key()

◆ get_epoch_private_key_timeout()

◆ is_other_epoch_announcement_better()

◆ it_find_announcement_with_most_members()

◆ it_find_valid_announcement_with_most_members()

◆ get_epoch_announcement()

◆ is_other_epoch_group_better()

◆ it_find_group_with_most_members()

◆ it_find_valid_group_with_most_members()

◆ get_epoch_group()

◆ is_epoch_previous_of_other()

◆ get_epoch_previous_announcement()

◆ get_epoch_previous_group()

◆ compare_member_public_keys()

◆ get_epoch_member_position()

◆ is_epoch_sender_in_room()

◆ is_epoch_member_in_room_graph()

◆ is_epoch_member()

◆ get_epoch_position_factor()

◆ send_epoch_message()

◆ update_epoch_announcement()

◆ set_epoch_proposing()

◆ is_epoch_proposing()

◆ update_epoch_group()

◆ on_epoch_proposal_timeout()

◆ is_epoch_subgroup_of_any_group()

◆ is_epoch_member_in_any_group()

◆ propose_epoch_group()

◆ set_epoch_proposal_group()

◆ get_epoch_proposal_group()

◆ cancel_epoch_proposal_group()

◆ iterate_epoch_announcement_invalidation()

◆ iterate_epoch_group_invalidation()

◆ invalidate_epoch_keys_by_member()