GNUnet  0.20.0
peerstore_common.c File Reference

Helper peerstore functions. More...

#include "platform.h"
#include "peerstore_common.h"
Include dependency graph for peerstore_common.c:

Go to the source code of this file.


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_EnvelopePEERSTORE_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_RecordPEERSTORE_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.

Omar Tarabai

Definition in file peerstore_common.c.

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.

38 {
39  size_t sssize;
40  size_t psize;
41  size_t ksize;
42  size_t totalsize;
43  void *block;
44  void *blockptr;
46  sssize = strlen (sub_system) + 1;
47  psize = sizeof(struct GNUNET_PeerIdentity);
48  ksize = strlen (key) + 1;
49  totalsize = sssize + psize + ksize;
50  block = GNUNET_malloc (totalsize);
51  blockptr = block;
52  GNUNET_memcpy (blockptr, sub_system, sssize);
53  blockptr += sssize;
54  GNUNET_memcpy (blockptr, peer, psize);
55  blockptr += psize;
56  GNUNET_memcpy (blockptr, key, ksize);
57  GNUNET_CRYPTO_hash (block, totalsize, ret);
58  GNUNET_free (block);
59 }
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
struct GNUNET_HashCode key
The key used in the DHT.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
The identity of the host (wraps the signing key of the peer).
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.

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.

sub_systemsub system string
peerPeer identity (can be NULL)
keyrecord key string (can be NULL)
valuerecord value BLOB (can be NULL)
value_sizerecord value size in bytes (set to 0 if value is NULL)
expirytime after which the record expires
optionsoptions specific to the storage operation
msg_typemessage type to be set in header
pointer to record message struct

Definition at line 76 of file peerstore_common.c.

84 {
85  struct StoreRecordMessage *srm;
86  struct GNUNET_MQ_Envelope *ev;
87  size_t ss_size;
88  size_t key_size;
89  size_t msg_size;
90  void *dummy;
92  GNUNET_assert (NULL != sub_system);
93  ss_size = strlen (sub_system) + 1;
94  if (NULL == key)
95  key_size = 0;
96  else
97  key_size = strlen (key) + 1;
98  msg_size = ss_size + key_size + value_size;
99  ev = GNUNET_MQ_msg_extra (srm, msg_size, msg_type);
100  srm->key_size = htons (key_size);
101  srm->expiry = GNUNET_TIME_absolute_hton (expiry);
102  if (NULL == peer)
103  srm->peer_set = htons (GNUNET_NO);
104  else
105  {
106  srm->peer_set = htons (GNUNET_YES);
107  srm->peer = *peer;
108  }
109  srm->sub_system_size = htons (ss_size);
110  srm->value_size = htons (value_size);
111  srm->options = htonl (options);
112  dummy = &srm[1];
113  GNUNET_memcpy (dummy, sub_system, ss_size);
114  dummy += ss_size;
115  GNUNET_memcpy (dummy, key, key_size);
116  dummy += key_size;
117  GNUNET_memcpy (dummy, value, value_size);
118  return ev;
119 }
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
static struct in_addr dummy
Target "dummy" address of the packet we pretend to respond to.
static char * value
Value of the record to add/remove.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition: gnunet_mq_lib.h:63
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:638
Message carrying a PEERSTORE record message.
Definition: peerstore.h:37
uint32_t options
Options, needed only in case of a store operation.
Definition: peerstore.h:80
uint16_t key_size
Size of the key string Allocated at position 1 after this struct.
Definition: peerstore.h:68
struct GNUNET_TIME_AbsoluteNBO expiry
Expiry time of entry.
Definition: peerstore.h:62
uint16_t value_size
Size of value blob Allocated at position 2 after this struct.
Definition: peerstore.h:74
uint16_t peer_set
GNUNET_YES if peer id value set, GNUNET_NO otherwise
Definition: peerstore.h:46
uint16_t sub_system_size
Size of the sub_system string Allocated at position 0 after this struct.
Definition: peerstore.h:52
struct GNUNET_PeerIdentity peer
Peer Identity.
Definition: peerstore.h:57

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.

srmthe actual message
Pointer to record or NULL on error

Definition at line 123 of file peerstore_common.c.

124 {
126  uint16_t req_size;
127  uint16_t ss_size;
128  uint16_t key_size;
129  uint16_t value_size;
130  char *dummy;
132  req_size = ntohs (srm->header.size) - sizeof(*srm);
133  ss_size = ntohs (srm->sub_system_size);
134  key_size = ntohs (srm->key_size);
135  value_size = ntohs (srm->value_size);
136  if (ss_size + key_size + value_size != req_size)
137  {
138  GNUNET_break (0);
139  return NULL;
140  }
142  if (GNUNET_YES == ntohs (srm->peer_set))
143  {
144  record->peer = srm->peer;
145  }
146  record->expiry = GNUNET_TIME_absolute_ntoh (srm->expiry);
147  dummy = (char *) &srm[1];
148  if (ss_size > 0)
149  {
150  record->sub_system = GNUNET_strdup (dummy);
151  dummy += ss_size;
152  }
153  if (key_size > 0)
154  {
155  record->key = GNUNET_strdup (dummy);
156  dummy += key_size;
157  }
158  if (value_size > 0)
159  {
160  record->value = GNUNET_malloc (value_size);
161  GNUNET_memcpy (record->value,
162  dummy,
163  value_size);
164  }
165  record->value_size = value_size;
166  return record;
167 }
static void record(void *cls, size_t data_size, const void *data)
Process recorded audio data.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:737
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
Single PEERSTORE record.
size_t value_size
Size of value BLOB.
struct GNUNET_MessageHeader header
GNUnet message header.
Definition: peerstore.h:41

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.


Definition at line 176 of file peerstore_common.c.

177 {
178  if (NULL != record->sub_system)
179  GNUNET_free (record->sub_system);
180  if (NULL != record->key)
181  GNUNET_free (record->key);
182  if (NULL != record->value)
183  {
184  GNUNET_free (record->value);
185  record->value = 0;
186  }
188 }

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: