GNUnet 0.22.2
program.c
Go to the documentation of this file.
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 it
6 under the terms of the GNU Affero General Public License as published
7 by the Free Software Foundation, either version 3 of the License,
8 or (at your 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 Affero General Public License for more details.
14
15 You should have received a copy of the GNU Affero General Public License
16 along with this program. If not, see <http://www.gnu.org/licenses/>.
17
18 SPDX-License-Identifier: AGPL3.0-or-later
19 */
20
28#include "platform.h"
29#include "gnunet_util_lib.h"
31#include "gnunet_constants.h"
32#include "speedup.h"
33#include <gcrypt.h>
34
35#define LOG(kind, ...) GNUNET_log_from (kind, "util-program", __VA_ARGS__)
36
37#define LOG_STRERROR_FILE(kind, syscall, filename) \
38 GNUNET_log_from_strerror_file (kind, "util-program", syscall, filename)
39
44{
48 char *const *args;
49
53 char *cfgfile;
54
59
63 void *task_cls;
64
69};
70
71
75static void
76shutdown_task (void *cls)
77{
78 (void) cls;
80}
81
82
87static void
88program_main (void *cls)
89{
90 struct CommandContext *cc = cls;
91
94 NULL);
96 cc->task (cc->task_cls,
97 cc->args,
98 cc->cfgfile,
99 cc->cfg);
100}
101
102
110static int
111cmd_sorter (const void *a1,
112 const void *a2)
113{
114 const struct GNUNET_GETOPT_CommandLineOption *c1 = a1;
115 const struct GNUNET_GETOPT_CommandLineOption *c2 = a2;
116
117 if (toupper ((unsigned char) c1->shortName) >
118 toupper ((unsigned char) c2->shortName))
119 return 1;
120 if (toupper ((unsigned char) c1->shortName) <
121 toupper ((unsigned char) c2->shortName))
122 return -1;
123 if (c1->shortName > c2->shortName)
124 return 1;
125 if (c1->shortName < c2->shortName)
126 return -1;
127 return 0;
128}
129
130
133 int argc,
134 char *const *argv,
135 const char *binaryName,
136 const char *binaryHelp,
139 void *task_cls,
140 int run_without_scheduler)
141{
142 struct CommandContext cc;
143
144#if ENABLE_NLS
145 char *path;
146#endif
147 char *loglev;
148 char *logfile;
149 char *cfg_fn;
151 int iret;
152 unsigned int cnt;
153 unsigned long long skew_offset;
154 unsigned long long skew_variance;
155 long long clock_offset;
157 const struct GNUNET_GETOPT_CommandLineOption defoptions[] = {
160 binaryHelp),
164 };
165 unsigned int deflen = sizeof(defoptions) / sizeof(defoptions[0]);
166 struct GNUNET_GETOPT_CommandLineOption *allopts;
167 const char *gargs;
168 char *lpfx;
169 char *spc;
170
171 logfile = NULL;
172 gargs = getenv ("GNUNET_ARGS");
173 if (NULL != gargs)
174 {
175 char **gargv;
176 unsigned int gargc;
177 char *cargs;
178
179 gargv = NULL;
180 gargc = 0;
181 for (int i = 0; i < argc; i++)
182 GNUNET_array_append (gargv,
183 gargc,
184 GNUNET_strdup (argv[i]));
185 cargs = GNUNET_strdup (gargs);
186 for (char *tok = strtok (cargs, " ");
187 NULL != tok;
188 tok = strtok (NULL, " "))
189 GNUNET_array_append (gargv,
190 gargc,
191 GNUNET_strdup (tok));
192 GNUNET_free (cargs);
193 GNUNET_array_append (gargv,
194 gargc,
195 NULL);
196 argv = (char *const *) gargv;
197 argc = gargc - 1;
198 }
199 memset (&cc, 0, sizeof(cc));
200 loglev = NULL;
201 cc.task = task;
202 cc.task_cls = task_cls;
204 /* prepare */
205#if ENABLE_NLS
206 if (NULL != pd->gettext_domain)
207 {
208 setlocale (LC_ALL, "");
209 path = (NULL == pd->gettext_path)
213 if (NULL != path)
214 {
216 path);
217 GNUNET_free (path);
218 }
220 }
221#endif
222 cnt = 0;
223 while (NULL != options[cnt].name)
224 cnt++;
225 allopts = GNUNET_new_array (cnt + deflen + 1,
227 GNUNET_memcpy (allopts,
228 options,
229 cnt * sizeof(struct GNUNET_GETOPT_CommandLineOption));
230 {
231 unsigned int xtra = 0;
232
233 for (unsigned int i = 0;
234 i<sizeof (defoptions) / sizeof(struct GNUNET_GETOPT_CommandLineOption);
235 i++)
236 {
237 bool found = false;
238
239 for (unsigned int j = 0; j<cnt; j++)
240 {
241 found |= ( (options[j].shortName == defoptions[i].shortName) &&
242 (0 != options[j].shortName) );
243 found |= ( (NULL != options[j].name) &&
244 (NULL != defoptions[i].name) &&
245 (0 == strcmp (options[j].name,
246 defoptions[i].name)) );
247 if (found)
248 break;
249 }
250 if (found)
251 continue;
252 GNUNET_memcpy (&allopts[cnt + xtra],
253 &defoptions[i],
254 sizeof (struct GNUNET_GETOPT_CommandLineOption));
255 xtra++;
256 }
257 cnt += xtra;
258 }
259 qsort (allopts,
260 cnt,
261 sizeof(struct GNUNET_GETOPT_CommandLineOption),
262 &cmd_sorter);
263 loglev = NULL;
264 if ((NULL != pd->config_file) && (NULL != pd->user_config_file))
266 else
267 cfg_fn = NULL;
268 lpfx = GNUNET_strdup (binaryName);
269 if (NULL != (spc = strstr (lpfx, " ")))
270 *spc = '\0';
271 iret = GNUNET_GETOPT_run (binaryName,
272 allopts,
273 (unsigned int) argc,
274 argv);
275 if ((GNUNET_OK > iret) ||
276 (GNUNET_OK != GNUNET_log_setup (lpfx,
277 loglev,
278 logfile)))
279 {
280 GNUNET_free (allopts);
281 GNUNET_free (lpfx);
282 ret = (enum GNUNET_GenericReturnValue) iret;
283 goto cleanup;
284 }
285 if (NULL != cc.cfgfile)
286 {
288 "Loading configuration from entry point specified as option (%s)\n",
289 cc.cfgfile);
290 if (GNUNET_YES !=
292 {
294 _ ("Unreadable configuration file `%s', exiting ...\n"),
295 cc.cfgfile);
297 GNUNET_free (allopts);
298 GNUNET_free (lpfx);
299 goto cleanup;
300 }
301 if (GNUNET_SYSERR ==
303 cc.cfgfile))
304 {
306 _ ("Malformed configuration file `%s', exiting ...\n"),
307 cc.cfgfile);
309 GNUNET_free (allopts);
310 GNUNET_free (lpfx);
311 goto cleanup;
312 }
313 }
314 else
315 {
316 if ( (NULL != cfg_fn) &&
317 (GNUNET_YES !=
318 GNUNET_DISK_file_test (cfg_fn)) )
319 {
321 _ ("Unreadable configuration file `%s'. Exiting ...\n"),
322 cfg_fn);
324 GNUNET_free (allopts);
325 GNUNET_free (lpfx);
326 goto cleanup;
327 }
329 "Loading configuration from entry point `%s'\n",
330 cc.cfgfile);
331 if (GNUNET_SYSERR ==
333 cfg_fn))
334 {
336 _ ("Malformed configuration. Exiting ...\n"));
338 GNUNET_free (allopts);
339 GNUNET_free (lpfx);
340 goto cleanup;
341 }
342 }
343 GNUNET_free (allopts);
344 GNUNET_free (lpfx);
345 if ((GNUNET_OK ==
347 "testing",
348 "skew_offset",
349 &skew_offset)) &&
350 (GNUNET_OK ==
352 "testing",
353 "skew_variance",
354 &skew_variance)))
355 {
356 clock_offset = skew_offset - skew_variance;
357 GNUNET_TIME_set_offset (clock_offset);
358 }
359 /* ARM needs to know which configuration file to use when starting
360 services. If we got a command-line option *and* if nothing is
361 specified in the configuration, remember the command-line option
362 in "cfg". This is typically really only having an effect if we
363 are running code in src/arm/, as obviously the rest of the code
364 has little business with ARM-specific options. */
365 if (GNUNET_YES !=
367 "arm",
368 "CONFIG"))
369 {
370 if (NULL != cc.cfgfile)
372 "arm",
373 "CONFIG",
374 cc.cfgfile);
375 else if (NULL != cfg_fn)
377 "arm",
378 "CONFIG",
379 cfg_fn);
380 }
381
382 /* run */
383 cc.args = &argv[iret];
384 if ((NULL == cc.cfgfile) && (NULL != cfg_fn))
385 cc.cfgfile = GNUNET_strdup (cfg_fn);
386 if (GNUNET_NO == run_without_scheduler)
387 {
389 }
390 else
391 {
393 cc.task (cc.task_cls, cc.args, cc.cfgfile, cc.cfg);
394 }
395 ret = GNUNET_OK;
396cleanup:
398 GNUNET_free (cc.cfgfile);
399 GNUNET_free (cfg_fn);
400 GNUNET_free (loglev);
401 GNUNET_free (logfile);
402 return ret;
403}
404
405
408 int argc,
409 char *const *argv,
410 const char *binaryName,
411 const char *binaryHelp,
414 void *task_cls)
415{
416 return GNUNET_PROGRAM_run2 (pd,
417 argc,
418 argv,
419 binaryName,
420 binaryHelp,
421 options,
422 task,
423 task_cls,
424 GNUNET_NO);
425}
426
427
430 int argc,
431 char *const *argv,
433{
434 char *cfg_filename;
435 char *opt_cfg_filename;
436 char *logfile;
437 char *loglev;
438 const char *xdg;
439 int do_daemonize;
440 int ret;
441 struct GNUNET_GETOPT_CommandLineOption service_options[] = {
442 GNUNET_GETOPT_option_cfgfile (&opt_cfg_filename),
444 "daemonize",
446 "do daemonize (detach from terminal)"),
447 &do_daemonize),
449 NULL),
454 };
455
456 xdg = getenv ("XDG_CONFIG_HOME");
457 if (NULL != xdg)
459 "%s%s%s",
460 xdg,
462 pd->config_file);
463 else
465
466 loglev = NULL;
467 logfile = NULL;
468 opt_cfg_filename = NULL;
469 // FIXME we need to set this up for each service!
470 ret = GNUNET_GETOPT_run ("libgnunet",
471 service_options,
472 argc,
473 argv);
474 if (GNUNET_SYSERR == ret)
475 goto error;
476 if (GNUNET_NO == ret)
477 {
478 goto error;
479 }
480 // FIXME we need to set this up for each service!
481 // NOTE: that was not the idea. What are you proposing? -CG
482 if (GNUNET_OK !=
483 GNUNET_log_setup ("libgnunet",
484 "DEBUG",// loglev,
485 logfile))
486 {
487 GNUNET_break (0);
488 goto error;
489 }
490 if (NULL == cfg)
491 {
493 if (NULL != opt_cfg_filename)
494 {
495 if ( (GNUNET_YES !=
496 GNUNET_DISK_file_test (opt_cfg_filename)) ||
497 (GNUNET_SYSERR ==
499 opt_cfg_filename)) )
500 {
502 _ ("Malformed configuration file `%s', exit ...\n"),
503 opt_cfg_filename);
504 goto error;
505 }
506 }
507 else
508 {
509 if (GNUNET_YES ==
511 {
512 if (GNUNET_SYSERR ==
515 {
517 _ ("Malformed configuration file `%s', exit ...\n"),
520 goto error;;
521 }
522 }
523 else
524 {
525 if (GNUNET_SYSERR ==
527 NULL))
528 {
530 _ ("Malformed configuration, exit ...\n"));
532 goto error;
533 }
534 }
535 }
536 }
537
538 GNUNET_free (logfile);
539 GNUNET_free (loglev);
541 GNUNET_free (opt_cfg_filename);
542
543 return GNUNET_OK;
544
545error:
548 GNUNET_free (logfile);
549 GNUNET_free (loglev);
551 GNUNET_free (opt_cfg_filename);
552
553 return GNUNET_SYSERR;
554}
555
556
558{
561};
562
563static void
564monolith_main (void *cls)
565{
566 struct MonoContext *mc = cls;
567
569 0,
570 NULL,
571 mc->cfg,
572 GNUNET_NO);
574 0,
575 NULL,
576 mc->cfg,
577 GNUNET_NO);
578}
579
580
581void
583 int argc,
584 char *const *argv,
586{
587 struct MonoContext mc = {
588 .cfg = cfg,
589 .pd = pd
590 };
591
592 if (GNUNET_YES !=
594 argc,
595 argv,
596 cfg))
597 return;
599 &mc);
600}
601
602
603/* A list of daemons to be launched when GNUNET_main()
604 * is called
605 */
607{
608 /* DLL */
610
611 /* DLL */
613
614 /* Program to launch */
616
618
619 const char *daemon_name;
620};
621
622/* The daemon list */
623static struct DaemonHandleList *hll_head = NULL;
624
625/* The daemon list */
626static struct DaemonHandleList *hll_tail = NULL;
627
628static void
629launch_daemon (void *cls)
630{
631 struct DaemonHandleList *hll = cls;
632
633 // FIXME read from config argv argc?
634 hll->d (NULL, NULL, NULL, hll->cfg);
635}
636
637
638static void
639launch_daemons (void *cls)
640{
641 struct GNUNET_CONFIGURATION_Handle *cfg = cls;
642
643 for (struct DaemonHandleList *hll = hll_head;
644 NULL != hll;
645 hll = hll->next)
646 {
648 "Launching daemon %s\n",
649 hll->daemon_name);
650 hll->cfg = cfg;
652 hll);
653 }
654}
655
656
657void
659 int argc,
660 char *const *argv,
662 enum GNUNET_GenericReturnValue with_scheduler)
663{
665 "Entering GNUNET_DAEMON_main\n");
666 if (GNUNET_YES == with_scheduler)
667 {
668 if (GNUNET_YES !=
670 argc,
671 argv,
672 cfg))
673 return;
675 cfg);
676 }
677 else
679}
680
681
683GNUNET_DAEMON_register (const char *daemon_name,
684 const char *daemon_help,
686{
687 struct DaemonHandleList *hle;
688
690 "registering daemon %s\n",
692 hle = GNUNET_new (struct DaemonHandleList);
693 hle->d = task;
696 hll_tail,
697 hle);
698 return GNUNET_OK;
699}
700
701
702/* end of program.c */
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_OPTION_END
Definition: 002.c:13
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
char * getenv()
#define gettext_noop(String)
Definition: gettext.h:74
#define textdomain(Domainname)
Definition: gettext.h:61
#define bindtextdomain(Domainname, Dirname)
Definition: gettext.h:62
static int ret
Final status code.
Definition: gnunet-arm.c:93
static struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Definition: gnunet-arm.c:108
static char * cfg_filename
Name of the configuration file.
static void cleanup(void *cls)
Disconnect and shutdown.
Definition: gnunet-did.c:131
static char * name
Name (label) of the records to list.
static struct GNUNET_TESTBED_Controller * mc
Handle to the master controller.
Functions related to doing DNS lookups.
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_create(const struct GNUNET_OS_ProjectData *pd)
Create a new configuration object.
void GNUNET_CONFIGURATION_set_value_string(struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, const char *value)
Set a configuration value that should be a string.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_number(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *number)
Get a configuration value that should be a number.
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
char * GNUNET_CONFIGURATION_default_filename(const struct GNUNET_OS_ProjectData *pd)
Return the filename of the default configuration filename that is used when no explicit configuration...
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_load(struct GNUNET_CONFIGURATION_Handle *cfg, const char *filename)
Load configuration.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_have_value(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option)
Test if we have a value for a particular option.
enum GNUNET_GenericReturnValue GNUNET_DISK_file_test(const char *fil)
Check that fil corresponds to a filename (of a file that exists and that is not a directory).
Definition: disk.c:520
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_cfgfile(char **fn)
Allow user to specify configuration file name (-c option)
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_logfile(char **logfn)
Allow user to specify log file name (-l option)
int GNUNET_GETOPT_run(const char *binaryOptions, const struct GNUNET_GETOPT_CommandLineOption *allOptions, unsigned int argc, char *const *argv)
Parse the command line.
Definition: getopt.c:884
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_help(const struct GNUNET_OS_ProjectData *pd, const char *about)
Defining the option to print the command line help text (-h option).
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_loglevel(char **level)
Define the '-L' log level option.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_flag(char shortName, const char *name, const char *description, int *val)
Allow user to specify a flag (which internally means setting an integer to 1/GNUNET_YES/GNUNET_OK.
struct GNUNET_GETOPT_CommandLineOption GNUNET_GETOPT_option_version(const char *version)
Define the option to print the version of the application (-v option)
#define GNUNET_log(kind,...)
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
GNUNET_GenericReturnValue
Named constants for return values.
@ GNUNET_OK
@ GNUNET_YES
@ GNUNET_NO
@ GNUNET_SYSERR
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
enum GNUNET_GenericReturnValue GNUNET_log_setup(const char *comp, const char *loglevel, const char *logfile)
Setup logging.
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
#define GNUNET_array_append(arr, len, element)
Append an element to an array (growing the array by one).
#define GNUNET_free(ptr)
Wrapper around free.
char * GNUNET_OS_installation_get_path(const struct GNUNET_OS_ProjectData *pd, enum GNUNET_OS_InstallationPathKind dirkind)
Get the path to a specific GNUnet installation directory or, with GNUNET_OS_IPK_SELF_PREFIX,...
@ GNUNET_OS_IPK_LOCALEDIR
Return the directory where translations are installed (share/locale/)
enum GNUNET_GenericReturnValue GNUNET_DAEMON_register(const char *daemon_name, const char *daemon_help, GNUNET_PROGRAM_Main task)
Definition: program.c:683
enum GNUNET_GenericReturnValue GNUNET_PROGRAM_run2(const struct GNUNET_OS_ProjectData *pd, int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls, int run_without_scheduler)
Run a standard GNUnet command startup sequence (initialize loggers and configuration,...
Definition: program.c:132
void GNUNET_PROGRAM_monolith_main(const struct GNUNET_OS_ProjectData *pd, int argc, char *const *argv, struct GNUNET_CONFIGURATION_Handle *cfg)
Start all services and daemons in a single process.
Definition: program.c:582
void(* GNUNET_PROGRAM_Main)(void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
Main function that will be run.
enum GNUNET_GenericReturnValue GNUNET_PROGRAM_run(const struct GNUNET_OS_ProjectData *pd, int argc, char *const *argv, const char *binaryName, const char *binaryHelp, const struct GNUNET_GETOPT_CommandLineOption *options, GNUNET_PROGRAM_Main task, void *task_cls)
Run a standard GNUnet command startup sequence (initialize loggers and configuration,...
Definition: program.c:407
enum GNUNET_GenericReturnValue GNUNET_PROGRAM_conf_and_options(const struct GNUNET_OS_ProjectData *pd, int argc, char *const *argv, struct GNUNET_CONFIGURATION_Handle *cfg)
Create configuration handle from options and configuration file.
Definition: program.c:429
void GNUNET_DAEMON_main(const struct GNUNET_OS_ProjectData *pd, int argc, char *const *argv, struct GNUNET_CONFIGURATION_Handle *cfg, enum GNUNET_GenericReturnValue with_scheduler)
Run the mainloop in a monolithic libgnunet.
Definition: program.c:658
void GNUNET_RESOLVER_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Create the connection to the resolver service.
Definition: resolver_api.c:258
void GNUNET_SCHEDULER_run(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Initialize and run scheduler.
Definition: scheduler.c:725
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received,...
Definition: scheduler.c:1339
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1304
void GNUNET_SERVICE_main(const struct GNUNET_OS_ProjectData *pd, int argc, char *const *argv, struct GNUNET_CONFIGURATION_Handle *cfg, enum GNUNET_GenericReturnValue with_scheduler)
Run the mainloop in a monolithic libgnunet.
Definition: service.c:2303
void GNUNET_TIME_set_offset(long long offset)
Set the timestamp offset for this instance.
Definition: time.c:49
#define DIR_SEPARATOR_STR
Definition: platform.h:167
#define _(String)
GNU gettext support macro.
Definition: platform.h:179
static void launch_daemon(void *cls)
Definition: program.c:629
static struct DaemonHandleList * hll_tail
Definition: program.c:626
static void monolith_main(void *cls)
Definition: program.c:564
static struct DaemonHandleList * hll_head
Definition: program.c:623
static void shutdown_task(void *cls)
task run when the scheduler shuts down
Definition: program.c:76
static void launch_daemons(void *cls)
Definition: program.c:639
static void program_main(void *cls)
Initial task called by the scheduler for each program.
Definition: program.c:88
static int cmd_sorter(const void *a1, const void *a2)
Compare function for 'qsort' to sort command-line arguments by the short option.
Definition: program.c:111
#define LOG(kind,...)
Definition: program.c:35
int GNUNET_SPEEDUP_start_(const struct GNUNET_CONFIGURATION_Handle *cfg)
Start task that may speed up our system clock artificially.
Definition: speedup.c:60
void GNUNET_SPEEDUP_stop_()
Stop tasks that modify clock behavior.
Definition: speedup.c:100
Context for the command.
Definition: program.c:44
void * task_cls
Closure for task.
Definition: program.c:63
char *const * args
Argv argument.
Definition: program.c:48
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration to use.
Definition: program.c:68
GNUNET_PROGRAM_Main task
Main function to run.
Definition: program.c:58
char * cfgfile
Name of the configuration file used, can be NULL!
Definition: program.c:53
const struct GNUNET_CONFIGURATION_Handle * cfg
Definition: program.c:617
GNUNET_PROGRAM_Main d
Definition: program.c:615
struct DaemonHandleList * next
Definition: program.c:612
struct DaemonHandleList * prev
Definition: program.c:609
const char * daemon_name
Definition: program.c:619
const struct GNUNET_OS_ProjectData * pd
Project data for this configuration object.
Definition of a command line option.
const char * name
Long name of the option (may not be NULL)
const char shortName
Short name of the option.
Project-specific data used to help the OS subsystem find installation paths.
const char * gettext_path
Gettext directory, e.g.
const char * gettext_domain
Gettext domain for localisation, e.g.
const char * user_config_file
Configuration file name to use (if $XDG_CONFIG_HOME is not set).
const char * config_file
Configuration file name (in $XDG_CONFIG_HOME) to use.
const char * version
String identifying the current project version.
const struct GNUNET_OS_ProjectData * pd
Definition: program.c:559
struct GNUNET_CONFIGURATION_Handle * cfg
Definition: program.c:560