GNUnet  0.11.x
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 {
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 {
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 
168  ch = GNUNET_new (struct GNUNET_CADET_Channel);
169  ch->cadet = h;
170  if (NULL == ccnp)
171  {
172  while (NULL != find_channel (h, h->next_ccn))
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 
203 static void
205 {
206  struct GNUNET_CADET_Handle *h = ch->cadet;
207 
209  "Destroying channel %X of %p\n",
210  htonl (ch->ccn.channel_of_client),
211  h);
212  GNUNET_assert (
213  GNUNET_YES ==
215  ntohl (ch->ccn.channel_of_client),
216  ch));
217  if (NULL != ch->mq_cont)
218  {
220  ch->mq_cont = NULL;
221  }
222  /* signal channel destruction */
223  if (NULL != ch->disconnects)
224  ch->disconnects (ch->ctx, ch);
225  if (NULL != ch->pending_env)
227  GNUNET_MQ_destroy (ch->mq);
228  GNUNET_free (ch);
229 }
230 
231 
238 static void
240 
241 
251 static int
252 open_port_cb (void *cls, const struct GNUNET_HashCode *id, void *value)
253 {
254  struct GNUNET_CADET_Handle *h = cls;
255  struct GNUNET_CADET_Port *port = value;
257  struct GNUNET_MQ_Envelope *env;
258 
259  (void) id;
261  msg->port = port->id;
262  GNUNET_MQ_send (h->mq, env);
263  return GNUNET_OK;
264 }
265 
266 
273 static void
274 reconnect_cbk (void *cls)
275 {
276  struct GNUNET_CADET_Handle *h = cls;
277 
278  h->reconnect_task = NULL;
280  reconnect (h);
282 }
283 
284 
290 static void
292 {
293  if (NULL != ch->window_changes)
294  ch->window_changes (ch->ctx,
295  ch, /* FIXME: remove 'ch'? */
296  ch->allow_send);
297 }
298 
299 
305 static void
306 cadet_mq_send_now (void *cls)
307 {
308  struct GNUNET_CADET_Channel *ch = cls;
309  struct GNUNET_MQ_Envelope *env = ch->pending_env;
310 
311  ch->mq_cont = NULL;
312  if (0 == ch->allow_send)
313  {
314  /* how did we get here? */
315  GNUNET_break (0);
316  return;
317  }
318  if (NULL == env)
319  {
320  /* how did we get here? */
321  GNUNET_break (0);
322  return;
323  }
324  ch->allow_send--;
325  ch->pending_env = NULL;
327  "Sending message on channel %s to CADET, new window size is %u\n",
328  GNUNET_i2s (&ch->peer),
329  ch->allow_send);
330  GNUNET_MQ_send (ch->cadet->mq, env);
332 }
333 
334 
347 static void
349  const struct GNUNET_MessageHeader *msg,
350  void *impl_state)
351 {
352  struct GNUNET_CADET_Channel *ch = impl_state;
353  struct GNUNET_CADET_Handle *h = ch->cadet;
354  uint16_t msize;
355  struct GNUNET_MQ_Envelope *orig_env;
356  struct GNUNET_MQ_Envelope *env;
357  struct GNUNET_CADET_LocalData *cadet_msg;
359 
360  if (NULL == h->mq)
361  {
362  /* We're currently reconnecting, pretend this worked */
364  return;
365  }
366  orig_env = GNUNET_MQ_get_current_envelope (mq);
367  pp = GNUNET_MQ_env_get_options (orig_env);
368 
369  /* check message size for sanity */
370  msize = ntohs (msg->size);
372  {
373  GNUNET_break (0);
375  return;
376  }
377  env = GNUNET_MQ_msg_nested_mh (cadet_msg,
379  msg);
380  cadet_msg->ccn = ch->ccn;
381  cadet_msg->pp = htonl ((uint32_t) pp);
382  GNUNET_assert (NULL == ch->pending_env);
383  ch->pending_env = env;
384  if (0 < ch->allow_send)
386 }
387 
388 
396 static void
397 cadet_mq_destroy_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
398 {
399  struct GNUNET_CADET_Channel *ch = impl_state;
400 
401  GNUNET_assert (mq == ch->mq);
402  ch->mq = NULL;
403 }
404 
405 
414 static void
416 {
417  struct GNUNET_CADET_Channel *ch = cls;
418 
419  if (GNUNET_MQ_ERROR_NO_MATCH == error)
420  {
421  /* Got a message we did not understand, still try to continue! */
422  GNUNET_break_op (0);
424  }
425  else
426  {
428  "MQ error in communication with CADET: %d\n",
429  error);
430  if (NULL != ch->disconnects)
431  ch->disconnects (ch->ctx, ch);
433  }
434 }
435 
436 
444 static void
445 cadet_mq_cancel_impl (struct GNUNET_MQ_Handle *mq, void *impl_state)
446 {
447  struct GNUNET_CADET_Channel *ch = impl_state;
448 
449  (void) mq;
450  GNUNET_assert (NULL != ch->pending_env);
452  ch->pending_env = NULL;
453  if (NULL != ch->mq_cont)
454  {
456  ch->mq_cont = NULL;
457  }
458 }
459 
460 
467 static void
469  void *cls,
471 {
472  struct GNUNET_CADET_Handle *h = cls;
473  struct GNUNET_CADET_Channel *ch;
474  struct GNUNET_CADET_Port *port;
475  const struct GNUNET_HashCode *port_number;
477 
478  ccn = msg->ccn;
479  port_number = &msg->port;
480  if (ntohl (ccn.channel_of_client) >= GNUNET_CADET_LOCAL_CHANNEL_ID_CLI)
481  {
482  GNUNET_break (0);
483  return;
484  }
485  port = find_port (h, port_number);
486  if (NULL == port)
487  {
488  /* We could have closed the port but the service didn't know about it yet
489  * This is not an error.
490  */
492  struct GNUNET_MQ_Envelope *env;
493 
495  "No handler for incoming channel %X (on port %s, recently closed?)\n",
496  ntohl (ccn.channel_of_client),
497  GNUNET_h2s (port_number));
498  env =
500  d_msg->ccn = msg->ccn;
501  GNUNET_MQ_send (h->mq, env);
502  return;
503  }
504 
505  ch = create_channel (h, &ccn);
506  ch->peer = msg->peer;
507  ch->incoming_port = port;
509  "Creating incoming channel %X [%s] %p\n",
510  ntohl (ccn.channel_of_client),
511  GNUNET_h2s (port_number),
512  ch);
513 
514  GNUNET_assert (NULL != port->connects);
515  ch->window_changes = port->window_changes;
516  ch->disconnects = port->disconnects;
520  ch,
521  port->handlers,
523  ch);
524  ch->ctx = port->connects (port->cls, ch, &msg->peer);
526 }
527 
528 
535 static void
537  void *cls,
539 {
540  struct GNUNET_CADET_Handle *h = cls;
541  struct GNUNET_CADET_Channel *ch;
542 
543  ch = find_channel (h, msg->ccn);
544  if (NULL == ch)
545  {
547  "Received channel destroy for unknown channel %X from CADET service (recently close?)\n",
548  ntohl (msg->ccn.channel_of_client));
549  return;
550  }
552  "Received channel destroy for channel %X from CADET service\n",
553  ntohl (msg->ccn.channel_of_client));
554  destroy_channel (ch);
555 }
556 
557 
566 static int
567 check_local_data (void *cls, const struct GNUNET_CADET_LocalData *message)
568 {
569  uint16_t size;
570 
571  (void) cls;
572  size = ntohs (message->header.size);
573  if (sizeof(*message) + sizeof(struct GNUNET_MessageHeader) > size)
574  {
575  GNUNET_break (0);
576  return GNUNET_SYSERR;
577  }
578  return GNUNET_OK;
579 }
580 
581 
588 static void
589 handle_local_data (void *cls, const struct GNUNET_CADET_LocalData *message)
590 {
591  struct GNUNET_CADET_Handle *h = cls;
592  const struct GNUNET_MessageHeader *payload;
593  struct GNUNET_CADET_Channel *ch;
594  uint16_t type;
595  int fwd;
596 
597  ch = find_channel (h, message->ccn);
598  if (NULL == ch)
599  {
601  "Unknown channel %X for incoming data (recently closed?)\n",
602  ntohl (message->ccn.channel_of_client));
603  return;
604  }
605 
606  payload = (const struct GNUNET_MessageHeader *) &message[1];
607  type = ntohs (payload->type);
610  "Got a %s data on channel %s [%X] of type %u\n",
611  fwd ? "FWD" : "BWD",
612  GNUNET_i2s (&ch->peer),
613  ntohl (message->ccn.channel_of_client),
614  type);
615  GNUNET_MQ_inject_message (ch->mq, payload);
616 }
617 
618 
626 static void
627 handle_local_ack (void *cls, const struct GNUNET_CADET_LocalAck *message)
628 {
629  struct GNUNET_CADET_Handle *h = cls;
630  struct GNUNET_CADET_Channel *ch;
631 
632  ch = find_channel (h, message->ccn);
633  if (NULL == ch)
634  {
636  "ACK on unknown channel %X\n",
637  ntohl (message->ccn.channel_of_client));
638  return;
639  }
640  ch->allow_send++;
642  "Got an ACK on mq channel %X (peer %s); new window size is %u!\n",
643  ntohl (ch->ccn.channel_of_client),
644  GNUNET_i2s (&ch->peer),
645  ch->allow_send);
646  if (NULL == ch->pending_env)
647  {
649  "Got an ACK on mq channel %X, allow send now %u!\n",
650  ntohl (ch->ccn.channel_of_client),
651  ch->allow_send);
652  notify_window_size (ch);
653  return;
654  }
655  if (NULL != ch->mq_cont)
656  return; /* already working on it! */
658 }
659 
660 
670 static int
671 destroy_channel_cb (void *cls, uint32_t cid, void *value)
672 {
673  /* struct GNUNET_CADET_Handle *handle = cls; */
674  struct GNUNET_CADET_Channel *ch = value;
675 
676  (void) cls;
677  (void) cid;
679  "Destroying channel due to GNUNET_CADET_disconnect()\n");
680  destroy_channel (ch);
681  return GNUNET_OK;
682 }
683 
684 
693 static void
694 handle_mq_error (void *cls, enum GNUNET_MQ_Error error)
695 {
696  struct GNUNET_CADET_Handle *h = cls;
697 
698  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MQ ERROR: %u\n", error);
700  GNUNET_MQ_destroy (h->mq);
701  h->mq = NULL;
702  GNUNET_assert (NULL == h->reconnect_task);
703  h->reconnect_task =
705 }
706 
707 
714 static void
716 {
717  struct GNUNET_MQ_MessageHandler handlers[] =
718  { GNUNET_MQ_hd_fixed_size (channel_created,
721  h),
725  h),
726  GNUNET_MQ_hd_var_size (local_data,
728  struct GNUNET_CADET_LocalData,
729  h),
730  GNUNET_MQ_hd_fixed_size (local_ack,
732  struct GNUNET_CADET_LocalAck,
733  h),
735 
736  GNUNET_assert (NULL == h->mq);
737  h->mq =
738  GNUNET_CLIENT_connect (h->cfg, "cadet", handlers, &handle_mq_error, h);
739 }
740 
741 
751 static int
752 destroy_port_cb (void *cls, const struct GNUNET_HashCode *id, void *value)
753 {
754  /* struct GNUNET_CADET_Handle *handle = cls; */
755  struct GNUNET_CADET_Port *port = value;
756 
757  (void) cls;
758  (void) id;
759  /* This is a warning, the app should have cleanly closed all open ports */
760  GNUNET_break (0);
762  return GNUNET_OK;
763 }
764 
765 
774 void
776 {
779  handle);
781  handle->ports = NULL;
784  handle);
786  handle->channels = NULL;
787  if (NULL != handle->mq)
788  {
789  GNUNET_MQ_destroy (handle->mq);
790  handle->mq = NULL;
791  }
792  if (NULL != handle->reconnect_task)
793  {
795  handle->reconnect_task = NULL;
796  }
797  GNUNET_free (handle);
798 }
799 
800 
807 void
809 {
810  GNUNET_assert (
811  GNUNET_YES ==
813  if (NULL != p->cadet->mq)
814  {
816  struct GNUNET_MQ_Envelope *env;
817 
819  msg->port = p->id;
820  GNUNET_MQ_send (p->cadet->mq, env);
821  }
822  GNUNET_free (p->handlers);
823  GNUNET_free (p);
824 }
825 
826 
836 void
838 {
839  struct GNUNET_CADET_Handle *h = channel->cadet;
841  struct GNUNET_MQ_Envelope *env;
842 
843  if (NULL != h->mq)
844  {
846  msg->ccn = channel->ccn;
847  GNUNET_MQ_send (h->mq, env);
848  }
850  "Destroying channel due to GNUNET_CADET_channel_destroy()\n");
851  channel->disconnects = NULL;
852  destroy_channel (channel);
853 }
854 
855 
865 const union GNUNET_CADET_ChannelInfo *
868  ...)
869 {
870  switch (option)
871  {
873  return (const union GNUNET_CADET_ChannelInfo *) &channel->peer;
874 
875  default:
876  GNUNET_break (0);
877  return NULL;
878  }
879 }
880 
881 
887 void
889 {
890  struct GNUNET_CADET_LocalAck *msg;
891  struct GNUNET_MQ_Envelope *env;
892 
895  "Sending ACK on channel %X\n",
896  ntohl (channel->ccn.channel_of_client));
897  msg->ccn = channel->ccn;
898  GNUNET_MQ_send (channel->cadet->mq, env);
899 }
900 
901 
909 struct GNUNET_CADET_Handle *
911 {
912  struct GNUNET_CADET_Handle *h;
913 
914  LOG (GNUNET_ERROR_TYPE_DEBUG, "GNUNET_CADET_connect()\n");
915  h = GNUNET_new (struct GNUNET_CADET_Handle);
916  h->cfg = cfg;
919  reconnect (h);
920  if (NULL == h->mq)
921  {
922  GNUNET_break (0);
924  return NULL;
925  }
927  return h;
928 }
929 
930 
937 static void
938 return_agpl (void *cls, const struct GNUNET_MessageHeader *msg)
939 {
940  struct GNUNET_SERVICE_Client *client = cls;
941  struct GNUNET_MQ_Handle *mq;
942  struct GNUNET_MQ_Envelope *env;
943  struct GNUNET_MessageHeader *res;
944  size_t slen;
946 
947  (void) msg;
948  slen = strlen (pd->agpl_url) + 1;
950  memcpy (&res[1], GNUNET_AGPL_URL, slen);
951  mq = GNUNET_SERVICE_client_get_mq (client);
952  GNUNET_MQ_send (mq, env);
954 }
955 
956 
969 struct GNUNET_CADET_Port *
971  const struct GNUNET_HashCode *port,
973  void *connects_cls,
976  const struct GNUNET_MQ_MessageHandler *handlers)
977 {
978  struct GNUNET_CADET_Port *p;
980 
981  GNUNET_assert (NULL != connects);
982  GNUNET_assert (NULL != disconnects);
984  "Listening to CADET port %s\n",
985  GNUNET_h2s (port));
986 
987  p = GNUNET_new (struct GNUNET_CADET_Port);
988  p->cadet = h;
989  p->id = *port;
991  h->ports,
992  &p->id,
993  p,
995  {
996  GNUNET_free (p);
997  return NULL;
998  }
999  p->connects = connects;
1000  p->cls = connects_cls;
1001  p->window_changes = window_changes;
1002  p->disconnects = disconnects;
1003  p->handlers = (NULL == pd->agpl_url)
1004  ? GNUNET_MQ_copy_handlers (handlers)
1005  : GNUNET_MQ_copy_handlers2 (handlers, &return_agpl, NULL);
1006 
1007  GNUNET_assert (GNUNET_OK == open_port_cb (h, &p->id, p));
1008  return p;
1009 }
1010 
1011 
1030 struct GNUNET_CADET_Channel *
1032  void *channel_cls,
1033  const struct GNUNET_PeerIdentity *destination,
1034  const struct GNUNET_HashCode *port,
1037  const struct GNUNET_MQ_MessageHandler *handlers)
1038 {
1039  struct GNUNET_CADET_Channel *ch;
1041  struct GNUNET_MQ_Envelope *env;
1042 
1043  GNUNET_assert (NULL != disconnects);
1045  "Creating channel to peer %s at port %s\n",
1046  GNUNET_i2s (destination),
1047  GNUNET_h2s (port));
1048  ch = create_channel (h, NULL);
1049  ch->ctx = channel_cls;
1050  ch->peer = *destination;
1051  ch->window_changes = window_changes;
1052  ch->disconnects = disconnects;
1053 
1054  /* Create MQ for channel */
1058  ch,
1059  handlers,
1061  ch);
1062  GNUNET_MQ_set_handlers_closure (ch->mq, channel_cls);
1063 
1064  /* Request channel creation to service */
1066  msg->ccn = ch->ccn;
1067  msg->port = *port;
1068  msg->peer = *destination;
1069  GNUNET_MQ_send (h->mq, env);
1070  return ch;
1071 }
1072 
1073 
1081 struct GNUNET_MQ_Handle *
1083 {
1084  return channel->mq;
1085 }
1086 
1087 
1088 /* end of cadet_api.c */
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration given by the client, in case of reconnection.
Definition: cadet_api.c:63
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
GNUNET_CADET_DisconnectEventHandler disconnects
Handler called when an incoming channel is destroyed.
Definition: cadet_api.c:114
void GNUNET_CADET_disconnect(struct GNUNET_CADET_Handle *handle)
Disconnect from the cadet service.
Definition: cadet_api.c:775
struct GNUNET_CADET_ClientChannelNumber ccn
ID of a channel controlled by this client.
Definition: cadet.h:213
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
Message to allow the client send more data to the service (always service -> client).
Definition: cadet.h:280
Project-specific data used to help the OS subsystem find installation paths.
static void channel_destroy(struct CadetChannel *ch)
Destroy the given channel.
GNUNET_CADET_DisconnectEventHandler disconnects
Disconnect handler.
Definition: cadet.h:165
uint32_t channel_of_client
Values for channel numbering.
Definition: cadet.h:110
Message for or to a client to destroy tunnel.
Definition: cadet.h:235
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_DESTROY
Tell client that a channel was destroyed.
GNUNET_CADET_WindowSizeEventHandler window_changes
Window size change handler.
Definition: cadet_api.c:109
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:1063
Opaque handle to the service.
Definition: cadet_api.c:38
#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_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.
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:866
struct GNUNET_MQ_Handle * GNUNET_SERVICE_client_get_mq(struct GNUNET_SERVICE_Client *c)
Obtain the message queue of c.
Definition: service.c:2436
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:252
static void reconnect_cbk(void *cls)
Reconnect callback: tries to reconnect again after a failer previous reconnecttion.
Definition: cadet_api.c:274
GNUNET_MQ_Error
Error codes for the queue.
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:536
We received a message for which we have no matching handler.
int GNUNET_CONTAINER_multihashmap32_iterate(struct GNUNET_CONTAINER_MultiHashMap32 *map, GNUNET_CONTAINER_MulitHashMapIterator32Callback it, void *it_cls)
Iterate over all entries in the map.
Message for a client to create and destroy channels.
Definition: cadet.h:181
void(* GNUNET_CADET_WindowSizeEventHandler)(void *cls, const struct GNUNET_CADET_Channel *channel, int window_size)
Function called whenever an MQ-channel&#39;s transmission window size changes.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_HashCode id
Port "number".
Definition: cadet_api.c:84
static void cadet_mq_send_now(void *cls)
Transmit the next message from our queue.
Definition: cadet_api.c:306
struct GNUNET_MQ_MessageHandler * GNUNET_MQ_copy_handlers(const struct GNUNET_MQ_MessageHandler *handlers)
Copy an array of handlers.
Definition: mq.c:1231
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
static void cadet_mq_destroy_impl(struct GNUNET_MQ_Handle *mq, void *impl_state)
Handle destruction of a message queue.
Definition: cadet_api.c:397
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
struct GNUNET_PeerIdentity peer
Other end of the channel.
Definition: cadet.h:122
Opaque handle to a channel.
Definition: cadet.h:116
static struct GNUNET_IDENTITY_Handle * id
Handle to identity service.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
GNUNET_MQ_PriorityPreferences
Per envelope preferences and priorities.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
unsigned int allow_send
How many messages are we allowed to send to the service right now?
Definition: cadet.h:175
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:291
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_CHANNEL_CREATE
Ask the cadet service to create a new channel.
GNUNET_CADET_ConnectEventHandler connects
Handler for incoming channels on this port.
Definition: cadet_api.c:99
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:468
int 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.
struct GNUNET_CADET_ClientChannelNumber next_ccn
child of the next channel to create (to avoid reusing IDs often)
Definition: cadet_api.c:58
Internal representation of the hash map.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
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:694
struct GNUNET_CADET_Handle * GNUNET_CADET_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the MQ-based cadet service.
Definition: cadet_api.c:910
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.
struct GNUNET_SCHEDULER_Task * mq_cont
Task to allow mq to send more traffic.
Definition: cadet.h:148
Handle to a client that is connected to a service.
Definition: service.c:250
enum GNUNET_MQ_PriorityPreferences GNUNET_MQ_env_get_options(struct GNUNET_MQ_Envelope *env)
Get performance preferences set for this envelope.
Definition: mq.c:1037
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:596
struct GNUNET_CADET_ClientChannelNumber ccn
Local ID of the channel, GNUNET_CADET_LOCAL_CHANNEL_ID_CLI bit is set if outbound.
Definition: cadet.h:170
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:627
#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
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:1269
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
char * agpl_url
URL pointing to the source code of the application.
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_ACK
Local ACK for data.
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:565
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 incomming MQ-based channels.
Definition: cadet_api.c:970
static void return_agpl(void *cls, const struct GNUNET_MessageHeader *msg)
Function to return link to AGPL source upon request.
Definition: cadet_api.c:938
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
int GNUNET_CONTAINER_multihashmap32_remove(struct GNUNET_CONTAINER_MultiHashMap32 *map, uint32_t key, const void *value)
Remove the given key-value pair from the map.
void * cls
Closure for mv and cb.
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
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
struct GNUNET_CONTAINER_MultiHashMap * ports
Ports open.
Definition: cadet_api.c:48
static char * value
Value of the record to add/remove.
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
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.
#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.
void * ctx
Any data the caller wants to put in here, used for the various callbacks (disconnects, window_changes, handlers).
Definition: cadet.h:138
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
struct GNUNET_MQ_Handle * mq
Message queue.
Definition: cadet_api.c:43
GNUNET_CADET_ChannelInfoOption
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:1296
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_OPEN
Start listening on a port.
static char * option
Name of the option.
Definition: gnunet-config.c:38
int 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.
static struct GNUNET_DNS_Handle * handle
Handle to transport service.
Number uniquely identifying a channel of a client.
Definition: cadet.h:101
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
#define GNUNET_CADET_LOCAL_CHANNEL_ID_CLI
Minimum value for channel IDs of local clients.
Definition: cadet.h:71
#define LOG(kind,...)
Definition: cadet_api.c:33
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:1261
Internal representation of the hash map.
static void reconnect(struct GNUNET_CADET_Handle *h)
Reconnect to the service, retransmit all infomation to try to restore the original state...
Definition: cadet_api.c:715
A 512-bit hashcode.
struct GNUNET_CADET_ClientChannelNumber ccn
ID of the channel.
Definition: cadet.h:262
Union to retrieve info about a channel.
Message handler for a specific message type.
static int res
void * connects(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
Definition: 010.c:2
#define GNUNET_CONSTANTS_MAX_CADET_MESSAGE_SIZE
Maximum message size that can be sent on CADET.
struct GNUNET_CONTAINER_MultiHashMap32 * GNUNET_CONTAINER_multihashmap32_create(unsigned int len)
Create a 32-bit key multi hash map.
struct GNUNET_TIME_Relative reconnect_time
Time to the next reconnect in case one reconnect fails.
Definition: cadet_api.c:73
void * cls
Closure for handler.
Definition: cadet_api.c:94
void GNUNET_CONTAINER_multihashmap32_destroy(struct GNUNET_CONTAINER_MultiHashMap32 *map)
Destroy a 32-bit key hash map.
void GNUNET_MQ_discard(struct GNUNET_MQ_Envelope *mqm)
Discard the message queue message, free all allocated resources.
Definition: mq.c:323
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:348
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...
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:445
struct GNUNET_HashCode port
Port to open/close.
Definition: cadet.h:194
static void destroy_channel(struct GNUNET_CADET_Channel *ch)
Destroy the specified channel.
Definition: cadet_api.c:204
#define GNUNET_MESSAGE_TYPE_RESPONSE_AGPL
Source code link.
static unsigned int size
Size of the "table".
Definition: peer.c:67
struct GNUNET_MQ_Handle * mq
Message Queue for the channel (which we are implementing).
Definition: cadet.h:143
Message for a client to create channels.
Definition: cadet.h:201
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:671
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
struct GNUNET_CADET_Handle * cadet
Handle to the CADET session this port belongs to.
Definition: cadet_api.c:89
struct GNUNET_CADET_ClientChannelNumber ccn
ID of the channel allowed to send more data.
Definition: cadet.h:290
struct GNUNET_CADET_Handle * cadet
Handle to the cadet this channel belongs to.
Definition: cadet.h:127
#define GNUNET_TIME_STD_BACKOFF(r)
Perform our standard exponential back-off calculation, starting at 1 ms and then going by a factor of...
int 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.
static unsigned long long payload
How much data are we currently storing in the database?
void * connects_cls
Closure for connects.
Definition: cadet_api.c:104
P2P messages used by CADET.
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:589
Handle to a message queue.
Definition: mq.c:85
The identity of the host (wraps the signing key of the peer).
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:888
struct GNUNET_CADET_ClientChannelNumber ccn
ID of a channel controlled by this client.
Definition: cadet.h:245
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:1031
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:752
static uint16_t port
Port number.
Definition: gnunet-bcd.c:82
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:155
configuration data
Definition: configuration.c:84
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_PORT_CLOSE
Stop listening on a port.
struct GNUNET_MQ_MessageHandler * handlers
Payload handlers for incoming channels.
Definition: cadet_api.c:119
#define GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA
Payload client <-> service.
GNUNET_CADET_WindowSizeEventHandler window_changes
Window change handler.
Definition: cadet.h:160
struct GNUNET_CADET_Port * incoming_port
Channel&#39;s port, if incoming.
Definition: cadet.h:132
#define GNUNET_log(kind,...)
Entry in list of pending tasks.
Definition: scheduler.c:134
const struct GNUNET_OS_ProjectData * GNUNET_OS_project_data_get(void)
#define GNUNET_AGPL_URL
NOTE: You MUST adjust this URL to point to the location of a publicly accessible repository (or TGZ) ...
Opaque handle to a port.
Definition: cadet_api.c:79
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
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 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:567
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
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:991
struct GNUNET_MessageHeader header
Type: GNUNET_MESSAGE_TYPE_CADET_LOCAL_DATA.
Definition: cadet.h:257
void GNUNET_CADET_close_port(struct GNUNET_CADET_Port *p)
Close a port opened with GNUNET_CADET_open_port().
Definition: cadet_api.c:808
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:837
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:415
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:355
Message for cadet data traffic.
Definition: cadet.h:252
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...
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
uint32_t pp
Priority and preferences (an enum GNUNET_MQ_PriorityPreferences) of the message in NBO...
Definition: cadet.h:268
struct GNUNET_SCHEDULER_Task * reconnect_task
Task for trying to reconnect.
Definition: cadet_api.c:68
struct GNUNET_CONTAINER_MultiHashMap32 * channels
Channels open.
Definition: cadet_api.c:53
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:499
struct GNUNET_PeerIdentity peer
Channel&#39;s peer.
Definition: cadet.h:218
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:837
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2242
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
struct GNUNET_HashCode port
Port of the channel.
Definition: cadet.h:223
#define GNUNET_free(ptr)
Wrapper around free.
Who is the peer at the other end of the channel.
Time for relative time used by GNUnet, in microseconds.
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:1082
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:972