GNUnet  last
gnunet-service-messenger_member_session.c File Reference
Include dependency graph for gnunet-service-messenger_member_session.c:

Go to the source code of this file.

Data Structures

struct  GNUNET_MESSENGER_MemberSessionHistoryEntry
 

Functions

struct GNUNET_MESSENGER_MemberSessioncreate_member_session (struct GNUNET_MESSENGER_Member *member, const struct GNUNET_CRYPTO_PublicKey *pubkey)
 Creates and allocates a new member session of a member with a given public key. More...
 
static void check_member_session_completion (struct GNUNET_MESSENGER_MemberSession *session)
 
static int iterate_copy_history (void *cls, const struct GNUNET_HashCode *key, void *value)
 
struct GNUNET_MESSENGER_MemberSessionswitch_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 member. More...
 
void destroy_member_session (struct GNUNET_MESSENGER_MemberSession *session)
 Destroys a member session and frees its memory fully. More...
 
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. More...
 
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. More...
 
int is_member_session_closed (const struct GNUNET_MESSENGER_MemberSession *session)
 Returns if the given member session has been closed. More...
 
int is_member_session_completed (const struct GNUNET_MESSENGER_MemberSession *session)
 Returns if the given member session has been completed. More...
 
struct GNUNET_TIME_Absolute get_member_session_start (const struct GNUNET_MESSENGER_MemberSession *session)
 Returns the timestamp of the member session's start. More...
 
const struct GNUNET_HashCodeget_member_session_key (const struct GNUNET_MESSENGER_MemberSession *session)
 Returns the key of the room a given member session belongs to. More...
 
const struct GNUNET_ShortHashCodeget_member_session_id (const struct GNUNET_MESSENGER_MemberSession *session)
 Returns the member id of a given member session. More...
 
const struct GNUNET_CRYPTO_PublicKeyget_member_session_public_key (const struct GNUNET_MESSENGER_MemberSession *session)
 Returns the public key of a given member session. More...
 
const struct GNUNET_HashCodeget_member_session_context (const struct GNUNET_MESSENGER_MemberSession *session)
 Returns the member context of a given member session. More...
 
struct GNUNET_MESSENGER_Contactget_member_session_contact (struct GNUNET_MESSENGER_MemberSession *session)
 Returns the contact which is connected to a given member session. More...
 
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. More...
 
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 ownership flag is set, if the message is owned by the sessions contact. More...
 
static void update_member_chain_history (struct GNUNET_MESSENGER_MemberSession *session, const struct GNUNET_HashCode *hash, int ownership)
 
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. More...
 
static void clear_member_chain_history (struct GNUNET_MESSENGER_MemberSession *session, const struct GNUNET_HashCode *hash)
 
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. More...
 
static void load_member_session_history (struct GNUNET_MESSENGER_MemberSession *session, const char *path)
 
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 required information can be read from the content of the given directory. More...
 
static struct GNUNET_MESSENGER_MemberSessionget_cycle_safe_next_session (struct GNUNET_MESSENGER_MemberSession *session, struct GNUNET_MESSENGER_MemberSession *next)
 
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. More...
 
static int iterate_save_member_session_history_hentries (void *cls, const struct GNUNET_HashCode *key, void *value)
 
static void save_member_session_history (struct GNUNET_MESSENGER_MemberSession *session, const char *path)
 
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 completely. More...
 

Function Documentation

◆ create_member_session()

struct GNUNET_MESSENGER_MemberSession* create_member_session ( struct GNUNET_MESSENGER_Member member,
const struct GNUNET_CRYPTO_PublicKey pubkey 
)

Creates and allocates a new member session of a member with a given public key.

If the creation fails, NULL gets returned.

Parameters
[in,out]memberMember
[in]pubkeyPublic key
Returns
New member session

Definition at line 35 of file gnunet-service-messenger_member_session.c.

37 {
38  if ((! member) || (! pubkey) || (! (member->store)))
39  return NULL;
40 
41  struct GNUNET_MESSENGER_MemberSession *session = GNUNET_new (struct
43  session->member = member;
44 
45  GNUNET_memcpy (&(session->public_key), pubkey, sizeof(session->public_key));
46 
48  get_member_session_key (session),
49  get_member_session_id (session),
50  &(session->context)
51  );
52 
54  session->member->store);
55 
56  session->contact = get_store_contact (
57  store,
60  );
61 
62  if (! (session->contact))
63  {
64  GNUNET_free (session);
65  return NULL;
66  }
67 
68  increase_contact_rc (session->contact);
69 
71 
72  init_list_messages (&(session->messages));
73 
74  session->prev = NULL;
75  session->next = NULL;
76 
77  session->start = GNUNET_TIME_absolute_get ();
78 
79  session->closed = GNUNET_NO;
80  session->completed = GNUNET_NO;
81 
82  return session;
83 }
static struct GNUNET_CRYPTO_PublicKey pubkey
Public key of the zone to look in.
void init_list_messages(struct GNUNET_MESSENGER_ListMessages *messages)
Initializes list of message hashes as empty list.
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.
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_CRYPTO_PublicKey * get_member_session_public_key(const struct GNUNET_MESSENGER_MemberSession *session)
Returns the public key of a given member session.
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_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_NO
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:111
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_CRYPTO_PublicKey *pubkey)
Returns a contact using a specific public key.
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

