GNUnet  0.10.x
gnunet-cadet.c
Go to the documentation of this file.
1 /*
2  This file is part of GNUnet.
3  Copyright (C) 2012, 2017, 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_cadet_service.h"
30 #include "cadet.h"
31 
32 #define STREAM_BUFFER_SIZE 1024 // Pakets
33 
37 static int request_peers;
38 
42 static char *peer_id;
43 
47 static int request_tunnels;
48 
52 static char *conn_id;
53 
57 static char *channel_id;
58 
62 static char *listen_port;
63 
67 static int echo;
68 
73 
78 
82 static char *target_id;
83 
87 static char *target_port = "default";
88 
92 static struct GNUNET_CADET_Handle *mh;
93 
97 static const struct GNUNET_CONFIGURATION_Handle *my_cfg;
98 
102 static struct GNUNET_CADET_GetPath *gpo;
103 
108 
113 
117 static struct GNUNET_CADET_Channel *ch;
118 
122 static struct GNUNET_HashCode porthash;
123 
128 
133 
137 static struct GNUNET_SCHEDULER_Task *job;
138 
139 static unsigned int sent_pkt;
140 
141 
145 static void
146 listen_stdio(void);
147 
148 
156 static const char *
157 enc_2s(uint16_t status)
158 {
159  switch (status)
160  {
161  case 0:
162  return "NULL ";
163 
164  case 1:
165  return "KSENT";
166 
167  case 2:
168  return "KRECV";
169 
170  case 3:
171  return "READY";
172 
173  default:
174  return "";
175  }
176 }
177 
178 
186 static const char *
187 conn_2s(uint16_t status)
188 {
189  switch (status)
190  {
191  case 0:
192  return "NEW ";
193 
194  case 1:
195  return "SRCH ";
196 
197  case 2:
198  return "WAIT ";
199 
200  case 3:
201  return "READY";
202 
203  case 4:
204  return "SHUTD";
205 
206  default:
207  return "";
208  }
209 }
210 
211 
217 static void
218 shutdown_task(void *cls)
219 {
220  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Shutdown\n");
221  if (NULL != lp)
222  {
224  lp = NULL;
225  }
226  if (NULL != ch)
227  {
229  ch = NULL;
230  }
231  if (NULL != gpo)
232  {
234  gpo = NULL;
235  }
236  if (NULL != plo)
237  {
239  plo = NULL;
240  }
241  if (NULL != tio)
242  {
244  tio = NULL;
245  }
246  if (NULL != mh)
247  {
249  mh = NULL;
250  }
251  if (NULL != rd_task)
252  {
253  GNUNET_SCHEDULER_cancel(rd_task);
254  rd_task = NULL;
255  }
256  if (NULL != echo_task)
257  {
258  GNUNET_SCHEDULER_cancel(echo_task);
259  echo_task = NULL;
260  }
261  if (NULL != job)
262  {
264  job = NULL;
265  }
266 }
267 
268 void
269 mq_cb(void *cls)
270 {
271  listen_stdio();
272 }
273 
274 
280 static void
281 read_stdio(void *cls)
282 {
283  struct GNUNET_MQ_Envelope *env;
284  struct GNUNET_MessageHeader *msg;
285  char buf[60000];
286  ssize_t data_size;
287 
288  rd_task = NULL;
289  data_size = read(0, buf, 60000);
290  if (data_size < 1)
291  {
293  "read() returned %s\n",
294  strerror(errno));
296  return;
297  }
299  "Read %u bytes from stdio\n",
300  (unsigned int)data_size);
301  env = GNUNET_MQ_msg_extra(msg, data_size, GNUNET_MESSAGE_TYPE_CADET_CLI);
302  GNUNET_memcpy(&msg[1], buf, data_size);
304 
305  sent_pkt++;
306 
307  if (GNUNET_NO == echo)
308  {
309  // Use MQ's notification if too much data of stdin is pooring in too fast.
311  {
312  GNUNET_MQ_notify_sent(env, mq_cb, cls);
313  sent_pkt = 0;
314  }
315  else
316  {
317  listen_stdio();
318  }
319  }
320  else
321  {
323  }
324 }
325 
326 
330 static void
332 {
333  struct GNUNET_NETWORK_FDSet *rs;
334 
335  /* FIXME: why use 'rs' here, seems overly complicated... */
337  GNUNET_NETWORK_fdset_set_native(rs, 0); /* STDIN */
340  rs,
341  NULL,
342  &read_stdio,
343  NULL);
345 }
346 
347 
357 static void
358 channel_ended(void *cls, const struct GNUNET_CADET_Channel *channel)
359 {
360  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Channel ended!\n");
361  GNUNET_assert(channel == ch);
362  ch = NULL;
364 }
365 
366 
381 static void *
383  struct GNUNET_CADET_Channel *channel,
384  const struct GNUNET_PeerIdentity *initiator)
385 {
387  "Incoming connection from %s\n",
388  GNUNET_i2s_full(initiator));
389  GNUNET_assert(NULL == ch);
390  GNUNET_assert(NULL != lp);
392  lp = NULL;
393  ch = channel;
394  if (GNUNET_NO == echo)
395  listen_stdio();
396  return channel;
397 }
398 
399 
405 static void
406 send_echo(void *cls)
407 {
408  struct GNUNET_MQ_Envelope *env;
409  struct GNUNET_MessageHeader *msg;
410 
411  echo_task = NULL;
412  if (NULL == ch)
413  return;
416 }
417 
418 
427 static int
428 check_data(void *cls, const struct GNUNET_MessageHeader *message)
429 {
430  return GNUNET_OK; /* all is well-formed */
431 }
432 
433 
444 static void
445 handle_data(void *cls, const struct GNUNET_MessageHeader *message)
446 {
447  size_t payload_size = ntohs(message->size) - sizeof(*message);
448  uint16_t len;
449  ssize_t done;
450  uint16_t off;
451  const char *buf;
452 
454  if (GNUNET_YES == echo)
455  {
456  if (NULL != listen_port)
457  {
458  struct GNUNET_MQ_Envelope *env;
459  struct GNUNET_MessageHeader *msg;
460 
461  env =
463  GNUNET_memcpy(&msg[1], &message[1], payload_size);
465  return;
466  }
467  else
468  {
469  struct GNUNET_TIME_Relative latency;
470 
474  "time: %s\n",
477  &send_echo,
478  NULL);
479  }
480  }
481 
482  len = ntohs(message->size) - sizeof(*message);
483  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Got %u bytes\n", len);
484  buf = (const char *)&message[1];
485  off = 0;
486  while (off < len)
487  {
488  done = write(1, &buf[off], len - off);
489  if (done <= 0)
490  {
491  if (-1 == done)
494  return;
495  }
496  off += done;
497  }
498 }
499 
500 
510 static void
511 peers_callback(void *cls, const struct GNUNET_CADET_PeerListEntry *ple)
512 {
513  if (NULL == ple)
514  {
515  plo = NULL;
517  return;
518  }
519  fprintf(stdout,
520  "%s tunnel: %c, paths: %u\n",
521  GNUNET_i2s_full(&ple->peer),
522  ple->have_tunnel ? 'Y' : 'N',
523  ple->n_paths);
524 }
525 
526 
534 static void
535 path_callback(void *cls, const struct GNUNET_CADET_PeerPathDetail *ppd)
536 {
537  if (NULL == ppd)
538  {
539  gpo = NULL;
541  return;
542  }
543  fprintf(stdout, "Path of length %u: ", ppd->path_length);
544  for (unsigned int i = 0; i < ppd->path_length; i++)
545  fprintf(stdout,
546  (i == ppd->target_offset) ? "*%s* " : "%s ",
547  GNUNET_i2s(&ppd->path[i]));
548  fprintf(stdout, "\n");
549 }
550 
551 
558 static void
559 tunnels_callback(void *cls, const struct GNUNET_CADET_TunnelDetails *td)
560 {
561  if (NULL == td)
562  {
563  tio = NULL;
565  return;
566  }
567  fprintf(stdout,
568  "%s [ENC: %s, CON: %s] CHs: %u, CONNs: %u\n",
569  GNUNET_i2s_full(&td->peer),
570  enc_2s(td->estate),
571  conn_2s(td->cstate),
572  td->channels,
573  td->connections);
574 }
575 
576 
582 static void
583 get_peers(void *cls)
584 {
585  job = NULL;
586  plo = GNUNET_CADET_list_peers(my_cfg, &peers_callback, NULL);
587 }
588 
589 
595 static void
596 show_peer(void *cls)
597 {
598  struct GNUNET_PeerIdentity pid;
599 
600  job = NULL;
602  strlen(peer_id),
603  &pid.public_key))
604  {
605  fprintf(stderr, _("Invalid peer ID `%s'\n"), peer_id);
607  return;
608  }
609  gpo = GNUNET_CADET_get_path(my_cfg, &pid, &path_callback, NULL);
610 }
611 
612 
618 static void
619 get_tunnels(void *cls)
620 {
621  job = NULL;
622  tio = GNUNET_CADET_list_tunnels(my_cfg, &tunnels_callback, NULL);
623 }
624 
625 
631 static void
632 show_channel(void *cls)
633 {
634  job = NULL;
635  GNUNET_break(0);
636 }
637 
638 
644 static void
645 show_connection(void *cls)
646 {
647  job = NULL;
648  GNUNET_break(0);
649 }
650 
651 
660 static void
661 run(void *cls,
662  char *const *args,
663  const char *cfgfile,
664  const struct GNUNET_CONFIGURATION_Handle *cfg)
665 {
666  struct GNUNET_MQ_MessageHandler handlers[] =
669  struct GNUNET_MessageHeader,
670  NULL),
672 
673  /* FIXME add option to monitor apps */
674  my_cfg = cfg;
675  target_id = args[0];
676  if (target_id && args[1])
677  target_port = args[1];
678 
679  if ((0 != (request_peers | request_tunnels) || NULL != conn_id ||
680  NULL != channel_id) &&
681  target_id != NULL)
682  {
683  fprintf(stderr,
684  _("Extra arguments are not applicable "
685  "in combination with this option.\n"));
686  return;
687  }
688 
689  if (NULL != peer_id)
690  {
691  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Show peer\n");
692  job = GNUNET_SCHEDULER_add_now(&show_peer, NULL);
693  }
694  else if (NULL != channel_id)
695  {
696  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Show channel\n");
698  }
699  else if (NULL != conn_id)
700  {
701  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Show connection\n");
703  }
704  else if (GNUNET_YES == request_peers)
705  {
706  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Show all peers\n");
707  job = GNUNET_SCHEDULER_add_now(&get_peers, NULL);
708  }
709  else if (GNUNET_YES == request_tunnels)
710  {
711  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Show all tunnels\n");
713  }
714 
715  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Connecting to CADET service\n");
716  mh = GNUNET_CADET_connect(cfg);
718  if (NULL == mh)
719  {
721  return;
722  }
723  if (NULL != listen_port)
724  {
725  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Opening CADET listen port\n");
727  lp = GNUNET_CADET_open_port(mh,
728  &porthash,
730  NULL,
731  NULL /* window changes */,
732  &channel_ended,
733  handlers);
734  }
735  if (NULL != target_id)
736  {
737  struct GNUNET_PeerIdentity pid;
738 
739  if (GNUNET_OK !=
741  strlen(target_id),
742  &pid.public_key))
743  {
745  _("Invalid target `%s'\n"),
746  target_id);
748  return;
749  }
751  "Connecting to `%s:%s'\n",
752  target_id,
753  target_port);
756  NULL,
757  &pid,
758  &porthash,
759  NULL /* window changes */,
760  &channel_ended,
761  handlers);
762  if (GNUNET_YES == echo)
763  {
764  echo_task = GNUNET_SCHEDULER_add_now(&send_echo, NULL);
765  }
766  else
767  {
768  listen_stdio();
769  }
770  }
771 
772  if ((NULL == lp) && (NULL == job) && (NULL == ch))
773  {
774  GNUNET_log(GNUNET_ERROR_TYPE_MESSAGE, _("No action requested\n"));
776  return;
777  }
778 }
779 
780 
788 int
789 main(int argc, char *const *argv)
790 {
791  int res;
792  const char helpstr[] =
793  "Create tunnels and retrieve info about CADET's status.";
794  struct GNUNET_GETOPT_CommandLineOption options[] =
795  { /* I would use the terminology 'circuit' here... --lynX */
797  'C',
798  "connection",
799  "CONNECTION_ID",
800  gettext_noop("Provide information about a particular connection"),
801  &conn_id),
803  "echo",
804  gettext_noop("Activate echo mode"),
805  &echo),
807  'o',
808  "open-port",
809  "SHARED_SECRET",
810  gettext_noop(
811  "Listen for connections using a shared secret among sender and recipient"),
812  &listen_port),
814  "peer",
815  "PEER_ID",
816  gettext_noop(
817  "Provide information about a patricular peer"),
818  &peer_id),
820  "peers",
821  gettext_noop(
822  "Provide information about all peers"),
823  &request_peers),
825  "tunnels",
826  gettext_noop(
827  "Provide information about all tunnels"),
828  &request_tunnels),
830  };
831 
832  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv))
833  return 2;
834 
835  res = GNUNET_PROGRAM_run(argc,
836  argv,
837  "gnunet-cadet (OPTIONS | PEER_ID SHARED_SECRET)",
838  gettext_noop(helpstr),
839  options,
840  &run,
841  NULL);
842 
843  GNUNET_free((void *)argv);
844 
845  if (GNUNET_OK == res)
846  return 0;
847  return 1;
848 }
849 
850 /* end of gnunet-cadet.c */
static void read_stdio(void *cls)
Task run in stdio mode, after some data is available at stdin.
Definition: gnunet-cadet.c:281
static char * listen_port
Port to listen on (-o).
Definition: gnunet-cadet.c:62
static struct GNUNET_CADET_Channel * ch
Channel handle.
Definition: gnunet-cadet.c:117
void GNUNET_CADET_disconnect(struct GNUNET_CADET_Handle *handle)
Disconnect from the cadet service.
Definition: cadet_api.c:838
static void done()
static struct GNUNET_CADET_ListTunnels * tio
Active tunnel listing operation.
Definition: gnunet-cadet.c:112
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
static void handle_data(void *cls, const struct GNUNET_MessageHeader *message)
Function called whenever a message is received.
Definition: gnunet-cadet.c:445
void * GNUNET_CADET_list_tunnels_cancel(struct GNUNET_CADET_ListTunnels *lt)
Cancel a monitor request.
Opaque handle to the service.
Definition: cadet_api.c:38
static void shutdown_task(void *cls)
Task to shut down this application.
Definition: gnunet-cadet.c:218
void GNUNET_NETWORK_fdset_set_native(struct GNUNET_NETWORK_FDSet *to, int nfd)
Set a native fd in a set.
Definition: network.c:1125
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
int GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1439
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static void get_tunnels(void *cls)
Call CADET&#39;s meta API, get all tunnels known to a peer.
Definition: gnunet-cadet.c:619
static struct GNUNET_CADET_Handle * mh
Cadet handle.
Definition: gnunet-cadet.c:92
static int echo
Request echo service.
Definition: gnunet-cadet.c:67
#define GNUNET_TIME_UNIT_SECONDS
One second.
static int request_tunnels
Option -T.
Definition: gnunet-cadet.c:47
uint16_t cstate
What is our connectivity state?
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
static char * peer_id
Option –peer.
Definition: gnunet-cadet.c:42
#define GNUNET_NO
Definition: gnunet_common.h:78
const char * GNUNET_i2s_full(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
Opaque handle to a channel.
Definition: cadet_api.c:79
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
Definition of a command line option.
unsigned int path_length
Number of entries on the path.
#define GNUNET_MESSAGE_TYPE_CADET_CLI
Traffic (net-cat style) used by the Command Line Interface.
static const struct GNUNET_CONFIGURATION_Handle * my_cfg
Our configuration.
Definition: gnunet-cadet.c:97
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
struct GNUNET_CADET_PeersLister * GNUNET_CADET_list_peers(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_CADET_PeersCB callback, void *callback_cls)
Request information about peers known to the running cadet service.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:517
static int check_data(void *cls, const struct GNUNET_MessageHeader *message)
Check data message sanity.
Definition: gnunet-cadet.c:428
void * GNUNET_CADET_list_peers_cancel(struct GNUNET_CADET_PeersLister *pl)
Cancel a peer info request.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
struct GNUNET_CADET_Handle * GNUNET_CADET_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the MQ-based cadet service.
Definition: cadet_api.c:973
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_string(char shortName, const char *name, const char *argumentHelp, const char *description, char **str)
Allow user to specify a string.
struct GNUNET_CADET_Port * lp
Data structure for ongoing reception of incoming virtual circuits.
Definition: gnunet-cadet.c:127
#define GNUNET_TIME_UNIT_FOREVER_ABS
Constant used to specify "forever".
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
struct GNUNET_PeerIdentity peer
Target of the tunnel.
static struct GNUNET_TIME_Absolute echo_time
Time of last echo request.
Definition: gnunet-cadet.c:72
void GNUNET_NETWORK_fdset_destroy(struct GNUNET_NETWORK_FDSet *fds)
Releases the associated memory of an fd set.
Definition: network.c:1254
static void run(void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
Main function that will be run by the scheduler.
Definition: gnunet-cadet.c:661
static char * conn_id
Option –connection.
Definition: gnunet-cadet.c:52
#define GNUNET_log_strerror(level, cmd)
Log an error message at log-level &#39;level&#39; that indicates a failure of the command &#39;cmd&#39; with the mess...
Details about a tunnel managed by CADET.
static const char * enc_2s(uint16_t status)
Convert encryption status to human readable string.
Definition: gnunet-cadet.c:157
static void channel_ended(void *cls, const struct GNUNET_CADET_Channel *channel)
Function called whenever a channel is destroyed.
Definition: gnunet-cadet.c:358
#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_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1237
struct GNUNET_NETWORK_FDSet * GNUNET_NETWORK_fdset_create(void)
Creates an fd set.
Definition: network.c:1238
static void * channel_incoming(void *cls, struct GNUNET_CADET_Channel *channel, const struct GNUNET_PeerIdentity *initiator)
Method called whenever another peer has added us to a channel the other peer initiated.
Definition: gnunet-cadet.c:382
static char * target_port
Port to connect to.
Definition: gnunet-cadet.c:87
struct GNUNET_CADET_GetPath * GNUNET_CADET_get_path(const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_PeerIdentity *id, GNUNET_CADET_PathCB callback, void *callback_cls)
Request information about paths known to the running cadet peer.
struct GNUNET_CADET_Port * GNUNET_CADET_open_port(struct GNUNET_CADET_Handle *h, const struct GNUNET_HashCode *port, GNUNET_CADET_ConnectEventHandler connects, void *connects_cls, GNUNET_CADET_WindowSizeEventHandler window_changes, GNUNET_CADET_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Open a port to receive incomming MQ-based channels.
Definition: cadet_api.c:1007
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
static char * channel_id
Option –channel.
Definition: gnunet-cadet.c:57
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:44
static void peers_callback(void *cls, const struct GNUNET_CADET_PeerListEntry *ple)
Method called to retrieve information about all peers in CADET, called once per peer.
Definition: gnunet-cadet.c:511
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1264
#define STREAM_BUFFER_SIZE
Definition: gnunet-cadet.c:32
static struct GNUNET_HashCode porthash
HashCode of the given port string.
Definition: gnunet-cadet.c:122
const char * GNUNET_STRINGS_relative_time_to_string(struct GNUNET_TIME_Relative delta, int do_round)
Give relative time in human-readable fancy format.
Definition: strings.c:686
static void show_peer(void *cls)
Call CADET&#39;s monitor API, get info of one peer.
Definition: gnunet-cadet.c:596
collection of IO descriptors
uint16_t status
See PRISM_STATUS_*-constants.
static char buf[2048]
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_select(enum GNUNET_SCHEDULER_Priority prio, struct GNUNET_TIME_Relative delay, const struct GNUNET_NETWORK_FDSet *rs, const struct GNUNET_NETWORK_FDSet *ws, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when any of the specified file descriptor set...
Definition: scheduler.c:1784
uint32_t channels
How many channels use the tunnel.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
static void path_callback(void *cls, const struct GNUNET_CADET_PeerPathDetail *ppd)
Method called to retrieve information about paths to a specific peer known to the service...
Definition: gnunet-cadet.c:535
static void get_peers(void *cls)
Call CADET&#39;s meta API, get all peers known to a peer.
Definition: gnunet-cadet.c:583
static void show_channel(void *cls)
Call CADET&#39;s monitor API, get info of one channel.
Definition: gnunet-cadet.c:632
void * GNUNET_CADET_get_path_cancel(struct GNUNET_CADET_GetPath *gp)
Cancel gp operation.
struct GNUNET_PeerIdentity peer
Which peer is the information about?
static struct GNUNET_CADET_PeersLister * plo
Active peer listing operation.
Definition: gnunet-cadet.c:107
A 512-bit hashcode.
unsigned int target_offset
Offset of the target peer on the path.
Message handler for a specific message type.
static int res
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:104
Operation handle.
static struct GNUNET_SCHEDULER_Task * echo_task
Task for next echo request.
Definition: gnunet-cadet.c:77
int have_tunnel
Do we have a tunnel to this peer?
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static struct GNUNET_SCHEDULER_Task * rd_task
Task for reading from stdin.
Definition: gnunet-cadet.c:132
static void send_echo(void *cls)
Send an echo request to the remote peer.
Definition: gnunet-cadet.c:406
const struct GNUNET_PeerIdentity * path
Array of PEER_IDs representing all paths to reach the peer.
static struct GNUNET_SCHEDULER_Task * job
Task for main job.
Definition: gnunet-cadet.c:137
uint16_t estate
What is our encryption state?
struct GNUNET_CADET_ListTunnels * GNUNET_CADET_list_tunnels(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_CADET_TunnelsCB callback, void *callback_cls)
Request information about tunnels of the running cadet peer.
int GNUNET_CRYPTO_eddsa_public_key_from_string(const char *enc, size_t enclen, struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Convert a string representing a public key to a public key.
Definition: crypto_ecc.c:501
The identity of the host (wraps the signing key of the peer).
Detailed information we return per peer.
void GNUNET_CADET_receive_done(struct GNUNET_CADET_Channel *channel)
Send an ack on the channel to confirm the processing of a message.
Definition: cadet_api.c:951
struct GNUNET_CADET_Channel * GNUNET_CADET_channel_create(struct GNUNET_CADET_Handle *h, void *channel_cls, const struct GNUNET_PeerIdentity *destination, const struct GNUNET_HashCode *port, GNUNET_CADET_WindowSizeEventHandler window_changes, GNUNET_CADET_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Create a new channel towards a remote peer.
Definition: cadet_api.c:1065
void mq_cb(void *cls)
Definition: gnunet-cadet.c:269
static void listen_stdio(void)
Wait for input on STDIO and send it out over the ch.
Definition: gnunet-cadet.c:331
configuration data
Definition: configuration.c:83
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:373
static unsigned int sent_pkt
Definition: gnunet-cadet.c:139
Information we return per peer.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_flag(char shortName, const char *name, const char *description, int *val)
Allow user to specify a flag (which internally means setting an integer to 1/GNUNET_YES/GNUNET_OK.
int main(int argc, char *const *argv)
The main function to obtain peer information.
Definition: gnunet-cadet.c:789
static const char * conn_2s(uint16_t status)
Convert connection status to human readable string.
Definition: gnunet-cadet.c:187
#define GNUNET_log(kind,...)
Entry in list of pending tasks.
Definition: scheduler.c:131
Opaque handle to a port.
Definition: cadet_api.c:143
static int request_peers
Option -P.
Definition: gnunet-cadet.c:37
unsigned int n_paths
Number of disjoint known paths to peer.
uint32_t connections
How many connections support the tunnel.
int GNUNET_PROGRAM_run(int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls)
Run a standard GNUnet command startup sequence (initialize loggers and configuration, parse options).
Definition: program.c:367
static char * target_id
Peer to connect to.
Definition: gnunet-cadet.c:82
Header for all communications.
static struct GNUNET_CADET_GetPath * gpo
Active get path operation.
Definition: gnunet-cadet.c:102
void GNUNET_CADET_close_port(struct GNUNET_CADET_Port *p)
Close a port opened with GNUNET_CADET_open_port().
Definition: cadet_api.c:871
Time for absolute times used by GNUnet, in microseconds.
#define GNUNET_YES
Definition: gnunet_common.h:77
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
Run with the default priority (normal P2P operations).
uint32_t data
The data value.
static void tunnels_callback(void *cls, const struct GNUNET_CADET_TunnelDetails *td)
Method called to retrieve information about all tunnels in CADET.
Definition: gnunet-cadet.c:559
static size_t data_size
Number of bytes in data.
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:900
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
static void show_connection(void *cls)
Call CADET&#39;s monitor API, get info of one connection.
Definition: gnunet-cadet.c:645
#define GNUNET_free(ptr)
Wrapper around free.
Time for relative time used by GNUnet, in microseconds.
struct GNUNET_CRYPTO_EddsaPublicKey public_key
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
#define gettext_noop(String)
Definition: gettext.h:69
struct GNUNET_MQ_Handle * GNUNET_CADET_get_mq(const struct GNUNET_CADET_Channel *channel)
Obtain the message queue for a connected peer.
Definition: cadet_api.c:1116
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:956