GNUnet  0.11.x
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 
263 
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 
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;
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;
496  GNUNET_free (ap);
497  }
498  if (NULL == ch->mq)
499  return;
500  GNUNET_MQ_destroy (ch->mq);
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  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 
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 == 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;
698  mh = (const struct GNUNET_MessageHeader *) &smt[1];
699  env = GNUNET_MQ_msg_copy (mh);
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 {
755  struct GNUNET_MQ_MessageHandler handlers[] =
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;
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;
835  ch->cc = cc;
836  reconnect (ch);
837  if (GNUNET_OK !=
839  config_section,
840  "MAX_QUEUE_LENGTH",
841  &ch->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  if (NULL == ch->mq)
908  return GNUNET_SYSERR;
909  if ((NULL == cb) && (GNUNET_MQ_get_length (ch->mq) >= ch->max_queue_length))
910  {
911  GNUNET_log (
913  "Dropping message: transport is too slow, queue length %llu exceeded\n",
914  ch->max_queue_length);
915  return GNUNET_NO;
916  }
917 
918  msize = ntohs (msg->size);
919  env =
921  if (NULL == env)
922  {
923  GNUNET_break (0);
924  return GNUNET_SYSERR;
925  }
926  im->expected_address_validity =
927  GNUNET_TIME_relative_hton (expected_addr_validity);
928  im->sender = *sender;
929  // FIXME: this is expensive, would be better if we would
930  // re-design the API to allow us to create the envelope first,
931  // and then have the application fill in the body so we do
932  // not have to memcpy()
933  memcpy (&im[1], msg, msize);
934  im->fc_on = htonl (GNUNET_NO);
935  if (NULL != cb)
936  {
937  struct FlowControl *fc;
938 
939  im->fc_on = htonl (GNUNET_YES);
940  im->fc_id = ch->fc_gen++;
941  fc = GNUNET_new (struct FlowControl);
942  fc->sender = *sender;
943  fc->id = im->fc_id;
944  fc->cb = cb;
945  fc->cb_cls = cb_cls;
947  }
948  GNUNET_MQ_send (ch->mq, env);
949  return GNUNET_OK;
950 }
951 
952 
953 /* ************************* Discovery *************************** */
954 
955 
978  const struct GNUNET_PeerIdentity *peer,
979  const char *address,
980  uint32_t mtu,
981  uint64_t q_len,
982  uint32_t priority,
983  enum GNUNET_NetworkType nt,
985  struct GNUNET_MQ_Handle *mq)
986 {
987  struct GNUNET_TRANSPORT_QueueHandle *qh;
988 
990  qh->ch = ch;
991  qh->peer = *peer;
992  qh->address = GNUNET_strdup (address);
993  qh->nt = nt;
994  qh->mtu = mtu;
995  qh->q_len = q_len;
996  qh->priority = priority;
997  qh->cs = cs;
998  qh->mq = mq;
999  qh->queue_id = ch->queue_gen++;
1001  send_add_queue (qh);
1002  return qh;
1003 }
1004 
1005 
1015 void
1018  const struct GNUNET_TRANSPORT_QueueHandle *u_qh,
1019  uint64_t q_len,
1020  uint32_t priority)
1021 {
1022  struct GNUNET_TRANSPORT_QueueHandle *qh;
1023 
1024  for (qh = ch->queue_head; NULL != qh; qh = qh->next)
1025  {
1026  if (u_qh == qh)
1027  break;
1028  }
1029  GNUNET_assert (NULL != qh);
1030  qh->q_len = q_len;
1031  qh->priority = priority;
1032  send_update_queue (qh);
1033 }
1034 
1035 
1042 void
1044 {
1046 
1047  send_del_queue (qh);
1049  GNUNET_MQ_destroy (qh->mq);
1050  GNUNET_free (qh->address);
1051  GNUNET_free (qh);
1052 }
1053 
1054 
1067  const char *address,
1068  enum GNUNET_NetworkType nt,
1070 {
1072 
1074  ai->ch = ch;
1075  ai->address = GNUNET_strdup (address);
1076  ai->nt = nt;
1077  ai->expiration = expiration;
1078  ai->aid = ch->aid_gen++;
1080  send_add_address (ai);
1081  return ai;
1082 }
1083 
1090 void
1093 {
1095 
1096  send_del_address (ai);
1098  GNUNET_free (ai->address);
1099  GNUNET_free (ai);
1100 }
1101 
1107 void
1110 {
1111  for (struct GNUNET_TRANSPORT_AddressIdentifier *ai = ch->ai_head; NULL != ai;
1112  ai = ai->next)
1114 }
1115 
1116 
1117 /* ************************* Backchannel *************************** */
1118 
1119 
1134 void
1137  const struct GNUNET_PeerIdentity *pid,
1138  const char *comm,
1139  const struct GNUNET_MessageHeader *header)
1140 {
1141  struct GNUNET_MQ_Envelope *env;
1142  struct GNUNET_TRANSPORT_CommunicatorBackchannel *cb;
1143  size_t slen = strlen (comm) + 1;
1144  uint16_t mlen = ntohs (header->size);
1145 
1146  GNUNET_assert (mlen + slen + sizeof(*cb) < UINT16_MAX);
1147  env =
1148  GNUNET_MQ_msg_extra (cb,
1149  slen + mlen,
1151  cb->pid = *pid;
1152  memcpy (&cb[1], header, mlen);
1153  memcpy (((char *) &cb[1]) + mlen, comm, slen);
1154  GNUNET_MQ_send (ch->mq, env);
1155 }
1156 
1157 
1158 /* end of transport_api2_communication.c */
GNUNET_TRANSPORT_CommunicatorCharacteristics
What characteristics does this communicator have?
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
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...
uint32_t aid_gen
Internal UUID for the address used in communication with the transport service.
enum GNUNET_NetworkType nt
Network type of the communciation queue.
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
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:666
static void handle_send_msg(void *cls, const struct GNUNET_TRANSPORT_SendMessageTo *smt)
Transport service wants us to send a message.
struct GNUNET_PeerIdentity receiver
Which peer is this about?
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG
transport tells communicator it wants to transmit
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
static void send_add_queue(struct GNUNET_TRANSPORT_QueueHandle *qh)
Send message to the transport service about queue qh being now available.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE
transport tells communicator it wants a queue
int 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.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
uint64_t id
More-or-less unique ID for the message.
unsigned long long max_queue_length
Maximum permissable queue length.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
common internal definitions for transport service
static void send_ack_cb(void *cls)
Message queue transmission by communicator was successful, notify transport service.
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
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...
#define GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_OK
Response from communicator: will try to create queue.
GNUNET_MQ_Error
Error codes for the queue.
char * address
Address used by the communication queue.
static void handle_backchannel_incoming(void *cls, const struct GNUNET_TRANSPORT_CommunicatorBackchannelIncoming *bi)
Transport service gives us backchannel message.
uint32_t queue_id
ID for this queue when talking to the transport service.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static struct GNUNET_CADET_Handle * mh
Cadet handle.
Definition: gnunet-cadet.c:92
struct GNUNET_TRANSPORT_QueueHandle * next
Kept in a DLL.
const char * config_section
Config section to use.
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
struct GNUNET_TRANSPORT_AddressIdentifier * next
Kept in a DLL.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_UPDATE
inform transport that a queue was updated
GNUNET_TRANSPORT_MessageCompletedCallback cb
Function to call once the message was processed.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
#define GNUNET_new(type)
Allocate a struct or union of the given type.
GNUNET_TRANSPORT_CommunicatorNotify notify_cb
Function to call when the transport service receives messages for a communicator (i.e.
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 (...
struct GNUNET_TRANSPORT_QueueHandle * prev
Kept in a DLL.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL_INCOMING
Transport signalling incoming backchannel message to a communicator.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
static int check_backchannel_incoming(void *cls, const struct GNUNET_TRANSPORT_CommunicatorBackchannelIncoming *bi)
Transport service gives us backchannel message.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
GNUNET_NetworkType
Types of networks (with separate quotas) we support.
Definition: gnunet_nt_lib.h:35
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Information we track per packet to enable flow control.
struct GNUNET_TRANSPORT_AddressIdentifier * ai_tail
Tail of DLL of addresses this communicator offers to the transport service.
#define GNUNET_MQ_check_boxed_message(m)
Insert code for a "check_" function that verifies that a given variable-length message received over ...
struct GNUNET_TRANSPORT_CommunicatorHandle * ch
Handle this queue belongs to.
struct GNUNET_TRANSPORT_QueueHandle * queue_head
DLL of queues we offer.
struct GNUNET_TRANSPORT_CommunicatorHandle * ch
Transport handle where the address was added.
Opaque handle to the transport service for communicators.
#define _(String)
GNU gettext support macro.
Definition: platform.h:184
void GNUNET_TRANSPORT_communicator_disconnect(struct GNUNET_TRANSPORT_CommunicatorHandle *ch)
Disconnect from the transport service.
struct AckPending * prev
Kept in a DLL.
enum GNUNET_TRANSPORT_ConnectionStatus cs
Communication status of the queue.
void * cb_cls
Closure for cb.
static void error_handler(void *cls, enum GNUNET_MQ_Error error)
Function called on MQ errors.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG
inform transport about an incoming 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.
static int check_send_msg(void *cls, const struct GNUNET_TRANSPORT_SendMessageTo *smt)
Transport service wants us to send a message.
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...
#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_TRANSPORT_QueueHandle * queue_tail
DLL of queues we offer.
uint64_t fc_gen
Flow-control identifier generator.
#define GNUNET_MQ_check_zero_termination(m)
Insert code for a "check_" function that verifies that a given variable-length message received over ...
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:787
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG_ACK
transport acknowledges processing an incoming message
unsigned int GNUNET_MQ_get_length(struct GNUNET_MQ_Handle *mq)
Obtain the current length of the message queue.
Definition: mq.c:337
static void send_del_address(struct GNUNET_TRANSPORT_AddressIdentifier *ai)
Send message to the transport service about address ai being no longer available. ...
#define GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_SETUP
inform transport that a queue was setup to talk to some peer
const char * addr_prefix
Address prefix to use.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL
Tell transport that it should assist with exchanging a message between communicators.
struct GNUNET_TIME_Relative expiration
When does the address expire? (Expected lifetime of the address.)
void(* GNUNET_TRANSPORT_MessageCompletedCallback)(void *cls, int success)
Function called to notify communicator that we have received and processed the message.
static void disconnect(struct GNUNET_TRANSPORT_CommunicatorHandle *ch)
Disconnect from the transport service.
uint16_t status
See PRISM_STATUS_*-constants.
struct AckPending * ap_tail
DLL of messages awaiting transmission confirmation (ack).
static void send_del_queue(struct GNUNET_TRANSPORT_QueueHandle *qh)
Send message to the transport service about queue qh being no longer available.
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.
struct FlowControl * fc_head
DLL of messages awaiting flow control confirmation (ack).
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG_ACK
communicator tells transports that message was sent
Information we track per message to tell the transport about success or failures. ...
static char * expiration
Credential TTL.
Definition: gnunet-abd.c:96
struct GNUNET_PeerIdentity sender
Which peer is this about?
Message handler for a specific message type.
static struct GNUNET_NAT_AUTO_Test * nt
Handle to a NAT test operation.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_DEL_ADDRESS
inform transport to delete an address of this peer
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:36
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...
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.
static struct GNUNET_TRANSPORT_AddressIdentifier * ai
Handle to the operation that publishes our address.
struct GNUNET_TIME_RelativeNBO GNUNET_TIME_relative_hton(struct GNUNET_TIME_Relative a)
Convert relative time to network byte order.
Definition: time.c:625
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...
struct FlowControl * prev
Kept in a DLL.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
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...
static void send_msg(void *cls)
Function called to notify a client about the socket begin ready to queue more data.
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
struct GNUNET_MQ_Handle * mq
Queue to talk to the transport service.
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.
struct GNUNET_TRANSPORT_AddressIdentifier * ai_head
Head of DLL of addresses this communicator offers to the transport service.
struct GNUNET_TRANSPORT_AddressIdentifier * prev
Kept in a DLL.
static void reconnect(struct GNUNET_TRANSPORT_CommunicatorHandle *ch)
(re)connect our communicator to the transport service
Handle to a message queue.
Definition: mq.c:85
struct GNUNET_PeerIdentity peer
Which peer we can communciate with.
The identity of the host (wraps the signing key of the peer).
static void send_update_queue(struct GNUNET_TRANSPORT_QueueHandle *qh)
Send message to the transport service about queue qh updated.
enum GNUNET_NetworkType nt
Network type for the address.
configuration data
Definition: configuration.c:84
#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...
#define GNUNET_MESSAGE_TYPE_TRANSPORT_NEW_COMMUNICATOR
Message sent to indicate to the transport which address prefix is supported by a communicator.
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...
#define GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_FAIL
Response from communicator: address bogus, will not try to create queue.
static void send_add_address(struct GNUNET_TRANSPORT_AddressIdentifier *ai)
Send message to the transport service about address ai being now available.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_TEARDOWN
inform transport that a queue was torn down
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
#define GNUNET_log(kind,...)
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.
struct GNUNET_MQ_Handle * mq
The queue itself.
static int check_create_queue(void *cls, const struct GNUNET_TRANSPORT_CreateQueue *cq)
Transport service wants us to create a queue.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_ADD_ADDRESS
inform transport to add an address of this peer
uint32_t queue_gen
Queue identifier generator.
struct GNUNET_TRANSPORT_CommunicatorHandle * ch
Communicator this entry belongs to.
Header for all communications.
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:837
uint64_t mid
More-or-less unique ID for the message.
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
GNUNET_TRANSPORT_ConnectionStatus
Possible states of a connection.
uint32_t aid
Internal UUID for the address used in communication with the transport service.
static struct GNUNET_PeerIdentity pid
Identity of the peer we transmit to / connect to.
const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
struct FlowControl * fc_tail
DLL of messages awaiting flow control confirmation (ack).
GNUNET_TRANSPORT_CommunicatorMqInit mq_init
Function to call when the transport service wants us to initiate a communication channel with another...
struct AckPending * next
Kept in a DLL.
enum GNUNET_TRANSPORT_CommunicatorCharacteristics cc
Characteristics of the communicator.
struct FlowControl * next
Kept in a DLL.
static char * address
GNS address for this phone.
uint32_t mtu
Maximum transmission unit for the queue.
Handle returned to identify the internal data structure the transport API has created to manage a mes...
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
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).
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.
struct AckPending * ap_head
DLL of messages awaiting transmission confirmation (ack).
Internal representation of an address a communicator is currently providing for the transport service...
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.
Bandwidth allocation API for the transport service.
static void handle_create_queue(void *cls, const struct GNUNET_TRANSPORT_CreateQueue *cq)
Transport service wants us to create a queue.