gnunet-service-messenger_peer_store.c File Reference

#include "gnunet-service-messenger_peer_store.h"
#include "gnunet-service-messenger_service.h"
#include "gnunet_common.h"
#include "messenger_api_message.h"
#include "messenger_api_util.h"

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

Go to the source code of this file.

Data Structures
struct	GNUNET_MESSENGER_PeerStoreEntry
struct	GNUNET_MESSENGER_ClosureVerifyPeer
struct	GNUNET_MESSENGER_ClosureFindPeer

Functions
void	init_peer_store (struct GNUNET_MESSENGER_PeerStore *store, struct GNUNET_MESSENGER_Service *service)
	Initializes a peer store as fully empty. More...
static enum GNUNET_GenericReturnValue	iterate_destroy_peers (void *cls, const struct GNUNET_ShortHashCode *id, void *value)
void	clear_peer_store (struct GNUNET_MESSENGER_PeerStore *store)
	Clears a peer store, wipes its content and deallocates its memory. More...
void	load_peer_store (struct GNUNET_MESSENGER_PeerStore *store, const char *path)
	Loads peer identities from a file into a peer store. More...
static enum GNUNET_GenericReturnValue	iterate_save_peers (void *cls, const struct GNUNET_ShortHashCode *id, void *value)
void	save_peer_store (const struct GNUNET_MESSENGER_PeerStore *store, const char *path)
	Saves peer identities from a peer store into a file. More...
static enum GNUNET_GenericReturnValue	verify_store_peer (void *cls, const struct GNUNET_ShortHashCode *id, void *value)
static struct GNUNET_MESSENGER_PeerStoreEntry *	add_peer_store_entry (struct GNUNET_MESSENGER_PeerStore *store, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_ShortHashCode *id, enum GNUNET_GenericReturnValue active)
static const struct GNUNET_PeerIdentity *	get_store_service_peer_identity (struct GNUNET_MESSENGER_PeerStore *store)
struct GNUNET_PeerIdentity *	get_store_peer_of (struct GNUNET_MESSENGER_PeerStore *store, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
	Returns the peer identity inside the store which verifies the signature of a given message as valid. More...
static enum GNUNET_GenericReturnValue	find_store_peer (void *cls, const struct GNUNET_ShortHashCode *id, void *value)
void	update_store_peer (struct GNUNET_MESSENGER_PeerStore *store, const struct GNUNET_PeerIdentity *peer, enum GNUNET_GenericReturnValue active)
	Adds a peer identity to the store if necessary. More...

Function Documentation

init_peer_store()

void init_peer_store	(	struct GNUNET_MESSENGER_PeerStore *	store,
		struct GNUNET_MESSENGER_Service *	service
	)

Initializes a peer store as fully empty.

Parameters

[out]	store	Peer store
[in,out]	service	Messenger service

Definition at line 40 of file gnunet-service-messenger_peer_store.c.

{
  GNUNET_assert ((store) && (service));
 
  store->service = service;
  store->peers = GNUNET_CONTAINER_multishortmap_create (4, GNUNET_NO);
}

References GNUNET_assert, GNUNET_CONTAINER_multishortmap_create(), GNUNET_NO, GNUNET_MESSENGER_PeerStore::peers, service, and GNUNET_MESSENGER_PeerStore::service.

Referenced by create_srv_room().

Here is the call graph for this function:

Here is the caller graph for this function:

iterate_destroy_peers()

static enum GNUNET_GenericReturnValue iterate_destroy_peers ( void *  cls, const struct GNUNET_ShortHashCode *  id, void *  value  )

static

Definition at line 51 of file gnunet-service-messenger_peer_store.c.

{
  struct GNUNET_MESSENGER_PeerStoreEntry *entry;
 
  GNUNET_assert (value);
 
  entry = value;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Free peer store entry: %s -> %s\n",
              GNUNET_sh2s (id),
              GNUNET_i2s (&(entry->peer)));
 
  GNUNET_free (entry);
  return GNUNET_YES;
}

References GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_sh2s(), GNUNET_YES, GNUNET_MESSENGER_PeerStoreEntry::peer, and value.

Referenced by clear_peer_store().

Here is the call graph for this function:

Here is the caller graph for this function:

clear_peer_store()

void clear_peer_store

(

struct GNUNET_MESSENGER_PeerStore *

store

)

Clears a peer store, wipes its content and deallocates its memory.

Parameters

[in,out]

store

Peer store

Definition at line 70 of file gnunet-service-messenger_peer_store.c.

{
  GNUNET_assert ((store) && (store->peers));
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Clear peer store\n");
 
  GNUNET_CONTAINER_multishortmap_iterate (store->peers, iterate_destroy_peers,
                                          NULL);
  GNUNET_CONTAINER_multishortmap_destroy (store->peers);
 
  store->peers = NULL;
}

References GNUNET_assert, GNUNET_CONTAINER_multishortmap_destroy(), GNUNET_CONTAINER_multishortmap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, iterate_destroy_peers(), and GNUNET_MESSENGER_PeerStore::peers.

Referenced by destroy_srv_room().

Here is the call graph for this function:

Here is the caller graph for this function:

load_peer_store()

void load_peer_store	(	struct GNUNET_MESSENGER_PeerStore *	store,
		const char *	path
	)

Loads peer identities from a file into a peer store.

Parameters

[out]	store	Peer store
[in]	path	Path to a file

Definition at line 85 of file gnunet-service-messenger_peer_store.c.

{
  struct GNUNET_DISK_FileHandle *handle;
  struct GNUNET_MESSENGER_PeerStoreEntry *entry;
  struct GNUNET_PeerIdentity peer;
  ssize_t len;
 
  GNUNET_assert ((store) && (path));
 
  if (GNUNET_YES != GNUNET_DISK_file_test (path))
    return;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Load peer store from path: %s\n",
              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_READ, permission);
  }
 
  if (! handle)
    return;
 
  GNUNET_DISK_file_seek (handle, 0, GNUNET_DISK_SEEK_SET);
 
  do {
    struct GNUNET_ShortHashCode peer_id;
 
    len = GNUNET_DISK_file_read (handle, &peer, sizeof(peer));
 
    if (len != sizeof(peer))
      break;
 
    entry = GNUNET_new (struct GNUNET_MESSENGER_PeerStoreEntry);
 
    if (! entry)
      continue;
 
    GNUNET_memcpy (&(entry->peer), &peer, sizeof(entry->peer));
    entry->active = GNUNET_YES;
 
    convert_peer_identity_to_id (&peer, &peer_id);
 
    if (GNUNET_OK == GNUNET_CONTAINER_multishortmap_put (
          store->peers, &peer_id, entry,
          GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE))
      continue;
 
    GNUNET_free (entry);
  } while (len == sizeof(peer));
 
  GNUNET_DISK_file_close (handle);
}

References GNUNET_MESSENGER_PeerStoreEntry::active, convert_peer_identity_to_id(), GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multishortmap_put(), 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_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_memcpy, GNUNET_new, GNUNET_OK, GNUNET_YES, handle, GNUNET_MESSENGER_PeerStoreEntry::peer, peer_id, and GNUNET_MESSENGER_PeerStore::peers.

Referenced by load_srv_room().

Here is the call graph for this function:

Here is the caller graph for this function:

iterate_save_peers()

static enum GNUNET_GenericReturnValue iterate_save_peers ( void *  cls, const struct GNUNET_ShortHashCode *  id, void *  value  )

static

Definition at line 144 of file gnunet-service-messenger_peer_store.c.

{
  struct GNUNET_DISK_FileHandle *handle;
  struct GNUNET_MESSENGER_PeerStoreEntry *entry;
 
  GNUNET_assert ((cls) && (id) && (value));
 
  handle = cls;
  entry = value;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Save peer store entry: %s\n",
              GNUNET_sh2s (id));
 
  if ((! entry) || (GNUNET_YES != entry->active))
    return GNUNET_YES;
 
  GNUNET_DISK_file_write (handle, &(entry->peer), sizeof(entry->peer));
  return GNUNET_YES;
}

