GNUnet  0.17.6
gnunet-service-messenger_handle.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2020--2022 GNUnet e.V.
4 
5  GNUnet is free software: you can redistribute it and/or modify it
6  under the terms of the GNU Affero General Public License as published
7  by the Free Software Foundation, either version 3 of the License,
8  or (at your option) any later version.
9 
10  GNUnet is distributed in the hope that it will be useful, but
11  WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13  Affero General Public License for more details.
14 
15  You should have received a copy of the GNU Affero General Public License
16  along with this program. If not, see <http://www.gnu.org/licenses/>.
17 
18  SPDX-License-Identifier: AGPL3.0-or-later
19  */
27 
30 
31 #include "messenger_api_util.h"
32 
35  struct GNUNET_MQ_Handle *mq)
36 {
37  GNUNET_assert((service) && (mq));
38 
40 
41  handle->service = service;
42  handle->mq = mq;
43 
44  handle->name = NULL;
45  handle->ego = NULL;
46 
48 
49  return handle;
50 }
51 
52 int
54  const struct GNUNET_HashCode *key,
55  void *value)
56 {
58 
59  return GNUNET_YES;
60 }
61 
62 void
64 {
66 
67  if (handle->service->dir)
69 
70  if (handle->name)
71  {
72  struct GNUNET_MESSENGER_EgoStore *store = get_service_ego_store(handle->service);
73 
74  unbind_store_ego(store, handle->name, handle);
75 
76  GNUNET_free(handle->name);
77  }
78 
81 
83 }
84 
85 void
87  const char *name,
88  char **dir)
89 {
90  GNUNET_assert((handle) && (dir));
91 
92  if (name)
93  GNUNET_asprintf (dir, "%s%s%c%s%c", handle->service->dir, "identities",
95  else
96  GNUNET_asprintf (dir, "%s%s%c", handle->service->dir, "anonymous",
98 }
99 
100 static int
102  const struct GNUNET_HashCode *key)
103 {
104  GNUNET_assert((handle) && (key));
105 
106  struct GNUNET_ShortHashCode *random_id = GNUNET_new(struct GNUNET_ShortHashCode);
107 
108  if (!random_id)
109  return GNUNET_NO;
110 
111  generate_free_member_id (random_id, NULL);
112 
113  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (handle->member_ids, key, random_id,
115  {
116  GNUNET_free(random_id);
117  return GNUNET_NO;
118  }
119 
120  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Created a new member id (%s) for room: %s\n", GNUNET_sh2s (random_id),
121  GNUNET_h2s (key));
122 
123  return GNUNET_YES;
124 }
125 
126 const struct GNUNET_ShortHashCode*
128  const struct GNUNET_HashCode *key)
129 {
130  GNUNET_assert((handle) && (key));
131 
132  return GNUNET_CONTAINER_multihashmap_get (handle->member_ids, key);
133 }
134 
135 int
137  const struct GNUNET_HashCode *key,
138  const struct GNUNET_ShortHashCode *unique_id)
139 {
140  GNUNET_assert((handle) && (key) && (unique_id));
141 
142  struct GNUNET_ShortHashCode *member_id = GNUNET_CONTAINER_multihashmap_get (handle->member_ids, key);
143 
144  if (!member_id)
145  {
146  member_id = GNUNET_new(struct GNUNET_ShortHashCode);
147  GNUNET_memcpy(member_id, unique_id, sizeof(*member_id));
148 
149  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (handle->member_ids, key, member_id,
151  {
152  GNUNET_free(member_id);
153  return GNUNET_SYSERR;
154  }
155  }
156 
157  if (0 == GNUNET_memcmp(unique_id, member_id))
158  goto send_message_to_client;
159 
160  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Change a member id (%s) for room (%s).\n", GNUNET_sh2s (member_id),
161  GNUNET_h2s (key));
162 
163  GNUNET_memcpy(member_id, unique_id, sizeof(*unique_id));
164 
165  GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Member id changed to (%s).\n", GNUNET_sh2s (unique_id));
166 
168  struct GNUNET_MQ_Envelope *env;
169 
170 send_message_to_client:
171 
173 
174  GNUNET_memcpy(&(msg->key), key, sizeof(*key));
175  GNUNET_memcpy(&(msg->id), member_id, sizeof(*member_id));
176 
178  return GNUNET_OK;
179 }
180 
181 static void
183  const char *name)
184 {
186 
187  if (handle->name)
188  GNUNET_free(handle->name);
189 
190  handle->name = name ? GNUNET_strdup(name) : NULL;
191 
192  const uint16_t name_len = handle->name ? strlen (handle->name) : 0;
193 
195  struct GNUNET_MQ_Envelope *env;
196 
198 
199  char *extra = ((char*) msg) + sizeof(*msg);
200 
201  if (name_len)
202  GNUNET_memcpy(extra, handle->name, name_len);
203 
204  extra[name_len] = '\0';
205 
207 }
208 
209 static void
211  const struct GNUNET_MESSENGER_Ego *ego)
212 {
214 
215  handle->ego = ego;
216 
217  ego = get_srv_handle_ego (handle);
218 
219  const uint16_t length = GNUNET_IDENTITY_key_get_length(&(ego->pub));
220 
222  struct GNUNET_MQ_Envelope *env;
223 
225 
226  char *extra = ((char*) msg) + sizeof(*msg);
227 
228  if (GNUNET_IDENTITY_write_key_to_buffer(&(ego->pub), extra, length) < 0)
229  GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Could not write key to buffer.\n");
230 
232 }
233 
235 {
238 };
239 
240 static int
242  const struct GNUNET_HashCode *key,
243  void *value)
244 {
245  struct GNUNET_MESSENGER_MessageHandle *msg_handle = cls;
246 
247  send_srv_handle_message (msg_handle->handle, key, msg_handle->message);
248 
249  return GNUNET_YES;
250 }
251 
252 void
254  const struct GNUNET_MESSENGER_Ego *ego)
255 {
256  GNUNET_assert((handle) && (ego));
257 
258  struct GNUNET_MESSENGER_MessageHandle msg_handle;
259 
260  msg_handle.handle = handle;
261  msg_handle.message = create_message_key (&(ego->priv));
262 
264 
265  destroy_message (msg_handle.message);
266 
267  change_handle_ego (handle, ego);
268 }
269 
270 const struct GNUNET_MESSENGER_Ego*
272 {
274 
275  static struct GNUNET_MESSENGER_Ego anonymous;
276  static int read_keys = 0;
277 
278  if (handle->ego)
279  return handle->ego;
280 
281  if (!read_keys)
282  {
284  GNUNET_memcpy(&(anonymous.priv), GNUNET_IDENTITY_ego_get_private_key (ego), sizeof(anonymous.priv));
285  GNUNET_IDENTITY_ego_get_public_key (ego, &(anonymous.pub));
286  read_keys = 1;
287  }
288 
289  return &anonymous;
290 }
291 
292 static void
294  const char *name,
295  const struct GNUNET_MESSENGER_Ego *ego)
296 {
297  struct GNUNET_MESSENGER_SrvHandle *handle = cls;
298 
299  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Setting up handle...\n");
300 
303 
304  if (handle->service->dir)
306 }
307 
308 void
310  const char *name)
311 {
313 
314  struct GNUNET_MESSENGER_EgoStore *store = get_service_ego_store(handle->service);
315 
317 }
318 
319 static void
321  const char *name,
322  const struct GNUNET_MESSENGER_Ego *ego)
323 {
324  struct GNUNET_MESSENGER_SrvHandle *handle = cls;
325 
326  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Updating handle...\n");
327 
328  struct GNUNET_MESSENGER_EgoStore *store = get_service_ego_store(handle->service);
329 
330  bind_store_ego(store, handle->name, handle);
331 
332  if (!ego)
333  create_store_ego (store, handle->name);
334  else
335  renew_store_ego (store, handle->name);
336 }
337 
338 void
340 {
342 
343  if (!handle->name)
344  {
345  GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Updating handle failed: Name is required!\n");
346  return;
347  }
348 
349  struct GNUNET_MESSENGER_EgoStore *store = get_service_ego_store(handle->service);
350 
352 }
353 
354 static void
356  const char *name,
357  const struct GNUNET_MESSENGER_Ego *ego)
358 {
359  struct GNUNET_MESSENGER_SrvHandle *handle = cls;
360 
361  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Renaming handle...\n");
362 
363  if (ego)
364  {
365  GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Renaming handle failed: Name is occupied! (%s)\n", name);
366  return;
367  }
368 
369  struct GNUNET_MESSENGER_EgoStore *store = get_service_ego_store(handle->service);
370 
371  char *old_dir;
372  get_srv_handle_data_subdir (handle, handle->name, &old_dir);
373 
374  char *new_dir;
376 
377  if ((GNUNET_YES == GNUNET_DISK_directory_test (new_dir, GNUNET_NO)) &&
379  goto free_dirs;
380 
382  {
384 
385  if (0 != rename (old_dir, new_dir))
386  goto free_dirs;
387  }
388 
389  if (handle->ego)
390  rename_store_ego(store, handle->name, name);
391 
392  struct GNUNET_MESSENGER_MessageHandle msg_handle;
393  msg_handle.handle = handle;
394  msg_handle.message = create_message_name (name);
395 
397  destroy_message (msg_handle.message);
399 
400 free_dirs:
401  GNUNET_free(old_dir);
402  GNUNET_free(new_dir);
403 }
404 
405 void
407  const char *name)
408 {
410 
411  if (!name)
412  {
413  if (handle->ego)
414  GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Renaming handle failed: Name is required!\n");
415  else
417 
418  return;
419  }
420 
421  struct GNUNET_MESSENGER_EgoStore *store = get_service_ego_store(handle->service);
422 
424 }
425 
426 int
428  const struct GNUNET_HashCode *key)
429 {
430  GNUNET_assert((handle) && (key));
431 
433  return GNUNET_NO;
434 
435  return open_service_room (handle->service, handle, key);
436 }
437 
438 int
440  const struct GNUNET_PeerIdentity *door,
441  const struct GNUNET_HashCode *key)
442 {
443  GNUNET_assert((handle) && (door) && (key));
444 
446  return GNUNET_NO;
447 
448  return entry_service_room (handle->service, handle, door, key);
449 }
450 
451 int
453  const struct GNUNET_HashCode *key)
454 {
455  GNUNET_assert((handle) && (key));
456 
458  return GNUNET_NO;
459 
460  return close_service_room (handle->service, handle, key);
461 }
462 
463 int
465  const struct GNUNET_HashCode *key,
466  const struct GNUNET_MESSENGER_Message *message)
467 {
468  GNUNET_assert((handle) && (key) && (message));
469 
471 
472  if (!id)
473  {
474  GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "It is required to be a member of a room to send messages!\n");
475  return GNUNET_NO;
476  }
477 
478  struct GNUNET_MESSENGER_SrvRoom *room = get_service_room (handle->service, key);
479 
480  if (!room)
481  {
482  GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "The room (%s) is unknown!\n", GNUNET_h2s (key));
483  return GNUNET_NO;
484  }
485 
486  struct GNUNET_MESSENGER_Message *msg = copy_message(message);
487 
488  GNUNET_memcpy(&(msg->header.sender_id), id, sizeof(*id));
489 
490  return send_srv_room_message (room, handle, msg);
491 }
492 
493 static const struct GNUNET_HashCode*
495 {
496  if (session->next)
497  return get_next_member_session_contect (session->next);
498  else
499  return get_member_session_context(session);
500 }
501 
502 static const struct GNUNET_MESSENGER_MemberSession*
504  struct GNUNET_MESSENGER_SrvRoom *room,
505  const struct GNUNET_HashCode *key)
506 {
507  GNUNET_assert((handle) && (room) && (key) && (handle->service));
508 
510 
511  if (!id)
512  return NULL;
513 
515  struct GNUNET_MESSENGER_Member *member = get_store_member(store, id);
516 
517  const struct GNUNET_MESSENGER_Ego *ego = get_srv_handle_ego(handle);
518 
519  if (!ego)
520  return NULL;
521 
522  return get_member_session(member, &(ego->pub));
523 }
524 
525 void
527  struct GNUNET_MESSENGER_SrvRoom *room,
528  const struct GNUNET_MESSENGER_MemberSession *session,
529  const struct GNUNET_MESSENGER_Message *message,
530  const struct GNUNET_HashCode *hash)
531 {
532  GNUNET_assert((handle) && (room) && (session) && (message) && (hash));
533 
534  const struct GNUNET_HashCode *key = get_srv_room_key(room);
535 
536  if ((!handle->mq) || (!get_srv_handle_member_id (handle, key)))
537  {
538  GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Notifying client about message requires membership!\n");
539  return;
540  }
541 
542  const struct GNUNET_IDENTITY_PublicKey *pubkey = get_contact_key(session->contact);
543 
544  struct GNUNET_HashCode sender;
545  GNUNET_CRYPTO_hash(pubkey, sizeof(*pubkey), &sender);
546 
547  const struct GNUNET_HashCode *context = get_next_member_session_contect (session);
548 
549  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Notifying client about message: %s\n", GNUNET_h2s (hash));
550 
551  struct GNUNET_MESSENGER_Message *private_message = NULL;
552 
553  if (GNUNET_MESSENGER_KIND_PRIVATE == message->header.kind)
554  {
555  private_message = copy_message(message);
556 
557  if (GNUNET_YES != decrypt_message(private_message, &(get_srv_handle_ego(handle)->priv)))
558  {
559  destroy_message(private_message);
560  private_message = NULL;
561  }
562  else
563  message = private_message;
564  }
565 
567  struct GNUNET_MQ_Envelope *env;
568 
569  uint16_t length = get_message_size (message, GNUNET_YES);
570 
572 
573  GNUNET_memcpy(&(msg->key), key, sizeof(msg->key));
574  GNUNET_memcpy(&(msg->sender), &sender, sizeof(msg->sender));
575  GNUNET_memcpy(&(msg->context), context, sizeof(msg->context));
576  GNUNET_memcpy(&(msg->hash), hash, sizeof(msg->hash));
577 
578  msg->flags = (uint32_t) GNUNET_MESSENGER_FLAG_NONE;
579 
580  if (get_handle_member_session(handle, room, key) == session)
581  msg->flags |= (uint32_t) GNUNET_MESSENGER_FLAG_SENT;
582 
583  if (private_message)
584  msg->flags |= (uint32_t) GNUNET_MESSENGER_FLAG_PRIVATE;
585 
586  char *buffer = ((char*) msg) + sizeof(*msg);
587  encode_message (message, length, buffer, GNUNET_YES);
588 
589  if (private_message)
590  destroy_message(private_message);
591 
593 }
594 
595 static int
597  const char *filename)
598 {
599  struct GNUNET_MESSENGER_SrvHandle *handle = cls;
600 
601  if ((strlen(filename) <= 4) || (0 != strcmp(filename + strlen(filename) - 4, ".cfg")))
602  return GNUNET_OK;
603 
604  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Load room configuration of handle: %s\n", filename);
605 
607 
609  {
610  struct GNUNET_HashCode key;
611  struct GNUNET_ShortHashCode member_id;
612 
613  if ((GNUNET_OK == GNUNET_CONFIGURATION_get_data (cfg, "room", "key", &key, sizeof(key))) &&
614  (GNUNET_OK == GNUNET_CONFIGURATION_get_data (cfg, "room", "member_id", &member_id, sizeof(member_id))))
615  change_srv_handle_member_id (handle, &key, &member_id);
616  }
617 
619  return GNUNET_OK;
620 }
621 
622 void
624 {
626 
627  char *id_dir;
628  get_srv_handle_data_subdir (handle, handle->name, &id_dir);
629 
631  {
632  char *scan_dir;
633  GNUNET_asprintf (&scan_dir, "%s%s%c", id_dir, "rooms", DIR_SEPARATOR);
634 
637 
639  }
640 
641  GNUNET_free(id_dir);
642 }
643 
644 static int
646  const struct GNUNET_HashCode *key,
647  void *value)
648 {
649  struct GNUNET_MESSENGER_SrvHandle *handle = cls;
650  struct GNUNET_ShortHashCode *member_id = value;
651 
652  char *id_dir;
653  get_srv_handle_data_subdir (handle, handle->name, &id_dir);
654 
655  char *filename;
656  GNUNET_asprintf (&filename, "%s%s%c%s.cfg", id_dir, "rooms", DIR_SEPARATOR, GNUNET_h2s (key));
657  GNUNET_free(id_dir);
658 
659  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Save room configuration of handle: %s\n", filename);
660 
662 
663  char *key_data = GNUNET_STRINGS_data_to_string_alloc (key, sizeof(*key));
664 
665  if (key_data)
666  {
667  GNUNET_CONFIGURATION_set_value_string (cfg, "room", "key", key_data);
668 
669  GNUNET_free(key_data);
670  }
671 
672  char *member_id_data = GNUNET_STRINGS_data_to_string_alloc (member_id, sizeof(*member_id));
673 
674  if (member_id_data)
675  {
676  GNUNET_CONFIGURATION_set_value_string (cfg, "room", "member_id", member_id_data);
677 
678  GNUNET_free(member_id_data);
679  }
680 
683 
685 
686  return GNUNET_YES;
687 }
688 
689 void
691 {
693 
694  char *id_dir;
695  get_srv_handle_data_subdir (handle, handle->name, &id_dir);
696 
698  == GNUNET_DISK_directory_create (id_dir)))
699  {
700  char *save_dir;
701  GNUNET_asprintf (&save_dir, "%s%s%c", id_dir, "rooms", DIR_SEPARATOR);
702 
703  if ((GNUNET_YES == GNUNET_DISK_directory_test (save_dir, GNUNET_NO)) ||
704  (GNUNET_OK == GNUNET_DISK_directory_create (save_dir)))
706 
707  GNUNET_free(save_dir);
708  }
709 
710  GNUNET_free(id_dir);
711 }
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static char * dir
Set to the directory where runtime files are stored.
Definition: gnunet-arm.c:89
struct GNUNET_HashCode key
The key used in the DHT.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
static char * filename
static pa_context * context
Pulseaudio context.
static struct GNUNET_IDENTITY_PublicKey pubkey
Public key of the zone to look in.
static char * value
Value of the record to add/remove.
static struct GNUNET_SERVICE_Handle * service
Handle to our service instance.
GNUnet MESSENGER service.
void renew_store_ego(struct GNUNET_MESSENGER_EgoStore *store, const char *identifier)
Replaces the registered EGO in a store under a specific identifier with a newly created one.
void bind_store_ego(struct GNUNET_MESSENGER_EgoStore *store, const char *identifier, void *handle)
Binds an EGO which was registered to a store under a specific identifier to a given handle
void lookup_store_ego(struct GNUNET_MESSENGER_EgoStore *store, const char *identifier, GNUNET_MESSENGER_EgoLookupCallback lookup, void *cls)
Lookups an EGO which was registered to a store under a specific identifier.
void create_store_ego(struct GNUNET_MESSENGER_EgoStore *store, const char *identifier)
Creates a new EGO which will be registered to a store under a specific identifier.
void unbind_store_ego(struct GNUNET_MESSENGER_EgoStore *store, const char *identifier, void *handle)
Binds an EGO which was registered to a store under a specific identifier to a given handle
void rename_store_ego(struct GNUNET_MESSENGER_EgoStore *store, const char *old_identifier, const char *new_identifier)
Updates the location of a registered EGO in a store to a different one under a specific new_identifie...
int change_srv_handle_member_id(struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key, const struct GNUNET_ShortHashCode *unique_id)
Changes the member id of a given handle in a specific room to match a unique_id and returns GNUNET_OK...
void save_srv_handle_configuration(struct GNUNET_MESSENGER_SrvHandle *handle)
Saves member ids and other potential configuration from a given handle which depends on the given nam...
void notify_srv_handle_message(struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_MESSENGER_MemberSession *session, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Notifies the handle that a new message was received or sent.
int close_srv_handle_room(struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
Removes the membership of the room using a specific key and closes it if no other handle from this se...
void load_srv_handle_configuration(struct GNUNET_MESSENGER_SrvHandle *handle)
Loads member ids and other potential configuration from a given handle which depends on the given nam...
static void callback_set_handle_name(void *cls, const char *name, const struct GNUNET_MESSENGER_Ego *ego)
const struct GNUNET_ShortHashCode * get_srv_handle_member_id(const struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
Returns the member id of a given handle in a specific room.
void set_srv_handle_ego(struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_MESSENGER_Ego *ego)
Sets the EGO used by a given handle.
static int create_handle_member_id(const struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
int open_srv_handle_room(struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
Makes a given handle a member of the room using a specific key and opens the room from the handles se...
void setup_srv_handle_name(struct GNUNET_MESSENGER_SrvHandle *handle, const char *name)
Tries to set the name and EGO key of a handle initially by looking up a specific name.
int entry_srv_handle_room(struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_PeerIdentity *door, const struct GNUNET_HashCode *key)
Makes a given handle a member of the room using a specific key and enters the room through a tunnel t...
int send_srv_handle_message(struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key, const struct GNUNET_MESSENGER_Message *message)
Sends a message from a given handle to the room using a specific key.
static int iterate_send_message(void *cls, const struct GNUNET_HashCode *key, void *value)
int iterate_free_member_ids(void *cls, const struct GNUNET_HashCode *key, void *value)
void set_srv_handle_name(struct GNUNET_MESSENGER_SrvHandle *handle, const char *name)
Tries to rename the handle which implies renaming the EGO its using and moving all related data into ...
static const struct GNUNET_HashCode * get_next_member_session_contect(const struct GNUNET_MESSENGER_MemberSession *session)
const struct GNUNET_MESSENGER_Ego * get_srv_handle_ego(const struct GNUNET_MESSENGER_SrvHandle *handle)
Returns the EGO used by a given handle.
static int callback_scan_for_rooms(void *cls, const char *filename)
static int iterate_save_rooms(void *cls, const struct GNUNET_HashCode *key, void *value)
void update_srv_handle(struct GNUNET_MESSENGER_SrvHandle *handle)
Tries to change the key pair of an EGO of a handle under the same name and informs all rooms about th...
static void change_handle_name(struct GNUNET_MESSENGER_SrvHandle *handle, const char *name)
static void callback_update_handle(void *cls, const char *name, const struct GNUNET_MESSENGER_Ego *ego)
static void callback_setup_handle_name(void *cls, const char *name, const struct GNUNET_MESSENGER_Ego *ego)
static void change_handle_ego(struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_MESSENGER_Ego *ego)
void get_srv_handle_data_subdir(const struct GNUNET_MESSENGER_SrvHandle *handle, const char *name, char **dir)
Writes the path of the directory for a given handle using a specific name to the parameter dir.
void destroy_srv_handle(struct GNUNET_MESSENGER_SrvHandle *handle)
Destroys a handle and frees its memory fully.
struct GNUNET_MESSENGER_SrvHandle * create_srv_handle(struct GNUNET_MESSENGER_Service *service, struct GNUNET_MQ_Handle *mq)
Creates and allocates a new handle related to a service and using a given mq (message queue).
static const struct GNUNET_MESSENGER_MemberSession * get_handle_member_session(struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_SrvRoom *room, const struct GNUNET_HashCode *key)
GNUnet MESSENGER service.
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.
const struct GNUNET_HashCode * get_member_session_context(const struct GNUNET_MESSENGER_MemberSession *session)
Returns the member context of a given member session.
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_Message * create_message_name(const char *name)
Creates and allocates a new name message containing the name to change to.
struct GNUNET_MESSENGER_Message * create_message_key(const struct GNUNET_IDENTITY_PrivateKey *key)
Creates and allocates a new key message containing the public key to change to derived from its priva...
int send_srv_room_message(struct GNUNET_MESSENGER_SrvRoom *room, struct GNUNET_MESSENGER_SrvHandle *handle, struct GNUNET_MESSENGER_Message *message)
Sends a message from a given handle into a room.
const struct GNUNET_HashCode * get_srv_room_key(const struct GNUNET_MESSENGER_SrvRoom *room)
Returns the shared secret you need to access a room.
struct GNUNET_MESSENGER_MemberStore * get_srv_room_member_store(struct GNUNET_MESSENGER_SrvRoom *room)
Returns the used member store of a given room.
int entry_service_room(struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_PeerIdentity *door, const struct GNUNET_HashCode *key)
Tries to enter a room using a given key for a service by a specific handle.
struct GNUNET_MESSENGER_SrvRoom * get_service_room(const struct GNUNET_MESSENGER_Service *service, const struct GNUNET_HashCode *key)
Returns the room identified by a given key for a service.
struct GNUNET_MESSENGER_EgoStore * get_service_ego_store(struct GNUNET_MESSENGER_Service *service)
Returns the used EGO-store of a given service.
int open_service_room(struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
Tries to open a room using a given key for a service by a specific handle.
int close_service_room(struct GNUNET_MESSENGER_Service *service, struct GNUNET_MESSENGER_SrvHandle *handle, const struct GNUNET_HashCode *key)
Tries to close a room using a given key for a service by a specific handle.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_data(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, void *buf, size_t buf_size)
Get Crockford32-encoded fixed-size binary data from a configuration.
void GNUNET_CONFIGURATION_set_value_string(struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, const char *value)
Set a configuration value that should be a string.
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_parse(struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename)
Parse a configuration file, add all of the options in the file to the configuration environment.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_write(struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename)
Write configuration file.
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
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_remove(const char *filename)
Remove all files in a directory (rm -rf).
Definition: disk.c:1085
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_test(const char *fil, int is_readable)
Test if fil is a directory and listable.
Definition: disk.c:404
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_create_for_file(const char *filename)
Create the directory structure for storing a file.
Definition: disk.c:582
enum GNUNET_GenericReturnValue GNUNET_DISK_directory_create(const char *dir)
Implementation of "mkdir -p".
Definition: disk.c:496
int GNUNET_DISK_directory_scan(const char *dir_name, GNUNET_FileNameCallback callback, void *callback_cls)
Scan a directory for files.
Definition: disk.c:814
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
void * GNUNET_CONTAINER_multihashmap_get(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Given a key find a value in the map matching the key.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST
, ' bother checking if a value already exists (faster than GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE...
const struct GNUNET_IDENTITY_PrivateKey * GNUNET_IDENTITY_ego_get_private_key(const struct GNUNET_IDENTITY_Ego *ego)
Obtain the ECC key associated with a ego.
Definition: identity_api.c:639
void GNUNET_IDENTITY_ego_get_public_key(struct GNUNET_IDENTITY_Ego *ego, struct GNUNET_IDENTITY_PublicKey *pk)
Get the identifier (public key) of an ego.
Definition: identity_api.c:652
ssize_t GNUNET_IDENTITY_write_key_to_buffer(const struct GNUNET_IDENTITY_PublicKey *key, void *buffer, size_t len)
Writes a GNUNET_IDENTITY_PublicKey to a compact buffer.
struct GNUNET_IDENTITY_Ego * GNUNET_IDENTITY_ego_get_anonymous()
Obtain the ego representing 'anonymous' users.
Definition: identity_api.c:156
ssize_t GNUNET_IDENTITY_key_get_length(const struct GNUNET_IDENTITY_PublicKey *key)
Get the compacted length of a GNUNET_IDENTITY_PublicKey.
Definition: identity_api.c:991
#define GNUNET_log(kind,...)
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
@ GNUNET_OK
Definition: gnunet_common.h:99
@ GNUNET_YES
@ GNUNET_NO
Definition: gnunet_common.h:98
@ GNUNET_SYSERR
Definition: gnunet_common.h:97
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
const char * GNUNET_sh2s(const struct GNUNET_ShortHashCode *shc)
Convert a short hash value to a string (for printing debug messages).
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
@ GNUNET_ERROR_TYPE_INFO
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
@ GNUNET_MESSENGER_KIND_PRIVATE
The private kind.
@ GNUNET_MESSENGER_FLAG_PRIVATE
The private flag.
@ GNUNET_MESSENGER_FLAG_SENT
The sent flag.
@ GNUNET_MESSENGER_FLAG_NONE
The none flag.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:302
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition: gnunet_mq_lib.h:56
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:71
#define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_RECV_MESSAGE
#define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_GET_NAME
#define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_GET_KEY
#define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_MEMBER_ID
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
const struct GNUNET_IDENTITY_PublicKey * get_contact_key(const struct GNUNET_MESSENGER_Contact *contact)
Returns the public key of a given contact.
int decrypt_message(struct GNUNET_MESSENGER_Message *message, const struct GNUNET_IDENTITY_PrivateKey *key)
Decrypts a private message using a given private key and replaces its body and kind with the inner en...
struct GNUNET_MESSENGER_Message * copy_message(const struct GNUNET_MESSENGER_Message *message)
Creates and allocates a copy of a given message.
void destroy_message(struct GNUNET_MESSENGER_Message *message)
Destroys a message and frees its memory fully.
void encode_message(const struct GNUNET_MESSENGER_Message *message, uint16_t length, char *buffer, int include_header)
Encodes a given message into a buffer of a maximal length in bytes.
uint16_t get_message_size(const struct GNUNET_MESSENGER_Message *message, int include_header)
Returns the exact size in bytes to encode a given message.
int generate_free_member_id(struct GNUNET_ShortHashCode *id, const struct GNUNET_CONTAINER_MultiShortmap *members)
Tries to generate an unused member id and store it into the id parameter.
messenger api: client implementation of GNUnet MESSENGER service
#define DIR_SEPARATOR
Definition: platform.h:164
const char * name
struct GNUNET_MQ_Handle * mq
Connection to DNS service, or NULL.
Definition: dns_api.c:61
A 512-bit hashcode.
Handle for an ego.
Definition: identity.h:37
An identity key as per LSD0001.
struct GNUNET_IDENTITY_PublicKey pub
struct GNUNET_IDENTITY_PrivateKey priv
Message to receive the current public key of a handle.
Message to receive the current member id of a handle in room.
struct GNUNET_MESSENGER_MemberSession * next
struct GNUNET_MESSENGER_MemberStore * store
struct GNUNET_MESSENGER_SrvHandle * handle
struct GNUNET_MESSENGER_Message * message
enum GNUNET_MESSENGER_MessageKind kind
The kind of the message.
struct GNUNET_MESSENGER_MessageHeader header
Header.
Message to receive the current name of a handle.
Message to receive something from a room.
const struct GNUNET_MESSENGER_Ego * ego
Handle to a message queue.
Definition: mq.c:86
The identity of the host (wraps the signing key of the peer).
A 256-bit hashcode.