gnunet-service-messenger_member_session.c File Reference

#include "gnunet-service-messenger_member_session.h"
#include "gnunet-service-messenger_room.h"
#include "gnunet-service-messenger_message_store.h"
#include "messenger_api_contact_store.h"

Include dependency graph for gnunet-service-messenger_member_session.c:

Go to the source code of this file.

Data Structures
struct	GNUNET_MESSENGER_SrvMemberSessionHistoryEntry

Functions
struct GNUNET_MESSENGER_SrvMemberSession *	create_member_session (struct GNUNET_MESSENGER_Member *member, const struct GNUNET_CRYPTO_BlindablePublicKey *pubkey)
	Creates and allocates a new member session of a member with a given public key.
static struct GNUNET_MESSENGER_MemberStore *	get_session_member_store (const struct GNUNET_MESSENGER_SrvMemberSession *session)
static struct GNUNET_MESSENGER_SrvRoom *	get_session_room (const struct GNUNET_MESSENGER_SrvMemberSession *session)
static void	check_member_session_completion (struct GNUNET_MESSENGER_SrvMemberSession *session)
static enum GNUNET_GenericReturnValue	iterate_copy_history (void *cls, const struct GNUNET_HashCode *key, void *value)
struct GNUNET_MESSENGER_SrvMemberSession *	switch_member_session (struct GNUNET_MESSENGER_SrvMemberSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
	Creates and allocates a new member session closing and replacing a given other session of the same member.
void	destroy_member_session (struct GNUNET_MESSENGER_SrvMemberSession *session)
	Destroys a member session and frees its memory fully.
enum GNUNET_GenericReturnValue	reset_member_session (struct GNUNET_MESSENGER_SrvMemberSession *session, const struct GNUNET_HashCode *hash)
	Resets a given member session which re-opens a member session for new usage.
void	close_member_session (struct GNUNET_MESSENGER_SrvMemberSession *session)
	Closes a given member session which opens the request for completion of the given member session.
enum GNUNET_GenericReturnValue	is_member_session_closed (const struct GNUNET_MESSENGER_SrvMemberSession *session)
	Returns if the given member session has been closed.
enum GNUNET_GenericReturnValue	is_member_session_completed (const struct GNUNET_MESSENGER_SrvMemberSession *session)
	Returns if the given member session has been completed.
struct GNUNET_TIME_Absolute	get_member_session_start (const struct GNUNET_MESSENGER_SrvMemberSession *session)
	Returns the timestamp of the member session's start.
const struct GNUNET_HashCode *	get_member_session_key (const struct GNUNET_MESSENGER_SrvMemberSession *session)
	Returns the key of the room a given member session belongs to.
const struct GNUNET_ShortHashCode *	get_member_session_id (const struct GNUNET_MESSENGER_SrvMemberSession *session)
	Returns the member id of a given member session.
const struct GNUNET_CRYPTO_BlindablePublicKey *	get_member_session_public_key (const struct GNUNET_MESSENGER_SrvMemberSession *session)
	Returns the public key of a given member session.
const struct GNUNET_HashCode *	get_member_session_context (const struct GNUNET_MESSENGER_SrvMemberSession *session)
	Returns the member context of a given member session.
struct GNUNET_MESSENGER_Contact *	get_member_session_contact (struct GNUNET_MESSENGER_SrvMemberSession *session)
	Returns the contact which is connected to a given member session.
enum GNUNET_GenericReturnValue	verify_member_session_as_sender (const struct GNUNET_MESSENGER_SrvMemberSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
	Verifies a given member session as sender of a selected message and its hash.
enum GNUNET_GenericReturnValue	check_member_session_history (const struct GNUNET_MESSENGER_SrvMemberSession *session, const struct GNUNET_HashCode *hash, enum GNUNET_GenericReturnValue ownership)
	Checks the history of a session for a specific message which is identified by its hash and if the ownership flag is set, if the message is owned by the sessions contact.
static void	update_member_chain_history (struct GNUNET_MESSENGER_SrvMemberSession *session, const struct GNUNET_HashCode *hash, enum GNUNET_GenericReturnValue ownership)
void	update_member_session_history (struct GNUNET_MESSENGER_SrvMemberSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
	Adds a given message to the history of a session using the messages hash.
static void	clear_member_chain_history (struct GNUNET_MESSENGER_SrvMemberSession *session, const struct GNUNET_HashCode *hash)
void	clear_member_session_history (struct GNUNET_MESSENGER_SrvMemberSession *session, const struct GNUNET_HashCode *hash)
	Removes a message from the history of a session using the messages hash.
static void	load_member_session_history (struct GNUNET_MESSENGER_SrvMemberSession *session, const char *path)
void	load_member_session (struct GNUNET_MESSENGER_Member *member, const char *directory)
	Loads data from a directory into a new allocated and created member session of a member if the required information can be read from the content of the given directory.
static struct GNUNET_MESSENGER_SrvMemberSession *	get_cycle_safe_next_session (struct GNUNET_MESSENGER_SrvMemberSession *session, struct GNUNET_MESSENGER_SrvMemberSession *next)
void	load_member_session_next (struct GNUNET_MESSENGER_SrvMemberSession *session, const char *directory)
	Loads the connection from one session to another through the next attribute.
static enum GNUNET_GenericReturnValue	iterate_save_member_session_history_hentries (void *cls, const struct GNUNET_HashCode *key, void *value)
static void	save_member_session_history (struct GNUNET_MESSENGER_SrvMemberSession *session, const char *path)
void	save_member_session (struct GNUNET_MESSENGER_SrvMemberSession *session, const char *directory)
	Saves data from a member session into a directory which can be load to restore the member session completely.

Function Documentation

create_member_session()

struct GNUNET_MESSENGER_SrvMemberSession * create_member_session	(	struct GNUNET_MESSENGER_Member *	member,
		const struct GNUNET_CRYPTO_BlindablePublicKey *	pubkey
	)

Creates and allocates a new member session of a member with a given public key.

If the creation fails, NULL gets returned.

Parameters

[in,out]	member	Member
[in]	pubkey	Public key

Returns

New member session

Definition at line 34 of file gnunet-service-messenger_member_session.c.

{
  struct GNUNET_MESSENGER_SrvMemberSession *session;
 
  if ((! member) || (! pubkey) || (! (member->store)))
    return NULL;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Create new member session!\n");
 
  session = GNUNET_new (struct GNUNET_MESSENGER_SrvMemberSession);
  session->member = member;
 
  GNUNET_memcpy (&(session->public_key), pubkey, sizeof(session->public_key));
 
  get_context_from_member (
    get_member_session_key (session),
    get_member_session_id (session),
    &(session->context));
 
  {
    struct GNUNET_MESSENGER_ContactStore *store;
 
    store = get_member_contact_store (member->store);
 
    session->contact = get_store_contact (
      store,
      get_member_session_context (session),
      get_member_session_public_key (session));
  }
 
  if (! (session->contact))
  {
    GNUNET_free (session);
    return NULL;
  }
 
  increase_contact_rc (session->contact);
 
  session->history = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
 
  init_list_messages (&(session->messages));
 
  session->prev = NULL;
  session->next = NULL;
 
  session->start = GNUNET_TIME_absolute_get ();
 
  session->closed = GNUNET_NO;
  session->completed = GNUNET_NO;
 
  return session;
}

References GNUNET_MESSENGER_SrvMemberSession::closed, GNUNET_MESSENGER_SrvMemberSession::completed, GNUNET_MESSENGER_SrvMemberSession::contact, GNUNET_MESSENGER_SrvMemberSession::context, get_context_from_member(), get_member_contact_store(), get_member_session_context(), get_member_session_id(), get_member_session_key(), get_member_session_public_key(), get_store_contact(), GNUNET_CONTAINER_multihashmap_create(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_memcpy, GNUNET_new, GNUNET_NO, GNUNET_TIME_absolute_get(), GNUNET_MESSENGER_SrvMemberSession::history, increase_contact_rc(), init_list_messages(), GNUNET_MESSENGER_SrvMemberSession::member, GNUNET_MESSENGER_SrvMemberSession::messages, GNUNET_MESSENGER_SrvMemberSession::next, GNUNET_MESSENGER_SrvMemberSession::prev, pubkey, GNUNET_MESSENGER_SrvMemberSession::public_key, GNUNET_MESSENGER_SrvMemberSession::start, and GNUNET_MESSENGER_Member::store.

Referenced by load_member_session(), and try_member_session().

Here is the call graph for this function:

Here is the caller graph for this function:

get_session_member_store()

static struct GNUNET_MESSENGER_MemberStore * get_session_member_store ( const struct GNUNET_MESSENGER_SrvMemberSession *  session )

static

Definition at line 90 of file gnunet-service-messenger_member_session.c.

{
  struct GNUNET_MESSENGER_Member *member;
 
  GNUNET_assert (session);
 
  member = session->member;
 
  GNUNET_assert (member);
 
  return member->store;
}

References GNUNET_assert, GNUNET_MESSENGER_SrvMemberSession::member, and GNUNET_MESSENGER_Member::store.

Referenced by check_member_session_completion(), destroy_member_session(), get_member_session_key(), get_session_room(), load_member_session_next(), reset_member_session(), and switch_member_session().

Here is the caller graph for this function:

get_session_room()

static struct GNUNET_MESSENGER_SrvRoom * get_session_room ( const struct GNUNET_MESSENGER_SrvMemberSession *  session )

static

Definition at line 106 of file gnunet-service-messenger_member_session.c.

{
  struct GNUNET_MESSENGER_MemberStore *store;
 
  GNUNET_assert (session);
 
  store = get_session_member_store (session);
 
  GNUNET_assert (store);
 
  return store->room;
}

References get_session_member_store(), GNUNET_assert, and GNUNET_MESSENGER_MemberStore::room.

Referenced by check_member_session_completion().

Here is the call graph for this function:

Here is the caller graph for this function:

check_member_session_completion()

static void check_member_session_completion ( struct GNUNET_MESSENGER_SrvMemberSession *  session )

static

Definition at line 121 of file gnunet-service-messenger_member_session.c.

{
  const struct GNUNET_HashCode *start;
  const struct GNUNET_HashCode *end;
  struct GNUNET_MESSENGER_MessageStore *msg_store;
  struct GNUNET_CONTAINER_MultiHashMap *completion;
  struct GNUNET_MESSENGER_ListMessages level;
  struct GNUNET_MESSENGER_ListMessages list;
 
  GNUNET_assert (session);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Check session history (%s) for completion.\n",
              GNUNET_sh2s (get_member_session_id (session)));
 
  if (! session->messages.tail)
  {
    session->completed = GNUNET_YES;
    goto completion;
  }
  else if (GNUNET_YES == session->completed)
    goto completion;
 
  start = &(session->messages.head->hash);
  end = &(session->messages.tail->hash);
 
  msg_store = get_srv_room_message_store (get_session_room (session));
  completion = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
 
  if (! completion)
    goto completion;
 
  init_list_messages (&level);
  add_to_list_messages (&level, end);
 
  init_list_messages (&list);
 
  while (level.head)
  {
    struct GNUNET_MESSENGER_ListMessage *element;
 
    for (element = level.head; element; element = element->next)
    {
      const struct GNUNET_MESSENGER_MessageLink *link;
 
      link = get_store_message_link (
        msg_store, &(element->hash),
        GNUNET_NO);
 
      if (! link)
        continue;
 
      if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_contains (completion, &(
                                                                  link->first)))
      {
        add_to_list_messages (&list, &(link->first));
        GNUNET_CONTAINER_multihashmap_put (completion, &(link->first), NULL,
                                           GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
      }
 
      if ((GNUNET_YES == link->multiple) &&
          (GNUNET_YES != GNUNET_CONTAINER_multihashmap_contains (completion, &(
                                                                   link->second)
                                                                 )))
      {
        add_to_list_messages (&list, &(link->second));
        GNUNET_CONTAINER_multihashmap_put (completion, &(link->second), NULL,
                                           GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
      }
    }
 
    clear_list_messages (&level);
 
    for (element = list.head; element; element = element->next)
    {
      if (GNUNET_YES != check_member_session_history (session, &(element->hash),
                                                      GNUNET_YES))
        continue;
 
      if (0 == GNUNET_CRYPTO_hash_cmp (&(element->hash), start))
      {
        session->completed = GNUNET_YES;
        break;
      }
    }
 
    if (GNUNET_YES != session->completed)
      copy_list_messages (&level, &list);
 
    clear_list_messages (&list);
  }
 
  GNUNET_CONTAINER_multihashmap_destroy (completion);
 
completion:
  if (GNUNET_YES == is_member_session_completed (session))
  {
    struct GNUNET_MESSENGER_MemberStore *member_store;
    struct GNUNET_MESSENGER_ContactStore *store;
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Completed session history (%s)\n",
                GNUNET_sh2s (get_member_session_id (session)));
 
    member_store = get_session_member_store (session);
    store = get_member_contact_store (member_store);
 
    if ((session->contact) && (GNUNET_YES == decrease_contact_rc (
                                 session->contact)))
      remove_store_contact (
        store,
        session->contact,
        get_member_session_context (session));
 
    session->contact = NULL;
  }
}

References add_to_list_messages(), check_member_session_history(), clear_list_messages(), GNUNET_MESSENGER_SrvMemberSession::completed, GNUNET_MESSENGER_SrvMemberSession::contact, copy_list_messages(), decrease_contact_rc(), end, GNUNET_MESSENGER_MessageLink::first, get_member_contact_store(), get_member_session_context(), get_member_session_id(), get_session_member_store(), get_session_room(), get_srv_room_message_store(), get_store_message_link(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_CRYPTO_hash_cmp(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_sh2s(), GNUNET_YES, GNUNET_MESSENGER_ListMessage::hash, GNUNET_MESSENGER_ListMessages::head, init_list_messages(), is_member_session_completed(), list, GNUNET_MESSENGER_SrvMemberSession::messages, GNUNET_MESSENGER_MessageLink::multiple, GNUNET_MESSENGER_ListMessage::next, remove_store_contact(), GNUNET_MESSENGER_MessageLink::second, start, and GNUNET_MESSENGER_ListMessages::tail.

Referenced by close_member_session(), switch_member_session(), and update_member_session_history().

Here is the call graph for this function:

Here is the caller graph for this function:

iterate_copy_history()

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

static

Definition at line 241 of file gnunet-service-messenger_member_session.c.

{
  struct GNUNET_MESSENGER_SrvMemberSession *next;
 
  GNUNET_assert ((cls) && (key));
 
  next = cls;
 
  GNUNET_CONTAINER_multihashmap_put (next->history, key, (value? next : NULL),
                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
 
  return GNUNET_YES;
}

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_YES, GNUNET_MESSENGER_SrvMemberSession::history, key, GNUNET_MESSENGER_SrvMemberSession::next, and value.

Referenced by switch_member_session().

Here is the call graph for this function:

Here is the caller graph for this function:

switch_member_session()

struct GNUNET_MESSENGER_SrvMemberSession * switch_member_session	(	struct GNUNET_MESSENGER_SrvMemberSession *	session,
		const struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_HashCode *	hash
	)

Creates and allocates a new member session closing and replacing a given other session of the same member.

The new session could have significant changes to the members public key or its member id depending on the used message to switch session. The new session will be linked to the old one.

Parameters

[in,out]	session	Old member session
[in]	message	Message
[in]	hash	Hash of message

Returns

New member session

Definition at line 259 of file gnunet-service-messenger_member_session.c.

{
  struct GNUNET_MESSENGER_MemberStore *store;
  struct GNUNET_MESSENGER_SrvMemberSession *next;
 
  if ((! session) || (! message) || (! hash))
    return NULL;
 
  GNUNET_assert ((GNUNET_MESSENGER_KIND_ID == message->header.kind) ||
                 (GNUNET_MESSENGER_KIND_KEY == message->header.kind));
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Switch member session!\n");
 
  store = get_session_member_store (session);
  next = GNUNET_new (struct GNUNET_MESSENGER_SrvMemberSession);
 
  if (GNUNET_MESSENGER_KIND_ID == message->header.kind)
  {
    next->member = add_store_member (store,
                                     &(message->body.id.id));
    if (! next->member)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Failed to switch member session to ID: %s\n",
                  GNUNET_sh2s (&(message->body.id.id)));
 
      GNUNET_free (next);
      return NULL;
    }
  }
  else
  {
    if (! session->member)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Failed to switch member session\n");
 
      GNUNET_free (next);
      return NULL;
    }
 
    next->member = session->member;
  }
 
  if (GNUNET_MESSENGER_KIND_KEY == message->header.kind)
    GNUNET_memcpy (&(next->public_key), &(message->body.key.key),
                   sizeof(next->public_key));
  else
    GNUNET_memcpy (&(next->public_key), get_member_session_public_key (session),
                   sizeof(next->public_key));
 
  get_context_from_member (
    get_member_session_key (next),
    get_member_session_id (next),
    &(next->context));
 
  update_store_contact (
    get_member_contact_store (store),
    get_member_session_contact (session),
    get_member_session_context (session),
    get_member_session_context (next),
    get_member_session_public_key (next));
 
  next->contact = get_member_session_contact (session);
 
  if (! (next->contact))
  {
    GNUNET_free (next);
    return NULL;
  }
 
  increase_contact_rc (next->contact);
 
  next->history = GNUNET_CONTAINER_multihashmap_create (
    GNUNET_CONTAINER_multihashmap_size (session->history),
    GNUNET_NO);
 
  GNUNET_CONTAINER_multihashmap_iterate (session->history, iterate_copy_history,
                                         next);
 
  init_list_messages (&(next->messages));
  copy_list_messages (&(next->messages), &(session->messages));
 
  session->next = next;
  next->prev = session;
  next->next = NULL;
 
  next->start = GNUNET_TIME_absolute_get ();
 
  session->closed = GNUNET_YES;
  next->closed = GNUNET_NO;
  next->completed = GNUNET_NO;
 
  check_member_session_completion (session);
 
  return next;
}

References add_store_member(), GNUNET_MESSENGER_Message::body, check_member_session_completion(), GNUNET_MESSENGER_SrvMemberSession::closed, GNUNET_MESSENGER_SrvMemberSession::completed, GNUNET_MESSENGER_SrvMemberSession::contact, GNUNET_MESSENGER_SrvMemberSession::context, copy_list_messages(), get_context_from_member(), get_member_contact_store(), get_member_session_contact(), get_member_session_context(), get_member_session_id(), get_member_session_key(), get_member_session_public_key(), get_session_member_store(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_memcpy, GNUNET_MESSENGER_KIND_ID, GNUNET_MESSENGER_KIND_KEY, GNUNET_new, GNUNET_NO, GNUNET_sh2s(), GNUNET_TIME_absolute_get(), GNUNET_YES, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_SrvMemberSession::history, GNUNET_MESSENGER_MessageId::id, GNUNET_MESSENGER_MessageBody::id, increase_contact_rc(), init_list_messages(), iterate_copy_history(), GNUNET_MESSENGER_MessageKey::key, GNUNET_MESSENGER_MessageBody::key, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_SrvMemberSession::member, GNUNET_MESSENGER_SrvMemberSession::messages, GNUNET_MESSENGER_SrvMemberSession::next, GNUNET_MESSENGER_SrvMemberSession::prev, GNUNET_MESSENGER_SrvMemberSession::public_key, GNUNET_MESSENGER_SrvMemberSession::start, and update_store_contact().

Referenced by handle_member_session_switch().

Here is the call graph for this function:

Here is the caller graph for this function:

destroy_member_session()

void destroy_member_session

(

struct GNUNET_MESSENGER_SrvMemberSession *

session

)

Destroys a member session and frees its memory fully.

Parameters

[in,out]

session

Member session

Definition at line 361 of file gnunet-service-messenger_member_session.c.

{
  struct GNUNET_MESSENGER_MemberStore *store;
  struct GNUNET_MESSENGER_Contact *contact;
 
  GNUNET_assert (session);
 
  GNUNET_CONTAINER_multihashmap_destroy (session->history);
 
  clear_list_messages (&(session->messages));
 
  store = get_session_member_store (session);
  contact = get_member_session_contact (session);
 
  if ((contact) && (GNUNET_YES == decrease_contact_rc (contact)))
    remove_store_contact (
      get_member_contact_store (store),
      contact,
      get_member_session_context (session));
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Free member session!\n");
  GNUNET_free (session);
}

References clear_list_messages(), decrease_contact_rc(), get_member_contact_store(), get_member_session_contact(), get_member_session_context(), get_session_member_store(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_YES, GNUNET_MESSENGER_SrvMemberSession::history, GNUNET_MESSENGER_SrvMemberSession::messages, and remove_store_contact().

Referenced by iterate_destroy_session(), and remove_room_member_session().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_member_session()

enum GNUNET_GenericReturnValue reset_member_session	(	struct GNUNET_MESSENGER_SrvMemberSession *	session,
		const struct GNUNET_HashCode *	hash
	)

Resets a given member session which re-opens a member session for new usage.

Every connection to other sessions will be be dropped. The member sessions messages will be cleared but old history from uncompleted sessions however can be reused!

Parameters

[in,out]	session	Member session
[in]	hash	Hash of initial message (JOIN message!)

Returns

GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 387 of file gnunet-service-messenger_member_session.c.

{
  struct GNUNET_MESSENGER_Contact *contact;
 
  GNUNET_assert ((session) && (hash));
 
  {
    struct GNUNET_MESSENGER_MemberStore *member_store;
    struct GNUNET_MESSENGER_ContactStore *store;
 
    member_store = get_session_member_store (session);
    store = get_member_contact_store (member_store);
    contact = get_store_contact (
      store,
      get_member_session_context (session),
      get_member_session_public_key (session));
  }
 
  if (! contact)
    return GNUNET_SYSERR;
 
  if (contact == session->contact)
    goto clear_messages;
 
  session->contact = contact;
  increase_contact_rc (session->contact);
 
clear_messages:
  clear_list_messages (&(session->messages));
  add_to_list_messages (&(session->messages), hash);
 
  session->next = NULL;
  session->closed = GNUNET_NO;
  session->completed = GNUNET_NO;
 
  return GNUNET_OK;
}

References add_to_list_messages(), clear_list_messages(), GNUNET_MESSENGER_SrvMemberSession::closed, GNUNET_MESSENGER_SrvMemberSession::completed, GNUNET_MESSENGER_SrvMemberSession::contact, get_member_contact_store(), get_member_session_context(), get_member_session_public_key(), get_session_member_store(), get_store_contact(), GNUNET_assert, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, increase_contact_rc(), GNUNET_MESSENGER_SrvMemberSession::messages, and GNUNET_MESSENGER_SrvMemberSession::next.

Referenced by handle_message_join().

Here is the call graph for this function:

Here is the caller graph for this function:

close_member_session()

void close_member_session

(

struct GNUNET_MESSENGER_SrvMemberSession *

session

)

Closes a given member session which opens the request for completion of the given member session.

Closing a session may complete a session and can't be used without a reset! (

See also

reset_member_session() )

Parameters

[in,out]

session

Member session

Definition at line 428 of file gnunet-service-messenger_member_session.c.

{
  GNUNET_assert (session);
 
  session->closed = GNUNET_YES;
  check_member_session_completion (session);
}

References check_member_session_completion(), GNUNET_MESSENGER_SrvMemberSession::closed, GNUNET_assert, and GNUNET_YES.

Referenced by handle_message_leave().

Here is the call graph for this function:

Here is the caller graph for this function:

is_member_session_closed()

enum GNUNET_GenericReturnValue is_member_session_closed

(

const struct GNUNET_MESSENGER_SrvMemberSession *

session

)

Returns if the given member session has been closed.

Parameters

[in]

session

Member session

Returns

GNUNET_YES or GNUNET_NO

Definition at line 438 of file gnunet-service-messenger_member_session.c.

{
  GNUNET_assert (session);
 
  return session->closed;
}

References GNUNET_MESSENGER_SrvMemberSession::closed, and GNUNET_assert.

is_member_session_completed()

enum GNUNET_GenericReturnValue is_member_session_completed

(

const struct GNUNET_MESSENGER_SrvMemberSession *

session

)

Returns if the given member session has been completed.

A completed member session can't verify any message as its own and it won't add any message to its history.

Parameters

[in]

session

Member session

Returns

GNUNET_YES or GNUNET_NO

Definition at line 448 of file gnunet-service-messenger_member_session.c.

{
  GNUNET_assert (session);
 
  return session->completed;
}

References GNUNET_MESSENGER_SrvMemberSession::completed, and GNUNET_assert.

Referenced by check_member_session_completion(), iterate_epoch_session_members(), iterate_forward_members(), iterate_notify_about_members(), iterate_update_member_sessions(), update_member_session_history(), and verify_member_session_as_sender().

Here is the caller graph for this function:

get_member_session_start()

struct GNUNET_TIME_Absolute get_member_session_start

(

const struct GNUNET_MESSENGER_SrvMemberSession *

session

)

Returns the timestamp of the member session's start.

Parameters

[in]

session

Member session

Returns

Absolute timestamp

Definition at line 458 of file gnunet-service-messenger_member_session.c.

{
  GNUNET_assert (session);
 
  if (session->prev)
    return get_member_session_start (session->prev);
 
  return session->start;
}

References get_member_session_start(), and GNUNET_assert.

Referenced by get_member_session_start(), and solve_srv_room_member_collisions().

Here is the call graph for this function:

Here is the caller graph for this function:

get_member_session_key()

const struct GNUNET_HashCode * get_member_session_key

(

const struct GNUNET_MESSENGER_SrvMemberSession *

session

)

Returns the key of the room a given member session belongs to.

Parameters

[in]

session

Member session

Returns

Key of room

Definition at line 471 of file gnunet-service-messenger_member_session.c.

{
  const struct GNUNET_MESSENGER_MemberStore *store;
 
  GNUNET_assert ((session) && (session->member));
 
  store = get_session_member_store (session);
 
  return get_member_store_key (store);
}

References get_member_store_key(), get_session_member_store(), GNUNET_assert, and GNUNET_MESSENGER_SrvMemberSession::member.

Referenced by create_member_session(), and switch_member_session().

Here is the call graph for this function:

Here is the caller graph for this function:

get_member_session_id()

const struct GNUNET_ShortHashCode * get_member_session_id

(

const struct GNUNET_MESSENGER_SrvMemberSession *

session

)

Returns the member id of a given member session.

Parameters

[in]

session

Member session

Returns

Member id

Definition at line 484 of file gnunet-service-messenger_member_session.c.

{
  GNUNET_assert (session);
 
  return get_member_id (session->member);
}

References get_member_id(), GNUNET_assert, and GNUNET_MESSENGER_SrvMemberSession::member.

Referenced by check_member_session_completion(), create_member_session(), delete_srv_room_message(), find_member_session_in_room(), iterate_epoch_session_members(), iterate_notify_about_members(), notify_about_members(), remove_room_member_session(), request_room_message_step(), save_member_session(), send_message_join(), switch_member_session(), traverse_epoch_session_message(), update_member_session_history(), and verify_member_session_as_sender().

Here is the call graph for this function:

Here is the caller graph for this function:

get_member_session_public_key()

const struct GNUNET_CRYPTO_BlindablePublicKey * get_member_session_public_key

(

const struct GNUNET_MESSENGER_SrvMemberSession *

session

)

Returns the public key of a given member session.

Parameters

[in]

session

Member session

Returns

Public key

Definition at line 493 of file gnunet-service-messenger_member_session.c.

{
  GNUNET_assert (session);
 
  return &(session->public_key);
}

References GNUNET_assert, and GNUNET_MESSENGER_SrvMemberSession::public_key.

Referenced by add_member_session(), create_member_session(), handle_message_id(), iterate_member_sessions_it(), notify_srv_handle_message(), remove_member_session(), remove_room_member_session(), reset_member_session(), save_member_session(), switch_member_session(), and verify_member_session_as_sender().

Here is the caller graph for this function:

get_member_session_context()

const struct GNUNET_HashCode * get_member_session_context

(

const struct GNUNET_MESSENGER_SrvMemberSession *

session

)

Returns the member context of a given member session.

Parameters

[in]

session

Member session

Returns

Member context as hash

Definition at line 503 of file gnunet-service-messenger_member_session.c.

{
  GNUNET_assert (session);
 
  return &(session->context);
}

References GNUNET_MESSENGER_SrvMemberSession::context, and GNUNET_assert.

Referenced by check_member_session_completion(), create_member_session(), destroy_member_session(), get_next_member_session_context(), reset_member_session(), and switch_member_session().

Here is the caller graph for this function:

get_member_session_contact()

struct GNUNET_MESSENGER_Contact * get_member_session_contact

(

struct GNUNET_MESSENGER_SrvMemberSession *

session

)

Returns the contact which is connected to a given member session.

Parameters

[in]

session

Member session

Returns

Contact

Definition at line 513 of file gnunet-service-messenger_member_session.c.

{
  GNUNET_assert (session);
 
  return session->contact;
}

References GNUNET_MESSENGER_SrvMemberSession::contact, and GNUNET_assert.

Referenced by destroy_member_session(), and switch_member_session().

Here is the caller graph for this function:

verify_member_session_as_sender()

enum GNUNET_GenericReturnValue verify_member_session_as_sender	(	const struct GNUNET_MESSENGER_SrvMemberSession *	session,
		const struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_HashCode *	hash
	)

Verifies a given member session as sender of a selected message and its hash.

The function returns GNUNET_OK if the message session is verified as sender, otherwise GNUNET_SYSERR.

See also

is_member_session_completed() for verification.

Parameters

[in]	session	Member session
[in]	message	Message
[in]	hash	Hash of message

Returns

GNUNET_OK on success, otherwise GNUNET_SYSERR

Definition at line 522 of file gnunet-service-messenger_member_session.c.

{
  GNUNET_assert ((session) && (message) && (hash));
 
  if (GNUNET_YES == is_member_session_completed (session))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Check message (%s) using history!\n",
                GNUNET_h2s (hash));
 
    if (GNUNET_YES == check_member_session_history (session, hash, GNUNET_YES))
      return GNUNET_OK;
    else
      return GNUNET_SYSERR;
  }
 
  if (0 != GNUNET_memcmp (get_member_session_id (session),
                          &(message->header.sender_id)))
    return GNUNET_SYSERR;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Check message (%s) using key: %s\n",
              GNUNET_h2s (hash),
              GNUNET_CRYPTO_blindable_public_key_to_string (
                get_member_session_public_key (session)));
 
  return verify_message (message, hash, get_member_session_public_key (
                           session));
}

References check_member_session_history(), get_member_session_id(), get_member_session_public_key(), GNUNET_assert, GNUNET_CRYPTO_blindable_public_key_to_string(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_memcmp, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, GNUNET_MESSENGER_Message::header, is_member_session_completed(), GNUNET_MESSENGER_MessageHeader::sender_id, and verify_message().

Referenced by iterate_search_session(), and update_member_session_history().

Here is the call graph for this function:

Here is the caller graph for this function:

check_member_session_history()

enum GNUNET_GenericReturnValue check_member_session_history	(	const struct GNUNET_MESSENGER_SrvMemberSession *	session,
		const struct GNUNET_HashCode *	hash,
		enum GNUNET_GenericReturnValue	ownership
	)

Checks the history of a session for a specific message which is identified by its hash and if the ownership flag is set, if the message is owned by the sessions contact.

Parameters

[in]	session	Member session
[in]	hash	Hash of message
[in]	ownership	Ownership flag

Returns

GNUNET_YES if found, otherwise GNUNET_NO

Definition at line 555 of file gnunet-service-messenger_member_session.c.

{
  GNUNET_assert ((session) && (hash));
 
  if (GNUNET_YES == ownership)
    return (NULL != GNUNET_CONTAINER_multihashmap_get (session->history, hash)?
            GNUNET_YES : GNUNET_NO);
  else
    return GNUNET_CONTAINER_multihashmap_contains (session->history, hash);
}

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_NO, GNUNET_YES, and GNUNET_MESSENGER_SrvMemberSession::history.

Referenced by check_member_session_completion(), delete_srv_room_message(), notify_about_members(), recv_message_request(), request_room_message_step(), and verify_member_session_as_sender().

Here is the call graph for this function:

Here is the caller graph for this function:

update_member_chain_history()

static void update_member_chain_history ( struct GNUNET_MESSENGER_SrvMemberSession *  session, const struct GNUNET_HashCode *  hash, enum GNUNET_GenericReturnValue  ownership  )

static

Definition at line 571 of file gnunet-service-messenger_member_session.c.

{
  GNUNET_assert ((session) && (hash));
 
  if ((GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (session->history, hash,
                                                       (GNUNET_YES == ownership?
                                                        session : NULL),
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
      && (session->next))
    update_member_chain_history (session->next, hash, ownership);
}

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_OK, GNUNET_YES, GNUNET_MESSENGER_SrvMemberSession::history, GNUNET_MESSENGER_SrvMemberSession::next, and update_member_chain_history().

Referenced by update_member_chain_history(), and update_member_session_history().

Here is the call graph for this function:

Here is the caller graph for this function:

update_member_session_history()

void update_member_session_history	(	struct GNUNET_MESSENGER_SrvMemberSession *	session,
		const struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_HashCode *	hash
	)

Adds a given message to the history of a session using the messages hash.

The ownership will be set automatically.

See also

is_member_session_completed() for updating a history.

Parameters

[in,out]	session	Member session
[in]	message	Message
[in]	hash	Hash of message

Definition at line 587 of file gnunet-service-messenger_member_session.c.

{
  GNUNET_assert ((session) && (message) && (hash));
 
  if (GNUNET_YES == is_member_session_completed (session))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Updating session history (%s) failed: Session already completed!\n",
                GNUNET_sh2s (get_member_session_id (session)));
    return;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Updating sessions history (%s) += (%s)\n",
              GNUNET_sh2s (get_member_session_id (session)), GNUNET_h2s (hash));
 
  if (GNUNET_OK == verify_member_session_as_sender (session, message, hash))
  {
    if (GNUNET_YES == is_message_session_bound (message))
      add_to_list_messages (&(session->messages), hash);
 
    update_member_chain_history (session, hash, GNUNET_YES);
  }
  else
    update_member_chain_history (session, hash, GNUNET_NO);
 
  if (GNUNET_YES == session->closed)
    check_member_session_completion (session);
}

References add_to_list_messages(), check_member_session_completion(), GNUNET_MESSENGER_SrvMemberSession::closed, get_member_session_id(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_h2s(), GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_sh2s(), GNUNET_YES, is_member_session_completed(), is_message_session_bound(), GNUNET_MESSENGER_SrvMemberSession::messages, update_member_chain_history(), and verify_member_session_as_sender().

Referenced by iterate_update_member_sessions().

Here is the call graph for this function:

Here is the caller graph for this function:

clear_member_chain_history()

static void clear_member_chain_history ( struct GNUNET_MESSENGER_SrvMemberSession *  session, const struct GNUNET_HashCode *  hash  )

static

Definition at line 622 of file gnunet-service-messenger_member_session.c.

{
  GNUNET_assert ((session) && (hash));
 
  if ((0 < GNUNET_CONTAINER_multihashmap_remove_all (session->history, hash)) &&
      (session->next))
    clear_member_session_history (session->next, hash);
}

References clear_member_session_history(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_remove_all(), GNUNET_MESSENGER_SrvMemberSession::history, and GNUNET_MESSENGER_SrvMemberSession::next.

Referenced by clear_member_session_history().

Here is the call graph for this function:

Here is the caller graph for this function:

clear_member_session_history()

void clear_member_session_history	(	struct GNUNET_MESSENGER_SrvMemberSession *	session,
		const struct GNUNET_HashCode *	hash
	)

Removes a message from the history of a session using the messages hash.

Parameters

[in,out]	session	Member session
[in]	hash	Hash of message

Definition at line 634 of file gnunet-service-messenger_member_session.c.

{
  GNUNET_assert ((session) && (hash));
 
  clear_member_chain_history (session, hash);
}

References clear_member_chain_history(), and GNUNET_assert.

Referenced by clear_member_chain_history().

Here is the call graph for this function:

Here is the caller graph for this function:

load_member_session_history()

static void load_member_session_history ( struct GNUNET_MESSENGER_SrvMemberSession *  session, const char *  path  )

static

Definition at line 650 of file gnunet-service-messenger_member_session.c.

{
  struct GNUNET_DISK_FileHandle *handle;
  enum GNUNET_GenericReturnValue status;
 
  GNUNET_assert ((session) && (path));
 
  if (GNUNET_YES != GNUNET_DISK_file_test (path))
    return;
 
  {
    enum GNUNET_DISK_AccessPermissions permission;
 
    permission = (GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
    handle = GNUNET_DISK_file_open (path, GNUNET_DISK_OPEN_READ, permission);
  }
 
  if (! handle)
    return;
 
  GNUNET_DISK_file_seek (handle, 0, GNUNET_DISK_SEEK_SET);
 
  do {
    struct GNUNET_MESSENGER_SrvMemberSessionHistoryEntry entry;
    ssize_t len;
 
    len = GNUNET_DISK_file_read (handle, &(entry.hash), sizeof(entry.hash));
 
    if (len != sizeof(entry.hash))
      break;
 
    len = GNUNET_DISK_file_read (handle, &(entry.ownership),
                                 sizeof(entry.ownership));
 
    if (len != sizeof(entry.ownership))
      break;
 
    status = GNUNET_CONTAINER_multihashmap_put (session->history, &(entry.hash),
                                                (entry.ownership? session :
                                                 NULL),
                                                GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
  } while (status == GNUNET_OK);
 
  GNUNET_DISK_file_close (handle);
}

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_DISK_file_close(), GNUNET_DISK_file_open(), GNUNET_DISK_file_read(), GNUNET_DISK_file_seek(), GNUNET_DISK_file_test(), GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_DISK_SEEK_SET, GNUNET_OK, GNUNET_YES, handle, GNUNET_MESSENGER_SrvMemberSessionHistoryEntry::hash, GNUNET_MESSENGER_SrvMemberSession::history, GNUNET_MESSENGER_SrvMemberSessionHistoryEntry::ownership, and status.

Referenced by load_member_session().

Here is the call graph for this function:

Here is the caller graph for this function:

load_member_session()

void load_member_session	(	struct GNUNET_MESSENGER_Member *	member,
		const char *	directory
	)

Loads data from a directory into a new allocated and created member session of a member if the required information can be read from the content of the given directory.

Parameters

[out]	member	Member
[in]	directory	Path to a directory

Definition at line 699 of file gnunet-service-messenger_member_session.c.

{
  char *config_file;
  struct GNUNET_MESSENGER_SrvMemberSession *session;
  struct GNUNET_CONFIGURATION_Handle *cfg;
 
  GNUNET_assert ((member) && (directory));
 
  GNUNET_asprintf (&config_file, "%s%s", directory, "session.cfg");
 
  session = NULL;
 
  if (GNUNET_YES != GNUNET_DISK_file_test (config_file))
    goto free_config;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Load session configuration of member: %s\n", config_file);
 
  cfg = GNUNET_CONFIGURATION_create (GNUNET_OS_project_data_gnunet ());
 
  if (! cfg)
    goto free_config;
 
  if (GNUNET_OK == GNUNET_CONFIGURATION_parse (cfg, config_file))
  {
    struct GNUNET_CRYPTO_BlindablePublicKey key;
    enum GNUNET_GenericReturnValue key_result;
    unsigned long long numeric_value;
    char *key_data;
 
    if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, "session",
                                                            "key", &key_data))
      goto destroy_config;
 
    key_result = GNUNET_CRYPTO_blindable_public_key_from_string (key_data,
                                                                 &key);
    GNUNET_free (key_data);
 
    if (GNUNET_OK != key_result)
      goto destroy_config;
 
    session = create_member_session (member, &key);
 
    if (! session)
      goto destroy_config;
 
    if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (cfg, "session",
                                                            "start",
                                                            &numeric_value))
      session->start.abs_value_us = numeric_value;
 
    if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (cfg, "session",
                                                            "closed",
                                                            &numeric_value))
      session->closed = (GNUNET_YES == numeric_value? GNUNET_YES : GNUNET_NO);
 
    if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (cfg, "session",
                                                            "completed",
                                                            &numeric_value))
      session->completed = (GNUNET_YES == numeric_value? GNUNET_YES :
                            GNUNET_NO);
  }
 
destroy_config:
  GNUNET_CONFIGURATION_destroy (cfg);
 
free_config:
  GNUNET_free (config_file);
 
  if (! session)
    return;
 
  {
    char *history_file;
    GNUNET_asprintf (&history_file, "%s%s", directory, "history.map");
 
    load_member_session_history (session, history_file);
    GNUNET_free (history_file);
  }
 
  {
    char *messages_file;
    GNUNET_asprintf (&messages_file, "%s%s", directory, "messages.list");
 
    load_list_messages (&(session->messages), messages_file);
    GNUNET_free (messages_file);
  }
 
  add_member_session (member, session);
}

References GNUNET_TIME_Absolute::abs_value_us, add_member_session(), cfg, GNUNET_MESSENGER_SrvMemberSession::closed, GNUNET_MESSENGER_SrvMemberSession::completed, config_file, create_member_session(), GNUNET_asprintf(), GNUNET_assert, GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_destroy(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_parse(), GNUNET_CRYPTO_blindable_public_key_from_string(), GNUNET_DISK_file_test(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_OS_project_data_gnunet(), GNUNET_YES, key, load_list_messages(), load_member_session_history(), GNUNET_MESSENGER_SrvMemberSession::messages, and GNUNET_MESSENGER_SrvMemberSession::start.

Referenced by callback_scan_for_sessions().

Here is the call graph for this function:

Here is the caller graph for this function:

get_cycle_safe_next_session()

static struct GNUNET_MESSENGER_SrvMemberSession * get_cycle_safe_next_session ( struct GNUNET_MESSENGER_SrvMemberSession *  session, struct GNUNET_MESSENGER_SrvMemberSession *  next  )

static

Definition at line 793 of file gnunet-service-messenger_member_session.c.

{
  struct GNUNET_MESSENGER_SrvMemberSession *check;
 
  if (! next)
    return NULL;
 
  for (check = next; check; check = check->next)
    if (check == session)
      return NULL;
 
  return next;
}

References GNUNET_MESSENGER_SrvMemberSession::next.

Referenced by load_member_session_next().

Here is the caller graph for this function:

load_member_session_next()

void load_member_session_next	(	struct GNUNET_MESSENGER_SrvMemberSession *	session,
		const char *	directory
	)

Loads the connection from one session to another through the next attribute.

Necessary information will be loaded from a configuration file inside of a given directory.

Parameters

[in,out]	session	Member session
[in]	directory	Path to a directory

Definition at line 810 of file gnunet-service-messenger_member_session.c.

{
  struct GNUNET_CONFIGURATION_Handle *cfg;
  char *config_file;
 
 
  GNUNET_assert ((session) && (directory));
 
  GNUNET_asprintf (&config_file, "%s%s", directory, "session.cfg");
 
  if (GNUNET_YES != GNUNET_DISK_file_test (config_file))
    goto free_config;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Load next session configuration of member: %s\n", config_file);
 
  cfg = GNUNET_CONFIGURATION_create (GNUNET_OS_project_data_gnunet ());
 
  if (! cfg)
    goto free_config;
 
  if (GNUNET_OK == GNUNET_CONFIGURATION_parse (cfg, config_file))
  {
    struct GNUNET_CRYPTO_BlindablePublicKey next_key;
    enum GNUNET_GenericReturnValue key_result;
    struct GNUNET_ShortHashCode next_id;
    char *key_data;
 
    if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, "session",
                                                            "next_key",
                                                            &key_data))
      goto destroy_config;
 
    key_result = GNUNET_CRYPTO_blindable_public_key_from_string (key_data, &
                                                                 next_key);
    GNUNET_free (key_data);
 
    if (GNUNET_OK != key_result)
      goto destroy_config;
 
    if (GNUNET_OK != GNUNET_CONFIGURATION_get_data (cfg, "session", "next_id",
                                                    &next_id, sizeof(next_id)))
      goto destroy_config;
 
    {
      struct GNUNET_MESSENGER_MemberStore *store;
      struct GNUNET_MESSENGER_Member *member;
 
      store = get_session_member_store (session);
      member = get_store_member (store, &next_id);
 
      session->next = get_cycle_safe_next_session (
        session,
        member? get_member_session (member, &next_key) : NULL);
    }
 
    if (session->next)
      session->next->prev = session;
  }
 
destroy_config:
  GNUNET_CONFIGURATION_destroy (cfg);
 
free_config:
  GNUNET_free (config_file);
}

References cfg, config_file, get_cycle_safe_next_session(), get_member_session(), get_session_member_store(), get_store_member(), GNUNET_asprintf(), GNUNET_assert, GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_destroy(), GNUNET_CONFIGURATION_get_data(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_parse(), GNUNET_CRYPTO_blindable_public_key_from_string(), GNUNET_DISK_file_test(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_OK, GNUNET_OS_project_data_gnunet(), GNUNET_YES, GNUNET_MESSENGER_SrvMemberSession::next, next_id, GNUNET_MESSENGER_SrvMemberSession::prev, and GNUNET_MESSENGER_Member::store.

Referenced by iterate_load_next_session().

Here is the call graph for this function:

Here is the caller graph for this function:

iterate_save_member_session_history_hentries()

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

static

Definition at line 880 of file gnunet-service-messenger_member_session.c.

{
  struct GNUNET_DISK_FileHandle *handle;
  unsigned char ownership;
 
  GNUNET_assert ((cls) && (key));
 
  handle = cls;
  ownership = value? GNUNET_YES : GNUNET_NO;
 
  GNUNET_DISK_file_write (handle, key, sizeof(*key));
  GNUNET_DISK_file_write (handle, &ownership, sizeof(ownership));
 
  return GNUNET_YES;
}

References GNUNET_assert, GNUNET_DISK_file_write(), GNUNET_NO, GNUNET_YES, handle, key, and value.

Referenced by save_member_session_history().

Here is the call graph for this function:

Here is the caller graph for this function:

save_member_session_history()

static void save_member_session_history ( struct GNUNET_MESSENGER_SrvMemberSession *  session, const char *  path  )

static

Definition at line 900 of file gnunet-service-messenger_member_session.c.

{
  struct GNUNET_DISK_FileHandle *handle;
 
  GNUNET_assert ((session) && (path));
 
  {
    enum GNUNET_DISK_AccessPermissions permission;
 
    permission = (GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
 
    handle = GNUNET_DISK_file_open (
      path,
      GNUNET_DISK_OPEN_CREATE | GNUNET_DISK_OPEN_WRITE,
      permission);
  }
 
  if (! handle)
    return;
 
  GNUNET_DISK_file_seek (handle, 0, GNUNET_DISK_SEEK_SET);
 
  GNUNET_CONTAINER_multihashmap_iterate (
    session->history,
    iterate_save_member_session_history_hentries,
    handle);
 
  GNUNET_DISK_file_sync (handle);
  GNUNET_DISK_file_close (handle);
}

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_DISK_file_close(), GNUNET_DISK_file_open(), GNUNET_DISK_file_seek(), GNUNET_DISK_file_sync(), GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_OPEN_WRITE, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_DISK_SEEK_SET, handle, GNUNET_MESSENGER_SrvMemberSession::history, and iterate_save_member_session_history_hentries().

Referenced by save_member_session().

Here is the call graph for this function:

Here is the caller graph for this function:

save_member_session()

void save_member_session	(	struct GNUNET_MESSENGER_SrvMemberSession *	session,
		const char *	directory
	)

Saves data from a member session into a directory which can be load to restore the member session completely.

Parameters

[in]	session	Member session
[in]	directory	Path to a directory

Definition at line 934 of file gnunet-service-messenger_member_session.c.

{
  struct GNUNET_CONFIGURATION_Handle *cfg;
  char *config_file;
  char *key_data;
 
  GNUNET_assert ((session) && (directory));
 
  GNUNET_asprintf (&config_file, "%s%s", directory, "session.cfg");
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Save session configuration of member: %s\n", config_file);
 
  cfg = GNUNET_CONFIGURATION_create (GNUNET_OS_project_data_gnunet ());
 
  if (! cfg)
    goto free_config;
 
  key_data = GNUNET_CRYPTO_blindable_public_key_to_string (
    get_member_session_public_key (session));
 
  if (key_data)
  {
    GNUNET_CONFIGURATION_set_value_string (cfg, "session", "key", key_data);
    GNUNET_free (key_data);
  }
 
  if (session->next)
  {
    const struct GNUNET_ShortHashCode *next_id = get_member_session_id (
      session->next);
 
    char *next_id_data = GNUNET_STRINGS_data_to_string_alloc (next_id,
                                                              sizeof(*next_id));
 
    if (next_id_data)
    {
      GNUNET_CONFIGURATION_set_value_string (cfg, "session", "next_id",
                                             next_id_data);
      GNUNET_free (next_id_data);
    }
 
    key_data = GNUNET_CRYPTO_blindable_public_key_to_string (
      get_member_session_public_key (session->next));
 
    if (key_data)
    {
      GNUNET_CONFIGURATION_set_value_string (cfg, "session", "next_key",
                                             key_data);
      GNUNET_free (key_data);
    }
  }
 
  GNUNET_CONFIGURATION_set_value_number (cfg, "session", "start",
                                         session->start.abs_value_us);
 
  GNUNET_CONFIGURATION_set_value_number (cfg, "session", "closed",
                                         session->closed);
  GNUNET_CONFIGURATION_set_value_number (cfg, "session", "completed",
                                         session->completed);
 
  GNUNET_CONFIGURATION_write (cfg, config_file);
  GNUNET_CONFIGURATION_destroy (cfg);
 
free_config:
  GNUNET_free (config_file);
 
  {
    char *history_file;
    GNUNET_asprintf (&history_file, "%s%s", directory, "history.map");
 
    save_member_session_history (session, history_file);
    GNUNET_free (history_file);
  }
 
  {
    char *messages_file;
    GNUNET_asprintf (&messages_file, "%s%s", directory, "messages.list");
 
    save_list_messages (&(session->messages), messages_file);
    GNUNET_free (messages_file);
  }
}

References GNUNET_TIME_Absolute::abs_value_us, cfg, GNUNET_MESSENGER_SrvMemberSession::closed, GNUNET_MESSENGER_SrvMemberSession::completed, config_file, get_member_session_id(), get_member_session_public_key(), GNUNET_asprintf(), GNUNET_assert, GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_destroy(), GNUNET_CONFIGURATION_set_value_number(), GNUNET_CONFIGURATION_set_value_string(), GNUNET_CONFIGURATION_write(), GNUNET_CRYPTO_blindable_public_key_to_string(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_OS_project_data_gnunet(), GNUNET_STRINGS_data_to_string_alloc(), GNUNET_MESSENGER_SrvMemberSession::messages, GNUNET_MESSENGER_SrvMemberSession::next, next_id, save_list_messages(), save_member_session_history(), and GNUNET_MESSENGER_SrvMemberSession::start.

Referenced by iterate_save_session().

Here is the call graph for this function:

Here is the caller graph for this function: