peerstore_common.h File Reference

Helper peerstore functions. More...

#include "platform.h"
#include "peerstore.h"

Include dependency graph for peerstore_common.h:

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

Go to the source code of this file.

Functions
void	PEERSTORE_hash_key (const char *sub_system, const struct GNUNET_PeerIdentity *peer, const char *key, struct GNUNET_HashCode *ret)
	Creates a hash of the given key combination. More...
struct GNUNET_MQ_Envelope *	PEERSTORE_create_record_mq_envelope (const char *sub_system, const struct GNUNET_PeerIdentity *peer, const char *key, const void *value, size_t value_size, struct GNUNET_TIME_Absolute expiry, enum GNUNET_PEERSTORE_StoreOption options, uint16_t msg_type)
	Creates a MQ envelope for a single record. More...
struct GNUNET_PEERSTORE_Record *	PEERSTORE_parse_record_message (const struct StoreRecordMessage *srm)
	Parses a message carrying a record. More...
void	PEERSTORE_destroy_record (struct GNUNET_PEERSTORE_Record *record)
	Free any memory allocated for this record. More...

Detailed Description

Helper peerstore functions.

Author

Omar Tarabai

Definition in file peerstore_common.h.

Function Documentation

PEERSTORE_hash_key()

void PEERSTORE_hash_key	(	const char *	sub_system,
		const struct GNUNET_PeerIdentity *	peer,
		const char *	key,
		struct GNUNET_HashCode *	ret
	)

Creates a hash of the given key combination.

Definition at line 34 of file peerstore_common.c.

{
  size_t sssize;
  size_t psize;
  size_t ksize;
  size_t totalsize;
  void *block;
  void *blockptr;
 
  sssize = strlen (sub_system) + 1;
  psize = sizeof(struct GNUNET_PeerIdentity);
  ksize = strlen (key) + 1;
  totalsize = sssize + psize + ksize;
  block = GNUNET_malloc (totalsize);
  blockptr = block;
  GNUNET_memcpy (blockptr, sub_system, sssize);
  blockptr += sssize;
  GNUNET_memcpy (blockptr, peer, psize);
  blockptr += psize;
  GNUNET_memcpy (blockptr, key, ksize);
  GNUNET_CRYPTO_hash (block, totalsize, ret);
  GNUNET_free (block);
}

References GNUNET_CRYPTO_hash(), GNUNET_free, GNUNET_malloc, GNUNET_memcpy, key, peer, and ret.

Referenced by GNUNET_PEERSTORE_watch(), handle_watch_record(), and watch_notifier().

Here is the call graph for this function:

Here is the caller graph for this function:

PEERSTORE_create_record_mq_envelope()

struct GNUNET_MQ_Envelope* PEERSTORE_create_record_mq_envelope	(	const char *	sub_system,
		const struct GNUNET_PeerIdentity *	peer,
		const char *	key,
		const void *	value,
		size_t	value_size,
		struct GNUNET_TIME_Absolute	expiry,
		enum GNUNET_PEERSTORE_StoreOption	options,
		uint16_t	msg_type
	)

Creates a MQ envelope for a single record.

Parameters

sub_system	sub system string
peer	Peer identity (can be NULL)
key	record key string (can be NULL)
value	record value BLOB (can be NULL)
value_size	record value size in bytes (set to 0 if value is NULL)
expiry	time after which the record expires
options	options specific to the storage operation
msg_type	message type to be set in header

Returns

pointer to record message struct

Definition at line 76 of file peerstore_common.c.

{
  struct StoreRecordMessage *srm;
  struct GNUNET_MQ_Envelope *ev;
  size_t ss_size;
  size_t key_size;
  size_t msg_size;
  void *dummy;
 
  GNUNET_assert (NULL != sub_system);
  ss_size = strlen (sub_system) + 1;
  if (NULL == key)
    key_size = 0;
  else
    key_size = strlen (key) + 1;
  msg_size = ss_size + key_size + value_size;
  ev = GNUNET_MQ_msg_extra (srm, msg_size, msg_type);
  srm->key_size = htons (key_size);
  srm->expiry = GNUNET_TIME_absolute_hton (expiry);
  if (NULL == peer)
    srm->peer_set = htons (GNUNET_NO);
  else
  {
    srm->peer_set = htons (GNUNET_YES);
    srm->peer = *peer;
  }
  srm->sub_system_size = htons (ss_size);
  srm->value_size = htons (value_size);
  srm->options = htonl (options);
  dummy = &srm[1];
  GNUNET_memcpy (dummy, sub_system, ss_size);
  dummy += ss_size;
  GNUNET_memcpy (dummy, key, key_size);
  dummy += key_size;
  GNUNET_memcpy (dummy, value, value_size);
  return ev;
}

References dummy, StoreRecordMessage::expiry, GNUNET_assert, GNUNET_memcpy, GNUNET_MQ_msg_extra, GNUNET_NO, GNUNET_TIME_absolute_hton(), GNUNET_YES, key, StoreRecordMessage::key_size, options, StoreRecordMessage::options, StoreRecordMessage::peer, peer, StoreRecordMessage::peer_set, StoreRecordMessage::sub_system_size, value, and StoreRecordMessage::value_size.

Referenced by GNUNET_PEERSTORE_iterate(), GNUNET_PEERSTORE_store(), reconnect(), record_iterator(), and watch_notifier_it().

Here is the call graph for this function:

Here is the caller graph for this function:

PEERSTORE_parse_record_message()

struct GNUNET_PEERSTORE_Record* PEERSTORE_parse_record_message

(

const struct StoreRecordMessage *

srm

)

Parses a message carrying a record.

Parameters

srm	the actual message

Returns

Pointer to record or NULL on error

Definition at line 123 of file peerstore_common.c.

{
  struct GNUNET_PEERSTORE_Record *record;
  uint16_t req_size;
  uint16_t ss_size;
  uint16_t key_size;
  uint16_t value_size;
  char *dummy;
 
  req_size = ntohs (srm->header.size) - sizeof(*srm);
  ss_size = ntohs (srm->sub_system_size);
  key_size = ntohs (srm->key_size);
  value_size = ntohs (srm->value_size);
  if (ss_size + key_size + value_size != req_size)
  {
    GNUNET_break (0);
    return NULL;
  }
  record = GNUNET_new (struct GNUNET_PEERSTORE_Record);
  if (GNUNET_YES == ntohs (srm->peer_set))
  {
    record->peer = srm->peer;
  }
  record->expiry = GNUNET_TIME_absolute_ntoh (srm->expiry);
  dummy = (char *) &srm[1];
  if (ss_size > 0)
  {
    record->sub_system = GNUNET_strdup (dummy);
    dummy += ss_size;
  }
  if (key_size > 0)
  {
    record->key = GNUNET_strdup (dummy);
    dummy += key_size;
  }
  if (value_size > 0)
  {
    record->value = GNUNET_malloc (value_size);
    GNUNET_memcpy (record->value,
                   dummy,
                   value_size);
  }
  record->value_size = value_size;
  return record;
}

References dummy, StoreRecordMessage::expiry, GNUNET_break, GNUNET_malloc, GNUNET_memcpy, GNUNET_new, GNUNET_strdup, GNUNET_TIME_absolute_ntoh(), GNUNET_YES, StoreRecordMessage::header, StoreRecordMessage::key_size, StoreRecordMessage::peer, StoreRecordMessage::peer_set, record(), GNUNET_MessageHeader::size, StoreRecordMessage::sub_system_size, GNUNET_PEERSTORE_Record::value_size, and StoreRecordMessage::value_size.

Referenced by check_iterate(), check_store(), handle_iterate(), handle_iterate_result(), handle_store(), and handle_watch_record().

Here is the call graph for this function:

Here is the caller graph for this function:

PEERSTORE_destroy_record()

void PEERSTORE_destroy_record

(

struct GNUNET_PEERSTORE_Record *

record

)

Free any memory allocated for this record.

Parameters

record

Definition at line 176 of file peerstore_common.c.

{
  if (NULL != record->sub_system)
    GNUNET_free (record->sub_system);
  if (NULL != record->key)
    GNUNET_free (record->key);
  if (NULL != record->value)
  {
    GNUNET_free (record->value);
    record->value = 0;
  }
  GNUNET_free (record);
}

References GNUNET_free, and record().

Referenced by check_iterate(), check_store(), handle_iterate(), handle_iterate_result(), handle_store(), handle_watch_record(), record_iterator(), and store_record_continuation().

Here is the call graph for this function:

Here is the caller graph for this function: