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 
103  struct GNUNET_MESSENGER_ListMessages list;
104  init_list_messages(&list);
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 
139  clear_list_messages(&list);
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
161 iterate_copy_history (void *cls, const struct GNUNET_HashCode *key, void *value)
162 {
163  struct GNUNET_MESSENGER_MemberSession *next = cls;
164 
165  GNUNET_CONTAINER_multihashmap_put(next->history, key, (value? next : NULL),
167 
168  return GNUNET_YES;
169 }
170 
173  const struct GNUNET_MESSENGER_Message *message,
174  const struct GNUNET_HashCode *hash)
175 {
176  if ((!session) || (!message) || (!hash))
177  return NULL;
178 
180  (GNUNET_MESSENGER_KIND_KEY == message->header.kind));
181 
183 
184  if (GNUNET_MESSENGER_KIND_ID == message->header.kind)
185  next->member = add_store_member(session->member->store, &(message->body.id.id));
186  else
187  next->member = session->member;
188 
189  if (GNUNET_MESSENGER_KIND_KEY == message->header.kind)
190  GNUNET_memcpy(&(next->public_key), &(message->body.key.key), sizeof(next->public_key));
191  else
192  GNUNET_memcpy(&(next->public_key), get_member_session_public_key(session), sizeof(next->public_key));
193 
195  get_member_session_key (next),
196  get_member_session_id (next),
197  &(next->context)
198  );
199 
206  );
207 
208  next->contact = get_member_session_contact(session);
209 
210  if (!(next->contact))
211  {
212  GNUNET_free(next);
213  return NULL;
214  }
215 
217 
220  );
221 
223 
224  init_list_messages(&(next->messages));
225  copy_list_messages(&(next->messages), &(session->messages));
226 
227  session->next = next;
228  next->prev = session;
229  next->next = NULL;
230 
232 
233  session->closed = GNUNET_YES;
234  next->closed = GNUNET_NO;
235  next->completed = GNUNET_NO;
236 
238 
239  return next;
240 }
241 
242 void
244 {
245  GNUNET_assert (session);
246 
248 
249  clear_list_messages (&(session->messages));
250 
251  struct GNUNET_MESSENGER_Contact *contact = get_member_session_contact (session);
252 
253  if ((contact) && (GNUNET_YES == decrease_contact_rc (contact)))
256  contact,
258  );
259 
260  GNUNET_free(session);
261 }
262 
263 int
265  const struct GNUNET_HashCode *hash)
266 {
267  GNUNET_assert ((session) && (hash));
268 
271  store,
272  get_member_session_context (session),
274  );
275 
276  if (!contact)
277  return GNUNET_SYSERR;
278 
279  if (contact == session->contact)
280  goto clear_messages;
281 
282  session->contact = contact;
283  increase_contact_rc (session->contact);
284 
285 clear_messages:
286  clear_list_messages(&(session->messages));
287  add_to_list_messages(&(session->messages), hash);
288 
289  session->next = NULL;
290  session->closed = GNUNET_NO;
291  session->completed = GNUNET_NO;
292 
293  return GNUNET_OK;
294 }
295 
296 void
298 {
299  GNUNET_assert (session);
300 
301  session->closed = GNUNET_YES;
303 }
304 
305 int
307 {
308  GNUNET_assert(session);
309 
310  return session->closed;
311 }
312 
313 int
315 {
316  GNUNET_assert(session);
317 
318  return session->completed;
319 }
320 
323 {
324  GNUNET_assert(session);
325 
326  if (session->prev)
327  return get_member_session_start(session->prev);
328 
329  return session->start;
330 }
331 
332 const struct GNUNET_HashCode*
334 {
335  GNUNET_assert((session) && (session->member));
336 
337  return get_member_store_key(session->member->store);
338 }
339 
340 const struct GNUNET_ShortHashCode*
342 {
343  GNUNET_assert(session);
344 
345  return get_member_id(session->member);
346 }
347 
348 const struct GNUNET_IDENTITY_PublicKey*
350 {
351  GNUNET_assert(session);
352 
353  return &(session->public_key);
354 }
355 
356 const struct GNUNET_HashCode*
358 {
359  GNUNET_assert(session);
360 
361  return &(session->context);
362 }
363 
366 {
367  GNUNET_assert (session);
368 
369  return session->contact;
370 }
371 
373  const struct GNUNET_MESSENGER_Message *message,
374  const struct GNUNET_HashCode *hash)
375 {
376  GNUNET_assert((session) && (message) && (hash));
377 
378  if (GNUNET_YES == is_member_session_completed(session))
379  return GNUNET_SYSERR;
380 
381  if (0 != GNUNET_memcmp(get_member_session_id(session), &(message->header.sender_id)))
382  return GNUNET_SYSERR;
383 
384  return verify_message(message, hash, get_member_session_public_key(session));
385 }
386 
387 int
389  const struct GNUNET_HashCode *hash, int ownership)
390 {
391  GNUNET_assert((session) && (hash));
392 
393  if (GNUNET_YES == ownership)
394  return (NULL != GNUNET_CONTAINER_multihashmap_get(session->history, hash)? GNUNET_YES : GNUNET_NO);
395  else
396  return GNUNET_CONTAINER_multihashmap_contains(session->history, hash);
397 }
398 
399 static void
401  const struct GNUNET_HashCode *hash, int ownership)
402 {
403  GNUNET_assert ((session) && (hash));
404 
405  if ((GNUNET_OK == GNUNET_CONTAINER_multihashmap_put(session->history, hash, (GNUNET_YES == ownership? session : NULL),
407  update_member_chain_history (session->next, hash, ownership);
408 }
409 
410 void
412  const struct GNUNET_MESSENGER_Message *message,
413  const struct GNUNET_HashCode *hash)
414 {
415  GNUNET_assert((session) && (message) && (hash));
416 
417  if (GNUNET_YES == is_member_session_completed(session))
418  return;
419 
420  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Updating sessions history (%s) += (%s)\n",
421  GNUNET_sh2s(get_member_session_id(session)), GNUNET_h2s(hash));
422 
423  if (GNUNET_OK == verify_member_session_as_sender (session, message, hash))
424  {
425  if (GNUNET_YES == is_message_session_bound (message))
426  add_to_list_messages(&(session->messages), hash);
427 
428  update_member_chain_history (session, hash, GNUNET_YES);
429  }
430  else
431  update_member_chain_history (session, hash, GNUNET_NO);
432 
433  if (GNUNET_YES == session->closed)
435 }
436 
437 static void
439  const struct GNUNET_HashCode *hash)
440 {
441  GNUNET_assert ((session) && (hash));
442 
443  if ((0 < GNUNET_CONTAINER_multihashmap_remove_all(session->history, hash)) && (session->next))
444  clear_member_session_history(session->next, hash);
445 }
446 
447 void
449  const struct GNUNET_HashCode *hash)
450 {
451  GNUNET_assert((session) && (hash));
452 
453  clear_member_chain_history (session, hash);
454 }
455 
457 {
459  unsigned char ownership;
460 };
461 
462 static void
464 {
465  GNUNET_assert((session) && (path));
466 
467  if (GNUNET_YES != GNUNET_DISK_file_test (path))
468  return;
469 
471 
473  path, GNUNET_DISK_OPEN_READ, permission
474  );
475 
476  if (!handle)
477  return;
478 
480 
482  ssize_t len;
483 
484  int status;
485 
486  do {
487  len = GNUNET_DISK_file_read(handle, &(entry.hash), sizeof(entry.hash));
488 
489  if (len != sizeof(entry.hash))
490  break;
491 
492  len = GNUNET_DISK_file_read(handle, &(entry.ownership), sizeof(entry.ownership));
493 
494  if (len != sizeof(entry.ownership))
495  break;
496 
497  status = GNUNET_CONTAINER_multihashmap_put(session->history, &(entry.hash), (entry.ownership? session : NULL),
499  } while (status == GNUNET_OK);
500 
501  GNUNET_DISK_file_close(handle);
502 }
503 
504 void
505 load_member_session (struct GNUNET_MESSENGER_Member *member, const char *directory)
506 {
507  GNUNET_assert ((member) && (directory));
508 
509  char *config_file;
510  GNUNET_asprintf (&config_file, "%s%s", directory, "session.cfg");
511 
512  struct GNUNET_MESSENGER_MemberSession *session = NULL;
513 
514  if (GNUNET_YES != GNUNET_DISK_file_test (config_file))
515  goto free_config;
516 
518 
519  if (GNUNET_OK == GNUNET_CONFIGURATION_parse (cfg, config_file))
520  {
521  char *key_data;
522 
523  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, "session", "key", &key_data))
524  goto destroy_config;
525 
526  struct GNUNET_IDENTITY_PublicKey key;
527 
528  enum GNUNET_GenericReturnValue key_return = GNUNET_IDENTITY_public_key_from_string(key_data, &key);
529 
530  GNUNET_free(key_data);
531 
532  if (GNUNET_OK != key_return)
533  goto destroy_config;
534 
535  session = create_member_session(member, &key);
536 
537  unsigned long long numeric_value;
538 
539  if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, "session", "start", &numeric_value))
540  session->start.abs_value_us = numeric_value;
541 
542  if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, "session", "closed", &numeric_value))
543  session->closed = (GNUNET_YES == numeric_value? GNUNET_YES : GNUNET_NO);
544 
545  if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cfg, "session", "completed", &numeric_value))
546  session->completed = (GNUNET_YES == numeric_value? GNUNET_YES : GNUNET_NO);
547  }
548 
549 destroy_config:
551 
552 free_config:
553  GNUNET_free(config_file);
554 
555  if (!session)
556  return;
557 
558  char *history_file;
559  GNUNET_asprintf (&history_file, "%s%s", directory, "history.map");
560 
561  load_member_session_history (session, history_file);
562  GNUNET_free(history_file);
563 
564  char *messages_file;
565  GNUNET_asprintf (&messages_file, "%s%s", directory, "messages.list");
566 
567  load_list_messages(&(session->messages), messages_file);
568  GNUNET_free(messages_file);
569 
570  add_member_session(member, session);
571 }
572 
573 static struct GNUNET_MESSENGER_MemberSession*
575 {
576  if (!next)
577  return NULL;
578 
579  struct GNUNET_MESSENGER_MemberSession *check = next;
580 
581  do {
582  if (check == session)
583  return NULL;
584 
585  check = check->next;
586  } while (check);
587 
588  return next;
589 }
590 
591 void
592 load_member_session_next (struct GNUNET_MESSENGER_MemberSession *session, const char *directory)
593 {
594  GNUNET_assert ((session) && (directory));
595 
596  char *config_file;
597  GNUNET_asprintf (&config_file, "%s%s", directory, "session.cfg");
598 
599  if (GNUNET_YES != GNUNET_DISK_file_test (config_file))
600  goto free_config;
601 
603 
604  if (GNUNET_OK == GNUNET_CONFIGURATION_parse (cfg, config_file))
605  {
606  char *key_data;
607 
608  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, "session", "next_key", &key_data))
609  goto destroy_config;
610 
611  struct GNUNET_IDENTITY_PublicKey next_key;
612 
613  enum GNUNET_GenericReturnValue key_return = GNUNET_IDENTITY_public_key_from_string(key_data, &next_key);
614 
615  GNUNET_free(key_data);
616 
617  if (GNUNET_OK != key_return)
618  goto destroy_config;
619 
620  struct GNUNET_ShortHashCode next_id;
621 
622  if (GNUNET_OK != GNUNET_CONFIGURATION_get_data (cfg, "session", "next_id", &next_id, sizeof(next_id)))
623  goto destroy_config;
624 
625  struct GNUNET_MESSENGER_Member *member = get_store_member(session->member->store, &next_id);
626 
628  session, member? get_member_session (member, &next_key) : NULL
629  );
630 
631  if (session->next)
632  session->next->prev = session;
633  }
634 
635 destroy_config:
637 
638 free_config:
639  GNUNET_free(config_file);
640 }
641 
642 static int
644 {
645  struct GNUNET_DISK_FileHandle *handle = cls;
646  unsigned char ownership = value? GNUNET_YES : GNUNET_NO;
647 
648  GNUNET_DISK_file_write(handle, key, sizeof(*key));
649  GNUNET_DISK_file_write(handle, &ownership, sizeof(ownership));
650 
651  return GNUNET_YES;
652 }
653 
654 static void
656 {
657  GNUNET_assert((session) && (path));
658 
660 
663  );
664 
665  if (!handle)
666  return;
667 
669 
671  session->history,
673  handle
674  );
675 
676  GNUNET_DISK_file_sync(handle);
677  GNUNET_DISK_file_close(handle);
678 }
679 
680 void
681 save_member_session (struct GNUNET_MESSENGER_MemberSession *session, const char *directory)
682 {
683  GNUNET_assert ((session) && (directory));
684 
685  char *config_file;
686  GNUNET_asprintf (&config_file, "%s%s", directory, "session.cfg");
687 
689 
691 
692  if (key_data)
693  {
694  GNUNET_CONFIGURATION_set_value_string (cfg, "session", "key", key_data);
695 
696  GNUNET_free(key_data);
697  }
698 
699  if (session->next)
700  {
701  const struct GNUNET_ShortHashCode *next_id = get_member_session_id(session->next);
702 
703  char *next_id_data = GNUNET_STRINGS_data_to_string_alloc (next_id, sizeof(*next_id));
704 
705  if (next_id_data)
706  {
707  GNUNET_CONFIGURATION_set_value_string (cfg, "session", "next_id", next_id_data);
708 
709  GNUNET_free(next_id_data);
710  }
711 
713 
714  if (key_data)
715  {
716  GNUNET_CONFIGURATION_set_value_string (cfg, "session", "next_key", key_data);
717 
718  GNUNET_free(key_data);
719  }
720  }
721 
722  GNUNET_CONFIGURATION_set_value_number(cfg, "session", "start", session->start.abs_value_us);
723 
724  GNUNET_CONFIGURATION_set_value_number (cfg, "session", "closed", session->closed);
725  GNUNET_CONFIGURATION_set_value_number (cfg, "session", "completed", session->completed);
726 
727  GNUNET_CONFIGURATION_write (cfg, config_file);
729 
730  GNUNET_free(config_file);
731 
732  char *history_file;
733  GNUNET_asprintf (&history_file, "%s%s", directory, "history.map");
734 
735  save_member_session_history (session, history_file);
736  GNUNET_free(history_file);
737 
738  char *messages_file;
739  GNUNET_asprintf (&messages_file, "%s%s", directory, "messages.list");
740 
741  save_list_messages(&(session->messages), messages_file);
742  GNUNET_free(messages_file);
743 }
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.
Open the file for reading.
struct GNUNET_MESSENGER_MessageHeader header
Header.
static int iterate_copy_history(void *cls, const struct GNUNET_HashCode *key, void *value)
const char * GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).
Create file if it doesn&#39;t exist.
struct GNUNET_MESSENGER_MessageStore * get_room_message_store(struct GNUNET_MESSENGER_SrvRoom *room)
Returns the used message store of a given room.
static struct GNUNET_MESSENGER_MemberSession * get_cycle_safe_next_session(struct GNUNET_MESSENGER_MemberSession *session, struct GNUNET_MESSENGER_MemberSession *next)
struct GNUNET_ShortHashCode sender_id
The senders id inside of the room the message was sent in.
struct GNUNET_MESSENGER_ListMessage * next
struct GNUNET_MESSENGER_Contact * get_member_session_contact(struct GNUNET_MESSENGER_MemberSession *session)
Returns the contact which is connected to a given member session.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
GNUnet MESSENGER service.
static int end
Set if we are to shutdown all services (including ARM).
Definition: gnunet-arm.c:34
struct GNUNET_MESSENGER_ListMessage * head
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...
struct GNUNET_MESSENGER_MemberSession * next
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.
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...
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:602
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.
int is_message_session_bound(const struct GNUNET_MESSENGER_Message *message)
Returns if the message should be bound to a member session.
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...
const struct GNUNET_HashCode * get_member_session_context(const struct GNUNET_MESSENGER_MemberSession *session)
Returns the member context of a given member session.
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.
static int start
Set if we are to start default services (including ARM).
Definition: gnunet-arm.c:39
char * GNUNET_IDENTITY_public_key_to_string(const struct GNUNET_IDENTITY_PublicKey *key)
Creates a (Base32) string representation of the public key.
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.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
enum GNUNET_GenericReturnValue GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1126
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.
int is_member_session_closed(const struct GNUNET_MESSENGER_MemberSession *session)
Returns if the given member session has been closed.
static void clear_member_chain_history(struct GNUNET_MESSENGER_MemberSession *session, const struct GNUNET_HashCode *hash)
struct GNUNET_ShortHashCode id
The new id which will replace the senders id in a room.
static char * config_file
Set to the name of the config file used.
Definition: gnunet-arm.c:84
int is_member_session_completed(const struct GNUNET_MESSENGER_MemberSession *session)
Returns if the given member session has been completed.
struct GNUNET_MESSENGER_MessageKey key
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
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_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.
GNUNET_GenericReturnValue
Named constants for return values.
Definition: gnunet_common.h:83
void add_member_session(struct GNUNET_MESSENGER_Member *member, struct GNUNET_MESSENGER_MemberSession *session)
Adds a given member session to its member.
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.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
#define GNUNET_new(type)
Allocate a struct or union of the given type.
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.
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_create(void)
Create a new configuration object.
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)...
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
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...
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.
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.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_write(struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename)
Write configuration file.
uint64_t abs_value_us
The actual value.
A 256-bit hashcode.
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.
struct GNUNET_TIME_Absolute get_member_session_start(const struct GNUNET_MESSENGER_MemberSession *session)
Returns the timestamp of the member session&#39;s start.
messenger api: client implementation of GNUnet MESSENGER service
static void check_member_session_completion(struct GNUNET_MESSENGER_MemberSession *session)
void init_list_messages(struct GNUNET_MESSENGER_ListMessages *messages)
Initializes list of message hashes as empty list.
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...
, &#39; bother checking if a value already exists (faster than GNUNET_CONTAINER_MULTIHASHMAPOPTION_...
static char * value
Value of the record to add/remove.
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:666
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
struct GNUNET_IDENTITY_PublicKey key
The new public key which replaces the current senders public key.
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.
static void save_member_session_history(struct GNUNET_MESSENGER_MemberSession *session, const char *path)
static struct GNUNET_IDENTITY_PublicKey pubkey
Public key of the zone to look in.
struct GNUNET_MESSENGER_MessageBody body
Body.
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
uint16_t status
See PRISM_STATUS_*-constants.
void increase_contact_rc(struct GNUNET_MESSENGER_Contact *contact)
Increases the reference counter of a given contact which is zero as default.
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.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
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.
GNUNET_DISK_AccessPermissions
File access permissions, UNIX-style.
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 load_member_session_next(struct GNUNET_MESSENGER_MemberSession *session, const char *directory)
Loads the connection from one session to another through the next attribute.
A 512-bit hashcode.
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...
void destroy_member_session(struct GNUNET_MESSENGER_MemberSession *session)
Destroys a member session and frees its memory fully.
struct GNUNET_CONTAINER_MultiHashMap * history
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:86
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...
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 void update_member_chain_history(struct GNUNET_MESSENGER_MemberSession *session, const struct GNUNET_HashCode *hash, int ownership)
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
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.
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.
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.
struct GNUNET_MESSENGER_MemberStore * store
struct GNUNET_HashCode key
The key used in the DHT.
struct GNUNET_MESSENGER_ContactStore * get_member_contact_store(struct GNUNET_MESSENGER_MemberStore *store)
Returns the used contact store of a given member store.
Open the file for writing.
struct GNUNET_MESSENGER_ListMessages messages
struct GNUNET_MESSENGER_ListMessage * tail
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.
void clear_list_messages(struct GNUNET_MESSENGER_ListMessages *messages)
Clears the list of message hashes.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
An identity key as per LSD0001.
static void load_member_session_history(struct GNUNET_MESSENGER_MemberSession *session, const char *path)
static char * next_id
Command-line option for namespace publishing: identifier for updates to this publication.
Seek an absolute position (from the start of the file).
configuration data
Definition: configuration.c:84
void save_list_messages(struct GNUNET_MESSENGER_ListMessages *messages, const char *path)
Saves the list of message hashes to a file under a given path.
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
enum GNUNET_GenericReturnValue GNUNET_DISK_file_sync(const struct GNUNET_DISK_FileHandle *h)
Write file changes to disk.
Definition: disk.c:1245
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.
#define GNUNET_log(kind,...)
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.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
Time for absolute times used by GNUnet, in microseconds.
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.
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_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.
char * GNUNET_STRINGS_data_to_string_alloc(const void *buf, size_t size)
Return the base32crockford encoding of the given buffer.
Definition: strings.c:937
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
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:1055
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.
struct GNUNET_MESSENGER_MessageId id
const struct GNUNET_ShortHashCode * get_member_id(const struct GNUNET_MESSENGER_Member *member)
Returns the current id of a given member.
Handle used to access files (and pipes).
struct GNUNET_MESSENGER_MemberSession * prev
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.
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:437
const struct GNUNET_ShortHashCode * get_member_session_id(const struct GNUNET_MESSENGER_MemberSession *session)
Returns the member id of a given member session.
#define GNUNET_free(ptr)
Wrapper around free.
enum GNUNET_MESSENGER_MessageKind kind
The kind of the message.
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
static int iterate_save_member_session_history_hentries(void *cls, const struct GNUNET_HashCode *key, void *value)