GNUnet  0.17.6
messenger_api.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2020--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 
29 
30 #include "messenger_api_handle.h"
31 #include "messenger_api_message.h"
32 #include "messenger_api_util.h"
33 
34 const char*
36 {
37  switch (kind)
38  {
40  return "INFO";
42  return "JOIN";
44  return "LEAVE";
46  return "NAME";
48  return "KEY";
50  return "PEER";
52  return "ID";
54  return "MISS";
56  return "MERGE";
58  return "REQUEST";
60  return "INVITE";
62  return "TEXT";
64  return "FILE";
66  return "PRIVATE";
68  return "DELETE";
69  default:
70  return "UNKNOWN";
71  }
72 }
73 
74 static int
75 check_get_name (void *cls,
76  const struct GNUNET_MESSENGER_NameMessage *msg)
77 {
79  return GNUNET_OK;
80 }
81 
82 static void
83 handle_get_name (void *cls,
84  const struct GNUNET_MESSENGER_NameMessage *msg)
85 {
86  struct GNUNET_MESSENGER_Handle *handle = cls;
87 
88  const char *name = ((const char*) msg) + sizeof(*msg);
89 
90  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Set name of handle: %s\n", name);
91 
92  set_handle_name (handle, strlen (name) > 0 ? name : NULL);
93 }
94 
95 static int
96 check_get_key (void *cls,
97  const struct GNUNET_MESSENGER_KeyMessage *msg)
98 {
99  const uint16_t full_length = ntohs (msg->header.size);
100 
101  if (full_length < sizeof(*msg))
102  return GNUNET_NO;
103 
104  const uint16_t length = full_length - sizeof(*msg);
105  const char *buffer = ((const char*) msg) + sizeof(*msg);
106 
108  if (GNUNET_IDENTITY_read_key_from_buffer(&pubkey, buffer, length) < 0)
109  return GNUNET_NO;
110 
111  return GNUNET_OK;
112 }
113 
114 static void
115 handle_get_key (void *cls,
116  const struct GNUNET_MESSENGER_KeyMessage *msg)
117 {
118  struct GNUNET_MESSENGER_Handle *handle = cls;
119 
120  const uint16_t length = ntohs (msg->header.size) - sizeof(*msg);
121  const char *buffer = ((const char*) msg) + sizeof(*msg);
122 
124  if (GNUNET_IDENTITY_read_key_from_buffer(&pubkey, buffer, length) < 0)
125  return;
126 
128  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Set key of handle: %s\n", str);
129  GNUNET_free(str);
130 
132 
133  if (handle->identity_callback)
134  handle->identity_callback (handle->identity_cls, handle);
135 }
136 
137 static void
138 handle_member_id (void *cls,
139  const struct GNUNET_MESSENGER_MemberMessage *msg)
140 {
141  struct GNUNET_MESSENGER_Handle *handle = cls;
142 
143  const struct GNUNET_HashCode *key = &(msg->key);
144  const struct GNUNET_ShortHashCode *id = &(msg->id);
145 
146  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Set id of handle in room: %s\n", GNUNET_h2s (key));
147 
149 
150  if (room)
151  {
152  if (!room->contact_id)
154 
155  GNUNET_memcpy(room->contact_id, id, sizeof(*id));
156  }
157 }
158 
159 static void
160 handle_room_open (void *cls,
161  const struct GNUNET_MESSENGER_RoomMessage *msg)
162 {
163  struct GNUNET_MESSENGER_Handle *handle = cls;
164 
165  const struct GNUNET_HashCode *key = &(msg->key);
166 
167  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Opened room: %s\n", GNUNET_h2s (key));
168 
170 }
171 
172 static void
173 handle_room_entry (void *cls,
174  const struct GNUNET_MESSENGER_RoomMessage *msg)
175 {
176  struct GNUNET_MESSENGER_Handle *handle = cls;
177 
178  const struct GNUNET_PeerIdentity *door = &(msg->door);
179  const struct GNUNET_HashCode *key = &(msg->key);
180 
181  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Entered room: %s\n", GNUNET_h2s (key));
182 
184 }
185 
186 static void
187 handle_room_close (void *cls,
188  const struct GNUNET_MESSENGER_RoomMessage *msg)
189 {
190  struct GNUNET_MESSENGER_Handle *handle = cls;
191 
192  const struct GNUNET_HashCode *key = &(msg->key);
193 
194  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Closed room: %s\n", GNUNET_h2s (key));
195 
197 }
198 
199 static int
201  const struct GNUNET_MESSENGER_RecvMessage *msg)
202 {
203  const uint16_t full_length = ntohs (msg->header.size);
204 
205  if (full_length < sizeof(*msg))
206  return GNUNET_NO;
207 
208  const uint16_t length = full_length - sizeof(*msg);
209  const char *buffer = ((const char*) msg) + sizeof(*msg);
210 
211  struct GNUNET_MESSENGER_Message message;
212 
214  return GNUNET_NO;
215 
216  if (GNUNET_YES != decode_message (&message, length, buffer, GNUNET_YES, NULL))
217  return GNUNET_NO;
218 
219  cleanup_message(&message);
220  return GNUNET_OK;
221 }
222 
223 static void
225  const struct GNUNET_MESSENGER_RecvMessage *msg)
226 {
227  struct GNUNET_MESSENGER_Handle *handle = cls;
228 
229  const struct GNUNET_HashCode *key = &(msg->key);
230  const struct GNUNET_HashCode *sender = &(msg->sender);
231  const struct GNUNET_HashCode *context = &(msg->context);
232  const struct GNUNET_HashCode *hash = &(msg->hash);
233  const enum GNUNET_MESSENGER_MessageFlags flags = (
234  (enum GNUNET_MESSENGER_MessageFlags) (msg->flags)
235  );
236 
237  const uint16_t length = ntohs (msg->header.size) - sizeof(*msg);
238  const char *buffer = ((const char*) msg) + sizeof(*msg);
239 
240  struct GNUNET_MESSENGER_Message message;
241  decode_message (&message, length, buffer, GNUNET_YES, NULL);
242 
243  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Receiving message: %s\n", GNUNET_MESSENGER_name_of_kind (message.header.kind));
244 
246 
247  if (room)
248  {
250 
251  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Raw contact from sender and context: (%s : %s)\n",
253 
255  store, context, sender
256  );
257 
258  contact = handle_room_message (room, contact, &message, hash);
259 
260  const struct GNUNET_MESSENGER_Message *stored_message = get_room_message(room, hash);
261 
262  if (handle->msg_callback)
263  handle->msg_callback (handle->msg_cls, room, contact, stored_message, hash, flags);
264  }
265  else
266  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Unknown room for this client: %s\n", GNUNET_h2s (key));
267 
268  cleanup_message(&message);
269 }
270 
271 static void
273 
274 static void
276  struct GNUNET_MESSENGER_Room *room)
277 {
279  struct GNUNET_MQ_Envelope *env;
280 
282  GNUNET_memcpy(&(msg->key), &(room->key), sizeof(msg->key));
284 }
285 
286 static void
288  struct GNUNET_MESSENGER_Room *room,
289  const struct GNUNET_PeerIdentity *door)
290 {
292  struct GNUNET_MQ_Envelope *env;
293 
295  GNUNET_memcpy(&(msg->door), door, sizeof(*door));
296  GNUNET_memcpy(&(msg->key), &(room->key), sizeof(msg->key));
298 }
299 
300 static void
302  struct GNUNET_MESSENGER_Room *room)
303 {
305  struct GNUNET_MQ_Envelope *env;
306 
308  GNUNET_memcpy(&(msg->key), &(room->key), sizeof(msg->key));
310 }
311 
312 static int
314  const struct GNUNET_HashCode *key,
315  void *value)
316 {
317  struct GNUNET_MESSENGER_Handle *handle = cls;
318  struct GNUNET_MESSENGER_Room *room = value;
319 
320  if (GNUNET_YES == room->opened)
321  send_open_room (handle, room);
322 
323  struct GNUNET_MESSENGER_ListTunnel *entry = room->entries.head;
324 
325  struct GNUNET_PeerIdentity door;
326 
327  while (entry)
328  {
329  GNUNET_PEER_resolve (entry->peer, &door);
330 
331  send_enter_room (handle, room, &door);
332 
333  entry = entry->next;
334  }
335 
336  return GNUNET_YES;
337 }
338 
339 static void
341 {
342  struct GNUNET_MESSENGER_Handle *handle = cls;
343 
344  handle->reconnect_task = NULL;
345  handle->reconnect_time = GNUNET_TIME_STD_BACKOFF(handle->reconnect_time)
346  ;
347 
348  reconnect (handle);
349 
351 }
352 
353 static int
355  const struct GNUNET_HashCode *key,
356  void *value)
357 {
358  struct GNUNET_MESSENGER_Handle *handle = cls;
359  struct GNUNET_MESSENGER_Room *room = value;
360 
361  send_close_room (handle, room);
362 
363  return GNUNET_YES;
364 }
365 
366 static void
367 callback_mq_error (void *cls,
368  enum GNUNET_MQ_Error error)
369 {
370  struct GNUNET_MESSENGER_Handle *handle = cls;
371 
372  GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "MQ_Error: %u\n", error);
373 
375 
376  if (handle->mq)
377  {
379  handle->mq = NULL;
380  }
381 
383 }
384 
385 static void
387 {
388  const struct GNUNET_MQ_MessageHandler handlers[] =
389  {
393  ),
397  ),
399  member_id,
402  ),
404  room_open,
407  ),
409  room_entry,
412  ),
414  room_close,
417  ),
419  recv_message,
422  ),
424  };
425 
427 }
428 
431  const char *name,
433  void *identity_cls,
435  void *msg_cls)
436 {
438 
439  reconnect (handle);
440 
441  if (handle->mq)
442  {
443  const uint16_t name_len = name ? strlen (name) : 0;
444 
446  struct GNUNET_MQ_Envelope *env;
447 
449 
450  char *extra = ((char*) msg) + sizeof(*msg);
451 
452  if (name_len)
453  GNUNET_memcpy(extra, name, name_len);
454 
455  extra[name_len] = '\0';
456 
458  return handle;
459  }
460  else
461  {
463  return NULL;
464  }
465 }
466 
467 int
469 {
470  if ((!handle) || (!get_handle_name (handle)))
471  return GNUNET_SYSERR;
472 
474  struct GNUNET_MQ_Envelope *env;
475 
478  return GNUNET_OK;
479 }
480 
481 void
483 {
484  if (!handle)
485  return;
486 
488  struct GNUNET_MQ_Envelope *env;
489 
492 
494 }
495 
496 const char*
498 {
499  if (!handle)
500  return NULL;
501 
502  return get_handle_name (handle);
503 }
504 
505 int
507  const char *name)
508 {
509  if (!handle)
510  return GNUNET_SYSERR;
511 
512  const uint16_t name_len = name ? strlen (name) : 0;
513 
515  struct GNUNET_MQ_Envelope *env;
516 
518 
519  char *extra = ((char*) msg) + sizeof(*msg);
520 
521  if (name_len)
522  GNUNET_memcpy(extra, name, name_len);
523 
524  extra[name_len] = '\0';
525 
527  return GNUNET_YES;
528 }
529 
530 static const struct GNUNET_IDENTITY_PublicKey*
532 {
533  if (0 == GNUNET_memcmp(public_key, get_anonymous_public_key()))
534  return NULL;
535 
536  return public_key;
537 }
538 
539 const struct GNUNET_IDENTITY_PublicKey*
541 {
542  if (!handle)
543  return NULL;
544 
546 }
547 
548 struct GNUNET_MESSENGER_Room*
550  const struct GNUNET_HashCode *key)
551 {
552  if ((!handle) || (!key))
553  return NULL;
554 
556 
557  if (!room)
558  {
559  room = create_room (handle, key);
560 
563  {
564  destroy_room (room);
565  return NULL;
566  }
567  }
568 
569  send_open_room (handle, room);
570  return room;
571 }
572 
573 struct GNUNET_MESSENGER_Room*
575  const struct GNUNET_PeerIdentity *door,
576  const struct GNUNET_HashCode *key)
577 {
578  if ((!handle) || (!door) || (!key))
579  return NULL;
580 
582 
583  if (!room)
584  {
585  room = create_room (handle, key);
586 
589  {
590  destroy_room (room);
591  return NULL;
592  }
593  }
594 
595  send_enter_room (handle, room, door);
596  return room;
597 }
598 
599 void
601 {
602  if (!room)
603  return;
604 
605  send_close_room (room->handle, room);
606 }
607 
609 {
612  size_t counter;
613  void *cls;
614 };
615 
616 static int
617 iterate_find_room (void* cls,
618  const struct GNUNET_HashCode *key,
619  void *value)
620 {
621  struct GNUNET_MESSENGER_RoomFind *find = cls;
622  struct GNUNET_MESSENGER_Room *room = value;
623 
624  if ((find->counter > 0) && ((!find->contact) || (GNUNET_YES == find_room_member(room, find->contact))))
625  {
626  find->counter--;
627 
628  if (!find->callback)
629  return GNUNET_YES;
630 
631  return find->callback(find->cls, room, find->contact);
632  }
633  else
634  return GNUNET_NO;
635 }
636 
637 int
639  const struct GNUNET_MESSENGER_Contact *contact,
641  void *cls)
642 {
643  if (!handle)
644  return GNUNET_SYSERR;
645 
646  struct GNUNET_MESSENGER_RoomFind find;
647 
648  find.contact = contact;
649  find.callback = callback;
650  find.counter = (contact? contact->rc : SIZE_MAX);
651  find.cls = cls;
652 
654 }
655 
656 const struct GNUNET_HashCode*
658 {
659  if (!room)
660  return NULL;
661 
662  return &(room->key);
663 }
664 
665 const struct GNUNET_MESSENGER_Contact*
667  const struct GNUNET_HashCode *hash)
668 {
669  if ((!room) || (!hash))
670  return NULL;
671 
672  return get_room_sender(room, hash);
673 }
674 
675 const char*
677 {
678  if (!contact)
679  return NULL;
680 
681  return get_contact_name (contact);
682 }
683 
684 const struct GNUNET_IDENTITY_PublicKey*
686 {
687  if (!contact)
688  return NULL;
689 
690  return get_non_anonymous_key (get_contact_key (contact));
691 }
692 
693 void
695  const struct GNUNET_MESSENGER_Message *message,
696  const struct GNUNET_MESSENGER_Contact *contact)
697 {
698  if ((!room) || (!message))
699  return;
700 
701  switch (filter_message_sending (message))
702  {
703  case GNUNET_SYSERR:
704  GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Sending message aborted: This kind of message is reserved for the service!\n");
705  return;
706  case GNUNET_NO:
707  GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Sending message aborted: This kind of message could cause issues!\n");
708  return;
709  default:
710  break;
711  }
712 
713  ssize_t key_length = 0;
714 
715  if (contact)
716  {
717  const struct GNUNET_IDENTITY_PublicKey *public_key = get_non_anonymous_key (
718  get_contact_key(contact)
719  );
720 
721  if (public_key)
722  key_length = GNUNET_IDENTITY_key_get_length(public_key);
723  else
724  key_length = -1;
725  }
726 
727  if (key_length < 0)
728  {
729  GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Sending message aborted: Invalid key!\n");
730  return;
731  }
732 
733  const uint16_t msg_length = get_message_size (message, GNUNET_NO);
734 
736  struct GNUNET_MQ_Envelope *env;
737 
738  const uint16_t length = (uint16_t) key_length + msg_length;
739 
741  msg, length,
743  );
744 
745  GNUNET_memcpy(&(msg->key), &(room->key), sizeof(msg->key));
746 
747  msg->flags = (uint32_t) (
749  );
750 
751  char *buffer = ((char*) msg) + sizeof(*msg);
752  char *msg_buffer = buffer + key_length;
753 
754  if (key_length > 0)
755  GNUNET_IDENTITY_write_key_to_buffer(get_contact_key(contact), buffer, key_length);
756 
757  encode_message (message, msg_length, msg_buffer, GNUNET_NO);
758 
759  GNUNET_MQ_send (room->handle->mq, env);
760 }
761 
762 const struct GNUNET_MESSENGER_Message*
764  const struct GNUNET_HashCode *hash)
765 {
766  if ((!room) || (!hash))
767  return NULL;
768 
769  const struct GNUNET_MESSENGER_Message *message = get_room_message (room, hash);
770 
771  if (!message)
772  {
774  struct GNUNET_MQ_Envelope *env;
775 
777  GNUNET_memcpy(&(msg->key), &(room->key), sizeof(msg->key));
778  GNUNET_memcpy(&(msg->hash), hash, sizeof(*hash));
779  GNUNET_MQ_send (room->handle->mq, env);
780  }
781 
782  return message;
783 }
784 
785 int
788  void *cls)
789 {
790  if (!room)
791  return GNUNET_SYSERR;
792 
793  return iterate_room_members(room, callback, cls);
794 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static int recv_message(void *cls, const struct GNUNET_MessageHeader *msg)
We have received a full message, pass to the MQ dispatcher.
Definition: client.c:334
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
struct GNUNET_HashCode key
The key used in the DHT.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
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.
GNUnet MESSENGER service.
struct GNUNET_MQ_Handle * GNUNET_CLIENT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *service_name, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *error_handler_cls)
Create a message queue to connect to a GNUnet service.
Definition: client.c:1055
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.
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_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...
char * GNUNET_IDENTITY_public_key_to_string(const struct GNUNET_IDENTITY_PublicKey *key)
Creates a (Base32) string representation of the public key.
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.
ssize_t GNUNET_IDENTITY_read_key_from_buffer(struct GNUNET_IDENTITY_PublicKey *key, const void *buffer, size_t len)
Reads a GNUNET_IDENTITY_PublicKey from a compact buffer.
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
const char * GNUNET_h2s_full(const struct GNUNET_HashCode *hc)
Convert a 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
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
const char * GNUNET_MESSENGER_get_name(const struct GNUNET_MESSENGER_Handle *handle)
Get the name (if specified, otherwise NULL) used by the messenger.
struct GNUNET_MESSENGER_Room * GNUNET_MESSENGER_enter_room(struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_PeerIdentity *door, const struct GNUNET_HashCode *key)
Enter a room to send and receive messages through a door opened using GNUNET_MESSENGER_open_room.
void(* GNUNET_MESSENGER_IdentityCallback)(void *cls, struct GNUNET_MESSENGER_Handle *handle)
Method called whenever the EGO of a handle changes or if the first connection fails to load a valid E...
int GNUNET_MESSENGER_iterate_members(struct GNUNET_MESSENGER_Room *room, GNUNET_MESSENGER_MemberCallback callback, void *cls)
Iterates through all members of a given room and calls a selected callback for each of them with a pr...
struct GNUNET_MESSENGER_Room * GNUNET_MESSENGER_open_room(struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *key)
Open a room to send and receive messages.
int GNUNET_MESSENGER_find_rooms(const struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_MESSENGER_Contact *contact, GNUNET_MESSENGER_MemberCallback callback, void *cls)
Searches for a specific contact in a given room and calls a selected callback with a given closure fo...
GNUNET_MESSENGER_MessageKind
Enum for the different supported kinds of messages.
GNUNET_MESSENGER_MessageFlags
Enum for the different supported flags used by message handling Compatible flags can be OR'ed togethe...
const struct GNUNET_IDENTITY_PublicKey * GNUNET_MESSENGER_contact_get_key(const struct GNUNET_MESSENGER_Contact *contact)
Get the public key used by the contact or NULL if the anonymous key was used.
int(* GNUNET_MESSENGER_MemberCallback)(void *cls, struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Contact *contact)
Method called for each member in a room during iteration.
struct GNUNET_MESSENGER_Handle * GNUNET_MESSENGER_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *name, GNUNET_MESSENGER_IdentityCallback identity_callback, void *identity_cls, GNUNET_MESSENGER_MessageCallback msg_callback, void *msg_cls)
Set up a handle for the messenger related functions and connects to all necessary services.
int GNUNET_MESSENGER_update(struct GNUNET_MESSENGER_Handle *handle)
Update a handle of the messenger to use a different ego key and replace the old one with a newly gene...
const char * GNUNET_MESSENGER_contact_get_name(const struct GNUNET_MESSENGER_Contact *contact)
Get the name used by the contact.
const struct GNUNET_IDENTITY_PublicKey * GNUNET_MESSENGER_get_key(const struct GNUNET_MESSENGER_Handle *handle)
Get the public key used by the messenger or NULL if the anonymous key was used.
const char * GNUNET_MESSENGER_name_of_kind(enum GNUNET_MESSENGER_MessageKind kind)
Get the name of a message kind.
Definition: messenger_api.c:35
const struct GNUNET_MESSENGER_Contact * GNUNET_MESSENGER_get_sender(const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash)
Get the contact of a member in a room which sent a specific message identified with a given hash.
void GNUNET_MESSENGER_disconnect(struct GNUNET_MESSENGER_Handle *handle)
Disconnect all of the messengers used services and clears up its used memory.
const struct GNUNET_HashCode * GNUNET_MESSENGER_room_get_key(const struct GNUNET_MESSENGER_Room *room)
Get the key of a given room.
#define GNUNET_MESSENGER_SERVICE_NAME
Identifier of GNUnet MESSENGER Service.
void GNUNET_MESSENGER_close_room(struct GNUNET_MESSENGER_Room *room)
Close a room which was entered, opened or both in various order and variety.
const struct GNUNET_MESSENGER_Message * GNUNET_MESSENGER_get_message(const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash)
Get the message in a room identified by its hash.
int GNUNET_MESSENGER_set_name(struct GNUNET_MESSENGER_Handle *handle, const char *name)
Set the name for the messenger.
void GNUNET_MESSENGER_send_message(struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_MESSENGER_Contact *contact)
Send a message into a room.
void(* GNUNET_MESSENGER_MessageCallback)(void *cls, struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Contact *sender, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash, enum GNUNET_MESSENGER_MessageFlags flags)
Method called whenever a message is sent or received from a room.
@ GNUNET_MESSENGER_KIND_INFO
The info kind.
@ GNUNET_MESSENGER_KIND_MISS
The miss kind.
@ GNUNET_MESSENGER_KIND_INVITE
The invite kind.
@ GNUNET_MESSENGER_KIND_PRIVATE
The private kind.
@ GNUNET_MESSENGER_KIND_FILE
The file kind.
@ GNUNET_MESSENGER_KIND_REQUEST
The request kind.
@ GNUNET_MESSENGER_KIND_NAME
The name kind.
@ GNUNET_MESSENGER_KIND_LEAVE
The leave kind.
@ GNUNET_MESSENGER_KIND_PEER
The peer kind.
@ GNUNET_MESSENGER_KIND_UNKNOWN
The unknown kind.
@ GNUNET_MESSENGER_KIND_KEY
The key kind.
@ GNUNET_MESSENGER_KIND_TEXT
The text kind.
@ GNUNET_MESSENGER_KIND_JOIN
The join kind.
@ GNUNET_MESSENGER_KIND_DELETE
The delete kind.
@ GNUNET_MESSENGER_KIND_MERGE
The merge kind.
@ GNUNET_MESSENGER_KIND_ID
The id kind.
@ GNUNET_MESSENGER_FLAG_PRIVATE
The private flag.
@ GNUNET_MESSENGER_FLAG_NONE
The none flag.
GNUNET_MQ_Error
Error codes for the queue.
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_handler_end()
End-marker for the handlers array.
#define GNUNET_MQ_check_zero_termination(m)
Insert code for a "check_" function that verifies that a given variable-length message received over ...
#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_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:685
void GNUNET_PEER_resolve(GNUNET_PEER_Id id, struct GNUNET_PeerIdentity *pid)
Convert an interned PID to a normal peer identity.
Definition: peer.c:225
#define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_OPEN
#define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_SEND_MESSAGE
#define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_RECV_MESSAGE
#define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_CREATE
#define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_UPDATE
#define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_GET_MESSAGE
#define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_DESTROY
#define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_GET_NAME
#define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_SET_NAME
#define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_GET_KEY
#define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_CLOSE
#define GNUNET_MESSAGE_TYPE_MESSENGER_CONNECTION_MEMBER_ID
#define GNUNET_MESSAGE_TYPE_MESSENGER_ROOM_ENTRY
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1254
#define GNUNET_TIME_STD_BACKOFF(r)
Perform our standard exponential back-off calculation, starting at 1 ms and then going by a factor of...
static int iterate_reset_room(void *cls, const struct GNUNET_HashCode *key, void *value)
static void handle_recv_message(void *cls, const struct GNUNET_MESSENGER_RecvMessage *msg)
static void callback_reconnect(void *cls)
static void handle_room_close(void *cls, const struct GNUNET_MESSENGER_RoomMessage *msg)
static const struct GNUNET_IDENTITY_PublicKey * get_non_anonymous_key(const struct GNUNET_IDENTITY_PublicKey *public_key)
static int iterate_find_room(void *cls, const struct GNUNET_HashCode *key, void *value)
static void handle_room_open(void *cls, const struct GNUNET_MESSENGER_RoomMessage *msg)
static void handle_room_entry(void *cls, const struct GNUNET_MESSENGER_RoomMessage *msg)
static void send_enter_room(struct GNUNET_MESSENGER_Handle *handle, struct GNUNET_MESSENGER_Room *room, const struct GNUNET_PeerIdentity *door)
static void send_close_room(struct GNUNET_MESSENGER_Handle *handle, struct GNUNET_MESSENGER_Room *room)
static void callback_mq_error(void *cls, enum GNUNET_MQ_Error error)
static void handle_get_key(void *cls, const struct GNUNET_MESSENGER_KeyMessage *msg)
static void handle_member_id(void *cls, const struct GNUNET_MESSENGER_MemberMessage *msg)
static int iterate_close_room(void *cls, const struct GNUNET_HashCode *key, void *value)
static int check_get_key(void *cls, const struct GNUNET_MESSENGER_KeyMessage *msg)
Definition: messenger_api.c:96
static void handle_get_name(void *cls, const struct GNUNET_MESSENGER_NameMessage *msg)
Definition: messenger_api.c:83
static int check_recv_message(void *cls, const struct GNUNET_MESSENGER_RecvMessage *msg)
static void reconnect(struct GNUNET_MESSENGER_Handle *handle)
static void send_open_room(struct GNUNET_MESSENGER_Handle *handle, struct GNUNET_MESSENGER_Room *room)
static int check_get_name(void *cls, const struct GNUNET_MESSENGER_NameMessage *msg)
Definition: messenger_api.c:75
const struct GNUNET_IDENTITY_PublicKey * get_contact_key(const struct GNUNET_MESSENGER_Contact *contact)
Returns the public key of a given contact.
const char * get_contact_name(const struct GNUNET_MESSENGER_Contact *contact)
Returns the current name of a given contact or NULL if no valid name was assigned yet.
struct GNUNET_MESSENGER_Contact * get_store_contact_raw(struct GNUNET_MESSENGER_ContactStore *store, const struct GNUNET_HashCode *context, const struct GNUNET_HashCode *key_hash)
Returns a contact using the hash of a specific public key.
void entry_handle_room_at(struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_PeerIdentity *door, const struct GNUNET_HashCode *key)
Adds a tunnel for a room known to a handle identified by a given key to a list of opened connections.
const char * get_handle_name(const struct GNUNET_MESSENGER_Handle *handle)
Returns the current name of a given handle or NULL if no valid name was assigned yet.
struct GNUNET_MESSENGER_Handle * create_handle(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_MESSENGER_IdentityCallback identity_callback, void *identity_cls, GNUNET_MESSENGER_MessageCallback msg_callback, void *msg_cls)
Creates and allocates a new handle using a given configuration and a custom message callback with a g...
void open_handle_room(struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *key)
Marks a room known to a handle identified by a given key as open.
void destroy_handle(struct GNUNET_MESSENGER_Handle *handle)
Destroys a handle and frees its memory fully from the client API.
struct GNUNET_MESSENGER_ContactStore * get_handle_contact_store(struct GNUNET_MESSENGER_Handle *handle)
Returns the used contact store of a given handle.
void close_handle_room(struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *key)
Destroys and so implicitly closes a room known to a handle identified by a given key.
void set_handle_name(struct GNUNET_MESSENGER_Handle *handle, const char *name)
Sets the name of a handle to a specific name.
void set_handle_key(struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_IDENTITY_PublicKey *pubkey)
Sets the public key of a given handle to a specific public key.
const struct GNUNET_IDENTITY_PublicKey * get_handle_key(const struct GNUNET_MESSENGER_Handle *handle)
Returns the public key of a given handle.
messenger api: client implementation of GNUnet MESSENGER service
int filter_message_sending(const struct GNUNET_MESSENGER_Message *message)
Returns if a specific kind of message should be sent by a client.
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.
int decode_message(struct GNUNET_MESSENGER_Message *message, uint16_t length, const char *buffer, int include_header, uint16_t *padding)
Decodes a message from a given buffer of a maximal length in bytes.
uint16_t get_message_kind_size(enum GNUNET_MESSENGER_MessageKind kind, int include_header)
Returns the minimal size in bytes to encode a message of a specific kind.
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.
void cleanup_message(struct GNUNET_MESSENGER_Message *message)
Frees the messages body memory.
messenger api: client and service implementation of GNUnet MESSENGER service
struct GNUNET_MESSENGER_Contact * handle_room_message(struct GNUNET_MESSENGER_Room *room, struct GNUNET_MESSENGER_Contact *sender, const struct GNUNET_MESSENGER_Message *message, const struct GNUNET_HashCode *hash)
Handles a message with a given hash in a room for the client API to update members and its informatio...
struct GNUNET_MESSENGER_Contact * get_room_sender(const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash)
Returns a messages sender locally stored from a map for a given hash in a room.
const struct GNUNET_MESSENGER_Message * get_room_message(const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_HashCode *hash)
Returns a message locally stored from a map for a given hash in a room.
int find_room_member(const struct GNUNET_MESSENGER_Room *room, const struct GNUNET_MESSENGER_Contact *contact)
Checks through all members of a given room if a specific contact is found and returns a result depend...
struct GNUNET_MESSENGER_Room * create_room(struct GNUNET_MESSENGER_Handle *handle, const struct GNUNET_HashCode *key)
Creates and allocates a new room for a handle with a given key for the client API.
int iterate_room_members(struct GNUNET_MESSENGER_Room *room, GNUNET_MESSENGER_MemberCallback callback, void *cls)
Iterates through all members of a given room to forward each of them to a selected callback with a cu...
void destroy_room(struct GNUNET_MESSENGER_Room *room)
Destroys a room and frees its memory fully from the client API.
const struct GNUNET_IDENTITY_PublicKey * get_anonymous_public_key()
Returns the public identity key of GNUNET_IDENTITY_ego_get_anonymous() without recalculating it every...
messenger api: client implementation of GNUnet MESSENGER service
#define SIZE_MAX
Definition: platform.h:207
const char * name
struct GNUNET_SCHEDULER_Task * reconnect_task
Task to reconnect to the service.
Definition: dns_api.c:81
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration to use.
Definition: dns_api.c:66
struct GNUNET_MQ_Handle * mq
Connection to DNS service, or NULL.
Definition: dns_api.c:61
A 512-bit hashcode.
An identity key as per LSD0001.
Message to create a handle for a client.
Message to destroy the handle for a client.
Message to request something from a room.
struct GNUNET_MQ_Handle * mq
GNUNET_MESSENGER_MessageCallback msg_callback
GNUNET_MESSENGER_IdentityCallback identity_callback
Message to receive the current public key of a handle.
struct GNUNET_MESSENGER_ListTunnel * next
struct GNUNET_MESSENGER_ListTunnel * head
Message to receive the current member id of a handle in room.
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.
GNUNET_MESSENGER_MemberCallback callback
const struct GNUNET_MESSENGER_Contact * contact
General message to confirm interaction with a room.
struct GNUNET_MESSENGER_Handle * handle
struct GNUNET_MESSENGER_ListTunnels entries
struct GNUNET_ShortHashCode * contact_id
struct GNUNET_HashCode key
Message to send something into a room.
Message to update the handle (its EGO key) for a client.
Message handler for a specific message type.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
The identity of the host (wraps the signing key of the peer).
A 256-bit hashcode.
static char * get_key(char *line)
Definition: testing.c:1808