src/mesh/gnunet-mesh.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2012 Christian Grothoff (and other contributing authors)
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      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      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18      Boston, MA 02111-1307, USA.
  19 */
  20
  21 /**
  22  * @file mesh/gnunet-mesh.c
  23  * @brief Print information about mesh tunnels and peers.
  24  * @author Bartlomiej Polot
  25  */
  26 #include "platform.h"
  27 #include "gnunet_configuration_lib.h"
  28 #include "gnunet_getopt_lib.h"
  29 #include "gnunet_mesh_service.h"
  30 #include "gnunet_program_lib.h"
  31
  32
  33 /**
  34  * Option -m.
  35  */
  36 static int monitor_connections;
  37
  38 /**
  39  * Option -t
  40  */
  41 static char *tunnel_id;
  42
  43 /**
  44  * Mesh handle.
  45  */
  46 static struct GNUNET_MESH_Handle *mh;
  47
  48 /**
  49  * Shutdown task handle.
  50  */
  51 GNUNET_SCHEDULER_TaskIdentifier sd;
  52
  53 /**
  54  * Task run in monitor mode when the user presses CTRL-C to abort.
  55  * Stops monitoring activity.
  56  *
  57  * @param cls Closure (unused).
  58  * @param tc scheduler context
  59  */
  60 static void
  61 shutdown_task (void *cls,
  62                const struct GNUNET_SCHEDULER_TaskContext *tc)
  63 {
  64   if (NULL != mh)
  65   {
  66     GNUNET_MESH_disconnect (mh);
  67         mh = NULL;
  68   }
  69 }
  70
  71
  72 /**
  73  * Method called to retrieve information about each tunnel the mesh peer
  74  * is aware of.
  75  *
  76  * @param cls Closure.
  77  * @param tunnel_number Tunnel number.
  78  * @param origin that started the tunnel (owner).
  79  * @param target other endpoint of the tunnel
  80  */
  81 static void
  82 tunnels_callback (void *cls,
  83                   uint32_t tunnel_number,
  84                   const struct GNUNET_PeerIdentity *origin,
  85                   const struct GNUNET_PeerIdentity *target)
  86 {
  87   fprintf (stdout, "Tunnel %s [%u]\n",
  88            GNUNET_i2s_full (origin), tunnel_number);
  89   fprintf (stdout, "\n");
  90 }
  91
  92
  93 /**
  94  * Method called to retrieve information about each tunnel the mesh peer
  95  * is aware of.
  96  *
  97  * @param cls Closure.
  98  * @param peer Peer in the tunnel's tree.
  99  * @param parent Parent of the current peer. All 0 when peer is root.
 100  *
 101  */
 102 static void
 103 tunnel_callback (void *cls,
 104                  const struct GNUNET_PeerIdentity *peer,
 105                  const struct GNUNET_PeerIdentity *parent)
 106 {
 107 }
 108
 109
 110 /**
 111  * Call MESH's monitor API, get all tunnels known to peer.
 112  *
 113  * @param cls Closure (unused).
 114  * @param tc TaskContext
 115  */
 116 static void
 117 get_tunnels (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 118 {
 119   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
 120   {
 121     return;
 122   }
 123   GNUNET_MESH_get_tunnels (mh, &tunnels_callback, NULL);
 124   if (GNUNET_YES != monitor_connections)
 125   {
 126     GNUNET_SCHEDULER_shutdown();
 127   }
 128 }
 129
 130 /**
 131  * Call MESH's monitor API, get info of one tunnel.
 132  *
 133  * @param cls Closure (unused).
 134  * @param tc TaskContext
 135  */
 136 static void
 137 show_tunnel (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 138 {
 139   struct GNUNET_PeerIdentity pid;
 140
 141   if (GNUNET_OK !=
 142       GNUNET_CRYPTO_hash_from_string (tunnel_id, &pid.hashPubKey))
 143   {
 144     GNUNET_SCHEDULER_shutdown();
 145     return;
 146   }
 147   GNUNET_MESH_show_tunnel (mh, &pid, 0, tunnel_callback, NULL);
 148 }
 149
 150
 151 /**
 152  * Main function that will be run by the scheduler.
 153  *
 154  * @param cls closure
 155  * @param args remaining command-line arguments
 156  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
 157  * @param cfg configuration
 158  */
 159 static void
 160 run (void *cls, char *const *args, const char *cfgfile,
 161      const struct GNUNET_CONFIGURATION_Handle *cfg)
 162 {
 163   static const struct GNUNET_MESH_MessageHandler handlers[] = {
 164     {NULL, 0, 0} /* FIXME add option to monitor msg types */
 165   };
 166   /* FIXME add option to monitor apps */
 167
 168   if (args[0] != NULL)
 169   {
 170     FPRINTF (stderr, _("Invalid command line argument `%s'\n"), args[0]);
 171     return;
 172   }
 173   mh = GNUNET_MESH_connect (cfg,
 174                             NULL, /* cls */
 175                             NULL, /* new tunnel */
 176                             NULL, /* cleaner */
 177                             handlers,
 178                             NULL);
 179   if (NULL == mh)
 180     GNUNET_SCHEDULER_add_now (shutdown_task, NULL);
 181   else
 182     sd = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
 183                                        shutdown_task, NULL);
 184
 185   if (NULL != tunnel_id)
 186     GNUNET_SCHEDULER_add_now (&show_tunnel, NULL);
 187   else
 188     GNUNET_SCHEDULER_add_now (&get_tunnels, NULL);
 189 }
 190
 191
 192 /**
 193  * The main function to obtain peer information.
 194  *
 195  * @param argc number of arguments from the command line
 196  * @param argv command line arguments
 197  * @return 0 ok, 1 on error
 198  */
 199 int
 200 main (int argc, char *const *argv)
 201 {
 202   int res;
 203   static const struct GNUNET_GETOPT_CommandLineOption options[] = {
 204     {'m', "monitor", NULL,
 205      gettext_noop ("provide information about all tunnels (continuously) NOT IMPLEMENTED"), /* FIXME */
 206      GNUNET_NO, &GNUNET_GETOPT_set_one, &monitor_connections},
 207     {'t', "tunnel", "OWNER_ID:TUNNEL_ID",
 208      gettext_noop ("provide information about a particular tunnel"),
 209      GNUNET_YES, &GNUNET_GETOPT_set_string, &tunnel_id},
 210     GNUNET_GETOPT_OPTION_END
 211   };
 212
 213   if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
 214     return 2;
 215
 216   res = GNUNET_PROGRAM_run (argc, argv, "gnunet-mesh",
 217                       gettext_noop
 218                       ("Print information about mesh tunnels and peers."),
 219                       options, &run, NULL);
 220
 221   GNUNET_free ((void *) argv);
 222
 223   if (GNUNET_OK == res)
 224     return 0;
 225   else
 226     return 1;
 227 }
 228
 229 /* end of gnunet-mesh.c */