gnunet-service-messenger_message_store.h File Reference

GNUnet MESSENGER service. More...

#include "platform.h"
#include "gnunet_util_lib.h"

Include dependency graph for gnunet-service-messenger_message_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_MessageEntry
struct	GNUNET_MESSENGER_MessageLink
struct	GNUNET_MESSENGER_MessageStore

Functions
void	init_message_store (struct GNUNET_MESSENGER_MessageStore *store)
	Initializes a message store as fully empty. More...
void	clear_message_store (struct GNUNET_MESSENGER_MessageStore *store)
	Clears a message store, wipes its content and deallocates its memory. More...
void	load_message_store (struct GNUNET_MESSENGER_MessageStore *store, const char *directory)
	Loads messages from a directory into a message store. More...
void	save_message_store (struct GNUNET_MESSENGER_MessageStore *store, const char *directory)
	Saves messages from a message store into a directory. More...
int	contains_store_message (const struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash)
	Checks if a message matching a given hash is stored in a message store. More...
const struct GNUNET_MESSENGER_Message *	get_store_message (struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash)
	Returns the message from a message store matching a given hash. More...
const struct GNUNET_MESSENGER_MessageLink *	get_store_message_link (struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash, int deleted_only)
	Returns the message link from a message store matching a given hash. More...
int	put_store_message (struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash, struct GNUNET_MESSENGER_Message *message)
	Stores a message into the message store. More...
int	delete_store_message (struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash)
	Deletes a message in the message store. More...

Detailed Description

GNUnet MESSENGER service.

Author

Tobias Frisch

Definition in file gnunet-service-messenger_message_store.h.

Function Documentation

init_message_store()

void init_message_store

(

struct GNUNET_MESSENGER_MessageStore *

store

)

Initializes a message store as fully empty.

Parameters

[out]

store

Message store

Definition at line 31 of file gnunet-service-messenger_message_store.c.

{
  GNUNET_assert(store);
 
  store->storage_messages = NULL;
 
  store->entries = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
  store->messages = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
  store->links = GNUNET_CONTAINER_multihashmap_create (8, GNUNET_NO);
 
  store->rewrite_entries = GNUNET_NO;
  store->write_links = GNUNET_NO;
}

References GNUNET_MESSENGER_MessageStore::entries, GNUNET_assert, GNUNET_CONTAINER_multihashmap_create(), GNUNET_NO, GNUNET_MESSENGER_MessageStore::links, GNUNET_MESSENGER_MessageStore::messages, GNUNET_MESSENGER_MessageStore::rewrite_entries, GNUNET_MESSENGER_MessageStore::storage_messages, and GNUNET_MESSENGER_MessageStore::write_links.

Referenced by create_srv_room().

Here is the call graph for this function:

Here is the caller graph for this function:

clear_message_store()

void clear_message_store

(

struct GNUNET_MESSENGER_MessageStore *

store

)

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

Parameters

[in,out]

store

Message store

Definition at line 82 of file gnunet-service-messenger_message_store.c.

{
  GNUNET_assert(store);
 
  if (store->storage_messages)
  {
    GNUNET_DISK_file_close (store->storage_messages);
 
    store->storage_messages = NULL;
  }
 
  GNUNET_CONTAINER_multihashmap_iterate (store->entries, iterate_destroy_entries, NULL);
  GNUNET_CONTAINER_multihashmap_iterate (store->messages, iterate_destroy_messages, NULL);
  GNUNET_CONTAINER_multihashmap_iterate (store->links, iterate_destroy_links, NULL);
 
  GNUNET_CONTAINER_multihashmap_destroy (store->entries);
  GNUNET_CONTAINER_multihashmap_destroy (store->messages);
  GNUNET_CONTAINER_multihashmap_destroy (store->links);
}

References GNUNET_MESSENGER_MessageStore::entries, GNUNET_assert, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_DISK_file_close(), iterate_destroy_entries(), iterate_destroy_links(), iterate_destroy_messages(), GNUNET_MESSENGER_MessageStore::links, GNUNET_MESSENGER_MessageStore::messages, and GNUNET_MESSENGER_MessageStore::storage_messages.

Referenced by destroy_srv_room().

Here is the call graph for this function:

Here is the caller graph for this function:

load_message_store()

void load_message_store	(	struct GNUNET_MESSENGER_MessageStore *	store,
		const char *	directory
	)

Loads messages from a directory into a message store.

Parameters

[out]	store	Message store
[in]	directory	Path to a directory

Definition at line 210 of file gnunet-service-messenger_message_store.c.

{
  GNUNET_assert((store) && (directory));
 
  enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
 
  if (store->storage_messages)
    GNUNET_DISK_file_close (store->storage_messages);
 
  char *filename;
  GNUNET_asprintf (&filename, "%s%s", directory, "messages.store");
 
  if (GNUNET_YES == GNUNET_DISK_file_test (filename))
    store->storage_messages = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_READWRITE, permission);
  else
    store->storage_messages = NULL;
 
  GNUNET_free(filename);
 
  if (!store->storage_messages)
    return;
 
  GNUNET_asprintf (&filename, "%s%s", directory, "entries.store");
 
  if (GNUNET_YES == GNUNET_DISK_file_test (filename))
    load_message_store_entries(store, filename);
 
  GNUNET_free(filename);
 
  GNUNET_asprintf (&filename, "%s%s", directory, "links.store");
 
  if (GNUNET_YES == GNUNET_DISK_file_test (filename))
    load_message_store_links(store, filename);
 
  GNUNET_free(filename);
}

References filename, GNUNET_asprintf(), GNUNET_assert, GNUNET_DISK_file_close(), GNUNET_DISK_file_open(), GNUNET_DISK_file_test(), GNUNET_DISK_OPEN_READWRITE, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_free, GNUNET_YES, load_message_store_entries(), load_message_store_links(), and GNUNET_MESSENGER_MessageStore::storage_messages.

Referenced by load_srv_room().

Here is the call graph for this function:

Here is the caller graph for this function:

save_message_store()

void save_message_store	(	struct GNUNET_MESSENGER_MessageStore *	store,
		const char *	directory
	)

Saves messages from a message store into a directory.

Parameters

[in]	store	Message store
[in]	directory	Path to a directory

Definition at line 323 of file gnunet-service-messenger_message_store.c.

{
  GNUNET_assert((store) && (directory));
 
  struct GNUNET_MESSENGER_ClosureMessageSave save;
 
  enum GNUNET_DISK_AccessPermissions permission = (GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE);
 
  char *filename;
 
  if (GNUNET_YES != store->write_links)
    goto save_entries;
 
  GNUNET_asprintf (&filename, "%s%s", directory, "links.store");
 
  save.store = store;
  save.storage = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE, permission);
 
  GNUNET_free(filename);
 
  if (!save.storage)
    goto save_entries;
 
  if (GNUNET_SYSERR == GNUNET_DISK_file_seek (save.storage, 0, GNUNET_DISK_SEEK_SET))
    goto close_links;
 
  GNUNET_CONTAINER_multihashmap_iterate (store->links, iterate_save_links, &save);
  store->write_links = GNUNET_NO;
 
close_links:
  GNUNET_DISK_file_close (save.storage);
 
save_entries:
  GNUNET_asprintf (&filename, "%s%s", directory, "entries.store");
 
  save.store = store;
  save.storage = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_WRITE | GNUNET_DISK_OPEN_CREATE, permission);
 
  GNUNET_free(filename);
 
  if (!save.storage)
    return;
 
  if (GNUNET_YES == store->rewrite_entries)
  {
    if (GNUNET_SYSERR == GNUNET_DISK_file_seek (save.storage, 0, GNUNET_DISK_SEEK_SET))
      goto close_entries;
 
    GNUNET_CONTAINER_multihashmap_iterate (store->entries, iterate_save_entries, &save);
    store->rewrite_entries = GNUNET_NO;
  }
  else if (GNUNET_SYSERR == GNUNET_DISK_file_seek (save.storage, 0, GNUNET_DISK_SEEK_END))
    goto close_entries;
 
  if (store->storage_messages)
    GNUNET_DISK_file_close (store->storage_messages);
 
  GNUNET_asprintf (&filename, "%s%s", directory, "messages.store");
 
  store->storage_messages = GNUNET_DISK_file_open (filename, GNUNET_DISK_OPEN_READWRITE | GNUNET_DISK_OPEN_CREATE,
                                                   permission);
 
  GNUNET_free(filename);
 
  if (store->storage_messages)
  {
    GNUNET_CONTAINER_multihashmap_iterate (store->messages, iterate_save_messages, &save);
 
    GNUNET_DISK_file_sync (store->storage_messages);
    GNUNET_DISK_file_sync (save.storage);
  }
 
close_entries:
  GNUNET_DISK_file_close (save.storage);
}

References GNUNET_MESSENGER_MessageStore::entries, filename, GNUNET_asprintf(), 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_READWRITE, GNUNET_DISK_OPEN_WRITE, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_DISK_SEEK_END, GNUNET_DISK_SEEK_SET, GNUNET_free, GNUNET_NO, GNUNET_SYSERR, GNUNET_YES, iterate_save_entries(), iterate_save_links(), iterate_save_messages(), GNUNET_MESSENGER_MessageStore::links, GNUNET_MESSENGER_MessageStore::messages, GNUNET_MESSENGER_MessageStore::rewrite_entries, save(), GNUNET_MESSENGER_MessageStore::storage_messages, GNUNET_MESSENGER_ClosureMessageSave::store, and GNUNET_MESSENGER_MessageStore::write_links.

