diff options
Diffstat (limited to 'src/util/program.c')
-rw-r--r-- | src/util/program.c | 354 |
1 files changed, 177 insertions, 177 deletions
diff --git a/src/util/program.c b/src/util/program.c index 77f4ea3ae..9bd3d64f9 100644 --- a/src/util/program.c +++ b/src/util/program.c | |||
@@ -16,7 +16,7 @@ | |||
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
18 | SPDX-License-Identifier: AGPL3.0-or-later | 18 | SPDX-License-Identifier: AGPL3.0-or-later |
19 | */ | 19 | */ |
20 | 20 | ||
21 | /** | 21 | /** |
22 | * @file util/program.c | 22 | * @file util/program.c |
@@ -31,16 +31,15 @@ | |||
31 | #include "speedup.h" | 31 | #include "speedup.h" |
32 | #include <gcrypt.h> | 32 | #include <gcrypt.h> |
33 | 33 | ||
34 | #define LOG(kind, ...) GNUNET_log_from (kind, "util-program", __VA_ARGS__) | 34 | #define LOG(kind, ...) GNUNET_log_from(kind, "util-program", __VA_ARGS__) |
35 | 35 | ||
36 | #define LOG_STRERROR_FILE(kind, syscall, filename) \ | 36 | #define LOG_STRERROR_FILE(kind, syscall, filename) \ |
37 | GNUNET_log_from_strerror_file (kind, "util-program", syscall, filename) | 37 | GNUNET_log_from_strerror_file(kind, "util-program", syscall, filename) |
38 | 38 | ||
39 | /** | 39 | /** |
40 | * Context for the command. | 40 | * Context for the command. |
41 | */ | 41 | */ |
42 | struct CommandContext | 42 | struct CommandContext { |
43 | { | ||
44 | /** | 43 | /** |
45 | * Argv argument. | 44 | * Argv argument. |
46 | */ | 45 | */ |
@@ -72,10 +71,10 @@ struct CommandContext | |||
72 | * task run when the scheduler shuts down | 71 | * task run when the scheduler shuts down |
73 | */ | 72 | */ |
74 | static void | 73 | static void |
75 | shutdown_task (void *cls) | 74 | shutdown_task(void *cls) |
76 | { | 75 | { |
77 | (void) cls; | 76 | (void)cls; |
78 | GNUNET_SPEEDUP_stop_ (); | 77 | GNUNET_SPEEDUP_stop_(); |
79 | } | 78 | } |
80 | 79 | ||
81 | 80 | ||
@@ -84,14 +83,14 @@ shutdown_task (void *cls) | |||
84 | * program. Runs the program-specific main task. | 83 | * program. Runs the program-specific main task. |
85 | */ | 84 | */ |
86 | static void | 85 | static void |
87 | program_main (void *cls) | 86 | program_main(void *cls) |
88 | { | 87 | { |
89 | struct CommandContext *cc = cls; | 88 | struct CommandContext *cc = cls; |
90 | 89 | ||
91 | GNUNET_SPEEDUP_start_ (cc->cfg); | 90 | GNUNET_SPEEDUP_start_(cc->cfg); |
92 | GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL); | 91 | GNUNET_SCHEDULER_add_shutdown(&shutdown_task, NULL); |
93 | GNUNET_RESOLVER_connect (cc->cfg); | 92 | GNUNET_RESOLVER_connect(cc->cfg); |
94 | cc->task (cc->task_cls, cc->args, cc->cfgfile, cc->cfg); | 93 | cc->task(cc->task_cls, cc->args, cc->cfgfile, cc->cfg); |
95 | } | 94 | } |
96 | 95 | ||
97 | 96 | ||
@@ -103,16 +102,16 @@ program_main (void *cls) | |||
103 | * @param a2 second command line option | 102 | * @param a2 second command line option |
104 | */ | 103 | */ |
105 | static int | 104 | static int |
106 | cmd_sorter (const void *a1, const void *a2) | 105 | cmd_sorter(const void *a1, const void *a2) |
107 | { | 106 | { |
108 | const struct GNUNET_GETOPT_CommandLineOption *c1 = a1; | 107 | const struct GNUNET_GETOPT_CommandLineOption *c1 = a1; |
109 | const struct GNUNET_GETOPT_CommandLineOption *c2 = a2; | 108 | const struct GNUNET_GETOPT_CommandLineOption *c2 = a2; |
110 | 109 | ||
111 | if (toupper ((unsigned char) c1->shortName) > | 110 | if (toupper((unsigned char)c1->shortName) > |
112 | toupper ((unsigned char) c2->shortName)) | 111 | toupper((unsigned char)c2->shortName)) |
113 | return 1; | 112 | return 1; |
114 | if (toupper ((unsigned char) c1->shortName) < | 113 | if (toupper((unsigned char)c1->shortName) < |
115 | toupper ((unsigned char) c2->shortName)) | 114 | toupper((unsigned char)c2->shortName)) |
116 | return -1; | 115 | return -1; |
117 | if (c1->shortName > c2->shortName) | 116 | if (c1->shortName > c2->shortName) |
118 | return 1; | 117 | return 1; |
@@ -138,16 +137,17 @@ cmd_sorter (const void *a1, const void *a2) | |||
138 | * @return #GNUNET_SYSERR on error, #GNUNET_OK on success | 137 | * @return #GNUNET_SYSERR on error, #GNUNET_OK on success |
139 | */ | 138 | */ |
140 | int | 139 | int |
141 | GNUNET_PROGRAM_run2 (int argc, | 140 | GNUNET_PROGRAM_run2(int argc, |
142 | char *const *argv, | 141 | char *const *argv, |
143 | const char *binaryName, | 142 | const char *binaryName, |
144 | const char *binaryHelp, | 143 | const char *binaryHelp, |
145 | const struct GNUNET_GETOPT_CommandLineOption *options, | 144 | const struct GNUNET_GETOPT_CommandLineOption *options, |
146 | GNUNET_PROGRAM_Main task, | 145 | GNUNET_PROGRAM_Main task, |
147 | void *task_cls, | 146 | void *task_cls, |
148 | int run_without_scheduler) | 147 | int run_without_scheduler) |
149 | { | 148 | { |
150 | struct CommandContext cc; | 149 | struct CommandContext cc; |
150 | |||
151 | #if ENABLE_NLS | 151 | #if ENABLE_NLS |
152 | char *path; | 152 | char *path; |
153 | #endif | 153 | #endif |
@@ -161,191 +161,191 @@ GNUNET_PROGRAM_run2 (int argc, | |||
161 | unsigned long long skew_variance; | 161 | unsigned long long skew_variance; |
162 | long long clock_offset; | 162 | long long clock_offset; |
163 | struct GNUNET_CONFIGURATION_Handle *cfg; | 163 | struct GNUNET_CONFIGURATION_Handle *cfg; |
164 | const struct GNUNET_OS_ProjectData *pd = GNUNET_OS_project_data_get (); | 164 | const struct GNUNET_OS_ProjectData *pd = GNUNET_OS_project_data_get(); |
165 | struct GNUNET_GETOPT_CommandLineOption defoptions[] = | 165 | struct GNUNET_GETOPT_CommandLineOption defoptions[] = |
166 | {GNUNET_GETOPT_option_cfgfile (&cc.cfgfile), | 166 | { GNUNET_GETOPT_option_cfgfile(&cc.cfgfile), |
167 | GNUNET_GETOPT_option_help (binaryHelp), | 167 | GNUNET_GETOPT_option_help(binaryHelp), |
168 | GNUNET_GETOPT_option_loglevel (&loglev), | 168 | GNUNET_GETOPT_option_loglevel(&loglev), |
169 | GNUNET_GETOPT_option_logfile (&logfile), | 169 | GNUNET_GETOPT_option_logfile(&logfile), |
170 | GNUNET_GETOPT_option_version (pd->version)}; | 170 | GNUNET_GETOPT_option_version(pd->version) }; |
171 | struct GNUNET_GETOPT_CommandLineOption *allopts; | 171 | struct GNUNET_GETOPT_CommandLineOption *allopts; |
172 | const char *gargs; | 172 | const char *gargs; |
173 | char *lpfx; | 173 | char *lpfx; |
174 | char *spc; | 174 | char *spc; |
175 | 175 | ||
176 | logfile = NULL; | 176 | logfile = NULL; |
177 | gargs = getenv ("GNUNET_ARGS"); | 177 | gargs = getenv("GNUNET_ARGS"); |
178 | if (NULL != gargs) | 178 | if (NULL != gargs) |
179 | { | 179 | { |
180 | char **gargv; | 180 | char **gargv; |
181 | unsigned int gargc; | 181 | unsigned int gargc; |
182 | char *cargs; | 182 | char *cargs; |
183 | 183 | ||
184 | gargv = NULL; | 184 | gargv = NULL; |
185 | gargc = 0; | 185 | gargc = 0; |
186 | for (int i = 0; i < argc; i++) | 186 | for (int i = 0; i < argc; i++) |
187 | GNUNET_array_append (gargv, gargc, GNUNET_strdup (argv[i])); | 187 | GNUNET_array_append(gargv, gargc, GNUNET_strdup(argv[i])); |
188 | cargs = GNUNET_strdup (gargs); | 188 | cargs = GNUNET_strdup(gargs); |
189 | for (char *tok = strtok (cargs, " "); NULL != tok; tok = strtok (NULL, " ")) | 189 | for (char *tok = strtok(cargs, " "); NULL != tok; tok = strtok(NULL, " ")) |
190 | GNUNET_array_append (gargv, gargc, GNUNET_strdup (tok)); | 190 | GNUNET_array_append(gargv, gargc, GNUNET_strdup(tok)); |
191 | GNUNET_free (cargs); | 191 | GNUNET_free(cargs); |
192 | GNUNET_array_append (gargv, gargc, NULL); | 192 | GNUNET_array_append(gargv, gargc, NULL); |
193 | argv = (char *const *) gargv; | 193 | argv = (char *const *)gargv; |
194 | argc = gargc - 1; | 194 | argc = gargc - 1; |
195 | } | 195 | } |
196 | memset (&cc, 0, sizeof (cc)); | 196 | memset(&cc, 0, sizeof(cc)); |
197 | loglev = NULL; | 197 | loglev = NULL; |
198 | cc.task = task; | 198 | cc.task = task; |
199 | cc.task_cls = task_cls; | 199 | cc.task_cls = task_cls; |
200 | cc.cfg = cfg = GNUNET_CONFIGURATION_create (); | 200 | cc.cfg = cfg = GNUNET_CONFIGURATION_create(); |
201 | /* prepare */ | 201 | /* prepare */ |
202 | #if ENABLE_NLS | 202 | #if ENABLE_NLS |
203 | if (NULL != pd->gettext_domain) | 203 | if (NULL != pd->gettext_domain) |
204 | { | ||
205 | setlocale (LC_ALL, ""); | ||
206 | path = (NULL == pd->gettext_path) | ||
207 | ? GNUNET_OS_installation_get_path (GNUNET_OS_IPK_LOCALEDIR) | ||
208 | : GNUNET_strdup (pd->gettext_path); | ||
209 | if (NULL != path) | ||
210 | { | 204 | { |
211 | bindtextdomain (pd->gettext_domain, path); | 205 | setlocale(LC_ALL, ""); |
212 | GNUNET_free (path); | 206 | path = (NULL == pd->gettext_path) |
207 | ? GNUNET_OS_installation_get_path(GNUNET_OS_IPK_LOCALEDIR) | ||
208 | : GNUNET_strdup(pd->gettext_path); | ||
209 | if (NULL != path) | ||
210 | { | ||
211 | bindtextdomain(pd->gettext_domain, path); | ||
212 | GNUNET_free(path); | ||
213 | } | ||
214 | textdomain(pd->gettext_domain); | ||
213 | } | 215 | } |
214 | textdomain (pd->gettext_domain); | ||
215 | } | ||
216 | #endif | 216 | #endif |
217 | cnt = 0; | 217 | cnt = 0; |
218 | while (NULL != options[cnt].name) | 218 | while (NULL != options[cnt].name) |
219 | cnt++; | 219 | cnt++; |
220 | allopts = | 220 | allopts = |
221 | GNUNET_malloc ((cnt + 1) * sizeof (struct GNUNET_GETOPT_CommandLineOption) + | 221 | GNUNET_malloc((cnt + 1) * sizeof(struct GNUNET_GETOPT_CommandLineOption) + |
222 | sizeof (defoptions)); | 222 | sizeof(defoptions)); |
223 | GNUNET_memcpy (allopts, defoptions, sizeof (defoptions)); | 223 | GNUNET_memcpy(allopts, defoptions, sizeof(defoptions)); |
224 | GNUNET_memcpy (&allopts[sizeof (defoptions) / | 224 | GNUNET_memcpy(&allopts[sizeof(defoptions) / |
225 | sizeof (struct GNUNET_GETOPT_CommandLineOption)], | 225 | sizeof(struct GNUNET_GETOPT_CommandLineOption)], |
226 | options, | 226 | options, |
227 | (cnt + 1) * sizeof (struct GNUNET_GETOPT_CommandLineOption)); | 227 | (cnt + 1) * sizeof(struct GNUNET_GETOPT_CommandLineOption)); |
228 | cnt += sizeof (defoptions) / sizeof (struct GNUNET_GETOPT_CommandLineOption); | 228 | cnt += sizeof(defoptions) / sizeof(struct GNUNET_GETOPT_CommandLineOption); |
229 | qsort (allopts, | 229 | qsort(allopts, |
230 | cnt, | 230 | cnt, |
231 | sizeof (struct GNUNET_GETOPT_CommandLineOption), | 231 | sizeof(struct GNUNET_GETOPT_CommandLineOption), |
232 | &cmd_sorter); | 232 | &cmd_sorter); |
233 | loglev = NULL; | 233 | loglev = NULL; |
234 | xdg = getenv ("XDG_CONFIG_HOME"); | 234 | xdg = getenv("XDG_CONFIG_HOME"); |
235 | if (NULL != xdg) | 235 | if (NULL != xdg) |
236 | GNUNET_asprintf (&cfg_fn, | 236 | GNUNET_asprintf(&cfg_fn, |
237 | "%s%s%s", | 237 | "%s%s%s", |
238 | xdg, | 238 | xdg, |
239 | DIR_SEPARATOR_STR, | 239 | DIR_SEPARATOR_STR, |
240 | pd->config_file); | 240 | pd->config_file); |
241 | else | 241 | else |
242 | cfg_fn = GNUNET_strdup (pd->user_config_file); | 242 | cfg_fn = GNUNET_strdup(pd->user_config_file); |
243 | lpfx = GNUNET_strdup (binaryName); | 243 | lpfx = GNUNET_strdup(binaryName); |
244 | if (NULL != (spc = strstr (lpfx, " "))) | 244 | if (NULL != (spc = strstr(lpfx, " "))) |
245 | *spc = '\0'; | 245 | *spc = '\0'; |
246 | ret = GNUNET_GETOPT_run (binaryName, allopts, (unsigned int) argc, argv); | 246 | ret = GNUNET_GETOPT_run(binaryName, allopts, (unsigned int)argc, argv); |
247 | if ((GNUNET_OK > ret) || | 247 | if ((GNUNET_OK > ret) || |
248 | (GNUNET_OK != GNUNET_log_setup (lpfx, loglev, logfile))) | 248 | (GNUNET_OK != GNUNET_log_setup(lpfx, loglev, logfile))) |
249 | { | ||
250 | GNUNET_free (allopts); | ||
251 | GNUNET_free (lpfx); | ||
252 | goto cleanup; | ||
253 | } | ||
254 | if (NULL != cc.cfgfile) | ||
255 | { | ||
256 | if ((GNUNET_YES != GNUNET_DISK_file_test (cc.cfgfile)) || | ||
257 | (GNUNET_SYSERR == GNUNET_CONFIGURATION_load (cfg, cc.cfgfile))) | ||
258 | { | 249 | { |
259 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 250 | GNUNET_free(allopts); |
260 | _ ( | 251 | GNUNET_free(lpfx); |
261 | "Unreadable or malformed configuration file `%s', exit ...\n"), | ||
262 | cc.cfgfile); | ||
263 | ret = GNUNET_SYSERR; | ||
264 | GNUNET_free (allopts); | ||
265 | GNUNET_free (lpfx); | ||
266 | goto cleanup; | 252 | goto cleanup; |
267 | } | 253 | } |
268 | } | 254 | if (NULL != cc.cfgfile) |
269 | else | ||
270 | { | ||
271 | if (GNUNET_YES == GNUNET_DISK_file_test (cfg_fn)) | ||
272 | { | 255 | { |
273 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load (cfg, cfg_fn)) | 256 | if ((GNUNET_YES != GNUNET_DISK_file_test(cc.cfgfile)) || |
274 | { | 257 | (GNUNET_SYSERR == GNUNET_CONFIGURATION_load(cfg, cc.cfgfile))) |
275 | GNUNET_log ( | 258 | { |
276 | GNUNET_ERROR_TYPE_ERROR, | 259 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, |
277 | _ ( | 260 | _( |
278 | "Unreadable or malformed default configuration file `%s', exit ...\n"), | 261 | "Unreadable or malformed configuration file `%s', exit ...\n"), |
279 | cfg_fn); | 262 | cc.cfgfile); |
280 | ret = GNUNET_SYSERR; | 263 | ret = GNUNET_SYSERR; |
281 | GNUNET_free (allopts); | 264 | GNUNET_free(allopts); |
282 | GNUNET_free (lpfx); | 265 | GNUNET_free(lpfx); |
283 | goto cleanup; | 266 | goto cleanup; |
284 | } | 267 | } |
285 | } | 268 | } |
286 | else | 269 | else |
287 | { | 270 | { |
288 | GNUNET_free (cfg_fn); | 271 | if (GNUNET_YES == GNUNET_DISK_file_test(cfg_fn)) |
289 | cfg_fn = NULL; | 272 | { |
290 | if (GNUNET_OK != GNUNET_CONFIGURATION_load (cfg, NULL)) | 273 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load(cfg, cfg_fn)) |
291 | { | 274 | { |
292 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 275 | GNUNET_log( |
293 | _ ("Unreadable or malformed configuration, exit ...\n")); | 276 | GNUNET_ERROR_TYPE_ERROR, |
294 | ret = GNUNET_SYSERR; | 277 | _( |
295 | GNUNET_free (allopts); | 278 | "Unreadable or malformed default configuration file `%s', exit ...\n"), |
296 | GNUNET_free (lpfx); | 279 | cfg_fn); |
297 | goto cleanup; | 280 | ret = GNUNET_SYSERR; |
298 | } | 281 | GNUNET_free(allopts); |
282 | GNUNET_free(lpfx); | ||
283 | goto cleanup; | ||
284 | } | ||
285 | } | ||
286 | else | ||
287 | { | ||
288 | GNUNET_free(cfg_fn); | ||
289 | cfg_fn = NULL; | ||
290 | if (GNUNET_OK != GNUNET_CONFIGURATION_load(cfg, NULL)) | ||
291 | { | ||
292 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | ||
293 | _("Unreadable or malformed configuration, exit ...\n")); | ||
294 | ret = GNUNET_SYSERR; | ||
295 | GNUNET_free(allopts); | ||
296 | GNUNET_free(lpfx); | ||
297 | goto cleanup; | ||
298 | } | ||
299 | } | ||
299 | } | 300 | } |
300 | } | 301 | GNUNET_free(allopts); |
301 | GNUNET_free (allopts); | 302 | GNUNET_free(lpfx); |
302 | GNUNET_free (lpfx); | 303 | if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cc.cfg, |
303 | if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (cc.cfg, | 304 | "testing", |
305 | "skew_offset", | ||
306 | &skew_offset) && | ||
307 | (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(cc.cfg, | ||
304 | "testing", | 308 | "testing", |
305 | "skew_offset", | 309 | "skew_variance", |
306 | &skew_offset) && | 310 | &skew_variance))) |
307 | (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (cc.cfg, | 311 | { |
308 | "testing", | 312 | clock_offset = skew_offset - skew_variance; |
309 | "skew_variance", | 313 | GNUNET_TIME_set_offset(clock_offset); |
310 | &skew_variance))) | 314 | } |
311 | { | ||
312 | clock_offset = skew_offset - skew_variance; | ||
313 | GNUNET_TIME_set_offset (clock_offset); | ||
314 | } | ||
315 | /* ARM needs to know which configuration file to use when starting | 315 | /* ARM needs to know which configuration file to use when starting |
316 | services. If we got a command-line option *and* if nothing is | 316 | services. If we got a command-line option *and* if nothing is |
317 | specified in the configuration, remember the command-line option | 317 | specified in the configuration, remember the command-line option |
318 | in "cfg". This is typically really only having an effect if we | 318 | in "cfg". This is typically really only having an effect if we |
319 | are running code in src/arm/, as obviously the rest of the code | 319 | are running code in src/arm/, as obviously the rest of the code |
320 | has little business with ARM-specific options. */ | 320 | has little business with ARM-specific options. */ |
321 | if (GNUNET_YES != GNUNET_CONFIGURATION_have_value (cfg, "arm", "CONFIG")) | 321 | if (GNUNET_YES != GNUNET_CONFIGURATION_have_value(cfg, "arm", "CONFIG")) |
322 | { | 322 | { |
323 | if (NULL != cc.cfgfile) | 323 | if (NULL != cc.cfgfile) |
324 | GNUNET_CONFIGURATION_set_value_string (cfg, "arm", "CONFIG", cc.cfgfile); | 324 | GNUNET_CONFIGURATION_set_value_string(cfg, "arm", "CONFIG", cc.cfgfile); |
325 | else if (NULL != cfg_fn) | 325 | else if (NULL != cfg_fn) |
326 | GNUNET_CONFIGURATION_set_value_string (cfg, "arm", "CONFIG", cfg_fn); | 326 | GNUNET_CONFIGURATION_set_value_string(cfg, "arm", "CONFIG", cfg_fn); |
327 | } | 327 | } |
328 | 328 | ||
329 | /* run */ | 329 | /* run */ |
330 | cc.args = &argv[ret]; | 330 | cc.args = &argv[ret]; |
331 | if ((NULL == cc.cfgfile) && (NULL != cfg_fn)) | 331 | if ((NULL == cc.cfgfile) && (NULL != cfg_fn)) |
332 | cc.cfgfile = GNUNET_strdup (cfg_fn); | 332 | cc.cfgfile = GNUNET_strdup(cfg_fn); |
333 | if (GNUNET_NO == run_without_scheduler) | 333 | if (GNUNET_NO == run_without_scheduler) |
334 | { | 334 | { |
335 | GNUNET_SCHEDULER_run (&program_main, &cc); | 335 | GNUNET_SCHEDULER_run(&program_main, &cc); |
336 | } | 336 | } |
337 | else | 337 | else |
338 | { | 338 | { |
339 | GNUNET_RESOLVER_connect (cc.cfg); | 339 | GNUNET_RESOLVER_connect(cc.cfg); |
340 | cc.task (cc.task_cls, cc.args, cc.cfgfile, cc.cfg); | 340 | cc.task(cc.task_cls, cc.args, cc.cfgfile, cc.cfg); |
341 | } | 341 | } |
342 | ret = GNUNET_OK; | 342 | ret = GNUNET_OK; |
343 | cleanup: | 343 | cleanup: |
344 | GNUNET_CONFIGURATION_destroy (cfg); | 344 | GNUNET_CONFIGURATION_destroy(cfg); |
345 | GNUNET_free_non_null (cc.cfgfile); | 345 | GNUNET_free_non_null(cc.cfgfile); |
346 | GNUNET_free_non_null (cfg_fn); | 346 | GNUNET_free_non_null(cfg_fn); |
347 | GNUNET_free_non_null (loglev); | 347 | GNUNET_free_non_null(loglev); |
348 | GNUNET_free_non_null (logfile); | 348 | GNUNET_free_non_null(logfile); |
349 | return ret; | 349 | return ret; |
350 | } | 350 | } |
351 | 351 | ||
@@ -364,22 +364,22 @@ cleanup: | |||
364 | * @return #GNUNET_SYSERR on error, #GNUNET_OK on success | 364 | * @return #GNUNET_SYSERR on error, #GNUNET_OK on success |
365 | */ | 365 | */ |
366 | int | 366 | int |
367 | GNUNET_PROGRAM_run (int argc, | 367 | GNUNET_PROGRAM_run(int argc, |
368 | char *const *argv, | 368 | char *const *argv, |
369 | const char *binaryName, | 369 | const char *binaryName, |
370 | const char *binaryHelp, | 370 | const char *binaryHelp, |
371 | const struct GNUNET_GETOPT_CommandLineOption *options, | 371 | const struct GNUNET_GETOPT_CommandLineOption *options, |
372 | GNUNET_PROGRAM_Main task, | 372 | GNUNET_PROGRAM_Main task, |
373 | void *task_cls) | 373 | void *task_cls) |
374 | { | 374 | { |
375 | return GNUNET_PROGRAM_run2 (argc, | 375 | return GNUNET_PROGRAM_run2(argc, |
376 | argv, | 376 | argv, |
377 | binaryName, | 377 | binaryName, |
378 | binaryHelp, | 378 | binaryHelp, |
379 | options, | 379 | options, |
380 | task, | 380 | task, |
381 | task_cls, | 381 | task_cls, |
382 | GNUNET_NO); | 382 | GNUNET_NO); |
383 | } | 383 | } |
384 | 384 | ||
385 | 385 | ||