GNUnet  0.10.x
transport-testing2.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2019 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 
27 #include "platform.h"
28 #include "gnunet_util_lib.h"
29 #include "gnunet_protocols.h"
30 #include "gnunet_constants.h"
31 #include "transport-testing2.h"
33 #include "gnunet_hello_lib.h"
34 #include "gnunet_signatures.h"
35 #include "transport.h"
36 
37 
38 #define LOG(kind, ...) GNUNET_log_from(kind, "transport-testing2", __VA_ARGS__)
39 
40 
49 
53  char *cfg_filename;
54 
59 
65 
70 
75 
80 
85 
90 
95 
99  char *c_address;
100 
105 
110 
111  /* Callbacks + Closures */
117 
122 
127 
132 
137 
141  void *cb_cls;
142 };
143 
144 
153 
162 
167 
171  uint32_t qid;
172 
176  uint64_t mid;
177 
181  uint32_t nt;
182 
186  uint32_t mtu;
187 
191  uint32_t cs;
192 
197 
202 };
203 
204 
209 };
210 
211 
221 static int
223  void *cls,
224  const struct GNUNET_TRANSPORT_CommunicatorAvailableMessage *msg)
225 {
226  uint16_t size;
227 
228  size = ntohs(msg->header.size) - sizeof(*msg);
229  if (0 == size)
230  return GNUNET_OK; /* receive-only communicator */
232  return GNUNET_OK;
233 }
234 
235 
244 static void
246  void *cls,
247  const struct GNUNET_TRANSPORT_CommunicatorAvailableMessage *msg)
248 {
250  uint16_t size;
251 
252  size = ntohs(msg->header.size) - sizeof(*msg);
253  if (0 == size)
254  return; /* receive-only communicator */
255  tc_h->c_characteristics = ntohl(msg->cc);
256  tc_h->c_addr_prefix = GNUNET_strdup((const char *)&msg[1]);
257  if (NULL != tc_h->communicator_available_cb)
258  {
259  LOG(GNUNET_ERROR_TYPE_DEBUG, "calling communicator_available_cb()\n");
260  tc_h->communicator_available_cb(tc_h->cb_cls,
261  tc_h,
262  tc_h->c_characteristics,
263  tc_h->c_addr_prefix);
264  }
266 }
267 
268 
276 static int
278  const struct GNUNET_TRANSPORT_AddAddressMessage *msg)
279 {
280  struct TransportClient *tc = cls;
281 
282  //if (CT_COMMUNICATOR != tc->type)
283  //{
284  // GNUNET_break (0);
285  // return GNUNET_SYSERR;
286  //}
288  return GNUNET_OK;
289 }
290 
291 
300 static void
302  const struct GNUNET_TRANSPORT_AddAddressMessage *msg)
303 {
305  uint16_t size;
306 
307  size = ntohs(msg->header.size) - sizeof(*msg);
308  if (0 == size)
309  return; /* receive-only communicator */
310  tc_h->c_address = GNUNET_strdup((const char *)&msg[1]);
311  if (NULL != tc_h->add_address_cb)
312  {
313  LOG(GNUNET_ERROR_TYPE_DEBUG, "calling communicator_available()\n");
314  tc_h->add_address_cb(tc_h->cb_cls,
315  tc_h,
316  tc_h->c_address,
317  GNUNET_TIME_relative_ntoh(msg->expiration),
318  msg->aid,
319  ntohl(msg->nt));
320  }
322 }
323 
324 
332 static int
334  const struct GNUNET_TRANSPORT_IncomingMessage *msg)
335 {
336  //struct TransportClient *tc = cls;
337 
338  //if (CT_COMMUNICATOR != tc->type)
339  //{
340  // GNUNET_break (0);
341  // return GNUNET_SYSERR;
342  //}
344  return GNUNET_OK;
345 }
346 
347 
356 static void
358  const struct GNUNET_TRANSPORT_IncomingMessage *msg)
359 {
361 
362  if (NULL != tc_h->incoming_msg_cb)
363  {
364  tc_h->incoming_msg_cb(tc_h->cb_cls,
365  tc_h,
366  (const struct GNUNET_MessageHeader *)msg);
367  }
368  else
369  {
371  "Incoming message from communicator but no handler!\n");
372  }
374 }
375 
376 
383 static void
385  const struct GNUNET_TRANSPORT_CreateQueueResponse *msg)
386 {
388 
389  if (NULL != tc_h->queue_create_reply_cb)
390  {
391  tc_h->queue_create_reply_cb(tc_h->cb_cls, tc_h, GNUNET_YES);
392  }
394 }
395 
396 
406 static void
408  void *cls,
409  const struct GNUNET_TRANSPORT_CreateQueueResponse *msg)
410 {
412 
413  if (NULL != tc_h->queue_create_reply_cb)
414  {
415  tc_h->queue_create_reply_cb(tc_h->cb_cls, tc_h, GNUNET_NO);
416  }
418 }
419 
420 
427 static int
429  const struct GNUNET_TRANSPORT_AddQueueMessage *aqm)
430 {
432  return GNUNET_OK;
433 }
434 
435 
444 static void
446  const struct GNUNET_TRANSPORT_AddQueueMessage *msg)
447 {
450 
451  tc_queue = tc_h->queue_head;
452  while (tc_queue->qid != msg->qid)
453  {
454  tc_queue = tc_queue->next;
455  }
456  GNUNET_assert(tc_queue->qid == msg->qid);
457  GNUNET_assert(0 == GNUNET_memcmp(&tc_queue->peer_id, &msg->receiver));
458  tc_queue->nt = msg->nt;
459  tc_queue->mtu = msg->mtu;
460  tc_queue->cs = msg->cs;
461  if (NULL != tc_h->add_queue_cb)
462  {
463  tc_h->add_queue_cb(tc_h->cb_cls, tc_h, tc_queue);
464  }
466 }
467 
468 
474 static void
476 {
477  struct GNUNET_SERVICE_Handle *h = cls;
478 
480 }
481 
482 
492 static void *
493 connect_cb(void *cls,
495  struct GNUNET_MQ_Handle *mq)
496 {
499 
500  LOG(GNUNET_ERROR_TYPE_DEBUG, "Client connected.\n");
501  tc_h->client = client;
502  tc_h->c_mq = mq;
503 
504  if (NULL == tc_h->queue_head)
505  return tc_h;
506  /* Iterate over queues. They are yet to be opened. Request opening. */
507  while (NULL != (tc_queue_iter = tc_h->queue_head))
508  {
509  if (NULL == tc_queue_iter->open_queue_env)
510  continue;
511  /* Send the previously created mq envelope to request the creation of the
512  * queue. */
513  GNUNET_MQ_send(tc_h->c_mq, tc_queue_iter->open_queue_env);
514  tc_queue_iter->open_queue_env = NULL;
515  }
516  return tc_h;
517 }
518 
519 
527 static void
528 disconnect_cb(void *cls,
530  void *internal_cls)
531 {
533 
534  LOG(GNUNET_ERROR_TYPE_DEBUG, "Client disconnected.\n");
535  tc_h->client = NULL;
536 }
537 
538 
546 static void
549 {
550  struct GNUNET_MQ_MessageHandler mh[] = {
551  GNUNET_MQ_hd_var_size(communicator_available,
553  struct GNUNET_TRANSPORT_CommunicatorAvailableMessage,
554  &tc_h),
555  //GNUNET_MQ_hd_var_size (communicator_backchannel,
556  // GNUNET_MESSAGE_TYPE_TRANSPORT_COMMUNICATOR_BACKCHANNEL,
557  // struct GNUNET_TRANSPORT_CommunicatorBackchannel,
558  // NULL),
559  GNUNET_MQ_hd_var_size(add_address,
561  struct GNUNET_TRANSPORT_AddAddressMessage,
562  &tc_h),
563  //GNUNET_MQ_hd_fixed_size (del_address,
564  // GNUNET_MESSAGE_TYPE_TRANSPORT_DEL_ADDRESS,
565  // struct GNUNET_TRANSPORT_DelAddressMessage,
566  // NULL),
567  GNUNET_MQ_hd_var_size(incoming_msg,
569  struct GNUNET_TRANSPORT_IncomingMessage,
570  NULL),
571  GNUNET_MQ_hd_fixed_size(queue_create_ok,
573  struct GNUNET_TRANSPORT_CreateQueueResponse,
574  tc_h),
575  GNUNET_MQ_hd_fixed_size(queue_create_fail,
577  struct GNUNET_TRANSPORT_CreateQueueResponse,
578  tc_h),
579  GNUNET_MQ_hd_var_size(add_queue_message,
581  struct GNUNET_TRANSPORT_AddQueueMessage,
582  NULL),
583  //GNUNET_MQ_hd_fixed_size (del_queue_message,
584  // GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_TEARDOWN,
585  // struct GNUNET_TRANSPORT_DelQueueMessage,
586  // NULL),
587  //GNUNET_MQ_hd_fixed_size (send_message_ack,
588  // GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG_ACK,
589  // struct GNUNET_TRANSPORT_SendMessageToAck,
590  // NULL),
591  };
592  struct GNUNET_SERVICE_Handle *h;
593 
594  h = GNUNET_SERVICE_start("transport",
595  tc_h->cfg,
596  &connect_cb,
597  &disconnect_cb,
598  tc_h,
599  mh);
600  if (NULL == h)
601  LOG(GNUNET_ERROR_TYPE_ERROR, "Failed starting service!\n");
602  else
603  {
604  LOG(GNUNET_ERROR_TYPE_DEBUG, "Started service\n");
606  }
607 }
608 
609 
615 static void
617 {
618  struct GNUNET_OS_Process *proc = cls;
619 
620  if (GNUNET_OK != GNUNET_OS_process_kill(proc, SIGTERM))
621  {
623  "Error shutting down communicator with SIGERM, trying SIGKILL\n");
624  if (GNUNET_OK != GNUNET_OS_process_kill(proc, SIGKILL))
625  {
627  "Error shutting down communicator with SIGERM and SIGKILL\n");
628  }
629  }
631 }
632 
633 
639 static void
642  const char *binary_name)
643 {
644  char *binary;
645 
646  LOG(GNUNET_ERROR_TYPE_DEBUG, "communicator_start\n");
647  binary = GNUNET_OS_get_libexec_binary_path(binary_name);
650  NULL,
651  NULL,
652  NULL,
653  binary,
654  binary_name,
655  "-c",
656  tc_h->cfg_filename,
657  NULL);
658  if (NULL == tc_h->c_proc)
659  {
660  GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to start communicator!");
661  return;
662  }
663  LOG(GNUNET_ERROR_TYPE_DEBUG, "started communicator\n");
664  GNUNET_free(binary);
666  tc_h->c_proc);
667 }
668 
669 
684  const char *service_name,
685  const char *binary_name,
686  const char *cfg_filename,
693  void *cb_cls)
694 {
696 
697  tc_h =
699  tc_h->cfg_filename = GNUNET_strdup(cfg_filename);
701  if ((GNUNET_SYSERR == GNUNET_CONFIGURATION_load(tc_h->cfg, cfg_filename)))
702  {
704  _("Malformed configuration file `%s', exit ...\n"),
705  cfg_filename);
706  GNUNET_free(tc_h->cfg_filename);
708  GNUNET_free(tc_h);
709  return NULL;
710  }
714  tc_h->add_queue_cb = add_queue_cb;
715  tc_h->incoming_msg_cb = incoming_message_cb;
716  tc_h->cb_cls = cb_cls;
717 
718  /* Start communicator part of service */
720 
721  /* Schedule start communicator */
722  communicator_start(tc_h,
723  binary_name);
724  return tc_h;
725 }
726 
727 
735 void
738  const struct GNUNET_PeerIdentity *peer_id,
739  const char *address)
740 {
742  static uint32_t idgen;
743  char *prefix;
744  struct GNUNET_TRANSPORT_CreateQueue *msg;
745  struct GNUNET_MQ_Envelope *env;
746  size_t alen;
747 
748  tc_queue =
750  tc_queue->tc_h = tc_h;
751  prefix = GNUNET_HELLO_address_to_prefix(address);
752  if (NULL == prefix)
753  {
754  GNUNET_break(0); /* We got an invalid address!? */
755  GNUNET_free(tc_queue);
756  return;
757  }
758  GNUNET_free(prefix);
759  alen = strlen(address) + 1;
760  env =
762  msg->request_id = htonl(idgen++);
763  tc_queue->qid = msg->request_id;
764  msg->receiver = *peer_id;
765  tc_queue->peer_id = *peer_id;
766  memcpy(&msg[1], address, alen);
767  if (NULL != tc_h->c_mq)
768  {
769  GNUNET_MQ_send(tc_h->c_mq, env);
770  }
771  else
772  {
773  tc_queue->open_queue_env = env;
774  }
775  GNUNET_CONTAINER_DLL_insert(tc_h->queue_head, tc_h->queue_tail, tc_queue);
776 }
777 
778 
791  const void *payload,
792  size_t payload_size /*,
793  GNUNET_TRANSPORT_TESTING_SuccessStatus cb,
794  void *cb_cls*/)
795 {
797  struct GNUNET_MessageHeader *mh;
798  struct GNUNET_TRANSPORT_SendMessageTo *msg;
799  struct GNUNET_MQ_Envelope *env;
800  size_t inbox_size;
801 
802  inbox_size = sizeof(struct GNUNET_MessageHeader) + payload_size;
803  mh = GNUNET_malloc(inbox_size);
804  mh->size = htons(inbox_size);
805  mh->type = GNUNET_MESSAGE_TYPE_DUMMY;
806  memcpy(&mh[1],
807  payload,
808  payload_size);
809  env = GNUNET_MQ_msg_extra(msg,
810  inbox_size,
812  msg->qid = htonl(tc_queue->qid);
813  msg->mid = tc_queue->mid++;
814  msg->receiver = tc_queue->peer_id;
815  memcpy(&msg[1], mh, inbox_size);
816  GNUNET_free(mh);
817  GNUNET_MQ_send(tc_queue->tc_h->c_mq, env);
818  return tc_t;
819 }
GNUNET_TRANSPORT_CommunicatorCharacteristics
What characteristics does this communicator have?
functions and structures related to testing-tng
struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorQueue * next
Next element inside a DLL.
struct GNUNET_PeerIdentity peer_id
Peer ID of the peer on the other side of the queue.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_SEND_MSG
transport tells communicator it wants to transmit
static void handle_queue_create_fail(void *cls, const struct GNUNET_TRANSPORT_CreateQueueResponse *msg)
Communicator informs that it wont try establishing requested queue.
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
#define GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE
transport tells communicator it wants a queue
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
void(* GNUNET_TRANSPORT_TESTING_QueueCreateReplyCallback)(void *cls, struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h, int will_try)
Get informed about the success of a queue request.
common internal definitions for transport service
void GNUNET_OS_process_destroy(struct GNUNET_OS_Process *proc)
Cleans up process structure contents (OS-dependent) and deallocates it.
Definition: os_priority.c:286
Handle to a service.
Definition: service.c:114
#define GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_CREATE_OK
Response from communicator: will try to create queue.
char * cfg_filename
File name of configuration file.
static void handle_communicator_available(void *cls, const struct GNUNET_TRANSPORT_CommunicatorAvailableMessage *msg)
Handle new communicator.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1284
void(* GNUNET_TRANSPORT_TESTING_AddQueueCallback)(void *cls, struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h, struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorQueue *tc_queue)
Handle opening of queue.
struct GNUNET_SCHEDULER_Task * ts_shutdown_task
Task that will be run on shutdown to stop and clean transport service.
static void shutdown_communicator(void *cls)
Task run at shutdown to kill communicator and clean up.
struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle * GNUNET_TRANSPORT_TESTING_transport_communicator_service_start(const char *service_name, const char *binary_name, const char *cfg_filename, GNUNET_TRANSPORT_TESTING_CommunicatorAvailableCallback communicator_available_cb, GNUNET_TRANSPORT_TESTING_AddAddressCallback add_address_cb, GNUNET_TRANSPORT_TESTING_QueueCreateReplyCallback queue_create_reply_cb, GNUNET_TRANSPORT_TESTING_AddQueueCallback add_queue_cb, GNUNET_TRANSPORT_TESTING_IncomingMessageCallback incoming_message_cb, void *cb_cls)
Start communicator part of transport service and communicator.
#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_OS_Process * GNUNET_OS_start_process(int pipe_control, enum GNUNET_OS_InheritStdioFlags std_inheritance, struct GNUNET_DISK_PipeHandle *pipe_stdin, struct GNUNET_DISK_PipeHandle *pipe_stdout, struct GNUNET_DISK_PipeHandle *pipe_stderr, const char *filename,...)
Start a process.
Definition: os_priority.c:687
static struct GNUNET_SCHEDULER_TaskContext tc
Task context of the current task.
Definition: scheduler.c:410
void GNUNET_TRANSPORT_TESTING_transport_communicator_open_queue(struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h, const struct GNUNET_PeerIdentity *peer_id, const char *address)
Instruct communicator to open a queue.
#define GNUNET_MESSAGE_TYPE_DUMMY
Dummy messages for testing / benchmarking.
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
struct GNUNET_SERVICE_Handle * GNUNET_SERVICE_start(const char *service_name, const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_SERVICE_ConnectHandler connect_cb, GNUNET_SERVICE_DisconnectHandler disconnect_cb, void *cls, const struct GNUNET_MQ_MessageHandler *handlers)
Low-level function to start a service if the scheduler is already running.
Definition: service.c:1874
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_MQ_Handle * c_mq
Handle to the client.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_create(void)
Create a new configuration object.
enum GNUNET_TRANSPORT_CommunicatorCharacteristics c_characteristics
Characteristics of the communicator.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define GNUNET_MQ_check_boxed_message(m)
Insert code for a "check_" function that verifies that a given variable-length message received over ...
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
GNUNET_TRANSPORT_TESTING_CommunicatorAvailableCallback communicator_available_cb
Callback called when a new communicator connects.
int GNUNET_CONFIGURATION_load(struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename)
Load configuration.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
Handle to a client that is connected to a service.
Definition: service.c:246
char * c_addr_prefix
Specifies supported addresses.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_INCOMING_MSG
inform transport about an incoming message
uint32_t cs
An enum GNUNET_TRANSPORT_ConnectionStatus in NBO.
static void handle_add_address(void *cls, const struct GNUNET_TRANSPORT_AddAddressMessage *msg)
The communicator informs about an address.
#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
static int check_add_queue_message(void *cls, const struct GNUNET_TRANSPORT_AddQueueMessage *aqm)
New queue became available.
#define GNUNET_MQ_check_zero_termination(m)
Insert code for a "check_" function that verifies that a given variable-length message received over ...
static int check_communicator_available(void *cls, const struct GNUNET_TRANSPORT_CommunicatorAvailableMessage *msg)
Check whether incoming msg indicating available communicator is correct.
static int check_add_address(void *cls, const struct GNUNET_TRANSPORT_AddAddressMessage *msg)
Address of our peer added.
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_MESSAGE_TYPE_TRANSPORT_QUEUE_SETUP
inform transport that a queue was setup to talk to some peer
static char * service_name
Option -s: service name (hash to get service descriptor)
Definition: gnunet-vpn.c:51
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
GNUNET_TRANSPORT_TESTING_AddAddressCallback add_address_cb
Callback called when a new communicator connects.
struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorTransmission * GNUNET_TRANSPORT_TESTING_transport_communicator_send(struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorQueue *tc_queue, const void *payload, size_t payload_size)
Instruct communicator to send data.
static void handle_queue_create_ok(void *cls, const struct GNUNET_TRANSPORT_CreateQueueResponse *msg)
Communicator informs that it tries to establish requested queue.
void GNUNET_SERVICE_stop(struct GNUNET_SERVICE_Handle *srv)
Stops a service that was started with GNUNET_SERVICE_start().
Definition: service.c:1907
struct GNUNET_TIME_Relative GNUNET_TIME_relative_ntoh(struct GNUNET_TIME_RelativeNBO a)
Convert relative time from network byte order.
Definition: time.c:639
Message handler for a specific message type.
When these flags are set, the child process will inherit stdout and stderr of the parent...
Definition: gnunet_os_lib.h:96
static int check_incoming_msg(void *cls, const struct GNUNET_TRANSPORT_IncomingMessage *msg)
Incoming message.
void(* GNUNET_TRANSPORT_TESTING_CommunicatorAvailableCallback)(void *cls, struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h, enum GNUNET_TRANSPORT_CommunicatorCharacteristics cc, char *address_prefix)
Function signature for callbacks that are called when new communicators become available.
struct GNUNET_CONFIGURATION_Handle * cfg
Handle to the configuration.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static unsigned int size
Size of the "table".
Definition: peer.c:66
char * GNUNET_HELLO_address_to_prefix(const char *address)
Given an address as a string, extract the prefix that identifies the communicator offering transmissi...
Definition: hello-ng.c:190
struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorQueue * prev
Previous element inside a DLL.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
GNUNET_TRANSPORT_TESTING_IncomingMessageCallback incoming_msg_cb
Callback called when a new communicator connects.
static void communicator_start(struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h, const char *binary_name)
Start the communicator.
static unsigned long long payload
How much data are we currently storing in the database?
uint32_t nt
An enum GNUNET_NetworkType in NBO.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
struct GNUNET_SERVICE_Handle * tsh
Handle to the transport service.
Handle to a message queue.
Definition: mq.c:84
uint32_t mtu
Maximum transmission unit, in NBO.
The identity of the host (wraps the signing key of the peer).
static void handle_add_queue_message(void *cls, const struct GNUNET_TRANSPORT_AddQueueMessage *msg)
Handle new queue.
configuration data
Definition: configuration.c:83
static void handle_incoming_msg(void *cls, const struct GNUNET_TRANSPORT_IncomingMessage *msg)
Receive an incoming message.
#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.
struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorQueue * queue_tail
Tail of the DLL of queues associated with this communicator.
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
Client connected to the transport service.
#define GNUNET_log(kind,...)
Entry in list of pending tasks.
Definition: scheduler.c:131
char * GNUNET_OS_get_libexec_binary_path(const char *progname)
Given the name of a gnunet-helper, gnunet-service or gnunet-daemon binary, try to prefix it with the ...
static void disconnect_cb(void *cls, struct GNUNET_SERVICE_Client *client, void *internal_cls)
Callback called when Client disconnects.
#define GNUNET_MESSAGE_TYPE_TRANSPORT_ADD_ADDRESS
inform transport to add an address of this peer
struct GNUNET_MQ_Envelope * open_queue_env
Envelope to a message that requests the opening of the queue.
struct GNUNET_OS_Process * c_proc
Process of the communicator.
Header for all communications.
void(* GNUNET_TRANSPORT_TESTING_AddAddressCallback)(void *cls, struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h, const char *address, struct GNUNET_TIME_Relative expiration, uint32_t aid, enum GNUNET_NetworkType nt)
Receive information about the address of a communicator.
GNUNET_TRANSPORT_TESTING_AddQueueCallback add_queue_cb
Callback called when a new communicator connects.
#define GNUNET_YES
Definition: gnunet_common.h:77
GNUNET_TRANSPORT_TESTING_QueueCreateReplyCallback queue_create_reply_cb
Callback called when a new communicator connects.
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_TESTING_TransportCommunicatorQueue * queue_head
Head of the DLL of queues associated with this communicator.
struct GNUNET_SCHEDULER_Task * c_shutdown_task
Task that will be run on shutdown to stop and clean communicator.
void(* GNUNET_TRANSPORT_TESTING_IncomingMessageCallback)(void *cls, struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h, const struct GNUNET_MessageHeader *msg)
Handle an incoming message.
struct GNUNET_SERVICE_Client * client
Handle to the client.
static void shutdown_service(void *cls)
Shut down the service.
static void transport_communicator_start(struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle *tc_h)
Start the communicator part of the transport service.
static char * address
GNS address for this phone.
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2234
#define LOG(kind,...)
#define GNUNET_malloc(size)
Wrapper around malloc.
struct GNUNET_TRANSPORT_TESTING_TransportCommunicatorHandle * tc_h
Handle to the TransportCommunicator.
char * c_address
Specifies supported addresses.
#define GNUNET_free(ptr)
Wrapper around free.
Queue of a communicator and some context.
int GNUNET_OS_process_kill(struct GNUNET_OS_Process *proc, int sig)
Sends a signal to the process.
Definition: os_priority.c:224
static void * connect_cb(void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
Callback called when new Client (Communicator) connects.
Bandwidth allocation API for the transport service.