GNUnet  0.11.x
peerstore_common.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet
3  Copyright (C) 2012-2013 GNUnet e.V.
4 
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your option) any later version.
9 
10  GNUnet is distributed in the hope that it will be useful, but
11  WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  Affero General Public License for more details.
14 
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
26 #include "peerstore_common.h"
27 
32 void
33 PEERSTORE_hash_key (const char *sub_system,
34  const struct GNUNET_PeerIdentity *peer,
35  const char *key,
36  struct GNUNET_HashCode *ret)
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 }
59 
60 
74 struct GNUNET_MQ_Envelope *
75 PEERSTORE_create_record_mq_envelope (const char *sub_system,
76  const struct GNUNET_PeerIdentity *peer,
77  const char *key,
78  const void *value,
79  size_t value_size,
80  struct GNUNET_TIME_Absolute expiry,
82  uint16_t msg_type)
83 {
84  struct StoreRecordMessage *srm;
85  struct GNUNET_MQ_Envelope *ev;
86  size_t ss_size;
87  size_t key_size;
88  size_t msg_size;
89  void *dummy;
90 
91  GNUNET_assert (NULL != sub_system);
92  ss_size = strlen (sub_system) + 1;
93  if (NULL == key)
94  key_size = 0;
95  else
96  key_size = strlen (key) + 1;
97  msg_size = ss_size + key_size + value_size;
98  ev = GNUNET_MQ_msg_extra (srm, msg_size, msg_type);
99  srm->key_size = htons (key_size);
100  srm->expiry = GNUNET_TIME_absolute_hton (expiry);
101  if (NULL == peer)
102  srm->peer_set = htons (GNUNET_NO);
103  else
104  {
105  srm->peer_set = htons (GNUNET_YES);
106  srm->peer = *peer;
107  }
108  srm->sub_system_size = htons (ss_size);
109  srm->value_size = htons (value_size);
110  srm->options = htonl (options);
111  dummy = &srm[1];
112  GNUNET_memcpy (dummy, sub_system, ss_size);
113  dummy += ss_size;
114  GNUNET_memcpy (dummy, key, key_size);
115  dummy += key_size;
116  GNUNET_memcpy (dummy, value, value_size);
117  return ev;
118 }
119 
120 
129 {
131  uint16_t req_size;
132  uint16_t ss_size;
133  uint16_t key_size;
134  uint16_t value_size;
135  char *dummy;
136 
137  req_size = ntohs (srm->header.size) - sizeof(*srm);
138  ss_size = ntohs (srm->sub_system_size);
139  key_size = ntohs (srm->key_size);
140  value_size = ntohs (srm->value_size);
141  if (ss_size + key_size + value_size != req_size)
142  {
143  GNUNET_break (0);
144  return NULL;
145  }
146  record = GNUNET_new (struct GNUNET_PEERSTORE_Record);
147  if (GNUNET_YES == ntohs (srm->peer_set))
148  {
149  record->peer = srm->peer;
150  }
151  record->expiry = GNUNET_TIME_absolute_ntoh (srm->expiry);
152  dummy = (char *) &srm[1];
153  if (ss_size > 0)
154  {
155  record->sub_system = GNUNET_strdup (dummy);
156  dummy += ss_size;
157  }
158  if (key_size > 0)
159  {
160  record->key = GNUNET_strdup (dummy);
161  dummy += key_size;
162  }
163  if (value_size > 0)
164  {
165  record->value = GNUNET_malloc (value_size);
166  GNUNET_memcpy (record->value,
167  dummy,
168  value_size);
169  }
170  record->value_size = value_size;
171  return record;
172 }
173 
174 
180 void
182 {
183  if (NULL != record->sub_system)
184  GNUNET_free (record->sub_system);
185  if (NULL != record->key)
186  GNUNET_free (record->key);
187  if (NULL != record->value)
188  {
189  GNUNET_free (record->value);
190  record->value = 0;
191  }
192  GNUNET_free (record);
193 }
struct GNUNET_MessageHeader header
GNUnet message header.
Definition: peerstore.h:41
uint16_t sub_system_size
Size of the sub_system string Allocated at position 0 after this struct.
Definition: peerstore.h:52
Helper peerstore functions.
struct GNUNET_PEERSTORE_Record * PEERSTORE_parse_record_message(const struct StoreRecordMessage *srm)
Parses a message carrying a record.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:673
struct GNUNET_PeerIdentity peer
Peer Identity.
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
void PEERSTORE_destroy_record(struct GNUNET_PEERSTORE_Record *record)
Free any memory allocated for this record.
size_t value_size
Size of value BLOB.
struct GNUNET_PeerIdentity peer
Peer Identity.
Definition: peerstore.h:57
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
uint16_t value_size
Size of value blob Allocated at position 2 after this struct.
Definition: peerstore.h:74
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_new(type)
Allocate a struct or union of the given type.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
char * key
Record key string.
#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:52
void * value
Record value BLOB.
static char * value
Value of the record to add/remove.
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:48
uint16_t peer_set
GNUNET_YES if peer id value set, GNUNET_NO otherwise
Definition: peerstore.h:46
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
GNUNET_PEERSTORE_StoreOption
Options for storing values in PEERSTORE.
A 512-bit hashcode.
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.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
struct GNUNET_HashCode key
The key used in the DHT.
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.
uint32_t options
Options, needed only in case of a store operation.
Definition: peerstore.h:80
static struct in_addr dummy
Target "dummy" address of the packet we pretend to respond to.
The identity of the host (wraps the signing key of the peer).
struct GNUNET_TIME_Absolute expiry
Expiry time of entry.
char * sub_system
Responsible sub system string.
Single PEERSTORE record.
static void record(void *cls, size_t data_size, const void *data)
Process recorded audio data.
Message carrying a PEERSTORE record message.
Definition: peerstore.h:36
Time for absolute times used by GNUnet, in microseconds.
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:657
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.