GNUnet  0.11.x
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 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  */
27 
30 
32 
35  const struct GNUNET_IDENTITY_PublicKey *pubkey)
36 {
37  if ((!member) || (!pubkey) || (!(member->store)))
38  return NULL;
39 
41  session->member = member;
42 
43  GNUNET_memcpy(&(session->public_key), pubkey, sizeof(session->public_key));
44 
46  get_member_session_key (session),
47  get_member_session_id (session),
48  &(session->context)
49  );
50 
52 
53  session->contact = get_store_contact(
54  store,
57  );
58 
59  if (!(session->contact))
60  {
61  GNUNET_free(session);
62  return NULL;
63  }
64 
65  increase_contact_rc (session->contact);
66 
68 
69  init_list_messages(&(session->messages));
70 
71  session->prev = NULL;
72  session->next = NULL;
73 
74  session->start = GNUNET_TIME_absolute_get();
75 
76  session->closed = GNUNET_NO;
77  session->completed = GNUNET_NO;
78 
79  return session;
80 }
81 
82 static void
84 {
85  GNUNET_assert (session);
86 
87  if (!session->messages.tail)
88  {
89  session->completed = GNUNET_YES;
90  goto completion;
91  }
92 
93  const struct GNUNET_HashCode* start = &(session->messages.head->hash);
94  const struct GNUNET_HashCode* end = &(session->messages.tail->hash);
95 
96  struct GNUNET_MESSENGER_ListMessages level;
97  init_list_messages(&level);
98 
99  add_to_list_messages(&level, end);
100 
102 
105 
106  while (level.head)
107  {
108  struct GNUNET_MESSENGER_ListMessage *element;
109 
110  for (element = level.head; element; element = element->next)
111  {
113  store, &(element->hash), GNUNET_NO
114  );
115 
116  if (!link)
117  continue;
118 
119  add_to_list_messages(&list, &(link->first));
120 
121  if (GNUNET_YES == link->multiple)
122  add_to_list_messages(&list, &(link->second));
123  }
124 
125  clear_list_messages(&level);
126 
127  for (element = list.head; element; element = element->next)
128  if (GNUNET_YES == check_member_session_history(session, &(element->hash), GNUNET_YES))
129  break;
130 
131  if (element)
132  if (0 != GNUNET_CRYPTO_hash_cmp(&(element->hash), start))
133  add_to_list_messages(&level, &(element->hash));
134  else
135  session->completed = GNUNET_YES;
136  else
137  copy_list_messages(&level, &list);
138 
140  }
141 
142 completion:
143  if (GNUNET_YES == is_member_session_completed(session))
144  {
146 
148 
149  if ((session->contact) && (GNUNET_YES == decrease_contact_rc (session->contact)))
151  store,
152  session->contact,
154  );
155 
156  session->contact = NULL;
157  }
158 }
159 
160 static int
162  const struct GNUNET_HashCode *key,
163  void *value)
164 {
165  struct GNUNET_MESSENGER_MemberSession *next = cls;
166 
169 
170  return GNUNET_YES;
171 }
172 
175  const struct GNUNET_MESSENGER_Message *message,
176  const struct GNUNET_HashCode *hash)
177 {
178  if ((!session) || (!message) || (!hash))
179  return NULL;
180 
182  (GNUNET_MESSENGER_KIND_KEY == message->header.kind));
183 
185 
186  if (GNUNET_MESSENGER_KIND_ID == message->header.kind)
187  next->member = add_store_member(session->member->store, &(message->body.id.id));
188  else
189  next->member = session->member;
190 
191  if (GNUNET_MESSENGER_KIND_KEY == message->header.kind)
192  GNUNET_memcpy(&(next->public_key), &(message->body.key.key), sizeof(next->public_key));
193  else
195 
199  &(next->context)
200  );
201 
208  );
209 
211 
212  if (!(next->contact))
213  {
214  GNUNET_free(next);
215  return NULL;
216  }
217 
219 
222  );
223 
225 
227  copy_list_messages(&(next->messages), &(session->messages));
228 
229  session->next = next;
230  next->prev = session;
231  next->next = NULL;
232 
234 
235  session->closed = GNUNET_YES;
236  next->closed = GNUNET_NO;
238 
240 
241  return next;
242 }
243 
244 void
246 {
247  GNUNET_assert (session);
248 
250 
251  clear_list_messages (&(session->messages));
252 
253  struct GNUNET_MESSENGER_Contact *contact = get_member_session_contact (session);
254 
255  if ((contact) && (GNUNET_YES == decrease_contact_rc (contact)))
258  contact,
260  );
261 
262  GNUNET_free(session);
263 }
264 
265 int
267  const struct GNUNET_HashCode *hash)
268 {
269  GNUNET_assert ((session) && (hash));
270 
273  store,
274  get_member_session_context (session),
276  );
277 
278  if (!contact)
279  return GNUNET_SYSERR;
280 
281  if (contact == session->contact)
282  goto clear_messages;
283 
284  session->contact = contact;
285  increase_contact_rc (session->contact);
286 
287 clear_messages:
288  clear_list_messages(&(session->messages));
289  add_to_list_messages(&(session->messages), hash);
290 
291  session->next = NULL;
292  session->closed = GNUNET_NO;
293  session->completed = GNUNET_NO;
294 
295  return GNUNET_OK;
296 }
297 
298 void
300 {
301  GNUNET_assert (session);
302 
303  session->closed = GNUNET_YES;
305 }
306 
307 int
309 {
310  GNUNET_assert(session);
311 
312  return session->closed;
313 }
314 
315 int
317 {
318  GNUNET_assert(session);
319 
320  return session->completed;
321 }
322 
325 {
326  GNUNET_assert(session);
327 
328  if (session->prev)
329  return get_member_session_start(session->prev);
330 
331  return session->start;
332 }
333 
334 const struct GNUNET_HashCode*
336 {
337  GNUNET_assert((session) && (session->member));
338 
339  return get_member_store_key(session->member->store);
340 }
341 
342 const struct GNUNET_ShortHashCode*
344 {
345  GNUNET_assert(session);
346 
347  return get_member_id(session->member);
348 }
349 
350 const struct GNUNET_IDENTITY_PublicKey*
352 {
353  GNUNET_assert(session);
354 
355  return &(session->public_key);
356 }
357 
358 const struct GNUNET_HashCode*
360 {
361  GNUNET_assert(session);
362 
363  return &(session->context);
364 }
365 
368 {
369  GNUNET_assert (session);
370 
371  return session->contact;
372 }
373 
375  const struct GNUNET_MESSENGER_Message *message,
376  const struct GNUNET_HashCode *hash)
377 {
378  GNUNET_assert((session) && (message) && (hash));
379 
380  if (GNUNET_YES == is_member_session_completed(session))
381  return GNUNET_SYSERR;
382 
383  if (0 != GNUNET_memcmp(get_member_session_id(session), &(message->header.sender_id)))
384  return GNUNET_SYSERR;
385 
386  return verify_message(message, hash, get_member_session_public_key(session));
387 }
388 
389 int
391  const struct GNUNET_HashCode *hash, int ownership)
392 {
393  GNUNET_assert((session) && (hash));
394 
395  if (GNUNET_YES == ownership)
396  return (NULL != GNUNET_CONTAINER_multihashmap_get(session->history, hash)? GNUNET_YES : GNUNET_NO);
397  else
398  return GNUNET_CONTAINER_multihashmap_contains(session->history, hash);
399 }
400 
401 static void
403  const struct GNUNET_HashCode *hash, int ownership)
404 {
405  GNUNET_assert ((session) && (hash));
406 
407  if ((GNUNET_OK == GNUNET_CONTAINER_multihashmap_put(session->history, hash, (GNUNET_YES == ownership? session : NULL),
409  update_member_chain_history (session->next, hash, ownership);
410 }
411 
412 void
414  const struct GNUNET_MESSENGER_Message *message,
415  const struct GNUNET_HashCode *hash)
416 {
417  GNUNET_assert((session) && (message) && (hash));
418 
419  if (GNUNET_YES == is_member_session_completed(session))
420  return;
421 
422  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Updating sessions history (%s) += (%s)\n",
423  GNUNET_sh2s(get_member_session_id(session)), GNUNET_h2s(hash));
424 
425  if (GNUNET_OK == verify_member_session_as_sender (session, message, hash))
426  {
427  if (GNUNET_YES == is_message_session_bound (message))
428  add_to_list_messages(&(session->messages), hash);
429 
430  update_member_chain_history (session, hash, GNUNET_YES);
431  }
432  else
433  update_member_chain_history (session, hash, GNUNET_NO);
434 
435  if (GNUNET_YES == session->closed)
437 }
438 
439 static void
441  const struct GNUNET_HashCode *hash)
442 {
443  GNUNET_assert ((session) && (hash));
444 
445  if ((0 < GNUNET_CONTAINER_multihashmap_remove_all(session->history, hash)) && (session->next))
446  clear_member_session_history(session->next, hash);
447 }
448 
449 void
451  const struct GNUNET_HashCode *hash)
452 {
453  GNUNET_assert((session) && (hash));
454 
455  clear_member_chain_history (session, hash);
456 }
457 
459 {
460  struct GNUNET_HashCode hash;
461  unsigned char ownership;
462 };
463 
464 static void
466  const char *path)
467 {
468  GNUNET_assert((session) && (path));
469 
470  if (GNUNET_YES != GNUNET_DISK_file_test (path))
471  return;
472 
474 
476  path, GNUNET_DISK_OPEN_READ, permission
477  );
478 
479  if (!handle)
480  return;
481 
483 
485  ssize_t len;
486 
487  int status;
488 
489  do {
490  len = GNUNET_DISK_file_read(handle, &(entry.hash), sizeof(entry.hash));
491 
492  if (len != sizeof(entry.hash))
493  break;
494 
495  len = GNUNET_DISK_file_read(handle, &(entry.ownership), sizeof(entry.ownership));
496 
497  if (len != sizeof(entry.ownership))
498  break;
499 
500  status = GNUNET_CONTAINER_multihashmap_put(session->history, &(entry.hash), (entry.ownership? session : NULL),
502  } while (status == GNUNET_OK);
503 
505 }
506 
507 void
509  const char *directory)
510 {
511  GNUNET_assert ((member) && (directory));
512 
513  char *config_file;
514  GNUNET_asprintf (&config_file, "%s%s", directory, "session.cfg");
515 
516  struct GNUNET_MESSENGER_MemberSession *session = NULL;
517 
519  goto free_config;
520 
522 
524  {
525  char *key_data;
526 
527  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, "session", "key", &key_data))
528  goto destroy_config;
529 
531 
533 
534  GNUNET_free(key_data);
535 
536  if (GNUNET_OK != key_return)
537  goto destroy_config;
538 
539  session = create_member_session(member, &key);
540 
541  unsigned long long numeric_value;
542 
543  if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, "session", "start", &numeric_value))
544  session->start.abs_value_us = numeric_value;
545 
546  if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, "session", "closed", &numeric_value))
547  session->closed = (GNUNET_YES == numeric_value? GNUNET_YES : GNUNET_NO);
548 
549  if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, "session", "completed", &numeric_value))
550  session->completed = (GNUNET_YES == numeric_value? GNUNET_YES : GNUNET_NO);
551  }
552 
553 destroy_config:
555 
556 free_config:
558 
559  if (!session)
560  return;
561 
562  char *history_file;
563  GNUNET_asprintf (&history_file, "%s%s", directory, "history.map");
564 
565  load_member_session_history (session, history_file);
566  GNUNET_free(history_file);
567 
568  char *messages_file;
569  GNUNET_asprintf (&messages_file, "%s%s", directory, "messages.list");
570 
571  load_list_messages(&(session->messages), messages_file);
572  GNUNET_free(messages_file);
573 
574  add_member_session(member, session);
575 }
576 
577 static struct GNUNET_MESSENGER_MemberSession*
580 {
581  if (!next)
582  return NULL;
583 
584  struct GNUNET_MESSENGER_MemberSession *check = next;
585 
586  do {
587  if (check == session)
588  return NULL;
589 
590  check = check->next;
591  } while (check);
592 
593  return next;
594 }
595 
596 void
598  const char *directory)
599 {
600  GNUNET_assert ((session) && (directory));
601 
602  char *config_file;
603  GNUNET_asprintf (&config_file, "%s%s", directory, "session.cfg");
604 
606  goto free_config;
607 
609 
611  {
612  char *key_data;
613 
614  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, "session", "next_key", &key_data))
615  goto destroy_config;
616 
617  struct GNUNET_IDENTITY_PublicKey next_key;
618 
619  enum GNUNET_GenericReturnValue key_return = GNUNET_IDENTITY_public_key_from_string(key_data, &next_key);
620 
621  GNUNET_free(key_data);
622 
623  if (GNUNET_OK != key_return)
624  goto destroy_config;
625 
627 
628  if (GNUNET_OK != GNUNET_CONFIGURATION_get_data (cfg, "session", "next_id", &next_id, sizeof(next_id)))
629  goto destroy_config;
630 
631  struct GNUNET_MESSENGER_Member *member = get_store_member(session->member->store, &next_id);
632 
634  session, member? get_member_session (member, &next_key) : NULL
635  );
636 
637  if (session->next)
638  session->next->prev = session;
639  }
640 
641 destroy_config:
643 
644 free_config:
646 }
647 
648 static int
650  const struct GNUNET_HashCode *key,
651  void *value)
652 {
653  struct GNUNET_DISK_FileHandle *handle = cls;
654  unsigned char ownership = value? GNUNET_YES : GNUNET_NO;
655 
656  GNUNET_DISK_file_write(handle, key, sizeof(*key));
657  GNUNET_DISK_file_write(handle, &ownership, sizeof(ownership));
658 
659  return GNUNET_YES;
660 }
661 
662 static void
664  const char *path)
665 {
666  GNUNET_assert((session) && (path));
667 
669 
672  );
673 
674  if (!handle)
675  return;
676 
678 
680  session->history,
682  handle
683  );
684 
687 }
688 
689 void
691  const char *directory)
692 {
693  GNUNET_assert ((session) && (directory));
694 
695  char *config_file;
696  GNUNET_asprintf (&config_file, "%s%s", directory, "session.cfg");
697 
699 
701 
702  if (key_data)
703  {
704  GNUNET_CONFIGURATION_set_value_string (cfg, "session", "key", key_data);
705 
706  GNUNET_free(key_data);
707  }
708 
709  if (session->next)
710  {
711  const struct GNUNET_ShortHashCode *next_id = get_member_session_id(session->next);
712 
713  char *next_id_data = GNUNET_STRINGS_data_to_string_alloc (next_id, sizeof(*next_id));
714 
715  if (next_id_data)
716  {
717  GNUNET_CONFIGURATION_set_value_string (cfg, "session", "next_id", next_id_data);
718 
719  GNUNET_free(next_id_data);
720  }
721 
723 
724  if (key_data)
725  {
726  GNUNET_CONFIGURATION_set_value_string (cfg, "session", "next_key", key_data);
727 
728  GNUNET_free(key_data);
729  }
730  }
731 
732  GNUNET_CONFIGURATION_set_value_number(cfg, "session", "start", session->start.abs_value_us);
733 
734  GNUNET_CONFIGURATION_set_value_number (cfg, "session", "closed", session->closed);
735  GNUNET_CONFIGURATION_set_value_number (cfg, "session", "completed", session->completed);
736 
739 
741 
742  char *history_file;
743  GNUNET_asprintf (&history_file, "%s%s", directory, "history.map");
744 
745  save_member_session_history (session, history_file);
746  GNUNET_free(history_file);
747 
748  char *messages_file;
749  GNUNET_asprintf (&messages_file, "%s%s", directory, "messages.list");
750 
751  save_list_messages(&(session->messages), messages_file);
752  GNUNET_free(messages_file);
753 }
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_room_message_store(struct GNUNET_MESSENGER_SrvRoom *room)
Returns the used message store of a given room.
GNUnet MESSENGER service.
#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.
Definition: gnunet_common.h:92
@ GNUNET_OK
Definition: gnunet_common.h:95
@ GNUNET_YES
Definition: gnunet_common.h:97
@ GNUNET_NO
Definition: gnunet_common.h:94
@ GNUNET_SYSERR
Definition: gnunet_common.h:93
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:1235
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
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:686
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:206
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:1425
enum GNUNET_GenericReturnValue GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1306
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_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:201
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.
int 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).
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
int 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.
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.
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_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:750
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:86
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.