gnunet-cadet.c

Go to the documentation of this file.

/*
     This file is part of GNUnet.
     Copyright (C) 2012, 2017, 2019 GNUnet e.V.
 
     GNUnet is free software: you can redistribute it and/or modify it
     under the terms of the GNU Affero General Public License as published
     by the Free Software Foundation, either version 3 of the License,
     or (at your option) any later version.
 
     GNUnet is distributed in the hope that it will be useful, but
     WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Affero General Public License for more details.
 
     You should have received a copy of the GNU Affero General Public License
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
     SPDX-License-Identifier: AGPL3.0-or-later
 */
 
#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_cadet_service.h"
#include "../../service/cadet/cadet.h" // FIXME Smell: this should not be shared like this.
 
#define STREAM_BUFFER_SIZE 1024 // Packets
 
static int request_peers;
 
static char *peer_id;
 
static int request_tunnels;
 
static char *conn_id;
 
static char *channel_id;
 
static char *listen_port;
 
static int echo;
 
static struct GNUNET_TIME_Absolute echo_time;
 
static struct GNUNET_SCHEDULER_Task *echo_task;
 
static char *target_id;
 
static const char *target_port = "default";
 
static struct GNUNET_CADET_Handle *mh;
 
static const struct GNUNET_CONFIGURATION_Handle *my_cfg;
 
static struct GNUNET_CADET_GetPath *gpo;
 
static struct GNUNET_CADET_PeersLister *plo;
 
static struct GNUNET_CADET_ListTunnels *tio;
 
static struct GNUNET_CADET_Channel *ch;
 
static struct GNUNET_HashCode porthash;
 
struct GNUNET_CADET_Port *lp;
 
static struct GNUNET_SCHEDULER_Task *rd_task;
 
static struct GNUNET_SCHEDULER_Task *job;
 
