diff options
author | ng0 <ng0@n0.is> | 2019-09-08 12:33:09 +0000 |
---|---|---|
committer | ng0 <ng0@n0.is> | 2019-09-08 12:33:09 +0000 |
commit | d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb (patch) | |
tree | 9efd18ea7d425652085ed0bd5e8e45604bc5f6b9 /src/arm/gnunet-arm.c | |
parent | a0fce305c565c0937d917a92712f15e9c5736260 (diff) | |
download | gnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.tar.gz gnunet-d41ed82a4ea0cc8e1674b6d5d2c49fd6462610bb.zip |
uncrustify as demanded.
Diffstat (limited to 'src/arm/gnunet-arm.c')
-rw-r--r-- | src/arm/gnunet-arm.c | 840 |
1 files changed, 430 insertions, 410 deletions
diff --git a/src/arm/gnunet-arm.c b/src/arm/gnunet-arm.c index f96076231..3396a4dbe 100644 --- a/src/arm/gnunet-arm.c +++ b/src/arm/gnunet-arm.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 arm/gnunet-arm.c | 22 | * @file arm/gnunet-arm.c |
@@ -144,25 +144,25 @@ static struct GNUNET_ARM_Operation *op; | |||
144 | * were specified when gnunet-arm was run. | 144 | * were specified when gnunet-arm was run. |
145 | */ | 145 | */ |
146 | static void | 146 | static void |
147 | delete_files () | 147 | delete_files() |
148 | { | 148 | { |
149 | GNUNET_log ( | 149 | GNUNET_log( |
150 | GNUNET_ERROR_TYPE_DEBUG, | 150 | GNUNET_ERROR_TYPE_DEBUG, |
151 | "Will attempt to remove configuration file %s and service directory %s\n", | 151 | "Will attempt to remove configuration file %s and service directory %s\n", |
152 | config_file, | 152 | config_file, |
153 | dir); | 153 | dir); |
154 | if (0 != unlink (config_file)) | 154 | if (0 != unlink(config_file)) |
155 | { | 155 | { |
156 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 156 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, |
157 | _ ("Failed to remove configuration file %s\n"), | 157 | _("Failed to remove configuration file %s\n"), |
158 | config_file); | 158 | config_file); |
159 | } | 159 | } |
160 | if (GNUNET_OK != GNUNET_DISK_directory_remove (dir)) | 160 | if (GNUNET_OK != GNUNET_DISK_directory_remove(dir)) |
161 | { | 161 | { |
162 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 162 | GNUNET_log(GNUNET_ERROR_TYPE_WARNING, |
163 | _ ("Failed to remove servicehome directory %s\n"), | 163 | _("Failed to remove servicehome directory %s\n"), |
164 | dir); | 164 | dir); |
165 | } | 165 | } |
166 | } | 166 | } |
167 | 167 | ||
168 | 168 | ||
@@ -173,37 +173,37 @@ delete_files () | |||
173 | * @param cls closure, unused | 173 | * @param cls closure, unused |
174 | */ | 174 | */ |
175 | static void | 175 | static void |
176 | shutdown_task (void *cls) | 176 | shutdown_task(void *cls) |
177 | { | 177 | { |
178 | (void) cls; | 178 | (void)cls; |
179 | if (NULL != al_task) | 179 | if (NULL != al_task) |
180 | { | 180 | { |
181 | GNUNET_SCHEDULER_cancel (al_task); | 181 | GNUNET_SCHEDULER_cancel(al_task); |
182 | al_task = NULL; | 182 | al_task = NULL; |
183 | } | 183 | } |
184 | if (NULL != op) | 184 | if (NULL != op) |
185 | { | 185 | { |
186 | GNUNET_ARM_operation_cancel (op); | 186 | GNUNET_ARM_operation_cancel(op); |
187 | op = NULL; | 187 | op = NULL; |
188 | } | 188 | } |
189 | if (NULL != h) | 189 | if (NULL != h) |
190 | { | 190 | { |
191 | GNUNET_ARM_disconnect (h); | 191 | GNUNET_ARM_disconnect(h); |
192 | h = NULL; | 192 | h = NULL; |
193 | } | 193 | } |
194 | if (NULL != m) | 194 | if (NULL != m) |
195 | { | 195 | { |
196 | GNUNET_ARM_monitor_stop (m); | 196 | GNUNET_ARM_monitor_stop(m); |
197 | m = NULL; | 197 | m = NULL; |
198 | } | 198 | } |
199 | if (NULL != timeout_task) | 199 | if (NULL != timeout_task) |
200 | { | 200 | { |
201 | GNUNET_SCHEDULER_cancel (timeout_task); | 201 | GNUNET_SCHEDULER_cancel(timeout_task); |
202 | timeout_task = NULL; | 202 | timeout_task = NULL; |
203 | } | 203 | } |
204 | if ((GNUNET_YES == end) && (GNUNET_YES == delete)) | 204 | if ((GNUNET_YES == end) && (GNUNET_YES == delete)) |
205 | delete_files (); | 205 | delete_files(); |
206 | GNUNET_CONFIGURATION_destroy (cfg); | 206 | GNUNET_CONFIGURATION_destroy(cfg); |
207 | cfg = NULL; | 207 | cfg = NULL; |
208 | } | 208 | } |
209 | 209 | ||
@@ -215,16 +215,17 @@ shutdown_task (void *cls) | |||
215 | * @return a string interpretation of the request status | 215 | * @return a string interpretation of the request status |
216 | */ | 216 | */ |
217 | static const char * | 217 | static const char * |
218 | req_string (enum GNUNET_ARM_RequestStatus rs) | 218 | req_string(enum GNUNET_ARM_RequestStatus rs) |
219 | { | 219 | { |
220 | switch (rs) | 220 | switch (rs) |
221 | { | 221 | { |
222 | case GNUNET_ARM_REQUEST_SENT_OK: | 222 | case GNUNET_ARM_REQUEST_SENT_OK: |
223 | return _ ("Message was sent successfully"); | 223 | return _("Message was sent successfully"); |
224 | case GNUNET_ARM_REQUEST_DISCONNECTED: | 224 | |
225 | return _ ("We disconnected from ARM before we could send a request"); | 225 | case GNUNET_ARM_REQUEST_DISCONNECTED: |
226 | } | 226 | return _("We disconnected from ARM before we could send a request"); |
227 | return _ ("Unknown request status"); | 227 | } |
228 | return _("Unknown request status"); | ||
228 | } | 229 | } |
229 | 230 | ||
230 | 231 | ||
@@ -235,32 +236,41 @@ req_string (enum GNUNET_ARM_RequestStatus rs) | |||
235 | * @return a string interpretation | 236 | * @return a string interpretation |
236 | */ | 237 | */ |
237 | static const char * | 238 | static const char * |
238 | ret_string (enum GNUNET_ARM_Result result) | 239 | ret_string(enum GNUNET_ARM_Result result) |
239 | { | 240 | { |
240 | switch (result) | 241 | switch (result) |
241 | { | 242 | { |
242 | case GNUNET_ARM_RESULT_STOPPED: | 243 | case GNUNET_ARM_RESULT_STOPPED: |
243 | return _ ("is stopped"); | 244 | return _("is stopped"); |
244 | case GNUNET_ARM_RESULT_STARTING: | 245 | |
245 | return _ ("is starting"); | 246 | case GNUNET_ARM_RESULT_STARTING: |
246 | case GNUNET_ARM_RESULT_STOPPING: | 247 | return _("is starting"); |
247 | return _ ("is stopping"); | 248 | |
248 | case GNUNET_ARM_RESULT_IS_STARTING_ALREADY: | 249 | case GNUNET_ARM_RESULT_STOPPING: |
249 | return _ ("is starting already"); | 250 | return _("is stopping"); |
250 | case GNUNET_ARM_RESULT_IS_STOPPING_ALREADY: | 251 | |
251 | return _ ("is stopping already"); | 252 | case GNUNET_ARM_RESULT_IS_STARTING_ALREADY: |
252 | case GNUNET_ARM_RESULT_IS_STARTED_ALREADY: | 253 | return _("is starting already"); |
253 | return _ ("is started already"); | 254 | |
254 | case GNUNET_ARM_RESULT_IS_STOPPED_ALREADY: | 255 | case GNUNET_ARM_RESULT_IS_STOPPING_ALREADY: |
255 | return _ ("is stopped already"); | 256 | return _("is stopping already"); |
256 | case GNUNET_ARM_RESULT_IS_NOT_KNOWN: | 257 | |
257 | return _ ("service is not known to ARM"); | 258 | case GNUNET_ARM_RESULT_IS_STARTED_ALREADY: |
258 | case GNUNET_ARM_RESULT_START_FAILED: | 259 | return _("is started already"); |
259 | return _ ("service failed to start"); | 260 | |
260 | case GNUNET_ARM_RESULT_IN_SHUTDOWN: | 261 | case GNUNET_ARM_RESULT_IS_STOPPED_ALREADY: |
261 | return _ ("service cannot be manipulated because ARM is shutting down"); | 262 | return _("is stopped already"); |
262 | } | 263 | |
263 | return _ ("Unknown result code."); | 264 | case GNUNET_ARM_RESULT_IS_NOT_KNOWN: |
265 | return _("service is not known to ARM"); | ||
266 | |||
267 | case GNUNET_ARM_RESULT_START_FAILED: | ||
268 | return _("service failed to start"); | ||
269 | |||
270 | case GNUNET_ARM_RESULT_IN_SHUTDOWN: | ||
271 | return _("service cannot be manipulated because ARM is shutting down"); | ||
272 | } | ||
273 | return _("Unknown result code."); | ||
264 | } | 274 | } |
265 | 275 | ||
266 | 276 | ||
@@ -270,7 +280,7 @@ ret_string (enum GNUNET_ARM_Result result) | |||
270 | * @param cls closure | 280 | * @param cls closure |
271 | */ | 281 | */ |
272 | static void | 282 | static void |
273 | action_loop (void *cls); | 283 | action_loop(void *cls); |
274 | 284 | ||
275 | 285 | ||
276 | /** | 286 | /** |
@@ -283,18 +293,18 @@ action_loop (void *cls); | |||
283 | * #GNUNET_SYSERR on error. | 293 | * #GNUNET_SYSERR on error. |
284 | */ | 294 | */ |
285 | static void | 295 | static void |
286 | conn_status (void *cls, int connected) | 296 | conn_status(void *cls, int connected) |
287 | { | 297 | { |
288 | static int once; | 298 | static int once; |
289 | 299 | ||
290 | (void) cls; | 300 | (void)cls; |
291 | if ((GNUNET_SYSERR == connected) && (0 == once)) | 301 | if ((GNUNET_SYSERR == connected) && (0 == once)) |
292 | { | 302 | { |
293 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 303 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, |
294 | _ ("Fatal error initializing ARM API.\n")); | 304 | _("Fatal error initializing ARM API.\n")); |
295 | GNUNET_SCHEDULER_shutdown (); | 305 | GNUNET_SCHEDULER_shutdown(); |
296 | return; | 306 | return; |
297 | } | 307 | } |
298 | once = 1; | 308 | once = 1; |
299 | } | 309 | } |
300 | 310 | ||
@@ -311,32 +321,32 @@ conn_status (void *cls, int connected) | |||
311 | * according to ARM | 321 | * according to ARM |
312 | */ | 322 | */ |
313 | static void | 323 | static void |
314 | start_callback (void *cls, | 324 | start_callback(void *cls, |
315 | enum GNUNET_ARM_RequestStatus rs, | 325 | enum GNUNET_ARM_RequestStatus rs, |
316 | enum GNUNET_ARM_Result result) | 326 | enum GNUNET_ARM_Result result) |
317 | { | 327 | { |
318 | (void) cls; | 328 | (void)cls; |
319 | op = NULL; | 329 | op = NULL; |
320 | if (GNUNET_ARM_REQUEST_SENT_OK != rs) | 330 | if (GNUNET_ARM_REQUEST_SENT_OK != rs) |
321 | { | 331 | { |
322 | fprintf (stdout, | 332 | fprintf(stdout, |
323 | _ ("Failed to start the ARM service: %s\n"), | 333 | _("Failed to start the ARM service: %s\n"), |
324 | req_string (rs)); | 334 | req_string(rs)); |
325 | GNUNET_SCHEDULER_shutdown (); | 335 | GNUNET_SCHEDULER_shutdown(); |
326 | return; | 336 | return; |
327 | } | 337 | } |
328 | if ((GNUNET_ARM_RESULT_STARTING != result) && | 338 | if ((GNUNET_ARM_RESULT_STARTING != result) && |
329 | (GNUNET_ARM_RESULT_IS_STARTED_ALREADY != result)) | 339 | (GNUNET_ARM_RESULT_IS_STARTED_ALREADY != result)) |
330 | { | 340 | { |
331 | fprintf (stdout, | 341 | fprintf(stdout, |
332 | _ ("Failed to start the ARM service: %s\n"), | 342 | _("Failed to start the ARM service: %s\n"), |
333 | ret_string (result)); | 343 | ret_string(result)); |
334 | GNUNET_SCHEDULER_shutdown (); | 344 | GNUNET_SCHEDULER_shutdown(); |
335 | return; | 345 | return; |
336 | } | 346 | } |
337 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ARM service [re]start successful\n"); | 347 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "ARM service [re]start successful\n"); |
338 | start = 0; | 348 | start = 0; |
339 | al_task = GNUNET_SCHEDULER_add_now (&action_loop, NULL); | 349 | al_task = GNUNET_SCHEDULER_add_now(&action_loop, NULL); |
340 | } | 350 | } |
341 | 351 | ||
342 | 352 | ||
@@ -352,44 +362,44 @@ start_callback (void *cls, | |||
352 | * according to ARM | 362 | * according to ARM |
353 | */ | 363 | */ |
354 | static void | 364 | static void |
355 | stop_callback (void *cls, | 365 | stop_callback(void *cls, |
356 | enum GNUNET_ARM_RequestStatus rs, | 366 | enum GNUNET_ARM_RequestStatus rs, |
357 | enum GNUNET_ARM_Result result) | 367 | enum GNUNET_ARM_Result result) |
358 | { | 368 | { |
359 | char *msg; | 369 | char *msg; |
360 | 370 | ||
361 | (void) cls; | 371 | (void)cls; |
362 | op = NULL; | 372 | op = NULL; |
363 | if (GNUNET_ARM_REQUEST_SENT_OK != rs) | 373 | if (GNUNET_ARM_REQUEST_SENT_OK != rs) |
364 | { | 374 | { |
365 | GNUNET_asprintf (&msg, | 375 | GNUNET_asprintf(&msg, |
366 | "%s", | 376 | "%s", |
367 | _ ( | 377 | _( |
368 | "Failed to send a stop request to the ARM service: %s\n")); | 378 | "Failed to send a stop request to the ARM service: %s\n")); |
369 | fprintf (stdout, msg, req_string (rs)); | 379 | fprintf(stdout, msg, req_string(rs)); |
370 | GNUNET_free (msg); | 380 | GNUNET_free(msg); |
371 | GNUNET_SCHEDULER_shutdown (); | 381 | GNUNET_SCHEDULER_shutdown(); |
372 | return; | 382 | return; |
373 | } | 383 | } |
374 | if ((GNUNET_ARM_RESULT_STOPPING != result) && | 384 | if ((GNUNET_ARM_RESULT_STOPPING != result) && |
375 | (GNUNET_ARM_RESULT_STOPPED != result) && | 385 | (GNUNET_ARM_RESULT_STOPPED != result) && |
376 | (GNUNET_ARM_RESULT_IS_STOPPED_ALREADY != result)) | 386 | (GNUNET_ARM_RESULT_IS_STOPPED_ALREADY != result)) |
377 | { | 387 | { |
378 | fprintf (stdout, | 388 | fprintf(stdout, |
379 | _ ("Failed to stop the ARM service: %s\n"), | 389 | _("Failed to stop the ARM service: %s\n"), |
380 | ret_string (result)); | 390 | ret_string(result)); |
381 | GNUNET_SCHEDULER_shutdown (); | 391 | GNUNET_SCHEDULER_shutdown(); |
382 | return; | 392 | return; |
383 | } | 393 | } |
384 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ARM service shutdown successful\n"); | 394 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "ARM service shutdown successful\n"); |
385 | end = 0; | 395 | end = 0; |
386 | if (restart) | 396 | if (restart) |
387 | { | 397 | { |
388 | restart = 0; | 398 | restart = 0; |
389 | start = 1; | 399 | start = 1; |
390 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Initiating an ARM restart\n"); | 400 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Initiating an ARM restart\n"); |
391 | } | 401 | } |
392 | al_task = GNUNET_SCHEDULER_add_now (&action_loop, NULL); | 402 | al_task = GNUNET_SCHEDULER_add_now(&action_loop, NULL); |
393 | } | 403 | } |
394 | 404 | ||
395 | 405 | ||
@@ -405,37 +415,37 @@ stop_callback (void *cls, | |||
405 | * according to ARM | 415 | * according to ARM |
406 | */ | 416 | */ |
407 | static void | 417 | static void |
408 | init_callback (void *cls, | 418 | init_callback(void *cls, |
409 | enum GNUNET_ARM_RequestStatus rs, | 419 | enum GNUNET_ARM_RequestStatus rs, |
410 | enum GNUNET_ARM_Result result) | 420 | enum GNUNET_ARM_Result result) |
411 | { | 421 | { |
412 | (void) cls; | 422 | (void)cls; |
413 | op = NULL; | 423 | op = NULL; |
414 | if (GNUNET_ARM_REQUEST_SENT_OK != rs) | 424 | if (GNUNET_ARM_REQUEST_SENT_OK != rs) |
415 | { | 425 | { |
416 | fprintf (stdout, | 426 | fprintf(stdout, |
417 | _ ("Failed to send a request to start the `%s' service: %s\n"), | 427 | _("Failed to send a request to start the `%s' service: %s\n"), |
418 | init, | 428 | init, |
419 | req_string (rs)); | 429 | req_string(rs)); |
420 | GNUNET_SCHEDULER_shutdown (); | 430 | GNUNET_SCHEDULER_shutdown(); |
421 | return; | 431 | return; |
422 | } | 432 | } |
423 | if ((GNUNET_ARM_RESULT_STARTING != result) && | 433 | if ((GNUNET_ARM_RESULT_STARTING != result) && |
424 | (GNUNET_ARM_RESULT_IS_STARTED_ALREADY != result)) | 434 | (GNUNET_ARM_RESULT_IS_STARTED_ALREADY != result)) |
425 | { | 435 | { |
426 | fprintf (stdout, | 436 | fprintf(stdout, |
427 | _ ("Failed to start the `%s' service: %s\n"), | 437 | _("Failed to start the `%s' service: %s\n"), |
428 | init, | 438 | init, |
429 | ret_string (result)); | 439 | ret_string(result)); |
430 | GNUNET_SCHEDULER_shutdown (); | 440 | GNUNET_SCHEDULER_shutdown(); |
431 | return; | 441 | return; |
432 | } | 442 | } |
433 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 443 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
434 | "Service %s [re]started successfully\n", | 444 | "Service %s [re]started successfully\n", |
435 | init); | 445 | init); |
436 | GNUNET_free (init); | 446 | GNUNET_free(init); |
437 | init = NULL; | 447 | init = NULL; |
438 | al_task = GNUNET_SCHEDULER_add_now (&action_loop, NULL); | 448 | al_task = GNUNET_SCHEDULER_add_now(&action_loop, NULL); |
439 | } | 449 | } |
440 | 450 | ||
441 | 451 | ||
@@ -451,42 +461,42 @@ init_callback (void *cls, | |||
451 | * according to ARM | 461 | * according to ARM |
452 | */ | 462 | */ |
453 | static void | 463 | static void |
454 | term_callback (void *cls, | 464 | term_callback(void *cls, |
455 | enum GNUNET_ARM_RequestStatus rs, | 465 | enum GNUNET_ARM_RequestStatus rs, |
456 | enum GNUNET_ARM_Result result) | 466 | enum GNUNET_ARM_Result result) |
457 | { | 467 | { |
458 | char *msg; | 468 | char *msg; |
459 | 469 | ||
460 | (void) cls; | 470 | (void)cls; |
461 | op = NULL; | 471 | op = NULL; |
462 | if (GNUNET_ARM_REQUEST_SENT_OK != rs) | 472 | if (GNUNET_ARM_REQUEST_SENT_OK != rs) |
463 | { | 473 | { |
464 | GNUNET_asprintf (&msg, | 474 | GNUNET_asprintf(&msg, |
465 | _ ( | 475 | _( |
466 | "Failed to send a request to kill the `%s' service: %%s\n"), | 476 | "Failed to send a request to kill the `%s' service: %%s\n"), |
467 | term); | 477 | term); |
468 | fprintf (stdout, msg, req_string (rs)); | 478 | fprintf(stdout, msg, req_string(rs)); |
469 | GNUNET_free (msg); | 479 | GNUNET_free(msg); |
470 | GNUNET_SCHEDULER_shutdown (); | 480 | GNUNET_SCHEDULER_shutdown(); |
471 | return; | 481 | return; |
472 | } | 482 | } |
473 | if ((GNUNET_ARM_RESULT_STOPPED != result) && | 483 | if ((GNUNET_ARM_RESULT_STOPPED != result) && |
474 | (GNUNET_ARM_RESULT_IS_STOPPED_ALREADY != result)) | 484 | (GNUNET_ARM_RESULT_IS_STOPPED_ALREADY != result)) |
475 | { | 485 | { |
476 | fprintf (stdout, | 486 | fprintf(stdout, |
477 | _ ("Failed to kill the `%s' service: %s\n"), | 487 | _("Failed to kill the `%s' service: %s\n"), |
478 | term, | 488 | term, |
479 | ret_string (result)); | 489 | ret_string(result)); |
480 | GNUNET_SCHEDULER_shutdown (); | 490 | GNUNET_SCHEDULER_shutdown(); |
481 | return; | 491 | return; |
482 | } | 492 | } |
483 | 493 | ||
484 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 494 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
485 | "Service %s stopped successfully\n", | 495 | "Service %s stopped successfully\n", |
486 | term); | 496 | term); |
487 | GNUNET_free (term); | 497 | GNUNET_free(term); |
488 | term = NULL; | 498 | term = NULL; |
489 | al_task = GNUNET_SCHEDULER_add_now (&action_loop, NULL); | 499 | al_task = GNUNET_SCHEDULER_add_now(&action_loop, NULL); |
490 | } | 500 | } |
491 | 501 | ||
492 | 502 | ||
@@ -501,39 +511,39 @@ term_callback (void *cls, | |||
501 | * @param list list of services that are running | 511 | * @param list list of services that are running |
502 | */ | 512 | */ |
503 | static void | 513 | static void |
504 | list_callback (void *cls, | 514 | list_callback(void *cls, |
505 | enum GNUNET_ARM_RequestStatus rs, | 515 | enum GNUNET_ARM_RequestStatus rs, |
506 | unsigned int count, | 516 | unsigned int count, |
507 | const char *const *list) | 517 | const char *const *list) |
508 | { | 518 | { |
509 | (void) cls; | 519 | (void)cls; |
510 | op = NULL; | 520 | op = NULL; |
511 | if (GNUNET_ARM_REQUEST_SENT_OK != rs) | 521 | if (GNUNET_ARM_REQUEST_SENT_OK != rs) |
512 | { | 522 | { |
513 | char *msg; | 523 | char *msg; |
514 | 524 | ||
515 | GNUNET_asprintf (&msg, | 525 | GNUNET_asprintf(&msg, |
516 | "%s", | 526 | "%s", |
517 | _ ("Failed to request a list of services: %s\n")); | 527 | _("Failed to request a list of services: %s\n")); |
518 | fprintf (stdout, msg, req_string (rs)); | 528 | fprintf(stdout, msg, req_string(rs)); |
519 | GNUNET_free (msg); | 529 | GNUNET_free(msg); |
520 | ret = 3; | 530 | ret = 3; |
521 | GNUNET_SCHEDULER_shutdown (); | 531 | GNUNET_SCHEDULER_shutdown(); |
522 | } | 532 | } |
523 | if (NULL == list) | 533 | if (NULL == list) |
524 | { | 534 | { |
525 | fprintf (stderr, | 535 | fprintf(stderr, |
526 | "%s", | 536 | "%s", |
527 | _ ("Error communicating with ARM. ARM not running?\n")); | 537 | _("Error communicating with ARM. ARM not running?\n")); |
528 | GNUNET_SCHEDULER_shutdown (); | 538 | GNUNET_SCHEDULER_shutdown(); |
529 | ret = 3; | 539 | ret = 3; |
530 | return; | 540 | return; |
531 | } | 541 | } |
532 | if (! quiet) | 542 | if (!quiet) |
533 | fprintf (stdout, "%s", _ ("Running services:\n")); | 543 | fprintf(stdout, "%s", _("Running services:\n")); |
534 | for (unsigned int i = 0; i < count; i++) | 544 | for (unsigned int i = 0; i < count; i++) |
535 | fprintf (stdout, "%s\n", list[i]); | 545 | fprintf(stdout, "%s\n", list[i]); |
536 | al_task = GNUNET_SCHEDULER_add_now (&action_loop, NULL); | 546 | al_task = GNUNET_SCHEDULER_add_now(&action_loop, NULL); |
537 | } | 547 | } |
538 | 548 | ||
539 | 549 | ||
@@ -544,85 +554,91 @@ list_callback (void *cls, | |||
544 | * @param cls closure, unused | 554 | * @param cls closure, unused |
545 | */ | 555 | */ |
546 | static void | 556 | static void |
547 | action_loop (void *cls) | 557 | action_loop(void *cls) |
548 | { | 558 | { |
549 | (void) cls; | 559 | (void)cls; |
550 | al_task = NULL; | 560 | al_task = NULL; |
551 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Running requested actions\n"); | 561 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Running requested actions\n"); |
552 | while (1) | 562 | while (1) |
553 | { | ||
554 | switch (phase++) | ||
555 | { | 563 | { |
556 | case 0: | 564 | switch (phase++) |
557 | if (NULL != term) | 565 | { |
558 | { | 566 | case 0: |
559 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Termination action\n"); | 567 | if (NULL != term) |
560 | op = GNUNET_ARM_request_service_stop (h, term, &term_callback, NULL); | 568 | { |
561 | return; | 569 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Termination action\n"); |
562 | } | 570 | op = GNUNET_ARM_request_service_stop(h, term, &term_callback, NULL); |
563 | break; | 571 | return; |
564 | case 1: | 572 | } |
565 | if (end || restart) | 573 | break; |
566 | { | 574 | |
567 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "End action\n"); | 575 | case 1: |
568 | op = GNUNET_ARM_request_service_stop (h, "arm", &stop_callback, NULL); | 576 | if (end || restart) |
569 | return; | 577 | { |
570 | } | 578 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "End action\n"); |
571 | break; | 579 | op = GNUNET_ARM_request_service_stop(h, "arm", &stop_callback, NULL); |
572 | case 2: | 580 | return; |
573 | if (start) | 581 | } |
574 | { | 582 | break; |
575 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Start action\n"); | 583 | |
576 | op = | 584 | case 2: |
577 | GNUNET_ARM_request_service_start (h, | 585 | if (start) |
578 | "arm", | 586 | { |
579 | (no_stdout | 587 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Start action\n"); |
580 | ? 0 | 588 | op = |
581 | : GNUNET_OS_INHERIT_STD_OUT) | | 589 | GNUNET_ARM_request_service_start(h, |
582 | (no_stderr | 590 | "arm", |
583 | ? 0 | 591 | (no_stdout |
584 | : GNUNET_OS_INHERIT_STD_ERR), | 592 | ? 0 |
585 | &start_callback, | 593 | : GNUNET_OS_INHERIT_STD_OUT) | |
586 | NULL); | 594 | (no_stderr |
587 | return; | 595 | ? 0 |
588 | } | 596 | : GNUNET_OS_INHERIT_STD_ERR), |
589 | break; | 597 | &start_callback, |
590 | case 3: | 598 | NULL); |
591 | if (NULL != init) | 599 | return; |
592 | { | 600 | } |
593 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Initialization action\n"); | 601 | break; |
594 | op = GNUNET_ARM_request_service_start (h, | 602 | |
595 | init, | 603 | case 3: |
596 | GNUNET_OS_INHERIT_STD_NONE, | 604 | if (NULL != init) |
597 | &init_callback, | 605 | { |
598 | NULL); | 606 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Initialization action\n"); |
599 | return; | 607 | op = GNUNET_ARM_request_service_start(h, |
600 | } | 608 | init, |
601 | break; | 609 | GNUNET_OS_INHERIT_STD_NONE, |
602 | case 4: | 610 | &init_callback, |
603 | if (list) | 611 | NULL); |
604 | { | 612 | return; |
605 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 613 | } |
606 | "Going to list all running services controlled by ARM.\n"); | 614 | break; |
607 | op = GNUNET_ARM_request_service_list (h, &list_callback, &list); | 615 | |
608 | return; | 616 | case 4: |
609 | } | 617 | if (list) |
610 | break; | 618 | { |
611 | case 5: | 619 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
612 | if (monitor) | 620 | "Going to list all running services controlled by ARM.\n"); |
613 | { | 621 | op = GNUNET_ARM_request_service_list(h, &list_callback, &list); |
614 | if (! quiet) | 622 | return; |
615 | fprintf (stderr, _ ("Now only monitoring, press CTRL-C to stop.\n")); | 623 | } |
616 | quiet = | 624 | break; |
617 | 0; /* does not make sense to stay quiet in monitor mode at this time */ | 625 | |
618 | return; /* done with tasks, just monitor */ | 626 | case 5: |
619 | } | 627 | if (monitor) |
620 | break; | 628 | { |
621 | default: /* last phase */ | 629 | if (!quiet) |
622 | GNUNET_SCHEDULER_shutdown (); | 630 | fprintf(stderr, _("Now only monitoring, press CTRL-C to stop.\n")); |
623 | return; | 631 | quiet = |
632 | 0; /* does not make sense to stay quiet in monitor mode at this time */ | ||
633 | return; /* done with tasks, just monitor */ | ||
634 | } | ||
635 | break; | ||
636 | |||
637 | default: /* last phase */ | ||
638 | GNUNET_SCHEDULER_shutdown(); | ||
639 | return; | ||
640 | } | ||
624 | } | 641 | } |
625 | } | ||
626 | } | 642 | } |
627 | 643 | ||
628 | 644 | ||
@@ -634,44 +650,48 @@ action_loop (void *cls) | |||
634 | * @param status status of the service | 650 | * @param status status of the service |
635 | */ | 651 | */ |
636 | static void | 652 | static void |
637 | srv_status (void *cls, | 653 | srv_status(void *cls, |
638 | const char *service, | 654 | const char *service, |
639 | enum GNUNET_ARM_ServiceStatus status) | 655 | enum GNUNET_ARM_ServiceStatus status) |
640 | { | 656 | { |
641 | const char *msg; | 657 | const char *msg; |
642 | 658 | ||
643 | (void) cls; | 659 | (void)cls; |
644 | switch (status) | 660 | switch (status) |
645 | { | 661 | { |
646 | case GNUNET_ARM_SERVICE_MONITORING_STARTED: | 662 | case GNUNET_ARM_SERVICE_MONITORING_STARTED: |
647 | return; /* this should be done silently */ | 663 | return; /* this should be done silently */ |
648 | case GNUNET_ARM_SERVICE_STOPPED: | 664 | |
649 | msg = _ ("Stopped %s.\n"); | 665 | case GNUNET_ARM_SERVICE_STOPPED: |
650 | break; | 666 | msg = _("Stopped %s.\n"); |
651 | case GNUNET_ARM_SERVICE_STARTING: | 667 | break; |
652 | msg = _ ("Starting %s...\n"); | 668 | |
653 | break; | 669 | case GNUNET_ARM_SERVICE_STARTING: |
654 | case GNUNET_ARM_SERVICE_STOPPING: | 670 | msg = _("Starting %s...\n"); |
655 | msg = _ ("Stopping %s...\n"); | 671 | break; |
656 | break; | 672 | |
657 | default: | 673 | case GNUNET_ARM_SERVICE_STOPPING: |
658 | msg = NULL; | 674 | msg = _("Stopping %s...\n"); |
659 | break; | 675 | break; |
660 | } | 676 | |
661 | if (! quiet) | 677 | default: |
662 | { | 678 | msg = NULL; |
663 | if (NULL != msg) | 679 | break; |
664 | fprintf (stderr, msg, service); | 680 | } |
665 | else | 681 | if (!quiet) |
666 | fprintf (stderr, | 682 | { |
667 | _ ("Unknown status %u for service %s.\n"), | 683 | if (NULL != msg) |
668 | status, | 684 | fprintf(stderr, msg, service); |
669 | service); | 685 | else |
670 | } | 686 | fprintf(stderr, |
671 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 687 | _("Unknown status %u for service %s.\n"), |
672 | "Got service %s status %d\n", | 688 | status, |
673 | service, | 689 | service); |
674 | (int) status); | 690 | } |
691 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, | ||
692 | "Got service %s status %d\n", | ||
693 | service, | ||
694 | (int)status); | ||
675 | } | 695 | } |
676 | 696 | ||
677 | 697 | ||
@@ -679,12 +699,12 @@ srv_status (void *cls, | |||
679 | * Task run on timeout (if -T is given). | 699 | * Task run on timeout (if -T is given). |
680 | */ | 700 | */ |
681 | static void | 701 | static void |
682 | timeout_task_cb (void *cls) | 702 | timeout_task_cb(void *cls) |
683 | { | 703 | { |
684 | (void) cls; | 704 | (void)cls; |
685 | timeout_task = NULL; | 705 | timeout_task = NULL; |
686 | ret = 2; | 706 | ret = 2; |
687 | GNUNET_SCHEDULER_shutdown (); | 707 | GNUNET_SCHEDULER_shutdown(); |
688 | } | 708 | } |
689 | 709 | ||
690 | 710 | ||
@@ -697,34 +717,34 @@ timeout_task_cb (void *cls) | |||
697 | * @param c configuration | 717 | * @param c configuration |
698 | */ | 718 | */ |
699 | static void | 719 | static void |
700 | run (void *cls, | 720 | run(void *cls, |
701 | char *const *args, | 721 | char *const *args, |
702 | const char *cfgfile, | 722 | const char *cfgfile, |
703 | const struct GNUNET_CONFIGURATION_Handle *c) | 723 | const struct GNUNET_CONFIGURATION_Handle *c) |
704 | { | 724 | { |
705 | (void) cls; | 725 | (void)cls; |
706 | (void) args; | 726 | (void)args; |
707 | (void) cfgfile; | 727 | (void)cfgfile; |
708 | cfg = GNUNET_CONFIGURATION_dup (c); | 728 | cfg = GNUNET_CONFIGURATION_dup(c); |
709 | if (GNUNET_OK != | 729 | if (GNUNET_OK != |
710 | GNUNET_CONFIGURATION_get_value_string (cfg, "PATHS", "GNUNET_HOME", &dir)) | 730 | GNUNET_CONFIGURATION_get_value_string(cfg, "PATHS", "GNUNET_HOME", &dir)) |
711 | { | 731 | { |
712 | GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "PATHS", "GNUNET_HOME"); | 732 | GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, "PATHS", "GNUNET_HOME"); |
713 | return; | 733 | return; |
714 | } | 734 | } |
715 | (void) GNUNET_CONFIGURATION_get_value_filename (cfg, | 735 | (void)GNUNET_CONFIGURATION_get_value_filename(cfg, |
716 | "arm", | 736 | "arm", |
717 | "CONFIG", | 737 | "CONFIG", |
718 | &config_file); | 738 | &config_file); |
719 | if (NULL == (h = GNUNET_ARM_connect (cfg, &conn_status, NULL))) | 739 | if (NULL == (h = GNUNET_ARM_connect(cfg, &conn_status, NULL))) |
720 | return; | 740 | return; |
721 | if (monitor) | 741 | if (monitor) |
722 | m = GNUNET_ARM_monitor_start (cfg, &srv_status, NULL); | 742 | m = GNUNET_ARM_monitor_start(cfg, &srv_status, NULL); |
723 | al_task = GNUNET_SCHEDULER_add_now (&action_loop, NULL); | 743 | al_task = GNUNET_SCHEDULER_add_now(&action_loop, NULL); |
724 | GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL); | 744 | GNUNET_SCHEDULER_add_shutdown(&shutdown_task, NULL); |
725 | if (0 != timeout.rel_value_us) | 745 | if (0 != timeout.rel_value_us) |
726 | timeout_task = | 746 | timeout_task = |
727 | GNUNET_SCHEDULER_add_delayed (timeout, &timeout_task_cb, NULL); | 747 | GNUNET_SCHEDULER_add_delayed(timeout, &timeout_task_cb, NULL); |
728 | } | 748 | } |
729 | 749 | ||
730 | 750 | ||
@@ -736,88 +756,88 @@ run (void *cls, | |||
736 | * @return 0 ok, 1 on error, 2 on timeout | 756 | * @return 0 ok, 1 on error, 2 on timeout |
737 | */ | 757 | */ |
738 | int | 758 | int |
739 | main (int argc, char *const *argv) | 759 | main(int argc, char *const *argv) |
740 | { | 760 | { |
741 | struct GNUNET_GETOPT_CommandLineOption options[] = | 761 | struct GNUNET_GETOPT_CommandLineOption options[] = |
742 | {GNUNET_GETOPT_option_flag ('e', | 762 | { GNUNET_GETOPT_option_flag('e', |
743 | "end", | 763 | "end", |
744 | gettext_noop ("stop all GNUnet services"), | 764 | gettext_noop("stop all GNUnet services"), |
745 | &end), | 765 | &end), |
746 | GNUNET_GETOPT_option_string ('i', | 766 | GNUNET_GETOPT_option_string('i', |
747 | "init", | 767 | "init", |
748 | "SERVICE", | 768 | "SERVICE", |
749 | gettext_noop ("start a particular service"), | 769 | gettext_noop("start a particular service"), |
750 | &init), | 770 | &init), |
751 | GNUNET_GETOPT_option_string ('k', | 771 | GNUNET_GETOPT_option_string('k', |
752 | "kill", | 772 | "kill", |
753 | "SERVICE", | 773 | "SERVICE", |
754 | gettext_noop ("stop a particular service"), | 774 | gettext_noop("stop a particular service"), |
755 | &term), | 775 | &term), |
756 | GNUNET_GETOPT_option_flag ('s', | 776 | GNUNET_GETOPT_option_flag('s', |
757 | "start", | 777 | "start", |
758 | gettext_noop ( | 778 | gettext_noop( |
759 | "start all GNUnet default services"), | 779 | "start all GNUnet default services"), |
760 | &start), | 780 | &start), |
761 | GNUNET_GETOPT_option_flag ('r', | 781 | GNUNET_GETOPT_option_flag('r', |
762 | "restart", | 782 | "restart", |
763 | gettext_noop ( | 783 | gettext_noop( |
764 | "stop and start all GNUnet default services"), | 784 | "stop and start all GNUnet default services"), |
765 | &restart), | 785 | &restart), |
766 | GNUNET_GETOPT_option_flag ('d', | 786 | GNUNET_GETOPT_option_flag('d', |
767 | "delete", | 787 | "delete", |
768 | gettext_noop ( | 788 | gettext_noop( |
769 | "delete config file and directory on exit"), | 789 | "delete config file and directory on exit"), |
770 | &delete), | 790 | &delete), |
771 | GNUNET_GETOPT_option_flag ('m', | 791 | GNUNET_GETOPT_option_flag('m', |
772 | "monitor", | 792 | "monitor", |
773 | gettext_noop ("monitor ARM activities"), | 793 | gettext_noop("monitor ARM activities"), |
774 | &monitor), | 794 | &monitor), |
775 | GNUNET_GETOPT_option_flag ('q', | 795 | GNUNET_GETOPT_option_flag('q', |
776 | "quiet", | 796 | "quiet", |
777 | gettext_noop ("don't print status messages"), | 797 | gettext_noop("don't print status messages"), |
778 | &quiet), | 798 | &quiet), |
779 | GNUNET_GETOPT_option_relative_time ( | 799 | GNUNET_GETOPT_option_relative_time( |
780 | 'T', | 800 | 'T', |
781 | "timeout", | 801 | "timeout", |
782 | "DELAY", | 802 | "DELAY", |
783 | gettext_noop ( | 803 | gettext_noop( |
784 | "exit with error status if operation does not finish after DELAY"), | 804 | "exit with error status if operation does not finish after DELAY"), |
785 | &timeout), | 805 | &timeout), |
786 | GNUNET_GETOPT_option_flag ('I', | 806 | GNUNET_GETOPT_option_flag('I', |
787 | "info", | 807 | "info", |
788 | gettext_noop ( | 808 | gettext_noop( |
789 | "list currently running services"), | 809 | "list currently running services"), |
790 | &list), | 810 | &list), |
791 | GNUNET_GETOPT_option_flag ( | 811 | GNUNET_GETOPT_option_flag( |
792 | 'O', | 812 | 'O', |
793 | "no-stdout", | 813 | "no-stdout", |
794 | gettext_noop ("don't let gnunet-service-arm inherit standard output"), | 814 | gettext_noop("don't let gnunet-service-arm inherit standard output"), |
795 | &no_stdout), | 815 | &no_stdout), |
796 | GNUNET_GETOPT_option_flag ( | 816 | GNUNET_GETOPT_option_flag( |
797 | 'E', | 817 | 'E', |
798 | "no-stderr", | 818 | "no-stderr", |
799 | gettext_noop ("don't let gnunet-service-arm inherit standard error"), | 819 | gettext_noop("don't let gnunet-service-arm inherit standard error"), |
800 | &no_stderr), | 820 | &no_stderr), |
801 | GNUNET_GETOPT_OPTION_END}; | 821 | GNUNET_GETOPT_OPTION_END }; |
802 | int lret; | 822 | int lret; |
803 | 823 | ||
804 | if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv)) | 824 | if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv)) |
805 | return 2; | 825 | return 2; |
806 | if (GNUNET_OK == | 826 | if (GNUNET_OK == |
807 | (lret = GNUNET_PROGRAM_run ( | 827 | (lret = GNUNET_PROGRAM_run( |
808 | argc, | 828 | argc, |
809 | argv, | 829 | argv, |
810 | "gnunet-arm", | 830 | "gnunet-arm", |
811 | gettext_noop ( | 831 | gettext_noop( |
812 | "Control services and the Automated Restart Manager (ARM)"), | 832 | "Control services and the Automated Restart Manager (ARM)"), |
813 | options, | 833 | options, |
814 | &run, | 834 | &run, |
815 | NULL))) | 835 | NULL))) |
816 | { | 836 | { |
817 | GNUNET_free ((void *) argv); | 837 | GNUNET_free((void *)argv); |
818 | return ret; | 838 | return ret; |
819 | } | 839 | } |
820 | GNUNET_free ((void *) argv); | 840 | GNUNET_free((void *)argv); |
821 | return lret; | 841 | return lret; |
822 | } | 842 | } |
823 | 843 | ||