References GNUNET_MESSENGER_MemberSession::closed, GNUNET_MESSENGER_MemberSession::completed, GNUNET_MESSENGER_MemberSession::contact, GNUNET_MESSENGER_MemberSession::context, get_context_from_member(), get_member_contact_store(), get_member_session_context(), get_member_session_id(), get_member_session_key(), get_member_session_public_key(), get_store_contact(), GNUNET_CONTAINER_multihashmap_create(), GNUNET_free, GNUNET_memcpy, GNUNET_new, GNUNET_NO, GNUNET_TIME_absolute_get(), GNUNET_MESSENGER_MemberSession::history, increase_contact_rc(), init_list_messages(), GNUNET_MESSENGER_MemberSession::member, GNUNET_MESSENGER_MemberSession::messages, GNUNET_MESSENGER_MemberSession::next, GNUNET_MESSENGER_MemberSession::prev, pubkey, GNUNET_MESSENGER_MemberSession::public_key, GNUNET_MESSENGER_MemberSession::start, and GNUNET_MESSENGER_Member::store.

Referenced by load_member_session(), and try_member_session().

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

◆ check_member_session_completion()

static void check_member_session_completion ( struct GNUNET_MESSENGER_MemberSession session)
static

Definition at line 87 of file gnunet-service-messenger_member_session.c.

88 {
89  GNUNET_assert (session);
90 
92  "Check session history (%s) for completion.\n",
94 
95  if (! session->messages.tail)
96  {
97  session->completed = GNUNET_YES;
98  goto completion;
99  }
100 
101  const struct GNUNET_HashCode *start = &(session->messages.head->hash);
102  const struct GNUNET_HashCode *end = &(session->messages.tail->hash);
103 
104  struct GNUNET_MESSENGER_ListMessages level;
105  init_list_messages (&level);
106 
107  add_to_list_messages (&level, end);
108 
110  session->member->store->room);
111 
114 
115  while (level.head)
116  {
117  struct GNUNET_MESSENGER_ListMessage *element;
118 
119  for (element = level.head; element; element = element->next)
120  {
122  store, &(element->hash), GNUNET_NO
123  );
124 
125  if (! link)
126  continue;
127 
128  add_to_list_messages (&list, &(link->first));
129 
130  if (GNUNET_YES == link->multiple)
131  add_to_list_messages (&list, &(link->second));
132  }
133 
134  clear_list_messages (&level);
135 
136  for (element = list.head; element; element = element->next)
137  if (GNUNET_YES == check_member_session_history (session, &(element->hash),
138  GNUNET_YES))
139  break;
140 
141  if (element)
142  if (0 != GNUNET_CRYPTO_hash_cmp (&(element->hash), start))
143  add_to_list_messages (&level, &(element->hash));
144  else
145  session->completed = GNUNET_YES;
146  else
147  copy_list_messages (&level, &list);
148 
150  }
151 
152 completion:
153  if (GNUNET_YES == is_member_session_completed (session))
154  {
155  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Completed session history (%s)\n",
156  GNUNET_sh2s (get_member_session_id (session)));
157 
159 
161  session->member->store);
162 
163  if ((session->contact) && (GNUNET_YES == decrease_contact_rc (
164  session->contact)))
166  store,
167  session->contact,
169  );
170 
171  session->contact = NULL;
172  }
173 }
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
void clear_list_messages(struct GNUNET_MESSENGER_ListMessages *messages)
Clears the list of message hashes.
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 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.
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 is_member_session_completed(const struct GNUNET_MESSENGER_MemberSession *session)
Returns if the given member session has been completed.
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.
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:221
unsigned int GNUNET_CONTAINER_multihashmap_clear(struct GNUNET_CONTAINER_MultiHashMap *map)
Remove all entries from the map.
#define GNUNET_log(kind,...)
@ GNUNET_YES
#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).
@ GNUNET_ERROR_TYPE_DEBUG
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 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.
A 512-bit hashcode.
struct GNUNET_MESSENGER_ListMessage * next
struct GNUNET_MESSENGER_ListMessage * head
struct GNUNET_MESSENGER_ListMessage * tail

References add_to_list_messages(), check_member_session_history(), clear_list_messages(), GNUNET_MESSENGER_MemberSession::completed, GNUNET_MESSENGER_MemberSession::contact, copy_list_messages(), decrease_contact_rc(), end, GNUNET_MESSENGER_MessageLink::first, get_member_contact_store(), get_member_session_context(), get_member_session_id(), get_srv_room_message_store(), get_store_message_link(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_clear(), GNUNET_CRYPTO_hash_cmp(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_sh2s(), GNUNET_YES, GNUNET_MESSENGER_ListMessage::hash, GNUNET_MESSENGER_ListMessages::head, GNUNET_MESSENGER_MemberSession::history, init_list_messages(), is_member_session_completed(), list, GNUNET_MESSENGER_MemberSession::member, GNUNET_MESSENGER_MemberSession::messages, GNUNET_MESSENGER_MessageLink::multiple, GNUNET_MESSENGER_ListMessage::next, remove_store_contact(), GNUNET_MESSENGER_MemberStore::room, GNUNET_MESSENGER_MessageLink::second, start, GNUNET_MESSENGER_Member::store, and GNUNET_MESSENGER_ListMessages::tail.

Referenced by close_member_session(), switch_member_session(), and update_member_session_history().

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

◆ iterate_copy_history()

static int iterate_copy_history ( void *  cls,
const struct GNUNET_HashCode key,
void *  value 
)
static

Definition at line 177 of file gnunet-service-messenger_member_session.c.

180 {
181  struct GNUNET_MESSENGER_MemberSession *next = cls;
182 
185 
186  return GNUNET_YES;
187 }
struct GNUNET_HashCode key
The key used in the DHT.
static char * value
Value of the record to add/remove.
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.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST
, ' bother checking if a value already exists (faster than GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE...

References GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_YES, GNUNET_MESSENGER_MemberSession::history, key, GNUNET_MESSENGER_MemberSession::next, and value.

Referenced by switch_member_session().

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

◆ switch_member_session()

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 member.

The new session could have significant changes to the members public key or its member id depending on the used message to switch session. The new session will be linked to the old one.

Parameters
[in,out]sessionOld member session
[in]messageMessage
[in]hashHash of message
Returns
New member session

Definition at line 191 of file gnunet-service-messenger_member_session.c.

194 {
195  if ((! session) || (! message) || (! hash))
196  return NULL;
197 
199  (GNUNET_MESSENGER_KIND_KEY == message->header.kind));
200 
203 
204  if (GNUNET_MESSENGER_KIND_ID == message->header.kind)
205  next->member = add_store_member (session->member->store,
206  &(message->body.id.id));
207  else
208  next->member = session->member;
209 
210  if (GNUNET_MESSENGER_KIND_KEY == message->header.kind)
211  GNUNET_memcpy (&(next->public_key), &(message->body.key.key),
212  sizeof(next->public_key));
213  else
215  sizeof(next->public_key));
216 
220  &(next->context)
221  );
222 
225  get_member_session_contact (session),
226  get_member_session_context (session),
229  );
230 
232 
233  if (! (next->contact))
234  {
235  GNUNET_free (next);
236  return NULL;
237  }
238 
240 
243  );
244 
246  next);
247 
249  copy_list_messages (&(next->messages), &(session->messages));
250 
251  session->next = next;
252  next->prev = session;
253  next->next = NULL;
254 
256 
257  session->closed = GNUNET_YES;
258  next->closed = GNUNET_NO;
260 
262 
263  return next;
264 }
static int iterate_copy_history(void *cls, const struct GNUNET_HashCode *key, void *value)
static void check_member_session_completion(struct GNUNET_MESSENGER_MemberSession *session)
struct GNUNET_MESSENGER_Contact * get_member_session_contact(struct GNUNET_MESSENGER_MemberSession *session)
Returns the contact which is connected to a given member session.
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.
unsigned int GNUNET_CONTAINER_multihashmap_size(const struct GNUNET_CONTAINER_MultiHashMap *map)
Get the number of key-value pairs in the map.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MultiHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
@ GNUNET_MESSENGER_KIND_KEY
The key kind.
@ GNUNET_MESSENGER_KIND_ID
The id kind.
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_CRYPTO_PublicKey *pubkey)
Moves a contact from the store to another location matching a given public key and member context.
struct GNUNET_MESSENGER_MessageId id
struct GNUNET_MESSENGER_MessageKey key
enum GNUNET_MESSENGER_MessageKind kind
The kind of the message.
struct GNUNET_ShortHashCode id
The new id which will replace the senders id in a room.
struct GNUNET_CRYPTO_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.

References add_store_member(), GNUNET_MESSENGER_Message::body, check_member_session_completion(), GNUNET_MESSENGER_MemberSession::closed, GNUNET_MESSENGER_MemberSession::completed, GNUNET_MESSENGER_MemberSession::contact, GNUNET_MESSENGER_MemberSession::context, copy_list_messages(), get_context_from_member(), get_member_contact_store(), get_member_session_contact(), get_member_session_context(), get_member_session_id(), get_member_session_key(), get_member_session_public_key(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_free, GNUNET_memcpy, GNUNET_MESSENGER_KIND_ID, GNUNET_MESSENGER_KIND_KEY, GNUNET_new, GNUNET_NO, GNUNET_TIME_absolute_get(), GNUNET_YES, GNUNET_MESSENGER_Message::header, GNUNET_MESSENGER_MemberSession::history, GNUNET_MESSENGER_MessageId::id, GNUNET_MESSENGER_MessageBody::id, increase_contact_rc(), init_list_messages(), iterate_copy_history(), GNUNET_MESSENGER_MessageKey::key, GNUNET_MESSENGER_MessageBody::key, GNUNET_MESSENGER_MessageHeader::kind, GNUNET_MESSENGER_MemberSession::member, GNUNET_MESSENGER_MemberSession::messages, GNUNET_MESSENGER_MemberSession::next, GNUNET_MESSENGER_MemberSession::prev, GNUNET_MESSENGER_MemberSession::public_key, GNUNET_MESSENGER_MemberSession::start, GNUNET_MESSENGER_Member::store, and update_store_contact().

Referenced by handle_member_session_switch().

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

◆ destroy_member_session()

void destroy_member_session ( struct GNUNET_MESSENGER_MemberSession session)

Destroys a member session and frees its memory fully.

Parameters
[in,out]sessionMember session

Definition at line 268 of file gnunet-service-messenger_member_session.c.

269 {
270  GNUNET_assert (session);
271 
273 
274  clear_list_messages (&(session->messages));
275 
277  session);
278 
279  if ((contact) && (GNUNET_YES == decrease_contact_rc (contact)))
282  contact,
284  );
285 
286  GNUNET_free (session);
287 }
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.

References clear_list_messages(), decrease_contact_rc(), get_member_contact_store(), get_member_session_contact(), get_member_session_context(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_free, GNUNET_YES, GNUNET_MESSENGER_MemberSession::history, GNUNET_MESSENGER_MemberSession::member, GNUNET_MESSENGER_MemberSession::messages, remove_store_contact(), and GNUNET_MESSENGER_Member::store.

Referenced by iterate_destroy_session(), and remove_room_member_session().

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

◆ reset_member_session()

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.

Every connection to other sessions will be be dropped. The member sessions messages will be cleared but old history from uncompleted sessions however can be reused!

Parameters
[in,out]sessionMember session
[in]hashHash of initial message (JOIN message!)
Returns
GNUNET_OK on success, GNUNET_SYSERR otherwise

Definition at line 291 of file gnunet-service-messenger_member_session.c.

293 {
294  GNUNET_assert ((session) && (hash));
295 
297  session->member->store);
298  struct GNUNET_MESSENGER_Contact *contact = get_store_contact (
299  store,
300  get_member_session_context (session),
302  );
303 
304  if (! contact)
305  return GNUNET_SYSERR;
306 
307  if (contact == session->contact)
308  goto clear_messages;
309 
310  session->contact = contact;
311  increase_contact_rc (session->contact);
312 
313 clear_messages:
314  clear_list_messages (&(session->messages));
315  add_to_list_messages (&(session->messages), hash);
316 
317  session->next = NULL;
318  session->closed = GNUNET_NO;
319  session->completed = GNUNET_NO;
320 
321  return GNUNET_OK;
322 }
@ GNUNET_OK
@ GNUNET_SYSERR

