src/hostlist/gnunet-daemon-hostlist.c

   1 /*
   2      This file is part of GNUnet.
   3      (C) 2007, 2008, 2009 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 hostlist/gnunet-daemon-hostlist.c
  23  * @brief code for bootstrapping via hostlist servers
  24  * @author Christian Grothoff
  25  */
  26
  27 #include <stdlib.h>
  28 #include "platform.h"
  29 #include "hostlist-client.h"
  30 #include "gnunet_core_service.h"
  31 #include "gnunet_getopt_lib.h"
  32 #include "gnunet_protocols.h"
  33 #include "gnunet_program_lib.h"
  34 #include "gnunet_statistics_service.h"
  35 #include "gnunet_strings_lib.h"
  36 #include "gnunet_time_lib.h"
  37 #include "gnunet_util_lib.h"
  38
  39 #if HAVE_MHD
  40
  41 #include "hostlist-server.h"
  42
  43 /**
  44  * Set if we are allowed to advertise our hostlist to others.
  45  */
  46 static int advertising;
  47
  48 /**
  49  * Set if the user wants us to run a hostlist server.
  50  */
  51 static int provide_hostlist;
  52
  53 /**
  54  * Handle to hostlist server's connect handler
  55  */
  56 static GNUNET_CORE_ConnectEventHandler server_ch;
  57
  58 /**
  59  * Handle to hostlist server's disconnect handler
  60  */
  61 static GNUNET_CORE_DisconnectEventHandler server_dh;
  62
  63 #endif
  64
  65 /**
  66  * Set if we are allowed to learn about peers by accessing
  67  * hostlist servers.
  68  */
  69 static int bootstrapping;
  70
  71 /**
  72  * Set if the user allows us to learn about new hostlists
  73  * from the network.
  74  */
  75 static int learning;
  76
  77 /**
  78  * Statistics handle.
  79  */
  80 static struct GNUNET_STATISTICS_Handle *stats;
  81
  82 /**
  83  * Handle to the core service (NULL until we've connected to it).
  84  */
  85 static struct GNUNET_CORE_Handle *core;
  86
  87 /**
  88  * Handle to the hostlist client's advertisement handler
  89  */
  90 static GNUNET_CORE_MessageCallback client_adv_handler;
  91
  92 /**
  93  * Handle to hostlist client's connect handler
  94  */
  95 static GNUNET_CORE_ConnectEventHandler client_ch;
  96
  97 /**
  98  * Handle to hostlist client's disconnect handler
  99  */
 100 static GNUNET_CORE_DisconnectEventHandler client_dh;
 101
 102 GNUNET_NETWORK_STRUCT_BEGIN
 103
 104 /**
 105  * A HOSTLIST_ADV message is used to exchange information about
 106  * hostlist advertisements.  This struct is always
 107  * followed by the actual url under which the hostlist can be obtained:
 108  *
 109  * 1) transport-name (0-terminated)
 110  * 2) address-length (uint32_t, network byte order; possibly
 111  *    unaligned!)
 112  * 3) address expiration (GNUNET_TIME_AbsoluteNBO); possibly
 113  *    unaligned!)
 114  * 4) address (address-length bytes; possibly unaligned!)
 115  */
 116 struct GNUNET_HOSTLIST_ADV_Message
 117 {
 118   /**
 119    * Type will be GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT.
 120    */
 121   struct GNUNET_MessageHeader header;
 122
 123   /**
 124    * Always zero (for alignment).
 125    */
 126   uint32_t reserved GNUNET_PACKED;
 127 };
 128 GNUNET_NETWORK_STRUCT_END
 129
 130 static struct GNUNET_PeerIdentity me;
 131
 132 static void
 133 core_init (void *cls, struct GNUNET_CORE_Handle *server,
 134            const struct GNUNET_PeerIdentity *my_identity)
 135 {
 136   me = *my_identity;
 137 }
 138
 139 /**
 140  * Core handler for p2p hostlist advertisements
 141  *
 142  * @param cls closure
 143  * @param peer identity of the sender
 144  * @param message advertisement message we got
 145  * @param atsi performance information
 146  * @param atsi_count number of records in 'atsi'
 147  * @return GNUNET_OK on success
 148  */
 149 static int
 150 advertisement_handler (void *cls, const struct GNUNET_PeerIdentity *peer,
 151                        const struct GNUNET_MessageHeader *message,
 152                        const struct GNUNET_ATS_Information *atsi,
 153                        unsigned int atsi_count)
 154 {
 155   GNUNET_assert (NULL != client_adv_handler);
 156   return (*client_adv_handler) (cls, peer, message, atsi, atsi_count);
 157 }
 158
 159
 160 /**
 161  * Method called whenever a given peer connects.  Wrapper to call both client's and server's functions
 162  *
 163  * @param cls closure
 164  * @param peer peer identity this notification is about
 165  * @param atsi performance data
 166  * @param atsi_count number of records in 'atsi'
 167  */
 168 static void
 169 connect_handler (void *cls, const struct GNUNET_PeerIdentity *peer,
 170                  const struct GNUNET_ATS_Information *atsi,
 171                  unsigned int atsi_count)
 172 {
 173   if (0 == memcmp (&me, peer, sizeof (struct GNUNET_PeerIdentity)))
 174     return;
 175   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 176               "A new peer connected, notifying client and server\n");
 177   if (NULL != client_ch)
 178     (*client_ch) (cls, peer, atsi, atsi_count);
 179 #if HAVE_MHD
 180   if (NULL != server_ch)
 181     (*server_ch) (cls, peer, atsi, atsi_count);
 182 #endif
 183 }
 184
 185 /**
 186  * Method called whenever a given peer disconnects. Wrapper to call both client's and server's functions
 187  *
 188  * @param cls closure
 189  * @param peer peer identity this notification is about
 190  */
 191 static void
 192 disconnect_handler (void *cls, const struct GNUNET_PeerIdentity *peer)
 193 {
 194   if (0 == memcmp (&me, peer, sizeof (struct GNUNET_PeerIdentity)))
 195     return;
 196   /* call hostlist client disconnect handler */
 197   if (NULL != client_dh)
 198     (*client_dh) (cls, peer);
 199 #if HAVE_MHD
 200   /* call hostlist server disconnect handler */
 201   if (NULL != server_dh)
 202     (*server_dh) (cls, peer);
 203 #endif
 204 }
 205
 206 /**
 207  * Last task run during shutdown.  Disconnects us from
 208  * the other services.
 209  */
 210 static void
 211 cleaning_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 212 {
 213   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Hostlist daemon is shutting down\n");
 214   if (core != NULL)
 215   {
 216     GNUNET_CORE_disconnect (core);
 217     core = NULL;
 218   }
 219   if (bootstrapping)
 220   {
 221     GNUNET_HOSTLIST_client_stop ();
 222   }
 223 #if HAVE_MHD
 224   if (provide_hostlist)
 225   {
 226     GNUNET_HOSTLIST_server_stop ();
 227   }
 228 #endif
 229   if (stats != NULL)
 230   {
 231     GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
 232     stats = NULL;
 233   }
 234 }
 235
 236
 237 /**
 238  * Main function that will be run.
 239  *
 240  * @param cls closure
 241  * @param args remaining command-line arguments
 242  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
 243  * @param cfg configuration
 244  */
 245 static void
 246 run (void *cls, char *const *args, const char *cfgfile,
 247      const struct GNUNET_CONFIGURATION_Handle *cfg)
 248 {
 249   static const struct GNUNET_CORE_MessageHandler learn_handlers[] = {
 250     {&advertisement_handler, GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT, 0},
 251     {NULL, 0, 0}
 252   };
 253   static const struct GNUNET_CORE_MessageHandler no_learn_handlers[] = {
 254     {NULL, 0, 0}
 255   };
 256   if ((!bootstrapping) && (!learning)
 257 #if HAVE_MHD
 258       && (!provide_hostlist)
 259 #endif
 260       )
 261   {
 262     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
 263                 _
 264                 ("None of the functions for the hostlist daemon were enabled.  I have no reason to run!\n"));
 265     return;
 266   }
 267
 268
 269
 270   stats = GNUNET_STATISTICS_create ("hostlist", cfg);
 271
 272   core =
 273       GNUNET_CORE_connect (cfg, 1, NULL, &core_init, &connect_handler,
 274                            &disconnect_handler, NULL, GNUNET_NO, NULL,
 275                            GNUNET_NO,
 276                            learning ? learn_handlers : no_learn_handlers);
 277
 278   if (bootstrapping)
 279   {
 280     GNUNET_HOSTLIST_client_start (cfg, stats, &client_ch, &client_dh,
 281                                   &client_adv_handler, learning);
 282   }
 283
 284 #if HAVE_MHD
 285   if (provide_hostlist)
 286   {
 287     GNUNET_HOSTLIST_server_start (cfg, stats, core, &server_ch, &server_dh,
 288                                   advertising);
 289   }
 290 #endif
 291   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &cleaning_task,
 292                                 NULL);
 293
 294   if (NULL == core)
 295   {
 296     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
 297                 _("Failed to connect to `%s' service.\n"), "core");
 298     GNUNET_SCHEDULER_shutdown ();
 299     return;
 300   }
 301 }
 302
 303
 304 /**
 305  * The main function for the hostlist daemon.
 306  *
 307  * @param argc number of arguments from the command line
 308  * @param argv command line arguments
 309  * @return 0 ok, 1 on error
 310  */
 311 int
 312 main (int argc, char *const *argv)
 313 {
 314   static const struct GNUNET_GETOPT_CommandLineOption options[] = {
 315 #if HAVE_MHD
 316     {'a', "advertise", NULL,
 317      gettext_noop ("advertise our hostlist to other peers"),
 318      GNUNET_NO, &GNUNET_GETOPT_set_one, &advertising},
 319 #endif
 320     {'b', "bootstrap", NULL,
 321      gettext_noop
 322      ("bootstrap using hostlists (it is highly recommended that you always use this option)"),
 323      GNUNET_NO, &GNUNET_GETOPT_set_one, &bootstrapping},
 324     {'e', "enable-learning", NULL,
 325      gettext_noop ("enable learning about hostlist servers from other peers"),
 326      GNUNET_NO, &GNUNET_GETOPT_set_one, &learning},
 327 #if HAVE_MHD
 328     {'p', "provide-hostlist", NULL,
 329      gettext_noop ("provide a hostlist server"),
 330      GNUNET_NO, &GNUNET_GETOPT_set_one, &provide_hostlist},
 331 #endif
 332     GNUNET_GETOPT_OPTION_END
 333   };
 334
 335   int ret;
 336
 337   GNUNET_log_setup ("hostlist", "WARNING", NULL);
 338   ret =
 339       (GNUNET_OK ==
 340        GNUNET_PROGRAM_run (argc, argv, "hostlist",
 341                            _("GNUnet hostlist server and client"), options,
 342                            &run, NULL)) ? 0 : 1;
 343
 344   return ret;
 345 }
 346
 347 /* end of gnunet-daemon-hostlist.c */