Merge branch 'master' of ssh://gnunet.org/gnunet
[oweals/gnunet.git] / src / util / program.c
1 /*
2      This file is part of GNUnet.
3      Copyright (C) 2009-2013 GNUnet e.V.
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 PURPROSE.  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., 51 Franklin Street, Fifth Floor,
18      Boston, MA 02110-1301, USA.
19 */
20
21 /**
22  * @file util/program.c
23  * @brief standard code for GNUnet startup and shutdown
24  * @author Christian Grothoff
25  */
26
27 #include "platform.h"
28 #include "gnunet_util_lib.h"
29 #include "gnunet_resolver_service.h"
30 #include "gnunet_constants.h"
31 #include "speedup.h"
32 #include <gcrypt.h>
33
34 #define LOG(kind,...) GNUNET_log_from (kind, "util-program", __VA_ARGS__)
35
36 #define LOG_STRERROR_FILE(kind,syscall,filename) GNUNET_log_from_strerror_file (kind, "util-program", syscall, filename)
37
38 /**
39  * Context for the command.
40  */
41 struct CommandContext
42 {
43   /**
44    * Argv argument.
45    */
46   char *const *args;
47
48   /**
49    * Name of the configuration file used, can be NULL!
50    */
51   char *cfgfile;
52
53   /**
54    * Main function to run.
55    */
56   GNUNET_PROGRAM_Main task;
57
58   /**
59    * Closure for @e task.
60    */
61   void *task_cls;
62
63   /**
64    * Configuration to use.
65    */
66   const struct GNUNET_CONFIGURATION_Handle *cfg;
67
68 };
69
70
71 /**
72  * Initial task called by the scheduler for each
73  * program.  Runs the program-specific main task.
74  */
75 static void
76 program_main (void *cls)
77 {
78   struct CommandContext *cc = cls;
79
80   GNUNET_SPEEDUP_start_(cc->cfg);
81   GNUNET_RESOLVER_connect (cc->cfg);
82   cc->task (cc->task_cls, cc->args, cc->cfgfile, cc->cfg);
83 }
84
85
86 /**
87  * Compare function for 'qsort' to sort command-line arguments by the
88  * short option.
89  *
90  * @param a1 first command line option
91  * @param a2 second command line option
92  */
93 static int
94 cmd_sorter (const void *a1, const void *a2)
95 {
96   const struct GNUNET_GETOPT_CommandLineOption *c1 = a1;
97   const struct GNUNET_GETOPT_CommandLineOption *c2 = a2;
98
99   if (toupper ((unsigned char) c1->shortName) >
100       toupper ((unsigned char) c2->shortName))
101     return 1;
102   if (toupper ((unsigned char) c1->shortName) <
103       toupper ((unsigned char) c2->shortName))
104     return -1;
105   if (c1->shortName > c2->shortName)
106     return 1;
107   if (c1->shortName < c2->shortName)
108     return -1;
109   return 0;
110 }
111
112
113 /**
114  * Run a standard GNUnet command startup sequence (initialize loggers
115  * and configuration, parse options).
116  *
117  * @param argc number of command line arguments in @a argv
118  * @param argv command line arguments
119  * @param binaryName our expected name
120  * @param binaryHelp help text for the program
121  * @param options command line options
122  * @param task main function to run
123  * @param task_cls closure for @a task
124  * @param run_without_scheduler #GNUNET_NO start the scheduler, #GNUNET_YES do not
125  *        start the scheduler just run the main task
126  * @return #GNUNET_SYSERR on error, #GNUNET_OK on success
127  */
128 int
129 GNUNET_PROGRAM_run2 (int argc, char *const *argv, const char *binaryName,
130                      const char *binaryHelp,
131                      const struct GNUNET_GETOPT_CommandLineOption *options,
132                      GNUNET_PROGRAM_Main task, void *task_cls,
133                      int run_without_scheduler)
134 {
135   struct CommandContext cc;
136 #if ENABLE_NLS
137   char *path;
138 #endif
139   char *loglev;
140   char *logfile;
141   char *cfg_fn;
142   const char *xdg;
143   int ret;
144   unsigned int cnt;
145   unsigned long long skew_offset;
146   unsigned long long skew_variance;
147   long long clock_offset;
148   struct GNUNET_CONFIGURATION_Handle *cfg;
149
150   struct GNUNET_GETOPT_CommandLineOption defoptions[] = {
151     GNUNET_GETOPT_OPTION_CFG_FILE (&cc.cfgfile),
152     GNUNET_GETOPT_OPTION_HELP (binaryHelp),
153     GNUNET_GETOPT_OPTION_LOGLEVEL (&loglev),
154     GNUNET_GETOPT_OPTION_LOGFILE (&logfile),
155     GNUNET_GETOPT_OPTION_VERSION (PACKAGE_VERSION " " VCS_VERSION)
156   };
157   struct GNUNET_GETOPT_CommandLineOption *allopts;
158   const char *gargs;
159   char *lpfx;
160   char *spc;
161
162   logfile = NULL;
163   gargs = getenv ("GNUNET_ARGS");
164   if (NULL != gargs)
165   {
166     char **gargv;
167     unsigned int gargc;
168     int i;
169     char *tok;
170     char *cargs;
171
172     gargv = NULL;
173     gargc = 0;
174     for (i = 0; i < argc; i++)
175       GNUNET_array_append (gargv, gargc, GNUNET_strdup (argv[i]));
176     cargs = GNUNET_strdup (gargs);
177     for (tok = strtok (cargs, " "); NULL != tok; tok = strtok (NULL, " "))
178       GNUNET_array_append (gargv, gargc, GNUNET_strdup (tok));
179     GNUNET_free (cargs);
180     GNUNET_array_append (gargv, gargc, NULL);
181     argv = (char *const *) gargv;
182     argc = gargc - 1;
183   }
184   memset (&cc, 0, sizeof (cc));
185   loglev = NULL;
186   cc.task = task;
187   cc.task_cls = task_cls;
188   cc.cfg = cfg = GNUNET_CONFIGURATION_create ();
189   /* prepare */
190 #if ENABLE_NLS
191   setlocale (LC_ALL, "");
192   path = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_LOCALEDIR);
193   if (NULL != path)
194   {
195     BINDTEXTDOMAIN ("GNUnet", path);
196     GNUNET_free (path);
197   }
198   textdomain ("GNUnet");
199 #endif
200   cnt = 0;
201   while (NULL != options[cnt].name)
202     cnt++;
203   allopts =
204       GNUNET_malloc ((cnt +
205                       1) * sizeof (struct GNUNET_GETOPT_CommandLineOption) +
206                      sizeof (defoptions));
207   GNUNET_memcpy (allopts, defoptions, sizeof (defoptions));
208   GNUNET_memcpy (&allopts
209           [sizeof (defoptions) /
210            sizeof (struct GNUNET_GETOPT_CommandLineOption)], options,
211           (cnt + 1) * sizeof (struct GNUNET_GETOPT_CommandLineOption));
212   cnt += sizeof (defoptions) / sizeof (struct GNUNET_GETOPT_CommandLineOption);
213   qsort (allopts, cnt, sizeof (struct GNUNET_GETOPT_CommandLineOption),
214          &cmd_sorter);
215   loglev = NULL;
216   xdg = getenv ("XDG_CONFIG_HOME");
217   if (NULL != xdg)
218     GNUNET_asprintf (&cfg_fn,
219                      "%s%s%s",
220                      xdg,
221                      DIR_SEPARATOR_STR,
222                      GNUNET_OS_project_data_get ()->config_file);
223   else
224     cfg_fn = GNUNET_strdup (GNUNET_OS_project_data_get ()->user_config_file);
225   lpfx = GNUNET_strdup (binaryName);
226   if (NULL != (spc = strstr (lpfx, " ")))
227     *spc = '\0';
228   ret = GNUNET_GETOPT_run (binaryName, allopts, (unsigned int) argc, argv);
229   if ((GNUNET_OK > ret) ||
230       (GNUNET_OK != GNUNET_log_setup (lpfx, loglev, logfile)))
231   {
232     GNUNET_free (allopts);
233     GNUNET_free (lpfx);
234     goto cleanup;
235   }
236   if (NULL == cc.cfgfile)
237     cc.cfgfile = GNUNET_strdup (cfg_fn);
238   if (GNUNET_YES ==
239       GNUNET_DISK_file_test (cc.cfgfile))
240   {
241     if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load (cfg, cc.cfgfile))
242     {
243       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
244                   _("Malformed configuration file `%s', exit ...\n"),
245                   cc.cfgfile);
246       ret = GNUNET_SYSERR;
247       GNUNET_free (allopts);
248       GNUNET_free (lpfx);
249       goto cleanup;
250     }
251   }
252   else
253   {
254     if (0 != strcmp (cc.cfgfile, cfg_fn))
255       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
256                   _("Could not access configuration file `%s'\n"),
257                   cc.cfgfile);
258     if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load (cfg, NULL))
259     {
260       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
261                   _("Malformed configuration, exit ...\n"));
262       ret = GNUNET_SYSERR;
263       GNUNET_free (allopts);
264       GNUNET_free (lpfx);
265       goto cleanup;
266     }
267   }
268   GNUNET_free (allopts);
269   GNUNET_free (lpfx);
270   if (GNUNET_OK ==
271       GNUNET_CONFIGURATION_get_value_number (cc.cfg, "testing", "skew_offset",
272                                              &skew_offset) &&
273       (GNUNET_OK ==
274        GNUNET_CONFIGURATION_get_value_number (cc.cfg, "testing",
275                                               "skew_variance", &skew_variance)))
276   {
277     clock_offset = skew_offset - skew_variance;
278     GNUNET_TIME_set_offset (clock_offset);
279   }
280   /* ARM needs to know which configuration file to use when starting
281      services.  If we got a command-line option *and* if nothing is
282      specified in the configuration, remember the command-line option
283      in "cfg".  This is typically really only having an effect if we
284      are running code in src/arm/, as obviously the rest of the code
285      has little business with ARM-specific options. */
286   if (GNUNET_YES !=
287       GNUNET_CONFIGURATION_have_value (cfg,
288                                        "arm",
289                                        "CONFIG"))
290   {
291     GNUNET_CONFIGURATION_set_value_string (cfg,
292                                            "arm", "CONFIG",
293                                            cc.cfgfile);
294   }
295
296   /* run */
297   cc.args = &argv[ret];
298   if (GNUNET_NO == run_without_scheduler)
299   {
300     GNUNET_SCHEDULER_run (&program_main, &cc);
301   }
302   else
303   {
304     GNUNET_RESOLVER_connect (cc.cfg);
305     cc.task (cc.task_cls, cc.args, cc.cfgfile, cc.cfg);
306   }
307   ret = GNUNET_OK;
308  cleanup:
309   GNUNET_SPEEDUP_stop_ ();
310   GNUNET_CONFIGURATION_destroy (cfg);
311   GNUNET_free_non_null (cc.cfgfile);
312   GNUNET_free (cfg_fn);
313   GNUNET_free_non_null (loglev);
314   GNUNET_free_non_null (logfile);
315   return ret;
316 }
317
318 /**
319  * Run a standard GNUnet command startup sequence (initialize loggers
320  * and configuration, parse options).
321  *
322  * @param argc number of command line arguments
323  * @param argv command line arguments
324  * @param binaryName our expected name
325  * @param binaryHelp help text for the program
326  * @param options command line options
327  * @param task main function to run
328  * @param task_cls closure for @a task
329  * @return #GNUNET_SYSERR on error, #GNUNET_OK on success
330  */
331 int
332 GNUNET_PROGRAM_run (int argc, char *const *argv,
333                     const char *binaryName,
334                     const char *binaryHelp,
335                     const struct GNUNET_GETOPT_CommandLineOption *options,
336                     GNUNET_PROGRAM_Main task,
337                     void *task_cls)
338 {
339   return GNUNET_PROGRAM_run2 (argc, argv,
340                               binaryName, binaryHelp,
341                               options,
342                               task, task_cls,
343                               GNUNET_NO);
344 }
345
346
347 /* end of program.c */