static unsigned int sent_pkt;
 
 
static void
listen_stdio (void);
 
 
static const char *
enc_2s (uint16_t status)
{
  switch (status)
  {
  case 0:
    return "NULL ";
 
  case 1:
    return "KSENT";
 
  case 2:
    return "KRECV";
 
  case 3:
    return "READY";
 
  default:
    return "";
  }
}
 
 
static const char *
conn_2s (uint16_t status)
{
  switch (status)
  {
  case 0:
    return "NEW  ";
 
  case 1:
    return "SRCH ";
 
  case 2:
    return "WAIT ";
 
  case 3:
    return "READY";
 
  case 4:
    return "SHUTD";
 
  default:
    return "";
  }
}
 
 
static void
shutdown_task (void *cls)
{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutdown\n");
  if (NULL != lp)
  {
    GNUNET_CADET_close_port (lp);
    lp = NULL;
  }
  if (NULL != ch)
  {
    GNUNET_CADET_channel_destroy (ch);
    ch = NULL;
  }
  if (NULL != gpo)
  {
    GNUNET_CADET_get_path_cancel (gpo);
    gpo = NULL;
  }
  if (NULL != plo)
  {
    GNUNET_CADET_list_peers_cancel (plo);
    plo = NULL;
  }
  if (NULL != tio)
  {
    GNUNET_CADET_list_tunnels_cancel (tio);
    tio = NULL;
  }
  if (NULL != mh)
  {
    GNUNET_CADET_disconnect (mh);
    mh = NULL;
  }
  if (NULL != rd_task)
  {
    GNUNET_SCHEDULER_cancel (rd_task);
    rd_task = NULL;
  }
  if (NULL != echo_task)
  {
    GNUNET_SCHEDULER_cancel (echo_task);
    echo_task = NULL;
  }
  if (NULL != job)
  {
    GNUNET_SCHEDULER_cancel (job);
    job = NULL;
  }
}
 
 
static void
mq_cb (void *cls)
{
  listen_stdio ();
}
 
 
static void
read_stdio (void *cls)
{
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_MessageHeader *msg;
  char buf[60000];
  ssize_t data_size;
 
  rd_task = NULL;
  data_size = read (0, buf, 60000);
  if (data_size < 1)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "read() returned  %s\n",
                strerror (errno));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Read %u bytes from stdio\n",
              (unsigned int) data_size);
  env = GNUNET_MQ_msg_extra (msg, data_size, GNUNET_MESSAGE_TYPE_CADET_CLI);
  GNUNET_memcpy (&msg[1], buf, data_size);
  GNUNET_MQ_send (GNUNET_CADET_get_mq (ch), env);
 
  sent_pkt++;
 
  if (GNUNET_NO == echo)
  {
    // Use MQ's notification if too much data of stdin is pooring in too fast.
    if (STREAM_BUFFER_SIZE < sent_pkt)
    {
      GNUNET_MQ_notify_sent (env, mq_cb, cls);
      sent_pkt = 0;
    }
    else
    {
      listen_stdio ();
    }
  }
  else
  {
    echo_time = GNUNET_TIME_absolute_get ();
  }
}
 
 
static void
listen_stdio ()
{
  struct GNUNET_NETWORK_FDSet *rs;
 
  /* FIXME: why use 'rs' here, seems overly complicated... */
  rs = GNUNET_NETWORK_fdset_create ();
  GNUNET_NETWORK_fdset_set_native (rs, 0);  /* STDIN */
  rd_task = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
                                         GNUNET_TIME_UNIT_FOREVER_REL,
                                         rs,
                                         NULL,
                                         &read_stdio,
                                         NULL);
  GNUNET_NETWORK_fdset_destroy (rs);
}
 
 
static void
channel_ended (void *cls, const struct GNUNET_CADET_Channel *channel)
{
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Channel ended!\n");
  GNUNET_assert (channel == ch);
  ch = NULL;
  GNUNET_SCHEDULER_shutdown ();
}
 
 
static void *
channel_incoming (void *cls,
                  struct GNUNET_CADET_Channel *channel,
                  const struct GNUNET_PeerIdentity *initiator)
{
  GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
              "Incoming connection from %s\n",
              GNUNET_i2s_full (initiator));
  GNUNET_assert (NULL == ch);
  GNUNET_assert (NULL != lp);
  GNUNET_CADET_close_port (lp);
  lp = NULL;
  ch = channel;
  if (GNUNET_NO == echo)
    listen_stdio ();
  return channel;
}
 
 
static void
send_echo (void *cls)
{
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_MessageHeader *msg;
 
  echo_task = NULL;
  if (NULL == ch)
    return;
  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_CADET_CLI);
  GNUNET_MQ_send (GNUNET_CADET_get_mq (ch), env);
}
 
 
static int
check_data (void *cls, const struct GNUNET_MessageHeader *message)
{
  return GNUNET_OK; /* all is well-formed */
}
 
 
static void
handle_data (void *cls, const struct GNUNET_MessageHeader *message)
{
  size_t payload_size = ntohs (message->size) - sizeof(*message);
  uint16_t len;
  ssize_t done;
  uint16_t off;
  const char *buf;
 
  GNUNET_CADET_receive_done (ch);
  if (GNUNET_YES == echo)
  {
    if (NULL != listen_port)
    {
      struct GNUNET_MQ_Envelope *env;
      struct GNUNET_MessageHeader *msg;
 
      env =
        GNUNET_MQ_msg_extra (msg, payload_size, GNUNET_MESSAGE_TYPE_CADET_CLI);
      GNUNET_memcpy (&msg[1], &message[1], payload_size);
      GNUNET_MQ_send (GNUNET_CADET_get_mq (ch), env);
      return;
    }
    else
    {
      struct GNUNET_TIME_Relative latency;
 
      latency = GNUNET_TIME_absolute_get_duration (echo_time);
      echo_time = GNUNET_TIME_UNIT_FOREVER_ABS;
      GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
                  "time: %s\n",
                  GNUNET_STRINGS_relative_time_to_string (latency, GNUNET_NO));
      echo_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
                                                &send_echo,
                                                NULL);
    }
  }
 
  len = ntohs (message->size) - sizeof(*message);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got %u bytes\n", len);
  buf = (const char *) &message[1];
  off = 0;
  while (off < len)
  {
    done = write (1, &buf[off], len - off);
    if (done <= 0)
    {
      if (-1 == done)
        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "write");
      GNUNET_SCHEDULER_shutdown ();
      return;
    }
    off += done;
  }
}
 
 
static void
peers_callback (void *cls, const struct GNUNET_CADET_PeerListEntry *ple)
{
  if (NULL == ple)
  {
    plo = NULL;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  fprintf (stdout,
           "%s tunnel: %c, paths: %u\n",
           GNUNET_i2s_full (&ple->peer),
           ple->have_tunnel ? 'Y' : 'N',
           ple->n_paths);
}
 
 
static void
path_callback (void *cls, const struct GNUNET_CADET_PeerPathDetail *ppd)
{
  if (NULL == ppd)
  {
    gpo = NULL;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  fprintf (stdout, "Path of length %u: ", ppd->path_length);
  for (unsigned int i = 0; i < ppd->path_length; i++)
    fprintf (stdout,
             (i == ppd->target_offset) ? "*%s* " : "%s ",
             GNUNET_i2s (&ppd->path[i]));
  fprintf (stdout, "\n");
}
 
 
static void
tunnels_callback (void *cls, const struct GNUNET_CADET_TunnelDetails *td)
{
  if (NULL == td)
  {
    tio = NULL;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  fprintf (stdout,
           "%s [ENC: %s, CON: %s] CHs: %u, CONNs: %u\n",
           GNUNET_i2s_full (&td->peer),
           enc_2s (td->estate),
           conn_2s (td->cstate),
           td->channels,
           td->connections);
}
 
 
static void
get_peers (void *cls)
{
  job = NULL;
  plo = GNUNET_CADET_list_peers (my_cfg, &peers_callback, NULL);
}
 
 
static void
show_peer (void *cls)
{
  struct GNUNET_PeerIdentity pid;
 
  job = NULL;
  if (GNUNET_OK != GNUNET_CRYPTO_eddsa_public_key_from_string (peer_id,
                                                               strlen (peer_id),
                                                               &pid.public_key))
  {
    fprintf (stderr, _ ("Invalid peer ID `%s'\n"), peer_id);
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  gpo = GNUNET_CADET_get_path (my_cfg, &pid, &path_callback, NULL);
}
 
 
static void
get_tunnels (void *cls)
{
  job = NULL;
  tio = GNUNET_CADET_list_tunnels (my_cfg, &tunnels_callback, NULL);
}
 
 
static void
show_channel (void *cls)
{
  job = NULL;
  GNUNET_break (0);
}
 
 
static void
show_connection (void *cls)
{
  job = NULL;
  GNUNET_break (0);
}
 
 
static void
run (void *cls,
     char *const *args,
     const char *cfgfile,
     const struct GNUNET_CONFIGURATION_Handle *cfg)
{
  struct GNUNET_MQ_MessageHandler handlers[] =
  { GNUNET_MQ_hd_var_size (data,
                           GNUNET_MESSAGE_TYPE_CADET_CLI,
                           struct GNUNET_MessageHeader,
                           NULL),
    GNUNET_MQ_handler_end () };
 
  /* FIXME add option to monitor apps */
  my_cfg = cfg;
  target_id = args[0];
  if (target_id && args[1])
    target_port = args[1];
 
  if (((0 != (request_peers | request_tunnels)) || (NULL != conn_id) ||
       (NULL != channel_id) ) &&
      (target_id != NULL) )
  {
    fprintf (stderr,
             _ ("Extra arguments are not applicable "
                "in combination with this option.\n"));
    return;
  }
 
  if (NULL != peer_id)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Show peer\n");
    job = GNUNET_SCHEDULER_add_now (&show_peer, NULL);
  }
  else if (NULL != channel_id)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Show channel\n");
    job = GNUNET_SCHEDULER_add_now (&show_channel, NULL);
  }
  else if (NULL != conn_id)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Show connection\n");
    job = GNUNET_SCHEDULER_add_now (&show_connection, NULL);
  }
  else if (GNUNET_YES == request_peers)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Show all peers\n");
    job = GNUNET_SCHEDULER_add_now (&get_peers, NULL);
  }
  else if (GNUNET_YES == request_tunnels)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Show all tunnels\n");
    job = GNUNET_SCHEDULER_add_now (&get_tunnels, NULL);
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Connecting to CADET service\n");
  mh = GNUNET_CADET_connect (cfg);
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
  if (NULL == mh)
  {
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if (NULL != listen_port)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Opening CADET listen port\n");
    GNUNET_CRYPTO_hash (listen_port, strlen (listen_port), &porthash);
    lp = GNUNET_CADET_open_port (mh,
                                 &porthash,
                                 &channel_incoming,
                                 NULL,
                                 NULL /* window changes */,
                                 &channel_ended,
                                 handlers);
  }
  if (NULL != target_id)
  {
    struct GNUNET_PeerIdentity pid;
 
    if (GNUNET_OK !=
        GNUNET_CRYPTO_eddsa_public_key_from_string (target_id,
                                                    strlen (target_id),
                                                    &pid.public_key))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
                  _ ("Invalid target `%s'\n"),
                  target_id);
      GNUNET_SCHEDULER_shutdown ();
      return;
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Connecting to `%s:%s'\n",
                target_id,
                target_port);
    GNUNET_CRYPTO_hash (target_port, strlen (target_port), &porthash);
    ch = GNUNET_CADET_channel_create (mh,
                                      NULL,
                                      &pid,
                                      &porthash,
                                      NULL /* window changes */,
                                      &channel_ended,
                                      handlers);
    if (GNUNET_YES == echo)
    {
      echo_task = GNUNET_SCHEDULER_add_now (&send_echo, NULL);
    }
    else
    {
      listen_stdio ();
    }
  }
 
  if ((NULL == lp) && (NULL == job) && (NULL == ch))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE, _ ("No action requested\n"));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
}
 
 
int
main (int argc, char *const *argv)
{
  int res;
  const char helpstr[] =
    "Create tunnels and retrieve info about CADET's status.";
  struct GNUNET_GETOPT_CommandLineOption options[] = {  /* I would use the terminology 'circuit' here...  --lynX */
    GNUNET_GETOPT_option_string (
      'C',
      "connection",
      "CONNECTION_ID",
      gettext_noop ("Provide information about a particular connection"),
      &conn_id),
    GNUNET_GETOPT_option_flag ('e',
                               "echo",
                               gettext_noop ("Activate echo mode"),
                               &echo),
    GNUNET_GETOPT_option_string (
      'o',
      "open-port",
      "SHARED_SECRET",
      gettext_noop (
        "Listen for connections using a shared secret among sender and recipient"),
      &listen_port),
    GNUNET_GETOPT_option_string ('p',
                                 "peer",
                                 "PEER_ID",
                                 gettext_noop (
                                   "Provide information about a patricular peer"),
                                 &peer_id),
    GNUNET_GETOPT_option_flag ('P',
                               "peers",
                               gettext_noop (
                                 "Provide information about all peers"),
                               &request_peers),
    GNUNET_GETOPT_option_flag ('T',
                               "tunnels",
                               gettext_noop (
                                 "Provide information about all tunnels"),
                               &request_tunnels),
    GNUNET_GETOPT_OPTION_END
  };
 
  res = GNUNET_PROGRAM_run (GNUNET_OS_project_data_gnunet (),
                            argc,
                            argv,
                            "gnunet-cadet (OPTIONS | PEER_ID SHARED_SECRET)",
                            gettext_noop (helpstr),
                            options,
                            &run,
                            NULL);
 
  if (GNUNET_OK == res)
    return 0;
  return 1;
}
 
 
/* end of gnunet-cadet.c */