Referenced by save_srv_room().

Here is the call graph for this function:

Here is the caller graph for this function:

contains_store_message()

int contains_store_message	(	const struct GNUNET_MESSENGER_MessageStore *	store,
		const struct GNUNET_HashCode *	hash
	)

Checks if a message matching a given hash is stored in a message store.

The function returns GNUNET_YES if a match is found, GNUNET_NO otherwise.

The message has not to be loaded from disk into memory for this check!

Parameters

[in]	store	Message store
[in]	hash	Hash of message

Returns

GNUNET_YES on match, otherwise GNUNET_NO

Definition at line 401 of file gnunet-service-messenger_message_store.c.

{
  GNUNET_assert((store) && (hash));
 
  if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (store->messages, hash))
    return GNUNET_YES;
 
  return GNUNET_CONTAINER_multihashmap_contains (store->entries, hash);
}

References GNUNET_MESSENGER_MessageStore::entries, GNUNET_assert, GNUNET_CONTAINER_multihashmap_contains(), GNUNET_YES, GNUNET_MESSENGER_MessageStore::messages, and GNUNET_MESSENGER_ClosureMessageSave::store.

Here is the call graph for this function:

get_store_message()

const struct GNUNET_MESSENGER_Message* get_store_message	(	struct GNUNET_MESSENGER_MessageStore *	store,
		const struct GNUNET_HashCode *	hash
	)

Returns the message from a message store matching a given hash.

If no matching message is found, NULL gets returned.

This function requires the message to be loaded into memory!

See also

contains_store_message()

Parameters

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

Returns

Message or NULL

Definition at line 413 of file gnunet-service-messenger_message_store.c.

{
  GNUNET_assert((store) && (hash));
 
  struct GNUNET_MESSENGER_Message *message = GNUNET_CONTAINER_multihashmap_get (store->messages, hash);
 
  if (message)
    return message;
 
  if (!store->storage_messages)
    return NULL;
 
  const struct GNUNET_MESSENGER_MessageEntry *entry = GNUNET_CONTAINER_multihashmap_get (store->entries, hash);
 
  if (!entry)
    return NULL;
 
  if (entry->offset != GNUNET_DISK_file_seek (store->storage_messages, entry->offset, GNUNET_DISK_SEEK_SET))
    return message;
 
  char *buffer = GNUNET_malloc(entry->length);
 
  if (!buffer)
    return NULL;
 
  if ((GNUNET_DISK_file_read (store->storage_messages, buffer, entry->length) != entry->length) ||
      (entry->length < get_message_kind_size(GNUNET_MESSENGER_KIND_UNKNOWN, GNUNET_YES)))
    goto free_buffer;
 
  message = create_message (GNUNET_MESSENGER_KIND_UNKNOWN);
 
  const int decoding = decode_message (message, entry->length, buffer, GNUNET_YES, NULL);
 
  struct GNUNET_HashCode check;
  hash_message (message, entry->length, buffer, &check);
 
  if ((GNUNET_YES != decoding) || (GNUNET_CRYPTO_hash_cmp (hash, &check) != 0))
  {
    if (GNUNET_YES != GNUNET_CONTAINER_multihashmap_remove (store->entries, hash, entry))
      GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Corrupted entry could not be removed from store: %s\n",
                 GNUNET_h2s(hash));
 
    store->rewrite_entries = GNUNET_YES;
 
    goto free_message;
  }
 
  if (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (store->messages, hash, message,
                                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST))
    goto free_buffer;
 
free_message: destroy_message (message);
  message = NULL;
 
free_buffer:
  GNUNET_free(buffer);
 
  return message;
}

