GNUnet  0.10.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 
45 struct FlowControl {
49  struct FlowControl *next;
50 
54  struct FlowControl *prev;
55 
60 
64  void *cb_cls;
65 
70 
74  uint64_t id;
75 };
76 
77 
82 struct AckPending {
86  struct AckPending *next;
87 
91  struct AckPending *prev;
92 
97 
101  struct GNUNET_PeerIdentity receiver;
102 
106  uint64_t mid;
107 };
108 
109 
118 
123 
128 
133 
138 
143 
148 
153 
158 
162  const char *config_section;
163 
167  const char *addr_prefix;
168 
174 
178  void *mq_init_cls;
179 
186 
191 
196 
200  unsigned long long max_queue_length;
201 
205  uint64_t fc_gen;
206 
211  uint32_t aid_gen;
212 
216  uint32_t queue_gen;
217 
222 };
223 
224 
234 
239 
244 
248  char *address;
249 
254 
259 
264 
269 
273  uint32_t queue_id;
274 
278  uint32_t mtu;
279 };
280 
281 
291 
296 
301 
305  char *address;
306 
312 
317  uint32_t aid;
318 
323 };
324 
325 
331 static void
333 
334 
341 static void
343 {
344  struct GNUNET_MQ_Envelope *env;
345  struct GNUNET_TRANSPORT_AddAddressMessage *aam;
346 
347  if (NULL == ai->ch->mq)
348  return;
349  env = GNUNET_MQ_msg_extra(aam,
350  strlen(ai->address) + 1,
352  aam->expiration = GNUNET_TIME_relative_hton(ai->expiration);
353  aam->nt = htonl((uint32_t)ai->nt);
354  memcpy(&aam[1], ai->address, strlen(ai->address) + 1);
355  GNUNET_MQ_send(ai->ch->mq, env);
356 }
357 
358 
365 static void
367 {
368  struct GNUNET_MQ_Envelope *env;
369  struct GNUNET_TRANSPORT_DelAddressMessage *dam;
370 
371  if (NULL == ai->ch->mq)
372  return;
374  dam->aid = htonl(ai->aid);
375  GNUNET_MQ_send(ai->ch->mq, env);
376 }
377 
378 
385 static void
387 {
388  struct GNUNET_MQ_Envelope *env;
389  struct GNUNET_TRANSPORT_AddQueueMessage *aqm;
390 
391  if (NULL == qh->ch->mq)
392  return;
393  env = GNUNET_MQ_msg_extra(aqm,
394  strlen(qh->address) + 1,
396  aqm->qid = htonl(qh->queue_id);
397  aqm->receiver = qh->peer;
398  aqm->nt = htonl((uint32_t)qh->nt);
399  aqm->mtu = htonl(qh->mtu);
400  aqm->cs = htonl((uint32_t)qh->cs);
401  memcpy(&aqm[1], qh->address, strlen(qh->address) + 1);
402  GNUNET_MQ_send(qh->ch->mq, env);
403 }
404 
405 
412 static void
414 {
415  struct GNUNET_MQ_Envelope *env;
416  struct GNUNET_TRANSPORT_DelQueueMessage *dqm;
417 
418  if (NULL == qh->ch->mq)
419  return;
421  dqm->qid = htonl(qh->queue_id);
422  dqm->receiver = qh->peer;
423  GNUNET_MQ_send(qh->ch->mq, env);
424 }
425 
426 
435 static void
437 {
438  struct FlowControl *fcn;
439  struct AckPending *apn;
440 
441  for (struct FlowControl *fc = ch->fc_head; NULL != fc; fc = fcn)
442  {
443  fcn = fc->next;
445  fc->cb(fc->cb_cls, GNUNET_SYSERR);
446  GNUNET_free(fc);
447  }
448  for (struct AckPending *ap = ch->ap_head; NULL != ap; ap = apn)
449  {
450  apn = ap->next;
452  GNUNET_free(ap);
453  }
454  if (NULL == ch->mq)
455  return;
456  GNUNET_MQ_destroy(ch->mq);
457  ch->mq = NULL;
458 }
459 
460 
464 static void
465 error_handler(void *cls, enum GNUNET_MQ_Error error)
466 {
468 
470  "MQ failure %d, reconnecting to transport service.\n",
471  error);
472  disconnect(ch);
473  /* TODO: maybe do this with exponential backoff/delay */
474  reconnect(ch);
475 }
476 
477 
485 static void
487  void *cls,
488  const struct GNUNET_TRANSPORT_IncomingMessageAck *incoming_ack)
489 {
491 
492  for (struct FlowControl *fc = ch->fc_head; NULL != fc; fc = fc->next)
493  {
494  if ((fc->id == incoming_ack->fc_id) &&
495  (0 == memcmp(&fc->sender,
496  &incoming_ack->sender,
497  sizeof(struct GNUNET_PeerIdentity))))
498  {
500  fc->cb(fc->cb_cls, GNUNET_OK);
501  GNUNET_free(fc);
502  return;
503  }
504  }
505  GNUNET_break(0);
506  disconnect(ch);
507  /* TODO: maybe do this with exponential backoff/delay */
508  reconnect(ch);
509 }
510 
511 
520 static int
521 check_create_queue(void *cls, const struct GNUNET_TRANSPORT_CreateQueue *cq)
522 {
523  (void)cls;
525  return GNUNET_OK;
526 }
527 
528 
535 static void
536 handle_create_queue(void *cls, const struct GNUNET_TRANSPORT_CreateQueue *cq)
537 {
539  const char *addr = (const char *)&cq[1];
540  struct GNUNET_TRANSPORT_CreateQueueResponse *cqr;
541  struct GNUNET_MQ_Envelope *env;
542 
543  if (GNUNET_OK != ch->mq_init(ch->mq_init_cls, &cq->receiver, addr))
544  {
546  "Address `%s' invalid for this communicator\n",
547  addr);
549  }
550  else
551  {
553  }
554  cqr->request_id = cq->request_id;
555  GNUNET_MQ_send(ch->mq, env);
556 }
557 
558 
567 static int
568 check_send_msg(void *cls, const struct GNUNET_TRANSPORT_SendMessageTo *smt)
569 {
570  (void)cls;
572  return GNUNET_OK;
573 }
574 
575 
585 static void
587  int status,
588  const struct GNUNET_PeerIdentity *receiver,
589  uint64_t mid)
590 {
591  struct GNUNET_MQ_Envelope *env;
592  struct GNUNET_TRANSPORT_SendMessageToAck *ack;
593 
595  ack->status = htonl(status);
596  ack->mid = mid;
597  ack->receiver = *receiver;
598  GNUNET_MQ_send(ch->mq, env);
599 }
600 
601 
608 static void
609 send_ack_cb(void *cls)
610 {
611  struct AckPending *ap = cls;
613 
615  send_ack(ch, GNUNET_OK, &ap->receiver, ap->mid);
616  GNUNET_free(ap);
617 }
618 
619 
626 static void
627 handle_send_msg(void *cls, const struct GNUNET_TRANSPORT_SendMessageTo *smt)
628 {
630  const struct GNUNET_MessageHeader *mh;
631  struct GNUNET_MQ_Envelope *env;
632  struct AckPending *ap;
633  struct GNUNET_TRANSPORT_QueueHandle *qh;
634 
635  for (qh = ch->queue_head; NULL != qh; qh = qh->next)
636  if ((qh->queue_id == smt->qid) &&
637  (0 == memcmp(&qh->peer,
638  &smt->receiver,
639  sizeof(struct GNUNET_PeerIdentity))))
640  break;
641  if (NULL == qh)
642  {
643  /* queue is already gone, tell transport this one failed */
645  "Transmission failed, queue no longer exists.\n");
646  send_ack(ch, GNUNET_NO, &smt->receiver, smt->mid);
647  return;
648  }
649  ap = GNUNET_new(struct AckPending);
650  ap->ch = ch;
651  ap->receiver = smt->receiver;
652  ap->mid = smt->mid;
654  mh = (const struct GNUNET_MessageHeader *)&smt[1];
655  env = GNUNET_MQ_msg_copy(mh);
657  GNUNET_MQ_send(qh->mq, env);
658 }
659 
660 
669 static int
671  void *cls,
672  const struct GNUNET_TRANSPORT_CommunicatorBackchannelIncoming *bi)
673 {
674  (void)cls;
676  return GNUNET_OK;
677 }
678 
679 
686 static void
688  void *cls,
689  const struct GNUNET_TRANSPORT_CommunicatorBackchannelIncoming *bi)
690 {
692 
693  if (NULL != ch->notify_cb)
694  ch->notify_cb(ch->notify_cb_cls,
695  &bi->pid,
696  (const struct GNUNET_MessageHeader *)&bi[1]);
697  else
698  GNUNET_log(
700  _("Dropped backchanel message: handler not provided by communicator\n"));
701 }
702 
703 
709 static void
711 {
712  struct GNUNET_MQ_MessageHandler handlers[] =
713  { GNUNET_MQ_hd_fixed_size(incoming_ack,
715  struct GNUNET_TRANSPORT_IncomingMessageAck,
716  ch),
717  GNUNET_MQ_hd_var_size(create_queue,
719  struct GNUNET_TRANSPORT_CreateQueue,
720  ch),
723  struct GNUNET_TRANSPORT_SendMessageTo,
724  ch),
726  backchannel_incoming,
728  struct GNUNET_TRANSPORT_CommunicatorBackchannelIncoming,
729  ch),
731  struct GNUNET_TRANSPORT_CommunicatorAvailableMessage *cam;
732  struct GNUNET_MQ_Envelope *env;
733 
734  ch->mq =
735  GNUNET_CLIENT_connect(ch->cfg, "transport", handlers, &error_handler, ch);
736  if (NULL == ch->mq)
737  return;
738  env = GNUNET_MQ_msg_extra(cam,
739  strlen(ch->addr_prefix) + 1,
741  cam->cc = htonl((uint32_t)ch->cc);
742  memcpy(&cam[1], ch->addr_prefix, strlen(ch->addr_prefix) + 1);
743  GNUNET_MQ_send(ch->mq, env);
744  for (struct GNUNET_TRANSPORT_AddressIdentifier *ai = ch->ai_head; NULL != ai;
745  ai = ai->next)
747  for (struct GNUNET_TRANSPORT_QueueHandle *qh = ch->queue_head; NULL != qh;
748  qh = qh->next)
749  send_add_queue(qh);
750 }
751 
752 
773  const struct GNUNET_CONFIGURATION_Handle *cfg,
774  const char *config_section,
775  const char *addr_prefix,
778  void *mq_init_cls,
780  void *notify_cb_cls)
781 {
783 
785  ch->cfg = cfg;
787  ch->addr_prefix = addr_prefix;
788  ch->mq_init = mq_init;
789  ch->mq_init_cls = mq_init_cls;
790  ch->notify_cb = notify_cb;
792  ch->cc = cc;
793  reconnect(ch);
794  if (GNUNET_OK !=
796  config_section,
797  "MAX_QUEUE_LENGTH",
798  &ch->max_queue_length))
800  if (NULL == ch->mq)
801  {
802  GNUNET_free(ch);
803  return NULL;
804  }
805  return ch;
806 }
807 
808 
814 void
817 {
818  disconnect(ch);
819  while (NULL != ch->ai_head)
820  {
821  GNUNET_break(0); /* communicator forgot to remove address, warn! */
823  }
824  GNUNET_free(ch);
825 }
826 
827 
828 /* ************************* Receiving *************************** */
829 
830 
851 int
854  const struct GNUNET_PeerIdentity *sender,
855  const struct GNUNET_MessageHeader *msg,
856  struct GNUNET_TIME_Relative expected_addr_validity,
858  void *cb_cls)
859 {
860  struct GNUNET_MQ_Envelope *env;
861  struct GNUNET_TRANSPORT_IncomingMessage *im;
862  uint16_t msize;
863 
864  if (NULL == ch->mq)
865  return GNUNET_SYSERR;
866  if ((NULL == cb) && (GNUNET_MQ_get_length(ch->mq) >= ch->max_queue_length))
867  {
868  GNUNET_log(
870  "Dropping message: transprot is too slow, queue length %llu exceeded\n",
871  ch->max_queue_length);
872  return GNUNET_NO;
873  }
874 
875  msize = ntohs(msg->size);
876  env =
878  if (NULL == env)
879  {
880  GNUNET_break(0);
881  return GNUNET_SYSERR;
882  }
883  im->expected_address_validity =
884  GNUNET_TIME_relative_hton(expected_addr_validity);
885  im->sender = *sender;
886  memcpy(&im[1], msg, msize);
887  if (NULL != cb)
888  {
889  struct FlowControl *fc;
890 
891  im->fc_on = htonl(GNUNET_YES);
892  im->fc_id = ch->fc_gen++;
893  fc = GNUNET_new(struct FlowControl);
894  fc->sender = *sender;
895  fc->id = im->fc_id;
896  fc->cb = cb;
897  fc->cb_cls = cb_cls;
899  }
900  GNUNET_MQ_send(ch->mq, env);
901  return GNUNET_OK;
902 }
903 
904 
905 /* ************************* Discovery *************************** */
906 
907 
927  const struct GNUNET_PeerIdentity *peer,
928  const char *address,
929  uint32_t mtu,
930  enum GNUNET_NetworkType nt,
932  struct GNUNET_MQ_Handle *mq)
933 {
934  struct GNUNET_TRANSPORT_QueueHandle *qh;
935 
937  qh->ch = ch;
938  qh->peer = *peer;
939  qh->address = GNUNET_strdup(address);
940  qh->nt = nt;
941  qh->mtu = mtu;
942  qh->cs = cs;
943  qh->mq = mq;
944  qh->queue_id = ch->queue_gen++;
946  send_add_queue(qh);
947  return qh;
948 }
949 
950 
957 void
959 {
961 
962  send_del_queue(qh);
964  GNUNET_MQ_destroy(qh->mq);
965  GNUNET_free(qh->address);
966  GNUNET_free(qh);
967 }
968 
969 
982  const char *address,
983  enum GNUNET_NetworkType nt,
985 {
987 
989  ai->ch = ch;
990  ai->address = GNUNET_strdup(address);
991  ai->nt = nt;
992  ai->expiration = expiration;
993  ai->aid = ch->aid_gen++;
995  send_add_address(ai);
996  return ai;
997 }
998 
999 
1006 void
1009 {
1011 
1012  send_del_address(ai);
1014  GNUNET_free(ai->address);
1015  GNUNET_free(ai);
1016 }
1017 
1018 
1019 /* ************************* Backchannel *************************** */
1020 
1021 
1036 void
1039  const struct GNUNET_PeerIdentity *pid,
1040  const char *comm,
1041  const struct GNUNET_MessageHeader *header)
1042 {
1043  struct GNUNET_MQ_Envelope *env;
1044  struct GNUNET_TRANSPORT_CommunicatorBackchannel *cb;
1045  size_t slen = strlen(comm) + 1;
1046  uint16_t mlen = ntohs(header->size);
1047 
1048  GNUNET_assert(mlen + slen + sizeof(*cb) < UINT16_MAX);
1049  env =
1051  slen + mlen,
1053  cb->pid = *pid;
1054  memcpy(&cb[1], header, mlen);
1055  memcpy(((char *)&cb[1]) + mlen, comm, slen);
1056  GNUNET_MQ_send(ch->mq, env);
1057 }
1058 
1059 
1060 /* 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.
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:651
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.
static char * expiration
Credential TTL.
#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.
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:900
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.
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_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#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:181
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:772
#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:333
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. ...
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.
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:104
#define GNUNET_MESSAGE_TYPE_TRANSPORT_DEL_ADDRESS
inform transport to delete an address of this peer
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.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
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:623
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
static void send_msg(void *cls)
Function called to notify a client about the socket begin ready to queue more data.
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:84
struct GNUNET_PeerIdentity peer
Which peer we can communciate with.
The identity of the host (wraps the signing key of the peer).
enum GNUNET_NetworkType nt
Network type for the address.
configuration data
Definition: configuration.c:83
#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:821
#define GNUNET_YES
Definition: gnunet_common.h:77
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:351
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, 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...
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).
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.