gnunet-service-messenger_peer_store.h File Reference

#include "gnunet_util_lib.h"

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

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

Go to the source code of this file.

Data Structures
struct	GNUNET_MESSENGER_PeerStore

Functions
void	init_peer_store (struct GNUNET_MESSENGER_PeerStore *store, struct GNUNET_MESSENGER_Service *service)
	Initializes a peer store as fully empty. More...
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...
void	save_peer_store (const struct GNUNET_MESSENGER_PeerStore *store, const char *path)
	Saves peer identities from a peer store into a file. More...
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...
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:

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 66 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 81 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:

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

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 271 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_WARNING,
                "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_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(), and handle_room_messages().

Here is the call graph for this function:

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