GNUnet 0.21.1
gnunet-service-messenger_peer_store.h File Reference
#include "gnunet_util_lib.h"
Include dependency graph for gnunet-service-messenger_peer_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_PeerStore
 

Functions

void init_peer_store (struct GNUNET_MESSENGER_PeerStore *store, struct GNUNET_MESSENGER_Service *service)
 Initializes a peer store as fully empty. More...
 
void clear_peer_store (struct GNUNET_MESSENGER_PeerStore *store)
 Clears a peer store, wipes its content and deallocates its memory. More...
 
void load_peer_store (struct GNUNET_MESSENGER_PeerStore *store, const char *path)
 Loads peer identities from a file into a peer store. More...
 
void save_peer_store (const struct GNUNET_MESSENGER_PeerStore *store, const char *path)
 Saves peer identities from a peer store into a file. More...
 
struct GNUNET_PeerIdentityget_store_peer_of (struct GNUNET_MESSENGER_PeerStore *store, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
 Returns the peer identity inside the store which verifies the signature of a given message as valid. More...
 
void update_store_peer (struct GNUNET_MESSENGER_PeerStore *store, const struct GNUNET_PeerIdentity *peer, enum GNUNET_GenericReturnValue active)
 Adds a peer identity to the store if necessary. More...
 

Function Documentation

◆ init_peer_store()

void init_peer_store ( struct GNUNET_MESSENGER_PeerStore store,
struct GNUNET_MESSENGER_Service service 
)

Initializes a peer store as fully empty.

Parameters
[out]storePeer store
[in,out]serviceMessenger service

Definition at line 40 of file gnunet-service-messenger_peer_store.c.

42{
43 GNUNET_assert ((store) && (service));
44
45 store->service = service;
47}
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
struct GNUNET_CONTAINER_MultiShortmap * GNUNET_CONTAINER_multishortmap_create(unsigned int len, int do_not_copy_keys)
Create a multi peer map (hash map for public keys of peers).
@ GNUNET_NO
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_MESSENGER_Service * service
struct GNUNET_CONTAINER_MultiShortmap * peers

References GNUNET_assert, GNUNET_CONTAINER_multishortmap_create(), GNUNET_NO, GNUNET_MESSENGER_PeerStore::peers, service, and GNUNET_MESSENGER_PeerStore::service.

Referenced by create_srv_room().

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

◆ clear_peer_store()

void clear_peer_store ( struct GNUNET_MESSENGER_PeerStore store)

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

Parameters
[in,out]storePeer store

Definition at line 61 of file gnunet-service-messenger_peer_store.c.

62{
63 GNUNET_assert ((store) && (store->peers));
64
65 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Clear peer store\n");
66
68 NULL);
70
71 store->peers = NULL;
72}
static enum GNUNET_GenericReturnValue iterate_destroy_peers(void *cls, const struct GNUNET_ShortHashCode *id, void *value)
int GNUNET_CONTAINER_multishortmap_iterate(struct GNUNET_CONTAINER_MultiShortmap *map, GNUNET_CONTAINER_ShortmapIterator it, void *it_cls)
Iterate over all entries in the map.
void GNUNET_CONTAINER_multishortmap_destroy(struct GNUNET_CONTAINER_MultiShortmap *map)
Destroy a hash map.
#define GNUNET_log(kind,...)
@ GNUNET_ERROR_TYPE_DEBUG

References GNUNET_assert, GNUNET_CONTAINER_multishortmap_destroy(), GNUNET_CONTAINER_multishortmap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, iterate_destroy_peers(), and GNUNET_MESSENGER_PeerStore::peers.

Referenced by destroy_srv_room().

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

◆ load_peer_store()

void load_peer_store ( struct GNUNET_MESSENGER_PeerStore store,
const char *  path 
)

Loads peer identities from a file into a peer store.

Parameters
[out]storePeer store
[in]pathPath to a file

Definition at line 76 of file gnunet-service-messenger_peer_store.c.