References add_to_list_messages(), clear_list_messages(), GNUNET_MESSENGER_MemberSession::closed, GNUNET_MESSENGER_MemberSession::completed, GNUNET_MESSENGER_MemberSession::contact, get_member_contact_store(), get_member_session_context(), get_member_session_public_key(), get_store_contact(), GNUNET_assert, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, increase_contact_rc(), GNUNET_MESSENGER_MemberSession::member, GNUNET_MESSENGER_MemberSession::messages, GNUNET_MESSENGER_MemberSession::next, and GNUNET_MESSENGER_Member::store.

Referenced by handle_message_join().

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

◆ close_member_session()

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.

Closing a session may complete a session and can't be used without a reset! (

See also
reset_member_session() )
Parameters
[in,out]sessionMember session

Definition at line 326 of file gnunet-service-messenger_member_session.c.

327 {
328  GNUNET_assert (session);
329 
330  session->closed = GNUNET_YES;
332 }

References check_member_session_completion(), GNUNET_MESSENGER_MemberSession::closed, GNUNET_assert, and GNUNET_YES.

Referenced by handle_message_leave().

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

◆ is_member_session_closed()

int is_member_session_closed ( const struct GNUNET_MESSENGER_MemberSession session)

Returns if the given member session has been closed.

Parameters
[in]sessionMember session
Returns
GNUNET_YES or GNUNET_NO

Definition at line 336 of file gnunet-service-messenger_member_session.c.

337 {
338  GNUNET_assert (session);
339 
340  return session->closed;
341 }

References GNUNET_MESSENGER_MemberSession::closed, and GNUNET_assert.

◆ is_member_session_completed()

int is_member_session_completed ( const struct GNUNET_MESSENGER_MemberSession session)

Returns if the given member session has been completed.

A completed member session can't verify any message as its own and it won't add any message to its history.

Parameters
[in]sessionMember session
Returns
GNUNET_YES or GNUNET_NO

Definition at line 345 of file gnunet-service-messenger_member_session.c.

347 {
348  GNUNET_assert (session);
349 
350  return session->completed;
351 }

Referenced by check_member_session_completion(), iterate_forward_members(), iterate_notify_about_members(), iterate_update_member_sessions(), update_member_session_history(), and verify_member_session_as_sender().

Here is the caller graph for this function:

◆ get_member_session_start()

struct GNUNET_TIME_Absolute get_member_session_start ( const struct GNUNET_MESSENGER_MemberSession session)

Returns the timestamp of the member session's start.

Parameters
[in]sessionMember session
Returns
Absolute timestamp

Definition at line 345 of file gnunet-service-messenger_member_session.c.

356 {
357  GNUNET_assert (session);
358 
359  if (session->prev)
360  return get_member_session_start (session->prev);
361 
362  return session->start;
363 }
struct GNUNET_TIME_Absolute get_member_session_start(const struct GNUNET_MESSENGER_MemberSession *session)
Returns the timestamp of the member session's start.

References GNUNET_MESSENGER_MemberSession::completed, and GNUNET_assert.

Referenced by solve_srv_room_member_collisions().

Here is the caller graph for this function:

◆ get_member_session_key()

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.

Parameters
[in]sessionMember session
Returns
Key of room

Definition at line 367 of file gnunet-service-messenger_member_session.c.

368 {
369  GNUNET_assert ((session) && (session->member));
370 
371  return get_member_store_key (session->member->store);
372 }
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.

References get_member_store_key(), GNUNET_assert, GNUNET_MESSENGER_MemberSession::member, and GNUNET_MESSENGER_Member::store.

Referenced by create_member_session(), and switch_member_session().

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

◆ get_member_session_id()

const struct GNUNET_ShortHashCode* get_member_session_id ( const struct GNUNET_MESSENGER_MemberSession session)

Returns the member id of a given member session.

Parameters
[in]sessionMember session
Returns
Member id

Definition at line 376 of file gnunet-service-messenger_member_session.c.

377 {
378  GNUNET_assert (session);
379 
380  return get_member_id (session->member);
381 }
const struct GNUNET_ShortHashCode * get_member_id(const struct GNUNET_MESSENGER_Member *member)
Returns the current id of a given member.

References get_member_id(), GNUNET_assert, and GNUNET_MESSENGER_MemberSession::member.

Referenced by check_member_session_completion(), create_member_session(), delete_srv_room_message(), find_member_session_in_room(), remove_room_member_session(), switch_member_session(), update_member_session_history(), and verify_member_session_as_sender().

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

◆ get_member_session_public_key()

const struct GNUNET_CRYPTO_PublicKey* get_member_session_public_key ( const struct GNUNET_MESSENGER_MemberSession session)

Returns the public key of a given member session.

Parameters
[in]sessionMember session
Returns
Public key

Definition at line 385 of file gnunet-service-messenger_member_session.c.

387 {
388  GNUNET_assert (session);
389 
390  return &(session->public_key);
391 }

References GNUNET_assert, and GNUNET_MESSENGER_MemberSession::public_key.

Referenced by add_member_session(), create_member_session(), handle_message_id(), iterate_member_sessions_it(), remove_member_session(), remove_room_member_session(), reset_member_session(), switch_member_session(), and verify_member_session_as_sender().

Here is the caller graph for this function:

◆ get_member_session_context()

const struct GNUNET_HashCode* get_member_session_context ( const struct GNUNET_MESSENGER_MemberSession session)

Returns the member context of a given member session.

Parameters
[in]sessionMember session
Returns
Member context as hash

Definition at line 395 of file gnunet-service-messenger_member_session.c.

397 {
398  GNUNET_assert (session);
399 
400  return &(session->context);
401 }

References GNUNET_MESSENGER_MemberSession::context, and GNUNET_assert.

Referenced by check_member_session_completion(), create_member_session(), destroy_member_session(), get_next_member_session_context(), reset_member_session(), and switch_member_session().

Here is the caller graph for this function:

◆ get_member_session_contact()

struct GNUNET_MESSENGER_Contact* get_member_session_contact ( struct GNUNET_MESSENGER_MemberSession session)

Returns the contact which is connected to a given member session.

Parameters
[in]sessionMember session
Returns
Contact

Definition at line 405 of file gnunet-service-messenger_member_session.c.

406 {
407  GNUNET_assert (session);
408 
409  return session->contact;
410 }

References GNUNET_MESSENGER_MemberSession::contact, and GNUNET_assert.

Referenced by destroy_member_session(), handle_message_name(), and switch_member_session().

Here is the caller graph for this function:

◆ verify_member_session_as_sender()

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.

The function returns GNUNET_OK if the message session is verified as sender, otherwise GNUNET_SYSERR.

See also
is_member_session_completed() for verification.
Parameters
[in]sessionMember session
[in]messageMessage
[in]hashHash of message
Returns
GNUNET_OK on success, otherwise GNUNET_SYSERR

Definition at line 414 of file gnunet-service-messenger_member_session.c.

418 {
419  GNUNET_assert ((session) && (message) && (hash));
420 
421  if (GNUNET_YES == is_member_session_completed (session))
422  return GNUNET_SYSERR;
423 
424  if (0 != GNUNET_memcmp (get_member_session_id (session),
425  &(message->header.sender_id)))
426  return GNUNET_SYSERR;
427 
428  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Check message (%s) using key: %s\n",
429  GNUNET_h2s (hash),
431  get_member_session_public_key (session)));
432 
433  return verify_message (message, hash, get_member_session_public_key (
434  session));
435 }
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
char * GNUNET_CRYPTO_public_key_to_string(const struct GNUNET_CRYPTO_PublicKey *key)
Creates a (Base32) string representation of the public key.
Definition: crypto_pkey.c:548
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
int verify_message(const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash, const struct GNUNET_CRYPTO_PublicKey *key)
Verifies the signature of a given message and its hash with a specific public key.
struct GNUNET_ShortHashCode sender_id
The senders id inside of the room the message was sent in.

References get_member_session_id(), get_member_session_public_key(), GNUNET_assert, GNUNET_CRYPTO_public_key_to_string(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_memcmp, GNUNET_SYSERR, GNUNET_YES, GNUNET_MESSENGER_Message::header, is_member_session_completed(), GNUNET_MESSENGER_MessageHeader::sender_id, and verify_message().

Referenced by iterate_search_session(), and update_member_session_history().

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

◆ check_member_session_history()

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 ownership flag is set, if the message is owned by the sessions contact.

Parameters
[in]sessionMember session
[in]hashHash of message
[in]ownershipOwnership flag
Returns
GNUNET_YES if found, otherwise GNUNET_NO

Definition at line 439 of file gnunet-service-messenger_member_session.c.

442 {
443  GNUNET_assert ((session) && (hash));
444 
445  if (GNUNET_YES == ownership)
446  return (NULL != GNUNET_CONTAINER_multihashmap_get (session->history, hash)?
448  else
449  return GNUNET_CONTAINER_multihashmap_contains (session->history, hash);
450 }
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).
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.

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_contains(), GNUNET_CONTAINER_multihashmap_get(), GNUNET_NO, GNUNET_YES, and GNUNET_MESSENGER_MemberSession::history.

Referenced by check_member_session_completion(), delete_srv_room_message(), notify_about_members(), recv_message_request(), and request_room_message_step().

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

◆ update_member_chain_history()

static void update_member_chain_history ( struct GNUNET_MESSENGER_MemberSession session,
const struct GNUNET_HashCode hash,
int  ownership 
)
static

Definition at line 454 of file gnunet-service-messenger_member_session.c.

456 {
457  GNUNET_assert ((session) && (hash));
458 
459  if ((GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (session->history, hash,
460  (GNUNET_YES == ownership?
461  session : NULL),
463  && (session->next))
464  update_member_chain_history (session->next, hash, ownership);
465 }
static void update_member_chain_history(struct GNUNET_MESSENGER_MemberSession *session, const struct GNUNET_HashCode *hash, int ownership)

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_OK, GNUNET_YES, GNUNET_MESSENGER_MemberSession::history, and GNUNET_MESSENGER_MemberSession::next.

Referenced by update_member_session_history().

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

◆ update_member_session_history()

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.

The ownership will be set automatically.

See also
is_member_session_completed() for updating a history.
Parameters
[in,out]sessionMember session
[in]messageMessage
[in]hashHash of message

Definition at line 469 of file gnunet-service-messenger_member_session.c.

472 {
473  GNUNET_assert ((session) && (message) && (hash));
474 
475  if (GNUNET_YES == is_member_session_completed (session))
476  return;
477 
479  "Updating sessions history (%s) += (%s)\n",
480  GNUNET_sh2s (get_member_session_id (session)), GNUNET_h2s (hash));
481 
482  if (GNUNET_OK == verify_member_session_as_sender (session, message, hash))
483  {
484  if (GNUNET_YES == is_message_session_bound (message))
485  add_to_list_messages (&(session->messages), hash);
486 
487  update_member_chain_history (session, hash, GNUNET_YES);
488  }
489  else
490  update_member_chain_history (session, hash, GNUNET_NO);
491 
492  if (GNUNET_YES == session->closed)
494 }
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.
int is_message_session_bound(const struct GNUNET_MESSENGER_Message *message)
Returns if the message should be bound to a member session.

References add_to_list_messages(), check_member_session_completion(), GNUNET_MESSENGER_MemberSession::closed, get_member_session_id(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_sh2s(), GNUNET_YES, is_member_session_completed(), is_message_session_bound(), GNUNET_MESSENGER_MemberSession::messages, update_member_chain_history(), and verify_member_session_as_sender().

Referenced by iterate_update_member_sessions().

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

◆ clear_member_chain_history()

static void clear_member_chain_history ( struct GNUNET_MESSENGER_MemberSession session,
const struct GNUNET_HashCode hash 
)
static

Definition at line 498 of file gnunet-service-messenger_member_session.c.

500 {
501  GNUNET_assert ((session) && (hash));
502 
503  if ((0 < GNUNET_CONTAINER_multihashmap_remove_all (session->history, hash)) &&
504  (session->next))
505  clear_member_session_history (session->next, hash);
506 }
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.
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.

References clear_member_session_history(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_remove_all(), GNUNET_MESSENGER_MemberSession::history, and GNUNET_MESSENGER_MemberSession::next.

Referenced by clear_member_session_history().

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

◆ clear_member_session_history()

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.

Parameters
[in,out]sessionMember session
[in]hashHash of message

Definition at line 510 of file gnunet-service-messenger_member_session.c.

512 {
513  GNUNET_assert ((session) && (hash));
514 
515  clear_member_chain_history (session, hash);
516 }
static void clear_member_chain_history(struct GNUNET_MESSENGER_MemberSession *session, const struct GNUNET_HashCode *hash)

References clear_member_chain_history(), and GNUNET_assert.

Referenced by clear_member_chain_history().

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

◆ load_member_session_history()

static void load_member_session_history ( struct GNUNET_MESSENGER_MemberSession session,
const char *  path 
)
static

Definition at line 526 of file gnunet-service-messenger_member_session.c.

528 {
529  GNUNET_assert ((session) && (path));
530 
531  if (GNUNET_YES != GNUNET_DISK_file_test (path))
532  return;
533 
536 
538  path, GNUNET_DISK_OPEN_READ, permission
539  );
540 
541  if (! handle)
542  return;
543 
545 
547  ssize_t len;
548 
549  int status;
550 
551  do {
552  len = GNUNET_DISK_file_read (handle, &(entry.hash), sizeof(entry.hash));
553 
554  if (len != sizeof(entry.hash))
555  break;
556 
557  len = GNUNET_DISK_file_read (handle, &(entry.ownership),
558  sizeof(entry.ownership));
559 
560  if (len != sizeof(entry.ownership))
561  break;
562 
563  status = GNUNET_CONTAINER_multihashmap_put (session->history, &(entry.hash),
564  (entry.ownership? session :
565  NULL),
567  } while (status == GNUNET_OK);
568 
570 }
static int status
The program status; 0 for success.
Definition: gnunet-nse.c:38
static struct GNUNET_VPN_Handle * handle
Handle to vpn service.
Definition: gnunet-vpn.c:35
struct GNUNET_DISK_FileHandle * GNUNET_DISK_file_open(const char *fn, enum GNUNET_DISK_OpenFlags flags, enum GNUNET_DISK_AccessPermissions perm)
Open a file.
Definition: disk.c:1237
enum GNUNET_GenericReturnValue GNUNET_DISK_file_test(const char *fil)
Check that fil corresponds to a filename (of a file that exists and that is not a directory).
Definition: disk.c:482
off_t GNUNET_DISK_file_seek(const struct GNUNET_DISK_FileHandle *h, off_t offset, enum GNUNET_DISK_Seek whence)
Move the read/write pointer in a file.
Definition: disk.c:205
GNUNET_DISK_AccessPermissions
File access permissions, UNIX-style.
enum GNUNET_GenericReturnValue GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1308
ssize_t GNUNET_DISK_file_read(const struct GNUNET_DISK_FileHandle *h, void *result, size_t len)
Read the contents of a binary file into a buffer.
Definition: disk.c:622
@ GNUNET_DISK_OPEN_READ
Open the file for reading.
@ GNUNET_DISK_PERM_USER_READ
Owner can read.
@ GNUNET_DISK_PERM_USER_WRITE
Owner can write.
@ GNUNET_DISK_SEEK_SET
Seek an absolute position (from the start of the file).
Handle used to access files (and pipes).

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST, GNUNET_DISK_file_close(), GNUNET_DISK_file_open(), GNUNET_DISK_file_read(), GNUNET_DISK_file_seek(), GNUNET_DISK_file_test(), GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_DISK_SEEK_SET, GNUNET_OK, GNUNET_YES, handle, GNUNET_MESSENGER_MemberSessionHistoryEntry::hash, GNUNET_MESSENGER_MemberSession::history, GNUNET_MESSENGER_MemberSessionHistoryEntry::ownership, and status.

Referenced by load_member_session().

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

◆ load_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 required information can be read from the content of the given directory.

Parameters
[out]memberMember
[in]directoryPath to a directory

Definition at line 574 of file gnunet-service-messenger_member_session.c.

576 {
577  GNUNET_assert ((member) && (directory));
578 
579  char *config_file;
580  GNUNET_asprintf (&config_file, "%s%s", directory, "session.cfg");
581 
582  struct GNUNET_MESSENGER_MemberSession *session = NULL;
583 
585  goto free_config;
586 
588  "Load session configuration of member: %s\n", config_file);
589 
591 
593  {
594  char *key_data;
595 
597  "key", &key_data))
598  goto destroy_config;
599 
601 
602  enum GNUNET_GenericReturnValue key_return =
604 
605  GNUNET_free (key_data);
606 
607  if (GNUNET_OK != key_return)
608  goto destroy_config;
609 
610  session = create_member_session (member, &key);
611 
612  unsigned long long numeric_value;
613 
615  "start",
616  &numeric_value))
617  session->start.abs_value_us = numeric_value;
618 
620  "closed",
621  &numeric_value))
622  session->closed = (GNUNET_YES == numeric_value? GNUNET_YES : GNUNET_NO);
623 
625  "completed",
626  &numeric_value))
627  session->completed = (GNUNET_YES == numeric_value? GNUNET_YES :
628  GNUNET_NO);
629  }
630 
631 destroy_config:
633 
634 free_config:
636 
637  if (! session)
638  return;
639 
640  char *history_file;
641  GNUNET_asprintf (&history_file, "%s%s", directory, "history.map");
642 
643  load_member_session_history (session, history_file);
644  GNUNET_free (history_file);
645 
646  char *messages_file;
647  GNUNET_asprintf (&messages_file, "%s%s", directory, "messages.list");
648 
649  load_list_messages (&(session->messages), messages_file);
650  GNUNET_free (messages_file);
651 
652  add_member_session (member, session);
653 }
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:109
static char * config_file
Set to the name of the config file used.
Definition: gnunet-arm.c:84
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 add_member_session(struct GNUNET_MESSENGER_Member *member, struct GNUNET_MESSENGER_MemberSession *session)
Adds a given member session to its member.
static void load_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_CRYPTO_PublicKey *pubkey)
Creates and allocates a new member session of a member with a given public key.
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.
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.
GNUNET_GenericReturnValue
Named constants for return values.
enum GNUNET_GenericReturnValue GNUNET_CRYPTO_public_key_from_string(const char *str, struct GNUNET_CRYPTO_PublicKey *key)
Parses a (Base32) string representation of the public key.
Definition: crypto_pkey.c:568
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
An identity key as per LSD0001.
uint64_t abs_value_us
The actual value.

References GNUNET_TIME_Absolute::abs_value_us, add_member_session(), cfg, GNUNET_MESSENGER_MemberSession::closed, GNUNET_MESSENGER_MemberSession::completed, config_file, create_member_session(), GNUNET_asprintf(), GNUNET_assert, GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_destroy(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_parse(), GNUNET_CRYPTO_public_key_from_string(), GNUNET_DISK_file_test(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_YES, key, load_list_messages(), load_member_session_history(), GNUNET_MESSENGER_MemberSession::messages, and GNUNET_MESSENGER_MemberSession::start.

Referenced by callback_scan_for_sessions().

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

◆ get_cycle_safe_next_session()

static struct GNUNET_MESSENGER_MemberSession* get_cycle_safe_next_session ( struct GNUNET_MESSENGER_MemberSession session,
struct GNUNET_MESSENGER_MemberSession next 
)
static

Definition at line 657 of file gnunet-service-messenger_member_session.c.

659 {
660  if (! next)
661  return NULL;
662 
663  struct GNUNET_MESSENGER_MemberSession *check = next;
664 
665  do {
666  if (check == session)
667  return NULL;
668 
669  check = check->next;
670  } while (check);
671 
672  return next;
673 }

References GNUNET_MESSENGER_MemberSession::next.

Referenced by load_member_session_next().

Here is the caller graph for this function:

◆ load_member_session_next()

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.

Necessary information will be loaded from a configuration file inside of a given directory.

Parameters
[in,out]sessionMember session
[in]directoryPath to a directory

Definition at line 677 of file gnunet-service-messenger_member_session.c.

679 {
680  GNUNET_assert ((session) && (directory));
681 
682  char *config_file;
683  GNUNET_asprintf (&config_file, "%s%s", directory, "session.cfg");
684 
686  goto free_config;
687 
689  "Load next session configuration of member: %s\n", config_file);
690 
692 
694  {
695  char *key_data;
696 
698  "next_key",
699  &key_data))
700  goto destroy_config;
701 
702  struct GNUNET_CRYPTO_PublicKey next_key;
703 
704  enum GNUNET_GenericReturnValue key_return =
705  GNUNET_CRYPTO_public_key_from_string (key_data, &next_key);
706 
707  GNUNET_free (key_data);
708 
709  if (GNUNET_OK != key_return)
710  goto destroy_config;
711 
713 
714  if (GNUNET_OK != GNUNET_CONFIGURATION_get_data (cfg, "session", "next_id",
715  &next_id, sizeof(next_id)))
716  goto destroy_config;
717 
718  struct GNUNET_MESSENGER_Member *member = get_store_member (
719  session->member->store, &next_id);
720 
721  session->next = get_cycle_safe_next_session (
722  session, member? get_member_session (member, &next_key) : NULL
723  );
724 
725  if (session->next)
726  session->next->prev = session;
727  }
728 
729 destroy_config:
731 
732 free_config:
734 }
static char * next_id
Command-line option for namespace publishing: identifier for updates to this publication.
struct GNUNET_MESSENGER_MemberSession * get_member_session(const struct GNUNET_MESSENGER_Member *member, const struct GNUNET_CRYPTO_PublicKey *public_key)
Returns the member session of a member identified by a given public key.
static struct GNUNET_MESSENGER_MemberSession * get_cycle_safe_next_session(struct GNUNET_MESSENGER_MemberSession *session, struct GNUNET_MESSENGER_MemberSession *next)
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.
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.
A 256-bit hashcode.

References cfg, config_file, get_cycle_safe_next_session(), get_member_session(), get_store_member(), GNUNET_asprintf(), GNUNET_assert, GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_destroy(), GNUNET_CONFIGURATION_get_data(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_parse(), GNUNET_CRYPTO_public_key_from_string(), GNUNET_DISK_file_test(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_OK, GNUNET_YES, GNUNET_MESSENGER_MemberSession::member, GNUNET_MESSENGER_MemberSession::next, next_id, GNUNET_MESSENGER_MemberSession::prev, and GNUNET_MESSENGER_Member::store.

Referenced by iterate_load_next_session().

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

◆ iterate_save_member_session_history_hentries()

static int iterate_save_member_session_history_hentries ( void *  cls,
const struct GNUNET_HashCode key,
void *  value 
)
static

Definition at line 738 of file gnunet-service-messenger_member_session.c.

741 {
742  struct GNUNET_DISK_FileHandle *handle = cls;
743  unsigned char ownership = value? GNUNET_YES : GNUNET_NO;
744 
745  GNUNET_DISK_file_write (handle, key, sizeof(*key));
746  GNUNET_DISK_file_write (handle, &ownership, sizeof(ownership));
747 
748  return GNUNET_YES;
749 }
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

References GNUNET_DISK_file_write(), GNUNET_NO, GNUNET_YES, handle, key, and value.

Referenced by save_member_session_history().

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

◆ save_member_session_history()

static void save_member_session_history ( struct GNUNET_MESSENGER_MemberSession session,
const char *  path 
)
static

Definition at line 753 of file gnunet-service-messenger_member_session.c.

755 {
756  GNUNET_assert ((session) && (path));
757 
760 
763  );
764 
765  if (! handle)
766  return;
767 
769 
771  session->history,
773  handle
774  );
775 
778 }
static int iterate_save_member_session_history_hentries(void *cls, const struct GNUNET_HashCode *key, void *value)
enum GNUNET_GenericReturnValue GNUNET_DISK_file_sync(const struct GNUNET_DISK_FileHandle *h)
Write file changes to disk.
Definition: disk.c:1427
@ GNUNET_DISK_OPEN_WRITE
Open the file for writing.
@ GNUNET_DISK_OPEN_CREATE
Create file if it doesn't exist.

References GNUNET_assert, GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_DISK_file_close(), GNUNET_DISK_file_open(), GNUNET_DISK_file_seek(), GNUNET_DISK_file_sync(), GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_OPEN_WRITE, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_DISK_SEEK_SET, handle, GNUNET_MESSENGER_MemberSession::history, and iterate_save_member_session_history_hentries().

Here is the call graph for this function:

◆ save_member_session()

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 completely.

Parameters
[in]sessionMember session
[in]directoryPath to a directory

Definition at line 782 of file gnunet-service-messenger_member_session.c.

784 {
785  GNUNET_assert ((session) && (directory));
786 
787  char *config_file;
788  GNUNET_asprintf (&config_file, "%s%s", directory, "session.cfg");
789 
791  "Save session configuration of member: %s\n", config_file);
792 
794 
795  char *key_data = GNUNET_CRYPTO_public_key_to_string (
797 
798  if (key_data)
799  {
800  GNUNET_CONFIGURATION_set_value_string (cfg, "session", "key", key_data);
801 
802  GNUNET_free (key_data);
803  }
804 
805  if (session->next)
806  {
808  session->next);
809 
810  char *next_id_data = GNUNET_STRINGS_data_to_string_alloc (next_id,
811  sizeof(*next_id));
812 
813  if (next_id_data)
814  {
815  GNUNET_CONFIGURATION_set_value_string (cfg, "session", "next_id",
816  next_id_data);
817 
818  GNUNET_free (next_id_data);
819  }
820 
823 
824  if (key_data)
825  {
826  GNUNET_CONFIGURATION_set_value_string (cfg, "session", "next_key",
827  key_data);
828 
829  GNUNET_free (key_data);
830  }
831  }
832 
833  GNUNET_CONFIGURATION_set_value_number (cfg, "session", "start",
834  session->start.abs_value_us);
835 
836  GNUNET_CONFIGURATION_set_value_number (cfg, "session", "closed",
837  session->closed);
838  GNUNET_CONFIGURATION_set_value_number (cfg, "session", "completed",
839  session->completed);
840 
843 
845 
846  char *history_file;
847  GNUNET_asprintf (&history_file, "%s%s", directory, "history.map");
848 
849  save_member_session_history (session, history_file);
850  GNUNET_free (history_file);
851 
852  char *messages_file;
853  GNUNET_asprintf (&messages_file, "%s%s", directory, "messages.list");
854 
855  save_list_messages (&(session->messages), messages_file);
856  GNUNET_free (messages_file);
857 }
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.
static void save_member_session_history(struct GNUNET_MESSENGER_MemberSession *session, const char *path)
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.
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_write(struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename)
Write configuration file.
char * GNUNET_STRINGS_data_to_string_alloc(const void *buf, size_t size)
Return the base32crockford encoding of the given buffer.
Definition: strings.c:764

Referenced by iterate_save_session().

Here is the caller graph for this function: