GNUnet  0.19.3
transport_api2_communication.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2018 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  */
20 
26 #include "platform.h"
27 #include "gnunet_util_lib.h"
28 #include "gnunet_protocols.h"
31 #include "transport.h"
32 
33 
39 #define DEFAULT_MAX_QUEUE_LENGTH 16
40 
41 
46 {
50  struct FlowControl *next;
51 
55  struct FlowControl *prev;
56 
61 
65  void *cb_cls;
66 
71 
75  uint64_t id;
76 };
77 
78 
83 struct AckPending
84 {
88  struct AckPending *next;
89 
93  struct AckPending *prev;
94 
99 
104 
108  uint64_t mid;
109 };
110 
111 
116 {
121 
126 
131 
136 
141 
146 
151 
156 
161 
165  const char *config_section;
166 
170  const char *addr_prefix;
171 
177 
181  void *mq_init_cls;
182 
189 
194 
199 
203  unsigned long long max_queue_length;
204 
208  uint64_t fc_gen;
209 
214  uint32_t aid_gen;
215 
219  uint32_t queue_gen;
220 
225 };
226 
227 
233 {
238 
243 
248 
252  char *address;
253 
258 
262  struct GNUNET_PeerIdentity peer;
263 
267  enum GNUNET_NetworkType nt;
268 
273 
277  uint32_t queue_id;
278 
282  uint32_t mtu;
283 
287  uint64_t q_len;
291  uint32_t priority;
292 };
293 
294 
300 {
305 
310 
315 
319  char *address;
320 
326 
331  uint32_t aid;
332 
336  enum GNUNET_NetworkType nt;
337 };
338 
339 
345 static void
347 
348 
355 static void
357 {
358  struct GNUNET_MQ_Envelope *env;
359  struct GNUNET_TRANSPORT_AddAddressMessage *aam;
360 
361  if (NULL == ai->ch->mq)
362  return;
363  env = GNUNET_MQ_msg_extra (aam,
364  strlen (ai->address) + 1,
366  aam->expiration = GNUNET_TIME_relative_hton (ai->expiration);
367  aam->nt = htonl ((uint32_t) ai->nt);
368  memcpy (&aam[1], ai->address, strlen (ai->address) + 1);
369  GNUNET_MQ_send (ai->ch->mq, env);
370 }
371 
372 
379 static void
381 {
382  struct GNUNET_MQ_Envelope *env;
383  struct GNUNET_TRANSPORT_DelAddressMessage *dam;
384 
385  if (NULL == ai->ch->mq)
386  return;
388  dam->aid = htonl (ai->aid);
389  GNUNET_MQ_send (ai->ch->mq, env);
390 }
391 
392 
399 static void
401 {
402  struct GNUNET_MQ_Envelope *env;
403  struct GNUNET_TRANSPORT_AddQueueMessage *aqm;
404 
405  if (NULL == qh->ch->mq)
406  return;
408  "Sending `GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_SETUP` message\n");
409  env = GNUNET_MQ_msg_extra (aqm,
410  strlen (qh->address) + 1,
412  aqm->qid = htonl (qh->queue_id);
413  aqm->receiver = qh->peer;
414  aqm->nt = htonl ((uint32_t) qh->nt);
415  aqm->mtu = htonl (qh->mtu);
416  aqm->q_len = GNUNET_htonll (qh->q_len);
417  aqm->priority = htonl (qh->priority);
418  aqm->cs = htonl ((uint32_t) qh->cs);
419  memcpy (&aqm[1], qh->address, strlen (qh->address) + 1);
420  GNUNET_MQ_send (qh->ch->mq, env);
421 }
422 
423 
430 static void
432 {
433  struct GNUNET_MQ_Envelope *env;
434  struct GNUNET_TRANSPORT_UpdateQueueMessage *uqm;
435 
436  if (NULL == qh->ch->mq)
437  return;
439  uqm->qid = htonl (qh->queue_id);
440  uqm->receiver = qh->peer;
441  uqm->nt = htonl ((uint32_t) qh->nt);
442  uqm->mtu = htonl (qh->mtu);
443  uqm->q_len = GNUNET_htonll (qh->q_len);
444  uqm->priority = htonl (qh->priority);
445  uqm->cs = htonl ((uint32_t) qh->cs);
446  GNUNET_MQ_send (qh->ch->mq, env);
447 }
448 
449 
456 static void
458 {
459  struct GNUNET_MQ_Envelope *env;
460  struct GNUNET_TRANSPORT_DelQueueMessage *dqm;
461 
462  if (NULL == qh->ch->mq)
463  return;
465  dqm->qid = htonl (qh->queue_id);
466  dqm->receiver = qh->peer;
467  GNUNET_MQ_send (qh->ch->mq, env);
468 }
469 
470 
479 static void
481 {
482  struct FlowControl *fcn;
483  struct AckPending *apn;
484 
485  for (struct FlowControl *fc = ch->fc_head; NULL != fc; fc = fcn)
486  {
487  fcn = fc->next;
488  GNUNET_CONTAINER_DLL_remove (ch->fc_head, ch->fc_tail, fc);
489  fc->cb (fc->cb_cls, GNUNET_SYSERR);
490  GNUNET_free (fc);
491  }
492  for (struct AckPending *ap = ch->ap_head; NULL != ap; ap = apn)
493  {
494  apn = ap->next;
495  GNUNET_CONTAINER_DLL_remove (ch->ap_head, ch->ap_tail, ap);
496  GNUNET_free (ap);
497  }
498  if (NULL == ch->mq)
499  return;
501  ch->mq = NULL;
502 }
503 
504 
508 static void
509 error_handler (void *cls, enum GNUNET_MQ_Error error)
510 {
512 
514  "MQ failure %d, reconnecting to transport service.\n",
515  error);
516  disconnect (ch);
517  /* TODO: maybe do this with exponential backoff/delay */
518  reconnect (ch);
519 }
520 
521 
529 static void
531  void *cls,
532  const struct GNUNET_TRANSPORT_IncomingMessageAck *incoming_ack)
533 {
535 
536  for (struct FlowControl *fc = ch->fc_head; NULL != fc; fc = fc->next)
537  {
538  if ((fc->id == incoming_ack->fc_id) &&
539  (0 == memcmp (&fc->sender,
540  &incoming_ack->sender,
541  sizeof(struct GNUNET_PeerIdentity))))
542  {
544  "Done with message with flow control id %lu for sender %s from sender %s\n",
545  incoming_ack->fc_id,
546  GNUNET_i2s (&fc->sender),
547  GNUNET_i2s (&incoming_ack->sender));
548  GNUNET_CONTAINER_DLL_remove (ch->fc_head, ch->fc_tail, fc);
549  fc->cb (fc->cb_cls, GNUNET_OK);
550  GNUNET_free (fc);
551  return;
552  }
553  }
555  "Message with flow control id %lu from sender %s not found\n",
556  incoming_ack->fc_id,
557  GNUNET_i2s (&incoming_ack->sender));
558  GNUNET_break (0);
559  disconnect (ch);
560  /* TODO: maybe do this with exponential backoff/delay */
561  reconnect (ch);
562 }
563 
564 
573 static int
574 check_create_queue (void *cls, const struct GNUNET_TRANSPORT_CreateQueue *cq)
575 {
576  (void) cls;
578  return GNUNET_OK;
579 }
580 
581 
588 static void
589 handle_create_queue (void *cls, const struct GNUNET_TRANSPORT_CreateQueue *cq)
590 {
592  const char *addr = (const char *) &cq[1];
593  struct GNUNET_TRANSPORT_CreateQueueResponse *cqr;
594  struct GNUNET_MQ_Envelope *env;
595 
596  if (GNUNET_OK != ch->mq_init (ch->mq_init_cls, &cq->receiver, addr))
597  {
599  "Address `%s' invalid for this communicator\n",
600  addr);
602  }
603  else
604  {
606  }
607  cqr->request_id = cq->request_id;
608  GNUNET_MQ_send (ch->mq, env);
609 }
610 
611 
620 static int
621 check_send_msg (void *cls, const struct GNUNET_TRANSPORT_SendMessageTo *smt)
622 {
623  (void) cls;
625  return GNUNET_OK;
626 }
627 
628 
638 static void
640  int status,
641  const struct GNUNET_PeerIdentity *receiver,
642  uint64_t mid)
643 {
644  struct GNUNET_MQ_Envelope *env;
645  struct GNUNET_TRANSPORT_SendMessageToAck *ack;
646 
648  ack->status = htonl (status);
649  ack->mid = mid;
650  ack->receiver = *receiver;
651  GNUNET_MQ_send (ch->mq, env);
652 }
653 
654 
661 static void
662 send_ack_cb (void *cls)
663 {
664  struct AckPending *ap = cls;
666 
667  GNUNET_CONTAINER_DLL_remove (ch->ap_head, ch->ap_tail, ap);
668  send_ack (ch, GNUNET_OK, &ap->receiver, ap->mid);
669  GNUNET_free (ap);
670 }
671 
672 
679 static void
680 handle_send_msg (void *cls, const struct GNUNET_TRANSPORT_SendMessageTo *smt)
681 {
683  const struct GNUNET_MessageHeader *mh;
684  struct GNUNET_MQ_Envelope *env;
685  struct AckPending *ap;
686  struct GNUNET_TRANSPORT_QueueHandle *qh;
687 
688  for (qh = ch->queue_head; NULL != qh; qh = qh->next)
689  if ((qh->queue_id == ntohl (smt->qid)) &&
690  (0 == memcmp (&qh->peer,
691  &smt->receiver,
692  sizeof(struct GNUNET_PeerIdentity))))
693  break;
694  if (NULL == qh)
695  {
696  /* queue is already gone, tell transport this one failed */
698  "Transmission failed, queue no longer exists.\n");
699  send_ack (ch, GNUNET_NO, &smt->receiver, smt->mid);
700  return;
701  }
702  ap = GNUNET_new (struct AckPending);
703  ap->ch = ch;
704  ap->receiver = smt->receiver;
705  ap->mid = smt->mid;
706  GNUNET_CONTAINER_DLL_insert (ch->ap_head, ch->ap_tail, ap);
707  mh = (const struct GNUNET_MessageHeader *) &smt[1];
710  GNUNET_MQ_send (qh->mq, env);
711 }
712 
713 
722 static int
724  void *cls,
725  const struct GNUNET_TRANSPORT_CommunicatorBackchannelIncoming *bi)
726 {
727  (void) cls;
729  return GNUNET_OK;
730 }
731 
732 
739 static void
741  void *cls,
742  const struct GNUNET_TRANSPORT_CommunicatorBackchannelIncoming *bi)
743 {
745  if (NULL != ch->notify_cb)
746  ch->notify_cb (ch->notify_cb_cls,
747  &bi->pid,
748  (const struct GNUNET_MessageHeader *) &bi[1]);
749  else
750  GNUNET_log (
752  _ ("Dropped backchanel message: handler not provided by communicator\n"));
753 }
754 
755 
761 static void
763 {
765  { GNUNET_MQ_hd_fixed_size (incoming_ack,
767  struct GNUNET_TRANSPORT_IncomingMessageAck,
768  ch),
769  GNUNET_MQ_hd_var_size (create_queue,
771  struct GNUNET_TRANSPORT_CreateQueue,
772  ch),
775  struct GNUNET_TRANSPORT_SendMessageTo,
776  ch),
778  backchannel_incoming,
780  struct GNUNET_TRANSPORT_CommunicatorBackchannelIncoming,
781  ch),
783  struct GNUNET_TRANSPORT_CommunicatorAvailableMessage *cam;
784  struct GNUNET_MQ_Envelope *env;
785 
786  ch->mq =
787  GNUNET_CLIENT_connect (ch->cfg, "transport", handlers, &error_handler, ch);
788  if (NULL == ch->mq)
789  return;
790  env = GNUNET_MQ_msg_extra (cam,
791  strlen (ch->addr_prefix) + 1,
793  cam->cc = htonl ((uint32_t) ch->cc);
794  memcpy (&cam[1], ch->addr_prefix, strlen (ch->addr_prefix) + 1);
795  GNUNET_MQ_send (ch->mq, env);
796  for (struct GNUNET_TRANSPORT_AddressIdentifier *ai = ch->ai_head; NULL != ai;
797  ai = ai->next)
799  for (struct GNUNET_TRANSPORT_QueueHandle *qh = ch->queue_head; NULL != qh;
800  qh = qh->next)
801  send_add_queue (qh);
802 }
803 
804 
807  const struct GNUNET_CONFIGURATION_Handle *cfg,
808  const char *config_section,
809  const char *addr_prefix,
812  void *mq_init_cls,
814  void *notify_cb_cls)
815 {
817 
819  ch->cfg = cfg;
820  ch->config_section = config_section;
821  ch->addr_prefix = addr_prefix;
822  ch->mq_init = mq_init;
823  ch->mq_init_cls = mq_init_cls;
824  ch->notify_cb = notify_cb;
825  ch->notify_cb_cls = notify_cb_cls;
826  ch->cc = cc;
827  reconnect (ch);
828  if (GNUNET_OK !=
831  "MAX_QUEUE_LENGTH",
832  &ch->max_queue_length))
833  ch->max_queue_length = DEFAULT_MAX_QUEUE_LENGTH;
834  if (NULL == ch->mq)
835  {
836  GNUNET_free (ch);
837  return NULL;
838  }
839  return ch;
840 }
841 
842 
848 void
851 {
852  disconnect (ch);
853  while (NULL != ch->ai_head)
854  {
855  GNUNET_break (0); /* communicator forgot to remove address, warn! */
857  }
858  GNUNET_free (ch);
859 }
860 
861 
862 /* ************************* Receiving *************************** */
863 
864 
865 int
868  const struct GNUNET_PeerIdentity *sender,
869  const struct GNUNET_MessageHeader *msg,
870  struct GNUNET_TIME_Relative expected_addr_validity,
872  void *cb_cls)
873 {
874  struct GNUNET_MQ_Envelope *env;
875  struct GNUNET_TRANSPORT_IncomingMessage *im;
876  uint16_t msize;
877 
878 
880  "communicator receive\n");
881 
882  if (NULL == ch->mq)
883  return GNUNET_SYSERR;
884  if ((NULL == cb) && (GNUNET_MQ_get_length (ch->mq) >= ch->max_queue_length))
885  {
886  GNUNET_log (
888  "Dropping message: transport is too slow, queue length %llu exceeded\n",
889  ch->max_queue_length);
890  return GNUNET_NO;
891  }
892 
893  msize = ntohs (msg->size);
894  env =
896  if (NULL == env)
897  {
898  GNUNET_break (0);
899  return GNUNET_SYSERR;
900  }
901  im->expected_address_validity =
902  GNUNET_TIME_relative_hton (expected_addr_validity);
903  im->sender = *sender;
904  // FIXME: this is expensive, would be better if we would
905  // re-design the API to allow us to create the envelope first,
906  // and then have the application fill in the body so we do
907  // not have to memcpy()
908  memcpy (&im[1], msg, msize);
909  im->fc_on = htonl (GNUNET_NO);
910  if (NULL != cb)
911  {
912  struct FlowControl *fc;
913 
914  im->fc_on = htonl (GNUNET_YES);
915  im->fc_id = ch->fc_gen++;
916  fc = GNUNET_new (struct FlowControl);
917  fc->sender = *sender;
918  fc->id = im->fc_id;
919  fc->cb = cb;
920  fc->cb_cls = cb_cls;
921  GNUNET_CONTAINER_DLL_insert (ch->fc_head, ch->fc_tail, fc);
923  "Created flow control id %lu for sender %s\n",
924  fc->id,
925  GNUNET_i2s (&fc->sender));
926  }
927  GNUNET_MQ_send (ch->mq, env);
928  return GNUNET_OK;
929 }
930 
931 
932 /* ************************* Discovery *************************** */
933 
934 
938  const struct GNUNET_PeerIdentity *peer,
939  const char *address,
940  uint32_t mtu,
941  uint64_t q_len,
942  uint32_t priority,
943  enum GNUNET_NetworkType nt,
945  struct GNUNET_MQ_Handle *mq)
946 {
947  struct GNUNET_TRANSPORT_QueueHandle *qh;
948 
949  // Do not notify the service if there is no intial capacity.
950  GNUNET_assert (0 < q_len);
951 
953  qh->ch = ch;
954  qh->peer = *peer;
955  qh->address = GNUNET_strdup (address);
956  qh->nt = nt;
957  qh->mtu = mtu;
958  qh->q_len = q_len;
959  qh->priority = priority;
960  qh->cs = cs;
961  qh->mq = mq;
962  qh->queue_id = ch->queue_gen++;
963  GNUNET_CONTAINER_DLL_insert (ch->queue_head, ch->queue_tail, qh);
964  send_add_queue (qh);
965  return qh;
966 }
967 
968 
969 void
972  const struct GNUNET_TRANSPORT_QueueHandle *u_qh,
973  uint64_t q_len,
974  uint32_t priority)
975 {
976  struct GNUNET_TRANSPORT_QueueHandle *qh;
977 
978  for (qh = ch->queue_head; NULL != qh; qh = qh->next)
979  {
980  if (u_qh == qh)
981  break;
982  }
983  GNUNET_assert (NULL != qh);
984  qh->q_len = q_len;
985  qh->priority = priority;
986  send_update_queue (qh);
987 }
988 
989 
996 void
998 {
1000 
1001  send_del_queue (qh);
1002  GNUNET_CONTAINER_DLL_remove (ch->queue_head, ch->queue_tail, qh);
1003  GNUNET_MQ_destroy (qh->mq);
1004  GNUNET_free (qh->address);
1005  GNUNET_free (qh);
1006 }
1007 
1008 
1021  const char *address,
1022  enum GNUNET_NetworkType nt,
1024 {
1026 
1028  ai->ch = ch;
1030  ai->nt = nt;
1032  ai->aid = ch->aid_gen++;
1033  GNUNET_CONTAINER_DLL_insert (ch->ai_head, ch->ai_tail, ai);
1034  send_add_address (ai);
1035  return ai;
1036 }
1037 
1044 void
1047 {
1049 
1050  send_del_address (ai);
1051  GNUNET_CONTAINER_DLL_remove (ch->ai_head, ch->ai_tail, ai);
1052  GNUNET_free (ai->address);
1053  GNUNET_free (ai);
1054  ai = NULL;
1055 }
1056 
1062 void
1065 {
1066  struct GNUNET_TRANSPORT_AddressIdentifier *ai = ch->ai_head;
1067  while (NULL != ai)
1068  {
1069  struct GNUNET_TRANSPORT_AddressIdentifier *ai_next = ai->next;
1071  ai = ai_next;
1072  }
1073 }
1074 
1075 
1076 /* ************************* Backchannel *************************** */
1077 
1078 
1079 void
1082  const struct GNUNET_PeerIdentity *pid,
1083  const char *comm,
1084  const struct GNUNET_MessageHeader *header)
1085 {
1086  struct GNUNET_MQ_Envelope *env;
1087  struct GNUNET_TRANSPORT_CommunicatorBackchannel *cb;
1088  size_t slen = strlen (comm) + 1;
1089  uint16_t mlen = ntohs (header->size);
1090 
1091  GNUNET_assert (mlen + slen + sizeof(*cb) < UINT16_MAX);
1092  env =
1093  GNUNET_MQ_msg_extra (cb,
1094  slen + mlen,
1096  cb->pid = *pid;
1097  memcpy (&cb[1], header, mlen);
1098  memcpy (((char *) &cb[1]) + mlen, comm, slen);
1099  GNUNET_MQ_send (ch->mq, env);
1100 }
1101 
1102 
1103 /* end of transport_api2_communication.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
static char * expiration
Credential TTL.
Definition: gnunet-abd.c:96
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
static struct GNUNET_CADET_Handle * mh
Cadet handle.
Definition: gnunet-cadet.c:92
static int mq_init(void *cls, const struct GNUNET_PeerIdentity *peer, const char *address)
Function called by the transport service to initialize a message queue given address information abou...
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
static char * address
GNS address for this phone.
uint16_t status
See PRISM_STATUS_*-constants.
static struct GNUNET_NAT_AUTO_Test * nt
Handle to a NAT test operation.
static struct GNUNET_PeerIdentity pid
Identity of the peer we transmit to / connect to.
static void send_msg(void *cls)
Function called to notify a client about the socket begin ready to queue more data.
Bandwidth allocation API for the transport service.
Constants for network protocols.
API of the transport service towards the communicator processes.
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
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_number(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *number)
Get a configuration value that should be a number.
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
#define GNUNET_log(kind,...)
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:37
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
@ GNUNET_SYSERR
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.
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
@ GNUNET_ERROR_TYPE_INFO
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_free(ptr)
Wrapper around free.
unsigned int GNUNET_MQ_get_length(struct GNUNET_MQ_Handle *mq)
Obtain the current length of the message queue.
Definition: mq.c:293
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.
#define GNUNET_MQ_check_zero_termination(m)
Insert code for a "check_" function that verifies that a given variable-length message received over ...
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition: gnunet_mq_lib.h:62
#define GNUNET_MQ_check_boxed_message(m)
Insert code for a "check_" function that verifies that a given variable-length message received over ...
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:77
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
void GNUNET_MQ_notify_sent(struct GNUNET_MQ_Envelope *ev, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
Call a callback once the envelope has been sent, that is, sending it can not be canceled anymore.
Definition: mq.c:638
struct GNUNET_MQ_Envelope * GNUNET_MQ_msg_copy(const struct GNUNET_MessageHeader *hdr)
Create a new envelope by copying an existing message.
Definition: mq.c:533
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:683
GNUNET_NetworkType
Types of networks (with separate quotas) we support.
Definition: gnunet_nt_lib.h:39
#define GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG_ACK
transport acknowledges processing an incoming message
#define GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_TEARDOWN
inform transport that a queue was torn down
#define GNUNET_MESSAGE_TYPE_TRANSPORT_NEW_COMMUNICATOR
Message sent to indicate to the transport which address prefix is supported by a communicator.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_FAIL
Response from communicator: address bogus, will not try to create queue.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE
transport tells communicator it wants a queue
#define GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL
Tell transport that it should assist with exchanging a message between communicators.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG
inform transport about an incoming message
#define GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_OK
Response from communicator: will try to create queue.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL_INCOMING
Transport signalling incoming backchannel message to a communicator.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG_ACK
communicator tells transports that message was sent
#define GNUNET_MESSAGE_TYPE_TRANSPORT_ADD_ADDRESS
inform transport to add an address of this peer
#define GNUNET_MESSAGE_TYPE_TRANSPORT_DEL_ADDRESS
inform transport to delete an address of this peer
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG
transport tells communicator it wants to transmit
#define GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_SETUP
inform transport that a queue was setup to talk to some peer
#define GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_UPDATE
inform transport that a queue was updated
struct GNUNET_TIME_RelativeNBO GNUNET_TIME_relative_hton(struct GNUNET_TIME_Relative a)
Convert relative time to network byte order.
Definition: time.c:618
void GNUNET_TRANSPORT_communicator_address_remove(struct GNUNET_TRANSPORT_AddressIdentifier *ai)
Notify transport service about an address that this communicator no longer provides for this peer.
int GNUNET_TRANSPORT_communicator_receive(struct GNUNET_TRANSPORT_CommunicatorHandle *ch, const struct GNUNET_PeerIdentity *sender, const struct GNUNET_MessageHeader *msg, struct GNUNET_TIME_Relative expected_addr_validity, GNUNET_TRANSPORT_MessageCompletedCallback cb, void *cb_cls)
Notify transport service that the communicator has received a message.
void GNUNET_TRANSPORT_communicator_mq_del(struct GNUNET_TRANSPORT_QueueHandle *qh)
Notify transport service that an MQ became unavailable due to a disconnect or timeout.
struct GNUNET_TRANSPORT_QueueHandle * GNUNET_TRANSPORT_communicator_mq_add(struct GNUNET_TRANSPORT_CommunicatorHandle *ch, const struct GNUNET_PeerIdentity *peer, const char *address, uint32_t mtu, uint64_t q_len, uint32_t priority, enum GNUNET_NetworkType nt, enum GNUNET_TRANSPORT_ConnectionStatus cs, struct GNUNET_MQ_Handle *mq)
Notify transport service that a MQ became available due to an "inbound" connection or because the com...
struct GNUNET_TRANSPORT_AddressIdentifier * GNUNET_TRANSPORT_communicator_address_add(struct GNUNET_TRANSPORT_CommunicatorHandle *ch, const char *address, enum GNUNET_NetworkType nt, struct GNUNET_TIME_Relative expiration)
Notify transport service about an address that this communicator provides for this peer.
GNUNET_TRANSPORT_CommunicatorCharacteristics
What characteristics does this communicator have?
void GNUNET_TRANSPORT_communicator_mq_update(struct GNUNET_TRANSPORT_CommunicatorHandle *ch, const struct GNUNET_TRANSPORT_QueueHandle *u_qh, uint64_t q_len, uint32_t priority)
Notify transport service that an MQ was updated.
void GNUNET_TRANSPORT_communicator_notify(struct GNUNET_TRANSPORT_CommunicatorHandle *ch, const struct GNUNET_PeerIdentity *pid, const char *comm, const struct GNUNET_MessageHeader *header)
The communicator asks the transport service to route a message via a different path to another commun...
void GNUNET_TRANSPORT_communicator_disconnect(struct GNUNET_TRANSPORT_CommunicatorHandle *ch)
Disconnect from the transport service.
void(* GNUNET_TRANSPORT_CommunicatorNotify)(void *cls, const struct GNUNET_PeerIdentity *sender, const struct GNUNET_MessageHeader *msg)
Function called when the transport service has received a backchannel message for this communicator (...
int(* GNUNET_TRANSPORT_CommunicatorMqInit)(void *cls, const struct GNUNET_PeerIdentity *peer, const char *address)
Function called by the transport service to initialize a message queue given address information abou...
GNUNET_TRANSPORT_ConnectionStatus
Possible states of a connection.
void GNUNET_TRANSPORT_communicator_address_remove_all(struct GNUNET_TRANSPORT_CommunicatorHandle *ch)
Notify transport service that this communicator no longer provides all its addresses for this peer.
struct GNUNET_TRANSPORT_CommunicatorHandle * GNUNET_TRANSPORT_communicator_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *config_section, const char *addr_prefix, enum GNUNET_TRANSPORT_CommunicatorCharacteristics cc, GNUNET_TRANSPORT_CommunicatorMqInit mq_init, void *mq_init_cls, GNUNET_TRANSPORT_CommunicatorNotify notify_cb, void *notify_cb_cls)
Connect to the transport service.
void(* GNUNET_TRANSPORT_MessageCompletedCallback)(void *cls, int success)
Function called to notify communicator that we have received and processed the message.
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
void receiver(void *cls, const void *buf, size_t available, const struct sockaddr *addr, socklen_t addrlen, int errCode)
Callback to read from the SOCKS5 proxy.
Definition: socks.c:330
Information we track per message to tell the transport about success or failures.
struct AckPending * next
Kept in a DLL.
uint64_t mid
More-or-less unique ID for the message.
struct GNUNET_TRANSPORT_CommunicatorHandle * ch
Communicator this entry belongs to.
struct AckPending * prev
Kept in a DLL.
struct GNUNET_PeerIdentity receiver
Which peer is this about?
Information we track per packet to enable flow control.
struct FlowControl * prev
Kept in a DLL.
GNUNET_TRANSPORT_MessageCompletedCallback cb
Function to call once the message was processed.
struct GNUNET_PeerIdentity sender
Which peer is this about?
struct FlowControl * next
Kept in a DLL.
uint64_t id
More-or-less unique ID for the message.
void * cb_cls
Closure for cb.
struct GNUNET_MQ_Handle * mq
Message Queue for the channel (which we are implementing).
Definition: cadet.h:142
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.
The identity of the host (wraps the signing key of the peer).
Time for relative time used by GNUnet, in microseconds.
Internal representation of an address a communicator is currently providing for the transport service...
struct GNUNET_TRANSPORT_AddressIdentifier * next
Kept in a DLL.
struct GNUNET_TIME_Relative expiration
When does the address expire? (Expected lifetime of the address.)
enum GNUNET_NetworkType nt
Network type for the address.
struct GNUNET_TRANSPORT_AddressIdentifier * prev
Kept in a DLL.
uint32_t aid
Internal UUID for the address used in communication with the transport service.
struct GNUNET_TRANSPORT_CommunicatorHandle * ch
Transport handle where the address was added.
Opaque handle to the transport service for communicators.
struct GNUNET_TRANSPORT_AddressIdentifier * ai_head
Head of DLL of addresses this communicator offers to the transport service.
struct AckPending * ap_head
DLL of messages awaiting transmission confirmation (ack).
struct GNUNET_TRANSPORT_QueueHandle * queue_tail
DLL of queues we offer.
enum GNUNET_TRANSPORT_CommunicatorCharacteristics cc
Characteristics of the communicator.
GNUNET_TRANSPORT_CommunicatorMqInit mq_init
Function to call when the transport service wants us to initiate a communication channel with another...
struct GNUNET_MQ_Handle * mq
Queue to talk to the transport service.
struct FlowControl * fc_tail
DLL of messages awaiting flow control confirmation (ack).
uint32_t queue_gen
Queue identifier generator.
const char * addr_prefix
Address prefix to use.
const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
struct FlowControl * fc_head
DLL of messages awaiting flow control confirmation (ack).
GNUNET_TRANSPORT_CommunicatorNotify notify_cb
Function to call when the transport service receives messages for a communicator (i....
struct AckPending * ap_tail
DLL of messages awaiting transmission confirmation (ack).
struct GNUNET_TRANSPORT_AddressIdentifier * ai_tail
Tail of DLL of addresses this communicator offers to the transport service.
struct GNUNET_TRANSPORT_QueueHandle * queue_head
DLL of queues we offer.
uint64_t fc_gen
Flow-control identifier generator.
const char * config_section
Config section to use.
unsigned long long max_queue_length
Maximum permissible queue length.
uint32_t aid_gen
Internal UUID for the address used in communication with the transport service.
Handle returned to identify the internal data structure the transport API has created to manage a mes...
enum GNUNET_TRANSPORT_ConnectionStatus cs
Communication status of the queue.
struct GNUNET_MQ_Handle * mq
The queue itself.
struct GNUNET_TRANSPORT_QueueHandle * next
Kept in a DLL.
struct GNUNET_TRANSPORT_QueueHandle * prev
Kept in a DLL.
uint32_t queue_id
ID for this queue when talking to the transport service.
uint32_t mtu
Maximum transmission unit for the queue.
char * address
Address used by the communication queue.
enum GNUNET_NetworkType nt
Network type of the communication queue.
struct GNUNET_PeerIdentity peer
Which peer we can communciate with.
struct GNUNET_TRANSPORT_CommunicatorHandle * ch
Handle this queue belongs to.
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
common internal definitions for transport service
static void handle_incoming_ack(void *cls, const struct GNUNET_TRANSPORT_IncomingMessageAck *incoming_ack)
Transport service acknowledged a message we gave it (with flow control enabled).
static void reconnect(struct GNUNET_TRANSPORT_CommunicatorHandle *ch)
(re)connect our communicator to the transport service
static void handle_create_queue(void *cls, const struct GNUNET_TRANSPORT_CreateQueue *cq)
Transport service wants us to create a queue.
static void handle_send_msg(void *cls, const struct GNUNET_TRANSPORT_SendMessageTo *smt)
Transport service wants us to send a message.
static void error_handler(void *cls, enum GNUNET_MQ_Error error)
Function called on MQ errors.
static void send_add_address(struct GNUNET_TRANSPORT_AddressIdentifier *ai)
Send message to the transport service about address ai being now available.
static void send_ack(struct GNUNET_TRANSPORT_CommunicatorHandle *ch, int status, const struct GNUNET_PeerIdentity *receiver, uint64_t mid)
Notify transport service about status of a message with mid sent to receiver.
static void send_add_queue(struct GNUNET_TRANSPORT_QueueHandle *qh)
Send message to the transport service about queue qh being now available.
static void disconnect(struct GNUNET_TRANSPORT_CommunicatorHandle *ch)
Disconnect from the transport service.
static void send_ack_cb(void *cls)
Message queue transmission by communicator was successful, notify transport service.
static int check_send_msg(void *cls, const struct GNUNET_TRANSPORT_SendMessageTo *smt)
Transport service wants us to send a message.
static void send_del_address(struct GNUNET_TRANSPORT_AddressIdentifier *ai)
Send message to the transport service about address ai being no longer available.
static void handle_backchannel_incoming(void *cls, const struct GNUNET_TRANSPORT_CommunicatorBackchannelIncoming *bi)
Transport service gives us backchannel message.
static int check_create_queue(void *cls, const struct GNUNET_TRANSPORT_CreateQueue *cq)
Transport service wants us to create a queue.
static int check_backchannel_incoming(void *cls, const struct GNUNET_TRANSPORT_CommunicatorBackchannelIncoming *bi)
Transport service gives us backchannel message.
#define DEFAULT_MAX_QUEUE_LENGTH
How many messages do we keep at most in the queue to the transport service before we start to drop (d...
static void send_del_queue(struct GNUNET_TRANSPORT_QueueHandle *qh)
Send message to the transport service about queue qh being no longer available.
static void send_update_queue(struct GNUNET_TRANSPORT_QueueHandle *qh)
Send message to the transport service about queue qh updated.