78{
79 GNUNET_assert ((store) && (path));
80
82 return;
83
84 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Load peer store from path: %s\n",
85 path);
86
89 );
90
92 path, GNUNET_DISK_OPEN_READ, permission
93 );
94
95 if (! handle)
96 return;
97
99
102 struct GNUNET_PeerIdentity peer;
103 ssize_t len;
104
105 do {
106 len = GNUNET_DISK_file_read (handle, &peer, sizeof(peer));
107
108 if (len != sizeof(peer))
109 break;
110
111
113
114 if (! entry)
115 continue;
116
117 GNUNET_memcpy (&(entry->peer), &peer, sizeof(entry->peer));
118 entry->active = GNUNET_YES;
119
121
123 store->peers, &peer_id, entry,
125 continue;
126
127 GNUNET_free (entry);
128 } while (len == sizeof(peer));
129
131}
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
static struct GNUNET_VPN_Handle * handle
Handle to vpn service.
Definition: gnunet-vpn.c:35
struct GNUNET_DISK_FileHandle * GNUNET_DISK_file_open(const char *fn, enum GNUNET_DISK_OpenFlags flags, enum GNUNET_DISK_AccessPermissions perm)
Open a file.
Definition: disk.c:1237
enum GNUNET_GenericReturnValue GNUNET_DISK_file_test(const char *fil)
Check that fil corresponds to a filename (of a file that exists and that is not a directory).
Definition: disk.c:482
off_t GNUNET_DISK_file_seek(const struct GNUNET_DISK_FileHandle *h, off_t offset, enum GNUNET_DISK_Seek whence)
Move the read/write pointer in a file.
Definition: disk.c:205
GNUNET_DISK_AccessPermissions
File access permissions, UNIX-style.
enum GNUNET_GenericReturnValue GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1308
ssize_t GNUNET_DISK_file_read(const struct GNUNET_DISK_FileHandle *h, void *result, size_t len)
Read the contents of a binary file into a buffer.
Definition: disk.c:622
@ GNUNET_DISK_OPEN_READ
Open the file for reading.
@ GNUNET_DISK_PERM_USER_READ
Owner can read.
@ GNUNET_DISK_PERM_USER_WRITE
Owner can write.
@ GNUNET_DISK_SEEK_SET
Seek an absolute position (from the start of the file).
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multishortmap_put(struct GNUNET_CONTAINER_MultiShortmap *map, const struct GNUNET_ShortHashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE
Allow multiple values with the same key.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_OK
@ GNUNET_YES
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
void convert_peer_identity_to_id(const struct GNUNET_PeerIdentity *identity, struct GNUNET_ShortHashCode *id)
Converts a peers identity to a short hash code which can be used as id to refer to a peer via sender ...
Handle used to access files (and pipes).
The identity of the host (wraps the signing key of the peer).
A 256-bit hashcode.

References GNUNET_MESSENGER_PeerStoreEntry::active, convert_peer_identity_to_id(), GNUNET_assert, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multishortmap_put(), GNUNET_DISK_file_close(), GNUNET_DISK_file_open(), GNUNET_DISK_file_read(), GNUNET_DISK_file_seek(), GNUNET_DISK_file_test(), GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_DISK_SEEK_SET, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_memcpy, GNUNET_new, GNUNET_OK, GNUNET_YES, handle, GNUNET_MESSENGER_PeerStoreEntry::peer, peer_id, and GNUNET_MESSENGER_PeerStore::peers.

Referenced by load_srv_room().

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

◆ save_peer_store()

void save_peer_store ( const struct GNUNET_MESSENGER_PeerStore store,
const char *  path 
)

Saves peer identities from a peer store into a file.

Parameters
[in]storePeer store
[in]pathPath to a file

Definition at line 153 of file gnunet-service-messenger_peer_store.c.

155{
156 GNUNET_assert ((store) && (path));
157
158 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Save peer store to path: %s\n",
159 path);
160
163 );
164
167 );
168
169 if (! handle)
170 return;
171
174 handle);
175
178}
static enum GNUNET_GenericReturnValue iterate_save_peers(void *cls, const struct GNUNET_ShortHashCode *id, void *value)
enum GNUNET_GenericReturnValue GNUNET_DISK_file_sync(const struct GNUNET_DISK_FileHandle *h)
Write file changes to disk.
Definition: disk.c:1427
@ GNUNET_DISK_OPEN_WRITE
Open the file for writing.
@ GNUNET_DISK_OPEN_CREATE
Create file if it doesn't exist.

References GNUNET_assert, GNUNET_CONTAINER_multishortmap_iterate(), GNUNET_DISK_file_close(), GNUNET_DISK_file_open(), GNUNET_DISK_file_seek(), GNUNET_DISK_file_sync(), GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_OPEN_WRITE, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_DISK_SEEK_SET, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, handle, iterate_save_peers(), and GNUNET_MESSENGER_PeerStore::peers.

Referenced by save_srv_room().

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

◆ get_store_peer_of()

struct GNUNET_PeerIdentity * get_store_peer_of ( struct GNUNET_MESSENGER_PeerStore store,
const struct GNUNET_MESSENGER_Message message,
const struct GNUNET_HashCode hash 
)

Returns the peer identity inside the store which verifies the signature of a given message as valid.

The specific peer identity has to be added to the store previously. Otherwise the function returns NULL.

Parameters
[in,out]storePeer store
[in]messageMessage
[in]hashHash of message
Returns
Peer identity or NULL

Definition at line 251 of file gnunet-service-messenger_peer_store.c.

254{
255 GNUNET_assert ((store) && (store->peers) && (message) && (hash));
256
257 if (GNUNET_YES != is_peer_message (message))
258 return NULL;
259
261 verify.message = message;
262 verify.hash = hash;
263 verify.sender = NULL;
264
268
269 if (verify.sender)
270 return verify.sender;
271
272 const struct GNUNET_PeerIdentity *peer;
273 enum GNUNET_GenericReturnValue active;
274
275 if (GNUNET_MESSENGER_KIND_PEER == message->header.kind)
276 {
277 peer = &(message->body.peer.peer);
278 active = GNUNET_YES;
279 }
280 else if (GNUNET_MESSENGER_KIND_MISS == message->header.kind)
281 {
282 peer = &(message->body.miss.peer);
283 active = GNUNET_NO;
284 }
285 else
286 {
288 "Peer message does not contain a peer identity\n");
289
290 peer = get_store_service_peer_identity (store);
291 active = GNUNET_NO;
292
293 if (! peer)
294 return NULL;
295 }
296
299
300 if (0 != GNUNET_memcmp (&peer_id, &(message->header.sender_id)))
301 {
303 "Sender id does not match peer identity\n");
304 return NULL;
305 }
306
307 if (GNUNET_OK != verify_message_by_peer (message, hash, peer))
308 {
310 "Verification of message with peer identity failed!\n");
311 }
312
314 entry = add_peer_store_entry (store, peer, &peer_id, active);
315
316 if (! entry)
317 {
319 "Initialization of entry in peer store failed: %s\n",
321
322 return NULL;
323 }
324
325 return &(entry->peer);
326}
static int verify
Verify mode.
Definition: gnunet-abd.c:127
static const struct GNUNET_PeerIdentity * get_store_service_peer_identity(struct GNUNET_MESSENGER_PeerStore *store)
static struct GNUNET_MESSENGER_PeerStoreEntry * add_peer_store_entry(struct GNUNET_MESSENGER_PeerStore *store, const struct GNUNET_PeerIdentity *peer, const struct GNUNET_ShortHashCode *id, enum GNUNET_GenericReturnValue active)
static enum GNUNET_GenericReturnValue verify_store_peer(void *cls, const struct GNUNET_ShortHashCode *id, void *value)
int GNUNET_CONTAINER_multishortmap_get_multiple(struct GNUNET_CONTAINER_MultiShortmap *map, const struct GNUNET_ShortHashCode *key, GNUNET_CONTAINER_ShortmapIterator it, void *it_cls)
Iterate over all entries in the map that match a particular key.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
GNUNET_GenericReturnValue
Named constants for return values.
const char * GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_MESSENGER_KIND_MISS
The miss kind.
@ GNUNET_MESSENGER_KIND_PEER
The peer kind.
enum GNUNET_GenericReturnValue is_peer_message(const struct GNUNET_MESSENGER_Message *message)
Returns whether a specific kind of message can be sent by the service without usage of a clients priv...
enum GNUNET_GenericReturnValue verify_message_by_peer(const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash, const struct GNUNET_PeerIdentity *identity)
Verifies the signature of a given message and its hash with a specific peer's identity.
const struct GNUNET_MESSENGER_Message * message
struct GNUNET_MESSENGER_MessageMiss miss
struct GNUNET_MESSENGER_MessagePeer peer
enum GNUNET_MESSENGER_MessageKind kind
The kind of the message.
struct GNUNET_ShortHashCode sender_id
The senders id inside of the room the message was sent in.
struct GNUNET_PeerIdentity peer
The peer identity of a disconnected door to a room.
struct GNUNET_PeerIdentity peer
The peer identity of the sender opening a room.
struct GNUNET_MESSENGER_MessageHeader header
Header.
struct GNUNET_MESSENGER_MessageBody body
Body.

References GNUNET_MESSENGER_PeerStoreEntry::active, add_peer_store_entry(), GNUNET_MESSENGER_Message::body, convert_peer_identity_to_id(), get_store_service_peer_identity(), GNUNET_assert, GNUNET_CONTAINER_multishortmap_get_multiple(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_memcmp, GNUNET_MESSENGER_KIND_MISS, GNUNET_MESSENGER_KIND_PEER, GNUNET_NO, GNUNET_OK, GNUNET_sh2s(), GNUNET_YES, GNUNET_MESSENGER_ClosureVerifyPeer::hash, GNUNET_MESSENGER_Message::header, is_peer_message(), GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_ClosureVerifyPeer::message, GNUNET_MESSENGER_MessageBody::miss, GNUNET_MESSENGER_MessagePeer::peer, GNUNET_MESSENGER_MessageMiss::peer, GNUNET_MESSENGER_MessageBody::peer, GNUNET_MESSENGER_PeerStoreEntry::peer, peer_id, GNUNET_MESSENGER_PeerStore::peers, GNUNET_MESSENGER_MessageHeader::sender_id, verify, verify_message_by_peer(), and verify_store_peer().

Referenced by callback_found_message(), callback_room_handle_message(), and handle_room_messages().

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

◆ update_store_peer()

void update_store_peer ( struct GNUNET_MESSENGER_PeerStore store,
const struct GNUNET_PeerIdentity peer,
enum GNUNET_GenericReturnValue  active 
)

Adds a peer identity to the store if necessary.

It ensures that the given peer can be verified as sender of a message afterwards by the store.

Parameters
[in,out]storePeer store
[in]peerPeer identity
[in]activeWhether the peer is active or not

Definition at line 355 of file gnunet-service-messenger_peer_store.c.

358{
359 GNUNET_assert ((store) && (store->peers) && (peer));
360
363
364 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Update peer store entry: %s\n",
366
368 find.requested = peer;
369 find.match = NULL;
370
372 find_store_peer, &find);
373
374 if (find.match)
375 {
376 find.match->active = active;
377 return;
378 }
379
380 if (! add_peer_store_entry (store, peer, &peer_id, active))
382 "Initial update of entry in peer store failed: %s\n",
384}
static enum GNUNET_GenericReturnValue find_store_peer(void *cls, const struct GNUNET_ShortHashCode *id, void *value)
const struct GNUNET_PeerIdentity * requested

References GNUNET_MESSENGER_PeerStoreEntry::active, add_peer_store_entry(), convert_peer_identity_to_id(), find_store_peer(), GNUNET_assert, GNUNET_CONTAINER_multishortmap_get_multiple(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_sh2s(), GNUNET_MESSENGER_ClosureFindPeer::match, GNUNET_MESSENGER_PeerStoreEntry::peer, peer_id, GNUNET_MESSENGER_PeerStore::peers, and GNUNET_MESSENGER_ClosureFindPeer::requested.

Referenced by handle_message_miss(), and handle_message_peer().

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