GNUnet  0.17.6
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  {
543  GNUNET_CONTAINER_DLL_remove (ch->fc_head, ch->fc_tail, fc);
544  fc->cb (fc->cb_cls, GNUNET_OK);
545  GNUNET_free (fc);
546  return;
547  }
548  }
549  GNUNET_break (0);
550  disconnect (ch);
551  /* TODO: maybe do this with exponential backoff/delay */
552  reconnect (ch);
553 }
554 
555 
564 static int
565 check_create_queue (void *cls, const struct GNUNET_TRANSPORT_CreateQueue *cq)
566 {
567  (void) cls;
569  return GNUNET_OK;
570 }
571 
572 
579 static void
580 handle_create_queue (void *cls, const struct GNUNET_TRANSPORT_CreateQueue *cq)
581 {
583  const char *addr = (const char *) &cq[1];
584  struct GNUNET_TRANSPORT_CreateQueueResponse *cqr;
585  struct GNUNET_MQ_Envelope *env;
586 
587  if (GNUNET_OK != ch->mq_init (ch->mq_init_cls, &cq->receiver, addr))
588  {
590  "Address `%s' invalid for this communicator\n",
591  addr);
593  }
594  else
595  {
597  }
598  cqr->request_id = cq->request_id;
599  GNUNET_MQ_send (ch->mq, env);
600 }
601 
602 
611 static int
612 check_send_msg (void *cls, const struct GNUNET_TRANSPORT_SendMessageTo *smt)
613 {
614  (void) cls;
616  return GNUNET_OK;
617 }
618 
619 
629 static void
631  int status,
632  const struct GNUNET_PeerIdentity *receiver,
633  uint64_t mid)
634 {
635  struct GNUNET_MQ_Envelope *env;
636  struct GNUNET_TRANSPORT_SendMessageToAck *ack;
637 
639  ack->status = htonl (status);
640  ack->mid = mid;
641  ack->receiver = *receiver;
642  GNUNET_MQ_send (ch->mq, env);
643 }
644 
645 
652 static void
653 send_ack_cb (void *cls)
654 {
655  struct AckPending *ap = cls;
657 
658  GNUNET_CONTAINER_DLL_remove (ch->ap_head, ch->ap_tail, ap);
659  send_ack (ch, GNUNET_OK, &ap->receiver, ap->mid);
660  GNUNET_free (ap);
661 }
662 
663 
670 static void
671 handle_send_msg (void *cls, const struct GNUNET_TRANSPORT_SendMessageTo *smt)
672 {
674  const struct GNUNET_MessageHeader *mh;
675  struct GNUNET_MQ_Envelope *env;
676  struct AckPending *ap;
677  struct GNUNET_TRANSPORT_QueueHandle *qh;
678 
679  for (qh = ch->queue_head; NULL != qh; qh = qh->next)
680  if ((qh->queue_id == ntohl (smt->qid)) &&
681  (0 == memcmp (&qh->peer,
682  &smt->receiver,
683  sizeof(struct GNUNET_PeerIdentity))))
684  break;
685  if (NULL == qh)
686  {
687  /* queue is already gone, tell transport this one failed */
689  "Transmission failed, queue no longer exists.\n");
690  send_ack (ch, GNUNET_NO, &smt->receiver, smt->mid);
691  return;
692  }
693  ap = GNUNET_new (struct AckPending);
694  ap->ch = ch;
695  ap->receiver = smt->receiver;
696  ap->mid = smt->mid;
697  GNUNET_CONTAINER_DLL_insert (ch->ap_head, ch->ap_tail, ap);
698  mh = (const struct GNUNET_MessageHeader *) &smt[1];
701  GNUNET_MQ_send (qh->mq, env);
702 }
703 
704 
713 static int
715  void *cls,
716  const struct GNUNET_TRANSPORT_CommunicatorBackchannelIncoming *bi)
717 {
718  (void) cls;
720  return GNUNET_OK;
721 }
722 
723 
730 static void
732  void *cls,
733  const struct GNUNET_TRANSPORT_CommunicatorBackchannelIncoming *bi)
734 {
736  if (NULL != ch->notify_cb)
737  ch->notify_cb (ch->notify_cb_cls,
738  &bi->pid,
739  (const struct GNUNET_MessageHeader *) &bi[1]);
740  else
741  GNUNET_log (
743  _ ("Dropped backchanel message: handler not provided by communicator\n"));
744 }
745 
746 
752 static void
754 {
756  { GNUNET_MQ_hd_fixed_size (incoming_ack,
758  struct GNUNET_TRANSPORT_IncomingMessageAck,
759  ch),
760  GNUNET_MQ_hd_var_size (create_queue,
762  struct GNUNET_TRANSPORT_CreateQueue,
763  ch),
766  struct GNUNET_TRANSPORT_SendMessageTo,
767  ch),
769  backchannel_incoming,
771  struct GNUNET_TRANSPORT_CommunicatorBackchannelIncoming,
772  ch),
774  struct GNUNET_TRANSPORT_CommunicatorAvailableMessage *cam;
775  struct GNUNET_MQ_Envelope *env;
776 
777  ch->mq =
778  GNUNET_CLIENT_connect (ch->cfg, "transport", handlers, &error_handler, ch);
779  if (NULL == ch->mq)
780  return;
781  env = GNUNET_MQ_msg_extra (cam,
782  strlen (ch->addr_prefix) + 1,
784  cam->cc = htonl ((uint32_t) ch->cc);
785  memcpy (&cam[1], ch->addr_prefix, strlen (ch->addr_prefix) + 1);
786  GNUNET_MQ_send (ch->mq, env);
787  for (struct GNUNET_TRANSPORT_AddressIdentifier *ai = ch->ai_head; NULL != ai;
788  ai = ai->next)
790  for (struct GNUNET_TRANSPORT_QueueHandle *qh = ch->queue_head; NULL != qh;
791  qh = qh->next)
792  send_add_queue (qh);
793 }
794 
795 
816  const struct GNUNET_CONFIGURATION_Handle *cfg,
817  const char *config_section,
818  const char *addr_prefix,
821  void *mq_init_cls,
823  void *notify_cb_cls)
824 {
826 
828  ch->cfg = cfg;
829  ch->config_section = config_section;
830  ch->addr_prefix = addr_prefix;
831  ch->mq_init = mq_init;
832  ch->mq_init_cls = mq_init_cls;
833  ch->notify_cb = notify_cb;
834  ch->notify_cb_cls = notify_cb_cls;
835  ch->cc = cc;
836  reconnect (ch);
837  if (GNUNET_OK !=
840  "MAX_QUEUE_LENGTH",
841  &ch->max_queue_length))
842  ch->max_queue_length = DEFAULT_MAX_QUEUE_LENGTH;
843  if (NULL == ch->mq)
844  {
845  GNUNET_free (ch);
846  return NULL;
847  }
848  return ch;
849 }
850 
851 
857 void
860 {
861  disconnect (ch);
862  while (NULL != ch->ai_head)
863  {
864  GNUNET_break (0); /* communicator forgot to remove address, warn! */
866  }
867  GNUNET_free (ch);
868 }
869 
870 
871 /* ************************* Receiving *************************** */
872 
873 
894 int
897  const struct GNUNET_PeerIdentity *sender,
898  const struct GNUNET_MessageHeader *msg,
899  struct GNUNET_TIME_Relative expected_addr_validity,
901  void *cb_cls)
902 {
903  struct GNUNET_MQ_Envelope *env;
904  struct GNUNET_TRANSPORT_IncomingMessage *im;
905  uint16_t msize;
906 
907 
909  "communicator receive\n");
910 
911  if (NULL == ch->mq)
912  return GNUNET_SYSERR;
913  if ((NULL == cb) && (GNUNET_MQ_get_length (ch->mq) >= ch->max_queue_length))
914  {
915  GNUNET_log (
917  "Dropping message: transport is too slow, queue length %llu exceeded\n",
918  ch->max_queue_length);
919  return GNUNET_NO;
920  }
921 
922  msize = ntohs (msg->size);
923  env =
925  if (NULL == env)
926  {
927  GNUNET_break (0);
928  return GNUNET_SYSERR;
929  }
930  im->expected_address_validity =
931  GNUNET_TIME_relative_hton (expected_addr_validity);
932  im->sender = *sender;
933  // FIXME: this is expensive, would be better if we would
934  // re-design the API to allow us to create the envelope first,
935  // and then have the application fill in the body so we do
936  // not have to memcpy()
937  memcpy (&im[1], msg, msize);
938  im->fc_on = htonl (GNUNET_NO);
939  if (NULL != cb)
940  {
941  struct FlowControl *fc;
942 
943  im->fc_on = htonl (GNUNET_YES);
944  im->fc_id = ch->fc_gen++;
945  fc = GNUNET_new (struct FlowControl);
946  fc->sender = *sender;
947  fc->id = im->fc_id;
948  fc->cb = cb;
949  fc->cb_cls = cb_cls;
950  GNUNET_CONTAINER_DLL_insert (ch->fc_head, ch->fc_tail, fc);
951  }
952  GNUNET_MQ_send (ch->mq, env);
953  return GNUNET_OK;
954 }
955 
956 
957 /* ************************* Discovery *************************** */
958 
959 
982  const struct GNUNET_PeerIdentity *peer,
983  const char *address,
984  uint32_t mtu,
985  uint64_t q_len,
986  uint32_t priority,
987  enum GNUNET_NetworkType nt,
989  struct GNUNET_MQ_Handle *mq)
990 {
991  struct GNUNET_TRANSPORT_QueueHandle *qh;
992 
993  // Do not notify the service if there is no intial capacity.
994  GNUNET_assert (0 < q_len);
995 
997  qh->ch = ch;
998  qh->peer = *peer;
999  qh->address = GNUNET_strdup (address);
1000  qh->nt = nt;
1001  qh->mtu = mtu;
1002  qh->q_len = q_len;
1003  qh->priority = priority;
1004  qh->cs = cs;
1005  qh->mq = mq;
1006  qh->queue_id = ch->queue_gen++;
1007  GNUNET_CONTAINER_DLL_insert (ch->queue_head, ch->queue_tail, qh);
1008  send_add_queue (qh);
1009  return qh;
1010 }
1011 
1012 
1022 void
1025  const struct GNUNET_TRANSPORT_QueueHandle *u_qh,
1026  uint64_t q_len,
1027  uint32_t priority)
1028 {
1029  struct GNUNET_TRANSPORT_QueueHandle *qh;
1030 
1031  for (qh = ch->queue_head; NULL != qh; qh = qh->next)
1032  {
1033  if (u_qh == qh)
1034  break;
1035  }
1036  GNUNET_assert (NULL != qh);
1037  qh->q_len = q_len;
1038  qh->priority = priority;
1039  send_update_queue (qh);
1040 }
1041 
1042 
1049 void
1051 {
1053 
1054  send_del_queue (qh);
1055  GNUNET_CONTAINER_DLL_remove (ch->queue_head, ch->queue_tail, qh);
1056  GNUNET_MQ_destroy (qh->mq);
1057  GNUNET_free (qh->address);
1058  GNUNET_free (qh);
1059 }
1060 
1061 
1074  const char *address,
1075  enum GNUNET_NetworkType nt,
1077 {
1079 
1081  ai->ch = ch;
1083  ai->nt = nt;
1085  ai->aid = ch->aid_gen++;
1086  GNUNET_CONTAINER_DLL_insert (ch->ai_head, ch->ai_tail, ai);
1087  send_add_address (ai);
1088  return ai;
1089 }
1090 
1097 void
1100 {
1102 
1103  send_del_address (ai);
1104  GNUNET_CONTAINER_DLL_remove (ch->ai_head, ch->ai_tail, ai);
1105  GNUNET_free (ai->address);
1106  GNUNET_free (ai);
1107 }
1108 
1114 void
1117 {
1118  for (struct GNUNET_TRANSPORT_AddressIdentifier *ai = ch->ai_head; NULL != ai;
1119  ai = ai->next)
1121 }
1122 
1123 
1124 /* ************************* Backchannel *************************** */
1125 
1126 
1141 void
1144  const struct GNUNET_PeerIdentity *pid,
1145  const char *comm,
1146  const struct GNUNET_MessageHeader *header)
1147 {
1148  struct GNUNET_MQ_Envelope *env;
1149  struct GNUNET_TRANSPORT_CommunicatorBackchannel *cb;
1150  size_t slen = strlen (comm) + 1;
1151  uint16_t mlen = ntohs (header->size);
1152 
1153  GNUNET_assert (mlen + slen + sizeof(*cb) < UINT16_MAX);
1154  env =
1155  GNUNET_MQ_msg_extra (cb,
1156  slen + mlen,
1158  cb->pid = *pid;
1159  memcpy (&cb[1], header, mlen);
1160  memcpy (((char *) &cb[1]) + mlen, comm, slen);
1161  GNUNET_MQ_send (ch->mq, env);
1162 }
1163 
1164 
1165 /* 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:1055
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:36
@ GNUNET_OK
Definition: gnunet_common.h:99
@ GNUNET_YES
@ GNUNET_NO
Definition: gnunet_common.h:98
@ GNUNET_SYSERR
Definition: gnunet_common.h:97
#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:291
GNUNET_MQ_Error
Error codes for the queue.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:302
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_MQ_check_zero_termination(m)
Insert code for a "check_" function that verifies that a given variable-length message received over ...
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
Definition: gnunet_mq_lib.h:56
#define GNUNET_MQ_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:71
#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:640
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:535
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:685
GNUNET_NetworkType
Types of networks (with separate quotas) we support.
Definition: gnunet_nt_lib.h:36
#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:617
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 an MQ became available due to an "inbound" connection or because the co...
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:329
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:143
Handle to a message queue.
Definition: mq.c:86
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.