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