GNUnet  0.10.x
core_api.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2009-2016 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 */
26 #include "platform.h"
27 #include "gnunet_util_lib.h"
28 #include "gnunet_constants.h"
29 #include "gnunet_core_service.h"
30 #include "core.h"
31 
32 #define LOG(kind, ...) GNUNET_log_from (kind, "core-api", __VA_ARGS__)
33 
34 
38 struct PeerRecord
39 {
40 
45 
50 
56 
61  void *client_cls;
62 
67 
71  uint16_t smr_id_gen;
72 };
73 
74 
79 {
80 
85 
89  void *cls;
90 
95 
100 
105 
110 
115 
121 
126 
131 
135  struct GNUNET_TIME_Relative retry_backoff;
136 
140  unsigned int hcnt;
141 
146 };
147 
148 
155 static void
156 reconnect (struct GNUNET_CORE_Handle *h);
157 
158 
165 static void
166 reconnect_task (void *cls)
167 {
168  struct GNUNET_CORE_Handle *h = cls;
169 
170  h->reconnect_task = NULL;
171  LOG (GNUNET_ERROR_TYPE_DEBUG, "Connecting to CORE service after delay\n");
172  reconnect (h);
173 }
174 
175 
185 static int
187  const struct GNUNET_PeerIdentity *key,
188  void *value)
189 {
190  struct GNUNET_CORE_Handle *h = cls;
191  struct PeerRecord *pr = value;
192 
193  GNUNET_assert (pr->h == h);
194  if (NULL != h->disconnects)
195  h->disconnects (h->cls, &pr->peer, pr->client_cls);
198  GNUNET_MQ_destroy (pr->mq);
199  GNUNET_assert (NULL == pr->mq);
200  if (NULL != pr->env)
201  {
202  GNUNET_MQ_discard (pr->env);
203  pr->env = NULL;
204  }
205  GNUNET_free (pr);
206  return GNUNET_YES;
207 }
208 
209 
216 static void
218 {
219  GNUNET_assert (NULL == h->reconnect_task);
220  if (NULL != h->mq)
221  {
222  GNUNET_MQ_destroy (h->mq);
223  h->mq = NULL;
224  }
225  GNUNET_assert (NULL == h->reconnect_task);
226  h->reconnect_task =
230  h);
232 }
233 
234 
242 static void
243 handle_mq_error (void *cls, enum GNUNET_MQ_Error error)
244 {
245  struct GNUNET_CORE_Handle *h = cls;
246 
247  LOG (GNUNET_ERROR_TYPE_DEBUG, "MQ ERROR: %d\n", error);
248  reconnect_later (h);
249 }
250 
251 
260 static void
262  const struct GNUNET_MessageHeader *msg,
263  void *impl_state)
264 {
265  struct PeerRecord *pr = impl_state;
266  struct GNUNET_CORE_Handle *h = pr->h;
267  struct SendMessageRequest *smr;
268  struct SendMessage *sm;
269  struct GNUNET_MQ_Envelope *env;
270  uint16_t msize;
272 
273  if (NULL == h->mq)
274  {
275  /* We're currently reconnecting, pretend this worked */
277  return;
278  }
279  GNUNET_assert (NULL == pr->env);
280  /* extract options from envelope */
282  flags = GNUNET_MQ_env_get_options (env);
283 
284  /* check message size for sanity */
285  msize = ntohs (msg->size);
286  if (msize >= GNUNET_MAX_MESSAGE_SIZE - sizeof (struct SendMessage))
287  {
288  GNUNET_break (0);
290  return;
291  }
292 
293  /* ask core for transmission */
295  "Asking core for transmission of %u bytes to `%s'\n",
296  (unsigned int) msize,
297  GNUNET_i2s (&pr->peer));
299  smr->priority = htonl ((uint32_t) flags);
300  smr->peer = pr->peer;
301  smr->size = htons (msize);
302  smr->smr_id = htons (++pr->smr_id_gen);
303  GNUNET_MQ_send (h->mq, env);
304 
305  /* prepare message with actual transmission data */
307  sm->priority = htonl ((uint32_t) flags);
308  sm->peer = pr->peer;
310  "Calling get_message with buffer of %u bytes\n",
311  (unsigned int) msize);
312 }
313 
314 
322 static void
323 core_mq_destroy_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
324 {
325  struct PeerRecord *pr = impl_state;
326 
327  GNUNET_assert (mq == pr->mq);
328  pr->mq = NULL;
329 }
330 
331 
339 static void
340 core_mq_cancel_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
341 {
342  struct PeerRecord *pr = impl_state;
343 
344  (void) mq;
345  GNUNET_assert (NULL != pr->env);
346  GNUNET_MQ_discard (pr->env);
347  pr->env = NULL;
348 }
349 
350 
359 static void
360 core_mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
361 {
362  /* struct PeerRecord *pr = cls; */
363  (void) cls;
364  (void) error;
365  GNUNET_break_op (0);
366 }
367 
368 
377 static void
379  const struct GNUNET_PeerIdentity *peer)
380 {
381  struct PeerRecord *pr;
382 
383  pr = GNUNET_new (struct PeerRecord);
384  pr->peer = *peer;
385  pr->h = h;
388  h->peers,
389  &pr->peer,
390  pr,
395  pr,
396  h->handlers,
398  pr);
399  if (NULL != h->connects)
400  {
401  pr->client_cls = h->connects (h->cls, &pr->peer, pr->mq);
403  }
404 }
405 
406 
415 static void
416 handle_init_reply (void *cls, const struct InitReplyMessage *m)
417 {
418  struct GNUNET_CORE_Handle *h = cls;
420 
421  GNUNET_break (0 == ntohl (m->reserved));
423  if (NULL != (init = h->init))
424  {
425  /* mark so we don't call init on reconnect */
426  h->init = NULL;
427  h->me = m->my_identity;
429  "Connected to core service of peer `%s'.\n",
430  GNUNET_i2s (&h->me));
431  h->have_init = GNUNET_YES;
432  init (h->cls, &h->me);
433  }
434  else
435  {
437  "Successfully reconnected to core service.\n");
438  if (GNUNET_NO == h->have_init)
439  {
440  h->me = m->my_identity;
441  h->have_init = GNUNET_YES;
442  }
443  else
444  {
445  GNUNET_break (0 == memcmp (&h->me,
446  &m->my_identity,
447  sizeof (struct GNUNET_PeerIdentity)));
448  }
449  }
450  /* fake 'connect to self' */
451  connect_peer (h, &h->me);
452 }
453 
454 
462 static void
464 {
465  struct GNUNET_CORE_Handle *h = cls;
466  struct PeerRecord *pr;
467 
469  "Received notification about connection from `%s'.\n",
470  GNUNET_i2s (&cnm->peer));
471  if (0 == memcmp (&h->me, &cnm->peer, sizeof (struct GNUNET_PeerIdentity)))
472  {
473  /* connect to self!? */
474  GNUNET_break (0);
475  return;
476  }
478  if (NULL != pr)
479  {
480  GNUNET_break (0);
481  reconnect_later (h);
482  return;
483  }
484  connect_peer (h, &cnm->peer);
485 }
486 
487 
495 static void
496 handle_disconnect_notify (void *cls, const struct DisconnectNotifyMessage *dnm)
497 {
498  struct GNUNET_CORE_Handle *h = cls;
499  struct PeerRecord *pr;
500 
501  if (0 == memcmp (&h->me, &dnm->peer, sizeof (struct GNUNET_PeerIdentity)))
502  {
503  /* disconnect from self!? */
504  GNUNET_break (0);
505  return;
506  }
507  GNUNET_break (0 == ntohl (dnm->reserved));
509  "Received notification about disconnect from `%s'.\n",
510  GNUNET_i2s (&dnm->peer));
512  if (NULL == pr)
513  {
514  GNUNET_break (0);
515  reconnect_later (h);
516  return;
517  }
518  disconnect_and_free_peer_entry (h, &pr->peer, pr);
519 }
520 
521 
529 static int
530 check_notify_inbound (void *cls, const struct NotifyTrafficMessage *ntm)
531 {
532  uint16_t msize;
533  const struct GNUNET_MessageHeader *em;
534 
535  (void) cls;
536  msize = ntohs (ntm->header.size) - sizeof (struct NotifyTrafficMessage);
537  if (msize < sizeof (struct GNUNET_MessageHeader))
538  {
539  GNUNET_break (0);
540  return GNUNET_SYSERR;
541  }
542  em = (const struct GNUNET_MessageHeader *) &ntm[1];
543  if (msize != ntohs (em->size))
544  {
545  GNUNET_break (0);
546  return GNUNET_SYSERR;
547  }
548  return GNUNET_OK;
549 }
550 
551 
559 static void
560 handle_notify_inbound (void *cls, const struct NotifyTrafficMessage *ntm)
561 {
562  struct GNUNET_CORE_Handle *h = cls;
563  const struct GNUNET_MessageHeader *em;
564  struct PeerRecord *pr;
565 
567  "Received inbound message from `%s'.\n",
568  GNUNET_i2s (&ntm->peer));
569  em = (const struct GNUNET_MessageHeader *) &ntm[1];
571  if (NULL == pr)
572  {
573  GNUNET_break (0);
574  reconnect_later (h);
575  return;
576  }
577  GNUNET_MQ_inject_message (pr->mq, em);
578 }
579 
580 
589 static void
590 handle_send_ready (void *cls, const struct SendMessageReady *smr)
591 {
592  struct GNUNET_CORE_Handle *h = cls;
593  struct PeerRecord *pr;
594 
596  if (NULL == pr)
597  {
598  GNUNET_break (0);
599  reconnect_later (h);
600  return;
601  }
603  "Received notification about transmission readiness to `%s'.\n",
604  GNUNET_i2s (&smr->peer));
605  if (NULL == pr->env)
606  {
607  /* request must have been cancelled between the original request
608  * and the response from CORE, ignore CORE's readiness */
609  return;
610  }
611  if (ntohs (smr->smr_id) != pr->smr_id_gen)
612  {
613  /* READY message is for expired or cancelled message,
614  * ignore! (we should have already sent another request) */
615  return;
616  }
617 
618  /* ok, all good, send message out! */
619  GNUNET_MQ_send (h->mq, pr->env);
620  pr->env = NULL;
622 }
623 
624 
631 static void
633 {
634  struct GNUNET_MQ_MessageHandler handlers[] =
635  {GNUNET_MQ_hd_fixed_size (init_reply,
637  struct InitReplyMessage,
638  h),
641  struct ConnectNotifyMessage,
642  h),
646  h),
647  GNUNET_MQ_hd_var_size (notify_inbound,
649  struct NotifyTrafficMessage,
650  h),
651  GNUNET_MQ_hd_fixed_size (send_ready,
653  struct SendMessageReady,
654  h),
656  struct InitMessage *init;
657  struct GNUNET_MQ_Envelope *env;
658  uint16_t *ts;
659 
660  GNUNET_assert (NULL == h->mq);
661  h->mq = GNUNET_CLIENT_connect (h->cfg, "core", handlers, &handle_mq_error, h);
662  if (NULL == h->mq)
663  {
664  reconnect_later (h);
665  return;
666  }
667  env = GNUNET_MQ_msg_extra (init,
668  sizeof (uint16_t) * h->hcnt,
670  LOG (GNUNET_ERROR_TYPE_INFO, "(Re)connecting to CORE service\n");
671  init->options = htonl (0);
672  ts = (uint16_t *) &init[1];
673  for (unsigned int hpos = 0; hpos < h->hcnt; hpos++)
674  ts[hpos] = htons (h->handlers[hpos].type);
675  GNUNET_MQ_send (h->mq, env);
676 }
677 
678 
693 struct GNUNET_CORE_Handle *
695  void *cls,
699  const struct GNUNET_MQ_MessageHandler *handlers)
700 {
701  struct GNUNET_CORE_Handle *h;
702 
703  h = GNUNET_new (struct GNUNET_CORE_Handle);
704  h->cfg = cfg;
705  h->cls = cls;
706  h->init = init;
707  h->connects = connects;
710  h->handlers = GNUNET_MQ_copy_handlers (handlers);
711  h->hcnt = GNUNET_MQ_count_handlers (handlers);
712  GNUNET_assert (h->hcnt <
713  (GNUNET_MAX_MESSAGE_SIZE - sizeof (struct InitMessage)) /
714  sizeof (uint16_t));
715  LOG (GNUNET_ERROR_TYPE_DEBUG, "Connecting to CORE service\n");
716  reconnect (h);
717  if (NULL == h->mq)
718  {
720  return NULL;
721  }
722  return h;
723 }
724 
725 
731 void
733 {
734  LOG (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from CORE service\n");
737  handle);
739  handle->peers = NULL;
740  if (NULL != handle->reconnect_task)
741  {
743  handle->reconnect_task = NULL;
744  }
745  if (NULL != handle->mq)
746  {
747  GNUNET_MQ_destroy (handle->mq);
748  handle->mq = NULL;
749  }
750  GNUNET_free_non_null (handle->handlers);
751  GNUNET_free (handle);
752 }
753 
754 
762 struct GNUNET_MQ_Handle *
764  const struct GNUNET_PeerIdentity *pid)
765 {
766  struct PeerRecord *pr;
767 
769  if (NULL == pr)
770  return NULL;
771  return pr->mq;
772 }
773 
774 
775 /* end of core_api.c */
struct GNUNET_MQ_Envelope * env
Message we are currently trying to pass to the CORE service for this peer (from mq).
Definition: core_api.c:55
static GNUNET_NETWORK_STRUCT_END struct GNUNET_PeerIdentity me
Our own peer identity.
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
#define GNUNET_MESSAGE_TYPE_CORE_SEND
Client with message to transmit (after SEND_READY confirmation was received).
Context for the core service connection.
Definition: core_api.c:78
Information we track for each peer.
Definition: core_api.c:38
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:901
#define GNUNET_MQ_msg_nested_mh(mvar, type, mh)
Allocate a GNUNET_MQ_Envelope, and append a payload message after the given message struct...
struct GNUNET_PeerIdentity me
Identity of this peer.
Definition: core_api.c:125
uint32_t priority
How important is this message?
Definition: core.h:208
static void connect_peer(struct GNUNET_CORE_Handle *h, const struct GNUNET_PeerIdentity *peer)
Add the given peer to the list of our connected peers and create the respective data structures and n...
Definition: core_api.c:378
GNUNET_MQ_Error
Error codes for the queue.
GNUNET_CORE_StartupCallback init
Function to call once we&#39;ve handshaked with the core service.
Definition: core_api.c:94
GNUNET_CORE_ConnectEventHandler connects
Function to call whenever we&#39;re notified about a peer connecting.
Definition: core_api.c:99
#define LOG(kind,...)
Definition: core_api.c:32
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
void(* GNUNET_CORE_DisconnectEventHandler)(void *cls, const struct GNUNET_PeerIdentity *peer, void *peer_cls)
Method called whenever a peer disconnects.
struct GNUNET_MQ_MessageHandler * GNUNET_MQ_copy_handlers(const struct GNUNET_MQ_MessageHandler *handlers)
Copy an array of handlers.
Definition: mq.c:1215
static void handle_disconnect_notify(void *cls, const struct DisconnectNotifyMessage *dnm)
Handle disconnect message received from CORE service.
Definition: core_api.c:496
static int check_notify_inbound(void *cls, const struct NotifyTrafficMessage *ntm)
Check that message received from CORE service is well-formed.
Definition: core_api.c:530
Message sent by the service to clients to notify them about a peer connecting.
Definition: core.h:126
struct GNUNET_MQ_Handle * mq
Message queue for the peer.
Definition: core_api.c:49
common internal definitions for core service
void * cls
Closure for the various callbacks.
Definition: core_api.c:89
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we&#39;re using.
Definition: core_api.c:84
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
int GNUNET_CONTAINER_multipeermap_remove(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, const void *value)
Remove the given key-value pair from the map.
void(* GNUNET_CORE_StartupCallback)(void *cls, const struct GNUNET_PeerIdentity *my_identity)
Function called after GNUNET_CORE_connect has succeeded (or failed for good).
#define GNUNET_NO
Definition: gnunet_common.h:81
struct GNUNET_PeerIdentity peer
Peer the record is about.
Definition: core_api.c:66
#define GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND
Notify clients about incoming P2P messages.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
GNUNET_MQ_PriorityPreferences
Per envelope preferences and priorities.
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_MESSAGE_TYPE_CORE_NOTIFY_DISCONNECT
Notify clients about peer disconnecting.
uint32_t options
Options, see GNUNET_CORE_OPTION_ values.
Definition: core.h:94
struct GNUNET_PeerIdentity my_identity
Public key of the local peer.
Definition: core.h:118
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
static void core_mq_cancel_impl(struct GNUNET_MQ_Handle *mq, void *impl_state)
Implementation function that cancels the currently sent message.
Definition: core_api.c:340
struct GNUNET_CONTAINER_MultiPeerMap * GNUNET_CONTAINER_multipeermap_create(unsigned int len, int do_not_copy_keys)
Create a multi peer map (hash map for public keys of peers).
struct GNUNET_PeerIdentity peer
Identity of the intended target.
Definition: core.h:219
Message transmitted core clients to gnunet-service-core to start the interaction. ...
Definition: core.h:83
struct GNUNET_SCHEDULER_Task * reconnect_task
ID of reconnect task (if any).
Definition: core_api.c:130
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
void GNUNET_CONTAINER_multipeermap_destroy(struct GNUNET_CONTAINER_MultiPeerMap *map)
Destroy a hash map.
int have_init
Did we ever get INIT?
Definition: core_api.c:145
struct GNUNET_CORE_Handle * h
Corresponding CORE handle.
Definition: core_api.c:44
void *(* GNUNET_CORE_ConnectEventHandler)(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
Method called whenever a given peer connects.
Message transmitted by the gnunet-service-core process to its clients in response to an INIT message...
Definition: core.h:102
enum GNUNET_MQ_PriorityPreferences GNUNET_MQ_env_get_options(struct GNUNET_MQ_Envelope *env)
Get performance preferences set for this envelope.
Definition: mq.c:1020
void GNUNET_MQ_set_handlers_closure(struct GNUNET_MQ_Handle *mq, void *handlers_cls)
Change the closure argument in all of the handlers of the mq.
Definition: mq.c:583
#define GNUNET_MESSAGE_TYPE_CORE_SEND_REQUEST
Request from client to transmit message.
static struct GNUNET_ARM_MonitorHandle * m
Monitor connection with ARM.
Definition: gnunet-arm.c:99
static void handle_init_reply(void *cls, const struct InitReplyMessage *m)
Handle init reply message received from CORE service.
Definition: core_api.c:416
#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:52
#define GNUNET_MESSAGE_TYPE_CORE_INIT
Initial setup message from core client to core.
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:1246
uint16_t type
Type of the message this handler covers, in host byte order.
Core notifying client that it is allowed to now transmit a message to the given target (response to G...
Definition: core.h:243
struct GNUNET_MQ_Handle * GNUNET_MQ_queue_for_callbacks(GNUNET_MQ_SendImpl send, GNUNET_MQ_DestroyImpl destroy, GNUNET_MQ_CancelImpl cancel, void *impl_state, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *cls)
Create a message queue for the specified handlers.
Definition: mq.c:552
static int disconnect_and_free_peer_entry(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Notify clients about disconnect and free the entry for connected peer.
Definition: core_api.c:186
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
void * client_cls
Value the client returned when we connected, used as the closure in various places.
Definition: core_api.c:61
static char * value
Value of the record to add/remove.
struct GNUNET_TIME_Relative retry_backoff
Current delay we use for re-trying to connect to core.
Definition: core_api.c:135
uint16_t size
How large is the message?
Definition: core.h:229
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
uint16_t smr_id
Counter for this peer to match SMRs to replies.
Definition: core.h:234
static void reconnect_task(void *cls)
Task schedule to try to re-connect to core.
Definition: core_api.c:166
static void core_mq_destroy_impl(struct GNUNET_MQ_Handle *mq, void *impl_state)
Handle destruction of a message queue.
Definition: core_api.c:323
Client asking core to transmit a particular message to a particular target (response to GNUNET_MESSAG...
Definition: core.h:274
struct GNUNET_PeerIdentity peer
Identity of the intended receiver.
Definition: core.h:296
static void reconnect_later(struct GNUNET_CORE_Handle *h)
Close down any existing connection to the CORE service and try re-establishing it later...
Definition: core_api.c:217
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
void GNUNET_MQ_inject_message(struct GNUNET_MQ_Handle *mq, const struct GNUNET_MessageHeader *mh)
Call the message message handler that was registered for the type of the given message in the given m...
Definition: mq.c:202
Client notifying core about the maximum-priority message it has in the queue for a particular target...
Definition: core.h:198
struct GNUNET_MQ_Handle * mq
Our message queue for transmissions to the service.
Definition: core_api.c:114
struct GNUNET_PeerIdentity peer
Identity of the connecting peer.
Definition: core.h:141
Internal representation of the hash map.
#define GNUNET_TIME_UNIT_MILLISECONDS
One millisecond.
Message handler for a specific message type.
void * connects(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
Definition: 010.c:2
unsigned int GNUNET_MQ_count_handlers(const struct GNUNET_MQ_MessageHandler *handlers)
Count the handlers in a handler array.
Definition: mq.c:1275
void GNUNET_MQ_discard(struct GNUNET_MQ_Envelope *mqm)
Discard the message queue message, free all allocated resources.
Definition: mq.c:321
struct GNUNET_MessageHeader header
Header with type GNUNET_MESSAGE_TYPE_CORE_NOTIFY_INBOUND or GNUNET_MESSAGE_TYPE_CORE_NOTIFY_OUTBOUND...
Definition: core.h:183
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:104
void disconnects(void *cls, const struct GNUNET_PeerIdentity *peer)
Definition: 011.c:2
There must only be one value per key; storing a value should fail if a value under the same key alrea...
struct GNUNET_HashCode key
The key used in the DHT.
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
#define GNUNET_MESSAGE_TYPE_CORE_SEND_READY
Confirmation from core that message can now be sent.
static void handle_notify_inbound(void *cls, const struct NotifyTrafficMessage *ntm)
Handle inbound message received from CORE service.
Definition: core_api.c:560
struct GNUNET_CORE_Handle * GNUNET_CORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, void *cls, GNUNET_CORE_StartupCallback init, GNUNET_CORE_ConnectEventHandler connects, GNUNET_CORE_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Connect to the core service.
Definition: core_api.c:694
void GNUNET_CORE_disconnect(struct GNUNET_CORE_Handle *handle)
Disconnect from the core service.
Definition: core_api.c:732
struct GNUNET_MQ_MessageHandler * handlers
Function handlers for messages of particular type.
Definition: core_api.c:109
#define GNUNET_MESSAGE_TYPE_CORE_NOTIFY_CONNECT
Notify clients about new peer-to-peer connections (triggered after key exchange). ...
static char * init
Set to the name of a service to start.
Definition: gnunet-arm.c:69
#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 void core_mq_send_impl(struct GNUNET_MQ_Handle *mq, const struct GNUNET_MessageHeader *msg, void *impl_state)
Implement sending functionality of a message queue for us sending messages to a peer.
Definition: core_api.c:261
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message...
struct GNUNET_MQ_Handle * GNUNET_CORE_get_mq(const struct GNUNET_CORE_Handle *h, const struct GNUNET_PeerIdentity *pid)
Obtain the message queue for a connected peer.
Definition: core_api.c:763
struct GNUNET_CONTAINER_MultiPeerMap * peers
Hash map listing all of the peers that we are currently connected to.
Definition: core_api.c:120
uint16_t smr_id
smr_id from the request.
Definition: core.h:261
Handle to a message queue.
Definition: mq.c:85
static void handle_connect_notify(void *cls, const struct ConnectNotifyMessage *cnm)
Handle connect message received from CORE service.
Definition: core_api.c:463
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
The identity of the host (wraps the signing key of the peer).
static void handle_mq_error(void *cls, enum GNUNET_MQ_Error error)
Error handler for the message queue to the CORE service.
Definition: core_api.c:243
uint32_t reserved
Always zero.
Definition: core.h:159
configuration data
Definition: configuration.c:85
uint32_t priority
How important is this message? Contains a enum GNUNET_MQ_PriorityPreferences in NBO.
Definition: core.h:285
void * GNUNET_CONTAINER_multipeermap_get(const struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key)
Given a key find a value in the map matching the key.
static void * connect_notify(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
Method called whenever a peer connects.
Entry in list of pending tasks.
Definition: scheduler.c:134
static void handle_send_ready(void *cls, const struct SendMessageReady *smr)
Handle message received from CORE service notifying us that we are now allowed to send a message to a...
Definition: core_api.c:590
static void reconnect(struct GNUNET_CORE_Handle *h)
Our current client connection went down.
Definition: core_api.c:632
Message sent by the service to clients to notify them about a peer disconnecting. ...
Definition: core.h:149
Message sent by the service to clients to notify them about messages being received or transmitted...
Definition: core.h:177
struct GNUNET_PeerIdentity peer
Identity of the connecting peer.
Definition: core.h:164
Header for all communications.
struct GNUNET_MQ_Envelope * GNUNET_MQ_get_current_envelope(struct GNUNET_MQ_Handle *mq)
Function to obtain the current envelope from within GNUNET_MQ_SendImpl implementations.
Definition: mq.c:974
unsigned int hcnt
Number of entries in the handlers array.
Definition: core_api.c:140
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:824
#define GNUNET_YES
Definition: gnunet_common.h:80
uint32_t reserved
Always zero.
Definition: core.h:113
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:353
static struct GNUNET_PeerIdentity pid
Identity of the peer we transmit to / connect to.
uint16_t smr_id_gen
SendMessageRequest ID generator for this peer.
Definition: core_api.c:71
void GNUNET_MQ_impl_send_continue(struct GNUNET_MQ_Handle *mq)
Call the send implementation for the next queued message, if any.
Definition: mq.c:486
struct GNUNET_PeerIdentity peer
Identity of the intended target.
Definition: core.h:266
#define GNUNET_MESSAGE_TYPE_CORE_INIT_REPLY
Response from core to core client to INIT message.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
struct GNUNET_PeerIdentity peer
Identity of the receiver or sender.
Definition: core.h:188
static void core_mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
We had an error processing a message we forwarded from a peer to the CORE service.
Definition: core_api.c:360
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.
static void disconnect_notify(void *cls, const struct GNUNET_PeerIdentity *peer, void *internal_cls)
Method called whenever a peer disconnects.
GNUNET_CORE_DisconnectEventHandler disconnects
Function to call whenever we&#39;re notified about a peer disconnecting.
Definition: core_api.c:104
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965