References GNUNET_MESSENGER_PeerStoreEntry::active, GNUNET_assert, GNUNET_DISK_file_write(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_sh2s(), GNUNET_YES, handle, GNUNET_MESSENGER_PeerStoreEntry::peer, and value.

Referenced by save_peer_store().

Here is the call graph for this function:

Here is the caller graph for this function:

save_peer_store()

void save_peer_store	(	const struct GNUNET_MESSENGER_PeerStore *	store,
		const char *	path
	)

Saves peer identities from a peer store into a file.

Parameters

[in]	store	Peer store
[in]	path	Path to a file

Definition at line 167 of file gnunet-service-messenger_peer_store.c.

{
  struct GNUNET_DISK_FileHandle *handle;
 
  GNUNET_assert ((store) && (path));
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Save peer store to path: %s\n",
              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_multishortmap_iterate (store->peers, iterate_save_peers,
                                          handle);
 
  GNUNET_DISK_file_sync (handle);
  GNUNET_DISK_file_close (handle);
}

References GNUNET_assert, GNUNET_CONTAINER_multishortmap_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, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, handle, iterate_save_peers(), and GNUNET_MESSENGER_PeerStore::peers.

Referenced by save_srv_room().

Here is the call graph for this function:

Here is the caller graph for this function:

verify_store_peer()

static enum GNUNET_GenericReturnValue verify_store_peer ( void *  cls, const struct GNUNET_ShortHashCode *  id, void *  value  )

static

Definition at line 207 of file gnunet-service-messenger_peer_store.c.

{
  struct GNUNET_MESSENGER_ClosureVerifyPeer *verify;
  struct GNUNET_MESSENGER_PeerStoreEntry *entry;
 
  GNUNET_assert ((cls) && (value));
 
  verify = cls;
  entry = value;
 
  if (! entry)
    return GNUNET_YES;
 
  if (GNUNET_OK == verify_message_by_peer (verify->message,
                                           verify->hash, &(entry->peer)))
  {
    verify->sender = &(entry->peer);
    return GNUNET_NO;
  }
 
  return GNUNET_YES;
}

References GNUNET_assert, GNUNET_NO, GNUNET_OK, GNUNET_YES, GNUNET_MESSENGER_PeerStoreEntry::peer, value, verify, and verify_message_by_peer().

Referenced by get_store_peer_of().

Here is the call graph for this function:

Here is the caller graph for this function:

add_peer_store_entry()

static struct GNUNET_MESSENGER_PeerStoreEntry * add_peer_store_entry ( struct GNUNET_MESSENGER_PeerStore *  store, const struct GNUNET_PeerIdentity *  peer, const struct GNUNET_ShortHashCode *  id, enum GNUNET_GenericReturnValue  active  )

static

Definition at line 233 of file gnunet-service-messenger_peer_store.c.

{
  struct GNUNET_MESSENGER_PeerStoreEntry *entry;
 
  GNUNET_assert ((store) && (peer));
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Add peer store entry: %s -> %s\n",
              GNUNET_sh2s (id),
              GNUNET_i2s (peer));
 
  entry = GNUNET_new (struct GNUNET_MESSENGER_PeerStoreEntry);
 
  if (! entry)
    return NULL;
 
  GNUNET_memcpy (&(entry->peer), peer, sizeof(entry->peer));
  entry->active = active;
 
  if (GNUNET_OK != GNUNET_CONTAINER_multishortmap_put (
        store->peers, id, entry,
        GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE))
  {
    GNUNET_free (entry);
    return NULL;
  }
 
  return entry;
}

References GNUNET_MESSENGER_PeerStoreEntry::active, GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multishortmap_put(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_memcpy, GNUNET_new, GNUNET_OK, GNUNET_sh2s(), GNUNET_MESSENGER_PeerStoreEntry::peer, and GNUNET_MESSENGER_PeerStore::peers.

Referenced by get_store_peer_of(), and update_store_peer().

Here is the call graph for this function:

Here is the caller graph for this function:

get_store_service_peer_identity()

static const struct GNUNET_PeerIdentity * get_store_service_peer_identity ( struct GNUNET_MESSENGER_PeerStore *  store )

static

Definition at line 267 of file gnunet-service-messenger_peer_store.c.

{
  static struct GNUNET_PeerIdentity peer;
 
  if (GNUNET_OK != get_service_peer_identity (store->service, &peer))
    return NULL;
 
  return &peer;
}

References get_service_peer_identity(), GNUNET_OK, and GNUNET_MESSENGER_PeerStore::service.

Referenced by get_store_peer_of().

Here is the call graph for this function:

Here is the caller graph for this function:

get_store_peer_of()

struct GNUNET_PeerIdentity * get_store_peer_of	(	struct GNUNET_MESSENGER_PeerStore *	store,
		const struct GNUNET_MESSENGER_Message *	message,
		const struct GNUNET_HashCode *	hash
	)

Returns the peer identity inside the store which verifies the signature of a given message as valid.

The specific peer identity has to be added to the store previously. Otherwise the function returns NULL.

Parameters

[in,out]	store	Peer store
[in]	message	Message
[in]	hash	Hash of message

Returns

Peer identity or NULL

Definition at line 279 of file gnunet-service-messenger_peer_store.c.

{
  const struct GNUNET_PeerIdentity *peer;
  enum GNUNET_GenericReturnValue active;
  struct GNUNET_ShortHashCode peer_id;
 
  GNUNET_assert ((store) && (store->peers) && (message) && (hash));
 
  if (GNUNET_YES != is_peer_message (message))
    return NULL;
 
  {
    struct GNUNET_MESSENGER_ClosureVerifyPeer verify;
    verify.message = message;
    verify.hash = hash;
    verify.sender = NULL;
 
    GNUNET_CONTAINER_multishortmap_get_multiple (store->peers,
                                                 &(message->header.sender_id),
                                                 verify_store_peer, &verify);
 
    if (verify.sender)
      return verify.sender;
  }
 
  if (GNUNET_MESSENGER_KIND_PEER == message->header.kind)
  {
    peer = &(message->body.peer.peer);
    active = GNUNET_YES;
  }
  else if (GNUNET_MESSENGER_KIND_MISS == message->header.kind)
  {
    peer = &(message->body.miss.peer);
    active = GNUNET_NO;
  }
  else
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Peer message does not contain a peer identity\n");
 
    peer = get_store_service_peer_identity (store);
    active = GNUNET_NO;
 
    if (! peer)
      return NULL;
  }
 
  convert_peer_identity_to_id (peer, &peer_id);
 
  if (0 != GNUNET_memcmp (&peer_id, &(message->header.sender_id)))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Sender id does not match peer identity\n");
    return NULL;
  }
 
  if (GNUNET_OK != verify_message_by_peer (message, hash, peer))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Verification of message with peer identity failed!\n");
  }
 
  {
    struct GNUNET_MESSENGER_PeerStoreEntry *entry;
    entry = add_peer_store_entry (store, peer, &peer_id, active);
 
    if (! entry)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Initialization of entry in peer store failed: %s\n",
                  GNUNET_sh2s (&peer_id));
 
      return NULL;
    }
 
    return &(entry->peer);
  }
}