References create_message(), decode_message(), destroy_message(), GNUNET_MESSENGER_MessageStore::entries, get_message_kind_size(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_CRYPTO_hash_cmp(), GNUNET_DISK_file_read(), GNUNET_DISK_file_seek(), GNUNET_DISK_SEEK_SET, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_malloc, GNUNET_MESSENGER_KIND_UNKNOWN, GNUNET_OK, GNUNET_YES, hash_message(), GNUNET_MESSENGER_MessageEntry::length, GNUNET_MESSENGER_MessageStore::messages, GNUNET_MESSENGER_MessageEntry::offset, GNUNET_MESSENGER_MessageStore::rewrite_entries, and GNUNET_MESSENGER_MessageStore::storage_messages.

Referenced by callback_verify_room_message(), check_srv_room_peer_status(), delete_srv_room_message(), forward_about_members(), get_store_message_link(), handle_room_messages(), notify_about_members(), request_room_message_step(), update_room_message(), and update_tunnel_last_message().

Here is the call graph for this function:

Here is the caller graph for this function:

get_store_message_link()

const struct GNUNET_MESSENGER_MessageLink* get_store_message_link	(	struct GNUNET_MESSENGER_MessageStore *	store,
		const struct GNUNET_HashCode *	hash,
		int	deleted_only
	)

Returns the message link from a message store matching a given hash.

If the flag is set to GNUNET_YES, only links from deleted messages will be returned or NULL.

Otherwise message links will also returned for messages found in the store under the given hash. The link which will be returned copies link information from the message for temporary usage.

Parameters

[in,out]	store	Message store
[in]	hash	Hash of message
[in]	deleted_only	Flag

Returns

Message link or NULL

Definition at line 475 of file gnunet-service-messenger_message_store.c.

{
  if (deleted_only)
    goto get_link;
 
  const struct GNUNET_MESSENGER_Message *message = get_store_message(store, hash);
 
  if (!message)
    goto get_link;
 
  static struct GNUNET_MESSENGER_MessageLink link;
 
  GNUNET_memcpy(&(link.first), &(message->header.previous), sizeof(link.first));
 
  link.multiple = GNUNET_MESSENGER_KIND_MERGE == message->header.kind? GNUNET_YES : GNUNET_NO;
 
  if (GNUNET_YES == link.multiple)
    GNUNET_memcpy(&(link.second), &(message->body.merge.previous), sizeof(link.second));
  else
    GNUNET_memcpy(&(link.second), &(message->header.previous), sizeof(link.second));
 
  return &link;
 
get_link:
  return GNUNET_CONTAINER_multihashmap_get (store->links, hash);
}

References GNUNET_MESSENGER_Message::body, GNUNET_MESSENGER_MessageLink::first, get_store_message(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_memcpy, GNUNET_MESSENGER_KIND_MERGE, GNUNET_NO, GNUNET_YES, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_MessageStore::links, GNUNET_MESSENGER_MessageBody::merge, GNUNET_MESSENGER_MessageLink::multiple, GNUNET_MESSENGER_MessageHeader::previous, GNUNET_MESSENGER_MessageMerge::previous, and GNUNET_MESSENGER_MessageLink::second.

Referenced by check_member_session_completion(), and request_room_message_step().

Here is the call graph for this function:

Here is the caller graph for this function:

put_store_message()

int put_store_message	(	struct GNUNET_MESSENGER_MessageStore *	store,
		const struct GNUNET_HashCode *	hash,
		struct GNUNET_MESSENGER_Message *	message
	)

Stores a message into the message store.

The result indicates if the operation was successful.

Parameters

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

Returns

GNUNET_OK on success, otherwise GNUNET_NO

Definition at line 505 of file gnunet-service-messenger_message_store.c.

{
  GNUNET_assert((store) && (hash) && (message));
 
  return GNUNET_CONTAINER_multihashmap_put (store->messages, hash, message,
                                            GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
}

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, and GNUNET_MESSENGER_MessageStore::messages.

Referenced by update_room_message().

Here is the call graph for this function:

Here is the caller graph for this function:

delete_store_message()

int delete_store_message	(	struct GNUNET_MESSENGER_MessageStore *	store,
		const struct GNUNET_HashCode *	hash
	)

Deletes a message in the message store.

It will be removed from disk space and memory. The result indicates if the operation was successful.

Parameters

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

Returns

GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 537 of file gnunet-service-messenger_message_store.c.

{
  GNUNET_assert((store) && (hash));
 
  const struct GNUNET_MESSENGER_MessageEntry *entry = GNUNET_CONTAINER_multihashmap_get (store->entries, hash);
 
  if (!entry)
    goto clear_memory;
 
  const struct GNUNET_MESSENGER_Message *message = get_store_message(store, hash);
 
  if (message)
    add_link (store, hash, message);
 
  if (!store->storage_messages)
    goto clear_entry;
 
  if (entry->offset != GNUNET_DISK_file_seek (store->storage_messages, entry->offset, GNUNET_DISK_SEEK_SET))
    return GNUNET_SYSERR;
 
  char *clear_buffer = GNUNET_malloc(entry->length);
 
  if (!clear_buffer)
    return GNUNET_SYSERR;
 
  GNUNET_CRYPTO_zero_keys (clear_buffer, entry->length);
 
  if ((entry->length != GNUNET_DISK_file_write (store->storage_messages, clear_buffer, entry->length)) || (GNUNET_OK
      != GNUNET_DISK_file_sync (store->storage_messages)))
  {
    GNUNET_free(clear_buffer);
    return GNUNET_SYSERR;
  }
 
  GNUNET_free(clear_buffer);
 
clear_entry:
  if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_remove (store->entries, hash, entry))
    store->rewrite_entries = GNUNET_YES;
 
clear_memory:
  GNUNET_CONTAINER_multihashmap_remove_all (store->messages, hash);
  return GNUNET_OK;
}

Referenced by callback_room_deletion().

Here is the caller graph for this function: