GNUnet  0.11.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 
269 void
270 mq_cb (void *cls)
271 {
272  listen_stdio ();
273 }
274 
275 
281 static void
282 read_stdio (void *cls)
283 {
284  struct GNUNET_MQ_Envelope *env;
285  struct GNUNET_MessageHeader *msg;
286  char buf[60000];
287  ssize_t data_size;
288 
289  rd_task = NULL;
290  data_size = read (0, buf, 60000);
291  if (data_size < 1)
292  {
294  "read() returned %s\n",
295  strerror (errno));
297  return;
298  }
300  "Read %u bytes from stdio\n",
301  (unsigned int) data_size);
302  env = GNUNET_MQ_msg_extra (msg, data_size, GNUNET_MESSAGE_TYPE_CADET_CLI);
303  GNUNET_memcpy (&msg[1], buf, data_size);
305 
306  sent_pkt++;
307 
308  if (GNUNET_NO == echo)
309  {
310  // Use MQ's notification if too much data of stdin is pooring in too fast.
312  {
313  GNUNET_MQ_notify_sent (env, mq_cb, cls);
314  sent_pkt = 0;
315  }
316  else
317  {
318  listen_stdio ();
319  }
320  }
321  else
322  {
324  }
325 }
326 
327 
331 static void
333 {
334  struct GNUNET_NETWORK_FDSet *rs;
335 
336  /* FIXME: why use 'rs' here, seems overly complicated... */
338  GNUNET_NETWORK_fdset_set_native (rs, 0); /* STDIN */
341  rs,
342  NULL,
343  &read_stdio,
344  NULL);
346 }
347 
348 
358 static void
359 channel_ended (void *cls, const struct GNUNET_CADET_Channel *channel)
360 {
361  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Channel ended!\n");
362  GNUNET_assert (channel == ch);
363  ch = NULL;
365 }
366 
367 
382 static void *
383 channel_incoming (void *cls,
384  struct GNUNET_CADET_Channel *channel,
385  const struct GNUNET_PeerIdentity *initiator)
386 {
388  "Incoming connection from %s\n",
389  GNUNET_i2s_full (initiator));
390  GNUNET_assert (NULL == ch);
391  GNUNET_assert (NULL != lp);
393  lp = NULL;
394  ch = channel;
395  if (GNUNET_NO == echo)
396  listen_stdio ();
397  return channel;
398 }
399 
400 
406 static void
407 send_echo (void *cls)
408 {
409  struct GNUNET_MQ_Envelope *env;
410  struct GNUNET_MessageHeader *msg;
411 
412  echo_task = NULL;
413  if (NULL == ch)
414  return;
417 }
418 
419 
428 static int
429 check_data (void *cls, const struct GNUNET_MessageHeader *message)
430 {
431  return GNUNET_OK; /* all is well-formed */
432 }
433 
434 
445 static void
446 handle_data (void *cls, const struct GNUNET_MessageHeader *message)
447 {
448  size_t payload_size = ntohs (message->size) - sizeof(*message);
449  uint16_t len;
450  ssize_t done;
451  uint16_t off;
452  const char *buf;
453 
455  if (GNUNET_YES == echo)
456  {
457  if (NULL != listen_port)
458  {
459  struct GNUNET_MQ_Envelope *env;
460  struct GNUNET_MessageHeader *msg;
461 
462  env =
464  GNUNET_memcpy (&msg[1], &message[1], payload_size);
466  return;
467  }
468  else
469  {
470  struct GNUNET_TIME_Relative latency;
471 
475  "time: %s\n",
478  &send_echo,
479  NULL);
480  }
481  }
482 
483  len = ntohs (message->size) - sizeof(*message);
484  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got %u bytes\n", len);
485  buf = (const char *) &message[1];
486  off = 0;
487  while (off < len)
488  {
489  done = write (1, &buf[off], len - off);
490  if (done <= 0)
491  {
492  if (-1 == done)
495  return;
496  }
497  off += done;
498  }
499 }
500 
501 
511 static void
512 peers_callback (void *cls, const struct GNUNET_CADET_PeerListEntry *ple)
513 {
514  if (NULL == ple)
515  {
516  plo = NULL;
518  return;
519  }
520  fprintf (stdout,
521  "%s tunnel: %c, paths: %u\n",
522  GNUNET_i2s_full (&ple->peer),
523  ple->have_tunnel ? 'Y' : 'N',
524  ple->n_paths);
525 }
526 
527 
535 static void
536 path_callback (void *cls, const struct GNUNET_CADET_PeerPathDetail *ppd)
537 {
538  if (NULL == ppd)
539  {
540  gpo = NULL;
542  return;
543  }
544  fprintf (stdout, "Path of length %u: ", ppd->path_length);
545  for (unsigned int i = 0; i < ppd->path_length; i++)
546  fprintf (stdout,
547  (i == ppd->target_offset) ? "*%s* " : "%s ",
548  GNUNET_i2s (&ppd->path[i]));
549  fprintf (stdout, "\n");
550 }
551 
552 
559 static void
560 tunnels_callback (void *cls, const struct GNUNET_CADET_TunnelDetails *td)
561 {
562  if (NULL == td)
563  {
564  tio = NULL;
566  return;
567  }
568  fprintf (stdout,
569  "%s [ENC: %s, CON: %s] CHs: %u, CONNs: %u\n",
570  GNUNET_i2s_full (&td->peer),
571  enc_2s (td->estate),
572  conn_2s (td->cstate),
573  td->channels,
574  td->connections);
575 }
576 
577 
583 static void
584 get_peers (void *cls)
585 {
586  job = NULL;
587  plo = GNUNET_CADET_list_peers (my_cfg, &peers_callback, NULL);
588 }
589 
590 
596 static void
597 show_peer (void *cls)
598 {
599  struct GNUNET_PeerIdentity pid;
600 
601  job = NULL;
603  strlen (peer_id),
604  &pid.public_key))
605  {
606  fprintf (stderr, _ ("Invalid peer ID `%s'\n"), peer_id);
608  return;
609  }
610  gpo = GNUNET_CADET_get_path (my_cfg, &pid, &path_callback, NULL);
611 }
612 
613 
619 static void
620 get_tunnels (void *cls)
621 {
622  job = NULL;
623  tio = GNUNET_CADET_list_tunnels (my_cfg, &tunnels_callback, NULL);
624 }
625 
626 
632 static void
633 show_channel (void *cls)
634 {
635  job = NULL;
636  GNUNET_break (0);
637 }
638 
639 
645 static void
646 show_connection (void *cls)
647 {
648  job = NULL;
649  GNUNET_break (0);
650 }
651 
652 
661 static void
662 run (void *cls,
663  char *const *args,
664  const char *cfgfile,
665  const struct GNUNET_CONFIGURATION_Handle *cfg)
666 {
667  struct GNUNET_MQ_MessageHandler handlers[] =
670  struct GNUNET_MessageHeader,
671  NULL),
673 
674  /* FIXME add option to monitor apps */
675  my_cfg = cfg;
676  target_id = args[0];
677  if (target_id && args[1])
678  target_port = args[1];
679 
680  if (((0 != (request_peers | request_tunnels)) || (NULL != conn_id) ||
681  (NULL != channel_id) ) &&
682  (target_id != NULL) )
683  {
684  fprintf (stderr,
685  _ ("Extra arguments are not applicable "
686  "in combination with this option.\n"));
687  return;
688  }
689 
690  if (NULL != peer_id)
691  {
692  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Show peer\n");
693  job = GNUNET_SCHEDULER_add_now (&show_peer, NULL);
694  }
695  else if (NULL != channel_id)
696  {
697  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Show channel\n");
698  job = GNUNET_SCHEDULER_add_now (&show_channel, NULL);
699  }
700  else if (NULL != conn_id)
701  {
702  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Show connection\n");
704  }
705  else if (GNUNET_YES == request_peers)
706  {
707  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Show all peers\n");
708  job = GNUNET_SCHEDULER_add_now (&get_peers, NULL);
709  }
710  else if (GNUNET_YES == request_tunnels)
711  {
712  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Show all tunnels\n");
713  job = GNUNET_SCHEDULER_add_now (&get_tunnels, NULL);
714  }
715 
716  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting to CADET service\n");
717  mh = GNUNET_CADET_connect (cfg);
719  if (NULL == mh)
720  {
722  return;
723  }
724  if (NULL != listen_port)
725  {
726  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Opening CADET listen port\n");
728  lp = GNUNET_CADET_open_port (mh,
729  &porthash,
731  NULL,
732  NULL /* window changes */,
733  &channel_ended,
734  handlers);
735  }
736  if (NULL != target_id)
737  {
738  struct GNUNET_PeerIdentity pid;
739 
740  if (GNUNET_OK !=
742  strlen (target_id),
743  &pid.public_key))
744  {
746  _ ("Invalid target `%s'\n"),
747  target_id);
749  return;
750  }
752  "Connecting to `%s:%s'\n",
753  target_id,
754  target_port);
757  NULL,
758  &pid,
759  &porthash,
760  NULL /* window changes */,
761  &channel_ended,
762  handlers);
763  if (GNUNET_YES == echo)
764  {
765  echo_task = GNUNET_SCHEDULER_add_now (&send_echo, NULL);
766  }
767  else
768  {
769  listen_stdio ();
770  }
771  }
772 
773  if ((NULL == lp) && (NULL == job) && (NULL == ch))
774  {
775  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, _ ("No action requested\n"));
777  return;
778  }
779 }
780 
781 
789 int
790 main (int argc, char *const *argv)
791 {
792  int res;
793  const char helpstr[] =
794  "Create tunnels and retrieve info about CADET's status.";
795  struct GNUNET_GETOPT_CommandLineOption options[] = { /* 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 
851 /* 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:282
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:841
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:446
void * GNUNET_CADET_list_tunnels_cancel(struct GNUNET_CADET_ListTunnels *lt)
Cancel a monitor request.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
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:1137
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:1300
int GNUNET_STRINGS_get_utf8_args(int argc, char *const *argv, int *u8argc, char *const **u8argv)
Returns utf-8 encoded arguments.
Definition: strings.c:1438
static size_t data_size
Number of bytes in data.
Definition: gnunet-abd.c:187
#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:620
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:80
#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:526
static int check_data(void *cls, const struct GNUNET_MessageHeader *message)
Check data message sanity.
Definition: gnunet-cadet.c:429
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:976
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:1266
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:662
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:359
#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:1253
struct GNUNET_NETWORK_FDSet * GNUNET_NETWORK_fdset_create(void)
Creates an fd set.
Definition: network.c:1250
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:383
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:1010
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:774
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:48
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:512
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:1280
#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:687
static void show_peer(void *cls)
Call CADET&#39;s monitor API, get info of one peer.
Definition: gnunet-cadet.c:597
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:1810
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:536
static void get_peers(void *cls)
Call CADET&#39;s meta API, get all peers known to a peer.
Definition: gnunet-cadet.c:584
static void show_channel(void *cls)
Call CADET&#39;s monitor API, get info of one channel.
Definition: gnunet-cadet.c:633
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
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:407
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:499
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:954
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:1068
void mq_cb(void *cls)
Definition: gnunet-cadet.c:270
static void listen_stdio(void)
Wait for input on STDIO and send it out over the ch.
Definition: gnunet-cadet.c:332
configuration data
Definition: configuration.c:85
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:375
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:790
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:134
Opaque handle to a port.
Definition: cadet_api.c:145
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:874
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:353
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:560
void GNUNET_CADET_channel_destroy(struct GNUNET_CADET_Channel *channel)
Destroy an existing channel.
Definition: cadet_api.c:903
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:646
#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:1119
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966