References GNUNET_MESSENGER_PeerStoreEntry::active, add_peer_store_entry(), GNUNET_MESSENGER_Message::body, convert_peer_identity_to_id(), get_store_service_peer_identity(), GNUNET_assert, GNUNET_CONTAINER_multishortmap_get_multiple(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_memcmp, GNUNET_MESSENGER_KIND_MISS, GNUNET_MESSENGER_KIND_PEER, GNUNET_NO, GNUNET_OK, GNUNET_sh2s(), GNUNET_YES, GNUNET_MESSENGER_ClosureVerifyPeer::hash, GNUNET_MESSENGER_Message::header, is_peer_message(), GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_ClosureVerifyPeer::message, GNUNET_MESSENGER_MessageBody::miss, GNUNET_MESSENGER_MessagePeer::peer, GNUNET_MESSENGER_MessageMiss::peer, GNUNET_MESSENGER_MessageBody::peer, GNUNET_MESSENGER_PeerStoreEntry::peer, peer_id, GNUNET_MESSENGER_PeerStore::peers, GNUNET_MESSENGER_MessageHeader::sender_id, verify, verify_message_by_peer(), and verify_store_peer().

Referenced by callback_found_message(), callback_room_handle_message(), handle_room_messages(), and traverse_epoch_session_message().

Here is the call graph for this function:

Here is the caller graph for this function:

find_store_peer()

static enum GNUNET_GenericReturnValue find_store_peer ( void *  cls, const struct GNUNET_ShortHashCode *  id, void *  value  )

static

Definition at line 368 of file gnunet-service-messenger_peer_store.c.

{
  struct GNUNET_MESSENGER_ClosureFindPeer *find;
  struct GNUNET_MESSENGER_PeerStoreEntry *entry;
 
  GNUNET_assert ((cls) && (value));
 
  find = cls;
  entry = value;
 
  if (! entry)
    return GNUNET_YES;
 
  if (0 == GNUNET_memcmp (find->requested, &(entry->peer)))
  {
    find->match = entry;
    return GNUNET_NO;
  }
 
  return GNUNET_YES;
}

References GNUNET_assert, GNUNET_memcmp, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_ClosureFindPeer::match, GNUNET_MESSENGER_PeerStoreEntry::peer, GNUNET_MESSENGER_ClosureFindPeer::requested, and value.

Referenced by update_store_peer().

Here is the caller graph for this function:

update_store_peer()

void update_store_peer	(	struct GNUNET_MESSENGER_PeerStore *	store,
		const struct GNUNET_PeerIdentity *	peer,
		enum GNUNET_GenericReturnValue	active
	)

Adds a peer identity to the store if necessary.

It ensures that the given peer can be verified as sender of a message afterwards by the store.

Parameters

[in,out]	store	Peer store
[in]	peer	Peer identity
[in]	active	Whether the peer is active or not

Definition at line 392 of file gnunet-service-messenger_peer_store.c.

{
  struct GNUNET_ShortHashCode peer_id;
 
  GNUNET_assert ((store) && (store->peers) && (peer));
 
  convert_peer_identity_to_id (peer, &peer_id);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Update peer store entry: %s\n",
              GNUNET_sh2s (&peer_id));
 
  {
    struct GNUNET_MESSENGER_ClosureFindPeer find;
    find.requested = peer;
    find.match = NULL;
 
    GNUNET_CONTAINER_multishortmap_get_multiple (store->peers, &peer_id,
                                                 find_store_peer, &find);
 
    if (find.match)
    {
      find.match->active = active;
      return;
    }
  }
 
  if (! add_peer_store_entry (store, peer, &peer_id, active))
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Initial update of entry in peer store failed: %s\n",
                GNUNET_sh2s (&peer_id));
}

References GNUNET_MESSENGER_PeerStoreEntry::active, add_peer_store_entry(), convert_peer_identity_to_id(), find_store_peer(), GNUNET_assert, GNUNET_CONTAINER_multishortmap_get_multiple(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_sh2s(), GNUNET_MESSENGER_ClosureFindPeer::match, peer_id, GNUNET_MESSENGER_PeerStore::peers, and GNUNET_MESSENGER_ClosureFindPeer::requested.

Referenced by handle_message_miss(), and handle_message_peer().

Here is the call graph for this function:

Here is the caller graph for this function: