diff options
Diffstat (limited to 'src/arm/gnunet-service-arm.c')
-rw-r--r-- | src/arm/gnunet-service-arm.c | 2268 |
1 files changed, 1135 insertions, 1133 deletions
diff --git a/src/arm/gnunet-service-arm.c b/src/arm/gnunet-service-arm.c index b0f7e07c4..e8c740235 100644 --- a/src/arm/gnunet-service-arm.c +++ b/src/arm/gnunet-service-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-service-arm.c | 22 | * @file arm/gnunet-service-arm.c |
@@ -29,10 +29,10 @@ | |||
29 | #include "gnunet_protocols.h" | 29 | #include "gnunet_protocols.h" |
30 | #include "arm.h" | 30 | #include "arm.h" |
31 | 31 | ||
32 | #define LOG(kind, ...) GNUNET_log_from (kind, "util", __VA_ARGS__) | 32 | #define LOG(kind, ...) GNUNET_log_from(kind, "util", __VA_ARGS__) |
33 | 33 | ||
34 | #define LOG_STRERROR(kind, syscall) \ | 34 | #define LOG_STRERROR(kind, syscall) \ |
35 | GNUNET_log_from_strerror (kind, "util", syscall) | 35 | GNUNET_log_from_strerror(kind, "util", syscall) |
36 | 36 | ||
37 | 37 | ||
38 | #if HAVE_WAIT4 | 38 | #if HAVE_WAIT4 |
@@ -65,8 +65,7 @@ struct ServiceList; | |||
65 | /** | 65 | /** |
66 | * Record with information about a listen socket we have open. | 66 | * Record with information about a listen socket we have open. |
67 | */ | 67 | */ |
68 | struct ServiceListeningInfo | 68 | struct ServiceListeningInfo { |
69 | { | ||
70 | /** | 69 | /** |
71 | * This is a linked list. | 70 | * This is a linked list. |
72 | */ | 71 | */ |
@@ -107,8 +106,7 @@ struct ServiceListeningInfo | |||
107 | /** | 106 | /** |
108 | * List of our services. | 107 | * List of our services. |
109 | */ | 108 | */ |
110 | struct ServiceList | 109 | struct ServiceList { |
111 | { | ||
112 | /** | 110 | /** |
113 | * This is a doubly-linked list. | 111 | * This is a doubly-linked list. |
114 | */ | 112 | */ |
@@ -280,30 +278,30 @@ static struct GNUNET_NotificationContext *notifier; | |||
280 | * parameter is ignore on systems other than LINUX | 278 | * parameter is ignore on systems other than LINUX |
281 | */ | 279 | */ |
282 | static void | 280 | static void |
283 | add_unixpath (struct sockaddr **saddrs, | 281 | add_unixpath(struct sockaddr **saddrs, |
284 | socklen_t *saddrlens, | 282 | socklen_t *saddrlens, |
285 | const char *unixpath, | 283 | const char *unixpath, |
286 | int abstract) | 284 | int abstract) |
287 | { | 285 | { |
288 | #ifdef AF_UNIX | 286 | #ifdef AF_UNIX |
289 | struct sockaddr_un *un; | 287 | struct sockaddr_un *un; |
290 | 288 | ||
291 | un = GNUNET_new (struct sockaddr_un); | 289 | un = GNUNET_new(struct sockaddr_un); |
292 | un->sun_family = AF_UNIX; | 290 | un->sun_family = AF_UNIX; |
293 | GNUNET_strlcpy (un->sun_path, unixpath, sizeof (un->sun_path)); | 291 | GNUNET_strlcpy(un->sun_path, unixpath, sizeof(un->sun_path)); |
294 | #ifdef LINUX | 292 | #ifdef LINUX |
295 | if (GNUNET_YES == abstract) | 293 | if (GNUNET_YES == abstract) |
296 | un->sun_path[0] = '\0'; | 294 | un->sun_path[0] = '\0'; |
297 | #endif | 295 | #endif |
298 | #if HAVE_SOCKADDR_UN_SUN_LEN | 296 | #if HAVE_SOCKADDR_UN_SUN_LEN |
299 | un->sun_len = (u_char) sizeof (struct sockaddr_un); | 297 | un->sun_len = (u_char)sizeof(struct sockaddr_un); |
300 | #endif | 298 | #endif |
301 | *saddrs = (struct sockaddr *) un; | 299 | *saddrs = (struct sockaddr *)un; |
302 | *saddrlens = sizeof (struct sockaddr_un); | 300 | *saddrlens = sizeof(struct sockaddr_un); |
303 | #else | 301 | #else |
304 | /* this function should never be called | 302 | /* this function should never be called |
305 | * unless AF_UNIX is defined! */ | 303 | * unless AF_UNIX is defined! */ |
306 | GNUNET_assert (0); | 304 | GNUNET_assert(0); |
307 | #endif | 305 | #endif |
308 | } | 306 | } |
309 | 307 | ||
@@ -329,10 +327,10 @@ add_unixpath (struct sockaddr **saddrs, | |||
329 | * set to NULL). | 327 | * set to NULL). |
330 | */ | 328 | */ |
331 | static int | 329 | static int |
332 | get_server_addresses (const char *service_name, | 330 | get_server_addresses(const char *service_name, |
333 | const struct GNUNET_CONFIGURATION_Handle *cfg, | 331 | const struct GNUNET_CONFIGURATION_Handle *cfg, |
334 | struct sockaddr ***addrs, | 332 | struct sockaddr ***addrs, |
335 | socklen_t **addr_lens) | 333 | socklen_t **addr_lens) |
336 | { | 334 | { |
337 | int disablev6; | 335 | int disablev6; |
338 | struct GNUNET_NETWORK_Handle *desc; | 336 | struct GNUNET_NETWORK_Handle *desc; |
@@ -353,72 +351,72 @@ get_server_addresses (const char *service_name, | |||
353 | *addrs = NULL; | 351 | *addrs = NULL; |
354 | *addr_lens = NULL; | 352 | *addr_lens = NULL; |
355 | desc = NULL; | 353 | desc = NULL; |
356 | if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "DISABLEV6")) | 354 | if (GNUNET_CONFIGURATION_have_value(cfg, service_name, "DISABLEV6")) |
357 | { | ||
358 | if (GNUNET_SYSERR == | ||
359 | (disablev6 = GNUNET_CONFIGURATION_get_value_yesno (cfg, | ||
360 | service_name, | ||
361 | "DISABLEV6"))) | ||
362 | return GNUNET_SYSERR; | ||
363 | } | ||
364 | else | ||
365 | disablev6 = GNUNET_NO; | ||
366 | |||
367 | if (! disablev6) | ||
368 | { | ||
369 | /* probe IPv6 support */ | ||
370 | desc = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_STREAM, 0); | ||
371 | if (NULL == desc) | ||
372 | { | 355 | { |
373 | if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) || | 356 | if (GNUNET_SYSERR == |
374 | (EACCES == errno)) | 357 | (disablev6 = GNUNET_CONFIGURATION_get_value_yesno(cfg, |
375 | { | 358 | service_name, |
376 | LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "socket"); | 359 | "DISABLEV6"))) |
377 | return GNUNET_SYSERR; | 360 | return GNUNET_SYSERR; |
378 | } | ||
379 | LOG (GNUNET_ERROR_TYPE_INFO, | ||
380 | _ ( | ||
381 | "Disabling IPv6 support for service `%s', failed to create IPv6 socket: %s\n"), | ||
382 | service_name, | ||
383 | strerror (errno)); | ||
384 | disablev6 = GNUNET_YES; | ||
385 | } | 361 | } |
386 | else | 362 | else |
363 | disablev6 = GNUNET_NO; | ||
364 | |||
365 | if (!disablev6) | ||
387 | { | 366 | { |
388 | GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (desc)); | 367 | /* probe IPv6 support */ |
389 | desc = NULL; | 368 | desc = GNUNET_NETWORK_socket_create(PF_INET6, SOCK_STREAM, 0); |
369 | if (NULL == desc) | ||
370 | { | ||
371 | if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) || | ||
372 | (EACCES == errno)) | ||
373 | { | ||
374 | LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "socket"); | ||
375 | return GNUNET_SYSERR; | ||
376 | } | ||
377 | LOG(GNUNET_ERROR_TYPE_INFO, | ||
378 | _( | ||
379 | "Disabling IPv6 support for service `%s', failed to create IPv6 socket: %s\n"), | ||
380 | service_name, | ||
381 | strerror(errno)); | ||
382 | disablev6 = GNUNET_YES; | ||
383 | } | ||
384 | else | ||
385 | { | ||
386 | GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(desc)); | ||
387 | desc = NULL; | ||
388 | } | ||
390 | } | 389 | } |
391 | } | ||
392 | 390 | ||
393 | port = 0; | 391 | port = 0; |
394 | if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "PORT")) | 392 | if (GNUNET_CONFIGURATION_have_value(cfg, service_name, "PORT")) |
395 | { | ||
396 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg, | ||
397 | service_name, | ||
398 | "PORT", | ||
399 | &port)) | ||
400 | { | ||
401 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
402 | _ ("Require valid port number for service `%s' in configuration!\n"), | ||
403 | service_name); | ||
404 | } | ||
405 | if (port > 65535) | ||
406 | { | 393 | { |
407 | LOG (GNUNET_ERROR_TYPE_ERROR, | 394 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg, |
408 | _ ("Require valid port number for service `%s' in configuration!\n"), | 395 | service_name, |
409 | service_name); | 396 | "PORT", |
410 | return GNUNET_SYSERR; | 397 | &port)) |
398 | { | ||
399 | LOG(GNUNET_ERROR_TYPE_ERROR, | ||
400 | _("Require valid port number for service `%s' in configuration!\n"), | ||
401 | service_name); | ||
402 | } | ||
403 | if (port > 65535) | ||
404 | { | ||
405 | LOG(GNUNET_ERROR_TYPE_ERROR, | ||
406 | _("Require valid port number for service `%s' in configuration!\n"), | ||
407 | service_name); | ||
408 | return GNUNET_SYSERR; | ||
409 | } | ||
411 | } | 410 | } |
412 | } | ||
413 | 411 | ||
414 | if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "BINDTO")) | 412 | if (GNUNET_CONFIGURATION_have_value(cfg, service_name, "BINDTO")) |
415 | { | 413 | { |
416 | GNUNET_break (GNUNET_OK == | 414 | GNUNET_break(GNUNET_OK == |
417 | GNUNET_CONFIGURATION_get_value_string (cfg, | 415 | GNUNET_CONFIGURATION_get_value_string(cfg, |
418 | service_name, | 416 | service_name, |
419 | "BINDTO", | 417 | "BINDTO", |
420 | &hostname)); | 418 | &hostname)); |
421 | } | 419 | } |
422 | else | 420 | else |
423 | hostname = NULL; | 421 | hostname = NULL; |
424 | 422 | ||
@@ -426,235 +424,235 @@ get_server_addresses (const char *service_name, | |||
426 | abstract = GNUNET_NO; | 424 | abstract = GNUNET_NO; |
427 | #ifdef AF_UNIX | 425 | #ifdef AF_UNIX |
428 | if ((GNUNET_YES == | 426 | if ((GNUNET_YES == |
429 | GNUNET_CONFIGURATION_have_value (cfg, service_name, "UNIXPATH")) && | 427 | GNUNET_CONFIGURATION_have_value(cfg, service_name, "UNIXPATH")) && |
430 | (GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename (cfg, | 428 | (GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename(cfg, |
431 | service_name, | 429 | service_name, |
432 | "UNIXPATH", | 430 | "UNIXPATH", |
433 | &unixpath)) && | 431 | &unixpath)) && |
434 | (0 < strlen (unixpath))) | 432 | (0 < strlen(unixpath))) |
435 | { | ||
436 | /* probe UNIX support */ | ||
437 | struct sockaddr_un s_un; | ||
438 | |||
439 | if (strlen (unixpath) >= sizeof (s_un.sun_path)) | ||
440 | { | 433 | { |
441 | LOG (GNUNET_ERROR_TYPE_WARNING, | 434 | /* probe UNIX support */ |
442 | _ ("UNIXPATH `%s' too long, maximum length is %llu\n"), | 435 | struct sockaddr_un s_un; |
443 | unixpath, | 436 | |
444 | (unsigned long long) sizeof (s_un.sun_path)); | 437 | if (strlen(unixpath) >= sizeof(s_un.sun_path)) |
445 | unixpath = GNUNET_NETWORK_shorten_unixpath (unixpath); | 438 | { |
446 | LOG (GNUNET_ERROR_TYPE_INFO, _ ("Using `%s' instead\n"), unixpath); | 439 | LOG(GNUNET_ERROR_TYPE_WARNING, |
447 | } | 440 | _("UNIXPATH `%s' too long, maximum length is %llu\n"), |
441 | unixpath, | ||
442 | (unsigned long long)sizeof(s_un.sun_path)); | ||
443 | unixpath = GNUNET_NETWORK_shorten_unixpath(unixpath); | ||
444 | LOG(GNUNET_ERROR_TYPE_INFO, _("Using `%s' instead\n"), unixpath); | ||
445 | } | ||
448 | #ifdef LINUX | 446 | #ifdef LINUX |
449 | abstract = GNUNET_CONFIGURATION_get_value_yesno (cfg, | 447 | abstract = GNUNET_CONFIGURATION_get_value_yesno(cfg, |
450 | "TESTING", | 448 | "TESTING", |
451 | "USE_ABSTRACT_SOCKETS"); | 449 | "USE_ABSTRACT_SOCKETS"); |
452 | if (GNUNET_SYSERR == abstract) | 450 | if (GNUNET_SYSERR == abstract) |
453 | abstract = GNUNET_NO; | 451 | abstract = GNUNET_NO; |
454 | #endif | 452 | #endif |
455 | if ((GNUNET_YES != abstract) && | 453 | if ((GNUNET_YES != abstract) && |
456 | (GNUNET_OK != GNUNET_DISK_directory_create_for_file (unixpath))) | 454 | (GNUNET_OK != GNUNET_DISK_directory_create_for_file(unixpath))) |
457 | GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "mkdir", unixpath); | 455 | GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "mkdir", unixpath); |
458 | } | ||
459 | if (NULL != unixpath) | ||
460 | { | ||
461 | desc = GNUNET_NETWORK_socket_create (AF_UNIX, SOCK_STREAM, 0); | ||
462 | if (NULL == desc) | ||
463 | { | ||
464 | if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) || | ||
465 | (EACCES == errno)) | ||
466 | { | ||
467 | LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "socket"); | ||
468 | GNUNET_free_non_null (hostname); | ||
469 | GNUNET_free (unixpath); | ||
470 | return GNUNET_SYSERR; | ||
471 | } | ||
472 | LOG (GNUNET_ERROR_TYPE_INFO, | ||
473 | _ ( | ||
474 | "Disabling UNIX domain socket support for service `%s', failed to create UNIX domain socket: %s\n"), | ||
475 | service_name, | ||
476 | strerror (errno)); | ||
477 | GNUNET_free (unixpath); | ||
478 | unixpath = NULL; | ||
479 | } | 456 | } |
480 | else | 457 | if (NULL != unixpath) |
481 | { | 458 | { |
482 | GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (desc)); | 459 | desc = GNUNET_NETWORK_socket_create(AF_UNIX, SOCK_STREAM, 0); |
483 | desc = NULL; | 460 | if (NULL == desc) |
461 | { | ||
462 | if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) || | ||
463 | (EACCES == errno)) | ||
464 | { | ||
465 | LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "socket"); | ||
466 | GNUNET_free_non_null(hostname); | ||
467 | GNUNET_free(unixpath); | ||
468 | return GNUNET_SYSERR; | ||
469 | } | ||
470 | LOG(GNUNET_ERROR_TYPE_INFO, | ||
471 | _( | ||
472 | "Disabling UNIX domain socket support for service `%s', failed to create UNIX domain socket: %s\n"), | ||
473 | service_name, | ||
474 | strerror(errno)); | ||
475 | GNUNET_free(unixpath); | ||
476 | unixpath = NULL; | ||
477 | } | ||
478 | else | ||
479 | { | ||
480 | GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(desc)); | ||
481 | desc = NULL; | ||
482 | } | ||
484 | } | 483 | } |
485 | } | ||
486 | #endif | 484 | #endif |
487 | 485 | ||
488 | if ((0 == port) && (NULL == unixpath)) | 486 | if ((0 == port) && (NULL == unixpath)) |
489 | { | ||
490 | if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno (cfg, | ||
491 | service_name, | ||
492 | "START_ON_DEMAND")) | ||
493 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
494 | _ ( | ||
495 | "Have neither PORT nor UNIXPATH for service `%s', but one is required\n"), | ||
496 | service_name); | ||
497 | GNUNET_free_non_null (hostname); | ||
498 | return GNUNET_SYSERR; | ||
499 | } | ||
500 | if (0 == port) | ||
501 | { | ||
502 | saddrs = GNUNET_new_array (2, struct sockaddr *); | ||
503 | saddrlens = GNUNET_new_array (2, socklen_t); | ||
504 | add_unixpath (saddrs, saddrlens, unixpath, abstract); | ||
505 | GNUNET_free_non_null (unixpath); | ||
506 | GNUNET_free_non_null (hostname); | ||
507 | *addrs = saddrs; | ||
508 | *addr_lens = saddrlens; | ||
509 | return 1; | ||
510 | } | ||
511 | |||
512 | if (NULL != hostname) | ||
513 | { | ||
514 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
515 | "Resolving `%s' since that is where `%s' will bind to.\n", | ||
516 | hostname, | ||
517 | service_name); | ||
518 | memset (&hints, 0, sizeof (struct addrinfo)); | ||
519 | if (disablev6) | ||
520 | hints.ai_family = AF_INET; | ||
521 | hints.ai_protocol = IPPROTO_TCP; | ||
522 | if ((0 != (ret = getaddrinfo (hostname, NULL, &hints, &res))) || | ||
523 | (NULL == res)) | ||
524 | { | 487 | { |
525 | LOG (GNUNET_ERROR_TYPE_ERROR, | 488 | if (GNUNET_YES == GNUNET_CONFIGURATION_get_value_yesno(cfg, |
526 | _ ("Failed to resolve `%s': %s\n"), | 489 | service_name, |
527 | hostname, | 490 | "START_ON_DEMAND")) |
528 | gai_strerror (ret)); | 491 | LOG(GNUNET_ERROR_TYPE_ERROR, |
529 | GNUNET_free (hostname); | 492 | _( |
530 | GNUNET_free_non_null (unixpath); | 493 | "Have neither PORT nor UNIXPATH for service `%s', but one is required\n"), |
531 | return GNUNET_SYSERR; | 494 | service_name); |
532 | } | 495 | GNUNET_free_non_null(hostname); |
533 | next = res; | ||
534 | i = 0; | ||
535 | while (NULL != (pos = next)) | ||
536 | { | ||
537 | next = pos->ai_next; | ||
538 | if ((disablev6) && (pos->ai_family == AF_INET6)) | ||
539 | continue; | ||
540 | i++; | ||
541 | } | ||
542 | if (0 == i) | ||
543 | { | ||
544 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
545 | _ ("Failed to find %saddress for `%s'.\n"), | ||
546 | disablev6 ? "IPv4 " : "", | ||
547 | hostname); | ||
548 | freeaddrinfo (res); | ||
549 | GNUNET_free (hostname); | ||
550 | GNUNET_free_non_null (unixpath); | ||
551 | return GNUNET_SYSERR; | 496 | return GNUNET_SYSERR; |
552 | } | 497 | } |
553 | resi = i; | 498 | if (0 == port) |
554 | if (NULL != unixpath) | ||
555 | resi++; | ||
556 | saddrs = GNUNET_new_array (resi + 1, struct sockaddr *); | ||
557 | saddrlens = GNUNET_new_array (resi + 1, socklen_t); | ||
558 | i = 0; | ||
559 | if (NULL != unixpath) | ||
560 | { | 499 | { |
561 | add_unixpath (saddrs, saddrlens, unixpath, abstract); | 500 | saddrs = GNUNET_new_array(2, struct sockaddr *); |
562 | i++; | 501 | saddrlens = GNUNET_new_array(2, socklen_t); |
502 | add_unixpath(saddrs, saddrlens, unixpath, abstract); | ||
503 | GNUNET_free_non_null(unixpath); | ||
504 | GNUNET_free_non_null(hostname); | ||
505 | *addrs = saddrs; | ||
506 | *addr_lens = saddrlens; | ||
507 | return 1; | ||
563 | } | 508 | } |
564 | next = res; | 509 | |
565 | while (NULL != (pos = next)) | 510 | if (NULL != hostname) |
566 | { | ||
567 | next = pos->ai_next; | ||
568 | if ((disablev6) && (AF_INET6 == pos->ai_family)) | ||
569 | continue; | ||
570 | if ((IPPROTO_TCP != pos->ai_protocol) && (0 != pos->ai_protocol)) | ||
571 | continue; /* not TCP */ | ||
572 | if ((SOCK_STREAM != pos->ai_socktype) && (0 != pos->ai_socktype)) | ||
573 | continue; /* huh? */ | ||
574 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
575 | "Service `%s' will bind to `%s'\n", | ||
576 | service_name, | ||
577 | GNUNET_a2s (pos->ai_addr, pos->ai_addrlen)); | ||
578 | if (AF_INET == pos->ai_family) | ||
579 | { | ||
580 | GNUNET_assert (sizeof (struct sockaddr_in) == pos->ai_addrlen); | ||
581 | saddrlens[i] = pos->ai_addrlen; | ||
582 | saddrs[i] = GNUNET_malloc (saddrlens[i]); | ||
583 | GNUNET_memcpy (saddrs[i], pos->ai_addr, saddrlens[i]); | ||
584 | ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port); | ||
585 | } | ||
586 | else | ||
587 | { | ||
588 | GNUNET_assert (AF_INET6 == pos->ai_family); | ||
589 | GNUNET_assert (sizeof (struct sockaddr_in6) == pos->ai_addrlen); | ||
590 | saddrlens[i] = pos->ai_addrlen; | ||
591 | saddrs[i] = GNUNET_malloc (saddrlens[i]); | ||
592 | GNUNET_memcpy (saddrs[i], pos->ai_addr, saddrlens[i]); | ||
593 | ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port); | ||
594 | } | ||
595 | i++; | ||
596 | } | ||
597 | GNUNET_free (hostname); | ||
598 | freeaddrinfo (res); | ||
599 | resi = i; | ||
600 | } | ||
601 | else | ||
602 | { | ||
603 | /* will bind against everything, just set port */ | ||
604 | if (disablev6) | ||
605 | { | 511 | { |
606 | /* V4-only */ | 512 | LOG(GNUNET_ERROR_TYPE_DEBUG, |
607 | resi = 1; | 513 | "Resolving `%s' since that is where `%s' will bind to.\n", |
514 | hostname, | ||
515 | service_name); | ||
516 | memset(&hints, 0, sizeof(struct addrinfo)); | ||
517 | if (disablev6) | ||
518 | hints.ai_family = AF_INET; | ||
519 | hints.ai_protocol = IPPROTO_TCP; | ||
520 | if ((0 != (ret = getaddrinfo(hostname, NULL, &hints, &res))) || | ||
521 | (NULL == res)) | ||
522 | { | ||
523 | LOG(GNUNET_ERROR_TYPE_ERROR, | ||
524 | _("Failed to resolve `%s': %s\n"), | ||
525 | hostname, | ||
526 | gai_strerror(ret)); | ||
527 | GNUNET_free(hostname); | ||
528 | GNUNET_free_non_null(unixpath); | ||
529 | return GNUNET_SYSERR; | ||
530 | } | ||
531 | next = res; | ||
532 | i = 0; | ||
533 | while (NULL != (pos = next)) | ||
534 | { | ||
535 | next = pos->ai_next; | ||
536 | if ((disablev6) && (pos->ai_family == AF_INET6)) | ||
537 | continue; | ||
538 | i++; | ||
539 | } | ||
540 | if (0 == i) | ||
541 | { | ||
542 | LOG(GNUNET_ERROR_TYPE_ERROR, | ||
543 | _("Failed to find %saddress for `%s'.\n"), | ||
544 | disablev6 ? "IPv4 " : "", | ||
545 | hostname); | ||
546 | freeaddrinfo(res); | ||
547 | GNUNET_free(hostname); | ||
548 | GNUNET_free_non_null(unixpath); | ||
549 | return GNUNET_SYSERR; | ||
550 | } | ||
551 | resi = i; | ||
608 | if (NULL != unixpath) | 552 | if (NULL != unixpath) |
609 | resi++; | 553 | resi++; |
554 | saddrs = GNUNET_new_array(resi + 1, struct sockaddr *); | ||
555 | saddrlens = GNUNET_new_array(resi + 1, socklen_t); | ||
610 | i = 0; | 556 | i = 0; |
611 | saddrs = GNUNET_new_array (resi + 1, struct sockaddr *); | ||
612 | saddrlens = GNUNET_new_array (resi + 1, socklen_t); | ||
613 | if (NULL != unixpath) | 557 | if (NULL != unixpath) |
614 | { | 558 | { |
615 | add_unixpath (saddrs, saddrlens, unixpath, abstract); | 559 | add_unixpath(saddrs, saddrlens, unixpath, abstract); |
616 | i++; | 560 | i++; |
617 | } | 561 | } |
618 | saddrlens[i] = sizeof (struct sockaddr_in); | 562 | next = res; |
619 | saddrs[i] = GNUNET_malloc (saddrlens[i]); | 563 | while (NULL != (pos = next)) |
620 | #if HAVE_SOCKADDR_IN_SIN_LEN | 564 | { |
621 | ((struct sockaddr_in *) saddrs[i])->sin_len = saddrlens[i]; | 565 | next = pos->ai_next; |
622 | #endif | 566 | if ((disablev6) && (AF_INET6 == pos->ai_family)) |
623 | ((struct sockaddr_in *) saddrs[i])->sin_family = AF_INET; | 567 | continue; |
624 | ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port); | 568 | if ((IPPROTO_TCP != pos->ai_protocol) && (0 != pos->ai_protocol)) |
569 | continue; /* not TCP */ | ||
570 | if ((SOCK_STREAM != pos->ai_socktype) && (0 != pos->ai_socktype)) | ||
571 | continue; /* huh? */ | ||
572 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
573 | "Service `%s' will bind to `%s'\n", | ||
574 | service_name, | ||
575 | GNUNET_a2s(pos->ai_addr, pos->ai_addrlen)); | ||
576 | if (AF_INET == pos->ai_family) | ||
577 | { | ||
578 | GNUNET_assert(sizeof(struct sockaddr_in) == pos->ai_addrlen); | ||
579 | saddrlens[i] = pos->ai_addrlen; | ||
580 | saddrs[i] = GNUNET_malloc(saddrlens[i]); | ||
581 | GNUNET_memcpy(saddrs[i], pos->ai_addr, saddrlens[i]); | ||
582 | ((struct sockaddr_in *)saddrs[i])->sin_port = htons(port); | ||
583 | } | ||
584 | else | ||
585 | { | ||
586 | GNUNET_assert(AF_INET6 == pos->ai_family); | ||
587 | GNUNET_assert(sizeof(struct sockaddr_in6) == pos->ai_addrlen); | ||
588 | saddrlens[i] = pos->ai_addrlen; | ||
589 | saddrs[i] = GNUNET_malloc(saddrlens[i]); | ||
590 | GNUNET_memcpy(saddrs[i], pos->ai_addr, saddrlens[i]); | ||
591 | ((struct sockaddr_in6 *)saddrs[i])->sin6_port = htons(port); | ||
592 | } | ||
593 | i++; | ||
594 | } | ||
595 | GNUNET_free(hostname); | ||
596 | freeaddrinfo(res); | ||
597 | resi = i; | ||
625 | } | 598 | } |
626 | else | 599 | else |
627 | { | 600 | { |
628 | /* dual stack */ | 601 | /* will bind against everything, just set port */ |
629 | resi = 2; | 602 | if (disablev6) |
630 | if (NULL != unixpath) | 603 | { |
631 | resi++; | 604 | /* V4-only */ |
632 | saddrs = GNUNET_new_array (resi + 1, struct sockaddr *); | 605 | resi = 1; |
633 | saddrlens = GNUNET_new_array (resi + 1, socklen_t); | 606 | if (NULL != unixpath) |
634 | i = 0; | 607 | resi++; |
635 | if (NULL != unixpath) | 608 | i = 0; |
636 | { | 609 | saddrs = GNUNET_new_array(resi + 1, struct sockaddr *); |
637 | add_unixpath (saddrs, saddrlens, unixpath, abstract); | 610 | saddrlens = GNUNET_new_array(resi + 1, socklen_t); |
638 | i++; | 611 | if (NULL != unixpath) |
639 | } | 612 | { |
640 | saddrlens[i] = sizeof (struct sockaddr_in6); | 613 | add_unixpath(saddrs, saddrlens, unixpath, abstract); |
641 | saddrs[i] = GNUNET_malloc (saddrlens[i]); | 614 | i++; |
615 | } | ||
616 | saddrlens[i] = sizeof(struct sockaddr_in); | ||
617 | saddrs[i] = GNUNET_malloc(saddrlens[i]); | ||
618 | #if HAVE_SOCKADDR_IN_SIN_LEN | ||
619 | ((struct sockaddr_in *)saddrs[i])->sin_len = saddrlens[i]; | ||
620 | #endif | ||
621 | ((struct sockaddr_in *)saddrs[i])->sin_family = AF_INET; | ||
622 | ((struct sockaddr_in *)saddrs[i])->sin_port = htons(port); | ||
623 | } | ||
624 | else | ||
625 | { | ||
626 | /* dual stack */ | ||
627 | resi = 2; | ||
628 | if (NULL != unixpath) | ||
629 | resi++; | ||
630 | saddrs = GNUNET_new_array(resi + 1, struct sockaddr *); | ||
631 | saddrlens = GNUNET_new_array(resi + 1, socklen_t); | ||
632 | i = 0; | ||
633 | if (NULL != unixpath) | ||
634 | { | ||
635 | add_unixpath(saddrs, saddrlens, unixpath, abstract); | ||
636 | i++; | ||
637 | } | ||
638 | saddrlens[i] = sizeof(struct sockaddr_in6); | ||
639 | saddrs[i] = GNUNET_malloc(saddrlens[i]); | ||
642 | #if HAVE_SOCKADDR_IN_SIN_LEN | 640 | #if HAVE_SOCKADDR_IN_SIN_LEN |
643 | ((struct sockaddr_in6 *) saddrs[i])->sin6_len = saddrlens[0]; | 641 | ((struct sockaddr_in6 *)saddrs[i])->sin6_len = saddrlens[0]; |
644 | #endif | 642 | #endif |
645 | ((struct sockaddr_in6 *) saddrs[i])->sin6_family = AF_INET6; | 643 | ((struct sockaddr_in6 *)saddrs[i])->sin6_family = AF_INET6; |
646 | ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port); | 644 | ((struct sockaddr_in6 *)saddrs[i])->sin6_port = htons(port); |
647 | i++; | 645 | i++; |
648 | saddrlens[i] = sizeof (struct sockaddr_in); | 646 | saddrlens[i] = sizeof(struct sockaddr_in); |
649 | saddrs[i] = GNUNET_malloc (saddrlens[i]); | 647 | saddrs[i] = GNUNET_malloc(saddrlens[i]); |
650 | #if HAVE_SOCKADDR_IN_SIN_LEN | 648 | #if HAVE_SOCKADDR_IN_SIN_LEN |
651 | ((struct sockaddr_in *) saddrs[i])->sin_len = saddrlens[1]; | 649 | ((struct sockaddr_in *)saddrs[i])->sin_len = saddrlens[1]; |
652 | #endif | 650 | #endif |
653 | ((struct sockaddr_in *) saddrs[i])->sin_family = AF_INET; | 651 | ((struct sockaddr_in *)saddrs[i])->sin_family = AF_INET; |
654 | ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port); | 652 | ((struct sockaddr_in *)saddrs[i])->sin_port = htons(port); |
653 | } | ||
655 | } | 654 | } |
656 | } | 655 | GNUNET_free_non_null(unixpath); |
657 | GNUNET_free_non_null (unixpath); | ||
658 | *addrs = saddrs; | 656 | *addrs = saddrs; |
659 | *addr_lens = saddrlens; | 657 | *addr_lens = saddrlens; |
660 | return resi; | 658 | return resi; |
@@ -672,19 +670,19 @@ get_server_addresses (const char *service_name, | |||
672 | * @return NULL if it was not found | 670 | * @return NULL if it was not found |
673 | */ | 671 | */ |
674 | static void | 672 | static void |
675 | signal_result (struct GNUNET_SERVICE_Client *client, | 673 | signal_result(struct GNUNET_SERVICE_Client *client, |
676 | const char *name, | 674 | const char *name, |
677 | uint64_t request_id, | 675 | uint64_t request_id, |
678 | enum GNUNET_ARM_Result result) | 676 | enum GNUNET_ARM_Result result) |
679 | { | 677 | { |
680 | struct GNUNET_MQ_Envelope *env; | 678 | struct GNUNET_MQ_Envelope *env; |
681 | struct GNUNET_ARM_ResultMessage *msg; | 679 | struct GNUNET_ARM_ResultMessage *msg; |
682 | 680 | ||
683 | (void) name; | 681 | (void)name; |
684 | env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_ARM_RESULT); | 682 | env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_ARM_RESULT); |
685 | msg->result = htonl (result); | 683 | msg->result = htonl(result); |
686 | msg->arm_msg.request_id = GNUNET_htonll (request_id); | 684 | msg->arm_msg.request_id = GNUNET_htonll(request_id); |
687 | GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client), env); | 685 | GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(client), env); |
688 | } | 686 | } |
689 | 687 | ||
690 | 688 | ||
@@ -697,34 +695,34 @@ signal_result (struct GNUNET_SERVICE_Client *client, | |||
697 | * otherwise, send to all clients in the notifier | 695 | * otherwise, send to all clients in the notifier |
698 | */ | 696 | */ |
699 | static void | 697 | static void |
700 | broadcast_status (const char *name, | 698 | broadcast_status(const char *name, |
701 | enum GNUNET_ARM_ServiceStatus status, | 699 | enum GNUNET_ARM_ServiceStatus status, |
702 | struct GNUNET_SERVICE_Client *unicast) | 700 | struct GNUNET_SERVICE_Client *unicast) |
703 | { | 701 | { |
704 | struct GNUNET_MQ_Envelope *env; | 702 | struct GNUNET_MQ_Envelope *env; |
705 | struct GNUNET_ARM_StatusMessage *msg; | 703 | struct GNUNET_ARM_StatusMessage *msg; |
706 | size_t namelen; | 704 | size_t namelen; |
707 | 705 | ||
708 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 706 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
709 | "Sending status %u of service `%s' to client\n", | 707 | "Sending status %u of service `%s' to client\n", |
710 | (unsigned int) status, | 708 | (unsigned int)status, |
711 | name); | 709 | name); |
712 | namelen = strlen (name) + 1; | 710 | namelen = strlen(name) + 1; |
713 | env = GNUNET_MQ_msg_extra (msg, namelen, GNUNET_MESSAGE_TYPE_ARM_STATUS); | 711 | env = GNUNET_MQ_msg_extra(msg, namelen, GNUNET_MESSAGE_TYPE_ARM_STATUS); |
714 | msg->status = htonl ((uint32_t) (status)); | 712 | msg->status = htonl((uint32_t)(status)); |
715 | GNUNET_memcpy ((char *) &msg[1], name, namelen); | 713 | GNUNET_memcpy((char *)&msg[1], name, namelen); |
716 | if (NULL == unicast) | 714 | if (NULL == unicast) |
717 | { | 715 | { |
718 | if (NULL != notifier) | 716 | if (NULL != notifier) |
719 | GNUNET_notification_context_broadcast (notifier, | 717 | GNUNET_notification_context_broadcast(notifier, |
720 | &msg->header, | 718 | &msg->header, |
721 | GNUNET_YES); | 719 | GNUNET_YES); |
722 | GNUNET_MQ_discard (env); | 720 | GNUNET_MQ_discard(env); |
723 | } | 721 | } |
724 | else | 722 | else |
725 | { | 723 | { |
726 | GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (unicast), env); | 724 | GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(unicast), env); |
727 | } | 725 | } |
728 | } | 726 | } |
729 | 727 | ||
730 | 728 | ||
@@ -737,9 +735,9 @@ broadcast_status (const char *name, | |||
737 | * being started. 0 if starting was not requested. | 735 | * being started. 0 if starting was not requested. |
738 | */ | 736 | */ |
739 | static void | 737 | static void |
740 | start_process (struct ServiceList *sl, | 738 | start_process(struct ServiceList *sl, |
741 | struct GNUNET_SERVICE_Client *client, | 739 | struct GNUNET_SERVICE_Client *client, |
742 | uint64_t request_id) | 740 | uint64_t request_id) |
743 | { | 741 | { |
744 | char *loprefix; | 742 | char *loprefix; |
745 | char *options; | 743 | char *options; |
@@ -755,194 +753,194 @@ start_process (struct ServiceList *sl, | |||
755 | lsocks = NULL; | 753 | lsocks = NULL; |
756 | ls = 0; | 754 | ls = 0; |
757 | for (sli = sl->listen_head; NULL != sli; sli = sli->next) | 755 | for (sli = sl->listen_head; NULL != sli; sli = sli->next) |
758 | { | ||
759 | GNUNET_array_append (lsocks, | ||
760 | ls, | ||
761 | GNUNET_NETWORK_get_fd (sli->listen_socket)); | ||
762 | if (NULL != sli->accept_task) | ||
763 | { | 756 | { |
764 | GNUNET_SCHEDULER_cancel (sli->accept_task); | 757 | GNUNET_array_append(lsocks, |
765 | sli->accept_task = NULL; | 758 | ls, |
759 | GNUNET_NETWORK_get_fd(sli->listen_socket)); | ||
760 | if (NULL != sli->accept_task) | ||
761 | { | ||
762 | GNUNET_SCHEDULER_cancel(sli->accept_task); | ||
763 | sli->accept_task = NULL; | ||
764 | } | ||
766 | } | 765 | } |
767 | } | ||
768 | #if WINDOWS | 766 | #if WINDOWS |
769 | GNUNET_array_append (lsocks, ls, INVALID_SOCKET); | 767 | GNUNET_array_append(lsocks, ls, INVALID_SOCKET); |
770 | #else | 768 | #else |
771 | GNUNET_array_append (lsocks, ls, -1); | 769 | GNUNET_array_append(lsocks, ls, -1); |
772 | #endif | 770 | #endif |
773 | 771 | ||
774 | /* obtain configuration */ | 772 | /* obtain configuration */ |
775 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, | 773 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, |
776 | sl->name, | 774 | sl->name, |
777 | "PREFIX", | 775 | "PREFIX", |
778 | &loprefix)) | 776 | &loprefix)) |
779 | loprefix = GNUNET_strdup (prefix_command); | 777 | loprefix = GNUNET_strdup(prefix_command); |
780 | else | 778 | else |
781 | loprefix = GNUNET_CONFIGURATION_expand_dollar (cfg, loprefix); | 779 | loprefix = GNUNET_CONFIGURATION_expand_dollar(cfg, loprefix); |
782 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, | 780 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, |
783 | sl->name, | 781 | sl->name, |
784 | "OPTIONS", | 782 | "OPTIONS", |
785 | &options)) | 783 | &options)) |
786 | options = NULL; | 784 | options = NULL; |
787 | else | 785 | else |
788 | options = GNUNET_CONFIGURATION_expand_dollar (cfg, options); | 786 | options = GNUNET_CONFIGURATION_expand_dollar(cfg, options); |
789 | { | 787 | { |
790 | char *new_options; | 788 | char *new_options; |
791 | char *optpos; | 789 | char *optpos; |
792 | char *fin_options; | 790 | char *fin_options; |
793 | 791 | ||
794 | fin_options = GNUNET_strdup (final_option); | 792 | fin_options = GNUNET_strdup(final_option); |
795 | /* replace '{}' with service name */ | 793 | /* replace '{}' with service name */ |
796 | while (NULL != (optpos = strstr (fin_options, "{}"))) | 794 | while (NULL != (optpos = strstr(fin_options, "{}"))) |
797 | { | 795 | { |
798 | /* terminate string at opening parenthesis */ | 796 | /* terminate string at opening parenthesis */ |
799 | *optpos = 0; | 797 | *optpos = 0; |
800 | GNUNET_asprintf (&new_options, | 798 | GNUNET_asprintf(&new_options, |
801 | "%s%s%s", | 799 | "%s%s%s", |
802 | fin_options, | 800 | fin_options, |
803 | sl->name, | 801 | sl->name, |
804 | optpos + 2); | 802 | optpos + 2); |
805 | GNUNET_free (fin_options); | 803 | GNUNET_free(fin_options); |
806 | fin_options = new_options; | 804 | fin_options = new_options; |
807 | } | 805 | } |
808 | if (NULL != options) | 806 | if (NULL != options) |
809 | { | 807 | { |
810 | /* combine "fin_options" with "options" */ | 808 | /* combine "fin_options" with "options" */ |
811 | optpos = options; | 809 | optpos = options; |
812 | GNUNET_asprintf (&options, "%s %s", fin_options, optpos); | 810 | GNUNET_asprintf(&options, "%s %s", fin_options, optpos); |
813 | GNUNET_free (fin_options); | 811 | GNUNET_free(fin_options); |
814 | GNUNET_free (optpos); | 812 | GNUNET_free(optpos); |
815 | } | 813 | } |
816 | else | 814 | else |
817 | { | 815 | { |
818 | /* only have "fin_options", use that */ | 816 | /* only have "fin_options", use that */ |
819 | options = fin_options; | 817 | options = fin_options; |
820 | } | 818 | } |
821 | } | 819 | } |
822 | options = GNUNET_CONFIGURATION_expand_dollar (cfg, options); | 820 | options = GNUNET_CONFIGURATION_expand_dollar(cfg, options); |
823 | use_debug = GNUNET_CONFIGURATION_get_value_yesno (cfg, sl->name, "DEBUG"); | 821 | use_debug = GNUNET_CONFIGURATION_get_value_yesno(cfg, sl->name, "DEBUG"); |
824 | { | 822 | { |
825 | const char *service_type = NULL; | 823 | const char *service_type = NULL; |
826 | const char *choices[] = {"GNUNET", "SIMPLE", NULL}; | 824 | const char *choices[] = { "GNUNET", "SIMPLE", NULL }; |
827 | 825 | ||
828 | is_simple_service = GNUNET_NO; | 826 | is_simple_service = GNUNET_NO; |
829 | if ((GNUNET_OK == GNUNET_CONFIGURATION_get_value_choice (cfg, | 827 | if ((GNUNET_OK == GNUNET_CONFIGURATION_get_value_choice(cfg, |
830 | sl->name, | 828 | sl->name, |
831 | "TYPE", | 829 | "TYPE", |
832 | choices, | 830 | choices, |
833 | &service_type)) && | 831 | &service_type)) && |
834 | (0 == strcasecmp (service_type, "SIMPLE"))) | 832 | (0 == strcasecmp(service_type, "SIMPLE"))) |
835 | is_simple_service = GNUNET_YES; | 833 | is_simple_service = GNUNET_YES; |
836 | } | 834 | } |
837 | 835 | ||
838 | GNUNET_assert (NULL == sl->proc); | 836 | GNUNET_assert(NULL == sl->proc); |
839 | if (GNUNET_YES == is_simple_service) | 837 | if (GNUNET_YES == is_simple_service) |
840 | { | ||
841 | /* A simple service will receive no GNUnet specific | ||
842 | command line options. */ | ||
843 | binary = GNUNET_strdup (sl->binary); | ||
844 | binary = GNUNET_CONFIGURATION_expand_dollar (cfg, binary); | ||
845 | GNUNET_asprintf ("edbinary, "\"%s\"", sl->binary); | ||
846 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
847 | "Starting simple service `%s' using binary `%s'\n", | ||
848 | sl->name, | ||
849 | sl->binary); | ||
850 | /* FIXME: dollar expansion should only be done outside | ||
851 | * of ''-quoted strings, escaping should be considered. */ | ||
852 | if (NULL != options) | ||
853 | options = GNUNET_CONFIGURATION_expand_dollar (cfg, options); | ||
854 | sl->proc = GNUNET_OS_start_process_s (sl->pipe_control, | ||
855 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, | ||
856 | lsocks, | ||
857 | loprefix, | ||
858 | quotedbinary, | ||
859 | options, | ||
860 | NULL); | ||
861 | } | ||
862 | else | ||
863 | { | ||
864 | /* actually start process */ | ||
865 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | ||
866 | "Starting service `%s' using binary `%s' and configuration `%s'\n", | ||
867 | sl->name, | ||
868 | sl->binary, | ||
869 | sl->config); | ||
870 | binary = GNUNET_OS_get_libexec_binary_path (sl->binary); | ||
871 | GNUNET_asprintf ("edbinary, "\"%s\"", binary); | ||
872 | |||
873 | if (GNUNET_YES == use_debug) | ||
874 | { | 838 | { |
875 | if (NULL == sl->config) | 839 | /* A simple service will receive no GNUnet specific |
876 | sl->proc = GNUNET_OS_start_process_s (sl->pipe_control, | 840 | command line options. */ |
877 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, | 841 | binary = GNUNET_strdup(sl->binary); |
878 | lsocks, | 842 | binary = GNUNET_CONFIGURATION_expand_dollar(cfg, binary); |
879 | loprefix, | 843 | GNUNET_asprintf("edbinary, "\"%s\"", sl->binary); |
880 | quotedbinary, | 844 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
881 | "-L", | 845 | "Starting simple service `%s' using binary `%s'\n", |
882 | "DEBUG", | 846 | sl->name, |
883 | options, | 847 | sl->binary); |
884 | NULL); | 848 | /* FIXME: dollar expansion should only be done outside |
885 | else | 849 | * of ''-quoted strings, escaping should be considered. */ |
886 | sl->proc = GNUNET_OS_start_process_s (sl->pipe_control, | 850 | if (NULL != options) |
887 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, | 851 | options = GNUNET_CONFIGURATION_expand_dollar(cfg, options); |
888 | lsocks, | 852 | sl->proc = GNUNET_OS_start_process_s(sl->pipe_control, |
889 | loprefix, | 853 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, |
890 | quotedbinary, | 854 | lsocks, |
891 | "-c", | 855 | loprefix, |
892 | sl->config, | 856 | quotedbinary, |
893 | "-L", | 857 | options, |
894 | "DEBUG", | 858 | NULL); |
895 | options, | ||
896 | NULL); | ||
897 | } | 859 | } |
898 | else | 860 | else |
899 | { | 861 | { |
900 | if (NULL == sl->config) | 862 | /* actually start process */ |
901 | sl->proc = GNUNET_OS_start_process_s (sl->pipe_control, | 863 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
902 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, | 864 | "Starting service `%s' using binary `%s' and configuration `%s'\n", |
903 | lsocks, | 865 | sl->name, |
904 | loprefix, | 866 | sl->binary, |
905 | quotedbinary, | 867 | sl->config); |
906 | options, | 868 | binary = GNUNET_OS_get_libexec_binary_path(sl->binary); |
907 | NULL); | 869 | GNUNET_asprintf("edbinary, "\"%s\"", binary); |
870 | |||
871 | if (GNUNET_YES == use_debug) | ||
872 | { | ||
873 | if (NULL == sl->config) | ||
874 | sl->proc = GNUNET_OS_start_process_s(sl->pipe_control, | ||
875 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, | ||
876 | lsocks, | ||
877 | loprefix, | ||
878 | quotedbinary, | ||
879 | "-L", | ||
880 | "DEBUG", | ||
881 | options, | ||
882 | NULL); | ||
883 | else | ||
884 | sl->proc = GNUNET_OS_start_process_s(sl->pipe_control, | ||
885 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, | ||
886 | lsocks, | ||
887 | loprefix, | ||
888 | quotedbinary, | ||
889 | "-c", | ||
890 | sl->config, | ||
891 | "-L", | ||
892 | "DEBUG", | ||
893 | options, | ||
894 | NULL); | ||
895 | } | ||
908 | else | 896 | else |
909 | sl->proc = GNUNET_OS_start_process_s (sl->pipe_control, | 897 | { |
910 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, | 898 | if (NULL == sl->config) |
911 | lsocks, | 899 | sl->proc = GNUNET_OS_start_process_s(sl->pipe_control, |
912 | loprefix, | 900 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, |
913 | quotedbinary, | 901 | lsocks, |
914 | "-c", | 902 | loprefix, |
915 | sl->config, | 903 | quotedbinary, |
916 | options, | 904 | options, |
917 | NULL); | 905 | NULL); |
906 | else | ||
907 | sl->proc = GNUNET_OS_start_process_s(sl->pipe_control, | ||
908 | GNUNET_OS_INHERIT_STD_OUT_AND_ERR, | ||
909 | lsocks, | ||
910 | loprefix, | ||
911 | quotedbinary, | ||
912 | "-c", | ||
913 | sl->config, | ||
914 | options, | ||
915 | NULL); | ||
916 | } | ||
918 | } | 917 | } |
919 | } | 918 | GNUNET_free(binary); |
920 | GNUNET_free (binary); | 919 | GNUNET_free(quotedbinary); |
921 | GNUNET_free (quotedbinary); | ||
922 | if (NULL == sl->proc) | 920 | if (NULL == sl->proc) |
923 | { | 921 | { |
924 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 922 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, |
925 | _ ("Failed to start service `%s'\n"), | 923 | _("Failed to start service `%s'\n"), |
926 | sl->name); | 924 | sl->name); |
927 | if (client) | 925 | if (client) |
928 | signal_result (client, | 926 | signal_result(client, |
929 | sl->name, | 927 | sl->name, |
930 | request_id, | 928 | request_id, |
931 | GNUNET_ARM_RESULT_START_FAILED); | 929 | GNUNET_ARM_RESULT_START_FAILED); |
932 | } | 930 | } |
933 | else | 931 | else |
934 | { | 932 | { |
935 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 933 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, |
936 | _ ("Starting service `%s'\n"), | 934 | _("Starting service `%s'\n"), |
937 | sl->name); | 935 | sl->name); |
938 | broadcast_status (sl->name, GNUNET_ARM_SERVICE_STARTING, NULL); | 936 | broadcast_status(sl->name, GNUNET_ARM_SERVICE_STARTING, NULL); |
939 | if (client) | 937 | if (client) |
940 | signal_result (client, sl->name, request_id, GNUNET_ARM_RESULT_STARTING); | 938 | signal_result(client, sl->name, request_id, GNUNET_ARM_RESULT_STARTING); |
941 | } | 939 | } |
942 | /* clean up */ | 940 | /* clean up */ |
943 | GNUNET_free (loprefix); | 941 | GNUNET_free(loprefix); |
944 | GNUNET_free (options); | 942 | GNUNET_free(options); |
945 | GNUNET_array_grow (lsocks, ls, 0); | 943 | GNUNET_array_grow(lsocks, ls, 0); |
946 | } | 944 | } |
947 | 945 | ||
948 | 946 | ||
@@ -954,17 +952,17 @@ start_process (struct ServiceList *sl, | |||
954 | * @return NULL if it was not found | 952 | * @return NULL if it was not found |
955 | */ | 953 | */ |
956 | static struct ServiceList * | 954 | static struct ServiceList * |
957 | find_service (const char *name) | 955 | find_service(const char *name) |
958 | { | 956 | { |
959 | struct ServiceList *sl; | 957 | struct ServiceList *sl; |
960 | 958 | ||
961 | sl = running_head; | 959 | sl = running_head; |
962 | while (sl != NULL) | 960 | while (sl != NULL) |
963 | { | 961 | { |
964 | if (0 == strcasecmp (sl->name, name)) | 962 | if (0 == strcasecmp(sl->name, name)) |
965 | return sl; | 963 | return sl; |
966 | sl = sl->next; | 964 | sl = sl->next; |
967 | } | 965 | } |
968 | return NULL; | 966 | return NULL; |
969 | } | 967 | } |
970 | 968 | ||
@@ -976,14 +974,14 @@ find_service (const char *name) | |||
976 | * @param cls callback data, `struct ServiceListeningInfo` describing a listen socket | 974 | * @param cls callback data, `struct ServiceListeningInfo` describing a listen socket |
977 | */ | 975 | */ |
978 | static void | 976 | static void |
979 | accept_connection (void *cls) | 977 | accept_connection(void *cls) |
980 | { | 978 | { |
981 | struct ServiceListeningInfo *sli = cls; | 979 | struct ServiceListeningInfo *sli = cls; |
982 | struct ServiceList *sl = sli->sl; | 980 | struct ServiceList *sl = sli->sl; |
983 | 981 | ||
984 | sli->accept_task = NULL; | 982 | sli->accept_task = NULL; |
985 | GNUNET_assert (GNUNET_NO == in_shutdown); | 983 | GNUNET_assert(GNUNET_NO == in_shutdown); |
986 | start_process (sl, NULL, 0); | 984 | start_process(sl, NULL, 0); |
987 | } | 985 | } |
988 | 986 | ||
989 | 987 | ||
@@ -996,121 +994,125 @@ accept_connection (void *cls) | |||
996 | * @param sl service entry for the service in question | 994 | * @param sl service entry for the service in question |
997 | */ | 995 | */ |
998 | static void | 996 | static void |
999 | create_listen_socket (struct sockaddr *sa, | 997 | create_listen_socket(struct sockaddr *sa, |
1000 | socklen_t addr_len, | 998 | socklen_t addr_len, |
1001 | struct ServiceList *sl) | 999 | struct ServiceList *sl) |
1002 | { | 1000 | { |
1003 | static int on = 1; | 1001 | static int on = 1; |
1004 | struct GNUNET_NETWORK_Handle *sock; | 1002 | struct GNUNET_NETWORK_Handle *sock; |
1005 | struct ServiceListeningInfo *sli; | 1003 | struct ServiceListeningInfo *sli; |
1004 | |||
1006 | #ifndef WINDOWS | 1005 | #ifndef WINDOWS |
1007 | int match_uid; | 1006 | int match_uid; |
1008 | int match_gid; | 1007 | int match_gid; |
1009 | #endif | 1008 | #endif |
1010 | 1009 | ||
1011 | switch (sa->sa_family) | 1010 | switch (sa->sa_family) |
1012 | { | 1011 | { |
1013 | case AF_INET: | 1012 | case AF_INET: |
1014 | sock = GNUNET_NETWORK_socket_create (PF_INET, SOCK_STREAM, 0); | 1013 | sock = GNUNET_NETWORK_socket_create(PF_INET, SOCK_STREAM, 0); |
1015 | break; | 1014 | break; |
1016 | case AF_INET6: | 1015 | |
1017 | sock = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_STREAM, 0); | 1016 | case AF_INET6: |
1018 | break; | 1017 | sock = GNUNET_NETWORK_socket_create(PF_INET6, SOCK_STREAM, 0); |
1019 | case AF_UNIX: | 1018 | break; |
1020 | if (0 == strcmp (GNUNET_a2s (sa, addr_len), | 1019 | |
1021 | "@")) /* Do not bind to blank UNIX path! */ | 1020 | case AF_UNIX: |
1022 | return; | 1021 | if (0 == strcmp(GNUNET_a2s(sa, addr_len), |
1023 | sock = GNUNET_NETWORK_socket_create (PF_UNIX, SOCK_STREAM, 0); | 1022 | "@")) /* Do not bind to blank UNIX path! */ |
1024 | break; | 1023 | return; |
1025 | default: | 1024 | sock = GNUNET_NETWORK_socket_create(PF_UNIX, SOCK_STREAM, 0); |
1026 | GNUNET_break (0); | 1025 | break; |
1027 | sock = NULL; | 1026 | |
1028 | errno = EAFNOSUPPORT; | 1027 | default: |
1029 | break; | 1028 | GNUNET_break(0); |
1030 | } | 1029 | sock = NULL; |
1030 | errno = EAFNOSUPPORT; | ||
1031 | break; | ||
1032 | } | ||
1031 | if (NULL == sock) | 1033 | if (NULL == sock) |
1032 | { | 1034 | { |
1033 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 1035 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, |
1034 | _ ("Unable to create socket for service `%s': %s\n"), | 1036 | _("Unable to create socket for service `%s': %s\n"), |
1035 | sl->name, | 1037 | sl->name, |
1036 | strerror (errno)); | 1038 | strerror(errno)); |
1037 | GNUNET_free (sa); | 1039 | GNUNET_free(sa); |
1038 | return; | 1040 | return; |
1039 | } | 1041 | } |
1040 | if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt (sock, | 1042 | if (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt(sock, |
1041 | SOL_SOCKET, | 1043 | SOL_SOCKET, |
1042 | SO_REUSEADDR, | 1044 | SO_REUSEADDR, |
1043 | &on, | 1045 | &on, |
1044 | sizeof (on))) | 1046 | sizeof(on))) |
1045 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, | 1047 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, |
1046 | "setsockopt"); | 1048 | "setsockopt"); |
1047 | #ifdef IPV6_V6ONLY | 1049 | #ifdef IPV6_V6ONLY |
1048 | if ((sa->sa_family == AF_INET6) && | 1050 | if ((sa->sa_family == AF_INET6) && |
1049 | (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt (sock, | 1051 | (GNUNET_OK != GNUNET_NETWORK_socket_setsockopt(sock, |
1050 | IPPROTO_IPV6, | 1052 | IPPROTO_IPV6, |
1051 | IPV6_V6ONLY, | 1053 | IPV6_V6ONLY, |
1052 | &on, | 1054 | &on, |
1053 | sizeof (on)))) | 1055 | sizeof(on)))) |
1054 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, | 1056 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK, |
1055 | "setsockopt"); | 1057 | "setsockopt"); |
1056 | #endif | 1058 | #endif |
1057 | #ifndef WINDOWS | 1059 | #ifndef WINDOWS |
1058 | if (AF_UNIX == sa->sa_family) | 1060 | if (AF_UNIX == sa->sa_family) |
1059 | GNUNET_NETWORK_unix_precheck ((struct sockaddr_un *) sa); | 1061 | GNUNET_NETWORK_unix_precheck((struct sockaddr_un *)sa); |
1060 | #endif | 1062 | #endif |
1061 | if (GNUNET_OK != | 1063 | if (GNUNET_OK != |
1062 | GNUNET_NETWORK_socket_bind (sock, (const struct sockaddr *) sa, addr_len)) | 1064 | GNUNET_NETWORK_socket_bind(sock, (const struct sockaddr *)sa, addr_len)) |
1063 | { | 1065 | { |
1064 | GNUNET_log ( | 1066 | GNUNET_log( |
1065 | GNUNET_ERROR_TYPE_WARNING, | 1067 | GNUNET_ERROR_TYPE_WARNING, |
1066 | _ ( | 1068 | _( |
1067 | "Unable to bind listening socket for service `%s' to address `%s': %s\n"), | 1069 | "Unable to bind listening socket for service `%s' to address `%s': %s\n"), |
1068 | sl->name, | 1070 | sl->name, |
1069 | GNUNET_a2s (sa, addr_len), | 1071 | GNUNET_a2s(sa, addr_len), |
1070 | strerror (errno)); | 1072 | strerror(errno)); |
1071 | GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock)); | 1073 | GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(sock)); |
1072 | GNUNET_free (sa); | 1074 | GNUNET_free(sa); |
1073 | return; | 1075 | return; |
1074 | } | 1076 | } |
1075 | #ifndef WINDOWS | 1077 | #ifndef WINDOWS |
1076 | if ((AF_UNIX == sa->sa_family) | 1078 | if ((AF_UNIX == sa->sa_family) |
1077 | #ifdef LINUX | 1079 | #ifdef LINUX |
1078 | /* Permission settings are not required when abstract sockets are used */ | 1080 | /* Permission settings are not required when abstract sockets are used */ |
1079 | && ('\0' != ((const struct sockaddr_un *) sa)->sun_path[0]) | 1081 | && ('\0' != ((const struct sockaddr_un *)sa)->sun_path[0]) |
1080 | #endif | 1082 | #endif |
1081 | ) | 1083 | ) |
1082 | { | 1084 | { |
1083 | match_uid = | 1085 | match_uid = |
1084 | GNUNET_CONFIGURATION_get_value_yesno (cfg, sl->name, "UNIX_MATCH_UID"); | 1086 | GNUNET_CONFIGURATION_get_value_yesno(cfg, sl->name, "UNIX_MATCH_UID"); |
1085 | match_gid = | 1087 | match_gid = |
1086 | GNUNET_CONFIGURATION_get_value_yesno (cfg, sl->name, "UNIX_MATCH_GID"); | 1088 | GNUNET_CONFIGURATION_get_value_yesno(cfg, sl->name, "UNIX_MATCH_GID"); |
1087 | GNUNET_DISK_fix_permissions (((const struct sockaddr_un *) sa)->sun_path, | 1089 | GNUNET_DISK_fix_permissions(((const struct sockaddr_un *)sa)->sun_path, |
1088 | match_uid, | 1090 | match_uid, |
1089 | match_gid); | 1091 | match_gid); |
1090 | } | 1092 | } |
1091 | #endif | 1093 | #endif |
1092 | if (GNUNET_OK != GNUNET_NETWORK_socket_listen (sock, 5)) | 1094 | if (GNUNET_OK != GNUNET_NETWORK_socket_listen(sock, 5)) |
1093 | { | 1095 | { |
1094 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "listen"); | 1096 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "listen"); |
1095 | GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (sock)); | 1097 | GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(sock)); |
1096 | GNUNET_free (sa); | 1098 | GNUNET_free(sa); |
1097 | return; | 1099 | return; |
1098 | } | 1100 | } |
1099 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 1101 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, |
1100 | _ ("ARM now monitors connections to service `%s' at `%s'\n"), | 1102 | _("ARM now monitors connections to service `%s' at `%s'\n"), |
1101 | sl->name, | 1103 | sl->name, |
1102 | GNUNET_a2s (sa, addr_len)); | 1104 | GNUNET_a2s(sa, addr_len)); |
1103 | sli = GNUNET_new (struct ServiceListeningInfo); | 1105 | sli = GNUNET_new(struct ServiceListeningInfo); |
1104 | sli->service_addr = sa; | 1106 | sli->service_addr = sa; |
1105 | sli->service_addr_len = addr_len; | 1107 | sli->service_addr_len = addr_len; |
1106 | sli->listen_socket = sock; | 1108 | sli->listen_socket = sock; |
1107 | sli->sl = sl; | 1109 | sli->sl = sl; |
1108 | sli->accept_task = | 1110 | sli->accept_task = |
1109 | GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, | 1111 | GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, |
1110 | sock, | 1112 | sock, |
1111 | &accept_connection, | 1113 | &accept_connection, |
1112 | sli); | 1114 | sli); |
1113 | GNUNET_CONTAINER_DLL_insert (sl->listen_head, sl->listen_tail, sli); | 1115 | GNUNET_CONTAINER_DLL_insert(sl->listen_head, sl->listen_tail, sli); |
1114 | } | 1116 | } |
1115 | 1117 | ||
1116 | 1118 | ||
@@ -1121,15 +1123,15 @@ create_listen_socket (struct sockaddr *sa, | |||
1121 | * @param sl entry to free | 1123 | * @param sl entry to free |
1122 | */ | 1124 | */ |
1123 | static void | 1125 | static void |
1124 | free_service (struct ServiceList *sl) | 1126 | free_service(struct ServiceList *sl) |
1125 | { | 1127 | { |
1126 | GNUNET_assert (GNUNET_YES == in_shutdown); | 1128 | GNUNET_assert(GNUNET_YES == in_shutdown); |
1127 | GNUNET_CONTAINER_DLL_remove (running_head, running_tail, sl); | 1129 | GNUNET_CONTAINER_DLL_remove(running_head, running_tail, sl); |
1128 | GNUNET_assert (NULL == sl->listen_head); | 1130 | GNUNET_assert(NULL == sl->listen_head); |
1129 | GNUNET_free_non_null (sl->config); | 1131 | GNUNET_free_non_null(sl->config); |
1130 | GNUNET_free_non_null (sl->binary); | 1132 | GNUNET_free_non_null(sl->binary); |
1131 | GNUNET_free (sl->name); | 1133 | GNUNET_free(sl->name); |
1132 | GNUNET_free (sl); | 1134 | GNUNET_free(sl); |
1133 | } | 1135 | } |
1134 | 1136 | ||
1135 | 1137 | ||
@@ -1142,10 +1144,10 @@ free_service (struct ServiceList *sl) | |||
1142 | * #GNUNET_SYSERR to close it (signal serious error) | 1144 | * #GNUNET_SYSERR to close it (signal serious error) |
1143 | */ | 1145 | */ |
1144 | static int | 1146 | static int |
1145 | check_start (void *cls, const struct GNUNET_ARM_Message *amsg) | 1147 | check_start(void *cls, const struct GNUNET_ARM_Message *amsg) |
1146 | { | 1148 | { |
1147 | (void) cls; | 1149 | (void)cls; |
1148 | GNUNET_MQ_check_zero_termination (amsg); | 1150 | GNUNET_MQ_check_zero_termination(amsg); |
1149 | return GNUNET_OK; | 1151 | return GNUNET_OK; |
1150 | } | 1152 | } |
1151 | 1153 | ||
@@ -1157,43 +1159,43 @@ check_start (void *cls, const struct GNUNET_ARM_Message *amsg) | |||
1157 | * @param amsg the actual message | 1159 | * @param amsg the actual message |
1158 | */ | 1160 | */ |
1159 | static void | 1161 | static void |
1160 | handle_start (void *cls, const struct GNUNET_ARM_Message *amsg) | 1162 | handle_start(void *cls, const struct GNUNET_ARM_Message *amsg) |
1161 | { | 1163 | { |
1162 | struct GNUNET_SERVICE_Client *client = cls; | 1164 | struct GNUNET_SERVICE_Client *client = cls; |
1163 | const char *servicename; | 1165 | const char *servicename; |
1164 | struct ServiceList *sl; | 1166 | struct ServiceList *sl; |
1165 | uint64_t request_id; | 1167 | uint64_t request_id; |
1166 | 1168 | ||
1167 | request_id = GNUNET_ntohll (amsg->request_id); | 1169 | request_id = GNUNET_ntohll(amsg->request_id); |
1168 | servicename = (const char *) &amsg[1]; | 1170 | servicename = (const char *)&amsg[1]; |
1169 | GNUNET_SERVICE_client_continue (client); | 1171 | GNUNET_SERVICE_client_continue(client); |
1170 | if (GNUNET_YES == in_shutdown) | 1172 | if (GNUNET_YES == in_shutdown) |
1171 | { | 1173 | { |
1172 | signal_result (client, | 1174 | signal_result(client, |
1173 | servicename, | 1175 | servicename, |
1174 | request_id, | 1176 | request_id, |
1175 | GNUNET_ARM_RESULT_IN_SHUTDOWN); | 1177 | GNUNET_ARM_RESULT_IN_SHUTDOWN); |
1176 | return; | 1178 | return; |
1177 | } | 1179 | } |
1178 | sl = find_service (servicename); | 1180 | sl = find_service(servicename); |
1179 | if (NULL == sl) | 1181 | if (NULL == sl) |
1180 | { | 1182 | { |
1181 | signal_result (client, | 1183 | signal_result(client, |
1182 | servicename, | 1184 | servicename, |
1183 | request_id, | 1185 | request_id, |
1184 | GNUNET_ARM_RESULT_IS_NOT_KNOWN); | 1186 | GNUNET_ARM_RESULT_IS_NOT_KNOWN); |
1185 | return; | 1187 | return; |
1186 | } | 1188 | } |
1187 | sl->force_start = GNUNET_YES; | 1189 | sl->force_start = GNUNET_YES; |
1188 | if (NULL != sl->proc) | 1190 | if (NULL != sl->proc) |
1189 | { | 1191 | { |
1190 | signal_result (client, | 1192 | signal_result(client, |
1191 | servicename, | 1193 | servicename, |
1192 | request_id, | 1194 | request_id, |
1193 | GNUNET_ARM_RESULT_IS_STARTED_ALREADY); | 1195 | GNUNET_ARM_RESULT_IS_STARTED_ALREADY); |
1194 | return; | 1196 | return; |
1195 | } | 1197 | } |
1196 | start_process (sl, client, request_id); | 1198 | start_process(sl, client, request_id); |
1197 | } | 1199 | } |
1198 | 1200 | ||
1199 | 1201 | ||
@@ -1203,11 +1205,11 @@ handle_start (void *cls, const struct GNUNET_ARM_Message *amsg) | |||
1203 | * @param cls closure (refers to service) | 1205 | * @param cls closure (refers to service) |
1204 | */ | 1206 | */ |
1205 | static void | 1207 | static void |
1206 | trigger_shutdown (void *cls) | 1208 | trigger_shutdown(void *cls) |
1207 | { | 1209 | { |
1208 | (void) cls; | 1210 | (void)cls; |
1209 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Triggering shutdown\n"); | 1211 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Triggering shutdown\n"); |
1210 | GNUNET_SCHEDULER_shutdown (); | 1212 | GNUNET_SCHEDULER_shutdown(); |
1211 | } | 1213 | } |
1212 | 1214 | ||
1213 | 1215 | ||
@@ -1220,10 +1222,10 @@ trigger_shutdown (void *cls) | |||
1220 | * #GNUNET_SYSERR to close it (signal serious error) | 1222 | * #GNUNET_SYSERR to close it (signal serious error) |
1221 | */ | 1223 | */ |
1222 | static int | 1224 | static int |
1223 | check_stop (void *cls, const struct GNUNET_ARM_Message *amsg) | 1225 | check_stop(void *cls, const struct GNUNET_ARM_Message *amsg) |
1224 | { | 1226 | { |
1225 | (void) cls; | 1227 | (void)cls; |
1226 | GNUNET_MQ_check_zero_termination (amsg); | 1228 | GNUNET_MQ_check_zero_termination(amsg); |
1227 | return GNUNET_OK; | 1229 | return GNUNET_OK; |
1228 | } | 1230 | } |
1229 | 1231 | ||
@@ -1235,72 +1237,72 @@ check_stop (void *cls, const struct GNUNET_ARM_Message *amsg) | |||
1235 | * @param amsg the actual message | 1237 | * @param amsg the actual message |
1236 | */ | 1238 | */ |
1237 | static void | 1239 | static void |
1238 | handle_stop (void *cls, const struct GNUNET_ARM_Message *amsg) | 1240 | handle_stop(void *cls, const struct GNUNET_ARM_Message *amsg) |
1239 | { | 1241 | { |
1240 | struct GNUNET_SERVICE_Client *client = cls; | 1242 | struct GNUNET_SERVICE_Client *client = cls; |
1241 | struct ServiceList *sl; | 1243 | struct ServiceList *sl; |
1242 | const char *servicename; | 1244 | const char *servicename; |
1243 | uint64_t request_id; | 1245 | uint64_t request_id; |
1244 | 1246 | ||
1245 | request_id = GNUNET_ntohll (amsg->request_id); | 1247 | request_id = GNUNET_ntohll(amsg->request_id); |
1246 | servicename = (const char *) &amsg[1]; | 1248 | servicename = (const char *)&amsg[1]; |
1247 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 1249 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, |
1248 | _ ("Preparing to stop `%s'\n"), | 1250 | _("Preparing to stop `%s'\n"), |
1249 | servicename); | 1251 | servicename); |
1250 | GNUNET_SERVICE_client_continue (client); | 1252 | GNUNET_SERVICE_client_continue(client); |
1251 | if (0 == strcasecmp (servicename, "arm")) | 1253 | if (0 == strcasecmp(servicename, "arm")) |
1252 | { | 1254 | { |
1253 | broadcast_status (servicename, GNUNET_ARM_SERVICE_STOPPING, NULL); | 1255 | broadcast_status(servicename, GNUNET_ARM_SERVICE_STOPPING, NULL); |
1254 | signal_result (client, servicename, request_id, GNUNET_ARM_RESULT_STOPPING); | 1256 | signal_result(client, servicename, request_id, GNUNET_ARM_RESULT_STOPPING); |
1255 | GNUNET_SERVICE_client_persist (client); | 1257 | GNUNET_SERVICE_client_persist(client); |
1256 | GNUNET_SCHEDULER_add_now (&trigger_shutdown, NULL); | 1258 | GNUNET_SCHEDULER_add_now(&trigger_shutdown, NULL); |
1257 | return; | 1259 | return; |
1258 | } | 1260 | } |
1259 | sl = find_service (servicename); | 1261 | sl = find_service(servicename); |
1260 | if (NULL == sl) | 1262 | if (NULL == sl) |
1261 | { | 1263 | { |
1262 | signal_result (client, | 1264 | signal_result(client, |
1263 | servicename, | 1265 | servicename, |
1264 | request_id, | 1266 | request_id, |
1265 | GNUNET_ARM_RESULT_IS_NOT_KNOWN); | 1267 | GNUNET_ARM_RESULT_IS_NOT_KNOWN); |
1266 | return; | 1268 | return; |
1267 | } | 1269 | } |
1268 | sl->force_start = GNUNET_NO; | 1270 | sl->force_start = GNUNET_NO; |
1269 | if (GNUNET_YES == in_shutdown) | 1271 | if (GNUNET_YES == in_shutdown) |
1270 | { | 1272 | { |
1271 | /* shutdown in progress */ | 1273 | /* shutdown in progress */ |
1272 | signal_result (client, | 1274 | signal_result(client, |
1273 | servicename, | 1275 | servicename, |
1274 | request_id, | 1276 | request_id, |
1275 | GNUNET_ARM_RESULT_IN_SHUTDOWN); | 1277 | GNUNET_ARM_RESULT_IN_SHUTDOWN); |
1276 | return; | 1278 | return; |
1277 | } | 1279 | } |
1278 | if (NULL != sl->killing_client) | 1280 | if (NULL != sl->killing_client) |
1279 | { | 1281 | { |
1280 | /* killing already in progress */ | 1282 | /* killing already in progress */ |
1281 | signal_result (client, | 1283 | signal_result(client, |
1282 | servicename, | 1284 | servicename, |
1283 | request_id, | 1285 | request_id, |
1284 | GNUNET_ARM_RESULT_IS_STOPPING_ALREADY); | 1286 | GNUNET_ARM_RESULT_IS_STOPPING_ALREADY); |
1285 | return; | 1287 | return; |
1286 | } | 1288 | } |
1287 | if (NULL == sl->proc) | 1289 | if (NULL == sl->proc) |
1288 | { | 1290 | { |
1289 | /* process is down */ | 1291 | /* process is down */ |
1290 | signal_result (client, | 1292 | signal_result(client, |
1291 | servicename, | 1293 | servicename, |
1292 | request_id, | 1294 | request_id, |
1293 | GNUNET_ARM_RESULT_IS_STOPPED_ALREADY); | 1295 | GNUNET_ARM_RESULT_IS_STOPPED_ALREADY); |
1294 | return; | 1296 | return; |
1295 | } | 1297 | } |
1296 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1298 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
1297 | "Sending kill signal to service `%s', waiting for process to die.\n", | 1299 | "Sending kill signal to service `%s', waiting for process to die.\n", |
1298 | servicename); | 1300 | servicename); |
1299 | broadcast_status (servicename, GNUNET_ARM_SERVICE_STOPPING, NULL); | 1301 | broadcast_status(servicename, GNUNET_ARM_SERVICE_STOPPING, NULL); |
1300 | /* no signal_start - only when it's STOPPED */ | 1302 | /* no signal_start - only when it's STOPPED */ |
1301 | sl->killed_at = GNUNET_TIME_absolute_get (); | 1303 | sl->killed_at = GNUNET_TIME_absolute_get(); |
1302 | if (0 != GNUNET_OS_process_kill (sl->proc, GNUNET_TERM_SIG)) | 1304 | if (0 != GNUNET_OS_process_kill(sl->proc, GNUNET_TERM_SIG)) |
1303 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); | 1305 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "kill"); |
1304 | sl->killing_client = client; | 1306 | sl->killing_client = client; |
1305 | sl->killing_client_request_id = request_id; | 1307 | sl->killing_client_request_id = request_id; |
1306 | } | 1308 | } |
@@ -1313,7 +1315,7 @@ handle_stop (void *cls, const struct GNUNET_ARM_Message *amsg) | |||
1313 | * @param message the actual message | 1315 | * @param message the actual message |
1314 | */ | 1316 | */ |
1315 | static void | 1317 | static void |
1316 | handle_list (void *cls, const struct GNUNET_ARM_Message *request) | 1318 | handle_list(void *cls, const struct GNUNET_ARM_Message *request) |
1317 | { | 1319 | { |
1318 | struct GNUNET_SERVICE_Client *client = cls; | 1320 | struct GNUNET_SERVICE_Client *client = cls; |
1319 | struct GNUNET_MQ_Envelope *env; | 1321 | struct GNUNET_MQ_Envelope *env; |
@@ -1323,40 +1325,40 @@ handle_list (void *cls, const struct GNUNET_ARM_Message *request) | |||
1323 | uint16_t count; | 1325 | uint16_t count; |
1324 | char *pos; | 1326 | char *pos; |
1325 | 1327 | ||
1326 | GNUNET_break (0 == ntohl (request->reserved)); | 1328 | GNUNET_break(0 == ntohl(request->reserved)); |
1327 | count = 0; | 1329 | count = 0; |
1328 | string_list_size = 0; | 1330 | string_list_size = 0; |
1329 | 1331 | ||
1330 | /* first count the running processes get their name's size */ | 1332 | /* first count the running processes get their name's size */ |
1331 | for (sl = running_head; NULL != sl; sl = sl->next) | 1333 | for (sl = running_head; NULL != sl; sl = sl->next) |
1332 | { | ||
1333 | if (NULL != sl->proc) | ||
1334 | { | 1334 | { |
1335 | string_list_size += strlen (sl->name); | 1335 | if (NULL != sl->proc) |
1336 | string_list_size += strlen (sl->binary); | 1336 | { |
1337 | string_list_size += 4; | 1337 | string_list_size += strlen(sl->name); |
1338 | count++; | 1338 | string_list_size += strlen(sl->binary); |
1339 | string_list_size += 4; | ||
1340 | count++; | ||
1341 | } | ||
1339 | } | 1342 | } |
1340 | } | ||
1341 | 1343 | ||
1342 | env = GNUNET_MQ_msg_extra (msg, | 1344 | env = GNUNET_MQ_msg_extra(msg, |
1343 | string_list_size, | 1345 | string_list_size, |
1344 | GNUNET_MESSAGE_TYPE_ARM_LIST_RESULT); | 1346 | GNUNET_MESSAGE_TYPE_ARM_LIST_RESULT); |
1345 | msg->arm_msg.request_id = request->request_id; | 1347 | msg->arm_msg.request_id = request->request_id; |
1346 | msg->count = htons (count); | 1348 | msg->count = htons(count); |
1347 | 1349 | ||
1348 | pos = (char *) &msg[1]; | 1350 | pos = (char *)&msg[1]; |
1349 | for (sl = running_head; NULL != sl; sl = sl->next) | 1351 | for (sl = running_head; NULL != sl; sl = sl->next) |
1350 | { | ||
1351 | if (NULL != sl->proc) | ||
1352 | { | 1352 | { |
1353 | size_t s = strlen (sl->name) + strlen (sl->binary) + 4; | 1353 | if (NULL != sl->proc) |
1354 | GNUNET_snprintf (pos, s, "%s (%s)", sl->name, sl->binary); | 1354 | { |
1355 | pos += s; | 1355 | size_t s = strlen(sl->name) + strlen(sl->binary) + 4; |
1356 | GNUNET_snprintf(pos, s, "%s (%s)", sl->name, sl->binary); | ||
1357 | pos += s; | ||
1358 | } | ||
1356 | } | 1359 | } |
1357 | } | 1360 | GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(client), env); |
1358 | GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client), env); | 1361 | GNUNET_SERVICE_client_continue(client); |
1359 | GNUNET_SERVICE_client_continue (client); | ||
1360 | } | 1362 | } |
1361 | 1363 | ||
1362 | 1364 | ||
@@ -1367,16 +1369,16 @@ handle_list (void *cls, const struct GNUNET_ARM_Message *request) | |||
1367 | * @param message the actual message | 1369 | * @param message the actual message |
1368 | */ | 1370 | */ |
1369 | static void | 1371 | static void |
1370 | handle_test (void *cls, const struct GNUNET_MessageHeader *message) | 1372 | handle_test(void *cls, const struct GNUNET_MessageHeader *message) |
1371 | { | 1373 | { |
1372 | struct GNUNET_SERVICE_Client *client = cls; | 1374 | struct GNUNET_SERVICE_Client *client = cls; |
1373 | struct GNUNET_MQ_Envelope *env; | 1375 | struct GNUNET_MQ_Envelope *env; |
1374 | struct GNUNET_MessageHeader *msg; | 1376 | struct GNUNET_MessageHeader *msg; |
1375 | 1377 | ||
1376 | (void) message; | 1378 | (void)message; |
1377 | env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_ARM_TEST); | 1379 | env = GNUNET_MQ_msg(msg, GNUNET_MESSAGE_TYPE_ARM_TEST); |
1378 | GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client), env); | 1380 | GNUNET_MQ_send(GNUNET_SERVICE_client_get_mq(client), env); |
1379 | GNUNET_SERVICE_client_continue (client); | 1381 | GNUNET_SERVICE_client_continue(client); |
1380 | } | 1382 | } |
1381 | 1383 | ||
1382 | 1384 | ||
@@ -1385,24 +1387,24 @@ handle_test (void *cls, const struct GNUNET_MessageHeader *message) | |||
1385 | * tasks, signal handler and the server. | 1387 | * tasks, signal handler and the server. |
1386 | */ | 1388 | */ |
1387 | static void | 1389 | static void |
1388 | do_shutdown () | 1390 | do_shutdown() |
1389 | { | 1391 | { |
1390 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Last shutdown phase\n"); | 1392 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Last shutdown phase\n"); |
1391 | if (NULL != notifier) | 1393 | if (NULL != notifier) |
1392 | { | 1394 | { |
1393 | GNUNET_notification_context_destroy (notifier); | 1395 | GNUNET_notification_context_destroy(notifier); |
1394 | notifier = NULL; | 1396 | notifier = NULL; |
1395 | } | 1397 | } |
1396 | if (NULL != service) | 1398 | if (NULL != service) |
1397 | { | 1399 | { |
1398 | GNUNET_SERVICE_shutdown (service); | 1400 | GNUNET_SERVICE_shutdown(service); |
1399 | service = NULL; | 1401 | service = NULL; |
1400 | } | 1402 | } |
1401 | if (NULL != child_death_task) | 1403 | if (NULL != child_death_task) |
1402 | { | 1404 | { |
1403 | GNUNET_SCHEDULER_cancel (child_death_task); | 1405 | GNUNET_SCHEDULER_cancel(child_death_task); |
1404 | child_death_task = NULL; | 1406 | child_death_task = NULL; |
1405 | } | 1407 | } |
1406 | } | 1408 | } |
1407 | 1409 | ||
1408 | 1410 | ||
@@ -1413,13 +1415,13 @@ do_shutdown () | |||
1413 | * @return number of active services found | 1415 | * @return number of active services found |
1414 | */ | 1416 | */ |
1415 | static unsigned int | 1417 | static unsigned int |
1416 | list_count (struct ServiceList *running_head) | 1418 | list_count(struct ServiceList *running_head) |
1417 | { | 1419 | { |
1418 | struct ServiceList *i; | 1420 | struct ServiceList *i; |
1419 | unsigned int res; | 1421 | unsigned int res; |
1420 | 1422 | ||
1421 | for (res = 0, i = running_head; NULL != i; i = i->next, res++) | 1423 | for (res = 0, i = running_head; NULL != i; i = i->next, res++) |
1422 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "%s\n", i->name); | 1424 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "%s\n", i->name); |
1423 | return res; | 1425 | return res; |
1424 | } | 1426 | } |
1425 | 1427 | ||
@@ -1430,61 +1432,61 @@ list_count (struct ServiceList *running_head) | |||
1430 | * @param cls closure, NULL if we need to self-restart | 1432 | * @param cls closure, NULL if we need to self-restart |
1431 | */ | 1433 | */ |
1432 | static void | 1434 | static void |
1433 | shutdown_task (void *cls) | 1435 | shutdown_task(void *cls) |
1434 | { | 1436 | { |
1435 | struct ServiceList *pos; | 1437 | struct ServiceList *pos; |
1436 | struct ServiceList *nxt; | 1438 | struct ServiceList *nxt; |
1437 | struct ServiceListeningInfo *sli; | 1439 | struct ServiceListeningInfo *sli; |
1438 | 1440 | ||
1439 | (void) cls; | 1441 | (void)cls; |
1440 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "First shutdown phase\n"); | 1442 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "First shutdown phase\n"); |
1441 | if (NULL != child_restart_task) | 1443 | if (NULL != child_restart_task) |
1442 | { | 1444 | { |
1443 | GNUNET_SCHEDULER_cancel (child_restart_task); | 1445 | GNUNET_SCHEDULER_cancel(child_restart_task); |
1444 | child_restart_task = NULL; | 1446 | child_restart_task = NULL; |
1445 | } | 1447 | } |
1446 | in_shutdown = GNUNET_YES; | 1448 | in_shutdown = GNUNET_YES; |
1447 | /* first, stop listening */ | 1449 | /* first, stop listening */ |
1448 | for (pos = running_head; NULL != pos; pos = pos->next) | 1450 | for (pos = running_head; NULL != pos; pos = pos->next) |
1449 | { | ||
1450 | while (NULL != (sli = pos->listen_head)) | ||
1451 | { | 1451 | { |
1452 | GNUNET_CONTAINER_DLL_remove (pos->listen_head, pos->listen_tail, sli); | 1452 | while (NULL != (sli = pos->listen_head)) |
1453 | if (NULL != sli->accept_task) | 1453 | { |
1454 | { | 1454 | GNUNET_CONTAINER_DLL_remove(pos->listen_head, pos->listen_tail, sli); |
1455 | GNUNET_SCHEDULER_cancel (sli->accept_task); | 1455 | if (NULL != sli->accept_task) |
1456 | sli->accept_task = NULL; | 1456 | { |
1457 | } | 1457 | GNUNET_SCHEDULER_cancel(sli->accept_task); |
1458 | GNUNET_break (GNUNET_OK == | 1458 | sli->accept_task = NULL; |
1459 | GNUNET_NETWORK_socket_close (sli->listen_socket)); | 1459 | } |
1460 | GNUNET_free (sli->service_addr); | 1460 | GNUNET_break(GNUNET_OK == |
1461 | GNUNET_free (sli); | 1461 | GNUNET_NETWORK_socket_close(sli->listen_socket)); |
1462 | GNUNET_free(sli->service_addr); | ||
1463 | GNUNET_free(sli); | ||
1464 | } | ||
1462 | } | 1465 | } |
1463 | } | ||
1464 | /* then, shutdown all existing service processes */ | 1466 | /* then, shutdown all existing service processes */ |
1465 | nxt = running_head; | 1467 | nxt = running_head; |
1466 | while (NULL != (pos = nxt)) | 1468 | while (NULL != (pos = nxt)) |
1467 | { | ||
1468 | nxt = pos->next; | ||
1469 | if (NULL != pos->proc) | ||
1470 | { | ||
1471 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Stopping service `%s'\n", pos->name); | ||
1472 | pos->killed_at = GNUNET_TIME_absolute_get (); | ||
1473 | if (0 != GNUNET_OS_process_kill (pos->proc, GNUNET_TERM_SIG)) | ||
1474 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); | ||
1475 | } | ||
1476 | else | ||
1477 | { | 1469 | { |
1478 | free_service (pos); | 1470 | nxt = pos->next; |
1471 | if (NULL != pos->proc) | ||
1472 | { | ||
1473 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Stopping service `%s'\n", pos->name); | ||
1474 | pos->killed_at = GNUNET_TIME_absolute_get(); | ||
1475 | if (0 != GNUNET_OS_process_kill(pos->proc, GNUNET_TERM_SIG)) | ||
1476 | GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "kill"); | ||
1477 | } | ||
1478 | else | ||
1479 | { | ||
1480 | free_service(pos); | ||
1481 | } | ||
1479 | } | 1482 | } |
1480 | } | ||
1481 | /* finally, should all service processes be already gone, terminate for real */ | 1483 | /* finally, should all service processes be already gone, terminate for real */ |
1482 | if (NULL == running_head) | 1484 | if (NULL == running_head) |
1483 | do_shutdown (); | 1485 | do_shutdown(); |
1484 | else | 1486 | else |
1485 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1487 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
1486 | "Delaying shutdown, have %u childs still running\n", | 1488 | "Delaying shutdown, have %u childs still running\n", |
1487 | list_count (running_head)); | 1489 | list_count(running_head)); |
1488 | } | 1490 | } |
1489 | 1491 | ||
1490 | 1492 | ||
@@ -1494,73 +1496,73 @@ shutdown_task (void *cls) | |||
1494 | * @param cls closure, always NULL | 1496 | * @param cls closure, always NULL |
1495 | */ | 1497 | */ |
1496 | static void | 1498 | static void |
1497 | delayed_restart_task (void *cls) | 1499 | delayed_restart_task(void *cls) |
1498 | 1500 | ||
1499 | { | 1501 | { |
1500 | struct ServiceList *sl; | 1502 | struct ServiceList *sl; |
1501 | struct GNUNET_TIME_Relative lowestRestartDelay; | 1503 | struct GNUNET_TIME_Relative lowestRestartDelay; |
1502 | struct ServiceListeningInfo *sli; | 1504 | struct ServiceListeningInfo *sli; |
1503 | 1505 | ||
1504 | (void) cls; | 1506 | (void)cls; |
1505 | child_restart_task = NULL; | 1507 | child_restart_task = NULL; |
1506 | GNUNET_assert (GNUNET_NO == in_shutdown); | 1508 | GNUNET_assert(GNUNET_NO == in_shutdown); |
1507 | lowestRestartDelay = GNUNET_TIME_UNIT_FOREVER_REL; | 1509 | lowestRestartDelay = GNUNET_TIME_UNIT_FOREVER_REL; |
1508 | 1510 | ||
1509 | /* check for services that need to be restarted due to | 1511 | /* check for services that need to be restarted due to |
1510 | * configuration changes or because the last restart failed */ | 1512 | * configuration changes or because the last restart failed */ |
1511 | for (sl = running_head; NULL != sl; sl = sl->next) | 1513 | for (sl = running_head; NULL != sl; sl = sl->next) |
1512 | { | ||
1513 | if (NULL != sl->proc) | ||
1514 | continue; | ||
1515 | /* service is currently not running */ | ||
1516 | if (0 == GNUNET_TIME_absolute_get_remaining (sl->restart_at).rel_value_us) | ||
1517 | { | 1514 | { |
1518 | /* restart is now allowed */ | 1515 | if (NULL != sl->proc) |
1519 | if (sl->force_start) | 1516 | continue; |
1520 | { | 1517 | /* service is currently not running */ |
1521 | /* process should run by default, start immediately */ | 1518 | if (0 == GNUNET_TIME_absolute_get_remaining(sl->restart_at).rel_value_us) |
1522 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | 1519 | { |
1523 | _ ("Restarting service `%s'.\n"), | 1520 | /* restart is now allowed */ |
1524 | sl->name); | 1521 | if (sl->force_start) |
1525 | start_process (sl, NULL, 0); | 1522 | { |
1526 | } | 1523 | /* process should run by default, start immediately */ |
1524 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | ||
1525 | _("Restarting service `%s'.\n"), | ||
1526 | sl->name); | ||
1527 | start_process(sl, NULL, 0); | ||
1528 | } | ||
1529 | else | ||
1530 | { | ||
1531 | /* process is run on-demand, ensure it is re-started if there is demand */ | ||
1532 | for (sli = sl->listen_head; NULL != sli; sli = sli->next) | ||
1533 | if (NULL == sli->accept_task) | ||
1534 | { | ||
1535 | /* accept was actually paused, so start it again */ | ||
1536 | sli->accept_task = | ||
1537 | GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, | ||
1538 | sli->listen_socket, | ||
1539 | &accept_connection, | ||
1540 | sli); | ||
1541 | } | ||
1542 | } | ||
1543 | } | ||
1527 | else | 1544 | else |
1528 | { | 1545 | { |
1529 | /* process is run on-demand, ensure it is re-started if there is demand */ | 1546 | /* update calculation for earliest time to reactivate a service */ |
1530 | for (sli = sl->listen_head; NULL != sli; sli = sli->next) | 1547 | lowestRestartDelay = |
1531 | if (NULL == sli->accept_task) | 1548 | GNUNET_TIME_relative_min(lowestRestartDelay, |
1532 | { | 1549 | GNUNET_TIME_absolute_get_remaining( |
1533 | /* accept was actually paused, so start it again */ | 1550 | sl->restart_at)); |
1534 | sli->accept_task = | 1551 | } |
1535 | GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, | ||
1536 | sli->listen_socket, | ||
1537 | &accept_connection, | ||
1538 | sli); | ||
1539 | } | ||
1540 | } | ||
1541 | } | ||
1542 | else | ||
1543 | { | ||
1544 | /* update calculation for earliest time to reactivate a service */ | ||
1545 | lowestRestartDelay = | ||
1546 | GNUNET_TIME_relative_min (lowestRestartDelay, | ||
1547 | GNUNET_TIME_absolute_get_remaining ( | ||
1548 | sl->restart_at)); | ||
1549 | } | 1552 | } |
1550 | } | ||
1551 | if (lowestRestartDelay.rel_value_us != | 1553 | if (lowestRestartDelay.rel_value_us != |
1552 | GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us) | 1554 | GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us) |
1553 | { | 1555 | { |
1554 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1556 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
1555 | "Will restart process in %s\n", | 1557 | "Will restart process in %s\n", |
1556 | GNUNET_STRINGS_relative_time_to_string (lowestRestartDelay, | 1558 | GNUNET_STRINGS_relative_time_to_string(lowestRestartDelay, |
1557 | GNUNET_YES)); | 1559 | GNUNET_YES)); |
1558 | child_restart_task = | 1560 | child_restart_task = |
1559 | GNUNET_SCHEDULER_add_delayed_with_priority (lowestRestartDelay, | 1561 | GNUNET_SCHEDULER_add_delayed_with_priority(lowestRestartDelay, |
1560 | GNUNET_SCHEDULER_PRIORITY_IDLE, | 1562 | GNUNET_SCHEDULER_PRIORITY_IDLE, |
1561 | &delayed_restart_task, | 1563 | &delayed_restart_task, |
1562 | NULL); | 1564 | NULL); |
1563 | } | 1565 | } |
1564 | } | 1566 | } |
1565 | 1567 | ||
1566 | 1568 | ||
@@ -1571,7 +1573,7 @@ delayed_restart_task (void *cls) | |||
1571 | * @param cls closure, NULL | 1573 | * @param cls closure, NULL |
1572 | */ | 1574 | */ |
1573 | static void | 1575 | static void |
1574 | maint_child_death (void *cls) | 1576 | maint_child_death(void *cls) |
1575 | { | 1577 | { |
1576 | struct ServiceList *pos; | 1578 | struct ServiceList *pos; |
1577 | struct ServiceList *next; | 1579 | struct ServiceList *next; |
@@ -1584,199 +1586,199 @@ maint_child_death (void *cls) | |||
1584 | unsigned long statusCode; | 1586 | unsigned long statusCode; |
1585 | const struct GNUNET_DISK_FileHandle *pr; | 1587 | const struct GNUNET_DISK_FileHandle *pr; |
1586 | 1588 | ||
1587 | (void) cls; | 1589 | (void)cls; |
1588 | pr = GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_READ); | 1590 | pr = GNUNET_DISK_pipe_handle(sigpipe, GNUNET_DISK_PIPE_END_READ); |
1589 | child_death_task = NULL; | 1591 | child_death_task = NULL; |
1590 | /* consume the signal */ | 1592 | /* consume the signal */ |
1591 | GNUNET_break (0 < GNUNET_DISK_file_read (pr, &c, sizeof (c))); | 1593 | GNUNET_break(0 < GNUNET_DISK_file_read(pr, &c, sizeof(c))); |
1592 | 1594 | ||
1593 | /* check for services that died (WAITPID) */ | 1595 | /* check for services that died (WAITPID) */ |
1594 | next = running_head; | 1596 | next = running_head; |
1595 | while (NULL != (pos = next)) | 1597 | while (NULL != (pos = next)) |
1596 | { | ||
1597 | next = pos->next; | ||
1598 | |||
1599 | if (NULL == pos->proc) | ||
1600 | { | 1598 | { |
1601 | if (GNUNET_YES == in_shutdown) | 1599 | next = pos->next; |
1602 | free_service (pos); | 1600 | |
1603 | continue; | 1601 | if (NULL == pos->proc) |
1604 | } | 1602 | { |
1603 | if (GNUNET_YES == in_shutdown) | ||
1604 | free_service(pos); | ||
1605 | continue; | ||
1606 | } | ||
1605 | #if HAVE_WAIT4 | 1607 | #if HAVE_WAIT4 |
1606 | if (NULL != wait_file) | 1608 | if (NULL != wait_file) |
1607 | { | 1609 | { |
1608 | /* need to use 'wait4()' to obtain and log performance data */ | 1610 | /* need to use 'wait4()' to obtain and log performance data */ |
1609 | struct rusage ru; | 1611 | struct rusage ru; |
1610 | int status; | 1612 | int status; |
1611 | pid_t pid; | 1613 | pid_t pid; |
1612 | 1614 | ||
1613 | pid = GNUNET_OS_process_get_pid (pos->proc); | 1615 | pid = GNUNET_OS_process_get_pid(pos->proc); |
1614 | ret = wait4 (pid, &status, WNOHANG, &ru); | 1616 | ret = wait4(pid, &status, WNOHANG, &ru); |
1615 | if (ret <= 0) | 1617 | if (ret <= 0) |
1616 | continue; /* no process done */ | 1618 | continue; /* no process done */ |
1617 | if (WIFEXITED (status)) | 1619 | if (WIFEXITED(status)) |
1618 | { | 1620 | { |
1619 | statusType = GNUNET_OS_PROCESS_EXITED; | 1621 | statusType = GNUNET_OS_PROCESS_EXITED; |
1620 | statusCode = WEXITSTATUS (status); | 1622 | statusCode = WEXITSTATUS(status); |
1621 | } | 1623 | } |
1622 | else if (WIFSIGNALED (status)) | 1624 | else if (WIFSIGNALED(status)) |
1623 | { | 1625 | { |
1624 | statusType = GNUNET_OS_PROCESS_SIGNALED; | 1626 | statusType = GNUNET_OS_PROCESS_SIGNALED; |
1625 | statusCode = WTERMSIG (status); | 1627 | statusCode = WTERMSIG(status); |
1626 | } | 1628 | } |
1627 | else if (WIFSTOPPED (status)) | 1629 | else if (WIFSTOPPED(status)) |
1628 | { | 1630 | { |
1629 | statusType = GNUNET_OS_PROCESS_SIGNALED; | 1631 | statusType = GNUNET_OS_PROCESS_SIGNALED; |
1630 | statusCode = WSTOPSIG (status); | 1632 | statusCode = WSTOPSIG(status); |
1631 | } | 1633 | } |
1632 | #ifdef WIFCONTINUED | 1634 | #ifdef WIFCONTINUED |
1633 | else if (WIFCONTINUED (status)) | 1635 | else if (WIFCONTINUED(status)) |
1634 | { | 1636 | { |
1635 | statusType = GNUNET_OS_PROCESS_RUNNING; | 1637 | statusType = GNUNET_OS_PROCESS_RUNNING; |
1636 | statusCode = 0; | 1638 | statusCode = 0; |
1637 | } | 1639 | } |
1638 | #endif | 1640 | #endif |
1639 | else | 1641 | else |
1640 | { | 1642 | { |
1641 | statusType = GNUNET_OS_PROCESS_UNKNOWN; | 1643 | statusType = GNUNET_OS_PROCESS_UNKNOWN; |
1642 | statusCode = 0; | 1644 | statusCode = 0; |
1643 | } | 1645 | } |
1644 | if ((GNUNET_OS_PROCESS_EXITED == statusType) || | 1646 | if ((GNUNET_OS_PROCESS_EXITED == statusType) || |
1645 | (GNUNET_OS_PROCESS_SIGNALED == statusType)) | 1647 | (GNUNET_OS_PROCESS_SIGNALED == statusType)) |
1646 | { | 1648 | { |
1647 | double utime = ru.ru_utime.tv_sec + (ru.ru_utime.tv_usec / 10e6); | 1649 | double utime = ru.ru_utime.tv_sec + (ru.ru_utime.tv_usec / 10e6); |
1648 | double stime = ru.ru_stime.tv_sec + (ru.ru_stime.tv_usec / 10e6); | 1650 | double stime = ru.ru_stime.tv_sec + (ru.ru_stime.tv_usec / 10e6); |
1649 | fprintf (wait_file, | 1651 | fprintf(wait_file, |
1650 | "%s(%u) %.3f %.3f %llu %llu %llu %llu %llu\n", | 1652 | "%s(%u) %.3f %.3f %llu %llu %llu %llu %llu\n", |
1651 | pos->binary, | 1653 | pos->binary, |
1652 | (unsigned int) pid, | 1654 | (unsigned int)pid, |
1653 | utime, | 1655 | utime, |
1654 | stime, | 1656 | stime, |
1655 | (unsigned long long) ru.ru_maxrss, | 1657 | (unsigned long long)ru.ru_maxrss, |
1656 | (unsigned long long) ru.ru_inblock, | 1658 | (unsigned long long)ru.ru_inblock, |
1657 | (unsigned long long) ru.ru_oublock, | 1659 | (unsigned long long)ru.ru_oublock, |
1658 | (unsigned long long) ru.ru_nvcsw, | 1660 | (unsigned long long)ru.ru_nvcsw, |
1659 | (unsigned long long) ru.ru_nivcsw); | 1661 | (unsigned long long)ru.ru_nivcsw); |
1660 | } | 1662 | } |
1661 | } | 1663 | } |
1662 | else /* continue with JUST this "if" as "else" (intentionally no brackets!) */ | 1664 | else /* continue with JUST this "if" as "else" (intentionally no brackets!) */ |
1663 | #endif | 1665 | #endif |
1664 | if ((GNUNET_SYSERR == (ret = GNUNET_OS_process_status (pos->proc, | 1666 | if ((GNUNET_SYSERR == (ret = GNUNET_OS_process_status(pos->proc, |
1665 | &statusType, | 1667 | &statusType, |
1666 | &statusCode))) || | 1668 | &statusCode))) || |
1667 | (ret == GNUNET_NO) || (statusType == GNUNET_OS_PROCESS_STOPPED) || | 1669 | (ret == GNUNET_NO) || (statusType == GNUNET_OS_PROCESS_STOPPED) || |
1668 | (statusType == GNUNET_OS_PROCESS_UNKNOWN) || | 1670 | (statusType == GNUNET_OS_PROCESS_UNKNOWN) || |
1669 | (statusType == GNUNET_OS_PROCESS_RUNNING)) | 1671 | (statusType == GNUNET_OS_PROCESS_RUNNING)) |
1670 | continue; | 1672 | continue; |
1671 | 1673 | ||
1672 | if (statusType == GNUNET_OS_PROCESS_EXITED) | 1674 | if (statusType == GNUNET_OS_PROCESS_EXITED) |
1673 | { | ||
1674 | statstr = _ (/* process termination method */ "exit"); | ||
1675 | statcode = statusCode; | ||
1676 | } | ||
1677 | else if (statusType == GNUNET_OS_PROCESS_SIGNALED) | ||
1678 | { | ||
1679 | statstr = _ (/* process termination method */ "signal"); | ||
1680 | statcode = statusCode; | ||
1681 | } | ||
1682 | else | ||
1683 | { | ||
1684 | statstr = _ (/* process termination method */ "unknown"); | ||
1685 | statcode = 0; | ||
1686 | } | ||
1687 | if (0 != pos->killed_at.abs_value_us) | ||
1688 | { | ||
1689 | GNUNET_log (GNUNET_ERROR_TYPE_INFO, | ||
1690 | _ ("Service `%s' took %s to terminate\n"), | ||
1691 | pos->name, | ||
1692 | GNUNET_STRINGS_relative_time_to_string ( | ||
1693 | GNUNET_TIME_absolute_get_duration (pos->killed_at), | ||
1694 | GNUNET_YES)); | ||
1695 | } | ||
1696 | GNUNET_OS_process_destroy (pos->proc); | ||
1697 | pos->proc = NULL; | ||
1698 | broadcast_status (pos->name, GNUNET_ARM_SERVICE_STOPPED, NULL); | ||
1699 | if (NULL != pos->killing_client) | ||
1700 | { | ||
1701 | signal_result (pos->killing_client, | ||
1702 | pos->name, | ||
1703 | pos->killing_client_request_id, | ||
1704 | GNUNET_ARM_RESULT_STOPPED); | ||
1705 | pos->killing_client = NULL; | ||
1706 | pos->killing_client_request_id = 0; | ||
1707 | } | ||
1708 | if (GNUNET_YES != in_shutdown) | ||
1709 | { | ||
1710 | if ((statusType == GNUNET_OS_PROCESS_EXITED) && (statcode == 0)) | ||
1711 | { | ||
1712 | /* process terminated normally, allow restart at any time */ | ||
1713 | pos->restart_at.abs_value_us = 0; | ||
1714 | GNUNET_log ( | ||
1715 | GNUNET_ERROR_TYPE_INFO, | ||
1716 | _ ("Service `%s' terminated normally, will restart at any time\n"), | ||
1717 | pos->name); | ||
1718 | /* process can still be re-started on-demand, ensure it is re-started if there is demand */ | ||
1719 | for (sli = pos->listen_head; NULL != sli; sli = sli->next) | ||
1720 | { | 1675 | { |
1721 | GNUNET_break (NULL == sli->accept_task); | 1676 | statstr = _(/* process termination method */ "exit"); |
1722 | sli->accept_task = | 1677 | statcode = statusCode; |
1723 | GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL, | 1678 | } |
1724 | sli->listen_socket, | 1679 | else if (statusType == GNUNET_OS_PROCESS_SIGNALED) |
1725 | &accept_connection, | 1680 | { |
1726 | sli); | 1681 | statstr = _(/* process termination method */ "signal"); |
1682 | statcode = statusCode; | ||
1727 | } | 1683 | } |
1728 | } | ||
1729 | else | 1684 | else |
1730 | { | ||
1731 | GNUNET_log ( | ||
1732 | GNUNET_ERROR_TYPE_INFO, | ||
1733 | _ ("Service `%s' terminated with status %s/%d, will restart in %s\n"), | ||
1734 | pos->name, | ||
1735 | statstr, | ||
1736 | statcode, | ||
1737 | GNUNET_STRINGS_relative_time_to_string (pos->backoff, GNUNET_YES)); | ||
1738 | { | 1685 | { |
1739 | /* Reduce backoff based on runtime of the process, | 1686 | statstr = _(/* process termination method */ "unknown"); |
1740 | so that there is a cool-down if a process actually | 1687 | statcode = 0; |
1741 | runs for a while. */ | 1688 | } |
1742 | struct GNUNET_TIME_Relative runtime; | 1689 | if (0 != pos->killed_at.abs_value_us) |
1743 | unsigned int minutes; | 1690 | { |
1744 | 1691 | GNUNET_log(GNUNET_ERROR_TYPE_INFO, | |
1745 | runtime = GNUNET_TIME_absolute_get_duration (pos->restart_at); | 1692 | _("Service `%s' took %s to terminate\n"), |
1746 | minutes = | 1693 | pos->name, |
1747 | runtime.rel_value_us / GNUNET_TIME_UNIT_MINUTES.rel_value_us; | 1694 | GNUNET_STRINGS_relative_time_to_string( |
1748 | if (minutes > 31) | 1695 | GNUNET_TIME_absolute_get_duration(pos->killed_at), |
1749 | pos->backoff = GNUNET_TIME_UNIT_ZERO; | 1696 | GNUNET_YES)); |
1697 | } | ||
1698 | GNUNET_OS_process_destroy(pos->proc); | ||
1699 | pos->proc = NULL; | ||
1700 | broadcast_status(pos->name, GNUNET_ARM_SERVICE_STOPPED, NULL); | ||
1701 | if (NULL != pos->killing_client) | ||
1702 | { | ||
1703 | signal_result(pos->killing_client, | ||
1704 | pos->name, | ||
1705 | pos->killing_client_request_id, | ||
1706 | GNUNET_ARM_RESULT_STOPPED); | ||
1707 | pos->killing_client = NULL; | ||
1708 | pos->killing_client_request_id = 0; | ||
1709 | } | ||
1710 | if (GNUNET_YES != in_shutdown) | ||
1711 | { | ||
1712 | if ((statusType == GNUNET_OS_PROCESS_EXITED) && (statcode == 0)) | ||
1713 | { | ||
1714 | /* process terminated normally, allow restart at any time */ | ||
1715 | pos->restart_at.abs_value_us = 0; | ||
1716 | GNUNET_log( | ||
1717 | GNUNET_ERROR_TYPE_INFO, | ||
1718 | _("Service `%s' terminated normally, will restart at any time\n"), | ||
1719 | pos->name); | ||
1720 | /* process can still be re-started on-demand, ensure it is re-started if there is demand */ | ||
1721 | for (sli = pos->listen_head; NULL != sli; sli = sli->next) | ||
1722 | { | ||
1723 | GNUNET_break(NULL == sli->accept_task); | ||
1724 | sli->accept_task = | ||
1725 | GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL, | ||
1726 | sli->listen_socket, | ||
1727 | &accept_connection, | ||
1728 | sli); | ||
1729 | } | ||
1730 | } | ||
1750 | else | 1731 | else |
1751 | pos->backoff.rel_value_us <<= minutes; | 1732 | { |
1733 | GNUNET_log( | ||
1734 | GNUNET_ERROR_TYPE_INFO, | ||
1735 | _("Service `%s' terminated with status %s/%d, will restart in %s\n"), | ||
1736 | pos->name, | ||
1737 | statstr, | ||
1738 | statcode, | ||
1739 | GNUNET_STRINGS_relative_time_to_string(pos->backoff, GNUNET_YES)); | ||
1740 | { | ||
1741 | /* Reduce backoff based on runtime of the process, | ||
1742 | so that there is a cool-down if a process actually | ||
1743 | runs for a while. */ | ||
1744 | struct GNUNET_TIME_Relative runtime; | ||
1745 | unsigned int minutes; | ||
1746 | |||
1747 | runtime = GNUNET_TIME_absolute_get_duration(pos->restart_at); | ||
1748 | minutes = | ||
1749 | runtime.rel_value_us / GNUNET_TIME_UNIT_MINUTES.rel_value_us; | ||
1750 | if (minutes > 31) | ||
1751 | pos->backoff = GNUNET_TIME_UNIT_ZERO; | ||
1752 | else | ||
1753 | pos->backoff.rel_value_us <<= minutes; | ||
1754 | } | ||
1755 | /* schedule restart */ | ||
1756 | pos->restart_at = GNUNET_TIME_relative_to_absolute(pos->backoff); | ||
1757 | pos->backoff = GNUNET_TIME_STD_BACKOFF(pos->backoff); | ||
1758 | if (NULL != child_restart_task) | ||
1759 | GNUNET_SCHEDULER_cancel(child_restart_task); | ||
1760 | child_restart_task = | ||
1761 | GNUNET_SCHEDULER_add_with_priority(GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
1762 | &delayed_restart_task, | ||
1763 | NULL); | ||
1764 | } | ||
1765 | } | ||
1766 | else | ||
1767 | { | ||
1768 | free_service(pos); | ||
1752 | } | 1769 | } |
1753 | /* schedule restart */ | ||
1754 | pos->restart_at = GNUNET_TIME_relative_to_absolute (pos->backoff); | ||
1755 | pos->backoff = GNUNET_TIME_STD_BACKOFF (pos->backoff); | ||
1756 | if (NULL != child_restart_task) | ||
1757 | GNUNET_SCHEDULER_cancel (child_restart_task); | ||
1758 | child_restart_task = | ||
1759 | GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
1760 | &delayed_restart_task, | ||
1761 | NULL); | ||
1762 | } | ||
1763 | } | ||
1764 | else | ||
1765 | { | ||
1766 | free_service (pos); | ||
1767 | } | 1770 | } |
1768 | } | ||
1769 | child_death_task = | 1771 | child_death_task = |
1770 | GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, | 1772 | GNUNET_SCHEDULER_add_read_file(GNUNET_TIME_UNIT_FOREVER_REL, |
1771 | pr, | 1773 | pr, |
1772 | &maint_child_death, | 1774 | &maint_child_death, |
1773 | NULL); | 1775 | NULL); |
1774 | if ((NULL == running_head) && (GNUNET_YES == in_shutdown)) | 1776 | if ((NULL == running_head) && (GNUNET_YES == in_shutdown)) |
1775 | do_shutdown (); | 1777 | do_shutdown(); |
1776 | else if (GNUNET_YES == in_shutdown) | 1778 | else if (GNUNET_YES == in_shutdown) |
1777 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1779 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
1778 | "Delaying shutdown after child's death, still have %u children\n", | 1780 | "Delaying shutdown after child's death, still have %u children\n", |
1779 | list_count (running_head)); | 1781 | list_count(running_head)); |
1780 | } | 1782 | } |
1781 | 1783 | ||
1782 | 1784 | ||
@@ -1785,17 +1787,17 @@ maint_child_death (void *cls) | |||
1785 | * respective handler by writing to the trigger pipe. | 1787 | * respective handler by writing to the trigger pipe. |
1786 | */ | 1788 | */ |
1787 | static void | 1789 | static void |
1788 | sighandler_child_death () | 1790 | sighandler_child_death() |
1789 | { | 1791 | { |
1790 | static char c; | 1792 | static char c; |
1791 | int old_errno = errno; /* back-up errno */ | 1793 | int old_errno = errno; /* back-up errno */ |
1792 | 1794 | ||
1793 | GNUNET_break ( | 1795 | GNUNET_break( |
1794 | 1 == | 1796 | 1 == |
1795 | GNUNET_DISK_file_write (GNUNET_DISK_pipe_handle (sigpipe, | 1797 | GNUNET_DISK_file_write(GNUNET_DISK_pipe_handle(sigpipe, |
1796 | GNUNET_DISK_PIPE_END_WRITE), | 1798 | GNUNET_DISK_PIPE_END_WRITE), |
1797 | &c, | 1799 | &c, |
1798 | sizeof (c))); | 1800 | sizeof(c))); |
1799 | errno = old_errno; /* restore errno */ | 1801 | errno = old_errno; /* restore errno */ |
1800 | } | 1802 | } |
1801 | 1803 | ||
@@ -1809,7 +1811,7 @@ sighandler_child_death () | |||
1809 | * @return #GNUNET_OK (continue) | 1811 | * @return #GNUNET_OK (continue) |
1810 | */ | 1812 | */ |
1811 | static void | 1813 | static void |
1812 | setup_service (void *cls, const char *section) | 1814 | setup_service(void *cls, const char *section) |
1813 | { | 1815 | { |
1814 | struct ServiceList *sl; | 1816 | struct ServiceList *sl; |
1815 | char *binary; | 1817 | char *binary; |
@@ -1819,65 +1821,65 @@ setup_service (void *cls, const char *section) | |||
1819 | socklen_t *addr_lens; | 1821 | socklen_t *addr_lens; |
1820 | int ret; | 1822 | int ret; |
1821 | 1823 | ||
1822 | (void) cls; | 1824 | (void)cls; |
1823 | if (0 == strcasecmp (section, "arm")) | 1825 | if (0 == strcasecmp(section, "arm")) |
1824 | return; | 1826 | return; |
1825 | if (GNUNET_OK != | 1827 | if (GNUNET_OK != |
1826 | GNUNET_CONFIGURATION_get_value_string (cfg, section, "BINARY", &binary)) | 1828 | GNUNET_CONFIGURATION_get_value_string(cfg, section, "BINARY", &binary)) |
1827 | { | 1829 | { |
1828 | /* not a service section */ | 1830 | /* not a service section */ |
1829 | return; | 1831 | return; |
1830 | } | 1832 | } |
1831 | if ((GNUNET_YES == | 1833 | if ((GNUNET_YES == |
1832 | GNUNET_CONFIGURATION_have_value (cfg, section, "RUN_PER_USER")) && | 1834 | GNUNET_CONFIGURATION_have_value(cfg, section, "RUN_PER_USER")) && |
1833 | (GNUNET_YES == | 1835 | (GNUNET_YES == |
1834 | GNUNET_CONFIGURATION_get_value_yesno (cfg, section, "RUN_PER_USER"))) | 1836 | GNUNET_CONFIGURATION_get_value_yesno(cfg, section, "RUN_PER_USER"))) |
1835 | { | ||
1836 | if (GNUNET_NO == start_user) | ||
1837 | { | 1837 | { |
1838 | GNUNET_free (binary); | 1838 | if (GNUNET_NO == start_user) |
1839 | return; /* user service, and we don't deal with those */ | 1839 | { |
1840 | GNUNET_free(binary); | ||
1841 | return; /* user service, and we don't deal with those */ | ||
1842 | } | ||
1840 | } | 1843 | } |
1841 | } | ||
1842 | else | 1844 | else |
1843 | { | ||
1844 | if (GNUNET_NO == start_system) | ||
1845 | { | 1845 | { |
1846 | GNUNET_free (binary); | 1846 | if (GNUNET_NO == start_system) |
1847 | return; /* system service, and we don't deal with those */ | 1847 | { |
1848 | GNUNET_free(binary); | ||
1849 | return; /* system service, and we don't deal with those */ | ||
1850 | } | ||
1848 | } | 1851 | } |
1849 | } | 1852 | sl = find_service(section); |
1850 | sl = find_service (section); | ||
1851 | if (NULL != sl) | 1853 | if (NULL != sl) |
1852 | { | 1854 | { |
1853 | /* got the same section twice!? */ | 1855 | /* got the same section twice!? */ |
1854 | GNUNET_break (0); | 1856 | GNUNET_break(0); |
1855 | GNUNET_free (binary); | 1857 | GNUNET_free(binary); |
1856 | return; | 1858 | return; |
1857 | } | 1859 | } |
1858 | config = NULL; | 1860 | config = NULL; |
1859 | if (((GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, | 1861 | if (((GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename(cfg, |
1860 | section, | 1862 | section, |
1861 | "CONFIG", | 1863 | "CONFIG", |
1862 | &config)) && | 1864 | &config)) && |
1863 | (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, | 1865 | (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename(cfg, |
1864 | "PATHS", | 1866 | "PATHS", |
1865 | "DEFAULTCONFIG", | 1867 | "DEFAULTCONFIG", |
1866 | &config))) || | 1868 | &config))) || |
1867 | (0 != stat (config, &sbuf))) | 1869 | (0 != stat(config, &sbuf))) |
1868 | { | ||
1869 | if (NULL != config) | ||
1870 | { | 1870 | { |
1871 | GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING, | 1871 | if (NULL != config) |
1872 | section, | 1872 | { |
1873 | "CONFIG", | 1873 | GNUNET_log_config_invalid(GNUNET_ERROR_TYPE_WARNING, |
1874 | strerror (errno)); | 1874 | section, |
1875 | GNUNET_free (config); | 1875 | "CONFIG", |
1876 | config = NULL; | 1876 | strerror(errno)); |
1877 | GNUNET_free(config); | ||
1878 | config = NULL; | ||
1879 | } | ||
1877 | } | 1880 | } |
1878 | } | 1881 | sl = GNUNET_new(struct ServiceList); |
1879 | sl = GNUNET_new (struct ServiceList); | 1882 | sl->name = GNUNET_strdup(section); |
1880 | sl->name = GNUNET_strdup (section); | ||
1881 | sl->binary = binary; | 1883 | sl->binary = binary; |
1882 | sl->config = config; | 1884 | sl->config = config; |
1883 | sl->backoff = GNUNET_TIME_UNIT_MILLISECONDS; | 1885 | sl->backoff = GNUNET_TIME_UNIT_MILLISECONDS; |
@@ -1885,32 +1887,32 @@ setup_service (void *cls, const char *section) | |||
1885 | #if WINDOWS | 1887 | #if WINDOWS |
1886 | sl->pipe_control = GNUNET_YES; | 1888 | sl->pipe_control = GNUNET_YES; |
1887 | #else | 1889 | #else |
1888 | if (GNUNET_CONFIGURATION_have_value (cfg, section, "PIPECONTROL")) | 1890 | if (GNUNET_CONFIGURATION_have_value(cfg, section, "PIPECONTROL")) |
1889 | sl->pipe_control = | 1891 | sl->pipe_control = |
1890 | GNUNET_CONFIGURATION_get_value_yesno (cfg, section, "PIPECONTROL"); | 1892 | GNUNET_CONFIGURATION_get_value_yesno(cfg, section, "PIPECONTROL"); |
1891 | #endif | 1893 | #endif |
1892 | GNUNET_CONTAINER_DLL_insert (running_head, running_tail, sl); | 1894 | GNUNET_CONTAINER_DLL_insert(running_head, running_tail, sl); |
1893 | if (GNUNET_YES == | 1895 | if (GNUNET_YES == |
1894 | GNUNET_CONFIGURATION_get_value_yesno (cfg, section, "IMMEDIATE_START")) | 1896 | GNUNET_CONFIGURATION_get_value_yesno(cfg, section, "IMMEDIATE_START")) |
1895 | { | 1897 | { |
1896 | sl->force_start = GNUNET_YES; | 1898 | sl->force_start = GNUNET_YES; |
1897 | if (GNUNET_YES == | 1899 | if (GNUNET_YES == |
1898 | GNUNET_CONFIGURATION_get_value_yesno (cfg, section, "NOARMBIND")) | 1900 | GNUNET_CONFIGURATION_get_value_yesno(cfg, section, "NOARMBIND")) |
1899 | return; | 1901 | return; |
1900 | } | 1902 | } |
1901 | else | 1903 | else |
1902 | { | 1904 | { |
1903 | if (GNUNET_YES != | 1905 | if (GNUNET_YES != |
1904 | GNUNET_CONFIGURATION_get_value_yesno (cfg, section, "START_ON_DEMAND")) | 1906 | GNUNET_CONFIGURATION_get_value_yesno(cfg, section, "START_ON_DEMAND")) |
1905 | return; | 1907 | return; |
1906 | } | 1908 | } |
1907 | if (0 >= (ret = get_server_addresses (section, cfg, &addrs, &addr_lens))) | 1909 | if (0 >= (ret = get_server_addresses(section, cfg, &addrs, &addr_lens))) |
1908 | return; | 1910 | return; |
1909 | /* this will free (or capture) addrs[i] */ | 1911 | /* this will free (or capture) addrs[i] */ |
1910 | for (unsigned int i = 0; i < (unsigned int) ret; i++) | 1912 | for (unsigned int i = 0; i < (unsigned int)ret; i++) |
1911 | create_listen_socket (addrs[i], addr_lens[i], sl); | 1913 | create_listen_socket(addrs[i], addr_lens[i], sl); |
1912 | GNUNET_free (addrs); | 1914 | GNUNET_free(addrs); |
1913 | GNUNET_free (addr_lens); | 1915 | GNUNET_free(addr_lens); |
1914 | } | 1916 | } |
1915 | 1917 | ||
1916 | 1918 | ||
@@ -1923,16 +1925,16 @@ setup_service (void *cls, const char *section) | |||
1923 | * @return @a client | 1925 | * @return @a client |
1924 | */ | 1926 | */ |
1925 | static void * | 1927 | static void * |
1926 | client_connect_cb (void *cls, | 1928 | client_connect_cb(void *cls, |
1927 | struct GNUNET_SERVICE_Client *client, | 1929 | struct GNUNET_SERVICE_Client *client, |
1928 | struct GNUNET_MQ_Handle *mq) | 1930 | struct GNUNET_MQ_Handle *mq) |
1929 | { | 1931 | { |
1930 | /* All clients are considered to be of the "monitor" kind | 1932 | /* All clients are considered to be of the "monitor" kind |
1931 | * (that is, they don't affect ARM shutdown). | 1933 | * (that is, they don't affect ARM shutdown). |
1932 | */ | 1934 | */ |
1933 | (void) cls; | 1935 | (void)cls; |
1934 | (void) mq; | 1936 | (void)mq; |
1935 | GNUNET_SERVICE_client_mark_monitor (client); | 1937 | GNUNET_SERVICE_client_mark_monitor(client); |
1936 | return client; | 1938 | return client; |
1937 | } | 1939 | } |
1938 | 1940 | ||
@@ -1945,12 +1947,12 @@ client_connect_cb (void *cls, | |||
1945 | * @param app_ctx must match @a client | 1947 | * @param app_ctx must match @a client |
1946 | */ | 1948 | */ |
1947 | static void | 1949 | static void |
1948 | client_disconnect_cb (void *cls, | 1950 | client_disconnect_cb(void *cls, |
1949 | struct GNUNET_SERVICE_Client *client, | 1951 | struct GNUNET_SERVICE_Client *client, |
1950 | void *app_ctx) | 1952 | void *app_ctx) |
1951 | { | 1953 | { |
1952 | (void) cls; | 1954 | (void)cls; |
1953 | GNUNET_assert (client == app_ctx); | 1955 | GNUNET_assert(client == app_ctx); |
1954 | for (struct ServiceList *sl = running_head; NULL != sl; sl = sl->next) | 1956 | for (struct ServiceList *sl = running_head; NULL != sl; sl = sl->next) |
1955 | if (sl->killing_client == client) | 1957 | if (sl->killing_client == client) |
1956 | sl->killing_client = NULL; | 1958 | sl->killing_client = NULL; |
@@ -1966,18 +1968,18 @@ client_disconnect_cb (void *cls, | |||
1966 | * #GNUNET_SYSERR to close it (signal serious error) | 1968 | * #GNUNET_SYSERR to close it (signal serious error) |
1967 | */ | 1969 | */ |
1968 | static void | 1970 | static void |
1969 | handle_monitor (void *cls, const struct GNUNET_MessageHeader *message) | 1971 | handle_monitor(void *cls, const struct GNUNET_MessageHeader *message) |
1970 | { | 1972 | { |
1971 | struct GNUNET_SERVICE_Client *client = cls; | 1973 | struct GNUNET_SERVICE_Client *client = cls; |
1972 | 1974 | ||
1973 | (void) message; | 1975 | (void)message; |
1974 | /* FIXME: might want to start by letting monitor know about | 1976 | /* FIXME: might want to start by letting monitor know about |
1975 | services that are already running */ | 1977 | services that are already running */ |
1976 | /* Removal is handled by the server implementation, internally. */ | 1978 | /* Removal is handled by the server implementation, internally. */ |
1977 | GNUNET_notification_context_add (notifier, | 1979 | GNUNET_notification_context_add(notifier, |
1978 | GNUNET_SERVICE_client_get_mq (client)); | 1980 | GNUNET_SERVICE_client_get_mq(client)); |
1979 | broadcast_status ("arm", GNUNET_ARM_SERVICE_MONITORING_STARTED, client); | 1981 | broadcast_status("arm", GNUNET_ARM_SERVICE_MONITORING_STARTED, client); |
1980 | GNUNET_SERVICE_client_continue (client); | 1982 | GNUNET_SERVICE_client_continue(client); |
1981 | } | 1983 | } |
1982 | 1984 | ||
1983 | 1985 | ||
@@ -1989,71 +1991,71 @@ handle_monitor (void *cls, const struct GNUNET_MessageHeader *message) | |||
1989 | * @param c configuration to use | 1991 | * @param c configuration to use |
1990 | */ | 1992 | */ |
1991 | static void | 1993 | static void |
1992 | run (void *cls, | 1994 | run(void *cls, |
1993 | const struct GNUNET_CONFIGURATION_Handle *c, | 1995 | const struct GNUNET_CONFIGURATION_Handle *c, |
1994 | struct GNUNET_SERVICE_Handle *serv) | 1996 | struct GNUNET_SERVICE_Handle *serv) |
1995 | { | 1997 | { |
1996 | struct ServiceList *sl; | 1998 | struct ServiceList *sl; |
1997 | 1999 | ||
1998 | (void) cls; | 2000 | (void)cls; |
1999 | cfg = c; | 2001 | cfg = c; |
2000 | service = serv; | 2002 | service = serv; |
2001 | GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL); | 2003 | GNUNET_SCHEDULER_add_shutdown(&shutdown_task, NULL); |
2002 | child_death_task = GNUNET_SCHEDULER_add_read_file ( | 2004 | child_death_task = GNUNET_SCHEDULER_add_read_file( |
2003 | GNUNET_TIME_UNIT_FOREVER_REL, | 2005 | GNUNET_TIME_UNIT_FOREVER_REL, |
2004 | GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_READ), | 2006 | GNUNET_DISK_pipe_handle(sigpipe, GNUNET_DISK_PIPE_END_READ), |
2005 | &maint_child_death, | 2007 | &maint_child_death, |
2006 | NULL); | 2008 | NULL); |
2007 | #if HAVE_WAIT4 | 2009 | #if HAVE_WAIT4 |
2008 | if (GNUNET_OK == | 2010 | if (GNUNET_OK == |
2009 | GNUNET_CONFIGURATION_get_value_filename (cfg, | 2011 | GNUNET_CONFIGURATION_get_value_filename(cfg, |
2010 | "ARM", | 2012 | "ARM", |
2011 | "RESOURCE_DIAGNOSTICS", | 2013 | "RESOURCE_DIAGNOSTICS", |
2012 | &wait_filename)) | 2014 | &wait_filename)) |
2013 | { | ||
2014 | wait_file = fopen (wait_filename, "w"); | ||
2015 | if (NULL == wait_file) | ||
2016 | { | 2015 | { |
2017 | GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, | 2016 | wait_file = fopen(wait_filename, "w"); |
2018 | "fopen", | 2017 | if (NULL == wait_file) |
2019 | wait_filename); | 2018 | { |
2019 | GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, | ||
2020 | "fopen", | ||
2021 | wait_filename); | ||
2022 | } | ||
2020 | } | 2023 | } |
2021 | } | ||
2022 | #endif | 2024 | #endif |
2023 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, | 2025 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, |
2024 | "ARM", | 2026 | "ARM", |
2025 | "GLOBAL_PREFIX", | 2027 | "GLOBAL_PREFIX", |
2026 | &prefix_command)) | 2028 | &prefix_command)) |
2027 | prefix_command = GNUNET_strdup (""); | 2029 | prefix_command = GNUNET_strdup(""); |
2028 | else | 2030 | else |
2029 | prefix_command = GNUNET_CONFIGURATION_expand_dollar (cfg, prefix_command); | 2031 | prefix_command = GNUNET_CONFIGURATION_expand_dollar(cfg, prefix_command); |
2030 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string (cfg, | 2032 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_string(cfg, |
2031 | "ARM", | 2033 | "ARM", |
2032 | "GLOBAL_POSTFIX", | 2034 | "GLOBAL_POSTFIX", |
2033 | &final_option)) | 2035 | &final_option)) |
2034 | final_option = GNUNET_strdup (""); | 2036 | final_option = GNUNET_strdup(""); |
2035 | else | 2037 | else |
2036 | final_option = GNUNET_CONFIGURATION_expand_dollar (cfg, final_option); | 2038 | final_option = GNUNET_CONFIGURATION_expand_dollar(cfg, final_option); |
2037 | start_user = | 2039 | start_user = |
2038 | GNUNET_CONFIGURATION_get_value_yesno (cfg, "ARM", "START_USER_SERVICES"); | 2040 | GNUNET_CONFIGURATION_get_value_yesno(cfg, "ARM", "START_USER_SERVICES"); |
2039 | start_system = | 2041 | start_system = |
2040 | GNUNET_CONFIGURATION_get_value_yesno (cfg, "ARM", "START_SYSTEM_SERVICES"); | 2042 | GNUNET_CONFIGURATION_get_value_yesno(cfg, "ARM", "START_SYSTEM_SERVICES"); |
2041 | if ((GNUNET_NO == start_user) && (GNUNET_NO == start_system)) | 2043 | if ((GNUNET_NO == start_user) && (GNUNET_NO == start_system)) |
2042 | { | 2044 | { |
2043 | GNUNET_log ( | 2045 | GNUNET_log( |
2044 | GNUNET_ERROR_TYPE_ERROR, | 2046 | GNUNET_ERROR_TYPE_ERROR, |
2045 | "Please configure either START_USER_SERVICES or START_SYSTEM_SERVICES or both.\n"); | 2047 | "Please configure either START_USER_SERVICES or START_SYSTEM_SERVICES or both.\n"); |
2046 | GNUNET_SCHEDULER_shutdown (); | 2048 | GNUNET_SCHEDULER_shutdown(); |
2047 | global_ret = 1; | 2049 | global_ret = 1; |
2048 | return; | 2050 | return; |
2049 | } | 2051 | } |
2050 | GNUNET_CONFIGURATION_iterate_sections (cfg, &setup_service, NULL); | 2052 | GNUNET_CONFIGURATION_iterate_sections(cfg, &setup_service, NULL); |
2051 | 2053 | ||
2052 | /* start default services... */ | 2054 | /* start default services... */ |
2053 | for (sl = running_head; NULL != sl; sl = sl->next) | 2055 | for (sl = running_head; NULL != sl; sl = sl->next) |
2054 | if (GNUNET_YES == sl->force_start) | 2056 | if (GNUNET_YES == sl->force_start) |
2055 | start_process (sl, NULL, 0); | 2057 | start_process(sl, NULL, 0); |
2056 | notifier = GNUNET_notification_context_create (MAX_NOTIFY_QUEUE); | 2058 | notifier = GNUNET_notification_context_create(MAX_NOTIFY_QUEUE); |
2057 | } | 2059 | } |
2058 | 2060 | ||
2059 | 2061 | ||
@@ -2065,61 +2067,61 @@ run (void *cls, | |||
2065 | * @return 0 ok, 1 on error | 2067 | * @return 0 ok, 1 on error |
2066 | */ | 2068 | */ |
2067 | int | 2069 | int |
2068 | main (int argc, char *const *argv) | 2070 | main(int argc, char *const *argv) |
2069 | { | 2071 | { |
2070 | struct GNUNET_SIGNAL_Context *shc_chld; | 2072 | struct GNUNET_SIGNAL_Context *shc_chld; |
2071 | struct GNUNET_MQ_MessageHandler handlers[] = | 2073 | struct GNUNET_MQ_MessageHandler handlers[] = |
2072 | {GNUNET_MQ_hd_var_size (start, | 2074 | { GNUNET_MQ_hd_var_size(start, |
2073 | GNUNET_MESSAGE_TYPE_ARM_START, | 2075 | GNUNET_MESSAGE_TYPE_ARM_START, |
2074 | struct GNUNET_ARM_Message, | 2076 | struct GNUNET_ARM_Message, |
2077 | NULL), | ||
2078 | GNUNET_MQ_hd_var_size(stop, | ||
2079 | GNUNET_MESSAGE_TYPE_ARM_STOP, | ||
2080 | struct GNUNET_ARM_Message, | ||
2081 | NULL), | ||
2082 | GNUNET_MQ_hd_fixed_size(monitor, | ||
2083 | GNUNET_MESSAGE_TYPE_ARM_MONITOR, | ||
2084 | struct GNUNET_MessageHeader, | ||
2075 | NULL), | 2085 | NULL), |
2076 | GNUNET_MQ_hd_var_size (stop, | 2086 | GNUNET_MQ_hd_fixed_size(list, |
2077 | GNUNET_MESSAGE_TYPE_ARM_STOP, | 2087 | GNUNET_MESSAGE_TYPE_ARM_LIST, |
2078 | struct GNUNET_ARM_Message, | 2088 | struct GNUNET_ARM_Message, |
2079 | NULL), | 2089 | NULL), |
2080 | GNUNET_MQ_hd_fixed_size (monitor, | 2090 | GNUNET_MQ_hd_fixed_size(test, |
2081 | GNUNET_MESSAGE_TYPE_ARM_MONITOR, | 2091 | GNUNET_MESSAGE_TYPE_ARM_TEST, |
2082 | struct GNUNET_MessageHeader, | 2092 | struct GNUNET_MessageHeader, |
2083 | NULL), | 2093 | NULL), |
2084 | GNUNET_MQ_hd_fixed_size (list, | 2094 | GNUNET_MQ_handler_end() }; |
2085 | GNUNET_MESSAGE_TYPE_ARM_LIST, | 2095 | |
2086 | struct GNUNET_ARM_Message, | 2096 | sigpipe = GNUNET_DISK_pipe(GNUNET_NO, GNUNET_NO, GNUNET_NO, GNUNET_NO); |
2087 | NULL), | 2097 | GNUNET_assert(NULL != sigpipe); |
2088 | GNUNET_MQ_hd_fixed_size (test, | ||
2089 | GNUNET_MESSAGE_TYPE_ARM_TEST, | ||
2090 | struct GNUNET_MessageHeader, | ||
2091 | NULL), | ||
2092 | GNUNET_MQ_handler_end ()}; | ||
2093 | |||
2094 | sigpipe = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO, GNUNET_NO, GNUNET_NO); | ||
2095 | GNUNET_assert (NULL != sigpipe); | ||
2096 | shc_chld = | 2098 | shc_chld = |
2097 | GNUNET_SIGNAL_handler_install (GNUNET_SIGCHLD, &sighandler_child_death); | 2099 | GNUNET_SIGNAL_handler_install(GNUNET_SIGCHLD, &sighandler_child_death); |
2098 | if (0 != GNUNET_SERVICE_run_ (argc, | 2100 | if (0 != GNUNET_SERVICE_run_(argc, |
2099 | argv, | 2101 | argv, |
2100 | "arm", | 2102 | "arm", |
2101 | GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN, | 2103 | GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN, |
2102 | &run, | 2104 | &run, |
2103 | &client_connect_cb, | 2105 | &client_connect_cb, |
2104 | &client_disconnect_cb, | 2106 | &client_disconnect_cb, |
2105 | NULL, | 2107 | NULL, |
2106 | handlers)) | 2108 | handlers)) |
2107 | global_ret = 2; | 2109 | global_ret = 2; |
2108 | #if HAVE_WAIT4 | 2110 | #if HAVE_WAIT4 |
2109 | if (NULL != wait_file) | 2111 | if (NULL != wait_file) |
2110 | { | 2112 | { |
2111 | fclose (wait_file); | 2113 | fclose(wait_file); |
2112 | wait_file = NULL; | 2114 | wait_file = NULL; |
2113 | } | 2115 | } |
2114 | if (NULL != wait_filename) | 2116 | if (NULL != wait_filename) |
2115 | { | 2117 | { |
2116 | GNUNET_free (wait_filename); | 2118 | GNUNET_free(wait_filename); |
2117 | wait_filename = NULL; | 2119 | wait_filename = NULL; |
2118 | } | 2120 | } |
2119 | #endif | 2121 | #endif |
2120 | GNUNET_SIGNAL_handler_uninstall (shc_chld); | 2122 | GNUNET_SIGNAL_handler_uninstall(shc_chld); |
2121 | shc_chld = NULL; | 2123 | shc_chld = NULL; |
2122 | GNUNET_DISK_pipe_close (sigpipe); | 2124 | GNUNET_DISK_pipe_close(sigpipe); |
2123 | sigpipe = NULL; | 2125 | sigpipe = NULL; |
2124 | return global_ret; | 2126 | return global_ret; |
2125 | } | 2127 | } |
@@ -2131,11 +2133,11 @@ main (int argc, char *const *argv) | |||
2131 | /** | 2133 | /** |
2132 | * MINIMIZE heap size (way below 128k) since this process doesn't need much. | 2134 | * MINIMIZE heap size (way below 128k) since this process doesn't need much. |
2133 | */ | 2135 | */ |
2134 | void __attribute__ ((constructor)) GNUNET_ARM_memory_init () | 2136 | void __attribute__ ((constructor)) GNUNET_ARM_memory_init() |
2135 | { | 2137 | { |
2136 | mallopt (M_TRIM_THRESHOLD, 4 * 1024); | 2138 | mallopt(M_TRIM_THRESHOLD, 4 * 1024); |
2137 | mallopt (M_TOP_PAD, 1 * 1024); | 2139 | mallopt(M_TOP_PAD, 1 * 1024); |
2138 | malloc_trim (0); | 2140 | malloc_trim(0); |
2139 | } | 2141 | } |
2140 | #endif | 2142 | #endif |
2141 | 2143 | ||