GNUnet 0.22.2
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_EnvelopePEERSTORE_create_record_mq_envelope (uint32_t rid, 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 PeerstoreRecordMessage *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 33 of file peerstore_common.c.

37{
38 size_t sssize;
39 size_t psize;
40 size_t ksize;
41 size_t totalsize;
42 void *block;
43 void *blockptr;
44
45 sssize = strlen (sub_system) + 1;
46 psize = sizeof(struct GNUNET_PeerIdentity);
47 ksize = strlen (key) + 1;
48 totalsize = sssize + psize + ksize;
49 block = GNUNET_malloc (totalsize);
50 blockptr = block;
51 GNUNET_memcpy (blockptr, sub_system, sssize);
52 blockptr += sssize;
53 GNUNET_memcpy (blockptr, peer, psize);
54 blockptr += psize;
55 GNUNET_memcpy (blockptr, key, ksize);
56 GNUNET_CRYPTO_hash (block, totalsize, ret);
57 GNUNET_free (block);
58}
static int ret
Final status code.
Definition: gnunet-arm.c:93
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).

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

Here is the call graph for this function:

◆ PEERSTORE_create_record_mq_envelope()

struct GNUNET_MQ_Envelope * PEERSTORE_create_record_mq_envelope ( uint32_t  rid,
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
ridrequest ID
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
Returns
pointer to record message struct

Definition at line 62 of file peerstore_common.c.

71{
72 struct PeerstoreRecordMessage *srm;
73 struct GNUNET_MQ_Envelope *ev;
74 size_t ss_size;
75 size_t key_size;
76 size_t msg_size;
77 void *dummy;
78
79 GNUNET_assert (NULL != sub_system);
80 ss_size = strlen (sub_system) + 1;
81 if (NULL == key)
82 key_size = 0;
83 else
84 key_size = strlen (key) + 1;
85 msg_size = ss_size + key_size + value_size;
86 ev = GNUNET_MQ_msg_extra (srm, msg_size, msg_type);
87 srm->key_size = htons (key_size);
88 srm->expiry = GNUNET_TIME_absolute_hton (expiry);
89 GNUNET_assert (NULL != peer);
90 srm->peer = *peer;
91 srm->rid = htons (rid);
92 srm->sub_system_size = htons (ss_size);
93 srm->value_size = htons (value_size);
94 srm->options = htonl (options);
95 dummy = &srm[1];
96 GNUNET_memcpy (dummy, sub_system, ss_size);
97 dummy += ss_size;
98 GNUNET_memcpy (dummy, key, key_size);
99 dummy += key_size;
100 GNUNET_memcpy (dummy, value, value_size);
101 return ev;
102}
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:640
Message carrying a PEERSTORE record message.
Definition: peerstore.h:38
uint16_t value_size
Size of value blob Allocated at position 2 after this struct.
Definition: peerstore.h:75
uint16_t key_size
Size of the key string Allocated at position 1 after this struct.
Definition: peerstore.h:69
struct GNUNET_TIME_AbsoluteNBO expiry
Expiry time of entry.
Definition: peerstore.h:52
uint32_t rid
Request id.
Definition: peerstore.h:57
uint32_t options
Options, needed only in case of a store operation.
Definition: peerstore.h:63
uint16_t sub_system_size
Size of the sub_system string Allocated at position 0 after this struct.
Definition: peerstore.h:82
struct GNUNET_PeerIdentity peer
Peer Identity.
Definition: peerstore.h:47

References dummy, PeerstoreRecordMessage::expiry, GNUNET_assert, GNUNET_memcpy, GNUNET_MQ_msg_extra, GNUNET_TIME_absolute_hton(), key, PeerstoreRecordMessage::key_size, options, PeerstoreRecordMessage::options, PeerstoreRecordMessage::peer, PeerstoreRecordMessage::rid, PeerstoreRecordMessage::sub_system_size, value, and PeerstoreRecordMessage::value_size.

Referenced by GNUNET_PEERSTORE_store(), iterate_proc(), monitor_iterate_cb(), and watch_notifier().

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 PeerstoreRecordMessage srm)

Parses a message carrying a record.

Parameters
srmthe actual message
Returns
Pointer to record or NULL on error

Definition at line 106 of file peerstore_common.c.

107{
109 uint16_t req_size;
110 uint16_t ss_size;
111 uint16_t key_size;
112 uint16_t value_size;
113 char *dummy;
114
115 req_size = ntohs (srm->header.size) - sizeof(*srm);
116 ss_size = ntohs (srm->sub_system_size);
117 key_size = ntohs (srm->key_size);
118 value_size = ntohs (srm->value_size);
119 if (ss_size + key_size + value_size != req_size)
120 {
121 GNUNET_break (0);
122 return NULL;
123 }
125 record->peer = srm->peer;
126 record->expiry = GNUNET_TIME_absolute_ntoh (srm->expiry);
127 dummy = (char *) &srm[1];
128 if (ss_size > 0)
129 {
130 record->sub_system = GNUNET_strdup (dummy);
131 dummy += ss_size;
132 }
133 if (key_size > 0)
134 {
135 record->key = GNUNET_strdup (dummy);
136 dummy += key_size;
137 }
138 if (value_size > 0)
139 {
141 GNUNET_memcpy (record->value,
142 dummy,
143 value_size);
144 }
145 record->value_size = value_size;
146 return record;
147}
static void record(void *cls, size_t data_size, const void *data)
Process recorded audio data.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
#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:741
Single PEERSTORE record.
size_t value_size
Size of value BLOB.
struct GNUNET_MessageHeader header
GNUnet message header.
Definition: peerstore.h:42

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

Referenced by check_store(), handle_iterate_result(), handle_result(), and handle_store().

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 156 of file peerstore_common.c.

157{
158 if (NULL != record->sub_system)
159 GNUNET_free (record->sub_system);
160 if (NULL != record->key)
161 GNUNET_free (record->key);
162 if (NULL != record->value)
163 {
164 GNUNET_free (record->value);
165 record->value = 0;
166 }
168}

References GNUNET_free, and record().

Referenced by check_store(), handle_iterate_result(), handle_result(), handle_store(), and store_record_continuation().

Here is the call graph for this function:
Here is the caller graph for this function: