GNUnet  0.19.3
cadet_api.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2011, 2017 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_cadet_service.h"
30 #include "cadet.h"
31 #include "cadet_protocol.h"
32 
33 #define LOG(kind, ...) GNUNET_log_from (kind, "cadet-api", __VA_ARGS__)
34 
39 {
44 
49 
54 
59 
64 
69 
74 };
75 
80 {
84  struct GNUNET_HashCode id;
85 
90 
94  void *cls;
95 
100 
105 
110 
115 
120 };
121 
122 
130 static struct GNUNET_CADET_Port *
132  const struct GNUNET_HashCode *hash)
133 {
134  return GNUNET_CONTAINER_multihashmap_get (h->ports, hash);
135 }
136 
137 
145 static struct GNUNET_CADET_Channel *
148 {
149  return GNUNET_CONTAINER_multihashmap32_get (h->channels,
150  ntohl (ccn.channel_of_client));
151 }
152 
153 
161 static struct GNUNET_CADET_Channel *
163  const struct GNUNET_CADET_ClientChannelNumber *ccnp)
164 {
165  struct GNUNET_CADET_Channel *ch;
167 
169  ch->cadet = h;
170  if (NULL == ccnp)
171  {
172  while (NULL != find_channel (h, h->next_ccn))
173  h->next_ccn.channel_of_client =
175  | (1 + ntohl (h->next_ccn.channel_of_client)));
176  ccn = h->next_ccn;
177  }
178  else
179  {
180  ccn = *ccnp;
181  }
182  ch->ccn = ccn;
185  h->channels,
186  ntohl (ch->ccn.channel_of_client),
187  ch,
189  return ch;
190 }
191 
192 
202 static void
204 {
205  struct GNUNET_CADET_Handle *h = ch->cadet;
206 
208  "Destroying channel %X of %p\n",
209  htonl (ch->ccn.channel_of_client),
210  h);
211  GNUNET_assert (
212  GNUNET_YES ==
214  ntohl (ch->ccn.channel_of_client),
215  ch));
216  if (NULL != ch->mq_cont)
217  {
219  ch->mq_cont = NULL;
220  }
221  /* signal channel destruction */
222  if (NULL != ch->disconnects)
223  ch->disconnects (ch->ctx, ch);
224  if (NULL != ch->pending_env)
227  GNUNET_free (ch);
228 }
229 
230 
237 static void
239 
240 
250 static int
251 open_port_cb (void *cls, const struct GNUNET_HashCode *id, void *value)
252 {
253  struct GNUNET_CADET_Handle *h = cls;
254  struct GNUNET_CADET_Port *port = value;
256  struct GNUNET_MQ_Envelope *env;
257 
258  (void) id;
260  msg->port = port->id;
261  GNUNET_MQ_send (h->mq, env);
262  return GNUNET_OK;
263 }
264 
265 
272 static void
273 reconnect_cbk (void *cls)
274 {
275  struct GNUNET_CADET_Handle *h = cls;
276 
277  h->reconnect_task = NULL;
278  h->reconnect_time = GNUNET_TIME_STD_BACKOFF (h->reconnect_time);
279  reconnect (h);
281 }
282 
283 
289 static void
291 {
292  if (NULL != ch->window_changes)
293  ch->window_changes (ch->ctx,
294  ch, /* FIXME: remove 'ch'? */
295  ch->allow_send);
296 }
297 
298 
304 static void
305 cadet_mq_send_now (void *cls)
306 {
307  struct GNUNET_CADET_Channel *ch = cls;
309 
310  ch->mq_cont = NULL;
311  if (0 == ch->allow_send)
312  {
313  /* how did we get here? */
314  GNUNET_break (0);
315  return;
316  }
317  if (NULL == env)
318  {
319  /* how did we get here? */
320  GNUNET_break (0);
321  return;
322  }
323  ch->allow_send--;
324  ch->pending_env = NULL;
326  "Sending message on channel %s to CADET, new window size is %u\n",
327  GNUNET_i2s (&ch->peer),
328  ch->allow_send);
331 }
332 
333 
346 static void
348  const struct GNUNET_MessageHeader *msg,
349  void *impl_state)
350 {
351  struct GNUNET_CADET_Channel *ch = impl_state;
352  struct GNUNET_CADET_Handle *h = ch->cadet;
353  uint16_t msize;
354  struct GNUNET_MQ_Envelope *orig_env;
355  struct GNUNET_MQ_Envelope *env;
356  struct GNUNET_CADET_LocalData *cadet_msg;
358 
359  if (NULL == h->mq)
360  {
361  /* We're currently reconnecting, pretend this worked */
363  return;
364  }
365  orig_env = GNUNET_MQ_get_current_envelope (mq);
366  pp = GNUNET_MQ_env_get_options (orig_env);
367 
368  /* check message size for sanity */
369  msize = ntohs (msg->size);
371  {
372  GNUNET_break (0);
374  return;
375  }
376  env = GNUNET_MQ_msg_nested_mh (cadet_msg,
378  msg);
379  cadet_msg->ccn = ch->ccn;
380  cadet_msg->pp = htonl ((uint32_t) pp);
381  GNUNET_assert (NULL == ch->pending_env);
382  ch->pending_env = env;
383  if (0 < ch->allow_send)
385 }
386 
387 
395 static void
396 cadet_mq_destroy_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
397 {
398  struct GNUNET_CADET_Channel *ch = impl_state;
399 
400  GNUNET_assert (mq == ch->mq);
401  ch->mq = NULL;
402 }
403 
404 
413 static void
415 {
416  struct GNUNET_CADET_Channel *ch = cls;
417 
418  if (GNUNET_MQ_ERROR_NO_MATCH == error)
419  {
420  /* Got a message we did not understand, still try to continue! */
421  GNUNET_break_op (0);
423  }
424  else
425  {
427  "MQ error in communication with CADET: %d\n",
428  error);
429  if (NULL != ch->disconnects)
430  ch->disconnects (ch->ctx, ch);
432  }
433 }
434 
435 
443 static void
444 cadet_mq_cancel_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
445 {
446  struct GNUNET_CADET_Channel *ch = impl_state;
447 
448  (void) mq;
449  GNUNET_assert (NULL != ch->pending_env);
451  ch->pending_env = NULL;
452  if (NULL != ch->mq_cont)
453  {
455  ch->mq_cont = NULL;
456  }
457 }
458 
459 
466 static void
468  void *cls,
470 {
471  struct GNUNET_CADET_Handle *h = cls;
472  struct GNUNET_CADET_Channel *ch;
473  struct GNUNET_CADET_Port *port;
474  const struct GNUNET_HashCode *port_number;
476 
477  ccn = msg->ccn;
478  port_number = &msg->port;
480  {
481  GNUNET_break (0);
482  return;
483  }
484  port = find_port (h, port_number);
485  if (NULL == port)
486  {
487  /* We could have closed the port but the service didn't know about it yet
488  * This is not an error.
489  */
491  struct GNUNET_MQ_Envelope *env;
492 
494  "No handler for incoming channel %X (on port %s, recently closed?)\n",
495  ntohl (ccn.channel_of_client),
496  GNUNET_h2s (port_number));
497  env =
499  d_msg->ccn = msg->ccn;
500  GNUNET_MQ_send (h->mq, env);
501  return;
502  }
503 
504  ch = create_channel (h, &ccn);
505  ch->peer = msg->peer;
506  ch->incoming_port = port;
508  "Creating incoming channel %X [%s] %p\n",
509  ntohl (ccn.channel_of_client),
510  GNUNET_h2s (port_number),
511  ch);
512 
513  GNUNET_assert (NULL != port->connects);
514  ch->window_changes = port->window_changes;
515  ch->disconnects = port->disconnects;
519  ch,
520  port->handlers,
522  ch);
523  ch->ctx = port->connects (port->cls, ch, &msg->peer);
525 }
526 
527 
534 static void
536  void *cls,
538 {
539  struct GNUNET_CADET_Handle *h = cls;
540  struct GNUNET_CADET_Channel *ch;
541 
542  ch = find_channel (h, msg->ccn);
543  if (NULL == ch)
544  {
546  "Received channel destroy for unknown channel %X from CADET service (recently close?)\n",
547  ntohl (msg->ccn.channel_of_client));
548  return;
549  }
551  "Received channel destroy for channel %X from CADET service\n",
552  ntohl (msg->ccn.channel_of_client));
554 }
555 
556 
565 static int
566 check_local_data (void *cls, const struct GNUNET_CADET_LocalData *message)
567 {
568  uint16_t size;
569 
570  (void) cls;
571  size = ntohs (message->header.size);
572  if (sizeof(*message) + sizeof(struct GNUNET_MessageHeader) > size)
573  {
574  GNUNET_break (0);
575  return GNUNET_SYSERR;
576  }
577  return GNUNET_OK;
578 }
579 
580 
587 static void
588 handle_local_data (void *cls, const struct GNUNET_CADET_LocalData *message)
589 {
590  struct GNUNET_CADET_Handle *h = cls;
591  const struct GNUNET_MessageHeader *payload;
592  struct GNUNET_CADET_Channel *ch;
593  uint16_t type;
594  int fwd;
595 
596  ch = find_channel (h, message->ccn);
597  if (NULL == ch)
598  {
600  "Unknown channel %X for incoming data (recently closed?)\n",
601  ntohl (message->ccn.channel_of_client));
602  return;
603  }
604 
605  payload = (const struct GNUNET_MessageHeader *) &message[1];
606  type = ntohs (payload->type);
609  "Got a %s data on channel %s [%X] of type %u\n",
610  fwd ? "FWD" : "BWD",
611  GNUNET_i2s (&ch->peer),
612  ntohl (message->ccn.channel_of_client),
613  type);
615 }
616 
617 
625 static void
626 handle_local_ack (void *cls, const struct GNUNET_CADET_LocalAck *message)
627 {
628  struct GNUNET_CADET_Handle *h = cls;
629  struct GNUNET_CADET_Channel *ch;
630 
631  ch = find_channel (h, message->ccn);
632  if (NULL == ch)
633  {
635  "ACK on unknown channel %X\n",
636  ntohl (message->ccn.channel_of_client));
637  return;
638  }
639  ch->allow_send++;
641  "Got an ACK on mq channel %X (peer %s); new window size is %u!\n",
642  ntohl (ch->ccn.channel_of_client),
643  GNUNET_i2s (&ch->peer),
644  ch->allow_send);
645  if (NULL == ch->pending_env)
646  {
648  "Got an ACK on mq channel %X, allow send now %u!\n",
649  ntohl (ch->ccn.channel_of_client),
650  ch->allow_send);
652  return;
653  }
654  if (NULL != ch->mq_cont)
655  return; /* already working on it! */
657 }
658 
659 
669 static int
670 destroy_channel_cb (void *cls, uint32_t cid, void *value)
671 {
672  /* struct GNUNET_CADET_Handle *handle = cls; */
673  struct GNUNET_CADET_Channel *ch = value;
674 
675  (void) cls;
676  (void) cid;
678  "Destroying channel due to GNUNET_CADET_disconnect()\n");
680  return GNUNET_OK;
681 }
682 
683 
692 static void
693 handle_mq_error (void *cls, enum GNUNET_MQ_Error error)
694 {
695  struct GNUNET_CADET_Handle *h = cls;
696 
697  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MQ ERROR: %u\n", error);
700  h->mq = NULL;
701  GNUNET_assert (NULL == h->reconnect_task);
702  h->reconnect_task =
703  GNUNET_SCHEDULER_add_delayed (h->reconnect_time, &reconnect_cbk, h);
704 }
705 
706 
713 static void
715 {
717  { GNUNET_MQ_hd_fixed_size (channel_created,
720  h),
724  h),
725  GNUNET_MQ_hd_var_size (local_data,
727  struct GNUNET_CADET_LocalData,
728  h),
729  GNUNET_MQ_hd_fixed_size (local_ack,
731  struct GNUNET_CADET_LocalAck,
732  h),
734 
735  GNUNET_assert (NULL == h->mq);
736  h->mq =
738 }
739 
740 
750 static int
751 destroy_port_cb (void *cls, const struct GNUNET_HashCode *id, void *value)
752 {
753  /* struct GNUNET_CADET_Handle *handle = cls; */
754  struct GNUNET_CADET_Port *port = value;
755 
756  (void) cls;
757  (void) id;
758  /* This is a warning, the app should have cleanly closed all open ports */
759  GNUNET_break (0);
761  return GNUNET_OK;
762 }
763 
764 
773 void
775 {
778  handle);
780  handle->ports = NULL;
783  handle);
785  handle->channels = NULL;
786  if (NULL != handle->mq)
787  {
789  handle->mq = NULL;
790  }
791  if (NULL != handle->reconnect_task)
792  {
794  handle->reconnect_task = NULL;
795  }
797 }
798 
799 
800 void
802 {
803  GNUNET_assert (
804  GNUNET_YES ==
805  GNUNET_CONTAINER_multihashmap_remove (p->cadet->ports, &p->id, p));
806  if (NULL != p->cadet->mq)
807  {
809  struct GNUNET_MQ_Envelope *env;
810 
812  msg->port = p->id;
813  GNUNET_MQ_send (p->cadet->mq, env);
814  }
815  GNUNET_free (p->handlers);
816  GNUNET_free (p);
817 }
818 
819 
829 void
831 {
832  struct GNUNET_CADET_Handle *h = channel->cadet;
834  struct GNUNET_MQ_Envelope *env;
835 
836  if (NULL != h->mq)
837  {
839  msg->ccn = channel->ccn;
840  GNUNET_MQ_send (h->mq, env);
841  }
843  "Destroying channel due to GNUNET_CADET_channel_destroy()\n");
844  channel->disconnects = NULL;
845  destroy_channel (channel);
846 }
847 
848 
849 const union GNUNET_CADET_ChannelInfo *
851  enum GNUNET_CADET_ChannelInfoOption option,
852  ...)
853 {
854  switch (option)
855  {
857  return (const union GNUNET_CADET_ChannelInfo *) &channel->peer;
858 
859  default:
860  GNUNET_break (0);
861  return NULL;
862  }
863 }
864 
865 
871 void
873 {
874  struct GNUNET_CADET_LocalAck *msg;
875  struct GNUNET_MQ_Envelope *env;
876 
879  "Sending ACK on channel %X\n",
880  ntohl (channel->ccn.channel_of_client));
881  msg->ccn = channel->ccn;
882  GNUNET_MQ_send (channel->cadet->mq, env);
883 }
884 
885 
893 struct GNUNET_CADET_Handle *
895 {
896  struct GNUNET_CADET_Handle *h;
897 
898  LOG (GNUNET_ERROR_TYPE_DEBUG, "GNUNET_CADET_connect()\n");
899  h = GNUNET_new (struct GNUNET_CADET_Handle);
900  h->cfg = cfg;
903  reconnect (h);
904  if (NULL == h->mq)
905  {
906  GNUNET_break (0);
908  return NULL;
909  }
910  h->next_ccn.channel_of_client = htonl (GNUNET_CADET_LOCAL_CHANNEL_ID_CLI);
911  return h;
912 }
913 
914 
921 static void
922 return_agpl (void *cls, const struct GNUNET_MessageHeader *msg)
923 {
924  struct GNUNET_SERVICE_Client *client = cls;
925  struct GNUNET_MQ_Handle *mq;
926  struct GNUNET_MQ_Envelope *env;
927  struct GNUNET_MessageHeader *res;
928  size_t slen;
930 
931  (void) msg;
932  slen = strlen (pd->agpl_url) + 1;
934  memcpy (&res[1], GNUNET_AGPL_URL, slen);
935  mq = GNUNET_SERVICE_client_get_mq (client);
936  GNUNET_MQ_send (mq, env);
938 }
939 
940 
953 struct GNUNET_CADET_Port *
955  const struct GNUNET_HashCode *port,
957  void *connects_cls,
960  const struct GNUNET_MQ_MessageHandler *handlers)
961 {
962  struct GNUNET_CADET_Port *p;
964 
965  GNUNET_assert (NULL != connects);
966  GNUNET_assert (NULL != disconnects);
968  "Listening to CADET port %s\n",
969  GNUNET_h2s (port));
970 
971  p = GNUNET_new (struct GNUNET_CADET_Port);
972  p->cadet = h;
973  p->id = *port;
975  h->ports,
976  &p->id,
977  p,
979  {
980  GNUNET_free (p);
981  return NULL;
982  }
983  p->connects = connects;
984  p->cls = connects_cls;
985  p->window_changes = window_changes;
986  p->disconnects = disconnects;
987  p->handlers = (NULL == pd->agpl_url)
990 
991  GNUNET_assert (GNUNET_OK == open_port_cb (h, &p->id, p));
992  return p;
993 }
994 
995 
1014 struct GNUNET_CADET_Channel *
1016  void *channel_cls,
1017  const struct GNUNET_PeerIdentity *destination,
1018  const struct GNUNET_HashCode *port,
1021  const struct GNUNET_MQ_MessageHandler *handlers)
1022 {
1023  struct GNUNET_CADET_Channel *ch;
1025  struct GNUNET_MQ_Envelope *env;
1026 
1027  GNUNET_assert (NULL != disconnects);
1029  "Creating channel to peer %s at port %s\n",
1030  GNUNET_i2s (destination),
1031  GNUNET_h2s (port));
1032  ch = create_channel (h, NULL);
1033  ch->ctx = channel_cls;
1034  ch->peer = *destination;
1035  ch->window_changes = window_changes;
1037 
1038  /* Create MQ for channel */
1042  ch,
1043  handlers,
1045  ch);
1046  GNUNET_MQ_set_handlers_closure (ch->mq, channel_cls);
1047 
1048  /* Request channel creation to service */
1050  msg->ccn = ch->ccn;
1051  msg->port = *port;
1052  msg->peer = *destination;
1053  GNUNET_MQ_send (h->mq, env);
1054  return ch;
1055 }
1056 
1057 
1065 struct GNUNET_MQ_Handle *
1067 {
1068  return channel->mq;
1069 }
1070 
1071 
1072 /* end of cadet_api.c */
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
void * connects(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
Definition: 010.c:2
void disconnects(void *cls, const struct GNUNET_PeerIdentity *peer)
Definition: 011.c:2
#define GNUNET_CADET_LOCAL_CHANNEL_ID_CLI
Minimum value for channel IDs of local clients.
Definition: cadet.h:70
static void notify_window_size(struct GNUNET_CADET_Channel *ch)
Notify the application about a change in the window size (if needed).
Definition: cadet_api.c:290
static void reconnect_cbk(void *cls)
Reconnect callback: tries to reconnect again after a failed previous connection.
Definition: cadet_api.c:273
static struct GNUNET_CADET_Channel * create_channel(struct GNUNET_CADET_Handle *h, const struct GNUNET_CADET_ClientChannelNumber *ccnp)
Create a new channel and insert it in the channel list of the cadet handle.
Definition: cadet_api.c:162
static void cadet_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: cadet_api.c:347
static void handle_channel_destroy(void *cls, const struct GNUNET_CADET_LocalChannelDestroyMessage *msg)
Process the channel destroy notification and free associated resources.
Definition: cadet_api.c:535
static void return_agpl(void *cls, const struct GNUNET_MessageHeader *msg)
Function to return link to AGPL source upon request.
Definition: cadet_api.c:922
static void cadet_mq_send_now(void *cls)
Transmit the next message from our queue.
Definition: cadet_api.c:305
static void cadet_mq_destroy_impl(struct GNUNET_MQ_Handle *mq, void *impl_state)
Handle destruction of a message queue.
Definition: cadet_api.c:396
static void destroy_channel(struct GNUNET_CADET_Channel *ch)
Destroy the specified channel.
Definition: cadet_api.c:203
static void cadet_mq_cancel_impl(struct GNUNET_MQ_Handle *mq, void *impl_state)
Implementation function that cancels the currently sent message.
Definition: cadet_api.c:444
static struct GNUNET_CADET_Channel * find_channel(struct GNUNET_CADET_Handle *h, struct GNUNET_CADET_ClientChannelNumber ccn)
Get the channel handler for the channel specified by id from the given handle.
Definition: cadet_api.c:146
static void handle_local_data(void *cls, const struct GNUNET_CADET_LocalData *message)
Process the incoming data packets, call appropriate handlers.
Definition: cadet_api.c:588
static void cadet_mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
We had an error processing a message we forwarded from a peer to the CADET service.
Definition: cadet_api.c:414
static struct GNUNET_CADET_Port * find_port(const struct GNUNET_CADET_Handle *h, const struct GNUNET_HashCode *hash)
Find the Port struct for a hash.
Definition: cadet_api.c:131
static int destroy_channel_cb(void *cls, uint32_t cid, void *value)
Function called during GNUNET_CADET_disconnect() to destroy all channels that are still open.
Definition: cadet_api.c:670
static void handle_local_ack(void *cls, const struct GNUNET_CADET_LocalAck *message)
Process a local ACK message, enabling the client to send more data to the service.
Definition: cadet_api.c:626
static void reconnect(struct GNUNET_CADET_Handle *h)
Reconnect to the service, retransmit all information to try to restore the original state.
Definition: cadet_api.c:714
#define LOG(kind,...)
Definition: cadet_api.c:33
static int check_local_data(void *cls, const struct GNUNET_CADET_LocalData *message)
Check that message received from CADET service is well-formed.
Definition: cadet_api.c:566
static int open_port_cb(void *cls, const struct GNUNET_HashCode *id, void *value)
Function called during reconnect_cbk() to (re)open all ports that are still open.
Definition: cadet_api.c:251
static void handle_channel_created(void *cls, const struct GNUNET_CADET_LocalChannelCreateMessage *msg)
Process the new channel notification and add it to the channels in the handle.
Definition: cadet_api.c:467
static int destroy_port_cb(void *cls, const struct GNUNET_HashCode *id, void *value)
Function called during GNUNET_CADET_disconnect() to destroy all ports that are still open.
Definition: cadet_api.c:751
static void handle_mq_error(void *cls, enum GNUNET_MQ_Error error)
Generic error handler, called with the appropriate error code and the same closure specified at the c...
Definition: cadet_api.c:693
P2P messages used by CADET.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
static int res
static uint16_t port
Port number.
Definition: gnunet-bcd.c:147
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
static char * value
Value of the record to add/remove.
static void channel_destroy(struct CadetChannel *ch)
Destroy the given channel.
static unsigned long long payload
How much data are we currently storing in the database?
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-uri.c:38
CADET service; establish channels to distant peers.
#define GNUNET_AGPL_URL
NOTE: You MUST adjust this URL to point to the location of a publicly accessible repository (or TGZ) ...
struct GNUNET_CADET_Channel * GNUNET_CADET_channel_create(struct GNUNET_CADET_Handle *h, void *channel_cls, const struct GNUNET_PeerIdentity *destination, const struct GNUNET_HashCode *port, GNUNET_CADET_WindowSizeEventHandler window_changes, GNUNET_CADET_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Create a new channel towards a remote peer.
Definition: cadet_api.c:1015
void GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
Send an ack on the channel to confirm the processing of a message.
Definition: cadet_api.c:872
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:830
void(* GNUNET_CADET_DisconnectEventHandler)(void *cls, const struct GNUNET_CADET_Channel *channel)
Function called whenever an MQ-channel is destroyed, unless the destruction was requested by GNUNET_C...
GNUNET_CADET_ChannelInfoOption
const union GNUNET_CADET_ChannelInfo * GNUNET_CADET_channel_get_info(struct GNUNET_CADET_Channel *channel, enum GNUNET_CADET_ChannelInfoOption option,...)
Get information about a channel.
Definition: cadet_api.c:850
void GNUNET_CADET_disconnect(struct GNUNET_CADET_Handle *handle)
Disconnect from the cadet service.
Definition: cadet_api.c:774
void GNUNET_CADET_close_port(struct GNUNET_CADET_Port *p)
Close a port opened with GNUNET_CADET_open_port.
Definition: cadet_api.c:801
void(* GNUNET_CADET_WindowSizeEventHandler)(void *cls, const struct GNUNET_CADET_Channel *channel, int window_size)
Function called whenever an MQ-channel's transmission window size changes.
void *(* GNUNET_CADET_ConnectEventHandler)(void *cls, struct GNUNET_CADET_Channel *channel, const struct GNUNET_PeerIdentity *source)
Method called whenever a peer connects to a port in MQ-based CADET.
struct GNUNET_MQ_Handle * GNUNET_CADET_get_mq(const struct GNUNET_CADET_Channel *channel)
Obtain the message queue for a connected peer.
Definition: cadet_api.c:1066
struct GNUNET_CADET_Handle * GNUNET_CADET_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the MQ-based cadet service.
Definition: cadet_api.c:894
struct GNUNET_CADET_Port * GNUNET_CADET_open_port(struct GNUNET_CADET_Handle *h, const struct GNUNET_HashCode *port, GNUNET_CADET_ConnectEventHandler connects, void *connects_cls, GNUNET_CADET_WindowSizeEventHandler window_changes, GNUNET_CADET_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Open a port to receive incoming MQ-based channels.
Definition: cadet_api.c:954
@ GNUNET_CADET_OPTION_PEER
Who is the peer at the other end of the channel.
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:1057
#define GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE
Maximum message size that can be sent on CADET.
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MultiHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap32_put(struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap32_remove(struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, const void *value)
Remove the given key-value pair from the map.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_remove(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, const void *value)
Remove the given key-value pair from the map.
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.
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
struct GNUNET_CONTAINER_MultiHashMap32 * GNUNET_CONTAINER_multihashmap32_create(unsigned int len)
Create a 32-bit key multi hash map.
void * GNUNET_CONTAINER_multihashmap32_get(const struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key)
Given a key find a value in the map matching the key.
void GNUNET_CONTAINER_multihashmap32_destroy(struct GNUNET_CONTAINER_MultiHashMap32 *map)
Destroy a 32-bit key 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.
int GNUNET_CONTAINER_multihashmap32_iterate(struct GNUNET_CONTAINER_MultiHashMap32 *map, GNUNET_CONTAINER_MultiHashMapIterator32Callback it, void *it_cls)
Iterate over all entries in the map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY
There must only be one value per key; storing a value should fail if a value under the same key alrea...
#define GNUNET_log(kind,...)
void * cls
Closure for mv and cb.
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_SYSERR
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
@ GNUNET_ERROR_TYPE_INFO
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
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:304
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
void GNUNET_MQ_discard(struct GNUNET_MQ_Envelope *mqm)
Discard the message queue message, free all allocated resources.
Definition: mq.c:285
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:465
#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:62
#define GNUNET_MQ_msg_nested_mh(mvar, type, mh)
Allocate a GNUNET_MQ_Envelope, and append a payload message after the given message struct.
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:421
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:77
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:187
GNUNET_MQ_PriorityPreferences
Per envelope preferences and priorities.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
enum GNUNET_MQ_PriorityPreferences GNUNET_MQ_env_get_options(struct GNUNET_MQ_Envelope *env)
Get performance preferences set for this envelope.
Definition: mq.c:839
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
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:489
struct GNUNET_MQ_MessageHandler * GNUNET_MQ_copy_handlers2(const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_MessageCallback agpl_handler, void *agpl_cls)
Copy an array of handlers, appending AGPL handler.
Definition: mq.c:975
struct GNUNET_MQ_MessageHandler * GNUNET_MQ_copy_handlers(const struct GNUNET_MQ_MessageHandler *handlers)
Copy an array of handlers.
Definition: mq.c:957
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:813
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:683
@ GNUNET_MQ_ERROR_NO_MATCH
We received a message for which we have no matching handler.
const struct GNUNET_OS_ProjectData * GNUNET_OS_project_data_get(void)
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE
Ask the cadet service to create a new channel.
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK
Local ACK for data.
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_CLOSE
Stop listening on a port.
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_OPEN
Start listening on a port.
#define GNUNET_MESSAGE_TYPE_RESPONSE_AGPL
Source code link.
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA
Payload client <-> service.
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY
Tell client that a channel was destroyed.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1299
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:975
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:1272
struct GNUNET_MQ_Handle * GNUNET_SERVICE_client_get_mq(struct GNUNET_SERVICE_Client *c)
Obtain the message queue of c.
Definition: service.c:2443
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2249
#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 unsigned int size
Size of the "table".
Definition: peer.c:68
struct GNUNET_MQ_Handle * mq
Our connection to the ARM service.
Definition: arm_api.c:107
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration that we are using.
Definition: arm_api.c:112
struct GNUNET_SCHEDULER_Task * reconnect_task
ID of the reconnect task (if any).
Definition: arm_api.c:147
Opaque handle to a channel.
Definition: cadet.h:116
void * ctx
Any data the caller wants to put in here, used for the various callbacks (disconnects,...
Definition: cadet.h:137
struct GNUNET_CADET_Handle * cadet
Handle to the cadet this channel belongs to.
Definition: cadet.h:126
unsigned int allow_send
How many messages are we allowed to send to the service right now?
Definition: cadet.h:174
struct GNUNET_SCHEDULER_Task * mq_cont
Task to allow mq to send more traffic.
Definition: cadet.h:147
struct GNUNET_PeerIdentity peer
Other end of the channel.
Definition: cadet.h:121
GNUNET_CADET_WindowSizeEventHandler window_changes
Window change handler.
Definition: cadet.h:159
struct GNUNET_CADET_ClientChannelNumber ccn
Local ID of the channel, GNUNET_CADET_LOCAL_CHANNEL_ID_CLI bit is set if outbound.
Definition: cadet.h:169
GNUNET_CADET_DisconnectEventHandler disconnects
Disconnect handler.
Definition: cadet.h:164
struct GNUNET_MQ_Handle * mq
Message Queue for the channel (which we are implementing).
Definition: cadet.h:142
struct GNUNET_MQ_Envelope * pending_env
Pending envelope with a message to be transmitted to the service as soon as we are allowed to.
Definition: cadet.h:154
struct GNUNET_CADET_Port * incoming_port
Channel's port, if incoming.
Definition: cadet.h:131
Number uniquely identifying a channel of a client.
Definition: cadet.h:101
uint32_t channel_of_client
Values for channel numbering.
Definition: cadet.h:109
Opaque handle to the service.
Definition: cadet_api.c:39
struct GNUNET_SCHEDULER_Task * reconnect_task
Task for trying to reconnect.
Definition: cadet_api.c:68
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration given by the client, in case of reconnection.
Definition: cadet_api.c:63
struct GNUNET_CADET_ClientChannelNumber next_ccn
child of the next channel to create (to avoid reusing IDs often)
Definition: cadet_api.c:58
struct GNUNET_CONTAINER_MultiHashMap * ports
Ports open.
Definition: cadet_api.c:48
struct GNUNET_TIME_Relative reconnect_time
Time to the next reconnect in case one reconnect fails.
Definition: cadet_api.c:73
struct GNUNET_MQ_Handle * mq
Message queue.
Definition: cadet_api.c:43
struct GNUNET_CONTAINER_MultiHashMap32 * channels
Channels open.
Definition: cadet_api.c:53
Message to allow the client send more data to the service (always service -> client).
Definition: cadet.h:280
struct GNUNET_CADET_ClientChannelNumber ccn
ID of the channel allowed to send more data.
Definition: cadet.h:289
Message for a client to create channels.
Definition: cadet.h:201
Message for or to a client to destroy tunnel.
Definition: cadet.h:235
struct GNUNET_CADET_ClientChannelNumber ccn
ID of a channel controlled by this client.
Definition: cadet.h:244
Message for cadet data traffic.
Definition: cadet.h:252
struct GNUNET_CADET_ClientChannelNumber ccn
ID of the channel.
Definition: cadet.h:261
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA.
Definition: cadet.h:256
uint32_t pp
Priority and preferences (an enum GNUNET_MQ_PriorityPreferences) of the message in NBO.
Definition: cadet.h:267
Message for a client to create and destroy channels.
Definition: cadet.h:181
Opaque handle to a port.
Definition: cadet_api.c:80
GNUNET_CADET_DisconnectEventHandler disconnects
Handler called when an incoming channel is destroyed.
Definition: cadet_api.c:114
void * cls
Closure for handler.
Definition: cadet_api.c:94
struct GNUNET_MQ_MessageHandler * handlers
Payload handlers for incoming channels.
Definition: cadet_api.c:119
struct GNUNET_HashCode id
Port "number".
Definition: cadet_api.c:84
GNUNET_CADET_WindowSizeEventHandler window_changes
Window size change handler.
Definition: cadet_api.c:109
void * connects_cls
Closure for connects.
Definition: cadet_api.c:104
struct GNUNET_CADET_Handle * cadet
Handle to the CADET session this port belongs to.
Definition: cadet_api.c:89
GNUNET_CADET_ConnectEventHandler connects
Handler for incoming channels on this port.
Definition: cadet_api.c:99
Internal representation of the hash map.
Internal representation of the hash map.
struct GNUNET_SCHEDULER_Task * reconnect_task
Task to reconnect to the service.
Definition: dns_api.c:81
struct GNUNET_MQ_Handle * mq
Connection to DNS service, or NULL.
Definition: dns_api.c:61
A 512-bit hashcode.
Handle to a message queue.
Definition: mq.c:87
Message handler for a specific message type.
Header for all communications.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
Project-specific data used to help the OS subsystem find installation paths.
char * agpl_url
URL pointing to the source code of the application.
The identity of the host (wraps the signing key of the peer).
Entry in list of pending tasks.
Definition: scheduler.c:136
Handle to a client that is connected to a service.
Definition: service.c:252
Time for relative time used by GNUnet, in microseconds.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
Union to retrieve info about a channel.