GNUnet  0.19.2
gnunet-service-messenger_member_session.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2021--2022 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 "platform.h"
28 
31 
33 
36  const struct GNUNET_IDENTITY_PublicKey *pubkey)
37 {
38  if ((!member) || (!pubkey) || (!(member->store)))
39  return NULL;
40 
42  session->member = member;
43 
44  GNUNET_memcpy(&(session->public_key), pubkey, sizeof(session->public_key));
45 
47  get_member_session_key (session),
48  get_member_session_id (session),
49  &(session->context)
50  );
51 
53 
54  session->contact = get_store_contact(
55  store,
58  );
59 
60  if (!(session->contact))
61  {
62  GNUNET_free(session);
63  return NULL;
64  }
65 
66  increase_contact_rc (session->contact);
67 
69 
70  init_list_messages(&(session->messages));
71 
72  session->prev = NULL;
73  session->next = NULL;
74 
75  session->start = GNUNET_TIME_absolute_get();
76 
77  session->closed = GNUNET_NO;
78  session->completed = GNUNET_NO;
79 
80  return session;
81 }
82 
83 static void
85 {
86  GNUNET_assert (session);
87 
88  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Check session history (%s) for completion.\n",
90 
91  if (!session->messages.tail)
92  {
93  session->completed = GNUNET_YES;
94  goto completion;
95  }
96 
97  const struct GNUNET_HashCode* start = &(session->messages.head->hash);
98  const struct GNUNET_HashCode* end = &(session->messages.tail->hash);
99 
100  struct GNUNET_MESSENGER_ListMessages level;
101  init_list_messages(&level);
102 
103  add_to_list_messages(&level, end);
104 
106 
109 
110  while (level.head)
111  {
112  struct GNUNET_MESSENGER_ListMessage *element;
113 
114  for (element = level.head; element; element = element->next)
115  {
117  store, &(element->hash), GNUNET_NO
118  );
119 
120  if (!link)
121  continue;
122 
123  add_to_list_messages(&list, &(link->first));
124 
125  if (GNUNET_YES == link->multiple)
126  add_to_list_messages(&list, &(link->second));
127  }
128 
129  clear_list_messages(&level);
130 
131  for (element = list.head; element; element = element->next)
132  if (GNUNET_YES == check_member_session_history(session, &(element->hash), GNUNET_YES))
133  break;
134 
135  if (element)
136  if (0 != GNUNET_CRYPTO_hash_cmp(&(element->hash), start))
137  add_to_list_messages(&level, &(element->hash));
138  else
139  session->completed = GNUNET_YES;
140  else
141  copy_list_messages(&level, &list);
142 
144  }
145 
146 completion:
147  if (GNUNET_YES == is_member_session_completed(session))
148  {
149  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Completed session history (%s)\n",
151 
153 
155 
156  if ((session->contact) && (GNUNET_YES == decrease_contact_rc (session->contact)))
158  store,
159  session->contact,
161  );
162 
163  session->contact = NULL;
164  }
165 }
166 
167 static int
169  const struct GNUNET_HashCode *key,
170  void *value)
171 {
172  struct GNUNET_MESSENGER_MemberSession *next = cls;
173 
176 
177  return GNUNET_YES;
178 }
179 
182  const struct GNUNET_MESSENGER_Message *message,
183  const struct GNUNET_HashCode *hash)
184 {
185  if ((!session) || (!message) || (!hash))
186  return NULL;
187 
189  (GNUNET_MESSENGER_KIND_KEY == message->header.kind));
190 
192 
193  if (GNUNET_MESSENGER_KIND_ID == message->header.kind)
194  next->member = add_store_member(session->member->store, &(message->body.id.id));
195  else
196  next->member = session->member;
197 
198  if (GNUNET_MESSENGER_KIND_KEY == message->header.kind)
199  GNUNET_memcpy(&(next->public_key), &(message->body.key.key), sizeof(next->public_key));
200  else
202 
206  &(next->context)
207  );
208 
215  );
216 
218 
219  if (!(next->contact))
220  {
221  GNUNET_free(next);
222  return NULL;
223  }
224 
226 
229  );
230 
232 
234  copy_list_messages(&(next->messages), &(session->messages));
235 
236  session->next = next;
237  next->prev = session;
238  next->next = NULL;
239 
241 
242  session->closed = GNUNET_YES;
243  next->closed = GNUNET_NO;
245 
247 
248  return next;
249 }
250 
251 void
253 {
254  GNUNET_assert (session);
255 
257 
258  clear_list_messages (&(session->messages));
259 
260  struct GNUNET_MESSENGER_Contact *contact = get_member_session_contact (session);
261 
262  if ((contact) && (GNUNET_YES == decrease_contact_rc (contact)))
265  contact,
267  );
268 
269  GNUNET_free(session);
270 }
271 
272 int
274  const struct GNUNET_HashCode *hash)
275 {
276  GNUNET_assert ((session) && (hash));
277 
280  store,
281  get_member_session_context (session),
283  );
284 
285  if (!contact)
286  return GNUNET_SYSERR;
287 
288  if (contact == session->contact)
289  goto clear_messages;
290 
291  session->contact = contact;
292  increase_contact_rc (session->contact);
293 
294 clear_messages:
295  clear_list_messages(&(session->messages));
296  add_to_list_messages(&(session->messages), hash);
297 
298  session->next = NULL;
299  session->closed = GNUNET_NO;
300  session->completed = GNUNET_NO;
301 
302  return GNUNET_OK;
303 }
304 
305 void
307 {
308  GNUNET_assert (session);
309 
310  session->closed = GNUNET_YES;
312 }
313 
314 int
316 {
317  GNUNET_assert(session);
318 
319  return session->closed;
320 }
321 
322 int
324 {
325  GNUNET_assert(session);
326 
327  return session->completed;
328 }
329 
332 {
333  GNUNET_assert(session);
334 
335  if (session->prev)
336  return get_member_session_start(session->prev);
337 
338  return session->start;
339 }
340 
341 const struct GNUNET_HashCode*
343 {
344  GNUNET_assert((session) && (session->member));
345 
346  return get_member_store_key(session->member->store);
347 }
348 
349 const struct GNUNET_ShortHashCode*
351 {
352  GNUNET_assert(session);
353 
354  return get_member_id(session->member);
355 }
356 
357 const struct GNUNET_IDENTITY_PublicKey*
359 {
360  GNUNET_assert(session);
361 
362  return &(session->public_key);
363 }
364 
365 const struct GNUNET_HashCode*
367 {
368  GNUNET_assert(session);
369 
370  return &(session->context);
371 }
372 
375 {
376  GNUNET_assert (session);
377 
378  return session->contact;
379 }
380 
382  const struct GNUNET_MESSENGER_Message *message,
383  const struct GNUNET_HashCode *hash)
384 {
385  GNUNET_assert((session) && (message) && (hash));
386 
387  if (GNUNET_YES == is_member_session_completed(session))
388  return GNUNET_SYSERR;
389 
390  if (0 != GNUNET_memcmp(get_member_session_id(session), &(message->header.sender_id)))
391  return GNUNET_SYSERR;
392 
393  return verify_message(message, hash, get_member_session_public_key(session));
394 }
395 
396 int
398  const struct GNUNET_HashCode *hash, int ownership)
399 {
400  GNUNET_assert((session) && (hash));
401 
402  if (GNUNET_YES == ownership)
403  return (NULL != GNUNET_CONTAINER_multihashmap_get(session->history, hash)? GNUNET_YES : GNUNET_NO);
404  else
405  return GNUNET_CONTAINER_multihashmap_contains(session->history, hash);
406 }
407 
408 static void
410  const struct GNUNET_HashCode *hash, int ownership)
411 {
412  GNUNET_assert ((session) && (hash));
413 
414  if ((GNUNET_OK == GNUNET_CONTAINER_multihashmap_put(session->history, hash, (GNUNET_YES == ownership? session : NULL),
416  update_member_chain_history (session->next, hash, ownership);
417 }
418 
419 void
421  const struct GNUNET_MESSENGER_Message *message,
422  const struct GNUNET_HashCode *hash)
423 {
424  GNUNET_assert((session) && (message) && (hash));
425 
426  if (GNUNET_YES == is_member_session_completed(session))
427  return;
428 
429  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Updating sessions history (%s) += (%s)\n",
430  GNUNET_sh2s(get_member_session_id(session)), GNUNET_h2s(hash));
431 
432  if (GNUNET_OK == verify_member_session_as_sender (session, message, hash))
433  {
434  if (GNUNET_YES == is_message_session_bound (message))
435  add_to_list_messages(&(session->messages), hash);
436 
437  update_member_chain_history (session, hash, GNUNET_YES);
438  }
439  else
440  update_member_chain_history (session, hash, GNUNET_NO);
441 
442  if (GNUNET_YES == session->closed)
444 }
445 
446 static void
448  const struct GNUNET_HashCode *hash)
449 {
450  GNUNET_assert ((session) && (hash));
451 
452  if ((0 < GNUNET_CONTAINER_multihashmap_remove_all(session->history, hash)) && (session->next))
453  clear_member_session_history(session->next, hash);
454 }
455 
456 void
458  const struct GNUNET_HashCode *hash)
459 {
460  GNUNET_assert((session) && (hash));
461 
462  clear_member_chain_history (session, hash);
463 }
464 
466 {
467  struct GNUNET_HashCode hash;
468  unsigned char ownership;
469 };
470 
471 static void
473  const char *path)
474 {
475  GNUNET_assert((session) && (path));
476 
477  if (GNUNET_YES != GNUNET_DISK_file_test (path))
478  return;
479 
481 
483  path, GNUNET_DISK_OPEN_READ, permission
484  );
485 
486  if (!handle)
487  return;
488 
490 
492  ssize_t len;
493 
494  int status;
495 
496  do {
497  len = GNUNET_DISK_file_read(handle, &(entry.hash), sizeof(entry.hash));
498 
499  if (len != sizeof(entry.hash))
500  break;
501 
502  len = GNUNET_DISK_file_read(handle, &(entry.ownership), sizeof(entry.ownership));
503 
504  if (len != sizeof(entry.ownership))
505  break;
506 
507  status = GNUNET_CONTAINER_multihashmap_put(session->history, &(entry.hash), (entry.ownership? session : NULL),
509  } while (status == GNUNET_OK);
510 
512 }
513 
514 void
516  const char *directory)
517 {
518  GNUNET_assert ((member) && (directory));
519 
520  char *config_file;
521  GNUNET_asprintf (&config_file, "%s%s", directory, "session.cfg");
522 
523  struct GNUNET_MESSENGER_MemberSession *session = NULL;
524 
526  goto free_config;
527 
528  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Load session configuration of member: %s\n", config_file);
529 
531 
533  {
534  char *key_data;
535 
536  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, "session", "key", &key_data))
537  goto destroy_config;
538 
540 
542 
543  GNUNET_free(key_data);
544 
545  if (GNUNET_OK != key_return)
546  goto destroy_config;
547 
548  session = create_member_session(member, &key);
549 
550  unsigned long long numeric_value;
551 
552  if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, "session", "start", &numeric_value))
553  session->start.abs_value_us = numeric_value;
554 
555  if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, "session", "closed", &numeric_value))
556  session->closed = (GNUNET_YES == numeric_value? GNUNET_YES : GNUNET_NO);
557 
558  if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, "session", "completed", &numeric_value))
559  session->completed = (GNUNET_YES == numeric_value? GNUNET_YES : GNUNET_NO);
560  }
561 
562 destroy_config:
564 
565 free_config:
567 
568  if (!session)
569  return;
570 
571  char *history_file;
572  GNUNET_asprintf (&history_file, "%s%s", directory, "history.map");
573 
574  load_member_session_history (session, history_file);
575  GNUNET_free(history_file);
576 
577  char *messages_file;
578  GNUNET_asprintf (&messages_file, "%s%s", directory, "messages.list");
579 
580  load_list_messages(&(session->messages), messages_file);
581  GNUNET_free(messages_file);
582 
583  add_member_session(member, session);
584 }
585 
586 static struct GNUNET_MESSENGER_MemberSession*
589 {
590  if (!next)
591  return NULL;
592 
593  struct GNUNET_MESSENGER_MemberSession *check = next;
594 
595  do {
596  if (check == session)
597  return NULL;
598 
599  check = check->next;
600  } while (check);
601 
602  return next;
603 }
604 
605 void
607  const char *directory)
608 {
609  GNUNET_assert ((session) && (directory));
610 
611  char *config_file;
612  GNUNET_asprintf (&config_file, "%s%s", directory, "session.cfg");
613 
615  goto free_config;
616 
617  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Load next session configuration of member: %s\n", config_file);
618 
620 
622  {
623  char *key_data;
624 
625  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, "session", "next_key", &key_data))
626  goto destroy_config;
627 
628  struct GNUNET_IDENTITY_PublicKey next_key;
629 
630  enum GNUNET_GenericReturnValue key_return = GNUNET_IDENTITY_public_key_from_string(key_data, &next_key);
631 
632  GNUNET_free(key_data);
633 
634  if (GNUNET_OK != key_return)
635  goto destroy_config;
636 
638 
639  if (GNUNET_OK != GNUNET_CONFIGURATION_get_data (cfg, "session", "next_id", &next_id, sizeof(next_id)))
640  goto destroy_config;
641 
642  struct GNUNET_MESSENGER_Member *member = get_store_member(session->member->store, &next_id);
643 
645  session, member? get_member_session (member, &next_key) : NULL
646  );
647 
648  if (session->next)
649  session->next->prev = session;
650  }
651 
652 destroy_config:
654 
655 free_config:
657 }
658 
659 static int
661  const struct GNUNET_HashCode *key,
662  void *value)
663 {
664  struct GNUNET_DISK_FileHandle *handle = cls;
665  unsigned char ownership = value? GNUNET_YES : GNUNET_NO;
666 
667  GNUNET_DISK_file_write(handle, key, sizeof(*key));
668  GNUNET_DISK_file_write(handle, &ownership, sizeof(ownership));
669 
670  return GNUNET_YES;
671 }
672 
673 static void
675  const char *path)
676 {
677  GNUNET_assert((session) && (path));
678 
680 
683  );
684 
685  if (!handle)
686  return;
687 
689 
691  session->history,
693  handle
694  );
695 
698 }
699 
700 void
702  const char *directory)
703 {
704  GNUNET_assert ((session) && (directory));
705 
706  char *config_file;
707  GNUNET_asprintf (&config_file, "%s%s", directory, "session.cfg");
708 
709  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Save session configuration of member: %s\n", config_file);
710 
712 
714 
715  if (key_data)
716  {
717  GNUNET_CONFIGURATION_set_value_string (cfg, "session", "key", key_data);
718 
719  GNUNET_free(key_data);
720  }
721 
722  if (session->next)
723  {
724  const struct GNUNET_ShortHashCode *next_id = get_member_session_id(session->next);
725 
726  char *next_id_data = GNUNET_STRINGS_data_to_string_alloc (next_id, sizeof(*next_id));
727 
728  if (next_id_data)
729  {
730  GNUNET_CONFIGURATION_set_value_string (cfg, "session", "next_id", next_id_data);
731 
732  GNUNET_free(next_id_data);
733  }
734 
736 
737  if (key_data)
738  {
739  GNUNET_CONFIGURATION_set_value_string (cfg, "session", "next_key", key_data);
740 
741  GNUNET_free(key_data);
742  }
743  }
744 
745  GNUNET_CONFIGURATION_set_value_number(cfg, "session", "start", session->start.abs_value_us);
746 
747  GNUNET_CONFIGURATION_set_value_number (cfg, "session", "closed", session->closed);
748  GNUNET_CONFIGURATION_set_value_number (cfg, "session", "completed", session->completed);
749 
752 
754 
755  char *history_file;
756  GNUNET_asprintf (&history_file, "%s%s", directory, "history.map");
757 
758  save_member_session_history (session, history_file);
759  GNUNET_free(history_file);
760 
761  char *messages_file;
762  GNUNET_asprintf (&messages_file, "%s%s", directory, "messages.list");
763 
764  save_list_messages(&(session->messages), messages_file);
765  GNUNET_free(messages_file);
766 }
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static int start
Set if we are to start default services (including ARM).
Definition: gnunet-arm.c:39
static int list
Set if we should print a list of currently running services.
Definition: gnunet-arm.c:69
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:34
static char * config_file
Set to the name of the config file used.
Definition: gnunet-arm.c:84
struct GNUNET_HashCode key
The key used in the DHT.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
uint16_t status
See PRISM_STATUS_*-constants.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
static struct GNUNET_IDENTITY_PublicKey pubkey
Public key of the zone to look in.
static char * value
Value of the record to add/remove.
static char * next_id
Command-line option for namespace publishing: identifier for updates to this publication.
void clear_list_messages(struct GNUNET_MESSENGER_ListMessages *messages)
Clears the list of message hashes.
void load_list_messages(struct GNUNET_MESSENGER_ListMessages *messages, const char *path)
Loads the list of message hashes from a file under a given path.
void init_list_messages(struct GNUNET_MESSENGER_ListMessages *messages)
Initializes list of message hashes as empty list.
void copy_list_messages(struct GNUNET_MESSENGER_ListMessages *messages, const struct GNUNET_MESSENGER_ListMessages *origin)
Copies all message hashes from an origin to another list.
void save_list_messages(const struct GNUNET_MESSENGER_ListMessages *messages, const char *path)
Saves the list of message hashes to a file under a given path.
void add_to_list_messages(struct GNUNET_MESSENGER_ListMessages *messages, const struct GNUNET_HashCode *hash)
Adds a specific hash from a message to the end of the list.
struct GNUNET_MESSENGER_MemberSession * get_member_session(const struct GNUNET_MESSENGER_Member *member, const struct GNUNET_IDENTITY_PublicKey *public_key)
Returns the member session of a member identified by a given public key.
void add_member_session(struct GNUNET_MESSENGER_Member *member, struct GNUNET_MESSENGER_MemberSession *session)
Adds a given member session to its member.
const struct GNUNET_ShortHashCode * get_member_id(const struct GNUNET_MESSENGER_Member *member)
Returns the current id of a given member.
static int iterate_copy_history(void *cls, const struct GNUNET_HashCode *key, void *value)
static void update_member_chain_history(struct GNUNET_MESSENGER_MemberSession *session, const struct GNUNET_HashCode *hash, int ownership)
const struct GNUNET_HashCode * get_member_session_key(const struct GNUNET_MESSENGER_MemberSession *session)
Returns the key of the room a given member session belongs to.
const struct GNUNET_ShortHashCode * get_member_session_id(const struct GNUNET_MESSENGER_MemberSession *session)
Returns the member id of a given member session.
void clear_member_session_history(struct GNUNET_MESSENGER_MemberSession *session, const struct GNUNET_HashCode *hash)
Removes a message from the history of a session using the messages hash.
const struct GNUNET_HashCode * get_member_session_context(const struct GNUNET_MESSENGER_MemberSession *session)
Returns the member context of a given member session.
void destroy_member_session(struct GNUNET_MESSENGER_MemberSession *session)
Destroys a member session and frees its memory fully.
int check_member_session_history(const struct GNUNET_MESSENGER_MemberSession *session, const struct GNUNET_HashCode *hash, int ownership)
Checks the history of a session for a specific message which is identified by its hash and if the own...
int reset_member_session(struct GNUNET_MESSENGER_MemberSession *session, const struct GNUNET_HashCode *hash)
Resets a given member session which re-opens a member session for new usage.
static int iterate_save_member_session_history_hentries(void *cls, const struct GNUNET_HashCode *key, void *value)
static void clear_member_chain_history(struct GNUNET_MESSENGER_MemberSession *session, const struct GNUNET_HashCode *hash)
void load_member_session_next(struct GNUNET_MESSENGER_MemberSession *session, const char *directory)
Loads the connection from one session to another through the next attribute.
void close_member_session(struct GNUNET_MESSENGER_MemberSession *session)
Closes a given member session which opens the request for completion of the given member session.
struct GNUNET_TIME_Absolute get_member_session_start(const struct GNUNET_MESSENGER_MemberSession *session)
Returns the timestamp of the member session's start.
static void load_member_session_history(struct GNUNET_MESSENGER_MemberSession *session, const char *path)
void update_member_session_history(struct GNUNET_MESSENGER_MemberSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Adds a given message to the history of a session using the messages hash.
int is_member_session_completed(const struct GNUNET_MESSENGER_MemberSession *session)
Returns if the given member session has been completed.
const struct GNUNET_IDENTITY_PublicKey * get_member_session_public_key(const struct GNUNET_MESSENGER_MemberSession *session)
Returns the public key from an EGO of a given member session.
static void check_member_session_completion(struct GNUNET_MESSENGER_MemberSession *session)
int verify_member_session_as_sender(const struct GNUNET_MESSENGER_MemberSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Verifies a given member session as sender of a selected message and its hash.
struct GNUNET_MESSENGER_MemberSession * switch_member_session(struct GNUNET_MESSENGER_MemberSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Creates and allocates a new member session closing and replacing a given other session of the same me...
static struct GNUNET_MESSENGER_MemberSession * get_cycle_safe_next_session(struct GNUNET_MESSENGER_MemberSession *session, struct GNUNET_MESSENGER_MemberSession *next)
void load_member_session(struct GNUNET_MESSENGER_Member *member, const char *directory)
Loads data from a directory into a new allocated and created member session of a member if the requir...
struct GNUNET_MESSENGER_Contact * get_member_session_contact(struct GNUNET_MESSENGER_MemberSession *session)
Returns the contact which is connected to a given member session.
int is_member_session_closed(const struct GNUNET_MESSENGER_MemberSession *session)
Returns if the given member session has been closed.
void save_member_session(struct GNUNET_MESSENGER_MemberSession *session, const char *directory)
Saves data from a member session into a directory which can be load to restore the member session com...
static void save_member_session_history(struct GNUNET_MESSENGER_MemberSession *session, const char *path)
struct GNUNET_MESSENGER_MemberSession * create_member_session(struct GNUNET_MESSENGER_Member *member, const struct GNUNET_IDENTITY_PublicKey *pubkey)
Creates and allocates a new member session of a member with a given public key.
struct GNUNET_MESSENGER_Member * get_store_member(const struct GNUNET_MESSENGER_MemberStore *store, const struct GNUNET_ShortHashCode *id)
Returns the member in a store identified by a given id.
const struct GNUNET_HashCode * get_member_store_key(const struct GNUNET_MESSENGER_MemberStore *store)
Returns the shared secret you need to access a room of the store.
struct GNUNET_MESSENGER_ContactStore * get_member_contact_store(struct GNUNET_MESSENGER_MemberStore *store)
Returns the used contact store of a given member store.
struct GNUNET_MESSENGER_Member * add_store_member(struct GNUNET_MESSENGER_MemberStore *store, const struct GNUNET_ShortHashCode *id)
Adds a member to a store under a specific id and returns it on success.
const struct GNUNET_MESSENGER_MessageLink * get_store_message_link(struct GNUNET_MESSENGER_MessageStore *store, const struct GNUNET_HashCode *hash, int deleted_only)
Returns the message link from a message store matching a given hash.
struct GNUNET_MESSENGER_MessageStore * get_srv_room_message_store(struct GNUNET_MESSENGER_SrvRoom *room)
Returns the used message store of a given room.
GNUnet MESSENGER service.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_data(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, void *buf, size_t buf_size)
Get Crockford32-encoded fixed-size binary data from a configuration.
void GNUNET_CONFIGURATION_set_value_string(struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, const char *value)
Set a configuration value that should be a string.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_number(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *number)
Get a configuration value that should be a number.
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_create(void)
Create a new configuration object.
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be a string.
void GNUNET_CONFIGURATION_set_value_number(struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long number)
Set a configuration value that should be a number.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_parse(struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename)
Parse a configuration file, add all of the options in the file to the configuration environment.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_write(struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename)
Write configuration file.
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:1234
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:481
ssize_t GNUNET_DISK_file_write(const struct GNUNET_DISK_FileHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: disk.c:685
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_sync(const struct GNUNET_DISK_FileHandle *h)
Write file changes to disk.
Definition: disk.c:1424
enum GNUNET_GenericReturnValue GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1305
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:621
@ GNUNET_DISK_OPEN_READ
Open the file for reading.
@ GNUNET_DISK_OPEN_WRITE
Open the file for writing.
@ GNUNET_DISK_OPEN_CREATE
Create file if it doesn't exist.
@ 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).
int GNUNET_CRYPTO_hash_cmp(const struct GNUNET_HashCode *h1, const struct GNUNET_HashCode *h2)
Compare function for HashCodes, producing a total ordering of all hashcodes.
Definition: crypto_hash.c:220
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_contains(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Check if the map contains any value under the given key (including values that are NULL).
int GNUNET_CONTAINER_multihashmap_remove_all(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Remove all entries for the given key from the map.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
unsigned int GNUNET_CONTAINER_multihashmap_clear(struct GNUNET_CONTAINER_MultiHashMap *map)
Remove all entries from the map.
void * GNUNET_CONTAINER_multihashmap_get(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Given a key find a value in the map matching the key.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST
, ' bother checking if a value already exists (faster than GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE...
enum GNUNET_GenericReturnValue GNUNET_IDENTITY_public_key_from_string(const char *str, struct GNUNET_IDENTITY_PublicKey *key)
Parses a (Base32) string representation of the public key.
char * GNUNET_IDENTITY_public_key_to_string(const struct GNUNET_IDENTITY_PublicKey *key)
Creates a (Base32) string representation of the public key.
#define GNUNET_log(kind,...)
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
GNUNET_GenericReturnValue
Named constants for return values.
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
@ GNUNET_SYSERR
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
const char * GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_DEBUG
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
@ GNUNET_MESSENGER_KIND_KEY
The key kind.
@ GNUNET_MESSENGER_KIND_ID
The id kind.
char * GNUNET_STRINGS_data_to_string_alloc(const void *buf, size_t size)
Return the base32crockford encoding of the given buffer.
Definition: strings.c:763
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:111
int decrease_contact_rc(struct GNUNET_MESSENGER_Contact *contact)
Decreases the reference counter if possible (can not underflow!) of a given contact and returns GNUNE...
void increase_contact_rc(struct GNUNET_MESSENGER_Contact *contact)
Increases the reference counter of a given contact which is zero as default.
void get_context_from_member(const struct GNUNET_HashCode *key, const struct GNUNET_ShortHashCode *id, struct GNUNET_HashCode *context)
Calculates the context hash of a member in a room and returns it.
struct GNUNET_MESSENGER_Contact * get_store_contact(struct GNUNET_MESSENGER_ContactStore *store, const struct GNUNET_HashCode *context, const struct GNUNET_IDENTITY_PublicKey *pubkey)
Returns a contact using a specific public key.
void remove_store_contact(struct GNUNET_MESSENGER_ContactStore *store, struct GNUNET_MESSENGER_Contact *contact, const struct GNUNET_HashCode *context)
Removes a contact from the store which uses a given member context.
void update_store_contact(struct GNUNET_MESSENGER_ContactStore *store, struct GNUNET_MESSENGER_Contact *contact, const struct GNUNET_HashCode *context, const struct GNUNET_HashCode *next_context, const struct GNUNET_IDENTITY_PublicKey *pubkey)
Moves a contact from the store to another location matching a given public key and member context.
messenger api: client implementation of GNUnet MESSENGER service
int is_message_session_bound(const struct GNUNET_MESSENGER_Message *message)
Returns if the message should be bound to a member session.
int verify_message(const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash, const struct GNUNET_IDENTITY_PublicKey *key)
Verifies the signature of a given message and its hash with a specific public key.
Handle used to access files (and pipes).
A 512-bit hashcode.
An identity key as per LSD0001.
struct GNUNET_MESSENGER_ListMessage * next
struct GNUNET_MESSENGER_ListMessage * head
struct GNUNET_MESSENGER_ListMessage * tail
struct GNUNET_CONTAINER_MultiHashMap * history
struct GNUNET_MESSENGER_MemberSession * prev
struct GNUNET_MESSENGER_MemberSession * next
struct GNUNET_MESSENGER_ListMessages messages
struct GNUNET_MESSENGER_MemberStore * store
struct GNUNET_MESSENGER_MessageId id
struct GNUNET_MESSENGER_MessageKey key
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_ShortHashCode id
The new id which will replace the senders id in a room.
struct GNUNET_IDENTITY_PublicKey key
The new public key which replaces the current senders public key.
struct GNUNET_MESSENGER_MessageHeader header
Header.
struct GNUNET_MESSENGER_MessageBody body
Body.
A 256-bit hashcode.
Time for absolute times used by GNUnet, in microseconds.
uint64_t abs_value_us
The actual value.